Python面向对象的总结以及类和正则表达式的详细解释

时间：2021-08-25 来源：互联网编辑：宝哥软件园浏览：次

Python3 面向对象

一丶面向对象技术简介

Class):用于描述具有相同属性和方法的对象集合。它定义集合中每个对象共有的属性和方法。对象是类的实例。方法：类中定义的函数。类变量：类变量在整个实例化对象中是通用的。类变量在类中和函数体外部定义。类变量通常不用作实例变量。数据成员：类变量或实例变量用于处理类及其实例对象的相关数据。方法覆盖：如果从父类继承的方法不能满足子类的需要，可以被覆盖。这个过程称为方法重写，也称为方法重写。局部变量：方法中定义的变量，只作用于当前实例的类。实例变量：在类的声明中，属性由变量表示。这种变量称为实例变量，在类声明中声明，但在类的其他成员方法之外声明。继承：派生类继承基类的字段和方法。继承还允许将派生类的对象视为基类对象。例如，有一种设计，其中Dog类型的对象是从Animal类派生的，它模拟了“is an (is-a)”的关系(在插图中，Dog是一种动物)。实例化：创建一个类的实例，一个类的具体对象。对象：由类定义的数据结构的实例。对象包括两个数据成员(类变量和实例变量)和方法。

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

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

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

1.带下划线的变量的特征

类中的方法实际上是类中的函数，可以分为实例方法、类方法和静态方法。方法和字段一样，都是类的属性，所以在操作时也有修改的特殊效果，但一般不建议这样做。

在类的基本语法中，我引入了构造函数方法：_ _ _ init _ _，_ _ _ new _ __;解构方法：_ _ _ del _ _；

请注意，虽然它以两个下划线(_ _)开头，但它同时以两个下划线(_ _)结尾，这表明它是一个“神奇的方法”。课堂上将对魔术方法进行讲解。

然而，如果你简单地从两个下划线开始，它仍然意味着私有化。请参见代码示例：

class test(object): def _ _ scolia _ _(self): #一个神奇的方法，它不是私有化的返回‘scolia’def _ _ good(self): #私有方法返回‘good’a=test()print a . _ _ scolia _ _()#神奇的方法可以访问print a.__good() #私有方法不能直接访问它。类似地，就像油田私有化一样，我们可以用特殊手段来实施。

打印a._Test__good() #强制访问

当然，私有方法也可以在类内部访问，就像私有字段一样。

因此，属性的私有化会混淆访问门户，同样，不建议强制访问私有属性。

可能这里的‘魔法法’好像不是‘魔法’，具体细节后面会解释。

示例方法：

在__init__构造函数中，提到它是一个实例方法，实例方法的特点是：

1.方法的第一个参数必须是self。当然，这是一种常规的写作方式。你可以用abc替换self，但是为了让其他程序员理解，统一使用self。在这里，self代表实例本身，也就是说，如果我在实例化时使用：a=Test()，那么self代表实例a，我们可以在很多构造函数中看到self.scolia='good '这样的写法。事实上，这种写法与类外的a.scolia='good '对于添加属性的效果相同，只是__init__方法是一个实例。

2.当实例方法被调用时，self被自动传递，所以我们不需要再次处理它。

3.只有在有实例的情况下才能调用实例方法，当然也有特殊的调用方法。

代码示例：

class test(object): def _ _ init _ _(self，a，b) : #构造函数在创建实例时初始化属性。自我。a=int (a) self。b=int(b)defaubc(self，C): #实例方法print self.a self.b int(c) #因为self是自动传递的，我们可以调用实例的属性a=Test(123，321) #我们只需要为a和b传递参数a.abc(666) #同样，只要C在这里传递参数，就会引入一个绑定(。

首先，我们知道方法是类的属性，而不是实例的属性。在上一篇博文中，我们还在类的属性和实例的属性中讨论了这个问题。

其次，一个方法只有在它的类有实例的情况下才能被调用。当一个类的实例存在时，一个方法被认为绑定到这个实例。当没有实例时，方法是未绑定的。

最后，任何方法定义的第一个参数是变量self，它表示调用此方法的实例对象。

显然，这里的绑定是例如方法。因为如果没有实例，self就不能传递，会导致参数不足，所以不能调用。

然而，我们可以通过自己传递来调用未绑定的方法。调用未绑定的方法通常意味着在我们继承父类之后，我们会覆盖父类中的一个方法，但是为了实现代码重用，我们希望在子类中调用父类的方法。简单地复制父类中的代码显然不是一个好的选择。除了浪费系统资源之外，还可能存在复制错误，将来修改父类的代码后，修改对应子类的代码效率太低。这是调用未绑定方法的场景。

代码示例：

类ABC(对象):def _ _ init _ _(自身，a) :self。a=-int (a)类测试(ABC) :def _ _ init _ _ (self，a，b) :abc。_ _ init _ _ (self，a)并手动传递selfself。b=b deffang fa(self): print self。一个自我。b #属性a由父类的构造函数创建，b由子类a=Test(123，321)的构造函数创建#我们只创建了子类的一个实例。如果不创建父类的实例a.fangfa()，我们就不能在不创建父类实例的情况下调用父类的实例方法，但是我们可以通过手动传递实例方法所需的self参数来实现调用。

这里的顺序是我们创建了一个Test的实例，它的自身是自动传递的。因此，在Test的构造方法__init__(self，A，b)中，self代表实例A，我们称之为abc。父类的__init__(self，A)，其中self是子类的实例A，参数A是我们传递的123，而在父类中，self。最后，我们可以在子类的方法中调用属性self.a。

2.Python面向对象的三大特性

一、继承

面向对象中的继承是指被继承的类直接拥有被继承类的属性，而不必在自己的类体中重写，其中被继承的类称为父类和基类，被继承的类称为派生类和子类。在python3中，如果不指定继承哪个类，默认情况下将继承Object类，继承Object类的类称为新类。在python2中，如果不指定继承哪个类，默认情况下不会继承Object类，但是不继承Object类的类称为经典类。经典类和新类的区别在于方法的搜索顺序不同。经典类是深度优先，即先找到自己的类。如果找不到，请在左侧找到第一个父类。如果没有找到，继续从这个父类的父类中找到，然后在左边找到第二个父类。然后重复前面的过程，直到所有的家长都再次找到它，如果找不到就报错；而新类则是广度优先，当下一个类可以被其他类找到的时候，它不会先找，而是在继承关系中找到与其子类同级别的其他类，以此类推，直到最终找到对象类，找不到指定的方法，才会报错。新的类别搜索顺序如下所示。您还可以通过类名查看新类继承中的属性搜索顺序。mro()

二、单继承与多继承

在其他语言中，只支持单一继承，即类名(父类名)，而python支持多重继承，多个父类之间用逗号分隔，即类名(父类名1，父类名2，)

三、继承与抽象

抽象化是提取一类事物的共同特征，而继承是取父类的属性并有自己的属性。抽象意味着包容的范围越来越大，共性越来越少，而继承意味着包容的回报越来越小，共性越来越多。定义父类的过程是抽象，定义子类的过程是继承。

四、父类方法重写

，我们调用有子类但没有父子类的方法作为子类的派生方法，而有子类的方法也有子类作为父方法的重写，因为根据类方法的搜索顺序，如果一个方法存在于子类中，那么它就不会在父类中被发现，这样一来，父类中的方法就不能被调用。如果想在父类中执行方法，同时在子类中定义新的函数，就需要从父类中单独继承这个方法。在python中，我们只能使用父类名和方法名(自身，父类的其他参数)。在python3中，我们可以使用super函数，例如super()。父类方法名(除self之外的其他参数)。实际上，我们需要在super函数中传入子类名称和子类对象(在类中使用self)，但在使用时不需要特意传递。请注意，当继承父类方法时，父类的参数不仅需要在父类的方法中传递，还需要在子类重写的方法中传递

class Animal : def _ _ init _ _(self，name，life_value，aggr): self . name=name self . life_value=life _ value self . aggr=aggr def eat(self): self . life _ value=10 class Person(Animal): def _ _ init _ _(self，money，name，life _ value，aggr): super()。__init__(名称，life_value，aggr) self.money=money def攻击(self，obj): obj . life _ value-=self . aggr

五、接口类

接口类用于规范子类方法名的定义。从接口类继承的子类没有任何逻辑关系，但是都需要实现一些常用的方法。为了统一这些子类的方法名称，使它们在以后调用这些方法时不需要关注特定的对象，子类一旦继承了接口类中定义的方法，就必须实现这些方法，否则在实例化子类时会报错，而接口类本身不需要实现。

从abc导入abcdmeta，abcdmethod类Payment(metaclass=abcdmethod): @ abcdmethod def pay(self，Money) : pass类微信pay (payment) : defpay (self，money) : #子类必须定义接口类中的方法，否则实例化会报错。pass w1=微信公众号()

六、抽象类

抽象类与接口类功能相同。一般只有继承它的子类才有一些逻辑关系，抽象类中的方法是可以实现的。子类在重写时可以用超函数调用抽象类的方法。同时，它们在使用抽象类时使用单继承，在使用接口类时使用多继承

七、多态

多态意味着不同的对象可以调用同一个方法，得到不同的结果，类似于接口类的感觉。多态性在python中无处不在，例如，无论您是列表、字符串还是数字，都可以使用和*。

八、封装

封装是将类中的属性和方法定义为私有的。方法是在属性名或方法名前添加双下划线。一旦以这种方式定义了属性或方法名，python会自动将其转换为_ class name _ _ attribute name(方法名)的格式。在类内部调用时，应该添加带双下划线的属性名或方法名。在类外调用时，应该使用父类的_类名_ _属性名(方法名)私有属性和方法，子类不能修改它们。

property property decorator:类中的方法的调用方式与属性相同，这个decorator也有与之匹配的setter和deleter。

class Demo : @ property def P(self): print(' property func ')@ P . setter def P(self，Num): print(' property _ setter ')@ P . deleteref P(self): print(' deleting ')D=Demo()D . P . D . P=10 del . D . P-。

Staticmethod静态方法装饰器：将类中的方法更改为普通函数，或将类外的函数作为方法调用放入类中

Class a: @ static方法defsum () : #这个方法和普通函数没什么区别。用类名-print(' static method ')a . sum()#调用。无法操作对象属性class a : role=' maly ' @ class method defsum(cls): #来操作类属性print(cls.role)A.sum() #调用类型为类名-。

A:类pass class B(A): pass B=B()print(is instance(B，B))print(isinstance(b，A)) print (type (b)是b) print (type (b)是A-。

九、类的装饰器

hasattr(对象或类名，‘属性或方法名’)判断指定的属性或方法是否存在于指定的对象或类中，并返回True

Getattr(对象或类名，‘属性或方法名’)获取对象或类的指定属性值或方法的内存地址

Setattr(对象或类名、“新属性名”、新属性值)向对象或类添加新属性或方法

Delattr(对象或类名，“新属性名”)删除以前添加的属性

十、isinstance和type的区别以及issubclass

__doc__:输出类描述信息

__module__:指示当前操作的对象在哪个模块中。

_ _ class _ _ _:表示当前操作的对象的类是什么

__dict__:查看类或对象调用中的所有成员类，以打印类的所有属性，不包括实例属性。实例调用打印所有实例属性

__str__打印格式%s输出此方法的值

__repr__ print format %r输出此方法的值，当没有__str__方法时，%s输出此方法的值。__del__ del执行此方法。__getitem__采用对象加[]的值

class a : def _ _ init _ _(self)3360 self。name=[' egon '，' Alex '，' EVA'] #可以是其他序列def _ _ getitem _ _ (self，item) :print (self。名称[项目])

A=A(A)[1]-亚历克斯

_ _ setitem _ _ add value _ _ delivery _ _ delete value _ _ new _ _用于创建没有属性的对象。您可以调用对象的__new__而无需自己实现它。这个方法可以用来实现带有括号的singleton pattern __call__ object来执行这个方法__len__ len()来执行这个方法_ _ eq _==来计算和输出这个方法的值

__hash__ hash执行此方法

两个代码实现(三维向量类)

类别Vecter3: def __init__(self，x=0，y=0，z=0): self。X=x自我。Y=y自我。Z=z def __add__(self，n): r=Vecter 3(). r . X=self。X n.X r.Y=自我。Y n . Y r . Z=自我。Z n.Z return r def __sub__(self，n): r=Vecter3() r.X=self。X-n . X . r . Y=自我。Y-n . Y . r . Z=自我。Z - n.Z返回r def __mul__(self，n): r=Vecter3() r.X=self。X * n r.Y=自我。Y * n r.Z=自我。Z * n return r def __truediv__(self，n): r=Vecter 3(). r . X=self。X/n r.Y=自我。Y/n r.Z=自我。Z/n返回r def __floordiv__(self，n): r=Vecter 3(). r . X=self。X //n r.Y=自我。Y //n r.Z=自我。Z //n返回r def show(self): print((self。x，自我。是的，赛尔夫。z))v1=vector 3(1，2，3)v2=vector 3(4，5，6)v3=v1v2 v3 . show()v4=v1-v2 v4 . show()V5=v1 * 3 V5 . show()V6=v1/2 V6 . show()。

跑步后是

三种代码实现(程序类)

这个程序是用正则表达式匹配类编写的，可以删除重复的英文并输出。输入这是我的名字

导入重分类Good: def __init__(self，n): self . n=n def love(self): S1=re . split(r ' '，self.n) s2=sorted(set(s1)，Key=s1.index) print (s2) b=good('这是我的名字')#您可以在这里输入字符串b.love()。

接下来，让我们看看运行结果