python基本理论

冯诺依曼体系架构
Python解释器：
官方Cpython：C语言开发，最广泛的解释器
IPython：交互式、功能增强的CPython
PyPy：Python编写的Python解释器，JIT技术，动态编译Python代码
Jython：Python的源代码编译成Java的字节码，泡在JVM上
IronPython：与Jyphon类似，运行在.net上的编译器

python是动态语言、强类型语言（不同类型之间操作，必须要先强制类型转换为同一类型）

Python基本语法：
#：注释
数字：
（1）整数，不区分long和int，没有上限了（3.0版本以上）
（2）浮点数：不能表达所有小数（如π）
（3）复数
字符串：
(1)使用单引号、双引号没有区别
（2）三引号（‘’‘，“”“）里面内容可以换行、可以在里面自由的使用单双引号
（3）在字符串前加r或者R前缀，表示该字符串不做特殊处理
转移序列：
\ \t(代表tab键) \r(代表回车) \n(代表换行符) '(代表内容里面的一个引号) "(代表字符串里一个双引号)
标识符：
（1）只能字母、数字、下划线
（2）只能用字符或下划线开头
（3）大小写敏感
（4）不允许使用中文
（5）不允许使用歧义单词（如class_）
（6）不要随便使用下划线开头的标识符
常量：一旦赋值就不能改变值得标识符
python无法定义常量
字面常量：一个单独的量
变量：赋值后，可以改变的标识符

数值型：int、float、complex、bool都是class（类）
int：python3 的int都是长整型，没有大小限制，受限于内存区域的大小
float：有证书部分和小数部分组成，支持十进制和科学计数法表示。只有双精度型（类似double；并不能精确地表示所有的小数，只能无限接近（如π）
complex（复数）：有实数和虚数部分组成，实数和虚数部分都是浮点数，3+4.2J
complex(x), complex(x,y) ：表示x为实数部分3，y表示虚数部分4.2J
bool：int的子类，仅有两个实例：True和False对应1和0，可以和整数直接运算。如：1+True+0.5=2.5

数字的处理函数：
round()：四舍六入，五取偶：1.5->2，2.5->2，3.5->4
floor()
min()
max()
pow(x,y)：等于x**y，x的y次方
math.sqrt()
进制函数，返回值是字符串：
bin()
oct()
hex()

math.pi：π

类型判断：
type(obj):返回类型，而不是字符串
isinstance(obj,class_or_tuple),返回布尔值。判断obj是属于什么类型的。isinstance(6,str)：True

列表list：
一个队列，一个排列整齐有序的队伍，可以使用索引。类似于链表
列表内的个体称为元素，由若干个元素按照顺序组成的列表
元素可以为任意对象（数字、字符串、对象、列表等）
线性的数据结构
使用**[ ]**表示
列表是可变的
初始化（只有以下两种方式）：
list() ->空list
list(iterable) ->里面只能是可迭代的对象：lst = list(range(5)) ->[0,1,2,3,4]
不能一开始就定义大小！
创建空列表： lists1 = [ ] 或者 lists1 = list( )

列表索引访问：
索引 也叫下标
正索引：从左至右，从0开始
负索引：从右至左，从-1开始
正负索引不可以超界，不然会引发异常IndexError
通过 list[index] 访问index索引位置的元素

列表查询：
index(value,[sart,[stop]])：
如：lst = [1,2,3,3,2]：lst.index(2) ->1，lst.index(2,1) ->1 , lst.index(2,2) ->4
括号中第一个是要查找的value值，后面的是开始查询的索引位置
通过value值，从指定区间查找列表内的元素是否匹配
匹配到第一个就立即返回索引
匹配不到，抛出异常ValueError
count(value):返回列表中匹配value的次数
时间复杂度：
index和count方法都是O(n),意思是要把元素全部遍历一遍，遍历n次
随着列表数据规模的增大，而效率下降
高效返回元素个数：
len()：len(lst) ->5

列表元素修改：
list[index] = value
索引不能超界
列表增加、插入元素：
append(object) ->None 尾部追加元素，返回None，意味着没有新的列表产生，就地修改， 如：a=lst.append(10) ->a返回None，lst追加10
时间复杂度是O(1)
insert(index,Object) ->None 在指定位置处插入元素Object，返回None，意味着没有新的列表产生，就地修改
可以超越上下界，超越的就默认是加到头或者尾
时间复杂度是O(1)
extend(iterator)：将可迭代对象的元素追加进来，返回None
如：lst=[1,2,3],lst1=[4,5,6],lst1.extend(lst) ->lst1=[4,5,6,1,2,3]
“+” :连接操作，将两个列表连接起来，产生新的列表，原列表不变
“*”：重复操作，将本列表元素重复n次，返回新的列表

列表删除元素：
clear() ->None
清除列表所有元素，剩下一个空列表
remove(value) ->None
从左至右查找第一个匹配的value值，移除该元素，返回None。就地修改
pop([index]) ->item（索引处或者尾部的值）
不指定索引值，就从列表尾部弹出一个值：lst.pop()
指定索引值，就从索引处弹出一个元素，索引超界则跑出异常IndexError

列表其他操作：
reversed() ->None
将列表元素反转，返回None，就地修改
sort(key=None,reverse=False) ->None
对列表元素进行排序，就地修改，默认升序，如：lst.sort()
reverse为True,反转，降序
key一个函数，指定key如何排序, 如：lst.sort(reverse=True) ->降序输出，lst.sort(key=str,reverse=True) ->lst=[ ‘a’,7,7,8,9,10 ]，按照string类型正序排序输出，将后面的整数根据ASCII码转成string类型

列表复制
1、“=”：指向同一个内存
lst0 = list(range[4])
lst2 = list(range[4])
lst0 == lst2 ->True，内容相等
lst0 is lst2 -> False
lst1 = lst0 ->复制，lst1与lst0都指向同一个内存
lst0 == lst1 ->True
lst1[2] =10 ->lst0=[0,1,10,3],lst1=[0,1,10,3]
lst0 == lst1 ->True
2、“copy”：没有嵌套数据的话拷贝的是内容（如下实例（1）），复杂嵌套数据拷贝的是嵌套外的内容+指向前套内的内存（如下实例（2））
（1）
lst0 = list(range[4])
lst5 = lst0.copy() ->只拷贝了内容，不是指向同一个内存了
lst0 == lst5 ->True，内容相等
lst5[2] = 10
lst0 == lst5 ->False
（2）复杂嵌套结构
lst0 = [1,[2,3,4],5] ->嵌套结构
lst5 = lst0.copy() ->拷贝的是外层的内容+嵌套里的指向的是同一个内存
lst0 == lst5 ->True，内容相等
lst5[2] = 10 ->修改的嵌套外的数据，lst5=[1,[2,3,4],10]，lst0 = [1,[2,3,4],5]
lst0 == lst5 ->False
lst5[2] = 5 ->再改回去
lst0 == lst5 ->True ,内容相等
lst5[1][1] = 20 ->修改的是嵌套里的数据lst5=[1,[2,20,4],5]
lst5 ==lst0 ->True

浅拷贝：也称影子拷贝，遇到引用类型，只是复制了一个引用而已
深拷贝(不常用)：deepcopy()，将引用类型在内存中也重新建立一个。
lst0 = [1,[2,3,4],5] ->嵌套结构
lst5 = lst0.deepcopy() ->拷贝的是外层的内容+内存中也重新建立了一个引用
lst0 == lst5 ->True，内容相等
lst5[1][1] = 20
lst5 ==lst0 ->False

随机数：
random模块
.randint(a,b)：返回[a,b]之间的随机整数（闭区间）
.choice(seq)：从非空集合中随机挑选一个。如：random.choice([1,2,3,4,5]) ->1 2 3 。。。
.rangrange([start],stop,[step])：从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
.shuffle(list) ->None 就地打乱元素