[Python知识库] Python学习03：函数相关

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Python知识库 -> Python学习03：函数相关 -> 正文阅读

[Python知识库]Python学习03：函数相关

一、定义函数

定义一个由自己想要功能的函数，以下是简单的规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号 : 起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return相当于返回 None。

在这里插入图片描述
一个简单的函数：

def hello():
    print("Hello World!")
hello()
## 结果为Hello World!

一个简单的传参函数：

# 比较两个数，选择一个最大的
def max(a, b):
    if a > b:
        return a
    else:
        return b
 
a = 4
b = 5
print(max(a, b))
## 结果为5

【补充】函数式编程和面向过程编程的区别：

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象：对函数进行分类和封装，让开发“更快更好更强…”

二、函数参数

1. 普通参数

1.形参变量只有在被调用时才分配内存单元，在调用结束后，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。

2.实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此，应预先使用赋值、输入等办法使用参数获得确定值。

3.实参与形参位置一一对应。

在这里插入图片描述
2. 默认参数

def func(name, age=18):
    print("%s:%s" % (name, age))

# 指定参数
func('wupeiqi', 19)
# 使用默认参数
func('alex')
## 结果为wupeiqi:19
## alex:18

def func(*args):
    print(args)

# 执行方式一
func(11, 33, 4, 4454, 5)
# 执行方式二
li = [11, 2, 2, 3, 3, 4, 54]
func(*li)  # 遍历列表中的元素
## 结果为(11, 33, 4, 4454, 5)
## (11, 2, 2, 3, 3, 4, 54)

3. 动态参数：

# 参数组：**字典  *列表
def test(x, *args):
    print(x)
    print(args)

test(1, ['z', 'y', 'z'])  # 将列表当成一个整体传给args
## 结果为1
## (['z', 'y', 'z'],)
test(1, *['z', 'y', 'z'])  # 加*可以遍历取到其值
## 结果为1
## ('z', 'y', 'z')

一个简单的例子：

def test(* params):
    print('参数的长度是：', len(params))
    print('第二个参数是：', params[1])

test(1, 'zhai', 2000, [2, 5, 0])  # 打包成元组传给* params
## 结果为 参数的长度是： 4
## 第二个参数是： zhai

位置参数和关键字：

def test(x, *args, **kwargs):
    print(x)
    print(args)
    print(kwargs)

test(1, 2, 3, 1, 1, y=2, z=6)  # 位置参数和关键字
## 结果为1  位置参数一一对应
## (2, 3, 1, 1)
## {'y': 2, 'z': 6}  关键字传值

三、函数返回值

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，以下实例演示了 return 语句的用法：

# 定义求和函数
def sum(arg1, arg2):
    # 返回2个参数的和."
    total = arg1 + arg2
    print("函数内 : ", total)
    return total

# 调用sum函数
total = sum(10, 20)
print("函数外 : ", total)

四、局部变量与全局变量

局部变量的作用域在函数内。

count = 0  # 定义全局变量count

def MyCount():
    count = 100000  # 函数内部定义的变量作用域在函数内
    print(count)

print(count)  # 在函数外值仍未改变  #结果为0
MyCount()  ## 100000

若想在函数内部使用全局变量，必须在前面加上global。

count = 0  # 定义全局变量count

def MyCount():
    global count  # 使用全局变量count
    print(count)

print(count)  ## 结果为0
MyCount()  ## 0

五、嵌套函数和闭包

1. 嵌套函数

python支持在函数内定义另一个函数。

def func1():
    print("func1 is running!")

    def func2():
        print("func2 is running!")

    func2()

func1()  # 调用func1方法
## 结果为func1 is running!
## func2 is running!

如果直接调用func2方法会出现如下所示的情况，编译器无法找到对应的func2方法，于是它认为该方法没有被定义。
在这里插入图片描述

2. 闭包

简单来说就是一个函数定义中引用了函数外定义的变量，并且该函数可以在其定义环境外被执行。这样的一个函数我们称之为闭包。

一个简单的例子：

def fun_x(x):
    def fun_y(y):
        return x * y
    return fun_y  # 此处不加括号是为了返回函数值

# 第一种赋值方式
res = fun_x(2)
print(type(res))  # 这里的res是一个函数类型，所以我们还需要对它进行调用
print(res(5))

# 第二种赋值方式
print(fun_x(2)(5))

运行结果为：
在这里插入图片描述
在嵌套函数的情况下，内部函数引用外部函数的局部变量。该例中，fun_y函数中引用了fun_x的局部变量x，所以fun_y函数就是闭包。fun_y是内部函数，fun_x是内部函数的外部作用域但不是全局作用域。
为了加深理解，引入了下一个例子：

def Fun1():
    x = 5
    def Fun2():
        x *= x
        return x
    return Fun2()

Fun1()

上述的代码运行时会报错：UnboundLocalError: local variable ‘x’ referenced before assignment。赋值前引用了局部变量“x”，解释器不明白x是全局变量还是局部变量，也可能是局部变量同全局变量同名了。
【解决方案1】将变量改为列表类型。
因为函数变量的存储是放在栈里面的，而列表是不存在栈中的，所以列表元素可以被内置函数所引用。

def Fun1():
    x = [5]
    def Fun2():
        x[0] *= x[0]
        return x[0]
    return Fun2()

print(Fun1())
## 结果为25

【解决方案2】使用nonlocal关键字。
nonlocal声明的变量不是局部变量,也不是全局变量,而是外部嵌套函数内的变量。
nonlocal关键字修饰变量后标识该变量是上一级函数中的局部变量，如果上一级函数中不存在该局部变量，nonlocal位置会发生错误（最上层的函数使用nonlocal修饰变量必定会报错）。

def Fun1():
    x = 5
    def Fun2():
        nonlocal x  # 只能用于嵌套函数中，并且外层函数中定义了相应的局部变量
        x *= x
        return x
    return Fun2()

print(Fun1())
## 结果为25

六、匿名函数

python 使用 lambda 来创建匿名函数。所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
使用 Lambda 表达式可以使代码变的更加简洁紧凑。

函数只有一个参数的情况：

####################### 普通函数 ######################
# 定义函数（普通方式）
def ds(x):
    return 2 * x + 1

print(ds(5))
## 结果为11

# 用lambda简化函数
g = lambda x : 2 * x + 1
print(g)  # lambda返回的是函数类型
print(g(5))
## 结果为<function <lambda> at 0x000001C21921A280>
## 11

函数中有两个参数的情况：

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

print(add(5, 7))

g = lambda x, y : x + y
print(g(5, 7))
## 结果为12

lambda表达式的作用：

python写一些执行脚本时，使用lambda就可以省下定义函数过程，比如说我们只是需要写个简单的脚本来管理服务器时间，就不需要专门定义一个函数然后再写调用，使用lambda就可以使得代码更加精简。
简化代码的可读性，省去def步骤。
对于一些比较抽象并且整个程序执行下来只需要调用一两次的函数，有时候给函数起个名字也是比较头疼的问题，使用lambda就不需要考虑命名的东西。

七、递归

【例1】利用函数编写斐波那契数列（如下图所示）。
在这里插入图片描述

# 递归实现算出第n次的结果
def fibonacci(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 2) + fibonacci(n - 1)
        
res = fibonacci(5)
print(res)

【例2】分别用递归方式和非递归方式实现求一个数的阶乘。
递归方法：

def factorial_recur(x):
    if x == 1:  # 记得写递归出口
        return 1
    else:
        return x * factorial_recur(x - 1)

number = input("请输入一个正整数用来求其阶乘：")
res = factorial_recur(int(number))
print("%s的阶乘为%s" % (number, res))
## 输入5结果为120

非递归方法：

def factorial(x):
    res = 1
    for i in range(1, x+1):
        res = i * res
    print(res)

n = input("请输入一个正整数用来求其阶乘：")
factorial(int(n))
## 输入5结果为120

【例3】递归实现汉诺塔。
在这里插入图片描述

def Hanoi(n, a, b, c):  # n代表盘子数,借助B从A移动到C
    if n == 1:  # 递归出口
        print(a, '-->', c)
    else:
        Hanoi(n - 1, a, c, b)  # 将前n-1个借助C从A移动到B
        print(a, '-->', c)  # 将最底下的一个盘子从A移动到C上
        Hanoi(n - 1, b, a, c)  # 将暂时存放在B上的前n-1个借助A放到C上


num = int(input("请输入汉诺塔的层数："))

Hanoi(num, 'A', 'B', 'C')  # 注意字符串实需加''符号

运行结果为：
在这里插入图片描述

八、内置函数

在这里插入图片描述
注：查看详细，点击官方说明文档

1. open( )函数

open函数用于文件处理。
操作文件时，一般需要经历如下步骤：①打开文件；② 操作文件

open打开文件

文件句柄 = open('文件路径', '模式')

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

打开文件的模式有：

r ，只读模式【默认】
w，只写模式【不可读；不存在则创建；存在则清空内容】
x，只写模式【不可读；不存在则创建，存在则报错】
a，追加模式【可读；不存在则创建；存在则只追加内容】

"+" 表示可以同时读写某个文件：

r+，读写【可读，可写】
w+，写读【可读，可写】
x+ ，写读【可读，可写】
a+，写读【可读，可写】

"b"表示以字节的方式操作：

rb 或 r+b
wb 或 w+b
xb 或 w+b
ab 或 a+b
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型。

class file(object)
    def close(self): # real signature unknown; restored from __doc__
        关闭文件
 
    def fileno(self): # real signature unknown; restored from __doc__
        文件描述符  
        return 0    
 
    def flush(self): # real signature unknown; restored from __doc__
        刷新文件内部缓冲区
        pass
 
    def isatty(self): # real signature unknown; restored from __doc__
        return False
 
    def next(self): # real signature unknown; restored from __doc__
        获取下一行数据，不存在，则报错
        pass
 
    def read(self, size=None): # real signature unknown; restored from __doc__
        读取指定字节数据
        pass
 
    def readinto(self): # real signature unknown; restored from __doc__
        读取到缓冲区，不要用，将被遗弃
        pass
 
    def readline(self, size=None): # real signature unknown; restored from __doc__
        仅读取一行数据
        pass
 
    def readlines(self, size=None): # real signature unknown; restored from __doc__
        读取所有数据，并根据换行保存值列表
        return []
 
    def seek(self, offset, whence=None): # real signature unknown; restored from __doc__
        指定文件中指针位置
        pass
 
    def tell(self): # real signature unknown; restored from __doc__
        获取当前指针位置
        pass
 
    def truncate(self, size=None): # real signature unknown; restored from __doc__
        截断数据，仅保留指定之前数据
        pass
 
    def write(self, p_str): # real signature unknown; restored from __doc__
        写内容
        pass
 
    def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__
        将一个字符串列表写入文件
        pass
 
    def xreadlines(self): # real signature unknown; restored from __doc__
        可用于逐行读取文件，非全部
        pass

2. filter( )函数

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将下划线返回 True 的元素放到新列表中。
语法格式为：

filter(function, iterable)
# function -- 判断函数
# iterable -- 可迭代对象
# 返回值为一个迭代器对象

一个简单的例子：

v1 = filter(None, [1, 0, False, True])
print(v1)  # 返回了一个过滤器对象
v2 = list(filter(None, [1, 0, False, True]))  # 转换成list类型
print(v2)  # 过滤掉为0和False的值

def odd(x):
    return x % 2  # 如果是偶数的话，返回的就是0；有返回值1的都是奇数

v3 = print(odd(10))  # 10是偶数，所以返回0

v4 = list(filter(lambda x : x % 2, range(10)))
print(v4)

运行结果为：
在这里插入图片描述

3. map( )函数

map() 函数会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
一个简单的例子：

def square(x):         # 计算平方数
      return x ** 2
v1 = list(map(square, [1, 2, 3, 4, 5]))  # 计算列表各个元素的平方
print(v1)
## 结果为[1, 4, 9, 16, 25]

v2 = list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))
print(v2)  # 输出的结果是把range(10)中每个对象放入前面的函数中做处理，再输出
## 结果为[1, 4, 9, 16, 25]