环境
虚拟机：VMware 10
Linux版本：CentOS-6.5-x86_64
客户端：Xshell4
FTP：Xftp4
python3.6
一、面向对象编程
1、概念
(1)面向对象编程(OOP)，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。面向对象是一种对现实世界理解和抽象的方法。
面向过程是一件事“该怎么做“，面向对象是一件事“该让谁来做”，然后那个“谁”就是对象，他要怎么做是他自己的事，反正最后一群对象合力能把事做好就行了。
面向对象三个特性:继承，封装，多态。
(2)类：具有相同属性和行为事物的统称：类(Class) 由3个部分构成：类的名称:类名；类的属性:一组数据；类的方法:允许对进行操作的方法 (行为)
(3)对象：某一个具体事物的存在 ,在现实世界中可以是看得见摸得着的,可以是直接使用的;
(4)类和对象关系：类就是创建对象的模板；
2、定义类
格式：class 类名: 方法列表
(1)定义类时有2种：新式类和经典类，下面的Car为经典类，如果是Car(object)则为新式类;
(2)类名的命名规则按照"大驼峰";
#定义一个Car类 class Car: def move(self): print('车正在移动...') def getCarInfo(self): print('车油耗数:%d, 颜色%s'%(self.oil, self.color))
3、创建对象
当创建一个对象时，就是用一个模子，来制造一个实物
格式：对象名 = 类名()
#创建对象 bmw=Car() #给对象bmw添加属性 bmw.color='白色' bmw.oil=30 #调用对象的方法 bmw.getCarInfo() bmw.move() print(bmw.color) print(bmw.oil)
(1)创建实例对象，一定在内存中有一块空间存放对象的数据信息。此时也可以通过实例对象bmw来访问属性或者方法,bmw是一个对象，它拥有属性（数据）和方法（函数）；
(2)第一次使用bmw.color = '白色'表示给bmw这个对象添加属性，如果后面再次出现bmw.color = xxx表示对属性进行修改；
4、self
类定义的方法中的参数self，可以理解为自己,可以把self当做C++中类里面的this指针一样理解，就是对象自身的意思。
(1)某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可;
(2)self可以不写self，方法中至少有一个参数，第一个参数表示当前对象。名字随便取，但是习惯都写self；
5、__init__()方法:初始化函数，用来完成一些默认的设定;该方法在创建对象后，就立刻被默认调用了。
(1)__init__()方法，在创建一个对象时默认被调用，不需要手动调用;
(2)__init__(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中出了self作为第一个形参外还需要2个形参，例如__init__(self,x,y);
(3)__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去;
示例：
class Car: def __init__(self): self.color='白色' self.wheel=4 self.oil=10 def move(self): print('车正在移动...') def getCarInfo(self): print('车油耗数:%d, 颜色%s'%(self.oil, self.color))
初始化函数使用入参：
class Car: def __init__(self,color,wheel,oil): self.color=color self.wheel=wheel self.oil=oil def move(self): print('车正在移动...') def getCarInfo(self): print('车油耗数:%d, 颜色%s'%(self.oil, self.color)) bmw=Car('黑色',4,10) print('汽车颜色=%s,轮子数量=%d,油耗数量=%d'%(bmw.color,bmw.wheel,bmw.oil))
6、__new__方法
(1)__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
(2)__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例
(3)__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值
(4)我们可以将类比作制造商，__new__方法就是前期的原材料购买环节，__init__方法就是在有原材料的基础上，加工，初始化商品环节
__new__与__init__关系：
(1)__new__方法（第一个执行）先于__init__方法执行；
(2)__new__方法是传入类(cls)，而__init__方法传入类的实例化对象(self)；
(3)__new__方法的第一个参数是这个类，而其余的参数会在调用成功后全部传递给__init__方法初始化；
(4)__new__和__init__想配合才是python中真正的类构造器；
示例：
class Dog(object): #创建对象 def __new__(cls,name,age): print('__new__方法') print("类内存地址：%s"%id(cls)) #return super().__new__(cls) ret=object.__new__(cls) print("实例化对象:%s"%ret) return ret def __init__(self,name,age): print('__init__方法') print("实例化对象:%s"%self) self.name=name self.age=age print('类内存地址：%s'%id(Dog)) d=Dog('haha',12) # 类内存地址：3992792 # __new__方法 # 类内存地址：3992792 # 实例化对象:<__main__.Dog object at 0x0000000002961390> # __init__方法 # 实例化对象:<__main__.Dog object at 0x0000000002961390>
7、__del__方法
当内存中销毁（释放）一个对象时回调__del__()方法;
import time class Animal(object): def __init__(self,name,age): print('__init__被调用...') self.__name=name self.__age=age def __del__(self): print('__del__被调用...') print('%s对象马上被干掉了'%self.__name) def __str__(self): return '名字'+self.__name+',年龄：'+str(self.__age) #创建对象 dog=Animal('哈皮狗',1) #删除对象 del dog # __init__被调用... # __del__被调用... # 哈皮狗对象马上被干掉了 cat=Animal('波斯猫',2) print(cat) cat2=cat cat3=cat print("---马上 删除cat对象") del cat print("---马上 删除cat2对象") del cat2 print("---马上 删除cat3对象") del cat3 print("程序2秒钟后结束") time.sleep(2) # __init__被调用... # 名字波斯猫,年龄：2 # ---马上 删除cat对象 # ---马上 删除cat2对象 # ---马上 删除cat3对象 # __del__被调用... # 波斯猫对象马上被干掉了 # 程序2秒钟后结束
关于对象被其他变量引用时，删除对象时的处理：
(1)当有1个变量保存了对象的引用时，此对象的引用计数就会加1
(2)当使用del删除变量指向的对象时，如果对象的引用计数不是1，比如3，那么此时只会让这个引用计数减1，即变为2，当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除
8、魔法方法
在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法
__str__()类似toString()
当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
9、id()用于打印对象内存地址
二、类和对象的属性
1、公有属性和私有属性
(1)Python中没有像C++中public和private这些关键字来区别公有属性和私有属性;
(2)它是以属性命名方式来区分，如果在属性名前面加了2个下划线'__'，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）。
2、类属性和实例属性
(1)类属性：所属类，类似C++，java中类的静态成员变量；
公有的类属性，在类外可以通过类和实例对象访问；
私有的类属性，类和实例对象均不能在类外访问。
(2)实例属性：在__init__通过self.XXX方式添加或者创建对象后，使用对象变量.XXX=数据时添加的
class People(object): name='Tom'#公有类属性 __age=10#私有的类属性 def __init__(self,address): self.address=address p=People('山东') #公有类属性与私有类属性 print(p.name) print(People.name) # print(p.__age)#报错：AttributeError: 'People' object has no attribute '__age' # print(People.__age)#报错：AttributeError: 'People' object has no attribute '__age' #实例属性与类属性 print(p.address) # print(People.address)#报错：AttributeError: type object 'People' has no attribute 'address' #通过实例(对象)去修改类属性 print(p.name)#Tom p.name='Jack' print(p.name)#实例属性会屏蔽掉同名的类属性 ：Jack print(People.name)#Tom del p.name#删除实例属性 print(p.name)#Tom
注意：
如果需要在类外修改类属性，必须通过类去引用然后进行修改。
如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。
三、类方法和静态方法
1、类方法
(1)是类所拥有的方法，用修饰器@classmethod来标识;
(2)第一个参数必须是类对象，一般以cls做标识（可用其他名称）;
(3)可以通过实例对象和类调用类方法;
2、静态方法
通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数。
class Person(object): country='山东' @classmethod def getCountry(cls): return cls.country @classmethod def setCountry(cls,country): cls.country=country @staticmethod def getCountry2(): return Person.country pn=Person() #通过实例对象和类调用类方法 print(pn.getCountry())#山东 print(Person.getCountry()) #山东 pn.setCountry('北京') print(pn.getCountry())#北京 print(Person.getCountry()) #北京 #静态方法 print(Person.getCountry2())#北京
|
方法类别 |
语法 |
描述 |
|
类方法 |
@classmethod |
第一个形参cls,默认传递, 通过cls引用的必定是类对象的属性和方法 |
|
静态方法 |
@staticmethod |
没有默认传递的形参 |
|
对象方法（成员方法） |
def 方法名 |
第一个形参self ，默认传递,通过self引用的可能是类属性、也有可能是实例属性, 不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。 |
四、继承、多继承、多态
1、继承
(1)子类在继承的时候，在定义类时，小括号()中为父类的名字;
(2)父类的属性(不包括私有属性)、方法(不包括私有方法)，会被继承给子类
class Animal(object): def __init__(self,name='动物',color='白色'): self.__name=name self.color=color def __test(self): print(self.__name) print(self.color) def test(self): print(self.__name) print(self.color) class Dog(Animal): def doTest(self): #print(self.__name)#不能访问到父类的私有属性 print(self.color) def doTest2(self): #self.__test()#不能访问父类中的私有方法 self.test() a=Animal() # print(a.__name)#报错：AttributeError: 'Animal' object has no attribute '__name' print(a.color) # a.__test()#报错：AttributeError: 'Animal' object has no attribute '__test' a.test() print('-'*30) d=Dog(name='小花',color='花色') d.doTest() d.doTest2()
2、多继承，即子类有多个父类，并且具有它们的特征
class Base(object): def test(self): print('---Base test---') class A(Base): def test(self): print('---A test---') class B(Base): def test(self): print('---B test---') class C(A,B): pass c=C() c.test()#---A test--- #可以查看C类的对象搜索方法时的先后顺序，C.__mro__算法得到一个元组 print(C.__mro__)#(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>)
注意：按照继承顺序调用父类的方法
3、重写
所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法
class Cat(object): def __init__(self,name): self.name=name self.color='黑色' def sayHello(self): print('-----Cat-----') class Bosi(Cat): def __init__(self,name): # 调用父类的__init__方法1(python2) Cat.__init__(self, name) # 调用父类的__init__方法2 super(Bosi,self).__init__(name) # 调用父类的__init__方法3 super().__init__(name) def sayHello(self): print('-----Bosi-----') bosi=Bosi('小花') bosi.sayHello()#-----Bosi----- print(bosi.name)#小花 print(bosi.color)#黑色
4、多态
所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态
class Animal(object): def run(self): print('Animal is running...') class Dog(Animal): def run(self): print('Dog is running...') class Cat(Animal): def run(self): print('Cat is running...') def run_twice(animal): animal.run() run_twice(Animal())#Animal is running... run_twice(Dog())#Dog is running... run_twice(Cat())#Cat is running...
参考：
Python学习笔记