一、元祖

1、什么是元祖（tuple)

Python提供的容器类型数据类型，不可变并且有序。（元祖就是不可变得列表）

不可变 - 不支持增删改，只支持查

有序 - 每个元素对应一个确定的下标

2、字面量和元素

(元素1, 元素2, 元素3, 元素4, ……)

其中的元素可以是任何类型的数据，并且类型可以不一样，同样的元素可以有多个。

point = (100, 30)
print(point, type(point))

注意：

  1. 空的元祖：()
tuple1 = ()
  1. 只有一个元素的元祖，要在后面加逗号。
tuple2 = (100,)
print  (tuple2, type(tuple2))  # (100,) <class 'tuple'>
  1. 直接将多个元素用逗号隔开，不加小括号表示的也是一个元祖。
tuple3 = 1, 2, 3
print(tuple3, type(tuple3))
3、元祖获取元素和列表一样
tuple4 = ('成都', '绵阳', '南充', '广元')
print(tuple4[1], tuple4[-1])

遍历

for city in tuple4:
    print(city)
    
for index in range(len(tuple4)):
	print(tuple4[index])

补充：特殊的获取方式

  1. 变量1, 变量2, 变量3… = 元祖 ---- 用前面变量依次获取元祖元素的值。
    要求前面的变量个数和元祖的个数一致。
point = (100, 200)
x, y = point	# x,y = (100, 200) <===> x,y = 100,200
print(x, y)
  1. 变量1，*变量2 = 元祖
    通过带*的变量获取元祖中剩余的部分,带*的变量只能有一个，不带*的能够有多个。
name , *socres = ('小明', 100, 200, 23, 55)
print(name, scores)  	# 小明 [100, 200, 23, 55]

name, num, *scores = ('小明', 100, 200, 23, 55)
print(name, num, scores)		# 小明 100 [200, 23, 55]

补充：*的用法

  1. 取元祖和列表中的数据
nums1  = (1, 2, 3)
nums2  = (11, 22, 33)
print(*nums1， *nums2) # 1 2 3 11 22 33
4、相关运算

+，*

in/not in

len(),max(),min(),sum(),tuple()

tuple1 = (1, 2, 3)
tuple2 = ('a', 'b')
print(tuple1 + tuple2)
print(tuple1*3)
print('a' in tuple2)

能够转换成列表的必须是序列。

5、排序

sorted(序列) - 对序列中的元素排序，产生一个新的列表（不管是什么排序，排完后都是列表）

new_nums = sorted('sdgfdsfssqazvzvl')
print(new_nums)
# ['a', 'd', 'd', 'f', 'f', 'g', 'l', 'q', 's', 's', 's', 's', 'v', 'v', 'z', 'z']

注意：
列表.sort() – 对原列表修改排序

sorted(列表) – 原列表不会变动，产生一个新的列表

join的使用

字符串.join(序列) - 将序列中的元素取出，用指定的字符串连接在一起。要求序列中的元素必须是字符串。

应用：将排序后的元祖连接成一个字符串。

new_nums = sorted('sdgfdsfssqazvzvl')
new_nums = ''.join(new_nums)
print(new_nums) 	# addffglqssssvvzz <class 'str'>

二、字典

1、什么是字典（dict）

Python提供的容器型数据类型，可变并且无序

可变 - 支持元素的增删改

无序 - 不支持下标操作

2、字面量和元素

用大括号括起来，里面有多个键值对，每个键值对就是字典的元素。

{key1:value1, key2:value2, key3:value3 …}

键值对 - 键/key : 值/value （键值对）；键值对必须成对出现，而且键值对脱离字典没有意义。

键 - 必须是不可变的，而且是唯一的。实际一般将字符串作为键。

值 - 可以是任意类型的数据

注意：字典存储数据，实质是通过值来存储的。key是值对应的标签和获取的方式。

dict1 = {} # 空字典
dict1 = {'a' : 100, 'b' : 200, 'c': 200}
print(dict1)

以下代码报错：

dict2 = {[1,2] : 23}
# 	TypeError: unhashable type: 'list'
3、用字典还是用列表

什么时候用字典：多个没有相同意义的数据（需要区分），就使用字典。字典可以用key来区分。例如：保存一个人的信息。

什么时候用列表：存储的多个数据是相同的或者相同意义的数据，不需要区分，就使用列表。

三、相关操作

1、查（获取）

注意：字典中的键值对单独拿出来没有任何意义

a、字典[key] - 获取字典中key对应值

注意：当key不存在的时候，会报错。

car = {'color' : '黄色', 'type' : '跑车', 'price' : 50000}
print(car['color'])
print(car['speed'])			# KeyError: 'speed'
b、get

字典.get(key) - 获取字典中key对应值当key不存在的时候不会报错，并且取到一个默认值None

字典.get(key, 值1) - 获取字典中key对应值；当key不存在的时候不会报错，并且取到指定的值1

car = {'color' : '黄色', 'type' : '跑车', 'price' : 50000}
print(car.get('type'))
print(car.get('speed'))		
print(car.get('speed' , '没有这个属性'))
c、遍历字典

直接通过for in遍历字典取到的是key

dict1 = {'a' : 10, 'b' : 20, 'c' : 30}
# 遍历字典取到的是key
for key in dict1:
    print(key, end = ' ')
    print(dict1[key])

遍历value

dict1 = {'a' : 10, 'b' : 20, 'c' : 30}
for value in dict1.values():
    print(value)
    
# 遍历字典的items(),直接获取key 和 value  （不建议使用)  
for key,value in dict1.items():
    print(key, value)
2、增、改

a、字典[key] = 值 - 当key不存在就是添加键值对；当key存在的时候就是修改key对应的值

movie = {'name' : '盗梦空间', 'type' : '卡通', 'time' : 109}
# 添加
movie['score'] = 7.9
print(movie)

#修改
movie['type'] = '搞笑'
print(movie)
3、删除（删除键对值）

a、del 字典[key] - 删除字典中指定的key对应的键值对

movie = {'name' : '盗梦空间', 'type' : '卡通', 'time' : 109}
del movie['time']
print(movie)

b、字典.pop(key) - 取出字典中key对应的值

movie = {'name' : '盗梦空间', 'type' : '卡通', 'time' : 109}
name =  movie.pop('name')
print(movie, name)

四、相关运算

1、比较运算符

字典不支持+ 和 *，支持比较运算。

注意：判断两个字典是否相等，只看键值对是否一样，不管键值对顺序。

字典不支持>和<符号。

print({'a' : 11, 'b' : 22} == {'a' : 11, 'b' : 22})
print({'a' : 11, 'b' : 22} == {'b' : 22, 'a' : 11}) # True
2、in 和 not in

key in 字典 – 判断字典中指定的key是否存在

key not in 字典 – 判断字典中指定的key是否不存在

dict1 = {'a' : 1, 'b' : 2, 'c' : 3}
print('a' in dict1)		#True
3、len()，max()，min()，dict()

dict(数据) - 数据要求是序列，并且序列中的元素都是有两个元素的子序列

print(dict([(1, 2), ('a', 3), [3, 33]]))
dict1 = {'a' : 1, 'b' : 2, 'c' : 3}
print(len(dict1))	# 返回键值对
print(max(dict1))	# 返回字典中key的最大值

字典转列表、元素和集合都是将字典中的key取出来作为列表、元祖和集合的元素。

4、相关方法
a、字典.clear() - 清空字典

注意：清空容器推荐使用clear(),而不是重新赋一个空的容器。

dict1 = {'a' : 1, 'b' : 2, 'c' : 3}
dict1.clear()

# 只有容器本身不存在的时候使用
dict2 = {}
b、字典.copy()

赋值字典的中元素，产生一个新的字典,赋值后相互不影响。

直接赋值，修改其中一个的元素，会影响另外一个。

dict1 = {'a' : 1, 'b' : 2, 'c' : 3}
dict2 = dict1
print(dict2)
dict2['a'] = 9
print(dict1)
print(dict2)
c、dict.fromkeys(序列, 值)

以序列中的元素为key，值作为value，创造一个字典。

new_dict = dict.fromkeys('abc', 100)
print(new_dict)	# {'a': 100, 'b': 100, 'c': 100}
d、

字典.keys() - 将字典所有的key取出产生一个新的序列

字典.values() - 将字典所有的values取出产生一个新的序列

字典.items() - 将字典所有的key和values取出产生一个新的序列

e、字典.setdefault(key, value = None)

字典.setdefault(key) - 当key不存在的时候，添加键值对key：None

字典.setdefault(key, value = None) - 当key不存在的时候，添加键值对key：Value

注意：这个操作当key存在的时候，不会修改。

f、字典1.update(字典2)

使用字典2中的键值对去更新键值对1；

如果字典2中的key，字典1中本身存在就修改，不存在就添加

dict1 = {'name' : 'xiaohu', 'color' : 'black', 'height' : 170}
dict1.update({'height' : 180})
print(dict1)

五、集合

1、说明是集合（set）

可变的、无序的；元素必须是唯一的，并且不可变。

2、字面量

{元素1, 元素2, 元素3…}

set1 = {1, 23, 'abc'}
print(set1)

# 空集合
set2 = set()
print(type(set2))
# 集合自带去重功能
list1 = [1, 2, 1, 3, 3, 4]
list1 = list(set(list1))
print(list1)
3、增删改查
a、查

集合不能单独的获取单个元素，只能一个一个的遍历

for item in set1:
	print(item)
b、增

a、集合.add(元素) - 在集合中添加指定的元素

set1 = {1, 28, 34}
set1.add('abd')
print(set1)

b、集合.update(序列) - 将序列中的元素添加到集合中

c、删

集合.remove(元素)

删除集合 中指定的元素

set1 = {1, 23, 33, 90}

set1.remove(90)

print(set1)
4、数学集合运算

名称

说明

set1 = {1, 2, 3, 4} ; set2 = {4, 6, 7, 8}

交集

两个集合公共的部分

set1 & set2 结果为{4}

并集

两个集合合并在一起产生新的集合

set1 | set2 结果为{1, 2, 3, 4, 6, 7, 8}

差集

去掉集合1中包含集合2中的部分

set1 - set2 结果为{1, 2, 3}

补集

两个集合的并集去除并集部分

set1 ^ set2 结果为{1, 2, 3, 6, 7, 8}

子集

不断一个集合是否包含另一个集合

set1> set2 判断集合1是否包含集合2，False