【千锋Python2205班10.14笔记-day17-面向对象编程（一阶段）】

最新推荐文章于 2023-03-29 08:48:11 发布

weixin_43600905

最新推荐文章于 2023-03-29 08:48:11 发布

阅读量762

点赞数

文章标签： python

本文链接：https://blog.csdn.net/weixin_43600905/article/details/127332680

版权

01-review

1.正则语法

1)匹配类符号：

普通字符、.、\d、\D、\s、\S、\w、\W、[字符集]、[^字符集]

2)匹配次数：

+、*、?、{N}、{M,N}、{M,}、{,N}

3)分组：()

4)分支：

正则1|正则2

5)检测类：

\b、\B、^、$

6)转义符合

2.re模块

from re import fullmatch, match, search, findall, finditer, split, sub

02-homework

from re import *

1.用户名匹配

要求: 1.用户名只能包含数字字母下划线

2.不能以数字开头

3.⻓度在 6 到 16 位范围内

username = 'hsjs'
result = fullmatch(r'[a-zA-Z_][\da-zA-Z_]{5,15}', username)
if result:
    print(f'{username} 合法')
else:
    print(f'{username}不合法')

2.密码匹配

要求: 1.不能包含!@#¥%^&*这些特殊符号

2.必须以字母开头

3.⻓度在 6 到 12 位范围内

pw = 'ahfka23'
result = fullmatch(r'[a-zA-Z][^!@#¥%^&*]{5,11}', pw)
if result:
    print(f'{pw} 合法')
else:
    print(f'{pw} 不合法')

3.ipv4 格式的 ip 地址匹配

提示: IP地址的范围是 0.0.0.0 - 255.255.255.255

0、2、19、23、45、199、230、245、254 - 合法
00、002、023 - 不合法

匹配0~255的正则： \d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]

0~9：\d

10~99: [1-9]\d

0~99: [1-9]?\d
100~199: 1\d\d
200~249: 2[0-4]\d
250~255: 25[0-5]

ip地址的正则
((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]).){3}(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])

re_str = r'((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.){3}(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])'
print(fullmatch(re_str, '10.7.184.255'))

4.提取用户输入数据中的数值 (数值包括正负数还包括整数和小数在内) 并求和

“-3.14good87ni009ce19by23.e” =====> -3.14 + 87 + 9 + 19 + 23 = 180.86

def sum_str(str1: str):
    result = findall(r'-?\d+\.?\d*', str1)
    return sum([float(x) for x in result])

message = '-3.14go.78od87nice19bye'
print(sum_str(message))

5.验证输入内容只能是汉字

print(fullmatch(r'[\u4e00-\u9fa5]+', '实际付款'))

6.匹配整数或者小数（包括正数和负数）

合法的整数： 0、23、1829、+234、-28293、+0、-0
不合法的整数：0001、000、-0012、+09
合法的小数：0.222、2.99、234.992、-23.999、+22.992、0.0、0.00、0.20
不合法的小数：.344、899.、0022.93

整数的正则：[-+]?(0|[1-9]\d*)
小数的正则：[-+]?((0|[1-9]\d*).\d+)
合并：[-+]?((0|[1-9]\d*)(.\d+)?)

print(fullmatch(r'[-+]?((0|[1-9]\d*)(\.\d+)?)', '0.23'))

8.拆分长字符串：将一首诗的中的每一句话分别取出来

poem = '窗前明月光，疑是地上霜。举头望明月，低头思故乡。'
result = split(r'[，。]', poem)
print([x for x in result if x])

按照字符串中所有的’you’和’me’对字符串进行切割

str1 = 'abcyou123me你好you哈哈youmnmehello'
result = split(r'you|me', str1, 3)
print(result)

03-认识类和对象

1. 编程思想

面向过程编程: 穷人思想（基本语法、分支、循环、逻辑思维）

函数式编程：小资思想（基本语法、分支、循环、逻辑思维、函数）

面相对象编程：富豪思想（基本语法、分支、循环、逻辑思维、函数、类、对象）

求10的阶乘

s = 1
for x in range(1, 11):
    s *= x
print(s)


def factorial(num):
    s = 1
    for x in range(1, num+1):
        s *= x
    return s

print(factorial(10))

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

“”"
类就是具有相同功能和相同属性的对象的集合。（类是一个抽象的概念）
对象就是类的实例。（某一类事物的具体表现）

人是类，余婷是人的对象，骆老师也是人的对象;
电脑是类，我桌上这台电脑就是电脑的对象;
车是类，我家的车那辆车是对象，楼下停着的那辆红色的车是对象；汽车、工程车、出租车是车的子类(分类)
“”"

3.定义类(创建类) -

用代码来描述这个类是拥有哪些相同属性和哪些相同功能的对象的集合

数值相关的共同特点用属性来描述 - 属性就是定义在类变量
非数值相关的共同特点用方法来描述 - 方法就是定义在类中的函数

语法：
class 类名:
类的说明文档
类的内容

说明：
1）class - 关键字；固定写法
2）类名 - 由程序员自己命名；必须满足两点命名要求
三个规范：首字母大写，采用驼峰式命名（大驼峰）; 见名知义; 不使用系统函数、类、模块名
3）: - 固定写法
4）类的说明文档 - 多行注释
5）类的内容 - 在这儿用代码来描述这个类相同的功能和属性和有哪些；
主要包含属性(对象属性、类属性)和方法(对象方法、类方法、静态方法)

class Person:
    """这是人类"""
    pass

4. 创建类的对象

“”"
语法：类名() - 创建指定类的对象并且返回
“”"

p1 = Person()
p2 = Person()

print(p1)
print(p2)

04-类中的方法

1. 方法 -

对象方法、类方法、静态方法

“”"

1）对象方法

a.怎么定义：直接定义在类中的函数就是对象方法
b.怎么调用：以’对象.xxx()'的方式来调用 - 通过对象来调用对象方法
c.特点：通过对象来调用对象方法的时候默认参数self不需要传参，系统会自动将当前对象传给self(self是谁调用就指向谁)
d.应用场景：

2）类方法

a.怎么定义：需要在定义函数前加"@classmethod"
b.怎么调用：以 '类.xxx()'的方式来调用 - 通过类来调用类方法
c.特点：通过类来调用类方法的时候默认参数cls不用传参，系统会自动将当前类传给cls
d.应用场景：

3）静态方法

a.怎么定义：需要再定义函数前加"@staticmethod"
b.怎么调用：以 '类.xxx()'的方式来调用 - 通过类来调用静态方法
c.特点：没有特点
d.应用场景：

class A:
    def func1(self):
        print('对象方法:', self)

    def func11(self, x):
        print('对象方法2：', self, x)

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

    @staticmethod
    def func3():
        print('静态方法')

2.通过对象调用对象方法

a = A()
b = A()
print(f'a:{a}')
print(f'b:{b}')
b.func1()
a.func11(100)

3.通过类调用类方法

print(A)
A.func2()
A.func3()

result = dict.fromkeys('abc', '123')
print(result)

05-初始化方法

1. 魔法方法

方法名由两个下划线开头同时由两个下划线结尾，并且会在特定情况下自动调用的方法就是魔法方法。

class A:
    def __add__(self, other):
        print('add被调用')
        return 100

    # def __str__(self):

    #     print('str被调用')

    #     return 'abc'

    def __repr__(self):
        print('repr被调用')
        return 'abc'


a1 = A()
a2 = A()
print(a1 + a2)
print(a1)
print('------------------------------------------华丽的分割线------------------------------------------------')
print(a2)

list1 = [a1, a2]
print(list1)

2. 常用的两个魔法方法

1）init方法

a. 当通过类创建对象的时候，类中的__init__方法会被自动调用
b. 在类中添加__init__方法的时候，可以根据需要在方法中随意添加参数。
如果在__init__方法中添加了额外的参数，那么在创建这个类的对象的时候必须通过类名后面的括号来给__init__方法提供额外的实参

2）repr方法

a. 打印类的对象的时候会自动调用__repr__方法，并且将这个方法的返回值作为这次打印的打印结果
b. 这个方法的返回值必须是字符串。（__repr__方法中的self指向的当前的打印对象）

class B:
    def __init__(self):
        print('init方法被调用')


b1 = B()
b2 = B()


class C:
    def __init__(self, x, y=2):
        print('C的init方法被调用', x, y)
        pass

    def __repr__(self):
        print('repr被调用')
        return 'abc'


c1 = C(10, 20)
c2 = C(x=100, y=200)
c3 = C(10)

print(c1)

06-属性

1. 属性 - 定义在类中的变量

1）类属性

a. 怎么定义：直接定义在类中的变量就是类属性
b. 怎么使用：以’类.xxx’的方式来使用 - 通过类来使用类属性
c. 什么时候用：属性值不会因为对象不同而不一样，就定义成类属性

2）对象属性

a. 怎么定义：以’self.属性名 = 值’的形式定义在__init__方法中
b. 怎么使用：以’对象.xxx’的方式来使用 - 通过对象来使用对象属性
c. 什么时候用：属性值会因为对象不同而不一样，就定义成对象属性

class A:

    # x、m是类属性

    x = 10
    m = '你好'

    # y和n是对象属性

    def __init__(self):
        self.y = 100
        self.n = 'hello'

通过类使用类属性

print(A.x, A.m)

通过对象使用对象属性

a = A()
print(a.y, a.n)

2. 对象属性赋值方式

class Circle:
    pi = 3.1415926

    def __init__(self, r=5):

        # 1)直接用一个具体的数据给对象属性赋值

        # self.r = 10

        # 2)用一个没有默认值的参数给对象属性赋值

        # self.r = r

        # 3)用一个有默认值的参数给对象属性赋值

        self.r = r

        # self.area = Circle.pi * r ** 2

    # 注意：如果实现函数的功能需要对象属性，那么这个函数必须定义成对象方法，并且在方法中通过self来提供你所需要的对象属性

    def area(self):
        return Circle.pi * self.r ** 2

1 ）方式1

# c1 = Circle()

# print(c1.r)

# c1.r = 5

# print(c1.r)

2）方式2

# c1 = Circle(5)

# print(c1.r)

#

# c2 = Circle(10)

# print(c2.r)

3）方式3

c1 = Circle()
print(c1.r)

c2 = Circle(10)
print(c2.r)

print(c1.area())
print(c2.area())

c2.r = 100
print(c2.area())

07-继承

1. 继承 -

让子类直接拥有父类的属性和方法
语法：
class 类名(父类1, 父类2,…):
说明文档
类的内容

注意：如果定义类的时候没有写继承关系，那么这个类默认继承object(基类); (class 类名: == class 类名(object)😃

class A:
    a = 100

    def __init__(self):
        self.b = 200
        self.c = 300

    def func1(self):
        print('A的对象方法')

    @classmethod
    def func2(cls):
        print('A的类方法')

    @staticmethod
    def func3():
        print('A的静态方法')


class B(A):

    # 1)在子类中添加类属性和方法的时候，直接定义新的类属性和新的方法

    m = 99

    def func11(self):
        print('B的对象方法')

    @classmethod
    def func22(cls):
        print('B的类方法')

    # 2）如果要在子类中添加对象属性，必须在子类的__init__方法中通过super()去调用父类的__init__方法

    def __init__(self):
        super().__init__()      # 调用当前类的父类的__init__方法
        self.e = 300
        self.f = 400


print(B.a)

x = B()

x.func1()
B.func2()
B.func3()

print(B.m)
x.func11()
B.func22()

print('------------------------------------------华丽的分割线------------------------------------------------')
print(x.b, x.c)
print(x.f, x.e)