Python: Nauka Pythona

Kompleksowy przewodnik po Pythonie

👋 Witamy w dokumentacji Stackhero!

Stackhero oferuje gotowe do użycia rozwiązanie Python cloud, które zapewnia wiele korzyści, w tym:

  • Wdrażaj swoją aplikację w kilka sekund za pomocą prostego git push.
  • Używaj własnej nazwy domeny i korzystaj z automatycznej konfiguracji certyfikatów HTTPS dla zwiększonego bezpieczeństwa.
  • Ciesz się spokojem dzięki automatycznym kopiom zapasowym, aktualizacjom jednym kliknięciem oraz prostemu, przejrzystemu i przewidywalnemu cennikowi.
  • Uzyskaj optymalną wydajność i solidne zabezpieczenia dzięki prywatnej i dedykowanej VM.

Oszczędzaj czas i upraszczaj sobie życie: wypróbowanie rozwiązania Python cloud hosting Stackhero zajmuje tylko 5 minut!

Ten przewodnik oferuje przegląd podstawowych pojęć i składni Pythona. Służy jako szybkie przypomnienie dla doświadczonych programistów oraz przyjazne wprowadzenie dla początkujących. Obejmuje wszystko, od podstawowych typów danych po zaawansowane funkcje, w tym takie tematy jak przepływ sterowania, funkcje, klasy, obiekty i popularne moduły. Trzymaj go pod ręką jako szybkie odniesienie podczas pracy nad projektami w Pythonie. Pamiętaj, że Python ma rozległy ekosystem bibliotek i frameworków, więc eksploracja dodatkowych zasobów i dokumentacji pomoże Ci zgłębić specjalistyczne tematy.

Szczęśliwego kodowania!

Wprowadzenie do Pythona

Python to wszechstronny, wysokopoziomowy język programowania stworzony przez Guido van Rossuma i po raz pierwszy wydany w 1991 roku. Jest popularny ze względu na swoją czytelność i prostotę, co czyni go doskonałym wyborem zarówno dla początkujących, jak i doświadczonych programistów. Python jest szeroko stosowany w tworzeniu aplikacji internetowych, analizie danych, sztucznej inteligencji, uczeniu maszynowym i automatyzacji, wśród wielu innych obszarów.

Niektóre powszechne zastosowania Pythona obejmują tworzenie aplikacji internetowych przy użyciu frameworków takich jak Django lub Flask, analizę i wizualizację danych za pomocą bibliotek takich jak pandas i matplotlib oraz rozwijanie modeli uczenia maszynowego za pomocą narzędzi takich jak TensorFlow i scikit-learn.

Rozległa standardowa biblioteka Pythona i rozwijający się ekosystem pakietów zewnętrznych czynią go potężnym i elastycznym językiem do rozwiązywania szerokiego zakresu zadań programistycznych.

Podstawowe typy danych

Podstawowe typy danych w Pythonie obejmują liczby całkowite (liczby całkowite), liczby zmiennoprzecinkowe (liczby z przecinkami), wartości logiczne (prawda/fałsz) i ciągi znaków (sekwencje znaków):

  • int: Liczba całkowita, np. 42
  • float: Liczba zmiennoprzecinkowa, np. 3.14
  • bool: Wartość logiczna, np. True lub False
  • str: Ciąg znaków, np. "hello"

Przykład:

integer = 42
floating_point = 3.14
boolean = True
string = "Hello, World!"

Powszechne struktury danych

Python oferuje kilka struktur danych, które pomagają efektywnie organizować, przechowywać i manipulować danymi. Najczęściej używane to listy, krotki, słowniki i zbiory. Listy i krotki utrzymują uporządkowaną sekwencję elementów, słowniki przechowują pary klucz-wartość, a zbiory przechowują unikalne elementy. Każda struktura oferuje szereg metod dostosowanych do konkretnych zastosowań.

  • Lista: my_list = [1, 2, 3, 4]
  • Krotka: my_tuple = (1, 2, 3, 4)
  • Słownik: my_dictionary = {'key1': 'value1', 'key2': 'value2'}
  • Zbiór: my_set = {1, 2, 3, 4}

Listy

Listy to zmienne, uporządkowane kolekcje elementów. Pozwalają na duplikaty i mogą zawierać elementy różnych typów danych, w tym inne listy, krotki, słowniki lub zbiory. Można łatwo dodawać, aktualizować i usuwać elementy. Listy są definiowane w nawiasach kwadratowych [] z elementami oddzielonymi przecinkami.

Kluczowe punkty dotyczące list:

  1. Zmienne i uporządkowane
  2. Pozwalają na duplikaty
  3. Utrzymują kolejność dodawania elementów
  4. Obsługują wiele typów danych
  5. Oferują operacje dodawania, aktualizacji i usuwania elementów

Listy są często używane, gdy potrzebujesz dynamicznej i zmieniającej się kolekcji elementów.

Przykłady:

# Tworzenie listy
my_list = [1, 2, 3, 4, 5]

# Dostęp do elementów
print(my_list[0])  # Wynik: 1
print(my_list[-1])  # Wynik: 5

# Dodawanie elementów
my_list.append(6)
print(my_list)  # Wynik: [1, 2, 3, 4, 5, 6]

# Aktualizacja elementów
my_list[0] = 0
print(my_list)  # Wynik: [0, 2, 3, 4, 5, 6]

# Usuwanie elementów
del my_list[0]
print(my_list)  # Wynik: [2, 3, 4, 5, 6]

Słowniki

Słowniki to zmienne, nieuporządkowane kolekcje par klucz-wartość. Każdy klucz musi być unikalny, a za pomocą tych kluczy można uzyskać dostęp do powiązanych wartości. Podobnie jak listy, słowniki mogą przechowywać elementy różnych typów danych, w tym zagnieżdżone kolekcje. Są definiowane w nawiasach klamrowych {} z parami klucz-wartość oddzielonymi przecinkami, a klucze i wartości oddzielone dwukropkiem.

Kluczowe punkty dotyczące słowników:

  1. Zmienna i nieuporządkowana kolekcja
  2. Składa się z par klucz-wartość z unikalnymi kluczami
  3. Dostęp do wartości za pomocą kluczy
  4. Przechowują różne typy danych

Słowniki są idealne do zadań wymagających wyszukiwania, takich jak ustawienia konfiguracyjne lub liczniki częstotliwości.

Przykłady:

# Tworzenie słownika
my_dictionary = {'a': 1, 'b': 2, 'c': 3}

# Dostęp do elementów
print(my_dictionary['a'])  # Wynik: 1

# Dodawanie elementów
my_dictionary['d'] = 4
print(my_dictionary)  # Wynik: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# Aktualizacja elementów
my_dictionary['a'] = 0
print(my_dictionary)  # Wynik: {'a': 0, 'b': 2, 'c': 3, 'd': 4}

# Usuwanie elementów
del my_dictionary['a']
print(my_dictionary)  # Wynik: {'b': 2, 'c': 3, 'd': 4}

Krotki

Krotki to niezmienne, uporządkowane kolekcje elementów. Działają podobnie jak listy, z tym że po utworzeniu krotki jej elementy nie mogą być zmieniane, dodawane ani usuwane. Krotki są definiowane za pomocą nawiasów () z elementami oddzielonymi przecinkami.

Kluczowe punkty dotyczące krotek:

  1. Niezmienna i uporządkowana kolekcja
  2. Obsługują wiele typów danych
  3. Struktura o stałym rozmiarze

Krotki są przydatne, gdy potrzebujesz niezmiennej kolekcji lub gdy chcesz użyć kolekcji jako klucza słownika.

Przykład:

# Tworzenie krotki
my_tuple = (1, 2, 3, 4, 5)

# Dostęp do elementów
print(my_tuple[0])  # Wynik: 1
print(my_tuple[-1])  # Wynik: 5

# Uwaga: Krotki są niezmienne

Zbiory

Zbiory to zmienne, nieuporządkowane kolekcje, które przechowują unikalne elementy. Automatycznie usuwają duplikaty i nie utrzymują kolejności. Zbiory mogą zawierać elementy różnych typów danych, z wyjątkiem typów zmiennych, takich jak listy i słowniki. Mogą być definiowane za pomocą nawiasów klamrowych {} lub konstruktora set().

Kluczowe punkty dotyczące zbiorów:

  1. Zmienne i nieuporządkowane
  2. Przechowują tylko unikalne elementy, automatycznie usuwając duplikaty
  3. Wykluczają typy zmienne (jak listy i słowniki)

Zbiory są idealne do testowania członkostwa, deduplikacji i wykonywania operacji na zbiorach, takich jak suma, przecięcie i różnica.

# Tworzenie zbioru
my_set = {1, 2, 3, 4, 5}

# Sprawdzanie członkostwa
print(1 in my_set)  # Wynik: True

# Dodawanie elementu
my_set.add(6)
print(my_set)  # Wynik: {1, 2, 3, 4, 5, 6}

# Aktualizacja przez usunięcie jednego elementu i dodanie innego
my_set.remove(1)
my_set.add(0)
print(my_set)  # Wynik: {0, 2, 3, 4, 5, 6}

# Usuwanie elementu
my_set.remove(0)
print(my_set)  # Wynik: {2, 3, 4, 5, 6}

Instrukcje warunkowe: if, elif, else

Instrukcje warunkowe pozwalają na wykonanie kodu w zależności od tego, czy warunek jest prawdziwy, czy fałszywy.

if condition1:
  # zrób coś
elif condition2:
  # zrób coś innego
else:
  # zrób jeszcze coś innego

Przykład:

x = 42

if x > 50:
  print("x jest większe niż 50")
elif x < 50:
  print("x jest mniejsze niż 50")
else:
  print("x jest równe 50")

Pętla for

Pętle for iterują po sekwencji, takiej jak lista lub zakres, wykonując blok kodu dla każdego elementu.

Przykład:

for i in range(5):
  print(i)

Pętla while

Pętle while wykonują blok kodu, dopóki określony warunek jest prawdziwy.

Przykład:

i = 0
while i < 5:
  print(i)
  i += 1

Funkcje

Funkcje kapsułkują kod w bloki wielokrotnego użytku, które mogą przyjmować dane wejściowe (argumenty) i zwracać wyniki. Są definiowane za pomocą słowa kluczowego def i mogą być wywoływane po nazwie.

def function_name(argument1, argument2=default_value):
  # zrób coś
  return result

Przykład:

def add(a, b):
  return a + b

result = add(3, 4)
print(result)  # Wynik: 7

Funkcje lambda

Funkcje lambda, znane również jako funkcje anonimowe, to zwięzłe funkcje jednowyrażeniowe tworzone za pomocą słowa kluczowego lambda. Są często używane do krótkich operacji, często jako argumenty dla funkcji takich jak map(), filter(), czy sorted().

lambda arguments: expression

Przykład:

add = lambda a, b: a + b
result = add(3, 4)
print(result)  # Wynik: 7

Zrozumienia listy

Zrozumienia listy pozwalają tworzyć listy w jednej, czytelnej linii, łącząc wyrażenie z pętlą i opcjonalnym warunkiem. Są doskonałe do przekształcania lub filtrowania danych.

new_list = [expression for item in iterable if condition]

Przykład:

squares = [x * x for x in range(1, 6)]
print(squares)  # Wynik: [1, 4, 9, 16, 25]

Obsługa wyjątków

Obsługa wyjątków umożliwia programowi zarządzanie błędami w czasie wykonywania w elegancki sposób. Python zapewnia bloki try, except i finally do przechwytywania i obsługi wyjątków, zapewniając, że program kontynuuje lub kończy się płynnie.

try:
    # kod, który może wywołać wyjątek
except ExceptionType as error_variable:
    # obsługa wyjątku
finally:
    # kod do wykonania niezależnie od tego, czy wystąpił wyjątek

Przykład:

try:
  result = 10 / 0
except ZeroDivisionError:
  print("Nie można dzielić przez zero!")

Klasy i obiekty

Klasy definiują plany tworzenia obiektów w programowaniu zorientowanym obiektowo (OOP). Obiekty są instancjami klasy z atrybutami (danymi) i metodami (funkcjami), które wykonują określone zadania. OOP promuje strukturalny, wielokrotnego użytku i łatwy do utrzymania kod.

class ClassName:
  def __init__(self, attribute1, attribute2):
    self.attribute1 = attribute1
    self.attribute2 = attribute2

  def method_name(self, argument1):
    # zrób coś
    return result

Przykład:

class Dog:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def bark(self):
    print("Woof!")

# Tworzenie instancji Dog
dog1 = Dog("Buddy", 3)
dog1.bark()  # Wynik: Woof!

Importowanie modułów

Moduły to oddzielne pliki zawierające kod Pythona, takie jak funkcje, klasy lub zmienne. Importowanie modułów umożliwia rozszerzenie funkcjonalności programu poprzez użycie zewnętrznych bibliotek i frameworków.

import module_name
from module_name import specific_function_or_class

Przykład:

import math
print(math.sqrt(16))  # Wynik: 4.0

Wejście/Wyjście plików

Wejście/wyjście (I/O) plików obejmuje odczytywanie i zapisywanie plików w Pythonie. Jest to niezbędne podczas pracy z przechowywaniem i pobieraniem danych.

Odczyt pliku

with open('filename.txt', 'r') as file:
  content = file.read()

Zapis do pliku

with open('filename.txt', 'w') as file:
  file.write('content to write to the file')

Menedżery kontekstu

Menedżery kontekstu pomagają zarządzać zasobami, takimi jak pliki lub połączenia sieciowe, zapewniając, że są one prawidłowo pozyskiwane i zwalniane. Użycie menedżera kontekstu zapewnia, że Twój kod jest czystszy i bardziej odporny na błędy.

with resource as alias:
  # użyj resource jako alias

Przykład:

with open('file.txt', 'r') as file:
  content = file.read()
  print(content)  # Wynik: Hello, World!

Dekoratory

Dekoratory pozwalają rozszerzać lub modyfikować zachowanie funkcji lub klas bez zmiany ich kodu źródłowego. Owijają inną funkcję i dodają pewną funkcjonalność przed lub po wykonaniu owiniętej funkcji.

def decorator_function(func):
  def wrapper(*args, **kwargs):
    # zrób coś przed wywołaniem funkcji
    result = func(*args, **kwargs)
    # zrób coś po wywołaniu funkcji
    return result
  return wrapper

@decorator_function
def my_function():
  # zrób coś

Przykłady:

def greet_decorator(func):
  def wrapper(name):
    return "Hello, " + func(name) + "!"
  return wrapper

@greet_decorator
def get_name(name):
  return name

print(get_name("John"))  # Wynik: Hello, John!

Moduł Itertools

Moduł itertools dostarcza funkcji do tworzenia i pracy z iteratorami. Obejmuje iteratory nieskończone (takie jak count, cycle i repeat), iteratory skończone (takie jak accumulate, chain, compress) i iteratory kombinatoryczne (takie jak product, permutations i combinations).

Przykład:

import itertools

for i in itertools.count(5, 5):
  if i > 20:
    break
  print(i)  # Wynik: 5, 10, 15, 20

Moduł Collections

Moduł collections oferuje specjalistyczne typy danych kontenerów, które mogą poprawić Twoje programy.

from collections import namedtuple, defaultdict, Counter, deque

Przykłady:

from collections import namedtuple, deque, Counter, OrderedDict, defaultdict

# namedtuple
Person = namedtuple('Person', 'name age')
person1 = Person("Alice", 30)
print(person1.name, person1.age)  # Wynik: Alice 30

# deque
dq = deque([1, 2, 3, 4, 5])
dq.append(6)
dq.appendleft(0)
print(dq)  # Wynik: deque([0, 1, 2, 3, 4, 5, 6])

# Counter
count = Counter("hello world")
print(count)  # Wynik: Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

# OrderedDict
od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3
print(od)  # Wynik: OrderedDict([('a', 1), ('b', 2), ('c', 3)])

# defaultdict
dd = defaultdict(int)
dd['a'] += 1
dd['b'] += 2
print(dd)  # Wynik: defaultdict(<class 'int'>, {'a': 1, 'b': 2})

Wyrażenia regularne

Wyrażenia regularne umożliwiają zaawansowane przetwarzanie i manipulację tekstem. Moduł re dostarcza funkcji takich jak match, search, findall, finditer, split i sub.

Przykład:

import re

pattern = r'\d+'
result = re.findall(pattern, "There are 10 cats and 5 dogs.")
print(result)  # Wynik: ['10', '5']

Daty i czasy

Praca z datami i czasami jest powszechnym wymaganiem, szczególnie w analizie danych lub zadaniach planowania. Moduł datetime dostarcza klas i funkcji do pracy z datami, czasami i przedziałami.

import datetime

# datetime, date, time, timedelta, timezone

Przykłady:

from datetime import datetime, timedelta

# Aktualna data i czas
current_time = datetime.now()
print("Aktualna data i czas:", current_time)

# Niestandardowa data i czas
custom_date = datetime(2022, 12, 31, 23, 59, 59)
print("Niestandardowa data i czas:", custom_date)

# Konwersja ciągu na datetime
date_str = "2023-01-01 00:00:00"
date_obj = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print("Ciąg na datetime:", date_obj)

# Konwersja datetime na ciąg
date_str2 = date_obj.strftime("%Y-%m-%d %H:%M:%S")
print("Datetime na ciąg:", date_str2)

# Arytmetyka dat i czasów
one_day = timedelta(days=1)
yesterday = current_time - one_day
tomorrow = current_time + one_day
print("Wczoraj:", yesterday)
print("Jutro:", tomorrow)

Wycinanie listy

Wycinanie listy pozwala na wyodrębnienie części listy lub innego typu sekwencji poprzez określenie wartości początkowej, końcowej i opcjonalnego kroku. Ta funkcja jest bardzo przydatna do wyodrębniania podsekwencji.

my_list[start:end:step]

Przykład:

my_list = [0, 1, 2, 3, 4, 5]
sub_list = my_list[1:4]
print(sub_list)  # Wynik: [1, 2, 3]

Formatowanie ciągów

Formatowanie ciągów to proces łączenia statycznego tekstu z dynamicznymi wartościami. Python oferuje kilka metod formatowania, w tym formatowanie z %, metodę str.format(), i f-strings (Python 3.6+), które pozwalają łatwo generować sformatowane ciągi.

Formatowanie z %

print("Hello, %s" % name)

str.format

print("Hello, {}".format(name))

f-strings (Python 3.6+)

print(f"Hello, {name}")

Przykład:

name = "John"
age = 30
formatted_string = f"My name is {name} and I am {age} years old."
print(formatted_string)  # Wynik: My name is John and I am 30 years old.

Argumenty wiersza poleceń

Argumenty wiersza poleceń pozwalają na przekazywanie wartości wejściowych do skryptu Pythona podczas jego wykonywania z wiersza poleceń. Lista sys.argv zapewnia dostęp do tych argumentów, ułatwiając ich analizę i użycie w skrypcie.

import sys

arguments = sys.argv

Przykład:

# Zapisz ten kod w pliku o nazwie "cmd_args.py"
# Uruchom z: python cmd_args.py Alice
# Oczekiwany wynik: Hello, Alice!
import sys

if len(sys.argv) > 1:
  print(f"Hello, {sys.argv[1]}!")
else:
  print("Brak podanych argumentów.")

Other articles for Python