Python 面向对象

1. 编程范式

　　编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程，一个程序是程序员为了得到一个任务结果而编写的一组指令的集合，正所谓条条大路通罗马，实现一个任务的方式有很多种不同的方式，对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，即为编程范式。不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路，大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。 两种最重要的编程范式分别是面向过程编程和面向对象编程。

1.1 面向过程编程(Procedural Programming)

　　就是程序从上到下一步步执行，一步步从上到下，从头到尾的解决问题 。基本设计思路就是程序一开始是要着手解决一个大的问题，然后把一个大问题分解成很多个小问题或子过程，这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。

　　这样做的问题也是显而易见的，就是如果你要对程序进行修改，对你修改的那部分有依赖的各个部分你都也要跟着修改， 举个例子，如果程序开头你设置了一个变量值 为1，但如果其它子过程依赖这个值 为1的变量才能正常运行，那如果你改了这个变量，那这个子过程你也要修改，假如又有一个其它子程序依赖这个子过程，那就会发生一连串的影响，随着程序越来越大，这种编程方式的维护难度会越来越高。 
　　所以我们一般认为，如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程的方式是极好的，但如果你要处理的任务是复杂的，且需要不断迭代和维护 的，那还是用面向对象最方便了。

1.2 面向对象编程(Object Oriented Programming)

　　面向对象编程是一种编程方式，此编程方式的落地需要使用"类"和"对象"来实现，所以，面向对象编程其实就是对"类"和"对象"的使用。

　　使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率；另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

1.3 类和对象

• 类就是一个模板，模板里可以包含多个函数，函数里实现一些功能；---函数在类中被称为方法
• 对象则是根据模板创建的实例，通过实例对象可以执行类中的函数；

# 定义一个类，class是定义类的语法；user是类名；(object)是新式类的写法
class user(object):
    def __init__(self,name):    # 初始化函数，(self,name)里是要初始化的属性,其中self为特殊参数，必填项；name为实际参数
        self.name = name    # 实例变量，作用域就是实例本身
    def uname(self):    # 类中创建了一个方法uname
        print("%s is the best!" % self.name)
# 对象名 = 类名()
i = user('dd')    # 根据类user创建对象i
i.uname()      # 执行uname方法

 1.4 self

• self   指的是调用该函数的对象。谁调用的函数 self 就是谁。

# 定义类
class Name():
    def wash(self,name):
        print('我会洗衣服')
        print("我是%s的self：" % name,self)

#  创建对象
Jack = Name()
print("我是Jack：",Jack)
Jack.wash("Jack")

kaer = Name()
print("我是kaer：",kaer)
kaer.wash("kaer")

# 执行结果
我是Jack： <__main__.Name object at 0x000001EDA093FBD0>
我会洗衣服
我是Jack的self： <__main__.Name object at 0x000001EDA093FBD0>
我是kaer： <__main__.Name object at 0x000001EDA093FD50>
我会洗衣服
我是kaer的self： <__main__.Name object at 0x000001EDA093FD50>

　

1.5. 类变量和实例变量

类变量： 

• 是可在类的所有实例之间共享的值（也就是说，它们不是单独分配给每个实例的）。

实例变量：

• 实例化之后，每个实例单独拥有的变量。

class Test(object): 
    num_of_instance = 0 
    def __init__(self, name): 
        self.name = name 
        Test.num_of_instance += 1 
   
if __name__ == '__main__': 
    print Test.num_of_instance 
    t1 = Test('cc') 
    print Test.num_of_instance 
    t2 = Test('lucy') 
    print t1.name , t1.num_of_instance 
    print t2.name , t2.num_of_instance  
 
-------------------------------打印输出-------------------------------
0
1
cc 2
lucy 2

　　

1.6 析构函数

　　上面我们已经知道构造函数__init__，具有初始化的作用，也就是当该类被实例化的时候就会执行该函数,那么我们就可以把要先初始化的属性放到这个函数里面。

　　那么与之对应的就是析构函数__del__,用于释放对象占用的资源的函数，做收尾工作，例如关闭数据库、打开临时文件等;

　　__del__()也是可选的，如果不提供，则Python 会在后台提供默认析构函数

　　如果要显式的调用析构函数，可以使用del关键字，方式如下： del 对象名

1.7 私有属性和方法

• 在python中定义私有变量只需要在变量名或函数名前加上 "__"两个下划线，那么这个函数或变量就成为私有的了。
• 私有方法和属性外部不能调用，只能在内部调用。

class People:
    __nationality = "中国"    # 私有属性
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __cat(self):    # 私有方法
        print(f"""姓名：{self.name}\n年龄：{self.name}\n国籍：{self.__nationality}""")
    def getCat(self):
        return self.__cat() # 内部方法可以执行，私有方法
    def getNationality(self):
        return self.__nationality
    def setNationality(self,name):
        self.__nationality = name
p = People("张三",18)
# p.__cat() # 方法会报错，外部不能调用私有方法
# 执行私有方法 __cat
p.getCat()
# 获取 __nationality 值
print(p.getNationality())
# 修改 __nationality 值
p.setNationality("地球")
# 获取 __nationality 值
print(p.getNationality())

　　

2. 面向对象的特性

继承

封装

多态

 

3 继承

• 面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
• 子类继承父类可以使用父类的方法和属性

3.1 经典类和新式类

# 经典类 python2
class 类名:
    代码
    ........
# 新式类 python3
class 类名(object):
    代码
    ........

3.2 单继承

• 单继承：一个子类继承一个父类

# 父类 A
class A(object):
    __nationality = "中国"
    def run(self):
        print(f"国籍：{self.__nationality}")
# 子类B继承A类
class B(A):
    pass
p = B()
p.run() # 执行父类方法

继承示例：

class SchoolMember(object):
    members = 0 #初始学校人数为0
    def __init__(self,name,age):
        self.name = name
        self.age = age
 
    def  tell(self):
        pass
 
    def enroll(self):
        '''注册'''
        SchoolMember.members +=1
        print("\033[32;1mnew member [%s] is enrolled,now there are [%s] members.\033[0m " %(self.name,SchoolMember.members))
     
    def __del__(self):
        '''析构方法'''
        print("\033[31;1mmember [%s] is dead!\033[0m" %self.name)
class Teacher(SchoolMember):
    def __init__(self,name,age,course,salary):
        super(Teacher,self).__init__(name,age)
        self.course = course
        self.salary = salary
        self.enroll()
 
 
    def teaching(self):
        '''讲课方法'''
        print("Teacher [%s] is teaching [%s] for class [%s]" %(self.name,self.course,'s12'))
 
    def tell(self):
        '''自我介绍方法'''
        msg = '''Hi, my name is [%s], works for [%s] as a [%s] teacher !''' %(self.name,'Oldboy', self.course)
        print(msg)
 
class Student(SchoolMember):
    def __init__(self, name,age,grade,sid):
        super(Student,self).__init__(name,age)
        self.grade = grade
        self.sid = sid
        self.enroll()
 
 
    def tell(self):
        '''自我介绍方法'''
        msg = '''Hi, my name is [%s], I'm studying [%s] in [%s]!''' %(self.name, self.grade,'Oldboy')
        print(msg)
 
if __name__ == '__main__':
    t1 = Teacher("Alex",22,'Python',20000)
    t2 = Teacher("TengLan",29,'Linux',3000)
 
    s1 = Student("Qinghua", 24,"Python S12",1483)
    s2 = Student("SanJiang", 26,"Python S12",1484)
 
    t1.teaching()
    t2.teaching()
    t1.tell()

3.3 多继承

• 多继承：一个子类继承多个父类
• 一个类继承多个父类，优先继承第一个父类，如果第一个类没有该方法，继承第二个类。

class A(object):
    def __init__(self):
        self.name = "A"
    
    def run(self):
        print(f"这是{self.name}类的方法")


class B(object):
    def __init__(self):
        self.name = "B"
    def run(self):
        print(f"这是{self.name}类的方法")
# C 类继承A类，B类，先执行A类中的方法，如果没有执行B类
class C(A,B):
    pass

p = C()
print(p.name)
p.run()

3.4 子类重写父类

•  子类和父类有相同的方法和属性，优先执行子类自己的方法和属性。

class A(object):
    def __init__(self):
        self.name = "jack"
    def run(self):
        print(f"你的名字{self.name}")
class B(A):
    def __init__(self):
        self.name = "Tom"
    def run(self):
        print(f"你的名字{self.name}")
p = B()
print(p.name)
p.run()

3.5 __mro__

• __mro__　　查看类的继承关系

class A(object):
    def __init__(self):
        self.name = "jack"
    def run(self):
        print(f"你的名字{self.name}")
class B(A):
    def __init__(self):
        self.name = "Tom"
    def run(self):
        print(f"你的名字{self.name}")
p = B()
print(p.name)
p.run()
# B类继承 A类和object
print(B.__mro__)

3.6 子类调用父类同名方法

• 调用父类的同名方法和属性，需要先调用init初始化

class A(object):
    def __init__(self):
        self.name = "jack"
    def run(self):
        print(f"你的名字{self.name}")
class B(A):
    def __init__(self):
        self.name = "Tom"
    def run(self):
        print(f"你的名字{self.name}")
    def a_run(self):
        # init 初始化
        A.__init__(self)
        A.run(self)
p = B()
p.run()
p.a_run()

3.7 super()

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

语法：

# 有参写法
super(自己的类名,self).__init__(参数...)

# 无参写法
super().__init__(参数...)

super()和写父类名的区别：

写父类名的缺点：

• 如果需要继承多个父类，不能写多个  类名.__init__(self)。
• 如果父类名字改了，继承父类的子类都需要修改 类名.__init__()。

super()优点：

• 可以继承多个父类，只需要写一次  super().__init__()。
• 父类名字改了，只需要修改继承父类的名字。

父类名示例：

class A(object):
    def __init__(self):
        self.name = "jack"
    def run(self):
        print(f"A类的名字{self.name}")
class B(object):
    def __init__(self):
        self.name = "Tom"
    def run(self):
        print(f"B类的名字{self.name}")
class C(A,B):
    def __init__(self):
        # 写父类名字
        A.__init__(self)
        # B.__init__(self)
    def run(self):
        A.run(self)
        # B.run(self)
        
p = C()
p.run()

　　

super()示例：

class A(object):
    def __init__(self):
        self.name = "jack"
    def run(self):
        print(f"A类的名字{self.name}")
class B(object):
    def __init__(self):
        self.name = "Tom"
    def run(self):
        print(f"B类的名字{self.name}")
class C(A,B):
    def __init__(self):
        # 有参，写自己的类名
        super(C,self).__init__()
        # 无参
        # super().__init__()
    def run(self):
        super().run()
p = C()
p.run()

　　

3.8 组合继承

• 先创建 Student 对象(student)，把对象传入Teacher类中，在把类对象(student_obj)赋值给self.school_obj，然后就可以调用Student类中方法和属性。

class SchoolMember(object):
    def __init__(self,addr,tel):
        self.name = addr
        self.age = tel
    def tell(self):
        pass
class Student(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def tell(self):
        print("Student :",self.name,self.age,self.sex)

class Teacher(SchoolMember):
    def __init__(self,addr,tel,student_obj): # 
        super(Teacher,self).__init__(addr,tel)
        self.salary = addr
        self.coures = tel
        # 对象赋值
        self.school_obj = student_obj

school = SchoolMember("北京",13800000000)
# 创建student对象
student = Student("alex",33,"M")
# 把 student对象传入 Teacher类中，
teacher = Teacher("北京",13800000000,student)
# 调用赋值后的 school_obj对象
print(teacher.school_obj.name)
teacher.school_obj.tell()

　　

3.9 继承顺序

• python3 经典类和新式类都是按照广度优先来继承的。
• python2 经典类按照深度优先来继承，新式类按照广度优先来继承。

# D类继承 B类和C类
# B类和C类继承 A类
class A(object):
    def __init__(self):
        print("A...")
class B(A):
    pass
    # def __init__(self):
    #     print("B...")
class C(A):
    def __init__(self):
        print("C...")
class D(B,C):
    pass
D()

 

python3继承顺序：

• ABC类都没注释，运行代码，会打印B类中的，如果B类注释了，会打印C类的，如果B和C类都注释了会打印A类的。

python2继承顺序：

• 经典类：运行代码，会打印B类的，如果B类注释了，会打印A类的。
• 新式类：和python3一样

 

4. 封装

• 封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。
• 封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

5. 多态

•  多态指的是一种接口，多种实现。用于接口的重用。
•  多态是子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的结果。

 例子：输出狗和猫的叫声

普通类的写法：

•  需要创建对象，执行 talk 方法。

class Animal(object):
    def __init__(self,name):
        self.name = name
    def talk(self):
        pass
class Cat(Animal):
    def talk(self):
        print("Meow!")
class Dog(Animal):
    def talk(self):
        print("Woof! Woof!")

c = Cat("Cat")
c.talk()

d = Dog("Dog")
d.talk()

　　

 多态的写法：

•  创建对象，调用同一个接口（animall_talk），实现猫和狗的不同叫声。同一种接口，多种实现。

class Animal(object):
    def __init__(self,name):
        self.name = name
    def talk(self):
        pass
    @staticmethod   # 静态方法，把类中方法变成普通的函数
    def animal_talk(obj):
        obj.talk()
class Cat(Animal):
    def talk(self):
        print("Meow!")
class Dog(Animal):
    def talk(self):
        print("Woof! Woof!")
# 创建对象
c = Cat("Cat")
d = Dog("Dog")
# 调用 animall_talk 接口
Animal.animal_talk(c)
Animal.animal_talk(d)