Python 函数
Python 函数
Python 函数之定义函数
在Python中，定义一个函数要使用
- def语句，依次写出函数名、括号、括号中的参数和冒号:
- 然后，在缩进块中编写函数体，函数的返回值用return语句返回。
1、定义一个函数
def myfirst():
print("Hello world!")
myfirst()
#输出结果
Hello world!
2、定义发送邮件的函数
- 不接收用户指定邮箱
# 不接收用户指定邮箱的函数
#!/usr/bin/env python
# -*- conding:utf-8 -*-
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
def mail():
msg = MIMEText('邮件内容', 'plain', 'utf-8')
msg['From'] = formataddr(["evescn", '18111434862@163.com'])
msg['To'] = formataddr(["gmkk", '519518995@qq.com'])
msg['Subject'] = "主题"
server = smtplib.SMTP("smtp.163.com", 25)
server.login("18111434862@163.com", "XXXXXX")
server.sendmail('18111434862@163.com', ['519518995@qq.com', ], msg.as_string())
server.quit()
mail()
- 用户可以指定邮箱
# 用户可以指定邮箱的函数
#!/usr/bin/env python
# -*- conding:utf-8 -*-
import smtplib
from email.mime.text import MIMEText
from email.utils import formataddr
def mail(mails):
msg = MIMEText('邮件内容', 'plain', 'utf-8')
msg['From'] = formataddr(["evescn", '18111434862@163.com'])
msg['To'] = formataddr(["gmkk", mails])
msg['Subject'] = "主题"
server = smtplib.SMTP("smtp.163.com", 25)
server.login("18111434862@163.com", "XXXXXX")
server.sendmail('18111434862@163.com', [mails, ], msg.as_string())
server.quit()
mail('519518995@qq.com')
3、函数的参数个数
- 无参
- 一个参数
- 两个参数
- ……
- 动态参数
4、举例
- 无参函数
# 无参函数
def show():
print('a')
return [11, 22, ]
print('b')
show()
# 输出结果
a
- 一个参数
# 一个参数
def show(arg):
print(arg)
n = [11, 22, 33, 44]
show(n)
# 输出结果
[11, 22, 33, 44]
- 两个参数
# 两个参数
def show(arg, xxx):
print(arg, xxx)
show('evescn', 'gmkk')
# 输出结果
evescn gmkk
- 默认参数
# 默认参数，必须写在实参之后
def jiecheng(arg, n=2):
print(arg ** n)
jiecheng(2)
jiecheng(2, 3)
# 输出结果
4
8
- 指定参数
# 指定参数
def show(a1,a2):
print(a1,a2)
show(123, 999)
show(a2=123, a1=999)
# 输出结果
123 999
999 123
- 动态参数列表
# 动态参数
# 传入参数为列表 OK?
def show(*arg): # 把所有位置参数转为了元组
print(arg, type(arg))
show(1,2,3,4,5,6,7,8)
# 输出结果
(1, 2, 3, 4, 5, 6, 7, 8) <class 'tuple'>
- 动态参数字典
# 动态参数
# 传入参数为字典 OK?
def show(**arg): # 把所有关键字参数转为了字典
print(arg,type(arg))
show(n1=1,n2=2,n3=3,n4=4,)
# 输出结果
{'n4': 4, 'n3': 3, 'n1': 1, 'n2': 2} <class 'dict'>
- 动态参数
# 实参、一个*的动态参数、两个*的动态参数
# 定义是先放变量，在放一个*的参数，再放**的参数
def show(a1, *args, **kwargs):
print(a1)
print(args, type(args))
print(kwargs, type(kwargs))
show(11, 22, 33, 44, n1=99, n2=88, n3=77)
# 输出结果
11
(22, 33, 44) <class 'tuple'>
{'n3': 77, 'n1': 99, 'n2': 88} <class 'dict'>
- 动态参数，传入数据类型列表和字典
# 仔细对比2次的输出结果，对于创建的列表和字典，传给函数时需指定传递给那个变量
def show(*args, **kwargs):
print(args,type(args))
print(kwargs, type(kwargs))
a1=[11, 22, 33, 44]
a2={'n1': 99, 'n2': 88, 'n3': 77}
show(a1, a2)
show(*a1, **a2)
#输出结果
([11, 22, 33, 44], {'n3': 77, 'n2': 88, 'n1': 99}) <class 'tuple'>
{} <class 'dict'>
(11, 22, 33, 44) <class 'tuple'>
{'n3': 77, 'n2': 88, 'n1': 99} <class 'dict'>
- format函数
# format函数，如何给farmat函数传递参数
s1 = "{0} to {1}"
l = ['evescn','gmkk']
ret1 = s1.format(*l)
ret2 = s1.format('evescn','gmkk')
print(ret1)
print(ret2)
s1 = "{name} to {acter}"
l = {'name':'evescn', 'acter':'gmkk'}
ret1 = s1.format(**l)
ret2 = s1.format(name='evescn', acter='gmkk')
print(ret1)
print(ret2)
# 输出结果
evescn to gmkk
evescn to gmkk
evescn to gmkk
evescn to gmkk
Python 函数之函数调用
Python内置了很多有用的函数，我们可以直接调用。
要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数abs，只有一个参数。可以直接从Python的官方网站查看文档：
http://docs.python.org/3/library/functions.html#abs
也可以在交互式命令行通过help(abs)查看abs函数的帮助信息。
1、调用abs函数
>>> abs(100)
100
>>> abs(-20)
20
>>> abs(12.34)
12.34
2、数据类型转换
Python内置的常用函数还包括数据类型转换函数，比如int()函数可以把其他数据类型转换为整数：
>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False
3、函数名
函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”
>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1
4、内置函数
注：查看详细猛击这里
局部变量全局变量
1、全局与局部变量
name = "Evescn"
def change_name(name):
print("before change:",name)
name = "GMKK"
print("after change", name)
change_name(name)
print("name: ",name)
# 输出结果
before change: Evescn
after change GMKK
name: Evescn
- 在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
- 全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
- 当全局变量与局部变量同名时：
- 在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。
Python 函数之递归
1、递归函数定义
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
我们来计算阶乘 n! = 1 x 2 x 3 x ... x n ，用函数 fact(n) 表示
fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n
所以， fact(n) 可以表示为 n x fact(n-1) ，只有 n=1 时需要特殊处理。
于是， fact(n) 用递归的方式写出来就是
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
上面就是一个递归函数。可以试试：
>>> fact(1)
1
>>> fact(5)
120
>>> fact(100)
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000L
如果我们计算 fact(5) ，可以根据函数定义看到计算过程如下：
===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120
递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试fact(1000)：
>>> fact(1000)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 4, in fact
...
File "<stdin>", line 4, in fact
RuntimeError: maximum recursion depth exceeded in comparison
2、利用函数编写如下数列
斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368 ...
def func(arg1, arg2):
# for i in range(10):
if arg1 == 0:
print(arg1)
print(arg2)
arg3 = arg1 + arg2
if arg3 < 1000:
print(arg3)
func(arg2, arg3)
else:
return
func(0, 1)
# 运行结果
0
1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
转载自
https://www.liaoxuefeng.com/wiki/1016959663602400/1017268131039072
高阶函数
什么是高阶函数？下面条件满足一个即时高阶函数
- 把一个函数名当作实参传给另外一个函数（在不修改被装饰函数源代码的情况下为其添加功能）
- 函数返回值中包含函数名（不修改函数的调用方式）
变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
def add(x,y,f):
return f(x) + f(y)
res = add(3,-6,abs)
print(res)
函数返回值中包含函数名
def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
当我们调用 lazy_sum() 时，返回的并不是求和结果，而是求和函数：
>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>
调用函数 f 时，才真正计算求和的结果：
>>> f()
25
Python 函数之lambda、map、filter和reduce
1、lambda 函数
lambda()是Python里的匿名函数，其语法如下：
lambda [arg1[, arg2, ... argN]]: expression
学习条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：
# 普通条件语句
if 1 == 1:
name = 'evescn'
else:
name = 'gm'
# 三元运算
name = 'evescn' if 1 == 1 else 'gm'
对于简单的函数，也存在一种简便的表示方式，即：lambda表达式
# ###################### 普通函数 ######################
# 定义函数（普通方式）
def func(arg):
return arg + 1
# 执行函数
result = func(123)
# ###################### lambda ######################
# 定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1
# 执行函数
result = my_lambda(123)
lambda存在意义就是对简单函数的简洁表示，下面在举一个列表的例子
l = [11, 22, 33, 44]
new_l = map(lambda x: x + 10, l)
a = list(new_l)
print(a)
# 输出结果
[21, 32, 43, 54]
2、map 函数
map函数会根据提供的函数对指定序列做映射，其语法如下：
map(function, sequence[, sequence, ...])
map 函数会对序列参数 sequence 中的每个元素调用 function 函数，返回的结果为每一个元素调用function函数的返回值
l = [11, 22, 33, 44]
def myadd(x):
return x + 10
new_n = map(myadd, l)
b = list(new_n)
print(b)
# 输出结果
[21, 32, 43, 54]
利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']：
# -*- coding: utf-8 -*-
def normalize(str):
return str.capitalize()
# 测试:
L1 = ['adam', 'LISA', 'barT', 'ROOT']
L2 = list(map(normalize, L1))
print(L2)
# 输出结果
['Adam', 'Lisa', 'Bart', 'Root']
3、filter 函数
filter函数会根据提供的函数对指定序列做筛选，其语法如下：
filter(function, iterable)
filter 函数会对于序列中的元素进行筛选，最终获取符合条件的序列
def myfunc(x):
if x > 30:
return True
else:
return False
a = [11, 22, 33]
new_a = filter(myfunc,a)
b = list(new_a)
print(b)
# 输出结果
[33]
4、reduce 函数
对于序列内所有元素进行累计操作
reduce 把一个函数作用在一个序列 [x1, x2, x3, ...] 上，这个函数必须接收两个参数， reduce 把结果继续和序列的下一个元素做累积计算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
比方说对一个序列求和，就可以用 reduce 实现：
>>> from functools import reduce
>>> def add(x, y):
... return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25
当然求和运算可以直接用Python内建函数 sum() ，没必要动用 reduce 。
但是如果要把序列 [1, 3, 5, 7, 9] 变换成整数 13579 ， reduce 就可以派上用场：
>>> from functools import reduce
>>> def fn(x, y):
... return x * 10 + y
...
>>> reduce(fn, [1, 3, 5, 7, 9])
13579
这个例子本身没多大用处，但是，如果考虑到字符串 str 也是一个序列，对上面的例子稍加改动，配合 map() ，我们就可以写出把 str 转换为 int 的函数
>>> from functools import reduce
>>> def fn(x, y):
... return x * 10 + y
...
>>> def char2num(s):
... return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
...
>>> reduce(fn, map(char2num, '13579'))
13579
整理成一个 str2int 的函数就是：
from functools import reduce
def str2int(s):
def fn(x, y):
return x * 10 + y
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
return reduce(fn, map(char2num, s))
还可以用 lambda 函数进一步简化成：
from functools import reduce
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
def str2int(s):
return reduce(lambda x, y: x * 10 + y, map(char2num, s))
也就是说，假设Python没有提供 int() 函数，你完全可以自己写一个把字符串转化为整数的函数，而且只需要几行代码！
转载自
https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014317852443934a86aa5bb5ea47fbbd5f35282b331335000
http://www.cnblogs.com/wupeiqi/articles/4943406.html
Python 函数之装饰器
1、函数
#### 第一波 ####
def foo():
print 'foo'
foo #表示是函数
foo() #表示执行foo函数
#### 第二波 ####
def foo():
print 'foo'
foo = lambda x: x + 1
foo() # 执行下面的lambda表达式，而不再是原来的foo函数，因为函数 foo 被重新定义了
2、需求
初创公司有N个业务部门，1个基础平台部门，基础平台负责提供底层的功能，如：数据库操作、redis调用、监控API等功能。业务部门使用基础功能时，只需调用基础平台提供的功能即可。如下：
############### 基础平台提供的功能如下 ###############
def f1():
print 'f1'
def f2():
print 'f2'
def f3():
print 'f3'
def f4():
print 'f4'
############### 业务部门A 调用基础平台提供的功能 ###############
f1()
f2()
f3()
f4()
############### 业务部门B 调用基础平台提供的功能 ###############
f1()
f2()
f3()
f4()
目前公司有条不紊的进行着，但是，以前基础平台的开发人员在写代码时候没有关注验证相关的问题，即：基础平台的提供的功能可以被任何人使用。现在需要对基础平台的所有功能进行重构，为平台提供的所有功能添加验证机制，即：执行功能前，先进行验证。
写代码要遵循开发封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：
- 封闭：已实现的功能代码块
- 开放：对扩展开发
如果将开放封闭原则应用在上述需求中，那么就不允许在函数 f1 、f2、f3、f4的内部进行修改代码
def w1(func):
def inner():
# 验证1
# 验证2
# 验证3
return func()
return inner
@w1
def f1():
print 'f1'
@w1
def f2():
print 'f2'
@w1
def f3():
print 'f3'
@w1
def f4():
print 'f4'
对于上述代码，也是仅仅对基础平台的代码进行修改，就可以实现在其他人调用函数 f1 f2 f3 f4 之前都进行【验证】操作，并且其他业务部门无需做任何操作。
这段代码的内部执行原理是什么呢？
单独以f1为例：
def w1(func):
def inner():
# 验证1
# 验证2
# 验证3
return func()
return inner
@w1
def f1():
print 'f1'
当写完这段代码后（函数未被执行、未被执行、未被执行），python解释器就会从上到下解释代码，步骤如下：
- def w1(func): ==>将w1函数加载到内存
- @w1
没错，从表面上看解释器仅仅会解释这两句代码，因为函数在没有被调用之前其内部代码不会被执行。
从表面上看解释器着实会执行这两句，但是 @w1 这一句代码里却有大文章，@函数名 是python的一种语法糖。
如上例@w1内部会执行一下操作：
- 执行w1函数，并将 @w1 下面的 函数 作为w1函数的参数，即：@w1 等价于 w1(f1)
所以，内部就会去执行：
def inner:
#验证
return f1() # func是参数，此时 func 等于 f1
return inner # 返回的 inner，inner代表的是函数，非执行函数
其实就是将原来的 f1 函数塞进另外一个函数中
- 将执行完的 w1 函数返回值赋值给@w1下面的函数的函数名
w1函数的返回值是：
def inner:
#验证
return 原来f1() # 此处的 f1 表示原来的f1函数
然后，将此返回值再重新赋值给 f1，即：
新f1 = def inner:
#验证
return 原来f1()
所以，以后业务部门想要执行 f1 函数时，就会执行 新f1 函数，在 新f1 函数内部先执行验证，再执行原来的f1函数，然后将 原来f1 函数的返回值 返回给了业务调用者。
如此一来， 即执行了验证的功能，又执行了原来f1函数的内容，并将原f1函数返回值 返回给业务调用着
3、装饰器参数
- 一个参数
### 一个参数
def w1(func):
def inner(arg):
# 验证1
# 验证2
# 验证3
return func(arg)
return inner
@w1
def f1(arg):
print 'f1'
- 两个参数
### 两个参数
def w1(func):
def inner(arg1,arg2):
# 验证1
# 验证2
# 验证3
return func(arg1,arg2)
return inner
@w1
def f1(arg1,arg2):
print 'f1'
- 三个参数
### 三个参数
def w1(func):
def inner(arg1,arg2,arg3):
# 验证1
# 验证2
# 验证3
return func(arg1,arg2,arg3)
return inner
@w1
def f1(arg1,arg2,arg3):
print 'f1'
- 装饰具有处理n个参数的函数的装饰器
### 装饰具有处理n个参数的函数的装饰器
def w1(func):
def inner(*args,**kwargs):
# 验证1
# 验证2
# 验证3
return func(*args,**kwargs)
return inner
@w1
def f1(arg1,arg2,arg3):
print 'f1'
- 装饰具有处理n个参数的函数的装饰器
### 装饰具有处理n个参数的函数的装饰器
def login(func):
def inner(*args, **kwargs):
print("passed user bingo")
return func(*args, **kwargs)
return inner
@login
def home():
print("Welcome to home page!")
@login
def tv(name):
print("Welcome %s to tv page!" %name)
return "gmkk"
@login
def movie(name, age):
print("Welcome %s %s to child page" %(name, age))
home()
t = tv("evescn")
print("T value ", t)
movie("evescn", 15)
# 输出结果
passed user bingo
Welcome to home page!
passed user bingo
Welcome evescn to tv page!
T value gmkk
passed user bingo
Welcome evescn 15 to child page
- 一个函数被多个装饰器装饰
### 一个函数被多个装饰器装饰
def w1(func):
def inner(*args,**kwargs):
# 验证1
# 验证2
# 验证3
return func(*args,**kwargs)
return inner
def w2(func):
def inner(*args,**kwargs):
# 验证1
# 验证2
# 验证3
return func(*args,**kwargs)
return inner
@w1
@w2
def f1(arg1,arg2,arg3):
print 'f1'
- 更吊的装饰器
### 还有什么更吊的装饰器吗？
#!/usr/bin/env python
#coding:utf-8
def Before(request,kargs):
print 'before'
def After(request,kargs):
print 'after'
def Filter(before_func,after_func):
def outer(main_func):
def wrapper(request,kargs):
before_result = before_func(request,kargs)
if(before_result != None):
return before_result;
main_result = main_func(request,kargs)
if(main_result != None):
return main_result;
after_result = after_func(request,kargs)
if(after_result != None):
return after_result;
return wrapper
return outer
@Filter(Before, After)
def Index(request,kargs):
print 'index'
def before1(*request, **kargs):
print("Before")
def after1(*request, **kargs):
print("After")
# def Filter(before_func, after_func):
# def login(main_func):
# def inner(*args, **kwargs):
# before_func()
# print("passed user bingo")
# main_func(*args, **kwargs)
# after_func()
# # return func(*args, **kwargs)
# return inner
# # return func
# return login
def Filter(before_func, after_func):
def outer(main_func):
def wrapper(*request, **kargs):
before_result = before_func(*request, **kargs)
if (before_result != None):
return before_result
main_result = main_func(*request, **kargs)
if (main_result != None):
return main_result
after_result = after_func(*request, **kargs)
if (after_result != None):
return after_result
return wrapper
return outer
@Filter(before1, after1)
def home():
print("Welcome to home page!")
@Filter(before1, after1)
def tv(name):
print("Welcome %s to tv page!" %name)
return "gmkk"
def movie(name):
print("Welcome %s to movie page" %name)
@Filter(before1, after1)
def child(name, age):
print("Welcome %s %s to child page" %(name, age))
home()
t = tv("evescn")
print(t)
child("evescn", 15)
# 输出结果
Before
Welcome to home page!
After
Before
Welcome evescn to tv page!
gmkk
Before
Welcome evescn 15 to child page
After
4、functools.wraps
上述的装饰器虽然已经完成了其应有的功能，即：装饰器内的函数代指了原函数，注意其只是代指而非相等，原函数的元信息没有被赋值到装饰器函数内部。例如：函数的注释信息
### 无元信息
def outer(func):
def inner(*args, **kwargs):
print(inner.__doc__) # None
return func()
return inner
@outer
def function():
"""
asdfasd
:return:
"""
print('func')
function()
# 输出结果
None
func
如果使用@functools.wraps装饰装饰器内的函数，那么就会代指元信息和函数
### 含元信息
import functools
def outer(func):
@functools.wraps(func)
def inner(*args, **kwargs):
print(inner.__doc__) # None
return func()
return inner
@outer
def function():
"""
asdfasd
:return:
"""
print('func')
function()
# 输出结果
asdfasd
:return:
func
转载自
http://www.cnblogs.com/wupeiqi/articles/4980620.html
