一、 python基础
1. 字符串
### 斜杠转义 和 r 不转义 # 可以转义很多字符， 表示换行， 表示制表符，\表示 # print('\ \') # \ \ print(r'\ \') # hello, # world print(r'''hello, world''') ### 字符串的修改 a.replace('A', 'a') ### 计算分数增长百分比 s1 = 72 s2 = 85 r = (s2 - s1) / s1 * 100 print('%.1f%%' % r) >>> 18.1% ### 字符串连接 'Jim' + 'Green' = 'JimGreen' '%s, %s' % ('Jim', 'Green') = 'Jim, Green' var_list = ['tom', 'david', 'john'] a = '###' a.join(var_list) = 'tom###david###john'
2. 变量（字符串、列表）
#### 字符串变量 a = 'ABC' b = a b = 'XYZ' print (a) # >>> ABC # 在内存中创建了一个'ABC'的字符串； # 在内存中创建了一个名为a的变量，并把它指向'ABC'。 #### 列表变量 a = [1, 2, 3] b = a # 和java数组一样 b[0] = 9 print (a) # >>> [9, 2, 3] # 将b指向了与a的同一个列表。b与a共同指向一个列表“实例”
3. list增删改
#### 列表的增加删除 ## 增加 append insert classmates = ['Michael', 'Bob', 'Tracy'] classmates.append('Adam') classmates.insert(1, 'Jack') ## 删除 pop # 删除list末尾的元素，用pop()方法 # 删除指定位置的元素，用pop(i)方法 classmates.pop() classmates.pop(1)
# 清空列表
classmates.clear() ## 修改 #某个元素替换成别的元素，可以直接赋值给对应的索引位置 classmates[1] = 'Sarah' #### 下标循环 enumerate # >>> 0 A # >>> 1 B # >>> 2 C for i, value in enumerate(['A', 'B', 'C']): print(i, value) ## 超出列表长度 list = [1, 2, 3] print (list[4:]) >>> []
4. tuple
#### 元祖 # 定义一个空的tuple t = () # 定义一个只有1个元素的tuple t = (1) # 定义的不是tuple，是1这个数 t = (1,) # 元祖的修改 # 变的不是tuple的元素，而是list的元素。 # tuple一开始指向的list并没有改成别的list # 指向'a'，就不能改成指向'b'， # 指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的 t = ('a', 'b', ['A', 'B']) t[2][0] = 'X' t[2][1] = 'Y' print (t) # >>> ('a', 'b', ['X', 'Y'])
5. 字典dict增删改查
dic_t = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
#### 增加
dic_t ['blithe'] = 100
print (dic_t ['blithe'])
# >>> 100
dic_t ['blithe'] = 90
print (dic_t ['blithe'])
# >>> 90 会直接修改之前key值的value
#### 条件判断 查找 in 和 get()
# 判断key值是否在字典中
>>> 'Thomas' in dic_t
>>> False
# 通过dict提供的get()方法，
# 如果key不存在，可以返回None，或者自己指定的value
dic_t .get('Thomas') # >>>None
dic_t .get('Thomas', -1) # >>> -1
#### 删除 pop(), del, clear()
# pop 删除字典给定键 key 所对应的值，
# 返回值为被删除的值
dic_t .pop('Bob')
# del 能删单一的元素也能清空字典，
# 清空只需一项操作
del dic_t ['Bob']
del dic_t
# clear 删除字典内所有元素
dic_t .clear() # dic_t = {}
# popitem 随机删除字典中的一对键值 并 随机返回还存在的值
dic_t .popitem()
#### 字典不存在的key值
dict = { 'a': 1, 'b': 2 }
print (dict['c'])
>>> KeyError: 'c'
#### 生成空字典的方法
d = {}
d = dict()
d.update([('svk', 'Bratislava'), ('deu', 'Berlin'), ('dnk', 'Copenhagen')])
#### 字典遍历 d = {'a': 1, 'b':2, 'c': 3} for key in d: print (key) for value in d.values(): print (value) for k, v in d.items(): print (k, v) #### zip字典生成 def create_dict(lista, listb): # print (create_dict(['a', 'b', 'c'], [2, 3, 4])) # >>>{'a': 2, 'b': 3, 'c': 4} if not isinstance(lista, list): return ("lista is not list") elif not isinstance(listb, list): return ("listb is not list") else: new_dict = {} if len(lista) == len(listb): new_dict = dict( zip( lista, listb) ) return new_dict #### formkey字典生成 # >>>{0: 'x', 1: 'x', 2: 'x'} dic = dict.fromkeys(range(3), 'x') #### 二元组列表创建 # >>>{'bar': 3, 'egg': 2, 'spam': 1} list = [('spam', 1), ('egg', 2), ('bar', 3)] dic = dict(list)
6. 集合（set）
#### set的增删 # set和dict类似，也是一组key的集合，但不存储value。 # 由于key不能重复，所以，在set中，没有重复的key ### 创建 # 创建一个set，需要提供一个list作为输入集合 # 重复元素在set中自动被过滤 s = set([1, 1, 2, 2, 3, 3]) # >>> {1, 2, 3} ### 增加 add # 可以重复添加，但不会有效果 s.add(4) s.add(4) # >>> {1, 2, 3, 4} ### 删除 remove s.remove(4) # >>> {1, 2, 3} ### 两个set可以做数学意义上的交集、并集 s1 = set([1, 2, 3]) s2 = set([2, 3, 4]) print (s1 & s2) # >>>{2, 3} print (s1 | s2) # >>> {1, 2, 3, 4}
二、 函数
1. 函数参数
参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数
#### 默认参数
def enroll(name, gender, age=6, city='Beijing'):
print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city)
print (enroll('Sarah', 'F'))
## 与默认参数不符的才需要提供额外的信息
print (enroll('Adam', 'M', city='Tianjin'))
## 默认参数必须指向不变对象
def add_end(L=[]):
# add_end()
# add_end()
# add_end()
# >>>['END', 'END', 'END']
L.append('END')
return L
#修改后 借用None这个不变对象
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L
#### 可变参数
# 允许传入0个或任意个参数，
# 这些可变参数在函数调用时自动组装为一个tuple
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
#### 关键字参数 & 命名关键字参数
# 允许你传入0个或任意个含参数名的参数，
# 这些关键字参数在函数内部自动组装为一个dict
# 存在可变参数和不存在可变参数
"""
>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}
"""
def f1(a, b, c=0, *args, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
def f2(a, b, c=0, *, d, e, **kw):
# 要限制关键字参数的名字
# 只接受 d、e为命名关键字参数
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
def person(name, age, *args, city='city', job, **kw):
# 如果函数定义中已经有了一个可变参数，
# 后面跟着的命名关键字参数就不再需要一个特殊分隔符*
# person('a', 11, 33, job='job', ot= 'ot', ot2= 'ot2'))
# >>>a 11 (33,) city job {'ot': 'ot', 'ot2': 'ot2'}
print(name, age, args, city, job, kw)
2. 函数返回值
import math def move(x, y, step, angle=0): nx = x + step * math.cos(angle) ny = y - step * math.sin(angle) return nx, ny # 函数可以同时返回多个值，但其实就是一个tuple。 x, y = move(100, 100, 60, math.pi / 6) r = move(100, 100, 60, math.pi / 6) print(x, y) # >>> 151.96152422706632 70.0 print(r) # >>> (151.96152422706632, 70.0)
三、 高级特性
1. 切片（Slice）
数列、元祖、字符串均可切片
## 先创建一个0-99的数列 L = list(range(100)) ## 取前10个数 # >>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] L[:10] ## 取后10个数 # >>> [90, 91, 92, 93, 94, 95, 96, 97, 98, 99] L[-10:] # >>> [90, 91, 92, 93, 94, 95, 96, 97, 98] L[-10:-1] ## 前10个数，每两个取一个 # >>> [0, 2, 4, 6, 8] L[:10:2] ## 所有数，每5个取一个 # >>> [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95] L[::5] ## 只写[:]就可以原样复制一个list # >>> [0, 1, 2, 3, ..., 99] L[:]
2. 迭代
使用for循环时，只要作用于一个可迭代对象，for循环就可以正常运行
判断一个对象是可迭代对象，方法是通过collections模块的Iterable类型判断
>>> from collections import Iterable >>> isinstance('abc', Iterable) # str是否可迭代 True >>> isinstance([1,2,3], Iterable) # list是否可迭代 True >>> isinstance(123, Iterable) # 整数是否可迭代 False
判断对象类型：
#### 判断对象类型 # 基本类型都可以用type()判断 """ >>> import types >>> def fn(): ... pass ... >>> type(fn)==types.FunctionType True >>> type(abs)==types.BuiltinFunctionType True >>> type(lambda x: x)==types.LambdaType True >>> type((x for x in range(10)))==types.GeneratorType True """ # 判断一个对象是否可迭代对象 """ from collections import Iterable print (isinstance('abc', Iterable)) print (isinstance([1,2,3], Iterable)) """ # 要获得一个对象的所有属性和方法，可以使用dir()函数 """ >>> dir('ABC') ['__add__', '__class__',..., '__subclasshook__', 'capitalize', 'casefold',..., 'zfill'] """
3. 列表生成式
可以用来创建list的生成式
# 生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] list(range(1, 11)) # 生成[4, 16, 36, 64, 100] L = [x * x for x in range(1, 11) if x % 2 == 0] # 两层循环，可以生成全排列 # >>> ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ'] L = [m + n for m in 'ABC' for n in 'XYZ'] ### 列出当前目录下的所有文件和目录名 # >>> ['.emacs.d', '.ssh', '.Trash'......'Workspace', 'XCode'] import os [d for d in os.listdir('.')] ### 使用两个变量来生成list # >>> ['y=B', 'x=A', 'z=C'] d = {'x': 'A', 'y': 'B', 'z': 'C' } L = [k + '=' + v for k, v in d.items()] ### if...else 和列表生成式 # 在一个列表生成式中，for前面的if ... else是表达式， # 而for后面的if是过滤条件，不能带else，否则报错 # >>> [-1, 2, -3, 4, -5, 6, -7, 8, -9, 10] L = [x if x % 2 == 0 else -x for x in range(1, 11)]
4. 生成器
在循环的过程中不断推算出后续的元素，就不必创建完整的list，从而节省大量的空间。这种一边循环一边计算的机制，称为生成器：generator。
#### 创建 # 把一个列表生成式的[]改成()，就创建了一个generator L = [x * x for x in range(10)] # >>> [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] g = (x * x for x in range(10)) # >>> <generator object <genexpr> at 0x1022ef630> # generator保存的是算法， # 每次调用next(g)，就计算出g的下一个元素的值， # 直到计算到最后一个元素，没有更多的元素，抛出错误。 ''' >>> next(g) 0 >>> next(g) 1 …… >>> next(g) 81 >>> next(g) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration ''' # 正确的方法是使用for循环，因为generator也是可迭代对象 g = (x * x for x in range(10)) for n in g: print(n) #### 定义generator的另一种方法 yield ## 斐波拉契数列 def fib(max): # >>> 1, 1, 2, 3, 5, 8, 13, 21, 34, ... n, a, b = 0, 0, 1 while n < max: yield b a, b = b, a + b n = n + 1 return 'done'
杨辉三角形：
# 杨辉三角形 生成器 generator def triangles(): L = [1] while True: yield L L.append(0) L = [ L[i]+ L[i-1] for i in range(len(L))] def triangles_yh(): # 期待输出: # [1] # [1, 1] # [1, 2, 1] # [1, 3, 3, 1] # [1, 4, 6, 4, 1] # [1, 5, 10, 10, 5, 1] # [1, 6, 15, 20, 15, 6, 1] # [1, 7, 21, 35, 35, 21, 7, 1] # [1, 8, 28, 56, 70, 56, 28, 8, 1] # [1, 9, 36, 84, 126, 126, 84, 36, 9, 1] n = 0 results = [] for t in triangles(): results.append(t) n = n + 1 if n == 10: break for t in results: print(t) real_res = [ [1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1] ] if results == real_res: print('测试通过!') else: print('测试失败!')
5. 迭代器
可以直接作用于for循环的数据类型有以下几种：
一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator，包括生成器和带yield的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
可以使用isinstance()判断一个对象是否是Iterator对象
>>> from collections.abc import Iterator >>> isinstance((x for x in range(10)), Iterator) True >>> isinstance([], Iterator) False >>> isinstance({}, Iterator) False >>> isinstance('abc', Iterator) False
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数：
>>> isinstance(iter([]), Iterator) True >>> isinstance(iter('abc'), Iterator) True
四、 函数式编程
1. 高阶函数： map / reduce
#### map()函数接收两个参数，一个是函数，一个是Iterable， # map将传入的函数依次作用到序列的每个元素， # 并把结果作为新的Iterator返回。 def f(x): return x * x r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) list(r) # >>> [1, 4, 9, 16, 25, 36, 49, 64, 81] # 把这个list所有数字转为字符串 list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])) # >>> ['1', '2', '3', '4', '5', '6', '7', '8', '9']
#### reduce()函数 # reduce把一个函数作用在一个序列[x1, x2, x3, ...]上， # 这个函数必须接收两个参数， # reduce把结果继续和序列的下一个元素做累积计算，其效果就是： # reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4) # 把序列[1, 3, 5, 7, 9]变换成整数13579 from functools import reduce def fn(x, y): return x * 10 + y reduce(fn, [1, 3, 5, 7, 9]) # 把str转换为int的函数 def char2num(s): digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9} return digits[s] reduce(fn, map(char2num, '13579'))
2. 高阶函数：filter
#### filter() # filter()也接收一个函数和一个序列。 #和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。 ## 把一个序列中的空字符串删掉 def not_empty(s): return s and s.strip() list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
3. 高阶函数：sorted
#### sorted() # sorted()函数可以对list进行排序 sorted([36, 5, -12, 9, -21]) # >>> [-21, -12, 5, 9, 36] sorted([36, 5, -12, 9, -21], key=abs) # >>> [5, 9, -12, -21, 36] # 反向排序，不必改动key函数，可以传入第三个参数reverse=True sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
4. 返回函数(闭包)
高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。
返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量。
def lazy_sum(*args): def sum(): ax = 0 for n in args: ax = ax + n return ax return sum # 当我们调用lazy_sum()时，返回的并不是求和结果，而是求和函数 # 调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数 f1 = lazy_sum(1, 3, 5, 7, 9) # >>> <function lazy_sum.<locals>.sum at 0x101c6ed90> f2 = lazy_sum(1, 3, 5, 7, 9) f1<> f2 f1() == f2() # >>> 25 ''' 在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量， 当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这称为“闭包（Closure）” ''' ## 闭包数据异常 =============== 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 =============== 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 f1, f2, f3 = count() # >>> f1() f2() f3() = 1, 4, 9
5. 匿名函数
lambda x：[ 表达式 ]
关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：f = lambda x: x * x
也可以把匿名函数作为返回值返回：
def build(x, y): return lambda: x * x + y * y
6. 装饰器
def now(): print('2015-3-25')
假设我们要增强now()函数的功能，比如，在函数调用前后自动打印日志，但又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
本质上，decorator就是一个返回函数的高阶函数。所以，我们要定义一个能打印日志的decorator，可以定义如下：
def log(func): def wrapper(*args, **kw): print('call %s():' % func.__name__) return func(*args, **kw) return wrapper
wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。
7. 偏函数
functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数。
当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。
import functools int2 = functools.partial(int, base=2) print （int2('1000000')） # 64 print （int2('1000000', base=10)） # 1000000
五、模块
1. 包和模块
一个abc.py的文件就是一个名字叫abc的模块，一个xyz.py的文件就是一个名字叫xyz的模块。
现在，假设我们的abc和xyz这两个模块名字与其他模块冲突了，于是我们可以通过包来组织模块，避免冲突。方法是选择一个顶层包名，比如mycompany，按照如下目录存放：
mycompany
├─ __init__.py
├─ abc.py
└─ xyz.py
引入了包以后，只要顶层的包名不与别人冲突，那所有模块都不会与别人冲突。现在，abc.py模块的名字就变成了mycompany.abc，类似的，xyz.py的模块名变成了mycompany.xyz。
请注意，每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录，而不是一个包。__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是mycompany。
2. 使用模块
#!/usr/bin/env python3 # -*- coding: utf-8 -*- ' a test module ' __author__ = 'Michael Liao' import sys def test(): args = sys.argv if len(args)==1: print('Hello, world!') elif len(args)==2: print('Hello, %s!' % args[1]) else: print('Too many arguments!') if __name__=='__main__': test()
第1行和第2行是标准注释，第1行注释可以让这个hello.py文件直接在Unix/Linux/Mac上运行，第2行注释表示.py文件本身使用标准UTF-8编码；
第4行是一个字符串，表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释；
第6行使用__author__变量把作者写进去，这样当你公开源代码后别人就可以瞻仰你的大名；
3. 作用域
正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等；
类似__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊变量，hello模块定义的文档注释也可以用特殊变量__doc__访问，我们自己的变量一般不要用这种变量名；
类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等；