Learn Python from JS/TS

let x: number = 5;
const y = "hello";
var z = true;

x: int = 5
y: str = "hello"
z = True

let arr: number[] = [1, 2, 3];
let tup: [string, number] = ["a", 1];
let obj: {name: string, age: number} = {name: "Alice", age: 25};

arr: list[int] = [1, 2, 3]
tup: tuple[str, int] = ("a", 1)
obj: dict[str, int] = {"name": "Alice", "age": 25}

function add(a: number, b: number): number { return a + b; }

(a,b) => a+b // Arrow functions

def add(a: int, b: int) -> int: return a + b

add = lambda a, b: a + b

if (x > 5) { console.log("yes"); 
} else { 
console.log("no"); 
}

if x > 5:
    print("yes")
else:
    print("no")

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

let i = 0;
while (i < 5) {
    console.log(i);
    i++;
}

const arr = [10, 20, 30];
arr.forEach((num) => {
    console.log(num);
});

for i in range(5):
    print(i)
//or
arr = [10, 20, 30]
for num in arr:
    print(num)


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

for index, value in enumerate(arr):
    print(index, value)

class Person {
    name: string;
    constructor(name: string) { this.name = name; }
    greet() { console.log("Hello " + this.name); }
}

const p1 = new Person("Alice");

console.log(p1.name);   // Output: Alice

p1.greet();  // Hello Alice

class Person:
    def __init__(self, name: str):
        self.name = name
    def greet(self):
        print("Hello " + self.name)

p1 = Person("Alice")

print(p1.name)  # Output: Alice

p1.greet()   # Hello Alice

# Unlike TS, Python lets you add attributes dynamically to objects:
p1.age = 25
print(p1.age)  # 25

class Animal {
    name: string;

    constructor(name: string) {
        this.name = name;
    }

    speak() {
        console.log(this.name + " makes a sound");
    }
}


class Dog extends Animal {
    constructor(name: string) {
        super(name); // Call parent constructor
    }

    speak() {
        console.log(this.name + " barks");
    }
}

const d = new Dog("Buddy");
d.speak();  // Buddy barks

class Animal:
    def __init__(self, name: str):
        self.name = name

    def speak(self):
        print(self.name + " makes a sound")


class Dog(Animal):
    def __init__(self, name: str):
        super().__init__(name)  # Call parent constructor

    def speak(self):
        print(self.name + " barks")

d = Dog("Buddy")
d.speak()   # Buddy barks

import { readFile } from 'fs';

export function something(){...}

from os import read

try {
    riskyOperation();
} catch (err) {
    console.error(err);
} finally {
    cleanup();
}

try:
    risky_operation()
except Exception as err:
    print(err)
finally:
    cleanup()

async function fetchData() { await fetch(url); }

import asyncio, aiohttp

async def fetch_data():
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            return await resp.text()

const arr1 = [1, 2, 3];
const arr2 = [0, ...arr1, 4];
console.log(arr2); // [0, 1, 2, 3, 4]

const obj1 = {a: 1, b: 2};
const obj2 = {...obj1, c: 3};
console.log(obj2); // {a: 1, b: 2, c: 3}

function sum(...nums: number[]): number {
    return nums.reduce((a, b) => a + b, 0);
}
console.log(sum(1, 2, 3, 4)); // 10

function printUser({name, age}: {name: string; age: number}) {
    console.log(name, age);
}
printUser({name: "Alice", age: 25});

arr1 = [1, 2, 3]
arr2 = [0, *arr1, 4]
print(arr2)  # [0, 1, 2, 3, 4]


obj1 = {"a": 1, "b": 2}
obj2 = {**obj1, "c": 3}
print(obj2)  # {'a': 1, 'b': 2, 'c': 3}

def sum_all(*nums: int) -> int:
    return sum(nums)

print(sum_all(1, 2, 3, 4))  # 10

def print_user(**kwargs):
    print(kwargs["name"], kwargs["age"])

print_user(name="Alice", age=25)

a, b, c = 1, 2, 3
print(a, b, c)  # 1 2 3

a, *rest = [1, 2, 3, 4, 5]
print(a)      # 1
print(rest)   # [2, 3, 4, 5]


user = {"name": "Alice", "age": 25}
name, age = user["name"], user["age"]
print(name, age)  # Alice 25

# 1. ABC
from abc import ABC, abstractmethod

class Person(ABC):
    @abstractmethod
    def greet(self):
        pass

class Student(Person):
    def __init__(self, name: str):
        self.name = name

    def greet(self):
        print("Hello " + self.name)

#Protocols
from typing import Protocol

class Greeter(Protocol):
    name: str
    def greet(self) -> None: ...

class Student:
    def __init__(self, name: str):
        self.name = name
    def greet(self) -> None:
        print("Hello " + self.name)

def welcome(g: Greeter):
    g.greet()

welcome(Student("Alice"))


#Duck typing
class Student:
    def __init__(self, name):
        self.name = name
    def greet(self):
        print("Hello " + self.name)

def welcome(person):
    person.greet()   # no interface needed!

welcome(Student("Alice"))

print(a)   # NameError - no hoisting
a = 5


if True:
    x = 10
print(x)   #  10 (still accessible, variables leaks out from if,while,for)


def foo():
    x = 10
    print(x)
foo()
print(x)  #  NameError x is function scoped

x = 5
def foo():
    global x 
    x = 10

foo()
print(x)  # 10

def outer():
    x = "outer"
    def inner():
        nonlocal x
        x = "inner"
    inner()
    print(x)

outer()  # inner

import asyncio

async def fetch_data():
    print("start")
    await asyncio.sleep(1)   # pauses here, gives control back to event loop
    print("end")

asyncio.run(fetch_data())

import asyncio

async def task(name):
    for i in range(3):
        print(f"{name} {i}")
        await asyncio.sleep(0.5)

async def main():
    await asyncio.gather(task("A"), task("B"))

asyncio.run(main())

A 0
B 0
A 1
B 1
A 2
B 2

import asyncio

async def task():
    await asyncio.sleep(1)
    return "done"

async def main():
    future = asyncio.create_task(task())  # returns a Future
    result = await future                  # wait for completion
    print(result)

asyncio.run(main())

done

import threading
import time

def worker(n):
    time.sleep(1)
    print(f"Worker {n} done")

threads = [threading.Thread(target=worker, args=(i,)) for i in range(3)]
[t.start() for t in threads]
[t.join() for t in threads]

from multiprocessing import Process

def worker(n):
    print(f"Worker {n} done")

processes = [Process(target=worker, args=(i,)) for i in range(3)]
[p.start() for p in processes]
[p.join() for p in processes]

import asyncio

async def task(n):
    await asyncio.sleep(1)
    print(f"Task {n} done")

async def main():
    await asyncio.gather(*(task(i) for i in range(3)))

asyncio.run(main())

function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const original = descriptor.value;
    descriptor.value = function(...args: any[]) {
        console.log(`Calling ${propertyKey} with`, args);
        return original.apply(this, args);
    }
}

class Example {
    @log
    greet(name: string) {
        console.log("Hello " + name);
    }
}

const ex = new Example();
ex.greet("Alice");
// Output:
// Calling greet with ['Alice']
// Hello Alice

def log(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__} with {args}")
        return func(*args, **kwargs)
    return wrapper

class Example:
    @log
    def greet(self, name):
        print("Hello", name)

ex = Example()
ex.greet("Alice")
# Output:
# Calling greet with (<__main__.Example object at 0x...>, 'Alice')
# Hello Alice

class Person:
    def __init__(self, name):
        self._name = name  # convention: _name = private

    @property
    def name(self):
        """Getter for name"""
        return self._name

    @name.setter
    def name(self, value):
        """Setter for name"""
        if not value:
            raise ValueError("Name cannot be empty")
        self._name = value

p = Person("Alice")
print(p.name)   # Alice (calls getter)
p.name = "Bob"  # calls setter
print(p.name)   # Bob
# p.name = ""   # raises ValueError

# Iterable example
numbers = [1, 2, 3]  # list is iterable
it = iter(numbers)   # creates iterator
print(next(it))  # 1
print(next(it))  # 2
print(next(it))  # 3
# next(it) -> StopIteration

def count_up_to(n):
    i = 1
    while i <= n:
        yield i
        i += 1

for num in count_up_to(3):
    print(num)
# Output: 1 2 3

# List comprehension (eager)
squares_list = [x*x for x in range(5)]
print(squares_list)  # [0, 1, 4, 9, 16]

# Generator expression (lazy)
squares_gen = (x*x for x in range(5))
for s in squares_gen:
    print(s)