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()
View Code
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
View Code
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()
View Code
注:在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()
View Code
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)
View Code
增删改查
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年,源远而流长,龙的形象是一种符号、一种意绪、一种血肉相联的情感。"
}
]
data.py
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()
异步models
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()
异步peewee语法
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,自减数(整数)
String操作
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操作
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操作
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)
# 同字符串的操作,用于增量迭代分批获取元素,避免内存消耗太大
set操作
有序集合,在集合的基础上,为每元素排序;元素的排序需要根据另外一个值来进行比较,所以,对于有序集合,每一个元素有两个值,即:值和分数,分数专门用来做排序。
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,用来对分数进行操作
zset操作
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()
pipe
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
View Code
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)
谢谢