Python---函数

已于 2024-08-28 11:37:57 修改
阅读量803 收藏 3
点赞数 4
分类专栏： python 文章标签： python 开发语言
于 2024-08-24 18:28:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhoutong2323/article/details/141499898
版权

文章目录

前言

 在python中，函数的应用非常广泛，在前面我们已经多次接触过函数，例如用于输出的print()函数，用于输入的函数input()，以及生成一系列整数的range()函数，这些都是python内置的标准函数，可以直接使用，除了可以直接使用标准函数外，python中还支持自定义函数，即通过将一段规律的，重复的代码定义为函数，来达到一次编写，多次调用的目的。使用函数可以提高代码的重复利用率。

一.函数基础

函数创建

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

def 函数名(【形式参数】):
    函数中的代码

函数调用 

 调用函数也就是执行函数。调用函数就i相当于使用创建的工具，调用函数的基本语法如下：

函数名(【实际参数】)
参数：用于指定各个参数的值，如果需要传递多个参数值，可以使用逗号隔开

二.参数 

参数分类

在Python中，函数定义时可以包含形式参数（也称为形参），这些参数是函数定义时声明的，用于接收函数调用时传入的实际参数（也称为实参）的值。

  • 形式参数是函数定义的一部分，用于指定函数在执行时所需的输入。它们通常用于在函数体内引用传递给函数的值。
  • 实际参数是函数调用时提供给函数的值。它们可以是字面值、变量、表达式等，用于实际传递给函数的形式参数。

位置参数

函数中的位置参数是指在定义函数时，按照参数的顺序进行传递的参数。它们在调用函数时必须以相同顺序传递给函数，否则会导致调用出错。

def greet(name, age):
    print("Hello,", name)
    print("You are", age, "years old.")

greet("Alice", 25)

在以上示例中，函数greet有两个位置参数name和age。在调用函数greet时，我们按照参数的顺序将值传递给它。因此，"Alice"会被赋给name，25会被赋给age。 

默认参数

在Python函数中，可以为参数提供默认值，这些参数被称为默认参数。如果调用函数时没有为这些参数提供值，那么就会使用默认值。

以下是一个使用默认参数的函数的示例：

def greet(name, message="Hello"):
    print(message, name)

在这个例子中，函数greet有两个参数：name和message。message参数被设置为默认值"Hello"。当调用函数时，如果只提供了name参数，而没有提供message参数，那么将会使用默认值"Hello"，如果提供了message参数，那么将会使用提供的值。

注意：默认参数只能使用不可变数据类型。

可变参数

在Python中，函数的可变参数是指在函数定义时，参数的数量是可变的，可以传入任意数量的参数。Python中有两种方式定义可变参数：*args和**kwargs。

使用*args可以接收任意数量的位置参数，这些参数会被封装成一个元组。下面是一个例子：

def sum_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total
print(sum_numbers(1, 2, 3))  # 输出：6

在这个例子中，sum_numbers函数使用了*args来接收任意数量的位置参数。在函数内部，它把接收到的所有参数封装成一个元组，并对这个元组中的每个元素进行求和操作 

 关键字参数

使用**kwargs可以接收任意数量的关键字参数，这些参数会被封装成一个字典。下面是一个例子：

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")
print_info(name="Alice", age=25, city="New York")

  在这个例子中，print_info函数使用了**kwargs来接收任意数量的关键字参数。在函数内部，它把接收到的所有参数封装成一个字典，并遍历打印出每个键值对。

参数传递 

引用传递

当我们将一个可变对象作为参数传递给函数时，实际上是将该对象的引用（内存地址）传递给函数。这意味着在函数中修改参数的值会影响到原始对象的值。

def change_list(lst):
    lst.append(4)

my_list = [1, 2, 3]
change_list(my_list)
print(my_list)  # 输出结果为[1, 2, 3, 4]，原始对象my_list被修改

值传递

当我们将不可变变量作为参数传递给函数时，实际上是将该变量的值进行复制并传递给函数。这意味着在函数中修改参数的值不会影响到原始变量的值。

def change_value(num):
    num += 1
x = 10
change_value(x)
print(x)  # 输出结果为10，原始变量x的值没有被修改

三.变量

在Python中，全局变量是在整个程序中都可以访问的变量，而局部变量则是在特定的函数或代码块中定义的变量，只能在其所在的范围内访问。

例如，下面的代码演示了全局变量和局部变量的概念：

# 全局变量
global_var = 10
def my_function():
    # 局部变量
    local_var = 20
    print("局部变量 local_var =", local_var)
    # 访问全局变量
    print("全局变量 global_var =", global_var)
my_function()
# 访问全局变量
print("全局变量 global_var =", global_var)
print("局部变量 local_var =", local_var)

区别1：局部变量无法在全局被调用 

上面的案例输出结果如下， 当我们在函数外调用局部变量时会提示局部变量未被定义不可调用。

区别2：若函数未声明变量为全局变量，那么函数中的全局变量会被当做局部变量。

函数中无法直接修改全局变量的值，要在函数中修改全局变量的值，需要使用global关键字声明该变量为全局变量。global 关键字的作用是告诉Python，在函数内部你想要修改的是全局作用域中的变量，而不是局部变量。

演示案例：fn()函数中的num是和全局变量num重名的局部变量，尽管函数尝试给全局变量赋值，全局变量也不会改变，而modify_fn()函数中声明了num是全局变量，然后可以直接修改该变量的值

def fn():
    num = -100
    print(f"函数中全局变量num={num}")

def modify_fn():
    global num
    num = 0
    print(f"函数中全局变量num={num}")

num = 100
fn()
modify_fn()
print(f"全局变量num修改后={num}")

四.lamda表达式

在Python中，lambda表达式是一种快速定义简单函数的方式。它允许我们在不使用def关键字的情况下定义一个小型的匿名函数。

lambda表达式的语法如下：

 lambda 参数列表: 表达式

 下面是一个简单的例子，用lambda表达式实现了一个求平方的函数：

def fn(num):
    num = num**2
    print(num)
square = lambda x: fn(x)
#调用lambda表达式
square(2)  #输出结果是4

lambda函数使用场景

  • map()函数中使用lambda函数：

map()函数接受一个函数和一个或多个可迭代对象作为参数，将函数应用于每个可迭代对象的对应元素，然后返回一个包含结果的新的可迭代对象。

numbers = [1, 2, 3, 4, 5]
doubled_numbers = list(map(lambda x: x * 2, numbers))
print(doubled_numbers)

输出：
[2, 4, 6, 8, 10]

在这个例子中，lambda函数定义为lambda x: x * 2，表示将输入的x乘以2。然后，map函数将这个lambda函数应用到numbers列表的每个元素上，返回一个生成器对象。通过将这个生成器对象转换为列表对象，我们获得了每个元素都乘以2的新列表。最后，使用print函数打印出这个新列表 

  • filter()函数中使用lambda函数：

filter()函数会将sequence中的元素逐个传入function函数中进行判断，如果返回值为True，则该元素被保留在新的序列中，否则被过滤掉。filter()函数的用法为：

filter(函数, 序列)

结合lambda函数，可以使用filter函数进行一些简单的筛选操作，下面是一个示例：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)
输出 
[2, 4, 6, 8, 10]
  •  sorted()函数中使用lambda函数

sorted函数用于对可迭代对象进行排序并返回一个新的排序后的列表。它可以接受一个可迭代对象作为参数，例如列表、元组、字符串等。sorted函数的语法如下：

sorted(iterable, key=None, reverse=False)

iterable：表示要排序的可迭代对象，例如列表、元组等。
key：可选参数，用于指定一个函数来作为排序的关键字
reverse：可选参数，用于指定排序的顺序。默认值为False-->升序排序；为True-->降序排序。

下面是一个结合lambda函数的sorted函数的例子，对一个列表中的元素进行排序：

numbers = ["1234","123","12"]
sorted_numbers = sorted(numbers, key=lambda x: len(x))
print(sorted_numbers)
输出结果为：
['12', '123', '1234']

sorted()函数将lambda函数作为排序依据 (即字符串长度)，然后执行sorted函数依据字符串长度排序。最后按照升序排序后的解雇输出。

 易用场景

def operate(fn,num1,num2):
    return fn(num1,num2)
result = operate(lambda num1,num2:num1+num2,10,20)
print(result)

 五.递归函数

递归函数是在函数内部调用自身的函数。递归函数通常包含两个部分：基本情况和递归情况。基本情况是当函数满足某个条件时，不再调用自身，而是返回一个结果。递归情况是函数调用自身以解决一个更小的问题，直到达到基本情况。

演示案例：利用递归函数计算10以内自然数之和

def sum(n):
    if n <=0:
        return 0
    else:
        return n+sum(n-1)
print(f"10以内自然数之和是：{sum(10)}")
分析：
sum(10)=10+sum(9)
sum(9)=9+sum(8)
sum(8)=8+sum(7)
.....
sum(1)=1+sum0)
sum(0)=0

最终结果：10+9+8+....1+sum(0)=10+9+8+....1+0=55

 演示案例：斐波那契数列

def feibonaci(n):
    if n==1 or n==0:
        return 1
    else:
        return feibonaci(n-1)+feibonaci(n-2)
n = int(input("请输入斐波那契数列项数："))
print(f"斐波那契数列中第{n}项的值是：{feibonaci(n)}")

六,函数练习 

编写一个函数，计算一个整数各个数字之间的和：输入234-->输出 9

def sum(n):
    sum = 0
    while n > 0:
        #n=403,n整除10后，n=40,然后再次进入循环，
        sum += n%10
        n //=10
    print(sum)
n = int(input("请输入一个随机数："))
sum(n)

编写一个程序测试输入的数是否是回文数(反向数和顺向数一样)

#定义reverse(0函数将整数各数字反转保存到列表
def reverse(n,ls):
    while n > 0:
        #n=403,n除以10求余数=3并添加到列表中
        ls.append(n%10)
        #n=403,n整除10后，n=40,然后再次进入循环，
        n = n//10

def isPalindrome(n,ls):
    reverse_num = 0
    m = 1
    # ls经过reverse函数反转后从[4,0,3]-->[3,0,4]
    for i in ls:
        #i=3->reverse_num=3*10二次方=300，再次进入循环
        reverse_num += i*10**(len(ls)-m)
        m +=1
    #经过for循环后，reverse_num=300+0+4=304
    if reverse_num == n:
        print("输入的数是一个回文数")
    else:
        print("输入的数不是一个回文数")
n = int(input("请输入一个随机数："))
ls = []
reverse(n,ls)
isPalindrome(n,ls)

 编写程序显示前100个回文素数，每行显示10个数字，并且准确对齐

def Palindromic_Prime(num ,ls):
    # 判断是否为素数
    for i in range(2, int(num ** 0.5) + 1):
        if num % i == 0:
            break
    else:
        # 定义反转函数
        def reverse(num, ls):
            while num > 0:
                ls.append(num % 10)
                num //= 10

        reverse(num, ls)
        # 判断是否为回文数
        reverse_num = 0
        m = 1
        for i in ls:
            reverse_num += i * 10 ** (len(ls) - m)
            m += 1
            if reverse_num == num:
                return num

#该函数判断列表中的回文素数是否超过100
def count(num,ls1):
    count_printed = 0
    #判断列表中的回文素数是否超过100
    while len(ls1)<101:
        if Palindromic_Prime(num,[]):
            ls1.append(num)
            print(num, end=' ')  # 打印当前回文素数，末尾不加换行
            count_printed += 1
            if count_printed % 10 == 0:  # 每10个后换行
                print()
        num +=1
    print()
count(2,[])

编写程序找出P<=31的梅森素数（可以写成 2^p−1形式的素数）。

def is_prime(num):
    for i in range(2,int(num**0.5)+1):
        if num % i == 0:
            break
    else:
        return num
ls = []
for p in range(1,32):
    num = int(2**p-1)
    if is_prime(num):
        ls.append(num)
print("所有p<=31的梅森素数是：",ls)

 

总结

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北 染 星 辰

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值