序列（列表、元組、字符串）字典小題

一.已知：元組 a = (1,2,3) 利用list方法，輸出下面的結果：(1,2,4)

二. 已知：b = [9,5,36,25,4,1,2]

1.求出列表b的長度，最大值，最小值。

2.取值：取出25

3.切片：輸出[5,36,25]

4. 刪除：刪除列表中25這個數字

5.擴充：將列表c =[7,6,11]擴充到列表b中

6. 排序：對b列表進行從小到大的排序輸出，然后再反向使列表從大到小輸出

7. 插入：將26插入到列表中，

使得最后輸出結果為：b = [36, 26, 11, 9, 7, 6, 5, 4, 2, 1]

========================================================================

一、已知字典ainfo = {'name':'lily','age':20}

1.加入兩項使得輸出的結果：

ainfo = {'name':'lily','age':20,'gender':'female','class':8}

2.訪問字典中的所有項，訪問字典的鍵，訪問字典中的值

二、將這三項內容創建字典,按下面規則添加到同一個對象中:

(name = 'lily',age= '20,gender = 'female',class = 8) 

(name ='jack',age= 25,gender ='male',class =8)

(name ='jane',age= 19,gender ='female',class =8)

1.將這三項內容創建的三個字典放到一個列表里。

2.將這三項內容創建的三個字典放到一個字典里，要求字典以個人姓名為鍵，其他信息組成的字典為姓名這個鍵所對應的值。（字典里面嵌套字典）

例如info = {'lily'：{'age':20,'gender':'female','class':8}}

=================================華麗的分隔符=================================

>>> # 一.已知：元組 a = (1,2,3) 利用list方法，輸出下面的結果：(1,2,4)

>>> a = (1,2,3)

>>> a = list(a)  #給a 這個對象強制轉換為list數據類型，再給這個對象起個 a的名字。

>>> print a  #打印a這個對象

[1, 2, 3]

>>> #題目要求輸出結果為（1，2，3）分析知道結果對象為tuple類型，list()可以使用remove移除子串3或者pop方法出棧最后一個子串，然后使用append追加對象4.

>>> a.pop()

3

>>> a.append(4)

>>> print a  #打印a對象，我們會發現跟題目結果不一樣，我們這里還需要轉換一下tuple類型

[1, 2, 4]

>>> a = tuple(a)  #給a 這個對象強制轉換為tuple數據類型，再給這個對象起個 a的名字。

>>> print a #我們再來看結果

(1, 2, 4)

>>> #remove方法類型，唯一區別是remove()傳參為子串對象，而pop()傳參為index。

>>> 

>>> #二. 已知：b = [9,5,36,25,4,1,2]

>>> b = [9,5,36,25,4,1,2]

>>> #求出列表b的長度，最大值，最小值。

>>> len(b)  #長度

7

>>> max(b)  #最大值 max方法是使用iterable迭代b對象的參數，返回其最大的item。或者使用兩個或兩個以上的實參，返回最大的實參。

36

>>> min(b)  #最小值 min()方法和max()一樣都是使用iterable迭代b對象的實際參數（argument），返回其最小的item。或者使用兩個或兩個以上的實參（argument）,返回最小的實參（argument）。

1

>>> #max() min() 方法返回的為value。

>>> #2.取值：取出25

>>> b[3]  #此題可以使用索引，正向索引或者反向索引

25

>>> b[-4] #反向索引

25

>>> #3.切片：輸出[5,36,25]

>>> b[1:4] #index切片，切片分為正向索引切片和反向索引切片。

[5, 36, 25]

>>> b[-6:-3]  #反向索引切片，切片格式為[start:end:step]不寫step,默認為1。

[5, 36, 25]

>>> #4. 刪除：刪除列表中25這個數字

>>> b.remove(25)  #操作方法L.remove(value) ,刪除第一次出現的值(value),如果發現L.remove(value) value == vlaue,就是值不存在，則報錯 ValueError:  錯誤。我查看了幫助 告訴我“Raises ValueError if the value is not present.” Raises百度翻譯的結果是舉起提起。不明白這里為什么不是return返回。

>>> print b  #打印 b 對象。

[9, 5, 36, 4, 1, 2]

>>> #5.擴充：將列表c =[7,6,11]擴充到列表b中

>>> c =[7,6,11]

>>> b.extend(c)  #L.extend(iterable),通過iterable迭代器追加到b對象的擴展列表。

>>> print b  #打印b對象的結果。

[9, 5, 36, 4, 1, 2, 7, 6, 11]

>>> #我們發現[7,6,11]是按照順序擴展到尾部。這正是通過iterable迭代添加到 b 對象。

>>> #6. 排序：對b列表進行從小到大的排序輸出，然后再反向使列表從大到小輸出

>>> #考慮了一個python提供了兩種排序方式列表方法的成員sort,內置函數sorted

>>> #sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list 從幫組中了解到sorted提供了一個迭代器，cmp(compare)是比較函數，比較什么由key決定,有默認值，迭代集合中的一項;

>>> #key：用列表元素的某個屬性和函數進行作為關鍵字，有默認值，迭代集合中的一項;

>>> #reverse：排序規則. reverse = True 或者 reverse = False，有默認值。

>>> #返回值：是一個經過排序的可迭代類型，與iterable一樣。

>>> #我們看到sorted返回值為new sorted list ，一個新產生的列表。

>>> #sort方法：L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;

>>> #cmp(x, y) -> -1, 0, 1

>>> #關于cmp比較函數，我還了解的比較淺，根據百度得到的知識記錄下來：

>>> #可以認為是compare（比較）的意思。在進行比較的時候將個數做減法運算，這個運算是影響符號位的，（大數減小數，符號位為+，反則為-）所以執行該指令后你可以通過查詢符號位CF是0還是1就可以知道兩個數那個大了。根據匯編知識里了解到，不知python是否適用，以后精通后，有能力再回頭看看源碼。這里知識表示看不懂！！！了解怎么用是現在的目標。

>>> b.sort(b)

Traceback (most recent call last):

  File "<pyshell#292>", line 1, in <module>

    b.sort(b)

TypeError: 'list' object is not callable

>>> #b.sort()  #唉，上面傳了錯誤的參數返回報錯，默認參數help里可以看到。

>>> b.sort()

>>> print b  #打印 對象 b

[1, 2, 4, 5, 6, 7, 9, 11, 36]

>>> #為了模擬sorted,剛好之前無意學了一點random函數，使用random打亂b對象列表里值的順序。

>>> #查看幫助，告訴我們shuffle屬性 將list 列表 x in place;應該是一個for循環重新隨機放置遍歷到的值，return None。下面我們使用一下。

>>> #shuffle(self, x, random=None) 再解釋一下這個方法self調用自己這個函數，x 是傳參的list的名字。random=None,默認參數。

>>> random.shuffle(b)

Traceback (most recent call last):

  File "<pyshell#299>", line 1, in <module>

    random.shuffle(b)

NameError: name 'random' is not defined

>>> import random  #悲劇了，他告訴我們random沒有定義，我們import 導入一下。

>>> random.shuffle(b) #將b這個對象傳入到參數。

>>> print b  #打印對象b 查看結果

[5, 36, 2, 7, 11, 9, 4, 1, 6]

>>> sorted(b) #sorted進行重新排序

[1, 2, 4, 5, 6, 7, 9, 11, 36]

>>> #注意啊！我們使用了sorted他是有返回值的。那么說說它與sort的區別吧。

>>> #sorted是python內置函數，注意觀察顏色，sort是list的成員方法。sorted是生成一個新的列表，而sort是對元素列表原位排序，這個方法改變列表，而不是返回排序后的列表，所有我們使用sort()方法后，它沒有返回。而sorted則返回了值。

>>> #7. 插入：將26插入到列表中，使得最后輸出結果為：b = [36, 26, 11, 9, 7, 6, 5, 4, 2, 1]

>>> #少了一個方向排序，reverse

>>> b.reverse()  #L.reverse() -- reverse *IN PLACE* 循環反向放置

>>> print b  #打印 對象 b 查看結果。

[6, 1, 4, 9, 11, 7, 2, 36, 5]

>>> b.sort()

>>> b

[1, 2, 4, 5, 6, 7, 9, 11, 36]

>>> b.reverse()

>>> b

[36, 11, 9, 7, 6, 5, 4, 2, 1]

>>> print b

[36, 11, 9, 7, 6, 5, 4, 2, 1]

>>> 

>>> #7. 插入：將26插入到列表中，使得最后輸出結果為：b = [36, 26, 11, 9, 7, 6, 5, 4, 2, 1]

>>> b.insert(1，26)  #L.insert(index, object) -- insert object before index，insert方法前面為要插入對象index的前面。

SyntaxError: invalid syntax

>>> b

[36, 11, 9, 7, 6, 5, 4, 2, 1]

>>> b.insert(1,26)

>>> #前面報錯，仔細發現是逗號使用中文半角了。

>>> 

>>> 

>>> #==================華麗的分隔符===========================

>>> #一、已知字典ainfo = {'name':'lily','age':20}

>>> #1.加入兩項使得輸出的結果：ainfo = {'name':'lily','age':20,'gender':'female','class':8}

>>> ainfo = {'name':'lily','age':20}

>>> ainfo['gender'] = 'female'; ainfo['class'] = 8

>>> ainfo #查看結果

{'gender': 'female', 'age': 20, 'name': 'lily', 'class': 8}

>>> #字典集合無序，元組字符串序列有序

>>> #2.訪問字典中的所有項，訪問字典的鍵，訪問字典中的值

>>> ainfo.items()  #字典的項格式為鍵值對的元組的列表

[('gender', 'female'), ('age', 20), ('name', 'lily'), ('class', 8)]

>>> ainfo.keys()  #字典keys的列表

['gender', 'age', 'name', 'class']

>>> ainfo.values()  #字典中的值 values列表

['female', 20, 'lily', 8]

>>> #二、將這三項內容創建字典,按下面規則添加到同一個對象中:

>>> #(name = 'lily',age= '20,gender = 'female',class = 8)

>>> #(name ='jack',age= 25,gender ='male',class =8)

>>> #(name ='jane',age= 19,gender ='female',class =8)

>>> #1.將這三項內容創建的三個字典放到一個列表里。

>>> binfo = {name:'jack',age:25,gender:'male','class':8}

Traceback (most recent call last):

  File "<pyshell#339>", line 1, in <module>

    binfo = {name:'jack',age:25,gender:'male','class':8}

NameError: name 'name' is not defined

>>> binfo = {'name':'jack','age':25,'gender':'male','class':8}

>>> cinfo = {'name' ='jane','age'= 19,'gender' ='female','class' =8}

SyntaxError: invalid syntax

>>> cinfo : {'name':'jane','age':19,'gender':'female','class':8}

SyntaxError: invalid syntax

>>> cinfo = {'name':'jane','age':19,'gender':'female','class':8}

>>> #分析，根據所學的知識，D.items()方法返回值為列表格式元組鍵值對，然后將結果對象起個名字，再將對象使用list.extend()方法擴展。

>>> a = ainfo.items()

>>> b = binfo.items()

>>> c = cinfo.items()

>>> print a  #打印結果

[('gender', 'female'), ('age', 20), ('name', 'lily'), ('class', 8)]

>>> print b

[('gender', 'male'), ('age', 25), ('name', 'jack'), ('class', 8)]

>>> print c

[('gender', 'female'), ('age', 19), ('name', 'jane'), ('class', 8)]

>>> a.extend(b)

>>> a.extend(c)

>>> print a  #查看最后的結果就是題目要求的三個字典放在一個列表里了。

[('gender', 'female'), ('age', 20), ('name', 'lily'), ('class', 8), ('gender', 'male'), ('age', 25), ('name', 'jack'), ('class', 8), ('gender', 'female'), ('age', 19), ('name', 'jane'), ('class', 8)]

>>> #2.將這三項內容創建的三個字典放到一個字典里，要求字典以個人姓名為鍵，其他信息組成的字典為姓名這個鍵所對應的值。（字典里面嵌套字典）

>>> #例如info = {'lily'：{'age':20,'gender':'female','class':8}}

>>> ainfo={'name': 'lily','age':20,'gender':'female','class':8}  #創建字典ainfo

>>> binfo={'name':'jack','age':25,'gender':'male','class':8}  #創建字典binfo

>>> cinfo={'name':'jane','age':19,'gender':'female','class':8}  #創建字典cinfo

>>> dic={}  #初始化一個字典dic

>>> dic[ainfo.pop('name')]=ainfo  #添加一個新值（value）ainfo,key 為ainfo.pop('name')的對象。

>>> dic[binfo.pop('name')]=binfo  #添加一個新值（value）binfo,key 為binfo.pop('name')的對象。

>>> dic[cinfo.pop('name')]=cinfo  #添加一個新值（value）cinfo,key 為cinfo.pop('name')的對象。

>>> print dic  #打印dic字典看結果。

{'jane': {'gender': 'female', 'age': 19, 'class': 8}, 'lily': {'gender': 'female', 'age': 20, 'class': 8}, 'jack': {'gender': 'male', 'age': 25, 'class': 8}}

>>>