7. Wejście i wyjście
********************

Wyjście programu można zaprezentować na różne sposoby; można wypisać
dane w formie czytelnej dla człowieka lub zapisać do pliku do
wykorzystania w przyszłości. Ten rozdział omówi niektóre z możliwości.


7.1. Wymyślniejsze formatowanie wyjścia
=======================================

Do tej pory natknęliśmy się na dwa sposoby wypisywania wartości:
*wyrażenia* i funkcję "print()". (Trzecim sposobem jest użycie metody
"write()" obiektu pliku; do pliku standardowego wyjścia można odwołać
się używając "sys.stdout". Więcej informacji na ten temat znajdziesz w
dokumentacji biblioteki standardowej.)

Często będziesz chciał(a) mieć więcej kontroli nad formatowaniem
swojego wyjścia niż proste wypisywanie wartości rozdzielonych spacją.
Jest kilka sposobów na formatowanie wyjścia.

* Aby użyć literału ciągu znaków, rozpocznij ciąg znaków znakiem "f"
  lub "F" przed otwierającym znakiem cudzysłowu. Wewnątrz ciągu
  znaków, możesz wpisać wyrażenia Pythona pomiędzy znakami "{" i "}",
  które mogą odnosić się do zmiennych lub wartości.

     >>> year = 2016
     >>> event = 'referendum'
     >>> f'Wyniki {event} {year}'
     'Wyniki referendum 2016'

* Metoda "str.format()" ciągów znaków wymaga większego ręcznego
  wysiłku. Nadal będziesz używał(a) "{" i "}" do zaznaczenia gdzie
  zmienna zostanie podstawiona i możesz podać dokładne dyrektywy
  formatowania, ale będziesz musiał(a) podać również informacje do
  sformatowania. W przedstawionym bloku kodu są dwa przykłady, jak
  formatować zmienne.

     >>> yes_votes = 42_572_654
     >>> total_votes = 85_705_149
     >>> percentage = yes_votes / total_votes
     >>> '{:-9} głosów na TAK  {:2.2%}'.format(yes_votes, percentage)
     ' 42572654 głosów na TAK  49.67%'

  Zauważ, że "yes_votes" są wypełnione spacjami i znakiem minus tylko
  dla liczb ujemnych. Przykład wypisuje również "percentage" pomnożony
  przez 100, z 2 miejscami po przecinku i ze znakiem procentu
  (szczegóły: Format Specification Mini-Language).

* Wreszcie, możesz wykonać całą obsługę ciągów znaków samodzielnie,
  używając operacji krojenia (slicing) i konkatenacji, aby stworzyć
  dowolny układ, jaki możesz sobie wyobrazić. Typ ciągu znaków posiada
  kilka metod, które wykonują przydatne operacje do wypełniania ciągów
  znaków do danej szerokości kolumny.

Gdy nie potrzebujesz wymyślnego wyjścia, tylko chcesz szybko
wyświetlić zmienne do debugowania, możesz zkonwertować dowolną wartość
do ciągu znaków przy pomocy funkcji "repr()" lub "str()".

Funkcja "str()" ma na celu zwrócenie reprezentacji wartości, które są
dość czytelne dla człowieka, podczas gdy "repr()" ma na celu
wygenerowanie reprezentacji, które mogą być odczytane przez
interpreter (lub wymuszą "SyntaxError", jeśli nie ma równoważnej
składni). Dla obiektów, które nie mają określonej reprezentacji do
użycia przez człowieka, "str()" zwróci taką samą wartość jak "repr()".
Wiele wartości, takich jak liczby lub struktury takie jak listy i
słowniki, ma taką samą reprezentację przy użyciu obu funkcji. Ciągi
znaków, w szczególności, mają dwie odrębne reprezentacje.

Trochę przykładów:

   >>> s = 'Witaj, świecie.'
   >>> str(s)
   'Witaj, świecie.'
   >>> repr(s)
   "'Witaj, świecie.'"
   >>> str(1/7)
   '0.14285714285714285'
   >>> x = 10 * 3.25
   >>> y = 200 * 200
   >>> s = 'Wartość x to ' + repr(x) + ', i y to ' + repr(y) + '...'
   >>> print(s)
   Wartość x to 32.5, i y to 40000...
   >>> # repr() ciągu znaków dodaje cudzysłów i backslashe:
   >>> hello = 'witaj, świecie\n'
   >>> hellos = repr(hello)
   >>> print(hellos)
   'witaj, świecie\n'
   >>> # argumentem repr() może być dowolny obiekt Pythona:
   >>> repr((x, y, ('mielonka', 'jajka')))
   "(32.5, 40000, ('mielonka', 'jajka'))"

Moduł "string" moduł zawiera wparcie dla prostego podejścia
szablonowania opartego na wyrażeniach regularnych, poprzez
"string.Template". Oferuje on jeszcze jeden sposób na wstawianie
wartości w ciągi znaków, używając placeholderów jak "$x" i zastępując
je wartościami ze słownika. Ta składnia jest łatwa w użyciu, chociaż
oferuje znacznie mniejszą kontrolę nad formatowaniem.


7.1.1. f-stringi
----------------

Formatowane literały ciągów znaków (nazywane też krótko f-stringami)
pozwalają zawrzeć wartość pythonowych wyrażeń wewnątrz ciągu znaków
przez dodanie prefiksu "f" lub "F" i zapisanie wyrażenia jako
"{expression}".

Po wyrażeniu może nastąpić opcjonalny specyfikator formatu. Umożliwia
on większą kontrolę nad sposobem formatowania wartości. Poniższy
przykład zaokrągla pi do trzech miejsc po przecinku:

   >>> import math
   >>> print(f'Wartość pi wynosi w przybliżeniu {math.pi:.3f}.')
   Wartość pi wynosi w przybliżeniu 3,142.

Przekazanie liczby całkowitej po znaku "':'" spowoduje, że pole będzie
miało minimalną liczbę znaków szerokości. Jest to przydatne przy
tworzeniu linii kolumn.

   >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
   >>> for name, phone in table.items():
   ...     print(f'{name:10} ==> {phone:10d}')
   ...
   Sjoerd     ==>       4127
   Jack       ==>       4098
   Dcab       ==>       7678

Inne modyfikatory mogą być użyte do konwersji wartości przed jej
sformatowaniem. "'!a'" stosuje "ascii()", "'!s'" stosuje "str()", a
"'!r'" stosuje "repr()":

   >>> animals = 'węgorze'
   >>> print(f'Na moim poduszkowcu są {animals}.')
   Na moim poduszkowcu są węgorze.
   >>> print(f'Na moim poduszkowcu są {animals!r}.')
   Na moim poduszkowcu są 'węgorze'.

Specyfikator "=" może być użyty do rozwinięcia wyrażenia do tekstu
wyrażenia, znaku równości, a następnie reprezentacji obliczonego
wyrażenia:

>>> bugs = 'roaches'
>>> count = 13
>>> area = 'living room'
>>> print(f'Debugging {bugs=} {count=} {area=}')
Debugging bugs='roaches' count=13 area='living room'

Zobacz wyrażenia samodokumentujące po więcej informacji na temat
specyfikatora "=". Informacje o specyfikacjach formatu znajdziesz w
przewodniku referencyjnym dla mini-języka specyfikacji formatu.


7.1.2. Metoda format() ciągu znaków
-----------------------------------

Podstawowe użycie metody "str.format()" wygląda tak:

   >>> print('Jesteśmy {}, którzy mówią „{}!”'.format('rycerzami', 'Ni'))
   Jesteśmy rycerzami, którzy mówią „Ni!”

Nawiasy i znaki wewnątrz nich (zwane polami formatu) są zastępowane
obiektami przekazywanymi do metody "str.format()". Liczba w nawiasach
może być użyta do odwołania się do pozycji obiektu przekazanego do
metody "str.format()".

   >>> print('{0} i {1}'.format('mielonka', 'jajka'))
   mielonka i jajka
   >>> print('{1} i {0}'.format('mielonka', 'jajka'))
   jajka i mielonka

Jeśli argumenty nazwane są używane w metodzie "str.format()", ich
wartości są przywoływane przy użyciu nazwy argumentu.

   >>> print('Ta {food} jest {adjective}.'.format(
   ...       food='mielonka', adjective='absolutnie okropna'))
   Ta mielonka jest absolutnie okropna.

Argumenty pozycyjne i nazwane mogą być dowolnie łączone:

   >>> print('Historia {0}, {1} i {other}.'.format('Billa', 'Manfreda',
   ...                                                    other='Georga'))
   Historia of Billa, Manfreda i Georga.

Jeśli masz naprawdę długi ciąg znaków formatu, którego nie chcesz
dzielić, byłoby miło, gdybyś mógł odwoływać się do zmiennych, które
mają być sformatowane według nazwy zamiast według pozycji. Można to
zrobić, po prostu przekazując dict i używając nawiasów kwadratowych
"'[]'", aby uzyskać dostęp do kluczy.

   >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
   >>> print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; '
   ...       'Dcab: {0[Dcab]:d}'.format(table))
   Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Można to również zrobić, przekazując dict "table" jako argumenty
nazwane przy użyciu notacji "**".

   >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
   >>> print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))
   Jack: 4098; Sjoerd: 4127; Dcab: 8637678

Jest to szczególnie przydatne w połączeniu z wbudowaną funkcją
"vars()", która zwraca słownik zawierający wszystkie zmienne lokalne:

   >>> table = {k: str(v) for k, v in vars().items()}
   >>> message = " ".join([f'{k}: ' + '{' + k +'};' for k in table.keys()])
   >>> print(message.format(**table))
   __name__: __main__; __doc__: None; __package__: None; __loader__: ...

Jako przykład, poniższe wiersze tworzą uporządkowany zestaw kolumn
zawierających liczby całkowite oraz ich kwadraty i sześciany:

   >>> for x in range(1, 11):
   ...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
   ...
    1   1    1
    2   4    8
    3   9   27
    4  16   64
    5  25  125
    6  36  216
    7  49  343
    8  64  512
    9  81  729
   10 100 1000

Aby uzyskać pełny przegląd formatowania ciągów znaków za pomocą
funkcji "str.format()", zobacz Format String Syntax.


7.1.3. Ręczne formatowanie ciągów znaków
----------------------------------------

Oto ta sama tabela kwadratów i sześcianów, sformatowana ręcznie:

   >>> for x in range(1, 11):
   ...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
   ...     # zwróć uwagę na użycie 'end' w poprzedniej linii
   ...     print(repr(x*x*x).rjust(4))
   ...
    1   1    1
    2   4    8
    3   9   27
    4  16   64
    5  25  125
    6  36  216
    7  49  343
    8  64  512
    9  81  729
   10 100 1000

(Zauważ, że jedna spacja między każdą kolumną została dodana przez
sposób działania funkcji "print()": zawsze dodaje ona spacje między
swoimi argumentami.)

Metoda "str.rjust()" obiektów typu string wyrównuje ciąg znaków do
prawej strony w polu o zadanej szerokości poprzez wypełnienie go
spacjami po lewej stronie. Istnieją podobne metody "str.ljust()" i
"str.center()". Metody te niczego nie wypisują, a jedynie zwracają
nowy ciąg znaków. Jeśli wejściowy ciąg jest zbyt długi, nie obcinają
go, ale zwracają go bez zmian; spowoduje to bałagan w układzie kolumn,
ale zwykle jest to lepsze niż alternatywa, która polegałaby na
kłamaniu na temat wartości. (Jeśli naprawdę chcesz przycinania, zawsze
możesz dodać operację wycinania, jak w "x.ljust(n)[:n]".)

Istnieje jeszcze jedna metoda, "str.zfill()", która wypełnia ciąg
liczbowy po lewej stronie zerami. Rozumie ona znaki plus i minus:

   >>> '12'.zfill(5)
   '00012'
   >>> '-3.14'.zfill(7)
   '-003.14'
   >>> '3.14159265359'.zfill(5)
   '3.14159265359'


7.1.4. Stare formatowanie ciągów znaków
---------------------------------------

Operator % (modulo) może być również używany do formatowania ciągów
znaków. Dla "format % values" (gdzie *format* jest ciągiem znaków),
specyfikacje konwersji "%" w ciągu znaków *format* są zastępowane
przez zero lub więcej elementów *values*. Operacja ta jest powszechnie
znana jako interpolacja ciągów znaków. Na przykład:

   >>> import math
   >>> print('Wartość pi to około %5.3f.' % math.pi)
   Wartość pi to około 3.142.

Więcej informacji można znaleźć w sekcji printf-style String
Formatting.


7.2. Odczytywanie i zapisywanie plików
======================================

"open()" zwraca *obiekt pliku* i jest najczęściej używany z dwoma
argumentami pozycyjnymi i jednym argumentem nazwanym: "open(filename,
mode, encoding=None)"

   >>> f = open('plikroboczy', 'w', encoding="utf-8")

Pierwszy argument to ciąg znaków zawierający nazwę pliku. Drugi
argument to kolejny ciąg znaków zawierający kilka znaków opisujących
sposób, w jaki plik będzie używany. *Tryb* może być "'r'" gdy plik
będzie tylko do odczytu, "'w'" tylko do zapisu (istniejący plik o tej
samej nazwie zostanie usunięty), a "'a'" otwiera plik do dołączania;
wszelkie dane zapisane do pliku są automatycznie dodawane na
koniec.``'r+'`` otwiera plik zarówno do odczytu, jak i zapisu.
Argument *trybu* jest opcjonalny; jeśli zostanie pominięty, zakłada
się, że domyślnie został wybrany "'r'".

Zwykle pliki są otwierane w trybie tekstowym *text mode*, co oznacza,
że czytasz i zapisujesz ciągi znaków do i z pliku, które są kodowane w
określonym *kodowaniu*. Jeśli *kodowanie* nie jest określone, domyślne
jest zależne od platformy (patrz "open()"). Ponieważ UTF-8 jest
współczesnym standardem, zaleca się stosowanie "encoding="utf-8"",
chyba że wiesz, że musisz użyć innego kodowania. Dodanie "'b'" do
trybu otwiera plik w trybie binarnym *binary mode*. Dane w trybie
binarnym są odczytywane i zapisywane jako obiekty "bytes". Nie możesz
określić kodowania podczas otwierania pliku w trybie binarnym.

W trybie tekstowym domyślnym podczas odczytywania następuje konwersja
końcówek linii specyficznych dla platformy ("\n" na systemie Unix,
"\r\n" na systemie Windows) na pojedynczy znak "\n". Podczas zapisu w
trybie tekstowym domyślnym jest konwersja wystąpień "\n" z powrotem na
końcówki linii specyficzne dla platformy. Ta niewidoczna modyfikacja
danych pliku jest odpowiednia dla plików tekstowych, ale uszkodzi dane
binarne, takie jak te w plikach "JPEG" lub "EXE". Bądź bardzo
ostrożny, używając trybu binarnego podczas odczytywania i zapisywania
takich plików.

Używanie "with" podczas pracy z obiektami plików należy do dobrych
praktyk. Zaletą tego podejścia jest to, że plik jest prawidłowo
zamykany po zakończeniu jego bloku, nawet jeśli w pewnym momencie
zostanie zgłoszony wyjątek. Użycie "with" jest również znacznie
krótsze niż pisanie równoważnych bloków "try" - "finally":

   >>> with open('plikroboczy', encoding="utf-8") as f:
   ...     read_data = f.read()

   >>> # Możemy sprawdzić, że plik został automatycznie zamknięty.
   >>> f.closed
   True

Jeśli nie używasz "with" to powinieneś wywołać "f.close()" w celu
zamknięcia pliku i natychmiastowego zwolnienia wszystkich zasobów
systemowych wykorzystywanych przez ten plik.

Ostrzeżenie:

  Wywołanie "f.write()" bez użycia "with" lub "f.close()" **może**
  spowodować, że argumenty "f.write()" nie zostaną w pełni zapisane na
  dysku, nawet jeśli program zakończy się pomyślnie.

Po zamknięciu obiektu pliku, zarówno przez instrukcję "with", jak i
"f.close()", wszystkie próby użycia obiektu pliku automatycznie się
nie powiodą.

   >>> f.close()
   >>> f.read()
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   ValueError: I/O operation on closed file.


7.2.1. Metody obiektów plików
-----------------------------

Reszta przykładów w tej sekcji zakłada, że obiekt pliku o nazwie "f"
został już utworzony.

Aby odczytać zawartość pliku, należy wywołać polecenie "f.read(size)",
które odczytuje pewną ilość danych i zwraca je jako ciąg znaków (w
trybie tekstowym) lub obiekt bajtowy (w trybie binarnym). *size* jest
opcjonalnym argumentem numerycznym.  Gdy *size* jest pominięty lub
ujemny, zostanie odczytana i zwrócona cała zawartość pliku; to twój
problem, jeśli plik jest dwa razy większy niż pamięć twojego
komputera. W przeciwnym razie odczytane i zwrócone zostanie co
najwyżej *size* znaków (w trybie tekstowym) lub *size* bajtów (w
trybie binarnym). Jeśli został osiągnięty koniec pliku, "f.read()"
zwróci pusty ciąg znaków ("''").

   >>> f.read()
   'To jest cały plik.\n'
   >>> f.read()
   ''

"f.readline()" odczytuje pojedynczą linię z pliku; znak nowej linii
("\n") jest pozostawiony na końcu ciągu znaków i jest pomijany tylko w
ostatniej linii pliku, jeśli plik nie kończy się nową linią. To
sprawia, że wartość zwracana jest jednoznaczna; jeśli "f.readline()"
zwróci pusty ciąg znaków, koniec pliku został osiągnięty, podczas gdy
pusta linia jest reprezentowana przez "'\n'", ciąg znaków zawierający
tylko pojedynczą nową linię.

   >>> f.readline()
   'To jest pierwsza linia pliku.\n'
   >>> f.readline()
   'Druga linia pliku\n'
   >>> f.readline()
   ''

Aby odczytać wiersze z pliku, można wykonać pętlę na obiekcie pliku.
Jest to wydajne pamięciowo, szybkie i prowadzi do prostego kodu:

   >>> for line in f:
   ...     print(line, end='')
   ...
   To jest pierwsza linia pliku.
   Druga linia pliku

Jeśli chcesz wczytać wszystkie wiersze pliku w listę, możesz również
użyć "list(f)" lub "f.readlines()".

"f.write(string)" zapisuje zawartość *string* do pliku, zwracając
liczbę zapisanych znaków.

   >>> f.write('To jest test\n')
   13

Inne typy obiektów muszą zostać przekonwertowane – albo na ciąg znaków
(w trybie tekstowym), albo na obiekt bajtowy (w trybie binarnym) –
przed ich zapisaniem:

   >>> value = ('odpowiedź', 42)
   >>> s = str(value)  # konwersja krotki na ciąg znaków
   >>> f.write(s)
   17

"f.tell()" zwraca liczbę całkowitą podającą aktualną pozycję obiektu
pliku w pliku reprezentowaną jako liczba bajtów od początku pliku w
trybie binarnym i nieprzejrzystą liczbę w trybie tekstowym.

Aby zmienić pozycję obiektu pliku, należy użyć "f.seek(offset,
whence)". Pozycja jest obliczana przez dodanie *offset* do punktu
odniesienia; punkt odniesienia jest wybierany przez argument *whence*.
Wartość *whence* równa 0 mierzy od początku pliku, 1 używa bieżącej
pozycji pliku, a 2 używa końca pliku jako punktu odniesienia. *whence*
może zostać pominięty i domyślnie przyjmuje wartość 0, używając
początku pliku jako punktu odniesienia.

   >>> f = open('plikroboczy', 'rb+')
   >>> f.write(b'0123456789abcdef')
   16
   >>> f.seek(5)      # Idź do szóstego bajtu w pliku
   5
   >>> f.read(1)
   b'5'
   >>> f.seek(-3, 2)  # Idź do trzeciego bajtu przed końcem
   13
   >>> f.read(1)
   b'd'

W plikach tekstowych (otwieranych bez "b" w ciągu znaków trybu)
dozwolone jest tylko wyszukiwanie względem początku pliku (wyjątkiem
jest wyszukiwanie do samego końca pliku z "seek(0, 2)"), a jedynymi
poprawnymi wartościami *offset* są te zwrócone z "f.tell()" lub zero.
Każda inna wartość *offset* powoduje niezdefiniowane zachowanie.

Obiekty plikowe mają kilka dodatkowych metod, takich jak "isatty()" i
"truncate()", które są rzadziej używane; zapoznaj się z Library
Reference, aby uzyskać pełny przewodnik po obiektach plikowych.


7.2.2. Zapisywanie struktur danych przy użyciu modułu "json"
------------------------------------------------------------

Ciągi znaków można łatwo zapisywać i odczytywać z pliku. Liczby
wymagają nieco więcej wysiłku, ponieważ metoda "read()" zwraca tylko
ciągi znaków, które będą musiały zostać przekazane do funkcji takiej
jak "int()", która pobiera ciąg znaków taki jak "'123'" i zwraca jego
wartość liczbową 123. W przypadku zapisywania bardziej złożonych typów
danych, takich jak zagnieżdżone listy i słowniki, ręczne parsowanie i
serializowanie staje się skomplikowane.

Zamiast zmuszać użytkowników do ciągłego pisania i debugowania kodu w
celu zapisania skomplikowanych typów danych do plików, Python pozwala
na użycie popularnego formatu wymiany danych zwanego JSON (JavaScript
Object Notation).  Standardowy moduł o nazwie "json" może pobierać
hierarchie danych Pythona i konwertować je na reprezentacje ciągów
znaków; proces ten nazywany jest *serializacją*.  Rekonstrukcja danych
z reprezentacji łańcuchowej nazywana jest *deserializacją*.  Pomiędzy
serializacją i deserializacją, ciąg znaków reprezentujący obiekt może
być przechowywany w pliku lub bazie danych, lub wysłany przez
połączenie sieciowe do odległej maszyny.

Informacja:

  Format JSON jest powszechnie używany przez nowoczesne aplikacje w
  celu umożliwienia wymiany danych. Wielu programistów jest już z nim
  zaznajomionych, co czyni go dobrym wyborem dla interoperacyjności.

Jeśli masz obiekt "x", możesz wyświetlić jego reprezentację JSON za
pomocą prostej linii kodu:

   >>> import json
   >>> x = [1, 'prosta', 'lista']
   >>> json.dumps(x)
   '[1, "prosta", "lista"]'

Inny wariant funkcji "dumps()", zwany "dump()", po prostu serializuje
obiekt do *pliku tekstowego*.  Jeśli więc "f" jest obiektem *pliku
tekstowego* otwartym do zapisu, możemy zrobić tak:

   json.dump(x, f)

Aby ponownie zdekodować obiekt, jeśli "f" jest obiektem *pliku
binarnego* lub *pliku tekstowego*, który został otwarty do odczytu:

   x = json.load(f)

Informacja:

  Pliki JSON muszą być zakodowane w UTF-8. Użyj "encoding="utf-8""
  podczas otwierania pliku JSON jako *pliku tekstowego* zarówno do
  odczytu jak i zapisu.

Ta prosta technika serializacji może obsługiwać listy i słowniki, ale
serializacja dowolnych instancji klas w JSON wymaga nieco dodatkowego
wysiłku. Wyjaśnienie tej kwestii znajduje się w dokumentacji modułu
"json".

Zobacz także:

  "pickle" – moduł pickle

  W przeciwieństwie do JSON, *pickle* jest protokołem, który pozwala
  na serializację dowolnie złożonych obiektów Pythona.  Jako taki,
  jest specyficzny dla Pythona i nie może być używany do komunikacji z
  aplikacjami napisanymi w innych językach. Jest on również domyślnie
  niezabezpieczony: deserializacja danych pickle pochodzących z
  niezaufanego źródła może wykonać dowolny kod, jeśli dane zostały
  spreparowane przez doświadczonego atakującego.
