面向对象
1.类和对象
#定义类
class Person:
name='小明' #类属性
age=20 #类属性
def eat(self): #实例方法
print(self.name+'吃'+'apple')
pass
#创建对象:类的实例化
xm=Person()
print(xm.name)
print(xm.eat())
小明
小明吃apple
2.实例方法、类属性和实例属性
class Person:
name='小明' #类属性
age=20 #类属性
def __init__(self,pro,fam):
self.nameone='jkl' #实例属性
self.pro=pro #实例属性
self.fam=fam #实例属性
def eat(self): #实例方法
print(self.name+'吃'+'banana')
pass
xm=Person('teacher','three')
print(xm.name,xm.pro)
print(xm.eat())
小明 teacher
小明吃banana
3.添加实例属性
class Person:
name='小明' #类属性
def __init__(self,pro,fam):
self.nameone='jkl' #实例属性
self.pro=pro #实例属性
self.fam=fam #实例属性
def eat(self): #实例方法
print(self.name+'吃'+'banana')
pass
xm=Person('teacher','three')
xm.age=20 #添加实例属性
print(xm.age)
xl=Person('teacher','three')
print(xl.age)
20
AttributeError: ‘Person’ object has no attribute ‘age’
4.魔术方法
（1）直接打印对象
class Person:
name='小明' #类属性
age=20 #类属性
def eat(self): #实例方法
print(self.name+'吃'+'apple')
pass
#创建对象:类的实例化
xm=Person()
print(xm) #直接打印对象，得到的是对象的地址
<main.Person object at 0x00000229D1164940>
（2）__ str __方法
class Person:
name = '小明' # 类属性
age = 20 # 类属性
def __init__(self, pro, fam):
self.nameone = 'jkl' # 实例属性
self.pro = pro # 实例属性
self.fam = fam # 实例属性
def eat(self, food): # 实例方法
print(self.name + '吃' + food)
pass
def __str__(self):
return '%s的专业是%s' % (self.nameone, self.pro)
xm=Person('teacher','three')
print(xm)
jkl的专业是teacher
（3）__ new __方法
若直接创建对象，则默认调用__ new __ ，若使用 __ new __，必须在内部创建并返回。
class Person:
name = '小明' # 类属性
age = 20 # 类属性
def __init__(self, pro, fam):
self.nameone = 'jkl' # 实例属性
self.pro = pro # 实例属性
self.fam = fam # 实例属性
def eat(self, food): # 实例方法
print(self.name + '吃' + food)
pass
def __new__(cls, *args, **kwargs):
print('new函数执行')
xm=Person('teacher','three')
print(xm.pro)
new函数执行
AttributeError: ‘NoneType’ object has no attribute ‘pro’
真正创建实例对象。new函数执行要早于init函数。
class Person:
name = '小明' # 类属性
age = 20 # 类属性
def __init__(self, pro, fam):
self.nameone = 'jkl' # 实例属性
self.pro = pro # 实例属性
self.fam = fam # 实例属性
def eat(self, food): # 实例方法
print(self.name + '吃' + food)
pass
def __new__(cls, *args, **kwargs):
print('new函数执行')
return object.__new__(cls) #创建当前类的实例对象并返回
xm=Person('teacher','three')
print(xm.pro)
new函数执行
teacher
5.析构方法
（1）程序执行完毕自动调用del释放内存
class Animal:
def __init__(self,name):
self.name=name
print('这是构造初始化')
pass
def __del__(self):
print('这是析构方法')
pass
cat=Animal('cat')
print(cat.name)
input('输入: ') #程序没有执行完毕，则不会调用del函数释放内存
没有执行完毕
这是构造初始化
cat
输入:
执行完毕
这是构造初始化
cat
输入:2
这是析构方法
（2）手动清理对象
class Animal:
def __init__(self,name):
self.name=name
print('这是构造初始化')
pass
def __del__(self):
print('这是析构方法')
pass
cat=Animal('cat')
del cat
手动清理对象，会指定del方法用来释放内存
这是构造初始化
这是析构方法
6.单继承
class Animal:
def eat(self):
print('吃')
pass
def drink(self):
print('喝')
pass
class dog(Animal): #继承父类，dog是子类
def wwj(self):
print('wwj')
pass
class cat:
def mmj(self):
print('mmj')
pass
d1=dog()
d1.eat()
d1.wwj()
吃
wwj
7.多继承
（1）多继承
class sx:
def fly(self):
print('会飞')
pass
class Monkey:
def ct(self):
print('吃桃')
pass
class Swk(sx,Monkey):
pass
swk=Swk()
swk.fly()
swk.ct()
会飞
吃桃
（2）继承顺序
class D:
def eat(self):
print('D.eat')
pass
class C(D):
def eat(self):
print('C.eat')
pass
class B(D):
pass
class A(B,C):
pass
a=A()
a.eat() #广度优先
print(A.__mro__)
C.eat
(<class ‘main.A’>, <class ‘main.B’>, <class ‘main.C’>, <class ‘main.D’>, <class ‘object’>)
（3）继承的传递性
class Gp:
def eat(self):
print('吃')
pass
pass
class Fa(Gp):
pass
class Son(Fa):
pass
son=Son()
son.eat()
吃
8.重写父类和调用父类
class Dog:
def __init__(self,name):
self.name=name
pass
def bark(self):
print('wwj')
pass
pass
class kj(Dog):
def __init__(self,name):
#Dog.__init__(self,name) #手动找到父类
super().__init__(name) #自动找到父类
self.age=20 #拓展新的属性
pass
def bark(self):
print('叫的厉害')
print(self.name)
pass
pass
gh=kj('哮天犬')
gh.bark()
print(gh.name)
叫的厉害
哮天犬
哮天犬
9.类属性和实例属性
class Student:
name='jkl'#类属性
def __init__(self,age):
self.age=age #实例属性
pass
pass
stu=Student(18)
stu.name='zqz' #实例修改类属性，只有修改的实例的属性会发生变化
print(stu.name,stu.age)
xm=Student(20)
print(xm.name)
Student.name='wxq' #通过类对象修改类属性，所有实例的类属性都会变化
stu1=Student(25)
print(stu1.name)
print(Student.name)
#print(Student.age) #类对象不能调用实例属性
zqz 18
jkl
wxq
wxq
10.类方法和静态方法
（1）类方法
class People:
'''
类方法：类对象拥有的方法，用装饰器@classmethod来标识，第一个参数是类对象cls。类对象、实例对象可以调用类方法。
'''
country='china'
@classmethod
def get_country(cls): #类方法
return cls.country
pass
@classmethod
def change_country(cls,data): #类方法中修改类属性的值
cls.country=data
pass
print(People.get_country()) #通过类对象引用
p=People()
print(p.get_country()) #通过实例对象引用
People.change_country('japan')
print(People.get_country())
china
china
japan
（2）静态方法
class People:
'''
静态方法：类对象拥有的方法，用装饰器@staticmethod来标识，可以不需任何参数。一般，不通过实例对象访问静态方法。
一般存放逻辑性的代码，和类、实例没有交互。
'''
country='china'
@staticmethod
def getdata():
return People.country
pass
print(People.getdata())
china
11.多态
（1）手动实现多态
'''
多态：同一种方法对不同的子类有不同的表现。
条件：继承和重写。
'''
class Animal:
def say(self):
print('一只动物')
pass
pass
class Dog(Animal):
def say(self):
print('一只狗')
pass
pass
class Cat(Animal):
def say(self):
print('一只🐱')
pass
pass
cat1=Cat()
cat1.say()
dog1=Dog()
dog1.say()
一只🐱
一只狗
（2）自动实现多态
class Animal:
def say(self):
print('一只动物')
pass
pass
class Dog(Animal):
def say(self):
print('一只狗')
pass
pass
class Cat(Animal):
def say(self):
print('一只🐱')
pass
pass
def commonInvoke(obj): #实现用统一的方法调用
obj.say()
pass
listobj=[Dog(),Cat()]
for i in listobj:
commonInvoke(i)
一只🐱
一只狗
12.私有化属性
class Person:
__hobby='sing'
def __init__(self):
self.__name='jkl'
self.age=30
pass
def __str__(self):
return '名字是%s,爱好是%s'%(self.__name,self.__hobby) #可以在类内访问
pass
def changevalue(self):
Person.__hobby='dance' #私有化属性可以在类内修改
class Student(Person):
pass
stu=Student()
#print(stu.__name) #子类不能继承父类私有化属性
xl=Person()
#print(xl.__name) #私有化属性在类外不能访问
xl.changevalue()
print(xl)
#print(xl.__hobby) #私有类属性不能在类外访问
名字是jkl,爱好是dance
13.私有化方法
class Animal:
def __eat(self):
print('吃')
pass
def run(self):
self.__eat() #可以在类内调用
print('跑')
pass
pass
class Bird(Animal):
pass
b1=Bird()
#b1.__eat() #类外不能调用私有化方法
b1.run()
吃
跑
|