1.可变类型：可以对该类型对象中保存的元素值进行修改，比如列表，字典都是可变类型
2.不可变类型：不可以对该类型对象中保存的元素值进行修改，只能通过给对象重新赋值来修改对象所保存的数据。这实际上是创建了一个新的不可变类型对象，而不是修改原对象的值，比如数字，字符串，元组都是不可变类型
3.赋值为同一对象的不可变类型实例拥有同样的内存地址，可以使用id函数查看内存地址
1.列表就是用[]括起来的多个元素的有序集合，各元素用逗号分开
2.如果一个列表不包含任何元素，即[]，则称为空列表
3.可以使用[]创建列表对象
ls = []
ls = [1,'2',[1,2,3]]
ls = list([1,2,3])
4.通过拼接运算可以将多个列表拼接到一起，生成一个新的列表
5.通过重复运算可以将一个列表重复指定次数，生成一个新的列表
print([1,2,3]+[4,5,6])
print([1,2,3]*3)
#[1, 2, 3, 4, 5, 6]
#[1, 2, 3, 1, 2, 3, 1, 2, 3]
1.在Python中，通过赋值运算实际上是将两个变量指向同一个对象，而不是将一个变量的值赋给另一个变量
2.当两个变量指向同一个对象后，我们通过一个变量修改对象的元素值，那么通过另一个变量访问对象时，访问到的元素值也是修改后的值
ls = [1,2,3]
lsCopy = ls
ls[0]=-1
print(ls,lsCopy)
#[-1, 2, 3] [-1, 2, 3]
3.为了避免上述情况，可以通过元素截取的方式实现列表元素的复制
ls = [1,2,3]
lsCopy = ls[:]
ls[0]=-1
print(ls,lsCopy)
#[-1, 2, 3] [1, 2, 3]
4.也可以利用 copy 模块中的 deepcopy 函数实现列表元素的复制
import copy
ls = [1,2,3]
lsCopy = copy.deepcopy(ls)
ls[0]=-1
print(ls,lsCopy)
#[-1, 2, 3] [1, 2, 3]
1.查找元素，可以通过index函数查找第一个匹配的元素下标，当不存在时程序会抛出错误
ls = [1,2,3,4,5]
print(ls.index(1))
2.插入元素，可以通过insert函数将一个元素插入到列表的指定位置，该方法直接修改原列表
ls = [1,2,3,4,5]
print(ls.insert(0,1))
print(ls)
#[1, 1, 2, 3, 4, 5]
3.删除元素，可以通过del关键字删除某个变量或列表中的某个元素
ls = [1,2,3,4,5]
del ls[0]
print(ls)
#[2, 3, 4, 5]
ls = [1,2,3,4,5]
del ls[0:3]
print(ls)
#[4, 5]
1.使用max方法和min方法可以分别获取列表的最大值和最小值
2.使用count方法可以获取指定值在列表中出现的次数
3.使用len方法可以获取列表的元素个数
ls = [1,2,3,4,5]
print(max(ls),min(ls))
print(ls.count(1))
print(len(ls))
#5 1
#1
#5
1，使用sort方法可以对列表元素按照指定规则进行排序，语法格式为：sort（key = None，reverse = False）
ls = [-1,0,-2,1,99,-99,2]
ls.sort(reverse = True)
print(ls)
[99, 2, 1, 0, -1, -2, -99]
2.可以通过设置key自定义排序规则，比如
ls = [-1,0,-2,1,99,-99,2]
ls.sort(key=lambda x:x**2,reverse = True)
print(ls)
[99, -99, -2, 2, -1, 1, 0]
1.元组就是用()括起来的多个元素的有序集合，各元素之间用逗号分隔
2.如果一个元组不包含任何元素，即()，则称为空元组
3.可以通过()创建元组，也可以使用内置方法tuple方法
4.如果使用()创建的元组中只包含一个元素，则需要在这唯一一个元素后面添加逗号，否则小括号会被系统认为是括号运算符，而不是在创建元组
t = ()
t = (1,2,3)
t = tuple((1,2,3))
t = (1,)
print(type(t))
#5.虽然元组中的元素不允许修改，但可以通过拼接运算将两个元组连接，生成一个新的元组，
6.元组同样也可以使用max，min，count，len等方法
t = (1,)
print(max(t),min(t))
print(t.count(1))
print(len(t))
#1
#1 1
#1
1.可以使用{}或者set函数创建集合，如果要创建空集合则只能使用set函数
2.集合不能包含有重复值的元素，如果创建集合或向集合插入元素时，指定的元素有重复值，则集合会自动过滤掉重复值
s = {1,2,3}
s = set([1,2,3,3])
print(s)
#{1, 2, 3}
3.插入元素，集合提供了两种插入元素的方法，add和update，add方法要求参数必须是可哈希对象，update方法要求参数必须是可迭代对象，update会将参数拆分为单个元素再插入集合
1.交集 intersection
2.并集 unioin
3.差集 difference
4.对称差集 symmetric_difference
s1 = {1,2,3}
s2 = {2,3,4}
print(s1.intersection(s2))
print(s1.union(s2))
print(s1.difference(s2))
print(s1.symmetric_difference(s2))
#{2, 3}
#{1, 2, 3, 4}
#{1}
#{1, 4}
5.issubset 判断子集
6.issuperset 判断父集
s1 = {1,2,3}
s2 = {1,2,3,4}
print(s1.issubset(s2))
print(s2.issuperset(s1))
#True
#True
1.与集合类似，字典是由若干无序元素组成
2.但与集合不同，字典是一种映射类型，每一个元素都是键值对形式
3.字典中每一个键的取值都必须唯一，且必须是可哈希类型的数据，字典对值没有限制
4.字典的主要应用是做数据的快速检索
5.可以使用{}或dict创建字典，如果要创建空字典可以使用{}或dict方法
d = {}
d = dict()
d = {1:1,2:4,3:9}
print(d)
#{1: 1, 2: 4, 3: 9}
6.可以使用fromkeys初始化字典元素，如果字典已存在其他元素，原有元素会被清除
d = {1:1,2:4,3:9}
d = d.fromkeys([1,2,3])
print(d)
#{1: None, 2: None, 3: None}
1.修改元素，给指定键的元素赋值时，如果字典中已存在，会修改值，如果字典中不存在，会在字典中插入一个新元素。
2.修改元素，可以使用update方法一次修改或插入多个元素
d = {1:1,2:4,3:9}
d[1]=100
print(d)#{1: 100, 2: 4, 3: 9}
d.update({1:99,2:98})
print(d)#{1: 99, 2: 98, 3: 9}
3.删除元素，可以使用del删除某个元素，也可以使用pop方法删除指定键的元素，语法格式：pop(key[,default])
d = {1:1,2:4,3:9}
del d[1]
print(d)#{2: 4, 3: 9}
d.pop(2,None)
print(d)#{3: 9}
1.浅拷贝：直接赋值
2.深拷贝：copy方法，copy模块的deepcopy方法
d = {1:1,2:4,3:9}
d0 = d
d1 = d.copy()
d2 = copy.deepcopy(d)
d[1] = 99
print(id(d),id(d0),id(d1),id(d2))
#2916242150272 2916242150272 2916242300544 2916242150080
1.是否存在键，可以使用get方法，语法格式：get(key,default=None)，如果存在会返回值，不存在会返回default指定的值
2.拼接两个字典，可以使用update方法
d1 = {1:1}
d2 = {2:2}
d1.update(d2)
print(d1)
#{1: 1, 2: 2}
1.len 计算字典中元素个数
d = {1:1,2:2,3:3}
print(len(d))#3
2.clear 清除字典中所有元素
d = {1:1,2:2,3:3}
d.clear()
print(d)#{}
3.keys 获取字典中的键集合
d = {1:1,2:2,3:3}
print(d.keys())#dict_keys([1, 2, 3])
4.values 获取字典中的值集合
d = {1:1,2:2,3:3}
print(d.values())#dict_values([1, 2, 3])
5.items 获取字典中的元素集合
d = {1:1,2:2,3:3}
print(d.items())#dict_items([(1, 1), (2, 2), (3, 3)])
6.提示，如果直接遍历字典，则每次只能获取到一个元素的键，然后再通过键去获取该元素的值
d = {1:1,2:2,3:3}
for x in d:
print(d[x])
#1
#2
#3
1.切片是指：从一个序列对象中取部分元素形成一个新的序列对象，语法格式为 [beg : end : step]
ls = [1,2,3,4,5,6,7,8,9,10]
print(ls[::2])
#[1, 3, 5, 7, 9]
2.列表生成表达式：在该表达式中，可以使用for，if以及一些运算生成列表的元素
ls = [x*x for x in range(10) if x%2 != 0]
print(ls)
3.列表生成表达式：也支持多层循环的形式
ls = [x*y for x in range(2) for y in range(2)]
print(ls)
#[0, 0, 0, 1]
1.当一个列表中包含大量元素时，如果一次性生成这些元素并保存在列表中，将占用大量的内存空间，有的情况下可用内存甚至无法满足存储需求
2.生成器（generator）可以解决这样的问题，根据需要进行计算并获取列表中某个元素的值，从而节省大量内存
3.将列表生成表达式的[]改为()就是生成器
g = (x for x in range(10))
print(type(g))
#4.对于生成器对象，也可以像其他可迭代对象一样使用for循环遍历对象中的每一个元素
g = (x for x in range(5))
for x in g:
print(x,end=' ')
#0 1 2 3 4
5.如果生成元素的方法比较复杂，不适合for循环方式实现，我们还可以借助yield关键字利用函数实现生成器
6.程序遇到yield会暂停函数执行并立即返回之后的变量，下次执行时从yield之后开始执行，比如下面的阶乘函数
def facList(n):
res = 1
for i in range(2,n+1):
yield res
res *=i
for i in facList(10):
print(i,end=' ')
#0 1 2 3 4 1 2 6 24 120 720 5040 40320 362880
1.可迭代对象：可直接用for循环遍历的对象统称为可迭代对象
2.迭代器是指可以通过next函数不断获取下一个值的可迭代对象，并不是所有的可迭代对象都是迭代器
3.可以通过isinstance方法判断一个对象是否是可迭代对象或迭代器
from collections.abc import Iterable,Iterator
ls = [1,2,3,4,5]
g = (x for x in range(5))
print(isinstance(ls,Iterable))#True
print(isinstance(ls,Iterator))#False
print(isinstance(g,Iterable))#True
print(isinstance(g,Iterator))#True
4.对于可迭代对象，可以通过iter函数获取迭代器，对于迭代器，则可以使用next函数不断获取下一个元素，当所有元素获取完毕在调用next函数就会引发StopIteration异常
5.自定义迭代器：对类实现__ next __和 __ iter __方法
class CustomIterator:
ls = [1,2,3,4,5]
index = 0
def __iter__(self):
return self
def __next__(self):
self.index += 1
return ls[self.index]
moota = CustomIterator()
for i in moota:
print(i)