1. 选教程
看到crossin的编程教室python教程还不错。以这个为主要学习内容。
python简单实验的编辑器用IDLE已经足够，更好的网上有推荐PyCharm(又是JetBrain的产品)的。
2. 站队
python学习需要站队，有2.7版本有3.6版本。我选择优先3.6，因为语法感觉更规范，当然2系列的语法也必须看懂，要不然以前的很多成果无法使用的。
3. if语句，while语句都不是像C语言使用大括号来界定其后的block的，而是采用冒号和后面的代码缩进来实现的。
4. for的反人类写法
最反人类的写法是这个
for i in range(1,101):
print i
sum = sum + i
print sum
打印结果是1~100， 而不是1~101. 最后sum是5050. 内心疯狂了有木有，有木有。
5. 关于字符串
以下都是对的
print "It's good" 外面双引号里面就用单引号，反过来一样
print "It\'s good"
#同样支持转义字串
print "You are a \"good\" man"
超级无敌的三个引号，里面的内容原样显示，包括换行：
print """
Stay hungry,
stay foolish.
-- Steve Jobs
"""
再看几个字符串的例子，一看就懂
print "very "+ str1
print "price is %.2f" %4.99
yourname="Stephen"
print "I love you, %s." %yourname
print "Today is %s." %'Friday'
6. for的嵌套
看个例子
*
**
***
****
*****
代码实现：
for j in range(0,5):
for i in range(0,j+1):
print "*",
print ""
注意到上面的逗号是不换行，在python3里要写成print('*', end=' ')
另外看一个例子，参数有多个的
print "%s's score is %d" % ('Mike', 87)
7. 布尔型的微小的反人类设计
在python中，其他类型转成 bool 类型时，以下数值会被认为是False：
为0的数字，包括0，0.0
空字符串，包括''，""
表示空值的None
空集合，包括()，[]，{}
其他的值都认为是True。
其实这个规则还好了，0是False而1是True是计算机界的传统。
None是python中的一个特殊值，表示什么都没有。感觉有点像Java中的null
8. 函数
先看简单的例子，很小白：
def sayHello():
print ("well, hello")
sayHello()
sayHello()
sayHello()
明白了吧,def是定义一个函数体
再来个带参数的
def plusint(num1, num2):
print (int(num1) + int(num2))
print ("please input n1")
n1 = input()
print ("please input n2")
n2 = input()
sum = plusint(n1,n2)
print (sum)
9. 条件if , else, elif
看下面的例子足够
print ("please input a")
a = input()
if a=="1":
print ("you input 1")
elif a=="2":
print ("you input 2")
else:
print ("you input other")
和其它语言一样， if也可以嵌套
10. 列表list
a = [1,1,2,3,5,8,13]
print (a)
b = range(10,15)
print (b)
c = ["meat","egg","fish"]
print (c)
d = [365, True]
print (d)
#delete second item in list c
del c[1] 注意这是删除指令，好熟悉,egg被删除了
for i in c:
print (i)
list中的每个元素都对应一个递增的序号。与现实中习惯的序号不同在于，计算机中的计数通常都是从0开始，python也不例外。如果你记不清这个而导致了错误，请去听一下孙燕姿的《爱从零开始》
#猜点球游戏,重点是choice方法的使用
from random import choice
print ("Choose one side to shoot:")
print ("left, center, right")
you = input()
print ("You kicked " + you)
direction = ["left", "center", "right"]
com = choice(direction) 从list中取出一个元素
print ("Computer saved" + com)
if you != com:
print ("Goal!")
else:
print ("Oops...")
另外关于list的负数表示，颠覆三观，实际是从右往左倒着数的意思：
>>> m = [1,3,5,7,9]
>>> m[-1]
9 倒数第1个元素是9
>>> m[-2]
7 倒数第2个元素是7
>>> m[2:4] 请注意，冒号这是切片操作符
[5, 7] 第2和第3个元素，从0计数
切片操作符是在[]内提供一对可选数字，用:分割。冒号前的数表示切片的开始位置，冒号后的数字表示切片到哪里结束。同样，计数从0开始。
注意，开始位置包含在切片中，而结束位置不包括。
11. 字符串的分割split
sentence1 = "I'm a student."
a1 = sentence1.split();
print (a1)
sentence2 = "3.1.4.1.5"
a2 = sentence2.split(".")
print (a2)
执行结果：
["I'm", 'a', 'student.']
['3', '1', '4', '1', '5']
12. 字符串的连接join
看例子就懂了
s=";"
t = ""
li = ["apple", "pear", "orange"]
fruit1 = s.join(li)
print (fruit1)
fruit2 = t.join(li)
print (fruit2)
执行结果：
apple;pear;orange
applepearorange
以上太费事了，简洁一点就这么写
result = "".join(['hello', 'world'])
结果是helloworld
13. 字符串运算总结：
1） 遍历
通过for...in可以遍历字符串中的每一个字符。
word = 'helloworld'
for c in word:
print c
2）索引访问
通过[]加索引的方式，访问字符串中的某个字符。
print word[0]
print word[-2]
与list不同的是，字符串不能通过索引访问去更改其中的字符。
word[1] = 'a'
这样的赋值是错误的。
3） 切片
通过两个参数，截取一段子串，具体规则和list相同。
print word[5:7]
print word[:-5]
print word[:] 全都打印出来了
4.）连接字符
join方法也可以对字符串使用，作用就是用连接符把字符串中的每个字符重新连接成一个新字符串。
newword = ','.join(word)
14. 文件读和写
#写文件例子
f1name = "1.txt"
f1 = open(f1name)
data = f1.read()
print (data)
f1.close()
#读文件例子
f2name = "2.txt"
f2 = open(f2name, "w")
f2.write("a new century");
f2.close()
readline() #读取一行内容
readlines() #把内容按行读取至一个list中
15. break和continue
while True:
a = input()
if a == 'hello':
print ("hello to you")
continue 继续循环
if a == 'bye':
break 中断
16. 异常
支持try: except:捕获异常
try:
f = open('non-exist222.txt')
print ('File opened!')
f.close()
except:
print ("maybe file not exist")
17. 字典（像是java里的map, key-value对）
score={
"Lucy":95,
"Lily":98
}
print (score)
del (score["Lucy"])
print (score)
18. 模块
import random 直接用import
print (random.randint(1,10))
print (random.choice([1,3,5]))
dir (random)
from math import pi 用from...import...
print(pi)
19. 方法的缺省参数
#def func(a=2,b)这是错误的，缺省的参数应该在最后
def func(a,b=5):
print (a+b)
func(3)
func(2,8)
20 综合例子 查天气
查天气就是发http request, 提交上城市的code, 然后返回json描述天气
import urllib.request
import json
from city import city 这里的city.py是一个字典，用于城市中文和城市代码对应关系的
def readweather():
cityname = input("which city?\n");
citycode = city.get(cityname)
#citycode = "101120201"
if citycode:
try:
url = ("http://www.weather.com.cn/data/cityinfo/%s.html" %citycode)
print ("url=\n" + url)
content = urllib.request.urlopen(url).read()
jsondata = json.loads(content) 看，这一句话就整成json了
print (content)
print ()
print (jsondata)
result = jsondata["weatherinfo"] 这一句话就把json节点取出来了
str_temp = ("weather is%s, and degree is:\nfrom %s to %s")%(
result["weather"], 把json的子节点取出来，这是天气概况
result["temp1"], 最低温度
result["temp2"] 最高温度
)
print (str_temp)
except:
print ("query fail") 可能网络服务异常或没网
else:
print ("city not found!") 没有找到合适的city
另外附上几行city.py内容：
city = {
'北京': '101010100',
'海淀': '101010200',
｝
运行结果是这样的：
21. 面向对象
同样python支持OOP，看来简单的例子
class MyClass:
name = "Tom"
def sayHi(self): 这个self是个保留字，等同于java里的this. 是要显式的传递的，和java不一样的, 其实有点繁琐，
print ("Hi %s"%self.name)
def sayGoodbye(self, something):
print ("Goodbye %s"%something);
mc = MyClass()
mc.name="Lily"
mc.sayHi()
mc.sayGoodbye("now")
注意：
__init__函数会在类被创建的时候自动调用，用来初始化类
22. and和or的技巧
好吧，我讨厌这些技巧，看一眼知道意思就行了。
and-or真正的技巧在于，确保a的值不会为假。最常用的方式是使 a 成为 [a] 、 b 成为 [b]，然后使用返回值列表的第一个元素：
a = "123"
b = "hell"
c = (True and [a] or [b])[0]
print (c)
打印的是123
抛开绕人的and和or的逻辑，你只需记住，在一个bool and a or b语句中，当bool条件为真时，结果是a；当bool条件为假时，结果是b。
有学过c/c++的同学应该会发现，这和bool?a:b表达式很像。
我还是讨厌这种让人看不懂的用法
23. 元组(tuple)
其实 tuple（音:它跑）也译作数组
元组（tuple）也是一种序列，和我们用了很多次的list类似，只是元组中的元素在创建之后就不能被修改。---好吧，我可以把它当作list常量吗?
position = (1, 2)
geeks = ('Sheldon', 'Leonard', 'Rajesh', 'Howard')
print (position)
print (geeks)
#都是元组的实例。它有和list同样的索引、切片、遍历等操作
上面讲的太高深和不接地气了，其实：
其实我们之前一直在用元组，就是在print语句中：
print '%s is %d years old' % ('Mike', 23)
('Mike', 23)就是一个元组。这是元组最常见的用处。
23. math库
和其它语言一样，提供了许多的数学库，千万要用，不要自己再发明轮子了
import math
print ("pi="+ str(math.pi))
print ("e="+ str(math.e))
print ("2^32=" + str( math.pow(2,64) ) )
print ("sqrt " + str ( math.sqrt(2) ))
24. 正则表达式
import re
text = "Hi, I am Lucy"
m = re.findall(r"[Hh]i", text)
if m:
print (m)
else:
print ("not match")
结果输出['Hi']
r"hi"
这里字符串前面加了r，是raw的意思，即不使用转义
今天主要说两个符号“.”和“*”，顺带说下“\S”和“?”。
“.”在正则表达式中表示除换行符以外的任意字符。在上节课提供的那段例子文本中：
Hi, I am Shirley Hilton. I am his wife.
如果我们用“i.”去匹配，就会得到
['i,', 'ir', 'il', 'is', 'if']
你若是暴力一点，也可以直接用“.”去匹配，看看会得到什么。
与“.”类似的一个符号是“\S”，它表示的是不是空白符的任意字符。注意是大写字符S。
--
在很多搜索中，会用“?”表示任意一个字符，“*”表示任意数量连续字符，这种被称为通配符。但在正则表达式中，任意字符是用“.”表示，而“*”则不是表示字符，而是表示数量：它表示前面的字符可以重复任意多次（包括0次），只要满足这样的条件，都会被表达式匹配上。
结合前面的“.*”，用“I.*e”去匹配，想一下会得到什么结果？
['I am Shirley Hilton. I am his wife']
结果是['ley Hilton. I am his wife']，即贪婪匹配
再換成这个"l.*?e"， 懒惰匹配，得到['le', 'lton. I am his wife']
这里不说太多了，记不住，做爬虫实战的时候，一定会返回来继续看的。
25. 再议随机数
1)产生随机整数
num = random.randint(1,100)
2)产生随机小数，
num2 = random.uniform(5,6.5)
print (num2)
2)关于choice
random.choice(seq)
从序列中随机选取一个元素。seq需要是一个序列，比如list、元组、字符串。
random.choice([1, 2, 3, 5, 8, 13]) #list
random.choice('hello') #字符串
random.choice(['hello', 'world']) #字符串组成的list
random.choice((1, 2, 3)) #元组
3) 带step的高级用法
random.randrange(start, stop, step)
random.randrange(1, 9, 2)
就是从[1, 3, 5, 7]中随机选取一个。
random.randrange(start, stop, step)其实在效果上等同于
random.choice(range(start, stop, step))
4）取样
random.sample(population, k)
从population序列中，随机获取k个元素，生成一个新序列。sample不改变原来序列
26. 关于时间time
import time
starttime = time.time() 一个很大的小数
print (starttime)
time.sleep(2) 延时2秒
print ("2 secs arrived")
27. 调试程序
traceback信息就是报错，也可以自己在合适的地方print
28. python shell的使用
提示符>>>就不再提了，关注一下返回上一个命令不是像DOS命令行一样按上箭头，而是alt+p 组合
29. 序列化pickle
存到文件和从文件中取出
import pickle
test_data = ["save me!", 123.456, True]
f = open("mypickle.txt", "wb")
pickle.dump(test_data, f)
f.close()
f2 = open("mypickle.txt", "rb")
newdata = pickle.load(f2)
f2.close()
print (newdata)
运行结果是：
['save me!', 123.456, True]
30. 列表解析List Comprehension
让代码更简洁的办法：
list_1 = [1, 2, 3, 5, 8, 13, 22]
list_2 = [i for i in list_1 if i % 2 == 0]
print list_2
输出
[2, 8, 22]
31. 带参数的函数
光看例子不说话，体会一下
def func(arg1=1, arg2=2, arg3=3):
print arg1, arg2, arg3
调用
func(2, 3, 4)
func(5, 6)
func(7)
输出为
2 3 4
5 6 3
7 2 3
好了，你一定秒懂。
上次说的 func(*args) 方式是把参数作为 tuple 传入函数内部。而 func(**kargs) 则是把参数以键值对字典的形式传入。
示例：
def printAll(**kargs):
for k in kargs:
print k, ':', kargs[k]
printAll(a=1, b=2, c=3)
printAll(x=4, y=5)
输出：
a : 1
c : 3
b : 2
y : 5
x : 4
在混合使用时，首先要注意函数的写法，必须遵守：
带有默认值的形参(arg=)须在无默认值的形参(arg)之后；
元组参数(*args)须在带有默认值的形参(arg=)之后；
字典参数(**kargs)须在元组参数(*args)之后。
32. 兰布达表达式
来看一个复杂一点的例子，把 lambda 表达式用在 def 函数定义中：
def fn(x):
return lambda y: x + y
a = fn(2)
print a(3)
输出：
5
这里，fn 函数的返回值是一个 lambda 表达式，也就等于是一个函数对象。当以参数2来调用 fn 时，得到的结果就是：
lambda y: 2 + y
33. 变量的作用域
def func(x):
print ("X in the beginning of func(x):", x)
x = 2
print ("X in the end of func(x):", x)
x = 50
func(x)
print ("X after calling func(x): ", x)
print()
def func2():
global x
#建议在写代码的过程中，显式地通过 global 来使用全局变量，避免在函数中直接使用外部变量。
print ("X start func(x):", x)
x = 3
print ("X end func(x):",x)
func2()
运行结果
X in the beginning of func(x): 50
X in the end of func(x): 2
X after calling func(x): 50
X start func(x): 50
X end func(x): 3
34. 使用map
map（）的使用方法形如map(f(x),Itera).
def triple_func(x):
return x * 3
#lst_2 = list( map(triple_func, lst_1) )
lst_2 = list( map(lambda x: x*3, lst_1) )
print (lst_2)
35. 使用reduce
reduce（）的使用
reduce（）的使用方法形如reduce(f(x),Itera).对，它的形式和map()函数一样。不过参数f（x）必须有两个参数。reduce()函数作用是：把结果继续和序列的下一个元素做累积计算。
from functools import reduce
lst = range(1, 101)
def add(x, y):
return x + y
print (reduce(add, lst))
36. 多线程
暂不学了