Python零基础入门篇 - 31 - 函数的定义与使用(1)，2024年最新面试的知识点有哪些_3、定义一个函数,向函数内传入形参username,password,当username值为admi-CSDN博客

本文链接：https://blog.csdn.net/2401_84182758/article/details/137583274

- 必传参数
默认参数
不确定参数(可变参数)
参数规则
函数小练习
函数的参数类型定义
全局变量与局部变量
- 全局变量
局部变量
global 关键字
递归函数
- 递归函数的定义方法
递归函数的说明
lambda - 匿名函数
函数练习 - 利用函数实现学生信息库

文章目录

- 函数的定义
- 函数的分类
函数的创建方法 - def
函数的返回值 - return
return 与 print 的区别
函数的传参
- 必传参数
默认参数
不确定参数(可变参数)
参数规则
函数小练习
函数的参数类型定义
全局变量与局部变量
- 全局变量
局部变量
global 关键字
递归函数
- 递归函数的定义方法
递归函数的说明
lambda - 匿名函数
函数练习 - 利用函数实现学生信息库

函数的定义

什么是函数？ — > 函数是具有某种特定功能的代码块，可以重复使用(在前面数据类型相关章节，其实已经出现了很多 Python 内置函数了）。它使得我们的程序更加模块化，不需要编写大量重复的代码。

函数可以提前保存起来，并给它起一个独一无二的名字，只要知道它的名字就能使用这段代码。函数还可以接收数据，并根据数据的不同做出不同的操作，最后再把处理结果反馈给我们。

由此我们得知：

将一件事情的步骤封装在一起并得到最终结果的步骤，就是函数的过程。
函数名代表了该函数要做的事情。
函数体是实现函数功能的流程。
在实际工作中，我们把实现一个函数也叫做 “实现一个方法或者实现一个功能”
函数可以帮助我们重复使用功能，通过函数名我们也可以知道函数的作用。

函数的分类

内置函数：在前面数据类型相关章节，其实已经出现了很多 Python 内置函数了。如 input、id、type、max、min、int、str等 ，这些都是 Python 的内置函数。也就是 Python 已经为我们定义好的函数，我们直接拿来使用即可。

自定义函数：由于每个业务的不同，需求也各不相同。Python无法提供给我们所有我们想要的功能，这时候我们就需要去开发，实现我们自己想要的功能。这部分函数，我们叫它 自定义函数 。

无论是内置函数，还是自定义函数，他们的书写方法都是一样的。

函数的创建方法 - def

def 关键字的功能：实现 Python 函数的创建。

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

def 函数名(参数列表):

todo something # 实现特定功能的多行代码

[return [返回值]] # 用 [] 括起来的为可选择部分，即可以使用，也可以省略。

>>> 各部分参数的含义如下：

>>> 函数名：其实就是一个符合 Python 语法的标识符，但不建议使用 a、b、c 这类简单的标识符作为函数名，函数名最好能够体现出该函数的功能（如user_info, user_mobile）。

>>> 参数列表：设置该函数可以接收多少个参数，多个参数之间用逗号（ , ）分隔。

>>> [return [返回值] ]：整体作为函数的可选参参数，用于设置该函数的返回值。也就是说，一个函数，可以用返回值，也可以没有返回值，是否需要根据实际情况而定。

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

示例如下：

def user_name():

print('这是一个 'user_name’函数 ')

user_name()

>>> 执行结果如下

>>> 这是一个 'user_name’函数

函数的返回值 - return

return 的意思就是返回的意思，它是将函数的结果返回的关键字，所以函数的返回值也是通过 return 来实现的。

需要注意的是，return 只能在函数体内使用； return 支持返回所有的数据类型，当一个函数返回之后，我们可以給这个返回值赋予一个新的变量来使用。

由此我们总结出：

return 是将函数结果返回的关键字
return 只能在函数体内使用
return 支持返回所有的数据类型
有返回值的函数，可以直接赋值给一个变量

return 的用法，示例如下：

def add(a,b):

c = a + b

return c

#函数赋值给变量

result = add(a=1,b=1)

print(result)

#函数返回值作为其他函数的实际参数

print(add(3,4))

需要注意的是，return 语句在同一函数中可以出现多次，但只要有一个得到执行，就会直接结束函数的执行。

现在我们利用 return 关键字，尝试自定义一个 capitalize 函数。示例如下：

def capitalize(data):

index = 0

temp = ‘’

for item in data:

if index == 0:

temp = item.upper()

else:

temp += item

index += 1

return temp

result = capitalize(‘hello , Jack’)

print(result)

>>> 执行结果如下

>>> Hello , Jack

再一次注意到，只要有一个得到执行，就会直接结束函数的执行。

return 与 print 的区别

print 只是单纯的将对象打印输出，并不支持赋值语句。
return 是对函数执行结果的返回，且支持赋值语句；但是我们可以将含有 renturn 值的函数放在 print 里进行打印。

函数的传参

必传参数：平时最常用的，必传确定数量的参数
默认参数：在调用函数时可以传也可以不传，如果不传将使用默认值
不确定参数：可变长度参数(也叫可变参数)
关键字参数：长度可变，但是需要以 key-value 形式传参

必传参数

什么是必传参数？ —> 在定义函数的时候，没有默认值且必须在函数执行的时候传递进去的参数；且顺序与参数顺序相同，这就是必传参数。

函数中定义的参数没有默认值，在调用函数的时候，如果不传入参数，则会报错。
在定义函数的时候，参数后边没有等号与默认值。
错误的函数传参方式：def add(a=1, b=1)

错误示例如下：

def add(a, b):

return a + b

result = add()

print(result)

>>> 执行结果如下

>>> TypeError: add() missing 2 required positional arguments: ‘a’ and ‘b’

正确的示例如下：

def add(a, b):

return a + b

result = add(1, 2)

print(result)

>>> 执行结果如下

>>> 3

>>> add 函数有两个参数，第一个参数是 a，第二个参数是 b

>>> 传入的两个整数按照位置顺序依次赋给函数的参数 a 和 b，参数 a 和参数 b 被称为位置参数

传递的参数个数必须等于参数列表的数量

根据函数定义的参数位置来传递参数，要求传递的参数与函数定义的参数两者一一对应
如果 “传递的参数个数” 不等于 “函数定义的参数个数”，运行时会报错

错误传参数量示例如下：

def add(a, b):

return a + b

sum = add(1, 2, 3)

>>> 执行结果如下

>>> sum = add(1, 2, 3)

>>> TypeError: add() takes 2 positional arguments but 3 were given

默认参数

在定义函数的时候，定义的参数含有默认值，通过赋值语句给参数一个默认的值。
使用默认参数，可以简化函数的调用，尤其是在函数需要被频繁调用的情况下
如果默认参数在调用函数的时候被给予了新的值，函数将优先使用新传入的值进行工作

示例如下：

def add(a, b, c=3):

return a + b + c

result = add(1, 2) # 1 对应的 a ；2 对应的 b ；没有传入 C 的值，使用 C 的默认值 3。

print(result)

>>> 执行结果如下

>>> 6

def add(a, b, c=3):

return a + b + c

result = add(1, 2, 7) # 1 对应的 a ；2 对应的 b ；传入 C 的值为 7，未使用 C 的默认值 3。

print(result)

>>> 执行结果如下

>>> 10

不确定参数(可变参数)

这种参数没有固定的参数名和数量(不知道要传的参数名具体是什么)

不确定参数格式如下:

def add(*args, **kwargs):

pass

*args ：将无参数的值合并成元组

**kwargs ：将有参数与默认值的赋值语句合并成字典

*args 代表：将无参数的值合并成元组
**kwargs 代表：将有参数与默认值的赋值语句合并成字典

从定义与概念上似乎难以理解，现在我们通过示例来看一下：

def test_args(*args, **kwargs):

print(args, type(args))

print(kwargs, type(kwargs))

test_args(1, 2, 3, name=‘Neo’, age=18)

>>> 执行结果如下

>>> (1, 2, 3) <class ‘tuple’>

>>> {‘name’: ‘Neo’, ‘age’: 18} <class ‘dict’>

>>> args 将输入的参数转成了一个元组

>>> kwargs 将输入的赋值语句转成了一个字典

>>> 在使用的时候，我们还可以根据元组与字典的特性，对这些参数进行使用；示例如下：

def test_args(*args, **kwargs):

if len(args) >= 1:

print(args[2])

if ‘name’ in kwargs:

print(kwargs[‘name’])

test_args(1, 2, 3, name=‘Neo’, age=18)

>>> 执行结果如下

>>> 3 根据元组特性，打印输出 args 索引为 2 的值

>>> Neo 根据字典特性，打印输出 kwargs 的 key 为 name 的 value

def test_args(*args, **kwargs):

if len(args) >= 1:

print(args[2])

else:

print(‘当前 args 的长度小于1’)

if ‘name’ in kwargs:

print(kwargs[‘name’])

else:

print(‘当前 kwargs 没有 key为 name 的元素’)

test_args(1, 2, 3, name1=‘Neo’, age=18)

>>> 执行结果如下

>>> 3 根据元组特性，打印输出 args 索引为 2 的值3

>>> 当前 kwargs 没有 key为 name 的元素(传入的 kwargs 为 name1=‘Neo’, age=18；没有 name)

参数规则

def add(a, b=1, *args, **kwargs)

参数的定义从左到右依次是 a - 必传参数 、b - 默认参数 、可变的 *args 参数 、可变的 **kwargs 参数
函数的参数传递非常有灵活性
必传参数与默认参数的传参也非常具有多样化

示例如下：

def add(a, b=2):

print(a + b)

我们来看一下该函数可以通过哪些方式传递参数来执行

add(1, 2) # 执行结果为： 3

add(1) # 执行结果为： 3

add(a=1, b=2) # 执行结果为： 3

add(a=1) # 执行结果为： 3

add(b=2, a=1) # 执行结果为： 3

add(b=2)

执行结果为： TypeError: add() missing 1 required positional argument: ‘a’ 。

(因为 a 是必传参数，这里只传入 b 的参数是不行的)

def test(a, b, *args):

print(a, b, args)

int_tuple = (1, 2)

test(1, 2, *int_tuple)

>>> 执行结果如下

>>> 1 2 (1, 2)

***********************************************************

def test(a, b, *args):

print(a, b, args)

int_tuple = (1, 2)

test(a=1, b=2, *int_tuple)

>>> 执行结果如下

>>> TypeError: test() got multiple values for argument ‘a’

>>> 提示我们参数重复，这是因为必传参数、默认参数、可变参数在一起时。如果需要赋值进行传参，需要将可变参数放在第一位，然后才是必传参数、默认参数。(这是一个特例)

************************************************************

def test(*args, a, b):

print(a, b, args)

int_tuple = (1, 2)

test(a=1, b=2, *int_tuple)

>>> 执行结果如下

>>> 1 2 (1, 2)

>>> 这种改变必传参数、默认参数、可变参数的方式，一般我们是不推荐使用的

def test(a, b=1, **kwargs):

print(a, b, kwargs)

test(1, 2, name=‘Neo’)

test(a=1, b=2, name=‘Jack’)

test(name=‘Jack’, age=18, a=1, b=2)

>>> 执行结果如下

>>> 1 2 {‘name’: ‘Neo’}

>>> 1 2 {‘name’: ‘Jack’}

>>> 1 2 {‘name’: ‘Jack’, ‘age’: 18}

注意：如果传参的顺序发生变化，一定要使用赋值语句进行传参。

函数小练习

需求：定义一个 login 函数，向函数内传入形参 username，password，当 username 值为 admin 且password值为字符串 123456 时，返回“登录成功”；否则返回“请重新登录”

def login(username, password):

定义一个登录函数，传入 username, password 必填参数

if username == “admin” and password == “123456”:

使用if语句，判断用户名和密码为“admin”和“123456”

print(“登录成功”) # 返回登录成功

else:

使用else子句处理用户名和密码非“admin”和“123456”的情况

print(“请重新登录”) # 返回请重新登录

调用函数，向函数内传入’admin’,‘123456’和’test’,'123456’两组数据测试结果

函数的参数类型定义

前文我们学习了函数的定义方法与使用方法，在定义参数的时候我们并不知道参数对应的数据类型是什么。都是通过函数体内根据业务调用场景去判断的，如果传入的类型与也无偿性不符，就会产生报错。现在我们学习一种方法，可以在定义函数的时候，将参数类型与参数一同定义，方便我们知道每一个参数需要传入的数据类型。

我们来看一个例子：

def person(name:str, age:int=18):

print(name, age)

必传参数：参数名 + 冒号 + 数据类型函数，为声明必传参数的数据类型
默认参数：参数名 + 冒号 + 数据类型函数 + 等号 + 默认值，为声明默认参数的数据类型
需要注意的是，对函数的定义数据类型在 python 3.7 之后的版本才有这个功能
虽然我们给函数参数定义了数据类型，但是在函数执行的时候仍然不会对参数类型进行校验，依然是通过函数体内根据业务调用场景去判断的。这个定义方法只是单纯的肉眼上的查看。

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Python开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注Python）

最后

Python崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS等更加高级的领域。Python可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！