Python小记——面向对象程序设计

​​菜鸟教程 面向对象​​

样例

In [1]: class A(object):
...: def __init__(self, v):
...: self.value = v
...: def show(self):
...: print(self.value)
...:

In [2]: a = A(3)

In [3]: a.show()
3

在Python中比较特殊的是，可以动态地为类和对象增加成员

class Car:
price = 100000 #定义类属性
def __init__(self, c):
self.color = c #定义实例属性

car1 = Car("Red") #实例化对象
car2 = Car("Blue")
print(car1.color) #查看实例属性
print(Car.price) #查看类属性的值
Car.price = 110000 #修改类属性
Car.name = 'QQ' #动态增加类属性
car1.color = "Yellow" #修改实例属性
print(car2.color, Car.price, Car.name)
print(car1.color, Car.price, Car.name)
import types
def setSpeed(self, s):
self.speed = s
car1.setSpeed = types.MethodType(setSpeed, car1) #动态增加成员方法
car1.setSpeed(50) #调用成员方法
print(car1.speed)>>> import types
>>> class Person(object):
def __init__(self, name):
assert isinstance(name, str), 'name must be string'
self.name = name

>>> def sing(self):
print(self.name+' can sing.')

>>> def walk(self):
print(self.name+' can walk.')

>>> def eat(self):
print(self.name+' can eat.')>>> zhang = Person('zhang')
>>> zhang.sing() #用户不具有该行为
AttributeError: 'Person' object has no attribute 'sing'
>>> zhang.sing = types.MethodType(sing, zhang)
#动态增加一个新行为
>>> zhang.sing()
zhang can sing.
>>> zhang.walk()
AttributeError: 'Person' object has no attribute 'walk'
>>> zhang.walk = types.MethodType(walk, zhang)
>>> zhang.walk()
zhang can walk.
>>> del zhang.walk #删除用户行为
>>> zhang.walk()
AttributeError: 'Person' object has no attribute 'walk'

函数和方法是有区别的

>>> class Demo:
pass
>>> t = Demo()
>>> def test(self, v):
self.value = v
>>> t.test = test
>>> t.test #普通函数
<function test at 0x00000000034B7EA0>
>>> t.test(t, 3) #必须为self参数传值>>> t.test = types.MethodType(test, t)
>>> t.test #绑定的方法
<bound method test of <__main__.Demo object at 0x000000000074F9E8>>
>>> t.test(5) #不需要为self参数传值

方法

• 在类中定义的方法可以粗略分为四大类：公有方法、私有方法、静态方法和类方法。
• 公有方法、私有方法都属于对象，私有方法的名字以两个下划线“__”开始，每个对象都有自己的公有方法和私有方法，在这两类方法中可以访问属于类和对象的成员；
  公有方法通过对象名直接调用，私有方法不能通过对象名直接调用，只能在属于对象的方法中通过 self 调用或在外部通过 Python 支持的特殊方式来调用。
  如果通过类名来调用属于对象的公有方法，需要显式为该方法的 self 参数传递一个对象名，用来明确指定访问哪个对象的数据成员。
• 类变量：属于类本身，用于定义该类本身所包含的状态数据
• 实例变量：属于该类的对象，用于定义对象所包含的状态数据
• 方法：定义该类的对象的行为或功能的实现

>>> class Root:
"""这是一个类""" #类定义说明文档
__total = 0 #类变量在整个实例化的对象中是公用的。类变量通常不作为实例变量使用
def __init__(self, v): #构造方法
value = 0 #局部变量
self.__value = v #实例变量
Root.__total += 1 #通过类来访问类变量

def show(self): #普通实例方法
print('self.__value:', self.__value)
print('Root.__total:', Root.__total)

@classmethod #修饰器，声明类方法
def classShowTotal(cls): #类方法
print(cls.__total)

@staticmethod #修饰器，声明静态方法
def staticShowTotal(): #静态方法
print(Root.__total)
>>> r = Root(3)
>>> r.classShowTotal() #通过对象来调用类方法
1
>>> r.staticShowTotal() #通过对象来调用静态方法
1
>>> r.show()
self.__value: 3
Root.__total: 1
>>> rr = Root(5)
>>> Root.classShowTotal() #通过类名调用类方法
2
>>> Root.staticShowTotal() #通过类名调用静态方法
2
>>> Root.show() #试图通过类名直接调用实例方法，失败
TypeError: unbound method show() must be called with Root instance as first argument (got nothing instead)
>>> Root.show(r) #但是可以通过这种方法来调用方法并访问实例成员
self.__value: 3
Root.__total: 2
>>> Root.show(rr) #通过类名调用实例方法时为self参数显式传递对象名
self.__value: 5
Root.__total: 2

• 对象是类的实例。
• 对于类变量而言，它们就是属于在类命名空间内定义的变量，因此程序不能直接访问这些变量，程序必须使用类名/对象来调用类变量。通过对象访问类变量，本质上依然是通过类名在访问。
• 如果程序对一个对象的实例变量进行了修改，这种修改也不会影响到类变量和其他对象的实例变量。
• 创建对象的根本方法是构造方法，调用某个类的构造方法即可创建这个类的对象，Python无需使用new方法。
• self 不是 python 关键字
• 在使用类调用实例方法的时候，Python不会自动为第一个参数绑定调用者。

u = User() User.walk(u) <=> u = User() u.walk()

• Python只要求手动为第一个参数绑定参数值，并不要求必须绑定User对象，User.walk(“asd”)也可。
• 当Python对象的一个方法调用另一个方法时，不可以省略self。
• 类方法的第一个参数（通常为cls）会自动绑定到类本身，但是对于静态方法则不会自动绑定。
• 静态方法和类方法都可以通过类名和对象名调用，但不能直接访问属于对象的成员，只能访问属于类的成员。
• 静态方法可以没有参数。
• 一般将cls作为类方法的第一个参数名称，但也可以使用其他的名字作为参数，并且在调用类方法时不需要为该参数传递值。
• 在使用Python编程时，一般不需要使用类方法或静态方法，程序完全可以使用函数来代替类方法或静态方法。但是在特殊的场景（比如工程模式），类方法和静态方法也是不错的选择。
• 类的专有方法
  
  
  
  
  
  
  

私有成员和公有成员

>>> class A:
def __init__(self, value1 = 0, value2 = 0):
self._value1 = value1
self.__value2 = value2
def setValue(self, value1, value2):
self._value1 = value1
self.__value2 = value2
def show(self):
print(self._value1)
print(self.__value2)
>>> a = A()
>>> a._value1
0
>>> a._A__value2 #在外部访问对象的私有数据成员
0

• 在Python中，以下划线开头的变量名和方法名有特殊的含义，尤其是在类的定义中。用下划线作为变量名和方法名前缀和后缀来表示类的特殊成员：
  _xxx：受保护成员，不能用’from module import *'导入；
  __xxx__：系统定义的特殊成员；
  __xxx：私有成员，只有类对象自己能访问，子类对象不能直接访问到这个成员，但在对象外部可以通过“对象名._类名__xxx”这样的特殊方式来访问。
  注意：Python中不存在严格意义上的私有成员。

In [8]: class Fruit(object):
...: value = 1
...: def __init__(self):
...: self.__color = 'Red'
...: self._num = 0.1
...: self.price = 1
...: def show(self):
...: print("value:{},color:{},num:{},price:{}".f
...: ormat(self.value, self.__color, self._num, self.pri
...: ce))
...:

In [9]: f = Fruit()

In [10]: f.show()
value:1,color:Red,num:0.1,price:1

In [11]: f.value
Out[11]: 1

In [12]: f.__color
------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-12-8047530fa8c8> in <module>
----> 1 f.__color

AttributeError: 'Fruit' object has no attribute '__color'

In [13]: f._num
Out[13]: 0.1

In [14]: f.price
Out[14]: 1>>> class Fruit:
def __init__(self):
self.__color = 'Red'
self.price = 1
>>> apple = Fruit()
>>> apple.price #显示对象公开数据成员的值
1
>>> apple.price = 2 #修改对象公开数据成员的值
>>> apple.price
2
>>> print(apple.price, apple._Fruit__color) #显示对象私有数据成员的值
2 Red
>>> apple._Fruit__color = "Blue" #修改对象私有数据成员的值
>>> print(apple.price, apple._Fruit__color)
2 Blue
>>> print(apple.__color) #不能直接访问对象的私有数据成员，出错
AttributeError: Fruit instance has no attribute '__color'

运算符重载

#!/usr/bin/python3

class Vector:
def __init__(self, a, b):
self.a = a
self.b = b

def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)

def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)In [18]: v1 + v2
Out[18]: <__main__.Vector at 0x1f935fa5cf8>Vector(7,8)

在程序中，可以使用一个下划线来表示不关心该变量的值。

>>> for _ in range(5):
print(3, end=' ')

3 3 3 3 3
>>> a, _ = divmod(60, 18) #只关心整商，不关心余数，等价于a = 60//18
>>> a
3

属性

将属性设置为可读、可修改、可删除。

class Test:
def __init__(self, value):
self.__value = value
def __get(self):
return self.__value
def __set(self, v):
self.__value = v
def __del(self):
del self.__value
value = property(__get, __set, __del)
def show(self):
print(self.__value)
>>> t = Test(3)
>>> t.show()
3
>>> t.value
3
>>> t.value = 5
>>> t.show()
5
>>> t.value
5
>>> del t.value #删除属性
>>> t.value #对应的私有数据成员已删除
AttributeError: 'Test' object has no attribute '_Test__value'
>>> t.show()
AttributeError: 'Test' object has no attribute '_Test__value'
>>> t.value =1 #为对象动态增加属性和对应的私有数据成员
>>> t.show()
1
>>> t.value
1

【文章原创作者：站群服务器 http://www.558idc.com/mggfzq.html 欢迎留下您的宝贵建议】