1.元祖

1.什么是元祖

使用（）将多个元素扩起来，多个元素之间用逗号隔开
a.
容器，可以同时存储多个数据，不可变的，有序的
不可变 ---> 不能增删改
有序 ---> 可以通过下标获取元素

b.
元素，可以是任何类型的数据

tuple1 = (1, 'yue',True,[1, 2],lambda s:s*2)
print(tuple1)
# (1, 'yue', True, [1, 2], <function <lambda> at 0x002E9AE0>)

注意

如果元祖的元素只有一个的时候，必须在元素的后面加逗号

tuple2 = (100,)
print(type(tuple2))
# <class 'tuple'>

多个数据直接用逗号隔开，表示也是一个元祖

tuple2 = 10, 20,'abc'
print(tuple2, type(tuple2))
# (10, 20, 'abc') <class 'tuple'>

2. 元素的查

元祖的元素不支持增删改
列表获取元素的方式，元祖都支持：元祖[下标]，元祖[:],元祖[::]

tuple2 = ('星期一', '星期二', '星期三', '星期四')
print(tuple2[1])
print(tuple2[2:])
print(tuple2[::-1])

for item in tuple2:
    print(item)

index = 0
while index < len(tuple2):
    print(tuple2[index])
    index += 1
# 星期二
# ('星期三', '星期四')
# ('星期四', '星期三', '星期二', '星期一')
# 星期一
# 星期二
# 星期三
# 星期四
# 星期一
# 星期二
# 星期三
# 星期四

补充：获取部分元素
可以通过相同的变量个数，来一一获取元祖中的元素

x, y = (10, 20)
print(x, y)
# 10 20
# 1.应用：交换两个数的值
a = 10
b = 20

# 方法1：
t = a
a = b
b = t

# 方法2：
a, b = b, a # a, b = (b, a) = (20, 10)

可以通过在变量前加*来获取部分的元素

tuple2 = ('小明', 90, 89, 67, 100)
name, *score = tuple2
print(name, score)
# 小明 [90, 89, 67, 100]

tuple2 = ( 90, 89, 67, 100, '小明')
*score, name = tuple2
print(score, name)
# [90, 89, 67, 100] 小明

tuple2 = ('boy', '123213213', 90, 89, 67, 100, '小明')
a, b, *score, name = tuple2
print(a, b, score,)
# boy 123213213 [90, 89, 67, 100]

(了解)
可以通过在列表或者元祖前加*，来展开列表中的元素

tuple3 = (1, 2, 3, 4)
print(*tuple3)
# 1 2 3 4

list1 = ['abc', 100, 200]
print(*list1)
# abc 100 200

3.元祖的运算

+， *， ==， is， in， not in ---> 和列表一样

print((1, 2,3) + ('a', 'b'))
print((1, 2) * 3)
print((1, 2, 3) == (1, 2, 3))
print((1, 2, 3) is (1, 2, 3))
print(1 in (1, 2, 3))
print(1 not in (1, 2, 3))
# abc 100 200
# (1, 2, 3, 'a', 'b')
# (1, 2, 1, 2, 1, 2)
# True
# False
# True
# False

4. len(),max(),min()

tuple3 = 10, 20, 30, 89, 90
print(len(tuple3))
print(max(tuple3))
print(min(tuple3))
# 5
# 90
# 10

6.tuple()

所有的序列都可以转换成元祖，注意，字典只能讲key值转换成元祖元素

print(tuple('asdasd'))
print(tuple([1, 23, 41]))
print(tuple(range(5)))
print(tuple({'a':100, 'b' : 200}))
# ('a', 's', 'd', 'a', 's', 'd')
# (1, 23, 41)
# (0, 1, 2, 3, 4)
# ('a', 'b')

7.sorted()

可以通过sorted（）方法，对元祖进行排序，产生一个新的列表

tuple3 = 10, 230, 3123, 123, 12
new = sorted(tuple3)
print(new, tuple3)
# [10, 12, 123, 230, 3123] (10, 230, 3123, 123, 12)

2.认识字典

1.什么是字典(dict)

字典是一个容器类的数据类型，可以用来存储多个数据（以键值对的形式储存）。可变的，无序的
{ key1:value1, key2:value2...}
可变 ---> 可以增删改
无序 ---> 不能通过下标获取值

键（key）: 用来定位值的，要求只能是不可变的数据类型（数字，字符串，元祖），是唯一的
值（value）: 存储的数据。可以是任何类型的数据

person1 = ['avicii', 18, 90, 100, '12321453123' ]
person2 ={'name': "avicii", 'age': 18, 'face': 90, 'score': 100, 'number': 12321453123}
dict1 = {10: 893, 'abc': 100, (1, 22): 'abc'}

3.字典的增删改

1.查（获取键值相对的value）

获取字典的值，必须通过key来获取

a.字典[key] ---> 获取key对应的值
注意： key值必须是存在的，否则会报keyError

student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'sex': 'boy'}
print(student['name'])  # 小明
print(student['sex'])  # boy
# print(student['xxx'])  KeyError: 'xxx'

b.字典.get(key) ----> 通过key获取值
注意：key值不存在的时候不会报错，结果是None

print(student.get('age'), student.get('study_id'))  # 30 py001
print(student.get('score'))  # None

确定key一定存在就使用[]语法，key可能不存在的时候用get语法

c.直接遍历字典（推荐使用）
通过for-in遍历字典拿到的是key值

for x in student:
    print(x)
# name
# age
# study_id
# sex
# 小明

d.其他遍历方式(多耗CPU，不推荐使用)

# 直接遍历拿到值
for value in student.values():
    print(value)
# 30
# py001
# boy

# 直接拿到key 和 value
for key,value in student.items():
    print(key, value)
# name 小明
# age 30
# study_id py001
# sex boy

2.增（添加键值对）

字典[key] = 值 （key不存在）

car = {}
car['color'] = 'yellow'
print(car)
# {'color': 'yellow'}

car['price'] = 300000
print(car)
# {'color': 'yellow', 'price': 300000}

3.修改（修改key值）

字典[key] = 值（key存在）

car['color'] = 'red'
print(car)
# {'color': 'red', 'price': 300000}

4.删（删除键值对）

a.del 字典[key] ---> 通过key删除键值对

student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'sex': 'boy'}
del student['age']
print(student)
# {'name': '小明', 'study_id': 'py001', 'sex': 'boy'}

b.pop(key) ---> 取出key对应的值（实质还是删除key对应的键值对）

student.pop('name')
print(student)
# {'study_id': 'py001', 'sex': 'boy'}

4.字典的相关操作

1.字典相关运算

==: 判断两个字典的值是否相等
is：判断两个字典的地址是否相等

in 和 not in : key in 字典 / key not in 字典

dict1 = {'a': 1, 'b': 2}
print({'a': 100, 'b': 200} == {'b': 200, 'a': 100}) # True
print({'a': 100, 'b': 200} is {'b': 200, 'a': 100}) # False
print('abc' in {'abc': 100, 'b': 200}) # True
print('abc' in {'100': 100, 'b': 200}) # False

2.字典相关的函数和方法

len(字典) ---> 获取键值对的个数

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(len(dict1))  # 4

字典.clear（） --> 清空字典

dict1.clear()
print(dict1)
# {}

3.字典.copy() ---> 将字典中的键值对复制一份产生一个新的字典

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict2 = dict1.copy()
print(dict1, dict2 is dict2)
# {'a': 1, 'b': 2, 'c': 3, 'd': 4} True

4.字典.fromkeys(序列,值) ---> 创建一个字典，将序列中的每个元素作为key，值作为value

dict3 = dict.fromkeys('xyz', 100)
dict3 = dict.fromkeys(['aa', 'bb', 'cc'], (1, 2))
print(dict3)
# {'aa': (1, 2), 'bb': (1, 2), 'cc': (1, 2)}

字典.get(key) ----> key不存在取None
字典.get(key,默认值) ---> key不存在取默认值

student = {}
print(student.get('name'))
print(student.get('name', '无名'))
# None
# 无名

6
字典.values() ---> 返回所有值对应的序列
字典.keys() ----> 返回虽有键对应的序列
字典.items() ----> 将键值对转换成元祖，然后作为一个序列的元素
注意：返回的都不是列表，是其他类型的序列

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
items = list(dict1.items())
print(items, type(items))
print(dict1.items(), type(dict1.items()))
# [('a', 1), ('b', 2), ('c', 3), ('d', 4)] <class 'list'>
# dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)]) <class 'dict_items'>

字典.setdefault(key) ---> 添加键值对，键是key，值是None
字典.setdefault(key,值) ----> 添加键值对，键是key，值是value
注意：key存在的时候，对字典不会有任何操作（不会修改key对应的值）

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict1.setdefault('a')
print(dict1)
dict1.setdefault('aa', 100)
print(dict1)
# {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'aa': 100}

8.字典1.update(字典2) ---> 使用字典2中键值对去更新字典1(已经存在的key就更新，不存在的就添加)

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 200, 'c': 100}
dict1.update(dict2)
print(dict1)
#  {'a': 1, 'b': 200, 'c': 100}

5.集合

1. 什么是集合（set）

容器.可以同时存储多个数据，可变的，无序的，元素是唯一的
可变 ----> 增删改
无序 ----> 不能通过下标获取元素
唯一 ---> 自带去重的功能
{元素1，元素2....}
元素：只能是不可变的数据

set1 = {10, 20, 'abc', (10, 200), 10}
print(set1)
# {(10, 200), 10, 20, 'abc'}
# set2 = {} 这个是空的字典

2.集合的增删改查

a.查（获取元素）

集合不能单独获取一个元素，也不能切片，只能通过for in 来遍历

for x in set1:
    print(x)
    # (10, 200)
    # 10
    # 20
    # abc

b.增(添加元素)

集合.add（元素） ----> 在集合中添加一个元素

set1 = {1, 2, 3}
set1.add(4)
print(set1)
# {1, 2, 3, 4}

集合1.update(集合2) ---> 将集合2中的元素添加到集合1当中
集合1.update(序列) ---> 将集合2中的序列添加到集合1当中

set1.update({'a', 'b'})
print(set1)

set1.update('3123')
print(set1)

set1.update(['asd', 'asds'])
print(set1)

set1.update({'name': 1,'das': 21})  # 字典只加Key
print(set1)
# {1, 2, 3, 4, 'b', 'a'}
# {'1', 1, 2, 3, 4, 'b', '3', 'a', '2'}
# {1, 2, 3, 4, 'b', 'asd', '2', '1', '3', 'a', 'asds'}
# {1, 2, 3, 4, 'b', 'das', 'asd', 'name', '2', '1', '3', 'a', 'asds'}

3.删（删除元素）

集合.remove(元素) ---> 删除指定的元素

set1.remove(1)
print(set1)
# {2, 3, 4, 'b', 'das', 'asd', 'name', '2', '1', '3', 'a', 'asds'}

4.改（集合不能改）

6.集合相关的数学运算

集合相关的运算：是否包含，交集、并集、差集、补集

1.包含

集合1 >= 集合2 ---> 判断集合1中是否包含集合2
集合2 <= 集合1 ---> 判断集合2中是否包含集合1

set1 = {1, 2, 3, 4, 5, 10}
set2 = {3, 4, 5, 6}
print(set1 >= set2)
# False

2.交集 - > &

&： 求两个集合公共的部分

set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3, 10, 20}
print(set1 & set2)
# {1, 2, 3}

3.求并集

| ----> 求两个集合的和

print(set1 | set2)
# {1, 2, 3, 4, 5, 10, 20}

4.求差集

集合1-集合2 ---> 求集合1中除了集合2以外的部分

print(set1-set2)
# {4, 5}

5.求补集

^ ---> 求两个集合除了公共部分以外的部分

print(set1 ^ set2)
# {20, 4, 5, 10}

7.类型的转换

1.整形

int()
浮点数、布尔、和部分字符串可以转换成整形
只有去掉引号后本身就是一个整数的字符串才能转换成整形

print(int('34'))
# print(int('34.5')) # 错误ValueError
print(int(+56))
print(int(-89))
# 34
# 56
# -89

2.浮点数

整数，布尔，部分字符串可以转换成浮点数
去掉的引号，本身就是一个数字的字符串才能转换成浮点数

print(float(100))  # 100.0
print(float(True))  # 1.0
print(float('32.123'))
# 100.0
# 1.0
# 32.123

3.布尔

所有的数据都可以转换成布尔
为空（None）为0的值转换成False,其他的数据都转换成True

print(bool('sadasd'))
print(bool(''))

num = 100
if num:
    print('是0')
if not num:
    print('是0')
# True
# False
# 是0

4 .字符串

所有的数据都可以转换成字符串
数据转换成字符串，就是在数据的最外面加引号

print(str(100))
print([str(True)])
print(str([1, 2, 3]))
print(str({'a': 1, 'b': 2}))
print([str(lambda x: x*2)])
# 100
# ['True']
# [1, 2, 3]
# {'a': 1, 'b': 2}
# ['<function <lambda> at 0x00968FA8>'

5.列表

list()
序列才能转换成列表
将序列中的元素作为列表的元素，将字典的key作为列表的元素

print(list('asdasd'))
print(list((12, 32, 'asd')))
print(list({'a': 1, 'b': 2}))
print(list({'a': 1, 'b': 2}.items()))
# ['a', 's', 'd', 'a', 's', 'd']
# [12, 32, 'asd']
# ['a', 'b']
# [('a', 1), ('b', 2)]

6.元祖

tuple()
只能讲序列转换成元祖

print(tuple('dasdsad'))
print(tuple({'a': 1, 'b': 2}))
# ('d', 'a', 's', 'd', 's', 'a', 'd')
# ('a', 'b')

7.字典

dict()
序列的每个元素有两个元素的数据才能转换成字典

list1 = [(1, 2), ['a', 'b']]
tuple1 = ((1, 2), {2, 'a'})
print(dict(list1))
print(tuple1)
# {1: 2, 'a': 'b'}
# ((1, 2), {2, 'a'})

8.集合

set()
序列转换成集合，有去重功能

print(set([1, 231, 123, 43, 1, 21]))
# {1, 231, 43, 21, 123}