Python基础学习Day5

1.列表（list）

Python 支持多种复合数据类型，可将不同值组合在一起。最常用的列表 ，是用方括号标注，逗号分隔的一组值。列表可以包含不同类型的元素，但一般情况下，各个元素的类型相同。

x=[10,20,88,10+2j,True,'xixi']#可以容纳不同数据类型
#列表是一种复合数据（数据容器）

1.1列表访问

访问方式与字符串一致，从0开始是第一个元素，若从右往左索引则第一个元素是-1，以此类推。

#访问类表中的值
#取出列表中的数据
y1=x[0]
y2=x[5]
y3=x[-2]
print(y1,y2,y3)


#列表索引(index，下标)不能超出索引范围(该行为称为越界)
x=[12,22,32,42,52,62]
print(x[0])
print(x[1])
print(x[2])
print(x[3])
print(x[4])
print(x[5])

for i in range(len(x)):
    print(i,x[i])
for el in x:
    print('num:',el)

1.2切片索引

利用下标来一次访问多个原列表内的值（[::]），访问方式与字符串一样。

#切片索引
x=[11,22,33,44,55,66,77,88,99,100,110]
x2=x[3:5]#x2表示从x列表中的第4取到第5个，[3,5)
print('x2',x2)
x3=x[2:-2]#从左往右取值，从2对应的元素取到倒数第3个，左闭右开
print('x3',x3)
x4=x[-3:5]#从左往右取，如果切片的范围没有任何元素，则得到一个空的列表
print('x4',x4)
x5=x[1:100]
print('x5',x5)
x6=x[:4]#省略冒号之前的，就表示从第一个开始
print('x6',x6)
x7=x[1:]#省略冒号后面的数，就表示取到len（）结束
print('x7',x7)
x8=x[1:8:2]#第二个冒号后面的数代表步长，[x[1],x[3],x[5],x[7]]
print('x8',x8)
x9=x[:8:2]#从头开始取，步长为2，[x[0],x[2],x[4],x[6]]
print('x9',x9)
x10=x[2::2]#从第三个开始取，步长为2，到结束[x[2],x[5],x[7],x[9],x[10]
print('x10',x10)
x11=x[::2]#从头开始取到最后一个，步长为3
print('x11',x11)
x12=x[::-2]
print('x12',x12)
x13=x[1:5:-1]
print('x13',x13)
x14=x[5:1:-1]
print('x14',x14)

1.3更新列表

使用append（）对列表添加，新元素位于列表的最后一位，无法一次添加多个新元素进原列表。更新列表会修改原列表，这是深拷贝。

x=[10,20,30,40,50,60]
x2=x[2:5]
print('x',x)
print('x2',x2)
print(id(x),id(x2))#id不相同
print(id(100),id(100))
x2[0]=300
print('x2的下标对应的元素被修改后：',x2)
print('x2的下标对应的元素被修改后的x：',x)

切片是一个数值，不能直接赋值。

x=[1,2,3,4,5]
x[0]=100
print(x)
#x[1:3]=100无法运行，x[1:3]是取值，无法把一个数值赋值给取值
#x[]=为赋值，=x[]是取值

x=[11,99,'hello',True,None,5675,[89,3547]]#列表本身就是一种数据，所以列表里面可以有列表
print(x)
x2=x[3:-1]
print(x2)
x2[0]=99999
print(x,x2)

x3=x[3:]
print(x,x3)
x3[0]=100
print(x,x3)

列表切片的元素是一种浅拷贝过来的元素。
切片后，新列表中的元素和原列表中的切片范围的元素“长的一样”是通过浅拷贝得到的。

y=[000,92331,'hello',True,332,889876,[89,3547]]
y2=y[4:]
print(y,y2)
y3=y2[1]
print(y3)
y3=999999
print(y,y2,y3,sep='\n')


print("-------")
list=[10,20,30,40,[88,99]]
Qlist=list[2:]
print(Qlist)
print(list)
Qlist[1]=55
Qlist[2][1]=1
print(Qlist)
print(list)

1.4删除列表元素

可以使用del对列表的元素进行删除，直接赋空值（None，会在原列表中留下一个None值。

x=[10,20,30,40,50]
#x[2]=None
del x[2]
print(x)
#对x[2]直接赋空值，会在原列表中留下一个None值。

1.5列表的操作符

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x)	1 2 3	迭代

x=[[10,20],[20,30],90,100]
x2=[10,20]
print(x[0],x2)
re=x2 in x #x2变量中保存的数据，在x中有没有一样的元素（数据一样就行不一定非得是同一个元素）
print(re)

1.6嵌套

使用嵌套列表即在列表里创建其它列表

a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
print(x)#[['a', 'b', 'c'], [1, 2, 3]]
print(x[1][2])#['a', 'b', 'c']
print(len(x))

# x[2][3][4][5] x是一个列表，取出下标为2的元素，取出的元素又是一个列表，再取出这个列表下标为3的元素，取出的元素又是一个列表……
x=[1,2,[1,1,1,[23,[232,23445,212,567,[13,5,7,8,0]]]]]
x2=x[2][3]
print(x2)

1.7常用API

序号	函数
1	len(list)列表元素个数
2	max(list)返回列表元素最大值
3	min(list)返回列表元素最小值
4	list(seq)将可迭代数据转换为列表（常见的官方提供的迭代数据有列表range）

序号	方法
1	list.append(obj)在列表末尾添加新的对象
2	list.count(obj)统计某个元素在列表中出现的次数
3	list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj)从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj)将对象插入列表
6	list.pop(index=-1)移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj)移除列表中某个值的第一个匹配项
8	list.reverse()反向列表中元素
9	list.sort( key=None, reverse=False)对原列表进行排序: x.sort(key=lambda a:abs(a-3), reverse=False)
10	list.clear()清空列表
11	list.copy()复制列表

#API
x=[1,2,3,4,5,6]
print(len(x))
print(max(x))
print(min(x))


x=[10,11,10,11,10,11]
print(x.count(10))

#count底层的设计相当于下面代码的片段
number1=[10,20]
n=0
count=0
while n<len(x):
    count+=number1 in x[n:]
    n+=1


x=[10,20,30,40]
x2=[10,1,2,3,3]
x.extend(x2)#会直接修改x列表
print(x)
#x.extend(20)会报错，只能传入可迭代数据
#x.extend([11,22],[224,335]]也会报错，可以执行两次以达到目的

x=[12,23,34,45,56]
re=x.index(23)
print(re)

x=[22,33,44,55,66,77]
x.insert(2,999999)#将原本下标为2的数据后移
print(x)
x.insert(100,'xixi')#越界的情况下，插到开头或者结尾
print(x)
x.insert(len(x),'hqyj')
print(x)

x=[10,20,30]
re=x.pop()#移除指定下标元素并返回对应元素，默认移除最后一个元素，不可以越界
print(re)
print(x)
re=x.pop(1)
print(re)
print(x)

x=[11,12,23,12,35,67]
re=x.remove(12)#移除第一个匹配到的元素
print(re)
print(x)
# re=x.remove(100)#越界的下标不能运行，会报错
# print(x,'666')

x=[11,22,33,44]
print(id(x))
x.clear()#移除原x的内部数据，id不变
print(x,id(x))
x=[]#重新赋值为空，更换id
print(x,id(x))

x=[11,22,33,44]
x2=x.copy()
print('x:',x)
print('x2:',x2)
print(x is x2)
print(id(x),id(x2))
x2[0]=100#修改x2内部数据
print(x,x2)#看看两个列表是不是都修改了

x=[[11,22,33],10,20]
x2=x.copy()
x2[0][0]=200
print(x,x2)

x=[11,22,33,44]
x2=x[::-1]
print(x,x2)
x3=x.reverse()
print(x3)#x.reverse()无法返回，直接对原数列操作
print(x)

x=[3,6,2,1,4,9,8,7]
x.sort(key=lambda x:x**2,)
print(x)

2.元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号 ( )，列表使用方括号 [ ]。

2.1创建元组

一旦创建了元组，就不能修改其内容。这意味着不能向元组中添加或删除元素，也不能改变已有元素的值。这一点与列表不同，列表是可以修改的

创建元组很简单，只需将元素放在圆括号内，并用逗号分隔，元组的小括号可以省略

x=(10,20,30,'hqyj','hello')
print(x)

x=10,20,30,40,'nihao'#元组可以省略小括号
print(x)

a=100
x=a,#元组也是一种数据容器
print(x)

如果只有一个元素的元组，需要在元素后面加上一个逗号来明确这是一个元组

x=(10)#只有一个元素时，如果不加逗号代表括号运算符，不是元组
print(x)
x=10,#只要一个元素的元组时，在元素后面添加逗号
x=(10,)#只要一个元素的元组时，在元素后面添加逗号
print(x)

2.2访问元组

可以通过索引来访问元组中的元素，索引从 0 开始：

x=10,20,30
print(x[2])
print(x[-1])
print(x[1:])

2.3修改元组

元组（tuple）是不可变的数据类型，但如果元组中含有可变的对象（如列表或字典），则可以通过间接的方式修改这些对象的内容。

如果元组包含了一个列表或字典等可变类型的数据，虽然不能直接改变元组的内容，但可以修改这些可变对象中的元素。

也可以通过拼接的方法将多个元组进行合并，达到修改的目的。

# x[0]=6666
# print(x) 会报错，元组、字符串、数字不可修改

x=10
x=20
print(x)#x变量是可以重新赋值为新的数据，但是x中保存的数字是不能改变的

x=[10,20,30]
print(id(x))
x[0]=100
print(id(x))#id没有变，数字是最小的存在，唯一性

#若元组内存在列表等可修改变量类型时，可以修改该变量内的数据
x=(1,2,3,[44,55,66])
x[3][0]=999
print(x)

x=(10,20,'hello')
a,b,c=x
#a=x[0] b=x[1] c=x[2]
#a,b,c=(10,20,'hello')
print(a)
print(b)
print(c)

x=10,20
x1=30,40
x2=x+x1
print(x2)

2.4删除元组

虽然无法对原则内的元素进行删除，但可以使用del将整个元组删除。

x=(12,987,'hello world',[2,'hqyj',Ture])
print(x)
del x
print(x)#name 'x' is not defined

2.5元组运算符

与字符串一样，元组之间可以使用 +、+=和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3)+(4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接得到一个新的元组
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print (x)	1 2 3	迭代

2.6元组常见API

序号	方法	描述
1	len(tuple)	返回元组中元素个数。
2	max(tuple)	返回元组中元素最大值。
3	min(tuple)	返回元组中元素最小值。
4	tuple(list)	将列表转换为元组。