面向对象

面向对象：

将数据和函数一起封装，减少了重复代码

面向过程：

根据业务逻辑从上到下依次写代码

1.类

class EatClass(object):
    def __init__(self,person_name):
        '''对象的属性（静态）'''
        self.person = person_name
    
    def dianti(self):
        print('调用电梯')

    def road(self):
        print('过马路')

1、类名：大驼峰式的命名规则
2、新式类的写法
3、具有相同属性和行为的事务的统称
4、类的构成：
（1）类名
（2）类的属性：一组数据（属性）
（3）类的方法：进行操作的方法（行为）

2.对象

根据类，产生对象，类是生生产对象的模板

1、类的实例化：类名(init需要的参数)
2、__init__(self)自动调用

3.__new__ 、__init__的区别

    @staticmethod # known case of __new__
    def __new__(cls, *more): # known special case of object.__new__
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass


 def __init__(self): # known special case of object.__init__
        """ Initialize self.  See help(type(self)) for accurate signature. """
        pass

1、new方法创建一个新对象，并且返回

2、init方法对创建的对象进行初始化操作

3、new方法先执行，init方法后执行

4.self

self指向的是对应的实例化对象

self.name = name    #属性的定义

class Lei:
    name = 'sss'

Lei().name = 'asd'    #属性的改变
Lei().age = 18  #属性的增加

class A:
    def __init__(self):
        self.name = 'asd'

    def s(self):
        print(self.name)         #属性的调用

5.私有属性与方法

self.__name = 'asd'         #私有属性
self.name = 'asd'        #公有属性


class A:
    def __s(self):
        print('asd')        #私有方法
    
    def s(self):
        print('dsa')        #公有方法

6.__str__与__repr__

__str__ 目的是可读性好，是为使用者准备的

__repr__ 目的是为了表示清楚，是为开发者准备的

class A:

    def __str__(self):
        return '这是字符串'

print(str(A()))        #这是字符串
print(repr(A()))         #<__main__.A object at 0x0000021D8F9CCCC0>    对象id

class A:

    def __repr__(self):
        return '这是字符串'

print(str(A()))           #这是字符串
print(repr(A()))          #这是字符串

可知 __str__应该是默认调用了 __repr__

7.类方法

1、类方法的第一个参数必须是类对象
2、一般以cls作为形参
3、必须用 @classmethod这个装饰器进行装饰
4、类方法的调用，可以使用实例，也可以使用类对象

class A:
    
    @classmethod
    def b(cls):
        print('asd')

A.b()        #asd
A().b()        #asd

当存在继承时 cls指向最底层

8.静态方法

1、类中无需实例参与即可调用的方法(不需要self参数)

2、在调用过程中，无需将类实例化

3、直接在类之后使用.号运算符调用方法

class A:
    
    name = 'asd'

    @staticmethod
    def b():
        print(A.name)

A.b()        #asd

9.继承

1、格式：
class 类名（继承的基类）：
　　类的属性以及方法
2、如果出现了同名的方法，优先使用的是自己的方法，如果自己没有当前的属性和方法，就逐层去寻找自己的父类的属性以及方法

class A:
    def b(self):
        print('这是b')
    def c(self):
        print('这是A中的c')

class B(A):
    def c(self):
        print('这是B中的c')

s = B()
s.b()         #这是b
s.c()         #这是B中的c

多继承

python 2中 经典类深度优先，新式类广度优先

python 3中 经典类和新式类都广度优先

class A:
    pass

class B(A):
    pass

class C:
    pass

class D(B, C):
    pass
深度优先
D->B->A
广度优先
D->B->C->A

10.单例模式

确保一个类只有一个实例化对象

1.__new__ 构造单例模式

class Test(object):

    __instance = None

    def __new__(cls, *args, **kwargs):
        if cls.__instance is None:
            cls.__instance = super().__new__(cls)
        return cls.__instance

class T(object):

    pass


print(Test() == Test())        #True
print(T() == T())        #False

2.装饰器构造单例模式

def singleton(cls):
    _instance = {}

    def _singleton(*args, **kwargs):
        if cls not in _instance:
            _instance[cls] = cls(*args, **kwargs)
        return _instance[cls]
    return _singleton


@singleton
class Test(object):

    __instance = None

    def __init__(self):
        pass


print(Test() == Test())              #True