前言
Python 是一種不受局限、跨平台的開源編程語言，它功能強大且簡單易學。
Python 已延伸到 ArcGIS 中，成為了一種用於進行數據分析、數據轉換、數據管理和地圖自動化的語言，因而有助於提高工作效率。要使用Python，首要的就是了解其基本的語法。
腳本文件點此下載。
運行Python
有三種方式可以運行Python（日常第一種就足夠使用了）：
1、交互式解釋器：
你可以通過命令行窗口進入python在交互式解釋器中開始編寫Python代碼。
在交互式編譯器中編寫代碼和編寫腳本不同。在Python Shell的菜單欄中，單擊File>New windows ， 就打開了一個名為Untitled 的新窗口。
在菜單欄單擊File>Save As ， 然后將腳本命名為hello.py。.py 是腳本文件的后綴名。點擊Run>Run Moudule（或者F5），可在交互式解釋器中看到運行結果。
2、命令行腳本
3、集成開發環境
PyCharm或者Visual Studio
IDLE快捷鍵
打開Options→configure IDLE→keys，可以配置選擇快捷
編輯狀態時
- Ctrl + [ 、Ctrl + ] 縮進代碼
- Alt + 3 Alt + 4 注釋、取消注釋代碼行
- Alt + 5 Alt + 6 切換縮進方式 空格<=>Tab
- Alt + / 單詞完成，只要文中出現過，就可以幫你自動補齊。多按幾次可以循環選擇
- Alt + M 打開模塊代碼，先選中模塊，然后按下此快捷鍵，會幫你打開改模塊的py源碼供瀏覽
- Alt + C 打開類瀏覽器，方便在源碼文件中的各個方法體之間切換
- Alt + FP 打開路徑瀏覽器，方便選擇導入包進行查看瀏覽
- F1 打開Python文檔
- 三個單引號 ''' 批量注釋
在編輯過程中
- 按F5進入shell調試。
- Alt + DG 先定位到錯誤行，按此快捷鍵可以快速定位到出錯位置
- Alt + DS 直接顯示出錯歷史，找到根源，方便啊
- Alt + DA 如果每次都要按，還不夠方便,按這個，以后出錯都出歷史
- Alt + DD 打開調試窗口，進入單步調試，方便。
- Ctrl + F6 為了清空前面的導入記錄等，重新啟動shell
另外值得注意的是
- Alt + N Alt + P 可以查找以前輸入的命令用於補全當前命令
- Ctrl + 方向鍵 能夠得到增強功能
注意點
1）Python是區分大小寫的
2）代碼中的多個空格是不會對代碼的運行產生影響的，但模塊、類、方法和屬性中不能使用空格
3）所有的引號都是英文的
4）python最具特色的就是使用縮進來表示代碼塊，不需要使用大括號 {} 。縮進的空格數是可變的，但是同一個代碼塊的語句必須包含相同的縮進空格數。
5）默認情況下，源碼文件以 UTF-8 編碼，所有字符串都是 unicode 字符串。 當然你也可以為源碼文件指定不同的編碼：
# -*- coding: cp936 -*-
注釋
Python中單行注釋以 # 開頭
多行注釋可以用多個 # 號，還有 ''' 和 """ ：
實例
# this is my first note!
# this is my second note!
'''
this is multiline note !
first line
second line
'''
"""
this is multiline note !
first line
second line
"""
print "hello world!"
運行結果
hello world!
導入模塊
在 python 用 import 或者 from...import 來導入相應的模塊。
將整個模塊(somemodule)導入，格式為： import somemodule
從某個模塊中導入某個函數,格式為： from somemodule import somefunction
從某個模塊中導入多個函數,格式為： from somemodule import firstfunc, secondfunc, thirdfunc
將某個模塊中的全部函數導入，格式為： from somemodule import *
變量
Python3中有六個標准的數據類型：
Number（數值）、String（字符串）、List（列表）、Tuple（元組）、Set（集合）、Dictionary（字典）
其中：
不可變數據（3 個）：Number（數字）、String（字符串）、Tuple（元組）；
可變數據（3 個）：List（列表）、Dictionary（字典）、Set（集合）。
變量命名規范
了解兩種變量命名方式：
Pascal（帕斯卡命名法）：首單詞首字母大寫，后面單詞首字母大寫，如FirstName
Camel（駝峰命名法）：首單詞首字母小寫，后面單詞首字母大寫，如firstName
-
變量名可以由字母、數字、下划線組成
-
變量名不能以數字開頭，所以var1 是一個合法的變量名，但是1var 就是一個非法的變量名
-
Python 的關鍵字不能用作變量名，如print 和import
-
變量區分大小寫，var和VAR是不一樣的
-
變量是動態的，即不需要定義變量的類型
-
多個變量可以在同一行賦值，x,y,z=1,2,3等同於x=1，x=2，x=3
創建變量很簡單，只要為變量分配一個值即可。例如：
var1 = 110 var2 = "Hello World!" print var1,var2運行結果
110 Hello World!
數值類型Number
Python 支持三種不同的數值類型：
整型(Int) - 通常被稱為是整型或整數，是正或負整數，不帶小數點。Python3 整型是沒有限制大小的，可以當作 Long 類型使用，所以 Python3 沒有 Python2 的 Long 類型。
布爾（bool）, 如 True，False。
浮點型(float) - 浮點型由整數部分與小數部分組成，浮點型也可以使用科學計數法表示（2.5e2 = 2.5 x 10^2 = 250）
復數( (complex)) - 復數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示， 復數的實部a和虛部b都是浮點型。
數值類型轉換
有時候，我們需要對數據內置的類型進行轉換，數據類型的轉換，你只需要將數據類型作為函數名即可。
-
int(x) 將x轉換為一個整數
-
float(x) 將x轉換到一個浮點數
-
complex(x) 將x轉換到一個復數，實數部分為 x，虛數部分為 0
-
complex(x, y) 將 x 和 y 轉換到一個復數，實數部分為 x，虛數部分為 y。x 和 y 是數字表達式
a=1.0 print int(a)運行結果
1
數值運算
Python 解釋器可以作為一個簡單的計算器，您可以在解釋器里輸入一個表達式，它將輸出表達式的值。
表達式的語法很直白： + , - , * 和 / , 和其它語言（如Pascal或C）里一樣。例如：
print 2+2
print 2-2
print 2*2
print 2/2
運行結果
4
0
4
1
不同類型的數混合運算時會將整數轉換為浮點數：
print 10/3 # 分子和分母都是整數，返回整數，Python2和Python3不同
print 10.0/3 # 分子或分母有一個是浮點型，返回浮點型
print 10/3.0 # 分子或分母有一個是浮點型，返回浮點型
print 10//3 # 整數除法返回向下取整后的結果
print 10%3 # 返回除法的余數
運行結果
3
3.33333333333
3.33333333333
3
1
Python 可以使用 ** 操作來進行冪運算：
print 5 ** 2 # 5 的平方
print 2 ** 7 # 2的7次方
運行結果
25
128
數學函數
| 函數 | 返回值 ( 描述 ) |
|---|---|
| abs(x) | 返回數字的絕對值，如abs(-10) 返回 10 |
| ceil(x) | 返回數字的上入整數，如math.ceil(4.1) 返回 5 |
| cmp(x, y) | 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 **Python 3 已廢棄，使用 (x>y)-(x。 |
| exp(x) | 返回e的x次冪(ex),如math.exp(1) 返回2.718281828459045 |
| fabs(x) | 返回數字的絕對值，如math.fabs(-10) 返回10.0 |
| floor(x) | 返回數字的下舍整數，如math.floor(4.9)返回 4 |
| log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
| log10(x) | 返回以10為基數的x的對數，如math.log10(100)返回 2.0 |
| max(x1, x2,...) | 返回給定參數的最大值，參數可以為序列。 |
| min(x1, x2,...) | 返回給定參數的最小值，參數可以為序列。 |
| modf(x) | 返回x的整數部分與小數部分，兩部分的數值符號與x相同，整數部分以浮點型表示。 |
| pow(x, y) | x**y 運算后的值。 |
| [round(x ,n]) | 返回浮點數x的四舍五入值，如給出n值，則代表舍入到小數點后的位數。 |
| sqrt(x) | 返回數字x的平方根。 |
代碼
import math
print "abs(-10):"
print abs(-10),"\n"
print "ceil(4.1):"
print math.ceil(4.1),"\n"
print "math.exp(1):"
print math.exp(1),"\n"
print "math.fabs(-10):"
print math.fabs(-10),"\n"
print "math.floor(4.9):"
print math.floor(4.9),"\n"
print "math.log(100,10):"
print math.log(100,10),"\n"
print "math.log10(100):"
print math.log10(100),"\n"
print "max(1,3,5,7,100):"
print max(1,3,5,7,100),"\n"
print "min(1,3,5,7,100):"
print min(1,3,5,7,100),"\n"
print "math.modf(10.6):"
print math.modf(10.6),"\n"
print "math.pow(2,8):"
print math.pow(2,8),"\n"
print "round(10.61,1):"
print round(10.61,1),"\n"
print "math.sqrt(5):"
print math.sqrt(5)
運行結果
abs(-10):
10
ceil(4.1):
5.0
math.exp(1):
2.71828182846
math.fabs(-10):
10.0
math.floor(4.9):
4.0
math.log(100,10):
2.0
math.log10(100):
2.0
max(1,3,5,7,100):
100
min(1,3,5,7,100):
1
math.modf(10.6):
(0.5999999999999996, 10.0)
math.pow(2,8):
256.0
round(10.61,1):
10.6
math.sqrt(5):
2.2360679775
隨機數函數
隨機數可以用於數學，游戲，安全等領域中，還經常被嵌入到算法中，用以提高算法效率，並提高程序的安全性。
Python包含以下常用隨機數函數：
| 函數 | 描述 |
|---|---|
| choice(seq) | 從序列的元素中隨機挑選一個元素，比如random.choice(range(10))，從0到9中隨機挑選一個整數。 |
| [randrange (start,] stop [,step]) | 從指定范圍內，按指定基數遞增的集合中獲取一個隨機數，基數默認值為 1 |
| random() | 隨機生成下一個實數，它在[0,1)范圍內。 |
| seed(x) | 改變隨機數生成器的種子seed。如果你不了解其原理，你不必特別去設定seed，Python會幫你選擇seed。 |
| shuffle(lst) | 將序列的所有元素隨機排序 |
| uniform(x, y) | 隨機生成下一個實數，它在[x,y]范圍內。 |
代碼
import random
print "從 range(10) 返回一個隨機數:"
print random.choice(range(10)),"\n"
print "從 1-100 中選取一個奇數:"
print random.randrange(1, 100, 2),"\n"
print "隨機生成下一個實數，它在[0,1)范圍內:"
print random.random(),"\n"
print "使用種子10生成隨機數："
random.seed(10)
print random.random(),"\n"
print "將序列[1,2,3,4,5,6,7,8]隨機排列:"
list = [1,2,3,4,5,6,7,8]
random.shuffle(list)
print list,"\n"
print "隨機生成1-20之間的隨機實數:"
print random.uniform(1,20),"\n"
運行結果（結果不一致是正常的，一樣就見了鬼了）
從 range(10) 返回一個隨機數:
5
從 1-100 中選取一個奇數:
21
隨機生成下一個實數，它在[0,1)范圍內:
0.804882972117
使用種子10生成隨機數：
0.57140259469
將序列[1,2,3,4,5,6,7,8]隨機排列:
[3, 1, 6, 8, 7, 2, 5, 4]
隨機生成1-20之間的隨機實數:
10.8927178332
三角函數
| 函數 | 描述 |
|---|---|
| acos(x) | 返回x的反余弦弧度值。x只能在(-1，1)之間 |
| asin(x) | 返回x的反正弦弧度值。 |
| atan(x) | 返回x的反正切弧度值。 |
| atan2(y, x) | 返回給定的 X 及 Y 坐標值的反正切值。 |
| cos(x) | 返回x的弧度的余弦值。 |
| hypot(x, y) | 返回歐幾里德范數 sqrt(xx + yy)。 |
| sin(x) | 返回的x弧度的正弦值。 |
| tan(x) | 返回x弧度的正切值。 |
| degrees(x) | 將弧度轉換為角度,如degrees(math.pi/2) ， 返回90.0 |
| radians(x) | 將角度轉換為弧度 |
代碼
import math
print "0.5的反余弦度數：math.acos(0.5)"
degree = math.acos(0.5)
print degree * 180/math.pi
print "\n0.5的反正弦度數：math.asin(0.5)"
degree = math.asin(0.5)
print degree * 180/math.pi
print "\n1的反正切度數：math.atan(1)"
degree = math.atan(1)
print degree * 180/math.pi
print "\n(1,1)坐標反正切度數：math.atan2(1,1)"
degree = math.atan2(1,1)
print degree * 180/math.pi
print "\npi/3的余弦值：math.cos(math.pi/3)"
print math.cos(math.pi/3)
print "\n(1,1)的歐幾里德范數（向量距離）：math.hypot(1,1)"
print math.hypot(1,1)
print "\npi/6正弦值：math.sin(math.pi/6)"
print math.sin(math.pi/6)
print "\npi/4正切值：math.tan(math.pi/4)"
print math.tan(math.pi/4)
print "\n0.5反正切度數：math.degrees(math.asin(0.5))"
print math.degrees(math.asin(0.5))
print "\n將45度轉為弧度：math.radians(45)"
print math.radians(45)
運行結果
0.5的反余弦度數：math.acos(0.5)
60.0
0.5的反正弦度數：math.asin(0.5)
30.0
1的反正切度數：math.atan(1)
45.0
(1,1)坐標反正切度數：math.atan2(1,1)
45.0
pi/3的余弦值：math.cos(math.pi/3)
0.5
(1,1)的歐幾里德范數（向量距離）：math.hypot(1,1)
1.41421356237
pi/6正弦值：math.sin(math.pi/6)
0.5
pi/4正切值：math.tan(math.pi/4)
1.0
0.5反正切度數：math.degrees(math.asin(0.5))
30.0
將45度轉為弧度：math.radians(45)
0.785398163397
數值常量
| 常量 | 描述 |
|---|---|
| pi | 數學常量 pi（圓周率，一般以π來表示） |
| e | 數學常量 e，e即自然常數（自然常數） |
代碼
import math
print "math.pi:",math.pi
print "math.e:",math.e
運行結果
math.pi: 3.14159265359
math.e: 2.71828182846
字符串String
字符串是 Python 中最常用的數據類型。我們可以使用引號( ' 或 " )來創建字符串。
訪問字符串中的值
Python 不支持單字符類型，單字符在 Python 中也是作為一個字符串使用。
Python 訪問子字符串，可以使用方括號來截取字符串，如下實例：
var1 = 'Hello World!'
var2 = "Runoob"
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])
運行結果
('var1[0]: ', 'H')
('var2[1:5]: ', 'unoo')
字符串更新
你可以截取字符串的一部分並與其他字段拼接，如下實例：
var1 = 'Hello World!'
print ("已更新字符串 : ", var1[:6] + 'bighead!')
運行結果
已更新字符串 : Hello bighead!
轉義字符
在需要在字符中使用特殊字符時，python用反斜杠()轉義字符。如下表
| 轉義字符 | 描述 |
|---|---|
| \(在行尾時) | 續行符 |
| \\ | 反斜杠符號 |
| \' | 單引號 |
| \" | 雙引號 |
| \a | 響鈴 |
| \b | 退格(Backspace) |
| \000 | 空 |
| \n | 換行 |
| \v | 縱向制表符 |
| \t | 橫向制表符 |
| \r | 回車 |
| \f | 換頁 |
| \oyy | 八進制數，yy 代表的字符，例如：\o12 代表換行，其中 o 是字母，不是數字 0。 |
| \xyy | 十六進制數，yy代表的字符，例如：\x0a代表換行 |
| \other | 其它的字符以普通格式輸出 |
字符串運算符
下表實例變量a值為字符串 "Hello"，b變量值為 "Python"：
| 操作符 | 描述 | 實例 |
|---|---|---|
| + | 字符串連接 | a + b 輸出結果： HelloPython |
| * | 重復輸出字符串 | a*2 輸出結果：HelloHello |
| [] | 通過索引獲取字符串中字符 | a[1] 輸出結果 e |
| [ : ] | 截取字符串中的一部分，遵循左閉右開原則，str[0,2] 是不包含第 3 個字符的。 | a[1:4] 輸出結果 ell |
| in | 成員運算符 - 如果字符串中包含給定的字符返回 True | 'H' in a 輸出結果 True |
| not in | 成員運算符 - 如果字符串中不包含給定的字符返回 True | 'M' not in a 輸出結果 True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思來使用，沒有轉義特殊或不能打印的字符。 原始字符串除在字符串的第一個引號前加上字母 r（可以大小寫）以外，與普通字符串有着幾乎完全相同的語法。 | print(r"\n") |
代碼
a = "Hello"
b = "Python"
print "a+b: ",a+b
print"a * 2: ", a * 2
print "a[1]: ", a[1]
print "a[1:4]：", a[1:4]
if( "H" in a) :
print("H 在變量 a 中")
else :
print("H 不在變量 a 中")
if( "M" not in a) :
print("M 不在變量 a 中")
else :
print("M 在變量 a 中")
print (r'\n')
print (R'\n')
運行結果
a+b: HelloPython
a * 2: HelloHello
a[1]: e
a[1:4]： ell
H 在變量 a 中
M 不在變量 a 中
\n
\n
字符串格式化
Python 支持格式化字符串的輸出 。盡管這樣可能會用到非常復雜的表達式，但最基本的用法是將一個值插入到一個有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用與 C 中 sprintf 函數一樣的語法。
print ("我叫 %s 今年 %d 歲!" % ('小明', 10))
運行結果
我叫 小明 今年 10 歲!
Python字符串格式化符號:
| 符 號 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII碼 |
| %s | 格式化字符串 |
| %d | 格式化整數 |
| %u | 格式化無符號整型 |
| %o | 格式化無符號八進制數 |
| %x | 格式化無符號十六進制數 |
| %X | 格式化無符號十六進制數（大寫） |
| %f | 格式化浮點數字，可指定小數點后的精度 |
| %e | 用科學計數法格式化浮點數 |
| %E | 作用同%e，用科學計數法格式化浮點數 |
| %g | %f和%e的簡寫 |
| %G | %f 和 %E 的簡寫 |
| %p | 用十六進制數格式化變量的地址 |
Python2.6 開始，新增了一種格式化字符串的函數 str.format()，它增強了字符串格式化的功能。
基本語法是通過 {} 和 : 來代替以前的 % 。
format 函數可以接受不限個參數，位置可以不按順序。
代碼
print("網站名：{name}, 地址： {url}".format(name="和尚的博客", url="www.bighead.fun"))
# 通過列表索引設置參數
print("網站名：{0}, 地址： {1}".format("和尚的博客", "www.bighead.fun"))
運行結果
網站名：和尚的博客, 地址： www.bighead.fun
網站名：和尚的博客, 地址： www.bighead.fun
三引號
python三引號允許一個字符串跨多行，字符串中可以包含換行符、制表符以及其他特殊字符。實例如下
para_str = """這是一個多行字符串的實例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用換行符 [ \n ]。
"""
print (para_str)
運行結果
這是一個多行字符串的實例
多行字符串可以使用制表符
TAB ( )。
也可以使用換行符 [
]。
三引號讓程序員從引號和特殊字符串的泥潭里面解脫出來，自始至終保持一小塊字符串的格式是所謂的WYSIWYG（所見即所得）格式的。
一個典型的用例是，當你需要一塊HTML或者SQL時，這時用字符串組合，特殊字符串轉義將會非常的繁瑣。
Unicode 字符串
在Python2中，普通字符串是以8位ASCII碼進行存儲的，而Unicode字符串則存儲為16位unicode字符串，這樣能夠表示更多的字符集。使用的語法是在字符串前面加上前綴 u。
在Python3中，所有的字符串都是Unicode字符串。
字符串內建函數
| 序號 | 方法及描述 |
|---|---|
| 1 | capitalize() 將字符串的第一個字符轉換為大寫 |
| 2 | center(width, fillchar) 返回一個指定的寬度 width 居中的字符串，fillchar 為填充的字符，默認為空格。 |
| 3 | count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出現的次數，如果 beg 或者 end 指定則返回指定范圍內 str 出現的次數 |
| 4 | bytes.decode(encoding="utf-8", errors="strict") Python3 中沒有 decode 方法，但我們可以使用 bytes 對象的 decode() 方法來解碼給定的 bytes 對象，這個 bytes 對象可以由 str.encode() 來編碼返回。 |
| 5 | encode(encoding='UTF-8',errors='strict') 以 encoding 指定的編碼格式編碼字符串，如果出錯默認報一個ValueError 的異常，除非 errors 指定的是'ignore'或者'replace' |
| 6 | endswith(suffix, beg=0, end=len(string)) 檢查字符串是否以 obj 結束，如果beg 或者 end 指定則檢查指定的范圍內是否以 obj 結束，如果是，返回 True,否則返回 False. |
| 7 | expandtabs(tabsize=8) 把字符串 string 中的 tab 符號轉為空格，tab 符號默認的空格數是 8 。 |
| 8 | find(str, beg=0, end=len(string)) 檢測 str 是否包含在字符串中，如果指定范圍 beg 和 end ，則檢查是否包含在指定范圍內，如果包含返回開始的索引值，否則返回-1 |
| 9 | index(str, beg=0, end=len(string)) 跟find()方法一樣，只不過如果str不在字符串中會報一個異常. |
| 10 | isalnum() 如果字符串至少有一個字符並且所有字符都是字母或數字則返 回 True,否則返回 False |
| 11 | isalpha() 如果字符串至少有一個字符並且所有字符都是字母則返回 True, 否則返回 False |
| 12 | isdigit() 如果字符串只包含數字則返回 True 否則返回 False.. |
| 13 | islower() 如果字符串中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是小寫，則返回 True，否則返回 False |
| 14 | isnumeric() 如果字符串中只包含數字字符，則返回 True，否則返回 False |
| 15 | isspace() 如果字符串中只包含空白，則返回 True，否則返回 False. |
| 16 | istitle() 如果字符串是標題化的(見 title())則返回 True，否則返回 False |
| 17 | isupper() 如果字符串中包含至少一個區分大小寫的字符，並且所有這些(區分大小寫的)字符都是大寫，則返回 True，否則返回 False |
| 18 | join(seq) 以指定字符串作為分隔符，將 seq 中所有的元素(的字符串表示)合並為一個新的字符串 |
| 19 | len(string) 返回字符串長度 |
| 20 | ljust(width[, fillchar])返回一個原字符串左對齊,並使用 fillchar 填充至長度 width 的新字符串，fillchar 默認為空格。 |
| 21 | lower() 轉換字符串中所有大寫字符為小寫. |
| 22 | lstrip() 截掉字符串左邊的空格或指定字符。 |
| 23 | maketrans() 創建字符映射的轉換表，對於接受兩個參數的最簡單的調用方式，第一個參數是字符串，表示需要轉換的字符，第二個參數也是字符串表示轉換的目標。 |
| 24 | max(str) 返回字符串 str 中最大的字母。 |
| 25 | min(str) 返回字符串 str 中最小的字母。 |
| 26 | replace(old, new [, max])把 將字符串中的 str1 替換成 str2,如果 max 指定，則替換不超過 max 次。 |
| 27 | rfind(str, beg=0,end=len(string)) 類似於 find()函數，不過是從右邊開始查找. |
| 28 | rindex( str, beg=0, end=len(string)) 類似於 index()，不過是從右邊開始. |
| 29 | rjust(width,[, fillchar])返回一個原字符串右對齊,並使用fillchar(默認空格）填充至長度 width 的新字符串 |
| 30 | rstrip() 刪除字符串字符串末尾的空格. |
| 31 | split(str="", num=string.count(str)) num=string.count(str)) 以 str 為分隔符截取字符串，如果 num 有指定值，則僅截取 num+1 個子字符串 |
| 32 | splitlines([keepends])按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表，如果參數 keepends 為 False，不包含換行符，如果為 True，則保留換行符。 |
| 33 | startswith(substr, beg=0,end=len(string)) 檢查字符串是否是以指定子字符串 substr 開頭，是則返回 True，否則返回 False。如果beg 和 end 指定值，則在指定范圍內檢查。 |
| 34 | strip([chars])在字符串上執行 lstrip()和 rstrip() |
| 35 | swapcase() 將字符串中大寫轉換為小寫，小寫轉換為大寫 |
| 36 | title() 返回"標題化"的字符串,就是說所有單詞都是以大寫開始，其余字母均為小寫(見 istitle()) |
| 37 | translate(table, deletechars="") 根據 str 給出的表(包含 256 個字符)轉換 string 的字符, 要過濾掉的字符放到 deletechars 參數中 |
| 38 | upper() 轉換字符串中的小寫字母為大寫 |
| 39 | zfill (width) 返回長度為 width 的字符串，原字符串右對齊，前面填充0 |
| 40 | isdecimal() 檢查字符串是否只包含十進制字符，如果是返回 true，否則返回 false。 |
代碼
# -*- coding: cp936 -*-
mystr = "This is Bighead's blog!"
print mystr
### 字符串長度
print "一、字符串長度"
print "19-返回對象（字符、列表、元組等）長度或項目個數。"
print 'len(mystr)：',len(mystr)
###大小寫轉換及判斷
print "\n\n二、大小寫轉換及判斷"
print "01-將字符串的第一個字母變成大寫,其他字母變小寫"
print "mystr.capitalize() : ", mystr.capitalize()
print "\n36-返回標題化的字符串，即所有單詞都是以大寫開始，其余字母均為小寫。"
print "mystr.title() : ", mystr.title()
print "\n21-轉換字符串中所有大寫字符為小寫。"
print "mystr.lower() : ", mystr.lower()
print "\n38-轉換字符串中的小寫字母為大寫。"
print "mystr.upper() : ", mystr.upper()
print "\n35-將字符串中大寫轉換為小寫，小寫轉換為大寫。"
print "mystr.swapcase() : ", mystr.swapcase()
print "\n24-返回字符串中最大的字母。"
print "max(mystr) : ", max(mystr)
print "\n25-返回字符串中最小的字母。"
print "min(mystr) : ", min(mystr)
print "\n17-檢測字符串中所有的字母是否都為大寫。"
print 'mystr.isupper()：',mystr.isupper()
print '"BIGHEAD".isupper()：',"BIGHEAD".isupper()
print "\n16-檢測字符串是否標題化，即所有的單詞拼寫首字母是否為大寫，且其他字母為小寫。。"
print 'mystr.istitle()：',mystr.istitle()
print '"Hello World".istitle()：',"Hello World".istitle()
### 首尾字符處理
print "\n\n三、首尾字符處理"
print "34-移除字符串頭尾指定的字符（默認為空格）或字符序列。"
print "mystr.strip() : ", mystr.strip()
print 'mystr.strip("T!") : ', mystr.strip("T!")
print "\n22-截掉字符串左邊的空格或指定字符。"
print "mystr.lstrip() : ", mystr.lstrip()
print 'mystr.lstrip("This") : ', mystr.lstrip("This")
print "\n30-刪除字符串末尾的指定字符（默認為空格）."
print "mystr.rstrip() : ", mystr.rstrip()
print 'mystr.rstrip("!") : ', mystr.rstrip("!")
### 查找字符
print "\n\n四、查找字符"
print "03-統計字符串里某個字符出現的次數。可選參數為在字符串搜索的開始與結束位置。"
print "mystr.count('h') : ", mystr.count("h")
print "mystr.count('h',1,5) : ", mystr.count('h',1,5)
print "\n33-檢查字符串是否是以指定子字符串開頭，如果是則返回 True，否則返回 False。如果參數 beg 和 end 指定值，則在指定范圍內檢查。"
print 'mystr.startswith("T")：',mystr.startswith("T")
print 'mystr.startswith("Th")：',mystr.startswith("Th")
print 'mystr.startswith("T",12,-1)：',mystr.startswith("g",12,-1)
print "\n06-判斷字符串是否以指定后綴結尾，如果以指定后綴結尾返回 True，否則返回 False。"
print 'mystr.endswith("g!")：',mystr.endswith("g!")
print 'mystr.endswith("g")：',mystr.endswith("g")
print 'mystr.endswith("g",0,11)：',mystr.endswith("g",0,11)
print "\n08-檢測字符串中是否包含子字符串，返回索引值，如果不包含返回-1。"
print 'mystr.find("ea")：',mystr.find("ea")
print 'mystr.find("ea",0,10)：',mystr.find("ea",0,10)
print "\n27-返回字符串最后一次出現的位置，如果沒有匹配項則返回-1。。"
print 'mystr.rfind("ea")：',mystr.rfind("ea")
print 'mystr.rfind("ea",0,10)：',mystr.rfind("ea",0,10)
print "\n09-檢測字符串中是否包含子字符串，返回索引值，如果不包含會報異常。"
print 'mystr.index("ea")：',mystr.index("ea")
#print 'mystr.index("ea",0,10)：',mystr.index("ea",0,10) #可自行嘗試
print "\n28-檢測字符串中是否包含子字符串，返回索引值，如果不包含會報異常。"
print 'mystr.rindex("ea")：',mystr.rindex("ea")
#print 'mystr.rindex("ea",0,10)：',mystr.rindex("ea",0,10) #可自行嘗試
### 字符串給定長度格式化
print "\n\n五、字符串給定長度格式化"
print "02-返回一個指定的寬度 width 居中的字符串，如果 width 小於字符串寬度直接返回字符串，否則使用 fillchar 去填充。"
print "mystr.center(40, '*') : ", mystr.center(40, '*')
print "\n20-返回一個原字符串左對齊,並使用空格填充至指定長度的新字符串。如果指定的長度小於原字符串的長度則返回原字符串。"
print "mystr.ljust(40, '*') : ", mystr.ljust(40, '*')
print "\n29-返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串。如果指定的長度小於字符串的長度則返回原字符串。"
print "mystr.rjust(40, '*') : ", mystr.rjust(40, '*')
print "\n39-返回指定長度的字符串，原字符串右對齊，前面填充0。"
print "mystr.zfill(40) : ", mystr.zfill(40)
### 字符串內容替換
print "\n\n六、字符串內容替換"
print "07-把字符串 mystring 中的 tab 符號轉為空格，tab 符號默認的空格數是 8 。"
tabmystr = "This is \t Bighead's blog!"
print tabmystr
print "tabmystr.expandtabs()：",tabmystr.expandtabs()
print "tabmystr.expandtabs(4)：",tabmystr.expandtabs(4)
print "\n26-把字符串中的 old（舊字符串） 替換成 new(新字符串)，如果指定第三個參數max，則替換不超過 max 次。"
print 'mystr.replace("is", "was")',mystr.replace("is", "was")
print 'mystr.replace("is", "was",1)',mystr.replace("is", "was",1)
from string import maketrans # 必須調用 maketrans 函數。
print "\n23-創建字符映射的轉換表,兩個字符串的長度必須相同，為一一對應的關系。"
intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)
print "mystr.translate(trantab)：",mystr.translate(trantab)
from string import maketrans # 必須調用 maketrans 函數。
print "\n37-根據參數table給出的表(包含 256 個字符)轉換字符串的字符,要過濾掉的字符放到 deletechars 參數中。"
intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab) #制作翻譯表
print "mystr.translate(trantab)：",mystr.translate(trantab)
print "mystr.translate(trantab,'i')：",mystr.translate(trantab,'i')
### 字符串分割連接
print "\n\n七、字符串分割連接"
print "31-通過指定分隔符對字符串進行切片，如果第二個參數 num 有指定值，則分割為 num+1 個子字符串。"
pathstr = r"C:\Users\Admin\Desktop\test"
print pathstr
print "pathstr.split('\\') : ", pathstr.split('\\')
print 'pathstr.split("\\",2) : ', pathstr.split("\\",2)
print "\n32-按照行('\r', '\r\n', \n')分隔，返回一個包含各行作為元素的列表，如果參數 keepends 為 False，不包含換行符，如果為 True，則保留換行符。"
linestr = "hello\nworld!"
print linestr
print "linestr.splitlines() : ", linestr.splitlines()
print 'linestr.splitlines(True) : ', linestr.splitlines(True)
print "\n18-將序列中的元素以指定的字符連接生成一個新的字符串。"
print '"-".join(["hello","world","pyhton"])：',"-".join(["hello","world","pyhton"])
### 字符串組成校驗
print "\n\n八、字符串組成校驗"
print "10-檢測字符串是否由字母和數字組成。"
print 'mystr.isalnum()：',mystr.isalnum() #有空格
print '"bighead123".isalnum()：',"bighead123".isalnum()
print "\n11-檢測字符串是否只由字母或文字組成。"
print 'mystr.isalpha()：',mystr.isalpha() #有空格
print '"i愛".isalpha()：',"i愛".isalpha() #Python2返回仍是False，Python3返回True
print "\n12-檢測字符串是否只由數字組成。"
print 'mystr.isdigit()：',mystr.isdigit()
print '"1235".isdigit()：',"1235".isdigit()
print "\n40-檢查字符串是否只包含十進制字符。這種方法只存在於unicode對象。"
print "u'123'.isdecimal() : ", u'123'.isdecimal()
print "mystr.decode('gbk').isdecimal() : ", mystr.decode('gbk').isdecimal()
print "\n13-檢測字符串是否由小寫字母組成。"
print 'mystr.islower()：',mystr.islower()
print '"bighead".islower()：',"bighead".islower()
print "\n14-檢測字符串是否只由數字組成，這種方法只針對unicode對象。"
#print 'mystr.isnumeric()：',mystr.isnumeric() #可自行嘗試，非Unicode編碼報錯
print 'u"123".isnumeric()：',u"123".isnumeric()
print "\n15-檢測字符串是否只由空白字符組成。"
print 'mystr.isspace()：',mystr.isspace()
print '" ".isspace()：'," ".isspace()
### 字符串編碼解碼
print "\n\n九、字符串編碼解碼"
print "04-以指定的編碼格式編碼字符串。"
print "UTF-8 編碼 mystr.encode('UTF-8','mystrict')：", mystr.encode('UTF-8','mystrict')
#以下語句在Python3，可正常運行，有條件可以嘗試
#print "UTF-8 編碼 'i愛'.encode('UTF-8','mystrict')：", 'i愛'.encode('UTF-8','mystrict')
#print "UTF-8 編碼 'i愛'.encode('UTF-8','mystrict').decode('UTF-8','mystrict')：", 'i愛'.encode('UTF-8','mystrict').decode('UTF-8','mystrict')
#下面為上面代碼運行結果
'''
UTF-8 編碼 'i愛'.encode('UTF-8','mystrict')： b'i\xe7\x88\xb1'
UTF-8 編碼 'i愛'.encode('UTF-8','mystrict').decode('UTF-8','mystrict')： i愛
'''
print "\n05-以指定的編碼格式解碼 bytes 對象。默認編碼為 'utf-8'。"
print "UTF-8 解碼 mystr.decode('UTF-8','mystrict')：", mystr.decode('UTF-8','mystrict')
運行結果
This is Bighead's blog!
一、字符串長度
19-返回對象（字符、列表、元組等）長度或項目個數。
len(mystr)： 23
二、大小寫轉換及判斷
01-將字符串的第一個字母變成大寫,其他字母變小寫
mystr.capitalize() : This is bighead's blog!
36-返回標題化的字符串，即所有單詞都是以大寫開始，其余字母均為小寫。
mystr.title() : This Is Bighead'S Blog!
21-轉換字符串中所有大寫字符為小寫。
mystr.lower() : this is bighead's blog!
38-轉換字符串中的小寫字母為大寫。
mystr.upper() : THIS IS BIGHEAD'S BLOG!
35-將字符串中大寫轉換為小寫，小寫轉換為大寫。
mystr.swapcase() : tHIS IS bIGHEAD'S BLOG!
24-返回字符串中最大的字母。
max(mystr) : s
25-返回字符串中最小的字母。
min(mystr) :
17-檢測字符串中所有的字母是否都為大寫。
mystr.isupper()： False
"BIGHEAD".isupper()： True
16-檢測字符串是否標題化，即所有的單詞拼寫首字母是否為大寫，且其他字母為小寫。。
mystr.istitle()： False
"Hello World".istitle()： True
三、首尾字符處理
34-移除字符串頭尾指定的字符（默認為空格）或字符序列。
mystr.strip() : This is Bighead's blog!
mystr.strip("T!") : his is Bighead's blog
22-截掉字符串左邊的空格或指定字符。
mystr.lstrip() : This is Bighead's blog!
mystr.lstrip("This") : is Bighead's blog!
30-刪除字符串末尾的指定字符（默認為空格）.
mystr.rstrip() : This is Bighead's blog!
mystr.rstrip("!") : This is Bighead's blog
四、查找字符
03-統計字符串里某個字符出現的次數。可選參數為在字符串搜索的開始與結束位置。
mystr.count('h') : 2
mystr.count('h',1,5) : 1
33-檢查字符串是否是以指定子字符串開頭，如果是則返回 True，否則返回 False。如果參數 beg 和 end 指定值，則在指定范圍內檢查。
mystr.startswith("T")： True
mystr.startswith("Th")： True
mystr.startswith("T",12,-1)： False
06-判斷字符串是否以指定后綴結尾，如果以指定后綴結尾返回 True，否則返回 False。
mystr.endswith("g!")： True
mystr.endswith("g")： False
mystr.endswith("g",0,11)： True
08-檢測字符串中是否包含子字符串，返回索引值，如果不包含返回-1。
mystr.find("ea")： 12
mystr.find("ea",0,10)： -1
27-返回字符串最后一次出現的位置，如果沒有匹配項則返回-1。。
mystr.rfind("ea")： 12
mystr.rfind("ea",0,10)： -1
09-檢測字符串中是否包含子字符串，返回索引值，如果不包含會報異常。
mystr.index("ea")： 12
28-檢測字符串中是否包含子字符串，返回索引值，如果不包含會報異常。
mystr.rindex("ea")： 12
五、字符串給定長度格式化
02-返回一個指定的寬度 width 居中的字符串，如果 width 小於字符串寬度直接返回字符串，否則使用 fillchar 去填充。
mystr.center(40, '*') : ********This is Bighead's blog!*********
20-返回一個原字符串左對齊,並使用空格填充至指定長度的新字符串。如果指定的長度小於原字符串的長度則返回原字符串。
mystr.ljust(40, '*') : This is Bighead's blog!*****************
29-返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串。如果指定的長度小於字符串的長度則返回原字符串。
mystr.rjust(40, '*') : *****************This is Bighead's blog!
39-返回指定長度的字符串，原字符串右對齊，前面填充0。
mystr.zfill(40) : 00000000000000000This is Bighead's blog!
六、字符串內容替換
07-把字符串 mystring 中的 tab 符號轉為空格，tab 符號默認的空格數是 8 。
This is Bighead's blog!
tabmystr.expandtabs()： This is Bighead's blog!
tabmystr.expandtabs(4)： This is Bighead's blog!
26-把字符串中的 old（舊字符串） 替換成 new(新字符串)，如果指定第三個參數max，則替換不超過 max 次。
mystr.replace("is", "was") Thwas was Bighead's blog!
mystr.replace("is", "was",1) Thwas is Bighead's blog!
23-創建字符映射的轉換表,兩個字符串的長度必須相同，為一一對應的關系。
mystr.translate(trantab)： Th3s 3s B3gh21d's bl4g!
37-根據參數table給出的表(包含 256 個字符)轉換字符串的字符,要過濾掉的字符放到 deletechars 參數中。
mystr.translate(trantab)： Th3s 3s B3gh21d's bl4g!
mystr.translate(trantab,'i')： Ths s Bgh21d's bl4g!
七、字符串分割連接
31-通過指定分隔符對字符串進行切片，如果第二個參數 num 有指定值，則分割為 num+1 個子字符串。
C:\Users\Admin\Desktop\test
pathstr.split('\') : ['C:', 'Users', 'Admin', 'Desktop', 'test']
pathstr.split("\",2) : ['C:', 'Users', 'Admin\\Desktop\\test']
32-按照行('
', '
',
')分隔，返回一個包含各行作為元素的列表，如果參數 keepends 為 False，不包含換行符，如果為 True，則保留換行符。
hello
world!
linestr.splitlines() : ['hello', 'world!']
linestr.splitlines(True) : ['hello\n', 'world!']
18-將序列中的元素以指定的字符連接生成一個新的字符串。
"-".join(["hello","world","pyhton"])： hello-world-pyhton
八、字符串組成校驗
10-檢測字符串是否由字母和數字組成。
mystr.isalnum()： False
"bighead123".isalnum()： True
11-檢測字符串是否只由字母或文字組成。
mystr.isalpha()： False
"i愛".isalpha()： False
12-檢測字符串是否只由數字組成。
mystr.isdigit()： False
"1235".isdigit()： True
40-檢查字符串是否只包含十進制字符。這種方法只存在於unicode對象。
u'123'.isdecimal() : True
mystr.decode('gbk').isdecimal() : False
13-檢測字符串是否由小寫字母組成。
mystr.islower()： False
"bighead".islower()： True
14-檢測字符串是否只由數字組成，這種方法只針對unicode對象。
u"123".isnumeric()： True
15-檢測字符串是否只由空白字符組成。
mystr.isspace()： False
" ".isspace()： True
九、字符串編碼解碼
04-以指定的編碼格式編碼字符串。
UTF-8 編碼 mystr.encode('UTF-8','mystrict')： This is Bighead's blog!
05-以指定的編碼格式解碼 bytes 對象。默認編碼為 'utf-8'。
UTF-8 解碼 mystr.decode('UTF-8','mystrict')： This is Bighead's blog!
列表List
列表是最常用的Python數據類型，它可以作為一個方括號內的逗號分隔值出現。
-
列表的數據項不需要具有相同的類型。
-
列表中的每個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。
創建一個列表，只要把逗號分隔的不同的數據項使用方括號括起來即可。如下所示：
list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]
運行結果
list1[0]: Google
list2[1:5]: [2, 3, 4, 5]
更新列表
可以對列表的數據項進行修改或更新 ，如下所示：
list = ['Google', 'Runoob', 1997, 2000]
print "第三個元素為 : ", list[2]
list[2] = 2001
print "更新后的第三個元素為 : ", list[2]
運行結果
第三個元素為 : 1997
更新后的第三個元素為 : 2001
刪除列表元素
可以使用 del 語句來刪除列表的的元素，如下實例：
list = ['Google', 'Runoob', 1997, 2000]
print "原始列表 : ", list
del list[2]
print "刪除第三個元素 : ", list
運行結果
原始列表 : ['Google', 'Runoob', 1997, 2000]
刪除第三個元素 : ['Google', 'Runoob', 2000]
Python列表腳本操作符
列表對 + 和 * 的操作符與字符串相似。+ 號用於組合列表，* 號用於重復列表
| Python 表達式 | 結果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 長度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 組合 |
| ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重復 |
| 3 in [1, 2, 3] | True | 元素是否存在於列表中 |
| for x in [1, 2, 3]: print(x, end=" ") | 1 2 3 | 迭代 |
Python列表截取與拼接
Python的列表截取與字符串操作類型，如下所示：
L=['Google', 'Runoob', 'Taobao']
| Python 表達式 | 結果 | 描述 |
|---|---|---|
| L[2] | 'Taobao' | 讀取第三個元素 |
| L[-2] | 'Runoob' | 從右側開始讀取倒數第二個元素: count from the right |
| L[1:] | ['Runoob', 'Taobao'] | 輸出從第二個元素開始后的所有元素 |
列表還支持拼接操作：
list = [1, 4, 9, 16, 25]
list += [36, 49, 64, 81, 100]
print list
運行結果
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
嵌套列表
使用嵌套列表即在列表里創建其它列表，例如：
a = ['a', 'b', 'c']
n = [1, 2, 3]
x = [a, n]
print x
print x[0]
print x[0][1]
運行結果
[['a', 'b', 'c'], [1, 2, 3]]
['a', 'b', 'c']
b
Python列表函數&方法
Python包含以下函數:
| 序號 | 函數 |
|---|---|
| 1 | len(list) 列表元素個數 |
| 2 | max(list) 返回列表元素最大值 |
| 3 | min(list) 返回列表元素最小值 |
| 4 | list(seq) 將元組轉換為列表 |
mylist = [1,2,3,"hello"]
print len(mylist)
print max(mylist)
mytuple = ("a","b","c") #小括號括起來的是元組
print list(mytuple)
運行結果
4
hello
['a', 'b', 'c']
Python包含以下方法:
| 序號 | 方法 |
|---|---|
| 1 | list.append(obj) 在列表末尾添加新的對象 |
| 2 | list.count(obj) 統計某個元素在列表中出現的次數 |
| 3 | list.extend(seq) 在列表末尾一次性追加另一個序列中的多個值（用新列表擴展原來的列表） |
| 4 | list.index(obj) 從列表中找出某個值第一個匹配項的索引位置 |
| 5 | list.insert(index, obj) 將對象插入列表 |
| 6 | list.pop([index=-1])移除列表中的一個元素（默認最后一個元素），並且返回該元素的值 |
| 7 | list.remove(obj) 移除列表中某個值的第一個匹配項 |
| 8 | list.reverse() 反向列表中元素 |
| 9 | list.sort( key=None, reverse=False) 對原列表進行排序 |
| 10 | list.clear() 清空列表 |
| 11 | list.copy() 復制列表 |
list1 = ['Google', 'Runoob', 'Taobao']
print "原列表：",list1
list1.append('Baidu')
print "\n1、添加元素后的列表\nlist1.append('Baidu') : ", list1
print "\n2、'Taobao'在列表中出現的次數\nlist.count('Taobao')：",list1.count("Taobao")
list2 = list(range(5))
list1.extend(list2)
print "\n3、擴展后的列表\nlist1.extend(range(5))：",list1
print "\n4、元素'Taobao'第一個匹配項的索引位置\nlist1.index('Taobao')",list1.index('Taobao')
list1.insert(2,'Tencent')
print "\n5、在索引為2處插入'Tencent'后的列表\nlist1.insert(2,'Tencent') ：",list1
list1.pop()
print "\n6、刪除最后一個元素后的列表\nlist1.pop() ：",list1
list1.pop(1)
print "刪除索引為1的一個元素后的列表\nlist1.pop(1) ：",list1
list1.remove(3)
print "\n7、刪除元素為3的第一個元素后的列表\nlist1.remove(3) ：",list1
list1.reverse()
print "\n8、反轉列表中元素后的列表\nlist1.reverse() ：",list1
list1.sort()
print "\n9、升序排列列表后的列表\nlist1.sort() ：",list1
list1.sort(reverse = True)
print "降序排列列表后的列表\nlist1.sort(reverse = False) ：",list1
### 最后兩種方法對於Python2不適用，有條件可在Python3測試
#list1.clear()
#print "\n10、清空后的列表\nlist1.clear() ：",list1
#list1=list2.copy()
#print "\n10、復制list2后的列表\nlist1=list2.copy() ：",list1
運行結果
原列表： ['Google', 'Runoob', 'Taobao']
1、添加元素后的列表
list1.append('Baidu') : ['Google', 'Runoob', 'Taobao', 'Baidu']
2、'Taobao'在列表中出現的次數
list.count('Taobao')： 1
3、擴展后的列表
list1.extend(range(5))： ['Google', 'Runoob', 'Taobao', 'Baidu', 0, 1, 2, 3, 4]
4、元素'Taobao'第一個匹配項的索引位置
list1.index('Taobao') 2
5、在索引為2處插入'Tencent'后的列表
list1.insert(2,'Tencent') ： ['Google', 'Runoob', 'Tencent', 'Taobao', 'Baidu', 0, 1, 2, 3, 4]
6、刪除最后一個元素后的列表
list1.pop() ： ['Google', 'Runoob', 'Tencent', 'Taobao', 'Baidu', 0, 1, 2, 3]
刪除索引為1的一個元素后的列表
list1.pop(1) ： ['Google', 'Tencent', 'Taobao', 'Baidu', 0, 1, 2, 3]
7、刪除元素為3的第一個元素后的列表
list1.remove(3) ： ['Google', 'Tencent', 'Taobao', 'Baidu', 0, 1, 2]
8、反轉列表中元素后的列表
list1.reverse() ： [2, 1, 0, 'Baidu', 'Taobao', 'Tencent', 'Google']
9、升序排列列表后的列表
list1.sort() ： [0, 1, 2, 'Baidu', 'Google', 'Taobao', 'Tencent']
降序排列列表后的列表
list1.sort(reverse = False) ： ['Tencent', 'Taobao', 'Google', 'Baidu', 2, 1, 0]
元組Tuple
-
Python 的元組與列表類似，不同之處在於元組的元素不能修改。
-
元組使用小括號，列表使用方括號。
元組創建很簡單，只需要在括號中添加元素，並使用逗號隔開即可
>>> tup1 = ('Google', 'Runoob', 1997, 2000);
>>> tup2 = (1, 2, 3, 4, 5 );
>>> tup3 = "a", "b", "c", "d"; # 不需要括號也可以
>>> type(tup3)
<class 'tuple'>
元組中只包含一個元素時，需要在元素后面添加逗號，否則括號會被當作運算符使用：
>>> tup1 = (50)
>>> type(tup1) # 不加逗號，類型為整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗號，類型為元組
<class 'tuple'>
訪問元組
元組可以使用下標索引來訪問元組中的值，如下實例:
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
運行結果
('tup1[0]: ', 'Google')
('tup2[1:5]: ', (2, 3, 4, 5))
修改元組
元組中的元素值是不允許修改的，但我們可以對元組進行連接組合，如下實例:
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
# 以下修改元組元素操作是非法的。
# tup1[0] = 100
# 創建一個新的元組
tup3 = tup1 + tup2;
print (tup3)
運行結果
(12, 34.56, 'abc', 'xyz')
刪除元組
元組中的元素值是不允許刪除的，但我們可以使用del語句來刪除整個元組，如下實例:
tup = ('Google', 'Runoob', 1997, 2000)
print (tup)
del tup;
print ("刪除后的元組 tup : ")
print (tup)
以上實例元組被刪除后，輸出變量會有異常信息，輸出如下所示：
('Google', 'Runoob', 1997, 2000)
刪除后的元組 tup :
Traceback (most recent call last):
File "C:\Users\Admin\Desktop\元組.py", line 6, in <module>
print (tup)
NameError: name 'tup' is not defined
元組運算符
與字符串一樣，元組之間可以使用 + 號和 * 號進行運算。這就意味着他們可以組合和復制，運算后會生成一個新的元組。
| Python 表達式 | 結果 | 描述 |
|---|---|---|
| len((1, 2, 3)) | 3 | 計算元素個數 |
| (1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | 連接 |
| ('Hi!',) * 4 | ('Hi!', 'Hi!', 'Hi!', 'Hi!') | 復制 |
| 3 in (1, 2, 3) | True | 元素是否存在 |
| for x in (1, 2, 3): print (x,) | 1 2 3 | 迭代 |
元組索引，截取
因為元組也是一個序列，所以我們可以訪問元組中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
L = ('Google', 'Taobao', 'Runoob')
| Python 表達式 | 結果 | 描述 |
|---|---|---|
| L[2] | 'Runoob' | 讀取第三個元素 |
| L[-2] | 'Taobao' | 反向讀取；讀取倒數第二個元素 |
| L[1:] | ('Taobao', 'Runoob') | 截取元素，從第二個開始后的所有元素。 |
元組內置函數
| 序號 | 方法及描述 | 實例 |
|---|---|---|
| 1 | len(tuple) 計算元組元素個數。 | >>> tuple1 = ('Google', 'Runoob', 'Taobao') >>> len(tuple1) 3 >>> |
| 2 | max(tuple) 返回元組中元素最大值。 | >>> tuple2 = ('5', '4', '8') >>> max(tuple2) '8' >>> |
| 3 | min(tuple) 返回元組中元素最小值。 | >>> tuple2 = ('5', '4', '8') >>> min(tuple2) '4' >>> |
| 4 | tuple(seq) 將列表轉換為元組。 | >>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu') |
字典Dictionary
字典是另一種可變容器模型，且可存儲任意類型對象。
字典的每個鍵值(key=>value)對用冒號(:)分割，每個對之間用逗號(,)分割，整個字典包括在花括號({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
-
鍵必須是唯一的，但值則不必。
-
值可以取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。
一個簡單的字典實例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
訪問字典里的值
把相應的鍵放入到方括號中，如下實例:
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print "dict['Name']: ", dict['Name']
print "dict['Age']: ", dict['Age']
運行結果
dict['Name']: Runoob
dict['Age']: 7
如果用字典里沒有的鍵訪問數據，會輸出錯誤 。
修改字典
向字典添加新內容的方法是增加新的鍵/值對，修改或刪除已有鍵/值對如下實例:
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8 # 更新 Age
dict['Blog'] = "大頭和尚" # 添加信息
print "dict['Age']: ", dict['Age']
print "dict['Blog']: ", dict['Blog']
運行結果
dict['Age']: 8
dict['Blog']: 大頭和尚
刪除字典元素
能刪單一的元素也能清空字典，清空只需一項操作。
顯示刪除一個字典用del命令，如下實例：
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 刪除鍵 'Name'
print dict
dict.clear() # 清空字典
del dict # 刪除字典
print "dict['Age']: ", dict['Age']
但這會引發一個異常，因為用執行 del 操作后字典不再存在：
{'Age': 7, 'Class': 'First'}
dict['Age']:
Traceback (most recent call last):
File "C:\Users\Admin\Desktop\字典.py", line 8, in <module>
print "dict['Age']: ", dict['Age']
TypeError: 'type' object has no attribute '__getitem__'
字典鍵的特性
字典值可以是任何的 python 對象，既可以是標准的對象，也可以是用戶定義的，但鍵不行。
兩個重要的點需要記住：
1）不允許同一個鍵出現兩次。創建時如果同一個鍵被賦值兩次，后一個值會被記住，如下實例：
dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鳥'}
print "dict['Name']: ", dict['Name']
運行結果
dict['Name']: 小菜鳥
2）鍵必須不可變，所以可以用數字，字符串或元組充當，而用列表就不行，如下實例：
dict = {['Name']: 'Runoob', 'Age': 7}
print "dict['Name']: ", dict['Name']
運行結果
Traceback (most recent call last):
File "C:\Users\Admin\Desktop\字典.py", line 1, in <module>
dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'
字典內置函數&方法
| 序號 | 函數及描述 | 實例 |
|---|---|---|
| 1 | len(dict) 計算字典元素個數，即鍵的總數。 | >>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(dict) 3 |
| 2 | str(dict) 輸出字典，以可打印的字符串表示。 | >>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(dict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}" |
| 3 | type(variable) 返回輸入的變量類型，如果變量是字典就返回字典類型。 | >>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(dict) |
Python字典包含了以下內置方法：
在此不詳細測試，如需深入了解點擊鏈接跳轉到菜鳥課程學習。
| 序號 | 函數及描述 |
|---|---|
| 1 | radiansdict.clear() 刪除字典內所有元素 |
| 2 | radiansdict.copy() 返回一個字典的淺復制 |
| 3 | radiansdict.fromkeys() 創建一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值 |
| 4 | radiansdict.get(key, default=None) 返回指定鍵的值，如果值不在字典中返回default值 |
| 5 | key in dict 如果鍵在字典dict里返回true，否則返回false |
| 6 | radiansdict.items() 以列表返回可遍歷的(鍵, 值) 元組數組 |
| 7 | radiansdict.keys() 返回一個迭代器，可以使用 list() 來轉換為列表 |
| 8 | radiansdict.setdefault(key, default=None) 和get()類似, 但如果鍵不存在於字典中，將會添加鍵並將值設為default |
| 9 | radiansdict.update(dict2) 把字典dict2的鍵/值對更新到dict里 |
| 10 | radiansdict.values() 返回一個迭代器，可以使用 list() 來轉換為列表 |
| 11 | pop(key[,default])刪除字典給定鍵 key 所對應的值，返回值為被刪除的值。key值必須給出。 否則，返回default值。 |
| 12 | popitem() 隨機返回並刪除字典中的最后一對鍵和值。 |
集合Set
集合（set）是一個無序的不重復元素序列。
可以使用大括號 { } 或者 set() 函數創建集合，注意：創建一個空集合必須用 set() 而不是 { }，因為 { } 是用來創建一個空字典。
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print basket # 這里演示的是去重功能
print "'orange' in basket：",'orange' in basket # 快速判斷元素是否在集合內
print "'crabgrass' in basket：",'crabgrass' in basket
### 下面展示兩個集合間的運算.
a = set('abracadabra')
b = set('alacazam')
print "a：",a
print "b：",b
print "集合a中包含而集合b中不包含的元素："
print a - b # 集合a中包含而集合b中不包含的元素
print "集合a或b中包含的所有元素："
print a | b # 集合a或b中包含的所有元素
print "集合a和b中都包含了的元素："
print a & b # 集合a和b中都包含了的元素
print "不同時包含於a和b的元素："
print a ^ b # 不同時包含於a和b的元素
運行結果
set(['orange', 'pear', 'apple', 'banana'])
'orange' in basket： True
'crabgrass' in basket： False
a： set(['a', 'r', 'b', 'c', 'd'])
b： set(['a', 'c', 'z', 'm', 'l'])
集合a中包含而集合b中不包含的元素：
set(['r', 'b', 'd'])
集合a或b中包含的所有元素：
set(['a', 'c', 'b', 'd', 'm', 'l', 'r', 'z'])
集合a和b中都包含了的元素：
set(['a', 'c'])
不同時包含於a和b的元素：
set(['b', 'd', 'm', 'l', 'r', 'z'])
添加元素
語法格式如下：
s.add( x )
將元素 x 添加到集合 s 中，如果元素已存在，則不進行任何操作。
thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")
print thisset
thisset.add("Google")
print thisset
運行結果
set(['Facebook', 'Google', 'Taobao', 'Runoob'])
set(['Facebook', 'Google', 'Taobao', 'Runoob'])
還有一個方法，也可以添加元素，且參數可以是列表，元組，字典等，語法格式如下：
s.update( x )
x 可以有多個，用逗號分開。
thisset = set(("Google", "Runoob", "Taobao"))
thisset.update({1,3})
print(thisset)
thisset.update([1,4],[5,6])
print(thisset)
運行結果
set([3, 1, 'Google', 'Taobao', 'Runoob'])
set([1, 3, 4, 5, 6, 'Runoob', 'Google', 'Taobao'])
刪除元素
語法格式如下：
s.remove( x )
將元素 x 從集合 s 中移除，如果元素不存在，則會發生錯誤。
thisset = set(("Google", "Runoob", "Taobao"))
thisset.remove("Taobao")
print thisset
thisset.remove("Facebook") # 不存在會發生錯誤
運行結果
set(['Google', 'Runoob'])
Traceback (most recent call last):
File "C:\Users\Admin\Desktop\集合.py", line 4, in <module>
thisset.remove("Facebook") # 不存在會發生錯誤
KeyError: 'Facebook'
此外還有一個方法也是移除集合中的元素，且如果元素不存在，不會發生錯誤。格式如下所示：
s.discard( x )
thisset = set(("Google", "Runoob", "Taobao"))
thisset.discard("Facebook") # 不存在不會發生錯誤
print thisset
運行結果
set(['Google', 'Taobao', 'Runoob'])
我們也可以設置隨機刪除集合中的一個元素，語法格式如下：
s.pop()
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()
print x #顯示隨機刪除的元素
運行結果
Facebook
在交互模式，pop 是刪除集合的第一個元素（排序后的集合的第一個元素）。
計算集合元素個數
語法格式如下：
len(s)
thisset = set(("Google", "Runoob", "Taobao"))
print len(thisset)
運行結果
3
清空集合
語法格式如下：
s.clear()
清空集合 s
thisset = set(("Google", "Runoob", "Taobao"))
thisset.clear()
print(thisset)
運行結果
set([])
判斷元素是否在集合中存在
集合內置方法
| 序號 | 方法 | 描述 |
|---|---|---|
| 1 | add() | 為集合添加元素 |
| 2 | clear() | 移除集合中的所有元素 |
| 3 | copy() | 拷貝一個集合 |
| 4 | difference() | 返回多個集合的差集 |
| 5 | difference_update() | 移除集合中的元素，該元素在指定的集合也存在。 |
| 6 | discard() | 刪除集合中指定的元素 |
| 7 | intersection() | 返回集合的交集 |
| 8 | intersection_update() | 返回集合的交集。 |
| 9 | isdisjoint() | 判斷兩個集合是否包含相同的元素，如果沒有返回 True，否則返回 False。 |
| 10 | issubset() | 判斷指定集合是否為該方法參數集合的子集。 |
| 11 | issuperset() | 判斷該方法的參數集合是否為指定集合的子集 |
| 12 | pop() | 隨機移除元素 |
| 13 | remove() | 移除指定元素 |
| 14 | symmetric_difference() | 返回兩個集合中不重復的元素集合。 |
| 15 | symmetric_difference_update() | 移除當前集合中在另外一個指定集合相同的元素，並將另外一個指定集合中不同的元素插入到當前集合中。 |
| 16 | union() | 返回兩個集合的並集 |
| 17 | update() | 給集合添加元素 |
代碼
set1={1}
set2={2}
# add一次只能添加一個元素
set1.add("Taobao")
set1.add("Baidu")
set1.add("Google")
print "add——使用add添加三個元素后的set1：\n",set1
# update可以添加元素，且參數可以是列表，元組，字典等
set2.update(("Google", "Runoob", "Tencent"))
print "\nupdate——使用update添加三個元素組成的元組后的set2：\n",set2
# isdisjoint判斷兩個集合是否不包含相同的元素，如果沒有返回 True，否則返回 False
print "\nisdisjoint——set1中是否不包含set2中的元素：\n",set1.isdisjoint(set2)
# issubset判斷集合的所有元素是否都包含在指定集合中，如果是則返回 True，否則返回 False。
print "\nissubset——set1中所有元素是否都在set2中：\n",set1.issubset(set2)
print "set1和set2的交集中所有元素是否都在set2中：\n",set1.intersection(set2).issubset(set2)
# issuperset判斷指定集合的所有元素是否都包含在原始的集合中，如果是則返回 True，否則返回 False。
print "\nissuperset——set2中所有元素是否都在set1中：\n",set1.issubset(set2)
print "set1和set2的交集中所有元素是否都在set1中：\n",set1.intersection(set2).issubset(set2)
# intersection返回兩個或更多集合中都包含的元素，即交集
print "\nintersection——返回set1和set2的交集：\n",set1.intersection(set2)
# union返回兩個集合的並集，即包含了所有集合的元素，重復的元素只會出現一次。
print "\nunion——返回set1和set2的並集：\n",set1.union(set2)
# difference返回集合的差集，即返回的集合元素包含在第一個集合中，但不包含在第二個集合(方法的參數)中
print "\ndifference——返回set1和set2的差集：\n",set1.difference(set2)
# symmetric_difference返回兩個集合中不重復的元素集合，即會移除兩個集合中都存在的元素。
print "\nsymmetric_difference——返回set1和set2中不重復的元素集合：\n",set1.symmetric_difference(set2)
# symmetric_difference_update移除當前集合中在另外一個指定集合相同的元素，並將另外一個指定集合中不同的元素插入到當前集合中。
set1.symmetric_difference_update(set2)
print "\nsymmetric_difference_update——移除set1中和set重復的元素，並將set2中不同的元素添加到set1中：\n",set1
# intersection_update在原始的集合上移除不重疊的元素
set1.intersection_update(set2)
print "\nintersection_update——移除set1中的set1和set2的不重疊元素：\n",set1
# difference_update用於移除兩個集合中都存在的元素
set1.difference_update(set2)
print "\ndifference_update——移除set1中的set1和set2的重疊元素：\n",set1
# copy將set2拷貝給set1
set1=set2.copy()
print "\ncopy——將set2拷貝給set1：\n",set1
# remove移除指定的集合元素，不存在會報錯
set1.remove("Tencent")
print "\nremove——移除set1中的'Tencent',不存在會報錯：\n",set1
# discard用於移除指定的集合元素，不存在不會報錯
set1.discard("Tencent")
print "\ndiscard——移除set1中的'Tencent',不存在不會報錯：\n",set1
# pop用於移除指定的集合元素，不存在會報錯
set1.pop()
print "\npop——隨機移除set1中的一個元素：\n",set1
# clear清空集合
set1.clear()
set2.clear()
print "\nclear——清空后的set1，set2：\n",set1,set2
運行結果
add——使用add添加三個元素后的set1：
set(['Baidu', 1, 'Google', 'Taobao'])
update——使用update添加三個元素組成的元組后的set2：
set([2, 'Google', 'Tencent', 'Runoob'])
isdisjoint——set1中是否不包含set2中的元素：
False
issubset——set1中所有元素是否都在set2中：
False
set1和set2的交集中所有元素是否都在set2中：
True
issuperset——set2中所有元素是否都在set1中：
False
set1和set2的交集中所有元素是否都在set1中：
True
intersection——返回set1和set2的交集：
set(['Google'])
union——返回set1和set2的並集：
set(['Baidu', 1, 2, 'Google', 'Runoob', 'Taobao', 'Tencent'])
difference——返回set1和set2的差集：
set(['Baidu', 1, 'Taobao'])
symmetric_difference——返回set1和set2中不重復的元素集合：
set(['Baidu', 1, 2, 'Runoob', 'Tencent', 'Taobao'])
symmetric_difference_update——移除set1中和set重復的元素，並將set2中不同的元素添加到set1中：
set(['Baidu', 1, 2, 'Runoob', 'Taobao', 'Tencent'])
intersection_update——移除set1中的set1和set2的不重疊元素：
set([2, 'Tencent', 'Runoob'])
difference_update——移除set1中的set1和set2的重疊元素：
set([])
copy——將set2拷貝給set1：
set([2, 'Google', 'Tencent', 'Runoob'])
remove——移除set1中的'Tencent',不存在會報錯：
set([2, 'Google', 'Runoob'])
discard——移除set1中的'Tencent',不存在不會報錯：
set([2, 'Google', 'Runoob'])
pop——隨機移除set1中的一個元素：
set(['Google', 'Runoob'])
clear——清空后的set1，set2：
set([]) set([])
運算符
算術運算符
以下假設變量a為10，變量b為21：
| 運算符 | 描述 | 實例 |
|---|---|---|
| + | 加 - 兩個對象相加 | a + b 輸出結果 31 |
| - | 減 - 得到負數或是一個數減去另一個數 | a - b 輸出結果 -11 |
| * | 乘 - 兩個數相乘或是返回一個被重復若干次的字符串 | a * b 輸出結果 210 |
| / | 除 - x 除以 y | b / a 輸出結果 2.1 |
| % | 取模 - 返回除法的余數 | b % a 輸出結果 1 |
| ** | 冪 - 返回x的y次冪 | a**b 為10的21次方 |
| // | 取整除 - 向下取接近除數的整數 | >>> 9//2 4 >>> -9//2 -5 |
比較運算符
以下假設變量a為10，變量b為20：
| 運算符 | 描述 | 實例 |
|---|---|---|
| == | 等於 - 比較對象是否相等 | (a == b) 返回 False。 |
| != | 不等於 - 比較兩個對象是否不相等 | (a != b) 返回 True。 |
| > | 大於 - 返回x是否大於y | (a > b) 返回 False。 |
| < | 小於 - 返回x是否小於y。所有比較運算符返回1表示真，返回0表示假。這分別與特殊的變量True和False等價。注意，這些變量名的大寫。 | (a < b) 返回 True。 |
| >= | 大於等於 - 返回x是否大於等於y。 | (a >= b) 返回 False。 |
| <= | 小於等於 - 返回x是否小於等於y。 | (a <= b) 返回 True。 |
賦值運算符
以下假設變量a為10，變量b為20，c=0：
| 運算符 | 描述 | 實例 |
|---|---|---|
| = | 簡單的賦值運算符 | c = a + b 將 a + b 的運算結果賦值為 c，c=20 |
| += | 加法賦值運算符 | c += a 等效於 c = c + a |
| -= | 減法賦值運算符 | c -= a 等效於 c = c - a， |
| *= | 乘法賦值運算符 | c *= a 等效於 c = c * a |
| /= | 除法賦值運算符 | c /= a 等效於 c = c / a |
| %= | 取模賦值運算符 | c %= a 等效於 c = c % a |
| **= | 冪賦值運算符 | c** = a 等效於 c = c ** a |
| //= | 取整除賦值運算符 | c //= a 等效於 c = c // a |
| := | 海象運算符，可在表達式內部為變量賦值。Python3.8 版本新增運算符。 | 在這個示例中，賦值表達式可以避免調用 len() 兩次:if (n := len(a)) > 10: print(f"List is too long ({n} elements, expected <= 10)") |
a = 21
b = 10
c = 0
c = a + b
print "1 - c 的值為：", c
c += a
print "2 - c 的值為：", c
c *= a
print "3 - c 的值為：", c
c /= a
print "4 - c 的值為：", c
c = 2
c %= a
print "5 - c 的值為：", c
c **= a
print "6 - c 的值為：", c
c //= a
print "7 - c 的值為：", c
運行結果
1 - c 的值為： 31
2 - c 的值為： 52
3 - c 的值為： 1092
4 - c 的值為： 52
5 - c 的值為： 2
6 - c 的值為： 2097152
7 - c 的值為： 99864
邏輯運算符
Python語言支持邏輯運算符，以下假設變量 a 為 10, b為 20:
| 運算符 | 邏輯表達式 | 描述 | 實例 |
|---|---|---|---|
| and | x and y | 布爾"與" - 如果 x 為 False，x and y 返回 False，否則它返回 y 的計算值。 | (a and b) 返回 20。 |
| or | x or y | 布爾"或" - 如果 x 是 True，它返回 x 的值，否則它返回 y 的計算值。 | (a or b) 返回 10。 |
| not | not x | 布爾"非" - 如果 x 為 True，返回 False 。如果 x 為 False，它返回 True。 | not(a and b) 返回 False |
成員運算符
除了以上的一些運算符之外，Python還支持成員運算符，測試實例中包含了一系列的成員，包括字符串，列表或元組。
| 運算符 | 描述 | 實例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否則返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中沒有找到值返回 True，否則返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if ( a in list ):
print ("1 - 變量 a 在給定的列表中 list 中")
else:
print ("1 - 變量 a 不在給定的列表中 list 中")
if ( b not in list ):
print ("2 - 變量 b 不在給定的列表中 list 中")
else:
print ("2 - 變量 b 在給定的列表中 list 中")
# 修改變量 a 的值
a = 2
if ( a in list ):
print ("3 - 變量 a 在給定的列表中 list 中")
else:
print ("3 - 變量 a 不在給定的列表中 list 中")
運行結果
1 - 變量 a 不在給定的列表中 list 中
2 - 變量 b 不在給定的列表中 list 中
3 - 變量 a 在給定的列表中 list 中
語句
條件控制
Python 條件語句是通過一條或多條語句的執行結果（True 或者 False）來決定執行的代碼塊。
Python中if語句的一般形式如下所示：
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3
- 如果 "condition_1" 為 True 將執行 "statement_block_1" 塊語句
- 如果 "condition_1" 為False，將判斷 "condition_2"
- 如果"condition_2" 為 True 將執行 "statement_block_2" 塊語句
- 如果 "condition_2" 為False，將執行"statement_block_3"塊語句
Python 中用 elif 代替了 else if，所以if語句的關鍵字為：if – elif – else。
注意：
- 1、每個條件后面要使用冒號 :，表示接下來是滿足條件后要執行的語句塊。
- 2、使用縮進來划分語句塊，相同縮進數的語句在一起組成一個語句塊。
- 3、在Python中沒有switch – case語句。
var1 = 100
if var1:
print "1——if 表達式條件為 true"
print var1
var2 = 0
if var2:
print "2——if 表達式條件為 true"
print var2
print "Good bye!"
運行結果
1——if 表達式條件為 true
100
Good bye!
多重判斷
age = int(input("請輸入你家狗狗的年齡: "))
print ""
if age <= 0:
print "你是在逗我吧!"
elif age == 1:
print "相當於 14 歲的人。"
elif age == 2:
print "相當於 22 歲的人。"
elif age > 2:
human = 22 + age -2*5
print "對應人類年齡: ", human
運行結果（輸入數字5）
請輸入你家狗狗的年齡: 5
對應人類年齡: 17
數字猜謎游戲
# 該實例演示了數字猜謎游戲
number = 7
guess = -1
print("數字猜謎游戲!")
while guess != number:
guess = int(input("請輸入你猜的數字："))
if guess == number:
print "恭喜，你猜對了！"
elif guess < number:
print "猜的數字小了..."
elif guess > number:
print "猜的數字大了..."
運行結果
數字猜謎游戲!
請輸入你猜的數字：100
猜的數字大了...
請輸入你猜的數字：5
猜的數字小了...
請輸入你猜的數字：6
猜的數字小了...
請輸入你猜的數字：7
恭喜，你猜對了！
嵌套判斷
num=int(input("輸入一個數字："))
if num%2==0:
if num%3==0:
print "你輸入的數字可以整除 2 和 3"
else:
print "你輸入的數字可以整除 2，但不能整除 3"
else:
if num%3==0:
print "你輸入的數字可以整除 3，但不能整除 2"
else:
print "你輸入的數字不能整除 2 和 3"
運行結果
輸入一個數字：15
你輸入的數字可以整除 3，但不能整除 2
循環語句
Python 中的循環語句有 for 和 while。
while 循環
Python 中 while 語句的一般形式：
while 判斷條件(condition)：
執行語句(statements)……
同樣需要注意冒號和縮進。另外，在 Python 中沒有 do..while 循環。
以下實例使用了 while 來計算 1 到 100 的總和：
n = 100
sum = 0
counter = 1
while counter <= n:
sum = sum + counter
counter += 1
print "1 到 %d 之和為: %d" % (n,sum)
運行結果
1 到 100 之和為: 5050
無限循環
我們可以通過設置條件表達式永遠不為 false 來實現無限循環，實例如下：
var = 1
while var == 1 : # 表達式永遠為 true
num = int(input("輸入一個數字 :"))
print "你輸入的數字是: ", num
print "Good bye!"
運行結果
輸入一個數字 :1
你輸入的數字是: 1
輸入一個數字 :2
你輸入的數字是: 2
輸入一個數字 :3
你輸入的數字是: 3
輸入一個數字 :
你可以使用 CTRL+C 來退出當前的無限循環。
無限循環在服務器上客戶端的實時請求非常有用。
while 循環使用 else 語句
在 while … else 在條件語句為 false 時執行 else 的語句塊。
語法格式如下：
while <expr>:
<statement(s)>
else:
<additional_statement(s)>
循環輸出數字，並判斷大小：
count = 0
while count < 5:
print count, " 小於 5"
count = count + 1
else:
print count, " 大於或等於 5"
運行結果
0 小於 5
1 小於 5
2 小於 5
3 小於 5
4 小於 5
5 大於或等於 5
for 語句
Python for循環可以遍歷任何序列的項目，如一個列表或者一個字符串。
for循環的一般格式如下：
for <variable> in <sequence>:
<statements>
else:
<statements>
languages = ["C", "C++", "Perl", "Python"]
for x in languages:
print x
運行結果
C
C++
Perl
Python
以下 for 實例中使用了 break 語句，break 語句用於跳出當前循環體：
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
if site == "Google":
print("Welcome to visit Google's websit!")
break
print"循環數據 " + site
else:
print "沒有循環數據!"
print "完成循環!"
運行結果
循環數據 Baidu
Welcome to visit Google's websit!
完成循環!
range()函數
如果你需要遍歷數字序列，可以使用內置range()函數。它會生成數列，例如:
for i in range(5) :
print i
運行結果
0
1
2
3
4
也可以使range以指定數字開始並指定不同的增量(甚至可以是負數，有時這也叫做'步長'):
for i in range(0, 10, 3) :
print i
運行結果
0
3
6
9
您可以結合range()和len()函數以遍歷一個序列的索引,如下所示:
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
print i, a[i]
運行結果
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
還可以使用range()函數來創建一個列表：
mylist=list(range(5))
print mylist
運行結果
[0, 1, 2, 3, 4]
break 和 continue 語句及循環中的 else 子句
break 語句可以跳出 for 和 while 的循環體。如果你從 for 或 while 循環中終止，任何對應的循環 else 塊將不執行。
continue 語句被用來告訴 Python 跳過當前循環塊中的剩余語句，然后繼續進行下一輪循環。ss 語句
while中使用
n = 5
while n > 0:
n -= 1
if n == 2:
break
print n
print "break test finished!"
m = 5
while m > 0:
m -= 1
if m == 2:
continue
print m
print "continue test finished!"
運行結果
4
3
break test finished!
4
3
1
0
continue test finished!
for中使用
blog = "www.bighead.fun"
for letter in blog :
print letter
if letter == "h" :
break
print "break test finished!"
for letter in blog :
print letter
if letter == "h" :
continue
print "continue test finished!"
運行結果
w
w
w
.
b
i
g
h
break test finished!
w
w
w
.
b
i
g
h
e
a
d
.
f
u
n
continue test finished!
循環語句可以有 else 子句，它在窮盡列表(以for循環)或條件變為 false (以while循環)導致循環終止時被執行，但循環被 break 終止時不執行。
如下實例用於查詢質數的循環例子:
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print n, '等於', x, '*', n//x
break
else:
# 循環中沒有找到元素
print n, ' 是質數'
運行結果
2 是質數
3 是質數
4 等於 2 * 2
5 是質數
6 等於 2 * 3
7 是質數
8 等於 2 * 4
9 等於 3 * 3
pass 語句
Python pass是空語句，是為了保持程序結構的完整性。
pass 不做任何事情，一般用做占位語句，如下實例
for letter in 'www.bighead.fun':
if letter == 'h':
pass
print '執行 pass 塊'
print '當前字母 :', letter
運行結果
當前字母 : w
當前字母 : w
當前字母 : w
當前字母 : .
當前字母 : b
當前字母 : i
當前字母 : g
執行 pass 塊
當前字母 : h
當前字母 : e
當前字母 : a
當前字母 : d
當前字母 : .
當前字母 : f
當前字母 : u
當前字母 : n
異常處理
Python 有兩種錯誤很容易辨認：語法錯誤和異常。
Python 的語法錯誤或者稱之為解析錯，是初學者經常碰到的 。
即便 Python 程序的語法是正確的，在運行它的時候，也有可能發生錯誤。運行期檢測到的錯誤被稱為異常。
try/except
異常捕捉可以使用 try/except 語句。
try :
執行代碼
except ErrorType(錯誤類型):
發生異常時執行的代碼
try 語句按照如下方式工作；
- 首先，執行 try 子句（在關鍵字 try 和關鍵字 except 之間的語句）。
- 如果沒有異常發生，忽略 except 子句，try 子句執行后結束。
- 如果在執行 try 子句的過程中發生了異常，那么 try 子句余下的部分將被忽略。如果異常的類型和 except 之后的名稱相符，那么對應的 except 子句將被執行。
- 如果一個異常沒有與任何的 excep 匹配，那么這個異常將會傳遞給上層的 try 中。
一個 try 語句可能包含多個except子句，分別來處理不同的特定的異常。最多只有一個分支會被執行。
處理程序將只針對對應的 try 子句中的異常進行處理，而不是其他的 try 的處理程序中的異常。
一個except子句可以同時處理多個異常，這些異常將被放在一個括號里成為一個元組，例如:
except (RuntimeError, TypeError, NameError):
pass
最后一個except子句可以忽略異常的名稱，它將被當作通配符使用。你可以使用這種方法打印一個錯誤信息，然后再次把異常拋出。
try :
fh =open("testfile.txt")
print fh.readline()
fh.close()
except IOError:
print "找不到文件，無法打開"
運行結果
找不到文件，無法打開
try/except...else
-
try/except 語句還有一個可選的 else 子句，如果使用這個子句，那么必須放在所有的 except 子句之后。else 子句將在 try 子句沒有發生任何異常的時候執行。
-
使用 else 子句比把所有的語句都放在 try 子句里面要好，這樣可以避免一些意想不到，而 except 又無法捕獲的異常。
try :
fh =open("testfile.txt","w")
fh.write("這是一個測試文件，用於測試異常！")
except IOError :
print "Error：沒有找到文件和讀取文件失敗"
else :
print "內容寫入成功"
fh.close()
運行結果
內容寫入成功
將testfile.txt設為只讀，再次運行結果
Error：沒有找到文件和讀取文件失敗
異常處理並不僅僅處理那些直接發生在 try 子句中的異常，而且還能處理子句中調用的函數（甚至間接調用的函數）里拋出的異常。
try-finally 語句
try-finally 語句無論是否發生異常都將執行最后的代碼。
try :
fh =open("testfile.txt","w")
fh.write("這是一個測試文件，用於測試異常！")
except IOError :
print "Error：沒有找到文件和讀取文件失敗"
else :
print "內容寫入成功"
fh.close()
finally :
print('這句話，無論異常是否發生都會執行。')
運行結果
內容寫入成功
這句話，無論異常是否發生都會執行。
將testfile.txt設為只讀，運行結果
Error：沒有找到文件和讀取文件失敗
這句話，無論異常是否發生都會執行。
用戶自定義異常
通過創建一個新的異常類，程序可以命名它們自己的異常。異常應該是典型的繼承自Exception類，通過直接或間接的方式。
下面代碼引發自定義的BigError錯誤
import os,stat
class BigError():
pass
try :
if os.path.exists('testfile.txt') :
os.chmod('testfile.txt', stat.S_IWRITE) #取消只讀權限
fh =open("testfile.txt","w")
fh.write("BigError")
fh.close()
fh =open("testfile.txt","r")
if fh.readline()=="BigError" :
raise BigError()
except IOError :
print "Error：沒有找到文件和讀取文件失敗"
except BigError :
print "Error：引發自定義BigError錯誤"
finally :
print('這句話，無論異常是否發生都會執行。')
運行結果
Error：引發自定義BigError錯誤
這句話，無論異常是否發生都會執行。
Python常見運行錯誤
UnicodeEncodeError: 'ascii' codec can't encode character
Python解釋器的默認編碼文件是用的ASCII碼，而你的python文件中使用了中文等非英語字符。
字符串在Python內部的表示是unicode編碼，因此，在做編碼轉換時，通常需要以unicode作為中間編碼，即先將其他編碼的字符串解碼（decode）成unicode，再從unicode編碼（encode）成另一種編碼。
Decode 的作用是將其他編碼的字符串轉換成unicode編碼，如str1.decode('gb2312')，表示將gb2312編碼的字符串str1轉換成unicode編碼。
Encode 的作用是將unicode編碼轉換成其他編碼的字符串，如str2.encode('gb2312')，表示將unicode編碼的字符串str2轉換成gb2312編碼。
因此，轉碼的時候一定要先搞明白，字符串str是什么編碼，然后decode成unicode，然后再encode成其他編碼。代碼中字符串的默認編碼與代碼文件本身的編碼一致。
以上為針對語句，或者直接在開頭加
# -*- coding: cp936 -*-
###或者
# -*- coding: utf-8 -*-
###或者
import sys
reload(sys)
sys.setdefaultencoding('utf8')
SyntaxError ：invalid syntax
忘記在if，for，def，elif，else，class等聲明末尾加 :
if spam == 42
print('Hello!')
使用= 而不是 ==
= 是賦值操作符而 == 是等於比較操作。該錯誤發生在如下代碼中：
if spam = 42:
print('Hello!')
IndentationError：unexpected indent
錯誤的使用縮進量導致
“IndentationError：unexpected indent”、
“IndentationError：unindent does not match any outer indetation level”
以及“IndentationError：expected an indented block”
記住縮進增加只用在以：結束的語句之后，而之后必須恢復到之前的縮進格式。該錯誤發生在如下代碼中：
print('Hello!')
print('Howdy!')
TypeError: 'list' object cannot be interpreted as an integer
在 for 循環語句中忘記調用 len()
通常你想要通過索引來迭代一個list或者string的元素，這需要調用 range() 函數。要記得返回len 值而不是返回這個列表。
該錯誤發生在如下代碼中：
spam = ['cat', 'dog', 'mouse']
for i in range(spam):
print(spam[i])
TypeError: 'str' object does not support item assignment
嘗試修改string的值
string是一種不可變的數據類型，該錯誤發生在如下代碼中：
spam = 'I have a pet cat.'
spam[13] = 'r'
print(spam)
而正確做法是：
spam = 'I have a pet cat.'
spam = spam[:13] + 'r' + spam[14:]
print(spam)
TypeError: Can't convert 'int' object to str implicitly
嘗試連接非字符串值與字符串
該錯誤發生在如下代碼中：
numEggs = 12
print('I have ' + numEggs + ' eggs.')
而正確做法是：
numEggs = 12
print('I have ' + str(numEggs) + ' eggs.')
numEggs = 12
print('I have %s eggs.' % (numEggs))
SyntaxError: EOL while scanning string literal
在字符串首尾忘記加引號
該錯誤發生在如下代碼中：
print(Hello!')
print('Hello!)
myName = 'Al'
print('My name is ' + myName + . How are you?')
NameError: name 'fooba' is not defined
變量或者函數名拼寫錯誤
該錯誤發生在如下代碼中：
foobar = 'Al'
print('My name is ' + fooba)
spam = ruond(4.2)
spam = Round(4.2)
AttributeError: 'str' object has no attribute 'lowerr'
方法名拼寫錯誤
該錯誤發生在如下代碼中：
spam = 'THIS IS IN LOWERCASE.'
spam = spam.lowerr()
IndexError: list index out of range
引用超過list最大索引
該錯誤發生在如下代碼中：
spam = ['cat', 'dog', 'mouse']
print(spam[6])
KeyError：‘spam’
使用不存在的字典鍵值
該錯誤發生在如下代碼中：
spam = {'cat': 'Zophie', 'dog': 'Basil', 'mouse': 'Whiskers'}
print('The name of my pet zebra is ' + spam['zebra'])
SyntaxError：invalid syntax
嘗試使用Python關鍵字作為變量名
Python關鍵不能用作變量名，該錯誤發生在如下代碼中：
class = 'algebra'
Python3的關鍵字有：
and, as, assert, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, None, nonlocal, not, or, pass, raise, return, True, try, while, with, yield
NameError: name 'foobar' is not defined
在一個定義新變量中使用增值操作符
不要在聲明變量時使用0或者空字符串作為初始值，這樣使用自增操作符的一句spam += 1等於spam = spam + 1，這意味着spam需要指定一個有效的初始值。
該錯誤發生在如下代碼中：
spam = 0
spam += 42
eggs += 42
UnboundLocalError: local variable 'foobar' referenced before assignment
在定義局部變量前在函數中使用局部變量（此時有與局部變量同名的全局變量存在）
在函數中使用局部變來那個而同時又存在同名全局變量時是很復雜的，使用規則是：如果在函數中定義了任何東西，如果它只是在函數中使用那它就是局部的，反之就是全局變量。
這意味着你不能在定義它之前把它當全局變量在函數中使用。
該錯誤發生在如下代碼中：
someVar = 42
def myFunction():
print(someVar)
someVar = 100
myFunction()
TypeError: 'range' object does not support item assignment
嘗試使用 range()創建整數列表
有時你想要得到一個有序的整數列表，所以 range() 看上去是生成此列表的不錯方式。然而，你需要記住 range() 返回的是 “range object”，而不是實際的 list 值。
該錯誤發生在如下代碼中：
spam = range(10)
spam[4] = -1
正確寫法：
spam = list(range(10))
spam[4] = -1
（注意：在 Python 2 中 spam = range(10) 是能行的，因為在 Python 2 中 range() 返回的是list值，但是在 Python 3 中就會產生以上錯誤）
SyntaxError: invalid syntax
不存在 ++ 或者 -- 自增自減操作符。
導致“SyntaxError: invalid syntax”
如果你習慣於例如 C++ , Java , PHP 等其他的語言，也許你會想要嘗試使用 ++ 或者 -- 自增自減一個變量。在Python中是沒有這樣的操作符的。
該錯誤發生在如下代碼中：
spam = 1
spam++
正確寫法：
spam = 1
spam += 1
TypeError: myMethod() takes no arguments (1 given)
忘記為方法的第一個參數添加self參數
該錯誤發生在如下代碼中：
class Foo():
def myMethod():
print('Hello!')
a = Foo()
a.myMethod()