record

1.列表（list）

容器型数据类型（序列），可变、有序

2.元素

任何类型的数据都可以作为列表元素

3.元素的增删改查（*）

3.1.查

查单个元素：列表[下标]
查部分元素[切片]：列表[开始下标：结束下标：步长]，列表[：]，列表[：：-1]
遍历：直接遍历、遍历下标

3.2.增

列表.append(元素)、列表.insert(下标，元素)

3.3.删

del 列表[下标]
列表.remove(元素)
列表.pop() 列表.pop(下标)

3.4.改

列表[下标] = 新值

4.+，*，==，!=，in/not in，len()，list()

5.列表常用方法

5.1.count

列表.count(元素) - 统计列表中指定元素的个数，返回一个整数

5.2.extend

列表.extend(序列) - 将序列中的元素全部添加到列表中

nums = [1, 2, 3, 4, 5]
nums.extend('abc')
print(nums)
nums.extend([1,2,3])
print(nums)

5.3.index

列表.index(元素) - 获取指定元素对应的下标（如果元素有多个，只取第一个）
注意：如果元素不存在会报错！

5.4.reverse

列表.reverse() - 反向列表（直接修改原列表）
reversed(序列) - 反向序列（不修改原序列，产生新的序列对应的迭代器）

str1 = 'hello'
new_str = reversed(str1)
print(str1, ''.jion(list(new_str)))

字符串.join(序列)

5.5.sort

列表.sort() - 将列表中的元素升序排序（从小到大）
列表.sort(reverse = True) - 将列表中的元素降序排序（从大到小）
sorted(序列) - 排序的时候不修改原序列，产生新的序列
注意：能够进行排序的列表要求列表中的元素类型一致，并且支持比较运算

# sort
nums = [100,60,34,101]
nums.sort(reverse = True)
print(nums)
# sorted
nums = [100,60,34,101]
new_nums = sorted(nums)

print(nums)  # [100,60,34,101]
print(new_nums)  # [34,60,100,101]
new_nums = sorted(nums, reverse = True)
print(new_nums)  # [101,100,60,34]

str2 = 'helloworld'
new_str = sorted(str2)
print(new_str)
print(''.join(new_str))

5.6.clear

列表.clear() - 删除列表中所有的元素（清空列表）

nums = [100,60,34,101]
print(id(nums))
nums.clear()
print(nums,id(nums))
nums = []
print(nums,id(nums))

5.7.copy

列表.copy() - 相当于列表[:]，将列表中的元素拷贝一份产生一个新的列表（浅拷贝）

tuple(元祖)

1.什么是元祖(tuple)

元祖是python提供的容器型数据类型（序列），不可变，有序
元祖就是不可变的列表，一般保存一些不让修改的数据
(元素1，元素2，元素3……)

2.元素

2.1.空的元祖

没什么意义

2.2.元素个数是1的元祖:如果一个元祖中只有一个元素，这个元素后面必须加逗号！

tuple2 = (10,)  # (10,)

2.3.元祖数据中的()可以省略(多个数据用逗号隔开，也表示元祖)

tuple2 = 1, 2, 3, 4, 5
print(tuple2,type(tuple2))  # (1, 2, 3, 4, 5) <class 'tuple'>

3.获取元素：和列表一样

3.1.让变量的个数和元祖中元素的个数保持一致，来一一获取元祖中每个元素的值

point = (100, 50)
x, y = point
print('x:', x, 'y:', y)  # x: 100 y: 50

3.2.让多个变量同事获取元祖中的元素的时候，可以在一个变量前加*将这个变量变成一个列表，来获取不带*的变量获取后剩下的数据。

注意：带*的变量只能有一个

student = ('小明', 18, 99, 88, 77, 66)
name, age, *scores = student
print(name, age, scores)
"""
小明 18 [99, 88, 77, 66]
"""

dict(字典)

1.什么是字典（dict）

字典是python提供的容器型数据类型（序列），可变，无序
{键值对1， 键值对2， 键值对3， ……} - 字典的元素就是键值对
键值对 - 以'键：值'的形式成对出现
键(key) - 要求不可变，唯一（建议使用字符串作为key，用来对值进行说明和区分的）
值(value) - 任何类型的数据都可以作为值

2.元素的操作

2.1.查 - 获取值

字典[key] - 获取字典中key对应的值(value)（如果key不存在会报错！）
字典.get(key) - 获取字典中key对应的value（如果key不存在不报错，结果是None）
字典.get(key, 默认值) - 获取字典中key对应的value（如果key不存在不报错，结果是默认值）

2.1.1.遍历字典

直接通过for循环遍历字典的时候，获取到的是所有的key
1.直接遍历（只用这个）
2.间接遍历
values()、items()

2.2.增/改

字典[key] = value - 如果key存在，修改key对应的值；如果key不存在，添加键值对

2.3.删

1.del 字典[key] - 删除字典中指定key对应的键值对。如果key不存在会报错
2.字典.pop(key) - 取出字典中key对应的值。如果key不存在会报错

2.4.字典相关操作

2.4.1.运算符：不支持数学运算，比较运算符只支持比较相等、不支持比较大小

2.4.2.in / not in

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

2.4.3.len

一个键值对算一个长度

2.4.4.dict

能转换成字典的数据要求：数据本身是序列，序列中的每个元素也是长度是2的序列，并且小序列中的第一个元素是不可变的

2.5.相关方法

1.clear
字典.clear() - 清空字典
2.copy
字典.copy() - 拷贝字典中的键值对产生一个新的字典
3.fromkeys
dict.fromkeys(序列， 值) - 创建一个新的字典，字典的key是序列的元素，key对应的value是值
4.keys, values, items
字典.key() - 获取字典中所有的key，结果一个序列
字典.values() - 获取字典中所有的value，结果是一个序列
字典.items() - 获取字典中的key和value，key和value以元祖的形式返回
5.setdefault
字典.setdefault(key,value) - 添加键值对（不能修改）
6.update
字典1.update(字典2) - 使用字典2中的键值对取更新字典

set（集合）

1.什么是集合(set)

容器型数据类型（序列），可变、无序

2.集合中的元素

{元素1， 元素2， 元素3， ……}
元素：不可变、唯一（自带去重功能）
注意：{}不能表示空的集合，set() - 空集合
集合可以去重

str1 = 'hedkahendgaksngessssded'
print(''.join(set(str1)))

list1 = [1,23,4,34,32,23,1]
print(list(set(list1)))

3.元素相关操作

3.1.查

集合不能单独获取制定的某一个元素，只支持遍历

3.2.增

集合.add() - 往集合中添加一个元素
集合.update(序列) - 将序列中的元素添加到集合中（自带去重）

3.3.删

集合.remove(元素) - 删除集合中指定的元素
注意：元素不存在会报错

3.4.数学集合运算（*）

3.4.1.并集：|

集合1|集合2 - 将两个集合中的元素合并产生新的集合

set1 = {1,2,3,4,5,6}
set2 = {4,5,6,7,8,9}
print(set1|set2)

3.4.2.交集：&

集合1&集合2 - 求两个集合公共的部分

set1 = {1,2,3,4,5,6}
set2 = {4,5,6,7,8,9}
print(set1&set2)

3.4.3.差集：-

集合1-集合2 - 获取集合1中除了集合2以外的部分

set1 = {1,2,3,4,5,6}
set2 = {4,5,6,7,8,9}
print(set1-set2)
print(set2-set1)

3.4.4.补集: ^

集合1^集合2 - 两个集合中除了公共部分以外的部分

set1 = {1,2,3,4,5,6}
set2 = {4,5,6,7,8,9}
print(set1^set2)

3.4.5.包含关系

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