python>oop

oop即Object Oriented programming,面向对象编程

何为编程:特定的语法+数据结构+算法

编程范式就是从经验中总结的套路:

　　面向过程编程

　　　　适用于简单的脚本,一次任务是极好的,可是复杂的,须要后期维护的就**了

　　面向函数编程

　　　　将电脑运算视为数学上的函数计算

　　　　优势:可读性强,由于数据不可变,因此多线程安全,完成同功能代码量比oop少,更清晰,速度也要高不少

　　　　缺点:因为数据不可变,因此很是占用运算资源,先天设计致使性能一直不够,要想大规模的使用函数式编程,还有不少问题

　　　面向对象编程

　　　　　　世界万物,皆可分类

　　　　　　世界万物,皆为对象

　　　　　　只要是对象,就属于类

　　　　　　只要是对象,就有属性

　　　　缺点:修改数据致使数据的不肯定性,为了写可重用的代码而产生的无用代码.并无彻底理解面向对象思想,为了面向对象而面向对象,使得代码晦涩难懂,后期维护产生问题..使用场景不能是性能苛刻的地方

oop简介

类:用来描述具备相同的属性和方法的对象的集合。它定义了该集合中每一个对象所共有的属性和方法。对象是类的实例

类变量:类变量在整个实例化的对象中是公有的.类变量定义在类中,函数体以外,一般不做为实例变量使用

数据成员:类变量或者实例变量用于处理类以及实例对象的相关的数据

方法重写:若是从父类继承的方法不能知足子类的需求,能够对其进行改写,这个过程叫作覆盖,也叫方法重写

实例变量：定义在方法中的变量，只做用于当前实例的类。

实例化：建立一个类的实例，类的具体对象。

方法：类中定义的函数。

 对象:类(模型)通过实例化后更好的被程序所调用,一个类能够实例化多个对象,一个对象能够有多个属性,对象包括两个数据成员（类变量和实例变量）和方法

三大特性

封装:在类中对数据的赋值,内部调用对外部是不可见的,这使类变成了一个容器

class people:

　　the_number_of_people = 0

　　def __init__(self,name,age):

　　　　self.Name = name

　　　　se;f.Age = age

　　def __del__(self):

　　　　print('It's over')

　　def eat(self):

　　　　print('%s is eating'%elf.Name)

　　def talk(self):

　　　　print('%s is talking'%self.Age)

def __init__(self): 方法是一种特殊的方法,被称为构造函数或者初始化方法

self 表明类的实例，表明当前对象的地址,,,self.Name则指向类..self 在定义类的方法时是必须有的，虽然在调用时没必要传入相应的参数。

the_number_of_people变量是一个类变量,他的值将会在这个类的全部实例之间共享,你能够在内部类或者外部类使用people.the_number_of_people访问

 

建立实例对象

peo1 = people('slz',19)建立people类的地一个对象

peo2 = people('sunlizhao',19.9)建立people的第二个对象

 

访问属性,调用方法

　　能够经过( . )来访问对象的属性

peo1.the_number_of_people  #属性

peo2.talk()  #方法

 

类的方法

在类的内部,使用def关键字来定义一个方法,跟通常函数定义不一样,类方法必须包含参数self,且为第一个参数,self表明类的实例

class people:
 def __init__(self,name,age):
 self.Name = name
 self.Age = age
 def __del__(self):
 print("It's over")
 def eat(self):
 print('%s说:我%s岁了'%(self.Name,self.Age))

peo1 = people('slz',19)
peo1.eat()

 

 

继承:一个类派生出子类,子类自动继承父类的属性和方法,若是一种语言不支持继承,那么类就没什么意义

多继承
class people:
 def __init__(self,name,age):
 self.Name = name
 self.Age = age
 def __del__(self):
 print("It's over")
 def eat(self):
 print('%s说:我%s岁了'%(self.Name,self.Age))
class speaker:
 __weight = 0
 def __init__(self,name,topic):
 self.Name = name
 self.Topic = topic
 def speak(self):
 print('自我介绍一下,我是%s,今天个人演讲主题是%s'%(self.Name,self.Topic))
class sample(people,speaker):
 def __init__(self,name,age,topic):
 people.__init__(self,name,age)
 speaker.__init__(self,name,topic)

text = sample('slz',19,'python')
text.eat()
text.speak()
__weight是私有属性,私有属性在类外部没法直接进行访问

方法重写

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

super()函数用来调用父类的一个方法

 

私有属性

class JustCounter:
 __secreCount = 0
 publicCount = 0
 def pount(self):
 self.__secreCount += 1
 self.publicCount += 1
 print(self.__secreCount)
counter = JustCounter()
counter.pount()
counter.pount()
print(counter.publicCount)
print(counter.__secreCount) #报错,实例不能访问私有变量

私有方法

#私有方法
class people_:
 def __init__(self,name,age):
 self.Name = name
 self.Age = age
 def __del__(self):
 print('我还爱大家')
 def __haha(self):
 print('看不到我,气不气!!!')
peo_1 = people_('slz',58)
peo_1.__haha #报错,私有方法外部不能调用

类的专有方法
__doc__:类的描述信息

class dog:
 '''It's gou 的描述'''
print(dog.__doc__)

多态:接口的多种实现即为多态

多态的目的是:实现接口重用

python中没有直接的语法定义多态

class Animal:
 def __init__(self,name):
 self.name = name
 def talk(self):
 print('lalala')
 def animal_talk(obj):
 obj.talk()

class Car(Animal):
 def talk(self):
 print('%s miao,miao,miao'%self.name)
class Dog(Animal):
 def talk(self):
 print('%s wang,wang,wang'%self.name)

a = Car('猴子')
b = Dog('李*华')
Animal.animal_talk(a)
Animal.animal_talk(b)