Python第二语言（十、Python面向对象（上））

1. 标记变量的基础类型

2. 初识对象

2.1 使用对象组织数据

3. 成员变量

3.1 类和类成员的定义

3.2 成员变量和成员方法使用

3.3 成员方法的定义语句

4. 类和对象class Clock: def ring(self):

4.1 创建类对象的语法：对象名 = 类名称()

4.2 用生活中的物件来解释对象

4.3 基于类创建对象

5. 构造方法：__init__()方法

5.1 构造方法

5.2 构造方法注意事项

6. 魔术方法：__init__ 、__str__...

6.1 __str__字符串方法：控制类转换成字符串的行为；

6.2 __lt__小于符号比较方法：对2个对象进行比较；

6.3 __le__小于等于比较符号方法：对2个对象进行比较；

6.4 __eq__，比较运算符实现方法，判断对象的值是否相等；

1. 标记变量的基础类型

方便了解变量的基础类型；

语法：变量: 类型

# 基础数据类型注解
var_1: int = 10
var_2: float = 3.55
var_3: bool = True
var_4: str = "zhangSan"

class Student:
    pass


# 类对象类型注解
stu: Student = Student()

2. 初识对象

2.1 使用对象组织数据

1. 在程序中设计表格：设计类(class)

class Student:
    name = None  #记录学生姓名

2. 在程序中打印生产表格：创建对象

# 基于类创建对象
stu_1 = Student()
stu_2 = Student()

3. 在程序中填写表格：对象属性赋值

stu_1.name ="zhangSan"  # 为学生1对象赋予名称属性值
stu_2.name ="lisi"  # 为学生2对象赋予名称属性值

4. 打印对象结果；

小结：

在程序中是可以做到和生活中那样，设计表格、生产表格、填写表格的组织形式的；
与程序进行对比：
1. 在程序中设计表格：设计类(class)
2. 在程序中打印生产表格：创建对象
3. 在程序中填写表格：对象属性赋值

3. 成员变量

3.1 类和类成员的定义

我们可以使用类去封装属性，并基于类创建出一个个的对象来使用；
而类的成员一般都会有：成员变量，成员方法
创建类对象的语法：对象 = 类名称()

class 类名称:  # class是关键字，表示定义一个类
    类的属性  # 即定义在类中的变量(成员变量)
    类的行为  # 即定义在类中的函数(成员方法)

3.2 成员变量和成员方法使用

类中定义的属性（变量）称之为：成员变量；
类中定义的行为（函数）称之为：成员方法；

class Student:
    name = None
    age = None

    def say_hi(self):
        print(f"大家好！我是{self.name}")  # 2.self.调用成员变量


stu = Student()
stu.name = "zhangSan"  # 1.成员变量的赋值
stu.say_hi()

3.3 成员方法的定义语句

1. 成员方法定义和self关键字：

在类中定义成员方法和定义函数基本一致：

def 方法名(se1f，形参1，.....·，形参N):
    方法体

self关键字：self关键字是成员方法定义的时候，必须填写的；
1. 它用来表示类对象自身的意思；
2. 当我们使用类对象调用方法时，self会自动被python传入；
3. 在方法内部，想要访问类的成员变量，必须使用self；

2. 类的行为：

在定义类行为时，若无传入的形参，则在相对应调用类的方法时，即可不用传递参数；
在定义类行为时，如果定义了形参，这时候在调用类的方法时，就必须传入对应的实参；
想要访问成员属性，必须使用self，但是如果是传递的参数，就可以不用，注意，self是必写的关键字，用来调用成员变量；

class Student:
    name = None
    age = None

    def say_hi(self):
        print("大家好！")

    def say_hi1(self, name):
        print(f"大家好！我是{name}")


stu = Student()
stu.say_hi()  # 调用时无需传参
stu.say_hi1("zhangSan")  # 调用时按照成员需要传递name实参

4. 类和对象class Clock: def ring(self):

概念：类就是一个模板，对象就是实现类的实体；

4.1 创建类对象的语法：对象名 = 类名称()

为什么要创建对象：因为类只是一种程序内的“设计图纸”，需要基于图纸生产实体（对象），才能正常工作，这种方式通常称为：面向对象编程；

4.2 用生活中的物件来解释对象

就比如闹钟：
1. 一个闹钟就好比一个对象；
2. 那么对象的属性就是闹钟的价格，型号、品牌；
3. 那么闹钟的行为就好比：闹钟响铃；

4.3 基于类创建对象

winsound类：可以让计算机发出一点声音；

# 设计一个闹钟类
class Clock:
    price = None  # 价格
    size = None  # 型号
    brand = None  # 品牌

    def ring(self):
        import winsound
        print("闹钟开始响铃...")
        winsound.Beep(2000, 1000)  # 频率，持续时间



# 构建闹钟对象并让其工作，clock就是闹钟的对象
clock = Clock()
clock.price = 10
clock.size = "标准型"
clock.brand = "小米"
print(f"闹钟价格{clock.price}元，型号：{clock.size}，品牌：{clock.brand}")
clock.ring()  # 闹钟响铃行为

小结：

现实世界的事物由什么组成？
- 属性；
- 行为；
- 类也可以包含属性和行为，所以使用类描述现实世界事物是非常合透的；
类和对象的关系是什么？
- 类是程序中的“设计图纸”；
- 对象是基于图纸生产的具体实体；
什么是面向对象编程？
- 面向对象编程就是，使用对象进行编程；
- 即，设计类，基于类创建对象，并使用对象来完成具体的工作；

5. 构造方法：init()方法

大致就是一个类，可以直接定义init构造方法，直接省去类的成员属性定义，而直接将成员属性定义在init中，并且在类创建时，会自动执行init构造方法，并将传入的参数自动传递给init方法使用；

5.1 构造方法

上面类的属性可以省略不写，在init中已经声明了；

Python类可以使用：_ init() _方法，称之为构造方法：

可以实现：

在创建类对象（构造类）的时候，会自动执行；
在创建类对象（构造类）的时候，将传入参数自动传递给init方法使用；

class Student:
    # name = None
    # age = None  省略成员属性
    # tel = None

    def __init__(self, name, age, tel):  # 构建类时传入的参数会自动提供给__init__方法，并在构建类的时候__init__方法会自动执行
        self.name = name
        self.age = age
        self.tel = tel
        print("Stu类创建了一个对象", f"学生名是：{name}")


sut = Student("zhangSan", 28, "18300000000")

5.2 构造方法注意事项

使用_ init _时，注意前后都有2个下划线；
构造方法也是成员方法，不用忘记在参数列表中提供：self关键字；
在构造方法内定义成员变量，需要使用self关键字，意思是要成为成员变量，需要用self来表示；

    def __init__(self, name, age, tel):  # 构建类时传入的参数会自动提供给__init__方法，并在构建类的时候__init__方法会自动执行
        self.name = name
        self.age = age
        self.tel = tel
        print("Stu类创建了一个对象", f"学生名是：{name}")

6. 魔术方法：init 、str...

概念：

不仅仅只有这几个魔术方法，在python中有大概二三十个；

比如说__init__ 就是python类内置的方法之一；

这些内置的类方法，各自有各自特殊的功能，这些内置方法称为魔术方法；
- 常见的魔术方法：
  1. __init__ ：构造方法
  2. __str__ ：字符串方法
  3. __lt__ ：小于，大于符号比较
  4. __le__ ：小于等于，大于等于符号比较
  5. __eq__ ：==符号比较

可以结合放在一段代码中案例；

6.1 str字符串方法：控制类转换成字符串的行为；

类创建时，自动执行__str__魔术方法；

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Student类对象，name={self.name}，age={self.age}"


student = Student("zhangSan", 28)
print(student)
print(str(student))

6.2 lt小于符号比较方法：对2个对象进行比较；

同时__lt__也支持大于符号的判断，但是不支持小于等于或大于等于判断；

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"Student类对象，name={self.name}，age={self.age}"

    def __lt__(self, other):  # 传入参数：other，另一个对象，返回值：True和False
        return self.age < other.age


student = Student("zhangSan", 28)
student1 = Student("zhangSan", 30)
print(student < student1)

6.3 le小于等于比较符号方法：对2个对象进行比较；

同时支持大于等于判断；等于符号也可以支持；

在这里两个对象相==判断是否相等是判断两个对象的内存地址是否相等，答案会为False；而比较对象值是否相等要使用__eq__；

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __le__(self, other):  # 传入参数：other，另一个对象，返回值：True和False
        return self.age <= other.age


student = Student("zhangSan", 28)
student1 = Student("zhangSan", 30)
print(student <= student1)

6.4 eq，比较运算符实现方法，判断对象的值是否相等；

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):  # 传入参数：other，另一个对象，返回值：True和False
        return self.age == other.age


student = Student("zhangSan", 30)
student1 = Student("zhangSan", 30)
print(student == student1)