“笨办法”学Python 3 ——练习 40. 模块、类和对象

练习40 模块、类和对象

知识点：

40.1.0 模块就像字典

my_stuff['apple'] #my_stuff是字典，访问字典apple键的值
import mystuff
mystuff.apple() #mystuff是模块，模块访问函数apple()
print(mystuff.tangerine) #模块访问变量tangerine

说明Python 中有一个非常通用的模式：
（1）用一个键=值（key=value）形式的容器。
（2）通过键的名称来从中获取内容。
（3）在字典中，键是一个字符串，语法是：[key]。而在模块中，键是一个识别符，语法是 .key，除此之外它们几乎是同一种东西。
—————————————————————————————————————————

40.1.1 类就像模块

类：类是一种整合一组函数和数据的方式，它将函数和数据放在一个容器内以便通过 . 运算符进行访问。类与模块功能相似，可以存储Python代码。但是类比模块更复杂，且在一个脚本程序中，模块就一个，而类可以复制很多。

语法：

class Name(object):
    def __init__(self,类属性1,类属性2, ......):
    	self.类属性1 = 属性1
    	self.类属性2 = 属性2
    	......
    def 函数1(self, 参数1，参数2)
    	内容
    .......

其中 init(self)函数：两个下划线开头的函数是声明该属性为私有，不能在类的外部被使用或访问；在python中我们可以使用__init__()方法来传递参数，比如赋值给对象属性等；__init__函数的第一个参数必须为self，后续参数为自己定义。

创建类，示例：

class Mystuff(object): #创建类，类名第一个字母大写

    def __init__(self): #函数__init__,初始化类
        self.tangerine = "And now a thousand years between"
    
    def apple(self): #创建函数apple
        print("I AM CLASSY APPLES!")

**注意：**创建类，一般都需要用到__init__(self)函数，主要原因：1.类会多次实例化，再调用前初始化。2.为了方便后面的创建实例的时候，给实例绑定上属性。 类的使用需要了解对象object。

40.1.2 对象就像import

类会有与模块中import类似的概念，被称为“实例化”或者“创造”，当类实例化后得到的东西叫做对象。实例化的方法就是像调用函数一样调用一个类，所有从类里面实例化出来的对象都具备这个类中提供的方法，python中调用一个类的时候，会以这个类为蓝本创建一个同类型的副本。

示例：

#输入
thing = Mystuff() #实例化类，对象thing,具有这个类的所有函数，变量等
thing.apple() #该对象可以调用类中包含的函数。
print(thing.tangerine) #该对象可以调用类中包含的变量。

#输出
And now a thousand years between

总结：
（1）类就像新的小型模块的蓝本，类在模块中创建。
（2）实例化就是如何创建这些小型模块并同时导入（调用）它们，即创建一个类的对象。
（3）所创建的小型模块的结果被称作对象，然后将它赋值给一个变量来使用（类似与import）。

40.1.3 获取数据

字典、模块以及类中获取其内容的方式总结如下：（不同的键值对）

#字典获取方式
mystuff['apples'] #通过键值对，访问内容

#模块获取方式
mystuff.apples() #mystuff是模块，模块.函数名访问内容
print(mystuff.tangerine) #模块.变量名访问内容

#类获取方式
thing = MyStuff() #创建一个空对象
thing.apples() #调用类中的函数
print(thing.tangerine) #调用类中的变量

40.1.4 第一个类的例子

源代码

class Song(object): #定义类Song

    def __init__(self, lyrics): #初始化，定义类的属性lyrics（抒情诗）
        self.lyrics = lyrics #实例的属性

    def sing_me_a_song(self): # 定义函数
        for line in self.lyrics:
            print(line)

#实例化对象happy_bday
happy_bday = Song(["Happy birthday to you",
                "I don't want to get sued",
                "So I'll stop right there"])

#实例化对象bulls_on_parade 
bulls_on_parade = Song(["They rally around the family",
                    "With pockets full of shells"])

happy_bday.sing_me_a_song() #调用类里面的函数sing_me_a_song()

bulls_on_parade.sing_me_a_song()#调用类里面的函数sing_me_a_song()

输出结果

Happy birthday to you
I don't want to get sued
So I'll stop right there
They rally around the family
With pockets full of shells

附加练习

1. 用这个方法再写一些歌，确保你明白你正在用字符列表来传歌词。
示例：

class Song(object): #定义类Song

    def __init__(self, lyrics): #初始化，定义类的属性lyrics（抒情诗）
        self.lyrics = lyrics #实例的属性

    def sing_me_a_song(self): # 定义函数
        for line in self.lyrics:
            print(line)

#附加练习，实例化对象happy
happy = Song(["When we are children",
        "The God told us",
        "when you feel happy",
        "Although you have nothing",
        "You also feel the world is very huge"])
    
#调用类的函数sing_me_a_song
happy.sing_me_a_song()

输出结果：

When we are children
The God told us
when you feel happy
Although you have nothing
You also feel the world is very huge

2. 把歌词放在一个单独的变量里，然后把这个变量放在类里面来使用。（将歌词变成单独的变量，传递给类使用）
示例：

#附加练习2，将歌词放入变量中。

#创建变量Sing_1为列表
Sing_1 = ["Happy birthday to you",
                "I don't want to get sued",
                "So I'll stop right there"]

#创建变量Sing_2为列表
Sing_2 = ["When we are children",
        "The God told us",
        "when you feel happy",
        "Although you have nothing",
        "You also feel the world is very huge"]

#创建对象F_Song,S_Song
F_Song = Song(Sing_1)
S_Song = Song(Sing_2)

#调用类中的函数
F_Song.sing_me_a_song()
S_Song.sing_me_a_song()

输出结果

Happy birthday to you
I don't want to get sued
So I'll stop right there
When we are children
The God told us
when you feel happy
Although you have nothing
You also feel the world is very huge

3.在网上搜搜“面向对象的编程”，然后填满你的大脑。别担心你看不懂，因为几乎一半的东西我也看不懂。
（1）面向对象编程：Object Oriented Programming，简称OOP，是一种程序设计方法。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的方法。Python就是一种面向对象的语言，支持面向对象编程，在其内部，一切都被视作对象。
（2）面向对象编程中，将函数和变量进一步封装成类，类才是程序的基本元素，它将数据和操作紧密地连结在一起，并保护数据不会被外界的函数意外地改变。类和和类的实例（也称对象）是面向对象的核心概念，是和面向过程编程、函数式编程的根本区别。
（3）类不同于函数，具有封装、继承和多态三大特点。一个类定义了具有相似性质的一组对象。而继承性是对具有层次关系的类的属性和操作进行共享的一种方式。继承将在后面学到。
（4）面向过程编程和面向对象编程的区别（简单例子），面向过程编程比面向对象编程更冗余。：
用函数进行面向过程编程：

def speak(animal):

    if animal == "狗":
        print("旺旺！")
    elif animal == "猫":
        print("喵！喵！")
    elif animal == "牛":
        print("哞！哞！")
    else:
        print("说人话！")

a, b, c, d = "猫", "狗", "牛", "二哈"

speak(a)
speak(b)
speak(c)
speak(d)

用面向对象编程如下：
用面向对象编程可以轻松的创建甚至几百万的对象。

# 先定义一个动物的类
class Animal:
    # 动物实例的初始化方法，需要提供动物类别和该类动物的叫声
    def __init__(self, kind, voice):
        self.kind = kind
        self.voice = voice
    # 让动物发出叫声的方法
    def speak(self):
        print(self.voice)

# 实例化四种动物对象
a = Animal("狗", "旺旺！")
b = Animal("猫", "喵！喵！")
c = Animal("牛", "哞！哞！")
d = Animal("二哈", "说人话！")

# 调用动物类的发声方法
a.speak()
b.speak()
c.speak()
d.speak()

常见问题

1. 为什么在类下面用 init 函数或者其他函数的时候要用 self ？ 如果不用 self，那么像 cheese = ‘Frank’ 这样的代码就会很含糊，计算机不知道你是指实例的 cheese 属性还是 一个叫做 cheese 的局部变量。而用 self.cheese = ‘Frank’ 的话就会很清晰，你是指实例的属性 self.cheese 。（self是为了表明实例）