一、列表
1、定义列表，取出列表中的值
1 names = [] #定义空列表 2 names = ['a','b','c'] #定义一个非空列表 3 4 # 取出列表中的值 5 >>> names = ['a','b','c'] 6 >>> names[0] 7 'a' 8 >>> names[1] 9 'b' 10 >>> names[2] 11 'c' 12 >>> names[-1]#倒着取最后一个值 13 'c'
2、切片
1 >>> names = ['a','b','c','d'] # 列表的下标值是从0开始取值的 2 >>> names[1:3] #取1到3之间的元素，包括1，不包括3 3 ['b', 'c'] 4 >>> names[1:-1] #取1到-1之间的元素，包括1，不包括-1 5 ['b', 'c'] 6 >>> names[0:3] 7 ['a', 'b', 'c'] 8 >>> names[:3] #从头开始取，0可以省略，效果等同于names[0:3] 9 ['a', 'b', 'c'] 10 >>> names[3:] #想取到最后一个值，必须不能写-1，只能这么写 11 ['d'] 12 >>> names[0::2] #后面的2表示：每隔一个元素就取一个 13 ['a', 'c'] 14 >>> names[::2] #从头开始0可以省略，效果跟上一句一样 15 ['a', 'c']
切片小结：
①序列始终都是从左向右切片的，不能是从右向左
①列表切片时，起始位的元素是包括的，结束位的元素是不包括（又叫顾头不顾尾），最后一个位置表示步长（names[开始位:结束位:步长]）
②如果从0位置取值，0可以省略
③想取最后一个值时，结束位不能是-1，因为结束位的元素不包括，所以只能留空
3、列表函数&方法
函数：
| 序号 | 函数 |
| 1 | cmp(list1, list2) #比较两个列表的元素 |
| 2 | len(list) #列表元素个数 |
| 3 | max(list) #返回列表元素最大值 |
| 4 | min(list) #返回列表元素最小值 |
| 5 | list(seq) #将元组转换为列表 |
方法：
| 序号 | 方法 |
| 1 | list.append(obj) #在列表末尾添加新的对象 |
| 2 | list.count(obj) #统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) #在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | list.index(obj) #从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index, obj) #将对象插入列表 |
| 6 | list.pop([index=-1]) #移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj) #移除列表中某个值的第一个匹配项 |
| 8 | list.reverse() #反向列表中元素 |
| 9 | list.sort([func]) #对原列表进行排序 |
| 10 | list.clear() #清空列表 |
| 11 | list.copy() #复制列表 |
演示：
1 # append 列表末尾添加新的对象 2 >>> names = ['a','b','c','d'] 3 >>> names.append('e') 4 >>> print(names) 5 ['a', 'b', 'c', 'd', 'e']#e是新加的元素 6 7 #统计（count(元素)） 8 >>> names = ['a','b','c','d','a'] 9 >>> print(names.count('a')) #统计'a'元素的个数 10 2 11 12 #扩展（extend）names2的列表合并到names1中，但是，names2这个列表依然存在，如果想删除names2这个变量，则只需del names2即可 13 >>> names1 = ['a','b','c','d'] 14 >>> names2 = [1,2,3,4] 15 >>> names1.extend(names2) 16 >>> print(names1) 17 ['a', 'b', 'c', 'd', 1, 2, 3, 4] 18 19 # insert(下标值，插入的内容) 20 >>> names = ['a','b','c','d'] 21 >>> names.insert(0,'1') #0表示需要插入的下标值，'1'表示插入的内容 22 >>> print(names) 23 ['1', 'a', 'b', 'c', 'd'] #在下标值为0的地方插入'1' 24 25 #翻转（reverse()） 26 >>> names = ['a','b','c','d'] 27 >>> names.reverse() 28 >>> print(names) 29 ['d', 'c', 'b', 'a'] #将整个列表翻转过来 30 31 #排序（sort()） 32 >>> names = [4,2,3,1] 33 >>> names.sort() 34 >>> print(names) 35 [1, 2, 3, 4] 36 37 #清空列表（clear()） 38 >>> names = ['a','b','c','d'] 39 >>> names.clear() 40 >>> print(names) 41 [] 42 43 #复制(copy()) 44 >>> names1 = ['a','b','c','d'] 45 >>> names2 = names1.copy() 46 >>> print(names2) 47 ['a', 'b', 'c', 'd']
删除（del、remove(元素)、pop()）
1 #根据下标值删除元素 2 >>> names = ['a','b','c','d'] 3 >>> del names[0] 4 >>> print(names) 5 ['b', 'c', 'd'] 6 7 #根据元素删除 8 >>> names = ['a','b','c','d'] 9 >>> names.remove('a') 10 >>> print(names) 11 ['b', 'c', 'd'] 12 13 #删除最后一个 14 >>> names = ['a','b','c','d'] 15 >>> names.pop() 16 'd' 17 >>> print(names) 18 ['a', 'b', 'c'] 19 20 #pop返回从列表中移除的元素对象 21 >>> names = ['a','b','c','d'] 22 >>> names_pop=names.pop(-1) 23 >>> print(names_pop) 24 d
二、元组
元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表
元组使用小括号，列表使用方括号
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
用途：一般情况下用于自己写的程序能存下数据，但是又希望这些数据不会被改变，比如：数据库连接信息等
1.访问元祖
1 >>> name = ('a','b','c','d') 2 #下标值跟列表一样，也是从0开始 3 >>> print(name[0]) 4 'a' 5 >>> print(name[1]) 6 'b' 7 #访问最后一个元素 8 >>> print(name[-1]) 9 'd'
2，count（统计） 与 index（索引）
# count 统计元素数量 >>> name = ('a','b','c','a') >>> print(name.count('a')) 2 # index 查看元素下标 >>> name = ('a','b','c','a') >>> print(name.index('b')) 1
3、修改元组 删除元祖
1 #元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例: 2 >>> tup1 = (12, 34.56); 3 >>> tup2 = ('abc', 'xyz') 4 5 # 以下修改元组元素操作是非法的。 6 # tup1[0] = 100 7 8 # 创建一个新的元组 9 >>> tup3 = tup1 + tup2; 10 >>> print (tup3) 11 (12, 34.56, 'abc', 'xyz') 12 13 14 15 #元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例: 16 >>> tup = ('Google', 'Runoob', 1997, 2000) 17 18 >>> print (tup) 19 >>> del tup; 20 >>> print ("删除后的元组 tup : ") 21 >>> print (tup) 22 23 #以上实例元组被删除后，输出变量会有异常信息，输出如下所示： 24 Traceback (most recent call last): 25 print (tup) # NameError: name 'tup' is not defined 26 NameError: name 'tup' is not defined 27 ('Google', 'Runoob', 1997, 2000) 28 删除后的元组 tup :
小结：
①元组中的数据不可以被修改，不可以被添加，不可以被删除(当然除非是元组中嵌套列表或者字典，列表和字典中的值是可以被更改的）
②元组的获取元素的方式和列表一样，都是通过下标值访问，下标值都是从0开始
③由于元组只能读，不能写，所以元组只有count和index两个方法
④元组的切片功能和列表一样
4、元组运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
| Python 表达式 | 结果 | 描述 |
| len((1, 2, 3)) | 3 | 计算元素个数 |
| (1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | 连接 |
| ('Hi!',) * 4 | ('Hi!', 'Hi!', 'Hi!', 'Hi!') | 复制 |
| 3 in (1, 2, 3) | True | 元素是否存在 |
| for x in (1, 2, 3): print x | 1 2 3 | 迭代 |
5、元祖内置函数
| 序号 | 方法 |
| 1 | len(tuple) #计算元组元素个数 |
| 2 | max(tuple) #返回元组中元素最大值 |
| 3 | min(tuple) #返回元组中元素最小值 |
| 4 | tuple(seq) #将列表转换为元组 |
三、字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
一、特征：
字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行
1、字典是无序的；
2，字典的key是唯一的,不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
1 >>> dict = {'Name': 'QQ', 'Age': 7, 'Name': 'DD'} 2 >>> print ("dict['Name']: ", dict['Name']) 3 dict['Name']: DD
3、键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例:
1 >>> dict = {['Name']: 'Runoob', 'Age': 7} 2 >>> print ("dict['Name']: ", dict['Name']) 3 4 #错误如下 5 Traceback (most recent call last): 6 dict = {['Name']: 'Runoob', 'Age': 7} 7 TypeError: unhashable type: 'list'
二、基本用法：增加、查看、修改、删除
1、增加
1 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18} 2 #新增 3 >>> stu_info["wanger"] = 30 4 #输出结果 5 >>> print(stu_info) 6 {'zhangsan': 23, 'lisi': 18, 'qigao': 18, 'wanger': 30}
2、查看
通过key查找value
1 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18} 2 #存在key返回value 3 >>> print(stu_info["qigao"]) 4 18 5 6 #不存在key提示报错 7 >>> print(stu_info["wanger"]) 8 Traceback (most recent call last): 9 print(stu_info["wanger"]) 10 KeyError: 'wanger'
通过get(key) 查找value
>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
#存在则返回对应的value
>>> print(stu_info.get("qigao"))
18
#不存在返回None
>>> print(stu_info.get("wanger"))
None
注：get(k)不存在key值，则返回None，通过key直接访问会报错，所以建议推荐用get(k)这个方法获取value
通过key in 字典判断 key是否存在与字典中
1 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18} 2 >>> print("qigao" in stu_info ) #标准用法,在Python3和Python2.7都可以用 3 True
3、修改
1 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18} 2 #修改'qigao'对应的value值，由18改为23 3 >>> stu_info["qigao"] = 23 4 #输出 5 >>> print(stu_info) 6 {'wanger': 30, 'lisi': 18, 'zhangsan': 23, 'qigao': 23}
4、删除(del、pop、popitem)
1 #del 2 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18} 3 >>> del stu_info['qigao'] 4 #结果输出 5 >>> print(stu_info) 6 {'zhangsan': 23, 'lisi': 18} 7 8 注：如果是del stu_info的话，则是删除stu_info这个变量 9 10 11 #pop 12 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18} 13 #删除时给出提示 14 >>> print(stu_info.pop("qigao")) 15 18 16 #输出结果 17 >>> print(stu_info) 18 {'zhangsan': 23, 'lisi': 18} 19 20 21 #popitem 22 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18} 23 #删除时给出提示 24 >>> print(stu_info.popitem()) 25 ('qigao', 18) 26 #输出结果 27 >>> print(stu_info) 28 {'zhangsan': 23, 'lisi': 18}
三、字典内置函数&方法
内置函数
| 序号 | 描述 |
| 1 | len(dict) #计算字典元素个数，即键的总数 |
| 2 | str(dict) #输出字典可打印的字符串表示 |
| 3 | type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型 |
1 #返回字典的元素个数(len ) 2 >>> dict = {'Name': 'zhangsan', 'Age': 7}; 3 >>> print (len (dict)) 4 2 5 6 7 #返回字符串(str) 8 >>> dict = {'Name': 'zhangsan', 'Age': 7}; 9 >>> print (str (dict)) 10 {'Name': 'zhangsan', 'Age': 7} 11 12 13 #返回输入的变量类型(type) 14 >>> dict = {'Name': 'zhangsan', 'Age': 7}; 15 >>> print (type (dict)) 16 <class 'dict'>
方法
| 序号 | 描述 |
| 1 | dict.clear() #删除字典内所有元素 |
| 2 | dict.copy() #返回一个字典的浅复制 |
| 3 | dict.fromkeys(seq[, val]) #创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值 |
| 4 | dict.get(key, default=None) #返回指定键的值，如果值不在字典中返回default值 |
| 5 | dict.items() #以列表返回可遍历的(键, 值) 元组数组 |
| 6 | dict.keys() #以列表返回一个字典所有的键 |
| 7 | dict.setdefault(key, default=None) #和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default |
| 8 | dict.update(dict2) #把字典dict2的键/值对更新到dict里 |
| 9 | dict.values() #以列表返回字典中的所有值 |
| 10 | pop(key[,default]) #删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出.否则，返回default值 |
| 11 | popitem() #返回并删除字典中的最后一对键和值 |
1 #删除字典内所有元素 clear() 2 >>> dict = {'Name': 'Zara', 'Age': 7} 3 4 >>> print ("字典长度 : %d" % len(dict)) 5 >>> dict.clear() 6 >>> print ("字典删除后长度 : %d" % len(dict)) 7 8 #输出： 9 字典长度 : 2 10 字典删除后长度 : 0 11 12 13 #----------------------------------------------------------------------------------- 14 15 16 ##返回一个字典的浅复制 copy() 17 >>> dict1 = {'user': 'runoob', 'num': [1, 2, 3]} 18 19 >>> dict2 = dict1 # 浅拷贝: 引用对象 20 >>> dict3 = dict1.copy() # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用 21 22 >>> # 修改 data 数据 23 >>> dict1['user'] = 'root' 24 >>> dict1['num'].remove(1) 25 26 >>> # 输出结果 27 >>> print(dict1) 28 >>> print(dict2) 29 >>> print(dict3) 30 31 #输出： 32 {'user': 'root', 'num': [2, 3]} 33 {'user': 'root', 'num': [2, 3]} 34 {'user': 'runoob', 'num': [2, 3]} 35 36 37 #----------------------------------------------------------------------------------- 38 39 40 #函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值 fromkeys() 41 >>> seq = ('name', 'age', 'sex') 42 43 >>> dict = dict.fromkeys(seq) 44 >>> print ("新的字典为 : %s" % str(dict)) 45 46 >>> dict = dict.fromkeys(seq, 10) 47 >>> print ("新的字典为 : %s" % str(dict)) 48 49 #输出： 50 新的字典为 : {'name': None, 'age': None, 'sex': None} 51 新的字典为 : {'name': 10, 'age': 10, 'sex': 10} 52 53 54 #----------------------------------------------------------------------------------- 55 56 57 #函数返回指定键的值，如果值不在字典中返回默认值 get() 58 >>> dict = {'Name': 'Runoob', 'Age': 27} 59 60 >>> print ("Age 值为 : %s" % dict.get('Age')) 61 >>> print ("Sex 值为 : %s" % dict.get('Sex', "NA")) 62 63 #输出： 64 Age 值为 : 27 65 Sex 值为 : NA 66 67 68 #----------------------------------------------------------------------------------- 69 70 71 #方法以列表返回可遍历的(键, 值) 元组数组 items() 72 >>> dict = {'Name': 'Runoob', 'Age': 7} 73 74 >>> print ("Value : %s" % dict.items()) 75 76 #输出： 77 Value : dict_items([('Name', 'Runoob'), ('Age', 7)]) 78 79 80 #----------------------------------------------------------------------------------- 81 82 83 #返回一个字典所有的键值 keys() 84 >>> dict = {'Name': 'QQ', 'Age': 7} 85 86 >>> print ("字典所有的键为 : %s" % dict.keys()) 87 >>> print ("字典所有值为 : ", list(dict.values())) 88 89 #输出： 90 字典所有的键为 : dict_keys(['Name', 'Age']) 91 字典所有值为 : ['QQ', 7] 92 93 94 #----------------------------------------------------------------------------------- 95 96 97 #和get()方法类似，如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值 setdefault() 98 >>> dict = {'Name': 'Runoob', 'Age': 7} 99 100 >>> print ("Age 键的值为 : %s" % dict.setdefault('Age', None)) 101 >>> print ("Sex 键的值为 : %s" % dict.setdefault('Sex', None)) 102 >>> print ("新字典为：", dict) 103 104 #输出： 105 Age 键的值为 : 7 106 Sex 键的值为 : None 107 新字典为： {'Name': 'Runoob', 'Age': 7, 'Sex': None} 108 109 110 #----------------------------------------------------------------------------------- 111 112 113 #把字典dict2的键值对更新到dict里 update() 114 >>> dict = {'Name': 'Runoob', 'Age': 7} 115 >>> dict2 = {'Sex': 'female' } 116 117 >>> dict.update(dict2) 118 >>> print ("更新字典 dict : ", dict) 119 120 #输出： 121 更新字典 dict : {'Name': 'Runoob', 'Age': 7, 'Sex': 'female'} 122 123 124 #----------------------------------------------------------------------------------- 125 126 127 #返回字典中的所有值 values() 128 >>> dict = {'Name': 'Zara', 'Age': 7} 129 130 >>> print ("Value : %s" % dict.values()) 131 132 #输出： 133 Value : dict_values(['Zara', 7])
四、循环字典
1 #方法一 2 for key in dict: 3 print(key,dict[key]) 4 5 #方法二 6 for k,v in info.items(): #会先把dict转成list,数据量大时莫用 7 print(k,v)
注：
①方法1的效率比方法2的效率高很多
②方法1是直接通过key取value
③方法2是先把字典转换成一个列表，再去取值
④当数据量比较大的时候，用第二种方法时，字典转换成列表的这个过程需要花大量的时间老转换，当然数据量不大，没有关系，效率差不多