Python之路-面向对象&继承和多态&类属性和实例属性&类方法和静态方法

Posted lyywj170403

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python之路-面向对象&继承和多态&类属性和实例属性&类方法和静态方法相关的知识,希望对你有一定的参考价值。

一、面向对象

  编程方式

  面向过程:根据业务逻辑从上到下写垒代码

  函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可

  面向对象:对函数进行分类和封装,让开发“更快更好更强…”

  什么是面向对象

  面向对象就不像面向过程那样按照功能划分模块了,它所关注的是软件系统有哪些参与者,把这些参与者称为对象,找出这些软件系统的参与者也就是对象之后,分析这些对象有哪些特征、哪些行为,以及对象之间的关系,所以说面向对象的开发核心是对象

  什么是类

  面向对象编程的两个重要的概念:类和对象

  类是对象的类型,具有相同属性和行为事物的统称。类是抽象的,在使用的时候通常会找到这个类的一个具体存在。

  什么是对象

  万物皆对象,对象拥有自己的特征和行为。

  类和对象的关系

  类是对象的类型,对象是类的实例。类是抽象的概念,而对象是一个你能够摸得着,看得到的实体。二者相辅相成,谁也离不开谁。

二、类的定义

  类由三部分组成

  类的名称:类型

  属性:对象的属性

  方法:对象的方法

  类定义:

  class 类名:

    属性列表

    方法列表

  __init__()构造方法和self

  __init__()是一个特殊的方法属于类的专有方法,被称为类的构造函数或初始化方法,方法的前面和后面都有两个下划线。   这是为了避免Python默认方法和普通方法发生名称的冲突。每当创建类的实例化对象的时候,__init__()方法都会默认被运行。作用就是初始化已实例化后的对象。

  在方法定义中,第一个参数self是必不可少的。类的方法和普通的函数的区别就是self,self并不是Python的关键字,你完全可以用其他单词取代他,只是按照惯例和标准的规定,推荐使用self。

‘‘‘
    类定义
    class 类名():
        #类的文档说明
        属性
        方法
‘‘‘
class person():
    ‘‘‘
    这是一个人类
    ‘‘‘

    country = ‘中国‘ #类属性
    #实例属性通过构造方法来声明
    #self不是关键字,代表的是当前对象(类似于this)
    def __init__(self,name,age,sex): #构造方法
        #构造方法不需要调用 在实例化的时候自动调用
        print(‘我是构造方法,在实例化的时候调用‘)
        self.name = name #通过self 创建实例属性 并且赋值
        self.age = age
        self.sex = sex

    #创建普通方法
    def getName(self):
         print(‘我的名字叫:%s,我来自%s‘ %(self.name,person.country))#在方法里面使用实例属性

#实例化对象
people01 = person(‘joe‘,12,‘男‘)
#这个people01 就要具有三个属性,并且可以使用getName方法

  类的属性分类

  类属性

  类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。如果需要用在函数中使用类名.类属性.

  实例属性

  实例变量:定义在方法中的变量,只作用于当前实例的类。

  类的属性的一些方法

  可以使用实例化对象名+.来访问对象的属性

  也可以使用以下函数的方式来访问属性

    getattr(obj, name[, default]) : 访问对象的属性

    hasattr(obj,name) : 检查是否存在一个属性

    setattr(obj,name,value) : 设置一个属性。如果属性不存在,会创建一个新属性

    delattr(obj, name) : 删除属性

  注意:name需要加单引号,obj为实例化对象名称

#访问属性
# print(people01.name)#通过对象名.属性名 访问实例属性(对象属性)
# print(people01.age)
# print(people01.sex)

#通过内置方法访问对象属性
# print(getattr(people01,‘name‘))

# print(hasattr(people01,‘name‘))
#
# print(setattr(people01,‘name‘,‘susan‘))
# print(people01.name)
#
# delattr(people01,‘name‘)
# print(people01.name)

#通过对象调用实例方法
# people01.getName()

  内置类属性

  Python内置类属性

  __dict__ : 类的属性(包含一个字典,由类的属性名:值组成) 实例化类名.__dict__

  __doc__ :类的文档字符串 (类名.)实例化类名.__doc__

  __name__: 类名,实现方式 类名.__name__

  __bases__ : 类的所有父类构成元素(包含了以个由所有父类组成的元组)  

‘‘‘
    内置类属性
‘‘‘
# print(people01.__dict__) #会将实例对象的属性和值通过字典的形式返回
#{‘age‘: 12, ‘name‘: ‘joe‘, ‘sex‘: ‘男‘}

# print(people01.__doc__) #查看类的文档说明
#    这是一个人类

# print(people01.__name__) #返回类名

# print(person.__bases__) #类的组成 (<class ‘object‘>,)

people02 = person(‘susan‘,32,‘女‘)
people02.getName()

  小结:

  类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

  类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

  数据成员:类变量或者实例变量(方法中的变量)用于处理类及其实例对象的相关的数据。

  方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。

  实例变量:定义在方法中的变量,只作用于当前实例的类。

  实例化:创建一个类的实例,类的具体对象。

  方法:类中定义的函数。

  对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

  __name__

  __name__:如果是放在Modules模块中,就表示是模块的名字; 如果是放在Classs类中,就表示类的名字;

  __main__:模块,xxx.py文件本身.被直接执行时,对应的模块名就是__main__了 可以在if __name__ == “__main__”: 中添加你自己想要的,用于测试模块,演示模块用法等代码。 作为模块,被别的Python程序导入(import)时,模块名就是本身文件名xxx了。

  一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

定义name.py文件

def a():
    print(‘我是a方法‘)

if __name__ == ‘__main__‘:
    a()

print(__name__) #__main__

输出:

  我是a方法
  __main__

定义name2.py文件

‘‘‘
引入name.py文件
输出 name
‘‘‘
import name

输出:name

练习:

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

2.三家餐馆:根据你为完成练习1而编写的类创建三个实例,
并对每个实例调用方法 describe_restaurant()。

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


‘‘‘
class Restaurant():
    ‘‘‘
        餐馆类
    ‘‘‘
    def __init__(self,restaurant_name,cuisine_type,number_served = 0):
        #声明两个实例属性
        self.restaurant_name = restaurant_name #餐馆名字
        self.cuisine_type = cuisine_type       #菜系
        self.number_served = number_served

    def describe_restaurant(self):
        print(‘名称:%s,菜系:%s‘%(self.restaurant_name,self.cuisine_type))


    def open_restaurant(self):
        print(‘欢迎光临%s,正在营业‘%self.restaurant_name)


    #设置就餐人数
    def set_number_served(self,n):
        self.number_served = n  #通过传递的参数给实例属性赋值
        print(‘当前就餐人数:%d‘%self.number_served)

    #递增增加就餐人数
    def increment_number_served(self,n):
        for i in range(1,n+1):
            self.number_served += 1
            print(‘当前就餐人数:%d‘%self.number_served)

if __name__ == ‘__main__‘:
    #练习1.
    # restaurant = Restaurant(‘金拱门‘,‘西餐‘)
    #打印两个属性
    # print(restaurant.restaurant_name)
    # print(restaurant.cuisine_type)

    #调用两个方法
    # restaurant.describe_restaurant()
    # restaurant.open_restaurant()

    # 练习2. 创建三个实例
    # chuancai = Restaurant(‘我家酸菜鱼‘, ‘川菜‘)
    # chuancai.describe_restaurant()
    #
    # xiangcai = Restaurant(‘沪上湘城‘, ‘湘菜‘)
    # xiangcai.describe_restaurant()
    #
    # loulan = Restaurant(‘楼兰‘, ‘新疆菜‘)
    # loulan.describe_restaurant()

    #4.
    loulan = Restaurant(‘楼兰‘, ‘新疆菜‘)
    # print(‘就餐人数:%d‘%loulan.number_served)
    # loulan.number_served = 10  #通过对象名.属性名设置 属性值
    # print(‘就餐人数:%d‘ % loulan.number_served)
    loulan.set_number_served(40)
    loulan.increment_number_served(10)

  

‘‘‘
    创建一个名为User的类,其中包含属性first_name和last_name ,
    还有用户简介通常会存储的其他属性。在User中定义一个名为describe_user()的方法
    他打印用户信息摘要;
    再定义一个名为greet_user()方法,他向用户发出个性化的问候。
    创建多个表示不同用户的实例,并对每个实例都调用上述两个方法
‘‘‘
‘‘‘
  2.尝试登录次数:在为完成练习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,age,sex,phone,login_attempts = 0):
        self.first_name = first_name
        self.last_name = last_name
        self.age = age
        self.sex = sex
        self.phone = phone
        self.login_attempts = login_attempts

    #查看用户信息
    def describe_user(self):
        print(‘大家好我叫%s %s,我今年%d岁,我的电话是%s‘ %(self.first_name,self.last_name,self.age,self.phone))

    #个性化问候
    def greet_user(self):
        print(‘尊敬的%s,恭喜你中了五百万‘%self.first_name)

    #增加登录次数
    def increment_login_attempts(self):
        self.login_attempts += 1
        print(‘当前登录次数为%d‘%self.login_attempts)

    #重置登录次数
    def reset_login_attempts(self):
        self.login_attempts = 0
        print(‘当前登录次数为%d‘ % self.login_attempts)

if __name__ == ‘__main__‘:

    joe = User(‘joe‘,‘black‘,19,‘男‘,‘15768476789‘)
    joe.describe_user()
    joe.greet_user()

    joe.increment_login_attempts()
    joe.increment_login_attempts()
    joe.increment_login_attempts()

    joe.reset_login_attempts()

三、继承和多态

  继承:

  在现实生活中,继承一般指的是子女继承父辈的财产。那么在程序中,继承描述的是事物之间的所属关系,例如猫和狗都属于动物,程序中可以描述为猫和狗都继承自动物。同理,波斯猫和家猫都继承自猫。而斑点狗,泰迪都继承之狗。程序中当我们定义一个class的时候,可以从某个现有的class继承,新的class称之为子类(Subclass),而被继承的class称之为基类、父类或超类。子类继承了其父类的所有属性和方法,同时还可以定义自己的属性和方法。

  子类的__init__()

class Animal():
    def __init__(self,name,food):
        self.name = name
        self.food = food

    def eat(self):
        print(‘%s爱吃%s‘%(self.name,self.food))

#声明一个子类继承Animal
class Dog(Animal):
    def __init__(self,name,food,drink):
        #加载父类的构造方法
        super(Dog,self).__init__(name,food)
        # Animal.__init__(name,food) #报错
        self.drink = drink #子类自己的属性

    #子类自己的方法
    def drinks(self):
        print(‘%s爱喝%s‘%(self.name,self.drink))

class Cat(Animal):
    def __init__(self,name,food,drink):
        #加载父类的构造方法
        super(Cat,self).__init__(name,food)
        # Animal.__init__(name,food) #报错
        self.drink = drink #子类自己的属性

    #子类自己的方法
    def drinks(self):
        print(‘%s爱喝%s‘%(self.name,self.drink))

    #重写父类的eat方法
    def eat(self):
        print(‘%s特别爱吃%s‘% (self.name, self.food))


dog1 = Dog(‘金毛‘,‘骨头‘,‘可乐‘)
dog1.eat()
dog1.drinks()

dog1 = Cat(‘波斯猫‘,‘秋刀鱼‘,‘雪碧‘)
dog1.eat()
dog1.drinks()

  多继承

  Python中多继承的语法格式如下:

  class DerivedClassName(Base1, Base2, Base3):

  <statement-1>

  .

  .

  .

  <statement-N>

  注意:圆括号中父类的顺序,如果继承的父类中有相同的方法名,而在子类中使用时未指定,python将从左至右查找父类中是否包含方法。

 

class A():
    def a(self):
        print(‘我是A里面的a方法‘)

class B():
    def b(self):
        print(‘我是B里面的b方法‘)

    def a(self):
        print(‘我是B里面的a方法‘)


class C():
    def c(self):
        print(‘我是C里面的C方法‘)

class D(A,B,C):
    def d(self):
        print(‘我是D里面的d方法‘)

dd = D()
dd.d() #调用自己的方法
dd.c()
dd.a()

  重新

class Animal():
    def __init__(self,name,food):
        self.name = name
        self.food = food

    def eat(self):
        print(‘%s爱吃%s‘%(self.name,self.food))

#声明一个子类继承Animal
class Dog(Animal):
    def __init__(self,name,food,drink):
        #加载父类的构造方法
        super(Dog,self).__init__(name,food)
        # Animal.__init__(name,food) #报错
        self.drink = drink #子类自己的属性

    #子类自己的方法
    def drinks(self):
        print(‘%s爱喝%s‘%(self.name,self.drink))

class Cat(Animal):
    def __init__(self,name,food,drink):
        #加载父类的构造方法
        super(Cat,self).__init__(name,food)
        # Animal.__init__(name,food) #报错
        self.drink = drink #子类自己的属性

    #子类自己的方法
    def drinks(self):
        print(‘%s爱喝%s‘%(self.name,self.drink))

    #重写父类的eat方法
    def eat(self):
        print(‘%s特别爱吃%s‘% (self.name, self.food))


dog1 = Dog(‘金毛‘,‘骨头‘,‘可乐‘)
dog1.eat()
dog1.drinks()

dog1 = Cat(‘波斯猫‘,‘秋刀鱼‘,‘雪碧‘)
dog1.eat()
dog1.drinks()

  练习

 

‘‘‘
冰淇淋小店:冰其淋小店是一种特殊的餐馆。
编写一个名为IceCreamStand的类,让它继承你为完成练习1或练习4而编写的Restaurant类。
这两个版本Restaurant类都可以,挑选你更喜欢的那个即可。
添加一个名为flavors的属性,用于存储一个由各种口味的冰淇淋组成的列表。
编写一个显示这些冰淇淋的方法。创建一IceCreamStand实例,并调用这个方法。
‘‘‘
from Restaurant import Restaurant

class IceCreamStand(Restaurant):
    #加载父类方法  并且增加新的属性
    def __init__(self,restaurant_name,cuisine_type,flavors,number_served = 0):
        super(IceCreamStand,self).__init__(restaurant_name,cuisine_type,number_served = 0)
        self.flavors = flavors

    def get_info(self):
        print(‘这家冰激凌小店的名字是%s,他的特色是%s,冰激凌的口味是%s‘%(self.restaurant_name,self.cuisine_type,self.flavors))

queen = IceCreamStand(‘冰雪换后‘,‘手工制作冰激凌‘,‘草莓味‘,‘巧克力味‘,‘奶油味‘)
queen.get_info()

 

  

 

‘‘‘
    管理员:管理员是一种特殊的用户。
    编写一个名为Admin的类,让它继承你为完成练习3或练习5而编写的User类。
    添加一个名为privileges的属性,用于存储一个由字符串(如“can add post”、
    “can delete post”、“can ban user”等)组成的列表。
    编写一个名为show_privileges()的方法,它显示管理员的权限,创建一个Admin实例,
    并调用这个方法。

‘‘‘

from User import User

class Admin(User):
    privileges = [‘can add post‘,‘can delete post‘,‘can ban user‘]
    def __init__(self,first_name,last_name,age,sex,phone,login_attempts = 0):
        super(Admin,self).__init__(first_name,last_name,age,sex,phone,login_attempts = 0)

    def show_privileges(self):
        print(‘管理员:%s%s具有以下权限。‘%(self.first_name,self.last_name))
        for i in Admin.privileges:
            print(i)

admin1 = Admin(‘susan‘,18,‘女‘,‘1243778494‘)
admin1.show_privileges()

  四、类属性和实例属性

  属性

  尽量把需要用户传入的属性作为实例属性,而把同类都一样的属性作为类属性。实例属性在每创造一个类是都会初始化一遍,不同的实例的实例属性可能不同,不同实例的类属性都相同。

  1:实例属性:     

  在__init__(self,...)中初始化     

  内部调用时都需要加上self.     

  外部调用时用“对象名.属性名”调用

  2:类属性:     

  在__init__()里初始化     

  在内部用classname.类属性名调用     

  外部既可以用classname.类属性名又可以用instancename.类属性名来调用

  3:私有属性:     

  双下划线__开头:外部不可通过“对象名.属性名”来访问或者更改实际将其转化为了“_类名__属性名”

  __foo__: 定义的是特殊方法,类似 __init__() 之类的。

  _foo: 以单下划线开头的表示的是 protected 类型的变量,即保护类型只能允许其本身与子类进行访问(创建的实例可以访问),不能用于 from module import *

  __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

class person():
    ‘‘‘
    这是一个人类
    ‘‘‘

    country = ‘中国‘ #类属性
    #实例属性通过构造方法来声明
    #self不是关键字,代表的是当前对象(类似于this)
    def __init__(self,name,age,sex,address): #构造方法
        #构造方法不需要调用 在实例化的时候自动调用
        print(‘我是构造方法,在实例化的时候调用‘)
        self.name = name #通过self 创建实例属性 并且赋值
        self.age = age
        self.sex = sex
        self.__address = address #私有属性

    #创建普通方法
    def getName(self):
        #私有属性在类里面使用可以正常使用
         print(‘我的名字叫:%s,我来自%s,我住在%s‘ %(self.name,person.country,self.__address))#在方法里面使用实例属性

    #外部要修改私有属性,预留一个接口去访问或者修改私有属性  这是正确的打开方式
    def getAddress(self,pwd):
        if pwd == ‘123‘:
            return self.__address
        else:
            return ‘权限不够‘

#实例化对象
people01 = person(‘joe‘,12,‘男‘,‘上海‘)
people01.getName()
#这个people01 就要具有三个属性,并且可以使用getName方法

#通过对象名.属性名访问私有属性
# print(people01.__address) #外部无法使用这种方式访问

#推荐使用
print(people01.getAddress(‘123‘))

#强制访问 不要使用
print(people01._person__address)

people01.__address = ‘北京‘ #看上去好像改了  其实没有  你给当前对象声明了一个新属性
print(people01.__address)

print(people01.getAddress(‘123‘))

五、访问限制

  私有类属性

  私有对象属性 为了保护属性不被随意修改和访问,可以将属性定义为私有属性

  如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线__,

  在Python中,实例变量名如果以__开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问. 

  注意:

  1.设置为私有属性不能直接通过对象访问属性,但是可以通过“实例化对象名._类名__属性名”直接进行访问。但是不建议这样操作.不同版本的Python解释器可能会把“__属性名”改成不同的变量名。总的来说就是,Python本身没有任何机制阻止你干坏事,一切全靠自觉。

  2.通过“对象名.__属性名”直接修改私有属性。 表面上看好像修改了其实并没有,因为Python解释器已经将对象内部的属性名解释成“_类名__属性名”。如果在外部修改相当于另外声明一个属性。类属性可以直接修改通过类名._类名__属性名=(可通过类方法定义) 

六、类方法和静态方法

  类方法与静态方法

  1:普通方法:     

    def fun_name(self,...):       

    pass     

    外部用实例调用

  2:静态方法:通过装饰器 @staticmethod 装饰       

    不能访问实例属性

    参数不能传入self       

    与类相关但是不依赖类与实例的方法

  3:类方法:@classmethod      

    不能访问实例属性 参数必须传入cls      

    必须传入cls参数(即代表了此类对象-----区别------self代表实例对象),并且用此来调用类属性:cls.类属性名

  静态方法与类方法都可以通过类或者实例来调用。其两个的特点都是不能够调用实例属性

  静态方法不需要接收参数,使用类名.类属性

class person():
    ‘‘‘
    这是一个人类
    ‘‘‘

    country = ‘中国‘ #类属性
    #实例属性通过构造方法来声明
    #self不是关键字,代表的是当前对象(类似于this)
    def __init__(self,name,age,sex,address): #构造方法
        #构造方法不需要调用 在实例化的时候自动调用
        print(‘我是构造方法,在实例化的时候调用‘)
        self.name = name #通过self 创建实例属性 并且赋值
        self.age = age
        self.sex = sex
        self.__address = address #私有属性

    #创建普通方法
    def getName(self):
        #私有属性在类里面使用可以正常使用
         print(‘我的名字叫:%s,我来自%s,我住在%s‘ %(self.name,person.country,self.__address))#在方法里面使用实例属性

    #创建一个静态方法
    @staticmethod
    def aa(): #不需要传递实例
        #静态方法不能访问实例属性
        #静态方法只能访问类属性
        print(‘我的名字叫:%s‘ % person.country)

    #类方法
    @classmethod
    def bb(cls):   #class 也不是关键字
        # 类方法不能访问实例属性
        print(‘我的名字叫:%s‘ % cls.country) #使用cls.类属性
        print(‘我的名字叫:%s‘ % person.country)

#实例化对象
people01 = person(‘joe‘,12,‘男‘,‘上海‘)
#通过对象来调用静态方法
people01.aa()
#通过对象来调用类方法
people01.bb()

#静态方法和类方法的调用  推荐使用类名的方式去调用
#通过类名来调用静态方法
person.aa()
#通过类名来调用类方法
person.bb()

  

‘‘‘
练习:亡者农药小游戏

1、创建三个游戏人物,分别是:
属性:
    名字:name,定位:category,血量:Output技能:Skill
英雄:
    铠,战士,血量:1000 技能:极刃风暴
    王昭君,法师 ,血量:1000 技能:凛冬将至
    阿轲,刺客,血量:1000 技能:瞬华

2、游戏场景,分别:

偷红buff,释放技能偷到红buff消耗血量300
solo战斗,一血,消耗血量500
补血,加血200

‘‘‘
class hero():

    #定义属性
    def __init__(self,name,category,skill,output = 0,score = 0):
        self.name = name
        self.category = category
        self.skill = skill
        self.output = output
        self.score = score

    #战队场景1:偷红buff
    def red_buff(self):
        self.output -= 300
        print(‘%s%s到对面野区偷红buff,消耗血量300‘)

    #战斗场景2:solo战斗
    def solo(self,n = 1):
        self.output -= 500
        if self.output < 0:
            print(‘%s%s,送了一个人头,血染王者峡谷‘%(self.category,self.name))
        else:
            if self.score == 0:
                self.score += n
                print(‘%s%s战斗拿到一血,血量消耗500‘%(self.category,self.name))
            else:
                self.score += n
                print(‘%s%s solo战斗收割%d个人头,血量消耗500‘%(self.category,self.name,n))
    #场景三:加血
    def add_xue(self):
        self.output += 200
        print(‘%s%s被辅助及时奶了一口,加血200‘%(self.category,self.name))
    #查看英雄信息
    def getInfo(self):
        if self.output <= 0:
            print(‘%s%s 正在复活。拿到%d个人头‘%(self.category,self.name,self.score))
        else:
            print(‘%s%s超神了!血量还有%d,拿到%d个人头‘%(self.category,self.name,self.output,self.score))

#实例化对象
kai = hero(‘铠‘,‘战士‘,‘极刃风暴‘)

#操作
kai.red_buff()
kai.getInfo()
kai.solo()
kai.getInfo()
kai.add_xue()
kai.getInfo()
kai.solo()
kai.getInfo()

  

‘‘‘
模拟一个简单的银行进行业务办理的类

类:
    创建一个银行类
属性:
    一个属于银行的类属性
        用来存储所用银行的开户信息,包含卡号、密码、用户名、余额
        (外界不能随意访问和修改。开户时要进行卡号验证,查看卡号是否已经存在)

    每个对象拥有
        卡号、密码、用户名、余额
        (外界不能随意访问和更改)

方法:
    银行类拥有
        查看本银行的开户总数
        查看所有用户的个人信息(包含卡号、密码、用户名、余额)
    每个对象拥有
        实例化对象的时候传入相关参数
            初始化对象及类属性
        取钱(需要卡号和密码验证)
            通过验证卡号和密码对个人的余额进行操作,如果取钱大于余额,返回余额不足
        存钱(需要卡号和密码验证)
            通过验证卡号和密码对个人的余额进行操作,返回操作成功
        查看个人详细信息(需要卡号密码验证)
            返回个人的卡号,用户名,余额信息
‘‘‘

class Bank():
    #一个属于银行的类属性
    __Users = {}

    #每个对象拥有 卡号 密码 用户名 余额
    def __init__(self,CardId,pwd,name,balance):
        if CardId not in Bank.__Users:
            Bank.__Users[CardId] = {‘pwd‘:pwd,‘Username‘:name,‘Balance‘:balance}
            self.__CardId = CardId
            self.__pwd = pwd
            self.__name = name
            self.__balance = balance

    #查看本银行的开户总数
    @classmethod
    def nums(cls):
         print(‘当前用户数%d‘%(len(cls.__Users)))

    #查看所有用户的个人信息(包含卡号、密码、用户名、余额)
    @classmethod
    def get_Users(cls):
        for key,val in cls.__Users.items():
            print(‘卡号:%s 
用户名:%s 
密码:%d 
 余额:%d‘%(key,val[‘Username‘],val[‘pwd‘],val[‘Balance‘]))
            print()

     #验证方法
    @staticmethod
    def check_User(CardId,pwd):
        if (CardId in Bank.__Users) and (pwd == Bank.__Users[CardId][‘pwd‘]):
            return True
        else:
            return False

    #验证金额
    @staticmethod
    def check_money(money):
        if isinstance(money,int):
            return True
        else:
            return False

    #取钱(需要卡号和密码验证)
    def q_money(self,CardId,pwd,money):
        if Bank.check_User(CardId,pwd):
            #开始取钱
            if Bank.check_money(money):
                if Bank.__Users[CardId][‘Balance‘] >= money:
                   Bank.__Users[CardId][‘Balance‘] -= money
                   print(‘当前卡号%s,当前取款金额%d,当前余额%d‘%(CardId,money,Bank.__Users[CardId][‘Balance‘]))
                else:
                    print(‘余额不足‘)
            else:
                print(‘您输入的金额有误‘)
        else:
            print(‘卡号或者密码有误‘)

    #存钱(需要卡号和密码验证)
    def c_money(self,CardId,pwd,money):
        if Bank.check_User(CardId,pwd):
            #开始取钱
            if Bank.check_money(money):
                Bank.__Users[CardId][‘Balance‘] += money
                print(‘当前卡号%s,当前存款金额%d,当前余额%d‘%(CardId,money,Bank.__Users[CardId][‘Balance‘]))
            else:
                print(‘您输入的金额有误‘)
        else:
            print(‘卡号或者密码有误‘)

    #查看个人详细信息
    def getInfo(self,CardId,pwd):
        if Bank.check_User(CardId, pwd):
            print(‘当前卡号%s,当前用户名%s,当前余额%d‘ %(CardId, Bank.__Users[CardId][‘Username‘], Bank.__Users[CardId][‘Balance‘]))
        else:
            print(‘卡号或者密码有误‘)

joe = Bank(‘1001‘,111111,‘joe‘,100)
joe2 = Bank(‘1001‘,111111,‘joe‘,100)
Bank.nums()
print(‘_‘*50)
Bank.get_Users()
print(‘_‘*50)
joe.c_money(‘1001‘,111111,500)
print(‘_‘*50)
joe.q_money(‘1001‘,111111,300)
print(‘_‘*50)
joe.getInfo(‘1001‘,111111)

  

 


以上是关于Python之路-面向对象&继承和多态&类属性和实例属性&类方法和静态方法的主要内容,如果未能解决你的问题,请参考以下文章

python之路 -- 面向对象基础2

Python全栈开发——面向对象的三大特性(继承 & 多态 &封装)

python开发面向对象基础:接口类&抽象类&多态&多继承

面向对象编程思想 以及 封装,继承,多态 和 python中实例方法,类方法,静态方法 以及 装饰器

Python之路:面向对象(进阶)

Python学习之路——Day8(面向对象进阶)