跳至主要內容

04-列表

黑静美...大约 11 分钟编程python
student = ['Lilei', 18, 'class01',201901]
student = ['W', 18, 'class02',201902]

1. 列表的特征

  • 利用中括号表示列表

  • 列表内的元素用逗号隔开

  • （半角）

    • 列表的可变性：可以修改列表里的内容

    • 字符串强制转化为列表

      （每个字母/数字/独立的汉字/空白占位符均被隔开）

str_to_list = list("じ Übung 好")
print(str_to_list)

#---output---
#['じ', ' ', 'Ü', 'b', 'u', 'n', 'g', ' ', '好']

2. 下标相关

获取列表的某一个元素

编程语言中通常第一个位置的编号是0

例：提取99和80

grade = [98, 99, 95, 80]
print(grade[1],grade[3])
print(grade[1::2])

#---output---
# 99 80
# [99, 80]

连续读取

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[2:6])
# [2, 3, 4, 5]

倒置列表

grade_r_side_l = grade[::-1]
print(grade_r_side_l )

#---output---
# 99 80
# [80, 95, 99, 98]

3.

1. 更改列表的元素

In [7]: name = list('python')

In [8]: name[2:]
Out[8]: ['t', 'h', 'o', 'n']

In [9]: name[2:] = list("abc")

In [10]: name
Out[10]: ['p', 'y', 'a', 'b', 'c']

2. 列表内插入内容

name = [1, 5]
print(name[1:1]) #指向1和5之间
# []
name[1:1] = [2,3,4] 
print(name)
# [1, 2, 3, 4, 5]
name[1:4] = [ ]
print(name)
# [1, 5]
  • 练习
numbers = [1, 2, 3, 5, 6]

#---output---
[1, 2, 3, 4, 5, 6]

numbers = [1, 2, 3, 5, 6]
numbers[2:2] = [4]
print(numbers)

获取用户输入:

numbers = [1, 2, 3, 5, 6]
val = int(input("The values you want to add in>>>"))
position = int(input("The position of the value>>>"))

# equal
numbers[position:position] = [val]
print(numbers)

3. 列表的加法1

numbers = [1, 2, 3, 5, 6]
# equal
result = numbers[:position] + [val] + numbers[position:]
print(result)

4. 在列表的特定位置插入元素「.insert(index,element)」

.int(index, element)是一个列表的基本方法，用于在列表特定位置插入元素。

它的基本语法是：

list.insert(index,element)

index： 指定要插入的元素的位置，索引从0开始。如果指定的索引超出了列表的当前长度， 不会报错，元素会被插入列表的末尾

element 想要插入的元素

# equal
result2 = numbers.insert(position, val)
print(result2)

5.修改列表中的元素2

list[index] = new

name = ["Lilei", 'W']
print("before: ", name)

name[0] = "Han Meimei"
print("after: ", name)

before:  ['Lilei', 'W']
after:  ['Han Meimei', 'W']

  • 修改多个数据

    numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print('before: ', numbers)
print(id(numbers))
numbers[1:5] = ['one', 'two', 'three', 'four'] #修改相同数量
print('afters: ', numbers)
print(id(numbers))
numbers[1:5] = ['one', 'two']  #修改不同数量
print('afters2: ', numbers)
print(id(numbers))             #可变性：地址相同的同一数据可以进行修改
numbers[1:5] = ['one', 'two', 'three', 'four']  #修改不同数量
print('afters2: ', numbers)
print(id(numbers)) 

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]   #本质算是新的数据
print('before: ', numbers)
print(id(numbers))
numbers[1:5] = ['one', 'two']  
print('afters2: ', numbers)
print(id(numbers))

    numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print('before: ', numbers)

numbers[1]= 'have a nice day' #字符串作为元素填入，第1个元素，当替换掉单一元素时，括号可省略，但是存在一些问题（如下）
print('1:',numbers)

numbers[1:3]= ['have', 'a nice day'] #字符串作为元素填入
print('2:',numbers)

  • 列表要替换的元素数量与要填入的元素数量不一致（存在的问题）

    • 字符串将拆分成列表填入
    numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]   #本质算是新的数据
print('before: ', numbers)

numbers[1]= 'have a nice day' #字符串作为元素填入，第1个元素
print(numbers)

numbers[1:3]= ['have', 'a nice day'] #字符串作为元素填入
print(numbers)

numbers[1:5]= 'have a nice day' #字符串将拆分成列表填入，并替换掉1-4的元素
print(numbers)
    • 数字型(以及布尔型）报错
    • 集合将拆分成列表填入
    • 集合将拆分成列表填入，并且乱序
    • 字典串将拆分成列表填入，并丢去目录
numbers[0]= 123  #数字型作为元素填入
print('7:',numbers)

###todo #can only assign an iterable

#numbers[0:2]= 123   #报错,数字型填入的数量不能和原数量不一致
#print('8:',numbers)

#numbers[1:1]= 123   #报错
#print('9:',numbers)


numbers[0]= {1,1,2,4,3,5}  #集合作为元素填入
print('10:', numbers)

numbers[0:2]= {1,1,2,4,3,5}  #集合作为元素填入，将拆分成列表填入
print('11:', numbers)

numbers[0:0]= (-1,0) #元组作为元素填入，将拆分成列表填入
print('12:', numbers)

numbers[0:0]= {'1':-2,'2':-3} #字典作为元素填入，将拆分成列表填入，并舍去目录
print('13:', numbers)

6. 末尾添加元素

a. 使用.append()在末尾添加元素

b. .extend()
lst = ['钥匙','毒药']
print('before:',lst)
print(id(lst))
lst.append('解药') #append每次只能添加一个元素
print('after:',lst)
print(id(lst))

lst.extend([1,2,3,43,5]) #extend可以添加多个元素
print('extend:',lst)

7. 删除元素

c. del删除元素

del 需要指定列表中要删除的单个元素或多个元素 如果不指定元素则删除整个变量

student_list =['Lilei',"W",'Hanmeimei']
del student_list[0]
print(student_list)
del student_list
# print(student_list) #报错
# NameError: name 'student_list' is not defined

d. .pop()默认删除最后一个元素

student_list =['Lilei',"W",'Hanmeimei']
student_list.pop() #默认删除最后一个
print(student_list)
student_list.pop(0) #删除指定元素（通过下标指定）
print(student_list)

e. .remove()指定删除列表中的元素

student_list.remove('W') #删除指定元素（通过内容指定）
print(student_list)

8. 使用+加号相加多个列表_加法2

numbers1= [0,1,2,3,4]
numbers2= [5,6,7,8,9]
print(numbers1+numbers2)

9. len长度

使用len()获取长度

student_list = ["Lilei", 'W',"Han Meimei"]
print(len(student_list))
print(len(student_list[0]))
#---output---
3
5

10. in

value in Sequence

判断某个值是否在列表中

inventory = ['钥匙','毒药', '解药']
print('毒药' in inventory) #返回布尔值
print('迷药' in inventory)
使用if条件
inventory = ['钥匙','毒药', '解药']
if '解药' in inventory:
    print('yes')
else:
    print('no')

True
False
yes

判断某个值是否在字典中

dct = {'x':'钥匙', 'y':'毒药', 'z':'解药'}
print('x'in dct)
print('钥匙' in dct)  # 在字典中检索的是'key'的内容

想检索字典中的值应该加入.values()

dct = {'x':'钥匙', 'y':'毒药', 'z':'解药'}
print('钥匙' in dct.values()) 

True
False
True

11. 获取列表中某个元素重复的次数 .count()

numbers = [0,1,1,2,3,4,1]
print(numbers.count(1))

12. .index()

寻找目标列表中的元素第一次出现的下标。不存在则会报错

numbers = [0,1,1,2,3,4,1]
print(numbers.index(1))
#output: 1

# print(numbers.index('i'))
# print(numbers.index('1'))

# print(numbers.index('i'))
    print(numbers.index('i'))
ValueError: 'i' is not in list

# print(numbers.index('1'))
    print(numbers.index('1'))
ValueError: '1' is not in list

13. 翻转列表.reverse()

numbers = [2, 1, 4, 3, 7, 6, 5, 0, 9, 8]
print(numbers)
print('id:',id(numbers))
numbers.reverse()
print(numbers)
print('id:',id(numbers))

14. 列表排序.sort()

使列表元素从大到小排列，直到修改到列表本身。如果指定reverse = True， 则降序排列。

numbers = [2, 1, 4, 3, 7, 6, 5, 0, 9, 8]
print(id(numbers))
numbers.sort()
print(numbers)
print(id(numbers))
numbers.sort(reverse=True)
print(numbers)

[2, 1, 4, 3, 7, 6, 5, 0, 9, 8]
id: 4298523392
[8, 9, 0, 5, 6, 7, 3, 4, 1, 2]
id: 4298523392
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
id: 4298523392
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

15. 列表排序2.sorted()

numbers2 = sorted(numbers, reverse=False)  #reverse=False 可以不写，为默认值
print(numbers2)
numbers2 = sorted(numbers)
print(numbers2)

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

两种排序的区别及注意事项

练习

numbers = '132569874'

numbers = list(numbers)
print(numbers)

print(numbers[::2].sort(reverse=True))  #错误
# output: None

numbers2 = numbers[::2]
numbers2.sort(reverse=True)
numbers[0::2] = numbers2
print(numbers)

['1', '3', '2', '5', '6', '9', '8', '7', '4']
None
['8', '3', '6', '5', '4', '9', '2', '7', '1']

16. 深浅拷贝

a. 直接赋值

x = ['毒药','解药','感冒药']
y = x # y直接读取了同一个变量
print(f'Original: \n\t x:{x} \n\t y:{y} \n\t id_x: {id(x)}\t id_y: {id(y)}') # id_x与 id_y相同
y[0] = '消炎药'
print(f'After: \n\t x:{x} \n\t y:{y} \n\t id_x: {id(x)}\t id_y: {id(y)}')

Original: 
	 x:['毒药', '解药', '感冒药'] 
	 y:['毒药', '解药', '感冒药'] 
	 id_x: 4346479616	 id_y: 4346479616
After: 
	 x:['消炎药', '解药', '感冒药'] 
	 y:['消炎药', '解药', '感冒药'] 
	 id_x: 4346479616	 id_y: 4346479616
观察数据的存储方式
open in new window
open in new window

网站 Pythontutor 输入该代码查看/uparrow/uparrow​

`y = x`在 **列表** 当中直接让`y`和`x`指向了同一地址

b. .copy()

x = ['消炎药','解药','感冒药']
y = x.copy()
print(f'Original: \n\t x:{x} \n\t y:{y} \n\t id_x: {id(x)}\t id_y: {id(y)}')
y[0] = '毒药'
print(f'After: \n\t x:{x} \n\t y:{y} \n\t id_x: {id(x)}\t id_y: {id(y)}')

Original: 
	 x:['消炎药', '解药', '感冒药'] 
	 y:['消炎药', '解药', '感冒药'] 
	 id_x: 4314039424	 id_y: 4314041280
After: 
	 x:['消炎药', '解药', '感冒药'] 
	 y:['毒药', '解药', '感冒药'] 
	 id_x: 4314039424	 id_y: 4314041280
观察数据的存储方式
image-20240526164104901
image-20240526164104901
存在的问题
x = ['毒药','解药','感冒药',['香蕉','橘子','梨']]
y = x.copy()
print(f'Original 2:\n\tx: {x}\n\ty: {y}\n\tid:\n\t\tid_x: {id(x)}\n\t\tid_y: {id(y)}\n\t\tid_children x[3]: {id(x[3])}\n\t\tid_children y[3]: {id(y[3])}')
y[3][0] = '苹果'
print(f'After 2:\n\tx: {x}\n\ty: {y}\n\tid:\n\t\tid_x: {id(x)}\n\t\tid_y: {id(y)}\n\t\tid_children x[3]: {id(x[3])}\n\t\tid_children y[3]: {id(y[3])}')

Original 2:
	x: ['毒药', '解药', '感冒药', ['香蕉', '橘子', '梨']]
	y: ['毒药', '解药', '感冒药', ['香蕉', '橘子', '梨']]
	id:
		id_x: 4336204800
		id_y: 4336339840
		id_children x[3]: 4336337984
		id_children y[3]: 4336337984
After 2:
	x: ['毒药', '解药', '感冒药', ['苹果', '橘子', '梨']]
	y: ['毒药', '解药', '感冒药', ['苹果', '橘子', '梨']]
	id:
		id_x: 4336204800
		id_y: 4336339840
		id_children x[3]: 4336337984
		id_children y[3]: 4336337984
使用copy复制出的新列表，子列表依然使用原地址
解决方案1

更改 y[3]

#解决方案1
y[3] = ['苹果','橘子','梨']
print(f'After 2:\n\tx: {x}\n\ty: {y}\n\tid:\n\t\tid_x: {id(x)}\n\t\tid_y: {id(y)}\n\t\tid_children x[3]: {id(x[3])}\n\t\tid_children y[3]: {id(y[3])}')

After 2:
	x: ['毒药', '解药', '感冒药', ['香蕉', '橘子', '梨']]
	y: ['毒药', '解药', '感冒药', ['苹果', '橘子', '梨']]
	id:
		id_x: 4369517888
		id_y: 4369515392
		id_children x[3]: 4369514560
		id_children y[3]: 4369515136
解决方案2⬇️

c. deepcopy

使用深拷贝需要导入库

from copy import deepcopy

具体实现：

from copy import deepcopy

x = ['毒药','解药','感冒药',['香蕉','橘子','梨']]
y = deepcopy(x)
print(f'Original 2:\n\tx: {x}\n\ty: {y}\n\tid:\n\t\tid_x: {id(x)}\n\t\tid_y: {id(y)}\n\t\tid_children x[3]: {id(x[3])}\n\t\tid_children y[3]: {id(y[3])}')
y[3][0] = '苹果'
print(f'After 2:\n\tx: {x}\n\ty: {y}\n\tid:\n\t\tid_x: {id(x)}\n\t\tid_y: {id(y)}\n\t\tid_children x[3]: {id(x[3])}\n\t\tid_children y[3]: {id(y[3])}')

常见的内置函数表格

下面是 Python 列表常见的内置函数表格：

序号函数名函数用法说明代码演示
1append()向列表末尾添加一个元素lst.append(4)
2extend()将一个列表中的所有元素添加到另一个列表中lst.extend([4, 5])
3insert()在指定位置插入一个元素lst.insert(1, 'a')
4remove()删除列表中的第一个匹配项（指定的值）lst.remove('a')
5pop()删除并返回列表中的一个元素（默认最后一个元素）lst.pop()
6clear()清空列表lst.clear()
7index()返回列表中指定元素的第一个匹配项的索引lst.index('a')
8count()计算列表中某个元素出现的次数lst.count(1)
9sort()对列表中的元素进行排序（默认升序）lst.sort()
10reverse()反转列表中的元素顺序lst.reverse()
11copy()返回列表的浅复制new_lst = lst.copy()
12len()返回列表中的元素数量len(lst)
13sum()计算列表中所有数字元素的总和（元素需要是数字类型）sum([1, 2, 3])
14min()返回列表中的最小值（元素需要可比较）min([1, 2, 3])
15max()返回列表中的最大值（元素需要可比较）max([1, 2, 3])
16sorted()返回列表排序后的新列表sorted([3, 1, 2])
17all()检查列表中所有元素是否都为真（非零或非空）all([1, 2, 3])
18any()检查列表中是否存在至少一个真值（非零或非空）any([0, 0, 1])
19enumerate()枚举列表，返回索引和元素的元组list(enumerate(['a', 'b', 'c']))
20zip()将多个列表中相同位置的元素配对，形成新的元组列表list(zip([1, 2], ['a', 'b']))
21map()对列表中的每个元素应用一个给定的函数，返回结果的迭代器list(map(str, [1, 2, 3]))
22filter()过滤列表中的元素，只返回使给定函数为真的元素list(filter(lambda x: x > 1, [1, 2, 3]))

这些函数涵盖了列表处理的大部分需求，从基本的添加和删除操作到更复杂的排序和转换处理。

练习

给定两个列表，合并这两个列表并按升序排序。给定一个列表，找出最大值和最小值

max(list)、min(list) 得到列表的最大值和最小值

17. max、min

上次编辑于:
贡献者: Heijingmei
0  字
评论
  • 按正序
  • 按倒序
  • 按热度
Powered by Waline v3.1.3
网页设计 by @黑静美 しずみ Lilya
Copyright © 2024 黑静美