python类变量继承_python 类的成员及继承

1. @staticmethod 静态方法

静态方法不能访问实例变量和类变量，除了身处类里面，所以只能通过类调用以外，它其实和类没有什么关系。如果想要用它访问实例变量或类变量，需要把实例和类传递给函数。

classPeople(object):def __init__(self,name):

self.name=name

@staticmethod#静态方法，不能访问实例变量和类变量，和类实际没啥关系，除了把它放到类里面，然后通过类来调用它。

def getname(self,sex): #虽然有self，但是需要调用的时候手动传入实例。

print('%s is a %s' %(self.name,sex))

people= People('LaoWang')

people.getname(people,'man') #想要访问实例变量，只能手动传递实例进入！如果写成：people.getname('man')会报错。

2. classmethod 类方法

类方法只能访问类变量，不能访问实例变量。想要访问实例变量，需要手动传递实例给函数。

classPeople(object):

age= 30

def __init__(self,name):

self.name=name

@staticmethod#静态方法，不能访问实例变量和类变量，和类实际没啥关系，除了把它放到类里面，然后通过类来调用它。

def getname(self,sex): #虽然有self，但是需要调用的时候手动传入实例。

print('%s is a %s' %(self.name,sex))

@classmethod#类方法，只能访问类变量,不能访问实例变量，如果要访问实例变量，需要手动传入实例。

defgetage(cls):print('age is %s' %cls.age)

people= People('LaoWang')

people.getname(people,'man') #想要访问实例变量，只能手动传递实例进入！如果写成：people.getname('man')会报错。

people.getage()

3. @property 属性方法

属性方法，把一个方法变成属性，调用时不加括号即可完成调用，就像调用一个属性一样。

classPeople(object):

age= 30

def __init__(self,name):

self.name=name

@staticmethod#静态方法，不能访问实例变量和类变量，和类实际没啥关系，除了把它放到类里面，然后通过类来调用它。

def getname(self,sex): #虽然有self，但是需要调用的时候手动传入实例。

print('%s is a %s' %(self.name,sex))

@classmethod#类方法，只能访问类变量,不能访问实例变量，如果要访问实例变量，需要手动传入实例。

defgetage(cls):print('age is %s' %cls.age)

@property#属性方法，把一个方法变成属性。调用时不用加括号。

defeat(self):print('%s is eating.' %self.name)

people= People('LaoWang')

people.getname(people,'man') #调用静态方法。想要访问实例变量，只能手动传递实例进入！如果写成：people.getname('man')会报错。

people.getage() #调用类方法。

people.eat #调用属性方法。不加括号

属性方法的修改和删除：

classPeople(object):

age= 30

def __init__(self,name):

self.name=name

@staticmethod#静态方法，不能访问实例变量和类变量，和类实际没啥关系，除了把它放到类里面，然后通过类来调用它。

def getname(self,sex): #虽然有self，但是需要调用的时候手动传入实例。

print('%s is a %s' %(self.name,sex))

@classmethod#类方法，只能访问类变量,不能访问实例变量，如果要访问实例变量，需要手动传入实例。

defgetage(cls):print('age is %s' %cls.age)

@property#属性方法，把一个方法变成属性。调用时不用加括号。

defeat(self):print('%s is eating.' %self.name)

@eat.setter#属性的修改

defeat(self,food):print('This is eat setter: %s' %food)

@eat.deleter#属性的删除

defeat(self):print('eat has been deleted.')

people= People('LaoWang')

people.getname(people,'man') #调用静态方法。想要访问实例变量，只能手动传递实例进入！如果写成：people.getname('man')会报错。

people.getage() #调用类方法。

people.eat#调用属性方法。不加括号

people.eat = 'suger' #调用eat.setter

del people.eat #调用eat.deleter

4. 其他类成员：

classT(object):'''this is doc'''

def __new__(cls, *args, **kwargs):print('this is new func')return super().__new__(cls)def __init__(self,name):

self.name=namedefgetname(self):print(self.name)def __getitem__(self, item):print('getitem:',item)def __setitem__(self, key, value):print('setitem:',key,value)def __delitem__(self, key):print('delitem:',key)def __call__(self, *args, **kwargs):print('this is call, you should add bracket')def __str__(self):return 'you are print obj'

def __del__(self):print('When obj is been destroyed,this func would execution automatically.')

t=T('Wang') ## T是一个类，它是由type创建的(type是所有类的类，它可以创建类对象，然后类对象可以创建实例)。而type里面定义了一个__call__函数，所以才能使用 'T()'

print(T.__doc__) #打印类的文档注释

print(t.__module__)#打印对象所处的模块名

print(t.__class__) #打印对象的类

print(t.__dict__) #打印对象的变量

print(T.__dict__) #打印类的变量

print(t) #打印对象，打印__str__方法的返回值(没有str方法，则打印对象的内存地址)

t() #对象直接加括号，调用__call__方法

val = t['1'] #__getitem__

t['1'] = 1 #__setitem__

del t['1'] #__delitem__

del t #__del__

5. 类的类

python中万物皆对象。类其实也是一个对象。在python中类可以创建实例，那么类本身又是谁创建的呢，答案是type

num = type(1)

string= type('my')

dictionary= type({1:'1'})print(num,string,dictionary)#

print(num.__class__,string.__class__,dictionary.__class__)#

从上面的例子可以看出，数字、字符串、字典，它们的类型都是由不同的类创建的。而这些类再往上追溯，它们又都是由 type 类创建的。所以说，type就是所有类的类。

通过type创建类：

#class A(object):#a = 5#def abc(self,name):#self.name = name#def getname(self):#print(self.name)

#使用type创建一个类，和上面的类一模一样

definit(self, name):

self.name=namedefgetname(self):print(self.name)

A= type('A',(object,),{'a':5,'__init__':init,'getname':getname})#type第一个参数：类名#type第二个参数：当前类的基类#type第三个参数：类的成员

aa= A('Wang')

aa.getname()print(aa.a)

6. 元类 metaclass

元类就是用来造类的类，type也是一个元类，只不过它是python内建的元类，是所有类的类。我们也可以自己创建一个元类，用来动态的创建类。

class MyType(type): #创建元类，父类需要传入type

def __new__(cls,name,bases,attrs): #第一步，元类的操作都在__new__中完成，第一个参数是将创建的类。name,将要创建的类。bases，将要创建的类的父类。attrs，类的方法和属性的字典

print("Mytype __new__",name,bases,attrs,sep='/')print('cls',cls)return type.__new__(cls, name,bases,attrs) #如果返回一个已经存在的实例或者不返回任何值，则init不会被调用

def __init__(self,*args,**kwargs): #第二步，init

print("Mytype __init__",*args,**kwargs)def __call__(self, *args, **kwargs): #第三步，创建的类实例化时才执行。类实例化时需要加括号对吧，这个括号就是__call__方法赋予的。

print("Mytype __call__", *args, **kwargs)

obj= self.__new__(self) #Foo类的new方法

print("obj....",obj,*args, **kwargs)print(self)

self.__init__(obj,*args, **kwargs)returnobjprint('-------------------------------------')class Foo(object,metaclass=MyType):def __new__(cls, *args, **kwargs):print("Foo __new__",cls, *args, **kwargs)return object.__new__(cls)def __init__(self,name):

self.name=nameprint("Foo __init__")defgetname(self):print('name is',self.name)

f= Foo("Wang")print("f",f)print("fname",f.name)

例子：使用元类来创建类，并动态的给所创建的所有类添加一个属性：类名 = 'Hello, '+类名

class Meta(type): #元类

def __new__(cls, name,bases,attrs): #name，类名。attrs，类的所有方法属性的字典。

attrs[name] = 'Hello, %s' % name #创建一个 类名 的变量，值为 ‘Hello， 类名’

print(attrs) #打印一下类的方法和属性。

return type.__new__(cls,name,bases,attrs)class People(object,metaclass=Meta): #使用元类来定制类

age = 22peo=People()print(peo.People)

因为python是一门解释性语言，所以按照从上往下顺序执行

class Meta --> Meta类里面的方法和属性 --> class People --> People里面的方法和属性 --> 注意：此时将People里面的方法和属性传递给元类，执行元类的__new__方法、__init__方法(此例子中没重写) --> peo=People() 实例化 --> 元类的__call__方法(此例子中没重写) --> print(peo.People)

7. 其他封装、继承、多态

#类变量：修改、增加、删除#实例变量：增加、删除、修改

#析构函数 __del__#私有变量、私有方法：前面加 __

classCar():

region= 'China' #类变量，公有变量，每个实例化的对象都可以访问

def __init__(self,brand,price): #构造方法，实例化

self.brand =brand

self.price=price

self.__mile = 100 #私有变量，只能内部访问，无法通过实例化的对象进行外部访问

def __modifyMiles(self,mile): #私有方法，只能内部调用

self.__mile +=miledefgetMiles(self):return self.__mile

def __del__(self): #析构方法，销毁对象时自动执行的方法(如程序运行结束、主动删除对象)

#print('destroy obj.')

pass@staticmethod#@staticmethod是把函数嵌入到类中的一种方式，函数属于类，但是和类没有什么直接关系

def car_run(obj): #接受一个对象作为参数，调用这个参数的方法

obj.run()

car= Car('奔驰',300000)

car.getMiles()

car.owner= 'LaoWang' #实例化的对象也可以在外面直接添加变量

print(car.region)

car.region= 'Beijing' #相当于重新声明了一个实例化变量

print(car.owner,car.region) #当类变量和实例化变量同时存在，首先访问实例变量

delcar.ownerdelcar.regionprint(Car.region)classCC():pass

class EleCar(Car,CC): #多继承，子类继承父类Car,CC；子类不能直接调用父类的私有变量和私有方法，可以调用父类的调用了私有方法的方法

def __init__(self,brand,price,battery): #要写父类的参数

#三种继承方法，推荐最后一种

#Car.__init__(self,brand,price)

#super(EleCar,self).__init__(brand,price)

super().__init__(brand,price) #继承父类，初始化父类的属性(只初始化一个父类，按继承的顺序从左到右查找(广度优先)，遇到的第一个带有__init__方法的父类停止)。不管多少个父类，只写一遍即可。

self.battery =batterydefrun(self):print('%s is running.' %self.brand)classBike(Car):def __init__(self,brand,price):

super().__init__(brand,price)defrun(self):print('%s is running.' %self.brand)

bike= Bike('永久',300)

bike.run()print('--------')

ec= EleCar('宝马',300000,'asdf')#print(ec.getMiles())

ec.run()print('多态：一个接口，多种实现')

Car.car_run(ec)

Car.car_run(bike)

8. 抽象类和抽象方法

from abc import ABCMeta, abstractmethod #导入抽象类和抽象方法

class Employee(metaclass=ABCMeta): #定义抽象类，抽象类不能被实例化，只能被继承！

def __init__(self,name):

self.name=name

@abstractmethod#抽象方法，子类必须实现此方法！

defget_salary(self):pass

class Manager(Employee): #子类

def __init__(self,name):

super().__init__(name)def get_salary(self): #实现抽象类的抽象方法

return 15000

classDeveloper(Employee):def __init__(self,name,hour=0):

self.name=name

self.hour=hourdefget_salary(self):return 200*self.hourclass Factory(): #工厂模式

@staticmethoddef create(type,*args,**kwargs):return type(*args,**kwargs)

M= Factory.create(Manager,'zhongtao')

D= Factory.create(Developer,'zhangsan',160)print(f'{M.name} salary: {M.get_salary()}')print(f'{D.name} salary: {D.get_salary()}')