列表
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。
基本操作：
索引
切片追加删除长度切片循环包含
创建、查看列表：
列表中的数字不要加引号，列表的索引从0开始：
list1 = ['physics', 'chemistry', 1997, 2000]; list2 = [1, 2, 3, 4, 5 ]; list3 = ["a", "b", "c", "d"]; len（）内置函数查看列表中元素的个数：
>>> shopping_list = ['Iphone', 'Mac', 'Bike','Coffee','Car','Clothes','Food','Gift']
>>> shopping_list ['Iphone', 'Mac', 'Bike', 'Coffee', 'Car', 'Clothes', 'Food', 'Gift']>>> len(shopping_list) 8>>> shopping_list[0] #取列表第一个元素
'Iphone'>>> shopping_list[-1] #取列表最后一个元素'Gift'>>> shopping_list[8] #超出列表索引范围，报错IndexError: list index out of range
切片：
格式： li[start : end : step]
start是切片起点索引，end是切片终点索引，但切片结果不包括终点索引的值。step是步长默认是1。
在step的符号一定的情况下，start和end可以混合使用正向和反向索引，无论怎样，你都要保证start和end之间有和step方向一致元素 间隔，否则会切出空列表
t=li[0:2]
t=li[0:-2]t=li[-4:-2]t=li[-4:2]上面的结果都是一样的；t为["A","B"]t=li[-1:-3:-1] t=li[-1:1:-1] t=li[3:1:-1] t=li[3:-3:-1] 上面的结果都是一样的；t为["D","C"]
t=li[-1:-3] t=li[-1:1] t=li[3:1] t=li[3:-3] 都切出空列
同时，step的正负决定了切片结果的元素采集的先后
省略start 和 end表示以原列表全部为目标 t=li[::-1] t--->["C","B","A"] #反向切，切出全部 t=li[:] t--->["A","B","C","D"] #正向切全部
从列表中取出指定多个元素，这种操作叫做切片，通过索引切片出来的元素，包括索引上边界位置的元素，但不包括下边界位置的元素（alex：虎头蛇尾 = =！）
>>> shopping_list
['Iphone', 'Mac', 'Bike', 'Coffee', 'Car', 'Clothes', 'Food', 'Gift']>>>>>> shopping_list[0:3] #取列表中1到第3个元素，不包括第4个['Iphone', 'Mac', 'Bike']>>> shopping_list[:3] #同上，取1到第3个元素，不包括第4个，0可以不写['Iphone', 'Mac', 'Bike']>>> shopping_list[2:5] #取第3至第5个元素['Bike', 'Coffee', 'Car']>>> shopping_list[:-3] #取从1至倒数第3个元素['Iphone', 'Mac', 'Bike', 'Coffee', 'Car']>>> shopping_list[-3:] #取最后3个元素['Clothes', 'Food', 'Gift']>>> shopping_list[1:8:2] #从1至8隔一个取一个，后面的2是步长，即每隔几个元素取一个['Mac', 'Coffee', 'Clothes', 'Gift']>>> shopping_list[::2] #从头到尾每隔一个取一个['Iphone', 'Bike', 'Car', 'Food']
增删改查：
>>> shopping_list
['Iphone', 'Mac', 'Bike', 'Coffee', 'Car', 'Clothes', 'Food', 'Gift']>>> shopping_list.append('MovieTicket') #向列表后面追加一个元素
>>> shopping_list['Iphone', 'Mac', 'Bike', 'Coffee', 'Car', 'Clothes', 'Food', 'Gift', 'MovieTicket']
列表删除元素----pop（index）; （指定删除，index不写默认删除最后一个元素）
对列表中的元素remove，pop，del删除的比较：
remove是指定元素删除（只能指定一个元素），pop指定索引删除（只能指定一个元素的索引），del删除多个元素
>>> shopping_list.pop() #删除最后一个元素'MovieTicket'>>> shopping_list.remove('Mac') #删除叫’Mac’的元素，如果有多个’Mac’,那会删除从左边数找到的第一个
>>> del shopping_list[3:8] #删除索引3至8的元素，不包括8
>>> shopping_list['Toy', 'Iphone', 'Gift', 'Bike', 'Banana', 'Apple']>>> shopping_list[2]'Coffee'>>> shopping_list[2] = 'COFFEE' #将索引为2的元素改为”COFFEE”，原来是小写 >>> shopping_list.insert(3,"Toy") #插入一个新元素，索引为3，指定的元素位置替换为插入的元素，原来的元素向后移动一位>>> shopping_list
['Iphone', 'Bike', 'COFFEE', 'Toy', 'Car', 'Clothes', 'Food', 'Gift']
列表中查找某个元素的索引----index：（只返回找到的第一个元素的索引，找到后立刻返回）
>>> shopping_list.index('Toy') #返回’Toy’元素的索引值，如果有多个相同元素，则返回匹配的第一个
3>>> shopping_list.append('Food')>>> shopping_list.count('Food') #统计’Food’的元素的个数，刚添加了一个，所以现在是2个2>>> shopping_list['Iphone', 'Bike', 'COFFEE', 'Toy', 'Car', 'Clothes', 'Food', 'Gift', 'Food']
列表追加、合并：extend
>>> list2= ['Banana','Apple'] #创建一个新列表>>> shopping_list.extend(list2) #把上面的新列表合并到shopping_list中>>> shopping_list['Iphone', 'Bike', 'COFFEE', 'Toy', 'Car', 'Clothes', 'Food', 'Gift', 'Food', 'Banana','Apple'] >>> shopping_list.sort() #将列表排序（2.0按照ASCII码排序，3.0数字和字符串无法放在一起排序，会报错）>>> shopping_list['Apple', 'Banana', 'Bike', 'COFFEE', 'Car', 'Clothes', 'Food', 'Food', 'Gift', 'Iphone','Toy'] >>> shopping_list.reverse() #将列表反转>>> shopping_list['Toy', 'Iphone', 'Gift', 'Food', 'Food', 'Clothes', 'Car', 'COFFEE', 'Bike', 'Banana','Apple'] >>> for i in shopping_list: #遍历列表... print i应用： 判断列表中是否存在一个元素: name = ['alex','peter','Jobs',111112,'joy',9,'oppo','apple',7777,'MBP',3333324234,'qqqqq','666']
if 9 in name: num_of_ele = name.count(9) pos_of_ele = name.index(9) print('%s num of 9 in name,pos: %s' % (num_of_ele,pos_of_ele)) 结果： 1 num of 9 in name,pos: 5 通过变量和索引更改某个元素的值：
name = ['alex','peter','Jobs',111112,'joy',9,'oppo','apple',9777,'MBP',3333324234,'qqqqq','666'] if 9 in name: num_of_ele = name.count(9) pos_of_ele = name.index(9) name[pos_of_ele] = 999 print (name) 结果： ['alex', 'peter', 'Jobs', 111112, 'joy', 999, 'oppo', 'apple', 9777, 'MBP', 3333324234, 'qqqqq', '666']
一次更改列表中所有的9：（列表中的数字必须没有引号，否则出错）
name = ['alex','peter','Jobs',111112,'joy',9,'oppo','apple',9,'MBP',3333324234,'qqqqq','666'] for i in range(name.count(9)): ele_index = name.index(9) name[ele_index] = 9999998999 print (name)
结果： ['alex', 'peter', 'Jobs', 111112, 'joy', 9999998999, 'oppo', 'apple', 9999998999, 'MBP', 3333324234, 'qqqqq', '666']
列表copy: name = ['alex','peter','Jobs',111112,'joy',9,'oppo','apple',9,'MBP',3333324234,'qqqqq','666']
name2 = name.copy() print (name) print (name2)
输出：
['alex', 'peter', 'Jobs', 111112, 'joy', 9, 'oppo', 'apple', 9, 'MBP', 3333324234, 'qqqqq', '666']
['alex', 'peter', 'Jobs', 111112, 'joy', 9, 'oppo', 'apple', 9, 'MBP', 3333324234, 'qqqqq', '666']
列表嵌套：
更改嵌套列表中的元素： name = ['alex','peter','Jobs',['WTF','haha',211,985],111112,'joy',9,'oppo','apple',9,'MBP',3333324234,'qqqqq','666'] name[3][1] = 'NBA_player' print (name) 输出： ['alex', 'peter', 'Jobs', ['WTF', 'NBA_player', 211, 985], 111112, 'joy', 9, 'oppo', 'apple', 9, 'MBP', 3333324234, 'qqqqq', '666']
注意：
copy方法只copy列表的第一层，嵌套的列表非copy而是共享（原因在于第二层的列表可能非常大，浪费内存），或者理解为：copy对于嵌套的列表只是copy了列表指向的内存地址
name = ['alex','peter','Jobs',['WTF','haha',211,985],111112,'joy',9,'oppo','apple',9,'MBP',3333324234,'qqqqq','666']
name2 = name.copy() name[3][1] = 'NBA_player' print (name) print (name2)
输出：
['alex', 'peter', 'Jobs', ['WTF', 'NBA_player', 211, 985], 111112, 'joy', 9, 'oppo', 'apple', 9, 'MBP', 3333324234, 'qqqqq', '666']
['alex', 'peter', 'Jobs', ['WTF', 'NBA_player', 211, 985], 111112, 'joy', 9, 'oppo', 'apple', 9, 'MBP', 3333324234, 'qqqqq', '666'] 完全copy------deepcopy（此方法相当于克隆一份，copy相当于软连接），要导入copy模块
import copy name = ['alex','peter','Jobs',['WTF','haha',211,985],111112,'joy',9,'oppo','apple',9,'MBP',3333324234,'qqqqq','666'] name2 = name.copy() name3 = copy.deepcopy(name) name[3][1] = 'NBA_player' print (name) print (name2) print (name3) 输出： ['alex', 'peter', 'Jobs', ['WTF', 'NBA_player', 211, 985], 111112, 'joy', 9, 'oppo', 'apple', 9, 'MBP', 3333324234, 'qqqqq', '666'] ['alex', 'peter', 'Jobs', ['WTF', 'NBA_player', 211, 985], 111112, 'joy', 9, 'oppo', 'apple', 9, 'MBP', 3333324234, 'qqqqq', '666'] ['alex', 'peter', 'Jobs', ['WTF', 'haha', 211, 985], 111112, 'joy', 9, 'oppo', 'apple', 9, 'MBP', 3333324234, 'qqqqq', '666'] #可以看出deepcopy之后的嵌套列表的元素并未改变 深浅拷贝：
1 # 1、数字和字符串 2 # 对于 数字 和 字符串 而言，赋值、浅拷贝和深拷贝无意义,都是同一id，因为其永远指向同一个内存地址。 3 4 import copy 5 6 n1 = 123 7 n2 = n1 8 n3 = copy.copy(n1) 9 n4 = copy.deepcopy(n1)10 print(id(n1))11 print(id(n2))12 print(id(n3))13 print(id(n4))14 15 # 输出结果都相同16 17 18 # 2、其他基本数据类型19 # 对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。20 # 赋值，只是创建一个变量，该变量指向原来内存地址21 22 23 # 深拷贝全部拷贝除了最后一层的数字和字符串（python的优化机制，最后一层的值只拷贝索引），浅拷贝只拷贝最外层24 import copy25 26 n1 = { "k1": "wu", "k2": 123, "k3": ["alex", 456]}27 n2 = copy.copy(n1)28 n3 = copy.deepcopy(n1)29 print(id(n1['k1']), id(n2), id(n3['k1'])) # 此处n1['k1']的id和n3['k1']的id是相同的，n1['k3']的id和n3['k3']的id是不同的，浅拷贝只拷贝最外层30 print(id(n1['k3']), id(n2), id(n3['k3'])) # 此处n1['k3']的id和n3['k3']的id是不同的，下一层是列表，而非数字和字符串
课堂练习： 列表：name = ['alex', 'peter', 'Jobs', [9, 4, 3, 5], 11, 34, 'joy', 9, 34, 'oppo', 'MBP', 3333324234, 'qqqqq', 3, 65, 3]
1、找出有多少个9，并改为999 2、同时找出所有34，并删除
num = name.count(34) for i in range(num): indexof34 = name.index(34) del name[indexof34] print(name)
元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建只需要在括号中添加元素，并使用逗号隔开即可。
如下实例：
tup1 = ('physics', 'chemistry', 1997, 2000); tup2 = (1, 2, 3, 4, 5 ); tup3 = "a", "b", "c", "d"; 创建空元组
tup1 = ();
元组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (50,);
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
字符串
字符串是 %s;整数 %d;浮点数%f
字符串常用功能：
- 移除空白
- 分割
- 长度
- 索引
- 切片
应用：
字符串格式化输出
name = "alex"
print "i am %s " % name
#输出: i am alex字符串------strip（脱去空格、tab ，常用）
name = input('username:') if name.strip() == 'sky': print('ok') 如果输入时后面多了空格，strip会脱去空格，结果打印ok 字符串-------split 拆开字符串：（拆开后相当于列表）]
name = 'WTF,NBA,SOS,ISIS'
name2 = name.split(',') print(name2) name3 = [1,2,3] name4 = name2 + name3 print(name4) 输出：
['WTF', 'NBA', 'SOS', 'ISIS']
['WTF', 'NBA', 'SOS', 'ISIS', 1, 2, 3]
字符串-------join方法：
name = 'WTF,NBA,SOS,ISIS' name2 = '-' print(name2.join(name))
输出：W-T-F-,-N-B-A-,-S-O-S-,-I-S-I-S
str = "-"; seq = ("a", "b", "c"); # 字符串序列 print str.join( seq ); 以上实例输出结果如下：
a-b-c
字符串--------format
msg = ''' hello, {name}, how are you, {time} ''' msg2 = msg.format(name='SKY', time=666) print(msg2) 输出：hello, SKY, how are you, 666 msg = 'hello, {name}, how are you, {time}' msg2 = msg.format(name='SKY', time=666) print(msg2) 输出：hello, SKY, how are you, 666
msg = 'hello, {name}, how are you, {time}' msg2 = 'hahah{0},dddd{1}' print(msg2.format('sky',25)) 输出 hahahsky,dddd25 字符串切片：（同列表切片）
msg = 'hello, {name}, how are you, {time}' print(msg[0:3]) 输出 hel 字符串-------center
msg = 'hello, {name}, how are you, {time}' print(msg.center(50, '-')) 输出 --------hello, {name}, how are you, {time}-------- 字符串------find
msg = 'hello, {name}, how are you, {time}' print(msg.find('o')) print(msg.find('#')) 输出：结果为元素所在的索引序号，找不到的字符，返回-1
4
-1 判断输入的是字符串还是数字------------isdigit
age = input('your age: ') if age.isdigit(): print(age) else: print('invalid ') 输出：只要输入有一个字符，就输出invalid
判断输入有无特殊字符--------isalnum 有-》false 没有--》true，如果包含特殊字符：包括空格等等返回false：
names = '11ppqwe -' names2 = '11ppqwe' print(names.isalnum()) print(names2.isalnum()) 输出：
False
True 判断以什么字符结尾：endwith，开始startwith
names = 'alex is good teacher' print(names.endswith('er')) print(names.startswith('er')) 输出：
True
False 把字符串都变为大写、都变为小写：upper 、 lower
names = 'alex is good teacher'
a = names.upper() l = names.lower() print(names.upper()) print(l)
ALEX IS GOOD TEACHER
alex is good teacher字符串replace方法：
f = open('yesterday', 'r', encoding='utf-8') f_new = open('yesterday.bak', 'w', encoding='utf-8') for line in f: if '有那么多肆意的快乐等我享受' in line: #f_new.write('有那么多肆意的快乐等whitesky享受') line = line.replace('有那么多肆意的快乐等我享受', '有那么多肆意的快乐等whitesky享受') f_new.write(line) else: f_new.write(line) 数据运算：
假设变量a为10，变量b为20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 30 |
| - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -10 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
| / | 除 - x除以y | b / a 输出结果 2 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 0 |
| ** | 幂 - 返回x的y次幂 | a**b 为10的20次方， 输出结果 100000000000000000000 |
| // | 取整除 - 返回商的整数部分 | 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
| <> | 不等于 - 比较两个对象是否不相等 | (a <> b) 返回 true。这个运算符类似 != 。 |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。注意，这些变量名的大写。 | (a < b) 返回 true。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 true。 |
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
下表中变量 a 为 60，b 为 13，二进制格式如下：
a = 0011 1100 b = 0000 1101 ----------------- a&b = 0000 1100 a|b = 0011 1101 a^b = 0011 0001 ~a = 1100 0011
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。 | (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False |
Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
身份运算符用于比较两个对象的存储单元
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is是判断两个标识符是不是引用自一个对象 | x is y, 如果 id(x) 等于 id(y) , is 返回结果 1 |
| is not | is not是判断两个标识符是不是引用自不同对象 | x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1 |
以下表格列出了从最高到最低优先级的所有运算符：
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not or and | 逻辑运算符 |
注意：
左移右移：（比除法的效率高），直接进行二进制移位
While循环语句
while 判断条件： 执行语句……
执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。当判断条件假false时，循环结束。
while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环，此外"判断条件"还可以是个常值，表示循环必定成立，具体用法如下：
# continue 和 break 用法i = 1 while i < 10: i += 1 if i%2 > 0: # 非双数时跳过输出 continue print i # 输出双数2、4、6、8、10 i = 1 while 1: # 循环条件为1必定成立 print i # 输出1~10 i += 1 if i > 10: # 当i大于10时跳出循环 break
如果条件判断语句永远为 true，循环将会无限的执行下去
循环使用 else 语句
在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
#!/usr/bin/pythoncount = 0 while count < 5: print count, " is less than 5" count = count + 1 else: print count, " is not less than 5"
以上实例输出结果为：
0 is less than 5 1 is less than 5 2 is less than 5 3 is less than 5 4 is less than 5 5 is not less than 5
字典：
字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中. 键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。 
View Code
一个简单的字典实例：
dict = { 'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'} info = { 'stu001': 'xiaoming', 'stu002': 'wahaha', 'stu003': '3pao', } print(info) print(info['stu001']) 输出：
{'stu002': 'wahaha', 'stu003': '3pao', 'stu001': 'xiaoming'}
xiaoming注意：字典是无序的，没有下标，也不需要下标，它有key值！（列表有下标），所以print结果是无序的
字典的方法：
1 class dict(object): 2 """ 3 dict() -> new empty dictionary 4 dict(mapping) -> new dictionary initialized from a mapping object's 5 (key, value) pairs 6 dict(iterable) -> new dictionary initialized as if via: 7 d = {} 8 for k, v in iterable: 9 d[k] = v 10 dict(**kwargs) -> new dictionary initialized with the name=value pairs 11 in the keyword argument list. For example: dict(one=1, two=2) 12 """ 13 14 def clear(self): # real signature unknown; restored from __doc__ 15 """ 清除内容 """ 16 """ D.clear() -> None. Remove all items from D. """ 17 pass 18 19 def copy(self): # real signature unknown; restored from __doc__ 20 """ 浅拷贝 """ 21 """ D.copy() -> a shallow copy of D """ 22 pass 23 24 @staticmethod # known case 25 def fromkeys(S, v=None): # real signature unknown; restored from __doc__ 26 """ 27 dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v. 28 v defaults to None. 29 """ 30 pass 31 32 def get(self, k, d=None): # real signature unknown; restored from __doc__ 33 """ 根据key获取值，d是默认值 """ 34 """ D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """ 35 pass 36 37 def has_key(self, k): # real signature unknown; restored from __doc__ 38 """ 是否有key """ 39 """ D.has_key(k) -> True if D has a key k, else False """ 40 return False 41 42 def items(self): # real signature unknown; restored from __doc__ 43 """ 所有项的列表形式 """ 44 """ D.items() -> list of D's (key, value) pairs, as 2-tuples """ 45 return [] 46 47 def iteritems(self): # real signature unknown; restored from __doc__ 48 """ 项可迭代 """ 49 """ D.iteritems() -> an iterator over the (key, value) items of D """ 50 pass 51 52 def iterkeys(self): # real signature unknown; restored from __doc__ 53 """ key可迭代 """ 54 """ D.iterkeys() -> an iterator over the keys of D """ 55 pass 56 57 def itervalues(self): # real signature unknown; restored from __doc__ 58 """ value可迭代 """ 59 """ D.itervalues() -> an iterator over the values of D """ 60 pass 61 62 def keys(self): # real signature unknown; restored from __doc__ 63 """ 所有的key列表 """ 64 """ D.keys() -> list of D's keys """ 65 return [] 66 67 def pop(self, k, d=None): # real signature unknown; restored from __doc__ 68 """ 获取并在字典中移除 """ 69 """ 70 D.pop(k[,d]) -> v, remove specified key and return the corresponding value. 71 If key is not found, d is returned if given, otherwise KeyError is raised 72 """ 73 pass 74 75 def popitem(self): # real signature unknown; restored from __doc__ 76 """ 获取并在字典中移除 """ 77 """ 78 D.popitem() -> (k, v), remove and return some (key, value) pair as a 79 2-tuple; but raise KeyError if D is empty. 80 """ 81 pass 82 83 def setdefault(self, k, d=None): # real signature unknown; restored from __doc__ 84 """ 如果key不存在，则创建，如果存在，则返回已存在的值且不修改 """ 85 """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """ 86 pass 87 88 def update(self, E=None, **F): # known special case of dict.update 89 """ 更新 90 {'name':'alex', 'age': 18000} 91 [('name','sbsbsb'),] 92 """ 93 """ 94 D.update([E, ]**F) -> None. Update D from dict/iterable E and F. 95 If E present and has a .keys() method, does: for k in E: D[k] = E[k] 96 If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v 97 In either case, this is followed by: for k in F: D[k] = F[k] 98 """ 99 pass100 101 def values(self): # real signature unknown; restored from __doc__102 """ 所有的值 """103 """ D.values() -> list of D's values """104 return []105 106 def viewitems(self): # real signature unknown; restored from __doc__107 """ 所有项，只是将内容保存至view对象中 """108 """ D.viewitems() -> a set-like object providing a view on D's items """109 pass110 111 def viewkeys(self): # real signature unknown; restored from __doc__112 """ D.viewkeys() -> a set-like object providing a view on D's keys """113 pass114 115 def viewvalues(self): # real signature unknown; restored from __doc__116 """ D.viewvalues() -> an object providing a view on D's values """117 pass118 119 def __cmp__(self, y): # real signature unknown; restored from __doc__120 """ x.__cmp__(y) <==> cmp(x,y) """121 pass122 123 def __contains__(self, k): # real signature unknown; restored from __doc__124 """ D.__contains__(k) -> True if D has a key k, else False """125 return False126 127 def __delitem__(self, y): # real signature unknown; restored from __doc__128 """ x.__delitem__(y) <==> del x[y] """129 pass130 131 def __eq__(self, y): # real signature unknown; restored from __doc__132 """ x.__eq__(y) <==> x==y """133 pass134 135 def __getattribute__(self, name): # real signature unknown; restored from __doc__136 """ x.__getattribute__('name') <==> x.name """137 pass138 139 def __getitem__(self, y): # real signature unknown; restored from __doc__140 """ x.__getitem__(y) <==> x[y] """141 pass142 143 def __ge__(self, y): # real signature unknown; restored from __doc__144 """ x.__ge__(y) <==> x>=y """145 pass146 147 def __gt__(self, y): # real signature unknown; restored from __doc__148 """ x.__gt__(y) <==> x>y """149 pass150 151 def __init__(self, seq=None, **kwargs): # known special case of dict.__init__152 """153 dict() -> new empty dictionary154 dict(mapping) -> new dictionary initialized from a mapping object's155 (key, value) pairs156 dict(iterable) -> new dictionary initialized as if via:157 d = {}158 for k, v in iterable:159 d[k] = v160 dict(**kwargs) -> new dictionary initialized with the name=value pairs161 in the keyword argument list. For example: dict(one=1, two=2)162 # (copied from class doc)163 """164 pass165 166 def __iter__(self): # real signature unknown; restored from __doc__167 """ x.__iter__() <==> iter(x) """168 pass169 170 def __len__(self): # real signature unknown; restored from __doc__171 """ x.__len__() <==> len(x) """172 pass173 174 def __le__(self, y): # real signature unknown; restored from __doc__175 """ x.__le__(y) <==> x<=y """176 pass177 178 def __lt__(self, y): # real signature unknown; restored from __doc__179 """ x.__lt__(y) <==> x a new object with type S, a subtype of T """185 pass186 187 def __ne__(self, y): # real signature unknown; restored from __doc__188 """ x.__ne__(y) <==> x!=y """189 pass190 191 def __repr__(self): # real signature unknown; restored from __doc__192 """ x.__repr__() <==> repr(x) """193 pass194 195 def __setitem__(self, i, y): # real signature unknown; restored from __doc__196 """ x.__setitem__(i, y) <==> x[i]=y """197 pass198 199 def __sizeof__(self): # real signature unknown; restored from __doc__200 """ D.__sizeof__() -> size of D in memory, in bytes """201 pass202 203 __hash__ = None204 205 dict
访问字典里的值
把相应的键放入熟悉的方括弧，如下实例:
#!/usr/bin/python dict = { 'Name': 'Zara', 'Age': 7, 'Class': 'First'}; print "dict['Name']: ", dict['Name']; print "dict['Age']: ", dict['Age']; 查找---------标准方法---get
info = { 'stu001': 'xiaoming', 'stu002': 'wahaha', 'stu003': '3pao', } print(info.get('stu001')) print(info.get('stu009')) 输出
xiaoming
None1 dic = { 'whisky': '333'}2 a = dic.get('alex', '2222222') # 如果字典中没有alex这个key，则设置缺省key的值为22222223 print(a)
非标准查找方法：
info["stu1105"] #如果一个key不存在，就报错，get不会，不存在只返回None
更改字典中的value：
info['stu001'] = 'white' print(info) 输出：
{'stu001': 'xiaoming', 'stu002': 'wahaha', 'stu003': '3pao'}
{'stu001': 'white', 'stu002': 'wahaha', 'stu003': '3pao'}
如果更改一个不存在的键值-----》就是添加key
info = { 'stu001': 'xiaoming', 'stu002': 'wahaha', 'stu003': '3pao', } print(info) info['stu007'] = 'white' print(info) 输出： {'stu001': 'xiaoming', 'stu002': 'wahaha', 'stu003': '3pao'}
{'stu001': 'xiaoming', 'stu007': 'white', 'stu002': 'wahaha', 'stu003': '3pao'}
删除字典中的key---------del、pop（popitem随机删，少用）
info = { 'stu001': 'xiaoming', 'stu002': 'wahaha', 'stu003': '3pao', } print(info) del info['stu001'] info.pop('stu003') print(info) 输出
{'stu001': 'xiaoming', 'stu002': 'wahaha', 'stu003': '3pao'}
{'stu002': 'wahaha'}
字典嵌套
menu = { '京东': { '家用电器': ['电视', '空调', '洗衣机', '冰箱', '热水器', '微波炉', '音响'] }, '天猫': { '电脑配件': ['显示器', 'CPU', '主板', '内存', '电源', '散热器', '显卡', '声卡'] }, '苏宁易购': { '海鲜水产': ['三文鱼', '元贝', '扇贝', '大闸蟹', '海参', '北极甜虾', '胖头鱼'] } } #改值,字典取元素用key，列表取元素用index，key尽量不要写中文，编码不一致时，取不出来 menu['京东']['家用电器'][0] = '投影仪' print(menu) 输出： {'天猫': {'电脑配件': ['显示器', 'CPU', '主板', '内存', '电源', '散热器', '显卡', '声卡']}, '苏宁易购': {'海鲜水产': ['三文鱼', '元贝', '扇贝', '大闸蟹', '海参', '北极甜虾', '胖头鱼']}, '京东': {'家用电器': ['投影仪', '空调', '洗衣机', '冰箱', '热水器', '微波炉', '音响']}} #字典其他常用方法： #打印所有的value，不包括key #print(menu.values()) #输出： #dict_values([{'家用电器': ['投影仪', '空调', '洗衣机', '冰箱', '热水器', '微波炉', '音响']}, {'电脑配件': ['显示器', 'CPU', '主板', '内存', '电源', '散热器', '显卡', '声卡']}, {'海鲜水产': ['三文鱼', '元贝', '扇贝', '大闸蟹', '海参', '北极甜虾', '胖头鱼']}]) #打印所有的key： #print(menu.keys()) #输出： #dict_keys(['京东', '天猫', '苏宁易购']) #setdefault,如果key存在，返回key的value，如果key不存在于字典中，将会添加key并将值设为default #menu.setdefault('天猫a', {'www.baidu.com': [1, 2]}) #print(menu) #输出： #{'京东': {'家用电器': ['投影仪', '空调', '洗衣机', '冰箱', '热水器', '微波炉', '音响']}, '天猫a': {'www.baidu.com': [1, 2]}, '天猫': {'电脑配件': ['显示器', 'CPU', '主板', '内存', '电源', '散热器', '显卡', '声卡']}, '苏宁易购': {'海鲜水产': ['三文鱼', '元贝', '扇贝', '大闸蟹', '海参', '北极甜虾', '胖头鱼']}} #update(dict2)把字典dict2的键/值对更新到dict里，作用合并两个字典，原来的key存在就覆盖，不存在就创建key #items(),把字典转换为列表 #print(menu.items()) #输出： #dict_items([('京东', {'家用电器': ['投影仪', '空调', '洗衣机', '冰箱', '热水器', '微波炉', '音响']}), ('天猫a', {'www.baidu.com': [1, 2]}), ('天猫', {'电脑配件': ['显示器', 'CPU', '主板', '内存', '电源', '散热器', '显卡', '声卡']}), ('苏宁易购', {'海鲜水产': ['三文鱼', '元贝', '扇贝', '大闸蟹', '海参', '北极甜虾', '胖头鱼']})]) #fromkeys()创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值,作用:初始化字典 #a = dict.fromkeys([1, 2, 3], 'test') #print(a) #输出： #{1: 'test', 2: 'test', 3: 'test'} #fromkeys的坑，举例： a = dict.fromkeys([1, 2, 3], [110, {'name': 'sky'}, 666]) print(a) a[1][1]['name'] = 'white' print(a) #输出： # {1: [110, {'name': 'sky'}, 666], 2: [110, {'name': 'sky'}, 666], 3: [110, {'name': 'sky'}, 666]} #{1: [110, {'name': 'white'}, 666], 2: [110, {'name': 'white'}, 666], 3: [110, {'name': 'white'}, 666]} #由输出可知，更改fromkeys初始化的字典中的一个key的value，其它key的value也全部被更改了，即所有的key共享value的内存地址，以后用fromkeys初始化字典时，除非只有一层，如果字典有多层，尽量不用
字典循环
menu = { 'stu001': 'clause', 'stu002': 'xiaoming', 'stu003': 'peter' } #打印key值： for i in menu: print(i) #输出 # stu002 #stu001 #stu003 #打印value： for i in menu: print(menu[i]) #输出： #xiaoming #clause #peter items的字典循环方式： menu = { 'stu001': 'clause', 'stu002': 'xiaoming', 'stu003': 'peter' } for i,j in menu.items(): print(i, j) #输出： #stu002 xiaoming #stu001 clause #stu003 peter 两种循环方法区别，第一种方法更高效，它是直接通过value取key，第二种是利用items 把字典变成列表，数据量大时，很耗时