python编程之 re模块和面向对象基础

一、re模块

1. re.compile()

compile(正则表达式) - 编译正则表达式，创建正则表达式对象

re_obj = compile(r'\d{3}')

fullmatch(r'\d{3}', '234')
re_obj.fullmatch('234')

search(r'\d{3}', 'hu23hjk890jhkh78')
re_obj.search('hu23hjk890jhkh78')

2.匹配

1)fullmatch(正则表达式, 字符串)

让整个字符串和正则表达式进行匹配

2)match(正则表达式, 字符串)

匹配字符串开头
如果匹配不到结果是None,如果匹配成功了结果是匹配对象

re_str = r'\d{3}'
print(fullmatch(re_str, '732'))
print(fullmatch(re_str, '732hjas'))   # None
print(match(re_str, '789'))
print(match(re_str, '789j手机打开'))

# 设置同时忽略大小写和单行匹配
print(fullmatch(r'123.[a-z]{3}', '123\nHNA', flags=S|IGNORECASE))
print(fullmatch(r'(?is)123.[a-z]{3}', '123\nHNA'))

3.匹配对象

# result = match(re_str, '789j手机打开')
re_str = r'(\d{2})-([a-z]{3})'
result = match(re_str, '23-sjm回款及时发货')
print(result)

1)获取匹配到的字符串

# 匹配对象.group()   -  获取整个正则表达式匹配到结果
print(result.group())    # 23-sjm

# 匹配对象.group(分组号)  - 获取正则表达式中指定的分组匹配到的结果(分组号从1开始)
print(result.group(1))   # 23
print(result.group(2))   # sjm

2)获取匹配到的子串的范围

# 匹配对象.span()
print(result.span())     # (0, 6)
print(result.span(2))    # (3, 6)

3)获取原字符串

# 匹配对象.string
print(result.string)

4.查找

1）search(正则表达式,字符串)

在字符串中查找第一个能和正则表达式匹配的子串。如果找到了返回匹配对象，找不到返回None

2) findall(正则表达式,字符串)

获取字符串中所有满足正则表达式的子串。返回一个列表，列表中的元素是字符串

3) finditer(正则表达式,字符串)

获取字符串中所有满足正则表达式的子串。返回一个迭代器，迭代器中的元素是匹配对象

str1 = 'and123=hu123aaa456klk98!ll7hu123oop'
result = search(r'\d+', str1)
print(result)    # <re.Match object; span=(3, 6), match='123'>

result = findall(r'\d+', str1)
print(result)    # ['123', '123', '456', '98', '7', '123']

result = findall(r'\d+[a-z]', str1)
print(result)   # ['123a', '456k', '7h', '123o']

# findall正则中如果有分组，只获取分组匹配到的内容
result = findall(r'(\d+)[a-z]', str1)
print(result)     # ['123', '456', '7', '123']

result = findall(r'(\d+)([a-z])', str1)
print(result)   # [('123', 'a'), ('456', 'k'), ('7', 'h'), ('123', 'o')]

str2 = '9h3jabc===9k2mabc9293h0oabc==!!!'
result = findall(r'(\d[a-zA-Z]){2}abc', str2)
print(result)


result = finditer(r'((\d[a-zA-Z]){2})abc', str2)
# print(list(result))
for x in result:
    print(x.group(1))

5.切割

split(正则表达式, 字符串)

将字符串中能和正则表达式匹配的子串作为切割点，对字符串进行切割。返回值是列表，列表中的元素是字符串

split(正则表达式, 字符串, 次数)

指定切割次数

str1 = 'and123=hu123aaa456klk98!ll7hu123oop'
result = split(r'\d+', str1)
print(result)    # ['and', '=hu', 'aaa', 'klk', '!ll', 'hu', 'oop']

result = split(r'\d+', str1, 3)
print(result)     # ['and', '=hu', 'aaa', 'klk98!ll7hu123oop']

6.替换

sub(正则表达式, 字符串1, 字符串2)

将字符串2中能和正则表达式匹配的子串全部替换成字符串1

sub(正则表达式, 字符串1, 字符串2, 次数)

限制替换次数

str1 = 'and123=hu123aaa456klk98!ll7hu123oop'
new_str1 = sub(r'\d+', '+', str1)
print(new_str1)

sentence = '你丫是傻 叉吗? 我操你大爷的. F u c k you.'
re_str = r'(?i)[操肏艹草曹]|f\s*u\s*c\s*k|s\s*h\s*i\s*t|傻\s*[比屄逼叉缺吊屌]|煞\s*笔'
new_sentence = sub(re_str, '*', sentence)
print(new_sentence)

二、类和对象

1.什么是类、什么是对象

类就是拥有相同属性和相同功能的对象的集合（抽象）
对象就是类的实例(具体)

从生活的角度：
如果人是类， 余婷就是对象，骆老师是另一个对象
如果杯子是类，我桌上的这个杯子就是对象

2.定义类(说清楚共同属性和功能是哪些)

语法：
class 类名:
类的说明文档
类的内容(包含属性和方法)

说明：
class - 关键字
类名 - 程序员自己命名
要求：标识符,不能是关键字
规范：驼峰式命名，并且首字母大写;见名知义；不适用系统的函数名、类名、模块名
类的说明文档 - 用""""""引起来的说明性文字，主要说清楚类提供了哪些属性和哪些功能
类的内容 - 主要包含属性和方法(定义在类中的函数叫方法)

# PEP8命名规范
student_name = '张三'
# 驼峰式命名
studentName = '李四'


# 定义一个人类
class Human:
    """人类"""
    def eat(self):
        print('人类在吃饭')

    def sleep(self):
        print('人类睡觉！')


class Servant:
    """佣人类"""
    def wash(self):
        print('洗衣服')

    def cook(self, food):
        print(f'做{food}')

3.定义对象(创建对象)

语法：
类名()

说明:
类名 - 是已经定义好的类的类名

p1 = Human()    # 创建人类的对象p1
p2 = Human()
print(p1)
print(p2)

s1 = Servant()  # 创建佣人类的对象s1
print(s1)
s2 = Servant()

s1.wash()
s2.wash()
s1.cook('面条')
s2.cook('包子')

三、方法

1.方法（定义在类中函数）

类中的方法分为三种：对象方法、类方法、静态方法

1)对象方法

怎么定义：直接定义在类中函数就是对象方法
特点：自带参数self(self在通过对象调用的时候不用传参, 系统会自动将当前对象传给self)，谁调用指向谁
怎么调用：用对象去调用(对象.方法名())

2)类方法

怎么定义: 定义函数前加装饰器 @classmethod
特点：自带参数cls(cls在通过类调用的时候不用传参，系统会自动将当前类传给cls)
怎么调用：用类调用(类.方法名())

3)静态方法

怎么定义: 定义函数前加装饰器 @staticmethod
特点：没有默认参数
怎么调用：用类调用

4)对象方法、类方法和静态方法怎么选：

如果实现函数的功能需要用到对象的属性，就选对象方法

class Dog:
    # eat是对象方法
    def eat(self):
        # self = dog1
        print(f'self:{self}')
        print('狗啃骨头')

    # count是类方法
    @classmethod
    def count(cls):
        # Dog能做的cls都能做
        print(f'cls:{cls}')
        dog2 = Dog()
        dog3 = cls()
        print(dog2, dog3)
        print('狗的数量是: 100')

    @classmethod
    def func(cls):
        print('类方法')

    #  func2是静态方法
    @staticmethod
    def func2():
        print('静态方法')


# 创建对象
dog1 = Dog()
print(f'dog1:{dog1}')

# 用对象调用对象方法
dog1.eat()

# 用类调用类方法
Dog.count()

# 用类调用静态方法
Dog.func2()

print('=========================注意：======================')
# 从本质上讲，类中的所有的方法都可以用对象和类调用，但是不能这么做
Dog.eat(12)    # 如果用类调用对象方法，self就会变成普通的参数，没有存在的价值

dog1 = Dog()
dog1.count()   # 用对象调用类方法的时候cls指向的还是类(不会指向对象)

dog1.func2()
Dog.func2()

四、init方法

1.构造方法

构造方法: 函数名和类名是一样的，用来创建对象的方法就是构造方法
（Python中的构造方法，在定义类的时候系统已经自动创建好了）

2.init方法

__init__方法又叫初始化方法，用来在创建对象的是对对象进行初始化操作的。
当我们通过类创建对象的时候，系统会自动调用__init__方法来对象创建出来的对象进行初始化。

调用构造方法创建对象的时候需不需要参数，需要几个，看被自动调用的__init__

class Person:
    def __init__(self, a, b):
        print('初始化方法:', a, b)
        print(f'self:{self}')


p1 = Person(10, 20)
print(p1)

# p2 = Person(a=100, b=200)
# p2 = Person()
"""
def Person(*args, **kwargs):
    对象 = 申请空间创建对象
    对象.__init__(*args, **kwargs)
    return 对象
"""

五、对象属性

1.属性: 对象属性和类属性

对象属性: 对象属性的值会因为对象不同而不一样

a.定义在init方法中

b.以 self.属性名 = 值

c.通过 对象.属性名 的方式使用属性

class Person:
    def __init__(self, name1, age1, gender1='男'):
        self.name = name1
        self.age = age1
        self.gender = gender1

    def eat(self):
        print(f'{self.name}吃饭')


p1 = Person('小明', 1)
print(p1.name, p1.age, p1.gender)

p2 = Person('小花', 3, '女')
print(p2.name, p2.age, p2.gender)
p2.name = '大花'
print(p2.name)

# p1.eat()
p2.eat()

本文地址：https://blog.csdn.net/qq_48484950/article/details/107090417