1.序列(sequence):
序列是py中最基本的一种数据结构
可变序列
- 列表
不可变序列
- 字符串
- 元组
序列基本操作:
- +可以将相同的序列拼接成一个序列
- *: 将序列重复指定次数
- in : 检查元素是否存在于指定列表/元组中
- not in：检查元素是否不存在指定列表/元组中
list=(12,None,'sh',True,3,5,6)+(5,5)
print(list*5)
print(5 in list)
print( 4 not in list)
几个函数
- max():序列中最大元素
- min()：序列中最小元素
- index(a,b,c):指定元素在序列中第一次出现时索引,a为查找元素，b为起始索引，c为结束索引，bc可以省略，如果序列中没有，则会抛出异常
- count(a)：统计指定元素出现的次数
list = (5, 3,5,8,9)
print(max('15881'))
print(min(list))
print(list.index(5,1,3))
print(list.count(5))
2.列表(List):
list是py中的一个对象。我们之前学习的对象只能保存单一的数据，列表可以保存多个有序的数据。也可以储存对象的对象。
列表的索引是从0开始的。
列表的创建:
#列表中只有一个元素
list=[12]
#列表中有多个元素，并且元素类型可以不同
list=[12,None,'sh',True]
#通过索引获取列表中的元素，如果索引超出，则会抛出list index out of range异常
a=list[0] #12
#注意:其也可以逆序访问，从-1开始
c=list[-2] #sh
# 获取列表元素数量
b=len(list)
列表的方法：
- append() ：向列表最后添加元素，依此只能添加一个
- insert(a,b): 向列表的指定位置插入元素，a为要插入的位置，b为角标。需要注意的是,当a超出角标时，会插入最后一位。其也支持逆序，当超出逆序时，会插入第一位。
- extend(a) ：将a序列(列表，元组，字符串)元素添加到当前列表最后。如果是字符串，则会将字符串中每一个字符当成一个元素。
- clear(): 清空列表
- pop(a): 根据索引删除并返回被删除的元素。若没有指定a角标，则删除最后一个
- del list[a] : 删除指定角标元素
- remove(): 删除指定元素，如果列表中有多个相同元素，只会删除第一个
- reverse()：反转列表
- sort()：对列表进行排序，默认升序，如果需要降序则需要传递 reverse=True 注意:若列表中元素类型不同，则无法排序
list=[12,None,'sh',True]
list.append('s')
list.insert(-8,'a') #之前的0号元素变为1号
a=[1,4]
list.extend(a)
list.extend('asd')
list.pop(1)
#反转
list.reverse()
#降序
a.sort(reverse=True)
print(list)
list.clear()
切片
指从现有列表中，获取一个子列表。
- 语法1: 列表[起始:结束]
通过切片获取元素时，会包括起始位置，不会包含结束位置。
切片不会影响原有列表，会返回一个新列表。
若省略开始位置，则默认从头开始截取
省略结束位置，则默认截取到最后
若起始和结束都省略，等于创建了一个列表副本
list=[12,None,'sh',True]
print(list[1:3])
print(list[1:])
print(list[:3])
- 语法2:列表[起始：结束：步长]
list=[12,None,'sh',True,3,5,6]
print(list[1:6:2])
print(list[1:6:-1])
#相当于逆序隔两个打印
print(list[::-2])
3.元组(tuple)
元组是一个不可变序列，其操作方式基本与列表一样，但是少了列表中的增删改方法。但是元组创建时，有几个特殊。
list0=()
# 只有一个元素时，必须加，不加就是一个int类型变量
list = (5,)
# 当元组不是空元组时，括号可以省略
list1=5,3,5
print(type(list0))
元组的解包(解构)
解包就是将元组当中每一个元素都赋值给一个变量
每一次解包里面，最多可以有一个带*号的变量。他其实就是一个list,他将解包中没有对应的元素放入列表中。
list=1,3,4,5,
a,b,c,d,=list
a,*b=list # b= 3，4，5
a,*b,c=list #b=3,4
print(b)
4.字典(dict)
字典是一种映射的数据结构，列表存储数据的性能很好，但是查询数据的性能很差。
字典中每一个元素都有唯一的名字，通过过指定的key值可以快速找到value，因此，查询元素时，字典的效率是非常快的。字典中有多个键值对，每一个键值对称位item
字典的值可以是任意对象， 字典的键可以是任意的“不可变对象” ，一般使用str
# 创建字典
a=(1,3)
#方式1，因为元组也是不可变的，因此可以作为键
dictionnary={'name':'h',a:[1,3,'s']}
#使用dict()函数创建字典，对应的键都是str
dictionnary1=dict(name='hha',age='15')
# 根据键获取值,若键值不存在则报错
b=dictionnary1['name']
#获取字典键值对个数
len(dictionnary1)
#in/not in 检查字典中是否包含指定的键
print('name' in dictionnary1)
#如果字典中存在此键则覆盖value值，若没有则添加键值对
dictionnary1['name']='54'
常用函数：
- get(key,default): 通过key获取value
- setdefault(key,default): 向字典中添加键值对，如果key存在则返回value值，若不存在则添加此键值对
- update(dict):将其它字典的添加到当前字典，若有重复键，则添加的会覆盖之前的。
- del dict['key']：删除指定键值对
- popitem():删除最后一个键值对，删除之后返回的是包含两个元素的元组，第一个是删除的key，第二个是删除的value。 当字典为空时，会抛出异常。
- pop(key,default) ：删除指定的key，default可以省略，如果指定了default默认值，则key不存在时不会报错，直接返回default
- clear():清空字典
- copy():对字典进行浅拷贝，复制以后的对象时相互独立的。
a=(1,3)
dictionnary={'name':'h',a:[1,3,'s']}
dictionnary.get('name')
dictionnary.setdefault('age',18)
dictionnary.update({'sex':'man'})
del dictionnary[a]
dictionnary.popitem()
dictionnary.pop('name','None')
b=dictionnary.copy()
b.clear()
dictionnary.setdefault('ss',{'15':77})
#字典嵌套
print(dictionnary['ss']['15'])
5.集合(set)
集合和列表相似，其不同点在于
- 集合中只能存储不可变对象
- 集合中存储的对象是无序的，非插入有序，但是集合中相同类型元素是有序的
- 集合中元素不能重复
set={1,3,6,4,5,'f'}
set=set()#空集合
set=set([1,3,4,5]) #将列表/元组转换为集合
#将字典转换为集合，只会包含键
set=set({'name':'he'})
常用函数：
- len():集合元素个数
- add():向集合中添加元素。
- update():将一个集合/序列/字典中的元素添加到当前集合中。
- pop():随机删除并返回集合中的元素
- remove(value)：删除集合中指定元素
- clear():清空集合
- copy():浅拷贝
set={1,3,6,4,5,'f'}
len(set)
set.add(7)
set.update([2,3,5,3])
set.pop()
set.remove(3)
print(set)
set.clear()
集合的运算
在对集合做运算时，不会影响原来的集合，会返回一个新的结果。
如果a集合中的元素全部都在b集合中出现，那么a集合就是b集合的子集，b集合是a集合超集
- &：交集运算
- | ：并集运算
- -：差集运算
- ^ :异或集:获取只在一个集合中出现的元素
- <=:检查一个集合是否是另一个集合的子集
- <:检查一个集合是不是另一个集合的真子集
- > : 检查一个集合是不是另一个的真超集
- >=:检查一个集合是否是另一个的超集
a={1,4,5,7}
b={1,4,5,7,3,6}
print(a&b) #{1, 4, 5, 7}
print(a|b) #{1, 3, 4, 5, 6, 7}
print(a^b) #{3, 6}
print(a<=b) #True
print(ab) #False
print(a>=b) #False