本文详细介绍如何使用Python操作Redis和Memcached，涵盖安装配置、基本命令、高级特性及应用场景，适合初学者和进阶开发者。
一、Memcached操作
Memcached是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象减少读取数据库的次数，从而提高动态、数据库驱动网站的速度。Memcached基于一个存储键/值的hashmap。其守护进程(daemon)是用C语言写的，但是客户端可以用任何语言来编写，并通过memcached协议与守护进程通信。
1，Memcached安装和基本使用
Memcached安装：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
#源码安装memcached,依赖libevent
#需要提前安装:yum -y install libevent-devel
wget http:
/
/
memcached.org
/
latest
tar
-
zxf memcached
-
1.4
.
29.tar
.gz
cd memcached
-
1.4
.
29
/
.
/
configure && make && make test && sudo make install
#编译安装以后，启动memcached进程
memcached
-
d
-
m
10
-
u root
-
l
10.211
.
55.4
-
p
12000
-
c
256
-
P
/
tmp
/
memcached.pid
#memcached参数说明：
-
d :启动一个守护进程；
-
m :分配给Memcache使用的内存数量，单位是MB；
-
u :运行memcache的用户；
-
l :监听的服务器IP地址；
-
p :设置Memcache监听的端口，最好是
1024
以上的端口；
-
c :选项是最大运行的并发连接数，默认是
1024
，按照你服务器的负载量来设定；
-
P :设置保存Memcache的pid文件。
|
Memcached操作命令：
|
1
2
3
|
存储命令：
set
/
add
/
replace
/
append
/
prepend
/
cas
获取命令： get
/
gets
其他命令： delete
/
stats..
|
2、Python操作Memcached
首先在本机安装Python-memcached的模块，下载并安装，模块地址：https://pypi.python.org/pypi/python-memcached
|
1
2
3
4
5
6
7
8
9
10
11
12
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
memcache
mc
=
memcache.Client([
'192.168.10.128:12000'
], debug
=
True
)
mc.
set
(
"foo"
,
"bar"
)
ret
=
mc.get(
'foo'
)
print
(ret)
#结果：
bar
|
上面例子我们通过调用memcache模块来实现对memcached进行存取数据，debug=True表示运行中出现错误时，显示错误信息，上线后移除该参数。
天生支持集群：
python-memcachd模块原生支持集群操作，其原理是在内存维护一个主机列表，且集群中主机的权重值和主机在列表中重复出现的次数成正比。
|
1
2
3
4
5
6
7
8
|
主机 权重
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'放置在该服务器的内存中。
代码实现如下：
|
1
2
3
|
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'
)
|
add:
添加一条键值对，如果已经存在的key，重复执行add操作会报异常。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
memcache
mc
=
memcache.Client([
'192.168.10.128:12000'
], debug
=
True
)
mc.add(
'k1'
,
'v1'
)
#mc.add('k1','v1') #如果重复添加
#重复添加的结果：
MemCached:
while
expecting
'STORED'
, got unexpected response
'NOT_STORED'
MemCached:
while
expecting
'STORED'
, got unexpected response
'NOT_STORED'
|
replace：
replace修改某个key的值，如果key不存在，则异常。
|
1
2
3
4
5
6
7
8
9
10
11
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
memcache
mc
=
memcache.Client([
'192.168.10.128:12000'
], debug
=
True
)
mc.replace(
'kkkk'
,
'999'
)
#如果memcache中存在kkkk,则替换成功，否则报异常
#结果：
MemCached:
while
expecting
'STORED'
, got unexpected response
'NOT_STORED'
|
set和set_multi：
-
set ：设置一个键值对，如果key不存在，则创建，如果key存在，则修改；
-
set_multi：设置多个键值对，如果key不存在，则创建，如果key存在，则修改。
|
1
2
3
4
5
6
7
8
9
10
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
memcache
mc
=
memcache.Client([
'192.168.10.128:12000'
], debug
=
True
)
mc.
set
(
'key0'
,
'jack'
)
mc.set_multi({
'key1'
:
'val1'
,
'key2'
:
'val2'
})
|
delete和delete_multi：
-
delete：在Memcached中删除指定的一个键值对；
-
delete_multi：在Memcached中删除指定的多个键值对。
|
1
2
3
4
5
6
7
8
9
10
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
memcache
mc
=
memcache.Client([
'192.168.10.128:12000'
], debug
=
True
)
mc.delete(
'key0'
)
mc.delete_multi([
'key1'
,
'key2'
])
|
get和get_multi：
-
get : 获取一个键值对；
-
get_multi：获取多个键值对。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
memcache
mc
=
memcache.Client([
'192.168.10.128:12000'
], debug
=
True
)
val
=
mc.get(
'key0'
)
print
(val)
item_dict
=
mc.get_multi([
'key1'
,
'key2'
])
print
(item_dict)
#结果：
jack
{
'key1'
:
'val1'
,
'key2'
:
'val2'
}
|
append和prepend：
-
append：修改指定key的值，在该值后面追加内容；
-
prepend：修改指定key的值，在该值前面插入内容。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
memcache
mc
=
memcache.Client([
'192.168.10.128:12000'
], debug
=
True
)
mc.append(
'k1'
,
'after'
)
val1
=
mc.get(
'k1'
)
print
(val1)
mc.prepend(
'k1'
,
'brefore'
)
val2
=
mc.get(
'k1'
)
print
(val2)
#结果：
v1afterafter
breforev1afterafter
|
decr和incr：
-
incr：自增，将Memcached中的某一个值增加N（N默认为1）；
-
decr：自减，将Memcached中的某一个值减少N（N默认为1）。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
memcache
mc
=
memcache.Client([
'192.168.10.128:12000'
], debug
=
True
)
mc.
set
(
'k1'
,
'777'
)
#mc.incr('k1') #778，默认自增1
mc.incr(
'k1'
,
10
)
val1
=
mc.get(
'k1'
)
print
(val1)
mc.decr(
'k1'
,
20
)
val2
=
mc.get(
'k1'
)
print
(val2)
#结果
787
#自增后的结果
767
#自减后的结果
|
gets和cas：
如商城商品剩余个数，假设改值保存在memcache中，product_count =9000
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即可，如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#Author:HaiFeng Di
import
memcache
mc
=
memcache.Client([
'192.168.10.128:12000'
], debug
=
True
)
v
=
mc.gets(
'product_count'
)
print
(v)
#如果有人在gets之后和cas之前修改了product_count,那么下面的设置将会执行失败，抛出异常，从而避免非正常数据的产出
v1
=
mc.cas(
'product_count'
,
"899"
)
print
(v1)
#结果：
899
True
|
本质上每次执行gets时，会从memcache中获取一个自增的数字，通过cas去修改gets的值时，会携带之前获取的自增值和memcache中的自增值进行比较，如果相等，则可以提交，如果不相等，那表示在gets和cas执行之间，又有其他人执行了gets(获取了缓冲的指定值)，如此一来有可能出现非正常数据，则不允许修改。
在现在Nosql数据库中，有mongodb、redis、memcache，有很多人就有疑惑了，memcache是不是已经过时了，我们通过一篇文章介绍给大家memcache是不是过时了，http://www.oschina.net/news/26691/memcached-timeout
二、Redis操作
redis是一个key-value存储系统。和memcache类似，它支持的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sortd set --有序集合)和hash(哈希类型)。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持不同方式的排序。与memcache一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改写入追加的记录文件，并且在此基础上实现了master-salve(主从)同步。
1，Redis安装和基本使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
wget http:
/
/
download.redis.io
/
releases
/
redis
-
3.0
.
6.tar
.gz
tar
-
zxf redis
-
3.0
.
6.tar
.gz
make
#编译安装完成后，启动后台进程
src
/
redis
-
server &
redis
-
cli
#进入客户端，进行操作
127.0
.
0.1
:
6379
>
set
foo bar
OK
127.0
.
0.1
:
6379
> get foo
"bar"
127.0
.
0.1
:
6379
>
|
2，Python操作Redis
|
1
2
3
4
5
6
7
8
9
|
sudo pip install redis
or
sudo easy_install redis
or
源码安装
windows下安装：python3
-
m pip install redis
详见：https:
/
/
github.com
/
WoLpH
/
redis
-
py
|
API使用：
redis-py的API的使用可以分类为：
-
连接方式
-
连接池
-
操作
String操作
Hash操作
List操作
Set操作
Sort Set 操作
-
管道
-
发布订阅
操作模式：
redis-py提供两个类Redis和StrictRedis用于实现Redis的命令，StrictRedis用于实现大部分官方的命令，并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
redis
r
=
redis.Redis(host
=
'192.168.10.128'
,port
=
6379
)
r.
set
(
'foo'
,
'Bar'
)
print
(r.get(
'foo'
))
#结果：
b
'Bar'
#取出来时二进制格式
|
连接池：
redis-py使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
redis
pool
=
redis.ConnectionPool(host
=
'192.168.10.128'
,port
=
6379
)
r
=
redis.Redis(connection_pool
=
pool)
r.
set
(
'foo'
,
'Bar'
)
print
(r.get(
'foo'
))
#结果：
b
'Bar'
|
操作：
1，String操作
redis中的String在内存中按照一个name对应一哥value来存储。如下图：
set（name,value,ex=None,px=None,nx=False,xx=False）
|
1
2
3
4
5
6
|
在Redis中设置值，默认，不存在则创建，存在则修改。
参数：
ex：过期时间(秒)
px：过期时间(毫秒)
nx：如果设置为
True
，则只有naem不存在时，当前
set
操作才执行
xx：如果设置为
True
，则只有name存在时，当前
set
操作才执行
|
setnx(name,value)
|
1
|
设置值，只有name不存在时，执行设置操作(添加)
|
setex(name,value,time)
|
1
2
3
|
#设置值
#参数：
#time，过期时间(数字秒，或者timedelta对象)
|
psetex(name,time_ms,value)
|
1
2
3
|
# 设置值
# 参数：
# time_ms，过期时间（数字毫秒 或 timedelta对象）
|
mset(*args,**kwargs)
|
1
2
3
4
5
|
#批量设置值
#如：
mset(k1
=
'v1'
,k2
=
'v2'
)
或
mset({
'k1'
:
'v1'
,
'k2'
:
'v2'
})
|
get(name)
|
1
|
获取值
|
mget(keys,*args)
|
1
2
3
4
5
|
#批量获取
#例：
mget(
'k1'
,
'k2'
)
或
mget([
'k1'
,
'k2'
])
|
getset(name,value)
|
1
|
#设置新值并获取原来的值
|
getrange(key,start,end)
|
1
2
3
4
5
6
|
#获取子序列(根据字节获取，非字符)
#参数：
key：Redis的key值
start：起始位置(字节)
end：结束位置(字节)
#如：'赵日天'，0-3表示‘赵’
|
setrange(name,offset,value)
|
1
2
3
4
|
#修改字符串内容，从指定字符串索引开始向后替换(新值太长时,则向后添加)
#参数：
offset：字符串的索引，字节(一个汉字三个字节)
value：要设置的值
|
setbit(name,offset,value)
|
1
2
3
4
5
6
7
8
9
10
|
#对name对应值的二进制表示的位进行操作
#参数：
name：redis的name
offset：位的索引(将值变成二进制后再进行索引)
value：值只能是
1
或
0
#如果在Redis中有一个对应：k1 ='foo'
那么字符串foo的二进制表示为：
01100110
01101111
01101111
如果执行 setbit(
'n1'
,
7
,
1
)，则就会将第
7
位设置为
1
，
那么最终二进制则变成
01100111
01101111
01101111
，即：
"goo"
|
getbit(name,offset)
|
1
|
获取name对应的二进制表示中的指定位的值(
0
或
1
)
|
bitcount(key,start=None,end=None)
|
1
2
3
4
5
|
#获取name对应的值的二进制表示中1的参数
#参数：
# key，Redis的name
# start，位起始位置
# end，位结束位置
|
bittop(operation,dest,*keys)
|
1
2
3
4
5
6
7
8
9
10
|
# 获取多个值，并将值做位运算，将最后的结果保存至新的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)
|
1
|
#返回name对应值的字节长度(一个汉字3个字节)
|
incr（self,name,amount=1）
|
1
2
3
4
5
6
7
|
#自增，name对应的值，当name不存在时，则创建name= amount，否则，则自增。
#参数：
# name,Redis的name
# amount,自增数（必须是整数）
# 注：同incrby
|
incrbyfloat(self,name,amount=1.0)
|
1
|
#跟上面的用法一样，这里的amount，自增数为浮点型
|
decr(self,name,amount=1)
|
1
2
3
4
5
|
#自减，name对应的值，当name不存在时，则创建name＝amount，否则，则自减。
# 参数：
# name,Redis的name
# amount,自减数（整数）
|
append(key,value)
|
1
2
3
4
5
|
#在redis name对应的值后面追加内容
#参数：
key：redis的name
value：要追加的字符串
|
2，Hash操作
hash操作，redis中Hash在内存中的存储格式如下图：
hset(name,key,value)
|
1
2
3
4
5
6
7
|
#name对应的hash中设置一个键值对(不存在，则创建；否则，修改)
#参数：
#name:redis的name
#key:name对应的hash中的key
#value:name对应的hash中的value
#注：hsetx(name,key,value),当name对应的hash中不存在当前key则创建(相当于添加)
|
hmset(name,mapping)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
#在name对应的hash中批量设置键值对
#参数：
#name：redis的name
#mapping：字典，如{'k1':'v1','k2','v2'}
#例：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
redis
pool
=
redis.ConnectionPool(host
=
'192.168.10.128'
,port
=
6379
)
r
=
redis.Redis(connection_pool
=
pool)
r.hmset(
'test'
,{
'k1'
:
'v1'
,
'k2'
:
'v2'
})
print
(r.hmget(
'test'
,
'k1'
,
'k2'
))
#结果
[b
'v1'
, b
'v2'
]
|
hget(name,key)
|
1
|
#在name对应的hash中获取根据key获取value
|
hmget(name,keys,*args)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
#在name对应的hash中获取多个key的值
#参数：
#name：redis对应的name
#keys：要获取key的集合，如：['k1','k2','k3']
#*args：要获取的key,如：k1,k2,k3
#例：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
redis
pool
=
redis.ConnectionPool(host
=
'192.168.10.128'
,port
=
6379
)
r
=
redis.Redis(connection_pool
=
pool)
r.hmset(
'test'
,{
'k1'
:
'v1'
,
'k2'
:
'v2'
})
print
(r.hmget(
'test'
,
'k1'
,
'k2'
))
#获取多个值
|
hgetall(name)：获取name对应hash的所有键值
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
redis
pool
=
redis.ConnectionPool(host
=
'192.168.10.128'
,port
=
6379
)
r
=
redis.Redis(connection_pool
=
pool)
r.hmset(
'test'
,{
'k1'
:
'v1'
,
'k2'
:
'v2'
})
print
(r.hgetall(
'test'
))
#结果：
{b
'k2'
: b
'v2'
, b
'k1'
: b
'v1'
}
|
hlen(name)：获取name对应的hash中键值的个数
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
redis
pool
=
redis.ConnectionPool(host
=
'192.168.10.128'
,port
=
6379
)
r
=
redis.Redis(connection_pool
=
pool)
r.hmset(
'test'
,{
'k1'
:
'v1'
,
'k2'
:
'v2'
})
print
(r.hlen(
'test'
))
#结果：
2
|
hkeys(name)：获取name对应的hash中所有的key的值
hvals(name)：获取name对应的hash中所有的value的值
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
redis
pool
=
redis.ConnectionPool(host
=
'192.168.10.128'
,port
=
6379
)
r
=
redis.Redis(connection_pool
=
pool)
r.hmset(
'test'
,{
'k1'
:
'v1'
,
'k2'
:
'v2'
})
print
(r.hkeys(
'test'
))
print
(r.hvals(
'test'
))
#结果：
[b
'k2'
, b
'k1'
]
[b
'v2'
, b
'v1'
]
|
hexists(name,key)：检查name对应的hash是否存在当前传入的key
hdel(name,*keys)：将name对应的hash中指定key的键值对删除
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
redis
pool
=
redis.ConnectionPool(host
=
'192.168.10.128'
,port
=
6379
)
r
=
redis.Redis(connection_pool
=
pool)
r.hmset(
'test'
,{
'k1'
:
'v1'
,
'k2'
:
'v2'
})
print
(r.exists(
'test'
))
print
(r.hdel(
'test'
,
'k1'
))
print
(r.hmget(
'test'
,
'k1'
,
'k2'
))
#结果：
True
1
[
None
, b
'v2'
]
|
hincrbyfloat(name,key,amount=1.0)
|
1
2
3
4
5
6
7
8
|
# 自增name对应的hash中的指定key的值，不存在则创建key=amount
# 参数：
# name，redis中的name
# key， hash对应的key
# amount，自增数（浮点数）
# 自增name对应的hash中的指定key的值，不存在则创建key=amount
|
hscan(name,cursor=0,match=None,count=None)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
# 增量式迭代获取，对于数据大的数据非常有用，hscan可以实现分片的获取数据，并非一次性将数据全部获取完，从而放置内存被撑爆
# 参数：
# name，redis的name
# cursor，游标（基于游标分批取获取数据）
# match，匹配指定key，默认None 表示所有的key
# count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
# 如：
# 第一次：cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None)
# 第二次：cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None)
# ...
# 直到返回值cursor的值为0时，表示数据已经通过分片获取完毕
|
hscan_iter(name,match=None,count=None)：利用yield封装hscan创建生成器，实现分批去redis中获取数据
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
# 参数：
# match，匹配指定key，默认None 表示所有的key
# count，每次分片最少获取个数，默认None表示采用Redis的默认分片个数
#例：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
redis
pool
=
redis.ConnectionPool(host
=
'192.168.10.128'
,port
=
6379
)
r
=
redis.Redis(connection_pool
=
pool)
r.hmset(
'test'
,{
'k1'
:
'v1'
,
'k2'
:
'v2'
})
for
item
in
r.hscan_iter(
'test'
):
print
(item)
#结果：
(b
'k1'
, b
'v1'
)
(b
'k2'
, b
'v2'
)
|
3，List操作
redis中的List在内存中按照一个name对应一个List来存储，如下图：
lpush(name,values)：在name对应的list中添加元素，每个新的的元素都添加到列表的最左边
|
1
2
3
4
5
|
#如：
r.lpush(
'mylist'
,
11
,
22
,
33
)
#保存顺序为：33,22,11
#扩展：
rpush(name,values)
#表示从右向左操作
|
lpushx(name,value)：在name对应的list中添加元素，只有name存在时，值添加到列表的最左边
llen(name)：name对应的list元素的个数
linsert(name,where,refvalue,value)：在name对应的列表的某一个值前后插入一个新值
|
1
2
3
4
5
|
#参数：
# name，redis的name
# where，BEFORE或AFTER
# refvalue，标杆值，即：在它前后插入数据
# value，要插入的数据
|
r.lset(name,index,value)：对name对应的list中的某一个索引位置重新赋值。
|
1
2
3
4
|
# 参数：
# name，redis的name
# index，list的索引位置
# value，要设置的值
|
r.lrem(name,value,num):在name对应的list中删除指定的值
|
1
2
3
4
5
6
|
# 参数：
# name，redis的name
# value，要删除的值
# num， num=0，删除列表中所有的指定值；
# num=2,从前到后，删除2个；
# num=-2,从后向前，删除2个
|
lpop(name)：在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
|
1
|
#扩展： rpop(name) 表示从右向左操作
|
lindex(name,index)：在name对应的列表中根据索引取列表元素
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
redis
pool
=
redis.ConnectionPool(host
=
'192.168.10.128'
,port
=
6379
)
r
=
redis.Redis(connection_pool
=
pool)
r.lpush(
'mylist'
,
11
,
22
,
33
)
print
(r.lindex(
'mylist'
,
0
))
#结果：
b
'33'
|
lrange(name,start,end)：在name对应的列表分片获取数据
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
redis
pool
=
redis.ConnectionPool(host
=
'192.168.10.128'
,port
=
6379
)
r
=
redis.Redis(connection_pool
=
pool)
r.lpush(
'mylist'
,
11
,
22
,
33
)
print
(r.lrange(
'mylist'
,
0
,
1
))
#结果：
[b
'33'
, b
'22'
]
|
ltrim(name,start,end)：在name对应列表中移除没有在start-end索引之间的值
|
1
2
3
4
|
# 参数：
# name，redis的name
# start，索引的起始位置
# end，索引结束位置
|
rpoplpush(src,dst)：从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
# 参数：
# src，要取数据的列表的name
# dst，要添加数据的列表的name
#例：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
redis
pool
=
redis.ConnectionPool(host
=
'192.168.10.128'
,port
=
6379
)
r
=
redis.Redis(connection_pool
=
pool)
r.lpush(
'mylist'
,
11
,
22
,
33
)
print
(r.rpoplpush(
'mylist'
,
'testlist'
))
|
blpop(keys,timeout)：将多个列表排列，按照从左到右去pop对应列表的元素
|
1
2
3
4
5
6
|
# 参数：
# keys，redis的name的集合
# timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
# 扩展：
# r.brpop(keys, timeout)，从右向左获取数据
|
brpoplpush(src,dst,timeout=0)：从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
|
1
2
3
4
|
# 参数：
# src，取出并要移除元素的列表对应的name
# dst，要插入元素的列表对应的name
# timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
|
自定义增量迭代：
由于redis类库没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：
-
获取name对应的所有列表
-
循环列表
但是，如果列表非常大，那么就有可能在第一步时将程序的内存撑爆，所有有必要自定义一个增量迭代的功能。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
import
redis
r
=
redis.Redis(host
=
'192.168.10.128'
, port
=
6379
)
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(
'pp'
):
print
(item)
|
4，Set操作，set集合就是不允许重复的列表
-
sadd(name,values)：name对应的集合中添加元素
-
scard(name)：获取name对应的集合中元素个数
-
sdiff(keys,*args)：在第一个name对应的集合中，且不在其他name对应的集合的元素集合
-
sdiffstore(dest,keys,*args)：获取第一个name对应集合，且不在其他name对应的集合，再将其新加入到redis对应的集合中
-
sinter(keys,*args)：获取多一个name对应集合的并集
-
sismember(name,value)：检查value是否是name对应的集合的成员
-
smembers(name)：获取name对应的集合的所有成员
-
smove(src,dst,value)：将某个成语从一个集合中移动到另一个集合中
-
spop(name)：从集合的右侧(尾部)移除一个成员，并将其放回
-
srandmember(name,numbers)：从name对应的集合中随机获取numbers个元素
-
serm(keys,*args)：在name对应的集合中删除某些值
-
sunion(dest,keys,*atgs)：获取多一个name对应的集合的并集
-
sunionstore(dest,keys,*args)：获取多个name对应的集合的并集，并将结果保存到dest对应的集合中
-
sscan(name,cursor=0,match=None,count=None)
sscan_iter(name,match=None,count=None) ：同字符串的操作，用于增量迭代分批获取元素，避免内存消耗太大
5，有序集合
在集合的基础上，为每个元素排序，元素的排序需要根据另外一个值进行比较，所以对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序
-
r.zadd(name,*args,**keargs)：在name对应的有序集合中添加元素
|
1
2
3
4
|
# 如：
# zadd('zz', 'n1', 1, 'n2', 2)
# 或
# zadd('zz', n1=11, n2=22)
|
-
r.zcard(name)：获取name对应的有序集合元素的数量
-
r.zcount(name,min,max)：获取name对应的有序集合中分数，在[min,max]之间的个数
-
r.zincrby(name,value,amount)：自增name对应的有序集合的name对应的分数
-
r.zrange(name,start,end,desc=False,withscores=False,score_cast_func=float):按照索引范围获取name对应的有序集合的元素
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
# 参数：
# 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)
|
-
zrank(name,value)：获取某个值在name对应的有序集合中的排行(从0开始)
|
1
|
#扩展：zrevrank(name,value) #从大到小排序
|
-
zrangebylex(name,min,max,start=None,num=None)
当有序集合的所有成员都具有相同的分值时，有序集合的元素会根据成员的值(lexicographical ordering来进行排序，而这个命令则可以返回给指定的有序集合键key中，元素的值介于min和max之间的成员。
对集合中的每个成员进行逐个字节的对比(byte-by-byte compare),并按照从低到高的顺序，返回排序后的集合成员。如果两个字符串有一部分内容时相同的话，那么这个命令会认为较长的字符串比较短的字符串要大。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
# 参数：
# 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的成员
-
zremrangebyrank(name, min, max)：根据排行范围删除
-
zremrangebyscore(name, min, max)：根据分数范围删除
-
zremrangebylex(name, min, max)：根据值返回删除
-
zsore(name,value)：获取name对应有序集合中value对应的分数
-
zinterstore(dest, keys, aggregate=None)：获取两个有序集合的交集，如果遇到相同值不同分数，则按照aggregate进行操作(aggregate:SUM,MIN,MAX)
-
zunionstore(dest, keys, aggregate=None)：获取两个有序集合的并集，如果遇到相同值不同分数，则按照aggregate进行操作
-
zscan(name, cursor=0, match=None, count=None, score_cast_func=float)
zscan_iter(name, match=None, count=None,score_cast_func=float)：同字符串相似，相较于字符串新增score_csat_func,用来对分数进行操作
6，其他常用操作
-
delete(*names)：删除redis中的任意数据类型
-
exists(name)：检测redis的name是否存在
-
keys(pattern='*')：根据模型获取redis的name
|
1
2
3
4
5
|
# 扩展：
# 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
7,管道
redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import
redis
pool
=
redis.ConnectionPool(host
=
'192.168.10.128'
,port
=
6379
)
r
=
redis.Redis(connection_pool
=
pool)
# pipe = r.pipeline(transaction=False)
pipe
=
r.pipeline(transaction
=
True
)
r.
set
(
'name'
,
'alex'
)
r.
set
(
'role'
,
'sb'
)
pipe.execute()
|
8，发布订阅
发布者：服务器
订阅者：Dashboad和数据处理
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import
redis
class
RedisHelper:
def
__init__(
self
):
self
.__conn
=
redis.Redis(host
=
'192.168.10.128'
)
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
|
订阅者：
|
1
2
3
4
5
6
7
8
|
from
monitor.RedisHelper
import
RedisHelper
obj
=
RedisHelper()
redis_sub
=
obj.subscribe()
while
True
:
msg
=
redis_sub.parse_response()
print
(msg)
|
发布者：
|
1
2
3
4
5
6
7
|
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from
monitor.RedisHelper
import
RedisHelper
obj
=
RedisHelper()
obj.public(
'hello'
)
|
更多redis的操作，请参考下面链接：
三、Python上下文管理
上下文管理器(context manager)是Python2.5以后开始支持的一种语法，用于规定某个对象的使用范围。通常我们使用contextlib模块配合with....as.....语法使用，contextlib模块的作用是提供更易用的上下文管理器，它是通过Generator实现的。contextlib中的contextmanager作为装饰器来提供一种针对函数级别的上下文管理机制。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
import
contextlib
@contextlib
.contextmanager
def
worker_state(state_list,wotker_thread):
"""
用于记录线程中正在等待的线程数
:param state_list:
:param wotker_thread:
:return:
"""
state_list.append(worker_state)
try
:
yield
#执行到yield会返回到with函数
finally
:
state_list.remove(worker_state)
free_list
=
[]
current_thread
=
'jack'
with worker_state(free_list,current_thread):
#会调用上面的worker_state函数
print
(
123
)
print
(
456
)
#结果：
123
456
|
上面是个简单的上下文管理的例子，下面我们通过上下文管理来实现自动关闭socket连接，请看下面例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import
contextlib
import
socket
@contextlib
.contextmanager
def
context_socket(host,port):
#执行顺序(2),执行此函数
sk
=
socket.socket()
sk.bind((host,port))
sk.listen(
5
)
try
:
yield
sk
#执行顺序(3),yield后面参数是将函数的返回值返回with的sock
finally
:
sk.close()
#执行顺序(5)，关闭socket连接
with context_socket(
'127.0.0.1'
,
8888
) as sock:
#执行顺序(1),调用上函数
print
(sock)
#执行顺序(4)
#结果：
<socket.socket fd
=
100
, family
=
AddressFamily.AF_INET,
type
=
SocketKind.SOCK_STREAM, proto
=
0
, laddr
=
(
'127.0.0.1'
,
8888
)>
|
其中，yield写入try-finally中是为了保证异常安全（能处理异常）as后的变量的值是由yield返回。yield前面的语句可看作代码块执行前操作，yield之后的操作可以看作在__exit__函数中的操作。
扫一扫
1503
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
