雙重探測法python代碼

Ⅰ 200. 島嶼數量（python）

難度：★★★☆☆
類型：數組
方法：深度優先搜索

傳送門

給你一個由 '1'（陸地）和 '0'（水）組成的的二維網格，請你計算網格中島嶼的數量。

島嶼總是被水包圍，並且每座島嶼只能由水平方向或豎直方向上相鄰的陸地連接形成。

此外，你可以假設該網格的四條邊均被水包圍。

輸入:
[
['1','1','1','1','0'],
['1','1','0','1','0'],
['1','1','0','0','0'],
['0','0','0','0','0']
]
輸出: 1

輸入:
[
['1','1','0','0','0'],
['1','1','0','0','0'],
['0','0','1','0','0'],
['0','0','0','1','1']
]
輸出: 3
解釋: 每座島嶼只能由水平和/或豎直方向上相鄰的陸地連接而成。

可以使用深度優先搜索方法，逐個點遍歷，每次遇到一個島嶼，就將這個島嶼淹沒，統計被淹沒的島嶼的數目就好。這里為了便於理解，採用了實例化島嶼和探測點。

如有疑問或建議，歡迎評論區留言~

Ⅱ 121 11 個案例掌握 Python 數據可視化--星際探索

星空是無數人夢寐以求想了解的一個領域，遠古的人們通過肉眼觀察星空，並制定了太陰歷，指導農業發展。隨著現代科技發展，有了更先進的設備進行星空的探索。本實驗獲取了美國國家航空航天局（NASA）官網發布的地外行星數據，研究及可視化了地外行星各參數、尋找到了一顆類地行星並研究了天體參數的相關關系。
輸入並執行魔法命令 %matplotlib inline， 設置全局字型大小，去除圖例邊框，去除右側和頂部坐標軸。

本數據集來自 NASA，行星發現是 NASA 的重要工作之一，本數據集搜集了 NASA 官網發布的 4296 顆行星的數據，本數據集欄位包括：

導入數據並查看前 5 行。

截至 2020 年 10 月 22 日 全球共發現 4296 顆行星，按年聚合並繪制年度行星發現數，並在左上角繪制 NASA 的官方 LOGO 。

從運行結果可以看出，2005 年以前全球行星發現數是非常少的，經計算總計 173 顆，2014 和 2016 是行星發現成果最多的年份，2016 年度發現行星 1505 顆。

對不同機構/項目/計劃進行聚合並降序排列，繪制發現行星數目的前 20 。

2009 年至 2013 年，開普勒太空望遠鏡成為有史以來最成功的系外行星發現者。在一片天空中至少找到了 1030 顆系外行星以及超過 4600 顆疑似行星。當機械故障剝奪了該探測器對於恆星的精確定位功能後，地球上的工程師們於 2014 年對其進行了徹底改造，並以 K2 計劃命名，後者將在更短的時間內搜尋宇宙的另一片區域。

對發現行星的方式進行聚合並降序排列，繪制各種方法發現行星的比例，由於排名靠後的幾種方式發現行星數較少，因此不顯示其標簽。

行星在宇宙中並不會發光，因此無法直接觀察，行星發現的方式多為間接方式。從輸出結果可以看出，發現行星主要有以下 3 種方式，其原理如下：

針對不同的行星質量，繪制比其質量大（或者小）的行星比例，由於行星質量量綱分布跨度較大，因此採用對數坐標。

從輸出結果可以看出，在已發現的行星中，96.25% 行星的質量大於地球。（圖中橫坐標小於 e 的紅色面積非常小）

通過 sns.distplot 介面繪制全部行星的質量分布圖。

從輸出結果可以看出，所有行星質量分布呈雙峰分布，第一個峰在 1.8 左右（此處用了對數單位，表示大約 6 個地球質量），第二個峰在 6.2 左右（大概 493 個地球質量）。

針對不同發現方式發現的行星，繪制各行星的公轉周期和質量的關系。

從輸出結果可以看出：徑向速度（Radial Velocity）方法發現的行星在公轉周期和質量上分布更寬，而凌日（Transit）似乎只能發現公轉周期相對較短的行星，這是因為兩種方法的原理差異造成的。對於公轉周期很長的行星，其運行到恆星和觀察者之間的時間也較長，因此凌日發現此類行星會相對較少。而徑向速度與其說是在發現行星，不如說是在觀察恆星，由於恆星自身發光，因此其觀察機會更多，發現各類行星的可能性更大。

針對不同發現方式發現的行星，繪制各行星的距離和質量的關系。

從輸出結果可以看出，凌日和徑向速度對距離較為敏感，遠距離的行星大多是通過凌日發現的，而近距離的行星大多數通過徑向速度發現的。原因是：近距離的行星其引力對恆星造成的擺動更為明顯，因此更容易觀察；當距離較遠時，引力作用變弱，擺動效應減弱，因此很難藉助此方法觀察到行星。同時，可以觀察到當行星質量更大時，其距離分布相對較寬，這是因為雖然相對恆星的距離變長了，但是由於行星質量的增加，相對引力也同步增加，恆星擺動效應會變得明顯。

將所有行星的質量和半徑對數化處理，繪制其分布並擬合其分布。
由於：

因此，從原理上質量對數與半徑對數應該是線性關系，且斜率為定值 3 ，截距的大小與密度相關。

從輸出結果可以看出：行星質量和行星半徑在對數變換下，具有較好的線性關系。輸出 fix_xy 數值可知，其關系可以擬合出如下公式：

擬合出曲線對應的行星平均密度為：

同樣的方式繪制恆星質量與半徑的關系。

從輸出結果可以看出，恆星與行星的規律不同，其質量與半徑在對數下呈二次曲線關系，其關系符合以下公式：

同樣的方式研究恆星表面重力加速度與半徑的關系。

從輸出結果可以看出，恆星表面對數重力加速度與其對數半徑呈現較好的線性關系：

以上我們分別探索了各變數的分布和部分變數的相關關系，當數據較多時，可以通過 pd.plotting.scatter_matrix 介面，直接繪制各變數的分布和任意兩個變數的散點圖分布，對於數據的初步探索，該介面可以讓我們迅速對數據全貌有較為清晰的認識。

通過行星的半徑和質量，恆星的半徑和質量，以及行星的公轉周期等指標與地球的相似性，尋找諸多行星中最類似地球的行星。

從輸出結果可以看出，在 0.6 附近的位置出現了一個最大的圓圈，那就是我們找到的類地行星 Kepler - 452 b ，讓我們了解一下這顆行星：

數據顯示，Kepler - 452 b 行星公轉周期為 384.84 天，半徑為 1.63 地球半徑，質量為 3.29 地球質量；它的恆星為 Kepler - 452 半徑為太陽的 1.11 倍，質量為 1.04 倍，恆星方面數據與太陽相似度極高。
以下內容來自網路。 開普勒452b（Kepler 452b） ，是美國國家航空航天局（NASA）發現的外行星， 直徑是地球的 1.6 倍，地球相似指數( ESI )為 0.83，距離地球1400光年，位於為天鵝座。
2015 年 7 月 24 日 0：00，美國國家航空航天局 NASA 舉辦媒體電話會議宣稱，他們在天鵝座發現了一顆與地球相似指數達到 0.98 的類地行星開普勒 - 452 b。這個類地行星距離地球 1400 光年，繞著一顆與太陽非常相似的恆星運行。開普勒 452 b 到恆星的距離，跟地球到太陽的距離相同。NASA 稱，由於缺乏關鍵數據，現在不能說 Kepler - 452 b 究竟是不是「另外一個地球」，只能說它是「迄今最接近另外一個地球」的系外行星。

在銀河系經緯度坐標下繪制所有行星，並標記地球和 Kepler - 452 b 行星的位置。

類地行星，是人類寄希望移民的第二故鄉，但即使最近的 Kepler-452 b ，也與地球相聚 1400 光年。

以下通過行星的公轉周期和質量兩個特徵將所有行星聚為兩類，即通過訓練獲得兩個簇心。
定義函數-計算距離
聚類距離採用歐式距離：

定義函數-訓練簇心
訓練簇心的原理是：根據上一次的簇心計算所有點與所有簇心的距離，任一點的分類以其距離最近的簇心確定。依此原理計算出所有點的分類後，對每個分類計算新的簇心。

定義函數預測分類
根據訓練得到的簇心，預測輸入新的數據特徵的分類。

開始訓練
隨機生成一個簇心，並訓練 15 次。

繪制聚類結果
以最後一次訓練得到的簇心為基礎，進行行星的分類，並以等高面的形式繪制各類的邊界。

從運行結果可以看出，所有行星被分成了兩類。並通過上三角和下三角標注了每個類別的簇心位置。
聚類前
以下輸出了聚類前原始數據繪制的圖像。

Ⅲ python庫skimage 實現canny邊緣探測

請參考： Canny演算法python手動實現
請參考： Canny邊緣檢測演算法原理及opencv實現

skimage.feature.canny(image, sigma=1.0, low_threshold=None, high_threshold=None, mask=None, use_quantiles=False)
sigma：高斯濾波器的標准差
low_threshold：Canny演算法最後一步中，小於該閾值的像素直接置為0
high_threshold：Canny演算法最後一步中，大於該閾值的像素直接置為255

Ⅳ Python模塊的幾種類型簡介

view plain to clipboardprint?
import os
import stat
import time<DIV></DIV>

fileStats = os.stat ( 'test.txt' )
fileInfo = {
'Size' : fileStats [ stat.ST_SIZE ],
'LastModified' : time.ctime ( fileStats [ stat.ST_MTIME ] ),
'LastAccessed' : time.ctime ( fileStats [ stat.ST_ATIME ] ),
'CreationTime' : time.ctime ( fileStats [ stat.ST_CTIME ] ),
'Mode' : fileStats [ stat.ST_MODE ]
}

for infoField, infoValue in fileInfo:
print infoField, ':' + infoValue
if stat.S_ISDIR ( fileStats [ stat.ST_MODE ] ):
print 'Directory. '
else:
print 'Non-directory.'

import os
import stat
import time

fileStats = os.stat ( 'test.txt' )
fileInfo = {
'Size' : fileStats [ stat.ST_SIZE ],
'LastModified' : time.ctime ( fileStats [ stat.ST_MTIME ] ),
'LastAccessed' : time.ctime ( fileStats [ stat.ST_ATIME ] ),
'CreationTime' : time.ctime ( fileStats [ stat.ST_CTIME ] ),
'Mode' : fileStats [ stat.ST_MODE ]
}

for infoField, infoValue in fileInfo:
print infoField, ':' + infoValue
if stat.S_ISDIR ( fileStats [ stat.ST_MODE ] ):
print 'Directory. '
else:
print 'Non-directory.'

Ⅳ 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 dict怎麼實現的

Python中dict對象是表明了其是一個原始的Python數據類型，按照鍵值對的方式存儲，其中文名字翻譯為字典，顧名思義其通過鍵名查找對應的值會有很高的效率，時間復雜度在常數級別O(1).dict底層實現（推薦學習：Python視頻教程）
在Python2中，dict的底層是依靠哈希表(Hash Table)進行實現的，使用開放地址法解決沖突.
所以其查找的時間復雜度會是O(1).
Dict的操作實現原理（包括插入、刪除、以及緩沖池等）
首先介紹：PyDictObject對象的元素搜索策略：
有兩種搜索策略，分別是lookdict和lookdict_string，lookdict_string就是lookdict在對於PyStringObject進行搜索時的特殊形式，那麼通用的搜索策略lookdict的主要邏輯是：
（1）對第一個entry的查找：
a)根據hash值獲得entry的索引
b)若entry處於unused態，則搜索結束；若entry所指向的key與搜索的key相同，則搜索成功
c)若當前entry處於mmy態，則設置freeslot（這里的freeslot是可以返回作為下一個立即可用的地址來存儲entry）
d)檢查Active態的entry，若其key所指向的值與搜索的值相同，則搜索成功
（2）對剩餘的探測鏈中的元素的遍歷查找：
a)根據所採用的探測函數，獲得探測鏈上的下一個待檢查的entry
b)檢查到一個unused態的entry，表明搜索失敗：
如果freeslot不為空，則返回freeslot；否則返回unused態的entry
c)檢查entry的key與所搜索的key的引用是否相同，相同則搜索成功，返回entry
d)檢查entry的key與所搜索的key的值是否相同，相同則搜索成功，返回entry
e)遍歷過程中，發現mmy態的entry，且freeslot未設置，則設置freeslot
接下來是：PyDictObject對象的元素插入與刪除的策略：
需要首先用到搜索策略，搜索成功，則直接將值進行替換，搜索失敗，返回unused態或mmy態的entry，設置key、value和hash值，並且根據目前插入的元素情況進行ma_table的大小的調整（調整的依據就是裝載率，根據是否大於2/3來進行調整）；刪除也是類似，先計算hash值，然後搜索相應的entry，搜索成功，刪除entry中維護的元素，將entry從Active態修改為mmy態

在PyDictObject的實現過程中，會用到緩沖池，在PyDictObject對象被銷毀的時候，才開始接納被緩沖的PyDictObject對象，定義的緩沖池可接納的對象數量是80個，創建新PyDictObject對象的時候，如果緩沖池中有，則可以直接從緩沖池中取出使用
更多Python相關技術文章，請訪問Python教程欄目進行學習！以上就是小編分享的關於python dict怎麼實現的的詳細內容希望對大家有所幫助，更多有關python教程請關注環球青藤其它相關文章！

Ⅶ Python：報錯類型是typeerror：must be str not int，求解答

第一關於

super().__init__()

這種不指定子類的繼承方法是在Python 3中新加入的，因為你使用的是Python 2， 所以會報錯。


第二，關於TypeError，請題主在定義兩個父類的時候加入他們的父類(object)，如下，再嘗試一次，因為Python 2中的classobj不算做一種type，如果你用Python 3的話應該就沒有這種問題了。

classBase1(object):
def__init__(self):
print"我是Base1"

classBase2(object):
def__init__(self):
print"我是Base2"

另外一點題外話，題主對Base這個子類採用了雙重繼承，即此子類同時擁有兩個父類（Base1和Base2），這種繼承方法有時容易造成混亂，即如果兩個父類有相同的方法名或變數名時，無法確定應繼承哪一個。因此在諸如Java等語言中多重繼承是不允許的。Python允許多重繼承，但在這種情況下為了避免混亂，Python會自動按順序選擇擁有所需方法名的第一個父類並執行，而忽略其他父類中的同名方法。比如你的

classBase(Base1,Base2):
def__init__(self):
super(Base,self).__init__()

中，使用

super(Base,self).__init__()

來呼叫Base父類的__init__方法，由於Base的父類有兩個（Base1和Base2），並且兩個都有__init__方法，所以Python默認只按順序呼叫Base1的__init__方法而忽略Base2的。這樣你運行

bbbb=Base()

時就只會顯示

我是Base1

而不會顯示「我是Base2」。如果你要使用super()方法並希望像使用

classBase(Base1,Base2):
def__init__(self):
Base1.__init__(self)
Base2.__init__(self)

時一樣同時輸出「我是Base1」和「我是Base2」的話，你需要修改代碼使Base2為Base1的子類，Base為Base2的子類才可以。如下：

classBase1(object):
def__init__(self):
print"我是Base1"

classBase2(Base1):
def__init__(self):
super(Base2,self).__init__()
print"我是Base2"

classBase(Base2):
def__init__(self):
super(Base,self).__init__()

這樣你運行

bbbb=Base()

時才會輸出

我是Base1
我是Base2

Ⅷ 如何用Python編寫一個素數環

此文主要目的，是向大家展示如何才能用python語言，來部署STARK演算法。
STARKs（可擴容的透明知識論證）是創建一種證明的技術，這項證明中f(x)=y，其中f可能要花很長的時間來進行計算，但是這個證明可以被很快驗證。STARK是「雙重擴容」：對於一個需要t步驟的計算，這會花費大約O(t * log(t))步驟才能完成這個證明，這可能是最優的情況，而且這需要通過~O(log2(t))個步驟才能驗證，對於中等大小的T值，它比原始計算快得多。STARKs也擁有隱私保護的「零知識證明」的特性，雖然我們將這類使用案例應用到其中，從而完成可驗證的延遲功能，不需要這類性質，所以我們不用擔心。
首先，先請幾項說明：
這個代碼還沒有完全審核；在實際使用案例中的情況，還不能保證
這部分代碼是還沒有達到理想狀態（是用Python語言寫的）
STARKs 的「真實情況」 傾向於使用二進制欄位而不是素數域的特定應用程序效率的原因；但是，他們確實也表現出，這里寫出的代碼是合法並且可用的。
沒有一個真實的方法來使用STARK。它是一個非常寬泛的加密和數學架構，同時為不同的應用有不同的設置，以及連續的研究來減少證明者和驗證者的復雜性，同時提高可用性。
此文希望大家能夠知道，模運算和素數域是如何運行的，
並且和多項式概念，插值和估值進行結合。
現在，讓我們一起來了解吧！
MIMC
下面是STARK的功能展示：
def mimc(inp, steps, round_constants): start_time = time.time() for i in range(steps-1): inp = (inp**3 + round_constants[i % len(round_constants)]) % molus print("MIMC computed in %.4f sec" % (time.time() - start_time)) return inp
我們選擇MIMC作為案例，因為它（i）很容易理解，（ii）在真實世界使用的很多。函數功能見下圖：
注意：在很多關於MIMC的討論中，你可以典型地看出使用了XOR，而不是+；這是因為MIMC可以在二進制情況下使用，其中添加是XOR；這里我們會在素數領域進行。
在我們的案例中，常數相對而言會是比較小的列表（例如，64位），這會一直連續地進行周期循環（也就說，在k[64]之後）。MIMC自身可以獲得這個特性，因為MIMC可以向後進行計算（從相應的輸出獲得輸入），但是往後計算需要比向前計算多花費100倍的時間（並且沒有方向可以同步進行）。所以你可以將往後計算的功能想像成計算不能同步的工作量證明，並且往前方向計算的功能可以作為驗證的過程。
x -> x(2p-1)/3 是x -> x3 的反函數；根據費馬小定理，這是真實的，盡管這個定理沒有費馬大定理出名，但是依然對數學的貢獻很大。
我們嘗試使用STARK來進行更加有效的驗證，而不是讓驗證者必須在向前方向運行MIMC，在完成向後計算之後，證明者可以在向前方向進行STARK計算，並且驗證者可以很簡單地驗證STARK。我們希望計算STARK可以比MIMC向前和向後之間的運行速度差別要小，所以證明者的時間仍然是有初始的向後計算來主導的。而並不是STARK計算。STARK的認證會相對較快（在python語言演算法中，可以是0.05-0.3秒），不論初始的計算時間有多長。
所有的計算會在2256 – 351 * 232 + 1個模內完成；我們使用素數模，因為它是小於2256 最大的素數，其中乘法群包含了232 個子集（也就是說，有這樣一個數g，從而在完全232次循環之後，G素數環的連續冪模繞回到1），而且是按照6k+5的形式。首個特性是保證FFT和FRI演算法的有效版本，其次是保證MIMC實際上可以向後計算（請見上面提到的x -> x(2p-1)/3 使用方法）。
素域操作
我們通過建立方便的等級來進行素域的操作，同時也有多項式的操作。代碼如下，收首先是小數位數：
class PrimeField(): def __init__(self, molus): # Quick primality test assert pow(2, molus, molus) == 2 self.molus = molus def add(self, x, y): return (x+y) % self.molus def sub(self, x, y): return (x-y) % self.molus def mul(self, x, y): return (x*y) % self.molus
並且使用擴展歐幾里得演算法，來計算模塊逆轉（這和在素域中計算1/x相同）：
# Molar inverse using the extended Euclidean algorithm def inv(self, a): if a == 0: return 0 lm, hm = 1, 0 low, high = a % self.molus, self.molus while low > 1: r = high//low nm, new = hm-lm*r, high-low*r lm, low, hm, high = nm, new, lm, low return lm % self.molus
上面的演算法是相對昂貴的；幸運地是，對於特定的案例，我們需要做很多的模逆計算，有一個數學方法可以讓我們來計算很多逆運算，被稱為蒙哥馬利批量求逆：
使用蒙哥馬利批量求逆來計算模逆，其輸入為紫色，輸出為綠色，乘法門為黑色，紅色方塊是唯一的模逆。
下面的代碼是演算法的體現，其中包含一些特別的邏輯。如果我們正在求逆的集合中包含零，那麼它會將這些零的逆設置為 0 並繼續前進。
def multi_inv(self, values): partials = [1] for i in range(len(values)): partials.append(self.mul(partials[-1], values[i] or 1)) inv = self.inv(partials[-1]) outputs = [0] * len(values) for i in range(len(values), 0, -1): outputs[i-1] = self.mul(partials[i-1], inv) if values[i-1] else 0 inv = self.mul(inv, values[i-1] or 1) return outputs
這部分演算法接下來會驗證稱為非常重要的東西，特別是當我們開始和不同階的多項式進行計算的時候。
現在我們來看看一些多項式計算。我們把多項式當做一個數據集，其中的i是第i階（例如，x3 + 2x + 1變成[1, 2, 0, 1]）。下面就是在一個點進行多項式估算的方法：
# Evaluate a polynomial at a point def eval_poly_at(self, p, x): y = 0 power_of_x = 1 for i, p_coeff in enumerate(p): y += power_of_x * p_coeff power_of_x = (power_of_x * x) % self.molus return y % self.molus
困難和挑戰
f.eval_poly_at([4, 5, 6], 2)的輸出是多少？模是31嗎？
下面的解釋就是答案
.其實也有代碼是多項式加法，減法，乘法和除法；這是很長的加減乘除運算。有一個很重要的內容是拉格朗日插值，它將一組 x 和 y 坐標作為輸入，並返回通過所有這些點的最小多項式（你可以將其視為多項式求值的逆）：
# Build a polynomial that returns 0 at all specified xs def zpoly(self, xs): root = [1] for x in xs: root.insert(0, 0) for j in range(len(root)-1): root[j] -= root[j+1] * x return [x % self.molus for x in root] def lagrange_interp(self, xs, ys): # Generate master numerator polynomial, eg. (x - x1) * (x - x2) * ... * (x - xn) root = self.zpoly(xs) # Generate per-value numerator polynomials, eg. for x=x2, # (x - x1) * (x - x3) * ... * (x - xn), by dividing the master # polynomial back by each x coordinate nums = [self.div_polys(root, [-x, 1]) for x in xs] # Generate denominators by evaluating numerator polys at each x denoms = [self.eval_poly_at(nums[i], xs[i]) for i in range(len(xs))] invdenoms = self.multi_inv(denoms) # Generate output polynomial, which is the sum of the per-value numerator # polynomials rescaled to have the right y values b = [0 for y in ys] for i in range(len(xs)): yslice = self.mul(ys[i], invdenoms[i]) for j in range(len(ys)): if nums[i][j] and ys[i]: b[j] += nums[i][j] * yslice return [x % self.molus for x in b]
相關數學知識請參見此文的M-N部分。需要注意，我們也會有特別的方法lagrange_interp_4和lagrange_interp_2來加速次數小於 2 的拉格朗日插值和次數小於 4 的多項式運算。
快速傅立葉變換
如果你仔細閱讀上面的演算法，你也許會發現拉格朗日插值和多點求值（即求在N個點處次數小於N的多項式的值）都需要耗費2次時間，例如對於1000個點求拉格朗日插值，需要幾百萬個步驟，而且100萬個點的拉格朗日插值需要萬億個步驟。這是不可接受的低效率，所以我們需要使用更加有效的演算法，快速傅立葉變換。
FFT只需要花費O(n * log(n))的時間（也就是說，1000個點的計算需要10,000步，100萬個點的計算需要2000步），雖然它的范圍更受限制；x坐標必須是單位根部的完全集合，必須滿足N = 2k 階。也就是說，如果有N個點，那麼x坐標必須某個P值的連續冪，1, p, p2, p3…，其中pN = 1。這個演算法能夠用來進行多點計算和插值計算，而且只需要調整一個小參數。
下面就是演算法詳情（這是個簡單的表達方式；更詳細內容可以參閱此處代碼）
def fft(vals, molus, root_of_unity): if len(vals) == 1: return vals L = fft(vals[::2], molus, pow(root_of_unity, 2, molus)) R = fft(vals[1::2], molus, pow(root_of_unity, 2, molus)) o = [0 for i in vals] for i, (x, y) in enumerate(zip(L, R)): y_times_root = y*pow(root_of_unity, i, molus) o[i] = (x+y_times_root) % molus o[i+len(L)] = (x-y_times_root) % molus return o def inv_fft(vals, molus, root_of_unity): f = PrimeField(molus) # Inverse FFT invlen = f.inv(len(vals)) return [(x*invlen) % molus for x in fft(vals, molus, f.inv(root_of_unity))]
你可以自己通過一些輸入來運行代碼，並且看看是否能得到想要的結果，當你使用eval_poly_at的時候，給出你期望得到的答案。例如：
>>> fft.fft([3,1,4,1,5,9,2,6], 337, 85, inv=True) [46, 169, 29, 149, 126, 262, 140, 93] >>> f = poly_utils.PrimeField(337) >>> [f.eval_poly_at([46, 169, 29, 149, 126, 262, 140, 93], f.exp(85, i)) for i in range(8)] [3, 1, 4, 1, 5, 9, 2, 6]
傅里葉變換會把[x[0] …. x[n-1]]作為輸入，並且它的目標是輸出x[0] + x[1] + … + x[n-1]作為首個元素，x[0] + x[1] * 2 + … + x[n-1] * w**(n-1)作為第二個元素，等等；快速傅里葉變換可以通過把數據分為兩半，來完成這個，在兩邊都進行FFT，然後將結果結合在一起。
上圖就是信息如何進行FFT運算的解釋。請注意FFT是如何進行兩次數據復制，並且進行粘合，直到你得到一個元素。
現在，我們把所有部分組合起來，看看整件事情是如何：def mk_mimc_proof(inp, steps, round_constants)，它生成運行 MIMC 函數的執行結果的證明，其中給定的輸入為步驟數。首先，是一些 assert 函數：
# Calculate the set of x coordinates xs = get_power_cycle(root_of_unity, molus) column = [] for i in range(len(xs)//4): x_poly = f.lagrange_interp_4( [xs[i+len(xs)*j//4] for j in range(4)], [values[i+len(values)*j//4] for j in range(4)], ) column.append(f.eval_poly_at(x_poly, special_x))
擴展因子是我們將要拉伸的計算軌跡（執行 MIMC 函數的「中間值」的集合）。
m2 = merkelize(column) # Pseudo-randomly select y indices to sample # (m2[1] is the Merkle root of the column) ys = get_pseudorandom_indices(m2[1], len(column), 40) # Compute the Merkle branches for the values in the polynomial and the column branches = [] for y in ys: branches.append([mk_branch(m2, y)] + [mk_branch(m, y + (len(xs) // 4) * j) for j in range(4)])
我們需要步數乘以擴展因子最多為 2^32，因為當 k > 32 時，我們沒有 2^k 次的單位根。
computational_trace_polynomial = inv_fft(computational_trace, molus, subroot) p_evaluations = fft(computational_trace_polynomial, molus, root_of_unity)
我們首個計算會是得出計算軌跡；也就是說，所有的計算中間值，從輸入到輸出。
assert steps <= 2**32 // extension_factor assert is_a_power_of_2(steps) and is_a_power_of_2(len(round_constants)) assert len(round_constants) < steps
然後，我們會從將計算軌跡轉換為多項式，在單位根 g （其中，g^steps = 1）的連續冪的軌跡上「放下」連續值，然後我們對更大的集合——即單位根 g2 的連續冪，其中 g2^steps * 8 = 1（注意 g2^8 = g）的多項式求值。
# Generate the computational trace computational_trace = [inp] for i in range(steps-1): computational_trace.append((computational_trace[-1]**3 + round_constants[i % len(round_constants)]) % molus) output = computational_trace[-1]
黑色： g1 的冪。紫色： g2 的冪。橙色：1。你可以將連續的單位根看作一個按這種方式排列的圓圈。我們沿著 g1的冪「放置」計算軌跡，然後擴展它來計算在中間值處（即 g2 的冪）的相同多項式的值。
我們可以將MIMC的循環常數轉換為多項式。因為這些循環常數鏈是非常通常發生地（在我們的測試中，每64個步驟都會進行），最終證明他們形成了64階的多項式，而且外面可以很容易計算出它的表達式，以及擴展式：
skips2 = steps // len(round_constants) constants_mini_polynomial = fft(round_constants, molus, f.exp(subroot, skips2), inv=True) constants_polynomial = [0 if i % skips2 else constants_mini_polynomial[i//skips2] for i in range(steps)] constants_mini_extension = fft(constants_mini_polynomial, molus, f.exp(root_of_unity, skips2))
假設其中有8192個步驟，並且有64個循環常數。這是我們想要做的：我們正在進行FFT，從而計算循環常數來作為g1128 的功能。然後我們在之間加入很多零，來完成g1本身的功能。因為g1128 大約每64步進行循環，我們知道g1這個功能也會同樣。我們只計算這個擴展中的512個步驟，因為我們知道這個擴展會在每512步之後重復。現在，我們按照斐波那契案例中那樣，計算C(P(x))，除了這次是計算，需要注意，我們不在計算使用系數形式的多項式；而是根據高次單位根的連續冪來對多項式進行求值。
c_of_p需要滿足Q(x) = C(P(x), P(g1*x)，K(x)) = P(g1*x) – P(x)**3 – K(x)；目標是對於任何我們放入計算軌道的x（除了最後一步，因為在最後一步之後，就沒有步驟），計算軌跡中的下個數值就和之前的相等，再加上循環常量。與第1部分中的斐波那契示例不同，其中如果某個計算步驟是在k向量，下個就會是k+1向量，我們把低次單位根（ g1 ）的連續冪放下計算軌跡，所以如果某個計算步驟是在x = g1i ，下個步驟就會在g1i+1 = g1i * g1 = x * g1。因此，對於低階單位根（ g1 ）的每一個冪，我們希望最終會是P(x*g1) = P(x)**3 + K(x)，或者P(x*g1) – P(x)**3 – K(x) = Q(x) = 0。因此，Q(x) 會在低次單位根 g 的所有連續冪上等於零（除了最後一個）。
# Create the composed polynomial such that # C(P(x), P(g1*x), K(x)) = P(g1*x) - P(x)**3 - K(x) c_of_p_evaluations = [(p_evaluations[(i+extension_factor)%precision] - f.exp(p_evaluations[i], 3) - constants_mini_extension[i % len(constants_mini_extension)]) % molus for i in range(precision)] print('Computed C(P, K) polynomial')
有個代數定理證明，如果Q(x)在所有這些x坐標，都等於零，那麼最小多項式的乘積就會在所有這些x坐標等於零：Z(x) = (x – x_1) * (x – x_2) * … * (x – x_n)。通過證明在任何單個的坐標，Q(x)是等於零，我們想要證明這個很難，因為驗證這樣的證明比運行原始計算需要耗費更長的時間，我們會使用一個間接的方式來證明Q(x)是Z(x)的乘積。並且我們會怎麼做呢？通過證明D(x) = Q(x) / Z(x)，並且使用FRI來證明它其實是個多項式，而不是個分數。
我們選擇低次單位根和高次單位根的特定排列，因為事實證明，計算Z(x)，而且除以Z(x)也十分簡單：Z 的表達式是兩項的一部分。
需要注意地是，直接計算Z的分子和分母，然後使用批量模逆的方法將除以Z轉換為乘法，隨後通過 Z(X) 的逆來逐點乘以 Q(x) 的值。需要注意，對於低次單位根的冪，除了最後一個，都可以得到Z(x) = 0，所以這個計算包含其逆計算就會中斷。這是非常不幸的，雖然我們會通過簡單地修改隨機檢查和FRI演算法來堵住這個漏洞，所以就算我們計算錯誤，也沒關系。
因為Z(x)可以簡潔地表達，我們也可以獲得另個好處：驗證者對於任何特別的x，可以快速計算Z(x)，而且還不需要任何提前計算。對於證明者來說，我們可以接受證明者必須處理大小等於步數的多項式，但我們不想讓驗證者做同樣的事情，因為我們希望驗證過程足夠簡潔。
# Compute D(x) = Q(x) / Z(x) # Z(x) = (x^steps - 1) / (x - x_atlast_step) z_num_evaluations = [xs[(i * steps) % precision] - 1 for i in range(precision)] z_num_inv = f.multi_inv(z_num_evaluations) z_den_evaluations = [xs[i] - last_step_position for i in range(precision)] d_evaluations = [cp * zd * zni % molus for cp, zd, zni in zip(c_of_p_evaluations, z_den_evaluations, z_num_inv)] print('Computed D polynomial')
在幾個隨機點上，進行概念檢測D(x) * Z(x) = Q(x)，從而可以驗證轉賬約束，每個計算步驟是之前步驟的有效結果。但是我們也想驗證邊界約束，其中計算的輸入和輸出就是證明者所說的那樣。只是要求證明者提供P(1), D(1), P(last_step)還有D(last_step)的數值，這些都是很脆弱的；沒有證明，那些數值都是在同個多項式。所以，我們使用類似的多項式除法技巧：
# Compute interpolant of ((1, input), (x_atlast_step, output)) interpolant = f.lagrange_interp_2([1, last_step_position], [inp, output]) i_evaluations = [f.eval_poly_at(interpolant, x) for x in xs] zeropoly2 = f.mul_polys([-1, 1], [-last_step_position, 1]) inv_z2_evaluations = f.multi_inv([f.eval_poly_at(quotient, x) for x in xs]) # B = (P - I) / Z2 b_evaluations = [((p - i) * invq) % molus for p, i, invq in zip(p_evaluations, i_evaluations, inv_z2_evaluations)] print('Computed B polynomial')
那麼，我們的論證如下。證明者想要證明P(1) == input和P(last_step) == output。如果我們將I(x)作為插值，那麼就是穿越(1, input)和(last_step, output)亮點的線，於是P(x) – I(x)就會在這亮點上等於零。因此，它會證明P(x) – I(x)是P(x) – I(x)的乘積，並且我們通過提高商數來證明這點。
紫色：計算軌跡多項式 (P) 。綠色：插值 (I)（注意插值是如何構造的，其在 x = 1 處等於輸入（應該是計算軌跡的第一步），在 x=g^(steps-1) 處等於輸出（應該是計算軌跡的最後一步）。紅色：P-I。黃色：在x = 1和 x=g^(steps-1)（即 Z2）處等於 0 的最小多項式。粉紅色：(P – I) / Z2。
現在，我們來看看將P，D和B的默克爾根部組合在一起。
現在，我們需要證明P，D和B其實都是多項式，並且是最大的正確階數。但是FRI證明是很大且昂貴的，而且我們不想有三個FRI證明，所以，我們計算 P，D 和 B 的偽隨機線性組合，並且基於它來進行FRI證明：
# Compute their Merkle roots mtree = merkelize([pval.to_bytes(32, 'big') + dval.to_bytes(32, 'big') + bval.to_bytes(32, 'big') for pval, dval, bval in zip(p_evaluations, d_evaluations, b_evaluations)]) print('Computed hash root')
除非所有這三個多項式有正確的低階，不然幾乎不可能有隨機選擇的線性組合，所以這很足夠。
我們想要證明D的階數小於2 * steps，而且P 和 B 的次數小於steps，所以我們其實使用了隨機的P, P * xsteps, B, Bsteps 和 D的隨機組合，並且可以看出這部分組合是小於2 * steps。
現在，我們來檢查下所有的多項式組合。我們先獲得很多隨機的索引，然後在這些索引上為默克爾樹枝提供多項式：
k1 = int.from_bytes(blake(mtree[1] + b'\x01'), 'big') k2 = int.from_bytes(blake(mtree[1] + b'\x02'), 'big') k3 = int.from_bytes(blake(mtree[1] + b'\x03'), 'big') k4 = int.from_bytes(blake(mtree[1] + b'\x04'), 'big') # Compute the linear combination. We don't even bother calculating it # in coefficient form; we just compute the evaluations root_of_unity_to_the_steps = f.exp(root_of_unity, steps) powers = [1] for i in range(1, precision): powers.append(powers[-1] * root_of_unity_to_the_steps % molus) l_evaluations = [(d_evaluations[i] + p_evaluations[i] * k1 + p_evaluations[i] * k2 * powers[i] + b_evaluations[i] * k3 + b_evaluations[i] * powers[i] * k4) % molus for i in range(precision)]
get_pseudorandom_indices函數會回復[0…precision-1]范圍中的隨機索引，而且exclude_multiples_of參數並不會給出特定參數倍數的值。這就保證了，我們不會沿著原始計算軌跡進行采樣，否則就會獲得錯誤的答案。
證明是由一組默克爾根、經過抽查的分支以及隨機線性組合的低次證明組成：
# Do some spot checks of the Merkle tree at pseudo-random coordinates, excluding # multiples of `extension_factor` branches = [] samples = spot_check_security_factor positions = get_pseudorandom_indices(l_mtree[1], precision, samples, exclude_multiples_of=extension_factor) for pos in positions: branches.append(mk_branch(mtree, pos)) branches.append(mk_branch(mtree, (pos + skips) % precision)) branches.append(mk_branch(l_mtree, pos)) print('Computed %d spot checks' % samples)
整個證明最長的部分是默克爾樹分支，還有FRI證明，這是有更多分支來組成的。這是驗證者的實質結果：
o = [mtree[1], l_mtree[1], branches, prove_low_degree(l_evaluations, root_of_unity, steps * 2, molus, exclude_multiples_of=extension_factor)]
在每個位置，證明者需要提供一個默克爾證明，從而讓驗證者能夠檢查這個默克爾證明，並且檢查C(P(x), P(g1*x), K(x)) = Z(x) * D(x)以及B(x) * Z2(x) + I(x) = P(x)（提醒：對於不在初始計算軌道上的x，Z(x)不會是零，所以C(P(x), P(g1*x), K(x)也不會是零)。驗證者也會檢查線性組合是正確的，然後調用。
for i, pos in enumerate(positions): x = f.exp(G2, pos) x_to_the_steps = f.exp(x, steps) mbranch1 = verify_branch(m_root, pos, branches[i*3]) mbranch2 = verify_branch(m_root, (pos+skips)%precision, branches[i*3+1]) l_of_x = verify_branch(l_root, pos, branches[i*3 + 2], output_as_int=True) p_of_x = int.from_bytes(mbranch1[:32], 'big') p_of_g1x = int.from_bytes(mbranch2[:32], 'big') d_of_x = int.from_bytes(mbranch1[32:64], 'big') b_of_x = int.from_bytes(mbranch1[64:], 'big') zvalue = f.div(f.exp(x, steps) - 1, x - last_step_position) k_of_x = f.eval_poly_at(constants_mini_polynomial, f.exp(x, skips2)) # Check transition constraints Q(x) = Z(x) * D(x) assert (p_of_g1x - p_of_x ** 3 - k_of_x - zvalue * d_of_x) % molus == 0 # Check boundary constraints B(x) * Z2(x) + I(x) = P(x) interpolant = f.lagrange_interp_2([1, last_step_position], [inp, output]) zeropoly2 = f.mul_polys([-1, 1], [-last_step_position, 1]) assert (p_of_x - b_of_x * f.eval_poly_at(zeropoly2, x) - f.eval_poly_at(interpolant, x)) % molus == 0 # Check correctness of the linear combination assert (l_of_x - d_of_x - k1 * p_of_x - k2 * p_of_x * x_to_the_steps - k3 * b_of_x - k4 * b_of_x * x_to_the_steps) % molus == 0
其實還沒有完成成功；證明對跨多項式檢查和 FRI 所需的抽查次數的可靠性分析是非常棘手的。但是這些就是所有代碼，至少你不用擔心進行瘋狂的優化。當我運行以上代碼的時候，我們會獲得STARK證明，會有300-400倍的證明成本例如，一個需要 0.2 秒的 MIMC 計算需要 60 秒來證明）。這就使得4核機器計算MIMC中的 STARK，實際上可以比後向計算 MIMC 更快。也就是說，在python語言，這會相對低效的實現，並且這也會證明運行時間比例會不同。同時，也值得指出，MIMC 的 STARK 證明成本非常低，因為MIMC幾乎是完美地可計算，它的數學形式很簡單。對於平均計算，會包含更少的清晰計算（例如，檢查一個數是大於還是小於另一個），其計算成本可能會更高，會有大約10000-50000倍。

Ⅸ 已知散列表長度為13，散列函數為H(key)=key % 11，處理沖突的方法為線性探測法

10%11=10 a[9]=10

8%11=8 a[7]=8

40%11=7 a[6]=40

27%11=5 a[4]=27

21%11=10

57%11=2 a[1]=57

46%11=2

23%11=1 a[0]=23

19%11=8

56%11=1

21和10沖突 且a[10]空 所以a[10]=21

46和57沖突 且a[2]空 所以 a[2]=46

19和8沖突 且a[8]空 所以 a[8]=19

56和23沖突 且a[1]、a[2]不空，a[3]空 a[3]=56

最後是23,57,46,56,27，空，40,8，19，10，21，空，空

查找成功的平均長度：6*1+3*2+1*3=15

查找不成功的平均長度：6+5+4+3+2+1+6+5+4+3+2+1=42

(9)雙重探測法python代碼擴展閱讀：

直接定址法

例如：有一個從1到100歲的人口數字統計表，其中，年齡作為關鍵字，哈希函數取關鍵字自身。

數字分析法

有學生的生日數據如下：

年.月.日

75.10.03

75.11.23

76.03.02

76.07.12

75.04.21

76.02.15

經分析，第一位，第二位，第三位重復的可能性大，取這三位造成沖突的機會增加，所以盡量不取前三位，取後三位比較好。

平方取中法

取關鍵字平方後的中間幾位為哈希地址。

折疊法

將關鍵字分割成位數相同的幾部分（最後一部分的位數可以不同），然後取這幾部分的疊加和（捨去進位）作為哈希地址，這方法稱為折疊法。

例如：每一種西文圖書都有一個國際標准圖書編號，它是一個10位的十進制數字，若要以它作關鍵字建立一個哈希表，當館藏書種類不到10,000時，可採用此法構造一個四位數的哈希函數。

除留余數法

取關鍵字被某個不大於哈希表表長m的數p除後所得余數為哈希地址。

H(key)=key MOD p (p<=m)

隨機數法

選擇一個隨機函數，取關鍵字的隨機函數值為它的哈希地址，即

H(key)=random(key），其中random為隨機函數。通常用於關鍵字長度不等時採用此法。

若已知哈希函數及沖突處理方法，哈希表的建立步驟如下：

Step1.取出一個數據元素的關鍵字key，計算其在哈希表中的存儲地址D=H(key）。若存儲地址為D的存儲空間還沒有被佔用，則將該數據元素存入；否則發生沖突，執行Step2。

Step2.根據規定的沖突處理方法，計算關鍵字為key的數據元素之下一個存儲地址。若該存儲地址的存儲空間沒有被佔用，則存入；否則繼續執行Step2，直到找出一個存儲空間沒有被佔用的存儲地址為止。

Ⅹ python3 獲取title的編寫

水平有限，不會造輪子，只為學習。

在原來寫埠掃描的基礎上進一步爬取web服務的title信息，方便收集信息。
適用於在外網收集資產形成IP字典後去批量獲取title，意在最快地尋找脆弱點。
自行安裝BeautifulSoup4、requests庫。
V1.0
python3 寫的單線程爬取web系統的title信息。
註解
1.使用BeautifulSoup4庫來解析HTML，爬取title信息；
2.列印title時，帶有顏色的輸出；
3.在開放443、4433、8443埠時，採用https進行訪問；
4.解決SSL認證問題；

V1.0.1
python3 單線程寫的爬取網站title信息。增加了OptionParser模塊，運行時看起來比較舒服。
註解
1.依然是從IP字典里爬取，實際運行腳本時，即使沒有獲取title，也應該手動訪問開放的埠，往往有意外驚喜；
2.埠內置在腳本里，可自行修改；

V1.1
python3寫的多線程爬取web系統的title。
註解
1.只是使用threading模塊，沒有添加到隊列，也沒有加鎖；本身port_list也不多；

V1.2
python3 寫的多線程加隊列的來爬取web系統的title信息。
註解
1.增加了queue隊列，和多線程配合使用。更加實用；

V1.3
python3 寫的多線程加隊列的來爬取web系統的title信息。
增加result輸出結果到文本，適應於內外網埠掃描並獲取title

python3 編寫掃描IP網段如192.168.1.0/24某些指定應用埠爬取title信息。 在代理進行內網滲透時內網資產不容易找到。
適用於內網、外網環境。
自行安裝BeautifulSoup4、requests庫。
V2.0
python3寫的掃描IP段並爬取title信息，收集資產。
註解
1.使用ipaddress模塊獲取C段地址，也可以是B段；
2.只使用threading模塊，沒有添加隊列queue；

V2.1
python3 寫的多線程掃描IP段爬取title。在一定線程下，代理探測內網資產title的非常使用。
註解
1.port_list列表移動到scan方法里；
2.將IP添加到queue隊列，而不是埠；

V2.2
python3 寫的多線程掃描IP段爬取title。
註解
1.只是增加了result_out方法，將結果輸出到指定文件；

https://github.com/aedoo/WebServiceScanner/blob/master/webservicescanner.py