Memcached

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

Memcached安装和基本使用

Memcached安装:

  • wget http://memcached.org/latest
  • tar -zxvf memcached-1.x.x.tar.gz
  • cd memcached-1.x.x
  • ./configure && make && make test && sudo make install
 
  • PS:依赖libevent
  •        yum install libevent-devel
  •        apt-get install libevent-dev

启动Memcached

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

Memcached命令

  1. 存储命令: set/add/replace/append/prepend/cas
  2. 获取命令: get/gets
  3. 其他命令: delete/stats..

Python操作Memcached

安装API

python操作Memcached使用Python-memcached模块
下载安装:https://pypi.python.org/pypi/python-memcached
 
  1. 1、第一次操作
  2.  
  3. import memcache
  4.  
  5. mc = memcache.Client(['10.211.55.4:12000'], debug=True)
  6. mc.set("foo", "bar")
  7. ret = mc.get('foo')
  8. print ret
  9.  
  10. Psdebug = True 表示运行出现错误时,现实错误信息,上线后移除该参数。
  11.  
  12. 2、天生支持集群
  13.  
  14. python-memcached模块原生支持集群操作,其原理是在内存维护一个主机列表,且集群中主机的权重值和主机在列表中重复出现的次数成正比
  15.  
  16. 主机 权重
  17. 1.1.1.1 1
  18. 1.1.1.2 2
  19. 1.1.1.3 1
  20.  
  21. 那么在内存中主机列表为:
  22. host_list = ["1.1.1.1", "1.1.1.2", "1.1.1.2", "1.1.1.3", ]
  23.  
  24. 如果用户根据如果要在内存中创建一个键值对(如:k1 = "v1"),那么要执行一下步骤:
  25.  
  26. 根据算法将 k1 转换成一个数字
  27. 将数字和主机列表长度求余数,得到一个值 N 0 <= N < 列表长度
  28. 在主机列表中根据 2步得到的值为索引获取主机,例如:host_list[N]
  29. 连接 将第3步中获取的主机,将 k1 = "v1" 放置在该服务器的内存中
  30.  
  31. 代码实现如下:
  32.  
  33. mc = memcache.Client([('1.1.1.1:12000', 1), ('1.1.1.2:12000', 2), ('1.1.1.3:12000', 1)], debug=True)
  34.  
  35. mc.set('k1', 'v1')
  36.  
  37. 3add
  38. 添加一条键值对,如果已经存在的 key,重复执行add操作异常
  39.  
  40. #!/usr/bin/env python
  41. # -*- coding:utf-8 -*-
  42. import memcache
  43.  
  44. mc = memcache.Client(['10.211.55.4:12000'], debug=True)
  45. mc.add('k1', 'v1')
  46. # mc.add('k1', 'v2') # 报错,对已经存在的key重复添加,失败!!!
  47.  
  48. 4replace
  49. replace 修改某个key的值,如果key不存在,则异常
  50.  
  51. #!/usr/bin/env python
  52. # -*- coding:utf-8 -*-
  53. import memcache
  54.  
  55. mc = memcache.Client(['10.211.55.4:12000'], debug=True)
  56. # 如果memcache中存在kkkk,则替换成功,否则一场
  57. mc.replace('kkkk','')
  58.  
  59. 5set set_multi
  60.  
  61. set 设置一个键值对,如果key不存在,则创建,如果key存在,则修改
  62. set_multi 设置多个键值对,如果key不存在,则创建,如果key存在,则修改
  63.  
  64. #!/usr/bin/env python
  65. # -*- coding:utf-8 -*-
  66. import memcache
  67.  
  68. mc = memcache.Client(['10.211.55.4:12000'], debug=True)
  69.  
  70. mc.set('key0', 'wupeiqi')
  71.  
  72. mc.set_multi({'key1': 'val1', 'key2': 'val2'})
  73.  
  74. 6delete delete_multi
  75.  
  76. delete Memcached中删除指定的一个键值对
  77. delete_multi Memcached中删除指定的多个键值对
  78.  
  79. #!/usr/bin/env python
  80. # -*- coding:utf-8 -*-
  81. import memcache
  82.  
  83. mc = memcache.Client(['10.211.55.4:12000'], debug=True)
  84.  
  85. mc.delete('key0')
  86. mc.delete_multi(['key1', 'key2'])
  87.  
  88. 7get get_multi
  89.  
  90. get 获取一个键值对
  91. get_multi 获取多一个键值对
  92.  
  93. #!/usr/bin/env python
  94. # -*- coding:utf-8 -*-
  95. import memcache
  96.  
  97. mc = memcache.Client(['10.211.55.4:12000'], debug=True)
  98.  
  99. val = mc.get('key0')
  100. item_dict = mc.get_multi(["key1", "key2", "key3"])
  101.  
  102. 8append prepend
  103.  
  104. append 修改指定key的值,在该值 后面 追加内容
  105. prepend 修改指定key的值,在该值 前面 插入内容
  106.  
  107. #!/usr/bin/env python
  108. # -*- coding:utf-8 -*-
  109. import memcache
  110.  
  111. mc = memcache.Client(['10.211.55.4:12000'], debug=True)
  112. # k1 = "v1"
  113.  
  114. mc.append('k1', 'after')
  115. # k1 = "v1after"
  116.  
  117. mc.prepend('k1', 'before')
  118. # k1 = "beforev1after"
  119.  
  120. 9decr incr  
  121.  
  122. incr 自增,将Memcached中的某一个值增加 N N默认为1
  123. decr 自减,将Memcached中的某一个值减少 N N默认为1
  124.  
  125. #!/usr/bin/env python
  126. # -*- coding:utf-8 -*-
  127. import memcache
  128.  
  129. mc = memcache.Client(['10.211.55.4:12000'], debug=True)
  130. mc.set('k1', '')
  131.  
  132. mc.incr('k1')
  133. # k1 = 778
  134.  
  135. mc.incr('k1', 10)
  136. # k1 = 788
  137.  
  138. mc.decr('k1')
  139. # k1 = 787
  140.  
  141. mc.decr('k1', 10)
  142. # k1 = 777
  143.  
  144. 10gets cas
  145.  
  146. 如商城商品剩余个数,假设改值保存在memcache中,product_count = 900
  147. A用户刷新页面从memcache中读取到product_count = 900
  148. B用户刷新页面从memcache中读取到product_count = 900
  149.  
  150. 如果AB用户均购买商品
  151.  
  152. A用户修改商品剩余个数 product_count899
  153. B用户修改商品剩余个数 product_count899
  154.  
  155. 如此一来缓存内的数据便不在正确,两个用户购买商品后,商品剩余还是 899
  156. 如果使用pythonsetget来操作以上过程,那么程序就会如上述所示情况!
  157.  
  158. 如果想要避免此情况的发生,只要使用 gets cas 即可,如:
  159.  
  160. #!/usr/bin/env python
  161. # -*- coding:utf-8 -*-
  162. import memcache
  163. mc = memcache.Client(['10.211.55.4:12000'], debug=True, cache_cas=True)
  164.  
  165. v = mc.gets('product_count')
  166. # ...
  167. # 如果有人在gets之后和cas之前修改了product_count,那么,下面的设置将会执行失败,剖出异常,从而避免非正常数据的产生
  168. mc.cas('product_count', "")
  169.  
  170. Ps:本质上每次执行gets时,会从memcache中获取一个自增的数字,通过cas去修改gets的值时,会携带之前获取的自增值和memcache中的自增值进行比较,如果相等,则可以提交,如果不想等,那表示在getscas执行之间,又有其他人执行了gets(获取了缓冲的指定值), 如此一来有可能出现非正常数据,则不允许修改。

Redis

redis是一个key-value存储系统。和Memcached类似,它支持存储的value类型相对更多,包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash(哈希类型)。这些数据类型都 支持push/pop、add/remove及取交集并集和差集及更丰富的操作,而且这些操作都是原子性的。在此基础上,redis支持各种不同方式的排 序。与memcached一样,为了保证效率,数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文 件,并且在此基础上实现了master-slave(主从)同步。

Redis安装和基本使用

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

启动服务端

src/redis-server

Python操作Redis

安装API

  1. sudo pip install redis
  2. or
  3. sudo easy_install redis
  4. or
  5. 源码安装
  6. 详见:https://github.com/WoLpH/redis-py
  1. 常用操作
  2.  
  3. 1、操作模式
  4.  
  5. redis-py提供两个类RedisStrictRedis用于实现Redis的命令,StrictRedis用于实现大部分官方的命令,并使用官方的语法和命令,RedisStrictRedis的子类,用于向后兼容旧版本的redis-py
  6.  
  7. #!/usr/bin/env python
  8. # -*- coding:utf-8 -*-
  9.  
  10. import redis
  11.  
  12. r = redis.Redis(host='10.211.55.4', port=6379)
  13. r.set('foo', 'Bar')
  14. print r.get('foo')
  15.  
  16. 2、连接池
  17.  
  18. redis-py使用connection pool来管理对一个redis server的所有连接,避免每次建立、释放连接的开销。默认,每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池,然后作为参数Redis,这样就可以实现多个Redis实例共享一个连接池。
  19.  
  20. #!/usr/bin/env python
  21. # -*- coding:utf-8 -*-
  22.  
  23. import redis
  24.  
  25. pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
  26.  
  27. r = redis.Redis(connection_pool=pool)
  28. r.set('foo', 'Bar')
  29. print r.get('foo')
  30.  
  31. 3、管道
  32.  
  33. redis-py默认在执行每次请求都会创建(连接池申请连接)和断开(归还连接池)一次连接操作,如果想要在一次请求中指定多个命令,则可以使用pipline实现一次请求指定多个命令,并且默认情况下一次pipline 是原子性操作。
  34.  
  35. #!/usr/bin/env python
  36. # -*- coding:utf-8 -*-
  37.  
  38. import redis
  39.  
  40. pool = redis.ConnectionPool(host='10.211.55.4', port=6379)
  41.  
  42. r = redis.Redis(connection_pool=pool)
  43.  
  44. # pipe = r.pipeline(transaction=False)
  45. pipe = r.pipeline(transaction=True)
  46.  
  47. r.set('name', 'alex')
  48. r.set('role', 'sb')
  49.  
  50. pipe.execute()
  51.  
  52. 4、发布订阅
  53.  
  54. 订阅者:
  55.  
  56. #!/usr/bin/env python
    # -*- coding:utf-8 -*-
     
    from monitor.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 -*-
     
    from monitor.RedisHelper import RedisHelper
     
    obj = RedisHelper()
    obj.public('hello')   

RabbitMQ

RabbitMQ是一个在AMQP基础上完整的,可复用的企业消息系统。他遵循Mozilla Public License开源协议。

MQ全称为Message Queue, 消息队列(MQ)是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息(针对应用程序的数据)来通信,而无需专用连接来链接它们。消 息传递指的是程序之间通过在消息中发送数据进行通信,而不是通过直接调用彼此来通信,直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。

RabbitMQ安装

  1. 安装配置epel源
  2.    $ rpm -ivh http://dl.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm
 
  1. 安装erlang
  2.    $ yum -y install erlang
  1. 安装RabbitMQ
  2.    $ yum -y install rabbitmq-server

安装API

  1. pip install pika
  2. or
  3. easy_install pika
  4. or
  5. 源码 https://pypi.python.org/pypi/pika
  1. 对于RabbitMQ来说,生产和消费不再针对内存里的一个Queue对象,而是某台服务器上的RabbitMQ Server实现的消息队列。
  2.  
  3. #!/usr/bin/env python
  4. import pika
  5.  
  6. # ######################### 生产者 #########################
  7.  
  8. connection = pika.BlockingConnection(pika.ConnectionParameters(
  9. host='localhost'))
  10. channel = connection.channel()
  11.  
  12. channel.queue_declare(queue='hello')
  13.  
  14. channel.basic_publish(exchange='',
  15. routing_key='hello',
  16. body='Hello World!')
  17. print(" [x] Sent 'Hello World!'")
  18. connection.close()
  19.  
  20. #!/usr/bin/env python
  21. import pika
  22.  
  23. # ########################## 消费者 ##########################
  24.  
  25. connection = pika.BlockingConnection(pika.ConnectionParameters(
  26. host='localhost'))
  27. channel = connection.channel()
  28.  
  29. channel.queue_declare(queue='hello')
  30.  
  31. def callback(ch, method, properties, body):
  32. print(" [x] Received %r" % body)
  33.  
  34. channel.basic_consume(callback,
  35. queue='hello',
  36. no_ack=True)
  37.  
  38. print(' [*] Waiting for messages. To exit press CTRL+C')
  39. channel.start_consuming()

1、acknowledgment 消息不丢失

  1.  

no-ack = False,如果生产者遇到情况(its channel is closed, connection is closed, or TCP connection is lost)挂掉了,那么,RabbitMQ会重新将该任务添加到队列中。

  1.  
  1. import pika
  2.  
  3. connection = pika.BlockingConnection(pika.ConnectionParameters(
  4. host='10.211.55.4'))
  5. channel = connection.channel()
  6.  
  7. channel.queue_declare(queue='hello')
  8.  
  9. def callback(ch, method, properties, body):
  10. print(" [x] Received %r" % body)
  11. import time
  12. time.sleep(10)
  13. print 'ok'
  14. ch.basic_ack(delivery_tag = method.delivery_tag)
  15.  
  16. channel.basic_consume(callback,
  17. queue='hello',
  18. no_ack=False)
  19.  
  20. print(' [*] Waiting for messages. To exit press CTRL+C')
  21. channel.start_consuming()
  22.  
  23. 2durable   消息不丢失
    生产者
  1. #!/usr/bin/env python
  2. import pika
  3.  
  4. connection = pika.BlockingConnection(pika.ConnectionParameters(host='10.211.55.4'))
  5. channel = connection.channel()
  6.  
  7. # make message persistent
  8. channel.queue_declare(queue='hello', durable=True)
  9.  
  10. channel.basic_publish(exchange='',
  11. routing_key='hello',
  12. body='Hello World!',
  13. properties=pika.BasicProperties(
  14. delivery_mode=2, # make message persistent
  15. ))
  16. print(" [x] Sent 'Hello World!'")
  17. connection.close()
  18.  
  19. 消费者
    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    import pika
  20.  
  21. connection = pika.BlockingConnection(pika.ConnectionParameters(host='10.211.55.4'))
    channel = connection.channel()
  22.  
  23. # make message persistent
    channel.queue_declare(queue='hello', durable=True)
  24.  
  25. def callback(ch, method, properties, body):
        print(" [x] Received %r" % body)
        import time
        time.sleep(10)
        print 'ok'
        ch.basic_ack(delivery_tag = method.delivery_tag)
  26.  
  27. channel.basic_consume(callback,
                          queue='hello',
                          no_ack=False)
  28.  
  29. print(' [*] Waiting for messages. To exit press CTRL+C')
    channel.start_consuming()
  30.  

3、消息获取顺序

默认消息队列里的数据是按照顺序被消费者拿走,例如:消费者1 去队列中获取 奇数 序列的任务,消费者1去队列中获取 偶数 序列的任务。

channel.basic_qos(prefetch_count=1) 表示谁来谁取,不再按照奇偶数排列

消费者

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(host='10.211.55.4'))
channel = connection.channel()

# make message persistent
channel.queue_declare(queue='hello')

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    import time
    time.sleep(10)
    print 'ok'
    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_qos(prefetch_count=1)

channel.basic_consume(callback,
                      queue='hello',
                      no_ack=False)

print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()

  1.  

4、发布订阅

发布订阅和简单的消息队列区别在于,发布订阅会将消息发送给所有的订阅者,而消息队列中的数据被消费一次便消失。所以,RabbitMQ实现发布和订阅时,会为每一个订阅者创建一个队列,而发布者发布消息时,会将消息放置在所有相关队列中。

exchange type = fanout

发布者

#!/usr/bin/env python
import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='logs',
                         type='fanout')

message = ' '.join(sys.argv[1:]) or "info: Hello World!"
channel.basic_publish(exchange='logs',
                      routing_key='',
                      body=message)
print(" [x] Sent %r" % message)
connection.close()

订阅者
#!/usr/bin/env python
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='logs',
                         type='fanout')

result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue

channel.queue_bind(exchange='logs',
                   queue=queue_name)

print(' [*] Waiting for logs. To exit press CTRL+C')

def callback(ch, method, properties, body):
    print(" [x] %r" % body)

channel.basic_consume(callback,
                      queue=queue_name,
                      no_ack=True)

channel.start_consuming()

5、关键字发送

exchange type = direct

之前事例,发送消息时明确指定某个队列并向其中发送消息,RabbitMQ还支持根据关键字发送,即:队列绑定关键字,发送者将数据根据关键字发送到消息exchange,exchange根据 关键字 判定应该将数据发送至指定队列。

  1. 消费者
  1. #!/usr/bin/env python
    import pika
    import sys
  2.  
  3. connection = pika.BlockingConnection(pika.ConnectionParameters(
            host='localhost'))
    channel = connection.channel()
  4.  
  5. channel.exchange_declare(exchange='direct_logs',
                             type='direct')
  6.  
  7. result = channel.queue_declare(exclusive=True)
    queue_name = result.method.queue
  8.  
  9. severities = sys.argv[1:]
    if not severities:
        sys.stderr.write("Usage: %s [info] [warning] [error]\n" % sys.argv[0])
        sys.exit(1)
  10.  
  11. for severity in severities:
        channel.queue_bind(exchange='direct_logs',
                           queue=queue_name,
                           routing_key=severity)
  12.  
  13. print(' [*] Waiting for logs. To exit press CTRL+C')
  14.  
  15. def callback(ch, method, properties, body):
        print(" [x] %r:%r" % (method.routing_key, body))
  16.  
  17. channel.basic_consume(callback,
                          queue=queue_name,
                          no_ack=True)
  18.  
  19. channel.start_consuming()
  1. 生产者
    #!/usr/bin/env python
    import pika
    import sys
  2.  
  3. connection = pika.BlockingConnection(pika.ConnectionParameters(
            host='localhost'))
    channel = connection.channel()
  4.  
  5. channel.exchange_declare(exchange='direct_logs',
                             type='direct')
  6.  
  7. severity = sys.argv[1] if len(sys.argv) > 1 else 'info'
    message = ' '.join(sys.argv[2:]) or 'Hello World!'
    channel.basic_publish(exchange='direct_logs',
                          routing_key=severity,
                          body=message)
    print(" [x] Sent %r:%r" % (severity, message))
    connection.close()

6、模糊匹配

  1.  

exchange type = topic

  1.  

在topic类型下,可以让队列绑定几个模糊的关键字,之后发送者将数据发送到exchange,exchange将传入”路由值“和 ”关键字“进行匹配,匹配成功,则将数据发送到指定队列。

  1.  
  • # 表示可以匹配 0 个 或 多个 单词
  • *  表示只能匹配 一个 单词
发送者路由值              队列中
old.boy.python          old.*  -- 不匹配
old.boy.python          old.#  -- 匹配
消费者
#!/usr/bin/env python
import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='localhost'))
channel = connection.channel()

channel.exchange_declare(exchange='topic_logs',
                         type='topic')

result = channel.queue_declare(exclusive=True)
queue_name = result.method.queue

binding_keys = sys.argv[1:]
if not binding_keys:
    sys.stderr.write("Usage: %s [binding_key]...\n" % sys.argv[0])
    sys.exit(1)

for binding_key in binding_keys:
    channel.queue_bind(exchange='topic_logs',
                       queue=queue_name,
                       routing_key=binding_key)

print(' [*] Waiting for logs. To exit press CTRL+C')

def callback(ch, method, properties, body):
    print(" [x] %r:%r" % (method.routing_key, body))

channel.basic_consume(callback,
                      queue=queue_name,
                      no_ack=True)

channel.start_consuming()

  1. 生产者
  1. #!/usr/bin/env python
    import pika
    import sys
  2.  
  3. connection = pika.BlockingConnection(pika.ConnectionParameters(
            host='localhost'))
    channel = connection.channel()
  4.  
  5. channel.exchange_declare(exchange='topic_logs',
                             type='topic')
  6.  
  7. routing_key = sys.argv[1] if len(sys.argv) > 1 else 'anonymous.info'
    message = ' '.join(sys.argv[2:]) or 'Hello World!'
    channel.basic_publish(exchange='topic_logs',
                          routing_key=routing_key,
                          body=message)
    print(" [x] Sent %r:%r" % (routing_key, message))
    connection.close()

SQLAlchemy

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

Dialect用于和数据API进行交流,根据配置文件的不同调用不同的数据库API,从而实现对数据库的操作,如:

  • MySQL-Python
  •     mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
 
  • pymysql
  •     mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
 
  • MySQL-Connector
  •     mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
 
  • cx_Oracle
  •     oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
  • 更多详见:http://docs.sqlalchemy.org/en/latest/dialects/index.html
  1. #!/usr/bin/env python
  2. # -*- coding:utf-8 -*-
  3.  
  4. from sqlalchemy.ext.declarative import declarative_base
  5. from sqlalchemy import Column, Integer, String
  6. from sqlalchemy.orm import sessionmaker
  7. from sqlalchemy import create_engine
  8.  
  9. engine = create_engine("mysql+mysqldb://root:123@127.0.0.1:3306/s11", max_overflow=5)
  10.  
  11. Base = declarative_base()
  12.  
  13. class User(Base):
  14. __tablename__ = 'users'
  15. id = Column(Integer, primary_key=True)
  16. name = Column(String(50))
  17.  
  18. # 寻找Base的所有子类,按照子类的结构在数据库中生成对应的数据表信息
  19. # Base.metadata.create_all(engine)
  20.  
  21. Session = sessionmaker(bind=engine)
  22. session = Session()
  23.  
  24. # ########## 增 ##########
  25. # u = User(id=2, name='sb')
  26. # session.add(u)
  27. # session.add_all([
  28. # User(id=3, name='sb'),
  29. # User(id=4, name='sb')
  30. # ])
  31. # session.commit()
  32.  
  33. # ########## 删除 ##########
  34. # session.query(User).filter(User.id > 2).delete()
  35. # session.commit()
  36.  
  37. # ########## 修改 ##########
  38. # session.query(User).filter(User.id > 2).update({'cluster_id' : 0})
  39. # session.commit()
  40. # ########## 查 ##########
  41. # ret = session.query(User).filter_by(name='sb').first()
  42.  
  43. # ret = session.query(User).filter_by(name='sb').all()
  44. # print ret
  45.  
  46. # ret = session.query(User).filter(User.name.in_(['sb','bb'])).all()
  47. # print ret
  48.  
  49. # ret = session.query(User.name.label('name_label')).all()
  50. # print ret,type(ret)
  51.  
  52. # ret = session.query(User).order_by(User.id).all()
  53. # print ret
  54.  
  55. # ret = session.query(User).order_by(User.id)[1:3]
  56. # print ret
  57. # session.commit()

python--第十二天总结(Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy)的更多相关文章

  1. 使用python操作RabbitMQ,Redis,Memcache,SQLAlchemy 其二

    一.概念 1.Memcached     Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态 ...

  2. 使用python操作RabbitMQ,Redis,Memcache,SQLAlchemy 其一

    一.概念 1.Memcached     Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态 ...

  3. Python全栈开发:RabbitMQ/Redis/Memcache/SQLAlchemy

    Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度 ...

  4. python学习之模块导入,操作邮件,redis

    python基础学习06 模块导入 导入模块的顺序 1.先从当前目录下找 2.当前目录下找不到,再从环境变量中找,如果在同时在当前目录和环境变量中建立相同的py文件,优先使用当前目录下的 导入模块的实 ...

  5. Python 【第六章】:Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy

    Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度 ...

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

    Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度 ...

  7. 十一天 python操作rabbitmq、redis

    1.启动rabbimq.mysql 在""运行""里输入services.msc,找到rabbimq.mysql启动即可 2.启动redis 管理员进入cmd, ...

  8. Python之路【第九篇】:Python操作 RabbitMQ、Redis、Memcache、SQLAlchemy

    Python之路[第九篇]:Python操作 RabbitMQ.Redis.Memcache.SQLAlchemy   Memcached Memcached 是一个高性能的分布式内存对象缓存系统,用 ...

  9. 文成小盆友python-num12 Redis发布与订阅补充,python操作rabbitMQ

    本篇主要内容: redis发布与订阅补充 python操作rabbitMQ 一,redis 发布与订阅补充 如下一个简单的监控模型,通过这个模式所有的收听者都能收听到一份数据. 用代码来实现一个red ...

随机推荐

  1. 软件工程第4次作业------石墨文档Android客户端案例分析

    作业要求的博客链接:https://edu.cnblogs.com/campus/nenu/2016CS/homework/2505 分析产品:石墨文档Android客户端 第一部分 调研和评测 1. ...

  2. list基本代码

    #include<iostream> #include<list> //STL之list的基本用法 using namespace std; void outputList(l ...

  3. golang-generate-1pixel-image

    package main import ( "bytes" "encoding/base64" "flag" "html/temp ...

  4. memcached-redis

    http://www.runoob.com/memcached/memcached-cas.html https://github.com/memcached/memcached/blob/maste ...

  5. Linux 判断进程是否运行

    问题 linux平台 多人开发服务器,有时自己运行一个进程在服务器上,但未知原因导致停止运行了,需要添加一个定时任务,用于监控指定进程是否运行 方法 一个通用的方法,以便使用在不同项目中. 思路:定时 ...

  6. Hello ThreadPoolExecutor

    ThreadPoolExecutor创建: public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliv ...

  7. Linux vim快捷键

    1  替换    r  替换  先按r再按要替换的内容 2  按yy复制当前行  按p是粘贴 3 # add at 18-10-25 #-------------------------------- ...

  8. (整理)EF分页的实现

    最近做一个小功能,需要数据分页,因为小框架使用的是EF,因此查询了一下EF的分页. EF分页主要用到了skip和take两个方法: GetListBy(lamda xxxxx).skip(PageSi ...

  9. docker 在windows7 、8下的安装

    这里说明一下这种安装方式适合win7 win8的系统环境下安装的,当然win10也可以,但是win10有更好的方式 即安装Docker Toolbox,同时还附加安装 Docker Client fo ...

  10. Problem C: 重复子串(string)

    /* 一个性质? right集合中只有相邻的位置才会有用 那么考虑set启发式合并, 能够求出大概nlogn个有用的对 那么将这些对按照右端点排序, 查询也按照右端点排序就可以离线维护信息 然后需要维 ...