ex35

• 这个程序应该倒着读，就理解了。
  要先输入taunt bear，进入分支，然后将bear_moved这个向量变为真值，接着再输入open door,如此才满足gold_room的分支条件，win。
• 如何判断输入的字符是否是数字？

next = raw_input(">")
if next.isdigit() is True:
    ....略
else:
    dead("Man,learn to type a number.") 

• exit()是干什么的？

在许多操作系统中可以使用exit(0)来中止程序，传递的数字参数表示是否遇到异常。如果使用exit(1)退出将会出现一个错误，但是用exit(0)就是正常的退出。参数部分和正常的布尔逻辑正好是相反的 (正常的布尔逻辑中 0==False) 您可以使用不同的数字来表示不同的错误结果。你也可以用exit(100)来表示一个不同于exit(2)和 exit(1)的错误信息.

来自分支和函数 | Learn Python the Hard Way 中文版

ex36

恩，花了两天，写完啦~
把之前所有学过的命令都复习一遍，然后画了个游戏草图，然后敲代码加debug共计2.5小时，完成人生第一个自主设计小游戏，包治游戏成瘾，最快5秒即玩完。。
感想：想的容易，做着难。

ex37

每天学5个。

and

布尔运算中的“且”。如果几个小命题用“and”相连，则这几个小命题都为True,总命题才为True

del

表示delete，删除；可以删除整个list，也可以只删除list中的一个元素。

>>> del L1[3]
>>> L1
['a', 'b', 'c', 'e', 'f']

del与pop,remove的区别，Quora
首先这三类型不同，直观表现就是写法不同。pop,remove都属于list的method，所以写成listname.pop;listname.remove.
del()
删除整个清单list，或者list中的一个元素item

>>> x = [1, 2, 3, 4]
>>> del x[3]
>>> x
[1, 2, 3]

remove()
删除清单中第一个匹配的item

>>> x = [1, 0, 0, 0, 3, 4, 5, 4]
>>> x.remove(4)
>>> x
[1, 0, 0, 0, 3, 5, 4]

pop()
返回list中最后一个元素item,并删除；或者，返回所选元素并删除。

>>> x = [1, 2, 3] 
>>> x.pop(2) 
3 
>>> x 
[1, 2]

from

用于引入module。
from sys import argv 与 import.argv的区别Stack Overflow
区别在于调用模块的写法。
当我们写成from urllib import request,那么在之后的代码里可以直接写mine = request()
如果写成 import urllib.request,之后代码里想调用，必须写成
mine=urllib.request()
所以推荐用from开头的写法，后续再用就简单清爽多了。

not

布尔运算的“非”。
非真——假
非假——真

while

无限循环。只要while后面的条件满足，这个循环就会一直一直进行下去。
慎用！

as

可以用于取“别名”。比如一个变量，或者模块名字太长，可以这样做：

import SomeBigModuleName
SomeBigModuleName.method()
等同于
import SomeBigModuleName  as sbmn
sbmn.method()

也可以配合with实现读取写file的功能：

f = open(file)
f.read()
f.close 
等同于
with open(file) as f:
    f.read()

参考 When would one use 'as' in Python? - Quora

elif 以及 if, else

elif=else if，和if一起出现，用于开启一个条件分支。结构是 if....elif....else...
if 可以单独使用，但是elif总是和if一起出现。程序进行到if,elif,else三者组成的分叉口时，检查顺序是if，elif,else。哪个先满足，就进行其后的操作，有先后顺序之分。

image

or

布尔运算的“或”。对于A 或 B这个argument，只要A和B中，有一个为真，则这个判断为真。

with

第一个用法见上： with 和 as 配合，用于操作文件。
第二个用法，ex15中曾经困扰我的，同时操作打开多个文件：

with open("inFile.txt", 'r') as fr:
    with open("outFile1.txt", 'w') as fw1:
        with open("outFile2.txt", 'w') as fw2:
            for line in fr.readlines():
                fw1.writelines(line)
                fw2.writelines(line)

参考：How can I open multiple files using "with open" in Python? - Stack Overflow

global

global，即在整个程序里通用；Local，即只在一小块程序（函数，条件句，模块等等）小范围通用。
假设我们在一个函数里定义了变量aa, 如果不加global，那么出了函数，我们是不知道aa是什么的，因为未被定义。加上global aa这个句子，那么aa在全程序里都会被认出来。

def bob():
    global me    #这句是关键。没有此句话，程序会报错。
    me = "locally defined"   # Defined locally but declared as global
    print me

bob()
print me  # Asking for a global variable

参考：Use of "global" keyword in Python - Stack Overflow

assert

用于测试代码的，如果不符合就会报错。assert后面加一个判断，如果之后的运行都符合这个判断，那么程序正常运行，我们也看不到assert的身影；如果现在运行的代码，不符合assert的判断，那么程序会停止，报错AssertionError.
看个例子：这是将开尔文温度转为摄氏温度的小代码。开尔文温度中，绝对零度就是宇宙最低温度了，所以输入的开尔文温度不能小于0.于是我们assert：温度>=0. 同时还打印一句提示“比绝对零度还低了！”

def KelvinToFahrenheit(Temperature):
   assert (Temperature >= 0),"Colder than absolute zero!"
   return ((Temperature-273)*1.8)+32

print KelvinToFahrenheit(273)
print int(KelvinToFahrenheit(505.78))
print KelvinToFahrenheit(-5)

输出结果为：

32.0
451
Traceback (most recent call last):
   File "test.py", line 9, in <module>
      print KelvinToFahrenheit(-5)
   File "test.py", line 4, in KelvinToFahrenheit
      assert (Temperature >= 0),"Colder than absolute zero!"
AssertionError: Colder than absolute zero!

例子来源于Assertions in Python
按照What is the use of "assert" in Python? - Stack Overflow所说，assert等同于

if not condition:
    raise AssertionError()

pass

很好玩的keyword,有两个功能：
一是占坑，相当于我们在论坛上发帖时的“先占个位置，之后再写”。假如有块函数，没来得及写完，但是现在需要运行全部大程序，又不想删掉这块未完成的部分，那就pass,告诉python跳过。
二还是为了跳过，不过不是占坑，而是筛选。
比如这个例子，来自Python pass Statement

for letter in 'Python': 
   if letter == 'h':
      pass
      print 'This is pass block'
   print 'Current Letter :', letter

print "Good bye!"

注意，这段小程序里的“letter”只是一个随意的变量名字，python并不是因为这个变量叫letter，就知道它要找字母的。可以把letter换成任意其他的变量名都ok.

• yield
  目前理解：类似于return；不过return返回一个数，yield返回一串数
  python - What does the "yield" keyword do? - Stack Overflow
  这页解释的非常详细，有不少细节没看懂。。先pass
  https://stackoverflow.com/a/36220775/9313875
  这个答案给的例子很棒！

break

用于打断循环（for 或者while循环）。配合If在循环里使用：if规定打断的条件，一旦这个条件满足，就break
比如下面这个例子，来自Python break statement，在之前的pass里也用过。当字母为h时，pass只是跳过h,其他的字母继续按循环要求运行；而break则直接退出此循环。

for ii in 'python':
    if ii == 'h':
        print 'H commes!' #这句会打印出来，因为在break之前出现
        break
        print 'current one:' #这句不会被打印出来，break一出现，程序就断了
    print 'Current Letter:',ii
print 'goodbye'

输出结果为

Current Letter: p
Current Letter: y
Current Letter: t
H commes!
goodbye

这有个判断一个数是不是质数prime的程序，很好玩，来自break and continue statement in Python - OverIQ.com

num = int(input("Enter a number: "))

is_prime = True

for i in range(2, num):
    if num % i == 0:
        is_prime = False  # number is not prime
        break  # exit from for loop

if is_prime:
    print(num, "is prime")
else:
    print(num, "is not a prime")

except

要了解这个概念，需要先知道在python里有两种错误Error:
一种叫做Syntax Error,即程序结构和语句本身有错，比如我目前犯过不止一次的错误：if后面少了冒号。。
另一种叫做Runtime Error或者Exception,即程序结构和语句本身正确，然而运行时仍然有问题，比如你设置的分母是0啦， 变量名前后不一致于是找不到啦，等等。运行时出现Exception时，报错时会有这句熟悉的Traceback (most recent call last):...
except正是用来处理跟exceptions有关的命令.

• try+exceptions，用于测试程序，使用python内置的各种exception，见6. Built-in Exceptions — Python 2.7.14 documentation
• raise+exception,用于创造自己的exception

例子见以下链接：

8. Errors and Exceptions — Python 2.7.14 documentation
Try/Except in Python: How do you properly ignore Exceptions? - Stack Overflow
Manually raising (throwing) an exception in Python - Stack Overflow
Exception Handling in Python - OverIQ.com
Errors and Exceptions in Python

import

用于引入各种各样的 module 模块 。

print

用于输出。本书前10课全是围绕此，比较简单，略过。

class

用于创建 class。
class类似于module，是一个小块，里面可以有函数有循环等。object是按照class这个模板生成的的一个实例。按照建筑学理解，class是样板间，object是项目的各真实房间，即规定的东西都会有，然后按需要调整。
Introduction to Python: An open resource for students and teachers
Objects and Classes in Python - OverIQ.com

exec

表示execute，即“do something”。
exec常常和eval比较，按照网友说法

exec is for statement and does not return anything. eval is for expression and returns value of expression.
expression means "something" while statement means "do something".
目前感觉exec可有可无。。

dynamic - What's the difference between eval, exec, and compile in Python? - Stack Overflow

in

用法同字面意思“在。。。里面”，子集。
可以是list,可以是string，可以说dictionary等等

目前已经接触三种date type了：list,tuple,dictionary

• list: 用[中括号]brackets包起来。有顺序的元素列，从0起数。list可以更改，删除，换顺序等等；写法 l = [1, 2, "a"]
• tuple:用parentheses（小括号）包起来。有顺序的元素列，从0起数。tuple不可更改。比如一年中的十二月份。写法：t = (1, 2, "a")
• dictionary：用curly bracket {大括号}包起来。没有顺序的元素列。每一项元素包括两部分，key+value: 比如 一个电话簿,写法d = {"a":1, "b":2}
  Lesson 6 - Tuples, Lists, and Dictionaries

raise

用于创造自己的exception.
常用句型是if (a < b): raise ValueError()
一个好例子足以说明这个keyword,来自Exception Handling in Python - OverIQ.com
求某个数的阶乘，因此这个数必须是整数（raise1），必须是正数（raise2）。

def factorial(n):
    if  not isinstance(n, int):
        raise RuntimeError("Argument must be int")

    if n < 0:
        raise RuntimeError("Argument must be >= 0")

    f = 1
    for i in range(n):
        f *= n
        n -= 1

    return f

try:
    print("Factorial of 4 is:", factorial(4))
    print("Factorial of 12 is:", factorial("12"))
except RuntimeError:
    print("Invalid Input")

补充：上面例子用到了一个built-in function,isinstance,功能是判断输入变量是否符合所选类型，句型是isinstance(object, classinfo)，返回True 或者 False

continue

与pass的功能很像，跳过某一段。与pass的细微差别在于，pass后面的命令会继续进行，而continue后面的不会进行。

...
pass
print  "This will be neglected."` #这句话会被打印出来
-------------------------------------------------------------------
...
continue
print  "This will be neglected."`#这句话不会被打印出来

再来看一个很棒的程序，很简单，计算一个数字的立方，同时使用break和continue,来自break and continue statement in Python - OverIQ.com

while True:
    value = raw_input("\nEnter a number:")
    
    if value == 'q':
        print "Exiting program."
        break
    if not value.isdigit():
        print "Enter digits only"
        continue
    value = int(value)
    print "Cube of ",value,"is",value**3

finally

还是和exception有关，第一次看到官方文件6 PEP 341: Unified try/except/finally写的这么清楚~

try:
    block-1 ...
except Exception1:
    handler-1 ...
except Exception2:
    handler-2 ...
else:
    else-block
finally:
    final-block

block-1先执行：
如果出现错误，按各自的错误分别执行handler-1 或者 handler-2；
如果没有错误，那么执行else-block;
无论有没有错误，最后都要执行 final-block.

is

当我们说 A is B，表示A 和 B 是同一个对象，他们的id (使用id() function验证）是相同的；
当我们说 A ==B，表示A 和 B 的 值 相等，id可以相同，也可以不同。

x = [1, 2, 3]
y = [1, 2, 3]
print x is y   #It prints false!
print x == y  # True

参考Understanding Python's "is" operator - Stack Overflow

• return
  这里What precisely does "return" in this code do? | Codecademy解释的非常好。
  return用于方程function中，来输出一个结果。
  从这一点来说，return跟常用的print没有区别，所以加不加return的输出结果一样，如下：

function i_return(x):
    print x
    return x

function i_dont(x):
    print x

i_return(5)        # prints 5
i_dont(5)          # prints 5

但是！return的另一个重要功能，就是返回这个结果变量，并储存在python里！而print只是一次性输出，方程结束就over了，结果无法再利用。
接上例，

print i_return(5) + 2    # prints 7
print i_dont(5) + 2      # causes an Error

另外关于return的一点，这里Returning a value from a function — Programs, Information, and People: Interactive Edition提到：（这个网站有许多概念辨析题，推荐！）

def addEm(x, y, z):
    return x+y+z
    print 'the answer is', x+y+z

上面这个例子有什么错？
return后面不应该再加任何东西了，return即方程的结束！

def

用于定义方程。所谓方程，即一连串的statement.

for

定义循环。
来自Strings and for loops — Programs, Information, and People: Interactive Edition的辨析题：
下面的循环里，hello会被打印几遍？

s = "python rocks"
for ch in s:
   print "HELLO"

12次，空格也纳入计数。

lambda

用于定义方程。和def不同的是，lambda定义匿名方程，不需要给方程一个名字了。

使用def
def square_root(x): return math.sqrt(x)
使用lambda
square_root = lambda x: math.sqrt(x)

两者效果没什么区别。那么有了def，为啥还需要lambda：
1)当这个方程很简单，
2)以后也不会再用了;
那么可以试试lamdba.
尤其配合map以及filter,用起来超快~

map

map是批量操作方程，句型是 map(func, seq)

my_list = [1, 5, 4, 6, 8, 11, 3, 12]
new_list = list(map(lambda x: x * 2 , my_list))
print(new_list)

# Output: [2, 10, 8, 12, 16, 22, 6, 24]

filter

方程作为过滤条件，过滤一串变量，句型是 filter(function, list)

my_list = [1, 5, 4, 6, 8, 11, 3, 12]
new_list = list(filter(lambda x: (x%2 == 0) , my_list))
print(new_list)
# Output: [4, 6, 8, 12]

reduce

将一个序列按照方程要求压缩成一个数。句型是 reduce(func, seq)
看例子就懂了：

找出最大值
>>> f = lambda a,b: a if (a > b) else b
>>> reduce(f, [47,11,42,102,13])
102

从1加到100
>>> reduce(lambda x, y: x+y, range(1,101))
5050

参考：
Python Tutorial: Lambda Operator, filter, reduce and map
Yet Another Lambda Tutorial | Python Conquers The Universe
Python Lambda (Anonymous) Function

try

见except, finally