Python学习笔记（点开有樱花哦~）

骗你的，这都信

python笔记

print("Hello World")

"""
本代码演示了：
- 各类字面量的写法
- 通过print语句输出各类字面量
  """

# 写一个整数字面量
666
# 写一个浮点数字面量
13.14
# 写一个字符串字面量
"马"

# 通过print语句输出各类字面量
print(666)
print(13.14)
print("马")

money = 50
print("钱包还有：",money)

# 卖了个冰激凌，花费10元
money = money - 10
print("买了冰激凌花费10元，还剩余：",money,"元")

# 假设，每隔一小时，输出一下钱包的余额
print("现在是下午1点，钱包余额是：",money,"元")
print("现在是下午2点，钱包余额是：",money,"元")
print("现在是下午3点，钱包余额是：",money,"元")
print("现在是下午4点，钱包余额是：",money,"元")

money = 50
print("钱包余额为：",money)
# 花费10元买冰激凌
money = money - 10
print("剩余：",money)
# 花费5元买可乐
money = money - 5
print("剩余：",money)

# 方式1 使用print直接输出类型信息
print(type("马"))
print(type(666))
print(type(13.14))

# 方式2 使用变量存储type()语句的结果
string_type = type("马")
int_type = type(666)
float_type = type(13.14)
print(string_type)
print(int_type)
print(float_type)

# 方式3 使用type()语句，查看变量中存储的数据类型信息
name = "马"
name_type = type(name)
print(name_type)

# 将数字类型转换成字符串
num_str = str(11)
print(type(num_str),num_str)

float_str = str(13.14)
print(type(float_str),float_str)

# 将字符串装换成数字
num = int("11")
print(type(num),num)

num2 = float("13.14")
print(type(num2),num2)

# 错误示例，想要将字符串转换成数字，必须要求字符创内的内容都是数字
# num3 = int("马")
# print(type(num3),num3)

# 整数转浮点数
num4 = float(11)
print(type(num4),num4)

# 浮点数装换成整数
int_num = int(13.14)
print(type(int_num),int_num)

# 规则一：内容限定，限定只能使用：中文，英文，数字，下划线 注意：不能数字开头
# 错误：1_name = "张三"
# 错误：name_! = "张三"
name_ = "张三"
_name = "张三"
name_1 = "张三"

# 规则2：大小写敏感
Itheima = "马"
itheima = 666
print(Itheima)
print(itheima)

# 规则3：不可使用关键字
# 错误：class = 1
# 错误：def = 1
Class = 1

"""
演示Python中的各种运算符
"""
# 算数运算符
print("1 + 1 =",1 + 1)
print("2 - 1 =",2 - 1)
print("3 * 3 =",3 * 3)
print("4 / 2 =",4 / 2)
print("11 // 2 =",11 // 2)
print("9 % 2 =",9 % 2)
print("2 ** 2 =",2 ** 2)

# 赋值运算符
num = 1 + 2 * 3
# 复合赋值运算符
num = 1
num += 1
print("num += 1:",num)
num -= 1
print("num -= 1:",num)
num *= 1
print("num *= 1:",num)
num /= 1
print("num /= 1:",num)

num = 3
num %= 2
print("num %= 2:",num)

num **= 2
print("num **= 2:",num)

num = 9
num //= 2
print("num //= 2:",num)

""" 演示字符串的三种定义方式：
单引号定义法
双引号定义法
三引号定义法(使用变量接受它，它就是字符串)
"""
# 单引号定义法，使用单引号进行包围
name = '马'
print(type(name))
# 双引号定义法
name = "马"
print(type(name))
# 三引号定义法
name = """
马
"""
print(type(name))

# 在字符串内 包含双引号
name = '"马"'
print(name)
# 在字符串内 包含单引号
name = "'马'"
print(name)
# 使用转义字符\ 解除引号的效用
name = "\"马\""
print(name)
name = '\'马\''
print(name)

# 字符串字面量之间的拼接
print("马" + "少宣")
# 字符串字面量和字符串变量的拼接
name = "额"
address = "癔症蛋"
print("我是：" + name + "，我是" + address)

#通过占位的形式，完成拼接
name = "马"
massage = "少宣%s" % name
print(massage)
#通过占位的形式，完成数字和字符串的拼接
class_num = 57
avg_salary = 16781
massage = "python大数据学科，北京%s期，毕业平均工资：%s" % (class_num, avg_salary)
print(massage)

name = "传智播客"
setup_year = 2006
stock_price = 19.99
massage = "%s,成立于:%d,我今天的股价是：%f" % (name,setup_year,stock_price)
print(massage)

num1 = 11
num2 = 11.345
print("数字11的宽度限制为5，结果是：%5d" % num1)
print("数字11的宽度限制为1，结果是：%1d" % num1)
print("数字11.345的宽度限制为7，小数精度是2，结果是：%7.2f" % num2)
print("数字11的宽度不限制，小数精度是2，结果是：% .2f" % num2)

# 演示第二种字符串格式化的方式：f"{占位}
name = "传智播客"
setup_year = 2006
stock_price = 19.99
print(f"我是{name},我成立于：{setup_year}，我今天的股价是：{stock_price}")

# 演示对表达式进行字符串格式化
print("1 + 1 的结果是：%d" % (1 + 1))
print(f"1 * 2 的结果是：{1 * 2}")
print("字符串在Python中的类型名是：%s" % type("字符串"))

# 股价计算小程序
name = "传智播客"
stock_price = 19.99
stock_code = "003032"
stock_price_daily_growth_factor = 1.2
growth_days = 7
finally_stock_price = stock_price * stock_price_daily_growth_factor ** growth_days
print(f"公司：{name}，股票代码：{stock_code}，当前股价：{stock_price}")
print("每日增长系数%.1f，经过%d天的增长后，股价达到了：%.2f" % (stock_price_daily_growth_factor,growth_days,finally_stock_price))

"""
# 演示Python中的input语句，"请告诉我你是谁"可以写到input里面
print("请告诉我你是谁")
name = input()
print("我知道了，你是：%s" % name)
# 输入数字类型
num = input("请告诉我你的年龄：")
num = int(num)
print("类型：",type(num))
"""

# 演示布尔类型的定义以及比较运算符的应用
bool_1 = True
bool_2 = False
print(f"bool_1 = {bool_1},类型是{type(bool_1)}")
print(f"bool_2 = {bool_2},类型是{type(bool_2)}")
# 比较运算符的使用
# == != > < >= <=
# 演示进行内容的相对比较
num1 = 10
num2 = 10
print(f"10 = 10的结果是：{num1 == num2}")

num1 = 10
num2 = 15
print(f"10 != 15的结果是：{num1 != num2}")

name1 = "itacst"
name2 = "itheima"
print(f"itcast == itheima 结果是：{name1 == name2}")

# 演示大于小于，大于等于小于等于的比较运算
num1 = 10
num2 = 5
print(f"10 > 5结果是：{num1 > num2}")
print(f"10 < 5结果是：{num1 < num2}")

num1 = 10
num2 = 11
print(f"10 >= 11结果是：{num1 >= num2}")
print(f"10 <= 11结果是：{num1 <= num2}")

#python判断语句：if语句的基本格式应用
age = 20
if age >= 18:
print("我已经成年了")
print("已经步入大学生活")
print("时间过得真快")

"""
# 练习成年人判断
age = input("请输入你的年龄:")
age = int(age)
if age >= 18:
print("您已成年需要买票10元")
print("祝您游玩愉快")
"""

"""
# if else 语句
age = int(input("请输入你的年龄："))
if age >= 18:
print("您已成年，需要买票10元")
else:
print("您未成年，祝您游玩愉快")
"""

"""
# 练习我要买票吗
height = int(input("请输入你的身高："))
if height > 120:
print("您的身高超过120cm，需要买票10元")
else:
print("你的身高低于120cm，可以免费游玩")
print("猪您啊")
"""

"""
# 演示if elif else
height = int(input("请输入你的身高："))
vip_level = int(input("请输入你的vip等级："))

if height < 120:
print("可以免费")
elif vip_level > 3:
print("可以免费")
else:
print("都不满足，需要买票10元")
print("猪你愉快")
"""
"""
#练习猜猜心里数字
num = 5
if int(input("请猜一个数字")) == num:
print("第一次猜对")
elif int(input("猜错了，再来一次：")) == num:
print("猜对了")
elif int(input("猜错了，再来一次：")) == num:
print("最后一次机会猜对了")
else:
print("sorry猜错了")
"""
"""
# 嵌套
if int(input("你的身高：")) > 120:
print("身高限制，不可免费")
print("如果你的VIP大于3可以免费")
if int(input("你的VIP等级：")) > 3:
print("可以免费")
else:
print("买票")
else:
print("欢迎游玩")
"""
"""
# 定义一个随机数字，猜
import random
num = random.randint(1,10)
guess_num = int(input("输入你要猜的数字："))
if guess_num == num:
print("正确")
else:
if guess_num > num:
print("大")
else:
print("小")
guess_num = int(input("再次输入你要猜的数字："))
if guess_num == num:
print("第二次正确")
else:
if guess_num > num:
print("大")
else:
print("小")
guess_num = int(input("第三次输入你要猜的数字："))
if guess_num == num:
print("第三次正确")
else:
print("机会用完")
"""

# while循环
i = 0
while i < 100:
print("我喜欢你")
i += 1

# 求1到100的和
i = 1
sum = 0
while i <= 100:
sum += i
i += 1
print(f"1-100累加的和:{sum}")

"""
# 一个1-100随机数，通过while循环，猜，并求猜了几次
import random
num = random.randint(1,100)
count = 0

flag = True
while flag:
guess_num = int(input("请输入猜测的数字："))
count += 1
if guess_num == num:
print("猜中了")
flag = False
else:
if guess_num > num:
print("大")
else:
print("小")

print(f"一共猜测了{count}次")
"""

# while循环的嵌套
i = 1
while i <= 100:
print(f"今天是第{i}天，准备表白")
j = 1
while j <= 10:
print(f"送给她{j}朵玫瑰")
j += 1
print("我喜欢你")
i += 1

print(f"坚持到第{i - 1}天，表白成功")

#在同一行
#print("hello",end='')
#print("world",end='')
#对其
#print("hello\tworld")
#print("itheima\tbest")

#练习while输出99乘法表
i = 1
while i <= 9:
j = 1
while j <= i:
print(f"{j} * {i} = {j * i}\t",end='')
j += 1
i += 1
print()


name = "mashaoxuan"
for x in name:
print(x)

# 练习数一数有几个a
name = "mashaoxuan"
count = 0
for x in name:
if x == "a":
count += 1
print(f"共有{count}个a")


# range语法一 range(num)
for x in range (5):
print("送玫瑰")
# range语法二 range(num1，num2)
for x in range (5,10):
print(x)
# range语法三 range(num1，num2，step)
for x in range(5,10,2):
print(x)


#for循环临时变量的作用域
i = 0   #规范
for i in range (5):
print(i)

print(i)


# for循环的嵌套
for i in range (1,101):
print(f"今天是表白的第{i}天")
for j in range (1,11):
print(f"送给她的第{j}朵玫瑰")
print("我喜欢你")

print("第一百天，表白成功")


#for循环99乘法表
for i in range(1,10):
for j in range(1,i + 1):
print(f"{j} * {i} = {i * j}\t",end = '')
print()

# 演示循环语句的中断控制：break和continue
# continue，结束本次循环continue以下的语句
for i in range(1,6):
print("灰太狼")
for j in range(1,3):
print("红太狼")
continue
print("哄她爱了")
print("爱了")
# break，直接结束循环
for i in range(1,6):
print("喜洋洋")
break
print("美羊羊")
print("沸羊羊")


# 发工资
money = 10000
for i in range(1,21):
import random
score = random.randint(1,10)
if score < 5:
print(f"员工{i}绩效分{score}不足，不发工资")
continue
if money >= 1000:
money -= 1000
print(f"员工{i}，发工资1000，账户余额：{money}")
else:
print(f"余额不足，当前{money}")
break


# 用函数统计字符串长度
str1 = "ma"
str2 = "shao"
str3 = "xuan"
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 say_hi():   #第二步执行
print("hello world")
say_hi()    # 第一步执行


# 定义函数
def check():
print("hello world\n你好")
# 调用函数
check()


def add(x,y):
result = x + y
print(f"{x} + {y} = {result}")
add(5,6)


def add(a,b):
result = a + b
return result
r = add(5,6)
print(r)

# 无return语句的函数返回值
def say_hi():
print("hello world")
result = say_hi()
print(f"无返回值函数，返回的内容是：{result}")
print(f"无返回值函数，返回的内容类型是：{type(result)}")

def say_hi2():
print("hello world")
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:
print("未成年，不可进入")


# 定义函数，进行文档说明
def add(x,y):
"""
三个引号，然后回车
:param x:
:param y:
:return:
"""
result = x + y
print(f"结果是 = {result}")
return result
add(5,6)


# 函数的嵌套调用
def func_b():
print("2")
def func_a():
print("1")
func_b()
print("3")
func_a()

# 局部变量
def func_a():
num = 100
print(num)
func_a()
#使用print(num)无法执行

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

# 在函数内修改全局变量
num = 200
def test_a():
print(f"test_a:{num}")
def test_b():
num = 500
print(f"test_b:{num}")
test_a()
test_b()
print(num)

# 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 = 5000000
name = None
name = input("请输入你的姓名：")
def query(show_header):
if show_header:
print("查询余额")
print(f"{name},余额{money}")
def saving(num):
global money
money += num
print("存款")
print(f"{name},存款{num}")
query(False)
def get_money(num):
global money
money -= num
print("取款")
print(f"{name},取款{num}")
query(False)
def main():
print("主菜单")
print(f"{name}")
print("查询余额\t[1]")
print("存款\t\t[2]")
print("取款\t\t[3]")
print("退出\t\t[4]")
return input("选择：")
while True:
keyboard_input = main()
if keyboard_input == "1":
query(True)
continue
elif keyboard_input == "2":
num = int(input("存入："))
saving(sum)
continue
elif keyboard_input == "3":
num = int(input("取走："))
get_money(sum)
continue
else:
print("退出")
break
"""

# 列表list定义和下标索引
name_list = ["m",6,True]
print(name_list)
print(type(name_list))
print(name_list[1])     # 6
print(name_list[-1])    # True

my_list = [[1, 2, 3],[4, 5, 6]]
print(my_list)
print(type(my_list))
print(my_list[1][0])       # 4

# 查找下表索引值

mylist = ["m","s","x"]
index = mylist.index("s")
print(f"s下标索引值：{index}")

# 修改下标索引值
mylist[0] = "马"
print(f"修改后：{mylist}")
# 插入元素
mylist.insert(1,"少")
print(f"插入后：{mylist}")
# 追加元素
mylist.append("宣")
print(f"追加后：{mylist}")
# 追加方法2
mylist2 = [1,2,3]
mylist.extend(mylist2)
print(f"追加后：{mylist}")
# 删除指定下标
mylist = [4,5,6]
del mylist[2]
print(f"删除后：{mylist}")
# 删除方法2
mylist = [4,5,6]
element = mylist.pop(2)
print(f"通过pop方法取出后：{mylist},取出：{element}")
# 删除某元素在列表
mylist = [4,4,5,6]
mylist.remove(4)        # 删除第一个4
print(f"通过remove方法移除元素：{mylist}")
# 清空列表
mylist = [4,5,6]
mylist.clear()
print(f"清空后：{mylist}")
# 统计某元素在列表中的数量
mylist = [4,4,5,6]
count = mylist.count(4)
print(f"4的数量是：{count}")
# 统计列表内全部元素的数量
mylist = [4,4,5,6]
count = len(mylist)
print(f"全部元素数量：{count}")


# 用while循环遍历列表list的演示函数
def list_while_func():
mylist = [1,2,3]
index = 0
while index < len(mylist):
element = mylist[index]
print(f"列表的元素：{element}")
index += 1
list_while_func()
# 用for循环遍历列表list的演示函数
def list_for_func():
mylist = [1,2,3]
for element in mylist:
print(f"列表的元素有：{element}")
list_for_func()


# 定义元组
t1 = (1,"m",True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)},内容是：{t1}")
print(f"t2的类型是：{type(t2)},内容是：{t2}")
print(f"t3的类型是：{type(t3)},内容是：{t3}")
# 定义单个元素的元组
t4 = ("m",)
print(f"t4的类型是：{type(t4)},内容是：{t4}")
# 元组的嵌套
t5 = ((1,2,3),(4,5,6))
print(f"t5的类型是：{type(t5)},内容是：{t5}")
# 下标索引取出内容
num = t5[1][2]
print(f"取出元素：{num}")
# 元组的操作：index查找元素方法
t6 = ("m","s","x")
index = t6.index("s")
print(f"s的下标：{index}")
# 元组的count统计方法
t7 = ("m","m","s","x")
num = t7.count("m")
print(f"m个数：{num}")
# 元组len函数统计玉足元素的个数
t8 = ("m","m","s","x")
num = len(t8)
print(f"元素个数：{num}")
# 元组的遍历while
index = 0
while index < len(t8):
print(t8[index])
index += 1
# for元组遍历
for element in t8:
print(f"元组的元素：{element}")
# 定义一个元组
t9 = ("m","m","s","x",["ma","shao"])
print(t9)
t9[4][0] = "xuan"
print(f"t9的内容：{t9}")

# 数据容器，字符串,不可修改
mystr = "ma shao xuan"
# 通过下标索引取值
value = mystr[2]
value2 = mystr[-1]
print(f"从字符串{mystr}去下标为2的元素{value}，下标为-1的元素{value2}")

# index方法
value = mystr.index("shao")
print(f"在字符串{mystr}中查找shao，起始下标：{value}")
# replace
newstr = mystr.replace("shao","少")
print(newstr)

# split方法，分割
mystr = "ma shao xuan"
mystrlist = mystr.split(" ")
print(f"将字符串{mystr}进行split切分后{mystrlist}，类型{type(mystrlist)}")

# strip方法
mystr = "  ma shao xuan  "
mystrlist = mystr.strip()       # 去除首尾空格
print(mystrlist)

mystr = "12ma shao xuan21"
newstr = mystr.strip("12")
print(f"字符串{mystr}被strip（'12'）后，结果：{newstr}")

# 某字符出现次数
mystr = "ma shao"
count = mystr.count("m")
print(count)

# 字符串长度
num = len(mystr)
print(num)

# 练习
mystr = "itma shaoit"
num = mystr.count("it")
print(f"{mystr},中有it{num}个")
newstr = mystr.replace(" ","|")
print(newstr)
mystrlist = newstr.split("|")
print(mystrlist)


# 队list切片
mylist = [1,2,3,4,5,6,7,8,9]
result1 = mylist[1:4]
print(result1)
# 对tuple切片
mytuple = (1,2,3,4,5,6,7,8,9)
result2 = mytuple[:]
print(result2)
# 对str切片
mystr = ("01234567")
result3 = mystr[::2]
print(result3)
# 对str切片
mystr = ("01234567")
result4 = mystr[::-1]
print(result4)
# 对列表切片
mylist = [1,2,3,4,5,6,7,8,9]
result5 = mylist[3:1:-1]
print(result5)
# 对元组切片
mytuple = (1,2,3,4,5,6,7,8,9)
result6 = mytuple[::-2]
print(result6)

# 定义集合
myset = {"ma","shao","xuan","ma","shao","xuan","ma","shao","xuan"}
myset2 = set()
print(f"myset的内容：{myset}，类型是：{type(myset)}")
print(f"myset2的内容：{myset2}，类型是：{type(myset2)}")
# 添加新元素
myset.add("python")
myset.add("ma")
print(f"myset的内容：{myset}，类型是：{type(myset)}")
# 移除元素
myset .remove("python")
print(f"myset的内容：{myset}，类型是：{type(myset)}")
# 随机取出一个元素
myset = {"ma","shao","xuan"}
element = myset.pop()
print(f"取出{element},取出后：{myset}")
# 清空clear
myset.clear()
print(f"清空后：{myset}")
# 取俩个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(f"取差集后：{set3}")
print(f"取差集后原有set1：{set1}")
print(f"取差集后原有set2：{set2}")
# 消除俩个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set1.difference_update(set2)
print(f"消除差集后原有set1：{set1}")
print(f"消除差集后原有set2：{set2}")
# 集合合并
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.union(set2)
print(f"2集合合并：{set3}")
print(f"合并后集合1：{set1}")
print(f"合并后集合2：{set2}")
# 统计集合元素数量
set1 = {1,2,3,4,5,6}

num = len(set1)
print(f"集合中元素数量：{num}")
# 集合的遍历不支持小标只能用for循环
set1 = {1,2,3,4,5,6}
for element in set1:
print(element)

# 字典定义
my_dict1 = {"ma":99,"shao":88,"xuan":77}
my_dict2 = {}
my_dict3 = dict()
print(f"字典一：{my_dict1},类型：{type(my_dict1)}")
print(f"字典二：{my_dict2},类型：{type(my_dict2)}")
print(f"字典三：{my_dict3},类型：{type(my_dict3)}")

# 定义重复key的字典
# my_dict1 = {"ma":99,"ma":88,"xuan":77}新的会把旧的重复
# 从字典中基于key获得Value
my_dict1 = {"ma":99,"shao":88,"xuan":77}
score = my_dict1["ma"]
print(f"ma的分数：{score}")
# 定义嵌套字典
my_dict1 = {"ma":{"语文":77,
"数学":66,
"英语":33},
"shao":{"语文":88,
"数学":86,
"英语":55},
"xuan":{"语文":99,
"数学":86,
"英语":55}
}
print(f"学生考试：{my_dict1}")
# shao的语文信息
score = my_dict1["shao"]["语文"]
print(f"shao的语文：{score}")

# 字典的常用操作
my_dict = {"ma":99,"shao":88,"xuan":77}
my_dict["马"] = 66
print(f"新增后：{my_dict}")
# 更新元素
my_dict["ma"] = 33
print(f"更新后：{my_dict}")
# 元素删除
score = my_dict.pop("ma")
print(f"移除后：{my_dict}")
# 清空元素
my_dict.clear()
print(f"清空后：{my_dict}")
# 获取全部的key
my_dict = {"ma":99,"shao":88,"xuan":77}
keys = my_dict.keys()
print(keys)
# 遍历字典
# 方式一通过key来完成遍历
for key in keys:
print(f"字典的key：{key}")
print(f"字典的value是：{my_dict[key]}")
# 方式二 直接对字典进行for循环 ，每一次循环都是直接得到key
for key in my_dict:
print(f"字典的key：{key}")
print(f"字典的value是：{my_dict[key]}")
# 统计字典内的元素数量
num = len(my_dict)
print(num)

# 字符串大小比较
print(f"abd大于abc，结果：{'abd' > 'abc'}")

# key1 比较 key2
# print(f"{key1 > key2}")

# 演示多个变量，接受多个返回值
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,'男')
# 位置不定长*号
def user_info(*args):
print(f"类型：{type(args)},内容：{args}")
user_info(1,2,3,'小米','难哄')
# 关键字不定长**号
def user_info(**kwargs):
print(f"类型：{type(kwargs)},内容：{kwargs}")
user_info(name='ma',age=20,gender='nanhai')

# 函数作为参数传递
def test_fund(compute):
result = compute(1,2)   # 确定compute是函数
print(f"compute参数的类型：{type(compute)}")
print(result)
def compute(x,y):
return x + y
test_fund(compute)

# lambda匿名函数
def test_fund(compute):
result = compute(1,2)
print(f"结果：{result}")
test_fund(lambda x,y:x +y)

# 演示对文件的读取
# 打开文件
f = open("D:/Python/PycharmProjects/pythonProject/练习/测试.txt","r",encoding="UTF-8")
print(type(f))
# 读取文件  - read
print(f"读取两个字节的结果：{f.read(2)}")
print(f"读取全部的结果：{f.read()}")
# 读取文件 - readlines()
lines = f.readlines()       # 前面注释，紧接着前面
print(f"lines对象的类型：{type(lines)}")
print(f"lines对象的内容：{lines}")
# 读取文件 - 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(line)
# 文件的关闭
# f.close()
# time.sleep(500000)
with open("D:/Python/PycharmProjects/pythonProject/练习/测试.txt"):
for line in f:
print(line)
# time.sleep(500000)
f.close()

# 演示文件的写入
#open("D:/Python/PycharmProjects/练习/ma.txt","w",encoding="UTF-8").close()
#f.write("hello world")
#f.flush()
#f.close()

# 捕获异常
# 基本捕获语法
try:
f = open("D:/abc.txt","r",encoding="UTF-8")
except:
print("出现异常，因为文件不存在，我将open的模式，改为w模式去打开")
f = open("D:/abc.txt","w",encoding="UTF-8")
# 捕获特定的异常
try:
print(name)
except NameError as e:
print("出现了变量未定义的异常")
print(e)
# 捕获多个异常
try:
1 / 0
print(name)
except (NameError,ZeroDivisionError) as e:
print("出现了变量未定义 或者 除以0的异常错误")
# 未正确
# 捕获所有异常
try:
print(name)
1 / 0
except Exception as e:
print("出现异常")
else:
print("没有异常")
finally:
print("我是finally，有没有异常都要执行")
f.close()

# # 演示异常的传递性
# # 定义一个出现异常的方法
# def func1():
#     print("func1 开始执行")
#     num = 1 / 0
#     print("func1 结束执行")
# # 定义一个无异常的方法，调用上面的方法
# def func2():
#     print("func2 开始执行")
#     func1()
#     print("func2 结束执行")
# # 定义一个方法，调用上面的方法
# def main():
#     try:
#           func2()
#     except Exception as e:
#           print(f"出现异常，{e}")
# main()

# # python1的模块导入
# # 使用import导入time模块使用sleep功能（函数）
# import time     # 导入Python内置的time模块（time.py这个代码文件）
# pritn("你好")
# time.sleep(5)   # 通过.就可以使用模块内部的全部功能（类，函数，变量）
# print("你好")
# # 使用form导入time的sleep功能（函数）
# from time import sleep
# pritn("你好")
# sleep(5)
# print("你好")
# # 使用*导入time的sleep功能（函数）
# from time import *    # *表示全部的意思
# pritn("你好")
# sleep(5)
# print("你好")
# 使用as给特定功能加上别名
# from time import t
# pritn("你好")
# t.sleep(5)
# print("你好")

# from time import sleep as sl
# print("你好")
# sl(5)
# print("我好")

# # 演示自定义模块
# # 导入自定义模块使用
# # import 文件 import test
# from 测试 import test
# test(1,2)

# # 导入不同模块的同名功能
# from 文件1 import test
# from 文件2 import test
# test(1,2)

# #__main__变量
# from 文件 import test

# #__all__变量
# from 文件 import *
# test_a(1,2)
# test_b(1,2)