python函数

定义函数

　　def func(x,y,z=v,*args,**kwargs):

　　　　pass

　　可以有多个返回值，通常封装为一个元组

　　函数可以是对象，也可以做参数传递和返回

　　　　一类对象：可以把对象当中参数和返回值来回传递

# !/usr/bin/python
# encoding:utf8



def __handleTXT(txt):
    print txt
def __handleJSON(json):
    print json
def __handleXML(xml):
    print xml

def decoder(type):
    if type=='xml':
        return __handleXML
    elif type=='json':
        return __handleJSON
    else:
        return __handleTXT()

decoder('xml')('<p>This is a plain text without any type of delivery of this example is only to prove that Python function.</p> ')

 

参数没有类型，python不做类型检查

没有重载，python不会区分参数名字和个数

多个同名函数时，后一个会覆盖前一个

位置参数和关键字参数（函数调用时）

任意数量的参数：*，**

　　def fun(*args,**kwargs)

# !/usr/bin/python
# encoding:utf8


def add(a,b):
    return  a+b
def add(a,b):
    return  a*b
print add(5,6)

def add(a,b,c):
    return a+b*c

print add(1,2,3)
print add(b=2,c=3,a=1)
print add(1,c=2,b=3)

# 列表
x=[1,2,30]
print add(x[0],x[1],x[2])
# *、**做拆包、分解动作
print add(*x)
print add(1,2,30)
#字典
y={'a':10,'b':20,'c':30}
print add(y['a'],y['b'],y['c'])
# key必须和add方法的一一对应
print add(**y)
print add(a=10,b=20,c=30)

def add(*args):
    return  sum(args)
# args为参数名，*为关键字。传入的参数被处理为列表
print add(1,2,3,4,5,6,7,8,9,0,11,12)

def add(**kwargs):
    return sum(kwargs.values())
# kwargs为参数名，**为关键字。传入的参数被处理为字典
print add(a=1,b=2,c=3,d=4)

def add(*args,**kwargs):
    return sum(args)+sum(kwargs.values())
# 必须保持前后字段一致
print add(1,2,3,a=1,b=2,c=3)

 

 

参数传递的是‘引用’

函数内部的修改会影响到外部

函数可以有多个返回值

可以用一个tuple对象接收返回值

也可以用多个变量接收

def f(a):
    a[2]='hh'
x=[1,2,3,4,5,6]
f(x)
print x

 

变量的作用域

LEGB原则

　　L(local)：函数本地

　　E(enclose)：任意上层的嵌套函数

　　G(global)：全局作用域（模块）

　　B(build-in)：内置作用域

x='global'
def outer():
    # x='enclose'
    def innter():
        # x='local'
        print x
    innter()
outer()
print __name__

 

global

x='global'
def outer():
    # x='enclose'
    def innter():
        global x
        x +='e'
        # x='local'
        print x
    innter()
outer()

函数是一类对象

　　函数可以有属性

　　文档属性

　　　　-　　定义函数的第一个没有赋值的字符串，可以通过__doc__访问

# !/usr/bin/python
# encoding:utf8



def f():
    pass
f.text='a'
f.test='b'
print f.text,f.test

def f(a,b,c):
    """
    This is a showcase of __doc__ method
    :param a: This is a common argument
    :param b: This is a common argument
    :param c: This is a common argument
    :return:  This method return values according to the specific method to determine
    """
    return a**b**c

print f.__doc__
print f(1,2,3)

 

 

函数嵌套和闭包

　　python的函数可以嵌套定义

　　闭包，能够保留函数定义时的环境信息

　　嵌套的函数定义

　　内部函数用到了外部函数中的变量

　　外部函数返回内部函数

　　　　def outer():

　　　　　　def inner():

　　　　　　　　...

　　　　　　return inner

　　

def outer():
    print 'outer'
    def inner():
        print 'inner'
    # return inner()
    return inner
x=outer()
x()
x=outer()()

 

装饰器

　　不带参数的装饰器

　　　　decorator(f)(*args,**kwargs)

　　　　@decorator

　　　　def f():

　　　　　　pass

　　　带参数的装饰器

　　　　decorator(name)(f)(*args,**kwargs)

　　　　@decorator(name)

　　　　def f():

　　　　　　pass

# !/usr/bin/python
# encoding:utf8


def decorator(f):
    def implenmention(*args,**kwargs):
        username=raw_input('name:')
        password=raw_input('pw:')
        if username=='huang' and password=='hjy123':
            return f(*args,**kwargs)
        else:
            print "test error"
    return implenmention

def search(searchkw):
    print  'search'
@decorator
def order(itemids):
    print 'order',itemids
def pay(orderid):
    print 'pay'

order(121)

迭代器

　　可迭代对象：Iterable

　　　　如果一个对象可以用for...in...的方式实现遍历其内容，這个对象就是一个可迭代对象。

　　迭代器：Iterable

　　　　遍历可迭代对象内容的方式

　　可迭代对象需要提供迭代器

　　　　实现__iter__\__next__

itertools提供比较复杂的迭代方式

　　permutations：排列

　　combinations：组合

　　product：笛卡尔积

　　repeat：重复

　　chain：链接一组迭代器

　　　　import itertools

　　　　itertools.permutations(X)