26-python函数（中阶）

一.变量作用域

（1）局部变量

指定义在函数体内部的变量，只在函数体内部生效，当函数调用完成后，局部变量会被销毁

def test():
    a = 100
    print(a)  
 
test() # 100
print(a) # a只作用于test函数内部，无法在函数体外部打印，所以报错

（2）全局变量

指定义在函数体外部的变量，在函数体内外部都生效

a = 100

def test():
    a =10
    print(a)

test() # 10，函数内部a作用于test函数内部
print(a) # 100，函数外部a作用于test函数内部和外部，可以在函数体外部打印，所以不会报错

注：在函数体内部，其局部变量优先于全代码段的全局变量

（3）global()：将局部变量转化为全局变量

a = 100

def test():
    global a
    a =10
    print(a)

test() # 10，函数内部a作用于test函数内部
print(a) # 10，函数外部 a=100 被函数体内部的global函数控制下的 a=10 覆盖

二.函数的返回值

（1）return表示跳出函数调用

def return_num():
 return 1
 return 2

result = return_num()
print(result) # 1 在函数体内自上而下执行第一次 return 时，该函数就已经调用完成了

（2）返回多个函数值

注：默认返回的是一个元组类型

def return_num():
 return 1,2

result = return_num()
print(result)

三.函数的参数

（1）位置参数

位置参数：调用函数时，根据函数定义的位置来传递参数，传递和定义参数的顺序和个数必须一致

def myself(name, age, gender):
    print(f'我的名字是{name}, 年龄是{age}, 性别是{gender}')

myself('yaoyuan', 20, '男')

（2）关键字参数

调用函数，以键值对的方式加以指定

def myself(name, age, gender):
    print(f'我的名字是{name}, 年龄是{age}, 性别是{gender}')
myself('chennan', age=20, gender='⼥')
myself('yaoyuan', gender='男', age=16)

（3）缺省参数

又名默认参数，用于定义函数，为参数提供默认值，调用函数的时候可以不传该默认函数的值

注：所有位置参数必须出现在默认参数之前

def myself(name, gender , age = 20,):
    print(f'我的名字是{name}, 年龄是{age}, 性别是{gender}')
myself('chennan',age=19,gender='⼥')
myself('yaoyuan', gender='男')

（4）不定长参数

又名可变参数，用于调用时不确定会传入多少个参数。此时，可以用包裹（packing）位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便

①下标

（其实这段代码是我老师PPT上没有的，老师也没教我们这种方法，我自己写这章博客的时候在pycharm上面突发奇想出来的，嘿嘿）

def myself(*args):
    print(f'name = {args[0]},age = {args[1]}')

myself('yaoyuan', 20)
myself('chennan')  #报错，传入的参数和函数定义的参数的数量不一致
myself('chennan',20)

②包裹位置传递

def myself(*args):
    print(args)

myself('yaoyuan') # ('yaoyuan')
myself('yaoyuan', 20) # ('yaoyuan', 20)

注：传进的所有参数都会被args变量收集，它可以根据传进的参数的位置合并成一个元组，args是一个元组类型，这就是包裹位置传递

③包裹关键词传递

def myself(**kwargs):
    print(kwargs)

myself(name='yaoyuan', age=20, id=110) # {'name': 'yaoyuan', 'age': 20, 'id': 110}

注：传进的所有参数都会被kwargs变量收集，它可以根据传进的参数的位置合并成一个字典，kwargs是一个字典类型，这就是包裹关键词传递

四.拆包

（1）元组拆包

def myself():
    return 'yaoyuan','love','chennan'

a,b,c = myself()
print(a,b,c)
print(c,b,a)

（2）字典拆包

myself= {'name': 'yaoyuan', 'age': 20}
name, age = myself

# 对字典进⾏拆包，取出来的是字典的key
print(name) # name
print(age) # age
print(myself[name]) # yaoyuan
print(myself[age]) # 20

五.交换变量值

①新增一个变量作为过渡

a = 1
b = 2

c = 0

c = a
a = b
b = c

print(a) # 2
print(b) # 1

②python中独特的交换方法

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

六.引用

（1）了解引用

在python中，靠的是引用来传递的，我们可以用id()来判断两个变量是否来自同一个值的引用，我们可以将id值理解为那块内存地址的标识

# 1. int类型
a = 1
b = a
print(b) # 1
print(id(a)) # 140708464157520
print(id(b)) # 140708464157520
# a和b来自同一个地址
a = 2
print(b) # 1,说明int类型为不可变类型
print(id(a)) # 140708464157552，此时得到是的数据2的内存地址
print(id(b)) # 140708464157520，b的地址并没有改变

# 2. 列表
aa = [10, 20]
bb = aa
print(id(aa)) # 2325297783432
print(id(bb)) # 2325297783432
aa.append(30)
print(bb) # [10, 20, 30], 列表为可变类型
print(id(aa)) # 2325297783432
print(id(bb)) # 2325297783432

（2）引用当参数

def test1(a):
 print(a)
 print(id(a))
 a += a
 print(a)
 print(id(a))
 
# int：计算前后id值不同
b = 100
test1(b)

# 列表：计算前后id值相同
c = [11, 22]
test1(c)

七.可变和不可变类型

这个你也别想着理解了，背下来
这里的变与不变着眼于数据本身，数据本身在同一个内存可以变化，其内存并未发生改变，即为可变类型

可变：列表，字典，集合

不可变：整形，浮点型，字符串，元组