python 中的函数、函数的变量和作用域、函数的返回 return、函数的传递和嵌套、lambda 匿名函数、字典元组的拆包

搞IT的放牛娃

已于 2023-06-16 18:38:09 修改

阅读量393

点赞数

文章标签： python 开发语言

于 2022-10-20 14:55:21 首次发布

本文链接：https://blog.csdn.net/weixin_64672480/article/details/127426760

版权

一、函数的作用：在开发程序时使用函数可以提高编写的效率以及代码的重用。

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

封装代码==》提高代码的重用性

内置函数：例如：print()

自定义函数：使用def关键字来创建Python自定义函数

二、函数的使用步骤：

1、定义函数:把代码封装在函数的内部

2、调用函数:执行函数内部封装的代码

三、自定义函数格式:

def fun():          # 定义一个函数fun
    # 这里是函数体 需要默认空一格tab键
    # print('hello')

# 函数的第一种调用方法
fun()


# 调用函数、如果函数只是被定义了不调用不会有输出结果，可以在其他模块种被导入使用


# 函数的第二种调用方法          # __name__ 代表的是当前模块的名称，__main__ 是被运行的模块名称
if __name__=='__main__':      # 主函数：是函数的入口、作用一般是用来调用代码
    fun()                     # 调用函数   main 函数下面的代码是不会导入到其他模块中使用

四、不带参数函数

输出20个 * 号
def fun():
    print('*' * 20)

fun()


def my_sum():
    a = 10
    b = 20
    print(a + b)

# 调用函数
my_sum()

五、带参数

def fun(name):                 # name 为行试参数 单个参数
    print(name + '都是大佬!!!')

fun("DCS")                    # 调用实参，如果调用是没给实际参数会报错，给多了也会报错



def fun(name,where):           # 两个参数
    print(name + '去' + where + '搬砖')

fun('张三','成都')



def my_sum(a,b):      # 形参只能是变量
    print(a + b)

调用函数
my_sum(3,6)           # 实参可是常量和变量,也可以是表达式

num1 = 2
num2 = 3
my_sum(num1,num2)     # 变量num1的值为2,所以形参a的值为2,形参b的值为3
my_sum(7 + 2,5 * 3)   # 形参a的值为9,形参b的值为15

练习: 定义一个函数,名字叫mu_func2,有一个参数num1，调用my_func2时,num1为1,输出1个*号,num1为5,输出5个*号

def my_func2(num1):
    print('*' * num1)

my_func2(1)
my_func2(5)

六、默认参数

def fun(name,where,actin='搬砖',time=None):    # 两个参数，当默认参数列表中出现形式参数和默认参数时，默认参数需要放在形式参数后面
    print(name+'去'+where+actin)

fun('张三','成都')                      # 默认参数不赋值时，默认使用默认参数
fun('张三','成都','砍柴')               # 当赋予新的值时，原默认参数会被覆盖

七、可变长元祖：参数前面加一个*

一个*号表示可变长元祖（函数调用本身时，可以无限添加实参）

def fun(*name):
    for i in name:
        print(i)

fun("张三","李四","王五")

def fun(*value):
    print(value)
    print(type(value))

fun('张三','李四','王五')

八、两个*号表示可变长字典：参数前面加两个

# 两个 ** 表示的是可变长字典

def fun5(**name):
    print(name)
    for i in name.items():
        print(i)

user = {"name":"xiaochen","sex":1,"age":18}

fun5(**user)

九、可变长元祖和可变长字典进行同时合并

def fun(*name,**usre1):            # 当可变长元组和可变长字典同时出现，需要将可变长字典放后面
    print(name)
    print(user1)
user1 = {"name":"xiaochen","sex":1,"age":18}
fun("xiaochen",'wangwu',**user1)

十、函数的变量和作用域

1、在函数体内部也可以定义变量，在函数中定义的变量被称之为局部变量，局部变量只在定义它的函数内部有效

2、在函数体之外定义的变量，我们称之我全局变量

3、局部变量

def my_func1():
    a = 1              # 局部变量
    print(a)

my_func1()             # 调用函数后 a 局部变量将不存在


num=100                # 全局变量,函数内部可以使用它
def fun():
    sum = num + 123    # 局部变量引用了全局变量
      # --如果函数内部有定义局部变量，就优先使用函数内部的局部变量 

    print(sum)         # 打印局部变量


fun()                  # 函数调的是局部变量
print(num)             # 打印全局变量

4、引用全局变量

num = 100              # 全局变量
def fun():
    num = 200          # 引用自身
    x = num + 100      # 引用全局变量
    print(x)

fun()                  # 调用函数本身


如果引用的局部变量，则不会引用全局，如没有定义局部则会引用全局函数内部的变量名，如果是第一次出现，且出现在=符号后面，且在之前已被定义为全局变量，则这里将引用全局变量。

a = 1
def my_test1():
    global a
    a = 2

def my_test2():
    a = 3
    my_test1()

print(a)
my_test2()
print(a)

5、全局变量与局部变量重名：如果要使用局部变量,需要申明局部变量为全局变量

在函数中将某个局部变量定义为全局变量时需要使用关键字global

num=100                  # 全局变量
def fun():
    global num           # 把函数内部的局部变量变为全局变量、原来在函数外部定义的全局变量会被覆盖
    num = 200            # 相当于把全局变量的值改为了200
    sum = num + 100
    print(sum)

fun()
print(num)

通过global声明后：在函数内的变量会被优先调用，原始的全局默认无作用

十一、函数的返回值 return

函数中一定要有return返回值才是完整的函数。如果没有python定义函数返回值，
那么函数就是执行一个隐式的代码语句”return None”,也叫是说函数都会有一个返回值，
如果没定义就执行隐性语句，定义的了就要实际定义的为主。

a = len('hello python')
print(a)                       # 有返回值的len函数
print(len('hello python'))

def fun():
    num = 600
    score = num / 6

fun()                     # 打印结果为空，没有输出
print(fun())              # 打印结果为None


def fun2(str="成都DCS"):
    s = str
    return s       # 把s的结果返回给函数的调用处、谁调用了fun这个函数，谁就拿到了s的值

fun2()             # 打印结果为空
print(fun2())      # 打印结果：成都DCS


def num ():
    num = 600
    a = num / 100
    return a
    print(a)       # 一旦函数内部碰到return就会直接把结果返回回去，后面的代码不会被执行

num()              # 运行结果为空
print(num())


def fun():
    num1 = 100
    b = num1 +10
    print(b)
    return b

fun()
print(fun())      # 相当于打印两次

总结:
有时候函数并不是要显示什么内容,而是把一个值返回给调用者,例如len函数
函数内部通过return返回给调用者一个值
return 后面可以是常量也可以是变量也可以是表达式

def my_max(num1,num2):
    if num1 > num2:
        return num1
    else:
        return num2
a  = my_max(50,6)
print(a)

练习题:定义一个函数,有两个参数,start和stop,start代表开始范围,stop代表终止范围,求这个范围中所有整数相加的和

def my_func1(start,stop):
    sum = 0
    a = start

    while a <= stop:
        sum += a
        a += 1
    return sum

num1 = my_func1(-9,40)

print(num1)

十二、return 的作用和意义

需求不停的变化,但函数一旦定义,函数内部的代码不应该因为需求改变而改变

所以要把因为需求而改变的代码放到函数之外,函数之内的代码,定义完后不改变

需求1:计算两个整数的和,当和大于10的时候,显示10,当和大于10的时候,显示太大了,当和小于10时,显示太小了

def my_sum(a,b):
    sum = a + b
    if sum == 10:
        print(10)
    elif sum > 10:
        print('太大了')
    else:
        print('太小了')
my_sum(4,9)

需求2:计算两个整数的和,当和等于1000的时候,显示1000,当和大于1000的时候,显示太小了,当和小于1000时,显示太小了

def my_sum(a,b):
    return a + b
sum = my_sum(200,8020)

if sum == 1000:
    print(sum)
elif sum > 1000:
    print('太大了')
else:
    print('太小了')

设计程序原则：需求随时可能会变化,可以修改函数外部的代码,但函数定义后,不应该修改函数内部的代码

练习:定义一个函数能够根据半径求出圆的面积

def cir(r):
    Π = 3.14
    s = Π * r ** 2
    return s
print(cir(8))

def my_func(num1,num2):
    if num1 % num2 == 0:
        return True
    else:
        return False
print(my_func(8,4))

十三、函数嵌套:一个函数的内部调用另一个函数

def test1():
    print('我是test1')


def my_name():
    print('我是my_name')

def test2():
    test1()     # test2函数调用test1函数
    my_name()

test2()

函数的传递

需求:编写一个求平均分的函数、然后根据各科平均分判断是否为优秀学生

def avg():
    num = 600
    score = num / 6
    return score
    
def is_good_student():
    # # 函数的传递
    value = avg()         # 把avg函数的返回值赋值给value变量、谁调用avg函数谁就拿到了返回值
    if value >  80:
        print('优秀学生')
    else:
        print('不是优秀学生')
        
if __name__ == '__main__':
    is_good_student()

假如是登入银行系统并显示余额，这里是两个功能一个是登入，第二个是登入后显示余额，我们当然可以写在主函数中，这样代码不简洁，我们要实现函数化编程，将不同的功能写成函数，然后在主程序中调用，同时也讲解return的用法。

def denglu():
    name = input("请输入账号：")
    if name == "张三":
        pwd = input("请输入密码：")
        if pwd == "942942":
            yzm = input("请输入验证码：")
            if yzm == "abcd":
                print("登陆成功")
                return True
            else:
                print("登陆失败")
                return False
        else:
            print("密码错误登陆失败")
    else:
        print("账号错误登陆失败")

def chaxun():
    veler = denglu()
    if veler == True:
        print("查询的余额为：百万富翁")
    else:
        pass
    
chaxun()

缺省值==》默认值

def my_test1(a, b = 10):     # 形参b有缺省值
    print(a, b)

def my_test2(a = 1, b = 2):
    print(a, b)

my_test1(1, 2)
my_test1(100)

my_test2()
my_test2(100, 12)

# def my_test3(a = 10, b):  不能把有缺省值的形参写到没缺省值形参的前面
#     print(a, b)

元组和字典拆包

# 1. 拆包元组数据
def return_num():
    return 100, 200

# result = return_num()
# print(result)
num1, num2 = return_num()    # 用两个参数接收
print(num1)
print(num2)


# 2. 字典数据拆包: 变量存储的数据是key值
# 先准备字典，然后拆包
dict1 = {'name': 'TOM', 'age': 20}
# dict1中有两个键值对，拆包的时候用两个变量接收数据
a, b = dict1
print(a)
print(b)

# v值
print(dict1[a])
print(dict1[b])

交换变量的值

a, b = 1, 2
print(a)
print(b)

a, b = b, a
print(a)
print(b)

引用

# 可变和不可变

# 1. 不可变：int： 1.1 声明变量保存整型数据，把这个数据赋值到另一个变量； 
# id()检测两个变量的id值(内存的十进制值)
a = 1
b = a

print(b)                   # 1

# 发现a和b的id值相同的
print(id(a))               # 140712465359504
print(id(b))               # 140712465359504

# 修改a的数据测试id值
a = 2
print(b)                   # 1

# 因为修改了a的数据，内存要开辟另外一份内存取存储2，id检测a和b的地址不同
print(id(a))               # 140712465359536
print(id(b))               # 140712465359504


# 2. 可变类型：列表
aa = [10, 20]
bb = aa
print(bb)               # [10, 20]

print(id(aa))           # 1876731847304
print(id(bb))           # 1876731847304

aa.append(30)
print(aa)               # [10, 20, 30]
print(bb)               # [10, 20, 30]  列表是可变类型

print(id(aa))           # 1876731847304
print(id(bb))           # 1876731847304

引用是否可以当做实参

def test1(a):
    print(a)
    print(id(a))
    print("--------------")
    a += a
    print(a)
    print(id(a))
    print("--------------")

b = 100
test1(b)

c = [11, 22]
test1(c)