python语言基础(六)--深浅拷贝、闭包与装饰器

于 2024-09-02 21:40:26 发布
阅读量480 收藏 10
点赞数 19
分类专栏： Python语法 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/egglikeFe/article/details/141831033
版权

一、深浅拷贝

1、概述

1. 所谓的深浅拷贝, 指的是: 拷贝的多与少.  深拷贝拷贝的多, 浅拷贝拷贝的少.
2. 深浅拷贝都可以操作可变 和 不可变类型, 但是深浅拷贝一般不会操作不可变类型.
3. 回顾可变和不可变类型, 划分依据: 在不改变地址值的情况下, 是否可以修改内容, 可以 => 可变类型, 不可以 => 不可变类型.
    可变类型:   列表, 字典, 集合
    不可变类型: 字符串, 整数, 浮点型, 元组, 布尔...
4. 所谓的深浅拷贝, 指的就是 copy 模块的不同函数.
    浅拷贝: copy.copy()
    深拷贝: copy.deepcopy()

2、浅拷贝

(一)、可变类型

概述

浅拷贝只拷贝第一层数据，深层次不拷贝。因此如果第一层数据改变，原列表改变，浅拷贝列表无变化；如果二层数据改变，浅拷贝的数据会发生变化。

例如

def dm02_浅拷贝可变类型():
    a = [1, 2, 3]
    b = [11, 22, 33]
    c = [6, 7, a, b]

    # 测试1 id(c)和id(d)
    d = copy.copy(c)        # 浅拷贝 = 只会拷贝 可变类型的 第1层数据.
    print('id(c)-->', id(c))    # 0x03
    print('id(d)-->', id(d))    # 0x04
    print("id(c)和id(d)值不一样, 说明浅拷贝第1层(最外面一层的数据)")

    # 测试2
    print(id(c[2]))     # 0x01
    print(id(a))        # 0x01
    print("id(c[2])和id(a)值一样, 说明浅拷贝第2层的数据")

    # 修改a[2] = 22
    a[2] = 22
    c[0] = 100
    print('c->', c)     # [100, 7, [1, 2, 22], [11, 22, 33]]
    print('d->', d)     # [6, 7, [1, 2, 22], [11, 22, 33]]

(二)、不可变类型

概述

不会给拷贝的对象开辟新的内存空间，只拷贝了这个对象的引用。

例如

def dm03_浅拷贝不可变类型():

    # 不可变类型 a b c
    a = (1, 2, 3)
    b = (11, 22, 33)
    c = (6, 7, a, b)

    d = copy.copy(c)
    print('id(c)-->', id(c))    # 0x03
    print('id(d)-->', id(d))    # 0x03
    print("id(c)和id(d)值一样, 说明c和d指向相同的内存空间")

3、 深拷贝

(一)、可变类型

概述

开辟新的内存空间,所有层都会深拷贝。所以不管是嵌套多少层的数据，都会独立开辟新的空间，之前存储的数据与新数据没有关系了。

作用

能保证数据的安全

例如

def dm04_深拷贝可变类型():
    a = [1, 2, 3]
    b = [11, 22, 33]
    c = [6, 7, a, b]

    d = copy.deepcopy(c)
    print('id(c)-->', id(c))    # 0x03
    print('id(d)-->', id(d))    # 0x04


    a[1] = 100
    b[1] = 800
    c[0] = 600
    print(f'c: {c}')    # [600, 7, [1, 100, 3], [11, 800, 33]]
    print(f'd: {d}')    # [6, 7, [1, 2, 3], [11, 22, 33]]

(二)、不可变类型

概述

直接就引用了, 不开辟新的内存空间

例如

def dm05_深拷贝不可变类型():
    a = (1, 2, 3)
    b = (11, 22, 33)
    c = (a, b)

    d = copy.deepcopy(c)
    print(id(c))    # 0x03
    print(id(d))    # 0x03
    print("c/d内存空间相同, 说明c和d指向相同的内存空间")

二、闭包与装饰器

1、函数名的作用

概述

  • Python是一门以 面向对象为基础的语言, 一切皆对象, 所以: 函数名也是对象.

  • 直接打印函数名, 打印的是函数的地址. 函数名()则是在调用函数.

  • 函数名可以作为对象使用, 所以它可以像变量一样赋值, 且赋值后的 变量名() 和 调用 原函数名() 效果是一样的.

作用

  • 函数名可以作为对象, 像变量那样赋值.

  • 函数名可以作为实参进行传递.

例如

# 1. 定义1个无参函数method()
def method():
    print('我是 method 函数')

def get_sum(a, b):
    print('get_sum函数: 加法运算')
    return a + b

def get_subtract(a, b):
    print('get_subtract函数: 减法运算')
    return a - b

# 2. 定义1个带1个参数的函数func()
def func(fn_name):
    """
    接收函数名(函数对象), 然后调用该函数的.
    :param fn_name: 接收到的函数名(即: 函数对象)
    :return: 无
    """
    print('我是 func 函数')
    fn_name()

# 模拟自定义的计算器.
def my_calculation(a, b, fn_name):
    """
    接收两个整数 和 具体的计算规则, 对整数进行对应的计算.
    :param a: 要操作的第1个整数
    :param b: 要操作的第2个整数
    :param fn_name: 具体的计算规则
    :return: 计算结果.
    """
    return fn_name(a, b)

# 3. 在main函数中测试.
if __name__ == '__main__':
    # 演示: 函数名可以作为实参进行传递
    func(method)
    print('-' * 21)

    # 加法
    result1 = my_calculation(10, 3, get_sum)
    print(f'result1: {result1}')    # 13
    print('-' * 21)

    # 减法
    result2 = my_calculation(10, 3, get_subtract)
    print(f'result2: {result2}')    # 7

2、闭包

概述

属于python中独有的一种写法，可以实现对外部函数的局部变量进行临时存储。

作用

可以"延长"函数内 局部变量的生命周期

构成条件

  • 有嵌套. 外部函数内要嵌套 内部函数.

  • 有引用. 在内部函数中使用 外部函数的变量.

  • 有返回. 在外部函数中, 返回 内部函数名, 即: 内部函数对象

格式

def 外部函数名(形参列表):
            ......
            def 内部函数名(形参列表):        # 有嵌套
                ......
                使用外部函数的变量           # 有引用
            return 内部函数名              # 有返回

目的

为了给 装饰器做铺垫, 因为装饰器的底层就是 闭包

例如

# 需求1: 定义1个函数用于保存变量10, 然后调用函数返回值并重复累加数值, 观察结果.
# 1. 定义函数.
def fn():
    return 10

# 需求2: 定义1个用于求和的闭包, 外部函数有num1参数, 内部函数有num2参数, 然后调用, 求两数之和, 观察结果.
def fn_outer(num1):         # 外部函数
    def fn_inner(num2):     # 内部函数, 有嵌套
        # 具体的求和动作.
        sum = num1 + num2   # 有引用, 内部函数中, 使用了外部函数的变量 num1
        # 打印结果.
        print(f'求和结果: {sum}')
    return fn_inner         # 有返回

# 在main函数中测试.
if __name__ == '__main__':
    # 3.测试: 非闭包写法.
    print(fn() + 1)     # 11
    print(fn() + 1)     # 11
    print(fn() + 1)     # 11
    print('-' * 21)

    # 4. 测试: 闭包的写法.
    my_fn = fn_outer(10)
    my_fn(1)    # 11
    my_fn(1)    # 11
    my_fn(1)    # 11

3、nonlocal关键字

概述

它可以实现在 内部函数中, 修改外部函数的 变量值

用法

类似于global关键字

例如

# 1. 定义函数, 实现 内部函数访问外部函数的变量值.
def fn_outer():     # 外部函数
    a = 100         # 外部函数的局部变量
    def fn_inner(): # 内部函数, 有嵌套.
        # 在内部函数中, 修改外部函数的变量值, 需要通过 nonlocal 关键字实现.
        nonlocal a
        a = a + 1
        # 在内部函数中, 访问外部函数的变量
        print(f"a: {a}")        # 有引用

    return fn_inner             # 有返回


# 在main函数中测试调用.
if __name__ == '__main__':
    fn = fn_outer()     # fn = fn_inner  等价于 内部函数.
    fn()    # 101
    fn()    # 102
    fn()    # 103

4、装饰器

(一)、介绍

概述

装饰器 也是 闭包的一种形式(写法), 即: 装饰器 = 闭包 + 额外功能

目的

在不改变原有函数的基础上, 对其功能做增强(扩展).

前提

  • 有嵌套.

  • 有引用.

  • 有返回值.

  • 有额外功能.

格式

def 外部函数名(形参列表):
            .....
            def 内部函数名(形参列表):        # 有嵌套
                功能扩展                   # 有额外功能
                ...
                使用外部函数的变量           # 有引用
            return 内部函数名              # 有返回

用法

方式1: 传统用法
变量名 = 装饰器名(被装饰的函数名)
变量名()

方式2: 语法糖, @标记符实现
在要被装饰的函数上, 写: @装饰器名, 之后就跟普通调用函数方式一样, 该怎么调用就怎么调用

例如

# 1. 定义函数, 充当装饰器, 用来给函数增加: 登陆功能(额外功能).
def check_login(fn_name):
    def fn_inner():         # 有嵌套
        print('登陆中...')   # 有额外功能
        fn_name()           # 有引用
    return fn_inner         # 有返回

# 2. 定义函数, 表示: 发表评论.
@check_login
def comment():
    print('发表评论!...')


# 在main函数中调用.
if __name__ == '__main__':
    # 3. 普通写法, 直接调用函数.
    # comment()

    # 4. 装饰器, 用法1: 传统格式.
    # comment = check_login(comment)
    # comment()

    # 5. 装饰器, 用法2: 语法糖格式.
    comment()

(二)、装饰无参无返回值的函数

装饰器的内置函数 格式要和 被装饰的函数 格式保持一致。被装饰的函数(原函数) 是无参无返回值的, 则: 装饰器的内置函数 也是 无参无返回值。

# 需求: 在无参无返回值的原有求和函数前, 添加1个友好提示, 即: 正在努力计算中...

# 1. 装饰器.
def print_info(fn_name):    # fn_name: 要被装饰的函数名(原函数名)
    def fn_inner():         # 有嵌套.  装饰器的内部函数 格式 要和 原函数 格式保持一致.
        print('[友好提示] 正在努力计算中...')  # 有额外功能
        fn_name()                          # 有引用
    return fn_inner         # 有返回


# 2. 要被装饰的函数, 即: 原函数(这里是: 无参无返回值的)
@print_info
def get_sum():
    a = 10
    b = 20
    # 求和
    sum = a + b
    # 打印结果.
    print(f'sum: {sum}')

# 在main函数中测试调用.
if __name__ == '__main__':
    # 装饰器 写法1: 传统写法.
    # get_sum = print_info(get_sum)
    # get_sum()

    # 装饰器 写法2: 语法糖
    get_sum()

(三)、装饰有参无返回值的函数

装饰器的内置函数 格式要和 被装饰的函数 格式保持一致。被装饰的函数(原函数) 是有参无返回值的, 则: 装饰器的内置函数 也是 有参无返回值。

# 需求: 在有参无返回值的原有求和函数前, 添加1个友好提示, 即: 正在努力计算中...

# 1. 装饰器.
def print_info(fn_name):    # fn_name: 要被装饰的函数名(原函数名)
    def fn_inner(a, b):         # 有嵌套.  装饰器的内部函数 格式 要和 原函数 格式保持一致.
        print('[友好提示] 正在努力计算中...')  # 有额外功能
        fn_name(a, b)                      # 有引用
    return fn_inner         # 有返回


# 2. 要被装饰的函数, 即: 原函数(这里是: 有参无返回值的)
@print_info
def get_sum(a, b):
    # 求和
    sum = a + b
    # 打印结果.
    print(f'sum: {sum}')

# 在main函数中测试调用.
if __name__ == '__main__':
    # 装饰器 写法1: 传统写法.
    # get_sum = print_info(get_sum)
    # get_sum(100, 200)

    # 装饰器 写法2: 语法糖
    get_sum(10, 3)

(四)、装饰无参有返回值的函数

装饰器的内置函数 格式要和 被装饰的函数 格式保持一致。被装饰的函数(原函数) 是无参有返回值的, 则: 装饰器的内置函数 也是 无参有返回值。

# 需求: 在无参有返回值的原有求和函数前, 添加1个友好提示, 即: 正在努力计算中...

# 1. 装饰器.
def print_info(fn_name):  # fn_name: 要被装饰的函数名(原函数名)
    def fn_inner():  # 有嵌套.  装饰器的内部函数 格式 要和 原函数 格式保持一致.
        print('[友好提示] 正在努力计算中...')  # 有额外功能
        return fn_name()  # 有引用

    return fn_inner  # 有返回


# 2. 要被装饰的函数, 即: 原函数(这里是: 无参有返回值的)
@print_info
def get_sum():
    a, b = 10, 3
    # 求和
    sum = a + b
    # 返回结果.
    return sum


# 在main函数中测试调用.
if __name__ == '__main__':
    # 装饰器 写法1: 传统写法.
    # get_sum = print_info(get_sum)
    # sum1 = get_sum()
    # print(f'sum1: {sum1}')

    # 装饰器 写法2: 语法糖
    sum2 = get_sum()
    print(f'sum2: {sum2}')

(五)、装饰有参有返回值的函数

装饰器的内置函数 格式要和 被装饰的函数 格式保持一致。被装饰的函数(原函数) 是有参有返回值的, 则: 装饰器的内置函数 也是 有参有返回值。

# 需求: 在有参有返回值的原有求和函数前, 添加1个友好提示, 即: 正在努力计算中...

# 1. 装饰器.
def print_info(fn_name):  # fn_name: 要被装饰的函数名(原函数名)
    def fn_inner(a, b):  # 有嵌套.  装饰器的内部函数 格式 要和 原函数 格式保持一致.
        print('[友好提示] 正在努力计算中...')  # 有额外功能
        return fn_name(a, b)  # 有引用

    return fn_inner  # 有返回


# 2. 要被装饰的函数, 即: 原函数(这里是: 有参有返回值的)
@print_info
def get_sum(a, b):
    # 求和
    sum = a + b
    # 返回结果.
    return sum


# 在main函数中测试调用.
if __name__ == '__main__':
    # 装饰器 写法1: 传统写法.
    # get_sum = print_info(get_sum)
    # sum1 = get_sum(10, 20)
    # print(f'sum1: {sum1}')

    # 装饰器 写法2: 语法糖
    sum2 = get_sum(11, 22)
    print(f'sum2: {sum2}')

(六)、装饰不定长参数函数

装饰器的内置函数 格式要和 被装饰的函数 格式保持一致。被装饰的函数(原函数) 是不定长参数, 则: 装饰器的内置函数 也是 不定长参数。

# 需求: 定义一个可以计算 多个数据 和 多个字典value值之和的 函数, 并调用.
# 要求: 在原有函数的计算结果之前, 加一个友好提示: 正在努力计算中.


# 1. 定义装饰器.
def print_info(fn_name):
    def fn_inner(*args, **kwargs):          # 有嵌套
        print('[友好提示]正在努力计算中...')    # 有额外功能.
        return fn_name(*args, **kwargs)     # 有引用
    return fn_inner                         # 有返回


# 2. 定义原函数, 表示具体的累加动作.
# @print_info
def get_sum(*args, **kwargs):  # (1, 2, 3, 4, 5),  {'a':1, 'b':2, 'c':3}
    # 2.1 定义求和变量, 记录求和结果.
    sum = 0

    # 2.2 回顾: *args, 接收所有的 位置参数, 封装成 元组, 即: (1, 2, 3)
    # 所以这里 等于 元组求和.
    for value in args:
        sum += value

    # 2.3 回顾: **kwargs, 接收所有的 键值对参数, 封装成 字典, 即: {'a':1, 'b':2, 'c':3}
    # 所以这里 等于 字典value值求和.
    for value in kwargs.values():
        sum += value

    # 2.4 返回求和计算结果.
    return sum


# 3. 在main函数中测试.
if __name__ == '__main__':
    # 4. 装饰器, 写法1: 传统方式.
    get_sum = print_info(get_sum)
    sum = get_sum(11, 22, 33, a=1, b=2, c=3)
    print(f'求和结果: {sum}')

    # 5. 装饰器, 写法2: 语法糖.
    # sum = get_sum(11, 22, 33, a=1, b=2, c=3)
    # print(f'求和结果: {sum}')

(七)、多个装饰器装饰一个函数

注意

1. 多个装饰器装饰1个函数时, 会按照 由内到外的 顺序进行装饰, 即: 就近原则.
2. 简单记忆:
    由内到外装饰(针对于: 传统写法),  从上往下执行(针对于: 语法糖写法).

代码

# 需求: 发表评论前, 需要先登录, 再进行验证码校验.

# 1. 定义装饰器, 增加 登陆功能.
def check_login(fn_name):
    def fn_inner():                 # 有嵌套
        print('登陆校验中!.....')     # 有额外功能.
        fn_name()                   # 有引用
    return fn_inner                 # 有返回


# 2. 定义装饰器, 增加 验证码校验功能.
def check_code(fn_name):
    def fn_inner():                 # 有嵌套
        print('验证码校验中!.....')     # 有额外功能.
        fn_name()                   # 有引用
    return fn_inner                 # 有返回


# 3. 定义原函数, 表示: 发表评论.
@check_login
@check_code
def comment():
    print("发表评论!")

# 在main函数中, 测试.
if __name__ == '__main__':
    # 4. 测试: 装饰器的写法1 传统写法.
    cc = check_code(comment)    # 增加: 验证码校验功能.
    cl = check_login(cc)        # 增加: 登陆功能.
    cl()
    print('-' * 21)

    # 5. 测试: 装饰器的写法2 语法糖.
    comment()

(八)、带有参数的装饰器

注意

1. 一个装饰器的参数只能有1个.
2. 如果装饰器有多个参数, 则可以在该装饰器的外边再定义1个函数, 用于封装多个参数, 并返回一个装饰器.

例如

# 需求: 定义1个既能装饰加法运算, 也能装饰减法运算的装饰器, 即: 带有参数的装饰器, 并测试.

# 1. 定义装饰器, 能装饰 加法, 减法运算.
def logging(flag):
    def decorator(fn_name):
    # def decorator(fn_name, flag):     # decorator: 装饰的意思,  这行代码会报错, 因为装饰器的参数只能有1个.
        def fn_inner():         # 有嵌套
            if flag == '+':
                print('[友好提示] 正在努力计算 加法 中...')  # 有额外功能
            elif flag == '-':
                print('[友好提示] 正在努力计算 减法 中...')  # 有额外功能
            fn_name()           # 有引用
        return fn_inner         # 有返回
    return decorator            # 有返回

# 2. 定义原函数, 表示: 加法运算.
@logging('+')
def add():
    a, b = 10, 3
    sum = a + b
    print(f'求和结果: {sum}')


# 3. 定义原函数, 表示: 减法运算.
@logging('-')
def subtract():
    a, b = 22, 11
    sub = a - b
    print(f'求差结果: {sub}')

# 在main函数中测试调用.
if __name__ == '__main__':
    # 4. 测试加法.
    add()
    print('-' * 21)

    # 5. 测试减法.
    subtract()

优化版本

拓展：Python中的每个函数(对象)都有一个属性 name, 可以获取该函数的 名字

# 需求: 定义1个既能装饰加法运算, 也能装饰减法运算的装饰器, 即: 带有参数的装饰器, 并测试.

# 1. 定义装饰器, 能装饰 加法, 减法运算.
def decorator(fn_name):
    def fn_inner():         # 有嵌套
        # fn_name = 函数名 = 函数对象.
        # print(fn_name)      # 地址值, 说明 fn_name = 函数对象
        # print(fn_name.__name__) # 根据函数对象, 获取该函数的名字.

        if fn_name.__name__ == 'add':
            print('[友好提示] 正在努力计算 加法 中...')  # 有额外功能
        elif fn_name.__name__ == 'subtract':
            print('[友好提示] 正在努力计算 减法 中...')  # 有额外功能
        fn_name()           # 有引用
    return fn_inner         # 有返回

# 2. 定义原函数, 表示: 加法运算.
@decorator
def add():
    a, b = 10, 3
    sum = a + b
    print(f'求和结果: {sum}')


# 3. 定义原函数, 表示: 减法运算.

@decorator
def subtract():
    a, b = 22, 11
    sub = a - b
    print(f'求差结果: {sub}')

# 在main函数中测试调用.
if __name__ == '__main__':
    # 4. 测试加法.
    add()
    print('-' * 21)

    # 5. 测试减法.
    subtract()
电子海鸥
关注
  • 19
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python——闭包与装饰器、深浅拷贝
flandreflor的博客
03-17 143
闭包 装饰器
Python---拷贝和闭包
m0_74051333的博客
06-05 899
浅拷贝只复制了原始对象的引用，而深拷贝则是递归地复制原始对象及嵌套对象，从而得到完全独立的新对象副本。==目标：==掌握函数的快速使用。在之前的学习中，已经学习过函数。一起来看看简单和综合函数语法格式。# 定义def 函数名():代码...# 调用函数名()# 定义def 函数名([参数1, 参数2, 参数3, ...]):代码...[return 值]# 调用函数名([值1, 值2, 值3, ...])接着，再来总结下函数的使用特点：（1）先定义，后调用；
Python基础（八） | 万字详解深浅拷贝、生成器、迭代器以及装饰器
热门推荐
timerring的博客
10-03 1万+
⭐本专栏旨在对Python的基础语法进行详解，精炼地总结语法中的重点，详解难点，面向零基础及入门的学习者，通过专栏的学习可以熟练掌握python编程，同时为后续的数据分析，机器学习及深度学习的代码能力打下坚实的基础。 🔥文章和代码已归档至【Github仓库】，需要的朋友们自取。或者关注公众号【AIShareLab】，回复 python基础 也可获取。
Python基础（八） 万字详解深浅拷贝、生成器、迭代器以及装饰器_python 深拷贝迭代器(1)
m0_60575487的博客
05-05 817
不知道你们用的什么环境，我一般都是用的Python3.6环境和pycharm解释器，没有软件，或者没有资料，没人解答问题，都可以免费领取（包括今天的代码），过几天我还会做个视频教程出来，有需要也可以领取~给大家准备的学习资料包括但不限于：Python 环境、pycharm编辑器/永久激活/翻译插件python 零基础视频教程Python 界面开发实战教程Python 爬虫实战教程Python 数据分析实战教程python 游戏开发实战教程Python 电子书100本。
Python编程基础(视频讲解版)-教学大纲.pdf
05-29
函数是编程的核心，课程会讲解函数的定义、参数、返回值、命名空间、作用域、嵌套函数、闭包、装饰器以及迭代器和生成器。模块部分将介绍Python的内置模块、第三方模块和自定义模块的使用，包括如何导入和管理模块。...
Python面试题1-6语言特性
weixin_43407319的博客
05-25 188
参考自：https://cloud.tencent.com/developer/article/1490616（题目来源） 你将获得如下知识点： 掌握 Python 的基础语法 语法常见的 Python 应用场景 掌握 Python 闭包的使用以及装饰器的使用 生成器和迭代器的使用 常见的设计模式的使用 深浅拷贝的区别 线程、进程、协程的使用 了解 Python 中的元编程和反射 常考的数据结构和算法 爬虫相关知识，网络编程基本知识等 所有题目 语言特性 1.谈谈对 Python 和其他语言的区别 语言
经典Python面试题之Python基础篇.docx
07-20
Python 的深浅拷贝及应用场景？ - **浅拷贝**: 复制对象本身，但对象内部的子对象只是引用。 - **深拷贝**: 完全复制对象及其内部的所有子对象。 - **应用场景**: 当需要复制含有复杂结构的对象时使用深拷贝。 ##...
python12 中，No module named‘distutils‘错误
qq_43557600的博客
08-27 1万+
python12 “ No module named'distutils' ”,​ 安装 pip install setuptools ，解决 ​
centos7 安装 superset4.0.2 教程
m0_37759590的博客
08-27 1万+
centos7 安装 superset4.0.2 教程
【python】关于判断空值None、判断len()=0，和 if not 的区别
Meggie35的博客
08-28 6688
python的“空”与“无”之辩，关于None，和空数值。在程序中，判断里面没有值和判断东西是不是为空，也是不一样的东西，我们可以往下看看具体的区别。
【Python-办公自动化】批量修改EXCEL指定内容
2202_76035290的博客
08-29 3047
欢迎来到"花花 Show Python"，一名热爱编程和分享知识的技术博主。在这里，我将与您一同探索Python的奥秘，分享编程技巧、项目实践和学习心得。无论您是编程新手还是资深开发者，都能在这里找到有价值的信息和灵感。我热衷于将复杂的技术概念以简单易懂的方式呈现给大家，让每个人都能享受到编程的乐趣。我相信，通过不断的学习和实践，我们都能够成为更好的开发者。如果您喜欢我的内容，别忘了点击关注哦！这样您就可以第一时间获取我的更新和分享。您的支持是我不断前进的动力。
JVM 内存参数
iOS逆向与安全
08-29 2126
它屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在各种平台上不加修改的运行。‌例如，‌可以将最小堆内存设置为2GB（‌-Xms2048m）‌，‌最大堆内存设置为4GB（‌-Xmx4096m）‌。如果初始化的高水位线设置过低，会频繁的触发Full GC，高水位线会被多次调整。一般来说，垃圾回收器都会有默认的对象晋升到老年代的年龄参数阈值，CMS默认是6，G1默认是15，不过这参数值也不是一成不变的，它会根据动态年龄判断规则来重新被赋值。
【Python报错已解决】`TypeError: ‘numpy.ndarray‘ object is not callable`
最新发布
鸽芷咕的博客
09-01 208
在编程中，你是否遇到过尝试调用一个Numpy数组对象时出现了`TypeError: 'numpy.ndarray' object is not callable`的报错？这个问题通常是由于误将Numpy数组当成了一个函数来调用。接下来，我们将分析这个问题并提供解决方案。
宝塔面板网站SSL证书到期如何手动和自动续签Let’s Encrypt
weixin_45734165的博客
08-27 1584
宝塔面板提供2种免费的SSL证书：宝塔SSL，Let’s Encrypt。前面第1，2步骤主要是手动续签，比较稳定可靠，唯一的缺点是需要进入后台进行操作，并且有时候可能忘记续签。实际上宝塔面板还提供了很多计划任务的脚本，可以自动续签Let’s Encrypt证书。不管是给网站部署SSL还是给网站SSL续签，利用宝塔后台来进行网站SSL证书的管理还是比较方便高效的。2.手动续签：网站设置后台点击【SSL】》【Let’s Encrypt】》【续签】1.手动续签：登录宝塔面板后台，点击【网站】》【设置】
yield：生成器
mohen_777的博客
08-28 1075
作为生成器，因为每次迭代就会返回一个值，所以不能显示的在生成器函数中return 某个值，包括None值也不行，否则会抛出“SyntaxError”的异常，但是在函数中可以出现单独的return，表示结束该语句。使用yield，可以让函数生成一个序列，该函数返回的对象类型是"generator"，通过该对象连续调用next()方法返回序列值。另外一种说法：生成器就是一个返回迭代器的函数，与普通函数的区别是生成器包含yield语句，更简单点理解生成器就是一个迭代器。处为止，next()的返回值就是生成值。
Java—Stream流
向上的咸鱼blueblue的博客
08-27 1483
本文详细介绍了JAVA中有关Stream的相关内容。
python方法介绍
weixin_67832625的博客
08-28 1114
前言导读：Python的创始⼈人为吉多·范罗苏姆（Guido van Rossum）。1989年年的圣诞节期间，吉多·范罗苏姆为了了在阿姆斯特丹打发时间，决⼼开发一个新的脚本解释程序，作为ABC语言的一种继承。其诞生于1990年；
Bug | CUDA | cuDNN error: CUDNN_STATUS_INTERNAL_ERROR
Junseer的博客
08-26 172
如果我指定了 “CUDA:5” 进行调试，程序就会出现如下的报错；但如果我用 “CUDA:0” 运行程序，就能够正常运行，不发生程序报错。本质是 CUDA_VISIBLE_DEVICES 无效设置导致的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值