python变量缺省函数元组和字典的拆包递归一文详解

本文链接：https://blog.csdn.net/weixin_46900108/article/details/119709216

变量的进阶：

变量的引用变量和数据都是在内存中保存的，在python中内函数的参数传递以及返回值都是靠引用传递的

变量和数据是分开存储的

例子：

def test(num):
    print("函数内部%d对应的内存地址是%d"%(num,id(num)))
    #1.定义一个字符串变量
    result = "hello"
    print("函数要返回的数据的内存地址%d"%id(result))
    #2.将字符串变量返回
    return result

#1.定义一个数字的变量
a =10
print("a变量保存数据的内存位置为%s"%(id(a)))

#2.调用test函数,本质上上是实参保存的数据
#注意 如果函数有返回值，但是没有定义变量接收
#程序不会报错，但是无法获得返回结果
r = test(a)
print("%s的内存地址为%d"%(r,id(r)))

可变类型和不可变类型：

不可变类型：

数字类型： int bool float complex long(2.x)

字符串： str

元组： tuple

可变类型：

列表： list

字典： dict

局部变量和全局变量：

全局变量可以在所有的函数内使用

局部变量只能在函数内部使用

def demo1():
    num =10
    print("在demo1函数内部的变量为%d"%num)
demo1()

局部变量的生命周期

所谓生命周期就是被创建到被系统回收的过程

函数的参数和返回值的作用：

定义函数时是通过实际的功能和需求进行决定的

1.如果函数内部处理的数据不确定，就可以将外界的数据以参数传递到函数内部

2.如果希望一个函数执行完成后，向外界汇报执行结果，就可以增加函数的返回值

对于函数的返回值的示例：

def measure():
    """测量温度和湿度"""
    print("测量开始...")
    temp = 39
    wetness =50
    print("测量结束...")
    #元组可以包含多个数据，因此可以通过元组让函数返回多个值
    #如果函数返回的类型是元组，小括号可以省略
    # return temp,wetness
    return (temp,wetness)
result=measure()
print(result)

对于函数的高级操作

def measure():
    """测量温度和湿度"""
    print("测量开始...")
    temp = 39
    wetness =50
    print("测量结束...")
    #元组可以包含多个数据，因此可以通过元组让函数返回多个值
    #如果函数返回的类型是元组，小括号可以省略
    # return temp,wetness
    return (temp,wetness)
result=measure()
print(result[0])
print(result[1])
#如果函数返回类型是元组，同时希望单独的处理元组的元素 可以使用多个变量，一次接收函数返回结果
gl_temp,gl_wetness = measure()
print(gl_temp)
print(gl_wetness)

面试题交换数字位置(使用其他变量和不使用其他变量)

a =6
b =100
#解法一 使用其他变量
c =a
a=b
b =c
#解法二 不使用其他的变量
a =a+b
b =a -b
a =a -b
#解法三 python独有 提示，等号后面是一个元组
a,b=(b,a)

print(a)
print(b)

函数内部的赋值不会对函数外部的全局变量进行修改

列表相加可以通过extend()方法

缺省参数的意义，就是默认认为是某个条件

def print_info(name,gender=True):
    """

    :param name: 下面调用输入参数的姓名
    :param gender: Ture为男生 Fslse是女生
    """
    gendertxt ="男生"
    if not gender:
        gendertxt ="女生"
        print("%s是%s"%(name,gendertxt))
print_info("老王")

缺省参数的时候我们一定要把缺省参数设置到最后一个

例如 def print_info(name,title,gender=True)

多值参数：

参数名前参数前一个* 可以接收元组

参数名前参数前两个** 可以接收字典

def demo(num,*nums,**person):
    print(num)
    print(nums)
	print(person)
demo(1)
>>1 () {}
demo(1,2,3,4,5)
>>1 (2,3,4,5) {}
demo(1,2,3,4,5,name="小明",age=18)
>>1 (2,3,4,5) {'age':18,'name':'小明'}

多值参数案例-计算任何多个数字的和

需求：定义一个函数sum_number，可以接收任意多个整数

功能要求，将传递所有数字累加，并且返回累加的结果

def sum_numbers(*args):
    num =0
    print(args)
    #通过遍历来进行相加
    for n in args:
        num =num+n
    return num
result =sum_numbers(1,2,3)
print(result)

如果要是不用缺省函数的的*来进行定义的话我们同样可以考虑将一个元组传进去进行接收，那样的话我们也可以同样获得相同的功能。

def sum_numbers(args):
    num =0
    print(args)
    #通过遍历来进行相加
    for n in args:
        num =num+n
    return num
result =sum_numbers((1,2,3,4,5))
print(result)

在函数调用时我们可以通过使用*来进行开发。

元组和字典的拆包

在调用带有多值函数时如果希望讲一个元组变量直接传递给args

将一个字典直接传给kwargs 就可以使用拆包，简化参数的传递，拆包的方式就是在元组变量前加一个* 在字典变量前增加两个*

def demo(*args,**kwargs):
    print(args)
    print(kwargs)
#元组/字典变量
gl_nums =(1,2,3)
gl_dict ={"name":"小明","age":18}
#拆包语法可以简化元组变量/字典变量的传递
demo(*gl_nums,**gl_dict)
# demo(1,2,3,name="小明",age=18)

递归

特点，函数内部可以调用其他函数，当然函数内部也可以调用自己的代码，函数内部的代码是相同的，只针对参数不同，处理结果不同，当参数满足一个条件时，函数不再执行。这个非常重要，通常被成为函数递归地出口，否则会出现死循环

def sum_number(num):
    print(num)
    #自己调用自己
    #一定要有出口，当参数满足某个条件时，不再执行函数
    if num==2:
        return
    sum_number(num -1)
sum_number(3)

递归案例：

需求：定义一个函数sum_number 能够接收一个num的整数函数，计算1+2+3+……+num的结果

def sum_number(num):
    #出口
    if num==1:
        return 1
    #数字的累加num+(1...num-1)
    #假设sum_number能够正确处理1...num-1
    temp = sum_numbers(num-1)
    return num +temp
result =sum_number(2)
print(result)