Python函数

Atopos__

已于 2024-05-21 14:32:46 修改

阅读量661

点赞数 16

分类专栏： python学习文章标签： python 开发语言

于 2024-05-21 14:16:08 首次发布

本文链接：https://blog.csdn.net/Atopos__/article/details/139002195

版权

python学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

函数：

函数可以实现一个特定的功能。将多行代码（可以实现一个特定的功能）放在一块，并给它起一个名字，在需要使用多行代码的时候，可以使用名字代替．

def login():
    print('1.输入用户名')
    print('2.输入密码')
    print('3.输入验证码')
    print('4.点击登录')

print('_' * 30)

login()

print('_' * 30)

login()

定义和调用函数:

定义
1.函数定义,就是给多行代码起名字的过程;
2.函数的定义需要使用关键字def,单词define
def 函数名():
函数中的代码
函数中的代码
1.处在def缩进中的代码都属于这个函数;
2.函数名要满足标识符的规则,见名知意;
3.def这行代码的最后需要一个冒号;
4.函数定义不会执行函数中的代码,想要执行,需要调用.
调用
1.函数调用,就是使用多行代码的过程;
2.语法函数名()

函数的文档注释:

1.函数的文档注释,本质就是注释,只不过作用和书写位置有特定的要求;

2.作用:是对函数的作用和使用方法进行说明,比如有哪些参数,返回值是什么;

3.书写位置:在def的下方,使用三对双引号来书写;

4.查看函数
在函数名上,使用快捷键ctrl+q查看;
在函数名上,使用快捷键ctrl+b 跳转到函数定义的地方查看
在函数名上,按住ctrl键,点击函数名,跳转到函数定义的地方查看.

函数参数:

在函数定义的时候,在括号中写入变量,这个变量就称为是函数的参数,形式参数(形参),在函数调用的时候,可以给定义时候的形参传递具体的数据值,供其使用,实际参数(实参)

即:在函数调用的时候,会将函数的实参值传递给形参

好处:可以让函数更加的通用,函数中的1数据值不是固定的,是调用的时候,你传递的

使用场景:判断函数中数据值是不是固定不变的,如果是变化的,就可以使用参数传递

注意点:目前书写的函数,如果存在形参,必须传递相同个数的实参.

def sun_2_num(a,b):  #形参
    c = a + b
    print(c)

sun_2_num(10,2)  #实参

函数的嵌套调用：

在一个函数中调用另一个函数：

代码从上到下执行的；
函数定义不会执行函数中的代码；
函数调用会进入函数中执行函数中的代码；
函数中的代码执行结束，会回到调用的地方继续向下执行。

#1.定义名为test01的函数，打印当前函数的名称
def test01():
    print(1)
    print('func01')
    print(2)

#2.定义名为test02的函数，打印当前函数的名称，并调用test01函数
def test02():
    print(3)
    print('func2')
    test01()
    print(4)

print(5)
test02()
print(6)

# 输出结果
# 5
# 3
# func2
# 1
# func01
# 2
# 4
# 6

函数的返回值：

返回值：函数执行的结果

print() ----> None

input() ---> 键盘输入的内容,类型字符串

type() ---> 变量的数据类型

len() ---> 容器长度

在一个函数中,想要返回一个数据(想要有返回值),需要使用return关键字;
为什么返回值?在函数中可能通过各种代码,得到的数据结果,想要在函数外部使用,就需要使用返回值;
如果函数有返回值,一般在调用的时候,会使用变量来接收(保存)返回值,以便后续使用;
return关键字的作用:将一个数据值返回到调用的地址;函数遇到return会结束函数的执行;
return关键字只能用在函数中;
如果一个函数没有写return,可以认为返回值是None.

# 设计一个函数用于获取两个数中的较大数,数据来自于函数的参数
def get_max(a, b):
    if a > b:
        return a
    else:
        return b


# 调用
num = get_max(10, 15)
print(num)

模块:

在python中,每个代码文件都可以成为是一个模块;
在模块中,别人书写好的功能(变量,函数,类),我们可以拿来直接使用;
我们自己写的代码文件,想要作为模块让别人使用,你的代码文件名(模块名)满足标识符的规则;
想要使用别人模块中写好的功能,需要先导入别人写好的功能;
as 关键字,可以给模块或者功能起别名.

模块导入的方法:

方式一
import 模块名 #模块名就是代码文件名,不要.py
#使用其中的功能
模块名.功能名 #功能可以是变量,函数和类
方式二
from 模块名 import 功能名 #导入指定的功能
#使用
功能名()

name变量:

导入模板的时候,会执行模块中的代码;
如果在导入模块的时候,模块中的部分代码不想被执行,可以使用__name__来解决;
__name__变量,是python解释器内置的变量(变量的值是自动维护的),每个代码文件中都有这个变量:
3.1 在模块中直接右键运行代码文件,__name__变量的值是'__main__'
3.2 如果是被导入运行代码文件,__name__变量的值是模块名(文件名)

模块的导入顺序:

在导入模块的时候,会先从代码所在的目录进行导入;
如果没有找到,会去python系统的目录查找导入;
如果还没有找到,就会报错.

注意点:我们自己定义的代码文件名字,不要和导入的系统的模块文件名一样.

包的导入:

方式一:
import 包名.模块名
#使用
包名.模块名.工具名
方式二:
from 包名 import 模块名
#使用
模块名.工具名
方式三使用快捷键导包
from 包名.模块名 import 工具名
#直接使用工具名
工具名(alt+enter)

变量的引用：

定义变量的时候，变量和数据都会在内存开辟空间；
变量所对应的内存空间中存储的是数据所在内存的地址(平时理解为将数据存储到变量中即可)；
变量中保存数据的地址，就成为是引用；
python中所有数据的传递,传递的都是引用(即地址);
赋值运算符(=),会改变变量的引用,即只有=可以修改变量的引用;
可以使用id(变量)函数,查看变量的引用.

a = 1 #本质:将数据1的地址保存到变量a中,通常理解:将1保存到a
b = a #本质:将变量a中的引用保存到变量b中,通常理解将a的值给b
print(f"a:{a},{id(a)}") #1
print(f"b:{b},{id(b)}") #1
a = 2 #本质:将数据2的地址保存到变量a中,只是改变a的引用,即改变a的值,没有改变b的引用
print(f"a:{a},{id(a)}") #2
print(f"b:{b},{id(b)}") #1

my_List = [1,2,3]
my_List1 = my_List
print(f"my_list:{my_List},{id(my_List)}") #[1, 2, 3]
print(f"my_list:{my_List},{id(my_List)}") #[1, 2, 3]
my_List[1] = 19  #修改列表my_list中下标为1位置的引用
print(f"my_list:{my_List},{id(my_List)}") #[1, 19, 3]
print(f"my_list:{my_List},{id(my_List)}") #[1, 19, 3]

可变类型与不可变类型:

根据内存中的数据是否允许修改,将数据类型分为可变类型与不可变类型

简单理解:不使用等号,能不能修改数据值

可变类型:可以修改

---列表(list) list.append()

---字典(dict) dict.pop()

---集合(set)

不可变类型:不允许修改

---数字类型(int,float,bool)

---字符串(str)

---元组(tuple)

my_tuple = (1,2,[10,20])  #元组中存储的1的地址,2的地址,列表的地址

print(my_tuple,id(my_tuple),id(my_tuple[-1]),id(my_tuple[-1][-1]))
my_tuple[-1][-1] = 30 #修改的列表中最后一个位置的引用,而非修改元组
print(my_tuple,id(my_tuple),id(my_tuple[-1]),id(my_tuple[-1][-1]))

局部变量:

在函数内部定义的变量,称为是局部变量;
特点:
2.1 局部变量,只能在当前函数内部使用
2.2 可以在不同函数内定义名字相同的局部变量
生命周期(使用范围)
3.1 在函数执行(调用)的时候被创建;
3.2 函数执行结束被销毁(删除)
形参可以认为是局部变量;
如果想要在函数外部使用局部变量的值,使用return返回.

def func1():
    num = 10  #局部变量
    print(num)

def func2():
    num = 20
    print(num)

if __name__ == '__main__':
    func1() #10
    func2() #20
    func1() #10

全局变量:

在函数外部定义的变量;
特点:
2.1 全局变量可以在任意函数内访问(读取)
2.2 想要在函数内部修改全局变量的引用,需要使用global关键字声明(使用global关键字可以声明为全局变量)
2.3 如果在函数内部出现和全局变量名字相同的局部变量,在函数内使用的是局部变量.
生命周期
代码执行的时候创建,执行结束销毁

#定义全局变量
g_num = 10

def func_1():
    print(g_num)  #使用全局变量
    
def func_2():
    g_num = 20 #定义局部变量
    print(g_num)
    
def func_3():
    global  g_num #声明为全局变量
    g_num = 30
    print(g_num)

if __name__ == '__main__':
    print(g_num) #10
    func_1() #10
    func_2() #20
    func_1() #10
    print(g_num) #10 修改了全局变量,但还没调用函数,因此结果仍为10
    func_3() #30 修改了全局变量,将全局变量的值改为30了
    func_1() #30

函数返回多个数据值:

return关键字作用:

1.返回数据值;
2.结束函数的运行

函数中如果想要返回多个数据值,一般是组成元素进行返回

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

result = cal(10,20)
print(result)

函数传参的方式:

是指如何将实参的值传递给形参

位置传参
在函数调用的时候按照形参的顺序将实参的值传递给形参
关键字传参
在函数调用的时候,指定将实参传递给哪个形参
混合使用
1.位置参数必须写在关键字参数的前边,关键字参数必须放在位置参数的后边;
2.同一个形参只能接受一个实参值(不能使用位置传参和关键字传参给同一个形参传参).

def show_info(name,age):
    print(f"name:{name},age:{age}")

#位置传参
show_info('小明',18)

#关键字传参
show_info(age = 18,name = '张三')

#混合使用
show_info('李四',age= 17)

缺省参数(默认参数):

定义:在函数定义的时候,给的形参一个默认的数据值,这个参数就是缺省参数(默认参数)
特点:在函数调用的时候,缺省参数可以不用传递实参值:
1.如果不传实参值,使用的就是默认值;
2.如果传递实参值,使用的就是传递的实参值.
注意点:缺省参数必须写在普通参数的后边

def show_info(name,age = 10,sex = '保密'):
    print((name, age, sex))

#调用
show_info('张三',18,'男')
#李四
show_info('李四')
#王五 19
show_info('王五',19)
#赵六 男
show_info('赵六',sex = '男')

多值参数(可变参数/不定长参数)

在函数定义的时候,不确定在调用的时候,实参有多少个,此时可以使用多值参数;
在普通的参数前面加上一个*,这个参数就变为多值参数;
这个参数可以接受任意多个位置传参的数据,类型元组;
这个形参一般写作args(arguments),即*args

参数顺序
普通,缺省.多值
def 函数名(普通,*args,缺省):
pass

def func(*args):
    print(args)

func()
func(1,3,5,4)

#定义一个函数my_sum,作用:可以对任意多个数字进行求和计算
def my_sum(*args):  #args是元组
    num = 0
    for i in args:
        num += i
    return num

print()
print(1,2)
print(1,2.3)

my_tuple = (1,2,3,4,5)
#需求对元组中的所有数据使用my_sum进行求和
#想要把列表(元组)中的数据作为位置参数进行传递,只需要在列表(元组)前面加上一个*,进行拆包即可
print(my_sum(*my_tuple))

匿名函数:

匿名函数:使用lambda关键字定义的表达式,称为匿名函数
语法:lambda 参数,参数:一行代码 #只能实现简单的功能,只能写一行代码

#匿名函数一般不直接调用,作为函数的参数使用

"""定义匿名函数,可以对两个数字进行求和"""
func = lambda a,b:a + b  #将匿名函数地址保存到变量func中,所以func就指代函数

print(func(1, 2))

匿名函数的应用:

user_list = [{'name':'张三','age':22,'title':'测试工程师'},
             {'name':'李四','age':24,'title':'开发工程师'},
             {'name':'王五','age':21,'title':'测试工程师'}]

#user_list.sort  只能对数字，字符串排序
# 根据字典的age键排序
# 想要对列表中的字典排序，需要key形参来指定根据字典中的什么键排序
# key这个参数需要传递一个函数，使用匿名函数
# 列表.sort(key=lambda x:x['键'])

user_list.sort(key=lambda x:x['age'])
print(user_list)

Atopos__

关注

16
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
Python函数

定义1.函数定义,就是给多行代码起名字的过程;2.函数的定义需要使用关键字def,单词definedef 函数名():函数中的代码函数中的代码1.处在def缩进中的代码都属于这个函数;2.函数名要满足标识符的规则,见名知意;3.def这行代码的最后需要一个冒号;4.函数定义不会执行函数中的代码,想要执行,需要调用.调用1.函数调用,就是使用多行代码的过程;2.语法函数名()
复制链接

扫一扫