从零开始学python---对象

一、基础介绍

步骤为设计类->创建对象->对象属性赋值
这里通俗介绍一下：
类：对同类型对象抽象出共性，形成类
对象：将数据以及对数据的操作方法封装到一起，作为一个相互依存不可分割的整体
下面简单进行一下演示：用对象存储数据

#设计一个类
class Student:
    name = None
    age = None
    gender = None
#创建一个名字为stu_1的对象
stu_1  = Student()
stu_1.age = 10
stu_1.name = "wjm041006"
stu_1.gender = "中国"

print(stu_1.name,stu_1.age,stu_1.gender)

'''
结果为
wjm041006 10 中国
'''

类的基本使用语法
class 类名称:
    类的属性（成员变量）
    类的行为（函数 = 成员方法）
创建对象
对象名称 = 类名称()

note：类内部的函数称为方法，self表示这个函数是方法，在类内部。同时成员方法想要访问类内部的变量，必须使用self.变量名，传参的时候不传self。

def 方法名(self,形参1,形参2....,形参n)
    方法内容

类包含属性和行为，相当于设计图纸，而对象是对类的实例化，就是通过图纸生产产品

二、构造方法

python类使用的__init__()方法，称为构造方法
在创建类对象的时候会自动执行，也可以在创建类对象的时候传入参数，自动传递给__init__()使用

#设计一个类
class Student:
'''可以省略前面三个变量的定义，因为下方的构造函数可以定义并赋值'''
    name = None
    age = None
    gender = None

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

stu_1 = Student("wjm",18,"沃尔玛塑料袋")

print(stu_1.name,stu_1.age,stu_1.gender)

'''
结果为
wjm 18 沃尔玛塑料袋
'''

note:在构造方法中定义变量，要加上self关键字

三、其余常见类似内置的类方法

__str__()字符串方法
__lt__()类小于符号比较方法，实现类之间的比较

__le__()类小于等于比较方法
__eq__()类等于等于比较方法

#设计一个类
class Student:

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

    def __str__(self):
        return f"name:{self.name},age:{self.age},gender:{self.gender}"

    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

stu_1 = Student("wjm",18,"沃尔玛塑料袋")
stu_2 = Student("www",180,"清朝老兵")

#str返回值为字符串
print(str(stu_1))
#lt类的小于符号比较（也可以比较大于）
print(stu_1 < stu_2)
#le类小于等于符号的比较
print(stu_1 <= stu_2)
#==比较运算符
print(stu_1 == stu_2)
'''
结果为
name:wjm,age:18,gender:沃尔玛塑料袋
True
True
False
'''

四、封装

封装定义：封装是指将现实世界中的属性和行为映射到类中
私有成员：现实世界中存在不公开的属性和行为，python中提供私有成员变量和私有成员方法
私有成员变量和方法的定义：在定义的变量和方法前面加上两个下划线
note:私有成员变量和方法无法在对象中直接使用，但是类中的其它成员可以使用

五、继承

5.1 继承的基本语法

继承的定义：从已经定义好的类中继承成员变量和成员方法
继承分为单继承和多继承
单继承为一个子类对应一个父类
多继承为一个子类对应多个父类
类单继承的形式：
class 子类(父类):
        子类内容
类单继承的形式：
class 子类(父类1,父类2,父类3......):
        子类内容

#设计一个单继承的示例
class Phone:
    ID = "wjm041006"
    def call_model(self):
        print("4G")

#继承的类
class Phone_new(Phone):
    face = True

    def call_model_new(self):
        print("5G")

Phone_wjm = Phone_new()
print(Phone_wjm.ID)
Phone_wjm.call_model_new()
Phone_wjm.call_model()

'''
结果为
wjm041006
5G
4G
'''

note；当涉及到多继承我们不想去增添其余内容的时候，可以直接使用pass关键字，这个起到一个补全语法的作用：

class wjm(wjm1,wjm2,wjm3):
#我这里不想定义一些其他的东西，wjm只需要继承上面三个类的属性就可以了
#使用pass关键字即可
    pass

note：在多继承中，如果涉及到重名的成员变量和成员方法，那么默认以从左到右的继承顺序为优先级，先继承的被保留，后继承的被覆盖

5.2 复写父类成员

复写定义：如果子类在继承父类的方法过后，若对从父类继承过来的方法不满意，就可以进行复写，就是在子类中重新定义父类中的成员变量或者成员方法

#设计一个类
class Phone:
    ID = "wjm041006"
#继承的类
class Phone_new(Phone):

    ID = "wjm"
Phone_wjm = Phone_new()
print(Phone_wjm.ID)

'''
结果为
wjm
'''

一旦进行复写过后，类对象调用成员的时候，就会调用复写后的成员，如果此时想要使用之前被复写的父类成员，那么可以使用以下两种方式：
1. 父类名.成员变量  父类名.成员方法(self)

2.使用super()调用父类成员：super().成员变量   super().成员方法() note:此处super调用的成员方法不需要使用self

# 设计一个类
class Phone:
    ID = "wjm041006"
# 继承的类
class Phone_new(Phone):
    ID = "wjm"

    def text(self):
        # 父类名调用
        print(Phone.ID)
        # super调用
        print(super().ID)

Phone_wjm = Phone_new()
print(Phone_wjm.ID)
Phone_wjm.text()

'''
结果为
wjm
wjm041006
wjm041006
'''

六、多态

多态指的为多种状态，即完成某一行为时，使用不同的对象得到不同的状态
多态常作用在继承关系上，即以父类做定义声明，以子类做实际工作

class animal:
    def speak(self):
        pass

class Dog(animal):
    def speak(self):
        print("wawawa")

class Cat(animal):
    def speak(self):
        print("miao")

def make_noise(animal):
    animal.speak()
dog = Dog()
cat = Cat()

make_noise(dog)
make_noise(cat)
'''
结果为
wawawa
miao
'''

抽象类：当父类的方法是空实现，具体的实现方法由子类自行决定，这种写法称为抽象类，具体来说，含有抽象方法的类称为抽象类
抽象方法：方法体为空实现
抽象类的主要作用是作为一个顶层设计，以便于子类做具体实现，也是对子类的一种约束，要求子类必须复写一些父类的方法