列表

列表是最常用的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 把字典变成列表，数据量大时，很耗时

第二天----列表、元组、字符串、算数运算、字典、while的更多相关文章

python中列表元组字符串如何互相转换
python中有三个内建函数:列表,元组和字符串,他们之间的互相转换使用三个函数,str(),tuple()和list(),具体示例如下所示: >>> s = "xxxxx ...
python 列表元组字符串
列表添加: list.append() list.extend() list.insert() 列表删除: list.remove() #删除某一个元素 list.pop() #删除某一个返回删 ...
python中列表元组字符串相互转换
python中有三个内建函数:列表,元组和字符串,他们之间的互相转换使用三个函数,str(),tuple()和list(),具体示例如下所示: >>> s = "xxxxx ...
python基础(五)列表,元组,集合
列表在python中是由数个有序的元素组成的数据结构,每一个元素对应一个index索引来隐式标注元素在列表中的位置.是python中最常用的一种数据类型.需要注意的是列表中可以有重复相同的数据. 列 ...
Python3基础（2）模块、数据类型及运算、进制、列表、元组、字符串操作、字典
---------------个人学习笔记--------------- ----------------本文作者吴疆-------------- ------点击此处链接至博客园原文------ 1 ...
Python第三天序列 5种数据类型数值字符串列表元组字典各种数据类型的的xx重写xx表达式
Python第三天序列 5种数据类型数值字符串列表元组字典各种数据类型的的xx重写xx表达式目录 Pycharm使用技巧(转载) Python第一天安装 shell ...
跟着ALEX 学python day2 基础2 模块数据类型运算符列表元组字典字符串的常用操作
声明 : 文档内容学习于 http://www.cnblogs.com/xiaozhiqi/ 模块初始: Python的强大之处在于他有非常丰富和强大的标准库和第三方库,几乎你想实现的任何功能都有相 ...
Python 第二篇：python字符串、列表和字典的基本操作方法
本文基于python 3.5.1 python常见的数据类型有字串.列表.元组.字典等,本文将详细介绍每一种数据类型的操作方法. 一:str字串的操作方法: 1.capitalize()--> ...
python 数据类型：字符串String / 列表List / 元组Tuple / 集合Set / 字典Dictionary
#python中标准数据类型字符串String 列表List 元组Tuple 集合Set 字典Dictionary 铭记:变量无类型,对象有类型 #单个变量赋值 countn00 = '; #整数 ...
Python第三天序列数据类型数值字符串列表元组字典
Python第三天序列数据类型数值字符串列表元组字典数据类型数值字符串列表元组字典序列序列:字符串.列表.元组序列的两个主要特点是索引操作符和切片操作符- 索引操作符让我 ...

随机推荐

hexo博客进阶－相册和独立域名
之前我已经写了一篇文章详细的讲述了如何使用hexo搭建github博客.如果还没有看的可以去看看,hexo搭建博客其实,根据这篇文章的过程我们就能够搭建一个专属于自己,并且非常美观的博客了.但是如果 ...
SharePoint 客户端对象模型共用ClientContext的坑
首先请看代码 private static void Main(string[] args) { Test2(); } private static void Test2() { var client ...
SuperMap iClient 7C——网络客户端GIS开发平台产品新特性
SuperMap iClient 7C是空间信息和服务的可视化交互开发平台,是SuperMap服务器系列产品的统一客户端.产品基于统一的架构体系,面向Web端和移动端提供了多种类型的SDK开发包,帮助 ...
[转]File Descriptor泄漏导致Crash: Too many open files
在实际的Android开发过程中,我们遇到了一些奇奇怪怪的Crash,通过sigaction再配合libcorkscrew以及一些第三方的Crash Reporter都捕获不到发生Crash的具体信息 ...
OC KVC
OC KVC KVC 全称 key valued coding 键值编码在说KVC之前应该简单的了解一下反射机制反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法. 对于任意 ...
python编码问题
SCII编码是1个字节,而Unicode编码(汉字)通常是2个字节.一个字节8位(bit) 如果统一成Unicode编码,英文字母就会占用2个字节,造成空间浪费.从而出现了utf8可变编码,utf8编 ...
Play Framework 完整实现一个APP（四）
上一篇最后出现的错误是因为断言 assertEquals(1, Post.count()); 出错,取到的Post的数量不是1,运行Test之前,表中有数据可以添加以下方法,运行Test前清空数据 ...
VirtualBox + vagrant
VirtualBox 虚拟机不必多说 vagrant 是ruby编写的VirtualBox的命令行镜像管理工具 1 先安装VirtualBox 然后安装 vageant 下载地址 googl ...
我对uml类图关系的理解
uml类图的关系: 泛化关系也就是继承. 实现关系就是一个类实现另外一个接口. 依赖关系就是一个类使用了另外一个类,是一种使用关系,在这个类的某个服务中需要另外一个类来协助. 关联关系就是一类拥有另外 ...
windows下安装nginx
说起开发,自己感到非常惭愧,由于公司让我给<绿电侠>项目写整体架构解决方案,才开始接触nginx这个东东,突然觉得它是一把非常好的利器. 本文主要记录在windows下安装nginx,另参 ...

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