知识回顾

1.类：拥有相同属性和相同功能的对象的集合

属性：存储数据（对象属性，类的字段）
功能：方法（对象方法，类方法和静态方法）

2.对象：类的实例

对象 = 类名（）

3.构造方法和init方法

构造方法：声明类的时候，系统会自动创建一个函数，这个函数的函数名和类名一样，这个方法就是构造方法
构造的作用就是创建对象，并且自动的去调用init方法
init方法：
a.系统在创建对象的时候自动调用
b.可以有除了self以外的其他参数，如果要给这些参数传参，需要使用构造方法来传
c.需要给类添加对象属性

4.对象方法：

直接声明在类中的函数，有默认参数self，并且要通过对象调用，调用的时候不用给self传参
对象.对象方法，系统会将前面的对象传递给对象方法中的self

5.对象的属性

a.声明在init方法中
b.self.属性 = 值

要通过对象去使用（增删改查）

6.类的字段（类的属性）

声明在类中，函数的外面的变量；通过类来使用

7.对象.__dict__

类方法和静态方法

类中的方法：对象方法、类方法和静态方法

1.对象方法：

a.直接声明在类中
b.自带参数self
c.通过对象来调用

2.类方法：

a.声明在@classmethod后面的函数就是类方法
b.自带参数cls(cls在函数调用的时候不用传参，系统会自动将调用这个方法的类赋给它)
c.通过类来调用

3.静态方法：

a.声明在@staticmethod后面的函数就是静态方法
b.没有自带参数
c.通过类来调用

4.怎么选择使用哪种方法

如果实现函数的功能需要用到对象的属性，那么就把这个函数声明成对象方法
静态方法和类方法：实现函数的功能不需要用到对象的属性，就可以选择用静态方法和类方法
类方法：在不使用对象属性的前提下，需要使用类
静态方法：既不需要对象的属性也不需要类

class Number:
    def __init__(self):
        self.value = 0
        self.type = int
        self.id = None

    @staticmethod
    def max():
        return 100

    @staticmethod
    def min():
        return -100


num = Number()
num.value = 1000
print(Number.max())

class Math:
    pi = 3.1415926

    @classmethod
    def circle_area(cls, radius):
        return cls.pi * radius * 2

    @staticmethod
    def sum(num1, num2):
        return num1 + num2


print(Math.circle_area(3))


class Rect:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

class Person:
    num = 20

    # 声明一个类方法
    @classmethod
    def destroy(cls):
        # cls指向的是当前类。调用这个方法的类可以做的事情，cls都能做
        print('cls:', cls, cls.num)
        p2 = cls()
        print('人类破坏环境')

    @staticmethod
    def func1():
        print(Person.num)
        p3 = Person()
        print('人类的静态方法')


print(Person)
Person.destroy()

私有化

类中的内容默认都是公开的（在类的外面可以使用）

1.私有化 : 将类的内容在类的外面隐藏

在类中方法名或者属性名前加两个下划线(不能以两个下划线结束）
私有的方法和属性只能在类的内部使用，不能在类的外部使用

2.私有的原理

python中没有真正的私有化(没有从访问权限上去限制内容的访问)
私有的原理就是私有的属性名或者方法名前加前缀'_类名'来阻止外部直接通过带两个下划线的名字去使用属性和方法

class Person:
    num = 30

    def __init__(self, name, age):
        self.name = name
        self.__age = age

    def show_info(self):
        print(self.__age)
        self.__func1()

    def __func1(self):
        print('私有对象方法')


p1 = Person('小明', 20)
print(p1.name)
p1.show_info()
# print(p1.age)

print(p1.__dict__)
print(p1._Person__age)

getter和setter

1.什么时候需要添加对象属性的getter和setter

如果希望在通过对象.属性获取属性的值之前，再干点别的事情，就可以给这个属性添加getter
如果希望在通过对象.属性给属性赋值之前，在干点别的事情，就可以给这个属性添加setter

2.怎么添加getter和setter

getter:
a.在属性名前加一个下划线
b.添加属性对应的getter

@property
def 属性名去掉_(self):
    函数体 -->   会对属性的值进行处理后，返回相应的结果(必须要有返回值)

c.使用属性的值的时候，不通过带下划线的属性名去使用，而是通过没有下划线的属性去使用

注意：对象.不带下划线的属性 --> 调用getter对应的函数

setter：
如果想要添加setter必须要先添加getter
a.添加setter

@getter名.setter
def 属性名去掉_(self, 参数):
    做别的事情
    self.属性名 = 处理后的值

class Number:
    def __init__(self):
        self._value = 0
        # 0-6保存星期
        self._week = 4
        self.type = int
        self.id = None

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, x):
        if not -100 <= x <= 100:
            raise ValueError
        self._value = x

    # _week的getter
    @property
    def week(self):
        if self._week == 0:
            return '星期天'
        elif self._week == 1:
            return '星期一'
        elif self._week == 2:
            return '星期二'
        elif self._week == 3:
            return '星期三'
        elif self._week == 4:
            return '星期四'
        elif self._week == 5:
            return '星期五'
        elif self._week == 6:
            return '星期六'

    """
    isinstance(值， 类)   -->    判断指定的值是否是指定的类型（返回值是bool）
    """
    @week.setter
    def week(self, value):
        # 如果传的值不是整型数据
        if not isinstance(value, int):
            raise ValueError
        if not 0 <= value <= 6:
            raise ValueError

        self._week = value

    @staticmethod
    def max():
        return 100

    @staticmethod
    def min():
        return -100


number = Number()
print(number.week)     # number.week 实质是在通过number去调用对象方法week
# print(number._week)

number.week = 6        # number.week = 值  实质是通过number去调用setter对应的week方法
print(number.week)

number.value = -20      # number.value 调用setter方法
print(number.value)

要求age的值只能在0-150之间，超过范围报错；获取age的值的时候，返回年龄值，并且返回这个年龄对应的阶段

class Person:
    def __init__(self, name, age=0):
        self.name = name
        self._age = age

    @property
    def age(self):
        if 0 <= self._age <= 12:
            return self._age, '儿童'
        elif 13 <= self._age <= 25:
            return self._age, '青年'
        elif 26 <= self._age <= 60:
            return self._age, '中年'
        elif 61 <= self._age <= 150:
            return self._age, '老年'

    @age.setter
    def age(self, x):
        if not 0 <= x <= 150:
            raise ValueError
        self._age = x


p1 = Person('小明')
p1.age = 100
print(p1.age)

作业

1.定义一个学生类。有属性：姓名、年龄、成绩（语文，数学，英语)[每课成绩的类型为整数]
方法：
a. 获取学生的姓名：getname()
b. 获取学生的年龄：getage()
c. 返回3门科目中最高的分数。get_course()

class Student:
    def __init__(self, name: str, age: int, chinese: int, math: int, english: int):
        self.__name = name
        self.__age = age
        self.chinese = chinese
        self.math = math
        self.english = english
        self.score = {'chinese': chinese, 'math': math, 'english': english}

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, x):
        if not 0 <= x <= 150:
            raise ValueError
        self.__age = x

    def get_name(self):
        print(self.__name)
        return self.__name

    def get_age(self):
        print('%s %d岁' % (self.__name, self.__age))
        return self.age

    def get_course(self):
        key = ''
        max1 = self.score['chinese']
        for index in self.score:
            if self.score[index] > max1:
                max1 = self.score[index]
                key = index
        print(self.score, '最高分：', index, max1)


stu1 = Student('小明', 20, 98, 80, 85)
# 获取名字
stu1.get_name()
# 获取年龄
stu1.get_age()
# 三门课的最高分
stu1.get_course()

结果：

1.JPG

(尝试)5.写一个类，其功能是：
1.解析指定的歌词文件的内容
2.按时间显示歌词 提示：歌词文件的内容一般是按下面的格式进行存储的。歌词前面对应的是时间，在对应的时间点可以显示对应的歌词

[00:00.20]蓝莲花
[00:00.80]没有什么能够阻挡
[00:06.53]你对自由地向往
[00:11.59]天马行空的生涯
[00:16.53]你的心了无牵挂
[02:11.27][01:50.22][00:21.95]穿过幽暗地岁月
[02:16.51][01:55.46][00:26.83]也曾感到彷徨
[02:21.81][02:00.60][00:32.30]当你低头地瞬间
[02:26.79][02:05.72][00:37.16]才发觉脚下的路
[02:32.17][00:42.69]心中那自由地世界
[02:37.20][00:47.58]如此的清澈高远
[02:42.32][00:52.72]盛开着永不凋零
[02:47.83][00:57.47]蓝莲花

class FileRead:
    lrc = []
    lrctime = {}
    lrc_min_sec = []

    def __init__(self, path: str):
        self.path = path

    def files_read(self):
        try:
            with open(self.path, 'r', encoding='utf-8') as f:
                for line in f:
                    FileRead.lrc.append(line)
                    print(line)
        except FileNotFoundError:
            print('文件不存在！')
        finally:
            f.close()
        return f

    def create_lrc(self):
        self.files_read()
        for second in FileRead.lrc:
            if second[0] == '[' and not second[10] == '[':
                key = int(second[1:3]) * 60 + int(second[4:6])
                value = second[10:]
                FileRead.lrctime[key] = value
        for second in FileRead.lrc:
            if second[0] == '[' and second[10] == '[':
                key = int(second[11:13]) * 60 + int(second[14:16])
                value = second[20:]
                FileRead.lrctime[key] = value

    def time_lrc(self, time):
        self.create_lrc()
        for index in FileRead.lrctime:
            if index == time:

                print(FileRead.lrctime[index])


f1 = FileRead('./files/蓝莲花.txt')

f1.time_lrc(6)

结果：

2.JPG