python：函数-CSDN博客

本文链接：https://blog.csdn.net/isun1/article/details/140576049

列表去重

列表去重：列表中存在多个数据，需求，去除列表中重复的数据

方式1：思路

遍历原列表中的数据判断在新列表中是否存在，如果存在，不管，如果不存在放入新的列表中

遍历：for 循环实现
判断是否存在：可以使用 in
存入数据：append( )

方法 2：

在 Python 中还有⼀种数据类型（容器），称为是集合（set）

特点：集合中不能有重复的数据（如果有重复的数据会自动去重）可以使用集合的特点对列表去重

使用 set（）类型转换将列表转换为集合类型
再使用 list（）类型转换将集合转换为列表

缺点： 不能保证数据在原列表中出现的顺序（⼀般来说，也不考虑这件事）

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)

函数基础

函数的参数

# 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='_*_')