Python操作redis、memcache和ORM框架_Day13

一、memcache

Memcached 是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库的次数，从而提高动态、数据库驱动网站的速度。Memcached基于一个存储键/值对的hashmap。其守护进程（daemon ）是用C写的，但是客户端可以用任何语言来编写，并通过memcached协议与守护进程通信。

启动:memcached -d -m 10    -u root -l 10.211.55.4 -p 12000 -c 256 -P /tmp/memcached.pid

参数说明:

    -d 是启动一个守护进程

    -m 是分配给Memcache使用的内存数量，单位是MB

    -u 是运行Memcache的用户

    -l 是监听的服务器IP地址

    -p 是设置Memcache监听的端口,最好是1024以上的端口

    -c 选项是最大运行的并发连接数，默认是1024，按照你服务器的负载量来设定

    -P 是设置保存Memcache的pid文件

memcached命令:

存储命令: set/add/replace/append/prepend/cas

获取命令: get/gets

python操作Memcached

安装python-memcached模块

 import memcache
 
 mc = memcache.Client(['10.211.55.4:12000'], debug=True)
 mc.set("foo", "bar")
 ret = mc.get('foo')
 print (ret)

Memcached天生支持和集群，其原理是在内存维护一个主机列表，且集群中主机的权重值和主机在列表中重复出现的次数成正比。

add 添加一条键值对

replace 修改某个key的值，如果key不存在，则异常

set和set_multi设置一个键值对

delete删除指定的一个键值对

delete_multi删除指定的多个键值对

get 获取一个键值对

get_multi 获取多个键值对

append 修改指定key的值，在该值后面追加内容

prepend 修改指定key的值，在该值前面插入内容

decr 自减，将memcache中的某一个值减少N(默认为1)

incr 自增，将memcache中的某一个值增加N（默认为1）

gets和cas同时出现，相当于事务，防止修改错误。

二、redis基本使用

启动服务

src/redis-server

启动客户端

src/redis-cli

操作模式

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

连接池

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

 import redis
 
 pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
 
 r = redis.Redis(connection_pool=pool)
 r.set('foo', 'Bar')
 print r.get('foo')

操作

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

参数：

ex,过期时间(s)  px,过期时间(ms)

nx,如果设置为True，则只有name不存在时，当前set操作才执行

xx,如果设置为True，则只有name存在时，岗前set操作才执行

 

setnx(name,value) 设置值，只有name不存在时，执行设置操作。

mset(*args,**kwargs) 批量设置

get(name) 获取值

mget(*args,**kwargs) 批量获取

getset(name,value) 设置新值并获取原来的值

getrange(key,start,end)  获取子序列

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

bitcount(key,start=None,end=None)  获取name对应的值的二进制表示中1的个数

strlen(name) 返回name对应值的字节长度（一个汉字三个字节）

incr(self,name,amount=1) 自增name对应的值，当name不存在，创建name=amount，否则自增

decr(self,name,amount=1) 自减name对应的值，当name不存在，创建name=amount，否则自减

append(key,value) 在redis name对应的值后面追加内容

 

hash操作

hset(name,key,value)

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

hmset(name,mapping) 在name对应的hash中批量设置键值对

hget(name,key) 在name对应的hash中根据key获取value

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

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

 

list操作

一个name对应一个list

Ipush(name,values)  在name对应的list中添加元素，每个新的元素都添加到列表的最左边

rpush(name,values)表示从右向左操作

llen(name) name对应的list元素的个数

linsert(name,where,refvalue,value) 在name对应的列表的某一个值前或后插入一个新值

r.lrem(name,value,num) 在name对应的list中删除指定的值

lindex(name,index) 在name对应的列表中根据索引获取列表元素

set操作

sadd(name,values) name对应的集合中添加元素

scard(name) 获取name对应的集合中元素个数

sdiff(keys,*args) 在第一个name对应的集合中且不在其他name对应的集合的元素集合

sinter(keys,*args) 获取多一个name对应集合的并集

sismember(name,value) 检查value是否是name对应的集合的成员

smembers(name) 获取name对应的集合的所有成员

smove(src,dst,value) 将某个成员从一个集合移动到另一个集合

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

srem(name,values) 在name对应的集合中删除某些值

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

有序集合

有序集合，在集合的基础上，为每元素排序；元素的排序需要根据另外一个值来进行比较，所以，对于有序集合，每一个元素有两个值，即：值和分数，分数专门用来做排序。

zadd(name,*args,**kwargs)  在name对应的有序集合中添加元素

zcard(name)  获取name对应的有序集合元素的数量

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

zincrby(name,value,amount)  自增name对应的有序集合的name对应的分数

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

zrem(name,values) 删除name对应的有序集合中值是values的成员

zremrangebyrangk(name,min,max) 根据排行范围删除

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

其他操作

delete(*names) 根据删除redis中的任意数据类型

exists(name) 检测redis的name是否存在

expire(name,time) 为某个redis的某个name设置超时时间

rename(src,dst) 对redis的name重命名

move(name,db) 将redis的某个值移动到指定的db下

randomkey() 随机获取一个redis的name(不删除)

type(name) 获取name对应值的类型

管道

redis-py默认在执行每次请求都会创建（连接池申请连接）和断开（归还连接池）一次连接操作，如果想要在一次请求中指定多个命令，则可以使用pipline实现一次请求指定多个命令，并且默认情况下一次pipline 是原子性操作。

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

发布订阅

订阅者

 from monitor.RedisHelper import RedisHelper
 
 obj = RedisHelper()
 redis_sub = obj.subscribe()
 
 while True:
     msg= redis_sub.parse_response()
     print msg

发布者

 from monitor.RedisHelper import RedisHelper
 
 obj = RedisHelper()
 obj.public('hello')

三、ORM框架之SQLAchemy

SQLAlchemy是Python编程语言下的一款ORM框架，该框架建立在数据库API之上，使用关系对象映射进行数据库操作，简言之便是：将对象转换成SQL，然后使用数据API执行SQL并获取执行结果。

1.创建表

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
 from sqlalchemy.orm import sessionmaker, relationship
 from sqlalchemy import create_engine
 
 engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/t1", max_overflow=5)
 
 Base = declarative_base()
 
 # 创建单表
 class Users(Base):
     __tablename__ = 'users'
     id = Column(Integer, primary_key=True)
     name = Column(String(32))
     extra = Column(String(16))
 
     __table_args__ = (
     UniqueConstraint('id', 'name', name='uix_id_name'),
         Index('ix_id_name', 'name', 'extra'),
     )
   def init_db():

    Base.metadata.create_all(engine)

     init_db()

一对多

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:Liumj
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String,ForeignKey,UniqueConstraint,Index
from sqlalchemy.orm import sessionmaker,relationship
from sqlalchemy import create_engine
 
engine = create_engine("mysql+pymysql://root:123@127.0.0.1/users",max_overflow=5)
Base =  declarative_base()
class Favor(Base):
    __tablename__ = 'favor'
    nid = Column(Integer,primary_key=True)
    caption = Column(String(50),default='red',unique=True)
class Person(Base):
    __tablename__ = 'person'
    nid = Column(Integer,primary_key=True)
    name = Column(String(32),index=True,nullable=True)
    favor_id = Column(Integer,ForeignKey("favor.nid"))
 
def init_db():
    Base.metadata.create_all(engine)
init_db()

多对多代码：

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Liumj
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy import Column,Integer,String,ForeignKey,UniqueConstraint,Index
 from sqlalchemy.orm import sessionmaker,relationship
 from sqlalchemy import create_engine
 engine = create_engine("mysql+pymysql://root:123@127.0.0.1/users",max_overflow=5)
 Base =  declarative_base()
 class Group(Base):
     __tablename__ = 'group'
     id = Column(Integer, primary_key=True)
     name = Column(String(64), unique=True, nullable=False)
     port = Column(Integer, default=22)
 
 class Server(Base):
     __tablename__ = 'server'
     id = Column(Integer, primary_key=True, autoincrement=True)
     hostname = Column(String(64), unique=True, nullable=False)
 
 class ServerToGroup(Base):
     __tablename__ = 'servertogroup'
     nid = Column(Integer, primary_key=True, autoincrement=True)
     server_id = Column(Integer, ForeignKey('server.id'))
     group_id = Column(Integer, ForeignKey('group.id'))
 
 def init_db():
     Base.metadata.create_all(engine)

29 init_db()

2.操作表

增

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Liumj
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy import Column,Integer,String,ForeignKey,UniqueConstraint,Index
 from sqlalchemy.orm import sessionmaker,relationship
 from sqlalchemy import create_engine
 Base = declarative_base()
 class Users(Base):
     __tablename__ = 'us'
     id = Column(Integer, primary_key=True)
     name = Column(String(32))
     extra = Column(String(16))
 engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/users?charset=utf8", max_overflow=5)
 Session = sessionmaker(bind=engine)
 session = Session()
 #obj1 = Users(id=1,name='root',extra='...')
 #session.add(obj1)
 session.add_all([
     Users(name="alex1", extra='sb'),
     Users(name="alex2", extra='sb'),
 ])
 session.commit()

删

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Liumj
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy import Column,Integer,String,ForeignKey,UniqueConstraint,Index
 from sqlalchemy.orm import sessionmaker,relationship
 from sqlalchemy import create_engine
 engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/users?charset=utf8", max_overflow=5)
 Base = declarative_base()
 class Users(Base):
     __tablename__ = 'us'
     id = Column(Integer, primary_key=True)
     name = Column(String(32))
     extra = Column(String(16))
 Session = sessionmaker(bind=engine)
 session = Session()
 session.query(Users).filter(Users.id > 1).delete()
 session.commit()

改

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Liumj
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy import Column,Integer,String,ForeignKey,UniqueConstraint,Index
 from sqlalchemy.orm import sessionmaker,relationship
 from sqlalchemy import create_engine
 engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/users?charset=utf8", max_overflow=5)
 Base = declarative_base()
 class Users(Base):
     __tablename__ = 'us'
     id = Column(Integer, primary_key=True)
     name = Column(String(32))
     extra = Column(String(16))
 Session = sessionmaker(bind=engine)
 session = Session()
 
 session.query(Users).filter(Users.id > 1).update({"name" : ""})
 session.query(Users).filter(Users.id > 1).update({Users.name: Users.name + ""}, synchronize_session=False)
 session.commit()

查

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Liumj
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy import Column,Integer,String,ForeignKey,UniqueConstraint,Index
 from sqlalchemy.orm import sessionmaker,relationship
 from sqlalchemy import create_engine
 engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/user?charset=utf8", max_overflow=5)
 Base = declarative_base()
 class Users(Base):
     __tablename__ = 'us'
     id = Column(Integer, primary_key=True)
     name = Column(String(32))
     extra = Column(String(16))
 Session = sessionmaker(bind=engine)
 session = Session()
 ret = session.query(Users).all()
 ret = session.query(Users.name, Users.extra).all()
 ret = session.query(Users).filter_by(name='alex').all()
 ret = session.query(Users).filter_by(name='alex').first()
 session.commit()
 print(ret)

查

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:Liumj
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy import Column,Integer,String,ForeignKey,UniqueConstraint,Index
 from sqlalchemy.orm import sessionmaker,relationship
 from sqlalchemy import create_engine
 engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/users?charset=utf8", max_overflow=5)
 Base = declarative_base()
 class Users(Base):
     __tablename__ = 'us'
     id = Column(Integer, primary_key=True)
     name = Column(String(32))
     extra = Column(String(16))
 Session = sessionmaker(bind=engine)
 session = Session()
 ret = session.query(Users).all()
 ret1 = session.query(Users.name, Users.extra).all()
 ret2 = session.query(Users).filter_by(name='alex').all()
 ret3 = session.query(Users).filter_by(name='alex').first()
 v = session.query(Users).filter_by(id=2).all()
 v1 = session.query(Users.id,Users.name)
 print(v)
 print(v1)
 print(ret)
 print(ret1)
 print(ret2)
 print(ret3)

其他

 #　条件
 ret = session.query(Users).filter_by(name='alex').all()
 ret = session.query(Users).filter(Users.id > 1, Users.name == 'eric').all()
 ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'eric').all()
 ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
 ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
 ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='eric'))).all()
 from sqlalchemy import and_, or_
 ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'eric')).all()
 ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'eric')).all()
 ret = session.query(Users).filter(
     or_(
         Users.id < 2,
         and_(Users.name == 'eric', Users.id > 3),
         Users.extra != ""
     )).all()
 
 # 通配符
 ret = session.query(Users).filter(Users.name.like('e%')).all()
 ret = session.query(Users).filter(~Users.name.like('e%')).all()
 
 # 限制
 ret = session.query(Users)[1:2]
 
 # 排序
 ret = session.query(Users).order_by(Users.name.desc()).all()
 ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()
 
 # 分组
 from sqlalchemy.sql import func
 
 ret = session.query(Users).group_by(Users.extra).all()
 ret = session.query(
     func.max(Users.id),
     func.sum(Users.id),
     func.min(Users.id)).group_by(Users.name).all()
 
 ret = session.query(
     func.max(Users.id),
     func.sum(Users.id),
     func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()
 
 # 连表
 
 ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()
 
 ret = session.query(Person).join(Favor).all()
 
 ret = session.query(Person).join(Favor, isouter=True).all()
 
 # 组合
 q1 = session.query(Users.name).filter(Users.id > 2)
 q2 = session.query(Favor.caption).filter(Favor.nid < 2)
 ret = q1.union(q2).all()
 
 q1 = session.query(Users.name).filter(Users.id > 2)
 q2 = session.query(Favor.caption).filter(Favor.nid < 2)
 ret = q1.union_all(q2).all()