python教程：列表(list)、元组(tuple)、字典(dict)

一、列表

1、定义列表，取出列表中的值

names = [] #定义空列表
names = ['a','b','c'] #定义一个非空列表# 取出列表中的值
>>> names = ['a','b','c']
>>> names[0]
'a'
>>> names[1]
'b'
>>> names[2]
'c'
>>> names[-1]#倒着取最后一个值
'c'

2、切片

>>> names = ['a','b','c','d'] # 列表的下标值是从0开始取值的
>>> names[1:3] #取1到3之间的元素，包括1，不包括3
['b', 'c']
>>> names[1:-1] #取1到-1之间的元素，包括1，不包括-1
['b', 'c']
>>> names[0:3]
['a', 'b', 'c']
>>> names[:3] #从头开始取，0可以省略，效果等同于names[0:3]
['a', 'b', 'c']
>>> names[3:]  #想取到最后一个值，必须不能写-1，只能这么写
['d']
>>> names[0::2] #后面的2表示：每隔一个元素就取一个
['a', 'c']
>>> names[::2] #从头开始0可以省略，效果跟上一句一样
['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()　　#复制列表

演示：

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''# append 列表末尾添加新的对象>>>    names = ['a','b','c','d']>>>    names.append('e')>>>    print(names)['a', 'b', 'c', 'd', 'e']#e是新加的元素#统计（count(元素)）>>> names = ['a','b','c','d','a']>>> print(names.count('a')) #统计'a'元素的个数2#扩展（extend）names2的列表合并到names1中，但是，names2这个列表依然存在，如果想删除names2这个变量，则只需del names2即可>>> names1 = ['a','b','c','d']>>> names2 = [1,2,3,4]>>> names1.extend(names2)>>> print(names1)['a', 'b', 'c', 'd', 1, 2, 3, 4]# insert(下标值，插入的内容) >>> names = ['a','b','c','d']>>> names.insert(0,'1') #0表示需要插入的下标值，'1'表示插入的内容>>> print(names)['1', 'a', 'b', 'c', 'd'] #在下标值为0的地方插入'1'#翻转（reverse()）>>> names = ['a','b','c','d']>>> names.reverse()>>> print(names)['d', 'c', 'b', 'a']  #将整个列表翻转过来#排序（sort()）>>> names = [4,2,3,1]>>> names.sort()>>> print(names)[1, 2, 3, 4]#清空列表（clear()）>>> names = ['a','b','c','d']>>> names.clear()>>> print(names)[]#复制(copy())>>> names1 = ['a','b','c','d']>>> names2 = names1.copy()>>> print(names2)['a', 'b', 'c', 'd']

删除（del、remove(元素)、pop()）

 #根据下标值删除元素>>> names = ['a','b','c','d']>>> del names[0] >>> print(names)['b', 'c', 'd']#根据元素删除>>> names = ['a','b','c','d']>>> names.remove('a')>>> print(names)['b', 'c', 'd']#删除最后一个>>> names = ['a','b','c','d']>>> names.pop()'d'>>> print(names)['a', 'b', 'c']#pop返回从列表中移除的元素对象>>> names = ['a','b','c','d']>>> names_pop=names.pop(-1)>>> print(names_pop)d

二、元组

元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表

元组使用小括号，列表使用方括号

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

用途：一般情况下用于自己写的程序能存下数据，但是又希望这些数据不会被改变，比如：数据库连接信息等

1.访问元祖

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
>>> name = ('a','b','c','d')
#下标值跟列表一样，也是从0开始
>>> print(name[0])
'a'
>>> print(name[1])
'b'
#访问最后一个元素
>>> print(name[-1])
'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、修改元组删除元祖

#元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
>>> tup1 = (12, 34.56);
>>> tup2 = ('abc', 'xyz')# 以下修改元组元素操作是非法的。
# tup1[0] = 100# 创建一个新的元组
>>> tup3 = tup1 + tup2;
>>> print (tup3)
(12, 34.56, 'abc', 'xyz')#元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
>>> tup = ('Google', 'Runoob', 1997, 2000)>>> print (tup)
>>> del tup;
>>> print ("删除后的元组 tup : ")
>>> print (tup)#以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
Traceback (most recent call last):print (tup) # NameError: name 'tup' is not defined
NameError: name 'tup' is not defined
('Google', 'Runoob', 1997, 2000)
删除后的元组 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 }

1、特征：

字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行

字典是无序的；
字典的key是唯一的,不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

 >>> dict = {'Name': 'QQ', 'Age': 7, 'Name': 'DD'}>>> print ("dict['Name']: ", dict['Name'])dict['Name']:  DD

键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例:

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
>>> dict = {['Name']: 'Runoob', 'Age': 7}
>>> print ("dict['Name']: ", dict['Name'])#错误如下
Traceback (most recent call last):dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'

2、基本用法：增加、查看、修改、删除

增加

>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
#新增
>>> stu_info["wanger"] = 30
#输出结果
>>> print(stu_info)
{'zhangsan': 23, 'lisi': 18, 'qigao': 18, 'wanger': 30}

查看

通过key查找value

>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
#存在key返回value
>>> print(stu_info["qigao"])
18#不存在key提示报错
>>> print(stu_info["wanger"])
Traceback (most recent call last):print(stu_info["wanger"])
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是否存在与字典中

 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}>>> print("qigao"  in stu_info ) #标准用法,在Python3和Python2.7都可以用True

修改

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
#修改'qigao'对应的value值，由18改为23
>>> stu_info["qigao"] = 23
#输出
>>> print(stu_info)
{'wanger': 30, 'lisi': 18, 'zhangsan': 23, 'qigao': 23}

删除(del、pop、popitem)

#del
>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
>>> del stu_info['qigao']
#结果输出
>>> print(stu_info)
{'zhangsan': 23, 'lisi': 18}注：如果是del stu_info的话，则是删除stu_info这个变量#pop
>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
#删除时给出提示
>>> print(stu_info.pop("qigao"))
18
#输出结果
>>> print(stu_info)
{'zhangsan': 23, 'lisi': 18}#popitem
>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
#删除时给出提示
>>> print(stu_info.popitem())
('qigao', 18)
#输出结果
>>> print(stu_info)
{'zhangsan': 23, 'lisi': 18}

3、字典内置函数&方法

内置函数

序号	描述
1	len(dict) #计算字典元素个数，即键的总数
2	str(dict) #输出字典可打印的字符串表示
3	type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
#返回字典的元素个数(len )
>>> dict = {'Name': 'zhangsan', 'Age': 7};
>>> print (len (dict))
2#返回字符串(str)
>>> dict = {'Name': 'zhangsan', 'Age': 7};
>>> print (str (dict))
{'Name': 'zhangsan', 'Age': 7}#返回输入的变量类型(type)
>>> dict = {'Name': 'zhangsan', 'Age': 7};
>>> print (type (dict))
<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() #返回并删除字典中的最后一对键和值

#删除字典内所有元素   clear()
>>> dict = {'Name': 'Zara', 'Age': 7}>>> print ("字典长度 : %d" %  len(dict))
>>> dict.clear()
>>> print ("字典删除后长度 : %d" %  len(dict))#输出：
字典长度 : 2
字典删除后长度 : 0#-----------------------------------------------------------------------------------##返回一个字典的浅复制   copy()
>>> dict1 = {'user': 'runoob', 'num': [1, 2, 3]}>>> dict2 = dict1  # 浅拷贝: 引用对象
>>> dict3 = dict1.copy()  # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用>>> # 修改 data 数据
>>> dict1['user'] = 'root'
>>> dict1['num'].remove(1)>>> # 输出结果
>>> print(dict1)
>>> print(dict2)
>>> print(dict3)#输出：
{'user': 'root', 'num': [2, 3]}
{'user': 'root', 'num': [2, 3]}
{'user': 'runoob', 'num': [2, 3]}#-----------------------------------------------------------------------------------#函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值    fromkeys()
>>> seq = ('name', 'age', 'sex')>>> dict = dict.fromkeys(seq)
>>> print ("新的字典为 : %s" %  str(dict))>>> dict = dict.fromkeys(seq, 10)
>>> print ("新的字典为 : %s" %  str(dict))#输出：
新的字典为 : {'name': None, 'age': None, 'sex': None}
新的字典为 : {'name': 10, 'age': 10, 'sex': 10}#-----------------------------------------------------------------------------------#函数返回指定键的值，如果值不在字典中返回默认值   get()
>>> dict = {'Name': 'Runoob', 'Age': 27}>>> print ("Age 值为 : %s" %  dict.get('Age'))
>>> print ("Sex 值为 : %s" %  dict.get('Sex', "NA"))#输出：
Age 值为 : 27
Sex 值为 : NA#-----------------------------------------------------------------------------------#方法以列表返回可遍历的(键, 值) 元组数组   items()
>>> dict = {'Name': 'Runoob', 'Age': 7}>>> print ("Value : %s" %  dict.items())#输出：
Value : dict_items([('Name', 'Runoob'), ('Age', 7)])#-----------------------------------------------------------------------------------#返回一个字典所有的键值   keys()
>>> dict = {'Name': 'QQ', 'Age': 7}>>> print ("字典所有的键为 : %s" %  dict.keys())
>>> print ("字典所有值为 : ",  list(dict.values()))#输出：
字典所有的键为 : dict_keys(['Name', 'Age'])
字典所有值为 :  ['QQ', 7]#-----------------------------------------------------------------------------------#和get()方法类似，如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值    setdefault()
>>> dict = {'Name': 'Runoob', 'Age': 7}>>> print ("Age 键的值为 : %s" %  dict.setdefault('Age', None))
>>> print ("Sex 键的值为 : %s" %  dict.setdefault('Sex', None))
>>> print ("新字典为：", dict)#输出：
Age 键的值为 : 7
Sex 键的值为 : None
新字典为： {'Name': 'Runoob', 'Age': 7, 'Sex': None}#-----------------------------------------------------------------------------------#把字典dict2的键值对更新到dict里   update()
>>> dict = {'Name': 'Runoob', 'Age': 7}
>>> dict2 = {'Sex': 'female' }>>> dict.update(dict2)
>>> print ("更新字典 dict : ", dict)#输出：
更新字典 dict :  {'Name': 'Runoob', 'Age': 7, 'Sex': 'female'}#-----------------------------------------------------------------------------------#返回字典中的所有值    values()
>>> dict = {'Name': 'Zara', 'Age': 7}>>> print ("Value : %s" %  dict.values())#输出：
Value : dict_values(['Zara', 7])

4、循环字典

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
#方法一
for key in dict:print(key,dict[key])#方法二
for k,v in info.items(): #会先把dict转成list,数据量大时莫用print(k,v)

注：

①方法1的效率比方法2的效率高很多

②方法1是直接通过key取value

③方法2是先把字典转换成一个列表，再去取值

④当数据量比较大的时候，用第二种方法时，字典转换成列表的这个过程需要花大量的时间老转换，当然数据量不大，没有关系，效率差不多