【12】python之函数

 函数

面向对象：类-》class
面向过程：过程-》def
函数式编程：函数-》def

1.代码重用

2.易维护

3.可扩展性

例1

'''
1.面向对象：类-》class
2.面向过程：过程-》def
3.函数式编程：函数-》def
'''
#过程
def func1(x):
    """test"""
    print("1%s"%x)
    return x
#函数
def func2(x):
    """test"""
    print("2%s"%x)

y=5*func1(1)
print("2",y)

例2

import time
def file(a):
    time_format = "%Y-%m-%d %X"#时间标准格式
    time_current = time.strftime(time_format)#显示时间
    with open("a.txt", "a+", encoding="utf-8") as f:
        f.write("%s end action\n"%time_current)
    print("in the test%s"%a)

def test1():
    file(1)

def test2():
    file(2)

def test3():
    file(3)

test1()
test2()
test3()

返回值

函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束

1.没有返回值，返回None

2.返回一个值，返回object

3.返回多个值，返回元组

def test1():
    print("test1")
def test2():
    print("test2")
    return 1
def test3():
    print("test3")
    return 1,"hello",["1","2"],{123:"dsaf"}
a = test1()
b = test2()
c = test3()
print(a)
print(b)
print(c)

形参与实参

# *args接收位置参数，转换为元组
# **kwargs接收关键字参数，转换为字典

def test1(x,y,z):
    print(x,y,z)
def test2(x,y="123"):
    return 1,"hello",["1","2"],{123:"dsaf"}
# *args接收位置参数，转换为元组
# **kwargs接收关键字参数，转换为字典
def test3(*args):
    return args
def test4(**kwargs):
    return kwargs,kwargs['name'],kwargs['age']
x=2
y=1
z=3
test1(y=y,x=x,z=z)#x,y是形参，1,2是实参
#test1(x=1,2,3)#会报错
#test1(3,x=2,3)#会报错
# test1(3,y=2,3)#会报错
#test1(3,3,y=2)#会报错
#test1(3,z=3,y=2)#不报错
b = test2(1)
c = test3(1,2,3,4,5)#c = test3(*[1,2,3,4,5])
d = test4(name='abc',age=10,sex='n')#把n个关键字参数转换为字典方式
print(b)
print(c)
print(d)

全局与局部变量

在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

当全局变量与局部变量同名时：

在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

name = "abc"

def change_name():
    # 强制更改全局变量或者定义全局变量，绝对不要使用
    # global name
    name = "abc1"
    def change_name2():
        name = "abc2"
        print("第3层打印", name)
    change_name2()  # 调用内层函数
    print("第2层打印", name)
change_name()
print("最外层打印", name)

除了字符串和整数不能再局部更改，其他的数据类型（列表、集合、字典）可以更改。

递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

1 def calc(n):
2     print(n)
3     if int(n / 2) == 0:
4         return n
5     return calc(int(n / 2))
6 
7 calc(10)

 

高阶函数

 

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。 

def add(x, y, f):
    return f(x) + f(y)

res = add(3, -6, abs)
print(res)

 

 ps.函数式编程

函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。

函数式编程中的函数这个术语不是指计算机中的函数（实际上是Subroutine），而是指数学中的函数，即自变量的映射。也就是说一个函数的值仅决定于函数参数的值，不依赖其他状态。比如sqrt(x)函数计算x的平方根，只要x不变，不论什么时候调用，调用几次，值都是不变的。