Learn Python the Hard Way

Reference

Zed Shaw - Learn Python the Hard Way

Ex0: The Setup

Windows

Python 2, Atom, Terminal. 

Ex1: A Good First Program

Keyword

print
print "Hello World! "

Run the file

python ex1.py

Error

Garbled Chinese

Possible Solutions (Unfortunately, none of them works.)

1. Add ASCII encodings

# -*- coding: utf-8 -*-

2. decode & encode⁰¹

print '中文'.decode("utf-8").encode("gb2312")
print '中文'.decode("utf-8").encode("gbk")

3. CHCP command^{01, 02}

chcp 65001

01 关于win终端下python输出中文乱码问题

02 Windows设置CMD命令行编码

Ex2: Comments and Pound Characters

Keywork

#
# Comments

Q: If # is for comments, then how come # -*- coding: utf-8 -*- works? 

A: Python still ignores that as code, but it's used as a kind of "hack" or workaround for problems with setting and detecting the format of a file. You also find a similar kind of comment for editor settings.

Q: Why does the # in print "Hi # there." not get ignored?

A: The # in that code is inside a string, so it will be put into the string until the ending " character is hit. These pound characters are just considered characters and aren't considered comments. 

Ex3: Numbers and Math

Keywords

+ # plus
- # minus
/ # slash: 7 / 4 = 1; 7.0 / 4.0 = 1.75
* # asterisk
% # percent; modulus: X divided by Y with J remaining, The result of % is the J part. 
< # less-than
> # greater-than
<= # less-than-equal
>= # greater-than-equal

Ex4: Variables and Names

Ex5: More Variables and Printing

Keywords

my_eyes = 'Black'
my_hair = 'Black'
print "She's got %s eyes and %s hair." % (my_eyes, my_hair)

03 String Formatting Operations

04 python中%r和%s的区别

Ex6: Strings and Text

Python knows you want something to be a string when you put either " (double-quotes) or ' (single-quotes) around the text.

Typically you'll use single-quotes for any short strings like 'a' or 'snow'. ^{* Quoted from Ex7.} 

You simply put the formatted variables in the string, and then a % (percent) character, followed by the variable. The only catch is that if you want multiple formats in your string to print multiple variables, you need to put them inside ( ) (parenthesis) separated by , (commas). 

Q: What is the difference between %r and %s?

A: Use the %r for debugging, since it displays the "raw" data of the variable, but the others are used for displaying to users.

Q: What's the point of %s and %d when you can just use %r?

A: The %r is best for debugging, and the other formats are for actually displaying variables to users.

Ex7: More Printing

print "." * 10

Result

..........

print "Cheese", 
print "Burger"

print "Cheese"
print "Burger"

Result

Cheese Burger

Cheese
Burger

Ex8: Printing, Printing

formatter = "%r %r %r %r"

print formatter % (1, 2, 3, 4)
print formatter % ("one", "two", "three", "four")
print formatter % (True, False, False, True)
print formatter % (formatter, formatter, formatter, formatter)
print formatter % (
    "I had this thing",
    "That you could type up right.",
    "But it didn't sing.",
    "So I said goodnight."
)

Result

C:UsersI******python_***>python ex8.py
1 2 3 4
'one' 'two' 'three' 'four'
True False False True
'%r %r %r %r' '%r %r %r %r' '%r %r %r %r' '%r %r %r %r'
'I had this thing' 'That you could type up right.' "But it didn't sing." 'So I said goodnight.'

Q: Why does %r sometimes print things with single-quotes when I wrote them with double-quotes?

A: Python is going to print the strings in the most efficient way it can, not replicate exactly the way you wrote them. This is perfectly fine since %r is used for debugging and inspection, so it's not necessary that it be pretty.

Ex9: Printing, Printing, Printing

months = "Jan
Feb
Mar
Apr
May
Jun
Jul
Aug"

print "Here are the months: ", months
print "Here are the months: %r" % months

Result

Here are the months:  Jan
Feb
Mar
Apr
May
Jun
Jul
Aug

Here are the months: 'Jan
Feb
Mar
Apr
May
Jun
Jul
Aug'

Q: 为什么当我使用 来换行的时候，%r就不生效了？
A: 这就是%r格式的工作原理；你如何输入的，它就如何打印输出。

print """ # 换行
There's something going on here.
With the three double-quotes.
We'll be able to type as much as we like.
Even 4 lines if we want, or 5, or 6.
"""

Ex10: What Was That? 

Escape Sequences

Keywords: r &

r 让字符串中的转义字符失去转义的意义⁰⁵

print "	t"
print r"	t"

Result

    t
	t

 表示将光标的位置回退到本行的开头位置⁰⁶

import time

count_down = 10
interval = 1
for i in range( 0, int( count_down / interval ) + 1 ):
    print "
" + "." * i + " " + str( i * 10 ) + "%"
    time.sleep( interval )
print "
Loaded"

Result

 0%
. 10%
.. 20%
... 30%
.... 40%
..... 50%
...... 60%
....... 70%
........ 80%
......... 90%
.......... 100%

Loaded

05 python中- 用法

06 Python中 ' ' 的实际应用

Ex11: Asking Questions

print "How old are you?", 
age = raw_input()
print "How tall are you?", 
height = raw_input()
print "How much do you weigh?", 
weight = raw_input()

print "So, you're %r old, %r tall and %r heavy." % (
    age, height, weight)

Result

How old are you? 26
How tall are you? 167cm
How much do you weigh? 60kg
So, you're '26' old, '167cm' tall and '60kg' heavy.

print "How old are you?"
age = raw_input()
print "How tall are you?"
height = raw_input()
print "How much do you weigh?"
weight = raw_input()

print "So, you're %r old, %r tall and %r heavy." % (
    age, height, weight)

Result

How old are you?
38
How tall are you?
6'2"
How much do you weigh?
180lbs
So, you're '38' old, '6'2"' tall and '180lbs' heavy.

单引号需要被转义，从而防止它被识别为字符串的结尾。

Keyword

raw_input()

input() 和 raw_input() 这两个函数均能接收 字符串 ，但 raw_input() 直接读取控制台的输入（任何类型的输入它都可以接收）。而对于 input() ，它希望能够读取一个合法的 python 表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个 SyntaxError 。

除非对 input() 有特别需要，否则一般情况下我们都是推荐使用 raw_input() 来与用户交互。⁰⁷

在Python代码里input()方法将会改变你输入的东西，但是这个方法存在安全问题，请尽量避免使用它。

>>> a = raw_input("input:")
input:123
>>> type(a)
<type 'str'>
>>> a = raw_input("input:")
input:runoob
>>> type(a)
<type 'str'>

>>> a = input("input:")
input:123
>>> type(a)
<type 'int'>
>>> a = input("input:")
input:"runoob"
>>> type(a)
<type 'str'>
>>> a = input("input:")
input:runoob
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'runoob' is not defined

Q: 如何接收用户输入的数字，用来进行数学计算？
A: 这略微复杂一些,你可以试试用x = int(raw_input()) 将通过raw_input()获得的字符串转化成整数。

Q: 什么情况下我应该在输入的字符串前面加一个u， 比如 u'35'？
A: 在Python中用这种方式告诉你这是一个Unicode编码的字符串。用%s格式可以让你正常打印。

>>> age = u'26'
>>> print age
26
>>> print "%s" % age
26

07 Python raw_input() 函数

Ex12: Prompting People

name = raw_input("Name? ")

pydoc

C:UsersI******python_***>python -m pydoc raw_input
Help on built-in function raw_input in module __builtin__:

raw_input(...)
    raw_input([prompt]) -> string

    Read a string from standard input.  The trailing newline is stripped.
    If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.
    On Unix, GNU readline is used if enabled.  The prompt string, if given,
    is printed without a trailing newline before reading.

When necessary, input q to quit pydoc. 

Ex13: Parameters, Unpacking, Variables

# -*- coding: utf-8 -*-
from sys import argv # 将Python的功能模块加入脚本；argv就是所谓的参数变量（argument variable）

script, first, second, third = argv # 将argv进行解包（unpack），将每个参数赋予一个变量名

print "The script is called: ", script
print "Your first variable is: ", first
print "Your second variable is: ", second
print "Your third variable is: ", third

fourth = raw_input("Your fourth variable is: ")

Execution

C:UsersI******python_***>python ex13.py 1st 2nd 3rd
The script is called:  ex13.py
Your first variable is:  1st
Your second variable is:  2nd
Your third variable is:  3rd
Your fourth variable is: 4th

Q: argv 和 raw_input()有什么区别?
A: 它们的不同之处在于要求用户输入的位置不同。如果你想让用户在命令行输入你的参数，你应该使用argv.，如果你希望用户在脚本执行的过程中输入参数，那就就要用到raw_input()。
Q: 命令行输入的参数是字符串吗?
A: 是的，如果你需要输入数字，可以使用int()把他们转化成整数，可以参考 int(raw_input()). 

Ex14: Prompting And Passing

raw_input()的提示符

prompt = '>'

print "Do you like me?"
likes = raw_input(prompt)

Result

Do you like me?
>Yes

Ex15: Reading Files

Keywords

txt = open(filename)
print txt.read()
txt.close()

Ex16: Reading and Writing Files

文件相关的各种命令（方法 / 函数）

close -- 关闭文件。跟你编辑器的 文件->保存..一个意思。
read -- 读取文件内容。你可以把结果赋给一个变量。
readline -- 读取文本文件中的一行。
truncate -- 清空文件，请谨慎使用该命令。
write('stuff') -- 将stuff写入文件。

'r' 是 open()函数的默认参数值。

'w' 也是打开文件的一种模式。如果你用了这个参数，表示以写(write)模式打开文件。同样有'a'’表示追加模式，还有一些其他的修饰符。

最重要的一个就是+, 使用它，你可以有'w+', 'r+', 和'a+'模式. 这样可以同时以读写模式打开文件。

08 Python open() 函数

Ex17: More Files

from sys import argv
from os.path import exists

script, from_file, to_file = argv

print "Copying from %s to %s" % (from_file, to_file)

# in_file = open(from_file)
# indata = in_file.read()
indata = open(from_file).read() # 这样写的话，就不需要在执行关闭操作，当执行完这一行的时候，文件自动就被关闭了。

print "The input file is %d bytes long" % len(indata)

print "Does the output file exist? %r" % exists(to_file)
print "Ready, hit RETURN to continue, CTRL-C to abort,"
raw_input()

out_file = open(to_file, 'w')
out_file.write(indata)

print "Alright, all done."

out_file.close()
# in_file.close()

Ex18: Names, Variables, Code, Functions

def print_two(*args):
    arg1, arg2 = args
    print "arg1: %r, arg2: %r" % (arg1, arg2)

def print_two_again(arg1, arg2):
    print "arg1: %r, arg2: %r" % (arg1, arg2)

def print_one(arg1):
    print "arg1: %r" % arg1

def print_none():
    print "I got nothing."

print_two("July","22nd")
print_two_again("July","22nd")
print_one("2018")
print_none()

函数print_two的问题是：它并不是创建函数最简单的方法。在 Python 函数中我们可以跳过整个参数解包的过程，直接使用()里边的名称作为变量名。这就是print_two_again实现的功能。

Q: *args中的星号*是干嘛的？
A: 它告诉Python把函数的所有参数组织一个列表放在args里。类似你之前用过的argv，只不过*args是用在函数里的。

Ex19: Functions and Variables

def cheese_and_crackers(cheese_count, boxes_of_crackers):
    print "You have %d cheeses!" % cheese_count
    print "You have %d boxes of crackers!" % boxes_of_crackers
    print "Man that's enough for a party!"
    print "Get a blanket.
"

print "We can just give the function numbers directly:"
cheese_and_crackers(20, 30)

print "OR, we can use variables from our script:"
amount_of_cheese = 10
amount_of_crackers = 50

cheese_and_crackers(amount_of_cheese, amount_of_crackers)

print "We can even do math inside too:"
cheese_and_crackers(10 + 20, 5 + 6)

print "And we can combine the two, variables and math"
cheese_and_crackers(amount_of_cheese + 100, amount_of_crackers + 1000)

amount_of_cheese = raw_input("Tell me the amount of cheese: ")
amount_of_crackers = raw_input("Tell me the amount of crackers: ")
cheese_and_crackers(int(amount_of_cheese), int(amount_of_crackers))

Result

C:UsersI******python_***>python ex19.py
We can just give the function numbers directly:
You have 20 cheeses!
You have 30 boxes of crackers!
Man that's enough for a party!
Get a blanket.

OR, we can use variables from our script:
You have 10 cheeses!
You have 50 boxes of crackers!
Man that's enough for a party!
Get a blanket.

We can even do math inside too:
You have 30 cheeses!
You have 11 boxes of crackers!
Man that's enough for a party!
Get a blanket.

And we can combine the two, variables and math
You have 110 cheeses!
You have 1050 boxes of crackers!
Man that's enough for a party!
Get a blanket.

Tell me the amount of cheese: 12
Tell me the amount of crackers: 23
You have 12 cheeses!
You have 23 boxes of crackers!
Man that's enough for a party!
Get a blanket.

Ex20: Functions and Files

from sys import argv

script, input_file = argv

def print_all(f):
    print f.read()

def rewind(f):
    f.seek(0)

def print_a_line(line_count, f):
    print line_count, f.readline()

current_file = open(input_file)

print "First let's print the whole file:
"

print_all(current_file)

print "Now let's rewind, kind of like a tape."

rewind(current_file)

print "Let's print three lines:"

current_line = 1
print_a_line(current_line, current_file)

current_line = current_line + 1
print_a_line(current_line, current_file)

current_line += 1
print_a_line(current_line, current_file)

Result

C:UsersI******python_***>python ex20.py ex17_to.txt
First let's print the whole file:

Today is a rainy day.
We're self-studying Python at home.
It's a bit challenging but really interesting.

Now let's rewind, kind of like a tape.
Let's print three lines:
1 Today is a rainy day.

2 We're self-studying Python at home.

3 It's a bit challenging but really interesting.

Keyword

fileObject.seek(offset[, whence])
# seek() 方法用于移动文件读取指针到指定位置。
# offset -- 开始的偏移量，也就是代表需要移动偏移的字节数
# whence：可选，默认值为 0。给offset参数一个定义，表示要从哪个位置开始偏移；0代表从文件开头开始算起，1代表从当前位置开始算起，2代表从文件末尾算起。
# 该函数没有返回值。

09 Python File seek() 方法

Q: 文件中为什么有3个空行？
A: 函数 readline() 返回一行以 结尾的文件内容， 在你调用print函数的最后增加一个逗号','，用来避免为每一行添加两个换行符 。

def print_a_line(line_count, f):
    print line_count, f.readline(),

Q: readline()怎么知道每一行的分界在哪里？
A: readline()内部代码是扫描文件的每一个字节，直到找到一个 字符代码，然后停止阅读，并返回到此之前获得的所有内容。代码中f的责任是在每次调用readline()之后，维护“磁头”在文件中的位置，以保证继续读后面的每一行。

Ex21: Functions Can Return Something

def add(a, b):
    print "ADDING %d + %d" % (a, b)
    return a + b

Ex22: What Do You Know So Far? 

Ex23: Read Some Code

Ex24: More Practice

def secret_formula(started):
    jelly_beans = started * 500
    jars = jelly_beans / 1000
    crates = jars / 100
    return jelly_beans, jars, crates

start_point = 10000
beans, jars, crates = secret_formula(start_point)

print "With a starting point of: %d" % start_point
print "We'd have %d beans, %d jars, and %d crates." % (beans, jars, crates)

start_point = start_point / 10

print "We can also do that this way:"
print "We'd have %d beans, %d jars, and %d crates." % secret_formula(start_point)

Ex25: Even More Practice

def break_words(stuff):
    """This function will break up words for us."""
    words = stuff.split(' ') # 通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则仅分隔 num 个子字符串10
    return words

def sort_words(words):
    """Sorts the words."""
    return sorted(words) # 保留原对象，对所有可迭代的对象进行排序操作。11

def print_first_word(words):
    """Prints the first word after popping it off."""
    word = words.pop(0) # 用于移除列表中的一个元素（默认最后一个元素 index = -1），并且返回该元素的值。12
    print word

def print_last_word(words):
    """Prints the last word after popping it off."""
    word = words.pop(-1)
    print word

def sort_sentence(sentence):
    """Takes in a full sentence and returns the sorted words."""
    words = break_words(sentence)
    return sort_words(words)

def print_first_and_last(sentence):
    """Prints the first and last words of the sentence."""
    words = break_words(sentence)
    print_first_word(words)
    print_last_word(words)

def print_first_and_last_sorted(sentence):
    """Sorts the words then prints the first and last one."""
    words = sort_sentence(sentence)
    print_first_word(words)
    print_last_word(words)

Execution

C:UsersI******python_***>python
Enthought Canopy Python 2.7.13 | 64-bit | (default, Mar 30 2017, 11:20:05) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import ex25
>>> sentence = "All good things come to those who wait."
>>> words = ex25.break_words(sentence)
>>> words
['All', 'good', 'things', 'come', 'to', 'those', 'who', 'wait.']
>>> sorted_words = ex25.sort_words(words)
>>> sorted_words
['All', 'come', 'good', 'things', 'those', 'to', 'wait.', 'who']
>>> ex25.print_first_word(words)
All
>>> ex25.print_last_word(words)
wait.
>>> ex25.print_first_word(sorted_words)
All
>>> ex25.print_last_word(sorted_words)
who
>>> sorted_words
['come', 'good', 'things', 'those', 'to', 'wait.']
>>> sorted_words = ex25.sort_sentence(sentence)
>>> sorted_words
['All', 'come', 'good', 'things', 'those', 'to', 'wait.', 'who']
>>> ex25.print_first_and_last(sentence)
All
wait.
>>> ex25.print_first_and_last_sorted(sentence)
All
who

10 Python split()方法

11 Python sorted() 函数

12 Python List pop()方法

Ex26: Congratulations, Take a Test! 

Ex27: Memorizing Logic

Ex28: Boolean Practice

Q: 为什么"test" and "test" 返回 "test"，以及1 and 1 返回 1 ，而不是 True?
A: Python和很多语言可以返回布尔表达式中的一个操作数，而不仅仅是真或假。这意味着如果你计算False and 1 你会得到表达式的第一个操作数 (False) ，但是如果你计算True and 1的时候，你得到它的第二个操作数(1)。试一试吧。

>>> (1 == 1) and 2
2
>>> (1 != 1) and 2
False
>>> (1 != 1) or 2
2
>>> ( 2 == 3 ) or (1 != 1)
False
>>> ( 2 != 3 ) or (1 == 1)
True

# 操作数默认真值
# 布尔运算结果为真，如运算带有操作数，返回操作数，否则，返回True。
# 布尔运算结果飞真，显示False。

Q: !=和<>有什么不同吗?
A: Python已经声明赞成使用!=而弃用<>，所以尽量使用!=吧。其他的应该没有区别了。

Ex29: What If

Q: +=表示什么意思？
A: 代码x += 1和x = x + 1 实现的是一样的功能，但是可以少输入一些字符。你可以称之为“增量”操作符。-= 也是相同的。

Ex30: Else and If

Q: 如果多个elif块为真，会怎样？
A: Python的启动和运行只会针对第一个为真的代码块，所以你说的那种情况，只会执行第一块。

Ex31: Making Decisions

Ex32: Loops and Lists

在你开始使用 for 循环之前，你需要在某个位置存放循环的结果。最好的方法是使用列表（list），顾名思义，列表就是一个按顺序存放东西的容器。

你要做的是以 [（左方括号）开头“打开”列表，然后写下你要放入列表的东西，用逗号隔开，就跟函数的参数一样，最后用]（右方括号）结束列表的定义。然后Python接收这个列表以及里边所有的内容，将其赋给一个变量。

the_count = [1, 2, 3, 4, 5]
fruits = ['apples', 'oranges', 'pears', 'apricots']
change = [1, 'pennies', 2, 'dimes', 3, 'quarters']

elements = []

for i in range(0, 6):
    print "Adding %d to the list." % i
    elements.append(i) # 在列表的末尾追加一个元素。

for i in elements:
    print "Element was: %d" % i

Result

Adding 0 to the list.
Adding 1 to the list.
Adding 2 to the list.
Adding 3 to the list.
Adding 4 to the list.
Adding 5 to the list.
Element was: 0
Element was: 1
Element was: 2
Element was: 3
Element was: 4
Element was: 5

Q: 为什么for 循环可以使用一个没有定义过的变量？
A: 在for循环开始的时候，就会定义这个变量， 并初始化。

Q: 为什么for i in range(1, 3):只循环了两次？
A: range()函数循环的次数不包括最后一个。所以range(1,3)只循环到2，这是这种循环最常用的方法。

Ex33: While Loops

while 循环所作的和if语句类似，也是去检查一个布尔表达式的真假，不一样的是它下面的代码片段不是只被执行一次，而是执行完后再调回到 while 所在的位置，如此重复进行，直到while表达式为False为止。

1. 尽量少用while-loop，大部分时候for-loop是更好的选择。
2. 重复检查你的while语句，确定你的布尔表达式最终会变成False 。
3. 如果不确定，就在while循环的结尾打印出你测试的值。看看它的变化。

for 循环只能对某种事物的集合做循环，而while可以进行任何种类的循环。但是，while循环很容易出错，大部分情况for循环也是一个很好的选择。

Ex34: Accessing Elements of Lists

Call Function in CMD

>>> import ex34
>>> ex34.animal(2)
The 2nd animal is at 1 and is a python.

Ex35: Branches and Functions

Q: 你为什么用了while True?
A: 这么写可以创建一个无限循环。

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

Ex36: Designing and Debugging

13 Python中如何Debug

Ex37: Symbol Reviews

Keywords

# and 逻辑与
True and False == False

# as with-as语句的一部分
with X as Y: pass

# assert 声明
assert False, "Error!" 

# break 停止整个循环
while True: break

# class 定义一个类
class Person(object)

# continue 停止这一次循环，但继续下一次循环
while True: continue

# def 定义一个函数
def X(): pass

# del 从字典中删除
del X[Y]

# elif else if条件
if: X; elif: Y; else: J

# else else条件
if: X; elif: Y; else: J

# except 如果捕获异常，执行该代码块
except ValueError, e: print e

# exec 将字符串作为Python代码执行
exec 'print "hello"'

# finally 不管是否有异常，finally代码块都执行
finally: pass

# for for循环
for X in Y: pass

# from 从某一模块中引入特定部分
import X from Y

# global 定义一个全局变量
global X

# if if条件
if: X; elif: Y; else: J

# import 引入一个模块到当前模块
import os

# in for循环的一部分 / 测试 X in Y. 
for X in Y: pass / 1 in [1] == True

# is 类似==，判断相等
1 is 1 == True

# lambda 创建一个无名函数
s = lambda y: y ** y; s(3)

# not 逻辑非
not True == False

# or 逻辑或
True or False == True

# pass 该代码块为空
def empty(): pass

# print 打印一个字符串
print 'this string'

# raise 代码出错时，抛出一个异常
raise ValueError("No")

# return 退出函数并返回一个返回值
def X(): return Y

# try 尝试代签代码块，有异常则进入except代码块
try: pass

# while while循环
while X: pass

# with 一个变量的别名
with X as Y: pass

# yield 暂停，返回给调用者
def X(): yield Y; X().next()

Data Types

# True True布尔值
True or False == True

# False False布尔值
False and Treu == False

# None 表示“nothing”或者“no value”
x = None

# strings 字符串，储存文本信息
x = "hello"

# numbers 储存整数
i = 100

# floats 储存小数
i = 10.389

# lists 储存某种东西的列表
j = [1, 2, 3, 4]

# dicts 储存某些东西的键值对
e = {'x': 1, 'y': 2}

Escape Sequences

\ #斜线
' #单引号
" #双引号
a #Bell
 #退格
f #Formfeed

 #换行

 #Carriage
	 #Tab键
v #垂直的Tab

String Formatting

# %d 格式化整数（不包含浮点数）
"%d" % 45 == '45'

# %i 与%d相同
"%i" % 45 == '45'

# %o 8进制数字
"%o" % 1000 == '1750'

# %u 负数
"%u" % -1000 == '-1000'

# %x 小写的十六进制数字
"%x" % 1000 == '3e8'

# %X 大写的十六进制数字
"%x" % 1000 == '3E8'

# %e 小写'e'的指数标记
"%e" % 1000 == '1.000000e+03'
 
# %E 大写'e'的指数标记
"%E" % 1000 == '1.000000E+03'

# %f 浮点数
"%f" % 10.34 == '10.340000'

# %F 与%f相同
"%F" % 10.34 == '10.340000'

# %g %f或者%e中较短的一个
"%g" % 10.34 == '10.34'

# %G %F或者%E中较短的一个
"%G" % 10.34 == '10.34'

# %c 字符格式化
"%c" % 34 == '""'

# %r 类型格式化
"%r" % int == "<type 'int'>"

# %s 字符串格式
"%s there" % 'hi' == 'hi there'

# %% 表示百分号%
"%g%%" % 10.34 == '10.34%'

Operators

# + 加
2 + 4 == 6

# - 减
2 - 4 == -2

# * 乘
2 * 4 == 8

# ** 幂乘
2 ** 4 == 16

# / 除
2 / 4.0 == 0.5

# // 整除，得到除法的商
2 // 4.0 == 0.0

# % 模除，返回除法的余数
2 % 4 == 2

# < 小于
4 < 4 == False

# > 大于
4 > 4 == False

# <= 小于等于
4 <= 4 == True

# >= 大于等于
4 >= 4 == True

# == 等于，比较操作对象是否相等
4 == 5 == False

# != 不等于
4 != 5 == True

# <> 不等于
4 <> 5 == True

# () 括号
len('hi') == 2

# [] 列表括号
[1,3,4]

# {} 字典括号
{'x': 5, 'y': 10}

# @ 装饰符
@classmehod

# , 逗号
range(0, 10)

# : 冒号
def X():

# . Dot
self.x = 10

# = 赋值等于
x = 10

# ; 分号
print "hi"; print "there"

# += 加等于
x = 1; x += 2

# -= 减等于
x = 1; x -= 2

# *= 乘等于
x = 1; x *= 2

# /= 除等于
x = 1; x /= 2

# //= 整除等于
x = 1; x //= 2

# %= 模除等于
x = 1; x %= 2

# **= 幂乘等于
x = 1; x **= 2

Ex38: Doing Things to Lists

ten_things = "Apples Oranges Crows Telephone Light Suger"

print "Wait there are not 10 things in that list. Let's fix that."

stuff = ten_things.split(' ')
more_stuff = ["Day", "Night", "Song", "Frisbee", "Corn", "Banana", "Girl", "Boy"]

while len(stuff) != 10:
    next_one = more_stuff.pop()
    print "Adding: ", next_one
    stuff.append(next_one)
    print "There are %d items now." % len(stuff)

print "There we go: ", stuff

print "Let's do some things with stuff."

print stuff[1]
print stuff[-1]
print stuff.pop()
print ' '.join(stuff)
print '#'.join(stuff[3:5])

Result

C:UsersI******python_***>python ex37.py
Wait there are not 10 things in that list. Let's fix that.
Adding:  Boy
There are 7 items now.
Adding:  Girl
There are 8 items now.
Adding:  Banana
There are 9 items now.
Adding:  Corn
There are 10 items now.
There we go:  ['Apples', 'Oranges', 'Crows', 'Telephone', 'Light', 'Suger', 'Boy', 'Girl', 'Banana', 'Corn']
Let's do some things with stuff.
Oranges
Corn
Corn
Apples Oranges Crows Telephone Light Suger Boy Girl Banana
Telephone#Light

列表能实现什么？

以扑克牌为例：

1) 你有一堆有值的卡片。
2) 这些卡片式一堆，一列，或者可以从头到尾排列这些卡片。
3) 你可以随机的从顶部、中部或者底部取出卡片。
4) 如果你想找到某张特殊的卡片, 你必须一张一张的检索这些卡片。

什么情况可以使用列表？

当你有一些有东西能匹配列表数据结构的有用特性时，使用列表：

1) 如果你需要维护一组次序，记住，这是把次序编成列表，而不是给次序排序，列表不会帮你排序。
2) 如果你需要根据一个随机数访问列表内容，记住，这时候基数从0开始。
3) 如果你需要从头到尾操作列表内容，记住，这就是for循环。

Ex39: Dictionaries, Oh Lovely Dictionaries

states = {
    'Oregon': 'OR',
    'Florida': 'FL',
    'California': 'CA',
    'New York': 'NY',
    'Michigan': 'MI'
}

cities = {
    'CA': 'San Francisco',
    'MI': 'Detroit',
    'FL': 'Jacksonville'
}

cities['NY'] = 'New York'
cities['OR'] = 'Portland'

print '-' * 10
print "NY State has: ", cities['NY']
print "OR State has: ", cities['OR']

print '-' * 10
print "Michigan's abbreviation is: ", states['Michigan']
print "Florida's abbreviation is: ", states['Florida']

print '-' * 10
print "Michigan has: ", cities[states['Michigan']]
print "Florida has: ", cities[states['Florida']]

print '-' * 10
for state, abbrev in states.items():
    print "%s is abbreviated %s" % (state, abbrev)

print '-' * 10
for abbrev, city in cities.items():
    print "%s has the city %s" % (abbrev, city)

print '-' * 10
for state, abbrev in states.items():
    print "%s state is abbreviated %s and has city %s" % (
        state, abbrev, cities[abbrev])

print '-' * 10
state = states.get('Texas')

if not state:
    print "Sorry, no Texas."

city = cities.get('TX', 'Does Not Exist')
print "The city for the state 'TX' is: %s" % city

Result

C:UsersI******python_***>python ex39.py
----------
NY State has:  New York
OR State has:  Portland
----------
Michigan's abbreviation is:  MI
Florida's abbreviation is:  FL
----------
Michigan has:  Detroit
Florida has:  Jacksonville
----------
California is abbreviated CA
Michigan is abbreviated MI
New York is abbreviated NY
Florida is abbreviated FL
Oregon is abbreviated OR
----------
FL has the city Jacksonville
CA has the city San Francisco
MI has the city Detroit
OR has the city Portland
NY has the city New York
----------
California state is abbreviated CA and has city San Francisco
Michigan state is abbreviated MI and has city Detroit
New York state is abbreviated NY and has city New York
Florida state is abbreviated FL and has city Jacksonville
Oregon state is abbreviated OR and has city Portland
----------
Sorry, no Texas.
The city for the state 'TX' is: Does Not Exist

字典能做什么？

字典是另一个数据结构的例子，和列表一样，是编程中最常用的数据结构之一。字典是用来做映射或者存储你需要的键值对，这样当你需要的时候，你可以通过key来获取它的值。

什么时候选择字典，什么时候选择列表？

当遇到下面情况的时候，可以使用字典：
1) 你要检索的东西是以一些标识为基础的，比如名字、地址或其他一切可以作为key的东西。
2) 你不需要这些东西是有序的。词典通常不会有序的概念，所以你必须使用一个列表。
3) 你想要通过key增删一个元素。
也就是说，如果你要用一个非数字的key，使用dict，如果你需要有序的东西，使用list。

有序字典：collections.OrderedDict

def new(num_buckets=256):
    aMap = []
    for i in range(0, num_buckets):
        aMap.append([])
    return aMap

def hash_key(aMap, key):
    return hash(key) % len(aMap)

def get_bucket(aMap, key):
    bucket_id = hash_key(aMap, key)
    return aMap[bucket_id]

def get_slot(aMap, key, default=None):
    bucket = get_bucket(aMap, key)

    for i, kv in enumerate(bucket):
        k, v = kv
        if key == k:
            return i, k, v

    return -1, key, default

def get(aMap, key, default=None):
    i, k, v = get_slot(aMap, key, default=default)
    return v

def set(aMap, key, value):
    bucket = get_bucket(aMap, key)
    i, k, v = get_slot(aMap, key)

    if i >= 0:
        bucket[1] = (key, value)
    else:
        bucket.append((key, value))

def delete(aMap, key):
    bucket = get_bucket(aMap, key)

    for i in xrange(len(bucket)):
        k, v = bucket[i]
        if key == k:
            del bucket[i]
            break

def list(aMap):
    for bucket in aMap:
        if bucket:
            for k, v in bucket:
                print k, v

Main Program

import hashmap

states = hashmap.new()
hashmap.set(states, 'Oregon', 'OR')
hashmap.set(states, 'Florida', 'FL')
hashmap.set(states, 'California', 'CA')
hashmap.set(states, 'New York', 'NY')
hashmap.set(states, 'Michigan', 'MI')

cities = hashmap.new()
hashmap.set(cities, 'CA', 'San Francisco')
hashmap.set(cities, 'MI', 'Detroit')
hashmap.set(cities, 'FL', 'Jacksonville')

hashmap.set(cities, 'NY', 'New York')
hashmap.set(cities, 'OR', 'Portland')

print '-' * 10
print "NY State has: %s" % hashmap.get(cities, 'NY')
print "OR State has: %s" % hashmap.get(cities, 'OR')

print '-' * 10
print "Michigan's abbreviation is: %s" % hashmap.get(states, 'Michigan')
print "Florida's abbreviation is: %s" % hashmap.get(states, 'Florida')

print '-' * 10
print "Michigan has: %s" % hashmap.get(cities, hashmap.get(states, 'Michigan'))
print "Florida has: %s" % hashmap.get(cities, hashmap.get(states, 'Florida'))

print '-' * 10
hashmap.list(states)

print '-' * 10
hashmap.list(cities)

print '-' * 10
state = hashmap.get(states, 'Texas')

if not state:
    print "Sorry, no Texas."

city = hashmap.get(cities, 'TX', 'Does Not Exist')
print "The city for the state 'TX' is: %s" % city

14 python中OrderedDict的使用

Ex40: Modules, Classes, and Objects

模块就像字典

1) 包含一些函数和变量的Python文件
2) 你可以导入这个文件
3) 你可以用.操作符访问这个模块的函数和变量

mystuff = {'apple': "I AM APPLES!"}
print mystuff['apple']

# mystuff.py
def apple():
    print "I AM APPLES!"

tangerine = "Living reflection of a dream"

# Call
mystuff['apple'] # get apple from dict

import mystuff
mystuff.apple() # get apple from the module
mystuff.tangerine # same thing, it's just a variable

在Python中有一套通用的模式：
1) 有一个key=value模式的容器
2) 通过key从容器中获取数据
在字典中，key是一个字符串，写法为[key]；在模块中，key是一个标识符，写法为.key；在其余的地方，他们几乎是一样的。

类就像模块

类的作用是组织一系列的函数和数据并将它们放在一个容器里，这样你可以通过.操作符访问到它们。

class MyStuff(object):

    def __init__(self):
        self.tangerine = "And now a thousand years between"

    def apple(self):
        print "I AM CLASSY APPLES!"

这个类就像写一个包含apple()方法的“迷你”mystuff模块一样。

你可以使用Mystuff这个类，还可以用它来创建更多个Mystuff，而他们之间也不会互相冲突。当你导入一个模块时，你的整个项目也就只有一个这个模块。

对象就像导入

如果一个类就像一个迷你模块，那么类也会有一个类似import的概念，这个概念被称为实例化，这只是对创建一种更虚幻更聪明的叫法。当一个类被实例化，你就得到一个类的对象。

实例化类的方法就是像调用函数一样调用这个类：

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

类和对象与模块的区别：

1) 类是用来创建迷你模块的蓝本或定义。
2) 实例化是如何创建这些小模块，并在同一时间将其导入。实例化仅仅是指通过类创建一个对象。
3) 由此产生的迷你模块被称为对象，你可以将其分配给一个变量，让它开始运行。

# dict style
mystuff['apples']

# module style
mystuff.apples()
print mystuff.tangerine

# class style
thing = MyStuff()
thing.apples()
print thing.tangerine

Ex41: Learning to Speak Object Oriented

单词解释

class（类）：告诉Python去创建一个新类型。
object（对象）：有两种意思，事物的基本类型，或者事物的实例化。
instance（实例）：你通过Python创建一个类所获得的。
def：用来在类中定义一个函数。
self：在一个类包含的函数中，self是一个用来访问实例或对象的变量。
inheritance：概念，表示一个类可以继承另一个类的特征，就像你和你的父母。
composition：概念，表示一个类可以包含其他类，就像汽车轮子。
attribute：类所拥有的特性，通常是变量。
is-a：惯用语，表示一个东西继承自另一个东西(a)，像在“鲑鱼”是“鱼”。
has-a：惯用语，表示由其他事情或有一个特征(a)，如“鲑鱼有嘴”。

短语解释

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

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

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

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

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

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

import random

WORDS = ['apple', 'pear', 'orange', 'strawberry', 'peach', 'melon']

PHRASES = {
    "class %%%(%%%):":
      "Make a class named %%% that is-a %%%.",
    "class %%%(object):
	def __init__(self, ***)" :
      "class %%% has-a __init__ that takes self and *** parameters.",
    "class %%%(object):
	def ***(self, @@@)":
      "class %%% has-a function named *** that takes self and @@@ parameters.",
    "*** = %%%()":
      "Set *** to an instance of class %%%.",
    "***.***(@@@)":
      "From *** get the *** function, and call it with parameters self, @@@.",
    "***.*** = '***'":
      "From *** get the *** attribute and set it to '***'."
}

def convert(snippet, phrase):
    class_names = [w.capitalize() for w in # capitalize the first character of the string
                   random.sample(WORDS, snippet.count("%%%"))] #.sample() picks certain number of strings.. #.count("str") returns the number of str in a string
    other_names = random.sample(WORDS, snippet.count("***"))
    results = []
    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[:]

        for word in class_names:
            result = result.replace("%%%", word, 1)

        for word in other_names:
            result = result.replace("***", word, 1)

        for word in param_names:
            result = result.replace("@@@", word, 1)

        results.append(result)

    return results

snippets = PHRASES.keys() # .keys() returns all the keys of the dictionary
random.shuffle(snippets) # random.shuffle() sorts the elements randomly

phrase = PHRASES["class %%%(object):
	def ***(self, @@@)"]
question, answer = convert("class %%%(object):
	def ***(self, @@@)", phrase)
if True:
    question, answer = answer, question

print question

print "ANSWER: %s

" % answer

Ex42: Is-A, Has-A, Objects, and Classes

Super()

15 Python super() 函数

16 Multiple inheritance 多重继承

Ex43: Gothons From Planet Percal #25

自顶向下
1) 写出或画出你的问题
2) 从1)中提炼关键问题并搜索相关资料
3) 为2)中的问题创建一个有层次结构的类和对象映射
4) 编写类和测试代码，并保证他们运行
5) 重复并精炼

自下而上
1) 取一小块问题，编写一些代码，并让他勉强运行
2) 完善代码，将其转换成一些更正式的包含类和自动化测试的代码
3) 提取其中的关键概念，并尝试找出研究他们
4) 写出到底发生了什么的描述
5) 继续完善代码，也可能是把它扔掉，并重新开始
6) 移动到其他问题上，重复步骤

17 有限状态机(FSM)

Ex44: Inheritance Vs. Composition

大多数继承的用途，可以简化或用组合物所取代，并应不惜一切代价避免多重继承。

隐形继承

class Parent(object):

    def implicit(self):
        print "PARENT implicit()"

class Child(Parent):
    pass

dad = Parent()
son = Child()

dad.implicit()
son.implicit()

Result

C:UsersI******python_***>python ex44a.py
PARENT implicit()
PARENT implicit()

重写方法

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()

Result

C:UsersI******python_***>python ex44b.py
PARENT override()
CHILD override()

之前或之后改变父类

class Parent(object):

    def altered(self):
        print "PARENT altered()"

class Child(Parent):

    def altered(self):
        print "CHILD, BEFORE PARENT altered()"
        super(Child, self).altered()
        print "CHILD, AFTER PARENT altered()"

dad = Parent()
son = Child()

dad.altered()
son.altered()

Result

C:UsersI******python_***>python ex44c.py
PARENT altered()
CHILD, BEFORE PARENT altered()
PARENT altered()
CHILD, AFTER PARENT altered()

第10行调用了super(Child, self).altered()方法, 这个方法能够意识到继承的发生，并给你获得类Parent。

你可以这样读这行代码“调用super，参数为Child和self，然后不管它返回什么，调用方法altered ”。

super() 函数是用于调用父类(超类)的一个方法。super是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。¹⁸

18 Python super() 函数

包含

class Other(object):

    def override(self):
        print "OTHER override()"

    def implicit(self):
        print "OTHER implicit()"

    def altered(self):
        print "OTHER altered()"

class Child(object):

    def __init__(self):
        self.other = Other()

    def implicit(self):
        self.other.implicit()

    def override(self):
        print "CHILD override()"

    def altered(self):
        print "CHILD, BEFORE OTHER altered()"
        self.other.altered()
        print "CHILD, AFTER OTHER altered()"

son = Child()

son.implicit()
son.override()
son.altered()

Result

C:UsersI******python_***>python ex44e.py
OTHER implicit()
CHILD override()
CHILD, BEFORE OTHER altered()
OTHER altered()
CHILD, AFTER OTHER altered()

这段代码没有使用名字Parent，因为没有父子的is-a关系了。这是一个has-a关系，在这个关系中Child has-a Other被用来保证代码的正常工作。

什么时候用继承，什么时候用包含？

继承通过创建一种机制，让你在基类中有隐含的功能来解决这个问题。而包含则是通过给你的模块和函数可以在其他类别被调用来解决这个问题。

3个指导性原则：
1) 不惜一切代价避免多重继承，因为它太复杂太不可靠。如果你必须要使用它，那么一定要知道类的层次结构，并花时间找到每一个类是从哪里来的。
2) 将代码封装为模块，这样就可以在许多不同的地方或情况使用。
3) 只有当有明显相关的可重用的代码，且在一个共同概念下时，可以使用继承。

Ex45: You Make a Game

Ex46: A Project Skeleton

安装包下载地址

pip – http://pypi.python.org/pypi/pip
distribute – http://pypi.python.org/pypi/distribute
nose – http://pypi.python.org/pypi/nose/
virtualenv – http://pypi.python.org/pypi/virtualenv

解压

执行

C:UsersI******>cd Downloadspip-18.0

C:UsersI******Downloadspip-18.0>python setup.py install

其余安装方法类似。¹⁹

创建项目骨架

C:UsersI******>cd python_***

C:UsersI******>python_***>mkdir projects

C:UsersI******>python_***>cd projects

C:UsersI******>python_***projects>mkdir skeleton

C:UsersI******>python_***projects>cd skeleton

C:UsersI******>python_***projectsskeleton>mkdir bin NAME tests docs

C:UsersI******>python_***projectsskeleton>type nul> NAME/__init__.py

C:UsersI******>python_***projectsskeleton>type nul> tests/__init__.py

目录

Test

C:UsersI******python_***projectsskeleton>nosetests
.
----------------------------------------------------------------------
Ran 1 test in 0.040s

OK

使用项目骨架

1) 拷贝这份骨架目录，把名字改成你新项目的名字。
2) 再将NAME模组更名为你需要的名字，它可以是你项目的名字，当然别的名字也行。
3) 编辑setup.py让它包含你新项目的相关信息。
4) 重命名tests/NAME_tests.py，让它的名字匹配到你模组的名字。
5) 使用nosetests检查有无错误。
6) 开始写代码吧。

19 windows下下载安装python、 pip、nose

Ex47: Automated Testing

Ex48: Advanced User Input

Ex49: Making Sentences

Ex50: Your First Website

Ex51: Getting Input from a Browser

Ex52: The Start of Your Web Game