From 3285bb7430e1cb6ca828cfbd939983c48dcdc7d6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Thu, 3 Aug 2017 18:41:26 +0200 Subject: [PATCH 01/24] introduction for buttons --- docs/tutorials/buttons.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/tutorials/buttons.rst b/docs/tutorials/buttons.rst index 51511ea..cf82c0a 100644 --- a/docs/tutorials/buttons.rst +++ b/docs/tutorials/buttons.rst @@ -1,9 +1,9 @@ Buttons ------- -So far we have created code that makes the device do something. This is called -*output*. However, we also need the device to react to things. Such things are -called *inputs*. +Jak dotychczas utworzyliśmy kod umożliwiający urządzeniu pokazywanie czegoś. Nazywa się to +*wyjście*. Musimy też jednak umożliwić urządzeniu reagowanie na zdarzenia. +Nazywa się to *wejście*. It's easy to remember: output is what the device puts out to the world whereas input is what goes into the device for it to process. From b52944736c2a2d2b821ff726480ebac35d39f676 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Tue, 8 Aug 2017 16:15:28 +0200 Subject: [PATCH 02/24] Translated 4 paragraphs of tutorial buttons --- docs/tutorials/buttons.rst | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/docs/tutorials/buttons.rst b/docs/tutorials/buttons.rst index cf82c0a..e294dbb 100644 --- a/docs/tutorials/buttons.rst +++ b/docs/tutorials/buttons.rst @@ -1,25 +1,28 @@ Buttons ------- -Jak dotychczas utworzyliśmy kod umożliwiający urządzeniu pokazywanie czegoś. Nazywa się to -*wyjście*. Musimy też jednak umożliwić urządzeniu reagowanie na zdarzenia. -Nazywa się to *wejście*. +Jak dotychczas utworzyliśmy kod umożliwiający urządzeniu pokazywanie czegoś. +Nazywa się to *wyjście*. Musimy też jednak umożliwić urządzeniu reagowanie na +zdarzenia. Nazywa się to *wejście*. -It's easy to remember: output is what the device puts out to the world -whereas input is what goes into the device for it to process. +Łatwo zapamiętać: wyjście dotyczy wszystkiego co wychodzi z urządzenia, +natomiast wejście to wszystko co przychodzi do urządzenia w celu +przetworzenia. -The most obvious means of input on the micro:bit are its two buttons, labelled -``A`` and ``B``. Somehow, we need MicroPython to react to button presses. +Najbardziej oczywiste jest to, że wejściem będą dwa przyciski na mikrobicie, +które oznaczone są jako 'A' i 'B'. Potrzebujemy aby MicroPython jakoś +zareagował na naciśnięcie przycisku. -This is remarkably simple:: +To jest fenomenalnie proste: from microbit import * sleep(10000) display.scroll(str(button_a.get_presses())) -All this script does is sleep for ten thousand milliseconds (i.e. 10 seconds) -and then scrolls the number of times you pressed button ``A``. That's it! +Cały skrypt jest uśpiony przez 10 000 milisekund (czyli 10 sekund) a po tym +czasie na wyświetlaczu przewinie się liczba ilości wciśnięć przycisku 'A'. +To tyle. While it's a pretty useless script, it introduces a couple of interesting new ideas: From d72a628a4c9fcb403231ce9c1bb17b85e18b7f9b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Lewtak?= Date: Thu, 24 Aug 2017 22:08:04 +0200 Subject: [PATCH 03/24] First translation for hello.rst --- docs/tutorials/hello.rst | 119 ++++++++++++++++++++------------------- 1 file changed, 61 insertions(+), 58 deletions(-) diff --git a/docs/tutorials/hello.rst b/docs/tutorials/hello.rst index 3d6d473..242351e 100644 --- a/docs/tutorials/hello.rst +++ b/docs/tutorials/hello.rst @@ -1,72 +1,75 @@ -Hello, World! +Witaj, świecie! ------------- -The traditional way to start programming in a new language is to get your -computer to say, "Hello, World!". +Tradycyjnie, gdy uczymy się programowania w nowym języku, pierwsza aplikacja +to wyświetlenie komunikatu "Hello, world!" (ang. "witaj świecie"). + .. image:: ../scroll-hello.gif -This is easy with MicroPython:: +To proste z MicroPythonem:: from microbit import * - display.scroll("Hello, World!") + display.scroll("Hello, world!") -Each line does something special. The first line:: +Każda linia ma swoje znaczenie. Pierwsza z nich:: from microbit import * -...tells MicroPython to get all the stuff it needs to work with the BBC -micro:bit. All this stuff is in a module called ``microbit`` (a module -is a library of pre-existing code). When you ``import`` something you're telling -MicroPython that you want to use it, and ``*`` is Python's way to say -*everything*. So, ``from microbit import *`` means, in English, "I want to be -able to use everything from the microbit code library". - -The second line:: - - display.scroll("Hello, World!") - -...tells MicroPython to use the display to scroll the string of characters -"Hello, World!". The ``display`` part of that line is an *object* from the -``microbit`` module that represents the device's physical display (we say -"object" instead of "thingy", "whatsit" or "doodah"). We can tell the display -to do things with a full-stop ``.`` followed by what looks like a command (in -fact it's something we call a *method*). In this case we're using the -``scroll`` method. Since ``scroll`` needs to know what characters to scroll -across the physical display we specify them between double quotes (``"``) -within parenthesis (``(`` and ``)``). These are called the *arguments*. So, -``display.scroll("Hello, World!")`` means, in English, "I want you to use the -display to scroll the text 'Hello, World!'". If a method doesn't need any -arguments we make this clear by using empty parenthesis like this: ``()``. - -Copy the "Hello, World!" code into your editor and flash it onto the device. -Can you work out how to change the message? Can you make it say hello to you? -For example, I might make it say "Hello, Nicholas!". Here's a clue, you need to -change the scroll method's argument. +...mówi MicroPythonowi, by zaimportował wszystkie rzeczy potrzebne do pracy +z BBC micro:bit. Wszystko to jest w module ``microbit`` (moduł to biblioteka +z wcześniej przygotowanym kodem). Poleceniem ``import`` mówisz MicroPythonowi, +że chcesz użyć danego modułu, a ``*`` to sposób Pythona, na określenie *wszystkiego*. +Zatem ``from microbit import *`` oznacza "chcę użyć wszystkich dostępnych funkcji +z biblioteki microbit". + +Druga linia:: + + display.scroll("Hello, world!") + +...mówi MicroPythonowi, by użył wyświetlacz do wyświetlenia przesuwającego +się ciągu znaków "Hello, world!". ``display`` w tym przypadku to *obiekt* +(ang. object) z modułu ``microbit``, który reprezentuje fizyczny wyświetlacz +urządzenia (mówimy "obiekt" zamiast "rzecz", "to coś" czy "wichajster"). +By wydać wyświetlaczowi polecenie, piszemy jego nazwę po kropce ``.`` - tak +naprawdę takie polecenia nazywamy *metodami* (ang. method). W tym przypadku +używamy polecenia ``scroll`` (ang. przewiń). Ponieważ polecenie ``scroll`` +musi wiedzieć jakie znaki pokazać na wyświetlaczu, przekazujemy je objęte +cudzysłowem (``"``) i nawiasami (``(`` i ``)``). W programowaniu nazywamy +to *argumentami* (ang. arguments). Zatem ``display.scroll("Hello, world!")`` +oznacza, po angielsku, "chcę użyć wyświetlacza by pokazać przesuwający się +tekst 'Hello, world!'". Jeśli metoda nie potrzebuje żadnych argumentów, +musimy to jasno określić używając pustych nawiasów: ``()``. + +Skopiuj powyższy kod do swojego edytora i zaprogramuj go (ang. flash) na +urządzeniu. Czy domyślasz się jak zmienić wyświetlany tekst? Czy możesz +go zmienić tak, by przywitał ciebie? Na przykład, chciałbym by tekst brzmiał +"Witaj, Andrzeju!". Mała podpowiedź: musisz zmienić argument metody ``scroll``. .. warning:: - It may not work. :-) - - This is where things get fun and MicroPython tries to be helpful. If - it encounters an error it will scroll a helpful message on the micro:bit's - display. If it can, it will tell you the line number for where the error - can be found. - - Python expects you to type **EXACTLY** the right thing. So, for instance, - ``Microbit``, ``microbit`` and ``microBit`` are all different things to - Python. If MicroPython complains about a ``NameError`` it's probably - because you've typed something inaccurately. It's like the difference - between referring to "Nicholas" and "Nicolas". They're two different people - but their names look very similar. - - If MicroPython complains about a ``SyntaxError`` you've simply typed code - in a way that MicroPython can't understand. Check you're not missing any - special characters like ``"`` or ``:``. It's like putting. a full stop in - the middle of a sentence. It's hard to understand exactly what you mean. - - Your microbit may stop responding: you cannot flash new code to it or - enter commands into the REPL. If this happens, try power cycling it. That - is, unplug the USB cable (and battery cable if it's connected), then plug - the cable back in again. You may also need to quit and re-start your code - editor application. + To może nie działać :-) + + Tutaj zaczyna się prawdziwa zabawa, a MicroPython stara się być naprawdę + pomocny. Jeśli napotka błąd, to na wyświetlaczu pokaże komunikat błędu. + W miarę możliwości, pokaże również numer linii kodu, która zawiera błąd. + + Python oczekuje, że wprowadzisz **BEZBŁĘDNY** kod. Na przykład, ``Microbit``, + ``microbit`` i ``microBit`` są przez Pythona traktowane jak trzy osobne + rzeczy. Jeśli w treści błędu zobaczysz ``NameError``, oznacza to że + prawdopodobnie wpisana nazwa została podana niedokładnie. To jak różnica + między "Pawłem" i "Gawłem". To dwa różne imiona, choć brzmią i wyglądają + podobnie. + + Natomiast jeśli w treści błędu zobaczysz ``SyntaxError``, oznacza to po + prostu, że podany kod jest niezrozumiały dla MicroPythona. Sprawdź czy + nie brakuje żadnych znaków specjalnych, jak ``"`` czy ``:``. To tak jak + gdyby umieścić. kropkę w środku zdania. Trudno jest cię wtedy dobrze + zrozumieć. + + Twój microbi może przestać odpowiadać: nie uda się zaprogramować nowego + kodu lub wpisywać poleceń w konsoli REPL. W takim przypadku spróbuj + odłączyć urządzenie od prądu i podłączyć ponownie po krótkiej chwili. + Chodzi o to, by odłączyć kabel USB (i kabel baterii jeśli jest podłączony), + a po chwili podłączyć ponownie. Najpewniej będzie należało również + zrestartować edytor kodu. From d0cf9d72bc287a6cd1445fc070c8e86aa5d7c446 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Lewtak?= Date: Thu, 24 Aug 2017 22:37:27 +0200 Subject: [PATCH 04/24] Few fixes for hello.rst --- docs/tutorials/hello.rst | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/docs/tutorials/hello.rst b/docs/tutorials/hello.rst index 242351e..ffa498c 100644 --- a/docs/tutorials/hello.rst +++ b/docs/tutorials/hello.rst @@ -1,8 +1,8 @@ -Witaj, świecie! +Hello, World! ------------- -Tradycyjnie, gdy uczymy się programowania w nowym języku, pierwsza aplikacja -to wyświetlenie komunikatu "Hello, world!" (ang. "witaj świecie"). +Tradycyjnie, pierwszym krokiem w nauce nowego języka programowania jest stworzenie +aplikacji, która wyświetli komunikat "Witaj świecie!" (ang. "Hello, World"). .. image:: ../scroll-hello.gif @@ -12,7 +12,7 @@ To proste z MicroPythonem:: from microbit import * display.scroll("Hello, world!") -Każda linia ma swoje znaczenie. Pierwsza z nich:: +Każdy wiersz ma swoje znaczenie. Pierwsza z nich:: from microbit import * @@ -27,15 +27,15 @@ Druga linia:: display.scroll("Hello, world!") -...mówi MicroPythonowi, by użył wyświetlacz do wyświetlenia przesuwającego -się ciągu znaków "Hello, world!". ``display`` w tym przypadku to *obiekt* +...mówi MicroPythonowi, by wyświetlił przesuwający się ciągu znaków "Hello, +world!". ``display`` w tym przypadku to *obiekt* (ang. object) z modułu ``microbit``, który reprezentuje fizyczny wyświetlacz -urządzenia (mówimy "obiekt" zamiast "rzecz", "to coś" czy "wichajster"). -By wydać wyświetlaczowi polecenie, piszemy jego nazwę po kropce ``.`` - tak +urządzenia (mówimy "obiekt" zamiast "rzecz" lub "to coś"). +By wydać wyświetlaczowi polecenie, używamy jego nazwy po kropce ``.`` - tak naprawdę takie polecenia nazywamy *metodami* (ang. method). W tym przypadku -używamy polecenia ``scroll`` (ang. przewiń). Ponieważ polecenie ``scroll`` -musi wiedzieć jakie znaki pokazać na wyświetlaczu, przekazujemy je objęte -cudzysłowem (``"``) i nawiasami (``(`` i ``)``). W programowaniu nazywamy +używamy polecenia ``scroll`` (ang. przewiń). Polecenie ``scroll`` +musi wiedzieć jakie znaki pokazać na wyświetlaczu. Wpisujemy je ujęte +w cudzysłów (``"``) i zamknięte w nawiasy (``(`` i ``)``). W programowaniu nazywamy to *argumentami* (ang. arguments). Zatem ``display.scroll("Hello, world!")`` oznacza, po angielsku, "chcę użyć wyświetlacza by pokazać przesuwający się tekst 'Hello, world!'". Jeśli metoda nie potrzebuje żadnych argumentów, From c07135f2522fe83a6c5b78e30a4551a4c2caee14 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Lewtak?= Date: Tue, 5 Sep 2017 21:16:06 +0200 Subject: [PATCH 05/24] Final fixes --- docs/tutorials/hello.rst | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/docs/tutorials/hello.rst b/docs/tutorials/hello.rst index ffa498c..e8740ab 100644 --- a/docs/tutorials/hello.rst +++ b/docs/tutorials/hello.rst @@ -12,7 +12,7 @@ To proste z MicroPythonem:: from microbit import * display.scroll("Hello, world!") -Każdy wiersz ma swoje znaczenie. Pierwsza z nich:: +Każdy wiersz ma swoje znaczenie. Pierwszy z nich:: from microbit import * @@ -27,7 +27,7 @@ Druga linia:: display.scroll("Hello, world!") -...mówi MicroPythonowi, by wyświetlił przesuwający się ciągu znaków "Hello, +...mówi MicroPythonowi, by wyświetlił przesuwający się ciąg znaków "Hello, world!". ``display`` w tym przypadku to *obiekt* (ang. object) z modułu ``microbit``, który reprezentuje fizyczny wyświetlacz urządzenia (mówimy "obiekt" zamiast "rzecz" lub "to coś"). @@ -58,16 +58,16 @@ go zmienić tak, by przywitał ciebie? Na przykład, chciałbym by tekst brzmia ``microbit`` i ``microBit`` są przez Pythona traktowane jak trzy osobne rzeczy. Jeśli w treści błędu zobaczysz ``NameError``, oznacza to że prawdopodobnie wpisana nazwa została podana niedokładnie. To jak różnica - między "Pawłem" i "Gawłem". To dwa różne imiona, choć brzmią i wyglądają + między "Pawłem" i "Gawłem" - dwa różne imiona, choć brzmią i wyglądają podobnie. Natomiast jeśli w treści błędu zobaczysz ``SyntaxError``, oznacza to po prostu, że podany kod jest niezrozumiały dla MicroPythona. Sprawdź czy nie brakuje żadnych znaków specjalnych, jak ``"`` czy ``:``. To tak jak - gdyby umieścić. kropkę w środku zdania. Trudno jest cię wtedy dobrze - zrozumieć. + gdyby umieścić. kropkę w środku zdania. Trudno jest wtedy zrozumieć co + autor miał na myśli. - Twój microbi może przestać odpowiadać: nie uda się zaprogramować nowego + Twój microbit może przestać odpowiadać: nie uda się zaprogramować nowego kodu lub wpisywać poleceń w konsoli REPL. W takim przypadku spróbuj odłączyć urządzenie od prądu i podłączyć ponownie po krótkiej chwili. Chodzi o to, by odłączyć kabel USB (i kabel baterii jeśli jest podłączony), From 61532becd4d3b29a8bbecce72f810bd8fd2176fe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Thu, 7 Sep 2017 17:18:05 +0200 Subject: [PATCH 06/24] half translated buttons page --- docs/tutorials/buttons.rst | 116 +++++++++++++++++++------------------ 1 file changed, 59 insertions(+), 57 deletions(-) diff --git a/docs/tutorials/buttons.rst b/docs/tutorials/buttons.rst index e294dbb..b327f7a 100644 --- a/docs/tutorials/buttons.rst +++ b/docs/tutorials/buttons.rst @@ -22,83 +22,85 @@ To jest fenomenalnie proste: Cały skrypt jest uśpiony przez 10 000 milisekund (czyli 10 sekund) a po tym czasie na wyświetlaczu przewinie się liczba ilości wciśnięć przycisku 'A'. -To tyle. +To wszystko. -While it's a pretty useless script, it introduces a couple of interesting new -ideas: +Chociaż ten skrypt jest bezużyteczny, to jednak pokazuje name kilka ciekawych +pomysłów: -#. The ``sleep`` *function* will make the micro:bit sleep for a certain number - of milliseconds. If you want a pause in your program, this is how to do it. - A *function* is just like a *method*, but it isn't attached by a dot to an - *object*. -#. There is an object called ``button_a`` and it allows you to get the number - of times it has been pressed with the ``get_presses`` *method*. +#. *Funkcja* ``sleep`` usypia micro:bit na pewną ilość milisekund. Jeżeli + chcesz zatrzymać program, to jest sposób w jaki możesz to zrobić. + *Funkcja* jest podobna do *metody* ale nie jest przyporządkowana do + *obiektu* za pomocą kropki. -Since ``get_presses`` gives a numeric value and ``display.scroll`` only -displays characters, we need to convert the numeric value into a string of -characters. We do this with the ``str`` function (short for "string" ~ it -converts things into strings of characters). +#. Istnieje obiekt nazwany ``button_a`` i on pozwala ci pobrać liczbę + określającą ilości naciśnięć za pomocą *metody* ``get_presses``. -The third line is a bit like an onion. If the parenthesis are the -onion skins then you'll notice that ``display.scroll`` contains ``str`` that -itself contains ``button_a.get_presses``. Python attempts to work out the -inner-most answer first before starting on the next layer out. This is called -*nesting* - the coding equivalent of a Russian Matrioshka doll. +*Metoda* ``get_presses`` daje nam tylko wartość, a ``display.scroll`` tylko +wyświetla znaki, więc potrzebujemy jeszcze przetworzyć wartość numeryczną na +znaki. Robimy to za pomocą funkcji ``str`` (skrót od ang "string" ~ przetwarza +wszystko na tekst). + +Trzeci wiersz jest jak cebula. Jeżeli przyjmiesz nawiasy za warstwy cebuli, to +zauważysz, że ``display.scroll`` zawiera ``str``, który zawiera +``button_a.get_presses``. Python próbuje rozpracować najbardziej wewnętrzne +odpowiedzi najpierw, zanim przejdzie do następnej warstwy. To nazywa się +*zagnieżdżenie* - programistyczny odpowiednik rosyjskiej lalki - matrioszka. .. image:: matrioshka.jpg -Let's pretend you've pressed the button 10 times. Here's how Python works out -what's happening on the third line: +Przyjmijmy, że nacisnąłeś przycisk 10 razy. Oto jak działa Python, to dzieje +się w trzeciej linii: -Python sees the complete line and gets the value of ``get_presses``:: +Python widzi pełną linię i dostaje wartość ``get_presses``:: display.scroll(str(button_a.get_presses())) -Now that Python knows how many button presses there have been, it converts the -numeric value into a string of characters:: +Teraz, gdy Python wie już ile razy został wciśnięty przycisk, to przetworzy +wartość numeryczną na tekst:: display.scroll(str(10)) -Finally, Python knows what to scroll across the display:: +No i w końcu Python wie co wyświetlić przewijając na ekranie:: display.scroll("10") -While this might seem like a lot of work, MicroPython makes this happen -extraordinarily fast. +Może ci się wydawać, że to jest mnóstwo pracy ale MicroPython robi to +niezwykle szybko. -Event Loops +Pętle zdarzeń +++++++++++ -Often you need your program to hang around waiting for something to happen. To -do this you make it loop around a piece of code that defines how to react to -certain expected events such as a button press. - -To make loops in Python you use the ``while`` keyword. It checks if something -is ``True``. If it is, it runs a *block of code* called the *body* of the loop. -If it isn't, it breaks out of the loop (ignoring the body) and the rest of the -program can continue. - -Python makes it easy to define blocks of code. Say I have a to-do list written -on a piece of paper. It probably looks something like this:: - - Shopping - Fix broken gutter - Mow the lawn - -If I wanted to break down my to-do list a bit further, I might write something -like this:: - - Shopping: - Eggs - Bacon - Tomatoes - Fix broken gutter: - Borrow ladder from next door - Find hammer and nails - Return ladder - Mow the lawn: - Check lawn around pond for frogs - Check mower fuel level +Często potrzebujesz aby program poczekał na coś, co się wydarzy. Aby uzyskać +to musisz zrobić pętlę dla jakiegoś kawałka kodu, który będzie miał +zdefiniowane w jaki sposób zareagować na oczekiwaną reakcję taką, jak +naciśnięcie przycisku. + +Aby utworzyć pętle w Pythonie użyj słowa kluczowego ``while``. To sprawdza czy +coś jest ``True``. Jeżeli tak jest, to uruchamia *blok kodu* zwany *zawartością* +pętli. Jeżeli jednak nie jest, to przerywa wykonywanie pętli (ignorując zawartość), +a wtedy reszta część programu może wykonać się. + +Python ułatwia definiowanie bloków kodu. Powiedz, że mam listę rzeczy do +zrobienia napisaną na kartcie papieru. Pewnie będzie wyglądało to tak:: + + Zakupy + Napraw uszkodzoną rynnę + Skoś trawnik + +Gdybym chciał nieco rozbić moją listę rzeczy do zrobienia, to mógłbym napisać +coś takiego:: + + Zakupy: + Jaja + Boczek + Pomidory + Napraw uszkodzoną rynnę: + Wyjmij drabinę z sąsiednich drzwi + Znajdź młotek i gwoździe + Obróć grabinę + Skoś trawnik: + Sprawdź trawnik wokół sadzawki dla żab + Sprawdź poziom paliwa w kosiarce It's obvious that the main tasks are broken down into sub-tasks that are *indented* underneath the main task to which they are related. So ``Eggs``, From 81455855962212013be581d059d9db55aa23a571 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Thu, 7 Sep 2017 22:44:32 +0200 Subject: [PATCH 07/24] next part of page buttons.rst --- docs/tutorials/buttons.rst | 50 ++++++++++++++++++++------------------ 1 file changed, 26 insertions(+), 24 deletions(-) diff --git a/docs/tutorials/buttons.rst b/docs/tutorials/buttons.rst index b327f7a..6328607 100644 --- a/docs/tutorials/buttons.rst +++ b/docs/tutorials/buttons.rst @@ -1,4 +1,4 @@ -Buttons +Przyciski ------- Jak dotychczas utworzyliśmy kod umożliwiający urządzeniu pokazywanie czegoś. @@ -37,8 +37,8 @@ pomysłów: *Metoda* ``get_presses`` daje nam tylko wartość, a ``display.scroll`` tylko wyświetla znaki, więc potrzebujemy jeszcze przetworzyć wartość numeryczną na -znaki. Robimy to za pomocą funkcji ``str`` (skrót od ang "string" ~ przetwarza -wszystko na tekst). +znaki. Robimy to za pomocą funkcji ``str`` (skrót od angielskiego słowa +"string" ~ przetwarza wszystko na ciąg znaków). Trzeci wiersz jest jak cebula. Jeżeli przyjmiesz nawiasy za warstwy cebuli, to zauważysz, że ``display.scroll`` zawiera ``str``, który zawiera @@ -56,11 +56,11 @@ Python widzi pełną linię i dostaje wartość ``get_presses``:: display.scroll(str(button_a.get_presses())) Teraz, gdy Python wie już ile razy został wciśnięty przycisk, to przetworzy -wartość numeryczną na tekst:: +wartość numeryczną na ciąg znaków:: display.scroll(str(10)) -No i w końcu Python wie co wyświetlić przewijając na ekranie:: +No i w końcu Python wie, że ma wyświetlić przesuwający się tekst na ekranie:: display.scroll("10") @@ -81,7 +81,7 @@ pętli. Jeżeli jednak nie jest, to przerywa wykonywanie pętli (ignorując zawa a wtedy reszta część programu może wykonać się. Python ułatwia definiowanie bloków kodu. Powiedz, że mam listę rzeczy do -zrobienia napisaną na kartcie papieru. Pewnie będzie wyglądało to tak:: +zrobienia napisaną na kartce papieru. Pewnie będzie wyglądało to tak:: Zakupy Napraw uszkodzoną rynnę @@ -102,12 +102,14 @@ coś takiego:: Sprawdź trawnik wokół sadzawki dla żab Sprawdź poziom paliwa w kosiarce -It's obvious that the main tasks are broken down into sub-tasks that are -*indented* underneath the main task to which they are related. So ``Eggs``, -``Bacon`` and ``Tomatoes`` are obviously related to ``Shopping``. By indenting -things we make it easy to see, at a glance, how the tasks relate to each other. +To oczywiste, że główne zadania są podzielone na podrzędne zadania, które +zaczynają się od *akapitu* (wcięcie) (ang. indent) poniżej głównego zadania, do którego +są powiązane. Tak więc ``Jaja``, ``Boczek`` i ``Pomidory`` są oczywiście +związane z zadaniem ``Zakupy``. Wcięcia ułatwiają nam sprawdzanie w jaki sposób +zadania są powiązane ze sobą. -This is called *nesting*. We use nesting to define blocks of code like this:: +To nazywane jest *zagnieżdżeniem*. Używamy zagnieżdżeń do definicji bloków +kodu takich jak:: from microbit import * @@ -116,22 +118,22 @@ This is called *nesting*. We use nesting to define blocks of code like this:: display.show(Image.SURPRISED) -The ``running_time`` function returns the number of milliseconds since the -device started. +Funkcja ``running_time`` zwraca liczbę milisekund od startu urządzenia. -The ``while running_time() < 10000:`` line checks if the running time is less -than 10000 milliseconds (i.e. 10 seconds). If it is, *and this is where we can -see scoping in action*, then it'll display ``Image.ASLEEP``. Notice how this is -indented underneath the ``while`` statement *just like in our to-do list*. +Linia ``while running_time() < 10000:`` sprawdza czy czas pracy urządzenia +jest mniejszy od 10000 milisekund (czyli 10 sekund). Jeżeli tak, *i to jest +miejsce gdzie możemy zobaczyć skalę działania*, to zostanie wyświetlony +``Image.ASLEEP``. Zauważ jak to jest wcięte poniżej instrukcji ``while`` +*tak jak na naszej liście zadań*. -Obviously, if the running time is equal to or greater than 10000 milliseconds -then the display will show ``Image.SURPRISED``. Why? Because the ``while`` -condition will be False (``running_time`` is no longer ``< 10000``). In that -case the loop is finished and the program will continue after the ``while`` -loop's block of code. It'll look like your device is asleep for 10 -seconds before waking up with a surprised look on its face. +Oczywiście, jeśli czas pracy jest równy lub większy niż 10000 milisekund, +wówczas na ekranie pojawi się ``Image.SURPRISED``. Dlaczego? Ponieważ warunek +``while`` będzie fałszywy (ang. False) (``running_time`` nie jest już ``< 10000``). +W takim przypadku pętla jest zakończona i program będzie kontynuowany po bloku +kodu pętli ``while``. Wygląda na to, że twoje urządzenie śpi przez 10 sekund +zanim obudzi się z zaskoczoną miną na swojej twarzy. -Try it! +Wypróbuj to! Handling an Event +++++++++++++++++ From e1a130ee65245e4cdfbb591dd114aa7fa7ba4063 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Fri, 8 Sep 2017 15:04:34 +0200 Subject: [PATCH 08/24] last part of translation buttons.rst --- docs/tutorials/buttons.rst | 75 ++++++++++++++++++++------------------ 1 file changed, 40 insertions(+), 35 deletions(-) diff --git a/docs/tutorials/buttons.rst b/docs/tutorials/buttons.rst index 6328607..d9531a2 100644 --- a/docs/tutorials/buttons.rst +++ b/docs/tutorials/buttons.rst @@ -135,24 +135,26 @@ zanim obudzi się z zaskoczoną miną na swojej twarzy. Wypróbuj to! -Handling an Event +Ogsługa zdarzenia +++++++++++++++++ -If we want MicroPython to react to button press events we should put it into -an infinite loop and check if the button ``is_pressed``. +Jeśli chcemy aby MicroPython reagował na zdarzenia naciśnięcia przycisku, to +powinniśmy umieścić go w nieskończonej pętli i sprawcać, czy przycisk +``is_pressed``. -An infinite loop is easy:: +Nieskończona pętla jest prosta:: while True: - # Do stuff + # rób coś -(Remember, ``while`` checks if something is ``True`` to work out if it should -run its block of code. Since ``True`` is obviously ``True`` for all time, you -get an infinite loop!) +(Pamiętaj, że ``while`` sprawdza czy coś jest ``True`` przed każdym wykonaniem +bloku kodu. Ponieważ ``True`` jest oczywiście ``True`` przez czały czas, to +otrzymujesz nieskończoną pętlę!) -Let's make a very simple cyber-pet. It's always sad unless you're pressing -button ``A``. If you press button ``B`` it dies. (I realise this isn't a very -pleasant game, so perhaps you can figure out how to improve it.):: +Zróbmy bardzo prosty cyber-zwierzak. Jest on smutny, dopóki nie naciśniesz +przycisku ``A``. Ale jeżeli naciśniesz przycisk ``B`` on umrze. (Zdaję sobię +sprawę, że to nie jest zbyt przyjemna gra, więc może masz pomysł jak ją +ulepszyć.):: from microbit import * @@ -166,31 +168,34 @@ pleasant game, so perhaps you can figure out how to improve it.):: display.clear() -Can you see how we check what buttons are pressed? We used ``if``, -``elif`` (short for "else if") and ``else``. These are called *conditionals* -and work like this:: +Czy widzisz jak sprawdzamy, jakie przyciski są wciśnięte? Użyliśmy ``if``, +``elif`` (skrót od "else if") oraz ``else``. Są one nazywane *warunkami* i +działają tak:: - if something is True: - # do one thing - elif some other thing is True: - # do another thing + if coś jest True: + # zrób pierwszą rzecz + elif coś innego jest True: + # zrób następną rzecz else: - # do yet another thing. - -This is remarkably similar to English! - -The ``is_pressed`` method only produces two results: ``True`` or ``False``. -If you're pressing the button it returns ``True``, otherwise it returns -``False``. The code above is saying, in English, "for ever and ever, if -button A is pressed then show a happy face, else if button B is pressed break -out of the loop, otherwise display a sad face." We break out of the loop (stop -the program running for ever and ever) with the ``break`` statement. - -At the very end, when the cyber-pet is dead, we ``clear`` the display. - -Can you think of ways to make this game less tragic? How would you check if -*both* buttons are pressed? (Hint: Python has ``and``, ``or`` and ``not`` -logical operators to help check multiple truth statements (things that -produce either ``True`` or ``False`` results). + # zrób jeszcze coś. + +To jest podobne do języka angielskiego! + +Metoda ``is_pressed`` generuje tylko dwa rezultaty: ``True`` albo ``False``. +Jeżeli naciśniesz przycisk, to zwróci ``True``, w przeciwnym wypadku zwróci +``False``. Powyższy kod można przetłumaczyć jako "jeżeli i tylko wtedy gdy +przycisk A został naciśnięty, to pokaż szczęśliwą twarz, jeżeli przycisk B +został naciśnięty, to przerwij pętlę, a w przeciwnym wypadku pokaż smutną +minę." Przerywamy wykonywanie pętli (zatrzymujemy uruchomiony w nieskończoność +program) za pomocą instrukcji ``braek``. + +Na samym końcu, kiedy cyber-zwierzak nie żyje, wyczyśćmy ekran metodą +``clear``. + +Czy możesz pomyśleć o sposobie, aby ta gra była mniej tragiczna? Jak chciałbyś +sprawdzić, czy przyciski *both* zostały naciśnięte? (Podpowiedź: Python ma +logiczne operatory ``and``, ``or`` i ``not``, które umożliwiają sprawdzenie +wielu wyrażeń warunkowych (rzeczy, które generują rezultaty ``True`` albo +``False``). .. footer:: The image of Matrioshka dolls is licensed CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=69402 From de13dd8c6a313f2b9d17d6e04763f7fd455be8c2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Lewtak?= Date: Fri, 27 Oct 2017 09:56:06 +0200 Subject: [PATCH 09/24] Update hello.rst according to review comments Fixed as suggested by deshipu in https://github.com/deshipu/microbit-micropython-pl/pull/3 --- docs/tutorials/hello.rst | 39 ++++++++++++++++++++------------------- 1 file changed, 20 insertions(+), 19 deletions(-) diff --git a/docs/tutorials/hello.rst b/docs/tutorials/hello.rst index e8740ab..83ef390 100644 --- a/docs/tutorials/hello.rst +++ b/docs/tutorials/hello.rst @@ -19,9 +19,9 @@ Każdy wiersz ma swoje znaczenie. Pierwszy z nich:: ...mówi MicroPythonowi, by zaimportował wszystkie rzeczy potrzebne do pracy z BBC micro:bit. Wszystko to jest w module ``microbit`` (moduł to biblioteka z wcześniej przygotowanym kodem). Poleceniem ``import`` mówisz MicroPythonowi, -że chcesz użyć danego modułu, a ``*`` to sposób Pythona, na określenie *wszystkiego*. -Zatem ``from microbit import *`` oznacza "chcę użyć wszystkich dostępnych funkcji -z biblioteki microbit". +że chcesz użyć danego modułu, a ``*`` to sposób Pythona na określenie *wszystkiego*. +Zatem ``from microbit import *`` oznacza "chcę użyć wszystkiego co jest dostępne +w bibliotece microbit". Druga linia:: @@ -31,15 +31,16 @@ Druga linia:: world!". ``display`` w tym przypadku to *obiekt* (ang. object) z modułu ``microbit``, który reprezentuje fizyczny wyświetlacz urządzenia (mówimy "obiekt" zamiast "rzecz" lub "to coś"). -By wydać wyświetlaczowi polecenie, używamy jego nazwy po kropce ``.`` - tak +By wydać wyświetlaczowi polecenie, po kropce ``.`` podajemy komendę -- tak naprawdę takie polecenia nazywamy *metodami* (ang. method). W tym przypadku używamy polecenia ``scroll`` (ang. przewiń). Polecenie ``scroll`` musi wiedzieć jakie znaki pokazać na wyświetlaczu. Wpisujemy je ujęte -w cudzysłów (``"``) i zamknięte w nawiasy (``(`` i ``)``). W programowaniu nazywamy -to *argumentami* (ang. arguments). Zatem ``display.scroll("Hello, world!")`` -oznacza, po angielsku, "chcę użyć wyświetlacza by pokazać przesuwający się -tekst 'Hello, world!'". Jeśli metoda nie potrzebuje żadnych argumentów, -musimy to jasno określić używając pustych nawiasów: ``()``. +w cudzysłów (``"``) i zamknięte w nawiasy (``(`` i ``)``). W programowaniu to +co przekazujemy do metody nazywamy *argumentami* (ang. arguments). Zatem +``display.scroll("Hello, world!")`` oznacza, po polsku, "chcę użyć +wyświetlacza by pokazać przesuwający się tekst 'Hello, world!'". Jeśli metoda +nie potrzebuje żadnych argumentów, musimy to jasno określić używając pustych +nawiasów: ``()``. Skopiuj powyższy kod do swojego edytora i zaprogramuj go (ang. flash) na urządzeniu. Czy domyślasz się jak zmienić wyświetlany tekst? Czy możesz @@ -56,20 +57,20 @@ go zmienić tak, by przywitał ciebie? Na przykład, chciałbym by tekst brzmia Python oczekuje, że wprowadzisz **BEZBŁĘDNY** kod. Na przykład, ``Microbit``, ``microbit`` i ``microBit`` są przez Pythona traktowane jak trzy osobne - rzeczy. Jeśli w treści błędu zobaczysz ``NameError``, oznacza to że - prawdopodobnie wpisana nazwa została podana niedokładnie. To jak różnica + rzeczy. Jeśli w treści błędu zobaczysz ``NameError`` (błąd nazwy), oznacza + to że prawdopodobnie wpisana nazwa została podana niedokładnie. To jak różnica między "Pawłem" i "Gawłem" - dwa różne imiona, choć brzmią i wyglądają podobnie. - Natomiast jeśli w treści błędu zobaczysz ``SyntaxError``, oznacza to po - prostu, że podany kod jest niezrozumiały dla MicroPythona. Sprawdź czy - nie brakuje żadnych znaków specjalnych, jak ``"`` czy ``:``. To tak jak - gdyby umieścić. kropkę w środku zdania. Trudno jest wtedy zrozumieć co - autor miał na myśli. + Natomiast jeśli w treści błędu zobaczysz ``SyntaxError`` (błąd składni), + oznacza to po prostu, że podany kod jest niezrozumiały dla MicroPythona. + Sprawdź czy nie brakuje żadnych znaków specjalnych, jak ``"`` czy ``:``. + To tak jak gdyby umieścić. kropkę w środku zdania. Trudno jest wtedy + zrozumieć co autor miał na myśli. - Twój microbit może przestać odpowiadać: nie uda się zaprogramować nowego + Twój microbit może przestać reagować: nie uda się zaprogramować nowego kodu lub wpisywać poleceń w konsoli REPL. W takim przypadku spróbuj odłączyć urządzenie od prądu i podłączyć ponownie po krótkiej chwili. Chodzi o to, by odłączyć kabel USB (i kabel baterii jeśli jest podłączony), - a po chwili podłączyć ponownie. Najpewniej będzie należało również - zrestartować edytor kodu. + a po chwili podłączyć ponownie. Może być także konieczne zrestartowanie + edytora kodu. From d5577c8c51dbbe8bd0ac96391dd579466d878217 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Lewtak?= Date: Fri, 27 Oct 2017 10:12:09 +0200 Subject: [PATCH 10/24] Change translation of word "flash" --- docs/tutorials/hello.rst | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/tutorials/hello.rst b/docs/tutorials/hello.rst index 83ef390..da2bee1 100644 --- a/docs/tutorials/hello.rst +++ b/docs/tutorials/hello.rst @@ -42,10 +42,10 @@ wyświetlacza by pokazać przesuwający się tekst 'Hello, world!'". Jeśli meto nie potrzebuje żadnych argumentów, musimy to jasno określić używając pustych nawiasów: ``()``. -Skopiuj powyższy kod do swojego edytora i zaprogramuj go (ang. flash) na -urządzeniu. Czy domyślasz się jak zmienić wyświetlany tekst? Czy możesz -go zmienić tak, by przywitał ciebie? Na przykład, chciałbym by tekst brzmiał -"Witaj, Andrzeju!". Mała podpowiedź: musisz zmienić argument metody ``scroll``. +Skopiuj powyższy kod do swojego edytora i wgraj go (ang. flash) na urządzeniu. +Czy domyślasz się jak zmienić wyświetlany tekst? Czy możesz go zmienić tak, +by przywitał ciebie? Na przykład, chciałbym by tekst brzmiał "Witaj, Andrzeju!". +Mała podpowiedź: musisz zmienić argument metody ``scroll``. .. warning:: From b6869c3ea078c2cd832c633fb78e38352906d42b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Pawe=C5=82=20Lewtak?= Date: Fri, 27 Oct 2017 10:25:22 +0200 Subject: [PATCH 11/24] Grammar fix --- docs/tutorials/hello.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/hello.rst b/docs/tutorials/hello.rst index da2bee1..ef62dee 100644 --- a/docs/tutorials/hello.rst +++ b/docs/tutorials/hello.rst @@ -42,7 +42,7 @@ wyświetlacza by pokazać przesuwający się tekst 'Hello, world!'". Jeśli meto nie potrzebuje żadnych argumentów, musimy to jasno określić używając pustych nawiasów: ``()``. -Skopiuj powyższy kod do swojego edytora i wgraj go (ang. flash) na urządzeniu. +Skopiuj powyższy kod do swojego edytora i wgraj go (ang. flash) do urządzenia. Czy domyślasz się jak zmienić wyświetlany tekst? Czy możesz go zmienić tak, by przywitał ciebie? Na przykład, chciałbym by tekst brzmiał "Witaj, Andrzeju!". Mała podpowiedź: musisz zmienić argument metody ``scroll``. From 0c47ee0be1566b28bdfd4d659f1398ad3125a422 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Fri, 27 Oct 2017 21:31:15 +0200 Subject: [PATCH 12/24] Corrections --- docs/tutorials/buttons.rst | 73 +++++++++++++++++++------------------- 1 file changed, 37 insertions(+), 36 deletions(-) diff --git a/docs/tutorials/buttons.rst b/docs/tutorials/buttons.rst index d9531a2..a7876e2 100644 --- a/docs/tutorials/buttons.rst +++ b/docs/tutorials/buttons.rst @@ -3,17 +3,17 @@ Przyciski Jak dotychczas utworzyliśmy kod umożliwiający urządzeniu pokazywanie czegoś. Nazywa się to *wyjście*. Musimy też jednak umożliwić urządzeniu reagowanie na -zdarzenia. Nazywa się to *wejście*. +zdarzenia. Zdarzenia i wszystkie dane jakie dostaje urządzenie nazywamy *wejściem*. Łatwo zapamiętać: wyjście dotyczy wszystkiego co wychodzi z urządzenia, natomiast wejście to wszystko co przychodzi do urządzenia w celu przetworzenia. -Najbardziej oczywiste jest to, że wejściem będą dwa przyciski na mikrobicie, -które oznaczone są jako 'A' i 'B'. Potrzebujemy aby MicroPython jakoś +Najprostszym sposobem na dostarczenie informacji na wejściu są dwa przyciski na urządzeniu micro:bit, +które oznaczone są jako ``A`` i ``B``. Potrzebujemy aby MicroPython jakoś zareagował na naciśnięcie przycisku. -To jest fenomenalnie proste: +Jest to niezwykle proste: from microbit import * @@ -21,46 +21,46 @@ To jest fenomenalnie proste: display.scroll(str(button_a.get_presses())) Cały skrypt jest uśpiony przez 10 000 milisekund (czyli 10 sekund) a po tym -czasie na wyświetlaczu przewinie się liczba ilości wciśnięć przycisku 'A'. +czasie na wyświetlaczu przewinie się liczba ilości wciśnięć przycisku ``A``. To wszystko. Chociaż ten skrypt jest bezużyteczny, to jednak pokazuje name kilka ciekawych pomysłów: -#. *Funkcja* ``sleep`` usypia micro:bit na pewną ilość milisekund. Jeżeli - chcesz zatrzymać program, to jest sposób w jaki możesz to zrobić. +#. *Funkcja* ``sleep`` usypia microbit na pewną ilość milisekund. Jeżeli + chcesz zatrzymać program, możesz to zrobić używając tej funkcji. *Funkcja* jest podobna do *metody* ale nie jest przyporządkowana do *obiektu* za pomocą kropki. #. Istnieje obiekt nazwany ``button_a`` i on pozwala ci pobrać liczbę - określającą ilości naciśnięć za pomocą *metody* ``get_presses``. + określającą ilość naciśnięć za pomocą *metody* ``get_presses``. -*Metoda* ``get_presses`` daje nam tylko wartość, a ``display.scroll`` tylko -wyświetla znaki, więc potrzebujemy jeszcze przetworzyć wartość numeryczną na -znaki. Robimy to za pomocą funkcji ``str`` (skrót od angielskiego słowa +*Metoda* ``get_presses`` daje nam tylko liczbę, a ``display.scroll`` przyjmuje +tylko ciągi znaków. Dlatego musimy zmienić liczbę na ciąg znaków, co możemy +zrobić za pomocą funkcji ``str`` (skrót od angielskiego słowa "string" ~ przetwarza wszystko na ciąg znaków). Trzeci wiersz jest jak cebula. Jeżeli przyjmiesz nawiasy za warstwy cebuli, to zauważysz, że ``display.scroll`` zawiera ``str``, który zawiera ``button_a.get_presses``. Python próbuje rozpracować najbardziej wewnętrzne -odpowiedzi najpierw, zanim przejdzie do następnej warstwy. To nazywa się +wyrażenia najpierw, zanim przejdzie do następnej warstwy. To nazywa się *zagnieżdżenie* - programistyczny odpowiednik rosyjskiej lalki - matrioszka. .. image:: matrioshka.jpg -Przyjmijmy, że nacisnąłeś przycisk 10 razy. Oto jak działa Python, to dzieje -się w trzeciej linii: +Przyjmijmy, że nacisnąłeś przycisk 10 razy. Python w następujący sposób +analizuje co się dzieje w trzeciej linii: Python widzi pełną linię i dostaje wartość ``get_presses``:: display.scroll(str(button_a.get_presses())) Teraz, gdy Python wie już ile razy został wciśnięty przycisk, to przetworzy -wartość numeryczną na ciąg znaków:: +wartość liczbową na ciąg znaków:: display.scroll(str(10)) -No i w końcu Python wie, że ma wyświetlić przesuwający się tekst na ekranie:: +W końcu Python wie, że ma wyświetlić przesuwający się tekst na ekranie:: display.scroll("10") @@ -70,17 +70,17 @@ niezwykle szybko. Pętle zdarzeń +++++++++++ -Często potrzebujesz aby program poczekał na coś, co się wydarzy. Aby uzyskać -to musisz zrobić pętlę dla jakiegoś kawałka kodu, który będzie miał -zdefiniowane w jaki sposób zareagować na oczekiwaną reakcję taką, jak +Często potrzebujesz aby program poczekał na jakieś zdarzenie. Aby uzyskać +to musisz zamknąć odpowiedni kawałek kodu w pętli, który będzie miał +zdefiniowane w jaki sposób zareagować na oczekiwane zdarzenie takie, jak naciśnięcie przycisku. -Aby utworzyć pętle w Pythonie użyj słowa kluczowego ``while``. To sprawdza czy -coś jest ``True``. Jeżeli tak jest, to uruchamia *blok kodu* zwany *zawartością* +Aby utworzyć pętle w Pythonie użyj słowa kluczowego ``while`` (ang. dopóki). To sprawdza czy +coś jest ``True`` (ang. prawdziwe). Jeżeli tak jest, to uruchamia *blok kodu* zwany *zawartością* pętli. Jeżeli jednak nie jest, to przerywa wykonywanie pętli (ignorując zawartość), -a wtedy reszta część programu może wykonać się. +a wtedy wykona się pozostała część kodu. -Python ułatwia definiowanie bloków kodu. Powiedz, że mam listę rzeczy do +W Pythonie definiowanie bloków kodu jest proste. Powiedzmy, że mam listę rzeczy do zrobienia napisaną na kartce papieru. Pewnie będzie wyglądało to tak:: Zakupy @@ -97,7 +97,7 @@ coś takiego:: Napraw uszkodzoną rynnę: Wyjmij drabinę z sąsiednich drzwi Znajdź młotek i gwoździe - Obróć grabinę + Zwróć drabinę Skoś trawnik: Sprawdź trawnik wokół sadzawki dla żab Sprawdź poziom paliwa w kosiarce @@ -108,7 +108,7 @@ są powiązane. Tak więc ``Jaja``, ``Boczek`` i ``Pomidory`` są oczywiście związane z zadaniem ``Zakupy``. Wcięcia ułatwiają nam sprawdzanie w jaki sposób zadania są powiązane ze sobą. -To nazywane jest *zagnieżdżeniem*. Używamy zagnieżdżeń do definicji bloków +To nazywane jest *zagnieżdżeniem*. Używamy zagnieżdżeń do definiowania bloków kodu takich jak:: from microbit import * @@ -120,15 +120,15 @@ kodu takich jak:: Funkcja ``running_time`` zwraca liczbę milisekund od startu urządzenia. -Linia ``while running_time() < 10000:`` sprawdza czy czas pracy urządzenia -jest mniejszy od 10000 milisekund (czyli 10 sekund). Jeżeli tak, *i to jest +Linia ``while running_time() < 10 000:`` sprawdza czy czas pracy urządzenia +jest mniejszy od 10 000 milisekund (czyli 10 sekund). Jeżeli tak, *i to jest miejsce gdzie możemy zobaczyć skalę działania*, to zostanie wyświetlony ``Image.ASLEEP``. Zauważ jak to jest wcięte poniżej instrukcji ``while`` *tak jak na naszej liście zadań*. -Oczywiście, jeśli czas pracy jest równy lub większy niż 10000 milisekund, +Oczywiście, jeśli czas pracy jest równy lub większy niż 10 000 milisekund, wówczas na ekranie pojawi się ``Image.SURPRISED``. Dlaczego? Ponieważ warunek -``while`` będzie fałszywy (ang. False) (``running_time`` nie jest już ``< 10000``). +``while`` (ang. dopóki) będzie fałszywy (ang. False) (``running_time`` nie jest już ``< 10000``). W takim przypadku pętla jest zakończona i program będzie kontynuowany po bloku kodu pętli ``while``. Wygląda na to, że twoje urządzenie śpi przez 10 sekund zanim obudzi się z zaskoczoną miną na swojej twarzy. @@ -139,7 +139,7 @@ Ogsługa zdarzenia +++++++++++++++++ Jeśli chcemy aby MicroPython reagował na zdarzenia naciśnięcia przycisku, to -powinniśmy umieścić go w nieskończonej pętli i sprawcać, czy przycisk +powinniśmy zdarzenie to umieścić w nieskończonej pętli i sprawdzać czy przycisk ``is_pressed``. Nieskończona pętla jest prosta:: @@ -151,7 +151,7 @@ Nieskończona pętla jest prosta:: bloku kodu. Ponieważ ``True`` jest oczywiście ``True`` przez czały czas, to otrzymujesz nieskończoną pętlę!) -Zróbmy bardzo prosty cyber-zwierzak. Jest on smutny, dopóki nie naciśniesz +Zróbmy bardzo prostego cyber-zwierzaka. Jest on smutny, dopóki nie naciśniesz przycisku ``A``. Ale jeżeli naciśniesz przycisk ``B`` on umrze. (Zdaję sobię sprawę, że to nie jest zbyt przyjemna gra, więc może masz pomysł jak ją ulepszyć.):: @@ -168,8 +168,9 @@ ulepszyć.):: display.clear() -Czy widzisz jak sprawdzamy, jakie przyciski są wciśnięte? Użyliśmy ``if``, -``elif`` (skrót od "else if") oraz ``else``. Są one nazywane *warunkami* i +Czy widzisz jak sprawdzamy jakie przyciski są wciśnięte? Użyliśmy ``if`` (ang. jeśli), +``elif`` (skrót od "else if") (ang. a jednak jeśli) oraz ``else`` (ang. inaczej). +Są one nazywane *warunkami* i działają tak:: if coś jest True: @@ -181,7 +182,7 @@ działają tak:: To jest podobne do języka angielskiego! -Metoda ``is_pressed`` generuje tylko dwa rezultaty: ``True`` albo ``False``. +Metoda ``is_pressed`` generuje jeden z dwóch wyników: ``True`` albo ``False``. Jeżeli naciśniesz przycisk, to zwróci ``True``, w przeciwnym wypadku zwróci ``False``. Powyższy kod można przetłumaczyć jako "jeżeli i tylko wtedy gdy przycisk A został naciśnięty, to pokaż szczęśliwą twarz, jeżeli przycisk B @@ -189,11 +190,11 @@ został naciśnięty, to przerwij pętlę, a w przeciwnym wypadku pokaż smutną minę." Przerywamy wykonywanie pętli (zatrzymujemy uruchomiony w nieskończoność program) za pomocą instrukcji ``braek``. -Na samym końcu, kiedy cyber-zwierzak nie żyje, wyczyśćmy ekran metodą +Na samym końcu, kiedy cyber-zwierzak nie żyje, czyścimy ekran metodą ``clear``. Czy możesz pomyśleć o sposobie, aby ta gra była mniej tragiczna? Jak chciałbyś -sprawdzić, czy przyciski *both* zostały naciśnięte? (Podpowiedź: Python ma +sprawdzić, czy *oba* przyciski zostały naciśnięte? (Podpowiedź: Python ma logiczne operatory ``and``, ``or`` i ``not``, które umożliwiają sprawdzenie wielu wyrażeń warunkowych (rzeczy, które generują rezultaty ``True`` albo ``False``). From 5c3049540c3aa8ef6623a3013d57eeaf71b865a6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Sun, 29 Oct 2017 23:37:02 +0100 Subject: [PATCH 13/24] one word chenged --- docs/tutorials/buttons.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorials/buttons.rst b/docs/tutorials/buttons.rst index a7876e2..cf7a857 100644 --- a/docs/tutorials/buttons.rst +++ b/docs/tutorials/buttons.rst @@ -33,7 +33,7 @@ pomysłów: *obiektu* za pomocą kropki. #. Istnieje obiekt nazwany ``button_a`` i on pozwala ci pobrać liczbę - określającą ilość naciśnięć za pomocą *metody* ``get_presses``. + określającą liczbę naciśnięć za pomocą *metody* ``get_presses``. *Metoda* ``get_presses`` daje nam tylko liczbę, a ``display.scroll`` przyjmuje tylko ciągi znaków. Dlatego musimy zmienić liczbę na ciąg znaków, co możemy From 9d2d5fac39366a41be9d55affe7d5af6fc4f53ba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Tue, 31 Oct 2017 15:18:29 +0100 Subject: [PATCH 14/24] =?UTF-8?q?changed;=20my=20propositions:=20else=20if?= =?UTF-8?q?=20->=20je=C5=9Bli=20jednak;=20else=20->=20w=20pozosta=C5=82ych?= =?UTF-8?q?=20przypadkach?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/tutorials/buttons.rst | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/docs/tutorials/buttons.rst b/docs/tutorials/buttons.rst index cf7a857..87cacd6 100644 --- a/docs/tutorials/buttons.rst +++ b/docs/tutorials/buttons.rst @@ -21,7 +21,7 @@ Jest to niezwykle proste: display.scroll(str(button_a.get_presses())) Cały skrypt jest uśpiony przez 10 000 milisekund (czyli 10 sekund) a po tym -czasie na wyświetlaczu przewinie się liczba ilości wciśnięć przycisku ``A``. +czasie na wyświetlaczu przewinie się liczba wciśnięć przycisku ``A``. To wszystko. Chociaż ten skrypt jest bezużyteczny, to jednak pokazuje name kilka ciekawych @@ -32,7 +32,7 @@ pomysłów: *Funkcja* jest podobna do *metody* ale nie jest przyporządkowana do *obiektu* za pomocą kropki. -#. Istnieje obiekt nazwany ``button_a`` i on pozwala ci pobrać liczbę +#. Istnieje obiekt nazwany ``button_a`` i on pozwala ci pobrać wartość określającą liczbę naciśnięć za pomocą *metody* ``get_presses``. *Metoda* ``get_presses`` daje nam tylko liczbę, a ``display.scroll`` przyjmuje @@ -72,7 +72,7 @@ Pętle zdarzeń Często potrzebujesz aby program poczekał na jakieś zdarzenie. Aby uzyskać to musisz zamknąć odpowiedni kawałek kodu w pętli, który będzie miał -zdefiniowane w jaki sposób zareagować na oczekiwane zdarzenie takie, jak +zdefiniowane w jaki sposób zareagować na oczekiwane zdarzenie takie jak naciśnięcie przycisku. Aby utworzyć pętle w Pythonie użyj słowa kluczowego ``while`` (ang. dopóki). To sprawdza czy @@ -169,7 +169,7 @@ ulepszyć.):: display.clear() Czy widzisz jak sprawdzamy jakie przyciski są wciśnięte? Użyliśmy ``if`` (ang. jeśli), -``elif`` (skrót od "else if") (ang. a jednak jeśli) oraz ``else`` (ang. inaczej). +``elif`` (skrót od "else if") (ang. jeśli jednak) oraz ``else`` (ang. w pozostałych przypadkach). Są one nazywane *warunkami* i działają tak:: @@ -188,7 +188,7 @@ Jeżeli naciśniesz przycisk, to zwróci ``True``, w przeciwnym wypadku zwróci przycisk A został naciśnięty, to pokaż szczęśliwą twarz, jeżeli przycisk B został naciśnięty, to przerwij pętlę, a w przeciwnym wypadku pokaż smutną minę." Przerywamy wykonywanie pętli (zatrzymujemy uruchomiony w nieskończoność -program) za pomocą instrukcji ``braek``. +program) za pomocą instrukcji ``break``. Na samym końcu, kiedy cyber-zwierzak nie żyje, czyścimy ekran metodą ``clear``. From ad10392353a04355d4b08c99191c5a61005b23ed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Thu, 9 Nov 2017 23:38:34 +0100 Subject: [PATCH 15/24] Translate buttons (#2) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * introduction for buttons * Translated 4 paragraphs of tutorial buttons * half translated buttons page * next part of page buttons.rst * last part of translation buttons.rst * Corrections * one word chenged * changed; my propositions: else if -> jeśli jednak; else -> w pozostałych przypadkach --- docs/tutorials/buttons.rst | 257 +++++++++++++++++++------------------ 1 file changed, 135 insertions(+), 122 deletions(-) diff --git a/docs/tutorials/buttons.rst b/docs/tutorials/buttons.rst index 51511ea..87cacd6 100644 --- a/docs/tutorials/buttons.rst +++ b/docs/tutorials/buttons.rst @@ -1,108 +1,115 @@ -Buttons +Przyciski ------- -So far we have created code that makes the device do something. This is called -*output*. However, we also need the device to react to things. Such things are -called *inputs*. +Jak dotychczas utworzyliśmy kod umożliwiający urządzeniu pokazywanie czegoś. +Nazywa się to *wyjście*. Musimy też jednak umożliwić urządzeniu reagowanie na +zdarzenia. Zdarzenia i wszystkie dane jakie dostaje urządzenie nazywamy *wejściem*. -It's easy to remember: output is what the device puts out to the world -whereas input is what goes into the device for it to process. +Łatwo zapamiętać: wyjście dotyczy wszystkiego co wychodzi z urządzenia, +natomiast wejście to wszystko co przychodzi do urządzenia w celu +przetworzenia. -The most obvious means of input on the micro:bit are its two buttons, labelled -``A`` and ``B``. Somehow, we need MicroPython to react to button presses. +Najprostszym sposobem na dostarczenie informacji na wejściu są dwa przyciski na urządzeniu micro:bit, +które oznaczone są jako ``A`` i ``B``. Potrzebujemy aby MicroPython jakoś +zareagował na naciśnięcie przycisku. -This is remarkably simple:: +Jest to niezwykle proste: from microbit import * sleep(10000) display.scroll(str(button_a.get_presses())) -All this script does is sleep for ten thousand milliseconds (i.e. 10 seconds) -and then scrolls the number of times you pressed button ``A``. That's it! +Cały skrypt jest uśpiony przez 10 000 milisekund (czyli 10 sekund) a po tym +czasie na wyświetlaczu przewinie się liczba wciśnięć przycisku ``A``. +To wszystko. -While it's a pretty useless script, it introduces a couple of interesting new -ideas: +Chociaż ten skrypt jest bezużyteczny, to jednak pokazuje name kilka ciekawych +pomysłów: -#. The ``sleep`` *function* will make the micro:bit sleep for a certain number - of milliseconds. If you want a pause in your program, this is how to do it. - A *function* is just like a *method*, but it isn't attached by a dot to an - *object*. -#. There is an object called ``button_a`` and it allows you to get the number - of times it has been pressed with the ``get_presses`` *method*. +#. *Funkcja* ``sleep`` usypia microbit na pewną ilość milisekund. Jeżeli + chcesz zatrzymać program, możesz to zrobić używając tej funkcji. + *Funkcja* jest podobna do *metody* ale nie jest przyporządkowana do + *obiektu* za pomocą kropki. -Since ``get_presses`` gives a numeric value and ``display.scroll`` only -displays characters, we need to convert the numeric value into a string of -characters. We do this with the ``str`` function (short for "string" ~ it -converts things into strings of characters). +#. Istnieje obiekt nazwany ``button_a`` i on pozwala ci pobrać wartość + określającą liczbę naciśnięć za pomocą *metody* ``get_presses``. -The third line is a bit like an onion. If the parenthesis are the -onion skins then you'll notice that ``display.scroll`` contains ``str`` that -itself contains ``button_a.get_presses``. Python attempts to work out the -inner-most answer first before starting on the next layer out. This is called -*nesting* - the coding equivalent of a Russian Matrioshka doll. +*Metoda* ``get_presses`` daje nam tylko liczbę, a ``display.scroll`` przyjmuje +tylko ciągi znaków. Dlatego musimy zmienić liczbę na ciąg znaków, co możemy +zrobić za pomocą funkcji ``str`` (skrót od angielskiego słowa +"string" ~ przetwarza wszystko na ciąg znaków). + +Trzeci wiersz jest jak cebula. Jeżeli przyjmiesz nawiasy za warstwy cebuli, to +zauważysz, że ``display.scroll`` zawiera ``str``, który zawiera +``button_a.get_presses``. Python próbuje rozpracować najbardziej wewnętrzne +wyrażenia najpierw, zanim przejdzie do następnej warstwy. To nazywa się +*zagnieżdżenie* - programistyczny odpowiednik rosyjskiej lalki - matrioszka. .. image:: matrioshka.jpg -Let's pretend you've pressed the button 10 times. Here's how Python works out -what's happening on the third line: +Przyjmijmy, że nacisnąłeś przycisk 10 razy. Python w następujący sposób +analizuje co się dzieje w trzeciej linii: -Python sees the complete line and gets the value of ``get_presses``:: +Python widzi pełną linię i dostaje wartość ``get_presses``:: display.scroll(str(button_a.get_presses())) -Now that Python knows how many button presses there have been, it converts the -numeric value into a string of characters:: +Teraz, gdy Python wie już ile razy został wciśnięty przycisk, to przetworzy +wartość liczbową na ciąg znaków:: display.scroll(str(10)) -Finally, Python knows what to scroll across the display:: +W końcu Python wie, że ma wyświetlić przesuwający się tekst na ekranie:: display.scroll("10") -While this might seem like a lot of work, MicroPython makes this happen -extraordinarily fast. +Może ci się wydawać, że to jest mnóstwo pracy ale MicroPython robi to +niezwykle szybko. -Event Loops +Pętle zdarzeń +++++++++++ -Often you need your program to hang around waiting for something to happen. To -do this you make it loop around a piece of code that defines how to react to -certain expected events such as a button press. - -To make loops in Python you use the ``while`` keyword. It checks if something -is ``True``. If it is, it runs a *block of code* called the *body* of the loop. -If it isn't, it breaks out of the loop (ignoring the body) and the rest of the -program can continue. - -Python makes it easy to define blocks of code. Say I have a to-do list written -on a piece of paper. It probably looks something like this:: - - Shopping - Fix broken gutter - Mow the lawn - -If I wanted to break down my to-do list a bit further, I might write something -like this:: - - Shopping: - Eggs - Bacon - Tomatoes - Fix broken gutter: - Borrow ladder from next door - Find hammer and nails - Return ladder - Mow the lawn: - Check lawn around pond for frogs - Check mower fuel level - -It's obvious that the main tasks are broken down into sub-tasks that are -*indented* underneath the main task to which they are related. So ``Eggs``, -``Bacon`` and ``Tomatoes`` are obviously related to ``Shopping``. By indenting -things we make it easy to see, at a glance, how the tasks relate to each other. - -This is called *nesting*. We use nesting to define blocks of code like this:: +Często potrzebujesz aby program poczekał na jakieś zdarzenie. Aby uzyskać +to musisz zamknąć odpowiedni kawałek kodu w pętli, który będzie miał +zdefiniowane w jaki sposób zareagować na oczekiwane zdarzenie takie jak +naciśnięcie przycisku. + +Aby utworzyć pętle w Pythonie użyj słowa kluczowego ``while`` (ang. dopóki). To sprawdza czy +coś jest ``True`` (ang. prawdziwe). Jeżeli tak jest, to uruchamia *blok kodu* zwany *zawartością* +pętli. Jeżeli jednak nie jest, to przerywa wykonywanie pętli (ignorując zawartość), +a wtedy wykona się pozostała część kodu. + +W Pythonie definiowanie bloków kodu jest proste. Powiedzmy, że mam listę rzeczy do +zrobienia napisaną na kartce papieru. Pewnie będzie wyglądało to tak:: + + Zakupy + Napraw uszkodzoną rynnę + Skoś trawnik + +Gdybym chciał nieco rozbić moją listę rzeczy do zrobienia, to mógłbym napisać +coś takiego:: + + Zakupy: + Jaja + Boczek + Pomidory + Napraw uszkodzoną rynnę: + Wyjmij drabinę z sąsiednich drzwi + Znajdź młotek i gwoździe + Zwróć drabinę + Skoś trawnik: + Sprawdź trawnik wokół sadzawki dla żab + Sprawdź poziom paliwa w kosiarce + +To oczywiste, że główne zadania są podzielone na podrzędne zadania, które +zaczynają się od *akapitu* (wcięcie) (ang. indent) poniżej głównego zadania, do którego +są powiązane. Tak więc ``Jaja``, ``Boczek`` i ``Pomidory`` są oczywiście +związane z zadaniem ``Zakupy``. Wcięcia ułatwiają nam sprawdzanie w jaki sposób +zadania są powiązane ze sobą. + +To nazywane jest *zagnieżdżeniem*. Używamy zagnieżdżeń do definiowania bloków +kodu takich jak:: from microbit import * @@ -111,41 +118,43 @@ This is called *nesting*. We use nesting to define blocks of code like this:: display.show(Image.SURPRISED) -The ``running_time`` function returns the number of milliseconds since the -device started. +Funkcja ``running_time`` zwraca liczbę milisekund od startu urządzenia. -The ``while running_time() < 10000:`` line checks if the running time is less -than 10000 milliseconds (i.e. 10 seconds). If it is, *and this is where we can -see scoping in action*, then it'll display ``Image.ASLEEP``. Notice how this is -indented underneath the ``while`` statement *just like in our to-do list*. +Linia ``while running_time() < 10 000:`` sprawdza czy czas pracy urządzenia +jest mniejszy od 10 000 milisekund (czyli 10 sekund). Jeżeli tak, *i to jest +miejsce gdzie możemy zobaczyć skalę działania*, to zostanie wyświetlony +``Image.ASLEEP``. Zauważ jak to jest wcięte poniżej instrukcji ``while`` +*tak jak na naszej liście zadań*. -Obviously, if the running time is equal to or greater than 10000 milliseconds -then the display will show ``Image.SURPRISED``. Why? Because the ``while`` -condition will be False (``running_time`` is no longer ``< 10000``). In that -case the loop is finished and the program will continue after the ``while`` -loop's block of code. It'll look like your device is asleep for 10 -seconds before waking up with a surprised look on its face. +Oczywiście, jeśli czas pracy jest równy lub większy niż 10 000 milisekund, +wówczas na ekranie pojawi się ``Image.SURPRISED``. Dlaczego? Ponieważ warunek +``while`` (ang. dopóki) będzie fałszywy (ang. False) (``running_time`` nie jest już ``< 10000``). +W takim przypadku pętla jest zakończona i program będzie kontynuowany po bloku +kodu pętli ``while``. Wygląda na to, że twoje urządzenie śpi przez 10 sekund +zanim obudzi się z zaskoczoną miną na swojej twarzy. -Try it! +Wypróbuj to! -Handling an Event +Ogsługa zdarzenia +++++++++++++++++ -If we want MicroPython to react to button press events we should put it into -an infinite loop and check if the button ``is_pressed``. +Jeśli chcemy aby MicroPython reagował na zdarzenia naciśnięcia przycisku, to +powinniśmy zdarzenie to umieścić w nieskończonej pętli i sprawdzać czy przycisk +``is_pressed``. -An infinite loop is easy:: +Nieskończona pętla jest prosta:: while True: - # Do stuff + # rób coś -(Remember, ``while`` checks if something is ``True`` to work out if it should -run its block of code. Since ``True`` is obviously ``True`` for all time, you -get an infinite loop!) +(Pamiętaj, że ``while`` sprawdza czy coś jest ``True`` przed każdym wykonaniem +bloku kodu. Ponieważ ``True`` jest oczywiście ``True`` przez czały czas, to +otrzymujesz nieskończoną pętlę!) -Let's make a very simple cyber-pet. It's always sad unless you're pressing -button ``A``. If you press button ``B`` it dies. (I realise this isn't a very -pleasant game, so perhaps you can figure out how to improve it.):: +Zróbmy bardzo prostego cyber-zwierzaka. Jest on smutny, dopóki nie naciśniesz +przycisku ``A``. Ale jeżeli naciśniesz przycisk ``B`` on umrze. (Zdaję sobię +sprawę, że to nie jest zbyt przyjemna gra, więc może masz pomysł jak ją +ulepszyć.):: from microbit import * @@ -159,31 +168,35 @@ pleasant game, so perhaps you can figure out how to improve it.):: display.clear() -Can you see how we check what buttons are pressed? We used ``if``, -``elif`` (short for "else if") and ``else``. These are called *conditionals* -and work like this:: +Czy widzisz jak sprawdzamy jakie przyciski są wciśnięte? Użyliśmy ``if`` (ang. jeśli), +``elif`` (skrót od "else if") (ang. jeśli jednak) oraz ``else`` (ang. w pozostałych przypadkach). +Są one nazywane *warunkami* i +działają tak:: - if something is True: - # do one thing - elif some other thing is True: - # do another thing + if coś jest True: + # zrób pierwszą rzecz + elif coś innego jest True: + # zrób następną rzecz else: - # do yet another thing. - -This is remarkably similar to English! - -The ``is_pressed`` method only produces two results: ``True`` or ``False``. -If you're pressing the button it returns ``True``, otherwise it returns -``False``. The code above is saying, in English, "for ever and ever, if -button A is pressed then show a happy face, else if button B is pressed break -out of the loop, otherwise display a sad face." We break out of the loop (stop -the program running for ever and ever) with the ``break`` statement. - -At the very end, when the cyber-pet is dead, we ``clear`` the display. - -Can you think of ways to make this game less tragic? How would you check if -*both* buttons are pressed? (Hint: Python has ``and``, ``or`` and ``not`` -logical operators to help check multiple truth statements (things that -produce either ``True`` or ``False`` results). + # zrób jeszcze coś. + +To jest podobne do języka angielskiego! + +Metoda ``is_pressed`` generuje jeden z dwóch wyników: ``True`` albo ``False``. +Jeżeli naciśniesz przycisk, to zwróci ``True``, w przeciwnym wypadku zwróci +``False``. Powyższy kod można przetłumaczyć jako "jeżeli i tylko wtedy gdy +przycisk A został naciśnięty, to pokaż szczęśliwą twarz, jeżeli przycisk B +został naciśnięty, to przerwij pętlę, a w przeciwnym wypadku pokaż smutną +minę." Przerywamy wykonywanie pętli (zatrzymujemy uruchomiony w nieskończoność +program) za pomocą instrukcji ``break``. + +Na samym końcu, kiedy cyber-zwierzak nie żyje, czyścimy ekran metodą +``clear``. + +Czy możesz pomyśleć o sposobie, aby ta gra była mniej tragiczna? Jak chciałbyś +sprawdzić, czy *oba* przyciski zostały naciśnięte? (Podpowiedź: Python ma +logiczne operatory ``and``, ``or`` i ``not``, które umożliwiają sprawdzenie +wielu wyrażeń warunkowych (rzeczy, które generują rezultaty ``True`` albo +``False``). .. footer:: The image of Matrioshka dolls is licensed CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=69402 From 7c30d32ab3a0a586da75f26f47086b8c88607dcb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Wed, 29 Nov 2017 20:02:59 +0100 Subject: [PATCH 16/24] Poprawki od Radomira --- docs/tutorials/buttons.rst | 122 +++++++++++++++++++------------------ 1 file changed, 63 insertions(+), 59 deletions(-) diff --git a/docs/tutorials/buttons.rst b/docs/tutorials/buttons.rst index 87cacd6..7c41efc 100644 --- a/docs/tutorials/buttons.rst +++ b/docs/tutorials/buttons.rst @@ -1,17 +1,17 @@ Przyciski ------- -Jak dotychczas utworzyliśmy kod umożliwiający urządzeniu pokazywanie czegoś. -Nazywa się to *wyjście*. Musimy też jednak umożliwić urządzeniu reagowanie na -zdarzenia. Zdarzenia i wszystkie dane jakie dostaje urządzenie nazywamy *wejściem*. +Jak dotychczas utworzyliśmy kod umożliwiający urządzeniu robienie czegoś. +Nazywa się to *wyjście*. Musimy też jednak umożliwić urządzeniu reagowanie. +To, na co ono reaguje nazywamy *wejściem*. Łatwo zapamiętać: wyjście dotyczy wszystkiego co wychodzi z urządzenia, natomiast wejście to wszystko co przychodzi do urządzenia w celu przetworzenia. -Najprostszym sposobem na dostarczenie informacji na wejściu są dwa przyciski na urządzeniu micro:bit, -które oznaczone są jako ``A`` i ``B``. Potrzebujemy aby MicroPython jakoś -zareagował na naciśnięcie przycisku. +Najłatwiejszą metodą dostarczenia *wejścia* są dwa przyciski, oznaczone +``A`` i ``B``. Musimy jakoś zmusić MicroPython do reagowania na ich +naciśnięcie. Jest to niezwykle proste: @@ -20,20 +20,20 @@ Jest to niezwykle proste: sleep(10000) display.scroll(str(button_a.get_presses())) -Cały skrypt jest uśpiony przez 10 000 milisekund (czyli 10 sekund) a po tym +Ten skrypt śpi przez 10 000 milisekund (czyli 10 sekund), a po tym czasie na wyświetlaczu przewinie się liczba wciśnięć przycisku ``A``. To wszystko. Chociaż ten skrypt jest bezużyteczny, to jednak pokazuje name kilka ciekawych -pomysłów: +koncepcji: -#. *Funkcja* ``sleep`` usypia microbit na pewną ilość milisekund. Jeżeli +#. *Funkcja* ``sleep`` usypia microbit na pewną liczbę milisekund. Jeżeli chcesz zatrzymać program, możesz to zrobić używając tej funkcji. - *Funkcja* jest podobna do *metody* ale nie jest przyporządkowana do + *Funkcja* jest podobna do *metody* ale nie jest przyporządkowana do *obiektu* za pomocą kropki. -#. Istnieje obiekt nazwany ``button_a`` i on pozwala ci pobrać wartość - określającą liczbę naciśnięć za pomocą *metody* ``get_presses``. +#. Obiekt ``button_a`` pozwala ci pobrać liczbę naciśnięć przycisku za pomocą + *metody* ``get_presses``. *Metoda* ``get_presses`` daje nam tylko liczbę, a ``display.scroll`` przyjmuje tylko ciągi znaków. Dlatego musimy zmienić liczbę na ciąg znaków, co możemy @@ -41,10 +41,10 @@ zrobić za pomocą funkcji ``str`` (skrót od angielskiego słowa "string" ~ przetwarza wszystko na ciąg znaków). Trzeci wiersz jest jak cebula. Jeżeli przyjmiesz nawiasy za warstwy cebuli, to -zauważysz, że ``display.scroll`` zawiera ``str``, który zawiera +zauważysz, że ``display.scroll`` zawiera ``str``, który zawiera ``button_a.get_presses``. Python próbuje rozpracować najbardziej wewnętrzne wyrażenia najpierw, zanim przejdzie do następnej warstwy. To nazywa się -*zagnieżdżenie* - programistyczny odpowiednik rosyjskiej lalki - matrioszka. +*zagnieżdżenie* - programistyczny odpowiednik rosyjskiej matrioszki. .. image:: matrioshka.jpg @@ -55,33 +55,37 @@ Python widzi pełną linię i dostaje wartość ``get_presses``:: display.scroll(str(button_a.get_presses())) -Teraz, gdy Python wie już ile razy został wciśnięty przycisk, to przetworzy +Teraz, gdy Python wie już ile razy został wciśnięty przycisk, skonwertuje wartość liczbową na ciąg znaków:: display.scroll(str(10)) -W końcu Python wie, że ma wyświetlić przesuwający się tekst na ekranie:: +W końcu Python wie, co ma wyświetlić na ekranie:: display.scroll("10") -Może ci się wydawać, że to jest mnóstwo pracy ale MicroPython robi to +Może ci się wydawać, że to jest mnóstwo pracy, ale MicroPython robi to niezwykle szybko. Pętle zdarzeń +++++++++++ -Często potrzebujesz aby program poczekał na jakieś zdarzenie. Aby uzyskać +Często chcesz aby program poczekał na jakieś zdarzenie. Żeby to uzyskać, musisz +zamknąć w pętli kawałek kodu definiujący jak reagować na oczekiwane zdarzenia, +takie jak naciśnięcie przycisku. + +Aby uzyskać to musisz zamknąć odpowiedni kawałek kodu w pętli, który będzie miał zdefiniowane w jaki sposób zareagować na oczekiwane zdarzenie takie jak naciśnięcie przycisku. -Aby utworzyć pętle w Pythonie użyj słowa kluczowego ``while`` (ang. dopóki). To sprawdza czy -coś jest ``True`` (ang. prawdziwe). Jeżeli tak jest, to uruchamia *blok kodu* zwany *zawartością* -pętli. Jeżeli jednak nie jest, to przerywa wykonywanie pętli (ignorując zawartość), -a wtedy wykona się pozostała część kodu. +Pętle w Pythonie tworzymy przy użyciu polecania ``while`` (ang. dopóki). Sprawdza ono czy +coś jest ``True`` (ang. prawdziwe). Jeżeli tak jest, to uruchamia *blok kodu* zwany *ciałem* +pętli. Jeżeli jednak nie jest, to przerywa wykonywanie pętli (ignorując ciało pętli) +i przechodzi do dalszej części kodu. W Pythonie definiowanie bloków kodu jest proste. Powiedzmy, że mam listę rzeczy do -zrobienia napisaną na kartce papieru. Pewnie będzie wyglądało to tak:: +zrobienia napisaną na kartce papieru. Może to wyglądać tak:: Zakupy Napraw uszkodzoną rynnę @@ -95,21 +99,21 @@ coś takiego:: Boczek Pomidory Napraw uszkodzoną rynnę: - Wyjmij drabinę z sąsiednich drzwi + Pożycz drabinę od sąsiada Znajdź młotek i gwoździe Zwróć drabinę Skoś trawnik: Sprawdź trawnik wokół sadzawki dla żab Sprawdź poziom paliwa w kosiarce -To oczywiste, że główne zadania są podzielone na podrzędne zadania, które -zaczynają się od *akapitu* (wcięcie) (ang. indent) poniżej głównego zadania, do którego -są powiązane. Tak więc ``Jaja``, ``Boczek`` i ``Pomidory`` są oczywiście +Oczywiście główne zadania są podzielone na podrzędne zadania, umieszczone +poniżej głównego zadania, z którym są powiązane i *wcięte*. +Tak więc ``Jaja``, ``Boczek`` i ``Pomidory`` są na pierwszy rzut oka związane z zadaniem ``Zakupy``. Wcięcia ułatwiają nam sprawdzanie w jaki sposób zadania są powiązane ze sobą. -To nazywane jest *zagnieżdżeniem*. Używamy zagnieżdżeń do definiowania bloków -kodu takich jak:: +Nazywamy to *zagnieżdżeniem*. Zagnieżdżania używamy do definiowania bloków kodu +w ten oto sposób:: from microbit import * @@ -120,27 +124,27 @@ kodu takich jak:: Funkcja ``running_time`` zwraca liczbę milisekund od startu urządzenia. -Linia ``while running_time() < 10 000:`` sprawdza czy czas pracy urządzenia -jest mniejszy od 10 000 milisekund (czyli 10 sekund). Jeżeli tak, *i to jest -miejsce gdzie możemy zobaczyć skalę działania*, to zostanie wyświetlony -``Image.ASLEEP``. Zauważ jak to jest wcięte poniżej instrukcji ``while`` -*tak jak na naszej liście zadań*. +Linia ``while running_time() < 10000:`` sprawdza czy czas pracy urządzenia +jest mniejszy od 10 000 milisekund (czyli 10 sekund). Jeżeli tak, *i tu widzimy +działanie zagnieżdżania*, to zostanie wyświetlony +``Image.ASLEEP``. Zwróć uwagę na wcięcie kodu po poleceniu ``while`` +*takie jak w naszej liście zadań*. Oczywiście, jeśli czas pracy jest równy lub większy niż 10 000 milisekund, wówczas na ekranie pojawi się ``Image.SURPRISED``. Dlaczego? Ponieważ warunek ``while`` (ang. dopóki) będzie fałszywy (ang. False) (``running_time`` nie jest już ``< 10000``). W takim przypadku pętla jest zakończona i program będzie kontynuowany po bloku -kodu pętli ``while``. Wygląda na to, że twoje urządzenie śpi przez 10 sekund -zanim obudzi się z zaskoczoną miną na swojej twarzy. +kodu pętli ``while``. Będzie to sprawiać wrażenie, że twoje urządzenie śpi przez 10 sekund +zanim obudzi się z zaskoczeniem na twarzy. -Wypróbuj to! +Spróbuj sam! -Ogsługa zdarzenia +Obsługa zdarzenia +++++++++++++++++ -Jeśli chcemy aby MicroPython reagował na zdarzenia naciśnięcia przycisku, to -powinniśmy zdarzenie to umieścić w nieskończonej pętli i sprawdzać czy przycisk -``is_pressed``. +Jeśli chcemy aby MicroPython reagował na zdarzenia naciśnięcia przycisku, +musimy wprowadzić go w nieskończoną pętlę i sprawdzać w niej czy przycisk jest +wciśnięty (ang. ``is_pressed``). Nieskończona pętla jest prosta:: @@ -151,8 +155,8 @@ Nieskończona pętla jest prosta:: bloku kodu. Ponieważ ``True`` jest oczywiście ``True`` przez czały czas, to otrzymujesz nieskończoną pętlę!) -Zróbmy bardzo prostego cyber-zwierzaka. Jest on smutny, dopóki nie naciśniesz -przycisku ``A``. Ale jeżeli naciśniesz przycisk ``B`` on umrze. (Zdaję sobię +Zróbmy bardzo proste elektroniczne zwierzątko. Jest on smutny, gdy nie naciskasz +przycisku ``A``. A gdy wciśniesz przycisk ``B`` umiera. (Zdaję sobię sprawę, że to nie jest zbyt przyjemna gra, więc może masz pomysł jak ją ulepszyć.):: @@ -168,7 +172,7 @@ ulepszyć.):: display.clear() -Czy widzisz jak sprawdzamy jakie przyciski są wciśnięte? Użyliśmy ``if`` (ang. jeśli), +Rozumiesz jak sprawdzić, które przyciski są wciśnięte? Użyliśmy ``if`` (ang. jeśli), ``elif`` (skrót od "else if") (ang. jeśli jednak) oraz ``else`` (ang. w pozostałych przypadkach). Są one nazywane *warunkami* i działają tak:: @@ -180,23 +184,23 @@ działają tak:: else: # zrób jeszcze coś. -To jest podobne do języka angielskiego! +Prawie jak po polsku! Metoda ``is_pressed`` generuje jeden z dwóch wyników: ``True`` albo ``False``. -Jeżeli naciśniesz przycisk, to zwróci ``True``, w przeciwnym wypadku zwróci -``False``. Powyższy kod można przetłumaczyć jako "jeżeli i tylko wtedy gdy -przycisk A został naciśnięty, to pokaż szczęśliwą twarz, jeżeli przycisk B -został naciśnięty, to przerwij pętlę, a w przeciwnym wypadku pokaż smutną -minę." Przerywamy wykonywanie pętli (zatrzymujemy uruchomiony w nieskończoność -program) za pomocą instrukcji ``break``. - -Na samym końcu, kiedy cyber-zwierzak nie żyje, czyścimy ekran metodą -``clear``. - -Czy możesz pomyśleć o sposobie, aby ta gra była mniej tragiczna? Jak chciałbyś -sprawdzić, czy *oba* przyciski zostały naciśnięte? (Podpowiedź: Python ma -logiczne operatory ``and``, ``or`` i ``not``, które umożliwiają sprawdzenie -wielu wyrażeń warunkowych (rzeczy, które generują rezultaty ``True`` albo +Jeżeli przycisk jest wciśnięty, zwraca ``True``, w przeciwnym wypadku zwróci +``False``. Powyższy kod można przetłumaczyć jako "przez cały czas: jeśli +przycisk A jest wciśnięty - pokazuj szczęśliwą twarz, jeśli jednak przycisk +B jest wciśnięty - przerwij pętlę, a w pozostałych przypadkach pokaż smutną +minę". Przerywamy pętlę (zatrzymując działający przez cały czas program) za +pomocą instrukcji ``break``. + +Na samym końcu, kiedy elektroniczne zwierzątko nie żyje, czyścimy +(ang. ``clear``) ekran. + +Wiesz jak uczynić tę grę mniej tragiczną? Jak sprawdziłabyś, czy *oba* +przyciski są wciśnięte? (Podpowiedź: Python ma operatory logiczne "i" (ang. +``and``), "lub" (ang. ``or``) oraz "nie" (ang .``not``), którymi można +sprawdzić wiele warunków (wyrażeń, które mają wartość ``True`` lub ``False``). .. footer:: The image of Matrioshka dolls is licensed CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=69402 From 931e0240dfc338b7f947bda65956e371b2839bdb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Thu, 30 Nov 2017 15:39:41 +0100 Subject: [PATCH 17/24] =?UTF-8?q?Kolejne=20poprawki=20od=20Radomira=20+=20?= =?UTF-8?q?korekta=20liter=C3=B3wek?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/tutorials/buttons.rst | 23 +++++++++-------------- 1 file changed, 9 insertions(+), 14 deletions(-) diff --git a/docs/tutorials/buttons.rst b/docs/tutorials/buttons.rst index 7c41efc..0e80c33 100644 --- a/docs/tutorials/buttons.rst +++ b/docs/tutorials/buttons.rst @@ -24,7 +24,7 @@ Ten skrypt śpi przez 10 000 milisekund (czyli 10 sekund), a po tym czasie na wyświetlaczu przewinie się liczba wciśnięć przycisku ``A``. To wszystko. -Chociaż ten skrypt jest bezużyteczny, to jednak pokazuje name kilka ciekawych +Chociaż ten skrypt jest bezużyteczny, to jednak pokazuje nam kilka ciekawych koncepcji: #. *Funkcja* ``sleep`` usypia microbit na pewną liczbę milisekund. Jeżeli @@ -38,7 +38,7 @@ koncepcji: *Metoda* ``get_presses`` daje nam tylko liczbę, a ``display.scroll`` przyjmuje tylko ciągi znaków. Dlatego musimy zmienić liczbę na ciąg znaków, co możemy zrobić za pomocą funkcji ``str`` (skrót od angielskiego słowa -"string" ~ przetwarza wszystko na ciąg znaków). +"string"), która przetwarza wszystko na ciąg znaków. Trzeci wiersz jest jak cebula. Jeżeli przyjmiesz nawiasy za warstwy cebuli, to zauważysz, że ``display.scroll`` zawiera ``str``, który zawiera @@ -70,14 +70,9 @@ niezwykle szybko. Pętle zdarzeń +++++++++++ -Często chcesz aby program poczekał na jakieś zdarzenie. Żeby to uzyskać, musisz -zamknąć w pętli kawałek kodu definiujący jak reagować na oczekiwane zdarzenia, -takie jak naciśnięcie przycisku. - -Aby uzyskać -to musisz zamknąć odpowiedni kawałek kodu w pętli, który będzie miał -zdefiniowane w jaki sposób zareagować na oczekiwane zdarzenie takie jak -naciśnięcie przycisku. +Często chcesz aby program poczekał na jakieś zdarzenie. Aby uzyskać to musisz +zamknąć odpowiedni kawałek kodu w pętli, który będzie miał zdefiniowane w jaki +sposób zareagować na oczekiwane zdarzenie takie jak naciśnięcie przycisku. Pętle w Pythonie tworzymy przy użyciu polecania ``while`` (ang. dopóki). Sprawdza ono czy coś jest ``True`` (ang. prawdziwe). Jeżeli tak jest, to uruchamia *blok kodu* zwany *ciałem* @@ -152,11 +147,11 @@ Nieskończona pętla jest prosta:: # rób coś (Pamiętaj, że ``while`` sprawdza czy coś jest ``True`` przed każdym wykonaniem -bloku kodu. Ponieważ ``True`` jest oczywiście ``True`` przez czały czas, to +bloku kodu. Ponieważ ``True`` jest oczywiście ``True`` przez cały czas, to otrzymujesz nieskończoną pętlę!) -Zróbmy bardzo proste elektroniczne zwierzątko. Jest on smutny, gdy nie naciskasz -przycisku ``A``. A gdy wciśniesz przycisk ``B`` umiera. (Zdaję sobię +Zróbmy bardzo proste elektroniczne zwierzątko. Jest ono smutne, gdy nie naciskasz +przycisku ``A``. A gdy wciśniesz przycisk ``B`` umiera. (Zdaję sobie sprawę, że to nie jest zbyt przyjemna gra, więc może masz pomysł jak ją ulepszyć.):: @@ -192,7 +187,7 @@ Jeżeli przycisk jest wciśnięty, zwraca ``True``, w przeciwnym wypadku zwróci przycisk A jest wciśnięty - pokazuj szczęśliwą twarz, jeśli jednak przycisk B jest wciśnięty - przerwij pętlę, a w pozostałych przypadkach pokaż smutną minę". Przerywamy pętlę (zatrzymując działający przez cały czas program) za -pomocą instrukcji ``break``. +pomocą instrukcji ``break`` (ang. przerwij). Na samym końcu, kiedy elektroniczne zwierzątko nie żyje, czyścimy (ang. ``clear``) ekran. From 31e7e1c2c2b4ba8b826f4aff05cdb9cf1f0a94f2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Thu, 30 Nov 2017 16:30:10 +0100 Subject: [PATCH 18/24] =?UTF-8?q?Przywr=C3=B3cona=20w=C5=82a=C5=9Bciwa=20w?= =?UTF-8?q?ersja=20akapitu?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/tutorials/buttons.rst | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/tutorials/buttons.rst b/docs/tutorials/buttons.rst index 0e80c33..67d38a5 100644 --- a/docs/tutorials/buttons.rst +++ b/docs/tutorials/buttons.rst @@ -70,9 +70,9 @@ niezwykle szybko. Pętle zdarzeń +++++++++++ -Często chcesz aby program poczekał na jakieś zdarzenie. Aby uzyskać to musisz -zamknąć odpowiedni kawałek kodu w pętli, który będzie miał zdefiniowane w jaki -sposób zareagować na oczekiwane zdarzenie takie jak naciśnięcie przycisku. +Często chcesz aby program poczekał na jakieś zdarzenie. Żeby to uzyskać, musisz +zamknąć w pętli kawałek kodu definiujący jak reagować na oczekiwane zdarzenia, +takie jak naciśnięcie przycisku. Pętle w Pythonie tworzymy przy użyciu polecania ``while`` (ang. dopóki). Sprawdza ono czy coś jest ``True`` (ang. prawdziwe). Jeżeli tak jest, to uruchamia *blok kodu* zwany *ciałem* From fce2ece277b2fbb69be3aec7ee2bce90080aeac4 Mon Sep 17 00:00:00 2001 From: Lukasz P Date: Tue, 16 Jan 2018 19:44:18 +0100 Subject: [PATCH 19/24] tlumaczenie tutoriala modulu Random --- docs/tutorials/random.rst | 97 +++++++++++++++++++-------------------- 1 file changed, 48 insertions(+), 49 deletions(-) diff --git a/docs/tutorials/random.rst b/docs/tutorials/random.rst index 57d8922..a09309c 100644 --- a/docs/tutorials/random.rst +++ b/docs/tutorials/random.rst @@ -1,12 +1,11 @@ -Random +Losowość ------ -Sometimes you want to leave things to chance, or mix it up a little: you want -the device to act randomly. +Czasem chcesz pozostawić rzeczy szczęściu, lub odrobinę je pomieszać. Słowem: chcesz, +by udządzenie działało losowo. -MicroPython comes with a ``random`` module to make it easy to introduce chance -and a little chaos into your code. For example, here's how to scroll a random -name across the display:: +MicroPython zawiera moduł ``random``, wprowadzający element losowy oraz odrobinę +chaosu do twojego kodu. Oto przykładowy kod przewijający na wyświetlaczu losowe imię:: from microbit import * import random @@ -15,46 +14,45 @@ name across the display:: display.scroll(random.choice(names)) -The list (``names``) contains seven names defined as strings of characters. -The final line is *nested* (the "onion" effect introduced earlier): the -``random.choice`` method takes the ``names`` list as an argument and returns -an item chosen at random. This item (the randomly chosen name) is the argument -for ``display.scroll``. +Lista (``names``) zawiera siedem imion zdefiniowanych jako łańcuchy znaków. +Ostatnia linia jest *zagnieżdżona* (the "onion" effect introduced eariler): +metoda ``random.choice`` przyjmuje jako argument listę ``names`` oraz zwraca +jej losowy element. Element ten (lowoso wybrane imię) jest agrumentem dla +``display.scroll``. -Can you modify the list to include your own set of names? +Czy możesz zmodyfikować listę tak, by zawierała wybrane przez ciebie imiona? -Random Numbers +Losowe Liczby ++++++++++++++ -Random numbers are very useful. They're common in games. Why else do we have -dice? +Losowe liczby są bardzo użyteczne. Często używane są w grach. Po cóż innego +mamy kostki? -MicroPython comes with several useful random number methods. Here's how to -make a simple dice:: +MicroPython zawiera wiele użtecznych metod powiązanych z losowymi liczbami. +Oto przykład prostej kości do gry:: from microbit import * import random display.show(str(random.randint(1, 6))) -Every time the device is reset it displays a number between 1 and 6. You're -starting to get familiar with *nesting*, so it's important to note that -``random.randint`` returns a whole number between the two arguments, inclusive -(a whole number is also called an integer - hence the name of the method). -Notice that because ``display.show`` expects a character then we use the -``str`` function to turn the numeric value into a character (we turn, for -example, ``6`` into ``"6"``). - -If you know you'll always want a number between ``0`` and ``N`` then use the -``random.randrange`` method. If you give it a single argument it'll return -random integers up to, but not including, the value of the argument ``N`` -(this is different to the behaviour of ``random.randint``). - -Sometimes you need numbers with a decimal point in them. These are called -*floating point* numbers and it's possible to generate such a number with the -``random.random`` method. This only returns values between ``0.0`` and ``1.0`` -inclusive. If you need larger random floating point numbers add the results -of ``random.randrange`` and ``random.random`` like this:: +Po każdym restarcie urządzenia wyświetla ono numer z zakresu 1-6. Zaczynasz +zapoznawać się z *zagnieżdżaniem*. Warto więc tylko zauważyć, że ``random.randint`` +zwraca liczbę całkowitą z przedziału domkniętego pomiędzy dwoma argumentami +(liczba całkowita nazywana jest integer, stąd nazwa metody). Zauważ, że skoro +``display.show`` oczekuje znaku alfabetycznego, używamy funkcji ``str`` do zamiany +numeru na znak (na przykład: ``6`` w ``"6"``). + +W wypadku, gdy zawsze potrzebujesz liczny z przedziału pomiędzy ``0`` a ``N``, +używaj metody ``random.randrange``. Gdy podasz jej pojedynczy argument, zwróci +losową liczbę całkowitą z przedziału zamkniętego od ``0`` do ``N`` (w +przeciwieństwie do funkcji ``random.randint``). + +Czasami potrzebujesz liczby z miejscem po przecinku. Nazywamy je liczbami +*zmiennoprzecinkowymi* i można je uzyskać używając metody ``random.radom``. +Zwraca ona wartość z przedziału domkniętego od ``0.0`` do ``1.0``. Jeżeli +potrzebujesz dużej liczby zmiennoprzecinkowej dodaj ``random.randrange`` do +``random.random``, jak poniżej:: from microbit import * import random @@ -62,22 +60,23 @@ of ``random.randrange`` and ``random.random`` like this:: answer = random.randrange(100) + random.random() display.scroll(str(answer)) -Seeds of Chaos +Pula Chaosu ++++++++++++++ -The random number generators used by computers are not truly random. They just -give random like results given a starting *seed* value. The seed is often -generated from random-ish values such as the current time and/or readings from -sensors such as the thermometers built into chips. +Losowe liczby generowane przez komputery nie są naprawdę losowe. Zwracają +jedynie pseudolosowe rezultaty zaczynając od wartości początkowej. Wartość +początkowa generowana jest na podstawie pseudolosowej wartości, takiej jak +obecna godzina i/lub odczyty z sensorów sprzętowych. + +Czasem chcesz osiągnąć powtarzalne, pseudolosowe zachowanie: odtwarzalne +źródło losowości. To jakby oczekiwać tych samych, losowych wyników pięciu +kolejnych rzutów kością. -Sometimes you want to have repeatable random-ish behaviour: a source of -randomness that is reproducible. It's like saying that you need the same five -random values each time you throw a dice. +Można to łatwo osiągnąć ustalając z góry wartość źródłową. Dla danej wartości +źródłowej generator liczb losowych będzie tworzył tę samą pulę liczb losowych. +Źródło jest ustawiane poprzez ``random.seed`` jako dowolna liczba całkowita. +Poniższa wersja programu do rzutu kością poda zawsze ten sam rezultat:: -This is easy to achieve by setting the *seed* value. Given a known seed the -random number generator will create the same set of random numbers. The seed is -set with ``random.seed`` and any whole number (integer). This version of the -dice program always produces the same results:: from microbit import * import random @@ -87,5 +86,5 @@ dice program always produces the same results:: if button_a.was_pressed(): display.show(str(random.randint(1, 6))) -Can you work out why this program needs us to press button A instead of reset -the device as in the first dice example..? +Czy dostrzegasz, czemu powyższy program oczekuje wciśnięcia klawisza A, w +przeciwieństwie do restartu urządzenia z poprzedniego przykładu..? From 8edcf79592719329ca981e5e02fe18c77328e389 Mon Sep 17 00:00:00 2001 From: Robo34 Date: Tue, 6 Feb 2018 20:01:13 +0100 Subject: [PATCH 20/24] Update next.rst MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Zaczynam tłumaczyć następne kroki next.rst sign Robo34 --- docs/tutorials/next.rst | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/tutorials/next.rst b/docs/tutorials/next.rst index ca606a3..eb41cec 100644 --- a/docs/tutorials/next.rst +++ b/docs/tutorials/next.rst @@ -1,10 +1,14 @@ Next Steps +Następne Kroki ---------- These tutorials are only the first steps in using MicroPython with the BBC micro:bit. A musical analogy: you've got a basic understanding of a very simple instrument and confidently play "Three Blind Mice". +Te tutoriale są tylko pierwszymi krokami w używaniu MicroPython-a z BBC micro + + This is an achievement to build upon. Ahead of you is an exciting journey to becoming a virtuoso coder. From cadb35da7216acc72d5a9136ff450ee2ebdc2975 Mon Sep 17 00:00:00 2001 From: Lukasz P Date: Tue, 6 Feb 2018 20:16:14 +0100 Subject: [PATCH 21/24] Revert "tlumaczenie tutoriala modulu Random" This reverts commit fce2ece277b2fbb69be3aec7ee2bce90080aeac4. --- docs/tutorials/random.rst | 97 ++++++++++++++++++++------------------- 1 file changed, 49 insertions(+), 48 deletions(-) diff --git a/docs/tutorials/random.rst b/docs/tutorials/random.rst index a09309c..57d8922 100644 --- a/docs/tutorials/random.rst +++ b/docs/tutorials/random.rst @@ -1,11 +1,12 @@ -Losowość +Random ------ -Czasem chcesz pozostawić rzeczy szczęściu, lub odrobinę je pomieszać. Słowem: chcesz, -by udządzenie działało losowo. +Sometimes you want to leave things to chance, or mix it up a little: you want +the device to act randomly. -MicroPython zawiera moduł ``random``, wprowadzający element losowy oraz odrobinę -chaosu do twojego kodu. Oto przykładowy kod przewijający na wyświetlaczu losowe imię:: +MicroPython comes with a ``random`` module to make it easy to introduce chance +and a little chaos into your code. For example, here's how to scroll a random +name across the display:: from microbit import * import random @@ -14,45 +15,46 @@ chaosu do twojego kodu. Oto przykładowy kod przewijający na wyświetlaczu loso display.scroll(random.choice(names)) -Lista (``names``) zawiera siedem imion zdefiniowanych jako łańcuchy znaków. -Ostatnia linia jest *zagnieżdżona* (the "onion" effect introduced eariler): -metoda ``random.choice`` przyjmuje jako argument listę ``names`` oraz zwraca -jej losowy element. Element ten (lowoso wybrane imię) jest agrumentem dla -``display.scroll``. +The list (``names``) contains seven names defined as strings of characters. +The final line is *nested* (the "onion" effect introduced earlier): the +``random.choice`` method takes the ``names`` list as an argument and returns +an item chosen at random. This item (the randomly chosen name) is the argument +for ``display.scroll``. -Czy możesz zmodyfikować listę tak, by zawierała wybrane przez ciebie imiona? +Can you modify the list to include your own set of names? -Losowe Liczby +Random Numbers ++++++++++++++ -Losowe liczby są bardzo użyteczne. Często używane są w grach. Po cóż innego -mamy kostki? +Random numbers are very useful. They're common in games. Why else do we have +dice? -MicroPython zawiera wiele użtecznych metod powiązanych z losowymi liczbami. -Oto przykład prostej kości do gry:: +MicroPython comes with several useful random number methods. Here's how to +make a simple dice:: from microbit import * import random display.show(str(random.randint(1, 6))) -Po każdym restarcie urządzenia wyświetla ono numer z zakresu 1-6. Zaczynasz -zapoznawać się z *zagnieżdżaniem*. Warto więc tylko zauważyć, że ``random.randint`` -zwraca liczbę całkowitą z przedziału domkniętego pomiędzy dwoma argumentami -(liczba całkowita nazywana jest integer, stąd nazwa metody). Zauważ, że skoro -``display.show`` oczekuje znaku alfabetycznego, używamy funkcji ``str`` do zamiany -numeru na znak (na przykład: ``6`` w ``"6"``). - -W wypadku, gdy zawsze potrzebujesz liczny z przedziału pomiędzy ``0`` a ``N``, -używaj metody ``random.randrange``. Gdy podasz jej pojedynczy argument, zwróci -losową liczbę całkowitą z przedziału zamkniętego od ``0`` do ``N`` (w -przeciwieństwie do funkcji ``random.randint``). - -Czasami potrzebujesz liczby z miejscem po przecinku. Nazywamy je liczbami -*zmiennoprzecinkowymi* i można je uzyskać używając metody ``random.radom``. -Zwraca ona wartość z przedziału domkniętego od ``0.0`` do ``1.0``. Jeżeli -potrzebujesz dużej liczby zmiennoprzecinkowej dodaj ``random.randrange`` do -``random.random``, jak poniżej:: +Every time the device is reset it displays a number between 1 and 6. You're +starting to get familiar with *nesting*, so it's important to note that +``random.randint`` returns a whole number between the two arguments, inclusive +(a whole number is also called an integer - hence the name of the method). +Notice that because ``display.show`` expects a character then we use the +``str`` function to turn the numeric value into a character (we turn, for +example, ``6`` into ``"6"``). + +If you know you'll always want a number between ``0`` and ``N`` then use the +``random.randrange`` method. If you give it a single argument it'll return +random integers up to, but not including, the value of the argument ``N`` +(this is different to the behaviour of ``random.randint``). + +Sometimes you need numbers with a decimal point in them. These are called +*floating point* numbers and it's possible to generate such a number with the +``random.random`` method. This only returns values between ``0.0`` and ``1.0`` +inclusive. If you need larger random floating point numbers add the results +of ``random.randrange`` and ``random.random`` like this:: from microbit import * import random @@ -60,23 +62,22 @@ potrzebujesz dużej liczby zmiennoprzecinkowej dodaj ``random.randrange`` do answer = random.randrange(100) + random.random() display.scroll(str(answer)) -Pula Chaosu +Seeds of Chaos ++++++++++++++ -Losowe liczby generowane przez komputery nie są naprawdę losowe. Zwracają -jedynie pseudolosowe rezultaty zaczynając od wartości początkowej. Wartość -początkowa generowana jest na podstawie pseudolosowej wartości, takiej jak -obecna godzina i/lub odczyty z sensorów sprzętowych. - -Czasem chcesz osiągnąć powtarzalne, pseudolosowe zachowanie: odtwarzalne -źródło losowości. To jakby oczekiwać tych samych, losowych wyników pięciu -kolejnych rzutów kością. +The random number generators used by computers are not truly random. They just +give random like results given a starting *seed* value. The seed is often +generated from random-ish values such as the current time and/or readings from +sensors such as the thermometers built into chips. -Można to łatwo osiągnąć ustalając z góry wartość źródłową. Dla danej wartości -źródłowej generator liczb losowych będzie tworzył tę samą pulę liczb losowych. -Źródło jest ustawiane poprzez ``random.seed`` jako dowolna liczba całkowita. -Poniższa wersja programu do rzutu kością poda zawsze ten sam rezultat:: +Sometimes you want to have repeatable random-ish behaviour: a source of +randomness that is reproducible. It's like saying that you need the same five +random values each time you throw a dice. +This is easy to achieve by setting the *seed* value. Given a known seed the +random number generator will create the same set of random numbers. The seed is +set with ``random.seed`` and any whole number (integer). This version of the +dice program always produces the same results:: from microbit import * import random @@ -86,5 +87,5 @@ Poniższa wersja programu do rzutu kością poda zawsze ten sam rezultat:: if button_a.was_pressed(): display.show(str(random.randint(1, 6))) -Czy dostrzegasz, czemu powyższy program oczekuje wciśnięcia klawisza A, w -przeciwieństwie do restartu urządzenia z poprzedniego przykładu..? +Can you work out why this program needs us to press button A instead of reset +the device as in the first dice example..? From fec440c57900235d488421cc136c1ffa3ca6c5a4 Mon Sep 17 00:00:00 2001 From: "Win7PLT430\\User2" Date: Tue, 13 Feb 2018 21:07:26 +0100 Subject: [PATCH 22/24] =?UTF-8?q?translate=5Fnext=20zosta=C5=82=20przet?= =?UTF-8?q?=C5=82umaczony=20pierwszy=20raz=20i=20czeka=20na=20ewentualne?= =?UTF-8?q?=20poprawki.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/tutorials/next.rst | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/docs/tutorials/next.rst b/docs/tutorials/next.rst index eb41cec..99fa7fc 100644 --- a/docs/tutorials/next.rst +++ b/docs/tutorials/next.rst @@ -6,18 +6,32 @@ These tutorials are only the first steps in using MicroPython with the BBC micro:bit. A musical analogy: you've got a basic understanding of a very simple instrument and confidently play "Three Blind Mice". -Te tutoriale są tylko pierwszymi krokami w używaniu MicroPython-a z BBC micro +Te tutoriale są tylko pierwszymi krokami w stosowaniu MicroPython-a z BBC micro:bit. +Analogiczne w muzyce: posiadając podstawowe zrozumienie bardzo prostego instrumentu +śmiało zagrasz "Trzy Ślepe Myszy". +------------------------------------------------------------------------------------- This is an achievement to build upon. Ahead of you is an exciting journey to becoming a virtuoso coder. +Jest to osiągnięcie, na którym można się oprzeć. + +Przed tobą jest ekscytująca podróż aby stać się wirtuozem kodowania. +------------------------------------------------------------------------------------- + You will encounter frustration, failure and foolishness. When you do please remember that you're not alone. Python has a secret weapon: the most amazing community of programmers on the planet. Connect with this community and you will make friends, find mentors, support each other and share resources. +Spotkasz się z frustracją, porażką i głupotą. Kiedy się z tym zetkniesz, pamiętaj +nie jesteś sam. Python posiada sekretną broń: wspaniałą społeczność programistów na tej planecie. +Połącz się z tą społecznością i będziesz miał przyjaciół, znajdź mentora, +wsparcie od każdego i dziel się źródłami. +------------------------------------------------------------------------------------- + The examples in the tutorials are simple to explain but may not be the simplest or most efficient implementations. We've left out lots of *really fun stuff* so we could concentrate on arming you with the basics. If you *really* want to @@ -25,14 +39,33 @@ know how to make MicroPython fly on the BBC micro:bit then read the API reference documentation. It contains information about *all* the capabilities available to you. +Przykłady w tym tutorialu są proste do wytłumaczenia ale również mogą nie być nie proste lub +dość sprawne do zaimplementowania. Pomineliśmy wiele "naprawdę fajnych rzezy", więc +mogliśmy skupić ciebie na uzbrojeniu się w podstawy. Jeżeli "poważnie" chcesz wiedzieć jak +tworzyć MicroPythona w locie na BBC micro:bit to przeczytaj o API w odniesieniu do dokumentacji. +Ona zawiera informacje na temat "wszystkich" możliwości dostępnych dla ciebie. +------------------------------------------------------------------------------------- + Explore, experiment and be fearless trying things out ~ for these are the attributes of a virtuoso coder. To encourage you we have hidden a number of Easter eggs in MicroPython and the code editors (both TouchDevelop and Mu). They're fun rewards for looking "under the hood" and "poking with a stick". +Badaj, eksperymentuj i bądź nieustraszony próbując rzeczy poza ~ dla nich są +atrybutami wirtuoza kodowania. Aby zachęcić ciebie mamy ukrytą liczbę jaj wielkanocnych w +MicroPython-ie i edytorach kodu (oba TouchDevelop-ie i Mu). To są zabawne nagrody dla +szukających "pod maską" i "grzebiących kijem". +------------------------------------------------------------------------------------- + Such skill in Python is valuable: it's one of the world's most popular professional programming languages. Amaze us with your code! Make things that delight us! Most of all, have fun! +Takie umiejętności w Pythonie są wartościowe: jest to jeden z dość popularnych +profesjonalnych języków programowania na świecie. + +Zaskocz nas swoim kodem! Stwórz rzeczy które zachwycą nas! Przedewszystkim miłej zabawy! + Happy hacking! +Udanego Hakowania! From 9d98821c8ce85854bc52985f2fe989834fd9f382 Mon Sep 17 00:00:00 2001 From: Robo34 Date: Tue, 13 Mar 2018 21:56:30 +0100 Subject: [PATCH 23/24] Update next.rst MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Usunąłem wersję anglojęzyczną, poprawiłem wersję polską, sprawdziłem tekst na poprawność ortografii. --- docs/tutorials/next.rst | 77 +++++++++++------------------------------ 1 file changed, 20 insertions(+), 57 deletions(-) diff --git a/docs/tutorials/next.rst b/docs/tutorials/next.rst index 99fa7fc..c039e37 100644 --- a/docs/tutorials/next.rst +++ b/docs/tutorials/next.rst @@ -1,71 +1,34 @@ -Next Steps Następne Kroki ---------- -These tutorials are only the first steps in using MicroPython with the -BBC micro:bit. A musical analogy: you've got a basic understanding of -a very simple instrument and confidently play "Three Blind Mice". - - -Te tutoriale są tylko pierwszymi krokami w stosowaniu MicroPython-a z BBC micro:bit. -Analogiczne w muzyce: posiadając podstawowe zrozumienie bardzo prostego instrumentu -śmiało zagrasz "Trzy Ślepe Myszy". -------------------------------------------------------------------------------------- - -This is an achievement to build upon. - -Ahead of you is an exciting journey to becoming a virtuoso coder. +Te przewodniki są tylko pierwszymi krokami w stosowaniu MicroPython-a z +BBC micro:bit. Analogicznie w muzyce: posiadając podstawową znajomość +bardzo prostego instrumentu pewnie zagrasz utwór "Trzy Ślepe Myszy". Jest to osiągnięcie, na którym można się oprzeć. -Przed tobą jest ekscytująca podróż aby stać się wirtuozem kodowania. -------------------------------------------------------------------------------------- - -You will encounter frustration, failure and foolishness. When you do please -remember that you're not alone. Python has a secret weapon: the most amazing -community of programmers on the planet. Connect with this community and you -will make friends, find mentors, support each other and share resources. - -Spotkasz się z frustracją, porażką i głupotą. Kiedy się z tym zetkniesz, pamiętaj -nie jesteś sam. Python posiada sekretną broń: wspaniałą społeczność programistów na tej planecie. -Połącz się z tą społecznością i będziesz miał przyjaciół, znajdź mentora, -wsparcie od każdego i dziel się źródłami. -------------------------------------------------------------------------------------- - -The examples in the tutorials are simple to explain but may not be the simplest -or most efficient implementations. We've left out lots of *really fun stuff* so -we could concentrate on arming you with the basics. If you *really* want to -know how to make MicroPython fly on the BBC micro:bit then read the API -reference documentation. It contains information about *all* the capabilities -available to you. - -Przykłady w tym tutorialu są proste do wytłumaczenia ale również mogą nie być nie proste lub -dość sprawne do zaimplementowania. Pomineliśmy wiele "naprawdę fajnych rzezy", więc -mogliśmy skupić ciebie na uzbrojeniu się w podstawy. Jeżeli "poważnie" chcesz wiedzieć jak -tworzyć MicroPythona w locie na BBC micro:bit to przeczytaj o API w odniesieniu do dokumentacji. -Ona zawiera informacje na temat "wszystkich" możliwości dostępnych dla ciebie. -------------------------------------------------------------------------------------- - -Explore, experiment and be fearless trying things out ~ for these are the -attributes of a virtuoso coder. To encourage you we have hidden a number of -Easter eggs in MicroPython and the code editors (both TouchDevelop and Mu). -They're fun rewards for looking "under the hood" and "poking with a stick". +Przed tobą ekscytująca podróż, aby stać się wirtuozem kodowania. -Badaj, eksperymentuj i bądź nieustraszony próbując rzeczy poza ~ dla nich są -atrybutami wirtuoza kodowania. Aby zachęcić ciebie mamy ukrytą liczbę jaj wielkanocnych w -MicroPython-ie i edytorach kodu (oba TouchDevelop-ie i Mu). To są zabawne nagrody dla -szukających "pod maską" i "grzebiących kijem". -------------------------------------------------------------------------------------- +Napotkasz frustrację, porażkę i głupotę. Kiedy do tego dojdzie proszę +pamiętaj nie jesteś sam. Python posiada sekretną broń: wspaniałą +społeczność programistów na tej planecie. Dołącz do tej społeczności a +zaprzyjaźnisz się, znajdź mentorów, wspieraj nawzajem i dziel się źródłami. -Such skill in Python is valuable: it's one of the world's most popular -professional programming languages. +Przykłady w tym przewodniku są proste do wytłumaczenia, ale również mogą nie być +najprostsze lub dość wydajne w implementowaniu. Pominęliśmy wiele "naprawdę +fajnych rzeczy", więc mogliśmy się skupić na uzbrojeniu ciebie w podstawy. Jeżeli +"poważnie" chcesz wiedzieć jak tworzyć MicroPython w locie na BBC micro:bit to +przeczytaj dokumentację w odniesieniu do API. Zawiera informacje na temat +"wszystkich" możliwości dostępnych dla ciebie. -Amaze us with your code! Make things that delight us! Most of all, have fun! +Badaj, eksperymentuj i bądź nieustraszony próbując różne rzeczy ~ są to +atrybuty wirtuoza kodowania. Aby ciebie zachęcić mamy wiele ukrytych "jaj +wielkanocnych" w MicroPython i edytorach kodu (zarówno TouchDevelop i Mu). +Są to zabawne nagrody dla szukających "pod maską" i "grzebiących kijem". -Takie umiejętności w Pythonie są wartościowe: jest to jeden z dość popularnych +Znajomość Pythona jest cenna: jest to jeden z najbardziej popularnych profesjonalnych języków programowania na świecie. -Zaskocz nas swoim kodem! Stwórz rzeczy które zachwycą nas! Przedewszystkim miłej zabawy! +Zaskocz nas swoim kodem! Stwórz rzeczy, które zachwycą nas! Przede wszystkim miłej zabawy! -Happy hacking! Udanego Hakowania! From 924c47ae9e02abdb42ae142d29c7a6e66528265f Mon Sep 17 00:00:00 2001 From: "Win7PLT430\\User2" Date: Tue, 13 Mar 2018 22:08:43 +0100 Subject: [PATCH 24/24] =?UTF-8?q?poprawi=C5=82em=20zakres=20do=2084=20znak?= =?UTF-8?q?=C3=B3w=20dla=20ostatniej=20linii?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/tutorials/next.rst | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/tutorials/next.rst b/docs/tutorials/next.rst index c039e37..c7c394f 100644 --- a/docs/tutorials/next.rst +++ b/docs/tutorials/next.rst @@ -29,6 +29,7 @@ Są to zabawne nagrody dla szukających "pod maską" i "grzebiących kijem". Znajomość Pythona jest cenna: jest to jeden z najbardziej popularnych profesjonalnych języków programowania na świecie. -Zaskocz nas swoim kodem! Stwórz rzeczy, które zachwycą nas! Przede wszystkim miłej zabawy! +Zaskocz nas swoim kodem! Stwórz rzeczy, które zachwycą nas! Przede wszystkim miłej +zabawy! Udanego Hakowania!