linux：python函数语句以及函数引用和装饰器

函数

所谓函数，就是把具有独立功能的代码块组织成为一个小模块，在需要的时候调用函数的使用包含两个步骤：
1.定义函数–封装独立的功能
2.调用函数–享受封装的成果 函数的作用:在开发时，使用函数可以提高编写的效率以及代码的重用‘ ’
函数： 函数是带名字的代码块，用于完成具体的工作
需要在程序中多次执行同一项任务时，你无需反复编写完成该任务的代码，而只需调用该任务的函数，让python运行其中的代码，你将发现，通过使用函数，程序编写，阅读，测试和修复都将更容易

一·1.定义函数

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

# _*_ coding:utf-8 _*_
"""
file: def_1.py
date: 2018-07-17 21:54
author: jiong
desc:


"""
# 定义好一个函数之后,只是表示这个函数封装了一段代码,如果不主动调用函数,函数是不会主动执行的
def hello():
    print 'hello1'
    print 'hello2'
    print 'hello3'
# 调用函数
hello()

# 实现两个数的减法（整数型）
def snum_1_snum(num1,num2):
     result = num1 - num2
     print '%d - %d = %d' % (num1,num2,result)
snum_1_snum(20,13)

# 实现两个数的乘法（浮点数）
def snum_2_snum(num1,num2):
    result = num1 * num2
    print '%.1f * %.1f = %.1f' % (num1,num2,result)
snum_2_snum(1.2,2.3)

二·参数的作用

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

形参和实参

形参：定义函数时，小括号中的参数，是用来接收参数用的，在函数内部作为变量使用
实参：调用函数时，小括号中的参数，是用来把数据传递到函数内部用的

函数的返回值

在程序开发中，有时候，会希望一个函数执行结束后(举例子：温度计函数，要返回给我>们当前的温度)，告诉调用者一个结果，以便调用者针对具体的结果作出后续的处理
返回值是函数完成工作后，最后给调用者的一个结果 在函数中使用return关键字可以返回结果 调用函数一方，可以使用变量来接收函数的返回结果
参数的传递：传递内存地址,并不是数字
函数返回值：返回一个数据的引用

# _*_ coding:utf-8 _*_
"""
file: def_2.py
date: 2018-07-17 21:58
author: jiong
desc:


"""
# return 表示返回，后续代码不会执行
def sum_2_mun(num1,num2):
    result = num1 + num2
    return result
    num = 100
    print 'num'
sum_result = sum_2_mun(20,10)
print sum_result

# _*_ coding:utf-8 _*_
"""
file: def_3.py
date: 2018-07-18 17:48
author: jiong
desc:


"""
# 1.定义一个函数,能够打印@组成的一条分割线
def print_line():
    print '@' * 10
print_line()

# 2.定义一个函数,打印任意一条分割线
def print_line(char):
    print char * 20
print_line('#')

# 3.定义一个函数,能够打印任意重复次数的分割线
def print_line(char,times):
    print char * times
print_line('$',15)

# 4.定义一个函数,能够打印四行分割线
# 分隔线符合需求3
def print_lines():
    row = 0
    while row < 4:
        print_line('%',10)
        row += 1
print_lines()

# 5.定义一个函数,能够打印四行分割线
# 分隔线符合需求3
def print_lines(char,times):
    """打印多行分割线

    :param char:分割线使用的分割字符
    :param times:分割线重复的次数
    """
    row = 0
    while row < 4:
        print_line(char,times)
        row += 1
print_lines('%',15)

三·局部变量和全局变量

局部变量是在函数内部定义的变量，只能在函数内部使用
全局变量是在函数外部定义的变量，(没有定义在某一个函数内)，所有函数内部都可以使用这个变量

局部变量 局部变量是在函数内部定义的变量，只能在函数内部使用 函数执行结束后，函数内部的局部变量，会被系统回收
不同的函数，可以定义相同的名字的局部变量，但是各用各的不会产生影响

局部变量的作用 在函数内部使用，临时保存函数内部需要使用的数据

1、局部变量

# _*_ coding:utf-8 _*_
"""
file: 局部变量.py
date: 2018-07-18 17:53
author: jiong
desc:


"""
def demo1():
    # 定义一个局部变量
    num = 10
    print num
# 在函数内部定义的变量,不能在其他位置使用
demo1()

def demo1():
    # 定义一个局部变量
    # 出生：执行了下方的代码后,才会被创建
    # 死亡：函数执行完后
    num = 20
    print num
    num = 10
    print num
def demo2():
    # demo1 中定义的局部变量,不能在其他函数中使用
    pass
# pass：占位
demo1()
demo2()

# 不同的函数,可以定义相同名字的局部变量,但是不会产生影响
def demo1():
    demo1_num = 10
    print demo1_num
def demo2():
    demo2_num = 20
    print demo2_num

demo1()
demo2()

2、全局变量

# _*_ coding:utf-8 _*_
"""
file: 全局变量.py
date: 2018-07-18 17:57
author: jiong
desc:


"""
# 全局变量,在函数外定义
num = 10
def demo1():
    print 'demo1=====> %d' % num
def demo2():
    print 'demo2=====> %d' % num
demo1()
demo2()

# 全局变量,在函数外定义
num = 10
def demo1():
    # 使用赋值语句,会在函数内部,定义一个局部变量
    num = 20
    print 'demo1=====> %d' % num
def demo2():
    print 'demo2=====> %d' % num
demo1()
demo2()

num = 10
def demo1():
    # 希望修改全局变量的值,使用global关键字,声明一下变量
    # global 关键字会告诉解释器后面是一个全局变量
    # 再用赋值语句时,就不会创建局部变量了
    global num
    num = 99
    print 'demo1=====> %d' % num
def demo2():
    print 'demo2=====> %d' % num

demo1()
demo2()

num = 10
title = 'westos'
name = 'jiong'
def demo():
    print '%d' % num
    print '%s' % title
    print '%s' % name

demo()

# 在开发的时候,应该把模板中的所有全局变量定义在其他函数上方
gl_num = 10
gl_title = 'westos'
gl_name = 'jiong'
def demo():
    print '%d' % gl_num
    print '%s' % gl_title
    print '%s' % gl_name


demo()

四·变量的引用

变量和数据都是保存在内存中的
在python中函数的参数传递以及返回值都是靠引用传递的

引用的概念

在python中
变量和数据是分开存储的
数据保存在内存中的一个位置
变量中保存的是数据在内存中的地址
变量中记录数据的地址，就叫做引用
使用id()函数可以查看变量中保存数据所在内存的地址

# _*_ coding:utf-8 _*_
"""
file: 引用.py
date: 2018-07-18 18:07
author: jiong
desc:


"""
# 定义一个函数,准备一个叫num变量,引用的数字10的内存地址
def test(num):
    print '在函数内部%d对应的内存地址是%d' % (num,id(num))
# 定义一个数字变量
a = 10
print 'a 变量保存数据内存的地址是%d' % id(a)

test(a)

def test(num):
    print '在函数内部%d对应的内存地址是%d' %(num,id(num))
    # 定义一个字符串变量
    result = 'hello'
    print '函数要返回数据的内存地址是%d' %(id(result))
    return result
# 定义一个数字变量
a = 10
print 'a 变量保存数据内存的地址是%d' %id(a)
r = test(a)
print '%s的内存地址是%d' %(r,id(r))

五·装饰器

概念：把一个函数当作函数,传递给函数,返回一个加强版的函数
本质上是一个返回值的函数
“在不改变原函数的基础上,给函数增加功能”

要求：在每句话的后面添加分割线

# _*_ coding:utf-8 _*_
"""
file: 装饰器.py
date: 2018-07-18 18:09
author: jiong
desc:


"""
def func1():
    print 'Have a nice day!'
# 要求：让func1函数在执行结果后添加一串$,并且不改变原函数
def outer():
    func1()
    print '$$$$$$$$$$$$$$$$'
outer()

def func1():
    print 'Have a nice day!'
def func2():
    print 'Hello python'
# 要求：让func1函数在执行结果后添加一串$,并且不改变原函数
# outer()相当于是一个“化妆师”
# 将传递进来的参数“化妆”，然后返回“化妆好了的函数”
# 这里为什么要有一个形参：因为“化妆师”可以给每个人化妆
def outer(func):
    def inner():
        func1()
        print '$$$$$$$$$$$$$$$$'
    # 将装饰好的函数返回
    return inner
# f是func1的加强版本,其实就是inner()
f = outer(func1)
f()
q = outer(func2)
q()