Python基础知识5

傻瓜学习

已于 2024-09-29 19:32:23 修改

阅读量616

点赞数 10

文章标签： python 开发语言

于 2024-09-29 19:30:32 首次发布

本文链接：https://blog.csdn.net/m0_73723097/article/details/142629098

版权

Python列表

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

list1 = ['openAI', 'hqyj', 1997, 2000]

list2 = [1, 2, 3, 4, 5 ]

list3 = ["a", "b", "c", "d"]

list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

2. 列表是一种复合数据(数据容器)

x=[10,20,3.14,True,False,"hqyj"]

访问列表中的值

索引

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

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )#red
print( list[1] )
#green
print( list[2] )#blue
#列表的index和下标不能超出他的范围，超出了叫做越界(列表越界、数组越界)
print(list[20])#超出列表长度的范围，出现报错

2.列表遍历

x=[100,33,22,44,22,44,55]
for i in range(7):#range(x)的范围[0,x)
    print(x[i])

x=[100,33,22,44,22,44,55]
for i in len(x):#出错
    print(x[i])

#更改
x=[100,33,22,44,22,44,55]
for i in range(len(x)):
    print(x[i])          
    
for i in x:#出错，因为i in x表示i属于x列表中的数据，print(x[i])表示索引范围是x列表中的数据，可能超出范围
    print(x[i])

x=[100,33,22,44,22,44,55]
for el in x:#定义变量el，并让其属于x列表中，打印el，实现对列表的遍历
    print(el)

反向索引

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

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )#black
print( list[-2] )#white
print( list[-3] )#yellow
#列表的index和下标不能超出他的范围，超出了叫做越界(列表越界、数组越界)
print(list[-20])#超出列表长度的范围，出现报错

切片索引

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

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])
print(list[2:-3])#[]从左往右取数据，如果切片的范围没能取到任何元素，就会得到一个空列表，不会报错，但取值超出范围就会报错
print(list[-1:])#取最后一个
print(list[::-1])#['Wiki', 'Taobao', 'Zhihu', 'hqyj', 'openAI'] 翻转列表数据，也可以说从0下标开始步长为-1,，取到结束-1，-2，-3……
print(list[2::-1])#['Zhihu', 'hqyj', 'openAI'] 前三个数据翻转列表数据，也就是说从2下标开始步长为-1，取到结束-3，-4……
print(list[2::2])#['Zhihu', 'Wiki'] 从2下标开始步长为2，取到结束
print(list[::1])#从['openAI', 'hqyj', 'Zhihu', 'Taobao', 'Wiki'] 头取到尾,步长为1
print(list[1:5:-1])# [] 超出了范围
#注意:切片是深拷贝操作

2.深拷贝和浅拷贝

x=[10,20,30]
x2=x
print(x,x2)
print(id(x),id(x2)) # 2798377425088 2798377425088 地址相同
x2[0]=100#x和x2索引为0的元素都会改变，叫做浅拷贝

x=[100,200,300]
x2=[x[0],x[1],x[2]] # 获取x的值
print(x,x2) # [100, 200, 300] [100, 200, 300]
print(id(x),id(x2)) # 2798377756096 2798377760000 地址不相同
x2[0]=999
print(x,x2) # [100, 200, 300] [999, 200, 300] 更改x2的元素不会改变x的元素

3.列表切片的元素是浅拷贝过来的元素

x=[10,20,"hello",-12,True,False,10000,[10,20,30,40]]
x2=x[6:]
x2[0]="hello"
#[10, 20, 'hello', -12, True, False, 10000, [10, 20, 30, 40]]
#['hello', [10, 20, 30, 40]]
print(x,x2)
x3=x2[1]#获取切片中的列表
print(x3)#[10, 20, 30, 40]
print(x3[0])#10
x3[0]=9999999#更改获取的切片中的列表的1值
#[10, 20, 'hello', -12, True, False, 10000, [9999999, 20, 30, 40]]
#['hello', [9999999, 20, 30, 40]]
# [9999999, 20, 30, 40]
print(x,x2,x3)

x4=x2[0]#获取切片中的元素
x4=5#更改获取后的元素的值
#[10, 20, 'hello', -12, True, False, 10000, [9999999, 20, 30, 40]]
# ['hello', [9999999, 20, 30, 40]]
# 5
print(x,x2,x4)

x=[10,20,"hello",-12,True,False,10000,[10,20,30,40]]
x2=x[3:-1]
print(x2) # [-12, True, False, 10000]
x2[0]=9999
# [10, 20, 'hello', -12, True, False, 10000, [10, 20, 30, 40]]
# [9999, True, False, 10000]
print(x,x2) # 更改x2的元素不会改变x的元素

4.更新切片，会产生一个新的原列表地址(深拷贝)

x=[10,20,30,40,50,60]
x2=x[2:5]
print("x:",x)#x: [10, 20, 30, 40, 50, 60]
print("x2:",x2)#x2: [30, 40, 50]
print(id(x),id(x2))#2164671895744 2164671893824 x和x2不是同一个id
x2[0]=300 # 改变了切片的值，但是再次获取x的同一个切片并且和x的值进行比较，发现x的值依旧未改变
x[2:5][0]=22 #误区 如果切片不存在一个切片中，那么访问这个切片的内容会直接在次与原列表中获取切片内容并覆盖掉此时的切片内容
print(x2) # [300, 40, 50]
print(x[2:5],x)#[30, 40, 50] [10, 20, 30, 40, 50, 60] 在此获取了一次切片 说明切片产生了一个新列表，产生了一个新的内存地址，切片与列表成为两个独立的列表
print(id(x[2:5]),id(x[2:5]))#输入同一个切片

5.列表进行切片时不能进行赋值

x=[10,20,30,40]
#把下标为0的存储空间找到，然后取出里面的数据
x[0]=100
print(x)#[100, 20, 30, 40]
#切片后的到的是一个列表，切片是取值操作 不能赋值
x[1:3]=100# 报错，不能进行迭代，因为切片在进行取值，并且是一个列表，所以一个值不能赋值给一个正在运行取值的迭代列表
print(x)

更新列表

1.对列表的数据项进行修改或更新

list = ['openAI', 'hqyj', 1997, 2000]
list[2] = 2001
print (list[2])#2001

2.使用 append() 方法来添加列表项(每次添加一个)

list1 = ['openAI', 'hqyj', 'Taobao']
list1.append('Baidu')
print (list1)

3.append() 不可以一次性添加多个

删除列表元素

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

#del删除
list = ['openAI', 'hqyj', 1997, 2004]
del list[2]
print (list)#['openAI', 'hqyj', 2004]
print(len(list))#3

#赋值为None
list = ['openAI', 'hqyj', 1997, 2004]
list[2]=None
print(list)#['openAI', 'hqyj', None, 2004]
print(len(list))#4

2.del删除整个列表

列表操作符

len([1, 2, 3])、for x in [1, 2, 3]: print(x)

1.笔试题

#引入，
#用len(x)求出列表的长度范围
x=[10,20,30,40]
re=range(len(x))# 数列 也是数据容器
print(re)#range(0, 4)
for i in range(len(x)):
    print(i)#0,1,2,3 最终循环的值是列表的下标而不是列表的值
    
# 逻辑
#i=0 [20,30,40,10]
#i=1 [20,40,10,30]
#i=2 [20,30,10,40]
#i=3 [20,30,40,10]
x=[10,20,30,40]
for i in range(len(x)):# 循环列表长度加1
    # print(i,x[i])
    temp=x[i]#temp被赋值为列表的数据
    del x[i]
    x.append(temp)#在列表后添加数据
print(x) # [20, 40, 30, 10]
print(temp,type(temp)) # 10 <class 'int'>a

[1, 2, 3] + [4, 5, 6]

x=[10,20,30,40]
x2=x+[10,20,30]
print(x2)#[10, 20, 30, 40, 10, 20, 30]

['Hi!'] * 4

x3=x*2
print(x3)#[10, 20, 30, 40, 10, 20, 30, 40]

3 in [1, 2, 3]

c=10 in x#判断语句，10是否在x列表中
print(c)#True

x=[[10,20],[20,30],90,100]
x2=[10,20]
print(x[0],x2) # [10, 20] [10, 20]
re=x2 in x # x2变量值保存中的数据，在x中有没有"一样"的元素(数据一样不一定非得是同一个元素)
print(re) # True
x3=[90,10]
re1=x3 in x#x3中要全部包含在x中才会返回True
print(re1) # False
x[0]=100
print(x2,x) #[10, 20] [100, [20, 30], 90, 100] 列表中的列表元素可以被修改为非列表元素

嵌套列表

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

x=[1,2,3,4]
x2=["a","b","c"]
x3=[x,x2]
print(x3) # [[1, 2, 3, 4], ['a', 'b', 'c']]
print(x3[0]) # [1, 2, 3, 4]
x4=x3[0]
print(x4) # [1, 2, 3, 4]
print(x4[3]) # 4
print(x3[0][3]) # 4 x3[0]取出来x3列表中的元素列表，再来一个索引[3]表示取出x3中的元素列表中的索引为3的元素
print(x3[0:2]) # [[1, 2, 3, 4], ['a', 'b', 'c']]
# print(x3[[0],[1]])#报错，列表不能多个一起取
# x=[2][3][1][6]#x是一个列表，去除下标为2的元素 取出的元素又是一个列表 再取出这个列表的下标为3的元素……

2.三通道

x=[
    [[1,2,3],[23,23,2],[23,23,2],[23,23,2],[23,23,2],[23,23,2],[23,23,2],[23,23,2]],
    [[1,2,3],[23,23,2],[23,23,2],[23,23,2],[23,23,2],[23,23,2],[23,23,2],[23,23,2]],
    [[1,2,3],[23,23,2],[23,23,2],[23,23,2],[23,23,2],[23,23,2],[23,23,2],[23,23,2]]
   ]

Python列表常用API

操作列表的函数

len(list)、max(list)、min(list)

1.len(list)：列表元素个数

2.max(list)：返回列表元素最大值

3.min(list)：返回列表元素最小值

x=[10,20,30,None,40]
print(len(x))#5
# print(max(x))#报错,None不能进行比较，没有具体数字大小的都不能

list(seq)

1.list(seq):将可迭代数据转换为列表，常见的官方提供的可迭代的数据有：列表、元组、range、字符串

#range
re=range(20)
x=list(re)
print(x) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
#字符串
re="hello"
x=list(re) # ['h', 'e', 'l', 'l', 'o']
print(x)
#元组
re=(10,20,30,40)
x=list(re)
print(x) # [10, 20, 30, 40]

2.补充：callable()是python的内置函数，用来检查对象是否可被调用，可被调用指的是对象能否使用()括号的方法调用，类似于iterable（）

3.出现以下报错，是因为由于变量list和函数list重名了，所以函数在使用list函数时，发现list是一个定义好的列表，而列表是不能被调用的，因此抛出一个类型错误

列表的方法

list.index(obj)、list.append(obj)

1.list.index(obj):从列表中找出某个值第一个匹配项的索引位置

2.list.append(obj):在列表末尾添加新的对象

list.count(obj)

1.list.count(obj):统计某个元素在列表中出现的次数

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

# #count底层的设计相当于下面的代码片段
x=[10,20,30,40,20,30,10,[10,20]]
number=[10,20]
n=0
count=0
while n<len(x):
    count+=number in x[n:n+1]#布尔表达式，结果为True(1)或False(0)
    n+=1
print(count)

list.extend(seq)

1.list.extend(seq):在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

x=[10,20,30,40]
x2=[10,1,2,3,3]
x.extend(x2)#会直接修改x列表
print(x) # [10, 20, 30, 40, 10, 1, 2, 3, 3]
re=x.extend(x2)
print(re)#None 无返回值
x.extend([10,20,30])
# x.extend([10,20,30],[23,32,4,2,3])
# print(x)#报错
# x.extend(10)
# print(x)#报错
x.extend("华清远见")#填入可迭代的数据
print(x) # [10, 20, 30, 40, 10, 1, 2, 3, 3, 10, 1, 2, 3, 3, 10, 20, 30, '华', '清', '远', '见']
x.extend(range(2,9,3)) #
print(x) # [10, 20, 30, 40, 10, 1, 2, 3, 3, 10, 1, 2, 3, 3, 10, 20, 30, '华', '清', '远', '见', 2, 5, 8]

list.insert(index, obj)

1.list.insert(index, obj):将对象插入列表

x=[10,20,30,40]
x.insert(2,999999)
print(x)# [10, 20, 999999, 30, 40]
x.insert(1000,999999)
print(x)# [10, 20, 999999, 30, 40, 999999]
x.insert(-100,999999)#插入元素到指定位置时越界了，就插入到开头或末尾
print(x)#[999999, 10, 20, 999999, 30, 40, 999999]
x.insert(len(x),123)
print(x)# [999999, 10, 20, 999999, 30, 40, 999999, 123] 在列表的末尾加上元素

list.pop(index=-1)、list.remove(obj)、list.clear()

x=[10,20,30]
#re=x.pop()
re=x.pop(0)#移除指定的下标对应的元素，返回这个移除的元素，默认移除最后一个元素
print(re) # 10
print(x) # [20, 30]

# re=x.pop(100)
print(re) # 10 移除指定下标不能越界，会报错

2.list.remove(obj)移除列表中某个值的第一个匹配项
x=[10,20,30,40,50,10]
x.remove(10)
print(x)# [20, 30, 40, 50, 10]移除第一个匹配到元素
# x.remove(100)#如果移除的元素没有在列表,报错

3.list.clear():清空列表
x=[10,20,30]
print(id(x))# 1872078952640 
x.clear()#全部清楚
print(x,id(x))# [] 1872078952640 与清楚之前的id值相同，说明是同一个列表
x=[]
print(x,id(x))# [] 1872078950720 地址不同 说明与被清除的列表不是同一个列表

list.copy()

1.list.copy()：复制列表

x=[10,20,30]
x2=x.copy()
print("x:",x,"x2:",x2) # x: [10, 20, 30] x2: [10, 20, 30]
print(x is x2) # False 并不存在与同一个地址
print(id(x),id(x2)) # 2226615605440 2226615603520
x2[0]=100#修改x2内部的数据，验证是否是浅拷贝或者深拷贝,属于深拷贝
print(x,x2) # [10, 20, 30] [100, 20, 30]

list.reverse()

1.list.reverse():反向列表中元素

x=[10,20,30,40]
x2=x[::-1]
print(x,x2) # [10, 20, 30, 40] [40, 30, 20, 10]
x3=x.reverse()#直接对原数据进行操作
print(x3)#无返回值 None
print(x) # [40, 30, 20, 10]

list.sort( key=None, reverse=False)

1.list.sort( key=None, reverse=False)对原列表进行排序: x.sort(key=lambda a:abs(a-3), reverse=False)

x=[10,7,20,5,30,2,3,40]
x.sort(key=lambda a:a**2)#将每个元素取出来在平方，平方之后从小到大排列顺序，但最后排列平方之前的数据
x.sort(key=lambda a:(a-10))#那个点距离时最近
print(x) #[2, 3, 5, 7, 10, 20, 30, 40]