In diesem Kapitel stellen wir vor, wie man redis in Python bedient. redis ist eine Key-Value-Datenbank. Der Wert unterstützt string, list, set, zset (geordnetes Set), hash (Hash-Typ) und andere Typen.

Weitere Informationen zu redis finden Sie in unseremredis-Tutorial. Beachten Sie, dass Sie vor dem Lernen dieses Kapitels sicherstellen müssen, dass Ihr redis-Dienst installiert wurde.

Die redis-Startoberfläche sieht wie folgt aus:

redis starten

$ ./redis-server
75858:C 25 Okt 11:43:34.329 # Warnung: Keine Konfigurationsdatei angegeben, es wird die Standardkonfiguration verwendet. Um eine Konfigurationsdatei anzugeben, verwenden Sie ./redis-server /path/to/redis.conf
75858:M 25 Okt 11:43:34.331 * Maximale Anzahl offener Dateien erhöht auf 10032 (sie war ursprünglich setze auf 256).
                _._                                                  
           _.-``__ ''-._                                            
      _.-``    `.  `_.  ''-._ Redis 3.0.3 (255fcb1a/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                  
 (    ' , .-` | `, ) Läuft im Standalone-Modus
 |`-._`-...-` __...-.``-._|'` _.-'| Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 75858
  `-._    `-._  `-./  _.-'    _.-'                                  
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-' | http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                  
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                  
      `-._    `-.__.-'    _.-'                                      
          `-._        _.-'                                          
              `-.__.-'                                              

75858:M 25 Okt 11:43:34.337 # Server gestartet, Redis Version 3.0.3
75858:M 25 Okt 11:43:34.339 * DB von Datenträger geladen: 0.002 Sekunden
75858:M 25 Okt 11:43:34.339 * Der Server ist jetzt bereit, Verbindungen auf Port anzunehmen 6379

Sie können sehen, die Standard-Portnummer ist6379。

redis-Modul installieren

Um redis in Python zu verwenden, müssen Sie zuerst das redis-Modul installieren:

sudo pip3 install redis
oder 
sudo easy_install redis
oder 
sudo python setup.py install

Quellcode-Adresse:https://github.com/WoLpH/redis-py

Prüfen Sie, ob die Installation erfolgreich ist:

>>> import redis
>>> r = redis.StrictRedis(host='localhost', port=6379, db=0)
>>> r.set('foo', 'bar')
True
>>> r.get('foo')
'bar'

redis bietet zwei Klassen: Redis und StrictRedis. StrictRedis wird verwendet, um die meisten offiziellen Befehle zu implementieren, und Redis ist eine Unterklasse von StrictRedis, die für die Abwärtskompatibilität mit alten Versionen verwendet wird.

Das von Redis abgerufene Ergebnis ist standardmäßig Bytes; wir könnendecode_responses=Truesetzen, um es in einen String umzuwandeln.

Beispiel

import redis   # Redis-Modul importieren

r = redis.Redis(host='localhost', port=6379, decode_responses=True)  
r.set('name', 'example')  # Setzt den Wert, der name entspricht
print(r['name'])
print(r.get('name'))  # Den Wert für den Schlüssel name abrufen
print(type(r.get('name')))  # Den Typ prüfen

Das Ausgabeergebnis ist:

example
example
<class 'str'>

Verbindungspool

redis-py verwendet einen Verbindungspool, um alle Verbindungen zu einem Redis-Server zu verwalten, wodurch der Overhead für das Aufbauen und Freigeben von Verbindungen bei jedem Vorgang vermieden wird.

Standardmäßig verwaltet jede Redis-Instanz ihren eigenen Verbindungspool. Sie können direkt einen Verbindungspool erstellen und ihn dann als Parameter an Redis übergeben, sodass mehrere Redis-Instanzen einen Verbindungspool gemeinsam nutzen können.

Beispiel

import redis    # Redis-Modul importieren

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(host='localhost', port=6379, decode_responses=True)  
r.set('name', 'example')  # Setzt den Wert, der name entspricht
print(r.get('name'))  # Den Wert für den Schlüssel name abrufen

Redis-Grundbefehle String

set(name, value, ex=None, px=None, nx=False, xx=False)

Setzt einen Wert in Redis. Standardmäßig wird er erstellt, falls er nicht existiert; falls er existiert, wird er geändert.

Parameter:

  • ex - Ablaufzeit (Sekunden)
  • px - Ablaufzeit (Millisekunden)
  • nx - Wenn auf True gesetzt, wird die aktuelle set-Operation nur ausgeführt, wenn name nicht existiert.
  • xx - Wenn auf True gesetzt, wird die aktuelle set-Operation nur ausgeführt, wenn name existiert.

1. ex - Ablaufzeit (Sekunden). Hier ist die Ablaufzeit 3 Sekunden. Nach 3 Sekunden wird der Wert des Schlüssels food zu None.

Beispiel

import redis

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)
r.set('food', 'mutton', ex=3)    # Der Schlüssel ist "food" und der Wert ist "mutton". Speichern Sie das Schlüssel-Wert-Paar im Redis-Cache.
print(r.get('food'))  # mutton. Ruft den Wert ab, der dem Schlüssel food entspricht.

2. px - Ablaufzeit (Millisekunden). Hier ist die Ablaufzeit 3 Millisekunden. Nach 3 Millisekunden wird der Wert des Schlüssels foo zu None.

Beispiel

import redis

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)
r.set('food', 'beef', px=3)
print(r.get('food'))

3. nx - Wenn auf True gesetzt, wird die aktuelle set-Operation nur ausgeführt, wenn name nicht existiert (erstellen).

Beispiel

import redis

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)
print(r.set('fruit', 'watermelon', nx=True))    # True--existiert nicht
# Wenn der Schlüssel fruit nicht existiert, ist die Ausgabe True; wenn der Schlüssel fruit bereits existiert, ist die Ausgabe None.

4. xx - Wenn auf True gesetzt, wird die aktuelle set-Operation nur ausgeführt, wenn name existiert (ändern).

Beispiel

print((r.set('fruit', 'watermelon', xx=True)))   # True--existiert bereits
# Wenn der Schlüssel fruit bereits existiert, ist die Ausgabe True; wenn der Schlüssel fruit nicht existiert, ist die Ausgabe None.

5.setnx(name, value)

Setzt einen Wert; führt die set-Operation nur aus, wenn name nicht existiert (hinzufügen).

print(r.setnx('fruit1', 'banana'))  # fruit1不存在，输出为True

6.setex(name, time, value)

Wert setzen

Parameter:

time - Ablaufzeit (numerische Sekunden oder timedelta-Objekt)

Beispiel

import redis
import time

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)
r.setex("fruit2", 5, "orange")
time.sleep(5)
print(r.get('fruit2'))  # Nach 5 Sekunden ändert sich der Wert von orange zu None.

7.psetex(name, time_ms, value)

Wert setzen

Parameter:

time_ms - Ablaufzeit (numerische Millisekunden oder timedelta-Objekt)

Beispiel

r.psetex("fruit3", 5000, "apple")
time.sleep(5)
print(r.get('fruit3'))  # Nach 5000 Millisekunden ändert sich der Wert von apple zu None.

8.mset(*args, **kwargs)

Werte stapelweise setzen

Zum Beispiel:

Beispiel

r.mget({'k1': 'v1', 'k2': 'v2'})
r.mset(k1="v1", k2="v2") # Hier dürfen k1 und k2 nicht in Anführungszeichen gesetzt werden; mehrere Schlüssel-Wert-Paare auf einmal setzen.
print(r.mget("k1", "k2"))   # Die Werte abrufen, die mehreren Schlüsseln auf einmal entsprechen.
print(r.mget("k1"))

9.mget(keys, *args)

Stapelabruf

Zum Beispiel:

Beispiel

print(r.mget('k1', 'k2'))
print(r.mget(['k1', 'k2']))
print(r.mget("fruit", "fruit1", "fruit2", "k1", "k2"))  # Die Werte, die den Schlüsseln im aktuellen Redis-Cache entsprechen, stapelweise abrufen.

10.getset(name, value)

Einen neuen Wert setzen und den ursprünglichen Wert abrufen

print(r.getset("food", "barbecue"))  # 设置的新值是barbecue 设置前的值是beef

11.getrange(key, start, end)

Teilsequenz abrufen (nach Bytes abrufen, nicht nach Zeichen)

Parameter:

  • name - der Name von Redis
  • start - Startposition (Byte)
  • end - Endposition (Byte)

Zum Beispiel: "君惜大大", 0-3 bedeutet "君"

Beispiel

r.set("cn_name", "Junxi the Great") # chinesische Schriftzeichen
print(r.getrange("cn_name", 0, 2))   # Holt die Bytes bei Index 0-2, die ersten 3 Bytes, "君", Slice-Operation (ein chinesisches Schriftzeichen belegt 3 Bytes, ein Buchstabe belegt 1 Byte, jedes Byte hat 8 Bits)
print(r.getrange("cn_name", 0, -1))  # Holt alle Bytes, "Junxi Dada", Slice-Operation
r.set("en_name","junxi") # Buchstaben
print(r.getrange("en_name", 0, 2))  # Holt die Bytes bei Index 0-2, die ersten 3 Bytes, "jun", Slice-Operation (ein chinesisches Schriftzeichen belegt 3 Bytes, ein Buchstabe belegt 1 Byte, jedes Byte hat 8 Bits)
print(r.getrange("en_name", 0, -1)) # Holt alle Bytes, "junxi", Slice-Operation

12.setrange(name, offset, value)

Ändert den String-Inhalt, ersetzt ab dem angegebenen String-Index (wenn der neue Wert zu lang ist, wird am Ende angehängt).

Parameter:

  • offset - Index des Strings, in Bytes (ein chinesisches Schriftzeichen belegt drei Bytes)
  • value - Wert, der gesetzt werden soll

Beispiel

r.setrange("en_name", 1, "ccc")
print(r.get("en_name"))    # jccci ursprünglicher Wert ist junxi, ersetze beginnend bei Index 1 durch ccc, wird zu jccci

13.setbit(name, offset, value)

Operationen an den Bits der Binärdarstellung des zu name gehörenden Werts ausführen

Parameter:

  • name - Redis-Name
  • offset - Index des Bits (den Wert vor dem Indexieren in Binär umwandeln)
  • value - Wert kann nur 1 oder 0 sein

Hinweis: Wenn es einen entsprechenden Eintrag in Redis gibt: n1 = "foo",

dann lautet die Binärdarstellung der Zeichenkette foo: 01100110 01101111 01101111

Wenn also setbit('n1', 7, 1) ausgeführt wird, dann wird das 7. Bit auf 1 gesetzt,

dann lautet die endgültige Binärdarstellung 01100111 01101111 01101111, d. h.: "goo"

Erweiterung, in Binärdarstellung umwandeln:

Beispiel

source = "Chen Siwei"
source = "foo"
for i in source:
num = ord(i)
print bin(num).replace('b','')

Insbesondere: Was, wenn source die chinesischen Zeichen "Chen Siwei" ist?

Antwort: Bei utf-8 belegt jedes chinesische Zeichen 3 Bytes, also hat "Chen Siwei" 9 Bytes. Bei chinesischen Zeichen wird bei Verwendung einer for-Schleife byteweise iteriert. Während der Iteration wird jedes Byte in eine Dezimalzahl umgewandelt und dann die Dezimalzahl in eine Binärzahl umgewandelt. 11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000

14.getbit(name, offset)

Ruft den Wert eines bestimmten Bits (0 oder 1) in der Binärdarstellung des Werts ab, der name entspricht

print(r.getbit("foo1", 0)) # 0 foo1 对应的二进制 4个字节 32位 第0位是0还是1

15.bitcount(key, start=None, end=None)

Ruft die Anzahl der Einsen in der Binärdarstellung des Werts ab, der name entspricht

Parameter:

  • key - Redis-Name
  • start - Byte-Startposition
  • end - Byte-Endposition

Beispiel

print(r.get("foo"))  # goo1 01100111
print(r.bitcount("foo",0,1))  # 11 gibt die Anzahl der Vorkommen von 1 in den ersten 2 Bytes an

16.bitop(operation, dest, *keys)

Mehrere Werte abrufen, bitweise Operationen an den Werten durchführen und das Endergebnis im Wert speichern, der einem neuen Namen entspricht

Parameter:

  • operation - AND (und), OR (oder), NOT (nicht), XOR (exklusives Oder)
  • dest - neuer Redis-Name
  • *keys - Redis-Namen zum Nachschlagen

e.g.:

bitop("AND", 'new_name', 'n1', 'n2', 'n3')

Die Werte abrufen, die n1, n2, n3 in Redis entsprechen, dann eine bitweise Operation an allen Werten durchführen (Vereinigung bilden) und dann das Ergebnis im Wert speichern, der new_name entspricht

Beispiel

r.set("foo","1")  # 0110001
r.set("foo1","2")  # 0110010
print(r.mget("foo","foo1"))  # ['goo1', 'baaanew']
print(r.bitop("AND","new","foo","foo1"))  # "new" 0 0110000
print(r.mget("foo","foo1","new"))

source = "12"
for i in source:
num = ord(i)
print(num)  # Gib den ASCII-Code-Wert aus, der jedem Buchstabenzeichen oder chinesischen Zeichen entspricht f-102-0b100111-01100111
print(bin(num))  # Gib jeden dezimalen ASCII-Code-Wert als Binärwert 0b1100110 aus (0b steht für binär)
print bin(num).replace('b','')  # Ersetze die Binärzahl 0b1100110 durch 01100110

17.strlen(name)

Gibt die Byte-Länge des Werts zurück, der name entspricht (ein chinesisches Zeichen ist 3 Bytes)

print(r.strlen("foo"))  # 4 'goo1'的长度是4

18.incr(self, name, amount=1)

Inkrementiert den Wert, der name entspricht. Wenn name nicht existiert, wird name＝amount erstellt, andernfalls wird inkrementiert.

Parameter:

  • name - Redis-Name
  • amount – Inkrementwert (muss eine Ganzzahl sein)

Hinweis: entspricht incrby

Beispiel

r.set("foo", 123)
print(r.mget("foo", "foo1", "foo2", "k1", "k2"))
r.incr("foo", amount=1)
print(r.mget("foo", "foo1", "foo2", "k1", "k2"))

Anwendungsszenario – Seitenaufrufzähler

Angenommen, wir müssen die Klickzahlen für eine Reihe von Seiten erfassen. Beispielsweise muss für jeden Beitrag in einem Forum die Klickzahl erfasst werden, und die Klickzahl ist viel größer als die Anzahl der Antworten. Wenn eine relationale Datenbank zum Speichern von Klicks verwendet wird, kann es zu vielen Konflikten durch Sperren auf Zeilenebene kommen. Daher ist die Verwendung des INCR-Befehls von Redis zum Erhöhen der Klickzahl die beste Lösung.

Wenn der Redis-Server startet, kann der Anfangswert der Klickzahl aus der relationalen Datenbank gelesen werden (Seite 12306 wurde 34634-mal aufgerufen)

r.set("visit:12306:totals", 34634)
print(r.get("visit:12306:totals"))

Immer wenn eine Seite angeklickt wird, verwenden Sie INCR, um die Klickzahl zu erhöhen.

r.incr("visit:12306:totals")
r.incr("visit:12306:totals")

Wenn die Seite geladen wird, kann dieser Wert direkt abgerufen werden

print(r.get("visit:12306:totals"))

19.incrbyfloat(self, name, amount=1.0)

Inkrementiert den Wert, der name entspricht. Wenn name nicht existiert, wird name＝amount erstellt, andernfalls wird inkrementiert.

Parameter:

  • name - Redis-Name
  • amount - Inkrementwert (Gleitkommazahl)

Beispiel

r.set("foo1", "123.0")
r.set("foo2", "221.0")
print(r.mget("foo1", "foo2"))
r.incrbyfloat("foo1", amount=2.0)
r.incrbyfloat("foo2", amount=3.0)
print(r.mget("foo1", "foo2"))

20.decr(self, name, amount=1)

Dekrementiert den Wert, der zu name gehört. Wenn name nicht existiert, lege name＝amount an, andernfalls dekrementiere.

Parameter:

  • name - Redis-Name
  • amount - Dekrementwert (Ganzzahl)

Beispiel

r.decr("foo4", amount=3) # Um 3 dekrementieren
r.decr("foo1", amount=1) # Um 1 dekrementieren
print(r.mget("foo1", "foo4"))

21.append(key, value)

Inhalt an den Wert anhängen, der dem Redis-Namen entspricht

Parameter:

  • key - Redis-Name
  • value - anzuhängende Zeichenkette

Beispiel

r.append("name", "haha")    # Hänge die Zeichenkette haha nach dem Wert junxi an, der name entspricht
print(r.mget("name"))

Redis-Grundbefehle Hash

1. Einzelnes Hinzufügen/Aktualisieren (einzelnes Abrufen) - hinzufügen, falls nicht vorhanden, ändern, falls vorhanden

hset(name, key, value)

Setzt ein Schlüssel-Wert-Paar im Hash, der name entspricht (falls nicht vorhanden, erstellen; andernfalls ändern)

Parameter:

  • name - Redis-Name
  • key - Schlüssel im Hash, der name entspricht
  • value - Wert im Hash, der name entspricht

Hinweis: hsetnx(name, key, value) legt an, wenn der aktuelle Schlüssel im Hash, der name entspricht, nicht existiert (entspricht dem Hinzufügen)

Beispiel

import redis
import time

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

r.hset("hash1", "k1", "v1")
r.hset("hash1", "k2", "v2")
print(r.hkeys("hash1")) # Alle Schlüssel im Hash abrufen
print(r.hget("hash1", "k1"))    # Den Wert für den Schlüssel des Hashes einzeln abrufen
print(r.hmget("hash1", "k1", "k2")) # Die Werte für mehrere Schlüssel des Hashes abrufen
r.hsetnx("hash1", "k2", "v3") # Kann nur neue erstellen
print(r.hget("hash1", "k2"))

2. Stapelweises Hinzufügen (Abrufen)

hmset(name, mapping)

Stapelweise Schlüssel-Wert-Paare im Hash setzen, der name entspricht

Parameter:

  • name - Redis-Name
  • mapping - Wörterbuch, wie z. B.: {'k1':'v1', 'k2': 'v2'}

e.g.:

Beispiel

r.hmset("hash2", {"k2": "v2", "k3": "v3"})
hget(name,key)

Im Hash, der name entspricht, den Wert anhand des Schlüssels abrufen

hmget(name, keys, *args)

Im Hash, der zu name gehört, die Werte mehrerer Schlüssel abrufen

Parameter:

  • name – Name, der zu Redis gehört
  • keys – Schlüsselsammlung zum Abrufen, z. B.: ['k1', 'k2', 'k3']
  • *args – Schlüssel zum Abrufen, z. B.: k1,k2,k3

e.g.:

Beispiel

print(r.hget("hash2", "k2"))  # Wert für key-k2 von "hash2" einzeln abrufen
print(r.hmget("hash2", "k2", "k3"))  # Werte für key-k2 k3 von "hash2" stapelweise abrufen -- Methode 1
print(r.hmget("hash2", ["k2", "k3"]))  # Werte für key-k2 k3 von "hash2" stapelweise abrufen -- Methode 2

3. Alle Schlüssel-Wert-Paare abrufen

hgetall(name)

Alle Schlüssel-Werte des Hashes abrufen, der zu name gehört

print(r.hgetall("hash1"))

4. Das Format aller Schlüssel-Wert-Paare abrufen, Hash-Länge

hlen(name)

Die Anzahl der Schlüssel-Wert-Paare im Hash abrufen, der zu name gehört

print(r.hlen("hash1"))

5. Alle Schlüssel abrufen (ähnlich wie das Abrufen aller Schlüssel eines Wörterbuchs)

hkeys(name)

Die Werte aller Schlüssel im Hash mit dem Namen name abrufen

print(r.hkeys("hash1"))

6. Alle Werte abrufen (ähnlich dem Abrufen aller Werte eines Dictionaries)

hvals(name)

Alle Werte im Hash mit dem Namen name abrufen

print(r.hvals("hash1"))

7. Prüfen, ob ein Mitglied existiert (ähnlich dem 'in' eines Dictionaries)

hexists(name, key)

Prüfen, ob der aktuell übergebene Schlüssel im Hash mit dem Namen name existiert

Beispiel

print(r.hexists("hash1", "k4"))  # False: existiert nicht
print(r.hexists("hash1", "k1"))  # True: existiert

8. Schlüssel-Wert-Paar löschen

hdel(name,*keys)

Das Schlüssel-Wert-Paar des angegebenen Schlüssels im Hash mit dem Namen name löschen

Beispiel

print(r.hgetall("hash1"))
r.hset("hash1", "k2", "v222")   # Vorhandenen Schlüssel k2 ändern
r.hset("hash1", "k11", "v1")   # Neues Schlüssel-Wert-Paar k11 hinzufügen
r.hdel("hash1", "k1")    # Ein Schlüssel-Wert-Paar löschen
print(r.hgetall("hash1"))

9. Integer inkrementieren/dekrementieren (für den Wert, der dem key entspricht, Integer, um 1 oder 2 oder einen anderen Integer erhöhen; negativ bedeutet dekrementieren)

hincrby(name, key, amount=1)

Inkrementieren Sie den Wert des angegebenen Schlüssels im Hash für name; falls dieser nicht existiert, legen Sie key=amount an

Parameter:

  • name - Name in Redis
  • key - Schlüssel, der dem Hash entspricht
  • amount - Auto-Inkrement-Zahl (Integer)

Beispiel

r.hset("hash1", "k3", 123)
r.hincrby("hash1", "k3", amount=-1)
print(r.hgetall("hash1"))
r.hincrby("hash1", "k4", amount=1)  # Falls er nicht existiert, ist der Wert standardmäßig 1
print(r.hgetall("hash1"))

10. Float inkrementieren/dekrementieren (für den Wert, der dem key entspricht, Float, um 1.0 oder 2.0 oder einen anderen Float erhöhen; negativ bedeutet dekrementieren)

hincrbyfloat(name, key, amount=1.0)

Inkrementieren Sie den Wert des angegebenen Schlüssels im Hash für name; falls dieser nicht existiert, legen Sie key=amount an

Parameter:

  • name - der Name in Redis
  • key - der Schlüssel, der dem Hash entspricht
  • amount, automatisch inkrementierende Zahl (float)

Inkrementiere den Wert des angegebenen Schlüssels im Hash, der name entspricht; wenn er nicht existiert, erstelle key=amount.

Beispiel

r.hset("hash1", "k5", "1.0")
r.hincrbyfloat("hash1", "k5", amount=-1.0)    # Existiert bereits, um -1.0 verringern
print(r.hgetall("hash1"))
r.hincrbyfloat("hash1", "k6", amount=-1.0)    # Existiert nicht, Wert initialisiert sich auf -1.0, jedes Mal um 1.0 verringern
print(r.hgetall("hash1"))

11. Wert abrufen - Slice-Lesen

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

Inkrementelles iteratives Abrufen ist sehr nützlich für große Datenmengen. hscan kann Daten in Shards abrufen, anstatt alle Daten auf einmal abzurufen, wodurch verhindert wird, dass der Speicher erschöpft wird.

Parameter:

  • name - der Name in Redis
  • cursor - Cursor (Daten in Batches basierend auf dem Cursor abrufen)
  • match - den angegebenen Schlüssel abgleichen, Standard None bedeutet alle Schlüssel
  • count - minimale Anzahl, die pro Shard abgerufen wird, Standard None bedeutet, die Standard-Shard-Anzahl von Redis zu verwenden

Zum Beispiel:

第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
...

Bis der zurückgegebene Cursor-Wert 0 ist, bedeutet es, dass alle Daten per Sharding abgerufen wurden

print(r.hscan("hash1"))

12, hscan_iter(name, match=None, count=None)

Verwende yield, um hscan zu umschließen und einen Generator zu erzeugen, der das Abrufen von Daten aus Redis in Batches ermöglicht

Parameter:

  • match - den angegebenen Schlüssel abgleichen, Standard None bedeutet alle Schlüssel
  • count - minimale Anzahl, die pro Shard abgerufen wird, Standard None bedeutet, die Standard-Shard-Anzahl von Redis zu verwenden

Zum Beispiel:

Beispiel

for item in r.hscan_iter('hash1'):
    print(item)
print(r.hscan_iter("hash1"))    # Speicheradresse des Generators

5. Liste der grundlegenden Redis-Befehle

1. Hinzufügen (ähnlich wie list append, aber hier wird von links hinzugefügt) -- erstellt eine neue, falls sie nicht existiert

lpush(name,values)

Fügt ein Element zur Liste hinzu, die name entspricht; jedes neue Element wird ganz links an die Liste angehängt

Zum Beispiel:

Beispiel

import redis
import time

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

r.lpush("list1", 11, 22, 33)
print(r.lrange('list1', 0, -1))

Die gespeicherte Reihenfolge ist: 33, 22, 11

Erweiterung:

r.rpush("list2", 11, 22, 33)  # 表示从右向左操作
print(r.llen("list2"))  # 列表长度
print(r.lrange("list2", 0, 3))  # 切片取出值，范围是索引号0-3

2. Hinzufügen (von rechts hinzufügen) -- erstellt eine neue, falls sie nicht existiert

Beispiel

r.rpush("list2", 44, 55, 66)    # Fügt 44, 55, 66 in Reihenfolge rechts an die Liste an
print(r.llen("list2"))  # Listenlänge
print(r.lrange("list2", 0, -1)) # Slicing, um Werte zu erhalten, Bereich ist Index 0 bis -1 (das letzte Element)

3. Füge für einen existierenden Namen ein Element auf der linken Seite der Liste hinzu; wenn er nicht existiert, kann er nicht erstellt werden

lpushx(name,value)

Füge ein Element zur Liste hinzu, die dem Namen entspricht; nur wenn der Name bereits existiert, wird der Wert ganz links zur Liste hinzugefügt

Mehr:

Beispiel

r.lpushx("list10", 10)   # Hier existiert "list10" nicht
print(r.llen("list10"))  # 0
print(r.lrange("list10", 0, -1))  # []
r.lpushx("list2", 77)   # Hier existierte "list2" bereits zuvor, füge ein Element ganz links an die Liste an, nur eines auf einmal
print(r.llen("list2"))  # Listenlänge
print(r.lrange("list2", 0, -1)) # Slicing, um Werte zu erhalten, Bereich ist Index 0 bis -1 (das letzte Element

4. Füge für einen existierenden Namen ein Element auf der rechten Seite der Liste hinzu; wenn er nicht existiert, kann er nicht erstellt werden

Beispiel

r.rpushx("list2", 99)   # Hier existierte "foo_list1" bereits zuvor, füge ein Element ganz rechts an die Liste an, nur eines auf einmal
print(r.llen("list2"))  # Listenlänge
print(r.lrange("list2", 0, -1)) # Slicing, um Werte zu erhalten, Bereich ist Index 0 bis -1 (das letzte Element)

5. Hinzufügen (Element an einer festen Indexposition einfügen)

linsert(name, where, refvalue, value))

Füge einen neuen Wert vor oder nach einem bestimmten Wert in der Liste ein, die name entspricht

Parameter:

  • name - der Name in Redis
  • where - BEFORE oder AFTER
  • refvalue - Referenzwert, d. h. Daten davor oder danach einfügen
  • value - einzufügende Daten

Beispiel

r.linsert("list2", "before", "11", "00")   # Element "00" vor dem ersten Vorkommen von "11" von links in die Liste einfügen
print(r.lrange("list2", 0, -1))   # Ausschnitt, um Werte zu erhalten, Bereich ist Index 0 - letztes Element

6. Ändern (durch Angabe des Index ändern)

r.lset(name, index, value)

Weise einen Wert an einer bestimmten Indexposition in der Liste neu zu, die name entspricht

Parameter:

  • name - der Name in Redis
  • index - Indexposition in der Liste
  • value - Wert, der gesetzt werden soll

Beispiel

r.lset("list2", 0, -11)    # Ändere das Element mit Index 0 zu -11
print(r.lrange("list2", 0, -1))

7. Löschen (Löschen nach angegebenem Wert)

r.lrem(name, value, num)

Den angegebenen Wert in der Liste, die name entspricht, löschen

Parameter:

  • name - der Name in Redis
  • value - zu löschender Wert
  • num - num=0, alle angegebenen Werte in der Liste löschen;
  • num=2 - 2 von vorne nach hinten löschen; num=1, das erste von links von vorne nach hinten löschen
  • num=-2 - 2 von hinten nach vorne löschen

Beispiel

r.lrem("list2", "11", 1)    # Das erste Vorkommen von "11" von links in der Liste löschen
print(r.lrange("list2", 0, -1))
r.lrem("list2", "99", -1)    # Das erste Vorkommen von "99" von rechts in der Liste löschen
print(r.lrange("list2", 0, -1))
r.lrem("list2", "22", 0)    # Alle "22" in der Liste löschen
print(r.lrange("list2", 0, -1))

8. Löschen und zurückgeben

lpop(name)

Das erste Element von der linken Seite der Liste, die name entspricht, abrufen und es aus der Liste entfernen; der Rückgabewert ist das erste Element

Mehr:

rpop(name) bedeutet von rechts nach links zu arbeiten

Beispiel

r.lpop("list2")    # Das am weitesten links stehende Element der Liste löschen und das gelöschte Element zurückgeben
print(r.lrange("list2", 0, -1))
r.rpop("list2")    # Lösche das rechteste Element der Liste und gib das gelöschte Element zurück
print(r.lrange("list2", 0, -1))

9. Werte außerhalb des Indexbereichs löschen

ltrim(name, start, end)

In der Liste, die name entspricht, Werte entfernen, die nicht zwischen den start-end-Indizes liegen

Parameter:

  • name - der Name in Redis
  • start - Startindexposition
  • end - Endindexposition

Beispiel

r.ltrim("list2", 0, 2)    # Elemente außerhalb des Index 0-2 löschen, Elemente mit den Indizes 0-2 behalten
print(r.lrange("list2", 0, -1))

10. Wert abrufen (Wert anhand des Index abrufen)

lindex(name, index)

Das Listenelement anhand des Index in der Liste abrufen, die name entspricht

print(r.lindex("list2", 0))  # 取出索引号是0的值

11. Ein Element von einer Liste in eine andere Liste verschieben

rpoplpush(src, dst)

Das rechteste Element aus einer Liste nehmen und es ganz links an eine andere Liste anhängen

Parameter:

  • src - der Name der Liste, aus der Daten entnommen werden
  • dst - der Name der Liste, zu der Daten hinzugefügt werden sollen
r.rpoplpush("list1", "list2")
print(r.lrange("list2", 0, -1))

12. Verschiebe ein Element von einer Liste in eine andere Liste, mit Timeout-Unterstützung

brpoplpush(src, dst, timeout=0)

Entferne ein Element von der rechten Seite einer Liste und füge es zur linken Seite einer anderen Liste hinzu

Parameter:

  • src - der Name der Liste, aus der das Element entnommen und entfernt wird
  • dst - der Name der Liste, in die das Element eingefügt wird
  • timeout - wenn in der Liste, die src entspricht, keine Daten vorhanden sind, die Timeout-Dauer (Sekunden) für das Blockieren, bis Daten verfügbar sind; 0 bedeutet unendlich blockieren

Beispiel

r.brpoplpush("list1", "list2", timeout=2)
print(r.lrange("list2", 0, -1))

13. Entferne gleichzeitig aus mehreren Listen

blpop(keys, timeout)

Ordne mehrere Listen an und entnehme Elemente aus den entsprechenden Listen von links nach rechts

Parameter:

  • keys - eine Sammlung von Redis-Namen
  • timeout - Timeout-Zeitraum; nach dem Abrufen von Elementen aus allen Listen die Zeit (Sekunden) für das blockierende Warten auf Daten in der Liste; 0 bedeutet unendlich blockieren

Mehr:

r.brpop(keys, timeout)Wie blpop, mehrere Listen anordnen und Elemente aus jeder Liste von rechts nach links entfernen

Beispiel

r.lpush("list10", 3, 4, 5)
r.lpush("list11", 3, 4, 5)
while True:
    r.blpop(["list10", "list11"], timeout=2)
    print(r.lrange("list10", 0, -1), r.lrange("list11", 0, -1))

14. Benutzerdefinierte inkrementelle Iteration

Da die redis-Bibliothek keine inkrementelle Iteration für Listenelemente bereitstellt, müssen Sie, wenn Sie über alle Elemente der Liste iterieren möchten, die name entspricht, die gesamte Liste abrufen, die name entspricht.

Die Liste durchlaufen

Wenn die Liste jedoch sehr groß ist, kann sie im ersten Schritt den Speicher des Programms erschöpfen, daher ist es notwendig, eine benutzerdefinierte inkrementelle Iterationsfunktion zu definieren:

Beispiel

def list_iter(name):
    """
Benutzerdefinierte inkrementelle Iteration für Redis-Listen
:param name: der Name in Redis, d. h. über die Liste iterieren, die name entspricht
:return: yield gibt Listenelemente zurück
    """
    list_count = r.llen(name)
    for index in range(list_count):
        yield r.lindex(name, index)

# Verwendung
for item in list_iter('list2'): # Diese Liste durchlaufen
    print(item)

6. Redis-Grundbefehle Set

1. Hinzufügen

sadd(name,values)

name - Elemente zum entsprechenden Set hinzufügen

Beispiel

r.sadd("set1", 33, 44, 55, 66)  # Elemente zum Set hinzufügen
print(r.scard("set1"))  # Die Länge des Sets ist 4
print(r.smembers("set1"))   # Alle Mitglieder im Set abrufen

2. Anzahl der Elemente abrufen, ähnlich wie len

scard(name)

Anzahl der Elemente im Set abrufen, das name entspricht

print(r.scard("set1"))  # 集合的长度是4

3. Alle Mitglieder der Menge abrufen

smembers(name)

Alle Mitglieder der Menge abrufen, die dem Namen entspricht

print(r.smembers("set1"))   # 获取集合中所有的成员

Alle Mitglieder der Menge abrufen - in Tupelform

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

Beispiel:

print(r.sscan("set1"))

Alle Mitglieder der Menge abrufen - Iteratormethode

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

Ähnlich wie String-Operationen, verwendet für inkrementelle Iteration, um Elemente in Batches abzurufen, wodurch übermäßiger Speicherverbrauch vermieden wird

for i in r.sscan_iter("set1"):
    print(i)

4. Differenz

sdiff(keys, *args)

Die Menge der Elemente, die in der Menge enthalten sind, die dem ersten Namen entspricht, aber nicht in den Mengen, die den anderen Namen entsprechen

Beispiel

r.sadd("set2", 11, 22, 33)
print(r.smembers("set1"))   # Alle Mitglieder im Set abrufen
print(r.smembers("set2"))
print(r.sdiff("set1", "set2"))   # In set1, aber nicht in set2
print(r.sdiff("set2", "set1"))   # In set2, aber nicht in set1

5. Differenz - die Differenz in einer neuen Menge speichern

sdiffstore(dest, keys, *args)

Ruft Elemente in der Menge ab, die dem ersten Namen entspricht, aber nicht in Mengen, die anderen Namen entsprechen, und fügt sie dann der Menge hinzu, die dest entspricht

Beispiel

r.sdiffstore("set3", "set1", "set2")    # In set1, aber nicht in set2
print(r.smembers("set3"))   # Alle Mitglieder in set3 abrufen

6. Schnittmenge

sinter(keys, *args)

Ruft die Schnittmenge der Mengen ab, die mehreren Namen entsprechen

print(r.sinter("set1", "set2")) # 取2个集合的交集

7. Schnittmenge - die Schnittmenge in einer neuen Menge speichern

sinterstore(dest, keys, *args)

Ruft die Vereinigung der Mengen ab, die mehreren Namen entsprechen, und fügt sie dann der Menge hinzu, die dest entspricht

print(r.sinterstore("set3", "set1", "set2")) # 取2个集合的交集
print(r.smembers("set3"))

Vereinigung

sunion(keys, *args)

Ruft die Vereinigung der Mengen ab, die mehreren Namen entsprechen

print(r.sunion("set1", "set2")) # 取2个集合的并集

Vereinigung - die Vereinigung in einer neuen Menge speichern

sunionstore(dest,keys, *args)

Ruft die Vereinigung der Mengen ab, die mehreren Namen entsprechen, und speichert das Ergebnis in der Menge, die dest entspricht

print(r.sunionstore("set3", "set1", "set2")) # 取2个集合的并集
print(r.smembers("set3"))

8. Prüfen, ob es ein Mitglied der Menge ist, ähnlich wie "in"

sismember(name, value)

Prüft, ob value ein Mitglied der Menge ist, die name entspricht; das Ergebnis ist True oder False

print(r.sismember("set1", 33))  # 33是集合的成员
print(r.sismember("set1", 23))  # 23不是集合的成员

9. Verschieben

smove(src, dst, value)

Ein Element von einer Menge in eine andere Menge verschieben

r.smove("set1", "set2", 44)
print(r.smembers("set1"))
print(r.smembers("set2"))

10. Löschen - zufällig löschen und den gelöschten Wert zurückgeben

spop(name)

Ein Element aus der Menge entfernen und zurückgeben. Hinweis: Die Menge ist ungeordnet, daher wird es zufällig gelöscht.

print(r.spop("set2"))   # 这个删除的值是随机删除的，集合是无序的
print(r.smembers("set2"))

11. Löschen - nach angegebenem Wert löschen

srem(name, values)

Bestimmte Werte aus der Menge löschen, die name entspricht

print(r.srem("set2", 11))   # 从集合中删除指定值 11
print(r.smembers("set2"))

7. Redis-Grundbefehle für geordnete Mengen

Mengenoperationen: Eine Menge ist eine Liste, die keine Duplikate zulässt und von Natur aus ungeordnet ist.

Geordnete Menge: Basierend auf einer Menge wird jedes Element sortiert; zum Sortieren ist ein Vergleich anhand eines anderen Werts erforderlich. Daher hat jedes Element einer geordneten Menge zwei Werte: Wert und Score. Der Score wird speziell zum Sortieren verwendet.

1. Hinzufügen

zadd(name, *args, **kwargs)

Elemente zur geordneten Menge entsprechend name hinzufügen

Zum Beispiel:

Beispiel

import redis
import time

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

r.zadd("zset1", n1=11, n2=22)
r.zadd("zset2", 'm1', 22, 'm2', 44)
print(r.zcard("zset1")) # Länge des Sets
print(r.zcard("zset2")) # Länge des Sets
print(r.zrange("zset1", 0, -1))   # Alle Elemente in der geordneten Menge abrufen
print(r.zrange("zset2", 0, -1, withscores=True))   # Alle Elemente und Scores in der geordneten Menge abrufen

2. Anzahl der Elemente in der geordneten Menge abrufen, ähnlich wie len

zcard(name)

Anzahl der Elemente in der name entsprechenden geordneten Menge abrufen

print(r.zcard("zset1")) # 集合长度

3. Alle Elemente der geordneten Menge abrufen

r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)

Elemente der name entsprechenden geordneten Menge nach Indexbereich abrufen

Parameter:

  • name - der Name in Redis
  • start - Startposition des Index der geordneten Menge (nicht Score)
  • end - Endposition des Index der geordneten Menge (nicht Score)
  • desc - Sortierregel, standardmäßig nach Score von niedrig nach hoch sortiert
  • withscores - ob der Score des Elements abgerufen werden soll; standardmäßig wird nur der Wert des Elements abgerufen
  • score_cast_func - Funktion zur Datenkonvertierung des Scores

3-1 In absteigender Reihenfolge sortieren (wie bei zrange wird das Set in absteigender Reihenfolge sortiert)

zrevrange(name, start, end, withscores=False, score_cast_func=float)

Beispiel

print(r.zrevrange("zset1", 0, -1))    # 只获取元素，不显示分数
print(r.zrevrange("zset1", 0, -1, withscores=True)) # 获取有序集合中所有元素和分数,分数倒序

3-2 Elemente des zu name gehörenden sortierten Sets nach Score-Bereich abrufen

zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)

Beispiel

Beispiel

for i in range(1, 30):
   element = 'n' + str(i)
   r.zadd("zset3", element, i)
print(r.zrangebyscore("zset3", 15, 25)) # # Elemente abrufen, die die Bedingung mit Scores zwischen 15-25 erfüllen
print(r.zrangebyscore("zset3", 12, 22, withscores=True))    # Elemente abrufen, die die Bedingung mit Scores zwischen 12-22 erfüllen (mit Scores)

3-3 Elemente des sortierten Sets nach Score-Bereich abrufen und sortieren (standardmäßig absteigend)

zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

Beispiel

print(r.zrevrangebyscore("zset3", 22, 11, withscores=True)) # 在分数是22-11之间，取出符合条件的元素 按照
Scores in umgekehrter Reihenfolge

3-4 Alle Elemente abrufen - standardmäßig nach Score-Reihenfolge sortiert

zscan(name, cursor=0, match=None, count=None, score_cast_func=float)

Beispiel

print(r.zscan("zset3"))

3-5 Alle Elemente abrufen - Iterator

zscan_iter(name, match=None, count=None,score_cast_func=float)

Beispiel

for i in r.zscan_iter("zset3"): # 遍历迭代器
    print(i)

4.zcount(name, min, max)

Gibt die Anzahl der Scores in der sortierten Menge zurück, die name entspricht, die zwischen [min, max] liegen

print(r.zrange("zset3", 0, -1, withscores=True))
print(r.zcount("zset3", 11, 22))

5. Inkrementieren

zincrby(name, value, amount)

Inkrementiert den Score, der value in der sortierten Menge entspricht, die name entspricht

r.zincrby("zset3", "n2", amount=2)    # 每次将n2的分数自增2
print(r.zrange("zset3", 0, -1, withscores=True))

6. Den Index eines Werts abrufen

zrank(name, value)

Den Index eines bestimmten Werts in der sortierten Menge abrufen, die name entspricht (beginnend bei 0)

Mehr:

zrevrank(name, value), sortiert vom größten zum kleinsten.

Beispiel

print(r.zrank("zset3", "n1"))   # Der Index von n1 ist 0, hier in Score-Reihenfolge (von klein nach groß)
print(r.zrank("zset3", "n6"))   # Der Index von n6 ist 1

print(r.zrevrank("zset3", "n1"))    # Der Index von n1 ist 29, hier in umgekehrter Score-Reihenfolge (von groß nach klein)

7. Löschen – nach angegebenem Wert löschen

zrem(name, values)

Löscht Mitglieder, deren Wert einer der Werte in der sortierten Menge ist, die name entspricht

r.zrem("zset3", "n3")   # 删除有序集合中的元素n3 删除单个
print(r.zrange("zset3", 0, -1))

8. Löschen – nach Rangbereich löschen, gemäß Indexnummer

zremrangebyrank(name, min, max)

Nach Rangbereich löschen

r.zremrangebyrank("zset3", 0, 1)  # 删除有序集合中的索引号是0, 1的元素
print(r.zrange("zset3", 0, -1))

9. Löschen – nach Score-Bereich löschen

zremrangebyscore(name, min, max)

Nach Score-Bereich löschen

r.zremrangebyscore("zset3", 11, 22)   # 删除有序集合中的分数是11-22的元素
print(r.zrange("zset3", 0, -1))

10. Den Score abrufen, der einem Wert entspricht

zscore(name, value)

Den Score abrufen, der dem Wert in der sortierten Menge entspricht, die name zugeordnet ist

print(r.zscore("zset3", "n27"))   # 获取元素n27对应的分数27

8. Weitere gängige Operationen

1. Löschen

delete(*names)

Beliebigen Datentyp in Redis anhand des Namens löschen (string, hash, list, set, sorted set)

r.delete("gender")  # 删除key为gender的键值对

2. Prüfen, ob ein Name existiert

exists(name)

Prüfen, ob der Name in Redis existiert; True, wenn er existiert, False, wenn nicht

print(r.exists("zset1"))

3. Fuzzy-Matching

keys(pattern='')

Redis-Namen nach einem Muster abrufen

Mehr:

  • KEYS * entspricht allen Schlüsseln in der Datenbank.
  • KEYS h?llo entspricht hello, hallo, hxllo usw.
  • KEYS hllo entspricht hllo und heeeeello usw.
  • KEYS h[ae]llo entspricht hello und hallo, aber nicht hillo
print(r.keys("foo*"))

4. Timeout setzen

expire(name ,time)

Ein Timeout für einen Namen in Redis setzen

r.lpush("list5", 11, 22)
r.expire("list5", time=3)
print(r.lrange("list5", 0, -1))
time.sleep(3)
print(r.lrange("list5", 0, -1))

5. Umbenennen

rename(src, dst)

Einen Namen in Redis umbenennen

r.lpush("list5", 11, 22)
r.rename("list5", "list5-1")

6. Einen zufälligen Namen abrufen

randomkey()

Einen zufälligen Namen aus redis abrufen (ohne Löschen)

print(r.randomkey())

7. Typ abrufen

type(name)

Den Typ des Werts abrufen, der name entspricht

print(r.type("set1"))
print(r.type("hash2"))

8. Alle Elemente anzeigen

Beispiel

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

print(r.hscan("hash2"))
print(r.sscan("set3"))
print(r.zscan("zset2"))
print(r.getrange("foo1", 0, -1))
print(r.lrange("list2", 0, -1))
print(r.smembers("set3"))
print(r.zrange("zset3", 0, -1))
print(r.hgetall("hash1"))

9. Alle Elemente anzeigen - Iterator

Beispiel

scan_iter(match=None, count=None)

for i in r.hscan_iter("hash1"):
    print(i)

for i in r.sscan_iter("set3"):
    print(i)

for i in r.zscan_iter("zset3"):
    print(i)

andere Methoden

Beispiel

print(r.get('name'))    # Wert mit Schlüssel name abfragen
r.delete("gender")  # Das Schlüssel-Wert-Paar mit Schlüssel gender löschen
print(r.keys()) # Alle Schlüssel abfragen
print(r.dbsize())   # Wie viele Datensätze das aktuelle Redis enthält
r.save()    # Führt die "checkpoint"-Operation aus, um Daten auf die Festplatte zurückzuschreiben. Blockiert während des Speicherns.
# r.flushdb() # Alle Daten in r löschen

Pipeline (pipeline)

Standardmäßig erstellt redis für jede Anfrage eine Verbindung und trennt sie wieder (es wird eine Verbindung aus dem Verbindungspool angefordert und an den Pool zurückgegeben). Wenn Sie mehrere Befehle in einer Anfrage angeben möchten, können Sie pipeline verwenden, um mehrere Befehle in einer Anfrage auszuführen, und standardmäßig ist eine pipeline eine atomare Operation.

Pipeline ist eine Unterklasse der Basisklasse, die redis zum Puffern mehrerer Serverbefehle in einer einzigen Anfrage bereitstellt. Sie verbessert die Funktionalität zum Ausführen von Batch-Befehlen erheblich, indem sie wiederholte TCP-Pakete zwischen Server und Client reduziert.

Beispiel

import redis
import time

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)

# pipe = r.pipeline(transaction=False) # Standardmäßig gewährleisten Befehle, die in der pipeline ausgeführt werden, Atomarität; das Ausführen von pipe = r.pipeline(transaction=False) deaktiviert diese Funktion.
# pipe = r.pipeline(transaction=True)
pipe = r.pipeline() # Eine Pipeline erstellen

pipe.set('name', 'jack')
pipe.set('role', 'sb')
pipe.sadd('faz', 'baz')
pipe.incr('num')    # Wenn num nicht existiert, ist der Wert 1; falls es existiert, wird der Wert um 1 erhöht
pipe.execute()

print(r.get("name"))
print(r.get("role"))
print(r.get("num"))

Pipeline-Befehle können zusammen geschrieben werden, zum Beispiel:

Beispiel

pipe.set('hello', 'redis').sadd('faz', 'baz').incr('num').execute()
print(r.get("name"))
print(r.get("role"))
print(r.get("num"))

Autor: Junxi丶

Link:https://www.jianshu.com/p/2639549bedc8