redis的操作

redis相当于是一个在内存中创建的大字典

redis的value有5大数据类型：

　　

redis的value有5大数据类型：
    字符串
　　

　　　　import redis
　　　　conn = redis.Redis(host='192.168.11.61',port=6379)
　　　　# 设置值
　　　　conn.set('laowang_name','laowang')
　　　　　　# 获取值
　　　　val = conn.get('laowang_name').decode('utf-8')
　　　　print(val)

    列表
    字典
    集合
    有序集合

其实redis是一个可以构造内部数据的大字典

只要外面的大字典类型不变  那么我们就可以随意构造内部的字典，（里面的key的长度类型可以随意拼接）

首先你要知道redis怎么设置值和获取值

你要先导入redis模块

import redis
然后去连接你的redis 并且设置一个对象获取连接内容
CONN = redis.Redis(host="192.169.11.11",port = )  # redis默认的端口是6379
然后设置值：
CONN.set(键,值)  #设置键值
然后获取值
CONN.get(键,).decode（"utf-8"）

x

redis设置值：

　　

set	字符串设置	h获取的是字符串类型的值
hset	字典类型设置	字典类型的值

　　

CONN.set("laowang","老王")  #给redis设置一个键值laowang，值是老王的值

CONN.hset("xx","laowang","老王")  # 给redis中的xx中字典中设置一个键laowang值是老王

Django连接数据库有两种，一种是配置在全局（比较麻烦，但是一次搞定终身使用），一种是配置在你使用的视图函数中（直接连接，但是每一个需要的视图函数都要连接一次）

在每一个使用的视图中配置：

import redis   # 导入rdis模块
CONN = redis.Redis(host = "211.159.153.150",port = 6379)  # 连接redis数据库并且创建一个连接对象

后面的操作都用这个连接对象来进行操作

在settings中配置全局系信息：

　　　　

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://192.168.11.61:6379",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
            "CONNECTION_POOL_KWARGS": {"max_connections": 100},
            # "PASSWORD": "密码",
        }
    }
}

如果配置了全局信息就要从你的全局中找  就不能用redis模块而是django_redis

from django_redis import get_redis_connection # 导入连接模块
CONN = get_redis_connection("default")  # 进行连接  和你的全局中的redis信息连接

 

settings中的default：如果你只使用一个redis服务器就用这个名字，要是你用多个redis服务器就需要用不同的名字来区分不同的redis的服务器

连接池:

redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import redis

pool = redis.ConnectionPool(host='10.211.55.4', port=6379)

r = redis.Redis(connection_pool=pool)
r.set('foo', 'Bar')
print r.get('foo')

操作

String操作，redis中的String在在内存中按照一个name对应一个value来存储

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

在Redis中设置值，默认，不存在则创建，存在则修改
参数：
     ex，过期时间（秒）
     px，过期时间（毫秒）
     nx，如果设置为True，则只有name不存在时，当前set操作才执行
     xx，如果设置为True，则只有name存在时，岗前set操作才执行

setnx(name, value)
1

设置值，只有name不存在时，执行设置操作（添加）

setnx(name, value)

1	设置值，只有name不存在时，执行设置操作（添加）

setex(name, value, time)

1 2 3

# 设置值 # 参数：     # time，过期时间（数字秒 或 timedelta对象）

psetex(name, time_ms, value)

1 2 3

# 设置值 # 参数：     # time_ms，过期时间（数字毫秒 或 timedelta对象）

conn.psetex("name",6000, "老张")  # 设置一个只值6000毫秒后过期

mset(*args, **kwargs)

1 2 3 4 5

批量设置值 如：     mset(k1='v1', k2='v2')     或     mget({'k1': 'v1', 'k2': 'v2'})

获取值就是用get

val = conn.get("laowang_name").decode("utf8")  # 获取道的值需要decode

批量获取:mget

批量获取
如：
    mget('ylr', 'wupeiqi')
    或
    r.mget(['ylr', 'wupeiqi'])

conn.psetex("name",6000, "老张")
val = conn.mget("laowang_name", "name")

print(val)  # [b'laowang', b'\xe8\x80\x81\xe5\xbc\xa0'] 得到的是一个列表
for i in val:
    m = i.decode("utf8")
    print(m)

getset(name, value)

1	设置新值并获取原来的值

hash操作，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时则创建（相当于添加）

hset(name, key, value)

1 2 3 4 5 6 7 8 9

# name对应的hash中设置一个键值对（不存在，则创建；否则，修改）   # 参数：     # name，redis的name     # key，name对应的hash中的key     # value，name对应的hash中的value   # 注：     # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建（相当于添加）

hmset(name, mapping)

1 2 3 4 5 6 7 8

# 在name对应的hash中批量设置键值对   # 参数：     # name，redis的name     # mapping，字典，如：{'k1':'v1', 'k2': 'v2'}   # 如：     # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

hget(name,key)

1	# 在name对应的hash中获取根据key获取value

hmget(name, keys, *args)

1 2 3 4 5 6 7 8 9 10 11

# 在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')

hgetall(name)

1	获取name对应hash的所有键值

hlen(name)

1	# 获取name对应的hash中键值对的个数

hkeys(name)

1	# 获取name对应的hash中所有的key的值

hvals(name)

1	# 获取name对应的hash中所有的value的值

hexists(name, key)

1	# 检查name对应的hash是否存在当前传入的key

hdel(name,*keys)

1	# 将name对应的hash中指定key的键值对删除

hincrby(name, key, amount=1)

1 2 3 4 5

# 自增name对应的hash中的指定key的值，不存在则创建key=amount # 参数：     # name，redis中的name     # key， hash对应的key     # amount，自增数（整数）

hincrbyfloat(name, key, amount=1.0)

1 2 3 4 5 6 7 8

# 自增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)

1 2 3 4 5 6 7 8 9 10 11 12 13

# 增量式迭代获取，对于数据大的数据非常有用，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时，表示数据已经通过分片获取完毕

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

1 2 3 4 5 6 7 8 9

# 利用yield封装hscan创建生成器，实现分批去redis中获取数据   # 参数：     # match，匹配指定key，默认None 表示所有的key     # count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数   # 如：     # for item in r.hscan_iter('xx'):     #     print item

　　

List操作，redis中的List在在内存中按照一个name对应一个List来存储。如图：

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

hincrbyfloat(name, key, amount=1.0)

1 2 3 4 5 6 7 8

# 自增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)

1 2 3 4 5 6 7 8 9 10 11 12 13

# 增量式迭代获取，对于数据大的数据非常有用，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时，表示数据已经通过分片获取完毕

.