[Introduction à Python3 Jour 19] Chapitre 8 Destinations de données (8.4-8.5)

8.4 Banque de données NoSQL

--Créé dans le but de traiter de très grands ensembles de données, de définir des données flexibles, de prendre en charge le traitement de données personnalisées, etc.

8.4.1 Famille dbm

• Le format dbm est un magasin clé-valeur (plusieurs paires clé / valeur)
• La nature de la banque de données dbm --Une valeur peut être affectée à la clé et la valeur affectée est automatiquement enregistrée dans le DB sur le disque.
• Vous pouvez obtenir la valeur de la clé.

#"c"Le mode est alphabétisé
>>> db=dbm.open("definitions","c")
#Attribuez des valeurs aux clés comme dans un dictionnaire.
>>> db["mustard"]="yellow"
>>> db["ketchup"]="red"
>>> db["pesto"]="green"
>>> db.close
<built-in method close of _dbm.dbm object at 0x101bb0290>
>>> db.close()
#Vérifiez si la version réécrite est réellement enregistrée.
>>> db=dbm.open("definitions","r")
#Les clés et les valeurs sont stockées sous forme d'octets.
>>> db["mustard"]
b'yellow'

8.4.2 memcached

--Un serveur de cache en mémoire rapide pour les clés et les valeurs.

• Souvent utilisé comme prétraitement DB ou pour stocker les données de session du serveur Web.
• Après la connexion, vous pouvez effectuer les opérations suivantes. --Obtenir et définir la valeur avec la clé spécifiée --Incrémentation de valeur, décrémentation
• Suppression de clé
• Les données ne sont pas persistantes et peuvent disparaître des plus anciennes. ** Empêche de jeter les anciennes données et de manquer de mémoire. ** **

8.4.3 Redis

--En règle générale, stockez-le en mémoire sur le serveur de structure de données.

• Les points suivants sont différents de memcached.
• Puisque les données peuvent être enregistrées sur le disque, les anciennes données peuvent être conservées. --Il existe également des structures de données autres que de simples chaînes de caractères.

8.4.3.1 Chaîne

Erreur

>>> import redis
#Connectez-vous au serveur Redis.
>>> conn=redis.Redis()
>>> conn.keys("*")
#Une erreur est survenue.

―― J'ai eu l'erreur suivante et l'ai étudiée pendant environ une heure. ⇨ ** L'erreur a été résolue en installant redis avec Homebrew. ** **

solution de contournement

During handling of the above exception, another exception occurred:

$ brew search redis
==> Successfully started `redis` (label: homebrew.mxcl.redis)

résultat

>>> import redis
>>> conn = redis.Redis()
>>> conn.keys()
[]
#set()Écrivez la valeur par.
>>> conn.set("secret","ni!")
True
>>> conn.set("caratst","24")
True
>>> conn.set("fever","101.5")
True

#Lisez la valeur à l'aide de la clé.
>>> conn.get("secret")
b'ni!'
>>> conn.get("caratst")
b'24'
>>> conn.get("fever")
b'101.5'

#setnx()La méthode définit la valeur sauf si la clé existe.
>>> conn.setnx("secret","icky-icky-icky-ptang-zoop-boing!")
False
>>> conn.get("secret")
b'ni!'

#getset()La méthode renvoie la valeur d'origine et définit la nouvelle valeur.
>>> conn.getset("secret","icky-icky-icky-ptang-zoop-boing!")
b'ni!'
>>> conn.get("secret")
b'icky-icky-icky-ptang-zoop-boing!'

#getrange()Extrait une sous-chaîne.
>>> conn.getrange("secret",-6,-1)
b'boing!'

#setarrange()Remplace la sous-chaîne.
>>> conn.setrange("secret",0,"ICKY")
32
>>> conn.get("secret")
b'ICKY-icky-icky-ptang-zoop-boing!'

#mset()Utilisez pour obtenir plusieurs clés en même temps.
>>> conn.mset({"pie":"cherry","cordial":"sherry"})
True

#mget()Utilisez pour obtenir plusieurs valeurs à la fois.
>>> conn.mget(["fever","caratst"])
[b'101.5', b'24']

#La clé est supprimée.
>>> conn.delete("fever")
1
>>> conn.incr("caratst")
25
>>> conn.decr("caratst",10)
15
>>> conn.set("caratst","24")
True
>>> conn.incr("caratst",10)
34
>>> conn.decr("caratst")
33
>>> conn.decr("caratst",15)
18
>>> conn.set("fever","101.5")
True
>>> conn.incrbyfloat("fever")
102.5
>>> conn.incrbyfloat("fever",0.5)
103.0

#decrbyfloat()A un incrément négatif.
>>> conn.incrbyfloat("fever",-2.0)
101.0

8.4.3.2 Liste

• La liste Redis ne peut stocker que des chaînes.

#Utilisez lpush pour insérer au début.
>>> conn.lpush("zoo","bear")
1
#Insérez plusieurs éléments au début.
>>> conn.lpush("zoo","alligator","duck")
3
#linsert()Insérer avant la valeur à l'aide de.
>>> conn.linsert("zoo","before","bear","behavor")
4
#linsert()Utilisez pour insérer après la valeur.
>>> conn.linsert("zoo","after","bear","aaaar")
5
#lset()Insérer à la position spécifiée à l'aide de.
>>> conn.lset("zoo",2,"marmoset")
True

#rpush()Insérer à la fin en utilisant.
>>> conn.rpush("zoo","marmoset")
6
#lindex()Utilisez pour obtenir la valeur de décalage.
>>> conn.lindex("zoo",3)
b'bear'
#lrange()Utilisez pour obtenir la valeur dans la plage de décalage spécifiée.
>>> conn.lrange("zoo",0,2)
[b'duck', b'alligator', b'marmoset']
#ltrim()Utilisez pour élaguer la liste. Seuls les éléments dans la plage de décalage spécifiée restent.
>>> conn.ltrim("zoo",1,4)
True
>>> conn.lrange("zoo",0,-1)
[b'alligator', b'marmoset', b'bear', b'aaaar']

8.4.3.3 Hash

• Les hachages Redis sont très similaires aux dictionnaires Python, mais ne peuvent stocker que des chaînes.

#hmset()Faire du hachage de chanson en utilisant,Définissez le champ re en même temps.
>>> conn.hmset("song",{"do":"aA","re":"About a deer"})
True
#hset()Utilisez pour définir la valeur d'un champ sur un champ dans le hachage.
>>> conn.hset("song","mi","a note to follow me")
1
#hget()Pour obtenir la valeur d'un champ.
>>> conn.hget("song","mi")
b'a note to follow me'
#hmget()Utilisez pour obtenir les valeurs de plusieurs champs.
>>> conn.hmget("song","re","do")
[b'About a deer', b'aA']
#hkeys()Utilisez pour obtenir les clés de tous les champs du hachage
>>> conn.hkeys("song")
[b'do', b're', b'mi']
#havals()Obtenez les valeurs de tous les champs du hachage en utilisant
>>> conn.hvals("song")
[b'aA', b'About a deer', b'a note to follow me']
#Obtenez le nombre de champs dans le hachage
>>> conn.hlen("song")
3
#hegetall()Utilisez pour obtenir les valeurs et les clés de tous les champs du hachage.
>>> conn.hgetall("song")
{b'do': b'aA', b're': b'About a deer', b'mi': b'a note to follow me'}
#hsetnx()Utilisez pour définir le champ si vous n'avez pas encore de clé.
>>> conn.hsetnx("song","fa","asdf")
1

8.4.3.4 Définir

• L'ensemble Redis est très similaire à l'ensemble Python.

#Ajoutez une ou plusieurs valeurs à l'ensemble.
>>> conn.sadd("zoo2","a","b","c")
3
#Obtenez le nombre de valeurs de l'ensemble.
>>> conn.scard("zoo2")
3
#Obtenez toutes les valeurs de l'ensemble.
>>> conn.smembers("zoo2")
{b'a', b'c', b'b'}
#Supprimez la valeur de l'ensemble.
>>> conn.srem("zoo2","c")
1

#Création de décors
>>> conn.sadd("zoo3","ni","b","a")
3
#Obtenez l'ensemble de produits.
>>> conn.sinter("zoo2","zoo3")
{b'a', b'b'}
#Obtenez l'ensemble de produits et définissez la volaille_Stockez le résultat dans le zoo.
>>> conn.sinterstore("fowl_zoo","zoo2","zoo3")
2
>>> conn.smembers("fowl_zoo")
{b'a', b'b'}

#Créer un ensemble de somme
>>> conn.sunion("zoo2","zoo3")
{b'a', b'b', b'ni'}
#Créez un ensemble de somme et définissez les résultats f_Magasin dans le zoo.
>>> conn.sunionstore("f_zoo","zoo2","zoo3")
3
>>> conn.smembers("f_zoo")
{b'a', b'b', b'ni'}

#sdiff()Créez un jeu de différences à l'aide de.(Choses qui sont dans le zoo2 mais pas dans le zoo3)
>>> conn.sdiff("zoo2","zoo3")
{b'c'}
#Créez un jeu de différences et définissez le zoo des résultats_Magasin en vente.
>>> conn.sdiffstore("zoo_sale","zoo2","zoo3")
1
>>> conn.smembers("zoo_sale")
{b'c'}

8.4.3.5 Ensemble trié

• Les types de données Redis les plus applicables sont des ensembles triés ou des zsets. --zset est un ensemble unique de valeurs, mais chaque valeur a également une fraction flottante appelée ** score **.

--J'ai vérifié l'erreur'str'object n'a pas d'attribut'items 'mais je n'ai pas pu la résoudre. J'ai fait ce qui suit pour le résoudre.

--Lorsque j'ai vérifié, j'ai vu sur certains sites que l'erreur avait été résolue en mettant à niveau les outils de configuration, alors je suis allé.

résultat

>>> import time
>>> now=time.time()
>>> now
1579936585.194324
>>> conn.zadd("logins","smeagol",now+(5*60))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File 
    return iter(x.items())
AttributeError: 'str' object has no attribute 'items'

Entraine toi

$ pip install --upgrade 
Successfully installed setuptools-45.1.0

8.4.3.6 bits

>>> days=["2013-02-24","2013-02-25","2013-02-26"]
#Donnez l'ID utilisateur.
>>> big_spender=1089
>>> tire_kicker=40459
>>> late_joiner=550212
#Définissez le bit de l'ID utilisateur connecté ce jour-là.
>>> conn.setbit(days[0],big_spender,1)
0
>>> conn.setbit(days[0],tire_kicker,1)
0
>>> conn.setbit(days[1],big_spender,1)
0
>>> conn.setbit(days[2],big_spender,1)
0
>>> conn.setbit(days[2],late_joiner,1)
0
#Qui sont les visiteurs chaque jour des trois jours?
>>> for day in days:
...     conn.bitcount(day)
... 
2
1
2
>>> conn.getbit(days[1],tire_kicker)
0
>>> conn.getbit(days[1],big_spender)
1

#Combien d'utilisateurs se connectent chaque jour?
>>> conn.bitop("and","everyday",*days)
68777
>>> conn.bitcount("everyday")
1
#Qu'est-ce? → grand_spender
>>> conn.getbit("everyday",big_spender)
1
>>> conn.getbit("everyday",tire_kicker)
0
>>> conn.bitop("or","alldays",*days)
68777
>>> conn.bitcount("alldays")
3

8.4.3.7 Cache et date d'expiration

• Toutes les clés Redis ont une durée de vie et une date d'expiration. (Par défaut, ce sont pour toujours.)
• Vous pouvez utiliser la fonction expire () pour indiquer à Redis combien de temps conserver la clé. (La valeur est en secondes)
• La commande expireat () invalide la clé à l'heure Unix spécifiée.

>>> import time
>>> key="now you see it"
>>> conn.set(key,"but not fot long")
True
>>> conn.expire(key,5)
True
>>> conn.ttl(key)
-2
>>> conn.get(key)
>>> time.sleep(6)
>>> conn.get(key)
>>> 

8.5 Revoir l'affectation

8-1 Remplacez la chaîne "Ceci est un test du système de texte d'urgence" dans la variable test1 et écrivez le contenu de test1 dans le fichier text.txt.

>>> test1="""This is a test of the emergency text system"""
>>> fout=open("text.txt","wt")
>>> fout.write(test1)
43
>>> fout.close()

8-2 Ouvrez un fichier appelé text.txt et lisez son contenu dans la variable test2. Test1 et test2 sont-ils identiques?

>>> with open("text.txt","rt") as infile:
...     test2=infile.read()
... 
>>> test1==test2
True

8-3 Enregistrez le texte suivant dans un fichier appelé books.csv.

>>> a="""auther,book
... J R R Tolkien,The Hobbit
... Lynne Truss,"Eats, Shoots & Leaves"
... """

8-4 Utilisez le module csv et sa méthode DictReader pour charger le contenu de books.csv dans la variable books et afficher le contenu.

>>> import csv
>>> with open("books.csv","rt") as fout:
...     books=csv.DictReader(fout)
...     for book in books:
...         print(book)
... 
OrderedDict([('auther', 'J R R Tolkien'), ('book', 'The Hobbit')])
OrderedDict([('auther', 'Lynne Truss'), ('book', 'Eats, Shoots & Leaves')])

8-5 Créez un fichier CSV appelé books.csv en utilisant les lignes suivantes.

>>> text="""title,author,year
... The Weirdstone of Brisingamen,Alan Garner,1960
... Perdido Street Station,China Miéville,2000
... Thud!,Terry Pratchett,2005
... The Spellman Files,Lisa Lutsz,2007
... Small Gods,Terry Pratchett,1992
... """

>>> with open("books.csv","wt") as fout:
...     fout.write(text)
... 
202

8-6 Créez un SQLiteDB appelé books.db à l'aide du module sqlite3 et créez une table appelée book avec les champs title, author et book.

>>> import sqlite3
>>> conn=sqlite3.connect("books.db")
>>> curs=conn.cursor()
>>> curs.execute("""CREATE TABLE book(title text,author text,year int)""")
<sqlite3.Cursor object at 0x1029e8960>
>>> db.commit()

8-7 Lisez books.csv et insérez les données dans la table de lecture.

>>> import csv
>>> import sqlite3
>>> ins_str ="insert into book values(?,?,?)"
>>> with open("books.csv","rt") as infile:
...     books=csv.DictReader(infile)
...     for book in books:
...         curs.execute(ins_str,(book["title"],book["author"],book["year"]))
... 
<sqlite3.Cursor object at 0x1029e8960>
<sqlite3.Cursor object at 0x1029e8960>
<sqlite3.Cursor object at 0x1029e8960>
<sqlite3.Cursor object at 0x1029e8960>
<sqlite3.Cursor object at 0x1029e8960>
>>> conn.commit()

8-8 Sélectionnez la colonne de titre de la table des livres et affichez-la par ordre alphabétique.

#Les données ont été insérées par erreur la première fois, donc lorsque j'ai réessayé, les données précédentes sont restées. De plus, j'ai découvert que SQLite ne peut pas supprimer des données, mais il est possible de supprimer une table.
>>> sql="select title from book order by title asc"
>>> for row in conn.execute(sql):
...     print(row)
... 
('    ',)
('        Perdido Street Station',)
('        Small Gods',)
('        The Spellman Files',)
('        The Weirdstone of Brisingamen',)
('        Thud!Terry Pratchett',)
('Perdido Street Station',)
('Small Gods',)
('The Spellman Files',)
('The Weirdstone of Brisingamen',)
('Thud!',)

8-9 Sélectionnez toutes les colonnes de la table des livres et affichez-les par ordre d'année de publication.

>>> for row in conn.execute("select * from book order by year"):
...     print(row)
... 
('        Thud!Terry Pratchett', '2005', None)
('    ', None, None)
('        The Weirdstone of Brisingamen', 'Alan Garner', 1960)
('The Weirdstone of Brisingamen', 'Alan Garner', 1960)
('        Small Gods', 'Terry Pratchett', 1992)
('Small Gods', 'Terry Pratchett', 1992)
('        Perdido Street Station', 'China Miéville', 2000)
('Perdido Street Station', 'China Miéville', 2000)
('Thud!', 'Terry Pratchett', 2005)
('        The Spellman Files', 'Lisa Lutsz', 2007)
('The Spellman Files', 'Lisa Lutsz', 2007)

Connectons-nous à la base de données de books.db de sqlite3 créée en 8-6 à l'aide du module sqlalchemy 8-10. Sélectionnez la colonne de titre comme en 8-8 et affichez-les par ordre alphabétique.

>>> import sqlalchemy as sa
>>> conn=sa.create_engine("sqlite:///books.db")
>>> sql="select title from book order by title asc"
>>> rows=conn.execute(sql)
>>> for row in rows:
...     print(row)
... 
('    ',)
('        Perdido Street Station',)
('        Small Gods',)
('        The Spellman Files',)
('        The Weirdstone of Brisingamen',)
('        Thud!Terry Pratchett',)
('Perdido Street Station',)
('Small Gods',)
('The Spellman Files',)
('The Weirdstone of Brisingamen',)
('Thud!',)
>>> 

8-11 Installez le serveur Redis et la bibliothèque redis de Python. Créez ensuite un hash Redis appelé test avec des champs count (1), name ("Fester Besteretester") pour afficher tous les champs de test.

#N'oubliez pas de redémarrer l'infusion!
$ brew services restart redis

>>> import redis
>>> conn=redis.Redis()

>>> conn.hmset("test",{"count":"1","name":"Fester Besteretester"})
True

#La sortie est une variable d'octets.
>>> conn.hgetall("test")
{b'count': b'1', b'name': b'Fester Besteretester'}

Incrémentons le champ de comptage du test 8-12 et affichons le résultat.

>>> conn.hincrby("test","count")
2
>>> conn.hget("test","count")
b'2'

Impressions

J'ai appris plus et mieux compris. Après cela, j'aimerais approfondir ma compréhension grâce à la documentation et à la recherche en ligne.

Les références

"Introduction à Python3 par Bill Lubanovic (publié par O'Reilly Japon)"

"Document Redis" http://redis.shibu.jp

"Installez Redis sur macOS." https://weblabo.oscasierra.net/redis-macos-install-homebrew/