一、列表
- 格式
list=[数据1,数据2,…]
- 列表的常用操作
(1)查找
1)用列表的下标查找列表的数据
name=['Lily','John','Amy']
print(name[0])#Lily
print(name[1])#John
print(name[2])#Amy
列表的下标从0开始增加,我们可以像上面的代码一样通过列表的下标来访问数据
2)函数
①index():返回指定数据所在位置的下标
列表序列.index(数据,开始位置下标,结束位置下标)
name=['Lily','John','Amy']
print(name.index('Lily',0,2))#1
print(name.index('Shirly',0,2))#报错
如果查找的数据不存在则报错
②count():统计指定数据在当前列表中出现的次数
name=['Lily','John','Amy']
print(name.count('Lily'))#1
③len():访问列表长度,即列表中数据的个数
name=['Lily','John','Amy']
print(len(name))#3
3)判断是否存在
①in:判断指定数据在某个列表中
②not in:判断指定数据不在某个列表中
name=['Lily','John','Amy']
print('Lily' in name)#True
print('Lily' not in name)#False
(2)增加
1)append():列表结尾追加数据
列表数据.append(数据)
如果append()追加的数据为一个序列,那么追加整个序列到列表
①追加单个数据
name=['Lily','John','Amy']
name.append('Lisa')
print(name)#['Lily','John','Amy','Lisa']
②追加序列
name=['Lily','John','Amy']
name.append(['xiaojun','xiaohong'])
print(name)
#['Lily','John','Amy',['xiaojun','xiaohong']]
2)extend():列表结尾追加数据
列表序列.extend(数据)
①追加单个数据
name=['Lily','John','Amy']
name.extend('xiaohong')
print(name)
#['Lily','John','Amy','x','i','a','o','h','o','n','g']
面对上述输出结果,我们会感到疑惑,运行结果和我们想象中的有所不同
extend添加数据时,会把输入的数据分成每个字符逐一输入到列表中
②追加序列数据
name=['Lily','John','Amy']
name.extend(['xiaoming','liuli'])
print(name)
#['Lily','John','Amy','xiaoming','liuli']
如果数据为一个序列,那么我们将序列里面的数据逐一添加到列表中
3)insert():指定位置新增数据
列表序列.insert(位置下标,数据)
name=['Lily','John','Amy']
name.list(1,'aaa')
print(name)
#['Lily','aaa','John','Amy']
(3)删除
1)del 目标:删除数据
①删除列表
name=['Lily','John','Amy']
del name
print(name)#报错
原有列表被删除再需打印列表时会报错,此时列表不存在
②删除指定数据
name=['Lily','John','Amy']
del name[0]
print(name)
#['John','Amy']
2)pop():删除指定下标的数据(如果没写列表下标则默认为列表最后一个数据),该函数拥有返回值
列表序列.pop(下标)
name=['Lily','John','Amy']
del_name1=name.pop()
print(del_name1)
#['Lily','John']
del_name2=name.pop(1)
print(del_name2)
#['Lily','Amy']
3)remove():移除列表中某个数据的第一个匹配项
列表序列.remove(数据)
name=['Lily','John','Amy']
name.remove('Lily')
print(name)
#['John','Amy']
4)clear():清空列表
列表序列.clear()
name=['Lily','John','Amy']
name.clear()
print(name)
#[]
清空列表只是清空列表中的数据,列表中的数据被清空后列表变为空列表:[ ]
(4)修改
1)修改指定下标数据
name=['Lily','John','Amy']
name[0]='Shirly'
print(name)
#['Shirly','John','Amy']
找到指定下标的数据,对该数据进行修改
2)reverse():逆置数据
num=[1,2,3,4,5,6,7]
num.reverse()
print(num)
#[7,6,5,4,3,2,1]
3)sort():排序
列表序列.sort(key=None,reverse=False/True)
reverse表示排序规则,如果reverse=True,则表现为降序,如果reverse=False,则表现为升序
如果没有写reverse的值,我们就默认reverse为False
num=[1,5,7,3,2,6,4]
num.sort(reverse=False)
print(num)
#[1,2,3,4,5,6,7]
num.sort(reverse=True)
print(num)
#[7,6,5,4,3,2,1]
(5)copy():复制
name=['Lily','John','Amy']
copy_name=name.copy()
print(copy_name)
#['Lily','John','Amy']
- 列表的循环遍历
1)用while循环遍历
name=['Lily','John','Amy']
i=0
while i<len(name):
print(name[i])
i+=1
2)用for循环遍历
name=['Lily','John','Amy']
for i in name:
print(i)
- 列表嵌套
name=[['Lily','Shirly','Amy],['张三','李四','王五’],['小红','小明','小军']]
print(name[1][2])
#王五
列表的嵌套可以和C语言中的二维数组相类比
二、元组
- 作用:一个元组可以存储多个数据,元组内的数据不可修改
- 定义元组
(1)元组特点:定义元组使用小括号,且逗号隔开各个数据,数据可以是不同的数据类型
(2)定义单个数据元组
t1=(10,)
t2=(20)
t3=('hello world')
print(type(t1))#tuple
print(type(t2))#int
print(type(t3))#str
我们看到上面代码的结果可能会感觉到奇怪,因为我们明明定义的是元组,但是每个我们定义的“元组”类型却各不相同,这是什么原因呢?
如果定义的元组只有一个数据,那么这个数据之后应该添加逗号,否则这个元组为唯一的这个数据的数据类型
(3)定义多个数据元组
t4=(10,20,30)
3.元组的常见操作
元组不支持修改,只支持查找
(1)按下标查找数据
tuple=('aa','bb','cc','bb')
print(tuple[0])
#aa
(2)index():查找某个数据,如果数据存在则返回对应下标,如果不存在就报错
tuple=('aa','bb','cc','bb')
print(tuple.index('aa'))
#0
print(tuple.index('dd'))
#报错
(3)count():统计某个数据在当前元组中出现的次数
tuple=('aa','bb','cc','bb')
print(tuple.count('bb'))
#2
(4)len():统计元组中数据的个数
tuple=('aa','bb','cc','bb')
print(len(tuple))
#4
(5)修改
1)元组内的数据如果直接修改则立刻报错
tuple=('aa','bb','cc','bb')
tuple[0]='dd'
#报错
元组内的数据不可修改
2)如果元组内有列表,支持修改元组数据中的列表
tuple=(10,20,['aa','bb','cc'],30)
tuple[2][1]='dd'
print(tuple)
#(10,20,['aa','dd','cc'],30)
三、字典
- 特点:字典不支持下标,字典中的数据以键值对的形式存在,字典数据和数据顺序没有关系
- 创建字典
1)创建字典的基本要求
①符号为大括号
②数据以键值对形式出现(一般冒号前面为键,冒号后面为值)
③各个键值对之间用逗号隔开
2)不同的字典
①有数据字典
dict={‘name’:‘Amy’,‘age’:18,‘gender’:‘女’}
②空字典
dict1={}
dict2=dict1()
- 字典常见操作
(1)增、改
字典序列[key]=值
如果key存在则修改这个key对应的值,如果不存在则新增键值对
dict={'name':'Amy','age':18,'gender':'女'}
dict['name']='Rose'
print(dict)#{'name':'Rose','age':18,'gender':'女'}
dict['id']=110
print(dict)#{'name':'Rose','age':18,'gender':'女','id':110}
(2)删
1)del()/del:删除字典或删除字典中指定键值对
dict={'name':'Amy','age':18,'gender':'女'}
del dict['gender']
print(dict)#{'name':'Amy','age':18}
2)clear():清空字典
dict={'name':'Amy','age':18,'gender':'女'}
dict.clear()
print(dict)#{}
(3)查
1)key值查找
如果当前查找的key值存在则返回对应的值,如果不存在则报错
dict={'name':'Amy','age':18,'gender':'女'}
print(dict['name'])#Tom
print(dict['id'])#报错
2)get()
字典序列.get(key,默认值)
若当前key不存在则返回默认值,如果在key不存在的情况下省略第二个参数则返回None
dict={'name':'Amy','age':18,'gender':'女'}
print(dict.get('name'))#Amy
print(dict.get('id',10))#10
print(dict.get('id'))#None
3)key()s:查找字典中所有的key
dict={'name':'Amy','age':18,'gender':'女'}
print(dict.keys())
#dict_keys(['name','age','gender'])
4)values():查找字典中所有的值
dict={'name':'Amy','age':18,'gender':'女'}
print(dict.values())
#dict_values(['Amy','18','女'])
5)items():查找字典中所有的键值对,返回可迭代对象,里面数据为元组
dict={'name':'Amy','age':18,'gender':'女'}
print(dict.items())
#dict_items([('name':'Amy'),('age':18),('gender':'女')])
- 字典的循环遍历
(1)遍历字典中key
dict={'name':'Amy','age':18,'gender':'女'}
for key in dict.keys():
print(key)
(2)遍历字典中value
dict={'name':'Amy','age':18,'gender':'女'}
for value in dict.values():
print(value)
(3)遍历字典中的元素
dict={'name':'Amy','age':18,'gender':'女'}
for item in dict.items():
print(item)
(4)遍历字典中的键值对
dict={'name':'Amy','age':18,'gender':'女'}
for key,value in dict.items():
print(f'{key}={value}')
四、集合
- 创建集合
创建集合使用**{}或者set(),但是若要创建空集合只可以使用set(),因为{}用于创建空字典**
s1=set()
s2={}
print(type(s1))#set
print(type(s2))#dict
s1={10,20,30,40,50}
print(s1)#{20,40,50,30,10}
s2={'abcde'}
print(s2)#{'a','c','d','b','e'}
看到上面代码的执行结果,我们可能会很奇怪,为什么我们输出的集合顺序和我们定义时大不相同呢?
原因在于:集合不存在顺序,不支持下标,所以输出的结果顺序不相同
s3={10,20,30,40,20,30}
print(s3)#{40,20,10,30}
看到上述代码我们可能还会有疑问,为什么打印出来的元素个数比起定义时的元素个数有所减少呢?
原因在于:集合不允许自己内部的元素重复,在使用集合时会自动去重
- 集合的常见操作
(1)增加数据
1)add()
s1={10,20}
s1.add(10)
s1.add(100)
print(s1)#{10,20,100}
因为集合有去重功能,当向集合中添加的数据为当前集合内已有的数据时,不进行任何操作
2)update():追加的数据为序列时
s1={10,20}
s1.update(100)#报错
s1.update([100,200])
print(s1)#{10,200,100,20}
(2)删除数据
1)remove():删除集合中指定数据,若不存在则报错
s1={10,20,30}
s1.remove(10)#{30,20}
si.remove(10)#报错,此时集合中的10已被删除,再次删除则是删除集合中不存在的数据,会报错
2)discard():删除集合中指定数据,若不存在也不报错
s1={10,20,30}
s1.discard(10){30,20}
s1.discard(10){30,20}
3)pop():随机删除集合中某个数据并返回该数据
s1={10,20,30}
del_num=s1.pop()
print(del_num)#{20,10}
print(s1)#{20,30,10}
pop()无法修改原集合,只能产生一个新的集合
(3)查找数据
in:判断数据在集合序列
not in:判断数据不在集合序列
s1={10,20,30}
print(10 in s1)#True
print(10 not in s1)#False