一、元祖
1.基本概念
定义：
容器，可以同时存储多个数据，不可变的(不能进行增删改)，有序的(可以通过下标获取元素)，元素可以是任何数据类型字面量：
使用()将多个元素括起来，多个元素之间用逗号隔开
多个数据直接用逗号隔开，表示的也是一个元祖注意：如果元祖元素只有一个的时候，必须在元素的后面加逗号；如果多个数据直接用逗号隔开，表示的是一个元祖
*例子：
tuple1 = (1, 'yue', True, [1, 2], lambda s:s*2)
print(tuple1)
#(1, 'yue', True, [1, 2], <function <lambda> at 0x000001A92607FAE8>)
tuple2 = (100,)
print(type(tuple2))
#<class 'tuple'>
tuple2 = 10, 20, 'abc'
print(tuple2, type(tuple2))
#(10, 20, 'abc') <class 'tuple'>
2.元祖的查找
获取单个元素：
元祖[下标]获取多个元素：
元祖[:]，元祖[::]通过相同变量的个数，来一一获取元祖中的元素
应用：
交换两个数字：a, b = b, a
通过在变量前加*来获取部分的元素(适用于列表)例子：
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
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', 15300022673, 90, 89, 67, 100, '小明']
sex, tel, *score, name = tuple2
print(sex, name, score)
#boy 小明 [90, 89, 67, 100]
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(tuple) | 元祖元素个数 |
| max(tuple) | 返回元祖元素最大值 |
| min(tuple) | 返回元祖元素最小值 |
| tuple(字符，range,字典，集合,迭代器) | 将序列转换为元祖 |
二、字典
1.基本概念
定义：
字典是一个容器类的数据类型，可以用来存储多个数据(以键值对的形式存储)。可变的（可以增删改），无序的（不能通过下标获取值）字面量：
{key1:value1, key2:value2...}
键(key):
用来定位值的。要求只能是不可变的数据类型(数字，字符串，元祖...)。是唯一的
值(value):
存储的数据。可以是任何类型的数据例子：
person2 = {'name': 'yuting', 'age': 18, 'face': 90, 'score': 100, 'tel': '1547262889', 'name':'小花'}
dict1 = {10: 893, 'abc': 100, (1, 23): 'abc'}
print(person2)
#{'name': '小花', 'age': 18, 'face': 90, 'score': 100, 'tel': '1547262889'}
dict1 = {}
print(dict1)
#{}
2.字典的增删改查
- a.查
方法：
字典[key] ---> 获取key对应的值；key值必须是存在的，否则会报KeyError
字典.get(key) ---> 通过key获取值；key值不存在的时候不会报错，结果是None
for-in遍历字典拿到的是key值例子：
student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'sex': 'boy'}
print(student['name'])
print(student['sex'])
# print(student['score']) # KeyError: 'score'
#小明
#boy
print(student.get('age'), student.get('study_id'))
print(student.get('score'))
#30 py001
#None
for x in student:
print(x, student[x])
#name 小明
#age 30
#study_id py001
#sex boy
- b.增
方法：
字典[key] = 值（key不存在）例子：
car = {}
car['color'] = 'yellow'
print(car)
#{'color': 'yellow'}
car['price'] = 300000
print(car)
#{'color': 'yellow', 'price': 300000}
- c.改
方法：
字典[key] = 值（key存在）例子：
car['color'] = 'red'
print(car)
#{'color': 'red', 'price': 300000}
- d.删
方法：
del 字典[key] ---> 通过key删除键值对
字典.pop(key) ---> 取出key对应的值(实质还是删除key对应的键值对)例子：
student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'sex': 'boy'}
del student['age']
print(student)
#{'name': '小明', 'study_id': 'py001', 'sex': 'boy'}
name = student.pop('name')
print(student, name)
#{'study_id': 'py001', 'sex': 'boy'} 小明
3.字典的运算
运算：
==: 判断两个字典的值是否相等
is: 判断两个字典的地址是否相等
in 和 not in: key in 字典 / key not in 字典 ---> 判断key是否存在例子：
dic1 = {'a': 1, 'b': 2}
aa = dic1
print(dic1 is aa) # True
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, 'a': 200}) # True
print('abc' in {'100': 'abc', 'a': 200}) # False
4.字典的方法
| 方法 | 说明 |
|---|---|
| dict.values() | 返回所有值对应的序列 |
| dict.keys() | 返回所有键对应的序列 |
| dict.items() | 将键值对转换成元祖，作为一个序列的元素 |
| dict.fromkeys(序列, 值) | 创建一个字典，将序列中的每个元素作为key，值作为value |
| dict.setdefault(key,value) | 添加键值对，键是key，值是value |
| dict..update(dict1) | 使用字典2中键值对去更新字典1。(已经存在的key就更新，不存在就添加) |
| dict.clear() | 清空列表 |
| dict.copy() | 复制列表 |
三、集合
1.基本概念
定义：
容器，可以同时存储多个数据,可变的（增删改），无序的（不能通过下标获取元素）,元素是唯一的（自带去重的功能）字面量：
{元素1, 元素2...}
元素：只能是不可变的数据例子：
set1 = {10, 20, 'abc', (10, 200), 10}
print(set1)
#{(10, 200), 10, 20, 'abc'}
2.集合的增删查
- a.查
方法：
集合不能单独的获取一个元素，也不能切片，只能通过for-in来遍历例子：
for x in set1:
print(x)
#(10, 200)
#10
#20
#abc
- b.增
- 方法：
集合.add(元素) --> 在集合中添加一个元素
集合1.update(序列) --> 将序列中的元素添加到集合1中 - 例子：
- 方法：
set1 = {1, 2, 3}
set1.add(4)
print(set1)
#{1, 2, 3, 4}
set1.update({'a', 'b'})
print(set1)
#{1, 2, 3, 4, 'a', 'b'}
set1.update('0987')
print(set1)
#{1, 2, 3, 4, '8', '9', 'b', '7', 'a', '0'}
set1.update(['abc', 'aaa'])
print(set1)
#{1, 2, 3, 4, '8', '9', 'b', 'abc', '7', 'aaa', 'a', '0'}
set1.update({'name': 1, 'age': 18}) # 字典只添加key
print(set1)
#{1, 2, 3, 4, '8', '9', 'b', 'name', 'abc', '7', 'aaa', 'a', 'age', '0'}
- c.删
方法：
集合.remove(元素) --> 删除指定的元素例子：
set1.remove(1)
print(set1)
#{2, 3, 4, '8', '9', 'b', 'name', 'abc', '7', 'aaa', 'a', 'age', '0'}
3.集合的数学运算
| 符号 | 名称 | 说明 |
|---|---|---|
| >=,<= | 包含 | 判断集合1之中是否包含集合2 |
| & | 交集 | 求两个集合公共的部分 |
| 丨 | 并集 | 求两个集合的和 |
| - | 差集 | 求集合1中除了集合2以外的部分 |
| ^ | 补集 | 求两个集合除了公共部分以外的部分 |
四、类型转换
| 函数 | 说明 | 限制 |
|---|---|---|
| int() | 整型 | 浮点数、布尔、去引号整数的字符串可以转换成整型。 |
| float() | 浮点型 | 整数，布尔，去引号数字的字符串可以转换成浮点数 |
| bool() | 布尔 | 所有的数据，为空为0的值转换成False, 其他的数据都转换成True |
| str() | 字符串 | 所有的数据都可以转换成字符串，数据转换成字符串，就是在数据的最外面加引号 |
| list() | 列表 | 序列，将序列的元素作为列表的元素。字典转换成列表，将字典的key作为列表的元素 |
| tuple() | 元祖 | 序列，将序列的元素作为元祖的元素。字典转换成元祖，将字典的key作为元祖的元素 |
| dict() | 字典 | 序列的每个元素有两个元素的数据才能转换成字典 |
| set() | 集合 | 序列可以转换成集合 |
五、拷贝
1.浅拷贝
字面量：
copy.copy(对象)应用：
直接拷贝地址（切片和字典列表的copy方法都是浅拷贝）
2.深拷贝
字面量：
import copy
copy.deepcopy(对象):深拷贝应用：
将地址对应值拷贝，产生新的地址
