1. Python函数参数
1. 位置参数
调用时根据定义参数的顺序传参，如下例：
def fun(a, b):
return a-b
fun(1, 2) # 结果为 1-2 = -1
2. 默认参数
定义函数时写入默认参数，即便不传参也不会显示错误，如下例：
def function (param = 0)
return param
规范： 将默认的、变化不大的写在后面，变化大的参数写在前面
3. 可更改与不可更改参数
所有的变量都可以理解是内存中一个对象的“引用”，而对象有两种,“可更改”（mutable）与“不可更改”（immutable）对象。在python中，strings, tuples, 和numbers是不可更改的对象，而list,dict等则是可以修改的对象，看下例：
a = 1
def fun(a):
a = 2
print a # 结果为1，不会随函数调用而更改
a = []
def fun(a):
a.append(1)
print a # 结果为[1]，随函数调用而更改
4. 可变参数
可变参数在函数调用时自动组装成tuple，直接上栗子：
定义：
def fun(*args):
pass
调用方法一：
fun(1,2,3)
调用方法二：
params = [1,2,3]
fun(*params)
5. 关键字参数
关键字参数在函数调用时自动组装成dict, 可不传，也可传入任意个数的关键字参数（必须传入参数名），上栗子：
定义：
def fun(**kwargs):
return kw
调用方法一：
fun(city = 'Beijing') # 返回{'city':'Beijing'}
调用方法二：
fun(gender ='M', job = 'Coder') # 返回{'gender':'M', 'job':'Coder'}
备注：当传入一个dict时，函数内部对其修改不会影响函数外的dict
6. 命名关键字参数
限制了传入的关键字参数，只接受固定名称参数传入，如下：
def fun(paraA, paraB, *, keyParaA, keyParaB)：
pass
则只有key为keyParaA和keyParaB的关键字函数可以传入。
7. *args and **kwargs
当不确定函数里将要传递多少参数时你可以用*args，相似的，**kwargs允许使用没有事先定义的参数名；
你也可以混着使用，命名参数首先获得参数值然后所有的其他参数都传递给*args和**kwargs，命名参数在列表的最前端，如：
def table_things(titlestring, **kwargs)
*args和**kwargs可以同时在函数的定义中，但是*args必须在**kwargs前面。
2. Python方法
Python有三种方法，分别是实例方法，静态方法(staticmethod)以及类方法(classmethod)，结合下例说明一下这三种方法的区别：
def fun(x):
print "executing fun(%s)"%(x)
class A(object):
def fun(self,x):
print "executing fun(%s,%s)"%(self,x)
@classmethod
def class_fun(cls,x):
print "executing class_fun(%s,%s)"%(cls,x)
@staticmethod
def static_fun(x):
print "executing static_fun(%s)"%x
a=A()
接下来我们来结合栗子对这三种方法做一下讲解。
对于实例方法，在类里每次定义方法的时候都需要绑定一个实例，在上栗中，fun()就是实例方法，它的调用离不开实例，所以我们把实例自己(self) 作为参数传给方法，便能进行方法与实例的绑定；
显然易见，class_fun()就是类方法了，而它则是通过cls来绑定了类；
而静态方法则不需要对谁进行绑定，那么这三种方法在调用时有什么区别呢？
| |实例方法 | 类方法 | 静态方法 | |
|---|---|---|---|
| a = A() | a.fun(x) | a.class_fun(x) | a.static_fun(x) |
| A | 不可用 | A.class_fun(x) | A.static_fun(x) |
3. Python中的下划线
废话不说直接上栗子：
>>> class MyClass():
... def __init__(self):
... self.__superprivate = "Hello"
... self._semiprivate = ", world!"
...
>>> mc = MyClass()
>>> print mc.__superprivate
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: myClass instance has no attribute '__superprivate'
>>> print mc._semiprivate
, world!
>>> print mc.__dict__
{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}
__foo__:只是约定,Python内部的名字，用来区别其他用户自定义的命名，以防冲突。
_foo:只是约定，用来指定变量私有.程序员用来指定私有变量的一种方式；
__foo:这个有真正的意义:解析器用_classname__foo来代替这个名字，以区别和其他类相同的命名。
4. Python装饰器
1. 两点定义：
- 前有@，将之后出现的函数作为参数传入
- 返回作为参数传入的函数
2、 栗子
def log (func):
@functools.wraps (func)
def wrapper (*args, **kw):
print ( 'call %s' %func.name)
return func (*args, **kw)
return wrapper
@log
def now ( ):
print ('2017-05-09')
3. 说明
在上栗中，调用now()时，now()方法会作为参数传入log()方法，实际上是调用了以now()为参数的log()方法；
上栗的打印内容是：
call now ( ):
2017-05-09
这么解释或许更加专业，原来的now()函数仍然存在，只是现在同名的now变量指向了新的函数log(now)，返回wrapper()函数。
5. Lambda
Lambda又称匿名函数，当我们需要使用一个简单的且无需重复调用的函数时，就可以使用lambda，优雅又简洁。其使用方法如下例：
lambda 参数 : 返回值
是不是超简单，那看一下具体使用吧：
map( lambda x: x*x, [y for y in range(10)] )
上述代码等价于：
def sq(x):
return x * x
map(sq, [y for y in range(10)])
使用lambda可以有效减少代码量，这样的写法是将「遍历列表，给遇到的每个元素都做某种运算」的过程从一个循环里抽象出来成为一个函数 map，然后用 lambda 表达式将这种运算作为参数传给 map。Python 之中，类似能用到 lambda 表达式的「高级」函数还有sort,reduce,filter等等。
6. map(),reduce(),filter()
既然说到了lambda，那就不得不提map()、reduce()和filter()，下面就一一介绍一下吧：
1. map()
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
比如我们有一个函数f(x)=x*x，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下：
map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
map()传入的第一个参数是f，即需要对列表中的元素进行的操作，第二个参数是迭代列表，返回则是一个新的经过处理后的列表。 map()作为高阶函数，将运算规则抽象了，将列表中的数字转为字符串只需要一行代码：
map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])
2. reduce()
与map()相同，reduce()同样接收两个参数，第一个是函数（这个函数必须接收两个参数），第二个是迭代列表，它的效果如下：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
即列表中的第一个元素与第二个元素作为参数传入f()的返回值，与列表中的第三个元素再次作为参数传入f()……
3. filter()
filter()函数用于过滤序列。
又和map()类似的是，filter()也接收一个函数和一个序列。和map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素，上栗子：
def is_odd(n):
return n % 2 == 1
filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])
# 结果: [1, 5, 9, 15]
7. Python中的拷贝
上个栗子一目了然：
import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
b = a #赋值，传对象的引用
c = copy.copy(a) #对象拷贝，浅拷贝
d = copy.deepcopy(a) #对象拷贝，深拷贝
a.append(5) #修改对象a
a[4].append('c') #修改对象a中的['a', 'b']数组对象
print 'a = ', a
print 'b = ', b
print 'c = ', c
print 'd = ', d
输出结果：
a = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b = [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c = [1, 2, 3, 4, ['a', 'b', 'c']]
d = [1, 2, 3, 4, ['a', 'b']]
8. Python中的正则表达式
1.预设元字符
\w匹配任意一个单词字符，包括数字和下划线，等价于[A-Za-z0-9_]，例如 a\wc 可以匹配 abc、acc\W匹配任意一个非单词字符，与 \w 操作相反，它等价于 [^A-Za-z0-9_]，例如： a\Wc 可匹配 a!c\s匹配任意一个空白字符，空格、回车等都是空白字符，例如：a\sc 可以配 a\nc，这里的 \n表示回车\S匹配任意一个非空白字符\d匹配任意一个数字，它等价于[0-9]，例如：a\dc 可匹配 a1c、a2c …\D匹配任意一个非数字
2.基本元字符
.匹配除换行符以外的任意一个字符，例如：”a.c” 可以完全匹配 “abc”，也可以匹配 “abcef” 中的 “abc”\转义字符，使特殊字符具有本来的意义，例如： 1.2 可以匹配 1.2[...]匹配方括号中的任意一个字符，例如：a[bcd]e 可以匹配 abe、ace、ade，它还支持范围操作，比如：a到z可表示为 “a-z”，0到9可表示为 “0-9”，注意，在 “[]” 中的特殊字符不再有特殊意义，就是它字面的意义，例如：[.*]就是匹配 . 或者 *[^...]字符集取反，表示只要不是括号中出现的字符都可以匹配，例如：a[^bcd]e 可匹配 aee、afe等
3.重复匹配
*重复匹配零次或者更多次?重复匹配零次或者一次+重复匹配1次或者多次{n}重复匹配n次{n,}重复匹配至少n次{n, m}重复匹配n到m次
4.贪婪与非贪婪
贪婪模式正则表达式重复匹配时，在使整个表达式能得到匹配的前提下尽可能匹配多的字符，我们称之为贪婪模式；
例如： r”a.*b” 表示匹配 a 开头 b 结尾，中间可以是任意多个字符的字符串，如果用它来匹配 aaabcb，那么它会匹配整个字符串非贪婪模式只需要在量词后面加一个问号” ？”，在保证匹配的情况下尽可能少的匹配;
比如刚才的例子，我们只希望匹配 aaab，那么只需要修改正则表达式为 r”a.*?b”
5.正则引擎
-
re.match(pattern, string)
match方法从字符串的起始位置开始检查，如果刚好有一个子字符串与正则表达式相匹配，则返回一个Match对象，只要起始位置不匹配则退出，返回 None -
re.search(pattern, string)
search 方法虽然也是从起始位置开始检查，但是它在起始位置不匹配的时候会一直尝试往后检查，直到匹配为止，如果到字符串的末尾还没有匹配，则返回 None -
re.findall(pattern, string)findall 返回的对象是由匹配的子字符串组成的列表，即使匹配到了也不中断，继续匹配
写了那么多，但每次写正则的时候，我还是会用度娘 =.=
