základní struktura programu

#! /usr/bin/env python3
 
if __name__ == '__main__':
    pass

převod do/z šestnáctkové soustavy

x = 0xffffff
x = int("ffffff", 16)
x = int("0xffffff", 0)
y = hex(16777215)

zjištění, jestli je proměnná nějakého typu

isinstance('hello', str)
isinstance(7, int)

výčtový typ

from enum import Enum
class Color(Enum):
     RED = 1
     GREEN = 2
     BLUE = 3

vytvoří seznam, který obsahuje délky slov

items=["ahoj", "nazdar", "cau"]
list(map(len, items))

vytvoří seznam skupin položek z původního seznamu, kdy velikost skupin je v proměnné count_members

numbers = range(1,8)
count_members = 3
group_numbers = (numbers[x:x+count_members]
                     for x in range(0, len(numbers), count_members))
print(list(group_numbers)) # [[1, 2, 3],[4, 5, 6],[7]]

globvar = 0
 
def set_globvar_to_one():
    global globvar    # potreba deklarovat promennou jako globalni
    globvar = 1
 
def print_globvar():
    print globvar     # neni potreba deklarovat promennou jako globalni
 
set_globvar_to_one()
print_globvar()       # vytiskne 1

vytvořit soubor ~/.pythonrc.py

try:
    import readline
except ImportError:
    print("Module readline not available.")
else:
    import rlcompleter
    readline.parse_and_bind("tab: complete")

do souboru ~/.bashrc přidat

export PYTHONSTARTUP=$HOME/.pythonrc.py

pokud změníme kod v modulu, tak je možné modul znova načíst následovně

import imp  
imp.reload(zmeneny_modul)

ukázka použití yield

def iter_numbers():
    for i in range(10):
        yield i
 
for number in iter_numbers():
    print(number)

seřadí seznam dvojic podle druhé položky

dvojice = [(1, 12), (5, 74), (105, 50)]
print(sorted(dvojice, key=lambda x:x[1]))

my_set = set()
my_set.add(1)
my_set.add(2)
my_set.remove(1)
print(1 in my_set)

n-tice s jedním prvkem

(1,)

ukázka použití statických metod

class Patient(object):
    CONST_AHOJ = "ahoj"
    def __init__(self, ico):
        self.pozdrav = "pozdrav"
 
    @classmethod
    def print_static(cls):
        print(cls.CONST_AHOJ)

použití property

class Person(object):
    def __init__(self, firstname, surname):
        self.firstname = firstname
        self.surname = surname
 
    @property
    def name(self):
        return self.firstname + " " + self.surname
 
    @name.setter
    def name(self, value):
        parts = value.partition(" ")
        self.firstname = parts[0]
        self.surname = parts[2]

volání kostruktoru rodiče

class A(object):
   def __init__(self):
       print("world")
 
class B(A):
   def __init__(self):
     print("hello")
     super().__init__()
 
B()

• __getitem__(self, i) - objekt[i]
• __init__(self, arg1, arg2, ...) - inicializace objektu
• __iter__(self) - umožňuje iterovat přes objekt

def __iter__(self): return iter(self.pole)

• __len__(self) - len(objekt)
• __setitem__(self, i, hodnota) - objekt[i] = hodnota

class ObjektSWith:
    def __enter__(self):
        return self
 
    def __exit__(self, type, value, tb):
        """metoda pro zavření/ukončení potřebného"""
        pass
 
with ObjektSWith() as obj:
    pass

• x.__lt__(y) - x<y
• x.__le__(y) - x<=y
• x.__eq__(y) - x==y
• x.__ne__(y) - x!=y
• x.__gt__(y) - x>y
• x.__ge__(y) - x>=y

mazání prvků

# smaže všechny prvky
seznam.clear()
# smaže prvek s indexem a vrátí ho
polozka = seznam.pop(1)
# smaže první položku s hodnotou
seznam.remove("hodnota")
# smaže jednu nebo víc položek
del seznam[2]
del seznam[2:5]

seřadí seznam slov podle délky slova

slova = ["z", "bcdefg", "ahoj"]
sorted(slova, key=len)

vrátí klíč nejvyšší hodnoty ve slovníku

slovnik = {"a":10, "b":20, "c":5}
max(slovnik, key=slovnik.get)

vrátí klíče, pro které má slovník hledanou hodnotu

slovnik = {"a":10, "b":20, "c":5}
[k for (k, v) in slovnik.items() if v == 20]

vytoří slovník s počtem písmen v seznamu

pismena = ["a", "z", "a", "b", "b", "a"]
pocet = {}
for pismeno in pismena:
    pocet[pismeno] = pocet.get(pismeno, 0) + 1

rozbalení slovníku jako argumenty funkce

seznam={"pozdrav": "ahoj", "osloveni": "Karle"}
"{pozdrav} {osloveni}".format(**seznam)

vrátí seznam seřazených klíčů sestupně podle jejich hodnoty

seznam={"a": 10, "b": 2, "c": 15}
klice=sorted(seznam, key=seznam.get, reverse=True)

Otevře dva soubory jeden pro čtení a druhý pro zápas. Každý řádek převede na znaky, ty pak spojí do řetězce a zapíše ho druhého souboru.

with open(input_file, 'r') as in_file, open(output_file, 'w') as out_file:
    for line in in_file:
        chars = list(line)
        # process chars
        out_file.write("".join(chars))

vrátí trojici ("polozka", ":", "hodnota")

retezec="polozka:hodnota"
retezec.partition(":")

formátování čísel

"{:03}".format(1) # 001
"{:.2f}".format(1.333) # 1.33

formátování se zadanými jmény

"{b} {a}".format(a=1, b=2)

• b - binární soustava
• c - korespondující unicode character
• d - dekadická soustava
• o - osmičková soustava
• x - hexadecimální soustava (malá písmena)
• X - hexadecimální soustava (velká písmena)
• n - stejné jak d, ale používá národní oddělovač číslic

vytiskne číslo hexadecimálně

"{:x}".format(215)

na UNIXu v příkazové řádce přečte jeden znak z klávesnice

def getchar():
    fd = sys.stdin.fileno()
    old_settings = termios.tcgetattr(fd)
    try:
        tty.setraw(sys.stdin.fileno())
        ch = sys.stdin.read(1)
    finally:
        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
    return ch

vyvolání výjimky TypeError

raise TypeError("nějaký text o chybě")

ošetří vstup od uživatele

try:
    x = int(input("Napiš číslo: "))
except (ValueError, TypeError) as err:
    print("To nebylo číslo!")