第二天----列表、元组、字符串、算数运算、字典、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、数字和字符串
 #   对于 数字 和 字符串 而言，赋值、浅拷贝和深拷贝无意义,都是同一id，因为其永远指向同一个内存地址。

 import copy

 n1 = 123
 n2 = n1
 n3 = copy.copy(n1)
 n4 = copy.deepcopy(n1)
 print(id(n1))
 print(id(n2))
 print(id(n3))
 print(id(n4))

 # 输出结果都相同

 # 2、其他基本数据类型
 # 对于字典、元祖、列表 而言，进行赋值、浅拷贝和深拷贝时，其内存地址的变化是不同的。
 # 赋值，只是创建一个变量，该变量指向原来内存地址

 # 深拷贝全部拷贝除了最后一层的数字和字符串（python的优化机制，最后一层的值只拷贝索引），浅拷贝只拷贝最外层
 import copy

 n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
 n2 = copy.copy(n1)
 n3 = copy.deepcopy(n1)
 print(id(n1['k1']), id(n2), id(n3['k1']))   # 此处n1['k1']的id和n3['k1']的id是相同的，n1['k3']的id和n3['k3']的id是不同的，浅拷贝只拷贝最外层
 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结果是无序的

字典的方法：

 class dict(object):
     """
     dict() -> new empty dictionary
     dict(mapping) -> new dictionary initialized from a mapping object's
         (key, value) pairs
     dict(iterable) -> new dictionary initialized as if via:
         d = {}
         for k, v in iterable:
             d[k] = v
     dict(**kwargs) -> new dictionary initialized with the name=value pairs
         in the keyword argument list.  For example:  dict(one=1, two=2)
     """

     def clear(self): # real signature unknown; restored from __doc__
         """ 清除内容 """
         """ D.clear() -> None.  Remove all items from D. """
         pass

     def copy(self): # real signature unknown; restored from __doc__
         """ 浅拷贝 """
         """ D.copy() -> a shallow copy of D """
         pass

     @staticmethod # known case
     def fromkeys(S, v=None): # real signature unknown; restored from __doc__
         """
         dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
         v defaults to None.
         """
         pass

     def get(self, k, d=None): # real signature unknown; restored from __doc__
         """ 根据key获取值，d是默认值 """
         """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
         pass

     def has_key(self, k): # real signature unknown; restored from __doc__
         """ 是否有key """
         """ D.has_key(k) -> True if D has a key k, else False """
         return False

     def items(self): # real signature unknown; restored from __doc__
         """ 所有项的列表形式 """
         """ D.items() -> list of D's (key, value) pairs, as 2-tuples """
         return []

     def iteritems(self): # real signature unknown; restored from __doc__
         """ 项可迭代 """
         """ D.iteritems() -> an iterator over the (key, value) items of D """
         pass

     def iterkeys(self): # real signature unknown; restored from __doc__
         """ key可迭代 """
         """ D.iterkeys() -> an iterator over the keys of D """
         pass

     def itervalues(self): # real signature unknown; restored from __doc__
         """ value可迭代 """
         """ D.itervalues() -> an iterator over the values of D """
         pass

     def keys(self): # real signature unknown; restored from __doc__
         """ 所有的key列表 """
         """ D.keys() -> list of D's keys """
         return []

     def pop(self, k, d=None): # real signature unknown; restored from __doc__
         """ 获取并在字典中移除 """
         """
         D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
         If key is not found, d is returned if given, otherwise KeyError is raised
         """
         pass

     def popitem(self): # real signature unknown; restored from __doc__
         """ 获取并在字典中移除 """
         """
         D.popitem() -> (k, v), remove and return some (key, value) pair as a
         2-tuple; but raise KeyError if D is empty.
         """
         pass

     def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
         """ 如果key不存在，则创建，如果存在，则返回已存在的值且不修改 """
         """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
         pass

     def update(self, E=None, **F): # known special case of dict.update
         """ 更新
             {'name':'alex', 'age': 18000}
             [('name','sbsbsb'),]
         """
         """
         D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
         If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
         If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
         In either case, this is followed by: for k in F: D[k] = F[k]
         """
         pass

     def values(self): # real signature unknown; restored from __doc__
         """ 所有的值 """
         """ D.values() -> list of D's values """
         return []

     def viewitems(self): # real signature unknown; restored from __doc__
         """ 所有项，只是将内容保存至view对象中 """
         """ D.viewitems() -> a set-like object providing a view on D's items """
         pass

     def viewkeys(self): # real signature unknown; restored from __doc__
         """ D.viewkeys() -> a set-like object providing a view on D's keys """
         pass

     def viewvalues(self): # real signature unknown; restored from __doc__
         """ D.viewvalues() -> an object providing a view on D's values """
         pass

     def __cmp__(self, y): # real signature unknown; restored from __doc__
         """ x.__cmp__(y) <==> cmp(x,y) """
         pass

     def __contains__(self, k): # real signature unknown; restored from __doc__
         """ D.__contains__(k) -> True if D has a key k, else False """
         return False

     def __delitem__(self, y): # real signature unknown; restored from __doc__
         """ x.__delitem__(y) <==> del x[y] """
         pass

     def __eq__(self, y): # real signature unknown; restored from __doc__
         """ x.__eq__(y) <==> x==y """
         pass

     def __getattribute__(self, name): # real signature unknown; restored from __doc__
         """ x.__getattribute__('name') <==> x.name """
         pass

     def __getitem__(self, y): # real signature unknown; restored from __doc__
         """ x.__getitem__(y) <==> x[y] """
         pass

     def __ge__(self, y): # real signature unknown; restored from __doc__
         """ x.__ge__(y) <==> x>=y """
         pass

     def __gt__(self, y): # real signature unknown; restored from __doc__
         """ x.__gt__(y) <==> x>y """
         pass

     def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
         """
         dict() -> new empty dictionary
         dict(mapping) -> new dictionary initialized from a mapping object's
             (key, value) pairs
         dict(iterable) -> new dictionary initialized as if via:
             d = {}
             for k, v in iterable:
                 d[k] = v
         dict(**kwargs) -> new dictionary initialized with the name=value pairs
             in the keyword argument list.  For example:  dict(one=1, two=2)
         # (copied from class doc)
         """
         pass

     def __iter__(self): # real signature unknown; restored from __doc__
         """ x.__iter__() <==> iter(x) """
         pass

     def __len__(self): # real signature unknown; restored from __doc__
         """ x.__len__() <==> len(x) """
         pass

     def __le__(self, y): # real signature unknown; restored from __doc__
         """ x.__le__(y) <==> x<=y """
         pass

     def __lt__(self, y): # real signature unknown; restored from __doc__
         """ x.__lt__(y) <==> x<y """
         pass

     @staticmethod # known case of __new__
     def __new__(S, *more): # real signature unknown; restored from __doc__
         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
         pass

     def __ne__(self, y): # real signature unknown; restored from __doc__
         """ x.__ne__(y) <==> x!=y """
         pass

     def __repr__(self): # real signature unknown; restored from __doc__
         """ x.__repr__() <==> repr(x) """
         pass

     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
         """ x.__setitem__(i, y) <==> x[i]=y """
         pass

     def __sizeof__(self): # real signature unknown; restored from __doc__
         """ D.__sizeof__() -> size of D in memory, in bytes """
         pass

     __hash__ = None

 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
None

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