面向过程

着眼于具体的细节

面向对象

着眼于某一种特殊功能的方法
类和对象是面向对象的核心

面向过程与面向对象区别与联系

类

物以类聚，人以群分
将一个具有相同功能，称之为一个类
类用于描述某一个对象的共同特征

对象

一个类中，具有特殊功能的实体 ，是类的具体存在

例子：
假设狗设为一个类
类属性：毛的颜色。名字
方法：狗会咬人，会叫，会吃

封装 对象=属性+方法

实例化对象

类的语法

class 类名（）：
类体

设计类，三大步：
1.事物的名称 – 类名
2.事物的特征-属性 – 属性
3.事物的行为 --方法

构造函数（Python内置的函数）

# 实例化对象时，会自动调用此函数
# 作用：初始化处理对象属性
def __init__(self):
    pass

析构函数

# 当对象被销毁的时候自动调用
def __del__(self):
    pass

有关self

1.self代表对象自己本身
2.定义函数self必须声明，传递参数的时候我们无需传递此参数，
对象会将自己作为第一个参数传递进去
3.self并不是一个关键字，是一种约定俗成的写法/也可自定义
4.self定义的位置一定是参数列表中的第一个位置

创建简单类

class Dog：
    def __init__(self,name,color):
        self.name = name
        self.color = color
    def eat(self):
        print('大狗狗吃狗粮！')
    def biter(self):
        print('谁来咬谁！')
if __name__ == '__main__':
    dog = Dog('大黄'，'黄色')
    dog.eat()          # 大狗狗吃狗粮
    print(dog.name)    # 大黄
    print(dog.color)   # 黄色

类变量（类属性）

定义在类中，并且在函数体之外的变量，我们称之为类变量，类变量一般情况建议使用类名来进行调用，但是
若使用对象来进行调用也不报错

成员变量（类属性）

定义在类的函数中，并且绑定在self身上的变量，我们称之为成员变量，
成员变量一定使用对象来进行调用的，不能使用类名来进行调用

类变量以及成员变量的区别：

1.定义的位置不同 类变量定义在类中的函数体之外，成员变量定义在类的函数中并且绑定在self身上的变量
2.访问的方式不同 成员变量必须使用对象来访问，类变量使用类名来访问，也可以使用对象
3.在内存中出现的时机不同 类变量随着类的加载创建，而成员变量随着对象的创建而创建
4.优先级不同 当使用对象来访问类变量与成员变量的时候，优先访问成员变量。

通过对象动态添加类变量

通过对象动态添加/修改类变量

class Person:
    age = 20
    def __init__(self,name):
        self.name = name

def say():
    print("hello")
    
if __name__ == '__main__':
    # 创建对象per
    per = Person('王五')
    per.color = '黄色'
    # 动态添加类变量
    print(per.color) # 黄色
    # 通过对象更改类变量，其实是动态创建了一个跟类变量同名的变量
    per.age=25
    print(per.age) # 25
    # 加载类方法
    per.say() # hello
    

    # 创建对象per2
    per2 = Person('王五')
    # 由对象per修改的类变量并没有真正的修改
    print(per2.age) # 20
    # 用类修改类变量
    Person.age = 33
    print(per2.age) # 33

    # 创建对象per3
    per3 = Person('王五')
    # 通过类修改的类变量，在其他对象中，也会跟着改变
    print(per3.age) # 33

总结：
我们可以动态给对象或者是类绑定属性以及方法
1.使用对象动态绑定属性以及方法的时候，只对当前对象起作用，
若是使用类名来进行绑定，对整个类起作用

2.使用对象可以调用类变量 不能直接修改类变量（通过类可以修改类变量的值），我们看到的对类变量的更改，
其实是创建一个新的变量，这个新的变量与类变量同名，使用对象来更改的类变量，只对当前对象起作用。

slots_ 对当前类的dongtai方法和动态成员变量进行限制，能够动态添加的属性名（包括__init__中的类属性，如果不加，将抛出异常）以及方法名加入slots中

class Person:
    
    # 将可以动态修改的的成员变量和方法加入__slots__中
    __slots__ = ("name")

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


def say():
    print("hello")

if __name__ == '__main__':
    per = Person('赵六')
    # 未加入__slots__ 中，不能够动态加载
    per.say() # 报错 'Person' object has no attribute 'say'
    per.name = '钱七'
    print(per.name) 
    # 当类中加了 __solts__后，不能直接通过对象更改类变量
    per.age = 22 # 报错 'Person' object attribute 'age' is read-only

成员方法

1.一般情况下定义在类中的方法,都是成员方法,不需要任何装饰器来进行装饰,
调用的时候使用对象来进行调用,不能使用类名调用。

class Person:

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

    def say(self):
        print("hello")

if __name__ == '__main__':
    per = Person("lili",20)
    # Person.say() # 报错

静态方法

1.当一个普通的方法，写在类中 与 写在类的外面写法都是相同，这个函数我们就可以将其写为静态方法
使用@staticmethod装饰器来进行装饰
调用的时候建议使用类名来进行调用，若使用对象来进行调用也不报错(跟类方法一样：@classmethod)

from datetime import datetime

class Person:

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

    def say(self):
        print("hello")

    @staticmethod
    def welcome(name):
        print("欢迎光临....%s"%name)

if __name__ == '__main__':
    print(datetime.now())
    per = Person("lili",18)
    per.welcome("xiaoming")
    Person.welcome("xiaohua")

类方法

类方法不是绑定到对象上，而是绑定在类上的方法
1.类方法是给我们的类准备的，调用的时候建议 使用类名 来进行调用(跟静态方法一样：@staticmethod)
使用对象来进行调用也不报错，但是有时候会让人引起误解
2.什么时候使用类方法？
.当在这个函数中，使用到类变量，类方法，静态方法的时候我们可以将此函数写成类方法
.类方法使用:@classmethod装饰器来进行装饰

from datetime import datetime

class Person:
   sex = 'boy'
   def __init__(self,name,age):
      self.name = name
      self.age = age

   def say(self):
      print('English')

   @classmethod
   def getSex(cls):
      print(cls) # <class '__main__.Person'>
      print(cls.sex) # boy
      cls.welcome()

   @staticmethod
   def welcome():
      print('欢迎光临！')


if __name__ == '__main__':
   per = Person('lili',18)
   print(Person) # <class '__main__.Person'>
   Person.getSex()
   # per.getSex()
   print(datetime.now())
   # print(datetime(2018,9,19).now())  # 不推荐

成员方法，类方法，静态方法 总结

1.成员方法不需要装饰器，类方法使用@classmethod，静态方法使用@staticmethod
2.成员方法使用对象来进行调用，类方法与静态方法建议使用类名（使用对象来进行调用也不报错，不建议）
3.成员方法与类方法都有一个隐式参数，声明的时候必须声明在参数列表的第一个位置，成员方法
为self代表对象本身，类方法使用cls，代表类本身。这个两个参数都不需要手动传递，
而静态方法没有隐式参数

code：

'''
1.计算正方形周长与面积
2.若传递了高的参数，计算正方体的体积。
'''


class  Square():
    def __init__(self,length):
        self.length = length

    def getArea(self):
        return self.length**2

    def getVolume(self,height):
        return self.getArea()*height



class  Square2():
    length = 10

    @classmethod
    def getArea(cls):
        return cls.length**2

    @classmethod
    def getVolume(cls,height):
        return cls.getArea()*height


class Square3():
    @staticmethod
    def getArea(length):
        return length ** 2

    @classmethod
    def getVolume(cls,length, height):
        return cls.getArea(length) * height


if __name__ == '__main__':
    squ = Square(10)
    print(squ.getArea()) # 100
    print(squ.getVolume(10)) # 1000

    squ2 = Square2()
    print(squ2.getArea()) # 100
    print(squ2.getVolume(10)) # 1000

    # 类方法和静态方法，直接用类调用
    print(Square3.getArea(10)) # 100
    print(Square3.getVolume(10,10)) # 1000

命名变量 + 下划线

1.foo：普通变量
2.foo：一般系统定义的变量，前后双下划线，可以直接访问，类似于__init__()
3.__foo:私有(private)变量，只能在本类中访问
4._foo:保护(protected)类型的变量，可以直接被访问，但是请把它视为私有的来进行访问
5.当函数名前面添加双下划线就变成了私有方法，只能在本类中调用。

class Father:
    def __init__(self,name,age,sex,money):
        self._name_ = name
        self.__age__ = age
        self._sex = sex
        self.__money = money

    def __say(self):
        print("hello")
    def say(self):
        self.__say()

if __name__ == '__main__':
    father = Father("小明", 18, "boy", 2000)
    print(father._name_) # 小明
    print(father.__age__) # 18
    print(father._sex) # boy
    father.say() # hello
    # print(father.__money) # 私有属性，不能直接访问，抛出异常
    

封装 – 语法糖

1.面向对象语言的三大特征：
.封装，继承，多态
2.封装：
.广义的封装：类与函数就是封装的体现
.狭义的封装：在本类的某些属性不希望外界直接访问，这时候我们这个属性私有化，
只有本类持有，再给外界暴露出一个访问的接口即可
.封装的本质:就是属性私有化的过程
3.优点：
.提高数据的复用性
.保证数据的安全性
4.语法糖—@property功能：
.可以将获取getter函数作为属性来进行访问,于此同时会产生一个新的装饰器@属性.setter，
这个装饰器可以将设置的方法setter变成属性进行调用
.注意：使用@属性.setter应在@property后面

'''
创建一个爸爸类，
属性：name  age  sex  money
将money私有化
超过一千块免谈
'''

class Father:
    def __init__(self,name,age,sex,money):
        self.name = name
        self.age = age
        self.sex = sex
        self.__money = money

    @property
    def mon(self):
        return self.__money

    @mon.setter
    def money(self,mon):
        if mon<=1000 and self.__money >= mon:
            self.__money -= mon
            print("给你...")
        else:
            print("免谈，没钱！！！")

    # def getMoney(self):
    #     return self.__money


class Girl:
    def __init__(self,name,age):
        self.name = name
        self.__age = age

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self,age):
        if age>= 0 and age <= 160:
            self.__age = age
        else:
            print("年龄非法...")


if __name__ == '__main__':
    father = Father("小明",18,"boy",2000)
    # father.money = 1200
    print(father.money)
    # print(father.getMoney())

    girl = Girl("lili",18)
    print(girl.name) # lili
    print(girl.age) # 18
    girl.age = 120 
    print(girl.age) # 120

封装 – 黑魔法

1.私有化属性不能直接访问，如：per.__money，是因为python解释器在解释被私有化变量的时候，
把__money变成了_PER__money(_类名__变量名)，可以通过解释出来的变量名去直接访问私有化属性，
但是不建议这么访问，因为不同解释器解释出来的变量名有可能不同。

class Father:
    def __init__(self,name,age,sex,money):
        self.name = name
        self.age = age
        self.sex = sex
        self.__money = money

if __name__ == '__main__':
    father = Father("小明", 18, "boy", 2000)
    print(father._Father__money) # 2000
    father._Father__money -= 100
    print(father._Father__money) # 1900

继承

从左到右

继承：
若两个或者两个以上的类拥有相同的属性以及方法，我们可以将共同的属性以及方法
抽取出来，在一个公共的类中进行声明，这个被抽取出来的类，我们称之为父类/超类/基类
其他类我们称之为子类/派生类/衍生类，他们之f间的关系，我们称之为继承。
注意：当一个类没有继承任何类的时候，默认继承object类，换句话说，
object类是一切类的基类

单继承：
1.一个子类只继承一个父类
2.子类可以直接使用父类中未私有化的属性以及方法
3.子类也可以拥有自己特有的属性以及方法
4.父类不能使用子类特有的属性以及方法
5.当子类拥有特有的属性的时候，需要重写init方法，在init方法中，
需要手动调用父类中的init，super().init()

'''
语法：
class 类名(父类):
    类体
注意：父类可以省略，默认继承object
'''
'''
猫:
属性：color，name，sex，age，kind
行为：eat  sleep  play  catchmouse

狗：
属性：color，name，sex，age，kind
行为：eat sleep play  holddoor

老鼠
属性：color，name，sex，age，kind,fat
行为：eat sleep play  moya
'''
class Animal:

    def __init__(self,color,name,sex,age,kind):
        self.color = color
        self.name = name
        self.sex = sex
        self.age = age
        self.kind = kind
        print("父类中的init被调用了...")

    def eat(self,food):
        print("吃%s"%food)

    def sleep(self):
        print("特别能睡...")

    def play(self):
        print("玩...")


class Dog(Animal):

    def holddoor(self):
        print("看门...")


class Cat(Animal):

    def catchmouse(self):
        print("捉老鼠...")


class Mouse(Animal):

    def __init__(self,color,name,sex,age,kind,fat):
        self.fat = fat
        super().__init__(color,name,sex,age,kind)
        print("子类中的init被调用了")
        # super().sleep() # 调用父类方法

    def moya(self):
        print("磨牙...")


if __name__ == '__main__':
    mouse = Mouse("灰色","Jerry","公",1,"土拨鼠","胖的")
    print(mouse.name) # Jerry
    print(mouse.color) # 灰色
    print(mouse.fat) # 胖的
    mouse.moya() # 磨牙
    mouse.sleep() # 特别能睡... / 调用父类方法

    # 当父类中需含有动态数据（__init__）的时候，必须给，不然抛出异常
    dog = Dog("白色","二哈","公",2,"萨摩耶")
    dog.eat("狗粮") # 吃狗粮
    dog.sleep() # 特别能睡...
    dog.holddoor() # 看门...
    print(dog.name) # 二哈
    print(dog.age) # 2
    print(dog.kind) # 萨摩耶

    cat = Cat("黄色","猫咪","母",1,"橘猫")
    cat.eat("鱼") # 吃鱼
    cat.catchmouse() # 捉老鼠...
    print(cat.name) # 猫咪
    print(cat.sex) # 母

多继承：
就是指一个子类可以继承多个父类，多个父类在继承列表中是有顺序的(从左到右，从上到下)。
class 类名(继承列表)：
pass
1.一个子类可以继承多个父类
2.这个子类可以继承多个父类未私有化的属性以及方法
3.父类不能使用子类的属性以及方法
4.当多个父类中属性有差异的时候，我们需要重写子类的__init__方法
在子类init的方法中，手动调用父类的__init__
5.当多个父类中出现同名的方法的时候，优先继承写在继承列表前面的那个。

注意：当子类中与父类都有__solts__限制的时候，子类的限制是子类加上父类的并集

'''
Father类
属性：name，age，car，house，__money
行为：makemoney  drivecar

Mother类
属性：name，age，facevalue
行为：makeup  shopping  drivercar

son类:
属性：name，age，car，house，height
行为：study  spendmoney
'''

class Father():

    __slots__ = ("name","age","car","house","__money")

    def __init__(self,name,age,car,house,money):
        self.name = name
        self.age = age
        self.car = car
        self.house = house
        self.__money = money
        print("father的init被调用了...")

    @property
    def money(self):
        return self.__money

    def makemoney(self):
        print("赚钱....")

    def drivecar(self):
        print("会%s..."%self.car)


class Mother:

    def __init__(self,name,age,facevalue):
        self.name = name
        self.age = age
        self.facevalue = facevalue
        print("mather的init被调用了")

    def makeup(self):
        print("很会化妆哦...")

    def shopping(self):
        print("会购物哦....")

    def drivecar(self):
        print("开吉普车...")


class Son(Father,Mother):

    __slots__ = ("height")

    def __init__(self,name,age,car,house,money,height,facevalue):
        self.height = height
        # super().__init__(name,age,car,house,money)
        Father.__init__(self,name,age,car,house,money) # 多继承
        Mother.__init__(self,name,age,facevalue) # 多继承
        print("son的init被调用了")

    def study(self):
        print("学习赚钱....")

    def spendmoney(self):
        print("很会花钱哦....")

    def drivecar(self):
        Mother.drivecar(self)


if __name__ == '__main__':
    son = Son("小明",20,"奇瑞QQ","别墅",100000000,180,98)
    son.makemoney()
    son.spendmoney()
    son.drivecar()
    son.study()
    print(son.height)
    print(son.house)
    print(son.money)
    son.makeup()
    son.shopping()
    print(son.facevalue)

多态

什么是多态？
一种事物的多种表现形态，多态是基于继承而存在的。
例如：序列：list，tuple，str，dict
动物：猫，老鼠，狗

鸭子模型：
如果有一只鸟，走路像鸭子，叫声像鸭子，我们就可以称这只鸟叫鸭子。
在python中我们只关注数据的使用[方法，属性]，不关注数据的类型。

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

    def eat(self):
        print("特别能吃...")

    @staticmethod
    def run(anim):
        print("%s跑..."%anim.name)

class Dog(Animal):

    def eat(self):
        print("吃肉....")
    pass

class Cat(Animal):
    pass

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

if __name__ == '__main__':
    dog = Dog("大黄",1)
    per = Person("小明")
    Animal.run(dog)
    Animal.run(per)
    print(isinstance(dog,Dog))
    print(isinstance(dog,Animal))
    print(isinstance(per,Animal))

函数重写

__str__是系统中方法
当我们str()或者print()打印的时候，会自动调用此方法，在__str__中 返回结果就是
打印的结果

__repr__方法:是给机器用的,在python解释器里面直接敲对象名在回车后调用方法
若在类中实现__repr__但是没有实现__str__我们采用赋值的方式
str = repr
功能：方便我们查看

repr() 函数将对象转化为供解释器读取的形式

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

    def __str__(self):
        return '%s--%s'%(self.name,self.age)

    def __repr__(self):  # 这个函数就是在打印类的时候，控制类输出的字符串
        # return "%s-%s"%(self.name,self.age)
        # return "{!r}"%(self.name)   # 报错   {!r} 匹配format

        return 'Iiitem({!r})'.format(self.name)


    # __str__ = __repr__


if __name__ == '__main__':
    # print(type(datetime.now()) )
    per = Person("lili",19)
    print(per)
    print(type(per))

运算符重载

class myint(int):
    def __len__(self):
        return len(str(self))

class Person():
    def __init__(self, name, age):
        print(1)
        self.name = name
        self.age = age

    def __repr__(self):
        print(2)
        return "%s-%s" % (self.name, self.age)

    __str__ = __repr__

    '''
    需求：实现对象的相加，name选第一个对象的名字，age就是年龄和
    '''
    def __add__(self, other):
        print(3)
        return Person(self.name,self.age+other.age)


if __name__ == '__main__':
    # num1 = myint(123456789)
    # print(len(num1))
    per1 = Person("lili",19)
    per2 = Person("小明",20)
    per3 = Person("小化",20)
    print(per1+per2+per3)

'''
实现dict相加，求并集，key若出现重复，只显示一次
'''
import copy


class mydict(dict):

    def __add__(self, other):
        # d1 = copy.deepcopy(self)
        d1 = mydict(self.copy())
        for k,v in other.items():
            d1[k] = v
        return d1



'''
实现列表相减，列表相减，求差集
'''
class mylist(list):

    def __sub__(self, other):
        l1 = mylist()
        for x in self:
            if x not in other:
                l1.append(x)
        return l1

    def __rxor__(self, other):
        pass

    def __gt__(self, other):
        return len(self) > len(other)


if __name__ == '__main__':
    l1 = mylist([1,2,3,4,5])
    l2 = mylist([11,2,3,3,44,55])
    # print(l1-l2)
    # print(l2-l1)
    print(l1>l2)
    # set
    # d1 = mydict({1:2,2:3,3:4})
    # d2 = mydict({4:2,2:"hello",3:"good"})
    # d3 = mydict({4:2,22:"hello2",32:"good3"})
    # print(d1+d2+d3)
    # print(d1)
    # print(d2)

单例模式

单例模式：就是一个类只有一个对象(实例)。
单例模式，只生成一个实例对象，减少了对系统资源的开销
该类可以自行实例化并向整个系统提供这个实例，
这个类称为单例类，单例模式是一种对象创建型模式

class MySingleton:

    __obj = None  # 类属性
    __init_flag = True  # 设置初始化打印了
    def __new__(cls, *args, **kwargs):
        if cls.__obj == None:
            cls.__obj = object.__new__(cls)
        return cls.__obj

    def __init__(self,name):
        if MySingleton.__init_flag == True:
            print("init。。。")
            self.name = name
            MySingleton.__init_flag = False

if __name__ == '__main__':
    a = MySingleton("aa")
    b = MySingleton("bb")
    # print(a.name,b.name)
    # print("a:",a,"b:",b)
    # print("id(a):",id(a),"id(b):",id(b))
    # c = MySingleton("cc")
    # print("c:",c,"id(c):",id(c))
    #
    # print("a.name:",a.name,"b.name:",b.name)

应用场景

class CarFactory:

    __obj = None  # 类属性
    __init_flag = True

    def create_car(self,brand):
        if brand == "奔驰":
            return Benz()
        elif brand == "宝马":
            return BWM()
        elif brand == "比亚迪":
            return BYD()
        else:
            return "未知品牌，无法创建"

    def __new__(cls, *args, **kwargs):
        if cls.__obj == None:
            cls.__obj = object.__new__(cls)
        return cls.__obj

    def __init__(self):
        if CarFactory.__init_flag == True:
            print("init。Carfactory。。")
            CarFactory.__init_flag = False

class Benz:
    pass
class BWM:
    pass
class BYD:
    pass
 
if __name__ == '__main__':
	factory = CarFactory()
	# c1 = factory.create_car("奔驰")	
	# c2 = factory.create_car("宝马")
	# c3 = factory.create_car("比亚迪")
	# print(c1,c2)
	# print(id(c1),id(c2))
	
	# factory2 = CarFactory()
	# print(factory,factory2)
	# print(id(factory),id(factory2))
	

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


def per2dict(per):
    return {
    "name":per.name,"age":per.age}

def dict2per(d):
    return Person(d["name"],d["age"])

if __name__ == '__main__':
    per1 = Person("lili",18)
    per2 = Person("lili2",18)
    per3 = Person("lili3",18)
    per4 = Person("lili4",18)
    perlist = [per1,per2,per3,per4]

    # with open("per2.txt","w",encoding="utf-8") as f:
    #     for per in perlist:
    #         f.write(str(per2dict(per))+"\n")

    l1 = []
    with open("per2.txt","r",encoding="utf-8") as f:
        for line in f.readlines():
            pdict = eval(line)
            p = dict2per(pdict)
            l1.append(p)
    print(l1)



    # with open("per.txt","wb") as f:
    #     pickle.dump(perlist,f)
    # with open("per.txt","rb") as f2:
    #     res = pickle.load(f2)
    #     print(res)