容器类型：

列表和元组

例如：访问数据元素
数据收纳盒名字[编号（从零开始）]
列表是可变类型，所以可以添加、删除、替换、重排序列中的元素
元组不可变

创建列表

方括号法

print([])
a=[]
print(a)
print([1,2,3])
b=[4,5,6]
print(b)
#[1,2,3]必须赋值给变量，不然会报错

输出

F:\k\venv\Scripts\python.exe F:/k/demo5.py
[]
[]
[1, 2, 3]
[4, 5, 6]

指明类型法

list()

print(list())
c = list()
print(c)
print(list([7,8]))
m = list([4,5])
print(m)

输出

[]
[]
[7, 8]
[4, 5]

创建元组

圆括号法

print(())
a=()
print(a)
print((1,2,3))
b=(4,5,6)
print(b)
#(1,2,3)必须赋值给变量，不然会报错

输出

F:\k\venv\Scripts\python.exe F:/k/demo5.py
()
()
(1, 2, 3)
(4, 5, 6)

指明类型法

tuple()

print(tuple())
c = tuple()
print(c)
print(tuple((7,8)))
m = tuple((4,5))
print(m)

输出

()
()
(7, 8)
(4, 5)

列表和元组中保存的元素类型没有限制

print(list([1,"abc","我",3.11]))
print(tuple((1,"abc","我",3.11)))

输出

[1, 'abc', '我', 3.11]
(1, 'abc', '我', 3.11)

列表的操作

append操作

a=list([1,2,3])
print(a)
a.append(2)
print(a)

输出

[1, 2, 3]
[1, 2, 3, 2]

insert操作

b=list([1,2,3])
print(b)
b.insert(1,8)
print(b)

b=list([6,2,3])   #在列表最后一个元素后面添加一个元素
print(b)
b.insert(3,3)
print(b)

输出

[1, 2, 3]
[1, 8, 2, 3]
[6, 2, 3]
[6, 2, 3, 3]

extend操作

b=list([6,2,3])
print(b)
b.extend([6])
print(b)

输出:

[6, 2, 3]
[6, 2, 3, 6]

pop操作

b=list([6,2,3,4,9])
print(b)
b.pop() #pop空括号()表示缩减列表最后一个元素
print(b)
b.pop(0)  #pop(0)是表示缩减列表中第一个元素
print(b)
b.pop(1) #pop(1)参数1是表示列表中元素排列的序号，选1就表示缩减列表中序号为1的元素即第二个元素
print(b)

输出

[6, 2, 3, 4, 9]
[6, 2, 3, 4]
[2, 3, 4]
[2, 4]

remove操作

b=list([6,2,3,4,9])
print(b)
b.remove(2) #remove后面的这个()里面是填写列表里面元素的值进行缩减列表元素的，比如这条代码b.remove(2)这个的这个2是对于列表中[6,2,3,4,9]里面的这个2
print(b)
b.remove(3) #这个跟上面那个注释的意思一样remove括号里面的3对于列表里面的那个3
print(b)

输出

[6, 2, 3, 4, 9]
[6, 3, 4, 9]
[6, 4, 9]

clear操作

b=list([6,2,3,4,9])
print(b)
b.clear() #clear()是表示缩减列表中所有的元素，比如#号左边的这条代码就表示缩减删除了list([6,2,3,4,9])列表中所有的元素
print(b)

输出

[6, 2, 3, 4, 9]
[]

reverse操作

reverse:把列表中的数据元素头尾反转重新排列

num=[1,2,3,7,5,6,9,4]
num.reverse()
print(num) 

输出

[4, 9, 6, 5, 7, 3, 2, 1]

sort操作

sort:把列表中的数值按从小到大进行排列

num=[1,2,3,7,5,6,9,4]
num.sort()
print(num)

输出

[1, 2, 3, 4, 5, 6, 7, 9]

如果列表里面的元素需要从大到小进行排序可以进行以下这样操作

num=[1,2,3,7,5,6,9,4]
num.sort(reverse = True) #这条代码的意思是num里面的元素进行从小到大的顺序排列之后，引用reverse函数，列表中的元素又进行了头尾反转的重新排列
print(num)

输出

[9, 7, 6, 5, 4, 3, 2, 1]

del操作

del：可以用来删除列表中的元素

num=[1,2,3,7,5,6,9,4]
del num[7] #需要删除列表中那个元素，直接del []中括号里面写上元素的序号就可以进行删除
print(num)
del num[3] #需要删除列表中那个元素，直接del []中括号里面写上元素的序号就可以进行删除
print(num)

输出

[1, 2, 3, 7, 5, 6, 9]
[1, 2, 3, 5, 6, 9]

列表和元组的合并

加法运算"+"：连接两个列表/元组得到一个新的列表且前面两个列表还继续存在不受影响

乘法运算"*":复制n次，生成新的列表 /元组

num = [1,2,3,7,5,6,9,4]
bal = ["hello","world"]
s = num+bal     #把两个列表用加法运算符合并得出一个新的列表且前面两个不受影响
print(s)

输出

[1, 2, 3, 7, 5, 6, 9, 4, 'hello', 'world']

把列表赋值给一个变量，然后这个变量用乘法(*)乘以一个整数，就等于给这个列表重复几次如下图：

num = [1,2,3,7,5,6,9,4]
d = num*3       #把num这个列表用乘法运算符“*”重复该列表三次得到一个新的列表且前面那个列表不受影响
print(b)

输出

[1, 2, 3, 7, 5, 6, 9, 4, 1, 2, 3, 7, 5, 6, 9, 4, 1, 2, 3, 7, 5, 6, 9, 4]

将元组有加号(+)进行连接合并如下图：

n = (3,6,9,8,5,2)
m = (1,4,7,2,5,8)
al = n+m #将两个元组用加法运算符进行合并，得到一个新的列表，前面两个列表不受影响
print(al)

输出

(3, 6, 9, 8, 5, 2, 1, 4, 7, 2, 5, 8)

把元组赋值给一个变量，然后这个变量用乘法(*)乘以一个整数，就等于给这个元组重复几次如下图：

n = (3,6,9,8,5,2)
ak = n*3 #将n这个列表用乘法运算符"*"重复该列表三次，得到一个新的类别且前面那个列表不受影响
print(ak)

输出

(3, 6, 9, 8, 5, 2, 3, 6, 9, 8, 5, 2, 3, 6, 9, 8, 5, 2)

求列表元组大小的可以调用len()函数

求列表元素的个数如下图：

num = [4,5,6,3,6,9] #创建一个列表并赋值给num
print(len(num)) #打印列表大小即列表元素的个数

输出

6

求元组里面元素的个数如下图：

num = (4,5,6,3,6,9,3,8)#创建一个元组并赋值给num
print(len(num)) #打印元组大小即元组元素的个数

输出

8

索引：alist[]或atuple[]

1.可以用alist[编号]给列表中任何一个位置的元素从新赋值，可以把alist[编号]赋值给'='左边的变量,也可以放在'='的右边作为一个表达式参与计算

2.元组属于不可变类型，索引只能获取对应位置值中的数据值，不可重新赋值

获取一个列表元素并将它当成一个变量重新进行赋值如下图：

alist = [1,2,3,4,5,6] #创建一个列表'alist'
alist[3]  = 0 #给alist[3]放在'='左边当成一个变量进行重新赋值0这么一个数值
print(alist) #打印结果为[1,2,3,0,5,6]

获取一个列表元素将它当成一个表达式进行计算如下图：

alist = [1,2,3,4,5,6] #创建一个列表'alist'
blist = 3 #创建一个变量并赋值数值3
als = alist[5]*blist #把alist[5]放在右边当成一个表达式参与计算
print(als) #alist[5]的取值是6，blist中暂存的值为3，6*3结果为十八

获取一个元组元素并且将它当成一个表达式赋值给一个变量，因为元组是不可变类型所以不能进行重新当成变量进行赋值如下图：

atuple = (1,2,3,4,5,6) #创建一个元组'atuple'
btuple = atuple[4] #给atuple[4]放在'='右边当成一个表达式计算
print(btuple) #打印结果为5

输出

5

获取一个元组的元素，把它当成一个变量进行重新赋值，就会报错如下图：

atuple = (1,2,3,4,5,6) #创建一个元组'atuple'
atuple[3]  = 0 #给atuple[3]放在'='左边当成一个变量进行重新赋值0这么一个数值
print(atuple) #打印结果报错,因为元组是不可变类型所以不可以对立面的元素进行重新赋值

输出

Traceback (most recent call last):
  File "F:/k/demo5.py", line 2, in <module>
    atuple[3]  = 0 #给atuple[3]放在'='左边当成一个变量进行重新赋值0这么一个数值
TypeError: 'tuple' object does not support item assignment

列表和元组切片

alist[start:end:step]

   开始：结束：步长

atuple[start:end:step]

       开始：结束：步长

具体操作如下

对元组进行切片如下图：

atuple = (1,2,3,4,5,6) #创建一个元组'atuple'
print(atuple[1:5:2] ) #对元组进行切片并进行打印结果为（2,4）因为步长为2所以要空跳两次3一次5一次

输出

(2, 4)

对列表进行切片如下图：

alist = [1,'hello','world']
print(alist[::-1]) #列表的切片步长为-1则表示列表里面的元素头尾调转重新排序
print(1 in alist) #判断列表中元素是否有1这个数值，结果是True

输出

['world', 'hello', 1]
True

index操作

列表.index(值)例如alist = [1,'hello','world']

print(alist.index('hello')具体看下图代码：

alist = [1,'hello','world']
print(alist.index('hello')) #打印输出结果为'hello'在列表中的位置所对应的序号

输出

1

count操作

count函数可以判断某一个数值在某个列表中出现过几次具体如下图：

alist = [1,'hello','world']
print(alist.count('world'))#列表.count()为语法格式，#左边的代码则是打印出world这个字符串在alist这个列表中出现过几次

输出

1

sum操作

sum：求一个列表或元组的累加之和

alist = [1,2,3,4,5,6,7,8,9]
print(sum(alist))#求1-9的累加之和并打印出来
atuple = (1,2,3,4,5,6,7,8,9)
print(sum(atuple))#求atuple元组1-9的累加之和并打印出来

输出

45
45

min操作

Min：求一个列表或一个元组的最小值

alist = [1,2,3,4,5,6,7,8,9]
print(min(alist))#求alist列表的最小值并打印出来
atuple = (1,2,3,4,5,6,7,8,9)
print(min(atuple))#求atuple元组的最小值并打印出来

输出

1
1

max操作

max：求一个列表或元组的最大值

alist = [1,2,3,4,5,6,7,8,9]
print(max(alist))#求alist列表的最大值并打印出来
atuple = (1,2,3,4,5,6,7,8,9)
print(max(atuple))#求atuple元组的最大值并打印出来

输出

9
9