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