Python面向对象

spiritx

已于 2023-10-26 22:19:56 修改

阅读量80

点赞数

分类专栏： Python实用教程文章标签： python 开发语言

于 2023-08-20 23:06:23 首次发布

本文链接：https://blog.csdn.net/spiritx/article/details/132388429

版权

Python实用教程专栏收录该内容

28 篇文章 5 订阅

订阅专栏

Python实用教程_spiritx的博客-CSDN博客

Python3从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。

如果以前没有接触过面向对象的编程语言，可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于学习Python的面向对象编程。

面向对象技术简介

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

和其它编程语言相比，Python 在尽可能不增加新的语法和语义的情况下加入了类机制。

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

对象可以包含任意数量和类型的数据。

类的定义

在Python中，采用类（class）来生产对象，用类来规定对象的属性和方法！也就是说，在Python中，要想得到对象，必须先有类！在Python中，对象是指现实中的一个具体的实体，而既然现实中的实体都有一个类别，所以，OOP中的对象也都应该有一个类！

一个对象的所有应该具有特征特性信息，都是由其所属的类来决定的，但是每个对象又可以具有不同的特征特性信息，

比如，我自己（人类）这个对象，名字叫老王，性别男，会写代码，会教书；另一个对象（人类）可能叫赵薇，性别女，会演戏，会唱歌！

类对象支持两种操作：属性引用和实例化。

属性引用使用和 Python 中所有的属性引用一样的标准语法：obj.name。

类对象创建后，类命名空间中所有的命名都是有效属性名。

使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾:

class ClassName:
   '类的帮助信息'   #类文档字符串
   class_suite  #类体由类成员，方法，数据属性组成。

类的实例化就是通过类得到对象！基本语法如下：

对象名= 类()

class MyClass:
    """一个简单的类实例"""
    ivar = 12345
    def foo(self):
        return 'hello world'
 
# 实例化类
myclass = MyClass()
 
# 访问类的属性和方法
print("MyClass 类的属性 ivar 为：", myclass.ivar)
print("MyClass 类的方法 foo 输出为：", myclass.foo())

‘’'
MyClass 类的属性 ivar 为： 12345
MyClass 类的方法 foo 输出为： hello world
‘''

类的属性定义

属性即是特征，比如：人的姓名、年龄、身高、体重…都是对象的属性。

对象属性既可以在类外面添加和获取，也能在类里面添加和获取。

对象属性从内部通过

self.属性名

来获得，从外部要通过对象名获得：

对象名.属性名

类的私有属性定义

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法定义

在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
# 实例化类
p = people('runoob',10,30)
p.speak()

‘’'
runoob 说: 我 10 岁。
‘''

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定使用 self。

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用，不能在类的外部调用。self.__private_methods。

init()

在python的类中，有一类方法，这类方法以两个下划线开头和两个下划线结尾，并且在满足某个特定条件的情况下，会自动调用。这类方法，称为魔法方法。

类有一个名为 __init__() 的魔法方法（构造方法），该方法在类实例化时会自动调用，像下面这样：

def __init__(self):
    类变量的初始化

__init__()除了第一个参数外，其他参数可以用来初始化属性。

类定义了 __init__() 方法，类的实例化操作会自动调用 __init__() 方法。如下实例化类 MyClass，对应的 __init__() 方法就会被调用:

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

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

class Test:
    def prt(self):
        print(self)
        print(self.__class__)
 
t = Test()
t.prt()

‘’'
<__main__.Test instance at 0x100771878>
__main__.Test
‘''

从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的:

class Test:
    def prt(runoob):
        print(runoob)
        print(runoob.__class__)
 
t = Test()
t.prt()

‘’'
<__main__.Test instance at 0x100771878>
__main__.Test
‘''

静态方法

在开发时，如果需要在类中封装一个方法，这个方法：

① 既不需要访问实例属性或者调用实例方法

② 也不需要访问类属性或者调用类方法

这个时候，可以把这个方法封装成一个静态方法，基本语法是：

@staticmethod

def 静态方法名(参数列表)

方法体

静态方法需要用修饰器 "@staticmethod" 来标识，告诉解释器这是一个静态方法。

通过类名.调用静态方法来调用

类和实例

类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响。以Dog类为例，类就像一个对象工厂，可以生产一个或多个实例对象。

>>> class Dog(object):
...     pass
...
>>> Dog
<class '__main__.Dog'>

>>> dog = Dog()
>>> dog
<__main__.Dog object at 0x10cd194a8>

>>> dog2 = Dog()
>>> dog2
<__main__.Dog object at 0x10cd19518>

实例方法、类方法、静态方法

实例方法是一个普通的函数，类方法和静态方法都是通过函数装饰器的方式实现的；

实例方法需要传入self，类方法需要传入cls参数，静态方法无需传入self参数或者是cls参数（但不等同于不能传入参数）

实例方法需要传入self，类方法需要传入cls参数，静态方法无需传入self参数或者是cls参数。

class MyClass(object):
    # 实例方法
    def instance_method(self):
        print('instance method called', self)

    # 类方法
    @classmethod
    def class_method(cls):
        print('class method called', cls)

    # 静态方法
    @staticmethod
    def static_method():
        print('static method called')

实例方法，self参数指向的是实例化出的实例对象。
类方法，cls参数指向的是一开始定义的类对象，不是实例对象。
静态方法，调用时并不需要传递类或者实例，不会与类或者实例绑定。

当调用实例方法(instance method)时，self参数指向的是刚刚实例化出的my_class实例对象。

当调用类方法(class method)时，cls参数指向的是一开始定义的MyClass类对象（注意不是实例对象）。

当调用静态方法(static method)时，只是调用了一个方法，不与类对象和实例对象相关。

注意：不管self参数，还是cls参数，都是一种约定俗成的用法，其实是可以使用其他的参数名代替。但是不建议使用其他参数名，毕竟代码不是只是写给自己看的。

类的继承

派生类的定义如下所示:

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>

子类（派生类 DerivedClassName）会继承父类（基类 BaseClassName）的属性和方法。

BaseClassName（实例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:

class DerivedClassName(modname.BaseClassName):

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()

‘’'
ken 说: 我 10 岁了，我在读 3 年级
‘''

继承可以分为：

单继承：如果一个类只有一个父类，把这种继承关系成为单继承
多继承：如果一个类有多个父类，把这种关系称为多继承
多层继承： C--> B -->A. C继承自B继承自A
重写：子类定义和父类名字相同的方法

super()

子类如果要引用父类，可以通过super()来引用

class Dog():
    def __init__(self,name):
        self.age = 0
        self.name = name
    def bark(self):
        print('汪汪汪-汪汪汪')

    def __str__(self):
        return f"{self.name } 的年龄是: {self.age} 岁"

#XTQ继承类Dog
class XTQ(Dog) :
    #如果子类重写了父类的__init__方法，在子类中需要手动调用父类的init方法，给对象添加父类继承的属性
    def __init__(self,name,color):
        super().__init__(name) #引用父类的构建方法
        self.color = color

    def __str__(self):
        return f"{self.name } 的年龄是: {self.age} 岁，它是 {self.color} 色的"

    def bark(self):
        print('嗷嗷嗷-嗷嗷嗷')

    
xtq = XTQ('aga','灰')

多继承

Python同样有限的支持多继承形式。多继承的类定义形如下例:

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索即方法在子类中未找到时，从左到右查找父类中是否包含方法。

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中参数位置排前父类的方法

‘’’
我叫 Tim，我是一个演说家，我演讲的主题是 Python
’‘’

方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法，实例如下：

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

‘’’
调用子类方法
调用父类方法
’‘’

super() 函数是用于调用父类(超类)的一个方法。

运算符重载

Python同样支持运算符重载，我们可以对类的专有方法进行重载，python中的类的运算符重载都是通过对应的魔法方法来实现的。

多态

在需要使用父类对象的地方，也可以使用子类对象，就是多态

#1。定义Dog类
class Dog(object):
    def __init__(self,name):
        self.name = name

    def play(self):
        print(f"小狗狗 {self.name} 在玩耍呀……")
        
#2。定义啸天犬类，继承Dog类
class XTQ(Dog):
    #子类重写play方法
    def play(self):
        print(f"神狗 {self.name} 在天上踩云彩。。。")
        
#4。定义一个共同的方法，调用子类和父类同名的方法
def play_with_dog(obj_dog):
    obj_dog.play()
    
#创建Dog类对西那个
dog = Dog('黄黄')
play_with_dog(dog)
#创建一个XTQ类的对象
xtq = XTQ('阿花')
play_with_dog(xtq)

可调用对象

如果对象实现了__call()__的魔法方法，可以使对象和函数一样，具有返回值，具有__call()__函数的对象是一个可调用对象，这是对象的一个重要属性，后面很多场景会用到。

并且call除第一个参数为self外，后续可以有任意的其他参数，也可以没有，语法格式如下：

__call__(self)

__call__(self, *args, **kwargs)

class Call(object):
	def test(self):
		print(1)

	def __init__(self):
		print("我是构造函数！ ")

	def __call__(self):
		print("当把本类实例化并作为函数调用时 自动调用本方法")

c = Call()
c() #调用

class TestCall(object):
    def __init__(self, name):
        self.name = name
 
    def __call__(self, *args, **kwargs):
        print("self.name: %s. " % self.name, end='   ')
        print('__call__()  is  running ')
 
if __name__ == '__main__':
    call = TestCall(name='xiaoming')
    
    ##可以直接使用call()函数，相当于调用了__call__()函数
    call()  # call.__call__()
 
    call.__call__()

class Adder:
    def __init__(self, value=0):
        self.data = value
 
    def __call__(self, x):
        return self.data + x
 
add = Adder()
print(add(1)) # 1
print(add(2)) # 2

class Adder:
    def __init__(self, value=0):
        self.data = value
        print("data in init is:{}".format(self.data))
    def __call__(self, x,y):
        print("In call,x is {},y is {}".format(x,y))
        return self.data + x+y
add = Adder()
print(add(1,3))
print(add(2,4))

spiritx

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Python面向对象

类(Class):用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。类中定义的函数。类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。类变量或者实例变量用于处理类及其实例对象的相关的数据。如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。定义在方法中的变量，只作用于当前实例的类。
复制链接

扫一扫