python編程基礎（一）

第3章 Python基礎

本章主題

• 語句和語法
• 變數賦值
• 基本風格指南
• 內存管理
• 第一個python程序

3.1語句和語法

python中有一些基本規則和特殊字元：

• （#）井號表示之後為字元為python的注釋
• （n）換行是標準的行分隔符
• （）反斜線表示繼續上一行
• （;）表示將兩個語句連在一行中
• （：）冒號表示將代碼塊的頭和體分開
• 語句（代碼塊）用於縮進的方式體現
• 不同的縮進深度分隔不同的代碼塊
• python文件以模塊的形式組織

3.1.1注釋（#）

解釋器會忽略掉#之後的內容

3.2.1繼續（/）

python語句，一般使用換行分隔，也就是說一行一個語句，一行過長的語句可以使用反斜杠（）分解成幾行。

在三引號時候可以跨行書寫。

括弧的可讀性更好。

3.1.3多個語句構成代碼（：）

縮進相同的一組語句構成一個代碼塊，我們稱之為代碼組。像if、while、def、class 這樣的複合句。首行以關鍵字開始，以冒號（：）結束，改行之後的一行或多行被稱之為代碼組。

我們將首行及後面的代碼稱之為字句（clause）

3.1.4代碼組不同的縮進分隔

python使用縮進來分隔代碼組。代碼的層次關係是通過同樣深度的空格或製表符的縮進體現。同一代碼組的代碼必須嚴格左對齊。

核心風格：縮進4個空格寬度，避免使用製表符。

隨著縮進深度的增加，代碼塊的層次也在增加，沒有縮進的代碼塊是最高的層次的，被稱之為主體（main）部分。

3.1.5同一行書寫多個語句（;）

（;）分號允許你在同一行書寫多個語句，之間用分號隔開。這些語句不能再這行開始的一個新的代碼塊。

例子：

import sys;x=foo;sys.stdout.write(x+n)n

3.1.6模塊

每個python腳本都可以被當做一個模塊。模塊以磁碟文件的形式存在。當一個模塊。

當一個模塊過大，並且驅動了很多功能的話，就應該考慮拆一些代碼出來另外建一個模塊。

模塊裡面代碼可以是一段直接可執行的腳本，也可以是一堆類似庫函數的代碼，從而可以被別的模塊導入（import）調用。

3.2 變數賦值

3.2.1賦值操作符

python語言中，等號（=）是主要的賦值操作符（其他的是增量操作符）

如：

anInt=12n

在python語言中，對象是通過引用傳遞的。python的賦值語句不會返回值。

>>> x=1n>>> y=(x=x+1)t#賦值語句不是合法表達式nSyntaxError: invalid syntaxnn>>> y=x=x+1n>>> x,yn(2, 2)n

3.2.2增量賦值

x=x+1n

等價於

x+=1n

增量賦值符，其一是寫法上的簡化，其二是第一個對象進被處理一次。

可變對象唄修改，不可變對象則和A=A+B的結果一樣。

>>> m=12n>>> m%=7n>>> mn5n>>> m**=2n>>> mn25n>>> aList=[123,xyz]n>>> aList+=[45.6e7]n>>> aListn[123, xyz, 456000000.0]n

3.2.3多重賦值

>>> x=y=z=1n>>> xn1n>>> yn1n>>> zn1n

該對象的同一個引用被賦值給x、y、z

3.2.4 "多元"賦值

將多個變數同時賦值的方法我們稱之為多元賦值（multuple）

>>> (x,y,z)=(1,2,a string)n>>> xn1n>>> yn2n>>> zna stringn

兩個整型和一個字元串分別被賦值給x、y、z

python的多元賦值方法可以實現無需中間變數交換。

3.3標識符

3.3.1合法的python標識符

python的標識符規則和其他大部分用C編寫的高級語言類似：

• 第一個字元必須是字母或者下劃線（_）
• 剩下的字元可以是字元和數字或下劃線。
• 大小寫敏感

3.3.2關鍵字

3.3.3內建

python有任何一級代碼使用的「內建」（built-in）的名字集全。把built-in當做「系統保留字」。

3.3.4專用下劃線標識符

python用下劃線作為變數前綴和後綴指定特殊變數。

對python下劃線的特殊用法做了總結：

• _xxx 不用『from module import *』導入
• _xxx_t 系統定義名字
• _xxx 類中的私有變數名

核心風格：避免下劃線作為變數名的開始

3.4基本風格指南

注釋

確保注釋的準確性。注釋對自己和他人都很重要。

文檔

python提供了一個機制，可通過__doc__特別變數，動態獲得文檔字串。在模塊、類聲明、或函數聲明第一個沒有賦值的字元串可以用屬性obj.__doc__來訪問。

obj是一個模塊、類、或函數的名字。

縮進

縮進對其十分重要，增強代碼可讀性。不要使用製表符。

選擇標識符名稱

選擇短的有意義的標識符。

python風格指南

3.4.1模塊的結構和布局

用模塊來合理組織你的python代碼是簡單又自然的方法。如下面的布局：

#（1）起始行

#（2）模塊文檔

#（3）模塊導入

#（4）變數定義

#（5）類定義

#（6）函數定義

#（7）主程序

（1）起始行

通常只在類unix環境下使用。

（2）模塊文檔

簡要介紹模塊的功能及重要全局變數的含義，模塊可通過 moudle.__doc__訪問這些內容

#/usr/bin/env python （1）起始行

"this is a test module" （2）模塊文檔

import sys

import os （3）模塊導入

debug=True （4）（全局）變數

class FooClass(object):

"Foo class"

passtttt （5）類定義

def test():

"test function"

foo=FooClass()

if debug:

print ran test() （6）函數定義（若有）

of __name__==__main__:

test() （7）主程序

（3）模塊導入

導入當前模塊的代碼需要的所有模塊，每個模塊僅導入一次（當前模塊載入時）；函數內部的模塊導入代碼不會被執行，除非該函數正在執行。

（4）變數定義

這裡定義的變數為全局變數，本模塊中的所有函數都可以直接使用。

盡量使用局部變數代替全局變數，代碼易維護，且提高性能節省內存。

（5）類定義語句

所有的類都在這裡定義，當模塊被導入時，class語句就會被執行。類也就會被定義。類的文檔變數是class.__doc__

（6）函數定義語句

函數語句可以通過module.function()被外部訪問到，當模塊被導入時def語句會被執行，函數也就都會定義好。函數的文檔變數是function.__doc__

（7）主程序

無論這個模塊是被別的模塊導入還是作為腳本直接執行，都會執行這部分代碼。

核心風格：主程序調用main（）函數。

絕大部分模塊的創建目的是為了被別人調用而不是作為獨立執行的腳本。

核心風格：__name__指示模塊應如何被載入

• 如果模塊是被導入，__name__的值為模塊名字
• 如果模塊是被直接執行，__name__的值為『 __main__ 』

3.4.2 在程序中書寫測試代碼

3.5 內存管理

• 變數無須事先聲明
• 變數無須指定類型
• 程序員不用關心內存管理
• 變數名會被「回收」
• del語句能夠直接釋放資源

3.5.1 變數定義

python中，無須此類顯式聲明語句，在第一次被賦值時候自動聲明。

>>> annTraceback (most recent call last):nFile "<pyshell#0>", line 1, in <module>nanNameError: name a is not definedn

變數一旦被賦值，就可以直接通過變數名來訪問他們。

>>> x=4n>>> y=this is a stringn>>> xn4n>>> ynthis is a stringn

3.5.2 動態類型

python無須類型聲明。

3.5.3 內存分配

底層的事情交給python解釋器去做就可以了。

3.5.4 引用計數

要追蹤內存中的對象，python引用了計數這一簡單技術。

1.增加引用計數

2.減少引用計數

3.del語句

3.5.5垃圾收集

不再使用的內存被一種稱之為垃圾收集的機制釋放。

3.6第一個python程序

例3-1 創建文件（makeTextFile.py）

這個腳本是在提醒用戶輸入一個（尚不存在）的文件名，然後由用戶輸入該文件的每一行。最後，將所有的文本寫入文本文件。

#!usr/bin/env/pythonnnmakeTextFile.py--create text filennimport osnls=os.linesepnn#get filenamenwhile True:nnif os.path.exists(fname):nprint "ERROR: %s already exists" % fnamenelse:nbreaknn#get file content(text) linesnall=()nprint "nEnter lines ( . by itself to quit).n"nn#loop until user terminates inputnwhile True:nentry=raw_input(>)nif entry== . :nbreaknelse:nall.append(entry)nn#write lines to file with proper line-endingnfobj=open(fname,w)nfobj.writelines([%s%s %(x,ls) for x in all])nfobj.close()nprint DONE!n

3.7 相關模塊和開發工具

《python風格指南》《python快速指南》

調試器：pdb

記錄器：logging

性能測試器：profile、hotshot

第4章 python對象

本章主題：

• python對象
• 內建類型
• 標準類型操作符
• 值的比較
• 對象身份比較
• 布爾類型
• 標準類型內建函數
• 標準類型總覽
• 各種類型
• 不支持的類型

4.1 python對象

python使用對象模型來存儲數據。構造任何類型的值都是一個對象。

python的對象有三個特性：身份，類型，和值。

身份：每個對象都有一個唯一的身份標識自己。

類型：對象的類型決定了該對象可以保存什麼類型的值。可以用type()函數查看對象的類型。

值：對象表示的數據項。

對象屬性

含有數據屬性的對象包括，類，類實例，模塊，複數，文件。

4.2標準類型

• 數字
• Integer 整型
• Boolean 布爾型
• Long Integer 長整型
• Floating point real number 浮點型
• Complex number 複數型
• String 字元串
• List 列表
• Tuple 元組
• Dictionary 字典

4.3其他內建類型

• 類型
• Null對象（None）
• 文件
• 集合/固定集合
• 函數/方法
• 模塊
• 類

4.3.1類型對象和type類型對象

內建函數type()

>>> type(32)n<type int>n

<type int>是一個類型對象。

>>> type(type(32))n<type type>n

所有類型對象的類型都是type，它是所以python類型對象的根和所有python標準類的默認元類（metaclass）。

4.3.2 None——Python的Null對象

Python有一個特殊對象，被稱為Null對象或NoneType，它只有一個值，那就是None。不支持任何運算也沒用任何內建方法。

None沒有任何屬性，布爾值為False

核心筆記：布爾值。

所有標準對象均可用於布爾測試，同類型的對象之間可以比較大小。每個對象天生具有布爾True和False

下面的對象布爾值為False：

• None
• False（布爾類型）
• 所有值為零的數
• 0（整型）
• 0.0（浮點型）
• 0L（長整型）
• 0.0+0.0j（複數）
• ""（空字元）
• []（空列表）
• ()（空元組）
• {}（空字典）

除上面以外的所有對象的布爾值都是True

4.4 內部函數

• 代碼
• 幀
• 跟蹤記錄
• 切片
• 省略
• Xrange

4.4.1 代碼對象

代碼對象是一個函數的屬性。

代碼對象是編譯過的python的源代碼，是可執行對象，通過調用函數compile()可以得到代碼對象。

4.4.2 幀對象

幀對象表示python的執行幀棧。幀對象包含python解釋器在運行時候所需要知道的所有信息。

4.4.3 跟蹤記錄對象

代碼出錯時，python會報錯。發生異常時，一個包含針對異常的棧跟蹤信息的跟蹤記錄對象被創建。

4.4.4 切片對象

使用python擴展的切片語法時候，就會創建切片對象。

包括多維切片，步進切片，省略切片。

多維切片語法：sequence[start1:end1,start2:end2]

省略切片語法：sequence[...,start1:end1]

步進切片語法：sequence[起始索引：結束索引：步進值]

如：

>>> f=abcdefn>>> f[::-1]nfedcban>>> f[::-2]nfdbn>>> fr=[123,abc,123.456,qwe]n>>> fr[::-1]n[qwe, 123.456, abc, 123]n

4.4.5 省略對象

省略對象用於擴展切片語法中，起記號作用。這個對象在切片語法中表示省略號。類似Null對象None

省略對象的有唯一名字Ellipsis ，布爾值為True

4.4.6 XRange對象

調用內建函數xrange()會生成一個Xrange對象。

4.5標準類型操作符

4.5.1對象值的比較

所有內建類型均支持比較運算，比較運算返回值布爾值為True或False

>>> 2==2nTruen>>> 2==3nFalsen>>> abc<xyznTruen>>> abc>xyznFalsen>>> [5,abc]== [5,abc]nTruen>>> [5,abc]== [abc,5]nFalsen

4.5.2 對象身份的比較

為方便理解，我們舉例：

例1：f1和f2指向相同對象

f1=f2=4

例2：f1和f2指向相同對象

f1=4

f2=f1

4.5.3布爾類型

布爾邏輯操作符 and，or，not都是python的關鍵字

not操作符擁有最高的優先順序。

>>> x,y=3.1415926,-1024n>>> x<5.0nTruen>>> not (x<5.0)nFalsen>>> (x<5.0 )or (y>2.71828)nTruen>>> (x<5.0 ) and (y>2.71828)nFalsen>>> not (x is y)nTruen

4.6標準類型內建函數

還有一些標準類型的內建函數：

cmp()、repr()、str()、type()、repr()函數的單反引號(` `)操作符

函數cmp()t比較函數，根據比較結果返回整形

函數repr()tt返回一個對象的字元串表示

函數str()ttt返回對象社會可讀性好的字元串表示

函數type()tt得到一個對象的類型，並返回相應的type對象

4.6.1 type()

內建函數type()，用法如下：

type(object)n

type()接受一個對象作為參數，並且返回他的類型，它的返回值是一個類型對象。

>>> type(4)t#整型n<type int>n>>> type(Hello World!)t#字元型n<type str>n>>> type(type(4))t#type類型n<type type>n

4.6.2 cmp()

若obj1<obj2 返回-1

若obj1>obj2 返回1

若obj1=obj2 返回0

若用戶自定義對象，cpm()函數會調用該類的特殊方法__cmp__

>>> cmp(a,b)n-1n>>> cmp(b,a)n1n>>> b=-4n>>> cmp(a,b)n0n

4.6.3str() 和repr()函數的單反引號(` `)操作符

str() 和repr()函數的單反引號(ˋˋ)操作符 可以方便的以字元串的方式獲取對象的內容、類型、數值屬性等信息。

str()函數得帶的字元串可讀性好；

repr()函數得帶的字元串通常用來重新獲取對象。

>>> str(4.53)n4.53n>>> str(1)n1n>>> str(2e10)n20000000000.0n>>> str([0,1,2,3])n[0, 1, 2, 3]n>>> repr(1)n1n>>> repr([0,1,2,3,4])n[0, 1, 2, 3, 4]n>>> `[0,1,2,3]`n[0, 1, 2, 3]n

repr()和(` `)做的事情幾乎完全一樣，返回一個對象的「官方」字元串表示。可以同eval()重新得到該對象。

str()則是致力於生產一個對象的可讀性好的字元串表示，適用於print()語句。

並非所有的repr()返回的字元串都可以用eval()內建函數來得到原來的對象。

>>> eval(`type(type)`)nnTraceback (most recent call last):nFile "<pyshell#24>", line 1, in <module>neval(`type(type)`)nFile "<string>", line 1n<type type>n^nSyntaxError: invalid syntaxn

為什麼我們有了repr()函數還需要（``）

因為某些場合函數會比操作符更適合使用。（現在不鼓勵使用（``））

4.6.4 type()和isinstance()

>>> type()n<type str>n>>> s=xyzn>>> type(s)n<type str>n>>> type(0+0j)n<type complex>n>>> type([])n<type list>n>>> type({})n<type dict>n>>> type(0.0)n<type float>n>>> type(0L)n<type long>n

4.6.5 python類型操作符和內建函數總結

4.7 類型工廠函數

內建轉換函數int()、 type() 、 list()，現在都成了工廠函數。

雖然他們看上去像函數，但是他們是類。

4.8 標準類型的分類

標準類型：python的「基本內建數據對象原始類型」

4.8.1 存儲模型

4.8.2 更新模型

請看下列代碼：

>>> x=pythonn>>> print id(x)n23849088n>>> x=what?n>>> print id(x)n30706720n>>> i=0n>>> print id(i)n23945996n

對象實際上對替換了。

>>> List=[abd,65,34,dad]n>>> Listn[abd, 65, 34, dad]n>>> List[2]n34n>>> id(List)n30671536n>>> List[2]=List[2]+1n>>> List[3]=dsrgen>>> Listn[abd, 65, 35, dsrge]n>>> id(List)n30671536n

列表的值不論如何變換，列表的ID始終不變。

4.8.3 訪問模型

4.9 不支持的類型

下面給出python目前還不支持的數據類型。

1. char和byte

python沒有char或byte類型來保存單一字元或8位整型

2. 指針

python替你管理內存，沒必要訪問指針

3. int vs short vs long

python的整型相當於C語言中的長整型

4. float vs double

python的浮點型實際上是C語言的雙精度浮點型

第5章 數字

本章主題

• 數字簡介
• 整型
• 布爾型
• 標準整型
• 長整型
• 浮點型實數
• 複數
• 操作符
• 內建函數
• 其他數字類型
• 相關模塊

本章主要內容：

詳細介紹每一種數字類型，他們使用的各種操作符，以及用於處理輸的內建函數。以及簡單介紹了幾個標準庫中用於處理數字的模塊。

5.1數字簡介

數字提供了標量存儲和直接訪問。是不可更改類型，也就是說變更數字的值會生成新的對象。

python支持多種數字類型：

整型、長整型、布爾型、雙精度浮點型、十進位浮點型和複數

5.1.1 如何創建數值對象並用其賦值（數字對象）

anInt=1naLong=-999999999LnaFloat=3.141592653naComplex=1.23+4.56Jn

5.1.2 如何更新數字對象

通過對數字對象（重新）賦值，可以更新一個數值對象。

變數就像一個盒子，我們無法改變盒子的內容，但是可以將指針指向一個新盒子。

5.1.3如何刪除數字對象

無法真正刪除數值對象，僅僅是不再使用而已

5.2整型

5.2.1布爾型

該類型取值範圍：布爾值True和布爾值False

5.2.2 標準整型

5.2.3長整型

python的長整型類型能表達的僅僅與你的機器支持的虛擬內大小有關

核心風格：大寫字母L表示長整型

>>> aLong=999999991n>>> aLong=99999999Ln>>> print aLongn99999999n

5.2.4 整型和長整型的統一

5.3 雙精度浮點型

浮點型通常是都有一個小數點和一個可選的後綴e

5.4 複數

複數由實數部分和虛數部分組成

虛數部分必須有後綴j

表示虛數的語法：real+imagj

複數的內建屬性

>>> aComplex=-8.333-1.47jn>>> aComplexn(-8.333-1.47j)n>>> aComplex.realn-8.333n>>> aComplex.imagn-1.47n>>> aComplex.conjugate()n(-8.333+1.47j)n

num.real ttt複數的實部

num.imag ttt複數的虛部

num.conjugate()tt複數的共軛複數

5.5 操作符

5.5.1 混合模式操作符

類型轉換基本原則：

整型轉換為浮點型，非複數轉換為複數

>>> 5+1.5n6.5n

5.5.2 標準類型操作符

不同類型之間運算，在運算之前，python會將兩個操作數轉換為同一數據類型

>>> -719>=920nFalsen>>> 2<5<8nTruen>>> 0.<-90.4<55.3e2!=3<181nFalsen>>> (-1<1) or (1<-1)nTruen

5.5.3 算術操作符

支持單目操作符：正號（+）和負號（-）

雙目操作符：+、-、*、%、** （分別表示加法、減法、乘法、除法、取余、冪運算）

>>> -422-77n-499n>>> 4**5n1024n>>> 8/3n2n>>> 8.0/3.0n2.6666666666666665n>>> 8%3n2n>>> 45L*25Ln1125Ln>>> 0x80+0777n639n>>> 0+1j**2n(-1+0j)n

5.5.4 位操作符（只適用於整型）

python整型支持標準位運算：

取反（~），按位與（&）、或（|）、異或（^）、左移（<<）右移(>>)

負數會被當做正數的2進行制補碼處理

左移和右移N位等同於無溢出檢查的2的N次冪運算：2**N

>>> 30&45n12n>>> 30|45n63n>>> 30&30n30n>>> 30|30n30n>>> ~30n-31n>>> ~45n-46n>>> 45<<22n188743680n>>> 45<<1n90n>>> 30^2n28n

5.6 內建函數與工廠函數

5.6.1 標準類型函數

>>> cmp(-6,2)n-1n>>> cmp(0xFF,255)n0n>>> type(int)n<type str>n>>> type(2-1j)n<type complex>n

5.6.2 數字類型函數

1.轉換工廠函數

函數int()、long()、float()、complex()用來將其他數值類型轉換為響應的數值類型。

>>> int(4.25555)n4n>>> long(42)n42Ln>>> float(4)n4.0n>>> complex(4)n(4+0j)n>>> complex(2.4,-8)n(2.4-8j)n>>> complex(2.3e-10,45.3e4)n(2.3e-10+453000j)n

2.功能函數

python有5個運算內建函數用於數值運算：abs()、coerce()、divmod()、pow()、round()

abs()返回給定參數的絕對值。若參數為複數，則返回math.sqrt(num.real2+num.imag2)

>>> abs(-1)n1n>>> abs(-10.)n10.0n>>> abs(1.2-2.1j)n2.4186773244895647n

coerce()返回一個包含類型轉換的完畢的兩個元素的數值元素的元組。

>>> coerce(1,2)n(1, 2)n>>> coerce(1.3,134L)n(1.3, 134.0)n>>> coerce(1j,134L)n(1j, (134+0j))n

divmod()內建函數把除法一求余結合起來，返回一個包含商和餘數的元組。

>>> coerce(1j,134L)n(1j, (134+0j))n>>> divmod(10,3)n(3, 1)n>>> divmod(3,10)n(0, 3)n>>> divmod(2.5,10)n(0.0, 2.5)n>>> divmod(2+1j,0.5-1j)n((-0+0j), (2+1j))n

pow()和（**）都可以進行指數操作，只是前者是內建函數，後者是操作符

>>> pow(2,5)n32n>>> pow(3.1415,4)n97.39760017099509n>>> pow(1+1j,3)n(-2+2j)n

round()用於對浮點型進行四捨五入運算

>>> round(3)n3.0n>>> round(3.4444)n3.0n>>> round(3.4999999,1)n3.5n>>> round(3.449999)n3.0n

• 函數int（）直接截取小數部分（返回值為整型）
• 函數floor（）得到最接近原數的但小於原數的整型（返回值為浮點型）
• 函數round（）得到最接近原數的整型（返回值為浮點型）

5.63 僅用於整型的函數

1.進位轉換函數

python支持八進位和十六進位，分別用內建函數oct() hex()來返回字元串

>>> hex(255)n0xffn>>> oct(255)n0377n

2。ASCII轉換函數

python提供了ASCII碼與其序列值之間的轉換函數。每個字元對應一個唯一的整型。

函數char()接受一個單位元組整型值，返回一個字元串；函數ord()接受一個字元，返回其對應的整型值。

>>> chr(88)nXn>>> chr(44L)n,n>>> ord(g)n103n>>> ord(D)n68n

5.7 其他數字類型

5.7.1 布爾「數」

布爾值事實上是整型的子類，對應與整型的1和0

有關布爾類型的概念：

• 有兩個永不改變的True和False
• 布爾型是整型的子類，但不能再被繼承而生成它的子類。
• 對於值為零的任何數字或空集在python中的布爾值都是False
• 數學運算中，Boolean值的True和False分別對應為1和0

#intron>>> bool(1)nTruen>>> bool(0)nFalsen>>> bool(1)nTruen>>> bool(0)nTruen>>> bool([])nFalsen

#使用布爾數n>>> foo=42n>>> bar=foo<100n>>> barnTruen>>> print bar+100n101n>>> print %s % barnTruen>>> print %d % barn1n

5.7.2 十進位浮點型

通過字元串或其他的十進位數創建十進位浮點數。必須導入decimal模塊以便於使用Decimal類

>>> from decimal import Decimaln>>> dec Decimal(.1)nSyntaxError: invalid syntaxn>>> dec=Decimal(.1)n>>> decnDecimal(0.1000000000000000055511151231257827021181583404541015625)n>>> print decn0.1000000000000000055511151231257827021181583404541015625n>>> dec=Decimal(.1)n>>> decnDecimal(0.1)n>>> print decn0.1n

5.8相關模塊

對數字科學計算應用來說，有第三方包(Numeric(Numpy))和Scipy

聲明：

以上學習筆記來自

《python核心編程》第2版 Wesley J.Chun 編著 宋吉廣譯 人民郵電出版社

推薦閱讀：