内部指令、變量、程式流、子產品、異常
Python是子產品化設計成的，它由許多即插即用的子產品組成。其中基礎子產品又叫内模組化塊，
被實作在解釋器中。這包括進階資料結構，關鍵字，和内置指令組成。
程式開始：
#!/usr/bin/python
-*- coding: UTF-8 -*- 語句和文法
# 表示python中行注釋，相當于C語言中的 //
\n 表示python換行符号，和unix中的C語言相同
\ 表示python中上一行的繼續，不添加換行符，相當于shell中的 \
； 表示python中兩條指令寫到一行，這是一條指令的結束符，分号
： 表示python中的代碼頭與代碼體區分，冒号 解釋：
# 可以從一行的任意一個位置開始，之後的會被認為是注釋
\ 使用小括号，中括号，花括号,以及三個單引号時，可以不使用"\"換行
： 代碼組，像if while class這些複合語句，冒号證明後面的子指令
； 代碼鍊，将多條語句放到同一行，我們使用分号來表示他們屬于同一邏輯 源代碼結構布局
# 起始行 UNIX 風格 #/usr/bin/env ptyhon
# 子產品文檔，就是一些descripion comments
# 子產品導入，導入其他子產品以便使用子產品内的函數
# 變量定義，定義一些全局變量和私有變量
# 類定義，使用面向對象的程式設計思想，定義一些類
# 函數定義，使用面向過程的程式設計思想，定義一些功能函數
# 主程式，這裡相當與C語言中的main()程式入口 Python原為C語言實作的，是以支援跨平台性。
1） 内置指令：包括标準輸入輸出I/O、資料類型生成、檔案操作
- 标準輸入輸出——raw_input()/input()/print()
- 資料類型生成——int()/long()/bool()/float()/tuple()/list()/dict()
- 檔案操作——open()
- 對象屬性操作——help()/dir()/type()/glable()/locals()
2） 進階資料結構：包括python所支援的資料類型
- 數字對象——有符号整數、長整型、布爾型、浮點型、負數
- 字元串對象——str()+索引+切片+連接配接+重複
- 元組對象——tuple()+索引+切片+連接配接+重複
- 清單對象——list()+索引+切片+連接配接+重複
- 字典對象——dict()+索引+切片+連接配接+重複
3） 關鍵字：主要是控制程式執行流的結構語句
- 分支結構——if語句
- 循環結構——while語句
一、内置指令
執行python指令後進入解釋器，即内嵌子產品的運作中；
内嵌子產品提供了三種基本指令，它們的執行不需要導入新的子產品
使用：type(command) ==》:
表示内嵌子產品提供的内嵌指令。檢視提供的所有内嵌函數使用:
import sys
print dir(sys.modules['builtin'])
a）列印對象内容 print()，内部實作為：sys.stdout.write()
參數：變量、單引号括起的字元串、或者%d
功能：常用來輸出變量的值，輸出最後自動添加換行符
例:print( "%s is number is %d" %(var1 , var2))
說明：輸出資料與替換變量間不能有逗号隔開，使用'%'隔開
注意：1.V2.x版本中屬于語句,V3.x版本中屬于内嵌函數,函數必須加()
變量與變量之間使用逗号隔開，替換量與變量之間使用%隔開
單引号和雙引号都是原樣引用的意思，變量不能包括在内
%s 表示字元串， %d 表示整數， %f 表示浮點數，>> 表示重定向
b）格式化變量format()
格式：format(var , [format_geshi])
參數：第二個參數是字元串類型的格式,使用單引号括起
例：print( format (num, '4.2f'))
說明：m.nf ，表示小數的後顯示n位，總共顯示m位
【n大于實際值，則使用0表示，小于實際值，則四舍五入】
【m大于實際值，則右對齊使用空格表示，小于實際值，左對齊不生效】m > n
c）終端讀取raw_input()/input()
ret = raw_input(“str”) => V2版本
功能:輸出提示字元串str,讀取标準輸入,傳回字元串類型，指派給變量
ret = input(“str”) => V3版本
功能:輸出提示字元串str,讀取标準輸入，傳回字元串類型，指派給變量
d）轉化為整形int()，類的構造函數初始化整型對象
格式:int(var),傳回轉換後的變量值,指派給新變量
e）轉化浮點型float()，類的構造函數初始化浮點型對象
格式:float(var),傳回轉換後的變量值,指派給新變量
f）轉化布爾型bool()，類的構造函數初始化布爾型對象
格式:bool(var),傳回ture或者false,指派給新變量
g）生成元組tuple()，類的構造函數初始化元組對象
格式:tuple(var),傳回轉換後的變量值,指派給新變量
h）生成清單list()，類的構造函數初始化清單對象
格式:list(var),傳回轉換後的變量值,指派給新變量
i）生成字典dict()，類的構造函數初始化字典對象
格式:dict(var),傳回轉換後的變量值,指派給新變量
j）檢視對象類型type()
格式:type(var)，傳回對象屬于的類
k）檢視對象内部id号id()
格式:id(var)，傳回對象再記憶體中的ID
l）檢視對象資訊dir()
格式:dir(var)，傳回該對象擁有的屬性和提供的方法，比如變量、類和子產品
m）打開檔案open()
格式:open(path,mode),傳回檔案句柄
n）擷取線上幫助help()
格式:help(raw_input) --- 将輸出内建函數的使用方法
o）函數 globals（moudle)
可以傳回全局命名空間裡的名字
p）函數 locals（）
可以傳回局部命名空間裡的名字
q）函數 reload（module）
可以重新載入子產品
s）函數 range（start, stop，step）
産生一個由開始到結束(stop-1)的清單,首參數及尾參數可以省略，step間隔資料
t）函數 len（obj）
傳回對象中字元的個數或者元素的格式,數字不存在該屬性
g) globals()和locals()函數 ：
根據調用地方的不同，globals()和locals()函數可被用來傳回全局和局部命名空間裡的名字。
如果在函數内部調用locals()，傳回的是所有能在該函數裡通路的命名。
如果在函數内部調用globals()，傳回的是所有在該函數裡能通路的全局名字。
兩個函數的傳回類型都是字典。是以名字們能用keys()函數摘取。
i) reload()函數 ： 當一個子產品被導入到一個腳本，子產品頂層部分的代碼隻會被執行一次。
是以，如果你想重新執行子產品裡頂層部分的代碼，可以用reload()函數。
該函數會重新導入之前導入過的子產品。文法如下：
reload(module_name) 在這裡，module_name要直接放子產品的名字，
而不是一個字元串形式。比如想重載hello子產品，如下：
reload(hello) 二、資料類型
Python裡一切都是對象，包括它所支援的資料類型,屬于内置進階資料結構。
1）python中資料類型
支援七種類型:數字、字元串、元組、清單、字典、集合、空對象
boolean 布爾類型，true or false
integer 整型類型
long 長整型類型
float 浮點類型
complex 複數類型
string 字元類型
list 清單類型，相當于C語言數組 ，使用中括号定義[]，也使用[]調用
tuple 元組類型，一次性初始化的不可變數組 ，使用小括号定義（），但使用[]調用
dict 字典類型，資料無序性(key=value)鍵值對，使用大括号定義 { }，仍然使用[]調用
Set 集合類型，資料無重複，無序
None ‘’空對象，空字元，空清單 注意:單引号和雙引号在字元串資料中的使用；
預設，python自帶的指令行會把所有的字元串視為語句、函數、或者方法。
是以，所有字元串資料必須使用引号
- 外面使用單引号，内部直接使用雙引号 ‘I Love "Itercast"’
- 外部使用雙引号，内部需要轉義單引号 "I Love \‘Itercast\’"
三個單引号可以達到到多行輸入的功能，好比使用shell中“\”
2）Python中的變量
變量值都是由類初始化的對象，對象是通過引用傳遞的,而不是值；
變量指派：變量名 = 變量值(使用"="等号進行變量的指派操作)
變量類型：python中變量值是由類初始化的對象，而變量名隻是一種名稱連接配接，
它不占用記憶體，同時每個對象都有自己的屬性和方法，是以對象是沒有類型的
我們用C語言了解一下Python中的變量(對象)：
變量值==>程式堆中會配置設定一塊記憶體，存儲對象本身，它的記憶體位址不會被作業系統标記，但會被程式存儲；
變量名==>程式堆中會另配置設定一塊記憶體，它的記憶體位址會被作業系統标記，用以尋找此對象，但它将存儲對象的記憶體位址；
變量分類：類變量和執行個體變量、動态變量和靜态變量
- 類變量 = 定義到函數之外，作用域為整個檔案，定義形式為 value = key
- 執行個體變量 = 定義到函數之内，作用域隻在函數内，定義形式是self.value = key
- 動态變量 = 動态變量包括(類變量和執行個體變量)，即動态變量可以被執行個體對象使用
- 靜态變量 = 靜态變量需要使用指定的修飾符，表示該變量隻能在類中使用，不能被對象使用
算數操作符 --- +，-，*，/，*，//
比較操作符 --- >，>=，<，<=，==，!=
邏輯操作符 --- and or not
增量操作符 --- +=，-=，=，/=，%=，**=，<
多重操作符 --- 将一個對象的多個引用指派給多個變量 ：x = y = z = 1
多元操作符 --- x, y, z = 1, 2, 'a string'，多個變量賦不同的值
檢視對象的類型 : 變量名.__class__
調用對象的方法 ：變量名.方法()
是以，python不需要變量聲明，且變量無類型，統一存儲為字元串
初始化格式: 變量名 = 變量值，我們認為變量就是對象 三、内置對象方法
對象的支援方法
變量是一種内建對象的引用，即變量名是記憶體資料對象的指向。 使用内建函數id(var)
==>可以檢視對象存儲的記憶體的邏輯位址。更改變量的值，實質是給重新建立了對象。
使用内建函數type(var)
==>可以檢視對象的類型，常見的類型有str、int、float、tuple、list、dict等
使用 内建函數 help（func/key）
==>可以檢視庫函數線上幫助、可以檢視類型對象的預設屬性和方法，help（int）、help（str）， help（list）
- 元組（tuple）：一種隻能被初始化而不能修改的一維數組對象，使用下标通路,元組名[下标号]，使用小括号初始化,使用逗号隔離元素
- 清單（list）：一種既能被初始化又能被修改的一維數組對象，使用下标通路,清單名[下标号]，使用中括号初始化,使用逗号隔離元素
- 字典（dict）：采用鍵值對的方式存儲資料的 key = value 對象，使用下标通路 字典名[鍵名]，使用大括号和冒号初始化,使用逗号隔離鍵值對
實際上：字元串類型對象也是一種元組，支援索引和切片的操作方法。
常有操作：
1）索引通路：直接使用對象名和索引序列号來通路對象中的某個元素，對象名[下标序列号] ,此序列号由零開始
2）切片通路：直接使用冒号和索引始終序列号來通路對象中多個元素，對象名[下标起始序列号：下标終點序列号]
字元串操作：help（str）
str_name.upper()
将字元串轉換成大寫
str_name.lower()
将字元串轉換成小寫
str_name.count（sub， start，stop）
傳回整個字元串中，指定的子串'sub'在指定的範圍内，出現的次數
str_name.index（sub , start , stop）
傳回字元串裡，指定的子串'sub'在指定的範圍内，首次出現時的下标序列号
str_name.find(sub, start, stop)
str_name.isalnum()
字元串對象中是否全部為數字或者字元串,傳回布爾類型
str_name.ispha()
字元串對象中是否全部為字元串,傳回布爾類型
str_name.isdigit()
字元串對象中是否全部為數字,傳回布爾類型
str_name.islower()
字元串對象中是否全部為小寫字元,傳回布爾類型
str_name.isupper()
字元串對象中是否全部為大寫字元,傳回布爾類型
str_name.istitle()
字元串對象中是否為标題(僅僅首字元大寫,其餘小寫)
字元串對象中将所有大寫字元轉換為小寫字元
字元串對象中将所有小寫字元轉換為大寫字元
str_name.title()
字元串對象轉換為标題(僅僅首字元大寫,其餘消息)
str_name.isspace()
字元串對象中是否全部為空格字元,傳回布爾類型
str_name.join(str)
字元串對象中将參數中每個字元添加到對象頭尾
str_name.split(sep)
字元串對象中将以參數作為分割符,傳回分割後的清單
元組操作：help（tuple）
tuple_name.count(element)
傳回元組裡，指定的元素'elemnt'出現了多少次
tuple_name.index(element, start, stop)
傳回元組裡，指定的元素'element'在指定的範圍内，首次出現時的下标序列号
清單操作：help（list）
list_name.append(element)
追加一個新的元素到清單末尾
list_name.insert(index, object)
插入一個新的元素object 到清單的指定的 index 位置上
list_name.extent(list/tuple/dict)
擴充原來的清單，在尾部添加一個新的對象，組成新的清單
list_name.remove(element)
删除指定的元素'element'在清單中首次出現的元素
list_name.pop(index)
傳回清單中指定索引index 的元素,并且在清單中删除它,預設從最後一位開始
list_name.count(element)
傳回整個清單裡，指定的元素'element'出現了多少次
list_name.index(element, start, stop)
傳回清單裡，指定的元素'element'在指定的範圍内,首次出現時的下标序列号
字典操作：help（dict）
dict_name.clean()
清空一個字典的所有内容
dict_name.copy()
複制一個字典的所有内容并傳回，可以使用變量存儲下來
dict_name.keys()
列出一個字典的所有鍵名内容，不會列出鍵值資料
dict_name.values()
列出一個字典的所有鍵值資料，不會列出鍵名内容
dict_name.items()
列出一個字典的鍵名與鍵值的對應關系
dict_name.get(key1 , value2)
列出字典中，鍵名為key1的值，如果沒有則将該鍵名的鍵值設為value2
dict_name.pop(key1, value2)
列出字典中，鍵名為key1的值，如果沒有則傳回内容為value2
其他說明：解釋器中的下劃線"_" 表示最後一個執行指令的表達式
"/" 表示傳統的除法
"//" 表示浮點的除法
"**" 表示乘方
四、程式流程
變量名:第一個字元必須是字母或者下劃線_，其餘字元必須是數字、字母、下劃線， 大小寫敏感
辨別符:理論上隻要滿足以上變量名定義規則,使用者可自行設計程式中的變量名稱,
但是python系統中仍然保留了關鍵詞和函數方法的名稱,
關鍵詞作用:控制程式的執行流程,以及程式特殊的操作，為此我們建議盡量不要使用這些關鍵詞作為變量名稱。
常見的關鍵字包括:
def import class expect
----------------------------------------------
and or not exec
----------------------------------------------
if elif else while break contine
-------------------------------------------------------------
is in print pass with
-------------------------------------------------------------
pass raise return from globle
------------------------------------------------------------- “人生道路雖然漫長，但緊要處常常隻需要幾步，特别是當人年輕的時候”--路遙
Python程式保持了C語言中的順序、循環執行流
1)邏輯分支
/當判定條件為ture時，執行指令/
if 條件判斷語句：(不要忘記冒号)
......(4位縮進)
elif 條件判斷語句：(不要忘記冒号)
......(4位縮進)
else：(不要忘記冒号)
......(4位縮進) 注意：python中不存在switch語句，同樣沒有三目運算符(food?eat=1:eat=0)
2)循環分支其一
/重複執行特定的語句/
for 變量1,變量2 in [清單]：(不要忘記冒号)
...... (4位縮進) 例如:
for i in range(1, 10, 2)
print i --> 1, 3, 5, 7, 9 3)循環分支其二
/當判斷條件為true時，循環執行代碼塊/
while (判斷條件) : (不要忘記冒号)
......(4位縮進) while raw_input("Enter name:") != 'admin':
print ('sorry,name error...')
continue
while raw_input("Enter pwd:") != '123456':
print ('sorry,passwd error...')
continue
print ('Congratulation, welcome...')
exit() 注意:子指令 continue 、 break解讀
continue == 直接進入下一次循環
break == 退出整個循環
疊代器 range(var) #生成list對象
iterator = iter(obj) #生成疊代器
五、函數(方法)定義
函數的定義和調用
函數（方法）通過組合特定的代碼，實作可重複執行的特定功能，
它通過參數接收資料，通過return傳回結果
def 函數名(形參清單):
......(4位縮進) //可以用來注釋代碼段
對象名.方法名(實參清單) //通過對象調用方法
注意：
1)函數參數可以傳遞預設值,使用key=val的形式；
2)傳遞變長參數時，會被自動轉換成以參數名命名的元組或字典，必須傳遞無預設值的參數指派
3)函數傳回多個對象時，總是以元組的形式傳回。
元組
def function(*var_name)：(不要忘記冒号)
func_name(value1,value2) 字典
def function(**var_name)
func_name(key1=value1, key2=value2) 函數的傳回值
return obj; //傳回對象
return ; //傳回None空對象，沒有return則傳回None空對象
注意：類變量和執行個體變量都是會定義記憶體的，但是類變量的改變會影響到全局；
因為return傳回了整個對象，覆寫原對象
定義在函數内部的變量擁有一個局部作用域，定義在函數外的擁有全局作用域。
局部變量隻能在其被聲明的函數内部通路，而全局變量可以在整個程式範圍内通路。
調用函數時，所有在函數内聲明的變量名稱都将被加入到作用域中
1、定義在函數之外的屬于全局變量，而在函數之内的使用，需要global聲明，表示目前調用全局變量
2、函數内外可以定義相同名稱的變量，但一個是全局的，一個是局部的。
是以，第一次調用函數時開銷比較大．但是其後的每次調用都隻會花費一條指令和一個間接的存儲器引用
六、子產品的使用
子產品：以檔案形式存儲，一個檔案就是一個子產品，可以用import導入調用
1）子產品：是包含執行代碼、函數、類和變量的獨立python檔案
import mod //不包括檔案擴充名，調用通過"子產品名.方法名"
mod.function();
from mod import function
function(); //直接調用"方法名" 注意：from 後面可以跟目錄名字，然後導入目錄中的子產品名（檔案名）
常用系統子產品
import sys.path //基礎子產品,又稱僞系統子產品
import os import * //linux系統調用能力的展現點
import socket, threading //網絡子產品和線程子產品
import time, random //時間子產品和随機子產品
import string, re //字元串子產品和正則子產品 常用私有子產品
>#/home/itercast/modules/m.py
path = '/home/itercast/modules/' 使用私有子產品
>sys.path.append(path) //把私有子產品路徑添加進來
form m import plus2 //導入私有子產品==> import指令在sys.path中查找子產品
直接執行 plus2 七、錯誤和異常
異常處理方式：
try:
#正常的代碼邏輯:
code_break
except ValumeError as e: //第一次調用捕獲具體異常
#如果上面的代碼執行錯誤，則執行本塊
....
except Exception as e: //第二次調用抓所有異常
#如果上面的代碼執行錯誤，則執行本塊
....
else：
#如果code_break沒有出錯，則繼續執行這裡的代碼
Finally:
#最後執行，不管上面的代碼有沒有出錯 Exception是捕獲異常的總類，e是該類的對象；
常見的Python錯誤包括：
ValumeError、IndexError、FileNotFoundError、IOError、TypeError等，這些值替代Exception字元串
即：ValumeError、IndexError、FileNotFoundError、IOError、TypeError是Exception的子類
![java的File機制實作目錄下的檔案檢索[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)