【python学习】-学习笔记.06

# python学习Tips:
# ///////////PY.06:函数///////////////////////////////////
# ====================================================

# 目录：
# 一、函数的定义和调用
# 二、函数的文档说明（函数的功能注释）
# 三、带参数的函数
# 四、局部变量与全局变量
# 五、函数返回值
# 六、函数的嵌套调用
# 七、函数的传参写法（位置传参、关键字传参、混合方式）
# 八、函数的参数（补充知识）
# 九、函数的参数应用练习题：求和
# 十、函数形参的完整格式

# ====================================================
# 函数：可以实现某个特殊且具体的功能，是多行代码的整合
# 定义函数时，函数的代码不会执行，只有在调用时才会执行
# 用处：重复的代码不需要重复书写，减少代码冗余

# /////////////////一、函数的定义和调用//////////////////////
# =======1.函数的定义===========
# 函数定义的格式：
# def 函数名（）:      #函数命名要遵守标识符的规则（字母数字下划线组成，且数字不能打头），见名知意
#     代码/函数体
def func():
    print('好好学习，天天向上')
    print('欲穷千里目，更上一层楼')


# 定义函数时尽量前后都空两行
# （或者一键操作：Ctrl+Alt+l：会按照pep8的代码规范来格式化代码）

# ========2.调用函数============
# 在定义了函数之后，就相当于拥有了一个具有某些功能的代码，
# 之后只需要调用该函数就可以执行
# 通过： 函数名（）即可调用
func()
func()
func()

# /////////////////二、函数的文档说明（函数的功能注释）//////////////////////
# 也就是函数的使用说明
# 有特定的位置书写要求：要写在函数的下面
# 查看可以使用help(函数名)
def func1():
    """
    打印或者输出一个hello world
    """
    print('hello world')
 
    
func1()
help(print)
help(func1)

print(help(func1))
# 输出：
# Help on function func1 in module __main__:

# func1()
#     打印或者输出一个hello world

# None
    

# /////////////////三、带参数的函数//////////////////////
# 使函数代码更加通用，适用于更多的场景
# 定义函数：
def add(a,b): # a 和 b 称为形式参数/形参
    # a = 10
    # b = 20
    c = a + b
    print(f"求和的结果是{c}")
    

# 调用函数：若函数有形参，则在调用时，必须传递实际参数
add(20,10)  # 这里的20和10被称为实际参数（实参）
            # 函数调用时，会把实参传递给形参
            # 实参和形参的个数需对应
            
# ///////////四、局部变量与全局变量//////////////////
# =========1.局部变量=======================
# 局部变量：在函数内部定义的变量
# （只能在函数内部使用，不能在外部和其他函数中使用）
# 局部变量的作用，是为了临时保存数据，需要在函数中定义变量来储存；
# 当函数调用时，局部变量被创建，当函数调用完成后这个变量就不能再使用了
def func():
    # 定义局部变量num
    num = 100
    print(num)
    

def func1():
    num = 200
    print(num) # 这个num和func()中的num没有关系
    

# 函数调用
func()


# ==========2.全局变量========================
# 全局变量：在函数外部定义的变量
# （在函数内部可以访问全局变量的值，但想要修改，需要用global关键字）
# 定义全局变量：
g_num = 100

# 探究：
# 1、能否在函数内部访问全局变量？=======>>可以直接访问全局变量的值
def func2():
    print(g_num)
    
# 2、能否在函数内部修改全局变量的值？========>>不能
def func3():
    g_num = 200
    # 定义一个局部变量，只是和全局变量名字一样而已
    # 若需要在函数内部修改全局变量的值，需要用global关键字声明这个变量是全局变量
    
func2() # 100
func3() # 200
func2() # 100

# ////////////五、函数返回值/////////////////////////
# =========1.return返回值===========

# 返回值：在函数中定义的局部变量，或者通过计算得出的局部变量，
# 需要在外部访问和使用时，可以用return关键字，将这个返回值返回
# return关键字的作用：1.将后面的数值返回；2.程序代码遇到return时，会终止
# ！！注意：return 关键字必须写在函数中

def add(a,b):
    c =a + b
    # 需要将求和的结果c返回到函数外部来使用
    return c # 函数遇到return就结束了，不会再运行return之后的代码
    print(f'求和的结果是{c}')
    
    
result = add(100,200)
print(f'函数外部获得了求和的结果{result}')

# ===========2.return返回多个数据值===========
# 1.程序代码遇到一个return后，后面的就不会再执行

def func(a,b):
    c = a + b 
    d = a - b
    # 将c和d都返回，可以放到容器中
    return(c, d)
    # return [c, d]  返回列表也可以
    # return{0: c, 1: d}  返回字典也可以
    # return c, d  这种写法默认是返回元组

result = func(10, 20)
print(f"a+b的结果是{result[0]},a-b的结果是{result[1]}")

# ==========3.return返回none=============
# （1）return 关键字后面可以不写数据值，默认返回none
def func():
    print('hello !')
    return # 返回None,终止函数的运行
# （2）函数里可以不写return，返回值默认是None
def func():
    print('hello !')
    pass

# 要在函数外面使用函数中定义的局部变量，就要使用return

#///////////////六、函数的嵌套调用//////////////

# 函数的嵌套调用：在函数里面再调用另一个函数
def func1():
    print('func1 start……')
    print('函数的其他代码')
    print('func1 end……')
    

def func2():
    print('func2 start……')
    func1()     # 内部调用func1
    print('func2 end……')
    
    
# 调用func1()
func1()
# 调用func2()
func2()

# 函数内部不能调用自己本身这个函数（禁止套娃！）
# 禁止两个或多个函数之间互相调用，形成闭环（禁止套娃！！）

# ////////////七、函数的传参写法///////////////
# 函数传参有三种形式：
# 1.位置传参
# 2.关键字传参
# 3.混合使用
def func(a, b, c):
    print(f"a:{a}")
    print(f"b:{b}")
    print(f"c:{c}")
# =============1.位置传参===========
# 位置传参：按照形参的位置顺序将实参的值传递给形参
func(1, 2, 3)
func(3, 1, 2)

#=============2.关键字传参===========
# 关键字传参：指定实参给到哪个形参
# 注意：此处的关键字必须是函数的形参名
func(c=10, a=20, b=30)
# 这样写就可以变换位置了

#============3.混合使用===============
# 混合使用：先写位置传参，再写关键字传参
# (位置参数要跟在关键字参数的后面)
# 仍然遵守位置对应，所以若混合使用可能会冲突：多重赋值
def func1(a, b, c):
    print(f"a:{a}")
    print(f"b:{b}")
    print(f"c:{c}")


func(10, 20, c=30)  # c = 30 写在最后面

func(50, b = 40, c = 60) # 混合写法没办法给a或者ab单独赋值

# 因此建议不要混合使用，就单独用一种，不容易出错

# ///////////八、函数的参数（补充知识）////////////////
# 函数的形参分为两种：缺省参数（默认参数）和不定长参数

#=========1.缺省参数（默认参数）============
# 缺省参数：形参，在函数定义时，给形参一个默认值，这个形参就是缺省参数
# 特点：
#       在调用函数时，若给出了指定实参，则传递实参的数值；
#       若未给出，则使用默认值

# 示例：
def func1(a, b, c=10): # 这里的形参c，就称为 缺省形参
    print(f"a:{a}")
    print(f"b:{b}")
    print(f"c:{c}")



func(1,2) # 没有给定c的实参，使用默认值10
func(1,2,3) # 给c传递了实参，就用这个实参3

##！！规则注意：在def函数时，缺省参数必须写在其他参数后面
##          若写在了前面，则其他参数也必须是缺省参数
## 示例：
# def func(a=10, b, c)   # 这是错误的，a是缺省参数，则b和c也必须是，得改成如下：
# def func(a=10, b=20, c=30)


#=========2.不定长参数=====================
# 不定长参数：写多少个就打印多少个

# def print(self, *args, sep='', end='\n', file=None):
# sep表示输入字词之间用什么隔开，一般有：
#   sep = '*'/ sep = '_*_'/ sep = ' '()空格
   
 # *args指代了不定长参数，可以接收所有的未定长参数
# 示例：
def func(args, kwargs): # 两个普通的形参
    print(args)
    print(kwargs)

# 普通的调用方式：
func(1, 3)
func(args=2, kwargs=3)
   
# （1）变成不定长元组： 
# 在形参前面加上一个*，则这个形参就变成了不定长元组参数
# 可以接收所有的位置实参，类型是元组

#（2）变成不定长字典：
# 在形参前面加上2个*，（**），则这个形参就变成了不定长字典参数
# 可以接收所有的关键字实参，类型是字典

##示例：
def func(*args, **kwargs):
    print(args)
    print(kwargs)
    
    
func(1, 2, 3, 4, 5)
# # 输出：（数字全部付给了args元组，字典为空）
# (1, 2, 3, 4, 5)
# {}

func(a=1, b=2, c=3, d=4)
# 输出：（字对全给了字典，元组为空）
# ()
# {'a': 1, 'b': 2, 'c': 3, 'd': 4}

func(1, 2, 3, a=4, b=5, c=6)
# 输出：（按照格式，把数值分别赋给了元组和字典）
# (1, 2, 3)
# {'a': 4, 'b': 5, 'c': 6}

# /////////九、函数的参数应用练习题：求和///////////
# 要求：写一个求和的程序

# 自答：
def my_sum(*args):
    sum = 0
    for i in args:
        sum += i
    print(f'所有数字的加和结果是{sum}')
    
    
my_sum(2, 5, 8, 9, 7)

# 输出：所有数字的加和结果是31

# 标答参考：
def my_sum1(*args, **kwargs):
    num = 0
    for i in args:
        num += i
        
    for j in kwargs.values():  
        # 第二个循环num的初始值继承自第一个循环的计算结果，
        # 然后在这个基础上进行第二个循环的累加
        num += j
    print(f'求和的结果为{num}')
    
    
my_sum1(1, 2, 3, a=4, b=5, c=6)
# 输出：求和的结果为21


##！！！注意：
# 函数定义中的args和kargs可以是任意的形参变量，
# 不过习惯使用args和kargs.



#/////////十、函数形参的完整格式///////////////////
# 种类： 普通形参； 缺省形参； 不定长元组形参； 不定长字典形参
def func(a, b=1): # 先写普通再写缺省
    pass

# def func1(a, b=1, *args):  # 顺序不对，语法上不会报错，但缺省参数不会使用默认值
#     print('a',a)
#     print('b',b)
#     print(args)
   
    
def func2(a, *args, b=1):
    print('a',a)
    print('b',b)
    print(args)
    
    
    
# func1(1, 2, 3, 4)
func2(1, 2, 3, 4)
# 输出：
# a 1
# b 1
# (2, 3, 4)

func2(1, 2, 3, 4, b=10)
# 输出：
# a 1
# b 10
# (2, 3, 4)


# 注意！！
# 书写顺序：普通形参； 不定长元组形参；缺省形参； 不定长字典形参
# 完整的种类混合情况顺序示例：
def func3(a, *args, b=10, **kwargs):
    print('a', a)
    print('b', b)
    print(args)
    print(kwargs)
    print(a + b)
 
    
func3(2, 5, 6, 7, 9, 27, b=35, c=88, d=39, e=56)
# 输出：
# a 2
# b 35
# (5, 6, 7, 9, 27)
# {'c': 88, 'd': 39, 'e': 56}
# 37


# ///////////////十一、拆包//////////////////////////////

# =========1.组包与拆包==================
# （1）组包：将多个数据值给一个变量
# 比如：
# 组包1：
a = 1, 2, 3
print(a, type(a))  # 输出：(1, 2, 3) <class 'tuple'>
# 组包2：
def func():
    return 1, 2 #组包
    

print(func())  # 输出：(1, 2)

#（2）拆包：将容器的数据分别给到多个变量。
#    需要注意：数据的个数和变量的个数要保持一致

# 1：(变量拆包)
a = 1, 2, 3   # 组包
b, c , d = a  # 拆包：找对应数量的几个变量来装数据，拆出来
print(f"b={b}, c={c}, d={d}")
# 输出：b=1, c=2, d=3

# 2：（函数拆包）
def func():
    return 1, 2 #组包


e, f = func()
print(e, f) # 输出： 1 2

# 3:（列表拆包）    # 或者：
a, b =[10, 20]     # list = [10, 20]
print(a, b)        # a, b = list
                   # print(a, b)
                
# 4：（字典拆包）
my_dict = {'name':'issac','age':18}
a, b = my_dict  # key值，而非value值
print(a, b)     # 输出：name age

# =========2.练习应用=============
# 要求：有a,b两个变量的值，写一个函数交换a和b的值
# 自答(方法一)：仅靠引入一个临时变量就可以
def exchange(a, b):
    c = a
    a = b
    b = c
    print('a',a)
    print('b',b)
    
    
exchange(a=10, b=15)
# 输出：
# a 15
# b 10

# 标答参考（方法二）：如果不依靠引入新的变量解决该问题：
def exchange1(a, b):
    a = a + b
    b = a - b  # 注意：此处的a已经改变了
    a = a - b
    print('a',a)
    print('b',b)


exchange1(a=25, b=72)
# 输出：a 72  b 25

# python中的使用：用组包和拆包的方法（方法三）
def exchange2(a, b):
    a, b = b, a     # 一行代码即可
    print('a',a)
    print('b',b)


exchange1(a=25, b=72)

# ///////////////十二、引用//////////////////////////////
# 在python中，数据值是靠引用来传递的
# 可以使用id()来查看变量的引用，可以将id值认为是内存地址的别名
# python中数据值的传递是引用
# 赋值运算符可以改变变量的引用

# 将数据值存储到变量a中：本质是将数据值10所在内存的引用地址保存到变量a中
a = 10
# 将变量a中保存的引用地址给到b
b = a
print(a,b)  # 打印变量a和b引用中存储的值
print(id(a),id(b))

my_list = [1, 2, 3] # 将列表的引用地址保存到变量my_list中
my_list1 = my_list # 将my_list1变量中存储的引用地址给到my_list