浅尝python 四

四、函数高级操作

1、局部变量和全局变量

1.1、可变类型与不可变类型

数据类型，整数（int），浮点数（float），布尔（bool），字符串（str），列表（list），元组（tuple），字典（dict）
划分标准：内存中数据是否允许被修改，允许被修改的 可变，否则 不可变【简单的判断标准：不使用等号，能否改变数据值】

• 可变：
  列表list， 列表.append()
  字典dict ， 字典.pop()
  集合
• 不可变
  整型 int
  浮点型 float
  字符串str
  元组tuple
  布尔bool

1.2、局部变量 和全局变量

• 局部变量
  1在函数内部定义的变量，即为局部变量，
  2 、不同函数中，可定义相同的局部变量 ，特点：局部变量的作用域为函数内部；生命周期 为函数被调用的时候创建，调用结束 在内存中被删除销毁
  3、一般的形式参数，可被认为是局部变量
• 全局变量
  1 、在函数外部定义的变量，特点：全局变量的值可以在任意函数中使用（读取）
  2、想在函数中修改全局变量的引用，需要使用global关键字声明
  3、函数内部，如果有局部变量和全局变量名称相同，在函数中默认使用以局部变量为准（就近原则）
  4、 生命周期：执行代码的时候创建，执行结束即被销毁（生命周期为代码的整个运行期间）

demo1

在引用工具的模块里定义全局变量

globale_num = 10
定义函数：
def func1():
    print(globale_num)

def func3():
    global globale_num  # 声明使用全局变量
    globale_num = 30  # 给全局变量赋值
    print(globale_num)
def func2():
    globale_num = 20  # 局部变量，不影响全局变量的值
    print(globale_num)
if __name__ == '__main__':
    func1()  # 10
    func2()  # 20
    func1()  # 10
    func3()  # 30
    func1()  # 30
    func2()  # 20
    globale_num = 40
    func1()  # 40
输出：
10
20
10
30
30
20
40

demo2

my_list = [1]


def func4():
    print(my_list)


def func5():
    my_list.append(123)


def func6():
    my_list = [10, 20]  # 局部变量


def func7():
    global my_list
    my_list = [222, 333]


if __name__ == '__main__':
    func4()  # [1]
    func5()
    func4()  # [1,123]
    print(my_list)  # [1,123]
    func6()
    func4()  # [1,123]
    func7()
    func4()  # [222, 333]
输出：
[1]
[1, 123]
[1, 123]
[1, 123]
[222, 333]

2、传参和返回值

2.1、函数传参的方式有3种

def func(a, b, c):
    print(f'a={a},b={b},c={c}')

2.1.1、位置传参

func(1, 2, 3)

2.1.2、关键字传参

【注意,关键字传参，变量名必须和函数定义变量名保持一致，否则报错】

func(a=1, b=2, c=3)

2.1.3、混合使用

关键字传参，数据必须写在位置传参的后边,【注意,关键字传参，变量名必须和函数定义变量名保持一致，否则报错】

func(1, b=12, c=14)

2.2、缺省参数

缺省参数：定义函数时，给某个参数指定一个默认值，具有默认值的参数
说明：调用函数时如果没有传入缺省参数的值，责使用默认值。
书写位置要求：缺省（默认）参数，必须写在普通参数的后边
def print(self, *args, sep=’ ‘, end=’\n’, file=None): 表示给型参一个默认的值，不填写就表示\n

def show_info(name, age=15, sex='猜'):  # 表示默认值，如果传就按实参传进来的值，如果不传，就按照函数定义这里的默认参数值
    print(f'name={name},age={age},sex={sex}')
show_info('小明', 18, '女')
show_info('小明1')
show_info('小明2', 17)
show_info('小明1', sex='男的')  # 缺省参数不止1个，可以使用关键字进行传参，ps：缺省参数必须放在普通参数后边
输出：
name=小明,age=18,sex=女
name=小明1,age=15,sex=猜
name=小明2,age=17,sex=猜
name=小明1,age=15,sex=男的

2.3、多值参数

多值参数，也称为可变参数，不定长参数，在函数定义的时候，不确定参数有多少个
在一个普通参数前边，加一个 * ，这个参数就变为不定长参数
特点：可以接收任意多个位置传参的数据，类型为元组
一般写法：一般将这个参数的名字写作args（arguments），加上 * 变为 *args
eg: print 函数中，就有可变参数/不定长参数/多值参数 *args ,args为元组类型

print(1)
print(1, 2)
print(1, 2, 3)

• 函数参数的顺序：默认值参数

def 函数( 普通参数 , *args , 缺省参数 )：

def func(a, *args, c=100):
    print(f'a:{a},args:{args},c:{c}')
func(1)  # a:1,args:(),c:100
func(1, 3, 5)  # a:1,args:(3, 5),c:100
func(1, 3, 5, c=5)  # a:1,args:(3, 5),c:5

输出：

a:1,args:(),c:100
a:1,args:(3, 5),c:100
a:1,args:(3, 5),c:5

demo

定义一个函数，可以对任意多数字加和运算并输出

def mySum(*args):  # args 默认为元组类型
    pass
    initV = 0
    for i in args:
        initV += i
    print(initV)

运算test1:

mySum()
mySum(1)
mySum(1, 2)
mySum(1, 2, 3)

输出：
0
1
3
6

运算test2:

# 多值参数应用-求和
my_list = [1, 2, 3]
my_tuple = (1, 7, 2)
# 以下为特殊的拆包
mySum(*my_list)  # 函数传参过程中的拆包
#  或者 mySum(my_list[0],my_list[1],my_list[2])
mySum(*my_tuple)

输出：
6
10

2.4、函数返回多个数据值

函数中返回数据值使用return
return 的作用，1⃣️ 返回数据值，2⃣️ 结束函数的运行
想要返回多个数据值，只需要将多个数据值变成容器（一般是元组）返回即可

demo

def calc(a,b):
    return a+b,a*b

calRs=calc(1,2)
print(calRs)

x,y=calc(3,1)
print(x,y)
输出：
(3, 2)
4 3

3、匿名函数

3.1、匿名函数

匿名函数，是指使用lambda关键字定义的函数
匿名函数，只能实现简单的功能，只能写一行代码

主要应用 ：

• 1、一般不主动调用，而是作为函数的参数，在函数内部调用，也可以使用def定义的函数作为函数的参数
• 2、若想要在函数外部调用，可以使用变量 保存匿名函数，调用形式： 变量 = lambda 参数：一行代码 【ps：变量相当于函数名】，使用变量形式 ： 变量（参数）

demo1、 定义一个匿名函数，求两个数的乘积（两个参数）

lambda x,y:x*y

想要调用匿名函数，需要使用变量保存

# 如果想要调用匿名函数，需要使用变量保存,调用方式为： 变量名（参数），如下
func =lambda x,y:x+y
print(func(1,2))
输出：
3

demo2、定义一个匿名函数，获取字典中 键为 age对应的值（参数 一个 字典）

lambda dictParam={'age': 12, 'name': 'tom'}: dictParam.get("age")

调用lambda 定义的匿名函数，使用变量保存

fun1 = lambda dictParam={'age': 12, 'name': 'tom'}: dictParam.get("age")
print(fun1(dictParam={'age': 18,'name':'tom'}))
输出：
18

3.2、匿名函数应用

常见应用：对列表中的字典排序

user_list=[
    {'name':'tom','age':28,'title':'研发'},
    {'name':'lisa','age':32,'title':'运营'},
    {'name':'jack','age':29,'title':'产品'}
]

按列表中某一元素进行排序

user_list.sort(key=lambda x:x['age'],reverse=True)
print(user_list)
输出：
[{'name': 'lisa', 'age': 32, 'title': '运营'}, {'name': 'jack', 'age': 29, 'title': '产品'}, {'name': 'tom', 'age': 28, 'title': '研发'}]

字符串大小比对

1、单个字符，按字母ask码 比较，eg：A<Z<a<z
2、字符串是按 对应下表位置的字符进行大小比对

• demo1 、比对字符串大小

print('a'>'ABC')
print('a'>'aAbc')
输出：
True
False

• demo2、给列表排序

my_list=['a','AB','XYZ','XYabc']
my_list.sort()
print(my_list)
输出：
['AB', 'XYZ', 'XYabc', 'a']

my_list.sort(key=lambda x:len(x),reverse=True)
print(my_list)
输出：
['XYabc', 'XYZ', 'AB', 'a']