Python-03函数使用-CSDN博客

本文链接：https://blog.csdn.net/lanxsx/article/details/138847612

1.函数

1.1.什么是函数

Python中函数的应用非常广泛，前面章节中我们已经接触过多个函数，比如 input() 、print()、range()、len() 函数等等，这些都是 Python 的内置函数，可以直接使用。

除了可以直接使用的内置函数外，Python 还支持自定义函数，将一段有规律的、可重复使用的代码定义成函数，从而达到一次编写、多次调用的目的。

Python 提供了一个功能，即允许我们将常用的代码以固定的格式封装（包装）成一个独立的模块，只要知道这个模块的名字就可以重复使用它，这个模块就叫做函数

函数与方法的区别：

直接调用的是函数
通过对象点出来的是方法

nums = [1, 2, 3]
print(len(nums))  # 函数
nums.append(4)    # 方法

1.2.函数的定义

定义函数，也就是创建一个函数，可以理解为创建一个具有某些用途的工具。定义函数需要用 def 关键字实现，具体的语法格式如下：

def 函数名(参数列表):
    #实现特定功能的多行代码
    [return [返回值]]

其中，用 [] 括起来的为可选择部分，即可以使用，也可以省略。

此格式中，各部分参数的含义如下：

函数名：其实就是一个符合 Python 语法的标识符，但不建议读者使用 a、b、c 这类简单的标识符作为函数名，函数名最好能够体现出该函数的功能。
形参列表：设置该函数可以接收多少个参数，多个参数之间用逗号（ , ）分隔。
[return [返回值] ]：整体作为函数的可选参参数，用于设置该函数的返回值。也就是说，一个函数，可以用返回值，也可以没有返回值，是否需要根据实际情况而定。

注意：在创建函数时，即使函数不需要参数，也必须保留一对空的“()”，否则 Python 解释器将提示“invaild syntax”错误。另外，如果想定义一个没有任何功能的空函数，可以使用 pass 语句作为占位符。

示例一：入门案例

def add():
    """函数方法注释"""
    print("hello python")
add()

1.3.函数的参数传递

通常情况下，定义函数时都会选择有参数的函数形式，函数参数的作用是传递数据给函数，令其对接收的数据做具体的操作处理。

在使用函数时，经常会用到形式参数（简称“形参”）和实际参数（简称“实参”），二者都叫参数，之间的区别是：

形式参数：在定义函数时，函数名后面括号中的参数就是形式参数:

#定义函数时，这里的函数参数 obj 就是形式参数
def demo(obj):
    print(obj)

实际参数：在调用函数时，函数名后面括号中的参数称为实际参数，也就是函数的调用者给函数的参数：

a = "Zking"
#调用已经定义好的 demo 函数，此时传入的函数参数 a 就是实际参数
demo(a)

实参和形参的区别，就如同剧本选主角，剧本中的角色相当于形参，而演角色的演员就相当于实参。

示例二：定义一个函数，传入一个名字xx，输出你好，xx

# 注意：方法名称定义不要使用驼峰命名，请使用下划线方法
# 错误方式：getUser()
# 正确方式：get_user()
def get_user(name):
    print(f"学员名称：{name}")
    
# 错误方式：get_user()
# 正确方式：get_user("张三")
get_user('张三')

调用有参函数时，不传递参数，提示错误如下： TypeError: get_user() missing 1 required positional argument: 'name'

代码在编写之间不会出现报错，只有在运行期间才会出现错误。

示例三：定义一个函数，输出两个数字相加的结果

def add(a, b):
    return a + b

print(add(1,2))
print(add('my name is',' zhangsan'))

传递不同类型的参数：

print(add(1,'zhangsan'))

运行提示错误： TypeError: unsupported operand type(s) for +: 'int' and 'str'

Python对于参数的传入是没有类型限制的，不过可以通过给参数添加类型，提示调用时应传入的类型

def res(a: int, b: int):
	return a+b

1.4.传参的几种情况

位置传参

res(1, 2)

关键字传参

res(a=1, b=2)
res(b=10, c=5)

缺省参数

def add(a: int, b: int = 10):
    return a + b
print(add(1))

参数具备默认值的时候可以不传，具备默认值的参数需要放在没有默认值的参数后面。

可变参数

单个*号的可变参数方式，传入得到的是一个元组。

def my_max(*nums):
    print(nums)
    val = nums[0]  		# 获取第一个元素
    for i in nums[1:]:  # 通过切片的方式排除掉第一个元素
        val = val if val > i else i  # 通过三元运算符比较最大值
    return val

print(my_max(1, 2, 3))

两个**号的可变参数方式，传入得到的是一个字典。

def my_max(**nums):
    print(nums)
    val=0
    # for i in nums.values():  # nums.values()获取字典中所有的值
    # for i in nums.keys():     # nums.keys()获取字典中所有的键
    # for i in nums.items():    # num.items()获取字典中的键值对，元组方式
    #     print(f'items:{i},key:{i[0]},value:{i[1]}')
    for k,v in nums.items():    # num.items()获取字典中的键值对，分别获取k和v
        print(f"key={k},value={v}")
        
# 错误方式：
# my_max(1,2,3,4,5)
# 正确方式：
my_max(a=1,b=2,c=3)

1.5.函数的返回值

Python中，用 def 语句创建函数时，可以用 return 语句指定应该返回的值，该返回值可以是任意类型。需要注意的是，return 语句在同一函数中可以出现多次，但只要有一个得到执行，就会直接结束函数的执行。

Python 函数可以返回多个值，多个值以元组的方式返回（也可以通过字典返回自定义结果）:

def res(*nums: int):
    max = nums[0]
    min = nums[0]
    sum = nums[0]
    for i in nums[1:]:
        max = max if max > i else i
        min = min if min < i else i
        sum += i
    #return sum, min, max  # 元组方式返回
    return {  			   # 字典方式返回
        '总和': sum,
        '最大值': max,
        '最小值': min
    }

print(res(1, 2, 3, 4, 5, 6, 7, 8, 9))

1.6.函数的注释

其实，函数的注释（说明文档），本质就是一段字符串，只不过作为说明文档，字符串的放置位置是有讲究的，函数的说明文档通常位于函数内部、所有代码的最前面。

def add(a, b):
    """
    返回两个数相加的和
    :param a: 参数数字a
    :param b: 参数数字b
    :return: 和
    """
    return a + b

查看python中关于函数的说明： help()

1.7.其他

1.7.1.函数嵌套

def a(a, b):
    return a + b


def b(c, d):
    return a(c, d) / 2


print(b(4, 8))

1.7.2.变量作用域

所谓作用域（Scope），就是变量的有效范围，就是变量可以在哪个范围以内使用。有些变量可以在整段代码的任意位置使用，有些变量只能在函数内部使用，有些变量只能在 for 循环内部使用。

变量的作用域由变量的定义位置决定，在不同位置定义的变量，它的作用域是不一样的。

在函数内部定义的变量，它的作用域也仅限于函数内部，出了函数就不能使用了，我们将这样的变量称为局部变量（Local Variable）。

def demo():
    add = "zking"
    print("函数内部 add =",add)
demo()
print("函数外部 add =",add)

除了在函数内部定义变量，Python 还允许在所有函数的外部定义变量，这样的变量称为全局变量（Global Variable）。

add = "zking"
def text():
    print("函数体内访问：",add)
text()
print('函数体外访问：',add)

1.7.3.递归调用

示例：计算n+1的和

def res(target: int):
    if target == 1:
        return 1
    return target + res(target - 1)

print(res(2))

示例：斐波那契数列

# 1,1,2,3,5,8,13,21,34,55,...
def fb(target: int):
    if target == 1 or target == 2:
        return 1
    return fb(target - 1) + fb(target - 2)

print(fb(10))

2.lambda表达式

lambda 表达式，又称匿名函数，常用来表示内部仅包含 1 行表达式的函数。如果一个函数的函数体仅有 1 行表达式，则该函数就可以用 lambda 表达式来代替。

lambda 表达式的语法格式如下：

lambda  参数 : 执行操作/返回值

入门示例：

# 未简写方式：
def res():
    return 10
    
# 简写方式：
res1 = lambda: 10

def res(a):
    return a+10
print(res(1))

res2=lambda a:a+10
print(res2(10))

def res(a,b):
    return a if a>b else b

res3=lambda a,b: a if a>b else b
print(res3(10,5))

示例：使用 lambda 对字典数据进行排序

通过sort方法实现对列表的排序：

nums=[1,6,5,2,3,4]
nums.sort()  			  #升序
nums.sort(reverse=False)  #降序
print(nums)

使用 lambda 对字典数据进行排序：

persons = [
    {"name": "张三", "age": 20},
    {"name": "李四", "age": 17},
    {"name": "王麻子", "age": 21}
]
persons.sort(key=lambda p:p["age"],reverse=True)
print(persons)

示例：将一个元素中所有的值翻倍 map

nums=[1,2,3,4,5,6,7,8]
m=map(lambda a:a*2,nums)
for i in m:
    print(i)

示例：让列表中的对应位置进行相加

nums1=[1,2,3,4,5,6,7,8]
nums2=[2,3,4,5,6,7,8,9]
m1=map(lambda a,b:a+b,nums1,nums2)
for i in m1:
    print(i)

示例：对列表进行筛选

nums3=[1,2,3,4,5,6,7,8]
f=filter(lambda a:a>5,nums3)
for i in f:
    print(i)