第三章 - Python 内置数据结构
分类
数值型
- int、float、complex、bool
序列对象
- 字符串 str
- 列表 list
- tuple
键值对
- 集合set
- 字典dict
数值型
数值型
- int、float、complex、bool都是class,1、5.0、2+3j都是对象即实例
- int:python3的int就是长整型,且没有大小限制,受限于内存区域的大小
- float:有整数部分和小数部分组成。支持十进制和科学计数法表示。只有双精度型。
- complex:有实数和虚数部分组成,实数和虚数部分都是浮点数,3+4.2J
- bool:int的子类,仅有2个实例True、False对应1和0,可以和整数直接运算
类型转换(built-in)
- int(x) 返回一个整数 ,int是与类型名相同的内置转换函数,如果字符串不合法抛出异常
- float(x) 返回一个浮点数
- complex(x)、complex(x,y) 返回一个复数
- bool(x) 返回布尔值,前面讲过False等价的对象
数字的处理函数
- round(),四舍五入?六入四舍五取偶
- math模块、floor()地板、天花板ceil()
- int() 、//
- 举例:
import math
print(math.floor(2.5), math.floor(-2.5))
print(math.ceil(2.5), math.ceil(-2.5))
以下打印什么结果?说明什么
print(int(-3.6), int(-2.5), int(-1.4))
print(int(3.6), int(2.5), int(1.4))
print(7//2, 7//-2, -7//2, -(7//2))
print(2//3, -2//3, -1//3)
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))
- round(),四舍六入五取偶
- floor()向下取整、ceil()向上取整
- int() 取整数部分
// 整除且向下取整
min()
- max()
- pow(x,y) 等于 x**y
math.sqrt()
进制函数,返回值是字符串
- bin()
- oct()
- hex()
math.pi π
- math.e 自如常数
类型判断
- type(obj) ,返回类型,而不是字符串
- isinstance(obj, class_or_tuple),返回布尔值
举例:
- type(a)
- type(‘abc’)
- type(123)
- isinstance(6, str)、type(6) == str
- isinstance(6, (str, bool, int))
type(1+True) # bool型是int的子类
- type(1+True+2.0) # 是什么?隐式转换 # 都是数值类型,往高精度转
列表
- 一个队列,一个排列整齐的队伍
- 列表内的个体称作元素,由若干元素组成列表
- 元素可以是任意对象(数字、字符串、对象、列表等)
- 列表内元素有顺序,可以使用索引
- 线性的数据结构
- 使用 [ ] 表示
- 列表是可变的
- 列表list、链表、queue、stack的差异
列表list定义 初始化
赋值即定义,这也是静态语言和动态语言的区别。
- list() -> new empty list
- list(iterable) -> new list initialized from iterable’s items
- 列表不能一开始就定义大小
lst = list()
lst = []
lst = [2, 6, 9, ‘ab’]
lst = list(range(5))
列表索引访问
- 索引,也叫下标
- 正索引:从左至右,从0开始,为列表中每一个元素编号
- 负索引:从右至左,从-1开始
- 正负索引不可以超界,否则引发异常IndexError
- 为了理解方便,可以认为列表是从左至右排列的,左边是头部,右边是尾部,左边是下界,右边是上界
- 列表通过索引访问
- list[index] ,index就是索引,使用中括号访问
列表查询
index(value,[start,[stop]])
- 通过值value,从指定区间查找列表内的元素是否匹配
- 匹配第一个就立即返回索引
- 匹配不到,抛出异常ValueError
count(value)
- 返回列表中匹配value的次数
时间复杂度
- index和count方法都是O(n)
- 随着列表数据规模的增大,而效率下降
如何返回列表元素的个数?如何遍历?如何设计高效?
- len() # 是序列共有的函数,不是list类的方法函数
如何查帮助
官方帮助文档
- 搜索关键字
IPython中
- help(keyword)
- keyword可以是变量、对象、类名、函数名、方法名
列表元素修改
- 索引访问修改
- list[index] = value
- 索引不要超界
列表增加、插入元素
append(object) -> None
- 列表尾部追加元素,返回None
- 返回None就意味着没有新的列表产生,就地修改
- 时间复杂度是O(1),因为直接可以索引到结尾添加
insert(index, object) -> None
- 在指定的索引index处插入元素object
- 返回None就意味着没有新的列表产生,就地修改
- 时间复杂度是O(n),因为会调整内存布局
- 索引能超上下界吗?
- 超越上界,尾部追加
- 超越下界,头部追加
列表增加、插入元素
extend(iteratable) -> None
- 将可迭代对象的元素追加进来,返回None
- 就地修改
+ -> list
- 连接操作,将两个列表连接起来
- 产生新的列表,原列表不变
- 本质上调用的是add()方法
* -> list
- 重复操作,将本列表元素重复n次,返回新的列表
列表 *重复的坑
- * -> list
- 重复操作,将本列表元素重复n次,返回新的列表
x = [[1,2,3]]*3
print(x)
x[0][1] = 20
print(x)
y = [1]*5
y[0] = 6
y[1] = 7
print(y)
上面代码运行结果是什么?为什么?
列表删除元素
remove(value) -> None
- 从左至右查找第一个匹配value的值,移除该元素,返回None
- 就地修改
- 效率?
pop([index]) -> item
- 不指定索引index,就从列表尾部弹出一个元素
- 指定索引index,就从索引处弹出一个元素,索引超界抛出IndexError错误
- 效率?指定索引的的时间复杂度?不指定索引呢?
clear() -> None
- 清除列表所有元素,剩下一个空列表(一批元素不要,可能会引起垃圾回收gc)
列表其它操作
reverse() -> None
- 将列表元素反转,返回None
- 就地修改
sort(key=None, reverse=False) -> None
- 只写一个参数,匹配的是第一个参数,要匹配第二个参数,要指明参数名字,这么写 lst.sort(reverse=True)
- 对列表元素进行排序,就地修改,默认升序
- reverse为True,反转,降序
- key一个函数,指定key如何排序
- lst.sort(key=functionname)
in
- [3,4] in [1, 2, [3,4]]
- for x in [1,2,3,4]
not in
列表复制
- 先看一段代码
lst0 = list(range(4))
lst2 = list(range(4))
print(lst0 == lst2)
lst1 = lst0
lst1[2] = 10
print(lst0)
lst0 == lst2相等吗?为什么?lst0里面存的是什么?
== 比较的是对象的内容 (True)
is 比较的是对象的地址 (False) 即 id(lst0) == id(lst2)
这里虽然都是创建 list(range(4)) 这个对象,解释器并没有优化为只创建一个
请问lst0的索引为2的元素的值是什么?
请问lst1 = lst0这个过程中有没有复制过程?
列表复制
- copy() -> List
- shadow copy返回一个新的列表
lst0 = list(range(4))
lst5 = lst0.copy()
id(lst0) 和 id(lst5) 是不同的 ,与 lst5=lst0 还是不一样的
copy是把原列表的item复制到一个片新内存,创建一个新列表
print(lst5 == lst0)
lst5[2] = 10
print(lst5 == lst0)
lst0和lst5一样吗?
- 对比前面程序的差别
lst0 = [1, [2, 3, 4], 5]
lst5 = lst0.copy()
lst5 == lst0
lst5[2] = 10
lst5 == lst0
lst5[2] = 5
lst5[1][1] = 20
lst5 == lst0
list中间元素是个复杂元素,所以copy时只拷贝了它的引用,即它的地址。所以在一边修改之后,另一边也一同修改了。
列表复制
shadow copy
- 影子拷贝,也叫浅拷贝,遇到引用类型,只是复制了一个引用而已
深拷贝
- copy模块提供了deepcopy
import copy
lst0 = [1, [2, 3, 4], 5]
lst5 = copy.deepcopy(lst0)
lst5[1][1] = 20
lst5 == lst0
随机数
- random模块
- randint(a, b) 返回[a, b]之间的整数
- choice(seq) 从非空序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。random.choice([1,3,5,7])
- randrange ([start,] stop [,step]) 从指定范围内,按指定基数递增的集合中获取一个随机数,基数缺省值为1。 random.randrange(1,7,2)
- random.shuffle(list) ->None 就地打乱列表元素
- sample(population, k) 从样本空间或总体(序列或者集合类型)中随机取出k个不同的元素,返回一个新的列表
- random.sample([‘a’, ‘b’, ‘c’, ‘d’], 2)
- random.sample([‘a’, ‘a’], 2) 会返回什么结果