Python——对象

一 Python中的对象

在Python中定义什么是对象，拿球做例子。可以操作一个球，比如捡球、踢球、抛球等。我们把这些操作称为动作。还可以通过颜色、重量和大小来描述一个球。这些就是球的属性。在Python中，一个对象的特征也称为属性，动作称为方法。

如果要建立一个球的Python版本或者模型，球就是一个对象，它要有属性和方法。

球的属性可能是 (这些都是关于球的描述)：

ball.color
ball.size
ball.weight

球的方法可能有 (这些都是可能对球做的操作)：

ball.kick()
ball.throw()
ball.inflate()

二 对象=属性+方法

什么是属性：

属性就是你所知道的关于球的所有方面，球的属性就是一些信息(数字、字符串等)，没错，它们就是变量，只不过是包含在对象中的变量。

可以显示：

print ball.size

可以给它们赋值：

ball.color = "green"

可以把它们赋值给常规的、不是对象的变量：

mycolor = ball.color

还可以把它们赋给其他对象的属性：

myball.color = yourball.color

什么是方法：

方法就是可以对对象做的操作，它们是一些代码块。可以调用这些代码来完成某个工作，是不是很熟悉？方法其实就是在对象中的函数。函数能做到的，方法都能做到，包括传递参数和返回值。

所以利用对象，可以把一个东西的属性和方法收集到一起。

三 创建对象

Python中创建对象包括两步：

第一步是描述对象。Python中对象的描述或蓝图称为一个类。
第二步是使用类建立一个对象。这个对象称为这个类的一个实例。

class Ball:
    def bounce(self):
        if self.direction == "down":
            self.direction == "up"

上例是一个球的类定义，其中一个方法bounce( )。属性并不属于类，它们属于各个实例。因为每个实例可以有不同的属性。

(1) 创建一个对象实例

前边说过，类定义并不是一个对象，只是一个蓝图。现在来真正的“盖房子”。

class Ball:
    def bounce(self):
        if self.direction == "down":
            self.direction = "up"
            
myball = Ball()
myball.direction = "down"
myball.color = "red"
myball.size = "small"

print "I just created a ball."
print "My ball is",myball.size
print "My ball is",myball.color
print "My ball's direction is",myball.direction
print "Now I'm going to bounce the ball."
print
myball.bounce()
print "Now the ball's direction is",myball.direction

调用bounce( ) 方法会把球的方向从 down 改为 up，这正是bounce( )方法中要做的。

(2) 初始化对象

创建球对象时，并没有在size、color、或direction中填入任何内容，必须在创建对象后填充这些内容。而初始化对象就是可以在创建对象时设置属性。

class Ball:
    def __init__(self, color,size,direction):
        self.color = color
        self.size = size
        self.direction = direction
        
    def bounce(self):
        if self.direction == "down":
            self.direction = "up"
            
myball = Ball("red", "small", "down")

print "I just created a ball."
print "My ball is",myball.size
print "My ball is",myball.color
print "My ball's direction is",myball.direction
print "Now I'm going to bounce the ball."
print
myball.bounce()
print "Now the ball's direction is",myball.direction

这里需要注意一个地方：
函数__init__( )，两边的下划线是双下划綫，而不是单下划线 _init( ) _，用错会出现这样的错误：

Traceback (most recent call last):
  File "F:\Python文件\5-1 对象.py", line 11, in 
    myball = Ball("red", "small", "down")
TypeError: this constructor takes no arguments`

(3) 神奇的__str__( )

键入：

class Ball:
    def __init__(self, color,size,direction):
        self.color = color
        self.size = size
        self.direction = direction
        
myball = Ball("red", "small", "down")
print myball

而加入__str__( )后：

class Ball:
    def __init__(self, color,size,direction):
        self.color = color
        self.size = size
        self.direction = direction

    def __str__(self):
        msg = "Hi, I'm a " + self.size + " " + self.color  + " ball!"
        return msg
    
myball = Ball("red", "small", "down")
print myball

它的功能是：告诉Python打印一个对象时具体显示什么内容。

四 一个实例类——HotDog

首先为热狗指定一些属性和方法。

下面是热狗的属性：

• cooked_level：这是一个数字。0-3表示还是生的，超过3表示半生不熟，超过5表示已经烤好，超过8表示已经烤糊。热狗刚开始都是生的。
• cooked_string：这是一个字符串。描述热狗的生熟程度。
• ingredients：这是配料，比如番茄酱、芥末酱等。

下面是热狗的方法：

• cook( )：把热狗烤一段时间。这会让热狗越来越熟。
• add_ingredients( )：给热狗加一些配料。
• __ init__( )：创建实例并设置默认属性。
• __ str__( )：让print的结果看起来更好一些。

(1) 定义类 初始化

首先，需要定义类。再定义__init__( )方法：

class HotDog:
    def __init__(self):
        self.cooked_level = 0
        self.cooked_string = "Raw"
        self.ingredients = []

先从一个没有加任何配料的生热狗开始。

(2) 建立方法

现在，建立一个方法烤热狗：

    def cook(self, time):
        self.cooked_level = self.cooked_level + time #按时间量增加烤制级别
        if self.cooked_level > 8:
            self.cooked_string = "Over-toasting"
        elif self.cooked_level > 5:
            self.cooked_string = "Well-down"
        elif self.cooked_level > 3:
            self.cookede_string = "Medium"
        else:
            self.cooked_level = "Raw"

(3) 测试

① 继续下面工作之前，先对这一部分做个测试。需要创建热狗的一个实例，还要检查它的属性：

myDog = HotDog()
print myDog.cooked_level
print myDog.cooked_string
print myDog.ingredients

把上边那些内容放在一起，运行：

class HotDog:
    def __init__(self):
        self.cooked_level = 0
        self.cooked_string = "Raw"
        self.ingredients = []

    def cook(self, time):
        self.cooked_level = self.cooked_level + time #按时间量增加烤制级别
        if self.cooked_level > 8:
            self.cooked_string = "Over-toasting"
        elif self.cooked_level > 5:
            self.cooked_string = "Well-down"
        elif self.cooked_level > 3:
            self.cookede_string = "Medium"
        else:
            self.cooked_level = "Raw"
            
myDog = HotDog()
print myDog.cooked_level
print myDog.cooked_string
print myDog.ingredients

② 现在测试cook( )方法，再增加下边的代码：

print "Now I'm going to cook the hot dog."
level = int(raw_input("Enter the cooked_level："))
myDog.cook(level)
print
print myDog.cooked_level
print myDog.cooked_string

运行这个程序，结果为：

(4) 增加配料和__str__( )的使用

class HotDog:
    def __init__(self):
        self.cooked_level = 0
        self.cooked_string = "Raw"
        self.ingredients = []

    def __str__(self):      #定义新的__str__()方法
        msg = "hot dog"
        if len(self.ingredients) > 0:
            msg = msg + "with"
        for i in self.ingredients:
            msg = msg + i + ","
        msg = msg.strip(",")
        msg = self.cooked_string + " " + msg + "."
        return msg
        
    def cook(self, time):
        self.cooked_level = self.cooked_level + time 
        if self.cooked_level > 8:
            self.cooked_string = "Over-toasting"
        elif self.cooked_level > 5:
            self.cooked_string = "Well-down"
        elif self.cooked_level > 3:
            self.cookede_string = "Medium"
        else:
            self.cooked_level = "Raw"
            
    def add_ingredients(self, ingredients):  #定义新的addingredients()方法
        self.ingredients.append(ingredients)
            
myDog = HotDog()

print myDog
print "Cooking hot dog for 4 minutes..."
myDog.cook(4)
print

print myDog
print "Cooking hot dog for 3 minutes..."
myDog.cook(3)
print

print myDog
print "Cooking hot dog for 10 minutes..."
myDog.cook(10)
print myDog
print

print "Now,I'm going to add some ingredients on my hot dog"
myDog.addingredients("ketchup")
myDog.addingredients("mustard")
print myDog

五 多态和继承

对象最为重要的两个方面：多台和继承。

(1) 多态

同一个方法，不同的行为
多态是指对于不同的类，可以有同名的两个(或多个)方法。取决于这些方法应用于哪个类，它们可以有不同的的行为。

例如，要建立一个程序做几何题，需要计算不同形状的面积，比如三角形和正方形。可以创建两个类：

class Triangle:
    def __init__(self,width,height):
        self.width = width
        self.height = height

    def getArea(self):
        area = self.width * self.height /2.0
        return area

class Square:
    def __init__(self,size):
        self.size = size

    def getArea(self):
        area = self.size * self.size
        return area

Triangle和Square类都有一个名为getArea( )的方法。在交互模式键入：

>>> myTriangle = Triangle(4,5)
>>> mySquare = Square(7)
>>> myTriangle.getArea()
10.0
>>> mySquare.getArea()
49
>>> 

这两个图形都使用了方法名getArea( )，不过每个形状中这个方法做的工作不同，这就是多态的一个例子。

(2) 继承

向父母学习
在面向对象的编程中，类可以从其他类继承属性和方法。从其他类继承属性或方法的类称为派生类或子类。

假如我们想建立一个游戏，玩家一路上可捡起不同的东西，比如食物、钱、或衣服。可以建一个类，名为GameObject。GameObject类有name等属性(例如coin、apple、或hat)和pickUp( )等方法。所有游戏对象都有这些共同的方法和属性。

然后，可以为硬币建立一个子类。Coin类从GameObject派生。它要继承GameObject的属性和方法，所以Coin类会自动有一个name属性和pickUp( )方法。Coin类还需要一个value属性和一个spend( )方法。
具体代码：

class GameObject:
    def __init__(self,player):
        self.name = name

    def pickUp(self,player):
        # 在这里添加代码将对象添加到玩家的集合中
        
class Coin(GameObject):
    def __init__(self,value):
        GameObject.__init__(self)
        self.value = value

    def spend(self,buyer,seller):
        # 把代码放在这里，从买家的钱中取出硬币，然后把钱加到卖方的钱上。

在上边的例子中，并没有在方法中加入任何实际代码。只用注释来解释这些方法要做什么，这一种很好的未雨绸缪的办法，“空”函数或方法称为代码桩。

如果运行上边的代码，会出现错误消息，因为函数定义不能为空。因此可以使用Python的关键字pass作为一个占位符:

class GameObject:
    def __init__(self,player):
        self.name = name

    def pickUp(self,player):
        pass
        # 在这里添加代码将对象添加到玩家的集合中
        
class Coin(GameObject):
    def __init__(self,value):
        GameObject.__init__(self)
        self.value = value

    def spend(self,buyer,seller):
        pass
        # 把代码放在这里，从买家的钱中取出硬币，然后把钱加到卖方的钱上。

做几个练习

戳这里