python学习日记7 python基本语法（函数定义及基本使用）

本文链接：https://blog.csdn.net/zqk6442/article/details/129951472

文章目录

一、函数
- 1.定义
- 2.调用
二、函数的基本使用

一、函数

在一个完整的项目中，某些功能可能会被反复使用，如果将反复出现的代码封装成函数，以后如果要继续使用该功能则直接使用函数即可，另外，如果要修改需求，只需要修改函数

本质：对某些特殊功能的封装

优点：
a.简化代码结构，提高应用的模块性
b.提高了代码的复用性
c.提高了代码维护性

1.定义

语法：

def  函数名(变量1，变量2....):
	函数体
	return   返回值

说明：

a.def是一个关键字，是definition的缩写，专门定义函数

b.函数名：遵循合法标识符的规则和规范即可，尽量做到见名知意

c.(变量1，变量2…):被称为形式参数，是一个参数列表，都只是没有赋值的变量，可以没有

d.函数体：封装某些特殊的功能

e.return是一个关键字，表示返回，只能用在函数中，表示结束函数，可以单独使用，也可以携带数据，当携带数据，则表示该函数的返回值

f.返回值:常量，变量，表达式

g.函数的定义分为两部分：函数的声明和函数的实现

h.变量1，变量2… 和 return 返回值可以根据具体的需求选择性的省略

"""
注意：
    1.定义函数相当于定义变量，简单来说，将函数加载到了内存中 访问函数名实际就是访问函数在内存中的地址
    2.一个函数一旦被定义，需要手动调用它，否则无法执行
"""

2.调用

语法：
	函数名(实参)

注意：
    1.函数调用的本质：就是使用函数的过程/执行函数内部代码的过程
    2.调用函数的过程中，一定要注意传参的问题
    3.形式参数：简称形参，出现在函数的声明部分，实际上就是一个变量，等待实参赋值
    4.实际参数：简称实参，出现在函数的调用部分，实际上就是一个数据【常量，变量，表达式】，目的是为了给形参赋值
    5.传参：在调用函数的过程中，实参给形参赋值的过程
"""
# a.无参
func()

# b.有参
def func1(num1,num2):
    print('hello~~~~~~')
    print(num1 + num2)
func1(12,45)

# 2.函数之间的相互调用
# a.正常使用
def check1():
    print('ok~~~1111')
    check2()
def check2():
    check3()
    print('ok~~~2222')
def check3():
    print('ok~~~3333')
check1()

# b.恶意调用
# def a():
#     print('aaaaa')
#     a()
# a()
"""
注意：
    1.函数之间可以相互调用
    2.代码在执行的过程中，一旦遇到某个函数的调用，则优先执行该函数，当该函数执行完毕好，回到调用函数的地方，继续执行后面的代码
    3.一定要避免函数之间的恶意调用

二、函数的基本使用

1.参数

1.1 参数分类

形式参数：简称形参，定义在函数的声明部分，本质是一个没有值的变量，用于接收实参的值

实际参数：简称实参，出现在函数的调用过程中，本质是一个有值的变量或者常量，用于给形参赋值

传参：实参给形参赋值的过程

参数分类：

必需参数
默认参数
关键字参数
不定长参数【可变参数】

# 1.必需参数，常用
# 注意1：如果形参是必需参数，调用函数的时候，实参和必需形参的数量必须保持一致
def func1(a,b):
    print(a + b)
func1(23,5)
# 注意2：如果形参是必需参数，根据函数的具体实现需求，实参需要注意类型的问题
func1('hello','python')

# 2.默认参数
# 注意1：默认参数体现在形参中，实参可以不用给默认参数传参，也可以给默认参数传参，会覆盖掉默认值
def add(num1,num2=5):
    print(num1 + num2)
add(10)  # 只对必需参数传参
add(10,20)  # 利用实参覆盖形参默认值

# 3.关键字参数
# 注意1：关键字参数体现在函数的调用部分，通过关键字参数传参，可以调换参数的顺序
# 注意2：调用函数的时候，如果使用关键字参数，则关键字一定要和形参名称保持一致
def func31(name,age):
    print(f"姓名:{name},年龄：{age}")
func31('张三',10)
func31(name='李四',age=20)  
func31(age=23,name='jack')

# 4.不定长参数/可变参数
# a. *x:x将会被当做元组处理，实参可以是任意数量的数据
def func41(*num):    # 打包
    print(num,type(num))
    print("*num:",*num)  # 拆包

func41()    # () <class 'tuple'>
func41('abc')  # ('abc',) <class 'tuple'>
func41('abc',45,65,7,8,89,9,True)  # ('abc', 45, 65, 7, 8, 89, 9, True) <class 'tuple'>

# b.**x：x将会被当做字典处理，实参必须以key=value的方式传参，key必须是一个标识符
def func42(**num):   # 打包
    print(num,type(num))
func42()
func42(x=45,y=6,z=67)  # {'x': 45, 'y': 6, 'z': 67}
func42(abc='hello')

# 说明：在实际应用中，*和**可以同时使用
def func(*args,**kwargs):
    print(args,kwargs)
func()
func(10,20)
func(10,20,name='zhangsan',age=10)

1.2 参数传递

参数的传递：值传递和引用传递

"""
值传递和引用传递的区别
值传递：传参的时候，传递的是不可变的数据类型，如：int/float/str/tuple/bool,当形参发生修改，对实参没有影
	   响
引用传递：传参的时候，传递的是可变的数据类型，如：list/dict/set等，当形参中的元素发生修改，则实参会随着
	     修改
"""

# 1.值传递
def func1(num):
    print(f"修改之前，num的地址：{id(num)}")
    num = 100
    print(f"修改之后，num的地址：{id(num)}~~~~")

temp = 45
func1(temp)
print(f"temp的值：{temp}")


print("*" * 50)


# 2.引用传递
def func1(num):
    print(f"修改之前，num的地址：{id(num)}")
    num[1] = 100
    print(f"修改之后，num的地址：{id(num)}~~~~")

temp = [2,3,4]
func1(temp)
print(f"temp的值：{temp}")

2.返回值

2.1 return

return是一个关键字，可以单独作为一条语句，只能使用在函数中，表示结束函数
同级的情况，在return的后面不添加任何语句，否则永远没有执行的机会
不同级的情况下，只要return有可能执行不到，return的后面是可以添加语句的

# return  xxx:此处的return不但表示结束函数，还表示在函数调用的过程中将指定值返回
# 注意1：如果函数没有设置返回值，则函数调用完毕之后，默认返回None
# 注意2：函数调用完毕之后，可以使用一个变量将返回值接出来
def show21():
    print('222222')
r1 = show21()   # r1 = 返回值  
print(r1)	   # None

# 注意3：如果一个函数设置了返回值，则函数在哪里调用，返回值会返回值到哪里
def show22():
    print('222~~~~~')
    return 66
r2 = show22()
print(r2)
print(show22())   # 如果一个函数的调用可以直接通过print打印，则说明该函数有返回值

# 3.给函数设置返回值的意义
def add2(num1,num2):
    total = num1 + num2
    return total
r = add2(34,18)
print(r)  # 可以将函数的结果通过返回值返回后，通过print输出

2.2 return和break

return:使用在函数中，表示结束函数,不管return处于多少层循环中，只要执行到return，函数都会结束
break:使用在循环中，表示结束当前循环

3.函数的封装

语法：

def xxx(形参):
函数体【要实现的需求】
return 返回值

如果要封装一个函数，需要注意两个方面:
是否需要设置形参：如果需求中有未知项参与运算，则设置为形参
是否需要设置返回值：如果需求运算完是否有结果，如果有结果，则设置返回值

4.匿名函数

概念：不再使用def这种标准形式定义函数，而是使用lambda表达式来创建函数，该函数没有函数名，被称为匿
名函数,匿名函数也被称为lambda表达式

语法：lambda 形参列表:返回值

说明：

a.lambda只是一个表达式，用一行代码实现一个简单的逻辑，可以达到对函数的简化【优点】

b.lambda主体是一个表达式，而不是一个代码块，只能封装有限的逻辑【缺点】

c.lambda拥有自己的命名空间，不能访问自有列表之外或者全局命名空间里的参数

# 1.无形参
# a.def标准函数
# 定义
def func1():
    print('111')
print(func1)   # <function func1 at 0x106778f70>
# 调用
r1 = func1()
print(r1)

# b.匿名函数
# 定义
# lambda :print('111!~~~~')
f2 = lambda :print('111!~~~~')
print(f2)   # <function <lambda> at 0x106814790>

# 调用
# 方式一:变量  = lambda xx:xxx,通过该变量就可以调用函数
r2 = f2()
print(r2)

# 2.有形参
def add1(num1,num2):
    return num1 + num2
r1 = add1(34,5)
print(r1)

# 注意：匿名函数的返回值不需要return
add2 = lambda num1,num2:num1 + num2
r2 = add2(23,9)
print(r2)

# 3.
def even1(num):
    if num % 2 == 0:
        return True
    return False
r1 = even1(10)
print(r1)

even2 = lambda num:True if num % 2 == 0 else False
r2 = even2(35)
print(r2)