Python 内置数据结构之一（类型转换及列表）

---

一、分类

1.1 数值型

• int
• float
• complex
• bool

1.2 序列对象

• 字符串 str
• 列表 list
• tuple

1.3 键值对

• 集合 set
• 字典 dict

---

二、数值型

2.1 数值型

• int、float、complex、bool 都是 class，1、5.0、2+3j 都是对象即实例
• int
  python 3 的 int 就是长整型，切没有大小限制，受限于内存区域大小
• float
  有整数部分和小数部分组成，支持十进制和科学计数法表示。只有双精度型
• complex
  有实数和虚数部分组成，实数和虚数部分都是浮点数，3+4.2j
• bool
  int 的子类，仅有 2 个实例 True、False 对应 1 和 0，可以和整数直接运算

2.2 类型转换（built-in）

• int(x)
  返回一个整数
• float(x)
  返回一个浮点数
• complex(x)、complex(x,y)
  返回一个复数
• bool(x)
  返回布尔值，详细见前面 False 等价对象

---

三、数字的处理函数

3.1 round()

四舍六入，五取偶
亦可理解为小数距离 0 或 1 那方更近，距离一样则优先最近的偶数

• 示例

print (round (2.51))   # 距离 1 更近
3

print (round (2.49999))   # 距离 0 更近
2

print (round (2.5))   # 最近偶数为 2
2

print (round (3.5))   # 最近偶数为 4
4

print (round (-0.5))
0

print (round (-0.49))
0

print (round (-0.51))
-1

print (round (-1.5))
-2

i示例.png 负数.png

3.2 floor() 地板、seil() 天花板

向下或向上取整

• 示例

import math

math.floor(1.5)
1

math.floor(2.5)
2

math.floor(2.6)
2

math.ceil(2.6)
3

math.ceil(2.2)
3

3.3 int()

取整数部分，和 // 整除一样

• 示例

print (int (2.1))
2

print (int (2.5))
2

print (int (2.6))
2

3.4 min()

• 示例

min (2,5)
2

3.5 max()

• 示例

max (2,5)
5

3.6 pow(x,y)

等价 x**y

• 示例

pow (2,5)
32

2 ** 5
32

3.7 math.sqrt()

• 示例

math.sqrt(4)
2.0

4 ** 0.5
2.0

3.8 进制函数

注意：返回值是字符串

• bin()
• oct()
• hex()
• 示例

print (bin (10))
0b1010

print (oct (10))
0o12

print (hex (10))
0xa

示例.png

3.9 math.pi

π

• 示例

import math

math.pi
3.141592653589793

示例.png

3.10 math.e

自如常数

• 示例

import math

math.e
2.718281828459045

示例.png

---

四、类型判断

4.1 type(obj)

注意：返回类型，而不是字符串

• 示例

a = 1
b = 'abc'

type(a)
int

type(b)
str

示例.png

4.2 isinstance(obj, class_or_tuple)

注意：返回布尔值

• 示例

isinstance(6,str)
False

isinstance(6,(str,int,bool))
True

示例.png

---

五、列表 list

5.1 简介

• 一个队列，一个排列整齐的队伍
• 列表内的个体称作元素，由若干元素组成列表
• 元素可以是任意对象（数字、字符串、对象、列表等）
• 列表内元素有顺序，可以使用索引
• 线性的数据结构
• 使用 [ ] 表示

注意：列表是可变的

5.2 list 的定义及初始化

• list()
  new empty list
  定义空列表
• list(iterable)
  new list initialized from iterable's items
  定义可迭代对象列表
• 列表不能一开始就定义大小
• 示例

# 不可直接定义大小
lst = list(5)
------------------------------------------------------------------------
TypeError                              Traceback (most recent call last)
<ipython-input-1-1b0da86a3f37> in <module>
----> 1 l1 = list(5)

TypeError: 'int' object is not iterable


lst = list()
lst = []
lst = [1,3,5,7,'xyz']   # 即定义，也赋值
lst = list(range(5))

5.3 列表索引访问

• 索引，也叫下标
• 正索引
  从左至右，从 0 开始，为列表中每一个元素编号
• 负索引
  从右至左，从 -1 开始
• 正索引不可以超界，否则引发异常 IndexError
• 为了理解方便，可以认为列表是从左至右排列的，左边是头部，右边是尾部，左边是下界，右边是上界
• 列表通过索引访问

list [index]
    index 就是索引，使用中括号访问

5.4 列表查询

• index (value,[start,[stop]])

1. 通过值 value ，从指定区间查找列表内的元素是否匹配
2. 匹配第一个就立即返回索引
3. 匹配不到，跑出异常 ValueError

索引示例.png

• count (value)

1. 返回列表中匹配 value 的次数

• 时间复杂度

1. index 和 count 方法都是 O(n)
    1.1 O(1) 
        这种时间复杂度是最好的，追求的，效率高，执行次数固定，数据越大，效率越高
    1.2 O(n)
        这种时间复杂度随数据量   线性   递增
    1.3 O(n^2)
        这种时间复杂度随数据量   指数   递增，效率低，极力避免出现
2. 随着列表数据规模的增大，而效率下降

• 如何返回列表元素的个数

1. len()

5.5 查看帮助

• 官方帮助文档
  搜索关键字
• IPython 中

1. help(keyword)
    keyword 可以是变量，对象，类名，函数名，方法名

IPython 示例.png

5.6 列表元素修改

• 索引访问修改

1. list [index] = value
2. 索引不要超界

修改示例及超界示例.png

5.7 列表增加、插入元素

• append (object) -> None

1. 列表尾部追加元素，返回 None
2. 返回 None 就意味着没有新的列表产生，就地修改
3. 时间复杂度是 O(1)

append 示例.png

• insert (index,object) -> None

1. 在指定的索引 index 处插入元素 object
2. 返回 None 就意味着没有新的列表产生，就地修改
3. 时间复杂度是 O(n)
4. 索引能超上下界么
    4.1 超越上界，尾部追加
    4.2 超越下界，头部追加

insert 示例.png

• extend (iteratable) -> None

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

extend 示例.png

• + -> list

1. 连接操作，将两个列表连接起来
2. 产生新的列表，原列表不变
3. 本质上调用的是 __add__() 方法

列表 + 示例.png

• * -> list

1. 重复操作，将本列表元素重复 n 次，返回新的列表
2. 需要注意重复操作的元素
    2.1 示例
        x = [[1,2,3]]*3
        print(x)
        x[0][1] = 20
        print(x)

        y = [1]*5
        y[0] = 6
        y[1] = 7
        print(y)

列表 * 示例.png 重复元素示例.png

5.8 列表删除元素

• remove(value) -> None

1. 从左至右查找第一个匹配 value 值，移除该元素，返回 None
2. 就地修改
3. 效率低

remove 示例.png

• pop([index]) -> item

1. 不指定索引 index ，就从列表尾部弹出一个元素
2. 指定索引 index ，就从索引处弹出一个元素，索引超界抛出 IndexError 错误
3. 效率？指定索引的时间复杂度，不指定的时间复杂度
    3.1 如果 pop 尾部元素，效率是高，时间复杂度 O(1)
    3.2 如果指定索引不在尾部，效率和 remove 相似，时间复杂度 O(n)，慎用

pop 示例.png

• clear() -> None

1. 清除列表所有元素，剩下一个空列表
2. 大规模数据集清除时，可能引起垃圾回收，影响效率，慎用

5.9 列表其他操作

• reverse() -> None

1. 将列表元素  反转 ，返回 None
2. 就地修改

reverse 示例.png

• sort(key=None,reverse=False) -> None

1. 对列表元素进行  排序  ，就地修改，默认升序
2. reverse 为 True ，反转，降序
3. key 一个函数，指定 key 如何排序
    3.1 l1.sort(key=FUNCTIONNAME)

sort 示例.png sort(key) 示例.png

• in

1. 示例
    [3,4] in [1,2,[3,4]]
    True
    5 not in [1,2,[3,4]]
    True

in 示例.png
结合 if 判断.png

5.10 列表复制

• shadow copy

1. 影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已

copy 引用示意图.png shadow copy 示例.png

• 深拷贝

1. copy 模块提供了 deepcopy
2. 示例

import copy
l1 = [1,[2,3,4],5]
l2 = copy.deepcopy(l1)
l2[1][1] = 20
l2 == l1

深拷贝示例.png

---

六、随机数

6.1 random 模块

• 示例

import random

6.2 randint(a,b)

• 返回 [a,b] 之间的整数
• 示例

random.randint(0,1)
1

randint 示例.png

6.3 choice(seq)

• 从非空序列的元素中随机挑选一个元素，比如 random.choice(range(10))，从 0 到 9 中随机挑选一个整数
• 示例

random.choice([1,3,5,7])
3

choise 示例.png

6.4 randrange ([start,]stop[,step])

• 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为 1
• 示例

random.randrange(1,7,2)
1

randrange 示例.png

6.5 random.shuffle(list) -> None

• 就地打乱列表元素
• 示例

l1 = list(range(5))
random.shuffle(l1)

shuffle 示例.png

6.6 sample(population, k)

• 从样本空间或总体（序列或者集合类型）中随机取出 k 个 不同的元素，返回一个新的列表
• 示例

random.sample(['a','b','c','d'],2)
['c','a']

sample 示例.png