元组tuple,集合set字典dict的补充

参考了《Python3从入门到实战》这本书

一、元素tuple

（1）元组是一个有序序列,但它是不可修改的

（2）创建一个元组,和list一样,tuple的对象的元素类型可以不同,可以包含list tuple等各种类型的对象

（3）创建只包含一个元素的tuple时,必须在这个元素后面加一个逗号,否则就不是一个元组

t = ("许嵩","周杰伦")
print(t)
运行结果如下:
('许嵩', '周杰伦')

#用函数tuple() 可以创建一个对象
t1 = tuple('hello')
t2 = tuple([2,3,4])
t3 = tuple((3,4,5))
t4 = tuple([i for i in range(10)])
t5 = tuple(range(1,10))
t6 = tuple(i for i in(1,2,3))
t7 = tuple(i for i in (1,2,3))
print(t1)
print(t2)
print(t3)
print(t4)
print(t5)
print(t6)
print(t7)
运行结果如下:
('h', 'e', 'l', 'l', 'o')
(2, 3, 4)
(3, 4, 5)
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
(1, 2, 3, 4, 5, 6, 7, 8, 9)
(1, 2, 3)
(1, 2, 3)

#tuple解封
x,y,z = (2,'hello',3.14)
print(x)
print(y)
print(z)
运行结果如下:
2
hello
3.14

（4）可以用tuple删除指向tuple对象的变量,减少该对象的引用计数

（5）不能修改一个对象是指不能修改其每个元素的值,这些元素实际上也是实际对象的引用,如果tuple中某个元素引用了一个可修改对象,则可以修改它引用的对象

a = (3.14,[1,2,3])
a[1].append(4)
print(a)
运行结果如下:
(3.14, [1, 2, 3, 4])

（6）和str list 一样 可以用for in遍历一个tuple对象

（7）也有max min sum count index等方法

二、集合set

（1）集合是无序不重复的元素容器类型

（2）set中的元素没有顺序,所以无法通过下标访问其中的元素,但可以检查一个元素是否在这个集合里面

（3）set中不允许出现重复的元素,因此可以用set对list或tuple中的重复元素进行去重

（4）可以进行数学意义上的交 并 差 对称差运算

s = {
    
    2,3.14,'hello'}
print(type(s))
运行结果如下:
<class 'set'>

（5）集合中的元素必须是可哈希的 list对象是不可哈希的 因此集合中不能包含list对象（这个根据不同的使用方法可能不一样，还是要自己实践一下下的。）

（6）内置函数set() 可以创建一个set对象 其参数可以是一个list tuple 字符串 另一个set对象或其他可迭代对象

（7）同样可以给set传递一个list解析式

s = set([x for x in range(10)])
print(s)
运行结果如下:
{
    
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

（8）如果要创建一个空的set对象,需要用set()方法

s1 = set()
s2 = {
    
    }
print(type(s1))
print(type(s2))
运行结果如下:
<class 'set'>
<class 'dict'>

（9）可以用for 遍历set的元素 , set中也有内置函数len() max()， min() ，sum()。

（10）用add() 添加一个对象 用 remove() 移除一个对象

s = {
    
    1,2,3,4}
s.remove(2)
print(s)
运行结果如下:
{
    
    1, 3, 4}

（11）如果用remove()删除的值不存在 则会产生一个异常 而discard()则不会

（12）可以用update()一次添加多个值 update() 方法的参数是一个可迭代对象 如list tuple str 等

s = {
    
    1,2,3}
l = [4,5,6]
s.update(l)
print(s)
运行结果如下:
{
    
    1, 2, 3, 4, 5, 6}

（13）如果要删除一个set对象中的所有元素 可以使用clear() 方法

（14）ssubset() issuperset() 方法可以用来判断一个set对象表示的集合 是否是另一个 set对象的子集或超集

（15）isdisjoint()方法判断两个集合是否有交集 只有当二者交集是空集时 才为True

A = {
    
    1,2,3}
B = {
    
    1,2,3,4,5}
C = {
    
    4,5}
print(A.issubset(B))
print(B.issuperset(A))
print(B.issubset(A))
print(A.isdisjoint(B))
print(A.isdisjoint(C))
运行结果如下:
True
True
False
False
True

（16）set运算符操作

A = {
    
    1,2,3}
B = {
    
    1,2,3,4,5}
print(A<B)#A是B的子集吗?
print(B>A)#B是A的超集吗？
print(A>B)#B是A的子集吗?
运行结果如下:
True
True
False

（17）同样的 == != >= <=都可以用来判断两个对象集合的大小(是否相等)

（18）in not in 可以判断一个值是否在一个集合里面

（19）set的集合运算

注：两个集合的对称差是旨在两个集合中的一个集合出现的值构成的集合.

A = {
    
    1,2,3}
B = {
    
    4,5,6}
C = A.union(B)#并集运算
D = A|B#并集运算
E = A.intersection(B)#交集运算
F = A&B#交集运算
G = A-B#差集运算
H = A.difference(B)#差集运算
I = A.symmetric_difference(B)#对称差运算
J = A^B#对称差运算
print(C)
print(D)
print(E)
print(F)
print(G)
print(H)
print(I)
print(J)

运行结果如下:
{
    
    1, 2, 3, 4, 5, 6}
{
    
    1, 2, 3, 4, 5, 6}
set()
set()
{
    
    1, 2, 3}
{
    
    1, 2, 3}
{
    
    1, 2, 3, 4, 5, 6}
{
    
    1, 2, 3, 4, 5, 6}

三、字典dict

（1）创建字典对象

d = {
    
    }
d1 = dict()
d2 = {
    
    '李白':12,'杜甫':23}
d3 = dict(李白= 12,杜甫 = 23)
d4 = {
    
    x:x**3 for x in range(3)}
print(d)
print(d1)
print(d2)
print(d3)
print(d4)
运行结果如下:
{
    
    }
{
    
    }
{
    
    '李白': 12, '杜甫': 23}
{
    
    '李白': 12, '杜甫': 23}
{
    
    0: 0, 1: 1, 2: 8}

注：用dict()创建dict对象时,如果按照关键字参数传递键值,则其关键字必须是一个有效的标识符,而不是其他的表达式.这里的 “李白”就是一个标识符

（2）formkeys()可以用于创建dict对象：dict.fromkeys()(iterable,value=None)，这种方式创建的所有键对应值是一样的

d = dict.fromkeys(['Python','Java','C++'],'好好学')
print(d)
运行结果:
{
    
    'Python': '好好学', 'Java': '好好学', 'C++': '好好学'}

（3）获取建的值的方法就是用[] 如果找不到会报错 用get()方法可以得到一个键对应的值,如果找不到就返回该函数的第二个参数设置的默认值

d = {
    
    'Libai':"李白",'dufu':"杜甫"}
print(d.get('Libai'))
print(d.get("2333","找不到"))#如果不写第二个参数,默认是None 
运行结果如下:
李白
找不到

（4）通过下标插入一个键值

d = {
    
    'a':"A","b":"B"}
print(d)
d['c'] = "C"
print(d)
运行结果如下:
{
    
    'a': 'A', 'b': 'B'}
{
    
    'a': 'A', 'b': 'B', 'c': 'C'}

（5）update()方法可以插入或更新一个或多个键值对

d = {
    
    'xusong':100}
d.update({
    
    'xusong':1000})
print(d)
d.update(dict({
    
    'xusong':10000}))
print(d)
d.update(xusong=(100000))
print(d)
d.update({
    
    'python':3.14})
print(d)
d.update({
    
    'java':112,'go':123})
print(d)
运行结果如下:
{
    
    'xusong': 1000}
{
    
    'xusong': 10000}
{
    
    'xusong': 100000}
{
    
    'xusong': 100000, 'python': 3.14}
{
    
    'xusong': 100000, 'python': 3.14, 'java': 112, 'go': 123}

（6）可以用del() pop() 方法删除一个键对应的键值对 pop会返回被删除的键对应的值

d = {
    
    '1':2,'3':4,'5':6}
del d['1']
print(d)
print(d.pop('5'))
print(d)
运行结果如下:
{
    
    '3': 4, '5': 6}
6
{
    
    '3': 4}

（7）可以用clear方法删除所有键值对

d = {
    
    '1':2,'3':4}
d.clear()
print(d)
运行结果如下:
{
    
    }

（8）keys() values() items() 方法可以分别返回一个dict对象的所有键,所有值,所有键值对的可迭代对象

d = {
    
    '1':2,'3':4}
print(d.keys())
print(d.values())
print(d.items()) 
运行结果如下:
dict_keys(['1', '3'])
dict_values([2, 4])
dict_items([('1', 2), ('3', 4)])

（9）用for in循环可以遍历一个dict对象的每一个键

d = {
    
    '1':2,'3':4}
for i in d:
	print(i)
for i in d.keys():
	print(i)
	print(d[i])
for i in d.values():
	print(i)
for i,j in d.items():
	print(i,'--->',j)
运行结果如下:
1
3
1
2
3
4
2
4
1 ---> 2
3 ---> 4

（10）内置函数len() 查询dict对象的元素个数、 str()将一个dict对象转化成一个字符串表示

d = {
    
    '1':2,'3':4}
print(len(d))
print(str(d))
print(type(str(d)))

运行结果如下:
2
{
    
    '1': 2, '3': 4}
<class 'str'>

（11）#函数dict接受两个对象变成一个dict，用in检测dict对象是够包含某个键,但无法检测值是否在dict对象中

d = dict(zip(('a','b','c'),[1,2,3]))
print(d)
print('a' in d)
print('3' in d)
print('f' in d)
运行结果如下:
{
    
    'a': 1, 'b': 2, 'c': 3}
True
False
False