定义函数
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()