Datenverarbeitungsmethoden von Python Redis

1. Vorwort

Redis: Remote Dictionary Server, das heißt, die unterste Ebene von Redis ist eine speicherbasierte Open-Source-NoSql-Datenbank andere Datenbanken und unterstützt Cluster. Es bietet die Vorteile der Verteilung und Master-Slave-Synchronisation und wird daher häufig in Szenarien wie dem Zwischenspeichern von Daten und dem Lesen und Schreiben mit hoher Geschwindigkeit verwendet.

2 Vorbereitung

Wir übernehmen die Installation von Beispiel: Redis-Server auf dem Cloud-Server Centos 7.8

Konfigurationsdateiverzeichnis: /etc/redis.conf

bind wird auf 0.0.0.0 geändert, um externen Netzwerkzugriff zu ermöglichen

requirepass Legen Sie ein Zugangspasswort fest

• # 下载epel仓库
  yum install epel-release
  
  # 安装redis
  yum install redis

  Es sollte darauf hingewiesen werden, dass dies der Fall ist Stellen Sie die Sicherheit der Cloud-Serverdaten sicher. Wenn Redis den Fernzugriff öffnet, muss das Kennwort gestärkt werden
• Starten Sie dann den Redis-Dienst, öffnen Sie die Firewall und den Port und konfigurieren Sie die Cloud-Server-Sicherheitsgruppe Der Redis-Dienst ist 6379
  Darüber hinaus muss er in der Cloud-Server-Sicherheitsgruppe konfiguriert werden, um sicherzustellen, dass die Redis-Datenbank normal verbunden werden kann

# vim /etc/redis.conf
# 1、bing从127.0.0.1修改为:0.0.0.0，开放远程连接
bind 0.0.0.0 

# 2、设置密码
requirepass 123456

Nach Abschluss der oben genannten Vorgänge können wir Redis-CLI oder das Redis-Client-Tool verwenden Um eine Verbindung herzustellen

Um Python zum Betrieb von Redis zu verwenden, müssen wir schließlich pip verwenden, um eine Abhängigkeit zu installieren

# 启动Redis服务，默认redis端口号是6379
systemctl start redis 

# 打开防火墙
systemctl start firewalld.service

# 开放6379端口
firewall-cmd --zone=public --add-port=6379/tcp --permanent   

# 配置立即生效
firewall-cmd --reload

3 Praktischer Kampf

Bevor wir die Daten in Redis betreiben, müssen wir den Host, die Portnummer und das Passwort instanziieren ein Redis-Verbindungsobjekt Es gibt zwei Möglichkeiten, Zeichenfolgen zu bedienen: set() und mset()

Unter ihnen: set() kann jeweils nur einen Wert speichern

Name: Schlüssel , stellt den Schlüssel dar

Wert: Wert, der zu speichernde Wert

Beispiel: Ablaufzeit in Sekunden, wenn nicht festgelegt, läuft er nie ab, andernfalls wird er gelöscht, wenn er abläuft

px: Ablaufzeit in Millisekunden Einheit

• nx/xx: Ob die Set-Operation ausgeführt wird, hängt davon ab, ob der Namensschlüssel vorhanden ist

• Die Operationsmethoden zum Abrufen des Werts und Löschen des Werts sind: get(Key), delete(Key or Keys)

  # 安装依赖，便于操作redis
  pip3 install redis

Für die Einstellung mehrwertiger Daten müssen Sie nur die Methode mset() aufrufen und die Schlüssel-Wert-Paare verwenden, um ein Wörterbuch als Parameter für zu bilden die einzufügenden Daten

• Ähnlich stellt Redis die mget()-Methode bereit, mit der mehrere Werte gleichzeitig abgerufen werden können. Der Wert des Schlüssels

  from redis import Redis
  
  class RedisF(object):
  
      def __init__(self):
          # 实例化Redis对象
          # decode_responses=True，如果不加则写入的为字节类型
          # host：远程连接地址
          # port：Redis端口号
          # password：Redis授权密码
          self.redis_obj = Redis(host='139.199.**.**',port=6379,password='123456',decode_responses=True,charset='UTF-8', encoding='UTF-8')

2 Häufigere davon sind wie folgt:
lpush/rpush: Fügen Sie einen oder mehrere Werte in den Kopf oder das Ende der Liste ein, wobei lpush für das Einfügen von Daten am Ende steht.

lset: Fügen Sie den Wert über den Index an der entsprechenden Position der Liste ein.

linsert: Fügen Sie Daten vor oder nach dem Listenelement ein. 1 stellt das letzte Element dar.

lrange: Rufen Sie den Wert des angegebenen Bereichs aus der Liste ab, indem Sie die Start- und Endposition angeben nicht vorhanden, 0 zurückgeben

• lpop: Entfernen Sie das erste Element in der Liste und geben Sie es zurück.

• rpop: Entfernen Sie das erste Element in der Liste und geben Sie es zurück. Das letzte Element

• Der Beispielcode lautet wie folgt:

  # set()：单字符串操作
  # 添加一个值，并设置超时时间为120s
   self.redis_obj.set('name', 'airpython', ex=120)
  
  # get()：获取这个值
  print(self.redis_obj.get('name'))
  
  # delete()：删除一个值或多个值
  self.redis_obj.delete('name')
  print(self.redis_obj.get('name'))

  3. Operation Set-Sammlung
• Set ist eine ungeordnete Sammlung von Elementen. Redis bietet auch viele Methoden, um die Operation der Set-Sammlung zu erleichtern folgt:

• sadd: Elemente zum Set hinzufügen, die bereits im Set vorhanden sind, werden ignoriert. Wenn das Set nicht existiert, erstellen Sie ein neues Set

• scard: Gibt die Anzahl der Set-Elemente zurück

• smembers: Gibt alle Elemente in der Menge zurück

• srem: Entfernt ein oder mehrere Elemente in der Menge und ignoriert, wenn das Element nicht existiert.

sinter: Gibt den Schnittpunkt zweier Mengen zurück, das Ergebnis ist immer noch eins Set

sunion: Gibt die Vereinigung zweier Mengen zurück

sdiff: Gibt unter Verwendung des ersten Mengenparameters als Standard die Differenzmenge zweier Mengen zurück

• sunionstore: Berechnet die Vereinigung zweier Mengen, Speichern unter eine neue Sammlung

• sismember: Bestimmen Sie, ob ein Element in der Sammlung vorhanden ist

• spop: Löschen Sie zufällig ein Element in der Sammlung und geben Sie es zurück

• Der spezifische Beispielcode lautet wie folgt:

# mset()：设置多个值
self.redis_obj.mset({"foo": "foo1", "zoo": "zoo1"})

# mget()：获取多个值
result = self.redis_obj.mget("foo", "zoo")
print(result)

• 4 , betreiben Die Zset-Sammlung ist im Vergleich zur gewöhnlichen Set-Sammlung geordnet. Zu den Elementen in der Zset-Sammlung gehören: Wert und Punktzahl, wobei die Punktzahl zum Sortieren verwendet wird

  其中，比较常用的方法如下：

  • zadd：往集合中新增元素，如果集合不存在，则新建一个集合，然后再插入数据

  • zrange：通过起始点和结束点，返回集合中的元素值（不包含分数）;如果设置withscores=True，则返回结果会带上分数

  • zscore：获取某一个元素对应的分数

  • zcard：获取集合中元素个数

  • zrank：获取元素在集合中的索引

  • zrem：删除集合中的元素

  • zcount：通过最小值和最大值，判断分数在这个范围内的元素个数

  实践代码如下：

  def manage_zset(self):
      """
      操作zset集合
      :return:
      """
      self.redis_obj.delete("fruit")
  
      # 往集合中新增元素：zadd()
      # 三个元素分别是："banana", 1/"apple", 2/"pear", 3
      self.redis_obj.zadd("fruit", "banana", 1, "apple", 2, "pear", 3)
  
      # 查看集合中所有元素（不带分数）
      result = self.redis_obj.zrange("fruit", 0, -1)
      # ['banana', 'apple', 'pear']
      print('集合中的元素（不带分数）有：', result)
  
      # 查看集合中所有元素（带分数）
      result = self.redis_obj.zrange("fruit", 0, -1, withscores=True)
      # [('banana', 1.0), ('apple', 2.0), ('pear', 3.0)]
      print('集合中的元素（带分数）有：', result)
  
      # 获取集合中某一个元素的分数
      result = self.redis_obj.zscore("fruit", "apple")
      print("apple对应的分数为：", result)
  
      # 通过最小值和最大值，判断分数在这个范围内的元素个数
      result = self.redis_obj.zcount("fruit", 1, 2)
      print("集合中分数大于1，小于2的元素个数有：", result)
  
      # 获取集合中元素个数
      count = self.redis_obj.zcard("fruit")
      print('集合元素格式:', count)
  
      # 获取元素的值获取索引号
      index = self.redis_obj.zrank("fruit", "apple")
      print('apple元素的索引为：', index)
  
      # 删除集合中的元素：zrem
      self.redis_obj.zrem("fruit", "apple")
      print('删除apple元素后，剩余元素为：', self.redis_obj.zrange("fruit", 0, -1))

  4、操作哈希

  哈希表中包含很多键值对，并且每一个键都是唯一的

  Redis 操作哈希表，下面这些方法比较常用：

  • hset：往哈希表中添加一个键值对值

  • hmset：往哈希表中添加多个键值对值

  • hget：获取哈希表中单个键的值

  • hmget：获取哈希表中多个键的值列表

  • hgetall：获取哈希表中种所有的键值对

  • hkeys：获取哈希表中所有的键列表

  • hvals：获取哈表表中所有的值列表

  • hexists：判断哈希表中，某个键是否存在

  • hdel：删除哈希表中某一个键值对

  • hlen：返回哈希表中键值对个数

  对应的操作代码如下：

  def manage_hash(self):
      """
      操作哈希表
      哈希：一个键对应一个值，并且键不容许重复
      :return:
      """
      self.redis_obj.delete("website")
  
      # 1、新建一个key为website的哈希表
      # 往里面加入数据：baidu（field），www.baidu.com(value)
      self.redis_obj.hset('website', 'baidu', 'www.alibababaidu.com')
      self.redis_obj.hset('website', 'google', 'www.google.com')
  
      # 2、往哈希表中添加多个键值对
      self.redis_obj.hmset("website", {"tencent": "www.qq.com", "alibaba": "www.taobao.com"})
  
      # 3、获取某一个键的值
      result = self.redis_obj.hget("website", 'baidu')
      print("键为baidu的值为：", result)
  
      # 4、获取多个键的值
      result = self.redis_obj.hmget("website", "baidu", "alibaba")
      print("多个键的值为:", result)
  
      # 5、查看hash表中的所有值
      result = self.redis_obj.hgetall('website')
      print("哈希表中所有的键值对为：", result)
  
      # 6、哈希表中所有键列表
      # ['baidu', 'google', 'tencent', 'alibaba']
      result = self.redis_obj.hkeys("website")
      print("哈希表，所有的键（列表）为:", result)
  
      # 7、哈希表中所有的值列表
      # ['www.alibababaidu.com', 'www.google.com', 'www.qq.com', 'www.taobao.com']
      result = self.redis_obj.hvals("website")
      print("哈希表，所有的值（列表）为:", result)
  
      # 8、判断某一个键是否存在
      result = self.redis_obj.hexists("website", "alibaba")
      print('alibaba这个键是否存在:', result)
  
      # 9、删除某一个键值对
      self.redis_obj.hdel("website", 'baidu')
      print('删除baidu键值对后，哈希表的数据包含：', self.redis_obj.hgetall('website'))
  
      # 10、哈希表中键值对个数
      count = self.redis_obj.hlen("website")
      print('哈希表键值对一共有：', count)

  5、操作事务管道

  Redis 支持事务管道操作，能够将几个操作统一提交执行

  操作步骤是：

  • 首先，定义一个事务管道

  • 然后通过事务对象去执行一系列操作

  • 提交事务操作，结束事务操作

  下面通过一个简单的例子来说明：

  def manage_steps(self):
      """
      执行事务操作
      :return:
      """
      # 1、定义一个事务管道
      self.pip = self.redis_obj.pipeline()
  
      # 定义一系列操作
      self.pip.set('age', 18)
  
      # 增加一岁
      self.pip.incr('age')
  
      # 减少一岁
      self.pip.decr('age')
  
      # 执行上面定义3个步骤的事务操作
      self.pip.execute()
  
      # 判断
      print('通过上面一些列操作，年龄变成:', self.redis_obj.get('age'))

Das obige ist der detaillierte Inhalt vonDatenverarbeitungsmethoden von Python Redis. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!