澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:数据库操作Memcache,学习笔

2019-07-15 作者:www.8455.com   |   浏览(92)

缓存

python---Redis 学习笔记,python---redis

缓存

前言:

世家都听过缓存,缓存是干啥的吧?大家得以和json和pickle来讲,八个程序之间完毕音讯互相,可以通过在A程序中把数量改成json ,然后传给B程序,通过文件这么些介质。文件这一个频率相当低。

举个例子说二个是QQ,四个是微信,大家想要达成三头的相互,大家前边学了rabbitMQ,能够达成消息的传递;对于数据的分享,qq存款和储蓄的数额微信能够平昔获得,这么些数额是坐落内部存款和储蓄器中的,这大家怎么落到实处八个内部存款和储蓄器分享呢?大家要有壹当中间商,中间商再运维多少个单身的次序,自个儿开荒一块内部存款和储蓄器,QQ和中间商创设叁个socket,微信和中等商业创建一个socket,那样就落实了数码共享。这一个中间商正是缓存。

主流的缓存:mongodb,redis,memcache。

一、Memcached

Python开采【十一章】:数据库操作Memcache、Redis,memcacheredis

一、Memcached

Memcached 是二个高质量的布满式内部存储器对象缓存系统,用于动态Web应用以缓解数据库负载。它经过在内部存款和储蓄器中缓存数据和目的来压缩读取数据库的次数,进而提升动态、数据库驱动网站的速度。Memcached基于一个存款和储蓄键/值对的hashmap。其守护进程(daemon )是用C写的,不过客户端能够用任何语言来编排,并由此memcached协议与护理进程通讯。

1、安装和着力使用

Memcached安装:

wget http://memcached.org/latest
tar -zxvf latest
cd memcached-1.x.x
./configure && make && make test && sudo make install

ps:依赖包libevent
       yum install libevent-devel
       apt-get install libevent-dev

启动Memcached:

memcached -d -m 10    -u root -l 192.168.20.219 -p 12000 -c 256 -P /tmp/memcached.pi

参数说明:
    -d 是启动一个守护进程
    -m 是分配给Memcache使用的内存数量,单位是MB
    -u 是运行Memcache的用户
    -l 是监听的服务器IP地址
    -p 是设置Memcache监听的端口,最好是1024以上的端口
    -c 选项是最大运行的并发连接数,默认是1024,按照你服务器的负载量来设定
    -P 是设置保存Memcache的pid文件

Python安装Memcached模块:

python操作Memcached使用Python-memcached模块
下载安装:https://pypi.python.org/pypi/python-memcached

解压压缩包,然后在cmd命令下切换到安装包目录
执行 python setup.py install 安装

2、轻易连接

import memcache

mc = memcache.Client(["192.168.20.219:12000"],debug=True)
mc.set("foo","Hello,World")
ret = mc.get("foo")
print(ret)

# Hello,World

debug = True 表示运营出现谬误时,呈现错误音讯,上线后移除该参数

3、集群

python-memcached模块原生支持集群操作,其原理是在内部存款和储蓄器维护一个主机列表,且集群中主机的权重值和主机在列表中重新现身的次数成正比

  主机    权重
    1.1.1.1   1
    1.1.1.2   2
    1.1.1.3   1

那么在内存中主机列表为:
    host_list = ["1.1.1.1", "1.1.1.2", "1.1.1.2", "1.1.1.3", ]

要是用户依照若是要在内部存款和储蓄器中开创二个键值对(如:k1 = "v1"),那么要实行一动手续:

  • 依据算法将 k1 调换成二个数字
  • 将数字和主机列表长度求余数,获得一个值 N( 0 <= N < 列表长度 )
  • 在主机列表中依照 第2步获得的值为索引获取主机,举例:host_list[N]
  • 总是 将第3步中获得的主机,将 k1 = "v1" 放置在该服务器的内部存款和储蓄器中

代码完毕如下:

mc = memcache.Client([('1.1.1.1:12000', 1), ('1.1.1.2:12000', 2), ('1.1.1.3:12000', 1)], debug=True)

mc.set('k1', 'v1')

4、Memcache操作

① add

添加一条键值对,假诺已经存在的 key,重复试行add操作极其

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

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)
mc.add('k1', 'v1')

#MemCached: while expecting 'STORED', got unexpected response 'NOT_STORED'
#报错,对已经存在的key重复添加,失败!!!

②、replace

replace 修改有个别key的值,假若key不设有,则丰硕

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

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)
# 如果memcache中存在kkkk,则替换成功,否则异常
mc.replace('kkkk', '999')

#MemCached: while expecting 'STORED', got unexpected response 'NOT_STORED'

③、set 和 set_multi

set            设置三个键值对,如若key不设有,则开创,假如key存在,则修改
set_multi   设置八个键值对,要是key不设有,则开创,固然key存在,则修改

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

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)

mc.set('key0', 'lianzhilei')

mc.set_multi({'key1': 'val1', 'key2': 'val2'})

④、delete 和 delete_multi

delete             在Memcached中删去钦定的一个键值对
delete_multi    在Memcached中去除钦点的多少个键值对

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

import memcache

mc = memcache.Client(['192.168.20.219:12000'], debug=True)

mc.delete('key0')
mc.delete_multi(['key1', 'key2'])

⑤、get 和 get_multi

get            获取叁个键值对
get_multi   获取多二个键值对

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

import memcache

mc = memcache.Client(['192.168.20.219:12000'], debug=True)

val = mc.get('key0')
item_dict = mc.get_multi(["key1", "key2", "key3"])

⑥、append 和 prepend

append    修改钦定key的值,在该值 前面 追加内容
prepend   修改钦定key的值,在该值 前边 插入内容

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)
# k1 = "v1"

mc.append('k1', 'after')
# k1 = "v1after"

mc.prepend('k1', 'before')

⑦、decr 和 incr  

incr  自增,将Memcached中的某三个值扩展 N ( N默感到1 )
decr 自减,将Memcached中的某二个值裁减 N ( N默感觉1 )

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

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)
mc.set('k1', '777')

mc.incr('k1')
# k1 = 778

mc.incr('k1', 10)
# k1 = 788

mc.decr('k1')
# k1 = 787

mc.decr('k1', 10)
# k1 = 777

⑧、gets 和 cas

如超级市场商品剩余个数,假诺改值保存在memcache中,product_count = 900
A用户刷新页面从memcache中读取到product_count = 900
B用户刷新页面从memcache中读取到product_count = 900

假若A、B用平衡购买商品

A用户修改商品剩余个数 product_count=899
B用户修改商品剩余个数 product_count=899

如此一来缓存内的多寡便不在准确,四个用户购买商品后,商品剩余如故 899
万一选择python的set和get来操作以上进度,那么程序就能够如上述所示意况!

只要想要防止此情景的发生,只要接纳 gets 和 cas 就能够,如:

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

import memcache

mc = memcache.Client(['192.168.20.219:12000'], debug=True, cache_cas=True)

v = mc.gets('product_count')
# ...
# 如果有人在gets之后和cas之前修改了product_count,那么,下面的设置将会执行失败,剖出异常,从而避免非正常数据的产生
mc.cas('product_count', "899")

Ps:本质上每一次实践gets时,会从memcache中得到贰个自增的数字,通过cas去修改gets的值时,会教导事先获得的自增值和memcache中的自增值举行相比较,假使相等,则能够付出,假若不想等,那表示在gets和cas实践之间,又有其余人实施了gets(获取了缓冲的钦点值), 如此一来有希望出现畸形数据,则不允许修改

 

 

二、Redis

redis是一个key-value存款和储蓄系统。和Memcached类似,它援助存款和储蓄的value类型相对更加多,包蕴string(字符串)、list(链表)、set(集结)、zset(sorted set --有序会集)和hash(哈希类型)。这么些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰硕的操作,而且那些操作都以原子性的。在此基础上,redis援救各类不一样方法的排序。与memcached同样,为了有限支撑功能,数据都以缓存在内部存款和储蓄器中。差其他是redis会周期性的把革新的多少写入磁盘只怕把修改操作写入追加的记录文件,并且在此基础上落到实处了master-slave(主从)同步

1、安装和骨干使用

redis安装:

wget http://download.redis.io/releases/redis-3.0.6.tar.gz
tar xzf redis-3.0.6.tar.gz
cd redis-3.0.6
make

起步服务端:

src/redis-server

起始客户端:

src/redis-cli
redis> set foo bar
OK
redis> get foo
"bar

2、Python安装Redis模块

sudo pip install redis
or
sudo easy_install redis
or
源码安装

详见:https://github.com/WoLpH/redis-py

redis-py 的API的选择能够分类为:

  • 接连格局
  • 连接池
  • 操作管道
    • String 操作
    • Hash 操作
    • List 操作
    • Set 操作
    • Sort Set 操作
  • 管道
  • 公告订阅

3、简单连接

redis-py提供七个类Redis和StrictRedis用于落到实处Redis的一声令下,StrictRedis用于落实比比较多合法的下令,并选拔官方的语法和下令,Redis是StrictRedis的子类,用于向后至极旧版本的redis-py

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

import redis

r = redis.Redis(host='192.168.20.219', port=6379)
r.set('foo', 'Hello,World')
print(r.get('foo'))

# b'Hello,World'

4、连接池

redis-py使用connection pool来管理对贰个redis server的装有连接,幸免每一趟创立、释放连接的开支。暗中认可,各种Redis实例都会怜惜二个和谐的连接池。能够一向创设多少个连接池,然后作为参数Redis,那样就可以达成五个Redis实例分享一个连接池

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

import redis

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

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

# b'Hello,World'

5、 String操作

redis中的String在在内部存款和储蓄器中根据多少个name对应叁个value来存款和储蓄。如图:

澳门新萄京官方网站 1

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

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

127.0.0.1:6379> set name lzl ex 2
OK
127.0.0.1:6379> get name
"lzl"
127.0.0.1:6379> get name
(nil)

② setnx(name, value)

设置值,只有name不存在时,执行设置操作(添加)

127.0.0.1:6379> setnx name lianzhilei
(integer) 0
127.0.0.1:6379> get name
"lzl"
127.0.0.1:6379> setnx name2 lianzhilei
(integer) 1
127.0.0.1:6379> get name2
"lianzhilei"

③ setex(name, value, time)

# 设置值
# 参数:
    # time,过期时间(数字秒 或 timedelta对象)

127.0.0.1:6379> setex age 2 18
OK
127.0.0.1:6379> get age
"18"
127.0.0.1:6379> get age
(nil)

④ psetex(name, time_ms, value)

# 设置值
# 参数:
    # time_ms,过期时间(数字毫秒 或 timedelta对象)

⑤ mset(*args, **kwargs)

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

127.0.0.1:6379[2]> mset name lzl age 18
OK
127.0.0.1:6379[2]> keys *
1) "age"
2) "name"

⑥ get(name)

#获取值

r.set("name","lzl")
print(r.get('name'))
# b'lzl'

⑦ mget(keys, *args)

批量获取
如:
    mget('name', 'age')
    或
    r.mget(['name', 'age'])

127.0.0.1:6379[2]> mget name age
1) "lzl"
2) "18"

⑧ getset(name, value)

设置新值并获取原来的值

127.0.0.1:6379[2]> getset name eric
"lzl"
127.0.0.1:6379[2]> get name
"eric"

⑨ getrange(key, start, end)

# 获取子序列(根据字节获取,非字符)
# 参数:
    # name,Redis 的 name
    # start,起始位置(字节)
    # end,结束位置(字节)
# 如: "连志雷" ,0-3表示 "连"

127.0.0.1:6379[2]> getrange name 0 5
"lianzh"

⑩ setrange(name, offset, value)

# 修改字符串内容,从指定字符串索引开始向后替换(新值太长时,则向后添加)
# 参数:
    # offset,字符串的索引,字节(一个汉字三个字节)
    # value,要设置的值

⑪ setbit(name, offset, value)

# 对name对应值的二进制表示的位进行操作

# 参数:
    # name,redis的name
    # offset,位的索引(将值变换成二进制后再进行索引)
    # value,值只能是 1 或 0

# 注:如果在Redis中有一个对应: n1 = "foo",
        那么字符串foo的二进制表示为:01100110 01101111 01101111
    所以,如果执行 setbit('n1', 7, 1),则就会将第7位设置为1,
        那么最终二进制则变成 01100111 01101111 01101111,即:"goo"

# 扩展,转换二进制表示:

    # source = "连志雷"
    source = "foo"

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

    特别的,如果source是汉字 "连志雷"怎么办?
    答:对于utf-8,每一个汉字占 3 个字节,那么 "武沛齐" 则有 9个字节
       对于汉字,for循环时候会按照 字节 迭代,那么在迭代时,将每一个字节转换 十进制数,然后再将十进制数转换成二进制
        11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000

127.0.0.1:6379[2]> set n1 foo
OK
127.0.0.1:6379[2]> setbit n1 7 1
(integer) 0
127.0.0.1:6379[2]> get n1
"goo"

setbit巨流弊的施用场景,想想怎么情况下会用到那些效应吗?超大型的运用平台,比如新浪博客园,笔者想查看当前正在登录的用户,怎么样促成?当然你会想到,用户登入后在数据库上的用户音讯上做个标识,然后count去总括做标志的用户一齐有些许,so,当前用户查看解决;OK,好好,首先每一种用户登陆都要安装标志,倘诺当前用户多少个亿,那么得存多少个亿的暗号位,一级占用库的付出;今后就有三个庞大高效的办法,即总括当前在线用户,又显得在线用户ID,那便是利用二进制位,什么意思吧?看上边包车型大巴代码就能够领略了

统计在线用户数

127.0.0.1:6379[2]> setbit lineuser 1000 1      #1000表示用户id  
(integer) 0
127.0.0.1:6379[2]> setbit lineuser 55 1
(integer) 0
127.0.0.1:6379[2]> setbit lineuser 6000 1
(integer) 0
127.0.0.1:6379[2]> bitcount lineuser        #统计当前二进制位1的个数,即当前在线用户数
(integer) 3

bitcount总计二级制位中1的个数,setbit和bitcount合营使用,轻巧解决日前在线用户数的题目,那还不是最厉害的,大家还是能够动用那些总结当前在线的皆有哪个人

查看用户ID有没有在线

127.0.0.1:6379[2]> getbit lineuser 1000        #查看id1000   1表示在线 0表示不在线
(integer) 1
127.0.0.1:6379[2]> getbit lineuser 100
(integer) 0

理之当然我们还足以通过for循环恐怕yield生成器打字与印刷出全体的在线用户ID,1字节=8位,那么10m=八千万位,即二个亿的在线用户也就10m多的内存就可化解,优化就在点滴之间

⑫ getbit(name, offset)

# 获取name对应的值的二进制表示中的某位的值 (0或1)

⑬ bitcount(key, start=None, end=None)

# 获取name对应的值的二进制表示中 1 的个数
# 参数:
    # key,Redis的name
    # start,位起始位置
    # end,位结束位置

⑭ bitop(operation, dest, *keys)

# 获取多个值,并将值做位运算,将最后的结果保存至新的name对应的值

# 参数:
    # operation,AND(并) 、 OR(或) 、 NOT(非) 、 XOR(异或)
    # dest, 新的Redis的name
    # *keys,要查找的Redis的name

# 如:
    bitop("AND", 'new_name', 'n1', 'n2', 'n3')
    # 获取Redis中n1,n2,n3对应的值,然后讲所有的值做位运算(求并集),然后将结果保存 new_name 对应的值中

⑮ strlen(name)

# 返回name对应值的字节长度(一个汉字3个字节)

127.0.0.1:6379[2]> get name
"lianzhilei"
127.0.0.1:6379[2]> strlen name
(integer) 10

⑯ incr(self, name, amount=1)

# 自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。

# 参数:
    # name,Redis的name
    # amount,自增数(必须是整数)

# 注:同incrby

127.0.0.1:6379[2]> incr login_users     #自增
(integer) 1
127.0.0.1:6379[2]> incr login_users 
(integer) 2
127.0.0.1:6379[2]> incr login_users 
(integer) 3

⑰ incrbyfloat(self, name, amount=1.0)

# 自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。

# 参数:
    # name,Redis的name
    # amount,自增数(浮点型)

⑱ decr(self, name, amount=1)

# 自减 name对应的值,当name不存在时,则创建name=amount,否则,则自减。

# 参数:
    # name,Redis的name
    # amount,自减数(整数)

127.0.0.1:6379[2]> decr login_users     #自减
(integer) 2
127.0.0.1:6379[2]> decr login_users
(integer) 1
127.0.0.1:6379[2]> decr login_users
(integer) 0

⑲ append(key, value)

# 在redis name对应的值后面追加内容

# 参数:
    key, redis的name
    value, 要追加的字符串

127.0.0.1:6379[2]> append name jjjj
(integer) 14
127.0.0.1:6379[2]> get name
"lianzhileijjjj"

 

6、Hash操作

redis中Hash在内存中的存款和储蓄格式如下图:

澳门新萄京官方网站 2

① hset(name, key, value)

# name对应的hash中设置一个键值对(不存在,则创建;否则,修改)

# 参数:
    # name,redis的name
    # key,name对应的hash中的key
    # value,name对应的hash中的value

# 注:
    # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建(相当于添加)


127.0.0.1:6379[3]> hset class14 name lzl
(integer) 1
127.0.0.1:6379[3]> hset class14 age 18
(integer) 1
127.0.0.1:6379[3]> hset class14 id 10001
(integer) 1
127.0.0.1:6379[3]> hgetall class14
1) "name"
2) "lzl"
3) "age"
4) "18"
5) "id"
6) "10001"
127.0.0.1:6379[3]> hget class14 name
"lzl"
127.0.0.1:6379[3]> hkeys class14
1) "name"
2) "age"
3) "id"
127.0.0.1:6379[3]> hvals class14
1) "lzl"
2) "18"
3) "10001"

② hmset(name, mapping)

# 在name对应的hash中批量设置键值对

# 参数:
    # name,redis的name
    # mapping,字典,如:{'k1':'v1', 'k2': 'v2'}

# 如:
    # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

127.0.0.1:6379[3]> hmset info k1 1 k2 2
OK
127.0.0.1:6379[3]> hmget info k1 k2
1) "1"
2) "2"

③ hget(name,key)

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

④ hmget(name, keys, *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')

127.0.0.1:6379[3]> hmset info k1 1 k2 2
OK
127.0.0.1:6379[3]> hmget info k1 k2
1) "1"
2) "2"

⑤ hgetall(name)

获取name对应hash的所有键值

⑥ hlen(name)

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

127.0.0.1:6379[3]> hlen info 
(integer) 2

⑦ hkeys(name)

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

⑧ hvals(name)

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

⑨ hexists(name, key)

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

127.0.0.1:6379[3]> hexists info k1
(integer) 1
127.0.0.1:6379[3]> hexists info k3
(integer) 0

⑩ hdel(name,*keys)

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

⑪ hincrby(name, key, amount=1)

# 自增name对应的hash中的指定key的值,不存在则创建key=amount
# 参数:
    # name,redis中的name
    # key, hash对应的key
    # amount,自增数(整数)

127.0.0.1:6379[3]> hincrby info k3 1
(integer) 1
127.0.0.1:6379[3]> hincrby info k3 1
(integer) 2
127.0.0.1:6379[3]> hincrby info k3 1
(integer) 3

⑫ 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时,表示数据已经通过分片获取完毕

127.0.0.1:6379[3]> hscan info 0 match k*
1) "0"
2) 1) "k1"
   2) "1"
   3) "k2"
   4) "2"
   5) "k3"
   6) "3"

⑭ hscan_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

 

7、List操作

redis中的List在在内部存款和储蓄器中遵照三个name对应二个List来储存。如图:

澳门新萄京官方网站 3

① lpush(name,values)

# 在name对应的list中添加元素,每个新的元素都添加到列表的最左边

# 如:
    # r.lpush('oo', 11,22,33)
    # 保存顺序为: 33,22,11

# 扩展:
    # rpush(name, values) 表示从右向左操作

127.0.0.1:6379[3]> lpush names lzl alex wupeiqi 
(integer) 3
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
2) "alex"
3) "lzl"

② lpushx(name,value)

# 在name对应的list中添加元素,只有name已经存在时,值添加到列表的最左边

# 更多:
    # rpushx(name, value) 表示从右向左操作

③ llen(name)

name对应的list元素的个数

127.0.0.1:6379[3]> llen names
(integer) 3

④ linsert(name, where, refvalue, value))

# 在name对应的列表的某一个值前或后插入一个新值

# 参数:
    # name,redis的name
    # where,BEFORE或AFTER
    # refvalue,标杆值,即:在它前后插入数据
    # value,要插入的数据

127.0.0.1:6379[3]> linsert names BEFORE alex befor
(integer) 4
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
2) "befor"
3) "alex"
4) "lzl"

⑤ lset(name, index, value)

# 对name对应的list中的某一个索引位置重新赋值

# 参数:
    # name,redis的name
    # index,list的索引位置
    # value,要设置的值

127.0.0.1:6379[3]> lset names 3 LianZhiLei
OK
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
2) "befor"
3) "alex"
4) "LianZhiLei"

⑥ lrem(name, value, num)

# 在name对应的list中删除指定的值

# 参数:
    # name,redis的name
    # value,要删除的值
    # num,  num=0,删除列表中所有的指定值;
           # num=2,从前到后,删除2个;
           # num=-2,从后向前,删除2个

127.0.0.1:6379[3]> lrem names 1 befor
(integer) 1
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
2) "alex"
3) "LianZhiLei"

⑦ lpop(name)

# 在name对应的列表的左侧获取第一个元素并在列表中移除,返回值则是第一个元素

# 更多:
    # rpop(name) 表示从右向左操作

127.0.0.1:6379[3]> lpop names
"wupeiqi"

⑧ lindex(name, index)

在name对应的列表中根据索引获取列表元素

⑨ lrange(name, start, end)

# 在name对应的列表分片获取数据
# 参数:
    # name,redis的name
    # start,索引的起始位置
    # end,索引结束位置

⑩ ltrim(name, start, end)

# 在name对应的列表中移除没有在start-end索引之间的值
# 参数:
    # name,redis的name
    # start,索引的起始位置
    # end,索引结束位置

127.0.0.1:6379[3]> LRANGE names 0 -1
1) "eric"
2) "wupeiqi"
3) "alex"
4) "LianZhiLei"
127.0.0.1:6379[3]> ltrim names 1 2
OK
127.0.0.1:6379[3]> LRANGE names 0 -1
1) "wupeiqi"
2) "alex"

⑪ rpoplpush(src, dst)

# 从一个列表取出最右边的元素,同时将其添加至另一个列表的最左边
# 参数:
    # src,要取数据的列表的name
    # dst,要添加数据的列表的name

127.0.0.1:6379[3]> rpush names2 LZL
(integer) 1
127.0.0.1:6379[3]> RPOPLPUSH names names2
"alex"
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
127.0.0.1:6379[3]> lrange names2 0 -1
1) "alex"
2) "LZL"

⑫ blpop(keys, timeout)

# 将多个列表排列,按照从左到右去pop对应列表的元素

# 参数:
    # keys,redis的name的集合
    # timeout,超时时间,当元素所有列表的元素获取完之后,阻塞等待列表内有数据的时间(秒), 0 表示永远阻塞

# 更多:
    # r.brpop(keys, timeout),从右向左获取数据

⑬ brpoplpush(src, dst, timeout=0)

# 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧

# 参数:
    # src,取出并要移除元素的列表对应的name
    # dst,要插入元素的列表对应的name
    # timeout,当src对应的列表中没有数据时,阻塞等待其有数据的超时时间(秒),0 表示永远阻塞

⑭ 自定义增量迭代

# 由于redis类库中没有提供对列表元素的增量迭代,如果想要循环name对应的列表的所有元素,那么就需要:
    # 1、获取name对应的所有列表
    # 2、循环列表
# 但是,如果列表非常大,那么就有可能在第一步时就将程序的内容撑爆,所有有必要自定义一个增量迭代的功能:

def list_iter(name):
    """
    自定义redis列表增量迭代
    :param name: redis中的name,即:迭代name对应的列表
    :return: yield 返回 列表元素
    """
    list_count = r.llen(name)
    for index in xrange(list_count):
        yield r.lindex(name, index)

# 使用
for item in list_iter('pp'):
    print item

 

8、Set操作

Set会集正是不容许再次的列表

① sadd(name,values)

# name对应的集合中添加元素

127.0.0.1:6379[3]> sadd names alex alex lzl lzl jack 
(integer) 3
127.0.0.1:6379[3]> smembers names
1) "jack"
2) "alex"
3) "lzl"

② scard(name)

# 获取name对应的集合中元素个数

127.0.0.1:6379[3]> scard names
(integer) 3

③ sdiff(keys, *args)

# 在第一个name对应的集合中且不在其他name对应的集合的元素集合(差级)

127.0.0.1:6379[3]> sadd names2 eric lzl wupeiqi
(integer) 3
127.0.0.1:6379[3]> sdiff names names2
1) "alex"
2) "jack"

④ sdiffstore(dest, keys, *args)

# 获取name1集合里有但是name2集合里没有的元素,然后把元素添加到dest对应的集合中

127.0.0.1:6379[3]> SMEMBERS names
1) "jack"
2) "alex"
3) "lzl"
127.0.0.1:6379[3]> SMEMBERS names2
1) "wupeiqi"
2) "lzl"
3) "eric"
127.0.0.1:6379[3]> SDIFFSTORE dest names names2
(integer) 2
127.0.0.1:6379[3]> SMEMBERS dest
1) "alex"
2) "jack"

⑤ sinter(keys, *args)

# 获取多个name集合中的交集

127.0.0.1:6379[3]> SINTER names names2 
1) "lzl"

⑥ sinterstore(dest, keys, *args)

# 获取多个name对应集合的交集,再讲其加入到dest对应的集合中

⑦ sismember(name, value)

# 检查value是否是name对应的集合的成员

127.0.0.1:6379[3]> SISMEMBER names lzl
(integer) 1

⑧ smembers(name)

# 获取name对应的集合的所有成员

⑨ smove(src, dst, value)

# 将某个成员从一个集合中移动到另外一个集合

⑩ spop(name)

# 从集合的右侧(尾部)移除一个成员,并将其返回

⑪ srandmember(name, numbers)

# 从name对应的集合中随机获取 numbers 个元素

⑫ srem(name, values)

# 在name对应的集合中删除某些值

⑬ sunion(keys, *args)

# 获取多一个name对应的集合的并集

⑭ sunionstore(dest,keys, *args)

# 获取多一个name对应的集合的并集,并将结果保存到dest对应的集合中

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

# 同字符串的操作,用于增量迭代分批获取元素,避免内存消耗太大

127.0.0.1:6379[3]> sscan names 0 match l*
1) "0"
2) 1) "lzl"

 

 

9、有序集中

在集结的功底上,为每成分排序;成分的排序须要基于其余四个值来进展相比,所以,对于有序集中,每多少个要素有多个值,即:值和分数,分数特地用来做排序

① zadd(name, *args, **kwargs)

# 在name对应的有序集合中添加元素
# 如:
     # zadd('zz', 'n1', 1, 'n2', 2)
     # 或
     # zadd('zz', n1=11, n2=22)

127.0.0.1:6379[4]> zadd z1 10 lzl 5 alex 8 jack  11 lzl
(integer) 3
127.0.0.1:6379[4]> ZRANGE z1 0 -1
1) "alex"
2) "jack"
3) "lzl"

#按分值排序并去重

② zcard(name)

# 获取name对应的有序集合元素的数量

③ zcount(name, min, max)

# 获取name对应的有序集合中分数 在 [min,max] 之间的个数

127.0.0.1:6379[4]> ZCOUNT z1 6 9
(integer) 1

④ zincrby(name, value, amount)

# 自增name对应的有序集合的 name 对应的分数

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

# 按照索引范围获取name对应的有序集合的元素

# 参数:
    # name,redis的name
    # start,有序集合索引起始位置(非分数)
    # end,有序集合索引结束位置(非分数)
    # desc,排序规则,默认按照分数从小到大排序
    # withscores,是否获取元素的分数,默认只获取元素的值
    # score_cast_func,对分数进行数据转换的函数

# 更多:
    # 从大到小排序
    # zrevrange(name, start, end, withscores=False, score_cast_func=float)

    # 按照分数范围获取name对应的有序集合的元素
    # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
    # 从大到小排序
    # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

127.0.0.1:6379[4]> ZRANGE z1 0 -1 withscores
1) "alex"
2) "5"
3) "jack"
4) "8"
5) "lzl"
6) "11"

⑥ zrank(name, value)

# 获取某个值在 name对应的有序集合中的排行(从 0 开始)

# 更多:
    # zrevrank(name, value),从大到小排序

127.0.0.1:6379[4]> ZRANK z1 lzl
(integer) 2

#排名第二

⑦ zrangebylex(name, min, max, start=None, num=None)

# 当有序集合的所有成员都具有相同的分值时,有序集合的元素会根据成员的 值 (lexicographical ordering)来进行排序,而这个命令则可以返回给定的有序集合键 key 中, 元素的值介于 min 和 max 之间的成员
# 对集合中的每个成员进行逐个字节的对比(byte-by-byte compare), 并按照从低到高的顺序, 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话, 那么命令会认为较长的字符串比较短的字符串要大

# 参数:
    # name,redis的name
    # min,左区间(值)。   表示正无限; - 表示负无限; ( 表示开区间; [ 则表示闭区间
    # min,右区间(值)
    # start,对结果进行分片处理,索引位置
    # num,对结果进行分片处理,索引后面的num个元素

# 如:
    # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
    # r.zrangebylex('myzset', "-", "[ca") 结果为:['aa', 'ba', 'ca']

# 更多:
    # 从大到小排序
    # zrevrangebylex(name, max, min, start=None, num=None)

⑧ zrem(name, values)

# 删除name对应的有序集合中值是values的成员

# 如:zrem('zz', ['s1', 's2'])

⑨ zremrangebyrank(name, min, max)

# 根据排行范围删除

⑩ zremrangebyscore(name, min, max)

# 根据分数范围删除

⑪ zremrangebylex(name, min, max)

# 根据值返回删除

⑫ zscore(name, value)

# 获取name对应有序集合中 value 对应的分数

⑬ zinterstore(dest, keys, aggregate=None)

# 获取两个有序集合的交集,如果遇到相同值不同分数,则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

⑭ zunionstore(dest, keys, aggregate=None)

# 获取两个有序集合的并集,如果遇到相同值不同分数,则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

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

# 同字符串相似,相较于字符串新增score_cast_func,用来对分数进行操作

 

10、别的常用操作

① 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

 

11、管道

redis-py默许在实行每一趟伏乞都会成立(连接池申请连接)和断开(归还连接池)三遍一连操作,假诺想要在一遍呼吁中钦点八个指令,则能够利用pipline完毕二遍呼吁钦定多少个指令,何况暗中认可情状下贰次pipline 是原子性操作

#!/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)

# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)

pipe.set('name', 'alex')
pipe.set('role', 'sb')

pipe.execute()

 

12、发表订阅
澳门新萄京官方网站 4

redishelper:

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

import redis

class RedisHelper:

    def __init__(self):
        self.__conn = redis.Redis(host='192.168.20.219')
        self.chan_sub = 'fm104.5'
        self.chan_pub = 'fm104.5'

    def public(self, msg):
        self.__conn.publish(self.chan_pub, msg)
        return True

    def subscribe(self):
        pub = self.__conn.pubsub()      #打开收音机
        pub.subscribe(self.chan_sub)    #调频道
        pub.parse_response()           #准备接受
        return pub

订阅者:

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

from redishelper import RedisHelper

obj = RedisHelper()
redis_sub = obj.subscribe()

while True:
    msg = redis_sub.parse_response()
    print(msg)

发布者:

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

from redishelper import RedisHelper

obj = RedisHelper()
obj.public('hello')

越多参见:

  

 

一、Memcached Memcached 是八个高质量的布满式内部存款和储蓄器对象缓存系统,用于动态Web应用...

1、redis连接

redis提供八个类Redis和StrictRedis用于落到实处Redis的通令,StrictRedis用于落到实处许多合法的授命,并利用官方的语法和下令,Redis是StrictRedis的子类,用于向后特出旧版本的redis-py。

redis连接实例是线程安全的,能够直接将redis连接实例设置为二个全局变量,直接动用。假设需求另三个Redis实例(or Redis数据库)时,就要求重新创建redis连接实例来获得贰个新的连接。同理,python的redis未有落成select命令。

安装redis

pip install redis

连接redis,加上decode_responses=True,写入的键值对中的value为str类型,不加这么些参数写入的则为字节类型。

import redis   # 导入redis模块,通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库

r = redis.Redis(host='localhost', port=6379, decode_responses=True)   # host是redis主机,需要redis服务端和客户端都启动 redis默认端口是6379
r.set('name', 'junxi')  # key是"foo" value是"bar" 将键值对存入redis缓存
print(r['name'])
print(r.get('name'))  # 取出键name对应的值
print(type(r.get('name')))

前言:

Redis

redis是一个key-value存款和储蓄系统,帮助存款和储蓄的value类型相对非常多,包罗:string,list(链表),set(集结),zset(sorted set -- 有序聚焦)和hash(哈希类型)。这一个数据类型都帮忙push/pop,add/remove以及交并差集等丰富的操作,而且这个操作都是原子性的。在此基础上redis帮衬各样不一样排序的不二等秘书籍。为了确认保证功效,数据是保存在内部存款和储蓄器中的。同有时候redis会周期性的把立异的数据写入磁盘只怕把修改操作写入追加的记录文件,并且在此基础上落到实处master-slave(主从)同步

安装:

wget http://download.redis.io/releases/redis-3.0.6.tar.gz
tar xzf redis-3.0.6.tar.gz
cd redis-3.0.6
make

 

开发银行服务端:

src/redis-server

 

起步客户端:

src/redis-cli

 

使用:

127.0.0.1:6379> set name xiaoming
OK
127.0.0.1:6379> set age 22
OK
127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> get name
"xiaoming"
127.0.0.1:6379> get age
"22"

 

keys * :查看系统中存了有一点个key

set key value:设置变量值;          set key value ex 2:设置变量,何况只可以存活2分钟

 

Memcached 是一个高质量的遍布式内部存款和储蓄器对象缓存系统,用于动态Web应用以缓慢解决数据库负载。它通过在内存中缓存数据和对象来压缩读取数据库的次数,进而抓实动态、数据库驱动网址的进程。Memcached基于一个存款和储蓄键/值对的hashmap。其料理进程(daemon )是用C写的,然而客户端可以用其余语言来编排,并经过memcached协议与医生和医护人员进度通讯。

2、连接池

redis-py使用connection pool来管理对一个redis server的全体连接,制止每趟建设构造、释放连接的开荒。暗许,每一种Redis实例都会维护二个投机的连接池。
能够一向建设构造二个连接池,然后作为参数Redis,这样就能够兑现多个Redis实例分享二个连接池

import redis    # 导入redis模块,通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)   # host是redis主机,需要redis服务端和客户端都起着 redis默认端口是6379
r = redis.Redis(connection_pool=pool)
r.set('gender', 'male')     # key是"gender" value是"male" 将键值对存入redis缓存
print(r.get('gender'))      # gender 取出键male对应的值

大家都听过缓存,缓存是干啥的吧?我们得以和json和pickle来说,多个程序之间达成音讯相互,能够通过在A程序中把数据改成json ,然后传给B程序,通过文件这一个介质。文件这一个频率十分的低。

python使用redis

安装redis模块:

sudo pip install redis
or
sudo easy_install redis

 

redis-py的API使用能够分为:

  连接方式,连接池,操作(String操作,Hash操作,List操作,Set操作,Sort Set 操作),管道,发布订阅

1.操作方式

三个类:Redis和StrictRedis用于落到实处redis命令,StrictRedis用于落实比非常多官方的指令,并应用官方语法和指令,Redis是StrictRedis的子类,

import redis

r = redis.Redis(host='192.168.1.103',port=6379)
r.set('foo','Bar')
print(r.get('foo'))

 

2.连接池

redis-py使用连接池来治本对三个redis server的具备连接,制止每趟创立,释放连接的花费。暗许各种redis实例都会珍爱二个要好的连接池,能够一贯营造八个连接池,然后作为参数Redis,那样能够兑现五个redis实例分享叁个连接池

import redis
pool = redis.ConnectionPool(host = '192.168.1.103',port=6379)
r = redis.Redis(connection_pool=pool)
r.set('xu',123)
print(r.get('xu'))

 

3.操作

String操作,redis中的String在内部存款和储蓄器中遵守key---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):设置值,独有name不设有的时候,推行设置操作(加多)

setex(name,  time,value):设置值,time 过期时间,数字秒                             psetex(name, time_ms, value):设置值,毫秒

mset(*args, **kwargs):

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

 

mget(keys, *args):

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

getset(name, value):设置新值并获得原本的值

getrange(key, start, end):

# 获取子序列(根据字节获取,非字符)
# 参数:
    # name,Redis 的 name
    # start,起始位置(字节)
    # end,结束位置(字节)
# 如: "ming" ,0-2表示 "min"

 

setrange(name, offset, value):

修改字符串内容,从指定字符串索引开始向后替换(新值太长时,则向后添加)
# 参数:
    # offset,字符串的索引,字节(一个汉字三个字节)
    # value,要设置的值

setbit(name, offset, value):

对name对应值的二进制表示的位进行操作

参数:
    # name,redis的name
    # offset,位的索引(将值变换成二进制后再进行索引)
    # value,值只能是 1 或 0

注:如果在Redis中有一个对应: n1 = "foo",
        那么字符串foo的二进制表示为:01100110 01101111 01101111
    所以,如果执行 setbit('n1', 7, 1),则就会将第7位设置为1,
        那么最终二进制则变成 01100111 01101111 01101111,即:"goo"

在python中只要想要知道三个字母的二进制是多少,可以先用ord()转为ASCII 值,然后在用bin()转交换一下地方二进制,然后从后往前数8位,不足补0,就是那个字母的二进制值

何以时候会用呢?

搜狐和讯在线用户会有许多,假如做多少解析,想要看脚下有怎么着用户在线,用数据库的效用是不高的。我们先看一下和命令bitcount,用来计数变量的二进制中有多少个1,如a:0b1100001,bitcount的结果正是3

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

获取name对应的值的二进制表示中 1 的个数
参数:
    # key,Redis的name
    # start,位起始位置
    # end,位结束位置

 

澳门新萄京官方网站 5

那就是说数据库中各类用户的id是独一的,从1从头活动抬高,到场我们有2亿的用户,有1亿在线,大家要计算那1亿用户到底是哪个人在线,大家得以由此改二进制位来落到实处,即: (n2是三个新的变量)

投入有一个用户id为一千的用户登入,大家设置:setbit n2 1000 1 ,又登陆了七个id为555的用户:setbit n2 555 1;用户id为四千的用户:setbit n2 陆仟 1;大家用bitcount来寻访n2:

澳门新萄京官方网站 6

表达在线用户有3个,那就贯彻了总括了在线用户人数,然后我们要看看到底是何人在线了,用户id是有一点笔者就取多少位,咱们循环这几个二进制的值就足以看来是相应的可怜人在线,比方

大家想看用户55在不在线,大家用getbit:

澳门新萄京官方网站 7

咱俩想看看用户555在不在线:

澳门新萄京官方网站 8

咱俩有2亿用户,最多也就占用2亿位,没有占多大空间,要是是用查看数据库的措施去看什么人在线的话,那表的记录就一点都非常的大,查询起来也不行慢。

 

strlen(name):重返name对应值的字节长度(三个汉字占3个字节)

incr(self, name, amount=1):

自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。
参数:
    # name,Redis的name
    # amount,自增数(必须是整数)

 decr(self, name, amount=1)

# 自减 name对应的值,当name不存在时,则创建name=amount,否则,则自减。

# 参数:
    # name,Redis的name
    # amount,自减数(整数)

 

若是大家不想计算全体用户在线的列表,你只想总括有微微用户在线,那只需求二个计数器,来贰个加叁个,同样也足以用redis落成,假若先来了三个用户,大家就直接:

 澳门新萄京官方网站 9

再来多个用户:

澳门新萄京官方网站 10

进而一贯来平昔来:

澳门新萄京官方网站 11

假诺这几个用户掉线了,就用decr

澳门新萄京官方网站 12

也便是说使用incr 和decr 能够完成自增自减

 

incrbyfloat(self, name, amount=1.0)

# 自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。

# 参数:
    # name,Redis的name
    # amount,自增数(浮点型)

append(key, value):

# 在redis name对应的值后面追加内容

# 参数:
    key, redis的name
    value, 要追加的字符串

澳门新萄京官方网站 13

 Hash操作,在redis中hash存在于内部存款和储蓄器中格式是这么的:

澳门新萄京官方网站 14

hset(name, key, value)

# name对应的hash中设置一个键值对(不存在,则创建;否则,修改)

# 参数:
    # name,redis的name
    # key,name对应的hash中的key
    # value,name对应的hash中的value

# 注:
    # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建(相当于添加)

 澳门新萄京官方网站 15

设置三个info变量,里面含有name,age,id 等key

 

hmset(name, mapping)

在name对应的hash中批量设置键值对

# 参数:
    # name,redis的name
    # mapping,字典,如:{'k1':'v1', 'k2': 'v2'}
# 如:
    # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

澳门新萄京官方网站 16

 

hget(name,key):

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

澳门新萄京官方网站 17

获得info里面的name值和age值

 

hmget(name, keys, *args)

在name对应的hash中获取多个key的值

# 参数:
    # name,reids对应的name
    # keys,要获取key集合,如:['k1', 'k2', 'k3']
    # *args,要获取的key,如:k1,k2,k3

 澳门新萄京官方网站 18

 

hgetall(name):获取name对应``hash``的所有键值

如获得info的具备键值:

澳门新萄京官方网站 19

hlen(name):获取name对应的hash中键值对的个数

澳门新萄京官方网站 20

 

hkeys(name):获取name对应的hash中具有的key的值

澳门新萄京官方网站 21

翻开那么些变量下的具备key,“属性”

 

hvals(name):获取name对应的hash中存有的value的值

澳门新萄京官方网站 22

 

hexists(name, key):检查name对应的hash是不是存在当前流传的key,即使存在重临1,不设有再次来到0

 

hdel(name,*keys):将name对应的hash中钦点key的键值对删除

hincrby(name, key, amount=1):

自增name对应的hash中的指定key的值,不存在则创建key=amount
# 参数:
    # name,redis中的name
    # key, hash对应的key
    # amount,自增数(整数)

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的默认分片个数

在hash中,二个name能存200多亿个key,如若大家存了过多的key,然后通过hkeys name抽出数据,就能够一点也不快,那大家用hscan就起到三个过滤的功能。

澳门新萄京官方网站 23

其一意思正是在info第22中学从第0个key开首相配到以k开端的键值对抽出来

澳门新萄京官方网站 24

这么些意思乃是想要把带有a的抽出来

 

hscan_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

 

list操作,redis中的list在内部存款和储蓄器中遵照二个name对应三个List来积存

澳门新萄京官方网站 25

lpush(name,values)

# 在name对应的list中添加元素,每个新的元素都添加到列表的最左边

# 如:
    # r.lpush('oo', 11,22,33)
    # 保存顺序为: 33,22,11

# 扩展:
    # rpush(name, values) 表示从右向左操作

 澳门新萄京官方网站 26

设置names列表,里面有3个因素,放在列表的最左侧

有lpush,就有rpush,正是存成分是坐落列表的右端:rpush names xixi haha hehe

澳门新萄京官方网站 27

笔者们可以见见我们新存的xixi,haha,hehe是在前边依次贮存的

lpushx(name,value)

在name对应的list中添加元素,只有name已经存在时,值添加到列表的最左边

# 更多:
    # rpushx(name, value) 表示从右向左操作

 

llen(name):name对应的list成分的个数

linsert(name, where, refvalue, value)):

在name对应的列表的某一个值前或后插入一个新值

# 参数:
    # name,redis的name
    # where,BEFORE或AFTER
    # refvalue,标杆值,即:在它前后插入数据
    # value,要插入的数据

 澳门新萄京官方网站 28

在names中往xiaoming前边插入meimei那么些新的因素

 

r.lset(name, index, value):

对name对应的list中的某一个索引位置重新赋值

# 参数:
    # name,redis的name
    # index,list的索引位置
    # value,要设置的值

 澳门新萄京官方网站 29

正是做三个改变数据的操作,把第6个要素改造值

 

r.lrem(name, value, num):

在name对应的list中删除指定的值

# 参数:
    # name,redis的name
    # value,要删除的值
    # num,  num=0,删除列表中所有的指定值;
           # num=2,从前到后,删除2个;
           # num=-2,从后向前,删除2个

 澳门新萄京官方网站 30

在linux中先数据要去除的个数,然后在输入删除的值

 

lpop(name):

在name对应的列表的左侧获取第一个元素并在列表中移除,返回值则是第一个元素

# 更多:
    # rpop(name) 表示从右向左操作

 澳门新萄京官方网站 31

把names列表中的第三个因素移出了

 

lindex(name, index):在name对应的列表中依照目录获取列表成分

 

lrange(name, start, end):

在name对应的列表分片获取数据
# 参数:
    # name,redis的name
    # start,索引的起始位置
    # end,索引结束位置

 澳门新萄京官方网站 32

把names列表中具备的要素都收取来就是0,-1.然后大家得以见到我们前边存进去的先抽取来,说明列表是先入后出

 澳门新萄京官方网站 33

赢得names中从第1个到第多个要素,默许是从0算起的,

ltrim(name, start, end):

在name对应的列表中移除没有在start-end索引之间的值
# 参数:
    # name,redis的name
    # start,索引的起始位置
    # end,索引结束位置

 澳门新萄京官方网站 34

移出除了第2第几个要素之外的保有的要素

 

rpoplpush(src, dst)

从一个列表取出最右边的元素,同时将其添加至另一个列表的最左边
# 参数:
    # src,要取数据的列表的name
    # dst,要添加数据的列表的name

 澳门新萄京官方网站 35

把names中的最左侧的xiaoming 移到了names2的最左侧

blpop(keys, timeout):

将多个列表排列,按照从左到右去pop对应列表的元素

# 参数:
    # keys,redis的name的集合
    # timeout,超时时间,当元素所有列表的元素获取完之后,阻塞等待列表内有数据的时间(秒), 0 表示永远阻塞

# 更多:
    # r.brpop(keys, timeout),从右向左获取数据

 澳门新萄京官方网站 36

把names中的数据每趟从左往右删除,假如names里面有成分就马上删除,负担就等候4s。

那边有三个选用:笔者把日子设置成40,然后在起步三个redis客户端,然后在那40s以内自身在给names增多一个新的成分,然后那边等待的客户端就立马把那个值收取来了

澳门新萄京官方网站 37澳门新萄京官方网站 38

当今也正是运转了三个经过,一个得以往列表中放入值,一个足以从列表中取值,有一些像队列,想生产者开支者,因为除去的时候会重临删除的值就相当于收取来数据

brpoplpush(src, dst, timeout=0)

从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧

# 参数:
    # src,取出并要移除元素的列表对应的name
    # dst,要插入元素的列表对应的name
    # timeout,当src对应的列表中没有数据时,阻塞等待其有数据的超时时间(秒),0 表示永远阻塞

 澳门新萄京官方网站 39

固然把names2的要素移到names中,从右端移到了左端

 

自定义增量迭代

由于redis类库中没有提供对列表元素的增量迭代,如果想要循环name对应的列表的所有元素,那么就需要:
    # 1、获取name对应的所有列表
    # 2、循环列表
# 但是,如果列表非常大,那么就有可能在第一步时就将程序的内容撑爆,所有有必要自定义一个增量迭代的功能:

def list_iter(name):
    """
    自定义redis列表增量迭代
    :param name: redis中的name,即:迭代name对应的列表
    :return: yield 返回 列表元素
    """
    list_count = r.llen(name)
    for index in xrange(list_count):
        yield r.lindex(name, index)

# 使用
for item in list_iter('pp'):
    print item

 

Set操作,Set会集就是不允许再一次的列表

澳门新萄京官方网站 40

 

上海体育地方能够看到,笔者往names中插入了6个值,不过在汇集中实际上就唯有3个值,所以说群集是不允许再度的列表

sadd(name,values):name对应的联谊中添欧成分

scard(name): 获取name对应的集纳瓜时素的个数

sdiff(keys, *args):在率先个name集结中且不再别的name对应的汇聚中的成分集合(差集:不含B群集成分的拥有A成分)

澳门新萄京官方网站 41

 

sdiffstore(dest, keys, *args):获取第叁个name对应的联谊中且其余不再name对应的聚众,再讲其出席新的dest集结中

澳门新萄京官方网站 42

 

把差集的结果存到集结n6中,

sinter(keys, *args):(数学里的参差不齐)

澳门新萄京官方网站 43

 

sinterstore(dest, keys, *args):获取群集之间的搅动,再讲其投入到dest对应的集合中

sismember(name, value):检查value是或不是是name对应的成团的积极分子

smembers(name): 获取name对应的会师的兼具成员,集结不可能用切成丝去取,因为它是冬日的

澳门新萄京官方网站 44

获得集结names3的全体值

 

smove(src, dst, value):将有个别成员从叁个晤面中移动到其他三个会见

spop(name):从群集的右臂(尾巴部分)移除一个成员,并将其回来

srandmember(name, numbers):从name对应的聚聚集随机获取 numbers 个成分

srem(name, values):在name对应的成团中除去有些值

sunion(keys, *args):获取多三个name对应的聚合的并集

sunionstore(dest,keys, *args):获取多四个name对应的集聚的并集,并将结果保存到dest对应的聚集中

sscan(name, cursor=0, match=None, count=None)
sscan_iter(name, match=None, count=None):同字符串的操作,用于增量迭代分批获取成分,制止内部存款和储蓄器消耗太大

 

以不改变应万变聚焦,在联谊的功底上,为每成分排序;成分的排序要求根据此外三个值来开始展览比较,所以,对于有序聚焦,每三个要素有七个值,即:值和分数,分数特意用来做排序。

zadd(name, *args, **kwargs)

在name对应的有序集合中添加元素
# 如:
     # zadd('zz', 'n1', 1, 'n2', 2)
     # 或
     # zadd('zz', n1=11, n2=22)

 澳门新萄京官方网站 45

给相应的因素设置权值,用来排序;先权值后值

 

zcard(name):获取name对应的有序群集成分的数据 

zcount(name, min, max):获取name对应的不改变聚集中分数 在 [min,max] 之间的个数

zincrby(name, value, amount):自增name对应的平稳集中的 name 对应的分数

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

# 按照索引范围获取name对应的有序集合的元素

# 参数:
    # name,redis的name
    # start,有序集合索引起始位置(非分数)
    # end,有序集合索引结束位置(非分数)
    # desc,排序规则,默认按照分数从小到大排序
    # withscores,是否获取元素的分数,默认只获取元素的值
    # score_cast_func,对分数进行数据转换的函数

# 更多:
    # 从大到小排序
    # zrevrange(name, start, end, withscores=False, score_cast_func=float)

    # 按照分数范围获取name对应的有序集合的元素
    # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
    # 从大到小排序
    # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

 澳门新萄京官方网站 46

澳门新萄京官方网站 47

 

zrank(name, value): 

获取某个值在 name对应的有序集合中的排行(从 0 开始)

# 更多:
    # zrevrank(name, value),从大到小排序

澳门新萄京官方网站 48

zrangebylex(name, min, max, start=None, num=None)

# 当有序集合的所有成员都具有相同的分值时,有序集合的元素会根据成员的 值 (lexicographical ordering)来进行排序,而这个命令则可以返回给定的有序集合键 key 中, 元素的值介于 min 和 max 之间的成员
# 对集合中的每个成员进行逐个字节的对比(byte-by-byte compare), 并按照从低到高的顺序, 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话, 那么命令会认为较长的字符串比较短的字符串要大

# 参数:
    # name,redis的name
    # min,左区间(值)。   表示正无限; - 表示负无限; ( 表示开区间; [ 则表示闭区间
    # min,右区间(值)
    # start,对结果进行分片处理,索引位置
    # num,对结果进行分片处理,索引后面的num个元素

# 如:
    # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
    # r.zrangebylex('myzset', "-", "[ca") 结果为:['aa', 'ba', 'ca']

# 更多:
    # 从大到小排序
    # zrevrangebylex(name, max, min, start=None, num=None)

zrem(name, values)

# 删除name对应的有序集合中值是values的成员

# 如:zrem('zz', ['s1', 's2'])

zremrangebyrank(name, min, max):遵照排行范围删除

zremrangebyscore(name, min, max):依据分数范围删除

zremrangebylex(name, min, max):依据值重回删除

zscore(name, value):获取name对应有序集结中 value 对应的分数

zinterstore(dest, keys, aggregate=None):

# 获取两个有序集合的交集,如果遇到相同值不同分数,则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

zunionstore(dest, keys, aggregate=None):

# 获取两个有序集合的并集,如果遇到相同值不同分数,则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_澳门新萄京官方网站:数据库操作Memcache,学习笔记。iter(name, match=None, count=None,score_cast_func=float)

# 同字符串相似,相较于字符串新增score_cast_func,用来对分数进行操作

另外常用操作

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下

  redis暗许有16个db,从0-15 ,能够用select 进行切换

randomkey():随机得到二个redis的name(不删除)

type(name):获取name对应值的类别

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

同字符串操作,用于增量迭代获取key

4.管道:

redis-py暗许在实行每回伏乞都会创建(连接池申请连接)和断开(归还连接池)一回一连操作,假设想要在一遍呼吁中钦赐五个指令,则足以行使pipline达成一遍呼吁钦点两个指令,何况默许情形下叁回pipline 是原子性操作。

import redis

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

r = redis.Redis(connection_pool=pool)

# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)

pipe.set('name', 'alex')
pipe.set('role', 'teacher')

pipe.execute()

 

5.文告订阅

澳门新萄京官方网站 49

那那一个怎么落实的吗?

 1 import redis
 2 class RedisHelper:
 3     def __init__(self):
 4         self.__conn = redis.Redis(host='192.168.1.101')
 5         self.chan_sub = 'fm104.7'
 6         self.chan_pub = 'fm104.7'
 7 
 8     def public(self, msg):
 9         self.__conn.publish(self.chan_pub, msg)
10         return True
11 
12     def subscribe(self):
13         pub = self.__conn.pubsub()#打开收音机
14         pub.subscribe(self.chan_sub)#调频道
15         pub.parse_response()#准备接收 
16         return pub

 订阅:

from RedisHelper import RedisHelper

obj = RedisHelper()
redis_sub = obj.subscribe()

while True:
    msg = redis_sub.parse_response()
    print(msg)

 

发布:

from RedisHelper import RedisHelper

obj = RedisHelper()
obj.public('hello,i am testing')

 

能够多少个揭橥新闻,通过同三个频段传给一位:

澳门新萄京官方网站 50

 

学习笔记,python---redis 缓存 前言: 大家都听过缓存,缓存是干啥的吗?我们得以和json和pickle来说,四个程序之间达成消息交互...

1、安装和中央选取

3、redis基本命令 String

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

在Redis中装置值,暗许,不设有则创制,存在则修改
参数:
ex,过期时光(秒)
px,过期时间(纳秒)
nx,要是设置为True,则唯有name不设不经常,当前set操作才试行
xx,假若设置为True,则唯有name存在时,当前set操作才推行

1.ex,过期岁月(秒) 这里过期时间是3秒,3秒后p,键food的值就改成None

import redis

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)
r.set('food', 'mutton', ex=3)    # key是"food" value是"mutton" 将键值对存入redis缓存
print(r.get('food'))  # mutton 取出键food对应的值

2.px,过期光阴(豪秒) 这里过期时间是3豪秒,3皮秒后,键foo的值就改成None

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,借使设置为True,则独有name子虚乌有时,当前set操作才施行 (新建)

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--不存在
# 如果键fruit不存在,那么输出是True;如果键fruit已经存在,输出是None

4.xx,假诺设置为True,则唯有name存在时,当前set操作才执行 (修改)

print((r.set('fruit', 'watermelon', xx=True)))   # True--已经存在
# 如果键fruit已经存在,那么输出是True;如果键fruit不存在,输出是None

5.setnx(name, value)
设置值,唯有name不设有的时候,施行设置操作(加多)

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

6.setex(name, value, time)
设置值
参数:
time,过期时间(数字秒 或 timedelta对象)

import redis
import time

pool = redis.ConnectionPool(host='localhost', port=6379, decode_responses=True)
r = redis.Redis(connection_pool=pool)
r.setex("fruit2", "orange", 5)
time.sleep(5)
print(r.get('fruit2'))  # 5秒后,取值就从orange变成None

7.psetex(name, time_ms, value)
设置值
参数:
time_ms,过期光阴(数字皮秒 或 timedelta对象)

r.psetex("fruit3", 5000, "apple")
time.sleep(5)
print(r.get('fruit3'))  # 5000毫秒后,取值就从apple变成None

8.mset(*args, **kwargs)
批量设置值
如:

r.mget({'k1': 'v1', 'k2': 'v2'})
r.mset(k1="v1", k2="v2") # 这里k1 和k2 不能带引号 一次设置对个键值对
print(r.mget("k1", "k2"))   # 一次取出多个键对应的值
print(r.mget("k1"))

9.mget(keys, *args)
批量到手
如:

print(r.mget('k1', 'k2'))
print(r.mget(['k1', 'k2']))
print(r.mget("fruit", "fruit1", "fruit2", "k1", "k2"))  # 将目前redis缓存中的键对应的值批量取出来

10.getset(name, value)
安装新值并拿走原本的值

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

11.getrange(key, start, end)
获取子系列(遵照字节获取,非字符)
参数:
name,Redis 的 name
start,发轫地点(字节)
end,甘休地点(字节)
如: "君惜大大" ,0-3意味着 "君"

r.set("cn_name", "君惜大大") # 汉字
print(r.getrange("cn_name", 0, 2))   # 取索引号是0-2 前3位的字节 君 切片操作 (一个汉字3个字节 1个字母一个字节 每个字节8bit)
print(r.getrange("cn_name", 0, -1))  # 取所有的字节 君惜大大 切片操作
r.set("en_name","junxi") # 字母
print(r.getrange("en_name", 0, 2))  # 取索引号是0-2 前3位的字节 jun 切片操作 (一个汉字3个字节 1个字母一个字节 每个字节8bit)
print(r.getrange("en_name", 0, -1)) # 取所有的字节 junxi 切片操作

12.setrange(name, offset, value)
修改字符串内容,从钦赐字符串索引起始向后替换(新值太长时,则向后增多)
参数:
offset,字符串的目录,字节(几个中华人民共和国字四个字节)
value,要设置的值

r.setrange("en_name", 1, "ccc")
print(r.get("en_name"))    # jccci 原始值是junxi 从索引号是1开始替换成ccc 变成 jccci

13.setbit(name, offset, value)
对name对应值的二进制表示的位举行操作
参数:
name,redis的name
offset,位的目录(将值转换到二进制后再开始展览索引)
value,值只好是 1 或 0

注:如果在Redis中有一个对应: n1 = "foo",
那么字符串foo的二进制表示为:01100110 01101111 01101111
所以,如果执行 setbit('n1', 7, 1),则就会将第7位设置为1,
那么最终二进制则变成 01100111 01101111 01101111,即:"goo"

扩展,转换二进制表示:
source = "陈思维"
source = "foo"
for i in source:
num = ord(i)
print bin(num).replace('b','')
特别的,如果source是汉字 "陈思维"怎么办?
答:对于utf-8,每一个汉字占 3 个字节,那么 "陈思维" 则有 9个字节
对于汉字,for循环时候会按照 字节 迭代,那么在迭代时,将每一个字节转换 十进制数,然后再将十进制数转换成二进制
11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000

14.getbit(name, offset)
获得name对应的值的二进制表示中的某位的值 (0或1)

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

15.bitcount(key, start=None, end=None)
收获name对应的值的二进制表示中 1 的个数
参数:
key,Redis的name
start 字节初叶地方

end,字节停止地方

print(r.get("foo"))  # goo1 01100111
print(r.bitcount("foo",0,1))  # 11 表示前2个字节中,1出现的个数

16.bitop(operation, dest, *keys) 获取几个值,并将值做位运算,将最后的结果保存至新的name对应的值 参数: operation,AND(并) 、 OSportage(或) 、 NOT(非) 、 XO奥德赛(异或) dest, 新的Redis的name *keys,要探寻的Redis的name 如:

bitop("AND", 'new_name', 'n1', 'n2', 'n3')
获取Redis中n1,n2,n3对应的值,然后讲所有的值做位运算(求并集),然后将结果保存 new_name 对应的值中
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)  # 打印每个字母字符或者汉字字符对应的ascii码值 f-102-0b100111-01100111
print(bin(num))  # 打印每个10进制ascii码值转换成二进制的值 0b1100110(0b表示二进制)
print bin(num).replace('b','')  # 将二进制0b1100110替换成01100110

17.strlen(name)
重回name对应值的字节长度(一个汉字3个字节)

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

18.incr(self, name, amount=1)
自增 name对应的值,当name空头支票时,则开创name=amount,不然,则自增。
参数:
name,Redis的name
amount,自增数(必须是整数)
注:同incrby

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"))

选择场景 – 页面点击数
只要我们对一文山会海页面需求记录点击次数。比方论坛的各样帖子都要记录点击次数,而点击次数比回帖的次数的多得多。假若利用关全面据库来存款和储蓄点击,恐怕存在大气的行级锁争用。所以,点击数的增加使用redis的INC凯雷德命令最佳然则了。
当redis服务器运维时,能够从关周全据库读入点击数的起首值(12306以此页面被访谈了346贰拾捌回)

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

每当有贰个页面点击,则动用INC卡宴扩展点击数就可以。

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

页面载入的时候则可直接获得这一个值

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

19.incrbyfloat(self, name, amount=1.0)
自增 name对应的值,当name不设有的时候,则创制name=amount,不然,则自增。
参数:
name,Redis的name
amount,自增数(浮点型)

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)
自减 name对应的值,当name不设不常,则创立name=amount,不然,则自减。
参数:
name,Redis的name
amount,自减数(整数)

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

21.append(key, value)
在redis name对应的值前面扩张内容
参数:
key, redis的name
value, 要增添的字符串

r.append("name", "haha")    # 在name对应的值junxi后面追加字符串haha
print(r.mget("name"))

比如说二个是QQ,四个是微信,大家想要达成多头的相互,我们事先学了rabbitMQ,能够完结新闻的传递;对于数据的分享,qq存款和储蓄的多寡微信能够间接得到,那些数目是位于内部存款和储蓄器中的,那大家怎么落到实处多少个内部存款和储蓄器分享呢?大家要有多当中间商,中间商再运转一个独立的次第,自个儿开垦一块内部存款和储蓄器,QQ和中间商创设三个socket,微信和高级中学级商业建立一个socket,那样就兑现了数量分享。那当中间商就是缓存。

Memcached安装:

4、redis基本命令 hash

1.单个扩张--修改(单个收取)--未有就剧增,有的话就修改
hset(name, key, value)
name对应的hash中安装贰个键值对(空头支票,则开创;不然,修改)
参数:
name,redis的name
key,name对应的hash中的key
value,name对应的hash中的value
注:
hsetnx(name, key, value),当name对应的hash中海市蜃楼当前key时则成立(相当于加多)

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")) # 取hash中所有的key
print(r.hget("hash1", "k1"))    # 单个取hash的key对应的值
print(r.hmget("hash1", "k1", "k2")) # 多个取hash的key对应的值
r.hsetnx("hash1", "k2", "v3") # 只能新建
print(r.hget("hash1", "k2"))

2 批量日增(收取)
hmset(name, mapping)
在name对应的hash中批量设置键值对
参数:
name,redis的name
mapping,字典,如:{'k1':'v1', 'k2': 'v2'}
如:

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

hget(name,key)
在name对应的hash中取得依据key获取value
hmget(name, keys, *args)
在name对应的hash中得到几个key的值
参数:
name,reids对应的name
keys,要获取key集合,如:['k1', 'k2', 'k3']
*args,要博取的key,如:k1,k2,k3
如:

print(r.hget("hash2", "k2"))  # 单个取出"hash2"的key-k2对应的value
print(r.hmget("hash2", "k2", "k3"))  # 批量取出"hash2"的key-k2 k3对应的value --方式1
print(r.hmget("hash2", ["k2", "k3"]))  # 批量取出"hash2"的key-k2 k3对应的value --方式2

3.收取全部的键值对
hgetall(name)
获得name对应hash的持有键值

print(r.hgetall("hash1"))

4.得到全数键值对的格式 hash长度
hlen(name)
获得name对应的hash中键值对的个数

print(r.hlen("hash1"))

5.到手全数的keys(类似字典的取全体keys)
hkeys(name)
收获name对应的hash中负有的key的值

print(r.hkeys("hash1"))

6.获取全数的value(类似字典的取全部value)
hvals(name)
收获name对应的hash中颇具的value的值

print(r.hvals("hash1"))

7.确定成员是或不是存在(类似字典的in)
hexists(name, key)
反省name对应的hash是不是留存当前传入的key

print(r.hexists("hash1", "k4"))  # False 不存在
print(r.hexists("hash1", "k1"))  # True 存在

8.删除键值对
hdel(name,*keys)
将name对应的hash中钦命key的键值对删除

print(r.hgetall("hash1"))
r.hset("hash1", "k2", "v222")   # 修改已有的key k2
r.hset("hash1", "k11", "v1")   # 新增键值对 k11
r.hdel("hash1", "k1")    # 删除一个键值对
print(r.hgetall("hash1"))

9.自增自减整数(将key对应的value--整数 自增1可能2,可能其余整数 负数就是自减)
hincrby(name, key, amount=1)
自增name对应的hash中的钦定key的值,不设有则创设key=amount
参数:
name,redis中的name
key, hash对应的key
amount,自增数(整数)

r.hset("hash1", "k3", 123)
r.hincrby("hash1", "k3", amount=-1)
print(r.hgetall("hash1"))
r.hincrby("hash1", "k4", amount=1)  # 不存在的话,value默认就是1
print(r.hgetall("hash1"))

10.自增自减浮点数(将key对应的value--浮点数 自增1.0大概2.0,大概其他浮点数 负数便是自减)
hincrbyfloat(name, key, amount=1.0)
自增name对应的hash中的钦点key的值,不设有则创设key=amount
参数:
name,redis中的name
key, hash对应的key
amount,自增数(浮点数)
自增name对应的hash中的内定key的值,一纸空文则开创key=amount

r.hset("hash1", "k5", "1.0")
r.hincrbyfloat("hash1", "k5", amount=-1.0)    # 已经存在,递减-1.0
print(r.hgetall("hash1"))
r.hincrbyfloat("hash1", "k6", amount=-1.0)    # 不存在,value初始值是-1.0 每次递减1.0
print(r.hgetall("hash1"))

11.取值查看--分片读取
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时,表示数据现已经过分片获取完成

print(r.hscan("hash1"))

12.hscan_iter(name, match=None, count=None)
采取yield封装hscan成立生成器,实现分批去redis中获取数据
参数:
match,相称钦赐key,暗许None 表示全数的key
count,每一次分片最少获取个数,默许None表示采取Redis的暗中认可分片个数
如:

for item in r.hscan_iter('hash1'):
    print(item)
print(r.hscan_iter("hash1"))    # 生成器内存地址

主流的缓存:mongodb,redis,memcache。

wget http://memcached.org/latest
tar -zxvf latest
cd memcached-1.x.x
./configure && make && make test && sudo make install

ps:依赖包libevent
       yum install libevent-devel
       apt-get install libevent-dev
5、redis基本命令 list

1.日增(类似于list的append,只是这里是从侧边新扩张)--未有就新建
lpush(name,values)
在name对应的list中添美金素,每一个新的要素都抬高到列表的最侧面
如:

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))

封存顺序为: 33,22,11

扩展:

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

2.扩充(从侧边增添)--未有就新建

r.rpush("list2", 44, 55, 66)    # 在列表的右边,依次添加44,55,66
print(r.llen("list2"))  # 列表长度
print(r.lrange("list2", 0, -1)) # 切片取出值,范围是索引号0到-1(最后一个元素)

3.往早已局地name的列表的左臂添新币素,未有的话不大概创设
lpushx(name,value)
在name对应的list中添法郎素,唯有name已经存在时,值增添到列表的最侧面
更多:

r.lpushx("list10", 10)   # 这里list10不存在
print(r.llen("list10"))  # 0
print(r.lrange("list10", 0, -1))  # []
r.lpushx("list2", 77)   # 这里"list2"之前已经存在,往列表最左边添加一个元素,一次只能添加一个
print(r.llen("list2"))  # 列表长度
print(r.lrange("list2", 0, -1)) # 切片取出值,范围是索引号0到-1(最后一个元素)

4.往曾经有的name的列表的右边添澳成分,未有的话无法创立

r.rpushx("list2", 99)   # 这里"foo_list1"之前已经存在,往列表最右边添加一个元素,一次只能添加一个
print(r.llen("list2"))  # 列表长度
print(r.lrange("list2", 0, -1)) # 切片取出值,范围是索引号0到-1(最后一个元素)

5.新增加(固定索引号地方插队成分)
linsert(name, where, refvalue, value))
在name对应的列表的某贰个值前或后插入贰个新值
参数:
name,redis的name
where,BEFORE或AFTER
refvalue,标杆值,即:在它左右插入数据
value,要插入的多寡

r.linsert("list2", "before", "11", "00")   # 往列表中左边第一个出现的元素"11"前插入元素"00"
print(r.lrange("list2", 0, -1))   # 切片取出值,范围是索引号0-最后一个元素

6.改造(内定索引号举行修改)
r.lset(name, index, value)
对name对应的list中的某四个目录地点再次赋值
参数:
name,redis的name
index,list的目录地方
value,要设置的值

r.lset("list2", 0, -11)    # 把索引号是0的元素修改成-11
print(r.lrange("list2", 0, -1))

7.剔除(钦赐值举行删减)
r.lrem(name, value, num)
在name对应的list中剔除内定的值
参数:
name,redis的name
value,要删减的值
num, num=0,删除列表中全部的钦命值;
num=2,在此以前到后,删除2个; num=1,在此此前到后,删除左边第三个
num=-2,从后向前,删除2个

r.lrem("list2", "11", 1)    # 将列表中左边第一次出现的"11"删除
print(r.lrange("list2", 0, -1))
r.lrem("list2", "99", -1)    # 将列表中右边第一次出现的"99"删除
print(r.lrange("list2", 0, -1))
r.lrem("list2", "22", 0)    # 将列表中所有的"22"删除
print(r.lrange("list2", 0, -1))

8.剔除并赶回
lpop(name)
在name对应的列表的侧边获取第多个要素并在列表中移除,重临值则是率先个成分
更多:
rpop(name) 表示从右向左操作

r.lpop("list2")    # 删除列表最左边的元素,并且返回删除的元素
print(r.lrange("list2", 0, -1))
r.rpop("list2")    # 删除列表最右边的元素,并且返回删除的元素
print(r.lrange("list2", 0, -1))

9.剔除索引之外的值
ltrim(name, start, end)
在name对应的列表中移除未有在start-end索引之间的值
参数:
name,redis的name
start,索引的早先地点
end,索引甘休地方

r.ltrim("list2", 0, 2)    # 删除索引号是0-2之外的元素,值保留索引号是0-2的元素
print(r.lrange("list2", 0, -1))

10.取值(依照索引号取值)
lindex(name, index)
在name对应的列表中根据目录获取列表成分

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

11.活动 成分从二个列表移动到其它叁个列表
rpoplpush(src, dst)
从三个列表取出最侧边的因素,同有时间将其增多至另三个列表的最左侧
参数:
src,要取多少的列表的name
dst,要添扩张少的列表的name

r.rpoplpush("list1", "list2")
print(r.lrange("list2", 0, -1))

12.运动 元素从二个列表移动到另外二个列表 可以设置超时
brpoplpush(src, dst, timeout=0)
从二个列表的左边手移除三个因素并将其增添到另叁个列表的左边手
参数:
src,抽取并要移除成分的列表对应的name
dst,要插入元素的列表对应的name
timeout,当src对应的列表中从不数量时,阻塞等待其有数量的过期时间(秒),0 表示永久阻塞

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

13.二遍移除七个列表
blpop(keys, timeout)
将多少个列表排列,根据从左到右去pop对应列表的要素
参数:
keys,redis的name的集合
timeout,超时时间,当元素全体列表的成分获得完事后,阻塞等待列表内有数量的光阴(秒), 0 表示永久阻塞
更多:
r.brpop(keys, timeout) 同blpop,将两个列表排列,依照从右像左去移除各种列表内的成分

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.自定义增量迭代
鉴于redis类库中从未提供对列表成分的增量迭代,假设想要循环name对应的列表的全部因素,那么就须要:

  1. 收获name对应的富有列表
  2. 循环列表

可是,假若列表相当大,那么就有非常大可能率在率先步时就将先后的从头到尾的经过撑爆,全体有要求自定义贰个增量迭代的效果与利益:

def list_iter(name):
    """
    自定义redis列表增量迭代
    :param name: redis中的name,即:迭代name对应的列表
    :return: yield 返回 列表元素
    """
    list_count = r.llen(name)
    for index in range(list_count):
        yield r.lindex(name, index)

# 使用
for item in list_iter('list2'): # 遍历这个列表
    print(item)

Redis

redis是四个key-value存款和储蓄系统,协助存款和储蓄的value类型相对非常多,包罗:string,list(链表),set(集结),zset(sorted set -- 有序聚焦)和hash(哈希类型)。这么些数据类型都扶助push/pop,add/remove以及交并差集等足够的操作,并且那几个操作都是原子性的。在此基础上redis帮衬各个差异排序的秘诀。为了保障功能,数据是保存在内部存款和储蓄器中的。同不时间redis会周期性的把立异的数据写入磁盘大概把修改操作写入追加的记录文件,而且在此基础上贯彻master-slave(主从)同步

安装:

wget http://download.redis.io/releases/redis-3.0.6.tar.gz
tar xzf redis-3.0.6.tar.gz
cd redis-3.0.6
make

 

启航服务端:

src/redis-server

 

起步客户端:

src/redis-cli

 

使用:

127.0.0.1:6379> set name xiaoming
OK
127.0.0.1:6379> set age 22
OK
127.0.0.1:6379> keys *
1) "name"
2) "age"
127.0.0.1:6379> get name
"xiaoming"
127.0.0.1:6379> get age
"22"

 

keys * :查看系统中存了稍稍个key

set key value:设置变量值;          set key value ex 2:设置变量,何况只可以存活2分钟

 

启动Memcached:

6、redis基本命令 set

1.新增
sadd(name,values)
name对应的会合中添日成分

r.sadd("set1", 33, 44, 55, 66)  # 往集合中添加元素
print(r.scard("set1"))  # 集合的长度是4
print(r.smembers("set1"))   # 获取集合中所有的成员

2.到手成分个数 类似于len
scard(name)
获得name对应的联谊兰月素个数

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

3.赢得集合中具备的成员
smembers(name)
收获name对应的聚合的具有成员

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

得到集结中有所的积极分子--元组格局
sscan(name, cursor=0, match=None, count=None)

print(r.sscan("set1"))

获取集结中颇具的积极分子--迭代器的章程
sscan_iter(name, match=None, count=None)
同字符串的操作,用于增量迭代分批获取成分,制止内部存款和储蓄器消耗太大

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

4.差集
sdiff(keys, *args)
在第一个name对应的聚合中且不在其余name对应的会面的因素集结

r.sadd("set2", 11, 22, 33)
print(r.smembers("set1"))   # 获取集合中所有的成员
print(r.smembers("set2"))
print(r.sdiff("set1", "set2"))   # 在集合set1但是不在集合set2中
print(r.sdiff("set2", "set1"))   # 在集合set2但是不在集合set1中

5.差集--差集存在二个新的聚集中
sdiffstore(dest, keys, *args)
收获第1个name对应的聚众中且不在其余name对应的聚众,再将其新参加到dest对应的成团中

r.sdiffstore("set3", "set1", "set2")    # 在集合set1但是不在集合set2中
print(r.smembers("set3"))   # 获取集合3中所有的成员

6.交集
sinter(keys, *args)
赢得多一个name对应集结的混杂

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

7.交集--交集存在贰个新的汇集中
sinterstore(dest, keys, *args)
赢得多一个name对应会集的并集,再将其投入到dest对应的联谊中

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

并集
sunion(keys, *args)
获得多少个name对应的成团的并集

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

并集--并集存在一个新的聚合
sunionstore(dest,keys, *args)
收获多一个name对应的汇聚的并集,并将结果保存到dest对应的汇集中

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

8.剖断是不是是集结的成员 类似in
sismember(name, value)
自己研讨value是还是不是是name对应的成团的成员,结果为True和False

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

9.移动
smove(src, dst, value)
将某些成员从三个凑合中活动到其他一个凑合

 

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

10.去除--随机删除并且重临被删除值
spop(name)
从群集移除四个分子,并将其归来,说美赞臣(Dumex)下,会集是冬辰的,全部是随便删除的

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

11.剔除--内定值删除
srem(name, values)
在name对应的晤面中除去有个别值

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

python使用redis

安装redis模块:

sudo pip install redis
or
sudo easy_install redis

 

redis-py的API使用可以分为:

  连接格局,连接池,操作(String操作,Hash操作,List操作,Set操作,Sort Set 操作),管道,发表订阅

1.操作情势

多少个类:Redis和StrictRedis用于落实redis命令,StrictRedis用于落到实处非常多法定的一声令下,并运用官方语法和下令,Redis是StrictRedis的子类,

import redis

r = redis.Redis(host='192.168.1.103',port=6379)
r.set('foo','Bar')
print(r.get('foo'))

 

2.连接池

redis-py使用连接池来保管对多个redis server的装有连接,防止每便建构,释放连接的费用。私下认可每一种redis实例都会爱护二个和煦的连接池,能够直接创建四个连接池,然后作为参数Redis,那样能够完成多少个redis实例分享二个连接池

import redis
pool = redis.ConnectionPool(host = '192.168.1.103',port=6379)
r = redis.Redis(connection_pool=pool)
r.set('xu',123)
print(r.get('xu'))

 

3.操作

String操作,redis中的String在内部存款和储蓄器中依据key---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):设置值,只有name空中楼阁时,执行设置操作(增加)

setex(name,  time,value):设置值,time 过期时间,数字秒                             psetex(name, time_ms, value):设置值,毫秒

mset(*args, **kwargs):

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

 

mget(keys, *args):

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

getset(name, value):设置新值并收获原本的值

getrange(key, start, end):

# 获取子序列(根据字节获取,非字符)
# 参数:
    # name,Redis 的 name
    # start,起始位置(字节)
    # end,结束位置(字节)
# 如: "ming" ,0-2表示 "min"

 

setrange(name, offset, value):

修改字符串内容,从指定字符串索引开始向后替换(新值太长时,则向后添加)
# 参数:
    # offset,字符串的索引,字节(一个汉字三个字节)
    # value,要设置的值

setbit(name, offset, value):

对name对应值的二进制表示的位进行操作

参数:
    # name,redis的name
    # offset,位的索引(将值变换成二进制后再进行索引)
    # value,值只能是 1 或 0

注:如果在Redis中有一个对应: n1 = "foo",
        那么字符串foo的二进制表示为:01100110 01101111 01101111
    所以,如果执行 setbit('n1', 7, 1),则就会将第7位设置为1,
        那么最终二进制则变成 01100111 01101111 01101111,即:"goo"

在python中一旦想要知道贰个字母的二进制是稍微,能够先用ord()转为ASCII 值,然后在用bin()转变个方式二进制,然后从后往前数8位,不足补0,便是这几个字母的二进制值

怎么样时候会用呢?

腾讯网腾讯网在线用户会有为数十分多,假设做多少深入分析,想要看脚下有何样用户在线,用数据库的频率是不高的。大家先看一下和命令bitcount,用来计数变量的二进制中有多少个1,如a:0b1100001,bitcount的结果正是3

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

获取name对应的值的二进制表示中 1 的个数
参数:
    # key,Redis的name
    # start,位起始位置
    # end,位结束位置

 

澳门新萄京官方网站 51

那就是说数据库中每种用户的id是独一的,从1发端活动抬高,参加大家有2亿的用户,有1亿在线,大家要计算那1亿用户到底是何人在线,大家得以因而改二进制位来兑现,即: (n2是四个新的变量)

步入有一个用户id为一千的用户登录,大家设置:setbit n2 一千 1 ,又登入了多少个id为555的用户:setbit n2 555 1;用户id为陆仟的用户:setbit n2 5000 1;大家用bitcount来拜望n2:

澳门新萄京官方网站 52

证实在线用户有3个,那就贯彻了总计了在线用户人数,然后大家要看看到底是何人在线了,用户id是多少自己就取多少位,大家循环那么些二进制的值就足以看出是相应的要命人在线,举例

大家想看用户55在不在线,我们用getbit:

澳门新萄京官方网站 53

咱俩想看看用户555在不在线:

澳门新萄京官方网站 54

咱俩有2亿用户,最多也就攻下2亿位,未有占多大空间,要是是用查看数据库的办法去看什么人在线的话,那表的记录就极其大,查询起来也相当慢。

 

strlen(name):重返name对应值的字节长度(贰其中中原人民共和国字占3个字节)

incr(self, name, amount=1):

自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。
参数:
    # name,Redis的name
    # amount,自增数(必须是整数)

 decr(self, name, amount=1)

# 自减 name对应的值,当name不存在时,则创建name=amount,否则,则自减。

# 参数:
    # name,Redis的name
    # amount,自减数(整数)

 

一经大家不想总结全数用户在线的列表,你只想总结有微微用户在线,这只必要三个计数器,来一个加贰个,一样也能够用redis完毕,要是先来了一个用户,大家就径直:

 澳门新萄京官方网站 55

再来叁个用户:

澳门新萄京官方网站 56

为此直接来直接来:

澳门新萄京官方网站 57

假如那个用户掉线了,就用decr

澳门新萄京官方网站 58

相当于说使用incr 和decr 能够实现自增自减

 

incrbyfloat(self, name, amount=1.0)

# 自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。

# 参数:
    # name,Redis的name
    # amount,自增数(浮点型)

append(key, value):

# 在redis name对应的值后面追加内容

# 参数:
    key, redis的name
    value, 要追加的字符串

澳门新萄京官方网站 59

 Hash操作,在redis中hash存在于内部存款和储蓄器中格式是那般的:

澳门新萄京官方网站 60

hset(name, key, value)

# name对应的hash中设置一个键值对(不存在,则创建;否则,修改)

# 参数:
    # name,redis的name
    # key,name对应的hash中的key
    # value,name对应的hash中的value

# 注:
    # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建(相当于添加)

 澳门新萄京官方网站 61

设置多少个info变量,里面含有name,age,id 等key

 

hmset(name, mapping)

在name对应的hash中批量设置键值对

# 参数:
    # name,redis的name
    # mapping,字典,如:{'k1':'v1', 'k2': 'v2'}
# 如:
    # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

澳门新萄京官方网站 62

 

hget(name,key):

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

澳门新萄京官方网站 63

获得info里面的name值和age值

 

hmget(name, keys, *args)

在name对应的hash中获取多个key的值

# 参数:
    # name,reids对应的name
    # keys,要获取key集合,如:['k1', 'k2', 'k3']
    # *args,要获取的key,如:k1,k2,k3

 澳门新萄京官方网站 64

 

hgetall(name):获取name对应``hash``的所有键值

如得到info的具备键值:

澳门新萄京官方网站 65

hlen(name):获取name对应的hash中键值对的个数

澳门新萄京官方网站 66

 

hkeys(name):获取name对应的hash中全体的key的值

澳门新萄京官方网站 67

查看那么些变量下的有着key,“属性”

 

hvals(name):获取name对应的hash中有所的value的值

澳门新萄京官方网站 68

 

hexists(name, key):检查name对应的hash是或不是存在当前传遍的key,假使存在再次回到1,不设有再次来到0

 

hdel(name,*keys):将name对应的hash中钦定key的键值对删除

hincrby(name, key, amount=1):

自增name对应的hash中的指定key的值,不存在则创建key=amount
# 参数:
    # name,redis中的name
    # key, hash对应的key
    # amount,自增数(整数)

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的默认分片个数

在hash中,多少个name能存200多亿个key,纵然我们存了过多的key,然后通过hkeys name抽出数据,就能不慢,那大家用hscan就起到二个过滤的效应。

澳门新萄京官方网站 69

以此意思正是在info第22中学从第0个key初步相配到以k开头的键值对抽出来

澳门新萄京官方网站 70

以此意思正是说想要把带有a的抽取来

 

hscan_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

 

list操作,redis中的list在内部存款和储蓄器中依据二个name对应八个List来储存

澳门新萄京官方网站 71

lpush(name,values)

# 在name对应的list中添加元素,每个新的元素都添加到列表的最左边

# 如:
    # r.lpush('oo', 11,22,33)
    # 保存顺序为: 33,22,11

# 扩展:
    # rpush(name, values) 表示从右向左操作

 澳门新萄京官方网站 72

设置names列表,里面有3个因素,放在列表的最左边

有lpush,就有rpush,正是存成分是投身列表的右端:rpush names xixi haha hehe

澳门新萄京官方网站 73

咱俩可以看出我们新存的xixi,haha,hehe是在后面依次寄存的

lpushx(name,value)

在name对应的list中添加元素,只有name已经存在时,值添加到列表的最左边

# 更多:
    # rpushx(name, value) 表示从右向左操作

 

llen(name):name对应的list成分的个数

linsert(name, where, refvalue, value)):

在name对应的列表的某一个值前或后插入一个新值

# 参数:
    # name,redis的name
    # where,BEFORE或AFTER
    # refvalue,标杆值,即:在它前后插入数据
    # value,要插入的数据

 澳门新萄京官方网站 74

在names中往xiaoming前面插入meimei那几个新的因素

 

r.lset(name, index, value):

对name对应的list中的某一个索引位置重新赋值

# 参数:
    # name,redis的name
    # index,list的索引位置
    # value,要设置的值

 澳门新萄京官方网站 75

就是做一个改换数据的操作,把第6个因素改换值

 

r.lrem(name, value, num):

在name对应的list中删除指定的值

# 参数:
    # name,redis的name
    # value,要删除的值
    # num,  num=0,删除列表中所有的指定值;
           # num=2,从前到后,删除2个;
           # num=-2,从后向前,删除2个

 澳门新萄京官方网站 76

在linux中先数据要去除的个数,然后在输入删除的值

 

lpop(name):

在name对应的列表的左侧获取第一个元素并在列表中移除,返回值则是第一个元素

# 更多:
    # rpop(name) 表示从右向左操作

 澳门新萄京官方网站 77

把names列表中的第1个因素移出了

 

lindex(name, index):在name对应的列表中依据目录获取列表元素

 

lrange(name, start, end):

在name对应的列表分片获取数据
# 参数:
    # name,redis的name
    # start,索引的起始位置
    # end,索引结束位置

 澳门新萄京官方网站 78

把names列表中装有的要素都抽出来正是0,-1.然后大家得以看来我们前边存进去的先抽取来,表明列表是先入后出

 澳门新萄京官方网站 79

赢得names中从第一个到第八个要素,默许是从0算起的,

ltrim(name, start, end):

在name对应的列表中移除没有在start-end索引之间的值
# 参数:
    # name,redis的name
    # start,索引的起始位置
    # end,索引结束位置

 澳门新萄京官方网站 80

移出除了第2第多少个要素之外的持有的要素

 

rpoplpush(src, dst)

从一个列表取出最右边的元素,同时将其添加至另一个列表的最左边
# 参数:
    # src,要取数据的列表的name
    # dst,要添加数据的列表的name

 澳门新萄京官方网站 81

把names中的最左侧的xiaoming 移到了names2的最侧面

blpop(keys, timeout):

将多个列表排列,按照从左到右去pop对应列表的元素

# 参数:
    # keys,redis的name的集合
    # timeout,超时时间,当元素所有列表的元素获取完之后,阻塞等待列表内有数据的时间(秒), 0 表示永远阻塞

# 更多:
    # r.brpop(keys, timeout),从右向左获取数据

 澳门新萄京官方网站 82

把names中的数据每回从左往右删除,假设names里面有成分就应声删除,负担就等候4s。

此地有一个使用:作者把日子设置成40,然后在起步八个redis客户端,然后在那40s以内自身在给names加多三个新的成分,然后那边等待的客户端就当下把那几个值收取来了

澳门新萄京官方网站 83澳门新萄京官方网站 84

今昔也就是运转了五个进程,二个方可往列表中放入值,七个方可从列表中取值,有一点点像队列,想生产者耗费者,因为除去的时候会回来删除的值就一定于抽取来数据

brpoplpush(src, dst, timeout=0)

从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧

# 参数:
    # src,取出并要移除元素的列表对应的name
    # dst,要插入元素的列表对应的name
    # timeout,当src对应的列表中没有数据时,阻塞等待其有数据的超时时间(秒),0 表示永远阻塞

 澳门新萄京官方网站 85

纵使把names2的因素移到names中,从右端移到了左端

 

自定义增量迭代

由于redis类库中没有提供对列表元素的增量迭代,如果想要循环name对应的列表的所有元素,那么就需要:
    # 1、获取name对应的所有列表
    # 2、循环列表
# 但是,如果列表非常大,那么就有可能在第一步时就将程序的内容撑爆,所有有必要自定义一个增量迭代的功能:

def list_iter(name):
    """
    自定义redis列表增量迭代
    :param name: redis中的name,即:迭代name对应的列表
    :return: yield 返回 列表元素
    """
    list_count = r.llen(name)
    for index in xrange(list_count):
        yield r.lindex(name, index)

# 使用
for item in list_iter('pp'):
    print item

 

Set操作,Set集合正是不允许再一次的列表

澳门新萄京官方网站 86

 

上海教室能够观望,作者往names中插入了6个值,可是在群集中实际就独有3个值,所以说集合是分化意再一次的列表

sadd(name,values):name对应的聚合中添港币素

scard(name): 获取name对应的汇聚十三月素的个数

sdiff(keys, *args):在第八个name群集中且不再别的name对应的聚众中的成分会集(差集:不含B集合成分的装有A成分)

澳门新萄京官方网站 87

 

sdiffstore(dest, keys, *args):获取第贰个name对应的会合中且别的不再name对应的汇集,再讲其步入新的dest集结中

澳门新萄京官方网站 88

 

把差集的结果存到集结n6中,

sinter(keys, *args):(数学里的交集)

澳门新萄京官方网站 89

 

sinterstore(dest, keys, *args):获取集结之间的错落有致,再讲其参加到dest对应的聚合中

sismember(name, value):检查value是不是是name对应的汇集的成员

smembers(name): 获取name对应的联谊的持有成员,集结无法用切成块去取,因为它是严节的

澳门新萄京官方网站 90

获取会集names3的全数值

 

smove(src, dst, value):将有些成员从二个成团中活动到其余三个集合

spop(name):从集合的左手(尾巴部分)移除二个成员,并将其回来

srandmember(name, numbers):从name对应的集结中随机获取 numbers 个因素

srem(name, values):在name对应的汇聚中删除有个别值

sunion(keys, *args):获取多贰个name对应的群集的并集

sunionstore(dest,keys, *args):获取多三个name对应的成团的并集,并将结果保存到dest对应的集纳中

sscan(name, cursor=0, match=None, count=None)
sscan_iter(name, match=None, count=None):同字符串的操作,用于增量迭代分批获取成分,避免内部存储器消耗太大

 

稳步聚焦,在联谊的基础上,为每成分排序;成分的排序须求依靠其余三个值来拓展比较,所以,对于有序聚焦,每二个元素有八个值,即:值和分数,分数专门用来做排序。

zadd(name, *args, **kwargs)

在name对应的有序集合中添加元素
# 如:
     # zadd('zz', 'n1', 1, 'n2', 2)
     # 或
     # zadd('zz', n1=11, n2=22)

 澳门新萄京官方网站 91

给相应的因素设置权值,用来排序;先权值后值

 

zcard(name):获取name对应的稳步会集成分的数额 

zcount(name, min, max):获取name对应的静止聚聚焦分数 在 [min,max] 之间的个数

zincrby(name, value, amount):自增name对应的不改变聚焦的 name 对应的分数

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

# 按照索引范围获取name对应的有序集合的元素

# 参数:
    # name,redis的name
    # start,有序集合索引起始位置(非分数)
    # end,有序集合索引结束位置(非分数)
    # desc,排序规则,默认按照分数从小到大排序
    # withscores,是否获取元素的分数,默认只获取元素的值
    # score_cast_func,对分数进行数据转换的函数

# 更多:
    # 从大到小排序
    # zrevrange(name, start, end, withscores=False, score_cast_func=float)

    # 按照分数范围获取name对应的有序集合的元素
    # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
    # 从大到小排序
    # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

 澳门新萄京官方网站 92

澳门新萄京官方网站 93

 

zrank(name, value): 

获取某个值在 name对应的有序集合中的排行(从 0 开始)

# 更多:
    # zrevrank(name, value),从大到小排序

澳门新萄京官方网站 94

zrangebylex(name, min, max, start=None, num=None)

# 当有序集合的所有成员都具有相同的分值时,有序集合的元素会根据成员的 值 (lexicographical ordering)来进行排序,而这个命令则可以返回给定的有序集合键 key 中, 元素的值介于 min 和 max 之间的成员
# 对集合中的每个成员进行逐个字节的对比(byte-by-byte compare), 并按照从低到高的顺序, 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话, 那么命令会认为较长的字符串比较短的字符串要大

# 参数:
    # name,redis的name
    # min,左区间(值)。   表示正无限; - 表示负无限; ( 表示开区间; [ 则表示闭区间
    # min,右区间(值)
    # start,对结果进行分片处理,索引位置
    # num,对结果进行分片处理,索引后面的num个元素

# 如:
    # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
    # r.zrangebylex('myzset', "-", "[ca") 结果为:['aa', 'ba', 'ca']

# 更多:
    # 从大到小排序
    # zrevrangebylex(name, max, min, start=None, num=None)

zrem(name, values)

# 删除name对应的有序集合中值是values的成员

# 如:zrem('zz', ['s1', 's2'])

zremrangebyrank(name, min, max):根据相排版行范围删除

zremrangebyscore(name, min, max):遵照分数范围删除

zremrangebylex(name, min, max):依照值重返删除

zscore(name, value):获取name对应有序集结中 value 对应的分数

zinterstore(dest, keys, aggregate=None):

# 获取两个有序集合的交集,如果遇到相同值不同分数,则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

zunionstore(dest, keys, aggregate=None):

# 获取两个有序集合的并集,如果遇到相同值不同分数,则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

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

# 同字符串相似,相较于字符串新增score_cast_func,用来对分数进行操作

任何常用操作

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下

  redis暗中同意有十四个db,从0-15 ,能够用select 进行切换

randomkey():随机得到一个redis的name(不删除)

type(name):获取name对应值的品种

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

同字符串操作,用于增量迭代获取key

4.管道:

redis-py私下认可在施行每一次央求都会成立(连接池申请连接)和断开(归还连接池)一遍三番五次操作,要是想要在贰遍呼吁中钦命多个指令,则足以使用pipline完结三遍呼吁钦命多少个指令,並且默许意况下二回pipline 是原子性操作。

import redis

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

r = redis.Redis(connection_pool=pool)

# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)

pipe.set('name', 'alex')
pipe.set('role', 'teacher')

pipe.execute()

 

5.揭露订阅

澳门新萄京官方网站 95

那这几个怎么落到实处的啊?

 1 import redis
 2 class RedisHelper:
 3     def __init__(self):
 4         self.__conn = redis.Redis(host='192.168.1.101')
 5         self.chan_sub = 'fm104.7'
 6         self.chan_pub = 'fm104.7'
 7 
 8     def public(self, msg):
 9         self.__conn.publish(self.chan_pub, msg)
10         return True
11 
12     def subscribe(self):
13         pub = self.__conn.pubsub()#打开收音机
14         pub.subscribe(self.chan_sub)#调频道
15         pub.parse_response()#准备接收 
16         return pub

 订阅:

from RedisHelper import RedisHelper

obj = RedisHelper()
redis_sub = obj.subscribe()

while True:
    msg = redis_sub.parse_response()
    print(msg)

 

发布:

from RedisHelper import RedisHelper

obj = RedisHelper()
obj.public('hello,i am testing')

 

能够多个发布音讯,通过同八个频道传给一位:

澳门新萄京官方网站 96

 

memcached -d -m 10    -u root -l 192.168.20.219 -p 12000 -c 256 -P /tmp/memcached.pi

参数说明:
    -d 是启动一个守护进程
    -m 是分配给Memcache使用的内存数量,单位是MB
    -u 是运行Memcache的用户
    -l 是监听的服务器IP地址
    -p 是设置Memcache监听的端口,最好是1024以上的端口
    -c 选项是最大运行的并发连接数,默认是1024,按照你服务器的负载量来设定
    -P 是设置保存Memcache的pid文件
7、redis基本命令 有序set

Set操作,Set集结就是分化意再度的列表,本人是严节的
有序聚焦,在聚集的底子上,为每成分排序;成分的排序需求依据其他一个值来进行比较,
于是,对于有序聚焦,每三个成分有三个值,即:值和分数,分数特地用来做排序。

1.新增
zadd(name, *args, **kwargs)
在name对应的不改变集中中添日币素
如:

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")) # 集合长度
print(r.zcard("zset2")) # 集合长度
print(r.zrange("zset1", 0, -1))   # 获取有序集合中所有元素
print(r.zrange("zset2", 0, -1, withscores=True))   # 获取有序集合中所有元素和分数

2.到手有序会集成分个数 类似于len
zcard(name)
获取name对应的平稳集结成分的多少

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

3.赢得有序集中的持有因素
r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float)
根据索引范围获得name对应的稳步集中的要素
参数:
name,redis的name
start,有序群集索引初步地方(非分数)
end,有序集结索引甘休地方(非分数)
desc,排序准绳,暗许遵照分数从小到大排序
withscores,是不是收获成分的分数,暗中认可只得到成分的值
score_cast_func,对分数进行数据转变的函数

3-1 从大到小排序(同zrange,会集是从大到小排序的)
zrevrange(name, start, end, withscores=False, score_cast_func=float)

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

3-2 根据分数范围取得name对应的不改变聚焦的因素
zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)

for i in range(1, 30):
   element = 'n'   str(i)
   r.zadd("zset3", element, i)
print(r.zrangebyscore("zset3", 15, 25)) # # 在分数是15-25之间,取出符合条件的元素
print(r.zrangebyscore("zset3", 12, 22, withscores=True))    # 在分数是12-22之间,取出符合条件的元素(带分数)

3-3 依照分数范围获得有序集中的要素并排序(暗中同意从大到小排序)
zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

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

3-4 获取具备因素--暗许依照分数顺序排序
zscan(name, cursor=0, match=None, count=None, score_cast_func=float)

print(r.zscan("zset3"))

3-5 获取具有因素--迭代器
zscan_iter(name, match=None, count=None,score_cast_func=float)

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

4.zcount(name, min, max)
获得name对应的不改变聚聚集分数 在 [min,max] 之间的个数

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

5.自增
zincrby(name, value, amount)
自增name对应的稳步聚焦的 name 对应的分数

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

6.获取值的索引号
zrank(name, value)
获得某些值在 name对应的有序聚聚焦的索引(从 0 早先)
更多:
zrevrank(name, value),从大到小排序

print(r.zrank("zset3", "n1"))   # n1的索引号是0 这里按照分数顺序(从小到大)
print(r.zrank("zset3", "n6"))   # n6的索引号是1

print(r.zrevrank("zset3", "n1"))    # n1的索引号是29 这里安照分数倒序(从大到小)

7.剔除--内定值删除
zrem(name, values)
剔除name对应的稳步聚集中值是values的积极分子

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

8.去除--依据排名范围删除,依照索引号来删除
zremrangebyrank(name, min, max)
听别人说排名范围删除

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

9.去除--依据分数范围删除
zremrangebyscore(name, min, max)
听闻分数范围删除

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

10.获取值对应的分数
zscore(name, value)
收获name对应有序集合中 value 对应的分数

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

Python安装Memcached模块:

8、别的常用操作

1.删除
delete(*names)
听别人讲删除redis中的自便数据类型(string、hash、list、set、有序set)

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

2.反省名字是不是留存
exists(name)
检查实验redis的name是不是留存,存在正是True,False 海市蜃楼

print(r.exists("zset1"))

3.模糊相配
keys(pattern='')
依附模型获取redis的name
更多:
KEYS
相称数据库中装有 key 。
KEYS h?llo 匹配 hello , hallo 和 hxllo 等。
KEYS h*llo 匹配 hllo 和 heeeeello 等。
KEYS h[ae]llo 相称 hello 和 hallo ,但不相称 hillo

print(r.keys("foo*"))

4.设置超时时间
expire(name ,time)
为某些redis的某些name设置超时时间

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.重命名
rename(src, dst)
对redis的name重命名

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

6.随机获取name
randomkey()
随机得到一个redis的name(不删除)

print(r.randomkey())

7.获得项目
type(name)
取得name对应值的体系

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

8.查看全数因素
scan(cursor=0, match=None, count=None)

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.查看全部因素--迭代器
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)

other 方法

print(r.get('name'))    # 查询key为name的值
r.delete("gender")  # 删除key为gender的键值对
print(r.keys()) # 查询所有的Key
print(r.dbsize())   # 当前redis包含多少条数据
r.save()    # 执行"检查点"操作,将数据写回磁盘。保存时阻塞
# r.flushdb()        # 清空r中的所有数据

 

管道(pipeline)
redis私下认可在实施每一回央浼都会创立(连接池申请连接)和断开(归还连接池)壹回接二连三操作,
如若想要在二回呼吁中钦定八个指令,则足以使用pipline完结二遍呼吁钦赐四个指令,况且默许意况下一遍pipline 是原子性操作。就是redis的事体。

管道(pipeline)是redis在提供单个要求中缓冲多条服务器命令的基类的子类。它经过降低服务器-客户端之间多次的TCP数据库包,进而大大升高了实行批量发令的作用。

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)    # 默认的情况下,管道里执行的命令可以保证执行的原子性,执行pipe = r.pipeline(transaction=False)可以禁用这一特性。
# pipe = r.pipeline(transaction=True)
pipe = r.pipeline() # 创建一个管道

pipe.set('name', 'jack')
pipe.set('role', 'sb')
pipe.sadd('faz', 'baz')
pipe.incr('num')    # 如果num不存在则vaule为1,如果存在,则value自增1
pipe.execute()

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

管道的命令可以写在同步,如:

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

 

 转自:

python操作Memcached使用Python-memcached模块
下载安装:https://pypi.python.org/pypi/python-memcached

解压压缩包,然后在cmd命令下切换到安装包目录
执行 python setup.py install 安装

2、轻松连接

import memcache

mc = memcache.Client(["192.168.20.219:12000"],debug=True)
mc.set("foo","Hello,World")
ret = mc.get("foo")
print(ret)

# Hello,World

debug = True 表示运营出现谬误时,彰显错误消息,上线后移除该参数

3、集群

python-memcached模块原生帮忙集群操作,其原理是在内部存款和储蓄器维护一个主机列表,且集群中主机的权重值和主机在列表中重新出现的次数成正比

  主机    权重
    1.1.1.1   1
    1.1.1.2   2
    1.1.1.3   1

那么在内存中主机列表为:
    host_list = ["1.1.1.1", "1.1.1.2", "1.1.1.2", "1.1.1.3", ]

万一用户依据假设要在内部存款和储蓄器中开创三个键值对(如:k1 = "v1"),那么要实践一出手续:

  • 依据算法将 k1 转变来四个数字
  • 将数字和主机列表长度求余数,获得二个值 N( 0 <= N < 列表长度 )
  • 在主机列表中依照第2步获得的值为索引获取主机,举例:host_list[N]
  • 总是 将第3步中获取的主机,将 k1 = "v1" 放置在该服务器的内部存款和储蓄器中

代码完毕如下:

mc = memcache.Client([('1.1.1.1:12000', 1), ('1.1.1.2:12000', 2), ('1.1.1.3:12000', 1)], debug=True)

mc.set('k1', 'v1')

4、Memcache操作

① add

增加一条键值对,假使已经存在的 key,重复试行add操作非常

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

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)
mc.add('k1', 'v1')

#MemCached: while expecting 'STORED', got unexpected response 'NOT_STORED'
#报错,对已经存在的key重复添加,失败!!!

②、replace

replace 修改有个别key的值,借使key不设有,则足够

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

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)
# 如果memcache中存在kkkk,则替换成功,否则异常
mc.replace('kkkk', '999')

#MemCached: while expecting 'STORED', got unexpected response 'NOT_STORED'

③、set 和 set_multi

set            设置一个键值对,假若key不设有,则创立,借使key存在,则修改
set_multi   设置多少个键值对,要是key不设有,则创建,假设key存在,则修改

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

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)

mc.set('key0', 'lianzhilei')

mc.set_multi({'key1': 'val1', 'key2': 'val2'})

④、delete 和 delete_multi

delete             在Memcached中删去钦命的一个键值对
澳门新萄京官方网站,delete_multi    在Memcached中剔除钦定的五个键值对

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

import memcache

mc = memcache.Client(['192.168.20.219:12000'], debug=True)

mc.delete('key0')
mc.delete_multi(['key1', 'key2'])

⑤、get 和 get_multi

get            获取四个键值对
get_multi   获取多一个键值对

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

import memcache

mc = memcache.Client(['192.168.20.219:12000'], debug=True)

val = mc.get('key0')
item_dict = mc.get_multi(["key1", "key2", "key3"])

⑥、append 和 prepend

append    修改钦定key的值,在该值 前边 追加内容
prepend   修改内定key的值,在该值 前边 插入内容

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)
# k1 = "v1"

mc.append('k1', 'after')
# k1 = "v1after"

mc.prepend('k1', 'before')

⑦、decr 和 incr  

incr  自增,将Memcached中的某三个值扩充 N ( N默以为1 )
decr 自减,将Memcached中的某三个值收缩 N ( N默感觉1 )

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

import memcache

mc = memcache.Client(["192.168.20.219:12000"], debug=True)
mc.set('k1', '777')

mc.incr('k1')
# k1 = 778

mc.incr('k1', 10)
# k1 = 788

mc.decr('k1')
# k1 = 787

mc.decr('k1', 10)
# k1 = 777

⑧、gets 和 cas

如超级市场商品剩余个数,即使改值保存在memcache中,product_count = 900
A用户刷新页面从memcache中读取到product_count = 900
B用户刷新页面从memcache中读取到product_count = 900

万一A、B用平衡购买商品

A用户修改商品剩余个数 product_count=899
B用户修改商品剩余个数 product_count=899

如此一来缓存内的数量便不在正确,八个用户购买商品后,商品剩余还是899
假若使用python的set和get来操作以上进度,那么程序就能够如上述所示情况!

即使想要制止此情景的发出,只要选用 gets 和 cas 就可以,如:

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

import memcache

mc = memcache.Client(['192.168.20.219:12000'], debug=True, cache_cas=True)

v = mc.gets('product_count')
# ...
# 如果有人在gets之后和cas之前修改了product_count,那么,下面的设置将会执行失败,剖出异常,从而避免非正常数据的产生
mc.cas('product_count', "899")

Ps:本质上每一回奉行gets时,会从memcache中得到一个自增的数字,通过cas去修改gets的值时,会带走事先得到的自增值和memcache中的自增值进行相比较,借使相等,则足以付出,借使不想等,这表示在gets和cas推行之间,又有别的人执行了gets(获取了缓冲的钦点值), 如此一来有非常的大可能率出现畸形数据,则不容许修改

 

 

二、Redis

redis是一个key-value储存系统。和Memcached类似,它援救存款和储蓄的value类型相对愈来愈多,满含string(字符串)、list(链表)、set(集合)、zset(sorted set --有序群集)和hash(哈希类型)。这个数据类型都帮忙push/pop、add/remove及取交集并集和差集及更丰盛的操作,並且那一个操作都以原子性的。在此基础上,redis帮助各类不一样方法的排序。与memcached一样,为了保证效用,数据都以缓存在内部存款和储蓄器中。差别的是redis会周期性的把立异的数额写入磁盘只怕把修改操作写入追加的笔录文件,並且在此基础上贯彻了master-slave(主从)同步

1、安装和大旨选拔

redis安装:

wget http://download.redis.io/releases/redis-3.0.6.tar.gz
tar xzf redis-3.0.6.tar.gz
cd redis-3.0.6
make

启航服务端:

src/redis-server

开发银行客户端:

src/redis-cli
redis> set foo bar
OK
redis> get foo
"bar

2、Python安装Redis模块

sudo pip install redis
or
sudo easy_install redis
or
源码安装

详见:https://github.com/WoLpH/redis-py

redis-py 的API的行使能够分类为:

  • 连天格局
  • 连接池
  • 操作管道
    • String 操作
    • Hash 操作
    • List 操作
    • Set 操作
    • Sort Set 操作
  • 管道
  • 颁发订阅

3、轻便连接

redis-py提供多少个类Redis和StrictRedis用于落实Redis的授命,StrictRedis用于落实许多法定的吩咐,并利用官方的语法和指令,Redis是StrictRedis的子类,用于向后格外旧版本的redis-py

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

import redis

r = redis.Redis(host='192.168.20.219', port=6379)
r.set('foo', 'Hello,World')
print(r.get('foo'))

# b'Hello,World'

4、连接池

redis-py使用connection pool来管理对贰个redis server的富有连接,幸免每趟创设、释放连接的支付。默许,每种Redis实例都会维护一个团结的连接池。能够直接创立三个连接池,然后作为参数Redis,那样就足以兑现多少个Redis实例分享七个连接池

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

import redis

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

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

# b'Hello,World'

5、 String操作

redis中的String在在内部存款和储蓄器中依照一个name对应二个value来存款和储蓄。如图:

澳门新萄京官方网站 97

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

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

127.0.0.1:6379> set name lzl ex 2
OK
127.0.0.1:6379> get name
"lzl"
127.0.0.1:6379> get name
(nil)

② setnx(name, value)

设置值,只有name不存在时,执行设置操作(添加)

127.0.0.1:6379> setnx name lianzhilei
(integer) 0
127.0.0.1:6379> get name
"lzl"
127.0.0.1:6379> setnx name2 lianzhilei
(integer) 1
127.0.0.1:6379> get name2
"lianzhilei"

③ setex(name, value, time)

# 设置值
# 参数:
    # time,过期时间(数字秒 或 timedelta对象)

127.0.0.1:6379> setex age 2 18
OK
127.0.0.1:6379> get age
"18"
127.0.0.1:6379> get age
(nil)

④ psetex(name, time_ms, value)

# 设置值
# 参数:
    # time_ms,过期时间(数字毫秒 或 timedelta对象)

⑤ mset(*args, **kwargs)

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

127.0.0.1:6379[2]> mset name lzl age 18
OK
127.0.0.1:6379[2]> keys *
1) "age"
2) "name"

⑥ get(name)

#获取值

r.set("name","lzl")
print(r.get('name'))
# b'lzl'

⑦ mget(keys, *args)

批量获取
如:
    mget('name', 'age')
    或
    r.mget(['name', 'age'])

127.0.0.1:6379[2]> mget name age
1) "lzl"
2) "18"

⑧ getset(name, value)

设置新值并获取原来的值

127.0.0.1:6379[2]> getset name eric
"lzl"
127.0.0.1:6379[2]> get name
"eric"

⑨ getrange(key, start, end)

# 获取子序列(根据字节获取,非字符)
# 参数:
    # name,Redis 的 name
    # start,起始位置(字节)
    # end,结束位置(字节)
# 如: "连志雷" ,0-3表示 "连"

127.0.0.1:6379[2]> getrange name 0 5
"lianzh"

⑩ setrange(name, offset, value)

# 修改字符串内容,从指定字符串索引开始向后替换(新值太长时,则向后添加)
# 参数:
    # offset,字符串的索引,字节(一个汉字三个字节)
    # value,要设置的值

⑪ setbit(name, offset, value)

# 对name对应值的二进制表示的位进行操作

# 参数:
    # name,redis的name
    # offset,位的索引(将值变换成二进制后再进行索引)
    # value,值只能是 1 或 0

# 注:如果在Redis中有一个对应: n1 = "foo",
        那么字符串foo的二进制表示为:01100110 01101111 01101111
    所以,如果执行 setbit('n1', 7, 1),则就会将第7位设置为1,
        那么最终二进制则变成 01100111 01101111 01101111,即:"goo"

# 扩展,转换二进制表示:

    # source = "连志雷"
    source = "foo"

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

    特别的,如果source是汉字 "连志雷"怎么办?
    答:对于utf-8,每一个汉字占 3 个字节,那么 "武沛齐" 则有 9个字节
       对于汉字,for循环时候会按照 字节 迭代,那么在迭代时,将每一个字节转换 十进制数,然后再将十进制数转换成二进制
        11100110 10101101 10100110 11100110 10110010 10011011 11101001 10111101 10010000

127.0.0.1:6379[2]> set n1 foo
OK
127.0.0.1:6379[2]> setbit n1 7 1
(integer) 0
127.0.0.1:6379[2]> get n1
"goo"

setbit巨流弊的利用场景,想想怎么动静下会用到那一个职能吗?超大型的施用平台,例如和讯腾讯网,笔者想查看当前正值登入的用户,如何兑现?当然你会想到,用户登入后在数据库上的用户新闻上做个标记,然后count去总结做标志的用户一同有稍许,so,当前用户查看解决;OK,好好,首先各种用户登陆都要安装标志,假如当前用户多少个亿,那么得存多少个亿的号子位,一级占用库的付出;今后就有二个无敌高效的点子,即计算当前在线用户,又展现在线用户ID,那就是选取二进制位,什么看头啊?看上边包车型地铁代码就可以知晓了

统计在线用户数

127.0.0.1:6379[2]> setbit lineuser 1000 1      #1000表示用户id  
(integer) 0
127.0.0.1:6379[2]> setbit lineuser 55 1
(integer) 0
127.0.0.1:6379[2]> setbit lineuser 6000 1
(integer) 0
127.0.0.1:6379[2]> bitcount lineuser        #统计当前二进制位1的个数,即当前在线用户数
(integer) 3

bitcount总计二级制位中1的个数,setbit和bitcount同盟使用,轻便搞定当下在线用户数的标题,那还不是最厉害的,大家还能够利用这么些总括当前在线的皆有何人

查看用户ID有没有在线

127.0.0.1:6379[2]> getbit lineuser 1000        #查看id1000   1表示在线 0表示不在线
(integer) 1
127.0.0.1:6379[2]> getbit lineuser 100
(integer) 0

自然大家还足以透过for循环或然yield生成器打字与印刷出富有的在线用户ID,1字节=8位,那么10m=7000万位,即一个亿的在线用户也就10m多的内部存款和储蓄器就可消除,优化就在轻便之间

⑫ getbit(name, offset)

# 获取name对应的值的二进制表示中的某位的值 (0或1)

⑬ bitcount(key, start=None, end=None)

# 获取name对应的值的二进制表示中 1 的个数
# 参数:
    # key,Redis的name
    # start,位起始位置
    # end,位结束位置

⑭ bitop(operation, dest, *keys)

# 获取多个值,并将值做位运算,将最后的结果保存至新的name对应的值

# 参数:
    # operation,AND(并) 、 OR(或) 、 NOT(非) 、 XOR(异或)
    # dest, 新的Redis的name
    # *keys,要查找的Redis的name

# 如:
    bitop("AND", 'new_name', 'n1', 'n2', 'n3')
    # 获取Redis中n1,n2,n3对应的值,然后讲所有的值做位运算(求并集),然后将结果保存 new_name 对应的值中

⑮ strlen(name)

# 返回name对应值的字节长度(一个汉字3个字节)

127.0.0.1:6379[2]> get name
"lianzhilei"
127.0.0.1:6379[2]> strlen name
(integer) 10

⑯ incr(self, name, amount=1)

# 自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。

# 参数:
    # name,Redis的name
    # amount,自增数(必须是整数)

# 注:同incrby

127.0.0.1:6379[2]> incr login_users     #自增
(integer) 1
127.0.0.1:6379[2]> incr login_users 
(integer) 2
127.0.0.1:6379[2]> incr login_users 
(integer) 3

⑰ incrbyfloat(self, name, amount=1.0)

# 自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。

# 参数:
    # name,Redis的name
    # amount,自增数(浮点型)

⑱ decr(self, name, amount=1)

# 自减 name对应的值,当name不存在时,则创建name=amount,否则,则自减。

# 参数:
    # name,Redis的name
    # amount,自减数(整数)

127.0.0.1:6379[2]> decr login_users     #自减
(integer) 2
127.0.0.1:6379[2]> decr login_users
(integer) 1
127.0.0.1:6379[2]> decr login_users
(integer) 0

⑲ append(key, value)

# 在redis name对应的值后面追加内容

# 参数:
    key, redis的name
    value, 要追加的字符串

127.0.0.1:6379[2]> append name jjjj
(integer) 14
127.0.0.1:6379[2]> get name
"lianzhileijjjj"

 

6、Hash操作

redis中Hash在内存中的存款和储蓄格式如下图:

澳门新萄京官方网站 98

① hset(name, key, value)

# name对应的hash中设置一个键值对(不存在,则创建;否则,修改)

# 参数:
    # name,redis的name
    # key,name对应的hash中的key
    # value,name对应的hash中的value

# 注:
    # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建(相当于添加)


127.0.0.1:6379[3]> hset class14 name lzl
(integer) 1
127.0.0.1:6379[3]> hset class14 age 18
(integer) 1
127.0.0.1:6379[3]> hset class14 id 10001
(integer) 1
127.0.0.1:6379[3]> hgetall class14
1) "name"
2) "lzl"
3) "age"
4) "18"
5) "id"
6) "10001"
127.0.0.1:6379[3]> hget class14 name
"lzl"
127.0.0.1:6379[3]> hkeys class14
1) "name"
2) "age"
3) "id"
127.0.0.1:6379[3]> hvals class14
1) "lzl"
2) "18"
3) "10001"

② hmset(name, mapping)

# 在name对应的hash中批量设置键值对

# 参数:
    # name,redis的name
    # mapping,字典,如:{'k1':'v1', 'k2': 'v2'}

# 如:
    # r.hmset('xx', {'k1':'v1', 'k2': 'v2'})

127.0.0.1:6379[3]> hmset info k1 1 k2 2
OK
127.0.0.1:6379[3]> hmget info k1 k2
1) "1"
2) "2"

③ hget(name,key)

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

④ hmget(name, keys, *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')

127.0.0.1:6379[3]> hmset info k1 1 k2 2
OK
127.0.0.1:6379[3]> hmget info k1 k2
1) "1"
2) "2"

⑤ hgetall(name)

获取name对应hash的所有键值

⑥ hlen(name)

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

127.0.0.1:6379[3]> hlen info 
(integer) 2

⑦ hkeys(name)

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

⑧ hvals(name)

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

⑨ hexists(name, key)

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

127.0.0.1:6379[3]> hexists info k1
(integer) 1
127.0.0.1:6379[3]> hexists info k3
(integer) 0

⑩ hdel(name,*keys)

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

⑪ hincrby(name, key, amount=1)

# 自增name对应的hash中的指定key的值,不存在则创建key=amount
# 参数:
    # name,redis中的name
    # key, hash对应的key
    # amount,自增数(整数)

127.0.0.1:6379[3]> hincrby info k3 1
(integer) 1
127.0.0.1:6379[3]> hincrby info k3 1
(integer) 2
127.0.0.1:6379[3]> hincrby info k3 1
(integer) 3

⑫ 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时,表示数据已经通过分片获取完毕

127.0.0.1:6379[3]> hscan info 0 match k*
1) "0"
2) 1) "k1"
   2) "1"
   3) "k2"
   4) "2"
   5) "k3"
   6) "3"

⑭ hscan_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

 

7、List操作

redis中的List在在内部存款和储蓄器中依据一个name对应二个List来积累。如图:

澳门新萄京官方网站 99

① lpush(name,values)

# 在name对应的list中添加元素,每个新的元素都添加到列表的最左边

# 如:
    # r.lpush('oo', 11,22,33)
    # 保存顺序为: 33,22,11

# 扩展:
    # rpush(name, values) 表示从右向左操作

127.0.0.1:6379[3]> lpush names lzl alex wupeiqi 
(integer) 3
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
2) "alex"
3) "lzl"

② lpushx(name,value)

# 在name对应的list中添加元素,只有name已经存在时,值添加到列表的最左边

# 更多:
    # rpushx(name, value) 表示从右向左操作

③ llen(name)

name对应的list元素的个数

127.0.0.1:6379[3]> llen names
(integer) 3

④ linsert(name, where, refvalue, value))

# 在name对应的列表的某一个值前或后插入一个新值

# 参数:
    # name,redis的name
    # where,BEFORE或AFTER
    # refvalue,标杆值,即:在它前后插入数据
    # value,要插入的数据

127.0.0.1:6379[3]> linsert names BEFORE alex befor
(integer) 4
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
2) "befor"
3) "alex"
4) "lzl"

⑤ lset(name, index, value)

# 对name对应的list中的某一个索引位置重新赋值

# 参数:
    # name,redis的name
    # index,list的索引位置
    # value,要设置的值

127.0.0.1:6379[3]> lset names 3 LianZhiLei
OK
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
2) "befor"
3) "alex"
4) "LianZhiLei"

⑥ lrem(name, value, num)

# 在name对应的list中删除指定的值

# 参数:
    # name,redis的name
    # value,要删除的值
    # num,  num=0,删除列表中所有的指定值;
           # num=2,从前到后,删除2个;
           # num=-2,从后向前,删除2个

127.0.0.1:6379[3]> lrem names 1 befor
(integer) 1
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
2) "alex"
3) "LianZhiLei"

⑦ lpop(name)

# 在name对应的列表的左侧获取第一个元素并在列表中移除,返回值则是第一个元素

# 更多:
    # rpop(name) 表示从右向左操作

127.0.0.1:6379[3]> lpop names
"wupeiqi"

⑧ lindex(name, index)

在name对应的列表中根据索引获取列表元素

⑨ lrange(name, start, end)

# 在name对应的列表分片获取数据
# 参数:
    # name,redis的name
    # start,索引的起始位置
    # end,索引结束位置

⑩ ltrim(name, start, end)

# 在name对应的列表中移除没有在start-end索引之间的值
# 参数:
    # name,redis的name
    # start,索引的起始位置
    # end,索引结束位置

127.0.0.1:6379[3]> LRANGE names 0 -1
1) "eric"
2) "wupeiqi"
3) "alex"
4) "LianZhiLei"
127.0.0.1:6379[3]> ltrim names 1 2
OK
127.0.0.1:6379[3]> LRANGE names 0 -1
1) "wupeiqi"
2) "alex"

⑪ rpoplpush(src, dst)

# 从一个列表取出最右边的元素,同时将其添加至另一个列表的最左边
# 参数:
    # src,要取数据的列表的name
    # dst,要添加数据的列表的name

127.0.0.1:6379[3]> rpush names2 LZL
(integer) 1
127.0.0.1:6379[3]> RPOPLPUSH names names2
"alex"
127.0.0.1:6379[3]> lrange names 0 -1
1) "wupeiqi"
127.0.0.1:6379[3]> lrange names2 0 -1
1) "alex"
2) "LZL"

⑫ blpop(keys, timeout)

# 将多个列表排列,按照从左到右去pop对应列表的元素

# 参数:
    # keys,redis的name的集合
    # timeout,超时时间,当元素所有列表的元素获取完之后,阻塞等待列表内有数据的时间(秒), 0 表示永远阻塞

# 更多:
    # r.brpop(keys, timeout),从右向左获取数据

⑬ brpoplpush(src, dst, timeout=0)

# 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧

# 参数:
    # src,取出并要移除元素的列表对应的name
    # dst,要插入元素的列表对应的name
    # timeout,当src对应的列表中没有数据时,阻塞等待其有数据的超时时间(秒),0 表示永远阻塞

⑭ 自定义增量迭代

# 由于redis类库中没有提供对列表元素的增量迭代,如果想要循环name对应的列表的所有元素,那么就需要:
    # 1、获取name对应的所有列表
    # 2、循环列表
# 但是,如果列表非常大,那么就有可能在第一步时就将程序的内容撑爆,所有有必要自定义一个增量迭代的功能:

def list_iter(name):
    """
    自定义redis列表增量迭代
    :param name: redis中的name,即:迭代name对应的列表
    :return: yield 返回 列表元素
    """
    list_count = r.llen(name)
    for index in xrange(list_count):
        yield r.lindex(name, index)

# 使用
for item in list_iter('pp'):
    print item

 

8、Set操作

Set集结便是不容许再度的列表

① sadd(name,values)

# name对应的集合中添加元素

127.0.0.1:6379[3]> sadd names alex alex lzl lzl jack 
(integer) 3
127.0.0.1:6379[3]> smembers names
1) "jack"
2) "alex"
3) "lzl"

② scard(name)

# 获取name对应的集合中元素个数

127.0.0.1:6379[3]> scard names
(integer) 3

③ sdiff(keys, *args)

# 在第一个name对应的集合中且不在其他name对应的集合的元素集合(差级)

127.0.0.1:6379[3]> sadd names2 eric lzl wupeiqi
(integer) 3
127.0.0.1:6379[3]> sdiff names names2
1) "alex"
2) "jack"

④ sdiffstore(dest, keys, *args)

# 获取name1集合里有但是name2集合里没有的元素,然后把元素添加到dest对应的集合中

127.0.0.1:6379[3]> SMEMBERS names
1) "jack"
2) "alex"
3) "lzl"
127.0.0.1:6379[3]> SMEMBERS names2
1) "wupeiqi"
2) "lzl"
3) "eric"
127.0.0.1:6379[3]> SDIFFSTORE dest names names2
(integer) 2
127.0.0.1:6379[3]> SMEMBERS dest
1) "alex"
2) "jack"

⑤ sinter(keys, *args)

# 获取多个name集合中的交集

127.0.0.1:6379[3]> SINTER names names2 
1) "lzl"

⑥ sinterstore(dest, keys, *args)

# 获取多个name对应集合的交集,再讲其加入到dest对应的集合中

⑦ sismember(name, value)

# 检查value是否是name对应的集合的成员

127.0.0.1:6379[3]> SISMEMBER names lzl
(integer) 1

⑧ smembers(name)

# 获取name对应的集合的所有成员

⑨ smove(src, dst, value)

# 将某个成员从一个集合中移动到另外一个集合

⑩ spop(name)

# 从集合的右侧(尾部)移除一个成员,并将其返回

⑪ srandmember(name, numbers)

# 从name对应的集合中随机获取 numbers 个元素

⑫ srem(name, values)

# 在name对应的集合中删除某些值

⑬ sunion(keys, *args)

# 获取多一个name对应的集合的并集

⑭ sunionstore(dest,keys, *args)

# 获取多一个name对应的集合的并集,并将结果保存到dest对应的集合中

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

# 同字符串的操作,用于增量迭代分批获取元素,避免内存消耗太大

127.0.0.1:6379[3]> sscan names 0 match l*
1) "0"
2) 1) "lzl"

 

 

9、有序集中

在集结的基础上,为每成分排序;成分的排序必要基于别的一个值来展开相比较,所以,对于有序聚焦,每八个要素有五个值,即:值和分数,分数特意用来做排序

① zadd(name, *args, **kwargs)

# 在name对应的有序集合中添加元素
# 如:
     # zadd('zz', 'n1', 1, 'n2', 2)
     # 或
     # zadd('zz', n1=11, n2=22)

127.0.0.1:6379[4]> zadd z1 10 lzl 5 alex 8 jack  11 lzl
(integer) 3
127.0.0.1:6379[4]> ZRANGE z1 0 -1
1) "alex"
2) "jack"
3) "lzl"

#按分值排序并去重

② zcard(name)

# 获取name对应的有序集合元素的数量

③ zcount(name, min, max)

# 获取name对应的有序集合中分数 在 [min,max] 之间的个数

127.0.0.1:6379[4]> ZCOUNT z1 6 9
(integer) 1

④ zincrby(name, value, amount)

# 自增name对应的有序集合的 name 对应的分数

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

# 按照索引范围获取name对应的有序集合的元素

# 参数:
    # name,redis的name
    # start,有序集合索引起始位置(非分数)
    # end,有序集合索引结束位置(非分数)
    # desc,排序规则,默认按照分数从小到大排序
    # withscores,是否获取元素的分数,默认只获取元素的值
    # score_cast_func,对分数进行数据转换的函数

# 更多:
    # 从大到小排序
    # zrevrange(name, start, end, withscores=False, score_cast_func=float)

    # 按照分数范围获取name对应的有序集合的元素
    # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float)
    # 从大到小排序
    # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float)

127.0.0.1:6379[4]> ZRANGE z1 0 -1 withscores
1) "alex"
2) "5"
3) "jack"
4) "8"
5) "lzl"
6) "11"

⑥ zrank(name, value)

# 获取某个值在 name对应的有序集合中的排行(从 0 开始)

# 更多:
    # zrevrank(name, value),从大到小排序

127.0.0.1:6379[4]> ZRANK z1 lzl
(integer) 2

#排名第二

⑦ zrangebylex(name, min, max, start=None, num=None)

# 当有序集合的所有成员都具有相同的分值时,有序集合的元素会根据成员的 值 (lexicographical ordering)来进行排序,而这个命令则可以返回给定的有序集合键 key 中, 元素的值介于 min 和 max 之间的成员
# 对集合中的每个成员进行逐个字节的对比(byte-by-byte compare), 并按照从低到高的顺序, 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话, 那么命令会认为较长的字符串比较短的字符串要大

# 参数:
    # name,redis的name
    # min,左区间(值)。   表示正无限; - 表示负无限; ( 表示开区间; [ 则表示闭区间
    # min,右区间(值)
    # start,对结果进行分片处理,索引位置
    # num,对结果进行分片处理,索引后面的num个元素

# 如:
    # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga
    # r.zrangebylex('myzset', "-", "[ca") 结果为:['aa', 'ba', 'ca']

# 更多:
    # 从大到小排序
    # zrevrangebylex(name, max, min, start=None, num=None)

⑧ zrem(name, values)

# 删除name对应的有序集合中值是values的成员

# 如:zrem('zz', ['s1', 's2'])

⑨ zremrangebyrank(name, min, max)

# 根据排行范围删除

⑩ zremrangebyscore(name, min, max)

# 根据分数范围删除

⑪ zremrangebylex(name, min, max)

# 根据值返回删除

⑫ zscore(name, value)

# 获取name对应有序集合中 value 对应的分数

⑬ zinterstore(dest, keys, aggregate=None)

# 获取两个有序集合的交集,如果遇到相同值不同分数,则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

⑭ zunionstore(dest, keys, aggregate=None)

# 获取两个有序集合的并集,如果遇到相同值不同分数,则按照aggregate进行操作
# aggregate的值为:  SUM  MIN  MAX

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

# 同字符串相似,相较于字符串新增score_cast_func,用来对分数进行操作

 

10、别的常用操作

① 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

 

11、管道

redis-py暗许在施行每回供给都会创设(连接池申请连接)和断开(归还连接池)二次一连操作,就算想要在一次呼吁中钦赐四个指令,则能够使用pipline完成三次呼吁钦定五个指令,而且私下认可景况下二回pipline 是原子性操作

#!/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)

# pipe = r.pipeline(transaction=False)
pipe = r.pipeline(transaction=True)

pipe.set('name', 'alex')
pipe.set('role', 'sb')

pipe.execute()

 

12、发表订阅
澳门新萄京官方网站 100

redishelper:

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

import redis

class RedisHelper:

    def __init__(self):
        self.__conn = redis.Redis(host='192.168.20.219')
        self.chan_sub = 'fm104.5'
        self.chan_pub = 'fm104.5'

    def public(self, msg):
        self.__conn.publish(self.chan_pub, msg)
        return True

    def subscribe(self):
        pub = self.__conn.pubsub()      #打开收音机
        pub.subscribe(self.chan_sub)    #调频道
        pub.parse_response()           #准备接受
        return pub

订阅者:

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

from redishelper import RedisHelper

obj = RedisHelper()
redis_sub = obj.subscribe()

while True:
    msg = redis_sub.parse_response()
    print(msg)

发布者:

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

from redishelper import RedisHelper

obj = RedisHelper()
obj.public('hello')

更加多参见:

  

 

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站:数据库操作Memcache,学习笔

关键词: