Python的类中的init方法

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

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)

new_sentence = sub(re_str, '*', sentence)
print(new_sentence)

编程思想

"""
面向过程编程(穷人的思想)：一遇到问题马上想到的是怎么写代码把这个功能实现(逻辑)


函数式编程(小资的思想)：一遇到问题马上想到有没有一个函数已经把这个功能实现了，如果有就拿过来用，没有就定义一个有这个功能的函数(函数)


面向对象编程(富豪的思想)：一遇到问题马上想到有没有一个类中有这个方法能够把这个功能实现，如果没有就创建这个类(类和对象)
"""

a = 10
b = 20
# 求变量a和b的和
print(a + b)

类和对象

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