python_list

发表于 更新于 分类于 ， 阅读次数：

认识 list

  • list 是一个序列
  • 存在于中括号内
  • list 中元素的类型可以多样，同一个 list 中的元素的类型可以是字符串（str）、整型（int）、布尔型（Boolean）、以及嵌套的 list 等
1
2
3
4
5
6
list1 = ['东北', '华北', '华南', '华东', '西南', '西北']  # 字符串用引号包含起来
list2 = []  # 空列表

type(list1)
list1
list2
1
2
3
list
['东北', '华北', '华南', '华东', '西南', '西北']
[]
1
2
3
4
list3 = list('ABCDEF')  # 字符串列表
list4 = list(range(10))  # 整型列表
list3
list4
1
2
['A', 'B', 'C', 'D', 'E', 'F']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

list 的索引

下标索引

  • 注意索引是从 0 开始，最后一个的索引编号为 n-1，即所有元素的编号依次为(0,1, 2, …, n-1)。
1
2
3
4
list3[0]
list3[2]
list3[-1]
list3[-2]
1
2
3
4
'A'
'C'
'F'
'E'

切片

  • list[start: end : step]
  • 包含 “start”，但不包含 “end”
  • “step” 表示步长，默认情况下，“step”为 1
1
2
3
4
5
list3[1:4]
list3[:4]
list3[4:]
list3[::-1]
list3[::2]
1
2
3
4
5
['B', 'C', 'D']
['A', 'B', 'C', 'D']
['E', 'F']
['F', 'E', 'D', 'C', 'B', 'A']
['A', 'C', 'E']

用for 循环遍历列表

1
2
for i in list1:
    print(i)
1
2
3
4
5
6
东北
华北
华南
华东
西南
西北

列表的增、改、删

  • list 是一个可变的序列，可以通过添加、修改、删除等操作来操作 list 中的元素。

append() 方法

  • 是在 list 的末尾添加元素
1
2
3
4
a = ['北京', '上海', '天津', '重庆']

a.append('深圳')  # 在列表的末尾增加新值
a
    ['北京', '上海', '天津', '重庆', '深圳']

insert()

  • 是在指定位置添加元素。
1
2
a.insert(1, '广州')  # 表示在索引1的位置插入新值
a
    ['北京', '广州', '上海', '天津', '重庆', '深圳']

用 pop()

  • 方法删除 list 末尾的元素
1
2
a.pop()
a
1
2
'深圳'
['北京', '广州', '上海', '天津', '重庆']

用 pop(i) 方法

  • 删除指定位置的元素
1
2
a.pop(0)
a
1
2
'北京'
['广州', '上海', '天津', '重庆']

修改 list 中的元素

  • 直接通过 list 的索引进行赋值来实现
1
2
a[0] = "北京"
a
1
['北京', '上海', '天津', '重庆']

列表操作符

‘ + ’ 拼接列表

1
2
3
4
es = ['黑龙江', '吉林', '辽宁']
ws = ['新疆', '青海', '甘肃', '宁夏', '陕西']

es+ws
1
['黑龙江', '吉林', '辽宁', '新疆', '青海', '甘肃', '宁夏', '陕西']

‘ * ‘ 重复列表

1
es*2
1
['黑龙江', '吉林', '辽宁', '黑龙江', '吉林', '辽宁']

判断元素是否存在

1
2
'黑龙江' in es
'黑龙江' in ws
1
2
True
False

列表函数

len( )

1
2
3
a = list(range(11, 29, 4))

len(a)
1
5

- max(list)

  • 返回列表元素最大值
1
max(a)
1
27

min(list)

  • 返回列表元素最小值
1
min(a)
1
11

list（）

  • 将其他序列转成列表
1
2
b = (1, 3, 5, 7)
list(b)
1
[1, 3, 5, 7]

list的其他方法

list.count(obj)

  • 统计某个元素在列表中出现的次数
1
2
3
a = list('guangzhou')
a.count('g')

1
2

list.extend(seq)

  • 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
1
2
3
a = list('guangzhou')
a.extend(['sh',12345])
a
1
['g', 'u', 'a', 'n', 'g', 'z', 'h', 'o', 'u', 'sh', 12345]

list.index(obj)

  • 从列表中找出某个值第一个匹配项的索引位置
1
2
a = list('guangzhou')
a.index('z')
1
5

list.remove(obj)

  • 移除列表中某个值的第一个匹配项
1
2
3
a = list('guangzhou')
a.remove('g')
a
    ['u', 'a', 'n', 'g', 'z', 'h', 'o', 'u']

list.sort()

  • 对原列表进行排序
1
2
3
4
a = list('guangzhou')
a.sort()

a
1
['a', 'g', 'g', 'h', 'n', 'o', 'u', 'u', 'z']

list.reverse()

  • 对原列表进行反向排序
1
2
3
a = list('guangzhou')
a.reverse()
a
1
['u', 'o', 'h', 'z', 'g', 'n', 'a', 'u', 'g']

列表推导式 (解析式)

一般语法结构：

  • new_list = [x for x in iterable]
  • 其中的 iterable 表示可迭代的对象，包括字符串（str）、列表（list），元组（tuple）、字典（dict）、集合（set）以及生成器（generator）等。
1
[x for x in range(1, 10, 2)]
1
[1, 3, 5, 7, 9]
1
2
# str.lower()转换成小写，str.upper()转换成大写
[x.upper() for x in "Lemon"]  
1
['L', 'E', 'M', 'O', 'N']
1
[str(x) for x in range(5)]
1
['0', '1', '2', '3', '4']

两层 for 循环的列表推导式

  • 列表推导式中，可以同时包含多个 for 循环，比如同时两个 for 循环
1
[x**2+y for x in range(1, 4) for y in [10, 20]]
1
[11, 21, 14, 24, 19, 29]

使用两个变量来生成 list

  • 列表推导式也可以使用两个或多个变量来生成 list，结合字典的使用
1
2
3
# 结合字典的使用
g = {'x': '1', 'y': '2', 'z': '4'}
[k+'='+v for k, v in g.items()]
1
['x=1', 'y=2', 'z=4']

含 if 语句的列表推导式

  • 列表推导式中还可以引入 if 条件语句，
  • 包含 if-else 语句的列表推导式
1
2
# 列表推导式中还可以引入 if 条件语句
[x**2 for x in range(5) if x % 2 == 1]
1
[1, 9]
1
2
3
# 包含 if-else 语句的列表推导式
[x**2 if x % 2 == 0 else x+2 for x in range(5)]

1
[0, 3, 4, 5, 16]
1
2
# 包含两个 if 语句的列表推导式
[x**2 for x in range(1, 9) if x % 2 == 0 if x % 3 == 0]
1
[36]

列表的去重

  1. 直接用set方法可以去重，但是原列表中元素的顺序被打乱
  2. 利用原来各元素在列表中的索引位可以保持原来的顺序
1
2
a = [1, 5, 3, 7, 5, 3, 1, 9]
list(set(a))
1
[1, 3, 5, 7, 9]

列表推导

1
2
3
4
5
6
# 方法1 
b = []
for x in a:
    if x not in b:
        b.append(x)
b
1
[1, 5, 3, 7, 9]

sorted

  • sorted(list(set(list1),key=list1.index）
1
2
# 方法2
sorted(list(set(a)), key=a.index)
1
[1, 5, 3, 7, 9]

{}.fromkeys(seq)

1
2
# 方法3 
list({}.fromkeys(a))
1
[1, 5, 3, 7, 9]

获取列表离散的元素

  • 获得第 1、2、4 个元素，能不能通过离散的索引值来获取呢？
    前面已经实践过，直接通过离散的索引值来获取列表中的元素是不行的。
    通过列表推导式的学习，我们可以换一种思路，来实现列表中离散的元素的获取，
1
2
ws=['新疆', '青海', '甘肃', '宁夏', '陕西']
[ws[x] for x in [0, 2, 4]]
1
['新疆', '甘肃', '陕西']
1
2
lst=list("ABCDEFG")
lst[1:4],lst[:4],lst[2:]
1
(['B', 'C', 'D'], ['A', 'B', 'C', 'D'], ['C', 'D', 'E', 'F', 'G'])
1
2
lst=list("ABCDE")
[lst[i] for i in [0,3,4] ]
1
['A', 'D', 'E']
1
2
3
4
lst=list("ABCDEFG")
lst.extend(["gg","dd"])
lst[len(lst):]=['dddd','ppp']
lst
    ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'gg', 'dd', 'dddd', 'ppp']