Python笔记2（实操笔记—KK-Greyson）

前言：该笔记主要从“面向对象编程”内容部分开始，“面向对象编程”前面的内容之前只实操了博主“In year”的笔记内容，而从“面向对象编程”开始的内容都是实操博主“KK-Greyson”的笔记内容，可能后面有些地方有点重复，不过感觉博主“KK-Greyson”做的笔记更全面且更详细，后期有时间都慢慢实操补完（他的Python1、Python2后半部分、Python3后面有时间慢慢补完）

————————————————————

面向对象编程   
定义类（有：属性、方法）
创建类的对象（调用类的：属性、方法）
（上面之前学的都是面向过程编程，它俩的区别可看其他笔记里的Python笔记）

1、Python中提供的形似"__方法名__"的内置方法/属性（⭐️❗️找个时间解决下这个疑难）
———
2、定义一个只包含方法的简单类：
class  类名：
     def  方法1（self，参数列表）：
            pass
     def  方法2（self，参数列表）：
            pass

注意：
①方法的定义格式和之前学习过的函数几乎一样，区别在于第一个参数必须是 self （方法可以理解为类中的函数）
②类名的命名规则要符合大驼峰命名法

类定义好后，用类来创建对象、对象调用属性/方法：
对象变量＝类名（）
对象变量.方法1（）
对象变量.方法2（）

第一个面向对象编程
需求：小猫爱吃鱼，小猫爱喝水
分析：定义一个猫类，猫类里面定义吃鱼、喝水两个方法，不需要定义属性（需求未提属性只提了方法），定义类、方法后创建具体对象调用方法
cat
eat（self）、drink（self）

代码：
class  Cat：
    def  eat（self）：
           print（"小猫爱吃鱼"）
    def  drink（self）：
           print（"小猫爱喝水"）
kitty＝Cat（）
kitty.eat（）
kitty.drink（）

补：
使用Cat类再创建一个对象
tom＝Cat（）
tom.eat（）
tom.drink（）

———
3、方法中的self参数
（1）
①在 Python 中，要给对象设置属性，非常的容易，但是不推荐使用（因为：对象属性的封装应该封装在类的内部）
②只需要在类的外部的代码中直接通过．设置一个属性即可（注意：这种方式虽然简单，但是不推荐使用！）
eg：
kitty.name＝"小美"
tom.name＝"小帅"

（2）
由“哪一个对象”调用的方法，方法内的 self 就是“哪一个对象的引用”
在方法内部：
①可以通过 self ．访问对象的属性
②也可以通过 self ．调用其他的对象方法

改造代码如下：
 class Cat :
       def eat ( self ):
              print ("% s 爱吃鱼"%self.name）

 tom ＝ Cat ()
tom.name=" Tom "
 tom . eat ()

 lazy_cat ＝Cat ()
 lazy_cat.name="大懒猫"
 lazy_cat.eat ()
———
 class Cat :
""这是一个猫类"""
 def eat ( self ):
 print (" % s 爱吃鱼"  %  self.name)

（3）
①在类的外部，通过“变量名．”访问对象的属性和方法
②在类封装的方法中，通过“self．”访问对象的属性和方法
———
4.初始化方法--解决在类的外部定义对象属性报错的问题
（1）在日常开发中，不推荐在类的外部给对象增加属性
（如果在运行时，没有找到属性，程序会报错）
（2）对象应该包含有哪些属性，应该封装在类的内部
（3）所以如何给一个类设置属性？
在__init__(self,参数列表)方法中，设置属性：
       self.属性名 = 属性的初始值/形参
然后在创建对象时，使用 类名(属性...)调用

class  Cat：
     def  __init__（self）：
            self.name＝"Tom"
     def  eat（self）：
            print（"%s  爱吃鱼" % self.name）
tom=Cat（）

或（这两张写法的差别就是标⭐️号的地方）

class  Cat：
       def  __init__（self，⭐️name）：
               self.name＝⭐️name
        def  eat（self）：
                print（"%s  爱吃鱼" % self.name）
tom＝Cat（⭐️"Tom"）
———
5.另外两个内置方法
（1）__del__方法（对象被从内存中销毁前，会被自动调用/触发；即这个方法的作用是回收程序过程中的变量，所以会判断变量存在与否后决定执行先后）
class  Cat：
     def  __init__（self，new_name）：
          self.name＝new_name
          print（"%s 来了" % self.name）
      def  __del__（self）：
           print（"%s 走了" % self.name）
#tom是一个全局变量
tom＝Cat（"Tom"）
print（tom.name）
print（"—" * 15）

输出结果：
Tom来了
Tom
———————————————
Tom走了

如果在“print（"—" * 15）”之前写“del tom”即主动删除tom变量就触发了del方法，del方法判断无变量需回收后，那
#tom是一个全局变量
tom＝Cat（"Tom"）
print（tom.name）
del  tom    #主动删除变量，del方法被触发
print（"—" * 15）

输出结果：
Tom来了
Tom
Tom走了
———————————————

（2）__str__方法（返回对象的描述信息， print 函数输出使用）
①在 Python 中，使用 print 输出对象变量，默认情况下，会输出这个变量引用的对象是由哪一个类创建的对象，以及在内存中的地址（十六进制表示）
②如果在开发中，希望使用 print 输出对象变量时，能够打印自定义的内容，就可以利用_ str _这个内置方法了
注意：_ str _方法必须返回一个字符串
③当使用 print 输出对象的时候，默认打印对象的内存地址。如果类定义了＿ str _＿方法，那么就会打印从在这个方法中 return 的数据（return后面没有冒号，可以用括号包起来，直接空格然后接内容，内容里的字符串内容用""包起来就行）

class  Cat（）：
    def   __int__（self，new_name）：
          self.name＝new_name
          print（"%s 来了" % self.name）
    def  __del__（self）：
          print（"%s 走了" % self.name）
     def  __str__（self）：
           return（"我是小猫［%s］" % self.name）
#Tom是一个全局变量
tom＝Cat（"Tom"）
print（tom）#直接打印变量而不是变量的属性的话，输出的是这个变量的地址，所以想要直接输出变量打印自定义的字符串内容的话就通过触发定义的str方法返回字符串结果

输出结果：
Tom来了
我是小猫［Tom］
Tom走了

——————————
面向对象封装案例1
封装就是面向对象编程的第一步：将属性和方法封装到一个抽象的类中（外界使用类创建对象，然后让对象调用方法；对象方法的细节都被封装在类的内部）

（1）小明爱跑步
class  Person：
    def  __init__（self，name，weight）：
          self.name＝name
          self.weight＝weight
     def __str__（self）：
     return"我的名字是%s，我的体重为%f" % （self.name，self.weight）
     def  run（self）：
         print（"%s 跑了一次步" % self.name）
         self.weight -= 0.5
     def  eat（self）：
         print（"%s 吃了一顿饭" % self.name）
         self.weight += 1
xiaoming＝Person（"小明",60）
xiaoming.eat（）
xiaoming.run（）
xiaoming.eat（）
print（xiaoming）#返回结果是_str_方法return的内容

（2）小明爱跑步，小美也爱跑步
①在对象的方法内部，是可以直接访问对象的属性的
②同一个类创建的多个对象之间，属性互不干扰！
接上（1）的代码写下面的内容：
xiaomei=Person（"小美",50）
xiaomei.run（）
xiaomei.eat（）
print（xiaomei）

（3）摆放家具
①先创建家具类
class  HouseItem：
    def  __init__（self，name，area）：
          self.name＝name
          self.area＝area
    def __str__（self）：
           return  "%s 占地面积： %.2f" % （self.name，self.area）
#创建家具
bed＝HouseItem（"席梦思",4）
chest＝HouseItem（"衣柜",2）
table＝HouseItem（"餐桌",1.5）
print（bed）
print（chest）
print（table）

②再创建房间类
class  House：
   def__init__（self，house_type，area）：
#注：self.属性＝形参（形参是init方法括号里可以定义的，形参是接收外部传入的数据的），要定义属性的话用“self.属性”去定义就行了
       self.house_type＝house_type
       self.area＝area
#剩余面积默认和总面积一致
       self.freearea＝area
#默认没有任何家具
       self.item_list＝［］
    def  __str__（self）：
          return （"户型:［%s］，总面积：［%.2f］，剩余：［%.2f］，家具：［%s］" %
（self.house_type，self.area，self.freearea，self.item_list））
     def  add_item（self，item）：
         print（"要添加%s" % item）

疑难：这里不用self.item吗？
→只有在需要将 item 保存为对象的状态（以便其他方法可以访问）时，才需要使用 self.item。如果只是临时使用参数的值，直接使用 item 即可。

#创建房子对象
my_home＝House（"两室一厅"，60）
my_home.add_item（bed）
my_home.add_item（chest）
my_home.add_item（table）
print（my_home）

③最后添加家具（应该是接续②中的补全）
def   add_item（self，item）：
   print（"要添加%s" % item）
   #1.判断家具面积是否大于剩余面积
   if  item.area＞self.freearea：
       print（"%s 的面积太大，不能添加到房子中" % item.name）
       return    #❗️⭐️疑难：这里return的作用是？
   #2.将家具的名称追加到名称列表中
        self.item_list.append（item.name）
   #3.计算剩余面积 
         self.freearea-=item.area

——————————
面向对象封装案例2（略，以后有时间去回头补）

——————————
is与==判断两变量时的区别：
①is用于判断两个变量引用对象是否为同一个
②==用于判断引用变量的值是否相等
a =[1,2,3]
 b =[1,2,3]
 b is a    #False 
 b == a   # True

——————————
私有属性和私有方法
1.场景和定义
（1）场景：
在开发中，有些属性和方法不希望被外界访问、只希望在对象的内部被使用
①私有属性：对象不希望公开的属性
②私有方法：对象不希望公开的方法
（2）定义：
在属性名/方法名前加两个下划线，定义的就是私有属性或方法
class   Women：
    def  __init__（self，name）：
         self.name＝name
         self.__age＝18
    def  __secret（self）：
         #在对象的方法内部，是可以访问对象的私有属性的
         print（"我的年龄是%s" % self.__age）
xiaofang＝Women（"小芳"）
#私有属性，不能访问
#print（xiaofang.__age）
#私有方法，不能访问
#xisofang.__secret（）

拓展补充：伪私有属性和私有方法（科普）→在Python中，没有真正意义上的私有：
    在私有属性或私有方法前面加上 _类名，同样可以在外部访问到私有属性或私有方法。
    但是不能这样做，这个仅供了解底层原理。

 

————————————————————

继承
———
面向对象的三大特性
1.封装  是根据职责将属性和方法封装到一个抽象的类中
2.继承  实现代码的重用，相同的代码不需要重复的编写
3.多态  不同的对象调用相同的方法，产生不同的执行结果增加代码的灵活度
——————————
（1）单继承
A.继承的概念、语法、特点
①概念：子类拥有父类所有的属性和方法
②语法：class  类名（父类名）：
                   pass

③传递性：
c类从b类继承，b类又从a类继承，那c类就具有b类和a类的所有方法和属性

B.方法的重写（java中有重载和重写，Python中只有重写）

场景：当父类的方法不能满足子类需求时，可以对方法进行重写（override）
———
Animal 
 eat ( self ):
 drink ( self ):
 run ( self ):
 sleep ( self ):

 Dog（Animal）
 bark ( self ):
 
 XiaoTianQuan （Dog）
 fly ( self ):
 bark ( self ):
———
重写父类方法有两种情况：
1.覆盖父类的方法
2.对父类方法进行扩展

1）覆盖父类的方法
①如果在开发中，父类的方法实现和子类的方法实现，完全不同
就可以使用覆盖的方式，在子类中重新编写父类的方法实现
②具体的实现方式，就相当于在子类中定义了一个和父类同名的方法并且实现
③重写之后，在运行时，只会调用子类中重写的方法，而不再会调用父类封装的方法

覆盖父类的A方法：
    在子类中，编写一个和A方法的方法名和参数列表都相同的方法，方法内容重写。

2）对父类方法进行扩展
①如果在开发中，子类的方法实现中包含父类的方法实现
父类原本封装的方法实现是子类方法的一部分
就可以使用扩展的方式
②在子类中重写父类的方法
③在需要的位置使用 super ()．父类方法来调用父类方法的执行
④代码其他的位置针对子类的需求，编写子类特有的代码实现

对父类方法进行扩展：
    子类中重写父类的方法，在子类的重写方法中，又使用了父类的某个方法，
        可以使用super().父类方法，在子类重写方法中调用父类方法。

class Dog（Animal）：
   def  bark（self）：
       print（"汪汪叫"）

class  XiaoTianQuan（Dog）：
    def  fly（self）：
       print（"我会飞"）
    def  bark（self）：
#1.针对子类特有的需求，编写代码
       print（"飞速召唤"）
#2.使用“super（）.”调用原来在父类中封装的方法，这里的方法的括号里不用写self了
       super（）.bark（）
#3.增加其他子类的代码
       print（"brbrbrbbrrbbr"）

———
super拓展补充：
但是在python2.x的早期版本中，没有super，那么怎么调用父类方法？
    用下面的方式：
略（之后有时间回头再补）

———
C.关于父类的私有属性和方法
1.子类对象不能在自己的方法内部，直接访问父类的私有属性或私有方法
2.子类对象可以通过父类的公有方法间接访问到私有属性和私有方法
———
A 
num1
__num2
__init__( self ):
__test ( self ): 
test ( self ):

 B 
 demo ( self ):
———
class B ( A ):
 def demo ( self ):
#1．在子类的对象方法中，不能访问父类的私有属性
# print ("访问父类的私有属性% d "% self .__num2)
#2．在子类的对象方法中，不能调用父类的私有方法
# self .__test ()
———
①B 的对象不能直接访问__num2属性
②B 的对象不能在 demo 方法内访问__num2属性
③B 的对象可以在 demo 方法内，调用父类的 test 方法
④父类的 test 方法内部，能够访问__num2属性和＿_ test 方法

eg：
class A：
    def  __init__（self）：
        self.num1
        self.__num2
     def __test ( self ): 
          print（"访问私有属性%s" % self.__num2）
     def test ( self ):
           print（"访问私有方法%s" % self.__test）
           self.__test（）

class B ( A ):
   def demo ( self ):
       print（"访问父类共有属性%s" % self.num1）
       self.test（）

b=B（）
b.test（） # 调用父类的公有方法（父类中的公有方法输出私有属性）
b.demo（） # 调用子类公有方法（子类方法中输出父类公有属性）

——————————
（2）多继承
A.概念、语法
①概念：子类可以拥有多个父类，并且具有所有父类的属性和方法
②语法：
class  子类名（父类名1，父类名2，…）：
       pass

B.使用多继承的注意事项：
如果不同的父类中存在同名的方法，子类对象在调用方法时，会调用哪一个父类中的方法呢？→会调用先继承到父类中的方法

提示：开发时，应该尽量避免这种容易产生混淆的情况！-﹣如果父类之间存在同名的属性或者方法，应该尽量避免使用多继承，或者至少调用父类方法时指定调用哪个父类的方法（示例见下面代码中）

class  A：
   test（self）：
        print（"A→test"）
   demo（self）：
         print（"A→demo"）
class  B:
      test（self）：
        print（"B→test"）
   demo（self）:
         print（"B→demo"）
class  C（A,B）:
     def  exam（self）:
#class  C（A,B）:先继承A类，那么会调用A类的test和demo方法
#class  C（B,A）:先继承B类，那么会调用B类的test和demo方法
      super（）.test（）
      super（）.demo（）

#可以指定调用哪个父类的哪个方法
     super（B）.test（）

#创建子类对象
#class  C（A,B）:先继承A类，那么子对象就会调用A类的test和demo方法
#class  C（B,A）:先继承B类，那么子对象就会调用B类的test和demo方法
c＝C（）
c.test（）
c.demo（）

#调用子类自己的方法
c.exam（）

C.Python中的MRO——方法搜索顺序

①Python 中针对类提供了一个内置属性__mro__可以查看方法搜索顺序
②MRO 是 method resolution order ，主要用于在多继承时判断方法、属性的调用路径

 print ( c.__mro__ )
输出结果
(< class '_ main _. C '>,< class '_ main _. A '>,< class '_ main _. B '>,< class ' object '>)

①在搜索方法时，是按照__mro__的输出结果从左至右的顺序查找的
②如果在当前类中找到方法，就直接执行，不再搜索
③如果没有找到，就查找下一个类中是否有对应的方法，如果找到，就直接执行，不再搜索
④如果找到最后一个类，还没有找到方法，程序报错

C类 查询某个方法 的 搜索顺序：
先在当前类 C类中 找； 没找到 去A类找；没找到去B类找；没找到 去object类找；再没找到，就报错。找到之后就不再往下找。
———
mro方法（推荐B站视频以及里面的弹幕和评论：BV1V5411S7dY）：
（1）C、B都继承了A，打印结果是：B，mro是：M C B A

 

（2）如果B没继承A，打印结果是：A，mro是：M C A B

 

问题：图一里C继承了A，为什么不顺着C先找到A，而是把A排在B后面？
→因为B也继承了A, 所以B必须要在A前面，而在M那C又在B前，所以就是M,C,B,A
———
mro就是每一个类会把它所有的父类和自己做一个线性化排队，这个排队是保证自己是最高优先级（优先级其次才是父类）

MRO就是用的C3算法的 Linearization Algorithm（线性化算法）

C3算法  简单的说就是：
1. 《 父 凭 子 贵 》
如果A或A的某个子类在B或B的某个子类之前，那么A在B之前。
2. 《 先 来 后 到 》
如果A先继承B再继承C，那么对于A及A的任一子类，B的优先级比C更高。
3. 《 子 承 父 业 》
如果A的所有父类都不使用B，则A不能使用B。
———
D.新式类和旧式（经典）类

object 是 Python 为所有对象提供的基类，提供有一些内置的属性和方法，可以使用 dir 函数查看

（1）新式类：以 object 为基类的类，推荐使用
（2）经典类：不以 object 为基类的类，不推荐使用
（3）在 Python 3.x中定义类时，如果没有指定父类，会默认使用 object 作为该类的基类﹣ Python 3.x中定义的类都是新式类
（4）在 Python 2.x中定义类时，如果没有指定父类，则不会以 object 作为基类
（5）新式类和经典类在多继承时﹣﹣会影响到方法的搜索顺序
（6）为了保证编写的代码能够同时在 Python 2.x和 Python 3.x运行！
今后在定义类时，如果没有父类，建议统一继承自 object 
 （7）示例
class 类名（ object ):
    pass

 

————————————————————
多态
（1）概念：不同的子类对象调用相同的父类方法
（2）案例演练：多态的实现
class  Dog：
    def  speak（self）：
        print（"Woof!"）
class  Cat:
     def  speak（self）:
          print（"Meow!"）
class  Bird:
     def  speak（self）:
          print（"Chirp!"）

#创建对象
dog=Dog（）
cat=Cat（）
bird=Bird（）

#创建一个函数，通过相同的接口调用不同的行为
（区分开，这个不是类里的方法，而是独立的函数，所以参数没有self、而是直接定义其他需要的参数）

def  animal_sound（animal）：
     animal.speak（）

#调用animal_sound函数
animal_sound（dog）   # 输出: Woof!animal_sound（cat）    # 输出: Meow!animal_sound（bird）   # 输出: Chirp!

在这个例子中，animal_sound()函数接受一个animal对象，并调用其speak()方法。即使dog、cat和bird是不同类型的对象，它们都实现了speak()方法，并能根据各自的实现表现出不同的行为。这个就是多态的体现。

 

————————————————————
类属性和类方法
（1）类的结构
1.1一些术语

使用类名（）创建对象后，内存中就有了一个对象的实实在在的存在——实例

a.创建出来的对象叫做类的实例
b.创建对象的动作叫做实例化
c.对象的属性叫做实例属性
d.对象调用的方法叫做实例方法
———
1.2类是一个特殊的对象——类对象
在程序中：类对象在内存中只有一份、使用一个类可以创建出很多个实例对象

除了封装实例（示例对象）的  属性  和  方法（self）  外，类对象还拥有自己的  属性  和  方法（cls）  ，即→
a.类属性
b.类方法（cls）

通过“类名.”的方式，可以  访问类的属性  或  调用类的方法

 

————————————
（2）类属性和实例属性
2.1概念和使用

一、类属性 （相当于 Java中的静态变量）
①定义：在类中 通过 "赋值语句" 定义类属性
②调用：通过 "类名.属性名" 调用类属性

二、实例属性 
①定义：在__init__方法中使用 "self.实例属名" 定义
②调用：通过 "对象.实例属性" 调用。

代码示例：
class  Tool（object）：
    #使用赋值语句，定义类属性，记录创建工具对象的总数
    count＝0

    def   __init__（self，name）：
         self.name＝name

     #针对类属性做一个计数+1（注意缩进，这里是调用类属性）
     Tool.count+=1

创建工具对象
tool1＝Tool（"斧头"）
tool2＝Tool（"榔头"）
tool3＝Tool（"铁锹"）

#知道使用Tool类创建了多少个对象？
print（"现在创建了 %d 个工具" % Tool.count）
———
2.2属性的获取机制
在Python中  属性的获取  存在一个  向上查找机制，
如tool1.count：
→①.首先在对象内部  查找对象属性
→②.没找到就会  向上寻找类属性

对象  调用  类属性/类名  访问  类属性的方式：
①也可以通过 “对象.类属性” 调用类属性，但是不推荐这样使用。（tool1.count）
②使用 “类名.类属性” 访问 类属性。（Tool.count）
③使用 “对象.类属性 = 值” 赋值语句，只会给对象添加一个属性，而不会影响到类属性的值。（tool1.count＝1）

———————————
（3）类方法和静态方法

3.1类方法

简述：
①类方法给类自己用，实例方法给实例用
②调用类方法，不需要创建对象；使用 “类名. ”调用类方法，不要传递 cls 参数
③类方法 相当于 Java中的 静态方法
④在类方法内部：使用 “cls. ”访问类属性；使用 “cls. ”访问其他的类方法；cls 是当前类
———
定义：
类方法就是针对类对象定义的方法
（在类方法内部可以直接访问类属性或者调用其他的类方法）
———
语法：
@classmethod 
 def  类方法名（cls):
        pass 

①类方法需要用修饰器  ＠classmethod  来标识，告诉解释器这是一个类方法
②类方法的第一个参数应该是cls
a.由哪一个类调用的方法，方法内的cls就是哪一个类的引用
b.⭐️这个参数和“实例方法的第一个参数是 self” 类似
c.提示使用其他名称也可以，不过习惯使用cls
———
调用方法：
①通过 “类名.类方法名” 调用类方法，调用方法时，不需要传递 cls 参数
②在方法内部
a.可以通过 “cls.类属性名” 访问类的属性
b.也可以通过 “cls.类方法名” 调用其他的类方法
———
代码示例：
class  Tool（object）：
    count = 0
    name＝None

    def  __init__（self，name）：
         self.name=name
         #应该在初始化时增加计数（让类属性的值+1）（优快云上借鉴的笔记这里代码写到下面去了写错了）
         Tool.count+=1

     @classmethod
     def  show_tool_count（cls）：
     #显示工具对象的总数
          print（"工具对象的总数 %d " % cls.count）
      #在类方法内部，可以直接使用cls访问  类属性  或  调用类方法
          
#创建工具对象
tool1＝Tool（"斧头"）
tool2＝Tool（"榔头"）

#调用类方法
Tool.show_tool_count（）

———————

3.2静态方法

简述：
静态方法，不需要必须设置第一个参数cls；通过 “类名. ” 调用静态方法，不需要创建对象。
———
定义：
在开发时，如果需要在类中封装一个方法，这个方法→
a.既不需要访问实例属性或者调用实例方法
b.也不需要访问类属性或者调用类方法
这个时候，可以把这个方法封装成一个静态方法
———
语法：
@staticmethod
def  静态方法名（）：
      pass

静态方法需要用修饰器  @staticmethod   来标识，告诉解释器这是一个静态方法
———
调用方法：
通过  “类名.静态方名”  调用静态方法
———
代码示例：
class  Dog（object）：
    #狗对象计数
     dog_count＝0

    @staticmethod
    def  run（）：
          #不需要访问实例属性也不需要访问类属性的方法
          print（"狗在跑…"）

     def  __init__（self，name）：
          self.name＝name

#通过“类名.静态方法名”调用静态方法，不需要创建对象
Dog.run（）

——————————
（4）方法综合案例
class  Game（object）：
      #游戏最高分，类属性
      top_score＝0

      def  __init__（self，player_name）：
           self.player_name＝player_name

      @staticmethod
      def  show_help（）：
           print（"帮助信息：让僵尸走进房间"）

       @classmethod
       def  show_top_score（cls）：
             print（"游戏的最高分是 %d " % cls.top_score）
             #⭐️①在类方法内部，可以直接使用 “cls.类属性名/类方法名” 访问  类属性  或  调用类方法（②在类方法外部，通过 "类名.属性名" 调用类属性；eg：Game.top_score）

        def  start_game（self）：
              print（"玩家［%s］开始游戏" % self.player_name）

               #使用“类名.”修改历史最高分
               Game.top_score=999

#1.查看游戏帮助
Game.show_help（）
#2.查看游戏最高分
Game.show_top_score（）
#3.创建游戏对象，开始游戏
game＝Game（"小明"）
game.start_game（）
#4.游戏结束，查看游戏最高分
Game.show_top_score（）