看了一个礼拜Python的书，断断续续的看了一大半。今天刚好没有课，想着也没什么事情干，就把这几天Python总结一下，都是一些基础知识
变量和对象的引用
在python中一切都是对象，不像C，java那样，还有基本数据类型（话说其实也是对象），但是他们基本类型的变量的值是放在栈里面的，Python就不同了，他没定义一个变量必须进行三步，首先在堆里面建立一个对象，然后声明一个变量，最后将这个变量指向这个对象。所有的变量定义都必须经历 “=”操着符，当然 你要定义一个glabal变量，是没有必要这样的：eg: global a = "",而且这样还会报错。其他的变量声明必须用 “=”，由于变量的数据的值是存放在堆里面的，所以我们进行这样的操作，实质上是改变了引用而已==>a = 3;b = a; b =1; a == 3 // True，b == 1//True;
del语句，删除一个对象，释放资源；a = 3; del a ; print(a) //异常, a已经不存在
Python的数据类型：
数字类型：int，float ， complex(复数)，bool（0/1）
complex（ai+bj）
序列：str，bytes（字节串），bytearray（字节数组），list（列表），tuple（元组）
映射：dict（字典 ）
集合：set，frozenset（不可变集合）
str定义：
可以用，单引号''，双引号""，和三引号''''''，其中三引号支持多行字符串，包括换行符。
运算符：+，+=，in，not in，*,[],[:]
值得注意的是in ：包括 “as” in “asd” //True
*: as*2 ==> "asas"
[]:a = "asd",a[0] =="a" //True,支持下标为负值 ，a[-1] == d //True
[:]:a = "asd" , a [1:2] == "sd"//True
方法：
ord(单个字符) ：返回编码值；
ord('A') == 65
chr(int) :返回字符：
chr(65) == 'A'
encode("字符集")：返回一个字节串；用指定的字符集编码
a = "asd" ; a.encode("GBK")
decode("字符集")：返回一个字节串；用指定的字符集解码
en（order）：order为序列，查看序列长度，返回一个数字，
a=“asd”, len(a) == 3;
max(order):order为序列，返回一个数字，表示order里面的最大值
zip（order1[，order2][，].....）：返回一个迭代器：item型如 ==》（order1[i],order2[i]....）
eg： a = [1,2,3]
for c in zip(a):
print(c) ===>(1,),(2,),(3,)
enuemrate(order):类似于zip（），返回一个迭代器 。item型如 ==》（下标，数值）
eg：a = [1,2,3]
emuerate(a) == > (0,1),(1,2)(2,3)
str.lower():转化为小写；
str。upper（）转换为大写
str.join(order);将序列转换为字符串：把order用str连接
eg：a = [1，1，3]
"".join(a) == 》 “113”
字节串：
字节串为二进制数据，值得范围是0~255，具有不可变性，数据以B/b开头
eg：b’\xff\x2‘
运算符：
值得注意的是：
/：/运算符的到的结果是浮点数
//：运算符的到的是整数
**：幂运算符，eg：2**3 == 8
<,>,<=,>=,=，可以连用，eg：a>b and b >c 可以表示为 a>b>c,但是很用以混淆逻辑，由于优先级的问题，建议使用and or 连接
python的最多有效位数是15位 ，过了15个有效数字会有问题：
eg：1 < 1 + e-16 不成立
eval（字符串[,映射]）方法：
将字符串转换为数字：可以进行复杂的运算
a = {'X':3,'Y':5}
eval("X*X+Y*Y",a) == 34
函数的定义：
关键字：def；
定义格式：
def <函数名>(参数列表):
<函数体>
eg:
def add(a,b):
return a+ b;
add(1,2) == >3
函数的参数的默认值：
def add（a，b=2）：
return a+b
add(1) == > 3
序列：
序列的特性：可以用过下表访问：
eg：a = list(“asd”)，a[0] == "a"
值比较可以用：<,>,=<+,>=,比较方法是字典序；
eg："a" < "b"//true;"ab" < "b"//true；
可以进行切片操作：
eg：list1 = list（["我爱你Python"]）
list1[2:3] == ['P'] //True list1[1:3] == ['爱' ，‘你’, 'P']
list[::2] == ['我', '你', 'y', 'h', 'n'] //True ,每隔一个，娶一个
llist 是其中的一个序列；
list相关的函数：
list.remove("需要移除的字符串") ， list.pop(下标)
eg: list1 = list("123") , list1.remove("1") ,list1 == ['2' , '3'] //True
list1 = list("123") list1.pop(1)//list ==['2' ,'3'] 弹出一个下标的值 返回弹出的值
可以进行 in not in +=，+，操作
元组：
元组的定义：
a = (a, b ,c .....) 由（）括起来的一个类似数组的对象
元组是不可变对象，可以作字典的建。
创建一个元组:
a = ("123","456")
元组的表现形式为（a，...）;这样是创建不了一个元组的；a = （1），这里的a是一个int类型，要这样创建a = （1，）；
关于python对象的复制：
python对象的复制，浅复制，不保护二级对象，及以二级下对象
这里展示浅复制
eg：a = ['a'，‘b’]
b = [1,2,3,a] a[0]在这里对于b来说是二级对象，不保护
c = b
c[0] = 0
c[3][0] = 0
print(a) ==>[0，‘b’]
要想对二级对象，及二级以下对象进行保护，需要进行深复制
需要引用copy模块
里面有一个deepcopy（）方法
字典：
字典的形式如：{"键":"值",.....}的形式
字典的创建：
1：d1 = {}；//创建一个空字典
2：d1 = {"a"：1，“b”：2，“c”：3}
3：用dict（元组）创建一个字典；
eg：
dict（（[“a”，1]，['b'，2]））
==》{‘a’：1，‘b’：2}
4：用{}.fromkeys（key序列，默认值）
eg：
{}.fromkeys（[‘a’，‘b’，‘c’]，0）
==》{‘a’：0，‘b’：0，‘c’：0}
访问字典的值：dict[‘key’]
dic = {‘a’：1，‘b’：2}
dic[‘a’] == 》1
但是这个访问方式在键不存在的时候肯可能会异常
遍历字典的键值访问，dict.keys()返回一个迭代器
可以 for c in dict.keys()
dict[c]