（python）数据结构------列表

一、数字的处理函数

（一）int()

取整数部分，与正负号无关，举例如下：

print(int(-3.6), int(-2.5), int(-1.4))
print(int(3.6), int(2.5), int(1.4))

运行结果如下：

　-3 -2 -1
　3 2 1

（二）//

整除并且向下取整，举例如下：

print(7//2, 7//-2, -7//2, -(7//2))
print(2//3, -2//3, -1//3)

运行结果如下：

　3 -4 -4 -3
　0 -1 -1

（三）round()

四舍六入五取偶，举例如下：

print(round(2.5), round(2.5001), round(2.6))
print(round(3.5), round(3.5001), round(3.6), round(3.3))
print(round(-2.5), round(-2.5001), round(-2.6))
print(round(-3.5), round(-3.5001), round(-3.6), round(-3.3))

运行结果如下：

　2 3 3
　4 4 4 3
　-2 -3 -3
　-4 -4 -4 -3

（四）floor()

向下取整，举例如下：

import math

print(math.floor(2.5), math.floor(-2.5))

运行结果如下：
2 -3

（五）ceil()

向上取整，举例如下：

import math

print(math.ceil(2.5), math.ceil(-2.5))

运行结果如下：
3 -2

（六）max()

获取最大值

（七）min()

获取最小值

（八）pow(x, y)

求次方（x的y次方），相当于x**y，也可以写成这种形式。

（九）sqrt()

求平方根，举例如下：

import math

print(math.sqrt(3))

运行结果如下：
1.7320508075688772

（十）bin()

将数字转换为二进制

（十一）oct()

将数字转换为八进制

（十二）hex()

将数字转换为十六进制

二、列表

（一）定义

• 列表是可变的、线性的数据结构
• 列表内的个体称为元素，由若干个元素组成列表
• 元素可以是任意对象（数字、字符串、对象、列表等）
• 列表内的元素是有序的，可以使用索引

（二）对列表的相关操作

1、列表索引访问

列表可以通过索引去访问其中的元素，索引的顺序是从0开始的（从左向右），-1索引表示列表中的最后一个元素，依次类推。

lst = ['a', 3, 'b']
print(lst[1])

运行结果如下：
3

2、list.index(value, [start, [stop]])

• 通过值value，从指定区间[start, stop]查找元素中是否有这个值，如果有则返回对应位置的索引，如果没有，就抛异常ValueError。
• 时间复杂度：O(n)，随着数据规模的增大，效率下降，所以尽量避免使用这个方法。

lst = ['a', 3, 'b']
print(lst.index('a'))

运行结果如下:
0

3、list.count(value)

• 返回列表中值value的出现次数。
• 时间复杂度：O(n)，随着数据规模的增大，效率下降，所以尽量避免使用这个方法。

lst = ['a', 3, 'b', 'a']
print(lst.count('a'))

运行结果如下：
2

4、列表元素的修改

• 列表是可变的有序的数据结构，所以可以根据其索引来修改列表中对应的元素。
• 注意，索引不能超界，否则抛出异常IndexError。

lst = ['a', 3, 'b', 'a']
lst[3] = 'c'
print(lst)

运行结果如下：
['a', 3, 'b', 'c']

5、list.append(object)

• 在列表的尾部追加元素。
• 返回None，就地修改。
• 时间复杂度：O(1)，直接在列表尾部追加，所以对于效率没有什么影响。

lst = ['a', 3, 'b', 'a']
lst.append('d')
print(lst)

运行结果如下：
['a', 3, 'b', 'a', 'd']

6、list.insert(index, object)

• 根据索引index，将元素插入到对应的位置。
• 返回None，就地修改。
• 时间复杂度：O(n)，所以这种方法不推荐使用，推荐使用append这种方法。
• 插入元素的时候索引可以超界，超过上界，头部追加，超过下界，尾部追加。

lst = ['a', 3, 'b', 'a']
lst.insert(2, 'd')
print(lst)

运行结果如下：
['a', 3, 'd', 'b', 'a']

7、list.extend(iteratable)

• 将可迭代对象的元素追加进行来。
• 返回None，就地修改。

lst = ['a', 3, 'b', 'a']
lst.extend('d')
print(lst)

运行结果如下：
['a', 3, 'b', 'a', 'd']

8、+

• 将两个列表连接起来，返回一个新的列表，原列表不变。

9、*

• 重复操作，将列表中的元素重复n次，返回一个新的列表。

10、list.remove(value)

• 找到匹配的值value，移除该值。
• 返回None，就地修改。
• 时间复杂度：O(n)，不建议使用这个方法。

lst = [3, 4, 2, 7]
lst.remove(4)
print(lst)

运行结果如下：
[3, 2, 7]

11、list.pop([index])

• 不指定索引index，则直接弹出列表尾部的值，指定索引，则弹出指定索引的值。
• 时间复杂度：不指定索引，时间复杂度O(1)，指定索引，时间复杂度O(n)。
• 注意，索引不能超界，否则抛异常IndexError。

lst = [3, 4, 2, 7]
lst.pop()
print(lst)
lst.pop(1)
print(lst)

运行结果如下：

　[3, 4, 2]
　[3, 2]

12、list.clear()

• 清除列表中的所有元素，返回一个空的列表。

13、list.reverse()

• 将列表中的元素进行反转。
• 返回None，就地修改。

lst = [3, 4, 2, 7]
lst.reverse()
print(lst)

运行结果如下：
[7, 2, 4, 3]

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

• 将列表中的元素进行排序，默认为升序。
• 返回None，就地修改。
• reverse改为True，降序排列。

lst = [3, 4, 2, 7]
lst.sort()
print(lst)

运行结果如下：
[2, 3, 4, 7]

15、list.copy()

• 浅拷贝，将列表中的元素进行拷贝，返回一个新的列表。
• 注意，浅拷贝如果遇到引用类型的数据时，修改其中一个列表的引用类型另一个列表中的值也会改变。

lst = [3, [3, 4], 7]
lst2 = lst.copy()
print(lst2)
lst2[1][0] = 10
print(lst)
print(lst2)

运行结果如下：

　[3, [3, 4], 7]
　[3, [10, 4], 7]
　[3, [10, 4], 7]

16、copy.deepcopy(list)

• 深拷贝，将列表中的元素拷贝返回一个新的列表。
• 深拷贝就没有引用类型数据修改变化的问题了。

import copy

lst = [3, [3, 4], 7]
lst2 = copy.deepcopy(lst)
print(lst2)
lst2[1][0] = 10
print(lst)
print(lst2)

运行结果如下：

　[3, [3, 4], 7]
　[3, [3, 4], 7]
　[3, [10, 4], 7]

三、random模块

1、randint(a, b)

• 返回a到b之间的整数

import random

print(random.randint(1, 10))

2、choice(seq)

• 从非空序列的元素中随机挑选出一个元素

import random

print(random.choice([2, 5, 8]))

3、randrange([start, ] stop, [, step])

• 从指定范围[start, stop]，按照指定的步数step随机获取一个数，step缺省值为1.

import random

print(random.randrange(1, 10, 2))

4、shuffle(list)

• 就地打乱列表中的元素

import random

lst = [1, 2, 3, 4, 5]
random.shuffle(lst)
print(lst)

5、sample(population, k)

• 从样本空间population中随机取出k个不同的元素，返回一个新的列表。

import random

lst = [1, 2, 3, 4, 5]
lst2 = random.sample(lst, 2)
print(lst2)