这段代码展示了Python编程中类和实例的使用，包括创建简单的Dog、Restaurant、User、Car等类，以及它们的实例方法如sit(), roll_over(), describe_restaurant(), increment_login_attempts()等。代码还涉及了继承、属性修改和方法调用，以及模拟电动汽车和冰激凌小店等特定场景。此外，还展示了如何导入和使用不同模块中的类。
dog.py
class Dog:
"""一次模拟小狗的简单尝试."""
def __init__(self, name, age):
"""初始化属性name和age."""
self.name = name
self.age = age
def sit(self):
"""模拟小狗收到命令时蹲下."""
print(f"{self.name} is now sitting.")
def roll_over(self):
"""模拟小狗收到命令时打滚."""
print(f"{self.name} rolled over!")
my_dog = Dog('willie', 6)
print(f"My dog's name is {my_dog.name}.")
print(f"My dog is {my_dog.age} years old.")
# 调用方法
my_dog = Dog('willie', 6)
my_dog.sit()
my_dog.roll_over()
# 创建多个实例
my_dog = Dog('willie', 6)
your_dog = Dog('Lucy', 3)
print(f"My dog's name is {my_dog.name}.")
print(f"My dog is {my_dog.age} years old.")
my_dog.sit()
print(f"My dog's name is {your_dog.name}.")
print(f"My dog is {your_dog.age} years old.")
your_dog.sit()
restaurant.py
# 练习 9-1 餐馆
# 创建一个名为 Restaurant 的类，其方法 __init__() 设置两个属性：
# restaurant_name和 cuisine_type 。
# 创建 一 个 名 为 describe_restaurant() 的 方 法
# 和 一 个 名 为open_restaurant() 的方法，
# 其中前者打印前述两项信息，而后者打印一条消息，指出餐馆正在营业。
# 根据这个类创建一个名为 restaurant 的实例，分别打印其两个属性，再调用前述两个方法。
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}."
print(f"\n{msg}")
def open_restaurant(self):
"""显示一条消息,指出餐馆正在营业."""
msg = f"{self.name} is open. Come on in!"
print(f"\n{msg}")
restaurant = Restaurant('the mean queen', 'pizza')
print(restaurant.name)
print(restaurant.cuisine_type)
restaurant.describe_restaurant()
restaurant.open_restaurant()
restaurants.py
# 练习 9-2 三家餐馆
#根据你为完成练习 9-1 而编写类创建三个实例，并对每个实例调用方法describe_restaurant() 。
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}."
print(f"\n{msg}")
def open_restaurant(self):
"""显示一条消息,指出餐馆正在营业."""
msg = f"{self.name} is open. Come on in!"
print(f"\n{msg}")
# 编写类创建三个实例，并对每个实例调用方法describe_restaurant()
mean_queen = Restaurant('the mean queen', 'pizza')
mean_queen.describe_restaurant()
ludvigs = Restaurant("ludvig's bistro", 'seafood')
ludvigs.describe_restaurant()
mango_thai = Restaurant('mango thai', 'thai food')
mango_thai.describe_restaurant()
user.py
# 练习 9-3 用户
# 创建一个名为 User 的类，其中包含属性 first_name 和 last_name ，还有用户简介
# 通常会存储的其他几个属性。定义一个名为 describe_user() 的方法，它打印用户信息摘要；
# 再定义一个名为 greet_user() 的方法，它向用户发出个性化的问候。
# 创建多个表示不同用户的实例，并对每个实例都调用上述两个方法。
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}!")
kuraki = User('kuraki', 'mai', 'kuraki_mai', 'kuraki_mai@example.com', 'tokyo')
kuraki.describe_user()
kuraki.greet_user()
sakura = User('sakura', 'yuki', 'sakura_yuki', 'sakura_yuki@example.com', 'yokohama')
sakura.describe_user()
sakura.greet_user()
car.py
# 使用类和实例
class Car:
"""一次模拟汽车的简单尝试"""
def __init__(self, make, model, year):
"""初始化汽车的属性."""
self.make = make
self.model = model
self.year = year
# 给属性指定默认值
self.odometer_reading = 0
def get_desriptive_name(self):
"""返回简洁的描述性信息."""
long_name = f"{self.year} {self.make} {self.model} {self.year}"
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息."""
print(f"This car has {self.odometer_reading} miles on it.")
my_new_car = Car('audi', 'a4', 2021)
print(my_new_car.get_desriptive_name())
my_new_car.read_odometer()
car1.py
# 修改属性的值
# 1.直接修改属性的值
class Car:
"""一次模拟汽车的简单尝试"""
def __init__(self, make, model, year):
"""初始化汽车的属性."""
self.make = make
self.model = model
self.year = year
# 给属性指定默认值
self.odometer_reading = 0
def get_desriptive_name(self):
"""返回简洁的描述性信息."""
long_name = f"{self.year} {self.make} {self.model} {self.year}"
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息."""
print(f"This car has {self.odometer_reading} miles on it.")
my_new_car = Car('audi', 'a4', 2021)
print(my_new_car.get_desriptive_name())
my_new_car.odometer_reading = 23
my_new_car.read_odometer()
car2.py
# 2.通过方法修改属性的值
class Car:
"""一次模拟汽车的简单尝试"""
def __init__(self, make, model, year):
"""初始化汽车的属性."""
self.make = make
self.model = model
self.year = year
# 给属性指定默认值
self.odometer_reading = 0
def update_odometer(self, mileage):
"""将里程表读数设置为指定的值."""
self.odometer_reading = mileage
def get_desriptive_name(self):
"""返回简洁的描述性信息."""
long_name = f"{self.year} {self.make} {self.model} {self.year}"
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息."""
print(f"This car has {self.odometer_reading} miles on it.")
my_new_car = Car('audi', 'a4', 2021)
print(my_new_car.get_desriptive_name())
my_new_car.update_odometer(23)
my_new_car.read_odometer()
car3.py
# 3.通过方法对属性的值进行递增
class Car:
"""一次模拟汽车的简单尝试"""
def __init__(self, make, model, year):
"""初始化汽车的属性."""
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
"""返回简洁的描述信息."""
long_name = f"{self.year} {self.make} {self.model}"
return long_name.title()
def read_odometer(self):
"""打印一条指出汽车里程的消息."""
print(f"This car has {self.odometer_reading} miles on it.")
def update_odometer(self, mileage):
"""将里程表读数设置为指定的值."""
self.odometer_reading = mileage
def increment_odometer(self, miles):
"""将里程表读数增加指定的量."""
self.odometer_reading += miles
my_used_car = Car('subaru', 'outback', 2015)
print(my_used_car.get_descriptive_name())
my_used_car.update_odometer(23_500)
my_used_car.read_odometer()
my_used_car.increment_odometer(100)
my_used_car.read_odometer()
restaurant1.py
# 练习 9-4 就餐人数
# 在为完成练习 9-1 而编写的程序中，添加一个名为 number_served 的属性，并将其默
# 认值设置为 0。根据这个类创建一个名为 restaurant 的实例；
# 打印有多少人在这家餐馆就餐过，然后修改这个值并再次打印它。
# 添加一个名为 set_number_served() 的方法，它让你能够设置就餐人数。
# 调用这个方法并向它传递一个值，然后再次打印这个值。
# 添加一个名为 increment_number_served() 的方法，它让你能够增加就餐人数。
# 调用这个方法并向它传递一个这样的值：你认为这家餐馆每天可能接待的就餐人数。
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}."
print(f"\n{msg}")
def open_restaurant(self):
"""显示一条消息，指出餐馆正在营业。"""
msg = f"{self.name} is open. Come on in!"
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
restaurant = Restaurant('the mean queen', 'pizza')
restaurant.describe_restaurant()
print(f"\nNumber served: {restaurant.number_served}")
restaurant.number_served = 430
print(f"Number served: {restaurant.number_served}")
restaurant.set_number_served(1257)
print(f"Number served: {restaurant.number_served}")
restaurant.increment_number_served(239)
print(f"Number served: {restaurant.number_served}")
login.py
# 练习 9-5 尝试登录次数
# 在为完成练习 9-3 而编写的 User 类中，添加一个名为 login_attempts 的属性。编写
# 一个名为 increment_login_attempts() 的方法，它将属性 login_attempts 的值加 1。再编
# 写一个名为 reset_login_attempts() 的方法，它将属性 login_attempts 的值重置为 0。
# 根据 User 类创建一个实例，再调用方法 increment_login_attempts() 多次。打印属
# 性 login_attempts 的值，确认它被正确地递增；然后，调用方法 reset_login_attempts() ，
# 并再次打印属性 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()
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"\nWelcome back, {self.username}!")
def increment_login_attempts(self):
"""将属性login_attempts的值加1."""
self.login_attempts += 1
def reset_login_attempts(self):
"""将 login_attempts 重置为 0。"""
self.login_attempts = 0
eric = User('eric', 'matthes', 'e_matthes', 'e_matthes@example.com', 'alaska')
eric.describe_user()
eric.greet_user()
print("\nMaking 3 login attempts...")
eric.increment_login_attempts()
eric.increment_login_attempts()
eric.increment_login_attempts()
print(f" Login attempts: {eric.login_attempts}")
print("Resetting login attempts...")
eric.reset_login_attempts()
print(f" Login attempts: {eric.login_attempts}")
electric_car.py
# 9.3 继承
class Car:
"""一次模拟汽车的简单尝试."""
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
long_name = f"{self.year} {self.make} {self.model}"
return long_name.title()
def read_odometer(self):
print(f"This car has {self.odometer_reading} miles on it.")
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 ElectricCar(Car):
"""电动汽车的独特之处."""
def __init__(self, make, model, year):
"""
初始化父类的属性.
再初始化电动汽车特有的属性.
"""
super().__init__(make, model, year)
self.battery_size = 75
def describe_battery(self):
"""打印一条描述电瓶容量的消息."""
print(f"This car has a {self.battery_size}-kWh battery.")
def fill_gas_tank(self):
"""电动汽车没有油箱."""
print("This car doesn't need a gas tank!")
my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
electric_car1.py
class Car:
"""一次模拟汽车的简单尝试."""
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
long_name = f"{self.year} {self.make} {self.model}"
return long_name.title()
def read_odometer(self):
print(f"This car has {self.odometer_reading} miles on it.")
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):
"""初始化电瓶的属性."""
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:
range = 260
elif self.battery_size == 100:
range = 315
print(f"This car can go about {range} miles on a full charge.")
class ElectricCar(Car):
"""电动汽车的独特之处."""
def __init__(self, make, model, year):
"""
初始化父类的属性.
再初始化电动汽车特有的属性.
"""
super().__init__(make, model, year)
self.battery = Battery()
my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
my_tesla.battery.get_range()
restaurant2.py
# 练习 9-6 冰激凌小店
# 冰激凌小店是一种特殊的餐馆。编写一个名为 IceCreamStand 的类，让它继承你为完
# 成练习 9-1 或 9-4 而编写的 Restaurant 类。
# 这两个版本的 Restaurant 类都可以，挑选你更喜欢的那个即可。
# 添加一个名为 flavors 的属性，用于存储一个由各种口味的冰激凌组成的列表。
# 编写一个显示这些冰激凌的方法。创建一个 IceCreamStand 实例，并调用这个方法。
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}."
print(f"\n{msg}")
def open_restaurant(self):
"""显示一条消息，指出餐馆正在营业。"""
msg = f"{self.name} is open. Come on in!"
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
class IceCreamStand(Restaurant):
"""一个表示冰激凌小店的类."""
def __init__(self, name, cuisine_type='ice_cream'):
"""初始化冰激凌小店."""
super().__init__(name,cuisine_type)
self.flavors = []
def show_flavors(self):
"""显示出售的冰激凌品种."""
print("\nWe have the following flavors available:")
for flavor in self.flavors:
print(f"- {flavor.title()}")
big_one = IceCreamStand('The Big One')
big_one.flavors = ['vanilla', 'chocolate', 'black cherry']
big_one.describe_restaurant()
big_one.show_flavors()
admin.py
# 练习 9-7 管理员
# 管理员是一种特殊的用户。编写一个名为 Admin 的类，让它继承你为完成练习 9-3 或
# 9-5 而编写的 User 类。添加一个名为 privileges 的属性，用于存储一个由字符串（如
# "can add post" 、 "can delete post" 和 "can ban user" 等）组成的列表。
# 编写一个名为show_privileges() 的方法，它显示管理员的权限。
# 创建一个 Admin 实例，并调用这个方法。
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"\nWelcome back, {self.username}!")
def increment_login_attempts(self):
"""将属性login_attempts的值加1."""
self.login_attempts += 1
def reset_login_attempts(self):
"""将 login_attempts 重置为 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)
self.privileges = []
def show_privileges(self):
"""显示当前管理员的权限."""
print("\nPrivileges:")
for privilege in self.privileges:
print(f"- {privilege}")
eric = Admin('eric', 'matthes', 'e_matthes', 'e_matthes@example.com', 'alaska')
eric.describe_user()
eric.privileges = [
'can reset passwords',
'can moderate discussions',
'can suspend accounts',
]
eric.show_privileges()
root.py
# 练习 9-8 权限
# 编写一个名为 Privileges 的类，它只有一个属性 privileges ，其中存储了练习 9-7
# 所说的字符串列表。将方法 show_privileges() 移到这个类中。在 Admin 类中，将一个
# Privileges 实例用作其属性。创建一个 Admin 实例，并使用方法 show_privileges() 来
# 显示其权限。
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"\nWelcome back, {self.username}!")
def increment_login_attempts(self):
"""将属性login_attempts的值加1."""
self.login_attempts += 1
def reset_login_attempts(self):
"""将 login_attempts 重置为 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)
# 将权限集初始化为空.
self.privileges = Privileges()
class Privileges:
"""一个存储管理员权限的类。"""
def __init__(self, privileges=[]):
self.privileges = privileges
def show_privileges(self):
"""显示当前管理员的权限."""
print("\nPrivileges:")
if self.privileges:
for privilege in self.privileges:
print(f"- {privilege}")
else:
print("- This user has no privileges.")
eric = Admin('eric', 'matthes', 'e_matthes', 'e_matthes@example.com', 'alaska')
eric.describe_user()
eric.privileges.show_privileges()
print("\nAdding privileges...")
eric_privileges = [
'can reset passwords',
'can moderate discussions',
'can suspend accounts',
]
eric.privileges.privileges = eric_privileges
eric.privileges.show_privileges()
electric_car2.py
# 练习 9-9 电瓶升级
# 在本节最后一个electric_car.py版本中，给 Battery 类添加一个名为 upgrade_battery()
# 的方法。这个方法检查电瓶容量，如果它不是 85，就将它设置为 85。创建一辆电瓶容量为
# 默认值的电动汽车，调用方法 get_range() ，然后对电瓶进行升级，并再次调用
# get_range() 。你将看到这辆汽车的续航里程增加了。
class Car:
"""一次模拟汽车的简单尝试."""
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0
def get_descriptive_name(self):
long_name = f"{self.year} {self.make} {self.model}"
return long_name.title()
def read_odometer(self):
print(f"This car has {self.odometer_reading} miles on it.")
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):
"""初始化电瓶的属性."""
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:
range = 260
elif self.battery_size == 100:
range = 315
print(f"This car can go about {range} miles on a full charge.")
def upgrade_battery(self):
"""在可能的情况下将电瓶升级。"""
if self.battery_size == 75:
self.battery_size = 100
print("Upgraded the battery to 100 kWh.")
else:
print("The battery is already upgraded.")
class ElectricCar(Car):
"""电动汽车的独特之处."""
def __init__(self, make, model, year):
"""
初始化父类的属性.
再初始化电动汽车特有的属性.
"""
super().__init__(make, model, year)
self.battery = Battery()
print("Make an electric car, and check the battery:")
my_tesla = ElectricCar('tesla', 'model s', 2019)
my_tesla.battery.describe_battery()
print("\nUpgrade the battery, and check it again:")
my_tesla.battery.upgrade_battery()
my_tesla.battery.describe_battery()
print("\nTry upgrading the battery a second time.")
my_tesla.battery.upgrade_battery()
my_tesla.battery.describe_battery()
---------------------------------------------------------------------------------------------------------------------------------
restaurant.py
# 练习 9-10 导入 Restaurant 类
# 将最新的 Restaurant 类存储在一个模块中。在另一个文件中，导入 Restaurant 类、
# 创建一个 Restaurant 实例并调用 Restaurant 的一个方法，以确认 import 语句正确无误。
"""一个表示餐馆的类。"""
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}."
print(f"\n{msg}")
def open_restaurant(self):
"""显示一条消息，指出餐馆正在营业。"""
msg = f"{self.name} is open. Come on in!"
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
my_restaurant.py
from restaurant import Restaurant
channel_club = Restaurant('the channel club', 'steak and seafood')
channel_club.describe_restaurant()
channel_club.open_restaurant()
---------------------------------------------------------------------------------------------------------------------------------
user.py
# 练习 9-11 导入 Admin 类
# 以为完成练习 9-8 而做的工作为基础。将 User 、Privileges 和 Admin 类存储在一个
# 模块中，再创建一个文件，在其中创建一个 Admin 实例并对其调用方法 show_priveleges() ，
# 以确认一切都能正确地运行。
"""一系列模拟用户的类。"""
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"\nWelcome back, {self.username}!")
def increment_login_attempts(self):
"""将属性 login_attempts 的值加 1。"""
self.login_attempts += 1
def reset_login_attempts(self):
"""将 login_attempts 重置为 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)
# 将权限集初始化为空。
self.privileges = Privileges()
class Privileges():
"""存储管理员权限的类。"""
def __init__(self, privileges=[]):
self.privileges = privileges
def show_privileges(self):
print("\nPrivileges:")
if self.privileges:
for privilege in self.privileges:
print(f"- {privilege}")
else:
print("- This user has no privileges.")
my_user.py
from user import Admin
eric = Admin('eric', 'matthes', 'e_matthes', 'e_matthes@example.com', 'alaska')
eric.describe_user()
eric_privileges = [
'can reset passwords',
'can moderate discussions',
'can suspend accounts',
]
eric.privileges.privileges = eric_privileges
print(f"\nThe admin {eric.username} has these privileges: ")
eric.privileges.show_privileges()
---------------------------------------------------------------------------------------------------------------------------------
user.py
# 练习 9-12 多个模块
# 将 User 类存储在一个模块中，并将 Privileges 和 Admin 类存储在另一个模块中。
# 再创建一个文件，在其中创建一个 Admin 实例并对其调用方法 show_privileges() ，以确
# 认一切都依然能够正确地运行。
"""一个模拟用户的类。"""
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"\nWelcome back, {self.username}!")
def increment_login_attempts(self):
"""将属性 login_attempts 的值加 1。"""
self.login_attempts += 1
def reset_login_attempts(self):
"""将 login_attempts 重置为 0。"""
self.login_attempts = 0
admin.py
"""一系列模拟管理员的类。"""
from user import User
class Admin(User):
"""有管理权限的用户。"""
def __init__(self, first_name, last_name, username, email, location):
"""初始化管理员。"""
super().__init__(first_name, last_name, username, email, location)
# 将权限集初始化为空。
self.privileges = Privileges()
class Privileges():
"""存储管理员权限的类。"""
def __init__(self, privileges=[]):
self.privileges = privileges
def show_privileges(self):
print("\nPrivileges:")
if self.privileges:
for privilege in self.privileges:
print(f"- {privilege}")
else:
print("- This user has no privileges.")
my_admin.py
from admin import Admin
eric = Admin('eric', 'matthes', 'e_matthes', 'e_matthes@example.com', 'alaska')
eric.describe_user()
eric_privileges = [
'can reset passwords',
'can moderate discussions',
'can suspend accounts',
]
eric.privileges.privileges = eric_privileges
print(f"\nThe admin {eric.username} has these privileges: ")
eric.privileges.show_privileges()
---------------------------------------------------------------------------------------------------------------------------------
random_1.py
# 练习 9-13 骰子
# 模块 random 包含以各种方式生成随机数的函数，其中的 randint() 随机返回一个位
# 于指定范围内的整数，例如，下面的代码随机地返回一个 1~6 的整数：
from random import randint
num = randint(1, 6)
# 请创建一个 Die 类，它包含一个名为 sides 的属性，该属性的默认值为 6。编写一
# 个名为 roll_die() 的方法，它打印位于 1 和骰子面数之间的随机数。创建一个 6 面的骰子
# 再掷 10 次。
# 创建一个 10 面的骰子和一个 20 面的骰子，再分别掷 10 次。
from random import randint
class Die():
"""一个表示骰子的类。"""
def __init__(self, sides=6):
"""初始化骰子。"""
self.sides = sides
def roll_die(self):
"""返回一个位于 1 和骰子面数之间的随机数。"""
return randint(1, self.sides)
# 创建一个 6 面的骰子，再掷 10 次并显示结果。
d6 = Die()
results = []
for roll_num in range(10):
result = d6.roll_die()
results.append(result)
print("10 rolls of a 6-sided die:")
print(results)
# 创建一个 10 面的骰子，再掷 10 次并显示结果。
d10 = Die(sides=10)
results = []
for roll_num in range(10):
result = d10.roll_die()
results.append(result)
print("\n10 rolls of a 10-sided die:")
print(results)
# 创建一个 20 面的骰子，再掷 10 次并显示结果。
d20 = Die(sides=20)
results = []
for roll_num in range(10):
result = d20.roll_die()
results.append(result)
print("\n10 rolls of a 20-sided die:")
print(results)
ticket_1.py
# 练习 9-14 彩票
# 创建一个列表或元组，其中包含 10 个数和 5 个字母。从这个列表或元组中随机地选
# 择 4 个数或字母，并打印一条消息，指出只要彩票上是这 4 个数或字母，就中大奖了。
from random import choice
possibilities = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a', 'b', 'c', 'd', 'e']
winning_ticket = []
print("Let's see what the winning ticket is...")
# 中奖组合中不能包含重复的数或字母，因此使用了 while 循环。
while len(winning_ticket) < 4:
pulled_item = choice(possibilities)
# 仅当摇出的数字或字母不在组合中时，才将其添加到组合中。
if pulled_item not in winning_ticket:
print(f" We pulled a {pulled_item}!")
winning_ticket.append(pulled_item)
ticket_2.py
# 练习 9-15 彩票分析
# 可使用循环来搞明白中彩票大奖有多难。为此，创建一个名为 my_ticket 的列表或
# 元组，再编写一个循环，不断地随机选择数或字母，直到中大奖为止。请打印一条消息，
# 指出执行循环多少次才中了大奖。
from random import choice
def get_winning_ticket(possibilities):
"""摇出中奖组合。"""
winning_ticket = []
# 中奖组合中不能包含重复的数字或字母，因此使用了 while 循环。
while len(winning_ticket) < 4:
pulled_item = choice(possibilities)
# 仅当摇出的数字或字母不在组合中时，才将其添加到组合中。
if pulled_item not in winning_ticket:
winning_ticket.append(pulled_item)
return winning_ticket
def check_ticket(played_ticket, winning_ticket):
# 检查彩票的每个数字或字母，只要有一个不在中奖组合中，就返回 False。
for element in played_ticket:
if element not in winning_ticket:
return False
# 如果代码执行到这里，就说明中奖了！
return True
def make_random_ticket(possibilities):
"""随机地生成彩票。"""
ticket = []
# 彩票不能包含重复的数字或字母，因此使用了 while 循环。
while len(ticket) < 4:
pulled_item = choice(possibilities)
# 仅当随机生成的数字或字母不在彩票中时，才将其添加到彩票中。
if pulled_item not in ticket:
ticket.append(pulled_item)
return ticket
possibilities = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a', 'b', 'c', 'd', 'e']
winning_ticket = get_winning_ticket(possibilities)
plays = 0
won = False
# 为避免程序执行时间太长，设置最多随机生成多少张彩票。
max_tries = 1_000_000
while not won:
new_ticket = make_random_ticket(possibilities)
won = check_ticket(new_ticket, winning_ticket)
plays += 1
if plays >= max_tries:
break
if won:
print("We have a winning ticket!")
print(f"Your ticket: {new_ticket}")
print(f"Winning ticket: {winning_ticket}")
print(f"It only took {plays} tries to win!")
else:
print(f"Tried {plays} times, without pulling a winner. :(")
print(f"Your ticket: {new_ticket}")
print(f"Winning ticket: {winning_ticket}")
扫一扫
1065
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
