python编程从入门到实践（第二版）第九章 课后练习题

"""练习 9-1 餐馆
创建一个名为 Restaurant 的类，其方法 __init__() 设置两个属性： restaurant_name
和 cuisine_type 。 创 建 一 个 名 为 describe_restaurant() 的 方 法 和 一 个 名 为
open_restaurant() 的方法，其中前者打印前述两项信息，而后者打印一条消息，指出餐
馆正在营业。
根据这个类创建一个名为 restaurant 的实例，分别打印其两个属性，再调用前述两
个方法。"""

# 1.创建类
class Restaurant():  # 餐厅
    """一个表示餐馆的类。"""
    def __init__(self, name, cuisine_type):  # 定义初始化实例属性（名字，菜类型）
        """初始化餐馆。"""
        self.name = name.title()  # 把形参赋值给变量并首字母大写
        self.cuisine_type = cuisine_type  # 把形参赋值给变量


    def describe_restaurant(self):# 定义实例方法
        """显示餐馆信息摘要。"""
        msg = f"{self.name} serves wonderful {self.cuisine_type}." # x 提供的 x 很好
        print(f"\n{msg}")  # 打印


    def open_restaurant(self):  # 定义实例方法
        """显示一条消息，指出餐馆正在营业。"""
        msg = f"{self.name} is open. Come on in!"  # x 有空进来
        print(f"\n{msg}") # 打印

# 2.创建对象
restaurant = Restaurant('麦当劳', 'pizza')  # 创建对象写入实参赋值给变量
print(restaurant.name)  # 打印(对象调用实例属性中的名字）
print(restaurant.cuisine_type)  # 打印(对象调用实例属性中的菜类型）

# 3.对象调用实例方法
restaurant.describe_restaurant()  # 对象调实例方法：用麦当劳提供的 pizza 很好
restaurant.open_restaurant() # 对象调实例方法：有空来麦当劳

"""练习 9-2 三家餐馆
根据你为完成练习 9-1 而编写类创建三个实例，并对每个实例调用方法"""
# 1.创建类
class Restaurant():  # 餐馆
    """一个表示餐馆的类。"""
    def __init__(self, name, cuisine_type):  # 定义初始化实例属性（名字，菜类型）
        """初始化餐馆。"""
        self.name = name.title()  # 把形参赋值给变量并首字母大写
        self.cuisine_type = cuisine_type  # 把形参赋值给变量

    def describe_restaurant(self):  # 定义实例方法
        """显示餐馆信息摘要。"""
        msg = f"{self.name} serves wonderful {self.cuisine_type}."  # x 提供的 x 很好
        print(f"\n{msg}")  # 打印

    def open_restaurant(self):  # 定义实例方法
        """显示一条消息，指出餐馆正在营业。"""
        msg = f"{self.name} is open. Come on in!"  # x 有空进来
        print(f"\n{msg}")

# 2.创建对象
restaurant = Restaurant('麦当劳', 'pizza')  # 创建对象
restaurant.describe_restaurant()  # 对象调用实例方法：麦当劳 提供的 pizza 很好

ludvigs = Restaurant("肯德基", 'bread')  # 创建对象
ludvigs.describe_restaurant()  # 对象调用实例方法：肯德基 提供的 bread 很好

mango_thai = Restaurant('华莱士', 'hamburg')  # 创建对象
mango_thai.describe_restaurant()  # # 对象调用实例方法：华莱士 提供的 hamburg 很好

"""练习9-3  用户
创建一个名为User的类，其中包含属性first_name和last_name，
还有用户简介通常会存储的其他几个属性。在类User中定义一个名为describe_user()的方法，
它打印用户信息摘要；再定义一个名为greet_user()的方法，它向用户发出个性化的问候。
创建多个表示不同用户的实例，并对每个实例都调用上述两个方法"""

# 1.定义一个用户类
class User():  # 用户
    """一个表示用户的简单类。"""
    def __init__(self, first_name, last_name, username, email, location):  # 定义初始化性
        """初始化用户（姓，名，用户名，电子邮箱，地址）"""
        self.first_name = first_name.title()  # 姓
        self.last_name = last_name.title()  # 名
        self.username = username  # 用户名
        self.email = email  # 电子邮箱
        self.location = location.title()  # 地址

    def describe_user(self):  # 定义实例方法：介绍用户
        """显示用户信息摘要。"""
        print(f"\n{self.first_name} {self.last_name}")  # 打印名字
        print(f" Username: {self.username}")  # 打印用户名
        print(f" Email: {self.email}")  # 打印邮箱
        print(f" Location: {self.location}")  # 打印地址

    def greet_user(self): # 打印实例方法：打招呼
        """向用户发出个性化的问候。"""
        print(f"\nWelcome back, {self.username}!")  # 欢迎回来 x


# 2.创建对象
eric = User('chen', 'fei', 'Afei', '0731431@163.com', '彩虹郡')  # 创建对象写入实参赋值变量
eric.describe_user()  # 调用实例方法：介绍用户
eric.greet_user()  # 调用实例方法：打招呼

willie = User('chen', 'si yuan', 'si yuan', '20020920@163.com', '彩虹郡')
willie.describe_user()
willie.greet_user()

"""练习9-4  就餐人数
在为完成练习9-1而编写的程序中，添加一个名为number_served的属性，并将其默认值设置为0。
1.根据这个类创建一个名为restaurant的实例；打印有多少人在这家餐馆就餐过，
2.然后修改这个值并再次打印它。
3.添加一个名为set_number_served()的方法，它让你能够设置就餐人数。调用这个方法并向它传递一个值，然后再次打印这个值。
4.添加一个名为increment_number_served()的方法，它让你能够增加就餐人数。
  调用这个方法并向它传递一个这样的值：你认为这家餐馆每天可能接待的就餐人数。"""

# 1.定义类
class Restaurant():  # 餐馆
    """一个表示餐馆的类。"""
    def __init__(self, name, cuisine_type):  # 定义实例属性：（名字，菜名）
        """初始化餐馆。"""
        self.name = name.title()  # 名字
        self.cuisine_type = cuisine_type  # 菜名
        self.number_served = 0  # 数量

    def describe_restaurant(self):  # 定义实例方法：描述餐厅
        """显示餐馆信息摘要。"""
        msg = f"{self.name} serves wonderful {self.cuisine_type}."  # x 端上了 x
        print(f"\n{msg}")  # 打印

    def open_restaurant(self):  # 定义实例方法：描述餐厅
        """显示一条消息，指出餐馆正在营业。"""
        msg = f"{self.name} is open. Come on in!"  # x 欢迎您
        print(f"\n{msg}")  # 打印

    def set_number_served(self, number_served):  # 定义实例方法：就餐人数
        """让用户能够设置就餐人数。"""
        self.number_served = number_served  # 就餐人数 = 参数

    def increment_number_served(self, additional_served):  # 定义实例方法：增加数量
        """让用户能够增加就餐人数。"""
        self.number_served += additional_served  # 就餐人数 = 原来人数 + 增加人数

# 2.创建对象
restaurant = Restaurant('麦当劳', 'pizza')  # 创建对象写入实参

# 3.调用对象
# 1
restaurant.describe_restaurant()  # 对象调用实例方法：描述餐厅( 麦当劳 端上了 pizza)
print(f"\n初始人数: {restaurant.number_served}")  # 打印初始属性为0

# 2
restaurant.number_served = 430  # 对象调用实例属性并设置人数为 430
print(f"更改初始人数: {restaurant.number_served}")  # 初始人数430

# 3
restaurant.set_number_served(1257)  # 对象调用实例方法：就餐人数（参数）
print(f"用户来设置就餐人数: {restaurant.number_served}")  # 让用户设置就餐人数

# 4
restaurant.increment_number_served(239)  # 对象调用实例方法：增加数量（参数）
print(f"我认为这家餐馆每天可能接待的就餐人数: {restaurant.number_served}")  # 我认为这家餐馆每天可能接待的就餐人数

"""练习 9-5 尝试登录次数
在为完成练习 9-3 而编写的 User 类中，
1.添加一个名为 login_attempts 的属性。
2.编写一个名为 increment_login_attempts() 的方法，它将属性 login_attempts 的值加 。
3.再编写一个名为 reset_login_attempts() 的方法，它将属性 login_attempts 的值重置为 0。
4.根据 User 类创建一个实例，再调用方法 increment_login_attempts() 多次。
5.打印属性 login_attempts 的值，确认它被正确地递增；
6.然后，调用方法 reset_login_attempts() ，
7.并再次打印属性 login_attempts 的值，确认它被重置为 0。"""

# 定义类
class User():  # 用户
    """一个表示用户的简单类。"""

    def __init__(self, first_name, last_name, username, email, location):  # 定义实例属性（姓，名，用户名，邮箱，地址）
        """初始化用户."""
        self.first_name = first_name.title()  # 姓
        self.last_name = last_name.title()  # 名
        self.username = username  # 用户名
        self.email = email  # 邮箱
        self.location = location.title()  # 地址
        # 1
        self.login_attempts = 0  # 登录次数

    def describe_user(self):  # 定义实例方法：描述用户
        """显示用户信息摘要。"""
        print(f"\n{self.first_name} {self.last_name}")
        print(f" Username: {self.username}")
        print(f" Email: {self.email}")
        print(f" Location: {self.location}")

    def greet_user(self):  # 定义实例方法：问候用户
        """向用户发出个性化问候。"""
        print(f"\n欢迎回来, {self.username}!")  # 很高兴看到你回来 x
    # 2
    def increment_login_attempts(self):  # 定义实例方法：增加登录次数
        """将属性 登录尝试次数 的值加 1。"""
        self.login_attempts += 1  # 登录次数 = 登录次数 + 1
    # 3
    def reset_login_attempts(self):  # 定义实例方法：重置登录尝试
        """将 登录尝试次数 重置为 0。"""
        self.login_attempts = 0


# 创建对象
eric = User('chen', 'si yuan', 'si yuan','20020920@163.com', '彩虹郡')  # 创建对象写入实参

# 调用方法
eric.describe_user()  # 对象调用描述用户
eric.greet_user()  # 对象调用问候用户

# 4
print("\n进行3次登录尝试...")  # 打印：进行三次登录尝试
eric.increment_login_attempts()  # 对象调用。增加登录次数
eric.increment_login_attempts()  # 对象调用。增加登录次数
eric.increment_login_attempts()  # 对象调用。增加登录次数

# 5
print(f"登录尝试次数: {eric.login_attempts}")  # 打印确认它被正确地递增
print("\n重置登录尝试...")

# 6
eric.reset_login_attempts()  # 重置登录

# 7
print(f"登录尝试次数: {eric.login_attempts}")  # 确认它被重置为 0

"""练习 9-6 冰激凌小店
冰激凌小店是一种特殊的餐馆。
1.编写一个名为 IceCreamStand 的类，让它继承你为完成练习 9-1 或 9-4 而编写的 Restaurant 类。
2.添加一个名为 flavors 的属性，用于存储一个由各种口味的冰激凌组成的列表。
3.编写一个显示这些冰激凌的方法。
4.创建一个 IceCreamStand 实例，并调用这个方法。"""

# 练习 9-1
class Restaurant():  # 餐厅
    """一个表示餐馆的类。"""
    def __init__(self, name, cuisine_type):  # 定义初始化实例属性（名字，菜类型）
        """初始化餐馆。"""
        self.name = name.title()  # 把形参赋值给变量并首字母大写
        self.cuisine_type = cuisine_type  # 把形参赋值给变量

    def describe_restaurant(self):  # 定义实例方法
        """显示餐馆信息摘要。"""
        msg = f"{self.name} 提供 {self.cuisine_type}."  
        print(f"\n{msg}")  # 打印

    def open_restaurant(self):  # 定义实例方法
        """显示一条消息，指出餐馆正在营业。"""
        msg = f"{self.name} is open. Come on in!"  # x 有空进来
        print(f"\n{msg}")  # 打印

# 1.定义子类继承你为完成练习 9-1
class IceCreamStand(Restaurant):  # 把父类作为参数传给子类
    """一个表示冰激凌小店的类。"""
    def __init__(self, name, cuisine_type='ice_cream'):  # 定义初始子类属性（把自己的品种作为默认值赋值给父类的品种）
        """初始化冰激凌小店。"""
        super().__init__(name, cuisine_type)  # 更改初始父类属性
        # 2
        self.flavors = []  # 定义口味的空列表

    # 3
    def show_flavors(self):  # 定义实例方法：口味
        """显示出售的冰激凌品种。"""
        print("\n我们有以下几种口味:")  # 我们有以下几种口味
        for flavor in self.flavors:  # 让临时口味循环在口味列表
            print(f"- {flavor}")  # 打印取值的口味


# 4 创建对象并调用这个方法
big_one = IceCreamStand('冰激凌小店', '怪味冰激凌')  # 创建对象并赋值给变量

big_one.flavors = ['甜', '酸', '苦','辣']  # 对象调用子类属性中的口味列表并赋值
big_one.describe_restaurant()  # 对象调用父类的方法：描述
big_one.show_flavors()  # 对象调用子类的方法：口味

"""练习 9-7 管理员 管理员是一种特殊的用户。
1.编写一个名为 Admin 的类，让它继承你为完成练习 9-3 或9-5 而编写的 User 类
2.添加一个名为 privileges 的属性，用于存储一个由字符串（如"can add post" 、 "can delete post" 和 "can ban user" 等）组成的列表。
3.编写一个名为show_privileges() 的方法，它显示管理员的权限。
4.创建一个 Admin 实例，并调用这个方法"""
# 练习 9-5
class User():  # 用户
    """一个表示用户的简单类。"""
    def __init__(self, first_name, last_name, username, email, location):  # 定义实例属性（姓，名，用户名，邮箱，地址）
        """初始化用户."""
        self.first_name = first_name.title()  # 姓
        self.last_name = last_name.title()  # 名
        self.username = username  # 用户名
        self.email = email  # 邮箱
        self.location = location.title()  # 地址
        self.login_attempts = 0  # 登录次数

    def describe_user(self):  # 定义实例方法：描述用户
        """显示用户信息摘要。"""
        print(f"\n{self.first_name} {self.last_name}")
        print(f" Username: {self.username}")
        print(f" Email: {self.email}")
        print(f" Location: {self.location}")

    def greet_user(self):  # 定义实例方法：问候用户
        """向用户发出个性化问候。"""
        print(f"\n欢迎回来, {self.username}!")  # 很高兴看到你回来 x

    def increment_login_attempts(self):  # 定义实例方法：增加登录次数
        """将属性 登录尝试次数 的值加 1。"""
        self.login_attempts += 1  # 登录次数 = 登录次数 + 1

    def reset_login_attempts(self):  # 定义实例方法：重置登录尝试
        """将 登录尝试次数 重置为 0。"""
        self.login_attempts = 0

# 1.定义子类
class Admin(User):  # 把父类作为参数传给子类
    """有管理权限的用户。"""

    def __init__(self, first_name, last_name, username, email, location):  # 定义实例属性
        """初始化管理员。"""
        super().__init__(first_name, last_name, username, email, location)  # 更改实例属性

        # 2.添加一个名为 privileges 的属性
        self.privileges = []  # 定义特殊对待人员的空列表

    # 3。编写一个名为show_privileges() 的方法
    def show_privileges(self):  # 定义实例方法：显示权限
        """显示当前管理员的权限。"""
        print("\nPrivileges:")  # 打印：特殊对待人员
        for privilege in self.privileges:  # 临时变量在特殊对待人员的列表里循环
            print(f"- {privilege}")  # 打印循环的取值


# 4.创建对象并调用
eric = Admin('chen', 'si yuan', 'si yuan','20020920@163.com', '彩虹郡')  # 创建对象并赋值

eric.describe_user()  # 对象调用父类实方法：描述用户
eric.privileges = [ 'can add post','can delete post','can ban user', ]
eric.show_privileges()  # 对象调用方法：显示权限

"""练习9-8  权限
1.编写一个名为Privileges的类，它只有一个属性——privileges，
2.其中存储了练习9-7所说的字符串列表。将方法show_privileges()移到这个类中。
3.在Admin类中，将一个Privileges实例用作其属性。
4.创建一个Admin实例，并使用方法show_privileges()来显示其权限。"""
# 练习 9-7
class User():  # 用户
    """一个表示用户的简单类。"""
    def __init__(self, first_name, last_name, username, email, location):  # 定义实例属性（姓，名，用户名，邮箱，地址）
        """初始化用户."""
        self.first_name = first_name.title()  # 姓
        self.last_name = last_name.title()  # 名
        self.username = username  # 用户名
        self.email = email  # 邮箱
        self.location = location.title()  # 地址
        self.login_attempts = 0  # 登录次数

    def describe_user(self):  # 定义实例方法：描述用户
        """显示用户信息摘要。"""
        print(f"\n{self.first_name} {self.last_name}")
        print(f" Username: {self.username}")
        print(f" Email: {self.email}")
        print(f" Location: {self.location}")

    def greet_user(self):  # 定义实例方法：问候用户
        """向用户发出个性化问候。"""
        print(f"\n欢迎回来, {self.username}!")  # 很高兴看到你回来 x

    def increment_login_attempts(self):  # 定义实例方法：增加登录次数
        """将属性 登录尝试次数 的值加 1。"""
        self.login_attempts += 1  # 登录次数 = 登录次数 + 1

    def reset_login_attempts(self):  # 定义实例方法：重置登录尝试
        """将 登录尝试次数 重置为 0。"""
        self.login_attempts = 0

class Admin(User):  # 把父类作为参数传给子类
    """有管理权限的用户。"""

    def __init__(self, first_name, last_name, username, email, location):  # 定义实例属性
        """初始化管理员。"""
        super().__init__(first_name, last_name, username, email, location)  # 更改实例属性

        # 3.在Admin类中，将一个Privileges实例用作其属性
        self.privileges = Privileges()   

# 1.编写一个名为Privileges的类，它只有一个属性
class Privileges():  # 权限
    """一个存储管理员权限的类。"""
    def __init__(self, privileges=[]):  # 定义实例属性：特权初始化为空列表
        self.privileges = privileges  # 把特权到列表

    # 2.将方法show_privileges()移到这个类中
    def show_privileges(self):  # 定义实例方法：显示特权
        print("\nPrivileges:")  # 打印：特权
        if self.privileges:  # 如果有特权
            for privilege in self.privileges:  # 临时变量在特权列表里循环
                print(f"- {privilege}")  # 打印循环的取值
        else:  # 以上不成立
            print("- 此用户没有权限")

# 4.创建对象并调用
eric = Admin('chen', 'si yuan', 'si yuan','20020920@163.com', '彩虹郡')  # 创建对象并赋值
eric.privileges.show_privileges()

eric.describe_user()  # 对象调用父类实方法：描述用户

# 3. 对象调用把特权列表赋值给 Privileges 类的 privileges 实例属性
print('\n正在添加权限......')
eric_privileges = ['can add post', 'can delete post', 'can ban user']  # 权限列表
# 题目要表达的可能是privileges类是Admin的属性，Admin的对象可以调用privileges里面的方法
eric.privileges.privileges = eric_privileges
eric.privileges.show_privileges()  # 现在就可以打印出权限了

"""练习9-9  电瓶升级
1.在本节最后一个electric_car.py版本中，给Battery类添加一个名为upgrade_battery()的方法。
2.这个方法检查电瓶容量，如果它不是85，就将它设置为85。
3.创建一辆电瓶容量为默认值的电动汽车，调用方法get_range()，然后对电瓶进行升级，
4.并再次调用get_range()。你将看到这辆汽车的续航里程增加了"""
# 定义父类
class Car():  # 定义汽车类
    """一次模拟汽车的简单尝试。"""
    def __init__(self, manufacturer, model, year):  # 定义实例属性（品牌，型号。年份）
        """初始化描述汽车的属性。"""
        self.manufacturer = manufacturer  # 品牌
        self.model = model  # 型号
        self.year = year  # 年份
        self.odometer_reading = 0  # 初始里程表读数

    def get_descriptive_name(self):  # 定义实例方法：描述信息
        """返回整洁的描述性信息。"""
        long_name = f"{self.year} {self.manufacturer} {self.model}"  # 名字 = 品牌，型号。年份
        return long_name.title()  # 返回名字信息并首字母大写

    def read_odometer(self):  # 定义实例方法：公里数
        """打印一条指出汽车里程的消息。"""
        print(f"This car has {self.odometer_reading} miles on it.")  # 这辆车行驶 x 公里了

    def update_odometer(self, mileage):  # 定义实例方法：指定公里数（参数）
        """
        将里程表读数设置为指定的值。
        禁止将里程表读数往回调。
        """
        if mileage >= self.odometer_reading:  # 如果参数 >= 初始里程表读数
            self.odometer_reading = mileage  # 就赋值给初始里程表读数
        else:  # 如果以上不成立
            print("You can't roll back an odometer!")  # 打印（你不能吧里程表倒回去）

    def increment_odometer(self, miles):  # 定义实例方法：增加公里数
        """将里程表读数增加指定的量。"""
        self.odometer_reading += miles  # 初始公里数 = 初始公里数 + 增加的里程数

# 定义电池类
class Battery():  # 电池
    """一次模拟电动汽车电瓶的简单尝试。"""
    def __init__(self, battery_size=75):  # 定义初始化属性（电量 = 75)
        """初始化电瓶的属性。"""
        self.battery_size = battery_size  # 把电池的电量赋值给电池

    def describe_battery(self):  # 定义实例方法：描述电瓶
        """打印一条描述电瓶容量的消息。"""
        print(f"This car has a {self.battery_size}-kWh battery.")  # 这辆车（实例属性）的容量

    def get_range(self):  # 定义实例方法：电瓶的续航
        """打印一条消息，指出电瓶的续航里程。"""
        if self.battery_size == 75:  # 如果电量 75
            range = 260  # 可以行驶 260 公里
        elif self.battery_size == 85:  # 如果电量 85
            range = 315  # 可以行驶 2315 公里

        message = f"这辆车可以行驶 {range}"  # 这辆车可以行驶 range 公里
        message += " 满负荷行驶"  # 满负荷行驶
        print(message)  # 打印：满负荷行驶这辆车可以行驶 range 公里
    # 1.添加一个名为upgrade_battery()的方法
    def upgrade_battery(self):   # 定义实例方法：升级电池
        """在可能的情况下将电瓶升级。"""
        if self.battery_size == 75:  # 如果电量 75
            self.battery_size = 85  # 把电量 85 赋值给电池
            print("将电池升级到 85.")  # 打印（将电池升级到 85 ）
        else:  # 以上不成立
            print("电池已经升级")  # 电池已经升级

# 定义电动汽车子类
class ElectricCar(Car):  # 定义子类（把父类作为参数传入）
    """电动汽车的独特之处。"""
    def __init__(self, manufacturer, model, year):  # 定义实例属性（ 品牌，型号。年份）
        """
        初始化父类的属性。
        再初始化电动汽车特有的属性。
        """
        super().__init__(manufacturer, model, year)  # 更改实例属性（品牌，型号。年份）
        self.battery = Battery()  # 把电池类赋值给电池
        print("制作一辆电动车并检查电池")  # 打印（制作一辆电动车并检查电池）

# 1.创建一辆电瓶容量为默认值的电动汽车
my_tesla = ElectricCar('tesla', 'roadster', 2019)  # 创建对象写入实参
my_tesla.battery.describe_battery()  # 对象调用电池类中的实例方法：描述电瓶

# 2.这个方法检查电瓶容量，如果它不是85，就将它设置为85
print("\n升级电池并再次检查:")  # 打印（升级电池并再次检查）
my_tesla.battery.upgrade_battery()  # 对象调用电池类中的实例方法：升级电池
my_tesla.battery.get_range()  # 对象调用电池类中的实例方法：描述电瓶的续航

# 4.并再次调用get_range()。你将看到这辆汽车的续航里程增加了
print("\n尝试第二次升级电池.")  # 打印（尝试第二次升级电池）
my_tesla.battery.upgrade_battery()  # 对象调用电池类中的实例方法：升级电池
my_tesla.battery.get_range()  # 对象调用电池类中的实例方法：描述电瓶的续航

"""练习9-10  导入Restaurant类
1.将最新的Restaurant类存储在一个模块中。
2.在另一个文件中，导入Restaurant类、
3.创建一个Restaurant实例并调用Restaurant的一个方法以确认import语句正确无误。"""

# 1. 找的练习9-1的文件 （文件名：restaurant.py)
# 2. 再新建一个文件，导入Restaurant类
from restaurant import Restaurant #（from 文件名 import 类名）
# 3.创建一个Restaurant实例并调用Restaurant的一个方法以确认import语句正确无误
channel_club = Restaurant('麦当劳', 'pizza')  # 创建对象
channel_club.describe_restaurant()  # 调用方法确认无误
channel_club.open_restaurant()

"""练习9-11  导入Admin类
以为完成练习9-8而做的工作为基础。将User、Privileges和Admin类存储在一个模块中，
再创建一个文件，
在其中创建一个Admin实例并对其调用方法show_privileges()，以确认一切都能正确地运行。"""

# 提示：这题和9-10一样，都是在新建文件里面导入以前的文件，再看看能否正常调用

"""练习 9-13 骰子
1.请创建一个 Die 类，它包含一个名为 sides 的属性，该属性的默认值为 6。
编写一个名为 roll_die() 的方法，它打印位于 1 和骰子面数之间的随机数。
2.创建一个 6 面的骰子再掷 10 次。
3.创建一个 10 面的骰子和一个 20 面的骰子，再分别掷 10 次。"""

# 把 random 模块中的 randint(随机整数） 类导入该模块中
from random import randint

# 1.创建一个类
class Die():
    """一个表示骰子的类。"""
    def __init__(self, sides=6):  # 定义实例属性（指定参数）
        """初始化骰子。"""
        self.sides = sides  # 面

    def roll_die(self):  # 定义实例方法
        """返回一个位于 1 和骰子面数之间的随机数。"""
        return randint(1, self.sides)  # 返回： 随机数函数（1，6））


# 2.创建一个 6 面的骰子再掷 10 次
d6 = Die()  # 参数是默认的 6
results = []  # 定义空列表

for roll_num in range(10):  # 让实例方法在指定范围内（10）循环
    result = d6.roll_die()  # 变量接收 = 对象调用实例方法
    results.append(result)  # 把循环的取值添加到列表
print("6 面的骰子掷 10 次")
print(results)  # 打印列表

# 3.创建一个 10 面的骰子，再掷 10 次并显示结果。
d10 = Die(sides=10)  # 创建对象写入指定参数 10
results = []  # 定义空列表
for roll_num in range(10): # 让实例方法在指定范围内（10）循环
    result = d10.roll_die()  # 变量接收 = 对象调用实例方法
    results.append(result)  # 把循环的取值添加到列表
print("\n10 面的骰子掷 10 次:")
print(results)  # 打印列表

# 3.创建一个 20 面的骰子，再掷 10 次并显示结果。
d20 = Die(sides=20)  # 创建对象写入指定参数 20
results = []  # 定义空列表
for roll_num in range(10):  # 让实例方法在指定范围内（10）循环
    result = d20.roll_die()  # 变量接收 = 对象调用实例方法
    results.append(result)  # 把循环的取值添加到列表
print("\n20 面的骰子掷 10 次")
print(results)  # 打印列表

"""练习 9-14 彩票
1.创建一个列表或元组，其中包含 10 个数和 5 个字母。
2.从这个列表或元组中随机地选择 4 个数或字母，
3.并打印一条消息，指出只要彩票上是这 4 个数或字母，就中大奖了。"""

# 把 random 模块中的 choice(随机字符串函数） 类导入该模块中
from random import choice

# 1.定义两个列表
possibilities = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a', 'b', 'c', 'd', 'e']  # 变量接收 = 定义列表写入数据
winning_ticket = []  # 定义一个空列表
print("开始选择...")

# 2.从列表中随机地选择 4 个数或字母。
while len(winning_ticket) < 4:  # 循环列表小于 4 次 （因为是循环序列所以前面要加 len ）
    pulled_item = choice(possibilities)  # 变量接收 = 随机字符串函数（列表）
    # 仅当摇出的数字或字母不在组合中时，才将其添加到组合中。
    if pulled_item not in winning_ticket:  # 如果随机字符数不在空列表里面
        print(f"你选择了 {pulled_item}!")
        winning_ticket.append(pulled_item)  # 把选中的随机数添加到空列表

# 3.并打印一条消息，指出只要彩票上是这 4 个数或字母，就中大奖了
print("\n你的彩票是...")
print(winning_ticket)
print("恭喜你中奖！")

"""练习 9-15 彩票分析
可使用循环来搞明白中彩票大奖有多难。
为此，创建一个名为 my_ticket 的列表或元组，
再编写一个循环，不断地随机选择数或字母，直到中大奖为止。
请打印一条消息，指出执行循环多少次才中了大奖。"""

# 1.把 random 模块中的 choice(随机字符串函数） 类导入该模块中
from random import choice

# 2.定义函数摇出开奖的号码
def get_winning_ticket(possibilities):  # 定义名为中将的函数，并写入形参（可能性）
    winning_ticket = []  # 定义一个空（奖票）列表
    # 中奖组合中不能包含重复的数字或字母，因此使用了 while 循环。
    while len(winning_ticket) < 4:  # 循环列表小于 4 次 （因为是循环序列所以前面要加 len ）
        pulled_item = choice(possibilities)  # 变量接收 = 随机字符串函数（实参）
        # 号码不能重复当摇出的数字或字母不在组合中时，才将其添加到组合中。
        if pulled_item not in winning_ticket:  # 如果摇出的值不在空列表里面
            winning_ticket.append(pulled_item)  # 就把它添加到空列表
    return winning_ticket  # 返回空列表


# 3.定义一个随机地生成彩票函数
def check_ticket(win_tickets, tickets):  # 写入形参（开奖的号码，号码列表）
    n = 0  # 总共循环次数
    my_tickets = []  # 定义一个我抽奖的号码列表
    while True:  # 无限循环
        i = 0  # 每张彩票循环次数
        copy_tickets = tickets[:]  # 将号码列表复制
        while i < len(win_tickets):  # 循环4次
            n += 1  # 总共循环次数+1
            chioce = choice(copy_tickets)  # 在号码列表选一个
            my_tickets.append(chioce)  # 添加到我抽奖的号码列表
            copy_tickets.remove(chioce)  # 将已经进入我的列表里的号码移除，避免号码重复
            i += 1  # 每张彩票循环次数+1（因为每张彩票4个号到4就停止内循环）
        if my_tickets != win_tickets:  # 如果我抽的号码不等于开奖的号码
            while my_tickets:  # 循环在我抽的号码
                my_tickets.pop()  # 将我的彩票列表清空
            continue # 重新开始循环选号
        else:  # 反之我抽的号码等于开奖的号码
            print(f'您抽的号码为：\n{my_tickets}')  # 打印
            print('\n恭喜你中奖了')    
            print(f'您抽奖抽了{n}次')
            break  # 结束循环

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a', 'b', 'c', 'd', 'e']  # 待选号码
win = get_winning_ticket(numbers)  # 拿到本期开奖号码
print(f'本期开奖号码：\n{win}')  # 打印本期开奖号码
check_ticket(win, numbers)  # 调用随机地生成彩票函数（本期开奖号码，待选号码）