---------------------------------------------------------------------------------------
第二章 内置数据结构
分类
数值型
int #整型
float #浮点型
compex #负数型
bool #布尔型
序列对象
字符串 #str
列表 # list
tuple #元组
键值对
集合 #set
字典 #dict
---------------------------------------------------------------------------------------
数值型
数值型
int,float,complex,bool都是class,1、5.0、2+3j都是对象即实例
类型转换(built-in)
int(x) #返回一个整数
float(x) #返回一个浮点数
complex(x)、complex(x,y) #返回一个复数
bool(x) #返回布尔值,前面讲过False等价的对象
数字的处理函数
floor #向下取整
ceil #向上取整
int #取整数部分
// #整除且向下取
round #四舍六(大于0.5也算6)入五取偶
min() #取最小值
max() #取最大值
pow(x,y)等于x**y #x的y次方(基本直接用后一种)
math.sqrt() #开方
进制函数返回的值是字符串
bin() #二进制
oct() #八进制
hex() #十六进制
math(pi) #π
math.e #自如常数
类型判断
type(obj) ,返回类型,而不是字符串
isinstance(obj, class_or_tuple),#返回布尔值
例:
type(hex(16)) #返回的是str,是一,类型
#type(16+Ture+2.0) #隐式类型转换,强类型转换
float #向高精度转换
max('1','2',3) #不同类型默认不可以比较
数据结构:
列表list
一个队列,一个排列整齐的队伍
列表内的个体称作元素,由若干元素组成列表
元素可以是任意对象(数字、字符串、对象、列表等)
列表内元素有顺序,可以使用索引
线性的数据结构
使用 [ ] 表示
***列表是可变的
#列表查找时直接平移找的速度快
列表list定义 初始化
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
列表不能一开始就定义大小
链表link #排列不是连续的,但是索引的
queue #队列,先进先出(例如过地铁安检)
stack #栈,后进先出(最先压进去的后出来)
列表索引访问
#索引,也叫下标
#正索引:从左至右,从0开始,为列表中每一个元素编号
#负索引:从右至左,从-1开始
#正负索引不可以超界,否则引发异常IndexError
#为了理解方便,可以认为列表是从左至右排列的,左边是头部,右边是尾部,左边是下界,右边是上界
#列表通过索引访问
#list[index] ,index就是索引,使用中括号访问
列表查询
#index(value,[start,[stop]])
# 通过值value,从指定区间查找列表内的元素是否匹配
#匹配第一个就立即返回索引
#匹配不到,抛出异常ValueError
例:对比
#l[3] #查找l列表索引号为3的元素 #O(1)索引找元素号
#l.index(3) #查找列表l元素第一个为3的索引号 #找O(n)遍历(少做)
count(value)
#返回列表中匹配的次数
时间复杂度
#index和count方法都是O(n) #遍历(耗时)
len() #查询列表元素个数
如何查帮助
#IPython中输入help(keyword)
#keyword可以是变量、对象、类名、函数名、方法名
列表元素修改
#索引访问修改
list[index] = value
索引不要超界
#列表增加、插入元素
append(object) -> None #O(1) #最常用,放什么都当是一个元素
#列表尾部追加元素,返回None
#返回None就意味着没有新的列表产生,就地修改
#时间复杂度是O(1)
#append格式
列表名.append()
insert(index, object) -> None #O(n)少用
#在指定的索引index处插入元素object
#返回None就意味着没有新的列表产生,就地修改
#时间复杂度是O(n)
#索引超越上界,尾部追加,超越下界,头部追加
列表增加、插入元素
#extend(iteratable) -> None
#将可迭代对象的元素追加进来,返回None,就地修改
#+ -> list
#连接操作,将两个列表连接起来 #两个列表相加新建列表占内存资源
#产生新的列表,原列表不变
#本质上调用的是__add__()方法
#* -> list
#重复操作,将本列表元素重复n次,返回新的列表
列表的修改分两种,下面举例说明:
#简单的类型,改任意内容等于改其本身
#lst = [1,2]*3
#lst =[1,2,1,2,1,2]
#复杂(引用类型)类型(放的是门牌号)
#lst = [[100,200]]*3
#lst = [[100, 200], [100, 200], [100, 200]]
#lst[0][1] = 9 #lst = [[100, 9], [100, 9], [100, 9]]
列表删除元素
remove(value) -> None
#从左至右查找第一个匹配value的值,移除该元素,返回None,就地修改O(n)
pop([index]) -> item
#不指定索引index,就从列表尾部弹出一个元素
#指定索引index,就从索引处弹出一个元素,索引超界抛出IndexError错误
#不指定索引是O(1),指定索引是O(n)
clear() -> None
#清除列表所有元素,剩下一个空列表
列表其他操作
reverse() -> None
#将列表元素反转,返回None,就地修改
sort(key=None, reverse=False) -> None
#对列表元素进行排序,就地修改,默认升序
#reverse为True,反转,降序
#key一个函数,指定key如何排序
格式:
lst.sort(key=str,reverse=True)
##降序,key = str,按照字符串的形式比较排序,排序后元素不变
in
#[3,4] in [1, 2, [3,4]]
#for x in [1,2,3,4]
== #比较的是内容
is #比较的是id是不是相同
列表复制
#shadow copy #影子拷贝,浅拷贝,遇到引用类型只复制了一个引用而已
如果lst5 = lst4.copy() #列表中的有引用类型拷贝时直接拷贝引用的id号,更改时两遍都改
深拷贝
#copy模块提供了deepcopy
例:
import copy
lst0 = [1, [2, 3, 4], 5]
lst5 = copy.deepcopy(lst0)
lst5[1][1] = 20 #只更改lst5索引为[1][1]的元素
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个不同的元素,返回一个新的列表
-------------------------------------------------------------------------------------------------
元组tuple
#一个有序的元素组成的集合
#使用小括号 ( ) 表示
#元组是不可变对象
元组的定义 初始化
#定义
#tuple() -> empty tuple
#tuple(iterable) -> tuple initialized from iterable's items
注意定义后不可以改:
t = tuple() # 空元组,工厂方法
t = () #空元组
t = tuple(range(1,7,2)) # iteratable
t = (2,4,6,3,4,2)
t = (1,) # 一个元素元组的定义,注意有个逗号
t = (1,)*5
t = (1,2,3) * 6
元组元素的访问和列表相同
支持索引(下标)
#正索引:从左至右,从0开始,为列表中每一个元素编号
#负索引:从右至左,从-1开始
#正负索引不可以超界,否则引发异常IndexError
#元组通过索引访问
#tuple[index] ,index就是索引,使用中括号访问
元组查询
#index(value,[start,[stop]])
#通过值value,从指定区间查找列表内的元素是否匹配
#匹配第一个就立即返回索引
#匹配不到,抛出异常ValueError
#count(value) #返回列表中匹配value的次数
#时间复杂度 #index和count方法都是O(n)
#随着列表数据规模的增大,而效率下降
#len(tuple) #返回元素的个数
元组其它操作
#元组是只读的,所以增、改、删方法都没有
命名元组namedtuple
#帮助文档中,查阅namedtuple,有使用例程
#namedtuple(typename, field_names, verbose=False, rename=False)
#命名元组,返回一个元组的子类,并定义了字段
#field_names可以是空白符或逗号分割的字段的字符串,可以是字段的列表
例:
from collections import namedtuple
Point = namedtuple('_Point',['x','y']) # Point为返回的类
p = Point(11, 22)
#打印p1结果为_Point(x=11,y=22)
引申内容:字符串处理
'x,y'.split() #输入结果为['x','y']
split() #默认使用空白字符切割,
Student = namedtuple('Student', 'name age')
tom = Student('tom', 20)
jerry = Student('jerry', 18)
tom.name
---------------------------------------------------------------------------------
冒泡法排序
#属于交换排序
#两两比较大小,交换位置。如同水泡咕嘟咕嘟往上冒
#结果分为升序和降序排列
升序: #n个数从左至右,编号从0开始到n-1,索引0和1的值比较,如果索引0大,则交换两者位置,如
果索引1大,则不交换。继续比较索引1和2的值,将大值放在右侧。直至n-2和n-1比较完,第
一轮比较完成。第二轮从索引0比较到n-2,因为最右侧n-1位置上已经是最大值了。依次类推,
每一轮都会减少最右侧的不参与比较,直至剩下最后2个数比较。降序和升序相反。
冒泡法总结
#冒泡法需要数据一轮轮比较
#可以设定一个标记判断此轮是否有数据交换发生,如果没有发生交换,可以结束排序,如果发生交换,继续下一轮排序
#最差的排序情况是,初始顺序与目标顺序完全相反,遍历次数1,...,n-1之和n(n-1)/2
#最好的排序情况是,初始顺序与目标顺序完全相同,遍历次数n-1
#时间复杂度O(n 2 )