memcache
安裝
wget http://www.memcached.org/files/memcached-1.4.25.tar.gz
tar xf memcached-1.4.25.tar.gz
./configure && make && make test && sudo make install && echo ok
注意:
memcache依賴libevent 安裝前需要先安裝 libevent
yum install -y libevent-devel
或者
sudo apt-get install libevent-dev
運行
memcached -d -m 10 -c 256參數說明: -d 是啓動一個守護進程 -m 是分配給Memcache使用的內存數量，單位是MB -u 是運行Memcache的用戶 -l 是監聽的服務器IP地址,默認爲本地 -p 是設置Memcache監聽的端口,最好是1024以上的端口,默認是11211 -c 選項是最大運行的併發連接數，默認是1024，按照你服務器的負載量來設定 -P 是設置保存Memcache的pid文件python-memcached模塊安裝:
pip install python-memcached
連接 memcache
import memcache
mc = memcache.Client(['127.0.0.1:11211'], debug=True)
mc.set("foo", "bar") #設置一個值 ,若此時鍵foo已存在和替換
mc.set_multi({'k1': 'v1', 'k2': 'v2'}) #設置多個值,若此時鍵foo已存在和替換
print mc.get('foo') #獲得一個值
print mc.get_multi(["k1","k2"]) #獲取多個值
mc.add('k1', 'v1') # 此時k1 已存在,這裏會報異常
mc.replace('k1','999') #替換k1的值爲999
mc.append('k1', 'after') # 修改指定key的值，在該值 後面 追加內容
mc.prepend('k1', 'before') #修改指定key的值，在該值 前面 插入內容
mc.incr('k1') #自增，將Memcached中的某一個值增加 N （ N默認爲1 ）
mc.incr('k1', 10)
mc.decr('k1') #自減，將Memcached中的某一個值減少 N （ N默認爲1 ）
mc.decr('k1', 10)
mc.delete('k0') #刪除一個key
mc.delete_multi(['k1', 'key2']) #刪除多個key
print mc.replace("foo2","123")
# for i in dir(memcache.Client):print(i)特殊的gets 和 casgets和cas 用於解決數據衝突問題,即:
商城商品剩餘個數，假設改值保存在memcache中，product_count = 900
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 即可
本質上每次執行gets時，會從memcache中獲取一個自增的數字，通過cas去修改gets的值時，會攜帶之前獲取的自增值和memcache中的 自增值進行比較，如果相等，則可以提交，如果不想等，那表示在gets和cas執行之間，又有其他人執行了gets（獲取了緩衝的指定值）， 如此一來有可能出現非正常數據，則不允許修改。
python-memcached 支持集羣操作,原理是在內存中維護一個集羣列表,集羣中主機的權重和主機在列表中出現的次數成正比
即:
主機 權重
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"），那麼要執行一下步驟：
1.根據算法將 k1 轉換成一個數字
2.將數字和主機列表長度求餘數，得到一個值 N（ 0 <= N < 列表長度 ）
3.在主機列表中根據 第2步得到的值爲索引獲取主機，例如：host_list[N]
4. 連接 將第3步中獲取的主機，將 k1 = "v1" 放置在該服務器的內存中
代碼實現如下：
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')
#################################################################
redis
安裝
wget http://download.redis.io/releases/redis-3.0.0.tar.gz
cd /usr/local/
mv redis-3.0.0/ redis
cd redis/
make
make install
cd utils
./install_server.sh
welcome to the redis service installer
This script will help you easily set up a running redis server
Please select the redis port for this instance: [6379]
Selecting default: 6379
Please select the redis config file name [/etc/redis/6379.conf]
Selected default - /etc/redis/6379.conf
Please select the redis log file name [/var/log/redis_6379.log]
Selected default - /var/log/redis_6379.log
Please select the data directory for this instance [/var/lib/redis/6379] /opt/redis/6379
Please select the redis executable path [/usr/local/bin/redis-server]
Selected config:
Port : 6379
Config file : /etc/redis/6379.conf
Log file : /var/log/redis_6379.log
Data dir : /opt/redis/6379
Executable : /usr/local/bin/redis-server
Cli Executable : /usr/local/bin/redis-cli
Is this ok? Then press ENTER to go on or Ctrl-C to abort.
Copied /tmp/6379.conf => /etc/init.d/redis_6379
Installing service...
Successfully added to chkconfig!
Successfully added to runlevels 345!
Starting Redis server...
Installation successful!
啓停
redis-server /etc/redis.conf #啓動
redis-cli shutdown #停止
python的redis模塊安裝
sudo pip install redis
常用操作
1、操作模式
redis-py提供兩個類Redis和StrictRedis用於實現Redis的命令，StrictRedis用於實現大部分官方的命令，並使用官方的語法和命令，Redis是StrictRedis的子類，用於向後兼容舊版本的redis-py。
import redis
r= redis.Redis(host='127.0.0.1',port=6379)
r.set("k1","v1")
print r.get("k1")2.redis模塊的連接池
redis-模塊使用connection pool來管理對一個redis server的所有連接，避免每次建立、釋放連接的開銷。默認，每個Redis實例都會維護一個自己的連接池。可以直接建立一個連接池，然後作爲參數 Redis，這樣就可以實現多個Redis實例共享一個連接池。
import redis
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.Redis(connection_pool=pool)
r.set('foo', 'Bar')
print r.get('foo')3 .redis模塊的管道
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)
r.set('name', 'alex')
r.set('role', 'sb')
pipe.execute()4 發佈和訂閱
#!/usr/bin/env python # -*- coding:utf-8 -*- # filename : redisHelper.py import redis class RedisHelper: def __init__(self): self.__conn = redis.Redis(host='10.211.55.4') 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
#!/usr/bin/env python # -*- coding:utf-8 -*- #filename : getInfo.py 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 -*-
# filename : sendInfo.py
from monitor.RedisHelper import RedisHelper
obj = RedisHelper()
obj.public('hello')####################################################
rabbitMQ
MQ全稱爲Message Queue, 消息隊列（MQ）是一種應用程序對應用程序的通信方法。應用程序通過讀寫出入隊列的消息（針對應用程序的數據）來通信，而無需專用連接來鏈接它們。消 息傳遞指的是程序之間通過在消息中發送數據進行通信，而不是通過直接調用彼此來通信，直接調用通常是用於諸如遠程過程調用的技術。排隊指的是應用程序通過 隊列來通信。隊列的使用除去了接收和發送應用程序同時執行的要求。
RabbitMQ是一個開源的AMQP實現，服務器端用Erlang語言編寫，支持多種客戶端，如：Python、Ruby、.NET、Java、 JMS、C、PHP、ActionScript、XMPP、STOMP等，支持AJAX。用於在分佈式系統中存儲轉發消息，在易用性、擴展性、高可用性等 方面表現不俗。
AMQP，即Advanced Message Queuing Protocol，高級消息隊列協議，是應用層協議的一個開放標準，爲面向消息的中間件設計。消息中間件主要用於組件之間的解耦，消息的發送者無需知道消息使用者的存在，反之亦然。
AMQP的主要特徵是面向消息、隊列、路由（包括點對點和發佈/訂閱）、可靠性、安全。
安裝
安裝配置epel源 $ rpm -ivh http://dl.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm安裝erlang $ yum -y install erlang安裝RabbitMQ $ yum -y install rabbitmq-serverpython通過pika模塊來操作rabbitMQ
安裝pika
sudo pip install pika
pika的使用
對於RabbitMQ來說，生產和消費不再針對內存裏的一個Queue對象，而是某臺服務器上的RabbitMQ Server實現的消息隊列。
#!/usr/bin/env python
# filename : prod.py
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')
channel.basic_publish(exchange='',
routing_key='hello',
body='Hello World!')
print(" [x] Sent 'Hello World!'")
connection.close()#!/usr/bin/env python
#filename : cust.py
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(
host='localhost'))
channel = connection.channel()
channel.queue_declare(queue='hello')
def callback(ch, method, properties, body):
print(" [x] Received %r" % body)
channel.basic_consume(callback,
queue='hello',
no_ack=True)
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()1、acknowledgment 消息不丟失
在消費者中 如果 no-ack ＝ False，如果生產者遇到情況(its channel is closed, connection is closed, or TCP connection is lost)掛掉了，那麼，RabbitMQ會重新將該任務添加到隊列中。
2. durable 消息不丟失 (這裏忘記咋回事了,回頭在補一下)
#!/usr/bin/env python
import pika
connection = pika.BlockingConnection(pika.ConnectionParameters(host='10.211.55.4'))
channel = connection.channel()
# make message persistent
channel.queue_declare(queue='hello', durable=True)
channel.basic_publish(exchange='',
routing_key='hello',
body='Hello World!',
properties=pika.BasicProperties(
delivery_mode=2, # make message persistent
))
print(" [x] Sent 'Hello World!'")
connection.close()#!/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', durable=True)
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_consume(callback,
queue='hello',
no_ack=False)
print(' [*] Waiting for messages. To exit press CTRL+C')
channel.start_consuming()3. 消息的獲取順序
默認消息隊列裏的數據是按照順序被消費者拿走，例如：消費者1 去隊列中獲取 奇數 序列的任務，消費者2去隊列中獲取 偶數 序列的任務。
channel.basic_qos(prefetch_count=1) 表示誰來誰取，不再按照奇偶數排列
4、發佈訂閱
發佈訂閱和簡單的消息隊列區別在於，發佈訂閱會將消息發送給所有的訂閱者，而消息隊列中的數據被消費一次便消失。所以，RabbitMQ實現發佈和訂閱時，會爲每一個訂閱者創建一個隊列，而發佈者發佈消息時，會將消息放置在所有相關隊列中。
exchange type = fanout
5、關鍵字發送
exchange type = direct
之前事例，發送消息時明確指定某個隊列並向其中發送消息，RabbitMQ還支持根據關鍵字發送，即：隊列綁定關鍵字，發送者將數據根據關鍵字發送到消息exchange，exchange根據 關鍵字 判定應該將數據發送至指定隊列。
6、模糊匹配
exchange type = topic
在topic類型下，可以讓隊列綁定幾個模糊的關鍵字，之後發送者將數據發送到exchange，exchange將傳入”路由值“和 ”關鍵字“進行匹配，匹配成功，則將數據發送到指定隊列。
# 表示可以匹配 0 個 或 多個 單詞
* 表示只能匹配 一個 單詞
發送者路由值 隊列中old.boy.python old.* -- 不匹配old.boy.python old.# -- 匹配#######################################################################
SQLAlchemy是Python編程語言下的一款ORM框架,提供了SQL工具包及對象關係映射（ORM）工具，使用MIT許可證發行。，該框架建立在數據庫API之上，使用關係對象映射進行數據庫操作，簡言之便是：將對象轉換成SQL，然後使用數據API執行SQL並獲取執行結果。
SQLAlchemy 的一個目標是提供能兼容衆多數據庫（如 SQLite、MySQL、Postgres、Oracle、MS-SQL、SQLServer 和 Firebird）的企業級持久性模型。
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...]步驟一：
使用 Engine/ConnectionPooling/Dialect 進行數據庫操作，Engine使用ConnectionPooling連接數據庫，然後再通過Dialect執行SQL語句。
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from sqlalchemy import create_engine
engine = create_engine("mysql+mysqldb://root:[email protected]:3306/s11", max_overflow=5)
engine.execute(
"INSERT INTO ts_test (a, b) VALUES ('2', 'v1')"
)
engine.execute(
"INSERT INTO ts_test (a, b) VALUES (%s, %s)",
((555, "v1"),(666, "v1"),)
)
engine.execute(
"INSERT INTO ts_test (a, b) VALUES (%(id)s, %(name)s)",
id=999, name="v1"
)
result = engine.execute('select * from ts_test')
result.fetchall()事務操作
from sqlalchemy import create_engine
engine = create_engine("mysql+mysqldb://root:[email protected]:3306/s11", max_overflow=5)
# 事務操作
with engine.begin() as conn:
conn.execute("insert into table (x, y, z) values (1, 2, 3)")
conn.execute("my_special_procedure(5)")
conn = engine.connect()
# 事務操作
with conn.begin():
conn.execute("some statement", {'x':5, 'y':10})步驟二：
使用 Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 進行數據庫操作。Engine使用Schema Type創建一個特定的結構對象，之後通過SQL Expression Language將該對象轉換成SQL語句，然後通過 ConnectionPooling 連接數據庫，再然後通過 Dialect 執行SQL，並獲取結果。
from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKey
metadata = MetaData()
user = Table('user', metadata,
Column('id', Integer, primary_key=True),
Column('name', String(20)),
)
color = Table('color', metadata,
Column('id', Integer, primary_key=True),
Column('name', String(20)),
)
engine = create_engine("mysql+mysqldb://root:[email protected]:3306/s11", max_overflow=5)
metadata.create_all(engine)from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKey
metadata = MetaData()
user = Table('user', metadata,
Column('id', Integer, primary_key=True),
Column('name', String(20)),
)
color = Table('color', metadata,
Column('id', Integer, primary_key=True),
Column('name', String(20)),
)
engine = create_engine("mysql+mysqldb://root:[email protected]:3306/s11", max_overflow=5)
conn = engine.connect()
# 創建SQL語句，INSERT INTO "user" (id, name) VALUES (:id, :name)
conn.execute(user.insert(),{'id':7,'name':'seven'})
conn.close()
# sql = user.insert().values(id=123, name='wu')
# conn.execute(sql)
# conn.close()
# sql = user.delete().where(user.c.id > 1)
# sql = user.update().values(fullname=user.c.name)
# sql = user.update().where(user.c.name == 'jack').values(name='ed')
# sql = select([user, ])
# sql = select([user.c.id, ])
# sql = select([user.c.name, color.c.name]).where(user.c.id==color.c.id)
# sql = select([user.c.name]).order_by(user.c.name)
# sql = select([user]).group_by(user.c.name)
# result = conn.execute(sql)
# print result.fetchall()
# conn.close()注：SQLAlchemy無法修改表結構，如果需要可以使用SQLAlchemy開發者開源的另外一個軟件Alembic來完成。
步驟三：
使用 ORM/Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 所有組件對數據進行操作。根據類創建對象，對象轉換成SQL，執行SQL。
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
engine = create_engine("mysql+mysqldb://root:[email protected]:3306/s11", max_overflow=5)
Base = declarative_base()
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String(50))
# 尋找Base的所有子類，按照子類的結構在數據庫中生成對應的數據表信息
# Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()
# ########## 增 ##########
# u = User(id=2, name='sb')
# session.add(u)
# session.add_all([
# User(id=3, name='sb'),
# User(id=4, name='sb')
# ])
# session.commit()
# ########## 刪除 ##########
# session.query(User).filter(User.id > 2).delete()
# session.commit()
# ########## 修改 ##########
# session.query(User).filter(User.id > 2).update({'cluster_id' : 0})
# session.commit()
# ########## 查 ##########
# ret = session.query(User).filter_by(name='sb').first()
# ret = session.query(User).filter_by(name='sb').all()
# print ret
# ret = session.query(User).filter(User.name.in_(['sb','bb'])).all()
# print ret
# ret = session.query(User.name.label('name_label')).all()
# print ret,type(ret)
# ret = session.query(User).order_by(User.id).all()
# print ret
# ret = session.query(User).order_by(User.id)[1:3]
# print ret
# session.commit()所有的知識都在這裏,你懂得:
http://www.cnblogs.com/wupeiqi/articles/5132791.html
這次寫特地查了好多資料.昨天半夜突然發現之前寫的內容全都不見了,也怪自己沒保存草稿,...........