print("你好" + " 这是一句代码" + " 哈哈")

# 打印结果：你好这是一句代码哈哈

print("He said"good!"") # 错误示例
print('He said" good!"')# 应该把内外的引号区分开
print("He said' good!'")# 应该把内外的引号区分开

print("He said "Let's go!"")     # 错误示例
print("He said \"Let\'s go!\"") # 正确示例：在字符串里的引号前面加一个反斜杠  \ 

print("第一行
      第二行") # 错误示例
print("第一行\n第二行") # 正确示例\n为换行转义字符，打印出来后就会分行。在另外一个笔记内字符串中的转义字符中有详细讲解。

my_name = '浅笑安然' #赋值

my_name = '浅笑安然'  #对变量赋值
my_ID = my_name  # 用变量给变量赋值
my_name = '李'  #覆盖掉这个变量的原先值
print('当前my_name的值：' + 'my_name')#可以随时用print打印出当前的值了解情况。
print('当前my_ID的值：' + 'my_ID')#可以随时用print打印出当前的值了解情况。

"6"  #被引号包裹的是字符串
6     #没小数点的是整数
6.0  #带小数点的是浮点数

import math # 在文件第一行输入，进入import库。
math.sin(1)#简单的应用，具体的可以去math库官方文档里查看。
print(math.sin(1))#要用print打印才可以看到计算的结果。
---------------------------------------------------------------
# 或者像下面这样，先对函数进行赋值，再打印结果。
print(math.sin(1))
sin = math.sin(1)
print(sin)

# 对字符串求长度
s = "Hello world!"
print(len(s))

# 通过索引获取单个字符
print(s[0])#获取第一个字符
print(s[len(s) - 1])#获取最后一个数字，字符串长度减一。

# 布尔类型，首字母需要大写。
b1 = True
b2 = False

# 空值类型
n = None

# type函数
print(type(s))
print(type(b1))
print(type(n))
print(type(1.5))

# 不能对布尔类型的变量使用len函数，因此下面一行会报错
# len(b1)

mood_index = int(input("对象今天的心情指数是："))
if mood_index >= 60:  #值大于等于60为真
    print("恭喜，今晚应该可以打游戏，去吧皮卡丘！")
    print("∠( ᐛ 」∠)_") 
else:  # mood_index < 60，值小于60为假
    print("为了自个儿小命，还是别打了。")

if [条件一]:                  # 满足条件一时，判断条件二
    if [条件二]:                  # 满足条件二时，返回执行语句。
        [执行语句]          #  一次缩进约四个空格
        [执行语句]
    else：                  
        [执行语句]
        [执行语句]
----------------------------------------------------------------------------
if [条件一]:            # 满足条件一时，判断条件二 。不满足时，返回语句C。
    if [条件二]:         # 满足条件二时，返回执行语句，不满足时返回语句B。
        [执行语句A]   #  一次缩进约四个空格
    else：                  
    [执行语句B]
else：                  
    [执行语句C]
    
----------------------------------------------------------------------------
if [条件一]: 
    [执行语句A]
elif [条件二]: 
    [执行语句B]
elif [条件三]: 
    [执行语句C]
else：                  
    [执行语句C]

gou_wu = ["键盘"，"鼠标"]   #列表示例

# 列表是可变的，往定义好的列表里加东西，可以用append。
gou_wu.append("耳机")  #append表示往列表里加东西。
gou_wu.remove("键盘") #remove可以删除列表里的某个元素，前提是列表里已有的，否则报错。

print(gou_wu)# 可以随时打印列表检查元素

len(gou_wu)#函数可以获取列表元素的数量。

print(gou_wu[1]) = "音箱"#通过索引直接覆盖该位置原本的元素
----------------------------------------------------------------------------
#针对列表的内置函数：
print(max(num_list))# 打印列表里的最大值
print(min(num_list))# 打印列表里的最小值
print(sorted(num_list))# 打印排序好的列表

contacts = {}#这是一个空的字典。
contacts = {"小明":"17500000000 ",
                   "小花":"17500000000 "}#这是一个字典。 
contacts["小明"]#获取对应键的值
----------------------------------------------------------------------------
# 元组作为键
contacts = {("张三", 31):"17500000000 ",
                   ("张三", 21):"13500000000 ",
                   ("张三", 51):"13700000000 "}
contacts[("张三", 51)]#使用元组作为键
----------------------------------------------------------------------------
#增加新的键值对
contacts["李四"] = "1330000000"# 新增值是这样的，更新也是这样，原理是直接覆盖。

#删除一个键值对，要是本身就不存在则报错。
del contacts["李四"]

# 判断键是否存在
"李四" in contacts  #会返回一个布尔值，判断该键是否存在于字典里。

len(contacts)#查看有多少键值对 

# 结合input、字典、if判断，做一个查询流行语含义的电子词典程序
slang_dict = {"觉醒年代":"《觉醒年代》首次以电视剧的形式回溯中国共产党的孕育和创立过程，生动再现中国近代历史的大变局，深刻讲述中国人民是怎样选择了中国共产党。该剧播出后广受好评，成为党史学习教育的生动教材。",
              "YYDS":"“永远的神”的拼音缩写，用于表达对某人的高度敬佩和崇拜。2021年东京奥运会期间，不管是杨倩夺得首金，还是全红婵一场决赛跳出三个满分，或是“苏神”站上百米决赛跑道，全网齐喊“YYDS”，奥运期间一度刷屏。"}
slang_dict["双减"] = "指进一步减轻义务教育阶段学生作业负担和校外培训负担。其目标是使学校教育教学质量和服务水平进一步提升，作业布置更加科学合理，学校课后服务基本满足学生需要，学生学习更好回归校园，校外培训机构培训行为全面规范。"
slang_dict["破防"] = "原指在游戏中突破了对方的防御，使对方失去防御能力。现指因遇到一些事或看到一些信息后情感上受到很大冲击，内心深处被触动，心理防线被突破。"
slang_dict["元宇宙"] = "源于小说《雪崩》的科幻概念，现指在XR（扩展现实）、数字孪生、区块链和AI（人工智能）等技术推动下形成的虚实相融的互联网应用和社会生活形态。现阶段，元宇宙仍是一个不断演变、不断发展的概念。Facebook（脸书）对外公布更名为“Meta”，该词即来源于“Metaverse”（元宇宙）。"
slang_dict["绝绝子"] = "该词流行于某网络节目，节目中一些粉丝用“绝绝子”为选手加油。多用于赞美，表示“太绝了、太好了”。这个词引发了网友对网络语言的关注和讨论。"
slang_dict["躺平"] = "该词指人在面对压力时，内心再无波澜，主动放弃，不做任何反抗。“躺平”更像是年轻人的一种解压和调整方式，是改变不了环境便改变心态的自我解脱。短暂“躺平”是为了积聚能量，更好地重新出发。"
slang_dict["伤害性不高，侮辱性极强"] = "一段网络视频中，两名男子相互夹菜，而同桌的另一名女子则显得很孤单。于是有网友调侃“伤害性不高，侮辱性极强”。后被网友用来调侃某事虽然没有实质性危害，但是却令人很难堪。"
slang_dict["我看不懂，但我大受震撼"] = "源自导演李安在纪录片《打扰伯格曼》（2013）里评价一部影视作品的话。现多用于表示自己对某件事情的不解、震惊。"
slang_dict["强国有我"] = "源自建党百年天安门广场庆典上青年学子的庄严宣誓。“请党放心，强国有我”是青年一代对党和人民许下的庄重誓言，彰显着新时代中国青年的志气、骨气、底气。"

query = input("请输入您想要查询的流行语：")
if query in slang_dict:
    print("您查询的" + query + "含义如下")
    print(slang_dict[query])
else:
    print("您查询的流行语暂未收录。")
    print("当前本词典收录词条数为：" + str(len(slang_dict)) + "条。")

while 条件A：
    行动B

# 示例：
year = "虎"
name = "老李"
message_content = ("""
律回春渐，新元肇启。
新岁甫至，福气东来。
金女{0}贺岁，欢乐祥瑞。
金{0}敲门，五福临门。
给{1}及家人拜年啦！
新春快乐，{0}年大吉！""".format(year,name))
print(message_content)
----------------------------------------------------------------------------
## 使用方法二：
year = "虎"
name = "老李"
message_content = ("""
律回春渐，新元肇启。
新岁甫至，福气东来。
金女{year}贺岁，欢乐祥瑞。
金{year}敲门，五福临门。
给{name}及家人拜年啦！
新春快乐，{year}年大吉！""".format(year=year, name=name)) #等号前面的是关键字，对应花括号内的关键字。等号后面的是参数值。
print(message_content)

year = "虎"
name = "老李"
message_content = f"""
律回春渐，新元肇启。
新岁甫至，福气东来。
金女{year}贺岁，欢乐祥瑞。
金{year}敲门，五福临门。
给{name}及家人拜年啦！
新春快乐，{year}年大吉！"""
print(message_content)

#format方法
gpa_dict = {"小明": 3.251, "小花": 3.251, "小李": 3.251, "小张": 3.251}
for name, gpa in gpa_dict.items():
    print("{0}你好，你的当前绩点为：{1:.2f}".format(name, gpa))#{1}里面的:.2f是保留两位小数，这是一种格式化字符串的方式。
 ----------------------------------------------------------------------------
#方法
gpa_dict = {"小明": 3.251, "小花": 3.251, "小李": 3.251, "小张": 3.251}
for name, gpa in gpa_dict.items():
    print(f"{name}你好，你的当前绩点为：{gpa:.2f}")#:.2f的意思同上

# 扇形面积（A）= (θ/360) × π × r²
def sector_1():
    # 接下来是一些定义函数的代码。
    angle_1 = 160
    radius_1 = 30
    area = angle_1 / 360 * 3.14 * radius_1 ** 2
    print(f"此扇形面积为：{area}")
sector_1()
 ----------------------------------------------------------------------------
# 优化_通过参数让函数变得通用
def sector(angle, radius):
    area = angle / 360 * 3.14 * radius ** 2
    print(f"此扇形面积为：{area}")
sector(160, 30)# 定义函数括号里的参数
sector(60, 15)

"""
写一个计算BMI的函数，函数名为 calculate_BMI。
1. 可以计算任意体重和身高的BMI值
2. 执行过程中打印一句话，"您的BMI分类为：xx"
3. 返回计算出的BMI值

BMI = 体重 / (身高 ** 2)

BMI分类
偏瘦：BMI <= 18.5
正常：18.5 < BMI <= 25
偏胖：25 < BMI <= 30
肥胖：BMI > 30
"""

def calculate_BMI(weight, height):
    BMI = weight / height ** 2
    if BMI <= 18.5:
        category = "偏瘦"
    elif BMI <= 25:
        category  = "正常"
    elif BMI <= 30:
        category = "偏胖"
    else:
        category = "肥胖"
    print(f"您的BMI分类为：{category}")
    return BMI

result = calculate_BMI(1.8, 70)
print(result)

# import语句
import statistics
print(statistics.median([19, -5, 36]))
print(statistics.mean([19, -5, 36]))
# from...import...语句
from statistics import median, mean
print(median([19, -5, 36]))
print(mean([19, -5, 36]))
# from...import*
from statistics import *
print(median([19, -5, 36]))
print(mean([19, -5, 36]))

class CuteCat:
    # 下面是定义类的代码
    def __init__(self):  #括号里可以放任意数量的参数，第一个永远是self代表对象自身，它能把属性的值绑定在实例对象
        self.name = "猫猫"# 说明是对象的name属性的值，可以把self看作对象来理解，就是  对象的名字=猫猫  ，如果不加self就不是给对象赋值而是普通的赋值操作
cat1 = CuteCat()# 创建一个 CuteCat 类的实例对象，并调用构造方法  
print(cat1.name)

class 类名:     #创建一个类
    def __init__(self,猫猫名字,猫猫颜色,猫猫性别):    # 将对象的属性加入参数里
        self.猫猫名字 = 猫猫名字
cat1 = CuteCat("大橘",白色,"母")# 创建一个 Cat 类的实例对象，并传递属性值
print(f"猫猫的名字是：{cat1.猫猫名字}")
print(f"猫猫的颜色是：{cat1.猫猫颜色}")
print(f"猫猫的性别是：{cat1.猫猫性别}")

class CuteCat:
   # 定义一个名为 CuteCat 的类  
    def __init__(self,cat_name,cat_age,cat_color): # 定义类的构造方法，当创建类的实例对象时，这个方法会自动被调用  
        self.name = cat_name 
        self.age = cat_age
        self.color = cat_color
cat1 = CuteCat("jojo",2,"白色")# 创建一个 CuteCat 类的实例对象，并调用构造方法，同时传递了三个参数，分别是 cat_name,cat_age,cat_color  
print(f"小猫{cat1.name}的年龄是{cat1.age}岁，花色是{cat1.color}")

# 先考虑各个对象有什么性质、能做什么，下面以ATM为例。
class ATM:  # 创建一个名为ATM类
    def __init__(self, 编号, 银行, 支行):  # 提取ATM的性质(编号,银行,支行)，定义ATM类。
        self.编号 = 编号
        self.银行 = 银行#将传递给 ATM 类构造函数的 银行 参数的值保存到 ATM 对象内部，以便以后可以在对象中使用。
        self.支行 = 支行
        self.余额 = 0  # ATM的初始余额为0
    """def 方法名(self, 参数1, 参数2, ...):
          方法的代码实现
          可以访问self来操作对象的属性和方法
          方法的具体逻辑"""
    def 存款(self, 金额):
        # 存款方法，用于将指定金额添加到ATM的余额中
        self.余额 += 金额
        return f"{金额} 元已成功存入ATM，当前余额为 {self.余额} 元。"

    def 取款(self, 金额):
        # 取款方法，用于从ATM的余额中取出指定金额
        if 金额 <= self.余额:
            self.余额 -= 金额
            return f"{金额} 元已成功取出，当前余额为 {self.余额} 元。"
        else:
            return "余额不足，无法取款。"

    def 查询余额(self):
        # 查询余额方法，用于查看ATM的当前余额
        return f"当前余额为 {self.余额} 元。"
# 通过类创建ATM对象
atm1 = ATM("001","招商银行","南支行")
atm2 = ATM("002","中国银行","北支行")
# 定义ATN类的方法(方法：放在类里面的函数。属性：类里面的变量。)

# 使用ATM对象的方法进行操作
print(atm1.存款(1000))
print(atm1.查询余额())
print(atm1.取款(500))
print(atm1.查询余额())

class CuteCat:
    # 下面是定义类的代码
    def __init__(self, cat_name, cat_age, cat_color):
        self.name = cat_name
        self.age = cat_age
        self.color = cat_color

    def speak(self):
        print("喵" * self.age)#"喵"✖年龄，如果一岁就打印一个，两岁打印两个。

    def think(self, content):#创建think方法
        print(f"小猫{self.name} 在思考{content}...")


cat1 = CuteCat("jojo", 2, "白色")
cat1.think("选择去抓沙发还是去撕纸箱")# 调用think方法给content参数
print(f"小猫{cat1.name}的年龄是{cat1.age}岁，花色是{cat1.color}")

# 定义一个学生类
# 要求：
# 1. 属性包括学生姓名、学号，以及语数英三科的成绩
# 2. 能够设置学生某科目的成绩
# 3. 能够打印出该学生的所有科目成绩

class Student:
    def __init__(self, name, student_id):
        self.name = name
        self.student_id = student_id
        self.grades = {"语文": 0, "数学": 0, "英语": 0}

    def set_grade(self, course, grade):
        if course in self.grades:
            self.grades[course] = grade

    def print_grades(self):
        print(f"学生{self.name} (学号：{self.student_id}) 的成绩为：")
        for course in self.grades:
            print(f"{course}: {self.grades[course]}分")

chen = Student("小陈", "100618")
chen.set_grade("语文", 92)
chen.set_grade("数学", 94)
chen.print_grades()
# zeng = Student("小曾", "100622")
# print(chen.name)
# zeng.set_grade("数学", 95)
# print(zeng.grades)

class 哺乳类:  # 这是父类
    def __init__(self,名字,性别):
        self.名字 = 名字
        self.性别 = 性别
        self.眼睛数量 = 2

    def 呼吸(self):
        print(self.名字 + "在呼吸...")

    def 拉屎(self):
        print(self.名字 + "在拉屎...")


class 人类(哺乳类):  # 这是子类
    def __init__(self,名字,性别):
        super().__init__(名字,性别)#super会返回当前类的父类，调用父类的构造函数
        self.尾巴 = False  #因为用了super就可以在子类里面接着父类的后面定义类
    def 阅读(self):
        print(self.名字 + "在阅读...")


class 猫(哺乳类):  # 这是子类
    def __init__(self, 名字, 性别):
        super().__init__(名字,性别)#super会返回当前类的父类
        self.尾巴 = True
    def 抓沙发(self):
        print(self.名字 + "在抓沙发...")
    def 拉屎(self):
        print(self.名字 + "在猫砂上拉屎...")


猫1 = 猫("小黑", "男")  # 由于子类没有自己的构造函数`__init__`，就会调用父类的,让实例具备名字性别眼睛数。

猫1 = 拉屎()  # 如果子类没有拉屎的方法就调用父类的，子类有就会调用自己的。（优先看所属的类有没有该方法，没有就往上找父类的同名方法用）

"A是B"                             class A(B):
"人类是动物"                    class 人类(动物):
"新能源车是车"                 class 新能源车(车):

# 类继承练习：人力系统
# - 员工分为两类：全职员工 FullTimeEmployee、兼职员工 PartTimeEmployee。
# - 全职和兼职都有"姓名 name"、"工号 id"属性，
#   都具备"打印信息 print_info"（打印姓名、工号）方法。
# - 全职有"月薪 monthly_salary"属性，
#   兼职有"日薪 daily_salary"属性、"每月工作天数 work_days"的属性。
# - 全职和兼职都有"计算月薪 calculate_monthly_pay"的方法，但具体计算过程不一样。

class Employee:
    def __init__(self, name, id):
        self.name = name
        self.id = id

    def print_info(self):
        print(f"员工名字：{self.name}，工号：{self.id}")

class FullTimeEmployee(Employee):
    def __init__(self, name, id, monthly_salary):
        super().__init__(name, id)
        self.monthly_salary = monthly_salary

    def calculate_monthly_pay(self):
        return self.monthly_salary

class PartTimeEmployee(Employee):
    def __init__(self, name, id, daily_salary, work_days):
        super().__init__(name, id)
        self.daily_salary = daily_salary
        self.work_days = work_days

    def calculate_monthly_pay(self):
        return self.daily_salary * self.work_days

zhangsan = FullTimeEmployee("张三", "1001", 6000)
lisi = PartTimeEmployee("李四", "1002", 230, 15)
zhangsan.print_info()
lisi.print_info()
print(zhangsan.calculate_monthly_pay())
print(lisi.calculate_monthly_pay())

open("./data.txt")  # 可以是相对路径或绝对路径

open("./data.txt", "r")  # 只读模式
open("./data.txt", "w")  # 只写模式
open("./data.txt")  # 读写模式

open("./data.txt", "r", encoding="utf-8")

file = open("./data.txt", "r", encoding="utf-8")
content = file.read()  # 读取全部内容并存储在变量中
content = file.read(10) #表示会读多少字节，下一次调用就会继续往下读。

file = open("./data.txt", "r", encoding="utf-8")
line = file.readline()  # 读取第一行
while line != "":  # 判断当前行是否为空
    print(line)     # 不为空则打印
    line = file.readline()  # 读取下一行

file = open("./data.txt", "r", encoding="utf-8")
lines = file.readlines()  # 将每行内容存储到列表中
for line in lines:     #一行一行循环列表里的内容
    print(line)        # 打印当前行

file = open("./data.txt")
# 执行文件操作
file.close()  # 关闭文件

with open("./data.txt") as file:

with open("./data.txt", "w", encoding="utf-8") as file:
    file.write("hello!\n")  # 向文件中写入"hello!"
    file.write("word")      # 继续写入"word"

with open("./data.txt", "a", encoding="utf-8") as file:
    file.write("hello!\n")  # 向文件中写入"hello!"
    file.write("word")      # 继续写入"word"，不会自动换行

with open("./data.txt", "r+", encoding="utf-8") as file:
    file.write("hello!\n")  # 向文件中写入"hello!"
    file.write("word")      # 继续写入"word"
    content = file.read()   # 读取文件内容

# 任务1：在一个新的名字为"poem.txt"的文件里，写入以下内容：
# 我欲乘风归去，
# 又恐琼楼玉宇，
# 高处不胜寒。
with open("./poem.txt", "w", encoding="utf-8") as f:
    f.write("我欲乘风归去，\n又恐琼楼玉宇，\n高处不胜寒。\n")

# 任务2：在上面的"poem.txt"文件结尾处，添加以下两句：
# 起舞弄清影，
# 何似在人间。
with open("./poem.txt", "a", encoding="utf-8") as f:
    f.write("起舞弄清影，\n")
    f.write("何似在人间。")

number_list = [56, 0, 8, 5]
number_list[4]  # 索引超出列表范围，引发 IndexError（索引错误）
---------------------------------------------------------------------------
print(56 / 0)  # 除以零，引发 ZeroDivisionError（除零错误）
---------------------------------------------------------------------------
open("./data1.txt", "w")  # 打开不存在的文件，引发 FileNotFoundError（文件未找到错误）
---------------------------------------------------------------------------
"he" * "hi"  # 两个字符串相乘，引发 TypeError（类型错误）

try:
    user_weight = float(input("请输入您的体重（单位：kg）："))  # 放上可能会报错的代码
    user_height = float(input("请输入您的身高（单位：m）："))
    user_BMI = user_weight / user_height ** 2
except ValueError:  # 跟上想捕捉的错误名字，以及冒号。捕捉 ValueError 异常
    print("输入不合理数字，请重新运行程序")  # 错误发生后执行的操作
except ZeroDivisionError: # 捕捉 ZeroDivisionError 异常
    print("身高不能为零，请重新运行程序")  # 错误发生后执行的操作
except:  # 后面什么都不填会捕捉所有的错误类型
    print("发生了未知错误，请重新运行程序")  # 错误发生后执行的操作
else:
    print("您的BMI值为：" + str(user_BMI))  # 没有发生异常时执行的代码
finally:
    print("程序结束运行")  # 无论错误与否都会被执行的语句，无论有没有错误，程序炸了，finally里面的内容都会被执行。

assert len("Hi") == 2  # 这会通过，因为字符串"Hi"的长度是2
assert 1 + 2 > 6  # 这会引发AssertionError异常，因为1 + 2不大于6
assert "a" in ["b", "c"]  # 这会引发AssertionError异常，因为"a"不在列表中
assert 1 > 3  # 错误的断言，会引发AssertionError异常

# 实现代码    my_calculator.py文件
def my_adder(x, y):
    return x + y

---------------------------------------------------------------------------------------------------
# 测试代码   test_my_calculator.py文件

import unittest
from my_calculator import my_adder  # from 文件名 impor 函数名或from 文件名 import类名


class TestMyAdder(unittest.TestCase):  # 创建一个测试的类,要当unittest.TestCase的子类，这样就可以使用继承自unittest.TestCase的测试功能了。
    def test_positive_with_positive(self):
        self.assertEquals(my_adder(5, 3), 8)

    def test_negative_with_positive(self):
        self.assertEquals(my_adder(-5, 3), -2)

#unittest.TestCase类的常见测试方法
# 方法                         #类似于
assertEqual(A,B)             assert A==B#  断言A是否等于B。
assertTrue(A)                assert A is True # 断言A是否为True。本质上可以代替所有方法，但是不够详细
assertIn(A,B)                assert A in B# 断言A是否在B中。

# 实现代码 sentence.py
class Sentence:
    def __init__(self,sentence):
        self.sentence = sentence

#返回句子字母数量
    def letter_count(self):
        return len(self.sentence)
#返回句子单词数量
    def word_count(self):
        return len(self.sentence.split(" "))
    # 返回所有字母大写后的句子
    def upper(self):
        return self.sentence.upper()

---------------------------------------------------------------------------
# 测试代码 test_sentence.py
import unittest
from sentence import Sentence
class TestMyAdder(unittest.TestCase):
    def setUp(self):
        self.sentence = Sentence("hello word!")

    def test_str_count(self):
        self.assertEquals(self.sentence.str_count(),12)

    def test_word_count(self):
        self.assertEquals(self.sentence.word_count(),2)

    def test_upper(self):
        self.assertEquals(self.sentence.upper(),"hello word!")

# 实现代码 shopping_list.py
class ShoppingList:
    """初始化购物清单，shopping_list是字典类型，包含商品名和对应价格
    例子：{"牙刷": 5, "沐浴露": 15, "电池": 7}"""
    def __init__(self, shopping_list):
        self.shopping_list = shopping_list

    """返回购物清单上有多少项商品"""
    def get_item_count(self):
        return len(self.shopping_list)

    """返回购物清单商品价格总额数字"""
    def get_total_price(self):
        total_price = 0
        for price in self.shopping_list.values():
            total_price += price
        return total_price
----------------------------------------------------------
# 测试代码 test_shopping_list.py
      
'''
注意：此文件是针对以下类的测试文件。
你可以在此文件同一文件夹下新建shopping_list.py，并复制以下内容到该文件：

class ShoppingList:
    """初始化购物清单，shopping_list是字典类型，包含商品名和对应价格
    例子：{"牙刷": 5, "沐浴露": 15, "电池": 7}"""
    def __init__(self, shopping_list):
        self.shopping_list = shopping_list

    """返回购物清单上有多少项商品"""
    def get_item_count(self):
        return len(self.shopping_list)

    """返回购物清单商品价格总额数字"""
    def get_total_price(self):
        total_price = 0
        for price in self.shopping_list.values():
            total_price += price
        return total_price
'''

import unittest
from shopping_list import ShoppingList

class TestShoppingList(unittest.TestCase):
    def setUp(self):
        self.shopping_list = ShoppingList({"纸巾": 8, "帽子": 30, "拖鞋": 15})

    def test_get_item_count(self):
        self.assertEqual(self.shopping_list.get_item_count(), 3)

    def test_get_total_price(self):
        self.assertEqual(self.shopping_list.get_total_price(), 55)

    

# 打印平方
def calculate_and_print(num):
    result = num * num   # 计算
    print(f"""
    丨数字参数丨 {num}丨
    丨计算结果丨 {result}丨""")# 打印


calculate_and_print(3)# 传入数字

-----------------------------------------------------------------------
#除了打印平方，还打印三次方。
def calculate_and_print(num,power):
    if power == 2:
        result = num * num  # 计算平方
    elif power == 3:
        result = num * num * num  # 计算三次方

    print(f"""
    丨数字参数丨 {num}丨
    丨计算结果丨 {result}丨""")# 打印


calculate_and_print(3,3)# 传入数字和打印选项

----------------------------------------------------------------
# 除了打印三次方还能打印某数字+10后的结果
# 不把计算的过程逻辑保留着函数中，而把计算的函数作为参数。
def calculate_and_print(num, calculator):
    result = calculator(num)
    print(f"""
    丨数字参数丨 {num}丨
    丨计算结果丨 {result}丨""")  # 打印


def calculate_square(num):  # 计算平方
    return num * num


def calculate_cube(num):  # 计算三次方
    return num * num * num


def calculate_plus_10(num):  # 计算+10
    return num + 10


calculate_and_print(3, calculate_square)  # 计算打印平方，就传入平方函数
calculate_and_print(3, calculate_plus_10)  # 计算+10就传入+10的函数
--------------------------------------------------------------------------------------------------
# 定义一个函数 calculate_and_print，接受三个参数：num（数字参数）、calculator（计算函数）、formatter（格式化函数）
def calculate_and_print(num, calculator, formatter):
    # 使用计算函数来计算结果，并将结果保存在变量 result 中
    result = calculator(num)

    # 使用格式化函数来格式化并打印数字参数和计算结果
    formatter(num, result)


# 定义一个格式化函数 print_with_vertical_bar，接受两个参数：num（数字参数）和 result（计算结果）
def print_with_vertical_bar(num, result):
    # 打印数字参数和计算结果，使用竖线丨进行装饰
    print(f"""
    丨数字参数丨 {num}丨
    丨计算结果丨 {result}丨""")


# 定义一个计算函数 calculate_square，用于计算数字的平方
def calculate_square(num):
    return num * num


# 定义一个计算函数 calculate_cube，用于计算数字的三次方
def calculate_cube(num):
    return num * num * num


# 定义一个计算函数 calculate_plus_10，用于将数字加上 10
def calculate_plus_10(num):
    return num + 10


# 调用 calculate_and_print 函数，传入数字 3、计算函数 calculate_square 和格式化函数 print_with_vertical_bar
calculate_and_print(3, calculate_square, print_with_vertical_bar)  # 计算打印平方，就传入平方函数

lambda num1, num2: num1 + num2

lambda  num1, num2: num1 + num2# 只能有一个语句/表达式
-------------------------------------------------------------------------
def calculate_sum(num1, num2):# 可以有多个语句/表达式
    print(num1)
    print(num2)
    return num1 + num2

# 定义一个函数 calculate_and_print，接受三个参数：num（数字参数）、calculator（计算函数）、formatter（格式化函数）
def calculate_and_print(num, calculator, formatter):
    # 使用计算函数来计算结果，并将结果保存在变量 result 中
    result = calculator(num)

    # 使用格式化函数来格式化并打印数字参数和计算结果
    formatter(num, result)


# 定义一个格式化函数 print_with_vertical_bar，接受两个参数：num（数字参数）和 result（计算结果）
def print_with_vertical_bar(num, result):
    # 打印数字参数和计算结果，使用竖线丨进行装饰
    print(f"""
    丨数字参数丨 {num}丨
    丨计算结果丨 {result}丨""")


# 定义一个计算函数 calculate_square，用于计算数字的平方
def calculate_square(num):
    return num * num


# 定义一个计算函数 calculate_cube，用于计算数字的三次方
def calculate_cube(num):
    return num * num * num


# 定义一个计算函数 calculate_plus_10，用于将数字加上 10
def calculate_plus_10(num):
    return num + 10


# 调用 calculate_and_print 函数，传入数字 3、lambda 函数（计算数字乘以 5），和格式化函数 print_with_vertical_bar
calculate_and_print(3, lambda num: num * 5, print_with_vertical_bar)  # 计算数字乘以 5，然后使用格式化函数打印