python学习随笔(二)_内置数据结构_列表,元组
---------------------------------------------------------------------------------------
第二章 内置数据结构
分类
数值型
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 )
