首页 / PYTHON / 五、python学习-面向对象
五、python学习-面向对象
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了五、python学习-面向对象，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9993字，纯文字阅读大概需要15分钟。
内容图文
1.面对对象程序开发基础（oop）
面对对象：高内聚 低耦合
面向过程：
优点：效率高，执行速度快
缺点：维护性，移植性差，表达不出一类的语义
面向对象：
优点：可读性，可移植性，可维护性高
缺点：执行效率捎慢
1.类的定义
class Car():
pass
class Car(object):
pass
2.类的实例化
class Car():
pass
obj = Car()
3.类的基本结构:成员属性、成员方法
4.类的命名：大驼峰命名法（每个单词首字符大写）
1.面对对象的三大特征：封装 继承 多态
1.封装：对类中成员属性和方法的保护，控制内部成员的访问、修改、删除等操作
对象的相关操作
1.两个保护等级：
public:
private:在成员前面加上（ __成员）下划线，默认是
2.类中的绑定方法（类的内部）
绑定到对象（对象调用方法，系统自动把该对象当成参数进行传递时）系统默认
绑定带类：对象或者类调用方法时，系统自动把该类当成参数进行传递
3.例子
class MyCar():
color = ""
__logo = ""
def drive(self):
pass
def __info():
pass
# 实例化
obj = MyCar()
obj.drive()
4.实例化的对象动态添加公有成员属性和方法
obj.color = "红色"
#__dict__查看对象或者类中的成员，返回一个字典：对象.__dict__
(1)动态添加无参方法
def dahuangfeng():
pass
# 对象.属性（自定义的） = 方法
obj.dahuangfeng = dahuangfeng
obj.dahuangfeng()
(2)动态添加有参方法
def qingtianzhu(name):
pass
obj.qingtianzhu = qingtianzhu
obj.qingtianzhu("擎天柱")
(3)动态添加lambda 匿名函数
obj.weizhentian = lambda : print("weizhentian")
obj.weizhentian()
5.在类外，让系统自动帮助传递obj这个对象参数
import types
def qingtianzhu(self,name):
pass
# 通过MethodType 来创建一个绑定方法，自动传递obj对象
obj.qingtianzhu = types.MethdType(qingtianzhu,obj)
obj.qingtianzhu("擎天柱")
类的相关操作
class MyCar():
color = ""
__logo = ""
def drive(self):
pass
def __info():
pass
1.定义的类访问公有成员属性和方法
MyCar.oil
MyCar.drive()
2.定义的类动态添加公有成员和属性
# 添加公有成员属性
MyCar.logo = ""
# 添加公有成员方法
(1)动态添加无参方法
def dahuangfeng():
pass
# 类.属性（自定义的） = 方法
MyCar.dahuangfeng = dahuangfeng
MyCar.dahuangfeng()
(2)动态添加有参方法
def qingtianzhu(name):
pass
MyCar.qingtianzhu = qingtianzhu
MyCar.qingtianzhu("擎天柱")
(3)动态添加lambda 匿名函数
MyCar.weizhentian = lambda : print("weizhentian")
MyCar.weizhentian()
##--**类和对象之间的注意点**
类中的成员只归属于当前这个类本身
对象可以调用其中的公有成员，但是没有修改和删除的权利，因为都归属于类，不是对象中的
类无法调用对象中的相关成员，但是对象可以调用类中的相关成员
# 对象调用类中成员
调用对象中的成员时，先看看自己有没有该成员
如果有就先调用自己没，没有调用类的
私有成员和删除成员
class Plane():
captain = "guo"
__airsister = 3
def fly(self):
pass
def fly2():
pass
def __plane_info(self):
print("%d" %(self.__airsister)
def __plane_info2():
print("%d" %(Plane.__airsister)
def pub_info(self):
self.__airsister
obj = Plane()
obj.fly()
obj.fly2()
1.私有成员的改名策略[_类名__成员名]
obj._Plane__airsister
Plane._Plane__airsister
obj._Plane__plane_info2
Plane._Plane__plane_info2
2.利用类内的公有方法简介调用私有成员（推荐）
obj.pub_info()
Plane.pub_info()
##--删除相关成员
3.实例化的对象删除公有成员属性和方法
obj.captain = "w"
del obj.captain
#
print(obj.captain)=>guo
# 删除方法
obj.func = lambda:pass
obj.func()
Plane.func()//error
del obj.func
obj.func()//error
4.定义的类删除公有成员属性和方法
del Plane.captain
#
print(obj.captain)=>error
# 删除方法
del Plane.fly
obj.fly()//error
类和对象的注意点
# 类空间和对象在内存中是两份空间
a.类空间在内存栈中
b.对象空间在内存堆中
__init__构造方法
# ###魔术方法(特定时机自动触发)
__doc__：
__name__：
__all__:指定类中方法(*)的范围 __all__ = ["a","测试"]
__init__魔术方法（构造方法）
触发时机：实例化对象，初始化的时候触发
功能：为对象添加成员
参数：参数不固定，至少一个self参数
返回值：无
#（1）基本语法
class MyClass():
def __init__(self):
self.name = "a"
obj = MyClass()
obj.name // "a"
# (2)多参数构造方法
class MyClass():
def __init__(self,name):
self.name = name
obj = MyClass(name = "ab")
obj.name // "ab"
2.继承：一个类除了自己所拥有的属性方法之外，还获取了另一个类的成员属性和方法
一个类继承另外一个类，该类是子类（衍生类），被集成的这个类叫做父类（基类，超类）
类都默认集成父类 object
1.单继承
子父继承之后，子类不可以调用父类的公有成员
子父继承之后，子类不可以调用父类的私有成员
子父继承之后，子类可以重写父类的同名方法
class Human(object):
hair = "金色"
sex = "男"
def eat(self):
pass
def __makeboby(self):
pass
class Man(Human):
pass
obj = Man()
2.多继承
calss Father():
property = "cac"
def f_hobby(self):
pass
calss Mother():
property = "caaa"
def m_hobby(self):
pass
calss Daughter(Father,Mother):
pass
obj = Daughter()
obj.property//cac
super(py3.0+：广度优先 py2.7+:深度优先)
super()只调用父类的相关公有成员
super()调用方法时，必须是绑定方法默认传递该类的对象
calss Father():
property = "cac"
def f_hobby():
pass
calss Mother():
property = "caaa"
def m_hobby(self):
pass
calss Son(Father,Mother):
property = "son"
//利用类来调用父类的成员
def ski1(self):
Mother.property
Father.property
//利用对象调用父类的属性方法
def ski2(self):
self.property//son
//利用super调用父类的属性方法
def ski3(self):
super()//Son()
super().m_hobby()
super().property//cac
super().f_hobby()//error
菱形继承（钻石继承）
# 结构：
# a
# b c
# d
class a():
pty = 4
def f(self):
print(1)
print(self.pty)
class b(a):
def f(self):
print(2)
super().f()
print(3)
class c(a):
def f(self):
print(4)
super().f()
print(5)
class d(b,c):
pty = 4
def f(self):
print(6)
super().f()
print(7)
obj = d()
obj.f()//6241537
mro列表(返回的是方法调用顺序的列表，针对于多继承下的同名方法，按照列表的顺序依次调用):类.mro()
issubclass:判断是否存在子父关系，只要在一个继承链上即可，应用范围在类身上（语法与isinstance的使用一模一样）
isinstance:判断类型
3. 多态
不同的子类对象，调用相同的父类的方法，产生不同的执行结果
2. 魔术方法
__init__构造方法
# ###魔术方法(特定时机自动触发)
__doc__：
__name__：
__all__:指定类中方法(*)的范围 __all__ = ["a","测试"]
__init__魔术方法（构造方法）
触发时机：实例化对象，初始化的时候触发
功能：为对象添加成员
参数：参数不固定，至少一个self参数
返回值：无
#（1）基本语法
class MyClass():
def __init__(self):
self.name = "a"
obj = MyClass()
obj.name // "a"
# (2)多参数构造方法
class MyClass():
def __init__(self,name):
self.name = name
obj = MyClass(name = "ab")
obj.name // "ab"
__new__魔术方法
魔术方法调用时，是按照触发时机排序，不是代码顺序
触发时机：实例化类生成对象的时候触发（触发时机在init之前）
功能：控制对象的创建过程
参数：至少一个cls接受当前的类，其他的根据情况决定
返回值：通畅返回对象或none
# 1. 基本语法
class MyClass():
a = 1
def __new__(cls):
pass
obj = MyClass()//Node
class MyClass(object):
a = 1
def __new__(cls):
# 借助父类object
obj = object.__new__(cls)
# 1.返回本类对象
return obj
# 2.返回其他类的对象
return object
# 3.不返回任何对象
return None
obj = MyClass()
# 2.new方法的处罚时机要快于init
# 3.new方法的参数要和init方法参数一一对应
class a():
def __new__(cls,name):
return object.__new__(cls)
def __init__(self,name):
self.name=name
# 4.注意点
如果返回的不是本类对象，不会调用init构造方法
__del__魔术方法（析构方法）
触发时机：当对象被内存回收的时候自动触发【1.页面执行完毕回收所有变量，2.所有对象被del的时候】
功能：对象使用完毕后资源回收
参数：一个self接受对象
返回值：无
class LangDog():
food = "吃肉"
def __init__(self.name):
self.name=name
def __del__(self):
print("del")
# 1.页面执行完毕回收所有变量
obj = LangDog("a")
print(obj.name)//a 刀疤
# 2.所有对象被del的时候
# 当一个值，没有任何变量指向 引用，这个值才会被真正的释放
other_obj = obj
print("开始")
del obj #删除的是obj的指向链接
print("结束")
#--开始 结束 del
# other_obj obj内存地址为同一个
other_obj = obj
print("开始")
del obj #删除的是obj的指向链接
del other_obj
print("结束")
#--开始 del 结束
# 3.模拟文件操作
#fp = open(文件，模式，编码)
#fp.read()
#fp.close()
class ReadFile():
def __new__(cls,*args,**kwargs):
# 判断文件存在不存在
if os.path.exists(filename):
return object.__new__(cls)
else:
return None
def __init__(self,filename):
self.fp = open(filename,"r","utf-8")
def __del__(self):
self.fp.close()
def readcontent(self):
return self.fp.read()
obj = ReadFile(filename="ceshi.txt")
obj.readcontent()
__str__魔术方法
触发时机：使用print(对象)或者str(对象)的时候触发
功能：查看对象
参数：一个self接受当前对象
返回值：必须返回字符串类型
calss Cat():
gift = "传说中的小猫有九条命"
def __init__(self,name):
self.name = name
def __str__(self):
return "123456"
def cat_info(self):
pass
tom = Cat("tangmu")
# 1.print答应改对象
print(tom)#123456
# 2.str
str(tom)#123456
__repr__魔术方法
触发时机：使用repr(对象时候触发)
功能：查看对象，与魔术方法__str__相似
参数：一个self接受当前对象
返回值：必须返回字符串类型
__str__ = __repr__
calss Cat():
gift = "传说中的小猫有九条命"
def __init__(self,name):
self.name = name
def __repr__(self):
return "123456"
def cat_info(self):
pass
tom = Cat("tangmu")
repr(obj)#"123456"
# __str__ = __repr__
# 1.print答应改对象
print(tom)#123456
# 2.str
str(tom)#123456
__call__魔术方法
触发时机：把对象当作函数调用的时候自动触发
功能：模拟函数花操作
参数：一个self接受当前对象
返回值：看需求
# 1.基本用法
class MyC():
def __call__(self):
print("call")
obj = MyC()
obj()# call
# 2.模拟洗衣服的过程
calss Wash():
def step1(self,name):
print(name)
def step2(self):
print(2)
def step3(self):
print(3)
def __call__(self,name):
self.step1(name)//1
self.step2()//2
self.step3()//3
obj = Wash()
obj.step1("a")//a
obj.step2()//2
obj.step3()//3
obj("a")
# 3.模拟内置方法 int 实现myint
import math
class MyInt():
def __call__(self,num):
if isinstance(num,bool):
if num ==True:
return 1
else:
return
elif isinstance(num,int):
return num
elif isinstance(num,float):
# <!--# 方法一-->
# <!--strvar = str(num)-->
# <!--return strvar.split(",")[0]-->
# <!--if num >= 0:-->
# <!-- return math.floor(num)-->
# <!--else:-->
# <!-- return math.ceil(num)-->
return math.floor(num) if num >= 0 else math.ceil(num)
elif isinstance(num,str):
if (num[0] == "+" or num[0] == "-")and num[1:].isdecimal():
if num[0] == "+":
sign = 1
else:
sign = -1
return eval((0 if num[1:].lstrip("0")=="" else num[1:].lstrip("0"))) * sign
elif num.isdecimal():
return eval((0 if num.lstrip("0") else num.lstrip("0")))
else:
return "error"
pass
myint = MyInt()
print(myint("+00002155251"))
bool（int、float ）
触发时机：使用bool(对象)的时候触发
功能：强制对象
参数：一个self接受当前对象
返回值：必须是布尔类型
add(与之相关的__radd__反向加法)(sub:- mul
标签：,,,,,,,, 来源： https://www.cnblogs.com/g-woniu/p/14665920.html
内容总结
以上是互联网集市为您收集整理的五、python学习-面向对象全部内容，希望文章能够帮你解决五、python学习-面向对象所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】