从0开始学Python-day5-列表

原创已于 2024-10-23 19:54:41 修改 · 940 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#python #开发语言

于 2024-10-14 20:10:50 首次发布

从0开始学python 专栏收录该内容

20 篇文章

订阅专栏

Python列表(list)

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

列表是一种复合数据容器

list1 = ['openAI', 'hqyj', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

1、访问列表中的值

1.1 索引

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推。

列表的索引（下标，index）不能超出索引范围（越界）（正负都不行）

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )

x=[1,2,31,43,45]
for i in range(len(x)):#range表示的是数列这个数据容器
    print(i,x[i])
   
for el in x:
    print(el,'1111')

1.2 反向索引

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

1.3 切片索引

使用下标索引来访问列表中的值，同样你也可以使用方括号 [] 的形式截取字符

注意:切片是深拷贝操作，变量直接赋值是浅拷贝操作

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])

list = ['openAI', 'hqyj', "Zhihu", "Taobao", "Wiki"] 
# 读取第二位
print (list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print (list[1:-2])
# 从下标2开始(包含2)到最后一个
print (list[2:])
# 从下标0开始到下标3结束(左闭右开)
print (list[:3])

x=[20,30,40,50,60,70,80,90]
x2=x[3:5]#x2表示从x列表中截取一个片段 得到一个新的列表 [3,5)
print("x2",x2)
x3=x[2:-2]#[2,-2) 从左往右取数据 从2对应的元素开始取值 一直取到-2对应的元素
print("x3:",x3)
x4=x[-3:4]#从左往右取数据，如果切片的范围没能取到任何元素，就会得到一个空的列表（不会报错）
print("x4:",x4)
x5=x[1:100]
print("x5:",x5)
x6=x[60:100]#超过了不会报错
print("x6:",x6)
x7=x[:4]#省略冒号前面的 就表示从0开始
print(x7)
x8=x[4:]#省略冒号前面的 就表示到len()结束
print(x8)
x9=x[:-1]#不取最后一个元素
print(x9)
x9=x[-1:]#取最后一个
print(x9)
x10=x[1:6:2]#[x[1],x[3],x[5]]
print("x10:",x10)
x11=x[1:6:1]#[x[1],x[2],x[3],x[4],x[5]]
print('x11:',x11)
x12=x[:8:2]#0 2 4 6
print('x12:',x12)
x13=x[2::2]#2 4 6 8，从2下标开始取数据，步长2 一直取到结束
print('x13:',x13)
x13=x[::]#全取
x13=x[:]#全取
x16=x[::-2]
x17=x[1:5:-1]#不行 ，步长达不到0，取的为空
x17=x[5:1:-1]#可以
#步长填负数的，前面一般不取
#把一个列表反转
#[::-1]

2、更新列表

对列表的数据项进行修改或更新,也可以使用 append() 方法来添加列表项

list = ['openAI', 'hqyj', 1997, 2000]
print (list[2])
list[2] = 2001
print (list[2])
list1 = ['openAI', 'hqyj', 'Taobao']
list1.append('Baidu')
print (list1)

x=[10,20,30,40,50]
print(x[0])
x[0]=100#通过下标修改列表中的数据
print(x)
print(x[0])
#添加元素到列表的末尾
x.append(60)#只能给一个数据
print(x)
#更新切片 会修改原列表（深拷贝）
x=[10,20,30,40,50,60]
x2=x[2:5]
print("x:",x)
print("x2:",x2)
print(id(x),id(x2))#x和x2不是同一个id
print(id(100),id(100))
x2[0]=300
print("x2的下标0对应的元素被修改后",x2)
print("x2的下标0对应的元素被修改后",x)
#深拷贝和浅拷贝
#浅拷贝-共用一个内存
x=[10,20,30]
x2=x
x2[0]=100
print(x)
print(x2)
print(id(x),id(x2))
#深拷贝-两个数据一样，但是是两个内存空间
x=[100,200,300]
x2=[x[0],x[1],x[2]]
print(x)
print(x2)
x2[0]=999
print(x)
print(x2)

x=[100,200,300]
x2=[x[0],x[1],x[2]]
print(x)
print(x2)
x2[0]=999
print(x)
print(x2)
#切片后得到一个新的列表 切片是取值操作 不能赋值
x=[10,20,30,40]
x[0]=100
print(x)
x[1:3]=100#报错，数据是不能赋值给数据的
print("x:",x)
#x[1]=把下标为1的存储空间找到然后更新里面的数据
#=x[1]把下标为1的存储空间找到然后取出里面的数据

x=[10,20,"hello",-12,True,None,10000,[10,20,30,40]]
print(x)

x2=x[3:-1]
print(x2)
x2[0]=9999
print(x,x2)#深拷贝

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

x3[4]="hello"
print(x,x3)

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

x=[10,20,"hello",-12,True,None,10000,[10,20,30,40]]
x2=x[6:]
print(x,x2)
x3=x2[1]
print(x3[0])
x3[0]=9999
print(x,x2,x3)

3、删除列表元素

可以使用 del 语句来删除列表的的元素

list = ['openAI', 'hqyj', 1997, 2004]
print (list)
del list[2]
print (list)

x=[10,20,30,40,50]
del x[2]
#x[2]=None
print(x)
print(len(x))
print(x[2])

del x#删除变量
x=[]#更新变量/删除变量

4、列表操作符

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)
x2[0]=100
print(x2,x)

列表和列表不能相乘

#笔试题
x=[10,20,30,40]
r=range(len(x))#数列 也是数据容器
print(r)
for i in r:
    #print(i,x[i])
    #x[i]=i
    temp=x[i]
    del x[i]
    x.append(temp)
print(x)#[20,40,30,10]
#i=0,先删除10，再把10拼接到末尾，形成[20,30,40,10]
#i=1,先删除30，再把30拼接到末尾，形成[20,40,10,30]
#i=2,先删除10，再把10拼接到末尾，形成[20,40,30,10]
#i=3,先删除10，再把10拼接到末尾，形成[20,40,30,10]

5、嵌套列表

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

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

#嵌套列表
x=[1,2,3]
x2=["a","b","c"]
x3=[x,x2]
print(x3)#[[1, 2, 3], ['a', 'b', 'c']]
print(x3[0])#[1, 2, 3]
x4=x3[0]
print(x4)#[1, 2, 3]
print(x4[2])#3
print(x3[0][2])#3
#print(x3[[0],[3]])列表不能用列表取值

#x[2][3][1][6] x是一个列表 取出下标为2的元素 取出的元素又是一个列表 再取出这个列表的下标为3的元素..:
#x=[1,2,[1,1,1,[23,[23,23,23,3,3,3,[11,12,3,123,12,3]]]]]

x=[
    [[1,2,3],[23,23,23]],
[[1,2,3],[23,23,23]],
[[1,2,3],[23,23,23]],
]#三通道

6、Python列表常用API

操作列表的函数

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

re=range(20)
x=list(re)
print(x)#将range转换为列表
re='hello'
x=list(re)
print(x)#将字符串转换为列表 ['h', 'e', 'l', 'l', 'o']

列表的方法

序号	方法
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()反向列表中元素，直接对原列表进行修改。[::-1]:形成新的列表。
9	list.sort( key=None, reverse=False)对原列表进行排序: x.sort(key=lambda a:abs(a-3), reverse=False)
10	list.clear()清空列表。和x=[ ]有区别，clear清空后的的内存地址不改变。
11	list.copy()复制列表，深拷贝

x=[[10,20],10,20,[10,20]]
n=x.count(10)#1 查看x列表中的每一个元素有几个10
print(n)
print(x.count([10,20]))

#count底层的设计相当于下面的代码片段
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,4]
x.extend(x2)#会直接修改x列表
print(x)

x=[10,20,30]
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: [10, 20, 30]
#x2: [10, 20, 30]
#False
#2642203300160 2642203302016
#[10, 20, 30] [100, 20, 30]
#深拷贝

x=[[10,20,30],10,20]
x2=x.copy()#去查资料 看看是否能够传入什么参数 让它内部的元素拷贝时也是深拷贝
x2[0][0]=200#赋值
print(x,x2)
#[[200, 20, 30], 10, 20] [[200, 20, 30], 10, 20] 在最外层进行了深拷贝

x=[3,6,2,1,-4,9,8,7]
x.sort(key=lambda x:x**2)
x.sort(key=lambda x:abs(x))#对绝对值进行排序
x.sort(key=lambda a:abs(a-10),reverse=True)#离10的距离近远进行排序，True是从小到大排，False是从大到小排
print(x)#[1, 2, 3, -4, 6, 7, 8, 9]
#把列表x中每一个元素都先平方，再按平方值的大小对原来的列表x进行排序

#拓展知识：
# x=[[101,10,20,30,40,50,60,70,80],
#    [1023,10,20,30,40,50,60,70,80],
#    [10,10,20,30,40,50,60,70,80],
#    [10,10,20,30,40,50,60,70,80],
#    [10,10,20,30,40,50,60,70,80],
#    [10,10,20,30,40,50,60,70,80],
#    [10,10,20,30,40,50,60,70,80],
#    [10,10,20,30,40,50,60,70,80]]
#100行 80列 每一个都不太一样
import random
x=[]
for col in range(100):
    row = []
    for i in range(80):
        row.append(int(random.random() * 100))
    x.append(row)
print(x)
#把这个列表拆分成两个列表，一个包含前面9个，一个包含最后一个
#print(x_train)#[[101,10,20,30,40,50,60,70],[1023,10,20,30,40,50,60,70],[[10,10,20,30,40,50,60,70],...]
#print(y_train)#[[80],[80],[80],...]