python 函数—闭包和装饰器

已于 2025-03-19 13:32:08 修改
阅读量451 收藏 8
点赞数 5
分类专栏： python 文章标签： python 开发语言
于 2025-03-18 11:01:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_65289420/article/details/146336006
版权

Python 闭包和装饰器教程

目录

  1. Python 闭包 (Closures)

  2. Python 装饰器 (Decorators)

  3. 高级主题

  4. 总结

Python 闭包 (Closures)

闭包的定义

闭包 (Closure) 是指一个函数能够记住它所在的作用域的变量，即使当这个函数在其定义环境之外被调用时，也能访问这些变量。更准确地说，闭包是由函数及其相关的引用环境组合而成的实体。

闭包必须同时满足三个条件：

  1. 必须有一个内部函数（嵌套函数）
  2. 内部函数必须引用外部函数中的变量
  3. 外部函数必须返回内部函数

闭包的原理和内存模型

要理解闭包，首先需要了解 Python 的作用域和名字查找规则 (LEGB):

  • Local (本地): 函数内部的命名空间
  • Enclosing (封闭): 外部嵌套函数的命名空间
  • Global (全局): 模块的命名空间
  • Built-in (内置): Python 内置模块的命名空间

闭包的内存模型解释：

def outer_func(x):
    # x 存储在 outer_func 的本地作用域
    def inner_func(y):
        # 当 inner_func 被调用时，它可以访问 x
        return x + y
    # 返回函数对象，而不是调用函数
    return inner_func

当 outer_func 被调用时：

  1. 创建 outer_func 的本地作用域，变量 x 被绑定到传入的值
  2. 定义内部函数 inner_func
  3. 关键点：Python 发现 inner_func 使用了变量 x，这个变量不在 inner_func 的本地作用域，而是在外部函数 outer_func 的作用域
  4. Python 创建一个闭包，将 x 的引用与 inner_func 绑定
  5. 当 outer_func 返回时，通常其本地作用域会被销毁，但因为 inner_func 仍然引用 x，所以 x 不会被垃圾回收
  6. 这个返回的函数对象包含函数代码和自由变量的引用（闭包）

等价理解方式：

闭包可以理解为一个特殊的对象，它包含：

  1. 函数代码
  2. 环境变量的快照

如果用类来模拟闭包，可以写成：

class ClosureSimulator:
    def __init__(self, x):
        self.x = x  # 存储外部变量
    
    def __call__(self, y):
        return self.x + y  # 使用存储的变量和参数执行操作

# 闭包函数
def outer_func(x):
    def inner_func(y):
        return x + y
    return inner_func

# 等价的类实现
closure_func = outer_func(10)
closure_obj = ClosureSimulator(10)

print(closure_func(5))  # 15
print(closure_obj(5))   # 15

这个等价形式帮助我们理解闭包是如何"记住"其创建环境的变量的。

创建闭包

以下是创建闭包的基本结构：

def 外部函数(外部参数):
    # 外部函数的代码
    
    def 内部函数(内部参数):
        # 内部函数使用外部参数
        结果 = 外部参数 + 内部参数
        return 结果
        
    # 返回内部函数，而不是调用它
    return 内部函数

一个具体的例子：

def make_multiplier(factor):
    def multiply(number):
        return number * factor
    return multiply

# 创建两个闭包函数
double = make_multiplier(2)
triple = make_multiplier(3)

# 使用闭包函数
print(double(5))  # 输出: 10
print(triple(5))  # 输出: 15

在这个例子中，double 和 triple 都是闭包。它们都"记住"了创建时各自的 factor 值。

闭包的应用场景

1. 函数工厂

创建专用函数的工厂：

def power_function_factory(exponent):
    def power(base):
        return base ** exponent
    return power

square = power_function_factory(2)
cube = power_function_factory(3)

print(square(4))  # 16
print(cube(4))    # 64
2. 数据隐藏和封装

创建带有私有状态的函数：

def counter_factory():
    count = 0  # 私有变量
    
    def counter():
        nonlocal count
        count += 1
        return count
        
    return counter

counter = counter_factory()
print(counter())  # 1
print(counter())  # 2
print(counter())  # 3

这里，count 变量被封装在闭包中，无法直接访问，只能通过返回的函数间接操作。

3. 实现装饰器

闭包是装饰器实现的基础：

def simple_decorator(func):
    def wrapper():
        print("函数将要执行")
        func()  # 调用原始函数
        print("函数已执行完毕")
    return wrapper

@simple_decorator
def hello():
    print("Hello, World!")

# 调用装饰后的函数
hello()

# 下一个例子
import time
def time_master(func):
def call_func():
print("开始运行程序 ... ”)
start = time. time ()
func()
stop = time. time ()
print("结束程序运行 .. ”)
print(f"一共耗费了{(stop-start) :. 2f}秒。”)
return call_func

def myfunc():
time.sleep(2)
print("I love FishC.")

myfunc = time_master(myfunc)
myfunc ()

闭包的注意事项

1. 修改外部变量需要使用 nonlocal

在 Python 3 中，如果需要在闭包内部修改外部函数的变量，必须使用 nonlocal 关键字：

def outer():
    x = 10
    def inner():
        nonlocal x  # 声明使用外部函数的变量
        x += 1      # 修改外部变量
        return x
    return inner

func = outer()
print(func())  # 11
print(func())  # 12

不使用 nonlocal 的话，Python 会将 x 视为内部函数的本地变量，导致 “UnboundLocalError”。

2. 闭包捕获的是变量引用而非变量值

闭包捕获的是变量的引用，而不是变量的值。如果在闭包创建后修改了被引用的变量，闭包会使用修改后的值：

def confusing_closure():
    funcs = []
    for i in range(3):
        def func():
            return i
        funcs.append(func)
    return funcs

funcs = confusing_closure()
# 所有函数都返回 2，因为它们引用的是同一个 i 变量，而该变量的最终值为 2
print([f() for f in funcs])  # [2, 2, 2]

解决方法：使用默认参数捕获当前值：

def correct_closure():
    funcs = []
    for i in range(3):
        def func(i=i):  # 将当前的 i 作为默认参数值
            return i
        funcs.append(func)
    return funcs

funcs = correct_closure()
print([f() for f in funcs])  # [0, 1, 2]

Python 装饰器 (Decorators)

装饰器的定义

装饰器 (Decorator) 是一个接收函数作为输入并返回新函数的可调用对象（通常是函数）。装饰器的目的是通过使用现有代码"装饰"（或增强）函数或方法，从而扩展其功能。

装饰器遵循了开放封闭原则：对扩展开放，对修改封闭。这意味着您可以扩展函数的行为，而无需修改函数本身的代码。

装饰器语法糖及其等价形式

Python 提供了一个特殊的语法糖 @decorator 来应用装饰器：

@decorator
def function():
    pass

等价形式:

def function():
    pass

function = decorator(function)

这两种形式完全相同。@decorator 语法糖实际上就是在定义函数后立即用装饰器包装这个函数。

具体例子:

def my_decorator(func):
    def wrapper():
        print("前置代码")
        func()
        print("后置代码")
    return wrapper

# 使用装饰器语法糖
@my_decorator
def say_hello():
    print("Hello!")

# 等价于
def say_hello_no_sugar():
    print("Hello!")

say_hello_no_sugar = my_decorator(say_hello_no_sugar)

嵌套函数与双括号调用

装饰器通常使用嵌套函数实现，这导致了双括号调用的形式。让我们详细解释这一过程：

def outer(func):
    def inner(*args, **kwargs):
        # 增强功能
        return func(*args, **kwargs)
    return inner

@outer
def function(arg):
    return arg

# 调用装饰后的函数
result = function("hello")

双括号运行过程解析:

  1. 第一对括号：outer(function)

    • outer 接收 function 作为参数
    • 定义了 inner 函数
    • 返回 inner 函数的引用

  2. 这使得装饰后的 function 实际上是 inner 函数

  3. 第二对括号：function("hello") (实际上是 inner("hello"))

    • 当调用 function("hello") 时，实际上是在调用 inner("hello")
    • inner 内部调用原始的 function 函数，并可能在前后添加新功能

等价形式:

使用变量名来跟踪每一步的函数引用：

def outer(func):
    def inner(*args, **kwargs):
        print("函数执行前")
        result = func(*args, **kwargs)
        print("函数执行后")
        return result
    return inner

# 定义原始函数
def original_function(arg):
    print(f"原始函数，参数: {arg}")
    return arg

# 手动应用装饰器
step1 = outer  # step1 引用装饰器函数
step2 = step1(original_function)  # step2 引用 inner 函数
step3 = step2("hello")  # step3 是调用 inner("hello") 的结果

# 这与以下调用等价
decorated_function = outer(original_function)
result = decorated_function("hello")

# 使用语法糖的最终形式
@outer
def function(arg):
    print(f"原始函数，参数: {arg}")
    return arg

result = function("hello")

这个等价形式清楚地展示了装饰器如何通过嵌套函数和双括号调用来工作。

带参数的装饰器

有时我们需要装饰器本身也能接受参数。这会导致更复杂的嵌套结构：

def repeat(n=1):
    def decorator(func):
        def wrapper(*args, **kwargs):
            result = None
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def say_hello(name):
    print(f"Hello, {name}!")
    return name

等价形式:

def repeat(n=1):
    # 第一对括号: repeat(3)
    def decorator(func):
        # 第二对括号: repeat(3)(say_hello)
        def wrapper(*args, **kwargs):
            # 第三对括号: repeat(3)(say_hello)("World")
            result = None
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

# 不使用语法糖
def say_hello(name):
    print(f"Hello, {name}!")
    return name

# 手动应用
step1 = repeat(3)  # 返回 decorator 函数
step2 = step1(say_hello)  # 返回 wrapper 函数
step3 = step2("World")  # 执行 wrapper，它会调用原始的 say_hello 三次

# 这与以下调用等价
decorated_function = repeat(3)(say_hello) # 嵌套函数的调用方式之一
result = decorated_function("World")

# 最终的语法糖形式
@repeat(3)
def say_hello(name):
    print(f"Hello, {name}!")
    return name

result = say_hello("World")

这个例子中有三层函数：

  1. repeat(n) - 接收装饰器参数
  2. decorator(func) - 接收要装饰的函数
  3. wrapper(*args, **kwargs) - 包装原始函数调用

多重装饰器

可以为函数应用多个装饰器，它们会从下到上（从内到外）执行：

@decorator1
@decorator2
@decorator3
def function():
    pass

等价形式:

def function():
    pass

# 从内到外应用装饰器
function = decorator1(decorator2(decorator3(function)))

实际例子:

def bold(func):
    def wrapper(*args, **kwargs):
        return f"<b>{func(*args, **kwargs)}</b>"
    return wrapper

def italic(func):
    def wrapper(*args, **kwargs):
        return f"<i>{func(*args, **kwargs)}</i>"
    return wrapper

def underline(func):
    def wrapper(*args, **kwargs):
        return f"<u>{func(*args, **kwargs)}</u>"
    return wrapper

@bold
@italic
@underline
def text(content):
    return content

# 使用装饰后的函数
print(text("Hello"))  # 输出: <b><i><u>Hello</u></i></b>

# 等价于:
def text_no_sugar(content):
    return content

decorated = bold(italic(underline(text_no_sugar)))
print(decorated("Hello"))  # 输出: <b><i><u>Hello</u></i></b>

在这个例子中，装饰器按以下顺序应用：

  1. 先应用 @underline
  2. 然后应用 @italic
  3. 最后应用 @bold

装饰器的应用场景

1. 执行时间测量
import time
import functools

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"函数 {func.__name__} 执行时间: {end_time - start_time:.4f} 秒")
        return result
    return wrapper

@timer
def slow_function(n):
    """这是一个耗时的函数"""
    time.sleep(n)  # 模拟耗时操作
    return n

slow_function(1)  # 输出: 函数 slow_function 执行时间: 1.xxxx 秒
2. 日志记录
import functools
import logging

logging.basicConfig(level=logging.INFO)

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        logging.info(f"调用函数: {func.__name__} 参数: {args}, {kwargs}")
        result = func(*args, **kwargs)
        logging.info(f"函数 {func.__name__} 返回: {result}")
        return result
    return wrapper

@log
def add(x, y):
    """加法函数"""
    return x + y

add(3, 5)
3. 缓存结果 (记忆化)
import functools

def memoize(func):
    cache = {}
    @functools.wraps(func)
    def wrapper(*args):
        if args in cache:
            return cache[args]
        result = func(*args)
        cache[args] = result
        return result
    return wrapper

@memoize
def fibonacci(n):
    """计算斐波那契数列第n项"""
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(35))  # 不使用缓存会非常慢，使用缓存后很快
4. 访问控制和身份验证
import functools

def require_auth(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        if not is_authenticated():  # 假设这是一个检查用户是否已认证的函数
            return "未授权访问"
        return func(*args, **kwargs)
    return wrapper

def is_authenticated():
    # 这里应该是实际的认证逻辑
    return False

@require_auth
def protected_resource():
    return "敏感数据"

print(protected_resource())  # 输出: 未授权访问

高级主题

装饰类的装饰器

装饰器不仅可以装饰函数，也可以装饰类：

def add_greeting(cls):
    cls.greet = lambda self: f"Hello from {self.__class__.__name__}"
    return cls

@add_greeting
class Person:
    def __init__(self, name):
        self.name = name

person = Person("张三")
print(person.greet())  # 输出: Hello from Person

保留原始函数信息

使用装饰器时，原始函数的元数据（如函数名、文档字符串等）会丢失。使用 functools.wraps 可以解决这个问题：

import functools

def my_decorator(func):
    @functools.wraps(func)  # 保留原函数的元数据
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

内置装饰器

Python 提供了一些内置的装饰器：

  1. @property - 将方法转换为属性
  2. @classmethod - 创建类方法（接收类作为第一个参数）
  3. @staticmethod - 创建静态方法（不接收特殊的第一个参数）
  4. @abstractmethod - 声明抽象方法（需要导入 abc 模块）

示例：

class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius
        
    @property
    def celsius(self):
        return self._celsius
        
    @celsius.setter
    def celsius(self, value):
        self._celsius = value
        
    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32
        
    @fahrenheit.setter
    def fahrenheit(self, value):
        self._celsius = (value - 32) * 5/9
        
    @classmethod
    def from_fahrenheit(cls, value):
        return cls(celsius=(value - 32) * 5/9)
        
    @staticmethod
    def is_freezing(temp_c):
        return temp_c <= 0

# 使用
temp = Temperature(25)
print(temp.celsius)  # 25
print(temp.fahrenheit)  # 77.0

temp.fahrenheit = 68
print(temp.celsius)  # 20.0

temp2 = Temperature.from_fahrenheit(41)
print(temp2.celsius)  # 5.0

print(Temperature.is_freezing(0))  # True

类作为装饰器

类也可以用作装饰器，只需要实现 __call__ 方法：

class CountCalls:
    def __init__(self, func):
        functools.update_wrapper(self, func)
        self.func = func
        self.count = 0
        
    def __call__(self, *args, **kwargs):
        self.count += 1
        print(f"函数 {self.func.__name__} 被调用了 {self.count} 次")
        return self.func(*args, **kwargs)

@CountCalls
def say_hello(name):
    return f"Hello, {name}!"

print(say_hello("World"))  # 函数 say_hello 被调用了 1 次
print(say_hello("Python"))  # 函数 say_hello 被调用了 2 次

这个例子中，CountCalls 类的实例作为装饰器，每次函数被调用时都会记录并显示调用次数。

闭包和装饰器的示例代码

"""
Python 闭包和装饰器示例代码
演示闭包和装饰器的工作原理和应用场景
"""

import time
import functools
from datetime import datetime

print("\n" + "="*50)
print("Python 闭包和装饰器示例")
print("="*50)

# =====================================================================
# 闭包基础示例
# =====================================================================
print("\n1. 闭包基础示例")

def make_multiplier(factor):
    """创建一个乘法闭包"""
    def multiply(number):
        """内部函数，执行乘法运算"""
        return number * factor
    
    # 输出闭包的内部状态，用于演示
    print(f"创建了一个乘法器，factor={factor}")
    print(f"multiply.__closure__={multiply.__closure__}")
    
    return multiply

# 创建闭包
double = make_multiplier(2)
triple = make_multiplier(3)

# 使用闭包
print(f"double(5) = {double(5)}")  # 10
print(f"triple(5) = {triple(5)}")  # 15

# 查看闭包的"记忆"
print(f"double.__closure__[0].cell_contents = {double.__closure__[0].cell_contents}")  # 2
print(f"triple.__closure__[0].cell_contents = {triple.__closure__[0].cell_contents}")  # 3

# =====================================================================
# 模拟闭包的类实现（等价形式）
# =====================================================================
print("\n2. 模拟闭包的类实现")

class MultiplierClass:
    """使用类模拟闭包的行为"""
    def __init__(self, factor):
        self.factor = factor
    
    def __call__(self, number):
        return number * self.factor

# 创建实例（等价于闭包）
double_class = MultiplierClass(2)
triple_class = MultiplierClass(3)

# 使用实例
print(f"double_class(5) = {double_class(5)}")  # 10
print(f"triple_class(5) = {triple_class(5)}")  # 15

# =====================================================================
# 闭包的应用：计数器
# =====================================================================
print("\n3. 闭包应用：计数器")

def make_counter():
    """创建一个计数器闭包"""
    count = 0
    
    def counter():
        nonlocal count
        count += 1
        return count
    
    return counter

counter1 = make_counter()
counter2 = make_counter()

for _ in range(3):
    print(f"counter1: {counter1()}")

for _ in range(2):
    print(f"counter2: {counter2()}")

# =====================================================================
# nonlocal 关键字的重要性
# =====================================================================
print("\n4. nonlocal 关键字的重要性")

def wrong_counter():
    count = 0
    
    def counter():
        # 没有 nonlocal，count 被视为局部变量
        # count += 1  # 将导致 UnboundLocalError
        return count
    
    return counter

def correct_counter():
    count = 0
    
    def counter():
        nonlocal count  # 声明 count 为外部变量
        count += 1
        return count
    
    return counter

try:
    # 会引发 UnboundLocalError 的代码已被注释，这里只进行演示
    print("如果尝试在不使用 nonlocal 的情况下修改 count，会引发 UnboundLocalError")
    c1 = correct_counter()
    print(f"正确的计数器: {c1()}, {c1()}")
except UnboundLocalError as e:
    print(f"错误: {e}")

# =====================================================================
# 闭包与循环变量
# =====================================================================
print("\n5. 闭包与循环变量")

def create_functions

总结

闭包:

  • 闭包是由函数及其引用环境组成的实体
  • 闭包允许函数"记住"其定义环境中的变量
  • 闭包主要用于数据隐藏、函数工厂和维护状态

装饰器:

  • 装饰器是扩展函数或类功能的工具
  • Python 的 @decorator 语法糖使装饰器使用更加简洁
  • 装饰器实现了开放封闭原则：对扩展开放，对修改封闭
  • 装饰器常用于日志记录、性能测量、访问控制等横切关注点
python入门教程－42－Python函数闭包及装饰器.zip
04-13
python入门教程－42－Python函数闭包及装饰器.zip
简析Python的闭包和装饰器
12-23
装饰器（Decorator）相对简单，咱们先介绍它：“装饰器的功能是将被装饰的函数当作参数传递给与装饰器对应的函数（名称相同的函数），并返回包装后的被装饰的函数”，听起来有点绕，没关系，直接看示意图,其中 a 为...
【Python】闭包与装饰器
flylr^的博客
05-11 1903
python中的闭包与装饰器
深入理解python中的闭包和装饰器
09-21
Python中的闭包和装饰器是两种非常重要的编程概念，它们都是基于函数的特性，特别是涉及到作用域和函数的嵌套。 闭包（Closure）在Python中是指一个内部函数引用了外部函数的局部变量，即使外部函数已经执行完毕，...
树莓派 cron 定时任务 设置定时开关脚本 我的是有图形界面(tk) 系统环境
2301_79558841的博客
05-29 599
是 Linux/Unix 系统里的一个守护进程（后台程序），专门用来定时执行你指定的任务（命令、脚本等）。echo $XAUTHORITY # 一般是 /home/admin/.Xauthority。确保脚本文件用的是 Unix 格式换行，避免 Windows 格式导致执行失败。添加定时任务（比如每天 21:49 启动，21:50 停止）/ 先测试。（cron 表）里，cron 会根据你设定的时间点自动触发执行。在这里注意我的路径和你的路径是否有区别。你把想定时执行的命令写到。
Python 验证码识别(使用pytesseract库)
宁静致远
06-01 417
Tesseract是一个高度精确的开源OCR（光学字符识别）系统，广泛应用于文本识别项目中。结合Python的pytesseract库，实现图片文字的提取。
Java BigInteger类详解与应用
m0_74482103的博客
05-31 624
通过合理运用BigInteger类，开发者可以处理任意精度的整数运算需求，适用于金融计算、密码学、科学计算等领域。注意根据具体场景选择合适的方法，并做好异常处理与性能优化。Biglnteger b1 = new Biglnteger("整数");2.如何获取BigInteger的对象?总结：1.Biglnteger表示一个大整数。
LLMs之Tool：Workflow Use的简介、特点、安装和使用方法、以及案例应用
头部AI社区如有邀博主AI主题演讲请私信—心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，专注，谦虚，自律，反思，成长，还算比较正能量的博主，公益免费传播…内心特别想在AI界做出一些可以推进历史进程影响力的技术(兴趣使然，有点小情怀，也有点使命感呀
05-31 635
​ LLMs之Tool：Workflow Use的简介、特点、安装和使用方法、以及案例应用 目录 Workflow Use的简介 Workflow Use的安装和使用方法 Workflow Use的案例应用 Workflow Use的简介 Workflow Use 旨在提供一种简便的方式来创建和执行确定性的工作流程。它利用变量，并在步骤失败时回退到 Browser Use。用户只需向记录器展示工作流程，Workflow Use 就能自动生成相应的工作流程。该项目尚处于早期开发
OpenCV CUDA模块直方图计算------在 GPU 上计算输入图像的直方图（histogram）函数histEven()
jndingxin的专栏
05-29 1223
该函数用于在 GPU 上计算输入图像的直方图（histogram）。它将像素值区间均匀划分为若干个 bin（桶），并统计每个 bin 中像素的数量。
pip国内镜像源配置
weixin_46161645的博客
05-28 512
简单的方式是使用命令配置。在pip安装命令后添加。
【Python】 -- 趣味代码 - 皮卡丘
银尘博客
05-28 196
本文介绍了使用Python的turtle模块绘制皮卡丘的程序设计。该程序通过模块化的方式实现了皮卡丘头部、身体、眼睛、嘴巴、脸颊、耳朵等部位的绘制，主要特点如下： 程序结构：采用面向对象设计，封装了Pikachu类，包含初始化画笔、设置参数等方法。 核心功能： 无轨迹移动函数noTrace_goto实现画笔精确定位 独立函数绘制各个部位（如leftEye、rightEye等） 色彩填充和精细曲线控制（如嘴巴的弧度） 特色实现： 使用坐标列表实现复杂的嘴唇形状 通过调整tracer控制绘制过程显示 精确控制每
uv：现代化的 Python 包和项目管理工具
hello！
05-31 764
摘要： uv是由Astral团队开发的Rust高性能Python包管理工具，旨在替代传统工具链（如pip、virtualenv）。其核心优势包括极速依赖解析（比传统工具快10–100倍）、内置虚拟环境管理、多Python版本支持，以及通过pyproject.toml统一依赖管理。安装简单，支持脚本、Homebrew或pip；常用操作如创建虚拟环境（uv venv）、依赖管理（uv add/sync）、运行脚本（uv run）等均高度简化。uv还支持自动下载指定Python版本，显著提升开发效率，适合现代Py
Python自学第7天：元组
ghost143的博客
05-29 264
Python中元组的用法及其示例
Tkinter 是 Python 的标准 GUI（图形用户界面）工具包
2401_87975790的博客
05-29 667
Tkinter 是 Python 的标准 GUI 工具包，基于 Tcl/Tk 开发，适合快速构建简单的桌面应用程序。其核心概念包括主窗口（通过 Tk() 创建并调用 mainloop() 启动事件循环）、控件（如按钮、标签等，需关联到父容器）、布局管理（支持 pack()、grid() 和 place() 三种方式）以及事件驱动（通过绑定回调函数响应用户操作）。Tkinter 还提供变量跟踪功能（如 StringVar、IntVar），用于动态绑定控件值。常用模块包括 tkinter、ttk（增强控件）、m
一周学会Pandas2之Python数据处理与分析-数据重塑与透视-unstack() - 解堆 (行 -＞ 列)
java1234的博客
05-30 288
一周学会Pandas2之Python数据处理与分析-数据重塑与透视-unstack() - 解堆 (行 -> 列)
15：00面试，15：06就出来了，问的问题有点变态。。。
2401_83387413的博客
05-26 1789
一位测试工程师分享了职场经历：从小厂跳槽后遭遇降薪危机，面试互联网公司时因HTTPS测试方案问题失利。文章总结了软件测试面试常见知识点，涵盖测试理论、Linux、MySQL、Web/API/App测试、Python基础、性能测试等16个模块。重点整理了高频面试题，包括测试步骤、Linux命令、Python编程、数据库优化等实用内容，并提到一份近200页的面试宝典资源，旨在帮助测试工程师高效备战面试。
深入探讨集合与数组转换方法
weixin_50055999的博客
05-28 1329
在 Java 中，list.toArray() 和 Arrays.asList() 是两个常见的集合与数组转换方法。 它们的行为和对原始数据的影响有显著区别，下面详细分析它们的机制及对数据修改的影响。示例代码 1.4、注意事项 不能添加/删除元素：调用 add 或 remove 会抛出 UnsupportedOperationException。 结构修改限制：仅支持修改元素内容，不支持改变集合大小。 示例： 示例： 2、数组copy 可参考： 小结：4.
Python打卡DAY43
最新发布
m0_65171196的博客
06-02 201
kaggle找到一个图像数据集，用cnn网络进行训练并且用grad-cam做可视化。，该数据集分为六类，包含建筑、森林、冰川、山脉、海洋和街道。进阶：并拆分成多个文件。
SpringBoot使用ThreadLocal保存登录用户信息
pan_junbiao的博客
05-29 1048
ThreadLocal‌ 是 Java 中解决多线程数据隔离问题的工具，其核心功能是：‌每个线程拥有独立的变量副本‌，避免线程间共享数据导致的并发安全问题。java.lang.ThreadLocal 是自 JDK1.2 版本起提供的线程成员操作类，在多线程环境下开发工作中，经常需要区分不同的线程，而且在一个线程的执行过程中能够一直访问某一个数据，而 ThreadLocal 就是可以很好地解决这个问题。
Pandas比MySQL快？
分享Python、数据分析、人工智能前沿知识
06-02 179
对了，其实你在Python中可以使用mysql的，有一个专门的sdk接口-pymysql，可以支持python连接mysql，不管是查询、建表、插入数据等都可以实现。它的数据存储在磁盘，得益于索引和查询优化，而且有分页查询、多线程等，比Pandas和Python列表快很多。实测来看，MySQL > Pandas > Python列表，而且MySQl远快于后两个，几乎是碾压。Python列表和Pandas是基于内存操作的，百万级数据内存占用高，可能会溢出。但Pandas算法更优，所以快于Python列表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值