Redis數據庫之列表，字典操做，管道

一：List操做

List操做，Redis中的List在內存中按照一個name對應一個list來存儲，如圖：

1.1 lpush(name,values)

#在name對應的list中添加元素，每一個新的元素都添加到列表的最左邊
#例如：
    # r.lpush('oo', 11,22,33)
    # 保存順序爲: 33,22,11
 
# 擴展：
    # rpush(name, values) 表示從右向左操做

1.2 lpushix(name,value)

在name對應的list中添加元素，只有name已經存在時，值添加到列表的最左邊（也就是最上邊）

# 更多：
    # rpushx(name, value) 表示從右向左操做，會添加在數據庫的最下邊

1.3 llen(name)

# name對應的list元素個數
print(conn.llen('a'))

1.4 linsert(name,where,refvalue,value)

#在name對應的的列表某一個值前或後插入一個新值
#參數：
    #name,redis的name
    #where，before或者after
    #refvalue,標杆值，即：在它前面插入數據（若是存在多個標杆值，以找到的第一個爲準）
    #value，要插入的數據
conn.linsert('a','before','zyx','love')

1.5 lset(name,index,value)

#在name對應的list中的某一個索引位置從新賦值（替換掉原來的值）

#參數：
    #name，Redis的name
    #index，list的索引位置
    #value，要設置的值
conn.lset('a','3','777')
#將3位置（從0開始）的那個值改成777

1.6 lrem(name,num,value)

#在name對應的list中刪除指定的值
#參數：
    #name，Redis的name
    #value，要刪除的值
    #num，num=0，刪除列表中全部的指定值
                #num=2，從前到後，刪除2個
                #num=-2，從後向前，刪除2個

conn.lrem('a','0','777')    #刪除全部的777

1.7  lpop(name)

#在name對應的列表的左側獲取第一個元素並在列表中移除，返回值是第一個元素
# 更多：
    # rpop(name) 表示從右向左操做

1.8 lindex(name,index)

#在name對應的列表中獲取元素
print(conn.lindex('b','2'))
#獲取b中的索引位置爲2的元素值

1.9 lrange(name,start,end)

# 在name對應的列表分片獲取數據
# 參數：
    # name，redis的name
    # start，索引的起始位置
    # end，索引結束位置

print(conn.lrange('b','0','2'))
#都是閉區間
#獲取的打印的值：[b'6', b'5', b'4']

1.10 ltrim(name, start, end)

# 在name對應的列表中移除沒有在start-end索引之間的值
# 參數：
    # name，redis的name
    # start，索引的起始位置
    # end，索引結束位置（大於列表長度，則表明不移除任何）

print(conn.ltrim('a','0','1'))
#都是閉區間，最後只有兩個值

1.11 rpoplpush(src, dst)

# 從一個列表取出最右邊的元素，同時將其添加至另外一個列表的最左邊
# 參數：
    # src，要取數據的列表的name
    # dst，要添加數據的列表的name

1.12 blpop(keys, timeout)

# 將多個列表排列，按照從左到右去pop對應列表的元素
 
# 參數：
    # keys，redis的name的集合
    # timeout，超時時間，當元素全部列表的元素獲取完以後，阻塞等待列表內有數據的時間（秒）, 0 表示永遠阻塞
 
# 更多：
    # r.brpop(keys, timeout)，從右向左獲取數據
爬蟲實現簡單分佈式：多個url放到列表裏，往裏不停放URL，程序循環取值，可是隻能一臺機器運行取值，能夠把url放到redis中，多臺機器從redis中取值，爬取數據，實現簡單分佈式

1.13 brpoplpush(src, dst, timeout=0)

# 從一個列表的右側移除一個元素並將其添加到另外一個列表的左側
 
# 參數：
    # src，取出並要移除元素的列表對應的name
    # dst，要插入元素的列表對應的name
    # timeout，當src對應的列表中沒有數據時，阻塞等待其有數據的超時時間（秒），0 表示永遠阻塞

1.14 自定義迭代

# 因爲redis類庫中沒有提供對列表元素的增量迭代，若是想要循環name對應的列表的全部元素，那麼就須要：
    # 一、獲取name對應的全部列表
    # 二、循環列表
# 可是，若是列表很是大，那麼就有可能在第一步時就將程序的內容撐爆，全部有必要自定義一個增量迭代的功能：
import redis
conn=redis.Redis(host='127.0.0.1',port=6379)
# conn.lpush('test',*[1,2,3,4,45,5,6,7,7,8,43,5,6,768,89,9,65,4,23,54,6757,8,68])
# conn.flushall()
def scan_list(name,count=2):
    index=0
    while True:
        data_list=conn.lrange(name,index,count+index-1)
        if not data_list:
            return
        index+=count
        for item in data_list:
            yield item
print(conn.lrange('test',0,100))
for item in scan_list('test',5):
    print('---')
    print(item)

二：字典操做

Redis中Hash在內存中的存儲格式以下：

hset(name,key,value)

# name對應的hash中設置一個鍵值對（不存在，則建立；不然，修改）
 
# 參數：
    # name，redis的name
    # key，name對應的hash中的key
    # value，name對應的hash中的value
 
# 注：
    # hsetnx(name, key, value),當name對應的hash中不存在當前key時則建立（至關於添加）

conn.hset('c','aaa','111')

hmset(name,mapping)

# 在name對應的hash中批量設置鍵值對
 
# 參數：
    # name，redis的name
    # mapping，字典，如：{'k1':'v1', 'k2': 'v2'}
 
# 如：
    # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

hget(name,key)

# 在name對應的hash中獲取根據key獲取value

hmget(name,key,*args)

# 在name對應的hash中獲取多個key的值
 
# 參數：
    # name，reids對應的name
    # keys，要獲取key集合，如：['k1', 'k2', 'k3']
    # *args，要獲取的key，如：k1,k2,k3
 
# 如：
    # r.mget('xx', ['k1', 'k2'])
    # 或
    # print r.hmget('xx', 'k1', 'k2')

print(conn.hmget('n2',['name','age']))
print(conn.hmget('n2','name','age'))
print(conn.hmget('n2','name'))

hgetall(name)

# 獲取name對應hash的全部鍵值
print(re.hgetall('a'))
# 若是不知道字典中存儲數據的量，儘可能慎用hgetall

hlen(name)

#獲取name對應的hash中鍵值對的個數

hkeys(name)

# 獲取name對應的hash中全部的key的值

hvals(name)

# 獲取name對應的hash中全部的value的值

hexists(name,key)

# 檢查name對應的hash是否存在當前傳入的key

hdel(name,*keys)

# 將name對應的hash中指定key的鍵值對刪除
print(re.hdel('xxx','sex','name'))

hincrby(name,key,amount=1)

# 自增name對應的hash中的指定key的值，不存在則建立key=amount
# 參數：
    # name，redis中的name
    # key， hash對應的key
    # amount，自增數（整數)

conn.hincrby('n1','age')
for i in range(100000):
    # conn.hset('n1','key%s'%i,'value%s'%i)
    conn.lpush('l1','value%s'%i)

hincrbyfloat(name,key,amount=1.0)

# 自增name對應的hash中的指定key的值，不存在則建立key=amount
 
# 參數：
    # name，redis中的name
    # key， hash對應的key
    # amount，自增數（浮點數）
 
# 自增name對應的hash中的指定key的值，不存在則建立key=amount

hscan(name,cursor=0,match=None,count=None)

# 增量式迭代獲取，對於數據大的數據很是有用，hscan能夠實現分片的獲取數據，並不是一次性將數據所有獲取完，從而放置內存被撐爆
 
# 參數：
    # name，redis的name
    # cursor，遊標（基於遊標分批取獲取數據）
    # match，匹配指定key，默認None 表示全部的key
    # count，每次分片最少獲取個數，默認None表示採用Redis的默認分片個數
 
# 如：
    # 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
    # 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
    # ...
    # 直到返回值cursor的值爲0時，表示數據已經經過分片獲取完畢

hsan_iter(name,match=None,count=None)

# 利用yield封裝hscan建立生成器，實現分批去redis中獲取數據
 
# 參數：
    # match，匹配指定key，默認None 表示全部的key
    # count，每次分片最少獲取個數，默認None表示採用Redis的默認分片個數
 
# 如：
    # for item in r.hscan_iter('xx'):
    #     print item
例：
ret=conn.hscan('n1',cursor=100,match=None,count=1000)
print(ret)
print(len(ret[1]))
# 迭代把全部數據取出,取出全部數據經過這種方式
for i in conn.hscan_iter('n1',count=10000):
    print(i)

三：其餘操做

delete(*names)

# 根據刪除redis中的任意數據類型

exists(name)

# 檢測redis的name是否存在

keys(pattern='*')

# 根據模型獲取redis的name
 
# 更多：
    # KEYS * 匹配數據庫中全部 key 。
    # KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
    # KEYS h*llo 匹配 hllo 和 heeeeello 等。
    # KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 

expire(name,time)

# 爲某個redis的某個name設置超時時間

rename(src,dst)

# 對redis的name重命名爲

move(name,db)

# 將redis的某個值移動到指定的db下

randomkey()

# 隨機獲取一個redis的name（不刪除）

type(name)

# 獲取name對應值的類型

scan(cursor=0, match=None, count=None)
scan_iter(match=None, count=None)

# 同字符串操做，用於增量迭代獲取key

四：管道（也能夠說是事務，由於能夠經過管道模擬事務原子性）

Redis-py默認執行每次請求都會建立（鏈接池申請鏈接）和斷開（歸還鏈接池）一次鏈接操做，若是想要在一次請求中指定多個命令，則可使用pipline實現一次請求指定多個命令，而且默認狀況下一次pipline是原子性操做。

import redis
 
pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
 
r = redis.Redis(connection_pool=pool)
 
# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)
pipe.multi()
pipe.set('name', 'alex')
pipe.set('role', 'sb')
 
pipe.execute()