Python基础知识总结

看了一个礼拜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]