42的练习

本办法在这章开始给我们普及概念了。

面向对象的编程，一定绕不开这几个概念：抽象、封装、类、实例、对象。

一句话可以概括下：对事物进行【抽象】，从而【封装】为【类】，由【类】可以生成【实例】或【对象】。

写成代码是什么 样 子
这个概念有点绕人，不过实话说，你只要在创建和使用 class 的时候操心一下就可以了。我来给你两个区分 Class 和 Object 的小技巧。
首先针对类和对象，你需要学会两个说法，“ is-a( 是啥 )” 和“ has-a( 有啥 )” 。“是啥”要用在谈论“两者以类的关系互相关联”的时候，而“有啥”要用在“两者无共同点，仅是互为参照”的时候。接下来，通读这段代码，将每一个注解为 ##?? 的位置标明他是“ is-a” 还是“ has-a” 的关系，并讲明白这个关系是什么。在代码的开始我还举了几个例子，所以你只要写剩下的就可以了。
记住，“是啥”指的是鱼和泥鳅的关系，而“有啥”指的是泥鳅和鳃的关系。
（译注：为了解释方便，译文使用了中文鱼名。原文使用的是“三文鱼 (salmon)” 和“大比目鱼(halibut)” ，名字也是英文常用人名。）

加分习题

1. 研究一下为什么 Python 添加了这个奇怪的叫做 object 的 class ，它究竟有什么含义呢？
   **这个是python独有的，开始设计语言时，没有考虑周全。

2. 有没有办法把 Class 当作 Object 使用呢？
   **这个还真不清楚， 没完全理解

3. 在习题中为 animals 、 fish 、还有 people 添加一些函数，让它们做一些事情。看看当函数在Animal 这样的“基类 (base class)” 里和在 Dog 里有什么区别。
   **

4. 找些别人的代码，理清里边的“是啥”和“有啥”的关系。
   **是啥”指的是鱼和泥鳅的关系(从属)，而“有啥”指的是泥鳅和鳃的关系（含有）

5. 使用列表和字典创建一些新的一对应多的“ has-many” 的关系。

6. 你认为会有一种“ has-many” 的关系吗？阅读一下关于“多重继承 (multiple inheritance)” 的资料，然后尽量避免这种用法。

常见 问题回答
这些 ## ?? 注解是干嘛用的？
这些注解是供你填空的。你应该在对应的位置填入“ is-a” 、“ has-a” 的概念。重读这节习题，看看其它的注解，仔细理解一下我的意思。

这句 self.pet = None 有什么用？
确保类的 self.pet 属性被设置为 None 。
super(Employee, self).init(name) 是做什么用的？
这样你可以可靠地将父类的 init 方法运行起来。搜索“ python super” ，看看它的优缺点。

43的练习

代码

import random#引入随机
from urllib.request import urlopen #从urllib进口urlopen
import sys

WORD_URL = "http://learncodethehardway.org/words.txt"
WORDS = []

PHRASES = {
    "class ###(###):":
        "Make a class named ### that is-a ###.",
    "class ###(object):\n\tdef __init__(self,***)":
      "class ###has-a __init__ that takes self and *** paramaters.",#类# # # has-a __init__以自我和***参数。”，
    "class ###(object):\n\tdef ***(self,@@@)":
      "class ### has-a function named *** that takes self and @@@ paramaters.",#类# # # has-a函数命名为***，以自我和@ @ @参数。
    "*** = ###()":
      "Set *** to an instance of class ###.",#设置***一类的实例# # #
    "***.###(@@@)":
      "From *** get the *** function, and call it with paramaters self, @@@.",#从***的***功能，并调用它的参数自，@ @ @
    "***.*** = '***'":
      "From *** get the *** attribute and set it to '***'."#从***获取***属性并将其设置为**
}

# do they want to drill phrases first #他们想操练短语第一
PHRASES_FIRST = False
if len(sys.argv) == 2 and sys.argv[1] == "english":
    PHRASES_FIRST = True

# load up the words from the website #把词从网站载入
for word in urlopen(WORD_URL).readlines():
    WORDS.append(word.strip())

def convert(snippet, phrase):
    class_names = [w.capitalize() for w in
                   random.sample(WORDS, snippet.count("###"))]
    other_names = random.sample(WORDS, snippet.count('***'))
    rssults = []
    param_names = []

    for i in range(0, snippet.count('@@@')):
        param_count = random.randint(1,3)
        param_names.append(', '.join(random.sample(WORDS, param_count)))

    for sentence in snippet, phrase:#对于片段中的句子，短语
        result = sentence[:]

        # fake class names #假类名称
        for word in class_names:
            result = result.replace('###', word, 1)

        # fake other names
        for word in other_names:
            result = result.replace('***', word, 1)

        # fake parameter lists #伪造参数列表
        for word in param_names:
            result = result.replace('@@@', word, 1)

        results.append(result)

        return results

    # keep going until they hit CTRL-D
    try:
        while True:
            snippets = PHRASES.keys()
            random.shuffle(snippets)

            for snippet in snippets:
                phrase = PHRASES[snippet]
                question, answer = convert(snippet, phrase)
                if PHRASE_FIRST:
                    question, answer = answer, question

                print(question)

                input("> ")
                print("ANSWER:  %s\n\n" % answer)
    except EOFError:
        print（"\nBye"）

没有运行出来，这个很模糊

ex44

隐 式继承（Implicit Inheritance ）

首先我将向你展示当你在父类里定义了一个函数，但没有在子类中定义的例子，这时候会发生隐式继承。

class Parent(object):
def implicit(self):
print "PARENT implicit()"
class Child(Parent):
pass

dad = Parent()
son = Child()
dad.implicit()
son.implicit()
class Child: 中的 pass 是在 Python 中创建空的代码区块的方法。这样就创建了一个叫 Child 的
类，但没有在里边定义任何细节。在这里它将会从它的父类中继承所有的行为。运行起来就是这样：
PARENT implicit()
PARENT implicit()
就算我在第 16 行调用了 son.implicit() 而且就算 Child 中没有定义过 implicit 这个函数，这
个函数依然可以工作，而且和在父类 Parent 中定义的行为一样。这就说明，如果你将函数放到基类中
（也就是这里的 Parent ），那么所有的子类（也就是 Child 这样的类）将会自动获得这些函数功能。
如果你需要很多类的时候，这样可以让你避免重复写很多代码。

显 式 覆 写（Explicit Override ）

有时候你需要让子类里的函数有一个不同的行为，这种情况下隐式继承是做不到的，而你需要覆写子类
中的函数，从而实现它的新功能。你只要在子类 Child 中定义一个相同名称的函数就可以了，如下所示：
class Parent(object):
def override(self):
print "PARENT override()"
class Child(Parent):
def override(self):
print "CHILD override()"
dad = Parent()
son = Child()
dad.override()
son.override()
这里我在两个类中都定义了一个叫 override 的函数，我们看看运行时会出现什么情况。
PARENT override()
CHILD override()
如你所见，运行到第 14 行时，这里执行的是 Parent.override ，因为 dad 这个变量是定义在 Parent
里的。不过到了第 15 行打印出来的却是 Child.override 里的信息，因为 son 是 Child 的一个实例，
而子类中新定义的函数在这里取代了父类里的函数。
现在来休息一下并巩固一下这两个概念，然后我们接着进行。

super() 和 init 搭 配 使用

最常见的 super() 的用法是在基类的 init 函数中使用。通常这也是唯一可以进行这种操作的地方，
在这里你在子类里做了一些事情，然后完成对父类的初始化。这里是一个在 Child 中完成上述行为的例
子：
class Child(Parent):
def init(self, stuff):
self.stuff = stuff
super(Child, self).init()
这和上面的 Child.altered 差别不大，只不过我在 init 里边先设了个变量，然后才用
Parent.init 初始化了 Parent

45

这个，无从下手，捉急！

7月30日听课

split函数

昨晚听，其实没太明白，今天百度补充。

Python split()方法

Python 字符串

Python 字符串
描述
Python split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串
语法
split()方法语法：
str.split(str="", num=string.count(str)).
参数
str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num -- 分割次数。

返回值
返回分割后的字符串列表。
实例
以下实例展示了split()函数的使用方法：

!/usr/bin/pythonstr = "Line1-abcdef \nLine2-abc \nLine4-abcd";print str.split( );print str.split(' ', 1 );

以上实例输出结果如下：
['Line1-abcdef', 'Line2-abc', 'Line4-abcd']['Line1-abcdef', '\nLine2-abc \nLine4-abcd']