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