重拾編程樂趣——我的Python筆記
早就想學學python了，但是一直沒有勇氣，一個偶然的機會，感謝圖靈教育送了我一本《父與子的編程之旅：與小卡特一起學Python》，讓我有激情、有動力學下去。
而我也很爭氣，很神奇的讀完了這本書，要知道我現(xiàn)在很少讀web相關外的技術書籍的，我給這本書的評價是5星，很棒的一本入門書，淺顯易懂，非常適合新手來閱讀，而且這不是一本講python的書，而是一本講編程的書。
感謝這本書，感謝python讓我重新找回了編程的樂趣，終于又有了那種剛剛學習C語言時候的感覺了，所以我決定寫下這篇文章，算是我的讀書筆記吧，也是給自己做個備忘，主要是對這本書和python的總結。
正文從這里開始，下面的內(nèi)容都會按照書的目錄結構來進行記錄。
出發(fā)吧
安裝python
學習python的第一步是安裝python，可以到python的官網(wǎng)下載，這里有很多版本，選擇合適的版本和平臺下載即可
我選擇是2.x，我下載時最新的版本是2.7.12，windows平臺的安裝就是一路下一步即可安裝好。
交互模式
在開始菜單搜索或找到python安裝目錄，打開IDLE(Python GUI)，即進入了python的交互模式，
交互模式的意思就是，你可以輸入一行代碼，然后按下回車，python會立馬告訴你執(zhí)行結果，這個特別好用。
print "Hello World"
上面代碼的執(zhí)行結果就是打印出Hellow World，print是python的輸出語句。
第一個程序
打開菜單->File->New File（ctrl + N），就可以進入文本編輯模式，這里可以輸入多行代碼，比如鍵入如下代碼：
print "Hello World";
print 22 + 10;
然后保存到某個目錄，名字為xxx.py，菜單->Run->Run Module（F5），即可執(zhí)行上面的代碼。
記住內(nèi)存和變量
每個程序都是由下面三個部分組成：
- 輸入（input）
- 處理輸入（process）
- 輸出（ouput）
名字
在python中聲明變量像下面這樣，python中的變量都類似于引用，也是沒有類型的。
num = 123;
str = "123";
基本數(shù)學運算
python可以完成基本的數(shù)學運算，當初python設計出來就是為了完成數(shù)學運算。
四大基本運算
python可以完成四大基礎運算，如下所示：
print 3 + 2 # 4
print 3 - 2 # 1
print 3 * 2 # 6
print 3 / 2 # 1
print 3.0 / 2 # 1.5
在前面的3 + 2中，3 和 2稱為操作數(shù)，+ 稱為操作符。
python的運算順序和數(shù)學中一樣，乘除高于加減，如果要改變運算順序，和數(shù)學中一樣的，需要添加括號。
print 3 + 1 * 2 # 6
print (3 + 1) * 2 # 8
指數(shù)和求余數(shù)
在python中指數(shù)可以像下面這樣表示
print 3 ** 5 # 3 * 3 * 3 * 3 * 3 = 243
求余數(shù)使用%，像下面這樣，注意和除法區(qū)分開
print 7 % 2 # 1
print 7 / 2 # 3
自增和自減
python中沒有想c++中的自增和自減（i++），要實現(xiàn)一個數(shù)的自增的像下面這樣
num = 2
num += 1 # 3
num -= 1 # 2
上面的代碼和下面的代碼效果是一樣的
num = 2
num = num + 1 # 3
num = num - 1 # 2
數(shù)據(jù)的類型
python中的變量雖然沒有類型，但是值是有類型的。
改變類型
可以通過下面的函數(shù)來改變數(shù)據(jù)類型
- float() 從一個字符串或整數(shù)創(chuàng)建浮點數(shù)
- int() 從一個字符串或浮點數(shù)創(chuàng)建一個新的整數(shù)
- str() 從一個書或其他任何類型創(chuàng)建一個新的字符串
三個函數(shù)都會返回一個新的值，而不會改變原來的值，因為值是不可變的
a = 24
b = float(a) # 24.0
c = 38.0
d = int(c) # 38
類型檢查
python中的變量是沒有類型，那么如何檢查一個變量當前的值是什么類型的呢？答案就是type函數(shù)。
a = 24
type(a) # <type 'int'>
b = 24.0
type(b) # <type 'float'>
c = 'str'
type(c) # <type 'str'>
輸入
對一個程序來說最重要的一點就是輸入了，如果電腦不能響應輸入，那么就一點用處都沒有了。
raw_input
raw_input函數(shù)可以從用戶哪里得到一個字符串
print "請輸入："
some = raw_input();
print "你的輸入是：", some
上面的程序會輸出你輸入的任何字符
raw_input還可以接受一個參數(shù)，這個參數(shù)會被作為輸出，上面的程序可以簡化為下面這樣
some = raw_input("請輸入：")
print "你的輸入是：", some
print用來給打印輸出，簡單點說就是向控制臺打印一些東西
print "yan"
print "yan"
print "yan"
上面的三條語句會得到下面的輸出
yan
yan
yan
如果想在同一行打印的話可以在結尾加上逗號
print "yan",
print "yan",
print "yan"
上面的語句會得到下面的輸出
yan yan yan
中間會有一個空格，print還支持多個參數(shù)，中間用逗號分隔
print "yan", "yan", "yan"
上面的語句會得到下面的輸出，中間也有一個空格
yan yan yan
來自互聯(lián)網(wǎng)的輸入
可以python的內(nèi)置庫，可以獲得從互聯(lián)網(wǎng)的而輸入，下面的代碼可以輸出我的博客內(nèi)容
import urllib2
file = urllib2.urlopen("http://yanhaijing.com")
msg = file.read()
print msg
判斷在判斷
每次程序執(zhí)行都輸出一樣的東西沒什么意思，需要有判斷分支才有意思。
測試，測試
人之所以有智能是因為人能夠思考，面對選擇是能做出選擇，那么如何讓計算機也能夠做出選擇呢？那就是測試，我們需要做一些測試，然后決定接下來做什么。這些測試可能包括如下問題：
- 這兩個東西相等嗎？
- 其中一個是不是小于另一個？
- 其中一個是不是大于另一個？
完成測試并更根據(jù)結果做出測試稱之為分支，在python中使用if來進行測試：
if a == 1
python中的代碼塊比較奇葩，不是靠大括號而是縮進來確定范圍的，聲明一個代碼塊時就加一個冒號，就像下面這樣：
if a == 1:
print "a等于1"
print "代碼塊"
print "這里不是代碼塊了"
python中的elseif和else像下面這樣：
if a == 1:
print "a等于1"
elif a == 2:
print "a等于2"
else:
print "a等于其他值"
比較操作符
python中的比較操作符不只有等于還有其他，比如大于小于等，完整的列表如下
- == （等于）
- < （小于）
-
（大于）
- <= （小于等于）
-
= （大于等于）
- != （不等于）
邏輯運算符
python中也可以表達邏輯演算中的與 或 非，分別用下面的符號表示
- and
- or
- not
邏輯運算符的用例如下
if a != 1 and a != 2:
print "a不等于1和2"
轉圈圈
來說說循環(huán)，循環(huán)分為兩種，計數(shù)循環(huán)和條件循環(huán)。
計數(shù)循環(huán)
python中的計數(shù)循環(huán)使用for in，語法如下所示，和c語言有很大差別
for looper in [1, 2, 3, 4]:
print looper
[1, 2, 3, 4]是列表，python中類似數(shù)組的東西，如果循環(huán)次數(shù)很多，可以用range來代替
for looper in range(1, 5):
print looper
range還可以之傳入一個參數(shù)，比如range(5)等同于 range(0, 5)
如果改變循環(huán)的步長，可以傳入第三個參數(shù)，range(0, 6, 2)等同于 [0, 2, 4]，其中2就是步長
步長還可以是負數(shù)，range(6, 0, -2)，等同于[6, 4, 2]
條件循環(huán)
條件循環(huán)的意思就是判斷某個條件是否為真，如果為真就一直循環(huán)下去，使用while關鍵字
while 1 == 1:
print "永遠也不會停下來"
跳出循環(huán)
跳出循環(huán)可以使用break和continue，分別是退出循環(huán)和退出本次循環(huán)。
全是為了你——注釋
對于程序而言注釋必不可少，python的注釋和類c語言不一樣，是使用#號，#號后面的都被當作注釋，像下面這樣
# 我是注釋我是注釋
print 213 # 行末注釋
python中沒有多行注釋，只能用單行注視模擬多行注釋，像下面這樣
# ***********
# 多行注釋
# 多行注釋
# ***********
收集起來——列表和字典
python中存取數(shù)據(jù)有兩種類型的東西，一種叫做列表，一種叫做字典。
列表
python中的列表和數(shù)組很像，創(chuàng)建列表的語法如下所示：
list = [1, 2, 3, 4]
print list[0] # 1
可以用append向列表添加一個元素
list = []
list.append(1)
print list # 1
列表分片
python中想從列表中獲取列表片段，需要用到分片(slicing)
list = ['a', 'b', 'c', 'd']
print list[1:3]
>>> ['b', 'c']
分片的語法可以簡寫，可以省略冒號前后的數(shù)字
list = [1, 2, 3, 4, 5]
print list[:]
>>> [1, 2, 3, 4, 5]
print list[3:]
>>> [4, 5]
print list[:3]
>>> [1, 2, 3]
需要注意分片會返回一個新的列表，不會修改原列表。
in關鍵字
要查找摸個元素是否在列表中，可以使用in
list = ['a']
print 'a' in list
>>> True
del關鍵字
del 從列表刪除指定位置元素
list = ['a', 'b', 'c']
del list[0]
print list
>>> ['b', 'c']
列表方法
列表有很多方法，上面的append就是其中之一
- append
- extend
- insert
- remove
- pop
- index
- sort
- reverse
- sorted
append用來在列表末尾添加一個元素
list = [1]
list.append(2)
print list
>>> [1, 2]
extend在列表末尾添加多個元素
list = [1]
list.extend([2, 3])
print list
>>> [1, 2, 3]
insert在指定位置插入元素
list = [1, 2, 3]
list.insert(1, 'a')
print list
>>> [1, 'a', 2, 3]
remove從列表中刪除指定元素，如果刪除的元素不在列表中會報錯，可以和in關鍵字配合使用
list = [1, 2, 3]
list.remove(2)
print list
>>> [1, 3]
注意：和del區(qū)分，del用來刪除指定的索引位置元素
pop去除列表中最后一個元素
list = [1, 2, 3]
a = list.pop()
print a
print list
>>> 3
>>> [1, 2]
index查找指定元素在列表中的索引，如果刪除的元素不在列表中會報錯，可以和in關鍵字配合使用
list = [1, 2, 3]
print list.index(3)
>>> 2
注意：和in區(qū)分開，in會返回布爾值，index會返回索引
sort用來給列表排序
list = [4, 2, 1]
list.sort()
print list
>>> [1, 2, 4]
如果想倒敘排列列表，可以給sort傳一個參數(shù)
list = [1, 2, 3]
list.sort(reverse = True)
print list
>>> [3, 2, 1]
注意：sort會修改原來的列表，而不是創(chuàng)建一個新的列表，所以下面的操作不正確
print list.sort() # 不正確的做法
>>> None
list.sort() # 需要分兩步
print list
reverse翻轉列表，逆序排序數(shù)組還可以用這個
list = [1, 2, 3]
list.reverse()
print list
>>> [3, 2, 1]
sorted輸一個系統(tǒng)函數(shù)，而不是數(shù)組函數(shù)，可以得到一個列表的有序副本，而不會影響原來的列表
list = [3, 2, 1]
nlist = sorted(list)
print list
print nlist
>>> [3, 2, 1]
>>> [1, 2, 3]
循環(huán)列表
列表可用for循環(huán)來遍歷
for i in [1, 2, 3]:
print i
>>> 1
>>> 2
>>> 3
不可變的列表
pythton中的列表是可變類型，python中有一種不可變的列表——元組，元組的語法如下
tuple = (1, 2, 3) # 不可增刪改
字典
python中的另一個種集合類型就是字典，類似其他語言中的關聯(lián)數(shù)組或哈希表，分為鍵和值，通過鍵來存取值。
phoneNumbers = {'yan': 133}
print phoneNumbers['yan']
>>> 133
phoneNumbers['hai'] = 666;
print phoneNumbers['hai']
>>> 666
字典方法
字典也有一些方法
- keys
- values
- clear
keys方法可以列出字典總的全部鍵值
dic = {'yan': 1, 'hai': 2}
print dic.keys()
>>> ['hai', 'yan']
values方法返回字典中的全部值
dic = {'yan': 1, 'hai': 2}
print dic.values()
>>> [2, 1]
如果需要字典返回有序的鍵值，可以對返回的鍵值列表進行排序
clear用來刪除字典中的而所有條目
dic = {'yan': 1, 'hai': 2}
dic.clear()
print dic
>>> {}
del & in
del用來刪除字典中的數(shù)據(jù)
dic = {'yan': 1}
del dic['yan']
print dic
>>> {}
檢查某個關鍵字是否在字典中使用in
dic = {'yan', 1}
print 'yan' in dic
>>> True
函數(shù)
當程序變大以后就需要一些方法來把程序分解成更小的部分，在python中主要有三種方法：
- 函數(shù)——就像代碼的積木，可以反復的使用
- 對象——把程序中的各個部分描述為自包含的單元
- 模塊——包含程序各部分的獨立文件
創(chuàng)建一個函數(shù)需要使用def關鍵字
def hello():
print 'hello world'
hello()
>>> 'hello world'
函數(shù)可以有多個參數(shù)，中間用逗號分隔
def hello(who):
print 'hello', who
hello()
>>> hello yan
函數(shù)可以有返回值
def add(x, y):
return x + y
add(1, 2)
>>> 3
函數(shù)內(nèi)部的變量都是局部變量，在函數(shù)外部不能訪問
def test():
x = 1
print x
x = 10
print x
test()
>>> 10
>>> 1
在函數(shù)中可以訪問全局變量，但不可修改，修改會創(chuàng)建一個局部變量
def test2():
y = 10
print y
y = 1
test2()
print y
>>> 10
>>> 1
在函數(shù)內(nèi)部想強制訪問全局變量，需要使用global
def test3():
global z
z = 10
print z
z = 1
test3()
print z
>>> 1
>>> 10
>>> 10
對象
對象可以把函數(shù)和數(shù)據(jù)收集在一起。對象可以包含屬性和動作。
舉個例子就是球，可以操作一個球，踢球，撿球，這些操作成為動作；球的顏色，大小稱為球的屬性。
python中稱為對象的屬性和方法。
創(chuàng)建對象
python中創(chuàng)建對象分為兩步，第一步是創(chuàng)建對象的描述——類；第二步使用類來創(chuàng)建一個真正的對象。
# 定義對象描述
# __init__ 初始化對象方法
# setColor 對象的方法
class Ball:
def __init__(self, color):
self.color = color
def setColor(self, color):
self.color = color
# 實例化對象
ball = Ball('red');
print ball.color
ball.setColor('green')
print ball.color
# python中的對象可動態(tài)添加屬性，這一點和java不一樣
ball.size = 'big'
>>> red
>>> green
“魔法”方法
python中對象有一些魔法方法，上面的__init__就是，還有一個魔法方法是__str__，可以自定義對象的打印文本
class Ball:
def __str__():
return 'yanhaijing.com'
ball = Ball()
print ball
>>> yanhaijing.com
self
python的對象方法調(diào)用時，的第一個參數(shù)表示調(diào)用的對象，self是約定俗成的做法，不是必須的。
隱藏數(shù)據(jù)
python也不支持私有的屬性，這一點和js一樣。
繼承
在面向對象編程中，類可以從其他類繼承屬性和方法。
class People:
__init__(self, name):
self.name = name
talk():
# pass作為占位符，可以表示為空函數(shù)
pass
# 繼承People
class Teacher(People):
__init__(self, name):
# 調(diào)用父類方法
People.__init__(self, name)
模塊
如果一個東西可以由幾部分組成，我們就可以說這個東西是模塊化的。樂高積木是最直觀的例子了。
python中每個文件都是一個模塊，模塊意味著分治，可以把一個復雜的系統(tǒng)拆分成由簡單的部分組成，這在大型程序中是非常有意義的。
模塊是更高維度的抽象，可以把一組功能類似的函數(shù)，都放到一個模塊中，一個復雜的模塊也可以由更多簡單的模塊組成。
創(chuàng)建模塊
模塊就是一個文件，文件中的函數(shù)，變量都可以被別的模塊引用，也就是說模塊的一切的公開的
# module1.py
qiu = 1
def hello():
return 'hello'
上面定義了一個模塊，有一個公開的屬性qiu和一個公開的函數(shù)hello。
使用模塊
在其他文件中可以用import關鍵字引用模塊。
import module1
print module1.qiu
print module1.hello()
>>> 1
>>> hello
還可以換一種寫法
from module1 import hello
print hello()
>>> hello
標準模塊
python中內(nèi)置了很多系統(tǒng)函數(shù)，要使用這些函數(shù)需要引用相應的模塊，比如：
- time
- 隨機數(shù)
time模塊能夠獲取你的計算機時鐘的信息，其中比較常用的就是sleep可以用來讓程序暫停一會
import time
time.sleep(1)
random模塊用于生成隨機數(shù)
import random
print random.randint(0, 100) # 1-100之間隨機數(shù)
print random.random() # 0-1之間隨機數(shù)
>>> 4
>>> 0.5456454545
打印格式化與字符串
這一章講了如何打印出格式化的內(nèi)容。
換行
可以在字符串中插入換行
print "hello \nworld"
>>> hello
>>> world
水平間隔——制表符
看了這本書我才知道制表符還有這個功能，一個制表符會占據(jù)8個字符的間隔，但是會和前面的字符串合并
print 'aaa\txyz'
print 'aaaa\txyz'
print 'aaaaa\txyz'
>>> aaa xyz
>>> aaaa xyz
>>> aaaaaa xyz
字符串插入變量
python中在字符串中插入變量稱為格式化字符串，使用百分號(%)。
str = '3'
print '1%s3' % str
>>> 123
%s表示插入字符串，還可以用%i用來表示整數(shù)，%f表示浮點數(shù)，都成為格式化字符串，用來指示如何顯示 變量。
數(shù)字格式化
數(shù)字格式化可能是最復雜的部分了
%d和%i用來格式化整數(shù)，如果傳入的是小數(shù)，則會進行截斷
number = 12.55
print '%i' % numver
print '%d' % numver
>>> 12
>>> 12
%f或%F用來格式化浮點數(shù)
number = 12.1234
print '%f' % number # 默認顯示六位小數(shù)
>>> 12.123400
print '%.2f' # 顯示兩位小數(shù)，末尾四舍五入
>>> 12.12
print '%+f' % number #強制顯示證號
>>> +12.123400
# 如果希望正負數(shù)的列表對齊，但是整數(shù)前沒有正號，可使用空格
number1 = -98.12
number = 98.12
print '% .2f' % number1
print '% .2f' % number2
>>> -98.12
>>> 98.12
%e和%E用來格式化E記法的數(shù)字
number = 12.1234
print '%e' % number
>>> 1.212340e+01
print '%.2e'
>>>> 1.2e+01
%g和%G用來自動表示為浮點數(shù)或E記法
number1 = 12
number2 = 1234567890
print '%g' % number1
print '%g' % number2
>>> 12
>>> 1.23456e+09
如果有多個格式化的字符串，需要使用元組
n1 = 1
n2 = 2
print '%i-%i' % (n1, n2)
>>> 1-2
還可以把格式化的字符串賦值給變量
str = '%.2f' % 12.123
print str
>>> 12.12
格式化新方法
python2.6中引入了格式化的新方法，format函數(shù)
print '{0:.1f}-{1:.1f}'.format(12.12, 11.12)
>> 12.1-11.1
格式化的符號用大括號括起來，冒號前面代表參數(shù)的索引。
更多字符串處理
如果想分解字符串使用split
list = '1,2,3,4'.split(',')
print list
>>> ['1', '2', '3', '4']
連接字符串使用join方法
list = [1, 2, 3, 4]
str = ''.join(list)
print str
>>> 1 2 3 4
搜索字符串的方法有很多
- startswith()
- endswith()
- in
- index()
下面來距離各個方法的用法
'abc'.startswith('a')
>>> True
'abc'.endswith(c)
>>> True
'b' in 'abc'
>>> True
'abc'.index('b')
>>> 1
刪除字符串的一部分使用strip
str = 'abcdef'
print str.strip('a')
>>> bcdef
str = ' abc '
print str.strip() # 沒有參數(shù)刪除空格
>>> abc
改變大小寫使用lower和upper
print 'abc'.upper()
>>> 'ABC'
print 'ABC'.lower()
>>> 'abc'
文件輸入與輸出
這一章講了python如何讀寫文件。
文件的屬性包括文字，類型，位置和大小等。
將一組文件組織在一起得東西稱為目錄，目錄還可以組織目錄，稱為子目錄。
打開文件
對文件進行操作之前需要先打開文件
file = open('test.txt', 'r'); # 讀文件
file = open('test.txt', 'w'); # 寫文件
file = open('test.txt', 'a'); # 追加文件
讀文件
讀文件之前需要先打開文件，然后使用readlines將文件讀到列表中，列表的每一項是文件中的一行
file = open('test.txt', 'r'); # 讀文件
lines = file.readlines()
print lines
file.close() # 一定不要忘記關閉文件
>>> ['line1\n', 'line2\n', 'line3']
還可以使用readline每次讀取一行文件
file = open('test.txt', 'r'); # 讀文件
line1 = file.readline()
line2 = file.readline()
print line1
print line2
file.close()
>>> line1
>>> line2
如果想改變文件當前讀到了第幾行，可以使用seek
file = open('test.txt', 'r'); # 讀文件
line1 = file.readline()
file.seek()
line2 = file.readline()
print line1
print line2
file.close()
>>> line1
>>> line1
文本文件和二進制文件
文件分為文本文件和二進制文件，打開文本文件和二進制文件的方式有些區(qū)別
file1 = open('text.txt', 'r') # 打開文本文件
file2 = open('music.mp3', 'rb') # 打開二進制文件
寫文件
寫文件兩種方式，第一種是覆蓋現(xiàn)有文件，第二種是追加現(xiàn)有文件。
file1 = open('text.txt', 'w') # 打開文件，后續(xù)可寫
file2 = open('text.txt', 'a') # 打開文本，后續(xù)可追加
打開文件后可以使用write函數(shù)來往文件寫內(nèi)容
file = open('text.txt', 'w')
file.write('\nline1')
file.write('\nline1')
file.close()
還可以用print函數(shù)進行寫文件
file = open('text.txt', 'w')
print >> file, "\nline1"
file.close()
上面的>>符號的意思是重定向輸出，即把輸出重定向到文件，而不是顯示器
在文件中保存內(nèi)容：pickle
python中為在文件中存取對象提供了一個方便的模塊——pickle
存儲文件的過程如下：
import pickle
list = ['12', '12', '12', '12']
file = open('temp.pkl', 'w')
pickle.dump(list, file);
file.close()
還原的過程如下：
import pickle
file = open('temp.pkl', 'r')
list = pickle.load(file)
file.close()
print list
>>> ['12', '12', '12', '12']
游戲
書中還提到了很多小游戲，其中也介紹了很多制作游戲和UI的庫，比如easyui，pygame等
舉一個猜拳游戲的小例子：
import random
secret = random.randint(1, 99)
guess = 0
tries = 0
print "helow, guess"
print "number from 1 to 99, 6 times"
while guess != secret and tries < 6:
guess = input("guess is:")
if guess < secret:
print "too low"
elif guess > secret:
print "too high"
tries = tries + 1
if guess == secret:
print "success"
else:
print "fail"
print "secret is ", secret
總結
這是我讀《父與子的編程之旅：與小卡特一起學Python》后記錄總結的一些筆記，書中還介紹了很多其他內(nèi)容，如果你沒看過我強烈建議你看一看這本書，如果看過了可以看這篇筆記用來快速回憶里面的內(nèi)容。
最后感謝你的閱讀。
更多建議：