Python函数：global + def + 生成器简记黑马课程

HJJ-DREAMER

已于 2023-04-22 10:56:59 修改

阅读量426

点赞数

分类专栏： Python 文章标签： python

于 2022-11-16 23:07:53 首次发布

本文链接：https://blog.csdn.net/m0_59267075/article/details/127895433

版权

Python 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

黑马简记

# -*- coding:utf8 -*-
"""
# editor: hjjdreamer
# create-time: 2022/11/15-23:07
# Python-Script: chapter5-func.py
# describe:
函数 是组织好的，可重复使用的，用来实现特定功能的代码段
"""

# example
str1 = "iteima"
str2 = "itcast"
str3 = "python"
# 定义一个数据统计
count = 0
for i in str1:
    count += 1
print(f"str1 = {str1} len = {count}")

count = 0
for i in str2:
    count += 1
print(f"str2 = {str2} len = {count}")

count = 0
for i in str3:
    count += 1
print(f"str3 = {str3} len = {count}")


# 函数优化
# 定义函数
def my_len(data):
    count = 0
    for i in data:
        count += 1
    print(f"data == {data}, len == {count}")


my_len(str1)
my_len(str2)
my_len(str3)
"""
函数优点：
功能封装 + 随时随地重复调用
复用性提高
冗余降低
效率提高
"""

# lesson2: define
"""
def function(vars):
    函数体
    return 返回值
"""


# 定义函数 == 后执行
def say_hi():
    print(f"hello")


# 调用函数 == 先执行
say_hi()
"""
参数 + 返回值 若不需要，可以省略
函数必须先定义后使用
"""


# 定义函数
def check():
    # 编写函数体
    print("weclome \n72 hours check")


# 调用函数
check()


# lesson3: 传入参数 == 函数计算时候，接受外部提供的数据
# 定义函数
def add(x, y):  # 形式参数，使用逗号分割
    result = x + y
    print(f"{x} + {y} = {result}")


# 调用函数
add(3, 4)  # 实际参数，按顺序传入，一一对应，真实参数


def check(num):
    print("welcome 72 hours check, show number")
    if num <= 37.5:
        print(f"num = {num}. healthy come in")
    else:
        print(f"num = {num}. get out")


check(25)
check(40)

# lesson4: 函数返回值 return
"""
函数功能实现后，将相加的结果返回给调用者，相应参数将结果输出
返回值 == 程序中函数完成后，最后给调用者的结果

def function(vars):
    函数体
    return 返回值
变量 = 函数(参数)
"""


def add(x, y, z):
    result = x + y + z
    return result  # 将函数返回结果返回


r = add(4, 5, 6)  # 调用函数，将结果返回给r
print(r)  # 输出结果

# lesson5: 函数返回值 return None
"""
None == 空的，没有实际意义
类型是 NoneType

函数如何返回None
1.不适用return语句
2.主动return None

使用场景
1.函数返回值
2.if判断
3.变量定义
"""


def say_hi():
    print("hello")


result = say_hi()
print(f"无返回值函数，返回内容是：{result}")
print(f"无返回值函数，返回的内容类型是：{type(result)}")


# 无返回值函数，返回内容是：None
# 无返回值函数，返回的内容类型是：<class 'NoneType'>


def say_hi2():
    print("hello")
    return None


result = say_hi2()
print(f"无返回值函数，返回内容是：{result}")
print(f"无返回值函数，返回的内容类型是：{type(result)}")

"""
None 在if判断上，None == False
一般用于在函数中主动返回None, 配合if判断做处理
"""


def check_age(age):
    if age > 18:
        return "success"
    else:
        return None


result = check_age(16)
if not result:
    # 进入 if 表示result是none值，也就是false
    print("false")

"""
None 用于声明无内容的变量上
定义变量，暂时不需要变量有具体值，用None代替
"""
name = None

# lesson6: 函数说明文档
# 多行啊注释实现说明
"""
函数说明内容
1.功能说明
2.参数说明
3.返回值说明
"""


def add(x, y):
    """
    add  接受2参数，进行2数字相加
    :param x:   x形参表示一个数字
    :param y:   y形参表示一个数字
    :return:    相加的结果
    """
    result = x + y
    print(f"{x} + {y} = {result}")
    return result


add(7, 8)

# lesson7: 函数的嵌套调用
"""
一个函数调用另外一个函数 == 函数嵌套调用
执行流程
A函数调用B函数，会将B函数全部执行完成后，继续执行函数A的剩余内容
"""


def func_b():
    print("bbbbbbbbbbbbbbbb")
    print("b call c")
    func_c()


def func_c():
    print("cccccccccccccccccc")


def func_a():
    print("aaaaaaaaaaaaaaaaa")

    print("call func_b")
    func_b()
    print()
    print("call func_c")
    func_c()


func_a()




# lesson8: 函数的作用域
"""
变量作用域 == 变量的作用范围，在哪里有效
分类
1.局部变量 == 函数体内部的变量，就是函数内部生效
             函数体内部临时保存数据，函数完成，销毁局部变量
2.全局变量 == 函数体内体外都可以使用的变量
"""


# 局部变量
def test_a():
    num = 100
    print(num)
test_a()
# print(num)
# Traceback (most recent call last):
#　File "E:/python+shell+yaml/python/ithelma/chapter5-func.py", line 258, in <module>
#     print(num)
# NameError: name 'num' is not defined


# 全局变量
num = 200   # 全局变量
def test1():
    print(f"{num}")
def test2():
    print(f"{num}")

test1()
test2()
print(num)
print("======================\n")

# global函数 == 函数体内修改全局变量
num = 200   # 全局变量初始化为200
def test1():
    print(f"{num}")
def test2():
    global num
    num = 500           # 升级修改全局变量
    global num2
    num2 = 1000
    print(f"{num} {num2}")
def test3():
    print(f"{num} {num2}")
test1()
test2()
print(num)
test3()
print(num2)


# lesson9：综合案例
# 定义全局变量
money = 5000000
name = None
# name 输入
name = str(input("please write down your name: "))
# 定义查询功能
def query(show_header):
    if show_header:
        print("-----------查询余额-----------")
    print(f"{name} hello. you have {money}.")

# 定义存款函数
def save(num):
    global money    # money 通过函数内部定义为全局变量
    money += num
    print("-----------存款-----------")
    print(f"{name} hello. you have {money}. {num} save success. \n{query(False)}")
    print()
    # 调用查询函数
    query(False)

# 定义取款函数
def get_money(num):
    global money
    money -= num
    print("------------取款-------------")
    print(f"{name} hello get {num}, {query(show_header=False)}")



def main():
    print("--------------主菜单----------------")
    print(f"welcome {name}")
    print("query\t    1")
    print("save\t    2")
    print("get\t    3")
    print("exit\t    4")
    return  input("what u choice")

while True:
    keyboard_input = main()
    if keyboard_input == "1":
        query(show_header=True)
        continue
    elif keyboard_input == "2":
        num = int(input("please save money"))
        save(num)
        continue
    elif keyboard_input == "3":
        num = int(input("please get money"))
        get_money(num)
        continue
    else:
        print("exit the function")
        break

函数式编程

函数作为参数传入函数

# 函数式编程
def func01(num):
    return True if num % 2 == 1 else False

# filter(布尔函数， 列表)： 让列表中的元素经过布尔函数的过滤
# 将结果为True的元素留下，False去除

if __name__ == "__main__":
    nums = [1,2,3,4,5,6,7,8,9,10]
    data1 = filter(func01, nums)
    print(f"data1: {list(data1)}")

# lambda-1
myadd = lambda x,y: x+y
print(myadd(1,2))

test = lambda num: True if num %2 == 1 else False
print(test(100))

# lambda-2
nums = [1,2,3,4,5,6,7,8,9,10]
d3 = filter(lambda num:True if num > 5 else False, nums)
print(list(d3))

def func02(num):
    return num ** 2 + 10
if __name__ == "__main__":
    nums = [1,2,3,4,5]
    data1 = map(func02, nums)
    print(f"data1: {data1}")
    print(f"data1: {list(data1)}")
    
    # map(加工函数，列表)
    # 将列表中每一个元素经过加工函数处理后添加到新列表中
    
    data2 = map(lambda n: n ** 2 + 10, nums)
    print(f"data2: {data2}")
    print(f"data2: {list(data2)}")
    data3 = map(lambda n: n > 3, nums)
    print(f"data3: {data3}")
    print(f"data3: {list(data3)}")

全局变量 + 局部变量

# 全局变量 + 局部变量
# 函数外部定义 == 全局变量
# 函数内部定义 == 局部变量


def function2():
    b = 20 # 局部变量
    
    # 就近原则 不导入其他模块
    # 局部 --》全局 --》 报错
    print(f"局部变量 {b}")
function2()
print(f"全局输出局部变量 {b}")



a = 10 # 全局变量
def function3():
    print(f"局部变量内输出全局变量 {a}")
function3()
print(f"全局变量在全局输出 {a}")


c = 30
def func03():
    print(__name__)
    c = 40
    print(f"func03 c = {c}")

func03()
print(f"global c = {c}")


# 函数内部修改函数外部的值
d = 50 # 函数外部 50
def func04():
    global d # 函数内使用的d就是全局变量的d
    d = 100  # 修改全局变量的值
    print(f"in func04 d = {d}")
print(f"origin global d = {d}")
func04()     # 执行操作func04
print(f"latest global d = {d}")

生成器

# 生成器
# 生成器的元素只能获取一次
list01 = [item for item in range(1,6)]
print(f"list01 = {list01}")

gen = (item for item in range(1,6))
print(f" gen = {gen}")
# next 获取数据
print(f"next: {gen.__next__()}")
print(f"next: {gen.__next__()}")

# for 循环
for item in gen:
    print(f"for: {item}")