python基础总结（oop）

1.面向对象和面向过程的理解

面向过程：根据业务逻辑从上到下写代码

面向对象：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程

class Kind:
    # 定义类

  def sedan(self, name, wheel):

        # 方法列表

        """给对象赋初始值，也可以在参数上直接赋值"""

        self.name = name

        self.wheel = wheel
　　　　　　　print（"小汽车的名字：%s
小汽车的轮子：%s" % (self.name, self.wheel)）

　　def move(self):
    　　print("车在移动....")
    """返回值""" 

kind = Kind()
#把值赋给kind，然后用kind开执行操作
kind.sedan("兰博基尼", 4)
#给sadan里面的参数赋值，然后输出
kind.move()
print(kind)

2.__init__()方法

当创建Car对象后，在没有调用__init__()方法的前提下，BMW就默认拥有了2个属性wheelNum和color，原因是__init__()方法是在创建对象后，就立刻被默认调用了

__init__()方法，在创建一个对象时默认被调用，不需要手动调用

__init__(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中出了self作为第一个形参外还需要2个形参，例如__init__(self,x,y)

__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去

class Dog:

    def __init__(self,name,age):

        self.name=name

        self.age=age

        print("狗的名字：%s,狗的年龄%s"%(self.name,self.age))

    def meet(self):

        print("啃骨头。。。")

dog=Dog("乖乖",5)

print(dog)

3.   定义__str__()方法

在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法

当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据

作用就是在打印的时候消除这些信息，加上__str__这个方法会直接使用return中的数据
" v:shapes="文本框_x0020_101">class Cat:

    def __init__(self,name,age):

        self.name=name

        self.age=age

    def meet(self):

        print("吃鱼咯。。。")

    def __str__(self):

        return "猫的名字是：%s,猫的年龄是%s"%(self.name,self.age)

cat=Cat("乖乖",6)

print(cat)

cat.meet()

4.理解self

1）所谓的self，可以理解为自己

2）可以把self当做C++中类里面的this指针一样理解，就是对象自身的意思

3）某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可

5.私有属性

如果有一个对象，当需要对其进行修改属性时，有2种方法

1）对象名.属性名 = 数据 ---->直接修改

2）对象名.方法名() ---->间接修改

为了更好的保存属性安全，即不能随意修改，一般的处理方式为

1）将属性定义为私有属性

2）添加一个可以调用的方法，供调用

在定义的属性名字前加上两个下划线表示这个是私有的，也就只能在这个类里面调用

class Cat:

    def __init__(self, name):

        self.name = name

    def __move(self):

        print("不想走。。。"

    def __str__(self):

        return "猫的名字是：%s " % (self.name)

    def ss(self):

        self.__move()

cat = Cat("乖乖")

print(cat)

cat.ss()

5.__del__()方法

创建对象后，python解释器默认调用__init__()方法；

当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法

import time

class  Initialize:

    def __init__(self,name):

        print("方法被调用！")

        self.name=name

    def __del__(self):

        print("__del__方法被调用")

        print("对象立刻被pass。。。%s"%(self.name))

initialize=Initialize("小狗")

# del initialize

print("程序5秒钟后结束")

time.sleep(5)

6.函数的继承

1）将共性的内容放在父类中，子类只需要关注自己特有的内容

2）python中所有的内容都是对象，所有的对象都直接或间接继承了object

3）子类在继承的时候，在定义类时，小括号()中为父类的名字

4)父类的属性、方法，会被继承给子类

5)私有的属性，不能通过对象直接访问，但是可以通过方法访问

6)私有的方法，不能通过对象直接访问

7)私有的属性、方法，不会被子类继承，也不能被访问

8)一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用

class Inherit:

    def __init__(self):

        print("aaa")

class one(Inherit):

    def Inherit_one(self):

        print("bbb")

class two(one):

    def Inherit_two(self):

        print("ccc")

class three(two,one):

    def Inherit_three(self):

        print("ddd")

qwe=one()

qwe.Inherit_one()

print(one.__mro__)

print("***********")

sss=two()

sss.Inherit_two()

print(two.__mro__)

print("***********")

ppp=three()

ppp.Inherit_three()

print(three.__mro__)

6.重写/覆盖父类方法与调用父类方法

所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法

class Cat(object):

    def sayHello(self):

        print("halou-----1")

class Bosi(Cat):

    def sayHello(self):

        print("halou-----2")     

bosi = Bosi()

bosi.sayHello()

调用父类方法

class Cat(object):

    def __init__(self,name):

        self.name = name

        self.color = 'yellow'

class Bosi(Cat):

    def __init__(self,name):

        # 调用父类的__init__方法1(python2)

        # Cat.__init__(self,name)

        # 调用父类的__init__方法2

        #super().__init__()       #一般用于单继承

        # 调用父类的__init__方法3

        super(Bosi,self).__init__(name)   #一般用这个，多继承的时候按照__mro__方法调用

    def getName(self):

        return self.name



bosi = Bosi('xiaohua')

print(bosi.name)

print(bosi.color)

7.多态

什么是封装？

类是一种封装，将属性和方法封装。

函数也是一种封装，将具有一定共的逻辑代码封装到一个函数中，使用的时候调用即可

提高代码的扩展性。

什么是继承？

将公共的（共性的）属性和方法放在父类中，子类只关注自己特有的属性和方法。

提高代码的扩展性。

什么是多态？

一个对象在不同的情况下，具有不同的形态，用于强类型语言。是使用在继承和接口中实现。

Python中有两种说法：

1、python支持多态，python是一个弱类型，本身一个变量名，可以存储任何类型的值，可以理解为多种形态

2、python不支持多态，多态本身是用于强类型语言的，python是一个弱类型，所以不支持多态

8.类属性，实例属性

实例属性:通过类创建的对象又称为实例对象，对象属性又称为实例属性，记录对象各自的数据，不同对象的同名实例属性，记录的数据可能不相同，实例属性只能通过实例对象调用。

类属性:类属性就是类对象拥有的属性，它被该类的所有实例对象所共有。类属性可以使用类对象或实例对象访问

class Student:

    air_conditioner="on"    #定义类属性    两个下划线+类名表示私有属性         ，所以不能在类外通过类对象访问私有的类属性                                                                                                                                                         def __init__(self,name,age):   #定义实例属性

        self.name=name

        self.age=age

s1=Student("张三",20)

s2=Student("李四",22)

print(s1.age)  #访问实例属性

print(s1.name) #访问实例属性

print(Student.air_conditioner)#访问类属性

print(s1.air_conditioner)#访问类属性

print(s2.air_conditioner)#访问类属性

Student.air_conditioner="off"#修改类属性

s1.air_conditioner="on-off-on"#增加实例属性

del s1.air_conditioner   #删除类属性

9.静态方法和类方法

类方法需要用@classmethod来修饰，第一个参数必须是类对象，一般是cls，

实例方法不需要修饰，但是第一个属性也必须是类对象，一般是self

静态方法也需要用@staticmethod来修饰，可以不用定义参数，也可以自己顶一参数

class Dog:

    Dog_die = "no"  # 类属性，表示狗是否存活！

    def __init__(self, name, coloer):  # 实例属性，定义狗的名字和颜色

        self.name = name

        self.coloer = coloer

    def pekingese_1(self):  # 实例方法

        print("这是一条温顺的狗")

    @classmethod

    def pekingese_2(cls):  # 类方法

        print("这是一条不乖的小狗")

        return cls.Dog_die

    @staticmethod

    def pekingese_3():  # 静态方法

        print("无奈。。。")



dog = Dog("乖乖", "黑色")

dog.pekingese_1()    #实例属性输出

dog.pekingese_2()

dog.pekingese_3()

print(Dog.pekingese_2())    类方法输出

print(dog.name, dog.coloer)   

10.设计模式六大原则

1）设计模式

1. 设计模式六大原则（1）：单一职责原则

即一个类只负责一项职责

1. 设计模式六大原则（2）：里氏替换原则

所有引用基类的地方必须能透明地使用其子类的对象

1. 设计模式六大原则（3）：依赖倒置原则

高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。高内聚，低耦合。

1. 设计模式六大原则（4）：接口隔离原则

客户端不应该依赖它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。

1. 设计模式六大原则（5）：迪米特法则

一个对象应该对其他对象保持最少的了解。尽量降低类与类之间的耦合。

1. 设计模式六大原则（6）：开闭原则

一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。

2）设计分类

1. 创建型模式

主要目的：创建对象

共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

1. 结构型模式

主要目的：对象的组成和对象的关系

共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

1. 行为型模式

主要目的：对象的行为，对象能做什么

共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

3）__new__的使用

class A(object):

    def __init__(self):

        print("这是 init 方法")

    def __new__(cls):

        print("这是 new 方法")

        return object.__new__(cls)

A()

总结：

__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供

__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例

__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值

我们可以将类比作制造商，__new__方法就是前期的原材料购买环节，__init__方法就是在有原材料的基础上，加工，初始化商品环节

注意：本篇文章是个人总结，仅供参考。若出现其他问题，与写者无关，切勿用于商业获取福利！

　　　如果总结有勿，或者交流与学习，请与写着联系！qq：1349176744