Python 学习总结——列表

东方鹗

1 列表的 CRUD 操作

1.1 创建列表类型数据并给它赋值

list1 = [123, 'abc', 3.14, [456, 'xdt'], 2-1j]
list2 = [None, '藕丝科技']
print(list1)
print(list2)
list2 = []
print(list2)
list('藕丝科技')
[123, 'abc', 3.14, [456, 'xdt'], (2-1j)]
[None, '藕丝科技']
[]





['藕', '丝', '科', '技']

1.2 访问列表中的值

print(list1[1])
print(list1[2:4])
print(list2[3:])
print(list1[3:])
print(list1[3][1])
abc
[3.14, [456, 'xdt']]
[]
[[456, 'xdt'], (2-1j)]
xdt

1.3 更新列表

print(list1)
print(list1[2])
list1[2] = 'PI'
print(list1)
list1.append('新增元素')
print(list1)
[123, 'abc', 3.14, [456, 'xdt'], (2-1j)]
3.14
[123, 'abc', 'PI', [456, 'xdt'], (2-1j)]
[123, 'abc', 'PI', [456, 'xdt'], (2-1j), '新增元素']

1.4 删除列表中的元素或者列表(本身)

print(list1)
del list1[0]
print(list1)
list1.remove('PI')
print(list1)
[123, 'abc', 'PI', [456, 'xdt'], (2-1j), '新增元素']
['abc', 'PI', [456, 'xdt'], (2-1j), '新增元素']
['abc', [456, 'xdt'], (2-1j), '新增元素']

2 列表类型操作符

2.1 标准类型操作符

>,<, ==, !=, and, or

  • >, <,==, != 比较运算,得到结果将是布尔值(True, False),列表的比较顺序按照列表的索引顺序进行比较
  • and, or 短路运算符
    • 1、从左往右执行运算
    • 2、and 的左侧为 False,执行短路逻辑,结果为左侧表达式, or 的左侧为 True,执行短路逻辑,结果为左侧表达式。
    • 3、如果 and 的左侧为 True, 则不短路,继续执行,结果为右侧表达式。
    • 4、如果 or 的左侧为 False,则不短路,继续执行,结果为右侧表达式。

2.2 序列类型操作符

2.2.1 切片( [] )

arr= list(range(1, 11))
print(arr[5])
print(arr[:5])
print(arr[:-1])
print(arr[1:5:2])
6
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 4]

2.2.2 成员关系操作( in, not in )

a= list(range(1, 11))
print(1 in a)
print(2 in a)
print(2 not in a)
print(12 in a)
True
True
False
False

2.2.3 连接操作符( + )

b = list(range(20, 30))
print(a + b)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

2.2.4 重复操作符( * )

print(a*2)
print(b*2)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

3 内建函数

序列类型函数 len() max() min() sorted() reversed() enumerate() zip() sum() list() tuple()

3.1 判断长度 len()

list1, list2 = [123, '藕丝', 'http://www.os373.cn', None, ''], [456, 'abc', ['abc', 456]]

print("第一个列表的长度 : ", len(list1))
print("第二个列表的长度 : " + str(len(list2)))
第一个列表的长度 :  5
第二个列表的长度 : 3

3.2 最大最小值

在 Python 2 中,max(),min() 函数支持混合类型(列表的内容可以是数字,字符串,列表,元组,字典等所有类型)的列表,但是在 Python 3 中,只能支持同类型的最大、最小取值。

list1, list2 = [123, 'xyz', 'zara', 'abc'], [456, 700, 200]
max(list1)
print("列表中的最大值是: ", max(list1))
print("列表中的最大值是 : " + str(max(list2)))
print("列表中的最小值是: ", min(list1))
print("列表中的最小值是 : " + str(min(list2)))
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-7-14d839693fc1> in <module>()
      1 list1, list2 = [123, 'xyz', 'zara', 'abc'], [456, 700, 200]
----> 2 max(list1)
      3 print("列表中的最大值是: ", max(list1))
      4 print("列表中的最大值是 : " + str(max(list2)))
      5 print("列表中的最小值是: ", min(list1))


TypeError: '>' not supported between instances of 'str' and 'int'
list1, list2 = ['xyz', 'zara', 'abc'], [456, 700, 200]
max(list1)
print("列表中的最大值是: ", max(list1))
print("列表中的最大值是 : " + str(max(list2)))
print("列表中的最小值是: ", min(list1))
print("列表中的最小值是 : " + str(min(list2)))
列表中的最大值是:  zara
列表中的最大值是 : 700
列表中的最小值是:  abc
列表中的最小值是 : 200

3.3 sorted 内建函数

sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。

sorted 语法:

sorted(iterable, key=None, reverse=False)

参数说明:

  • iterable -- 可迭代对象。
  • key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
  • reverse -- 排序规则,reverse = True 降序 , reverse = False 升序(默认)。

返回值

  • 返回重新排序的列表
a1 = [5, 2, 3, 1, 4]
b1 = sorted(a1)
print(b1) # 默认为升序
print(a1) # 没有修改原始的列表
#你也可以使用 list 的 list.sort() 方法。这个方法会修改原始的 list(返回值为None)。
#通常这个方法不如sorted()方便--如果你不需要原始的 list,list.sort()方法效率会稍微高一些。
a2 = [6, 2, 3, 0, 4]
b2 = a2.sort()
print(b2)
print(a2)
[1, 2, 3, 4, 5]
[5, 2, 3, 1, 4]
None
[0, 2, 3, 4, 6]
# 另一个区别在于list.sort() 方法只为 list 定义。而 sorted() 函数可以接收任何的 iterable。
print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}))
print(sorted({'a': 'a', 'b': 'b', 'c': 'c', 'd':'d'}))
[1, 2, 3, 4, 5]
['a', 'b', 'c', 'd']

使用 key

A = ['早餐', '上午茶', '中餐', '下午茶','晚餐', '夜宵']
B = ['晚餐', '上午茶', '夜宵']
print(sorted(B, key=A.index))
['上午茶', '晚餐', '夜宵']

利用key进行倒序排序

example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list)
[7, 6, 5, 4, 3, 2, 1, 0]

要进行反向排序,也通过传入第三个参数 reverse=True:

example_list = [5, 0, 6, 1, 2, 7, 3, 4]
sorted(example_list, reverse=True)
[7, 6, 5, 4, 3, 2, 1, 0]

3.4 reversed 内建函数

reversed 函数返回一个反转的迭代器。 语法 以下是 reversed 的语法:

reversed(seq)

参数

  • seq -- 要转换的序列,可以是 tuple, string, list 或 range。

返回值

  • 返回一个反转的迭代器。
# 字符串
seqString = 'Runoob'
print(reversed(seqString))
print(list(reversed(seqString)))

# 元组
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple)))

# range
seqRange = range(5, 9)
print(list(reversed(seqRange)))

# 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))
<reversed object at 0x7f17dc28a7b8>
['b', 'o', 'o', 'n', 'u', 'R']
['b', 'o', 'o', 'n', 'u', 'R']
[8, 7, 6, 5]
[5, 3, 4, 2, 1]

3.5 enumerate 内建函数

enumerate多用于在for循环中得到计数,enumerate()返回的是一个enumerate对象。

seq = range(5)
enumerate(seq)
# for index, item in enumerate(seq):
#     print(index, item)
<enumerate at 0x7fbd6020de58>

一般方法

list1 = ["这", "是", "一个", "测试"]
for i in range (len(list1)):
    print(i ,list1[i])
0 这
1 是
2 一个
3 测试

使用 enumerate

list2 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list2):
    print(index, item)
0 这
1 是
2 一个
3 测试

enumerate还可以接收第二个参数,用于指定索引起始值,如:

list3 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list3, 1):
    print(index, item)
1 这
2 是
3 一个
4 测试

3.6 zip 内建函数

  • Python3中zip()返回的是元祖组成的 迭代器,而在Python2中返回的是元祖组成的 列表
l1,l2,l3 = (1,2,3),(4,5,6),(7,8,9)
list(zip(l1,l2,l3))
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
  • zip() 参数可以接受任何类型的序列,同时也可以有两个以上的参数;当传入参数的长度不同时,zip 能自动以 最短序列长度 为准进行截取,获得元组。
str1 = 'abc'
str2 = 'def123'
list(zip(str1,str2))
[('a', 'd'), ('b', 'e'), ('c', 'f')]
  • 搭配 for 循环,支持并行迭代
l1 = [2,3,4]
l2 = [4,5,6]
print(list(zip(l1, l2)))

for (x,y) in zip(l1,l2):
    print(x, ' * ', y, ' = ', x*y)
[(2, 4), (3, 5), (4, 6)]
2  *  4  =  8
3  *  5  =  15
4  *  6  =  24
  • zip() in conjunction with the * operator can be used to unzip a list
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
list(zipped)
[(1, 4), (2, 5), (3, 6)]
x2, y2 = zip(*zip(x, y)) # * (解包)操作,相当于去掉了最外围的 []
print(x2, y2)
x3, y3 = zip((1, 4), (2, 5), (3, 6))
print(x3, y3)
(1, 2, 3) (4, 5, 6)
(1, 2, 3) (4, 5, 6)
  • 二维矩阵变换(矩阵的行列互换)
l1=[[1,2,3],[4,5,6],[7,8,9,10]]
print([[j[i] for j in l1] for i in range(len(l1[0])) ])

list(zip(*l1))
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]





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

4 练习实例

4.1 列表分割

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = [a[i:i+3] for i in range(0, len(a), 3)]
print(b)
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]]

4.2 用一个列表的顺序去排另一个列表

A = ['早餐', '上午茶', '中餐', '下午茶', '晚餐', '夜宵']
B = ['晚餐', '上午茶', '夜宵']
print(sorted(B, key=A.index))
['上午茶', '晚餐', '夜宵']

4.3 列表取值

arr= list(range(1, 11))
print(arr[5])
print(arr[:5])
print(arr[:-1])
print(arr[1:5:2])
print(arr[1:5:-2]) # 该结果为空,why?
6
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 4]
[]

当 step 为负数时, index 应该是 start 大于 end, 负数步长只能操作反向切片。 因此,正确的操作如下:

print(arr[-1:-5:-2])

print(arr[::-1]) # 等同于 arr.reverse(),序列的反向操作
[10, 8]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

4.4 比较

Python 3.X 的版本中已经没有 cmp 函数,如果你需要实现比较功能,需要引入 operator 模块,适合任何对象,包含的方法有:

operator.lt(a, b)
operator.le(a, b)
operator.eq(a, b)
operator.ne(a, b)
operator.ge(a, b)
operator.gt(a, b)
operator.__lt__(a, b)
operator.__le__(a, b)
operator.__eq__(a, b)
operator.__ne__(a, b)
operator.__ge__(a, b)
operator.__gt__(a, b)
import operator
print(operator.eq('藕丝科技', '藕丝空间'))
print(operator.__eq__('藕丝科技', '藕丝空间'))
print(operator.eq('http://os373.cn', 'http://os373.cn'))
print(operator.__eq__('http://os373.cn', 'http://os373.cn'))
False
False
True
True

4.5 列表类型的内建函数

list1 = ['os373.cn', '藕丝空间']
list1.append('藕丝科技')
print('list1 = ', list1)
list1.append('藕丝科技')# 在列表尾部增加一个对象
print('list1 = ', list1)
list2 = ['东方鹗', '编程']
list1.append(list2)
print('list1 = ', list1)
list1.extend(list2) # 在列表尾部增加列表或元组内的所有内容
print('list1 = ', list1)
list3, list4 = '我是insert', ['我是insert']
list1.insert(3, list3) # 在列表的索引为 3 的位置插入对象
print('list1 = ', list1)
list1.insert(3, list4) # 在列表的索引为 3 的位置插入对象
print('list1 = ', list1)
print(list1.count('藕丝科技')) # 统计某个元素在列表中出现的次数
print(list1.index('藕丝科技')) # 从列表中找出某个值第一个匹配项的索引位置
print(list1.pop(3)) # 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
print('list1 = ', list1)
list1.remove('藕丝科技') # 移除列表中某个值的第一个匹配项
print('list1 = ', list1)
list1.reverse() # 反向列表中元素
print('list1 = ', list1)
list1.sort() # Python 3 中,只支持同类型的列表内容进行排序
list1 =  ['os373.cn', '藕丝空间', '藕丝科技']
list1 =  ['os373.cn', '藕丝空间', '藕丝科技', '藕丝科技']
list1 =  ['os373.cn', '藕丝空间', '藕丝科技', '藕丝科技', ['东方鹗', '编程']]
list1 =  ['os373.cn', '藕丝空间', '藕丝科技', '藕丝科技', ['东方鹗', '编程'], '东方鹗', '编程']
list1 =  ['os373.cn', '藕丝空间', '藕丝科技', '我是insert', '藕丝科技', ['东方鹗', '编程'], '东方鹗', '编程']
list1 =  ['os373.cn', '藕丝空间', '藕丝科技', ['我是insert'], '我是insert', '藕丝科技', ['东方鹗', '编程'], '东方鹗', '编程']
2
2
['我是insert']
list1 =  ['os373.cn', '藕丝空间', '藕丝科技', '我是insert', '藕丝科技', ['东方鹗', '编程'], '东方鹗', '编程']
list1 =  ['os373.cn', '藕丝空间', '我是insert', '藕丝科技', ['东方鹗', '编程'], '东方鹗', '编程']
list1 =  ['编程', '东方鹗', ['东方鹗', '编程'], '藕丝科技', '我是insert', '藕丝空间', 'os373.cn']



---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-51-df4b3ae4eecd> in <module>()
     22 list1.reverse() # 反向列表中元素
     23 print('list1 = ', list1)
---> 24 list1.sort() # Python 3 中,只支持同类型的列表内容进行排序


TypeError: '<' not supported between instances of 'list' and 'str'

4.6 创建二维数组

arr_2 = [ [0 for i in range(5)] for i in range(5)]
print(arr_2)
print(len(arr_2))
arr_2[0].append(3)
print(arr_2)
arr_2[0].append(5)
print(arr_2)
arr_2[1].append(3)
print(arr_2)
arr_2[2].append(8)
print(arr_2)
arr_2[5].append(8)
print(arr_2)
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
5
[[0, 0, 0, 0, 0, 3], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[0, 0, 0, 0, 0, 3, 5], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[0, 0, 0, 0, 0, 3, 5], [0, 0, 0, 0, 0, 3], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
[[0, 0, 0, 0, 0, 3, 5], [0, 0, 0, 0, 0, 3], [0, 0, 0, 0, 0, 8], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]



---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

<ipython-input-15-bf472d4233d3> in <module>()
     10 arr_2[2].append(8)
     11 print(arr_2)
---> 12 arr_2[5].append(8)
     13 print(arr_2)


IndexError: list index out of range

4.7 列表推导

4.7.1 使用列表推导取平方

matrix = [[1,2,3],[4,5,6],[7,8,9]]
flat = [row for row in matrix] # 列表推导,解包之后又形成列表
print(flat)
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
squared = [[x**2 for x in row] for row in matrix] # 保持列表的二维数组结构不变,然后对每个元素取平方数
print(squared)
[[1, 4, 9], [16, 25, 36], [49, 64, 81]]
flat = [x for row in matrix for x in row] # 将二维数组解包为一维数组
print(flat)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
squared = [x**2 for row in matrix for x in row] # 取平方数
print(squared)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

下面将会演示 Python 2 中的作用域缺陷

squared = [x**2 for x in row for row in matrix] Python 2  3 版本都无法运行
File "<ipython-input-16-c51e9340104c>", line 1
    squared = [x**2 for x in row for row in matrix] Python 2 和 3 版本都无法运行
                                                         ^
SyntaxError: invalid syntax
flat = [x for row in matrix] # Python 2 和 3 版本都无法运行
---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-69-3d62df6ba0bb> in <module>()
----> 1 flat = [x for row in matrix] # Python 2 和 3 版本都无法运行


<ipython-input-69-3d62df6ba0bb> in <listcomp>(.0)
----> 1 flat = [x for row in matrix] # Python 2 和 3 版本都无法运行


NameError: name 'x' is not defined
flat = [x for x in row for row in matrix] # 只能在 Python 2 中运行,主要是 Python 2 中的作用域有缺陷所致,因为 row 已运行过一次。
print(flat)
---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-72-171968cac87d> in <module>()
----> 1 flat = [x for x in row for row in matrix]
      2 print(flat)


NameError: name 'row' is not defined
flat = [row for x in row for row in matrix] # Python 2 和 3 版本都无法运行
print(flat)
---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-75-504a4823252c> in <module>()
----> 1 flat = [row for x in row for row in matrix] # Python 2 和 3 版本都无法运行
      2 print(flat)


NameError: name 'row' is not defined

4.7.2 列出1-1000内不包含4的数字

主要是用到了 str.find() 函数,如果字符串中包含该字符,则返回该字符在字符串中的索引值,反之,返回 -1.

[i for i in range(0,1000) if str(i).find('4') == -1]
[0,
 1,
 2,
 3,
 5,
 6,
 7,
 8,
 9,
 10,
 11,
 12,
 13,
 15,
 16,
...,
 995,
 996,
 997,
 998,
 999]

  • 打赏