14.笨方法学python 习题40

小鱼儿 2023-03-13 11:57 58阅读 0赞

Python是一种“面向对象编程语言”。这种说法的意思是，python里边有一种叫 类（class）的结构，通过它可以用一种特殊的方式构造软件。

### 模块和字典差不多 ###

你知道怎么创建和使用字典，如果你有一个字典，它里面有个叫’apple‘ 的键（key），而你要从中取值（value）的话，你需要像下面这样做。

mystuff = { 'apple': 'I AM AN APPLE'} 
       print(mystuff[ 'apple'])

记住这个 “从Y中获取X” 的概念，现在再来看看模块（module），你已经创建和使用一些模块了，已经了解了它们的一些属性。

*      1. 模块是包含函数和变量的Python文件
 *      2. 可以导入这个文件
 *      3. 然后可以使用 . 操作符访问模块中的函数和变量

假如说我有一个模块名称叫 mystuff.py，并且里边放了个叫 apple 的函数，就像下面这样。

# this goes in mystuff.py 
       def apple(): 
       print( 'I AM AN PAALE')

接下来就可以用 import 来调用这个模块，并且访问 apple 函数。如下：

import mystuff 
       mystuff.apple()

我还可以放一个叫 tangerine 的变量到模块里面。如下：

def apple(): 
       print( 'I AM AN APPLE') 
       
       #this is just a variable 
       tangerine = 'Living reflection of a dream'

同样，还是可以访问这个变量。

import mystuff 
       
       mystuff.apple() 
       print(mystuff.tangerine)

回到字典的概念，你会发现这和字典的使用方式有点相似，只不过语法不同而已。我们来比较一下：

mystuff[ 'apple'] # get apple from dict 
       mystuff.apple() # get apple from the module 
       mystuff.tangerine # get apple from the module,but it's just a variable

也就是说，Python里边有一个非常常用的模式：

*      1. 拿一个类似 “ 键 = 值 ” 风格的容器；
 *      2. 通过对 “键” 的名称获取其中的值；

模块和字典，除了语法，基本上就没有什么区别了。实际上它们是完全不同的东西，但是Zed到目前为止就是这么解释的。

--------------------

###  类和模块差不多 ###

你可以把模块当作一种专用的字典，你可以通过它存储一些python代码，并通过 “ **.** ”运算符访问这些代码。Python还有另外一种代码结构来实现类似的目的，那就是类。通过类，你可以把一组函数和数据放到一个容器内，从而使用 “ **.** ” 来访问它们。

如果要用创建 mystuff 模块的方法来创建一个类，那么大致方法是下面这样的：

class MyStuff(object): 
       
       def __init__(self): 
       self.tangerine = 'And now a thousand years between' 
       
       def apple(self): 
       print( 'I AM CLASS APPLES!')

和模块比起来可能有些复杂，不过你应该能大致看出来，这段代码差不多就是模拟了一个名字叫MyStuff 的迷你模块，里面有一个叫 apple() 的函数，难懂的恐怕就是 \_\_init\_\_() 这个函数，还有就是设置  tangerine 实例变量时用到的 self.dangerine。

使用类而非模块的原因如下：你可以那上面的这个MyStuff 类重复创建出很多出来，哪怕是100万个，它们也不会互相干涉。而对于模块来说，一次导入之后，整个程序例就只有这么一份内容。

不过在弄懂这个之前，你先要理解 “对象” （object）是什么东西，以及如何使用 MyStuff 达到类似 mystuff.py 模块的结果。

--------------------

### 对象和import差不多  ###

如果说类和迷你模块差不多，那么对于类来说，也必然有一个类似导入（import）的概念。这个概念就叫“实例化”（instantiate）。这只是一种故作高深的叫法而已，它的意思其实是“创建”。当你将一个类“实例化”以后，你得到的就叫“对象”（object）。

thing = MyStuff() 
       thing.apple() 
       print(thing.tangerine)

第一行代码就是“实例化”操作，这和调用函数很相似，下面我们针对上面的代码详细解释下Python的工作流程：↓

1. Python 查找MyStuff() 并且知道了它是你定义过的一个类。

2. Python 创建了一个空对象，里面包含了你在该类中用 def 指定的所有函数。

3. 然后Python 回去检查你是不是在里面创建了一个 \_\_init\_\_“魔法”函数，如果有创建，他就会调用这个函数，从而对你新创建的空对象实现了初始化。

4. 在MyStuff() 的 \_\_init\_\_ 函数里，有一个多余的函数叫 self ，这既是Python 为你创建的空对象，而你可以对它进行类似模块、字典等的操作，为它设置一些变量。

5. 在这里，我把 self.tangerine 设成了一点歌词，这样我就初始化了该对象。

6. 最后 Python 将这个新创建的对象赋给一个叫 thing 的变量，以供后面使用。

这就是当你像调用函数一样调用类的时候 Python 完成这个“迷你导入”的过程。记住这不是拿一个类来直接用，而是将类当作一个“蓝图”，然后用它创建和这个类有相同属性的副本。

--------------------

**如果还是看不懂，就往下翻，有一段我觉得讲的挺明白的详解，国人出品。**感觉Zed讲的不太清楚...可能是文化差异？？？

--------------------

### 获取某样东西里包含的东西 ###

现在有3种方法可以从某个东西里面获取东西：

'''字典类型''' 
       mystuff[ 'apples'] 
       
       '''模块类型''' 
       mystuff.apples() 
       print(mystuff.tangerine) 
       
       '''类 类型''' 
       thing = MyStuff() 
       thing.apples() 
       print(thing.tangerine)

--------------------

### 第一个类的例子 ###

class Song(object): 
       
       def __init__(self, lyrics): 
       self.lyrics = lyrics 
       
       def sing_me_a_song(self): 
       for line in self.lyrics: 
       print(line) 
       
       happy_bday = Song([ "Happy birthday to you", 
       "I don't want to get sued", 
       "So I'll stop right there"]) 
       
       bulls_on_parade = Song([ "They rally around the family", 
       "With pockets full of shells"]) 
       
       happy_bday.sing_me_a_song() 
       
       bulls_on_parade.sing_me_a_song()

### 结果：  ###

![70][]

--------------------

### 然后到底什么是对象？ ###

面向对象程序设计（Object-oriented programming，OOP）是一种程序设计范型，也是一种程序开发方法。对象指的是类的实例，类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫作类的实例化。面向对象程序设计将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。面向对象编程中的主要概念如下：

类（class）：

定义了一件事物的抽象特点。通常来说，类定义了事物的属性和它可以做到的行为。比如拿人来说，人类是一个类，黄种人、白种人和黑人；男人和女人，都具有人类的特征或行为，比如身高、体重、肤色、吃饭、睡觉、生老病死等等。一个类中可以有成员函数和成员变量。在面向对象的术语中，成员函数被称为方法；成员变量被称为属性。

对象（object）：

是类的实例。当一个类被实例化时，他的属性就有了具体的值（比如，人类是一个类，具体到某一个人的时候，他就有具体的身高、体重、肤色等）。每个类可以有若干个可以被实例化的对象。在操作系统中，系统给对象分配内存空间，而不会给类分配内存空间。

继承（inheritance）：

是指通过一个已有的类（父类）定义另外一个类（子类），子类共享父类开放的属性和方法。子类的对象除了是一个子类的一个实例，还是其父类的一个实例。举个例子：人类做为父类，实例化一个子类黄种人，黄种人（子类）实例化一个对象中国人。中国人除了是黄种人（子类）的一个实例，也是人类（父类）的一个实例。

封装性（Encapsulation）：

封装性是指类在定义时可以将不能活不需要其他类知道的成员定义成私有成员，而只公开其他类需要使用的成员，以达到信息隐蔽和简化的作用。比如：通过眼睛观察我们可以大概知道其他人的肤色、性别等等，但是比如血型、DNA等等是无法直接得知的。

多态性（Polymorphism）：

是指同一方法作用于不同的对象，可以有不同的解释，产生不同的执行结果。在具体实现方法上，多态性是允许开发者将父对象的变量设置为对子对象的引用，赋值之后，父对象变量就可以根据当前的赋值给他的子对象的特性以不同的方式运作。比如：黄种人和白种人还有黑种人都属于人类，但是其肤色属性是不一样的（赋值不同）。

随着面向对象编程（OPP）的普及，面向对象程序设计（OOD）也只日臻成熟，形成了以UML（Unified Modieling Language）为代表的标准建模语言。UML是一个支持模型化和软件系统开发的图形化语言，为软件开发的所有阶段提供了模型化和可视化支持，包括由需求分析到规格，再到构造和配置的所有阶段。

### END！！！ ###

[70]: /images/20230312/63be91fcd03e44b6aa272cbd17e604ad.png