云计算百科
云计算领域专业知识百科平台

AI应用-1.4Python_函数

一、函数基础

1.什么是函数:

        函数是组织好的、可重复使用的、用来实现特定功能的代码片段。

2.函数的作用:

        (1)提高代码复用性

        (2)提高代码的可读性、可管理性、维护性

3.定义函数:

def 函数名(参数列表):
"""函数文档字符串(说明作用)"""
函数体代码
return 返回值 # 可选,没有return默认返回None

        注意:(1)函数定义时如果有多个参数,多个参数之间使用逗号“ , ”分隔

                   (2)return 语句只有返回功能,而没有输出打印的功能,如果要输出,需要结合print()函数来实现

4.调用函数:

函数名(参数)

5.简单案例-函数定义+调用

        函数内不确定的数据:设置成参数让外部进行传递

        函数的执行结果:在外部定义变量接收

"""
#函数定义
定义语法:
def 函数名称(): #无参无返回值
函数体
def 函数名称(参数): #有参无返回值
函数体
def 函数名称(): #无参有返回值
函数体
return 结果
def 函数名称(参数): #有参有返回值
函数体
return 结果
参数和返回结果如何设计:
看需求

#函数调用
调用语法:
函数名称() #无参无返回值
函数名称(实参) #无参无返回值
变量 = 函数名称() #无参有返回值
变量 = 函数名称(实参) #有参有返回值
"""

#需求1:设计函数计算12345和54321的和,并打印结果
def func1():
result = 12345 + 54321
print(result)
#需求2:设计函数并计算两个数和,并打印结果
def func2(num1, num2):
result = num1 + num2
print(result)
#需求3:设计函数计算12345和54321的和
def func3():
result = 12345 + 54321
return result
#需求4:设计函数并计算两个数和
def func4(num1, num2):
result = num1 + num2
return result

#需求5:调用4个函数
func1()
func2(123,456)
result3 = func3()
result4 = func4(123,456)

6.函数的说明文档

       (1) 函数说明文档是写在函数开头,用三个引号包裹的字符串,用于解释函数的功能、参数、返回值等信息,方便调用者清楚函数的具体作用及细节

        (2)函数说明文档的作用:方便调用者清楚函数的具体作用及细节,使代码更容易理解、使用和维护

        (3)如何添加函数说明文档:

                        写在函数开头

                        用三个引号包裹的字符串

                        用于解释函数的功能、参数、返回值等信息

        (4)如何查看函数说明文档:

                        方式一:通过help函数

                                       help(rectangle_area)

                        方式二:在pycharm中,鼠标悬浮在函数上,自动展示(推荐)

#定义一个函数:计算传入的字符串中元音字母的个数
"""
需求1:
函数名:count
参数:需要,传递统计的字符串参数,count_str
返回值:需要,返回统计的个数
功能实现:略
"""
def count(count_str):
"""
计算传入的字符串中元音字母的个数
:param count_str:
:return:
"""
count = 0
for i in count_str:
if i in "aeiouAEIOU":
count+=1
return count

count1 = count("abandon")
print(count1)

#定义一个函数:计算传入的班级学员高考成绩列表中最高分、最低分、平均分
"""
需求2:
函数名:count_score
参数:需要,传递统计的字符串参数,score_list
返回值:需要,返回统计的最高分、最低分、平均分(从五大容器中选择封装多个结果,返回容器)
功能实现:略
"""
def count_score(score_list):
"""
计算传入的班级学员高考成绩列表中最高分、最低分、平均分
:param score_list:
:return:
"""
max_score = max(score_list)
min_score = min(score_list)
avg_score = sum(score_list)/len(score_list)
score = {"max":max_score,"min":min_score,"avg":avg_score}
return score

count_score1 = count_score([88,99,66,77])
print(count_score1)

二、函数进阶

1.函数—变量作用域

(1)有哪些作用域:

        —— local (局部):在del函数里面创建的变量,就是局部变量

        —— Enclosing (嵌套外层):函数里面再套一个函数(嵌套函数)

        —— Global (全局):直接写在函数外面

        —— Built – in (内置):Python自带的名字

        注意:

                全局变量:在函数、推导式之外定义的变量,称之为全局变量。

                                  在整个文件中(包括函数内)都可以使用(通常定义在文件的顶部)。

                局部变量:在函数、推导式内部定义的变量,称之为局部变量。

                                  只在该函数内部使用外部无法访问,执行完毕后会自动销毁其内部局部变量

(2)作用域特点:

        变量在哪定义,它的活动范围基本就在哪

        口诀:LEGB(查变量的寻找顺序)

                   Local(局部)–>Enclosing(嵌套外层)–> Global(全局)–> Built – in(内置)

(3)在局部修改全局变量:

        <1>首先,使用global修饰变量

                        global 变量名称

        <2>告知Python解释器,当前操作的是外部全局的变量,当前位置不要重新创建新的变量,直接操作外部全局变量

                        变量名称 = 新的值

# 全局变量
num = 100

def change_num():
# 声明:下面操作的 num 是全局变量
global num
num = 200 # 修改全局变量的值
print("函数内部num:", num)

# 调用
change_num()
print("函数外部num:", num)

2.函数-参数

(1)传参方式

        方式一、位置传参

               调用函数时根据函数定义时的位置来传递参数

               要求:调用函数时参数顺序与定义函数时参数顺序完全一致

        方式二、关键字传参

                调用函数时以函数定义时形参作为关键字,以“键=值”的形式来传递参数(不要求顺序)

                注意:如果位置参数与关键字参数混用,关键字参数必须在位置参数之后(关键字参数之间,没有顺序要求)

对比项位置参数关键字参数
写法 f(值1, 值2, 值3) f(名1=值1, 名2=值2)
对应依据 位置顺序 参数名
顺序是否重要 ✅ 必须严格对应 ❌ 可任意排列
可读性 差(值是什么要靠猜) 强(一眼看懂)
代码量 简洁 稍繁琐
易错风险 高(顺序错就全错,且不报错) 低(名字错会直接报错)
维护扩展 难(加参数要改所有调用处) 易(只补需要的那一个)
适用场景 参数 ≤ 3 个,且顺序自然 参数较多,或类型 / 含义易混淆

"""
要求:掌握函数调用时,参数传递的方式
方式一:位置参数
调用函数,传递参数时,参数的顺序和定义函数时完全一致
方式二:关键字参数
调用参数,传递参数时,参数的顺序和定义函数时可以不一致
参数名称=值,参数名称=值
"""
def show_info(name,age,gender,address):
print(f"name={name}")
print(f"age={age}")
print(f"gender={gender}")
print(f"address={address}")

#调用函数:位置参数方式传递参数
show_info("柚子",21,"女","杭州")
print()

#调用函数:关键字参数方式传递参数
show_info(gender="男",age=23,address="杭州",name="柠檬")
print()

        方式三、缺省传参/默认参数

                在定义函数时,为参数提供默认值,调用函数时,可以不传递有默认值的参数。

                注意:默认参数必须放在没有默认值的参数列表的后面,一个函数在定义时是可以设置多个默认参数的。

                          函数调用时,若果为默认参数传递了值,则会修改默认的参数值;如果没有传递该参数,则直接使用默认值。

def show_info(name,age,gender="女",address="杭州"):
print(f"name={name}")
print(f"age={age}")
print(f"gender={gender}")
print(f"address={address}")

show_info("桃子",25,"女","上海")
print()
show_info("柚子",25)

        方式四、不定长传参

                不定长参数也叫可变参数,用于函数定义及调用时参数个数不确定(0或多个)的场景

                类型:——位置传递

"""
语法:
def 函数名称(*args):
函数体
return 结果
"""
#需求:统计一批数据的最大值、最小值、平均值
#传递的所有实参都被datas变量收集,并封装到一个tuple中
def calc_data(*datas): #datas只是一个形参名称,可自行定义;形参前加*表示组包(将多个参数封装到一个容器中)
print(f"形参的类型是{type(datas)}")
print(f"最小值:{min(datas)}")
print(f"最大值:{max(datas)}")
print(f"平均值:{type(datas)}")
print()

calc_data(1, 2, 3)
calc_data(1, 2, 3,4,5) #实参:需要传递多个位置参数数据
calc_data(1, 2)
calc_data(1, 22, 3,44,5,66,7,88,9,100)

t1 = (12,3,4,5)
calc_data(*t1,1,2,3) #实参前加*表示解包(将容器中的多个数据,提取出来作为多个参数)

注意:

       (1) 传递的所有匹配的位置参数都会被args变量收集,这些参数会合并封装为一个元组,args是元组类型(注意并不会封装关键字参数)

        (2)args只是约定俗成的变量名,并不是关键字,这里可以使用任何合法的变量名(eg:*data)   

                           ——关键字传递

"""
要求:看懂不定长关键字参数的书写形式
语法:
def 函数名称(*args):
函数体
return 结果
"""

#需求:展示用户信息
#传递的所有实参都被datas变量收集,并封装到一个dict中
def show_info(**datas): #datas只是一个形参名称,可以自行定义
print(f"形参的类型是{type(datas)}")
print(datas)
print()

show_info(name="张三",age=23,gender="男",tel="18000000000000")
show_info(name="张三",gender="男",tel="18000000000000")
show_info(gender="男",tel="18000000000000")
show_info(gender="男")

注意:

        (1)参数是以“键=值”形式传递的关键字参数,这些“键=值”参数都会被kwargs接受,并合并封装为一个字典类型。

        (2)kwargs只是约定俗成的变量名,并不是关键字,这里可以使用任何合法的变量名(eg:**options)

def f(必填, 可选=默认, *数据, 仅关键字, **选项)
↑ ↑ ↑
单个可省 打包成元组 打包成字典
f(1, 2, 3, 4, opt=5, x=6)

3.参数类型

(1)普通参数

        eg.        float、int、bool、str、list、set、tuple、dict等

(2)特殊参数

        def 函数名称(普通参数,函数参数):

                函数参数()

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

def calc(a,b,operator):
"""
对两个数进行四则运算操作
:param a: 第一个数据
:param b:第二个数据
:param operator: 运算的函数
:return: 运算结果
"""
result = operator(a,b)
print(f"计算结果{result}")

calc(10,20,add)
calc(10,20,sub)

4.匿名函数——lambda

(1)概念:匿名函数指的是没有名称的函数,需要通过lambda表达式来声明函数,可以简化简单函数的编写(单行表达式)

(2)为什么使用匿名函数:

        ——需要定义一个函数:函数只临时使用一下,只使用一次,函数逻辑不复杂

        ——需要将此函数作为参数传递给另一个函数使用

(3)lambda使用条件:

                条件1:有返回值

                条件2:函数体只有一行代码

(4)语法格式:

lambda [参数列表]:函数体

(5)注意:

                    传递的是函数名称,不是调用函数本身;

                    匿名函数中必须是一个表达式,会自动将表达式的运行结果作为返回值。如果执行的是print()这类无返回值的操作,lambda会返回None;

def calculation(x, y, operator):
"""
对两个数进行四则运算操作
:param x: 第一个数据
:param y: 第二个数据
:param operator: 运算的函数
:return: 运算结果
"""
result = operator(x, y)
print(f'计算结果:{result}')

"""
要求:看懂普通参数和特殊类型的参数
普通参数:
int , float , bool , None type
str , list , tuple , set , dict
特殊参数:
函数
"""
calculation(10, 20, lambda x, y: x + y)

calculation(1234, 1000, lambda x, y: x – y)

"""
内置函数:map(fun,datas)
作用:对一批数据进行批处理
参数:1.加工处理的函数,2.待处理的一批数据
返回:处理后的一批结果序列数据,可以使用list()/tuple()/set()转换成具体的容器
"""
def func(x):
return x.replace('你大爷','**')

# 需求:["你大爷,身体最近好吗?","菜鸡,去你大爷的","会玩吗?你大爷!"],对列表中的敏感数据进行脱敏处理,把你大爷,替换成**
data_list = ["你大爷,身体最近好吗?","菜鸡,去你大爷的","会玩吗?你大爷!"]
result = map(func, data_list)
print(list(result))

补充:map()函数

map(函数, 可迭代对象)

  • 作用:把可迭代对象里的每一个元素,依次传给这个函数做处理,返回一个 map 对象(迭代器)
  • 特点:懒加载,不会立刻算出全部结果,需要用 list() 转成列表查看

一句话:对序列里每一个元素批量执行同一个函数

5.递归算法

(1)表现:函数调用函数

(2)场景:发现公式中存在函数自己调用自己的情况,可以使用递归算法实现

(3)实现步骤:找递归公式 –> 定义递归函数 –> 设置出口,避免栈内存溢出

"""
递归算法:函数自己调用自己
def func1():
func1()
注意:避免栈内存溢出

递归编写流程:
1.找递归公示
2.定义递归函数
3.设置出口,避免栈内存溢出
"""
# 需求1:计算一个数的阶乘
def func1(n):
# 递归的出口
if n == 1:
return 1
return n*func1(n-1)
print(func1(5))

# 需求2:计算一个数的累加和
def func2(n):
# 递归的出口
if n == 1:
return 1
return n+func1(n-1)
print(func2(5))

6.类型注解

(1)相关定义

        ——类型注解:是Python中的一种语法特性,用于明确标识变量、函数参数和返回值的数据类型,从而使代码更清晰、更安全、更易维护。

        ——类型推断:Python解释器自动推断出变量、函数参数和返回值的数据类型的能力,而无需开发者显式声明。

(2)类型的写法:

        -变量:

# 基础写法:变量名: 类型 = 值
name: str = "小明"
age: int = 20
score: float = 95.5
is_student: bool = True

# 容器类型注解(Python3.9+可以直接写list)
nums: list[int] = [10, 20, 30]
info: dict[str, int] = {"语文": 88, "数学": 92}

print(name, age, nums)

        -函数:

# 函数:接收两个int,返回int
def add(a: int, b: int) -> int:
return a + b

# 调用
res = add(3, 5)
print(res)

# 另一个例子:接收字符串,返回布尔值
def is_long(s: str) -> bool:
return len(s) > 5

print(is_long("hello"))

(3)常见类型的写法

        ——单个类型:int、float、bool、str、None、list、set、tuple、dict

        ——多个类型:str | int | None

(4)类型注解的好处

        -代码结构更清晰、代码逻辑更安全、易维护

        -更准确的代码自动提示

        -提前发现代码潜在问题

(5)使用场景

        -Python是动态类型语言,添加的类型注解只是提示,并不是强制约束

        -类型推断:Python会自动进行类型推断 –> 如果对变量直接赋值、变量运算等场景

        -类型注解:函数参数、返回值,推荐使用类型注解

7.模块

了解即可

补充:特殊变量

__all__ = ["名字1", "名字2", "名字3"]

__all__ 是一个列表,用来控制 from 模块名 import * 时,哪些名字会被导入(白名单)。

只对 import * 生效!import 模块、from xxx import 名字 不受它限制。

__name__:判断模块是直接运行还是被导入,控制代码是否执行 取值:__main__ , 模块名称 if __name__ == “__main__”: 测试代码

__name__ == "__main__"

8.软件包

导入包方式:

导入语句导入对象控制白名单使用方式
import 包名.模块名 模块 无 包名.模块名.功能
from 包名 import 模块名 模块 无 模块名.功能
from 包名 import * 包下的模块 包的__init__.py里的__all__ 模块名.功能
from 包名.模块名 import 功能名 单个功能(类 / 函数) 无 直接 功能名()
from 包名.模块名 import * 模块内的功能 模块 py 文件里的__all__ 直接 功能名()

注意:注意:在包中导入当前包中的模块时,不要忘记使用相对路径,从当前包中获取功能 相对路径:from .模块名称

赞(0)
未经允许不得转载:网硕互联帮助中心 » AI应用-1.4Python_函数
分享到: 更多 (0)

评论 抢沙发

评论前必须登录!