python3 类 单例 python3类和对象

Python 类与对象

• Python 类与对象

• 类
• 对象
• 示例

• Python 属性（实例属性、类属性）

• 实例属性
• 类属性
• 示例

• Python 方法（实例方法、类方法、静态方法）

• 实例方法
• 类方法
• 静态方法
• 示例

• Python 类的继承

• 类的继承
• 示例

Python 类与对象

类

类 —— 一群具有 相同特征或相同行为 的事物的一个统称 —— 人类：

（1）类只有一个
（2）特征：一般为特性, Python中称为属性
（3）行为：一般为动作, Python中称为方法（在类的外面定义的一定是函数, 在类的里面定义的才是方法）
（4）在类下可以调用类外的函数

对象

对象 —— 一个具体的存在 —— 男人 女人 性别不详的人：

（1）对象由类创建（创建对象是一个实例化的过程）, 并且具有类的特征和行为
（2）对象有很多个
（3）每个对象间拥有不同的属性值
（4）每个对象的实例属性是独有的

示例

class PeopleInfo:
    head = 1

    def __init__(self, name, age, height):
        """
        构造方法 —— 绝大多数情况下会用__init__方法来创建属性

        :param name:形参, 由类名("张三")来传参实参
        :param age:形参, 由类名(20)来传参实参
        :param height:形参, 由类名(170)来传参实参
        """
        self.name = name
        self.age = age
        self.height = height

    def run(self):
        """
        实例方法 —— 在类下创建的方法, 如果带 self, 那么它叫做实例方法
        """
        print("{}会跑步".format(self.name))

    def __str__(self):
        """
        魔术方法 —— 使用return来定义

        （1）如果使用print函数打印一个对象, 那么会自动调用__str__实例方法
        （2）往往_str__实例方法需要返回一个字符串, 否则会报错
        """
        return "{}".format(self.name)


one_person = PeopleInfo("张三", 20, 170)  # 类名() 默认调用__init__方法, 实参
two_person = PeopleInfo("李四", 30, 180)

one_person.run()
print(one_person.__str__())

输出：

/home/zhanglei/PycharmProjects/untitled/venv/bin/python /home/zhanglei/PycharmProjects/untitled/zl/classAobject.py
张三会跑步
张三

Process finished with exit code 0

Python 属性（实例属性、类属性）

属性：
实例属性 ——
类属性 —— 对象共有的特征

---

实例属性

在类的外面

        赋值（创建）
                        类名.实例属性名 = 属性值（错误用法，执行报错）　
            对象.实例属性名 = 属性值（不推荐）　　　　
        调用
                        类名.实例属性名（错误用法，执行报错）　
            对象.实例属性名

在类的里面

        赋值（创建）
            使用__init__方法来给实例属性赋值（写死）
            self.实例属性名 = 属性值　　
                        cls.实例属性名 = 属性值（错误用法，执行报错）　　
        调用
            self.实例属性名　　
                        cls.实例属性名（错误用法，执行报错）

实例属性, 在类外赋值（创建）, 使用 对象.实例属性名 = 属性值（不推荐）
实例属性, 在类外调用, 使用 对象.实例属性名

实例属性, 在类下赋值（创建）, 使用__init__方法来给实例属性赋值（写死）
实例属性, 在类下赋值（创建）, 使用 self.实例属性名 = 属性值
实例属性, 在类下调用, 使用 self.实例属性名

---

类属性

在类的外面

        赋值（创建）
            类名.类属性名 = 类属性值　　
                        对象.类属性名 = 类属性值（错误用法，执行报错）　　
        调用
            类名.类属性名　　
            对象.类属性名
        修改
            类名.类属性名 = 类属性值（不推荐）

在类的里面

        赋值（创建）
            类名.类属性名 = 类属性值
                        self.类属性名 = 类属性值（错误用法，执行报错）
            cls.类属性名 = 类属性值
        调用
            类名.类属性名
            self.类属性名
            cls.类属性名
        修改
            cls.类属性名 = 类属性值

类属性, 在类外赋值（创建）, 使用 类名.类属性名 = 类属性值
类属性, 在类外调用, 使用 类名.类属性名
类属性, 在类外调用, 使用 对象.类属性名
类属性, 在类外修改, 使用 类名.类属性名 = 类属性值（不推荐）

类属性, 在类下赋值（创建）, 使用 类名.类属性名 = 类属性值
类属性, 在类下赋值（创建）, 使用 cls.类属性名 = 类属性值
类属性, 在类下调用, 使用 类名.类属性名
类属性, 在类下调用, 使用 self.类属性名
类属性, 在类下调用, 使用 cls.类属性名
类属性, 在类下修改, 使用 cls.类属性名 = 类属性值

---

示例

class PeopleInfo:
    head = 1
    print("1 类属性 —— 对象共有的特征：", head)

    def __init__(self, name, age, height):
        self.fair = "假发"
        print("2 实例属性, 在类下赋值（创建）, 使用__init__方法来给实例属性赋值（写死）：", self.fair)
        self.name = name
        self.age = age
        self.height = height
        print("3 实例属性, 在类下赋值（创建）, 使用 self.实例属性名 = 属性值：", self.name)
        print("4 实例属性, 在类下调用, 使用 self.实例属性名：", self.height)

    def info(self):
        PeopleInfo.hand = 1
        print("5 类属性, 在类下赋值（创建）, 使用 类名.类属性名 = 类属性值：", PeopleInfo.hand)
        print("6 类属性, 在类下调用, 使用 类名.类属性名：", PeopleInfo.head)
        print("7 类属性, 在类下调用, 使用 self.类属性名：", self.head)

    @classmethod
    def angry(cls):
        cls.foot = 1
        print("8 类属性, 在类下赋值（创建）, 使用 cls.类属性名 = 类属性值：", cls.foot)
        print("9 类属性, 在类下调用, 使用 cls.类属性名：", cls.head)
        cls.head = 2
        print("10 类属性, 在类下修改, 使用 cls.类属性名 = 类属性值：", cls.head)

        pass


one_person = PeopleInfo("张三", 20, 170)
one_person.info()
one_person.angry()

# =======================================================================================
one_person.name = "小明"
print("11 实例属性, 在类外赋值（创建）, 使用 对象.实例属性名 = 属性值（不推荐）：", one_person.name)
print("12 实例属性, 在类外调用, 使用 对象.实例属性名：", one_person.age)

# =======================================================================================
PeopleInfo.eye = 3
print("13 类属性, 在类外赋值（创建）, 使用 类名.类属性名 = 类属性值：", PeopleInfo.eye)
print("14 类属性, 在类外调用, 使用 类名.类属性名：", PeopleInfo.head)
print("15 类属性, 在类外调用, 使用 对象.类属性名：", one_person.head)
PeopleInfo.head = 3
print("16 类属性, 在类外修改, 使用 类名.类属性名 = 类属性值（不推荐）：", PeopleInfo.head)

输出：

/home/zhanglei/PycharmProjects/untitled/venv/bin/python /home/zhanglei/PycharmProjects/untitled/zl/attributes.py
1 类属性 —— 对象共有的特征： 1
2 实例属性, 在类下赋值（创建）, 使用__init__方法来给实例属性赋值（写死）： 假发
3 实例属性, 在类下赋值（创建）, 使用 self.实例属性名 = 属性值： 张三
4 实例属性, 在类下调用, 使用 self.实例属性名： 170
5 类属性, 在类下赋值（创建）, 使用 类名.类属性名 = 类属性值： 1
6 类属性, 在类下调用, 使用 类名.类属性名： 1
7 类属性, 在类下调用, 使用 self.类属性名： 1
8 类属性, 在类下赋值（创建）, 使用 cls.类属性名 = 类属性值： 1
9 类属性, 在类下调用, 使用 cls.类属性名： 1
10 类属性, 在类下修改, 使用 cls.类属性名 = 类属性值： 2
11 实例属性, 在类外赋值（创建）, 使用 对象.实例属性名 = 属性值（不推荐）： 小明
12 实例属性, 在类外调用, 使用 对象.实例属性名： 20
13 类属性, 在类外赋值（创建）, 使用 类名.类属性名 = 类属性值： 3
14 类属性, 在类外调用, 使用 类名.类属性名： 2
15 类属性, 在类外调用, 使用 对象.类属性名： 2
16 类属性, 在类外修改, 使用 类名.类属性名 = 类属性值（不推荐）： 3

Process finished with exit code 0

Python 方法（实例方法、类方法、静态方法）

方法：
实例方法 —— 在类下创建的方法, 如果带 self, 那么它叫做实例方法
类方法 —— 使用 @classmethod 定义
静态方法 —— 使用 @staticmethod 定义

实例方法 —— 只能被对象调用; 处理实例属性
类方法 —— 能被对象和类来调用; 处理类属性
静态方法 —— 能被对象和类来调用; 与对象和类没有直接关系的一段逻辑

---

实例方法

在类的外面

        调用
                        类名.实例方法()（错误用法，执行报错）
            对象.实例方法()

在类的里面

        调用　　
                        类名.实例方法()（错误用法，执行报错）
            self.实例方法()
                        cls.实例方法()（错误用法，执行报错）

实例方法, 在类外调用, 使用 对象.实例方法()

实例方法, 在类下调用, 使用 self.实例方法()

---

类方法

在类的外面

        调用
            类名.类方法()
            对象.类方法()

在类的里面

        调用
            类名.类方法()　
            self.类方法()

类方法, 在类外调用, 使用 类名.类方法()
类方法, 在类外调用, 使用 对象.类方法()

类方法, 在类下调用, 使用 类名.类方法()
类方法, 在类下调用, 使用 self.类方法()

---

静态方法

在类的外面

        调用
            类名.静态方法(参数)
            对象.静态方法(参数)

在类的里面

        调用
            类名.静态方法(参数)　　
            self.静态方法(参数)
            cls.静态方法(参数)

静态方法, 在类外调用, 使用 类名.静态方法(参数)
静态方法, 在类外调用, 使用 对象.静态方法(参数)

静态方法, 在类下调用, 使用 类名.静态方法(参数)
静态方法, 在类下调用, 使用 self.静态方法(参数)
静态方法, 在类下调用, 使用 cls.静态方法(参数)

---

注：对象不能调用类外面的函数

---

示例

class PeopleInfo:

    head = 1

    def __init__(self, name, age, height):

        self.fair = "假发"

        self.name = name
        self.age = age
        self.height = height

        print("1 实例方法, 在类下调用, 使用 self.实例方法()：", self.run())

        print("2 类方法, 在类下调用, 使用 类名.类方法()：", PeopleInfo.angry())
        print("3 类方法, 在类下调用, 使用 self.类方法()：", self.angry())

        print("4 静态方法, 在类下调用, 使用 类名.静态方法(参数)：", PeopleInfo.weather('晴朗'))
        print("5 静态方法, 在类下调用, 使用 self.静态方法(参数)：", self.weather('晴朗'))

    def run(self):
        """
        实例方法 —— 在类下创建的方法, 如果带 self, 那么它叫做实例方法
        """
        return self.name + '会跑步'

    @classmethod  # 装饰器, 类方法来处理类属性的
    def angry(cls):  # 如果不加装饰器, 默认创建实例方法(当对象调用类方法时, 会把对象所属的类ID自动赋值给cls)
        """
        类方法 —— 使用 @classmethod 定义
        """
        return '生气'

    @classmethod
    def smile(cls):
        print("6 静态方法, 在类下调用, 使用 cls.静态方法(参数)：", cls.weather('晴朗'))

    @staticmethod
    def weather(motion):  # 静态跟类外面定义的函数几乎没有区别, 只是位置不同
        """
        静态方法 —— 使用 @staticmethod 定义
        """
        return motion


one_person = PeopleInfo("张三", 20, 170)
one_person.smile()

# =======================================================================================
print("7 实例方法, 在类外调用, 使用 对象.实例方法()：", one_person.run())

# =======================================================================================
print("8 类方法, 在类外调用, 使用 类名.类方法()：", PeopleInfo.angry())
print("9 类方法, 在类外调用, 使用 对象.类方法()：", one_person.angry())

# =======================================================================================
print("10 静态方法, 在类外调用, 使用 类名.静态方法(参数)：", PeopleInfo.weather('晴朗'))
print("11 静态方法, 在类外调用, 使用 对象.静态方法(参数)：", one_person.weather('晴朗'))

输出：

/home/zhanglei/PycharmProjects/untitled/venv/bin/python /home/zhanglei/PycharmProjects/untitled/zl/methods.py
1 实例方法, 在类下调用, 使用 self.实例方法()： 张三会跑步
2 类方法, 在类下调用, 使用 类名.类方法()： 生气
3 类方法, 在类下调用, 使用 self.类方法()： 生气
4 静态方法, 在类下调用, 使用 类名.静态方法(参数)： 晴朗
5 静态方法, 在类下调用, 使用 self.静态方法(参数)： 晴朗
6 静态方法, 在类下调用, 使用 cls.静态方法(参数)： 晴朗
7 实例方法, 在类外调用, 使用 对象.实例方法()： 张三会跑步
8 类方法, 在类外调用, 使用 类名.类方法()： 生气
9 类方法, 在类外调用, 使用 对象.类方法()： 生气
10 静态方法, 在类外调用, 使用 类名.静态方法(参数)： 晴朗
11 静态方法, 在类外调用, 使用 对象.静态方法(参数)： 晴朗

Process finished with exit code 0

Python 类的继承

类的继承

1.继承:父类有的子类也有（私有方法(__private_method)和私用属性(__private_attrs)除外） —— 类名(父类名)
2.多继承:继承多个父类（若继承多个父类有相同的函数, 则继承前面的函数）
3.超继承：继承父类并添加了新特性 —— super(类名, self).属性名/方法名(参数)
4.重写：子类中重写父类
5.拓展：子类中父类没有的函数

示例

class Dad:  # 父类

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

    def sport(self, hours):
        print(self.name + "运动{}小时".format(hours))

    def cooking(self):
        print(self.name + "会做红烧肉")

    def smoke(self):
        print(self.name + "吸烟")


class Mother:  # 父类

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

    def cooking(self):
        print(self.name + "会做寿司")


class Girl(Dad):  # 子类（继承）

    def sport(self, hours):  # 超继承
        super(Girl, self).sport(hours)  # 保持父类的特性
        print(self.name + "早晨运动")

    def smoke(self):  # 重写
        print(self.name + "不吸烟")

    def coding(self):  # 拓展
        print(self.name + "是一个程序员")


class Son(Mother, Dad):  # 子类（多继承）
    pass


Girl("丽丽", "20").cooking()  # 继承
Girl("丽丽", "20").sport(1)  # 超继承
Girl("丽丽", "20").smoke()  # 重写
Girl("丽丽", "20").coding()  # 拓展
Son("明明", "25").cooking()  # 多继承

输出：

/home/zhanglei/PycharmProjects/untitled/venv/bin/python "/home/zhanglei/PycharmProjects/untitled/zl/inheritance .py"
丽丽会做红烧肉
丽丽运动1小时
丽丽早晨运动
丽丽不吸烟
丽丽是一个程序员
明明会做寿司

Process finished with exit code 0