# print absolute value of an integer:
a = 100
if a >= 0:
    print(a)
else:
    print(-a)

>>> classmates = ["Michael", "Bob", "Tracy"]
>>> classmates
["Michael", "Bob", "Tracy"]

>>> classmates[0]
"Michael"

>>> classmates = ('Michael', 'Bob', 'Tracy')

>>> (1)  # 不加 `,` 的返回为整数 1
1
>>> (1,)  # 加了 `,` 才会被识别为 tuple
(1,)

>>> scores = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> scores['Michael']
95

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

(* 赋值语句 *)
assignment_stmt ::=  target_list ("=" expression_list)+
                   | target augassign expression
                   | target_list ":=" expression  (* 海象运算符 *)

(* 赋值目标 *)
target_list     ::=  target ("," target)* [","]

target          ::=  identifier
                   | "(" target_list ")"
                   | "[" target_list "]"
                   | attributeref
                   | subscription
                   | slicing
                   | "*" target  (* 解包 *)

(* 增强赋值运算符 *)
augassign       ::=  "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" 
                   | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|="

(* 表达式列表 *)
expression_list ::=  expression ("," expression)* [","]

(* 属性引用、下标、切片 *)
attributeref    ::=  primary "." identifier
subscription    ::=  primary "[" expression_list "]"
slicing         ::=  primary "[" slice_list "]"
primary         ::=  atom | attributeref | subscription | slicing | call

a = 1           # 变量 a 是一个整数
t_007 = "0007"  # 变量 t_007 是一个字符串
Answer = True   # 变量 Answer 是一个布尔值(True)

>>> a = 123 # a是整数
>>> print(a)
123
>>> a = "ABC" # a变为字符串
print(a)
ABC

int a = 123; // a是整数类型变量
a = "ABC"; // 错误：不能把字符串赋给整型变量

>>> a = "ABC"  # 创建 a 对象和 "ABC" 字符串对象，并将 a 指向 "ABC"
>>> b = a      # 创建 b 对象，将 b 指向 a 所指的对象（"ABC"）
>>> a = "XYZ"  # 创建字符串对象 "XYZ"，并将 a 重新指向 "XYZ"
>>> print(b)
ABC

PI = 3.14159265359

# 字面量表达式
42          # 值: 42
"hello"     # 值: "hello"
[1, 2, 3]   # 值: [1, 2, 3]

# 运算表达式
1 + 2 * 3   # 值: 7
a > b       # 值: True 或 False
x or y      # 值: x 或 y 的真值

# 调用表达式
len("abc")  # 值: 3
max(1, 2)   # 值: 2

# 条件表达式（三元运算符）
x if x > 0 else 0  # 值: 根据条件返回 x 或 0

# 推导式（也是表达式！）
[x*2 for x in range(3)]  # 值: [0, 2, 4]

# 赋值语句（动作：绑定名字）
x = 5                       # 没有值！不能写成 y = (x = 5)

# 控制流语句
if x > 0:                   # 动作：条件判断
    pass
for i in range(3):          # 动作：循环
    pass
while True:                 # 动作：循环
    break

# 函数/类定义语句
def foo():                  # 动作：创建函数对象并绑定名字
    pass
class Bar:                  # 动作：创建类
    pass

# 返回语句
return 42                   # 动作：从函数返回（本身不是值）

# 导入语句
import os                   # 动作：导入模块

# 异常处理
try:                        # 动作：捕获异常
    pass
except:
    pass

if_statement ::= "if" expression ":" suite
               ("elif" expression ":" suite)*
               ["else" ":" suite]

suite        ::= simple_statement | NEWLINE INDENT statement+ DEDENT
expression   ::= 条件表达式（返回布尔值或可转换为布尔值的对象）

if number >= 0:
    print("number 是非负数")
else:
    print("number 是负数")

if number > 0:
    print("number 是正数")
elif number == 0:
    print("number 等于 0")
elif number < 0:
    print("number 是负数")
else:
    print("number 类型非法")

if x:
    print('True')

value = a if condition else b

match_stmt      ::=  "match" subject_expr ":" NEWLINE INDENT case_block+ DEDENT
subject_expr    ::=  expression
case_block      ::=  "case" patterns [guard] ":" block
patterns        ::=  open_sequence_pattern | pattern
pattern         ::=  as_pattern | or_pattern
as_pattern      ::=  or_pattern "as" capture_pattern
or_pattern      ::=  closed_pattern ("|" closed_pattern)*
closed_pattern  ::=  literal_pattern | capture_pattern | wildcard_pattern
                   | value_pattern | group_pattern | sequence_pattern
                   | mapping_pattern | class_pattern

guard           ::=  "if" named_expression

def http_status(status):
    match status:
        case 200 | 201 | 202:
            return "OK"
        case 404:
            return "Not Found"
        case code if code.startswith("5") and code.isdigit():  # 守卫子句：模糊匹配所有5xx
            return "Server Error"
        case _:
            return "Unknown status"

>>> names = ['Michael', 'Bob', 'Tracy']
>>> for name in names:
...     print(name)
...
Michael
Bob
Tracy

>>> sum = 0
>>> for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
...    sum = sum + x
>>> print(sum)
55

while (condition):
    loopBody

while monkey_typing[-19:] is "William Shakespeare":
    monkey_typing = keep_typing()

for i in range(1, 101):
    print(i)
print('END')

for i in range(1, 101):
    if i > 10: # 当 i=11 时，条件满足，执行 break 语句
        break  # break 语句会结束当前循环 --+
    print(i)   #                            |
print('END')   # <--------------------------+

for i in range(1, 101):  # <-------------------------+
    if i % 2 == 0:       #                           |
        continue  # 使用 continue 语句跳过奇数循环 --+
    print(i)
print('END')

>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1

def my_abs(x):
    return x if x >= 0 else -x

def hello1():
    print("hello!")
    return None

def hello2():
    print("hello!")
    return

def hello3():
    print("hello!")

def nop():
    pass

if age >= 18:
    pass

def second_to_minute(second):
    minute = second // 60
    second = second % 60
    return minute, second  # 不用写为 (minute, second)

>>> minute, second = second_to_minute(145)  # 不用写括号
>>> print(minute, second)
2 25

>>> time = second_to_minute(145)
>>> print(time)
(2, 25)
>>> print(type(time))
<class 'tuple'>

# 基本类型
def greet(name: str) -> str:
    return f"Hello, {name}"

# 多个参数
def add(x: int, y: int) -> int:
    return x + y

# 默认参数值
def greet_with_default(name: str, greeting: str = "Hello") -> str:
    return f"{greeting}, {name}"

from typing import List, Dict, Set, Tuple

# 列表：指定元素类型
def sum_numbers(numbers: List[int]) -> int:
    return sum(numbers)

# 字典：指定键值类型
def get_user_info(users: Dict[str, int]) -> List[str]:
    return list(users.keys())

# 集合
def unique_items(items: List[int]) -> Set[int]:
    return set(items)

# 元组：固定长度，指定每个位置类型
def get_point() -> Tuple[float, float]:
    return (1.0, 2.0)

# 可变长度元组
def get_coordinates() -> Tuple[int, ...]:
    return (1, 2, 3, 4)

from typing import Optional

# 参数可能为 None
def find_user(user_id: int) -> Optional[str]:
    if user_id > 0:
        return f"User {user_id}"
    return None

# 默认值为 None 的参数
def greet_optional(name: Optional[str] = None) -> str:
    if name is None:
        return "Hello, Stranger"
    return f"Hello, {name}"

# Python 3.10+ 可用 | 语法
def find_user_new(user_id: int) -> str | None:
    pass

>>> def fact(n):
...     match n:
...         case n if n < 0:
...             print("Input cannot be negative.")
...             return None
...         case 0 | 1:
...             return 1
...         case _:
...             return n * fact(n - 1)
...
>>> fact(-100)
Input cannot be negative.
None
>>> fact(0)
1
>>> fact(1)
1
>>> fact(100)
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

def power(x):
    return x ** 2

>>> power(5)
25
>>> power(15)
225

def power(x, n):
    return x ** n

>>> power(5, 2)   # x=5, n=2
25
>>> power(5, 3)   # x=5, n=3
125

def square_and_sum(numbers):
    """接收一个可迭代对象，计算各元素的平方和"""
    return sum(n ** 2 for n in numbers)

>>> square_and_sum((1, 2, 3))      # 传入元组
14
>>> square_and_sum([1, 25, 7])     # 传入列表，函数对任意可迭代对象生效
675

def square_and_sum(*numbers):
    """接收任意个数，计算平方和"""
    print(f"type: {type(numbers)}, value: {numbers}")
    return sum(n ** 2 for n in numbers)

>>> square_and_sum(1, 25, 7)
type: <class 'tuple'>, value: (1, 25, 7)
675
>>> square_and_sum()           # 不传参，numbers 为空元组 ()
type: <class 'tuple'>, value: ()
0
>>> square_and_sum(5)          # 单参数
type: <class 'tuple'>, value: (5,)
25

def power(x, n=2):
    return x ** n

>>> power(5)
25
>>> power(5, 2)
25
>>> power(5, 3)
125

def power(x=0, n=2):
    return x ** n

>>> def power(x, n=2):
...     return x ** n
...
>>> power(2, 5)
32
>>> power(n=2, 5)
SyntaxError: positional argument follows keyword argument

>>> def add_end(L=[]):
...     L.append('END')
...     return L
...
>>> add_end([1, 2, 3])
[1, 2, 3, 'END']
>>> add_end()
['END']
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']

def person(name, age, **kw):
    print("name:", name, "age:", age, "other:", kw)

>>> person("Michael", 30)
name: Michael age: 30 other: {}

>>> person("Bob", 35, city="Beijing")
name: Bob age: 35 other: {"city": "Beijing"}
>>> person("Adam", 45, gender="M", job="Engineer")
name: Adam age: 45 other: {"gender": "M", "job": "Engineer"}

>>> extra = {"city": "Beijing", "job": "Engineer"}
>>> person("Jack", 24, **extra)
name: Jack age: 24 other: {"city": "Beijing", "job": "Engineer"}

def person(name, age, **kw):
    if 'city' in kw:
        # 有city参数
        pass
    if 'job' in kw:
        # 有job参数
        pass
    print('name:', name, 'age:', age, 'other:', kw)

>>> person('Jack', 24, city='Beijing', addr='Chaoyang', zipcode=123456)

def person(name, age, *, city, job):
    print(name, age, city, job)

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job'

def person(name, age, *, city='Beijing', job):
    print(name, age, city, job)

>>> person('Jack', 24, job='Engineer')
Jack 24 Beijing Engineer

def person(name, age, city, job):
    # 缺少 *，city和job被视为位置参数
    pass

def f1(a, b, c=0, *args, **kw):
    print(f'a={a}, b={b}, c={c}, args={args}, kw={kw}')

def f2(a, b, c=0, *, d, **kw):
    print(f'a={a}, b={b}, c={c}, d={d}, kw={kw}')

>>> f1(1, 2)
a=1, b=2, c=0, args=(), kw={}
>>> f1(1, 2, c=3)
a=1, b=2, c=3, args=(), kw={}
>>> f1(1, 2, 3, 'a', 'b')
a=1, b=2, c=3, args=('a', 'b'), kw={}
>>> f1(1, 2, 3, 'a', 'b', x=99)
a=1, b=2, c=3, args=('a', 'b'), kw={'x': 99}
>>> f2(1, 2, d=99, ext=None)
a=1, b=2, c=0, d=99, kw={'ext': None}

>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a=1, b=2, c=3, args=(4,), kw={'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)
a=1, b=2, c=3, args=(), kw={'d': 88, 'x': '#'}

def my_abs(x):
    return x if x >= 0 else -x

>>> my_abs(1, 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: my_abs() takes 1 positional argument but 2 were given

>>> my_abs('A')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in my_abs
TypeError: unorderable types: str() >= int()
>>> abs('A')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'

def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError(f"bad operand type for my_abs(): '{type(x).__name__}'")
    return x if x >= 0 else -x

>>> my_abs('A')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in my_abs
TypeError: bad operand type for my_abs(): 'str'

>>> def add_item(item, item_list=[]):  # 危险！使用了可变对象 list 作为默认值
...     item_list.append(item)
...     return id(item_list), item_list
...
>>> add_item(1)
2252960611520 [1]
>>> add_item(2)
2252960611520 [1, 2]
>>> add_item(3)
2252960611520 [1, 2, 3]
>>> add_item(3, [0])
2252973655680 [0, 3]

>>> def add_item(item, item_list=None):
...     # 每次调用创建新对象
...     if item_list is None: 
...         item_list = []
...     item_list.append(item)
...     return item_list
...
>>> add_item(1)
[1]
>>> add_item(2)
[2]
>>> add_item(3)
[3]
>>> add_item(3, [0])
[0, 3]

>>> def greet(name, age=18):
...     print(f"{name} is {age} years old.")
...
>>> greet("Alice", 20)  # 位置传参
Alice is 20 years old.
>>> greet("Bob", age=25)  # 关键字传参
Bob is 25 years old.

>>> def greet(*, name, age=18):
...     print(f"{name} is {age} years old.")
...
>>> greet("Alice", 20)  # 位置传参
TypeError: greet() takes 0 positional arguments but 2 were given
>>> greet("Bob", age=25)  # 关键字传参
TypeError: greet() takes 0 positional arguments but 1 were given
>>> greet(name="Carol", age=30)
Carol is 30 years old.

>>> def get_info(*args, **kw):
...     return args, kw
...
>>> get_info("Alice", 25, "Female", city="York", qual="master")
(('Alice', 25, 'Female'), {'city': 'York', 'qual': 'master'})

>>> def test_kwargs(**kw):
...     print(f"id(kw): {id(kw)}, value: {kw}")
...         # 重新赋值 kw，不影响外部
...         kw = {"new": "value"}
...         print(f"id(kw): {id(kw)}, value: {kw}")
...
>>> test_kwargs(type="Cat", name="Dog")
id(kw): 2154372319680, value: {'type': 'Cat', 'name': 'Dog'}
id(kw): 2154372275584, value: {'new': 'value'}

>>> def test_kwargs(**kw):
...     print(f"id(kw): {id(kw)}, value: {kw}")
...         # 修改 kw 内的可变对象，会影响外部 extra
...         kw["type"] = "Fox"
...         print(f"id(kw): {id(kw)}, value: {kw}")
...
>>> test_kwargs(type="Cat", name="Dog")
id(kw): 1832511392256, value: {'type': 'Cat', 'name': 'Dog'}
id(kw): 1832511392256, value: {'type': 'Fox', 'name': 'Dog'}

>>> from copy import deepcopy
>>> extra = {"type": "Cat", "name": "Dog"}
>>> def test_kwargs(**kw):
...     # 创建完全独立的副本
...     kw = deepcopy(kw)  # 深拷贝，彻底隔离
...     # 现在随意修改都不会影响外部
...     kw["type"] = 999
...     return kw
...
>>> result = test_kwargs(**extra)
{'type': 999, 'name': 'Dog'}
>>> print(f"id: {id(result)}, value: {result}")
id: 1637442070272, value: {'type': 999, 'name': 'Dog'}
>>> print(f"id: {id(extra)}, value: {extra}")
id: 1637442069376, value: {'type': 'Cat', 'name': 'Dog'}