pythonredis连接

Ⅰ python怎么将数据写入到redis

代码如下:
import redis

class Database:
def __init__(self):
self.host = 'localhost'
self.port = 6379

def write(self,website,city,year,month,day,deal_number):
try:
key = '_'.join([website,city,str(year),str(month),str(day)])
val = deal_number
r = redis.StrictRedis(host=self.host,port=self.port)
r.set(key,val)
except Exception, exception:
print exception

def read(self,website,city,year,month,day):
try:
key = '_'.join([website,city,str(year),str(month),str(day)])
r = redis.StrictRedis(host=self.host,port=self.port)
value = r.get(key)
print value
return value
except Exception, exception:
print exception

if __name__ == '__main__':
db = Database()
db.write('meituan','beijing',2013,9,1,8000)
db.read('meituan','beijing',2013,9,1)

Ⅱ python 虚拟环境里怎么启动redis

运行
打开Python解释器：
>>> import redis
>>> r = redis.Redis(host='localhost', port=6379, db=0) #如果设置了密码，就加上password=密码
>>> r.set('foo', 'bar') #或者写成 r['foo'] = 'bar'
True
>>> r.get('foo')
'bar'
>>> r.delete('foo')
True
>>> r.dbsize() #库里有多少key，多少条数据
0
>>> r['test']='OK!'

Ⅲ python怎么测试与redis的连接

Redis服务端：192.168.100.132；port=6379
Redis客户端：192.168.100.132
客户端操作：
安装python支持redis;
tar zxvf redis-2.9.1.tar.gz
cd redis-2.9.1
python setup.py install
服务端启动redis
/root/redis-2.2.12/src/redis-server
客户端测试：
[root@master ~]# python
>>> import redis
>>> r = redis.Redis(host='192.168.100.132',port=6379,db=0) //#如果设置了密码，就加上password=密码
>>> r.set('name','lansgg')
True
>>> r.get('name')
'lansgg'
>>> r.exists('name') //#看是否存在这个键值
True
>>> r.delete('name')
1
>>> r.dbsize() //#库里有多少key，多少条数据
0L
>>> r.set('name','lansgg')
True
>>> r.flushdb() // #删除当前数据库的所有数据
True
>>> r.get('name')
>>> r.set('name','lansgg')
True
>>> r.set('wm','leo')
True
>>> r.set('tt','coffee')
True
>>> r.keys() // # 列出所有键值。
['tt', 'wm', 'name']
>>> r.save() // #强行把数据库保存到硬盘。保存时阻塞
True
>>> r.dbsize()
3L
>>> dir(r)
['RESPONSE_CALLBACKS', '__class__', '__contains__', '__delattr__', '__delitem__', '__dict__', '__doc__', '__format__', '__getattribute__', '__getitem__', '__hash__', '__init__', '__mole__', '__new__', '__rece__', '__rece_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_zaggregate', 'append', 'bgrewriteaof', 'bgsave', 'bitcount', 'bitop', 'blpop', 'brpop', 'brpoplpush', 'client_getname', 'client_kill', 'client_list', 'client_setname', 'config_get', 'config_resetstat', 'config_set', 'connection_pool', 'dbsize', 'debug_object', 'decr', 'delete', 'mp', 'echo', 'eval', 'evalsha', 'execute_command', 'exists', 'expire', 'expireat', 'flushall', 'flushdb', 'from_url', 'get', 'getbit', 'getrange', 'getset', 'hdel', 'hexists', 'hget', 'hgetall', 'hincrby', 'hincrbyfloat', 'hkeys', 'hlen', 'hmget', 'hmset', 'hscan', 'hset', 'hsetnx', 'hvals', 'incr', 'incrby', 'incrbyfloat', 'info', 'keys', 'lastsave', 'lindex', 'linsert', 'llen', 'lock', 'lpop', 'lpush', 'lpushx', 'lrange', 'lrem', 'lset', 'ltrim', 'mget', 'move', 'mset', 'msetnx', 'object', 'parse_response', 'persist', 'pexpire', 'pexpireat', 'ping', 'pipeline', 'psetex', 'pttl', 'publish', 'pubsub', 'randomkey', 'register_script', 'rename', 'renamenx', 'response_callbacks', 'restore', 'rpop', 'rpoplpush', 'rpush', 'rpushx', 'sadd', 'save', 'scan', 'scard', 'script_exists', 'script_flush', 'script_kill', 'script_load', 'sdiff', 'sdiffstore', 'sentinel', 'sentinel_get_master_addr_by_name', 'sentinel_masters', 'sentinel_sentinels', 'sentinel_slaves', 'set', 'set_response_callback', 'setbit', 'setex', 'setnx', 'setrange', 'shutdown', 'sinter', 'sinterstore', 'sismember', 'slaveof', 'smembers', 'smove', 'sort', 'spop', 'srandmember', 'srem', 'sscan', 'strlen', 'substr', 'sunion', 'sunionstore', 'time', 'transaction', 'ttl', 'type', 'unwatch', 'watch', 'zadd', 'zcard', 'zcount', 'zincrby', 'zinterstore', 'zrange', 'zrangebyscore', 'zrank', 'zrem', 'zremrangebyrank', 'zremrangebyscore', 'zrevrange', 'zrevrangebyscore', 'zrevrank', 'zscan', 'zscore', 'zunionstore']
这只是一个简单的测试，为了测试redis是否正常工作，我们安装是否正确；

Ⅳ python-redis链接redis怎么认证

利用r=reids.Redis(host='localhost', port=6379,db=0)也可以。
区别：Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。

Ⅳ 如何在linux上为Python语言安装Redis客户端

（1）下载好之后，使用命令进行解压：

（2）使用命令python ez_setup.py进行运行：

（3）使用命令python -m easy_install redis hiredis 来安装redis包以及hireredis包：

由上图可看出在安装过程中出问题了，最终找到原因才是因为Linux上的Python版本（2.7）太低！！！所以我们接下来升级Python的版本：

a）首先还是在Python的官网上下载安装包，下面给出下载的地址：

https://www.python.org/downloads/source/

我选择的版本是Python-3.1.2版本，其他的版本也是可以，但至少要比2.7版本要高：

b）解压安装包：

d）在/usr/local下创建目录python3，用于安装python的路径，以免覆盖老的版本：

e）开始编译安装：
./configure --prefix = /usr/local/python3

make && make install

f）编译安装完成之后，此时没有覆盖原来的版本，再将原来/usr/bin/python链接改为别的名字：

mv /usr/bin/python /usr/bin/python_old

g）再建立新版本python的链接：

ln -s
/usr/local/python3/bin/python3
/usr/bin/python

至此python的安装已经完成！！！！

PS：如果不建立新安装路径python3，而是直接默认安装，则安装后的新python应该会覆盖linux下自带的老版本，也有可能不覆盖，具体看安装过程了，这个大家可以自己试验下，当然如果还想保留原来的版本，那么这种方法最好不过了。

以上则就是python的新版本！！！！

然后再使用刚开始的命令：

（4）

（5）

至此我们已经完成了在Linux上为Python语言安装Redis客户端！！！！接下来我们进行验证：

（6）首先开启redis服务：

（7）查看服务器开启端口：

（8）开启redis客户端连接服务器：

(9)下面我们使用python来测试redis，首先启动python：

（10）导入redis客户端：

（11）创建redis连接，并设置一个值，然后通过获取返回值来判断设置操作是否执行成功

Ⅵ python redis连接 线程安全么

在ConnectionPool之前，如果需要连接redis，我都是用StrictRedis这个类，在源码中可以看到这个类的具体解释：

redis.StrictRedis Implementation of the Redis protocol.This abstract class provides a Python interface to all Redis commands and an
implementation of the Redis protocol.Connection and Pipeline derive from this, implementing how the commands are sent and received to the Redis server
使用的方法：

?

1
2

r=redis.StrictRedis(host=xxxx, port=xxxx, db=xxxx)
r.xxxx()

有了ConnectionPool这个类之后，可以使用如下方法

?

1
2

pool = redis.ConnectionPool(host=xxx, port=xxx, db=xxxx)
r = redis.Redis(connection_pool=pool)

这里Redis是StrictRedis的子类
简单分析如下：
在StrictRedis类的__init__方法中，可以初始化connection_pool这个参数，其对应的是一个ConnectionPool的对象：

?

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

class StrictRedis(object):
........
def __init__(self, host='localhost', port=6379,
db=0, password=None, socket_timeout=None,
socket_connect_timeout=None,
socket_keepalive=None, socket_keepalive_options=None,
connection_pool=None, unix_socket_path=None,
encoding='utf-8', encoding_errors='strict',
charset=None, errors=None,
decode_responses=False, retry_on_timeout=False,
ssl=False, ssl_keyfile=None, ssl_certfile=None,
ssl_cert_reqs=None, ssl_ca_certs=None):
if not connection_pool:
..........
connection_pool = ConnectionPool(**kwargs)
self.connection_pool = connection_pool

在StrictRedis的实例执行具体的命令时会调用execute_command方法，这里可以看到具体实现是从连接池中获取一个具体的连接，然后执行命令，完成后释放连接：

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# COMMAND EXECUTION AND PROTOCOL PARSING
def execute_command(self, *args, **options):
"Execute a command and return a parsed response"
pool = self.connection_pool
command_name = args[0]
connection = pool.get_connection(command_name, **options) #调用ConnectionPool.get_connection方法获取一个连接
try:
connection.send_command(*args) #命令执行，这里为Connection.send_command
return self.parse_response(connection, command_name, **options)
except (ConnectionError, TimeoutError) as e:
connection.disconnect()
if not connection.retry_on_timeout and isinstance(e, TimeoutError):
raise
connection.send_command(*args)
return self.parse_response(connection, command_name, **options)
finally:
pool.release(connection) #调用ConnectionPool.release释放连接

在来看看ConnectionPool类：
?

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class ConnectionPool(object):
...........
def __init__(self, connection_class=Connection, max_connections=None,
**connection_kwargs): #类初始化时调用构造函数
max_connections = max_connections or 2 ** 31
if not isinstance(max_connections, (int, long)) or max_connections < 0: #判断输入的max_connections是否合法
raise ValueError('"max_connections" must be a positive integer')
self.connection_class = connection_class #设置对应的参数
self.connection_kwargs = connection_kwargs
self.max_connections = max_connections
self.reset() #初始化ConnectionPool 时的reset操作
def reset(self):
self.pid = os.getpid()
self._created_connections = 0 #已经创建的连接的计数器
self._available_connections = [] #声明一个空的数组，用来存放可用的连接
self._in_use_connections = set() #声明一个空的集合，用来存放已经在用的连接
self._check_lock = threading.Lock()
.......
def get_connection(self, command_name, *keys, **options): #在连接池中获取连接的方法
"Get a connection from the pool"
self._checkpid()
try:
connection = self._available_connections.pop() #获取并删除代表连接的元素，在第一次获取connectiong时，因为_available_connections是一个空的数组，
会直接调用make_connection方法
except IndexError:
connection = self.make_connection()
self._in_use_connections.add(connection) #向代表正在使用的连接的集合中添加元素
return connection
def make_connection(self): #在_available_connections数组为空时获取连接调用的方法
"Create a new connection"
if self._created_connections >= self.max_connections: #判断创建的连接是否已经达到最大限制，max_connections可以通过参数初始化
raise ConnectionError("Too many connections")
self._created_connections += 1 #把代表已经创建的连接的数值+1
return self.connection_class(**self.connection_kwargs) #返回有效的连接，默认为Connection(**self.connection_kwargs)
def release(self, connection): #释放连接，链接并没有断开，只是存在链接池中
"Releases the connection back to the pool"
self._checkpid()
if connection.pid != self.pid:
return
self._in_use_connections.remove(connection) #从集合中删除元素
self._available_connections.append(connection) #并添加到_available_connections 的数组中
def disconnect(self): #断开所有连接池中的链接
"Disconnects all connections in the pool"
all_conns = chain(self._available_connections,
self._in_use_connections)
for connection in all_conns:
connection.disconnect()

execute_command最终调用的是Connection.send_command方法，关闭链接为 Connection.disconnect方法，而Connection类的实现：

?

1
2
3
4
5
6
7

class Connection(object):
"Manages TCP communication to and from a Redis server"
def __del__(self): #对象删除时的操作，调用disconnect释放连接
try:
self.disconnect()
except Exception:
pass

核心的链接建立方法是通过socket模块实现：

?

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
26
27

def _connect(self):
err = None
for res in socket.getaddrinfo(self.host, self.port, 0,
socket.SOCK_STREAM):
family, socktype, proto, canonname, socket_address = res
sock = None
try:
sock = socket.socket(family, socktype, proto)
# TCP_NODELAY
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
# TCP_KEEPALIVE
if self.socket_keepalive: #构造函数中默认 socket_keepalive=False，因此这里默认为短连接
sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
for k, v in iteritems(self.socket_keepalive_options):
sock.setsockopt(socket.SOL_TCP, k, v)
# set the socket_connect_timeout before we connect
sock.settimeout(self.socket_connect_timeout) #构造函数中默认socket_connect_timeout=None，即连接为blocking的模式
# connect
sock.connect(socket_address)
# set the socket_timeout now that we're connected
sock.settimeout(self.socket_timeout) #构造函数中默认socket_timeout=None
return sock
except socket.error as _:
err = _
if sock is not None:
sock.close()
.....

关闭链接的方法：

?

1
2
3
4
5
6
7
8
9
10
11

def disconnect(self):
"Disconnects from the Redis server"
self._parser.on_disconnect()
if self._sock is None:
return
try:
self._sock.shutdown(socket.SHUT_RDWR) #先shutdown再close
self._sock.close()
except socket.error:
pass
self._sock = None

可以小结如下
1）默认情况下每创建一个Redis实例都会构造出一个ConnectionPool实例，每一次访问redis都会从这个连接池得到一个连接，操作完成后会把该连接放回连接池（连接并没有释放）,可以构造一个统一的ConnectionPool，在创建Redis实例时，可以将该ConnectionPool传入，那么后续的操作会从给定的ConnectionPool获得连接，不会再重复创建ConnectionPool。
2）默认情况下没有设置keepalive和timeout，建立的连接是blocking模式的短连接。
3）不考虑底层tcp的情况下，连接池中的连接会在ConnectionPool.disconnect中统一销毁。

Ⅶ window系python连接linux服务器上Redis

你来错地方了，去逼乎或者贴吧

Ⅷ python 用redis做什么功能

redis-py提供两个类Redis和StrictRedis用于实现Redis的命令，StrictRedis用于实现大部分官方的命令，
并使用官方的语法和命令，Redis是StrictRedis的子类，用于向后兼容旧版本的redis-py。
import redis 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库
r = redis.Redis(host='192.168.19.130', port=6379) host是redis主机，需要redis服务端和客户端都起着 redis默认端口是6379
r.set('foo', 'Bar') key是"foo" value是"bar" 将键值对存入redis缓存
print r.get('foo') Bar 取出键foo对应的值！

Ⅸ python 的 redis 库，连接池怎么用

连接池的作用是当前连接断掉了自动重连
使用方法 https://github.com/andymccurdy/redis-py#connection-pools
你可以全局都公用一个 redis client

By default, each Redis instance you create will in turn create its own connection pool.
你可以不用自己手动使用连接池

Redis 的连接池是多线程安全的、多进程安全的、自动重连的。

你扔 flask.g 之类的全局的地方当然也行，反正 Redis 总是会使用连接池（不指定它每次就用一个新的）。显式指定连接池的话差异不大，反正你总是要手动在某个全局的地方存一样东西（连接池对象或者 Redis 对象）。

Ⅹ python把字典存到redis怎么使用

python把字典存到redis怎么使用
先写个测试redis是否正常连接上
import redis
cache = redis.StrictRedis('172.20.0.227',6379)

存储字符串
key = "javaman_test"
value = "test_string_yy"
cachevalue = cache.get(key)

存储Dict对象，取出来为字符串
value = {"id":1,"name":"sunxy"}
cache.set(key,value,60)
cachevalue = cache.get(key)
print type(value),type(cachevalue)

这时使用eval()对获取的结果转换成dict
cachevalue = cache.get(key)
trans_value = eval(cachevalue)
print type(trans_value),trans_value.get("name")

如果不是一个dict，直接是一个对象呢？
之前用了django中的对象，来看一下
取出来仍然是字符串，如何把对象存进去呢

eval()只是将结果转换成字典，这个肯定不行，我们应该需要将对象存到redis中。

使用pickle模块，在存入到redis中时调用mps函数，获取后调用loads函数
import pickleredis.set(key,pickle.mps(xt_instry),180)
pickle.loads(result)