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 cadb35da7216acc72d5a9136ff450ee2ebdc2975 Mon Sep 17 00:00:00 2001 From: Lukasz P Date: Tue, 6 Feb 2018 20:16:14 +0100 Subject: [PATCH 20/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 edcbfb62c6a19679829f42e0f2d29c4f3746a053 Mon Sep 17 00:00:00 2001 From: gorniczy Date: Tue, 6 Feb 2018 20:37:44 +0100 Subject: [PATCH 21/24] translate some text --- docs/tutorials/network.rst | 39 +++++++++++++++++++++++++++++++++++--- 1 file changed, 36 insertions(+), 3 deletions(-) diff --git a/docs/tutorials/network.rst b/docs/tutorials/network.rst index 99df7e1..d9437af 100644 --- a/docs/tutorials/network.rst +++ b/docs/tutorials/network.rst @@ -1,4 +1,4 @@ -Network +Network -x- Sieć ------- It is possible to connect devices together to send and receive @@ -6,14 +6,27 @@ messages to and from each other. This is called a network. A network of interconnected networks is called an internet. The Internet is an internet of all the internets. +-x- Możemy połączyć urządzenia w celu wymiany wiadomości między +nimi. Nazywa się to siecią. Sieć połączonych sieci nazywana +jest internetem. Natomiast Internet łaczy w sobie wszystkie pozostałe +internety. + + Networking is hard and this is reflected in the program described below. However, the beautiful thing about this project is it contains all the common aspects of network programming you need to know about. It's also remarkably simple and fun. +-x- Praca w sieci (networking) jest trudna. Można to zaobserwować na +przykładzie opisanego niżej programu. Jednak niewątpliwą zaletą tego projetku +jest to, że zawiera on wszystkie rozpowszechione aspekty programowiania sieciowego +o których powinieneś wiedzieć. W dodatku jest niezwykle prosty i przyjemny w obsłudze. + But first, let's set the scene... -Connection +-x- Ale zacznijmy od początku... + +Connection -x- Połączenie ++++++++++ Imagine a network as a series of layers. At the very bottom is the most @@ -21,11 +34,19 @@ fundamental aspect of communication: there needs to be some sort of way for a signal to get from one device to the other. Sometimes this is done via a radio connection, but in this example we're simply going to use two wires. +-x- Wyobraźmy sobie sieć jako szereg warstw. Na samym dole mamy najabrdziej +fundamentalny aspekt komunikacji: musi być jakiś sposób, żeby przekazać sygnał +z jednego urządzenia do drugiego. Czasem jest to wykonywane poprzez połączenie radiowe, +ale w tym przykładzie zwyczajnie użyjemy dwóch przewodów. + .. image:: network.png It is upon this foundation that we can build all the other layers in the *network stack*. +-x- To właśnie na tym fundamencie możemy układać wszystkie pozostałe warstwy +naszej *sieci*. + As the diagram shows, blue and red micro:bits are connected via crocodile leads. Both use pin 1 for output and pin 2 for input. The output from one device is connected to the input on the other. It's a bit like knowing which @@ -34,15 +55,27 @@ and the other a speaker (the output). The recording of your voice via your microphone is played out of the other person's speaker. If you hold the phone the wrong way up, you'll get strange results! +-x- Jak widzimy na rysunku, niebieskie urządzenie micro:bits jest połączone z czerwonym +za pośrednictwem przewodów krokodylkowych. W obydwu przypadkach wtyk 1 jest wykorzystywany do +sygnału wyjściowego, natomiast wtyk 2 — wejściowego. Wyjście jednego urządzenia jest +połączone z wejściem drugiego. Przypomina to słuchawkę telefonu: na jednym jej końcu +umiejscowiony jest mikrofon (wyjście), na drugim — głośniczek (wejście). Głos zapisany +za pośrnictwem mikrofonu jest odtwarzany przez głośniczek drugiego urządzenia. Gdybyśmy +trzymali słuchawkę odwrotnie, mogłoby z tego wyjść coś dziwnego! + It's exactly the same in this instance: you must connect the wires properly! -Signal +-x- W tym przypadku jest tak samo: konieczne jest poprawne podpięcie przewodów! + +Signal -x- Sygnał ++++++ The next layer in the *network stack* is the signal. Often this will depend upon the characteristics of the connection. In our example it's simply digital on and off signals sent down the wires via the IO pins. +-x- Następną warstwą w naszej *sieci* jest sygnał. + If you remember, it's possible to use the IO pins like this:: pin1.write_digital(1) # switch the signal on From 83ae91528bacac4123ebe274f14f7d49b17d01f9 Mon Sep 17 00:00:00 2001 From: gorniczy Date: Tue, 13 Feb 2018 21:10:24 +0100 Subject: [PATCH 22/24] translate up to line 147 --- .DS_Store | Bin 0 -> 8196 bytes docs/.DS_Store | Bin 0 -> 6148 bytes docs/tutorials/network.rst | 197 +++++++++++++++---------------------- 3 files changed, 82 insertions(+), 115 deletions(-) create mode 100644 .DS_Store create mode 100644 docs/.DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..ce7778e8e184790e1f28ed3fc55e659e0426e0aa GIT binary patch literal 8196 zcmeHL%}>-o6n_s^?W#!m5=2cJHzp=kCiSzLA@F%lEhnPlcSoq4Zs=GR|8UI74;#q4o_ zE&$M|a@6-wvq9nWyw;TlIkJ-w$sf|CppbT1nvUPqS*roXfMP%~pcqgLC1N~B$^V-0%?W{3Rgnm ziZaDO;ZEa*v@<1^1qydSnS7v(j50&PC_0_rh|B>^fvQyuCAox8MnT#GkpH&ctOlnSk|7$hx!COUGmc3So)8FSbAR{EM_m*({L zGt3Ju$Fuz^^V#c;mu00SD|*==I?uQjE|PB)Xio23Ss57WHTnlnuJ#%$LqmPN#z6mx z)m2UFJbHY1WIn%qZ{_~#gC}B3C?5;ZT(iZe)%$ZYOY;8&zOL-=ldiAraQB|QP5YYl zme#hG_Lh$Q9i3ert=$I?&FO7vD|0*N^R=E~F7uOa(Vo+r1L9&N!@P0dUZR~&h4$Sr z<=msG)*6QiJA3Qr(ByJ~Y}$VgL?=D(+qO58^PTM2!a`t&Q#?Y(XRbTW0w;8sH(fP5 zJsU+2?fi(hz$hYL!B~Nt1=nmpAguGBy6IYJ+a2?gEDTwG+VXwN%h}20DTj8!R~`jO z6|9Wo=0$0xK@XgU6wJaMD8plT z4lm&iyob;54I8lu_u~=l!CoB1AvAFWNAVI~#tEDe{tcC@dbko*AZ7{IRJ)Y&J(qbo z8sqjF*l-st$U^~K>i?^%uG{BtsQW4~`5K!WRFcyrW3o5Nx1S~V{rA(a8ZDyuas5N~8 z*XlF)0IuAb_y#6!d;u4(U3uU`}zm^ z2K$DFhek$+#x9RtDVPJUQ+!?y`CTtCpM`0^M)O{g1zB&O=41LI=0?Hn|08aNmYy9< z<@Tx=Gk7o|YTXMd4c5z{S6bfQj%b`On7vUkWWJwakr#U`SUcoh+lcT{EXB046l^nG zaTm#6uJW*Gm4*@GvHbj|@3_=o4$>@+S!K-$LnkQH^d67o)v%FFNO>i(Qnu<8y`Y?$ z{~`HI*_pO+LmDQeqydn!Yg@uLOp?q6PK72@_Cw`0U>xqi1IWS-)ZsO}gZJM0;4G){QFyV)@CSx`oAJM(Db z*}YPH7~N-=0^PZ0Kr?U(1N{47p>nhpwj_#A2M*#0fSAB(A!zfn1kbS)+6r3|(St%{ zDxyp!>WD#PI?h`v&Q{oxDAR$c!v|3-6Lmr%Vs)% zo__upL3+>(Xa@dI21sHtyO_q_)ZTimOTO1ys9UI9cw9@ONWnpE$HL%S@hGYg^jX|M Wv=z1_;tY!Z5fC)!K{N1I8TbX6X47^6 literal 0 HcmV?d00001 diff --git a/docs/tutorials/network.rst b/docs/tutorials/network.rst index d9437af..dea54bb 100644 --- a/docs/tutorials/network.rst +++ b/docs/tutorials/network.rst @@ -1,114 +1,81 @@ -Network -x- Sieć +Sieć ------- -It is possible to connect devices together to send and receive -messages to and from each other. This is called a network. A network of -interconnected networks is called an internet. The Internet is an internet -of all the internets. - --x- Możemy połączyć urządzenia w celu wymiany wiadomości między +Możemy połączyć urządzenia w celu wymiany wiadomości między nimi. Nazywa się to siecią. Sieć połączonych sieci nazywana -jest internetem. Natomiast Internet łaczy w sobie wszystkie pozostałe +jest internetem. Natomiast Internet łączy w sobie wszystkie pozostałe internety. - -Networking is hard and this is reflected in the program described below. -However, the beautiful thing about this project is it contains all the common -aspects of network programming you need to know about. It's also remarkably -simple and fun. - --x- Praca w sieci (networking) jest trudna. Można to zaobserwować na -przykładzie opisanego niżej programu. Jednak niewątpliwą zaletą tego projetku -jest to, że zawiera on wszystkie rozpowszechione aspekty programowiania sieciowego +Praca w sieci (networking) jest trudna. Można to zaobserwować na +przykładzie opisanego niżej programu. Jednak niewątpliwą zaletą tego projektu +jest to, że zawiera on wszystkie rozpowszechnione aspekty programowania sieciowego o których powinieneś wiedzieć. W dodatku jest niezwykle prosty i przyjemny w obsłudze. -But first, let's set the scene... +Ale zacznijmy od początku... --x- Ale zacznijmy od początku... - -Connection -x- Połączenie +Połączenie ++++++++++ -Imagine a network as a series of layers. At the very bottom is the most -fundamental aspect of communication: there needs to be some sort of way for -a signal to get from one device to the other. Sometimes this is done via a -radio connection, but in this example we're simply going to use two wires. - --x- Wyobraźmy sobie sieć jako szereg warstw. Na samym dole mamy najabrdziej -fundamentalny aspekt komunikacji: musi być jakiś sposób, żeby przekazać sygnał +Wyobraźmy sobie sieć jako szereg warstw. Na samym dole mamy najbardziej +fundamentalny aspekt komunikacji: musi być jakiś sposób, żeby przekazać sygnał z jednego urządzenia do drugiego. Czasem jest to wykonywane poprzez połączenie radiowe, -ale w tym przykładzie zwyczajnie użyjemy dwóch przewodów. +ale w tym przykładzie zwyczajnie użyjemy dwóch przewodów. .. image:: network.png -It is upon this foundation that we can build all the other layers in the -*network stack*. - --x- To właśnie na tym fundamencie możemy układać wszystkie pozostałe warstwy +To właśnie na tym fundamencie możemy układać wszystkie pozostałe warstwy naszej *sieci*. -As the diagram shows, blue and red micro:bits are connected via crocodile -leads. Both use pin 1 for output and pin 2 for input. The output from one -device is connected to the input on the other. It's a bit like knowing which -way round to hold a telephone handset - one end has a microphone (the input) -and the other a speaker (the output). The recording of your voice via your -microphone is played out of the other person's speaker. If you hold the -phone the wrong way up, you'll get strange results! - --x- Jak widzimy na rysunku, niebieskie urządzenie micro:bits jest połączone z czerwonym +Jak widzimy na rysunku, niebieskie urządzenie micro:bits jest połączone z czerwonym za pośrednictwem przewodów krokodylkowych. W obydwu przypadkach wtyk 1 jest wykorzystywany do sygnału wyjściowego, natomiast wtyk 2 — wejściowego. Wyjście jednego urządzenia jest połączone z wejściem drugiego. Przypomina to słuchawkę telefonu: na jednym jej końcu umiejscowiony jest mikrofon (wyjście), na drugim — głośniczek (wejście). Głos zapisany -za pośrnictwem mikrofonu jest odtwarzany przez głośniczek drugiego urządzenia. Gdybyśmy +za pośrednictwem mikrofonu jest odtwarzany przez głośniczek drugiego urządzenia. Gdybyśmy trzymali słuchawkę odwrotnie, mogłoby z tego wyjść coś dziwnego! -It's exactly the same in this instance: you must connect the wires properly! - --x- W tym przypadku jest tak samo: konieczne jest poprawne podpięcie przewodów! +W tym przypadku jest tak samo: konieczne jest poprawne podpięcie przewodów! -Signal -x- Sygnał +Sygnał ++++++ -The next layer in the *network stack* is the signal. Often this will depend -upon the characteristics of the connection. In our example it's simply -digital on and off signals sent down the wires via the IO pins. +Następną warstwą w naszej *sieci* jest sygnał. Często zależy on od +rodzaju połączenia. W naszym przypadku jest to zwykły sygnał wlączenia i +wyłącznia przekazywany za pośrednictwem wtyków w naszych przewodach. --x- Następną warstwą w naszej *sieci* jest sygnał. +Jak już wiemy, wtyki wyjścia/wejścia można wykorzystać w następujący sposób:: -If you remember, it's possible to use the IO pins like this:: + pin1.write_digital(1) # włącz sygnał + pin1.write_digital(0) # wyłącz sygnał + input = pin2.read_digital() # odczytaj wartość sygnału (1 lub 0) - pin1.write_digital(1) # switch the signal on - pin1.write_digital(0) # switch the signal off - input = pin2.read_digital() # read the value of the signal (either 1 or 0) + Następnym krokiem będzie opisanie sposobu użycia i kontrolowania sygnału. W tym celu będzie + nam potrzebny... -The next step involves describing how to use and handle a signal. For that we -need a... - -Protocol +Protokół ++++++++ -If you ever meet the Queen there are expectations about how you ought to -behave. For example, when she arrives you may bow or curtsey, if she offers her -hand politely shake it, refer to her as "your majesty" and thereafter as -"ma'am" and so on. This set of rules is called the royal protocol. A protocol -explains how to behave given a specific situation (such as meeting the -Queen). A protocol is pre-defined to ensure everyone understands what's going -on before a given situation arises. +Gdybyś kiedyś spotkał się z Królową, musiałbyś sprostać pewnym oczekiwaniom. +Na przykład, po jej przyjeździe musiałbyś się ukłonić, a gdyby podała ci rękę, +należałoby kulturalnie ją uścisnąć. Zwracać się do Królowej przyjęto +per "wasza wysokość", następnie per "proszę pani" itd. Ten zestaw zasad nazywany jest +Królewskim Protokołem. Protokół wyjaśnia jak zachować się w odpowiedniej sytuacji +(np. na spotkaniu z Królową). Protokół jest z góry określony w celu zagwarantowania +jasności sytuacji zanim miałaby ona wystąpić. .. image:: queen.jpg -It is for this reason that we define and use protocols for communicating -messages via a computer network. Computers need to agree before hand how to -send and receive messages. Perhaps the best known protocol is the -hypertext transfer protocol (HTTP) used by the world wide web. +Definiujemy i wykorzystujemy protokoły po to, żeby móc przekazywać wiadomości +za pośrednictwem sieci komputerowych. Komputery muszą z góry uzgodnić, jak +wysyłać i przyjmować wiadomości. Prawdopodobnie najbardziej znanym protokołem +jest protokół transmisji hipertekstu (HTTP), wykorzystywany przez sieć www. -Another famous protocol for sending messages (that pre-dates computers) is -Morse code. It defines how to send character-based messages via on/off signals -of long or short durations. Often such signals are played as bleeps. Long -durations are called dashes (``-``) whereas short durations are dots (``.``). -By combining dashes and dots Morse defines a way to send characters. For -example, here's how the standard Morse alphabet is defined:: +Innym znanym protokołem wysyłania wiadomości (który istniał jeszcze przed komputerami) +jest alfabet Morse'a. Określa on sposób wysyłania wiadomości złożonych z liter poprzez +sygnały o krótkim lub długim czasie trwanie. Często takie sygnały są odtwarzane jako +dźwięki. Sygnały o długim czasie trwania nazywane są kreskami ("-"), podczas gdy +te krótkie określane są kropkami ("."). Poprzez połączenie kresek z kropkami Morse +umożliwia wysyłanie liter. Poniżej zamieszczony jest standardowy alfabet Morsa:: .- A --- J ... S .---- 1 ----. 9 -... B -.- K - T ..--- 2 ----- 0 @@ -120,63 +87,63 @@ example, here's how the standard Morse alphabet is defined:: .... H --.- Q --.. Z ---.. 8 .. I .-. R -Given the chart above, to send the character "H" the signal is switched on four -times for a short duration, indicating four dots (``....``). For the letter -"L" the signal is also switched on four times, but the second signal has a -longer duration (``.-..``). +Jak wynika z powyższego wykresu, żeby wysłać literę "H", należy czterokrotnie +wysłać krótki sygnał, który odpowiada czterem kropkom ("...."). W przypadku +litery "L" sygnał również jest wysyłany cztery razy, jednak drugie włączenie +trwa dłużej (".-.."). -Obviously, the timing of the signal is important: we need to tell a dot from a -dash. That's another point of a protocol, to agree such things so everyone's -implementation of the protocol will work with everyone elses. In this instance -we'll just say that: +Oczywiście czas trwania sygnału ma znaczenie: musimy odróżnić kropkę od kreski. +Na tym polega kolejny cel protokołu — żeby uzgodnić wspólne dla wszystkich zasady +wdrażania protokołu. +W tym przypadku powiemy tylko, że: -* A signal with a duration less than 250 milliseconds is a dot. -* A signal with a duration from 250 milliseconds to less than 500 milliseconds is a dash. -* Any other duration of signal is ignored. -* A pause / gap in the signal of greater than 500 milliseconds indicates the end of a character. +* Sygnał trwający mniej niż 250 milisekund jest kropką. +* Sygnał trwający od 250 do 499 milisekund jest kreską. +* Każdy sygnał o innym czasie trwania będzie ignorowany. +* Przerwa / odstęp między sygnałami, który przekracza 500 milisekund określa koniec litery. -In this way, the sending of a letter "H" is defined as four "on" signals that -last no longer than 250 milliseconds each, followed by a pause of greater than -500 milliseconds (indicating the end of the character). +W ten sposób, wysłanie litery "H" określane jest jako cztery sygnały trwające +nie więcej niż 250 milisekund każdy, po których następuje przerwa dłuższa +niż 500 milisekund (określająca koniec litery). -Message +Wiadomość +++++++ -We're finally at a stage where we can build a message - a message that actually -means something to us humans. This is the top-most layer of our *network -stack*. +Wreszcie dotarliśmy do chwili, gdy możemy stworzyć wiadomość, która +ma dla ludzi określone znaczenie. Jest to najwyższa warstwa w +naszej *sieci*. -Using the protocol defined above I can send the following sequence of signals -down the physical wire to the other micro:bit:: +Wykorzystując zdefiniowany wyżej protokół, mogę wysłać za pośrednictwem +przewodu następującą sekwencję sygnałów do innego urządzenia micro:bit:: ...././.-../.-../---/.--/---/.-./.-../-.. -Can you work out what it says? +Czy możesz odczytać te wiadomość? -Application +Aplikacja +++++++++++ -It's all very well having a network stack, but you also need a way to -interact with it - some form of application to send and receive messages. -While HTTP is interesting *most* people don't know about it and let their -web-browser handle it - the underlying *network stack* of the world wide web -is hidden (as it should be). +Posiadanie sieci jest dobre, jednak potrzebujemy również sposobu, żeby wejść +z nią w interakcję. Można to zrobić z pomocą aplikacji, która wysyła i przyjmuje +wiadomości. HTTP jest ciekawe, jednak *większość* ludzi nie wie o nim, pozostawiając +jego obsługę przeglądarce - sieć leżąca u podstaw sieci ogólnoświatowej +jest ukryta (tak jak być powinno). -So, what sort of application should we write for the BBC micro:bit? How should -it work, from the user's point of view? +A więc, jakiego rodzaju aplikację powinniśmy napisać dla urządzenia BBC micro:bit? +Jak powinna ona działać, patrząc z perspektywy użytkownika? -Obviously, to send a message you should be able to input dots and dashes (we -can use button A for that). If we want to see the message we sent or just -received we should be able to trigger it to scroll across the display (we can -use button B for that). Finally, this being Morse code, if a speaker is -attached, we should be able to play the beeps as a form of aural feedback while -the user is entering their message. +Żeby wysłać wiadomość, powinniśmy mieć możliwość wprowadzenia kropek i kresek +(w tym celu możemy wykorzystać przycisk A). Żeby zobaczyć wiadomość, którą wysłaliśmy +lub otrzymaliśmy, powinniśmy mieć możliwość odtworzenia jej poprzez przewijanie na +wyświetlaczu (możemy w tym celu wykorzystać przycisk B). Co więcej, jako że jest +to alfabet Morse'a, jeśli mamy podłączony głośniczek, powinniśmy mieć możliwość +odtworzenia sygnałów dźwiękowych w chwili gdy użytkownik wprowadza swoją wiadomość. -The End Result +Efekt końcowy ++++++++++++++ -Here's the program, in all its glory and annotated with plenty of comments so -you can see what's going on:: +Poniżej zamieszczony jest program w całej swojej krasie wraz z dużą ilością +komentarzy, żebyś mógł zobaczyć co się dzieje:: from microbit import * import music From a49b29578d869111c483d79bffe29f777b5a8e7b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Wed, 28 Mar 2018 01:31:01 +0200 Subject: [PATCH 23/24] =?UTF-8?q?T=C5=82umaczenie=20komentarzy=20w=20kodzi?= =?UTF-8?q?e=20oraz=20poprawki.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- docs/tutorials/network.rst | 115 +++++++++++++++++++------------------ 1 file changed, 58 insertions(+), 57 deletions(-) diff --git a/docs/tutorials/network.rst b/docs/tutorials/network.rst index dea54bb..4260a12 100644 --- a/docs/tutorials/network.rst +++ b/docs/tutorials/network.rst @@ -1,5 +1,5 @@ Sieć -------- +---- Możemy połączyć urządzenia w celu wymiany wiadomości między nimi. Nazywa się to siecią. Sieć połączonych sieci nazywana @@ -27,7 +27,7 @@ To właśnie na tym fundamencie możemy układać wszystkie pozostałe warstwy naszej *sieci*. Jak widzimy na rysunku, niebieskie urządzenie micro:bits jest połączone z czerwonym -za pośrednictwem przewodów krokodylkowych. W obydwu przypadkach wtyk 1 jest wykorzystywany do +za pośrednictwem krokodylków. W obydwu przypadkach wtyk 1 jest wykorzystywany do sygnału wyjściowego, natomiast wtyk 2 — wejściowego. Wyjście jednego urządzenia jest połączone z wejściem drugiego. Przypomina to słuchawkę telefonu: na jednym jej końcu umiejscowiony jest mikrofon (wyjście), na drugim — głośniczek (wejście). Głos zapisany @@ -40,8 +40,8 @@ Sygnał ++++++ Następną warstwą w naszej *sieci* jest sygnał. Często zależy on od -rodzaju połączenia. W naszym przypadku jest to zwykły sygnał wlączenia i -wyłącznia przekazywany za pośrednictwem wtyków w naszych przewodach. +rodzaju połączenia. W naszym przypadku jest to zwykły sygnał włączenia i +wyłączenia przekazywany za pośrednictwem wtyków w naszych przewodach. Jak już wiemy, wtyki wyjścia/wejścia można wykorzystać w następujący sposób:: @@ -107,7 +107,7 @@ nie więcej niż 250 milisekund każdy, po których następuje przerwa dłuższa niż 500 milisekund (określająca koniec litery). Wiadomość -+++++++ ++++++++++ Wreszcie dotarliśmy do chwili, gdy możemy stworzyć wiadomość, która ma dla ludzi określone znaczenie. Jest to najwyższa warstwa w @@ -121,7 +121,7 @@ przewodu następującą sekwencję sygnałów do innego urządzenia micro:bit:: Czy możesz odczytać te wiadomość? Aplikacja -+++++++++++ ++++++++++ Posiadanie sieci jest dobre, jednak potrzebujemy również sposobu, żeby wejść z nią w interakcję. Można to zrobić z pomocą aplikacji, która wysyła i przyjmuje @@ -140,7 +140,7 @@ to alfabet Morse'a, jeśli mamy podłączony głośniczek, powinniśmy mieć mo odtworzenia sygnałów dźwiękowych w chwili gdy użytkownik wprowadza swoją wiadomość. Efekt końcowy -++++++++++++++ ++++++++++++++ Poniżej zamieszczony jest program w całej swojej krasie wraz z dużą ilością komentarzy, żebyś mógł zobaczyć co się dzieje:: @@ -149,7 +149,7 @@ komentarzy, żebyś mógł zobaczyć co się dzieje:: import music - # A lookup table of morse codes and associated characters. + # tabela kodów alfabetu Morse'a i odpowiednio do każdego z nich przypisanego znaku. MORSE_CODE_LOOKUP = { ".-": "A", "-...": "B", @@ -191,12 +191,12 @@ komentarzy, żebyś mógł zobaczyć co się dzieje:: def decode(buffer): - # Attempts to get the buffer of Morse code data from the lookup table. If - # it's not there, just return a full stop. + # Próba pobrania kodu Morse'a z tabeli znaków. Jeżeli + # go tam nie ma, po prostu zwróć kropkę. return MORSE_CODE_LOOKUP.get(buffer, '.') - # How to display a single dot. + # Jak wyświetlić pojedynczą kropkę. DOT = Image("00000:" "00000:" "00900:" @@ -204,7 +204,7 @@ komentarzy, żebyś mógł zobaczyć co się dzieje:: "00000:") - # How to display a single dash. + # Jak wyświetlić pojedynczą kreskę. DASH = Image("00000:" "00000:" "09990:" @@ -212,91 +212,92 @@ komentarzy, żebyś mógł zobaczyć co się dzieje:: "00000:") - # To create a DOT you need to hold the button for less than 250ms. + # Aby utworzyć KROPKĘ musisz przytrzymać przycisk krócej niż 250 milisekund. DOT_THRESHOLD = 250 - # To create a DASH you need to hold the button for less than 500ms. + # Aby utworzyć KRESKĘ musisz przytrzymać przycisk krócej niż 500 milisekund. DASH_THRESHOLD = 500 - # Holds the incoming Morse signals. + # Trzyma przychodzący sygnał Morse'a. buffer = '' - # Holds the translated Morse as characters. + # Trzyma przetłumaczony sygnał Morse'a na znaki. message = '' - # The time from which the device has been waiting for the next keypress. + # Czas od kiedy urządzenie czeka na naciśnięcie następnego klawisza. started_to_wait = running_time() - # Put the device in a loop to wait for and react to key presses. + # Ustaw urządzenie w pętli, aby czekało i zareagowało na naciśnięcie. while True: - # Work out how long the device has been waiting for a keypress. + # Oblicz jak długo urządzenie czekało na naciśnięcie. waiting = running_time() - started_to_wait - # Reset the timestamp for the key_down_time. + # Zresetuj czas dla key_down_time. key_down_time = None - # If button_a is held down, then... + # Jeżeli button_a jest przytrzymany, to wtedy... while button_a.is_pressed(): - # Play a beep - this is Morse code y'know ;-) + # Zabrzęcz - to jest alfabet Morse'a, rozumiesz ;-) music.pitch(880, 10) - # Set pin1 (output) to "on" + # Ustaw pin1 (wyjście) na "on" (ang. włączony) pin1.write_digital(1) - # ...and if there's not a key_down_time then set it to now! + # ... i jeżeli key_down_time jest puste, to wtedy ustaw go na teraz! if not key_down_time: key_down_time = running_time() - # Alternatively, if pin2 (input) is getting a signal, pretend it's a - # button_a key press... + # Alternatywnie, jeżeli pin2 (wejście) jest otrzymuje sygnał, zasymuluj + # naciśnięcie klawisza button_a... while pin2.read_digital(): if not key_down_time: key_down_time = running_time() - # Get the current time and call it key_up_time. + # Pobierz aktualny czas i nazwij go key_up_time. key_up_time = running_time() - # Set pin1 (output) to "off" + # Ustaw pin1 (wyjście) na "off" (ang. wyłączony) pin1.write_digital(0) - # If there's a key_down_time (created when button_a was first pressed - # down). + # Jeżeli key_down_time jest ustawiona (utworzona gdy button_a został + # naciśnięty pierwszy raz). if key_down_time: - # ... then work out for how long it was pressed. + # ... potem oblicz jak długo był wciśnięty. duration = key_up_time - key_down_time - # If the duration is less than the max length for a "dot" press... + # Jeżeli duration (ang. czas trwania) jest mniejszy niż maksymalna długość + # dla naciśnięcia "dot"... (ang. kropka) if duration < DOT_THRESHOLD: - # ... then add a dot to the buffer containing incoming Morse codes - # and display a dot on the display. + # ... wtedy dodaj kropkę do buffer (ang. bufor) zawierającego + # przychodzący kod Morse'a i wyświetl kropkę na wyświetlaczu. buffer += '.' display.show(DOT) - # Else, if the duration is less than the max length for a "dash" - # press... (but longer than that for a DOT ~ handled above) + # W przeciwnym wypadku, ale jeżeli czas trwania jest mniejszy niż maksymalna + # długość dla naciśnięcia "dash"... (ang. kreska) (ale dłuższy niż dla + # KROPKI ~ określonej powyżej) elif duration < DASH_THRESHOLD: - # ... then add a dash to the buffer and display a dash. + # ... wtedy dodaj kreskę do bufora i wyświetl kreskę. buffer += '-' display.show(DASH) - # Otherwise, any other sort of keypress duration is ignored (this isn't - # needed, but added for "understandability"). + # W pozostałych przypadkach, każda inna długość naciśnięcia jest ignorowana + # (to nie jest konieczne, ale zostało dodane dla "zrozumiałości"). else: pass - # The button press has been handled, so reset the time from which the - # device is starting to wait for a button press. + # Obsługa przycisku została zakończona, więc zresetuj czas od którego + # urządzenie rozpoczyna czekać na naciśnięcie przycisku. started_to_wait = running_time() - # Otherwise, there hasn't been a button_a press during this cycle of the - # loop, so check there's not been a pause to indicate an end of the - # incoming Morse code character. The pause must be longer than a DASH - # code's duration. + # W przeciwnym razie button_a nie został naciśnięty podczas tego cyklu pętli, + # więc sprawdź czy to nie przerwa wskazująca na koniec przychodzącego kodu + # Morse'a dla znaku. Przerwa musi być dłuższa niż czas dla KRESKI (DASH) elif len(buffer) > 0 and waiting > DASH_THRESHOLD: - # There is a buffer and it's reached the end of a code so... - # Decode the incoming buffer. + # Mamy bufor i przetwarzanie dobiegło końca tak więc... + # Rozkoduj zawartość bufora. character = decode(buffer) - # Reset the buffer to empty. + # Opróżnij bufor do czysta. buffer = '' - # Show the decoded character. + # Pokaż odkodowane znaki. display.show(character) - # Add the character to the message. + # Dodaj znaki do wiadomości. message += character - # Finally, if button_b was pressed while all the above was going on... + # Ostatecznie, jeżeli button_b został naciśnięty podczas trwania powyższego... if button_b.was_pressed(): - # ... display the message, + # ... wyświetl wiadomość, display.scroll(message) - # then reset it to empty (ready for a new message). + # potem opróżnij do czysta (gotowy na nową wiadomość). message = '' -How would you improve it? Can you change the definition of a dot and a dash so -speedy Morse code users can use it? What happens if both devices are sending at -the same time? What might you do to handle this situation? +Jak chciałbyś ulepszyć to? Czy możesz zmienić definicje kropki i kreski tak by +biegły użytkownik alfabetu Morse'a mógł użyć tego? Co się stanie gdy oba urządzenia +będą wysyłać w tym samym czasie? Co możesz zrobić, aby poradzić sobie z tą sytuacją. -.. footer:: The image of Queen Elizabeth II is licensed as per the details here: https://commons.wikimedia.org/wiki/File:Queen_Elizabeth_II_March_2015.jpg +.. footer:: Obraz Królowej Elżbiety II został użyty zgodnie z licencją określoną na stronie: https://commons.wikimedia.org/wiki/File:Queen_Elizabeth_II_March_2015.jpg From 6fb766427aa0b05bfe453459dcee44f0a01fda85 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Wojciech=20Zaj=C4=85c?= Date: Wed, 28 Mar 2018 01:35:31 +0200 Subject: [PATCH 24/24] =?UTF-8?q?usuni=C4=99te=20jakie=C5=9B=20zb=C4=99dne?= =?UTF-8?q?=20pliki?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .DS_Store | Bin 8196 -> 0 bytes docs/.DS_Store | Bin 6148 -> 0 bytes 2 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 .DS_Store delete mode 100644 docs/.DS_Store diff --git a/.DS_Store b/.DS_Store deleted file mode 100644 index ce7778e8e184790e1f28ed3fc55e659e0426e0aa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8196 zcmeHL%}>-o6n_s^?W#!m5=2cJHzp=kCiSzLA@F%lEhnPlcSoq4Zs=GR|8UI74;#q4o_ zE&$M|a@6-wvq9nWyw;TlIkJ-w$sf|CppbT1nvUPqS*roXfMP%~pcqgLC1N~B$^V-0%?W{3Rgnm ziZaDO;ZEa*v@<1^1qydSnS7v(j50&PC_0_rh|B>^fvQyuCAox8MnT#GkpH&ctOlnSk|7$hx!COUGmc3So)8FSbAR{EM_m*({L zGt3Ju$Fuz^^V#c;mu00SD|*==I?uQjE|PB)Xio23Ss57WHTnlnuJ#%$LqmPN#z6mx z)m2UFJbHY1WIn%qZ{_~#gC}B3C?5;ZT(iZe)%$ZYOY;8&zOL-=ldiAraQB|QP5YYl zme#hG_Lh$Q9i3ert=$I?&FO7vD|0*N^R=E~F7uOa(Vo+r1L9&N!@P0dUZR~&h4$Sr z<=msG)*6QiJA3Qr(ByJ~Y}$VgL?=D(+qO58^PTM2!a`t&Q#?Y(XRbTW0w;8sH(fP5 zJsU+2?fi(hz$hYL!B~Nt1=nmpAguGBy6IYJ+a2?gEDTwG+VXwN%h}20DTj8!R~`jO z6|9Wo=0$0xK@XgU6wJaMD8plT z4lm&iyob;54I8lu_u~=l!CoB1AvAFWNAVI~#tEDe{tcC@dbko*AZ7{IRJ)Y&J(qbo z8sqjF*l-st$U^~K>i?^%uG{BtsQW4~`5K!WRFcyrW3o5Nx1S~V{rA(a8ZDyuas5N~8 z*XlF)0IuAb_y#6!d;u4(U3uU`}zm^ z2K$DFhek$+#x9RtDVPJUQ+!?y`CTtCpM`0^M)O{g1zB&O=41LI=0?Hn|08aNmYy9< z<@Tx=Gk7o|YTXMd4c5z{S6bfQj%b`On7vUkWWJwakr#U`SUcoh+lcT{EXB046l^nG zaTm#6uJW*Gm4*@GvHbj|@3_=o4$>@+S!K-$LnkQH^d67o)v%FFNO>i(Qnu<8y`Y?$ z{~`HI*_pO+LmDQeqydn!Yg@uLOp?q6PK72@_Cw`0U>xqi1IWS-)ZsO}gZJM0;4G){QFyV)@CSx`oAJM(Db z*}YPH7~N-=0^PZ0Kr?U(1N{47p>nhpwj_#A2M*#0fSAB(A!zfn1kbS)+6r3|(St%{ zDxyp!>WD#PI?h`v&Q{oxDAR$c!v|3-6Lmr%Vs)% zo__upL3+>(Xa@dI21sHtyO_q_)ZTimOTO1ys9UI9cw9@ONWnpE$HL%S@hGYg^jX|M Wv=z1_;tY!Z5fC)!K{N1I8TbX6X47^6