1. 列表 相当于数组
1. 列表的创建和删除
1. 直接用[]声明
a='1'
li=[1,2,a]
2. 使用range函数创造迭代器核心,再用list()方法来创建
ran = range(5,10,2)
li = list(ran)
3. 也可以 使用list作为核心,再用list()方法来创建 ,应该可以用作浅复制;
a='1'
li=[1,2,a]
li1 = list(li)
2. 列表的增删改查操作
1. 增
- 1 . append方法 追加一个元素到数组末尾
li1 = [1,2,3]
li2 = [1,2,3]
li=[1,li1,3,4,5,6,7,8,9,0]
li.append(li2)
- 2 . extend 散开数组元素追加到数组末尾
li1 = [1,2,3]
li2 = [1,2,3]
li=[1,li1,3,4,5,6,7,8,9,0]
li.extend(li2)
结果: [1, [1, 2, 3], 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3]
- 3 . insert 在列表任意位置加入元素
li1 = [1,2,3]
li2 = [1,2,3]
li=[1,li1,3,4,5,6,7,8,9,0]
li.insert(2,li2)
print(li)
- 4 . 切片 其实不是添加了,其实是切掉替换 ,注意切的位置也可以实现增加
li1 = [1,2,3]
li=[1,2,3,4,5,6,7,8,9,0]
li[1:]=li1
print(li)
2. 删
- 1 . remove() 根据值删除元素
li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
li.remove('ccc')
print(li)
一次删除一个,重复的话只会删除第一个值, 如果值不存在就报valueError
- 2 . pop() 根据索引删除元素
li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
li.pop(100)
print(li)
一次删除一个 如果索引不存在就报indexError,如果没有指定索引,那么就删除最后一个
- 3 . 切片 变相的做法 把某一段范围的元素用空列表替代
li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
li[1:9]=[]
print(li)
- 4 . clear 清空一个列表 类似于 li=[]
li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
li.clear()
print(li)
- 5 . del 删除一个列表 ,删除了一个列表的引用,会报错
li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
del li
print(li)
3. 改
- 1 . 使用索引指定一个新值
li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
li[9]=['hello','world']
print(li)
- 2 . 切片 把列表上某一段范围的元素用其他列表替代
li1 = [1,2,3]
li=['a','b','c',li1,5,6,7,8,9,0]
li[1:9]=['hello','world']
print(li)
4. 查
- 1 . 正向索引
li = 【1,2,3】 print(li[2])
0 到 n-1 为正常索引 超出报错
- 2 . 倒向索引
li = 【1,2,3】 print(li[-2])
-n 到 -1 为正常索引 超出报错
- 3 . 获取切片操作 是一个原列表片段的浅拷贝 范围也是左闭右开,语法 [起始(默认0):结束(默认为长度-1):步长(默认为1)]
li=[1,2,3,4,5,6,7,8,9,0]
print(li[1:3:1])
起始 结束 步长也可以为负数,不过一般不常用,倒序拷贝输出,可以用来reverse倒排(reverse对自身改变), 不需要掌握
3. 列表元素的排序 注意 类型必须一样哦 字符串和数字混着来会报错的哦
1. 列表的sort 方法 改变原列表
li=[5,6,7,8,9,0]
li.sort(reverse=True)
print(li)
2. 内置函数sorted方法产生新的列表 不改变原列表
li=[5,6,7,8,9,0]
li2 = sorted(li,reverse=True)
print(li2)
4. 列表的推导生成式
[ ii for i in range(1,10)] 中括号含有两部分,1,值部分可以是一个表达式 ii 2,迭代器发动机部分 for in语句
li=[i*i for i in range(1,10)]
print(li)
5. index方法
index()方法也是返回第一个下标,没有会报错不会返回-1,这个和其他语言不同,
第2,3个参数可以指定查询范围,左闭右开
6. in & not in
元素是否存在列表返回布尔值
但是对于复杂类型的元素 ,这边应该使用的是粗糙的值比价,而不是精准的内存地址比较
7. 可以使用for in和while进行循环 (类似有迭代器的都可以进行循环)
2.字典 就是其他语言中的对象
1 . 字典的原理
简单来说字典是一个巨大的稀疏列表,典型以空间换时间的做法,key的实际索引值是通过hash算法得到一个巨大切不重复的值 hash值很少会撞针
字典的元素是无序的
key不允许重复如果重复将会被覆盖
key必须为不可变对象不能是一个复合结构 可以为字符串、数字、元祖还有False
2 . 字典的创建
1. 以{}字面量创建
di = {'a':1,1:2}
di[4]=5
print(di)
2. dict()方法创建
di = dict(a=1,b=2) # 不能创建数字key
di[4]=5
print(di)
3 . 字典的增删改查
1. 增
- 1 . 直接 dict[key] =value
di = dict(a=1,b=2)
di['c']=100
print(di)
2. 删
- 1 . del
di = dict(a=1,b=2)
del di['a']
print(di)
- 2 . clear 清空字典
di = dict(a=1,b=2)
di.clear()
print(di)
3. 改
- 1 . 直接 dict[key] =value
di = dict(a=1,b=2)
di['a']=100
print(di)
4. 查
- 1 . []
di = dict(a=1,b=2)
print(di['a'])
查找没有的key 会报keyError
- 2 . 使用get(key)
di = dict(a=1,b=2)
print(di.get('a'))
如果查找不存在,会返回none ,这个时候还可以指定默认值,为第二个参数
di = dict(a=1,b=2)
print(di.get('c',3))
4 . 字典的推导生成式 使用内置函数zip()进行打包
语法为 {} 包含两部分 1, 键值对示意表达式 2, for in 循环
zip 函数的参数必须为两个迭代器对象
如果两个迭代器对象长度不一致以短的那个长度为准
items = ['中华','芙蓉王','玉溪']
prices= [50,28,23]
di = { item:price for item, price in zip(items,prices)}
print(di)
5 . key 是否存在 in & not in 返回布尔值
di = dict(a=1,b=2)
print('a' in di)
6. 字典的视图 都是类似于range的迭代器类型,可以使用list进行转换为列表
1. keys type 为 dict_keys,
di = dict(a=1,b=2)
diKeys=di.keys()
print(diKeys)
for key in diKeys:
print(di[key])
2. values type 为 dict_values
di = dict(a=1,b=2)
diValues=di.values()
print(list(diValues))
3. items type 为 dict_items, 每一项都是一个元祖’tuple’
di = dict(a=1,b=2)
diItems=di.items()
print(list(diItems))
for item in diItems:
print(type(item))
7. 字典的循环
di = dict(a=1,b=2)
for item in di:
print(item,di[item],di.get(item))
3. 元祖 tuple
1. 什么是元祖
元祖是一个不可变队列, 里面存放的内存地址都不可以改变的
不可变队列是指不能增删改等操作,字符串数组,改变就会产生新的地址
可变队列是指可以改变的 如列表,字典, 地址不会发生变化
没有元祖的推导生成式
2. 元祖的创建方式
1. 直接小括号()
tu = (1,2,3)
print(type(tu))
2. 使用内置函数tuple() 注意是两层括号
tu = tuple((1,2,3))
print(tu)
3. 只包含一个元祖的元素需要使用逗号和小括号 (,),(否则就是元素的值而已,不是元祖类型了)
tu = (1,)
print(tu)
4. 空元祖 两种方式 tu = (),tu = tuple()
3. 元祖的遍历 for in
tu = (1,2,3)
for t in tu:
print(t)
4. 元祖的查询方式
tu = (1,2,3)
print(tu[1])
4. 集合 set
类似于字典但是只有key,没有value
可以是无序的
1. 集合的创建方式
1. {}
s = {1,2,3,4}
print(type(s))
2. set() ,可以去重, 参数有 字符串,元祖 ,列表,range,set本身,不传(空集合)
print(set(range(0,10)))
print(set('python'))
print(set((1,2,3,3)))
print(set([1,2,3,3]))
print(set({1,2,3,3}))
print(set())
2. 集合的增删改查
1. 增
- 1 . add(),添加一个元素到末尾
s={1,2,3}
s.add(4)
print(s)
- 2 . update() 参数必须为列表 元祖 集合,否则报错,至少可以添加一个元素到末尾
s={1,2,3}
s.update([4,5,6])
s.update((7,8))
s.update({9})
print(s)
2. 删
- 1 . remove 删除一个指定元素,如果没有会报keyError
s={1,2,3}
s.remove(2)
print(s)
- 2 . discard() 删除一个指定元素,如果没有不会报错
s={1,2,3}
s.discard(2)
s.discard(5)
print(s)
- 3 . pop 删除一个任意的字符,不能指定参数,空集合使用会报错
s={1,2,3}
s.pop()
s.pop()
s.pop()
print(s)
- 4 . clear 清空集合
s={1,2,3}
s.clear()
print(s)
3. 集合的生成式
公式在{}内由两部分构成: 1. 实际value生成部分可以是个表达式 i*i 2. for in 迭代器部分
s1={ i*i for i in range(1,10)}
print(s1)
4. 集合的 in & not in
s= {1,2,3}
print(1 in s )
5. 集合之间的关系
1. 是否相等使用 == 或者!= 来判断 返回布尔指
s1={1,2,3}
s2={1,2,3}
s3={4,5,6}
print(s1==s2)
print(s1!=s2)
print(s3!=s1)
print(s3==s1)
2. 一个集合是否是另外一个集合的子集 issubset()
s1={1,2,3}
s2={1,2,3,4,5,6}
s3={4,5,6}
print(s1.issubset(s2))
print(s1.issubset(s3))
3. 一个集合是否是另外一个集合的超集 issuperset()
s1={1,2,3,4,5,6,7}
s2={1,2,3,4,5,6}
s3={4,5,6}
print(s1.issuperset(s2))
print(s1.issuperset(s3))
4. 两个集合是否没有交集 isdisjoint() 注意是dis 反向的 没有交集
s1={1,2,3}
s2={1,2,3,4,5,6}
s3={4,5,6}
print(s1.isdisjoint(s2))
print(s1.isdisjoint(s3))
6. 集合的数学操作
1. 交集 intersection() 简写为&
s1={1,2,3}
s2={1,4,5,6}
print(s1.intersection(s2))
print(s1&s2)
2. 并集 union() 简写为|
s1={1,2,3}
s2={1,4,5,6}
print(s1.union(s2))
print(s1|s2)
3. 差集 difference() 简写为 - 相对于前面那个集合的差集
s1={1,2,3}
s2={1,4,5,6}
print(s1.difference(s2))
print(s1-s2)
4. 对称差集 symmetric_difference() 简写为^ 两个集合的非交集部分
s1={1,2,3}
s2={1,4,5,6}
print(s1.symmetric_difference(s2))
print(s1^s2)
7. 集合的遍历 for in
s1={1,2,3}
for i in s1:
print(i)