python 语法糖
\，换行连接
s = ”
s += ‘a’ + \
‘b’ + \
‘c’
n = 1 + 2 + \
3
# 6
while，for 循环外的 else
如果 while 循环正常结束（没有break退出）就会执行else。
num = [1,2,3,4]
mark = 0while mark < len(num):
n = num[mark] if n % 2 == 0:
print(n) # break
mark += 1else: print("done")
zip() 并行迭代
a = [1,2,3]
b = [‘one’,’two’,’three’]
list(zip(a,b))
# [(1, ‘one’), (2, ‘two’), (3, ‘three’)]
列表推导式
x = [num for num in range(6)]
# [0, 1, 2, 3, 4, 5]
y = [num for num in range(6) if num % 2 == 0]
# [0, 2, 4]
# 多层嵌套
rows = range(1,4)
cols = range(1,3)
for i in rows:
for j in cols:
print(i,j)
# 同
rows = range(1,4)
cols = range(1,3)
x = [(i,j) for i in rows for j in cols]
字典推导式
{ key_exp : value_exp fro expression in iterable }
#查询每个字母出现的次数。
strs = ‘hello world’
s = { k : strs.count(k) for k in set(strs) }
集合推导式
{expression for expression in iterable }
元组没有推导式
本以为元组推导式是列表推导式改成括号，后来发现那个 生成器推导式。
生成器推导式
>>> num = ( x for x in range(5) )>>> num
…:
函数
函数关键字参数，默认参数值
def do(a=0,b,c)
return (a,b,c)
do(a=1,b=3,c=2)
函数默认参数值在函数定义时已经计算出来，而不是在程序运行时。列表字典等可变数据类型不可以作为默认参数值。
def buygy(arg, result=[]):
result.append(arg)
print(result)
changed：
def nobuygy(arg, result=none):
if result == none:
result = []
result.append(arg)
print(result)
# or
def nobuygy2(arg):
result = []
result.append(arg)
print(result)
*args 收集位置参数
def do(*args):
print(args)
do(1,2,3)
(1,2,3,’d’)
**kwargs 收集关键字参数
def do(**kwargs):
print(kwargs)
do(a=1,b=2,c=’la’)
# {‘c’: ‘la’, ‘a’: 1, ‘b’: 2}
lamba 匿名函数
a = lambda x: x*x
a(4)
# 16
生成器
生成器是用来创建python序列的一个对象。可以用它迭代序列而不需要在内存中创建和存储整个序列。通常，生成器是为迭代器产生数据的。
生成器函数函数和普通函数类似，返回值使用 yield 而不是 return 。
def my_range(first=0,last=10,step=1):
number = first
while number < last:
yield number
number += step
>>> my_range()
…
装饰器
有时需要在不改变源代码的情况下修改已经存在的函数。装饰器实质上是一个函数，它把函数作为参数输入到另一个函数。 举个栗子：
# 一个装饰器
def document_it(func):
def new_function(*args, **kwargs):
print(“runing function: “, func.__name__)
print(“positional arguments: “, args)
print(“keyword arguments: “, kwargs)
result = func(*args, **kwargs)
print(“result: ” ,result)
return result
return new_function
# 人工赋值
def add_ints(a, b):
return a + b
cooler_add_ints = document_it(add_ints) #人工对装饰器赋值
cooler_add_ints(3,5)
# 函数器前加装饰器名字
@document_it
def add_ints(a, b):
return a + b
可以使用多个装饰器，多个装饰由内向外向外顺序执行。
命名空间和作用域
a = 1234
def test():
print(“a = “,a) # true
####
a = 1234
def test():
a = a -1 #false
print(“a = “,a)
可以使用全局变量 global a 。
a = 1234
def test():
global a
a = a -1 #true
print(“a = “,a)
python 提供了两个获取命名空间内容的函数 local() global()
_ 和 __
python 保留用法。 举个栗子：
def amazing():
”’this is the amazing.
hello
world”’
print(“the function named: “, amazing.__name__)
print(“the function docstring is: \n”, amazing.__doc__)
异常处理，try…except
只有错误发生时才执行的代码。 举个栗子：
>>> l = [1,2,3]
>>> index = 5
>>> l[index]
traceback (most recent call last):
file “”, line 1, in
indexerror: list index out of range
再试下：
>>> l = [1,2,3]
>>> index = 5
>>> try:
… l[index]
… except:
… print(“error: need a position between 0 and”, len(l)-1, “, but got”, index)
…
error: need a position between 0 and 2 , but got 5
没有自定异常类型使用任何错误。
获取异常对象，except exceptiontype as name
hort_list = [1,2,3]while 1:
value = input(“position [q to quit]? “) if value == ‘q’: break
try:
position = int(value)
print(short_list[position]) except indexerror as err:
print(“bad index: “, position) except exception as other:
print(“something else broke: “, other)
自定义异常
异常是一个类。类 exception 的子类。
class uppercaseexception(exception):
pass
words = [‘a’,’b’,’c’,’aa’]
for i in words:
if i.isupper():
raise uppercaseexception(i)
# error
traceback (most recent call last):
file “”, line 3, in
__main__.uppercaseexception: aa
命令行参数
命令行参数
python文件：
import sys
print(sys.argv)
pprint()友好输出
与print()用法相同，输出结果像是列表字典时会不同。
类
子类super()调用父类方法
举个栗子：
class person():
def __init__(self, name):
self.name = nameclass email(person):
def __init__(self, name, email):
super().__init__(name)
self.email = email
a = email(‘me’, ‘me@me.me’)>>> a.name… ‘me’>>> a.email… ‘me@me.me’
self.__name 保护私有特性
class person():
def __init__(self, name):
self.__name = name
a = person(‘me’)>>> a.name… attributeerror: ‘person’ object has no attribute ‘__name’# 小技巧a._person__name
实例方法( instance method )
实例方法，以self作为第一个参数，当它被调用时，python会把调用该方法的的对象作为self参数传入。
class a():
count = 2
def __init__(self): # 这就是一个实例方法
a.count += 1
类方法 @classmethod
class a():
count = 2
def __init__(self):
a.count += 1 @classmethod
def hello(h):
print(“hello”,h.count)
注意，使用h.count(类特征)，而不是self.count(对象特征)。
静态方法 @staticmethod
class a(): @staticmethod
def hello():
print(“hello, staticmethod”)
>>> a.hello()
创建即用，优雅不失风格。
特殊方法(sqecial method)
一个普通方法：
class word():
def __init__(self, text):
self.text = text
def equals(self, word2): #注意
return self.text.lower() == word2.text.lower()
a1 = word(‘aa’)
a2 = word(‘aa’)
a3 = word(’33’)
a1.equals(a2)
# true
使用特殊方法：
class word():
def __init__(self, text):
self.text = text def __eq__(self, word2): #注意，使用__eq__
return self.text.lower() == word2.text.lower()
a1 = word(‘aa’)
a2 = word(‘aa’)
a3 = word(’33’)
a1 == a2# true
# true
其他还有：
*方法名* *使用*
__eq__(self, other) self == other
__ne__(self, other) self != other
__lt__(self, other) self < other
__gt__(self, other) self > other
__le__(self, other) self = other
__add__(self, other) self + other
__sub__(self, other) self – other
__mul__(self, other) self * other
__floorp__(self, other) self // other
__truep__(self, other) self / other
__mod__(self, other) self % other
__pow__(self, other) self ** other
__str__(self) str(self)
__repr__(self) repr(self)
__len__(self) len(self)
文本字符串
‘%-10d | %-10f | %10s | %10x’ % ( 1, 1.2, ‘ccc’, 0xf )
#
‘1 | 1.200000 | ccc | 33’
{} 和 .format
‘{} {} {}’.format(11,22,33)
# 11 22 33
‘{2:2d} {0:-10d} {1:10d}’.format(11,22,33)
# :后面是格式标识符
# 33 11 22
‘{a} {b} {c}’.format(a=11,b=22,c=33)