Основи Python для JavaScript розробників: Швидкий старт

Вступ: Перехід з JavaScript на Python

Привіт, JavaScript розробнику! Якщо ти читаєш цю статтю, ймовірно, ти вирішив розширити свій арсенал мов програмування і зацікавився Python. Це чудовий вибір! Python — одна з найпопулярніших мов у світі, яка використовується у веб-розробці (Django, Flask), аналізі даних, машинному навчанні, автоматизації та багатьох інших сферах.

Хоча JavaScript і Python мають багато спільного як високорівневі, динамічно типізовані мови, між ними є значні відмінності, які варто розуміти для швидкого та ефективного переходу. Цей посібник допоможе тобі зробити цей перехід максимально плавним, пояснюючи ключові концепції Python через призму твого досвіду з JavaScript.

Ми розглянемо:

• Синтаксис та структура коду: Відступи замість дужок.
• Типи даних: Примітиви та структури.
• Функції: Звичайні та анонімні (лямбда).
• Об'єктно-орієнтоване програмування: Класи та об'єкти.
• Модулі та імпорти: Як організований код.
• Асинхронне програмування: asyncio vs async/await.
• Поради: Як прискорити свій шлях у Python.

Поїхали!

1. Синтаксис та структура коду: Відступи — це важливо!

Перше, що кидається в очі при переході з JavaScript на Python, це відсутність фігурних дужок {} для визначення блоків коду. У Python структура коду визначається відступами (індексацією). Це означає, що кількість пробілів або табуляцій перед рядком коду є критично важливою. Зазвичай використовують 4 пробіли для відступу.

JavaScript:

if (user.isAdmin) {
    console.log("Welcome, Admin!");
    // Блок коду всередині if
} else {
    console.log("Welcome, User!");
}

function greet(name) {
    let message = `Hello, ${name}!`;
    return message;
}

Python:

if user.is_admin:
    print("Welcome, Admin!")  # Блок коду всередині if
else:
    print("Welcome, User!")

def greet(name):
    message = f"Hello, {name}!"
    return message

Ключові відмінності:

• Блоки коду: У Python використовуються відступи (зазвичай 4 пробіли) замість фігурних дужок.
• Закінчення оператора: У Python не потрібна крапка з комою ; в кінці рядка. Кожен логічний рядок — це окремий оператор.
• Змінні: Ключові слова let, const, var відсутні. Змінна створюється при першому присвоєнні значення.
• Друк у консоль: Замість console.log() використовується функція print().

2. Типи даних та їх еквіваленти

Хоча обидві мови динамічно типізовані, є відмінності у назвах та поведінці деяких типів.

JavaScript (приклади):

let num = 42;             // Number (цілі числа та числа з плаваючою комою)
let str = "Hello";        // String
let bool = true;          // Boolean
let arr = [1, 2, 3];      // Array
let obj = {name: "Alice"};// Object
let nothing = null;       // Null
let undefinedVar;         // Undefined

Python (приклади):

num_int = 42              # int (ціле число)
num_float = 3.14          # float (число з плаваючою комою)
string_var = "Hello"      # str
boolean_var = True        # bool (зверніть увагу на велику літеру)
list_var = [1, 2, 3]      # list (аналог JavaScript Array)
tuple_var = (1, 2, 3)     # tuple (незмінний список, немає прямого аналога в JS)
dict_var = {"name": "Alice"} # dict (аналог JavaScript Object)
set_var = {1, 2, 3}       # set (унікальні елементи, немає прямого аналога в JS)
none_var = None           # NoneType (аналог JavaScript null, але використовується для відсутності значення)

Ключові відмінності та нові типи:

• Number: У Python розділено на int та float.
• Array -> list: Основний динамічний масив у Python.
• Object -> dict: Основний словник (хеш-таблиця) у Python.
• null -> None: Аналог null, використовується для представлення відсутності значення.
• undefined: У Python немає прямого еквіваленту undefined. Якщо змінна не була оголошена, спроба доступу до неї викличе NameError.
• tuple: Низькісний, незмінний список. Корисно для колекцій, які не повинні змінюватися.
• set: Колекція унікальних елементів без певного порядку. Корисно для операцій над множинами (об'єднання, перетин).

3. Рядки (Strings)

Рядки у Python дуже схожі на рядки в JavaScript, але мають деякі відмінності у методах та інтерполяції.

JavaScript:

const name = "Alice";
const greeting = `Hello, ${name}!`; // Template literals
console.log(greeting);

console.log("Hello".length); // Довжина
console.log("Hello".toUpperCase()); // Верхній регістр

Python:

name = "Alice"
greeting = f"Hello, {name}!" # F-strings (форматовані рядкові літерали)
print(greeting)

print(len("Hello")) # Довжина (функція len())
print("Hello".upper()) # Верхній регістр

Ключові відмінності:

• Інтерполяція рядків: У Python використовується f-strings (форматовані рядкові літерали), які є більш сучасним та зручним способом інтерполяції, ніж старі методи (.format() або %).
• Довжина рядка: Замість властивості .length використовується вбудована функція len().
• Методи рядків: Назви методів можуть відрізнятися (наприклад, toUpperCase() -> upper()).

4. Списки (Lists) та Словники (Dictionaries)

list (список) у Python — це основний еквівалент Array у JavaScript, а dict (словник) — еквівалент Object.

Списки (Lists) - JavaScript Array

// JavaScript Array
const fruitsJs = ["apple", "banana", "cherry"];
console.log(fruitsJs[0]); // Доступ за індексом
fruitsJs.push("orange"); // Додавання елемента
console.log(fruitsJs.length); // Довжина
fruitsJs.forEach(fruit => console.log(fruit)); // Ітерація

# Python List
fruits_py = ["apple", "banana", "cherry"]
print(fruits_py[0]) # Доступ за індексом
fruits_py.append("orange") # Додавання елемента
print(len(fruits_py)) # Довжина (функція len())

for fruit in fruits_py: # Ітерація (цикл for-in)
    print(fruit)

# List Comprehension - потужний інструмент для створення нових списків
squared_numbers = [x**2 for x in [1, 2, 3, 4, 5] if x % 2 == 0]
print(squared_numbers) # [4, 16]

Ключові відмінності:

• Ітерація: У Python для ітерації використовується цикл for ... in ....
• Довжина: Використовується len().
• Методи: Аналоги push, pop, shift, unshift, splice існують, але можуть мати інші назви (наприклад, append() для додавання в кінець, extend() для додавання іншого списку, insert() для додавання за індексом, pop() для видалення з кінця або за індексом).
• List Comprehension: Надзвичайно потужна та ідіоматична конструкція Python для створення списків на основі існуючих ітерованих об'єктів. Це аналог map() та filter() разом, але часто більш читабельний та ефективний.

Словники (Dictionaries) - JavaScript Object

// JavaScript Object
const userJs = {
    name: "Bob",
    age: 30,
    city: "New York"
};
console.log(userJs.name); // Доступ до властивостей
userJs.email = "bob@example.com"; // Додавання/зміна властивостей
console.log("name" in userJs); // Перевірка наявності ключа

# Python Dictionary
user_py = {
    "name": "Bob",
    "age": 30,
    "city": "New York"
}
print(user_py["name"]) # Доступ за ключем (як у JS об'єкті з ["key"])
user_py["email"] = "bob@example.com" # Додавання/зміна значень
print("name" in user_py) # Перевірка наявності ключа (оператор in)

# Ітерація по словнику
for key, value in user_py.items():
    print(f"{key}: {value}")

Ключові відмінності:

• Доступ до значень: У Python завжди використовується синтаксис квадратних дужок dict_var["key"]. Крапковий синтаксис obj.property використовується лише для атрибутів об'єктів (класів), а не для елементів словника.
• Ітерація: Можна ітерувати по ключах (for key in dict_var:), значеннях (for value in dict_var.values():) або парах ключ-значення (for key, value in dict_var.items():).
• Dict Comprehension: Аналогічно list comprehension, можна використовувати для створення словників.

5. Умовні оператори (if/else) та Цикли (Loops)

Умовні оператори

// JavaScript
const ageJs = 20;
if (ageJs >= 18) {
    console.log("Дорослий");
} else if (ageJs < 12) {
    console.log("Дитина");
} else {
    console.log("Підліток");
}

# Python
age_py = 20
if age_py >= 18:
    print("Дорослий")
elif age_py < 12: # Зверніть увагу на elif замість else if
    print("Дитина")
else:
    print("Підліток")

Ключові відмінності:

• Відступи: Використовуються для визначення блоків.
• elif: Скорочення від else if.
• Логічні оператори: Замість && і || використовуються слова and та or. Замість ! використовується not.

  # Python логічні оператори
  is_admin = True
  is_editor = False
  
  if is_admin and not is_editor:
      print("Only admin")
  
  if is_admin or is_editor:
      print("Admin or editor")
  

Цикли

Цикл for

// JavaScript for loop
for (let i = 0; i < 5; i++) {
    console.log(i);
}

const itemsJs = ["a", "b", "c"];
for (const item of itemsJs) { // for...of для ітерації по елементах
    console.log(item);
}

# Python for loop (завжди for...in)
for i in range(5): # range(5) генерує послідовність від 0 до 4
    print(i)

items_py = ["a", "b", "c"]
for item in items_py: # Ітерація безпосередньо по елементах
    print(item)

# Ітерація з індексом (як у for (let i = 0; ...) )
for index, item in enumerate(items_py):
    print(f"Index {index}: {item}")

Ключові відмінності:

• range(): Для циклів за лічильником використовується функція range(), яка генерує послідовність чисел.
• for...in: У Python це єдиний for цикл, який ітерується по елементах будь-якого ітерованого об'єкта (списки, рядки, словники, діапазони тощо). Немає окремого for...of або традиційного for (let i = 0; ...).
• enumerate(): Функція для отримання як індексу, так і значення під час ітерації.

Цикл while

// JavaScript while loop
let countJs = 0;
while (countJs < 3) {
    console.log(countJs);
    countJs++;
}

# Python while loop
count_py = 0
while count_py < 3:
    print(count_py)
    count_py += 1 # Скорочений оператор інкременту/декременту

Ключові відмінності:

• Інкремент/декремент: У Python немає операторів ++ або --. Використовуйте скорочені оператори присвоєння, такі як += 1 або -= 1.

6. Функції та лямбда-вирази

Функції є основою обох мов, але синтаксис та деякі можливості відрізняються.

JavaScript:

// Оголошення функції
function add(a, b) {
    return a + b;
}

// Функція зі значеннями за замовчуванням
function greet(name = "Гість") {
    console.log(`Привіт, ${name}!`);
}

// Стрілкові функції (лямбда-еквівалент)
const multiply = (a, b) => a * b;

// Нескінченна кількість аргументів (Rest parameters)
function sumAll(...numbers) {
    return numbers.reduce((acc, curr) => acc + curr, 0);
}

Python:

# Оголошення функції
def add(a, b):
    return a + b

# Функція зі значеннями за замовчуванням
def greet(name="Гість"):
    print(f"Привіт, {name}!")

# Лямбда-функції (обмежені одним виразом)
multiply = lambda a, b: a * b

# Нескінченна кількість аргументів (Arbitrary Arguments, *args)
def sum_all(*numbers):
    return sum(numbers) # Вбудована функція sum()

# Аргументи по ключу (**kwargs)
def print_user_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_user_info(name="Alice", age=30, city="London")

Ключові відмінності:

• Оголошення: Використовується ключове слово def.
• Лямбда-функції: У Python лямбда-функції обмежені одним виразом (не можуть містити багаторядковий код або оператори). Це більше схоже на JavaScript стрілкові функції без фігурних дужок.
• Аргументи:
  • Значення за замовчуванням: Працюють схоже.
  • Позиційні та ключові аргументи: Python активно використовує ключові аргументи, дозволяючи передавати значення за назвою параметра.
  • *args (Arbitrary Positional Arguments): Еквівалент JavaScript rest parameters (...numbers). Збирає всі додаткові позиційні аргументи у кортеж.
  • **kwargs (Arbitrary Keyword Arguments): Унікальна для Python можливість, збирає всі додаткові ключові аргументи у словник. Дуже потужно для гнучких функцій та передачі конфігурації.
• Типові анотації (Type Hints): Хоча Python є динамічно типізованою мовою, він дозволяє додавати типові анотації для кращої читабельності, підтримки IDE та статичного аналізу коду (наприклад, за допомогою MyPy). Це не впливає на виконання, але дуже корисно для великих проектів.

  def add_numbers(a: int, b: int) -> int:
      return a + b
  
  def process_data(data: list[str]) -> None:
      for item in data:
          print(item.upper())
  

7. Об'єктно-орієнтоване програмування (ООП)

У Python ООП є центральною парадигмою. Якщо ти знайомий з класами в JavaScript (ES6+), то тобі буде легше.

JavaScript (ES6+ Classes):

class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }

    greet() {
        console.log(`Привіт, мене звати ${this.name} і мені ${this.age} років.`);
    }
}

class Employee extends Person {
    constructor(name, age, position) {
        super(name, age);
        this.position = position;
    }

    work() {
        console.log(`${this.name} працює на посаді ${this.position}.`);
    }
}

const alice = new Employee("Alice", 30, "Розробник");
alice.greet();
alice.work();

Python:

class Person:
    def __init__(self, name, age): # Конструктор
        self.name = name
        self.age = age

    def greet(self): # Метод екземпляра (self - обов'язковий перший аргумент)
        print(f"Привіт, мене звати {self.name} і мені {self.age} років.")

class Employee(Person): # Спадкування
    def __init__(self, name, age, position):
        super().__init__(name, age, position) # Виклик конструктора батьківського класу
        self.position = position

    def work(self):
        print(f"{self.name} працює на посаді {self.position}.")

alice = Employee("Alice", 30, "Розробник") # Створення об'єкта
alice.greet()
alice.work()

Ключові відмінності:

• self: В Python всі методи екземпляра класу повинні приймати self як перший аргумент. self посилається на поточний екземпляр об'єкта (аналог this в JavaScript).
• Конструктор: Називається __init__. Це спеціальний метод, який викликається при створенні нового об'єкта.
• Спадкування: Клас-нащадок вказується в дужках class Child(Parent):.
• Виклик батьківського конструктора: Використовується super().__init__().
• Приватні/захищені атрибути: У Python немає жорсткого механізму приватних полів, як у деяких інших мовах. Зазвичай використовують угоду:
  • Атрибути, що починаються з одного підкреслення (_name), вважаються "захищеними" (для внутрішнього використання, але доступні).
  • Атрибути, що починаються з двох підкреслень (__name), "манглюються" (name mangling), що робить їх складніше доступними ззовні, але це не справжня приватність.
• Декоратори: Потужна особливість Python, яка дозволяє модифікувати поведінку функцій або методів. Часто використовуються для властивостей (@property), статичних методів (@staticmethod), методів класу (@classmethod) тощо.

  class Circle:
      def __init__(self, radius):
          self._radius = radius # Захищений атрибут
  
      @property # Декоратор, що перетворює метод на геттер
      def radius(self):
          return self._radius
  
      @radius.setter # Декоратор, що перетворює метод на сеттер
      def radius(self, value):
          if value < 0:
              raise ValueError("Радіус не може бути від'ємним")
          self._radius = value
  
      @staticmethod # Декоратор для статичних методів
      def pi_value():
          return 3.14159
  
  c = Circle(5)
  print(c.radius) # Виклик геттера
  c.radius = 7    # Виклик сеттера
  print(Circle.pi_value()) # Виклик статичного методу
  

8. Модулі та імпорти

У JavaScript ми використовуємо import/export для роботи з модулями. У Python це реалізується за допомогою import.

JavaScript:

// math.js
export function add(a, b) {
    return a + b;
}

export const PI = 3.14;

// main.js
import { add, PI } from './math.js';
// Або import * as MathUtils from './math.js';

console.log(add(2, 3));
console.log(PI);

Python:

# math_operations.py
def add(a, b):
    return a + b

PI = 3.14

# main.py
import math_operations # Імпорт всього модуля
print(math_operations.add(2, 3))
print(math_operations.PI)

from math_operations import add, PI # Імпорт конкретних об'єктів
print(add(5, 7))
print(PI)

from math_operations import add as sum_func # Імпорт з перейменуванням
print(sum_func(10, 20))

Ключові відмінності:

• Файли як модулі: Кожен .py файл у Python автоматично є модулем.
• import: Ключове слово для імпорту. Можна імпортувати весь модуль або конкретні об'єкти з нього.
• as: Використовується для перейменування імпортованих об'єктів.
• Відносні імпорти: Можна використовувати для імпорту модулів всередині пакета (директорії з файлом __init__.py).

  # my_package/sub_module.py
  from .another_module import some_function # Імпорт з того ж пакета
  from ..utils import helper_function # Імпорт з батьківського пакета
  

• __init__.py: Порожній (або з кодом ініціалізації) файл __init__.py у директорії позначає її як Python-пакет, дозволяючи імпортувати модулі з неї.

9. Асинхронне програмування

У JavaScript async/await є стандартним способом роботи з асинхронністю. Python має схожу модель з asyncio.

JavaScript:

async function fetchData(url) {
    try {
        const response = await fetch(url);
        const data = await response.json();
        console.log(data);
    } catch (error) {
        console.error("Помилка:", error);
    }
}

fetchData("https://api.example.com/data");

Python (asyncio):

import asyncio
import httpx # Популярна асинхронна HTTP-бібліотека

async def fetch_data(url: str):
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(url)
            response.raise_for_status() # Викличе виняток для статусів 4xx/5xx
            data = response.json()
            print(data)
        except httpx.HTTPStatusError as e:
            print(f"HTTP помилка: {e}")
        except httpx.RequestError as e:
            print(f"Помилка запиту: {e}")

# Запуск асинхронної функції
if __name__ == "__main__":
    asyncio.run(fetch_data("https://api.example.com/data"))

Ключові відмінності:

• async def: Функції, що є корутинами, оголошуються за допомогою async def.
• await: Використовується для очікування завершення іншої корутини або асинхронної операції.
• asyncio: Вбудований фреймворк Python для асинхронного програмування. Він надає цикл подій, інструменти для роботи з корутинами, задачами, мережевими операціями тощо.
• Запуск: Для запуску головної асинхронної функції використовується asyncio.run().
• Бібліотеки: Для асинхронних HTTP-запитів часто використовують httpx, для роботи з базами даних — асинхронні драйвери (наприклад, asyncpg для PostgreSQL).

10. Поради для переходу

1. Використовуй віртуальні середовища (venv): Це стандартна практика в Python. Віртуальні середовища дозволяють ізолювати залежності проекту, уникаючи конфліктів.

   python3 -m venv myenv         # Створити віртуальне середовище
   source myenv/bin/activate    # Активувати (Linux/macOS)
   # myenv\Scripts\activate   # Активувати (Windows)
   pip install package_name     # Встановлення пакетів
   deactivate                   # Деактивувати
   

2. Менеджери пакетів pip: Еквівалент npm або yarn у JavaScript.

   pip install requests         # Встановити пакет
   pip install -r requirements.txt # Встановити пакети зі списку
   pip freeze > requirements.txt # Зберегти встановлені пакети
   

3. Читайте PEP 8: Це офіційний посібник зі стилю коду Python. Дотримання його зробить ваш код читабельним для інших Python-розробників.
4. Використовуйте PyCharm або VS Code з Python розширенням: Ці IDE мають відмінну підтримку Python, включаючи автодоповнення, відлагодження, рефакторинг та інтеграцію з віртуальними середовищами.
5. Пам'ятайте про ідіоматичний Python (Pythonic way): Кожна мова має свої унікальні підходи до вирішення проблем. Не намагайтеся писати Python як JavaScript. Наприклад, використовуйте list comprehensions, for-in цикли замість індексованих for циклів, context managers (with оператор) для роботи з файлами та ресурсами.
6. Використовуйте типові анотації (Type Hints): Це значно покращить читабельність та підтримуваність вашого коду, особливо у великих проектах.

Висновок

Перехід з JavaScript на Python — це захоплююча подорож, яка відкриє тобі нові можливості у світі програмування. Хоча є відмінності у синтаксисі та філософії, базові концепції програмування залишаються незмінними.

Пам'ятай про ключові моменти: відступи замість дужок, list та dict замість Array та Object, def для функцій та класів, self у методах класу, а також потужність f-strings та list comprehensions.

Не бійся експериментувати, пиши багато коду, читай документацію та вивчай приклади ідіоматичного Python. Успіхів тобі у освоєнні нової мови!