python實現原理
㈠ python 解釋本方法的實現原理
你好， mark = int(input("mark:")) 這句沒啥說的，聲明一個變數mark,而mark的賦值說白了就是你從鍵盤上輸啥，mark的值就是啥.
至於print(["Fail", "Pass", "Good"][(mark>=60)+(mark>=80)])語句，其實抽象出來就是print(list[i]),["Fail", "Pass", "Good"]相當於這里的list, [(mark>=60)+(mark>=80)]相當於這里的[i],所以簡單來說print()函數列印的就是列表中的某個元素，只不過索引[i]的寫法看著比較邪乎。索引[(mark>=60)+(mark>=80)]中兩個括弧中是兩個邏輯表達式，而邏輯表達如果成立，通常值為true,邏輯表達式不成立，值為false,而邏輯琢達式的值用在算數運算中，true表示1，false表示0。如此一來[(mark>=60)+(mark>=80)]這個索引中的內容就變成了[0或1+0或1]，如mark=70,則[(70>=60)+(70>=80)]這個計算出來就是[1+0]，即[1],也就是說當你輸入的值為70的時候，print()函數就變為了print(["Fail","Pass","Good"][1]),這樣就直觀了
㈡ python程序如何工作
隨著人工智慧時代的來臨，python成為了人們學習編程的首先語言。那麼，python程序怎麼運行的?我們下面來介紹下。
python程序執行原理
我們都知道，使用C，C++之類的編譯性語言編寫的程序，是需要從源文件轉換成計算機使用的機器語言，經過鏈接器鏈接之後形成了二進制可執行文件。運行該程序的時候，就可以二進製程序從硬碟載入到內存中並運行。
相關推薦：《Python教程》
但是對於Python而言，Python源碼不需要編譯成二進制代碼，它可以直接從源代碼運行程序。Python解釋器將源代碼轉換為位元組碼，然後把編譯好的位元組碼轉發到Python虛擬機(PVM)中進行執行。當我們運行Python程序的時候，Python解釋器會執行兩個步驟。
(1) 把源代碼編譯成位元組碼。編譯後的位元組碼是特定於Python的一種表現形式，它不是二進制的機器碼，需要進一步編譯才能被機器執行，這也是Python代碼無法運行的像C，C++一樣快的原因。如果Python進程在機器上擁有寫入許可權，那麼它將把程序的位元組碼保存為一個以.pyc為擴展名的文件，如果Python無法在機器上寫入位元組碼，那麼宇節碼將會在內存中生成並在程序結束時自動丟棄。在構建程序的時候最好給Python賦上在計算機上寫的許可權，這樣只要源代碼沒有改變，生成的.pyc文件可以重復利用，提高執行效率。
(2) 把編譯好的位元組碼轉發到Python虛擬機(PVM)中進行執行。PVM是Python Virtual Machine的簡稱，它是Python的運行引擎，是Python系統的一部分，它是迭代運行位元組碼指令的一個大循環，一個接一個地完成操作。
㈢ Python的垃圾回收機制原理
1.Python的垃圾回收機制原理
Python無需我們手動回收內存，它的垃圾回收是如何實現的呢？
引用計數為主（缺點：循環引用無法解決）
引入標記清除和分代回收解決引用計數問題
引用計數為主+標記清除和分代回收為輔
垃圾回收（GC）
（1）引用計數
a = [1] # [1]對象引用計數增加1，ref=1
b = a # [1]對象引用計數增加1，ref=2
b = None # [1]對象引用計數減少1，ref=1
del a # [1]對象引用計數減少1，ref=0
a = [1],當把列表 [1] 賦值給 a 的時候，它的引用計數就會增加1，此時列表 [1] 對象的引用計數ref=1 ； b = a 又把 a 賦值給 b ，a和b 同時引用了列表[1]對象，ref又增加1，此時 ref =2。繼續執行 b = None， 讓b指向None，這個時候它就不會指向原來的列表[1]對象，列表[1]對象的引入計數就會減少1，又變成ref=1。執行del a ，引用計數就會減少1，這個時候 ref = 0。當對象的引用計數為0就可以回收掉，
注意：del 作用就會減少對象引用計數，並不是銷毀對象。只有當引用計數為0的時候，Python解釋器才回去把對象佔用的內存回收掉。
// object.h
struct _object {
Py_ssize_t ob_refcnt; # 引用計數值
}PyObject;
① 什麼時候引用計數增加呢？
② 什麼時候引用計數會減少呢？
（2）引用計數無法解決循環引用問題
循環引用
a = [1] # 對象[1]引用計數增加1，ref=1
b = [2] # 對象[2]引用計數增加1，ref=1
a.append(b) # b被a引用，對象[2]引用計數增加1，ref=2
b.append(a) # a又被b引用，對象[1]引用計數增加1，ref=2
del a # 對象[1]引用計數減少1，ref=1
del b # 對象[2]引用計數減少1，ref=1
（3）標記清除（Mark and Sweep）
（4）分代回收
import gc
㈣ Python數據結構與演算法-哈希map的實現及原理
1-collections.MutableMapping
1.1 概念：這是什麼？
大家可能想知道這一串英文是什麼意思？其實只需要了解在collections庫當中有一個非常重要的抽象基類MutableMappin
g，專門用於實現map的一個非常有價值的工具。後邊我們會用到它。
2-我們的map基類
2.1 實現這個類
這個基類其實也就是確定了鍵值對的屬性，並且存儲了基本的比較方法。它的對象就是一個鍵值對咯。這個很好理解。有點類似object的感覺。
3-通過map基類實現的無序映射
給大家看一個上邊的例子，這個例子來源於網路，自己改了改，能用，更加詳細而已，湊合看.
4-Python哈希表的實現的基類
4.1 咱有話直說：上才（代）藝（碼）
如果還不知道哈希表概念的同xio，請參考 python進階之數據結構與演算法–中級-哈希表（小白piao分享） 。廢話不多說，咱們擼代碼：
OK了，基本的哈希表就實現了，其實仔細想想很容易，但是自己要能實現還是要理解哈希表的本質哦，外加一定量的練習才可以熟練掌握，練習的目的就是為了熟練而已。
5-分離鏈表實現的具體哈希map類
說明：這玩意只是一種降低沖突的手段，上一節提過，降低沖突最好的地方是發生在元組進入桶的時候，所以想必大家猜到了，接下來的分離鏈表也就是為了self._bucket_xxxxxxx系列方法做准備。這里之所以在上邊使用@abstractmethod就是為了繼承實現，目的可以實現多種將沖突的哈希表。分離鏈表的概念上一節也有的。
「見碼入面」（借鑒：見字如面這個電視節目，有興趣可以看看，還不錯的）：
6-用線性探測處理沖突的哈希map類
這種方式的好處不需要再去藉助其他額外的賦值結構來表示桶。結構更加簡單。不會再像上一種方法還要讓桶是一個UnsortedTableMap的對象。
代碼如下：
㈤ 圖像雙三次插值演算法原理及python實現
一. 圖像雙三次插值演算法原理：
假設源圖像 A 大小為 m*n ，縮放後的目標圖像 B 的大小為 M*N 。那麼根據比例我們可以得到 B(X,Y) 在 A 上的對應坐標為 A(x,y) = A( X*(m/M), Y*(n/N) ) 。在雙線性插值法中，我們選取 A(x,y) 的最近四個點。而在雙立方插值法中，我們選取的是最近的16個像素點作為計算目標圖像 B(X,Y) 處像素值的參數。如圖所示：
如圖所示 P 點就是目標圖像 B 在 (X,Y) 處對應於源圖像中的位置，P 的坐標位置會出現小數部分，所以我們假設 P 的坐標為 P(x+u,y+v)，其中 x,y 分別表示整數部分，u,v 分別表示小數部分。那麼我們就可以得到如圖所示的最近 16 個像素的位置，在這里用 a(i,j)(i,j=0,1,2,3) 來表示。
雙立方插值的目的就是通過找到一種關系，或者說系數，可以把這 16 個像素對於 P 處像素值的影響因子找出來，從而根據這個影響因子來獲得目標圖像對應點的像素值，達到圖像縮放的目的。
BiCubic基函數形式如下：
二. python實現雙三次插值演算法
from PIL import Image
import numpy as np
import math
# 產生16個像素點不同的權重
def BiBubic(x):
x=abs(x)
if x<=1:
return 1-2*(x**2)+(x**3)
elif x<2:
return 4-8*x+5*(x**2)-(x**3)
else:
return 0
# 雙三次插值演算法
# dstH為目標圖像的高，dstW為目標圖像的寬
def BiCubic_interpolation(img,dstH,dstW):
scrH,scrW,_=img.shape
#img=np.pad(img,((1,3),(1,3),(0,0)),'constant')
retimg=np.zeros((dstH,dstW,3),dtype=np.uint8)
for i in range(dstH):
for j in range(dstW):
scrx=i*(scrH/dstH)
scry=j*(scrW/dstW)
x=math.floor(scrx)
y=math.floor(scry)
u=scrx-x
v=scry-y
tmp=0
for ii in range(-1,2):
for jj in range(-1,2):
if x+ii<0 or y+jj<0 or x+ii>=scrH or y+jj>=scrW:
continue
tmp+=img[x+ii,y+jj]*BiBubic(ii-u)*BiBubic(jj-v)
retimg[i,j]=np.clip(tmp,0,255)
return retimg
im_path='../paojie.jpg'
image=np.array(Image.open(im_path))
image2=BiCubic_interpolation(image,image.shape[0]*2,image.shape[1]*2)
image2=Image.fromarray(image2.astype('uint8')).convert('RGB')
image2.save('BiCubic_interpolation.jpg')
三. 實驗結果：
四. 參考內容：
https://www.cnblogs.com/wojianxin/p/12516762.html
https://blog.csdn.net/Ibelievesunshine/article/details/104942406
㈥ 請教Python 使用裝飾器實現單例模式的原理
def func():
...
是下面代碼的簡寫
func = deco(func)
這就是裝飾器做的事情
[0]
private = 0
a simple fun
private = 1
a simple fun
private = 2
a simple fun
private = 3
a simple fun
private = 4
a simple fun
[0]
private = 0
a simple2 fun
private = 1
a simple2 fun
private = 2
a simple2 fun
private = 3
a simple2 fun
private = 4
a simple2 fun
復制代碼
#!/usr/bin/python2
# coding: utf-8
def deco(f):
private = [0]
print private
# wrap 是一個closure
def wrap():
print 'private = ', private[0]
f()
private[0] += 1
return wrap
@deco
def simple():
print "a simple fun"
for i in xrange(5):
simple()
def simple2():
print "a simple2 fun"
# @deco
# def simple():
# ...
# 是下面代碼的簡寫
# simple = deco(simple)
# 這就是裝飾器做的事情
simple2 = deco(simple2)
for i in xrange(5):
simple2()
㈦ Python實現viterbi演算法原理流程是什麼樣的
維特比演算法說白了就是動態規劃實現最短路徑，只要知道「動態規劃可以降低復雜度」這一點就能輕松理解維特比演算法
維特比演算法是一個特殊但應用最廣的動態規劃演算法，利用動態規劃，可以解決任何一個圖中的最短路徑問題。而維特比演算法是針對一個特殊的圖——籬笆網路的有向圖（Lattice )的最短路徑問題而提出的。 它之所以重要，是因為凡是使用隱含馬爾可夫模型(Hidden Markov Model，HMM)描述的問題都可以用它來解碼，包括今天的數字通信、語音識別、機器翻譯、拼音轉漢字、分詞等。——《數學之美》 ps 多處摘錄此書，不再贅述。
籬笆網路有向圖的特點是同一列節點有多個，並且和上一列節點交錯地連接起來。同一列節點代表同一個時間點上不同的狀態的並列，大概因為這種一列一列整齊的節點和交錯的邊很像籬笆而得名。
假設上圖每一列分別有n1……nn個節點，如果不使用動態的話，那麼計算復雜度就是O(n1*n2……nn)。
而維特比演算法的精髓就是，既然知道到第i列所有節點Xi{j=123…}的最短路徑，那麼到第i+1列節點的最短路徑就等於到第i列j個節點的最短路徑+第i列j個節點到第i+1列各個節點的距離的最小值。
這是一句大白話，所謂中文偽碼。
分析一下復雜度，假設整個籬笆有向圖中每一列節點最多有D個（也就是圖的寬度為D），並且圖一共有N列，那麼，每次計算至多計算D*D次（從i列的D個節點中挑一個計算到i+1列D個節點的距離）。至多計算N次。那麼復雜度驟減為O（ND2），遠遠小於窮舉O（DN）。
㈧ python之多線程原理
並發：邏輯上具備同時處理多個任務的能力。
並行：物理上在同一時刻執行多個並發任務。
舉例：開個QQ，開了一個進程，開了微信，開了一個進程。在QQ這個進程裡面，傳輸文字開一個線程、傳輸語音開了一個線程、彈出對話框又開了一個線程。
總結：開一個軟體，相當於開了一個進程。在這個軟體運行的過程里，多個工作同時運轉，完成了QQ的運行，那麼這個多個工作分別有多個線程。
線程和進程之間的區別：
進程在python中的使用，對模塊threading進行操作，調用的這個三方庫。可以通過 help(threading) 了解其中的方法、變數使用情況。也可以使用 dir(threading) 查看目錄結構。
current_thread_num = threading.active_count() # 返回正在運行的線程數量
run_thread_len = len(threading.enumerate()) # 返回正在運行的線程數量
run_thread_list = threading.enumerate() # 返回當前運行線程的列表
t1=threading.Thread(target=dance) #創建兩個子線程，參數傳遞為函數名
t1.setDaemon(True) # 設置守護進程，守護進程：主線程結束時自動退出子線程。
t1.start() # 啟動子線程
t1.join() # 等待進程結束 exit()`# 主線程退出，t1子線程設置了守護進程，會自動退出。其他子線程會繼續執行。
㈨ python dict 實現原理 2019-04-17
dict對象是Python中一個原始的數據類型，按照鍵值對的方式存儲，中文名為字典，其通過鍵名查找對應的值有很高的效率，時間復雜度在常數級別O(1)。Python dict的底層是依靠哈希表(Hash Table)進行實現的，使用開放地址法解決沖突。所以其查找的時間復雜度會是O(1)，why？
哈希表是key-value類型的數據結構，通過關鍵碼值直接進行訪問。通過散列函數進行鍵和數組的下標映射從而決定該鍵值應該放在哪個位置，哈希表可以理解為一個鍵值需要按一定規則存放的數組，而哈希函數就是這個規則。
演算法中時間和空間是不能兼得的，哈希表就是一種用合理的時間消耗去減少大量空間消耗的操作，這取決於具體的功能要求。
創建一個數組，數組下標是索引號，數組中的值是要獲得的數據，這樣只需要O(1)的時間復雜度就可以完成操作，但是擴展性不強，有以下兩個方面的考慮：
-1- 新添加的元素超出數組索引范圍，這就需要重新申請數組進行遷移操作。
-2- 假設一種極端的情況：只存在兩個元素，索引號分別是1和100000000001，按照先前的設計思路，會浪費很大的存儲空間。
會不會存在一個方法，為已有的索引創建新的索引，通過壓縮位數，讓新索引可以和原有的大范圍的稀疏索引進行一一對應，新索引所需要的存儲空間要大大減小，這就是哈希思想。
上面的例子中哈希函數的設計很隨意，但是從這個例子中我們也可以得到信息：
哈希函數就是一個映射，因此哈希函數的設定很靈活，只要使得任何關鍵字由此所得的哈希函數值都落在表長允許的范圍之內即可；
因為新的索引對舊的索引進行了空間上的壓縮，所以不可能所有的輸入都只對應唯一一個輸出，也就是哈希函數式有可能發生沖突的，哈希函數不可能做成一對一的映射關系，其本質是一個多對一的映射。
直接定址法：很容易理解，key=Value+C； 這個「C」是常量。Value+C其實就是一個簡單的哈希函數。
除法取余法： 很容易理解， key=value%C;解釋同上。
數字分析法：這種蠻有意思，比如有一組value1=112233，value2=112633，value3=119033，針對這樣的數我們分析數中間兩個數比較波動，其他數不變。那麼我們取key的值就可以是key1=22,key2=26,key3=90。
平方取中法。此處忽略，見名識意。
折疊法：這種蠻有意思,比如value=135790，要求key是2位數的散列值。那麼我們將value變為13+57+90=160，然後去掉高位「1」,此時key=60，哈哈，這就是他們的哈希關系，這樣做的目的就是key與每一位value都相關，來做到「散列地址」盡可能分散的目地。
當兩個不同的數據元素的哈希值相同時，就會發生沖突。解決沖突常用的手法有2種：
開放地址法：
如果兩個數據元素的哈希值相同，則在哈希表中為後插入的數據元素另外選擇一個表項。當程序查找哈希表時，如果沒有在第一個對應的哈希表項中找到符合查找要求的數據元素，程序就會繼續往後查找，直到找到一個符合查找要求的數據元素，或者遇到一個空的表項。
鏈接法：
將哈希值相同的數據元素存放在一個鏈表中，在查找哈希表的過程中，當查找到這個鏈表時，必須採用線性查找方法。
python的dict採用了哈希表，最低能在 O(1)時間內完成搜索，在發生哈希沖突的時候採用的是開放定址法。java的HashMap也是採用了哈希表實現，但是在發生哈希沖突的時候採用的是鏈接法。
㈩ 雙線性插值法原理 python實現
碼字不易，如果此文對你有所幫助，請幫忙點贊，感謝！
一. 雙線性插值法原理：
① 何為線性插值？
插值就是在兩個數之間插入一個數，線性插值原理圖如下：
② 各種插值法：
插值法的第一步都是相同的，計算目標圖（dstImage）的坐標點對應原圖（srcImage）中哪個坐標點來填充，計算公式為：
srcX = dstX * (srcWidth/dstWidth)
srcY = dstY * (srcHeight/dstHeight)
(dstX,dstY)表示目標圖像的某個坐標點，(srcX,srcY)表示與之對應的原圖像的坐標點。srcWidth/dstWidth 和 srcHeight/dstHeight 分別表示寬和高的放縮比。
那麼問題來了，通過這個公式算出來的 srcX, scrY 有可能是小數，但是原圖像坐標點是不存在小數的，都是整數，得想辦法把它轉換成整數才行。
不同插值法的區別就體現在 srcX, scrY 是小數時，怎麼將其變成整數去取原圖像中的像素值。
最近鄰插值（Nearest-neighborInterpolation）：看名字就很直白，四捨五入選取最接近的整數。這樣的做法會導致像素變化不連續，在目標圖像中產生鋸齒邊緣。
雙線性插值（Bilinear Interpolation）：雙線性就是利用與坐標軸平行的兩條直線去把小數坐標分解到相鄰的四個整數坐標點。權重與距離成反比。
雙三次插值（Bicubic Interpolation）：與雙線性插值類似，只不過用了相鄰的16個點。但是需要注意的是，前面兩種方法能保證兩個方向的坐標權重和為1，但是雙三次插值不能保證這點，所以可能出現像素值越界的情況，需要截斷。
③ 雙線性插值演算法原理
假如我們想得到未知函數 f 在點 P = (x, y) 的值，假設我們已知函數 f 在 Q11 = (x1, y1)、Q12 = (x1, y2), Q21 = (x2, y1) 以及 Q22 = (x2, y2) 四個點的值。最常見的情況，f就是一個像素點的像素值。首先在 x 方向進行線性插值，然後再在 y 方向上進行線性插值，最終得到雙線性插值的結果。
④ 舉例說明
二. python實現灰度圖像雙線性插值演算法：
灰度圖像雙線性插值放大縮小
import numpy as np
import math
import cv2
def double_linear(input_signal, zoom_multiples):
'''
雙線性插值
:param input_signal: 輸入圖像
:param zoom_multiples: 放大倍數
:return: 雙線性插值後的圖像
'''
input_signal_cp = np.(input_signal) # 輸入圖像的副本
input_row, input_col = input_signal_cp.shape # 輸入圖像的尺寸（行、列）
# 輸出圖像的尺寸
output_row = int(input_row * zoom_multiples)
output_col = int(input_col * zoom_multiples)
output_signal = np.zeros((output_row, output_col)) # 輸出圖片
for i in range(output_row):
for j in range(output_col):
# 輸出圖片中坐標 （i，j）對應至輸入圖片中的最近的四個點點（x1，y1）（x2, y2），（x3， y3），(x4，y4)的均值
temp_x = i / output_row * input_row
temp_y = j / output_col * input_col
x1 = int(temp_x)
y1 = int(temp_y)
x2 = x1
y2 = y1 + 1
x3 = x1 + 1
y3 = y1
x4 = x1 + 1
y4 = y1 + 1
u = temp_x - x1
v = temp_y - y1
# 防止越界
if x4 >= input_row:
x4 = input_row - 1
x2 = x4
x1 = x4 - 1
x3 = x4 - 1
if y4 >= input_col:
y4 = input_col - 1
y3 = y4
y1 = y4 - 1
y2 = y4 - 1
# 插值
output_signal[i, j] = (1-u)*(1-v)*int(input_signal_cp[x1, y1]) + (1-u)*v*int(input_signal_cp[x2, y2]) + u*(1-v)*int(input_signal_cp[x3, y3]) + u*v*int(input_signal_cp[x4, y4])
return output_signal
# Read image
img = cv2.imread("../paojie_g.jpg",0).astype(np.float)
out = double_linear(img,2).astype(np.uint8)
# Save result
cv2.imshow("result", out)
cv2.imwrite("out.jpg", out)
cv2.waitKey(0)
cv2.destroyAllWindows()
三. 灰度圖像雙線性插值實驗結果：
四. 彩色圖像雙線性插值python實現
def BiLinear_interpolation(img,dstH,dstW):
scrH,scrW,_=img.shape
img=np.pad(img,((0,1),(0,1),(0,0)),'constant')
retimg=np.zeros((dstH,dstW,3),dtype=np.uint8)
for i in range(dstH-1):
for j in range(dstW-1):
scrx=(i+1)*(scrH/dstH)
scry=(j+1)*(scrW/dstW)
x=math.floor(scrx)
y=math.floor(scry)
u=scrx-x
v=scry-y
retimg[i,j]=(1-u)*(1-v)*img[x,y]+u*(1-v)*img[x+1,y]+(1-u)*v*img[x,y+1]+u*v*img[x+1,y+1]
return retimg
im_path='../paojie.jpg'
image=np.array(Image.open(im_path))
image2=BiLinear_interpolation(image,image.shape[0]*2,image.shape[1]*2)
image2=Image.fromarray(image2.astype('uint8')).convert('RGB')
image2.save('3.png')
五. 彩色圖像雙線性插值實驗結果：
六. 最近鄰插值演算法和雙三次插值演算法可參考：
① 最近鄰插值演算法： https://www.cnblogs.com/wojianxin/p/12515061.html
https://blog.csdn.net/Ibelievesunshine/article/details/104936006
② 雙三次插值演算法： https://www.cnblogs.com/wojianxin/p/12516762.html
https://blog.csdn.net/Ibelievesunshine/article/details/104942406
七. 參考內容：
https://www.cnblogs.com/wojianxin/p/12515061.html
https://blog.csdn.net/Ibelievesunshine/article/details/104939936