Python之函数小结

（1）函数参数

# -*- coding: utf-8 -*-

#函数式编程，def Fun(arg,*args,**kargs) 默认参数arg，可变参数args，kargs


#当传入的参数个数不定时，可以使用*，python会将传入的参数自动包装成一个列表再传入进函数
def show1(*arg):
    for item in arg:
        print item
show1("li","dd","ds","ss")

#**kargs会将传入的参数转换成字典的形式
def show2(**kargs):
    for item in kargs.items():
        print item
#会将＝前面的视为key，将＝后面的部分视为value
show2(name="liyang",age=12)

#直接传入一个字典作为参数，需要将**也加进去，将列表作为参数传入进去也是相同的道理
user_dict = {"k1":123,"k2":456}
show2(**user_dict)

（2）三元运算符

result = "gt" if 1>3 else "lt"
print result

（3）lambda表达式

temp = lambda x,y:x+y
print temp(4,10)

（4）map，reduce，zip，filter及eval

#-*- coding: utf-8 -*-
li = [11,22,33]
temp = map(lambda arg:arg+100,li)
print temp

#筛选的函数返回的是True则保留在新temp中，否则就过滤掉
def foo(arg):
    if arg<22:
        return True
    else:
        return False
temp2 = filter(foo,li)
print temp2

#实现累加
temp3 = reduce(lambda x,y:x+y,li)
print temp3

x = [1,2,3]
y = [4,5,6]
z = [7,8,9]
print zip(x,y,z)
a = "8*8"
print eval(a)

（5）反射
反射，（1）可通过字符串的形式导入模块 （2）以字符串的形式执行函数

temp = "mysalhelper"
func = "count"
model = __import__(temp)
Function = getattr(model,func)
print Function

修改temp的内容就可以动态的切换需要导入的模块，及通过func来使用你想调用的函数

（6）md5加密

import hashlib
hash = hashlib.md5()
hash.update("admin")
#输出
print hash.hexdigest()
print hash.digest()

（7）序列化及反序列化，json

#-*- coding: utf-8 -*-
import pickle
#（1）例如两个python间想进行复杂的数据结构的数据交换时，可以通过序列化和反序列化的方式进行传输和解析 （2）数据存入硬盘
li = ["alex",11,22,"ok"]
#序列化，如下将一个列表序列化成一个字符串
dumpsed = pickle.dumps(li)
# pickle.dump(li,open("D:/temp.pk","r))
print dumpsed
print type(dumpsed)

#反序列化
loadsed = pickle.loads(dumpsed)
# result = pickle.load(open("D:/temp.pk","r),"r")
print loadsed
print type(loadsed)

import json
name_dic = {"name":"Tom","age":23}
print json.dumps(name_dic)
serialized_obj = json.loads(json.dumps(name_dic))
print serialized_obj

（8）闭包

Python支持一种名为函数闭包的特性，意味着在非全局作用域定义的函数记得外层命名空间是怎样的，例如：

>>> def outer(x):
...     def inner():
...         print x # 1
...     return inner
>>> print1 = outer(1)
>>> print2 = outer(2)
>>> print1()
1
>>> print2()
2

从这个示例可以看到闭包——函数记住其外层作用域的事实——可以用来构建本质上有一个硬编码参数的自定义函数。虽然没有直接给 inner 函数传参 1 或 2，但构建了能“记住”该打印什么数的 inner 函数自定义版本。

（9）装饰器

装饰器其实就是一个以函数作为参数并返回一个替换函数的可执行函数。让我们从简单的开始，直到能写出实用的装饰器。

>>> def outer(some_func):
...     def inner():
...         print "before some_func"
...         ret = some_func() # 1
...         return ret + 1
...     return inner
>>> def foo():
...     return 1
>>> decorated = outer(foo) # 2
>>> decorated()
before some_func
2

请仔细看这个装饰器示例。首先，定义了一个带单个参数 some_func 的名为 outer 的函数。然后在 outer 内部定义了一个内嵌函数 inner。inner 函数将打印一行字符串然后调用 some_func，并在 #1 处获取其返回值。在每次 outer 被调用时，some_func 的值可能都会不同，但不论 some_func 是什么函数，都将调用它。最后，inner 返回 some_func() 的返回值加 1。在 #2 处可以看到，当调用赋值给 decorated 的返回函数时，得到的是一行文本输出和返回值 2，而非期望的调用 foo 的返回值 1。

我们可以说变量 decorated 是 foo 的装饰版——即 foo 加上一些东西。

装饰器，通过@方式建立函数和装饰器之间的关系,可以用 @ 符号来装饰函数

#-*- coding: utf-8 -*-
def outer(fun):
    def wrapper():
        print "decorator"
        fun()
        print "after the fun"
    return wrapper

@outer

def fun1():
    print "fun1"

"""
fun1()＝
    def wrapper():
        print "decorator"
        fun()
    return wrapper
执行fun1相当于执行如上函数，其中的fun相当于fun1原函数中定义的内容
"""

@outer
def fun2():
    print "fun2"

@outer
def fun3():
    print "fun3"



fun1()
fun2()
fun3()

#含参数的装饰器
def outer2(fun):
    def wrapper(arg):
        print "decorator 2"
        fun(arg)
        print "after the fun"
    return wrapper

@outer2
def fun4(arg):
    print arg

fun4("hello world")

def outer3(fun):
    def wrapper(arg):
        print "decorator 3"
        result = fun(arg)
        print "after the fun"
        return result
    return wrapper

@outer3
def fun5(arg):
    print arg
    return "return"

result = fun5("hello world")
print result

个人感觉核心就是一句话，通过一个函数将需要进行包装的函数进行包装，加入一些想添加的功能