Python OOP面向对象

'''
在现实世界中站在人这个角度，先有对象才有类
对象1：mogu
特征：
五官=眼、口、耳、鼻、喉
姓名=mogu
技能：
学习、吃饭、睡觉
对象2：小明
特征：
五官=眼、口、耳、鼻、喉
姓名=小明
技能：
学习、吃饭、睡觉
对象1：小李
特征：
五官=眼、口、耳、鼻、喉
姓名=小李
技能：
学习、吃饭、睡觉 现实中的人类：
相似的特征：五官=眼、口、耳、鼻、喉
相似的技能：学习、吃饭、睡觉
'''

#方式一、为对象初始化自己独有的特征
class People:
country='China'
x=1
def run(self):
print('----->', self)# 实例化出三个空对象
obj1=People()
obj2=People()
obj3=People()# 为对象定制自己独有的特征
obj1.name='mogu'
obj1.age=18
obj1.sex='male'obj2.name='xiaoqing'
obj2.age=28
obj2.sex='female'obj3.name='xiaoming'
obj3.age=28
obj3.sex='female'# print(obj1.__dict__)
# print(obj2.__dict__)
# print(obj3.__dict__)
# print(People.__dict__)#方式二、为对象初始化自己独有的特征
class People:
country='China'
x=1
def run(self):
print('----->', self)# 实例化出三个空对象
obj1=People()
obj2=People()
obj3=People()# 为对象定制自己独有的特征
def chu_shi_hua(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
obj.name = x
obj.age = y
obj.sex = zchu_shi_hua(obj1,'mogu',18,'male')
chu_shi_hua(obj2,'xiaoqing',28,'female')
chu_shi_hua(obj3,'xiaoming',28,'female')#方式三、为对象初始化自己独有的特征
class People:
country='China'
x=1 def chu_shi_hua(obj, x, y, z):
obj.name = x
obj.age = y
obj.sex = z def run(self):
print('----->', self)obj1=People()
# print(People.chu_shi_hua)
People.chu_shi_hua(obj1,'mogu',18,'male')obj2=People()
People.chu_shi_hua(obj2,'xiaoqing',28,'female')obj3=People()
People.chu_shi_hua(obj3,'xiaoming',28,'female')# 方式四、为对象初始化自己独有的特征
class People:
country='China'
x=1 def __init__(obj, x, y, z): #obj=obj1,x='egon',y=18,z='male'
obj.name = x
obj.age = y
obj.sex = z def run(self):
print('----->', self)obj1=People('mogu',18,'male') #People.__init__(obj1,'mogu',18,'male')
obj2=People('xiaoqing',28,'female') #People.__init__(obj2,'xiaoqing',28,'female')
obj3=People('xiaoming',28,'female') #People.__init__(obj3,'xiaoming',28,'female')# __init__方法
# 强调：
# 1、该方法内可以有任意的python代码
# 2、一定不能有返回值

#类的数据属性是所有对象共享的,id都一样
class People:
money=1
def learn(self):
print('is learning')obj1=People()
obj2=People()
obj3=People()print(id(People.money))print(id(obj1.money))
print(id(obj2.money))
print(id(obj3.money))'''
1643995360
1643995360
1643995360
1643995360
'''# 类的函数属性是绑定给对象使用的,obj.method称为绑定方法,内存地址都不一样
# ps:id是python的实现机制,并不能真实反映内存地址,如果有内存地址,还是以内存地址为准
print(People.learn)
print(obj1.learn)
print(obj2.learn)
print(obj3.learn)
'''
<function People.learn at 0x0000000002201D90>
<bound method People.learn of <__main__.People object at 0x0000000002203048>>
<bound method People.learn of <__main__.People object at 0x0000000002203080>>
<bound method People.learn of <__main__.People object at 0x00000000022036D8>>
'''

#练习：编写一个学生类，产生一堆学生对象，要求有一个计数器（属性），统计总共实例了多少个对象
class Student:
count=0
def __init__(self,name):
self.name=name
Student.count+=1
obj1=Student('a')
obj2=Student('z')
obj3=Student('q')
obj4=Student('w')
obj5=Student('r')
obj6=Student('s')
obj7=Student('x')
print(Student.count)

#类型dict就是类dict
>>> list
<class 'list'>#实例化的到3个对象l1,l2,l3
>>> l1=list()
>>> l2=list()
>>> l3=list()#三个对象都有绑定方法append,是相同的功能,但内存地址不同
>>> l1.append
<built-in method append of list object at 0x10b482b48>
>>> l2.append
<built-in method append of list object at 0x10b482b88>
>>> l3.append
<built-in method append of list object at 0x10b482bc8>#操作绑定方法l1.append(3),就是在往l1添加3,绝对不会将3添加到l2或l3
>>> l1.append(3)
>>> l1
[3]
>>> l2
[]
>>> l3
[]
#调用类list.append(l3,111)等同于l3.append(111)
>>> list.append(l3,111) #l3.append(111)
>>> l3
[111]

class Animal:
def __init__(self,name):
self.name=name def eat(self):
print('%s is eating'%self.name) def drink(self):
print('%s is drinking'%self.name) def la(self):
print('%s is laing'%self.name) def sa(self):
print('%s is saing'%self.name)class People(Animal):
pass
class Pig(Animal):
pass
class Dog(Animal):
passaobama=People('奥巴码')
meixi=People('梅戏')
maidou=Pig('麦兜')
zjq=Pig('猪坚强')
shinubi=Dog('史努比')
shipaike=Dog('史派克')aobama.drink() #奥巴码 is drinking
maidou.drink() #麦兜 is drinking
shinubi.drink()#史努比 is drinking

class People:
country='China'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def learn(self): #父类的学习方法
print('%s is learn from People' % self.name)class Teacher(People):
def __init__(self,name,age,sex,level):
People.__init__(self,name,age,sex)#重用父类的方法
self.level=level def teach(self):
print('%s is teach'%self.name)class Student(People):
def __init__(self,name,age,sex,score):
People.__init__(self,name,age,sex)#重用父类的方法
self.score=score def learn(self): #派生学生自己的学习方法
print('%s is learn from Student'%self.name)egon=Teacher('egon',28,'male',99)
mogu=Student('mogu',24,'male',0)

class A(object):
def test(self):
print('from A')class B(A):
def test(self):
print('from B')class C(A):
def test(self):
print('from C')class D(B):
def test(self):
print('from D')class E(C):
def test(self):
print('from E')class F(D,E):
# def test(self):
# print('from F')
pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类继承顺序

# 指名道姓地访问某一个类的函数
# 注意：
# 1. 该方式与继承是没有关系的
# 2. 访问是某一个类的函数，没有自动传值的效果class People:
country='China'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sexclass Teacher(People):
def __init__(self,name,age,sex,level):
People.__init__(self,name,age,sex)#重用父类的方法
self.level=level def teach(self):
print('%s is teach'%self.name)class Student(People):
def __init__(self,name,age,sex,score):
People.__init__(self,name,age,sex)#重用父类的方法
self.score=score def learn(self):
print('%s is learn'%self.name)egon=Teacher('egon',28,'male',99)
mogu=Student('mogu',24,'male',0)

# 在子类派生出的新方法中重用父类功能的方式二：只能在子类中用
# 在python2：super(自己的类名,对象自己)
# 在python3：super()
# 调用super()会得到一个特殊的对象，该特殊的对象是专门用来引用父类中的属性的，!!!完全参照mro列表!!!class People:
country='China'
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
def learn(self):
print('%s is learn from People' % self.name)class Teacher(People):
def __init__(self,name,age,sex,level):
super(People,self).__init__(name,age,sex)#重用父类的方法二
self.level=level def teach(self):
print('%s is teach'%self.name)class Student(People):
def __init__(self,name,age,sex,score):
super().__init__(name,age,sex)#重用父类的方法二(简写)
self.score=score def learn(self):
print('%s is learn from Student'%self.name)egon=Teacher('egon',28,'male',99)
mogu=Student('mogu',24,'male',0)# 注意：
# 1. 该方式与继承严格依赖于继承的mro列表
# 2. 访问是绑定方法，有自动传值的效果

#例子
class A:
def test(self):
print('A.test()')
super().test()class B:
def test(self):
print('from B')class C(A,B):
passobj=C()
print(C.mro())
#[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
obj.test()
'''
A.test()
from B
'''

class People:
country = 'China' def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
self.course = [] def choose_course(self, course_name):
'''选择课程方法'''
self.course.append(course_name) def check_course(self):
'''查看课程信息方法'''
for course_obj in self.course: # 查看老师课程信息
print(course_obj.name, course_obj.price) # 英语 9999 #此处还可自定义显示格式class Teacher(People):
'''老师类'''
passclass Student(People):
'''学生类'''
passclass Course:
'''课程类'''
def __init__(self, name, price, period):
self.name = name
self.price = price
self.period = periodegon = Teacher('egon', 28, 'male') # 实例化老师
mogu = Student('mogu', 24, 'male') # 实例化学生
english = Course('英语', 9999, 12) # 实例化课程egon.choose_course(english) # 老师选择了课程
mogu.choose_course(english) # 蘑菇选择了课程egon.check_course()
mogu.check_course()
#ps : Teacher类与Student类 无任何继承关系 却使用了课程对象的信息
# 此处即为组合实现

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
def read(self):
pass def write(self):
passclass DiskFile:
def read(self):
pass
def write(self):
pass

#str,list,tuple都是序列类型
s=str('hello')
l=list([1,2,3])
t=tuple((4,5,6))#我们可以在不考虑三者类型的前提下使用s,l,t
s.__len__()
l.__len__()
t.__len__()len(s)
len(l)
len(t)

class People:
__country='China' #_People__country='China'
__n=111 #_People__n=111 def __init__(self,name):
self.__name=name #self._People__name=name def run(self):
print('%s is running' %self.__name) #self._People__name# print(People.__country)#访问不到会报错obj=People('egon')
# print(obj.__name)#访问不到会报错
print(obj.run)
obj.run()print(People.__dict__)
print(People._People__country) #这样就能访问到
print(obj.__dict__)
print(obj._People__name)#这样就能访问到# 总结这种隐藏需要注意的问题:
# 1. 这种隐藏只是一种语法上的变形,并没有真的限制访问
# 2. 这种变形只在类定义阶段检测语法时变形一次,类定义阶段之后新增的__开头的属性不会发生变形# 3. 在继承中，父类如果不想让子类覆盖自己的方法，可以在该方法前加__开头class Foo:
def __f1(self): #_Foo__f1
print('Foo.f1') def f2(self):
print('Foo.f2')
self.__f1() #self._Foo__f1()class Bar(Foo):
def __f1(self): #_Bar__f1
print('Bar.f1')obj=Bar()
obj.f2()

# 封装的真实意图:把数据属性或函数属性装起来就是为了以后使用的,封起来即藏起来是为不让外部直接使用
# 1.封数据属性:把数据属性藏起来,是为了不让外部直接操作隐藏的属性,而通过类内开辟的接口来间接地操作属性,
# 我们可以在接口之上附加任意的控制逻辑来严格控制使用者对属性的操作
class People:
def __init__(self, name, age):
self.__name = name
self.__age = age def tell_info(self):
print('<name:%s age:%s>' % (self.__name, self.__age)) def set_info(self, name, age):
if type(name) is not str:
print('名字必须是str类型')
return
if type(age) is not int:
print('年龄必须是int类型')
return self.__name = name
self.__age = agepeo = People('xiaoming', 28)# obj.tell_info()
# obj.set_info('xiaozhang',19)
# obj.set_info(123,19)
peo.set_info('xiaoli',19)
peo.tell_info()

class ATM:
def __card(self):
print('插卡')
def __auth(self):
print('用户认证')
def __input(self):
print('输入取款金额')
def __print_bill(self):
print('打印账单')
def __take_money(self):
print('取款') def withdraw(self):
self.__card()
self.__auth()
self.__input()
self.__print_bill()
self.__take_money()a=ATM()
a.withdraw()

IP='127.0.0.1'
PORT=3306

import settingsclass Mysql:
def __init__(self,ip,port):
self.ip=ip
self.port=port def tell_info(self):
print('%s : %s' %(self.ip,self.port)) @classmethod
def from_conf(cls):
return cls(settings.IP, settings.PORT)obj1=Mysql.from_conf()obj1.tell_info()

class Mysql:
def __init__(self):
self.id=self.create_id() @staticmethod
def create_id():#不需要传任何参数
import uuid
return uuid.uuid4()obj=Mysql()
print(obj.id)

# HOST='127.0.0.1'
# PORT=3306import settings
class MySQL:
def __init__(self,host,port):
self.host=host
self.port=port @staticmethod
def from_conf():
return MySQL(settings.HOST,settings.PORT) # @classmethod #哪个类来调用,就将哪个类当做第一个参数传入
# def from_conf(cls):
# return cls(settings.HOST,settings.PORT) def __str__(self):
return '就不告诉你'class Mariadb(MySQL):
def __str__(self):
return '<%s:%s>' %(self.host,self.port)m=Mariadb.from_conf()
print(m) #我们的意图是想触发Mariadb.__str__,但是结果触发了MySQL.__str__的执行，打印就不告诉你：

class Ftp:
def get(self):
print('get') def put(self):
print('put') def login(self):
print('login') def run(self):
while True:
choice=input('>>>: ').strip()
if hasattr(self,choice):
method=getattr(self,choice)
method()
else:
print('命令不存在')obj=Ftp()
obj.run()

#1. __doc__ 表示类的描述信息
class Foo:
'''
描述信息啦
'''
def func(self):
pass
print(Foo.__doc__)

#2. __module__ 和 __class__
#2.1 __module__ 表示当前操作的对象在哪个模块
#2.2 __class__ 表示当前操作的对象的类是什么 （__class__.__name__ 即可拿到类名）#settings 文件内定义一个类
class Foo:
def __init__(self,name):
self.name=name#src 文件
import settingsobj=settings.Foo('mogu')
print(obj.__module__) #settings
print(obj.__class__.__name__) #Foo

#3. __str__ 如果一个类中定义了__str__方法，那么在打印对象时，默认输出该方法的返回值。
class Foo:
def __str__(self):
return '我是__str__啦啦'obj=Foo()
print(obj)

#4. __del__：在对象被删除前自动触发, 在该方法内应该执行与该对象有关的系统资源的回收操作
class Foo:
def __init__(self,filename,encoding='utf-8'):
self.f=open(filename,'r',encoding=encoding) def __del__(self):
# print('run.....')
self.f.close()obj=Foo('a.txt')
del obj #obj.__del__()

#5. __call__ 对象后面加括号，触发执行
class Foo:
def __init__(self):
pass
def __call__(self, *args, **kwargs):
print('__call__')obj = Foo() # 执行 __init__
obj() # 执行 __call__

。。。

#7. __getitem__ 和 __setitem__ 和 __delitem__
#用于索引操作，如字典。以上分别表示获取、设置、删除数据
class Foo:
def __getitem__(self, item):
print('__getitem__',item)
def __setitem__(self, key, value):
print('__setitem__',key,value)
def __delitem__(self, key):
print('__delitem__',key)
obj=Foo()
result=obj['mogu'] #自动触发 __getitem__ mogu
obj['k']='xiaoming' #自动触发 __setitem__ k xiaoming
del obj['k'] #自动触发 __delitem__ k

#8. __iter__ 用于迭代器，之所以列表、字典、元组可以进行for循环，是因为类型内部定义了 __iter__
class Foo(object): def __init__(self, list):
self.list = list def __iter__(self):
return iter(self.list)obj = Foo([11,22,33,44])for i in obj:
print(i)#等同于（详细去看迭代器）
obj = iter([11, 22, 33, 44])
for i in obj:
print(i)

#9. __new__ 和 __metaclass__
# 详见元类