内置数据结构
帮助：
手册中找关键字；
help(keyword)，keyword可以是变量、对象、类名、函数名、方法名；
分类：
数值型：int,float,complex,bool；
sequence序列对象：str,list,tuple；
键值对：set集合（约定set为集，collection为集合类型），dict字典；
数值型：
int,float,complex,book都是class，1,5,0,2+3j都是对象（即实例）；
int，python3的int就是长整型，且没有大小限制（没有上限，指进程寻址的大内存区域），受制于内存区域的大小；
float，由整数部分和小数部分组成，支持十进制和科学计数法表示，只有双精度型，通常浮点数比较时用<,>，不能用==（注：浮点数并不能完全准确的表达我们指定的小数，只能说近似表达）；
complex，复数，由实数部分和虚数部分组成，实数部分和虚数部分都是浮点数，如3+4.2j；
bool，int的子类（类似哺乳类下的人类），仅有2个实例True（对应1），False（对应0），可以和整数直接运算；
类型转换：
int(x)，返回一个整数；
float(x)，返回一个浮点数；
complex(x)，complex(x,y)，返回一个复数；
bool(x)，返回布尔值；
数字的处理函数：
round()，不是四舍五入，是四舍六入五取偶，银行家算法，其它语言的round()也一样；
math.floor()，地板，向下取整；
math.ceil()，天花板，向上取整； #django.core.paginator.Paginator中Paginator.num_pages用到
int()，取整数部分，和//整除一样；
min()；
max()；
pow()，等于x**6；
math.sqrt()，开平方；
bin()，进制函数，返回值是字符串；
oct()，进制函数，返回值是字符串；
hex()，进制函数，返回值是字符串；
math.pi，取PI；
math.e，自如常数；
例：
In [1]: round(1.4)
Out[1]: 1
In [2]: round(1.5)
Out[2]: 2
In [3]: round(1.6)
Out[3]: 2
In [4]: round(2.6)
Out[4]: 3
In [5]: round(2.5) #四舍六入五取偶
Out[5]: 2
In [6]: import math
In [7]: math.floor(2.5)
Out[7]: 2
In [8]: math.ceil(2.5)
Out[8]: 3
类型判断：
type(obj)，返回类型，而不是字符串；
isinstance(obj,class_or_tuple)，返回布尔值；
例：
In [9]: a=1
In [10]: type(a)
Out[10]: int
In [11]: type(type(a))
Out[11]: type
In [12]: type(a)==int
Out[12]: True
In [13]: isinstance(a,int) #类继承时使用
Out[13]: True
In [14]: type(1+True)
Out[14]: int
In [15]: type(1+True+2.0) #有隐式转换，int和float都是数值型，可理解为这俩是表亲；
Out[15]: float
list：
一个队列，一个排列整齐的队伍（有序）；
列表内的个体称作元素（item或element），由若干元素组成列表；
元素可以是任意对象（数字、字符串、对象、列表）；
列表内元素有顺序，可以使用索引；
线性的数据结构；
使用[]表示；
列表是可变的；
list列表、链表、queue队列、stack栈的差异：
list，有序的整齐排列；
链表（元素手拉手在一起，不是网状，在内存中零散的存放，不能用索引）；
queue（先进先出或后进先出，可用list模拟queue）；
stack（压栈，后进先出，撂盘子）；
注：
赋值即定义（动态语言与静态语言的差别）；
list定义，初始化：
list()，new empty list；
list(iterable)，new list initialized from iterable's item，如lst=list(5)不可以，必须是可迭代对象，list()里要么放可迭代对象，要么什么都不放；
列表不能一开始就定义大小；
例：
In [16]: lst=list() #工厂方法定义
In [17]: lst=[]
In [18]: lst=[2,6,9,'ab',None] #通常用此种，定义和初始化一起搞
In [19]: lst=list(range(5))
In [21]: lst
Out[21]: [0, 1, 2, 3, 4]
In [22]: _ #仅在ipython中使用此变量，返回上一次输出
Out[22]: [0, 1, 2, 3, 4]
list索引访问：
索引也叫下标，列表通过索引访问，list[index]，使用[]访问；
正索引，从左至右，从0开始，为列表中的第一个元素编号；
负索引，从右至左，从-1开始；
正负索引不可以超界，否则引发异常IndexError；
为理解方便，可认为列表是从左至右排列的，左边是头部，右边是尾部，左边是下界，右边是上界；
list查询：
index(value,[start,[stop]])，通过value，从指定区间查找列表内的元素是否匹配；匹配第一个就立即返回索引；从左至右，从右至左，返回的索引值是不一样的，通常从右至左找更快更便利，如在给定路径中找文件名；匹配不到，抛出异常ValueError；
count(value)，返回列表中匹配value的次数；
时间复杂度：
O(1)，性能最好；
O(n),O(n**2)，随着列表数据规模的增大而效率下降；
index()和count()都是O(n)；
如何返回列表元素的个数？如何遍历？如何设计高效？len(lst)，len()是公共内置函数，O(1)，增删list元素时记录着该list的类似元数据信息；
空间复杂度：生产中，尤其是vm中要考虑；
list元素修改：
lst[index]=value，索引访问修改，索引不要超界；
list增加插入元素：
append(object)-->None，列表尾部追加元素，返回None；返回None就意味着没有新的list产生，就地修改；时间复杂度O(1)；
insert(index,object)-->None，在指定的index处插入元素object；返回None，就地修改；时间复杂度O(1)，该方法少用，若在头部或中间插入，整个内存中的元素需移动；
索引能超上下界吗？超越上界，尾部追加，超越下界，头部追加；
extend(iterable)-->None，将可迭代的元素追加进来，返回None，就地修改；
+-->list，连接操作，将两个list连接起来，产生新的list，原list不变；本质上调用的是__add__()方法；
*-->list，重复操作，将本list元素重复n次，返回新的list；
注：
返回若不是None，将有特殊的编程方式；
list不适用insert元素，头或中间插入时需要挪动，链表适合insert；
list删除元素：
remove(value)-->None，从左至右查找第一个匹配value的值，移除该元素返回None，就地修改；效率？不高；
pop([index])-->item，若不指定index就从list尾部弹出一个元素；指定index，就从索引处弹出指定元素；索引超界，抛出IndexError；效率？移除尾部元素效率高，不是尾部不要用；指定索引的时间复杂度？不指定索引的时间复杂度？
clear()-->None，清除列表的元素，剩下一个空列表；元素量大时会引起GC；
list其它操作：
reverse()-->None，将列表元素反转，返回None，就地修改，少用；
sort(key=None,reverse=False)-->None，对列表元素进行排序，就地修改，默认升序，少用；reverse为True，反转，降序；key（高阶函数）指定一个函数，用于自定义排序；
in，not in，返回bool型；
例：
In [23]: lst=[1,2,3,4]
In [24]: lst.sort(reverse=True) #注意关键字参数，就地修改
In [25]: lst
Out[25]: [4, 3, 2, 1]
In [26]: lst.append('a')
In [27]: lst.sort(key=str) #把每个元素都转为str，按ASCII码排序
In [28]: lst
Out[28]: [1, 2, 3, 4, 'a']
In [29]: lst.sort(key=str,reverse=True)
In [30]: lst
Out[30]: ['a', 4, 3, 2, 1]
列表复制（深浅拷贝）：
在构造嵌套结构的列表时要注意；
==是值比较，内容是否相同；
is是比较内存地址，相当于先取id()再比较；
copy()-->list，shadow copy，影子拷贝，浅拷贝，返回一个新列表，遇到引用类型，只是复制了一个引用，列表如果有嵌套则拷贝的是嵌套列表的内存地址，内层相当于在引用；
深拷贝，copy模块提供了deepcopy()，copy.deepcopy()；
例：
In [35]: lst0=list(range(4))
In [36]: lst1=list(range(4))
In [37]: lst0==lst1 #但lst[0] is lst[1]结果为False
Out[37]: True
In [38]: lst2=lst0
In [39]: lst2[2]=10
In [42]: lst2==lst1
Out[42]: False
In [44]: lst0
Out[44]: [0, 1, 10, 3]
In [45]: lst1
Out[45]: [0, 1, 2, 3]
In [46]: lst2
Out[46]: [0, 1, 10, 3]
In [47]: id(lst0) #lst2引用lst0，这俩指向同一个内存地址
Out[47]: 139655179771656
In [48]: id(lst2)
Out[48]: 139655179771656
例：
In [50]: lst3=list(range(4))
In [51]: lst4=lst3.copy()
In [52]: lst3==lst4
Out[52]: True
In [53]: lst3 is lst4
Out[53]: False
In [54]: lst3[2]=10
In [55]: lst3==lst4
Out[55]: False
例：
In [71]: lst5=[1,[2,3,4],5]
In [72]: lst6=lst5.copy()
In [73]: lst5==lst6
Out[73]: True
In [74]: lst5[1][1]=8
In [75]: lst5==lst6 #注意，返回True，lst6是lst5的拷贝，对于嵌套结构只copy()了引用
Out[75]: True
In [76]: lst5 is lst6
Out[76]: False
In [77]: lst5
Out[77]: [1, [2, 8, 4], 5]
In [78]: lst6
Out[78]: [1, [2, 8, 4], 5]
例：
In [1]: import copy
In [2]: lst0=[1,[2,3,4],5]
In [3]: lst1=copy.deepcopy(lst0)
In [4]: lst1[1][1]=8
In [5]: lst0==lst1
Out[5]: False
In [6]: lst0 is lst1
Out[6]: False
随机数：
random模块；
random.randint(a,b)，返回[a,b]之间的整数，两边都是闭区间（不同于range(a,b)，[a,b)前包后不包）；
random.choice(seq)，从非空序列的元素中随机挑选一个元素，如random.choice(range(10))，从0-9中挑选一个整数，random.choice([1,3,5,7])；
random.randrange([start,]stop[,step])，同range()，从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1，如random.randrange(1,7,2)，返回1,3,5中的一个；
random.shuffle(list)-->None，就地打乱列表元素；
测试效率：
#作性能测试时把print()语句注释掉，否则影响较大；
import datetime
start = datetime.datetime.now()
code segment
stop = datetime.datetime.now()
delta =(stop-start).total_seconds()
print(delta)
另外有需要云服务器可以了解下创新互联cdcxhl.cn，海内外云服务器15元起步，三天无理由+7*72小时售后在线，公司持有idc许可证，提供“云服务器、裸金属服务器、高防服务器、香港服务器、美国服务器、虚拟主机、免备案服务器”等云主机租用服务以及企业上云的综合解决方案，具有“安全稳定、简单易用、服务可用性高、性价比高”等特点与优势，专为企业上云打造定制，能够满足用户丰富、多元化的应用场景需求。