Python操作mysql之pymysql
pymsql是Python中操作MySQL的模块,其使用方法和MySQLdb几乎相同。
1、执行SQL
#!/usr/bin/env python # -*- coding:utf-8 -*- import pymysql # 创建连接 conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1') # 创建游标 cursor = conn.cursor() # 执行SQL,并返回收影响行数 effect_row = cursor.execute("update hosts set host = '1.1.1.2'") # 执行SQL,并返回受影响行数 #effect_row = cursor.execute("update hosts set host = '1.1.1.2' where nid > %s", (1,)) # 执行SQL,并返回受影响行数 #effect_row = cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)]) # 提交,不然无法保存新建或者修改的数据 conn.commit() # 关闭游标 cursor.close() # 关闭连接 conn.close()
2、获取新创建数据自增ID
#!/usr/bin/env python # -*- coding:utf-8 -*- import pymysql conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1') cursor = conn.cursor() cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)]) conn.commit() cursor.close() conn.close() # 获取最新自增ID new_id = cursor.lastrowid
3、获取查询数据
#!/usr/bin/env python # -*- coding:utf-8 -*- import pymysql conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1') cursor = conn.cursor() cursor.execute("select * from hosts") # 获取第一行数据 row_1 = cursor.fetchone() # 获取前n行数据 # row_2 = cursor.fetchmany(3) # 获取所有数据 # row_3 = cursor.fetchall() conn.commit() cursor.close() conn.close()
注:在fetch数据时按照顺序进行,可以使用cursor.scroll(num,mode)来移动游标位置,如:
- cursor.scroll(1,mode='relative') # 相对当前位置移动
- cursor.scroll(2,mode='absolute') # 相对绝对位置移动
4、fetch数据类型
关于默认获取的数据是元祖类型,如果想要或者字典类型的数据,即:
#!/usr/bin/env python # -*- coding:utf-8 -*- import pymysql conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1') # 游标设置为字典类型 cursor = conn.cursor(cursor=pymysql.cursors.DictCursor) r = cursor.execute("call p1()") result = cursor.fetchone() conn.commit() cursor.close() conn.close()
Python操作mysql之MySQLdb
import MySQLdb
conn = MySQLdb.connect(host='', user='', passwd='', db='')
cur = conn.cursor()
reCount = cur.execute(sql)
conn.commit()
cur.close()
conn.close()
print reCount #返回的结果是被影响的行数
import MySQLdb conn = MySQLdb.connect(host='139.129.119.104', user='hy', passwd='hy', db='mydb') cur = conn.cursor() sql = '''create table UserInfo ( id int not null auto_increment primary key, name char(8) , sex char(4) , age tinyint unsigned , address char(20) , tel char(13) null default "-" ); ''' reCount = cur.execute(sql) conn.commit() cur.close() conn.close() print reCount
import MySQLdb conn = MySQLdb.connect(host='139.129.119.104', user='hy', passwd='hy', db='mydb') cur = conn.cursor() sql = 'insert into UserInfo(name,address) values(%s,%s)' reCount = cur.execute(sql,('alex','usa')) conn.commit() cur.close() conn.close() print reCount
import MySQLdb conn = MySQLdb.connect(host='139.129.119.104', user='hy', passwd='hy', db='mydb') cur = conn.cursor() li =[ ('alex','usa'), ('sb','usa'), ] sql = 'insert into UserInfo(name,address) values(%s,%s)' reCount = cur.executemany(sql,li) conn.commit() cur.close() conn.close() print reCount
import MySQLdb conn = MySQLdb.connect(host='139.129.119.104', user='hy', passwd='hy', db='mydb') cur = conn.cursor() sql = 'delete from UserInfo' reCount = cur.execute(sql) conn.commit() cur.close() conn.close() print reCount
import MySQLdb conn = MySQLdb.connect(host='139.129.119.104', user='hy', passwd='hy', db='mydb') cur = conn.cursor() sql = "update UserInfo set address = %s where name = 'sb'" reCount = cur.execute(sql,'chongqing') conn.commit() cur.close() conn.close() print reCount
import MySQLdb conn = MySQLdb.connect(host='139.129.119.104', user='hy', passwd='hy', db='mydb') cur = conn.cursor() sql_update_address1 = "update UserInfo set address = '%s' where name = 'sb'" % ('beijing') sql_select_address2 ="update UserInfo set address = '%s' where name = 'alex'" % ('shahe') try: reCount = cur.execute(sql_update_address1) reCount2 = cur.execute(sql_select_address2) conn.commit() except: conn.rollback() cur.close() conn.close() print reCount 事务
import MySQLdb conn = MySQLdb.connect(host='139.129.119.104', user='hy', passwd='hy', db='mydb') cur = conn.cursor() sql = 'select * from UserInfo' reCount = cur.execute(sql) nRet = cur.fetchall() conn.commit() cur.close() conn.close() # print reCount print nRet for i in nRet: print i[0],i[1],i[3]
Python操作mysql之SQLAchemy
SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象转换成SQL,然后使用数据API执行SQL并获取执行结果。
why SQLAlchemy
1.支持多种数据库,mysql,sqlserver,oracle...
2.原生sql语句复杂, SQLAlchemy提供简单的规则
3.自动转化sql语句,不负责连接(连接通过调用dbapi)
如何使用
pip install SQLAlchemy
连接mysql
MySQL-Python
mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
pymysql
mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
其它数据库连接方式
http://docs.sqlalchemy.org/en/latest/dialects/index.html
操作mysql
首先手动创建数据库和类,然后 SQLAlchemy通过api操作(增删改查)mysql
创建数据库
create database dbtest default charset utf8;
创建表 删除表
# coding:utf-8 __author__ = 'hy' from sqlalchemy import Column, Integer, String, create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker engine = create_engine("mysql+pymysql://root:root@127.0.0.1:3306/dbtest?charset=utf8", max_overflow=5) Base = declarative_base() class User(Base): # 表的名字: __tablename__ = 'user' # 表的结构: id = Column(Integer, primary_key=True, autoincrement=True) username = Column(String(32)) password = Column(String(32)) def init_table(): ''' 创建表 :return: ''' Base.metadata.create_all(engine) def drop_table(): ''' 删除表 :return: ''' Base.metadata.drop_all(engine)
增删改查
init_table() Session = sessionmaker(bind=engine) session = Session() new_user = User(username='hy', password='hypd') # 添加到session: session.add(new_user) session.add_all([ User(username="hy1", password='hy1pd'), User(username="hy2", password='hy2pd'), ]) # 提交即保存到数据库: session.commit() # 关闭session: session.close()
Session = sessionmaker(bind=engine) session = Session() new_user = User(username='hy', password='hypd') session.query(User).filter(User.id > 2).delete() # 提交即保存到数据库: session.commit() # 关闭session: session.close()
Session = sessionmaker(bind=engine) session = Session() session.query(User).filter(User.id).update({"username": "hybaba"}) session.query(User).filter_by(id='2').update({"username": "hy", "password": "hypw"}) # synchronize_session 基于原来字段,不同类型值不同 session.query(User).filter_by(id=2).update({User.username: User.username + "add2"}, synchronize_session=False) session.query(User).filter(User.id < 2).update({"id": User.id + 2}, synchronize_session="evaluate") # 提交即保存到数据库: session.commit() # 关闭session: session.close() 改
ret = session.query(User).all() ret = session.query(User.name, User.extra).all() ret = session.query(User).filter_by(name='alex').all() ret = session.query(User).filter_by(name='alex').first() ret = session.query(User).filter(text("id<:value and name=:name")).params(value=224, name='fred').order_by(User.id).all() ret = session.query(User).from_statement(text("SELECT * FROM User where name=:name")).params(name='ed').all()
Python操作mysql之peewee
同步peewee
官方文档 http://docs.peewee-orm.com/en/latest/
from datetime import datetime from peewee import * from peewee import Model db = MySQLDatabase('message', host="127.0.0.1", port=3306, user="root", password="root") class BaseModel(Model): add_time = DateTimeField(default=datetime.now, verbose_name="添加时间") class Meta: database = db # database class Supplier(BaseModel): name = CharField(max_length=100, verbose_name="名称", index=True) address = CharField(max_length=100, verbose_name="联系地址") phone = CharField(max_length=11, verbose_name="联系方式") class Meta: database = db table_name = "supplier" class Goods(BaseModel): supplier = ForeignKeyField(Supplier, verbose_name="商家", backref="goods") name = CharField(max_length=100, verbose_name="商品名称", index=True) click_num = IntegerField(default=0, verbose_name="点击数") goods_num = IntegerField(default=0, verbose_name="库存数") price = FloatField(default=0.0, verbose_name="价格") brief = TextField(verbose_name="商品简介") class Meta: table_name = "goods" def init_table(): db.create_tables([Goods, Supplier]) if __name__ == "__main__": init_table()
supplier_list = [ { "name":"淘宝", "address":"杭州市", "phone":"18888888888" }, { "name":"京东", "address":"上海市", "phone":"17777777777" }, { "name":"天猫", "address":"北京市", "phone":"16666666666" } ] goods_list = [ { "supplier":6, "name": "52度茅台集团国隆双喜酒500mlx6", "click_num": 100, "goods_num": 666, "price": 128, "brief": "贵州茅台酒厂(集团)保健酒业有限公司生产,是以“龙”字打头的酒水。中国龙文化上下8000年,源远而流长,龙的形象是一种符号、一种意绪、一种血肉相联的情感。" }, { "supplier":7, "name": "52度水井坊臻酿八號500ml", "click_num": 585, "goods_num": 288, "price": 36, "brief": "贵州茅台酒厂(集团)保健酒业有限公司生产,是以“龙”字打头的酒水。中国龙文化上下8000年,源远而流长,龙的形象是一种符号、一种意绪、一种血肉相联的情感。" }, { "supplier":8, "name": "53度茅台仁酒500ml", "click_num": 553, "goods_num": 280, "price": 190, "brief": "贵州茅台酒厂(集团)保健酒业有限公司生产,是以“龙”字打头的酒水。中国龙文化上下8000年,源远而流长,龙的形象是一种符号、一种意绪、一种血肉相联的情感。" }, { "supplier":6, "name": "茅台53度飞天茅台500ml", "click_num": 48, "goods_num": 20, "price": 22, "brief": "贵州茅台酒厂(集团)保健酒业有限公司生产,是以“龙”字打头的酒水。中国龙文化上下8000年,源远而流长,龙的形象是一种符号、一种意绪、一种血肉相联的情感。" }, { "supplier":7, "name": "芝华士12年苏格兰威士忌700ml", "click_num": 31, "goods_num": 15, "price": 88, "brief": "贵州茅台酒厂(集团)保健酒业有限公司生产,是以“龙”字打头的酒水。中国龙文化上下8000年,源远而流长,龙的形象是一种符号、一种意绪、一种血肉相联的情感。" } ]
from models.model import Supplier from data import supplier_list for data in supplier_list: supplier = Supplier() supplier.name = data["name"] supplier.address = data["address"] supplier.phone = data["phone"] supplier.save()
from models.model import Goods from data import goods_list for data in goods_list: good = Goods(**data) good.save()
from models.model import Goods try: good = Goods.get_by_id(1) good.click_num += 1 good.save() good.delete_instance() except Goods.DoesNotExist: pass # delete from goods where price>150 Goods.delete().where(Goods.price > 150).execute()
from models.model import Goods try: good = Goods.get_by_id(1) good.click_num += 1 good.save() except Goods.DoesNotExist: pass # update click_num=100 where id =1 Goods.update(click_num=Goods.click_num+1).where(Goods.id==1).execute()
from models.model import Goods # 获取某一条数据 good = Goods.get(Goods.id==2) # good = Goods.get_by_id(1) good = Goods[1] # select 返回的是modelselect对象 # 获取所有数据 # select price from goods goods = Goods.select(Goods.name, Goods.price) # select * from goods where price > 100 goods = Goods.select().where(Goods.price > 100) # select * from goods where price>100 and click_num>200 goods = Goods.select().where((Goods.price > 100) | (Goods.click_num > 200)) # select * from goods where name like "%飞天" goods = Goods.select().where(Goods.name.contains("飞天")) goods = Goods.select().where(Goods.id << [1, 3]) goods = Goods.select().where((Goods.id == 1) | (Goods.id == 3)) goods = Goods.select().where((Goods.id.in_([1, 3]))) # select * from goods where price>click_num goods = Goods.select().where(Goods.price > Goods.click_num) # 排序 select * from goods order by price desc goods = Goods.select().order_by(Goods.price.asc()) goods = Goods.select().order_by(Goods.price) # 分页 goods = Goods.select().order_by(Goods.price).paginate(2, 2) for good in goods: print(good.price)
总结:增删改查操作,有两种语法,一种基于对象的多条语句(Models.field 操作符 ...;object.save/delete_instance),一种基于类的单一语句(Models.(create/delete/update/select).execute())
异步peewee
官方文档 https://peewee-async.readthedocs.io/en/latest/
from datetime import datetime from peewee import * from peewee import Model import peewee_async # db = MySQLDatabase('message', host="127.0.0.1", port=3306, user="root", password="root") database = peewee_async.MySQLDatabase( 'message', host="127.0.0.1", port=3306, user="root", password="root" ) objects = peewee_async.Manager(database) # No need for sync anymore! database.set_allow_sync(False) class BaseModel(Model): add_time = DateTimeField(default=datetime.now, verbose_name="添加时间") class Meta: database = database class Supplier(BaseModel): name = CharField(max_length=100, verbose_name="名称", index=True) address = CharField(max_length=100, verbose_name="联系地址") phone = CharField(max_length=11, verbose_name="联系方式") class Meta: database = database table_name = "supplier" class Goods(BaseModel): supplier = ForeignKeyField(Supplier, verbose_name="商家") name = CharField(max_length=100, verbose_name="商品名称", index=True) click_num = IntegerField(default=0, verbose_name="点击数") goods_num = IntegerField(default=0, verbose_name="库存数") price = FloatField(default=0.0, verbose_name="价格") brief = TextField(verbose_name="商品简介") class Meta: table_name = "goods" def init_table(): database.create_tables([Goods, Supplier]) if __name__ == "__main__": init_table()
import asyncio from models.model import Goods from models.model import objects async def handler(): # 创建记录 # await objects.create(Goods, supplier_id=7, name="53度水井坊臻酿八號500ml", # click_num=20, goods_num=1000, price=500, brief="州茅台酒厂(集团)保健酒业有限公司生产") # 查询记录 goods = await objects.execute(Goods.select()) for good in goods: print(good.name) loop = asyncio.get_event_loop() loop.run_until_complete(handler()) # loop.close()
Python操作Redis
Linux:yum install python-redis #pip等方式也可以安装
Pycharm:安装redis模块
API使用
redis-py 的API的使用可以分类为:
连接池
操作
String 操作
Hash 操作
List 操作
Set 操作
Sort Set 操作
管道
发布订阅
1、操作模式
redis-py提供两个类Redis和StrictRedis用于实现Redis的命令,StrictRedis用于实现大部分官方的命令,并使用官方的语法和命令,Redis是StrictRedis的子类,用于向后兼容旧版本的redis-py。
import redis r = redis.Redis(host='ip',port=6379,password='') r.set('foo', 'Bar') print r.get('foo')
2、连接池
redis-py使用connection pool来管理对一个redis server的所有连接,避免每次建立、释放连接的开销。默认,每个Redis实例都会维护一个自己的连接池。可以直接建立一个连接池,然后作为参数Redis,这样就可以实现多个Redis实例共享一个连接池。
import redis pool = redis.ConnectionPool(host='ip',password='') r = redis.Redis(connection_pool=pool) r.set('foo2', 'Bar2') print r.get('foo2')
3、操作
redis中的String在在内存中按照一个name对应一个value来存储。 set(name, value, ex=None, px=None, nx=False, xx=False) #在Redis中设置值,默认,不存在则创建,存在则修改 #参数: ex,过期时间(秒) px,过期时间(毫秒) nx,如果设置为True,则只有name不存在时,当前set操作才执行 xx,如果设置为True,则只有name存在时,岗前set操作才执行 mset(*args, **kwargs) #批量设置值 #如: mset(k1='v1', k2='v2') 或 mget({'k1': 'v1', 'k2': 'v2'}) get(name) #获取值 mget(keys, *args) #批量获取 #如: mget('ylr', 'wupeiqi') 或 r.mget(['ylr', 'wupeiqi']) getset(name, value) 设置新值并获取原来的值 setrange(name, offset, value) # 修改字符串内容,从指定字符串索引开始向后替换(新值太长时,则向后添加) # 参数: # offset,字符串的索引,字节(一个汉字三个字节) # value,要设置的值 getrange(key, start, end) # 获取子序列(根据字节获取,非字符) # 参数: # name,Redis 的 name # start,起始位置(字节) # end,结束位置(字节) strlen(name) # 返回name对应值的字节长度(一个汉字3个字节) ncr(self, name, amount=1) # 自增 name对应的值,当name不存在时,则创建name=amount,否则,则自增。 # 参数: # name,Redis的name # amount,自增数(必须是整数) decr(self, name, amount=1) # 自减 name对应的值,当name不存在时,则创建name=amount,否则,则自减。 # 参数: # name,Redis的name # amount,自减数(整数)
Hash操作,redis中的Hash在在内存中按照一个name对应一个key,value来存储。 hset(name, key, value) # name对应的hash中设置一个键值对(不存在,则创建;否则,修改) # 参数: # name,redis的name # key,name对应的hash中的key # value,name对应的hash中的value # 注: # hsetnx(name, key, value),当name对应的hash中不存在当前key时则创建(相当于添加) hmset(name, mapping) # 在name对应的hash中批量设置键值对 # 参数: # name,redis的name # mapping,字典,如:{'k1':'v1', 'k2': 'v2'} # 如: # r.hmset('xx', {'k1':'v1', 'k2': 'v2'}) hget(name,key) # 在name对应的hash中获取根据key获取value hmget(name, keys, *args) # 在name对应的hash中获取多个key的值 # 参数: # name,reids对应的name # keys,要获取key集合,如:['k1', 'k2', 'k3'] # *args,要获取的key,如:k1,k2,k3 # 如: # r.mget('xx', ['k1', 'k2']) # 或 # print r.hmget('xx', 'k1', 'k2') hgetall(name) 获取name对应hash的所有键值 hlen(name) # 获取name对应的hash中键值对的个数 hkeys(name) # 获取name对应的hash中所有的key的值 hvals(name) # 获取name对应的hash中所有的value的值 hexists(name, key) # 检查name对应的hash是否存在当前传入的key hdel(name,*keys) # 将name对应的hash中指定key的键值对删除 hincrby(name, key, amount=1) # 自增name对应的hash中的指定key的值,不存在则创建key=amount # 参数: # name,redis中的name # key, hash对应的key # amount,自增数(整数) hscan(name, cursor=0, match=None, count=None) # 增量式迭代获取,对于数据大的数据非常有用,hscan可以实现分片的获取数据,并非一次性将数据全部获取完,从而放置内存被撑爆 # 参数: # name,redis的name # cursor,游标(基于游标分批取获取数据) # match,匹配指定key,默认None 表示所有的key # count,每次分片最少获取个数,默认None表示采用Redis的默认分片个数 # 如: # 第一次:cursor1, data1 = r.hscan('xx', cursor=0, match=None, count=None) # 第二次:cursor2, data1 = r.hscan('xx', cursor=cursor1, match=None, count=None) # ... # 直到返回值cursor的值为0时,表示数据已经通过分片获取完毕 Hash操作
List操作,redis中的List在内存中按照一个name对应一个List来存储。 lpush(name,values) # 在name对应的list中添加元素,每个新的元素都添加到列表的最左边 # 如: # r.lpush('oo', 11,22,33) # 保存顺序为: 33,22,11 # 扩展: # rpush(name, values) 表示从右向左操作 llen(name) # name对应的list元素的个数 linsert(name, where, refvalue, value)) # 在name对应的列表的某一个值前或后插入一个新值 # 参数: # name,redis的name # where,BEFORE或AFTER # refvalue,标杆值,即:在 r.lset(name, index, value) # 对name对应的list中的某一个索引位置重新赋值 # 参数: # name,redis的name # index,list的索引位置 # value,要设置的值 r.lrem(name, value, num) # 在name对应的list中删除指定的值 # 参数: # name,redis的name # value,要删除的值 # num, num=0,删除列表中所有的指定值; # num=2,从前到后,删除2个; # num=-2,从后向前,删除2个 lpop(name) # 在name对应的列表的左侧获取第一个元素并在列表中移除,返回值则是第一个元素 # 更多: # rpop(name) 表示从右向左操作 lindex(name, index) 在name对应的列表中根据索引获取列表元素 lrange(name, start, end) # 在name对应的列表分片获取数据 # 参数: # name,redis的name # start,索引的起始位置 # end,索引结束位置 ltrim(name, start, end) # 在name对应的列表中移除没有在start-end索引之间的值 # 参数: # name,redis的name # start,索引的起始位置 # end,索引结束位置 List操作
sadd(name,values) # name对应的集合中添加元素 scard(name) 获取name对应的集合中元素个数 sdiff(keys, *args) 在第一个name对应的集合中且不在其他name对应的集合的元素集合 sdiffstore(dest, keys, *args) # 获取第一个name对应的集合中且不在其他name对应的集合,再将其新加入到dest对应的集合中 sinter(keys, *args) # 获取多一个name对应集合的并集 sinterstore(dest, keys, *args) # 获取多一个name对应集合的并集,再讲其加入到dest对应的集合中 sismember(name, value) # 检查value是否是name对应的集合的成员 smembers(name) # 获取name对应的集合的所有成员 smove(src, dst, value) # 将某个成员从一个集合中移动到另外一个集合 spop(name) # 从集合的右侧(尾部)移除一个成员,并将其返回 srandmember(name, numbers) # 从name对应的集合中随机获取 numbers 个元素 srem(name, values) # 在name对应的集合中删除某些值 sunion(keys, *args) # 获取多一个name对应的集合的并集 sunionstore(dest,keys, *args) # 获取多一个name对应的集合的并集,并将结果保存到dest对应的集合中 sscan(name, cursor=0, match=None, count=None) sscan_iter(name, match=None, count=None) # 同字符串的操作,用于增量迭代分批获取元素,避免内存消耗太大
有序集合,在集合的基础上,为每元素排序;元素的排序需要根据另外一个值来进行比较,所以,对于有序集合,每一个元素有两个值,即:值和分数,分数专门用来做排序。 zadd(name, *args, **kwargs) # 在name对应的有序集合中添加元素 # 如: # zadd('zz', 'n1', 1, 'n2', 2) # 或 # zadd('zz', n1=11, n2=22) zcard(name) # 获取name对应的有序集合元素的数量 zcount(name, min, max) # 获取name对应的有序集合中分数 在 [min,max] 之间的个数 zincrby(name, value, amount) # 自增name对应的有序集合的 name 对应的分数 r.zrange( name, start, end, desc=False, withscores=False, score_cast_func=float) # 按照索引范围获取name对应的有序集合的元素 # 参数: # name,redis的name # start,有序集合索引起始位置(非分数) # end,有序集合索引结束位置(非分数) # desc,排序规则,默认按照分数从小到大排序 # withscores,是否获取元素的分数,默认只获取元素的值 # score_cast_func,对分数进行数据转换的函数 # 更多: # 从大到小排序 # zrevrange(name, start, end, withscores=False, score_cast_func=float) # 按照分数范围获取name对应的有序集合的元素 # zrangebyscore(name, min, max, start=None, num=None, withscores=False, score_cast_func=float) # 从大到小排序 # zrevrangebyscore(name, max, min, start=None, num=None, withscores=False, score_cast_func=float) zrank(name, value) # 获取某个值在 name对应的有序集合中的排行(从 0 开始) # 更多: # zrevrank(name, value),从大到小排序 zrangebylex(name, min, max, start=None, num=None) # 当有序集合的所有成员都具有相同的分值时,有序集合的元素会根据成员的 值 (lexicographical ordering)来进行排序,而这个命令则可以返回给定的有序集合键 key 中, 元素的值介于 min 和 max 之间的成员 # 对集合中的每个成员进行逐个字节的对比(byte-by-byte compare), 并按照从低到高的顺序, 返回排序后的集合成员。 如果两个字符串有一部分内容是相同的话, 那么命令会认为较长的字符串比较短的字符串要大 # 参数: # name,redis的name # min,左区间(值)。 + 表示正无限; - 表示负无限; ( 表示开区间; [ 则表示闭区间 # min,右区间(值) # start,对结果进行分片处理,索引位置 # num,对结果进行分片处理,索引后面的num个元素 # 如: # ZADD myzset 0 aa 0 ba 0 ca 0 da 0 ea 0 fa 0 ga # r.zrangebylex('myzset', "-", "[ca") 结果为:['aa', 'ba', 'ca'] # 更多: # 从大到小排序 # zrevrangebylex(name, max, min, start=None, num=None) zrem(name, values) # 删除name对应的有序集合中值是values的成员 # 如:zrem('zz', ['s1', 's2']) zremrangebyrank(name, min, max) # 根据排行范围删除 zremrangebyscore(name, min, max) # 根据分数范围删除 zremrangebylex(name, min, max) # 根据值返回删除 zscore(name, value) # 获取name对应有序集合中 value 对应的分数 zinterstore(dest, keys, aggregate=None) # 获取两个有序集合的交集,如果遇到相同值不同分数,则按照aggregate进行操作 # aggregate的值为: SUM MIN MAX zunionstore(dest, keys, aggregate=None) # 获取两个有序集合的并集,如果遇到相同值不同分数,则按照aggregate进行操作 # aggregate的值为: SUM MIN MAX zscan(name, cursor=0, match=None, count=None, score_cast_func=float) zscan_iter(name, match=None, count=None,score_cast_func=float) # 同字符串相似,相较于字符串新增score_cast_func,用来对分数进行操作
4、管道
redis-py默认在执行每次请求都会创建(连接池申请连接)和断开(归还连接池)一次连接操作,如果想要在一次请求中指定多个命令,则可以使用pipline实现一次请求指定多个命令,并且默认情况下一次pipline 是原子性操作。
#!/usr/bin/env python # -*- coding:utf-8 -*- import redis pool = redis.ConnectionPool(host='ip', port=6379,password='') 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()
5.其他操作
delete(*names) # 根据删除redis中的任意数据类型 exists(name) # 检测redis的name是否存在 keys(pattern='*') # 根据模型获取redis的name # 更多: # KEYS * 匹配数据库中所有 key 。 # KEYS h?llo 匹配 hello , hallo 和 hxllo 等。 # KEYS h*llo 匹配 hllo 和 heeeeello 等。 # KEYS h[ae]llo 匹配 hello 和 hallo ,但不匹配 hillo expire(name ,time) # 为某个redis的某个name设置超时时间 rename(src, dst) # 对redis的name重命名为 move(name, db)) # 将redis的某个值移动到指定的db下 randomkey() # 随机获取一个redis的name(不删除) type(name) # 获取name对应值的类型 scan(cursor=0, match=None, count=None) scan_iter(match=None, count=None) # 同字符串操作,用于增量迭代获取key
6.发布与订阅
r = redis.Redis(host='',password='') r.publish('fm88.7','do you knwo who am i ? ? ') r.publish('fm88.7','i am a publisher')
#!/usr/bin/env python # -*- coding:utf-8 -*- import redis def subscribe(): conn = redis.Redis(host='', password='redis') pub = conn.pubsub() # 打开收音机 pub.subscribe('fm88.7') # 调到那个频道 pub.parse_response() # 准备听 return pub redis_sub = subscribe() while True: msg = redis_sub.parse_response() print msg ############输出########### ['message', 'fm88.7', 'do you know who am i ?'] ['message', 'fm88.7', 'i am a publisher']
python操作mongo
pymongo 提供了mongdb和python交互的所有方法 安装方式: pip install pymongo 导入pymongo并选择要操作的集合 数据库和集合乜有会自动创建 from pymongo import MongoClient client = MongoClient(host,port) collection = client[db名][集合名] 添加一条数据 ret = collection.insert_one({"name":"test10010","age":33}) print(ret) 添加多条数据 item_list = [{"name":"test1000{}".format(i)} for i in range(10)] #insert_many接收一个列表,列表中为所有需要插入的字典 t = collection.insert_many(item_list) 查找一条数据 #find_one查找并且返回一个结果,接收一个字典形式的条件 t = collection.find_one({"name":"test10005"}) print(t) 查找全部数据 结果是一个Cursor游标对象,是一个可迭代对象,可以类似读文件的指针,但是只能够进行一次读取 #find返回所有满足条件的结果,如果条件为空,则返回数据库的所有 t = collection.find({"name":"test10005"}) #结果是一个Cursor游标对象,是一个可迭代对象,可以类似读文件的指针, for i in t: print(i) for i in t: #此时t中没有内容 print(i)’ 更新一条数据 注意使用$set命令 #update_one更新一条数据 collection.update_one({"name":"test10005"},{"$set":{"name":"new_test10005"}}) 更行全部数据 # update_one更新全部数据 collection.update_many({"name":"test10005"},{"$set":{"name":"new_test10005"}}) 删除一条数据 #delete_one删除一条数据 collection.delete_one({"name":"test10010"}) 删除全部数据 #delete_may删除所有满足条件的数据 collection.delete_many({"name":"test10010"}) 事务 conn = pymongo.MongoClient("mongo服务ip", 27017) t1 = conn["test"]['t1'] t2 = conn["test"]['t2'] with conn.start_session(causal_consistency=True) as session: """事物必须在session下执行,with保证了session的正常关闭""" with session.start_transaction(): """一旦出现异常会自动调用session.abort_transaction()""" t1.insert_one(document={"city": "beijing"}, session=session) # 注意多了session这个参数 raise Exception("haha") # 制造一个错误, t1和t2的插入都不会成功. t2.insert_one(document={"city": "tianjin"}, session=session)