2. 程式人生 > 實用技巧 >zookeeper實現分散式鎖的原理和一個小例子

zookeeper實現分散式鎖的原理和一個小例子

阿新 • • 發佈：2020-11-28

  1. python 不支援複數轉換為整數或浮點數

    >>> float(4.5+0j)
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    float(4.5+0j)
TypeError: can't convert complex to float

>>> int(4+0j)
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    int(4+0j)
TypeError: can't convert complex to int
>>>

  2. 隨機數函式中缺少 randint,sample

    random.randint(x,y)　#隨機生一個整數int型別，可以指定這個整數的範圍

    例項

    >>> random.randint(1000,9999)
8449

    random.sample(sequence,length) 可以從指定的序列中，隨機的擷取指定長度的片斷，不修改原序列。

    例項

    >>> lst = random.sample('abcd1234',4)
>>> strs = ''.join(lst)
>>> strs
'a432'
>>>
     
  3. print(round(10.4)) #10
print(round(10.5)) #10
print(round(10.6)) #11
print()
print(round(11.4)) #11
print(round(11.5)) #12
print(round(11.6)) #12

    由執行得出結論：

    1. 當小數點左邊為偶數：小數點右邊X<6，舍
    2. 當小數點左邊為偶數：小數點右邊X>=6，入
    3. 當小數點左邊為奇數：小數點右邊X<5，舍
    4. 當小數點左邊為奇數：小數點右邊X>=5，入

    所以當小數點左邊分別為奇數和偶數的時候，小數點右邊的取捨也分別對應兩種取捨標準！

  4. 關於round,接力分析，結論如下：

    當個位為奇數，小數部分>=0.5入，其餘為舍

    當個位為偶數，小數部分>0.5入，其餘為舍。

    互動模式下的 example:

    >>> round(10.49)
10
>>> round(10.50)
10
>>> round(10.51)
11
>>> round(11.50)
12
>>> round(11.49)
11

  5. “4舍6入5看齊,奇進偶不進”我覺得並不是因為浮點數在計算機表示的問題。計算機浮點數的表示是 ieee定義的標準規則，如果 python中存在，沒道理其他語言中不存在。事實上是因為該取捨方法比過去的 "四捨五入"方法在科學計算中更準確。而國家標準也已經規定使用 “4舍6入5看齊,奇進偶不進”取代"四捨五入".

    從統計學的角度上來講,如果大量資料無腦的採用四捨五入會造成統計結果偏大。而"奇進偶舍"可以將舍入誤差降到最低。

    奇進偶舍是一種比較精確比較科學的計數保留法，是一種數字修約規則。

    其具體要求如下（以保留兩位小數為例）：

    • （1）要求保留位數的後一位如果是4或者4以下的數字，則捨去， 例如 5.214保留兩位小數為5.21。
    • （2）如果保留位數的後一位如果是6或者6以上的數字，則進上去， 例如5.216保留兩位小數為5.22。
    • （3）如果保留位數是保留整數部分或保留一位小數，則要根據保留位來決定奇進偶舍： 
      >>> round(5.215,2)#實際並沒有進位
5.21
>>> round(5.225,2)
5.22
>>>
>>> round(1.5)#此處進位
2
>>> round(1.5)==round(2.5)#偶數捨去
True
>>> round(1.15,1)
1.1
>>> round(1.25,1)
1.2
>>> round(1.151,1)
1.2
>>> round(1.251,1)
1.3
    • (4) 如果保留位數的後一位如果是5，且該位數後有數字。則進上去，例如5.2152保留兩位小數為5.22，5.2252保留兩位小數為5.23，5.22500001保留兩位小數為5.23。
    從統計學的角度，“奇進偶舍”比“四捨五入”要科學，在大量運算時，它使舍入後的結果誤差的均值趨於零，而不是像四捨五入那樣逢五就入，導致結果偏向大數，使得誤差產生積累進而產生系統誤差，“奇進偶舍”使測量結果受到舍入誤差的影響降到最低。

  6. 針對前面有人提到複數不能強轉為int或者float的問題：

    其實在Python中，複數提供了2個函式，一個函式是real，返回複數的實數部分，另一個函式是imag，返回複數的虛數部分。因為實數跟複數是差異很大的型別，所以不支援強制轉換是可以理解的。因為在強制轉換過程中，虛數部分到底該怎麼轉換，是沒有定義的，而int和float只有實數部分，虛數部分該如何取捨？

    >>> a = 4.1+0.3j
>>> a
(4.1+0.3j)
>>> a.real
4.1
>>> a.imag
0.3

  7. Python3中已經不能使用cmp()函數了，被如下五個函式替代:

    import operator       #首先要匯入運算子模組

operator.gt(1,2)      #意思是greater than（大於）
operator.ge(1,2)      #意思是greater and equal（大於等於）
operator.eq(1,2)      #意思是equal（等於）
operator.le(1,2)      #意思是less and equal（小於等於）
operator.lt(1,2)      #意思是less than（小於）

  8. fractions 模組提供了分數型別的支援。

    建構函式： 
    class fractions.Fraction(numerator=0, denominator=1) 
class fractions.Fraction(int|float|str|Decimal|Fraction)

    可以同時提供分子（numerator）和分母（denominator）給建構函式用於例項化Fraction類，但兩者必須同時是int型別或者numbers.Rational型別，否則會丟擲型別錯誤。當分母為0，初始化的時候會導致丟擲異常ZeroDivisionError。

    分數型別：

    from fractions import Fraction

>>> x=Fraction(1,3)
>>> y=Fraction(4,6)
>>> x+y
Fraction(1, 1)

>>> Fraction('.25') 
Fraction(1, 4)

    浮點數與分數的轉換：

    >>> f=2.5
>>> z=Fraction(*f.as_integer_ratio())
>>> z
Fraction(5, 2)
>>> x=Fraction(1,3)
>>> float(x)
0.3333333333333333
>>>

  9. 小數物件:

    decimal 模組提供了一個 Decimal 資料型別用於浮點數計算，擁有更高的精度。

    >>> import decimal
>>> decimal.getcontext().prec=4              # 指定精度（4位小數）
>>> decimal.Decimal(1) / decimal.Decimal(7)
Decimal('0.1429')
>>> with decimal.localcontext() as ctx:      # 小數上下文管理器
...     ctx.prec=2
...     decimal.Decimal('1.00') / decimal.Decimal('3.00')
... 
Decimal('0.33')
>>>

  10. 關於Python整數比較的一些坑：

    Python中一切都是物件，物件比較可以用 == 或者 is。

    == 比較的是兩個物件的內容是否相等，預設會呼叫物件的 __eq__() 方法。

    is 比較的是兩個物件的 id 是否相等，也就是是否是同一個物件，是否指向同一個記憶體地址。

    >>> a = 4
>>> b = 4
>>> a == b
True
>>> a is b
True
>>> a = 256
>>> b = 256
>>> a == b
True
>>> a is b
True
>>> a = 257
>>> b = 257
>>> a == b
True
>>> a is b
False

    我們看到，前幾組比較我們都可以理解顯示的結果，但是最後當 a/b 都指向 257 這個整數物件的時候，用 is 比較以後的結果是 False。

    這是因為 Python 處於對效能的考慮，內部作了優化，對於整數物件，把一些頻繁使用的整數物件快取起來，儲存到一個叫 small_ints 的連結串列中。

    在 Python 整個生命週期中，任何需要引用這些整數物件的地方，都不再重新建立新的整數物件，範圍是 [-5,256]。

    再看下面這個例子 ：

    >>> a = 259
>>> def foo () :
...     b = 259
...     c = 259
...     print(a is b)
...     print(b is c)
...
>>> foo()
False
True

    這是因為 Python 程式都是由程式碼塊構成，程式碼塊作為程式的一個最小基本單位來執行。一個模組檔案/一個函式體/一個類/互動式命令中的單行程式碼都叫做一個程式碼塊。

    上面的程式中有兩部分程式碼塊，一個是名稱 a 所在的程式碼塊，一個是名稱 b/c 所在的程式碼塊。Python 的另一個優化的地方就是，如果在同一個程式碼塊中建立的兩個整數物件中，它們的值相等的話，那麼這兩個物件引用同一個整數物件。所以Python出於對效能的考慮，但凡是不可變的物件，在同一程式碼塊中，只有值相等的物件就不會重複建立，而是直接引用已經存在的物件。不僅整數物件，字串物件也遵循同樣的原則。

  11. 有時候在編寫程式的時候會用到進位制轉換，通常學校裡面教的都是取餘的方法其實有更加簡便的方法，這裡給大家分享一下。

    二進位制&十六進位制轉換表：

    十六進位制   0     1     2     3     4     5     6     7 
二進位制   0000  0001  0010  0011  0100  0101  0110  0111
十進位制     0     1     2     3     4     5     6     7
    十六進位制   8     9     A     B     C     D     E     F 
二進位制   1000  1001  1010  1011  1100  1101  1110  1111
十進位制     8     9     10    11    12    13    14    15

    把這個表牢牢記住！然後用下面的方法轉換，會有很高的效率。

    轉換方法：

    取四合一法：從二進位制小數點為分隔符，向左或向右每四位二進位制合為一位十六進位制。例子：

    1011| 1001 |1011.1001
  B     9     B .  9

    那最後的結果就是: b9b.9

    注意：換算時不足四位的情況，可以向左或向右補0。

  12. 關於小數的四捨五入問題與電腦的二進位制和十進位制之間轉換問題，這不僅是出現在小數上，也出現在一些除法上，例如：

    10/3=3.3333333333333335 而不是約等於 3.3333……:

    >>> 10/3
3.3333333333333335

    還有就是 0.1+0.1+0.1-0.3 不會等於 0，而是等於 5.551115123125783e-17:

    >>> 0.1+0.1+0.1-0.3
5.551115123125783e-17

  13. 補充上面關於 cmp() 函式的問題，官方文件中有如下描述： (If you really need the cmp() functionality, you could use the expression (a > b) - (a < b) as the equivalent for cmp(a,b).)

    補充上面關於round()函式的問題，注意下面例子：

    >>> round(1.05,1)
1.1
>>> round(1.15,1)
1.1
>>> round(1.55,1)
1.6
>>> round(2.05,1)
2.0
>>> round(2.15,1)
2.1
>>> round(2.55,1)
2.5

    官方的解釋是：這不是bug，而事關浮點數儲存：

    >>> from decimal import Decimal
>>> Decimal.from_float(1.05)
Decimal('1.0500000000000000444089209850062616169452667236328125')
>>> Decimal.from_float(1.15)
Decimal('1.149999999999999911182158029987476766109466552734375')
>>> Decimal.from_float(1.55)
Decimal('1.5500000000000000444089209850062616169452667236328125')
>>> Decimal.from_float(2.05)
Decimal('2.04999999999999982236431605997495353221893310546875')
>>> Decimal.from_float(2.15)
Decimal('2.149999999999999911182158029987476766109466552734375')
>>> Decimal.from_float(2.55)
Decimal('2.54999999999999982236431605997495353221893310546875')

    儘量避免使用round()。

  14. 數字與字元，列表之間的轉換

    1、字元轉為數字

    var='1234'
num=int(var) # 如果是小數可用 float

    2、字元轉為列表

    num_list=list(var)

    3、列表轉為陣列

    可以用 numpy 模組：

    import numpy as np

num_array=np.array(num_list)

    也可以是 num_array=[int(i) for i in num_list]。

  15. 一定要注意 += 和 =+ 的不同。

    例項 1：

    >>> a = 5
>>> a += 6
>>> a
11

    以上例項與下面例項的效果一樣：

    >>> a = 5
>>> a = a + 6
>>> a
11

    例項2：

    >>> b = 5
>>> b =+ 6
>>> b
6

    為什麼會是 6 而不是 11 呢? 因為例項2與下面程式碼一樣：

    >>> b = 5
>>> b = +6  # 其實就是正數，只是一個賦值操作，+ 6 即為 +6，+6 為 6
>>> b
6

    一定要分清 += 和 =+ 哦！另外要注意 Python 可是沒有 a++ 指令的！

  16. 其實準確的進位規則是二進位制浮點數的:

    >>> round(1.5,0) # 1.5d -> 0x3FF8000000000000 -> 1.5, 按照5後為0處理，奇進偶不進
2.0
>>> round(2.5,0) # 2.5 -> 0x4004000000000000 -> 2.5,  按照5後為0處理，奇進偶不進
2.0
>>> round(1.15,1) #1.15 ->0x3FF2666666666666 -> 1.14999999999999991118215802999 按照4處理，退位
1.1
>>> round(1.25,1) # 1.25 ->0x3FF4000000000000 ->1.25 同2.5退位
1.2
>>>

    可以認為進位首先計算的是與整數間的差距，如果差距相等，才會出現奇進偶不進。注意其中1.15由於進位制問題到1.1和1.2距離不同，所以不是十進位制的round結果。

    >>> abs(1.25-1.2)==abs(1.25-1.2)
True
>>> abs(1.15-1.2)==abs(1.15-1.1)
False

相關推薦

zookeeper實現分散式鎖的原理和一個小例子

Zookeeper分散式鎖-概念 •在我們進行單機應用開發，涉及併發同步的時候，我們往往採用synchronized（同步）或者Lock的方式來解決多執行緒間的程式碼同步問題，這時多執行緒的執行都是在同一個JVM之下，沒有任何問

ZooKeeper分散式專題(七)-- 使用zookeeper實現分散式鎖

ZooKeeper分散式專題與Dubbo微服務入門 zookeeper實現分散式鎖 什麼多執行緒 多執行緒為了能夠提高應用程式的執行效率，在一個程式中有多條不同的執行路徑，同時並行執行，互不影響。

Java redisson實現分散式鎖原理詳解

Redisson分散式鎖 之前的基於註解的鎖有一種鎖是基本redis的分散式鎖，鎖的實現我是基於redisson元件提供的RLock，這篇來看看redisson是如何實現鎖的。

使用Redis 或Zookeeper實現分散式鎖

最近在微信公眾號上看到一篇名為《分散式鎖用Redis還是Zookeeper?》的文章，感覺作者總結的很不錯，於是轉載過來，以便和大家一起學習！

ZooKeeper實現分散式鎖

目錄 ZooKeeper 的資料模型ZNode的四種類型Zookeeper實現分散式鎖獲取鎖釋放鎖操作完成，顯示釋放宕機

zk - zookeeper實現分散式鎖程式碼

技術標籤：zkzk 世界上並沒有完美的程式，但是我們並不因此而沮喪，因為寫程式不斷追求完美的過程。

JUC鎖框架原始碼閱讀-AQS+Zookeeper實現分散式鎖

介紹 1.建立一個永久節點 2.競爭鎖的時候同樣的的key 所有執行緒都往永久節點插入指定key name的臨時節點(節點不允許重複只會有一個插入成功)

Redis實現分散式鎖和等待序列的方法示例

在叢集下，經常會因為同時處理髮生資源爭搶和併發問題，但是我們都知道同步鎖synchronized 、cas 、ReentrankLock 這些鎖的作用範圍都是JVM ，說白了在叢集下沒啥用。這時我們就需要能在多臺JVM 之間決定執行順序的

詳細解讀分散式鎖原理及三種實現方式

目前幾乎很多大型網站及應用都是分散式部署的，分散式場景中的資料一致性問題一直是一個比較重要的話題。分散式的CAP理論告訴我們“任何一個分散式系統都無法同時滿足一致性（Consistency）、可用性（Availability）

基於redis實現分散式鎖的原理與方法

前言 系統的不斷擴大，分散式鎖是最基本的保障。與單機的多執行緒不一樣的是，分散式跨多個機器。執行緒的共享變數無法跨機器。

redis分散式鎖原理與實現

分散式鎖原理分散式鎖，是控制分散式系統之間同步訪問共享資源的一種方式。在分散式系統中，常常需要協調他們的動作。如果不同的系統或是同一個系統的不同主機之間共享了一個或一組資源，那麼訪問這些資源的時候，往

zookeeper實現分散式讀寫鎖

　　大多數應用程式在大部分時間都是在響應資料讀取事件，而資料的讀寫併發可能會帶來資料髒讀(讀執行緒在讀取的資料，寫執行緒已經修改但未提交)等問題，基於類似的可能會發生對同一個資源進行讀寫操作的場景，我們

基於zookeeper的分散式鎖實現

>>> 工作中需要寫一個定時任務,由於是叢集環境,自然而然想到需要通過分散式鎖來保證單臺執行..相信大家都會想到使用zk來實現對應的分散式鎖.下面就簡單介紹一下幾種實現

Redis實現簡單分散式鎖原理

基於Redis實現分散式所得簡單邏輯 最簡單邏輯： //注入 StringRedisTemplate stringRedisTemplate

Redisson實現分散式鎖(1)---原理

有關Redisson作為實現分散式鎖，總的分3大模組來講。 1、Redisson實現分散式鎖原理

redis 實現分散式鎖 和基本鎖

1 為什麼要使用鎖 執行以下程式碼 # 模擬多執行緒 import threading def change_it(n): global num

ZK（ZooKeeper）分散式鎖實現

點贊再看，養成習慣，微信搜尋【牧小農】關注我獲取更多資訊，風裡雨裡，小農等你。

Zookeeper Curator 框架實現分散式鎖

官方文件：https://curator.apache.org/index.html   依賴 <dependency><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId><version>3.5.7</ver

Redis 實現分散式鎖

在單節點情況下，實現執行緒安全需要靠同步狀態來控制。而在分散式應用中，使程式正確執行不被併發問題影響，就需要分散式鎖來控制。

SpringBoot + Redisson實現分散式鎖

一、什麼是分散式？ 要想說什麼是分散式，那麼首先要知道分散式之前的系統是什麼樣的架構，之前的架構又存在什麼樣的問題？