Bibliothèque standard Python: seconde moitié (mémo d'apprentissage Python ⑨)

Mise en forme de la sortie

reprlib, pprint, textwrap, locale, etc.

import reprlib
import pprint
import textwrap
import locale

#reprlib est repr()Dans une autre version de, l'énorme projet de pièce de conteneur est omis et affiché.
charset = reprlib.repr(set('supercalifragilisticexpialidocious'))
print(charset)
# {'a', 'c', 'd', 'e', 'f', 'g', ...}

#pprint affiche la structure des données de manière simple à comprendre
t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta', 'yellow'], 'blue']]]
pprint.pprint(t, width=30)
# [[[['black', 'cyan'],
#    'white',
#    ['green', 'red']],
#   [['magenta', 'yellow'],
#    'blue']]]

# textwrap.fill()Enveloppe chaque paragraphe pour l'adapter à la largeur spécifiée
doc = """The wrap() method is just like fill() except that it returns a list of strings instead of one big string with newlines to separate the wrapped lines."""
print(textwrap.fill(doc, width=40))
# The wrap() method is just like fill()
# except that it returns a list of strings
# instead of one big string with newlines
# to separate the wrapped lines.

#le lieu est une représentation nationale(Unité etc.)Peut être appelé
locale.setlocale(locale.LC_ALL, 'English_United States.1252')
conv = locale.localeconv()
x = 1234567.8
print(locale.format("%d", x, grouping=True))
# 1,234,567
print(locale.format_string("%s%.*f", (conv['currency_symbol'], conv['frac_digits'], x), grouping=True))
# $1,234,567.80

modèle

point

• Le module Template vous permet d'implémenter une chaîne de modèle avec un symbole de remplacement ($).
• $ Peut être suivi de caractères alphanumériques et de nombres de soulignement
• \ $ Peut être échappé avec \ $
• Si vous continuez {} après $, vous pouvez continuer alphanumérique et souligné sans insérer d'espace.

from string import Template
t = Template('${village}folk send $$10 to $cause.')
sentence = (t.substitute(village='Nottingham', cause='the ditch func'))

print(sentence)
# Nottinghamfolk send $10 to the ditch func.


#La méthode de substitution est-elle un dictionnaire d'espaces réservés?
#Si vous ne passez pas l'argument de mot-clé, KeyError se produira, donc
# safe_La méthode de remplacement peut être plus sûre
#S'il n'y a pas de données, l'espace réservé sera affiché tel quel
t = Template('Return the $item to $owner.')
d = dict(item='unladen swallow')
sentence = t.safe_substitute(d)

print(sentence)
# Return the unladen swallow to $owner.

Vous pouvez également changer le délimiteur au lieu de $ dans la sous-classe Template

Changer le numéro de fichier

import time, os.path
from string import Template

photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']

class BatchRename(Template):
    delimiter = '%'

fmt = input('Comment renommez-vous(%d-Date%n-nombre%f-format): ')
#Comment renommez-vous(%d-Date%n-nombre%f-format): Ashley_%n%f 

t = BatchRename(fmt)
date = time.strftime('%d%b%y')

for i, filename in enumerate(photofiles):
    base, ext = os.path.splitext(filename)
    newname = t.substitute(d=date, n=i, f=ext)
    print('{0} --> {1}'.format(filename, newname))

# img_1074.jpg --> Ashley_0.jpg
# img_1076.jpg --> Ashley_1.jpg
# img_1077.jpg --> Ashley_2.jpg

Traitement des enregistrements de données binaires

Vous pouvez utiliser les modules struct`` pack () ʻet ʻunpack () pour traiter les enregistrements binaires de longueur variable.

Exemple de bouclage de chaque information d'en-tête du fichier zip

import struct

# rb:Lire en binaire
with open('myfile.zip', 'rb') as f:
    data = f.read()

start = 0

for i in range(3): #Affiche les en-têtes des trois premiers fichiers
    start += 14
    fields = struct.unpack('<IIIHH', data[start:start+16])
    crc32, comp_size, uncomp_size, filenamesize, extra_size = fields

    start += 16
    filename = data[start:start+filenamesize]
    start += filenamesize
    extra = data[start:start+extra_size]
    print(filename, hex(crc32), comp_size, uncomp_size)

    start += extra_size + comp_size #Passer à l'en-tête suivant

Multithread

point

• En utilisant le module threading, le traitement en arrière-plan peut être effectué pendant que le programme principal est en cours d'exécution.

import threading, zipfile

class AsyncZip(threading.Thread):
    def __init__(self, infile, outfile):
        threading.Thread.__init__(self)
        self.infile = infile
        self.outfile = outfile
    def run(self):
        f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)
        f.write(self.infile)
        f.close()
        print('Finished background zip of:', self.infile)

background = AsyncZip('mydata.txt', 'myarchive.zip')
background.start()
print('Le programme principal est en cours d'exécution')

background.join() #Attendez que la tâche d'arrière-plan se termine

print('Le programme principal attendait la fin du traitement en arrière-plan')

• Pour la coordination des tâches dans les applications multithreads, il est préférable de concentrer l'accès aux ressources sur un seul thread principal et d'utiliser le module queue pour alimenter les requêtes d'autres threads vers le thread principal.
• L'utilisation d'un objet Queue pour la communication inter-thread facilite la conception et améliore la lisibilité.

Journal

point

• Système de journalisation flexible dans le module journalisation
• Par défaut, les messages DEBUG et INFO sont supprimés
• Par défaut, la destination de sortie est la sortie d'erreur standard
• Les autres options de sortie incluent le courrier électronique, le datagramme, le socket et le transfert vers le serveur HTTP
• Vous pouvez également sélectionner la destination de sortie pour chaque priorité de message

import logging

logging.debug('Debugging information')
logging.info('Informational message')
logging.warning('Warning: config file %s not found', 'server.conf')
logging.error('Error occurred')
logging.critical('Critical error -- shutting down')

# WARNING:root:Warning: config file server.conf not found
# ERROR:root:Error occurred
# CRITICAL:root:Critical error -- shutting down

Référence faible

• lowref vous permet de suivre un objet sans générer de référence
• Les objets qui ne sont plus nécessaires sont automatiquement supprimés de la table de référence faible et un rappel vers l'objet de référence faible se produit.

import weakref, gc

class A:
    def __init__(self, value):
        self.value = value
    def __repr__(self):
        return str(self.value)

a = A(10) #Générer une référence
d = weakref.WeakValueDictionary()
d['primary'] = a #Ne générez pas de référence
print(d['primary']) #Récupérez l'objet s'il est vivant
10

del a #Supprimer la référence
gc.collect() #Exécuter le ramasse-miettes

d['primary'] #L'entrée a été supprimée automatiquement
# Traceback (most recent call last):
#   File ".\weakref_sample.py", line 17, in <module>
#     d['primary'] #L'entrée a été supprimée automatiquement
#   File "C:\Program Files\WindowsApps\PythonSoftwareFoundation.Python.3.7_3.7.1520.0_x64__qbz5n2kfra8p0\lib\weakref.py", line 137, in __getitem__      
#     o = self.data[key]()
# KeyError: 'primary'

Outil de manipulation de liste

• Le module ʻarray fournit un objet de type liste ʻarray qui ne contient que les données de la même pièce.

from array import array

a = array('H', [4000, 10, 700, 22222])
print(sum(a))
# 26932

print(a[1:3])
# array('H', [10, 700])

• Le module collections amène un objetdeque à l'extrémité gauche où ʻappend et pop` sont plus rapides que la liste, mais la référence centrale est plus lente.
• Utile lors de la mise en œuvre de la recherche d'arborescence de priorité de file d'attente ou de largeur

from collections import deque
d = deque(["task1", "task2", "task3"])
d.append("task4")
print("Handling", d.popleft())

unsearched = deque([starting_node])
def breadth_first_search(unsearched):
    node = unsearched.popleft()
    for m in gen_moves(node):
        if is_goal(m):
            return m
        unsearched.append(m)

• Il a également un module bisect qui a des fonctions pour manipuler les listes triées.
• Le module heapq fournit une fonction qui implémente un tas basé sur une liste régulière.

Calcul en virgule flottante des nombres décimaux

• Le module decimal fournit le type de données Decimal pour le calcul en nombres décimaux flottants.
• Calcul plus rigoureux que le type float