Python学习从0到1 day19 第二阶段 面向对象 ① 类和对象及构造方法

我们应在日暮之时燃烧

                —— 24.3.30

01.初识对象

02.类的成员方法

03.类和对象

04.构造方法

05.魔术方法

一、初识对象

01.理解使用对象完成数据组织的思路

使用对象组织数据

现实生活中，我们可以打印出表格对数据进行组织，编辑，在程序中，我们如何做到像生活中一样的组织形式呢？

1.在程序中设计表格，我们称之为：设计类（class）

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

2.在程序中打印生产表格，我们称之为：创建对象

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

3.在程序中填写表格，我们称之为：对象属性赋值

stu_1.name = "周杰伦"    # 为学生1对象赋予名称的属性值
stu_2.name = "林俊杰"    # 为学生2对象赋予名称的属性值

4.案例

# 1.设计一个类（类比生活中：设计一张登记表）
class StudentForm:
    name = None          # 记录学生姓名
    gender = None        # 记录学生性别
    nationality = None   # 记录学生国籍
    native_place = None  # 记录学生籍贯
    age = None           # 记录学生年龄

# 2.创建一个对象（类比生活中：打印一张登记表）
stu_1 = StudentForm()

# 3.对象属性进行赋值（类比生活中：填写表单）
stu_1.name = "张三"
stu_1.gender = "男"
stu_1.nationality = "中国"
stu_1.native_place = "北京"
stu_1.age = 17

# 4.获取对象中记录的信息
print(stu_1.name,stu_1.gender,stu_1.nationality,stu_1.native_place,stu_1.age)

5.总结

        ①生活中或是程序中，我们都可以使用设计表格、生产表格、填写表格的形式组织数据

        ②进行对比，在程序中：

                设计表格，称之为：设计类（class）

                打印表格，称之为：创建对象

                填写表格，称之为：对象属性赋值

二、类的成员方法

01.掌握类的定义和使用语法

02.掌握成员方法的使用

03.掌握self关键字的作用

1.类的使用语法：

class 类名称：

        类的属性

        类的行为

        ①class是关键字，表示要定义类了

        ②类的属性，即定义在类中的变量（成员变量）

        ③类的行为，即定义在类中的函数（成员方法）

2.创建类对象的语法：

对象 = 类名称（）

3.示例：

# 5.类的行为（方法）
class Student:
    name = None
    age = None
    def sayHello(self):
        print(f"Hello，大家好，我的名字是{self.name},我今年{self.age}岁了")

# 6.调用类内的函数
stu_2 = Student()
stu_2.name = "李四"
stu_2.age = 16
stu_2.sayHello()

4.成员方法的定义语法：

def 方法名(self，形参1，……形参N):
    方法体

5.self关键字：

        self关键字是成员方法定义的时候，必须填写的

                ①它用来表示类对象自身的意思

                ②当我们使用类对象调用方法的时候，self会自动被python传入

                ③在成员方法内部，想要访问类内部的成员变量，必须使用self关键字

        注意事项：

                self关键字，尽管在参数列表中，但是self是透明的，传参的时候可以忽略它不用理会它

6.示例：

# 定义一个带有成员方法的类
class Student:
    name = None    #学生的姓名

    def say_hi(self):
        print(f"Hello，大家好，我是{self.name},请大家多多关照")

Stu_1 = Student()
Stu_1.name = "Lihua"
Stu_1.say_hi()

Stu_2 = Student()
Stu_2.name = "小明"
Stu_2.say_hi()

Stu_3 = Student()
Stu_3.name = "小红"
Stu_3.say_hi()

7.在一个类内部定义多个成员方法 示例

# 定义一个带有成员方法的类
class Student:
    name = None    #学生的姓名

    def say_hi(self):
        print(f"Hello，大家好，我是{self.name},请大家多多关照")

    def say_hi2(self,msg):
        print(f"大家好，我是:{self.name},{msg}")

Stu_4 = Student()
Stu_4.name = "王二麻子"
Stu_4.say_hi2("一切都会好的")

8.总结

        ①类是由哪两部分组成呢？

                类的属性，称之为：成员变量

                类的行为，称之为：成员方法

        注意：函数是写在类外的，定义在类内部的我们都称之为方法

        ②类和成员方法的定义语法：
                

class 类名称：
    成员变量
    def 成员方法（self,参数列表）：
        成员方法体

        ③self的作用：

                表示类对象本身的意思

                只有通过self，成员方法才能访问类的成员变量

                self出现在形参列表中，但是不占用参数位置，无需理会

三、类和对象

01.掌握使用类描述现实世界事物的思想

02.掌握类和对象的关系

03.理解什么是面向对象

1.掌握使用类描述现实世界事物的思想

现实世界的事物也有属性和行为，类也有属性和行为

使用程序中的类，可以完美的描述现实世界的事物

2.类和对象的关系

类为什么非要创建对象才能使用呢？

        类只是一种程序内的“设计图纸”，需要基于图纸生产实体（对象），才能正常工作

        这种套路称之为：面向对象编程

案例：设计一个闹钟类，定义两个闹钟对象

'''
演示类和对象的关系，即面向对象的编程思路（思想）
'''

# 设计一个闹钟类
class Clock():
    id = None       # 序列号
    price = None    # 价格

    def ring(self):
        # 内置模块winsound，可以让电脑发出一些声音
        import winsound
        # 2000表示频率 3000表示持续时间
        winsound.Beep(2000,3000)

# 构建两个闹钟对象并让其工作
clock1 = Clock()
clock1.id = "02151"
clock1.price = 19.99
print(f"脑子id:{clock1.id},价格:{clock1.price}")
clock1.ring()

clock2 = Clock()
clock2.id = "01241104"
clock2.price = 27.99
print(f"脑子id:{clock2.id},价格:{clock2.price}")
clock2.ring()

3.总结

①现实世界的事物由什么组成？

        属性 行为

        类也可以包含属性和行为，所以使用类描述现实世界事物是非常合适的

②类的对象的关系是什么？

        类是程序中的设计图纸

        对象是基于图纸生产的具体实体

③什么是面向对象编程？

        面向对象编程就是，使用对象进行编程

        即，设计类，基于类创建对象，并使用对象来完成具体的工作

四、构造方法

01.掌握使用构造方法向成员变量赋值

1.构造方法

python类可以使用:__init__()方法，称之为构造方法

可以实现：

        在创建类对象（构造类）的时候，会自动执行

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

'''
演示类的构造方法
'''

# 演示使用构造方法对成员变量进行赋值
# 构造方法的名称：__init__
class Student:
    # 这三行可省略，可以直接定义并赋值
    name = None
    age = None
    tel = None


    def __init__(self,name,age,tel):
        self.name = name
        self.age = age
        self.tel = tel
        print("Student类创建了一个对象")

stu1 = Student("小明",27,"16256568456")

# 方式2：
stu2 = Student
stu2.age = 15
print(stu2.age)

2.构造方法的注意事项

构造方法名称：__init__，init前后都有两个下划线

构造方法也是成员方法，不要忘记在参数列表中提供：self

在构造方法内定义成员变量，需要使用self关键字

3.总结

        ①构造方法的名称是：__init__

        ②构造方法的作用：

                构建类对象的时候会自动运行

                构建类对象的传参会传递给构造方法，借此特性可以给成员变量赋值

        ③注意事项：

                构造方法不要忘记self关键字

                在方法内使用成员变量需要用到self

4.练习案例

        开学了有一批学生信息需要录入系统，请设计一个类，记录学生的：姓名，年龄，地址这三类信息

        请实现：

                ①通过for循环，配合input输入语句，并使用构造方法，完成学生信息的键盘录入

                ②输入完成后，使用print语句，完成信息的输出

'''
开学了有一批学生信息需要录入系统，请设计一个类，记录学生的：姓名，年龄，地址这三类信息
请实现：
    ①通过for循环，配合input输入语句，并使用构造方法，完成学生信息的键盘录入
    ②输入完成后，使用print语句，完成信息的输出
'''
class Student:
    name = None
    age = None
    arrdress = None
    def __init__(self,name,age,arrdress):
        self.name = name
        self.age = age
        self.arrdress = arrdress

stu = Student
for i in range(9):
    print(f"请您输入第{i+1}位学生的信息：")
    stu.name = input("姓名：")
    stu.age = input("年龄:")
    stu.arrdress = input("地址：")
    print(f"学生{i+1}信息录入完成，信息为：学生姓名：{stu.name},学生年龄:{stu.age},学生地址:{stu.arrdress}")

运行结果：

五、魔术方法

01.掌握几种常用的类内置方法

1.魔术方法

上文学习的__init__构造方法，是python类内置的方法之一

这些内置的类方法，各自有各自特殊的功能，这些内置方法我们称之为：魔术方法

2.__str__字符串方法

class Student:
    def __init__(self,name,age):
        self.name = name    # 学生姓名
        self.age = age      #学生年龄

stu = Student("张三",19)
print(stu)
print(str(stu))

通过__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}"

stu = Student("张三",19)
print(stu)
print(str(stu))

3.__lt__ 小于符号比较方法

直接对两个对象进行比较是不可以的，但是在类中实现__lt__方法，即可同时完成：小于符号和大于符号2种比较

方法名：__lt__
传入参数：other，另一个类对象
返回值：True或False
内容：自行定义

示例：

class Student:
    def __init__(self,name,age):
        self.name = name    # 学生姓名
        self.age = age      #学生年龄

    # __str__魔术方法
    def __str__(self):
        return f"Student类对象，name:{self.name},age:{self.age}"

    # __lt__魔术方法
    def __lt__(self, other):
        return self.age < other.age

stu1 = Student("张三",19)
print(stu1)
print(str(stu1))

stu2 = Student("李四",26)
print(stu2)
print(str(stu2))
print(stu1>stu2)
print(stu1<stu2)

4.__le__小于等于比较符号方法

魔术方法：__le__可用于:<=、>=两种比较运算符上

方法名：__le__
传入参数：other，另一个类对象
返回值：True或False
内容：自行定义

class Student:
    def __init__(self,name,age):
        self.name = name    # 学生姓名
        self.age = age      #学生年龄

    # __str__魔术方法
    def __str__(self):
        return f"Student类对象，name:{self.name},age:{self.age}"

    # __lt__魔术方法
    def __lt__(self, other):
        return self.age < other.age

    def __le__(self, other):
        return self.age <= other.age

stu1 = Student("张三",19)
print(stu1)
print(str(stu1))

stu2 = Student("李四",26)
print(stu2)
print(str(stu2))
print(stu1>stu2)
print(stu1<stu2)

stu3 = Student("小红",19)
print(stu3)
print(str(stu3))
print(stu2>=stu3)
print(stu1<=stu3)

5.__eq__，比较运算符实现方法

方法名：__eq__
传入参数：other，另一个类对象
返回值：True或False
内容：自行定义

不实现__eq__方法，对象之间可以比较内存地址，也即是：不同对象，比较一定是false结果

实现了__eq__方法，就可以按照自己的想法来决定2个对象是否相等了

class Student:
    def __init__(self,name,age):
        self.name = name    # 学生姓名
        self.age = age      #学生年龄

    # __str__魔术方法
    def __str__(self):
        return f"Student类对象，name:{self.name},age:{self.age}"

    # __lt__魔术方法
    def __lt__(self, other):
        return self.age < other.age

    def __le__(self, other):
        return self.age <= other.age

    def __eq__(self, other):
        return self.age == other.age

stu1 = Student("张三",19)
print(stu1)
print(str(stu1))

stu2 = Student("李四",26)
print(stu2)
print(str(stu2))
print(stu1>stu2)
print(stu1<stu2)

stu3 = Student("小红",19)
print(stu3)
print(str(stu3))
print(stu2>=stu3)
print(stu1<=stu3)

print(stu1==stu3)

6.总结