Python之面向对象编程

初识类

       类是用来描述具有相同属性和方法的对象的集合。对象是具体存在的，而类是一种抽象概念。在程序中遵循先定义类再调用类的顺序。类的名字是采用驼峰体的，类在定义阶段就会立刻执行类体内代码，将产生的名字存放在类的名称空间中，可以用__dict__查看类的名称空间，将以字典形式返回结果。

　　类分为父类和子类。父类又称为基类或超类，子类又称为派生类。类有两种属性：数据属性和函数属性（函数是没有被任何装饰器装饰的）。类的数据属性是直接对象所有共享的，类的函数属性是绑定给对象用的，绑定给不同的对象就是不同的绑定方法。

复制代码
class Student:
　　#定义私有属性，外部无法直接访问
    n=0
    #__init__()构造方法
　　 #self代表类的实例
　　 #def定义方法，类方法的第一个参数必须是用来代表类的实例的
    def __init__(self,name,age,gender):
        self.name=name#类对象的属性引用
        self.age=age
        self.gender=gender
        Student.n+=1

    school='红太阳'

    def learn(self):
       return '%s is learning'%self.name

#obj.class指向类
stu1=Student('aa',19,'female')#类对象的实例化
# print(stu1.n)
# print(stu1.learn)
# #<bound method Student.learn of <__main__.Student object at 0x000001BEFD188B38>>
# print(stu1.learn())

stu2=Student('bb',23,'male')
# print(stu2.n)
# print(stu2.learn)
# #<bound method Student.learn of <__main__.Student object at 0x000001BEFD188BA8>>

# print(id(Student.n),Student.n)
# print(id(stu1.n),stu1.n)
# print(id(stu2.n),stu2.n)
# #同id

# Student.n=1
# print(id(Student.n),Student.n)
# print(id(stu1.n),stu1.n)
# print(id(stu2.n),stu2.n)
#都随着Student.n变化而变

# stu1.n=1
# print(id(Student.n),Student.n)
# print(id(stu1.n),stu1.n)#1345678816 1
# print(id(stu2.n),stu2.n)
#只有stu1变化，其他都不变
复制代码

类的实例化就是调用类产生对象的过程，实例对象就是类的实例化的结果。对象除了共有的属性和方法之外，应该还有其特有的，这样类实例化结果的对象就不是一模一样的了。要使对象就有其特征，就要在类体内定义一个__init__函数，该函数在调用类时自动触发执行。

调用类的过程将发生三件事：

　　一是产生空对象；

　　二是自动触发类体内的__init__函数；

　　三是将空对象连同调用类时括号内的参数一起传给__init__函数。

类的使用：

　　1.必须遵循函数的参数规则

　　2.类中定义的函数主要是给对象使用的，而且是绑定到对象的。虽然所有对象的指向都是相同的功能，但是绑定到不同对象就是不同的绑定方法。绑定到对象的特殊之处就在于绑定谁就由谁调用，谁调用就将谁本身当做第一个参数（self）传给方法，即自动传值。

对象间的交互

复制代码
class Dog:
    def __init__(self,name,d_type,aggressivity,life_value):
        self.name=name
        self.d_type=d_type
        self.aggressivity=aggressivity
        self.life_value=life_value

    def bite(self,enemy):
        enemy.life_value-=self.aggressivity
        print('''
        狗[%s]咬人[%s]
        人掉血[%s]
        人的生命值还剩[%s]'''%(self.name,enemy.name,self.aggressivity,enemy.life_value))

dog1 = Dog('旺财', '中华田园犬', 50, 60)

class People:
    def __init__(self,name,aggressivity,life_value=100):
        self.name=name
        self.aggressivity=aggressivity
        self.life_value=life_value

    def bite(self,enemy):
        enemy.life_value -= self.aggressivity
        print('''
                人[%s]咬狗[%s]
                狗掉血[%s]
                狗的生命值还剩[%s]''' % (self.name, enemy.name, self.aggressivity, enemy.life_value))



people1=People('aa',30)
people1.bite(dog1)
复制代码

 

继承和派生

继承就是类与类之间的关系，是创建类的一种方式，继承的 目的就是减少代码冗余。子类会遗传父类的属性，子类可以继承一个或多个父类。

寻找继承关系需要先抽象再继承。

属性查找是现从子类自己查找，找不到再去父类查找。

派生就是子类定义 自己的新属性，如果是与父类的属性同名，以子类 自己的为准。在子类派生的 新方法中重用父类功能的方式：一是指名道姓地调用，这种方式与继承关系是无关的 ，与调用普通函数是一样的；二是通过执行super()得到返回值，该返回值是一个 特殊对象，该对象专门用来调用mro()列表从当前的查找位置往后查找下一个类的属性或方法。第二种方法是严格遵循继承关系的。

 组合

1.组合是什么？

组合是用于描述一个对象拥有的属性，该属性来自于另一个类。

2.组合怎么用？

封装

1.封装是什么？

封装从字面意思上看是隐藏，但是又与隐藏有所不同，封装是对外隐藏，对内公开。

封装数据属性：把数据属性封装起来，将需要的开辟接口给外部使用者用。其好处是添加控制逻辑，从而控制访问者对属性的操作，起到隔离复杂性的效果。

2.封装如何实现隐藏？

在属性名前面加__开头，但是不是以__结尾的

　3.封装要注意的三个点：

　　　　（1）为一个属性加__开头会在属性定义阶段将属性名变形，是一种语法上的变形

　　　　（2）这种语法上变形只在定义阶段发生一次，定义之后新增的属性即使是以__开头也不会变形

　　　　（3）如果父类不想属性被子类的覆盖就可以给该属性加__开头

多态

 1.多态是什么？

多态就是同一属性的多种形态

2.多态的特性？

可以在不考虑对象具体类型的前提下直接使用对象下的方法

3.使用多态的好处？

　　　　（1）增加程序的灵活性

　　　　（2）增加了程序的可扩展性

　　

鸭子类型

　　Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’

python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象

也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。

反射

通过字符串来操作类与对象的属性，这种操作称为反射；反射也是内置函数
下述四个函数是专门用来操作类与对象属性的
class People:
    country="China"
    def __init__(self,name):
        self.name=name
    def tell(self):
        print('%s is aaa' %self.name)
 
obj=People('egon')
1、hasattr
print(hasattr(People,'country')) #可用来操纵类 # print('country' in People.__dict__)
print(hasattr(obj,'name'))     #可用来操纵对象
print(hasattr(obj,'country'))
print(hasattr(obj,'tell'))
2、getattr
print(getattr(People,'country1',None))  #如果没有返回None；若不写，没有报错
f=getattr(obj,'tell',None)  #obj.tell
f() #obj.tell()
 
3、setattr
setattr(People,'x',111)   #People.x=111
print(People.x)
setattr(obj,"age",18)     #obj.age=18
print(obj.__dict__)
4、delattr
复制代码
delattr(People,"country")   #del People.country
print(People.__dict__)
delattr(obj,"name")           #del obj.name
print(obj.__dict__)
 
#用户用input输入了字符串形式的指令，可以被反射以操纵类和对象的属性
class Foo:
    def run(self):
        while True:
            cmd=input('cmd>>: ').strip()
            if hasattr(self,cmd):
                func=getattr(self,cmd)
                func()
 
    def download(self):
        print('download....')
 
    def upload(self):
        print('upload...')
 
obj=Foo()
obj.run()
复制代码
三、__str__方法
__xxx__是满足一定条件时自动触发
__str__ 当打印对象时自动触发，可用来定制打印格式
复制代码
class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
 
    def __str__(self):
        return '<名字：%s 年龄：%s 性别：%s>' %(self.name,self.age,self.sex)
 
obj=People('egon',18,'male')
print(obj) #print(obj.__str__())，若没有__str__，返回一个内存地址（原生状态）
 
l=list([1,2,3])
print(l)   #[1, 2, 3]， python帮忙优化的，否则返回一个内存地址
复制代码
四、__del__方法
__del__在删除对象时自动触发
复制代码
import time
class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
 
    def __del__(self): #在对象被删除的条件下，自动执行
        print('__del__')
 
obj=People('egon',18,'male')
del obj #obj.__del__()  #若没有这一行，睡2s后会自动触发__del__，因为程序结束前会删除对象（清除资源）
time.sleep(2)
复制代码
__del__的主要用途是回收系统资源
复制代码
class Mysql:
    def __init__(self,ip,port):
        self.ip=ip
        self.port=port
        self.conn=connect(ip,port) #申请系统资源， 此行为伪代码
    def __del__(self):
        self.conn.close()         #回收系统资源
 
obj=Mysql('1.1.1.1',3306)
 
class MyOpen:
    def __init__(self,filepath,mode="r",encoding="utf-8"):
        self.filepath=filepath
        self.mode=mode
        self.encoding=encoding
        self.fobj=open(filepath,mode=mode,encoding=encoding)
    def __str__(self):
        msg="""
        filepath:%s
        mode:%s
        encoding:%s
        """ %(self.filepath,self.mode,self.encoding)
        return msg
    def __del__(self):
        self.fobj.close()    #回收系统资源
 
f=MyOpen('aaa.py',mode='r',encoding='utf-8')
print(f.filepath,f.mode,f.encoding)
print(f)
print(f.fobj)
res=f.fobj.read()
print(res)
复制代码
以下四个皆为绑定对象的方法，在满足一定条件时，自动触发
__init__
__str__
__del__
__call__
 
posted @   桥前石头  阅读(205)  评论(0)  编辑  收藏  举报
编辑推荐：
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 记一次.NET内存居高不下排查解决与启示
· 探究高空视频全景AR技术的实现原理
· 理解Rust引用及其生命周期标识（上）
· 浏览器原生「磁吸」效果！Anchor Positioning 锚点定位神器解析
阅读排行：
· DeepSeek 开源周回顾「GitHub 热点速览」
· 物流快递公司核心技术能力-地址解析分单基础技术分享
· .NET 10首个预览版发布：重大改进与新特性概览！
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 单线程的Redis速度为什么快？
点击右上角即可分享
微信分享提示
AI FOR CODE 大赛