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.匹配對象

print('=============================')

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\su\sc\sk|s\sh\si\st|傻\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()

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()