11. Krótka wycieczka po bibliotece standardowej — Część II

Ta druga wycieczka obejmuje bardziej zaawansowane moduł, które wspierają profesjonalne potrzeby programistyczne. Te moduł rzadko występują w małych skryptach.

11.1. Formatowanie wyjścia

reprlib moduł zapewnia wersja z repr() dostosowany do skróconego wyświetlania dużych lub głęboko zagnieżdżonych kontenerów:

>>> import reprlib
>>> reprlib.repr(set('supercalifragilisticexpialidocious'))
"{'a', 'c', 'd', 'e', 'f', 'g', ...}"

Moduł pprint oferuje bardziej wyrafinowaną kontrolę nad drukowaniem zarówno wbudowanej, jak i obiektów zdefiniowanych przez użytkownika w sposób czytelny dla interpretera. Gdy wynik jest dłuższy niż jedna linia, „ładna drukarka” dodaje podziały linii i wcięcia, aby wyraźniej ujawnić strukturę danych:

>>> import pprint
>>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',
...     'yellow'], 'blue']]]
...
>>> pprint.pprint(t, width=30)
[[[['black', 'cyan'],
   'white',
   ['green', 'red']],
  [['magenta', 'yellow'],
   'blue']]]

Moduł textwrap formatuje akapity tekstu tak, aby pasowały do danej szerokości ekranu:

>>> import textwrap
>>> 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.

locale moduł uzyskuje dostęp do bazy danych formatów danych specyficznych dla danej kultury. Grupowanie atrybut formatu locale funkcja zapewnia bezpośredni sposób formatowania liczb za pomocą separatorów grup:

>>> import locale
>>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')
'English_United States.1252'
>>> conv = locale.localeconv()          # get a mapping of conventions
>>> x = 1234567.8
>>> locale.format("%d", x, grouping=True)
'1,234,567'
>>> locale.format_string("%s%.*f", (conv['currency_symbol'],
...                      conv['frac_digits'], x), grouping=True)
'$1,234,567.80'

11.2. Szablonowanie

Moduł string zawiera wszechstronną klasę Template z uproszczoną składnią odpowiednią do edycji przez użytkowników końcowych. Pozwala to użytkownikom na dostosowanie ich aplikacja bez konieczności zmiany aplikacja.

Format wykorzystuje nazwy placeholder utworzone przez $ z ważnymi identyfikatorami Python (alfanumeryczne znak i podkreślenia). Otoczenie placeholder nawiasami klamrowymi pozwala na umieszczenie po nim kolejnych liter alfanumerycznych bez spacji. Napisanie $$ tworzy pojedynczy $:

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

Metoda substitute() rzuci KeyError, gdy placeholder nie jest podany w słowniku lub argument nazwany. W przypadku mail-merge aplikacjach, dane dostarczone przez użytkownika mogą być niekompletne, a metoda safe_substitute() może być bardziej odpowiednia — pozostawi placeholder bez zmian, jeśli brakuje danych:

>>> t = Template('Return the $item to $owner.')
>>> d = dict(item='unladen swallow')
>>> t.substitute(d)
Traceback (most recent call last):
  ...
KeyError: 'owner'
>>> t.safe_substitute(d)
'Return the unladen swallow to $owner.'

Szablon podklas mogą określać niestandardowy separator. Na przykład, narzędzie do wsadowej zmiany nazw dla przeglądarki zdjęć może zdecydować się na użycie znaków procentowych jako placeholder, takich jak bieżące dane, numer sekwencyjny obrazu lub format pliku:

>>> import time, os.path
>>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']
>>> class BatchRename(Template):
...     delimiter = '%'
...
>>> fmt = input('Enter rename style (%d-date %n-seqnum %f-format):  ')
Enter rename style (%d-date %n-seqnum %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

Innym aplikacja dla szablonów jest oddzielenie logiki programu od szczegółów wielu formatów wyjściowych. Umożliwia to zastąpienie niestandardowych szablonów plikami XML, raportami tekstowymi i raportami internetowymi HTML.

11.3. Praca z układami rekordów danych binarnych

Moduł struct udostępnia pack() i unpack() funkcje do pracy z formatami rekordów binarnych o zmiennej długości. Poniższy przykład pokazuje, jak zapętlić informacje nagłówka w pliku ZIP bez użycia moduł zipfile . Kody pakietów "H" i "I" reprezentują odpowiednio dwu- i czterobajtowe liczby bez znaku. Oznaczenie "<" wskazuje, że mają one standardowy rozmiar i kolejność bajtów little-endian:

import struct

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

start = 0
for i in range(3):                      # show the first 3 file headers
    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     # skip to the next header

11.4. Wielowątkowość

Wątkowanie jest techniką oddzielania zadań, które nie są sekwencyjnie zależne. Wątek może być używany do poprawy szybkości reakcji aplikacji, które akceptują dane wejściowe użytkownika, podczas gdy inne zadania działają w tle. Powiązanym przypadkiem użycia jest równoległe wykonywanie operacji wejścia/wyjścia z obliczeniami w innym wątku.

Poniższy kod pokazuje, w jaki sposób wysokopoziomowy threading moduł może uruchamiać zadania w tle, podczas gdy główny program nadal działa:

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('The main program continues to run in foreground.')

background.join()    # Wait for the background task to finish
print('Main program waited until background was done.')

Głównym wyzwaniem wielowątkowej aplikacji jest koordynacja wątkow, które współdzielą dane lub inne zasoby. W tym celu wątkowanie moduł zapewnia szereg prymitywów synchronizacji, w tym blokady, zdarzenia, zmienne warunkowe i semafory.

Chociaż narzędzia te są potężne, drobne błędy projektowe mogą skutkować trudnymi do odtworzenia problemami. Dlatego preferowanym podejściem do koordynacji zadań jest skoncentrowanie całego dostępu do zasobu w jednym wąteku, a następnie wykorzystanie moduł queue do zasilania tego wąteka żądaniami z innych wątekow. Aplikacja wykorzystuje obiekty Queue do komunikacji i koordynacji międzywątekowych są łatwiejsze do zaprojektowania, bardziej czytelne i niezawodne.

11.5. Logowanie

Moduł logging oferuje w pełni funkcjonalny i elastyczny system logowania. W najprostszym przypadku komunikaty dziennika są wysyłane do pliku lub na adres sys.stderr:

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')

Daje to taki wyniki:

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

Domyślnie, komunikaty informacyjne i debugowanie są tłumione, a dane wyjściowe są wysyłane do standardowego błędu. Inne opcje wyjściowe obejmują kierowanie wiadomości przez e-mail, datagramy, gniazda lub do serwera HTTP. Nowe filtry mogą wybierać różne trasy na podstawie priorytetu wiadomości: DEBUG, INFO, WARNING, ERROR i CRITICAL.

System logowania może być skonfigurowany bezpośrednio z poziomu Pythona lub może być załadowany z edytowalnego przez użytkownika pliku konfiguracyjnego w celu dostosowania rejestrowania bez zmiany aplikacji.

11.6. Wsparcie słabych odniesień

Python wykonuje automatyczne zarządzanie pamięcią (liczenie referencji dla większości obiektów i garbage collection w celu wyeliminowania cykli). Pamięć jest zwalniana wkrótce po usunięciu ostatniego odniesienia do niej.

Takie podejście sprawdza się w większości przypadków aplikacji, ale czasami istnieje potrzeba śledzenia obiektów tylko tak długo, jak są one używane przez coś innego. Niestety, samo ich śledzenie tworzy odniesienie, które czyni je trwałymi. weakref moduł zapewnia narzędzia do śledzenia obiektów bez tworzenia odniesienia. Gdy obiekt nie jest już potrzebny, jest automatycznie usuwany z tabeli weakref i uruchamiane jest wywołanie zwrotne dla obiektów weakref. Typowe aplikacja obejmują buforowanie obiektów, których utworzenie jest kosztowne:

>>> import weakref, gc
>>> class A:
...     def __init__(self, value):
...         self.value = value
...     def __repr__(self):
...         return str(self.value)
...
>>> a = A(10)                   # create a reference
>>> d = weakref.WeakValueDictionary()
>>> d['primary'] = a            # does not create a reference
>>> d['primary']                # fetch the object if it is still alive
10
>>> del a                       # remove the one reference
>>> gc.collect()                # run garbage collection right away
0
>>> d['primary']                # entry was automatically removed
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    d['primary']                # entry was automatically removed
  File "C:/python310/lib/weakref.py", line 46, in __getitem__
    o = self.data[key]()
KeyError: 'primary'

11.7. Narzędzia do pracy z listami

Wiele potrzeb związanych ze strukturami danych można zaspokoić za pomocą listy wbudowanej. Czasami jednak istnieje potrzeba alternatywnych implementacji z różnymi kompromisami w zakresie wydajności.

The array module provides an array() object that is like a list that stores only homogeneous data and stores it more compactly. The following example shows an array of numbers stored as two byte unsigned binary numbers (typecode "H") rather than the usual 16 bytes per entry for regular lists of Python int objects:

>>> from array import array
>>> a = array('H', [4000, 10, 700, 22222])
>>> sum(a)
26932
>>> a[1:3]
array('H', [10, 700])

The collections module provides a deque() object that is like a list with faster appends and pops from the left side but slower lookups in the middle. These objects are well suited for implementing queues and breadth first tree searches:

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

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)

Oprócz alternatywnych implementacji list, biblioteka oferuje również inne narzędzia, takie jak bisect moduł z funkcja do manipulowania posortowanymi listami:

>>> import bisect
>>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]
>>> bisect.insort(scores, (300, 'ruby'))
>>> scores
[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]

Moduł heapq udostępnia funkcje do implementacji stert opartych na listach regularnych. Wpis o najniższej wartości jest zawsze przechowywany na pozycji zero. Jest to przydatne dla aplikacji, które wielokrotnie uzyskują dostęp do najmniejszego elementu, ale nie chcą uruchamiać pełnego sortowania listy:

>>> from heapq import heapify, heappop, heappush
>>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]
>>> heapify(data)                      # rearrange the list into heap order
>>> heappush(data, -5)                 # add a new entry
>>> [heappop(data) for i in range(3)]  # fetch the three smallest entries
[-5, 0, 1]

11.8. Decimal Floating Point Arithmetic

The decimal module offers a Decimal datatype for decimal floating point arithmetic. Compared to the built-in float implementation of binary floating point, the class is especially helpful for

• finansowe aplikacja i inne zastosowania wymagające dokładnej reprezentacji dziesiętnej,

• kontrola nad precyzją,

• kontrolę nad zaokrągleniami w celu spełnienia wymogów prawnych lub regulacyjnych,

• śledzenie znaczących miejsc po przecinku, lub

• aplikacja gdzie użytkownik oczekuje, że wyniki będą zgodne z obliczeniami wykonanymi ręcznie.

Na przykład, obliczenie 5% podatku od 70 centów opłaty telefonicznej daje różne wyniki w dziesiętnej zmiennoprzecinkowej i binarnej zmiennoprzecinkowej. Różnica staje się znacząca, jeśli wyniki zostaną zaokrąglone do najbliższego centa:

>>> from decimal import *
>>> round(Decimal('0.70') * Decimal('1.05'), 2)
Decimal('0.74')
>>> round(.70 * 1.05, 2)
0.73

Wynik Decimal zachowuje końcowe zero, automatycznie wywnioskowując znaczenie czterech miejsc z mnożników o znaczeniu dwóch miejsc. Decimal odtwarza matematykę wykonaną ręcznie i unika problemów, które mogą powstać, gdy binarna liczba zmiennoprzecinkowa nie może dokładnie reprezentować wielkości dziesiętnych.

Dokładna reprezentacja umożliwia klasie Decimal wykonywanie obliczeń modulo i testów równości, które nie są odpowiednie dla binarnych liczb zmiennoprzecinkowych:

>>> Decimal('1.00') % Decimal('.10')
Decimal('0.00')
>>> 1.00 % 0.10
0.09999999999999995

>>> sum([Decimal('0.1')]*10) == Decimal('1.0')
True
>>> sum([0.1]*10) == 1.0
False

Moduł decimal zapewnia arytmetykę z taką precyzją, jaka jest potrzebna:

>>> getcontext().prec = 36
>>> Decimal(1) / Decimal(7)
Decimal('0.142857142857142857142857142857142857')