python元组字典例子_Python基础总结（十一）（元组、集合、字典）

一、元组

元组跟列表相似，但是元组用的元素是固定的。也就是说元组被创建以后就不能对元组中的元素进行添加、删除、替换或重新排列。

如果在应用中不应该对列表中的内容进行修改，可以使用元组来防止元素被意外添加、删除或替换。由于Python的实现，元组比列表的效率更高。

可以使用下面的语法创建一个元组：

t1 = ()

t2 = (1, 2, 3)

t3 = tuple([2 * x for x in range(1, 5)])

#也可以从字符串创建一个元组

t4 = tuple("abcd") # t4 is ('a', 'b', 'c', 'd')

可以对元组使用len、min、max、sum函数，可以使用for循环遍历元组所有内容，可以使用下标运算符访问元组对应元素或元素段，可以使用in或not in运算符判断一个元素是否在元组中，并使用比较运算符来对元组中的元素进行比较。例如：

>>> t1 = tuple([1, 7, 3, 2, 23, 5])

>>> len(t1)

6

>>> min(t1)

1

>>> max(t1)

23

>>> sum(t1)

41

>>> t2 = ("a","b", "c")

>>> t1+t2

(1, 7, 3, 2, 23, 5, 'a', 'b', 'c')

>>> 2*t1

(1, 7, 3, 2, 23, 5, 1, 7, 3, 2, 23, 5)

>>> t1[2: 4]

(3, 2)

>>> 2 in t1

True

>>> list1 = list(t1)

>>> list1.sort()

>>> list1

[1, 2, 3, 5, 7, 23]

>>> t3 = tuple(list1)

>>> t3

(1, 2, 3, 5, 7, 23)

我们知道元组的元素是固定的，那么上面例子中对元组的+和*操作是怎么回事呢？其实是将结果重新分配给了一个新的元组，而不是将原来的元组改变了。

注意：一个元组本身的元素是固定的，但是元组的元素自身的变量可能是易变的。例如：

circles = (circle1, circle2)

circles[0].setRadius(4)

print(circles[0].getRadius()) #打印：4

这个例子中，元组的元素中的圆的半径可以改变。

二、集合

集合和类表类似，可以使用它们存储一个元素集合，但是，集合中的元素是不重复且不是按任何特定顺序放置的,所以不能使用下标访问集合。

如果应用中不关心元素的顺序，使用集合比使用列表效率更高。

创建集合

可以使用花括号{}创建集合，也可以将列表或元组转换成集合。

s1 = set() #注意s1 = {}是创建一个空字典，而不是空集合

s2 = {1， 3，5}

s3 = set((1, 3, 5)) #从元组创建一个集合

s4 = set([x * 2 for x in range(1, 10)]) # 从列表创建集合

s5 = set("abcd") # 从字符串创建集合 {'a', 'b', 'c'}

s6 = {1, 2, 3, "one", "two"} #包含不同元素的集合

注意：集合中不包含重复的元素，例如s5

操作集合

可以使用add(e)或remove(e)来对一个集合添加或删除元素，可以使用函数len、min、max、sum、for循环、in或not in对集合进行操作。如果删除一个集合中不存在的元素，remove(e)方法将抛出一个KeyError异常。

集合运算

子集和超集：如果集合s1中的元素都在s2中，则s1是s2的子集，s2是s1的超集

s1.issubset(s2)

s2.issuperset(s1)

真子集和真超集：s1中每个元素都在s2中，但是s2中至少有一个元素不在s1中，s1就是s2的真子集，s2是s1的真超集。

s1 == s2 # s1和s2包含相同元素

s1 < s2 # s1是s2真子集

s1 <= s2 # s1是s2子集

s1 > s2 # s1是s2真超集

s1 >= s2 # s1是s2超集

并集：包含两个集合所有元素的集合

s1.union(s2)

或

s1 | s2

交集：包含两个集合共同元素的集合

s1.intersection(s2)

或

s1 & s2

差集：包含在s1中但不在s2中的集合，是s1和s2的差集

s1.difference(s2)

或

s1 - s2

对称差（异或）:两个集合中除它们共同元素之外的元素的集合

s1.symmertric_difference(s2)

或

s1 ^ s2

集合和列表性能比较

我们上面说集合比列表效率高，那么是真的高么？这里给出个例子，我们看一看两者在检测一个元素是否存在和从两者中删除元素各自的执行时间：

import random

import time

NUMBER_OF_ELEMENTS = 10000

lst = list(range(NUMBER_OF_ELEMENTS))

random.shuffle(lst)

s = set(lst)

startTime = time.time()

for i in range(NUMBER_OF_ELEMENTS):

i in s

endTime = time.time()

runTime = int((endTime - startTime) * 1000)

print("测试", NUMBER_OF_ELEMENTS, "个对象在集合中\n", "运行时间是：", runTime, "毫秒")

startTime = time.time()

for i in range(NUMBER_OF_ELEMENTS):

i in lst

endTime = time.time()

runTime = int((endTime - startTime) * 1000)

print("测试", NUMBER_OF_ELEMENTS, "个对象在列表中\n", "运行时间是：", runTime, "毫秒")

startTime = time.time()

for i in range(NUMBER_OF_ELEMENTS):

s.remove(i)

endTime = time.time()

runTime = int((endTime - startTime) * 1000)

print("删除", NUMBER_OF_ELEMENTS, "个对象在集合中\n", "运行时间是：", runTime, "毫秒")

startTime = time.time()

for i in range(NUMBER_OF_ELEMENTS):

lst.remove(i)

endTime = time.time()

runTime = int((endTime - startTime) * 1000)

print("删除", NUMBER_OF_ELEMENTS, "个对象在列表中\n", "运行时间是：", runTime, "毫秒")

import os

os.walk()

显示结果如下：

测试 10000 个对象在集合中

运行时间是： 2 毫秒

测试 10000 个对象在列表中

运行时间是： 1356 毫秒

删除 10000 个对象在集合中

运行时间是： 2 毫秒

删除 10000 个对象在列表中

运行时间是： 589 毫秒

从结果可以看出集合的处理效率是优于列表的，这跟Python中集合的实现是相关的。

三、字典

创建一个字典：

dictionary = {}

dictionary = {"1": "john", "2": "jack"}

添加字典的值：

dictionaryName[key] = value

获取字典的值：

value = dictionaryName[key]

删除一个条目：

del dictionaryName[key]

遍历字典：

for key in dictionary:

print(key, dictionary[key])

可以使用len（dictionary）获取字典中条目的数目。

可以使用in或not in运算符来判断一个关键字是否在一个字典当中。

可以使用运算符==和!=来检测两个字典是否包含同样的条目（不在乎数据的顺序），不能使用>、>=、<=和<对字典比较，因为字典中的元素是没有顺序的。

字典方法：

方法名

解释

keys(): tuple

返回关键字组成的元组

values():tuple

返回值组成的元组

items():tuple

返回每个条目组成的元组

clear():None

删除所有条目

get(key): value

返回这个关键字对应的值

pop(key): value

删除这个关键字对应的条目并返回它的值

popitem(): tuple

返回一个随机选择的键值对作为元组并删除这个被选择的条目