第二天----列表、深浅拷贝、元组、字符串、算数运算、字典、while

列表

列表是最常用的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 copy
25 
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/python

count = 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)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中.




 键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

一个简单的字典实例：


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         pass
100 
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         pass
110 
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         pass
114 
115     def viewvalues(self): # real signature unknown; restored from __doc__
116         """ D.viewvalues() -> an object providing a view on D's values """
117         pass
118 
119     def __cmp__(self, y): # real signature unknown; restored from __doc__
120         """ x.__cmp__(y) <==> cmp(x,y) """
121         pass
122 
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 False
126 
127     def __delitem__(self, y): # real signature unknown; restored from __doc__
128         """ x.__delitem__(y) <==> del x[y] """
129         pass
130 
131     def __eq__(self, y): # real signature unknown; restored from __doc__
132         """ x.__eq__(y) <==> x==y """
133         pass
134 
135     def __getattribute__(self, name): # real signature unknown; restored from __doc__
136         """ x.__getattribute__('name') <==> x.name """
137         pass
138 
139     def __getitem__(self, y): # real signature unknown; restored from __doc__
140         """ x.__getitem__(y) <==> x[y] """
141         pass
142 
143     def __ge__(self, y): # real signature unknown; restored from __doc__
144         """ x.__ge__(y) <==> x>=y """
145         pass
146 
147     def __gt__(self, y): # real signature unknown; restored from __doc__
148         """ x.__gt__(y) <==> x>y """
149         pass
150 
151     def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
152         """
153         dict() -> new empty dictionary
154         dict(mapping) -> new dictionary initialized from a mapping object's
155             (key, value) pairs
156         dict(iterable) -> new dictionary initialized as if via:
157             d = {}
158             for k, v in iterable:
159                 d[k] = v
160         dict(**kwargs) -> new dictionary initialized with the name=value pairs
161             in the keyword argument list.  For example:  dict(one=1, two=2)
162         # (copied from class doc)
163         """
164         pass
165 
166     def __iter__(self): # real signature unknown; restored from __doc__
167         """ x.__iter__() <==> iter(x) """
168         pass
169 
170     def __len__(self): # real signature unknown; restored from __doc__
171         """ x.__len__() <==> len(x) """
172         pass
173 
174     def __le__(self, y): # real signature unknown; restored from __doc__
175         """ x.__le__(y) <==> x<=y """
176         pass
177 
178     def __lt__(self, y): # real signature unknown; restored from __doc__
179         """ x.__lt__(y) <==> x<y """
180         pass
181 
182     @staticmethod # known case of __new__
183     def __new__(S, *more): # real signature unknown; restored from __doc__
184         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
185         pass
186 
187     def __ne__(self, y): # real signature unknown; restored from __doc__
188         """ x.__ne__(y) <==> x!=y """
189         pass
190 
191     def __repr__(self): # real signature unknown; restored from __doc__
192         """ x.__repr__() <==> repr(x) """
193         pass
194 
195     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
196         """ x.__setitem__(i, y) <==> x[i]=y """
197         pass
198 
199     def __sizeof__(self): # real signature unknown; restored from __doc__
200         """ D.__sizeof__() -> size of D in memory, in bytes """
201         pass
202 
203     __hash__ = None
204 
205 dict



View Code


 


访问字典里的值


把相应的键放入熟悉的方括弧，如下实例:


#!/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
None




1 dic = {'whisky': '333'}
2 a = dic.get('alex', '2222222')      # 如果字典中没有alex这个key，则设置缺省key的值为2222222
3 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 把字典变成列表，数据量大时，很耗时


 








		

		
posted @ 
2016-11-15 15:17 
whitesky-root 
阅读(449) 
评论(0) 
编辑 
收藏 
举报