Python笔记-面向对象编程

1、类和实例

面向-对象的三大特点：数据封装、继承和多态

在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。

假设我们要处理学生的成绩表，为了表示一个学生的成绩，面向过程的程序可以用一个dict表示：

std1 = { 'name': 'Michael', 'score': 98 }
std2 = { 'name': 'Bob', 'score': 81 }

而处理学生成绩可以通过函数实现，比如打印学生的成绩：

def print_score(std):
    print('%s: %s' % (std['name'], std['score']))

如果采用面向对象的程序设计思想，我们首选思考的不是程序的执行流程，而是Student这种数据类型应该被视为一个对象，这个对象拥有name和score这两个属性（Property）。如果要打印一个学生的成绩，首先必须创建出这个学生对应的对象，然后，给对象发一个print_score消息，让对象自己把自己的数据打印出来。

class Student(object):
    def __init__(self,name,score):
        self.name=name
        self.score=score
    def print_info(self):
        print('the {0} of score is {1}'.format(self.name,self.score))
    def get_grade(self):
        if self.score>=90:
            return 'A'
        elif self.score>=60:
            return 'B'
        else :
            return 'C'
stu1=Student('Andre',90)
stu2=Student('Natasha',75)
stu3=Student('秋儿',59)
stu1.print_info()
stu2.print_info()
stu3.print_info()
print(stu1.name,stu1.get_grade())
print(stu2.name,stu2.get_grade())

结果：

the Andre of score is 90
the Natasha of score is 75
the 秋儿 of score is 59
Andre A
Natasha B
秋儿 C

小结：

要定义一个方法，除了第一个参数是self外，其他和普通函数一样。要调用一个方法，只需要在实例变量上直接调用，除了self不用传递，其他参数正常传入

name,score,方法这些数据和逻辑被“封装”起来了，调用很容易，但却不用知道内部实现的细节。

2、访问限制

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问

class Student(object):
    def __init__(self,name,score):
        self.__name=name
        self.__score=score
        
    def    set_gender(self,gender):
        if gender=='male' or gender=='female':
            self.__gender=gender
        else:
            raise ValueError('incorrect value')
            
    def get_score(self):
        return self.__score
    def get_name(self):
        return self.__name
    def get_gender():
        return self.__gender
        
    def print_info(self):
        print('the {0} of score is {1}'.format(self.__name,self.__score))
        
    def get_grade(self):
        if self.__score>=90:
            return 'A'
        elif self.__score>=60:
            return 'B'
        else :
            return 'C'
            
#对象实例化
stu1=Student('Andre',90)
stu2=Student('Natasha',75)
stu3=Student('秋儿',59)

#打印姓名，成绩信息
stu1.print_info()
stu2.print_info()
stu3.print_info()

#set实例性别
stu4=Student('龙儿',66)
stu4.set_gender('male')
#print(stu4.get_gender())

#获取实例的姓名以及分数等级
print(stu1.get_name(),stu1.get_grade())
print(stu2.get_name(),stu2.get_grade())
print(stu3.get_name(),stu3.get_grade())

3、继承和多态

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
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()    
    
    
a = Animal()
d = Dog()
c = Cat()

print('a is Animal?', isinstance(a, Animal))
print('a is Dog?', isinstance(a, Dog))
print('a is Cat?', isinstance(a, Cat))

print('d is Animal?', isinstance(d, Animal))
print('d is Dog?', isinstance(d, Dog))
print('d is Cat?', isinstance(d, Cat))

run_twice(c)

继承可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写。

 4、获取对象信息

使用type()函数可以判断对象的类型

>>> type(123)
<class 'int'>

对于class的继承关系来说，使用type()就很不方便。我们要判断class的类型，可以使用isinstance()函数。

>>> isinstance(h, Animal)
True

5、实例属性和类属性

我们定义一个类属性，这个属性虽然归类所有，但类的所有实例都可以访问到

class Student(object):
    name = 'Student'

联系

为了统计学生人数，可以给Student类增加一个类属性，每创建一个实例，该属性自动增加：

class Student(object):
    count=0
    def __init__(self,name):
        self.name=name
        Student.count+=1
    def get_gender(self,gender):
        if gender=='male' or gender=='female':
            self.__gender=gender
        else:
            raise ValueError('Values Error!')
    
    
student1=Student('Natasha')
student1.get_gender('male')
student2=Student('Andrei')

print(Student.count)