第十四节课

多态的简介

一、多态是面向对象的三大特性之一。从字面上理解就是多种形态.
二、一个对象可以以不同的形态去呈现。
三、面向对象的三大特性: 1、封装 确保对象中数据的安全。 2、继承保证了对象的拓展性。 3、多态保证了程序的灵活性。
四、python中多态的特点: 1、只关心对象的方法是否重名，不关心对象所属的类型。 2、对象所属的类之间，继承关系可有可无。
3、多态的好处可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强。 4、多态是调用方法的技巧，不会影响到类的内部设计。

class A(object):

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

    def speak(self):
        print('大家好，我是%s' % self.name)


class B(object):

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

    def speak(self):
        print('大家好，我是%s' % self.name)


a = A('刘亦菲')
b = B('张惠妹')


def fun(obj):
    obj.speak()


fun(a)
fun(b)

# 鸭子类型: 当看到一只鸟走起路来像鸭子，游泳起来像鸭子，叫起来也像鸭子，那么这只鸟就可以称之为鸭子。
# 我们并不关心对象是什么类型，到底是不是鸭子，只关心行为。


class Yz(object):
    def fly(self):
        print('鸭子跑起来了')


class Te(object):
    def fly(self):
        print('天鹅飞起来了')


class Fj(object):
    def fly(self):
        print('飞机起飞了')


def fun(o):
    o.fly()


yz = Yz()
te = Te()
fj = Fj()  # 没有继承关系


# super()  为什么要有super()   继承和方法的重为基础
class Yy(object):
    def money(self):
        print('这是爷爷的钱')


class Bb(Yy):
    def money(self):
        super().money()  # 使用super()调用父类中的方法
        print('这是爸爸的钱')


class Mm(Bb):
    def money(self):
        super().money()
        print('这是妈妈的钱')


def money(obj):
    obj.money()


y = Yy()  # 有继承关系  有继承关系更加灵活
b = Bb()
m = Mm()
money(y)
money(b)
money(m)

属性和方法

一、属性
1、类属性，直接在类中定义的属性是类属性。
2、类属性可以通过类或者类的实例访问到。但是类属性只能通过类对象来修改，无法通过实例对象来修改。
3、实例属性：通过实例对象添加的属性属于实例属性。
4、实例属性通过实例对象来添加的属性是实例属性，只能通过实例对象调用，不能通过类对象调用。
二、方法
1、在类中定义，以self为第一个参数的方法都是实例方法。
2、实例方法中调用时，Python会将调用对象以self传入 3、实例方法可以通过类实例和类去调用。
4、当通过实例调用时，会自动将当前的调用对象作为self传入。 5、当通过类调用时，不会自动传递self，我们必须手动传递self。
5、类方法在类的内容以@classmethod来修饰的方法属性类方法。
6、类方法第一个参数是cls也会被自动传递，cls就是当前的类对象。
7、类方法和实例方法的区别，实例方法第一个参数是self，类方法的第一个参数是cls。
8、类方法可以通过实例调用，也可以通过类去调用。

# 类属性和实列属性
class A(object):

    # 类属性:  直接定义类中的属性
    # 类属性可以通过类和实例对象来调用
    # 类属性只能通过类对象来修改，不能通过实例对象来修改
    # mun = 0  # 类对象

    def __init__(self, name):
        self.name = name  # 这个属性是实例属性
        print(self)

    def speak(self):  # 实例方法
        print('大家好，我是%s' % self.name)

    @classmethod  # 类方法
    def run(cls):
        print('我能跑')

    def study(self):
        print('我是什么方法')

    @staticmethod
    def static():
        print('我是静态方法')  # 功能方法，工具方法


a = A('刘亦菲')
print(a)
# 实例属性通过实例对象来添加的属性是实例属性，只能通过实例对象调用，不能通过类对象调用
a.mun = 10  # 实例属性
# print(A.mun)

# print(A.mun)  # 使用类对象来调用属性
print(a.mun)  # 使用实例对象来调用属性
print(a.name)
# print(A.name)

# 方法
# 实例方法  实例方法类对象和实例对象都可以调用，但是类对象需要传递一个实例对象参数
# print(a.speak())
# print(A.speak(a))
# 类方法  实例对象和类对象都可以调用
# A.run()
# a.run()


# a.study()
# A.study()

# 静态方法
# 一、在类中用@staticmethod来修饰的方法属于静态方法
# 二、静态方法不需要指定任何默认参数，静态方法可以通过类和实例调用
# 三、静态方法，基本上是和当前类无关的方法，它只是一个保存到当前类中的函数
# 四、静态方法一般都是些工具方法，和当前类无关

a.static()
A.static()

单例模式

一、单例模式的介绍
1 、单例模式是一种常用的软件设计模式。也就是说该类只包含一个实例
2、通过单例模式可以保证系统中一个类只有一个实例并且该实例易于外界访问，
从而方便对实例的控制并且节约系统资源。
3、如果希望系统中某个类的对象只能存在一个，单例模式就是最好的解决方案。
通常应用在一些资源管理器中，比如日志记录等。
new()方法
new()方法用于创建与返回一个对象。在类准备将自身实例化时调用。
对象创建执行顺序
1、通过__new__()方法创建对象　2、并将对象返回，init
init()与__new__()的区别 __init__实例方法__new__静态方法
__init__在对象创建后自动调用__new__创建对象的方法

# class Deno(object):
#    def __init__(self):
#        print('__init__')
#
#    def __new__(cls, *args, **kwargs):
#        print('__new__')
#        return super().__new__(Deno)


# d = Deno()
# d1 = Deno()
# print(d)
# print(d1)

"""
做一个判断:1、如果实例存在了，我们就不在调用super这个方法，而是直接返回之前的那个实例对象
         2、如果不存在，就调用super方法创建实例并且返回
"""
class Dl(object):
    obj = None
    def __new__(cls, *args, **kwargs):
        if cls.obj is None:
            cls.obj = super().__new__(cls)
            return cls.obj
        else:
            return cls.obj


d = Dl()
d1 = Dl()
print(d)
print(d1)

模块的创建和使用

一、模块
1、模块化指将一个完整的程序分解成一个个的小模块
2、通过将模块组合，来搭建出一个完整的程序
3、模块化的优点: 1、方便开发 2、方便维护 3、模块可以复用
二、模块的创建
1、在python中一个py文件就是一个模块
2、在一个模块中引入外部模块import 模块名（模块名就是py文件）
3、可以引入同一个模块多次，但是模块的实例只会创建一次
4、import模块名as模块别名
5、在一个模块内部都有一个__name__.通过它我们可以获取模块的名字
6、如果py文件直接运行时，那么__name__默认等于字符串’main’。
__name__属性值为__main__的模块是主模块。一个程序中只有一个主模块

import cs
import cs
import cs as test
from cs import fun
from cs import *  # 导入所有


# print(cs)
# fun()
# print(a)
# print(b)

# print(__name__)


a = A('刘亦菲')


import random
import  time
import os
import sys

print('这是我的第一个模块')


# a = 1
# b = 2


def fun():
    print('我是fun')


print(__name__)


class A(object):
    def __init__(self, name):
        self.name = name
        print(self.name)


if __name__ == '__name__':  # main函数  程序的人口函数   不是在当前模块运行的程序，那么这个程序就不会运行。
    b = A('周慧敏')