自学Python之Python基础：（二）Python容器：列表、元组、字典

转载的老板请注明出处：http://blog.csdn.net/cc_xz/article/details/78687587万分感谢！

前言：

本篇为Python基础中的第二章，简单的介绍了Python中列表、元组、字典，并讨论了它们的常用函数。

在本篇中，你将了解到：
1.关于列表以及它的常用函数。
2.关于元组的使用方法。
3.关于字典以及它的常用函数。

使用特定的数据结构来存储由一系列元素组成的序列，这些元素以他们在列表中的位置为索引，从第一个到最后一个依次编号。在Python中拥有两种这样的序列结构：列表和元组。他们都可以包含零个或多个元素，而且列表和元组并不要求所包含的元素类型相同，甚至是在一个列表中存储另外一个列表。
其中，列表中的元素是可变的，可以根据需求随时的插入、修改或删除其中的元素。而元组是不可变的，当在创建元组并为其赋值后，这些值变被固定在了元组中，再也无法修改了。

列表：
列表非常适合利用顺序和位置定位某个元素，尤其是当元素的顺序或内容经常发生改变时。而且列表还允许相同的元素出现多次。。

使用list()将其他数据类型转换为列表：

test01 = "虚其心，实其腹，弱其志，强其骨。"  
list01 = list(test01) #默认list会将一个字符串分割成一个一个的字符，再以字符为单位将元素放置到列表中。
list02 = list(test01.split("，")) #而在处理字符串时，对字符串进行分割，使其以“，”为分割，再将元素放置到列表中。
print(list01) 
print(list02)

输出结果为：

['虚', '其', '心', '，', '实', '其', '腹', '，', '弱', '其', '志', '，', '强', '其', '骨', '。']
['虚其心', '实其腹', '弱其志', '强其骨。']

使用list()将其他数据类型转换为列表：

test01 = "虚其心，实其腹，弱其志，强其骨。" 
list01 = list(test01.split("，"))
print(list01[0:4]) 
print(list01[-1])

输出结果为：

['虚其心', '实其腹', '弱其志', '强其骨。']   
强其骨。

包含列表的列表：

list01 = list("法有，民安其次，主变，事能得齐，国守安，主操权，利，故主贵多变，国贵少变".split("，")) 
list02 = list("民，辱则贵爵，弱则尊官，贫则重赏，以刑治民，则乐用，以赏战民，则轻死".split("，")) 
list03 = list("法枉治乱，任善言多，治众国乱，言多兵弱，法明治省，任力言息".split("，"))
list04 = [list01,list02,list03]
print(list04[2]) #查看其中一个list时显示整个list中全部内容。
print(list04[0][2]) #首先查看list04中的第一个列表，接着在第一个列表中抽取出第三个元素来显示(0为第一个)

输出结果为：

['法枉治乱', '任善言多', '治众国乱', '言多兵弱', '法明治省', '任力言息']    
主变  

使用偏移值修改元素：

list01 = [1,2,3,4,5,6,7,8,9] 
list01[3] = "修改" 
print(list01)

输出结果为：

[1, 2, 3, '修改', 5, 6, 7, 8, 9]

使用append()添加元素至尾部：

list01 = [1,2,3,4,5,6,7,8,9] 
list01.append(10) 
print(list01)

输出结果为：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

注意使用append()函数每次只能添加一个元素。

使用extend()或+=合并列表：

list01 = [1,2,3,4,5,6,7,8,9]  
list02 = ["A","B","C","D","E","F","G","H"] 
list03 = [] 
list03 += list01 + list02 
list01.extend(list02)
print(list01)
print(list03)

输出结果为：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'] 
[1, 2, 3, 4, 5, 6, 7, 8, 9, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']

值得注意的是，如果使用了append()是将一个列表作为整体元素添加，而extend()是将两个列表进行合并。

使用insert()在指定位置插入元素：

list01 = [1,2,3,4,5,6,7,8,9]
list01.insert(5,"插入一条")
print(list01)

输出结果为：

[1, 2, 3, 4, 5, '插入一条', 6, 7, 8, 9]

使用del删除指定位置元素：

list01 = [1,2,3,4,5,6,7,8,9] 
del list01[3] 
print(list01)

输出结果为：

[1, 2, 3, 5, 6, 7, 8, 9]

值得注意的是，del是Python语句，而不是列表的方法，即：无法通过list.del()来进行操作。del就像赋值语句的逆转过程：它将一个Python对象与它的名字之间的关联删除，而如果这个对象无其他名称的引用，则其占用的空间也将被清除。

使用remove()删除具有指定值的元素：
如果你不确定或不关心元素在列表中的位置，则使用remove()根据指定元素的值来删除元素。

list01 = [1,2,3,4,5,6,7,8,9]
list01.remove(4)
print(list01)

输出结果为：

[1, 2, 3, 5, 6, 7, 8, 9]

使用pop()获取并删除指定位置的元素：
使用pop()同样可以获取列表中指定位置的元素，而在获取完成后，则将该元素删除。如果为pop()指定了偏移值，它会返回并删除偏移值对应位置的元素；如果不指定，则默认返回并删除-1（最后一个）位置上的元素。

list01 = [1,2,3,4,5,6,7,8,9] 
name = list01.pop(5) 
print(name,"\n",list01)

输出结果为：

6 
 [1, 2, 3, 4, 5, 7, 8, 9]

使用index()查询特定元素的位置：

list01 = [1,2,3,4,5,6,7,8,9]  
print(list01.index(5))

输出结果为：

4 

判断值是否存在以及出现次数：

list01 = [1,2,3,4,5,6,7,8,9,1]
IfThere = 1 in list01 
print(IfThere)

输出结果为：

True

这种方法，只要1出现，则返回1，而无法计算该值出现多少次。

list01 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 1, 1] 
number = 0  
for test in list01:
   if test == 1:  
      number += 1
print(number)

输出结果为：

4

上述方法可以计算出列表中的某值出现次数。

list01 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 1, 1]
print(list01.count(1),list01.count(10))

输出结果为：

4 0

但list内置了该功能，而且对于不包含的值，则输出0。

将列表重新排序：

• 列表方法sort()会对原列表进行排序，并修改原列表中的内容。
• 通过函数sorted()则返回排序好的列表副本，而原列表中的内容不会被修改。

如果列表中的元素都是数字，则会被按照从小到大的升序，如果元素都是字符串，则会按照字母表的顺序排序。

list01 = [1, 2, 3, 4, 7, 5, 7, 9, 8, 6]
list02 = sorted(list01)  # 创建一个副本 
print(list01)
list01.sort(reverse=True)  # 直接修改源文件,默认升序，设置为降序。
print(list01)
print(list02, "\n")

list03 = ["嘻嘻", "哈哈", "cc", "zz"]
list03.sort()  # 注意，这只是一个排序操作，而不会返回具体的值。
print(list03)

输出结果为：

[1, 2, 3, 4, 7, 5, 7, 9, 8, 6]
[9, 8, 7, 7, 6, 5, 4, 3, 2, 1]
[1, 2, 3, 4, 5, 6, 7, 7, 8, 9] 

['cc', 'zz', '哈哈', '嘻嘻']

使用“=”赋值引用和copy()复制数据：

list01 = [1,2,3,4,5]  
list02 = list01 #list01和02实际上是指向了同一个列表，只是名称不同而已。
list03 = list01.copy() #而使用copy()是将list01的值复制给了list03，不仅仅是将list01的列表引用复制到list03（list02是这种方法）。
list01[4] = "这是一段字符串"  
print(list01,list02,list03) 

输出结果为：

[1, 2, 3, 4, '这是一段字符串', '\n'] [1, 2, 3, 4, '这是一段字符串', '\n'] [1, 2, 3, 4, 5, '\n']

元组：
与列表类似，元组也是由任意类型元素组成的序列，但与列表不同的是，元组是不可变的，这意味着一旦元组被定义，将无法进行增加、删除或修改元素等操作。因此，元组就像是一个常量列表。

定义元组：

tuple01 = () #创建一个空元组 
tuple02 = (1) #给元组赋值
tuple03 = "A","B",3 #再定义一个元组，而元组的定义不会被强制要求增加括号，但增加括号有助于代码的可读性。
print(tuple01,tuple02,tuple03)

输出结果为：

() 1 ('A', 'B', 3)

使用list等其他容器/类型创建元组：

list01 = [1,2,3,4,5,6]   
tuple01 = tuple(list01) 
print(list01,tuple01)

输出结果为：

[1, 2, 3, 4, 5, 6] (1, 2, 3, 4, 5, 6)

从元组中取值：

tuple01 = "A","B",3 #再定义一个元组，而元组的定义不会被强制要求增加括号，但增加括号有助于代码的可读性。
a,b,c = tuple01  
#d,e = tuple01 #如果元组中有3个值，那么必须对应3个变量。
print(a,b,c) 
d = tuple01[0] 
e = tuple01[1] 
print(d,e) 

输出结果为：

A B 3
A B

元组与列表：
通常在许多地方可以使用元组代替列表，但相对于列表，由于元组的无法修改，列表将更加灵活。元组的优点和常用场景如下：

• 元组占用内存空间较小。
• 元组常常作为字典的键（Key）。
• 命名元组可以作为对象的代替品。
• 函数的参数是通过元组的形式传递的。

字典：
字典与列表类型，但其中元素的顺序是无序的，因为在使用字典时不会通过元素的偏移值来访问。而是给每个元素设定一个唯一的键值Key，即字典是通过键值对（Key-Value）的方式使用的。
键（Key）通常是一个字符串，但也可以使用Python中其他的任意的类型，例如布尔值、整数、浮点数、元组等。字典是可变的，可以通过增加、删除或修改其中的键值对。

使用｛｝创建字典：

dict01 = {"战法第一段":"凡战法必本于政胜，则其民不争，不争则无以私意，以上为意。故王者之政，使民怯于邑斗，而勇于寇战。民习 以力攻难，故轻死。", 
          "战法第二段":"见敌如溃，溃而不止，则免。故兵法大战胜，逐北无过十里。小战胜，逐北无过五里。"}
print(dict01["战法第二段"])

输出结果为：

见敌如溃，溃而不止，则免。故兵法大战胜，逐北无过十里。小战胜，逐北无过五里。

值得注意的是，Python允许在列表、元组或字典的最后添加逗号，这不会产生任何问题。此外在括号之间输入键值对来创建字典时并不会强制要求缩进，但为了代码的可读性，还是应该尽量分段编写。

使用[Key]添加或修改元素：

list01 = [["1", "2"], ["2", "3"]]
dict01 = dict(list01)
print(dict01)

dict01["name"] = "这是一个名字"
print(dict01)
dict01["name"] = "苍良"
print(dict01)

输出结果为：

{'1': '2', '2': '3'}    
{'1': '2', 'name': '这是一个名字', '2': '3'}
{'1': '2', 'name': '苍良', '2': '3'}

向字典中添加元素非常简单，只需要指定该元素的键（Key）并赋予相应的结果即可。如果该键不存在于字典中，则创建该Key-Value，如果该键已经存在于字典中，则替换掉旧值。即：键（Key）必须的唯一的。

使用update()合并字典：

dict01 = {"1":"哈哈","2":"嘿嘿"} 
dict02 = {"2":"嘻嘻","3":"呵呵"}
dict01.update(dict02)
print(dict01)

输出结果为：

{'3': '呵呵', '2': '嘻嘻', '1': '哈哈'}

注意，Key值相同的键值对将被覆盖。

删除字典：

dict01 = {"1":"哈哈","2":"嘿嘿","3":"嘻嘻","4":"呵呵"}
del dict01["2"] #通过Python语句删除。  
dict01.pop("3") #通过dict函数删除。
print(dict01) 
dict01.clear() #清空字典   
print(dict01)  

输出结果为：

{'4': '呵呵', '1': '哈哈'}  
{}

判断某Key是否存在：

dict01 = {"1":"哈哈","2":"嘿嘿","3":"嘻嘻","4":"呵呵"} 
IfExist = "1" in dict01 
print(IfExist) 
IfExist = "5" in dict01 
print(IfExist)

输出结果为：

True    
False

通过Key获取dict中的元素：

dict01 = {"1":"哈哈","2":"嘿嘿","3":"嘻嘻","4":"呵呵"} 
name01 = dict01["1"] #此种方法，如果名为“1”的Key不存在，则会报出异常。 
name02 = dict01.get("2") #此种方法，如果名为“2”的Key不存在，则会返回None。
name03 = dict01.get("5")  
name04 = dict01.get("6","噗") #可以定义默认值，如果对应的Key不存在，则返回默认值。 
print(name01,name02,name03,name04)

输出结果为：

哈哈 嘿嘿 None 噗

获取所有的键（Key）和值（Value）：

dict01 = {"1":"哈哈","2":"嘿嘿","3":"嘻嘻","4":"呵呵"}
print(dict01.keys()) #获取全部的Key值，默认会返回一个dict_keys类型的合集。
key01 = list(dict01.keys()) #需要显式的将其转化成list。
print(key01[0]) #否则无法通过偏移值的方式调取其中的元素。 
print(key01)

输出结果为：

dict_keys(['2', '1', '4', '3'])
2
['2', '1', '4', '3']    

dict01 = {"1":"哈哈","2":"嘿嘿","3":"嘻嘻","4":"呵呵"} 
print(list(dict01.values())) #获取全部的值（Value）
print(list(dict01.items())) #获取所以的键值对（Key-Value）

输出结果为：

['呵呵', '嘻嘻', '嘿嘿', '哈哈']    
[('4', '呵呵'), ('3', '嘻嘻'), ('2', '嘿嘿'), ('1', '哈哈')]    

值得注意的是，在使用items()返回全部的键值对时，我们显式的将其转换为一个list，但list中所包含的却是元组（tuple）。也就是说，通过items()函数返回的键值对是无法修改的。