Python面向对象基础

一、面向对象

面向对象的两个基本概念：
——类：定义了一件事物的抽象特点，例如现实生活中的某个群体
——对象：类的实例，例如某个群体中的个体

面向对象的基本要素：
——属性（变量），例如某个群体的信息：年龄、性别、身高
——方法（函数），例如某个群体的功能：写代码、修电脑

面向对象的特性：
——封装性：对外暴露了功能，隐藏了具体的实现细节
——继承：对庞大群体进行细微分类，子类继承父类的属性和方法，分为单继承与多重继承，例如前端程序员、后端程序员
——多态：由同一个类继承的几个类，在调用同一个方法时，会有不同的反应，例如同一类群体对同一件事有不同的看法

二、Python定义类：

class  ClassName:     #类名通常单词开头字母大写
    def __init__(self, [……)    #构造函数：设置类的属性
        pass
    def __del__(self, [……)     #析构函数：销毁对象时调用，是被Python垃圾回收的时候才会被调用 
        pass
    ...

Python2中定义的类有两种不同方法，效果也不一样
定义旧式类：

class OldStyle:
    pass

定义新式类：

class NewStyle(object):
    pass 

类的内建函数：

——type()：返回对象的类型，也可以使用isinstance（）来获取，而且更好。

isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。

——dir()：返回对象的属性，dir() 不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

Python2中新式老类定义 ， type()和dir()的输出结果如下图：
新式类和老式类的对比实例：

class OldStyle:

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

class NewStyle(object):

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

if __name__ == '__main__':
    old =OldStyle('old','Old style class')
    print(old)
    print(type(old))
    print (dir(old))
    print ('-------------------------------------------------------')
    new=NewStyle('new','New style class')
    print (new)
    print (type(new))
    print (dir(new))

输出结果：

在python2中，若一个类没有继承别的类，最好让他继承object类，不然他的类型和属性会有麻烦；在python3中，所有类皆是新式类，若没有继承别的类，都默认继承object，在python3.6时两个定义类的方法输出会是一样了

一个.py文件，如果是自身在运行，那么他的__name__值就是"main"；
如果它是被别的程序导入的（作为一个模块），比如：
import re
那么，他的__name__就不是"main"了。

三、Python定义属性

调用也可以作为属性

定义类的属性的第一个方法 ：

直接在类里面定义
class Student（object）:
    sex = "male"

定义类的属性的第二个方法 ：

在构造函数里面定义
class Student（object）：
    def __init__(self,name,sex):    #在构造对象的时候将属性值传入
        self.name = name              
        self.sex = sex

Python实际上不提供访问控制（私有属性）的功能，
常用属性定义：
1.没有下划线—>公有成员变量
2.有一个下划线—>不严格的私有成员变量：实际还是可以访问
3.有两个下划线—>较严格的私有成员变量，实际需要变法访问
记住方法：没有不严格，只有 1级严格 2级严格

属性定义实例：

class Programer(object):
    hobby = 'Play Computer'
     
    def __init__(self, name, age, weight):
        self.name = name                 #无下划线-->可以公开访问
        self._age = age                  #有一个下划线-->私有属性，仍可访问
        self.__weight = weight           #两个下划线-->部分私有属性，需要改变属性名访问
         
    def get_weight(self):                #定义获取weight属性的方法
        return self.__weight
         
if __name__ == '__main__':
    programer = Programer('Albert', 25, 80)    #对象实例化
    print（ dir(programer)）
    print（ programer.__dict__  ）                 #从构造函数里获得的属性
    print （programer.get_weight()）
    print（ programer._Programer__weight ）        #“对象名._类名__属性名”的方法访问

我们来看一下输出结果就十分明了了：

四、Python定义类中的方法

经典话语：Python里面一切都是对象

函数与方法的区别：
——函数：直接调用函数名的方式
——方法：必须与对象结合使用，依附于类

类的方法可以看做类的属性，是 method 类型的属性，也没有访问控制（与类的属性一致，有三种定义方式无下划线，一个下划线，两个下划线）：

方法的装饰器有两种：
——@classmethod 可用类名直接调用，也可以用对象名调用
——@property 只能用对象名调用，后不用跟()

调用方法的三种途径：
1.实例化，通过实例调用
2.打@classmethod 标签，然后用类名直接调用
3.打@property 标签，然后用实例调用，但是不需要加括号，适用于没有参数的方法

定义类中方法和调用实例：

class Programer(object):
    hobby='Play Computer'
    def __init__(self,name,age,weight):
    @classmethld
    def get_hobby(cls):     #
        return cls.hobby
    @property
    def get_weight(self):
        return self.__weight
  
if __name__ ="__main__":
     programer_albert=Programer('Albert', 25, 80)
     print(Programer.get_hobby())      
      print(programer_albert.get_weight)

输出结果(对于上述程序输出的是Play Computer 和 80)：

五、类的继承

继承使得大量代码被复用，是面向对象的优势。
Object类是一切类的父类。继承的子类会继承父类的属性和方法，也可以自己定义，覆盖父类的属性和方法。

super() 函数是用于调用父类(超类)的一个方法。

Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx :

继承实例：

class Programer(object):
    hobby = 'Play Computer'
    def __init__(self,name,age,weight):
            self.name = name         
            self._age = age      
            self.__weight = weight        
                
    @classmethod   
    def get_hobby(cls):        
        return cls.hobby          
     
    @property  
    def get_weight(self):      
        return self.__weight   
            
    def self_introduction(self):       
        print （'My name is %s \n I am %s years old\n '%(self.nameB,self._age)）
    
class BackendProgramer(Programer):
    def __init__(self,name,age,language):
        super(BackendProgramer,self).__init__(name,age,weight)       
        self.language = language
        
if __name__ == '__main__':
    programer_b = BackendProgramer('Albert',25,80,'Python')
        print（dir(programer_b)）
        print（programer_b.__dict__）
        print （type(programer_b)）
        print （isinstance(programer,Programer))

结果如下：

六、Python类的多态

多态的要素：
——继承
——方法重写

实例：

class Programer(object):
    hobby = 'Play Computer'
     
    def __init__(self, name, age, weight):
        self.name = name
        self._age = age
        self.__weight = weight
         
    def self_introduction(self):
        print（ 'My name is %s \nI am %s years old\n' % (self.name, self._age)）
     
class BackendProgramer(Programer):
    def __init__(self, name, age, weight, language):
        super(BackendProgramer, self).__init__(name, age, weight)
        self.language = language    
     
    def self_introduction(self):
        print（ 'My name is %s \nMy favorite language is %s' % (self.name, self.language)）
 
def introduce(programer):
    if isinstance(programer, Programer):
        programer.self_introduction()
                    
if __name__ == '__main__':
    programer1= Programer('Albert', 25, 80)
    backend_programer1= BackendProgramer('Tim', 30, 70, 'Python')
    introduce(programer1)
    introduce(backend_programer1)

输出结果：

Python面向对象基础就到这里，后续再介绍深入理解Python面向对象

写在最后，欢迎关注一个一起学python的微信公众号：大众学python

掏出手机扫一扫：