-
基础
1.r''表示''内部的字符串默认不转义 2.'''...'''表示多行内容 3. 布尔值：True、False（注意大小写） 4.与运算and、或运算：or、非运算：not 5. None代表空值 6.声明一个变量（前面不用声明类型--动态语言）： a = 1;//a是整数 b = 'hello'//b是str(字符串) 7.除法： /: 9/3 = 3.0(计算结果是浮点数) 地板除//: 10/3 = 3(计算结果是整数) 8.ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符 9.对bytes类型的数据用带b前缀的单引号或双引号表示:x = b'ABC' 10.要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes '中文'.encode('utf-8') 得到bytes类型为b'\xe4\xb8\xad\xe6\x96\x87' 从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode() b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')得到str类型为'中文' 11.计算长度len():计算的是str的字符数，如果换成bytes应该这么写len(b'ABC')输出3 len('中文'.encode('utf-8'))输出6，可见一个英文字符占一个字节，一个中文字符占3个字节 12.如果源代码中有中文，则需要在开头加上 # -*- coding: utf-8 -*- 告诉Python解释器按utf-8编码读取，注意：声明了这个并不代表文件本身是utf-8编码的 13.格式化字符串%： 'Hello, %s' % 'world' -----'Hello, world' 'Hi, %s, you have $%d.' % ('Michael', 1000000)-----'Hi, Michael, you have $1000000.' 格式化整数和浮点数还可以指定是否补0和整数与小数的位数： '%2d-%02d' % (3, 1)----' 3-01' '%.2f' % 3.1415926-----'3.14' %015d ----至少15位（不足高位补0） 如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串： 'Age: %s. Gender: %s' % (25, True)----'Age: 25. Gender: True' 字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个% 14.有序列表list(可变)和tuple(不可变) list： s = ['first','second','three']//索引从0开始s[0] //还可以-1做索引代表最后一个s[-1]是three、s[-2]、s[-3] s.append('x') s.insert(1,'x') s.pop()//删除末尾元素 s.pop(1)//删除index为1的元素 s[1]='haha'//替换 list里面的元素的数据类型也可以不同，比如： L = ['Apple', 123, True] [] 是空列表 tuple： ()是空tuple (1)定义的不是tuple而是小括号1这个数 所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：（1,） “可变的”tuple： t = ('a', 'b', ['A', 'B']) t[2][0] = 'X' t[2][1] = 'Y' 15.条件判断： if x://只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False print('True')//注意要缩进 16.int()函数把str转换成整数 17.循环有两种：a.for...in循环 b.while循环 names = ['Michael', 'Bob', 'Tracy'] for name in names: print(name) sum = 0 n = 99 while n > 0: sum = sum + n n = n - 2 print(sum) 18. 字典dict,在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度 d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} d['Michael']//得到 95 避免key不存在的错误，有两种办法， 一是通过in判断key是否存在：'Thomas' in d 二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value： d.get('Thomas') d.get('Thomas', -1) pop(key)//删除 dict的key必须是不可变对象 19. set(无序和无重复元素的集合):set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key s = set([1, 2, 3])//传入的参数[1, 2, 3]是一个list add(key) remove(key) 20.字符串可以通过+相连（和java一样） 21.bin()十进制转二进制，hex()十进制转十六进制，oct()十进制转八进制，0b二进制 0x十六进制 0八进制 22.join()方法： fields = [] fields.append('a') fields.append('b') fields.append('c') fields.append('d') print(" ".join(fields))#输出a b c d print(",".join(fields))#输出a,b,c,d -
函数
1.函数名是指向一个函数对象的引用，可以把函数名赋给一个变量，相当于“别名” eg： a = abs #abs是内置函数取绝对值 a(-1) 2.定义函数: def my_abs(x): #有冒号 if x >= 0: #注意缩进 return x #注意缩进 else: return -x 3.默认参数： def power(x, n=2): power(5)和power(5,2)的结果是一样的 默认参数的坑：L默认是一个空列表，每次调用这个方法L的内容会改变，导致L的内容是改变后的内容 def add_end(L=[]): L.append('END') return L 调用第一次返回['END'] 调用第二次返回['END','END'] ... 解决方法： def add_end(L=None): if L is None: L = [] L.append('END') return L 因为None是不可变对象，所以每次调用只会加一个 调用第一次返回['END'] 调用第二次返回['END'] 4.可变参数（*）:在函数调用时自动组装为一个tuple def calc(*numbers): calc(1,2,3) #调用 如果已经有了一个list或tuple，只需要在前面加*就会当成可变参数 nums = [1, 2, 3] calc(*nums) 5.关键字参数(**):可变参数在函数调用时自动组装为一个dict,是参数的拷贝，改变不会影响参数本身 def person(name, age, **kw): print('name:', name, 'age:', age, 'other:', kw) eg：person('Adam', 45, gender='M', job='Engineer') 输出name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'} 如果已经有了一个dict，只需要在前面加**就会当成关键字参数 extra = {'city': 'Beijing', 'job': 'Engineer'} person('Jack', 24, **extra) 6.命名关键字参数 对于关键字参数，函数的调用者可以传入任意不受限制的关键字参数 如果要限制关键字参数的名字，就可以用命名关键字参数 例如，只接收city和job作为关键字参数,定义如下： def person(name, age, *, city, job): #*后面的参数被视为命名关键字参数 print(name, age, city, job) 此时调用函数时必须传递四个参数，并且最后两个字典的key必须分别是 city和job，否则会报错 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了： def person(name, age, *args, city, job): print(name, age, args, city, job) 命名关键字可以有缺省值： def person(name, age, *, city='Beijing', job): #调用时可以不用传city的字典 7.参数组合 def f1(a, b, c=0, *args, **kw): print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw) 注意 tuple 和 list可以调用 eg： args = (1, 2, 3, 4) kw = {'d': 99, 'x': '#'} f1(*args, **kw) 输出a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'} 8.尾递归 在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况 普通递归： def fact(n): if n==1: return 1 return n * fact(n - 1)#表达式 尾递归： def fact(n): return fact_iter(n, 1) def fact_iter(num, product): if num == 1: return product return fact_iter(num - 1, num * product) #没有表达式，仅返回递归函数本身 -
高级特性
1. 切片（Slice）：取一个list或tuple的部分元素 L[0:3]代表取L的[0,3)，如果第一个索引为0，还可以省略：L[:3] L[1:len(L)]代表L的[1,L的长度)，可以省略为L[1:] L[-1]取倒数第一个元素，L[-2:]代表取后面两个 L[:10:2] 前10个元素 每隔两个取一个 L[::5] 所有元素，每隔五个取一个 对tuple切片得到的结果还是tuple 字符串'xxx'也可以看成是一种list，可以进行切片(类似java中的substring)，eg： 'ABCDEFG'[:3] ->'ABC' 2.迭代（for ... in）：只要是可迭代对象就可以使用这种方式 dict默认是对key迭代，若要对value 则 for value in dict.values(): 若同时对key value迭代则for k, v in d.items() 字符串也是可迭代对象 eg：for ch in 'ABC': 如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断： from collections import Iterable isinstance('abc', Iterable) # str是否可迭代 输出true 对list实现类似Java那样的下标循环： for i, value in enumerate(['A', 'B', 'C']): print(i, value) #输出0 A (","逗号会输出空格) 1 B 2 C 同时遍历两个变量 for x, y in [[1, 1], [2, 4], [3, 9]]: print(x, y) 3.列表生成式（#注意操作在for前面） list(range(1, 11)) 生成 [1,10] [x * x for x in range(1, 11)] 生成[1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 还可以过滤： [x * x for x in range(1, 11) if x % 2 == 0] 生成[4, 16, 36, 64, 100] 两层循环，可以生成全排列： [m + n for m in 'ABC' for n in 'XYZ']生成 ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ'] for循环其实可以同时使用两个甚至多个变量： d = {'x': 'A', 'y': 'B', 'z': 'C' } for k, v in d.items(): print(k, '=', v) 输出：y = B x = A z = C 把一个list中所有的字符串变成小写： L = ['Hello', 'World', 'IBM', 'Apple'] [s.lower() for s in L] #注意操作在for前面 4.生成器(generator):不必创建完整的list，从而节省大量的空间 把一个列表生成式的[]改成()，就创建了一个generator 如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator 每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行,eg定义一个generator，依次返回数字1，3，5： def odd(): yield 1 yield(3) yield(5) for i in odd(): print(i) 输出1 3 5 也可以这样 o = odd() next(o) next(o) next(o) 同样输出1 3 5（到了最后一个元素，再调用next(o)会报错） 5.迭代器（Iterator） 凡是可作用于for循环的对象都是Iterable类型； 凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列； 集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。 Python的for循环本质上就是通过不断调用next()函数实现的 -
函数式编程
1.map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回 2. reduce()和map接收参数一样，把结果继续和序列的下一个元素做累积计算eg：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4) 3.字符串转int(利用 map 和reduce) from functools import reduce def str2int(s): def fn(x, y): return x * 10 + y def char2num(s): return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s] return reduce(fn, map(char2num, s)) 4.filter()筛选和map接收参数一样，返回也是Iterator惰性序列 5.sorted()函数可以对list进行排序，还可以接收一个参数key函数来实现自定义排序eg：按绝对值排序： sorted([36, 5, -12, 9, -21], key=abs) # 输出 [5, 9, -12, -21, 36] 要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True 6.返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量 def count(): fs = [] for i in range(1, 4): def f(): return i*i fs.append(f) return fs f1, f2, f3 = count() #此时f1() f2() f3()的结果都是9，因为引用了同一个变量i ，解决办法： def count(): def f(j): def g(): return j*j return g fs = [] for i in range(1, 4): fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f() return fs 7.匿名函数 def f(x): return x * x 等价于 lambda x: x * x 8.装饰器：在不改变某个函数具体实现的情况下，增加函数的功能 def now(): print('2015-3-25') 需要增加打印函数名的功能： def log(func): @functools.wraps(func)#用于把原始函数的__name__等属性复制到wrapper()函数中，否则调用now.__name__会得到 wrapper def wrapper(*args, **kw): print('call %s():' % func.__name__)#__name__是函数对象内置 return func(*args, **kw) return wrapper 使用@ @log def now(): print('2015-3-25') @log 等价于 now = log(now) 输出：call now(): 2015-3-25 如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数eg： def log(text): def decorator(func): def wrapper(*args, **kw): print('%s %s():' % (text, func.__name__)) return func(*args, **kw) return wrapper return decorator 用法： @log('execute') def now(): print('2015-3-25') 9.偏函数（functools.partial）：把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单 int()函数默认按十进制转换 int('12345', 8)转化8进制到十进制 import functools int2 = functools.partial(int, base=2)#偏函数，转换二进制到10进制 int2('1000000') 相当于kw = { 'base': 2 } int('10010', **kw) max2 = functools.partial(max, 10)#实际上会把10作为*args的一部分自动加到左边，也就是： max2(5, 6, 7)相当于args = (10, 5, 6, 7) max(*args) -
模块
1.一个.py文件就是一个模块 2.if __name__=='__main__': #运行本模块会为True，在其他模块导入这个模块时会为False 3.作用域： 正常的函数和变量名是公开的（public）eg：a、b、c 类似_xxx和__xxx这样的函数或变量就是非公开的（private）eg：_a、__b -
面向对象编程
1.类（class）和实例： class Student(object):#表示Student类继承object def __init__(self, name, score):#第一个参数必须是self,init前后有两个下划线，代表初始化必须传name、score两个参数 self.name = name#public self.__score = score#private 不能直接访问__score是因为Python解释器对外把__score变量改成了_Student__score，所以，仍然可以通过_Student__score来访问__score变量(不建议！！) bart.__score = 20 # 设置__score变量！是给bart新增了一个变量__score 2.type()获取对象的类型 3.类属性（类似java的静态变量） class Student(object): name = 'Student' 4.在类中定义的函数第一个参数永远是实例变量self（self指向创建的实例本身），并且调用时不用传递该参数 5.__init__类似于构造方法，用于创建类时必须传递的参数 6.变量名类似__xxx__的是特殊变量，特殊变量是可以直接访问的，不是private变量 7.dir()获得一个对象的所有属性和方法 8.类似__xxx__的属性和方法在Python中都是有特殊用途的，调用len()函数试图获取一个对象的长度，实际上，在len()函数内部，它自动去调用该对象的__len__() eg： len('ABC') == 'ABC'.__len__() 我们自己写的类，如果也想用len(myObj)的话，就自己写一个__len__()方法 9.给实例绑定属性的方法是通过实例变量，或者通过self变量 10.给类动态绑定方法： def set_age(self, age): # 定义一个函数作为实例方法 self.age = age from types import MethodType s.set_age = MethodType(set_age, s) # 给实例绑定一个方法 s.set_age(25) # 调用实例方法 s.age # 测试结果 输出25 但是，给一个实例绑定的方法，对另一个实例是不起作用的，解决方法给class绑定： def set_score(self, score): self.score = score Student.set_score = set_score -
面向对象高级编程
1.动态绑定允许我们在程序运行的过程中动态给class加上功能： def set_score(self, score): self.score = score Student.set_score = set_score #动态绑定方法 s = Student() s.set_score(100) s.score 2.__slots__限制实例可绑定的属性（仅对当前类实例起作用，对继承的子类不起作用） class Student(object): __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称 s = Student() # 创建新的实例 s.name = 'Michael' # 绑定属性'name' s.age = 25 # 绑定属性'age' s.score = 99 # 绑定属性'score'会报错 3.多继承 class Dog(Mammal, Runnable): 4.__str__ 类似java 的toString方法 class Student(object): def __init__(self, name): self.name = name def __str__(self): return 'Student object (name: %s)' % self.name 使用：print(Student('Michael')) 输出 Student object (name: Michael) 直接显示变量调用的不是__str__()，而是__repr__()(可以令__repr__ = __str__) 5.__iter__ 使一个类可用于for ... in循环 class Fib(object): def __init__(self): self.a, self.b = 0, 1 # 初始化两个计数器a，b def __iter__(self): return self # 实例本身就是迭代对象，故返回自己 def __next__(self): self.a, self.b = self.b, self.a + self.b # 计算下一个值 if self.a > 100000: # 退出循环的条件 raise StopIteration() return self.a # 返回下一个值 6.__getitem__使一个类可按照下标取出元素 7.__getattr__使可以访问一个非类的属性 class Student(object): def __init__(self): self.name = 'Michael' def __getattr__(self, attr): if attr=='score': return 99 Student().score 实例：链式调用 class Chain(object): def __init__(self, path=''): self._path = path def __getattr__(self, path): return Chain('%s/%s' % (self._path, path)) def __str__(self): return self._path __repr__ = __str__ Chain().status.user.timeline.list #输出：'/status/user/timeline/list' 8.__call__ 使得对象方便的调用方法 class Student(object): def __init__(self, name): self.name = name def __call__(self): print('My name is %s.' % self.name) 调用：s = Student('neo') s() #输出My name is neo 所以你完全可以把对象看成函数，把函数看成对象 通过callable()函数，我们就可以判断一个对象是否是“可调用”对象. 9.枚举 from enum import Enum Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')) 直接使用Month.Jan来引用一个常量，枚举它的所有成员： for name, member in Month.__members__.items(): print(name, '=>', member, ',', member.value) 10.type()函数既可以返回一个对象的类型，又可以创建出新的类型 返回类型： from hello import Hello h = Hello() h.hello()#Hello, world. print(type(Hello))#<class 'type'> Hello是一个class，它的类型就是type print(type(h))#<class 'hello.Hello'> h是一个实例，它的类型就是hello.py模块下的 Hello类 创建类型： def fn(self, name='world'): # 先定义函数 print('Hello, %s.' % name) Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class h = Hello() h.hello()#Hello, world. print(type(Hello))#<class 'type'> print(type(h))#<class '__main__.Hello'> # __main__模块的Hello类 type()函数参数： 1.class的名称； 2.继承的父类集合，注意Python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法； 3.class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上。 11.元类metaclass（可以把类看成是metaclass创建出来的“实例”） # metaclass是类的模板，所以必须从`type`类型派生： class ListMetaclass(type): def __new__(cls, name, bases, attrs): attrs['add'] = lambda self, value: self.append(value) return type.__new__(cls, name, bases, attrs) class MyList(list, metaclass=ListMetaclass):#说明Python创建MyList会去调用元类ListMetaclass的__new__方法 pass L = MyList() L.add(1) print(L)#输出[1] __new__()方法接收到的参数依次是： 1.当前准备创建的类的对象； 2.类的名字； 3.类继承的父类集合； 4.类的方法集合。 12.使用@property：@property装饰器就是负责把一个方法变成属性调用。 class Student(object): @property def birth(self): return self._birth#下划线开头的变量名是可以外部直接方法的（但是不建议这么做） @birth.setter #@property内部创建的:方法名.setter def birth(self, value): self._birth = value @property def age(self): return 2015 - self._birth birth是可读写属性，而age就是一个只读属性 s = Student() s.birth = 12#等同于s.birth(12) .方法名 s.birth #等同于s.birth() 13.python可以多继承 -
错误、调试、测试
1. try: print('try...') r = 10 / int('2') print('result:', r) except ValueError as e: print('ValueError:', e) except ZeroDivisionError as e: print('ZeroDivisionError:', e) else: print('no error!') finally: print('finally...') 2. raise类似java的throw logging类似Log 3. pdb命令行方式进行调试 -
IO编程
1.文本文件（默认utf-8） try: f = open('/Users/neo/fps.txt', 'r',encoding='gbk')#'r'表示读 print(f.read()) finally: if f: f.close()#及时关闭 等价于 with open('/Users/neo/fps.txt', 'r') as f: print(f.read())#不用close read()一次性读取全部内部到内存有危险，可反复调用read(size)方法 2.二进制文件 f = open('/Users/michael/test.jpg', 'rb') 3. StringIO:在内存中读写str from io import StringIO f = StringIO() f.write('hello') f.write(' ') f.write('world!') print(f.getvalue())#输出hello world! from io import StringIO f = StringIO('Hello!\nHi!\nGoodbye!') while True: s = f.readline() if s == '': break print(s.strip())#输出Hello! Hi! Goodbye! 4.BytesIO：用法和StringIO类似，是内存中读写字节 5.import os os.path.abspath('.')# 查看当前目录的绝对路径: os.path.join('/Users/neo', 'testdir')# 在某个目录下创建一个新目录，首先把新目录的完整路径表示出来: os.mkdir('/Users/neo/testdir')# 然后创建一个目录: os.rmdir('/Users/neo/testdir')# 删掉一个目录: os.rename('test.txt', 'test.py')# 对文件重命名: os.remove('test.py')# 删掉文件: 5.列出所有的.py文件 [x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py'] 6. pickling序列化（利用pickle模块） 对象到JSON格式的转换（json模块） import json d = dict(name='Bob', age=20, score=88) print(json.dumps(d))#输出{"name": "Bob", "age": 20, "score": 88} JSON转为对象 import json json_str = '{"age": 20, "score": 88, "name": "Bob"}' persion = json.loads(json_str) print(persion['age'])#输出20 7.json模块序列化类 import json class Student(object): def __init__(self, name, age, score): self.name = name self.age = age self.score = score def student2dict(std): return { 'name': std.name, 'age': std.age, 'score': std.score} s = Student('Bob', 20, 88) print(json.dumps(s,default=student2dict)) print(json.dumps(s, default=lambda obj: obj.__dict__))#把任意class的实例变为dict 反序列化： import json class Student(object): def __init__(self, name, age, score): self.name = name self.age = age self.score = score def dict2student(d): return Student(d['name'], d['age'], d['score']) json_str = '{"age": 20, "score": 88, "name": "Bob"}' print(json.loads(json_str, object_hook=dict2student)) -
进程和线程
1.Unix/Linux操作系统提供了一个fork()系统调用，它非常特殊。普通的函数调用，调用一次，返回一次， 但是fork()调用一次，返回两次，因为操作系统自动把当前进程（称为父进程）复制了一份（称为子进程），然后，分别在父进程(返回子进程id)和子进程（返回0）内返回 import os print('Process (%s) start...' % os.getpid()) # Only works on Unix/Linux/Mac: pid = os.fork() if pid == 0: print('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid())) else: print('I (%s) just created a child process (%s).' % (os.getpid(), pid)) 输出Process (1812) start... I (1812) just created a child process (1813). I am child process (1813) and my parent is 1812. 2.Windows没有fork，可使用multiprocessing模块 from multiprocessing import Process import os # 子进程要执行的代码 def run_proc(name): print('Run child process %s (%s)...' % (name, os.getpid())) if __name__=='__main__': print('Parent process %s.' % os.getpid()) p = Process(target=run_proc, args=('test',)) print('Child process will start.') p.start() p.join()#等待子进程结束后再继续往下运行 print('Child process end.') 3.多线程（使用threading模块） import time, threading # 新线程执行的代码: def loop(): print('thread %s is running...' % threading.current_thread().name) n = 0 while n < 5: n = n + 1 print('thread %s >>> %s' % (threading.current_thread().name, n)) time.sleep(1) print('thread %s ended.' % threading.current_thread().name) print('thread %s is running...' % threading.current_thread().name) t = threading.Thread(target=loop, name='LoopThread') t.start() t.join()#主线程等待子线程执行完毕 print('thread %s ended.' % threading.current_thread().name) 4.锁：lock = threading.Lock() lock.acquire()#获取锁 lock.release()#一定要手动释放锁 5.Python解释器由于设计时有GIL全局锁，任何Python线程执行前，必须先获得GIL锁，然后，每执行100条字节码， 解释器就自动释放GIL锁，让别的线程有机会执行，导致了多线程无法利用多核（可以使用多进程） 6. ThreadLocal import threading # 创建全局ThreadLocal对象: local_school = threading.local() def process_student(): # 获取当前线程关联的student: std = local_school.student print('Hello, %s (in %s)' % (std, threading.current_thread().name)) def process_thread(name): # 绑定ThreadLocal的student: local_school.student = name process_student() t1 = threading.Thread(target= process_thread, args=('Alice',), name='Thread-A') t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B') t1.start() t2.start() t1.join() t2.join() 输出Hello, Alice (in Thread-A) Hello, Bob (in Thread-B) -
正则表达式
1. \d：匹配一个数字 \w：匹配一个字母或数字 \s：匹配一个空格（也包括Tab等空白符） 2.匹配变长的字符： *表示任意个字符（包括0个） +表示至少一个字符 ?表示0个或1个字符 {n}表示n个字符，用{n,m}表示n-m个字符 3.需要转义的字符： _ ：\_ 4.表示范围：[] [0-9a-zA-Z\_]可以匹配一个数字、字母或者下划线 [0-9a-zA-Z\_]+可以匹配至少由一个数字、字母或者下划线组成的字符串，比如'1','a100'，'0_Z'，'Py3000'等等 5.^表示行的开头，^\d表示必须以数字开头。 $表示行的结束，\d$表示必须以数字结束。 6.re模块 判断是否匹配： import re if re.match(r'^\d{3}\-\d{3,8}$', '010-12345'): print('yes') else: print('no') 输出yes �切分字符串： -
网络编程
1.网络通信其实就是两个进程通信 2.如果一台计算机同时接入到两个或更多的网络，比如路由器，它就会有两个或多个IP地址，所以，IP地址对应的实际上是计算机的网络接口，通常是网卡 3.IP地址实际上是一个32位整数（称为IPv4），以字符串表示的IP地址如192.168.0.1实际上是把32位整数按8位分组后的数字表示，目的是便于阅读 4.IPv6地址实际上是一个128位整数 5.IP协议负责把数据从一台计算机通过网络发送到另一台计算机 6.TCP协议则是建立在IP协议之上的。TCP协议负责在两台计算机之间建立可靠连接，保证数据包按顺序到达。TCP协议会通过握手建立连接，然后，对每个IP包编号，确保对方按顺序收到，如果包丢掉了，就自动重发 7.HTTP协议基于TCP协议 8.端口的作用:同一台计算机上跑着多个网络程序。一个IP包来了之后，到底是交给浏览器还是QQ，就需要端口号来区分 9、端口号小于1024的是Internet标准服务的端口，端口号大于1024的，可以任意使用 10.UDP协议时，不需要建立连接，只需要知道对方的IP地址和端口号，就可以直接发数据包，不可靠、速度快 -
电子邮件
1.Email从MUA(Mail User Agent--电子邮件软件)发出去，发到发件人邮箱所属的MTA：Mail Transfer Agent——邮件传输代理（Email服务提供商）， 从发件人所属的MTA发送到目标邮件地址所属的MTA（这个过程中间可能还会经过别的MTA）， 目标地址所属的MTA会把邮件发送到最终目的地MDA：Mail Delivery Agent——邮件投递代理，Email到达MDA后，就静静地躺在目标服务器，等待MUA从MDA中取邮件 2.发邮件时，MUA和MTA使用的协议就是SMTP 3.收邮件时，MUA和MDA使用的协议有两种：POP3、IMAP4 4.MUA在发邮件时，要先配置SMTP服务器，也就是你要发到哪个MTA上 假设你正在使用163的邮箱，你就不能直接发到新浪的MTA上，因为它只服务新浪的用户， 所以，你得填163提供的SMTP服务器地址：smtp.163.com，为了证明你是163的用户，SMTP服务器还要求你填写邮箱地址和邮箱口令 类似的，从MDA收邮件时，Outlook之类的邮件客户端会要求你填写POP3或IMAP服务器地址、邮箱地址和口令 from email.mime.text import MIMEText msg = MIMEText('hello, send by Python...', 'plain', 'utf-8') # 输入Email地址和口令: from_addr = '755766986@qq.com' password = 'iwfcltqyzjbpbbjj' # 输入收件人地址: to_addr = '578179809@qq.com' # 输入SMTP服务器地址: smtp_server = 'smtp.qq.com' import smtplib server = smtplib.SMTP(smtp_server, 587) # SMTP协议默认端口是25 server.set_debuglevel(1) server.starttls() server.login(from_addr, password) server.sendmail(from_addr, [to_addr], msg.as_string()) server.quit() -
访问数据库
# -*- coding: utf-8 -*- # 导入MySQL驱动: import mysql.connector # 注意把password设为你的root口令: conn = mysql.connector.connect(user='root', password='zq112hf', database='test') cursor = conn.cursor() # 创建user表: cursor.execute('create table IF NOT EXISTS user (id varchar(20) primary key, name varchar(20))') # 插入一行记录，注意MySQL的占位符是%s: cursor.execute('insert into user (id, name) values (%s, %s)', ['2', 'Michael']) print('cursor.rowcount = %d'%cursor.rowcount) # 提交事务: conn.commit() cursor.close() # 运行查询: cursor = conn.cursor() cursor.execute('select * from user where id = %s', ('2',)) values = cursor.fetchall() print(values) # 关闭Cursor和Connection: cursor.close() conn.close() Web开发
1.Python内置了一个WSGI（Web Server Gateway Interface）服务器：wsgiref模块，效率比较低，仅供开发和测试使用
# server.py
# 从wsgiref模块导入:
from wsgiref.simple_server import make_server
# 导入我们自己编写的application函数:
from hello import application
# 创建一个服务器，IP地址为空，端口是8000，处理函数是application:
httpd = make_server('', 8000, application)
print('Serving HTTP on port 8000...')
# 开始监听HTTP请求:
httpd.serve_forever()
# hello.py
def application(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
return [b'<h1>Hello, web!</h1>']
运行server.py来启动WSGI服务器
2.Web框架-Flask。每个请求对于一个方法
from flask import Flask
from flask import request
app = Flask(__name__)
@app.route('/', methods=['GET', 'POST'])
def home():
return '<h1>Home</h1>'
@app.route('/signin', methods=['GET'])
def signin_form():
return '''<form action="/signin" method="post">
<p><input name="username"></p>
<p><input name="password" type="password"></p>
<p><button type="submit">Sign In</button></p>
</form>'''
@app.route('/signin', methods=['POST'])
def signin():
# 需要从request对象读取表单内容：
if request.form['username']=='admin' and request.form['password']=='password':
return '<h3>Hello, admin!</h3>'
return '<h3>Bad username or password.</h3>'
if __name__ == '__main__':
app.run()
3. 使用模板
在Jinja2模板中：
{{ name }}：需要替换的变量
{% ... %}：指令
- 异步IO
1.异步IO模型需要一个消息循环，在消息循环中，主线程不断地重复“读取消息-处理消息”过程
当遇到IO操作时，代码只负责发出IO请求，不等待IO结果，然后直接结束本轮消息处理，进入下一轮消息处理过程。
当IO操作完成后，将收到一条“IO完成”的消息，处理该消息时就可以直接获取IO操作结果
2.协程：一个线程执行，效率高（子程序切换不是线程切换、不需要锁）
协程通过generator实现（包含yield关键字的方法就是一个generator，不知道这样理解对不对）
def consumer():#generator
r = ''
while True:
n = yield r
if not n:
return
print('[CONSUMER] Consuming %s...' % n)
r = '200 OK'
def produce(c):#参数是一个generator
c.send(None)
n = 0
while n < 5:
n = n + 1
print('[PRODUCER] Producing %s...' % n)
x = c.send(n)
print('[PRODUCER] Consumer return: %s' % x)
c.close()
c = consumer()#把generator赋值给变量c
produce(c)
执行过程：
1.首先调用c.send(None)启动生成器（generator）；
2.然后，一旦生产了东西，通过c.send(n)切换到consumer执行；
3.consumer通过yield拿到消息，处理，又通过yield把结果传回（就是给consumer()的r赋值）；
4.produce拿到consumer处理的结果（上面的x），继续生产下一条消息；
5.produce决定不生产了，通过c.close()关闭consumer，整个过程结束
3. asyncio内置了对异步IO的支持（消息循环）
import asyncio
@asyncio.coroutine#标记为coroutine
def hello():
print("Hello world!")
# 异步调用asyncio.sleep(1):
r = yield from asyncio.sleep(1)#执行到这里会直接中断并去执行EventLoop中其他可以执行的coroutine
#过了1秒返回一个None（r = None），CPU再来执行后面的代码
print("Hello again!")
# 获取EventLoop:
loop = asyncio.get_event_loop()
# 执行coroutine
loop.run_until_complete(hello())#把协程放到消息队列里执行,如果有多个使用wait：asyncio.wait([hello(),A(),B()])
loop.close()#记得关闭循环
4.Python 3.5开始
@asyncio.coroutine = async
yield from = await
5. aiohttp则是基于asyncio实现的HTTP框架
import asyncio
from aiohttp import web
async def index(request):
await asyncio.sleep(0.5)
return web.Response(body=b'<h1>Index</h1>')
async def hello(request):
await asyncio.sleep(0.5)
text = '<h1>hello, %s!</h1>' % request.match_info['name']
return web.Response(body=text.encode('utf-8'))
async def init(loop):
app = web.Application(loop=loop)
app.router.add_route('GET', '/', index)
app.router.add_route('GET', '/hello/{name}', hello)
srv = await loop.create_server(app.make_handler(), '127.0.0.1', 8000)
print('Server started at http://127.0.0.1:8000...')
return srv
loop = asyncio.get_event_loop()
loop.run_until_complete(init(loop))
loop.run_forever()
- 其他
1.with关键字的用法：
with expression as variable:
with block
该代码快的执行过程是： 1.先执行expression，然后执行该表达式返回的对象实例的__enter__函数，然后将该函数的返回值赋给as后面的变量。(注意，是将__enter__函数的返回值(返回expression的值)赋给变量)
2.然后执行with block代码块，不论成功，错误，异常，在with block执行结束后，会执行第一步中的实例的__exit__函数。)
2.