Python基本語法及使用
Python基本語法及使用
Author: Lijbhtml
Email:lijb1121@163.comjava
Base
- 輸出語句
print()---在python3中須要加括號---內置函數 向控制檯輸出內容
- 輸入語句
input(提示信息) 將用戶在控制檯輸入的內容轉換城字符串輸出
- 變量
1. 賦值後使用---（先定義，後使用） 2. 做用範圍：從定義開始到包含它的代碼塊結束 3. 變量至關於一個標籤貼在了數據上（貼在對象上）---python其實是沒有類型的---只有一個類型（對象類型）（str,int,float） 書寫形式：變量名=變量值
- 標識符
名字：變量名，函數名，類名 語法：（強制性 ） 1. 合法標識符，字母，數字（不能開頭），下劃線 中文也是合法的標識符（屬於字母） 例如：呵呵=10；---強烈不建議用，會出現中文亂碼 Python2:ASCII Python3:UTF-8(Unicode) 2. 大小寫敏感 3. 關鍵字不能使用 4. 沒有長度限制 開發習慣： 和Java同樣
- 數據類型
1. 整型：int 32:-2^31~2^31-1 64:-2^63~2^63-1 2. 浮點型：float大小沒有限制 inf:無限大 e計法：科學計數法 1e+10 1乘以10的10次方 3. 字符串：str:'a' "a" '''a''' """a"""(三引號能夠換行) 4. 布爾類型：bool:True False 5. 空值：None 6. 複數：實部+虛部 a+bj 不可變數據類型 -------------------------------------------------------- 可變數據類型 - 7. 列表：list是一種有序的集合 8. 元組：tuple是一種有序的集合（不可變） 9. 字典：dict 集合set
- 字符串
1. 單引號，雙引號，三引號包含的內容---字符串---由一個一個的字符組成 2. 引號成對出現 3. 轉義字符---r表示原始字符串：不會發生轉義 4. 長字符串：指三引號包含的字符串 5. len():內置函數---參數長度
-
<!--類型轉換-->git
1. 字符串-->整型：用int()函數 --要求參數必須爲數字(`整數`)的字符串 2. 字符串-->浮點型：用float() ---底層整數部分和小數部分是分開的 如：".123"轉成浮點型爲0.123 3. 浮點型-->整型：用int()函數 --直接去掉小數部分 4. 整型-->浮點型：用float()函數 --參數必須爲數字，若是數字較大則採用e計法展現（科學記數法） 5. 浮點型-->字符串：用str()函數 6. 整型-->字符串：用str()函數 # int() float() str() list() 但凡與數據類型相關的內置函數-->都是工廠函數-->這種轉換模式也是工廠模式
- 獲取類型的信息
1. type():查看數據的類型 2. isinstance(); 參數一：具體固然數據 參數二：數據的類型 返回值：布爾值--->判斷參數一和參數二是否匹配
- 表達式
定義：變量和字面值用某個式子鏈接的模式 # 表達式必須有固定的字面值
- 運算符
1. 通常運算符： + - * /（真除法） % //（floor除法） **（冪運算） 2. 賦值運算符： = += -= *= /= %= //= 3. 布爾運算符：（比較運算符） 4. 邏輯運算符：配合布爾運算符 and or not 5. 位運算符： >> << & 按位求與，二者都爲1 結果爲1不然爲0 | 按位求或 ~ 按位求非 ^ 按位求異或 6. 三元運算符： a=(10 if 1<0 else 20)
- 優先級
1. 先乘除，後加減 2. 冪運算優先 3. 元數越少，優先級越高 高--->低 冪運算-->正負號-->算術運算符-->比較運算符-->邏輯運算符
流程控制
條件分支流程
- if-else
if 布爾表達式:
代碼塊
--------------------------------------------------------------------------------------
if 布爾表達式:
代碼塊
else:
代碼塊
--------------------------------------------------------------------------------------
if 布爾表達式:
代碼塊
elif:
代碼塊
else:
代碼塊
--------------------------------------------------------------------------------------
三種結構：if if-else if-elif-elif-else 相互之間能夠嵌套使用
- 斷言
assert 1. 這個關鍵字後面的條件爲假，則系統自動奔潰，拋出異常AssertionError 2. 這個關鍵字後面的條件爲真，則系統正常運行
循環流程
Python提供了for循環和while循環（在Python中沒有do..while循環）程序員
while循環
1.語法：
while 布爾表達式：
代碼塊
示例：
n=1
while n<10:
print("while循環")
n+=1
n=1
while True:
print("while循環")
n+=1
if n==10:
break
2.語法
while 布爾表達式：
代碼塊1
else :
代碼塊2
#注：布爾表達式條件爲真執行代碼塊1，條件爲假執行代碼塊2
示例：
count = 0
while count < 5:
print count, " is less than 5"
count = count + 1
else:
print count, " is not less than 5"
#補充：while後面能夠跟True/False---> 0/1--->任何一個對象（只要對象不爲空就一直循環）
list=[1,2,3,4]
while list:
front,list=list[0],list[1:]
print(front,list)
for循環
也稱之爲：計數循環
Python中的for循環能夠調方法、能夠捕獲異常
語法：
for 目標 in 表達式：
目標：變量
表達式：元組、列表、字符串--->可迭代對象
示例1：#表達式爲字符串
for i in "hello":
print(i)
示例2：#表達式爲列表
list=[1,2,3,4,5,6,7,8,9,0]
for i in list:
print(i)
示例3：#表達式爲元組
tuple=(1,2,3,4,5,6,7,8,9,0)
for i in tuple:
print(i)
- range()內置函數
range([start=0],stop,[step=1])
1.[]:可選參數
2.start:表示從start開始默認爲0；stop表示到stop結束；step:表示步幅默認爲1
3.range()函數返回一個range對象（Python2裏面返回的是列表）--->可迭代對象
示例1：#若是step爲1的話能夠直接寫成for i in range(10):
for i in range(0,10,2):
print(i)
- break
跳出當前循環
- continue
跳過本次循環--->不會影響其餘循環
- pass
pass是空語句，是爲了保持程序結構的完整性。
- 循環嵌套使用
1.#九九乘法表
for i in range(1,10):
for j in range(1,i+1):
print("%d*%d=%2d" % (j,i,j*i),end=" ")
print (" ")
1*1= 1
1*2= 2 2*2= 4
1*3= 3 2*3= 6 3*3= 9
1*4= 4 2*4= 8 3*4=12 4*4=16
1*5= 5 2*5=10 3*5=15 4*5=20 5*5=25
1*6= 6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7= 7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8= 8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9= 9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
2.#輸出2~100之間的素數：
i = 2
while (i < 100):
j = 2
while (j <= (i / j)):
if not (i % j): break
j = j + 1
if (j > i / j):
print(i, " 是素數")
i = i + 1
print("Good bye!")
列表
列表：能夠存聽任何形式的數據（最經常使用的數據類型之一） list--->關鍵字
- 建立列表
三種列表： 1. 普通列表 l=[1,2,3] l=['python','java','scala'] 2. 混合列表： l=[1,2,3,'hehe'] l=[1,2,3,'hhe',[4,5,'hehe']] 3. 空列表 l=[] 列表長度：len(1)
- 向列表中添加元素
1. append(object):
object:任何對象（萬物皆對象）
做用：向列表中添加一個元素，並將元素添加到末尾
調用形式：list.append(元素)
2. extend(iterable):
iterable:可迭代對象
做用：將可迭代對象中的元素添加到列表中
3. insert(index,object):
index:索引下標
objec：要插入的元素
- 刪除列表元素
1. remove(value):
從列表中刪除一個元素
value:元素
注：若是元素不在列表中則會報錯拋出異常ValueError
2. pop():
彈棧：指的就是把棧頂的元素拿出去
刪除並返回最後一個元素，若是設置了index則刪除並返回index下標處的元素
若是列表爲空或者下標越界則拋出異常IndexError
3. del:不是一個方法，而是一個語句
del 變量名：做用是刪除變量，並不會刪除列表自己
可使用 del 語句來刪除列表的元素，以下實例：
list1 = ['physics', 'chemistry', 1997, 2000]
print list1
del list1[2]
print "After deleting value at index 2 : "
print list1
- 從列表中獲取元素
經過下標獲取元素:
list[index]
訪問：
1. 讀取數據
2. 修改數據
遍歷：
將列表中的元素所有訪問一遍，不充分不遺漏
list=[1,2,3,4,5,6]
for i in list:
print(i)
- 列表的分片
slice:分片/切片 利用索引，獲取所有元素 書寫方式： list[起始下標 ：結束下標]--->[start:end] 切片沒有下標限制 簡寫： 若是起始下標爲0；則可省略 list[:end] 若是結束下標爲leng-1;則可省略 list[start:] 若是所有省略表示整個列表選用 list[:]--->作一些拷貝工做 list[起始下標:結束下標:步長]
Python列表截取
| Python 表達式 | 結果 | 描述 |
|---|---|---|
| L[2] | 'Taobao' | 讀取列表中第三個元素 |
| L[-2] | 'Runoob' | 讀取列表中倒數第二個元素 |
| L[1:] | ['Runoob', 'Taobao'] | 從第二個元素開始截取列表 |
Python列表操做符
列表對 + 和 * 的操做符與字符串類似。+ 號用於組合列表，* 號用於重複列表。express
以下所示：編程
| 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 | 迭代 |
- 列表經常使用運算符
1. 比較運算符
布爾運算符：> < >= <= != ==
比較每個元素，從下標爲0開始比較，若是相等，則比較下一個元素
2. 邏輯運算符
and or not
3. 列表拼接
+
4. 重複操做符（運算符）
*
5. 成員關係運算符：
in /not in
Python列表函數&方法
Python包含如下函數:api
| 序號 | 函數 |
|---|---|
| 1 | cmp(list1, list2) 比較兩個列表的元素 |
| 2 | len(list) 列表元素個數 |
| 3 | max(list) 返回列表元素最大值 |
| 4 | min(list) 返回列表元素最小值 |
| 5 | list(seq) 將元組轉換爲列表 |
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(cmp=None, key=None, reverse=False) 對原列表進行排序 |
- 列表的淺拷貝
copy() list切片也是淺拷貝
- 二位列表
一維列表中的一維列表，和Java同樣bash
- 排序
#冒泡排序
list=[5,4,3,9,2,8,6,7,1]
n=len(list)
for i in range(1,n):
for j in range(n-i):
if list[j]>list[j+1]:
#list[j]^=list[j+1]
#list[j+1]^=list[j]
#list[j]^=list[j+1]
list[j],list[j+1]=list[j+1],list[j]
print(list)
#選擇排序
list=[5,4,3,9,2,8,6,7,1]
n=len(list)
for i in range(0,n-1):
for j in range(i+1,n):
if list[i]>list[j]:
#list[i]^=list[j]
#list[j]^=list[i]
#list[i]^=list[j]
list[j],list[i]=list[i],list[j]
print(list)
#兩個變量的數據進行交換：
在Java裏有中間變量、異或運算、加發運算
在Python裏除了Java優的方法以外還能夠寫成：a,b=b,a的形式
a=1
b=2
a,b=b,a
交換以後a=2,b=1
元組
- 圓括號（括號運算符）
做用： 1. 控制優先級 括號的優先級最高，能夠控制優先級 2. 能夠做爲元組的組成部分
- 元組
tuple 列表：能夠存聽任何數據，能夠修改 元組：能夠存聽任何數據，不能修改 元組：不可變類型 元組最重要的符號是逗號
- 建立並訪問一個元組
1. 直接訪問
t=(元素1，元素2)--->建立多個元素的元組
t=元素1，元素2 --->建立多個元素的元組
t=元素 --->建立一個元素的元組
t=(元素，) --->建立一個元素的元組
2. tuple()工廠函數建立
tuple()--->返回空元組
tuple(可迭代對象)--->新元組（元素是可迭代對象中的元素）
3. 訪問一個元組
經過下標訪問（和列表是同樣的）
4. 元組的切片
t[1:5]
5. 不能夠修改
直接修改會報錯：TypeError
能夠利用元組的拼接修改
6. 刪除元組
del 變量--->刪除的是變量--->元組自己還在
7. 更新一個元組
第一步：利用切片和拼接操做建立新元組
第二步：更名
8. 空元組
t=()
t=tuple()
元組操做符
與字符串同樣，元組之間可使用 + 號和 * 號進行運算。這就意味着他們能夠組合和複製，運算後會生成一個新的元組。
| 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 = ('spam', 'Spam', 'SPAM!')
| Python 表達式 | 結果 | 描述 |
|---|---|---|
| L[2] | 'SPAM!' | 讀取第三個元素 |
| L[-2] | 'Spam' | 反向讀取，讀取倒數第二個元素 |
| L[1:] | ('Spam', 'SPAM!') | 截取元素 |
無關閉分隔符
任意無符號的對象，以逗號隔開，默認爲元組，以下實例：
print 'abc', -4.24e93, 18+6.6j, 'xyz' x, y = 1, 2 print "Value of x , y : ", x,y #運行結果 abc -4.24e+93 (18+6.6j) xyz Value of x , y : 1 2
元組內置函數
Python元組包含了如下內置函數
| 序號 | 方法及描述 |
|---|---|
| 1 | cmp(tuple1, tuple2) 比較兩個元組元素。 |
| 2 | len(tuple) 計算元組元素個數。 |
| 3 | max(tuple) 返回元組中元素最大值。 |
| 4 | min(tuple) 返回元組中元素最小值。 |
| 5 | tuple(seq) 將列表轉換爲元組。 |
字符串
天生具備跨平臺性--os--支持字符串（內因：文本、字母、數字、符號 外因：編碼表 a=95） 應用 編輯代碼 傳輸信息
- Python中的字符串
s='abc' s="abc" s='''abc''' 能夠換行--->默認添加了\n--->多行字符串--->還能夠表示文檔註釋 s="""abc""" 能夠換行--->默認添加了\n--->多行字符串--->還能夠表示文檔註釋 1. 字符串支持分片操做 2. 字符串時不可變類型--->元組、數字、字符串都是不可變類型 列表爲可變類型
Python字符串轉義字符
在須要在字符中使用特殊字符時，python用反斜槓()轉義字符。以下表：
| 轉義字符 | 描述 |
|---|---|
| (在行尾時) | 續行符 |
| \ | 反斜槓符號 |
| ' | 單引號 |
| " | 雙引號 |
| \a | 響鈴 |
| \b | 退格(Backspace) |
| \e | 轉義 |
| \000 | 空 |
| \n | 換行 |
| \v | 縱向製表符 |
| \t | 橫向製表符 |
| \r | 回車 |
| \f | 換頁 |
| \oyy | 八進制數，yy表明的字符，例如：\o12表明換行 |
| \xyy | 十六進制數，yy表明的字符，例如：\x0a表明換行 |
| \other | 其它的字符以普通格式輸出 |
Python字符串運算符
下表實例變量 a 值爲字符串 "Hello"，b 變量值爲 "Python"：
| 操做符 | 描述 | 實例 |
|---|---|---|
| + | 字符串鏈接 | >>>a + b 'HelloPython' |
| * | 重複輸出字符串 | >>>a * 2 'HelloHello' |
| [] | 經過索引獲取字符串中字符 | >>>a[1] 'e' |
| [ : ] | 截取字符串中的一部分 | >>>a[1:4] 'ell' |
| in | 成員運算符 - 若是字符串中包含給定的字符返回 True | >>>"H" in a True |
| not in | 成員運算符 - 若是字符串中不包含給定的字符返回 True | >>>"M" not in a True |
| r/R | 原始字符串 - 原始字符串：全部的字符串都是直接按照字面的意思來使用，沒有轉義特殊或不能打印的字符。 原始字符串除在字符串的第一個引號前加上字母"r"（能夠大小寫）之外，與普通字符串有着幾乎徹底相同的語法。 | >>>print r'\n' \n >>> print R'\n' \n |
| % | 格式字符串 | |
| not/or | 邏輯操做符 |
Python 字符串格式化
Python 支持格式化字符串的輸出 。儘管這樣可能會用到很是複雜的表達式，但最基本的用法是將一個值插入到一個有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用與 C 中 sprintf 函數同樣的語法。
以下實例：
print "My name is %s and weight is %d kg!" % ('Zara', 21)
#以上實例輸出結果：
My name is Zara and weight is 21 kg!
- python字符串格式化符號
| 符 號 | 描述 |
|---|---|
| %c | 格式化字符及其ASCII碼 |
| %s | 格式化字符串 |
| %d | 格式化整數 |
| %u | 格式化無符號整型 |
| %o | 格式化無符號八進制數 |
| %x | 格式化無符號十六進制數 |
| %X | 格式化無符號十六進制數（大寫） |
| %f | 格式化浮點數字，可指定小數點後的精度 |
| %e | 用科學計數法格式化浮點數 |
| %E | 做用同%e，用科學計數法格式化浮點數 |
| %g | %f和%e的簡寫 |
| %G | %f 和 %E 的簡寫 |
| %p | 用十六進制數格式化變量的地址 |
- 格式化操做符輔助指令
| 符號 | 功能 |
|---|---|
| * | 定義寬度或者小數點精度 |
| - | 用作左對齊 |
| + | 在正數前面顯示加號( + ) |
| <sp> | 在正數前面顯示空格 |
| # | 在八進制數前面顯示零('0')，在十六進制前面顯示'0x'或者'0X'(取決於用的是'x'仍是'X') |
| 0 | 顯示的數字前面填充'0'而不是默認的空格 |
| % | '%%'輸出一個單一的'%' |
| (var) | 映射變量(字典參數) |
| m.n. | m 是顯示的最小總寬度,n 是小數點後的位數(若是可用的話) |
Python2.6 開始，新增了一種格式化字符串的函數 str.format()，它加強了字符串格式化的功能。
- 格式化函數
str.format()
字符串格式化：按照必定的格式輸出
format():
可變長參數 ：*args **kwargs
1. 用{}表示字符串參數，花括號中的數字表示位置參數
對傳遞進來的參數進行格式化整理，並展現最終結果
s='{[0]呵呵[1]}'.format('hello','world')--->#hello呵呵world
2. 用{}表示字符串參數，花括號中的字母表示關鍵字參數
s='{a}{b}'.format(a='hello',b='world')--->#helloworld
注：若是關鍵字參數和未知參數混用，則位置參數要放在前邊
Python的字符串內置函數
字符串方法是從python1.6到2.0慢慢加進來的——它們也被加到了Jython中。
這些方法實現了string模塊的大部分方法，以下表所示列出了目前字符串內建支持的方法，全部的方法都包含了對Unicode的支持，有一些甚至是專門用於Unicode的。
| 方法 | 描述 |
|---|---|
| string.capitalize() | 把字符串的第一個字符大寫 |
| string.center(width) | 返回一個原字符串居中,並使用空格填充至長度 width 的新字符串 |
| string.count(str, beg=0, end=len(string)) | 返回 str 在 string 裏面出現的次數，若是 beg 或者 end 指定則返回指定範圍內 str 出現的次數 |
| string.decode(encoding='UTF-8', errors='strict') | 以 encoding 指定的編碼格式解碼 string，若是出錯默認報一個 ValueError 的 異 常 ， 除非 errors 指 定 的 是 'ignore' 或 者'replace' |
| string.encode(encoding='UTF-8', errors='strict') | 以 encoding 指定的編碼格式編碼 string，若是出錯默認報一個ValueError 的異常，除非 errors 指定的是'ignore'或者'replace' |
| string.endswith(obj, beg=0, end=len(string)) | 檢查字符串是否以 obj 結束，若是beg 或者 end 指定則檢查指定的範圍內是否以 obj 結束，若是是，返回 True,不然返回 False. |
| string.expandtabs(tabsize=8) | 把字符串 string 中的 tab 符號轉爲空格，tab 符號默認的空格數是 8。 |
| string.find(str, beg=0, end=len(string)) | 檢測 str 是否包含在 string 中，若是 beg 和 end 指定範圍，則檢查是否包含在指定範圍內，若是是返回開始的索引值，不然返回-1 |
| string.format() | 格式化字符串 |
| string.index(str, beg=0, end=len(string)) | 跟find()方法同樣，只不過若是str不在 string中會報一個異常. |
| string.isalnum() | 若是 string 至少有一個字符而且全部字符都是字母或數字則返回 True,不然返回 False |
| string.isalpha() | 若是 string 至少有一個字符而且全部字符都是字母則返回 True,不然返回 False |
| string.isdecimal() | 若是 string 只包含十進制數字則返回 True 不然返回 False. |
| string.isdigit() | 若是 string 只包含數字則返回 True 不然返回 False. |
| string.islower() | 若是 string 中包含至少一個區分大小寫的字符，而且全部這些(區分大小寫的)字符都是小寫，則返回 True，不然返回 False |
| string.isnumeric() | 若是 string 中只包含數字字符，則返回 True，不然返回 False |
| string.isspace() | 若是 string 中只包含空格，則返回 True，不然返回 False. |
| string.istitle() | 若是 string 是標題化的(見 title())則返回 True，不然返回 False |
| string.isupper() | 若是 string 中包含至少一個區分大小寫的字符，而且全部這些(區分大小寫的)字符都是大寫，則返回 True，不然返回 False |
| string.join(seq) | 以 string 做爲分隔符，將 seq 中全部的元素(的字符串表示)合併爲一個新的字符串 |
| string.ljust(width) | 返回一個原字符串左對齊,並使用空格填充至長度 width 的新字符串 |
| string.lower() | 轉換 string 中全部大寫字符爲小寫. |
| string.lstrip() | 截掉 string 左邊的空格 |
| string.maketrans(intab, outtab]) | maketrans() 方法用於建立字符映射的轉換表，對於接受兩個參數的最簡單的調用方式，第一個參數是字符串，表示須要轉換的字符，第二個參數也是字符串表示轉換的目標。 |
| max(str) | 返回字符串 str 中最大的字母。 |
| min(str) | 返回字符串 str 中最小的字母。 |
| string.partition(str) | 有點像 find()和 split()的結合體,從 str 出現的第一個位置起,把 字 符 串 string 分 成 一 個 3 元 素 的 元 組 (string_pre_str,str,string_post_str),若是 string 中不包含str 則 string_pre_str == string. |
| string.replace(str1, str2, num=string.count(str1)) | 把 string 中的 str1 替換成 str2,若是 num 指定，則替換不超過 num 次. |
| string.rfind(str, beg=0,end=len(string) ) | 相似於 find()函數，不過是從右邊開始查找. |
| string.rindex( str, beg=0,end=len(string)) | 相似於 index()，不過是從右邊開始. |
| string.rjust(width) | 返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串 |
| string.rpartition(str) | 相似於 partition()函數,不過是從右邊開始查找 |
| string.rstrip() | 刪除 string 字符串末尾的空格. |
| string.split(str="", num=string.count(str)) | 以 str 爲分隔符切片 string，若是 num 有指定值，則僅分隔 num+ 個子字符串 |
| [string.splitlines(keepends]) | 按照行('\r', '\r\n', \n')分隔，返回一個包含各行做爲元素的列表，若是參數 keepends 爲 False，不包含換行符，若是爲 True，則保留換行符。 |
| string.startswith(obj, beg=0,end=len(string)) | 檢查字符串是不是以 obj 開頭，是則返回 True，不然返回 False。若是beg 和 end 指定值，則在指定範圍內檢查. |
| string.strip([obj]) | 在 string 上執行 lstrip()和 rstrip() |
| string.swapcase() | 翻轉 string 中的大小寫 |
| string.title() | 返回"標題化"的 string,就是說全部單詞都是以大寫開始，其他字母均爲小寫(見 istitle()) |
| string.translate(str, del="") | 根據 str 給出的表(包含 256 個字符)轉換 string 的字符,要過濾掉的字符放到 del 參數中 |
| string.upper() | 轉換 string 中的小寫字母爲大寫 |
| string.zfill(width) | 返回長度爲 width 的字符串，原字符串 string 右對齊，前面填充0 |
序列(Sequence)
- 列表、元組、字符串
共同點： 1.可迭代對象 2.能夠經過索引得到相應的元素 3.均可以使用分片操做 4.有共同的操做符 特色： 1.能夠經過下標操做 2.有一一對應的元素 序列：列表、元組、字符串
- 序列相關的函數
內置函數：BIF
列表、元組、字符串中的內置函數
1. list():
list():建立一個空列表
list(iterable):建立一個列表
2. tuple():
tuple:建立一個元組
tuple(iterable):建立元組
3. str(obj=''):
將obj轉換成字符串
4. len(obj):
獲取對象obj的長度
5. max(iterable)
返回可迭代的對象中最大的元素（數值大，編碼大）
6. min(iterable)
返回可迭代的對象中最小的元素（數值小，編碼小）
7. sum(iterable,start=0)
從start開始加起，逐個加迭代對象中的數字
8. sorted()
排序（默認升序）
9. reversed():
原地翻轉
返回一個list_reverseiterator對象
查看該對象：
利用工廠函數進行轉換(list(),tuple())
利用for循環查看
10. enumerate(iterable[,start]):
返回元組序列：（下標，元素）
11. zip(iter1[,iter2[...]])-->):
打包
字典（Dictionary）
字典是另外一種可變容器模型，且可存儲任意類型對象。
字典的每一個鍵值 key=>value 對用冒號 : 分割，每一個鍵值對之間用逗號 , 分割，整個字典包括在花括號 {} 中 ,格式以下所示：
d = {key1 : value1, key2 : value2 }
關鍵字：dict
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
1. 鍵通常是惟一的，若是重複最後的一個鍵值對會替換前面的，值不須要惟一。
2. 值能夠取任何數據類型，但鍵必須是不可變的，如字符串，數字或元組。
3. 字典不是序列--->是映射類型--->是可迭代對象
- 字典的建立
1. 直接建立
d = {key1 : value1, key2 : value2 }
2. 利用函數建立
1.空字典：dict()
2.dict(mapping):參數是一個映射
3.dict(*元組)：參數是一個可迭代對象
- 字典的訪問
讀取+修改
1. 讀取：字典名[key] 2. 修改：字典名[key]=新值 3. 添加鍵值對：字典名[key]=value
字典內置函數&方法
Python字典包含了如下內置函數：
| 序號 | 函數及描述 |
|---|---|
| 1 | cmp(dict1, dict2) 比較兩個字典元素。 |
| 2 | len(dict) 計算字典元素個數，即鍵的總數。 |
| 3 | str(dict) 輸出字典可打印的字符串表示。 |
| 4 | type(variable) 返回輸入的變量類型，若是變量是字典就返回字典類型。 |
Python字典包含了如下內置方法：
| 序號 | 函數及描述 |
|---|---|
| 1 | dict.clear() 刪除字典內全部元素 |
| 2 | dict.copy() 返回一個字典的淺複製 |
| 3 | [dict.fromkeys(seq, val]) 建立一個新字典，以序列 seq 中元素作字典的鍵，val 爲字典全部鍵對應的初始值 |
| 4 | dict.get(key, default=None) 返回指定鍵的值，若是值不在字典中返回default值 |
| 5 | dict.has_key(key) 若是鍵在字典dict裏返回true，不然返回false |
| 6 | dict.items() 以列表返回可遍歷的(鍵, 值) 元組數組 |
| 7 | dict.keys() 以列表返回一個字典全部的鍵 |
| 8 | dict.setdefault(key, default=None) 和get()相似, 但若是鍵不存在於字典中，將會添加鍵並將值設爲default |
| 9 | dict.update(dict2) 把字典dict2的鍵/值對更新到dict裏 |
| 10 | dict.values() 以列表返回字典中的全部值 |
| 11 | [pop(key,default]) 刪除字典給定鍵 key 所對應的值，返回值爲被刪除的值。key值必須給出。 不然，返回default值。（彈棧） |
| 12 | popitem() 隨機返回並刪除字典中的一對鍵和值。彈出鍵值對 |
函數
- 結果化編程
關鍵字：def 函數的建立： def 函數名 (形參列表)： 邏輯代碼 函數的調用： 函數名(實參列表)
- 函數的特色、運行機制同Java和Scala中的函數同樣
1. 避免代碼冗餘 2. 提升程序的靈活性 3. 提升程序的可維護性 4. 提升代碼的重用性
- 函數的定義位置
1. 能夠定義在文件頂頭
2. 函數能夠定義在函數內部
參考變量定義函數
做用範圍：
從定義開始到包含它的代碼塊結束---做爲腳本運行
- 函數的結構
1. 函數的聲明（定義） def 函數名（參數列表）：多個參數用逗號分開，參數個數無限制 2. 函數的內容： 代碼 沒有內容：pass 3. 函數的返回值 關鍵字：return ---若是不寫系統自動添加--任何函數必定有返回值
函數的參數
- 位置參數
#和java同樣嚴格按照參數的位置進行調用和數據傳遞 def fun(a,b): 內容 fun(a,b)
- 關鍵字參數
定義了關鍵字的參數，與位置無關 def fun(a,b): print(a,b) fun(b='B',a='A') 1. 利用關鍵字參數傳遞與位置無關 2. 位置參數必須在關鍵字參數前面。（系統爲會認爲從關鍵字參數開始後面的參數均爲關鍵字參數） 3. 關鍵字參數不能屢次賦值
- 默認參數
是定義了默認值的參數
#默認參數
def fun(a='A',b='B'):
print(a,b)
fun('C','D')
- 可變長參數
收集參數 1. 在參數前面加* 將全部的參數打包成元組，輸出--->不能使用關鍵字參數 2. 在參數前面加** 將全部參數打包成字典。輸出--->只能使用關鍵字參數傳遞
- 命名關鍵字參數
*後面定義的形式
def fun(*param,a):
print(a)
fun('A','B',a='C')
1. 可變長參數和位置參數共用
若是位置參數在後，則實參在指定爲位置使用關鍵字參數
若是位置參數在前，直接傳參不能使用關鍵字參數
- 函數的文檔
文檔的讀取 1. help() 2. 函數名._doc_
函數與過程
1. 函數：函數的聲明，函數的返回值 2. 過程：函數的實現（內容） 函數與過程是相互分離的
返回值
python的返回值是動態的，編譯器動態的肯定具體類型 1. return 語句後面必定要有一個參數 2. 函數若是沒有書寫return則系統會自動的增長一個return None 3. 函數若是沒有書寫return後面的值，則系統會自動的增長一個None 4. return能夠返回多個返回值，多個數據之間用逗號分隔開，本質上封裝成了元組 5. return能夠返回一個容器類型的數據（容器中能夠裝多個數據） 6. return後面能夠書寫一個表達式，函數的調用，返回一個值
- 函數變量的做用域
局部變量、全局變量、做用範圍和java裏面同樣使用
- global
全局變量有關
#能夠在函數內部訪問全局變量
a=10
def fun():
global a
a=20
print(a)
fun()
print(a)
#20 20
- nonlocal
局部變量有關
#能夠在內部函數的內部訪問外部函數的局部變量
def fun():
a=10
def fun1():
nonlocal a
a = 20
print(a)
fun1()
print(a)
fun()
注意： 函數不能對全局變量進行加強賦值運算（a=a+1 a+=1） 內部函數不能對外部函數的局部變量進行加強運算（a=a+1 a+=1） 解決方案：能夠利用gloabl和nonlocal聲明一下
lambda表達式與匿名函數
匿名函數
python 使用 lambda 來建立匿名函數。
- lambda只是一個表達式，函數體比def簡單不少。
- lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
- lambda函數擁有本身的命名空間，且不能訪問自有參數列表以外或全局命名空間裏的參數。
- 雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，後者的目的是調用小函數時不佔用棧內存從而增長運行效率。
- 語法
lambda函數的語法只包含一個語句，以下：
語法： lambda [arg1 [,arg2,.....argn]]:expression ：左邊是參數 ：右邊式返回值
以下實例：
# 可寫函數說明 sum = lambda arg1, arg2: arg1 + arg2; # 調用sum函數 print "相加後的值爲 : ", sum( 10, 20 ) print "相加後的值爲 : ", sum( 20, 20 ) #以上實例輸出結果： 相加後的值爲 : 30 相加後的值爲 : 40
#普通函數
def fun(x):
return 2*x+1
print(fun(5))
#lambda表達式改寫
a=lambda x:2*x+1
print(a(5))
注意
1.使用場景：只是用一次以後就不用的這種函數就能夠用lambda表達式取建立。 2.lambda表達式的運行效率較普通函數更低。 3.lambda表達式的優先級最低。
補充點：（閉包的延時綁定python深層次的知識點）**
概念： 1.閉包：函數式編程中的重要語法結構，函數式編程是一種編程範式 2.編程範式：對代碼進行提煉和抽象的歸納，使得代碼的重用性更高 # 若是在一個內部函數裏面對外部函數的局部變量進行引用，外部函數之內部函數名調用，則這個內部函數就是一個閉包 條件： 1.只要內部函數使用了外部函數的局部變量 2.若是外層函數返回值爲內層函數對象 做用： 1.能夠在聲明較少參數狀況下，傳遞更多的參數 2.可使用內部的函數 3.多應用於集羣
def fun1():
a=10
def fun2(x):
return a+x
return fun2
print(fun1()(10))
#結果爲：20
Python中的做用域泄露
for i in range(3): # i局部變量--->做用域泄露--->危險 a=i*2 # i最終將變成2 print(a) # 4
閉包的延時綁定
def fun():
return [lambda x:i*x for i in range(4)] #此處i相對於該函數來講是全局變量
print([m(2) for m in fun()])
#結果
[6, 6, 6, 6]
'''
Python 中文檔說明：
若是i 被賦值（執行for循環），那麼能夠在for循環以外分享變量
若是i並無被賦值，那麼則訪問不到
'''
#等價於
def fun():
list=[]
for i in range(4):
def lam(x):
return x*i
list.append(lam)
return list
print([m(2) for m in fun()])
- 閉包的延時綁定問題的解決辦法
def fun():
return [lambda x,n=i:x*n for i in range(4)]
print([m(2) for m in fun()])
def fun():
list=[]
for i in range(4):
def lam(x,n=i):
return x*n
list.append(lam)
return list
print([m(2) for m in fun()])
#只須要取每一次遍歷的i便可，不要取最終的i
Python中的高級函數
- filter()
filter(function or None,iterable) 參數一：是一個函數或者None 參數二：是一個可迭代對象 若是第一個參數爲函數，則將第二個參數中的每個元素做爲參數傳遞給第一個函數參數 注意： 1.若是第一個參數爲None，則返回第二參數（可迭代對象）中的非False(0,False,全部的空值) 2.第一個參數的返回值--->只返回True或者False--->布爾函數
def fun(x):
return x%2
print(list(filter(fun,[1,2,3,4,5,6,7,8,9,10])))
#結果爲：[1, 3, 5, 7, 9]
def fun1(x):
if x%2==0:
return True
else:
return False
print(list(filter(fun1,[1,2,3,4,5,6,7,8,9,10])))
#結果爲：[2, 4, 6, 8, 10]
# filter()函數要作的事情就是把全部爲False的去除
- map()
map(func,*iterable) 參數一：函數 參數二：多個可迭代對象 1. 將每個參數的元素進行運算，直到每一個元素都進行運算完畢，將運算後的總體構建成新的序列
def fun(x):
return x*2
print(list(map(fun,[1,2,3,4,5])))
#結果爲：[2, 4, 6, 8, 10]
改爲lambda形式
print(list(map(lambda x:x*2,[1,2,3,4,5])))
- reduce()
Python3:functiontools.reduce() #須要引入該模塊
1. reduce(function(),sequence[,initial])
對序列中的一對元素進行計算,這個計算結果將和第三個元素繼續進行計算，以此類推。
第一個參數：函數
第二個參數：序列
第三個參數：初始值，若是給了初始值則先計算初始值
#沒有初始值狀況：
import functools
def fun(x,y):
return x+y
print(functools.reduce(fun,[1,2,3,4,5,6]))
# 結果爲：21
#有初始值狀況
import functools
def fun(x,y):
return x+y
print(functools.reduce(fun,[1,2,3,4,5,6],10))
# 結果爲：31
函數嵌套和遞歸
函數嵌套：在一個函數裏面調用另外一個函數 執行流程和java同樣的
- 一元二次方程
$ax^2+bx+c=0$
$x=\frac{-b\pm\sqrt{b^2-4ac}}{2a}$
# 解一元二次方程
def fun(a, b, c):
# 判斷是否有解
delta = b ** 2 - 4 * a * c
if existSolution(a, b, c):
x1 = (-b + delta ** 0.5) / 2 * a
x2 = (-b + delta ** 0.5) / 2 * a
print('方程有解，x1=%s x2=%s' %(x1,x2))
else:
print("方程無解")
# 判斷是否有解,有解返回True無解返回False
def existSolution(a, b, c):
delta = b ** 2 - 4 * a * c
if delta >= 0:
return True
else:
return False
#調用
fun(1,0,-4)
#結果：方程有解，x1=2.0 x2=2.0
- 遞歸
和Java同樣，遞歸是一種特殊的函數嵌套調用，本身調用本身 避免無窮遞歸--->要加收斂條件
def fact(n):
if n == 1:
return 1
else:
ret = n * fact(n - 1)
return ret
n = int(input("請輸入一個數："))
print('%s 的階乘爲%s' %(n,fact(n)))
#結果爲：
請輸入一個數：5
5 的階乘爲120
- 斐波那契數列
#斐波那契額數列
def feibo(n):
a=1
b=1
for i in range(1,n+1):
if i<3:
print(1,end=' ')
else:
a,b=b,a+b
print(b,end=' ')
feibo(12)
#結果爲：1 1 2 3 5 8 13 21 34 55 89 144
#用遞歸實現
def feibo(n):
if n<3:
return 1
else:
return feibo(n-1)+feibo(n-2)
for i in range(1,13):
print(feibo(i),end=' ')
#結果爲：1 1 2 3 5 8 13 21 34 55 89 144
- 漢諾塔問題
遞歸中的經典問題
#a,b,c柱子名稱（從a將n個盤子挪到b,藉助c）;n表示共有幾個盤子
def hannoi(a,b,c,n):
if n==1:
print('%s --->%s'%(a,b))
return
hannoi(a,c,b,n-1)
print('%s ---> %s' %(a,b))
hannoi(c,b,a,n-1)
hannoi('A','B','C',3)
#結果爲：
A --->B
A ---> C
B --->C
A ---> B
C --->A
C ---> B
A --->B
Python 內置函數
__init__ : 構造函數，在生成對象時調用 __new__ :建立對象 __del__ : 析構函數，釋放對象時使用，析構器/垃圾回收器 __repr__ : 打印，轉換 __setitem__ : 按照索引賦值 __getitem__: 按照索引獲取值 __len__: 得到長度 __cmp__: 比較運算 __call__: 函數調用 __add__: 加運算 __sub__: 減運算 __mul__: 乘運算 __truediv__: 除運算 __mod__: 求餘運算 __pow__: 乘方
集合
1. 集合中的元素是無序的、惟一的 字典的key是集合實現的 因此是無序的惟一的不重複的
- 集合的建立
集合（set）是一個無序的不重複元素序列。 可使用大括號 { } 或者 set() 函數建立集合，注意：建立一個空集合必須用 set() 而不是 { }，由於 { } 是用來建立一個空字典。
1. 直接建立
2. 使用set()工廠函數：
set()：返回一個空集合對象--->沒有空集合
set(iterable):去重轉集合
- 集合的訪問
# 其餘訪問的函數下表總結 1. 遍歷： 利用for循環進行遍歷 2. 成員運算符： in 包含 not in 不包含 3. 比較運算符： 參考數學中集合的比較概念：比大小是比包含關係的不是拿元素內容比的
- 並集、交集、差集
和數學中的概念是同樣的 1. 交集：& 2. 並集：or python2中支持+ 3. 差集：-
- 不可變集合
關鍵字：frozenset a=frozenset([1,2,3]) 返回一個frozenset對象
- enumerate
enumerate(iterable[,start])
返回一個enumerate對象，該對象封裝可迭代對象的元素和下標--->封裝成了(index,value)形式
list=[1,2,3,4,5]
for i in enumerate(list):
print(i)
#結果爲：
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
集合內置方法
| 方法 | 描述 |
|---|---|
| add() | 爲集合添加元素,若是該元素存在則不添加 |
| clear() | 移除集合中的全部元素 |
| copy() | 拷貝一個集合 |
| difference() | 返回多個集合的差集 |
| difference_update() | 移除集合中的元素，該元素在指定的集合也存在。 |
| discard() | 刪除集合中指定的元素 |
| intersection() | 返回集合的交集 |
| intersection_update() | 刪除集合中的元素，該元素在指定的集合中不存在。 |
| isdisjoint() | 判斷兩個集合是否包含相同的元素，若是沒有返回 True，不然返回 False。 |
| issubset() | 判斷指定集合是否爲該方法參數集合的子集。 |
| issuperset() | 判斷該方法的參數集合是否爲指定集合的子集 |
| pop() | 隨機移除元素 |
| remove() | 移除指定元素 |
| symmetric_difference() | 返回兩個集合中不重複的元素集合。 |
| symmetric_difference_update() | 移除當前集合中在另一個指定集合相同的元素，並將另一個指定集合中不一樣的元素插入到當前集合中。 |
| union() | 返回兩個集合的並集 |
| update() | 給集合添加元素 |
面向對象
面向對象的幾個概念
1. 類(Class): 用來描述具備相同的屬性和方法的對象的集合。它定義了該集合中每一個對象所共有的屬性和方法。對象是類的實例。 2. 方法：類中定義的函數。 3. 類變量：類變量在整個實例化的對象中是公用的。類變量定義在類中且在函數體以外。類變量一般不做爲實例變量使用。 4. 數據成員：類變量或者實例變量用於處理類及其實例對象的相關的數據。 5. 方法重寫：若是從父類繼承的方法不能知足子類的需求，能夠對其進行改寫，這個過程叫方法的覆蓋（override），也稱爲方法的重寫。 6. 局部變量：定義在方法中的變量，只做用於當前實例的類。 7. 實例變量：在類的聲明中，屬性是用變量來表示的。這種變量就稱爲實例變量，是在類聲明的內部可是在類的其餘成員方法以外聲明的。 8. 繼承：即一個派生類（derived class）繼承基類（base class）的字段和方法。繼承也容許把一個派生類的對象做爲一個基類對象對待。例如，有這樣一個設計：一個Dog類型的對象派生自Animal類，這是模擬"是一個（is-a）"關係（例圖，Dog是一個Animal）。 9. 實例化：建立一個類的實例，類的具體對象。 10. 對象：經過類定義的數據結構實例。對象包括兩個數據成員（類變量和實例變量）和方法。
- 類的定義
#定義類
class Student:
name='lijb'
age=18
sex=True
#定義方法
def learn(self,name):
print('Students %s are learning...' %(name))
#建立對象
s=Student()
#調用對象的屬性
print(s.name)
#調用對象的方法
s.learn('luanp')
- 屬性
1. 屬性的分類（變量）
示例屬性：在方法內部定義，定義方式（self.屬性名=屬性值）
類屬性：在類的內部，方法的外部定義
2. 訪問形式:
對象.屬性名
3. 類屬性
建立：直接定義，須要默認值
訪問形似：對象.屬性名
4. 實例屬性：
建立：經過self.屬性名
優點：直接使用屬性而不用定義，該定義形式能夠避免建立時必須賦值的狀況
在類的內部訪問：self.屬性名
利用對象去訪問：對象名.屬性名
- 實例屬性和類屬性的區分
實例屬性：每一個實例各自擁有，互不影響 類屬性：全類全部
- 方法
1. 方法：聲明+實現
2. self（指當前對象）
方法能夠多個參數，用逗號隔開
self:在調用時，自動傳遞，不須要手動傳遞
3. 方法：
只能在建立對象以後調用，放法綁定到對象（實例）上
- 構造方法
1. __init__(self): 在建立對象時默認調用1次，能夠手工調用可是不須要手工調用 2. __init__(self,param1,param2,...): 構造方法能夠有多個參數，用逗號隔開 3. 若是一個類中沒有任何構造方法，默認調用的是父類的構造方法 4. 一個類中能夠定義多個構造方法，可是隻會執行最後一個構造方法（後面的構造方法將前面的覆蓋） 5. 構造方法的返回值爲None
- 建立對象
1. 建立對象
變量名=類名（構造參數）
d=Dog()
Dog()這種沒有引用的對象會被標記爲垃圾，垃圾回收機制
2. 建立的對象統稱爲實例--instance
和實例相關的屬性：實例屬性---綁定屬性
和實例相關的方法：實例方法---綁定方法
- 組合
一個類的屬性是另外一個對象稱之爲組合 注意： 1.若是實例屬性和方法發生命名衝突，則方法沒法調用 2.若是類屬性和方法發生命名衝突，則類屬性沒法被調用（調用時顯示爲同名方法的地址）
- 公有和私有問題
成員私有化 1. 私有化：name mangling---名字重造 2. 在成員名前加__兩個下劃線 3. 私有成員 不能在類以外被訪問，只能在本類重訪問 成員私有化後要提供對應的get/set方法 4. python的私有化爲僞私有化 將成員名修改成：_類名_成員名
1. 類的私有屬性 __private_attrs：兩個下劃線開頭，聲明該屬性爲私有，不能在類的外部被使用或直接訪問。在類內部的方法中使用時 self.__private_attrs。 類的方法 在類的內部，使用 def 關鍵字來定義一個方法，與通常函數定義不一樣，類方法必須包含參數 self，且爲第一個參數，self 表明的是類的實例。 self 的名字並非規定死的，也可使用 this，可是最好仍是按照約定是用 self。 2. 類的私有方法 __private_method：兩個下劃線開頭，聲明該方法爲私有方法，只能在類的內部調用 ，不能在類的外部調用。self.__private_methods。
封裝
和Java同樣，數據隱藏，屬性私有化
繼承
定義形式：
class 子類類名（父類類名）：#父類類名不寫默認爲object
繼承特色：
1. 子類能夠繼承父類的方法和屬性
2. 可擴展性
3. 父類中的私有成員不能被繼承（不能直接訪問）
4. 子類中沒有構造方放時默認調用父類的構造方法
子類調用父類的構造方法：
A.父類名.__init__(self): ---在子類內部調用
B.父類名.__init__(當前對象):---在子類外部調用
C.super().__init__(): ---利用super()函數---不用傳self參數由於系統自動給super傳了
5. 子類有構造方法時調用本身的構造方法
其特色和Java同樣
單繼承
class DerivedClassName(BaseClassName1):
<statement-1>
.
.
.
<statement-N>
須要注意圓括號中基類的順序，如果基類中有相同的方法名，而在子類使用時未指定，python從左至右搜索 即方法在子類中未找到時，從左到右查找基類中是否包含方法。
BaseClassName（示例中的基類名）必須與派生類定義在一個做用域內。除了類，還能夠用表達式，基類定義在另外一個模塊中時這一點很是有用:
#類定義
class people:
#定義基本屬性
name = ''
age = 0
#定義私有屬性,私有屬性在類外部沒法直接進行訪問
__weight = 0
#定義構造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 說: 我 %d 歲。" %(self.name,self.age))
#單繼承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#調用父類的構函
people.__init__(self,n,a,w)
self.grade = g
#覆寫父類的方法
def speak(self):
print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
s = student('ken',10,60,3)
s.speak()
多繼承
class DerivedClassName(Base1, Base2, Base3):
<statement-1>
.
.
.
<statement-N>
須要注意圓括號中父類的順序，如果父類中有相同的方法名，而在子類使用時未指定，python從左至右搜索 即方法在子類中未找到時，從左到右查找父類中是否包含方法。
特色：多繼承要不斷的建立父類對象佔內存浪費資源
#類定義
class people:
#定義基本屬性
name = ''
age = 0
#定義私有屬性,私有屬性在類外部沒法直接進行訪問
__weight = 0
#定義構造方法
def __init__(self,n,a,w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print("%s 說: 我 %d 歲。" %(self.name,self.age))
#單繼承示例
class student(people):
grade = ''
def __init__(self,n,a,w,g):
#調用父類的構函
people.__init__(self,n,a,w)
self.grade = g
#覆寫父類的方法
def speak(self):
print("%s 說: 我 %d 歲了，我在讀 %d 年級"%(self.name,self.age,self.grade))
#另外一個類，多重繼承以前的準備
class speaker():
topic = ''
name = ''
def __init__(self,n,t):
self.name = n
self.topic = t
def speak(self):
print("我叫 %s，我是一個演說家，我演講的主題是 %s"%(self.name,self.topic))
#多重繼承
class sample(speaker,student):
a =''
def __init__(self,n,a,w,g,t):
student.__init__(self,n,a,w,g)
speaker.__init__(self,n,t)
test = sample("Tim",25,80,4,"Python")
test.speak() #方法名同，默認調用的是在括號中排前地父類的方法
Python中的繼承時多繼承---鑽石繼承問題--多繼承要不斷的建立父類對象佔內存浪費資源--解決辦法爲：super() super()底層是mro內核（繼承鏈關係）實現的
方法重寫
若是父類方法的功能不能知足你的需求，你能夠在子類重寫你父類的方法，實例以下：
class Parent: # 定義父類
def myMethod(self):
print ('調用父類方法')
class Child(Parent): # 定義子類
def myMethod(self):
print ('調用子類方法')
c = Child() # 子類實例
c.myMethod() # 子類調用重寫方法
super(Child,c).myMethod() #用子類對象調用父類已被覆蓋的方法
執行以上程序輸出結果爲：
調用子類方法 調用父類方法
多態
多態
多態指一類事物具備多種形態（繼承關係） 序列：列表、元組、字符串 動物：貓、狗。。。
多態性
是指不一樣功能的函數，可使用同一個函數名，可使用同一個函數名調用不一樣的內容 向不一樣的對象發送同一條消息，不一樣的對象在接受時會產生不一樣的形式爲。
函數
- issubclass()
issubclass(cls,class_or_tuple): 1. 若是cls類是class類的子類返回True,相同也返回True,不是則返回False 2. 若是cls是tuple元素的子類則返回True
- isinstance()
isinstance(obj,class_or_tuple): 1. 若是obj是class的實例對象則返回True 2. 若是obj繼承了class則返回True 3. 若是obj是tuple中的元素實例則返回True
- hasattr()
hasattr(obj,name,/): 判斷obj對象中是否有name這個屬性---name是str
- getattr()
getattr(object,name[,default]): 1. 從object中獲取一個屬性值---name 2. 若是name不存在則返回default中的信息 3. 若是default沒有定義則拋出異常
- setattr()
setattr(obj,name,value): 設置obj中的name屬性值爲value
- delattr()
delattr(object,name): 刪除object中name屬性
- property（）
property（fget=None,fset=None,fdel=None,doc=None）: 1. 經過屬性設置屬性 2. 將屬性和另外一個屬性作關聯，修改一個屬性，則另外一個屬性也隨之更改 3. fget,fset,fdel分別表明關聯屬性的get,set,del 4. 方法的返回值用於關聯另外一個屬性
修飾器（修飾符）
做用：能夠爲已經存在的代碼增長額外功能
修飾器：Decorator: 關鍵字：@ 1. 修飾器只能出如今函數定義的前一行，不容許和函數定義在同一行 2. 只能在模塊或類中定義，而且不能修飾類，只能是對函數或方法進行修飾 3. 裝飾器自己是一個函數，是將被修飾的函數看成參數傳遞給裝飾器，返回的是修飾以後的函數
- 基本定義形式
#基本定義形式
class B:
#定義修飾器
def A(fun):
print("修飾器")
return fun #返回一個函數
#修飾器修飾方法
[@A](https://my.oschina.net/a8856225a)
def m1(self):
print('運行m1()')
#建立對象並調用方法
b=B()
b.m1()
#結果：
修飾器
運行m1()
- 利用內嵌函數
#利用內嵌函數
def funA(f):
def funB():
print("inner function B")
funB()
return f
@funA
def funC():
print('function C')
funC()
#結果：
inner function B
function C
- 利用閉包
#利用閉包
def funD(f):
def funE():
print('inner function E')
f()
return None
return funE
[@funD](https://my.oschina.net/u/3954936)
def funF():
print('function F')
return None
funF()
#結果：
inner function E
function F
- 利用類
#利用類
class G:
def __init__(self,f):
self.f=f
def __call__(self):
print('class G')
return self.f()
[@G](https://my.oschina.net/godzilar)
def funH():
print('function H')
return None
funH()
#結果：
class G
function H
- 使用案例
計算程序運行的時間
#計算程序運行的時間
import time
def timelong(f):
start=time.clock()
print('time start')
f()
end=time.clock()
print('time end')
print('程序運行的時間爲：%s s'%(end-start))
return lambda :None
@timelong
def sum1():
ret=0
for i in range(100):
ret +=i
print('計算的結果爲：%s'%(ret))
sum1()
#結果：
time start
計算的結果爲：4950
time end
程序運行的時間爲：4.758972406575423e-05 s
Python中內置的裝飾器
1. classmethond:修飾類方法 2. property 3. staticmethond:靜態方法（和函數的使用徹底同樣）
專題
專題1：Python中的賦值
| 運算 | 解釋 |
|---|---|
| a='hehe' | 基本形式 |
| a,b=1,2 | 元組賦值（位置性） |
| [a,b]=[1,2] | 列表賦值（位置性） |
| a,b,c,d='spark' | 序列賦值（通用性） |
| a,b,c=[1,2,3] | 序列賦值（通用性） |
| a,*b='spark' | 擴展的序列解包（Python3獨有的） |
| a=b=c=d='spark' | 多目標賦值 |
| a+=1 | 加強賦值：至關於a=a+1 |
- 高級序列賦值
- 高級序列賦值--->賦值嵌套序列
s='spark'
(a,b),c=s[:2],s[2:]
print((a,b),c)
#結果：
('s', 'p') ark
- 高級序列賦值--->利用range()函數
a,b,c=range(3) print(a,b,c)
- 利用切片進行序列的分割
list=[1,2,3,4]
while list:
front,list=list[0],list[1:]
print(front,list)
#結果以下：
1 [2, 3, 4]
2 [3, 4]
3 [4]
4 []
- Python3中擴展的序列解包
- a,*b a匹配第一個元素元素 b匹配剩餘的元素
a,*b=[1,2,3,4] print(a,b) #結果： （1,[2,3,4]）
- *a,b b匹配最後一項 a匹配前面的剩餘項
*a,b=[1,2,3,4] print(a,b) #結果： ([1,2,3],4)
- a,*b,c a匹配第一項 b匹配中間項目 c匹配最後一項
a,*b,c=[1,2,3,4] print(a,b,c) #結果： (1,[2,3],4)
- 序列分割
list=[1,2,3,4]
while list:
front,*list=list
print(front,list)
#結果以下：
1 [2, 3, 4]
2 [3, 4]
3 [4]
4 []
專題2：可迭代對象
字符串、列表、元組、集合、字典
- 容器
容器是一種把多個元素組織在一塊兒的數據結構，容器中的元素能夠逐個的迭代獲取 特色:能夠經過in/not in 成員關係操做符 檢測元素是否在容器以內 常見的容器類型： list/str/tuple/set/dict/frozenset
專題3：Python中的推導式
列表推導式 字典推導式 集合推導式 推導式能夠從一個數據序列構建另外一個數據序列
- 列表推導式
推導式--->解析式
1. 格式：
變量名=[表達式 for 變量 in 可迭代對象 if 布爾表達式]
if能夠省略
2. 案例：
s=[i for i in range(10)]
print(s)
#結果爲：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9
- 字典推導式
1. 格式
變量={鍵:值 for 變量 in 可迭代對象 if 表達式}
2. 案例：
d={k:v for k,v in [('one',1),('two',2),('three',3)] if k!='one'}
print(d)
#結果爲：
{'two': 2, 'three': 3}
#大小寫合併 將字典s轉成不區分大小寫的新字典輸出，避免覆蓋key相同時value相加
s={'a':10,'b':20,'A':100,'B':200}
d={k.lower():s[k.lower()]+s[k.upper()]for k in s}
print(d)
#結果爲：{'a': 110, 'b': 220}
- 集合推導式
1. 格式：
變量={表達式 for 變量 in 可迭代對象 if 布爾表達式}
2. 案例：
s={i for i in range(10)}
print(s)
#結果爲：{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
注：推導式中表達式能夠徹底換成函數，該函數只使用一次故能夠換成lambda表達式寫成匿名函數
專題4：MinxIn編程
MinxIn是一種開發模式，是將多個類中的功能進行組合的使用方法
1. 利用多繼承，不關注繼承只關注功能 2. 利用__bases__ 3. 利用插件模式
專題5：鴨子類型
1. 在程序設計中，鴨子類型（duck typing）是一種動態類型的風格 2. Python是一門動態類型的語言 3. **在鴨子類型中，關注的不是對象類型自己，而是關注其如何使用** 4. 實際上鴨子類型就是多態性的一種體現 5. 在Python文檔中，使用鴨子類型時儘可能避免使用isinstance(),type()這樣的方法去判斷類型，由於這樣會限制鴨子類型的使用靈活性 全部的控制由程序員控制--->可能會出錯
專題6：池化
1. 池化有助於減小對象數量和內存的消耗，提升性能 2. 池化是一種預分配機制 線程池，請求池、鏈接池。。。和Java是同樣的
專題7：魔法方法
在Python中被兩條下劃線包圍的方法或屬性稱之爲魔法方法，如：__init__()等。
對象的建立和消亡相關
- _init_
1. __init__(self,[...]) 構造方法---初始化方法 初始化實例屬性時進行調用 本質時覆蓋了object中的__init__ 2. 有返回值，返回值必須是None
- _new_
1. __new__(cls,[...]) 建立對象的時候自動的被調用，只調用一次，可是__init__不是第一次被調用的魔法方法，第一次被調用的是__new__ cls:class---類 new的參數傳遞給了init 2. 通常不修改new方法
- _del_
1. __del__(self): init--構造方法 del---析構方法 析構器：垃圾回收器finalizer：當一個對象在消亡時，由編譯器自動調用 析構函數：destructor 和構造函數相反---當對象脫離做用區域時，則自動調用析構函數 del 變量名---刪除的是引用---和__del__不同
算術相關魔法方法
- property的實現--描述符
定製容器
1. 協議：protocols 協議和接口很類似：規定了哪些方法必須定義的---指南 2. Python中的協議： 一種思想 鴨子類型--動車類型風格 3. 容器類型： 列表，字典。元組，集合。字符串，不可編集合
- 定製容器的協議
1. 若是定製容器不可變： __len__() __getitem__() 2. 若是定製可變容器 __len__() __getitem__() __setitem__() __delitem__()
#編寫一個不可變的列表，要求記錄列表中每個元素被訪問的次數
class MyList:
def __init__(self,*args):
self.value=[x for x in args] #用來存儲傳進來的值
#建立字典記錄被訪問次數--元素1：次數1 元素2：次數2 元素3：次數3
self.counts={k:0 for k in self.value}
def __len__(self):
return len(self.value)
def __getitem__(self, item): #item是被訪問元素的下標
temp=self.value[item]
self.counts[temp]+=1
return self.counts[temp]
m1=MyList(1,2,3,4,5)
m1[0]
m1[0]
m1[1]
print(m1.counts)
迭代器
迭代：每一次重複的過程，每一次迭代的結果做爲下一次迭代的初始值 迭代器：存放迭代方法的容器，但凡是實現了__iter__()和__next__()的都是迭代器 關於迭代操做： 1. iter(): 對一個容器調用iter()方法，返回該對象的迭代器 2. next(): 迭代器調用next()方法，則返回下一個值，若是迭代器沒有下一個值，則拋出異常：StopIteration Error 包含的魔法方法 1. __iter__() 返回一個迭代對象，通常不會進行修改，直接返回當前對象（self） 2. __next__() next()方法底層調用的是__next__()--核心：迭代規則 # 綜上所述：一個對象實現了__iter__()和__next__()方法以後自己就是一個迭代器
- 練習
斐波那契數列
#斐波那契數列 函數寫法
def feibo(n):
a=1
b=1
for i in range(1,n+1):
if i<3:
print(1,end=' ')
else:
a,b=b,a+b
print(b,end=' ')
feibo(12)
def feibo(n):
if n<3:
return 1
else:
return feibo(n-1)+feibo(n-2)
for i in range(1,13):
print(feibo(i),end=' ')
#---------------------------------------------------------------------------------------
# 利用迭代器中包含的魔法方法實現
class Fibo:
#寫一個初始方法，給兩個初始值
def __init__(self):
self.a,self.b=0,1
#實現__iter__() and __next__()
def __iter__(self):
return self
def __next__(self):
#核心---決定迭代規則
self.a,self.b=self.b,self.a+self.b
return self.a
fibo=Fibo()
for i in fibo:
if i > 100:
break
else:
print(i,end=' ')
- 總結
模塊
1. 模塊的概念：將代碼量較大的程序分割成多個組織，彼此獨立，且能相互調用的代碼片斷，這些文件稱之爲模塊。 2. 模塊在物理形式上以.py結尾的代碼文件（源文件） 3. Python容許導入其餘模塊以實現代碼重用，從而實現了將獨立的代碼文件組織成更大的程序系統
import 語句
想使用 Python 源文件，只需在另外一個源文件裏執行 import 語句，語法以下：
import module1[, module2[,... moduleN]
當解釋器遇到 import 語句，若是模塊在當前的搜索路徑就會被導入。
搜索路徑是一個解釋器會先進行搜索的全部目錄的列表。如想要導入模塊 support，須要把命令放在腳本的頂端：
import sys #引入模塊
print('命令行參數以下:')
for i in sys.argv:
print(i)
print('\n\nPython 路徑爲：', sys.path, '\n')
這種導入方式只能導入模塊級別，不能導入函數級別
from … import 語句
Python 的 from 語句讓你從模塊中導入一個指定的部分到當前命名空間中，語法以下：
from modname import name1[, name2[, ... nameN]] from 包名+模塊名 as 別名
例如，要導入模塊 fibo 的 fib 函數，使用以下語句：
>>> from fibo import fib, fib2 >>> fib(500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377
這個聲明不會把整個fibo模塊導入到當前的命名空間中，它只會將fibo裏的fib函數引入進來。
from … import * 語句
把一個模塊的全部內容全都導入到當前的命名空間也是可行的，只需使用以下聲明：
from modname import * from 包名+模塊名 as 別名
這提供了一個簡單的方法來導入一個模塊中的全部項目。然而這種聲明不應被過多地使用。
__name__屬性
一個模塊被另外一個程序第一次引入時，其主程序將運行。若是咱們想在模塊被引入時，模塊中的某一程序塊不執行，咱們能夠用__name__屬性來使該程序塊僅在該模塊自身運行時執行。
1. if __name__ == '__main__' 主要用於代碼的測試,若是以腳本的形式運行，則if中的語句會執行 2. __name__是模塊對象的屬性 若是以腳本的形式運行，則__name__屬性的值爲__main__ 若是以模塊的形式運行，則__name__屬性的值爲模塊的權限定名
#!/usr/bin/python3
# Filename: using_name.py
if __name__ == '__main__':
print('程序自身在運行')
else:
print('我來自另外一模塊')
運行輸出以下：
$ python using_name.py 程序自身在運行 $ python >>> import using_name 我來自另外一模塊 >>>
說明： 每一個模塊都有一個__name__屬性，當其值是'main'時，代表該模塊自身在運行，不然是被引入。
說明：name 與 main 底下是雙下劃線， _ _ 是這樣去掉中間的那個空格。
搜索路徑
import sys sys.path 1. Python中的全部路徑都在sys.pyth中 標準庫模塊：python安裝目錄下的lib下 第三方模塊：通常來自社區的模塊---site-packages 自定義模塊：本身編輯的模塊 2. 若是模塊真實存在，可是沒法直接import，能夠手動append到sys.path中
時間和日期
Python 程序能用不少方式處理日期和時間，轉換日期格式是一個常見的功能。 Python 提供了一個 time 和 calendar 模塊能夠用於格式化日期和時間。 時間間隔是以秒爲單位的浮點小數。 每一個時間戳都以自從1970年1月1日午夜（曆元）通過了多長時間來表示。 Python 的 time 模塊下有不少函數能夠轉換常見日期格式。如函數time.time()用於獲取當前時間戳,
import time; # 引入time模塊
ticks = time.time()
print ("當前時間戳爲:", ticks)
#結果爲：當前時間戳爲: 1554082392.113664
獲取當前時間
從返回浮點數的時間戳方式向時間元組轉換，只要將浮點數傳遞給如localtime之類的函數。
import time
localtime = time.localtime(time.time())
print ("本地時間爲 :", localtime)
# 獲取到時間元組
#運行結果爲：本地時間爲 : time.struct_time(tm_year=2019, tm_mon=4, tm_mday=1, tm_hour=9, tm_min=35, tm_sec=29, tm_wday=0, tm_yday=91, tm_isdst=0)
獲取格式化時間
你能夠根據需求選取各類格式，可是最簡單的獲取可讀的時間模式的函數是asctime():
import time
localtime = time.asctime( time.localtime(time.time()) )
print ("本地時間爲 :", localtime)
#運行結果爲：本地時間爲 : Mon Apr 1 09:37:48 2019
格式化日期
咱們可使用 time 模塊的 strftime 方法來格式化日期，：
time.strftime(format[, t])
import time
# 格式化成2019-03-20 11:45:39形式
print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
# 格式化成Sat Mar 28 22:24:24 2019形式
print (time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))
# 將格式字符串轉換爲時間戳
a = "Sat Mar 28 22:24:24 2019"
print (time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")))
python中時間日期格式化符號
1. %y 兩位數的年份表示（00-99） 2. %Y 四位數的年份表示（000-9999） 3. %m 月份（01-12） 4. %d 月內中的一天（0-31） 5. %H 24小時制小時數（0-23） 6. %I 12小時制小時數（01-12） 7. %M 分鐘數（00=59） 8. %S 秒（00-59） 9. %a 本地簡化星期名稱 10. %A 本地完整星期名稱 11. %b 本地簡化的月份名稱 12. %B 本地完整的月份名稱 13. %c 本地相應的日期表示和時間表示 14. %j 年內的一天（001-366） 15. %p 本地A.M.或P.M.的等價符 16. %U 一年中的星期數（00-53）星期天爲星期的開始 17. %w 星期（0-6），星期天爲星期的開始 18. %W 一年中的星期數（00-53）星期一爲星期的開始 19. %x 本地相應的日期表示 20. %X 本地相應的時間表示 21. %Z 當前時區的名稱 22. %% %號自己
獲取某月日曆
Calendar模塊有很普遍的方法用來處理年曆和月曆，例如打印某月的月曆：
import calendar
cal = calendar.month(2019, 4)
print ("如下輸出2019年4月份的日曆:")
print (cal)
#輸出結果爲：
如下輸出2019年4月份的日曆:
April 2019
Mo Tu We Th Fr Sa Su
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30
Time模塊的內置函數
Time 模塊包含了如下內置函數，既有時間處理的，也有轉換時間格式的：
| 序號 | 函數及描述 | 實例 |
|---|---|---|
| 1 | time.altzone 返回格林威治西部的夏令時地區的偏移秒數。若是該地區在格林威治東部會返回負值（如西歐，包括英國）。對夏令時啓用地區才能使用。 | 如下實例展現了 altzone()函數的使用方法：>>> import time >>> print ("time.altzone %d " % time.altzone) time.altzone -28800 |
| 2 | time.asctime([tupletime]) 接受時間元組並返回一個可讀的形式爲"Tue Dec 11 18:07:14 2008"（2008年12月11日 週二18時07分14秒）的24個字符的字符串。 | 如下實例展現了 asctime()函數的使用方法：>>> import time >>> t = time.localtime() >>> print ("time.asctime(t): %s " % time.asctime(t)) time.asctime(t): Thu Apr 7 10:36:20 2016 |
| 3 | time.clock() 用以浮點數計算的秒數返回當前的CPU時間。用來衡量不一樣程序的耗時，比time.time()更有用。 | 實例因爲該方法依賴操做系統，在 Python 3.3 之後不被推薦，而在 3.8 版本中被移除，需使用下列兩個函數替代。time.perf_counter() # 返回系統運行時間 time.process_time() # 返回進程運行時間 |
| 4 | time.ctime([secs]) 做用至關於asctime(localtime(secs))，未給參數至關於asctime() | 如下實例展現了 ctime()函數的使用方法：>>> import time >>> print ("time.ctime() : %s" % time.ctime()) time.ctime() : Thu Apr 7 10:51:58 2016 |
| 5 | time.gmtime([secs]) 接收時間戳（1970紀元後通過的浮點秒數）並返回格林威治天文時間下的時間元組t。注：t.tm_isdst始終爲0 | 如下實例展現了 gmtime()函數的使用方法：>>> import time >>> print ("gmtime :", time.gmtime(1455508609.34375)) gmtime : time.struct_time(tm_year=2016, tm_mon=2, tm_mday=15, tm_hour=3, tm_min=56, tm_sec=49, tm_wday=0, tm_yday=46, tm_isdst=0) |
| 6 | time.localtime([secs] 接收時間戳（1970紀元後通過的浮點秒數）並返回當地時間下的時間元組t（t.tm_isdst可取0或1，取決於當地當時是否是夏令時）。 | 如下實例展現了 localtime()函數的使用方法：>>> import time >>> print ("localtime(): ", time.localtime(1455508609.34375)) localtime(): time.struct_time(tm_year=2016, tm_mon=2, tm_mday=15, tm_hour=11, tm_min=56, tm_sec=49, tm_wday=0, tm_yday=46, tm_isdst=0) |
| 7 | time.mktime(tupletime) 接受時間元組並返回時間戳（1970紀元後通過的浮點秒數）。 | 實例 |
| 8 | time.sleep(secs) 推遲調用線程的運行，secs指秒數。 | 如下實例展現了 sleep()函數的使用方法：#!/usr/bin/python3 import time print ("Start : %s" % time.ctime()) time.sleep( 5 ) print ("End : %s" % time.ctime()) |
| 9 | time.strftime(fmt[,tupletime]) 接收以時間元組，並返回以可讀字符串表示的當地時間，格式由fmt決定。 | 如下實例展現了 strftime()函數的使用方法：>>> import time >>> print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) 2016-04-07 11:18:05 |
| 10 | time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') 根據fmt的格式把一個時間字符串解析爲時間元組。 | 如下實例展現了 strptime()函數的使用方法：>>> import time >>> struct_time = time.strptime("30 Nov 00", "%d %b %y") >>> print ("返回元組: ", struct_time) 返回元組: time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1) |
| 11 | time.time( ) 返回當前時間的時間戳（1970紀元後通過的浮點秒數）。 | 如下實例展現了 time()函數的使用方法：>>> import time >>> print(time.time()) 1459999336.1963577 |
| 12 | time.tzset() 根據環境變量TZ從新初始化時間相關設置。 | 實例 |
| 13 | time.perf_counter() 返回計時器的精準時間（系統的運行時間），包含整個系統的睡眠時間。因爲返回值的基準點是未定義的，因此，只有連續調用的結果之間的差纔是有效的。 | 實例 |
| 14 | time.process_time() 返回當前進程執行 CPU 的時間總和，不包含睡眠時間。因爲返回值的基準點是未定義的，因此，只有連續調用的結果之間的差纔是有效的。 |
Time模塊包含了如下2個很是重要的屬性：
| 序號 | 屬性及描述 |
|---|---|
| 1 | time.timezone 屬性time.timezone是當地時區（未啓動夏令時）距離格林威治的偏移秒數（>0，美洲;<=0大部分歐洲，亞洲，非洲）。 |
| 2 | time.tzname 屬性time.tzname包含一對根據狀況的不一樣而不一樣的字符串，分別是帶夏令時的本地時區名稱，和不帶的。 |
日曆（Calendar）模塊
此模塊的函數都是日曆相關的，例如打印某月的字符月曆。
星期一是默認的每週第一天，星期天是默認的最後一天。更改設置需調用calendar.setfirstweekday()函數。模塊包含了如下內置函數：
| 序號 | 函數及描述 |
|---|---|
| 1 | calendar.calendar(year,w=2,l=1,c=6) 返回一個多行字符串格式的year年年曆，3個月一行，間隔距離爲c。 每日寬度間隔爲w字符。每行長度爲21* W+18+2* C。l是每星期行數。 |
| 2 | calendar.firstweekday( ) 返回當前每週起始日期的設置。默認狀況下，首次載入caendar模塊時返回0，即星期一。 |
| 3 | calendar.isleap(year) 是閏年返回 True，不然爲 false。>>> import calendar >>> print(calendar.isleap(2000)) True >>> print(calendar.isleap(1900)) False |
| 4 | calendar.leapdays(y1,y2) 返回在Y1，Y2兩年之間的閏年總數。 |
| 5 | calendar.month(year,month,w=2,l=1) 返回一個多行字符串格式的year年month月日曆，兩行標題，一週一行。每日寬度間隔爲w字符。每行的長度爲7* w+6。l是每星期的行數。 |
| 6 | calendar.monthcalendar(year,month) 返回一個整數的單層嵌套列表。每一個子列表裝載表明一個星期的整數。Year年month月外的日期都設爲0;範圍內的日子都由該月第幾日表示，從1開始。 |
| 7 | calendar.monthrange(year,month) 返回兩個整數。第一個是該月的星期幾，第二個是該月有幾天。星期幾是從0（星期一）到 6（星期日）。>>> import calendar >>> calendar.monthrange(2014, 11) (5, 30)(5, 30)解釋：5 表示 2014 年 11 月份的第一天是週六，30 表示 2014 年 11 月份總共有 30 天。 |
| 8 | calendar.prcal(year,w=2,l=1,c=6) 至關於 print calendar.calendar(year,w,l,c). |
| 9 | calendar.prmonth(year,month,w=2,l=1) 至關於 print calendar.calendar（year，w，l，c）。 |
| 10 | calendar.setfirstweekday(weekday) 設置每週的起始日期碼。0（星期一）到6（星期日）。 |
| 11 | calendar.timegm(tupletime) 和time.gmtime相反：接受一個時間元組形式，返回該時刻的時間戳（1970紀元後通過的浮點秒數）。 |
| 12 | calendar.weekday(year,month,day) 返回給定日期的日期碼。0（星期一）到6（星期日）。月份爲 1（一月） 到 12（12月）。 |
其餘相關模塊和函數
在Python中，其餘處理日期和時間的模塊還有：
**案例1：**perf_counter 進度條實例
import time
scale = 50
print("執行開始".center(scale//2,"-")) # .center() 控制輸出的樣式，寬度爲 25//2，即 22，漢字居中，兩側填充 -
start = time.perf_counter() # 調用一次 perf_counter()，從計算機系統裏隨機選一個時間點A，計算其距離當前時間點B1有多少秒。當第二次調用該函數時，默認從第一次調用的時間點A算起，距離當前時間點B2有多少秒。兩個函數取差，即實現從時間點B1到B2的計時功能。
for i in range(scale+1):
a = '*' * i # i 個長度的 * 符號
b = '.' * (scale-i) # scale-i） 個長度的 . 符號。符號 * 和 . 總長度爲50
c = (i/scale)*100 # 顯示當前進度，百分之多少
dur = time.perf_counter() - start # 計時，計算進度條走到某一百分比的用時
print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,dur),end='') # \r用來在每次輸出完成後，將光標移至行首，這樣保證進度條始終在同一行輸出，即在一行不斷刷新的效果；{:^3.0f}，輸出格式爲居中，佔3位，小數點後0位，浮點型數，對應輸出的數爲c；{}，對應輸出的數爲a；{}，對應輸出的數爲b；{:.2f}，輸出有兩位小數的浮點數，對應輸出的數爲dur；end=''，用來保證不換行，不加這句默認換行。
time.sleep(0.1) # 在輸出下一個百分之幾的進度前，中止0.1秒
print("\n"+"執行結果".center(scale//2,'-'))
#執行結果爲：
-----------執行開始----------
24 %[************->......................................]1.24s
import time
import calendar
"""
時間元組（年、月、日、時、分、秒、一週的第幾日、一年的第幾日、夏令時）
一週的第幾日: 0-6
一年的第幾日: 1-366
夏令時: -1, 0, 1
"""
"""
python中時間日期格式化符號：
------------------------------------
%y 兩位數的年份表示（00-99）
%Y 四位數的年份表示（000-9999）
%m 月份（01-12）
%d 月內中的一天（0-31）
%H 24小時制小時數（0-23）
%I 12小時制小時數（01-12）
%M 分鐘數（00=59）
%S 秒（00-59）
%a 本地簡化星期名稱
%A 本地完整星期名稱
%b 本地簡化的月份名稱
%B 本地完整的月份名稱
%c 本地相應的日期表示和時間表示
%j 年內的一天（001-366）
%p 本地A.M.或P.M.的等價符
%U 一年中的星期數（00-53）星期天爲星期的開始
%w 星期（0-6），星期天爲星期的開始
%W 一年中的星期數（00-53）星期一爲星期的開始
%x 本地相應的日期表示
%X 本地相應的時間表示
%Z 當前時區的名稱 # 亂碼
%% %號自己
"""
# （1）當前時間戳
# 1538271871.226226
time.time()
# （2）時間戳 → 時間元組，默認爲當前時間
# time.struct_time(tm_year=2018, tm_mon=9, tm_mday=3, tm_hour=9, tm_min=4, tm_sec=1, tm_wday=6, tm_yday=246, tm_isdst=0)
time.localtime()
time.localtime(1538271871.226226)
# （3）時間戳 → 可視化時間
# time.ctime(時間戳)，默認爲當前時間
time.ctime(1538271871.226226)
# （4）時間元組 → 時間戳
# 1538271871
time.mktime((2018, 9, 30, 9, 44, 31, 6, 273, 0))
# （5）時間元組 → 可視化時間
# time.asctime(時間元組)，默認爲當前時間
time.asctime()
time.asctime((2018, 9, 30, 9, 44, 31, 6, 273, 0))
time.asctime(time.localtime(1538271871.226226))
# （6）時間元組 → 可視化時間（定製）
# time.strftime(要轉換成的格式，時間元組)
time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
# （7）可視化時間（定製） → 時間元祖
# time.strptime(時間字符串，時間格式)
print(time.strptime('2018-9-30 11:32:23', '%Y-%m-%d %H:%M:%S'))
# （8）浮點數秒數，用於衡量不一樣程序的耗時，先後兩次調用的時間差
time.clock()
Python的標準庫
派派社區：https://pypi.python.org/pypi
1. 查看Python中的模塊
help('modeles')
- 執行環境
1. 模塊帶入到其餘文件中，也能夠導入到其餘模塊---模塊的調用---鏈式調用
模塊能夠用其餘語言寫---Java/c
2. 模塊能夠包含：
類，全局變量，函數
1其餘內容儘可能不要書寫---（while,for,if else,input,if...）,寫到函數中
緣由：模塊再被導入時會自動執行一次
3. 模塊的文件類型：
py pyc pyo
py:源文件
pyc：字節碼文件---經過pvm
pyo：優化編譯後的程序---硬件
文件
- 打開文件
open()函數
Python open() 方法用於打開一個文件，並返回文件對象，在對文件進行處理過程都須要使用到這個函數，若是該文件沒法被打開，會拋出 OSError。 注意：使用 open() 方法必定要保證關閉文件對象，即調用 close() 方法。 open() 函數經常使用形式是接收兩個參數：文件名(file)和模式(mode)。
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) 參數說明: 1. file: 必需，文件路徑（相對或者絕對路徑）。 2. mode: 可選，文件打開模式 3. buffering: 設置緩衝;---0:關閉緩衝區/1：打開緩衝區/大於1設置緩衝區大小爲該值/負數：緩衝區交由系統管理 4. encoding: 通常使用utf8 5. errors: 報錯級別 6. newline: 區分換行符 7. closefd: 傳入的file參數類型 8. opener:
mode 參數有：
| 模式 | 描述 |
|---|---|
| t | 文本模式 (默認)。 |
| x | 寫模式，新建一個文件，若是該文件已存在則會報錯。 |
| b | 二進制模式。 |
| + | 打開一個文件進行更新(可讀可寫)。 |
| U | 通用換行模式（不推薦）。 |
| r | 以只讀方式打開文件。文件的指針將會放在文件的開頭。這是默認模式。 |
| rb | 以二進制格式打開一個文件用於只讀。文件指針將會放在文件的開頭。這是默認模式。通常用於非文本文件如圖片等。 |
| r+ | 打開一個文件用於讀寫。文件指針將會放在文件的開頭。 |
| rb+ | 以二進制格式打開一個文件用於讀寫。文件指針將會放在文件的開頭。通常用於非文本文件如圖片等。 |
| w | 打開一個文件只用於寫入。若是該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。若是該文件不存在，建立新文件。 |
| wb | 以二進制格式打開一個文件只用於寫入。若是該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。若是該文件不存在，建立新文件。通常用於非文本文件如圖片等。 |
| w+ | 打開一個文件用於讀寫。若是該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。若是該文件不存在，建立新文件。 |
| wb+ | 以二進制格式打開一個文件用於讀寫。若是該文件已存在則打開文件，並從開頭開始編輯，即原有內容會被刪除。若是該文件不存在，建立新文件。通常用於非文本文件如圖片等。 |
| a | 打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容以後。若是該文件不存在，建立新文件進行寫入。 |
| ab | 以二進制格式打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。也就是說，新的內容將會被寫入到已有內容以後。若是該文件不存在，建立新文件進行寫入。 |
| a+ | 打開一個文件用於讀寫。若是該文件已存在，文件指針將會放在文件的結尾。文件打開時會是追加模式。若是該文件不存在，建立新文件用於讀寫。 |
| ab+ | 以二進制格式打開一個文件用於追加。若是該文件已存在，文件指針將會放在文件的結尾。若是該文件不存在，建立新文件用於讀寫。 |
默認爲文本模式，若是要以二進制模式打開，加上 b 。
file 對象
file 對象使用 open 函數來建立
- file對象扽屬性
1. closed 2. mode 3. name 4. softspace
- file對象的方法
| 序號 | 方法及描述 |
|---|---|
| 1 | file.close()關閉文件。關閉後文件不能再進行讀寫操做。 |
| 2 | file.flush()刷新文件內部緩衝，直接把內部緩衝區的數據馬上寫入文件, 而不是被動的等待輸出緩衝區寫入。 |
| 3 | file.fileno()返回一個整型的文件描述符(file descriptor FD 整型), 能夠用在如os模塊的read方法等一些底層操做上。 |
| 4 | file.isatty()若是文件鏈接到一個終端設備返回 True，不然返回 False。 |
| 5 | file.next()返回文件下一行。 |
| 6 | [file.read(size])從文件讀取指定的字節數，若是未給定或爲負則讀取全部。 |
| 7 | [file.readline(size])讀取整行，包括 "\n" 字符。 |
| 8 | [file.readlines(sizeint])讀取全部行並返回列表，若給定sizeint>0，返回總和大約爲sizeint字節的行, 實際讀取值可能比 sizeint 較大, 由於須要填充緩衝區。 |
| 9 | [file.seek(offset, whence])設置文件當前位置 |
| 10 | file.tell()返回文件當前位置。 |
| 11 | [file.truncate(size])從文件的首行首字符開始截斷，截斷文件爲 size 個字符，無 size 表示從當前位置截斷；截斷以後後面的全部字符被刪除，其中 Widnows 系統下的換行表明2個字符大小。 |
| 12 | file.write(str)將字符串寫入文件，返回的是寫入的字符長度。 |
| 13 | file.writelines(sequence)向文件寫入一個序列字符串列表，若是須要換行則要本身加入每行的換行符。 |
錯誤和異常
異常處理--捕獲異常
while True:
try:
x = int(input("Please enter a number: "))
break
except ValueError:
print("Oops! That was no valid number. Try again ")
try語句按照以下方式工做；
- 首先，執行try子句（在關鍵字try和關鍵字except之間的語句）
- 若是沒有異常發生，忽略except子句，try子句執行後結束。
- 若是在執行try子句的過程當中發生了異常，那麼try子句餘下的部分將被忽略。若是異常的類型和 except 以後的名稱相符，那麼對應的except子句將被執行。最後執行 try 語句以後的代碼。
- 若是一個異常沒有與任何的except匹配，那麼這個異常將會傳遞給上層的try中。
一個 try 語句可能包含多個except子句，分別來處理不一樣的特定的異常。最多隻有一個分支會被執行。
處理程序將只針對對應的try子句中的異常進行處理，而不是其餘的 try 的處理程序中的異常。
一個except子句能夠同時處理多個異常，這些異常將被放在一個括號裏成爲一個元組，例如:
except (RuntimeError, TypeError, NameError): pass
最後一個except子句能夠忽略異常的名稱，它將被看成通配符使用。你可使用這種方法打印一個錯誤信息，而後再次把異常拋出。
import sys
try:
f = open('myfile.txt')
s = f.readline()
i = int(s.strip())
except OSError as err:
print("OS error: {0}".format(err))
except ValueError:
print("Could not convert data to an integer.")
except:
print("Unexpected error:", sys.exc_info()[0])
raise
try except 語句還有一個可選的else子句，若是使用這個子句，那麼必須放在全部的except子句以後。這個子句將在try子句沒有發生任何異常的時候執行。例如:
for arg in sys.argv[1:]:
try:
f = open(arg, 'r')
except IOError:
print('cannot open', arg)
else:
print(arg, 'has', len(f.readlines()), 'lines')
f.close()
使用 else 子句比把全部的語句都放在 try 子句裏面要好，這樣能夠避免一些意想不到的、而except又沒有捕獲的異常。
異常處理並不只僅處理那些直接發生在try子句中的異常，並且還能處理子句中調用的函數（甚至間接調用的函數）裏拋出的異常。例如:
>>>def this_fails():
x = 1/0
>>> try:
this_fails()
except ZeroDivisionError as err:
print('Handling run-time error:', err)
Handling run-time error: int division or modulo by zero
異常處理--拋出異常
Python 使用 raise 語句拋出一個指定的異常，raise 惟一的一個參數指定了要被拋出的異常。它必須是一個異常的實例或者是異常的類（也就是 Exception 的子類）。若是你只想知道這是否拋出了一個異常，並不想去處理它，那麼一個簡單的 raise 語句就能夠再次把它拋出。
>>>try:
raise NameError('HiThere')
except NameError:
print('An exception flew by!')
raise
An exception flew by!
Traceback (most recent call last):
File "<stdin>", line 2, in ?
NameError: HiThere
- 自定義異常
能夠經過建立一個新的異常類來擁有本身的異常。異常類繼承自 Exception 類，能夠直接繼承，或者間接繼承，例如:
>>>class MyError(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
>>> try:
raise MyError(2*2)
except MyError as e:
print('My exception occurred, value:', e.value)
My exception occurred, value: 4
>>> raise MyError('oops!')
Traceback (most recent call last):
File "<stdin>", line 1, in ?
__main__.MyError: 'oops!'
'''
在這個例子中，類 Exception 默認的 __init__() 被覆蓋。
當建立一個模塊有可能拋出多種不一樣的異常時，一種一般的作法是爲這個包創建一個基礎異常類，而後基於這個基礎類爲不一樣的錯誤狀況建立不一樣的子類:
'''
定義清理行爲
try:
result = x / y
except ZeroDivisionError:
print("division by zero!")
else:
print("result is", result)
finally: #不管如何都要執行的代碼塊
print("executing finally clause")
若是一個異常在 try 子句裏（或者在 except 和 else 子句裏）被拋出，而又沒有任何的 except 把它截住，那麼這個異常會在 finally 子句執行後再次被拋出。
>>>def divide(x, y):
try:
result = x / y
except ZeroDivisionError:
print("division by zero!")
else:
print("result is", result)
finally:
print("executing finally clause")
預約義的清理行爲
一些對象定義了標準的清理行爲，不管系統是否成功的使用了它，一旦不須要它了，那麼這個標準的清理行爲就會執行。
這面這個例子展現了嘗試打開一個文件，而後把內容打印到屏幕上:
for line in open("myfile.txt"):
print(line, end="")
以上這段代碼的問題是，當執行完畢後，文件會保持打開狀態，並無被關閉。
關鍵詞 with 語句就能夠保證諸如文件之類的對象在使用完以後必定會正確的執行他的清理方法:
with open("myfile.txt") as f:
for line in f:
print(line, end="")
以上這段代碼執行完畢後，就算在處理過程當中出問題了，文件 f 老是會關閉。
多線程
- 進程
1. 計算機的核心是CPU，承擔計算任務 2. 操做系統是計算機的管理者，負責任務的調度、資源的分配和管理以及整個計算機硬件。 3. 應用程序是具備某種功能的程序，程序試運行在操做系統中的。 4. 進程是一個具備獨立功能的程序，在一個數據集合上的一個獨立的單位，是應用程序運行的載體。 5. 進程是一種模糊的概念，沒有標準的定義 進程包括： 程序：程序用於描述進程要完成的功能，是控制進程執行的指令集。 數據集合：程序在執行時所須要的數據和工做區。 進程的控制塊：包含進程的描述信息和控制信息，是進程的惟一標識。 進程的特色 1. 動態性：動態產生動態消亡。 2. 併發性：宏觀並行微觀串行。 3. 獨立性：進程與進程之間互不影響。 4. 結構性：進程=程序+數據集合+進程控制塊
- 線程
1. 線程也是一種抽象的概念，是輕量級的進程 2. 進程中能夠包含線程 線程包括： 線程ID 指令指針 寄存器 堆棧 線程的特色： 1. 線程是程序執行的最小單位，是CPU調度和分配的最小單位。---內存空間 2. 進程是操做系統分配資源的最小單位。---時間片 3. 一個進程有多個線程組成，線程是進程的不一樣執行路線 4. 進程和進程之間是相互獨立的，可是一個進程下的多個線程之間共享進程的空間以及進程的一些資源。 5. 不一樣進程間的線程獨立不可見。 6. 線程的調度和切換要比進程的調度和切換快的多。
- 單線程和多線程
1. 單線程：一個進程只有一個線程，程序全部的資源供一個線程使用。 2. 多線程：在一個進程中有多個線程，多個線程之間併發（宏觀並行微觀串行）執行，相互搶佔資源。
- Python的多線程模塊threading
1. Thread類：
threading.Thread(self,group=None,target=None,name=None,args=(),kwargs={})
Thread是threading模塊中最重要的類，能夠建立線程
參數說明：
group：預留的參數用於擴展
target：可調用的對象（函數對象）
name：線程的名字，線程默認的名字：Thread-N;好比第一個線程Thread-1;第二個線程Thread-2
args/kwargs：分別表示target的參數和關鍵字參數
建立線程的的方式
繼承Thread類,覆蓋run()方法
#自定義類繼承Thread
import threading
#建立線程任務類--繼承Thread
class MyThread1(threading.Thread):
def __init__(self,names,count):
super().__init__()
self.names=names
self.count=count
#覆蓋run()方法
def run(self):
for i in range(self.count):
print('****************%s******************' % (self.names))
class MyThread2(threading.Thread):
def __init__(self, names, count):
super().__init__()
self.names = names
self.count = count
# 覆蓋run()方法
def run(self):
for i in range(self.count):
print('================%s=================='%(self.names))
if __name__ == '__main__':
#建立線程對象
t1=MyThread1('A',100)
t2=MyThread2('B',100)
#啓動線程
t1.start()
t2.start()
threading.Thread()
#threading.Thread()的方式建立線程
import threading
#建立線程任務
def task1(names,count):
for i in range(count):
print('****************%s******************'%(names))
def task2(names,coun):
for i in range(coun):
print('================%s=================='%(names))
if __name__ == '__main__':
#建立線程對象
t1= threading.Thread(target=task1,args=('A',100)) #給threading下的Thread類傳遞構造參數
t2= threading.Thread(target=task2,args=('B',100)) #給threading下的Thread類傳遞構造參數
# 開啓線程
t1.start()
t2.start()
- threading.Thread類的其餘方法
1. getName():獲取線程的名字 2. setName():設置線程的名字 3. ident:獲取線程標識符 應該放在啓動以後---通常是一個非零的整數 若是放在啓動以前---None 4. is_alive():判斷線程是不是激活狀態 5. join([timeout]): 調用Thread.join()線程會阻塞---當前線程（主線程），直到被join（）的線程執行完畢 timeout：設置超時時間 若是發生了當前線程阻塞，等等timeout秒，若是時間到，則不在阻塞 6. setDaemon():線程守護--守護線程--精靈線程
線程的狀態
和Java同樣 分爲五個狀態，初始狀態、就緒狀態、運行狀態、死亡狀態、阻塞狀態
GIL全局鎖
線程同步
import threading,time
lock=threading.Lock() #定義鎖
class MyList:
def __init__(self):
self.l=['A','B','','','','']
self.index=2
def addList(self,value):
lock.acquire() #添加鎖標記
self.l[self.index]=value
time.sleep(0.0001)
self.index+=1
lock.release() #釋放鎖標記
def getList(self):
return self.l
def addTask(myList,value):
myList.addList(value)
if __name__=='__main__':
m=MyList()
#m.addList('C')
#m.addList('D')
t1=threading.Thread(target=addTask,args=(m,'C'))
t2=threading.Thread(target=addTask,args=(m,'D'))
t1.start()
t2.start()
t1.join()
t2.join()
print(m.getList())
- 死鎖
1. 死鎖：一個線程中有且只有一次機會使用acquire()給線程加鎖，若是出現多個，則線程進入到死鎖狀態，沒法使用 2. 解決方案：只是用一次鎖；或者使用RLock類得到鎖對象，該鎖可被屢次調用。
Python的風格
PEP8
Python的語句和語法
- 註釋
#:能夠從任意一行開始註釋，主要用於python的文檔
- 續行
\:單一語句跨行 ''':閉合操做符，單一語句跨多行，用於內置文檔，實現多行註釋，能夠用於字符串進行使用
- 代碼塊（代碼組）
1. 縮進相同的一組語句構成一個代碼塊 2. 代碼塊中能夠嵌套其餘代碼塊 3. python使用縮進來進行分割---同一個代碼塊中的代碼必須嚴格的進行左對齊。
- 同一行書寫多個語句
;:使用分號隔開，例如：print(100);print(200);print(300);print(400); 強烈建議不這樣書寫
- 模塊
1. 每一個python腳本文件均可以看成一個模塊（模塊名--腳本名--文件名） 2. 模塊裏的代碼能夠是一段直接執行的腳本，也能夠是一些相似庫函數的代碼從而能夠有別的模塊執行導入 import 3. 模塊在被導入時會執行一次，模塊中儘可能只包含類、函數、全局變量，直接執行的代碼儘可能避免 import在導入模塊時，會自動編譯--生成模塊對象，方便其餘的模塊調用
相關文章
- 1. Scss的基本語法及使用
- 2. [2] CSS＆javascript(基本語法及使用)
- 3. Scala基本語法及使用
- 4. sass的基本語法及使用
- 5. jade安裝及基本語法使用
- 6. Shell 使用 - 變量及基本語法
- 7. JS——基本語法及其使用
- 8. python 基本語法
- 9. Python基本語法
- 10. python基本語法
- 更多相關文章...
- • Lua 基本語法 - Lua 教程
- • C# 基本語法 - C#教程
- • Kotlin學習（一）基本語法
- • Kotlin學習（二）基本類型
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 升級Gradle後報錯Gradle‘s dependency cache may be corrupt (this sometimes occurs
- 2. Smarter, Not Harder
- 3. mac-2019-react-native 本地環境搭建(xcode-11.1和android studio3.5.2中Genymotion2.12.1 和VirtualBox-5.2.34 )
- 4. 查看文件中關鍵字前後幾行的內容
- 5. XXE萌新進階全攻略
- 6. Installation failed due to: ‘Connection refused: connect‘安卓studio端口占用
- 7. zabbix5.0通過agent監控winserve12
- 8. IT行業UI前景、潛力如何？
- 9. Mac Swig 3.0.12 安裝
- 10. Windows上FreeRDP-WebConnect是一個開源HTML5代理，它提供對使用RDP的任何Windows服務器和工作站的Web訪問
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Scss的基本語法及使用
- 2. [2] CSS＆javascript(基本語法及使用)
- 3. Scala基本語法及使用
- 4. sass的基本語法及使用
- 5. jade安裝及基本語法使用
- 6. Shell 使用 - 變量及基本語法
- 7. JS——基本語法及其使用
- 8. python 基本語法
- 9. Python基本語法
- 10. python基本語法