python 面向对象(类)
面向对象，即是将具备某种共性的事物抽象成一个类（模板），然后再根据类来创建实例对象进行具体的使用。
概述
- 面向过程：根据业务逻辑从上到下写垒代码
- 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
- 面向对象：对函数进行分类和封装，让开发“更快更好更强...”
本节学习目标：
- 创建类和对象
- 面向对象三大特性：封装、继承、多态
- 类成员：变量（类变量，实例变量）、方法（普通方法，类方法，静态方法）、属性）
- 类和对象在内存中的保存情况
- 类成员修饰符：公有成员xx，私有成员__xx
- 类的特殊成员：__doc__,__module__,__class__,__init__,__call__,__dict__,__str__
创建类和对象
class Car(object): # 创建类
can_run=True # 类变量
def __init__(self,name): # 构造函数
self.name=name # 实例变量
def run(self):
return '%s run...' %self.name
bmw=Car("BMW") # 通过类创建实例对象
print bmw.can_run # 通过实例对象调用类变量
print bmw.run() # 通过实例变量调用方法
运行结果：
True BMW run...
面向对象的三大特性：封装、继承、多态
class Person(object):
sex = 'M'
def __init__(self, name):
self.name = name
def speak(self):
return 'Human can speak...'
class Student(Person):
''' Student继承于Person'''
id = 0 # 类变量，公有
__score=60 # 类变量，私有
def __init__(self, name, grade):
super(Student, self).__init__(name)
self.grade = grade # 实例变量
Student.id += 1 # 每创建实例一次，类变量+1
self.id = Student.id # 实例变量
def job(self):
return '%s is leaning in grade %s' % (self.name, self.grade)
class Teacher(Person):
def __init__(self, name, course):
super(Teacher, self).__init__(name)
self.course = course # 课程
def job(self):
return '%s is teaching %s' % (self.name, self.course)
def speak(self):
''' 重写父类speak 方法'''
return '%s can speak %s' % (self.name, self.course)
# 根据Student类创建实例对象s1
s1 = Student('Milton', 1)
print 's1.name:', s1.name # 调用实例s1变量name
print 's1.id:', s1.id
print 's1.job:', s1.job() # 通过实例s1调用类方法
# 继承父类的方法与属性
print 's1.speak:', s1.speak()
print 's1.sex:', s1.sex
# 重写父类的方法
t1 = Teacher('Loveyp', 'English')
print 't1.speak:', t1.speak()
# 多态
for p in [Student('Perter', 1), Teacher('Marry', 'English')]:
print p.job()
运行结果：
通过实例对象调用实例变量，类方法，类变量： s1.name: Milton s1.id: 1 s1.count: 1 s1.job: Milton is leaning in grade 1 ************************************************** 子类s1中继承父类的方法与属性: s1.speak: Human can speak... s1.sex: M ************************************************** 子类重写父类的方法： t1.speak: Loveyp can speak English ****************************** 多态： Perter is leaning in grade 1 Marry is teaching English
类成员：变量（类变量，实例变量）、方法（普通方法，类方法，静态方法）、属性
class Car(object):
count = 0 # 类变量
style = "SUV"
tax = 0.8
def __init__(self, name, money):
self.name = name # 实例变量
self.money = money
Car.count += 1 # 调用类变量
# 普通方法
def run(self):
return '%s run...' % self.name
@classmethod # 类方法，类方法中不能使用实例变量
def play_music(cls, song):
return '%s car can playing music %s' % (cls.style, song)
@staticmethod # 静态方法,不能直接使用类变量与实例变量
def add_gas(name):
return '%s can add_gas...' % name
@property # 将方法设置为属性
def price(self):
return self.money * Car.tax
@price.setter
def price(self, money):
self.money = money
bmw = Car("BMW", 80)
print "实例对象调用类变量:", bmw.count
print "类直接调用类变量:", Car.count
print "实例对象调用方法:", bmw.run()
print "实例对象调用实例变量:", bmw.name
try:
Car.run()
except Exception, e:
print "类直接调用方法失败：", e
aodi = Car("AODI", 100)
print "实例对象调用类变量:", aodi.count
print "类直接调用类变量:", Car.count
print "实例对象调用类方法:", aodi.play_music("Hello World")
print "类直接调用类方法:", Car.play_music("ABC")
try:
aodi.add_gas()
except Exception, e:
print "静态方法直接引用实例变量:", e
print "静态方法中传入参数:", aodi.add_gas(aodi.name)
print "修改属性前访问属性:",aodi.price
aodi.price = 200
print "修改属性后访问属性:",aodi.price
运行结果：
实例对象调用类变量: 1 类直接调用类变量: 1 实例对象调用方法: BMW run... 实例对象调用实例变量: BMW 类直接调用方法失败： unbound method run() must be called with Car instance as first argument (got nothing instead) 实例对象调用类变量: 2 类直接调用类变量: 2 实例对象调用类方法: SUV car can playing music Hello World 类直接调用类方法: SUV car can playing music ABC 静态方法直接引用实例变量: add_gas() takes exactly 1 argument (0 given) 静态方法中传入参数: AODI can add_gas... 修改属性前访问属性: 64.0 修改属性后访问属性: 160.0
类和对象在内存中的保存情况
class Car(object):
count = 0 # 类变量
style = "SUV"
def __init__(self, name):
self.name = name # 实例变量
Car.count += 1 # 调用类变量
# 普通方法
def run(self):
return '%s run...' % self.name
@classmethod # 类方法，类方法中不能使用实例变量
def play_music(cls, song):
return '%s car can playing music %s' % (cls.style, song)
@staticmethod # 静态方法,不能直接使用类变量与实例变量
def add_gas(name):
return '%s can add_gas...' % name
bmw = Car("BMW")
bmw.color="white"
aodi = Car("AODI")
类成员修饰符：公有成员xx，私有成员__xx
class Car(object):
__count = 0 # 类变量,私有
style="SUV" # 类变量,公有
def __init__(self, name):
self.name = name # 实例变量
Car.__count += 1 # 调用类变量
bmw = Car("BMW")
try:
print bmw.__count
except Exception,e:
print "外部调用类私有变量:",e
print "外部调用类公有变量:",bmw.style
运行结果：
外部调用类私有变量: 'Car' object has no attribute '__count' 外部调用类公有变量: SUV
类的特殊成员：__doc__,__module__,__class__,__init__,__call__,__dict__,__str__
class Car(object):
'''小车模型'''
style = "SUV" # 类变量,公有
def __init__(self, name):
self.name = name # 实例变量
print '__init__ function call...'
def __call__(self, *args, **kwargs):
print '__call__ function call...'
def __str__(self):
return "this is a nice card！"
print "文档注释", Car.__doc__
print "模块名：", Car.__module__
print "类型:", Car.__class__
bmw = Car("BMW")
bmw()
print "类成员:", Car.__dict__
print "实例成员:", bmw.__dict__
print "str 输出:", bmw
运行结果：
文档注释 小车模型
模块名： __main__
类型: <type 'type'>
__init__ function call...
__call__ function call...
类成员: {'__dict__': <attribute '__dict__' of 'Car' objects>, '__module__': '__main__', '__call__': <function __call__ at 0x039098F0>,
'__str__': <function __str__ at 0x03909870>, '__weakref__': <attribute '__weakref__' of 'Car' objects>, 'style': 'SUV',
'__init__': <function __init__ at 0x039098B0>, '__doc__': '\xe5\xb0\x8f\xe8\xbd\xa6\xe6\xa8\xa1\xe5\x9e\x8b'}
实例成员: {'name': 'BMW'}
str 输出: this is a nice card！
