第037讲：类和对象：面向对象编程

目录

0. 请写下这一节课你学习到的内容：格式不限，回忆并复述是加强记忆的好方式！

（一）self 是什么？

Python 的 self 相当于 C++ 的 this
指针。我们知道，类是图纸，而由类实例化出的对象才是真正可以住人的房子，这是我们上节课大的比方。我们还知道，根据一张图纸就可以设计出成千上万的房子，这些房子都长得差不多，因为它们都来自于同一张图纸，但是它们都有不同的主人，每个人都只可以回到自己的家，self 就相当于每个房子的门牌号，有了 self，就可以轻松的找到自己的房子，Python 的 self
参数就是同样的道理，由同一个类可以生成无数个对象，这些对象都长得很相似，因为它们都是来源于同一个类的属性和方法，当一个对象的方法被调用的时候，对象会将自身作为第一个参数传给
self 参数，接收到这个 self 参数的时候，Python 就知道你是哪一个对象在调用方法了。举例说明：

>>> class Ball:
	def setName(self, name):
		self.name = name
	def kick(self):
		print("我叫%s，该死的，谁踢我..."% self.name)
 
		
>>> a = Ball()
>>> a.setName("球A")
>>> b = Ball()
>>> b.setName("球B")
>>> a.kick()
我叫球A，该死的，谁踢我...
>>> b.kick()
我叫球B，该死的，谁踢我...

我们发现，在对象类定义这里，它的这些方法都有一个 self，我们生成两个实例化对象 a 和 b，这里都调用 kick()
方法，但是实现结果不一样，是因为 a.kick() 和 b.kick() 都有一个隐藏属性 self，会找到各自对应的
name，这些都是由Python 在背后默默的工作，你只需要在类的定义的时候把 self 写进第一个参数。

（二）Python 的魔法方法

你听说过Python 的魔法方法吗？据说，Python
的对象天生拥有一些神奇的方法，它们是面向对象的Python的一切…它们是可以给你的类增加魔力的特殊方法…如果你的对象实现了这些方法中的某一个，那么这个方法在特殊情况下被Python所调用，而这一切都是自动发生的…Python的这些具有魔力的方法总是会被双下划线所包围
我们今天介绍其中一个最基础的特殊方法：__init __(self)

对于Python的其它的魔法方法，我们后面会专门进行讲解。我们把__init __(self)方法称为构造方法，__init __(self)方法的魔力体现在只要实例化一个对象的时候，那么这个方法就会在对象被创建的时候自动调用。有过C++基础的同学就会知道，这就是构造函数。

其实实例化对象的时候是可以存入参数的，这些参数会自动的存入到__init__(self)方法中， __init __(self，param1，param2…)
> 默认不重写的形式为 __init __（）

也就是我们这个魔法方法中，我们可以通过重写这个方法来自定义对象的初始化操作，说起来比较复杂，举例说明：

>>> class Ball:
	def __init__(self, name):
		self.name = name
	def kick(self):
		print("我叫%s，该死的，谁踢我..."% self.name)
 
		
>>> a = Ball("土豆")  #因为重写了__init__(self)方法，实例化对象时需要一个参数
>>> a.kick()
我叫土豆，该死的，谁踢我...
>>> b = Ball()  #这里没有传入参数就会报错，可以在定义类是给name设置默认参数
Traceback (most recent call last):
  File "<pyshell#84>", line 1, in <module>
    b = Ball()
TypeError: __init__() missing 1 required positional argument: 'name'

（三）公有和私有

默认上来说，对象的属性和方法都是公开的，都是共有的，我们可以通过点（.）操作符来进行访问，举例说明：

class Person:
name = "123"
 
 #IDLE执行

>>> p = Person()
>>> p.name
'123'

为了实现类似于私有变量的特征，Python内部采用了一种叫做 name mangling（名字改编，名字重整）的技术，在Python
中定义私有变量只主要在变量名或函数名前加上“__”两个下划线，那么这个函数或变量就会为私有的了。

class Person:
	__name = "123"
 
#执行

>>> p = Person()
>>> p.__name
Traceback (most recent call last):
  File "<pyshell#94>", line 1, in <module>
    p.__name
AttributeError: 'Person' object has no attribute '__name'
>>> p.name
Traceback (most recent call last):
  File "<pyshell#95>", line 1, in <module>
    p.name
AttributeError: 'Person' object has no attribute 'name'

这时，p.__name 和 p.name
都无法访问对象的name属性，因为它们都找不到了，这样在外部就会将变量名隐藏起来，理论上如果要访问，就要从内部进行，可以这样写：

class Person:
	__name = "123"
	def getName(self):
		return self.__name
#执行

>>> p = Person()
>>> p.getName()
'123'

上面的方法只是理论上的，其实只要你琢磨一下，name mangling
技术的意思就是名字改编、名字重整，那么应该不难发现，Python只是动了一下手脚，它把双下划线开头的变量改了名字而已，它自动是改成了
***_类名__变量名（单下划线+类名+双下划线+变量名）***，如下 ：

class Person:
	__name = "123"
#执行
>>> p = Person()
>>> p._Person__name
'123'

所以说，Python的私有机制是伪私有，Python是没有权限控制的，所以变量是可以被外部调用的。
测试题

0. 以下代码体现了面向对象编程的什么特征？

>>> "FishC.com".count('o')
1
>>> [1, 1, 2, 3, 5, 8].count(1)
2
>>> (0, 2, 4, 8, 12, 18).count(1)
0

答：体现了面向对象编程的多态特征。

1. 当程序员不想把同一段代码写几次，他们发明了函数解决了这种情况。当程序员已经有了一个类，而又想建立一个非常相近的新类，他们会怎么做呢？

答：他们会定义一个新类继承已有的这个类，这样子就只需要简单添加和重写需要的方法即可。
例如已有龟类，那么如果要新定义一个甲鱼类，我们只需要让甲鱼类继承已有的龟类，然后重写壳的属性为“软的”即可（据说甲鱼的壳是软的）。

2. self参数的作用是什么？

答：绑定方法，有了这个参数，Python 再也不会傻傻分不清是哪个对象在调用方法了，你可以认为方法中的 self 其实就是实例对象的唯一标志。

3. 如果我们不希望对象的属性或方法被外部直接引用，我们可以怎么做？

答：我们可以在属性或方法名字前边加上双下划线，这样子从外部是无法直接访问到，会显示AttributeError错误。

4. 类在实例化后哪个方法会被自动调用？

答：__init__方法会在类实例化时被自动调用，我们称之为魔法方法。你可以重写这个方法，为对象定制初始化方案。

5. 请解释下边代码错误的原因：

class MyClass:
        name = 'FishC'
        def myFun(self):
                print("Hello FishC!")

                
>>> MyClass.name
'FishC'
>>> MyClass.myFun()
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    MyClass.myFun()
TypeError: myFun() missing 1 required positional argument: 'self'
>>>

答：首先你要明白类、类对象、实例对象是三个不同的名词。
我们常说的类指的是类定义，由于“Python无处不对象”，所以当类定义完之后，自然就是类对象。在这个时候，你可以对类的属性（变量）进行直接访问（MyClass.name）。
一个类可以实例化出无数的对象（实例对象），Python 为了区分是哪个实例对象调用了方法，于是要求方法必须绑定（通过 self 参数）才能调用。而未实例化的类对象直接调用方法，因为缺少 self 参数，所以就会报错。

动动手

0. 按照以下要求定义一个游乐园门票的类，并尝试计算2个成人+1个小孩平日票价。

平日票价100元
周末票价为平日的120%
儿童半票

class ticket:
    Price=100
    def calculatePrice(self,adult,childrent,isweekend):
        if isweekend=='T':
            price=int(self.Price*1.2)
        elif isweekend=='F:
            price=self.Price
        halfprice=int(price*0.5)

        return adult*price+childrent*halfprice

1. 游戏编程：按以下要求定义一个乌龟类和鱼类并尝试编写游戏。

初学者不一定可以完整实现，但请务必先自己动手，你会从中学习到很多知识的^_）
假设游戏场景为范围（x, y）为0<=x<=10，0<=y<=10
游戏生成1只乌龟和10条鱼
它们的移动方向均随机
乌龟的最大移动能力是2（Ta可以随机选择1还是2移动），鱼儿的最大移动能力是1
当移动到场景边缘，自动向反方向移动
乌龟初始化体力为100（上限）
乌龟每移动一次，体力消耗1
当乌龟和鱼坐标重叠，乌龟吃掉鱼，乌龟体力增加20
鱼暂不计算体力
当乌龟体力值为0（挂掉）或者鱼儿的数量为0游戏结束
答：参考代码附详细注释，希望先自己认真完成，你会从中学习到很多知识的。

import random

class fish:
    def __init__(self):
        self.x =random.randint(0,11)
        self.y =random.randint(0,11)
    def move(self):
        direct=random.randint(1,5)
        if direct==1:
            self.y+=1
            if self.y==11:
                self.y=9
                
        elif direct==2:
            self.y-=1
            if self.y==-1:
                self.y=1
            
        elif direct==3:
            self.x-=1
            if self.x==-1:
                self.x=1

                
        elif direct==4:
            self.x+=1
            if self.x==11:
                self.x=9

class tortoise:
    HP=100
    x=random.randint(0,11)
    y=random.randint(0,11)
    def move1(self):
        direct=random.randint(1,5)
        if direct==1:
            self.y+=1
            if self.y==11:
                self.y=9
                
        elif direct==2:
            self.y-=1
            if self.y==-1:
                self.y=1
            
        elif direct==3:
            self.x-=1
            if self.x==-1:
                self.x=1

                
        elif direct==4:
            self.x+=1
            if self.x==11:
                self.x=9
        self.HP-=1
                
    def move2(self):
        direct=random.randint(1,5)
        if direct==2:
            self.y+=2
            if self.y==12:
                self.y=8
                
        elif direct==2:
            self.y-=2
            if self.y==-2:
                self.y=2
            
        elif direct==3:
            self.x-=2
            if self.x==-2:
                self.x=2

                
        elif direct==4:
            self.x+=2
            if self.x==12:
                self.x=8
        self.HP-=1
    def eat(self):
        newHP=self.HP+20
        if newHP>=100:
            self.HP=100
        else:
            self.HP=newHP

def meet(Fish,Tortoise):
    if Fish.x==Tortoise.x and Fish.y==Tortoise.y:
        return True
    else:
        return False

Fishes=[]
out=[]
for i in range(10):
    Fishes.append(fish())
tortoise1=tortoise()

count=10
while True:
    for i in Fishes:
        if meet(i,tortoise1):
            tortoise1.eat()
            out.append(i)
            count-=1

    for i in out:
        Fishes.remove(i)
    out=[]
    
    if count==0 or tortoise1.HP==0:
        break;

    
    for i in Fishes:
        i.move()
    tortoise1.move1()

print(tortoise1.x,tortoise1.y,tortoise1.HP,end='乌龟的状态\n鱼的状态:\n')
for i in Fishes:
    print(i.x,i.y)