day07列表相关操作学习总结

day07列表进阶

1.列表相关操作

1.数学运算：+、*

#列表1+列表2 —— 将列表1和列表2中的元素合并成一个新的列表

#列表 * N、N * 列表 —— N个指定列表合并成一个新的列表(列表中的元素重复N次产生一个新的列表)

list1 = [10，20，30]

list2 = [100，200]

result = list1 + list2

print(result)  #[10,20,30,100， 200]

result = list * 3
print(result)    #[10, 20, 30, 10, 20, 30, 10, 20, 30,]

2.比较运算符：

<、>、>=、<=、==、!=

1）比较相等：

、

print([10, 20, 30] == [10, 20, 30])     #True

print([10, 20, 30] == [20, 10, 30])      # False

print([10] == 10)     #  False

2)比较大小：

<、>、>=、<=

两个列表比较大小，比较的是第一对不相等的元素的大小。

list1 = [20, 30, 40,50]
list2 = [21, 2]
print(list1 > list2)  # False
print([10, 3, 300, 400] < [10, 4, -100])  # true

3. in 和 not in

元素 in 列表 —— 判断列表中是否存在指定元素

元素 not in列表 —— 判断列表中是否不存在指定元素

print(10 in [100, 200, 300])   # False

2.相关函数

1. sum

sum（列表）- 求列表中所有元素的和(要求列表中所有的元素都必须是数字)

scores = [29，34，8.9,98，99]
print( sum( scores ))    #268.9

print( sum( range( 1, 101)))   #5050

2. max、min

max(列表) —— 求列表中值最大的元素

max(数据1， 数据2， 数据3， …) —— 求多个数据中的最大值

scores = [29, 34, 8.9, 98, 99, 72]
print(max ( scores ))   #99
print(min( scores ))  #8.9

a, b, c = 100，30，200
print(max( a, b, c))
print(min( a, b, c))

3. sorted

sorted(列表）- 将列表中的所有的元素从小到大排序，产生一个新的列表（不会修改原列表)

sorted(列表, reverse=True) - 将列表中的所有的元素从大到小排序，产生一个新的列表〈不会修改原列表)

scores = [29, 34, 8.9, 98,  99, 72]
new_scores = sorted(scores)
print(new_scores)       #[8.9, 29, 34， 72, 98, 99]

new_scores = sorted( scores, reverse=True)

print( new_scores)      #[99, 98, 72, 34, 29, 8.9]

4. list

list(序列) —— 将指定数据转换成列表(数据必须是容器型数据类型的数据)

所有的序列都可以转换成列表;转换的时候会将序列中的元素作为列表的元素

print( list( 'abc " ))  # [ 'a ' , 'b ', 'c "]
print( list(range(3))   # [0, 1，2]

3.列表相关方法

1.列表.clear()

清空列表

nums =[29,78，9,23]
print(nums)
nums.clear()
print(nums)   #[]

2.列表.copy()

复制指定的列表产生一个一模一样的新列表并且返回

列表[:] == 列表.copy() == 列表*1 == 列表+[]

A = [29, 78, 9, 23]
B = A
C = A.copy()
print('A:', A)      # A: [29, 78, 9, 23]
print('B:', B)      # B: [29, 78, 9, 23]
print('C:', C)      # C: [29, 78, 9, 23]

A.append(100)
A[0] = 290
print('A:', A)          # A: [290, 78, 9, 23, 100]
print('B:', B)          # B: [290, 78, 9, 23, 100]
print('C:', C)          # C: [29, 78, 9, 23]

print(id(A), id(B))
print(id(A), id(C))

3.列表.count(元素)

统计列表中指定元素的个数

A = [29, 78, 9, 23, 100, 9]
print(A.count(10))      # 0
print(A.count(9))       # 2

4.列表.extend(序列)

将序列中的元素全部添加到列表的最后

A = [29, 78, 9, 23]
print(A)        # [29, 78, 9, 23]
A.append([10, 20])
print(A)        # [29, 78, 9, 23, [10, 20]]


A = [29, 78, 9, 23]
print(A)        # [29, 78, 9, 23]
A.extend([10, 20])
print(A)        # [29, 78, 9, 23, 10, 20]

A = [29, 78, 9, 23]
print(A)
A.append('abc')
print(A)        # [29, 78, 9, 23, 'abc']


A = [29, 78, 9, 23]
print(A)
A.extend('abc')
print(A)        # [29, 78, 9, 23, 'a', 'b', 'c']

5.列表.index(元素)

获取指定元素在列表中的下标值(0开始的下标值)

A = [29, 78, 9, 23, 9]
print(A.index(78))      # 1
print(A.index(9))       # 2
# print(A.index(1))     # 报错！

6.列表.reverse()

将列表倒序

A = [29, 78, 9, 23, 9]
A.reverse()
print(A)        # [9, 23, 9, 78, 29]

7.列表.sort()

列表.sort(reverse=True)

A = [29, 78, 9, 23, 9]
new_A = sorted(A)
print(new_A, A)     # [9, 9, 23, 29, 78]
A = [29, 78, 9, 23, 9]
A.sort()
print(A)        # [9, 9, 23, 29, 78]

4. 列表推导式*

列表推导式 - 快速创建列表的表达式

1.结构1

[表达式 for 变量 in 序列]

功能:创建列表，列表中的元素就让变量去序列中取值，取一个值就计算一次表达式的结果，这个结果就是列表的元素

result = [10 for x in range(4)]
print(result)       # [10, 10, 10, 10]

result = [10*x for x in range(4)]
print(result)       # [0, 10, 20, 30]

练习1：提取 nums 中所有元素的个位数

[nums = [78, 34, 661, 90, 75]
# [8, 4, 1, 0, 5]
result = [x % 10 for x in nums]
print(result)

2.结构2

[表达式 for 变量 in 序列 if 条件语句]

创建一个列表，列表的元素就是变量去序列中取值，取一个值判断一次条件是否成立，成立就计算一次表达式的结果，并且将结果作为列表的元素

result = [x for x in range(10) if x < 6]
print(result)       # [0, 1, 2, 3, 4, 5]

result = [x for x in range(10) if x % 2 != 0]
print(result)       # [1, 3, 5, 7, 9]

提取 nums 中所有的偶数

#[78, 34, 90]

nums = [78, 34, 661, 90, 75]
result = [x for x in nums if x % 2 == 0]
print(result)       # [78, 34, 90]

提取 nums 中所有的偶数的个位数

#[8, 4, 0]

nums = [78, 34, 661, 90, 75]
result = [x%10 for x in nums if x % 2 == 0]
print(result)       # [8, 4, 0]