print("hello python")

hello python

x = 100

print(type(x))
print(id(x))

<class 'int'>
140735568356104

a = [1, 2]
b = [1, 2]

print(a == b)
print(a is b)

True
False

a = [1, 2]
a.append(3)
print(a)

s = "ab"
s += "c"
print(s)

[1, 2, 3]
abc

d = {}

# d[[1, 2]] = "value"  # TypeError: unhashable type: 'list'

d[(1, 2)] = "value"

print(d)

{(1, 2): 'value'}

value = None

if value is None:
    print("value is None")

value is None

values = ["", [], {}, 0, None, "python"]

for v in values:
    print(bool(v))

False
False
False
False
False
True

print(0 or "default")
print("python" and "ok")

default
ok

x = 1
x = "hello"

print(x)

hello

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

print(add("1", "2"))

12

s = "python"

print(s[::-1])

nohtyp

words = ["Python", "is", "good"]

print(" ".join(words))

Python is good

s = "  a,b,c  "

print(s.strip())
print(s.strip().split(","))

a,b,c
['a', 'b', 'c']

nums = [x * x for x in range(5)]

print(nums)

[0, 1, 4, 9, 16]

nums = [x for x in range(10) if x % 2 == 0]

print(nums)

[0, 2, 4, 6, 8]

a = [1, 2]
a.append([3, 4])
print(a)

b = [1, 2]
b.extend([3, 4])
print(b)

[1, 2, [3, 4]]
[1, 2, 3, 4]

a = [3, 1, 2]

b = sorted(a)

print(a)
print(b)

a.sort()
print(a)

[3, 1, 2]
[1, 2, 3]
[1, 2, 3]

t = ([1, 2], "a")

t[0].append(3)

print(t)

([1, 2, 3], 'a')

user = {"name": "vito"}

print(user.get("age"))
print(user.get("age", 18))

None
18

user = {"name": "vito", "age": 18}

for k, v in user.items():
    print(k, v)

name vito
age 18

d = {x: x * x for x in range(3)}

print(d)

{0: 0, 1: 1, 2: 4}

nums = [1, 2, 2, 3]

print(set(nums))

{1, 2, 3}

a = {1, 2, 3}
b = {3, 4}

print(a | b)
print(a & b)
print(a - b)

{1, 2, 3, 4}
{3}
{1, 2}

from collections import Counter

items = ["a", "b", "a", "c", "b", "a"]

print(Counter(items))

Counter({'a': 3, 'b': 2, 'c': 1})

from collections import Counter

items = ["a", "b", "a", "c", "b", "a"]

print(Counter(items).most_common(1))

[('a', 3)]

def demo(a, b=2, *args, **kwargs):
    print(a, b, args, kwargs)

demo(1, 3, 4, 5, name="vito")

1 3 (4, 5) {'name': 'vito'}

def add_item(item, box=[]):
    box.append(item)
    return box

print(add_item("a"))
print(add_item("b"))

['a']
['a', 'b']

def add_item(item, box=None):
    if box is None:
        box = []
    box.append(item)
    return box

print(add_item("a"))
print(add_item("b"))

['a']
['b']

def total(*args):
    return sum(args)

print(total(1, 2, 3))

6

def show(**kwargs):
    print(kwargs)

show(name="vito", age=18)

{'name': 'vito', 'age': 18}

def hello():
    return "hello"

f = hello

print(f())

hello

def apply(func, value):
    return func(value)

print(apply(abs, -10))

10

add = lambda a, b: a + b

print(add(1, 2))

3

nums = [1, 2, 3]

print(list(map(lambda x: x * 2, nums)))

[2, 4, 6]

nums = [1, 2, 3, 4]

print(list(filter(lambda x: x % 2 == 0, nums)))

[2, 4]

names = ["a", "b"]
scores = [90, 80]

print(list(zip(names, scores)))

[('a', 90), ('b', 80)]

x = "global"

def outer():
    x = "outer"

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

    inner()

outer()

inner

count = 0

def inc():
    global count
    count += 1

inc()

print(count)

1

def outer():
    count = 0

    def inner():
        nonlocal count
        count += 1
        return count

    return inner

f = outer()

print(f())
print(f())

1
2

def make_multiplier(n):
    def mul(x):
        return x * n

    return mul

double = make_multiplier(2)

print(double(5))

10

def log(func):
    def wrapper():
        print("before")
        func()
        print("after")
    return wrapper

@log
def hello():
    print("hello")

hello()

before
hello
after

from functools import wraps

def log(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@log
def hello():
    """say hello"""
    print("hello")

print(hello.__name__)
print(hello.__doc__)

hello
say hello

from functools import wraps

def repeat(n):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(2)
def say():
    print("hi")

say()

hi
hi

try:
    x = 1 / 0
except ZeroDivisionError as e:
    print("error:", e)

error: division by zero

try:
    x = 10 / 2
except ZeroDivisionError:
    print("except")
else:
    print("else:", x)
finally:
    print("finally")

else: 5.0
finally

def check_age(age):
    if age < 0:
        raise ValueError("age cannot be negative")
    return age

try:
    check_age(-1)
except ValueError as e:
    print(e)

age cannot be negative

class BusinessError(Exception):
    pass

raise BusinessError("業(yè)務(wù)異常")

BusinessError: 業(yè)務(wù)異常

try:
    int("abc")
except Exception:
    print("發(fā)生異常，但這里至少要記錄日志")

發(fā)生異常，但這里至少要記錄日志

with open("demo.txt", "w", encoding="utf-8") as f:
    f.write("hello")

class Demo:
    def __enter__(self):
        print("enter")
        return self

    def __exit__(self, exc_type, exc, tb):
        print("exit")

with Demo():
    print("running")

enter
running
exit

nums = iter([1, 2, 3])

print(next(nums))
print(next(nums))

1
2

for ch in "abc":
    print(ch)

a
b
c

def gen():
    yield 1
    yield 2

g = gen()

print(next(g))
print(next(g))

1
2

def numbers(n):
    for i in range(n):
        yield i

for x in numbers(3):
    print(x)

0
1
2

def gen():
    yield from [1, 2, 3]

print(list(gen()))

[1, 2, 3]

g = (x * x for x in range(3))

print(g)
print(list(g))

<generator object <genexpr> at 0x...>
[0, 1, 4]

class User:
    pass

u = User()

print(type(u))

<class '__main__.User'>

class User:
    def __init__(self, name):
        self.name = name

u = User("vito")

print(u.name)

vito

class User:
    role = "tester"

u1 = User()
u2 = User()

u1.name = "vito"

print(u1.role)
print(u2.role)
print(u1.name)

tester
tester
vito

class Demo:
    def ins(self):
        print("instance")

    @classmethod
    def cls_method(cls):
        print("class")

    @staticmethod
    def static_method():
        print("static")

d = Demo()

d.ins()
Demo.cls_method()
Demo.static_method()

instance
class
static

class Animal:
    def speak(self):
        print("animal speak")

class Dog(Animal):
    pass

Dog().speak()

animal speak

class Animal:
    def speak(self):
        print("animal")

class Dog(Animal):
    def speak(self):
        print("wang")

Dog().speak()

wang

class Base:
    def hello(self):
        print("base hello")

class Child(Base):
    def hello(self):
        super().hello()
        print("child hello")

Child().hello()

base hello
child hello

class A:
    def hello(self):
        print("A")

class B(A):
    pass

class C(A):
    def hello(self):
        print("C")

class D(B, C):
    pass

D().hello()
print(D.mro())

C
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

class User:
    def __str__(self):
        return "User object"

print(User())

User object

class User:
    def __repr__(self):
        return "User(name='vito')"

u = User()

print(repr(u))

User(name='vito')

class Circle:
    def __init__(self, r):
        self.r = r

    @property
    def area(self):
        return 3.14 * self.r * self.r

c = Circle(2)

print(c.area)

12.56

from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int

u = User("vito", 18)

print(u)

User(name='vito', age=18)

class User:
    __slots__ = ("name",)

u = User()
u.name = "vito"

print(u.name)

# u.age = 18  # AttributeError

vito

# demo.py
def hello():
    return "hello"

# import demo
# print(demo.hello())

def main():
    print("running main")

if __name__ == "__main__":
    main()

running main

python -m venv .venv
source .venv/bin/activate
pip install requests

python -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install requests

requests==2.32.3
pytest==8.3.2

pip install -r requirements.txt

[project]
name = "demo"
version = "0.1.0"

[tool.pytest.ini_options]
testpaths = ["tests"]

import os

os.environ["APP_ENV"] = "dev"

print(os.getenv("APP_ENV"))

dev

__all__ = ["hello"]

def hello():
    print("hello")

def hidden():
    print("hidden")

import threading
import time

def task(name):
    time.sleep(1)
    print(name, "done")

t1 = threading.Thread(target=task, args=("A",))
t2 = threading.Thread(target=task, args=("B",))

t1.start()
t2.start()

t1.join()
t2.join()

A done
B done

def cpu_task():
    return sum(i * i for i in range(100000))

print(cpu_task())

333328333350000

from multiprocessing import Pool

def square(x):
    return x * x

if __name__ == "__main__":
    with Pool(2) as pool:
        print(pool.map(square, [1, 2, 3]))

[1, 4, 9]

from multiprocessing import Process

def hello():
    print("hello")

if __name__ == "__main__":
    p = Process(target=hello)
    p.start()
    p.join()

hello

import asyncio

async def main():
    print("start")
    await asyncio.sleep(1)
    print("end")

asyncio.run(main())

start
end

import asyncio

async def fetch():
    await asyncio.sleep(1)
    return "data"

async def main():
    result = await fetch()
    print(result)

asyncio.run(main())

data

import asyncio

async def task(name):
    await asyncio.sleep(1)
    return f"{name} done"

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

asyncio.run(main())

['A done', 'B done']

import asyncio

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

asyncio.run(task())

done

import threading

count = 0
lock = threading.Lock()

def inc():
    global count
    for _ in range(10000):
        with lock:
            count += 1

threads = [threading.Thread(target=inc) for _ in range(2)]

for t in threads:
    t.start()

for t in threads:
    t.join()

print(count)

20000

from collections import defaultdict

d = defaultdict(list)

d["python"].append("good")

print(d)

defaultdict(<class 'list'>, {'python': ['good']})

from collections import deque

q = deque([1, 2])

q.appendleft(0)
q.append(3)

print(q)

deque([0, 1, 2, 3])

import heapq

nums = [5, 1, 3]

heapq.heapify(nums)

print(heapq.heappop(nums))

1

import json

s = json.dumps({"name": "vito"}, ensure_ascii=False)
print(s)

obj = json.loads(s)
print(obj["name"])

{"name": "vito"}
vito

import json
from decimal import Decimal

data = {"price": str(Decimal("10.50"))}

print(json.dumps(data))

{"price": "10.50"}

from pathlib import Path

p = Path("logs") / "app.log"

print(p)

logs/app.log

import csv

rows = [["name", "score"], ["vito", "90"]]

with open("score.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerows(rows)

with open("score.csv", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row)

{'name': 'vito', 'score': '90'}

import logging

logging.basicConfig(level=logging.INFO)

logging.info("service started")

INFO:root:service started

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

def test_add():
    assert add(1, 2) == 3

pytest test_demo.py

1 passed in 0.01s

import pytest

def div(a, b):
    return a / b

def test_div_zero():
    with pytest.raises(ZeroDivisionError):
        div(1, 0)

1 passed in 0.01s

import sys

a = [1, 2, 3]

print(sys.getsizeof(a))

88

total = sum(x * x for x in range(1000000))

print(total)

333332833333500000

import copy

a = [[1, 2], [3, 4]]

b = copy.copy(a)
c = copy.deepcopy(a)

a[0].append(99)

print(b)
print(c)

[[1, 2, 99], [3, 4]]
[[1, 2], [3, 4]]

try:
    with open("demo.txt", "r", encoding="utf-8") as f:
        print(f.read())
except FileNotFoundError:
    print("file not found")

hello

file not found

def calculate_total_price(price: float, count: int) -> float:
    return price * count

print(calculate_total_price(9.9, 3))

29.700000000000003

from typing import Sequence

def average(nums: Sequence[float]) -> float:
    if not nums:
        raise ValueError("nums cannot be empty")
    return sum(nums) / len(nums)

print(average([80, 90, 100]))

90.0