Dołącz do społeczności programistów Pythona! * Poznaj elementy języka * Zaprojektuj interfejsy użytkownika * Stwórz własne aplikacje sieciowe Python to jeden z najszybciej rozwijających się języków programowania. Jest dostępny na licencji open source i posiada elastyczną, czytelną składnię. Jego możliwości pozwalają programistom na tworzenie aplikacji sieciowych, komunikację z bazami danych i zarządzanie systemami operacyjnymi. Python jest językiem wieloplatformowym, dzięki czemu napisane w nim programy można uruchamiać w różnych środowiskach i pod kontrolą różnych systemów operacyjnych. Ogromne możliwości tego języka zainspirowały duże grono entuzjastów aktywnie dzielących się wiedzą na jego temat na różnego rodzaju forach i listach dyskusyjnych. Gwarantuje to, że żadne zadane im pytanie dotyczące Pythona nie pozostanie bez odpowiedzi. Książka "Python. Od podstaw" to podręcznik dla tych, którzy chcą opanować ten język i tworzyć w nim własne aplikacje. Dzięki niej poznasz wszystkie elementy Pythona i dowiesz się, na czym polega programowanie obiektowe. Nauczysz się przetwarzać dane tekstowe i liczbowe, tworzyć graficzne interfejsy użytkownika za pomocą GTK oraz łączyć aplikacje z bazami danych. Poznasz zasady korzystania z plików XML, pisania aplikacji internetowych i integrowania Pythona z usługami sieciowymi oraz innymi językami programowania. Oto niektóre z zagadnień poruszanych w tej książce:* operacje na liczbach i ciągach znaków, * konstrukcje sterujące, * funkcje i moduły, * programowanie obiektowe, * operacje na plikach i folderach, * połączenia z bazami danych, * przetwarzanie plików XML, * obsługa serwerów pocztowych, * tworzenie własnych rozszerzeń w języku C, * aplikacje biznesowe, * usługi sieciowe, * integracja Pythona i Javy. ...\nAutor: Zespó³ autorów\nKATALOG KSI¥¯EK T³umaczenie: Rafa³ Joñca\nKATALOG ONLINE Tytu³ orygina³u: Beginning Python\nDo³¹cz do spo³ecznoœci programistów Pythona!\nTWÓJ KOSZYK • Poznaj elementy jêzyka\n• Zaprojektuj interfejsy u¿ytkownika\n• Stwórz w³asne aplikacje sieciowe\nPython to jeden z najszybciej rozwijaj¹cych siê jêzyków programowania.\nCENNIK I INFORMACJE Jest dostêpny na licencji open source i posiada elastyczn¹, czyteln¹ sk³adniê.\nJego mo¿liwoœci pozwalaj¹ programistom na tworzenie aplikacji sieciowych,\nkomunikacjê z bazami danych i zarz¹dzanie systemami operacyjnymi.\nO NOWOœCIACH Python jest jêzykiem wieloplatformowym, dziêki czemu napisane w nim programy\nmo¿na uruchamiaæ w ró¿nych œrodowiskach i pod kontrol¹ ró¿nych systemów\noperacyjnych. Ogromne mo¿liwoœci tego jêzyka zainspirowa³y du¿e grono entuzjastów\naktywnie dziel¹cych siê wiedz¹ na jego temat na ró¿nego rodzaju forach i listach\ndyskusyjnych. Gwarantuje to, ¿e ¿adne zadane im pytanie dotycz¹ce Pythona nie\nCZYTELNIA pozostanie bez odpowiedzi.\nKsi¹¿ka „Python. Od podstaw” to podrêcznik dla tych, którzy chc¹ opanowaæ ten jêzyk\nFRAGMENTY KSI¥¯EK ONLINE i tworzyæ w nim w³asne aplikacje. Dziêki niej poznasz wszystkie elementy Pythona\ni dowiesz siê, na czym polega programowanie obiektowe. Nauczysz siê przetwarzaæ\ndane tekstowe i liczbowe, tworzyæ graficzne interfejsy u¿ytkownika za pomoc¹ GTK\noraz ³¹czyæ aplikacje z bazami danych. Poznasz zasady korzystania z plików XML,\npisania aplikacji internetowych i integrowania Pythona z us³ugami sieciowymi oraz\ninnymi jêzykami programowania.\nOto niektóre z zagadnieñ poruszanych w tej ksi¹¿ce:\n• operacje na liczbach i ci¹gach znaków,\n• konstrukcje steruj¹ce,\n• funkcje i modu³y,\nWydawnictwo Helion • operacje na plikach i folderach,\nul. Koœciuszki 1c • po³¹czenia z bazami danych,\n44-100 Gliwice • przetwarzanie plików XML,\ntel. 032 230 98 63 • obs³uga serwerów pocztowych,\ne-mail: helion@helion.pl • tworzenie w³asnych rozszerzeñ w jêzyku C,\n• aplikacje biznesowe,\n• us³ugi sieciowe,\n• integracja Pythona i Javy.\nO autorach ..................................................................................................................................................15\nRozdział 1. Podstawy programowania i ciągi znaków ........................................................................... 25\nCzym różni się programowanie od używania komputera? ................................................. 25\nProgramowanie to spójność ..................................................................................... 26\nProgramowanie to sterowanie .................................................................................. 26\nProgramowanie podąża za zmianami ........................................................................ 27\nCo to wszystko oznacza? ......................................................................................... 27\nPierwsze kroki ............................................................................................................. 27\nUruchamianie edytora codeEditor ............................................................................. 28\nWykorzystywanie powłoki Pythona w edytorze codeEditor ............................................ 28\nZaczynamy korzystać z Pythona — ciągi znaków ............................................................. 29\nCzym jest ciąg znaków? ........................................................................................... 30\nDlaczego cudzysłowy? ............................................................................................. 30\nStosowanie apostrofów i cudzysłowów ...................................................................... 31\nŁączenie dwóch ciągów znaków ..................................................................................... 32\nZłączanie ciągów znaków na różne sposoby ................................................................... 33\nWyświetlanie tekstów za pomocą instrukcji print ............................................................. 34\nPodsumowanie ............................................................................................................ 35\nĆwiczenia .................................................................................................................... 36\nRozdział 2. Liczby i operatory .................................................................................................................. 37\nRóżne rodzaje liczb ...................................................................................................... 37\nLiczby w Pythonie .................................................................................................... 38\nPliki programów ........................................................................................................... 40\nKorzystanie z różnych typów ..................................................................................... 41\nPodstawowe działania matematyczne ....................................................................... 43\nKilka niespodzianek ................................................................................................ 45\nWykorzystywanie obliczeń matematycznych .................................................................... 45\nKolejność wykonywania działań ................................................................................ 45\nFormaty liczb .......................................................................................................... 46\n6 Python. Od podstaw\nBłędy się zdarzają ................................................................................................... 47\nPewne nietypowe rozwiązania .................................................................................. 48\nĆwiczenia .................................................................................................................... 50\nRozdział 3. Zmienne — nazwy dla wartości ............................................................................................51\nPrzechowywanie danych — wykorzystywanie nazw ........................................................... 51\nZmiana danych za pomocą nazwy zmiennej ............................................................... 52\nKopiowanie danych ................................................................................................. 53\nNazwy, których nie można używać, i kilka zasad ........................................................ 53\nKolejne wbudowane typy danych ................................................................................... 54\nKrotki — niezmienne sekwencje danych ................................................................... 54\nListy — modyfikowalne sekwencje danych ................................................................ 57\nSłowniki — grupowanie danych z indeksacją na podstawie nazw ................................ 59\nTraktowanie ciągu znaków jak listy ........................................................................... 61\nTypy specjalne ........................................................................................................ 62\nInne typowe właściwości sekwencji ................................................................................ 63\nDostęp do ostatniego elementu ............................................................................... 63\nZakresy sekwencji .................................................................................................. 63\nRozszerzanie list przez dodawanie kolejnych elementów ............................................ 64\nWykorzystywanie list do tymczasowego przechowywania danych ................................. 65\nPodsumowanie ............................................................................................................ 66\nĆwiczenia .................................................................................................................... 66\nRozdział 4. Podejmowanie decyzji ........................................................................................................... 69\nPorównywanie wartości — czy są takie same? ............................................................... 69\nOperacja przeciwna — nierówność ................................................................................ 71\nPorównywanie wartości — która jest większa? ............................................................... 71\nWiększy lub równy, mniejszy lub równy ...................................................................... 73\nNegacja prawdy lub fałszu ............................................................................................ 73\nPoszukiwanie wyniku więcej niż jednego porównania ....................................................... 74\nPodejmowanie decyzji ............................................................................................. 75\nPowtarzanie ................................................................................................................. 77\nJak wykonywać coś raz za razem? ............................................................................ 77\nZatrzymywanie pętli ................................................................................................. 79\nObsługa błędów ........................................................................................................... 81\nWypróbowywanie kodu ............................................................................................ 82\nPodsumowanie ............................................................................................................ 84\nĆwiczenia .................................................................................................................... 85\nRozdział 5. Funkcje ................................................................................................................................... 87\nUmieszczanie programu w osobnym pliku ...................................................................... 87\nFunkcje — grupowanie kodu pod konkretną nazwą ......................................................... 89\nDobór nazwy ........................................................................................................... 90\nOpisywanie funkcji w jej wnętrzu ............................................................................... 91\nTa sama nazwa w dwóch różnych miejscach ............................................................. 92\nPozostawianie notatek samemu sobie ...................................................................... 93\nPrzekazywanie wartości do funkcji ............................................................................ 94\nSprawdzanie parametrów ........................................................................................ 96\nUstawianie wartości domyślnej parametru ................................................................ 98\nWywoływanie funkcji wewnątrz innych funkcji ............................................................. 99\nFunkcje wewnątrz funkcji ....................................................................................... 101\nZgłaszanie własnych błędów .................................................................................. 102\nWarstwy funkcji .......................................................................................................... 103\nSposób analizy błędów w zagnieżdżonych funkcjach ................................................. 103\nPodsumowanie .......................................................................................................... 104\nĆwiczenia .................................................................................................................. 105\nRozdział 6. Klasy i obiekty .......................................................................................................................107\nPodejścia do programowania ...................................................................................... 107\nPojęcie obiektu jest powszechnie znane ................................................................. 107\nW jaki sposób korzystać z obiektów? ...................................................................... 109\nDefiniowanie klasy ..................................................................................................... 109\nW jaki sposób wykonać obiekt? ............................................................................. 110\nObiekty i ich zasięg ............................................................................................... 117\nPodsumowanie .......................................................................................................... 120\nĆwiczenia .................................................................................................................. 122\nRozdział 7. Organizacja programów .....................................................................................................123\nModuły ...................................................................................................................... 124\nImportowanie modułów, z których chce się skorzystać ............................................. 124\nTworzenie modułu na podstawie istniejącego kodu .................................................. 125\nKorzystanie z modułów — zaczynamy od wiersza poleceń ........................................ 127\nZmiana sposobu działania importu ......................................................................... 129\nPakiety ...................................................................................................................... 129\nModuły i pakiety ......................................................................................................... 131\nPrzeniesienie wszystkiego do aktualnego zasięgu .................................................... 131\nPonowny import modułów i pakietów ...................................................................... 132\nPodstawy testowania modułów i pakietów .................................................................... 134\nPodsumowanie .......................................................................................................... 135\nĆwiczenia .................................................................................................................. 136\nRozdział 8. Pliki i foldery .........................................................................................................................137\nObiekty file ................................................................................................................ 137\nZapis plików tekstowych ........................................................................................ 138\nOdczyt plików tekstowych ...................................................................................... 139\nWyjątki dotyczące plików ....................................................................................... 141\nŚcieżki i foldery ......................................................................................................... 142\nŚcieżki ................................................................................................................. 142\nZawartość folderu ................................................................................................. 145\nUzyskiwanie informacji o plikach ............................................................................ 146\nRekurencyjne wyświetlanie folderów ....................................................................... 146\nZmiana nazwy, przenoszenie, kopiowanie i usuwanie plików ..................................... 148\nPrzykład — rotacja plików ...................................................................................... 148\nTworzenie i usuwanie folderów ............................................................................... 150\nGlobbing .............................................................................................................. 150\nSerializacja ................................................................................................................ 152\nWskazówki dotyczące serializacji ............................................................................ 153\nWydajna serializacja .............................................................................................. 154\nPodsumowanie .......................................................................................................... 154\nĆwiczenia .................................................................................................................. 155\n8 Python. Od podstaw\nRozdział 9. Inne elementy języka Python ...............................................................................................157\nLambda i filtry — krótkie funkcje anonimowe ............................................................... 157\nFunkcja reduce .......................................................................................................... 158\nFunkcja map — krótsza wersja pętli ............................................................................ 159\nDecyzje wewnątrz list — listy składane ........................................................................ 160\nGenerowanie list dla pętli ........................................................................................... 161\nZastępowanie ciągów znaków wartościami ze słowników ............................................... 163\nPrzydatne modułu ...................................................................................................... 165\nGetopt — pobieranie opcji z wiersza poleceń .......................................................... 165\nWykorzystywanie więcej niż jednego procesu ........................................................... 167\nWątki — wiele zadań wykonywanych przez jeden proces .......................................... 169\nPrzechowywanie haseł ........................................................................................... 171\nPodsumowanie .......................................................................................................... 172\nĆwiczenia .................................................................................................................. 173\nRozdział 10. Tworzenie modułu ...............................................................................................................175\nSzczegóły działania modułów ...................................................................................... 175\nImportowanie modułów ......................................................................................... 177\nZnajdowanie modułu ............................................................................................. 177\nAnaliza istniejącego modułu .................................................................................. 178\nTworzenie modułów i pakietów .................................................................................... 181\nStosowanie klas ........................................................................................................ 182\nElementy programowania obiektowego ................................................................... 183\nTworzenie klas ...................................................................................................... 183\nRozszerzanie istniejących klas ............................................................................... 185\nWykonywanie pozostałych zadań związanych z modułami ............................................... 186\nDefiniowanie błędów specyficznych dla modułu ....................................................... 186\nOkreślanie eksportowanych informacji .................................................................... 187\nDokumentowanie modułu ...................................................................................... 188\nTestowanie modułu ............................................................................................... 194\nUruchamianie modułu jako programu ..................................................................... 195\nTworzenie pełnego modułu .......................................................................................... 196\nJak to działa? ....................................................................................................... 199\nInstalacja własnych modułów ...................................................................................... 202\nPodsumowanie .......................................................................................................... 205\nĆwiczenia .................................................................................................................. 206\nRozdział 11. Przetwarzanie tekstu ........................................................................................................207\nDlaczego przetwarzanie tekstów jest tak istotne? ......................................................... 207\nWyszukiwanie plików ............................................................................................. 208\nAnaliza dzienników ................................................................................................ 209\nPrzeszukiwanie poczty ........................................................................................... 210\nPoruszanie się po systemie plików za pomocą modułu os ............................................. 210\nWyrażenia regularne i moduł re ................................................................................... 216\nPodsumowanie .......................................................................................................... 219\nĆwiczenia .................................................................................................................. 220\nRozdział 12. Testy .....................................................................................................................................221\nAsercje ..................................................................................................................... 222\nPrzypadki testowe i zestawy testowe ........................................................................... 223\nOsprzęt testowy ......................................................................................................... 227\nŁączymy wszystko, wykorzystując metodologię XP ......................................................... 230\nImplementacja w Pythonie narzędzia wyszukiwania .................................................. 231\nBardziej zaawansowany skrypt wyszukujący ............................................................. 236\nTesty formalne w cyklu życia oprogramowania .............................................................. 238\nRozdział 13. Tworzenie graficznych interfejsów użytkownika ...........................................................241\nŚrodowiska do tworzenia graficznych interfejsów dostępne w Pythonie ........................... 241\nWprowadzenie do pyGTK ............................................................................................. 243\nZasoby dotyczące pyGTK ............................................................................................ 243\nTworzenie interfejsów graficznych za pomocą pyGTK ..................................................... 245\nSygnały GUI .......................................................................................................... 247\nWątki pomocnicze GUI i kolejka zdarzeń GUI ........................................................... 248\nPakowanie widgetów ............................................................................................. 254\nGlade — tworzenie interfejsów graficznych dla pyGTK .............................................. 255\nSystemy budowania GUI dla innych szkieletów interfejsów graficznych ...................... 256\nWykorzystywanie libglade w Pythonie ........................................................................... 256\nKrótki przewodnik po Glade ......................................................................................... 257\nUruchamianie Glade .............................................................................................. 257\nTworzenie projektu ................................................................................................ 259\nWykorzystywanie palety do utworzenia okna ............................................................ 259\nUmieszczanie widgetów w oknie ............................................................................. 260\nGlade tworzy plik XML opisujący interfejs graficzny .................................................. 261\nTworzenie rozbudowanej aplikacji z wykorzystaniem Glade ............................................. 263\nZaawansowane widgety .............................................................................................. 269\nDalsza rozbudowa PyRAP ............................................................................................ 272\nPodsumowanie .......................................................................................................... 278\nĆwiczenia .................................................................................................................. 279\nRozdział 14. Dostęp do baz danych ..........................................................................................................281\nKorzystanie z trwałych słowników DBM ........................................................................ 282\nWybór modułu DBM .............................................................................................. 282\nTworzenie trwałego słownika .................................................................................. 283\nDostęp do danych trwałego słownika ...................................................................... 285\nKiedy stosować trwały słownik, a kiedy relacyjną bazę danych? ................................ 287\nKorzystanie z relacyjnych baz danych ........................................................................... 288\nInstrukcje SQL ...................................................................................................... 289\nDefinicje tabel ...................................................................................................... 291\nTworzenie bazy danych .......................................................................................... 292\nStosowanie interfejsu programistycznego baz danych ................................................... 294\nPobieranie modułów .............................................................................................. 295\nTworzenie połączeń ............................................................................................... 296\nKorzystanie z kursorów .......................................................................................... 296\nTransakcje — zatwierdzanie i wycofywanie zmian .................................................... 304\nSprawdzanie możliwości modułu oraz metadane ..................................................... 304\nObsługa błędów .................................................................................................... 305\nPodsumowanie .......................................................................................................... 306\nĆwiczenia .................................................................................................................. 306\n10 Python. Od podstaw\nRozdział 15. Python i XML .......................................................................................................................309\nCzym jest XML? ......................................................................................................... 309\nHierarchiczny język znaczników .............................................................................. 309\nRodzina standardów .............................................................................................. 311\nCzym jest Schema i DTD? ........................................................................................... 312\nDo czego używa się modelu dokumentów? .............................................................. 312\nCzy model dokumentu jest potrzebny? .................................................................... 312\nDokument DTD .......................................................................................................... 312\nPrzykład DTD ........................................................................................................ 313\nDTD to nie XML .................................................................................................... 314\nOgraniczenia DTD ................................................................................................. 314\nDokument Schema .................................................................................................... 314\nPrzykład dokumentu Schema ................................................................................. 315\nSchema to standardowy dokument XML ................................................................. 315\nSchema jest hierarchiczny ..................................................................................... 315\nInne zalety Schema ............................................................................................... 316\nSchema jest znacznie rzadziej obsługiwany ............................................................. 316\nXPath ........................................................................................................................ 316\nHTML jako podzbiór języka XML ................................................................................... 317\nModele DTD dla języka HTML ................................................................................. 317\nModuł i klasa HTMLParser ..................................................................................... 317\nModuł htmllib ....................................................................................................... 318\nBiblioteki XML dostępne w Pythonie ............................................................................ 319\nWalidacja dokumentu XML w Pythonie ......................................................................... 320\nCzym jest walidacja? ............................................................................................. 320\nPoprawność formatu a walidacja ............................................................................ 320\nDostępne narzędzia .............................................................................................. 321\nCzym jest SAX? .......................................................................................................... 322\nBazujący na strumieniu ......................................................................................... 323\nSterowany zdarzeniami .......................................................................................... 323\nCzym jest DOM? ........................................................................................................ 323\nDostęp bezpośrednio z pamięci operacyjnej ............................................................ 323\nSAX czy DOM? ........................................................................................................... 324\nMożliwości ........................................................................................................... 324\nWymagania pamięciowe ........................................................................................ 324\nSzybkość działania ................................................................................................ 324\nAnalizatory SAX i DOM dostępne w Pythonie ................................................................. 325\nPakiet PyXML ....................................................................................................... 325\nPakiet xml.sax ...................................................................................................... 325\nPakiet xml.dom.minidom ....................................................................................... 325\nWprowadzenie do XSTL ............................................................................................... 328\nXSTL to XML ......................................................................................................... 328\nJęzyk formatowania i przekształceń ........................................................................ 329\nFunkcyjny, sterowany szablonami ........................................................................... 329\nWykorzystywanie Pythona do przekształceń XML za pomocą XSTL .................................. 329\nŁączymy wszystko — kanały RSS ................................................................................ 331\nWstęp do kanałów RSS ......................................................................................... 332\nModel DTD dla RSS .............................................................................................. 333\nProblem z rzeczywistego świata ............................................................................. 333\nKolejny problem z rzeczywistego świata .................................................................. 336\nPodsumowanie .......................................................................................................... 338\nĆwiczenia .................................................................................................................. 338\nRozdział 16. Programowanie sieciowe ...................................................................................................341\nProtokoły ................................................................................................................... 343\nPorównanie protokołów i języków programowania .................................................... 343\nStos protokołów internetowych .............................................................................. 344\nDodatkowe informacje na temat protokołu IP .......................................................... 346\nWysyłanie wiadomości e-mail ...................................................................................... 347\nFormat wiadomości e-mail ..................................................................................... 348\nWiadomości MIME ................................................................................................ 349\nWysyłanie poczty za pomocą SMTP i smtplib ........................................................... 358\nOdczytywanie wiadomości e-mail ................................................................................. 360\nPrzetwarzanie lokalnej skrzynki pocztowej modułem mailbox .................................... 360\nPobieranie poczty z serwera POP3 za pomocą modułu poplib ................................... 361\nPobieranie poczty z serwera IMAP modułem imaplib ................................................ 364\nBezpieczne połączenia POP3 i IMAP ....................................................................... 368\nAplikacje obsługi poczty przez WWW nie są typowymi klientami poczty ...................... 369\nProgramowanie z wykorzystaniem gniazd ...................................................................... 369\nGniazda ............................................................................................................... 369\nDołączanie do zewnętrznych interfejsów .................................................................. 372\nSerwer odwracający tekst ...................................................................................... 372\nKlient dla serwera odwracającego tekst .................................................................. 374\nModuł SocketServer .............................................................................................. 375\nSerwery wielowątkowe ........................................................................................... 377\nSerwer pogawędek internetowych ........................................................................... 378\nProjekt serwera pogawędek ................................................................................... 378\nProtokół serwera pokoju pogawędek ....................................................................... 379\nKlient pogawędek ................................................................................................. 384\nJednowątkowa wielozadaniowość uzyskiwana za pomocą select ............................... 386\nInne tematy ............................................................................................................... 388\nRozważania na temat projektowania protokołów ...................................................... 388\nSzkielet Twisted ................................................................................................... 389\nArchitektura komunikacji równorzędnej ................................................................... 392\nPodsumowanie .......................................................................................................... 392\nĆwiczenia .................................................................................................................. 393\nRozdział 17. Tworzenie rozszerzeń w języku C ...................................................................................395\nOgólna postać modułu rozszerzeń ............................................................................... 396\nKompilacja i instalacja modułu rozszerzenia ................................................................. 398\nPrzekazywanie parametrów z Pythona do C ................................................................... 400\nZwracanie wartości z C do Pythona .............................................................................. 403\nProjekt LAME ............................................................................................................. 404\nModuł rozszerzenia LAME ........................................................................................... 408\nUżywanie obiektów Pythona z poziomu kodu języka C ....................................................... 420\nPodsumowanie .......................................................................................................... 423\nĆwiczenia .................................................................................................................. 423\nRozdział 18. Pisanie programów komercyjnych i shareware ............................................................425\nAnaliza przypadku — tło ............................................................................................. 426\nW jakim stopniu wykorzystywać Pythona? ..................................................................... 426\nLicencjonowanie kodu napisanego w Pythonie .............................................................. 428\nWarto skorzystać z usług internetowych .................................................................. 429\n12 Python. Od podstaw\nStrategia cen ............................................................................................................. 430\nZnaki wodne ......................................................................................................... 430\nInne modele ......................................................................................................... 435\nSprzedaż platformy, a nie produktu ........................................................................ 436\nTwoje środowisko programistyczne .............................................................................. 436\nPoszukiwanie programistów języka Python .................................................................... 438\nSzkolenie programistów znających inne języki niż Python .......................................... 438\nDoświadczeni programiści Pythona ......................................................................... 438\nProblemy z Pythonem ................................................................................................. 438\nTworzenie kodu dla innych wersji Pythona ............................................................... 439\nPrzejście na inny system operacyjny ....................................................................... 440\nDebugowanie wątków ............................................................................................ 441\nTypowe pomyłki .................................................................................................... 441\nPrzenośna dystrybucja ................................................................................................ 442\nIstotne biblioteki ........................................................................................................ 443\nTimeoutsocket ...................................................................................................... 443\nPyGTK .................................................................................................................. 444\nGEOip .................................................................................................................. 444\nPodsumowanie .......................................................................................................... 444\nRozdział 19. Programowanie numeryczne ...........................................................................................445\nLiczby w Pythonie ....................................................................................................... 446\nLiczby całkowite .................................................................................................... 446\nDługie liczby całkowite .......................................................................................... 447\nWartości zmiennoprzecinkowe ............................................................................... 447\nFormatowanie liczb ............................................................................................... 448\nZnaki jako liczby ................................................................................................... 451\nMatematyka .............................................................................................................. 452\nArytmetyka ........................................................................................................... 452\nWbudowane funkcje matematyczne ........................................................................ 454\nModuł math ......................................................................................................... 455\nLiczby zespolone ........................................................................................................ 456\nTablice ...................................................................................................................... 459\nModuł array .......................................................................................................... 460\nPakiet numarray ................................................................................................... 462\nPodsumowanie .......................................................................................................... 465\nĆwiczenia .................................................................................................................. 465\nRozdział 20. Python w firmie .................................................................................................................467\nAplikacje biznesowe ................................................................................................... 468\nZarządzanie dokumentem ...................................................................................... 468\nLudzie skatalogowani ............................................................................................ 471\nPodejmowanie akcji za pomocą diagramów przepływu .............................................. 472\nAudyty, ustawy i inna cenna wiedza ............................................................................. 473\nAudyty i zarządzanie dokumentami ......................................................................... 474\nKorzystanie z rzeczywistych systemów biznesowych ...................................................... 475\nWprowadzenie do zestawu narzędzi wftk ................................................................. 476\nModuł python-ldap ................................................................................................ 490\nDodatkowe informacje na temat LDAP .................................................................... 494\nWracamy do wftk .................................................................................................. 495\nPodsumowanie .......................................................................................................... 500\nĆwiczenia .................................................................................................................. 500\nRozdział 21. Aplikacje i usługi internetowe ............................................................................................501\nREST — architektura sieci WWW ................................................................................. 502\nCharakterystyka REST ........................................................................................... 502\nOperacje REST ..................................................................................................... 504\nHTTP — REST w realnym świecie ................................................................................ 505\nWidoczny serwer WWW .......................................................................................... 506\nŻądanie HTTP ....................................................................................................... 509\nOdpowiedź HTTP ................................................................................................... 510\nCGI — zamiana skryptu w aplikację internetową ........................................................... 511\nUmowa między serwerem WWW a skryptem CGI ...................................................... 513\nSpecjalne zmienne środowiskowe CGI .................................................................... 514\nPobieranie danych od użytkownika przy użyciu formularzy HTML ................................ 516\nModuł cgi — przetwarzanie formularzy HTML ........................................................... 517\nTworzenie wiki ........................................................................................................... 522\nGłówna biblioteka BittyWiki .................................................................................... 524\nInterfejs WWW dla BittyWiki ................................................................................... 527\nUsługi internetowe ..................................................................................................... 536\nSposób działania usług internetowych .................................................................... 537\nUsługi internetowe REST ............................................................................................ 538\nSzybkie wprowadzenie do REST — znajdowanie okazji w Amazon.com ...................... 538\nZnajdowanie okazji ................................................................................................ 540\nDodawanie interfejsu REST do BittyWiki .................................................................. 544\nWyszukiwanie i zastępowanie w wiki\nprzy użyciu usługi internetowej w systemie REST ................................................. 547\nProtokół XML-RPC ...................................................................................................... 551\nKrótkie wprowadzenie do XML-RPC — pobieranie wiadomości z Meerkat ................... 553\nŻądanie XML-RPC ................................................................................................. 555\nOdpowiedź XML-RPC ............................................................................................. 556\nGdy coś nie działa ................................................................................................ 557\nUdostępnianie BittyWiki dzięki XML-RPC ................................................................. 558\nWyszukiwanie i zastępowanie korzystające z usługi XML-RPC .................................... 561\nSOAP ........................................................................................................................ 563\nKrótkie wprowadzenie do SOAP — interfejs Google API ............................................ 563\nŻądanie SOAP ...................................................................................................... 566\nOdpowiedź SOAP .................................................................................................. 567\nJeśli zdarzy się błąd .............................................................................................. 568\nUdostępnianie BittyWiki za pomocą interfejsu SOAP ................................................ 569\nWyszukiwanie i zastępowanie korzystające z usługi SOAP ........................................ 571\nDokumentowanie interfejsu usługi internetowej ............................................................ 572\nDokumentacja czytelna dla ludzi ............................................................................ 573\nInterfejs introspekcji XML-RPC ............................................................................... 574\nWSDL .................................................................................................................. 575\nWybór standardu usług internetowych .......................................................................... 578\nEtykieta usług internetowych ....................................................................................... 579\nUżytkownicy usług ................................................................................................. 579\nTwórcy usług ........................................................................................................ 580\nWykorzystywanie aplikacji internetowych jako usługi internetowe .............................. 580\nPrzykłady publicznie dostępnych usług internetowych .................................................... 581\nPodsumowanie .......................................................................................................... 582\nĆwiczenia .................................................................................................................. 582\n14 Python. Od podstaw\nRozdział 22. Integracja Pythona i Javy .................................................................................................583\nPowody tworzenia skryptów w aplikacjach Javy ............................................................. 584\nPorównanie implementacji Pythona .............................................................................. 585\nInstalacja Jythona ...................................................................................................... 586\nUruchamianie Jythona ................................................................................................ 586\nUruchamianie trybu interaktywnego ........................................................................ 586\nWykonywanie skryptów w Jythonie .......................................................................... 588\nOpcje sterowania skryptami ................................................................................... 589\nTworzenie poleceń wykonywalnych ......................................................................... 589\nUruchamianie Jythona bez użycia skryptu ..................................................................... 591\nPakiet aplikacji bazującej na Jythonie .......................................................................... 591\nIntegracja Javy i Jythona ............................................................................................. 592\nStosowanie klas Javy w Jythonie ............................................................................ 592\nDostęp do baz danych z poziomu Jythona ............................................................... 597\nTworzenie serwletów J2EE w Jythonie ..................................................................... 602\nRozszerzanie HttpServlet ............................................................................................ 605\nWybór narzędzi dla Jythona .................................................................................... 608\nTestowanie z wykorzystaniem Jythona .......................................................................... 609\nOsadzanie interpretera Jythona ................................................................................... 610\nWywoływanie skryptu Jythona w Javie ..................................................................... 610\nKompilacja skryptu Pythona do kodu Javy .................................................................... 612\nObsługa różnic między rozwiązaniami CPython i Jython .................................................. 613\nPodsumowanie .......................................................................................................... 614\nĆwiczenia .................................................................................................................. 615\nDodatek A Odpowiedzi do ćwiczeń ..........................................................................................................617\nDodatek B Zasoby internetowe ...............................................................................................................651\nDodatek C Co nowego w Pythonie 2.4? ..................................................................................................655\nNiniejszy rozdział stanowi wprowadzenie do programowania w Pythonie. Python to bardzo\nbogaty język, z wieloma funkcjami, więc warto poświęcić chwilę na naukę chodzenia, zanim\nrozpocznie się bieganie. Rozdziały od 1. do 3. zawierają opis podstawowych zasad progra-\nmowania przedstawiony w sposób jak najbardziej przyjazny, wraz z prostymi przykładami.\nJeśli jesteś doświadczonym programistą i chcesz jedynie poznać Pythona, możesz tylko\nprzejrzeć ten rozdział, zwracając baczniejszą uwagę na prezentowane przykłady. Od roz-\ndziału 3. zaczyna się jednak materiał, który warto przeczytać w całości, gdyż zawiera wiele\ncennych informacji o nowym języku.\nJeśli jesteś programistą początkującym, pod koniec rozdziału będziesz posiadał już pewną\nwiedzę na temat programowania, a także miał za sobą pierwsze interakcje z językiem pro-\ngramowania — Pythonem. Ćwiczenia znajdujące się na końcu rozdziału mają za zadanie\nsprawdzić i ugruntować zdobytą wiedzę.\nWarto zrozumieć, że gdy się programuje, ma się kontrolę nad poczynaniami komputera. Cza-\nsem nie wykonuje on od razu tego, czego się oczekiwało, niemniej po kilku próbach i mo-\ndyfikacjach najczęściej zaczyna poprawnie realizować powierzone mu zadania — oczywi-\nście do momentu, gdy nie zmieni się programu.\nNiestety, w komputerach osobistych pojawił się trend, który oddalił nas od niezawodności,\nponieważ nowe oprogramowanie tworzone jest na podstawie innego oprogramowania, które\nnie zawsze bywa stabilne. Z tego powodu typowy użytkownik komputera odnosi czasem\n26 Python. Od podstaw\nwrażenie, że komputer jest złośliwą i cwaną bestią, która wymaga ogromnego nakładu pracy\ni środków, by coś poprawnie wykonać. Jeśli też tak czujesz, wiedz, że nie jesteś sam. Gdy\nktoś nauczy się programować, zaczyna rozumieć powody takiego stanu rzeczy. Co więcej,\nczęsto zdaje sobie sprawę, że pewne zadania mógłby wykonać lepiej niż programiści piszący\noprogramowanie, z którego aktualnie korzysta.\nPamiętaj, że programowanie w języku takim jak Python, czyli w języku interpretowanym,\noznacza, że nie trzeba zawracać sobie głowy całym sprzętem, pamięcią i długimi sekwen-\ncjami zer i jedynek. Wszystko zapisuje się w formie tekstowej podobnej do języka natural-\nnego, choć prostszej i bardziej zhierarchizowanej. Python jest językiem, więc podobnie jak\njęzyk polski jest zrozumiały dla wszystkich osób, które go poznały. Nauka języka programo-\nwania jest łatwiejsza od nauki języka naturalnego, ponieważ nie jest związana z dyskusjami,\ndebatami, rozmowami telefonicznymi, filmami, sztukami i innymi interakcjami. Język pro-\ngramowania ma za zadanie przekazać komputerowi konkretne instrukcje i zapewnić ich po-\nprawne wykonanie. Z biegiem czasu okazało się, że komputery można zastosować niemal\nwszędzie tam, gdzie wcześniej podobne zadania wykonywali ludzie. Mimo to cały czas skła-\ndają się z podobnych części i wykonują swe zadania w zbliżony sposób.\nProgramowanie to spójność\nPomimo całej złożoności różnorakich zastosowań komputerów jego podstawowa struktura\ni sposób działania nie ulegały znaczącym zmianom. W zasadzie wewnętrzne mechanizmy\ndefiniujące sposób działania komputera nie zmieniły się w znaczący sposób od lat pięćdzie-\nsiątych ubiegłego wieku, kiedy to do budowy komputerów zaczęto wykorzystywać tranzystory.\nDzięki tej wewnętrznej prostocie mamy pewność, że komputery mogą i powinny być wysoce\nspójne. Dla programistów oznacza to mniej więcej tyle, że gdy każe się komputerowi wyko-\nnać wirtualny skok, należy podać jego wysokość i miejsce lądowania, a komputer będzie wy-\nkonywał to zadanie dowolnie długo z identycznym rezultatem. Program nie powinien zmienić\nsposobu swego działania, o ile nie wymusimy tych zmian.\nProgramowanie to sterowanie\nProgramowanie komputera znacząco różni się od tworzenia programu dla ludzi, w potocz-\nnym znaczeniu tego słowa. W świecie rzeczywistym, gdy poprosi się osobę o wykonanie\npewnego zadania, czasem trzeba się nieźle natrudzić, by prośba ta została spełniona. Jeśli\nna przykład planuje się przyjęcie na 30 osób i poprosi dwie z nich, by przyniosły chipsy,\nmoże się okazać, że jedna z nich przyniesie ciasteczka lub drinki.\nW świecie komputerów ten problem nie istnieje. Komputer będzie wykonywał dokładnie to\nzadanie, które zostało mu powierzone. Nietrudno sobie wyobrazić, że trzeba zwrócić uwagę\nna szczegóły — komputer może wykonać nasze zadanie niezależnie od jego konsekwencji.\nJednym z celów Pythona jest zapewnienie możliwości tworzenia bloków kodu, które to po-\nzwalają kreować coraz większe aplikacje w sposób modułowy i jak najbardziej zrozumiały.\nStanowi to kluczowy element stylu programowania nazywanego programowaniem obiek-\ntowym. Główne zasady tego stylu dotyczą tworzenia godnych zaufania fragmentów, które\nRozdział 1. n Podstawy programowania i ciągi znaków 27\ndziałają poprawnie po złączeniu ich w jedną całość, a jednocześnie są zrozumiałe i uży-\nteczne jako niezależne komponenty. Programista ma pełną kontrolę nad sposobem wyko-\nnania poszczególnych części programu, ale jednocześnie ma możliwość rozszerzania jego\nfunkcjonalności, gdy zajdzie taka potrzeba.\nProgramowanie podąża za zmianami\nProgramy działają na komputerach borykających się z problemami świata rzeczywistego.\nW tym rzeczywistym świecie plany i warunki często się zmieniają. Z racji tych zmian pro-\ngramista bardzo rzadko ma okazję napisać perfekcyjnie zgrany, użyteczny i elastyczny pro-\ngram. Najczęściej można osiągnąć tylko dwa z podanych celów. Zmiany, z którymi trzeba\nsię zmierzyć, powodują ostrożne podchodzenie do pewnych zagadnień programistycznych.\nPrzy odrobinie uwagi można napisać programy, które będą potrafiły stwierdzić, że zostały\npoproszone o wykonanie zadania przekraczającego ich możliwości i informowały o tym użyt-\nkownika. Czasem można nawet utworzyć programy, które dokładnie wskażą miejsce i przy-\nczynę niepowodzenia. Python oferuje specjalne funkcje pozwalające opisać warunki, które\nmusiały zajść, by uniemożliwić poprawne działanie.\nPo połączeniu tych wszystkich wymienionych elementów można wysnuć następujący wnio-\nsek: programowanie umożliwia poinformowanie komputera, jakie zadania ma wykonywać\nprzy jednoczesnej pełnej kontroli nad tym procesem. Czasem zdarzają się wypadki. Można\nje często przewidzieć i zaoferować mechanizm, który pozwoli je obsłużyć w odpowiedni spo-\nsób, a nawet powrócić do pracy.\nNa początek warto odwiedzić witrynę wydawnictwa Helion (http://helion.pl), pobrać znaj-\ndujące się tam przykłady oraz zainstalować program PythonCard. PythonCard to zbiór narzę-\ndzi ułatwiających programowanie w Pythonie. Są one dostępne bezpłatnie i zostały napisane\nspecjalnie z myślą o tym języku. Zawierają edytor, codeEditor, z którego będziemy korzystać\nw pierwszej części książki. Ma on wiele wspólnego z domyślnym edytorem dostarczanym\nwraz z Pythonem (idle), ale w opinii autorów codeEditor jest lepszym narzędziem do nauki\nprogramowania, gdyż został napisany z myślą o prostszych projektach. Co więcej, sam edytor\nzostał napisany w Pythonie.\nProgramy pisze się w postaci tak zwanego kodu źródłowego. Kod źródłowy to zestaw\ninstrukcji w formie zgodnej z danym językiem programowania. Komputer analizuje kod\ni wykonuje zawarte w nim zadania.\nTak jak autorzy mają wyspecjalizowane narzędzia do pisania tekstów dla magazynów, książek\ni publikacji online, tak programiści mają własne wyspecjalizowane narzędzia. Dla początku-\njącego programisty języka Python dobrym narzędziem będzie codeEditor.\n28 Python. Od podstaw\nUruchamianie edytora codeEditor\nSposób uruchomienia edytora zależy od wykorzystywanego systemu operacyjnego.\nPo zainstalowaniu pakietu PythonCard w systemach Linux i Unix wystarczy w oknie ter-\nminala wpisać codeEditor, by uruchomić edytor.\nW systemie Windows edytor znajduje się w menu Start na zakładce Programy/PythonCard.\nKliknięcie elementu codeEditor spowoduje uruchomienie edytora.\nUruchomiony po raz pierwszy edytor nie otwiera żadnego pliku — zapewnia najmniejszy\nmożliwy punkt startowy, czyli jedno proste okienko. Po lewej stronie znajduje się numeracja\nwierszy. Programiści bardzo często stosują numery wierszy, by przekazać sobie informacje\nna temat miejsca wystąpienia błędu. Jest to jedna z podstawowych cech dobrego edytora\nWykorzystywanie powłoki Pythona w edytorze codeEditor\nZanim zaczniemy pisać programy, poeksperymentujemy trochę z powłoką Pythona. Na ra-\nzie powłokę warto traktować jako sposób na uzyskanie dostępu do Pythona. Umożliwia ona\nwejście do wnętrza działającego egzemplarza interpretera Pythona w celu przekazywania\nkodu do wykonania. Co więcej, w tym samym czasie Python wykona wszystkie powierzone\nmu zadania i wyświetli odpowiedzi. Ponieważ uruchomione programy często mają kontekst\n— określone środowisko dostosowane do potrzeb programu przez programistę — powłoka\njest doskonałym narzędziem, gdyż daje dostęp do utworzonego kontekstu. Czasem zamiast\nsłowa kontekst mówi się o środowisku aplikacji.\nspróbuj sam Uruchomienie powłoki Pythona\nAby uruchomić powłokę Pythona z poziomu edytora codeEditor, rozwiń menu Shell i kliknij\npolecenie Shell Window. Pojawi się nowe okno z powłoką Pythona (to chyba nikogo nie za-\nskoczyło?) obok głównego okna edytora z numerami wierszy (rysunek 1.1). Podobny interfejs\nłatwo uzyskać bez stosowania PythonCard — wystarczy wywołać interpreter języka Python,\nkorzystając z polecenia python w systemie Unix lub wywołując polecenie Python z menu\nW uruchomionej powłoce pojawiły się dodatkowe informacje, którymi nie należy się na razie\nprzejmować (from, import, pcapp itp.). Na końcu znajduje się znak zachęty interpretera (>>>),\nktóry informuje o gotowości do przyjmowania kolejnych poleceń.\n>>> from PythonCard import dialog, util\n>>> bg = pcapp.getCurrentBackground()\n>>> self = bg\n>>> comp = bg.components\nRozdział 1. n Podstawy programowania i ciągi znaków 29\nEdytor codeEditor jest programem napisanym w Pythonie, a zawarta w nim powłoka jest\nspecjalnym środowiskiem, z którego skorzystamy w dalszej części książki, aby poznawanie\njęzyka Python było możliwie wygodne. Instrukcje from, import i inne zostały szczegółowo\nomówione w rozdziale 7. Na razie nie warto zaprzątać sobie nimi głowy.\nW tym momencie warto poeksperymentować, by poznać podstawowe zachowanie powłoki.\nWpisz dowolny tekst umieszczony w cudzysłowach. Oto przykład:\n>>> "Ten tekst tak naprawdę nic nie robi"\n'Ten tekst tak naprawdxea nic nie robi'\nZauważ, że zaraz po wpisaniu pierwszego cudzysłowu (") powłoka edytora zmieniła kolor\ntekstu dla całego zdania. Oczywiście powyższy tekst jest całkowicie prawdziwy — nic nie\nrobi. Nie zmienia środowiska Pythona; został po prostu wyliczony przez egzemplarz inter-\npretera jako wyrażenie, ponieważ takie polecenie wydaliśmy. Polecenie brzmiało: odczytaj\npodany tekst. Nie została zawarta tu żadna informacja o zmianie środowiska.\nPython informuje, że odczytał wpisany tekst. Przedstawił go poniżej w odpowiedniej postaci,\nczyli w apostrofach. Co więcej, polskie znaki diakrytyczne zostały zastąpione odpowiednimi\nkodami. Gdy opiszemy typy danych, przedstawimy sposoby wyświetlania informacji przez\nPythona w zależności od jej typu.\n30 Python. Od podstaw\nCzym jest ciąg znaków?\nCiąg znaków (ang. string) to pierwszy typ danych, którym zajmiemy się w języku Python.\nKomputery, a w szczególności języki programowania, dzielą wszystko na typy. Typy to\nkategorie elementów występujących w trakcie działania programu. Program (i programista),\ngdy zna typ, wie, co może zrobić z danym elementem. Jest to bardzo istotny aspekt działania\nkomputerów, ponieważ nie rozumieją one pojęć abstrakcyjnych i muszą dokładnie wiedzieć,\nw jaki sposób połączyć dwie różne wartości. Gdy jasno zdefiniuje się typ tych dwóch warto-\nści, nic nie stoi na przeszkodzie, by określić zasady rządzące ich łączeniem. Gdy znany jest\ntyp elementu, Python wie, jakie zadania może wykonać. Podobnie dzieje się z programistą.\nPowróćmy do tematu ciągu znaków. W Pythonie ciąg znaków to podstawowa jednostka tekstu.\nW odróżnieniu od innych języków programowania pojedyncza litera jest reprezentowana\nprzez ciąg znaków o długości 1. Zamiast wyjaśniać działanie ciągów znaków w próżni, wyko-\nnajmy kilka przykładów w powłoce Pythona i prześledźmy wyniki.\nspróbuj sam Wpisywanie ciągów znaków z cudzysłowami i apostrofami\nw różnych postaciach\nWpisz następujące ciągi znaków, umieszczając je w cudzysłowach lub apostrofach. Na końcu\nkażdego wiersza naciśnij klawisz Enter.\n>>> "To jest kolejny tekst"\n'To jest kolejny tekst'\n>>> 'To także jest tekst'\n'To takxbfe jest tekst'\n>>> """To kolejny tekst, który różni\n... się od poprzednich"""\n'To kolejny tekst, ktxf3ry rxf3xbfnin sixea od poprzednich'\nW trakcie pisania kodu można stosować apostrofy lub cudzysłowy — Python traktuje za-\nwarty w nich tekst dokładnie w ten sam sposób. Więcej informacji na ten temat znajdzie się\nPo wykonaniu ćwiczenia Czytelnik zapewne zwrócił uwagę na kilka kwestii. Po pierwsze,\nże tekst początkowo zawarty w cudzysłowach pojawił się później w apostrofach. Po drugie,\nw trzecim przykładzie pojawiają się obok siebie trzy cudzysłowy. Po słowie „różni” stosu-\njemy klawisz Enter, by przejść do kolejnego wiersza. Kolejny podrozdział dokładnie wyja-\nśnia wszystkie te wątpliwości.\nRozdział 1. n Podstawy programowania i ciągi znaków 31\nStosowanie apostrofów i cudzysłowów\nPython stosuje trzy różne tryby oznaczania ciągów znaków. Istnieją apostrofy i cudzysłowy,\nna które można patrzeć w dwojaki sposób. W pierwszym przypadku są one równoważne —\ndziałają tak samo i dają te same wyniki. Dlaczego zatem stosuje się jedne i drugie? Powo-\ndów jest kilka. Ciągi znaków pełnią ogromną rolę w niemal każdym programie, a ciągi\nznaków definiuje się za pomocą cudzysłowów. Trzeba jednak pamiętać, że znaki te nie są\nznakami specjalnymi i wymysłem programistów. Stanową część zwykłego tekstu w języku\npolskim i najczęściej wskazują na zastosowanie cytatu. Co więcej, używa się ich również\ndo podkreślenia pewnych słów lub zaakcentowania, że nie należy ich traktować dosłownie.\nJęzyki programowania mają pewien problem, ponieważ stosować mogą tylko te znaki, które\nwystępują na klawiaturze. Z drugiej strony, typowy użytkownik klawiatury również ma dostęp\ndo wszystkich znaków, więc może ich użyć do zadań innych niż programowanie! W jaki sposób\nwskazać, że jakiś znak jest znakiem specjalnym? W jaki sposób wskazać językowi progra-\nmowania, że jako programiści chcemy uzyskać inne znaczenie cudzysłowu, a jako użytkownik\nprogramu całkowicie odmienne?\nJednym z rozwiązań tego problemu są tak zwane sekwencje specjalne. W większości języków\nprogramowania przyjmują one najczęściej formę pojedynczego znaku nazywanego znakiem\nspecjalnym. Znak ten ma za zadanie znosić specjalne znaczenie innych znaków, na przykład\ncudzysłowów. W Pythonie znakiem tym jest lewy ukośnik (). Jeśli więc chce się umieścić\nw apostrofach tekst, który również zawiera apostrofy, należy wewnętrzne apostrofy poprzedzić\nznakiem specjalnym, by znieść ich specjalne znaczenie i zapewnić poprawną analizę tekstu\nprzez Pythona. Ponieważ czasem przykład jest lepszy od słów, oto on:\n>>> 'I powiedział 'ten tekst zawiera apostrofy''\n"I powiedziaxb3 'ten tekst zawiera apostrofy'"\nPowróćmy do analizy wcześniejszego przykładu. Standardowo powłoka Pythona wyświetla\nciąg znaków wewnątrz apostrofów. Jeśli jednak w tekście zastosuje się apostrof, a sam cyto-\nwany tekst umieści w cudzysłowach, Python zastosuje odpowiednią kombinację tych dwóch\nznaków, by ułatwić odczyt danych. Oto przykład:\n>>> 'Bartek powiedział "To Jerry'ego wina"'\n'Bartek powiedziaxb3 "To Jerry'ego wina"'\nTak naprawdę miedzy apostrofami i cudzysłowami nie ma żadnej różnicy. Oczywiście należy\npamiętać o tym, że ciąg znaków zaczynający się znakiem cudzysłowu nie może zakończyć się\nznakiem apostrofu i na odwrót. Jeśli ciąg znaków zawiera tylko cudzysłowy, można otoczyć\ngo apostrofami i w ten sposób uniknąć pisania znaków specjalnych. Podobnie sprawa wygląda\nz tekstami z apostrofami — warto umieszczać je w cudzysłowach. Przydaje się to szczególnie\nw trakcie tworzenia zapytań SQL (język zapewniający dostęp do baz danych), gdyż w nich\nnajczęściej trzeba stosować apostrofy. Więcej informacji na temat SQL-a znajduje się w roz-\ndziale 14. Warto pamiętać o jednej sprawie — same cudzysłowy lub apostrofy nie dopusz-\nczają przenoszenia tekstu do kolejnego wiersza (czyli utworzenia znaku nowego wiersza).\nWynika to z faktu, że Python stosuje ten znak do oznaczania końca instrukcji. Ogólnie jed-\nnak znak ten służy do wskazania, że należy przenieść kursor do nowego wiersza.\n32 Python. Od podstaw\nWewnątrz ciągów znaków Python dopuszcza kilka sposobów określania znaków steru-\njących, które standardowo nie są wyświetlane — najczęściej znaki sterujące dotyczą\nwykonania pewnej akcji, na przykład przejścia do nowego wiersza. Do wskazania ta-\nkich sytuacji przeważnie korzysta się ze znaku sterującego (pamiętaj, że ten znak\njest używany także do wcześniej wymienionych celów, więc w zasadzie można mówić\no znaku superspecjalnym). Kombinacja n powoduje wstawienie znaku przejścia do no-\nwego wiersza. Stosuje się ją najczęściej.\nZanim nie nauczymy się przekazywać tekstów na ekran w inny sposób, powłoka bę-\ndzie wyświetlała znaki specjalne w postaci n zamiast dokonać rzeczywistego przej-\nścia do nowego wiersza.\nPython wykorzystuje jeszcze jeden sposób tworzenia ciągów znaków, który w zasadzie elimi-\nnuje potrzebę stosowania znaków specjalnych, a także dopuszcza tworzenie tekstów wielo-\nwierszowych. Sposób ten wymaga użycia trzech cudzysłowów lub apostrofów. Gdy tylko\numieści się trzy takie znaki obok siebie, nie trzeba przejmować się stawianiem znaków spe-\ncjalnych przed apostrofami i cudzysłowami stanowiącymi część tekstu. Python traktuje wszystko,\nco zostało wpisane, jako element ciągu znaków, dopóki ponownie nie napotka trzech znaków\ncudzysłowu lub apostrofu.\n>>> """To jest specjalny ciąg znaków pozwalający złamać\n... kilka zasad, których jeszcze nie wspominaliśmy."""\n'To jest specjalny cixb9g znakxf3w pozwalajxb9cy zxb3amaxe6n kilka zasad,\nktxf3rych jeszcze nie wspominalix9cmy.'\nNietrudno zauważyć, że pomiędzy potrójnymi cudzysłowami Python jest bardzo wyrozu-\nmiały co do zawartości tekstu. Pojawia się jednak pewne pytanie — dlaczego w wyniku\npojawił się znak n? W tekście dokonaliśmy przejścia do nowego wiersza, więc dlaczego\nPython nie wykonał tego samego zadania w wyniku? Otóż Python stara się zachować jed-\nnolity sposób wyświetlania i zapewnić jego dokładność. Oto dlaczego n może być bardziej\npreferowane od przejścia do nowego wiersza: po pierwsze, istnieje sposób poinformowania\nPythona, że chce się dokonać rzeczywistego przejścia do nowego wiersza. Po drugie, gdyby\ndomyślnie w takich sytuacjach było stosowane przejście do nowego wiersza, tak naprawdę\nnie byłoby wiadomo, czy znak n naprawdę występuje, gdyż przejście mogło zostać wy-\nwołane na przykład przez zawinięcie tekstu z racji osiągnięcia końca wiersza terminala.\nPython, stosując znak n, informuje o rzeczywistej zawartości tekstu.\nBardzo często w trakcie programowania zachodzi potrzeba połączenia kilku ciągów znaków\nw jeden i wyświetlenia jako całość. Przykładem może być tu posiadanie osobnych rekordów\ndla imienia, drugiego imienia i nazwiska osoby lub też adresu rozbitego na kilka części.\nPython każdy z elementów może traktować jako niezależną część.\nRozdział 1. n Podstawy programowania i ciągi znaków 33\nspróbuj sam Zastosowanie znaku + do łączenia tekstów\nIstnieje kilka rozwiązań pozwalających połączyć poszczególne ciągi znaków. Pierwsze z roz-\nwiązań polega na zastosowaniu domyślnego łączenia zakodowanego w języku Python.\n>>> "Jan" + "T." + "Kowalski"\nPoszczególne ciągi zostały złączone w jedną całość, ale między nimi nie pojawiły się tak\npożądane odstępy. Teraz nazwisko i imię są mało czytelne, ponieważ operator + nie bierze\npod uwagę żadnego specjalnego sposobu łączenia tekstów.\nAby uzyskać właściwy efekt, między poszczególnymi elementami można wstawić spacje.\nPodobnie jak znaki nowego wiersza, spacje są traktowane jak każdy inny znak, na przykład A,\ns lub 5. Python nie usuwa spacji z tekstu, choć nie są one widoczne.\n>>> "Jan" + " " + "T." + " " + "Kowalski"\n'Jan T. Kowalski'\nTakie podejście zapewnia dużą elastyczność, ale istnieją inne rozwiązania ułatwiające two-\nrzenie złożonych tekstów.\nKolejne rozwiązanie polega na użyciu tak zwanego określnika formatu. W ciągu znaków\numieszcza się specjalną sekwencję, która Python zamienia później na wskazaną przez nas\nwartość. Choć początkowo może się wydawać, że takie podejście komplikuje całą sprawę,\ntak naprawdę ułatwia sterowanie wyświetlaniem, na przykład pozwala stosować pewne do-\nspróbuj sam Wykorzystanie określnika formatu do wypełnienia ciągu znaków\nNajpierw przetestujmy działanie określnika na nazwisko Jana T.:\n>>> Jan T. %s" % ("Kowalski")\nOkreślnik formatu %s oznacza ciąg znaków. Kilka kolejnych określników przedstawimy w dal-\nszych rozdziałach wraz z nowymi typami danych. Każdy określnik tymczasowo zastępuje\nrzeczywisty tekst. Znak % po ciągu znaków informuje, iż wszystkie określniki formatu z wcze-\nśniejszego tekstu należy zastąpić wartościami podanymi zaraz po nim.\n34 Python. Od podstaw\nDlaczego docelowy tekst znalazł się w nawiasach? Ponieważ informują one Pythona, że powi-\nnien spodziewać się sekwencji zawierającej wartości mające zastąpić określniki formatu.\nSekwencje są bardzo istotną częścią programowania w Pythonie. Wkrótce zostaną opisane\nbardziej szczegółowo. Na razie po prostu będziemy je stosować. Trzeba pamiętać, że każdy\nokreślnik formatu występujący w oryginalnym tekście musi posiadać odpowiadającą mu\nwartość zastępującą. Poszczególne wartości umieszcza się właśnie w sekwencji i oddziela\nprzecinkami (jeśli jest więcej niż jedna). W przedstawionym przykładzie sekwencji nie trzeba\nstosować, gdyż zastępujemy tylko jeden określnik. Nic jednak nie stoi na przeszkodzie, by\nNazwa określnik formatu nie jest przypadkowa, ponieważ określnik nie tylko umożliwia\nwstawienie wartości, ale również odpowiednie jej sformatowanie. Zagadnienie to przedstawimy\nw kolejnym przykładzie.\nspróbuj sam Formatowanie ciągów znaków\nIstnieje kilka bardzo prostych opcji związanych z formatowaniem ciągów znaków.\n>>> "%s %s %10s" % ("Jan", "T.", "Kowalski")\n>>> "%-10s %s %10s" % ("Jan", "T.", "Kowalski")\nW pierwszym wyniku nazwisko znalazło się bardziej na prawo, ponieważ w określniku formatu\npojawiła się informacja o tym, by zrobić miejsce na tekst o długości 10 znaków. To właśnie\noznacza %10s. Ponieważ słowo Kowalski ma tylko 8 znaków, po jego lewej stronie pojawiły\nsię dwa dodatkowe znaki spacji.\nW drugim przykładzie T. pozostało samotne na środku, a pierwsze imię i nazwisko znalazły\nsię na bokach. Opisaliśmy już działanie prawego określnika. Określnik po lewej stronie działa\nbardzo podobnie, choć na odwrót — także rezerwuje miejsce na 10 znaków tekstu, ale zastoso-\nwano kod %-10s. Znak minusa oznacza, że przekazany tekst należy umieścić po lewej za-\nmiast po prawej stronie dziesięcioznakowego miejsca.\nDo tej pory Python wyświetlał wprowadzane przez nas teksty w taki sposób, w jaki prze-\nchowuje je wewnętrznie. Nie zastosowaliśmy żadnego polecenia, które powodowało wy-\nświetlenie tekstu użytkownikowi. Zdecydowania większość programów przedstawia użyt-\nkownikom różnego rodzaju informacje: statystyki rozgrywek sportowych, tabelę odjazdów\npociągów, witryny internetowe, a nawet informacje rozliczeniowe za telefon. Najważniejsze\njest, by zostały one poprawnie zrozumiane przez osobę, która je zobaczy.\nRozdział 1. n Podstawy programowania i ciągi znaków 35\nspróbuj sam Wyświetlanie tekstu\nWiększość języków posiada specjalne polecenia zapewniające wyświetlanie tekstu użyt-\nkownikom. W Pythonie najprostszym poleceniem tego typu jest funkcja print.\n>>> print "%s %s %10s" % ("Jan", "T.", "Kowalski")\nZauważ, że tym razem całego tekstu nie otaczają żadne cudzysłowy ani apostrofy. Jest to\nniezmiernie istotne — po raz pierwszy wykonaliśmy instrukcję, która spowodowałaby wy-\nświetlenie tekstu użytkownikowi!\nInstrukcja print jest funkcją — specjalną nazwą, którą nadaje się fragmentowi programu\nwykonującemu jedno lub więcej ściśle określonych zadań. Najczęściej nie trzeba się w ogóle\nprzejmować sposobem wykonania tych zadań. (Dopiero w rozdziale 5., w którym zajmiemy\nsię pisaniem własnych funkcji, zastanowimy się nad szczegółami ich działania.)\nFunkcja print jest przykładem funkcji wbudowanej, czyli funkcji stanowiącej część języka\nPython, w przeciwieństwie do pozostałych funkcji pisanych przez siebie lub też innych\nprogramistów. Funkcja print wyświetla dane na wyjściu, czyli przedstawia coś użytkowni-\nkowi w miejscu, które może zobaczyć: terminalu, oknie, drukarce, a nawet wyświetlaczu\nciekłokrystalicznym. Inne funkcje zajmują się pobieraniem danych wejściowych, czyli da-\nnych pochodzących od użytkownika, z pliku, z sieci itp. Python wszystkie te funkcje łączy\nw jeden pakiet funkcji wejścia-wyjścia. Funkcje tego typu dotyczą wszystkich operacji zajmu-\njących się pobieraniem lub też wysyłaniem danych na zewnątrz programu. Więcej informa-\ncji na ten temat znajduje się w rozdziale 8.\nW niniejszym rozdziale przedstawiliśmy, w jaki sposób korzystać z edytora programistycz-\nnego codeEditor napisanego w Pythonie i służącego do edycji programów w tym języku. Poza\nedycją plików codeEditor obsługuje również powłokę Python, która ułatwia testowanie in-\nKorzystając z powłoki, poznaliśmy podstawy obsługi ciągów znaków, wliczając w to łączenie\nkilku mniejszych ciągów znaków w jeden duży, a także zastosowanie określników formatu.\nOkreślnik %s informuje o wstawianiu ciągu znaków. Zastosowanie w nim wartości liczbowej,\nna przykład %8s, pozwala określić ilość miejsca przewidzianego dla tekstu (w przykładzie\ndokładnie 8 znaków). W kolejnych rozdziałach przedstawimy określniki formatu dla innych\nZaznajomiliśmy się również z wyświetlaniem utworzonych ciągów znaków. Wyświetlanie\ntekstu to operacja wejścia-wyjścia (szczegółowe informacje na ten temat znajdują się w roz-\ndziale 8.). Funkcja print wyświetla na ekranie przekazany do niej ciąg znaków.\n36 Python. Od podstaw\nW kolejnym rozdziale zajmiemy się obsługą liczb, a także operacjami, które można na nich\nprzeprowadzać, łączeniem liczb i tekstów, by wyświetlić wyniki za pomocą funkcji print.\nWykorzystamy w tym celu poznaną w tym rozdziale technikę określników formatu.\n1. W powłoce Pythona wpisz następujący tekst "Szalej dziecinko, szalej,ntna\nwierzchołkach drzew,ttgdy wiatr zawiejenttt spadniesz mi na ziemię.".\nPoeksperymentuj z liczbą i rozmieszczeniem sekwencji specjalnych t i n.\nSprawdź efekt. Co się stało?\n2. W powłoce Pythona zastosuj ten sam tekst co w poprzednim ćwiczeniu, ale użyj\nfunkcji print do jego wyświetlenia. Ponownie poeksperymentuj z rozmieszczeniem\nsekwencji specjalnych t i n. Jak sądzisz, co się stało?


Zróżnicowanie opcji do wyboru - magicaliapoodles.com\nKlienci doceniają profesjonalizm oraz szczególne zróżnicowanie, z którym aktualnie wychodzi do nich producent. Stara się on, aby każda propozycja zestawu klocków lego była na znakomity poziomie. Stawiając na lego hobbit, można być pewnym dostarczenia dziecku rozrywki na wysokim poziomie. Warto zwracać uwagę na najnowsze propozycje, bo wywierają one niezwykłe wrażenie na użytkownikach. Wysoki poziom, niezwykła funkcjonalność oraz pełne zaawansowanie to cechy niezaprzeczalnie przemawiające za kupnem.\nDuńskie klocki lego creator robią ogromne wrażenie\nTworzenie różnorodnych zestawów, takich jak nowe lego creator, to podstawowe zadanie naszej firmy, do jakiego przykładamy się z pełnym zaangażowaniem. Wybierając markowe klocki na prezent dla naszego malucha lub dziecka znajomej pary, mamy gwarancję niezawodności oraz świetnego dostosowania do potrzeb malców. Warto zwrócić też uwagę na większe klocki - kolorowe klocki maxi. Wśród najnowszych zestawów znaleźć możemy niezwykle inspirujące połączenia, które budzą emocje oraz wskazują na profesjonalne podejście naszych specjalistów. Pasji nie da się ukryć!\nKlocki lego hobbit to od kolekcja powstająca na bazie ogromnego doświadczenia producenta.\nZaglądnij na stronę twórcy (https://profill.com.pl/wsparcie-sprzedazy). Namawiamy Cię gorąco! A to przez to, że czeka tam na Ciebie masa ekstra oraz interesujących szczegółów.\nStara się on ciągle zaskakiwać swych odbiorców propozycjami na rewelacyjnym poziomie. Podarunek dla dziecka w takiej postaci sprawi mu szczególną radość oraz okaże się znakomitą zabawą na długie godziny. Wielofunkcyjne zabawki okażą się doskonałym wyborem, natomiast maluchy odkrywają swoją nową pasję.\nPytacie czasami o naszą kolejną stronę. Oto ona. Należy najechać na podany link i można zobaczyć tutaj (http://pischool.pl/kursy_dla_mlodziezy_i_doroslych/6/) kolejne ciekawe artykuły.\nNieograniczony wybór oraz złożoność zestawów dają się zauważyć już na początku.\nWzrost popularności propozycji klocków lego\nWieloletnia tradycja, wysoka pozycja producenta i pełne zaangażowanie w tworzenie nowych, jeszcze ciekawszych zestawów przekłada się na coraz większą popularność w szczególnie szerokich kręgach. Klienci stawiają na lego creator, ponieważ zestaw ten odróżnia się zdecydowanie na tle innych dostępnych propozycji. Szczególnie korzystne ceny, doskonała jakość oraz niepowtarzalność to cechy przemawiające na korzyść duńskich ofert klocków lego. Doskonałym pomysłem może okazać się na przykład zakup klocków lego, które są imitacją prawdziwego życia - kreatywne lego city.\nDzień Dziecka jest świętem każdego dziecka. A wiadomo, że o dzieci należy zadbać. W zasadzie wszystkie święta trzeba święcić, także takie świeckie!


Wybieramy wylewkę na ogrzewanie podłogowe – na co zwrócić uwagę? , artykuł - budowa.org\nDlaczego podkład podłogowy – potocznie nazywany wylewką jest tak ważny?\n- Bo w dużym stopniu wpływa na efektywność i wydajność ogrzewania, a także trwałość posadzki – odpowiada krótko Tomasz Dzierwa z Baumit Polska. Wiele zależy od jego właściwości. Sprawdźmy, na jakie parametry powinniśmy zwrócić szczególną uwagę wybierając odpowiednie rozwiązanie.\nPamiętajmy, że podkład podłogowy na ogrzewaniu podłogowym narażony jest m.in. na obciążenia, wynikające z oddziaływania zmiennych temperatur – jest naprzemiennie nagrzewany i schładzany. Musi być zatem na tyle wytrzymały, by nie popękał – mogłoby to doprowadzić do uszkodzenia zatopionych w nim rurek grzewczych lub wierzchniej warstwy wykończeniowej, czyli posadzki, np. z płytek ceramicznych.\nW kontekście efektywności systemu ogrzewania podłogowego, jednym z kluczowych parametrów jest współczynnik przewodzenia ciepła podkładu podłogowego – λ [W/mK]. Im będzie on wyższy, tym podłoga nagrzeje się w znacznie krótszym czasie i szybciej odda ciepło do pomieszczenia. Różnicę na pewno zauważymy, otrzymując niższe rachunki za ogrzewanie.\nStruktura podkładu podłogowego - wylewki\nZaprawa musi dokładnie otaczać rurki ogrzewania podłogowego.\n– To ważne, bo wszelkie pustki powietrzne powstałe podczas układania podkładu podłogowego mogą powodować mniejszą skuteczność przekazywania ciepła z instalacji grzewczej. Im bardziej zwarta i homogeniczna będzie struktura wylewki, tym lepsza będzie wydajność naszej instalacji – wyjaśnia Tomasz Dzierwa.\nWylewanie podkładu samopoziomującego, fot. Baumit\nZ perspektywy prawidłowej eksploatacji ogrzewania podłogowego, bardzo istotna jest również odpowiednia grubość wylewki. Ze względu na wytrzymałość podkładów podłogowych przyjmuje się, że średnio powinno to być minimum 5 cm.\n– Minimalna grubość wylewki na ogrzewaniu podłogowym powinna wynosić 3,5 cm nad przewodami grzewczymi, a zależnie od projektowanych obciążeń dobiera się grubość w danym przypadku. Dużo zależy też od rodzaju i właściwości zastosowanego materiału, czy będzie to podkład na bazie spoiwa alfa, anhydrytowy czy cementowy. Warto przy tym pamiętać, że grubsza warstwa wylewki to większa bezwładność cieplna instalacji, a w przypadku jastrychów cementowych podłoga wolniej się nagrzewa. To także większy opór cieplny, większe zużycie materiału oraz obciążenie stropu – mówi nasz ekspert.\nIdealnym uzupełnieniem systemów „ciepłej podłogi” są podkłady samopoziomujące (CA) na bazie kompozycji spoiw zawierających półhydrat siarczanu(VI) wapnia odmiany alfa, czego najlepszym przykładem są produkty Baumit Alpha. Ich płynna konsystencja i wysoce homogeniczna struktura gwarantują dokładne otoczenie rurek grzewczych zaprawą i zapewniają optymalną współpracę z instalacją ogrzewania podłogowego. Dodatkowo wyróżniają się one wysokim współczynnikiem przewodzenia ciepła l ≥ 1,6 [W/mK]. W efekcie taki podkład nagrzewa się nawet dwukrotnie szybciej niż tradycyjne cementowe (dla których l to ok. 1,0-1,2 [W/mK]) oraz znacznie efektywniej oddaje ciepło do pomieszczenia. Pozwala to m.in. na skuteczne działanie automatyki sterującej systemem ogrzewania.\nTo jednak nie wszystko. Wysoka wytrzymałość oraz parametry techniczne podkładów Baumit Alpha pozwalają zapomnieć o konieczności zbrojenia wylewki, a dodatkowo również zmniejszyć jej grubość z minimum 4,5 cm (dla tradycyjnego jastrychu cementowego) do 3,5 cm nad przewodami grzewczymi. Nie zapominajmy również o odporności na wodę, która jest wyższa niż w przypadku wylewek anhydrytowych.\nPodkład podłogowy na bazie spoiwa alfa to zdecydowanie najlepsza opcja także wówczas, jeśli chcemy szybko uruchomić instalację. Przy zastosowaniu tej technologii będziemy mieli taką możliwość już po 3 dniach, podczas gdy w przypadku jastrychów anhydrytowych musielibyśmy z tym poczekać 7 dni, a przy tradycyjnych cementowych aż 28 dni.\nAby ogrzewanie podłogowe dobrze spełniało swoją rolę, do wykonania podkładu należy użyć materiału o odpowiednich parametrach wytrzymałościowych i wysokiej przewodności cieplnej. Stając przed wyborem konkretnego rozwiązania, kierujmy się zawsze jego jakością. Poczynione na tym etapie oszczędności mogą w przyszłości narazić nas na konieczność naprawy podłogi, a co za tym idzie kosztować nas sporo nerwów, jak i pieniędzy.\nsystem ogrzewania ogrzewanie podłogowe Baumit remont domu wylewka\nKamienica w Bytomiu - udany powrót do przeszłości Budynek z Piły zwycięzcą międzynarodowego plebiscytu! Polskie budynki w finale Baumit Life Challenge 2022! Baumit wyróżniony tytułem Dobra Marka Fasada Roku 2022 – zgłoś budynek i zawalcz o 10 000 zł! Minimaxy – w krainie maksymalnego komfortu\nPodkład pod posadzkę Baumit Alpha 2000 Wykonanie podkładu i posadzki z ogrzewaniem podłogowym Wylewka samopoziomująca firmy Baumit Samopoziomujące podkłady podłogowe Baumit na bazie spoiwa alpha Mieszanka do wykonywania jastrychów – Baumit Estrich Baumit Nivello Quattro – pogromca nierówności


Obecnie obowiązek używania kasy finansowej stanowi wyjątkowo przystępny, a przed kupnem urządzenia należy okazać się znajomością parametrów, pracy i przede wszystkim rodzajów kas. Każde urządzenie fiskalne należy dokładnie dopasować do rodzaju wykonywanej czynności. Wybór urządzenia wymaga stanowić znacznie dobro przemyślany.\nNajlepiej kupić tego typu urządzenie zdecydowanie wcześniej, niż zaplanowany jest termin fiskalizacji, dzięki czemu będziemy mieli kilkoro czasu na poznanie się z jej rolami. Właściciel firmy handlowej przede wszystkim wymaga zdać sobie na pytanie ilu konsumentów dziennie obsługuje oraz jakie są możliwości rozwoju placówki. Drugim szczególnie efektywnym założenie jest dobranie narzędzi do wysokości przedsiębiorstwa.\nKupno kasy fiskalnej to dla większości konsumentów zarówno trudny wybór, jak również silny wydatek. Dziś na targu prostych jest znacznie modeli urządzeń różnych producentów. Wybierając urządzenie pod kątem działalności, nie możemy odnosić się tylko kosztem. Kasy fiskalne ceny kształtują się od 400 złotych. Tanie wyposażenia są stworzone zwłaszcza dla niedużych firm, gdzie w zupełności wystarczy ich pewna funkcjonalność. Wtedy handlowcy piszą na najtańsze rozwiązania.\nA czy tańsza znaczy lepsza? O w tym elemencie pomyśleć czy kupując tańsze urządzenie w prawd i z rozwojem okresu nie pokaże się one bliższe? Kupując tanie urządzenie dla jednostki, która powoduje dosyć dużą jego obsługę mamy gwarancja, że kasa taka za chwilę będzie się psuć i potrzebne będzie wzywanie serwisu co w rezultacie jest połączone z kosztami. W współczesnym fakcie tańsza kasa będzie oznaczać tylko pozorne oszczędności. Aby tego ujść musimy brać urządzenie dopasowane do danej prac mając postać tego, iż posiada nam wykonywać przez masa lata. Z biegiem czasu, wraz z biegiem firmy że się okazać, że konieczna będzie pomoc kasy z innymi urządzeniami takimi jak: czytnik, waga czy komputer. Warto wtedy zainwestować trochę bardzo w ostatnie narzędzie, by dać sobie komfort książce oraz dysponować urządzeniem sprawdzonego producenta, nabyte u solidnego dostawcy, zapewniającego kompleksową opiekę serwisową.\nOferty kupna mebli\nRynek zbytu tlumaczenie\nRozwoj technologii betonu


Naleśniki z pieczarkami - Kuchnia Haim\n- ok. 500 g pieczarek ( w tym jedna do dekoracji)\n- 3 do 4 łyżek startego żółtego sera (dałam Gouda)\n- ok. 100 - 150 g śmietanki kremówki (najlepiej gęstej)\n- sól, pieprz, może być odrobina rozmarynu\n- 1,5 szklanki mąki pszennej ( może być odrobinę więcej)\n- olej do posmarowania patelni |(ja to robię tylko przed pierwszym smażeniem pędzelkiem)\nPrzygotowujemy farsz. Oczyszczone pieczarki kroimy w kostkę, cebulę również.\nPodsmażamy do miękkości. Doprawiamy solą i pieprzem, mogą być zioła wedle uznania.\nNastępnie dodajemy śmietanę kremówkę i lekko dusimy farsz, aby nieco zgęstniał.\nNa koniec dodajemy potarty ser, całość mieszamy, odstawiamy.\nCiasto jest bardzo proste.\nFarsz jeszcze raz delikatnie podgrzewamy, żeby nie był zimny.\nNakładamy na całości naleśnika, którego składamy w trójkąty.\nNa koniec możemy udekorować potrawę, kładąc ją na liściu sałaty (ja akurat nie miałam, więc dałam kapustę pekińską), ułożyć na wierzchu surowe, pokrojone w plasterki pieczarki i i przybrać świeżymi ziołami.