相關(guān)網(wǎng)站

• Python官方文檔：https://docs.python.org/3/
• iPython（網(wǎng)頁(yè)編程）：http://ipython.org/
• jupyter notebook（網(wǎng)頁(yè)編程）：https://jupyter-notebook.readthedocs.io/en/latest/
• PyCharm：https://www.jetbrains.com/pycharm/
• pip：http://pip.pypa.io/en/stable/installing/
• pep8規(guī)范：https://www.python.org/dev/peps/pep-0008/

安裝

mac：

下載相應(yīng)系統(tǒng)的安裝包安裝即可（下載地址：https://www.python.org/downloads/）
檢驗(yàn)安裝成功與否：

$ python3

Linux：

下載源碼壓縮包：https://www.python.org/downloads/source/

tar -zxvf Python-3.6.1.tgz
cd Python-3.6.1
./configure
make && make install
# 檢查 Python3 是否正橙咚可用
python3 -V

其他環(huán)境見(jiàn)https://www.runoob.com/python3/python3-install.html

獲取幫助文檔：

$ python3
$ help(filter)

安裝autopep8

1. 安裝：$ pip3 install autopep8
2. 進(jìn)入pycharm菜單Preference - Tools - External Tools
3. 點(diǎn)擊+按鈕
4. 填寫(xiě)

• Name: autopep8
• Program: /Library/Frameworks/Python.framework/Versions/3.8/bin/autopep8
• Arguments: --in-place --aggressive --aggressive $FilePath$
• Working directory: $ProjectFileDir$
• Output filters: $FILE_PATH$\:$LINECOLUMN$:.*

基本數(shù)據(jù)類型

• Number（數(shù)字）
• String（字符串）
• List（列表）
• Tuple（元組）
• Set（集合）
• Dictionary（字典）

不可變數(shù)據(jù)：Number（數(shù)字）、String（字符串）考廉、Tuple（元組）
可變數(shù)據(jù)：List（列表）番官、Dictionary（字典）荒适、Set（集合）

多變量賦值：

a = b = c = 1
a, b, c = 1, 1.1, 'abc'

一個(gè)變量可以通過(guò)賦值指向不同類型的對(duì)象

判斷數(shù)據(jù)類型：

type('123')  # <class 'str'>
isinstance(123, int) # True

isinstance 和 type 的區(qū)別在于：
type()不會(huì)認(rèn)為子類是一種父類類型离熏；
isinstance()會(huì)認(rèn)為子類是一種父類類型荚板。

Number（數(shù)字）

• 支持 int杰扫、float队寇、complex（復(fù)數(shù)）等數(shù)值類型
• 整型是沒(méi)有限制大小的，可以當(dāng)作 Long 類型使用
• 浮點(diǎn)型可以使用科學(xué)計(jì)數(shù)法表示：2.5e2 = 2.5 x 10^2 = 250
• 復(fù)數(shù)由實(shí)數(shù)部分和虛數(shù)部分構(gòu)成章姓，可以用a + bj,或者complex(a,b)表示英上， 復(fù)數(shù)的實(shí)部a和虛部b都是浮點(diǎn)型
• 數(shù)據(jù)類型不允許改變，如改變數(shù)字?jǐn)?shù)據(jù)類型的值啤覆，將重新分配內(nèi)存空間
• 在混合計(jì)算時(shí)苍日，將把整型轉(zhuǎn)換成為浮點(diǎn)數(shù)
• 數(shù)值的除法包含兩個(gè)運(yùn)算符：/ 返回一個(gè)浮點(diǎn)數(shù)，// 返回一個(gè)整數(shù)

數(shù)值運(yùn)算：

5 + 4  # 9
4.3 - 2 # 2.3
3 * 7  # 21
2 / 4  # 0.5窗声，得到一個(gè)浮點(diǎn)數(shù)
2 // 4 # 0相恃，得到一個(gè)整數(shù)
17 % 3 # 2，取余 
2 ** 5 # 32笨觅，乘方

數(shù)值類型轉(zhuǎn)換：

x, y, z, k = 1, 2.5, 0xA0F, 0o37
int(y) # 2
float(x) # 1.0
complex(x) # (1+0j)
complex(x, y) # (1+2.5j)
z # 十六進(jìn)制拦耐，等于2575
k # 八進(jìn)制耕腾，等于31

String（字符串）

• 字符串用單引號(hào) ' 或雙引號(hào) " 括起來(lái)
• 使用三引號(hào)('''或""")可以指定一個(gè)多行字符串
• 不支持單字符類型，單字符是作為一個(gè)字符串使用
• 反斜杠可以用來(lái)轉(zhuǎn)義杀糯，使用r可以讓反斜杠不發(fā)生轉(zhuǎn)義
• 字符串有兩種索引方式扫俺，從左往右以0開(kāi)始，從右往左以-1開(kāi)始
• 字符串不能被改變固翰。向一個(gè)索引位置賦值狼纬，比如word[0] = 'm'會(huì)導(dǎo)致錯(cuò)誤

字符串的截取：

str = 'abcd'
str[0] # a
str[1:3] # bc
str[0:-1] # abc
str[1:] # bcd

字符串其他操作：

str = 'abc'
str[a * 3] # abcabcabc骂际，重復(fù)
str + 'def' # abcdef疗琉，連接
print('abc\ndef')
# abc
# def，\ 轉(zhuǎn)義特殊字符

print(r'abc\ndef') # abc\ndef歉铝，字符串前面添加一個(gè) r盈简，表示原始字符串

# 字符串格式化
print ("我叫 %s 今年 %d 歲!" % ('小陳', 28)) # 我叫 小陳 今年 28 歲!

# f-string
name = 'chan'
f'hello {name}' # hello chan
f'{1+2}' # '3'
rect = {'w': 100, 'h': 150}
f'寬度：{rect["w"]}, 高度：{rect["h"]}' # 寬度：100, 高度：150

# 字符串更新
str = 'hello world'
str[:6] + 'chan' # hello chan

List（列表）

• 和字符串一樣，可以被索引和切片
• List可以使用+操作符進(jìn)行拼接
• List中的元素是可以改變的
• 列表截取的語(yǔ)法：變量[頭下標(biāo):尾下標(biāo)]

基本操作：

list = [1, 2, 3, 'a', 'b', 'c', 1.1, True]
list2 = [0, 9, 8]

list[1] # 2
list[1:4] # [2, 3, 'a']
list[2:] # [3, 'a', 'b', 'c', 1.1, True]
list * 2 # [1, 2, 3, 'a', 'b', 'c', 1.1, True, 1, 2, 3, 'a', 'b', 'c', 1.1, True]
list + list2 # [1, 2, 3, 'a', 'b', 'c', 1.1, True, 0, 9, 8]

len(list) # 8太示，獲取長(zhǎng)度
del list[2] # 刪除第三個(gè)元素
3 in list # True柠贤，元素是否存在于列表中
for x in list: print(x) # 迭代輸出
list(tuple) # 將元組轉(zhuǎn)換為列表

list.append('z') # [1, 2, 3, 'a', 'b', 'c', 1.1, True, 'z']，在列表末尾添加新的對(duì)象
list.count(2) # 1类缤，統(tǒng)計(jì)某個(gè)元素在列表中出現(xiàn)的次數(shù)
list.extend([5, 6, 7]) # [1, 2, 3, 'a', 'b', 'c', 1.1, True, 'z', 5, 6, 7]种吸，在列表末尾一次性追加另一個(gè)序列中的多個(gè)值
list.index('a') # 3，從列表中找出某個(gè)值第一個(gè)匹配項(xiàng)的索引位置
list.insert(6, 'd') # [1, 2, 3, 'a', 'b', 'c', 'd', 1.1, True, 'z', 5, 6, 7]呀非，將對(duì)象插入列表
list.pop() # [1, 2, 3, 'a', 'b', 'c', 'd', 1.1, True, 'z', 5, 6]坚俗，移除列表中的一個(gè)元素（默認(rèn)最后一個(gè)元素），并且返回該元素的值
list.remove(1.1) # [1, 2, 3, 'a', 'b', 'c', 'd', True, 'z', 5, 6]岸裙，移除列表中某個(gè)值的第一個(gè)匹配項(xiàng)
list.reverse() # [6, 5, 'z', True, 'd', 'c', 'b', 'a', 3, 2, 1]猖败，反向列表中元素
list.sort() # 排序
list2 = list.copy() # 復(fù)制列表
list.clear() # []，清空列表

# 遍歷獲取列表索引
for i, v in enumerate(list):
    print('第', i, '行的值是', v)

# 同時(shí)遍歷兩個(gè)數(shù)組
people = ['Lily', 'Lucy', 'Sam']
age = [18, 20, 22]
for p, a in zip(people, age):
    print('{0} 的年齡是 {1}'.format(p, a))
# Lily 的年齡是 18
# Lucy 的年齡是 20
# Sam 的年齡是 22

列表推導(dǎo)式：

list = [1, 3, 6]
list2 = [x * x for x in list]
print(list2) 
# [1, 9, 36]
list3 = [[x, x % 2] for x in list]
print(list3) 
# [[1, 1], [3, 1], [6, 0]]
list4 = ['chi', '   chi ', 'chi   ']
list5 = [x.strip() for x in list4]
print(list5) 
# ['chi', 'chi', 'chi']
list6 = [x for x in list if x > 2]
print(list6) 
#  [3, 6]
matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12]
]
matrix2 = [[row[i] for row in matrix] for i in range(4)]
print(matrix2)
# [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
# 3X4的矩陣列表轉(zhuǎn)換為4X3列表

Tuple（元組）

• 與列表類似降允，不同之處在于元組的元素不能修改
• 元組寫(xiě)在小括號(hào) () 里恩闻，元素之間用逗號(hào)隔開(kāi)
• 只包含一個(gè)元素時(shí)，需要在元素后面添加逗號(hào)剧董，否則括號(hào)會(huì)被當(dāng)作運(yùn)算符使用
• 元組中的元素值是不允許刪除的幢尚，但我們可以使用del語(yǔ)句來(lái)刪除整個(gè)元組

基本操作：

tuple = (1, 2, 3, 'a', 'b', 'c')
tuple2 = 4, 5, 6, 'd', 'e', 'f' # 不用括號(hào)也可以
tuple3 = (10)
tuple4 = (10,)
type(tuple2) # <class 'tuple'>
type((tuple3) # <class 'int'>
type((tuple4) # <class 'tuple'>
len(tuple) # 6
tuple4 * 5 # (10, 10, 10, 10, 10)
for x in tuple: print(x) # 迭代輸出
tuple(list) # 將列表轉(zhuǎn)為元組
del tuple # 刪除

Dict 字典

• 字典是一種可變?nèi)萜髂Ｐ停铱纱鎯?chǔ)任意類型對(duì)象
• 格式：d = {key1 : value1, key2 : value2 }
• 鍵必須是唯一且不可變翅楼，可以用數(shù)字尉剩，字符串或元組，列表不行
• 如果同一個(gè)鍵被賦值兩次毅臊，以后一個(gè)為準(zhǔn)
• 值可以取任何數(shù)據(jù)類型

基本操作：

dict = {
    'name': 'cyc',
    'age': 28
}
dict2 = { 'cyc': 'good' }

dict['name'] # cyc
dict['age'] # 28
dict['sex'] = 'male' # {'name': 'cyc', 'age': 28, 'sex': 'male'}
del dict['sex'] # 刪除元素理茎，{'name': 'cyc', 'age': 28}
dict[3] = 'c' # 鍵可以是數(shù)字

dict.get('age') # 28
len(dict) # 3，獲取元素個(gè)數(shù)
str(dict) # 轉(zhuǎn)字符串，{'name': 'cyc', 'age': 28, 3: 'c'}
'name' in dict # True皂林，是否有該鍵

list(dict.keys()) # ['name', 'age', 3]
list(dict.values()) # ['cyc', 28, 'c']
list(dict.items()) # [('name', 'cyc'), ('age', 28), (3, 'c')]

dict.copy() # 淺復(fù)制
dict.update(dict2) # {'name': 'cyc', 'age': 28, 3: 'c', 'cyc': 'good'}朗鸠，把字典dict2的鍵/值對(duì)更新到dict里
dict.pop('name') # cyc，刪除字典給定鍵 key 所對(duì)應(yīng)的值础倍，返回值為被刪除的值
dict.popitem() # ('cyc', 'good')烛占，返回并刪除字典中的最后一對(duì)鍵和值

dict.clear() # 清空字典
del(dict) # 刪除字典

dict2 = dict2.fromkeys(('Tom', 'Ben', 'Sam'), 10) 
# {'Tom': 10, 'Ben': 10, 'Sam': 10}
# 創(chuàng)建一個(gè)新字典，以序列seq中元素做字典的鍵沟启，val為字典所有鍵對(duì)應(yīng)的初始值

# 元組列表轉(zhuǎn)字典
dict = dict([('Lucy', 18), ('Lily', 20), ('Ben', 22)])
print(dict) # {'Lucy': 18, 'Lily': 20, 'Ben': 22}
# 遍歷技巧
for k, v in dict.items():
    print(k, "is ", v, ' age years old')
# Lucy is  18  age years old
# Lily is  20  age years old
# Ben is  22  age years old

字典推導(dǎo)式：

square = {x : x * x for x in (2, 4, 6)}
print(square) # {2: 4, 4: 16, 6: 36}

Set 集合

• 是一個(gè)無(wú)序的不重復(fù)元素序列
• 使用大括號(hào) { } 或者 set() 函數(shù)創(chuàng)建集合
• 創(chuàng)建一個(gè)空集合必須用 set() 而不是 { }

基本操作

fruit = {'apple', 'banana', 'lemon', 'orange'}
print('apple' in fruit) # True忆家，判斷是否存在與集合中

set1 = set('abcdefg') # {'f', 'd', 'c', 'a', 'b', 'e', 'g'}
set2 = set('efgh') # {'h', 'e', 'g', 'f'}
set1 - set2 # {'a', 'b', 'd', 'c'}，集合set1中包含而集合set2中不包含的元素
set1 | set2 # {'f', 'h', 'd', 'b', 'a', 'c', 'e', 'g'}美浦，集合set1或set2中包含的所有元素
set1 & set2 # {'e', 'g', 'f'}弦赖，集合set1和set2中都包含了的元素
set1 ^ set2 # {'h', 'd', 'c', 'a', 'b'}项栏，不同時(shí)包含于set1和set2的元素
set2.add('ij') # {'f', 'h', 'e', 'g', 'ij'}浦辨，添加元素

set3 = set(('Tom', 'Ben', 'Sam')) # {'Ben', 'Tom', 'Sam'}
set3.update({'Lily', 'Lucy'}) # {'Tom', 'Sam', 'Ben', 'Lily', 'Lucy'}，添加元素
set3.update(['Kaka', 'Fango'], ['Trump', 'Bush']) # {'Fango', 'Bush', 'Kaka', 'Sam', 'Ben', 'Lily', 'Lucy', 'Tom', 'Trump'}沼沈，添加元素
len(set3) # 9流酬，獲取集合元素個(gè)數(shù)
set3.remove('Trump') # 刪除元素，元素不存在會(huì)報(bào)錯(cuò)
set3.discard('Bush') # 刪除元素列另，元素不存在也不會(huì)報(bào)錯(cuò)
print(set3.pop()) # 隨機(jī)刪除一個(gè)元素芽腾，并返回該元素
set3.clear() # set()，情況集合

集合推導(dǎo)式：

set1 = {x for x in 'chenyuchi' if x not in 'chen'}
print(set1) # {'u', 'i', 'y'}

條件控制

• 每個(gè)條件后面要使用冒號(hào) :页衙，表示接下來(lái)是滿足條件后要執(zhí)行的語(yǔ)句塊
• 使用縮進(jìn)來(lái)劃分語(yǔ)句塊摊滔，相同縮進(jìn)數(shù)的語(yǔ)句在一起組成一個(gè)語(yǔ)句塊
• Python中沒(méi)有switch – case語(yǔ)句

if 1 == 1:
    print(True)
print(False)

# if 1 == 2 and 1 != 2:
# if 1 == 2 or 1 != 2:
# if not 1 == 2:
# if 1 in [1, 2, 3]:
# if 1 not in [1, 2, 3]

a = 0
while a < 10:
    if a % 2 == 0:
        print(a, '是偶數(shù)')
    else:
        print(a, '是奇數(shù)')
    a += 1

age = int(input("你幾歲？: "))
if age < 28:
    print("你比我械昀帧艰躺！")
elif age == 28:
    print("跟我一樣！")
elif age > 28:
    print("你比我大")

# 退出提示
input("點(diǎn)擊 enter 鍵退出")

循環(huán)語(yǔ)句

• Python 中有while和for等循環(huán)語(yǔ)句眨八，沒(méi)有 do..while 循環(huán)

# 計(jì)算從 0 加到 100 之和
i, sum = 0, 0
while i < 100:
    i += 1
    sum += i
print(sum) # 5050

# while...else語(yǔ)句
x = 0
while x < 10:
    print('%d小于10' % x)
    x += 1
else:
    print('%d大于10' % x)

# 循環(huán)遍歷列表
people = ['Ben', 'Lucy', 'Lily', 'Sam']
for x in people:
    print(x)
# break語(yǔ)句
for y in people:
    print(y)
    if 'L' in y:
        print('名字有L腺兴，break')
        break
# continue語(yǔ)句
for y in people:
    if 'L' in y:
        print('名字有L，不輸出')
        continue
    print(y)

# range函數(shù)廉侧，會(huì)生成數(shù)列
for i in range(5):
    print(i, end()) # 0,1,2,3,4

for i in range(5, 9):
    print(i) # 5,6,7,8

for i in range(0, 10, 3):
    print(i) # 0,3,6,9

for i in range(len(people)):
    print(i, people[i]) # 0 Ben,1 Lucy,2 Lily,3 Sam

list = list(range(5)) # [0, 1, 2, 3, 4]

# pass是空語(yǔ)句页响，是為了保持程序結(jié)構(gòu)的完整性。
# pass不做任何事情段誊，一般用做占位語(yǔ)句
for letter in 'chenyuchi':
    if letter == 'y':
        pass
        print('執(zhí)行 pass 塊')
    print('當(dāng)前字母 :', letter)

函數(shù)

• 不帶表達(dá)式的return相當(dāng)于返回 None

# 簡(jiǎn)單示例
def area(width, height):
    return width * height
w = 4
h = 5
print('寬為', w, '闰蚕，高為', h, '的長(zhǎng)方形，面積是 ', area(w, h))
# 寬為 4 连舍，高為 5 的長(zhǎng)方形陪腌，面積是  20

# 不帶return
def func():
  a = 0
print(func()) # None，不帶表達(dá)式的return相當(dāng)于返回 None

# 參數(shù)為不可變類型
# 如 整數(shù)、字符串诗鸭、元組染簇，傳遞的只是x的值，沒(méi)有影響x對(duì)象本身强岸，只是修改另一個(gè)復(fù)制的對(duì)象
def setVal(x):
    x += 1
    print(x) # 1
x = 0
setVal(x)
print(x) # 0

# 參數(shù)為可變類型
# 如 列表锻弓，字典，函數(shù)內(nèi)修改后外部的變量也會(huì)受影響
def setList(list):
    list.append(['a', 'b', 'c'])
    print(list) # [1, 2, 3, ['a', 'b', 'c']]
list = [1, 2, 3]
setList(list)
print(list) # [1, 2, 3, ['a', 'b', 'c']]

參數(shù)：

• 必需參數(shù)：須以正確的順序傳入函數(shù)蝌箍。調(diào)用時(shí)的數(shù)量必須和聲明時(shí)的一樣
• 關(guān)鍵字參數(shù)
• 默認(rèn)參數(shù)
• 不定長(zhǎng)參數(shù)

def func1(str, num): 
  print(str, num)
# str和num為必傳參數(shù)青灼，調(diào)用時(shí)數(shù)量和順序必須和聲明時(shí)的一樣

def func2(str, num, arg = 30):
    print(str, num, arg)
func(num=10, str='abc') # abc 10 30
# str和num為關(guān)鍵字參數(shù)，調(diào)用時(shí)順序可與申明時(shí)不一樣妓盲，arg為默認(rèn)參數(shù)

def func3(arg1, arg2, *others):
    print(arg1, arg2, others)
func2(1, 2, 3, 4, 5) # 1 2 (3, 4, 5)
# 不定長(zhǎng)參數(shù)杂拨，前面用*號(hào)開(kāi)頭，帶*號(hào)參數(shù)會(huì)以元組的形式導(dǎo)入悯衬，存放所有未命名的變量參數(shù)

def func4(arg1, arg2, **others):
    print(arg1, arg2, others)
func3(1, 2, a=3, b=4, c=5) # 1 2 {'a': 3, 'b': 4, 'c': 5}
# 前面用**號(hào)開(kāi)頭的弹沽，會(huì)以字典的形式導(dǎo)入

def func5(a, b, /, c, d, *, e, f):
    print(a, b, c, d, e, f)
# 強(qiáng)制位置參數(shù)
# a 和 b 必須使用指定位置參數(shù)，c 或 d 可以是位置形參或關(guān)鍵字形參筋粗，而 e 或 f 要求為關(guān)鍵字形參
# f(10, 20, 30, d=40, e=50, f=60)策橘，正確
# f(10, b=20, c=30, d=40, e=50, f=60) 錯(cuò)誤，b不能使用關(guān)鍵字參數(shù)的形式
# f(10, 20, 30, 40, 50, f=60)娜亿，錯(cuò)誤丽已，e必須使用關(guān)鍵字參數(shù)的形式

匿名函數(shù)：

使用 lambda 來(lái)創(chuàng)建匿名函數(shù)

• lambda的主體是一個(gè)表達(dá)式，而不是一個(gè)代碼塊
• lambda 函數(shù)擁有自己的命名空間买决，且不能訪問(wèn)自己參數(shù)列表之外或全局命名空間里的參數(shù)
• 語(yǔ)法：lambda [arg1 [,arg2,.....argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2
print(sum(10, 30)) # 40

iter 迭代器：

list = [1, 2, 3]
it = iter(list)
print(next(it)); # 1
print(next(it)); # 2

yield語(yǔ)句：

def frang (start, stop, step):
    x = start
    while x < stop:
        yield x
        x += step

for i in frang(0, 5, 0.5):
    print(i, end=',')
# 0,0.5,1.0,1.5,2.0,2.5,3.0,3.5,4.0,4.5

常用內(nèi)置函數(shù)：

l = [1, 2, 3, 4, 5, 6 , 7, 8, 9, 10]
# filter
l2 = list(filter(lambda x : x > 5, l))
print(l2) # [6, 7, 8, 9, 10]
# map
l3 = list(map(lambda x : x * 10, l))
print(l3) # [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
# reduce
l4 = reduce(lambda x, y : x + y, l, 1)
print(l4) # 56
# zip
t = (1, 2, 3)
t2 = (4, 5, 6)
for i in zip(t, t2):
    print(i)
# (1, 4)
# (2, 5)
# (3, 6)
d = {'a': 'aa', 'b': 'bb'}
d2 = zip(d.values(), d.keys())
print(dict(d2))
# {'aa': 'a', 'bb': 'b'}

閉包：

def counter(start = 0):
    l = [start]
    def addOne() :
        l[0] += 1
        return l[0]
    return addOne
num5 = counter(5)
num10 = counter(10)
print(num5()) # 6
print(num5()) # 7
print(num10()) # 11
print(num10()) # 12
print(num10()) # 13

def line_func(a, b):
    return lambda x : a * x + b
line1 = line_func(3, 5)
line2 = line_func(5, 8)
print(line1(10))
print(line2(10))

裝飾器：

import time

def timer(func):
    def wrapper():
        start_time = time.time()
        func()
        end_time = time.time()
        print('程序運(yùn)行了 %f 秒' % (end_time - start_time))
    return wrapper

@timer
def mySleep():
    time.sleep(3)

mySleep()

def communicate(word):
    def do(func):
        def wrapper(name, something):
            print(word, end=',')
            print(name, end=' ')
            func(name, something)
            print(something)
        return wrapper
    return do

@communicate('hello')
def eat(name, something):
    print('is eating', end=' ')

@communicate('good moring')
def find(name, something):
    print('is finding', end=' ')

eat('Tom', 'apple') # hello,Tom is eating apple
find('Ben', 'a pen') # good moring,Ben is finding a pen

模塊

模塊是一個(gè)包含所有你定義的函數(shù)和變量的文件沛婴，其后綴名是.py。模塊可以被別的程序引入督赤，以使用該模塊中的函數(shù)等功能嘁灯。

import 語(yǔ)句

import module1[, module2[,... moduleN]
# 使用別名
import time as t

from … import 語(yǔ)句

# from modname import name1[, name2[, ... nameN]]
from fibo import fib, fib2
fib(500)

from … import * 語(yǔ)句

把一個(gè)模塊的所有內(nèi)容全都導(dǎo)入到當(dāng)前的命名空間

from modname import *

__name__屬性

if __name__ == '__main__':
   print('程序自身運(yùn)行')
else:
   print('在其他模塊運(yùn)行')

dir() 函數(shù)

內(nèi)置的函數(shù) dir() 可以找到模塊內(nèi)定義的所有名稱

import my_module
my_module.hello('Ben')
print(dir(my_module))
# ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'bye', 'hello', 'morning']

包（package）

• 包是一種管理 Python 模塊命名空間的形式
• 目錄只有包含一個(gè)叫做 init.py 的文件才會(huì)被認(rèn)作是一個(gè)包

import pA.pAA.mA
pA.pAA.mA.afternoon('Tom')
# 必須使用全名去訪問(wèn)

from pA.pAA import mA
mA.afternoon('Tom')

from pA.pAA.mA import afternoon
afternoon('Tom')

File文件

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

• filename：文件名稱的字符串值
• mode：打開(kāi)文件的模式
• buffering: 設(shè)置緩沖
• encoding: 一般使用utf8
• errors: 報(bào)錯(cuò)級(jí)別
• newline: 區(qū)分換行符
• closefd: 傳入的file參數(shù)類型

f = open('file.text', 'w+')
f.read(size) # 讀取一定數(shù)目的數(shù)據(jù)
f.readline() # 讀取整行，包括 "\n" 字符蚊惯，如果返回一個(gè)空字符串, 說(shuō)明已經(jīng)已經(jīng)讀取到最后一行
f.readlines(sizehint,) # 讀取所有行并返回列表愿卸，若給定sizeint>0，返回總和大約為sizeint字節(jié)的行, 實(shí)際讀取值可能比 sizeint 較大, 因?yàn)樾枰畛渚彌_區(qū)
f.write('123') # 寫(xiě)入字符串到文件中, 返回寫(xiě)入的字符數(shù)
f.writelines(sequence) # 向文件寫(xiě)入一個(gè)序列字符串列表截型，如果需要換行則要自己加入每行的換行符
f.tell() # 返回文件對(duì)象當(dāng)前所處的位置, 從文件開(kāi)頭開(kāi)始算起的字節(jié)數(shù)
f.seek(5) # 移動(dòng)到文件的第六個(gè)字節(jié)
f.seek(-3, 2) # 移動(dòng)到文件的倒數(shù)第三字節(jié)
f.flush() # 刷新文件內(nèi)部緩沖趴荸，直接把內(nèi)部緩沖區(qū)的數(shù)據(jù)立刻寫(xiě)入文件, 而不是被動(dòng)的等待輸出緩沖區(qū)寫(xiě)入。
f.close() # 關(guān)閉文件并釋放系統(tǒng)的資源

錯(cuò)誤和異常

try/except 異常處理

try:
  x = int(input("請(qǐng)輸入一個(gè)數(shù)字: "))
except ValueError:
  print("您輸入的不是數(shù)字宦焦，請(qǐng)?jiān)俅螄L試輸入发钝！") 

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS 錯(cuò)誤: {0}".format(err))
except ValueError:
    print("無(wú)法將數(shù)據(jù)轉(zhuǎn)換為整型")
except:
    print("其他錯(cuò)誤:", sys.exc_info()[0])
    raise

try/except...else

else 子句將在 try 子句沒(méi)有發(fā)生任何異常的時(shí)候執(zhí)行

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('打開(kāi)不了', arg)
    else:
        print(arg, '內(nèi)容為：', len(f.readlines()), 'lines')
        f.close()

try-finally

無(wú)論是否發(fā)生異常都將執(zhí)行最后的代碼

拋出異常

raise [Exception [, args [, traceback]]]

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值為: {}'.format(x))

面向?qū)ο?/h1>

聲明類：

class Animal():
    # 構(gòu)造函數(shù)
    def __init__(self, color, food): # self代表類的實(shí)例波闹，而非類
        self.color = color
        self.food = food
    # 類方法
    def move(self):
        print('I can move')
    def getInfo(self):
        print('This animal is %s, eats %s' %(self.color, self.food))

私有變量和私有方法以兩個(gè)下劃線開(kāi)頭

實(shí)例化：

tiger = Animal('yello', 'meat')
tiger.getInfo() # This animal is yello, eats meat

繼承 & 方法重寫(xiě)：

class Cat(Animal):
    def __init__(self, color, food):
        super().__init__(color, food)
    def move(self): # 方法重寫(xiě)
        print('Of couse, I can move!')
    def catch_mouse(self):
        print('I can catch mouse')
cat = Cat('black', 'fish and mouse')
cat.getInfo() # This animal is black, eats fish and mouse
cat.catch_mouse() # I can catch mouse
cat.move() # Of couse, I can move!
super(Cat, cat).move() # I can move , 調(diào)用父類已被覆蓋的方法

# 多繼承：class DerivedClassName(Base1, Base2, Base3):

pip源的設(shè)置和使用

$ cd ~
$ mkdir .pip
$ vi pip.conf

編輯pip.conf文件內(nèi)容：

[global]
timeout=30000
index-url=http://mirrors.aliyun.com/pypi/simple/
[install]
trusted-host=mirrors.aliyun.com

臨時(shí)配置：

$ pip3 -i http://mirrors.aliyun.com/pypi/simple/ install XXX