Podstawy Python 3:

Tabele informatyczne

Dominik Matusiak

Podstawy Python 3: Tabele informatyczne

dr Dominik Matusiak

d.matusiak@op.pl

Wydanie 4

ISBN 978-83-964183-9-5

Wydawnictwo Eclipse, Zgierz, 2025 r.

Źródło ryciny na okładce: www.python.org/community/logos/

Wprowadzenie

Python jest wieloparadygmatowym, dynamicznie (nie deklaruje się typu danych dla zmiennej) i silnie typowanym, interpretowanym, obiektowym językiem programowania wysokiego poziomu i ogólnego przeznaczenia. Jest jednym z najpopularniejszych języków (obok C i Java). Jest rozwijany jako projekt open source (www.python.org). Jego składnia jest zwięzła i przejrzysta. Python dostępny jest na różne systemy operacyjne. Dostępnych jest wiele bibliotek rozszerzających jego funkcjonalność (np. na pypi.org – Python Package Index). Obok Pascala, Javy i C++ jest językiem programowania dopuszczonym do użytku na maturze z informatyki. Python standardowo wyposażony jest w proste, zintegrowane środowisko programistyczne (IDE − Integrated Development Environment) nazywane IDLE (Integrated Development and Learning Environment). Bogatym w funkcje środowiskiem programistycznym jest np. PyCharm, Visual Studio Code. Pliki źródłowe w Pythonie mają rozszerzenie „py”. Gotowe skrypty można łączyć w jeden plik wykonywalny za pomocą dodatków "py2exe", "PyInstaller" (np. „pyinstaller -F c:\skrypt.py”), "Auto PY to EXE" czy "cx_Freeze"; nie jest to jednak kompilacja, gdyż kod źródłowy nadal jest wykonywany przez interpreter. Dostępne są również interpretery w wersji online (np. www.programiz.com/python-programming/online-compiler/, www.online-python.com). Skrypty można zaciemnić, tj. utrudnić ich czytanie i zrozumienie bez zmiany funkcjonalności, za pomocą np. dodatku "pyarmor" (np. „pyarmor g c:\skrypt.py”), usług online (np. development-tools.net/python-obfuscator/). Nieoficjalnym kompila-torem Python jest program Nuitka (konwertujący Python do C++, a następnie do kodu maszynowego). Język Python został również zaimplementowany dla .NET (IronPython) i Java (Jython). W dalszej części zostaną omówione podstawowe cechy i komendy Pythona wraz z przykładami.

Wybrane zalety Python:

Prosta i zwięzła składnia, open source, duża dostępność bibliotek, przenośność (dostępność na różne platformy), różnorodność zastosowań (np. aplikacje webowe, analiza danych, uczenie maszynowe, aplikacje desktopowe), dopuszczony do użytku na maturze, możliwość pisania programów dla UEFI (Unified Extensible Firmware Interface), zastosowanie w elektronice i robotyce (np. Microbit i PyBoard oparte o MicroPython, CircuitPython – odmiana poprzedniego, Pybricks – Lego Mindstorms i in.).

Wybrane wady Python:

Brak oficjalnego kompilatora oraz wolniejsze działanie programów, brak natywnej obsługi tablic, brak komentarzy wieloliniowych, duże zużycie pamięci, niemutowalne zmienne tekstowe (ale alternatywnie można zastosować typ danych „bytearray”), dynamiczne typowanie utrudniające wykrywanie błędów, ubogie oficjalne IDE (IDLE), ograniczone zastosowanie dla aplikacji mobilnych (jednakże dostępne są np. frameworki Kivy, BeeWare; QPython, Pydroid, SL4A – Scripting Layer For Android, p4a – python for android, PyQt, Chaquopy, Flet), brak natywnej obsługi makr składniowych, nienajlepsze dokumentacje, mało zrozumiałe informacje o błędach, brak oficjalnego edytora wizualnego jak w Visual Basic (ale dostępny np. wxGlade, QT Designer, MD Python Designer, PyUiBuilder, P4D – Python for Delphi, PAGE – Python Automatic GUI Generator, Gluonix Designer, Anvil – aplikacje online), brak wsparcia nowszych wersji Python dla starszych systemów Windows, to samo polecenie nieco odmiennie może funkcjonować w różnych wersjach Python 3, brak oficjalnego wsparcia dla Android (w tym Android TV) i Tizen TV, brak oficjalnego wsparcia dla wstawek asemblerowych (ale dostępne np. biblioteki PeachPy, PyAsm).

Interpreter

W IDLE możliwe jest bezpośrednie wpisywanie i wykonywanie poleceń, jak również tworzenie nowych skryptów lub uruchamianie już napisanych.

F5 − uruchomienie edytowanego skryptu

control + c − zatrzymanie działania skryptu

help (print) # wyświetlenie pomocy na temat polecenia "print"

Skrypty można również uruchamiać z linii poleceń:

python c:\skrypt.py

Przykładowe IDE i rozbudowane edytory tekstów

Pisanie programów w Python ułatwiają m.in. następujące programy: IDLE (dołączony do interpretera), PyCharm (dużo funkcji), Spyder, Visual Studio Code, Atom, Sublime Text, Thonny, Eclipse + PyDev, Visual Studio + PTVS (Python Tools for Visual Studio), Ninja-IDE, Notepad++, Wing.

Komentarze

Print ("tekst") # komentarz

# Komentarz2

'''

Brak komentarzy wieloliniowych w Python. Jako substytut można zastosować trzy apostrofy.

'''

Operatory

Arytmetyczne:

+      dodawanie            -      odejmowanie

*      mnożenie            /       dzielenie

//       dzielenie całkowite (odrzucenie części ułamkowej wyniku)

%       reszta z dzielenia (modulo)

**       potęgowanie (można również wykorzystać do wyciągania pierwiastka, gdyż: n√a = a1/n)

Przypisania:

a = (2 * 5) + 3

zmienna_tekst = "tekst" # Python rozróżnia wielkość liter.

# To samo co: zmienna_tekst = 'tekst'

a += 5  # to samo co: a = a + 5; podobnie działają: -=, *=, /=, //=, **=

Relacji:

==      równy                        !=      różny

<      mniejszy                  >      większy

<=      mniejszy bądź równy            >=      większy bądź równy

Operacji na bitach (logiczne):

&      koniunkcja            |      alternatywa

^      alternatywa rozłączna (XOR – exlusive or, można stosować do prostego szyfrowania danych)

x << y (przesunięcie bitów liczby o y pozycji w lewo, to samo co: x*2**y)

x >> y (przesunięcie bitów liczby o y pozycji w prawo, to samo co: x // 2**y)

Rozdzielanie komend i kodu

liczba = 1; print (liczba)

# Komendy można zapisywać w jednej linii, jeśli rozdzieli się je średnikiem.

print ("tekst" + \

"tekst2") # Kod można rozdzielić na więcej linii, jeśli zastosuje się lewy ukośnik.

Zmienne

Python obsługuje m.in. zmienne całkowite (integer), zmienno-przecinkowe (float), tekstowe / łańcuchowe (string), listy, słowniki, krotki.

liczba = 0 # całkowita

liczba2 = 1_000_000 # to samo co: liczba2 = 1000000

liczba3 = 0.0 # zmiennoprzecinkowa

liczba = "0b111" # zapis liczby binarnej

liczba2 = "0xFF" # zapis liczby w systemie szesnastkowym

tekst = "tekst"

# to samo co tekst: tekst = 'tekst', tego typu zmienne nie są modyfikowalne # (mutowalne)

tekst = """tekst

tekst 2"""

lista = []

lista2 = [2.5, "tekst", 15] # to samo: lista2 = list((2.5, "tekst", 15))

# Lista stanowi zbiór elementów, które mogą być różnego typu.

lista2 = lista2 + [3, 4] # dodawanie dwóch elementów do listy

krotka = ("Jan", "3.0", "Poniedziałek")

# zadeklarowanie krotki – podobna do listy, tylko niemodyfikowalna

slownik = {"klucz1" : "wartość1", "klucz2" : 100, "klucz3" : True}

Wykonanie np. polecenia "print (a)" bez zdefiniowania zmiennej "a", wygeneruje błąd.

Wielokrotne przypisanie:

a, b, c = 1, 2, 3 # a = 1; b = 2; c = 3

Wyświetlanie danych w konsoli

a = 2; b = 5

tekst = "slowo"

print (a * b, "tekst")

print (tekst,"\ntekst w nowej linii")

print("\\n") # ignorowanie opcji \n i zapisanie "\n"

print(f"Tekst to: {tekst}")

# wyświetlenie napisu oraz wartości zmiennej "tekst",

# to samo co: print("Tekst to: {}".format(tekst))

print ("a", "b", "c", sep = ":", end = ".") # sep - separator, end - końcowy znak/znaki

Minimalny program

print ("Hello world")

Pobieranie danych od użytkownika

tekst = input ("Wpisz tekst: ")

# Funkcja ta pobiera dane tekstowe i zapisuje do zmiennej.

tekst2 = input ()

liczba = int(input())

# pobranie wartości, konwersja do liczby całkowitej i zapisanie do zmiennej "liczba"

liczba2 = float(input()) # jak wyżej, tylko konwersja na liczbę zmiennoprzecinkową

Funkcje

def funkcja (a): # Funkcje jako parametry mogą przyjmować również listy.

return a + 2 # charakterystyczne wcięcie w składni Python (zwykle 4 spacje)

# Domyślnymi wartościami parametrów są 2, 3 i 4.

def funkcja2 (a = 2, b = 3, name = 4):

return a + 2, b * 3, funkcja(a+3)

def funkcja3 (): # funkcja bez parametrów

global x # Domyślnie zmienne w funkcjach są lokalne. Komenda global

# oznacza je jako globalne.

print ("Witaj", x + 5)

def funkcja4 (*args):# funkcja z nieokreśloną liczbą argumentów

pass # Polecenie to nie wywołuje żadnych skutków. Zastępuje kod, tam gdzie # składnia tego wymaga.

a = 2

funkcja (a) # wywołanie funkcji

print (funkcja2 (3, 4)) # wywołanie funkcji

funkcja3 () # wywołanie funkcji bez parametrów

f_anonimowa = lambda a, b : a + b # funkcja anonimowa

print (f_anonimowa(5,5))

# yield zamiast return

def funkcja4():

yield "A"; yield 15+10; yield "B" # zwracanie listy elementów

x = funkcja4()

for a in x:

print(a)

def funkcja(imie, wiek):

print(f"Nazywam się {imie}, mam {wiek} lat.")

slownik = {"imie": "Zenek", "wiek": 20}

funkcja(**slownik) #przekazanie kluczy ze słownika jako argumenty dla funkcji

# funkcje wyższego rzędu "map" i "filter"

def funkcja(x):

if x < 3: return True

else: return False # usunięcie elementu

lista = [1.5, 2.9, 3.1]

wynik = map(int, lista)

# przetworzenie każdego elementu za pomocą podanej funkcji

print(list(wynik))

print(list(filter(funkcja,lista))) # filtrowanie danych za pomocą podanej funkcji

Instrukcje warunkowe

a = 1; b = 0

if a == 1:

# operatory: == (równe), != (nierówne), <, >, >=, <=, or ("albo", alternatywa),

# and ("i", koniunkcja), not ("nie", negacja)

print("a") # charakterystyczne wcięcie w składni Python

if not a == 1 or b == 2 and a > 1 or (a+b) == 5:

print("a")

if a == 1:

print("a")

else:

print("b")

if a == 1:

print("a")

elif b == 2: # Jeśli kilka "elif" jest spełnionych, to tylko pierwsza jest wykonywana.

print("b")

print ("Tak") if a == 1 else print ("Nie") # instrukcja warunkowa w 1 linijce

a = 5

if 2 < a < 10: # to samo co: if a < 10 and a > 2:

print ("a")

# Czy wyszukiwana fraza znajduje się w zmiennej (tekstowej lub liście). Możliwe # operatory: in, not in.

zmienna = "Nie lubię poniedziałków"

if "Nie" in zmienna:

print ("Tak")

Importowanie bibliotek

Wiele funkcji jest definiowanych przez dodatkowe biblioteki, które przed użyciem należy zaimportować:

import turtle # korzystanie z funkcji zaimportowanych w ten sposób: turtle.fd(100)

import turtle as zolw

# korzystanie z funkcji zaimportowanych w ten sposób: zolw.fd(100)

from math import sqrt

# importowanie funkcji "sqrt" z biblioteki "math", korzystanie z funkcji # zaimportowanych w ten sposób (możliwe kolizje nazw): sqrt(4)

from turtle import * # zaimportowanie wszystkich funkcji

Standardowa wersja Python wyposażona jest tylko w podstawowe biblioteki. Aby zainstalować dodatkowe, należy posłużyć się programem "pip" (python install package), np.: "pip install keyboard".

Przykładowe biblioteki / frameworki / dystrybucje:

math − funkcje matematyczne

keyboard − funkcje związane z klawiaturą

random − generowanie liczb pseudolosowych

time − funkcje związane z czasem i datą

turtle − grafika żółwia (wzorowana na języku Logo)

winsound − obsługa dźwięków w Windows

os − wykorzystywane funkcjonalności systemu operacyjnego

shutil – operacje na plikach, w tym kopiowanie

tkinter, wxPython, PyQt, PySimpleGUI, Gooey, Textual (w konsoli),

PyVisual − tworzenie interfejsów graficznych (GUIs − Graphical

User Interfaces)

pygame, pyglet, pysfml − różne funkcje przydatne do tworzenia gier

i programów multimedialnych

NumPy − funkcje matematyczne (w tym macierze, generowanie liczb

pseudolosowych, funkcje statystyczne)

SciPy − obliczenia naukowe, statystyczne

pandas − obróbka i analiza danych

matplotlib − tworzenie wykresów

pillow, PIL (Python Image Library) − funkcje graficzne

pynput − obsługa klawiatury i myszki

colorama, rich − zmiana koloru tekstu w terminalu, inne

statistics − funkcje statystyczne

Django, Flask, Web2Py, Pyramid, CherryPy − aplikacje webowe

Kivi − aplikacje desktopowe, mobilne

csv − obsługa plików CSV (Comma Separated Value)

functools – obsługa funkcji wyższego rzędu (funkcje, które zwracają

lub przyjmują jako argument inne funkcje)

openCV – obróbka obrazów

BearLibTerminal – obsługa trybu tekstowego

Anaconda – dystrybucja do zastosowań naukowych (w tym analiza

danych, uczenie maszynowe, zawiera np. biblioteki SciPy, NumPy,

pandas)

pyxxl – integruje Python z Microsoft Excel, alternatywa dla VBA

(Visual Basic for Applications)

openpyxl – obsługa plików Excel

json – obsługa JavaScript Object Notation

datetime – obsługa czasu, daty

PeachPy, PyAsm – obsługa assemblera

fractions – obsługa liczb wymiernych

decimal – do precyzyjnego obliczania liczb zmiennoprzecinkowych

re – obsługa wyrażeń regularnych

Instrukcje iteracyjne (pętle)

While:

a = 1

while a < 6: # powtarzanie pętli, aż do spełnienia warunku

print (a); a = a + 1

while True: # pętla w nieskończoność

print ("Tekst")

For:

# powtarzanie pętli w zakresie 0-4 (wartości indeksowane od 0)

for a in range(5):

print (a)

# Funkcja "range" może przyjmować również bardziej złożoną postać:

# range(start, stop, przeskok)

for a in range(1, 10, 2):

print (a, a+1)

for _ in range(10):

print("Text")

lista = ["Jan", "Maria", "Zenon"]

for imie in lista: # enumerate(lista) – dodatkowo ponumeruje elementy listy

print (imie)

Przerywanie pętli/programu:

if a == 3: break # przerwanie pętli

if a == 3: continue # przejście do następnego cyklu pętli

if a == 4: exit() # zakończenie programu

Pauza i timer

input ("Naciśnij enter ")

import time

time.sleep (3.5) # pauza 3,5 sekundy

timer = time.time()

# zapisanie w zmiennej "timer" liczby sekund od 01.01.1970, 24:00

print (timer)

Czyszczenie ekranu

from os import system

system("cls") # wykonanie komendy "cls" w systemie Windows

Podstawowe funkcje matematyczne

a = int (2.5) # konwersja liczby zmiennoprzecinkowej na całkowitą

liczba = bin (60) # konwersja na liczbę binarną

b = hex (60) # konwersja na liczbę szesnastkową

c = int (liczba, 2) # konwersja liczby binarnej na dziesiętną

d = int (liczba, 16) # konwersja liczby szesnastkowej na dziesiętną

e = round (5.555, 2) # zaokrąglenie liczby do 2 miejsc po przecinku

f = round (5.55) # zaokrąglenie do liczby całkowitej

from math import *

g = fmod (6, 4) # reszta z dzielenia 6/4, podobnie działa funkcja: remainder(a, b)

h = sqrt (4) # pierwiastek 2. stopnia, to samo co: a = 4 ** 0.5,

# cbrt() – pierwiastek 3. stopnia

i = fabs (-2) # wartość bezwzględna

j = log (10)) # logarytm naturalny

k = log10 (10) # logarytm dziesiętny, log10 = ln(x) * 0,434

l = pi # przybliżona wartość stałej pi

m = e # przybliżona wartość stałej e

n = trunc (2.556) # usunięcie części ułamkowej liczby

# Podobnie ale z pewnymi różnicami działa: floor()

o = pow (2, 4) # podniesienie 2 do potęgi 4

ulamek, calkowita = math.modf (1.5)

# oddzielenie części ułamkowej od całkowitej danej liczby

m = sin (10) # Podaje wartość sinus dla kąta w radianach, podobnie działają:

# cos (), tan (), cot ().

n = radians (180) # Konwertuje 180º na radiany, podobne działa funkcja degrees ().

# tożsamości trygonometryczne: sin2 α + cos2 α = 1, tan = sin α / cos α,

# cot α = 1 / tan α, 1 rad ≈ 57,30º

o = gcd(6, 2) # największy wspólny dzielnik

p = factorial(5) # silnia (= 1*2*3*4*5)

Generowanie liczb pseudolosowych

import random

a = random.randrange (0,10)

# generowanie liczby całkowitej, randrange (start, stop, przeskok − opcjonalne)

b = random.randint (0,10) # jw., random.randint (start, stop)

c = random.random() # generowanie liczby zmiennoprzecinkową z zakresu 0-1

print (a, b, c)

lista = ["a", "c", "c"]

print(random.choice(lista)) # wybranie losowej pozycji z listy

from numpy import random

x = random.randint(100) # wygenerowanie losowej liczby całkowitej 0-100

x = random.rand() # wygenerowanie losowej liczby zmiennoprzecinkowej 0-1

Manipulowanie zmiennymi tekstowymi

tekst = "       To jest tekst"

print (tekst[0:10:2])

# wyświetlenie fragmentu tekstu, tekst[start:stop-1:przeskok], indeks liczony od 0

print (tekst [:3]) # wyświetlenie pierwszych trzech znaków

print (tekst[0]) # wyświetlenie pierwszego elementu

print (tekst[-1]) # wyświetlenie ostatniego elementu

print (tekst.lower()) # konwersja na małe litery

print (tekst.upper()) # konwersja na duże litery

print (tekst.swapcase()) # konwersja małych liter na duże oraz vice versa

print (tekst.lstrip()) # usuwane białe znaki (np. spacje, tabulatory) z lewej strony, # można też usuwać inne znaki, strip() - usuwa z obu stron

print (tekst.rstrip()) # usuwane białe znaki z prawej strony

print (chr(65)) # wyświetlenie znaku ASCII (American Standard Code for

# Information Interchange) o nr. 65

tekst *= 2 # dwukrotne zwielokrotnienie zawartości zmiennej tekstowej

tekst += "abc" # przyłączenie fragmentu do zmiennej tekstowej

# Można też użyć funkcji: join()

print (tekst.isalnum()) # Zwraca prawdę, gdy w zmiennej tekstowej występują tylko # litery i cyfry. „isalpha()” – tylko litery, „isdecimal()” – tylko cyfry

a = tekst.count("e")

# w zmiennej "a" zapisana liczba powtórzeń "e" w zmiennej "tekst"

b = tekst.find("tek")

# zapisanie w zmiennej "b" indeksu pierwszego wystąpienia "tek" w zmiennej

# "tekst", -1 jeśli nie znaleziono

c = tekst.rfind("tek")

# indeks ostatniego wystąpienia "tek" w zmiennej "tekst", -1 jeśli nie znaleziono

d = len(tekst) # zapisanie w zmiennej "d" długość zmiennej "tekst", możliwość

# zastosowania również dla list

e = ord("a") # zapisanie w zmiennej "e" kodu ASCII dla znaku "a"

tekst = str(5) # konwersja liczby na tekst

tekst = "SzukaneSzukane"

tekst2 = tekst.replace("Szukane", "Zamiana") # zamiana "Szukane" na "Zamiana"

Praca na listach

lista = [1, 2.0, "tekst"]

del lista [2] # usunięcie trzeciego elementu listy

del lista # usuwanie listy / słownika

lista = [1, 2.0, "tekst"]

lista.clear() # czyszczenie zawartości listy / słownika, to samo co: lista = []

lista = [1, 2.0, "tekst"]

lista2 = lista.reverse() # odwracanie porządku w liście i zapis do drugiej zmiennej

lista3 = lista.copy() # skopiowanie listy

lista[0] = 3 # nadanie pierwszemu elementowi listy wartość "3"

lista.append (3) # dodanie do końca listy wartości "3",

# więcej niż 1 wartość dodaje funkcja: extend()

lista.insert(2, 10) # wstawianie liczby "10" na pozycję trzecią

print (lista[0]) # wyświetlenie pierwszego elementu listy

print (lista[-1]) # wyświetlenie ostatniego elementu listy

print (lista[0::2]) # wyświetlenie co drugiego elementu listy od pierwszej pozycji

print (min(lista)) # wyświetlenie najmniejszego elementu listy

print (max(lista)) # wyświetlenie największego elementu listy

print (lista.pop(0)) # usunięcie pierwszego elementu z listy i jego wyświetlenie

print (lista.pop()) # usunięcie ostatniego elementu z listy i jego wyświetlenie

a = lista.count(1) # zliczanie wystąpień "1" i zapisanie do zmiennej

b = lista.index(2.0) # miejsce pierwszego wystąpienia "2.0" zapisywane do zmiennej

tekst = "Nie lubię poniedziałków"

lista = tekst.split() # konwersja tekstu na listę wyrazów

lista = tekst.split(",") # konwersja tekstu na listę wyrazów, separatorem jest ","

lista = ["Marek", "Adam", "Dionizy"]

lista.sort() # sortowanie listy, podobnie działa funkcja: sorted()

lista.sort(reverse=True) # sortowanie w odwrotnej kolejności

lista = [1, 0, 0] # to samo co: lista = [True, False, False]

print (any(lista)) # Zwraca prawdę, jeśli którykolwiek z elementów jest prawdziwy.

print (all(lista)) # Zwraca prawdę, jeśli wszystkie elementy z listy są prawdziwe.

print (sum(lista)) # Zwraca sumę elementów.

List comprehension:

# tworzenie nowej listy w oparciu o inną listę w postaci bardziej kompaktowej

# składni

lista = [5, 1, 8]

lista2 = [x +1 for x in lista]

lista3 = [x +1 for x in lista if x > 1]

print (lista,"\n",lista2,"\n",lista3)

Listy mogą być zagnieżdżone i tworzyć tablice (macierze):

wysokosc, szerokosc = 2, 3

macierz = [[0 for szerokosc in range(szerokosc)] for wysokosc in range(wysokosc)]

macierz[0][0] = 1 # przypisanie wartości

print(macierz[0][0])

# Podobnie mogą być zagnieżdżone słowniki.

Wykorzystanie słowników

slownik = {"klucz1" : "wartość1", "klucz2" : "wartość2", "klucz3" : "wartość3"}

# utworzenie słownika

slownik = { # utworzenie słownika – zapis równoważny do powyższego

"klucz1" : "wartość1",

"klucz2" : "wartość2",

"klucz3" : "wartość3"

}

print (slownik.items()) # wyświetlenie wszystkich elementów słownika

print (slownik.keys()) # wyświetlenie wszystkich kluczy słownika

print (slownik.values()) # wyświetlenie wszystkich wartości słownika

print (slownik["klucz1"]) # wyświetlenie wartości dla podanego klucza,

# można też użyć funkcji: print(slownik.get("klucz1")

slownik["klucz2"] = "nowa wartość"

# przypisanie nowej wartości do podanego klucza

a = slownik.popitem() # pobranie ostatniego klucza i wartości ze słownika

slownik.update({"klucz1": "nowe"}) # aktualizacja wartości w słowniku

def funkcja(imie, wiek):

print(f"Nazywam się {imie}, mam {wiek} lat.")

slownik = {"imie": "Zenek", "wiek": 20}

funkcja(**slownik) #przekazanie kluczy ze słownika jako argumenty dla funkcji

Wykorzystanie funkcjonalności klawiatury

import keyboard

keyboard.wait("enter") # Pauzuje działanie programu do wciśnięta podanego # przycisku, np. "enter", "esc", "space".

while True:

znak = keyboard.read_key()

ascii = ord(znak[0])

# pobranie wciśniętego klawisza i wyświetlenie jego kodu ASCII

print (ascii)

if keyboard.read_key() == "space":

# wykonywanie pętli dopóki nie zostanie wciśnięta spacja

break

if keyboard.is_pressed("enter"): # Sprawdza czy wciśnięto podany klawisz.

print ("Tak")

Grafika żółwia

Proste funkcje graficzne, wzorujące się na języku Logo:

from turtle import *

screensize ("blue") # ustawienie koloru tła na niebieski

penup () # wyłączenie rysowania, to samo co: pu ()

pendown () # włączenie rysowania, to samo co: pd ()

hideturtle () # schowanie rysika (standardowo w kształcie strzałki), to samo co: ht ()

showturtle () # pokazanie rysika, to samo co: st ()

pencolor ("red") # ustawienie koloru rysowania na czerwony

# white − biały, black − czarny, grey − szary, brown − brązowy, blue − niebieski, # cyan − niebieskozielony,

# purple − fioletowy, green − zielony, yellow − żółty, orange − pomarańczowy, # pink − różowy, red − czerwony

goto (x,y) # ruch rysika do pozycji x, y

setx (x) # ustawienie współrzędnej x (poziomej) rysika

sety (y) # ustawienie współrzędnej y (pionowej) rysika

xcor () # Zwraca pozycję x rysika.

ycor () # Zwraca pozycję y rysika.

right (90) # obrót rysika o podany kąt (w stopniach) w prawo

left (45) # obrót rysika o podany kąt (w stopniach) w lewo

setheading (90) # to samo co: seth (90), ustawia kierunek rysika (w stopniach):

# 0 − wschód, 90 − północ, 180 − zachód, 270 − południe

heading () # Zwraca kierunek ruchu rysika.

forward (40) # ruch rysika o 40 pikseli do przodu, to samo co: fd (40)

backward (40) # ruch rysika o 40 pikseli do tyłu, to samo co: bk (40)

speed (0) # ustawienie szybkości rysowania, 0 (najszybciej), 1 (wolno)-10 (szybko)

pensize (40) # ustawienie grubości rysika, to samo co: width (40)

circle (40) # rysowanie okręgu o promieniu 40

dot () # rysowanie kropki

dot (2, "blue") # rysowanie kropki koloru niebieskiego o średnicy 2

undo () # cofanie ostatniego ruchu rysika

clearscreen () # czyszczenie ekranu i resetowanie ustawień rysika

begin_fill () # włączenie wypełniania kolorem rysowanego kształtu

end_fill () # zakończenie wypełniania kolorem rysowanego kształtu

fillcolor ("yellow") # wypełnianie kolorem rysowanego kształtu na żółto

onclick (funkcja)

# Wciśnięcie lewego przycisku myszy na rysiku wywoła funkcję o podanej nazwie.

onclick (funkcja2, btn=3) # Jw., tylko dotyczy prawego przycisku myszy.

write ("tekst") # wyświetlenie tekstu

write ("Tekst", move=False, align="left", font=("Arial", 8, "normal"))

# move − rysik przesuwany wraz z tekstem: "True" lub "1" (prawda), "False" lub # "0" (fałsz)

# align − wyrównanie tekstu: "left" (do lewej), "center" (do środka), "right"

# (do prawej)

# font − typ, rozmiar oraz wygląd czcionki ("normal" − standardowy, "bold" − # pogrubiony, "italic" − kursywa)

Przykład 1:

from turtle import *

# Ustawia tak koordynaty, że lewy, dolny róg mają współrzędne x = 0 i y = 0.

setworldcoordinates (0, 0, window_width(), window_height())

ht ()

pu ()

speed (0)

goto (0,0)

pd ()

fillcolor ("yellow")

begin_fill ()

fd (200)

left (90)

fd (200)

left (90)

fd (200)

left (90)

fd (200)

end_fill ()

Przykład 2:

from turtle import *

def funkcja (x, y):

dane = int(textinput("Tytuł", "Podaj dane"))

# wyświetlenie okna z polem do wprowadzenia danych

fd(dane)

def funkcja2 (x, y):

right (90)

onclick (funkcja)

onclick (funkcja2, btn=3)

Biblioteka graficzna PIL

from PIL import Image, ImageDraw, ImageFont

obraz = Image.new("RGB", (640, 480))

# utworzenie nowego obrazu, czarne tło, RGB (Red, Green, Blue) − true color

# Image.new(tryb koloru, (szerokość piksele, wysokość piksele))

obraz = Image.new("RGB", (640, 480), "white") # białe tło

obraz.putpixel((20,20), (255, 0, 0)) # putpixel((x, y), (czerwony, zielony, niebieski)), # kolory: 0-255

obraz.putpixel((21,20), (255, 0, 0))

obraz.putpixel((22,20), (255, 0, 0))

obraz.putpixel((23,20), (255, 0, 0))

obraz = Image.open ("d:\obraz.png")

# Obsługiwane są różne formaty, np. GIF, BMP, JPG, TIFF.

r, g, b = obraz.getpixel((20, 20)) # pobranie koloru piksela z x, y

print (r, g, b)

rysowanie = ImageDraw.Draw(obraz)

rysowanie.line((100,200, 150,300), fill="red") # rysowanie linii

rysowanie.line((200,200, 300,200), fill=(0, 0, 0), width=2)

# rysowanie.line((x1,y1, x2,y2), fill=kolor, width=grubość linii)

czcionka = ImageFont.truetype("arial.ttf", 20)

# ustawienie czcionki, ImageFont.truetype(nazwa czcionki, wielkość)

rysowanie.text((28, 36), "Tekst", font=czcionka, fill=(0, 0, 0))

# rysowanie tekstu, fill − kolor tekstu

obraz.save ("d:\obraz.png") # zapisanie obrazu do pliku

obraz.show() # wyświetlenie obrazu

obraz = Image.open ("d:\obraz.png") # odczytanie obrazu z pliku

Dźwięki

import winsound

winsound.Beep (2000, 100)

# generowanie prostego dźwięku, Beep(częstotliwość 37-32767, czas trwania w ms)

# odtworzenie pliku WAV

winsound.PlaySound ("a.wav", winsound.SND_FILENAME)

Biblioteka Colorama

Wykorzystuje kody ANSI (American National Standards Institute) do obsługi tekstu w terminalu. Nie działa w IDLE.

from colorama import *

init(autoreset=True)

print(Fore.RED + Back.GREEN + "Tekst")

# tekst o czerwonym kolorze i zielonym tle

# kolory: black − czarny, red − czerwony, green − zielony, yellow − żółty, blue − # niebieski, magenta − purpurowy, cyan − turkusowy, white − biały

print(Style.BRIGHT + "Tekst") # rozjaśniony tekst

print(Style.DIM + "Tekst") # przyciemniony tekst

print ("\033[1B" + "Tekst")

# kursor w dół o jedną pozycję, "\033" wprowadza znak escape

print ("\033[3C" + "Tekst") # kursor w prawo o trzy pozycje

tekst = input("Podaj tekst:")

print ("\033[2J") # czyszczenie ekranu

print ("\033[6;3H") # ustawia pozycję kursora na y = 6 i x = 3 (liczone od lewego, # górnego brzegu ekranu)

print (tekst)

Obsługa plików

Przykład 1:

plik = open("d:\\a.txt","w", encoding="utf-8")

# otwiera plik, open(nazwa pliku, tryb, kodowanie znaków – opcjonalne,

# np. "utf-8", "ascii")

# tryb: r – read (odczyt), w – write (zapis), a – append (dopisywanie), r+ – odczyt # i zapis, w+ – zapis i odczyt,

# a+ – dopisywanie i odczyt, r+b – odczyt i zapis w trybie binarnym

plik.write("tekst")

plik.write("\n") # przejście do nowej linii

plik.write("tekst2")

plik.close() # zamknięcie otwartego pliku

Przykład 2:

plik = open("d:\\a.txt","r")

tekst = plik.read() # odczytywany cały tekst, plik.read(10) – odczytuje 10 znaków

print (tekst)

plik.close()

Przykład 3:

plik = open("d:\\a.txt","r")

tekst = plik.readline() # odczytywana linijka tekstu

print (tekst)

plik.close()

Przykład 4:

import os

rozmiar = os.stat("d:\\a.txt").st_size # sprawdzenie rozmiaru pliku

print (rozmiar)

Przykład 5:

plik = open("d:\\b.txt","wb")

plik.write(b"a") # zapis w trybie binarnym znaku "a"

bajt = bytes(chr(66),"ascii")

# definiowana zmienna jednobajtowa zawierająca znak o kodzie ASCII 66

plik.write(bajt)

plik.write(b"c")

plik.write(b"d")

plik.write(b"e")

plik.seek(1,0) # ustawienie pozycji w pliku, seek(pozycja, 0-2)

# 0 − od początku pliku, 1 − od obecnej pozycji w pliku, 2 − od końca pliku

plik.write(b"b")

plik.close()

Przykład 6:

bajt = bytes(chr(0),"ascii")

plik = open("d:\\b.txt","rb")

plik.seek(1, 0)

bajt = plik.read(1)

print (ord(bajt))

plik.close()

Przykład 7:

with open("d:\\a.txt","r") as plik: # alternatywny sposób otwierania pliku

plik.read()

Obsługa błędów

try: # testowany blok kodu pod względem błędów

print (2/0)

# Błąd można też wywołać za pomocą komendy: raise FileNotFoundError

except ZeroDivisionError:

print ("Błąd - dzielenie przez zero!")

except:

print("Pojawił się inny błąd.")

finally: # Ten blok kodu zawsze jest wykonywany, można pominąć.

print("Koniec")

Uruchomienie innego skryptu

exec(open("./plik.py").read())

Wczytanie parametru z linii poleceń

import sys

if len(sys.argv) >=2:

zmienna = str(sys.argv[1])

print(zmienna)

Funkcje statystyczne

import statistics

print (statistics.fmean ([3.5, -3, 15])) # średnia arytmetyczna

print (statistics.median ([3.5, -3, 15])) # mediana

print (statistics.mode ([3, 3, 15, 3, 3, 8])) # moda (dominanta)

print (statistics.stdev ([3.5, -3, 15])) # odchylenie standardowe próbki

print (statistics.variance ([3.5, -3, 15])) # wariancja próbki

import numpy

print (numpy.mean ([3.5, -3, 15])) # średnia arytmetyczna

print (numpy.median ([3.5, -3, 15])) # mediana

print (numpy.nanstd ([3.5, -3, 15])) # odchylenie standardowe

print (numpy.var ([3.5, -3, 15])) # wariancja próbki

Biblioteka Tkinter

Biblioteka obsługująca okienka (interfejsu Tk).

Przykład:

from tkinter import *

from tkinter import messagebox, simpledialog

def wcisniecie(): # deklaracja funkcji wciśnięcia przycisku 1

przycisk.config(text="Tekst4") # zmiana etykiety przycisku 1

pole_tekstowe.insert(END, " Tekst")

# dodanie tekstu do pola tekstowego (od końca)

def wcisniecie2(): # deklaracja funkcji wciśnięcia przycisku 2

zapisane = pole_tekstowe.get("1.0", END) # pobranie danych z pola tekstowego

pole_tekstowe.delete("1.0", END)

# usunięcie całego tekstu w polu tekstowym (od 1. znaku do końca)

messagebox.showinfo("Tytuł", "Zapisane dane: " + zapisane)

# wywołanie okna informacyjnego

okno = Tk()

okno.geometry("500x500")

# utworzenie okna o podanej szerokości i długości w pikselach

okno.title("Program") # nadanie nazwy okna

tekst = Label(okno, text="Tekst", font = ("Times New Roman", 20), fg="green", \ bg = "white") # wyświetlenie tekstu, text – tekst, font – rodzaj i wielkość czcionki # (w pkt), fg – kolor tekstu (foreground), bg – kolor tła (background)

tekst.pack()

tekst.place(x=0, y=0) # umiejscowienie elementu

# utworzenie przycisku 1

przycisk = Button(okno, text="Tekst", width=10, height=3, command=wcisniecie, \ fg="green", bg = "white") # width – szerokość, height – wysokość, command – # wywołanie danej funkcji po wciśnięciu

przycisk.pack()

przycisk.place(x=0, y=100)

przycisk2 = Button(okno, text="Tekst2", command=wcisniecie2)

# utworzenie przycisku 2

przycisk2.pack()

przycisk2.place(x=100, y=100)

tekst = simpledialog.askstring("Tytuł", "Wpisz tekst: ")

# wywołanie okna z polem do wprowadzania danych (string)

# simpledialog.askfloat() – pobiera liczbę zmiennoprzecinkową

# simpledialog.askinteger() – pobiera liczbę całkowitą

pole_tekstowe = Text(okno, width = 50, height = 50, fg="blue")

# utworzenie pola tekstowego

pole_tekstowe.pack()

pole_tekstowe.place(x=0, y=200)

pole_tekstowe.insert(END, tekst)

pytanie = messagebox.askokcancel("Tytuł", "Zapytanie")

# wywołanie okna pytającego

if pytanie == True:

pole_tekstowe.insert(END, " Ok")

else:

pole_tekstowe.insert(END, " Cancel")

stan = IntVar()

zaznaczenie = Checkbutton(okno, text="Text", variable=stan)

# tworzy pole do zaznaczania

zaznaczenie.pack()

zaznaczenie.place(x=100, y=0)

zaznaczenie.toggle() # zmiana stanu zaznaczenia

if stan.get() == 1:

pole_tekstowe.insert(END, " Pole zaznaczone")

okno.mainloop()

OOP (Object-Oriented Programming)

class Obiekt: # zadeklarowanie klasy

def __init__(self, wartosc = 1): # konstruktor obiektu

self.wartosc = wartosc # nadanie parametru obiektu (instancji klasy) podczas # inicjalizacji, wartość domyślna = 1

def metoda(self, x = 1): # zdefiniowanie metody

self.wartosc = self.wartosc + x

class Obiekt2(Obiekt):

# zadeklarowanie klasy − dziedziczenie właściwości klasy "Obiekt"

def __init__ (self, wartosc2 = -2):

super().__init__() # odwołanie się do klasy nadrzędnej

self.wartosc2 = wartosc2

ob1 = Obiekt(4) # utworzenie obiektów

ob2 = Obiekt(2)

ob3 = Obiekt()

print (ob1.wartosc, ob2.wartosc, ob3.wartosc)

ob1.metoda(5) # wywołanie metody

print (ob1.wartosc)

ob4 = Obiekt2(1)

print (ob4.wartosc, ob4.wartosc2)

ob4.metoda(5)

print (ob4.wartosc)

Biblioteka Numpy – deklarowanie tablicy

import numpy

tablica1 = numpy.array([[1, 2, 3],

[4, 5, 6]])

tablica2 = numpy.full ((2, 3), "5")

# utworzenie tablicy o wysokości 2 i szerokości 3 wypełnionej wartością "5"

print (tablica1)

print (tablica2)

print ()

print (tablica1[0, 0]) # [rząd, kolumna]

print (tablica1[1, 0])

print ()

tablica1[0, 0] = 5

print (tablica1[0, 0])

Tryb tekstowy – biblioteka BearLibTerminal

from bearlibterminal import terminal

terminal.open() # otwarcie okna terminalu

terminal.set("window.title='Nazwa okna'; window.size=80x25; \ window.fullscreen=false;") # ustawienie okna terminalu

# window.size – rozmiar okna (szerokość, wysokość), window.fullscreen=false – # tryb pełnoekranowy wyłączony

terminal.refresh() # odświeżenie utworzonego okna terminalu

terminal.color(0xFFFF0000)

# ustawienie koloru tekstu na czerwony (AARRGGBB)

# A – alpha (przezroczystość), R – red  G – green, B – blue; w systemie 16

terminal.bkcolor(0xFF00FF00) # ustawienie koloru tła tekstu na zielony

terminal.printf(5, 10, 'Tekst') # wyświetlenie tekstu w danej lokalizacji (y, x)

znak = str(terminal.pick(5, 10)) # pobranie kodu znaku z danej pozycji (x , y)

kolor = str(terminal.pick_color(5, 10))

# pobranie koloru znaku z danej pozycji (x , y)

terminal.printf(5, 10, 'Tekst')

terminal.printf(5, 11, znak)

terminal.printf(5, 12, kolor)

terminal.bkcolor(0x00000000) # ustawienie koloru tła tekstu na czarny

terminal.refresh()

terminal.delay(2000) # pauza na 2000 ms

terminal.clear() # czyszczenie okna terminalu

terminal.printf(1, 1, 'Tekst2')

terminal.refresh()

terminal.delay(2000)

terminal.close() # zamknięcie okna terminalu

Jak przyspieszyć działanie skryptów Python?

Aby przyspieszyć działanie skryptów Python można wykorzystywać: słowniki, krotki, zestawy (sets) zamiast list; list comprehension zamiast pętli; wielokrotne przypisanie, wbudowane biblioteki Python, łączenie zmiennych tekstowych za pomocą funkcji „join()” (zamiast „+”), „While 1:” (zamiast „While True:”), odwołanie do funkcji bez kropki (np. „sqrt(4)” zamiast „math.sqrt(4)”), interpreter PyPy.

Typ danych „bytearray”

# Alternatywa dla stringów – mutowalne.

a = bytearray("Tekst", "ASCII")

a[2]= ord("!")

lista = [65, 65, 65]

b = bytearray(lista)

print (a.decode())

print (b.decode())

Biblioteka Pygame

Przykład 1:

import pygame

pygame.init() # zainicjowanie biblioteki

screen = pygame.display.set_mode([500, 500]) # szerokość, długość okna

pygame.display.set_caption('nazwa okna')

screen.fill((255, 255, 255)) # wypełnienie okna kolorem, RGB (0-255)

pygame.draw.circle(screen, (0, 0, 255), (250, 250), 75)

# rysowanie koła; , RGB (0-255), x, y, promień

pygame.draw.line(screen,(0, 255, 255), (0, 0), (130, 100))

# rysowanie linii; , RGB, pozycja początkowa x i y, pozycja końcowa x i y

pygame.time.wait(1000) # pauza(ms), podobnie działa: pygame.time.delay()

pygame.draw.rect(screen, (0, 255, 255), pygame.Rect(30, 30, 60, 60))

# rysowanie prostokąta; , RGB, pozycja początkowa x i y, pozycja końcowa x i y

font = pygame.font.SysFont("Courier", 24, bold=True, italic=True)

# nazwa czcionki, grubość w pkt., „bold” – pogrubienie, „italic” – kursywa

img = font.render('hello', True, (50, 50, 150)) # utworzenie tekstu; tekst, , RGB

screen.blit(img, (20, 20)) # wyświetlenie tekstu, pozycja początkowa x i y

dzwiek = pygame.mixer.Sound("d:\\a.wav") # wczytanie dźwięku

pygame.mixer.Sound.play(dzwiek) # odtworzenie dźwięku

running = True

while running:

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

pygame.display.flip() # zaktualizowanie okna

pygame.quit()

Przykład 2:

import pygame

pygame.init()

screen = pygame.display.set_mode([500, 500])

obraz = pygame.image.load("d:\\a.png").convert() # wczytanie obrazu

screen.blit(obraz, (0, 0)) # wyświetlenie obrazu, pozycja początkowa x i y

pygame.joystick.init() # zainicjowanie modułu dżojstika / pada

print (pygame.joystick.get_count()) # liczba dzojstików

joystick = pygame.joystick.Joystick(0)

joystick.init() # zainicjowanie dżojstika

running = True

while running:

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

if event.type == pygame.JOYHATMOTION:

hat = joystick.get_hat(0)

if hat == (0, 1):

print("D-pad góra")

elif hat == (0, -1):

print("D-pad dół")

elif hat == (-1, 0):

print("D-pad lewo")

elif hat == (1, 0):

print("D-pad prawo")

if event.type == pygame.JOYBUTTONDOWN:

button = event.button

if button == 0:

print("przycisk A")

elif button == 1:

print("przycisk B")

elif button == 2:

print("przycisk X")

elif button == 3:

print("przycisk Y")

elif button == 4:

print("lewy bumper")

elif button == 5:

print("prawy bumper")

elif button == 6:

print("przycisk Select")

elif button == 7:

print("przycisk Start")

pygame.display.flip()

pygame.quit()

Przykład 3:

import pygame

pygame.init()

screen = pygame.display.set_mode([500, 500])

pygame.mouse.set_visible(1) # pokazanie kursora myszy

running = True

while running:

# Zwraca pozycję kursora myszy (x, y) od lewej, górnej krawędzi.

pygame.mouse.get_pos()

pygame.mouse.set_pos(100, 200) # ustawienie pozycji kursora (x, y)

for event in pygame.event.get():

# Funkcja zwraca wciśnięte przyciski myszy. Do tego celu można również

# wykorzystać: pygame.mousebuttondown.

click = pygame.mouse.get_pressed()

if click == (1, 0, 0):

print ("Przycisk 1")

if event.type == pygame.QUIT:

running = False

if event.type == pygame.KEYDOWN:

# wykrywanie wciśnięcia przycisku na klawiaturze

if event.key == pygame.K_a:

print("Wciśnięto 'a'")

# Podobnie działa np.: K_BACKSPACE, K_RETURN, K_TAB, K_ESCAPE, # K_SPACE, K_EXCLAIM, K_HASH, K_DOLLAR, K_AMPERSAND, # K_LEFTPAREN, K_ASTERISK, K_PLUS, K_COMMA, K_MINUS, # K_PERIOD, K_SLASH, K_0, K_COLON, K_LESS, K_EQUALS, # K_GREATER, K_AT, K_LEFTBRACKET, K_BACKSLASH, # K_UNDERSCORE, K_DELETE, K_UP, K_PAGEUP, K_F1, K_NUMLOCK, # K_RSHIFT.

pygame.display.flip()

pygame.quit()

Polecenie „eval”

Wykonuje komendę Python (jeśli jest prawidłowo sformułowana).

Przykład:

polecenie = "print (2+2)"

eval(polecenie)

PySimpleGui

Prosta biblioteka do obsługi interfejsów graficznych.

Przykład:

import PySimpleGUI as sg # FreeSimpleGUI - darmowa alternatywa

uklad = [[sg.Text("Tekst", text_color = "blue", font=("Calibri", 24, "italic")),

sg.Image("d:/a.png", subsample=2)],

# "italic" - kursywa, "bold" - pogrubienie, "underline" - podkreślenie, "overstrike" -

# przekreślenie, "24"- rozmiar czcionki w pkt.

# Image - obsługiwane obrazy PNG i GIF, "subsample" - rozmiar 1/x, "zoom=2" -

# powiększenie 2x

[sg.Text("Tekst2"), sg.InputText(default_text="Standarowy tekst",

key="-Pole-", size=50)], # "key" – identyfikator, size - szerokość

[sg.Button("Ok", tooltip="pomoc", button_color = ("red", "yellow")),

sg.Button("Cancel"), sg.Checkbox("Tekst4", default=True,

key="-Opcja-"), sg.Multiline(key="-Pole2-", size=(10,3))]]

# to samo co: "[sg.Ok(), sg.Cancel()]", button_color = ("kolor tekstu", "kolor tła")

# size=szerokość,wysokość

sg.theme("Black") # opcjonalne, ustawienie kolorystyki okna, np. "Dark Blue 1",

# "Light red 1"

window = sg.Window("Nazwa okna", uklad, background_color="green")

sg.popup("Tekst3")

while True:

event, values = window.read()

if event == sg.WIN_CLOSED: break

if event == "Ok":

window.set_cursor("pencil") # inne przykłady kursora: "wait", "hand1",

# "plus"

window.refresh()

tekst = sg.popup_get_text("Podaj dane")

if event == "Cancel":

tekst = sg.popup("Koniec") # inne warianty monitów, np. "popup_get_file",

# "popup_get_folder", "popup_get_text", "popup_error", "popup_yes_no"

print("Wprowadzony tekst w polu tekstowym", values["-Pole-"],

values["-Opcja-"])

print("Wprowadzony tekst w okienku", tekst)

window.close()

Matplotlib

Biblioteka do tworzenia wykresów.

Przykład 1:

# wykres linowy

import matplotlib.pyplot as plt

import numpy as np

x = np.linspace(0, 3, 100) # utworzenie 100-elementowej tablicy danych w zakresie 0-2

fig, ax = plt.subplots()

ax.plot([1, 2, 3], [5, 10, 15], label="dane1") # dane x i y

ax.plot(x, x**2, label="dane2")

ax.set_xlabel("x etykieta")

ax.set_ylabel("y etykieta")

ax.set_title("Tytuł wykresu") # dodanie tytułu wykresu

ax.legend() # dodanie legendy do wykresu

plt.show() # wyświetlenie wykresu

Przykład 2:

# wykres kołowy

import matplotlib.pyplot as plt

etykiety = "A", "B", "C", "D"

dane = [10, 50, 20, 20]

fig, ax = plt.subplots()

ax.pie(dane, labels=etykiety)

plt.show()

Przykład 3:

# wykres słupkowy

import matplotlib.pyplot as plt

etykiety = "A", "B", "C", "D"

dane = [10, 50, 20, 20]

plt.bar(etykiety, dane, color =["green", "red", "yellow", "black"], width = 0.7)

# width – ustawienie szerokości, color – ustawienie koloru

plt.show()

Polecenie „match”

a = input("Podaj dane: ")

match a:

case "A" | "B":

print("1 lub 2")

case "C":

print("2")

case "D":

print("3")

case _: # Inny przypadek, nie pasujący do wyszczególnionych powyżej.

print("4")

a = int(input("Podaj dane liczbowe: "))

match a:

case a if a < 0:

print("< 0")

case a if a > 0:

print("> 0")

Przykładowe różnice między Python 2 i 3

2: Nie jest już rozwijany i wspierany (podobnie biblioteki) – ostatnia wersja w 2010 r.

3: Nadal rozwijany.

2: Zmienne tekstowe domyślnie kodowane jako ASCII.

3: Zmienne tekstowe domyślnie kodowane jako Unicode.

2: print "Tekst"

3: print ("Tekst")

2: Dzielenie dwóch liczb zwraca liczę całkowitą (7/2 > 3).

3: Dzielenie dwóch liczb zwraca liczę zmiennoprzecinkową (7/2 > 3,5).

2: W pętlach for stosowane polecenie: xrange().

3: W pętlach for stosowane polecenie: range().

Double-Ended Queue

# Obsługa zaawansowanych list, które łatwo modyfikować z obu stron.

from collections import deque

dq = deque(['A', 'B', 'C', 5]) # zadeklarowanie Double-Ended Queue

dq.append(6) # dodanie elementu z prawej strony, "appendleft()" - z lewej strony

dq.remove('A') # usunięcie pierwszego wystąpienia elementu

dq.rotate(1) # rotacja elementów w prawo o podaną ilość, wartość ujemna - w lewo

print (dq.pop()) # pobranie i usunięcie elementu z prawej strony,

# "popleft()" - z lewej strony

print(dq[0], ",", dq[-1], ',', len(dq)) # wyświetlenie 1. i ostatniego elementu oraz # długości listy

print (dq.count('C')) # Zlicza podany element.

print (dq.index('C')) # Podaje pozycję pierwszego wystąpienia podanego elementu.

dq.reverse() # odwrócenie listy

dq.clear() # usunięcie wszystkich elementów z listy

Biblioteka Openpyxl

# Obsługa plików Excel. Edytowane pliki nie mogą być otwarte w Excel.

import openpyxl

from openpyxl.styles import PatternFill, Font

plik = 'z:/a.xlsx'

wb = openpyxl.load_workbook(plik) # otwarcie danego pliku Excel

ws = wb.active # przejście do pierwszego arkusza w Excel

ws['A1'] = 'Text' # zapisanie do A1

ws.cell(row=2, column=2, value = '1234') # zapisanie do 2. kolumny w 2. rzędzie

ws['A1'].font = Font(name='Calibri', size=11, bold=True, italic=False, underline='single', strike=False, color='FF000000') # formatowanie danej komórki, # name - nazwa czcionki, bold - pogrubinie, italic - kursywa,

# underline - podkreślenie, strike - przekreślenie, color - kolor aRGB

# Część atrybutów można pominąć.

ws["A1"].fill = PatternFill('solid', start_color="38e3ff")

# wypełnienie tła danej komórki kolorem

print(wb.sheetnames) # wyświetlenie nazw arkuszy

ws.append(['Text2', 45, 'Text3']) # dodanie rzędu danych

ws.append(['A', 'B'])

ws['E1'] = '= AVERAGE(B2:B3)' # dodanie formuły

ws.delete_rows(4, 1) # usunięcie rzędu

# ws.delete_rows(numer rzędu, liczba rzędów do usunięcia)

print(ws.max_row, ws.max_column) # wyświetlenie liczby rzędów i kolumn

wb.create_sheet('Arkusz2') # dodanie arkusza

ws = wb['Arkusz2'] # przejście do danego arkusza

ws['A1'] = 'Text4'

wb.create_sheet('Arkusz3')

wb.copy_worksheet(wb['Arkusz3']) # utworzenie kopii arkusza

wb.remove(wb['Arkusz3']) # usunięcie danego arkusza

wb.save(plik) # zapisanie zmian

wb.close() # zamknięcie otwartego arkusza

Pyinstaller

Program ten generuje pakiety dystrybucyjne dla Windows, MacOS, Linux.

Instalacja:

pip install pyinstaller

Opcje programu:

wyświetlenie pomocy:

-help lub -h

ustawienie katalogu docelowego:

--dispatch d:\katalog

utworzenie pakietu w postaci jednego pliku:

--onefile lub -F

ustawienie ikony dla pliku wykonywalnego:

-i lub --icon

Przykładowe zastosowanie:

pyinstaller -F d:\python\skrypt.py --distpath d:\katalog

-i d:python\ikona.ico

Biblioteka Itertools

# zaawansowana obsługa iteratorów

import itertools

for a in itertools.count(start = 2, step = 3):

print(a)

if a > 10: break

print ()

b = 0

for a in itertools.cycle("123456789"):

print(a)

if b > 15: break

b+=1

Przetwarzanie równoległe

# Jednoczesne wykorzystanie więcej niż jednego rdzenia procesora.

# Nie działa w IDLE.

import multiprocessing, math, time # Biblioteka threading - alternatywa.

def funkcja1(dane1, wyjscie1):

x1 = round(math.log10(math.factorial(dane1)), 2) # silnia

wyjscie1.value = x1

def funkcja2(dane2, wyjscie2):

x2 = round(math.log10(math.factorial(dane2)), 2)

wyjscie2.value = x2

if __name__ == "__main__":

print ("Liczba rdzeni / procesorów:", multiprocessing.cpu_count())

wejscie1 = 1000000; wejscie2 = 1000000

wyjscie1 = multiprocessing.Value('d') # d - float, i - integer

wyjscie2 = multiprocessing.Value('d')

start_time = time.time()

p1 = multiprocessing.Process(target=funkcja1, args=(wejscie1, wyjscie1))

p2 = multiprocessing.Process(target=funkcja2, args=(wejscie2, wyjscie2))

# args- argumenty dla funkcji

p1.start(); p2.start() # uruchomienie dwóch funkcji jednocześnie

p1.join(); p2.join()

end_time = time.time()

print ("Czas z przetwarzaniem równoległym [s]:", round(end_time - start_time, 2))

start_time = time.time() # wykonanie dwóch funkcji jedna po drugiej

funkcja1(wejscie1, wyjscie1)

funkcja2(wejscie1, wyjscie2)

end_time = time.time()

print ("Czas bez przetwarzania równoległego [s]:", round(end_time - start_time, 2))

print (wyjscie1.value, wyjscie2.value)

Aplikacje mobilne i nie tylko – Beeware

Python nie jest optymalnym językiem programowania do zastosowania na urządzeniach z systemem Android.

Pobierz i zainstaluj GIT z "git-scm.com".

Beeware powinno samodzielnie pobrać i zainstalować pozostałe, brakujące elementy do działania (np. Android SDK).

Zainstaluj briefcase:

python -m pip install briefcase

Stworzenie nowego projektu (trzeba podać różne dane):

briefcase new

Edytuj plik "app.py" w podkatalogu "src" projektu.

Stworzenie aplikacji mobilnej (wpisz polecenie w katalogu danego projektu):

briefcase create android

Uruchomienie aplikacji mobilnej w emulatorze (chwilę trwa). Może wymagać włączenia Hyper-V w systemie (Panel sterowania > Programy > Programy i funkcje). Wpisz polecenie w katalogu danego projektu:

briefcase run android

Aplikację można też testować na Windows (w katalogu danego projektu):

briefcase dev

Skompilowanie aplikacji mobilnej do formatu apk (w katalogu danego projektu):

briefcase build android

Skopiuj plik apk na urządzenie z Androidem i zainstaluj aplikację.

Wpisując poniższe polecenia utworzy się program wykonywalny dla Windows (z rozszerzeniem "exe"):

briefcase create

briefcase build

Przykładowy program ("app.py", działa na różnych systemach):

"""

Program

"""

import toga # biblioteka z widżetami

from toga.style.pack import COLUMN, LEFT, RIGHT, ROW, Pack

def Nazwa(app): # nazwa projektu

c_box = toga.Box()

f_box = toga.Box()

box = toga.Box()

c_input = toga.TextInput(readonly=True) # pole do pobierania danych

f_input = toga.TextInput()

c_label = toga.Label("C", style=Pack(text_align=LEFT))

f_label = toga.Label("F", style=Pack(text_align=LEFT))

join_label = toga.Label("=", style=Pack(text_align=RIGHT))

def oblicz(widget):

try:

c_input.value = (float(f_input.value) - 32.0) * 5.0 / 9.0

except ValueError:

c_input.value = "???"

button = toga.Button("Napis na przycisku", on_press=oblicz)

f_box.add(f_input)

f_box.add(f_label)

c_box.add(join_label)

c_box.add(c_input)

c_box.add(c_label)

box.add(f_box)

box.add(c_box)

box.add(button)

box.style.update(direction=COLUMN, margin=10, gap=10)

f_box.style.update(direction=ROW, gap=10)

c_box.style.update(direction=ROW, gap=10)

c_input.style.update(flex=1) # flex=1 - zajmuje całą dostępną szerokość

f_input.style.update(flex=1, margin_left=210)

c_label.style.update(width=100)

f_label.style.update(width=100)

join_label.style.update(width=200)

button.style.update(margin_top=5)

return box

def main():

return toga.App(

"Program",

startup=Nazwa,

)

if __name__ == "__main__":

main().main_loop()

Biblioteki decimal i fractions

# Do przetwarzania liczb zmiennoprzecinkowych (z ustaloną dokładnością).

from decimal import *

print (1.1 + 2.2)

getcontext().prec = 3 # ograniczenie precyzji do 3 liczb znaczących

print (Decimal(1.1) + Decimal(2.2))

# Do przetwarzania liczb wymiernych (ułamków zwykłych).

from fractions import *

print (Fraction('3/7') + Fraction('1/7'))

Biblioteka pandas

# Biblioteka do obróbki i analizy danych.

import pandas as pd

dane = {

'Osobnik': ["A", "B", "C"],

'Waga': [3, 7, 2]}

moje_dane = pd.DataFrame(dane)

# utworzenie zbioru danych (dwuwymiarowa tablica)

moje_dane2 = pd.DataFrame([[1, 2], [3, 4], [5], [18, 0], [18, 0]],

index=['A', 'B', 'C', 'D', 'E'], # etykiety danych

columns=['Max', 'Min']) # etykiety kolumn

print(moje_dane)

moje_dane2.fillna({"Min": 500}, inplace=True)

# wypełnienie brakujących danych w kolumnie 'Min' wartością '500'

moje_dane2.fillna(1000, inplace = True)

# wypełnienie brakujących danych wartością '1000'

moje_dane2.dropna(inplace = True) # usunięcie wierszy z brakującymi danymi

moje_dane2.loc['B'] = [300, 400]

moje_dane2.sort_values(by='Min', ascending=False, inplace=True)

# sortowanie danych względem kolumny 'Min' od # wartości największych, # 'ascending=True' - od wartości najmniejszych (chronologicznie)

print ()

print(moje_dane2)

print ()

print (moje_dane2.loc['B']) # wyświetlenie danych dla 'B'

print ()

print (moje_dane2.loc[(moje_dane2['Max'] > 1) & (moje_dane2['Max'] < 7)])

# & - koniunkcja, | - alternatywa, ~ - negacja

print ()

print (moje_dane2.duplicated()) # Podaje informacje, które dane są zduplikowane.

moje_dane2.drop_duplicates(inplace = True) # usunięcie zduplikowanych danych

print ()

print (moje_dane2.corr())  # Wylicza korelację (Pearsona) między kolumnami.

print ()

print (moje_dane2.corr(method='spearman')) # jw., tylko korelację Spearmana

print ()

print (moje_dane2.max()) # Podaje najwyższe wartości dla kolumn.

# podobnie działają: min() - minimalna wartość, sum() - suma, mean() - średnia, # median() - mediana

print ()

print (moje_dane2.shape) # Podaje liczbę wierszy i kolumn.

print ()

print (moje_dane2.info()) # Wyświetla informacje o zbiorze danych.

# podobnie działa 'describe()' - wyświetla podstawowe parametry statystyczne

moje_dane2.to_csv('d:\\plik2.csv') # zapisanie danych do pliku CSV

moje_dane3 = pd.read_csv('d:\\plik.csv') # wczytanie danych z pliku CSV

#moje_dane4 = pd.read_json('d:\plik.json') # wczytanie danych z pliku JSON

print ('\n' * 3) # wstawienie 3 pustych linii

print (moje_dane3.head(3)) # Wyświetla trzy pierwsze wiersze.

print ()

print (moje_dane3.tail(3)) # Wyświetla trzy ostatnie wiersze.

Przykładowe programy

Przykład 1:

# wyznaczanie wartości ciągu Fibonacciego metodą iteracyjną

pozycja = int(input("Podaj pozycję w ciągu Fibonacciego: "))

if pozycja == 1:

print ("Wartość: 0"); exit

if pozycja == 2:

print ("Wartość: 1"); exit

if pozycja < 1:

exit

a = 0; b = 1; pozycja2 = 3

while pozycja2 <= pozycja:

wynik = a + b

a = b

b = wynik

pozycja2 = pozycja2 +1

print ("Wynik: ", wynik)

Przykład 2:

# generowanie liczby pseudolosowej 0-99

print ("Wciśnij 'a' w losowym momencie, 'k' aby zakończyć program.")

import keyboard

liczba = 0

while True:

liczba = liczba + 1

if keyboard.is_pressed('k'): break

if keyboard.is_pressed('a'):

print ("Losowa liczba: ", liczba)

liczba = 0

if liczba > 99: liczba = 0

Przykład 3:

# kompresja 255-bajtowych ciągów danych algorytmem BPE

# (Byte Pair Encoding)

dane_przedkompresja = "ubcdfaaabbbcccccaaaabbbbbbbcccccccddeeffffggggaaaabcdeabcdeacbdacbdabcdaaaaabbbbccccaaaaaaaabbhbaaabbaaabcabeeefgbbdddaabbaabbbccccddeeffffggggaaaabcdeabcdeacbdacbdabcdaaaaabbbbccccaaaaaaaabbhbbeeefgbbdddaaabcccccdddddeaaaaaabcccaabbccaabbaaaabbcceadbcabz"

dane_pokompresji = ""

dane_zdekompresowane = ""

# wyznaczenie znaku niewystępującego w zbiorze danych

for niewystepujacy_znak in range(0,255):

if chr(niewystepujacy_znak) not in dane_przedkompresja: break

# wyznaczenie najczęstszej pary znaków

pary = {}; max = 0; najczestsza_para = ""

for petla in range (0, 255 - 1):

para = dane_przedkompresja[petla:petla+2]

if para not in pary:

pary[para] = 1

else:

pary[para] = pary[para] + 1

if pary[para] > max:

max = pary[para]

najczestsza_para = para

# kompresja (zastąpienie najczęstszej pary znaków znakiem nie

# występującym w zbiorze danych)

dane_pokompresji = chr(niewystepujacy_znak) + najczestsza_para

# zapisanie słownika

for petla in range (0, 255, 2):

para = dane_przedkompresja[petla:petla+2]

if para == najczestsza_para:

dane_pokompresji += chr(niewystepujacy_znak)

else:

dane_pokompresji += para

# dekompresja

niewystepujacy_znak = dane_pokompresji[0]

# odczytanie słownika, pierwszy bajt z danych po kompresji

najczestsza_para = dane_pokompresji[1:3]

# drugi i trzeci bajt z danych po kompresji

for petla in range (3, len(dane_pokompresji)):

bajt = dane_pokompresji[petla]

if bajt == niewystepujacy_znak:

dane_zdekompresowane += najczestsza_para

else:

dane_zdekompresowane += bajt

# podsumowanie

if len(dane_przedkompresja) > len(dane_pokompresji):

print ("Dane po kompresji są mniejsze od wyjściowych o", len(dane_przedkompresja) - len(dane_pokompresji), "bajty.")

if dane_przedkompresja == dane_zdekompresowane:

print ("Brak błędów.")

else:

print ("Błąd. Dane poddane kompresji i zdekompresowane różnią się!")

Przykład 4:

# program zgaduje liczbę

print ("Wymyśl liczbę całkowitą w zakresie 0-100 000.")

input ("Wciśnij enter")

min = 1; max= 100000; prob = 1

import random

while True:

if min != max:

liczba = random.randrange (min,max)

else:

liczba = min

print ()

print (liczba)

pytanie = input ("Czy powyższa liczba: jest: 1- mniejsza, 2- równa, 3- większa, 0- koniec? ")

if pytanie == "0": break

if pytanie == "2":

print ("Udało się odgadnąć liczbę po próbach:", prob); break

if pytanie == "1":

max = liczba - 1

prob = prob +1

if pytanie == "3":

min = liczba +1

prob = prob +1

Przykład 5:

# sortowanie bąbelkowe danych

dane = [15, 8, 3, 150, 0]

pozycja = 0

print ("Dane przed sortowaniem:", dane)

while True:

a = dane[pozycja]

b = dane[pozycja+1]

# zamiana par danych

if a > b:

dane[pozycja] = b

dane[pozycja+1] = a

pozycja+= 1

if pozycja +1 == len(dane): pozycja = 0

# Sprawdzanie czy już koniec - czy nie ma już co zamieniać.

zmienna = 0

for petla in range(len(dane) -1):

a = dane[petla]

b = dane[petla+1]

if a > b: zmienna = 1

if zmienna == 0: break

print ("Dane po sortowaniu:", dane)

Przykład 6:

# sortowanie danych przez wstawianie

dane_przed = [15, 8, 0, 3, 150, 0, 80]

print ("Dane przed sortowaniem:", dane_przed)

dane_po=[]

dane_po.append(dane_przed.pop(0))

while True:

if len(dane_przed) == 0: break

a = dane_przed.pop(0)

najwiekszy = max(dane_po)

najmniejszy = min(dane_po)

if a >= najwiekszy:

dane_po.append(a)

elif a <= najmniejszy:

dane_po.insert (dane_po.index(najmniejszy), a)

else:

for petla in range(0, len(dane_po)):

b = dane_po[petla]

if a > b: pozycja = petla +1

if pozycja > 0:

dane_po.insert (pozycja, a)

pozycja = 0

print ("Dane po sortowaniu:", dane_po)

Przykład 7:

# algorytm Euklidesa (wyznaczania NWD - Największego Wspólnego Dzielnika)

liczby = [2000, 6000]

while liczby[0] != liczby[1]:

najmniejsza = min(liczby); najwieksza = max(liczby)

roznica = najwieksza - najmniejsza

liczby[0] = roznica

liczby[1] = najmniejsza

print ("Największy wspólny dzielnik liczb:", liczby[0])

Przykład 8:

# Ucina liczbę zmiennoprzecinkową do podanej liczby miejsc po przecinku.

liczba = 1.92324356328437452

poprzecinku = 3; liczba2 = float(str(liczba)[:poprzecinku+2])

print (liczba2)

# Wyznacza liczbę pi (stosunek obwodu koła do długości jego średnicy)

# z dokładnością do 3 miejsc po przecinku za pomocą ciągu Gregorego-Leibniza.

# Wydłużenie ciągu pozwoli zwiększyć dokładność wyznaczenia liczby pi.

pi=3+4/(2*3*4)-4/(4*5*6)+4/(6*7*8)-4/(8*9*10)+4/(10*11*12)-4/(12*13*14)+4/(14*15*16)-4/(17*18*19)

print (float(str(pi)[:poprzecinku+2]))

Przykład 9:

# proste szyfrowanie za pomocą XOR

def xor (dane, klucz):

global dane2; dane2 = ""

for petla in range(len(dane)):

dane2 += chr(ord(dane[petla]) ^ klucz) # XOR

return dane2

dane = "Tekst do szyfrowania 123!"; klucz = 45 # 0-255

print (len(dane), xor(dane, klucz))

dane = dane2

print (len(dane), xor(dane, klucz))

Przykład 10:

tekst = "To jest tekst!"

def left(tekst, ile):

return tekst[:ile]

def right(tekst, ile):

return tekst[-ile:]

def mid(tekst, offset, ile):

return tekst[offset:offset+ile]

print (left(tekst, 5))

print (right(tekst, 5))

print (mid(tekst, 3, 4))

Przykład 11:

# Program wylicza średnią.

liczba = ""; suma = 0; liczb = 0

while liczba != 'k':

liczba = input("Podaj liczbę (k - koniec): ")

if liczba != 'k':

suma += float(liczba)

liczb += 1

print ("\n", "Suma: ", suma)

print ("Liczba elementów: ", liczb)

print ("Średnia: ", suma / liczb)

Przykład 12:

import pygame, random

pygame.init()

screen = pygame.display.set_mode([500, 500])

running = True

screen.fill((255, 255, 255))

x1, y1  = random.randrange (0,500), random.randrange (0,500)

while running:

r, g, b = random.randrange (0,255), random.randrange (0,255), random.randrange (0,255)

x, y = random.randrange (0,500), random.randrange (0,500)

pygame.draw.line(screen,(r, g, b), (x1, y1), (x, y))

pygame.time.wait(250)

x1, y1 = x, y

r, g, b = random.randrange (0,255), random.randrange (0,255), random.randrange (0,255)

x, y = random.randrange (0,500), random.randrange (0,500)

pygame.draw.line(screen,(r, g, b), (x, y), (x, y))

# rysowanie piksela (ten sam efekt można osiągnąć na różne sposoby)

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

pygame.display.flip()

pygame.quit()

Przykład 13:

# Generowanie losowego ciągu liter, aż do otrzymania pożądanej frazy.

a = bytearray("000000000000000", "ASCII")

fraza = "KOT"; cykli = 0

import random

while fraza not in a.decode():

cykli += 1

pozycja = random.randrange (0, len(a.decode()))

znak = random.randrange (65, 90+1)

a[pozycja] = znak

print (cykli, a.decode())

Przykład 14:

# metoda środkowo-kwadratowa generowania liczb pseudolosowych

seed = 5489

for _ in range(5):

seed2 = str(seed**2).zfill(8)

# zfill - wypełnienie zerami od lewej do długości 8 znaków

a = seed2[4-1:8-1] # pobranie środkowych cyfr

seed = int(a)

print ("losowa liczba: ", a)

Literatura uzupełniająca

Arsen A.: „Python. Tablice informatyczne”, Helion, 2017

Bell. A.: „Python. Uczymy się programować”, Helion, 2019

Ceder N.: „Python. Szybko i prosto”, Helion, 2019

Dawson M.: „Python dla każdego. Podstawy programowania”,

Helion, 2014

Gorelick M., Ozsvald I.: „Python. Programuj szybko i wydajnie”,

Helion, 2015

Jagaciak K.: „Komputer Świat. Python: kurs programowania na

prostych przykładach”, Ringier Axel Springer Polska, 2019

Johansson R.: „Matematyczny Python. Obliczenia naukowe i analiza

danych z użyciem NumPy, SciPy i Matplotlib”, Helion, 2021

Lubanovic B.: „Python. Nowoczesne programowanie w prostych

Krokach”, Helion, 2020

Lutz M.: „Python. Leksykon kieszonkowy”, Helion, 2019

Lutz M.: „Python wprowadzenie”, Helion, 2022

Matthes E.: „Instrukcje dla programisty”, Helion, 2020

Miles R.: „Python. Zacznij programować”, Helion, 2018

Ramalho L.: „Zaawansowany Python”, Promise, 2022

Sarbicki G.: „Python. Kurs dla nauczycieli i studentów”, Helion, 2022

Severance C. R.: „Python dla wszystkich: Odkrywanie danych

z Python 3”, 2022

Szabłowicz-Zawadzka G.: „Informatyka Europejczyka. Python.

Programowanie na maturze”, Helion Edukacja, 2018

Shaw Z. A.: „Python 3. Proste wprowadzenie do fascynującego świata

Programowania”, Helion, 2018

Zimek R.: „Python na maturze. Rozwiązania i analiza wybranych

zadań programistycznych”, Helion, 2021

Przydatne linki:

https://www.python.org/

https://pypi.org/ − Python Package Index, repozytorium bibliotek

https://wiki.python.org/moin/

https://www.online-python.com/

https://www.programiz.com/python-programming/online-compiler/

https://www.onlinegdb.com/online_python_interpreter

https://www.w3schools.com/python/python_compiler.asp

https://development-tools.net/python-obfuscator/

https://pyobfuscate.com/pyd

https://www.jetbrains.com/pycharm/

https://code.visualstudio.com/

Tabela kodów ASCII 0-127

Źródło: Wikimedia Commons, plik: „ASCII-Table.svg”

Kody 0-31 są sterujące. Znaki powyżej 127 są zmienne w różnych stronach kodowych.

Spis treści

Wprowadzenie                                     2

Wybrane zalety Python                                3

Wybrane wady Python                                3

Interpreter                                            4

Przykładowe IDE i rozbudowane edytory tekstów        4

Komentarze                                            4

Operatory                                            4

Rozdzielanie komend i kodu                         5

Zmienne                                           5

Wielokrotne przypisanie                               6

Wyświetlanie danych w konsoli                          6

Minimalny program                                      6

Pobieranie danych od użytkownika                    6

Funkcje                                           7

Instrukcje warunkowe                               8

Importowanie bibliotek                              9

Instrukcje iteracyjne (pętle)                         10

Przerywanie pętli/programu                         11

Pauza i timer                                          11

Czyszczenie ekranu                                      11

Podstawowe funkcje matematyczne                    11

Generowanie liczb pseudolosowych                    12

Manipulowanie zmiennymi tekstowymi                    12

Praca na listach                                     13

Wykorzystanie słowników                                15

Wykorzystanie funkcjonalności klawiatury             15

Grafika żółwia                                     15

Biblioteka graficzna PIL                               17

Dźwięki                                           18

Biblioteka Colorama                                     18

Obsługa plików                                     19

Obsługa błędów                                    21

Uruchomienie innego skryptu                          21

Wczytanie parametru z linii poleceń                    21

Funkcje statystyczne                                21

Biblioteka Tkinter                                     22

OOP (Object-Oriented Programming)                   23

Biblioteka Numpy – deklarowanie tablicy                    24

Tryb tekstowy – biblioteka BearLibTerminal             24

Jak przyspieszyć działanie skryptów Python?             25

Typ danych „bytearray”                                25

Biblioteka Pygame                                     26

Polecenie „eval”                                    28

Biblioteka PySimpleGUI                              29

Biblioteka Matplotlib                                    29

Polecenie „match”                                    30

Przykładowe różnice między Python 2 i 3                  32

Double-Ended Queue                                    32

Biblioteka Openpyxl                                    33

Pyinstaller                                          34

Biblioteka Itertools                                    34

Przetwarzanie równoległe                              35

Aplikacje mobilne i nie tylko – Beeware                  36

Biblioteki decimal i fractions                              38

Biblioteka pandas                                    39

Przykładowe programy                              41

Literatura uzupełniająca                              50

Przydatne linki                                    51

Tabela kodów ASCII 0-127                              52

Notatki

Wydanie 4

ISBN 978-83-964183-9-5

Wydawnictwo Eclipse, Zgierz, 2025 r.