• N - počet
• ? - $0-1$
• + - $1-\infty$
• * - $0-\infty$
• argparse.REMAINDER - všechny argumenty jako seznam

parsování argumntů

import argparse
 
def parse_args():
    parser = argparse.ArgumentParser(description='description')
    parser.add_argument('-s', '--something', metavar='SOM',
                        type=str, help='help message', required=True,  dest="something")
    parser.add_argument('-ch', '--choice', metavar='CHOICE', choices=["first", "second"],
                        type=str, help='help message', default="first",  dest="something")
    parser.add_argument('-b', '--bool_arg', action='store_true', help='help message', dest="bool_arg")
    parser.add_argument('positions_arg', metavar='P', type=str, nargs='+', help='help message')
 
    return parser.parse_args()

kodování/dekodování base64

import base64
encoded = base64.b64encode(b"text")
decoded = base64.b64decode(encoded)

najde pozici pro vložení prvku do seřazeného seznamu půlením intervalů

from bisect import bisect_left
pozice = bisect_left([1,2,8,15], 3)

vrátí název prvního měsíce a zkratku středy (pokud se nastaví locale, tak třeba i česky)

import calendar
 
calendar.month_name[1]
calendar.day_abbr[2]

iteruje přes všechny dny měsíce (iteruje i přes dny předchozího a následujícího měsíce, pokud zasahují do prvního nebo posledního týdne)

from calendar import Calendar
 
cal = Calendar()
for month_date in cal.itermonthdates(year, month):
    print(month_date)

Iteruje přes položky csv souboru. K položkám se přistupuje přes klíč, který se vezme z prvního řádku.

import csv
 
with open("soubor.csv") as csvfile:
    csv_reader = csv.DictReader(csvfile, delimiter=";", quotechar='"')
    for row in csv_reader:
        yield row

pojmenovaná ntice

from collections import namedtuple
 
Point = namedtuple("Point", ("x", "y"))
p = Point(x=10, y=11)
print(p.x, p.y)

převede barvu vyjádřenou jako HSV do RGB

from colorsys import hsv_to_rgb
 
(red, green, blue) = hsv_to_rgb(0.8, 0.5, 0.3)

from datetime import datetime, timedelta
 
now = datetime.now()
now -= timedelta(hours=6)
date = now.strftime("%y%m%d")
hour = now.hour

parsuje datum v různých formátech

from datetime import datetime
 
datetime.strptime("2013-11-1", "%Y-%m-%d")
datetime.strptime("2016-05-26 20:56:35", "%Y-%m-%d %H:%M:%S")

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

soubory v UNIX stylu - vrátí seznam bmp souborů z adresáře database

from glob import glob
 
files = glob("database/*.bmp")

vrátí hexadecimální vyjádření hashe z textu

from hashlib import sha256
 
sha256(b"text").hexdigest()

spojí dva seřazené seznamy

from heapq import merge
 
merge([1,5,12], [3,4,18,19])

Importuje znovu modul.

import importlib
importlib.reload(<modul>)

z více iterátorů udělá jeden, který iteruje přes všechny prvky

import itertools
ab = itertools.chain(['a', 'b'], ['c'], ['d', 'e'])
list(ab)

načte data ze souboru soubor.json

import json
 
with open("soubor.json") as f:
    data = json.load(f)

nastaví českou lokalizaci všeho

import locale
 
locale.setlocale(locale.LC_ALL, ("cs_CZ"))

základní logování

import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
 
logger.info("Nějaka zpráva.")

logování do souboru

import logging
logging.basicConfig(filename="file.log", level=logging.DEBUG)

• os.linesep - řetězec nového řádku podle OS

• os.stat(<soubor>) - informace o souboru (práva, datum vytvoření, velikost, …)
• os.unlink(<soubor>) - smaže soubor

nahradí ~ za správný domácí adresář na Linuxu i ve Windows

os.path.expanduser("~/<zbytek cesty>")

vrátí pouze jméno souboru

os.path.basename("<cesta/k/souboru>")

vrátí absolutní cestu

os.path.abspath("<cesta/k/souboru>")

časy souboru

import os
from datetime import datetime
# datum poslední změny souboru
print(datetime.fromtimestamp(os.path.getctime(<sobor>)))
# datum poslední změny obsahu souboru
print(datetime.fromtimestamp(os.path.getmtime(<sobor>)))
# datum posledního přístupu k souboru
print(datetime.fromtimestamp(os.path.getatime(<sobor>)))

rozdělí název souboru na příponu a zbytek

import os
fileName, fileExtension = os.path.splitext('/path/to/somefile.ext')

rodičovský adresář

from pathlib import Path
parent = Path("path/to/file").parent

vytvoří rekurzivně všechny adresáře, pokud neexistují

from pathlib import Path
Path("/my/directory").mkdir(parents=True, exist_ok=True)

spojí cestu

from pathlib import Path
Path("/my/directory").joinpath("file.txt")

rekurzivně najde ve všech podadresářích včetně aktuálního soubory s příponou py

from pathlib import Path
files = Path('.').glob('**/*.py')

seed() inicializuje generátor podle času

náhodně vybere položku

from random import choice
choice(("a", "b", "c"))

náhodně vybere cele číslo z rozsahu 0-9

from random import randrange
randrange(10)

náhodně spřehází položky v seznamu

from random import shuffle
my_list = list(range(1,11))
shuffle(my_list)

• *?, +? - nehladové vyhledávání
• \s - bílý znak
• \S - nebílý znak

použití regulárního výrazu s jeho předkompilováním (dá se využít k optimalizaci)

from re import compile
 
RE_BOOKMARK = compile("(.+/)(\d+)(.*)")
match = RE_BOOKMARK.match("Spojité/60,Black,notBold,notItalic,open,TopLeftZoom,48,77,0.0")
page = int(match.group(2))

rozdělí řetězec podle mezer, ale bere ohled na závorky jak v terminále

import shlex
shlex.split('1 2 "3 4"')
# vysledek je ['1', '2', '3 4']

Přesune adresář rekurzivně i s obsahem.

import shutil
shutil.move("/cesta/k/zdroji", "/cesta/k/cily")

vytvoří TCP spojení k serveru localhost na port 8000 a pošle mu zprávu

import socket
 
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP)
server_address = ('localhost', 8000)
sock.connect(server_address)
message = b"nejaka zprava"
sock.sendall(message)
sock.close()

from sqlite3 import connect
 
connection = connect(<cesta k souboru>)
cursor = connection.cursor()
cursor.execute("""CREATE TABLE "tabulka" (
                  "id" INTEGER PRIMARY KEY,
                  "sloupec1" TEXT,
                  "sloupec2" BLOB)""")
text = "text"
data = b"data"   
cursor.execute("insert into tabulka(sloupec1, sloupec2) values(?, ?)", (text, data))
print(cursor.lastrowid)
connection.commit()
cursor.execute("select id, sloupec1, sloupec2 from tabulka")
for (id, sloupec1, sloupec2) in cursor:
    print(id, sloupec1, sloupec2)
connection.close()

spustí gnuplot a na stdin přesměruje řetězec

from subprocess import Popen, PIPE
 
p = Popen(("gnuplot",), stdin=PIPE)
p.communicate(GNUPLOT_SCRIPT.encode())

spustí program s parametry a jeho výstup uloží do proměnné dump

from subprocess import check_output
 
dump = check_output(("pdftk", "<soubor pdf>", "dump_data_utf8")).decode()

spustí program a návrátovou hodnotu programu uloží do proměnné status

from subprocess import call
 
args = ["pdftk"] + files + ["cat", "output"] + [output]
status = call(args)

uloží výstup programu ls do souboru test.txt

with open("test.txt", "w") as f_output:
    call(["ls", "-l"], stdout=f_output)

vytiskne verzi pythonu

import sys
print(sys.version)

nastaví základní cestu do vnořeného adresáře lib

import os, sys
base_dir = sys.path[0]
sys.path[0] = os.path.join(base_dir, "lib")

vytvoří dočasný soubor, uloží do něj text něco s ním provede a pak ho smaže

from tempfile import NamedTemporaryFile
from subprocess import call
from os import unlink
 
f = NamedTemporaryFile(mode="w", delete=False, prefix='moje', suffix=".txt")
f.write(bookmarks)
f.close()
call(("jpdfbookmarks_cli", file, "--apply", f.name, "--out", file, "--force"))
unlink(f.name)

import unittest
from lib import is_leap_year
 
class TestLeapYear(unittest.TestCase):
    VALUES = {1999: self.assertFalse,
              2000: self.assertTrue,
              2004: self.assertTrue}
 
    def setUp(self):
        # nastavení před testem
 
    def test_is_leap_year(self):
        for year in self.VALUES:
            VALUES[year](is_leap_year(year))
 
    @unittest.skip("preskoci test")
    def test_skip(self):
        self.fail("kdyby se sem dostal, tak by selhal")
 
    def tearDown(self):
        # nastavení po testu

starou metodu nahradí novou, která vrací text „Ahoj“

from unittest.mock import MagicMock
 
class Pozdrav:
    def zdrav(self):
        return "Dobry den"
 
p=Pozdrav()
print(p.zdrav())
p.zdrav = MagicMock(return_value="Ahoj")
print(p.zdrav())

převádí non ASCII znaky do ASCII pro url

import urllib
url="https://cs.wikipedia.org/wiki/P%C5%99esmy%C4%8Dka"
print(urllib.parse.quote(urllib.parse.unquote(url)))

parsování url

from urllib.parse import urlparse
print(urlparse("http://vojta.kalcik.cz/doku.php?id=navody:python_modules#parse"))
# ParseResult(scheme='http', netloc='vojta.kalcik.cz', path='/doku.php', params='', query='id=navody:python_modules', fragment='parse')

vytiskne kód stránky

from urllib.request import urlopen, HTTPError
from sys import stderr
 
url = "http://www.neco.cz/index.html"
try:
    req = urlopen(url)
    print(req.read())
except HTTPError:
    print("Stránka neexistuje!", file=stderr)