亚洲免费在线-亚洲免费在线播放-亚洲免费在线观看-亚洲免费在线观看视频-亚洲免费在线看-亚洲免费在线视频

經驗拾憶(純手工)=> Redis與Python操作Redis語法對比解析

系統 1528 0

前言

          
            R: 代表 redis-cli
P: 代表 python的redis

          
        

準備

          
            pip install redis
pool = redis.ConnectionPool(host='39.107.86.223', port=6379, db=1)
redis = redis.Redis(connection_pool=pool)
redis.所有命令
下面命令所有命令我都省略了, 有和Python內置函數沖突的我會加上 redis.

          
        

全局命令

  • dbsize(返回key的數量)

                  
                       R: dbsize
       P: print(redis.dbsize())
                  
                
  • exists(是否存在某key)

                  
                       R: exists name
       P: exists('name')
       
                  
                
  • keys(列出所有key,可使用通配符)

                  
                       R: keys na*
       P: keys('na*')
       注:時間復雜度為 O(n)
                  
                
  • scan (對應keys,迭代取出所有keys)

                  
                       R: scan 0 match '*' count 4       
       P: keys_iter = redis.scan_iter(match='*', count=4)  
       注:這種scan,API后面也會有, 所以我全部放在最后的結束語中講
                  
                
  • info (查看資源信息)

                  
                       R: info            # 也可以填參數  info memory     info cpu 等
       P: redis.info()    # redis.info('CPU')     redis.info('MEMORY')
                  
                
  • type (列出類型)

                  
                       R: type name
       P: redis.type('name')   # type和python的沖突了,所以這里我寫全了    
       redis中類型有:  none string list    set zset     hash
    
                  
                

過期時間

  • expire(設置)

                  
                       R: expire name 秒數
       P: expire('name',  秒數)
                  
                
  • ttl(查詢)

                  
                       R: ttl name     
       P: ttl('name')
       
       # 返回剩余過期時間值
       # 返回值為 -2 則代表 無此 key
       # 返回值為 -1 則代表 有此 key , 但未設置過期時間
       
                  
                
  • persist(刪除)

                  
                       R: persist name
       P: persist('name')
    
                  
                
  • 自增,自減

                  
                       incr incrby     加上一個整數
           R: incr age   或 incrby age 1
           P: incr age 1 或 incrby age 1        # python實現 的 incr 被 重定向為 incrby,所以用哪個都行
           
       decr decrby     減去一個整數
           同上
       
       incrbyfloat     加減一個浮點數
           同上
    
                  
                

字符串相關操作

  • set 設置值

                  
                       R: set name lin
       P: redis.set('name', 'lin') 
    
       set選項(原子操作)
           nx(設置默認值)
               R: set name lin nx    
               P: redis.set('name', 'lin', nx=True)
                   注: nx 代表key不存在才會將值設置成功, 類似python dict的 setdefault,即給key設置默認值
               
           xx(更新值)
               R: set name Tom xx
               P: redis.set('name', 'lin', xx=True)
                   注: xx 代表key存在才會將值更新成功。 如果key不存在, 則更新失敗。
                  
                
  • get 獲取值

                  
                       R: get name
       P: redis.get('name')
       注:通過py redis客戶端的 get取出的都是 字節二進制類型, 所以需要手動轉為對應類型
           前面提到的 incr decr 等, 操作返回結果直接就是 int, 而非 字節類型
    
                  
                
  • mset 批量設置

                  
                       R: mset name lin age 18
       p: redis.mset( {'name': 'lin', 'age': 18} )
                  
                
  • mget 批量獲取

                  
                       R: mget name age
       p: redis.mget('name', 'age')    # 返回值為 字節類型的 列表
                  
                
  • getset 設置新值并返回舊值

                  
                       R: getset name zhang
       P: print( redis.getset('name', 'zhang') )
                  
                
  • append 字符串追加拼接

                  
                       R: append name abc
       P: redis.append('name', 'abc')
                  
                
  • strlen 獲取字符串長度

                  
                       R: strlen name
       P: print( redis.strlen('name') )
       注: 與編程語言的普遍API不同的是, strlen返回的字符串 長度是 字符對應編碼的長度。。。。
           中文 utf-8 占 3個字節
                  
                
  • getrange 字符串切片 (從0開始,前閉后閉)

                  
                       R: getrange name 1 2
       P: redis.getrange('name', 1, 2)
                  
                
  • setrange 字符串按索引賦值(覆蓋)

                  
                       R: setrange name 0 abc     # 把第0個位置開始, 逐個覆蓋賦值為 abc, 多余的不變
       P: redis.setrange('name', 0, 'abc')
                  
                
  • del 刪除鍵值

                  
                       R: del k1 k2
       P: redis.delete(k1, k2)
                  
                

Hash相關操作(可對應為 文檔-屬性-值)

  • hset 設置 1條文檔,1個屬性-值

                  
                       R: hset user name lin
       P: redis.hset('user', 'name', 'lin')
                  
                
  • hget 獲取 1條文檔,1個屬性

                  
                       R: hget user name
       P: print(redis.hget('user', 'name'))        
                  
                
  • hmset 設置 1條文檔, 多個屬性-值

                  
                       R: hmset user name lin age 18
       P: redis.hmset('user', {'user': 'lin', 'age': 18})
                  
                
  • hmget 獲取 1條文檔, 多個屬性-值

                  
                       R: hmget user name age
       P: print(redis.hmget('user', 'name', 'age'))
                  
                
  • hkeys 獲取所有 key

                  
                       R: hkeys user
       P: print(redis.hkeys('user'))
                  
                
  • hvals 獲取所有 values

                  
                       R: hvals user
       P: print(redis.hvals('user'))
                  
                
  • hgetall 獲取 一條文檔,所有屬性值(慎用,見下一條API)

                  
                       R: hgetall user                    # 返回為列表, 偶數索引為key,奇數索引為vaLue(從0開始)
       P: print(redis.hgetall('user'))    # 返回為 dict格式
       
       注: hgetall 會將所有key-value取出來,所以數據量龐大可能會造成性能影響。
           大批量數據在python是怎么處理來著???????
           沒錯,就是迭代器,當然python的redis模塊已為我們封裝好一個API,hscan_iter, 見一條API
                  
                
  • hscan (hash迭代,大體上可代替 hgetall使用)

                  
                       R: hscan user 0 match * count 200        # 按游標,按數量取
           # 0代表游標從頭開始
           # match是關鍵字 
           # * 是key的通配符
           # count 是一次接待的條數
       P: result_iter = redis.hscan_iter('user', match= 'na*', count=2)    
           # python的 cursor參數沒有,是因為源碼中被固定設置為 0了, 其他參數解釋同上
           # 返回結果為可迭代對象,可遍歷取出。
                  
                
  • hexists 檢測是否存在某key

                  
                       R: hexists user name1                   # 存在返回 1,不存在返回 0
       P: print(redis.hexists('user', 'name')) # 存在返回True
                  
                
  • hlen 統計獲取一個文檔,所有屬性的 總數

                  
                       R: hlen user
       P: print(redis.hlen('user'))        
                  
                
  • hdel 刪除指定字段

                  
                       R: hdel key field
       P: redis.hdel('key', 'field')
                  
                

List相關操作

  • lpush (左壓棧)

                  
                       R: lpush list1 1 2 3
       P: redis.lpush('list1', 1,2,3)
                  
                
  • rpush (右壓棧,同左壓棧,略)

  • lpop (左彈棧)

                  
                       R: lpop list2
       P: print(redis.lpop('list2'))
                  
                
  • rpop (右彈棧,同左彈棧,略)

  • blpop (左阻塞彈棧,列表為空時,就阻塞了)

                  
                       R: blpop list2 1000      # 1000為過期時間為1000秒,1000秒后自動解除阻塞,有值加入也會解除阻塞
       P: redis.blpop('list2', timeout=1000)
                  
                
  • brpop (右阻塞彈棧,同左阻塞彈棧,略)

  • linsert ( 在指定 值 的 前后 插入值)

                  
                       R: linsert list2 before Tom jerry                # 在Tom前插入 jerry, before代表之前
       P: redis.linsert('list2', 'after', 'b', 'Tom')   # 在b的后面插入Tom,  after代表之后
                  
                
  • lset (按索引賦值, 注意索引不要越界)

                  
                       R:lset list2 4 zhang
       P: redis.lset('list2', 4, 'zhang')
                  
                
  • lindex (按索引取值, 索引可正可負)

                  
                       R: lindex list2 -3
       P: print(redis.lindex('list2', 3))
                  
                
  • llen (獲取列表元素個數)

                  
                       R: llen list2
       P: print(redis.llen('list2'))    
                  
                
  • ltrim (注意:在原數據上切片,不返回值。)

                  
                       R: ltrim list2 3 10                     # 保留 索引 3-10 的列表數據,其他都刪除
       P: print(redis.ltrim('list2', 2, -1))   # 索引前閉后閉,可正可負
                  
                
  • lrem (刪除指定值)

                  
                       R: lrem list2 0 Tom    
           # 0 這個位置的參數代表刪除值的個數
               # 0 代表全部刪除, 刪除全部Tom值
               # 正數代表 從左到右 刪除n個。  eg:  lrem list2 5 Tom    即為 從左到右 刪除5個Tom值
               # 負數代表 從右到左 刪除n個。  eg:  lrem list2 -5 Tom   即為 從右到左 刪除5個Tom值
       P: print(redis.lrem('list2', -5, 1))    # 解釋同上
                  
                
  • lrange(遍歷,正負索引都可,前閉后閉)

                  
                       R: lrange list1 0 -1 
       P: print(redis.lrange('list2', 0, -1))
                  
                

Set相關操作

  • sadd (插入元素)

                  
                       R: sadd set1 1 2 3
       P: redis.sadd('set1', *[1,2,3])
                  
                
  • srem (刪除指定值的元素)

                  
                       R: srem set1 Tom
       P: redis.srem('set1', 'Tom')
                  
                
  • scard (獲取集合中元素個數)

                  
                       R: scard set1
       P: redis.scard('set1')
                  
                
  • sismember (判斷某元素是否在集合)

                  
                       R: sismember set1 Tom
       P: redis.sismember('set1', 'Tom')
                  
                
  • srandmember (隨機取出集合指定個數元素)

                  
                       “”“類似py的 random.choices,注意有s”“
       R: srandmember set1 2             # 從集合隨機中取出2個元素
       P: redis.srandmember('set1', 2)
                  
                
  • smembers (取出集合中所有元素)

                  
                       R: smembers set1
       P: redis.smembers('set1')
       注: 同 hgetall, 如果一次性取出,可能會出問題,所以需要迭代獲取,見下 sscan
                  
                
  • sscan (游標/迭代取出集合所有元素)

                  
                       R: sscan set1 0 match * count 200
       P: result_iter = redis.sscan_iter('set1', match='*', count=200)    # 遍歷迭代
                  
                
  • sdiff (差集)

                  
                       R: sdiff sset1 sset2
       P: print(redis.sdiff('sset1', 'sset2'))
                  
                
  • sinter(交集)

                  
                       R: sinter sset1 sset2
       P: print(redis.sinter('sset1', 'sset2'))
                  
                
  • sunion (并集)

                  
                       R: sunion sset1 sset2
       P: print(redis.sunion('sset1', 'sset2'))
                  
                

zset 有序集合相關操作

  • zadd (有序插入)

                  
                       R: zadd zset 100 Tom 90 Jerry    #  100是權重,Tom是數據值, 注意redis-cli  權重在前,值在后
       P: redis.zadd('zset', {'Tom': 100, 'Jerry': 90})    # 注意,py語法,權重作為字典的value
       注特別注意:
           zadd的默認機制是同值,不同權重時,會更新值的權重
           eg: 上面再插入一條 Tom, 不過這次的權重是 50 ( zadd zset 50 Tom),則Tom的權重會更新為50
           
       這時就延申出2個參數,(應該還記得前面講的 set的 nx 和 xx參數吧,沒錯 zadd也有)
       nx: (不存在才更新(添加), 存在則更新(添加) 失敗)
           R: zadd zset nx 1000 Tom            
           P: redis.zadd('zset',{'Tom': 1000}, nx=True)    
           注:
               如果Tom這個值之前存在,則這個1000就不會被更新了
               若不存在,則就會新創建,并把這個1000設置成功
               
       nx:(存在才更新(添加),  不存在則更新(添加) 失敗)
           R: zadd zset xx 1000 Tom            
           P:redis.zadd('zset',{'Tom': 1000}, xx=True)    
           注:
               如果Tom這個值之前存在,則1000才會更新成功
               如果不存在,比如 {'張三':500}, 張三本來就不存在,用了xx, 他不會被添加進來,更何談更新
                  
                
  • zrange (遍歷)

                  
                       R: zrange zset 0 -1
       P: print(redis.zrange('zset', 0, -1))    # 返回值為列表
    
       withscores 參數(把權重也帶出來返回):
           R: zrange zset 0 -1 withscores    # 注意,  返回時 奇數位 是值, 偶數位是權重
           P: print(redis.zrange('zset', 0, -1, withscores=True))  # 返回列表嵌套元組,[(值,權重)]
                  
                
  • zrevrange (逆序-降序,遍歷)

                  
                       這條API就是多了 "rev" 三個字母,   reversed單詞 熟悉把, python內置逆序高階函數。。就是那個意思
       操作同zrange,略
                  
                
  • zrangebyscore (根據權重來遍歷)

                  
                       R: zrangebyscore zset 40 99 limit 1 3   # 查出權重在40-99之內的數據,并從第1條開始,返回3條
           # 40-99都是閉區間, 要想變成開區間這樣寫即可   (40 (99
       P: print(redis.zrangebyscore('zset', 40, 99, start=1, num=3))
                  
                
  • zrevrangebyscore (根據權重來 逆序遍歷)

                  
                       操作同 zrangebyscore, 略
       這API設計的,還不如,直接弄成一條命令,然后加一個逆序參數,吐槽!!!!
                  
                
  • zrem (刪除某值)

                  
                       R: zrem zset Tom        # 刪除Tom這個值
       P: print(redis.zrem('zset','Tom'))
                  
                
  • zremrangebyscore (刪除 權重 范圍內的值)

                  
                       R: zremrangebyscore zset 70 90        # 把權重在70-90分的所有數據刪除
       P: redis.zremrangebyscore('zset', 70, 90)
                  
                
  • zremrangebyrank (刪除 索引 范圍內的值)

                  
                       R: zremrangebyrank zset 0 -1    # 刪除所有值 ( 0到-1的索引就代表所有值啦!)
       P: redis.zremrangebyrank('zset', 0, -1)    # redis的API風格真的。。。沒辦法python也無奈同名
                  
                
  • zcard (獲取有序集合的 所有 元素個數)

                  
                       R: zcard zset
       P: print(redis.zcard('zset'))
                  
                
  • zcount (統計有序集合的 某權重范圍的 元素個數)

                  
                       R: zcount zset 10 69         # 同樣默認閉區間, ( 可改為開區間
       P: print(redis.zcount('zset',50, 69))  
                  
                
  • zrank (獲取某元素的索引)

                  
                       R: zrank zset Jerry       # 不用猜,索引肯定從0開始
       P: print(redis.zrank('zset', 'Jerry'))
                  
                
  • zrevrank (逆序 獲取某元素的索引)

                  
                       逆序獲取索引,比如最后一個,索引就是0
       具體操作,同 zrank, 略
                  
                
  • zscore (獲取某元素對應的權重)

                  
                       R: zscore zset Jerry
       P: print(redis.zscore('zset', 'Jerry'))
                  
                
  • zscan (迭代方式和返回 所有元素及其權重)

                  
                       """
           嗯?似曾相識燕歸來? 
           前面說過的 scan hsacn sscan 還有接下來要說的 zscan 都是一個樣子的,都是為了應對大數據來迭代處理
           python版的redis給了我們一個簡化函數,那就是 _iter結尾的, eg: hscan_iter()
           這種 _iter結尾的函數,不用我們來傳游標cursor參數, 為啥呢??
               一. 因為python有生成器-迭代器機制阿!(當然 _iter等函數的源碼就是用yield為我們實現的)
               二. cursor游標不易于管理
       """
       R: zscan zset 0 match * count 5 
       P: zset_iter = redis.zscan_iter('zset', match='*', count=5)   # 同理返回可迭代對象
       注:還要說明一下:
           match參數:  
               過濾查詢數據(其實過濾完了,數據量小了也沒必要用scan了,此參數主要用在"hscan"之類的)
               "因此match參數可不寫",  "match='*' 和 不傳是一個效果的。"
           count參數: 
               Py源碼解釋   ``count`` allows for hint the minimum number of returns
               意思就是:   這個參數是一次迭代"最少"取5個",但不管怎么說,最終還是會取出全部數據!!
                  
                
  • zpopmax (彈出最大優先級數據對,redis5.+新增)

                  
                       R: zpopmax zset1 2        # 2代表彈出最大的2對key:score,不寫,默認只彈一對key:score
       P: data = redis.zpopmax(zset1, count=None)    # 原理同上
       zpopmax可等價于下面兩條命令的加起來的效果: 
           data = redis.zrange(zset1, -1, -1)
           zrem(zset1, data)
       注:無論count指定幾個或不指定,py返回值為  [(key, score)]  列表嵌元組這種格式。
                  
                
  • zpopmin (彈出最小優先級數據對,redis5.+新增)

                  
                       用法同zpopmax
       zpopmax可等價于下面兩條命令的加起來的效果:
           data = redis.zrange(zset1, 0, 0) # 就這里變了,默認升序,故最小值需要從第0條開始彈
           zrem(zset1, data)
       注:    
           zpopmax 和 zpopmin 這兩個方法是 redis5.+才有的。
           前面也說了這種方法 = zrange + zrem
           很明顯,由原來的多行操作。變成了原子操作。
           我想,redis新增這兩條命令,應該正是解決資源競爭的這一問題!!!!!!
                  
                

Redis兩種持久化的方式

  • 生成RDB文件 (三種方法)

                  
                       """RDB機制就是 觸發生成RDB文件,將Redis數據以二進制形式寫入其中, 觸發方式有如下三種"""
       RDB基本配置:
           vi /etc/redis/redis.conf
               dbfilename dump.rdb    # 配置RDB文件名
               dir /var/lib/redis     # 配置RDB文件存放目錄 (ll 命令查看 dump.rdb是否為最新時間)
               appendonly no          # 若為yes, 會優先按照aof文件來恢復,或不恢復
       上述配置,可在下面三種方法實現的時候,自動觸發生成RDB文件。并在redis啟動時恢復RDB文件
                  
                
  • 觸發方式1:save (阻塞)

                  
                       R: save
       P: redis.save()
                  
                
  • 觸發方式2:bgsave (開fork進程,異步,非阻塞)

                  
                       R: bgsave
       P: redis.bgsave()
                  
                
  • 觸發方式3:自動動態生成RDB文件(配置文件)

                  
                       在上面RDB基本配置基礎上,追加如下配置
       vi /etc/redis/redis.conf
           save 100 10    # 100秒鐘改變10條數據就會,自動生成RDB文件
                  
                
  • RDB缺點

                  
                       大數據耗時,RDB文件寫入影響IO性能。宕機數據不可控
    
                  
                
  • 生成AOF文件(三種方法)

                  
                       """AOF機制就是 每執行一條命令,都會記錄到緩沖區,在根據某種策略刷新到AOF文件中,策略有如下三種"""
       AOF基本配置:
           vi /etc/redis/redis.conf
               appendonly yes    # 開關,先要打開
               appendfilename "appendonly.aof"    # AOF文件名
               dir /var/lib/redis     # AOF文件目錄(和RDB是一樣的)
           
                  
                
  • 刷新策略1:always

                  
                       always 即緩沖區有一條命令,就會刷新追加到AOF文件中 (安全可靠,耗IO)
                  
                
  • 刷新策略2:everysec (默認)

                  
                       everysec 即每過1秒 就會把緩沖區的命令 刷新追加到AOF文件中
               如果就在這一秒鐘宕機,那么數據就丟失了。。。(1秒不可控)
                  
                
  • 刷新策略3:no

                  
                       no 即 什么時候刷新,全聽操作系統自己的 (完全不可控)
    
                  
                
  • AOF重寫機制 (兩種方法,異步)

  • 重寫清潔過程:

                  
                       如上可知,越來越多的命令會追加到AOF中,其中可能會有一些類似
           一、鍵值覆蓋: 
                   set name tom
                   set name jerry
           二、超時時間過期
           三、多條插入(可用一條命令代替)
       如上無用命令,會讓AOF文件變得繁雜。
       可通過 AOF重寫策略優化來達到化簡,提高恢復速度等。
                  
                
  • 重寫原理(查找資料 + 個人理解):

                  
                       一、 開fork子進程 新弄一份AOF文件,它的任務就是把當前redis中的數據重新按照上面的
           ”重寫清潔過程“ 捋一遍,并記錄到這個新AOF文件中
       二、 此時主進程可以正常接受用戶的請求及修改,(這時可能子進程AOF,和數據庫內容不一致,往下看)
       三、 其實---第一條開fork的時候,順便也開了一份內存空間A(名為重寫緩沖區) 用來平行記錄 用戶新請求的命令
       四、 當子進程AOF重寫完事后, 會把上面 空間A中 中的數據命令追加到 AOF中(類似斷點復制)
       五、 新AOF替代 舊的AOF
       
       打個比方(針對于 二、三、四):
           就是,你給我一個任務,我正做著,你又給我很多任務,我當然忙不過來
           那這樣,你先拿個清單記錄下來,一會等我忙完了,咱們對接一下就好了)
                  
                
  • 重寫方式1:bgrewriteaof

                  
                       R: bgrewriteaof
       P: redis.bgrewriteaof()
                  
                
  • 重寫方式2:配置文件實現自動重寫

                  
                       在上面AOF基本配置的基礎上,追加如下配置
       vi /etc/redis/redis.conf
           appendfsync everysec    # 就是上面說的三種策略,選一種  always no
           auto-aof-rewrite-min-size 64mb     # 當AOF文件超過64mb就會自動重寫
           auto-aof-rewrite-percentage 100    # 100為增長率, 每一次的限制大小是之前的100%,也就是二倍
    
           no-appendfsync-on-rewrite yes     # yes 就是不把 “重寫緩沖區” 的內容 刷新到 磁盤
           注意這個參數:
               這就是針對上面 ’重寫原理‘ 中的第三條 中的 內存空間A(重寫緩沖區)
               如果這個 重寫緩沖區 不刷新持久化到磁盤中, 要是宕機了,那么這個緩沖區的數據就會丟失。
               丟失多少呢?  據悉(linux中 最多最多 會丟失 30秒的數據)
               
               如果你將其 設置為 no,那么 重寫緩沖區 就會像 前面講的 原始AOF一樣地 刷新持久化到硬盤中。
               但是你想想, 如果 重寫緩沖區  和 原始AOF 都做持久化刷新
                   那么 它們就會 競爭 IO,性能必定大打折扣,特殊情況下,還可能 堵塞。
                   
               so, 要性能(設為yes), 要數據完整安全(設為no), 自己選....
                  
                

結束語

          
            本文主要寫了關于 redis 以及 python操作redis的語法對比詳細解釋!!
python的redis API 也是非常夠意思了,函數名幾乎完全還原 原生Redis!!

語法部分印象比較深刻的就是 "redis的 scan家族函數" 以及 "python的 scan_iter"家族函數:
    上面陸陸續續講了那么多數據結構,都有它們各自的"遍歷所有數據的操作"
    但對于大量數據的情況下, 這些遍歷函數就都變成渣渣了, 可能會造成"OOM(內存溢出)等情況"
    這時 redis 機智的為我們 提供了一些列 "scan家族函數" , 當然這些函數是都需要游標控制的。
    "游標cursor"是比較頭疼的東西, 因此 python本著 人性化的思想:
        將 "scan家族函數" 封裝為 "scan_iter家族函數", 讓我們省去了游標的操作,可以愉快編程!
    那我就列出全部大家族 以及 對應 原始遍歷函數:
        原始遍歷    redis    python
        keys       scan     scan_iter
        hgetall    hscan    hscan_iter
        smembers   sscan    sscan_iter
        zrange     zscan    zscan_iter
        沿著這個對應規律,之前我發現一件事情:
            為什么 "list 的 lrange 沒有對應的 lscan?"
        我像zz一樣還去ov查了一遍, 居然還看到一位外國朋友和我有一樣的疑問。。。
        解答者的一句話,我直接就清醒了, "Instead, you should use LRANGE to iterate the list"
            由于順著規律,思維定勢,卻忘記了 "lrange本身就可以帶索引來迭代 "   lrange list1 0 n
            
        這時我突然又想起 zrange不也是和 lrange語法一樣么???
        為何 zrange單獨設立了一個 zscan, 而 list卻沒???
            (查了一下好像是list底層性能之類的原因,我也沒愿意繼續看了。。。)
    
    scan 與 iter家族函數,各自的數據結構章節都有寫, 并且在"zset"那節的 "zscan"那里做出了詳細的分析
END
          
        

更多文章、技術交流、商務合作、聯系博主

微信掃碼或搜索:z360901061

微信掃一掃加我為好友

QQ號聯系: 360901061

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧,狠狠點擊下面給點支持吧,站長非常感激您!手機微信長按不能支付解決辦法:請將微信支付二維碼保存到相冊,切換到微信,然后點擊微信右上角掃一掃功能,選擇支付二維碼完成支付。

【本文對您有幫助就好】

您的支持是博主寫作最大的動力,如果您喜歡我的文章,感覺我的文章對您有幫助,請用微信掃描上面二維碼支持博主2元、5元、10元、自定義金額等您想捐的金額吧,站長會非常 感謝您的哦!!!

發表我的評論
最新評論 總共0條評論
主站蜘蛛池模板: 香蕉在线影院 | 亚洲视频不卡 | 羞羞视频网站在线观看 | 99激情网 | 99久久精品国产综合一区 | 99这里只有精品6 | 看片久久 | 91尤物国产尤物福利在线 | 九九在线精品视频 | 久久久久久不卡 | 日韩在线播放中文字幕 | 亚洲综合图色 | 国产日韩欧美亚洲 | 97s色视频一区二区三区在线 | 青青青国产免费全部免费观看 | 成熟性xxxxx 成在线人免费视频一区二区三区 | 亚洲网在线 | 操熟美女又肥又嫩的骚屁股 | 久久综合狠狠综合久久综合88 | 国产精品麻豆一区二区 | 日韩a一级欧美一级在线播放 | 天天天天躁天天天天碰 | 免费福利视频网站 | 日本一本一道久久香蕉免费 | 日本一区不卡视频 | 福利网站在线播放 | 777奇米影视色888成人 | 成人国产在线观看 | 久久久久久综合成人精品 | 中国欧美日韩一区二区三区 | 精品视频午夜一区二区 | 亚洲综合色婷婷在线观看 | 精品国产免费久久久久久婷婷 | 日本不卡高清免费v | 亚洲精品国产高清不卡在线 | 天天干天天干天天干天天 | 亚洲精品专区一区二区三区 | 另类久久 | 99视频在线观看视频一区 | 欧美精品在线免费观看 | 99这里只有精品6 |