Python 基礎

Python

Python雖慢但功能齊全，是一門工程語言。

基礎

簡單語法

• pip 包管理

# 默認python的管理工具爲 pip

# 更新 pip 到最新版
python -m pip install --upgrade pip

# 安裝最新版
pip intsall package
# 安裝指定版本
pip install package==1.0.1
# 安裝最小版本
pip install package>=1.0.1

# 更新指定包，默認最新版
pip install --update package

# 卸載指定包
pip uninstall package

# 獲取已經安裝的包 [可升級的包]
pip list [-o]

# 獲取詳細信息
pip show [-f package]

數據類型

• 弱類型

1. 變量都是弱類型的，使用時會動態變化。
2. 基礎類型 int、float、complex、str、bool、None等6種。
3. 基礎類型 int、float、str 的內存都是動態分配的。
4. 基礎類型 function，內存處理類似於其餘基礎類型。

# int-類型-十進制
int = 100
# int-類型-八進制
int = 0o100
# int-類型-十六進制
int = 0x100

# 浮點類型
flo = 100.02

# 複數類型
com = 1+2j

# 字符串類型
str = 'hello world'

# False/None/0/0.0 都爲 false
# True/... 都爲 true
bol = False

# None 即爲 python 中的 null 值
null = None

# 函數類型
def demo():
    print('hello world!')
# 函數也能夠做爲普通變量
hel = demo

# 轉化爲 int
a = int(x)
# 轉化爲 浮點數
a = float(x)
# 轉化爲 字符串
a = str(x)
# 轉化爲 char
a = chr(x)

# 將字符轉化爲整形
a = ord(x)
# 將整數轉化爲16進制
a = hex(x)
# 將整數轉化爲 8進制
a = oct(x)

• String

1. 'str' "str" """str""" string定義。
2. string 拼接，長度空格大小寫，格式化，正則匹配。
3. string 索引 0 ~ n。
4. string len(str)，須要根據場景改變編碼格式。

# 'str' 標準定義，內部可轉義，但內部不能有 `''`
x = 'hello world'
# "str" 經常使用定義，可轉義，可添加 `''`
x = "I can't go!"
# """ str """ 多行定義格式
x = """
hello!
My world!
"""

# 字符串重複、拼接，* + (* 優先級大於 +)
x = 'hello' + ' ' + 'world' * 2

# 支持切片、索引，str[start:end:step]
print(x[0:],x[0],x[-1])

# 字串查詢，find不存在爲 -1，index不存在會報錯:('str',start,end)
print(x.find('nt'),x.index('he'))
# 查詢字串是否存在，查詢字串出現的次數
print('hello' in x,x.count('h'))

x = "哈哈"
# 此處默認 Utf-8，可選參數 gbk或其餘編碼格式
y = x.encode()

# len(x) 2 len(y) 6 須要根據場景轉換編碼格式
print(x,y)   # \xe5\x93\x88\xe5\x93\x88 哈哈
# string 轉換大小寫
print(x.lower(),x.upper())
# 去除string兩側、左側、右側指定字符串，通常都是特殊字符
print(x.strip('st'),x.lstrip('l'),s.rstrip('r'))

# index索引，格式化字符串
x = "name {} age {}"
print(x.format('zsh',22))          # name zsh age 22

# hash映射，格式化字符串，支持多點映射
x = "name {name} {name} age {age}"
print(x.format(name="zsh",age=22)) # name zsh zsh age 22

x = "hello world"
# 默認 空格，將原string分割爲 list
y = x.split()
# 以指定 'str' 將原string分割爲 list
y = x.split('o')

x = ['www','baidu','com']
# 將指定 list 以指定分隔符 '.' 鏈接爲 string
print('.'.join(x)) # 'www.baidu.com'
print(''.join(x))  # 'wwwbaiducom'

# 正則匹配模式 ^start [dat]{freq}(time) end$
# re 模塊，正則會用到

• 函數

1. function 定義與內存處理同等與基礎類型。
2. function 內限定局部變量，外部爲全局變量。
3. function 支持右側參數設定默認值。
4. function 支持 lambda 語法糖定義函數。
5. function * ** 系參數都是動態深拷貝。
6. function * 將連續的參數轉爲tuple。
7. function ** 將連續的參數映射，轉化爲字典類型。

# python function 基礎定義
def demo():
    print('hello world')

exp = demo

# 徹底類似於基礎變量的內存管理
print(id(exp),id(demo))
demo()
exp()

x = 100
# 函數內部爲局部變量區域
def demo():
    # 此時輸出函數外變量
    print(x)

# 存在默認值的參數必須在右邊，不然會報錯
def demo(dat,tmp='hello')
    print(dat+tmp)

# 語法糖生成簡單函數
# 參數列表:自動返回表達式
demo = lambda a : a*a
# 參數列表:自動執行語句塊
demo = lambda a : print(a*10)

# 將原始參數轉化爲一個元組
def demo(*dat):
    for val in dat:
        print(val)

# 將原始參數轉化爲字典
def test(**dat):
    for key,val in dat.items():
        print(key+':'+str(val))

# 動態傳參，參數執行深拷貝
demo(1,2,3)
test(a=1,b=2,c=3)

# 匿名函數回調
def demo(args, fun):
    print("function demo running")
    fun(args)

demo("hello world",lambda args:print(args))

# 閉包函數，注意內存泄漏
def demo(args):
    return lambda : print(args)

demo("hello world")()

語法控制

• 運算符

# 加 減 乘 除
+ - * /
# 整除 求餘 求冪
// % **

# 賦值運算
= += -= *= /= //= %= **=
# 比較運算
> >= < <= == !=
# 邏輯運算
and or not

# 與 或 反 異或 左移 右移
& | ~ ^ >> <<

• 流程控制

# if
if True:
    pass

# if else
if True:
    pass
else:
    pass

# if elseif else
if True:
    pass
elif True:
    pass
else:
    pass

# while 循環
while True:
    pass

# for 循環
for i in range(1,10,2):
    print(i)

# break continue

• 異常處理

異常類型	異常說明
NameError	訪問一個不存在的變量
IOError	IO 異常
MemoryError	內存溢出或不足
ValueError	傳入值錯誤
IndexError	索引出界異常
ImportError	import 導包異常
TypeError	類型異常
...	...

1. assert 1 == 0 判斷是否中斷程序。
2. try except finally 標準的異常處理塊。
3. raise ExpError("ExpMsg") 主動拋異常，通常配合if使用。

# raise 用於主動拋出異常
def det(dat):
    if dat == 10:
        raise IndexError("demo-10")
    return 100/dat

# try except finally 處理異常
try:
    print(det(0))
    # 手動拋出異常，通常配合 if 使用
    raise IndexError("demo")
# 捕獲系統拋出的異常
except ZeroDivisionError as err:
    # err 異常信息
    # err.with_traceback() 獲取異常棧信息
    print(err)
# 捕獲本身拋出的異常
except IndexError as er:
    print(er)
finally:
    print("end")

# 調試專用，根據條件中斷進程
# True 則繼續執行 Flase 會中斷進程，並輸出異常信息
assert 1 == 0

數據結構

• 概括分析

1. python struct 都是容器類型，只存引用，內存動態化。
2. python struct 內部依然是弱類型的，可組成靈活的嵌套結構。
3. python list/tuple set 可組成靈活的數據結構體。
4. python dict 類似於 lua-table/Json 等數據操做方式。

# list tuple set 這三種容器是能夠相互轉化的
x = [1,2,3,4]
y = tuple(x)
z = set(x)
# dict key 可由 tuple/obj組成，value則無限制
d = { y:x }

# list tuple set dict 容器特性，引用鏈接致使內部無限定
x = [1,2,'3']
x = (1,2,'3')
x = {1,2,'2'}
x = {1:1,'1':'2'}

# list tuple set dict 均可以使用推導式建立
# list  = [ exp for if ]
# tuple = ( exp for if )
# set   = { exp for if }
# sict  = { exp1:exp2 for if }

# len str (a in b) 等方法皆適用 list tuple set dict
print(len(x),str(x),a in b)

# list tuple set dict 淺拷貝
new = old

# list set dict 深拷貝
# tuple 是不可變的，一個副本就夠了，因此沒有 copy 方法
new = old.copy()

# list set dict 內存都是動態管理
dat.clear()

序列

• 基本結構

1. python list 能夠當作數組、鏈表。
2. python list 可執行動態切片功能。
3. python list 亦可執行 + *。

x = [1,2,3,'4']

# list 正數爲 0~n，負數則是反向序數索引
print(x[0],x[-1])

# 切片功能 x[start:end:step]
# 半開區間 [start,end) step 可省略，默認爲 1
print(x[1:2:1])

# 可重複連接 list
print(x*2,x+x)

# range 類，內部爲迭代函數
x = range(1,10)
# 此處將迭代函數實現爲 list
x = list(x)

# enumrate，index-value 組，內部爲迭代函數
x = enumerate(x)
# (0,1) (1,2) (2,3) ...

# 遍歷 value，非循環內部變量
for value in y:
    print(value)

# 遍歷 index value，非循環內部變量
for index,value in enumerate(y):
    print(index,value)

• 增刪改查 sort

x = [1,2,3,4]

# insert

# append 無返回值
# append 在末端連接一個數據結構
x.append(5) # [1,2,3,4,5]
x.append(x) # [1,2,3,4,[1,2,3,4]]

# extend 無返回值
# extend 在末端連接一個數據結構中的全部數據
# x+y 系列的方法，默認就是用這個方法
x.extend(x) # [1,2,3,4,1,2,3,4]

# insert 無返回值
# insert(index,val)，index 支持正負
# index 以前插入，val 值
x.insert(0,0)

# delete

# pop 返回 val，並刪除此 val
# x.pop()命中最後一個 val
# x.pop(index) 用索引命中 val
x.pop()   # 4
x.pop(0)  # 1

# remove 無返回值
# 刪除指定 val
x.remove(1)
# remove 通常配合 if 使用
if 1 in x:
    x.remove(1)

# update

# 更改操做通常直接用 索引、切片
x[0] = -1
x[0:2] = [-1,-2]

# select

# 判斷 val 是否在 list 中
print(1 in x)

# 計數 list 存在多少個 val
print(x.count(1))

# 返回命中的第一個索引
print(x.index(1))
# 此處帶區間
print(x.index(1,0,2))

# sort 無返回值，排序方式，排序方向等均可設置
x.sort()

# 反排序
import random
# 將原 list 順序打亂重排
random.shuffle(x)

元組

• 基本結構

1. python tuple tuple 就是不可變的 list。
2. python tuple 處理速度較快與list，選擇合適的場景便可。

# 元組與list類似，內部節點相互獨立
x = (1,2,3,'4')

# 元組可作 * 運算
print(x*2)
# sum len str max min 等經常使用函數亦支持
x = tuple(range(1,10))

# count index 及標準索引等方法亦支持
print(x.count(1),x.index(1),x[0])

# x[start:end:step] 亦支持切片
print(x[2:],x[:2],x[1:4:2])

x = (1,2,3,4)

# tuple 支持 + 運算，但必須爲同類型
print(x+x)

# tuple 沒有 append extend insert remove pop 等方法
# tuple 只要被建立，既沒法被修改，只能刪除或被清理

集合

• 基本結構

1. python set 本質是一個無序不重複的集合。
2. 集合自己都是能夠作交併補等集合運算的。

# 集合自己會將重複對象自動過濾
x = {1,2,'2',2}  # {1,2,'2'}

# 添加、刪除 對象
x.add(3)
x.remove(3)
# 擴展的添加刪除對象
x.update(1,2,3)  # 一次性添加多個元素
x.discard(1)     # 安全移除集合元素(可能不存在)

# 集合自己無序，只能隨機 pop 出一個對象
x.pop()

# 交併補等運算 ......

# 迭代集合
for i in x:
    print(i)

字典

• 基本結構

1. python dict key:value 映射關係。
2. python dict key 是不可變的，value無限制。

# 標準定義方法
x = { "a":1, "b":2 }

# key 惟一且不可變，類型無限制，不能是標識符a、b等，value 無限制
x = { 1:1, 2:"a" }

y = [1,2,3]
z = (1,2,3)

# 快捷建立字典，z必須爲tuple
x = {z:y}

# zip(a,b) 將多個 list/tuple 轉化爲元組組成的zip對象
# dict(a,b) 則是將元組、列表或元組 組成字典對象
x = dict(zip(z,y))

# 此處設計友好，但實際 標識符被轉化爲 string
x = dict(a=1,b=2)

# 實際建立字典 {1:None,2:None}
x = dict.fromkeys([1,2])

x = {"a":1,"b":2}

# 判斷是否存在此 key
if "a" in x:
    print(x["a"])

# 獲取 key --> value，和 lua 蠻像的
print(x["a"],x.get("a"))

# 新增或修改均可以以來這個操做
x["c"] = 3

# 此時迭代每一組，且轉化爲 元組 (key,value)
for item in x.items():
    print(item)

設計

面向對象

基礎部分

• 組成部分

組成	說明	初始化	訪問
類變量	非構造函數內定義的類內變量	加載模塊	類/對象
類函數	參數沒有self的任意類內函數	加載模塊	類/對象
成員變量	構造函數內定義的變量	初始化對象	對象
成員函數	參數攜帶self的任意類內函數	初始化對象	對象
默認	全部類都附帶的方法和變量	加載模塊	~

• 訪問控制權限

適用於全部類的組成部分。

類型		_	__
示例	exp	_exp	__exp
訪問區域	無限制	本模塊、子類	類內部
對比-Java	public	protected	private

class exp:
    # 類變量，exp.msg obj.msg 便可訪問
    msg = 'static-value'
    # 類方法，exp.show() obj.msg 便可訪問
    def show():
        print('static-function')

    # 構造方法
    def __init__(self,x,y=10):
        # 無任何前綴的變量，可隨意訪問，public
        self.x = x
        # _ 前綴的變量，子類、本類、本模塊可訪問，protected
        self._y = y
        # __前綴的變量，僅能內部訪問，private
        self.__z = z

    # function 存在self，則爲對象方法，不然爲類方法
    def show(self):
        print(self.x,self.y)

    def _sh0(self,z):
        print(self.x,self.y,z)

    def __sh(self,z):
        print(self.x,self.y,z)

    # 被 property註解的方法，參數只有self，且存在返回值
    # 對象調用此對象方法時，能夠直接當作變量來用
    @property
    def exec(self):
        return self.__z

# 新建對象
obj = exp(10)

# 類級別變量，均可引用
print(exp.msg,obj.msg)
# 對象方法，注意權限控制
exp.show()
# 被 property 註解的方法，
print(exp.exec)

抽象化

面向對象本質就是代碼設計抽象化的過程。

• 類基礎方法

1. __init__ 構造方法
2. __del__ 析構方法
3. __str__ string化對象
4. __cmp__ 比較 obj

這些方法均可以被重寫，構造方法通常須要重寫。

• 繼承

子類 super() 獲取父類引用，self獲取自身引用。

# 父類 demo
class demo:
    def __init__(self,x):
        self.__x = x

    @property
    def get_x(self):
        return self.__x

# 子類 exp 繼承 demo
class exp(demo):
    def __init__(self,x,y):
        # super() 即爲父類引用
        super().__init__(x)
        self.__y = y

    def get_y(self):
        return self.__y

ex = exp(10,12)

# 同時訪問父類與子類的方法
print(ex.get_x,ex.get_y())

• 重寫

自定義實現的 init 就是重寫此方法。

# __init__ 可自動初始化
class fat:
    def show(self):
        print('father')

    def sh(self):
        print('ok')

# 繼承過程當中，__init__ 亦可自動初始化
class son(fat):
    # 子類重寫父類方法
    def show(self):
        print('son')

# 調用重寫的方法
son().show()
# 掉用父類方法
son().sh()

• others

1. python 沒有抽象類與接口，需引入abc包(不推薦)。
2. python 過程式爲主，簡單快速，不必非要搞得很複雜。

# getter setter
class demo:
    def __init__(self,x):
        self.x = __x

    # @property 註解，無參數，存在返回值纔可註解
    def get_x(self):
        return self.__x

    def set_x(self,x)
        self.__x = x

模塊化

• 模塊

1. python 導入模塊相似於Lua。
2. 先在sys.modules中查找模塊是否已加載。
3. 若模塊已加載則直接返回索引。
4. 若未加載則先加載至sys.modules中，再返回索引。
5. 默認模塊名就是索引，可as自定義。
6. 模塊之間可限定訪問權限與附加操做。

sys.path 默認加載路徑。
sys.modules 已完成加載的模塊。

# 導入包，as 用於重命名
import sys as sys
# 導入模塊中的某一個引用，能夠是對象，亦能夠是函數
from sys import path

# 遍歷輸出全部，模塊加載路徑
for v in sys.path:
    print(v)

# 遍歷輸出，全部已被加載的模塊
for v in sys.modules:
    print(v)

# 熱更新思想，就是刪除已加載的模塊，繼續加載一次
import exp
# 熱更新基礎原理，相似於 lua
if 'exp' in sys.modules:
    del sys.modules['exp']
    import exp

# python3 以後自帶的，熱更新方法
from imp import reload
reload(exp)

# exp 模塊
def demo():
    # 此處可限定其餘模塊引用的附加操做
    if __name__ == '__main__':
        print("self using")
    else:
        print("others using")

# test 模塊
import exp
exp.demo()    # others using

• 包

1. python 包就是一個自帶__init__.py的文件夾。
2. python 包自己是個 namespace，內部控制其餘模塊。
3. __init__.py 的 __all__ 可設定 * 匹配值。
4. __init__py 在import 時執行，通常空便可。

exp
   __init__.py
   demo.py

# package.module_name
import exp.demo as demo

# __init__.py
__all__ = [ "module_1","module_2" ]

# 此時僅會導入 __all__ 鏈表中的模塊
import exp.*

內存管理

• 弱類型 容器

1. python 的全部對象都是弱類型的。
2. 語言中，弱類型對象執行時纔可肯定對象類型。
3. 即弱類型語言僅在執行時變量纔會申請內存。
4. 容器類對象，僅提供指向具體內存的引用(指針)，不提供具體空間。

• 引用計數器

1. python 普通對象的申請與Java-常量池很是類似。
2. 引用計數器，即指程序會記錄內存塊被引用的數量。
3. 某個對象的引用計數器爲 0~n 之間，爲零即會被回收。

• GC 分代

1. python GC，中止全部運行線程。
2. python GC，和對象無關，只和內存塊以及引用計數器相關。
3. python GC，自動觸發執行，new - free > sta(700) 即執行。
4. python 內存塊分代，new -> 0代，以後逐次變化。

• 內存分級

1. python 內存整體是一個金字塔類型。
2. -1 -2 層，這部分 OS 控制，與python無關。
3. 0 層，某些內存需求大於256k，python利用malloc，free控制堆內存。
4. 1 2 層，這部分即爲內存池，python控制存一些小內存的變量。
5. 3 層，這一層由程序員徹底控制便可。

# x 被使用時，纔會解析變量類型，以肯定內存大小，0 代
x = 100
# y、x 同時指向一塊內存，引用計數器爲 2
y = x
# 執行常量池原則 ，x、y、z 指向一塊內存，引用計數器爲 3
z = 100

# 清除 z 的引用相關，原始內存的引用計數器爲 2，x、y依然正常使用
del z

# 容器類對象，內部只存對象引用
dat = [1,2,3]
# 改變 dat[0]所指向的內存塊的引用計數爲0，而後再刪除dat[0]節點
del dat[0]
# 改變 dat 對象或遞歸對象所指向的內存塊的引用計數爲 0
del dat

pass

# 執行GC，除主線程-執行GC，其餘線程所有中止
# 引用計數爲 0 的清除，繼續存活的逐漸升級迭代

adr = id(x)  # int  提供對象的實際內存地址
ok = x is y  # bool 判斷兩個對象是否指向一個內存地址，內部id()
del(x)       # None 將實際內存地址的引用計數：減一，並清除此對象

經常使用

方法

1. 包括 時間、文件、網絡IO、系統等的一些處理。

• 通用

# 1 ~ 10，間隔 2
x = range(1,10,2)

# 四捨五入
x = round(10.2,2)
# 求和
x = sum(range(1,10))
# 10 的4次冪
x = pow(10,4)

# 時間模塊
import time
# 程序休眠 10 秒
time.sleep(10)
# 時間戳
print(time.time())
# 時間 2020-02-29 00:00:12
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))

# 打開二進制文件
file = open('exp.png','rb')
file.close()

# 安全操做文件，避免中途出現異常，致使文件被鎖或損壞
with open('exp.txt','w') as file:
    file.read()
    file.write("...")
    file.close()
    pass

模塊

1. 一些主要的模塊，sys、os、time。