Python之面向对象

yolo2016

于 2023-01-13 18:53:19 发布

阅读量457

点赞数 1

分类专栏： Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/yolo2016/article/details/128678192

版权

Python 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

Python之面向对象

基本概念

面向过程面向对象
对象的特征技能
属性方法
类：对象的抽象 1 类的本质是一个用来存放变量与函数的容器 2 类的用途之一就是当做容器从其内部去取出名字来使用 3 类的用途之二是调用来的产生对象对象没有独立的属性，用的是类的属性和方法

class Teacher:
    #相同的属性/特征
    name='Tony'
    age=18
    sex='M'

    #函数、方法  技能
    def course(self):
        print('course')

print(Teacher.__dict__)
print(Teacher.age)

#修改属性
Teacher.name='Andy'
#添加属性
Teacher.play="basketball"
print(Teacher.__dict__)
#删除属性
del Teacher.play
print(Teacher.__dict__)

对象没有独立的属性，用的是类的属性和方法

生成对象 init方法

#生成对象 __init__方法
class Teacher:
    school='SZU'
    #相同的属性/特征
    def __init__(self,name,age,sex):
        self.name=name
        self.age = age
        self.sex = sex

    #函数、方法  技能
    def course(self):
        #self就是对象
        #是哪个对象调用的self的方法，传入的self就是那个对象
        #self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
        print(self,type(self),id(self))
        print('course')

#属性查找优先找对象，没有去类里面找

t=Teacher("Andy",18,"man")
print(t,type(t),id(t))
t.course()

在这里插入图片描述

self绑定对象的方法

绑定方法的精髓在于自动传值
特性：绑定给谁就应该由谁来调用，谁来调用就会将谁作为第一个参数自动传入。
绑定方法
绑定给对象方法
在类内部定义的函数（没有被任何装饰器修饰的），默认就是绑定给对象用的
绑定给类的方法
在类内部定义的函数如果被装饰器@classmethod装饰
则绑定给类的应该由类来调用，类来调用就自动将类作为第一个参数自动传入

一切皆对象

class Student:
    school='ShenZhenUniversity'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def ziwojieshao(self):
        name=self.name
        age=self.age
        sex=self.sex
        height=170
        print(self,type(self))
        print(f"My name is {name},I am {age} and {sex}")
        print(f"My name is {self.name},I am {self.age} and {self.sex},my height is {height}")

    @classmethod
    def say(self):
        print('You can say hello')
    @staticmethod
    def jump():
        print('Jump jump jump')


yolo=Student('yolo',30,'M')
yolo.ziwojieshao()
yolo.jump()
print(yolo.__dict__)
print('#####')
print(type(Student),id(Student))
print(type(yolo),id(yolo))

print('#####')
Student.say()
Student.jump()

继承

子类可以遗传重用父类的属性和方法


'''
A.mro()查看继承类关系
广度优先级

'''


class People:
    school='szu'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

#子类派生的两种方法
class Student(People):
    def __init__(self,name,age,sex,score):
        # People.__init__(self,name,age,sex) #不用必须继承父类
        # super(Student,self).__init__(name,age,sex)#必须基层父类
        super().__init__(name, age, sex)  # 必须基层父类
        self.score=score
    def play(self):
        print('%s play football'%self.name)


# yolo=Student('yolo',30,'Male',99)
# yolo.play()
# print(yolo)

组合

'''
组合
 组合指的是某一个对象拥有一个属性，该属性的值是另外一个类的对象
为何要组合
  通过为摸一个对象添加属性（属性的值是另外一个类的对象）的方式，可以间接
  将两个类关联/整合/组合到一起，从而减少类与类之间的代码冗余。
  
如何用组合
 
'''
class Foo:
    xxx=100
class Bar:
    yyy=200
    def zzz(self):
        print('Bar')

obj=Foo()
obj1=Bar()
obj.attr=obj1
#把obj1对象添加到obj的属性里面，这样obj能调用obj1的属性和方法
# print(obj.xxx)
# print(obj.__dict__)
# print(obj.attr.yyy)
# obj.attr.zzz()

多态

'''
多态
    同一事物的不同形态
多态性：在多态的背景下，可以在不考虑对象具体类型的前提下而直接使用对象
    多态的精髓在于统一


'''
class Animal:
    def speak(self):
        print("我是动物我会说话")
class People(Animal):
    def speak(self):
        print("say,hello")
class Dog(Animal):
    def speak(self):
        print("wang wang wang")
class Ping(Animal):
    def speak(self):
        print('heng heng heng')

# obj2=Animal()
# obj2.speak()
# obj=People()
# obj.speak()

常用的魔法方法

'''
常用的魔法方法
__str__ 在对象被打印时自动触发，可以用来定义对象被打印时的输出信息
__del__在对象被删除时先自动触发该方法，可以用来回收对象以外其他相关资源，比如系统资源
__call__在对象被调用的时候会自动触发该方法
'''

class People:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __str__(self):
        return 'name%s  age%s'%(self.name,self.age)
# obj=People('yolo',20)
# print(obj)

class Foo:
    def __init__(self,x,filepath,encoding='utf-8'):
        self.x=x
        self.f=open(filepath,'rt',encoding=encoding)
    def __del__(self):
        self.f.close() #回收对象关联的其他资源
# obj=Foo(1,'a.txt')

class People2:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def __call__(self, *args, **kwargs):
        print(self,args,kwargs)

# obj3=People2(1,2)
# print(obj3)
# obj3(1,2,a=123)
# obj3.__call__(obj3,1,2,a=123)

封装

'''
封装
如何封装
  在类的定义的属性前加上__
  只是语法意义上的变形
封装是在定义类阶段进行的，在外面是无法进行封装

封装数据属性：将数据属性隐藏起来，类外就无法直接操作属性，怎么间接使用？
需要类开辟一个接口来外部的使用，可以间接的操作属性，可以在接口内定义任意的控制逻辑，从而严格控制使用对属性的操作
'''


class Foo:
    x=111
    __y=222
    def __init__(self,name):
        self.name=name

    def func(self):
        print("func...")
    def __fun1(self):
        print("__func1...")

print(Foo.__dict__)
# Foo.__y #无法访问
print(Foo._Foo__y)
Foo.__z=333
print(Foo.__dict__)


class People:
    def __init__(self,name,age):
        self.__name=name
        self.__age=age
    def tell_info(self):
        print(f" {self.__name}   {self.__age}")
    def set_info(self,name,age):
        if type(name) is not str:
            print("name must be string type")
            return
        if type(age) is not int:
            print("age must be int type")
            return
        self.__name=name
        self.__age=age
obj=People('yolo',30)
obj.tell_info()
obj.set_info('yolo',22) #修改属性
obj.tell_info()
# 封装函数属性  隔离复杂度  间接的访问一些使用者不需要知道的方法
class ATM:
    def __card(self):
        print("插卡")
    def __auth(self):
        print("认证")
    def __input(self):
        print("输入金额")
    def __print_bill(self):
        print("打印账单")
    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()

obj=ATM()
obj.withdraw()

#把方法封装成属性 @property  BMI

反射

反射  通过字符串来反射/映射到对象/类的属性上

hasattr(obj,name)  
getattr(obj,name)     #获取对象的属性
setattr(obj,name,'dahai')  #修改对象的属性,不存在，就增加
delatrr(obj,name)
    
反射方法应用
if hsattr(self,cmd):
    method=getattr(self,cmd)
    method()

单例模式

'''
单例模式

'''
class Mysql:
    __instance=None
    def __init__(self,ip,port):
        self.ip=ip
        self.port=port

    @classmethod
    def from_conf(cls):
        print("类绑定方法")
        if cls.__instance is None:
            cls.__instance=cls('127.0.0.1',1234)
        return cls.__instance

obj=Mysql.from_conf()
print(obj.__dict__,obj.port)

元类

'''
元类
 一切皆对象，而对象是由类实例化得到的
#推理  元类 type
关系 
 调用元类--》自定义的类
 调用自定义的类---》自定义的对象

type元类创建自定义的类
exec() #arg1 代码放到字符串里面 arg2 全局的字典， arg3 是局部字典

yolo2016

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Python之面向对象

面向过程面向对象对象的特征技能属性方法类：对象的抽象 1 类的本质是一个用来存放变量与函数的容器 2 类的用途之一就是当做容器从其内部去取出名字来使用 3 类的用途之二是调用来的产生对象对象没有独立的属性，用的是类的属性和方法对象没有独立的属性，用的是类的属性和方法。
复制链接

扫一扫