一、元组（Turple）

1.1、概念

定义

元组名 = （元素1，元素2，元素3）

注意事项

1. 使用小括号进行数据保存，所有元素包含在小括号内，元素与元素之间用“，”隔开
2. 不同元素也可以是不同的数据类型
3. 元素只包含一个元素的时候，末尾必须加“，”,否则返回的是唯一数据类型

1.2、常见操作

元组只支持查询操作，不支持增删改操作。

元组在Python中是一种不可变的、有序的数据容易。

tua = ()  # 定义空元组
print(tua, type(tua))  # () <class 'tuple'>
tua = (1)  # 元组包含一个元素时，末尾必须加“,”，否则返回的是<class 'int'>
print(tua, type(tua))  # () <class 'tuple'>

查询元素

1. in：判断某个元素是否存在与元组中，存在就返回True，不存在则返回False。
2. not in：判断某个元素是否存在与元组中，不存在就返回True，存在则返回False。
3. count()：统计指定元素在当前列表中出现的次数。
4. index()：返回指定元素所在位置的下标 ，如果查找的元素不存在则报错。
5. len()：求长度

li = ('a','b','b')
print('a' in li) # 判断某个元素是否存在与元组中
print(li.count('a'))
if 'a' in li:print(li.index('a')) #返回指定元素所在位置的下标

二、列表

1.1、概念

列表是最常用的 Python 数据类型，是处理一组有序项目的数据结构。也可以理解为他是一个可变的元组。或者说元组是一个不变的列表。

定义

列表名 = [元素1, 元素2, 元素3, …]

注意事项

1. 列表的所有元素放在一对中括号[]中，并使用逗号分隔开
2. 一个列表中的数据类型可以各不相同
3. 通过下标快速查找对应元素
4. 列表也可以进行切片操作

li = [1, 2, 'a', 'b']
print(li[2])  # 通过下标迅速查找对应元素
print(li[0:2])  # 对列表进行切片操作
for i in li:  # 列表迭代操作print(i)

1.2、常见操作

添加

append()：在列表末尾追加元素（常用）
**extend()：分散添加，将另外一个类型中的元素逐一添加 **
insert()：在指定位置插入元素，指定位置若有元素则原有元素后移。效率没有append高

list = ['a', 'b']
list.append('c')  # 在列表后面添加元素
list.extend('de')  # 分散添加，将另外一个类型中的元素逐一添加
list.insert(3, 5)  # 在位置3+1的地方插入元素
list.insert(13, 'Py')  # 若位置大于列表长度插入末尾
print(list)  # ['a', 'b', 'c', 5, 'd', 'e', 'Py']

extend():插入的一定是可迭代对象，可迭代对象指的是元组、列表、集合、字典还有字符串。

修改

列表名[下标] = 值

li = [1, 2, 'a', 'b']
li[0] = 'Hello'  # 修改第一个元组
print(li)

查找

in：判断指定数据是否存在列表中，返回值为布尔
not in：判断指定数据是否存在列表中，返回值为布尔
index()：返回指定元素所在位置的下标，如果查找的元素不存在报错
count()：统计指定元素在当前列表中出现的次数

li = [1, 2, 3]
print(2 in li)          # True
print(2 not in li)      # False
print(4 in li)          # False
print(4 not in li)      # True

li = [1, 2, 3, 4, 2]
print(li.index(2))       # 1
# print(li.index(5))     # 报错，ValueError: 5 is not in list(值错误：5不在列表中)
print(li.count(2))       # 2，出现2次
print(li.count(5))       # 0，出现0次

删除

del :根据下标删除，超出下标范围就报错。
remove()：根据元素的值进行删除，如果元素不存在则报错

li = [1, 2, 3, 4, 5]
del li[4]
print(li)                # [1, 2, 3, 4]
# del li[6]              # 报错，IndexError: list assignment index out of range(索引错误：列表下标超出范围)
del li # 删除整个列表

li = [1, 2, 3, 4, 3]
if 1 in li:li.remove(1)
print(li)  # [2, 3, 4, 3]

排序

sort()：将列表按特定顺序重新排列，默认从小到大
reverse()：倒序，将列表倒置，反过来

li = [2, 5, 3, 4, 1]
li.sort()
print(li)               # [1, 2, 3, 4, 5]
li1 = [2, 5, 3, 4, 1]
li1.reverse()
print(li1)              # [1, 4, 3, 5, 2]

列表推导式

[表达式 for 临时变量 in 列表]
根据列表生成指定需求的列表

li = []                  # 定义一个空列表
for i in range(1, 11):li.append(i)         # 把取出的i值放进列表中     
print(li)                # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

列表嵌套

含义：一个列表中又有一个列表

li = ['a','b','c',['d','e','f']]     # ['d','e','f']是里面的列表

三、集合

1.1、概念

集合（set）是一种基本的数据结构，用于存储不重复的元素。

定义

集合名 = {元素1, 元素2, 元素3…}
集合和字典都是用{}表示，空字典用{}定义，空集合用set()定义。

集合的特点

1. 无序：定义一个集合后，多次打印会发现顺序改变
2. 唯一：集合的元素不重复
3. 确定：集合中的元素必须可hash(散列)
   ** 常见的可hash类型：数值类型、字符串、元组 **
   ** 常见的不可hash类型：列表、字典、集合**

1.2、常见操作

添加元素

add()：添加元素，添加的是一个整体

s2 = {1, 2, 3, 4}
print("原集合:", s2)  # 原集合: {1, 2, 3, 4}
s2.add(5)
print('添加后', s2)   # 添加后 {1, 2, 3, 4, 5}
s2.add(2)
print('添加后', s2)   # 添加后 {1, 2, 3, 4, 5}，# 因为集合有自动去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进行任何操作。
# s2.add(5,6)        # 报错，一次只能添加一个元素
s2.add((5,6))        # 添加一个元组类型的元素
print('添加后', s2)   # 添加后 {1, 2, 3, 4, 5, (5, 6)}

update()：把传入的元素拆分，逐个放入集合中

s2 = {1, 2, 3, 4}
print("原集合:", s2)  # 原集合: {1, 2, 3, 4}
# s2.update(567)     #报错
s2.update('567')
print('添加后', s2)   # 添加后 {1, 2, 3, 4, '5', '6', '7'}

删除元素

remove()：选择删除的数字如果集合中有就删除，没有就会报错

s2 = {1, 2, 3, 4}
s2.remove(3)
# s2.remove(5)        # 报错(集合中没有元素5)
print("删除后:", s2)  # 删除后: {1, 2, 4}

discard()：选择要删除的元素，有就会删除，没有则不会发生改变，不会进行操作

s2 = {1, 2, 3, 4}
print("原列表:", s2)  # 原列表: {1, 2, 3, 4}
s2.discard(3)
print('删除后:', s2)  # 删除后: {1, 2, 4}
s2.discard(7)
print('删除后:',s2)   # 删除后: {1, 2, 4}

交集&，并集|

交集&：表示共有的部分

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a & b)          # {3, 4}

并集|：表示所有的都放一起，重复的不算

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a | b)          # {1, 2, 3, 4, 5, 6}

应用场景

可以用于快速去重

四、字典

1.1、概念

键值对形式保存，键和值之间必须用:隔开,键值对之间用,隔开

定义

字典名 = {键1: 值1, 键2: 值2}

dic = {'name': 'bingbing', 'age': 18}
print(type(dic))           # <class 'dict'>

注意事项

字典中的键具备唯一性，但是值可以重复。

1.2、常见操作

查看元素

**变量名[键名] **
**变量名.get(键名) **

dic2 = {'name': 'python', 'name2': 'java'}
# print(dic2[2])       # 不可以根据下标，字典中没有下标，查找元素需要根据键名，键名相当于索引
print(dic2['name'])    # python
# print(dic2['tel'])   # 报错，键名不存在

修改元素

字典名 [键名] = 值

d = {'name': 'python', 'age': 18}
d['age'] = 20    # 列表通过下标修改，字典通过键名修改
print(d)         # {'name': 'python', 'age': 20}

添加元素

**字典名 [键名] = 值 **：键名存在就是修改，不存在则是新增

删除元素

**del：删除指定键值对，键名不存在就会报错 **
**删除整个字典 **
**clear()：清空整个字典里面的东西，但保留了这个字典 **

d = {'name': '小明', 'age': 28}
del d['age']      
# del d['remark']      # 没有指定的键就会报错
print("删除后: ", d)   # 删除后:  {'name': '小明'}
del d # 删除整个字典
# print('删除后:' ,d)  # 报错

del 字典是删除整个字典，clear()，清空字典保留这字典。

其他操作

len()：求长度
keys()：返回字典里面包含所有键名
values()：返回字典里面包含所有值
items()：返回字典里面包含所有键值对(元组形式)的列表

p = {'name': 'PP', 'age': 33, 'qq': 123456}
print(len(p))  # 3，因为字典中有3对键值对
print(p.keys())  # dict_keys(['name', 'age', 'qq'])
print(p.values())  # dict_values(['PP', 33, 123456])
print(p.items())  # dict_items([('name', 'PP'), ('age', 33), ('qq', 123456)])

1.3、字典应用场景

使用多个键值对，存储描述一个物体的相关信息