Python程序设计基础笔记

第六章：面向对象程序设计

6.1 类的定义与使用

语法格式：
class 类名[(父类)]:
----内同

实例化对象：
对象名 = 类名([参数])

可以使用 type 查看一个对象实例化对象的类型，或者用 isinstance(实例名,类名) 来查看是否属于此类。
可以在定义类的时候使用注释，写在三引号中，在外部可以使用类名.–doc-- 显示。
使用 dir(类名或实例名) 来查看此实例或者此类中包含的成员。

6.2 数据成员与方法成员

成员：

按私密性，分为私有成员（命名时一般前面加两个下划线）和公有成员。
按成分，分为数据成员和方法成员。
对于数据成员，分为属于对象的数据成员和属于类的数据成员
对于方法成员，分为实例方法类方法静态方法和抽象方法

私有的属于对象的数据成员：不可以通过外部访问，可以通过内部调用。
公有的属于对象的数据成员：可以通过实例在外部访问，可以在内部调用。
私有的属于类的数据成员；不可以通过外部访问，可以通过内部调用。
公有的属于类的数据成员：可以通过实例和类在外部访问，可以通过内部调用。
属于类的数据成员的内部调用格式：
实例方法、静态方法：类名.数据成员
类方法：cls.数据成员

私有的实例方法：称为私有方法，不可以通过实例访问，可以通过实例中的公有方法在内部调用。
公有的实例方法：称为公有方法，可以通过实例访问，也可以通过实例中的公有方法在内部调用。
类方法：一般不用私有的，可以通过类和实例调用，不可以调用实例成员。
静态方法：一般不用私有的，可以通过类和实例调用，不可以调用实例成员。
抽象方法:一般不用私有的，要改写方法。

成员特殊命名格式：

-xxx：以一个下划线开头，只有类对象和子类对象才可以访问这些成员，在类的外部一般不建议访问。在模块中此种成员不能用 from moudle import * 调用，除非在模块中使用 --all-- 变量明确指明。
–xxx–：系统定义的特殊成员。
–xxx：私有成员，只有类对象自己可以访问，在外部可以通过对象名.-类名–xxx 这样的方式访问，但不建议这样做。

类的实现

class Person:
    
    __people = 0     #私有类数据成员
    men = 0		     #公有类数据成员
    
    def __init__(self,name,age,sex = 'male'):   #构造方法，每当有新实例，此方法执行
        self.name = name
        self.__age = age
        self.sex = sex
        Person.__people += 1           
        if self.sex == 'male':
            Person.men += 1
            
    def showAdress(self,adress):          #公有方法
        self.__adress = adress			  #在公有方法中创建私有实例数据成员
        print(self.name + ' is ' + str(self.__age) + 
              ' years old , living in '+ self.__adress,end = ' , ')  
        return self.__hobby				  #在公有方法中调用私有成员方法
        
    def __hobby(self,hobby):              #定义私有方法
        self.hobby = hobby
        print('into '+hobby)
        
    @classmethod						  #类方法，第一个参数是 cls ，代表 Person 类
    def showPeople(cls):
        print(str(cls.__people) + ' people in total')
        
    @staticmethod						  #静态方法，可以不需要参数，注意其与类方法在调用类成员的区别
    def showWomen():
        print(str(Person.__people - Person.men) + ' women in total')
        
zs = Person('zhangsan',23)				  #实例化对象，使用了默认参数
ls = Person('lisi',22)
my = Person('mary',22,'female')     	  #实例化对象，修改了默认参数
jh = Person('john',25,'male')

ls.showAdress('USA')('basketball')        
zs.showAdress('Beijing')('games')
Person.showAdress(my,'Shanghai')('singing')   #另类调用实例方法                     
ls.showPeople()                           #用实例调用类方法
Person.showWomen()						  #用类调用静态方法
jh.showAdress('UK') 					  #未实现 __hobby 方法 

==>
runfile('D:/ThisPython/alltests.py', wdir='D:/ThisPython')
lisi is 22 years old , living in USA , into basketball
zhangsan is 23 years old , living in Beijing , into games
mary is 22 years old , living in Shanghai , into singing
4 people in total
1 women in total
john is 25 years old , living in UK ,

抽象方法一般在抽象类中定义，并且要求在派生类中必须重新实现抽象方法：

import abc      #为 Abstract Base Classes 的缩写

class Person(metaclass = abc.ABCMeta):
    def f1(self):
        print('function f1')
    @abc.abstractmethod
    def f2(self):
        raise Exception('you must reimplement this method')

class student(Person):
    def f2(self):       #重写
        print('It has been modified.')

zs = student()

zs.f2()  ==>It has been modified.

属性

类与对象的动态性、混入机制

6.3 继承、多态

6.3.1 继承

派生类可以继承父类的公有成员，但是不能继承其私有成员。
对于方法成员，在子类中继承父类的语法格式为：
super(父类名,self).方法名(参数列表) 或
父类名.方法名(self,参数列表)

class Person(object):    
   def __init__(self,name,sex,age=20):
       self.name = name
       self.sex = sex
       self.age = age
   def show(self):
       print(self.name,self.age,self.sex)

class teacher(Person):
    def __init__(self,name,sex,age,department):
        super(teacher,self).__init__(name,sex,age)   #调用基类构造方法，初始化数据成员
        #或者 Person.__init__(self,name,sex,age)
        self.department = department
    def show(self):
        super(teacher,self).show()          #调用基类公有方法，让子类继承
        print(self.department)

zs = teacher('zhangsan','male',32,'math')

zs.show()
==>
zhangsan 32 male
math