录：

面向对象编程，类的定义，类的属性，类方法，__init__ 初始化魔法方法

面向对象编程

面向对象(object-oriented ;简称: OO) 至今还没有统一的概念 我这里把它定义为: 按人们 认识客观世界的系统思维方式,采用基于对象(实体) 的概念建立模型,模拟客观世界分析、设计、实现软件的办法。

# **程序是由数据和功能组合而成的对象构建起来的**

面向对象编程(Object Oriented Programming-OOP) 是一种解决软件复用的设计和编程方法。 这种方法把软件系统中相近相似的操作逻辑和操作应用数据、状态,以类的型式描述出来,

# 以对象实例的形式在软件系统中复用,以达到提高软件开发效率的作用。

• 面向过程 VS. 面向对象

面向过程：根据业务逻辑从上到下写代码，
面向对象：对数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程

- 面向对象和面向过程都是解决问题的一种思路而已

  - 当遇到一个需求的时候不用自己去实现，如果自己一步步实现那就是面向过程
  - 应该找一个专门做这个事的人来做
  - 面向对象是基于面向过程的

如何将面对对象带入到编程中去？----通过class 类

类的定义

• 类基本概念及理解

类是对象的抽象化，类是一群具有相同特征或行为的事物的统称。（如人类）

• 类的定义的格式

class 类名():
    pass

• 类的命名规则：

驼峰命名法（首字母大写）
只能是一个词，不能有空格。
只能包含字母、数字、和下划线。
不能以数字开头。
不可以使用关键字(重名) 例如int，class
取名尽量有意义---见名思意

• 调用：类的实例化

class Person():
    pass

# 调用：类的实例化
wum = Person()  # wum是Person类的一个实例对象
mar = Person()  # 同上

• 类的构成：属性及方法

类可以看作是独立存放【属性及方法】的空间。
类就像人拥有其独特的特性（属性）以及行动（方法）

• 类与实例之间的联系

类是一个事物的抽象，不是真实存在的，描绘了事物的共性
实例：某类事物的具体个体，是该类事物的具体表现，真实存在

实例是存放变量的空间，不同实例之间互不可见，即互不影响
***实例对象可以获得类中所有的属性及方法***
  在查找属性时，会优先在实例中查找，然后在类中查找

类的属性----共有属性 和 私有属性

• 可以通过dir()查看类的内置属性、内置方法、内置函数

• 共有属性----可直接访问、修改

共有属性前没有下划线，实例可以直接访问，也可以修改

• 私有属性分两类：

属性前加'_'一个下划线，外部可以直接访问
属性前加'__'两个下划线，外部不可以直接访问，因为访问名称改变了，可以通过dir()查看
私有属性可以更好的保存属性安全，即不能随意修改

# 私有属性是一种规范，并非限制，因此可以通过特定的方法访问私有属性
# 定义在类中的私有属性也可以被子类（实例对象）继承

_ 和 __这是一种规范（约定）， 没有真正的限制作用，因此仍可以访问前面有两条下划线的私有属性。

访问两条下划线的私有属性的方法：_类名+__私有属性名（例如：_Person__age）

• 实例对象类属性的添加

class Person():
    name = '小明'

xiaoming = Person()
xiaoming.age = 18     #给xiaoming这个实例对象添加age属性，而Person类是没有age这个属性的
print(xiaoming.age)

18

类方法

类方法就是针对 类对象定义的方法；如果类是人类，那么类方法可以理解为是人类的行动

• 定义类方法的格式：通常将默认传入方法名后的参数命名为self

self代表实例对象本身

方法总是定义在类中，但是却叫实例方法，因为它表示该类所有实例共有的行为

class Person():

def 方法名(self): #定义类方法一定要在类中，因此要注意左边缩进

pass

• 调用类方法

通过实例对象调用

__init__ 初始化魔法方法

定义和用途

#定义：

所谓魔法方法，就是在特定条件下，自动触发方法。

__init__魔法方法则是在实例化后自动调用，以完成实例初始化。

#用途：

该函数可用于解决：每一个实例化对象需要不同的属性

**初始化的定义必须在类的开头**

在初始化定义时：

1.多个属性的值可以在实例对象调用时传入

2.可以固定属性的值

3.可以修改固定属性的值

#定义类
class Person():
    def __init__(self,num,name):
        self.age = num    

        self.gender = '男'      
#固定属性的值，即所有实例对象都有gender属性值（'男'），若要修改可以在实例对象调用时直接改

        self.name = name     
        

#调用实例
xiaoming = Person(8,'小明')
print(xiaoming.age)    
print(xiaoming.name)       
print(xiaoming.gender)

h = Person(50,'h')
print(h.gender)

xiaohua = Person(18,'小花')
xiaohua.gender = '女'           #将xiaohua这个实例对象的gender从 '男' 改成 '女'
print(xiaohua.gender)

8

小明

男

男 -------h.gender

女--------xiaohua.gender

私有属性调用方式：

1.调用私有属性方式：_类名__属性名

2.在方法中调用私有属性，在外部调用时可以直接调取

3.可以定义一个方法，专门返回私有属性，这样在外部调用该方法时，可以直接调用私有属性

4.可以定义一个方法，专门返回改变后的属性，再用返回私有属性方法，打印改变后的属性

5.最后返回的结果和定义时的函数顺序无关，和调用实例对象时的代码顺序有关

class Person():
    def __init__(self,name):
        self.__name = name      #__name是私有属性

    def eat(self):
        print(f'{self.__name}吃饭')      
#在方法中调用私有属性，在外部可以直接调用该方法获得私有属性

    def to(self):                #查找返回私有属性
        return self.__name

    def set_name(self,newname):      #修改私有属性
        self.__name = newname

xiaoming = Person('小明')
xiaoming.eat()              #调用eat方法，可以直接调用私有属性name
print(xiaoming.to())        #查找修改前的私有属性name
xiaoming.set_name('hhh')    #调用set_name方法，修改私有属性name的值为'hhh'
print(xiaoming.to())        #查找修改后的私有属性name

#最后返回的结果和定义时的函数顺序无关，和调用实例对象的代码顺序有关，
因此虽然在定义方法时，to查找方法在set_name修改方法之前，但是他们的定义顺序和最后输出的
结果无关，只要在调用方法时注意他们的先后顺序就能输出想要的结果（修改前或修改后的私有属性）

小明吃饭

小明 ----修改前的私有属性

hhh ----修改后的私有属性

建Web游戏

今天小编教大家如何用Python编程语言创建Web游戏，如果你能完成，你就可以算是一个能力相当不错的Python初学者了。虽然还需要多读一些书，多写一些程序，不过你已经具备进一步学习的功底了。接下来的学习就只是时间、动力及资源的问题了。

在这个习题中，我们不会去创建一个完整的游戏，相反，我们会为习题42中的游戏创建一个“引擎”（engine），让这个游戏能够在浏览器中运行起来。这会涉及重构习题42中的游戏，混合习题47中的结构，添加自动测试代码，最后创建一个可以运行这个游戏的Web引擎。

这是一个很庞大的习题。预计你要花一周到一个月才能完成。最好的方法是一点一点来，每晚完成一点，在进行下一步之前确认上一步已经正确完成。

重构习题43中的游戏

你已经在两个习题中修改了gothonweb项目，这个习题中会再修改一次。你学习的这种修改的技术叫做“重构”，或者用我喜欢的讲法来说，叫“修理”。重构是一个编程术语，它指的是清理旧代码或者为旧代码添加新功能的过程。你其实已经做过这样的事情了，只不过不知道这个术语而已。重构是软件开发中经历的最习以为常的事情。

在这个习题中你要做的是将习题47中的可以测试的房间地图和习题43中的游戏这两样东西合并到一起，创建一个新的游戏结构。游戏的内容不会发生变化，只不过我们会通过“重构”让它有一个更好的结构而已。

第一步是将ex47/game.py的内容复制到gothonweb/map.py中，然后将tests/ex47_tests.py的内容复制到tests/map_tests.py中，然后再次运行nosetests，确认它们还能正常工作。

注意

从现在开始，我不会再展示运行测试的输出了，我假设你会回去运行这些测试，而且知道什么样的输出是正确的。

将习题47的代码复制完毕后，就该开始重构它，让它包含习题43中的地图。我一开始会把基本结构为你准备好，然后你需要去完成map.py和map_tests.py里边的内容。

首先要做的是用Room这个类来构建地图的基本结构。

map.py

1  class Room(object):
2  
3      def __init__(self, name, description):
4          self.name = name
5          self.description = description
6          self.paths = []
7  
8      def go(self, direction):
9           return self.paths.get(direction, None)
10  
11      def add_paths(self, paths):
12           self.paths.update(paths)
13  
14  
15  central_corridor = Room("Central Corridor",
16  """
17  The Gothons of Planet Percal #25 have invaded your ship and destroyed
18  your entire crew.  You are the last surviving member and your last
19  mission is to get the neutron destruct bomb from the Weapons Armory,
20  put it in the bridge, and blow the ship up after getting into an 
21  escape pod.
22  
23  You're running down the central corridor to the Weapons Armory when
24  a Gothon jumps out, red scaly skin, dark grimy teeth, and evil clown costume
25  flowing around his hate filled body.  He's blocking the door to the
26  Armory and about to pull a weapon to blast you.
27  """)
28  
29  
30  laser_weapon_armory = Room("Laser Weapon Armory",
31  """
32  Lucky for you they made you learn Gothon insults in the academy.
33  You tell the one Gothon joke you know:
34  Lbhe zbgure vf fb sng, jura fur fvgf nebhaq gur ubhfr, fur fvgf nebhaq gur ubhfr.
35  The Gothon stops, tries not to laugh, then busts out laughing and can't move.
36  While he's laughing you run up and shoot him square in the head
37  putting him down, then jump through the Weapon Armory door.
38  
39  You do a dive roll into the Weapon Armory, crouch and scan the room
40  for more Gothons that might be hiding.  It's dead quiet, too quiet.
41  You stand up and run to the far side of the room and find the
42  neutron bomb in its container.  There's a keypad lock on the box
43  and you need the code to get the bomb out.  If you get the code
44  wrong 10 times then the lock closes forever and you can't
45  get the bomb.  The code is 3 digits.
46  """)
47  
48  
49  the_bridge = Room("The Bridge",
50  """
51  The container clicks open and the seal breaks, letting gas out.
52  You grab the neutron bomb and run as fast as you can to the
53  bridge where you must place it in the right spot.
54  
55  You burst onto the Bridge with the netron destruct bomb
56  under your arm and surprise 5 Gothons who are trying to
57  take control of the ship.  Each of them has an even uglier
58  clown costume than the last.  They haven't pulled their
59  weapons out yet, as they see the active bomb under your
60  arm and don't want to set it off.
61  """)
62  
63  
64  escape_pod = Room("Escape Pod",
65  """
66  You point your blaster at the bomb under your arm
67  and the Gothons put their hands up and start to sweat.
68  You inch backward to the door, open it, and then carefully
69  place the bomb on the floor, pointing your blaster at it.
70  You then jump back through the door, punch the close button
71  and blast the lock so the Gothons can't get out.
72  Now that the bomb is placed you run to the escape pod to
73  get off this tin can.
74  
75  You rush through the ship desperately trying to make it to
76  the escape pod before the whole ship explodes.  It seems like
77  hardly any Gothons are on the ship, so your run is clear of
78  interference.  You get to the chamber with the escape pods, and
79  now need to pick one to take.  Some of them could be damaged
80  but you don't have time to look.  There's 5 pods, which one
81  do you take?
82  """)
83  
84  
85  the_end_winner = Room("The End",
86  """
87  You jump into pod 2 and hit the eject button.
88  The pod easily slides out into space heading to
89  the planet below.  As it flies to the planet, you look
90  back and see your ship implode then explode like a
91  bright star, taking out the Gothon ship at the same
92  time.  You won!
93  """)
94  
95  
96  the_end_loser = Room("The End",
97  """
98  You jump into a random pod and hit the eject button.
99  The pod escapes out into the void of space, then
100  implodes as the hull ruptures, crushing your body
101  into jam jelly.
102  """
103  )
104  
105  escape_pod.add_paths({
106      '2': the_end_winner,
107      '*': the_end_loser
108  })
109  
110  generic_death = Room("death", "You died.")
111  
112  the_bridge.add_paths({
113      'throw the bomb': generic_death,
114      'slowly place the bomb': escape_pod
115  })
116  
117  laser_weapon_armory.add_paths({
118      '0132': the_bridge,
119      '*': generic_death
120  })
121  
122  central_corridor.add_paths({
123      'shoot!': generic_death,
124      'dodge!': generic_death,
125      'tell a joke': laser_weapon_armory
126  })
127  
128  START = central_corridor

你会发现Room类和地图有一些问题。

1．我们必须把以前放在if-else结构中的房间描述做成每个房间的一部分。这样房间的次序就不会被打乱了，这对我们的游戏是一件好事。这是你后面要修改的东西。

2．原版游戏中我们使用了专门的代码来生成一些内容，如炸弹的激活键码、舰舱的选择等，这次我们做游戏时就先使用默认值好了，不过后面的附加练习里，我会要求你把这些功能再加到游戏中。

3．我为游戏中所有错误决策的失败结尾写了一个generic_death，你需要去补全这个函数。你需要把原版游戏中所有的场景结局都加进去，并确保代码能正确运行。

4．我添加了一种新的转换模式，以"*"为标记，用来在游戏引擎中实现“捕获所有操作”的功能。

等把上面的代码基本写好以后，接下来就是你必须继续写的自动测试tests/map_test.py了。

map_tests.py

1  from nose.tools import *
2  from gothonweb.map import *
3  
4  def test_room():
5       gold = Room("GoldRoom", 
6                      """This room has gold in it you can grab. There's a
7                      door to the north.""")
8       assert_equal(gold.name, "GoldRoom")
9       assert_equal(gold.paths, {})
10  
11  def test_room_paths():
12      center = Room("Center", "Test room in the center.")
13      north = Room("North", "Test room in the north.")
14      south = Room("South", "Test room in the south.")
15  
16      center.add_paths({'north': north, 'south': south})
17      assert_equal(center.go('north'), north)
18      assert_equal(center.go('south'), south)
19  
20  def test_map():
21      start = Room("Start", "You can go west and down a hole.")
22      west = Room("Trees", "There are trees here, you can go east.")
23      down = Room("Dungeon", "It's dark down here, you can go up.")
24  
25      start.add_paths({'west': west, 'down': down})
26      west.add_paths({'east': start})
27      down.add_paths({'up': start})
28  
29      assert_equal(start.go('west'), west)
30      assert_equal(start.go('west').go('east'), start)
31      assert_equal(start.go('down').go('up'), start)
32  
33  def test_gothon_game_map():
34      assert_equal(START.go('shoot!'), generic_death)
35      assert_equal(START.go('dodge!'), generic_death)
36  
37      room = START.go('tell a joke')
38      assert_equal(room, laser_weapon_armory)

你在这个习题中的任务是完成地图，并且让自动测试可以完整地检查整个地图。这包括将所有的generic_death对象修正为游戏中实际的失败结尾。让你的代码成功运行起来，并让你的测试越全面越好。后面我们会对地图做一些修改，到时候这些测试将用来确保修改后的代码还可以正常工作。

会话和用户跟踪

在Web应用程序运行的某个位置，你需要追踪一些信息，并将这些信息和用户的浏览器关联起来。在HTTP协议的框架中，Web环境是“无状态”的，这意味着你的每一次请求和你的其他请求都是相互独立的。如果你请求了页面A，输入了一些数据，然后点了一个页面B的链接，那你发送给页面A的数据就全部消失了。

解决这个问题的方法是为Web应用程序建立一个很小的数据存储，给每个浏览器进程赋予一个独一无二的数字，用来跟踪浏览器所做的事情。这个存储通常用数据库或者存储在磁盘上的文件来实现。在lpthw.web这个小框架中实现这样的功能是很容易的，下面就是一个这样的例子。

session.sample.py

1  import web
2  
3  web.config.debug = False
4  
5  urls = (
6        "/count", "count",
7        "/reset", "reset"
8  )
9  app = web.application(urls, locals())
10  store = web.session.DiskStore('sessions')
11  session = web.session.Session(app, store, initializer=['count': 0])
12  
13  class count:
14       def GET(self):
15            session.count += 1
16            return str(session.count)
17  
18  class reset:
19       def GET(self):
20            session.kill()
21            return ""
22  
23  if __name__ == "__main__":
24      app.run()

为了实现这个功能，需要创建一个sessions/文件夹作为程序的会话存储位置，创建好以后运行这个程序，然后检查/count页面，刷新一下这个页面，看计数会不会累加上去。关掉浏览器后，程序就会“忘掉”之前的位置，这也是我们的游戏所需的功能。有一种方法可以让浏览器永远记住一些信息，不过这会让测试和开发变得更难。如果你回到/reset页面，然后再访问/count页面，你可以看到你的计数器被重置了，因为你已经关掉了这个会话。

你需要花点时间弄懂这段代码，注意会话开始时count的值是如何设为0的，另外再看看sessions/下面的文件，看能不能打开。下面是我打开一个Python会话并解码的过程：

>>> import pickle
>>> import base64
>>> base64.b64decode(open("sessions/XXXXX").read())
"(dp1\nS'count'\np2\nI1\nsS'ip'\np3\nV127.0.0.1\np4\nsS'session_id'\np5\nS'XXXX'\np6\ns."
>>>
>>> x = base64.b64decode(open("sessions/XXXXX").read())
>>>
>>> pickle.loads(x)
{'count': 1, 'ip': u'127.0.0.1', 'session_id': 'XXXXX'}

所以，会话其实就是使用pickle和base64这些库写到磁盘上的字典。存储和管理会话的方法很多，大概和Python的Web框架那么多，所以了解它们的工作原理并不是很重要。当然如果你需要调试或者清空会话，知道点儿原理还是有用的。

创建引擎

你应该已经写好了游戏地图和它的单元测试代码。现在要你制作一个简单的游戏引擎，用来让游戏中的各个房间运转起来，从玩家收集输入，并且记住玩家所在的位置。我们将用到你刚学过的会话来制作一个简单的引擎，让它可以：

1．为新用户启动新的游戏；

2．将房间展示给用户；

3．接收用户的输入；

4．在游戏中处理用户的输入；

5．显示游戏的结果，继续游戏，直到玩家角色死亡为止。

为了创建这个引擎，你需要将bin/app.py搬过来，创建一个功能完备的、基于会话的游戏引擎。这里的难点是，我会先使用基本的HTML文件创建一个非常简单的版本，接下来将由你完成它。基本的引擎是下面这个样子的：

app.py

1  import web
2  from gothonweb import map
3  
4  urls = (
5      '/game', 'GameEngine',
6      '/', 'Index',
7  )
8  
9  app = web.application(urls, globals())
10  
11  # little hack so that debug mode works with sessions
12  if web.config.get('_session') is None:
13        store = web.session.DiskStore('sessions')
14        session = web.session.Session(app, store,
15                                            initializer=['room': None])
16      web.config._session = session
17  else:
18       session = web.config._session
19  
20  render = web.template.render('templates/', base="layout")
21  
22  
23  class Index(object):
24       def GET(self):
25          # this is used to "setup" the session with starting values
26          session.room = map.START
27          web.seeother("/game")
28  
29  
30  class GameEngine(object):
31  
32      def GET(self):
33           if session.room:
34                return render.show_room(room=session.room)
35           else:
36              # why is there here? do you need it?
37              return render.you_died()
38  
39      def POST(self):
40           form = web.input(action=None)
41  
42          # there is a bug here, can you fix it?
43          if session.room and form.action:
44               session.room = session.room.go(form.action)
45  
46          web.seeother("/game")
47  
48  if __name__ == "__main__":
49      app.run()

在这个脚本里你可以看到更多的新东西，不过了不起的事情是，整个基于网页的游戏引擎只要一个小文件就可以做到了。这段脚本里最有技术含量的就是将会话带回来的那几行，这对于调试模式下的代码重载是必需的，否则每次刷新网页，会话就会消失，游戏也不会再继续了。

在运行bin/app.py之前，你需要修改PYTHONPATH环境变量。不知道什么是环境变量？要运行一个最基本的Python程序，你就得学会环境变量，用Python的人就喜欢这样：

在终端输入下面的内容：

export PYTHONPATH=$PYTHONPATH:.

如果用的是Windows，那就在PowerShell中输入以下内容：

$env:PYTHONPATH = "$env:PYTHONPATH;."

你只要针对每一个shell会话输入一次就可以了，不过如果你运行Python代码时看到了导入错误，那就需要去执行一下上面的命令，或者是因为你上次执行的有错才导致导入错误的。

接下来需要删掉templates/hello_form.html和templates/index.html，然后重新创建上面代码中提到的两个模板。下面是一个非常简单的templates/show_room.html，供你参考。

show_room.html

$def with (room)

<h1> $room.name </h1>

<pre>
$room.description
</pre>

$if room.name == "death":
    <p><a href="/">Play Again?</a></p>
$else:
    <p>
    <form action="/game" method="POST">
        - <input type="text" name="action"> <input type="SUBMIT">
    </form>
    </p>

这就用来显示游戏中的房间的模板。接下来，你需要在用户跑到地图的边界时，用一个模板告诉用户，他的角色的死亡信息，也就是templates/you_died.html这个模板。

you_died.html

<h1>You Died!</h1>

<p>Looks like you bit the dust.</p>
<p><a href="/">Play Again</a></p>

准备好这些文件就可以做下面的事情了。

1．再次运行测试代码tests/app_tests.py，这样就可以测试这个游戏。由于会话的存在，你可能顶多只能实现几次点击，不过你应该可以做出一些基本的测试来。

2．删除sessions/*下的文件，再重新运行一遍游戏，确认游戏是从一开始运行的。

3． 运行python bin/app.py脚本，试玩一下你的游戏。

你需要和往常一样刷新和修正你的游戏，慢慢修改游戏的HTML文件和引擎，直到实现游戏需要的所有功能为止。

期末考试

你有没有觉得我一下子给了你超多的信息呢？那就对了，我想要你在学习技能的同时有一些可以用来鼓捣的东西。为了完成这个习题，我将给你最后一套需要你自己完成的练习。你会注意到，到目前为止你写的游戏并不是很好，这只是你的第一版代码而已，你现在的任务就是让游戏更加完善，实现下面的这些功能。

1．修正代码中所有我提到和没提到的bug，如果你发现了新bug，你可以告诉我。

2．改进所有的自动测试，以便可以测试更多的内容，直到你可以不用浏览器就能测到所有的内容为止。

3．让HTML页面看上去更美观一些。

4．研究一下网页登录系统，为这个程序创建一个登录界面，这样人们就可以登录这个游戏，并且可以保存游戏高分。

5．完成游戏地图，尽可能地把游戏做大，功能做全。

6．给用户一个“帮助系统”，让他们可以查询每个房间里可以执行哪些命令。

7．为游戏添加新功能，想到什么功能就添加什么功能。

8．创建多个地图，让用户可以选择他们想要玩的一张地图来进行游戏。你的bin/app.py应该可以运行提供给它的任意地图，这样你的引擎就可以支持多个不同的游戏。

9．最后，使用在习题48和习题49中学到的东西创建一个更好的输入处理器。你手头已经有了大部分必要的代码，只需要改进语法，让它和你的输入表单以及游戏引擎挂钩即可。

祝你好运！

常见问题回答

我在游戏中用了会话（`session）`，不能用nosetests测试。

你需要阅读并了解带reloader的会话：http://webpy.org/cookbook/session_with_reloader。

我看到了ImportError。

错误路径，错误Python版本，PYTHONPATH没设置对，漏了__init__.py文件，拼写错误，都检查一下吧。

头条创作挑战赛#

在Python中，class是一种用于创建对象的蓝图或模板。它定义了一组属性和方法，用于描述对象的行为和状态。通过定义一个class，您可以创建多个具有相同属性和方法的对象。

以下是关于Python中的class的详细讲解：

定义一个class: 使用 class 关键字来定义一个class，并指定class的名称。类名通常使用首字母大写的驼峰命名法。

class MyClass:

# 类的定义

pass

实例化对象: 通过调用类来创建对象的过程称为实例化。实例化一个类会调用类的 __init__ 方法，对对象进行初始化。

obj = MyClass() # 创建一个MyClass的对象 obj

构造方法: 构造方法（ __init__ ）是在实例化对象时自动调用的特殊方法。它用于初始化对象的属性。

class MyClass:

def __init__(self, arg1, arg2):

self.arg1 = arg1

self.arg2 = arg2

实例属性和方法: 类定义中定义的属性和方法称为实例属性和实例方法。实例属性是每个对象特有的属性，可以通过 self 关键字来访问。实例方法是与实例对象相关联的函数，可以通过实例对象进行调用。

class MyClass:

def __init__(self, arg1):

self.arg1 = arg1

def instance_method(self):

print(self.arg1)

obj = MyClass("Hello")

obj.instance_method() # 输出 "Hello"

类属性和类方法: 类属性是与类关联的属性，它们在所有实例之间共享。类属性可以直接通过类名访问。类方法是与类关联的方法，而不是实例，它可以访问类属性并进行操作。

class MyClass:

class_attr = "Hello"

@classmethod

def class_method(cls):

print(cls.class_attr)

MyClass.class_method() # 输出 "Hello"

继承: 继承是一种创建新类的方法，它通过继承现有类的属性和方法来扩展新类。子类继承父类的所有属性和方法，并可以添加新的属性和方法。

class ParentClass:

def parent_method(self):

print("Parent method")

class ChildClass(ParentClass):

def child_method(self):

print("Child method")

obj = ChildClass()

obj.parent_method() # 输出 "Parent method"

obj.child_method() # 输出 "Child method"

封装和访问控制: Python中没有严格的访问控制机制，但可以通过约定来实现封装。通常，私有属性和方法会用一个下划线开头 _ 表示，表示它们应该被视为私有的，并且不应该在类的外部直接访问。

class MyClass:

def __init__(self):

self._private_attr = "Private attribute"

def _private_method(self):

print("Private method")

def public_method(self):

print(self._private_attr)

self._private_method()

obj = MyClass()

obj.public_method() # 输出 "Private attribute" 和 "Private method"

这些是Python中class的基本概念和用法。通过使用class，可以更好地组织代码，提高代码的可读性和可维护性，使其更符合面向对象的编程范式。