一、列表

  1. 格式

list=[数据1,数据2,…]

  1. 列表的常用操作
    (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. 列表的循环遍历
    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)
  1. 列表嵌套
name=[['Lily','Shirly','Amy],['张三','李四','王五’],['小红','小明','小军']]
 print(name[1][2])
 #王五

列表的嵌套可以和C语言中的二维数组相类比

二、元组

  1. 作用：一个元组可以存储多个数据，元组内的数据不可修改
  2. 定义元组
    (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. 创建字典
    1）创建字典的基本要求
    ①符号为大括号
    ②数据以键值对形式出现（一般冒号前面为键，冒号后面为值）
    ③各个键值对之间用逗号隔开
    2）不同的字典
    ①有数据字典

dict={‘name’:‘Amy’,‘age’:18,‘gender’:‘女’}

②空字典

dict1={}
dict2=dict1()

  1. 字典常见操作
    (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. 字典的循环遍历
    (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}')

四、集合

  1. 创建集合
    创建集合使用**{}或者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)增加数据
    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