Python Learning Note Day 06

2018-03-26 0 条评论 1.17k 次阅读 0 人点赞

今天是Python学习第六天,主要学习第九章的内容:创建和使用类、使用类和实例、集成、类的导入,Python标准库介绍以及类编码风格。感觉这本书并不是针对完全没基础的,很多概念讲的略。

大纲

相关练习代码

class Dog():
    """创建一个简单的小狗类"""
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def set(self):
        """描述小狗坐下"""
        print(self.name.title() + " is now sitting.")

    def roll_over(self):
        """描述小狗已经打滚了"""
        print(self.name.title()+' has rolled over')

my_dog=Dog('cK',12)
print('The name of my dog is '+my_dog.name.title())
print('My dog '+my_dog.name.title()+' is '+str(my_dog.age)+' now')
my_dog.set()
my_dog.roll_over()

you_dog=Dog('mq',38)
print(you_dog.name.title()+' is your dog')
print('It is a '+str(you_dog.age)+' years old now')
# 9-1 餐馆:创建一个名为Restaurant 的类,其方法__init__()设置两个属性:
# restaurant_name 和cuisine_type。创建一个名为describe_restaurant()的方法和一个
# 名为open_restaurant()的方法,其中前者打印前述两项信息,而后者打印一条消息,
# 指出餐馆正在营业。
# 根据这个类创建一个名为restaurant 的实例,分别打印其两个属性,再调用前述
# 两个方法。
class Restaurant():
    """餐馆类"""
    def __init__(self,restaurant_name,cuisine_type):
        """类的初始化"""
        self.restaurant_name=restaurant_name
        self.cuisine_type=cuisine_type
    def describe_restaurant(self):
        """描述餐馆"""
        print('Our name is '+self.restaurant_name)
        print('We offer you '+self.cuisine_type)

    def open_restaurant(self):
        print('Now we are opening')

my_restaurant=Restaurant('Addlove','Cake')
print('Our name is '+my_restaurant.restaurant_name.title())
print('Our cuisine type is '+my_restaurant.cuisine_type.title())
my_restaurant.describe_restaurant()
my_restaurant.open_restaurant()

# 9-2 三家餐馆:根据你为完成练习9-1 而编写的类创建三个实例,并对每个实例调
# 用方法describe_restaurant()。
your_restaurant=Restaurant('H&N','Noddle')
your_restaurant.describe_restaurant()
our_restaurant=Restaurant('KFC','Chicken')
our_restaurant.describe_restaurant()
restaurant=Restaurant('McDownload','Coder food')
restaurant.describe_restaurant()


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

class User():
    """用户类"""
    # def __init__(self,fname,lname,**des):
    def __init__(self, fname, lname, des):
        self.fname=fname
        self.lname=lname
        self.des=des
        # for k,v in des.items():
        #     self.dess[k]=v

    def describe_user(self):
        print('Name:'+self.fname.title()+' '+self.lname.title())
        print('Other information:\n'+self.des)

        # for k,v in self.dess.items():
        #     print('\t'+k+':'+str(v))

    def greet_user(self):
        print('Hola '+self.fname.title()+' '+self.lname.title()+'!')

me=User('Kiwi','Qing','sex:male')
me.describe_user()
me.greet_user()

you=User('Shine','Feng','sex:female')
you.describe_user()
you.greet_user()

# 使用类和实例
class Car():
    """描述小汽车,包括年份、制造商和型号"""
    def __init__(self,year,maker,model):
        """初始化汽车属性"""
        self.year=year
        self.maker=maker
        self.model=model
        self.odometer_reading=0
        # 给一个路码表初始读数0
    def get_name_des(self):
        """描述汽车"""
        long_name=str(self.year)+' '+self.maker+' '+self.model
        return long_name

    def get_odometer_reading(self):
        """打印路码表读数"""
        print('The odometer reading is '+str(self.odometer_reading)+' now')

    def update_odometer(self,mile):
        """修改路码表读数+防止往回调路码表"""
        # self.odometer_reading=mile
        if mile >= self.odometer_reading:
            self.odometer_reading=mile
        else:
            print("You can't roll back an odometer!")

    def add_odometer(self,mile):
        """将里程表读数增加指定的量"""
        if mile >= 0:
            self.odometer_reading+=mile
        else:
            print("You can't roll back an odometer!")

# 初始化一辆2018年的BMW i3
new_car=Car(2018,'BMW','i3')
print(new_car.get_name_des())
new_car.get_odometer_reading()

# 直接修改路码表的读数(属性)为234,并且打印
new_car.odometer_reading=234
new_car.get_odometer_reading()

# 使用类内部的方法修改路码表的读数(属性)为438
new_car.update_odometer(438)
new_car.get_odometer_reading()

new_car.update_odometer(146)
new_car.get_odometer_reading()

new_car.add_odometer(146)
new_car.get_odometer_reading()

new_car.add_odometer(-234)
new_car.get_odometer_reading()
# 9-4 就餐人数:在为完成练习9-1 而编写的程序中,添加一个名为number_served
# 的属性,并将其默认值设置为0。根据这个类创建一个名为restaurant 的实例;打印有
# 多少人在这家餐馆就餐过,然后修改这个值并再次打印它。
# 添加一个名为set_number_served()的方法,它让你能够设置就餐人数。调用这个
# 方法并向它传递一个值,然后再次打印这个值。
# 添加一个名为increment_number_served()的方法,它让你能够将就餐人数递增。
# 调用这个方法并向它传递一个这样的值:你认为这家餐馆每天可能接待的就餐人数。
class Restaurant():
    """餐馆类"""
    def __init__(self,restaurant_name,cuisine_type):
        """类的初始化"""
        self.restaurant_name=restaurant_name
        self.cuisine_type=cuisine_type
        self.number_served=0
    def describe_restaurant(self):
        """描述餐馆"""
        print('Our name is '+self.restaurant_name)
        print('We offer you '+self.cuisine_type)

    def open_restaurant(self):
        """说明餐馆开张了"""
        print('Now we are opening')

    def set_number_served(self,number):
        """设置餐馆就餐人数"""
        if number > 0:
            self.number_served=number
        else:
            self.number_served = 0

    def increment_number_served(self,inc):
        """让餐馆人数递增"""
        if inc > 0:
            self.number_served+=inc
        else:
            self.number_served+=0

# 实例化这个类
my_restaurant=Restaurant('KFC','food')
# 打印就餐人数
print('There is '+str(my_restaurant.number_served)+' people eaten here.')
# 设置就餐人数并且打印
my_restaurant.set_number_served(23)
print('There is '+str(my_restaurant.number_served)+' people eaten here.')
# 增加就餐人数并打印
my_restaurant.increment_number_served(23)
print('There is '+str(my_restaurant.number_served)+' people eaten here.')



# 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, fname, lname, des):
        """初始化用户类"""
        self.fname=fname
        self.lname=lname
        self.des=des
        self.login_attempts=0

    def describe_user(self):
        """描述用户"""
        print('Name:'+self.fname.title()+' '+self.lname.title())
        print('Other information:\n'+self.des)

    def greet_user(self):
        """给用户打招呼"""
        print('Hola '+self.fname.title()+' '+self.lname.title()+'!')

    def increment_login_attempts(self):
        """将尝试登录次数+1"""
        self.login_attempts+=1

    def reset_login_attempts(self):
        """重置尝试登录次数"""
        status=input('Rest?(yes for continue) ')
        if status=='yes':
            self.login_attempts=0

user=User('KIWI','QING','sex=male')
user.increment_login_attempts()
print(user.fname.title()+' attempt login '+str(user.login_attempts)+' times')
user.increment_login_attempts()
print(user.fname.title()+' attempt login '+str(user.login_attempts)+' times')
user.increment_login_attempts()
print(user.fname.title()+' attempt login '+str(user.login_attempts)+' times')
user.reset_login_attempts()
print(user.fname.title()+' attempt login '+str(user.login_attempts)+' times')


# 一个类继承(inherit)另一个类时,它将自动获得另一个类的所有属性和方法;原有的类称为父类,
# 而新类称为子类。子类继承了其父类的所有属性和方法,同时还可以定义自己的属性和方法
class Car():
    """描述小汽车,包括年份、制造商和型号"""
    def __init__(self,maker,model,year):
        """初始化汽车属性"""
        self.maker=maker
        self.model=model
        self.year = year
        self.odometer_reading=0
        # 给一个路码表初始读数0
    def get_name_des(self):
        """描述汽车"""
        long_name=self.maker+' '+self.model+' '+str(self.year)
        return long_name

    def get_odometer_reading(self):
        """打印路码表读数"""
        print('The odometer reading is '+str(self.odometer_reading)+' now')

    def update_odometer(self,mile):
        """修改路码表读数+防止往回调路码表"""
        # self.odometer_reading=mile
        if mile >= self.odometer_reading:
            self.odometer_reading=mile
        else:
            print("You can't roll back an odometer!")

    def add_odometer(self,mile):
        """将里程表读数增加指定的量"""
        if mile >= 0:
            self.odometer_reading+=mile
        else:
            print("You can't roll back an odometer!")

    def fill_gas_tank(self):
        """为演示重写父类方法而添加"""
        print("OK Now!")

class E_car(Car):
    """电动车"""
    def __init__(self,maker,model,year,size):
        """初始化"""
        super().__init__(maker,model,year)
        # 父类也称为超类(superclass),名称super因此而得名。
        self.battery_size=size

    def show_battery_size(self):
        """显示电动车的电池容量"""
        print('It\'s has '+str(self.battery_size)+' kwh battery.')

    def fill_gas_tank(self):
        """电动汽车没有油箱"""
        print("This car doesn't need a gas tank!")
        # 对于父类的方法,只要它不符合子类模拟的实物的行为,都可对其进行重写。为此,可在子
        # 类中定义一个这样的方法,即它与要重写的父类方法同名。这样,Python将不会考虑这个父类方
        # 法,而只关注你在子类中定义的相应方法。

e_car=E_car('Tesla','modelX',2017,80)
print(e_car.get_name_des())
e_car.show_battery_size()
e_car.fill_gas_tank()


# 将实例用作属性
# 使用代码模拟实物时,你可能会发现自己给类添加的细节越来越多:属性和方法清单以及文
# 件都越来越长。在这种情况下,可能需要将类的一部分作为一个独立的类提取出来。你可以将大
# 型类拆分成多个协同工作的小类。
class Battery():
    """把电池提取出来成为一个小类"""
    def __init__(self):
        self.battery_size=70
        self.battery_life=100

    def show_battery_size(self):
        print('Size of battery is '+str(self.battery_size)+' kwh')

    def show_battery_life(self):
        print('Life of battery is '+str(self.battery_life)+' hours')

class E_car_2(Car):
    """实例作为属性演示"""
    def __init__(self,maker,model,year,size):
        """初始化"""
        super().__init__(maker,model,year)
        # 父类也称为超类(superclass),名称super因此而得名。
        self.batterry=Battery()

ecar=E_car_2('tesla','modelx',2017,80)
ecar.batterry.show_battery_size()
# 9-6 冰淇淋小店:冰淇淋小店是一种特殊的餐馆。编写一个名为IceCreamStand 的
# 类,让它继承你为完成练习9-1 或练习9-4 而编写的Restaurant 类。这两个版本的
# Restaurant 类都可以,挑选你更喜欢的那个即可。添加一个名为flavors 的属性,用于
# 存储一个由各种口味的冰淇淋组成的列表。编写一个显示这些冰淇淋的方法。创建一个
# IceCreamStand 实例,并调用这个方法。

class Restaurant():
    """餐馆类"""
    def __init__(self,restaurant_name,cuisine_type):
        """类的初始化"""
        self.restaurant_name=restaurant_name
        self.cuisine_type=cuisine_type
    def describe_restaurant(self):
        """描述餐馆"""
        print('Our name is '+self.restaurant_name)
        print('We offer you '+self.cuisine_type)

    def open_restaurant(self):
        """餐馆开业通知"""
        print('Now we are opening')

class IceCreamStand(Restaurant):
    """冰淇淋小店"""
    def __init__(self,restaurant_name,cuisine_type,flavors):
        """初始化"""
        super().__init__(restaurant_name,cuisine_type)# 将子类与父类连接
        self.flavors=flavors

    def print_icecream(self):
        """打印所有的冰淇淋"""
        print('we offer :')
        for item in self.flavors:
            print('-'+item)


icecreams=[]# 冰淇淋列表,由用户输入
while True:
    icecream=input('say some icecream (no for break):')
    if icecream=='no':
        break
    else:
        icecreams.append(icecream)

iceCreamStand=IceCreamStand('kiwi','icecream',icecreams)
iceCreamStand.open_restaurant()
iceCreamStand.print_icecream()


# 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, fname, lname, des):
        """初始化"""
        self.fname=fname
        self.lname=lname
        self.des=des

    def describe_user(self):
        """描述用户信息"""
        print('Name:'+self.fname.title()+' '+self.lname.title())
        print('Other information:\n'+self.des)

    def greet_user(self):
        """给用户个性化的问候"""
        print('Hola '+self.fname.title()+' '+self.lname.title()+'!')

class Admin(User):
    """Admin权限类"""
    def __init__(self,fname,lname,des):
        super().__init__(fname,lname,des)
        self.privileges=['can add post','can delete post','can ban user']
        # self.show=Privileges()
    def show_privileges(self):
        """显示管理员权限"""
        self.greet_user()
        print('Your privileges are: ')
        for item in self.privileges:
            print('\t'+item.title())

admin=Admin('Kiwi','qing','sex:male')
admin.show_privileges()

# 9-8 权限:编写一个名为Privileges 的类,它只有一个属性——privileges,其中
# 存储了练习9-7 所说的字符串列表。将方法show_privileges()移到这个类中。在Admin
# 类中,将一个Privileges 实例用作其属性。创建一个Admin 实例,并使用方法
# show_privileges()来显示其权限。
class Admins(User):
    """Admin权限类"""
    def __init__(self,fname,lname,des):
        super().__init__(fname,lname,des)
        self.show=Privileges()

class Privileges():
    """权限列表类"""
    def __init__(self):
        self.privileges = ['can add posts', 'can delete posts', 'can ban user']

    def show_privileges(self):
        """显示管理员权限"""
        # self.greet_user()
        print('Your privileges are: ')
        for item in self.privileges:
            print('\t'+item.title())



admin2=Admins('tina','wang','sex:female')
admin2.show.show_privileges()



# 9-9 电瓶升级:在本节最后一个electric_car.py 版本中,给Battery 类添加一个名为
# upgrade_battery()的方法。这个方法检查电瓶容量,如果它不是85,就将它设置为85。
# 创建一辆电瓶容量为默认值的电动汽车,调用方法upgrade_battery(),然后对电瓶进行升级,
# 并再次调用get_range()。你会看到这辆汽车的续航里程增加了。

class Car():
    """描述小汽车,包括年份、制造商和型号"""
    def __init__(self,maker,model,year):
        """初始化汽车属性"""
        self.maker=maker
        self.model=model
        self.year = year
        self.odometer_reading=0
        # 给一个路码表初始读数0
    def get_name_des(self):
        """描述汽车"""
        long_name=self.maker+' '+self.model+' '+str(self.year)
        return long_name

    def get_odometer_reading(self):
        """打印路码表读数"""
        print('The odometer reading is '+str(self.odometer_reading)+' now')

    def update_odometer(self,mile):
        """修改路码表读数+防止往回调路码表"""
        # self.odometer_reading=mile
        if mile >= self.odometer_reading:
            self.odometer_reading=mile
        else:
            print("You can't roll back an odometer!")

    def add_odometer(self,mile):
        """将里程表读数增加指定的量"""
        if mile >= 0:
            self.odometer_reading+=mile
        else:
            print("You can't roll back an odometer!")

    def fill_gas_tank(self):
        """为演示重写父类方法而添加"""
        print("OK Now!")

class Battery():
    """一次模拟电动汽车电瓶的简单尝试"""
    def __init__(self, battery_size=70):
        """初始化电瓶的属性"""
        self.battery_size = battery_size

    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")

    def get_range(self):
        """打印一条消息,指出电瓶的续航里程"""

        if self.battery_size == 70:
            range = 240
        elif self.battery_size == 85:
            range = 2700
        message = "This car can go approximately " + str(range)
        message += " miles on a full charge."
        print(message)

    def upgrade_battery(self):
        if self.battery_size != 85:
            self.battery_size=85

class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """
        初始化父类的属性,再初始化电动汽车特有的属性
        """
        super().__init__(make, model, year)
        self.battery = Battery()

car=ElectricCar('Tesla','modleX',2016)
car.battery.get_range()
car.battery.upgrade_battery()
car.battery.get_range()
"""一个可用于表示汽车的类"""

class Car():
    """描述小汽车,包括年份、制造商和型号"""
    def __init__(self,maker,model,year):
        """初始化汽车属性"""
        self.maker=maker
        self.model=model
        self.year = year
        self.odometer_reading=0
        # 给一个路码表初始读数0
    def get_name_des(self):
        """描述汽车"""
        long_name=self.maker+' '+self.model+' '+str(self.year)
        return long_name

    def get_odometer_reading(self):
        """打印路码表读数"""
        print('The odometer reading is '+str(self.odometer_reading)+' now')

    def update_odometer(self,mile):
        """修改路码表读数+防止往回调路码表"""
        # self.odometer_reading=mile
        if mile >= self.odometer_reading:
            self.odometer_reading=mile
        else:
            print("You can't roll back an odometer!")

    def add_odometer(self,mile):
        """将里程表读数增加指定的量"""
        if mile >= 0:
            self.odometer_reading+=mile
        else:
            print("You can't roll back an odometer!")

    def fill_gas_tank(self):
        """为演示重写父类方法而添加"""
        print("OK Now!")

class Battery():
    """一次模拟电动汽车电瓶的简单尝试"""
    def __init__(self, battery_size=70):
        """初始化电瓶的属性"""
        self.battery_size = battery_size

    def describe_battery(self):
        """打印一条描述电瓶容量的消息"""
        print("This car has a " + str(self.battery_size) + "-kWh battery.")

    def get_range(self):
        """打印一条消息,指出电瓶的续航里程"""

        if self.battery_size == 70:
            range = 240
        elif self.battery_size == 85:
            range = 2700
        message = "This car can go approximately " + str(range)
        message += " miles on a full charge."
        print(message)

    def upgrade_battery(self):
        if self.battery_size != 85:
            self.battery_size=85

class ElectricCar(Car):
    """电动汽车的独特之处"""
    def __init__(self, make, model, year):
        """
        初始化父类的属性,再初始化电动汽车特有的属性
        """
        super().__init__(make, model, year)
        self.battery = Battery()
from car import Car

my_car=Car('Tesla','model3',2018)
print(my_car.get_name_des())
my_car.odometer_reading=234
my_car.get_odometer_reading()
from car import Car,ElectricCar

normal_car=Car('Benz','CL-300',2018)
e_car=ElectricCar('Tesla','Roadster',2019)
print(normal_car.get_name_des())
print(e_car.get_name_des())
import car

my_car=car.Car('honda','civic',2008)
print(my_car.get_name_des())
# 9-10 导入Restaurant 类:将最新的Restaurant 类存储在一个模块中。在另一个文
# 件中,导入Restaurant 类,创建一个Restaurant 实例,并调用Restaurant 的一个方法,
# 以确认import 语句正确无误。

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



from restaurant import Restaurant
from admin import Admin

my_restaurant=Restaurant('kfc','food')
my_restaurant.describe_restaurant()

admin=Admin('Kiwi','qing','none')
admin.show.show_privileges()
# 9-12 多个模块:将User 类存储在一个模块中,并将Privileges 和Admin 类存储在
# 另一个模块中。再创建一个文件,在其中创建一个Admin 实例,并对其调用方法
# show_privileges(),以确认一切都依然能够正确地运行。
from admin_import import Admin

admin=Admin('Kiwi','kiwi','null')
admin.show.show_privileges()
from collections import OrderedDict

favorite_language=OrderedDict()
favorite_language['kiwi1']='python1'
favorite_language['kiwi2']='python2'
favorite_language['kiwi3']='python3'
favorite_language['kiwi4']='python4'
favorite_language['kiwi5']='python5'
favorite_language['kiwi6']='python6'
favorite_language['kiwi7']='python7'
favorite_language['kiwi8']='python8'
favorite_language['kiwi9']='python9'

for name,lang in favorite_language.items():
    print(name+':'+lang)

# 9-13 使用OrderedDict:在练习6-4 中,你使用了一个标准字典来表示词汇表。请
# 使用OrderedDict 类来重写这个程序,并确认输出的顺序与你在字典中添加键—值对的
# 顺序一致。
from collections import OrderedDict

dict=OrderedDict()

dict['PHP']='超文本预处理器'
dict['range']='用于生成指定范围内的数字的函数'
dict['if']='条件判断语句'
dict['元组']='不可变的列表'
dict['字典']='类似php里的数组'
dict['迭代']='遍历'

for k,v in dict.items():
    print(k+':'+v)
# 9-14 骰子:模块random 包含以各种方式生成随机数的函数,其中的randint()返回
# 一个位于指定范围内的整数,例如,下面的代码返回一个1~6 内的整数:
# from random import randint
# x = randint(1, 6)
# 请创建一个Die 类,它包含一个名为sides 的属性,该属性的默认值为6。编写一
# 个名为roll_die()的方法,它打印位于1 和骰子面数之间的随机数。创建一个6 面的骰
# 子,再掷10 次。
# 创建一个10 面的骰子和一个20 面的骰子,并将它们都掷10 次
from random import randint

class Die():
    """die 类"""
    def __init__(self):
        """初始化"""
        self.sides=6

    def roll_die(self):
        """生成并打印相应数字"""
        num = randint(1, self.sides+1)
        for num in range(1,num):
            print(num)
        print('------')

roll=Die()
roll.sides=6
for i in range(0,10):
    roll.roll_die()
roll.sides=10
for i in range(0,10):
    roll.roll_die()
roll.sides=20
for i in range(0,10):
    roll.roll_die()
class User():
    """用户类"""
    def __init__(self, fname, lname, des):
        """初始化"""
        self.fname=fname
        self.lname=lname
        self.des=des

    def describe_user(self):
        """描述用户信息"""
        print('Name:'+self.fname.title()+' '+self.lname.title())
        print('Other information:\n'+self.des)

    def greet_user(self):
        """给用户个性化的问候"""
        print('Hola '+self.fname.title()+' '+self.lname.title()+'!')

class Admin(User):
    """Admin权限类"""
    def __init__(self,fname,lname,des):
        super().__init__(fname,lname,des)
        self.show=Privileges()

class Privileges():
    """权限列表类"""
    def __init__(self):
        self.privileges = ['can add posts', 'can delete posts', 'can ban user']

    def show_privileges(self):
        """显示管理员权限"""
        # self.greet_user()
        print('Your privileges are: ')
        for item in self.privileges:
            print('\t'+item.title())
from user import User

class Admin(User):
    """Admin权限类"""
    def __init__(self,fname,lname,des):
        super().__init__(fname,lname,des)
        self.show=Privileges()

class Privileges():
    """权限列表类"""
    def __init__(self):
        self.privileges = ['can add posts', 'can delete posts', 'can ban user']

    def show_privileges(self):
        """显示管理员权限"""
        # self.greet_user()
        print('Your privileges are: ')
        for item in self.privileges:
            print('\t'+item.title())
class Restaurant():
    """餐馆类"""
    def __init__(self,restaurant_name,cuisine_type):
        """类的初始化"""
        self.restaurant_name=restaurant_name
        self.cuisine_type=cuisine_type
    def describe_restaurant(self):
        """描述餐馆"""
        print('Our name is '+self.restaurant_name)
        print('We offer you '+self.cuisine_type)

    def open_restaurant(self):
        """餐馆开业通知"""
        print('Now we are opening')
class User():
    """用户类"""
    def __init__(self, fname, lname, des):
        """初始化"""
        self.fname=fname
        self.lname=lname
        self.des=des

    def describe_user(self):
        """描述用户信息"""
        print('Name:'+self.fname.title()+' '+self.lname.title())
        print('Other information:\n'+self.des)

    def greet_user(self):
        """给用户个性化的问候"""
        print('Hola '+self.fname.title()+' '+self.lname.title()+'!')

今天学的东西还需要消化,多练习,类很重要

Kiwi

Valar Morghulis

文章评论(0)