python【第九篇】操作数据库

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)




 




 


 


 


 


 


 


 


 


 


 


 


 


 


 


 







            

            
posted @ 
2017-03-25 18:34 
沐风先生 
阅读(346) 
评论(0) 
编辑 
收藏 
举报