一、memcache

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

启动:memcached --10    -u root -10.211.55.4 -12000 -256 -/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模块

  1. import memcache
  2.  
  3. mc = memcache.Client(['10.211.55.4:12000'], debug=True)
  4. mc.set("foo", "bar")
  5. ret = mc.get('foo')
  6. 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

操作模式

  1. import redis
  2.  
  3. r = redis.Redis(host='192.168.10.12',port=6379)
  4. r.set('foo','Bar')
  5. print(r.get('foo'))

连接池

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

  1. import redis
  2.  
  3. pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
  4.  
  5. r = redis.Redis(connection_pool=pool)
  6. r.set('foo', 'Bar')
  7. 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 是原子性操作。

  1. import redis
  2.  
  3. pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
  4.  
  5. r = redis.Redis(connection_pool=pool)
  6.  
  7. # pipe = r.pipeline(transaction=False)
  8. pipe = r.pipeline(transaction=True)
  9.  
  10. pipe.set('name', 'alex')
  11. pipe.set('role', 'sb')
  12.  
  13. pipe.execute()

发布订阅

订阅者

  1. from monitor.RedisHelper import RedisHelper
  2.  
  3. obj = RedisHelper()
  4. redis_sub = obj.subscribe()
  5.  
  6. while True:
  7. msg= redis_sub.parse_response()
  8. print msg

发布者

  1. from monitor.RedisHelper import RedisHelper
  2.  
  3. obj = RedisHelper()
  4. obj.public('hello')

三、ORM框架之SQLAchemy

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

1.创建表

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. from sqlalchemy.ext.declarative import declarative_base
  4. from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
  5. from sqlalchemy.orm import sessionmaker, relationship
  6. from sqlalchemy import create_engine
  7.  
  8. engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/t1", max_overflow=5)
  9.  
  10. Base = declarative_base()
  11.  
  12. # 创建单表
  13. class Users(Base):
  14. __tablename__ = 'users'
  15. id = Column(Integer, primary_key=True)
  16. name = Column(String(32))
  17. extra = Column(String(16))
  18.  
  19. __table_args__ = (
  20. UniqueConstraint('id', 'name', name='uix_id_name'),
  21. Index('ix_id_name', 'name', 'extra'),
  22. )
    def init_db():
    Base.metadata.create_all(engine)
     init_db()

一对多

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. # Author:Liumj
  4. from sqlalchemy.ext.declarative import declarative_base
  5. from sqlalchemy import Column,Integer,String,ForeignKey,UniqueConstraint,Index
  6. from sqlalchemy.orm import sessionmaker,relationship
  7. from sqlalchemy import create_engine
  8.  
  9. engine = create_engine("mysql+pymysql://root:123@127.0.0.1/users",max_overflow=5)
  10. Base = declarative_base()
  11. class Favor(Base):
  12. __tablename__ = 'favor'
  13. nid = Column(Integer,primary_key=True)
  14. caption = Column(String(50),default='red',unique=True)
  15. class Person(Base):
  16. __tablename__ = 'person'
  17. nid = Column(Integer,primary_key=True)
  18. name = Column(String(32),index=True,nullable=True)
  19. favor_id = Column(Integer,ForeignKey("favor.nid"))
  20.  
  21. def init_db():
  22. Base.metadata.create_all(engine)
    init_db()

多对多代码:

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. # Author:Liumj
  4. from sqlalchemy.ext.declarative import declarative_base
  5. from sqlalchemy import Column,Integer,String,ForeignKey,UniqueConstraint,Index
  6. from sqlalchemy.orm import sessionmaker,relationship
  7. from sqlalchemy import create_engine
  8. engine = create_engine("mysql+pymysql://root:123@127.0.0.1/users",max_overflow=5)
  9. Base = declarative_base()
  10. class Group(Base):
  11. __tablename__ = 'group'
  12. id = Column(Integer, primary_key=True)
  13. name = Column(String(64), unique=True, nullable=False)
  14. port = Column(Integer, default=22)
  15.  
  16. class Server(Base):
  17. __tablename__ = 'server'
  18. id = Column(Integer, primary_key=True, autoincrement=True)
  19. hostname = Column(String(64), unique=True, nullable=False)
  20.  
  21. class ServerToGroup(Base):
  22. __tablename__ = 'servertogroup'
  23. nid = Column(Integer, primary_key=True, autoincrement=True)
  24. server_id = Column(Integer, ForeignKey('server.id'))
  25. group_id = Column(Integer, ForeignKey('group.id'))
  26.  
  27. def init_db():
  28. Base.metadata.create_all(engine)
  1. 29 init_db()

2.操作表

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

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

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

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

  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3. # Author:Liumj
  4. from sqlalchemy.ext.declarative import declarative_base
  5. from sqlalchemy import Column,Integer,String,ForeignKey,UniqueConstraint,Index
  6. from sqlalchemy.orm import sessionmaker,relationship
  7. from sqlalchemy import create_engine
  8. engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/users?charset=utf8", max_overflow=5)
  9. Base = declarative_base()
  10. class Users(Base):
  11. __tablename__ = 'us'
  12. id = Column(Integer, primary_key=True)
  13. name = Column(String(32))
  14. extra = Column(String(16))
  15. Session = sessionmaker(bind=engine)
  16. session = Session()
  17. ret = session.query(Users).all()
  18. ret1 = session.query(Users.name, Users.extra).all()
  19. ret2 = session.query(Users).filter_by(name='alex').all()
  20. ret3 = session.query(Users).filter_by(name='alex').first()
  21. v = session.query(Users).filter_by(id=2).all()
  22. v1 = session.query(Users.id,Users.name)
  23. print(v)
  24. print(v1)
  25. print(ret)
  26. print(ret1)
  27. print(ret2)
  28. print(ret3)

其他

  1. # 条件
  2. ret = session.query(Users).filter_by(name='alex').all()
  3. ret = session.query(Users).filter(Users.id > 1, Users.name == 'eric').all()
  4. ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'eric').all()
  5. ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
  6. ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
  7. ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='eric'))).all()
  8. from sqlalchemy import and_, or_
  9. ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'eric')).all()
  10. ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'eric')).all()
  11. ret = session.query(Users).filter(
  12. or_(
  13. Users.id < 2,
  14. and_(Users.name == 'eric', Users.id > 3),
  15. Users.extra != ""
  16. )).all()
  17.  
  18. # 通配符
  19. ret = session.query(Users).filter(Users.name.like('e%')).all()
  20. ret = session.query(Users).filter(~Users.name.like('e%')).all()
  21.  
  22. # 限制
  23. ret = session.query(Users)[1:2]
  24.  
  25. # 排序
  26. ret = session.query(Users).order_by(Users.name.desc()).all()
  27. ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()
  28.  
  29. # 分组
  30. from sqlalchemy.sql import func
  31.  
  32. ret = session.query(Users).group_by(Users.extra).all()
  33. ret = session.query(
  34. func.max(Users.id),
  35. func.sum(Users.id),
  36. func.min(Users.id)).group_by(Users.name).all()
  37.  
  38. ret = session.query(
  39. func.max(Users.id),
  40. func.sum(Users.id),
  41. func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()
  42.  
  43. # 连表
  44.  
  45. ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()
  46.  
  47. ret = session.query(Person).join(Favor).all()
  48.  
  49. ret = session.query(Person).join(Favor, isouter=True).all()
  50.  
  51. # 组合
  52. q1 = session.query(Users.name).filter(Users.id > 2)
  53. q2 = session.query(Favor.caption).filter(Favor.nid < 2)
  54. ret = q1.union(q2).all()
  55.  
  56. q1 = session.query(Users.name).filter(Users.id > 2)
  57. q2 = session.query(Favor.caption).filter(Favor.nid < 2)
  58. ret = q1.union_all(q2).all()

Python操作redis、memcache和ORM框架_Day13的更多相关文章

  1. Python操作Redis、Memcache、RabbitMQ、SQLAlchemy

    Python操作 Redis.Memcache.RabbitMQ.SQLAlchemy redis介绍:redis是一个开源的,先进的KEY-VALUE存储,它通常被称为数据结构服务器,因为键可以包含 ...

  2. python运维开发(十一)----python操作缓存memcache、redis

    内容目录: 缓存 memcache redis memcache Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数 ...

  3. python操作三大主流数据库(12)python操作redis的api框架redis-py简单使用

    python操作三大主流数据库(12)python操作redis的api框架redis-py简单使用 redispy安装安装及简单使用:https://github.com/andymccurdy/r ...

  4. Python操作Redis、Memcache

       今天主要介绍如何通过python来对Redis和memcache进行操作,下面开始今天的内容: 一.Memcached操作 Memcached是一个高性能的分布式内存对象缓存系统,用于动态Web ...

  5. 数据库之redis篇(3)—— Python操作redis

    虽然前面两篇已经说了redis的一些配置安装什么的,篇幅有点长,可能看完了也不知道怎么操作,这里再浓缩一下: 什么是redis redis完全开源免费的,遵守BSD协议,是一个高性能的非关系型key- ...

  6. 第二百九十六节,python操作redis缓存-Hash哈希类型,可以理解为字典类型

    第二百九十六节,python操作redis缓存-Hash哈希类型,可以理解为字典类型 Hash操作,redis中Hash在内存中的存储格式如下图: hset(name, key, value)name ...

  7. 第二百九十五节,python操作redis缓存-字符串类型

    python操作redis缓存-字符串类型 首先要安装redis-py模块 python连接redis方式,有两种连接方式,一种是直接连接,一张是通过连接池连接 注意:以后我们都用的连接池方式连接,直 ...

  8. Python操作Redis(一)

    redis是一个key-value存储系统.和Memcached类似,它支持存储的value类型相对更多,包括string(字符串).list(链表).set(集合).zset(sorted set ...

  9. Python—操作redis

    Python操作redis 连接方式:点击 1.String 操作 redis中的String在在内存中按照一个name对应一个value来存储 set() #在Redis中设置值,默认不存在则创建, ...

随机推荐

  1. Memcached安装配置最大使用内存

    Memcached安装配置最大使用内存 项目做了很多,虽然用memcached的项目也有很多.但是没有太关注安装memcached细节问题 最近做了一个项目,把很多东西都放到memcached缓存中, ...

  2. 基于认证的代理平台搭建配置squid-20130730

    基于认证的代理平台搭建配置squid-20130730 功能:通过squid代理实现 (1)基于用户名密码认证的出口ip路由选择 (2)基于client源ip的出口ip路由选择 (3)基于连接本机ip ...

  3. 【July】从头到尾彻底理解KMP

    从头到尾彻底理解KMP 作者:July时间:最初写于2011年12月,2014年7月21日晚10点 全部删除重写成此文,随后的半个多月不断反复改进. 1. 引言 本KMP原文最初写于2年多前的2011 ...

  4. C语言的一些常见细节

    C语言的一些常见细节 对于C语言,不同的编译器采用了不同的实现,并且在不同平台上表现也不同.脱离具体环境探讨C的细节行为是没有意义的,以下是我所使用的环境,大部分内容都经过测试,且所有测试结果基于这个 ...

  5. jQuery判断元素是否显示与隐藏

    jQuery判断一个元素是显示还是隐藏,jQuery使用is()方法来判断一个元素是否显示,反之则为隐藏 核心代码 if($("#username").is(":hidd ...

  6. Javascript 封装问题

    Javascript 封装问题 为什么会用这样一个题目呢,这是要说封装的什么问题,本文并不讲高深的封装理论,只是解决一个小问题. 问题来源 今天在百度知道上闲逛,遇到一个网友的问题,问题如下,问题的地 ...

  7. 三.redis 排序

    本篇文章介绍下redis排序命令.redis支持对list,set和sorted set元素的排序.排序命令是sort 完整的命令格式如下: SORT key [BY pattern] [LIMIT ...

  8. Oracle用脚本语言导入SCOTT用户

    许多Oracle新手都遇到这样的问题,安装Oracle之后没有SCOTT用户,那就自己加入吧,打开Oracle 命令窗口复制下面SQL脚本直接输入就行了,包含了测试学习的DEPT.EMP.BONUS. ...

  9. 记录下自己写的gulp打包脚本

    var c = { rootPath: 'src',//项目文件夹 outputPath: 'output',//文件编译后的输出目录 revPath: 'manifest',//rev映射文件目录 ...

  10. Excel 自定义函数

    浅谈Excel开发:四 Excel 自定义函数   我们知道,Excel中有很多内置的函数,比如求和,求平均,字符串操作函数,金融函数等等.在有些时候,结合业务要求,这些函数可能不能满足我们的需求,比 ...