数据结构类型
数值型，都是class，都是对象即实例
int：长整型（python3中不区分长整形，没有大小，大小受限于内存）
float：浮点型，整数和小数部分，只有双精度型
complex：复数，实数虚数部分都是浮点数
bool：波尔型，int的子类，True（1）False（0），可与整数直接运算
类型转换：import math
floor（）向下取整
ceil（）向上取整
int（x）返回整数，直接去掉小数部分
float（x）返回浮点数
complex（x）、complex（x，y）返回一个复数
bool（x）返回布尔值，if后只跟波尔值
round（）四舍六入五取偶，遇到.5向偶取整，其他与四舍五入一致
min( ) 取最小值
max（）取最大值
divmod( ) 返回取模，取余值
pow（x，y）平方 ，x**y
math.sqrt()开方，
bin（）换算为二进制，返回字符串
oct（）换算为八进制，返回字符串
hex（）换算为十六进制，返回字符串
type 在ipython中可以查看对象类型
整型与浮点型运算，结果会转变为浮点型，向高精度方向转换，与其它语言相同。
isinstance 比较两个数据的数据类型，返回一个bool值，
也可表示为isinstance（‘5’，（int，float））字符串5判断是否为int或float中的一种，结果返回为false，此例中如果去掉引号，就返回Ture
// 整除向下取整
序列对象：
str：字符串，有序
list：列表
tuple：元组
键值对
set：集合
dict：字典
list 列表
python的官方文档
Ipython中 help(keyword)
可以是变量，对象，类名，函数名，方法名
列表内个体称为元素，有若干元素组成列表
列表查询较快，通过索引可以快速定位，但列表更改或删除增加较慢，假设插入中间一处位置，其后的所有数据都要在向后移动一位，速度较慢。
元素可以是任意对象（数字，字符串，对象，列表）
在内存中存放地址连续，可迭代，有序就可以索引
线性的数据结构
使用[ ]表示
不能提前定义大小
列表是可变的
list() -> new empty list list(iterable) -> new list initialized from iterable's items
lst=list(range(5)) 列表为可迭代对象 lst=[1,2,3,4,]
lst=[range(5)] 列表为字符串lst=[range(5)]
l=list（range（5））列表内包含可迭代对象，0，1，2，3，4，
l=[range（5）] 列表内包含一个字符串 range（5）
索引
正索引：从左至右，从0开始，为列表每一个元素编号
负索引：从右至左，从-1开始
正索引不可以超界，否则引发IndexError
规定 索引从左至右排列，左边是头部，是上界；右边是尾部，下界
list[index] index就是索引，使用中括号访问，根据索引号找元素
index(value,[start,[stop]]) 根据元素查找索引号，可指定区间，注意尽量不用,（要遍历）
匹配到第一个就退出
匹配不到，抛出异常
count（value）返回列表中value的出现次数，遍历 list.count(value)
时间复杂度 O(n) 随着列表数据规模的增大，效率降低
遍历 O(n)
len（）查看列表内元素的数目，信息在列表信息里，不会遍历O(1)
list[index] = value 根据索引修改元素，不要超界
append(object) -->None
append 增加的元素是一个，不能加列表，加列表，用extend
尾部追加元素，返回None
就地修改，返回None，没有新列表产生
时间复杂度是O(1)
insert(index,object) -->None
在指定处插入元素object
就地修改
时间复杂度O(n)
超越上界，尾部追加，用append
超越下界，首部追加，insert（1）
extend（iteratable）-->None
追加可迭代对象内的元素，返回None，追加的元素数目要注意，如果追加的数目过多的话，会影响原列表。要考虑内存中放最重要的数据。
就地修改
list + list
连接列表，产生新列表，本质是调用_add_()方法
返回新列表，重新占用内存，相当于将内存占用位置翻倍，要适当使用。
list*
lst1=[1,2]*3 返回的lst1=[1,2,1,2,1,2]
重复操作，将列表元素重复三次，返回新的列表。
list*重复的坑
lst2=[[100,200]]*3 返回的lst2=[[100,200],[100,200],[100,200]]
在列表lst2中，有三个元素，每个元素都是列表，此时输入lst[2][1]='a'
再次输入lst2查看，此时lst2=[[100, 'a'], [100, 'a'], [100, 'a']]
此处要注意，在列表中，某个元素为引用类型，表示这个元素的内存路径指向列表所在的地址，可以比喻为门牌号，三个门牌为101，102，103的房间里为门牌号301，当修改lst2[2][1]时，相当于修改了301里的数据。输入id查询列表的id号时，可以看到是一样的。先理解为这样。
如果输入lst2=[[100, 'a'], [100, 'a'], [100, 'a']]，那么就不会产生以上情况。三个地址是不同的，输入id（）可以查看在Cpython中的地址，可以看到是不同的。
remove（value）--》None
从左至右查找第一个匹配value的值，移除该元素，返回None
就地修改，一旦使用，要遍历列表，效率较低
pop([index])->item
不指定索引index，从列表尾部弹出一个元素
指定索引index，从索引处弹出一个元素，超界抛出异常IndexError错误
指定索引的话，如果位置较靠前，后边的元素全部向前推进一位，效率较低
如果不指定，直接弹出尾部元素，时间复杂度为O（1）
列表只用append和pop，可当作栈使用。
clear--》None 清除列表所有元素，剩下空列表，返回None，少做
reverse（）--》None
将列表元素反转，返回None，就地修改。
取数据时倒着取就行，何必反转，效率低，reversed 内建函数
sort (key=None,reverse=False)-->None
对列表元素进行排序，就地修改，默认升序
reverse为True，反转，降序，，key一个函数，指定key如何排序
lst.sort(key=functionname)
in
[1,2] in [1,2,3,4] --->True
for i in [1,2,3,4,5]
列表复制
lst0=[1,2,3,4,5]
lst1=lst0 此时lst0和lst1的地址相同，改一个，另一个也改变。
如果其中有引用类型，改变其中的列表内的元素，外边的地址仍然相同。
lst1=[1,2,3,4,[5,6]]
lst0=lst1
lst0[4][1]=100
lst0==lst1 这两个列表仍然相等,地址相同
lst3=[] for i in lst0 lst3.append()
用以上的方法复制的列表lst3是一个新列表，与原列表地址不同。
copy()--> list
shadow copy #复制，返回一个新的列表，直接copy就是浅拷贝。
浅复制只是复制单一元素和引用元素的地址，不会复制引用类型的引用内容。
deepcopy #深拷贝，copy模块提供了deepcopy
import copy lst0 = [1,[2,3,4],5] lst5 = copy.deepcopy(lst0) lst5[1][1] = 20
此时，返回False，深拷贝是重新创建了一个列表，包括其中的引用类型的内容。
如果要一个与原列表无关的新列表，就使用深拷贝。
随机数
random模块，随机数模块
random.randint(1,5) --> [1,5] 1到5之间的整数，包括1和5
random.randrange([start],stop,[step] --> 左闭右开区间。
random.choice --> 从可迭代对象中随机取一个值，常用来从列表中取值。
random.choices(population, weights=None, *, cum_weights=None, k=1)--> 从可迭代对象中随机挑选多次目标,population样本空间，weights权重，k是选出的次数，每次都是全部随机。
random.shuffle --> 打乱列表内的元素顺序，重新排序，就地打乱。
random.sample(population,k) --> 从列表中随机取k个不同的元素，返回一个列表。如果抽取数目，与元素个数相同，就相当于shuffle
元组
一个有序的元素组成的集合，元祖是不可变对象。只读，不能增，删，改。
定义：tuple()-->empty tuple
tuple(iterable) :元组内对象来自可迭代对象
t = tuple()
t=tuple(range(1,4,1))
t=(1,) #一个元素的元组的定义，要加逗号
t=(1,2,3)*4
索引
正索引，负索引，从0和-1开始，不可超界，会引发异常
tuple[index] ,index是索引，使用中括号
index(value,[start,[stop]]) ,通过value值查找索引号，找到第一个立即返回，匹配不到，抛异常
count(value) ,返回列表中value的个数
index和value都是O(n),随列表数据增大，效率下降
len(tuple) ,返回元素个数，O(1)
元组加元组，返回一个新元组
namedtuple(typename,filed_names,verbose=False,rename=False)
命名元祖，返回一个子类，并定义了字段。
Point = namedtuple('_P','x y') :字段以空格切分，如果有逗号，会换算为空格，全部转换为其中的字符串，这是函数定义的，可以在源代码中看到。
例子：
from collections import namedtuple Student = namedtuple('Student','name age') tom = Student('tom' ,20) jerry = Student('jerry',18) jerry.age
链表
有序，在内存中地址不连续
链表每次查询都需要从头或尾遍历，查询较慢
链表插入，删除数据速度快于列表，但要先进行遍历
链表的插入类似与将手拉手的人断开，再加一个进去与两边握手。
queue 队列
先进先出 FIFO
stack 栈
先进后出FILO