面向对象编程

最新推荐文章于 2023-12-14 20:05:29 发布

sunz_dragon

最新推荐文章于 2023-12-14 20:05:29 发布

阅读量330

点赞数

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

本文链接：https://blog.csdn.net/weixin_43366181/article/details/127845792

版权

Python 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

类的基础语法

类的声明与定义

类体由类成员、方法、数据属性组成

class ClassName(bases_classes):
    '类文档字符串'
    class_suite     # 类体

类名ClassName，开头通常是大写
bases_classes表示这个类是由哪个类继承来的，如果没有合适的继承类，就使用object类
通过ClassName.__doc__查看类文档字符串

类的属性与实例化

类的数据属性

类的数据属性也可以称为静态变量，它通常用来跟踪与类相关的值

class DataProperty:
    theData = 10

类中还有很多特殊属性，具体如下:

ClassName.__name__：类ClassName的名字；
ClassName.__doc__：类ClassName的文档字符串；
ClassName.__bases__：类ClassName的所有父类构成的元组；
ClassName.__dict__：类ClassName的属性；
ClassName.__module__：类ClassName定义所在的模块；
Instance.__class__：实例Instance所对应的类。

类的方法

类中的方法一定要通过实例的句点方法去调用。

class  MethodExample:
    def theMethod(self):
        print("这是方法实例")
me = MethodExample()
me.theMethod()

类的实例化

在实例化一个对象后，Python 会检查是否实现了__init__()方法。如果没有实现__init__()方法，则不会做其它的操作，直接返回对象，实例化过程完毕。而__init__()方法是用来给类本身初始化的，支持带参数的初始化。

class Book:
    def __init__(self,bookname,price,author):
        self.bookname = bookname
        self.price = price
        self.author = author
    def sell(self):
        print("%s书本的价格为%d" %(self.bookname,int(self.price)))
book = Book("python","45","aas")
book.sell()

在上面的例子中，init()是解释器在创建一个实例后调用的第一个方法。有__int__，（两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。）可以在生成实例的时候，进行参数代入

绑定与方法调用

绑定方法

class bindExample:
    def bindMethod(self):
        print("绑定方法调用实例")
be = bindExample()
be.bindMethod()

非绑定方法

class bindExample:
    def bindMethod(self):
        print("非绑定方法调用实例")
be = bindExample()
bindExample.bindMethod(be)

静态方法与类方法

在声明静态方法的时候，使用函数修饰符@staticmethod
在声明类方法的时候，使用函数修饰符@classmethod

class ClassMethod:
	@staticmethod
    def statictest():
        print("这是静态函数")#静态函数可以直接调用
    @classmethod
    def classtest(cls):
        print(cls)
        print("这是类方法")#类方法需要依托实例
StaticMethood.statictest()
cm = ClassMethod()
cm.classtest()

类的导入

导入整个模块：import ModuleName，调用object = ModuleName.ClassName()
导入单个或多个类的语句为：from ModuleName import ClassName1,ClassName2,...，调用object = ClassName()
导入模块中所有的类：from ModuleName import *，调用object = ClassName()

类的继承

初识继承

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

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

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

覆盖方法

覆盖方法：在子类里再写一个与父类中一样的方法，实现自己想要实现的功能。
子类中调用父类方法：
Parent.sayHello(sc)
在重写了父类中的方法后，也可以调用父类中的被重写方法。使用super()函数。（super() 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。）
语法：super(type[, object-or-type])
Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替super(Class, self).xxx

super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类 FooChild 的对象转换为类 FooParent 的对象

从标准类派生

在 Python 中有6种标准数据类型，分别为：Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Sets（集合）和Dict（字典）。而根据内存中的内容是否可变，分为可变类型与不可变类型。其中，数字、字符串、元组和集合被称为不可变类型，列表和字典称为可变类型。

类的内建函数

参考链接

链接: 内建函数参考链接

# 请在下面填入判断subClass是否为parentClass的子类的代码，并输出结果
########## Begin ##########
print(issubclass(subClass,  parentClass))
########## End ##########
# 请在下面填入判断sc是否为subClass实例的代码，并输出结果
########## Begin ##########
print(isinstance(sc,subClass))
########## End ##########
# 请在下面填入判断实例sc是否包含一个属性为name的代码，并输出结果
########## Begin ##########
print(hasattr(sc,'name'))
########## End ##########
# 请在下面填入将sc的属性name的值设置为subclass的代码
########## Begin ##########
setattr(sc,'name','subclass')
########## End ##########
# 请在下面填入获取sc的属性name的值的代码，并输出结果
########## Begin ##########
print(getattr(sc,'name'))
########## End ##########
# 请在下面填入调用subClass的父类的tell()方法的代码
########## Begin ##########
super(subClass,self).tell()
########## End ##########

类的其他特性

类的私有化

双下划线

在 Python 中，可以在属性或方法前添加双下划线将其变为私有。
调用私有属性就在名字前加上单下划线和类名

class privatization(object):
    def __init__(self,var):
        self._var = var
        self.__var = var
        self.__var__ = var
        self.varation = var
pr = privatization(2)
print(pr._var)
print(pr.__var__)
print(pr.varation)
print(pr._privatization__var)#调用私有属性

单下划线

在一个模块中以单下划线开头的变量和函数被默认当做内部函数。当我们使用from module import *来导入模块时，这些不会被导入。但如果使用import module来导入整个模块，这部分还是会被导入，那么就可以用module.var来访问。
以双下划线开头和双下划线结尾的是一些特殊的方法。比如__init__()、__del__()等。

包装和授权

包装

包装就是对已存在对象的属性功能进行调整，删除不需要的、添加或是修改已存在的功能，以达到自己所理想的规格，并装换成另外一种更适合当前使用场合的对外接口。包装包括定义一个类，它的实例拥有标准类型的核心行为。

class Wrap(object):
    def __init__(self,obj):     # 声明了构造函数，模拟要包装对象的构造方法
        self.__obj = obj     # __obj就是这个被包装对象的核心
    def get(self):     # 获取__obj对象
        return self.__obj
    def __repr__(self):
        return 'self.__obj'
    def __str__(self):     # 转换__obj对象
        return str(self.__obj)
    def __getattr__(self,thelist):
        return getattr(self.__obj,thelist)

授权

授权是包装的一个特性，采用已存在的功能达到最大限度的代码重用。在包装中我们可以新建、修改或删除已有的功能，授权的过程就是将更新的功能交由新类来处理，已存在的功能就授权给对象的默认属性。

要实现授权，一定要覆盖__getattr__()方法。在代码里包含一个对getattr()内建函数的调用，调用getattr()得到默认对象的属性（数据属性或者方法）并返回它，以便于访问或者调用。

对象的销毁

增加引用计数

在 Python 中，当一个对象被创建时，就自动地创建了一个引用计数器。当引用计数加1时，增加对这个对象的引用，引用计数器也依次增加。例如：

x = 12
y = x
z = y

在这个例子中，语句x = 12创建了对象12并将这个对象赋值给了x。此时12的引用计数为1，语句y = x创建了一个指向对象12的别名y，计数为2，在语句z = y中又创建了一个别名，所以此时对象12的引用计数为3

对象的引用计数在下列情况下增加：

对象被创建时；
创建了另一个别名时；
被作为参数传递给函数时；
成为容器对象的一个元素时。

减少引用计数

当别名被重新赋值时，源对象的引用计数减1。例如：

var1 = "we"
var2 = var1
var1 = 12

在这个例子中，对象"we"赋值给了var1，引用为1，语句var2 = var1将对象的值又赋给了var2，引用为2。但在语句var1 = 12中，将对象12赋值给了var1，此时对象"we"的引用减1，12的引用加1。

对象的引用计数在下列情况下减少：

一个本地引用离开了其作用范围时，比如函数结束；
对象别名被销毁时；
对象本身被销毁时。

对象销毁

当对象的引用计数变为0时，它被垃圾回收。Python 中的垃圾回收机制可以处理两种情况，一种是引用为0，另一种是循环引用。循环引用是指两个对象互相引用，且都没有外部的对象对它们进行引用。例如：

class delObject:
    def __init__(self):
        self.var = 100
    def __del__(self):
        class_name = self.__class__.__name__
        print("对象%s销毁" %class_name)
do1 = delObject()
do2 = do1
do3 = do1
print(id(do1))
print(id(do2))
print(id(do3))
del(do1)
del(do2)
del(do3)

结果为：

2176419869752
2176419869752
2176419869752
对象delObject销毁

在这个例子中，__del__()为一个析构函数。当删除对象时，会调用本身的函数，在对象删除完毕时也会再次调用这个函数。