Python學習筆記

一、資料類型

1、整數 2、浮點數 3、字元串 4、布爾值 5、空值

二、print語句

連結 >>> print 'The quick brown fox', 'jumps over', 'the lazy dog'

The quick brown fox jumps over the lazy dog

三、raw字元串與多行字元串

print '\"To be, or not to be\": that is the question.\nWhether it\'s nobler in the mind to suffer.'

print r'''"To be, or not to be": that is the question.Whether it's nobler in the mind to suffer.'''

四、Unicode字元串

# -*- coding: utf-8 -*-      print u'中文'

五、List（清單）的操作

定義：>>> classmates = ['Michael', 'Bob', 'Tracy']    print classmates

順序通路：L = [95.5,85,59,59]      print L[0]   95.5

倒序通路：L = [95.5,85,59]      print L[-1]   59

添加：1、append（）方法，追加到list的末尾    

>>> L = ['Adam', 'Lisa', 'Bart']

>>> L.append('Paul')

>>> print L

['Adam', 'Lisa', 'Bart', 'Paul']

  2、insert（）方法，可以最近到指定地點

>>> L.insert(0, 'Paul')

['Paul', 'Adam', 'Lisa', 'Bart']

删除：1、pop（）方法預設從list尾部删除一個元素

>>> L = ['Adam', 'Lisa', 'Bart', 'Paul']

>>> L.pop()

'Paul'

['Adam', 'Lisa', 'Bart']

  2、>>> L = ['Adam', 'Lisa', 'Paul', 'Bart']

>>> L.pop(2)

替換：>>> L = ['Adam', 'Lisa', 'Bart']

>>> L[2] = 'Paul'

L = ['Adam', 'Lisa', 'Paul']

六、建立tuple（元組）

tuple 和 list 非常類似，但是，tuple一旦建立完畢，就不能修改了。

建立tuple和建立list唯一不同之處是用( )替代了[ ]，其他操作基本都一緻。

單元素tuple為了避免歧義，規定定義 >>> t = (1,)    >>> print  t     (1,)

可變tuple  >>> t = ('a', 'b', ['A', 'B'])    注意到 t 有 3 個元素：'a'，'b'和一個

list：['A', 'B']。list作為一個整體是tuple的第3個元素。list對象可以通過 t[2] 拿到：>>> L = t[2]

七、if語句

Python代碼的縮進非常嚴格，具有相同縮進的代碼被視為代碼塊，

縮進請嚴格按照Python的習慣寫法：4個空格，不要使用Tab，更不要混合Tab和空格，否則很容易造成因為縮進引起的文法錯誤。

if 語句後接表達式，然後用:表示代碼塊開始。

如果你在Python互動環境下敲代碼，還要特别留意縮進，并且退出縮進需要多敲一行回車：

age = 20

if age >= 18:

    print 'your age is', age

    print 'adult'

print 'END'

If-else語句

else:

    print 'teenager'

If-elif-else語句

score = 85

if score>=90:

    print 'excellent'

elif score>=80:

    print 'good'

elif score>=60:

    print 'passed'

    print 'failed'

八、for循環

L = [75, 92, 59, 68]

sum = 0.0

for score in L:

    sum = sum + score

print sum / 4

九、while循環

和 for 循環不同的另一種循環是 while 循環，while 循環不會疊代 list 或 tuple 的元素，而是根據表達式判斷循環是否結束。

利用while循環計算100以内奇數的和

sum = 0

x = 1

while x < 100:

   sum = sum + x

   x = x + 2

print sum

十、break退出循環

用 for 循環或者 while 循環時，如果要在循環體内直接退出循環，可以使用 break 語句。

利用 while True 無限循環配合 break 語句，計算 1 + 2 + 4 + 8 + 16 + ... 的前20項的和。

n = 1

while True:

    sum = sum + x

    x = x * 2

    n = n + 1

    if n > 20:

        break

十一、Continue

對已有的計算 0 - 100 的while循環進行改造，通過增加 continue 語句，使得隻計算奇數的和：

x = 0

    x = x + 1

    if x > 100:

    if x % 2 == 0:

        continue

    sum = sum + x

十二、多重循環

對100以内的兩位數，請使用一個兩重循環列印出所有十位數數字比個位數數字小的數，例如，23（2 < 3）

for x in [1, 2, 3, 4, 5, 6, 7, 8, 9]:

    for y in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:

        if x < y:

            print x * 10 + y

十三、Dict

我們把名字稱為key，對應的成績稱為value，dict就是通過 key 來查找 value。

花括号 {} 表示這是一個dict，然後按照 key: value, 寫出來即可。最後一個 key: value 的逗号可以省略。

由于dict也是集合，len() 函數可以計算任意集合的大小：

d = {

    'Adam': 95,

    'Lisa': 85,

    'Bart': 59

}

十四、通路dict

1、if 'Paul' in d:

    print d['Paul']  通過key通路，傳回value值

2、通過dict本身提供的get方法

>>> print d.get('Bart')

59

>>> print d.get('Paul')

None          沒有key值時，傳回None

十五、dict的特點

1、查找速度快

無論dict有10個元素還是10萬個元素，查找速度都一樣。而list的查找速度随着元素增加而逐漸下降。

不過dict的查找速度快不是沒有代價的，dict的缺點是占用記憶體大，還會浪費很多内容，list正好相反，占用記憶體小，但是查找速度慢。

由于dict是按 key 查找，是以，在一個dict中，key不能重複。

2、存儲的key-value序對是沒有順序的

當我們試圖列印這個dict時：

>>> print d

{'Lisa': 85, 'Adam': 95, 'Bart': 59}

列印的順序不一定是我們建立時的順序，而且，不同的機器列印的順序都可能不同，這說明dict内部是無序的，不能用dict存儲有序的集合。

3、作為 key 的元素必須不可變

Python的基本類型如字元串、整數、浮點數都是不可變的，都可以作為 key。但是list是可變的，就不能作為 key。

十六、更新dict

1、key值不同，新添加，用指派語句：>>> d['Paul'] = 72

2、如果key值已有，則更新，覆寫原有

十七、周遊dict

for key in d:

    print key + ':', d.get(key)

十八、Set

dict的作用是建立一組 key 和一組 value 的映射關系，dict的key是不能重複的。

有的時候，我們隻想要 dict 的 key，不關心 key 對應的 value，目的就是保證這個集合的元素不會重複，這時，set就派上用場了。

set 持有一系列元素，這一點和 list 很像，但是set的元素沒有重複，而且是無序的，這點和 dict 的 key很像。

建立 set 的方式是調用 set() 并傳入一個 list，list的元素将作為set的元素：

列印的順序和原始 list 的順序有可能是不同的，因為set内部存儲的元素是無序的。

因為set不能包含重複的元素，是以，當我們傳入包含重複元素的 list 會怎麼樣呢？

十九、通路set

由于set存儲的是無序集合，是以我們沒法通過索引來通路。

通路 set中的某個元素實際上就是判斷一個元素是否在set中。

>>> s = set(['Adam', 'Lisa', 'Bart', 'Paul'])

>>> 'Bart' in s

True

>>> 'Bill' in s   大小寫敏感

False   

二十、set的特點

set的内部結構和dict很像，唯一差別是不存儲value，是以，判斷一個元素是否在set中速度很快。

set存儲的元素和dict的key類似，必須是不變對象，是以，任何可變對象是不能放入set中的。

最後，set存儲的元素也是沒有順序的。

months = set(['Jan','Feb','Mar','Apr','Jun','Jul','Aug','Sep','Oct','Nov','Dec'])

x1 = 'Feb'

x2 = 'Sun'

if x1 in months:

    print 'x1: ok'

    print 'x1: error'

if x2 in months:

    print 'x2: ok'

    print 'x2: error'

二十一、周遊set

s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])

for x in s:

    print x[0] + ':', x[1]

Lisa: 85

Adam: 95

Bart: 59

二十二、更新set

1、添加新的元素

>>> s = set([1, 2, 3])

>>> s.add(4)

>>> print s

set([1, 2, 3, 4])

2、删除set中的元素      如果删除的元素不存在set中，remove()會報錯：

>>> s = set([1, 2, 3, 4])

>>> s.remove(4)

set([1, 2, 3])

二十三、函數

寫一次，多次調用

調用函數  絕對值的函數 abs

比較函數 cmp(x, y) 就需要兩個參數，如果 x<y，傳回 -1，如果 x==y，傳回 0，如果 x>y，傳回 1

int()函數可以把其他資料類型轉換為整數

str()函數把其他類型轉換成 str

sum()函數接受一個list作為參數，并傳回list所有元素之和。請計算 1*1 + 2*2 + 3*3 + ... + 100*100。

L = []

while x <= 100:

    L.append(x * x)

print sum(L)

二十四、編寫函數

在Python中，定義一個函數要使用 def 語句，依次寫出函數名、括号、括号中的參數和冒号:，然後，在縮進塊中編寫函數體，函數的傳回值用 return 語句傳回。

請定義一個 square_of_sum 函數，它接受一個list，傳回list中每個元素平方的和

def square_of_sum(L):

    sum = 0

    for x in L:

        sum = sum + x * x

    return sum

print square_of_sum([1, 2, 3, 4, 5])

print square_of_sum([-5, 0, 5, 15, 25])

傳回多值

用print列印傳回結果，原來傳回值是一個tuple！

但是，在文法上，傳回一個tuple可以省略括号，而多個變量可以同時接收一個tuple，按位置賦給對應的值，是以，Python的函數傳回多值其實就是傳回一個tuple，但寫起

來更友善。一進制二次方程的定義是：ax2 + bx + c = 0

請編寫一個函數，傳回一進制二次方程的兩個解。

注意：Python的math包提供了sqrt()函數用于計算平方根。

import math

def quadratic_equation(a, b, c):

    t = math.sqrt(b * b - 4 * a * c)

    return (-b + t) / (2 * a),( -b - t )/ (2 * a)

print quadratic_equation(2, 3, 0)

print quadratic_equation(1, -6, 5)

二十五、遞歸函數

漢諾塔 (http://baike.baidu.com/view/191666.htm) 的移動也可以看做是遞歸函數。

我們對柱子編号為a, b, c，将所有圓盤從a移到c可以描述為：

如果a隻有一個圓盤，可以直接移動到c；

如果a有N個圓盤，可以看成a有1個圓盤（底盤） + (N-1)個圓盤，首先需要把 (N-1) 個圓盤移動到 b，然後，将 a的最後一個圓盤移動到c，再将b的(N-1)個圓盤移動到c。

請編寫一個函數，給定輸入 n, a, b, c，列印出移動的步驟：

move(n, a, b, c)

例如，輸入 move(2, 'A', 'B', 'C')，列印出：

A --> B

A --> C

def move(n, a, b, c):

    if n == 1:

        print a,'-->',c

        return

    move(n-1,a,c,b)

    print a,'-->',c

    move(n-1,b,a,c)

move(4, 'A', 'B', 'C')

B --> C

定義預設參數

int()函數的第二個參數是轉換進制，如果不傳，預設是十進制 (base=10)，如果傳了，就用傳入的參數。

由于函數的參數按從左到右的順序比對，是以預設參數隻能定義在必需參數的後面：

# OK:

def fn1(a, b=1, c=2):

    pass

# Error:

def fn2(a=1, b):

    Pass

def greet(name='world'):

    print 'Hello,' + name + '.'

greet()

greet('Bart')

Hello,world.

Hello,Bart.

定義可變參數

可變參數也不是很神秘，Python解釋器會把傳入的一組參數組裝成一個tuple傳遞給可變參數，是以，在函數内部，直接把變量 args 看成一個 tuple 就好了。

可變參數 args 是一個tuple，當0個參數傳入時，args是一個空tuple。

參考代碼:

def average(*args):

    sum = 0.0

    if len(args) == 0:

        return sum

    for x in args:

        sum = sum + x

    return sum / len(args)

print average()

print average(1, 2)

print average(1, 2, 2, 3, 4)

二十六、對list進行切片Slice

取前3個元素，用一行代碼就可以完成切片：

>>> L[0:3]

隻用一個 : ，表示從頭到尾：

>>> L[:]

請利用切片，取出：

1. 前10個數；

2. 3的倍數；

3. 不大于50的5的倍數。

L = range(1, 101)

print L[:10]

print L[2::3]

print L[4:50:5]

倒序切片

5的倍數可以用 ::5 取出，要确定起始索引。

print L[-10:]

print L[-46::5]

二十七、對字元串切片

但它會把所有字母都變成大寫。請設計一個函數，它接受一個字元串，然後傳回一個僅首字母變成大寫的字元串。

def firstCharUpper(s):

    return s[0].upper() + s[1:]

print firstCharUpper('hello')

print firstCharUpper('sunday')

print firstCharUpper('september')

Hello

Sunday

September

二十八、疊代

因為 Python 的 for循環不僅可以用在list或tuple上，還可以作用在其他任何可疊代對象上。

是以，疊代操作就是對于一個集合，無論該集合是有序還是無序，我們用 for 循環總是可以依次取出集合的每一個元素。

注意: 集合是指包含一組元素的資料結構，我們已經介紹的包括：

1. 有序集合：list，tuple，str和unicode；

2. 無序集合：set

3. 無序集合并且具有 key-value 對：dict

而疊代是一個動詞，它指的是一種操作，在Python中，就是 for 循環。

疊代與按下标通路數組最大的不同是，後者是一種具體的疊代實作方式，而前者隻關心疊代結果，根本不關心疊代内部是如何實作的。

請用for循環疊代數列 1-100 并列印出7的倍數。

for i in range(1,101):

    if i % 7 == 0:

        print i