【自动化测试必学语言】python：函数_python函数float-优快云博客

my_list = [3, 2, 4, 1, 2, 3, 3, 2, 1, 2, 3, 1]
# print(list(set(my_list)))

# new_list = list(set(my_list))
# print(new_list)

new_list = []
# for i in my_list:
    # 判断新列表中是否存在 i
    if i in new_list:
        # 存在
        pass # continue
    else:
        new_list.append(i)

for i in my_list:
    if i not in new_list:
        new_list.append(i)

print(new_list)

函数基础

函数的概念

函数，就是把具有独立功能的代码块组织为⼀个小模块，在需要的时候调用
函数，通俗理解，将多行代码写在⼀块，起个名字，在需要这多行代码的时候，可以直接使用这个名字来代替
函数好处：减少代码的冗余（重复的代码不用多写），提高程序的编写效率

定义

将多行代码放在⼀块，起名字的过程，称为函数定义
函数必须先定义后调用

语法

def 函数名():
函数中的代码
函数中的代码

# 1. def 是关键字，用来定义函数的 define 的缩写
# 2. 函数名需要遵守标识符的规则
# 3. 处于 def 缩进中的代码，称为函数体
# 4. 函数定义的时候，函数体中的代码不会执行，在调用的时候才会执行

函数定义小技巧

在前期，书写不熟练的时候
1. 可以先不管函数，先把功能写出来
2. 给多行代码起名字
3. 选中多行代码，使用 tab 键进行缩进

函数调用

1. 使用多行代码的时候，称为函数调用

语法

函数名()
# 1. 函数调用的时候会执行函数体中代码
# 2. 函数调用的代码，要写在函数体外边

def say_hello():
 print('hello 1')
 print('hello 2')
 print('hello 3')
 
# 调⽤
say_hello()
say_hello()

函数的参数

# 1. 定义⼀个函数，my_sum，对两个数字进行求和计算

def my_sum ():

        num1 = 10

        num2 = 20

        num = num1 + num2

        print ( num )

my_sum ()

# 函数存在的问题，这个函数只能对 10 和 20 进行求和，不能对任意的函数进行求和计算

# 问题的解决：想要解决这个问题，可以使用函数参数来解决

函数参数： 在函数定义的时候，使用变量代替具体的数据值（进行占位），在函数调用的时候，传递具体的数据值

好处： 让函数更加通用，能够解决以类问题，而不是单纯的⼀个

函数的返回值

函数的返回值，可以理解为是函数整体执行的结果是什么

什么上班需要书写返回值：函数中得到的数据在后续的代码中还要使用，这个时候就应该将这个数据作为返回值返回，以供后续使用

print( ) ---> None
input( ) ---> 键盘输⼊的内容
type( ) ---> 类型
len( ) ---> 数据的长度（元素的个数）

在函数中想要将⼀个数据作为返回值返回，需要使用 return

关键字（只能在函数中使用）

作用：

将数据值作为返回值返回
函数代码执行遇到 return，会结束函数的执行

def my_sum(a, b):
    num = a + b
    # print(num) # 代码中没有返回值,只有 print,这个结果只能在函数中⽤⼀次,不能后续使⽤
    # 我们想要将这个求和的结果 在后续的代码中使⽤, 需要使⽤ return 将求和的结果进⾏返回
    return num     #将这个结果返回到调⽤的地⽅法
    # return 之后的代码会执⾏吗
    print('我是 return 之后的代码, 我会执⾏吗---> 不会执⾏')

# 1. 函数中没有 print, 只有 return, 想要查看结果,需要在调⽤的时候使⽤ print
print(my_sum(1, 2))

# 2, 想要将函数中返回的结果,在后续代码中使⽤, 即需要将这个数据保存下来, 需要使⽤变量来接收(保存) 函数的返回值(执⾏结果)
# 变量 = 函数()
result = my_sum(10, 20) # 将求和的结果保存到变量
result 中, 可以在后续代码中使⽤
print('使⽤: 1, 直接打印: ', result)
print('使⽤: 2, 对数字 加 10:', result + 10)

返回值的说明

def 函数名 (): # 返回值 None

        pass # 代码中没有 return

def 函数名 ():

        return # return 后边没有数据，返回值 None

def 函数名 ():

        return xx # 返回值是 xx

变量进阶【理解知道】

在这⼀部分我们了解 Python 底层是如何处理数据的

变量的引用【理解】

在定义变量的时候变量 = 数据值，Python 解释器会在内存中开辟两块空间
变量和数据都有自己的空间
日常简单理解，将数据保存到变量的内存中，本质是将数据的地址保存到变量对应的内存中
变量中存储数据地址的行为就是引用（变量引用了数据的地址，简单说就是变量中存储数据），存储的地址称为引用地址
可以使用 id( ) 来获取变量中的引用地址（即数据的地址），如果两个变量的 id( ) 获取的引用地址⼀样，即代表着，两个变量引用了同⼀个数据，是同⼀个数据
只有赋值运算符=，可以改变变量的引用（等号左边数据的引用）
python 中数据的传递，都是传递的引用

可变类型和不可变类型

数据类型： int float bool str list tuple dict set

可变不可变是指：数据所在的内存是否允许修改，允许修改就是可变类型，不允许修改就是不可变类型（不使用=，变量引用的数据中的内容是否会变化，会变化是可变的，不会变化是不可变的）

可变类型：列表 list ，字典 dict ，集合 set

列表 . append ()

字典 . pop ( 键 )

不可变类型 : int float bool str tuple

组包和拆包

组包(pack)： 将多个数据值使⽤逗号连接，组成元组

拆包(unpack)： 将容器中的数据值使用多个变量分别保存的过程，注意：变量的个数和容器中数据的个数要保持⼀致

赋值运算符，都是先执行等号右边的代码，执行的结果，保存到等号左边的变量中

# 组包
c = b, a # 组包
print(type(c), c) # <class 'tuple'> (10, 20)

# 拆包
a, b = c
print(a, b)

x, y, z = [1, 2, 3]
print(x, y, z)

局部变量和全局变量

变量：根据变量的定义位置，可以将变量分为局部变量和全局变量

局部变量

局部变量：在函数内部(函数的缩进中)定义的变量，称为是局部变量

特点：

1. 局部变量只能在当前函数内部使用，不能在其他函数和函数外部使用

2. 在不同函数中，可以定义名字相同的局部变量，两者之间没有影响

3. 生存周期(生命周期，作用范围)--> 在哪能用

在函数被调用的时候，局部变量被创建，函数调用结束，局部变量的值被销毁（删除），不能使用

所以函数中的局部变量的值，如果想要在函数外部使用，需要使用 return 关键字，将这个值进行返回

def func1():
    num = 10     # num 就是局部变量
    print(f"func1 函数中 {num}")

def func2():
    num = 100 # 可以在不同函数中定义名字相同的局部变量,没有影响
    print(f"func2 函数中 {num}")

func1() # 10
func2() # 100
func1() # 10

全局变量

定义位置：在函数外部定义的变量，称为是全局变量

特点：

1. 可以在任何函数中读取(获取) 全局变量的值

2. 如何在函数中存在和全局变量名字相同的局部变量，在函数中使用的是局部变量的值（就近）

3. 在函数内部想要修改全局变量的引用（数据值），需要添加global 关键字，对变量进行声明为全局变量

4. 生命周期

代码执行的时候被创建，代码执行结束，被销毁(删除)

g_num = 10 # 全局变量

def func1():
    print(f'func1 中 {g_num}') # 在函数中可以读取全局变量的值
def func2():
    g_num = 20 # 定义局部变量, 不会影响全局变量
    print(f'func2 中 {g_num}')
def func3():
    global g_num # 这个函数中使⽤的 g_num 都是全局变量, 写在函数的第⼀⾏
    g_num = 30 # 修改了全局变量
    print(f'func3 中 {g_num}')

# func1() # 10
# func2() # 20
# func1() # 10
# func3() # 30
# func1() # 30
print(g_num)

返回值- 函数返回多个数据值

函数中想要返回⼀个数据值，使用 return 关键字

将多个数据值组成容器进行返回，⼀般是元组（组包）

def calc(a, b):
    num = a + b
    num1 = a - b
    return num, num1

# 写法⼀
result = calc(10, 5)
print(result, result[0], result[1])

# 写法⼆, 直接拆包
x, y = calc(20, 10)
print(x,y)

函数参数

形参的不同书写方法

函数传参的方式

位置传参

在函数调用的时候，按照形参的顺序，将实参值传递给形参

关键字传参

在函数调用的时候，指定数据值给到那个形参

混合使用

关键字传参必须写在位置传参的后面
不要给⼀个形参传递多个数据值

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

# 位置传参
func(1, 2, 3)

# 关键字传参
func(a=2, b=3, c=1)

# 混合使⽤
func(1, 3, c=5)

缺省参数

缺省参数，默认参数

列表 . pop ( ) # 不写参数，删除最后⼀个

列表 . sort ( reverse = True )

1. 定义方式

在函数定义的时候，给形参⼀个默认的数据值，这个形参就变为缺省参数，注意，缺省参数的书写要放在普通参数的后边

2. 特点（好处）

缺省参数，在函数调用的时候，可以传递实参值，也可以不传递实参值

如果传参，使用的就是传递的实参值，如果不传参，使用的就是默认值

def show_info(name, sex='保密'):
    print(name, sex)

show_info('⼩王')
show_info('⼩王', '男')

多值参数【可变参数/不定长参数】

当我们在书写函数的时候，不确定参数的具体个数时，可以使用不定长参数

不定长位置参数（不定长元组参数）

1. 书写，在普通参数的前边，加上⼀个 *，这个参数就变为不定长位置参数

2. 特点，这个形参可以接收任意多个位置传参的数据

3. 数据类型，形参的类型是元组

4. 注意，不定长位置参数要写在普通的参数的后面

5. ⼀般写法，不定长位置参数的名字为 args ，即 ( * args )

# arguments

不定长关键字参数（不定长字典参数）

1. 书写，在普通参数的前边，加上两个 *，这个参数就变为不定长关键字参数

2. 特点，这个形参可以接收任意多个关键字传参的数据

3. 数据类型，形参的类型是字典

4. 注意，不定长关键字参数，要写在所有参数的最后边

5. ⼀般写法，不定长关键字参数的名字为 kwargs ，即 ( ** kwargs ) , keyword arguments

完整的参数顺序

def 函数名 ( 普通函数 , * args , 缺省参数 , ** kwargs ):

pass

# ⼀般在使用的时候，使用 1-2 种，按照这个顺序挑选书写即可

def func(*args, 
**kwargs):
    print(type(args), args)
    print(type(kwargs), kwargs)
    print('-' * 30)

func()
func(1, 2, 3) # 位置传参, 数据都给 args
func(a=1, b=2, c=3) # 关键字传参, 数据都给 kwargs
func(1, 2, 3, a=4, b=5, c=6)

Print 函数的解析

# print()
# sep=' ', 多个位置参数之间的间隔
# end='\n' 每⼀个 print 函数结束, 都会打印的内容 结束符
print(1, end=' ')
print(2, end=' ')
print(3)

print(1, 2, 3, 4, 5, 6, sep='_')
print(1, 2, 3, 4, 5, 6, sep='_*_')

不定长参数补充-函数调用时的拆包

def my_sum(*args, **kwargs):
    num = 0 # 定义变量,保存求和的结果
    for i in args:
        num += i
 
    for j in kwargs.values():
        num += j
 
    print(num)
 
# 需求, my_list = [1, 2, 3, 4] 字典 my_dict = {'a':1, 'b': 2, 'c': 3, 'd': 4}
my_list = [1, 2, 3, 4]
my_dict = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
 
# 将字典和列表中的数据使⽤ my_sum 函数进⾏求和, 改如何传参的问题
# my_sum(1, 2, 3, 4)
# my_sum(a=1, b=2, c=3, d=4)
# 想要将列表(元组)中的数据 分别作为位置参数,进⾏传参,需要对列表进⾏拆包操作
# my_sum(*my_list) # my_sum(1, 2, 3, 4)
 
# 想要将字典中的数据, 作为关键字传参,, 需要使⽤ 使⽤ **对字典进⾏拆包
my_sum(**my_dict) # my_sum(a=1, b=2, c=3, d=4)

匿名函数

匿名函数：就是使用 lambda 关键字定义的函数
⼀般称为使用 def 关键字定义的函数为，标准函数
匿名函数只能书写⼀行代码
匿名函数的返回值不需要 return ，⼀行代码（表达式）的结果就是返回值
使用场景： 作为函数的参数，这个函数比较简单，值使用⼀次，没有必要使用 def 定义

语法

lambda 参数： ⼀行代码 # 这⼀行代码，称为是表达式
# 匿名函数⼀般不需要我们主动的调用，⼀般作为函数的参数使用的
# 我们在学习阶段为了查看匿名函数定义的是否正确，可以调用
# 1. 在定义的时候，将匿名函数的引用保存到⼀个变量中
变量 = lambda 参数：⼀行代码
# 2. 使用变量进行调用
变量 ( )

代码

# 1. ⽆参⽆返回值
def func1():
    print('hello world')
 
func1()
# lambda : print('hello lambda') # 匿名函数的定义
func11 = lambda: print('hello lambda')
func11()
 
# 2. ⽆参有返回值
def func2():
    return 10
 
print(func2())
func22 = lambda: 10
print(func22())
 
# 3. 有参⽆返回值
def my_sum(a, b):
    print(a + b)
 
my_sum(1, 2)
my_sum11 = lambda a, b: print(a+b)
my_sum11(10, 20)
 
# 4. 有参有返回值
def func4(a, b):
    return a + b
print(func4(1, 2)) # num = func4(1, 2) 
print(num)
func44 = lambda a, b: a+b
 
print(func44(10, 20))

匿名函数作为函数的参数 - 列表中的字典排序

user_list = [
{ "name" : "zhangsan" , "age" : 18 } , { "name" : "lisi" , "age" : 19 } , { "name" : "wangwu" , "age" : 17 }
]
列表排序（列表中的数字）：
列表 . sort ( ) # 升序
列表 . sort ( reverse = True ) # 降序
列表中的内容都是字典，想要排序 ?

user_list = [
    {"name": "zhangsan", "age": 18},
    {"name": "lisi", "age": 19},
    {"name": "wangwu", "age": 17}
]
 
# user_list.sort()
# 列表的排序, 默认是对列表中的数据进⾏⽐⼤⼩的, 可以对数字类型和字符串进⾏⽐⼤⼩
# 但是对于字典来说,就不知道该怎么⽐⼤⼩,此时,我们需要使⽤sort函数中的key这个参数, 来指定字典⽐⼤⼩的⽅法
# key 这个参数,需要传递⼀个函数,⼀般是匿名函数, 字典的排序,其实要指定根据字典的什么键进⾏排序, 我们只需要使⽤
# 匿名函数返回字典的这个键对应的值即可
# 列表.sort(key=lambda x: x['键'])
# 根据年龄排序
# user_list.sort(key=lambda x: x['age'])
user_list.sort(key=lambda x: x['age'], reverse=True)
print(user_list)
 
# user_list.sort(key=lambda x: x['age'])
# 说明: 匿名函数中的参数是 列表中的数据, 在 sort 函数内部,会调⽤ key 这个函数(将列表中每个数据作为实参传递给形参)
# 从列表中的获取函数的返回值, 对返回值进⾏⽐⼤⼩操作(<)
 
def get_value(x):
    return x['age']
user_list.sort(key=get_value)