Little Umbrellas - floss

How to mount a Flask app under a URL prefix (or really, any WSGI app)

2020-11-15T00:00:00+01:00

Intro

In a hurry? Skip to the minimal working example below!

So this is probably something that seasoned Flask webapp devs will find trivial, especially if they're also well-acquainted with WSGI itself (the Python web server standard that Flask and the other popular synchronous Python web frameworks comply with).

But my background is not like that. I've only occasionally used Flask for a project here and there over the years (and I've been really happy with it, since it delivers on its promise of being "micro" and keeps out of the way most of the time). I learned it mostly through its own docs. I've been aware that WSGI is a thing, but it never occurred to me I should learn more about it, it always felt like the Flask docs (should) cover everything I need.

Which they did, except for the issue mentioned in the title of the article: transparently mounting the app under a URL prefix. Up until yesterday (when I found out basically by sheer luck that this is addressed by the WSGI standard that Flask conforms to), I had no idea what the proper way to do it in Flask was. I never could find any guidance in the Flask docs; as far as I know, I don't think the idiomatic solution I'll be discussing below is covered in there (and I've tried searching them again now that I know what I'm looking for). So I always resorted to clunky workarounds in order to achieve this.

I'm fairly sure I'm not the only person like this -- a happy occasional user of Flask whose one major frustration has been having to manually smuggle URL prefixes into his routes. If you have a similar background, then may Google be more clement than it was to me and rank this article on the first page of its results when you hit this particular roadblock ;)

If you're a Flask / WSGI whiz, then your reaction will probably be "But of course this is how it's done!" So in order to get something out of this article, you can instead muse upon the relative merits and drawbacks of splitting up technical documentation in a way that's well-organized / clearly delineated / methodical / logical (= Flask info in Flask docs, WSGI info in WSGI docs) vs. in a way that's useful and accessible even to occasional users, beginners etc. (= Flask docs might want to cover the parts of WSGI that a budding Flask dev might want to care about, even though that means duplicating information).

The problem

As you're prototyping and developing a Flask app, routing is pretty easy and straightforward:

@app.route("/login", methods=["GET", "POST"])
def login_func():
    ...

But when the time comes to deploy it, you often realize you need to mount it under a URL prefix, e.g. /my-app. For the route above, that means that you want to trigger it when users navigate to example.com/my-app/login, not example.com/login. And similarly, you want this prefix added when generating internal redirects or links in your templates.

So you think to yourself, this is surely such a common use case that there's definitely an example how to do this directly in Flask's Quickstart. Or failing that, definitely somewhere in the docs.

So you search the docs for a reasonable query like "url prefix", which sounds like what you're interested in, and you learn about blueprints, which is where stuff starts to become confusing. Blueprints are for making reusable application components and they support registering at a URL prefix and/or a subdomain.

They're also a fairly advanced feature useful in more complicated apps, so they sort of go against the grain of your expectations with Flask. You likely picked up Flask because you liked that a simple app can consist of just a single Python module and a few lines of code, but now it looks like if you want to run it in production in a flexible way, you'll need to learn about blueprints and rewrite it as one? Because it sure doesn't look like vanilla Flask apps support URL prefixes, the docs don't mention any promising leads...

So you end up deciding to roll your own homegrown solution, which might be configurable but still boilerplate-y if you still have some mental energy left to invest into the problem:

PREFIX = "/my-app"

@app.route(f"{PREFIX}/login", methods=["GET", "POST"])
def login_func():
    ...

Or it might just be hardcoded to show you really don't care anymore, if you've just lost an hour searching for a Flask feature that would handle this in a civilized manner, and/or reading up on blueprints (before giving up):

@app.route("/my-app/login", methods=["GET", "POST"])
def login_func():
    ...

If that sounds like you (and it certainly sounds like me), then boy do I have good news for you :) Turns out there actually is a right way to do it!

The idiomatic solution

The title of the article hints at the reason why the right way to do it is so hard to figure out: it turns out that deploying a Flask app under a URL prefix isn't actually a feature of Flask per se, it's a feature of the Python WSGI standard that Flask conforms to. So that's probably why the way to achieve this isn't described in the Flask docs themselves, because I suppose you're expected to read up on the available WSGI knobs and handles separately...? Frankly, I don't think that's a realistic expectation :) I think this information would make a great addition to the Flask docs, maybe even directly in the Quickstart section.

So what's the trick? The trick is to set the rather quirkily/quaintly named SCRIPT_NAME environment variable prior to starting the web server running the app. If you set SCRIPT_NAME=/my-app, WSGI guarantees that the web server running your app will strip this prefix from incoming URLs, and add it to outgoing URLs (redirects, in-app links in templates). That's it, no need to modify your app at all, whether to add a configurable or hardcoded prefix to all the routes, or to rewrite it as a blueprint. Nice.

EDIT: As u/james_pic points out over on Reddit, reading SCRIPT_NAME from an env var is actually not required by the WSGI spec, it's a convenience feature provided by some WSGI servers, e.g. Gunicorn.

Caveats

Because of course, there are a few issues you might run into.

Flask's builtin web server ignores `SCRIPT_NAME`

EDIT: As should be clear from the previous edit, Flask's builtin web server only ignores the SCRIPT_NAME env var. It works perfectly well with the SCRIPT_NAME WSGI variable, which however requires quite a bit more work to set up. You need to add WSGI routing middleware to your application, e.g. like this:

from werkzeug.middleware.dispatcher import DispatcherMiddleware
from werkzeug.wrappers import Response

app.wsgi_app = DispatcherMiddleware(
    Response('Not Found', status=404),
    {'/my-app': app.wsgi_app}
)

Presumably, you'd make the actual value of the prefix part of the app's config.

(Code sample courtesy of u/james_pic over on Reddit, thank you!)

When you find out about SCRIPT_NAME, your first intuition is to test if it indeed does what you need with Flask's builtin dev server, because, well, that's what you use for development. Unfortunately, it turns out that Flask's server couldn't care less about this env var, which might lead you to (wrongly) conclude that you're on the wrong path. I actually think this happened to me a few years back because I feel like I've tinkered with SCRIPT_NAME before, only to conclude it doesn't seem to do anything.

The fix: just use a ~~fully-featured production~~ WSGI server that supports reading this configuration from an environment variable, e.g. Gunicorn. I promise SCRIPT_NAME works there.

Alternatively, add some routing middleware of the kind sketched above to your app.

Is this one of the reasons why Flask's builtin server warns "This is a development server. Do not use it in a production deployment"? I'd always thought it was for performance / stability / security reasons, but it looks like it also just isn't (fully) WSGI-compliant.

Use `url_for` to generate internal links

I.e. instead of writing href="/login" in your templates or redirect("/login") in your view functions, write href="{{ url_for('login_func') }}" and redirect(url_for("login_func")). This will make sure the URLs are correctly prefixed with SCRIPT_NAME, if applicable.

This is recommended as best practice by the Flask docs anyway, so it's not like it's additional hoops to jump through. Interestingly, this section in the Flask docs is the closest they brush with discussing mounting the app under a URL prefix. They tell you:

If your application is placed outside the URL root, for example, in /myapplication instead of /, url_for() properly handles that for you.

But they don't tell you how to place your application outside the URL root in the first place, which is kind of maddening. If you open the link to the url_for() docs, you are further teased with mentions of APPLICATION_ROOT and SERVER_NAME configuration values, which sound a lot like the kind of setting you were looking for, except the docs immediately dash your hopes and remain silent about what you really want, i.e. the SCRIPT_NAME env var:

Configuration values APPLICATION_ROOT and SERVER_NAME are only used when generating URLs outside of a request context.

I remember tearing my hair out in despair at this point of digging through the Flask docs and trying in vain (of course) to tinker with those configuration values a few years back.

EDIT: Again, after reading u/james_pic's very helpful and insightful comment on Reddit, I've realized the Flask docs technically do contain information which can help you figure this out, in the Application Dispatching section, specifically under Dispatch by Path.

The trouble is that the section is introduced by the following sentence:

Application dispatching is the process of combining multiple Flask applications on the WSGI level.

Which sounds like it's once again a more advanced topic (kind of like blueprints) meant for people who are trying to run multiple apps under the same WSGI server at the same time (which you're not). The code examples are fairly complex to match, so at first sight, it doesn't look like this is what you should be spending your time reading if you just need to figure out something as basic as running your app under a URL prefix in production.

Don't strip the prefix in your reverse proxy config

If you're configuring your Flask app under a URL prefix, it's probably running behind a reverse proxy of some sort (Nginx, Apache, etc.). Reverse proxies can be configured to strip these prefixes when relaying requests to individual apps, but don't do this!

You want to leave the handling of the prefix to the WSGI server running your app, because the WSGI server has intimate knowledge about the app (it knows it can expect the app to talk WSGI), so it can be smart about how exactly prefix handling should be done. By contrast, the reverse proxy has very little information about your app -- it can rewrite incoming URLs in request headers fairly easily, but that's about it, it can hardly rewrite outgoing URLs in response bodies, that would be non-trivial. That's what sprinkling url_for()s where appropriate throughout your app is for (see previous section).

So make sure your reverse proxy leaves the prefix alone. As an example, for Nginx, you don't want this, which would get rid of the /my-app/ prefix:

location /my-app/ {
    proxy_pass http://127.0.0.1:8000/;
    # ...
}

~~Instead, you want this:~~

location /my-app/ {
    proxy_pass http://127.0.0.1:8000/my-app/;
    # ...                            ^^^^^^^
}

Actually, as Ivan Shatsky helpfully pointed out in the comments, you want this:

location /my-app/ {
    proxy_pass http://127.0.0.1:8000;
    # ...
}

Notice the lack of a trailing slash after the port number. The effect will be the same, but you'll save some CPU cycles -- instead of first stripping the prefix and then adding the same one, Nginx just completely leaves it alone.

Minimal working example

Let's wrap up with a runnable demo. Put this in app.py:

from flask import Flask, url_for

app = Flask(__name__)

@app.route("/")
def index():
    return url_for("index")

Run the app with a WSGI-compliant web server, e.g. Gunicorn (again, not Flask's builtin dev server, see above), while setting the SCRIPT_NAME env var:

$ SCRIPT_NAME=/my-app gunicorn app:app

Now try accessing / with curl:

$ curl localhost:8000/

You should get an internal server error. If you inspect the traceback in the window where the app is running, you'll see this was due to the fact that the expected /my-app prefix wasn't found, so try adding it:

$ curl localhost:8000/my-app/
/my-app/

Now everything works, even though your app's source code is clean and blissfully unaware of any prefix. Gunicorn strips away the prefix from the request before passing it on to your app's router, and url_for takes care of adding the prefix back into any internal link generated by your app, as you can see in the output (/my-app/ instead of /).

Just to confirm Flask's builtin development server doesn't ~~properly handle~~ read SCRIPT_NAME from the environment -- run the app with it:

$ FLASK_APP=app SCRIPT_NAME=/my-app flask run

The prefix is ignored, which means that accessing / works (which we don't want):

$ curl localhost:5000/
/

And /my-app/ unfortunately doesn't:

$ curl localhost:5000/my-app/
# outputs Flask's default 404 message

Vše, co jste kdy chtěli vědět o Pythonu...

2018-11-07T00:00:00+01:00

... ale báli jste se zeptat na hodině ;)

In [1]:

from utils import TableOfContents

TableOfContents("python_crash_course.ipynb")

Objekty¶

Programování v Pythonu spočívá v manipulaci s různými objekty -- čísli, řetězci (písmen), seznamy, funkcemi... Zastřešující pojem "objekt" naznačuje analogii s fyzickými předměty. Každý předmět slouží k něčemu jinému, něco s ním lze udělat jednoduše, něco hůř, něco vůbec; taky případně může obsahovat další předměty. Podobně v Pythonu: čísla se hodí na sčítání, ale nemůžeme změřit jejich délku; a seznam jakožto objekt je vlastně kolekcí dalších objektů, jeho prvků.

Když Python spustíte, načte se poměrně velké množství zabudovaných objektů (funkcí a konstant), se kterými můžete rovnou začít pracovat. Např. funkce sorted vytvoří z libovolného iterovatelného objektu (= objektu, ze kterého lze jeden po druhém tahat nějaké jeho dílčí prvky) seřazený seznam:

In [2]:

# cokoli za znakem # na jakémkoli řádku Python ignoruje,
# jsou to tzv. komentáře, které slouží jen lidem
sorted

Out[2]:

<function sorted(iterable, /, *, key=None, reverse=False)>

(Seznam všech zabudovaných funkcí -- built-in functions -- v Pythonu)

Konstanta True zas označuje "pravdu" (v logickém smyslu)...

In [3]:

True

Out[3]:

True

... takže ji Python vrátí jako výslednou hodnotu při vyhodnocení pravdivého výroku:

In [4]:

2 + 2 == 4

Out[4]:

True

Ale další objekty si můžeme libovolně vytvářet.

In [5]:

# čísla
42

Out[5]:

In [6]:

# řetězce
"Hello, world!"

Out[6]:

'Hello, world!'

Proměnné¶

Abychom s objekty mohli dál pracovat, je potřeba je nějak pojmenovat, jinak na ně nemůžeme odkazovat. Štítek se jménem můžeme na objekt pověsit pomocí přiřazovacího operátoru =.

In [7]:

vzdálenost = 10

In [8]:

čas = 20

In [9]:

rychlost = vzdálenost / čas

In [10]:

rychlost

Out[10]:

0.5

Těm štítkům se jmény se říká proměnné, protože je lze libovolně kdykoli pověsit na jiný objekt.

In [11]:

vzdálenost = 5

In [12]:

rychlost = vzdálenost / čas

In [13]:

rychlost

Out[13]:

0.25

Jsou i jiné způsoby, jak pověsit štítek se jménem na nějaký objekt. Např. když teď vytvoříme funkci a pojmenujeme ji rychlost, tak štítek rychlost strhneme z čísla 0.25, na které jsme ho naposledy navěsili, a nalepíme ho na tu funkci (která je z hlediska Pythonu zase jen dalším typem objektu, jako čísla, řetězce atp.).

In [14]:

def rychlost(vzdálenost, čas):
    return vzdálenost / čas

In [15]:

rychlost

Out[15]:

<function __main__.rychlost(vzdálenost, čas)>

Nyní tedy už proměnná rychlost neodkazuje na číslo 0.25, ale na funkci, kterou jsme právě vytvořili.

Funkci můžeme zavolat, tj. spustit "recept" (sérii kroků, malý dílčí program), který je v ní uložený:

In [16]:

rychlost(vzdálenost, čas)

Out[16]:

0.25

Nic nebrání tomu, abychom na existující objekty navěsili štítků víc, a můžeme k tomu použít stávající štítky:

In [17]:

distance = vzdálenost
time = čas
speed = rychlost

In [18]:

speed(distance, time)

Out[18]:

0.25

Jak to funguje? Python nejprve vyhodnotí výraz napravo od operátoru =, tj. v tomto případě jen dohledá objekty, na které odkazují původní proměnné, a pak na ty samé objekty navěsí další nové štítky (uvedené nalevo od operátoru =).

Všimněte si, že jsme tímto způsobem jednoduše přiřadili další jméno i funkci rychlost:

In [19]:

speed

Out[19]:

<function __main__.rychlost(vzdálenost, čas)>

To, zda dvě jména (dvě proměnné) odkazují na ten samý objekt, jednoduše zjistíme pomocí operátoru is:

In [20]:

distance is vzdálenost

Out[20]:

True

In [21]:

distance is čas

Out[21]:

False

In [22]:

distance = čas

In [23]:

distance is čas

Out[23]:

True

In [24]:

speed is rychlost

Out[24]:

True

POZN.: Rovnost (x == y) a identita (x is y) jsou dvě různé věci. Dva různé objekty (z hlediska identity) jsou si rovné, pokud reprezentují tu samou hodnotu. Např. dva různé seznamy čísel od jedné do tří:

In [25]:

x = [1, 2, 3]
y = [1, 2, 3]

In [26]:

x == y

Out[26]:

True

In [27]:

x is y

Out[27]:

False

Je to podobně jako s jednovaječnými dvojčaty: vypadají stejně, takže třeba pro účel focení jsou zaměnitelná, ale to neznamená, že je to ten samý člověk.

Ještě pár slov ke konvencím pojmenovávání proměnných v Pythonu:

u drtivé většiny proměnných (vč. funkcí) je zvykem používat jen malá písmena, např. proměnná
občas se používají i číslice, např. x1, ale jméno proměnné číslicí nesmí začínat
když pojmenování sestává z více slov, oddělují se pomocí podtržítka, např. víceslovná_pojmenování (tzv. snake case)
proměnné, které se používají napříč celým programem (často je definujeme na začátku programu a pak na ně odkazujeme v růzých jeho částech), se někdy odlišují pomocí velkých písmen, např. ABECEDA nebo RYCHLOST_SVĚTLA
jména tříd (viz níže) jsou většinou v tzv. camel case s velkým počátečním písmenem, např. Třída či JináTřída

Jméno proměnné by nemělo být moc dlouhé, ale zároveň by mělo být deskriptivní -- mělo by srozumitelně naznačovat, k čemu proměnná slouží, jak se používá. Hezky a trefně pojmenovat proměnnou je často těžší, než by se na první pohled mohlo zdát. Když píšete program na jedno použití, je to jedno, ale pokud po sobě budete program ještě někdy číst (nebo někdo jiný), budete za každou smysluplně pojmenovanou proměnnou (a každý vhodně umístěný komentář) vděční.

Typy a třídy¶

Každý objekt v Pythonu spadá do nějaké kategorie objektů -- např. číslo, řetězec, seznam apod. -- podobně jako předměty v reálném světě spadají do různých kategorií (všechny kočky do kategorie "kočka", všechny tužky do kategorie "tužka" apod.). Těmto kategoriím s v Pythonu říká typy a u libovolného objektu lze zjistit jeho typ pomocí funkce type:

In [28]:

obj = 1
type(obj)

Out[28]:

int

In [29]:

obj = "ahoj"
type(obj)

Out[29]:

str

In [30]:

obj = [1, "ahoj"]
type(obj)

Out[30]:

list

In [31]:

type(1) == type(2)

Out[31]:

True

In [32]:

type("a") == type("b")

Out[32]:

True

In [33]:

# ovšem pozor
type("1")

Out[33]:

str

In [34]:

type(1) == type("1")

Out[34]:

False

Typy jako int, str nebo list jsou v Pythonu přímo zabudované, jsou k dispozici vždycky. Ale každý programátor si může definovat vlastní typy a dále s nimi pracovat. Těmto uživatelsky definovaným typům se říká třídy, podle klíčového slovíčka class, pomocí něhož se definují:

In [35]:

class FooBar:
    # klíčové slovíčko pass je prázdný příkaz (Python na jeho základě nic
    # nevykoná)
    pass

Instanci třídy, tj. konkrétní objekt, jehož typem bude daná třída, vytvoříme tak, že zavoláme tzv. konstruktor, tj. funkci, která nám instanci "postaví", "zkonstruuje". Počáteční sestavení a nastavení objektu někdy nazýváme inicializací. Jako konstruktor většinou slouží třída samotná, kterou zavoláme jako funkci:

In [36]:

obj = FooBar()
type(obj)

Out[36]:

__main__.FooBar

In [37]:

type(obj) is FooBar

Out[37]:

True

Oproti tomu instance zabudovaných typů můžeme vytvářet i pomocí speciálních zápisů, tzv. literálů, nepotřebujeme k tomu nutně funkce. V konstruktoru je proces vytváření objektu svým způsobem skrytý, není na první pohled jasné, co se v něm odehrává (obecně může konstruktorem být libovolná funkce), kdežto v literálu doslova (angl. literally) prostě jen vypíšeme, jak má nějaký objekt vypadat, a Python nám ho podle toho poskládá:

In [38]:

# číselný literál
42

Out[38]:

In [39]:

# řetězcový literál
"Hello, world!"

Out[39]:

'Hello, world!'

Literály jsou součástí syntaxe Pythonu, tj. pravidel pro skládání programů tak, aby jim Python rozuměl a mohl je vykonávat. Důležité jsou ještě literály pro vytváření kolekcí (viz odd. Kolekce).

Chceme-li ověřit, zda je nějaký objekt instancí nějaké dané třídy či obecněji typu, můžeme použít funkci isinstance.

In [40]:

isinstance(obj, FooBar)

Out[40]:

True

In [41]:

isinstance(1, int)

Out[41]:

True

Třídy se hodí pro některé pokročilejší programátorské účely (viz např. notebook object_oriented.ipynb). V tomto semestru se jim blíže nevěnujeme.

Importování knihoven¶

Knihovna (též balíček, angl. package) je v programování soubor funkcí, tříd atp., které jsou často užitečné, takže nemá smysl, aby si je každý programátor implementoval znovu a znovu, když je potřebuje. Zároveň ale nejsou potřeba úplně pořád, takže taky nemá smysl, aby byly do Pythonu přímo zabudované (tj. aby byly k dispozici pokaždé, když Python spustíme, podobně třeba jako funkce sorted). Vždy jsou ale na dosah ruky, stačí je importovat.

Např. knihovna random obsahuje funkcionalitu související s generováním náhodných čísel:

In [42]:

import random

# následujícímu příkazu není potřeba věnovat přílišnou
# pozornost, jen zajistí, abychom pokaždé dostali stejnou
# sérii pseudonáhodných čísel; viz:
# https://docs.python.org/3/library/random.html#random.seed
random.seed(42)

K objektům, které knihovna definuje, se pak dostaneme přes tečku. Např. pokud chceme pomocí funkce randint vygenerovat náhodné číslo mezi jednou a deseti:

In [43]:

random.randint(1, 10)

Out[43]:

Při importu si lze knihovnu přejmenovat pomocí klíčového slovíčka as, např. pokud jméno random už v programu používáme pro něco jiného.

In [44]:

random = "random. angl. náhodný"

import random as rnd

rnd.randint(1, 10), random

Out[44]:

(1, 'random. angl. náhodný')

Taky je možné si z knihovny naimportovat přímo jeden konkrétní objekt (funkci, třídu atp.):

In [45]:

from random import randint

randint(1, 10)

Out[45]:

To se hodí zejm. v případě, kdy objekt budeme používat často a nechce se nám pokaždé zdlouhavě psát jméno_knihovny.jméno_objektu. Pokud chceme, můžeme si jich rovnou naimportovat i víc zároveň:

In [46]:

from random import random, randint

random(), randint(1, 10)

Out[46]:

(0.24489185380347622, 3)

Větší knihovny sestávají z dílčích modulů, které při importu oddělujeme tečkami.

In [47]:

import os.path

this_file = "python_crash_course.ipynb"

os.path.isfile(this_file)

Out[47]:

True

In [48]:

import os.path as osp

osp.realpath(this_file)

Out[48]:

'/home/david/src/dlukes.github.io/content/notebooks/python_crash_course.ipynb'

In [49]:

from os.path import splitext

splitext(this_file)

Out[49]:

('python_crash_course', '.ipynb')

Funkce¶

Funkce je jako recept -- série příkazů, malý dílčí program, který má jméno, pomocí něhož ho můžeme kdykoli spusit, tzv. zavolat. Funkci definujeme pomocí klíčového slovíčka def...

In [50]:

def hoď_kostkou():        # hlavička
    return randint(1, 6)  # tělo

... a voláme tak, že napíšeme její jméno a za ně kulaté závorky:

In [51]:

hoď_kostkou()

Out[51]:

Recept uložený ve funkci se vykonává krok po kroku (řádek po řádku), dokud Python nenarazí na klíčové slovíčko return. V tu chvíli funkci ukončí a hodnotu výrazu, který se nachází za return, vrátí jako výsledek celé funkce. Tento výsledek můžeme uložit do proměnné:

In [52]:

výsledek_hodu_kostkou = hoď_kostkou()

In [53]:

výsledek_hodu_kostkou

Out[53]:

Do těla funkce patří vše, co následuje po hlavičce a je odsazené alespoň o jednu úroveň dál než samotná hlavička:

In [54]:

def function():
    print("Tohle patří do těla funkce.")
    print("Tohle taky.")

print("Tohle už ne.")

Tohle už ne.

In [55]:

function()

Tohle patří do těla funkce.
Tohle taky.

Funkce často mají jeden nebo více parametrů či argumentů, tj. proměnných, které deklarujeme v hlavičce funkce. Např. následující funkce má parametry počet_stěn a násobek.

In [56]:

def hoď_kostkou_a_vynásob(počet_stěn, násobek):
    return randint(1, počet_stěn) * násobek

Když funkci voláme, je potřeba za parametry dosadit konkrétní objekty, které funkce pak v rámci receptu použije:

In [57]:

hoď_kostkou_a_vynásob(20, 100)

Out[57]:

POZN.: Přísně vzato bychom měli takto rozlišovat mezi (formálními) parametry (= proměnnými, se kterými pracujeme při definici funkce a které v tu chvíli nereprezentují žádnou konkrétní hodnotu) a (konkrétnimi) argumenty (= konkrétními objekty, které funkci předáme ve chvíli, kdy ji voláme). Nicméně často tento rozdíl není příliš důležitý, takže v praxi se oba termíny používají zaměnitelně.

Parametry mohou mít defaultní hodnotu:

In [58]:

def hoď_kostkou_a_vynásob(počet_stěn, násobek=100):
    return randint(1, počet_stěn) * násobek

Pokud nám defaultní hodnota daného parametru vyhovuje, nemusíme ho pak při volání specifikovat:

In [59]:

hoď_kostkou_a_vynásob(20)

Out[59]:

Pokud nám naopak nevyhouje, nic nám v tom nebrání:

In [60]:

hoď_kostkou_a_vynásob(20, 0.01)

Out[60]:

0.19

Parametrům bez defaultní hodnoty se říká povinné (je potřeba je specifikovat vždy), parametrům s defaultní hodnotou pak volitelné.

Parametry můžeme funkci předávat buď na základě pořadí (tzv. pozičně)...

In [61]:

# počet_stěn = 4, násobek = 10
hoď_kostkou_a_vynásob(4, 10)

Out[61]:

In [62]:

# počet_stěn = 10, násobek = 4
hoď_kostkou_a_vynásob(10, 4)

Out[62]:

... nebo pomocí jejich jmen (pak hovoříme o pojmenovaných argumentech, angl. named nebo též keyword arguments):

In [63]:

hoď_kostkou_a_vynásob(počet_stěn=4, násobek=10)

Out[63]:

In [64]:

# v tomto případě na pořadí nezáleží
hoď_kostkou_a_vynásob(násobek=10, počet_stěn=4)

Out[64]:

Oba způsoby můžeme i kombinovat, dokonce je to velmi časté. V Pythonu je většinou zvykem, že se povinné parametry předávají pozičně (bývá jich málo a je potřeba je zadávat pokaždé, takže si člověk jejich pořadí zapamatuje) a volitelné parametry jsou pojmenované (může jich být mnoho a používají se příležitostně, takže si člověk jejich pořadí nezapamatuje; navíc často chceme specifikovat jen jeden a ostatním nechat defaultní hodnotu). V případě naší funkce by to vypadalo takto:

In [65]:

hoď_kostkou_a_vynásob(4, násobek=10)

Out[65]:

Lokální vs. globální proměnné¶

Parametry plus jakékoli další proměnné, které v rámci funkce vytvoříme, jsou soukromé, dostupné čistě jen funkci -- jsou to tzv. lokální proměnné. Též hovoříme o tom, že tyto proměnné mají lokální dosah (angl. local scope). To znamená, že s nimi můžeme pracovat pouze v rámci těla funkce.

In [66]:

def function(parameter):
    local_variable = 1
    print("My parameter:", parameter)
    print("My local variable:", local_variable)

In [67]:

function(0)

My parameter: 0
My local variable: 1

Mimo tělo funkce function nejsou proměnné parameter a local_variable definované:

In [68]:

parameter

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-68-cfbbb8ed4864> in <module>
----> 1 parameter

NameError: name 'parameter' is not defined

In [69]:

local_variable

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-69-ffb5b39c1381> in <module>
----> 1 local_variable

NameError: name 'local_variable' is not defined

TIP: Naučit se číst chybové hlášky je k nezaplacení, Python se vám s jejich pomocí snaží ze všech sil poradit, v čem je problém. Zkuste si každou chybovou hláškou pečlivě přečíst, zamyslet se nad ní, pochopit, v čem je problém a kde přesně nastal.

Funkce mohou taky pracovat s globálními proměnnými, tj. s proměnnými definovanými samostatně, mimo nějaké funkce či třídy.

In [70]:

global_variable = 2

In [71]:

def function(parameter):
    local_variable = 1
    print("My parameter:", parameter)
    print("My local variable:", local_variable)
    print("My global variable:", global_variable)

In [72]:

function(0)

My parameter: 0
My local variable: 1
My global variable: 2

Taková funkce se ale snadno může rozbít -- stačí dotyčnou globální proměnnou smazat...

In [73]:

del global_variable

... a když funkci příště zavoláme, tak zkolabuje:

In [74]:

function(0)

My parameter: 0
My local variable: 1

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-74-e85ea32b6f77> in <module>
----> 1 function(0)

<ipython-input-71-051e3887233a> in function(parameter)
      3     print("My parameter:", parameter)
      4     print("My local variable:", local_variable)
----> 5     print("My global variable:", global_variable)

NameError: name 'global_variable' is not defined

Snad ještě horší je to, že u takové funkce není možné jen na základě jejího volání odhadnout, co přesně udělá:

In [75]:

global_variable = 512

In [76]:

function(0)

My parameter: 0
My local variable: 1
My global variable: 512

In [77]:

global_variable = 1024

In [78]:

function(0)

My parameter: 0
My local variable: 1
My global variable: 1024

V obou případech funkci voláme jako function(0), ale výsledek je pokaždé trochu jiný.

Mnohem lepší je tedy psát funkce tak, aby používaly jen lokální proměnné a nebyly závislé na těch globálních. Nejde to vždycky, ale většinu času ano. Místo přímého odkazování na globální proměnné je lepší dát funkci více parametrů, přes něž jí můžeme globální proměnné zprostředkovaně předávat, což je mnohem bezpečnější a přehlednější.

In [79]:

def function(parameter1, parameter2):
    local_variable = 1
    print("My first parameter:", parameter1)
    print("My local variable:", local_variable)
    print("My other parameter:", parameter2)

In [80]:

global_variable = 2

function(0, global_variable)

My first parameter: 0
My local variable: 1
My other parameter: 2

print vs. return¶

Jaký je rozdíl v tom, když zavolám následující dvě funkce?

In [81]:

def funkce1():
    print(1)

In [82]:

def funkce2():
    return 1

In [83]:

funkce1()

In [84]:

funkce2()

Out[84]:

V obou případech se mi zobrazí číslo 1, v druhém je navíc vedle něj číslo v hranatých závorkách a dvojtečka. V čem se to liší?

Rozdíl se lépe projeví, když se pokusíme výsledek funkce uložit do proměnné:

In [85]:

výsledek1 = funkce1()

In [86]:

výsledek1

In [87]:

výsledek2 = funkce2()

In [88]:

výsledek2

Out[88]:

funkce1 číslo 1 jen v rámci svého běhu vytiskne na obrazovku, kdežto funkce2 ho vrátí jako svůj výsledek, takže ho můžeme uložit do proměnné a dál s ním pracovat. Možná pomůže, když se podíváme na funkci, která jedno čísle tiskne a jiné vrací:

In [89]:

def funkce3():
    print(1)
    return 2

In [90]:

výsledek3 = funkce3()

In [91]:

výsledek3

Out[91]:

Zbývá tedy jen otázka: co vrací funkce1? Nic, když vůbec ani neobsahuje klíčové slovíčko return? Svým způsobem ano, ale i nic je v Pythonu něco ;) Což zní krypticky, ale je to jednoduché: Python má speciální objekt (konstantu) None, která reprezentuje "nic". Protože None je nic, tak se vám po vyhodnocení ani neukáže:

In [92]:

None

A kdykoli nějaká funkce doběhne na konec svého receptu, aniž by potkala return, tak implicitně automaticky vrátí jako svůj výsledek None.

Vím, že je trochu záludné, že ono None není "vidět", ale v praxi si můžeme to, že funkce1 skutečně vrátila None, lehce ověřit:

In [93]:

výsledek1 is None

Out[93]:

True

Pokročilé způsoby předávání argumentů¶

V Pythonu lze také vytvořit funkce, které pracují s libovolným počtem pozičních nebo pojmenovaných argumentů. Slouží k tomu speciální operátory * a **:

In [94]:

def flexibilní_funkce(
    poziční_argument,
    *zbytek_pozičních_argumentů,
    pojmenovaný_argument,
    **zbytek_pojmenovaných_argumentů
):
    print("poziční argument:", poziční_argument)
    print("zbytek pozičních argumentů:", zbytek_pozičních_argumentů)
    print("pojmenovaný argument:", pojmenovaný_argument)
    print("zbytek pojmenovaných argumentů:", zbytek_pojmenovaných_argumentů)

In [95]:

flexibilní_funkce(1, 2, 3, 4, a=5, b=6, pojmenovaný_argument=7, c=8)

poziční argument: 1
zbytek pozičních argumentů: (2, 3, 4)
pojmenovaný argument: 7
zbytek pojmenovaných argumentů: {'a': 5, 'b': 6, 'c': 8}

Parametr *zbytek_pozičních_argumentů sesbírá zbylé poziční argumenty, sestaví z nich n-tici a tu uloží do proměnné zbytek_pozičních_argumentů; podobně parametr **zbytek_pojmenovaných_argumentů sesbírá zbylé pojmenované argumenty, sestaví z nich slovník a uloží ho do proměnné zbytek_pojmenovaných_argumentů (víc o n-ticích a slovnících viz odd. Kolekce).

Jak vidno, můžeme tyto speciální parametry pojmenovat libovolně, speciální chování jim propůjčuje operátor *, resp. **. Nicméně konvenčně se v Pythonu používají jména *args a **kwargs (jako keyword arguments).

A aby toho nebylo málo, funguje to i "naopak": máme-li seznam/n-tici (nebo slovník) a chceme jeho položky předat funkci jako poziční (nebo pojmenované) argumenty, můžeme taky využít operátoru * (nebo **):

In [96]:

def nudná_funkce(a, b):
    return a + b

In [97]:

poziční_argumenty = [1, 2]

In [98]:

nudná_funkce(*poziční_argumenty)

Out[98]:

In [99]:

pojmenované_argumenty = {"a": 1, "b": 2}

In [100]:

nudná_funkce(**pojmenované_argumenty)

Out[100]:

U pozičních argumentů musí pochopitelně sedět počet...

In [101]:

poziční_argumenty = [1, 2, 3]

In [102]:

nudná_funkce(*poziční_argumenty)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-102-1d551cc00f6d> in <module>
----> 1 nudná_funkce(*poziční_argumenty)

TypeError: nudná_funkce() takes 2 positional arguments but 3 were given

... a u pojmenovaných jména:

In [103]:

pojmenované_argumenty = {"a": 1, "c": 2}

In [104]:

nudná_funkce(**pojmenované_argumenty)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-104-75894a48cf5c> in <module>
----> 1 nudná_funkce(**pojmenované_argumenty)

TypeError: nudná_funkce() got an unexpected keyword argument 'c'

Metody¶

Metody jsou funkce úzce spjaté s objekty. Seznam metod, které daný objekt podporuje, získáme tak, že napíšeme jméno proměnné, která objekt obsahuje, za ně tečku a stiskneme tabulátor:

obj.<TAB>

In [105]:

obj = "ahoj"
obj.upper()

Out[105]:

'AHOJ'

Formálně je metoda jen funkce "navěšená" na třídě:

In [106]:

class FooBar:
    
    def get_my_type(self):
        return type(self)

In [107]:

obj = FooBar()
obj.get_my_type()

Out[107]:

__main__.FooBar

První argument metody (self) odkazuje na instanci třídy, na které jsme metodu zavolali, tj. v příkladu výše na ten samý objekt, na který odkazuje proměnná obj. Na rozdíl od případných dalších argumentů se metodě předává pomocí propojení přes tečku, ne v závorkách za metodou, nepíšeme tedy obj.get_my_type(obj).

Čísla¶

V Pythonu jsou dva základní typy čísel:

celá čísla (angl. integer) -- typ int
reálná čísla, reprezentovaná pomocí tzv. pohyblivé řádové čárky (angl. floating point) -- typ float

Literály celých čísel vypadají např. takhle:

In [108]:

Out[108]:

In [109]:

type(3)

Out[109]:

int

In [110]:

-5

Out[110]:

-5

In [111]:

Out[111]:

Pro lepší čitelnost mohou obsahovat i podtržítka:

In [112]:

9_543_761

Out[112]:

Literály reálných čísel se většinou poznají podle toho, že obsahují desetinnou čárku... tedy tečku protože je to podle angličtiny:

In [113]:

3.14

Out[113]:

3.14

In [114]:

type(3.14)

Out[114]:

float

In [115]:

-2.72

Out[115]:

-2.72

In [116]:

0.1

Out[116]:

0.1

In [117]:

# nulu můžeme vynechat
.1

Out[117]:

0.1

Ovšem ne nutně -- Python má speciální syntax pro tzv. vědecký zápis čísel, a čísla zapsaná tímto způsobem jsou vždycky typu float, i když desetinnou tečku neobsahují.

In [118]:

# 1 × 10³
1e3

Out[118]:

1000.0

In [119]:

# 1 × 10⁻³
1e-3

Out[119]:

0.001

In [120]:

# 2.34 × 10²
2.34e2

Out[120]:

234.0

Kromě celých a reálných čísel disponuje Python i komplexními čísly:

In [121]:

3 + 4j

Out[121]:

(3+4j)

In [122]:

type(3 + 4j)

Out[122]:

complex

Jestli jste o nich nikdy neslyšeli, tak je zase pusťte z hlavy :)

Kromě desítkové (decimální) soustavy, na kterou jsme všichni zvyklí, mají celá čísla v Pythonu literály i v soustavách jiných. Rozpoznáme je pomocí prefixů:

0b → binární (dvojková) soustava -- používá číslice 0 a 1
0o → oktální (osmičková) soustava -- používá číslice 0–7
0x → hexadecimální (šestnáctková) soustava -- používá číslice 0–9 a a–f

In [123]:

0b11010

Out[123]:

In [124]:

0o32

Out[124]:

In [125]:

0x1a

Out[125]:

Jak vidíme, převod na desítkovou soustavu je jednoduchý -- stačí vyhodnotit literál v soustavě jiné a Python nám ho v odpovědi převede do desítkové. K převodu opačným směrem existují funkce, které nám vrátí řetězec obsahující zápis čísla v požadované soustavě:

In [126]:

bin(26)

Out[126]:

'0b11010'

In [127]:

oct(26)

Out[127]:

'0o32'

In [128]:

hex(26)

Out[128]:

'0x1a'

S čísly jdou provádět různé výpočty pomocí následujících operátorů, které snad díky zkušenosti s kalkulačkou budou působit převážně povědomě.

In [129]:

# sčítání
3 + 4

Out[129]:

In [130]:

# odečítání
3 - 4

Out[130]:

-1

In [131]:

# násobení
3 * 4

Out[131]:

In [132]:

# exponenciace
2**3

Out[132]:

In [133]:

# dělení
5 / 3

Out[133]:

1.6666666666666667

U dělení si všimněte, že výsledek je vždy float, i když dělíme dva inty a výsledkem je něco, co my lidé chápeme jako celé číslo:

In [134]:

4 / 2

Out[134]:

2.0

In [135]:

# celočíselné dělení
4 // 2

Out[135]:

In [136]:

5 // 3

Out[136]:

In [137]:

# modulo (= zbytek po celočíselném dělení)
5 % 3

Out[137]:

Když chceme zároveň celočíselné dělení i zbytek po něm, můžeme použít zabudovanou funkci divmod.

In [138]:

divmod(5, 3)

Out[138]:

(1, 2)

In [139]:

divmod(5, 3) == (5 // 3, 5 % 3)

Out[139]:

True

To se hodí např. při časových převodech -- kolik je 143 vteřin minut?

In [140]:

divmod(143, 60)

Out[140]:

(2, 23)

→ 2 minuty a 23 vteřin.

Zabudovaná funkce abs vrátí absolutní hodnotu čísla:

In [141]:

abs(-4.1)

Out[141]:

4.1

Pokud máme nějakou kolekci čísel (viz odd. Kolekce), můžeme identifikovat nejmenší, resp. největší z nich pomocí zabudovaných funkcí min a max.

In [142]:

from math import inf

# inf reprezentuje nekonečno
inf

Out[142]:

inf

In [143]:

čísla = [0, -inf, 3.14, -2.72, inf]

In [144]:

min(čísla)

Out[144]:

-inf

In [145]:

max(čísla)

Out[145]:

inf

Operátory mají různou prioritu, stejně jako v matematice:

In [146]:

2**3 + 4 * 5

Out[146]:

Pokud si nejsme pořadím operací jisti, můžeme ho pro jistotu specifikovat pomocí kulatých závorek:

In [147]:

(2**3) + (4 * 5)

Out[147]:

Nebo pochopitelně i změnit:

In [148]:

2**(3 + 4) * 5

Out[148]:

Všechny výše uvedené typy i zápisy čísel můžeme při výpočtech libovolně kombinovat, jen je potřeba mít na paměti, že jakmile se nám jako dílčí výsledek objeví float, i celkový výsledek bude float.

In [149]:

-0x1f + 165 * -0b1001 + 1.0

Out[149]:

-1515.0

Ke konverzi z intu na float slouží funkce float:

In [150]:

i = 3

In [151]:

float(i)

Out[151]:

3.0

Dokáže též převést textový zápis čísla (řetězec) na reálné číslo:

In [152]:

float("3.14")

Out[152]:

3.14

In [153]:

float("3")

Out[153]:

3.0

Analogicky funguje funkce int:

In [154]:

int(2.0)

Out[154]:

In [155]:

int("2")

Out[155]:

In [156]:

int(2.72)

Out[156]:

Všimněte si, že funkce int prostě jen uřízne desetinná místa. Pokud chceme zaokrouhlit podle matematických zvyklostí, je potřeba použít funkci round:

In [157]:

round(2.72)

Out[157]:

Při počítání s floaty je nutná jistá obezřetnost. Kvůli tomu, jak jsou v paměti počítače reprezentovány, není jejich zachycení úplně přesné, a některé výsledky tak můžou být překvapivé...

In [158]:

.1 + .2

Out[158]:

0.30000000000000004

... což vede až k tomu, že některé očekávané rovnosti neplatí:

In [159]:

.1 + .2 == .3

Out[159]:

False

Při porovnávání floatů je bezpečnější místo operátoru == (striktní rovnosti) používat funkci isclose z knihovny math (přibližná rovnost).

In [160]:

from math import isclose

isclose(.1 + .2, .3)

Out[160]:

True

S číselnými proměnnými často narážíme na následující situaci: vytvoříme proměnnou...

In [161]:

i = 0
i

Out[161]:

... a následně ji pak pomocí nějaké aritmetické operace potřebujeme aktualizovat na základě staré hodnoty -- např. přičíst k původnímu číslu nějaké nové a výsledek znovu uložit do té samé proměnné:

In [162]:

i = i + 2
i

Out[162]:

Python umožňuje zápis i = i + x zkrátit na i += x, abychom nemuseli psát i dvakrát:

In [163]:

i += 7
i

Out[163]:

Tento zkrácený zápis funguje s libovolným operátorem.

In [164]:

i **= 2
i

Out[164]:

Řetězce¶

Řetězce (angl. strings, v Pythonu typ str) nám umožňují reprezentovat text jako uspořádanou sérii (řetězec) znaků. Literály řetězců mají různé varianty, vždy jsou ale ohraničené jednoduchými nebo dvojitými uvozovkami.

In [165]:

"hello"

Out[165]:

'hello'

In [166]:

'hello'

Out[166]:

'hello'

In [167]:

type("hello")

Out[167]:

str

Chceme-li do řetězce uvozeného jednoduchými (dvojitými) uvozovkami vložit jednoduchou (dvojitou) uvozovku, je potřeba zrušit její speciální význam "ukončovač řetězce". K tomu slouží zpětné lomítko. Angl. se říká the backslash escapes the next character.

In [168]:

"\"Hello,\" I said."

Out[168]:

'"Hello," I said.'

In [169]:

'\'Hello,\' I said.'

Out[169]:

"'Hello,' I said."

Někdy je ale jednodušší prostě jen prostřídat druh uvozovek, které slouží k delimitaci řetězce, jak nám to ve svých odpovědích naznačuje sám Python.

Zpětné lomítko ale neslouží jen k rušení speciálního významu uvozovek -- jiným znakům speciální význam naopak dodává. Slouží tak spíš jako přepínač mezi doslovným a speciálním významem. Speciálním sekvencím znaků, které tvoří zpětné lomítko + jeden či více dalších znaků a mají jiný než doslovný význam, se angl. říká escape sequences.

Např. sekvence \n se promění ve znak nového řádku, \t pak ve znak tabulátoru:

In [170]:

"a\t1\naa\t11"

Out[170]:

'a\t1\naa\t11'

Na první pohled to tak nevypadá, ale to je jen kvůli tomu, že nás Python chce na tyto speciální znaky upozornit (což je dobře), takže když řetězec jen zobrazuje, reprezentuje tyto znaky pomocí dobře čitelných speciálních sekvencí. Aby se nové řádky a tabulátory projevily, musíme řetězec vytisknout:

In [171]:

print("a\t1\naa\t11")

a	1
aa	11

Což odpovídá zamýšlené podobě, ale je mnohem těžší poznat, co je v řetězci skutečně za znaky. Úplně jiný řetězec může totiž vytištěný vypadat zcela identicky:

In [172]:

print("a       1   \naa      11    ")

a       1   
aa      11

Speciální sekvence existují též např. pro vložení libovolného unicodového znaku, ve formátu \uXXXX nebo \UXXXXXXXX, kde XXX... je hexadecimální zápis pořadového čísla znaku v unicodové tabulce:

In [173]:

"asi nějaký čínský znak...? \u4e3e"

Out[173]:

'asi nějaký čínský znak...? 举'

Pořadové číslo znaku lze v Pythonu získat pomocí funkce ord...

In [174]:

ord("č")

Out[174]:

... takto získáme jeho hexadecimální zápis...

In [175]:

hex(269)

Out[175]:

'0x10d'

... a ten pak můžeme použít ve speciální sekvenci:

In [176]:

"tohle by mělo být č: \u010d"

Out[176]:

'tohle by mělo být č: č'

Inverzní funkcí k funkci ord je funkce chr -- dáme jí pořadové číslo znaku a ona nám vrátí odpovídající znak.

In [177]:

chr(269)

Out[177]:

'č'

In [178]:

chr(0x10d)

Out[178]:

'č'

Více o znacích, Unicodu a kódování textu obecně viz samostatný notebook unicode.ipynb.

Python pozná, když zpětné lomítko nepředchází znaku či znakům, s nímž/nimiž by tvořilo speciální sekvenci, a vloží na takovém místě doslovné zpětné lomítko, ale zároveň nám jemně naznačí, že by byl radši, kdybychom speciální přepínací význam zpětného lomítka v literálu explicitně vypnuli... pomocí zpětného lomítka:

In [179]:

"a \ b"

Out[179]:

'a \\ b'

In [180]:

print("a \ b")

a \ b

In [181]:

print("a \\ b")

a \ b

In [182]:

"a \ b" == "a \\ b"

Out[182]:

True

Z toho mj. plyne, že když chceme zpětných lomítek napsat víc za sebou, je jich potřeba vždy dvojnásobek:

In [183]:

"a \\\\ b"

Out[183]:

'a \\\\ b'

In [184]:

print("a \\\\ b")

a \\ b

Podobné literály začnou brzy vypadat nepřehledně. Člověk pak zatouží všechny speciální sekvence zrušit, jen aby všechny znaky fungovaly jednoduše doslovně. I to je možné, pomocí tzv. surových řetězců (angl. raw strings). V nich je zpětné lomítko jen další znak:

In [185]:

r"\t \\\\ \n"

Out[185]:

'\\t \\\\\\\\ \\n'

In [186]:

print(r"\t \\\\ \n")

\t \\\\ \n

Surové řetězce se velmi dobře hodí pro práci s regulárními výrazy (viz notebook regex.ipynb), kde se lomítka často používají a hodí se nemuset přemýšlet o tom, jestl nám je Python nějak nepomíchá.

Formátovací řetězce (angl. format strings) umožňují pomocí složených závorek vkládat do řetězců libovolné výrazy:

In [187]:

x = 1
y = 2
f"{x} + {y} = {x + y}"

Out[187]:

'1 + 2 = 3'

Místo pár jednoduchých/dvojitých uvozovek můžeme řetězce též delimitovat párem trojic jednoduchých/dvojitých uvozovek. Tyto literály můžou obsahovat doslovné znaky nového řádku (ne jen speciální sekvenci \n) jednoduché/dvojité uvozovky bez lomítek (jen ne tři za sebou).

In [188]:

"""a
b
c"""

Out[188]:

'a\nb\nc'

In [189]:

"""
a
b
c
"""

Out[189]:

'\na\nb\nc\n'

In [190]:

s = """"Hello," I said.
"Hi," she replied."""

In [191]:

print(s)

"Hello," I said.
"Hi," she replied.

Jinak v nich platí stejná pravidla jako v běžných řetězcích, můžou být taktéž surové nebo formátovací nebo obojí zároveň atp.

Řetězce mají mnoho užitečných metod. Několik jich začíná na is... a informují nás o obsahu řetězce:

In [192]:

"hello".islower()

Out[192]:

True

In [193]:

"HELLO".isupper()

Out[193]:

True

In [194]:

"Hello".istitle()

Out[194]:

True

In [195]:

"12".isnumeric()

Out[195]:

True

Jiné vytvoří nový pozměněný řetězec:

In [196]:

"hello".upper()

Out[196]:

'HELLO'

In [197]:

"hello".title()

Out[197]:

'Hello'

Metoda strip oseká z okrajů řetězce prázdné znaky (angl. whitespace)...

In [198]:

"  \n   ZZZ\n \t \n".strip()

Out[198]:

'ZZZ'

... popřípadě libovolné znaky, které jí zadáme:

In [199]:

"bbabZZZaabaaa".strip("ab")

Out[199]:

'ZZZ'

Metoda split naseká řetězec na dílčí řetězce na prázdných znacích...

In [200]:

"a b c".split()

Out[200]:

['a', 'b', 'c']

... nebo na každém výskytu zadaného podřetězce:

In [201]:

"a, b, c".split(", ")

Out[201]:

['a', 'b', 'c']

Prázdných znaků může být libovolné množství a pokud dělením vznikne prázdný řetězec, tak je z výsledku odebrán...

In [202]:

"   a\n  b  \t c\n  ".split()

Out[202]:

['a', 'b', 'c']

... ale pokud zadáme podřetězec, hledá metoda doslova a do písmene přesně jeho výskyty a případné prázdné řetězce ve výstupu zachovává:

In [203]:

" a, b, ,  c".split(", ")

Out[203]:

[' a', 'b', '', ' c']

Opakem metody split je metoda join, která pospojuje kolekci řetězců, kterou jí předáme jako argument:

In [204]:

"-".join(["a", "b", "c"])

Out[204]:

'a-b-c'

In [205]:

# i řetězec lze chápat jako kolekci jednoznakových řetězců
"-".join("abc")

Out[205]:

'a-b-c'

Důležité je, že řetězce patří k tzv. nemodifikovatelným typům, tj. ať s nimi děláme co děláme...

In [206]:

s = "   a,b,c   "
s

Out[206]:

'   a,b,c   '

In [207]:

s.strip().split(",")

Out[207]:

['a', 'b', 'c']

... původní řetězec vždy zůstane nedotčený:

In [208]:

Out[208]:

'   a,b,c   '

Více o (ne)modifikovatelných typech viz odd. Kolekce.

Ještě pár slov k funkci print. Tato funkce vytiskne všechny svoje poziční argumenty oddělené mezerami a na závěr přilepí znak nového řádku.

In [209]:

print(1, "a", [])

1 a []

Oddělovač (mezeru) i ukončovač (nový řádek) si můžeme upravit pomocí pojmenovaných argumentů sep a end -- může to být libovolný jiný řetězec.

In [210]:

print(1, "a", [], sep="__ODDĚLOVAČ__", end="__UKONČOVAČ__")

1__ODDĚLOVAČ__a__ODDĚLOVAČ__[]__UKONČOVAČ__

Jak to, že print umí vytisknout i jiné objekty než jen řetězce? Ve skutečnosti neumí, jen na každý poziční argument zavolá funkci str, která ho právě na řetězec převede.

In [211]:

str(1)

Out[211]:

'1'

In [212]:

str([])

Out[212]:

'[]'

U objektů, které již řetězci jsou, žádný převod pochopitelně není potřeba, str jako výsledek vrátí nezměněný argument:

In [213]:

str("a")

Out[213]:

'a'

Kolekce¶

Kolekce je objekt, který obsahuje další objekty, které z něj lze jeden po druhém vytáhnout. Mezi základní zabudované typy kolekcí patří:

seznamy -- typ list
n-tice -- typ tuple
množiny -- typ set
slovníky -- typ dict

Svým způsobem můžeme i na řetězce nahlížet jako na kolekce znaků -- jak uvidíme níže, jde s nimi provádět stejné typy operací. Stejně jako ostatní kolekce např. reagují na funkci len, která vrací počet prvků v kolekci...

In [214]:

len("abc")

Out[214]:

... nebo na operátor in, který testuje přítomnost prvku v kolekci...

In [215]:

"b" in "abc"

Out[215]:

True

... nebo na funkci sorted, která umí na základě kolekce vyrobit seřazený seznam jejích prvků:

In [216]:

sorted("bca")

Out[216]:

['a', 'b', 'c']

Seznamy¶

Klíčové vlastnosti:

uspořádanost (angl. se uspořádaná kolekce řekne ordered collection): zachovává pořadí prvků
prvky se mohou opakovat
modifikovatelnost (angl. mutability): seznam lze kdykoli upravovat (přidávat/ubírat prvky)

Literál seznamu sestává z hranatých závorek, mezi něž vypíšeme počáteční prvky seznamu oddělené čárkami:

In [217]:

[1, "a"]

Out[217]:

[1, 'a']

In [218]:

# opakované prvky
[1, 1, 1]

Out[218]:

[1, 1, 1]

In [219]:

# prázdný seznam
[]

Out[219]:

[]

Kromě literálu můžeme seznam vytvořit ještě pomocí funkce list, např. proměnit řetězec na seznam znaků:

In [220]:

list("abc")

Out[220]:

['a', 'b', 'c']

Argument pro funkci list může být jakýkoli iterovatelný objekt, tj. objekt, ze kterého lze opakovaně tahat další objekty jako králíky z klobouku (iterace = opakování). Většinou se jedná o různé typy kolekcí, ale ne nutně. Např. funkce range umí vytvořit objekt, z nějž lze postupně tahat čísla v zadaném rozpětí:

In [221]:

list(range(3))

Out[221]:

[0, 1, 2]

In [222]:

# prázdný seznam
list()

Out[222]:

[]

Vytvořme si nyní seznam na hraní:

In [223]:

zvířata = "kočka pes morče slon žirafa kočka".split()
zvířata

Out[223]:

['kočka', 'pes', 'morče', 'slon', 'žirafa', 'kočka']

Díky tomu, že je seznam uspořádaný, má každý jeho prvek pořadového číslo, tzv. index (číslováno od nuly). Pomocí indexů lze k jednotlivým prvkům seznamu přistupovat ("ukázat" si na ně -- index pochází z latinského slova pro ukazováček). Této operaci se říká indexace a vypadá tak, že za seznam napíšeme hranaté závorky s požadovaným indexem:

In [224]:

zvířata[0]

Out[224]:

'kočka'

Záporná čísla indexují odzadu:

In [225]:

zvířata[-1]

Out[225]:

'kočka'

Teoreticky lze indexaci přilepit přímo za literál seznamu, byť to v praxi není moc užitečné a zápis vypadá zvláštně:

In [226]:

["kočka", "pes", "morče"][2]

Out[226]:

'morče'

Dohledat index nějakého prvku můžeme pomocí metody index:

In [227]:

zvířata.index("morče")

Out[227]:

In [228]:

zvířata.index("orangutan")

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-228-979eb2c01602> in <module>
----> 1 zvířata.index("orangutan")

ValueError: 'orangutan' is not in list

Spočítat počet výskytů nějakého prvku můžeme pomocí metody count:

In [229]:

zvířata.count("kočka")

Out[229]:

Když chceme vytáhnout ze seznamu ne jeden prvek, ale podseznam, použijeme při indexaci tzv. výřez (angl. slice):

In [230]:

zvířata[2:4]

Out[230]:

['morče', 'slon']

První číslo je index prvku, jímž podseznam začíná, druhé číslo je index prvního prvku, který již do podseznamu nepatří. To je na první pohled možná trochu zvláštní, ale v kombinaci s tím, že vypuštěním prvního/druhého čísla dosáhneme toho, že výřez bude od začátku/do konce, nám to umožňuje jednoduše rozříznout seznam na nepřekrývající se části:

In [231]:

hranice = 3

In [232]:

zvířata[:hranice]

Out[232]:

['kočka', 'pes', 'morče']

In [233]:

zvířata[hranice:]

Out[233]:

['slon', 'žirafa', 'kočka']

Když vynecháme obě čísla, vytvoříme podseznam odpovídající původnímu seznamu:

In [234]:

zvířata[:]

Out[234]:

['kočka', 'pes', 'morče', 'slon', 'žirafa', 'kočka']

In [235]:

# což je to samé jako toto
zvířata[0:len(zvířata)]

Out[235]:

['kočka', 'pes', 'morče', 'slon', 'žirafa', 'kočka']

Ve výřezu můžeme volitelně specifikovat ještě třetí číslo, které stanovuje, že do seznamu má být zahrnutý jen každý x-tý prvek (např. každý druhý):

In [236]:

zvířata[1:4:2]

Out[236]:

['pes', 'slon']

Když je toto číslo záporné, můžeme podseznam vyříznou v opačném směru (zprava doleva):

In [237]:

zvířata[4:1:-2]

Out[237]:

['žirafa', 'morče']

In [238]:

# takto lze tedy převrátit pořadí seznamu
zvířata[::-1]

Out[238]:

['kočka', 'žirafa', 'slon', 'morče', 'pes', 'kočka']

In [239]:

# ale srozumitelnější je asi tento ekvivalentní zápis
# pomocí funkce reversed
list(reversed(zvířata))

Out[239]:

['kočka', 'žirafa', 'slon', 'morče', 'pes', 'kočka']

Kromě vyřezávání lze nové seznamy vytvářet i spojováním seznamů pomocí operátoru +...

In [240]:

zvířata + ["mastodont"]

Out[240]:

['kočka', 'pes', 'morče', 'slon', 'žirafa', 'kočka', 'mastodont']

... nebo klonováním pomocí operátoru *:

In [241]:

2 * zvířata

Out[241]:

['kočka',
 'pes',
 'morče',
 'slon',
 'žirafa',
 'kočka',
 'kočka',
 'pes',
 'morče',
 'slon',
 'žirafa',
 'kočka']

Říkali jsme si, že seznamy jsou modifikovatelné, že lze prvky libovolně ubírat a přidávat. Nicméně všechno, co jsme zatím s naším seznamem zvířata prováděli, na něm nezkřivilo ani vlásek:

In [242]:

zvířata

Out[242]:

['kočka', 'pes', 'morče', 'slon', 'žirafa', 'kočka']

Zatím jsme tedy tento seznam nijak nemodifikovali, všechny operace, které jsme na něj aplikovali, vedly k tomu, že na jeho základě vznikl nový, který z toho původního nějakým způsobem vycházel.

K modifikaci seznamu slouží některé jeho metody. Ukažme si to na příkladu seřazování. Samostatná funkce sorted vytvoří na základě původního seznamu nový seznam, který obsahuje stejné prvky, ovšem seřazené, a vrátí ho jako výsledek:

In [243]:

seřazená_zvířata = sorted(zvířata)
seřazená_zvířata

Out[243]:

['kočka', 'kočka', 'morče', 'pes', 'slon', 'žirafa']

Můžeme si jednoduše ověřit, že zvířata a seřazená_zvířata jsou dva různé objekty...

In [244]:

zvířata is seřazená_zvířata

Out[244]:

False

... a ani si nejsou rovné (protože záleží na pořadí):

In [245]:

zvířata == seřazená_zvířata

Out[245]:

False

Naopak metoda sort seřadí původní seznam, na kterém ji zavoláme, a vrátí None:

In [246]:

# v tuto chvíli poprvé modifikujeme seznam zvířata...
zvířata.sort()

In [247]:

# ... což si můžeme jednoduše ověřit (změnilo se pořadí)
zvířata

Out[247]:

['kočka', 'kočka', 'morče', 'pes', 'slon', 'žirafa']

Seznamy zvířata a seřazená_zvířata jsou nadále různé objekty...

In [248]:

zvířata is seřazená_zvířata

Out[248]:

False

... ale v tuto chvíli už jsou si rovné (protože teď už obsahují stejné prvky ve stejném pořadí):

In [249]:

zvířata == seřazená_zvířata

Out[249]:

True

Některé další užitečné modifikující metody objektů typu list:

In [250]:

# přidání jednoho prvku na konec
zvířata.append("užovka")
zvířata

Out[250]:

['kočka', 'kočka', 'morče', 'pes', 'slon', 'žirafa', 'užovka']

In [251]:

# pomocí indexace lze nahradit jeden prvek...
zvířata[4] = "slonice"
zvířata

Out[251]:

['kočka', 'kočka', 'morče', 'pes', 'slonice', 'žirafa', 'užovka']

In [252]:

# ... nebo celý podseznam:
zvířata[4:6] = ["slon", "žirafáč"]
zvířata

Out[252]:

['kočka', 'kočka', 'morče', 'pes', 'slon', 'žirafáč', 'užovka']

In [253]:

# přidání jednoho prvku na libovolný index
zvířata.insert(1, "kocour")
zvířata

Out[253]:

['kočka', 'kocour', 'kočka', 'morče', 'pes', 'slon', 'žirafáč', 'užovka']

In [254]:

# přidání celé kolekce prvků na konec
zvířata.extend(["kapr", "štika", "candát"])
zvířata

Out[254]:

['kočka',
 'kocour',
 'kočka',
 'morče',
 'pes',
 'slon',
 'žirafáč',
 'užovka',
 'kapr',
 'štika',
 'candát']

In [255]:

# odebrání posledního prvku
zvířata.pop()

Out[255]:

'candát'

In [256]:

zvířata

Out[256]:

['kočka',
 'kocour',
 'kočka',
 'morče',
 'pes',
 'slon',
 'žirafáč',
 'užovka',
 'kapr',
 'štika']

In [257]:

# odebrání prvku na libovolném indexu
zvířata.pop(0)

Out[257]:

'kočka'

In [258]:

zvířata

Out[258]:

['kocour',
 'kočka',
 'morče',
 'pes',
 'slon',
 'žirafáč',
 'užovka',
 'kapr',
 'štika']

In [259]:

# odebrání prvního výskytu konkrétního prvku
zvířata.remove("pes")
zvířata

Out[259]:

['kocour', 'kočka', 'morče', 'slon', 'žirafáč', 'užovka', 'kapr', 'štika']

In [260]:

# převrácení pořadí prvků
zvířata.reverse()
zvířata

Out[260]:

['štika', 'kapr', 'užovka', 'žirafáč', 'slon', 'morče', 'kočka', 'kocour']

Důležitým důsledkem modifikovatelnosti je, že pokud na ten samý seznam odkazuje více proměnných (= má více jmen), jakákoli modifikace se projeví pod všemi jmény. Představte si analogii: pokud mám bratra, který se jmenuje Jan, tak když se Jan nechá ostříhat, bude ostříhaný i můj bratr, protože je to jedna a tatáž osoba. Podobně se seznamy:

In [261]:

jan = ["nohy", "trup", "hlava", "vlasy"]
bratr = jan

In [262]:

jan is bratr

Out[262]:

True

In [263]:

# teď Jana "ostříháme"
jan.pop()

Out[263]:

'vlasy'

In [264]:

jan

Out[264]:

['nohy', 'trup', 'hlava']

In [265]:

bratr

Out[265]:

['nohy', 'trup', 'hlava']

Modifikace je ošemetná zejména v případě, kdy je skrytá v nějaké funkci a týká se argumentů, které funkci předáváme zvenčí. Pak nám vůbec nemusí dojít, že argumenty vlastně modifikujeme:

In [266]:

def zkrášlit(osoba):
    # osobu zkrášlíme tak, že ji ostříháme
    osoba.pop()

josef = ["nohy", "trup", "hlava", "vlasy"]

In [267]:

zkrášlit(josef)

Nic není vidět, zafungovala to vůbec, podařilo se nám Josefa zkrášlit? No pro jistotu to zkusíme ještě jednou, tím přece nemůžeme nic zkazit, že...

In [268]:

zkrášlit(josef)

Tak co teď? Podívejme se na Josefa...

In [269]:

josef

Out[269]:

['nohy', 'trup']

Ježišmarja chudák Josef, kde má hlavu?!

(Je to trochu fórek pórek, ale snad si rozumíme, v čem tkví nebezpečí :) )

Závěrem -- s modifikací je potřeba být opatrný a raději s ní šetřit:

pokud možno přímo nemodifikovat argumenty funkcí
kde se to hodí, používat místo seznamů nemodifikovatelné n-tice

n-tice¶

Klíčové vlastnosti jsou stejné jako u seznamů jen s tím rozdílem, že jsou nemodifikovatelné. Lze s nimi tedy provádět ty samé operace, s výjimkou těch modifikujících.

Literály n-tic v zásadě mohou sestávat jen z prvků oddělených čárkami:

In [270]:

1, "a"

Out[270]:

(1, 'a')

Nicméně v praxi je často potřeba obalit n-tici do kulatých závorek, protože čárka má jako operátor velmi nízkou prioritu (viz odd. Čísla). Je to podobné, jako když musíme použít závorky, aby sčítání proběhlo před dělením -- např. 2 + 3 × 4 = 14 vs. (2 + 3) × 4 = 20. Kdo se tím nechce moc zabývat, může závorky okolo n-tic používat pořád.

In [271]:

(1, "a")

Out[271]:

(1, 'a')

Specifickou syntax má prázdná n-tice...

In [272]:

()

Out[272]:

()

In [273]:

type(())

Out[273]:

tuple

In [274]:

len(())

Out[274]:

... a jednoprvková n-tice (čárka před uzavírací závorkou je povinná):

In [275]:

("a",)

Out[275]:

('a',)

Jiný iterovatelný objekt na n-tici proměníme pomocí funkce tuple:

In [276]:

tuple([1, "a"])

Out[276]:

(1, 'a')

In [277]:

tuple("abc")

Out[277]:

('a', 'b', 'c')

In [278]:

tuple(range(3))

Out[278]:

(0, 1, 2)

Jedním z důsledků nemodifikovatelnosti n-tic je, že do nich lze sice indexovat...

In [279]:

ntice = tuple("abc")
ntice[1]

Out[279]:

'b'

... ale už nelze pomocí indexace prvky nahrazovat jinými:

In [280]:

ntice[1] = "Z"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-280-53c8f0165f7f> in <module>
----> 1 ntice[1] = "Z"

TypeError: 'tuple' object does not support item assignment

Podobně řetězce, které jsou také nemodifikovatelné:

In [281]:

řetězec = "abc"
řetězec[1]

Out[281]:

'b'

In [282]:

řetězec[1] = "Z"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-282-a215aaf9569e> in <module>
----> 1 řetězec[1] = "Z"

TypeError: 'str' object does not support item assignment

Množiny¶

Klíčové vlastnosti:

neuspořádanost: prvky nemají dané pořadí
prvky se nesmí opakovat
modifikovatelnost

Literály vypadají následovně:

In [283]:

{1, "a"}

Out[283]:

{1, 'a'}

Ovšem pozor, {} není prázdná množina, ale prázdný slovník (viz níže)! Prázdnou množinu získáme pomocí funkce set...

In [284]:

set()

Out[284]:

set()

... která nám poslouží i k převodu jiné kolekce na množinu:

In [285]:

set("kočička")

Out[285]:

{'a', 'i', 'k', 'o', 'č'}

Prvky v množině se nesmějí opakovat v tom smyslu, že do množiny nelze vložit dva prvky a a b, o nichž platí, že a == b. Nicméně není třeba se bát, když se o to pokusíme, nenastane chyba, množina prostě druhý pokus jednoduše ignoruje:

In [286]:

{1, 2, 1}

Out[286]:

{1, 2}

In [287]:

set([1, 2, 1])

Out[287]:

{1, 2}

Vytvořme si dvě množiny na hraní:

In [288]:

set1 = {1, 2, 3}
set2 = {2, 3, 4}

Důležitým důsledkem neuspořádanosti je, že do množiny nelze indexovat -- ptát se po "prvním" prvku množiny nedává smysl:

In [289]:

set1[0]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-289-c38563f1af7a> in <module>
----> 1 set1[0]

TypeError: 'set' object is not subscriptable

Množiny podporují různé množinové operace. Některé jsou nemodifikující...

In [290]:

# sjednocení
set1.union(set2)

Out[290]:

{1, 2, 3, 4}

In [291]:

# též možno pomocí operátoru |
set1 | set2

Out[291]:

{1, 2, 3, 4}

In [292]:

# průnik
set1.intersection(set2)

Out[292]:

{2, 3}

In [293]:

# též možno pomocí operátoru &
set1 & set2

Out[293]:

{2, 3}

In [294]:

# rozdíl
set1.difference(set2)

Out[294]:

{1}

In [295]:

# též možno pomocí operátoru -
set1 - set2

Out[295]:

{1}

In [296]:

# vztahy mezi množinami
set1.issubset(set2)

Out[296]:

False

... jiné jsou modifikující:

In [297]:

# přidání prvku
set1.add(4)
set1

Out[297]:

{1, 2, 3, 4}

In [298]:

# zde k modifikaci nedojde, protože set1 už prvek 4 obsahuje
set1.add(4)
set1

Out[298]:

{1, 2, 3, 4}

In [299]:

# odebrání prvku
set1.remove(4)
set1

Out[299]:

{1, 2, 3}

In [300]:

# přidání více prvků, ovšem znovu pochopitelně s vyřazením duplicit
set1.update([0, 1, 2])
set1

Out[300]:

{0, 1, 2, 3}

In [301]:

# průnik, přičemž výsledek operace se uloží do původní množiny set1
set1.intersection_update(set2)
set1

Out[301]:

{2, 3}

Teď už tedy platí:

In [302]:

set1.issubset(set2)

Out[302]:

True

In [303]:

# též možno pomocí operátoru < ("menší než")
set1 < set2

Out[303]:

True

In [304]:

set2.issuperset(set1)

Out[304]:

True

In [305]:

# též možno pomocí operátoru > ("větší než")
set2 > set1

Out[305]:

True

Kromě toho, že nám množiny dobře poslouží, když chceme kolekci s duplicitami zredukovat na kolekci unikátních objektů (např. když chceme seznam tokenů v textu převést na množinu typů), mají ještě jednu výhodu: díky tomu, že prvky nemusí respektovat pořadí zadané uživatelem, můžou být interně uspořádané tak, aby umožňovaly velmi rychle zjistit, zda množina daný prvek obsahuje či ne.

V případě seznamu je potřeba ho procházet prvek po prvku, od začátku do konce, abychom zjistili, zda daný prvek obsahuje či ne. Čím je seznam delší, a čím dál v něm prvek je (nebo pokud v něm prvek vůbec není), tím déle to trvá:

In [306]:

# seznam prvního milionu čísel
seznam = list(range(1_000_000))

In [307]:

# Python musí seznam projít celý, prvek po prvku, aby zjistil,
# že řetězec "a" v našem seznamu prvního milionu čísel není
"a" in seznam

Out[307]:

False

In [308]:

%%timeit
# speciální direktiva %%timeit není přímo součástí Pythonu,
# poskytuje ji prostředí Jupyter; slouží k tomu, že spustí
# danou buňku opakovaně, pokaždé změří, jak dlouho trvá
# buňku vykonat, a pak nám ukáže průměrný čas
"a" in seznam

8.28 ms ± 26.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Oproti tomu v množině lze díky jejímu internímu uspořádání dohledat prvek velmi rychle:

In [309]:

množina = set(seznam)

In [310]:

"a" in množina

Out[310]:

False

In [311]:

%%timeit
"a" in množina

26.3 ns ± 0.0176 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

U seznamu trvá naše operace v řádu desítek milisekund (10⁻³ s), kdežto u množiny jsou to desítky nanosekund (10⁻⁹ s) -- je tedy milionkrát rychlejší!

Nemodifikovatelným protějškem typu set je typ frozenset.

Slovníky¶

Slovníky se od ostatních kolekcí, které jsme doposud potkali, liší v tom, že obsahují dva typy prvků:

klíče (angl. keys), podle nichž se ve slovníku hledá
a hodnoty (angl. values), které pod klíči dohledáme

Je to podobně jako s jazykovými slovníky (proto se tak v Pythonu jmenují): když ve slovníku hledám slovo "kočka", tak "kočka" je klíč, a definice, kterou najdu, je jeho odpovídající hodnota.

Stěžejní vlastnosti slovníků:

neuspořádanost: prvky nemají dané pořadí
klíče se nesmí opakovat, ale hodnoty klidně můžou
modifikovatelnost

Literály vypadají následovně:

In [312]:

{"a": 1, "b": 2}

Out[312]:

{'a': 1, 'b': 2}

Prvek před dvojtečkou je vždy klíč, za dvojtečkou pak jeho odpovídající hodnota.

Když stejný klíč specifikujeme víckrát, nenastane chyba, jen poslední asociovaná hodnota přemaže ty předchozí:

In [313]:

{"a": 1, "a": 2, "a": 3}

Out[313]:

{'a': 3}

In [314]:

# prázdný slovník
{}

Out[314]:

{}

In [315]:

type({})

Out[315]:

dict

Slovníky lze vytvářet i pomocí funkce dict, a to v zásadě dvěma způsoby. První možnost je, že do slovníku "nasypeme" kolekci sestávající z dvojic objektů, z nichž první vždy bude brán jako klíč a druhý jako jeho asociovaná hodnota:

In [316]:

# např. seznam n-tic o dvou položkách...
dict([("a", 1), ("b", 2)])

Out[316]:

{'a': 1, 'b': 2}

In [317]:

# ... nebo klidně seznam seznamů o dvou položkách...
dict([["a", 1], ["b", 2]])

Out[317]:

{'a': 1, 'b': 2}

In [318]:

# ... nebo třeba n-tice řetězců o dvou znacích atp.
dict(("ab", "cd"))

Out[318]:

{'a': 'b', 'c': 'd'}

Druhá možnost je, že využijeme pojmenované argumenty -- jména argumentů pak skončí jako klíče, argumenty samotné jako hodnoty:

In [319]:

dict(a=1, b=2)

Out[319]:

{'a': 1, 'b': 2}

Vytvořme si slovník na hraní:

In [320]:

slovník = {
    "pes": "nejlepší přítel člověka",
    "kočka": "vypočítavá potvora"
}

Slovníky jsou sice stejně jako množiny neuspořádané, ale indexaci na rozdíl od nich podporují. Jen se jako index nepoužívá pořadové číslo (protože žádné pořadí neexistuje), ale klíč:

In [321]:

slovník["kočka"]

Out[321]:

'vypočítavá potvora'

Přes metodu keys se dostaneme ke všem klíčům ve slovníku...

In [322]:

slovník.keys()

Out[322]:

dict_keys(['pes', 'kočka'])

... přes metodu values k hodnotám...

In [323]:

slovník.values()

Out[323]:

dict_values(['nejlepší přítel člověka', 'vypočítavá potvora'])

... a přes metodu items k uspořádaným dvojicím (klíč, hodnota):

In [324]:

slovník.items()

Out[324]:

dict_items([('pes', 'nejlepší přítel člověka'), ('kočka', 'vypočítavá potvora')])

Když se pokusíme indexovat podle klíče, který ve slovníku není, Python zkolabuje:

In [325]:

slovník["morče"]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-325-21eeb4f972e5> in <module>
----> 1 slovník["morče"]

KeyError: 'morče'

Abychom se kolapsu (a tím i zastavení běhu programu) vyhnuli, můžeme použít metodu get, která v případě absence klíče vrátí místo hodnoty ve slovníku nějaký jiný objekt (defaultně je to None, ale můžeme specifikovat libovolný objekt).

In [326]:

slovník.get("pes")

Out[326]:

'nejlepší přítel člověka'

In [327]:

slovník.get("morče")

In [328]:

slovník.get("morče", "MORČE VE SLOVNÍKU NENÍ!")

Out[328]:

'MORČE VE SLOVNÍKU NENÍ!'

Díky tomu, že jsou slovníky modifikovatelné, můžeme hodnoty odpovídající jednotlivým klíčům libovolně měnit...

In [329]:

slovník["kočka"] = "chlupatý mazlíček"
slovník

Out[329]:

{'pes': 'nejlepší přítel člověka', 'kočka': 'chlupatý mazlíček'}

... nebo přidávat nové:

In [330]:

slovník["rybička"] = "němá slizká tvář"
slovník

Out[330]:

{'pes': 'nejlepší přítel člověka',
 'kočka': 'chlupatý mazlíček',
 'rybička': 'němá slizká tvář'}

V prvním případě jsme přepsali původní hodnotu odpovídající klíči "kočka", ve druhém jsme přidali nový klíč "rybička" a k němu odpovídající hodnotu. Syntax (zápis) ale vypadá v obou případech stejně.

Občas potřebujeme zajistit, aby za žádnou cenu nedošlo k přepsání existující hodnoty (viz první případ výše). K tomu poslouží metoda setdefault -- pokud klíč už ve slovníku existuje, původní hodnotu nezmění, jen ji vrátí...

In [331]:

slovník.setdefault("kočka", "tuhle novou hodnotu do slovníku neprocpu :(")

Out[331]:

'chlupatý mazlíček'

In [332]:

slovník

Out[332]:

{'pes': 'nejlepší přítel člověka',
 'kočka': 'chlupatý mazlíček',
 'rybička': 'němá slizká tvář'}

... ale pokud neexistuje, klíč a odpovídající hodnotu do slovníku přidá (a hodnotu taky vrátí):

In [333]:

slovník.setdefault("morče", "ale tuhle procpu :)")

Out[333]:

'ale tuhle procpu :)'

In [334]:

slovník

Out[334]:

{'pes': 'nejlepší přítel člověka',
 'kočka': 'chlupatý mazlíček',
 'rybička': 'němá slizká tvář',
 'morče': 'ale tuhle procpu :)'}

Metoda setdefault tedy funguje podobně jako metoda get s tím rozdílem, že v případě nepřítomnosti klíče ve slovníku defaultní hodnotu nejen vrátí, ale i uloží do slovníku.

Metoda update, která přidává nové prvky do slovníku / upravuje stávající, nabízí co do argumentů, které zvládne zpracovat, podobné možnosti jako samotná funkce dict:

In [335]:

# libovolná kolekce dvojic prvků...
slovník.update([("a", 1), ("b", 2)])
slovník

Out[335]:

{'pes': 'nejlepší přítel člověka',
 'kočka': 'chlupatý mazlíček',
 'rybička': 'němá slizká tvář',
 'morče': 'ale tuhle procpu :)',
 'a': 1,
 'b': 2}

In [336]:

slovník.update(("ab", "cd"))
slovník

Out[336]:

{'pes': 'nejlepší přítel člověka',
 'kočka': 'chlupatý mazlíček',
 'rybička': 'němá slizká tvář',
 'morče': 'ale tuhle procpu :)',
 'a': 'b',
 'b': 2,
 'c': 'd'}

In [337]:

# ... jiný slovník...
slovník.update({"b": "z"})
slovník

Out[337]:

{'pes': 'nejlepší přítel člověka',
 'kočka': 'chlupatý mazlíček',
 'rybička': 'němá slizká tvář',
 'morče': 'ale tuhle procpu :)',
 'a': 'b',
 'b': 'z',
 'c': 'd'}

In [338]:

# ... nebo pojmenované argumenty:
slovník.update(žralok="dravá mořská paryba", kůň="tam někde v pastvinách")
slovník

Out[338]:

{'pes': 'nejlepší přítel člověka',
 'kočka': 'chlupatý mazlíček',
 'rybička': 'němá slizká tvář',
 'morče': 'ale tuhle procpu :)',
 'a': 'b',
 'b': 'z',
 'c': 'd',
 'žralok': 'dravá mořská paryba',
 'kůň': 'tam někde v pastvinách'}

Odebírat prvky ze slovníku lze různými způsoby, podle toho, zda chceme odebrat konkrétní klíč a chceme ještě pracovat s jeho hodnotou...

In [339]:

# metoda pop smaže prvek podle klíče a vrátí odpovídající hodnotu
slovník.pop("a")

Out[339]:

'b'

In [340]:

slovník

Out[340]:

{'pes': 'nejlepší přítel člověka',
 'kočka': 'chlupatý mazlíček',
 'rybička': 'němá slizká tvář',
 'morče': 'ale tuhle procpu :)',
 'b': 'z',
 'c': 'd',
 'žralok': 'dravá mořská paryba',
 'kůň': 'tam někde v pastvinách'}

... nebo zda hodnotu k ničemu nepotřebujeme...

In [341]:

# operátor del smaže prvek podle klíče a nevrátí nic
del slovník["b"]

In [342]:

slovník

Out[342]:

{'pes': 'nejlepší přítel člověka',
 'kočka': 'chlupatý mazlíček',
 'rybička': 'němá slizká tvář',
 'morče': 'ale tuhle procpu :)',
 'c': 'd',
 'žralok': 'dravá mořská paryba',
 'kůň': 'tam někde v pastvinách'}

... nebo zda je nám jedno, který prvek odebereme (necháme Python vybrat za nás):

In [343]:

# metoda popitem odebere nějaký prvek (nevíme předem jaký)
# a vrátí klíč a hodnotu jako n-tici
slovník.popitem()

Out[343]:

('kůň', 'tam někde v pastvinách')

In [344]:

slovník

Out[344]:

{'pes': 'nejlepší přítel člověka',
 'kočka': 'chlupatý mazlíček',
 'rybička': 'němá slizká tvář',
 'morče': 'ale tuhle procpu :)',
 'c': 'd',
 'žralok': 'dravá mořská paryba'}

Díky neuspořádanosti a zákazu opakování je dohledávání klíčů ve slovníku velmi rychlé (stejně jako u množin) a zapisuje se velmi jednoduše:

In [345]:

"kočka" in slovník

Out[345]:

True

Hodnoty ale ve slovníku takhle jednoduše nedohledáme:

In [346]:

"nejlepší přítel člověka" in slovník

Out[346]:

False

Je potřeba je projít jednu po druhé pomocí metody values, což na rozdíl od klíčů trvá stejně dlouho jako u seznamu (asi jako kdybychom v jazykovém slovníku hledali tak, že bychom pročítali jen definice):

In [347]:

"nejlepší přítel člověka" in slovník.values()

Out[347]:

True

Můžeme si to ověřit na libovolném velkém slovníku. K vytvoření takového velkého testovacího slovníku můžeme použít zabudovanou funkci zip, která "sezipuje" dohromady prvky několika iterovatelných objektů. Zní to složitě, ale když se na ni podíváme v akci, je to myslím jednoduché:

In [348]:

# vše obalíme do funkce list, aby se výsledné "sezipované" prvky
# uložily do seznamu
list(zip("abc", [1, 2, 3]))

Out[348]:

[('a', 1), ('b', 2), ('c', 3)]

Pomocí funkce zip jednoduše můžeme vytvořit slovník, v němž namapujeme první milion čísel na sebe sama, ve stylu...

In [349]:

dict(zip(range(3), range(3)))

Out[349]:

{0: 0, 1: 1, 2: 2}

... akorát větší. Takový slovník samozřejmě není k ničemu užitečný, jen je velký, takže dobře poslouží k ilustraci rozdílu rychlosti v hledání mezi klíči a hodnotami.

In [350]:

libovolný_velký_slovník = dict(zip(range(1_000_000), range(1_000_000)))

Hledání v hodnotách:

In [351]:

"a" in libovolný_velký_slovník.values()

Out[351]:

False

In [352]:

%%timeit
"a" in libovolný_velký_slovník.values()

11.4 ms ± 243 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Hledání v klíčích:

In [353]:

"a" in libovolný_velký_slovník

Out[353]:

False

In [354]:

%%timeit
"a" in libovolný_velký_slovník

23.6 ns ± 0.00474 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

Znovu pozorujeme rozdíl šesti řádů: hledání v klíčích je milionkrát rychlejší než hledání v hodnotách.

A když už máme slovníku plné zuby, můžeme jeho obsah vymazat a začít nanovo:

In [355]:

libovolný_velký_slovník.clear()

In [356]:

libovolný_velký_slovník

Out[356]:

{}

Vnořené kolekce¶

Jak už jsme ostatně v některých příkladech výše naznačili, kolekce lze do sebe libovolně zanořovat, čímž můžeme reprezentovat různé složité strukturní vztahy. Literální zápis vnořených kolekcí je celkem intuitivní:

In [357]:

slovník = {
    "hesla": {
        "kočka": {
            "definice": "chlupatý mazlíček",
            "příklad": "Na okně seděla kočka...",
        },
        "pes": {
            "definice": "nejlepší přítel člověka",
            "příklad": "... a venku štěkal pes.",
        },
    },
    "autoři": [
        {"jméno": "John", "příjmení": "Doe"},
        {"jméno": "Jane", "příjmení": "Doe"},
    ],
    "datum": (2018, 11, 7),
}

Naproti tomu indexace do vnořených kolekcí občas lidem činí při prvním setkání potíže. Chceme-li např. vytáhnout ze slovníku definici kočky, někdo má tendenci zkoušet následující zápis, který svým vnořením zrcadlí vnoření literálu:

In [358]:

slovník["hesla"["kočka"]]

<>:1: SyntaxWarning: str indices must be integers or slices, not str; perhaps you missed a comma?
<>:1: SyntaxWarning: str indices must be integers or slices, not str; perhaps you missed a comma?
<ipython-input-358-c2f5af94dca9>:1: SyntaxWarning: str indices must be integers or slices, not str; perhaps you missed a comma?
  slovník["hesla"["kočka"]]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-358-c2f5af94dca9> in <module>
----> 1 slovník["hesla"["kočka"]]

TypeError: string indices must be integers

Chybová hláška zní trochu krypticky, ale můžeme z ní odvodit, že se Python zřejmě snaží indexovat do nějakého řetězce (tj. vytáhnout znak z řetězce), což jsme rozhodně nezamýšleli, takže zápis musí být špatně.

Co se tedy děje? Pojďme si výraz rozebrat tak, jak ho vidí Python. Nejdřív vidí proměnnou slovník, za ní hranaté závorky. Usoudí tedy (správně), že se snažíme přistoupit k nějakému klíči ve slovníku. K jakému klíči? To je potřeba zjistit na základě obsahu hranatých závorek. Jinými slovy, Python v tuto chvíli vidí slovník[X], kde X je zástupný znak pro klíč, který chceme, aby ve slovníku dohledal.

Dobře, tak dál. Abych mohl X dohledat, uvažuje Python, musím nejdřív zjistit, co je zač. Hm, podle všeho mám za X dosadit výraz "hesla"[Y]. Ten musím tedy vyhodnotit jako první, abych mohl posléze vyhodnotit výraz slovník[X].

Co je "hesla"[Y] za výraz? Je to výraz, v němž máme řetězec "hesla", a pomocí indexace se z něj snažíme vytáhnout znak, který odpovídá indexu Y.

Skvěle, tetelí se Python, už tedy stačí jen zjistit, jaká je hodnota indexu Y, a můžu začít celý výraz vyhodnocovat, pěkně zvnitřka k vnějšku. Jenže ouha, Y by mělo být pořadové číslo požadovaného znaku, ale místo toho je to řetězec "kočka". Chudák Python neví, co to znamená, vytáhnout "kočka"-tý znak z řetězce "hesla", a tak to vzdá a jen si postěžuje, že indexy do řetězců by měly být celá čísla ("string indices must be integers").

Jinými slovy, vyhodnocování celého výrazu selže na tomto podvýrazu:

In [359]:

"hesla"["kočka"]

<>:1: SyntaxWarning: str indices must be integers or slices, not str; perhaps you missed a comma?
<>:1: SyntaxWarning: str indices must be integers or slices, not str; perhaps you missed a comma?
<ipython-input-359-acc1bf557eb4>:1: SyntaxWarning: str indices must be integers or slices, not str; perhaps you missed a comma?
  "hesla"["kočka"]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-359-acc1bf557eb4> in <module>
----> 1 "hesla"["kočka"]

TypeError: string indices must be integers

Jak vidno, chyba je stejná.

Jak tedy na to? Vždycky je možné rozdělit indexaci do vnořené kolekce na víc jednoduchých indexací s použitím pomocných proměnných:

In [360]:

hesla = slovník["hesla"]
kočka = hesla["kočka"]
kočka

Out[360]:

{'definice': 'chlupatý mazlíček', 'příklad': 'Na okně seděla kočka...'}

Z výše uvedeného zápisu ale plyne, že se meziproměnné hesla můžeme zbavit pomocí dosazování. Začněme od proměnné kočka, která obsahuje zamýšlený výsledek (slovníkové heslo pro kočku; mezery slouží jen ke zvýraznění toho, jak probíhá dosazování):

In [361]:

kočka

Out[361]:

{'definice': 'chlupatý mazlíček', 'příklad': 'Na okně seděla kočka...'}

Za výraz kočka lze dosadit výraz hesla["kočka"] (protože kočka = hesla["kočka"]):

In [362]:

hesla              ["kočka"]

Out[362]:

{'definice': 'chlupatý mazlíček', 'příklad': 'Na okně seděla kočka...'}

Výborně, výsledek zůstal stejný, takže dosazení platí. Dále můžeme za výraz hesla dosadit výraz slovník["hesla"] (protože hesla = slovník["hesla]), přičemž útržek kódu ["kočka"] zůstane tam, kde byl:

In [363]:

slovník["hesla"]   ["kočka"]

Out[363]:

{'definice': 'chlupatý mazlíček', 'příklad': 'Na okně seděla kočka...'}

Skvěle, výsledek je stále stejný! Teď už se jen zbavíme mezer, aby byl zápis konvenčnější, a vymysleli jsme způsob, jak indexovat do vnořených kolekcí.

In [364]:

slovník["hesla"]["kočka"]

Out[364]:

{'definice': 'chlupatý mazlíček', 'příklad': 'Na okně seděla kočka...'}

In [365]:

# rok
slovník["datum"][0]

Out[365]:

In [366]:

# příkladová věta pro psa
slovník["hesla"]["pes"]["příklad"]

Out[366]:

'... a venku štěkal pes.'

In [367]:

# jméno druhého autora
slovník["autoři"][1]["jméno"]

Out[367]:

'Jane'

A tak podobně.

Nezabudované kolekce¶

Existuje samozřejmě mnoho nezabudovaných kolekcí -- např. třída FreqDist z knihovny nltk je taky kolekce (obsahuje dílčí prvky). Nezabudované kolekce pochopitelně nemají literály, je potřeba je inicializovat pomocí příslušného konstruktoru třídy (viz odd. Typy a třídy):

In [368]:

from nltk import FreqDist

In [369]:

FreqDist("aababc")

Out[369]:

FreqDist({'a': 3, 'b': 2, 'c': 1})

Opakování operací: for-cyklus¶

Často chceme nějakou operaci provést opakovaně, ale pokaždé s trochu jinými daty. Např. chceme vytisknout čísla od 0 do 2. Mohli bychom samozřejmě použít copy-paste, tj. řádek třikrát zkopírovat a pokaždé jen nahradit číslo...

In [370]:

print(0)
print(1)
print(2)

0
1
2

... jenže pak je problém, že jakmile chceme akci trochu upravit, třeba vytisknout "Číslo: 0" místo jen "0", a podobně pro ostatní čísla, musíme provést úpravu na každém řádku:

In [371]:

print("Číslo:", 0)
print("Číslo:", 1)
print("Čísloo:", 2)

Číslo: 0
Číslo: 1
Čísloo: 2

Při takovém opisování / kopírování je snadné udělat na jednom místě chybu (viz výše "Čísloo" místo "Číslo") a najednou místo toho, abychom provedli třikrát tu samou operaci, provedeme dvakrát jednu a potřetí trochu jinou.

Proto je lepší se zamyslet, co se při každém opakování mění a co naopak zůstává stejné, a zaznamenat to pomocí tzv. for-cyklu (angl. for-loop):

In [372]:

for i in [0, 1, 2]:     # hlavička
    print("Číslo:", i)  # tělo

Číslo: 0
Číslo: 1
Číslo: 2

Takový for-cyklus můžeme parafrázovat následovně: každé číslo ze seznamu [0, 1, 2] postupně ulož do proměnné i a proveď sérii operací popsaných v těle cyklu. Zkráceně: pro každé (angl for each) číslo ze seznamu proveď následující operaci/operace.

Hlavička for-cyklu popisuje proměnlivou část akce, kterou provádíme (zde: proměnná i postupně nabývá různých hodnot, které čerpáme ze seznamu). Tělo for-cyklu popisuje repetitivní část (zde: pokaždé proměnnou i vytiskneme, spolu s prefixem "Číslo: "). Podobně jako u funkcí poznáme to, co ještě patří do těla for-cyklu, a to, co už ne, podle odsazení:

In [373]:

for i in [0, 1, 2]:
    print("Číslo:", i)
    print("Já ještě do těla cyklu patřím!")

print("Já už ne :(")

Číslo: 0
Já ještě do těla cyklu patřím!
Číslo: 1
Já ještě do těla cyklu patřím!
Číslo: 2
Já ještě do těla cyklu patřím!
Já už ne :(

Obecně můžeme for-cyklus charakterizovat takto:

for item in iterable:
    # do something with item

Proměnná iterable může obsahovat jakýkoli iterovatelný objekt (= objekt, ze kterého lze tahat další objekty, viz odd. Kolekce). Seznamy už jsme v roli iterable viděli v akci výše, n-tice fungují stejně. Řetězce taky, přičemž ve for-cyklu je procházíme znak po znaku:

In [374]:

řetězec = "abc"

for znak in řetězec:
    print(znak)

a
b
c

Množiny fungují podobně, jen není zaručené pořadí, v němž budeme prvky vytahovat:

In [375]:

množina = {2, 3, 1}

for prvek in množina:
    print(prvek)

1
2
3

U slovníků je to trochu složitější -- záleží, zda chceme procházet klíče...

In [376]:

slovník = {"a": 1, "b": 2, "c": 3}

for klíč in slovník:
    print(klíč)

a
b
c

In [377]:

# nebo též explicitněji
for klíč in slovník.keys():
    print(klíč)

a
b
c

... hodnoty...

In [378]:

for hodnota in slovník.values():
    print(hodnota)

1
2
3

... nebo obojí zároveň:

In [379]:

# jak přesně tato syntax funguje si vysvětlíme o kousek níž
for klíč, hodnota in slovník.items():
    print(f"Pod klíčem {klíč!r} je uložená hodnota {hodnota}.")

Pod klíčem 'a' je uložená hodnota 1.
Pod klíčem 'b' je uložená hodnota 2.
Pod klíčem 'c' je uložená hodnota 3.

Ale iterovatelný objekt nerovná se nutně jen kolekce. V kombinaci s for-cyklem se často hodí funkce range:

In [380]:

for i in range(3):
    print("Číslo:", i)

Číslo: 0
Číslo: 1
Číslo: 2

Funkce range vytvoří objekt, který v hlavičce for-cyklu postupně generuje čísla v zadaném rozpětí (v našem případě od 0 do 3, horní hranici vyjímaje). Proč je to užitečné? Představte si, že bychom chtěli operaci print("Číslo:", i) provést pro prvních milion nezáporných čísel. Oproti seznamu má funkce range dvě výhody:

pro nás je výhoda, že nemusíme ručně vypisovat seznam s milionem čísel
pro počítač je výhoda, že nemusí vytvářet celý seznam najednou a pak ho uchovávat v paměti (milion čísel sice dnešní počítače zvládnou hravě, ale obecně platí, že paměti nikdy není neomezeně) -- čísla tiskne jedno po druhém a jakmile jedno zpracuje, tak ho může zapomenout

Když proměnnou z hlavičky for-cyklu nikde v těle nepoužijeme, bývá zvykem jí dát speciální jméno _, čímž ostatním programátorům naznačíme, že se nemají divit, že není použitá.

In [381]:

# tři hody kostkou
for _ in range(3):
    print(randint(1, 6))

2
5
5

Občas se stane, že potřebujeme for-cyklem projít kolekci, jejímiž prvky jsou n-tice nebo seznamy, které v rámci for-cyklu potřebujeme dále rozebrat na dílčí prvky. Můžeme samozřejmě použít indexaci:

In [382]:

# Větu "Prší." máme reprezentovanou jako seznam dvou tokenů. Každý token
# je trojice řetězců: první označuje slovní tvar, druhý lemma (=
# slovníkovou podobu), třetí slovní druh (V = sloveso, Z = interpunkce).
věta = [("Prší", "pršet", "V"), (".", ".", "Z")]

for token in věta:
    word = token[0]
    lemma = token[1]
    tag = token[2]
    print(f"WORD: {word!r}, LEMMA: {lemma!r}, TAG: {tag!r}")

WORD: 'Prší', LEMMA: 'pršet', TAG: 'V'
WORD: '.', LEMMA: '.', TAG: 'Z'

Práci nám ale může ušetřit tzv. destrukturace (angl. destructuring, též se tomu někdy říká unpacking nebo pattern matching): máme-li uspořádanou kolekci (seznam nebo n-tici) o X prvcích, můžeme prvky rovnou namapovat na X proměnných:

In [383]:

a, b, c = [1, 2, 3]

In [384]:

Out[384]:

In [385]:

Out[385]:

In [386]:

Out[386]:

Jak to funguje? Strukturní vzorec (pattern) nalevo od = obsahuje tři volné "sloty" (odpovídající třem proměnným). Python se tento vzorec pokusí přiložit na datovou strukturu napravo od = (představte si průhledný pauzovací papír), namapovat (match) objekty, které datová struktura obsahuje, na volné sloty, a strukturu tak rozebrat na dílčí prvky (proto hovoříme o destrukturaci nebo unpacking -- rozbalení).

Ne vždycky se to samozřejmě povede -- např. když je slotů víc než prvků...

In [387]:

a, b, c = (1, 2)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-387-24077ba23852> in <module>
----> 1 a, b, c = (1, 2)

ValueError: not enough values to unpack (expected 3, got 2)

... nebo naopak:

In [388]:

a, b = (1, 2, 3)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-388-faee755feda6> in <module>
----> 1 a, b = (1, 2, 3)

ValueError: too many values to unpack (expected 2)

Strukturní vzorec může obsahovat proměnnou s hvězdičkou (viz odd. Funkce), pak na sebe tato proměnná naváže zbývající prvky kolekce:

In [389]:

a, *rest = (1, 2, 3, 4, 5, 6)

In [390]:

Out[390]:

In [391]:

rest

Out[391]:

[2, 3, 4, 5, 6]

Když je kolekce vnořená, můžeme strukturní vzorec namapovat jen na nejvyšší úroveň...

In [392]:

a, b = (1, (2, 3))

In [393]:

Out[393]:

In [394]:

Out[394]:

(2, 3)

... nebo může vzorec být taktéž vnořený:

In [395]:

a, (b, c) = (1, (2, 3))

In [396]:

Out[396]:

In [397]:

Out[397]:

In [398]:

Out[398]:

Když dáme destrukturaci dohromady s for-cyklem, zkrátí a zpřehlední se nám zápis:

In [399]:

for token in věta:
    word, lemma, tag = token
    print(f"WORD: {word!r}, LEMMA: {lemma!r}, TAG: {tag!r}")

WORD: 'Prší', LEMMA: 'pršet', TAG: 'V'
WORD: '.', LEMMA: '.', TAG: 'Z'

A dokonce můžeme ubrat ještě jeden řádek, protože destrukturaci lze provést přímo v rámci hlavičky for-cyklu:

In [400]:

for word, lemma, tag in věta:
    print(f"WORD: {word!r}, LEMMA: {lemma!r}, TAG: {tag!r}")

WORD: 'Prší', LEMMA: 'pršet', TAG: 'V'
WORD: '.', LEMMA: '.', TAG: 'Z'

Varianta s vnořeným strukturním vzorcem může nastat např. v případě, že si jednotlivé tokeny očíslujeme pomocí funkce enumerate, která ke každému prvku ve zdrojové kolekci přidá pořadové číslo. Takhle to vypadá, když si výsledek uložíme do seznamu:

In [401]:

list(enumerate(věta))

Out[401]:

[(0, ('Prší', 'pršet', 'V')), (1, ('.', '.', 'Z'))]

A takhle bychom ji spolu s vnořenou destrukturací mohli použít ve for-cyklu:

In [402]:

for i, (word, lemma, tag) in enumerate(věta):
    print(f"{i + 1}. WORD: {word!r}, LEMMA: {lemma!r}, TAG: {tag!r}")

1. WORD: 'Prší', LEMMA: 'pršet', TAG: 'V'
2. WORD: '.', LEMMA: '.', TAG: 'Z'

V prvním opakování for-cyklu provede Python tuto destrukturaci...

In [403]:

i, (word, lemma, tag) = (0, ("Prší", "pršet", "V"))

... v druhém pak tuto:

In [404]:

i, (word, lemma, tag) = (1, (".", ".", "Z"))

Na závěr příklad použití destrukturace s hvězdičkou -- může se hodit, když jsou jednotlivé dílčí kolekce, které postupně ve for-cyklu zpracováváme, různě dlouhé:

In [405]:

for i, *rest in [(1,), (2, 3), (4, 5, 6)]:
    print(i)
    print(rest)

1
[]
2
[3]
4
[5, 6]

Občas se v rámci for-cyklů můžou hodit klíčová slovíčka break a continue. break okamžitě ukončí for-cyklus. Následující for-cyklus by měl sice teoreticky projít čísla od 0 do 4, ale zastaví se u čísla 3:

In [406]:

for i in range(5):
    # syntax podmínek viz odd. Podmínky
    if i == 3:
        break
    print(i)

0
1
2

continue ukončí současnou iteraci for-cyklu a zahájí další. Následující for-cyklus tedy projde čísla od 0 do 4, ale vytiskne jen ta lichá, protože u sudých se k řádku s funkcí print vůbec nedostane:

In [407]:

for i in range(5):
    if i % 2 == 0:
        continue
    print(i)

1
3

POZN.: V tělech for-cyklů jsme všude použili funkci print, abychom mohli nahlédnout do jejich průběhu, tj. do toho, jak se jednotlivé operace opakují. Bez funkce print to jde samozřejmě taky, jen se nám nedostane žádné vizuální zpětné vazby, která by nám pomohla pochopit, co se po spuštění for-cyklu odehrává:

In [408]:

num = 0

for x in range(101):
    num += x

In [409]:

num

Out[409]:

Jen ještě doplním, že elegantněji můžeme čísla od 0 do 100 sečíst pomocí funkce sum:

In [410]:

sum(range(101))

Out[410]:

Logika¶

V Pythonu lze pracovat i s logickými výroky. Základem pro to jsou konstanty True a False, které označují pravdu, resp. nepravdu, a které Python vrací, když posuzuje pravdivost nějakého logického výroku:

In [411]:

# rovnost
2 + 2 == 4

Out[411]:

True

In [412]:

list("abc") == sorted("cab")

Out[412]:

True

In [413]:

# negace rovnosti
2 + 2 != 5

Out[413]:

True

In [414]:

# přítomnost prvku v kolekci
"a" in "abc"

Out[414]:

True

In [415]:

# přítomnost celého čísla v rozpětí celých čísel
7 in range(5, 10)

Out[415]:

True

In [416]:

# identita objektu
jan = bratr = ["nohy", "trup", "hlava", "vlasy"]
jan is bratr

Out[416]:

True

In [417]:

# různé typy nerovností -- menší než
2 < 3

Out[417]:

True

In [418]:

# menší nebo rovno
3 <= 3

Out[418]:

True

In [419]:

# větší
2 > 1

Out[419]:

True

In [420]:

# větší nebo rovno
1 >= 1

Out[420]:

True

In [421]:

1 < 3 > 2

Out[421]:

True

In [422]:

# výroky o řetězcích
"abc".islower()

Out[422]:

True

A tak podobně, viz příklady operací, které vrací True nebo False, v předchozích oddílech.

Pravdivostní hodnotu ale mají všechny objekty v Pythonu. Můžeme ji zjistit pomocí funkce bool:

In [423]:

bool("abc")

Out[423]:

True

Pravdivé jsou skoro všechny objekty kromě:

In [424]:

# čísla 0
bool(0)

Out[424]:

False

In [425]:

# prázdných kolekcí
bool([])

Out[425]:

False

In [426]:

bool({})

Out[426]:

False

In [427]:

bool("")

Out[427]:

False

In [428]:

# None
bool(None)

Out[428]:

False

In [429]:

# a pochopitelně samotné konstanty False
bool(False)

Out[429]:

False

Sestavovat z jednoduchých výroků složitější lze pomocí operátorů and, or a not:

In [430]:

# x and y platí, když jsou oba výroky x a y pravdivé
True and True

Out[430]:

True

In [431]:

True and False

Out[431]:

False

In [432]:

# x or y platí, když je aspoň jeden z výroků x a y pravdivý
True or True

Out[432]:

True

In [433]:

True or False

Out[433]:

True

In [434]:

False or False

Out[434]:

False

In [435]:

# not invertuje pravdivostní hodnotu výroku
not True

Out[435]:

False

In [436]:

not False

Out[436]:

True

V praxi použijeme třeba následovně:

In [437]:

řetězec = "kočka"

len(řetězec) > 3 and "č" in řetězec

Out[437]:

True

Jak jsme psali výše, pravdivostní hodnotu mají všechny objekty v Pythonu, můžeme tedy klidně napsat:

In [438]:

not "abc"

Out[438]:

False

In [439]:

True or 0

Out[439]:

True

Díky tomu můžeme trochu upřesnit chování operátorů and a or. and začne vyhodnocovat výrazy (zleva doprava) a vrátí buď první nepravdivý, nebo poslední zbývající:

In [440]:

# poslední zbývající (pravdivý)
True and 1 and "abc" and sorted

Out[440]:

<function sorted(iterable, /, *, key=None, reverse=False)>

In [441]:

# první nepravdivý
True and 1 and "abc" and sorted and [] and 0

Out[441]:

[]

or taky začne vyhodnocovat výrazy (zleva doprava) a vrátí buď první pravdivý, nebo poslední zbývající:

In [442]:

# první pravdivý
0 or [] or False or 42 or "abc"

Out[442]:

In [443]:

# poslední zbývající (nepravdivý)
0 or [] or False or {}

Out[443]:

{}

Jakmile and nebo or narazí na výraz, podle kterého se může rozhodnout, další už nevyhodnocuje. Můžeme si to ukázat, když jeden z výrazu bude volání funkce, jejímž vedlejším efektem je, že něco vytiskne na obrazovku.

In [444]:

def funkce():
    print("volám funkci...")
    return "výsledek funkce"

In [445]:

# zde může and vrátit hned první výraz, takže se funkce nezavolá
0 and funkce()

Out[445]:

In [446]:

# zde je potřeba po prvním výrazu pokračovat v ověřování pravdivostních
# hodnot, takže se funkce zavolá
1 and funkce()

volám funkci...

Out[446]:

'výsledek funkce'

Pomocí or tedy můžeme např. nahradit metodu setdefault (viz odd. Kolekce -- Slovníky) -- úpravu slovníku provedeme pouze v případě, že daný klíč ještě neobsahuje:

In [447]:

slovník = dict(a=1, b=2)

In [448]:

# "a" už ve slovníku je, první výraz tedy platí a druhý se ani
# nevyhodnotí
"a" in slovník or slovník.update(a=42)

Out[448]:

True

In [449]:

slovník

Out[449]:

{'a': 1, 'b': 2}

In [450]:

# "c" ve slovníku není, první výraz tedy neplatí a druhý se
# vyhodnotí
"c" in slovník or slovník.update(c=42)

In [451]:

slovník

Out[451]:

{'a': 1, 'b': 2, 'c': 42}

Máme-li kolekci objektů a chceme ověřit, zda je aspoň jeden z nich pravdivý, můžeme použít zabudovanou funkci any:

In [452]:

any([True, False, False])

Out[452]:

True

Chceme-li ověřit, zda jsou všechny pravdivé, použijeme zabudovanou funkci all:

In [453]:

all([True, True, True])

Out[453]:

True

any a all jsou velmi užitečné v kombinaci s konvertory kolekcí (viz odd. Konvertory kolekcí).

Varování na závěr -- složitější logické výroky jsou zrádné, jejich úpravy jsou netriviální a řídí se přesně danými pravidly. Kdo si je podobně jako já ze střední školy pamatuje spíš matně, měl by si dát extra pozor ;) Např. výrok not (x and y) je ekvivalentní výroku not x or not y, ne výroku not x and not y, jak bychom možná mohli mít tendenci naivně "roznásobit".

Složitější případy si naštěstí vždy lze pro jistotu ověřit pomocí pravdivostní tabulky, ať už si ji nakreslíme ručně nebo si rovnost výroků pro všechny možné kombinace hodnot x a y zkontrolujeme pomocí Pythonu:

In [454]:

for x in [True, False]:
    for y in [True, False]:
        #         ↓ výroky, jejichž rovnost ověřujeme ↓
        is_equal = (not (x and y)) == (not x or not y)
        print(f"x is {x}, y is {y}, the equality is {is_equal}")

x is True, y is True, the equality is True
x is True, y is False, the equality is True
x is False, y is True, the equality is True
x is False, y is False, the equality is True

Aby rovnost dvou výrazů platila obecně, musí platit pro každou variantu dosazení konkrétních hodnot za proměnné (zde x a y). O tom se můžeme přesvědčit buď ověřením výstupů funkce print (viz předchozí buňka), nebo můžeme kód taky upravit jako konvertor kolekce v kombinaci s funkcí all a dostaneme tak celkový výsledek rovnou:

In [455]:

all(
    (not (x and y)) == (not x or not y)
    for x in [True, False]
    for y in [True, False]
)

Out[455]:

True

A ještě pro srovnání, jak by vypadaly výstupy v případě, že si porovnávané výrazy obecně vzato rovné nejsou (všimněte si, že pro některé kombinace hodnot x a y rovnost platí, ale ne pro všechny)...

In [456]:

for x in [True, False]:
    for y in [True, False]:
        is_equal = (not (x and y)) == (not x and not y)
        print(f"x is {x}, y is {y}, the equality is {is_equal}")

x is True, y is True, the equality is True
x is True, y is False, the equality is False
x is False, y is True, the equality is False
x is False, y is False, the equality is True

... takže celkový verdikt je...

In [457]:

all(
    (not (x and y)) == (not x and not y)
    for x in [True, False]
    for y in [True, False]
)

Out[457]:

False

Podmínky: if, elif, else (a while-cyklus)¶

Na logických výrocích lze dál stavět větvení programu pomocí podmínek:

In [458]:

if 2 + 2 == 4:                   # hlavička
    print("matematika funguje")  # tělo

matematika funguje

Syntax podmínek je znovu postavená na principu hlavičky a odsazeného těla, které se vykoná, pokud podmínka uvedená v hlavičce platí.

if je jako výhybka: platí-li podmínka, vydá se program trochu jinou cestou, než když neplatí. Alternativních podmíněných cest může být více, napojíme je pomocí klíčového slovíčka elif:

In [459]:

num = 2

if num == 0:
    print("nula")
elif num == 1:
    print("jedna")
elif num == 2:
    print("dva")

dva

Na závěr můžeme přidat ještě jednu nepodmíněnou alternativní cestu pomocí klíčového slovíčka else. Tou se programu vydá, když se ukáže, že ani jedna z předchozích podmínek neplatí:

In [460]:

num = 3

if num == 0:
    print("nula")
elif num == 1:
    print("jedna")
elif num == 2:
    print("dva")
else:
    print("něco jiného")

něco jiného

Je důležité si uvědomit, že větvení skutečně funguje jako výhybka: program se vydá první cestou, kde narazí na pravdivou podmínku, a zbývající ignoruje, i kdyby byly nakrásně pravdivé taky:

In [461]:

if True:
    print("podmínka u téhle větve je vždy pravdivá")
elif True:
    print("u téhle taky, ale není to nic platné, je až druhá")

podmínka u téhle větve je vždy pravdivá

Vizuálně si to můžeme představit takto:

     .---> if
    /
   /-----> elif
  /
 --------> elif
  \
   \-----{ ...
    \
     `---> else

Důležitým důsledkem je, že záleží na pořadí podmínek. Pravidlo pravé ruky zní, že specifičtější podmínky by měly pro jistotu být na začátku, jinak se k nim program nemusí dostat, protože ho odchytí dřívější méně specifické podmínky.

Např. podmínka x >= 0 je méně specifická než podmínka x == 2, takže když bude před ní, sebere jí všechny potenciální zákazníky:

In [462]:

for x in range(4):
    if x >= 0:
        print(f"{x} je větší než 0")
    elif x == 2:
        print("HA! DVOJKA.")

0 je větší než 0
1 je větší než 0
2 je větší než 0
3 je větší než 0

Srovnejte s výstupem, když pořadí podmínek prohodíme:

In [463]:

for x in range(4):
    if x == 2:
        print("HA! DVOJKA.")
    elif x >= 0:
        print(f"{x} je větší než 0")

0 je větší než 0
1 je větší než 0
HA! DVOJKA.
3 je větší než 0

Každé klíčové slovíčko if odstartuje nové větvení, pod něž spadají případná následující elif a else na stejné úrovni odsazení:

In [464]:

num = 2

if num > 1:
    print("1. větvení: num je větší než jedna")
elif num < 1:
    print("1. větvení: num je menší než jedna")
else:
    print("1. větvení: num je rovno jedné")

if num == 2:
    print("2. větvení: num je rovno dvěma")

1. větvení: num je větší než jedna
2. větvení: num je rovno dvěma

Vizuálně si to můžeme představit takto:

    .---> if
   /
  /-----> elif
 /
--------> elif
 \
  \-----{ ...
   \
    `---> else

--------> if

Existuje též speciální dvoučlenný operátor if ... else, který jako výsledek vrátí jednu ze dvou možností podle toho, jak dopadne pravdivostní test:

výsledek_je_li_test_pravdivý if test else výsledek_je_li_test_nepravdivý

Konkrétní příklad bude asi srozumitelnější:

In [465]:

"A" if True else "B"

Out[465]:

'A'

In [466]:

"A" if False else "B"

Out[466]:

'B'

Díky tomuto operátoru máme k dispozici kompaktnější zápis, když chceme hodnotu nějaké proměnné stanovit na základě pravdivostního testu. Bez operátoru if ... else bychom např. museli psát:

In [467]:

lednička = {"puding", "sýr", "salát"}

if "puding" in lednička:
    reakce = "hurá, puding!"
else:
    reakce = "není puding :("

reakce

Out[467]:

'hurá, puding!'

Ale s pomocí operátoru if ... else stačí napsat:

In [468]:

reakce = "hurá, puding!" if "puding" in lednička else "není puding :("
reakce

Out[468]:

'hurá, puding!'

S podmínkami souvisí i jiná podoba cyklu, tzv. while-cyklus. While-cyklus se opakuje tak dlouho, dokud je podmínka v hlavičce pravdivá:

In [469]:

i = 0

while i < 3:
    print("Číslo", i, "je menší než 3.")
    i += 1

Číslo 0 je menší než 3.
Číslo 1 je menší než 3.
Číslo 2 je menší než 3.

Konvertory kolekcí¶

Mnoho funkcí pracuje s kolekcemi, např. zabudovaná funkce sorted nebo konstruktor FreqDist z knihovny nltk. Někdy je užitečné mít možnost kolekci trochu upravit ve chvíli, kdy ji takové funkci předáváme. K tomu přesně slouží konvertory kolekce.

Kamkoli můžeme dát normální kolekci...

In [470]:

věta = "Bylo nás pět .".split()
věta

Out[470]:

['Bylo', 'nás', 'pět', '.']

In [471]:

sorted(věta)

Out[471]:

['.', 'Bylo', 'nás', 'pět']

... můžeme propašovat místo ní i konvertor:

In [472]:

sorted(slovo for slovo in věta if slovo.islower())

Out[472]:

['nás', 'pět']

Jejich syntax připomíná syntax for-cyklu, jen jsou jednotlivé prvky přeskládané a možnosti jsou omezenější než v plném for-cyklu. Abychom se v jejich zápisu lépe zorientovali, využijeme toho, že uvnitř jakýchkoli závorek můžeme kód v Pythonu libovolně nasekat na řádky a přidat odsazení, aby se nám lépe četl:

In [473]:

sorted(
    slovo
    for slovo in věta
    if slovo.islower()
)

Out[473]:

['nás', 'pět']

Teď už je lépe vidět, že konvertor kolekce má tři části. Čtou se odprostředka:

convert(item)            # 3.
for item in collection   # 1.
if test(item)            # 2.

Popis jednotlivých fází vypadá následovně:

Procházíme kolekci prvek po prvku.
Nepovinně můžeme provést nějaký test; pokud ho aktuální prvek nesplní, bude z výsledku vyřazen. Tím můžeme zdrojovou kolekci profiltrovat.
Nakonec spočítáme hodnotu, kterou za daný prvek ze zdrojové kolekce zařadíme do výsledku. Tato hodnota může být původní prvek samotný, může být vypočítaná na základě prvku, nebo s ním taky vůbec nemusí souviset.

Nejjednodušší konvertor kolekce, kterým kolekce projede nezměněná, vypadá takto:

item                    # 3.
for item in collection  # 1.
                        # 2. nic

In [474]:

sorted(
    slovo              # 3.
    for slovo in věta  # 1.
                       # 2.
)

Out[474]:

['.', 'Bylo', 'nás', 'pět']

Chceme-li místo slov samotných do výsledku zařadit n-tici (slovo, délka_slova), musíme upravit fázi 3:

In [475]:

sorted(
    (slovo, len(slovo))  # 3. úprava zde
    for slovo in věta    # 1.
                         # 2.
)

Out[475]:

[('.', 1), ('Bylo', 4), ('nás', 3), ('pět', 3)]

Chceme-li navíc zahodit všechna slova, která nesestávají z malých písmen, musíme doplnit fázi 2:

In [476]:

sorted(
    (slovo, len(slovo))  # 3.
    for slovo in věta    # 1.
    if slovo.islower()   # 2. úprava zde
)

Out[476]:

[('nás', 3), ('pět', 3)]

Konvertor kolekce lze vždy přeskládat na normální for-cyklus, např. ten bezprostředně předcházející:

In [477]:

pomocný_seznam = []
for slovo in věta:
    if slovo.islower():
        pomocný_seznam.append((slovo, len(slovo)))
sorted(pomocný_seznam)

Out[477]:

[('nás', 3), ('pět', 3)]

Naopak přeskládat for-cyklus na konvertor kolekce pokaždé nejde, protože for-cyklus poskytuje mnohem větší volnost. Výměnou za toto omezení poskytují konvertory kolekce oproti for-cyklům několik výhod:

úspornější syntax (nesnaží se pokrýt plnou flexibilitu for-cyklů)
při běhu programu zabírají méně času a paměti (např. není potřeba vytvářet žádné pomocné kolekce typu pomocný_seznam)
ve for-cyklu se kvůli jeho flexibilitě snadno může schovat mnohem větší množství chyb

Vztah konvertorů kolekcí k for-cyklům je tedy podobný jako vztah (nemodifikovatelných) n-tic k (modifikovatelným) seznamům: konvertory (a n-tice) jsou mnohem méně flexibilní, ale ve chvíli, kdy tu flexibilitu nepotřebujete, je dobré mít možnost se jí explicitně vzdát a uchránit se tak možných chyb, které by z ní mohly plynout.

Když není konvertor kolekce jediným argumentem funkce, je potřeba ho uzávorkovat...

In [478]:

sorted((slovo for slovo in věta if slovo.islower()), reverse=True)

Out[478]:

['pět', 'nás']

... jinak nás Python vyplísní:

In [479]:

sorted(slovo for slovo in věta if slovo.islower(), reverse=True)

  File "<ipython-input-479-bd2750ac97af>", line 1
    sorted(slovo for slovo in věta if slovo.islower(), reverse=True)
           ^
SyntaxError: Generator expression must be parenthesized

Existuje speciální syntax na to, když chceme výsledky z konvertoru kolekce nasypat do seznamu (angl. se tomuto zápisu říká list comprehension)...

In [480]:

[slovo for slovo in věta if slovo.islower()]

Out[480]:

['nás', 'pět']

... do množiny (angl. set comprehension)...

In [481]:

{len(slovo) for slovo in věta}

Out[481]:

{1, 3, 4}

... nebo do slovníku (angl. dict comprehension):

In [482]:

{slovo: len(slovo) for slovo in věta}

Out[482]:

{'Bylo': 4, 'nás': 3, 'pět': 3, '.': 1}

U ostatních kolekcí speciální syntax neexistuje, ale není proč si zoufat, jejich konstruktory většinou podporují inicializaci na základě zdrojového iterovatelného objektu, takže stačí vepsat konvertor kolekce do konstruktoru:

In [483]:

tuple(slovo.lower() for slovo in věta)

Out[483]:

('bylo', 'nás', 'pět', '.')

In [484]:

from nltk import FreqDist

FreqDist(slovo.lower() for slovo in věta)

Out[484]:

FreqDist({'bylo': 1, 'nás': 1, 'pět': 1, '.': 1})

Konvertory kolekcí jsou velmi užitečné v kombinaci s logickými funkcemi all a any (viz výše odd. Logika):

In [485]:

all(x < 10 for x in range(5))

Out[485]:

True

In [486]:

any(x == 2 for x in range(5))

Out[486]:

True

In [487]:

all(x == 2 for x in range(5))

Out[487]:

False

Konvertorům kolekce též říkáme generátorové výrazy (angl. generator expression), podle toho, že jejich výsledkem je generátor -- objekt, který generuje další objekty (na základě prvků původní kolekce). Když ho vytvoříme samostatně, můžeme si ho i prohlédnout:

In [488]:

gen = (slovo for slovo in věta)

In [489]:

gen

Out[489]:

<generator object <genexpr> at 0x7fea335dd7b0>

In [490]:

type(gen)

Out[490]:

generator

Generátory poslouží kdekoli, kde je potřeba iterovatelný objekt (podobně jako kolekce nebo funkce range). Navíc z nich lze prvky vytahovat po jednom pomocí zabudované funkce next:

In [491]:

next(gen)

Out[491]:

'Bylo'

Existují dvě široké kategorie iterovatelných objektů:

kolekce
a něco, co bychom mohli souhrnně nazvat potenciální či virtuální kolekce (sem patří generátory, výstupy funkcí range, reversed, enumerate apod.)

Rozdíl mezi reálnou kolekcí o milionu prvků a potenciální kolekcí o milionu prvků je v tom, že v případě reálné kolekce musí celý milion prvků zároveň fyzicky existovat v paměti počítače. U potenciální kolekce stačí mít recept, jak ten milion prvků vytvořit... až budou potřeba.

Často nepotřebujeme všechny prvky kolekce najednou, stačí nám je zpracovávat jeden po druhém. Pak jsou potenciální kolekce ideální -- zabírají mnohem méně paměti.

Jindy ale všechny prvky najednou potřebujeme, typicky když si je chceme prohlédnout. Pak nám potenciální kolekce moc neposlouží:

In [492]:

(slovo for slovo in věta)

Out[492]:

<generator object <genexpr> at 0x7fea2bf89510>

In [493]:

enumerate(slovo for slovo in věta)

Out[493]:

<enumerate at 0x7fea2bf86c80>

In [494]:

reversed([1, 2, 3])

Out[494]:

<list_reverseiterator at 0x7fea2bfbfd30>

In [495]:

range(-2, 2)

Out[495]:

range(-2, 2)

Řešení je naštěstí jednoduché -- stačí potenciální kolekci donutit, aby vygenerovala všechny prvky, které v ní dřímají, a uložit je do reálné kolekce, např. do seznamu:

In [496]:

list(slovo for slovo in věta)

Out[496]:

['Bylo', 'nás', 'pět', '.']

In [497]:

list(enumerate(slovo for slovo in věta))

Out[497]:

[(0, 'Bylo'), (1, 'nás'), (2, 'pět'), (3, '.')]

In [498]:

list(reversed([1, 2, 3]))

Out[498]:

[3, 2, 1]

In [499]:

list(range(-2, 2))

Out[499]:

[-2, -1, 0, 1]

Drobnosti¶

Práce se soubory¶

Nejjednodušeji se v Pythonu pracuje se soubory v podobě tzv. čistého textu (angl. plain text; často mívají příponu .txt).

K otevření souboru slouží zabudovaná funkce open. Chceme-li do souboru zapisovat, je potřeba specifikovat mód w (jako write):

In [500]:

text = "kočka leze dírou\npes oknem"

with open("kočka.txt", "w", encoding="utf-8") as file:  # hlavička
    file.write(text)                                    # tělo

Argument encoding je nepovinný, Python ho automaticky stanoví na základě nastavení vašeho operačního systému (v podstatě všude kromě Windows to bude UTF-8). Vzhledem k tomu, že vaše první volba kódování by vždy měla být UTF-8 (viz notebook unicode.ipynb), je dobré si zvyknout ho vypisovat explicitně a nenechat operační systém rozhodovat za vás.

Syntaxi s klíčovým slovíčkem with se říká context manager. V hlavičce zavoláme funkci open a její výsledek uložíme do proměnné file, která reprezentuje otevřený soubor. Tělo je pak kontext, v jehož rámci s tímto otevřeným souborem můžeme pracovat (v našem případě do něj zapisovat). Jakmile kontext skončí (= zrušíme odsazení), Python za nás soubor automaticky zase zavře, aniž bychom museli ručně volat metodu file.close(). Co víc, pokud v rámci těla nastane nějaký problém (chyba), tak Python soubor taky zavře, ještě než zkolabuje, abychom po sobě nenechali nepořádek.

Když chceme soubor znovu načíst, můžeme při jeho otevírání specifikovat mód r (jako read), ale nemusíme, protože je to default. Při načítání máme tři možnosti -- buď načteme celý soubor najednou jako jeden dlouhý řetězec...

In [501]:

with open("kočka.txt", encoding="utf-8") as file:
    text = file.read()

text

Out[501]:

'kočka leze dírou\npes oknem'

... nebo celý soubor najednou jako seznam řádků...

In [502]:

with open("kočka.txt", encoding="utf-8") as file:
    lines = file.readlines()

lines

Out[502]:

['kočka leze dírou\n', 'pes oknem']

... nebo ho můžeme zpracovávat řádek po řádku pomocí for-cyklu:

In [503]:

with open("kočka.txt", encoding="utf-8") as file:
    for line in file:
        print(line, end="")

kočka leze dírou
pes oknem

Poslední varianta se hodí zejména v případě, že máme velký textový soubor, který nepotřebujeme (a tím pádem ani nechceme) načítat celý najednou do paměti.

Někdy jsou plaintextové soubory strukturované, takže načítat je řádek po řádku není úplně nejlepší způsob, jak s nimi pracovat. Např. jupyterovské notebooky jsou ve formátu JSON, který se snaží reprezentovat základní datové typy (čísla, řetězce, seznamy a slovníky) tak, aby šly vyměňovat mezi různými programovacími jazyky.

Když načteme tento notebook jedním ze standardních způsobů popsaných výše, tahle struktura se nám nevyjeví:

In [504]:

with open("python_crash_course.ipynb", encoding="utf-8") as file:
    nb = file.readlines()

# prvních deset řádků souboru s notebookem
nb[:10]

Out[504]:

['{\n',
 ' "cells": [\n',
 '  {\n',
 '   "cell_type": "code",\n',
 '   "execution_count": 1,\n',
 '   "metadata": {},\n',
 '   "outputs": [\n',
 '    {\n',
 '     "data": {\n',
 '      "text/html": [\n']

Vypadne na nás jen seznam řetězců (= řádků). Podle jejich obsahu se zdá, že tam nějaká struktura bude (vidíme odsazení, uvozovky, hranaté a složené závorky), ale nemůžeme s ní nijak pracovat, jediné, co máme k dispozici, jsou řádky textu.

Na rozpoznání struktury většiny běžných plaintextových formátů (tzv. parsování) naštěstí existují knihovny:

In [505]:

import json

with open("python_crash_course.ipynb", encoding="utf-8") as file:
    nb = json.load(file)

Pomocí knihovny json za nás Python naparsuje strukturu textového souboru a převede ji do podoby, s níž umíme pracovat (vnořené kolekce):

In [506]:

type(nb)

Out[506]:

dict

In [507]:

nb.keys()

Out[507]:

dict_keys(['cells', 'metadata', 'nbformat', 'nbformat_minor'])

In [508]:

nb["cells"][0]["source"]

Out[508]:

['from utils import TableOfContents\n',
 '\n',
 'TableOfContents("python_crash_course.ipynb")']

A tak podobně.

Pokud budete někdy potřebovat v Pythonu pracovat s jinými typy souborů než s čistým textem (např. Excel, Word atp.), na 99 % půjde vygooglit nějakou knihovnu, která vám s tím pomůže. Třeba s excelovými tabulkami se dobře pracuje pomocí knihovny pandas.

Výrazy vs. příkazy¶

Někdy je užitečné mít jemnější terminologické rozlišení pro různé části kódu.

Výraz (angl. expression) je jakýkoli kousek pythonovského kódu, který lze vyhodnotit a jeho výsledek uložit do proměnné. Jinými slovy, výraz je cokoli, co můžeme napsat napravo od operátoru =. Všechno ostatní v Pythonu jsou příkazy (angl. statement).

Příklady:

Hlavička for-cyklu (for x in y:) je příkaz -- sama o sobě nemá žádný výsledek, který by šel uložit do proměnné. Klíčové slovíčko for ale může být i součástí výrazu, konkrétně generátorového výrazu, jehož výsledkem je generátor:

In [509]:

(x for x in range(3))

Out[509]:

<generator object <genexpr> at 0x7fea2bfebf90>

Podobný rozdíl existuje mezi hlavičkou podmínkového větvení (if x:, elif y: i else: jsou všechno příkazy) a operátorem if ... else, který je součástí výrazu:

In [510]:

42 if False else 0

Out[510]:

A do třetice všeho dobrého: přiřazování proměnné (např. x = 3) je příkaz tvořený:

jménem proměnné (zde x)
přiřazovacím operátorem =
a libovolným výrazem (zde číselný literál 3)

Dokumentace¶

Dokumentace programu slouží k tomu, aby byl čitelný nejen pro Python, ale i pro nás a další programátory. To je důležité, protože když je program nesrozumitelný, těžko se upravuje / opravuje.

Složitější místa v kódu si zaslouží komentář. Je ale zbytečné komentovat každou operaci, zejména když je její záměr i výsledek naprosto jasný už z kódu:

In [511]:

# sečíst dvě jedničky a výsledek uložit do proměnná dva
dva = 1 + 1

Funkce, které nejsou jen na jedno použití, by měly mít dokumentační řetězec (angl. docstring).

In [512]:

def funkce():
    """Toto je dokumentační řetězec.
    
    První řádek by měl obsahovat stručný popis, k čemu funkce
    slouží. Další mohou obsahovat detaily, charakteristiku
    parametrů funkce atp.
    
    """
    pass

Dokumentační řetězec k libovolné funkci si lze zobrazit pomocí zabudované funkce help...

In [513]:

help(funkce)

Help on function funkce in module __main__:

funkce()
    Toto je dokumentační řetězec.
    
    První řádek by měl obsahovat stručný popis, k čemu funkce
    slouží. Další mohou obsahovat detaily, charakteristiku
    parametrů funkce atp.

... nebo v prostředí Jupyter pomocí ?:

In [514]:

funkce?

Signature: funkce()
Docstring:
Toto je dokumentační řetězec.

První řádek by měl obsahovat stručný popis, k čemu funkce
slouží. Další mohou obsahovat detaily, charakteristiku
parametrů funkce atp.
File:      ~/src/dlukes.github.io/content/notebooks/<ipython-input-512-8724e3419bb6>
Type:      function

Inspiraci, jak psát užitečné docstringy, doporučuju hledat u funkcí, které sami používáte :)

In [515]:

sorted?

Signature: sorted(iterable, /, *, key=None, reverse=False)
Docstring:
Return a new list containing all items from the iterable in ascending order.

A custom key function can be supplied to customize the sort order, and the
reverse flag can be set to request the result in descending order.
Type:      builtin_function_or_method

Make the most of Python Jupyter notebooks

2017-12-19T00:00:00+01:00

Python-based Jupyter notebooks mostly consist of Python code, obviously, and some Markdown text. But they also offer some very handy functions and shortcuts which are not available in Python itself, and which are really helpful for interactive work. This is my personal best of / reference.

The shortcuts fall into two groups:

magics: special functions with special syntax whose names start with % (in which case they apply to the rest of the line → "line magics") or %% (in which case they apply to the entire cell → "cell magics")
command line programs: if you know how to use command line programs, you can do so directly from the notebook by prefixing the command line invocation with !

If you want to follow along, the easiest way is to just click this link and have Binder launch a Jupyter environment with the notebook loaded for you. Or you can download this post in its original notebook format here and load it into your own Jupyter instance yourself.

NB: Most of the following also applies to the IPython REPL.

Magics¶

The syntax of magic functions is modeled after the syntax of command line programs:

to call them, just write their name and evaluate the cell, without any parentheses (unlike regular Python functions, which are called like this: function())
arguments are separated just by whitespace (in Python, there are commas: function(arg1, arg))
some have optional arguments (options) which tweak their behavior: these are formed by a hyphen and a letter, e.g. -r

Getting help¶

You can read more about the magic function system by calling the %magic magic:

In [1]:

%magic

%quickref brings up a useful cheat sheet of special functionality:

In [2]:

%quickref

If you want more information about an object, %pinfo and %pinfo2 are your friends:

In [3]:

def foo():
    "This foo function returns bar."
    return "bar"

In [4]:

# shows the object's docstring
%pinfo foo

In [5]:

# shows the full source code
%pinfo2 foo

These are so handy that they have their own special syntax: ? and ??, placed either before or after the object's name:

In [6]:

?foo

In [7]:

foo?

In [8]:

??foo

In [9]:

foo??

Of course, this also works with magic functions:

In [10]:

?%pylab

You can also open a documentation popup by pressing Shift+Tab with your cursor placed in or after a variable name. Repeating the command cycles through different levels of detail.

Manipulating objects¶

The appeal of an interactive environment like Jupyter is that you can inspect any object you're working with by just evaluating it:

In [11]:

foo = 1

In [12]:

foo

Out[12]:

%who and %whos will show you all the objects you've defined:

In [13]:

%who

foo

In [14]:

%whos

Variable   Type    Data/Info
----------------------------
foo        int     1

Sometimes though, these objects are large and you don't want to litter your notebook with tons of output you'll delete right afterwards. (Also, if you forget to delete it, your notebook might get too large to save.) That's when you need to use the Jupyter pager, which lets you inspect an object in a separate window.

In [15]:

foo = "This is a line of text.\n" * 1000

In [16]:

%page foo

By default, the pager pretty-prints objects using the pprint() function from the pprint module. This is handy for collections, because it nicely shows the nesting hierarchy, but not so much for strings, because special characters like newlines \n are shown as escape sequences. If you want the string to look like it would if it were a text file, pass the -r option ("raw") to page through the result of calling str() on the object instead:

In [17]:

%page -r foo

If you want to inspect the source code of a module, use %pfile on the object representing that module, or an object imported from that module:

In [18]:

import os
from random import choice

In [19]:

%pfile os

In [20]:

%pfile choice

Sometimes, you create an object which you know you will want to reuse in a different session or maybe in a completely different notebook. A lightweight way to achieve this is using the %store magic:

In [21]:

%store foo

Stored 'foo' (str)

You can list the values stored in your database by invoking %store without arguments:

In [22]:

%store

Stored variables and their in-db values:
foo             -> 'This is a line of text.\nThis is a line of text.\

To restore a variable from the database into your current Python process, use the -r option:

In [23]:

# restores only `foo`
%store -r foo

In [24]:

# restores all variables in the database
%store -r

And this is how you clear no longer needed variables from storage:

In [25]:

# removes `foo`
%store -d foo

In [26]:

# removes all variables
%store -z

In [27]:

%store

Stored variables and their in-db values:

Working with the file system¶

%ls lists files in the directory where your notebook is stored:

In [28]:

%ls

3foos.py              command_line_intro.ipynb  pos_tagging.ipynb    zipf.ipynb
classification.ipynb  foo.py                    regex.ipynb
cmudict.ipynb         jupyter_magic.ipynb       unicode.ipynb
collocations.ipynb    libraries.ipynb           xcorr_vs_conv.ipynb

If you provide a path as argument, it lists that directory instead:

In [29]:

%ls /etc/nginx

conf.d/         koi-utf     nginx.conf    sites-available/  uwsgi_params
fastcgi.conf    koi-win     proxy_params  sites-enabled/    win-utf
fastcgi_params  mime.types  scgi_params   snippets/

If you provide a glob pattern, then only files that match it are listed:

In [30]:

%ls /etc/nginx/*.conf

/etc/nginx/fastcgi.conf  /etc/nginx/nginx.conf

%ll ("long listing") formats the listing as one entry per line with columns providing additional information:

In [31]:

%ll ~/edu/

total 12805
drwxrwsrwt+  3 lukes 2000147 Oct  4 18:52 exchange/
drwxrwsr-x+ 21 lukes 2041640 Oct 24 14:44 lukes/
drwxrwsr-x+  9 lukes 2060567 Dec 18 21:54 mda/
drwxrwsr-x+ 14 lukes 3001102 Oct 31 17:39 python/
drwxrwsr-x+  4 lukes 2004559 Feb 23  2017 r/
drwxr-sr-x+  4 lukes 2002420 Mar  9  2017 textlink/

One of those columns indicates file size, which is great, but they're in bytes, which is less great (hard to read at a glance). The -h option makes the file sizes print in human-readable format:

In [32]:

%ll -h ~/edu/python/syn*

-rw-rw-r--+ 1 lukes 1.5G Nov  1  2016 /home/lukes/edu/python/syn2015.gz
-rw-rw-r--+ 1 lukes 112M Nov  2  2016 /home/lukes/edu/python/syn2015_sample

%%writefile writes the contents of a cell to a file:

In [33]:

%%writefile foo.py

def foo():
    "This foo function returns bar."
    return "bar"

Writing foo.py

%cat prints the contents of a file into the notebook:

In [34]:

%cat foo.py

def foo():
    "This foo function returns bar."
    return "bar"

%cat is called %cat because it can also concatenate multiple files (or the same file, multiple times):

In [35]:

%cat foo.py foo.py

def foo():
    "This foo function returns bar."
    return "bar"
def foo():
    "This foo function returns bar."
    return "bar"

The output of %cat can be saved into a file with > (if the file exists, it's overwritten):

In [36]:

%cat foo.py foo.py >3foos.py

In [37]:

%cat 3foos.py

def foo():
    "This foo function returns bar."
    return "bar"
def foo():
    "This foo function returns bar."
    return "bar"

Hey! Our 3foos.py is one foo short. Let's add it by appending to the file with >>:

In [38]:

%cat foo.py >>3foos.py

In [39]:

%cat 3foos.py

def foo():
    "This foo function returns bar."
    return "bar"
def foo():
    "This foo function returns bar."
    return "bar"
def foo():
    "This foo function returns bar."
    return "bar"

There, much better.

%less opens a file in the pager (with nice syntax highlighting if it's a Python source file):

In [40]:

%less foo.py

%less is named after the program less, which is used to page through text files at the command line. Why is the original less called "less"? Because an earlier pager program was called more (as in "show me more of this text file"), and as the saying goes, "less is more".

(Programmers are fond of dad jokes. I like how this one works on multiple levels -- the literal meaning that less-the-program is intended to replace more-the-program interacts with the figurative meaning that having less is better than having more, and both coalesce into "use less because it's better than more".)

%cat and %ls are also named after corresponding command line programs.

Finding out more about your code¶

When developing, code often behaves differently from what you intended when you wrote it. The following tools might help you find out why.

Timing the execution of a piece of code will help you determine if it's slowing you down. The %timeit magic has your back, it runs your code repeatedly and thus provides more reliable estimates. It comes in both line and cell variants.

In [41]:

%timeit sorted(range(1_000_000))

61.4 ms ± 7.63 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [42]:

%%timeit
lst = list(range(1_000_000))
sorted(lst)

68.8 ms ± 7.57 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

The cell variant can include initialization code on the first line, which is run only once:

In [43]:

%%timeit lst = list(range(1_000_000))
sorted(lst)

28.8 ms ± 4.84 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

If you have the memory_profiler library installed, you can load its magic extension and use %memit in the same way as %timeit to get a notion of how much memory your code is consuming.

In [44]:

%load_ext memory_profiler

In [45]:

%memit list(range(1_000_000))

peak memory: 82.43 MiB, increment: 35.71 MiB

Peak memory is the highest total amount of memory the Python process used when your code ran. Increment is peak memory minus the amount of memory Python used before your code ran.

In [46]:

%%memit
lst = list(range(1_000_000))
even = [i for i in lst if i % 2 == 0]

peak memory: 127.82 MiB, increment: 73.29 MiB

In [47]:

%%memit lst = list(range(1_000_000))
even = [i for i in lst if i % 2 == 0]

peak memory: 98.02 MiB, increment: -30.69 MiB

If you have a more involved piece of code where multiple functions are called, you may need more granular information about running times than that provided by %timeit. In that case, you can resort to profiling using the %prun magic. Profiling tells you how fast different parts of your code run relative to each other, in other words, where your bottlenecks are.

In [48]:

import time

def really_slow():
    time.sleep(1)

def fast():
    pass

def only_slow_because_it_calls_another_slow_function():
    fast()
    really_slow()

In [49]:

%prun only_slow_because_it_calls_another_slow_function()

The results show up in the pager, here's a copy:

         7 function calls in 1.001 seconds

   Ordered by: internal time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    1.001    1.001    1.001    1.001 {built-in method time.sleep}
        1    0.000    0.000    1.001    1.001 {built-in method builtins.exec}
        1    0.000    0.000    1.001    1.001 <ipython-input-81-8d3b1f67a0d9>:3(really_slow)
        1    0.000    0.000    1.001    1.001 <ipython-input-81-8d3b1f67a0d9>:9(only_slow_because_it_calls_another_slow_function)
        1    0.000    0.000    1.001    1.001 <string>:1(<module>)
        1    0.000    0.000    0.000    0.000 <ipython-input-81-8d3b1f67a0d9>:6(fast)
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

%prun also has a cell variant:

In [50]:

%%prun
really_slow()
fast()

         6 function calls in 1.001 seconds

   Ordered by: internal time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    1.001    1.001    1.001    1.001 {built-in method time.sleep}
        1    0.000    0.000    1.001    1.001 {built-in method builtins.exec}
        1    0.000    0.000    1.001    1.001 <string>:2(<module>)
        1    0.000    0.000    1.001    1.001 <ipython-input-81-8d3b1f67a0d9>:3(really_slow)
        1    0.000    0.000    0.000    0.000 <ipython-input-81-8d3b1f67a0d9>:6(fast)
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

Perhaps the most useful magic for development is %debug, which allows you to pause the execution of a piece of code, examine the variables which are defined at that moment in time, resume execution fully or step-by-step etc. You can either pass a statement that you want to debug as argument:

In [51]:

def foo():
    for i in range(10):
        print("printing", i)

In [52]:

%debug foo()

NOTE: Enter 'c' at the ipdb>  prompt to continue execution.
> <string>(1)<module>()

ipdb> help

Documented commands (type help <topic>):
========================================
EOF    cl         disable  interact  next    psource  rv         unt   
a      clear      display  j         p       q        s          until 
alias  commands   down     jump      pdef    quit     source     up    
args   condition  enable   l         pdoc    r        step       w     
b      cont       exit     list      pfile   restart  tbreak     whatis
break  continue   h        ll        pinfo   return   u          where 
bt     d          help     longlist  pinfo2  retval   unalias  
c      debug      ignore   n         pp      run      undisplay

Miscellaneous help topics:
==========================
exec  pdb

ipdb> step
--Call--
> <ipython-input-51-e20c0aea6cfb>(1)foo()
----> 1 def foo():
      2     for i in range(10):
      3         print("printing", i)

ipdb> next
> <ipython-input-51-e20c0aea6cfb>(2)foo()
      1 def foo():
----> 2     for i in range(10):
      3         print("printing", i)

ipdb> next
> <ipython-input-51-e20c0aea6cfb>(3)foo()
      1 def foo():
      2     for i in range(10):
----> 3         print("printing", i)

ipdb> i
0
ipdb> next
printing 0
> <ipython-input-51-e20c0aea6cfb>(2)foo()
      1 def foo():
----> 2     for i in range(10):
      3         print("printing", i)

ipdb> next
> <ipython-input-51-e20c0aea6cfb>(3)foo()
      1 def foo():
      2     for i in range(10):
----> 3         print("printing", i)

ipdb> i
1
ipdb> quit

Or you can invoke plain %debug after an exception has been raised to jump directly to the place where the error occurred, so that you can figure out why things went wrong:

In [53]:

def foo():
    dct = dict(foo=1)
    return dct["bar"]

In [54]:

foo()

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-54-c19b6d9633cf> in <module>()
----> 1 foo()

<ipython-input-53-29ed6ce0c4f1> in foo()
      1 def foo():
      2     dct = dict(foo=1)
----> 3     return dct["bar"]

KeyError: 'bar'

In [55]:

%debug

> <ipython-input-53-29ed6ce0c4f1>(3)foo()
      1 def foo():
      2     dct = dict(foo=1)
----> 3     return dct["bar"]

ipdb> "bar" in dct
False
ipdb> dct.keys()
dict_keys(['foo'])
ipdb> quit

If you want to pause one of your functions and explore its state at a particular point, set a breakpoint using the set_trace() function from the IPython.core.debugger module. The debugger will be automatically invoked when the call to set_trace() is reached during execution:

In [56]:

from IPython.core.debugger import set_trace

def foo():
    for i in range(2):
        set_trace()
        print("printing", i)

In [57]:

foo()

> <ipython-input-56-805417d84ad8>(6)foo()
      2 
      3 def foo():
      4     for i in range(2):
      5         set_trace()
----> 6         print("printing", i)

ipdb> i
0
ipdb> continue
printing 0
> <ipython-input-56-805417d84ad8>(5)foo()
      2 
      3 def foo():
      4     for i in range(2):
----> 5         set_trace()
      6         print("printing", i)

ipdb> i
1
ipdb> continue
printing 1

The Python debugger is called pdb and it has some special commands of its own which allow you to step through the execution. They can be listed by typing help at the debugger prompt (see above), or you can have a look at the documentation. The examples above also illustrate what a typical debugging session looks like (stepping through the program, inspecting variables). When you want to stop debugging, don't forget to quit the debugger with quit (or just q) at the debugger prompt, or else your Python process will become unresponsive.

Plotting¶

Jupyter is tightly integrated with the matplotlib plotting library. Plotting is enabled by running the %matplotlib magic with an argument specifying how the notebook should handle graphical output. %matplotlib notebook will generate an interactive plot which you can resize, pan, zoom and more. A word of caution though: when using this variant, once you're done with the plot, don't forget to "freeze" it using the ⏻ symbol in the upper right corner, or else subsequent plotting commands from different cells will all draw into this same plot.

In [58]:

%matplotlib notebook

In [59]:

import matplotlib.pyplot as plt

In [60]:

plt.plot(range(10))

Out[60]:

[<matplotlib.lines.Line2D at 0x7ff8e9b94518>]

By contrast, %matplotlib inline will just show a basic plot with a default size:

In [61]:

%matplotlib inline

In [62]:

plt.plot(range(10))

Out[62]:

[<matplotlib.lines.Line2D at 0x7ff8e9afa358>]

For more information on plotting with matplotlib, see their usage guide.

Command line programs¶

The operations listed in the section on magics for working with the file system can of course also be achieved using the corresponding command line programs, so if you know those, no need to memorize the magics. In fact, the magics are often just thin wrappers around the command line programs, which is why they are named the same.

In [63]:

!ls --color -hArtl /etc/nginx

total 56K
-rw-r--r-- 1 root root 3.0K Mar 30  2016 win-utf
-rw-r--r-- 1 root root  664 Mar 30  2016 uwsgi_params
-rw-r--r-- 1 root root  636 Mar 30  2016 scgi_params
-rw-r--r-- 1 root root  180 Mar 30  2016 proxy_params
-rw-r--r-- 1 root root 3.9K Mar 30  2016 mime.types
-rw-r--r-- 1 root root 2.2K Mar 30  2016 koi-win
-rw-r--r-- 1 root root 2.8K Mar 30  2016 koi-utf
-rw-r--r-- 1 root root 1007 Mar 30  2016 fastcgi_params
-rw-r--r-- 1 root root 1.1K Mar 30  2016 fastcgi.conf
drwxr-xr-x 2 root root 4.0K Apr 26  2016 conf.d
-rw-r--r-- 1 root root 1.5K Apr 27  2016 nginx.conf
drwxr-xr-x 2 root root 4.0K Apr 27  2016 sites-enabled
drwxr-xr-x 2 root root 4.0K Aug 15 09:21 sites-available
drwxr-xr-x 2 root root 4.0K Aug 15 09:21 snippets

The only functionality that I miss among the magics is the ability to take a quick look at part of a possibly very large text file. This can be done with the head command line program, which prints the beginning of a file:

In [64]:

!head jupyter_magic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Make the most of Python Jupyter notebooks\n",
    "\n",
    "[![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/dlukes/dlukes.github.io/source?filepath=content%2Fnotebooks%2Fjupyter_magic.ipynb)\n",
    "\n",

The -n option controls how many lines from the beginning of the file should be printed:

In [65]:

!head -n3 jupyter_magic.ipynb regex.ipynb

==> jupyter_magic.ipynb <==
{
 "cells": [
  {

==> regex.ipynb <==
{
 "cells": [
  {

Similarly, the tail program prints endings of files:

In [66]:

!tail -n5 jupyter_magic.ipynb

  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}

Another useful feature of command line execution is that instead of printing the result, you can have it returned as a list of strings corresponding to lines of output. Either by prepending two exclamation marks instead of one:

In [67]:

!!tail -n5 jupyter_magic.ipynb

Out[67]:

['  }', ' },', ' "nbformat": 4,', ' "nbformat_minor": 2', '}']

Or by assigning the expression to a variable:

In [68]:

out = !tail -n5 jupyter_magic.ipynb

In [69]:

out

Out[69]:

['  }', ' },', ' "nbformat": 4,', ' "nbformat_minor": 2', '}']

In summary¶

These are just my favorite shortcuts, the ones I find most helpful. Obviously, there are many more, see %magic or %quickref. If you think I've missed a really neat one, let me know!

Monkey-patching in R

2017-10-24T00:00:00+02:00

While building a Shiny application with R recently, I've come across the need to invert the filterRange() function in the DT package, which provides a convenient high-level way to add DataTables to your Shiny app. As indicated by its name, this function filters a numeric column in your datatable based on a range, so as it contains only values contained within that range. What I needed was the opposite: include values outside the specified range.

The filtering is done server-side and unfortunately, no option is provided out-of-the-box to perform this inversion. One of the solutions is therefore to monkey-patch the filterRange() function in the DT R package, replacing it with a version that filters the outer range instead.

Googling for "monkey patching r" (currently) yields this blog post, which provides a more complicated though arguably cleaner solution, which introduces a new environment in the search path. My position on this is that if you're worried about cleanliness, you shouldn't be monkey-patching in the first place. Conversely, if you decide monkey-patching is acceptable in your situation, the code required should be as quick and dirty as the thought.

Of course, this is R, uncontested king of weird ways of doing anything but the most common data analysis tasks, and even some of those -- so it's never going to be as simple as Python, for instance:

import sys
sys.stdin = "foo"
# Aaand done.

But it doesn't have to be as complicated as the solution in the blog post above, either.

The solution presented here is basically taken from this mailing list post, which has the disadvantage of not containing the key term "monkey-patch", which makes it hard to find on Google. It consists in the following steps:

Get a handle on the relevant library's namespace with getNamespace().
Make the relevant binding modifiable with unlockBinding().
Define your custom version of the function.
Store it in the namespace under the original name.
Re-seal everything with lockBinding().

Here's the code for my specific use case with DT::filterRange():

# Monkey patch the filterRange() function in the DT package so that server-side filtering returns
# values *outside* the range instead of inside.

DT <- getNamespace("DT")
unlockBinding("filterRange", DT)

####################################################################################################
# This part of the code is deliberately kept as similar to the original as possible, in order to
# make potential updates easier. See https://github.com/rstudio/DT/blob/v0.2/R/shiny.R#L474.

# filter a numeric/date/time vector using the search string "lower ... upper"
filterRange = function(d, string) {
  if (!grepl('[.]{3}', string) || length(r <- strsplit(string, '[.]{3}')[[1]]) > 2)
    stop('The range of a numeric / date / time column must be of length 2')
  if (length(r) == 1) r = c(r, '')  # lower,
  r = gsub('^\\s+|\\s+$', '', r)
  r1 = r[1]; r2 = r[2]
  if (is.numeric(d)) {
    r1 = as.numeric(r1); r2 = as.numeric(r2)
  } else if (inherits(d, 'Date')) {
    if (r1 != '') r1 = as.Date(r1)
    if (r2 != '') r2 = as.Date(r2)
  } else {
    if (r1 != '') r1 = as.POSIXct(r1, tz = 'GMT', '%Y-%m-%dT%H:%M:%S')
    if (r2 != '') r2 = as.POSIXct(r2, tz = 'GMT', '%Y-%m-%dT%H:%M:%S')
  }
  if (r[1] == '') return(d <= r2)
  if (r[2] == '') return(d >= r1)
  d <= r1 | d >= r2
}

# End pastiche of original DT code.
####################################################################################################

DT$filterRange <- filterRange
lockBinding("filterRange", DT)

EDIT, 2021-04-13: As Vincent Wolowski points out in the comments, you can also call the higher-level function assignInNamespace, which does the unlock/relock dance for you behind the scenes: assignInNamespace('filterRange', filterRange, 'DT').

The last piece of the puzzle concerns UX: the user should understand that the filter applies to the outer range, not the inner one. Visually:

This is easily achieved with a few lines of CSS:

#datatable-id .noUi-background {
    background: #3FB8AF;
    box-shadow: inset 0 0 3px rgba(51,51,51,.45);
    transition: background 450ms;
}

#datatable-id .noUi-connect {
    background: #FAFAFA;
    box-shadow: inset 0 1px 1px #f0f0f0;
}

In conclusion, monkey-patching is rarely the most elegant, debuggable and maintainable solution to a problem you're having. More often, it's actually the least elegant (etc.) one. But every once in a while, it's the simplest one, the one with the best hassle/reward ratio (until it comes back to bite you once your codebase has grown or assumptions about the monkey-patched code have changed). At any rate, if you need to resort to it, it's nice to have a quick, googlable how-to, hence this post.

"Responsive" iframes, e.g. for DokuWiki and Shiny

2016-09-29T00:00:00+02:00

Sometimes, the best way to embed an interactive element into a website is to use an iframe. Obviously, not when your website is a webapp and that element represents the main functionality it's supposed to provide -- that would be gross. But when your website is mostly textual / graphical content, typically authored within a wiki or blogging platform, and you just want to include this one element to liven it up, iframes are actually a decent (and perhaps the only?) solution.

Trouble is, you probably want this Frankenstein monster to actually look good, i.e. seamless if at all possible. But iframes don't have automatic vertical resizing according to their content, which means you'll need to take care of that manually. How? By using the JavaScript messaging API for communication between parent and child frames to send information about window resize events (from parent to child) and height updates (from child to parent).

Let's imagine you have a DokuWiki article in which you want to embed a small Shiny app. If you just embed it in your dokuwiki code using an iframe, taking care to remove the border and stretch it horizontally...

<html>
<iframe id="embedded-app" src="https://your.shiny.app/url" frameborder="0" width="100%"></iframe>
</html>

... this will happen:

Eww, scrollbar. Messaging to the rescue! First of all, you need to teach your embedded web page to send information about its height to the parent at appropriate times. This can be achieved by adding this piece of JavaScript to it:

(function() {
  ////////////////////////////////////////////
  // CONFIGURE THESE TO MATCH YOUR USE CASE //
  ////////////////////////////////////////////

  // set this to a selector for the element that contains the entire UI
  // you want to access via the iframe -- for a Shiny app, it might be
  // a div with Bootstrap's container-fluid class
  var containerSelector = ".container-fluid";

  // this should be the root URL of the parent frame (DokuWiki) which you want
  // to allow to send messages to the child
  var allowedOrigin = "https://dokuwiki.example.com"

  ///////////////////////
  // END CONFIGURATION //
  ///////////////////////

  function sendHeightOf(querySelector) {
    var container = document.querySelector(querySelector);
    if (container.scrollHeight !== undefined) {
      var h = container.scrollHeight;
      parent.postMessage(h, "*");
    } else {
      console.log("No element corresponding to querySelector " + querySelector +
                  " found, or element did not have property scrollHeight.");
    }
  }

  // cross-browser compatible infrastructure
  var eventMethod = window.addEventListener ? "addEventListener" : "attachEvent";
  var eventer = window[eventMethod];
  var messageEvent = eventMethod == "attachEvent" ? "onmessage" : "message";

  // listen for resize message from parent window (see point ② below)
  eventer(messageEvent, function(e) {
    if (e.origin == allowedOrigin) {
      sendHeightOf(containerSelector);
    } else {
      console.log("Was expecting a message from " + allowedOrigin + ", got "
                  + e.origin + " instead.");
    }
  });

  window.onload = function() {
    // inform parent at least once after load (see point ① below)
    sendHeightOf(containerSelector);

    // monitor self-initiated changes in size (see point ③ below)
    var mo = new MutationObserver(function() {
      sendHeightOf(containerSelector);
    });
    mo.observe(document, {subtree: true, childList: true, characterData: true});
  };
})();

What are these "appropriate times" mentioned above? The code above implements the following ones, which should be generic enough to cover most situations:

on initial page load
on window resize (see below, the parent frame has to send a message to the child frame that it has been resized, to which the child responds with a size update message)
on any kind of mutation of the DOM inside the child frame (not a full reload of the entire page, that would be handled by point ① above), which might affect the size of the rendered component

On the parent (DokuWiki) side, you then need to handle the incoming size update messages from the child frame, and send resize messages when the window is resized. This can be achieved with the following DokuWiki markup:

<html>
<iframe id="embedded-app" src="https://your.shiny.app/url" frameborder="0" width="100%"></iframe>
<script>
(function() {
  ////////////////////////////////////////////
  // CONFIGURE THESE TO MATCH YOUR USE CASE //
  ////////////////////////////////////////////

  // this should be the root URL of the child frame (Shiny app) which you want
  // to allow to send messages to the parent
  var allowedOrigin = "https://your.shiny.app"

  ///////////////////////
  // END CONFIGURATION //
  ///////////////////////

  var embeddedApp = document.getElementById("embedded-app");

  function resizeIframe(pixels) {
      embeddedApp.style.height = pixels + "px";
  }

  // cross-browser compatible infrastructure
  var eventMethod = window.addEventListener ? "addEventListener" : "attachEvent";
  var eventer = window[eventMethod];
  var messageEvent = eventMethod == "attachEvent" ? "onmessage" : "message";

  // listen to message from iframe
  eventer(messageEvent, function(e) {
    if (e.origin === allowedOrigin) {
      var key = e.message ? "message" : "data";
      var data = e[key];
      resizeIframe(data);
    } else {
      console.log("Was expecting a message from " + allowedOrigin + ", got " + e.origin + " instead.");
    }
  }, false);

  // send message to iframe on window resize
  window.onresize = function() {
    embeddedApp.contentWindow.postMessage("parentWindowResized", "*");
  };
})();
</script>
</html>

And the result?

Yay! And of course, the iframe gets resized as needed when display conditions change:

Cue bittersweet feeling after having figured out a workaround for such a specific use case that you're not quite sure it was worth putting all that effort into it in the first place...

Beyond semantic versioning? (cross-post)

2014-12-14T00:00:00+01:00

Background

Ever since I first read about semantic versioning, I've thought of it as a neat idea. But only recently did it occur to me that what I liked about the idea was its goal, much less its execution (more on that below). What made it obvious was this lengthy discussion about breaking changes introduced in v1.7 of underscore.js without an accompanying major version bump.

Even though I still think sticking to semver is the right thing to do if your community of users expects you to (even if you don't personally like the system), I am convinced there are fundamentally better ways of dealing with the problem of safely and consistently updating dependencies.

It made me want to add my two cents to the discussion, as someone who's more of a dabbler in programming and not really part of the community, so feel free to ignore me :) I attach my commentary below for reference (it's virtually the same text as in the link above).

tl;dr

semver is trying to do the right thing, but doing it wrong -- instead of implicitly encoding severity of change information in version numbers, explicit keywords like :patch, :potentially-breaking or :major-api-change would make much more sense.

More verbosely

I've always found the goals of semver worthy, but this thread has made me realize that while its aims are commendable, its methods are kind of broken:

semver tries to take an existing semiotic system (= version numbers), which has developed informally and is therefore a loose convention rather than an exact spec, and reinterpret it in terms of an exact spec (or impose that spec on it). trouble is, the prior informal meaning won't go away so easily (why should it?), especially for projects that have been around longer than semver. the problem then is, since the two systems (the informal one and semver) look the same in terms of their symbolic representation, it's hard to guess which one you're dealing with by just eyeballing the version number of a library (or project in general).

it's like if someone decided that "f*ck" should mean "orchid" from now on, because it's nicer -- on hearing the word, you'd never know if it's being used as the original profanity, or in its new meaning. homonymy is a pain to deal with when it's accidental (cf. NLP), so why introduce it on purpose? the job that semver set out to do should be fulfilled by a new formal means which is instantly recognizable, not by hijacking an existing one and overlaying additional interpretation on it and thus making it ambiguous.
even if version numbers hadn't existed before semver, they're terribly inadequate for the purpose of conveying information about the severity of changes introduced by an update (though I understand their appeal to mathematically-minded people). they're inadequate because they're implicit -- it's a bit like if someone decided they don't need hash maps because they can make do with arrays by remembering the order in which they're adding in the key-val pairs. if I remember the order, then I know which key the given index implicitly refers to, and the result is as good as a hash map, isn't it?

except it isn't. keys are useful because they have explicit semantics, making it instantly clear what kind of value you're retrieving. in the same way, encoding the information about the severity of changes into version numbers makes it implicit (in addition to being ambiguous, as stated previously). why not use explicit keyword tags along with the version number (which can be romantic, semantic -- whichever floats the dev team's boat and best reflects the progress of the project) to give a heads up as to the nature of the update? e.g. :patch, :potentially-breaking, :major-api-change etc.

granted, even language is a code which needs to be learned, like semver (gross oversimplification here, but let's not get into the details of language acquisition), but since it's widely established and conventionalized for conveying the kinds of meanings semver is trying to convey, why not just use it when it's available? why use a system (version numbers) which is less well-suited to the purpose and ambiguous to boot?

(on the other hand, numbers are eminently well-suited for keeping track of which version is newer than which and how much so -- the original purpose of version numbering -- because they are designed to have orderings defined on them. by contrast, words would do a terrible job at this. if you care to indicate the evolution of your codebase, you might introduce your own disciplined romantic or sentimental versioning scheme, which ironically is a more meaningful and ergo semantic way of doing versioning than semver, because it sticks to the conventional semantics of numbers (the closer the numbers, the more similar the versions). if you don't care about this, which is perfectly fine, you might as well use dates for version numbers.)

keyword tags have the advantage that they're instantly human-readable by anyone who has a basic command of English. if there is sufficient will in the community, a useful subset can be frozen in a binding spec, so that they are machine-readable as well.

I'm not sure whether these keywords should be an appendix to the version number (like v2.3.4-:potentially-breaking), or whether the information they provide should be more extensive and included in a formalized preamble to the changelog (finally forcing people to at least take a glance at it ;) ). using the latter approach, the information provided could be (optionally) even more targeted, e.g. detailing explicitly which parts of the API are affected in a non-backwards compatible manner by the update.

anyways, just a few ideas :) I am not primarily a coder, so there may be obvious drawbacks to this scheme that I can't see or which have already been discussed by the community on multiple occasions which have escaped my attention. in which case, please bear with me and excuse my lack of sophistication.