当前位置： 首页 > news >正文

python面向对象

news 来源：原创 2024/5/15 11:55:33

OOP 面向对象的程序开发

用几大特征表达一类事物称为一个类,类更像是一张图纸,表达的是一个抽象概念
对象是类的具体实现,更像是由这图纸产出的具体物品,类只有一个,但对象可以通过这个类实例化出多个
对象是类的实例,类是对象的模板
*类中的成员只有方法和属性,不要裸露的把判断和循环直接写在类中,而是用方法包起来
​
(1)类的定义
# 定义一
class Myclass:
    pass

# 定义二
class Myclass():
    pass

# 定义三
class Myclass(object):
    pass
(2)类的实例化 产生的是对象
>>> class Car():
...   color = "red"
...
>>> obj = Car()
>>> print(obj)
<__main__.Car object at 0x0000026497119BE0>
>>>
(3)类的基本结构
　　1.成员属性
　　2.成员方法
>>> class MyCar():
...   # 成员属性
...   color = "red"
...   # 成员方法
...   def run():
...     pass
...
>>>
(4)类的命名
　　推荐使用驼峰命令，每个单词首字母大写
　　myclass --> MyClass

面向对象三大特征: 封装 继承 多态

封装:对类中成员属性和方法的保护,控制外界对内部成员的访问,修改,删除等操作
　　对象的使用方式：
　　　　对象.属性
　　　　对象.方法
class MyCar():
    # 公有成员属性
    attra = "属性"
    # 私有成员属性
    __attrb = "私有属性"
    # 公有成员方法
    def run(self):
        print("调用属性",self.attra)
    # 私有成员方法
    def __private_info(self):
        print("私有成员方法")

"""
绑定方法：
  1.绑定到对象，默认把对象当成参数进行传递，self形参接受
  2.绑定到类，默认把类当成参数进行传递，形参接受
"""
# 实例化对象
obj = MyCar()

# 1.实例化的对象防卫公有成员属性和方法
print(obj.attra)
obj.run()

# 2.实例化的对象动态添加公有成员属性和方法
"""
__dict__ 获取对象或者类的内部成员
"""
print(obj.__dict__) # 当前对象没有成员
obj.attra = "改变属性"
print(obj.__dict__)

# 动态添加成员方法
# 1) 添加无参方法
def methoda():
    print("新添加的方法1")
# 类外的函数赋值给obj对象一个成员方法
obj.methoda = methoda
obj.methoda()
print(obj.__dict__)

# 2) 添加有参方法
def methodb(self,arge):
    print(self.attra,arge)
# 赋值
obj.methodb = methodb
# 需要手动传入对象
obj.methodb(obj,"有参方法")

# 3) 添加lambda表达式
obj.methodc = lambda : print("添加方法c")
obj.methodc()

# -------------------------------
# 运行结果
属性
调用属性 属性
{}
{'attra': '改变属性'}
新添加的方法1
{'attra': '改变属性', 'methoda': <function methoda at 0x0000020F70DA2EA0>}
改变属性 有参方法
添加方法c
继承
    一个类除了自身所拥有的属性方法之外,还获取了另外一个类的成员属性和方法
　　 一个类继承另外一个类，当前类是子类（衍生类），被继承的类是父类（基类、超类）。所有类的父类都是object
　　 单继承 
　　　　-1.子类可以使用父类的共有方法
>>> class Father():
...   attra = 'a'
...   def func(self):
...     print('func')
...
>>> class Son(Father):
...   pass
...
>>> obj = Son()
>>> print(obj.attra)
a
>>> obj.func()
func
>>>

　　　　-2.子类不能调用父类的私有方法

>>> class Father():
...   __attrb = 'b'
...   def __func(self):
...     print('private func')
...
>>> class Son(Father):
...   pass
...
>>> obj = Son()
>>> obj.__attrb
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Son' object has no attribute '__attrb'
>>> obj.__func()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Son' object has no attribute '__func'
>>>

　　　　-3.子类可以改写父类方法

　　　　　　self对象优先调用本类中的方法，如果本类中没有调用父类的

  多继承

# 基本语法
class Father():
    attra = "属性a"
    def methoda(self):
        print("methoda")

class Mother():
    attrb = "属性b"
    def methodb(self):
        print("methodb")

class Son(Father,Mother):
    pass

obj = Son()
print(obj.attra)
obj.methoda()

# 执行结果
属性a
methoda

 

   类的相关操作

    语法：类.属性  类.方法()

　　1.调用类中成员的时候，要么使用对象，要么使用类

　　    对象可以使用类中的相关公有成员，但是没有归属权

　　　类中的成员都归当前这个类所有，但是不能使用对象中的成员

　　2.对象中如果有成员，使用自己的，如果没有，使用类中的

class Person():
    attra = "公有成员属性"
    __attrb = "私有成员属性"
    def method():
        print("普通公有方法",Person.__attrb)
    def __private_method():
        print("普通私有方法")

obj = Person() # 实例化一个对象
print(Person.attra) # 类访问成员属性
print(Person.method()) # 类访问成员方法
"""
1.对象无法调用无参的普通方法，必须加上self
2.无论是对象还是类，都无法在类外调用类中的私有成员
"""
print(Person.__dict__) # 查看类的所有成员

# 定义的类动态添加公有成员属性和方法
Person.attrc = "添加成员属性"
print(Person.__dict__)
print(obj.__dict__)

# 1) 添加无参方法
def methoda():
    print("添加无参方法")
Person.methoda = methoda
Person.method()

# 2) 添加有参方法
def methodb(name):
    print("方法",name)
Person.methodb = methodb
Person.methodb("有参方法")

# 3) lambda表达式
Person.methodc = lambda : print("lambda表达式")
Person.methodc()

# 执行结果
公有成员属性
普通公有方法 私有成员属性
None
{'__module__': '__main__', 'attra': '公有成员属性', '_Person__attrb': '私有成员属性', 'method': <function Person.method at 0x00000280E4203598>, '_Person__private_method': <function Person.__private_method at 0x00000280E4203488>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
{'__module__': '__main__', 'attra': '公有成员属性', '_Person__attrb': '私有成员属性', 'method': <function Person.method at 0x00000280E4203598>, '_Person__private_method': <function Person.__private_method at 0x00000280E4203488>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None, 'attrc': '添加成员属性'}
{}
普通公有方法 私有成员属性
方法 有参方法
lambda表达式

多态:不同的子类对象,调用相同的父类方法,产生不同的执行结果
　　 好处：多态是针对对象来说的，在不改变原有代码的前提下，完成不同的功能。不同的对象，调用相同的方法，达到不同的功能
# 定义一个父类
class Father():
    # 方法
    def methoda(self):
        pass

# 定义子类调用父类方法
class Sona(Father):
    def methoda(self):
        print("调用父类，定制化子类a")

class Sonb(Father):
    def methoda(self):
        print("调用父类，定制化子类b")

# 实例化
obja = Sona()
objb = Sonb()
listvar = [obja,objb]
for i in listvar:
    i.methoda()

# 执行结果
调用父类，定制化子类a
调用父类，定制化子类b

python对成员的保护分为两个等级

私有的: private
    在本类内部可以访问,类的外部不可以访问.(python中 属性或者方法前面加上两个下划线__)
公有的: public
 在本类的内部和外部都可以访问.
(了解)在其他高级语言当中,如java php c++等语言,有三个等级 private public protected
 私有成员的改名策略 [_类名__成员名]
 对象的相关操作
    (1)实例化的对象访问公有成员属性和方法
    (2)实例化的对象动态添加公有成员属性和方法
    (3)实例化的对象删除公有成员属性和方法
 类的相关操作
   (1)定义的类访问公有成员属性和方法
   (2)定义的类动态添加公有成员属性和方法
   (3)定义的类删除公有成员属性和方法
    
普通方法: 没有任何参数传递,只能类调用
绑定方法: 把默认传参的方法叫做绑定方法,绑定到对象(默认传对象),绑定到类(默认传类)
非绑定方法:静态方法(无需传任何参数,对象和类都能调用)
私有的：只能载类或者对象的结构中访问
公有的：可以载任何位置访问
受保护：可以载当前类或者对象 和子类或者子类对象中访问
​
  类内   子类中   类外部
公有的： √       √       √  
私有的： √       X       X
受保护： √       √       X (python语言不支持)

编程语言的发行时间 

1972    C
1983    C++(即带有类概念的C语言,更名于1983年7月)
1989 Python
1991 Visual Basic
1993 Ruby
1995 JavaScript
1995 PHP
1996 Java
2001 C#
2009 Go

多继承弊端

多继承的弊端会造成菱形继承这种情况,找不清调用顺序
super对象按照mro列表的顺序依次调用,解决菱形继承存在的问题
​
经典类:深度优先 (python2.x)
新式类:广度优先 (python3.x)
​
写多继承时,尽量避免造成不同类相同方法名的情况,提高代码质量 高内聚,低耦合
高内聚:一个模块只完成一个任务,专一性高
低耦合:模块与模块之间可以彼此独立不冲突,方便移植复用.

super调用父类方法

(1)super本身是一个类 super()是一个对象 用于调用父类的绑定方法
(2)super() 只应用在绑定方法中,默认自动传递self对象 (前提:super所在作用域存在self)
(3)super用途: 解决复杂的多继承调用顺序
class Father():
    attra = "aaa"
    def methoda():
        print("aaa")

class Mother():
    attrb = "bbb"
    def methodb(self):
        print("bbb")

class Son(Father,Mother):
    attra = "s-aaa"
    def methodb(self):
        print("s-bbb")
    def calla(self):
        print(Father.attra)
        Father.methoda()
    """
    self在调用时，本类有，优先调用自己，本类没有，调用父类
    """
    def callb(self):
        print(self.attrb)
        self.methodb()
    def callc(self):
        print(super().attra)
        super().methodb()

obj = Son()
obj.calla()
obj.callb()
obj.callc()

# 执行结果
aaa
aaa
bbb
s-bbb
aaa
bbb

魔术方法(特定时机自动触发)

__init__魔术方法(构造方法)
'''
    触发时机：实例化对象,初始化的时候触发
 功能：为对象添加成员
 参数：参数不固定,至少一个self参数
 返回值：无
'''
# 基本语法
class MyClass():
    def __init__(self):
        self.name = "Python"

obj = MyClass()
print(obj.name)

# 多个参数的__init__
class MyClass():
    def __init__(self,name):
        self.name = name

obj = MyClass("Python")
print(obj.name)

# 综合
class MyClass():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def score(self):
        print("-->111")
    def course(self):
        print("-->222")
obj = MyClass("Python",18)
obj.score()
obj.course()

# 执行结果 
Python
Python
-->111
-->222 
__new__ 魔术方法
'''
    触发时机：实例化类生成对象的时候触发(触发时机在__init__之前)
 功能：控制对象的创建过程
 参数:至少一个cls接受当前的类,其他根据情况决定
 返回值：通常返回对象或None
'''
# 可以通过__new__来控制对象创建的过程
class MyClassa():
    attra = 'a'
obja = MyClassa()

class MyClassb():
    def __new__(cls, *args, **kwargs):
        print(cls) # 通过父类object 中的 __new__ 魔术方法 ,返回该类的对象,参数是类
        return obja # 可以返回别人的对象

objb = MyClassb()
print(objb)
print(obja.attra)

 

__new__和__init__之间的区别
"""
__new__ 创建对象
__init__ 初始化对象
__new__ 在 __init__触发之前
"""
class MyClass():
    def __new__(cls,name): # __new__和__init__形参和实参要匹配
        print(111)
        return object.__new__(cls) # 需要返回给__init__中参数
    def __init__(self,name):
        print(222)
        self.name = name

obj = MyClass("test")
print(obj.name)

# 升级
class MyClass():
    def __new__(cls, *args, **kwargs):
        print(111)
        return object.__new__(cls)
    def __init__(self,name,age,sex):
        print(222)
        self.name = name
        self.age = age
        self.sex = sex

obj = MyClass("A",22,"M")
print(obj.name)

# __init__只会初始化自己的对象
class MyClassa():
    def __new__(cls, *args, **kwargs):
        print(111)
        return obj
    def __init__(self):
        print(222)

obj = MyClassa()
print(obj)

# 执行结果
111
222
test
111
222
A
111
<__main__.MyClass object at 0x000002AD34F1E1D0> 
__del__ 魔术方法(析构方法)
    触发时机:当对象被内存回收的时候自动触发[1.页面执行完毕回收所有变量 2.所有对象被del的时候]
    功能：对象使用完毕后资源回收
 参数：一个self接受对象
 返回值：无
1.执行完毕触发析构方法
class Del():
    def __init__(self,name):
        self.name = name

    def splitline(self):
        print('-----')

    def __del__(self):
        print('析构方法触发')

obj = Del('析构方法测试')
# 1.执行完毕触发析构方法
print('--程序执行完毕--')

# 执行结果
--程序执行完毕--
析构方法触发

　2.所有对象被del后触发

class Del():
    def __init__(self,name):
        self.name = name

    def splitline(self):
        print('-----')

    def __del__(self):
        print('析构方法触发')

obj1 = Del('析构方法测试')
print('--程序执行完毕start--')
obj2 = obj1
del obj1
del obj2 # 此处不执行del则在最后触发析构方法
print('--程序执行完毕end--')

　3.例：文件读取操作（应用）

class ReadFile():
    def __new__(cls,filename):
        if os.path.exists(filename):
            return object.__new__(cls)
        return print("改文件不存在")
            
    def __init__(self,filename):
        self.fp = open(filename,mode="r",encoding="utf-8")
        
    def readcontent(self):
        res = self.fp.read()
        return res
        
    def __del__(self):
        self.fp.close()

obj = ReadFile("ceshi111.txt")
res = obj.readcontent()
print(res)
__call__ 魔术方法
'''
    触发时机：把对象当作函数调用的时候自动触发
 功能: 模拟函数化操作
 参数: 参数不固定,至少一个self参数
 返回值: 看需求
'''
# 统一调用
class MyClass():
    def __call__(self,task):
        print("统一调用{}".format(task))
        self.step1()
        self.step2()
        self.step3()
    def step1(self):
        print(111)
    def step2(self):
        print(222)
    def step3(self):
        print(333)

obj = MyClass()
obj('test')

# 执行结果
统一调用test
111
222
333 
__str__ 魔术方法
'''
    触发时机: 使用print(对象)或者str(对象)的时候触发
 功能:     查看对象
 参数:     一个self接受当前对象
 返回值:   必须返回字符串类型
'''
class MyClass():
    attra = 'attra'
    def __init__(self,name):
        self.name = name
    def info(self):
        return "测试属性{},测试名称{}".format(self.attra,self.name)
    def __str__(self):
        return self.info()

obj = MyClass("test")
# 打印时触发
print(obj) # 没有__str__时 ：<__main__.MyClass object at 0x000001F1DEACA208>
print(obj) # 有__str__时 ：测试属性attra,测试名称test 
__repr__ 魔术方法
'''
    触发时机: 使用repr(对象)的时候触发
 功能:     查看对象,与魔术方法__str__相似
 参数:     一个self接受当前对象
 返回值:   必须返回字符串类型
'''
class MyClass():
    attra = "attra"
    def __init__(self,name):
        self.name = name
    def info(self):
        return "属性{}，名称{}".format(self.attra,self.name)
    def __repr__(self):
        return self.info()
    # 系统底层自动添加下面语句
    __str__ = __repr__

obj = MyClass("test")
print(obj)
print(str(obj)) 
----普通变量的基本操作,如果应用在对象上,也有相应的魔术方法
​
__bool__ 魔术方法
'''
 触发时机：使用bool(对象)的时候自动触发
 功能：强转对象
 参数：一个self接受当前对象
 返回值：必须是布尔类型
'''
class MyClass():
    def __bool__(self):
        return False 
        
# 实例化对象
obj = MyClass()        
res = bool(obj)
print(res)
'''
类似的还有如下等等(了解):
 __complex__(self)     被complex强转对象时调用
 __int__(self)         被int强转对象时调用
 __float__(self)       被float强转对象时调用
 ...
 ...
'''
__add__ 魔术方法  (与之相关的__radd__ 反向加法)
'''
    触发时机：使用对象进行运算相加的时候自动触发
 功能：对象运算
 参数：二个对象参数
 返回值：运算后的值
'''
class MyClass():
    def __init__(self,num):
        self.num = num
        
    # 当对象在+加号的左侧时,自动触发;
    def __add__(self,other):
        return self.num * 2 + other
        
    # 当对象在+加号的右侧时,自动触发
    def __radd__(self,other):
        return self.num * 3 + other

a = MyClass(3)
# self 接收到 a ,other 接收到 1 self.num * 2 + 1 = 3 * 2 +1 = 7
res = a+1
print(res)


b = MyClass(5)
# 第一次参数永远接受的是对象,self接收的 b ,other 接受的是 2 => 5 * 3 + 2 => 17
res = 2 + b
print(res)

 


'''
类似的还有如下等等(了解):
 __sub__(self, other)           定义减法的行为：-
 __mul__(self, other)           定义乘法的行为：
 __truediv__(self, other)       定义真除法的行为：/
 ...
 ...
'''
__len__ 魔术方法
'''
    触发时机：使用len(对象)的时候自动触发 
 功能：用于检测对象中或者类中某个内容的个数
 参数：一个self接受当前对象
 返回值：必须返回整型
'''
# 计算类中的成员个数
class MyClass():
    pty1 = 1
    __pty2 = 2
    pty3 = 3
    
    def func1(self):
        pass
    
    def func2(self):
        pass
        
    def __func3(self):
        pass
        
    def __len__(self):
        dic = MyClass.__dict__
        """
        lst = []        
        for i in dic:
            if not( i.startswith("__") and i.endswith("__") ):
                lst.append(i)
        """
        lst = [i for i in dic if not( i.startswith("__") and i.endswith("__") )]
        return len(lst)

obj =  MyClass()
print(len(obj))
'''
类似的还有如下等等(了解):
 __iter__(self)                 定义迭代容器中的元素的行为
 __reversed__(self)             定义当被 reversed() 调用时的行为
 __contains__(self, item)       定义当使用成员测试运算符（in 或 not in）时的行为
 ...
 ...
''' 

反射

 概念：通过字符串去操作类对象 或者 模块中的属性方法
 (1)类中的反射
hasattr() 检测对象/类是否有指定的成员
getattr() 获取对象/类成员的值
setattr() 设置对象/类成员的值
delattr() 删除对象/类成员的值

 (2)模块的反射
sys.modules 返回一个系统字典,字典的键是加载的所有模块

class Myclass():
    attra = '属性a'
    __attrb = "私有属性b"
    def methoda():
        print("普通方法")
    def methodb(self):
        print("绑定方法")
    def __methodc(self):
        print("私有方法")

obj = Myclass()
# 1.hasattr() 检测对象/类是否有指定的成员
print(hasattr(obj,"attra"))
print(hasattr(Myclass,'attra'))

# 2.getarrt() 获取对象/类成员的值
print(getattr(obj,"attra"))
getattr(obj,"methodb")()

# 3.setarrt() 设置对象/类成员的值
setattr(obj,"attrc","属性c")
print(obj.attrc)

# 4.delattr() 删除对象/类成员的值
delattr(obj,"attrc")

 

转载于:https://www.cnblogs.com/wangzihong/p/11297496.html

相关文章：

  • leetcode 337. House Robber III
  • Durandal入门
  • js中使用EL表达式总结
  • leetcode 309. Best Time to Buy and Sell Stock with Cooldown
  • 环境变量
  • 手机端和网页端使用同一后台时进行会话控制
  • SpringBoot起步
  • 获取当前python 解释器的路径=.=
  • $.proxy和$.extend
  • Java Web 开发必须掌握的三个技术：Token、Cookie、Session
  • springBoot测试
  • SpringBoot传参方式
  • Springboot项目自动加载设置
  • SpringBoot项目打包
  • Win10修改字体
  • 【159天】尚学堂高琪Java300集视频精华笔记（128）
  • 【译】React性能工程(下) -- 深入研究React性能调试
  • 2017届校招提前批面试回顾
  • CentOS从零开始部署Nodejs项目
  • crontab执行失败的多种原因
  • Docker下部署自己的LNMP工作环境
  • FineReport中如何实现自动滚屏效果
  • Fundebug计费标准解释：事件数是如何定义的？
  • HTML5新特性总结
  • JavaScript服务器推送技术之 WebSocket
  • Java教程_软件开发基础
  • JS变量作用域
  • JS正则表达式精简教程（JavaScript RegExp 对象）
  • js中forEach回调同异步问题
  • Linux Process Manage
  • Material Design
  • NLPIR语义挖掘平台推动行业大数据应用服务
  • oldjun 检测网站的经验
  • php面试题 汇集2
  • Redux系列x：源码分析
  • vue数据传递--我有特殊的实现技巧
  • 包装类对象
  • 规范化安全开发 KOA 手脚架
  • 诡异！React stopPropagation失灵
  • 精彩代码 vue.js
  • 前端工程化（Gulp、Webpack）-webpack
  • 微信小程序设置上一页数据
  • 主流的CSS水平和垂直居中技术大全
  • mysql面试题分组并合并列
  • # C++之functional库用法整理
  • #我与Java虚拟机的故事#连载15：完整阅读的第一本技术书籍
  • $(document).ready(function(){}), $().ready(function(){})和$(function(){})三者区别
  • （51单片机）第五章-A/D和D/A工作原理-A/D
  • （Redis使用系列） Springboot 使用redis的List数据结构实现简单的排队功能场景 九
  • （剑指Offer）面试题34：丑数
  • （三） diretfbrc详解
  • （学习日记）2024.01.19
  • （学习日记）2024.02.29：UCOSIII第二节
  • （学习日记）2024.03.12：UCOSIII第十四节：时基列表
  • (原创) cocos2dx使用Curl连接网络(客户端)