Biến, kiểu dữ liệu và toán tử

x = 5
name = "An"
is_active = True
price = 19.99

print(type(x))         # <class 'int'>
print(type(name))      # <class 'str'>
print(type(is_active)) # <class 'bool'>

# Reassign sang type khác — runtime cho phép
x = "giờ tôi là chuỗi"
print(type(x))         # <class 'str'>

# ✅ Đúng — snake_case
user_age = 25
first_name = "An"
def calculate_total(items): ...

# ❌ Sai — camelCase (style JS/Java)
userAge = 25
def calculateTotal(items): ...

# ✅ Hằng số — UPPER_CASE (chỉ là convention, Python KHÔNG enforce)
MAX_RETRY = 3
PI = 3.14159
DEFAULT_TIMEOUT = 30

x = 2 ** 100
print(x)
# 1267650600228229401496703205376

print(type(x))
# <class 'int'>  — vẫn là int, không cần BigInt riêng

# Tính giai thừa 100 — vẫn chính xác từng chữ số
import math
print(math.factorial(100))
# 93326215443944152681699238856266700490715968264381621468592963895217...

7 + 3     # 10  — cộng
7 - 3     # 4   — trừ
7 * 3     # 21  — nhân
7 / 3     # 2.3333...  — chia (LUÔN trả float, kể cả int / int)
7 // 3    # 2   — chia lấy nguyên (floor division)
7 % 3     # 1   — chia lấy dư
7 ** 3    # 343 — luỹ thừa

# Lưu ý: // và % với số âm — Python floor về phía âm vô cực
-7 // 3   # -3  (KHÔNG phải -2 như C/Java)
-7 % 3    # 2   (luôn cùng dấu với divisor)

>>> 0.1 + 0.2
0.30000000000000004

>>> 0.1 + 0.2 == 0.3
False

# So sánh đúng — math.isclose
>>> import math
>>> math.isclose(0.1 + 0.2, 0.3)
True

# float đặc biệt
>>> float("inf")
inf
>>> float("nan")
nan
>>> float("nan") == float("nan")
False   # NaN không bằng chính nó — IEEE 754 rule

from decimal import Decimal, getcontext

# Khởi tạo từ chuỗi để tránh lỗi float lúc gõ literal
price = Decimal("19.99")
tax = Decimal("0.08")
total = price * (1 + tax)
print(total)   # 21.5892 — chính xác từng cent

# So với float — sai số tích luỹ
print(19.99 * 1.08)   # 21.589200000000002 (!!)

# Set precision toàn cục
getcontext().prec = 10
Decimal("1") / Decimal("7")   # Decimal('0.1428571429')

from fractions import Fraction

a = Fraction(1, 3)
b = Fraction(1, 6)
print(a + b)              # 1/2  — tự rút gọn
print(Fraction("0.1") + Fraction("0.2"))
# 3/10  — tránh hoàn toàn lỗi 0.30000000000000004

s = "Xin chào, Việt Nam! 🇻🇳"
print(len(s))    # đếm code point Unicode, không đếm byte
print(type(s))   # <class 'str'>

# Indexing — như array
print(s[0])     # 'X'
print(s[-1])    # '🇻🇳' (đếm từ cuối)

# Slicing — s[start:stop:step], stop loại trừ
print(s[0:3])   # 'Xin'
print(s[:3])    # 'Xin' (start mặc định = 0)
print(s[4:])    # 'chào, Việt Nam! 🇻🇳'
print(s[::-1])  # đảo ngược chuỗi

# IMMUTABLE — không sửa được ký tự
s[0] = "Y"     # TypeError: 'str' object does not support item assignment

csv = "  1, 2 ,3  ,4"
nums = [int(x.strip()) for x in csv.split(",")]
print(nums)    # [1, 2, 3, 4]

# Ngược lại — list → string
print(", ".join(str(n) for n in nums))
# "1, 2, 3, 4"

name = "An"
age = 25

# Cũ — % formatting (1990s)
"Tôi tên %s, %d tuổi" % (name, age)

# Cũ hơn chút — .format()
"Tôi tên {}, {} tuổi".format(name, age)

# Hiện đại — f-string (Python 3.6+)
print(f"Tôi tên {name}, {age} tuổi")
# Tôi tên An, 25 tuổi

# Expression bên trong
print(f"Năm sau: {age + 1}")
print(f"Tên hoa: {name.upper()}")
print(f"Là người lớn: {age >= 18}")

x = 3.14159
n = 1234567
name = "An"

# Làm tròn số thập phân
print(f"{x:.2f}")        # '3.14'
print(f"{x:.4f}")        # '3.1416'

# Phân cách hàng nghìn
print(f"{n:,}")          # '1,234,567'
print(f"{n:_}")          # '1_234_567' (Python style)

# Căn lề (mặc định 10 ký tự)
print(f"{name:>10}")     # '        An'  (căn phải)
print(f"{name:<10}")     # 'An        '  (căn trái)
print(f"{name:^10}")     # '    An    '  (căn giữa)
print(f"{name:*^10}")    # '****An****' (fill bằng *)

# Phần trăm
ratio = 0.7523
print(f"{ratio:.1%}")    # '75.2%'

# Hex / binary / octal
print(f"{255:x}")        # 'ff'
print(f"{255:#x}")       # '0xff'
print(f"{10:b}")         # '1010'

# Debug self-documenting (Python 3.8+) — in cả tên biến
print(f"{x=}")            # 'x=3.14159'

>>> isinstance(True, int)
True

>>> True == 1
True
>>> False == 0
True

>>> True + True
2
>>> True * 10
10
>>> sum([True, True, False, True])
3   # đếm True trong list — idiom Pythonic

>>> bool([])     # False ✅ (JS: true)
False
>>> bool({})     # False ✅ (JS: true)
False
>>> bool("0")    # True  (string khác empty)
True

# Pythonic check rỗng — không cần len()
items = []
if not items:
    print("không có gì")

>>> type(None)
<class 'NoneType'>

>>> a = None
>>> b = None
>>> a is b
True   # cả 2 đều trỏ vào CÙNG MỘT object None duy nhất

>>> id(a) == id(b)
True

# str — immutable
s = "hello"
s[0] = "H"          # TypeError
s = s.replace("h", "H") # tạo string MỚI, gán lại tên s

# list — mutable
xs = [1, 2, 3]
xs[0] = 99         # OK — sửa tại chỗ
xs.append(4)         # OK — sửa tại chỗ
print(xs)            # [99, 2, 3, 4]

>>> hash("hello")        # OK
-4378789663243879052
>>> hash((1, 2, 3))      # tuple immutable → OK
2528502973977326415
>>> hash([1, 2, 3])      # list mutable → lỗi
TypeError: unhashable type: 'list'

# Áp dụng — dùng tuple làm key
locations = {
    (21.0285, 105.8542): "Hà Nội",
    (10.7769, 106.7009): "TP.HCM",
}

a = [1, 2, 3]
b = a               # b trỏ CÙNG list với a, không phải copy!
b.append(4)
print(a)            # [1, 2, 3, 4]  ← a cũng đổi!!
print(a is b)       # True (cùng object)

import copy

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

# Shallow — copy top-level, nhưng nested object vẫn share
shallow = copy.copy(original)   # hoặc original[:] hoặc list(original)
shallow[0].append(99)
print(original)  # [[1, 2, 99], [3, 4]]  ← bị ảnh hưởng!

# Deep — copy cả nested
deep = copy.deepcopy(original)
deep[0].append(777)
print(original)  # [[1, 2, 99], [3, 4]]  ← không đổi
print(deep)      # [[1, 2, 99, 777], [3, 4]]

>>> 5 == 5.0
True          # giá trị toán học bằng nhau
>>> 5 is 5.0
False         # int và float là 2 object khác nhau

>>> a = [1, 2]
>>> b = [1, 2]
>>> a == b
True          # cùng nội dung
>>> a is b
False         # nhưng là 2 list khác nhau trong RAM

>>> c = a
>>> c is a
True          # giờ thì cùng object

# Substring trong string
"chao" in "xin chao"            # True
"X" in "xin chao"               # False (case-sensitive)

# Phần tử trong list / tuple
3 in [1, 2, 3]                  # True
9 in (1, 2, 3)                  # False

# Key trong dict (KHÔNG phải value)
d = {"a": 1, "b": 2}
"a" in d                          # True
1 in d                            # False (1 là value, không phải key)
1 in d.values()                   # True — check value

# Phần tử trong set
5 in {1, 3, 5}                  # True

# Phủ định — not in
"z" not in "abc"                  # True

x = 7

# Cách Pythonic — đọc như toán
if 0 < x < 10:
    print("x trong khoảng (0, 10)")

# Tương đương với:
if 0 < x and x < 10:
    ...

# NHƯNG khác ở chỗ x chỉ được evaluate 1 LẦN
# Quan trọng nếu x là expression đắt như f() hoặc có side effect
if 0 < expensive_call() < 100:  # gọi 1 lần
    ...

# Có thể chain nhiều hơn 2
if 0 <= score <= 100:
    grade = "valid"

# Trộn nhiều toán tử cũng OK
a, b, c = 1, 2, 3
print(a < b < c)        # True
print(a < b == 2)       # True (a<b AND b==2)
print(a == 1 < 10 > 3) # True

# Biến với hint
name: str = "An"
age: int = 25
prices: list[float] = [19.99, 29.99]

# Function với hint
def greet(name: str, age: int) -> str:
    return f"Xin chào {name}, {age} tuổi"

# Type không bị enforce ở runtime
age: int = "hai-mươi-lăm"   # KHÔNG lỗi! chạy bình thường
print(age)               # "hai-mươi-lăm"

# Nhưng mypy/pyright sẽ bắt:
# error: Incompatible types in assignment (str, expected int)