正则表达式，面向对象

正则表达式-re模块

正则表达式符号

' . ' 默认匹配除\n之外的任意一个字符
' ^ ' 匹配字符开头
' $ ' 匹配字符结尾
' * ' 匹配*号前的字符0次或多次
' + ' 匹配前一个字符1次或多次
' ? ' 匹配前一个字符1次或0次
'{m}' 匹配前一个字符m次
'{n,m}' 匹配前一个字符n到m次
' | ' 匹配|左或|右的字符，相当于或操作
'(...)' 分组匹配，将括弧里的内容当做整体同时作用
'\A' 只从字符开头匹配
'\Z' 匹配字符结尾，同$
'\d' 匹配数字，等效于[0-9]
'\D' 匹配非数字
'\w' 匹配[A-Za-z0-9]
'\W' 匹配非[A-Za-z0-9]
's' 匹配空白字符、\t、\n、\r

匹配语法

import re
re.match("匹配字符","总字符串") #从头开始匹配
re.search("匹配字符","总字符串") #匹配包含
re.findall("匹配字符","总字符串") #把所有匹配到的字符放到以列表中的元素返回
re.splitall("分割字符","总字符串") #以分割字符当做列表分隔符，将字符分割成列表
re.sub("匹配字符","替换字符","总字符串") #匹配字符并替换

面向对象

核心特征

Class 类

一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性（variables(data)）、共同的方法

Object 对象

一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同

Encapsulation 封装

在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

Inheritance 继承

一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

Polymorphism 多态

多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。

类的基本概念

构造函数，是一种特殊的方法。主要用来在创建对象时初始化对象，即为对象成员变量赋初始值
实例化，指在面向对象的编程中，把用类创建对象的过程称为实例化
析构函数，与构造函数相反，在实例释放销毁后执行，通常用于一些收尾工作，如关闭数据库，删除无用变量
私有方法/属性：python中定义私有变量只需要在变量名或函数名前加上 "__"两个下划线，那么这个函数或变量就会为私有的了，声明该方法为私有方法，不能在类的外部调用

class People(object):
    n = 123 #类变量，大家共用的属性，节省开销
    # 构造函数，在实例化时做初始化的一些工作
    def __init__(self,name,age,sex):
        # 实例变量，又称静态属性，作用域为实例本身
        self.name = name
        self.age = age
        self.__sex = sex#设定为私有属性，只可在内部访问
    
    def how_old(self): # 类的方法/功能，又称动态属性
        print("%s is %d years old" %(self.name,self.age))

p1 = People("zzh",23,"male")#实例化，生成一个对象p1
p1.how_old()#使用实例的方法
print(p1.n)#打印类变量

类的继承

class People(object):#新建People类
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def eat(self):
        print("%s is eating" %self.name)

    def sleep(self):
        print("%s is sleeping" % self.name)

class Man(People):#类的继承
    def strong(self):#新建方法
        print("%s is strong himself" %(self.name))

m1 = Man("zzh",22)#实例化对象
m1.eat()#继承父类的方法
m1.strong()#使用自己新建的方法

类的多态

一个接口，多种实现，多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name
    @staticmethod
    def func(obj):  # 一个接口，多种形态
        obj.talk()

class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' % self.name)

class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' % self.name)

c1 = Cat('小晴')#实例化Cat
d1 = Dog('李磊')#实例化Dog
Animal.func(c1)#多态的展示
Animal.func(d1)#一种接口多种实现

静态方法

通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法
普通的方法，可以在实例化后直接调用，并且在方法里可以通过self.调用实例变量或类变量，但静态方法是不可以访问实例变量或类变量的，一个不能访问实例变量和类变量的方法，其实相当于跟类本身已经没什么关系了，它与类唯一的关联就是需要通过类名来调用这个方法
换句话说，静态方法只是名义上归类管理，实际性就是个普通的方法

class Dog(object):
    def __init__(self, name):
        self.name = name

    @staticmethod #静态方法，它和类没有过多关联
    def eat(name, food):
        print("%s is eating %s" % (name, food))

d = Dog("huihui")#实例化
d.eat(d.name,"hambuger")#静态方法的调用

类方法

类方法通过@classmethod装饰器实现，类方法和普通方法的区别是，类方法只能访问类变量，不能访问实例变量

class Dog(object):
    food = "hambuger"#类变量
    name = "zzh"

    def __init__(self, name):
        self.name = name

    @classmethod #类方法
    def eat(self):#类方法只可访问类变量，不能访问实例变量
        print("%s is eating %s" % (self.name, self.food))

d = Dog("huihui")
Dog.eat()#类方法的调用，通过类名
#zzh is eating hambuger

属性方法

属性方法的作用就是通过@property把一个方法变成一个静态属性，隐藏实现细节
属性方法的应用场合，对用户而言，只是一个属性，但是对于开发者而言，背后却需要对应一系列的操作

class Dog(object):
    def __init__(self, name):
        self.name = name
        self.__food = None  # 私有属性

    @property  # 属性方法，将方法变成静态属性
    def eat(self):
        print("%s is eating %s" % (self.name,self.__food))

    @eat.setter  # 为属性方法进行赋值
    def eat(self, food):
        self.__food = food
        print("the food is", self.__food)

    @eat.deleter  # 设定del属性方法对应的操作
    def eat(self):
        self.__food = None

d = Dog("huihui")
d.eat  # 属性方法，像属性一样调用
d.eat = "hambuger"  # 通过赋值传入参数
del d.eat #调用属性方法的删除
d.eat#再次调用属性方法

#huihui is eating None
#the food is hambuger
#huihui is eating None

类的特殊成员方法

doc

__doc__用于获取类的描述信息

class Foo(object):
    """ 我是渣渣辉 """
    pass

print(Foo.__doc__)#打印类的描述信息
# 输出：我是渣渣辉

module 和 class

__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
首先，先新建一个lib的包，再在包中新建名为test的模块，类中包含一个名为A的类：

class A:
    def __init__(self):
        self.name = 'zzh'

再新建一个.py文件，进行测试：

from lib.test import A
obj = A()
print obj.__module__  # 输出 lib.aa，即：输出模块
print obj.__class__      # 输出 lib.aa.C，即：输出类

init

__init__ 为构造方法，通过类创建对象时，自动触发执行。用法见：类的基本概念

del

__del__为析构方法，当对象在内存中被释放时，自动触发执行。用法见：类的基本概念

call

常用的构造方法的执行是由创建对象触发的，即：对象 = 类名()
而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者类()()

class Foo(object):
    def __init__(self):
        pass 
    def __call__(self, *args, **kwargs):
        print '__call__'

obj = Foo() # 执行 __init__
obj()       # 执行 __call__

dict

__dict__ 用于查看类或对象中的所有成员，当用类调用该方法，则打印类里的所有属性，不包括实例属性；当用实例化的对象进行调用，则打印所有实例属性，不包括类属性

class Foo(object):
    def __init__(self):
        pass
print(Foo.__dict__)
##{'__module__': '__main__', '__init__': <functioncts>, '__weakref__': <attribute '__weakref__' of 'Foo' objects>

str

__str__ 如果一个类中定义了__str__方法，那么在打印对象时，默认输出该方法的返回值。

class Foo(object):
    def __str__(self):
        return "zzh"
a = Foo()
print(a)
#结果：zzh

参考资料：
https://www.cnblogs.com/alex3714/articles/5161349.html
https://docs.python.org/3.7/py-modindex.html

[Python5]正则表达式_面向对象

正则表达式-re模块

正则表达式符号

匹配语法

面向对象

核心特征

Class 类

Object 对象

Encapsulation 封装

Inheritance 继承

Polymorphism 多态

类的基本概念

类的继承

类的多态

静态方法

类方法

属性方法

类的特殊成员方法

doc

module 和 class

init

del

call

dict

str

感谢您的支持，我会继续努力的!

[Python5]正则表达式_面向对象

正则表达式-re模块

正则表达式符号

匹配语法

面向对象

核心特征

Class 类

Object 对象

Encapsulation 封装

Inheritance 继承

Polymorphism 多态

类的基本概念

类的继承

类的多态

静态方法

类方法

属性方法

类的特殊成员方法

__doc__

__module__ 和 __class__

__init__

__del__

__call__

__dict__

__str__

感谢您的支持，我会继续努力的!

doc

module 和 class

init

del

call

dict

str