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

python-面向对象

目录

面向对象

封装

继承

重写

 重载

多态

单下划线、双下划线、头尾双下划线说明:


面向对象

  • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  • 数据成员:类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
  • 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
  • 局部变量:定义在方法中的变量,只作用于当前实例的类。
  • 实例变量:在类的声明中,属性是用变量来表示的。这种变量就称为实例变量,是在类声明的内部但是在类的其他成员方法之外声明的。
  • 继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。
  • 实例化:创建一个类的实例,类的具体对象。
  • 方法:类中定义的函数。
  • 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

# 创建类  Stuent是类名 包含name和age两个属性
class Stuent:
    name=None
    age=0

# stu是Stuent类变量,也就是对象
stu=Stuent()

#通过对象引用类属性
stu.age=18
stu.name="张三"

print("stu.name ",{stu.name },"stu.age",{stu.age})

成员方法

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

  • self 代表类的实例,self 在定义类的方法时是必须有的,但是调用时不必传入相应的参数。

  • self 代表的是类的实例,代表当前对象的地址,而 self.__class__ 则指向类,通过self可以调用类的属性
  • self 不是 python 关键字,我们把它换成其他变量也是可以正常执行的

# Student类包括两个成员属性 name和age,还包括一个成员方法
class Student:
    name=None
    age=0
    def printf(self,name,age):
       print(self)
       self.name=name
       self. age=age
       print("name ", {self.name}, "age", {self.age},"self.__class__",self.__class__)

stu=Student()
stu.printf("张三",18)

构造方法

 __init__()方法是一种特殊的方法,被称为类的构造函数或初始化方法,当创建了这个类的实例时就会调用该方法

python里一个class不可以定义多个构造函数,一个class只能有一个用于构造对象的__init__函数,这时,可以使用不定长参数接收多个参数

析构函数 __del__ ,__del__在对象销毁的时候被调用,当对象不再被使用时,__del__方法运行


# Student类包括两个成员属性 name和age,还包括一个成员方法
class Student:
    name=None
    age=0
    # 成员方法
    def printf(self):
       print(self)
       print("name ", {self.name}, "age", {self.age},"self.__class__",self.__class__)
    # 构造方法
    def __init__(self,name,age):
        self.name=name
        self.age=age

stu=Student("张三",18)   #创建对象 调用构造方法
stu.printf()

 内置方法

一个类中,包含了多种内置方法,实现了不同的功能,称为魔术方法

1、字符串转换:控制类对象的转化

正常打印类对象时,得到的是类变量的内存地址

 str方法:返回自定义字符串,执行此类对象的print方法,自动调用str方法

# Student类包括两个成员属性 name和age,还包括一个成员方法
class Student:
    name=None
    age=0
    # 成员方法
    def printf(self):
       print(self)
       print("name ", {self.name}, "age", {self.age},"self.__class__",self.__class__)
    # 构造方法
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return f"Student变量: name={self.name},age={self.age}"
stu=Student("张三",18)   #创建对象 调用构造方法
print(stu)

 2、lt:小于比较

直接对两个类对象,进行比较是不可以的。要通过lt方法制定比较规则


# Student类包括两个成员属性 name和age,还包括一个成员方法
class Student:
    name=None
    age=0
    # 构造方法
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return f"Student变量: name={self.name},age={self.age}"
    def __lt__(self, other):
        return self.age<other.age

stu=Student("张三",18)   #创建对象 调用构造方法
stu1=Student("张三",18)   #创建对象 调用构造方法
print(stu<stu1)


3、le:小于等于比较


# Student类包括两个成员属性 name和age,还包括一个成员方法
class Student:
    name=None
    age=0
    # 构造方法
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return f"Student变量: name={self.name},age={self.age}"
    def __le__(self, other):
        return self.age<=other.age

stu=Student("张三",18)   #创建对象 调用构造方法
stu1=Student("张三",18)   #创建对象 调用构造方法
print(stu<=stu1)


4、eq方法:判断是否相等

不重写eq方法,默认比较的是两个对象的内存地址,肯定不相等


# Student类包括两个成员属性 name和age,还包括一个成员方法
class Student:
    name=None
    age=0
    # 构造方法
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return f"Student变量: name={self.name},age={self.age}"
    def __eq__(self, other):
        return self.name==other.name

stu=Student("张三",10)   #创建对象 调用构造方法
stu1=Student("张三",18)   #创建对象 调用构造方法
print(stu==stu1)


关系运算是比较2个对象,包括:

关系运算含义
__lt__X<Y
__gt__X>Y
__le__X<=Y
__ge__X>=Y
__eq__X==Y
__ne__X!=Y
__cmp__比较X和Y,用于sorted,返回值是-1,1,0

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

封装

封装:将现实中的事物转化为类

私有属性,只可以在类中被使用,在其余地方都无法使用


class Student:
    __age=10  #age是私有变量
    __name="张三"  #name是私有变量
    def __printf(self): #私有方法 对象不可以调用此方法
        print("name ", {self.__name}, "age", {self.__age})
    def init(self):  #公开方法
        self.__printf()
stu=Student()
stu.init()

继承

子类继承父类,得到父类的公开属性

python支持多继承:一个子类可以继承多个父类,如果多个父类中包含了同名属性,以左侧的父类为准

class Aniaml:
    name=None
    __age=0
    def eat(self):
        print(self.name+"正在吃东西")

#Bird类继承了Aniaml父类,得到了Aniaml类的公开属性
class Bird (Aniaml):
    def fly(self):
        print("鸟在飞")


bird =Bird()
bird.name="糖豆"
bird.fly()
bird.eat()

在python中继承中的一些特点:


  1. 子类不重写 __init__,实例化子类时,会自动调用父类定义的 __init__。
  2. 子类重写了__init__ 时,实例化子类,就不会调用父类已经定义的 __init__
  3. 子类重写了__init__ 时,要使用父类的构造方法,可以使用 super 关键字,语法:super(子类,self).__ init __(参数);也可以使用如下格式调用:父类名.__init__(self, 参数列表

这里和java不一样的是,java是子类先帮父类构造,如果父类只包含无参的构造方法,创建子类对象会自动先调用父类无参的构造方法,如果父类存在包含参数的构造方法,就要使用super关键字显示调用


class A:
    age=0
    def __init__(self,*args):
        self.age=args[0]
        print("父类A的有参构造方法",{self.age})
        print("离开父类的有参构造方法")

class B (A):
    def __init__(self,age):
       print("子类B的构造方法")
       super(B, self).__init__(age)
       print("离开子类B")

class C(B,A):  #这里不是A,B这样的传参顺序,是因为B类继承了A类,如果是A,B顺序,先创建A对象,创建B对象也会创建A对象,python不允许这样
    def __init__(self, age):
        super(C, self).__init__(age)
        print("子类C的构造方法")
        print("离开子类C")
C(10)

  • 2、Python 总是首先查找对应类型的方法,如果它不能在派生类中找到对应的方法,它才开始到基类中逐个查找。(先在本类中查找调用的方法,找不到才去基类中找)

重写

子类可以对父类方法重写,调用时执行重写后的方法


class Aniaml:
    name=None
    __age=0
    def eat(self):
        print(self.name+"正在吃东西")

#Bird类继承了Aniaml父类,得到了Aniaml类的公开属性
class Bird (Aniaml):
    def fly(self):
        print("鸟在飞")

    def eat(self):  #对父类的这个方法进行重写
        print("有一只鸟正在吃东西")

bird =Bird()
bird.fly()
bird.eat()

 super关键字:在子类中调用父类属性

super().成员变量

super().成员方法()

 重载

Python 是一种动态语言,不需要声明变量类型。该函数可以接受任何类型的参数,因此不支持根据参数类型进行重载。但是可以支持运算符重载

python支持运算符如下:

 


class A:
    def __init__(self,x,y):
        self.x=x
        self.y=y

    def __str__(self):
        return  f"x={self.x},y={self.y}"
    def __sub__(self, other):
        return A(self.x-other.x,self.y-other.y)
a=A(1,2)
b=A(3,6)
print(a.__sub__(b))   # 1-3=-2   2-6=-4

多态

在完成某一个行为时,通过不同的对象,执行不同的方法

class AC:
    def ac(self):
        pass

pass关键字起到占位符的作用,ac方法没有方法体,pass是为了让ac方法符合语法规定添加的。

这样没有方法体的方法称为抽象方法,包含抽象方法的类就是抽象类

抽象类是要被继承的,子类要重写抽象父类的抽象方法


class AC:
    def ac(self):
        pass
class A (AC):
    def ac(self):
        print("A子类重写父类AC的ac方法")
class B (AC):
    def ac(self):
        print("B子类重写父类AC的ac方法")

def printf(tmp :AC):
    tmp.ac()
printf(A())
printf(B())

printf方法的执行,取决于参数tmp的实际类型

tmp是A类型,它实际上拥有自己的 ac()方法。调用 tmp.ac()总是先查找它自身的定义,如果没有定义,则顺着继承链向上查找,直到在某个父类中找到为止。

python是动态类型的语言,所以,传递给函数 printf(tmp)的参数tmp 不一定是 AC 或 AC 的子类型。任何数据类型的实例都可以,只要它有一个ac()的方法即可

单下划线、双下划线、头尾双下划线说明:

  • __foo__: 定义的是特殊方法,一般是系统定义名字 ,类似 __init__() 之类的。

  • _foo: 以单下划线开头的表示的是 protected 类型的变量,即保护类型只能允许其本身与子类进行访问,不能用于 from module import *

  • __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

相关文章:

  • 地方门户网站如何宣传/注册一个公司网站需要多少钱
  • 深圳建网站三千/百度升级最新版本下载安装
  • 群晖 wordpress外网/营销软文是什么意思
  • wordpress 添加视频/aso排名服务公司
  • 一起做网店的类似网站/做推广的都是怎么推
  • 毛片做暧小视频在线观看网站/如何网上免费做推广
  • 字符串位置的查询 - 指针
  • 【C++】STL——priority_queue的介绍和使用及模拟实现
  • NeurIPS'22 | APG:面向CTR预估的自适应参数生成网络
  • 【python绘制地图——folium实用功能进阶】
  • HTTPS协议的密钥交换流程
  • 钱为什么会贬值?
  • 2022年债券估值工具和方法
  • 5G核心网用户数据演进方案
  • 操作系统:输入输出系统 练习题(带有答案和解析)
  • [FireshellCTF2020]Caas
  • 位图详解.
  • 西瓜书-支持向量机