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 = ageself.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_serveddef 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 += 1print('当前就餐人数:%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_nameself.last_name = last_nameself.age = ageself.sex = sexself.phone = phoneself.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 += 1print('当前登录次数为%d'%self.login_attempts)#重置登录次数def reset_login_attempts(self):self.login_attempts = 0print('当前登录次数为%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 = nameself.food = fooddef eat(self):print('%s爱吃%s'%(self.name,self.food))#声明一个子类继承Animalclass 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 = nameself.food = fooddef eat(self):print('%s爱吃%s'%(self.name,self.food))#声明一个子类继承Animalclass 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 Restaurantclass 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 = flavorsdef 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 Userclass 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 = ageself.sex = sexself.__address = address #私有属性#创建普通方法def getName(self):#私有属性在类里面使用可以正常使用print('我的名字叫:%s,我来自%s,我住在%s' %(self.name,person.country,self.__address))#在方法里面使用实例属性#外部要修改私有属性，预留一个接口去访问或者修改私有属性 这是正确的打开方式def getAddress(self,pwd):if pwd == '123':return self.__addresselse: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 = ageself.sex = sexself.__address = address #私有属性#创建普通方法def getName(self):#私有属性在类里面使用可以正常使用print('我的名字叫:%s,我来自%s,我住在%s' %(self.name,person.country,self.__address))#在方法里面使用实例属性#创建一个静态方法@staticmethoddef aa(): #不需要传递实例#静态方法不能访问实例属性#静态方法只能访问类属性print('我的名字叫:%s' % person.country)#类方法@classmethoddef 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消耗血量300solo战斗，一血，消耗血量500补血，加血200'''class hero():#定义属性def __init__(self,name,category,skill,output = 0,score = 0):self.name = nameself.category = categoryself.skill = skillself.output = outputself.score = score#战队场景1：偷红buffdef red_buff(self):self.output -= 300print('%s%s到对面野区偷红buff,消耗血量300')#战斗场景2：solo战斗def solo(self,n = 1):self.output -= 500if self.output < 0:print('%s%s,送了一个人头，血染王者峡谷'%(self.category,self.name))else:if self.score == 0:self.score += nprint('%s%s战斗拿到一血，血量消耗500'%(self.category,self.name))else:self.score += nprint('%s%s solo战斗收割%d个人头，血量消耗500'%(self.category,self.name,n))#场景三：加血def add_xue(self):self.output += 200print('%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 = CardIdself.__pwd = pwdself.__name = nameself.__balance = balance#查看本银行的开户总数@classmethoddef nums(cls):print('当前用户数%d'%(len(cls.__Users)))#查看所有用户的个人信息（包含卡号、密码、用户名、余额）@classmethoddef get_Users(cls):for key,val in cls.__Users.items():print('卡号：%s \n用户名：%s \n密码：%d \n 余额：%d'%(key,val['Username'],val['pwd'],val['Balance']))print()#验证方法@staticmethoddef check_User(CardId,pwd):if (CardId in Bank.__Users) and (pwd == Bank.__Users[CardId]['pwd']):return Trueelse:return False#验证金额@staticmethoddef check_money(money):if isinstance(money,int):return Trueelse: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'] -= moneyprint('当前卡号%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'] += moneyprint('当前卡号%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)