iis服务器助手广告广告
返回顶部
首页 > 资讯 > 后端开发 > Python >Python面向对象总结及类与正则表达式
  • 286
分享到

Python面向对象总结及类与正则表达式

面向对象正则表达式Python 2023-01-31 00:01:47 286人浏览 独家记忆

Python 官方文档:入门教程 => 点击学习

摘要

一丶面向对象技术简介 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 方法:类中定义的函数。 类变量:类变量在整个实例化的对象中是公用的。类变量定义在


一丶面向对象技术简介

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

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

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

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

1.类中带下划线开头的变量特点

     类中的方法,其实就是类中的函数,可以分为:实例方法,类方法,静态方法。方法和字段一样,也是属于类的属性,所以也具有运行中修改的特效, 但一般不推荐这样做。

  我在类的基本语法中,介绍了构造器方法:__init__ 、__new__;解构器方法:__del__;

  注意,这里虽然是以两个下划线(__)开头,但同时以两个下划线(__)结尾,这里表明其是一个‘魔法方法’,关于类中的魔法方法,将起一篇进行说明。

  但是,如果单纯只以两个下划线开始,则依然是私有化的意思,看代码示例:

复制代码
class Test(object):

    def __scolia__(self):   # 一个类似魔术方法,并不是私有化
        return 'scolia'

    def __Good(self):   # 私有方法
        return 'good'

a = Test()
print a.__scolia__()   # 魔法方法可以在直接访问
print a.__good()    # 私有方法不能直接访问
复制代码

 

  同样的,和字段私有化一样,我们也可能同特殊手段进行强制访问:

print a._Test__good()  # 强制访问

 

  当然,私有方法也可以在类的内部访问,和私有字段一样。

  所以说,属性的私有化都是对访问入口进行混淆,同样的,也不建议强制访问私有属性。

  也许这里的‘魔法方法’看起来并不‘魔法’,详情将以后解释。


实例方法:

  在 __init__ 构造器中,提起过其是一个实例方法,实例方法的特点就是:

  1.方法的第一个参数必须是 self,当然这是约定俗成的写法,你可以将 self 换成 abc 之类的,但是为了别的程序员能看得懂,还是统一用 self 吧。这里的 self 代表实例本身,也就是说如果我实例化时使用的是: a = Test() ,那么 self 就代表 a 这个实例,我们可以在很多构造器中看到类似 self.scolia = 'good' 的写法,其实这个写法和在类外面 a.scolia = 'good' 效果一样,是为了添加属性,只不过 __init__ 方法是实例化时自动调用的函数,所以适合进行初始属性的创建。

  2.实例方法在调用的时候,self 是自动传递的,所以不需要我们再处理。

  3.实例方法一般要有实例才能调用,当然也有特殊的调用方法。

代码示例:

复制代码
class Test(object):

    def __init__(self, a, b):   # 构造器在实例创建时进行属性的初始化
        self.a = int(a)
        self.b = int(b)

    def abc(self, c):  # 实例方法
        print self.a + self.b + int(c)  # 因为self是自动传递的,所以我们可以在实例方法中调用实例的属性

a = Test(123, 321)  # 我们只要为 a 和 b 传参就行了
a.abc(666)  # 同样的,只要为 c 传参
复制代码

 

  这里,将引入一个绑定 (binding) 的概念,其主要和方法的调用有关。

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

  其次,方法只有在其所属的类拥有实例时,才能被调用。当一个类存在实例后,方法才被认为是绑定到这个实例。没有实例的时候,方法是未绑定的。

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

  很明显这里的绑定针对的是实例方法。因为如果没有实例的话,self 就无法传递,这将导致参数的不足,当然就无法调用了。

  但是,我们可以自己传递 self 来调用未绑定的方法。调用未绑定的方法通常是在我们继承了一个父类后, 我们覆盖了父类中的某个方法,但是为了实现代码重用,我们又想在子类中调用父类的方法。单纯的复制父类中的代码明显不是一个好选择, 除了浪费系统资源之外,还有可能在复制的时候出错,而且以后修改父类的代码之后,还要修改相应子类中的代码,实在太低效,这个时候就是调用未绑定方法的场景。

代码示例:

复制代码
class abc(object):
    def __init__(self, a):
        self.a = -int(a)

class Test(abc):
    def __init__(self, a, b):
        abc.__init__(self, a)   # 调用父类的构造器,并手动传递 self
        self.b = b

    def fangfa(self):
        print self.a + self.b   # 属性 a 由父类的构造器创建,b 由子类构造器创建

a = Test(123, 321)  # 我们只创建了子类的实例,而没有创建父类的实例
a.fangfa()
复制代码

 

  本来我们没有创建父类的示例,是无法调用父类的实例方法的,但是我们手动传递了实例方法需要的 self 参数,就可以实现调用了。

  这里的顺序是,我们创建了 Test 的实例,其 self 是自动传递的,故 Test 的构造方法 __init__(self, a, b) 中 self 就代表实例 a,而我们又调用了父类的 abc.__init__(self, a) 这里的 self 就是子类的实例 a ,参数 a 就是我们传的 123,而父类中 self.a = -int(a) ;最后我们可在子类的方法中调用 self.a 这个属性。

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

一、继承

  面向对象中的继承就是继承的类直接拥有被继承类的属性而不需要在自己的类体中重新再写一遍,其中被继承的类叫做父类、基类,继承的类叫做派生类、子类。在python3中如果不指定继承哪个类,默认就会继承Object类,而继承了Object类的类就叫做新式类,而在python2中如果不指定继承哪个类也不会默认去继承Object类,而没有继承Object类的类就叫做经典类。经典类和新式类的不同就在于对方法的搜索顺序不同,经典类是深度优先即先找自己类内,如果没有就找左边第一个父类,没找到继续从这个父类的父类中找依次类推直到找到最上一级的父类也没找到再找左边第二个父类,然后再重复之前的过程,直到所有父类找一遍没找到就报错;而新式类是广度优先,当下一个类可以通过其他类找到时就先不去找它,而是找继承关系中与它的子类同级的其他类,依次类推直到最后找到object类没有找到指定方法就报错。新式类搜索顺序图示如下,还可以通过类名.mro()查看新式类继承中的属性搜索顺序

 

 二、单继承与多继承

  在其他语言中只支持单继承即class 类名(父类名),而python支持多继承,用逗号将多个父类隔开即class 类名(父类名1,父类名2,。。。。)

 

  三、继承与抽象

  抽象就是把一类事物的共有特性提取出来,继承则是把父类的属性拿过来并且还拥有自己的属性。抽象是包含的范围越来越大,共性越来越少,继承则是包含的返回越来越小,共性越来越多。我们定义父类的过程就是抽象,定义子类的过程就是继承。

 

 四、父类方法重写

 我们把子类有而父类没有的方法叫做子类的派生方法,而父类有子类也有的方法叫做对父类方法的重写,因为按照类方法的搜索顺序一个方法如果在子类中有就不会再从父类中找了,结果就是父类中的方法无法调用了,如果既想执行父类中的方法同时在子类中又能定义新功能,就需要先把父类中的这个方法单独继承过来,在python中只能使用父类名.方法名(self,父类的其他参数)的方式,在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__(name,life_value,aggr)
        self.money=money
    def attack(self,obj):
        obj.life_value-=self.aggr
复制代码

 

  五、接口类

   接口类是用于规范子类的方法名定义用的,继承接口类的子类可以不存在任何逻辑上的关系但是都需要实现某些共同的方法,为了让这些子类的方法名能够统一以便之后调用这些方法时不需要关注具体的对象就用接口类规范了这些方法的名字,子类一旦继承了接口类就必须实现接口类中定义的方法,否则在子类实例化的时候就会报错,而接口类本身则不需要实现去实现这些方法。

   

复制代码
 1 from abc import ABCMeta,abstractmethod
 2 class Payment(metaclass=ABCMeta):
 3     @abstractmethod
 4     def pay(self,money):pass
 5 
 6 class Wechatpay(Payment):
 7     def pay(self,money):  #子类中必须定义接口类中有的方法,否则实例化会报错
 8         pass
 9 
10 w1=Wechatpay()
复制代码

 

  六、抽象类

   抽象类的作用和接口类一样,只是继承它的子类一般存在一些逻辑上的关系,且抽象类中的方法可以去实现,子类在重写时用super函数调用抽象类的方法即可,同时在用抽象类时使用单继承,使用接口类时使用多继承

 

  七、多态

   多态就是不同的对象可以调用相同的方法然后得到不同的结果,有点类似接口类的感觉,在python中处处体现着多态,比如不管你是列表还是字符串还是数字都可以使用+和*。

 

  八、封装

  封装就是把类中的属性和方法定义为私有的,方法就是在属性名或方法名前加双下划线,而一旦这样定义了属性或方法名后,python会自动将其转换为_类名__属性名(方法名)的格式,在类的内部调用还是用双下划线加属性名或方法名,在类的外部调用就要用_类名__属性名(方法名)。父类的私有属性和方法,子类无法对其进行修改。

 

  九、类的装饰器 

  property属性装饰器:将类内的方法的调用方式和属性一样,这个装饰器还有和其配套的setter、deleter。

   

复制代码
class Demo:
    @property
    def p(self):
        print('property func')
    @p.setter
    def p(self,num):
        print('property_setter')
    @p.deleter
    def p(self):
        print('在删除')
d=Demo()
d.p  
d.p=10
del d.p
--------------------------------------------------------------------------------------
property func
property_setter
在删除
复制代码

 

   staticmethod静态方法装饰器:将类内的方法变成普通的函数,或者把类外的函数放到类内当作方法调用

   

复制代码
class A:
    @staticmethod
    def sum():   #这个方法跟普通函数没有区别
        print('staticmethod')
A.sum() #用类名调用
--------------------------------------------------------------------------------------
staticmethod
复制代码

  claSSMethod类方法装饰器:该方法用于操作类属性,无法操作对象属性

  

复制代码
class A:
    role='male'
    @classmethod
    def sum(cls):   #用于操作类属性
        print(cls.role)
A.sum() #用类名调用
--------------------------------------------------------------------------------------
male
复制代码

 

  十、isinstance和type的区别以及issubclass

   isinstance和type都可以用于判断对象和指定类间的关系,但是isinstance的判断没有type准确,它无法正确判断子类的对象和其父类的关系

   

复制代码
class A:
    pass
class B(A):
    pass

b=B()
print(isinstance(b,B))
print(isinstance(b,A))
print(type(b) is B)
print(type(b) is A)
--------------------------------------------------------------------------------------
True
True
True
False
复制代码

 

  issubclass用于判断给定的两个类,前者是否是后者的子类

 

  十一、反射

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

   getattr(对象或类名,'属性或方法名')  获取对象或类的指定属性值或方法的内存地址

   setattr(对象或类名,‘新属性名’,新属性值) 给对象或类添加新的属性或方法

   delattr(对象或类名,‘新属性名’) 删除之前添加的属性

 

  十二、类的内置方法

  __doc__ :输出类的描述信息

  __module__ :表示当前操作的对象在那个模块

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

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

  __str__ 格式化输出%s输出该方法的值

  __repr__  格式化输出%r输出该方法的值,并且%s在没有__str__方法时也是输出该方法的值
  __del__  del 执行该方法
  __getitem__  用对象加[]方式取值

  

复制代码
class A:
    def __init__(self):
        self.names=['egon','alex','eva'] #可以是其他序列
    def __getitem__(self, item):
        print(self.names[item])

a=A()
a[1]
----------------------------------------------------------
alex
复制代码

 


  __setitem__   添加值
  __delitem__  删除值
  __new__ 用于创建没有属性的对象,调用object的__new__即可不需要自己实现。可以利用该方法实现单例模式
  __call__ 对象加括号执行该方法
  __len__  len()执行该方法
  __eq__  ==运算输出该方法的值

  __hash__ hash执行该方法

 

二丶代码实现(三维向量类)

 

 1 class Vecter3:
 2     def __init__(self, x=0, y=0, z=0):
 3         self.X = x
 4         self.Y = y
 5         self.Z = z
 6     def __add__(self, n):
 7         r = Vecter3()
 8         r.X = self.X + n.X
 9         r.Y = self.Y + n.Y
10         r.Z = self.Z + n.Z
11         return r
12     def __sub__(self, n):
13         r = Vecter3()
14         r.X = self.X - n.X
15         r.Y = self.Y - n.Y
16         r.Z = self.Z - n.Z
17         return r
18     def __mul__(self, n):
19         r = Vecter3()
20         r.X = self.X * n
21         r.Y = self.Y * n
22         r.Z = self.Z * n
23         return r
24     def __truediv__(self, n):
25         r = Vecter3()
26         r.X = self.X / n
27         r.Y = self.Y / n
28         r.Z = self.Z / n
29         return r
30     def __floordiv__(self, n):
31         r = Vecter3()
32         r.X = self.X // n
33         r.Y = self.Y // n
34         r.Z = self.Z // n
35         return r
36     def show(self):
37         print((self.X,self.Y,self.Z))
38 
39 v1 = Vecter3(1,2,3)
40 
41 v2 = Vecter3(4,5,6)
42 
43 v3 = v1+v2
44 
45 v3.show()
46 
47 v4 = v1-v2
48 
49 v4.show()
50 
51 v5 = v1*3
52 
53 v5.show()
54 
55 v6 = v1/2
56 
57 v6.show()

此类可实现三维向量的加减乘除

运行后为

三丶代码实现(程序类)

这个程序运用类与正则表达式匹配来写,可以删除重复的英文并输出,这里输入 This is my name

import re
class 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('This is is my name')#此处可自行输入字符串
b.love()

接下来我们看运行结果

 

 

 

--结束END--

本文标题: Python面向对象总结及类与正则表达式

本文链接: https://www.lsjlt.com/news/181926.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑,方便收藏和打印~

下载Word文档
猜你喜欢
  • Python面向对象总结及类与正则表达式
    一丶面向对象技术简介 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 方法:类中定义的函数。 类变量:类变量在整个实例化的对象中是公用的。类变量定义在...
    99+
    2023-01-31
    面向对象 正则表达式 Python
  • Python正则表达式总结分享
    目录1. 正则表达式基础1.1. 简单介绍1.2. 数量词的贪婪模式与非贪婪模式1.3. 反斜杠的困扰1.4. 匹配模式2. re模块2.1. 开始使用re2.2. Match2.3...
    99+
    2024-04-02
  • python re 正则表达式学习总结
    # -*- coding: utf-8 -*- import re import os #------------------------------------- re(正则表达式)模块 ------------------------...
    99+
    2023-01-31
    正则表达式 python
  • python常用的正则表达式总结
    本篇内容介绍了“python常用的正则表达式总结”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!检验手机号码# 要求:手机号码必须为...
    99+
    2023-06-02
  • JavaScript RegExp(正则表达式) 对象
     JavaScript RegExp(正则表达式) 对象正则表达式是描述字符模式的对象。正则表达式用于在文本上执行模式匹配和“搜索和替换”功能。var patt = /JC2182/i示例说明:&nb...
    99+
    2023-06-03
  • Java 之正则表达式语法及常用正则表达式汇总
    正则表达式概念: 正则表达式,又称规则表达式。(英语:Regular Expression,在代码中常简写为 regex、regexp 或 RE),计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。 正则表...
    99+
    2023-08-18
    正则表达式 java 开发语言
  • C#正则表达式(Regex类)用法实例总结
    目录前言1.正则表达式的概念1.1正则表达式的组成1.1.1元字符是什么1.1.2定位元字符1.2三个括号1.3简化正则表达式1.4@符号的作用1.5正则表达式可以实现四种功能:2....
    99+
    2022-11-13
    c#正则表达式的用法 c# 正则式 C# 正则表达式
  • PostgreSQL模式匹配与正则表达式方法总结
    目录1.1 PostgreSQL中的模式匹配和正则表达式1.2 传统SQL的LIKE操作符1.3 SIMILAR TO正则表达式1.4 POSIX正则表达式1.5 模式匹配函数substring总结1.1 Postgre...
    99+
    2022-11-19
    postgresql模式匹配 postgresql正则表达式 pg正则
  • VBS正则表达式的语法总结
    本篇内容主要讲解“VBS正则表达式的语法总结”,感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷,实用性强。下面就让小编来带大家学习“VBS正则表达式的语法总结”吧!正则表达式语法一个正则表达式就是由普通字符(例如字符 a 到 z)以及特...
    99+
    2023-06-09
  • Python中使用正则表达式及正则表达式匹配规则详解
    目录1 导库2 使用模板3 说明4 示例5 正则表达式匹配规则1 导库 import re 2 使用模板 re_pattern = re.compile(pattern, flags...
    99+
    2023-03-22
    Python正则表达式匹配规则 Python正则表达式
  • Python正则表达式中的'r'用法总结
    目录Python正则表达式中的'r'一、Python字符串前面加'r'二、正则表达式匹配原理三、正则表达式前面加'r'总结Python...
    99+
    2023-05-18
    python正则表达式r python 正则表达 python 正则表达式
  • Python 类与对象简单理解及总结
    类:  类,指一群具有相同属性和方法的对象的抽象。  类的更严格的定义是由某种特定的元数据所组成的内聚的包。它描述了一些对象的行为规则,而这些对象就被称为该类的实例。类有接口和结构。接口描述了如何通过方法与类及其实例互操作,而结构描述了一个...
    99+
    2023-01-31
    对象 简单 Python
  • java正则表达式匹配规则超详细总结
    目录1 单个字符的匹配规则如下:2 多个字符的匹配规则如下:3 复杂匹配规则主要有:4 提取匹配的字符串子段5 非贪婪匹配6 替换和搜索6.1 分割字符串6.2 搜索字符串6.3 替...
    99+
    2024-04-02
  • Python进阶篇之正则表达式常用语法总结
    目录正则表达式概述1、点-匹配所有字符2、星号-重复匹配任意次3、加号-重复匹配多次4、 花括号-匹配指定次数5、 问号-贪婪模式和非贪婪模式6、方括号-匹配几个字符之一7、起始位置...
    99+
    2024-04-02
  • Python中怎么使用正则表达式及正则表达式匹配规则是什么
    1 导库import re2 使用模板re_pattern = re.compile(pattern, flags=0) result = re.findall(re_pattern,string)3 说明参数描述pattern匹配的正则表...
    99+
    2023-05-14
    Python
  • Python正则表达式的另类解答
    目录一、正则表达式的作用二、正则表达式基本符号三、Python自带正则表达式模块总结一、正则表达式的作用 提示:正则表达式是一段特殊的字符串,它表示的是一段有规律的信息。如果我们想从...
    99+
    2024-04-02
  • VBS中怎么创建正则表达式对象
    VBS中怎么创建正则表达式对象,相信很多没有经验的人对此束手无策,为此本文总结了问题出现的原因和解决方法,通过这篇文章希望你能解决这个问题。一直以来,我都是用 New RegExp 来创建正则表达式对象的: Set regex = New ...
    99+
    2023-06-08
  • Python正则表达式对象怎么解决相关问题
    本篇内容主要讲解“Python正则表达式对象怎么解决相关问题”,感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷,实用性强。下面就让小编来带大家学习“Python正则表达式对象怎么解决相关问题”吧!产生方式:通过re.compile(pa...
    99+
    2023-06-17
  • JAVA正则表达式及字符串的替换与分解相关知识总结
    JAVA正则表达式及字符串的替换与分解 Java 提供了 java.util.regex 包来与正则表达式进行模式匹配 java.util.regex 包主要包括以下三个类: Pat...
    99+
    2024-04-02
  • python中面向对象_类_对象的概念与
    1. 面向对象的概念,面向对象是一种编程思想。 是对现实世界中一类事物的抽象,在编程中可以理解为是一种建立现实世界事物的模型     2.  面向对象和面向过程的区别: 面向过程关注的是完成工作的步骤。 面向对象关注的是谁能完成工作。 面...
    99+
    2023-01-30
    面向对象 对象 概念
软考高级职称资格查询
编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
  • 官方手机版

  • 微信公众号

  • 商务合作