一、数字的处理函数

（一）int()

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

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

运行结果如下：

　-3 -2 -1
　3 2 1

（二）//

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

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

运行结果如下：

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

（三）round()

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

1 print(round(2.5), round(2.5001), round(2.6))
2 print(round(3.5), round(3.5001), round(3.6), round(3.3))
3 print(round(-2.5), round(-2.5001), round(-2.6))
4 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()

向下取整，举例如下：

1 import math
2
3 print(math.floor(2.5), math.floor(-2.5))

运行结果如下：2 -3

（五）ceil()

向上取整，举例如下：

1 import math
2
3 print(math.ceil(2.5), math.ceil(-2.5))

运行结果如下：3 -2

（六）max()

获取最大值

（七）min()

获取最小值

（八）pow(x, y)

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

（九）sqrt()

求平方根，举例如下：

1 import math
2
3 print(math.sqrt(3))

运行结果如下：1.7320508075688772

（十）bin()

将数字转换为二进制

（十一）oct()

将数字转换为八进制

（十二）hex()

将数字转换为十六进制

二、列表

（一）定义

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

（二）对列表的相关操作

1、列表索引访问

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

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

运行结果如下：3

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

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

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

运行结果如下:0

3、list.count(value)

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

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

运行结果如下：2

4、列表元素的修改

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

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

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

5、list.append(object)

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

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

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

6、list.insert(index, object)

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

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

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

7、list.extend(iteratable)

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

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

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

8、+

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

9、*

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

10、list.remove(value)

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

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

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

11、list.pop([index])

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

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

运行结果如下：

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

12、list.clear()

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

13、list.reverse()

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

1 lst = [3, 4, 2, 7]
2 lst.reverse()
3 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()

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

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

运行结果如下：

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

16、copy.deepcopy(list)

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

1 import copy
2
3 lst = [3, [3, 4], 7]
4 lst2 = copy.deepcopy(lst)
5 print(lst2)
6 lst2[1][0] = 10
7 print(lst)
8 print(lst2)

运行结果如下：

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

三、random模块

1、randint(a, b)

返回a到b之间的整数

import randomprint(random.randint(1, 10))

2、choice(seq)

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

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

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

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

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

4、shuffle(list)

就地打乱列表中的元素

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

5、sample(population, k)

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

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

转载于:https://www.cnblogs.com/Sweltering/p/9882301.html

（python）数据结构------列表相关推荐

Python数据结构--列表（二）
1.列表元素删除列表中有了众多元素之后,可能会遇到需要删除全部元素或者某个元素的时候. 1.1 删除全部元素如果想清空列表中的全部元素,可以使用clear()方法. 如下: a = [1,2,3] ...
Python笔记——基本数据结构:列表、元组及字典
转载请注明出处:http://blog.csdn.net/wklken/archive/2011/04/10/6312888.aspx Python基本数据结构:列表,元组及字典一.列表一组有序项 ...
python数据结构的列表_Python自带数据结构列表(list)
Python自带数据结构列表(list) 列表是Python中最通用的数据类型,可以写成方括号之间的逗号分隔值(项目)列表. 使用列表的重要事项是,列表中的项目不必是相同的类型.也就是说一个列表中的 ...
Python数据结构与算法（一）列表和元组
本系列总结了python常用的数据结构和算法,以及一些编程实现. 参考书籍:<数据结构与算法 Python语言实现> [美]Michael T.Goodrich, Roberto Tama ...
Python数据结构与算法笔记（六）：数据结构——列表和栈
数据结构介绍存储一组有关系的数据数据结构的分类: 树结构图结构: 列表列表存储与基本操作数组: 开辟一定长度的内存,用来存储数据,里面是真实的值.32位机器上,一个整数占4字节.假设第一个数 ...
Python学习数据结构列表字典元组
本章节我们主要结合前面所学的知识点来介绍Python数据结构. 1.元组结构(Tuple) 元组由不同的元素组成,每个元素可以存储不同类型的数据,如字符串.数字甚至元组.元组创建后不能修改. 元组通常 ...
python基本数据结构——列表
一.python基本数据结构--列表列表可以实地的增长或者缩短(长度可变),并且可以包含任何类型的对象而不仅仅是包含有单个字符的字符串(异构) 从技术上来讲,Python列表包含了零个或多个 ...
python数据结构：列表
1.什么是列表 ❖在前面基本数据结构中,采用PythonList来实现了多种线性数据结构 ❖列表List是一种简单强大的数据集结构,提供了丰富的操作接口但并不是所有的编程语言都提供了List数据类型 ...
python删除列表中的重复元素并保持相对顺序不变
python删除列表中的重复元素并保持相对顺序不变从列表中删除重复项以便所有元素都是唯一的同时保持原有相对顺序不变对于列表我们可以使用如下方法: l1 = [1,7,7,8,5,5,4] l2 = ...

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