https://docs.python.org/3/tutorial/inputoutput.html
https://docs.python.org/3/library/string.html
Podstawowe polecenie do wyprowadzania wyników w Pythonie 2 to print. Jest to przyjazny programiście interfejs do standardowego strumienia wyjścia (stdout). Polecenie przekształca obiekt na jego reprezentację tekstową, dodaje formatowanie i przesyła do standardowego wyjścia.
Kolejne elementy po słowie print oddzielamy przecinkami. Przecinek na końcu wiersza z print zapobiega wyświetleniu "\n", czyli przejściu do nowej linii.
W Pythonie 3 print() jest funkcją wbudowaną.
# Konstrukcja podobna do C z procentem i krotką.
# Składnia:
# %[(nazwa)][opcje][szerokość][.precyzja]kod_typu
print("int %d float %f str %s" % (5, 3.14159, "napis"))
# Format z %s jest uniwersalny - korzysta z funkcji str().
print("int %s float %s str %s" % (5, 3.14159, "napis"))
print("%-10s|%10s" % ("napis1", "napis2"))
print("pi = %8.2f" % 3.14159) # po procencie jest krotka
print("pi = %8.2f" % (3.14159,)) # bardziej precyzyjnie
print("a %10.1f b %3d" % (1.23456, 2)) # dwie lub więcej pozycji
# Wyprowadzanie danych do pliku:
afile = open("data.txt", "w")
afile.write("%s %s\n" % (item1, item2)) # jeden sposób
afile.write("{} {}\n".format(item1, item2)) # drugi sposób
print >> afile, item1, item2 # niezbyt ładne, Py2
print(file=afile, item1, item2) # Py3
afile.close()
# Korzystanie z modułu sys.
# Obiekt sys.stdout jest typu file, mode "w".
import sys
print(X)
sys.stdout.write(str(X) + "\n") # jw, równoważne
sys.stdout.write("%s\n" % X) # jw, ale będzie problem dla X tuple
print("{} {}".format("alpha", "beta")) # zalecane
sys.stdout.write("%s %s\n" % ("alpha", "beta")) # jw
sys.stdout.write("{} {}\n".format("alpha", "beta")) # jw
# Można na chwilę zmienić stdout:
import sys
tmp = sys.stdout
sys.stdout = open("log.txt", "a")
print("napis") # komunikat idzie do pliku
sys.stdout.close()
sys.stdout = tmp
# Korzystanie ze słownika przy formatowaniu stringu.
phones = {"Adam": 1234, "Bogdan": 3456, "Czarek": 5678}
print("Telefony: Adam: %(Adam)s, Bogdan: %(Bogdan)s." % phones)
# Można wykorzystać funkcję systemową zwracającą słownik.
name = "elektron"
mass = 0.511034 # MeV
print("%(name)s, masa %(mass)s MeV" % locals())
# Zapis wywołań print działający w Py2 i Py3.
print("napis") # jeden obiekt
print("%s %s %s" % (item1, item2, item3))
print("{} {} {}".format(item1, item2, item3)) # zalecane
# Emulacja funkcji print() z Py3 w Py2.
# print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
def print3(*arguments, **keywords):
import sys
sep = keywords.get("sep", " ")
end = keywords.get("end", "\n")
file = keywords.get("file", sys.stdout)
output = sep.join(str(arg) for arg in arguments)
file.write(output + end)
# Zastosowanie.
print3(1, 2, 3) # zwykłe wywołanie
print3(1, 2, 3, sep="") # wstrzymanie separatora
print3(1, 2, 3, sep="...") # zmiana separatora
print3(4, 5, 6, end="") # wstrzymanie nowego wiersza
print3(7, 9, 9, file=sys.stderr) # przekierowanie strumienia
# PEP 236 - Back to the __future__ # W Py2.6 można włączyć obsługę funkcji print() # z Py3 za pomocą instrukcji import. # Ta instrukcja nie powoduje błędu w Py3. from __future__ import print_function
# Składnia (Py2.6+, Py3):
# S.format(*arguments, **keywords)
# Argumenty pozycyjne.
print("{0} albo {1}".format("prawda", "fałsz")) # prawda albo fałsz
print("{} albo {}".format("prawda", "fałsz")) # prawda albo fałsz (Py2.7, Py3)
print("{1} albo {0}".format("prawda", "fałsz")) # fałsz albo prawda
print("{0} {0} {1} {1}".format("prawda", "fałsz")) # prawda prawda fałsz fałsz
# Formatowanie {position:format_spec}.
# {position:10} typ str, szerokość minimum 10 znaków;
# {position:4d} typ int, szerokość minimum 4 znaki;
# {position:.3f} typ float, 3 cyfry po przecinku;
# {position:8.1f} typ float, 1 cyfra po przecinku, całość 8 znaków;
for x in range(1, 11):
print ( "{0:2d} {1:3d}".format(x, x*x) )
# Argumenty w postaci słów kluczowych.
print("{person} jest {description}".format(
person="Adam", description="okropny"))
# Formatowanie {key:format_spec}.
# {key:d} key wskazuje na typ int;
# Argumenty pozycyjne i słowa kluczowe można używać łącznie.
print("Kali liczyć: {0}, {1}, {2}, {last}.".format(
"jeden", "dwa", "trzy", last="mnóstwo"))
# Kali liczyć: jeden, dwa, trzy, mnóstwo.
# Formatowania {position!conversion:format_spec} oraz
# {key!conversion:format_spec}.
# {position!s} wymusza formatowanie obiektu przez str().
# {position!r} wymusza formatowanie obiektu przez repr().
# {position!a} wymusza formatowanie obiektu przez ascii() (Py3).
# Podobnie {key!s}, {key!r}, {key!a} (Py3).
import math
print("PI wynosi {0} {0!s} {0!r}".format(math.pi))
# 'PI wynosi 3.14159265359 3.14159265359 3.1415926535897931'
# Zastosowanie słownika ze słowami kluczowymi.
table = {"Adam":1234, "Bogdan":5678}
print("Adam {Adam:d}; Bogdan {Bogdan:d}".format(**table))
# Adam 1234; Bogdan 5678
# Using alignment options in format_spec.
# '<' forces the field to be left-aligned within the available space
# '>' forces the field to be right-aligned within the available space
# '^' forces the field to be centered within the available space
# '=' forces the padding to be placed after the sign (if any)
# but before the digits (‘+000000120’)
"|{0:>3}|{1:<3}|{2:^3}|{3:0=+5}|".format('a', 'b', 'c', 12)
# '| a|b | c |+0012|' # [[fill]align][sign][width]
"{:*^20}".format("centered") # use '*' as a fill char
# '******centered******' # [[fill]align][width]
# Użycie nazwy atrybutu i indeksu elementu.
# Formatowanie {position.attr_name}, {position[idx]}.
# Formatowanie {key.attr_name}, {key[idx]}.
L = [11, 12, 13]
"{0[1]}".format(L) # '12'
"{seq[2]}".format(seq=L) # '13'
coord = (3, 5)
"x {0[0]} y {0[1]}".format(coord) # 'x 3 y 5'
p = Point(12, 34)
"{0.x}".format(p) # '12'
"{point.y}".format(point=p) # '34'
c = 2-4j
"complex {0} real {0.real} imag {0.imag}".format(c)
# 'complex (2-4j) real 2.0 imag -4.0'
# Using different bases.
"int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(42)
# 'int: 42; hex: 2a; oct: 52; bin: 101010'
# with 0x, 0o, or 0b as prefix:
"int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(42)
# 'int: 42; hex: 0x2a; oct: 0o52; bin: 0b101010'
# W Py3.6 pojawiły się f-strings, formatted string literals (PEP 498).
# F-strings są szybsze od metody z % i format().
# Rozpoczynają się od prefiksu 'f' lub 'F', w klamrach {} są wyrażenia lub zmienne.
name = "Adam"
age = 18
print(f"Hello, {name}. You are {age}.")
print(f'{2 * 37}') # "74"
print(f"{{18}}") # wynik to "{18}"
print(f"""{function_name(argument)} is funny.""")
print(f'''{instance.method()} is fast.''')
print(f"{variable!r}") # używa repr(), a nie str()
message = (
f"First part {variable1}. "
f"Second part {variable2}. "
f"Third part {variable3}."
) # multiline f-strings (rezultat to jeden wiersz!)
name, phone = 'Andrzej', 4628
f'|{name:10}|{phone:10d}|' # '|Andrzej | 4628|'
# Alignment options can be used.
f'|{name:>10}|{phone:<10}|' # '| Andrzej|4628 |'