redis列表,字典,管道,vue安装,创建项目

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