笨办法41学会说面向对象【我有新书啦！！！

python3.7.0自带Urllib库，无需安装

class X(Y)：创建一个叫X的类，并继承Y

class X(object): def __init__(self, J)：类X有一个__init__方法，该方法有self和J两个参数

class X(object): def M(self, J)：类X有一个叫M的函数，该函数有self和J两个参数

foo = X()：给foo赋值为类X的一个实例

foo.M(J)：从foo里调用M函数，传递的参数为self和J

foo.K = Q：从foo里调用K属性，并将其设置为Q。

原文代码：

import random
from urllib.request import urlopen
import sys

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

PHRASES = {
    "class ###(###):":
        "创建一个叫###的类，并继承###.",
    "class ###(object):\n\tdef __init__(self, ***)":
        "类###有一个__init__方法，该方法有self和***两个参数.",
    "class ###(object):\n\tdef ***(self, @@@)":
        "类###有一个叫***的函数，该函数有self和@@@两个参数.",
    "*** = ###()":
        "给***赋值为类###的一个实例.",
    "***.***(@@@)":
        "从***里调用***函数，传递的参数为self和@@@.",
    "***.*** = '***'":
        "从***里调用***属性，并将其设置为***."
}

# do they want to drill phrases first           # 是否想先练习短语
if len(sys.argv) == 2 and sys.argv[1] == "english":
    PHRASE_FIRST = True                         # True表示先打印value
else:
    PHRASE_FIRST = False                        # False表示先打印key

# load up the words from the website            # 加载网站上的文字
for word in urlopen(WORD_URL).readlines():
    WORDS.append(str(word.strip(), encoding="utf-8"))   # 删除每一行开始和结尾的空格，只留下单词并加入到words列表中


def convert(snippet, phrase):                   # 传参
    class_names = [w.capitalize() for w in      # 从WORDS序列中随机取出1个单词首字母大写后赋值给class_names，此处假设为'Actor'
                   random.sample(WORDS, snippet.count("###"))]
    other_names = random.sample(WORDS, snippet.count("***"))    # 从WORDS序列中随机取出一个单词赋值给other_names，此处假设为'dinner'
    results = []
    param_names = []

    for i in range(0, snippet.count("@@@")):    # 只循环一次
        param_count = random.randint(1, 3)      # 假设随机到2
        param_names.append(', '.join(           # 从WORDS中随机取出2个单词用逗号和空格连接起来，放在param_names中，假设为'cook, donkey'
            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)      # 添加到results序列中

    return results


# keep going until they hit CTRL-D
try:
    while True:
        snippets = list(PHRASES.keys())     # 提取PHRASES中的键
        random.shuffle(snippets)            # 打乱snippets中元素（PHRASES中键）的顺序

        for snippet in snippets:            # 取一个键来操作，假设取到'class %%%(object):\n\tdef ***(self, @@@)'
            phrase = PHRASES[snippet]       # 取出值'class %%% has-a function named *** that takes self and @@@ parameters.'
            question, answer = convert(snippet, phrase)     # 去上面找定义的函数
            if PHRASE_FIRST:                # 先打印value，再打印key
                question, answer = answer, question

            print(question)

            input("> ")
            print(f"ANSWER:  {answer}\n\n")
except EOFError:
    print("\nBye")

流程图：

涉及的方法及函数：

strip（）方法：s为字符串，rm为要删除的字符序列
s.strip(rm)     删除s字符串中开头、结尾处，位于 rm删除序列的字符
s.lstrip(rm)     删除s字符串中开头处，位于 rm删除序列的字符
s.rstrip(rm)     删除s字符串中结尾处，位于 rm删除序列的字符

capitalize（）方法：将字符串的第一个字母变成大写,其他字母变小写。

函数原型：random.sample(sequence, k)
参数：sequence是一个list，k是一个整数
返回值：返回一个list，该list由sequence中随机的k个元素组成，sequence不变

函数原型：random.randint(a, b)
用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限

join() 方法：用于将序列中的元素以指定的字符连接生成一个新的字符串。
函数原型：str.join(sequence)        
参数sequence：要连接的元素序列（必须为字符，否则会报错）
参数str：连接元素的字符
返回值：返回通过str连接序列中元素后生成的字符串

函数原型：str.replace(old, new[, max])  
参数old：将被替换的子字符串
参数new：新字符串，用于替换old子字符串。 
参数max：可选字符串, 替换不超过 max 次
返回值：返回以new代替old不超过max次的新字符串

shuffle() 方法：将序列的所有元素随机排序
函数原型：random.shuffle(lst)
参数lst：可以是一个序列或者元组
返回值：None. 直接修改lst的顺序

函数原型：dict.keys()  
参数：None  
返回值：返回一个字典所有的键

标签：笨办法,self,random,41,面向对象,参数,names,class,###
来源： https://www.cnblogs.com/p36606jp/p/15113350.html