1 复习
数值分类：
int、float、bool、complex
序列对象：
字符串str、列表list、元组
键值对：
集合set、字典dict
数值型：
int、float、bool、complex都是对象，都是对象即实例：
int：python3的int就是长整型，且没有大小限制，受限于内存区域的大小。
float：有整数部分和小数部分组成。支持十进制和科学计数法表示。 C的双精度型实现。
complex：有实数和虚数部分组成，实数和虚数部分都是浮点数。
bool：int的子类，仅有2个实例True、 False对应1和0，可以和整数直接运算。
类型转换（built-in）：
int(x)： 返回一个整数
float(x)： 返回一个浮点数
complex(x)、 complex(x,y) ：返回一个复数
bool(x)： 返回布尔值，前面讲过False等价的对象
数学简单语句：
import math
math.floor()#向下取整
math.ceil()#向上取整
math.sqrt()#开根号
math.pow(x,y)#x的y次幂，等同于x**y
math.pi # π
math.e # 自如常数
max(iterable,*[,key,default])#可迭代对象的最大值
min(iterable,*[,key,default])#可迭代对象的最小值
round(number[,ndigits])#四舍六入，五取偶（取离他最近的偶数)
int()#不论正负只取整数部分
//#向下取整
进制函数（返回值是字符串）：
bin(x)#x转成二进制
oct(x)#x转成八进制
hex(x)#x转成十六进制
类型判断：
type(obj)#返回obj的类型，不是字符串。
isinstance(obj,class_or_tuple)->bool#obj是不是class_or_tuple的类型，类型多种必须用()括起来，返回布尔值。
type(1+True+2.0) # 是什么？注意这里有隐式转换。
isinstance(obj,class_or_tuple)类型判断，前面obj是不是后面的类型，多个类型必须用元组()，返回bool值
2 列表
2.1 列表定义
列表list（不要循环自己还增删自己！）：
有顺序、可索引、内存地址连续，随机查找，不便于在中间插入和删除
列表内的个体称作元素，有若干元素组成列表
元素可以是任意对象
线性的数据结构
使用[ ]表示
列表是可变的
和其他结构的区别：
链表：有顺序，可索引、内存地址可不连续，顺序查找，便于插入和删除
queue队列：先进先出、只能对两端操作，一种是列表实现，一种是链表实现
stack栈：只能对一端进行操作
2.1 列表表示
list() -> new empty list
list(iterable) -> new list initialized from iterable’s items
注意列表不能一开始就定义大小！
[]、list()#空列表2种定义方式。
list(range())#列表里面可以是可迭代对象。
和 [range( )] 区别：list把数据全输出，第二个显示range()，表示range()是列表的一个元素。列表中有引用类型时，复制时对引用类型是浅拷贝！可以使用深拷贝递归拷贝。
2.2 列表索引
索引，也叫下标：
正索引：从左至右，从0开始，为列表中每一个元素编号
负索引：从右至左，从-1开始
正负索引不可以超界，否则引发异常IndexError
为了理解方便，可以认为列表是从左至右排列的，左边是头部，右边是尾部，左边是下界，右边是上界
list[index]#index就是索引，使用中括号访问。
2.3 列表查询
列表查询：
.index(value,[start,[stop]])#匹配到第一个就立即返回索引，找不到异常，O(n)。
value in list: #比如`22 in list1`，返回bool值，判断value是否在list中。
.count(sub[,start[,end]])->int#返回列表中匹配value的次数，O(n)。
len(s)#()里面是容器，直接取长度计数，O(1)。
时间复杂度O(n)，随着列表数据规模的增大，而效率下降。
如何返回列表元素的个数？如何遍历？如何设计高效？使用len()函数。
官方文档(Python 3.x Manuals)可以查看函数的具体用法，也可以去官网查阅。
2.4 列表元素修改
列表增加、插入元素：
list[index] = value#索引不要超界
.append(object)->None
#尾部追加1个元素，因为是list所以追加数据量大会要连续的空间可能会引起GC，时间消耗大，尽量避免追加大量数据。
#返回None就意味着没有新的列表产生，就地修改
#时间复杂度是O(1)
.insert(index, object) -> None
#在指定的索引index处插入元素object，就地修改
#时间复杂度是O(n)，效率低，能不用则不用
#索引能超上下界吗？超越上界，尾部追加,超越下界，头部追加
.extend(iteratable)->None
#将可迭代对象的元素追加进来，就地修改，初始化可以用，别的就不用了。
+ -> list
#连接操作，将两个列表连接起来
#产生新的列表，原列表不变
#本质上调用的是__add__()方法
#注意和l4 += [1,2]执行过程不同，这个是就地修改。
* -> list
#重复操作，将本列表元素重复n次
#产生新的列表，原列表不变
#（有风险!）重复的其实是地址！
列表删除元素：
.remove(value) -> None
#从左至右查找第一个匹配value的值，移除该元素，返回None，就地修改，需要遍历，效率低。
.pop([index]) -> item
#不指定索引index，就从列表尾部弹出一个元素
#指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误
#效率？指定索引的的时间复杂度？不指定索引呢？都是，O(1)，效率高。
clear() -> None
#清除列表所有元素，剩下一个空列表
#GC会执行操作，数据量大，时间会长，不要频繁使用，而且数据很重要，不要轻易清空！
2.5 列表其他操作
reverse() -> None
#将列表元素反转，返回None，就地修改
sort(key=None, reverse=False) -> None
#对列表元素进行排序，就地修改，默认升序
#reverse为True，反转，降序
#key一个函数，指定key如何排序`lst.sort(key=function)`
2.6 复制
shadow copy：影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已
deep copy：深拷贝，copy模块提供了deepcopy，真正的拷贝了一遍，生成全新的对象
.copy()#浅拷贝
import copy
copy.deepcopy(x)#深拷贝x
3 元组
3.1 元组定义
tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable’s items
元组是不可变对象
元组、列表、字符串都是连续空间存放。
元组不可以改变，指的非类时：不能改变内容、指的是类时：地址不能改，内容可改。
！元组是只读的，所以增、改、删方法都没有！
()、tuple()#空元组
(1,)#注意一个元素后面加`,`才是元组
3.2 元组索引
支持索引（下标）：
正索引：从左至右，从0开始，为列表中每一个元素编号
负索引：从右至左，从-1开始
正负索引不可以超界，否则引发异常IndexError
tuple[index]#index就是索引，使用中括号访问
3.3 元组查询
index(value,[start,[stop]])->index
#通过值value，从指定区间查找列表内的元素是否匹配，匹配第一个就立即返回索引，匹配不到，抛出异常ValueError
count(value)
#返回列表中匹配value的次数
#index和count方法都是O(n)，随着列表数据规模的增大，而效率下降
#多使用len(tuple)：返回元素的个数，O(n)。
3.4 元组其他操作
命名元组：
namedtuple()：创建的是tuple类型，创建后不许修改，返回的是类型。
from collections import namedtuple
a=namedtuple('b','name')
tom = a(name='san')
print(tom)#输出：b(name='san')
4 随机数
随机数：
import random
random.choice(seq)
#从非空序列的元素中随机挑选一个元素。
#比如random.choice(range(10))，从0到9中随机挑选一个整数。
random.shuffle(x[,random]))->None
#洗牌，就地打乱列表元素,就地修改。
random.randrange(start,stop[,step])
#[)左闭右开，从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1。
random.randrange(stop)
#[)左闭右开，从0~stop取一个数。
random.randint(a,b)
# 返回[a, b]之间的整数。
random.sample(population,k)
#从样本空间或总体（序列或者集合类型）中随机取出k个`不同的元素`，返回一个新的列表。
#`不同元素`指的是是不同索引！