python——def函数梳理

'''
函数的基础定义语法：
def 函数名（传入参数):
    函数体
    return 返回值（表达式）
变量=函数名（参数）
注意：
1、参数不需要时，可以省略
2、返回值不需要时，可以省略

'''


# 定义一个函数，输出相关信息：
def say_hi():
    print("hi，我是新手，正在起飞")
# 调用函数，让定义的函数开始工作
say_hi()  # 输出结果：hi，我是新手，正在起飞

'''
练习案例：自动查核酸
定义一个函数，函数名任意，要求调用函数后可以输出如下欢迎语：
”欢迎来到黑马程序员！
请出示您的健康码以及72小时核酸证明！
'''
def check(): # 定义一个检查函数
    print("欢迎来到黑马程序员！\n请出示您的健康码以及72小时核酸证明！") # \n表示换行
check()


'''
内容一：函数的传入参数
传入参数的功能：在函数进行计算的时候，接收外部（调用时）提供的数据
有如下代码，完成了2个数字相加的功能：
def add():
    result=1+2
    print(f"1+2的结果是:{result}")
这样写代码，函数的功能非常局限，只能计算1+2
有没有可能实现，每一次使用函数，去计算用户指定的2个数字。
def add(x,y):
    result=x+y
    print(f"{x}+{y}的结果是:{result}")

'''
def add():
    result=1+2
    print(f"1+2的结果是:{result}")
# 调用函数
add()

def add_1(x,y):   # 这时候的x、y并没有进行赋值，因而是形式参数
    result=x+y
    print(f"{x}+{y}等于:{result}")
# 调用函数，这里x和y都要可以随便取值，取值后就是实际参数
add_1(9,10) #输出结果：9+10等于:19
add_1(3,6)  #输出结果：3+6等于:9

'''
形式参数和实际参数
·形式参数：
def关键字语句所在行括号里面的参数叫形式参数，一般简称形参，是函数定义时的参数，用于接收函数调用时用户输入的实际参数。
因此在定义函数时，函数的形参不代表任何具体的值，
只有函数在被调用时，才会有具体的值赋值给形参，形参个数不限量，超过1个，各个参数之间就要用英文逗号隔开，要和形式参数顺序一一对应。
·实际参数：
调用函数时输入的参数叫实际参数，简称实参，用于接收函数调用时用户传递的值，这个值传递方法有不同情况，输入错误可能报错。
'''

'''
练习案例：升级版自动查核酸
定义一个函数，函数名任意，并接收一个参数传入（数字类类型，表示体温）
在函数内进行体温判断（正常范围：小于等于37.5度），并输出如下内容：

”欢迎来到黑马程序员！请出示您的健康码以及72小时核酸证明！并配合测量体温！您的体温是：37.5度，体温正常，欢迎进入！
”欢迎来到黑马程序员！请出示您的健康码以及72小时核酸证明！并配合测量体温！您的体温是：39.5度，体温异常，需要隔离！
'''
def check(x): #  定义一个函数，接收一个形式参数，数字类型表示体温
    print(f"欢迎来到黑马程序员！请出示您的健康码以及72小时核酸证明！并配合测量体温")
    if x<=37.5:
        print(f"您的体温是：{x}度，体温正常，欢迎进入！")
    else:
        print(f"您的体温是：{x}度，体温异常，需要隔离！")
# 调用函数，传入实际参数
check(37.5)
check(39.5)
'''
欢迎来到黑马程序员！请出示您的健康码以及72小时核酸证明！并配合测量体温
您的体温是：37.5度，体温正常，欢迎进入！
欢迎来到黑马程序员！请出示您的健康码以及72小时核酸证明！并配合测量体温
您的体温是：39.5度，体温异常，需要隔离！
'''

'''
内容二：函数的返回值
1、函数返回值的定义:两数相加，会将相加的结果返回给函数调用者，所以，变量r接收到了函数的执行结果。
程序中的返回值
def add(a,b):
    result=a+b
    return result 
r=add(1,2)
print(r)
'''
# 情况1:有返回值
def add_numbers(a, b):
    result = a + b
    return result

sum_result = add_numbers(3, 5) # 把函数传入实际参数3和5后，将运行的结果8返回给函数，并将8赋值给一个新变量。
print(sum_result)  # 输出 8
# 情况2：没有返回值，返回特殊值None
def add_numbers(a, b):
    result = a + b

sum_result = add_numbers(7, 5)
print(sum_result)  # 此时，没有返回值，输出：None

'''在这个例子中，add_numbers函数通过return语句返回了a + b的结果。
当我们调用这个函数并传入数字3和5时，函数会计算出和（即8），
然后通过return语句将这个结果返回。我们将这个返回值存储在变量sum_result中，并打印出来.'''

'''
2、None值
值得注意的是，return语句不仅可以返回简单的值，还可以返回复杂的数据结构，如列表、字典等。
此外，如果函数没有return语句或者return后面没有任何表达式，那么函数将返回一个特殊的值——None。
None在Python中代表空或无值，它是Python中的一个特殊类型。'''
# 返回值是复杂的结构。在这个例子中，我们定义了一个名为get_name_and_age的函数，
# 它返回一个元组，包含一个名字和一个年龄。当我们调用这个函数时，我们可以使用元组解包将返回的值赋给两个变量。
def get_name_and_age():
    return "张三", 18

name, age = get_name_and_age()
print(name)  # 输出：张三
print(age)   # 输出：18


'''
def say_hi():
    print("你好呀!")
result=say_hi()
print(f"无返回值函数，返回的内容是：{result}") # 输出结果中；无返回值函数，返回的内容是：None
print(f"无返回值函数，返回的内容类型是：「、{type(result)}") #输出结果：无返回值函数，返回的内容类型是：「、<class 'NoneType'>


def say_hi():
    result=say_hi() # result 表达式没有任何其他计算公式，因此下面打印的结果仍然是None
print(result) # 输出解雇：None

'''

'''
None 类型的应用场景
None作为一个特殊的字面量，用于表示：空、无意义、有很多应用场景
1、用在函数返回值上
2、用在if判断上
   ·在if 判断中，None等同于False
   ·一般用于在函数中主动返回None，配合if判断做相关处理
3、用于声明无内容的变量上
   · 定义变量，但暂时不需要变量有具体值，可以用None来代替,暂时不赋值变量具体值
   name=None

'''
# 主动返回None的函数
def say_hi2():
    print("你好呀!")  # 输出结果：“你好呀”
    return None
result=say_hi2()
print(f"无返回值函数，返回的内容是：{result}") # 输出结果中；无返回值函数，返回的内容是：None
print(result)  #输出结果：None

def say_hi2():
    print("你好呀!")   # 输出内容：“你好呀”
    return "加油，加油"
result=say_hi2()
print(f"与上一例子对比，我将返回值随便定义为“加油，加油”，，返回的内容是：{result}") # 与上一例子对比，我将返回值随便定义为“加油，加油”，，返回的内容是：加油，加油
print(result)  # 输出结果也不再是None，而是：加油加油

# None用于if判断：
def check_age(age):
    if age>18:
        return "已满18岁，可以进入"
    else:
        return None

result=check_age(22) #返回值："已满18岁，可以进入"
result_1=check_age(16) # 返回值是None
if not result_1: #双重否定表示肯定，if判断语句，在肯定情况下执行下面要做的事情。也可以写成if result==None:
    print("未成年人，不可以进入") # 返回值None==None,所以要打印“未成年人，不可以进入”
print(result)  # result=check_age(22)的返回值是： "已满18岁，可以进入"，所以输出结果：已满18岁，可以进入。

# None用于声明无初始内容的变量，一开始不用对变量赋值时
name=None

'''
如果参数较多，而又希望只对其中的一些进行指定，关键字参数可能更好，否则还得对着每个形参位置输入实参。
关键字参数让我们不再需要考虑参数的顺序，函数的使用将更加容易。
注意，Python允许用户同时使用位置参数和关键字参数，但遵循位置参数在前，关键字参数在后的原则，否则会显示语法错误，无法执行。
'''
def happy_new_year(name,year):
    print('祝愿'+name+str(year)+'年快乐')
#调用函数,关键字参数在前，位置参数在后
#happy_new_year(name='哆猫咪',2024)
#运行结果如下
#SyntaxError: positional argument follows keyword argument
#语法错误:位置参数跟在关键字参数后面

# 08 函数的说明文档
'''
函数时纯代码语言，想要理解其含义，就需要一行行的阅读理解代码，效率比较低。
我们可以给函数添加说明文档，辅助理解函数的作用，
语法如下：
def add(x,y):
    """
    函数说明
    ：param X:形式参数x的说明
    ：param y:相似参数y的说明
    ；return: 返回值的说明
    """
    result=x+y
    print(f"2数相加的结果是
    return result
    
add(5,6)
'''  # 通过多行注释的形式，对函数进行说明解释；内容应该写在函数体之前


def add(x, y):
    """
    函数说明
    ：param X:形式参数x的说明
    ：param y:实际参数y的说明
    ：return: 返回值的说明
    """
    result = x + y
    print(f"2数相加的结果是{result}")
    return result

add(5, 6)

# 09 函数的嵌套调用
'''
1、什么是函数的嵌套？
  · 所谓函数嵌套调用是指一个函数里面又调用另外一个函数；
  · 在函数A执行到调用函数B的语句，会将函数B全部执行完成后，继续执行函数A的剩余内容。
def func_b():
    print("---2---")
def func_a():
    print("---1---")
    func_b():
    print("---3---")
# 调用函数func_a()
'''
# 定义函数func_b
def func_b():
    print("---2---")
# 定义函数func_a,并在内部调用func_b
def func_a():
    print("---1---") # 第一步执行
    # 嵌套调用函数func_b
    func_b()   #第二步执行
    print("---3---") # 第三步执行
# 调用函数func_a()
func_a()

# 10 变量在函数中的作用域
'''
变量作用域指的是变量的作用范围（变量在哪里可用，在哪里不可用）
主要分类为：局部变量和全局变量

所谓局部变量是在函数体内部的变量，即只在函数体内部生效效
局部变量的作用：在函数体内部，临时保存数据，即当函数点用完成后，则销毁局部变量。
def testA():
    num=100
    print(num)
testA()  # 100
print(num) # 报错：name'num'is not defined
变量a是定义在‘testA'函数内部的变量，在函数外部访问则立即报错。
'''
# 局部变量
def testA():
    num=155
    num_1=377
    print(num)
    print(num_1)
a=testA()  # 输出结果：155、377
# 局部变量的作用：在函数体内部，临时保存数据，即当函数调用完成后，则销毁局部变量。
#print(num) # 报错：name'num'is not defined
print(a) # 输出结果：None,因为testA运行完后,并没有返回值，所以不能存储数值
print(testA()) # 输出结果：100、300、None；因为testA()先调用,再打印print(a)=None.

# 全局变量
'''全局变量可以在整个代码文件中访问，可以在函数外定义赋值，也可以在函数内用global关键字转变为作用域。
当我们在函数外部定义变量时，默认情况下它是全局的。当全局变量和局部变量的名称相同时,在函数内部局部变量优先级高。'''
num_2=666
def test_1():
    print(f"test_1:{num_2}")
def test_2():
    print(f"test_2:{num_2}")

test_1() # 输出内容：test_1:666
test_2() # 输出内容：test_2:666
print(num_2) # 输出内容：666

# 将函数内的局部变量修改为全局变量
num_3=666
def test_1():
    print(f"test_1:{num_3}")
def test_2():
    num_3=888  # 这次修改的num_3,有变成了局部变量。但不会对print(num_3)输出有影响
    print(f"test_2:{num_3}")

test_1() # 输出内容：test_1:666
test_2() # 输出内容：test_2:888
print(num_3) # 输出内容：666。
   # 使用global关键字，让在内部修改的函数变量也能在外部打印出来。
num_4=123
def test_1():
    print(f"test_1:{num_4}")
def test_2():
    global num_4 # global关键字声明num_4是全局变量
    num_4=1314  # 有了声明后，这次修改的num_4,变成了全局部变量。
    print(f"test_2:{num_4}")

test_1() # 输出内容：test_1:123
test_2() # 输出内容：test_2:1314
print(num_4) # 输出内容：1314
'''
# 注意！声明和赋值，必须是分开执行，而且顺序先通过global声明是全局变量，再给变量赋值。
def add():
    s = 118899
    global s # 声明在赋值后面了
print(add())
print(s)
#运行结果如下
# SyntaxError: name 'a' is assigned to before global declaration
#语法错误：变量a在全局声明前已经存在'''

'''
离开函数作用域后，重名变量会输出全局变量。
s=50
def add():
    s = 100
    return s+1
print(add())
print(s)
#运行结果如下
101
50
'''

'''
global关键字只是告诉Python解释器函数内部变量s要变为全局变量，但是s变量在函数运行完毕后就消失了。
通过其他操作调用自定义函数（例如使用print函数或自定义函数赋值给一个新变量），变量s的声明和赋值才算执行。
def add():
    global s
    s = 100
print(s)
#运行结果如下
NameError: name 's' is not defined
#名称错误:未定义名称“s”

def add():
    global s
    s = 100
add() # 没有结果，不打印
print(add())  # s在函数中的运行结束，且函数没否返回值，所以print(add())的打印结果是None
print(s) #n 直接按照全局变量打印出来，打印结果100
print(s*s)
#运行结果如下
None
100
10000
'''