# 需求：统计字符申的长度，不使用内置函数Len()
str1 = "itheima"
str2 = "itcast"
str3 = "python"

# 定义一个计数的变量
count = 0
for i in str1:
    count += 1
print(f"字符串{str1}的长度是: {count}")

count = 0
for i in str2:
    count += 1
print(f"字符申{str2}的长度是: {count}")

count = 0
for i in str3:
    count += 1
print(f"字符串{str3}的长度是: {count}")

# 优化后的代码
def my_len(data):
    count = 0
    for i in data:
        count += 1
    print(f"字符串{data}的长度是：{count}")

my_len(str1)
my_len(str2)
my_len(str3)

函数的定义:
def 函数名(传入参数):
    函数体
    return 返回值

# 定义一个函数，输出相关信息
def say_hi():
    print("Hi,我是python,学Python,找AlanDoDo")
# 调用参数,让定义的函数开始工作
say_hi()

#定义2个数相加的函数，通过参数接收被计算的2个数字
def add(x,y):
    result = x + y
    print(f"{x} + {y} 的计算结果是: {result}")
# 调用函数，传入被计算的2个数字
add(5,6)

# 定义函数，接收1个形式参数，数字类型，表示体温
def check(num):
    # 在函数体内进行判断体温
    print("欢迎来到python! 请出示您的健康码以及72小时核酸证明,并配合测量体温!")
    if num <= 37.5:
        print(f"体温测量中，您的体温是: {num}度，体温正常请进!")
    else:
        print(f"体温测量中，您的体温是: {num}度，需要隔离!")
# 调用函数，传入实际参数
check(37.1)

# 定义一个函数，完成2数相加功能
def add(a,b):
    result = a + b
# 通过返回值，将相加的结果返回给调用者
    return result
    # 返回结果后，还想输出一句话
    print("我完事了")
# 函数的返回值，可以通过变量去接收并
r = add(5,6)
print(r)

# 无return语句的函数返回值
def say_hi():
    print("你好呀")
result = say_hi()

print(f"无返回值函数，返回的内容是: {result}")
print(f"无返回值函数，返回的内容类型是: {type(result)}")
# 主动返回None的函数
def say_hi2():
    print("你好呀")
    return None

result=say_hi2()

print(f"无返回值函数，返回的内容是: {result}")
print(f"无返回值函数，返回的内容类型是:{type(result)}")
# 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("未成年，不可以进入")
# None用于声明无初始内容的交量
name = None

def func(x，y) :
"""
函数说明
:param x:形参x的说明
:param y: 形参y的说明
:return: 返回值的说明
"""
函数体
return 返回值

# 定义函数，进行文档说明
def add(x, y):
    """
    add函数可以接收2个参数，进行2数相加的功能
    :param x:形参x表示相加的其中一个数宁
    :param y:形参y表示相加的另一个数宇
    :return: 返回值是2数相加的结果
    """
    result = x + y
    print(f"2数相加的结果是:{result}")
    return result

add (5,6)

# 定义函数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()

# global关键字，在函数内声明交量为全局变属
num = 200

def test_a():
    print(f"test_a: {num}")
def test_b():
    global num   # 设置内部定义的交量为全局交眉
    num = 500
    print(f"test_b: {num}")
    
test_a()
test_b()
print(num)

# 定义全局交量money name
money = 5000000
name = None
# 要求客户输入姓名
name = input("请输入您的姓名:")
# 定义查询函数
def query(show_header):
    if show_header:
        print("-------------查询余额---------")
    print(f"{name}，您好，您的余额剩余: {money}元")
    
# 定义存款丽数
def saving(num):
    global money # money在西数内部定义为全局变量
    money += num
    print("-------------存款-------------")
    print(f"{name}，您好，您存款{num}元成功。")
    
    # 调用query函数查询余额
    query(False)
    
# 定义取款函数
def get_money(num):
    global money
    money -= num
    print("---------------取款-------------")
    print(f"{name}，您好，您取款{num}元成功。")
    
    # 调用query函数查询余额
    query(False)
    
# 定义主菜单函数
def main():
    print("------------主菜单---------------")
    print(f"{name},您好,欢迎来到python银行ATM,请选择操作:")
    print("查询余额\t[输入1]")
    print("存款\t\t[输入2]")
    print("取款\t\t[输入3]")  # 通过\t制表符对齐输出
    print("退出\t\t[输入4]")
    return input("请输入您的选择:")

# 设置无限箭环，确保程序不退出
while True:
    keyboard_input = main()
    if keyboard_input =="1":
        query(True)
        continue    # 通continue继续下一次筋环，一进来就是同到了主袭单
    elif keyboard_input =="2":
        num = int(input("您想要存多少钱? 请输入:"))
        saving(num)
        continue
    elif keyboard_input =="3":
        num = int(input("您想要取多少钱? 请输入:"))
        get_money(num)
        continue
    else:
        print("程序退出啦")
        break    # 越过break退出循环

# 演示数据容器之:List 列表
# 语法:[元素，元素，....]

# 定义一个列表 List
my_list = ["itheima", "itcast", "python"]
print(my_list)
print(type(my_list))

my_list = ["itheima",666, True]
print(my_list)
print(type(my_list))

# 定义一个收套的列表
my_list = [[1,2,3],[4, 5,6]]
print(my_list)
print(type(my_list))

# 通过下标素引取出对应位置的数据
my_list =["Tom","Lily","Rose"]
# 列表[下标索引]，从前向后从0开始，每次+1，从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范
# print(my_list[3])

# 通过下标索引取出数招（倒序取出)
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

# 取出嵌套列表的元素
my_list = [[1,2,3],[4,5,6]]
print(my_list[1][1])

# 语法:列表.index(元素)
# List列表的常用操作
mylist = ["itcast","itheima","python"]

# 1.1 查找某元素在列表内的下标索引
index = mylist.index("itheima")
print(f"itheima在列表中的下标索引值是:(index)")

# 1.2如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是: {index}")

# 修改特定下标资引的值
mylist[0] = "传智教育"
print(f"列表被修改元素值后，结果是:{mylist}")

# 语法: 列表.insert(下标,元素)，在指定的下标位置，插入指定的元素
# 在指定下标位置插入新元素
mylist.insert(1,"best")
print(f"列表插入元素后，结果是: {mylist}")

# 语法: 列表appen(元素)，将指定元素，追加到列表的尾部
# 在列表的尾部追加单个新元素
mylist.append("黑马程序员")
print(f"列表在追加了元素后，结果是:{mylist}")

# 在列表的尾部追加一批新元素
mylist2 = [1,2,3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是:{mylist}")

# 语法1: del列表[下标]  
mylist =["itcast","itheima","python"]
del mylist[2]
print(f"列表删除元素后结果是: {mylist}")

# 语法2:列表.pop(下标)
mylist =["itcast","itheima","python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容: {mylist}，取出的元素是:{element}")

# 删除某元素在列表中的第一个匹配项
mylist = ["itcast","itheima","itcast","itheima","python"]
mylist.remove("itheima")
print(f"通过remove方法移除元素后,列表的结果是: {mylist}")

# 清空列表
mylist.clear()
print(f"列表被清空了。结果是:{mylist}")

# 统计列表内某元素的数量
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = mylist.count("itheima")
print(f"列表中itheima的数星是: {count}")

# 统计列表中全部的元素数量
mylist =["itcast","itheima","itcast","itheima","python"]
count = len(mylist)
print(f"列表的元素数量总共有:{count}个")

# 1. 定义这个列表，并用变量接收它，内容是:[21，25，21，23，22，20]
mylist =[21,25,21,23,22,20]

# 2.追加一个数字31，到列表的尾部
mylist.append(31)

# 3，追加一个新列表[29，33，30]，到列表的尾部
mylist.extend([29,33,30])

# 4.取出第一个元素(应是:21)
num1 = mylist[0]
print(f"从列表中取出来第一个元素,应该是21,实际上是: {num1}")

# 5，取出最后一个元素(应是:30)
num2 = mylist[-1]
print(f"从列表中取出来最后一个元素,应该是30,实际上是: {num2}")

# 6.查找元清31，在列表中的下标位置
index = mylist.index(31)
print(f"元素31在列表的下标位置是: {index}")
print(f"最后列表的内容是: {mylist}")

def list_while_func():
# 使用while循环遍历列表的演示函数
# :return: None
    my_list = ["教育", "程序员", "Python"]
    # 循环控制变量通过下标索引来控制，默认0
    # 每一次循环将下标索引变量+1
    # 循环条件:下标索引变量 < 列表的元素数量

    # 定义一个变量用来标记列表的下标
    index =0   # 初始值为0
    while index < len(my_list):
        # 通过index变量取出对应下标的元素
        element = my_list[index]
        print(f"列表的元素: {element}")
        
        # 至关重要 将循环变量(index)每一次循环都+1
        index += 1
    
list_while_func()

def list_for_func():
    # 使用for循环遍历列表的演示函数
    # :return: None
    my_list = [1, 2, 3, 4, 5]
    # for 临时变量 in 数据容器:
    for element in my_list:
        print(f"列表的元素有: {element}")

list_for_func()

# 定义元组
t1 = (1,"Hello",True)
t2=()
t3 = tuple()
print(f"t1的类型是: {type(t1)}，内容是: {t1}")
print(f"t2的类型是: {type(t2)}，内容是: {t2}")
print(f"t3的类型是: {type(t3)}，内容是: {t3}")

# 定义单个元素的元素
t4 = ("hello",)
print(f"t4的类型是: {type(t4)},t4的内容是: {t4}")
# 元组的嵌套
t5 = ( (1,2,3),(4,5,6) )
print(f"t5的类型是: {type(t5)}，内容是: {t5}")

# 下标索引去取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是: {num}")

# 元组的操作:index查找方法
t6 = ("传智教育","黑马程序员","Python")
index = t6.index("黑马程序员")
print(f"在元组t6中查找黑马程序员,的下标是: {index}")
# 元组的操作:count统计方法
t7 = ("传智教育","黑马程序员","黑马程序员","黑马程序员","Python")
num = t7.count("黑马程序员")
print(f"在元组t7中统计黑马程序员的数量有: {num}个")
# 元组的操作:Len函数统计元组元素数量
t8 = ("传智教育","黑马程序员","黑马程序员","黑马程序员","Python")
num = len(t8)
print(f"t8元组中的元素有: {num}个")

# 元组的遍历:while
index = 0
while index < len(t8):
    print(f"元组的元素有: {t8[index]}")
    # 至关重要
    index += 1
# 元组的遍历:for
for element in t8:
    print(f"2元组的元素有: {element}")

# 修改元组内容
# t8[0]="itcast"

# 演示以数据容器的角色，学习字符申的相关操作
my_str = "itheima and itcast"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素,。值是: {value},取下标为-16的元素。值是: {value2}")

# my_str[2]="H"

# index方法
value = my_str.index("and")
print(f"在字符申{my_str}中查找and,其起始下标是: {value}")
    
# replace方法
new_my_str = my_str.replace("it","程序")
print(f"将字符申{my_str}，进行替换后得到: {new_my_str}")


# 语法:字符串.split(分隔符字符串 )
# 功能:按照指定的分隔符字符串，将字符串划分为多个字符串，并存人列表对象中
# 注意:学符串本身不变，而是得到了一个列表对象
# split方法
my_str = "hello python itheima itcast"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到:{my_str_list}，类型是: {type(my_str_list)}")

# strip方法
my_str ="  itheima and itcast  "
new_my_str = my_str.strip() # 不传入参数，去除首尾空格
print(f"字符串{my_str}被strip后,结果: {new_my_str}")

my_str ="12itheima and itcast21"
new_my_str = my_str.strip("12")
print(f"字符申{my_str}被strip('12')后,结果: {new_my_str}")

# 统计字符串中某字符串的出现次数，count
my_str ="itheima and itcast"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是: {count}")

# 统计字符串的长度,len()
num = len(my_str)
print(f"字符申{my_str}的长度是: {num}")

# List进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5,6]
result1 = my_list[1:4] # 步长默认是1，所以可以省略不写
print(f"结果1: {result1}")

# tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[:] # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2: {result2}")

# str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3: {result3}")

# str进行切片，从头开始，到最后结束，步长-1
my_str ="01234567"
result4 = my_str[::-1]  # 等同于将序列反转了
print(f"结果4:{result4}")

# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0,1,2,3,4,5,6]
result5 = my_list[3:1:-1]
print(f"结果5: {result5}")

# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0,1,2,3,4,5,6)
result6 = my_tuple[::-2]
print(f"结果6:{result6}")

# 定义集合
my_set ={"教育","程序员","it","教育","程序员","it","教育","程序员","it"}
my_set_empty = set()  # 定义空集合
print(f"my_set的内容是: {my_set}，类型是: {type(my_set)}")
print(f"my_set_empty的内容是: {my_set_empty}，类型是: {type(my_set_empty)}")

# 添加新元素
my_set.add("Python")
my_set.add("教育")
print(f"my_set添加元素后结果是: {my_set}")

# 移除元素
my_set.remove("程序员")
print(f"my_set移除程序员后,结果是: {my_set}")

# 随机取出一个元素
my_set = {"教育","程序员","it"}
element = my_set.pop()
print(f"集合被取出元素是: {element}，取出元素后: {my_set}")

# 清空集合，clear
my_set.clear()
print(f"集合被清空啦，结果是: {my_set}")

# 取2个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是: {set3}")
print(f"取差集后,原有set1的内容: {set1}")
print(f"取差集后,原有set2的内容: {set2}")

# 消除2个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(f"消除差集后,集合1结果: {set1}")
print(f"消除差集后,集合2结果: {set2}")

# 2个集合合并为1个
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(f"2集合合并结果: {set3}")
print(f"合并后集合1: {set1}")
print(f"合并后集合2: {set2}")

# 统计集合元素数量Len()
set1 = {1,2,3,4,5,1,2,3,4,5}
num = len(set1)
print(f"集合内的元素数量有: {num}个")

# 集合的遍历
# 集合不支持下标索引，不能用while循环,可以用for循环
set1 = {1,2,3,4,5}
for element in set1:
    print(f"集合的元素有: {element}")

# 定义字典{key: value,key: value,...}
my_dict1 = {"王力鸿": 99,"周杰轮": 88,"林俊节": 77}
# 定义空宇典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是: {my_dict1}，类型:{type(my_dict1)}")
print(f"字典2的内容是: {my_dict2}，类型:{type(my_dict2)}")
print(f"字典3的内容是: {my_dict3}，类型:{type(my_dict3)}")

# 定义重复Key的宇典,新的会覆盖老的
my_dict1 = {"王力鸿": 99,"王力鸿": 88,"林俊节": 77}
print(f"重复key的字典的内容是: {my_dict1}")

# 从字典中基于Key获取Value[]
my_dict1 = {"王力鸿": 99,"周杰轮": 88,"林俊节": 77}
score = my_dict1["王力鸿"]
print(f"王力鸿的考试分数是:{score}") 

# 定义嵌套宇典
# 记录学生各科的考试信息
stu_score_dict = {
    "王力鸿": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    },"周杰轮":{
        "语文": 88,
        "数学": 86,
        "英语": 55
    },"林俊节": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }
}
print(f"学生的考试信息是: {stu_score_dict}")

# 从套字典中获取数据
# 看一下周杰轮的语文信息
score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是:{score}")

# 语法:字典[Key] = Value,结果:字典被修改，新增了元素
# 语法:字典[Key] = Value,结果:字典被修改，元素被更新
# 注意:字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值
my_dict={"周杰轮":99,"林俊节":88,"张学油": 77}
# 新增元素
my_dict["张信哲"] = 66
print(f"字典经过新增元素后，结果: {my_dict}")
# 更新元素
my_dict["周杰轮"] = 33
print(f"字典经过更新后，结果: {my_dict}")
# 删除元素
score = my_dict.pop("周杰轮")
print(f"字典中被移除了一个元素，结果: {my_dict}，周杰轮的考试分数是: {score}")

# 清空元素，clear
my_dict.clear()
print(f"字典被清空了，内容是: {my_dict}")

# 获取全部的key
my_dict = {"周杰轮": 99,"林俊节": 88,"张学油": 77}
keys = my_dict.keys()
print(f"字典的全部keys是:{keys}")

# 遍历字典
# (1)通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是:{key}")
    print(f"字典的value是: {my_dict[key]}")
#(2)直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(f"2字典的key是:{key}")
    print(f"2字典的value是: {my_dict[key]}")

# 统计字典内的元素数量，len()函数
num = len(my_dict)
print(f"字典中的元素数量有: {num}个")

# 演示宇典的课后练习:升职加薪，对所有级别为1级的员工，级别上升1级，薪水增加1000元
# 组织宇典记录数据
info_dict = {
    "王力鸿":{
    "部门":"科技部",
    "工资": 3000,
    "级别": 1
    },
    "周杰轮":{
    "部门":"市场部",
    "工资": 5000,
    "级别": 2
    },
    "林俊节":{
    "部门":"市场部",
    "工资": 7000,
    "级别":3
    },
    "张学油":{
    "部门":"科技部",
    "工资": 4000,
    "级别":1
    },
    "刘德滑":{
    "部门":"市场部",
    "工资": 6000,
    "级别": 2
    }
}
print(f"员工在升值加薪之前的结果: {info_dict}")
# for循环遍历字典
for name in info_dict:
    # if条件判断符合条件员工
    if info_dict[name]["级别"] == 1:
        # 升职加薪操作
        # 获取到员工的信息宇典
        employee_info_dict = info_dict[name]
        # 修改员工的信息
        employee_info_dict["级别"] = 2 # 级别+1
        employee_info_dict["工资"] += 1000 # 工资+1000
        # 将员工的信息更新回info_dict
        info_dict[name] = employee_info_dict
    
# 输出结果
print(f"对员工进行升级加薪后的结果是: {info_dict}")

# 演示数据容器的通用功能
my_list = [1,2,3,4,5]
my_tuple = (1,2,3,4,5)
my_str ="abcdefg"
my_set = {1,2,3,4,5}
my_dict = {"key1": 1,"key2": 2,"key3": 3,"key4": 4,"key5": 5}

# Len元素个数
print(f"列表 元素个数有:{len(my_list)}")
print(f"元组 元素个数有:{len(my_tuple)}")
print(f"字符串元素个数有:{len(my_str)}")
print(f"集合 元素个数有:{len(my_set)}")
print(f"字典 元素个数有:{len(my_dict)}")

# max最大/最小元素
print(f"列表 最大的元素是:{max(my_list)}")
print(f"元组 最大的元素是:{max(my_tuple)}")
print(f"字符串最大的元素是:{max(my_str)}")
print(f"集合 最大的元素是:{max(my_set)}")
print(f"字典 最大的元素是:{max(my_dict)}")

# 类型转换: 容器转列表/元组(tuple)/字符串(str)/集合(set)
print(f"列表转列表的结果是:{list(my_list)}")
print(f"元组转列表的结果是:{list(my_tuple)}")
print(f"字符串转列表结果是:{list(my_str)}")
print(f"集合转列表的结果是:{list(my_set)}")
print(f"字典转列表的结果是:{list(my_dict)}")

# 进行容器的排序
my_list = [3,1,2,5,4]
my_tuple = (3,1,2,5,4)
my_str ="bdcefga"
my_set = {3,1,2,5,4}
my_dict = {"key3": 1,"key1": 2,"key2": 3,"key5": 4,"key4": 5}

print(f"列表对象的排序结果: {sorted(my_list)}")
print(f"元组对象的排序结果: {sorted(my_tuple)}")
print(f"字符串对象的排序结果: {sorted(my_str)}")
print(f"集合对象的排序结果: {sorted(my_set)}")
print(f"字典对象的排序结果: {sorted(my_dict)}")

print(f"列表对象的反向排序结果: {sorted(my_list,reverse=True)}")
print(f"元组对象的反向排序结果: {sorted(my_tuple,reverse=True)}")
print(f"字符串对象反向的排序结果: {sorted(my_str,reverse=True)}")
print(f"集合对象的反向排序结果: {sorted(my_set,reverse=True)}")
print(f"字典对象的反向排序结果::{sorted(my_dict,reverse=True)}")

# abc 比较 abd
print(f"abd大于abc,结果: {'abd'> 'abc'}")
# a比较 ab
print(f"ab大于a,结果: {'ab'> 'a'}")
# a比较A
print(f"a 大于 A,结果: {'a'> 'A'}")
# key1 比较 key2
print(f"key2 > key1,结果: {'key2'> 'key'}")

# 演示使用多个变量，接收多个返回值
def test_return():
    return 1,"hello",True
x,y,z=test_return()
print(x)
print(y)
print(z)

# 演示多种传参的形式
# 注意:传递的参数和定义的参数的顺序及个数必须一致
def user_info(name,age,gender):
    print(f"姓名是:{name}，年龄是:{age}，性别是:{gender}")
# 位置参数 - 默认使用形式
user_info('小明',20,'男')

# 关键字参数
# 注意:函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
user_info(name='小王',age=11,gender='女')
user_info(age=10,gender='女',name='潇潇') # 可以不按照参数的定义顺序传参
user_info('甜甜',gender='女',age=9)

# 缺省参数(默认值)
# 注意:函数调用时，如果为缺省参数传值则修改默认参数值，否则使用这个默认值
def user_info(name,age,gender):
    print(f"姓名是:{name}，年龄是:{age}，性别是:{gender}")

user_info('小天',13,'男')

# 不定长- 位置不定长，*号
# 不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
# 位置不定长传递以*号标记一个形式参数，以元组的形式接受参数形式参数一般命名为args
def user_info(*args):
    print(f"args参数的类型是: {type(args)}，内容是:{args}")

user_info(1,2,3,'小明','男孩')

# 不定长 - 关键字不定长，** 号
# 关键字不定长传递以**号标记一个形式参数，以字典的形式接受参数，形式参数一般命名为kwargs
def user_info(**kwargs):
    print(f"args参数的类型是: {type(kwargs)}，内容是:{kwargs}")

user_info(name='小王',age=11,gender='男孩')

# 定义一个函数，接收另一个函数作为传入参数
def test_func(compute):
    result = compute(1,2)  # 确定cmpute是函数
    print(f"compute参数的类型是:{type(compute)}")
    print(f"计算结果: {result}")
    
# 定义一个函数，准备作为参数传入另一个函数
def compute(x,y):
    return x + y
# 调用，并传入函数
test_func(compute)

# 演示Lambda匿名函数 lambda 传入参数: 函数体(一行代码)
# 定义一个函数，接受其它函数输入
def test_func(compute):
    result = compute(1,2)
    print(f"结果是:{result}")
# 通过Lambda匿名函数的形式，将匿名函数作为参数传入
def add(x,y):
    return x + y
test_func(add)
test_func(lambda x,y: x + y)

# 语法如下 open(name,,mode,encoding)
# name:是要打开的目标文件名的字符串(可以包含文件所在的具体路径)
# mode: 设置打开文件的模式(访问模式): 只读、写入、追加等。
# encoding: 编码格式(推荐使用UTF-8)
# 打开文件
f = open("F:\Code\测试.txt","r",encoding="UTF-8")
print(type(f))
# 读取文件 - read()
print(f"读取10个字节的结果: {f.read(10)}")
print(f"read方法读取全部内容的结果是: {f.read()}")
print("------------------------")

# 读取文件 - readLines()
lines = f.readlines()  # 读取文件的全部行，封装到列表中
print(f"lines对象的类型: {type(lines)}")
print(f" ines对象的内容是: {lines}")

# 打开文件
import time
f = open("F:\Code\测试.txt","r",encoding="UTF-8")
print(type(f))
print("---------------")
# 读取文件- readline()
line1 = f.readline()
line2 = f.readline()
line3 = f.readline()
print(f"第一行数据是: {line1}")
print(f"第二行数据是: {line2}")
print(f"第三行数据是: {line3}")
# for循坏读取文件行
for line in f:
    print(f"每一行数据是:{line}")
    
# 文件的关闭
f.close()
time.sleep(500000)

# with open 语法操作文件
# import.time
# with open("F:\Code\测试.txt","r",encoding="UTF-8") as f:
#    for line in f:
#        print(f"每一行数据是: {line}")
    
# time.sleep(500000)

# 打开文件，不存在的文件，r，w，a
import time

# f = open("F:\Code\text.txt","w",encoding="UTF-8")
# write写入
# f.write("Hello World!!!")  # 内容写入到内存中
# flush刷新
# f.flush()  # 将内存中积攒的内容，写入到硬盘的文件中
#  close关闭
# f.close()  # close方法，内置了flush的功能的

#打开一个存在的文件
f = open("F:\Code\text.txt","w",encoding="UTF-8")
# write写入、fLush刷新
f.write("程序员")
# cLose关闭
f.close()

# 打开文件，不存在的文件
# f= open("F:\Code\text.txt","a",encoding="UTF-8")
# write写入
# f.write("黑马程序员")
# # flush刷新
# f.flush()
# # close关闭
# f.close()
# 打开一个存在的文件
f = open("F:\Code\text.txt","a",encoding="UTF-8")
# write写入,fLush刷新
f.write("学Python最佳选择")
# cLose关闭
f.close()