Python note

def add(a, b):
    """
    这是一个加法函数

    Args:
        a: 第一个加数
        b: 第二个加数

    Returns:
        两个数的和
    """
    return a + b

# 无穷大，无穷小 float("inf") 和 float("-inf")。这两个值分别对应数学世界里的正负无穷大。
# 当它们和任意数值做比较时，满足这样的规律：float("-inf") < 任意数值 < float("inf")。
print(float("-inf") < 9 < float("inf"))
 
def sort_users_inf(users):

    def key_func(username):
        age = users[username]
        # 当年龄为空时，返回正无穷大作为 key，因此就会被排到最后
        return age if age is not None else float('inf')

    return sorted(users.keys(), key=key_func)

users = {"tom": 19, "jenny": 13, "jack": None, "andrew": 43}
print(sort_users_inf(users))
 

x = float(input('x = '))
if x > 1:
    y = 3 * x - 5
elif x >= -1:
    y = x + 2
else:
    y = 5 * x + 3
print(f'f({x}) = {y}')

total = 0
for x in range(2, 101, 2):
    total += x
print(total)

import random

targetNumber = random.randint(1, 100)

while True:
    guess = int(input("请输入1-100的数字: "))
    if guess < targetNumber:
        print("小了")
    elif guess > targetNumber:
        print("大了")
    else:
        print("你猜对了")
        break

my_list = list('hello list')
print(my_list) ## 因为字符串是可迭代的，所以构造了单个字符的list

my_list_num = list(range(10))
print(my_list_num)

items1 = [35, 12, 99, 68, 55, 87]
items2 = [45, 8, 29]

# 列表的拼接
items3 = items1 + items2
print(items3)    # [35, 12, 99, 68, 55, 87, 45, 8, 29]

# 列表的重复
items4 = ['hello'] * 3
print(items4)    # ['hello', 'hello', 'hello']

# 列表的成员运算
print(100 in items3)        # False
print('hello' in items4)    # True

# 获取列表的长度(元素个数)
size = len(items3)
print(size)                 # 9

# 列表的索引
print(items3[0], items3[-size])        # 35 35
items3[-1] = 100
print(items3[size - 1], items3[-1])    # 100 100

# 列表的切片
#  origin list : [35, 12, 99, 68, 55, 87,45, 8, 29,100]
print(items3[:5])          # [35, 12, 99, 68, 55]
print(items3[4:])          # [55, 87, 45, 8,29, 100]
print(items3[-5:-7:-1])    # [87, 55]
print(items3[::-2])        # [100, 45, 55, 99, 35]

# 列表的比较运算
items5 = [1, 2, 3, 4]
items6 = list(range(1, 5))
# 两个列表比较相等性比的是对应索引位置上的元素是否相等
print(items5 == items6)    # True
items7 = [3, 2, 1]
# 两个列表比较大小比的是对应索引位置上的元素的大小
print(items5 <= items7)    # True

items = ['Python', 'Java', 'Go', 'Kotlin']

# 使用append方法在列表尾部添加元素
items.append('Swift')
print(items)    # ['Python', 'Java', 'Go', 'Kotlin', 'Swift']
# 使用insert方法在列表指定索引位置插入元素
items.insert(2, 'SQL')
print(items)    # ['Python', 'Java', 'SQL', 'Go', 'Kotlin', 'Swift']

# 删除指定的元素
items.remove('Java')
print(items)    # ['Python', 'SQL', 'Go', 'Kotlin', 'Swift']
# 删除指定索引位置的元素
items.pop(0)
items.pop(len(items) - 1)
print(items)    # ['SQL', 'Go', 'Kotlin']

# 清空列表中的元素
items.clear()
print(items)    # []

# 创建一个由1到9的数字构成的列表
items1 = [x for x in range(1, 10)]
print(items1)    # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 创建一个由'hello world'中除空格和元音字母外的字符构成的列表
items2 = [x for x in 'hello world' if x not in ' aeiou']
print(items2)    # ['h', 'l', 'l', 'w', 'r', 'l', 'd']

# 创建一个由个两个字符串中字符的笛卡尔积构成的列表
items3 = [x + y for x in 'ABC' for y in '12']
print(items3)    # ['A1', 'A2', 'B1', 'B2', 'C1', 'C2']

scores = [[0] * 3] * 5
print(scores)    # [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]
# 嵌套的列表需要多次索引操作才能获取元素
scores[0][0] = 95
print(scores)
# [[95, 0, 0], [95, 0, 0], [95, 0, 0], [95, 0, 0], [95, 0, 0]]

scores = [[0] * 3 for _ in range(5)]
scores[0][0] = 95
print(scores)
# [[95, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

# 空元组
a = ()
print(type(a))    # <class 'tuple'>
# 不是元组
b = ('hello')
print(type(b))    # <class 'str'>
c = (100)
print(type(c))    # <class 'int'>
# 一元组
d = ('hello', )
print(type(d))    # <class 'tuple'>
e = (100, )
print(type(e))    # <class 'tuple'>
# 接收iterable 对象
f = tuple('hello')
print(f)

# 打包
a = 1, 10, 100
print(type(a), a)    # <class 'tuple'> (1, 10, 100)
# 解包
i, j, k = a
print(i, j, k)       # 1 10 100

a = 1, 10, 100, 1000
i, j, *k = a
print(i, j, k)          # 1 10 [100, 1000]
i, *j, k = a
print(i, j, k)          # 1 [10, 100] 1000
*i, j, k = a
print(i, j, k)          # [1, 10] 100 1000
*i, j = a
print(i, j)             # [1, 10, 100] 1000
i, *j = a
print(i, j)             # 1 [10, 100, 1000]
i, j, k, *l = a
print(i, j, k, l)       # 1 10 100 [1000]
i, j, k, l, *m = a
print(i, j, k, l, m)    # 1 10 100 1000 []

# 将元组转换成列表
info = ('骆昊', 175, True, '四川成都')
print(list(info))       # ['骆昊', 175, True, '四川成都']
# 将列表转换成元组
fruits = ['apple', 'banana', 'orange']
print(tuple(fruits))    # ('apple', 'banana', 'orange')

# 忽略展开时的第二个变量
author, _ = usernames

# 忽略第一个和最后一个变量之间的所有变量
username, *_, score = data

s1 = 'hello, world!'
s2 = "你好，世界！"
print(s1, s2)
# 以三个双引号或单引号开头的字符串可以折行
s3 = '''
hello, 
world!
'''
print(s3, end='')

# 字符串s2中没有转义字符，每个字符都是原始含义
s2 = r'\time up \now'
print(s2)

s1 = 'hello world'
s2 = 'hello world'
s3 = s2
# 比较字符串的内容
print(s1 == s2, s2 == s3)    # True True
# 比较字符串的内存地址
print(s1 is s2, s2 is s3)    # False True

s = 'abc123456'

# i=2, j=5, k=1的正向切片操作
print(s[2:5])     # c12

# i=-7, j=-4, k=1的正向切片操作
print(s[-7:-4])   # c12

# i=2, j=9, k=1的正向切片操作
print(s[2:])      # c123456

# i=-7, j=9, k=1的正向切片操作
print(s[-7:])     # c123456

# i=2, j=9, k=2的正向切片操作
print(s[2::2])    # c246

# i=-7, j=9, k=2的正向切片操作
print(s[-7::2])   # c246

# i=0, j=9, k=2的正向切片操作
print(s[::2])     # ac246

# i=1, j=-1, k=2的正向切片操作
print(s[1:-1:2])  # b135

# i=7, j=1, k=-1的负向切片操作
print(s[7:1:-1])  # 54321c

# i=-2, j=-8, k=-1的负向切片操作
print(s[-2:-8:-1]) # 54321c

# i=7, j=-10, k=-1的负向切片操作
print(s[7::-1])  # 54321cba

# i=-1, j=1, k=-1的负向切片操作
print(s[:1:-1])  # 654321c

# i=0, j=9, k=1的正向切片
print(s[:])   # abc123456

# i=0, j=9, k=2的正向切片
print(s[::2])  # ac246

# i=-1, j=-10, k=-1的负向切片
print(s[::-1])   # 654321cba

# i=-1, j=-10, k=-2的负向切片
print(s[::-2])    # 642ca

s = 'hello, world'

# center方法以宽度20将字符串居中并在两侧填充*
print(s.center(20, '*'))  # ****hello, world****
# rjust方法以宽度20将字符串右对齐并在左侧填充空格
print(s.rjust(20))        # hello, world
# ljust方法以宽度20将字符串左对齐并在右侧填充~
print(s.ljust(20, '~'))   # hello, world~~~~~~~~
# 在字符串的左侧补零
print('33'.zfill(5))      # 00033
print('-33'.zfill(5))     # -0033

name = 'Alice'
age = 25
height = 1.68

# 基本用法
print(f'My name is {name}, I am {age} years old')
# My name is Alice, I am 25 years old

# 表达式计算
print(f'{name} will be {age + 1} next year')
# Alice will be 26 next year

# 格式化数字：指定小数位数
print(f'Height: {height:.1f}m')  # Height: 1.7m

# 格式化数字：指定宽度和对齐
price = 49.5
print(f'Price: {price:>10.2f}')  # Price:      49.50
print(f'Price: {price:<10.2f}')  # Price: 49.50
print(f'Price: {price:^10.2f}')  # Price:   49.50

# 千分位分隔符
amount = 1234567.89
print(f'Amount: {amount:,.2f}')  # Amount: 1,234,567.89

# 百分比格式
ratio = 0.875
print(f'Success rate: {ratio:.1%}')  # Success rate: 87.5%

# 进制转换
num = 42
print(f'Binary: {num:b}')    # Binary: 101010
print(f'Octal: {num:o}')     # Octal: 52
print(f'Hex: {num:x}')       # Hex: 2a
print(f'Hex: {num:X}')       # Hex: 2A

name = 'Bob'
age = 30

# 位置参数
print('My name is {}, I am {} years old'.format(name, age))
# My name is Bob, I am 30 years old

# 索引参数
print('My name is {0}, I am {1} years old. {0} is my name'.format(name, age))
# My name is Bob, I am 30 years old. Bob is my name

# 关键字参数
print('My name is {n}, I am {a} years old'.format(n=name, a=age))
# My name is Bob, I am 30 years old

# 格式化数字
pi = 3.1415926
print('Pi: {:.2f}'.format(pi))  # Pi: 3.14
print('Pi: {:10.3f}'.format(pi))  # Pi:      3.142

name = 'Charlie'
age = 35

# 基本用法
print('My name is %s, I am %d years old' % (name, age))
# My name is Charlie, I am 35 years old

# 格式化浮点数
height = 1.75
print('Height: %.2f' % height)  # Height: 1.75

s = '   jackfrued@126.com  \t\r\n'
# strip方法获得字符串修剪左右两侧空格之后的字符串
print(s.strip())    # jackfrued@126.com

suits = 'spades diamonds clubs hearts'.split()

words = ['Numbers(1-10):']
for i in range(10):
    words.append(f'Value: {i + 1}')
print('\n'.join(words))

def extract_value_v2(s):
    # 当 s 包含分隔符 : 时，元组最后一个成员刚好是 value
    # 若是没有分隔符，最后一个成员默认是空字符串 ''
    # 它会找到第一个分隔符，然后返回一个元组，元组的三个成员分别是分隔符前的字符串、分隔符本身和分隔符后的字符串
    return s.partition(':')[-1]

s = '明明是中文,却使用了英文标点.'
# 创建替换规则表：',' -> '，', '.' -> '。'
table = s.maketrans(',.', '，。')
s.translate(table)

## 这种方式的字符串是单行的
inline_text_of_multiple_lines_style = ("line1"
"line2"
"line3")
print(inline_text_of_multiple_lines_style)

## 这种方式的字符串是多行的
multiple_lines2 = """
line1
line2
line3
"""
print(multiple_lines2)

# 创建集合的字面量语法(重复元素不会出现在集合中)
set1 = {1, 2, 3, 3, 3, 2}
print(set1)         # {1, 2, 3}
print(len(set1))    # 3

# 创建集合的构造器语法
set2 = set('hello')
print(set2)         # {'h', 'l', 'o', 'e'}

# 创建集合的生成式语法(将列表生成式的[]换成{})
set4 = {num for num in range(1, 20) if num % 3 == 0 or num % 5 == 0}
print(set4)         # {3, 5, 6, 9, 10, 12, 15, 18}

person = {
    'name': '王大锤', 'age': 55, 'weight': 60, 'office': '科华北路62号',
    'home': '中同仁路8号', 'tel': '13122334455', 'econtact': '13800998877'
}
print(person)

# dict函数(构造器)中的每一组参数就是字典中的一组键值对
person = dict(name='王大锤', age=55, weight=60, home='中同仁路8号')
print(person)    # {'name': '王大锤', 'age': 55, 'weight': 60, 'home': '中同仁路8号'}

for key in person:
    print(key, person[key])

for key, value in person.items():
    print(key, value)

## 这种方式会报错
print(person['gender'])

## 捕获异常
try:
    print(person['gender'])
except KeyError:
    print('没有这个key')

## 这种方式不会报错
print(person.get('gender'))

## 这种方式也不会报错，提供默认值
print(person.get('gender', '未知'))

d = {}
d.setdefault('hobbies', []).append('羽毛球')
print(d)

d2 = {'hobbies': ['默认爱好']}
d2.setdefault('hobbies', []).append('羽毛球')
print(d2)

d3 = {'name': '王大锤', 'age': 55}
# 不提供默认值，如果key不存在会报错
returnValue = d3.pop('notExistKey', '默认值')
print(returnValue)

try:
    del d3['notExistKey']
except KeyError:
    print('没有这个key')

# int必须在最前面
class UserType(int, Enum):
    VIP = 3
    BANNED = 13

print(UserType.VIP.value)
# 可以直接当数字使用
print( 2 + UserType.VIP)
print(UserType.BANNED)

def is_triangle(a, b, c):
    print(f'a = {a}, b = {b}, c = {c}')
    return a + b > c and b + c > a and a + c > b


# 调用函数传入参数不指定参数名按位置对号入座
print(is_triangle(1, 2, 3))
# 调用函数通过“参数名=参数值”的形式按顺序传入参数
print(is_triangle(a=1, b=2, c=3))
# 调用函数通过“参数名=参数值”的形式不按顺序传入参数
print(is_triangle(c=3, a=1, b=2))

def is_triangle(*, a, b, c):
    print(f'a = {a}, b = {b}, c = {c}')
    return a + b > c and b + c > a and a + c > b


# TypeError: is_triangle() takes 0 positional arguments but 3 were given
# print(is_triangle(3, 4, 5))
# 传参时必须使用“参数名=参数值”的方式，位置不重要
print(is_triangle(a=3, b=4, c=5))
print(is_triangle(c=5, b=4, a=3))

def calc(*args, **kwargs):
    result = 0
    for arg in args:
        if type(arg) in (int, float):
            result += arg
    for value in kwargs.values():
        if type(value) in (int, float):
            result += value
    return result


print(calc())                  # 0
print(calc(1, 2, 3))           # 6
print(calc(a=1, b=2, c=3))     # 6
print(calc(1, 2, c=3, d=4))    # 10

import random
import time


def download(filename):
    print(f'开始下载{filename}.')
    time.sleep(random.randint(2, 6))
    print(f'{filename}下载完成.')

    
def upload(filename):
    print(f'开始上传{filename}.')
    time.sleep(random.randint(4, 8))
    print(f'{filename}上传完成.')

    
download('MySQL从删库到跑路.avi')
upload('Python从入门到住院.pdf')

import time


# 定义装饰器函数，它的参数是被装饰的函数或类
def record_time(func):
    
    # 定义一个带装饰功能（记录被装饰函数的执行时间）的函数
    # 因为不知道被装饰的函数有怎样的参数所以使用*args和**kwargs接收所有参数
    # 在Python中函数可以嵌套的定义（函数中可以再定义函数）
    def wrapper(*args, **kwargs):
        # 在执行被装饰的函数之前记录开始时间
        start = time.time()
        # 执行被装饰的函数并获取返回值
        result = func(*args, **kwargs)
        # 在执行被装饰的函数之后记录结束时间  
        end = time.time()
        # 计算和显示被装饰函数的执行时间
        print(f'{func.__name__}执行时间: {end - start:.3f}秒')
        # 返回被装饰函数的返回值（装饰器通常不会改变被装饰函数的执行结果）
        return result
    
    # 返回带装饰功能的wrapper函数
    return wrapper

download = record_time(download)
upload = record_time(upload)
download('MySQL从删库到跑路.avi')
upload('Python从入门到住院.pdf')

import random
import time


def record_time(func):

    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f'{func.__name__}执行时间: {end - start:.3f}秒')
        return result

    return wrapper


@record_time
def download(filename):
    print(f'开始下载{filename}.')
    time.sleep(random.randint(2, 6))
    print(f'{filename}下载完成.')


@record_time
def upload(filename):
    print(f'开始上传{filename}.')
    time.sleep(random.randint(4, 8))
    print(f'{filename}上传完成.')


download('MySQL从删库到跑路.avi')
upload('Python从入门到住院.pdf')

names = ['foo', 'bar']
## start用于指定循环下标的初始值（默认为 0）
for index, s in enumerate(names, start=10):
    print(index, s)
 

print('---------------- list comprehension ----------------')
numbers = [1, 2, 3, 4, 5]
# 会直接加载到内存中
num_result = [x * 3 for x in numbers if x % 2 == 0]
print(num_result)

print('---------------- generation expression ----------------')
# 不会直接加载到内存中，而是生成一个生成器对象
g_express = (x * 3 for x in numbers if x % 2 == 0)
print(g_express)
for index, x in enumerate(g_express):
    print(f'第{index}个元素: {x}')

class Student:

    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def study(self, course_name):
        print(f'{self.__name}正在学习{course_name}.')


stu = Student('王大锤', 20)
stu.study('Python程序设计')
print(stu.__name)

class FrenchDeck:
    ranks = [str(n) for n in range(2, 11)] + list('JQKA')
    suits = 'spades diamonds clubs hearts'.split()

    def __init__(self):
        self._cards = [NamedCard(rank, suit) for suit in self.suits
                                        for rank in self.ranks]

    def __len__(self):
        return len(self._cards)

    def __getitem__(self, position):
        return self._cards[position]

frenchDeck = FrenchDeck()
print(frenchDeck[0])
print(len(frenchDeck))
print(frenchDeck[-1])
print(choice(frenchDeck))

x = None

# ✅ 正确 (Pythonic): 检查身份
if x is None:
    print("x is None")

if x is not None:
    print("x has a value")

# ❌ 不推荐: 检查值 (虽然通常也能工作，但在工程上是不严谨的)
if x == None:
    pass

# 没有传入items，会使用默认值，多次调用时，会使用同一个默认值
def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item(1))
print(add_item(2))

# 没有传入items，会使用默认值，多次调用时，每次都会创建一个新列表
def add_item(item, items=None):
    if items is None:
        items = []  # 每次调用时创建一个新列表
    items.append(item)
    return items

print(add_item(1))
print(add_item(2))

def my_generator():
    print('生成器被执行!') 
    yield 1
    print('生成器被继续执行!')
    yield 2
    print('生成器结束!')

gen = my_generator()
print(next(gen))
print(next(gen))

def my_generator():
    yield 1
    yield 2
    yield 3
for number in my_generator():
    print(number)