内置数据类型
分类：
数值型
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、Flase对应1和0，可以和整数直接运算
类型转换（built-in）
int(x)返回一个整数
float(x)返回一个浮点数
complex(x)、complex(x,y) 返回一个复数 1 返回实部 2 返回虚部
bool(x) 返回布尔值
数字的处理函数
round() 四舍六入 五取偶
floor() 向下取整 ceil() 向上取整
int() 取整数部分 ，和 // 整除一样
例子：
import math
math.floor(3.1) math.floor(3.7) > 都为3
math.ceil(4.1) math.ceil(4.7) > 都为5
round(5.3) > 5
round(5.5) > 6
round(6.6) > 7
min() 取最小
max() 取最大
pow(x,y) 等于x**y (x的y次方)
math.sqrt() 开方
例子：
min(1,2,7,3) > 1
max(1,2,7,3) > 7
pow(2,3) > 等价于 2**3 2的3次方 > 8
pow(4,4) > 256
math.sqrt(4)
进制函数，返回值是字符串
bin() 返回二进制数值
oct() 返回八进制数值
hex() 返回十六进制数值
例子：
bin(2) > 0b10
bin(11) > 0b1011
oct(8) > 0o10
oct(11) > 0o13
hex(16) > 0x10
hex(11) > 0xb
hex(12) > 0xc
math.pi π 圆周率
math.e 自如常数
例子：
math.pi > 3.141592653589793
math.e > 2.718281828459045
类型判断
type(obj) 返回类型，而不是字符串
isinstance(obj,class_or_tuple) 返回布尔值
例子：
a = 5
b = 'example'
type(a) > int
type(b) > str
type(a) == int > True
type(b) == int > Flase
type(b) == str > True
isinstance(a,int) > True
isinstance(a,str) > Flase
isinstance(b,int) > True
isinstance(b,str) > Flase
isinstance(a,(int,str)) > True a属于（int,str）当中的一个
isinstance(b,(int,str)) > True
isinstance(6,(str,bool,int)) > True
思考:
type(1+True) ?
type(1+True+2.0) 是什么？
1+True+2.5 = 4.5
列表list
一个队列，一个排列整齐的队伍
列表内的个体称作元素，由若干个元素组成列表
元素可以是任意对象（数字、字符串、对象、列表等）
列表内元素有顺序，可以使用索引
线性的数据结构
使用[]表示
列表是可变的
列表list、链表、queue（队列，先进先出，后进先出）、stack（栈，后进先出）的差异
列表list定义 初始化
list() > new empty list
list(iterable) > new list initialized from iterable's items
列表不能一开始就定义大小
加乘列表可以产生新的列表
+ - * /
例子：
lst = [] 可以写成 list()
lst = list()
lst = []
lst = [2,4,8,'ab']
lst = list(range(5))
a = [1,2,3,4]
b = [123,'abc',456]
c = [a,b]
print(c) > [[1, 2, 3, 4], [123, 'abc', 456]]
列表索引访问
索引，也叫下标
正索引：从左到右，从0开始，为列表中每一个元素编号
负索引：从右到左，从-1开始
正负索引不可以超界，否则引发异常 IndexError
为了理解方便，可以认为列表是从左到右排列的，左边是头部，右边是尾部，左边是下界，
右边是上界
列表通过索引访问
list[index]，index就是索引，使用中括号访问
列表查询
index(value,[start,[stop]])
通过值value,从指定区间查找列表内的元素是否匹配
匹配第一个就立即返回索引
匹配不到，抛出异常IndexError
备注：start 表示是从哪个索引号开始查找
exp:
a = [1,2,2,4,5,5,8]
a.index(8) > 6
a.index(2) > 2
a.index(2,1) > 1 从索引编号1开始找
a.index(4,3) > 3 从索引编号3开始找
a.index(4.4) > 4 is not in list 索引编号为4上的值为5，所以找不到
count(value)
返回列表中匹配value的次数
exp:
a.count(1) > 1 1在列表a中的个数为1
a.count(5) > 2 5在列表a中的个数为2
a.count(9) > 0 9在列表a中的个数为0
时间复杂度
index和count方法都是O(n) n表示列表中元素的个数
随着列表数据规模的增大，而效率下降
O(1) 执行1次
O(n) 执行n次
如何返回列表元素的个数？如何遍历？如何设计高效？
len()
如何查帮助
官方帮助文档
搜索关键字
IPython中
help(keyword)
keyword可以是变量、对象、类名、函数名、方法名
列表元素修改
索引访问修改
list[index] = value
索引不要超界
exp:
a = [1,2,3,45,6]
a [3] = 54
a
[1, 2, 3, 54, 6]
列表增加、插入元素
append(object) -> None
列表尾部增加元素，返回None
返回None就意味着没有新的列表产生，就地修改
时间复杂度是O(1)
exp:
a = [1, 2, 3, 54, 6]
a.append(9)
type(a.append(9)) -> None
a
[1, 2, 3, 54, 6, 9]
说明：在列表a尾部加入元素9
insert(index,object) -> None
在指定的索引index处插入元素object
返回None就意味着没有新的列表产生，就地修改
时间复杂度是O(1)
索引能超上下界吗？
超越上界，尾部增加
超越下界，头部增加
exp:
a.insert(1,'x')
print(a)
[1, 'x', 2, 3, 54, 6, 9, 10]
a.insert(10,99)
print(a)
[1, 'x', 2, 3, 54, 6, 9, 10,99]
extend(iteratable) -> None
将可迭代对象的元素增加进来，返回None
就地修改
exp:
a=[11,21,31]
b=[99,101,103,105]
a.extend(b)
a
[11, 21, 31, 99, 101, 103, 105]
b
[99, 101, 103, 105]
+ -> list (加减操作产生新列表，原列表不变)
连接操作，将两个列表连接起来
产生新的列表，原列表不变
本质上调用的是 _add_()方法
exp:
a=[11,21,31]
b=[99,101,103,105]
a+b > [11, 21, 31, 99, 101, 103, 105]
a
[11,21,31]
b
[99,101,103,105]
* -> list 乘
重复操作，将本列表元素重复n次，返回新的列表，原列表不变
exp:
b = [99, 101, 103, 105]
b*3
[99, 101, 103, 105, 99, 101, 103, 105, 99, 101, 103, 105]
列表删除元素
remove(value) -> None
从左到右查找第一个匹配vlaue的值，移除该元素，返回None
就地修改
效率 O(1)
exp:
b = [99, 101, 103, 105]
b.remove(101)
b
[99, 103, 105]
pop([index]) -> item
不指定索引index，就从列表尾部弹出一个元素
指定索引index，就从索引处弹出一个元素，索引超界，抛出IndexError
效率？指定索引的时间复杂度？不指定索引呢？
exp：
b = [99, 103, 105]
b.pop(0)
99
b
[103, 105]
clear() -> None
清除列表所有元素，剩下一个空列表
列表其它操作
reverse() -> None
将列表元素反转，返回None
就地修改
exp:
a = [1,2,3,4,5,6,99,100]
a.reverse()
a = [100, 99, 6, 5, 4, 3, 2, 1]
sort(key=None,reverse=Flase) -> None
对列表元素进行排序，就地修改，默认升序
reverse为True，反转，降序
key一个函数，指定key如何排序
lst.sort(key=functionname)
注意：排序的同时如果也要进行reverse，则要在括号内写明，reverse=True
不能只写True，只写True是对于key的值，而key的值为函数
exp:
b = [99,101,89,120,75,91]
b.sort()
b
[75, 89, 91, 99, 101, 120]
b.sort(reverse=True) 排序并将元素反转
b
[120, 101, 99, 91, 89, 75]
a = [120,99,'felix',19,'alina']
a.sort(key=int,reverse=true)
a
['felix', 'alina', 99, 19, 120]
in
[3,4] in [1,2,3,4]
for x in [1,2,3,4]
exp:
a = [120,99,'felix',19,'alina']
120 in a
True
11 in a
Flase
'felix' in a
True
列表复制
lst0 = list(range(4))
lst1 = list(range(4))
lst0 == lst1
lst2 = lst0
lst2[2] = 10
请问：
lst0 == lst1吗？
lst0的索引为2的元素值是什么？
lst2 = lst0 这个过程有没有复制过程？
解析：
lst0
[0, 1, 2, 3]
id(lst0)
78963400
lst1
[0, 1, 2, 3]
id(lst1)
77840520
lst0 == lst1 #此处是进行列表里的元素进行等价
True
lst2 = lst0
lst2
[0, 1, 2, 3]
id(lst2)
78963400 #id 和lst0一样
lst2[2] = 10
lst2
[0, 1, 10, 3]
id(lst2)
78963400
lst0
[0, 1, 10, 3]
所以：没有复制过程，因为内存地址是一样的
copy() -> list
shadow copy返回一个新的列表
exp1:
lst0 = list(range(4))
lst5 = lst0.copy()
lst5[2] = 10
lst0和lst5一样吗
解析：
lst5是复制lst0的内容，新创建一个列表，lst5和lst0内存地址不一样
exp2:
lst0 = [1,[2,3,4],5]
lst5 = lst0.copy()
lst5 == lst0 -> True #元素内容相等，所以列表相等
lst5[2] = 10
lst5 == lst0 -> Flase #元素内容不相等，所以列表不相等
lst5[2] = 5
lst5[1][1] = 20 -> 将[2,3,4]的索引1的改为20 -> [1,[2,20,4],5]
lst5 == lst0 -> True #因为lst0和lst5都是将[2,3,4]
解析：
因为lst0和lst5都是将[2,3,4]试做一个内存地址，复制的过程是复制这块区域，所以当lst5修改这块区域索引1
的值为20时，lst5和lst0同时修改，所以此时 lst5 == lst0 为True
shadow copy
影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已
深拷贝
copy模块提供了deepcopy
import copy
lst0 = [1,[2,3,4],5]
lst5 = copy.deepcopy(lst0)
lst5 == lst0 -> True
lst5[1][1] = 20
lst5 = -> [1,[2,20,4],5]
lst0 = [1,[2,3,4],5]
lst5 == lst0 -> Flase
随机数
random模块
randint(a,b) 返回[a,b]之间的整数
choice(seq)从非空序列的元素中随机挑选一个元素，
比如random.choice(range(10))，随机挑选一个整数，random.choice([1,3,5,7])
randrange([start,]stop[,setp]) 从指定范围中，按指定基数递增的集合中获取
一个随机整数，基数缺省值为1，random.randrange(1,7,2)
random.shffle(list) -> None 就地打乱列表元素