python-函数

定义函数

def  函数名(参数1，参数2，...):
    执行语句
    return

函数调用

函数名(实参)

import time

def logger(n):
    time_format='%Y-%m-%d %X'
    time_current= time.strftime(time_format)
    with open('日志记录','a') as f:
        f.write('%s end action%s\n'%(time_current,n))

def action1(n):
    print('starting action1...')
    logger(n)

def action2(n):
    print('starting action2...')
    logger(n)

def action3(n):
    print('starting action3...')
    logger(n)

action1(11)
action2(22)
action3(33)

函数参数

必须参数

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

ret=add(1,2)
print(ret+5)

默认参数

def names(name,age=18):
    print(name,age)
names('alex',33)

关键字参数

def show_info(name,age,sex=1):
    print(name)
    print(age)
    print(sex)
show_info(name="中秋",age=26,)

可变长参数

• 在定义函数时，可以在形参前边加上一个*,这样这个形参将会获取到所有的实参
• 它将会将所有的实参保存到一个元组中
• 可变参数不是必须写在最后，但是注意，带*的参数后的参数，必须以关键字参数的形式传递
• 如果在形参的开头直接写一个*，则所有的参数必须以关键字参数的形式传递
• *形参只能接收位置参数，不能接收关键字参数

def add(*args):
    sum = 0
    for i in args:
        sum+=i
    return sum

ret=add(1,2,3)
print(ret)

def show_info(**kwargs):
    print(kwargs)
    for i in kwargs:
        print(i,kwargs[i])

show_info(name="alex",age=26,sex=1,salary=5000)

def fn(a,*b,c):
	print('a = ',a)
	print('b = ',b)
	print('c = ',c)

fn(1,2,3,4,c=5)

https://kivy.org/docs/installation/installation-windows.html

任意参数

def name(*args):
    print(*args)
name('alex','egon','wusir','oldboy')

def name(a,b,*args):
    print(a)
    print(b)
    print(*args)
name('alex','egon','wusir','oldboy')

def name(a,*args,**kwargs):
    print(a)
    print(*args)
    print(kwargs)
name('alex',4,5,1,6,{'k':'v'},b='sss')

说明：

• **形参可以接收其它的关键字参数，它会将这些参数统一保存到一个字典中
• 字典的key就是参数的名字，字典的value就是参数的值
• **形参只能有一个，并且必须写在所有参数的最后

**kwargs  关键传参

运行结果：

alex
4 5 1 6 {'k': 'v'}
{'b': 'sss'}

参数解包

• 传递实参时，也可以在序列类型的参数前添加星号，它会自动将序列中的元素依次作为参数传递
• 通过 ** 对一个字典进行解包操作

def fn(a,b,c):
	print('a = ',a)
	print('b = ',b)
	print('c = ',c)

t = (10,20,30)
fn(*t)
d = {'a':100,'b':200,'c':300}
fn(**d)

http://www.cnblogs.com/yuanchenqi/articles/5828233.html

函数式编程

• 在Python中，函数是一等对象

• 一等对象一般都会具有如下特点：

  • 对象是在运行时创建的
  • 能赋值给变量或作为数据结构中的元素
  • 能作为参数传递
  • 能作为返回值返回

• 高阶函数

  • 高阶函数至少要符合以下两个特点中的一个
    ① 接收一个或多个函数作为参数
    ② 将函数作为返回值返回

l = [1,2,3,4,5,6,7,8,9,10]


# 定义一个函数，用来检查一个任意的数字是否是偶数
def fn2(i):
    if i % 2 == 0:
        return True
    return False


# 用来检查指定的数字是否大于5
def fn3(i):
    if i > 5:
        return True
    return False


# 定义一个高阶函数
def fn(func, lst):
    new_list = []  #创建一个新列表
    for n in lst:
        if func(n):
            new_list.append(n)

    return new_list

def fn4(i):
    if i % 3 == 0:
        return True
    return False

print(fn(fn4, l))

匿名函数

l = [1,2,3,4,5,6,7,8,9,10]
def fn4(i):
    return i % 3 == 0

# print(fn(fn4, l))

#filter() 可以从序列中过滤出符合条件的元素，保存到一个新的序列中
# 参数：
#  1.函数，根据该函数来过滤序列（可迭代结构）
#  2.需要过滤的序列（可迭代的结构）
# 返回值：
# 过滤后的新序列（可迭代的结构）

# fn4是作为参数传递金filter函数中
# r = filter(fn4, l)
# print(list(r))

# 匿名函数 lambda函数表达式(语法糖)
# lambda函数表达式专门用来创建一些简单的函数，它是函数创建的又一种方式
# 语法： lambda 参数列表： 返回值
# 匿名函数一般都是作为参数使用，其它地方不会使用

# def fn5(a, b):
#     return a + b

#print((lambda a, b: a + b)(10, 20))
# 将匿名函数赋值给一个变量
#fn6 = lambda a, b: a + b
#print(fn6(10, 30))

l = [1,2,3,4,5,6,7,8,9,10]
r = filter(lambda i : i % 2 == 0, l)
print(list(r))

#map() 可以对可迭代对象中的所有元素做指定的操作，然后将其添加到一个新的对象中返回
l = [1,2,3,4,5,6,7,8,9,10]
r = map(lambda i : i + 1, l)
print(list(r))

sort

# sort()该方法用来对列表中的元素进行排序
# sort()方法默认是直接比较列表中的元素的大小
# 在sort()可以接收一个关键字参数，key
# key需要一个函数作为参数，当设置了函数作为参数
# 每次都会以列表中的一个元素作为参数来调用函数，并且使用函数的返回值来比较元素的大小
l = ['bb', 'aaaa', 'c', 'ddddddd', 'fff']
l.sort(key=len)
l = [2,5,'1',3,'6','4']
l.sort(key=int)
#print(l)

# sorted()函数可以对任意的序列进行排序，并且使用sorted()排序不会影响原来的对象,而是返回一个新的对象
l = [2,5,'1',3,'6','4']
l = '12314253434534588973'
print('排序前:', l)
print(sorted(l, key=int))
print('排序后:', l)

闭包

形成闭包的要件

• 函数嵌套
• 将内部函数作为返回值返回
• 内部函数必须要使用到外部函数的变量

# 将函数作为返回值返回，也是一种高阶函数
# 这种高阶函数也称为闭包

def fn():
    a = 10
    # 函数内部再定义一个函数
    def inner():
        print('我是inner', a)
    # 将内部函数inner作为返回值返回
    return inner

# r是一个函数，是调用fn()后返回的函数
# 这个函数是在fn()内部定义的
# 所以这个函数总是能访问到fn()函数内的变量
r = fn()
#r()

# 求多个数的平均值
def make_averager():
    # 创建一个列表，用来保存数值
    nums = []

    # 创建一个函数，用来计算平均值
    def averager(n):
        # 将n添加到列表中
        nums.append(n)
        # 求平均值
        return sum(nums) / len(nums)
    return averager

averager = make_averager()
print(averager(10))
print(averager(20))
print(averager(30))

装饰器

装饰器本质上是一个Python函数(其实就是闭包)，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。装饰器用于有以下场景，比如:插入日志、性能测试、事务处理、缓存、权限校验等场景

• 在定义函数时，可以通过@装饰器，来使用指定的装饰器，来装饰当前的函数
• 可以同时为一个函数指定多个装饰器，函数将会按照从内向外的顺序被装饰

def add(a, b):
    r = a + b
    return r

def mul(a, b):
    r = a * b
    return r

#r = add(123, 456)
#print(r)

def fn():
    print('我是fn函数...')

def fn2():
    print('函数开始执行...')
    fn()
    print('函数执行结束...')

#fn2()

def new_add(a, b):
    print('函数开始执行...')
    r = add(a, b)
    print('函数执行结束...')
    return r

# r = new_add(123, 456)
# print(r)

def begin_end(old):
    def new_function(*args, **kwargs):
        print('开始执行...')
        result = old(*args, **kwargs)
        print('执行结束...')
        return result

    return new_function

f = begin_end(fn)
f2 = begin_end(add)
f3 = begin_end(mul)
#r = f()
#r = f2(123,456)
# r = f3(123,456)
# print(r)

def fn3(old):
    def new_function(*args, **kwargs):
        print('fn3装饰~开始执行...')
        result = old(*args, **kwargs)
        print('fn3装饰~执行结束...')
        return result

    return new_function

@begin_end # 装饰器
@fn3
def say_hello():
    print('大家好...')

say_hello()