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