Python 函数

标签：f1 return 函数 Python func print def

一、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", '[email protected]'])
    msg['To'] = formataddr(["gmkk", '[email protected]'])
    msg['Subject'] = "主题"

    server = smtplib.SMTP("smtp.163.com", 25)
    server.login("[email protected]", "XXXXXX")
    server.sendmail('[email protected]', ['[email protected]', ], 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", '[email protected]'])
    msg['To'] = formataddr(["gmkk", mails])
    msg['Subject'] = "主题"

    server = smtplib.SMTP("smtp.163.com", 25)
    server.login("[email protected]", "XXXXXX")
    server.sendmail('[email protected]', [mails, ], msg.as_string())
    server.quit()


mail('[email protected]')

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、内置函数

注：查看详细猛击这里

三、局部变量全局变量

全局与局部变量

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 函数之 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

标签：f1,return,函数,Python,func,print,def
From： https://www.cnblogs.com/evescn/p/17493835.html

Python 函数

Python 函数

一、Python 函数之定义函数

1、定义一个函数

2、定义发送邮件的函数

3、函数的参数个数

4、举例

二、Python 函数之函数调用

1、调用abs函数

2、数据类型转换

3、函数名

4、内置函数

三、局部变量全局变量

全局与局部变量

四、Python 函数之 lambda、map、filter和reduce

1、lambda 函数

2、map 函数

3、filter 函数

4、reduce 函数

转载自

五、Python 函数之装饰器

1、函数

2、需求

3、装饰器参数

4、functools.wraps

转载自

相关文章

赞助商

阅读排行