零基礎學習Python個人筆記

阿新 • • 發佈：2019-01-04

環境搭建

官網下載python直譯器即可
用idea還是編輯器自己定

先從一段程式碼入門，溫度轉換

#tmp.py
tmpStr = input("輸入溫度：");    
if tmpStr[-1] in ['F', 'f']:
    C = (eval(tmpStr[0:-1]) - 32) / 1.8
    print("轉換後為{:.2f}C".format(C))
elif tmpStr[-1] in ['C', 'c']:
    F = 1.8 * eval(tmpStr[0:-1]) + 32
    print("轉換後為{:.2f}F".format(F))
else:
    print("格式錯誤!")

用縮排表達包含關係，即if，else，while等層次關係
#是單行註釋，”’是多行註釋（用三個單引號開頭與結尾）
變數命名規則：大小寫字母、數字、下劃線和漢字，大小寫敏感，首字元不能為數字
保留字的True與False的首字母是大寫，要注意。

資料型別

字串

定義：由一對單引號或者雙引號表示的字元序列。單引號與雙引號沒有區別。

編號，從0開始表示第一個字元。提供兩種體系，正向遞增序號與反向遞減序號。

正向從0到n-1，反向從-1到-n。用<字串>[i]獲取字元，用<字串>[i:j]返回一段字串，這是左閉右開，j位置取不到，如str[0:-1]表示0 ~ n-2

的這麼一段字串。用[M: N: K]根據步長對字串切片。[::-1]相當於將字串逆序。

擴充套件字串

由一對三單引號或者三雙引號表示多的多行字串。（也可當做註釋）

''' python 
            語言 '''

希望在字串中出現單引號，那麼字串就用雙引號括起來；反之，希望出現雙引號，就用單引號括起來。若又想單引號又想雙引號，那麼用三個單引號表示字串。

數字型別

整數：無取值範圍限制。pow(x, y)可計算x^y,想算多大算多大，不像C++。

浮點數：浮點數取值範圍和小數精度都存在限制，常規計算可忽略。運算存在不確定尾數。多以浮點數比較用round(x,d)

,對x四捨五入,d是小數擷取位數。round(0.1 + 0.2, 1) == 0.3 -> true。注意：round函式的第二個引數不加就表示取整。

複數：a + bj，a是實部，b是虛部。z = 1.23e-4 + 5.6 + 89j,z.real獲取實部，z.imag獲得虛部。

列表型別

由0個或多個數據組成的有序序列，用[]表示，中間元素用,分隔。

str[-1] in ['F','f']表示字串str的最後一個字元是不是在列表元素總，即是否與某一個列表元素相同。

數值運算操作符

+ - * / 注意， x / y 產生的是浮點數，要求得整數除，用x // y。

-y表示y的負值。x ** y表示x的y次冪x^y，y可以是小數。

型別鍵可以進行混合運算，生成結果“最寬”。整數 -> 浮點數 -> 複數，由窄到寬。

字串操作符

x + y：表示字串連線
n * x 或 x * n：表示複製n次字串x
x in s：判斷x是否為s的子串，返回true / false

字串方法

str.lower()或者str.upper()：將字串中的字元變為全小寫或者全大寫。

str.split()：分割，返回一個列表。如："A,B,C".split(",") 結果為 ['A', 'B', 'C']

str.join(iter)：在iter變數除最後元素外每個元素後增加一個str。如：",".join("12345") 結果為 "1,2,3,4,5"，主要用於分隔字串

str.count(sub)：返回子串sub在str中出現的次數。

str.replace(old, new)：返回符串str的副本，所有old子串被替換成new子串。

str.center(width[,fillchar])：字串根據寬度width居中。如："Python".center(20,"=") 結果為 =======Python=======

str.strip(chars)：從str中去掉在其左側和右側chars中列出的字元。如："= python= ".strip(" =np") 結果為 "ytho，將左右兩側' ', '=', 'p', 'n'去掉。

str.join(iter)：在iter變數除最後元素外每個元素增加一個str。如："j".join("12345") 結果為 "1,2,3,4,5"，主要用於字串分隔。

字串的格式化

<模板字串>.format()

槽：由一對大括號{}組成，每個槽需要新增的內容與.fomat()中的引數順序一致，類似於printf。如：

"{}:計算機{}的CPU的佔用率為{}%".format("2018","C",10)

槽內部對格式化的配置方式{<引數序號>:<格式控制標記>}，其中格式控制標記為<填充符><對齊方式><寬度><,(表示千位分隔符)><.精度><型別>，如：

"{0:=^20}".format("python")
 結果為 '=======python======='
 注意：^居中對齊，<左對齊，>右對齊

 "{:10}.format("BIT")"
 結果為 'BIT       '
 直接給出寬度，預設左對齊，填充空格

 "{:,.2f}".format(12345.6789)
 結果為 '12,345.68'

 "{0:b},{0:o},{0:X}".format(425)
 結果為 '110101001,651,1A9'
 b，o,X表示型別二進位制、八進位制、大寫十六進位制

 "{0:e},{0:%}".format(3.14)
 結果為 '3.140000e+00,314.000000%'

語句與函式

賦值語句

賦值語句的右側資料型別同時作用於變數，如：

str = input("")，input返回一個字串，那麼str就是字串型別。

分支語句

用if elif else構成條件判斷語句，並且要加:,若條件成立則執行縮排的語句。

函式語句

input()：從控制檯獲得使用者的輸入。<變數> = input(<提示資訊字串>)，以字串格式型別儲存在<變數中>。

print()：向控制檯輸出。printf(<字串>)。保留兩位小數print("{:.2f}".format(變數))

eval()：去掉引數最外側引號（單或雙）並執行餘下語句。如：eval("1") 將得到數字 1 ， eval("1 + 2") 將得到數字3，eval('"1"')得到字串”1”，eval('"print("hello!)"')將執行print(“hello”)語句。

divmod(x, y)：商餘，同時輸出商和餘數。divmod(10, 3)的結果為(3, 1)。

pow(x, y[, z])：等同於(x ** y) % z。

max(x1, x2, …, xn)：求最大值

min(x1, x2, …, xn)：求最小值

int(x)：取整數部分，int(123.6) = 123，int("123") = 123

float(x)：將x變成浮點數，增加小數部分。float(12) = 12.0，float("1.23") = 1.23

len(x)：返回字串的長度。

str(x)：任意型別x所對應的字串形式，如str(1.23)結果為"1.23"，str([1,2])結果為"[1,2]"，與eval()函式相反。

hex(x)或者oct(x)：將x轉化為16進位制或者8進位制的小寫形式字串，如：hex(425)結果為"0x1a9"

ord(char)：得到Ascll碼

畫畫

import 引入了turtle庫（海龜庫）。是python標準庫之一，隨直譯器安裝。

import turtle
turtle.setup(650, 350, 200, 200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(25)
turtle.pencolor("purple")
turtle.seth(-40)
for i in range(4):
    turtle.circle(40, 80)
    turtle.circle(-40, 80)
turtle.circle(40, 80/2)
turtle.fd(40)
turtle.circle(16, 180)
turtle.fd(40 * 2/3)
turtle.done()

畫窗控制

turtle.setup(width, height, startx, starty),設定窗體大小以及位置。電腦的螢幕左上角為(0,0)，startx和starty是窗體的左上角在電腦螢幕的座標（不指定則在正中心）。並不必須

turtle.done()，加上後窗體不會自動關閉。

畫筆控制

turtle.penup()，拿起畫筆，此時移動海龜不會留下線。turtle.pendown()，落下畫筆，移動海龜會留下線。turtle.pensize(width)，設定畫筆的粗細。turtle.pencolor(color)，修改畫筆顏色，可以是顏色字串、RGB小數值或者元組值。

運動控制

turtle.goto(x, y)，表示從當前位置到(x,y)位置，中途經過地方都會有線。這個座標是turtle座標，即窗體的最中心是(0,0)，x軸為橫軸，y軸為縱軸。

turtle.fd(d)表示海龜向前移動d畫素，turtle.bk(d)表示海龜後退d畫素，turtle.circle(r,angle)表示以海龜當前位置左側（若r為負數，那麼就在右側）某r處為圓心畫圈，角度為angle（預設360）。

方向控制

turtle.seth(angle)設定當前海龜的前進方向，即面朝的方向，其中angle為絕對角度（即座標軸的標準角度）。

turtle.left(angle)，海龜向左轉一定角度；turtle.right(angle)，海龜向右轉一定角度。(相對海龜角度)

迴圈語句

for <變數> in range(<函式名>):
    <被執行的語句>

range中的引數值控制迴圈次數，<變數>表示迴圈的計數，0到<次數>-1

for i in range(5):  #相當於從0到n-1
    print(i)

結果:
0
1
2
3
4

range()函式：產生迴圈計數序列。range(N),產出從0到N-1的n和序列。range(m, n)產生從m開始到n-1的序列，共n-m個。

天天向上的力量（寫函式）

問：A在週一到週五進步，在週六周天能力下降1%。B不休息，每天進步1%。那麼A必須至少週一到週五每天進步多少才能趕上B？

#寫函式，用 def name(factor): 

#函式，傳入努力引數
def dayUp(df):
    dayup = 1
    for i in range(365):
        if i % 7 in [6, 0]:
            dayup = dayup * (1 - 0.01)
        else:
            dayup = dayup * (1 + df)
    return dayup

dayFactor = 0.01
while dayUp(dayFactor) < 37.78:
    dayFactor += 0.001
print("{:.3f}".format(dayFactor))

time庫

python中處理時間的標準庫，需要import time，再使用time.<b>()函式。

時間獲取

time.time()：獲取當前時間戳，即計算機內部時間值，浮點數。如151693876.6022282

time.ctime()：獲取當前時間，字串。如：Fri Jan 26 12:11:16 2018

time.gmtime()：獲取當前時間，表示為計算機可處理的時間格式。

時間格式化

time.strftime(tpl, ts)：tpl是格式化模板字串，定義輸出效果，ts是計算機內部時間型別變數。如：

t = time.gmtime()
time.strftime("%Y-%m-%d %H:%M:S", t)
結果為：'2018-01-26 12:55:20'

%Y  年份      0000~9999
%m  月份      01~12
%B  月份名稱  January~December
%b  月份縮寫  Jan~Dec
%d  日期      01~31
%A  星期      Monday~Sunday
%a  星期縮寫  Mon~Sun
%H  24小時    00~23
%h  12小時    01~12
%p  上午下午  AM, PM
%M  分鐘      00~59
%S  秒        00~59

time.strptime(str, tpl)：與strftime()相反，用時間字串構造出時間型別變數。如：

timeStr = '2018-01-26 12:55:20'
time.strptime(timeStr, "%Y-%m-%d %H:%M:S")

程式計時

程式計時指測量起止動作所經歷的時間

time.perf_counter()：返回一個CPU級別的精確時間計數值，單位為秒。如：

start = time.perf_counter()
end = time.perf_counter()
end - start         #計算差值

sleep(s)：s是休眠時間，單位是秒，可以是浮點數

def wait():
    time.sleep(3.3)
wait()

基本進度條

import time
scale = 10
print("------start------")
for i in range(scale + 1):
    a = '*' * i
    b = '.' * (scale - i)
    c = (i/scale) * 100
    print("{:^3.0f}%[{}->{}]".format(c, a, b))
    time.sleep(1)
print("-------end-------")

結果為：
------start------
 0 %[->..........]
10 %[*->.........]
20 %[**->........]
30 %[***->.......]
40 %[****->......]
50 %[*****->.....]
60 %[******->....]
70 %[*******->...]
80 %[********->..]
90 %[*********->.]
100%[**********->]
-------end-------

單行動態重新整理

後列印的字元覆蓋之前的字元，即不能換行，且退游標。

import time
scale = 100
print("------start------")
for i in range(scale + 1):
    print("\r{:3}%".format(i), end="")
    time.sleep(0.25)
print("-------end-------")

print()有個引數為end,end="資訊"，預設end="\n",意思是print執行後自動增加的資訊。

\r是指退回到行首

綜合進度條

import time
scale = 50
print("執行開始".center(scale, "-"))
start = time.perf_counter()
for i in range(scale + 1):
    a = "*" * i
    b = "." * (scale - i)
    c = (i / scale) * 100
    dur = time.perf_counter() - start
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c, a, b, dur), end = "")
    time.sleep(0.1)
print("\n執行結束".center(scale, "-"))

分支結構

單分支

if <條件> :
   <語句塊>

二分支

if <條件1> :
   <語句塊1>
else :
   <語句塊3>

另外還有緊湊形式：<表示式1> if <條件> else <表示式2>

guess = eval(input())
print("猜{}了".format("對" if guess == 99 else "錯"))

多分支

if <條件1> :
   <語句塊1>
elif <條件2> :
   <語句塊2>
......
else :
   <語句塊3>

邏輯運算

邏輯與運算and： x and y

邏輯或運算or：x or y

邏輯非運算not：not x

異常處理

當語句塊1有異常時，執行語句塊2。

try :
    <語句塊1>
except <異常型別>:      %異常型別可省略
    <語句塊2>

另有
try :
    <語句塊1>
except <異常型別>:     
    <語句塊2>
else :
    <語句塊3>           %無異常時執行3
finally :
    <語句塊4>           %有無異常都執行

BMI程式設計例子

注意：同時給兩個變數賦值的方法

#CalBMIv.py
height, weight = eval(input("請輸入身高(m)和體重(kg)[逗號隔開]："))
BMI = weight / pow(height, 2)
print("BMI 數值為：{:.2f}".format(BMI))
who, nat = "", ""
if BMI < 18.5 :
    who, nat = "偏瘦", "偏胖"
elif 18.5 <= BMI < 24 :
    who, nat = "正常", "正常"
elif 24 <= BMI < 25 :
    who, nat = "正常", "偏胖"
elif 25 <= BMI < 28 :
    who, nat = "偏胖", "偏胖"
elif 28 <= BMI < 30 :
    who, nat = "偏胖", "肥胖"
else :
    who, nat = "肥胖", "肥胖"
print("BMI 指標為：國際'{0}', 國內'{1}'".format(who, nat))

迴圈結構

遍歷迴圈

for <迴圈變數> in <遍歷結構>:
    <語句塊>

#計數迴圈，range(n)產生n個數，0~n-1
for i in range(n):
    <語句塊>

#i從m到n-1，以k為步長
for i in range(m, n, k):
    <語句塊>

#字串遍歷迴圈；c是字元，s是字串
for c in s:
    <語句塊>

#列表遍歷迴圈，ls是一個列表，如[123,"22",23]
for item in ls:
    <語句塊>

無限迴圈

while <條件> :
    <語句塊>

a = 3
while a > 0 :
    a = a - 1

有break與continue

高階迴圈

當迴圈沒有被break時，執行else語句。即正常迴圈結束是需要執行else裡面的語句的。

for <迴圈變數> in <遍歷結構> :
    <語句塊1>
else :
    <語句塊2>

while <條件> :
    <語句塊>
else :
    <語句塊2>

random庫

random是使用隨機數的python標準庫，使用import random

基本隨機函式

隨機數種子->梅森旋轉演算法->隨機序列，隨機序列由隨機數種子唯一確定

seed(a=None)：初始化給定的隨機數種子；如果不呼叫此函式，預設種子為當前系統時間。random.seed(10) %產生種子10對應的序列

random()：生成一個[0.0, 1.0]之間的隨機小數。random.random()

擴充套件隨機函式

randint(a, b)：生成一個[a, b]之間的整數

randrange(m, n, k)：生成一個[m, n)之間以k為步長的隨機整數random.randrange(10, 100, 10) 可能結果為80

getrandbits(k)：生成一個k位元長的隨機整數,random.getrandbits(16) 結果可能為37885

uniform(a, b)：生成一個[a, b]之間的隨機小數，精度為小數點後16位。

choice(seq)：在序列中隨機選取一個元素，random.choice([1,2,3])

shuffle(seq)：將序列元素隨機排序，s = [1,2,3];random.shuffle(s);print(s),會改變s自身。

蒙特卡洛求圓周率的演算法

#計算圓周率.py
import random
import time
import math

n = 1000 * 1000     #計算1e6次
hist = 0
start = time.perf_counter()   #計時
for i in range(1, n + 1) :
    x, y = random.random(), random.random() #得到隨機的座標[0,1]
    dist = math.sqrt(x ** 2 + y ** 2) #距離圓心的距離
    if dist <= 1.0 :
        hist = hist + 1

pi = 4 * (hist / n);
print("圓周率是：{}".format(pi))
print("執行時間是：{:.5f}".format(time.perf_counter() - start))

函式

函式定義

def <函式名>(<引數(0個或多個)>):
    函式體
    return <返回值>

#可選引數，注意可選引數必須在必選引數的後面
def fact(n, m=1):  
    ...
    return ...

m是可選引數，如果呼叫時不給出，就使用預設值。可以是：fact(10)或者fact(10,2)

#可變引數傳遞，可以不確定引數的總數量
def <函式名>(<引數>, *b):
    <函式體>
    return <返回值>

#例子，這裡必須有引數n，但是b可以有任意個
def fact(n, *b):
    s = 1
    for i in range(1, n+1):
        s *= i
    for item in b:
        s *= item
    return s

返回值

可以有return,也可以沒有；同時，可以返回多個值。e.g.return a, b, c,返回的是元組型別(a, b, c)。

全域性變數與區域性變數

python中是有全域性變數與區域性變數的概念的。

使用global可以在函式中宣告使用全域性變數。

s = 100
def fact(n):
global s #此時使用的s是全域性變數s
…
return …
區域性變數為組合型別且未建立，等同於全域性變數

ls = [“F”, “f”] #建立了一個列表
def fact(a):
ls.append(a) #此處ls是列表型別，未真實建立，等同於全域性變數
return
func(“C”)
print(ls) #結果是[“F”,”f”,”C”]

真實建立

ls = [“F”, “f”]
def fact(a):
ls = []
ls.append(a)
return
func(“C”)
print(ls) #結果是[“C”]

s = 1
def fac():
s = 3 #建立了就是區域性變數
print(s)
fac()
print(s) #結果是3 1

s = 1
def fac():
print(s) #未建立就是全域性變數
fac()
print(s) #結果是1 1

s = 1
def fac():
global s #宣告使用的是全域性變數
s = 3
print(s)

fac()
print(s) #結果是3 3
lambda函式

lambda函式是一種匿名函式，即沒有名字的函式，返回值就是函式的名字。僅用於在一行內表達的函式

<函式名> = lambda<引數>:<表示式>
f = lambda x, y : x + y   #定義了函式f，引數是(x, y)，返回值是x+y

f = lambda : "hello"
print(f())       #結果是輸出hello

7數碼管的繪製

按照圖中的線路走，比如0就是過1的時候不畫，其他都畫；8就是過每一條線的時候都畫。

import turtle, time

def drawLine(draw):             #繪製單段數碼管
    if draw:
        turtle.pendown()
    else:
        turtle.penup()
    turtle.fd(40)
    turtle.right(90)

def drawdDigit(digit):          #根據數字畫七段數碼管
    drawLine(True) if digit in [2,3,4,5,6,8,9] else drawLine(False)     #就是隻有2,3,4...等數字需要畫1號線
    drawLine(True) if digit in [0,1,3,4,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,6,8] else drawLine(False)
    turtle.left(90)             #保持直行
    drawLine(True) if digit in [0,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,2,3,4,7,8,9] else drawLine(False)
    turtle.left(180)
    turtle.penup()
    turtle.fd(20)               #隔一段距離，開始下一個數字的繪製

def drawDate(date):             #date是個日期字串，逐一解析裡面的數字進行繪製,格式為'%Y-%m=%d+'
    turtle.color("red")
    for i in date:
        if i == '-':
            turtle.write('年', font = ("Arial", 18, "normal"))
            turtle.pencolor("green")
            turtle.penup()
            turtle.fd(40)
        elif i == '=':
            turtle.write('月', font = ("Arial", 18, "normal"))
            turtle.pencolor("blue")
            turtle.penup()
            turtle.fd(40)
        elif i == '+':
            turtle.write('日', font = ("Arial", 18, "normal"))
        else:
            drawdDigit(eval(i))

def main():
    turtle.setup(800, 350, 200, 200)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawDate(time.strftime('%Y-%m=%d+', time.gmtime()))
    turtle.hideturtle()
    turtle.done()

main()

PyInstaller庫

將.py的原始碼轉換為可執行檔案。
是第三方庫，需要額外安裝。

(cmd命令列) pyinstaller -F <檔名.py>

科赫曲線舉例（遞迴）

import turtle

def koch(size, n):          #繪製n階的size長的koch曲線
    if n == 0:
        turtle.fd(size)     #0階就是直線
    else:
        for angle in [0, 60, -120, 60]:     #一條線會分為4個部分
            turtle.left(angle)
            koch(size/3, n-1)

def main():
    turtle.setup(800, 400)
    turtle.penup()
    turtle.goto(-300, -50)
    turtle.pendown()
    turtle.pensize(2)
    koch(600, 3)            #把長為600的直線畫為3階的koch曲線
    turtle.hideturtle()
main()

組合資料型別

（1）集合型別

集合是多個元素的無序組合（不存在相同元素），與數學概念一致。
python中要求集合中的元素是不可更改的。（不可修改）列表型別是可修改的。
集合用{}表示,元素用,分隔。建立空集合，要用set()函式。

A = {“PYTHON”, 123, (“PYTHON”, 123)} #使用{}建立集合，()表示的資料叫元組
B = set(“123pypy”) #使用set()函式，結果將拆分為{‘1’, ‘2’, ‘3’, ‘p’, ‘y’}

集合運算：

S | T：並集

S - T：差集

S & T：交集

S ^ T：補集（包括集合S和T中的非相同元素）

S <= T 或者 S < T（也有>=,>）：用來判斷S和T的包含關係，返回True/False

有|= -= &= ^=操作符，會改變原有操作集合

集合方法

S.add(x)：新增元素

S.discard(x)：刪除元素，x不在集合中，不報錯

S.remove(x)：刪除元素，x不在集合中，會產生KeyError異常

S.clear()：清空集合

S.pop()：從集合中隨機取出一個元素（並且刪除），若S為空產生KeyError異常

S.copy()：返回集合S的一個副本

len(S)：返回集合元素個數

x in S：判斷x是否在集合S中，返回True/False

set(x)：其他型別轉換為集合型別

#遍歷集合，注意用for迴圈取出的順序與定義順序不一定一致
A = {"P", 123}
for item in A:
    print(item)

try:
    while True:
        print(A.pop())
except:
    pass
#注意最後，A會成為空集合

集合應用場景

判斷包含關係

“P” in {“P”, 123} #True
{“p”, “y”} >= {“p”, “y”, 123} #False
資料去重

ls = [1, 1, 2]
s = set(ls) #結果{1, 2}
lt = list(s) #結果[1, 2]

（2）序列型別

序列是具有先後關係的一組元素，是以為元素向量。元素型別可以不同。
元素可以由序號引導，通過下標進行訪問。
序列型別是基類，衍生出的型別是字串型別、元組型別、列表型別。

序列型別（基類）及操作

x in s：判斷x是否在s中，返回True/False

s + t：連線兩個序列s和t

s * n：將序列s複製n次

s[i]：返回第i個元素

s[i:j]或s[i:j:k]：切片，返回第i個到第j-1個以k為步長的元素子序列（左閉右開）

ls = ["p", 123, ".io"]
ls[::-1]    #逆序，得到[".io", 123, "p"]

s = "123"
s[::-1]     #字串也是序列型別，得到"312"

len(s)：返回序列元素的個數

min(s)/max(s)：返回序列s中最小/最大的元素，需要元素有可比性

s.index(x) 或 s.index(x, i, j)：s從i開始到j-1位置中第一次出現元素x的下標（左閉右開）

s. count(x)：序列s中x出現的總次數

元組型別及操作

是序列型別的拓展,繼承了序列型別的所有操作，元組一旦被建立就不能被修改
使用()或tuple()建立，元素用,分隔
可以使用或不適用小括號

def func():
return 1, 2 #返回的是一個值，是元組型別(1, 2)

creature = “cat”, “dog”, “human”
color = (0x00100, “blue”, creature)
color[-1][2] == “human”

列表型別及操作

是序列型別的拓展，建立後元素可以隨意修改
使用[] 或 list()建立，元素用,分隔

ls = [“cat”, “dog”, “tiger”, 1024]
lt = ls #僅通過賦值，系統中並沒有再建立一個列表，僅僅傳遞了引用，使用[]或者list()才能建立列表

ls[i] = x：替換第i個元素

ls[i:j:k] = lt：用列表lt替換ls切片後對應元素的子列表

del ls[i]：刪除列表中的第i個元素

del ls[i:j:k]：刪除列表中第i到第j-1以k為步長的元素

ls += lt：將lt的元素增加到ls後

ls *= n：更新ls，對元素重複n次

ls = [1, 2, 3]
ls[1:2] = [100, 100, 100]       #結果為[1, 100, 100, 100, 3]
del ls[::3]                     #結果為[100, 100, 3]    刪除了0和3號元素

sorted(ls)：對列表ls進行排序

ls.append(x)：列表後增加一個元素

ls.clear(x)：清空

ls.copy()：複製列表

ls.insert(i, x)：在第i位置增加元素x

ls.pop(i, x)：將第i位置元素取出（並刪除）

ls.remove(x)：將列表ls中出現的第一個x刪除

ls.reverse()：將ls元素反轉

序列型別的應用場景

元組用於元素不改變的應用場景，進行資料保護
列表更加靈活
資料遍歷

（3）字典型別

對映：一種鍵（索引）和值（資料）對應的關係。
字典型別是“對映”體現，字典是鍵值對的集合，鍵值對之間是沒有順序的。
使用{}和dict()建立，鍵值對用冒號:表示，鍵值對之間用,分隔

<字典變數> = {<鍵1>:<值1>, …, <鍵n>:<值n>} #建立
<字典變數>[<鍵>] #查詢<值>
<字典變數>[<鍵>] = <值> #改變
dict = {} #生成空字典；注意，不能用這種方法生成空集合，要使用set()

字典型別操作方法

del d[k]：刪除鍵k對應的資料值

d[<鍵>] = <值>：新增元素/修改元素

k in d：判斷某個鍵是否在字典d中

d.keys()：返回字典d中所有鍵的資訊

d.values()：返回d中所有值的資訊

d.items()：返回d中所有鍵值對的資訊

d.get(k, )：鍵k存在則返回對應值，不存在就返回值

d.pop(k, )：鍵k存在則返回對應值，並刪除，不存在就返回值

d.popitem()：隨機取出一個鍵值對，以元組形式返回

d.clear()：清空

len(d)：返回元素個數

d = {...}  #d是字典
for k in d:     #這裡k是鍵
    ...

jieba庫

中文分詞的第三方庫

精確模式：把文字精確切分開，不存在冗餘單詞
全模式：把文字中所有可能的詞語都掃描出來，有冗餘
搜尋引擎模式：在精確模式的基礎上，對長詞再次切分

jieba.lcut(s)：精確模式，返回一個列表型別的分詞結果
jieba.lcut(s, cut_all=True)：全模式，存在冗餘
jieba.lcut_for_search(s)：搜尋引擎模式，存在冗餘
jieba.add_word(s)：增加新詞

jieba.lcut("中國是一個偉大的國家") -> ['中國', '是', '一個', '偉大', '的', '國家']
jieba.lcut("中國是一個偉大的國家", cut_all=True) -> ['中國', '國是', '一個', '偉大', '的', '國家']
jieba.lcut_for_search("中華人民共和國是偉大的") -> ['中華', '華人', '人民', '共和', '共和國', '中華人民共和國', '是', '偉大', '的']

例子：文字詞頻統計

先獲取文字的具體資訊。
對於英文文字，需要有大小寫轉換，逗號、句號的處理。

英文：

#讀取檔案，並改為小寫，並處理特殊字元為空格
def getText():
    txt = open("hamlet.txt", "r").read()    #開啟檔案讀入txt
    txt = txt.lower()                       #變為小寫
    for c in '!"$%^&*()+,-./:;<=>[email protected][\\]_\'{|}~':
        txt = txt.replace(c, " ")
    return txt

hamletTxt = getText()
words = hamletTxt.split()                   #預設以空格分隔
counts = {}                                 #空字典，用於統計單詞頻率

for w in words:
    counts[w] = counts.get(w, 0) + 1        #用get()查詢w對應的值（次數），如果沒有返回0

#將字典型別變為列表型別 便於排序
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True)#對鍵值對的第二個元素進行排序  reverse為True是從大到小

for i in range(10):
    word, count = items[i]
    print("{0:<10}{1:>5}".format(word, count))

中文：中文就需要分詞，不存在大小寫問題

import jieba

#讀取檔案
txt = open("threekingdoms.txt", "r", encoding="UTF-8").read()
words = jieba.lcut(txt)

counts = {}                                 #空字典，用於統計單詞頻率
for w in words:
    if len(w) == 1:
        continue
    counts[w] = counts.get(w, 0) + 1        #用get()查詢w對應的值（次數），如果沒有返回0

#將字典型別變為列表型別 便於排序
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True)#對鍵值對的第二個元素進行排序  reverse為True是從大到小

for i in range(15):
    word, count = items[i]
    print("{0:<10}{1:>5}".format(word, count))

檔案操作

根據檔案展示方式分為：文字檔案和二進位制檔案。

文字檔案：單一特定編碼組成的檔案，如UTF-8編碼。也就是長的字串。
二進位制檔案：由01構成的檔案，沒有統一字元編碼。

檔案處理步驟：開啟-操作（讀寫）-關閉

開啟：

<變數名> = open(<檔名>, <開啟模式>)，變數名成為檔案控制代碼

開啟模式：
    'r'，只讀模式，檔案不存在返回FileNotFoundError
    'w'，覆蓋寫模式，檔案不存在則建立檔案，存在則完全覆蓋
    'x'，建立寫模式，檔案不存在則建立，存在則返回FileExistSError
    'a'，追加寫模式，檔案不存在則建立檔案，存在則在檔案後面追加內容

    'b'，以二進位制模式開啟
    't'，以文字模式開啟（預設是t）
    '+'，與r/w/x/a一同使用，在原功能基礎上增加同時讀寫的功能    r+/w+/a+

    f = open("f.txt")       #預設文字模式、只讀模式
    f = open("f.txt", "rt") #跟預設一樣
    f = open("f.txt", "w")  #文字模式，覆蓋寫模式
    f = open("f.txt", "a+") #文字形式，追加寫模式 + 讀模式，只有a只能寫，不能讀
    f = open("f.txt", "b")  #二進位制、只讀模式
    f = open("f.txt", "wb") #二進位制模式、覆蓋寫模式

關閉：

<變數名>.close()

檔案內容讀取：

f.read(size=-1)：讀入全部內容，如果給出引數size，則讀入前size字元
f.readline(size=-1)：讀入一行，如果給出引數size，則讀入該行前size字元
f.readlines(hint=-1)：讀入所有行，以每行為元素形成列表，給出引數則讀入前hint行

e.g:
#遍歷全文字：一次性讀入（佔記憶體）
f = open(fname, "r")
txt = f.read()
...
f.close

#遍歷全文字：逐步讀入
f = open(fname, "r")
txt = f.read(2)
while txt != "":
    ...
    txt = f.read(2)
f.close

#逐行操作：一次性讀入
f = open(fname, "r")
for line in f.raedlines():
    ...
f.close

#逐行操作：逐步讀入
f = open(fname, "r")
for line in f:          #逐行讀入
    ...
f.close

檔案寫入：

f.write(s)：向檔案中寫入一個字串
f.writelines(lines)：將一個元素全部為字串的列表寫入檔案。寫進去字串之間沒有空格隔，也不會換行
f.seek(offset)：改變當前檔案操作的指標的位置，0-檔案開頭；1-當前位置；2-檔案結尾

f = open("output.txt", "w+")
ls = ["中國","美國","法國"]
f.writelines(ls)
for line in f:
    ...
f.close()
發現並沒有輸出，因為寫完之後指標在最後，用for in 方法不能遍歷

解決辦法：加個seek(0)
f = open("output.txt", "w+")
ls = ["中國","美國","法國"]
f.writelines(ls)
f.seek(0)
for line in f:
    ...
f.close()
輸出："中國美國法國"

列子：自動歸集繪製

需求：根據指令碼來繪製圖形；讀取一個檔案，解析其中的資料，繪製出相應的圖形。

檔案：一行代表一次操作：行進距離,轉向判斷(0左轉,1右轉),轉向角度,RGB三個通道的顏色
300,0,144,1,0,0     
300,0,144,0,1,0
300,0,144,0,0,1
300,0,144,1,1,0
300,0,108,0,1,0

import turtle as t
#畫布引數設定
t.title('自動軌跡繪製')
t.setup(800, 600, 0, 0)
t.pencolor("red")
t.pensize(5)

#資料讀取
datals = []                     #將每一個操作讀入到datals的每一行
f = open("data.txt")
for line in f:
    line.replace("\n", "")      #去掉換行符
    datals.append(list(map(eval, line.split(','))))     #map函式，將第一個引數的功能作用於第二個引數的每一個元素
f.close()

#自動繪製
t.pendown()
for i in range(len(datals)):
    t.pencolor(datals[i][3], datals[i][4], datals[i][5])
    t.fd(datals[i][0])
    if datals[i][1] == 1:
        t.right(datals[i][2])
    else:
        t.left(datals[i][2])

資料格式化

一維資料格式化

一維資料有序，可使用列表型別
無序，可使用集合型別（不可重複)

將儲存的一維資料讀入程式表達為列表或者集合

#讀入用空格分隔的字串檔案
txt = open(fname).read()
ls = txt.split()
txt.close()

#採用空格方式分隔字串並寫入檔案
ls = ['1', '2', '3']
f = open("f.txt", 'w')
f.write(' '.join(ls))           #join方法，使用某引數分隔元素，形成一個字串
f.close()

二維資料格式化

使用二維列表型別二維資料

CSV儲存格式：用逗號分隔值，國際通用的一二維資料儲存格式，一般用.csv副檔名；每行是一個一維資料，採用逗號分隔，並且檔案中沒有空行。不同行就是不同維度

#從csv格式檔案讀入資料
ls = []
f = open(filename)
for line in f:
    line.replace("\n", "")      #去掉換行符
    ls.append(ling.spilt(','))
f.close()

#將資料寫入CSV格式的檔案中
ls = [[...], ..., [...]]           #二維檔案
f = open(filename, 'w')
for item in ls:
    f.write(','.join(item) + '\n')  #增加逗號和回車
f.close()

#遍歷二維資料
for row in ls:
    for column in row:
        print(ls[row][column])

python生態

安裝第三方庫命令：

pip install <name>
pip install -U <name>   #對已安裝的更新
pip uninstall <name>    #解除安裝
pip download <name>     #下載不安裝
pip show <name>         #列出詳情
pip search <name>       #搜尋相關的第三方庫
pip list                #列出已經安裝的第三方庫

整合安裝庫：Anaconda

https://www.continuum.io
下載了後系統就有了800個第三方庫（資料相關的，適合計算領域開發）

檔案安裝方法：

某些第三方庫需要pip下載，結合本地作業系統編譯後才能安裝，但是本地不具有相應的安裝環境。

然後直接找到已經編譯好的檔案，結合作業系統和python版本下載

然後使用pip install <檔名> 進行安裝（同一目錄下）

os庫

os庫提供通用的、基本的作業系統互動功能，是python標準庫

路徑操作——os.path

os.path子庫以path為入口，用於操作和處理檔案路徑

os.path.abspath(path)：返回path在當前作業系統的絕對路徑，os.path.abspath("file.txt") -> C:\\user\\file.txt

os.path.normpath(path)：歸一化path表示形式，統一用\\分隔，os.path.normpath("D://file.txt") -> D:\\file.txt

os.path.relpath(path)：返回當前程式與檔案之間的相對路徑，結果可能為：..\\..\\user//file.txt

os.path.dirname(path)：返回目錄名

os.path.basename(path)：獲得最後的檔名

os.path.join(path, *paths)：組合path和paths，返回一個路徑字串

os.path.exists(path)：判斷檔案或者目錄是否存在，返回True False

os.path.getatime(path)：上一次的訪問時間

os.path.getmtime(path)：最近一次的修改時間

os.path.getctime(path)：建立時間

os.path.getsize(path)：返回path對應的檔案大小，以位元組為單位

程序管理——os.system

import os
os.system("C:\\dota.exe")   #直接呼叫程式

環境引數

os.chdir(path)：修改當前程式操作的路徑

os.getcwd()：返回程式的當前路徑

os.getlogin()：獲得當前系統登入的使用者名稱稱

os.cpu_count()：返回當前系統的CPU數量

os.urandom(n)：獲得n個位元組長度的隨機字串，用於加密解密

例子：批量安裝第三方庫

import os
libs = {"", "", ..., ""}        #第三方庫的名字
try:
    for lib in libs:
        os.system("pip install " + lib)
    print("successful!")
except:
    print("Failed Somhow!")

python生態

資料分析

Numpy：表達N為陣列的最基礎的庫，計算速度優異（c語言實現），提供矩陣運算等功能。

Pandas：python資料分析的高層次應用庫，提供簡單易用的資料結構和資料分析工具，基於Numpy開發。

SciPy：數學、科學和工程計算功能庫，類似matlab，提供個很多優化演算法

資料視覺化

Matplotlib：高質量的二維資料的視覺化功能庫，通過Matplotlib.pyplot字型檔呼叫各個視覺化效果

Seaborn：統計類資料視覺化功能（分佈、分類、線性關係等）

Mayavi：三維科學資料視覺化功能庫

文字處理

PyPDF2：用來處理PDF檔案，獲取資訊、分隔整合檔案、加密解密

NLTK：自然語言文字處理第三方庫，包括分類、標記、語法句法、語義分析等

Python-docx：建立或者更新word檔案的第三方庫

機器學習

Scikit-learn：機器學習方法工具集，聚類、分類、迴歸、強化學習等功能

TensorFlow：機器學習計算框架

MXNet：基於神經網路的深度學習計算框架

網路爬蟲

Request：最友好的網路爬蟲工具，主要是頁面

Scrapy：網路爬蟲框架，可以構建網路爬蟲系統，支援批量和定時網頁爬取，提供資料處理流程

pyspider：強大的web頁面爬取系統，支援資料庫後端，訊息佇列、分散式架構等

web資訊提取

爬蟲之後解析內容

Beautiful Soup：HTML和XML的解析庫，可以載入多種解析引擎

Re：正則表示式解析和處理功能庫，是python的標準庫，無需安裝

Python-Goose：提取文章型別web頁面的功能庫，文章資訊、視訊資訊的元資料提取功能

網站開發、後端框架

Django：最流行的框架，MTV模式

Pyramid：規模適中的web應用框架

Flask：微型web框架

網路應用開發

WeRoBot：微信公眾號開發框架

aip：百度AI開放平臺介面，訪問百度AI服務的python功能介面，包括語音、人臉、NLP、知識圖譜、影象搜尋等

MyQR：二維碼生成第三方庫

圖形使用者介面

PyQt5：Qt開發框架的python介面，桌面應用開發系統，完備的GUI

wxPython：跨平臺GUI開發框架

PyGObject：使用GTK+開發GUI功能庫

遊戲開發

PyGame：簡單的遊戲開發功能庫

Panda3D：開源、跨平臺的3D遊戲開發庫

cocos2d：構建2D遊戲和圖形介面互動式應用的框架，支援GPU加速

虛擬現實

VR Zero：樹莓派上開發VR應用的python庫，適合初學者

pyovr：針對Oculus裝置的python開發庫，比較成熟

Vizard：通用vr開發引擎，支援多種VR裝置

圖形藝術

Quads：迭代的圖形

ascii_art：ascll藝術庫

零基礎學習Python個人筆記

環境搭建

資料型別

字串

擴充套件字串

數字型別

列表型別

數值運算操作符

字串操作符

字串方法

字串的格式化

語句與函式

賦值語句

分支語句

函式語句

畫畫

畫窗控制

畫筆控制

運動控制

方向控制

迴圈語句

天天向上的力量（寫函式）

time庫

時間獲取

時間格式化

程式計時

基本進度條

單行動態重新整理

綜合進度條

分支結構

單分支

二分支

多分支

邏輯運算

異常處理

BMI程式設計例子

迴圈結構

遍歷迴圈

無限迴圈

有break與continue

高階迴圈

random庫

基本隨機函式

擴充套件隨機函式

蒙特卡洛求圓周率的演算法

函式

函式定義

返回值

全域性變數與區域性變數

真實建立

7數碼管的繪製

PyInstaller庫

科赫曲線舉例（遞迴）

組合資料型別

（1）集合型別

（2）序列型別

（3）字典型別

jieba庫

例子：文字詞頻統計

檔案操作

列子：自動歸集繪製

資料格式化

一維資料格式化

二維資料格式化

python生態

安裝第三方庫命令：

整合安裝庫：Anaconda

檔案安裝方法：

os庫

路徑操作——os.path

程序管理——os.system

環境引數

例子：批量安裝第三方庫

python生態

資料分析

資料視覺化

文字處理

機器學習

網路爬蟲

web資訊提取