目录：
分类
数字的处理函数
类型判断
list
练习题
一. 分类
1). 数值型：int（整型）, float（浮点型）, complex（复数）, bool （布尔型）
2). 序列对象：str （字符串）, tuple（元组）
3). 键值对：set（集合）, dict（字典）
二. 数字的处理函数
round(), 对浮点数取近似值
|
1
2
3
4
5
|
In [
1
]:
round
(
2.675
,
2
)
Out[
1
]:
2.67
In [
2
]:
round
(
2.676
,
2
)
Out[
2
]:
2.68
|
在机器中浮点数不一定能精确表达，因为换算成一串1和0后可能是无限位数的，机器已经做出了截断处理。那么在机器中保存的2.675这个数字就比实际数字要小一点点。这一点点就导致了它离2.67要更近一点点，所以保留两位小数时就近似到了2.67。
floor(), 地板, 即总是向小的方向变换.
ceil(), 天花板, 即总是向大的方向变换.
注：floor()和ceil()使用前需先导入math模块.
|
1
2
3
4
5
6
7
|
In [
3
]:
import
math
In [
4
]: math.ceil(
2.675
)
Out[
4
]:
3
In [
5
]: math.floor(
2.675
)
Out[
5
]:
2
|
三. 类型判断
type(obj), 返回类型.
isinstance(obj, class_or_tuple), 返回布尔值.
|
1
2
3
4
5
6
7
8
9
10
11
12
|
In [
1
]: name
=
'ames'
In [
2
]:
type
(name)
Out[
2
]:
str
In [
3
]:
isinstance
(name,
str
)
Out[
3
]:
True
In [
4
]:
isinstance
(name,
list
)
Out[
4
]:
False
In [
5
]:
|
四. list
1). 列表的特点
|
1
2
3
4
5
6
7
|
1. 一个队列，一个排列整齐的队伍;
2. 列表内的个体称作元素，由若干元素组成列表;
3. 元素可以是任意对象（数字，字符串，对象，列表，元组，字典等）;
4. 列表内元素有序，可以使用索引;
5. 线性的数据结构;
6. 使用[]表示;
7. 列表是可变的;
|
2). 列表定义, 初始化
|
1
2
3
4
5
6
7
|
In [
6
]: lst
=
list
()
In [
7
]:
type
(lst)
Out[
7
]:
list
In [
8
]: lst
Out[
8
]: []
|
3). 列表索引访问
列表可通过索引访问，索引也称作下标，索引分为正索引和负索引，索引超界会引发 IndexError.
4). 列表 - 增
创建列表 :
|
1
|
In [
9
]: fruits_list
=
[
'apple'
,
'orange'
,
'mango'
]
|
or
|
1
|
In [
11
]: fruits_list
=
list
([
'apple'
,
'orange'
,
'mango'
])
|
增加元素 : L.append(object) -> None
|
1
2
3
4
5
6
7
|
In [
12
]: fruits_list
Out[
12
]: [
'apple'
,
'orange'
,
'mango'
]
In [
13
]: fruits_list.append(
'cherry'
)
In [
14
]: fruits_list
Out[
14
]: [
'apple'
,
'orange'
,
'mango'
,
'cherry'
]
|
插入元素 : L.insert(index, object) -> None
|
1
2
3
4
|
In [
17
]: fruits_list.insert(
1
,
'lime'
)
In [
18
]: fruits_list
Out[
18
]: [
'apple'
,
'lime'
,
'orange'
,
'mango'
,
'cherry'
]
|
列表扩展 : L.extend(iterable) -> None
|
1
2
3
4
5
6
7
8
|
In [
22
]: number
=
[
'first'
,
'second'
,
'third'
]
In [
23
]: fruits_list.extend(number)
In [
24
]: fruits_list
Out[
24
]: [
'apple'
,
'lime'
,
'orange'
,
'mango'
,
'cherry'
,
'first'
,
'second'
,
'third'
]
In [
25
]:
|
连接操作 : '+ -' -> list
|
1
2
3
4
5
6
|
In [
25
]: fruits_list
=
[
'apple'
,
'lime'
,
'orange'
]
In [
26
]: number
=
[
'first'
,
'second'
,
'third'
]
In [
27
]: fruits_list
+
number
Out[
27
]: [
'apple'
,
'lime'
,
'orange'
,
'first'
,
'second'
,
'third'
]
|
重复操作 : '*' -> list
|
1
2
3
4
|
In [
28
]: fruits_list
=
[
'apple'
,
'lime'
,
'orange'
]
In [
29
]: fruits_list
*
2
Out[
29
]: [
'apple'
,
'lime'
,
'orange'
,
'apple'
,
'lime'
,
'orange'
]
|
5). 列表 - 删
根据value删除元素 : L.remove(value) -> None
|
1
2
3
4
5
6
|
In [
33
]: fruits_list
=
[
'apple'
,
'lime'
,
'orange'
,
'mango'
,
'apple'
,
'lime'
,
'orange'
,
'mango'
]
In [
34
]: fruits_list.remove(
'lime'
)
In [
35
]: fruits_list
Out[
35
]: [
'apple'
,
'orange'
,
'mango'
,
'apple'
,
'lime'
,
'orange'
,
'mango'
]
|
根据索引值删除元素 : L.pop([index]) -> item
注：不指定索引值，就从列表尾部弹出一个元素, 索引超界会报错 IndexError
|
1
2
3
4
5
6
7
8
|
In [
36
]: fruits_list
Out[
36
]: [
'apple'
,
'orange'
,
'mango'
,
'apple'
,
'lime'
,
'orange'
,
'mango'
]
In [
37
]: fruits_list.pop(
2
)
Out[
37
]:
'mango'
In [
38
]: fruits_list
Out[
38
]: [
'apple'
,
'orange'
,
'apple'
,
'lime'
,
'orange'
,
'mango'
]
|
清除列表所有元素 : L.clear() -> None
注：清除列表所有元素后，剩下一个空列表；
|
1
2
3
4
5
6
7
|
In [
39
]: fruits_list
Out[
39
]: [
'apple'
,
'orange'
,
'apple'
,
'lime'
,
'orange'
,
'mango'
]
In [
40
]: fruits_list.clear()
In [
41
]: fruits_list
Out[
41
]: []
|
6). 列表 - 改
通过索引访问修改 : list[index] = value
注：索引不要越界.
|
1
2
3
4
5
6
|
In [
44
]: fruits_list
=
[
'apple'
,
'lime'
,
'orange'
]
In [
45
]: fruits_list[
1
]
=
'mango'
In [
46
]: fruits_list
Out[
46
]: [
'apple'
,
'mango'
,
'orange'
]
|
7). 列表 - 查
查找元素对应的索引值 : L.index(value, [start, [stop]]) -> integer
注：查找时，匹配到一个就立即返回，否则报错 ValueError
|
1
2
3
4
|
In [
48
]: fruits_list
=
[
'apple'
,
'orange'
,
'apple'
,
'lime'
,
'orange'
,
'mango'
]
In [
49
]: fruits_list.index(
'apple'
,
1
,
5
)
Out[
49
]:
2
|
匹配列表中元素出现次数 : L.count(value) -> integer
|
1
2
3
4
|
In [
50
]: fruits_list
=
[
'apple'
,
'orange'
,
'apple'
,
'lime'
,
'orange'
,
'mango'
]
In [
51
]: fruits_list.count(
'apple'
)
Out[
51
]:
2
|
8). 列表其他操作：
将列表元素反转 : L.reverse() -> None
|
1
2
3
4
5
6
7
|
In [
52
]: fruits_list
Out[
52
]: [
'apple'
,
'orange'
,
'apple'
,
'lime'
,
'orange'
,
'mango'
]
In [
53
]: fruits_list.reverse()
In [
54
]: fruits_list
Out[
54
]: [
'mango'
,
'orange'
,
'lime'
,
'apple'
,
'orange'
,
'apple'
]
|
对列表排序 : L.sort(key=None, reverse=False) -> None
注：排序时默认升序，reverse为True，则反转降序排列；key指定一个函数，指定如何排序。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
In [
59
]: fruits_list
Out[
59
]: [
'mango'
,
'orange'
,
'lime'
,
'apple'
,
'orange'
,
'apple'
]
In [
60
]: fruits_list.sort()
In [
61
]: fruits_list
Out[
61
]: [
'apple'
,
'apple'
,
'lime'
,
'mango'
,
'orange'
,
'orange'
]
In [
62
]: fruits_list.sort(key
=
len
)
In [
63
]: fruits_list
Out[
63
]: [
'lime'
,
'apple'
,
'apple'
,
'mango'
,
'orange'
,
'orange'
]
|
判断一个元素是否在列表中 : in
注：返回结果为bool.
|
1
2
|
In [
64
]:
'apple'
in
fruits_list
Out[
64
]:
True
|
9). 列表复制
列表复制 : L.copy() -> list -- a shallow copy of L
shadow copy : 影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已.
深拷贝 : copy模块提供了 deepcopy
浅拷贝在内存中只额外创建第一层数据.
深拷贝在内存中将所有的数据重新创建一份（排除最后一层，即：python内部对字符串和数字的优化）
浅拷贝：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
In [
65
]: lst0
=
[
1
,
2
, [
3
,
4
,
5
],
6
]
In [
66
]: lst1
=
lst0.copy()
In [
67
]: lst0
=
=
lst1
Out[
67
]:
True
In [
68
]: lst1[
2
][
2
]
=
10
In [
69
]: lst1
Out[
69
]: [
1
,
2
, [
3
,
4
,
10
],
6
]
In [
70
]: lst1
=
=
lst0
Out[
70
]:
True
|
深拷贝：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
In [
71
]:
import
copy
In [
72
]: lst2
=
[
1
,
2
, [
3
,
4
,
5
],
6
]
In [
73
]: lst3
=
copy.deepcopy(lst2)
In [
74
]: lst2
=
=
lst3
Out[
74
]:
True
In [
75
]: lst3[
2
][
2
]
=
10
In [
76
]: lst3
Out[
76
]: [
1
,
2
, [
3
,
4
|