redis
mysql,redis,mogondb
1.mysql,oracle:关系型数据库,有表概念
2.redis,mongodb/nosql:非关系型数据库
没有表概念
mongodb存储在硬盘上
redis存储在内存中
用途:1.做缓存
2.session
3.游戏排行榜
4.对速度要求比较高的数据存储
5.做消息队列
redis是key-value的存储,像python中的字典
比较redis和memcached
1.有5大数据类型:
字符串,字典,集合,列表,有序集合
2.支持持久化
3.单线程,单进程(瞬时并发量可以达到10万),速度非常快
(memcached只支持字符串,不支持持久化,多线程,多进程)
字符串操作重点:
set get mget mset insr desr append
redis使用
生成一个对象
def __init__(self, host='localhost', port=6379,
db=0, password=None, socket_timeout=None,
socket_connect_timeout=None,
socket_keepalive=None, socket_keepalive_options=None,
connection_pool=None, unix_socket_path=None,
encoding='utf-8', encoding_errors='strict',
charset=None, errors=None,
decode_responses=False, retry_on_timeout=False,
ssl=False, ssl_keyfile=None, ssl_certfile=None,
ssl_cert_reqs='required', ssl_ca_certs=None,
max_connections=None):
#配置好库后,将库名设置为localhost,可以不传参数,port固定为6379
conn = redis.Redis()
插入
set(name,value,ex=None,px=None,nx=False,xx=False)
conn.set('name','zb')
#ex=3 3秒后删除数据
conn.set('height',180,ex=3)
#px=3000 3000毫秒后删除数据
conn.set('height',180,px=3000)
#nx=True 当key不存在才进行操作
conn.set('age','20',nx=True)#age=19,执行后age值不变
#xx=True 当key存在时才进行操作
conn.set('age','20',xx=True)#age更新为20
#只有key不存在时才会执行
setnx(name, value)等价于set(name,value,nx=True)
#设置过期时间,单位秒
setex(name,time, value)
#设置过期时间,单位毫秒
psetex(name, time_ms, value)
#批量插入
mset(*args, **kwargs)
mset({'k1':1,'K2':2})
#获取值
get(name)
#批量获取值
1.mget('k1','k2')
2.mget(['k1','k2'])
#设置新值并获取原来的值
old_value = getset(name,value)
#切片获取,顾头又顾尾
getrange(key,start,end)
#修改字符串内容,从offset位置开始向后替换
setrange(name,offset,value)
#获取字节长度
strlen(name)
#自增,默认增长为1,
res = incr(self,name,amount=1)
res直接是int类型,key不存在的话,会新增
#浮点型自增
incrbyfloat(self, name, amount=1.0)
#自减
decr(self, name, amount=1)
#追加,在对应的值后增加(字符串拼接)
append(key, value)
# 参数：
key, redis的name
value, 要追加的字符串
redis连接池
#做成单例模式(在一个模块内定义好,然后导入使用)
pool = redis.ConnectionPool(host="127.0.0.1",port=6379,max_connectiongs=10000)
#每次执行这句话,从池子中取一个连接
conn = redis.Redis(connection_pool=pool)
redis字典操作
#ps:redis支持5大数据类型,但是它只支持一层
conn = redis.Redis()
#hset(name,key,value)
conn.hset('k1','name','zb')
#hsetnx(name,key,value)当key不存在时执行
conn.hset('k1','name','egon')
#hmset(name,mapping)
conn.hmset('k2',{'name':'lqz','age':18})
#hget(name,key)取出的数据为bytes类型
ret = conn.hget('k2','age')>>>b'18'
#hmget(name,keys,*args)
1.ret = conn.hmget('k2','name','age')>>>[b'lqz', b'18']
2.ret = conn.hmget('k2',['name','age'])
>>>[b'lqz', b'18']
#hgetall(name)不建议使用,当数据量过大时,数据库压力较大
ret = conn.hgetall('k2')>>>>{b'name': b'lqz', b'age': b'18'}
#hlen(name) 获得键值对个数
ret = conn.hlen('k2')>>>2
#hkeys(name)获取所有键
ret = conn.hkeys('k2')>>>>[b'name', b'age']
#hvals(name)获取所有值
ret = conn.hvals('k2')>>>>>[b'lqz', b'18']
#hexists(name,key)key是否存在
ret = conn.hexists('k2','sex')>>>False
ret = conn.hexists('k2','age')>>>True
#hdel(name,*keys) 删除指定可以
conn.hdel('k1')>>>>>不传key报错
conn.hdel('k1','age')>>>>存在删除,不存在不报错
#hincrby(name,key,amount=1)key对应的值自增1
#1.key不存在新建
#2.key存在加amount
#3.返回值就是更改后的int类型
conn.hincrby('k2','age')>>>>age=19
conn.hmset("k1",{"name":"zb","pwd":123})
conn.hincrby("k1","pwd",amount=1)>>>>>>pwd=124
#hincrbyfloat(name,key,amount=1.0)key对应的浮点数自增1
conn.hincrbyfloat('k2','age')>>>>age=20
#hscan(name,cursor=0,match=None,count=None)取一定数量的数据,减少数据库压力,cursor起始坐标,count取的数量,match匹配指定的key,默认为none表示所有的key
conn.hscan('k1',count=100)
#hscan_iter(name,match=None,count=None)
#源码里执行了hscan,得到的数据封装成迭代器,减少了数据库压力,
for i in conn.hscan_iter('k2',count=1000):
print(i)
源码
def hscan_iter(self, name, match=None, count=None):
cursor = '0'
while cursor != 0:
#使用hscan函数每次取出count数量的数据,data接收,当数据取完时cursor=0
cursor, data = self.hscan(name, cursor=cursor,
match=match, count=count)
#将data数据做成生成器,一次取一个,减少数据库压力
for item in data.items():
yield item
redis的列表操作
#redis支持5大数据类型,但是它只支持一层
conn = redis.Redis()
#lpush(name,values)新元素都添加到列表的最左边
#conn.lpush('k3',[1,2,3])>>>报错
conn.lpush('k3',1,2,3)>>>
row value
1 3
2 2
3 1
ret = conn.lrange('k3',0,100) >>>>[b'3', b'2', b'1']
#rpush(name,values)新元素都添加到列表的最右边
conn.rpush('k4',1,2,3)
row value
1 1
2 2
3 3
ret = conn.lrange('k4',0,100) >>>>[b'1', b'2', b'3']
#lpushx(name,value)当name存在时,值添加到列表的最左边
conn.lpushx('k3',4)>>>
row value
1 4
2 3
3 2
4 1
#llen(name)获取列表长度
ret = conn.llen('k3')>>>>4
#linsert(name,where,refvalue,value)
# 在name对应的列表的某一个值前或后插入一个新值
# where，BEFORE或AFTER(小写也可以)
# refvalue，标杆值，即：在它前后插入数据（如果存在多个标杆值，以找到的第一个为准）
# value，要插入的数据
conn.linsert('k3','before',2,5)>>>>
row value
1 4
2 3
3 5
4 2
5 1
#lset(name,index,value)更改索引位置的值
#索引从0开始
conn.lset('k3',2,2.5)
row value
1 4
2 3
3 2.5
4 2
5 1
#lrem(name,count,value)删除列表中指定的value，value有重复的话，num为指定删除几个
#num=0删除所有值
#num=2 从前到后删除2个
#num=-2 从后到前删除2个
conn.lrem('k3',2.5)
#lpop(name)从列表左侧获取第一个元素并移除,返回值则是第一个元素
#rpop则是从右向左操作
conn.rpush('k3',4)>>>>
row value
1 4
2 3
3 2
4 1
5 4
conn.rpop('k3')>>>>
row value
1 4
2 3
3 2
4 1
conn.lpop('k3')>>>>
row value
1 3
2 2
3 1
#lindex(name,index)在列表中根据索引获取列表元素
conn.lindex('k3',2)>>>b'1'
#lrange(name,start,end)在列表中获取分片数据,顾头顾尾
conn.lrange('k3',0,conn.llen('k3'))>>>[b'3', b'2', b'1']
#ltrim(name,start,end)保留start,end之间的数据,其他数据移除
conn.ltrim('k3',0,1)>>>
row value
1 3
2 2
#rpoplpush(src,dst)从列表中取出最右边的元素,将其添加到另一个列表的最左边
#blpop(names,timeout)
# 将多个列表排列，按照从左到右去pop对应列表的元素
# 参数：
# names，redis的name的集合
# timeout，超时时间，当元素所有列表的元素获取完之后，阻塞等待列表内有数据的时间（秒）, 0 表示永远阻塞
'''
r.brpop(keys, timeout)，从右向左获取数据
爬虫实现简单分布式：多个url放到列表里，往里不停放URL，程序循环取值，但是只能一台机器运行取值，可以把url放到redis中，多台机器从redis中取值，爬取数据，实现简单分布式
'''
conn.blpop(['k4','li1'])#从左到右pop,先pop k4中最左边的元素
#brpoplpush(src, dst, timeout=0)
# 从一个列表的右侧移除一个元素并将其添加到另一个列表的左侧
# 参数：
# src，取出并要移除元素的列表对应的name
# dst，要插入元素的列表对应的name
# timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
自定义迭代器
列表没有增量迭代,字典有hscan_iter方法,故需要自定义
import redis
conn = redis.Redis()
def scan_list(name,count=1000):
cursor=0
while cursor < conn.llen(name):
data_list = conn.lrange(name,cursor,cursor+count-1)
#lrange是分片取,故要将范围调整
cursor += count
for data in data_list:
yield data
for i in scan_list('test',5):
print(i)
其他操作
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
redis管道
相当于mysql的事务,原子性:要么一起成功,要么一起失败
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)
pipe.multi()
pipe.set('name', 'alex')
pipe.set('role', 'sb')
#将两个操作一起执行
pipe.execute()
在pycharm中使用redis
import redis
re = redis.Redis(host='127.0.0.1', port=6379,db=0,)
POOL = redis.ConnectionPool(max_connections=100)
conn = redis.Redis(connection_pool=POOL)
conn.set('1',1)
django中使用redis
方式一:
utils文件中,建立redis_pool.py
import redis
POOL= redis.ConnectionPool(
host='127.0.0.1',
port = 6379,
max_connections=1000
)
视图函数中使用
import redis
from django.shortcuts import render HttpResponse
from utils.redis_pool import POOL
def index(request):
conn = redis.Redis(connection_pool=POOL)
conn.hset('kkk','age',18)
return HttpResponse('设置成功')
方式二:使用django-redis模块
settings.py配置
#可以用做缓存
CACHES = {
"default": {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "redis://127.0.0.1:6379",
"OPTIONS": {
"CLIENT_CLASS": "django_redis.client.DefaultClient",
"CONNECTION_POOL_KWARGS": {"max_connections": 100}
# "PASSWORD": "123",
}
}
}
视图函数
from django_redis import get_redis_connection
conn = get_redis_connection('default')
print(conn.hgetall('xxx'))
vue的创建
安装node.js
安装vue脚手架
创建vue项目.vue create 项目名字
在pycharm中打开
1.从pycharm中将文件打开
2.settings plugins 装vue.js插件
3.在editor configuration中添加npm,以后运行就可以直接在pycharm中运行了
在pycharm中开发vue
-webstrom,pycharm,goland,idea,androidStuidio,php