python中函数的使用

一 函数的定义

所谓函数，就是把具有独立功能的代码块组织成为一个小模块，在需要的时候调用
函数的使用包含两个步骤
1.定义函数–封装独立的功能
2.调用函数–享受封装的成果

使用函数的好处：

在开发时，使用函数可以提高编写的效率以及代码的重用
函数是带名字的代码块，用于完成具体的工作
需要在程序中多次执行同一项任务时，你无需反复编写完成该任务的代码，而只需调用该任务的函数，让python运行其中的代码，你将发现，通过使用函数，程序编写，阅读，测试和修复都将更容易 

1）函数的定义规则

 def 函数名():
         函数的代码
 # def是英文define的缩写
 # 函数名称应该能够表达函数封装代码的功能，方便后续的调用
 # 函数名称的命名应该符合标识符的命名规则
     可由字母，下划线和数字组成
     不能以数字开头
     不能与关键字重名

示例：

#  如果不主动调用函数，函数是不会执行的
def say_hello():
    print 'hello1'
    print 'hello2'
    print 'hello3'
# 函数的调用
say_hello()

2）函数中的参数

    参数的作用
    函数，把具有独立功能的代码块组织成为一个小模块，在需要的时候调用
    函数的参数，增加函数的通用性，针对相同的数据处理逻辑，能够适应更多的数据
    1.在函数内部，把参数当作变量使用，进行需要的数据处理
    2.函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过
    参数传递
    实参，形参
        形参： 定义函数时，小括号中的参数，是用来接收参数使用的，
        在函数内部，是当作变量来使用的
        实参： 调用函数时使用，小括号中的参数，是用来把数据传地到函数内部的

示例：

"""
函数参数的使用
在函数名后面的小括号内填写 参数
多个参数之间使用 , 分隔
"""
# 定义函数时的变量，叫形参 形参可以任意起名字
def sum_2_sum(num1,num2):
    """                     #函数的解释，可通过 crtl + Q 来进行查看

    :param num1:
    :param num2:
    :return:

    """
    result = num1 + num2
    print '%d + %d = %d' %(num1,num2,result)

# 在调用函数的时候
# 在调用函数时传递得参数称为实参(真实的数据信息)
sum_2_sum(5,20)

3）函数的作用域

全局变量是在函数外部定义的变量，(没有定义在某一个函数内)，所有函数内部都可以使用这个变量
局部变量：在函数内部定义的普通变量，只在函数内部作用，函数执行结束
变量会自动删除（也就是说局部变量是有生命周期的，函数执行完后，就会被内存回收）

示例：全局变量和局部变量的使用

a = 1

print 'outside:',id(a)    #使用id（a）来查看变量在内存中地址，具有惟一性
def fun():
    global a # 声明a为全局变量
    a = 5
    print 'inside:',id(a)
fun()
print a
print id(a)
########## 输出的结果
outside: 36670568
inside: 36670472
5
36670472
########## 分析：使用了全局变量，那么函数的值在经过函数的计算之后记录新值，也就是说a这个变量之前是记录1这个数的地址，在函数内部重新赋值之后，它就便成5这个数的地址，并且函数执行完后不被系统内存回收。
a = 1

print 'outside:',id(a)
def fun():
    #global a # 注释掉全局变量声明
    a = 5
    print 'inside:',id(a)
fun()
print a
print id(a)
##########   输出的结果
outside: 33066088
inside: 33065992
1
33066088
##########分析：结合上面的示例，就会发现函数执行完后，局部变量的函数的生命周期也就结束，被系统回收。

4）函数的返回值

返回值：函数运算的结果，还需要进一步操作时，给一个返回值
return用来返回函数执行结果的,如果没有返回值，默认为None
python可以间接返回多个值(返回了一个元组)
一旦遇到return,函数执行结束，后面的代码不会执行

def mypow(x, y=2):
    return x ** y, x + y
    print 'hello'    #结合结果可以看出return之后的语句不会被执行

# 对元组进行解包
a, b = mypow(3)      #这个时候发现形参需要两个参数，实参只有一个，这个时候，y=2
                      为默认参数
print a, b

5）函数之四大参数
参数:形参 实参
形参：位置参数 默认参数 可变参数 关键字参数

#位置参数：形参和实参个数必须保持一致
def getInfo(name,age):
    print name,age
getInfo(age=12,name='tom')
###################  输出结果
tom 12
###################  说明顺序没有关系，变量名和输入一一对应即可

# 默认参数:形参和实参的个数可以不一致
def mypow(x,y=2):
    """
    求x的y次方，y的值默认为2
    :param x:
    :param y:
    :return:
    """
    print x**y
mypow(4)
# 默认形参可以改变
mypow(4,3)

###########
16              #默认参数y=2
64              #也可以给赋值y=3
###########


# 可变参数
def mysum(*agrs):
    """
    *args:是可变参数
     args：是元组类型数据
     args:名字可变(因为是形参 名字可变)
    :param agrs:
    :return:
    """
    print agrs
    sum = 0
    for item in agrs:
        sum += item
    print sum

#对list tuple set 解包时，只需要在变量前加 *
nums = [1,2,3,4,66,78]
nums1 =(1,2,3,4,5)
nums2 = {1,2,3}
# *nums:解包
mysum(*nums2)             #可以减少错误和工作量
mysum(1,2,3,4,5)           #也可以不使用中间变量，之间赋值

################
(1, 2, 3)
6
(1, 2, 3, 4, 5)
15
################

# 4.关键字参数
def getStuInfo(name,age,**kwargs):
    """
    **kwargs：是一个字典；可以传递任意多的key-value对
    :param name:
    :param age:
    :param kwargs:
    :return:
    """
    print name,age
    print kwargs
getStuInfo('tom',18,hobbies=['code','running'],gender ='female')

###########################
tom 18
{'gender': 'female', 'hobbies': ['code', 'running']}
########################### key-value对任意输出

6）函数的装饰器

装饰器：
“在不改变原函数的基础上，给函数增加功能”
把一个函数当作参数，返回一个替代版的函数
本质上：返回函数的函数

def desc(fun):
    def add_info():
        print 'how are you'
        fun()
        print 'I have fun'

    return add_info


# 语法糖
@desc
def login():
    print 'login....'

@desc  # login = desc(login)
def logout():
    print 'logout....'

@desc
def savemoney():
    print '存钱...'

@desc
def transferMoney():
    print '转账....'

login()
logout()
savemoney()
transferMoney()

1 带有参数的装饰器

import functools
import time

def log(kind): #kind = 'debug'
    def add_log(fun):
        @functools.wraps(fun)
        def wrapper(*args,**kwargs):
            start_time = time.time()
            res = fun(*args,**kwargs)
            end_time = time.time()
            print '<%s> [%s] 函数名:%s,运行时间:%.5f,运行的返回值结果%d' \
                  %(kind,time.ctime(),fun.__name__,end_time-start_time,res)
            return res
        return wrapper
    return add_log

# log('debug') 返回值：add_log
# add = add_log(add)
@log('debug')
def add(x,y):
    time.sleep(1)
    return x+y
print add(1,2)

2 验证用户登陆的装饰器

需求：
1.如果用户登陆成功，则执行被装饰的函数
2.如果用户登陆不成功，则执行登陆函数

import functools

login_users = ['admin', 'root']


def is_login(fun):
    @functools.wraps(fun)
    def wrapper(*args, **kwargs):
        # 判断要写博客的这个用户是否登陆成功
        if kwargs.get('name') in login_users:
            res = fun(*args, **kwargs)
            return res
        else:
            res = login()
            return res
    return wrapper


@is_login
def writeBlog(name):
    return '编写博客'


def login():
    return '登陆。。。'

print writeBlog(name='111')

3 带有多个装饰器的函数

需求1：用户登陆验证的装饰器is_login
1 如果用户登陆成功, 则执行被装饰的函数;
2 如果用户登陆不成功, 则执行登陆函数
需求: 判断登陆用户是否未管理员is_admin(此处管理员只有一个为：admin用户)
1 如果用户为管理员, 则执行被装饰的函数;
2 如果用户不是管理员, 则报错;

import functools

login_users = ['admin', 'root']

def is_admin(fun):
    @functools.wraps(fun)
    def wrapper(*args,**kwargs):
        if kwargs.get('name') == 'admin':
            res = fun(*args,**kwargs)
            return res
        else:
            return 'Error：您没有权限访问该网站'
    return wrapper


def is_login(fun):
    @functools.wraps(fun)
    def wrapper(*args, **kwargs):
        # 判断要写博客的这个用户是否登陆成功
        if kwargs.get('name') in login_users:
            res = fun(*args, **kwargs)
            return res
        else:
            res = login()
            return res
    return wrapper


@is_login
@is_admin
def writeBlog(name):
    return '编写博客'


def login():
    return '登陆。。。'

print(writeBlog(name='root'))