python基础 -25- 内存管理和垃圾回收

最新推荐文章于 2023-04-13 17:47:50 发布
最新推荐文章于 2023-04-13 17:47:50 发布
阅读量148 收藏
点赞数
分类专栏： python 文章标签： python 内存结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44766883/article/details/107887100
版权

一句话

引用计数器为主 标记清除和分代回收为辅 + 缓存机制


引用计数器

环状双向链表 rechain

 在python程序中创建的任何对象都会放在rechain链表中，

name = "莫崽子"
age = 18
hobby = ["篮球", "编程"]

  • 内部会创建一些数据[上一个对象，下一个对象，类型，引用个数]

    name = “莫崽子”

  • 内部会创建一些数据[上一个对象，下一个对象，类型，引用个数，val=18]

    age = 18

  • 内部会创建一些数据[上一个对象，下一个对象，类型，引用个数，items=元素，元素个数]

    hobby = [“篮球”, “编程”]

 在c语言源码中可以看出每个对象都有相同的值：PyObject(4个值)

 由多个元素组成的对象：PyObject结构体 + ob_size

 例如：每个类型的对象在创建时都有PyObject中的那4部分数据；list/set/tuple等由多个元素组成对象创建时都有PyVarObject中的那5部分数据


类型封装结构体

  • float类型

    typedef struct {
    PyObject_HEAD
    double ob_fval;
} PyFloatObject;

  • int类型

    struct _longobject {
    PyObject_VAR_HEAD
    digit ob_digit[1];
};
/* Long (arbitrary precision) integer object interface */
typedef struct _longobject PyLongObject; /* Revealed in longintrepr.h */

  • str类型

    typedef struct {
    PyObject_HEAD
    Py_ssize_t length;          /* Number of code points in the string */
    Py_hash_t hash;             /* Hash value; -1 if not set */
    struct {
        unsigned int interned:2;
        /* Character size:
             - PyUnicode_WCHAR_KIND (0):
               * character type = wchar_t (16 or 32 bits, depending on the
                 platform)
             - PyUnicode_1BYTE_KIND (1):
               * character type = Py_UCS1 (8 bits, unsigned)
               * all characters are in the range U+0000-U+00FF (latin1)
               * if ascii is set, all characters are in the range U+0000-U+007F
                 (ASCII), otherwise at least one character is in the range
                 U+0080-U+00FF
             - PyUnicode_2BYTE_KIND (2):
               * character type = Py_UCS2 (16 bits, unsigned)
               * all characters are in the range U+0000-U+FFFF (BMP)
               * at least one character is in the range U+0100-U+FFFF
             - PyUnicode_4BYTE_KIND (4):
               * character type = Py_UCS4 (32 bits, unsigned)
               * all characters are in the range U+0000-U+10FFFF
               * at least one character is in the range U+10000-U+10FFFF
             */
        unsigned int kind:3;
        unsigned int compact:1;
        unsigned int ascii:1;
        unsigned int ready:1;
        unsigned int :24;
    } state;
    wchar_t *wstr;              /* wchar_t representation (null-terminated) */
} PyASCIIObject;
typedef struct {
    PyASCIIObject _base;
    Py_ssize_t utf8_length;     /* Number of bytes in utf8, excluding the
                                       * terminating \0. */
    char *utf8;                 /* UTF-8 representation (null-terminated) */
    Py_ssize_t wstr_length;     /* Number of code points in wstr, possible
                                       * surrogates count as two code points. */
} PyCompactUnicodeObject;
typedef struct {
    PyCompactUnicodeObject _base;
    union {
        void *any;
        Py_UCS1 *latin1;
        Py_UCS2 *ucs2;
        Py_UCS4 *ucs4;
    } data;                     /* Canonical, smallest-form Unicode buffer */
} PyUnicodeObject;

  • list类型

    typedef struct {
    PyObject_VAR_HEAD
    PyObject **ob_item;
    Py_ssize_t allocated;
} PyListObject;

  • tuple类型

    typedef struct {
    PyObject_VAR_HEAD8
    PyObject *ob_item[1];
} PyTupleObject;

  • dict类型

    typedef struct {
    PyObject_HEAD
    Py_ssize_t ma_used;
    PyDictKeysObject *ma_keys;
    PyObject **ma_values;
} PyDictObject;

例子

data = 3.14

内部会创建：
	_ob_next = refchain中的上一个对象
    _ob_prev = refchain中的下一个对象
    ob_refcnt = 1
    ob_type = float
    ob_fval = 3.14

通过常见结构体可以基本了解到本质上每个对象内部会存储的数据。

扩展：在结构体部分你应该发现了str类型比较繁琐，那是因为python字符串在处理时需要考虑到编码的问题，在内部规定（见源码结构体）：

  • 字符串只包含ascii，则每个字符用1个字节表示，即：latin1
  • 字符串包含中文等，则每个字符用2个字节表示，即：ucs2
  • 字符串包含emoji等，则每个字符用4个字节表示，即：ucs4

引用计数器
v1 = 3.14
v2 = 999
v3 = (1,2,3)

 当python程序运行时，会根据数据类型的不同找到其对应的结构体，根据结构体中的字段来进行创建相关的数据，然后将对象添加到rechain双向链表中。

 在C源码中有两个关键的结构体：pyObject，pyVarObject

 每个对象中有ob_refcnt就是引用计数器，值默认为1，当有其他变量引用对象时，引用计数器就会发生变化。

  • 引用

    a = 99999
b = a

  • 删除引用

    a = 99999
b = a
del b  # 删除变量；b对应的引用计数器为-1
del a  # 删除变量：a对象的应用计数器为-1

    当一个对象的引用计数器为0时，意味着没有人再使用这个对象了，这个对象就是垃圾，垃圾回收

    回收：1.对象从refchain链表中移除 2.将对象销毁，内存归还


循环引用问题


标记清除

 目的：为了解决引用计数器循环引用的不足

 实现：在python的底层再维护一个链表，链表中专门放那些可能存在循环的对象(list/tuple/dict/set)

 在Python内部某种情况下触发，会去扫描可能存在循环应用的链表中的每个元素，检查是否有循环引用，如果有则让双方的引用计数器-1；如果是0则垃圾回收


分代回收

 将可能存在循环引用的对象维护成3个链表

  • 0代：0代中对象个数达到700个扫描一次(是垃圾就回收，不是垃圾)
  • 1代：0代扫描10次，则1代扫描一次
  • 2代：1代扫描10次，则2代扫描一次

情景模拟

第一步：当创建对象age=19时，会将对象添加到refchain链表中。

第二步：当创建对象num_list = [11,22]时，会将列表对象添加到 refchain 和 generations 0代中。

第三步：新创建对象使generations的0代链表上的对象数量大于阈值700时，要对链表上的对象进行扫描检查。

当0代大于阈值后，底层不是直接扫描0代，而是先判断2、1是否也超过了阈值。

  • 如果2、1代未达到阈值，则扫描0代，并让1代的 count + 1 。
  • 如果2代已达到阈值，则将2、1、0三个链表拼接起来进行全扫描，并将2、1、0代的count重置为0.
  • 如果1代已达到阈值，则讲1、0两个链表拼接起来进行扫描，并将所有1、0代的count重置为0.

对拼接起来的链表在进行扫描时，主要就是剔除循环引用和销毁垃圾，详细过程为：

  • 扫描链表，把每个对象的引用计数器拷贝一份并保存到 gc_refs中，保护原引用计数器。

  • 再次扫描链表中的每个对象，并检查是否存在循环引用，如果存在则让各自的gc_refs减 1 。

  • 再次扫描链表，将 gc_refs 为 0 的对象移动到unreachable链表中；不为0的对象直接升级到下一代链表中。

  • 处理unreachable

    链表中的对象的 析构函数 和 弱引用，不能被销毁的对象升级到下一代链表，能销毁的保留在此链表。

    • 析构函数，指的就是那些定义了__del__方法的对象，需要执行之后再进行销毁处理。

  • 弱引用，

  • 最后将 unreachable 中的每个对象销毁并在refchain链表中移除（不考虑缓存机制）。

至此，垃圾回收的过程结束。


缓存机制

 从上文大家可以了解到当对象的引用计数器为0时，就会被销毁并释放内存。而实际上他不是这么的简单粗暴，因为反复的创建和销毁会使程序的执行效率变低。Python中引入了“缓存机制”机制。
 例如：引用计数器为0时，不会真正销毁对象，而是将他放到一个名为 free_list 的链表中，之后会再创建对象时不会在重新开辟内存，而是在free_list中将之前的对象来并重置内部的值来使用。

  • float类型，维护的free_list链表最多可缓存100个float对象。

    v1 = 3.14    # 开辟内存来存储float对象，并将对象添加到refchain链表。
print( id(v1) ) # 内存地址：4436033488
del v1    # 引用计数器-1，如果为0则在rechain链表中移除，不销毁对象，而是将对象添加到float的free_list.
v2 = 9.999    # 优先去free_list中获取对象，并重置为9.999，如果free_list为空才重新开辟内存。
print( id(v2) ) # 内存地址：4436033488

# 注意：引用计数器为0时，会先判断free_list中缓存个数是否满了，未满则将对象缓存，已满则直接将对象销毁。

  • int类型，不是基于free_list，而是维护一个small_ints链表保存常见数据（小数据池），小数据池范围：-5 <= value < 257。即：重复使用这个范围的整数时，不会重新开辟内存。

    v1 = 38    # 去小数据池small_ints中获取38整数对象，将对象添加到refchain并让引用计数器+1。
print( id(v1))  #内存地址：4514343712
v2 = 38 # 去小数据池small_ints中获取38整数对象，将refchain中的对象的引用计数器+1。
print( id(v2) ) #内存地址：4514343712

# 注意：在解释器启动时候-5~256就已经被加入到small_ints链表中且引用计数器初始化为1，代码中使用的值时直接去small_ints中拿来用并将引用计数器+1即可。另外，small_ints中的数据引用计数器永远不会为0（初始化时就设置为1了），所以也不会被销毁。

  • str类型，维护unicode_latin1[256]链表，内部将所有的ascii字符缓存起来，以后使用时就不再反复创建。

    v1 = "A"
print( id(v1) ) # 输出：4517720496
del v1
v2 = "A"
print( id(v1) ) # 输出：4517720496

# 除此之外，Python内部还对字符串做了驻留机制，针对那么只含有字母、数字、下划线的字符串（见源码Objects/codeobject.c），如果内存中已存在则不会重新在创建而是使用原来的地址里（不会像free_list那样一直在内存存活，只有内存中有才能被重复利用）。
v1 = "wupeiqi"
v2 = "wupeiqi"
print(id(v1) == id(v2)) # 输出：True

  • list类型，维护的free_list数组最多可缓存80个list对象。

    v1 = [11,22,33]
print( id(v1) ) # 输出：4517628816
del v1
v2 = ["武","沛齐"]
print( id(v2) ) # 输出：4517628816

  • tuple类型，维护一个free_list数组且数组容量20，数组中元素可以是链表且每个链表最多可以容纳2000个元组对象。元组的free_list数组在存储数据时，是按照元组可以容纳的个数为索引找到free_list数组中对应的链表，并添加到链表中。

    v1 = (1,2)
print( id(v1) )
del v1  # 因元组的数量为2，所以会把这个对象缓存到free_list[2]的链表中。
v2 = ("武沛齐","Alex")  # 不会重新开辟内存，而是去free_list[2]对应的链表中拿到一个对象来使用。
print( id(v2) )

  • dict类型，维护的free_list数组最多可缓存80个dict对象。

    v1 = {"k1":123}
print( id(v1) )  # 输出：4515998128
del v1
v2 = {"name":"武沛齐","age":18,"gender":"男"}
print( id(v1) ) # 输出：4515998128

c语言源码分析(int为例)

创建
age = 19

 当在python中创建一个整型数据时，底层会触发他的如下源码:

PyObject *
    PyLong_FromLong(long ival)
{
    PyLongObject *v;
    ...
        // 优先去小数据池中检查，如果在范围内则直接获取不再重新开辟内存。（ -5 <= value < 257）
        CHECK_SMALL_INT(ival);
    ...
        // 非小数字池中的值，重新开辟内存并初始化
        v = _PyLong_New(ndigits);
    if (v != NULL) {
        digit *p = v->ob_digit;
        Py_SIZE(v) = ndigits*sign;
        t = abs_ival;
        ...
    }
    return (PyObject *)v;
}
#define NSMALLNEGINTS           5
#define NSMALLPOSINTS           257
#define CHECK_SMALL_INT(ival) \
        do if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) { \
            return get_small_int((sdigit)ival); \
        } while(0)
static PyObject *
    get_small_int(sdigit ival)
{
    PyObject *v;
    v = (PyObject *)&small_ints[ival + NSMALLNEGINTS];
    // 引用计数器 + 1
    Py_INCREF(v);
    ...
        return v;
}
PyLongObject *
    _PyLong_New(Py_ssize_t size)
{
    // 创建PyLongObject的指针变量
    PyLongObject *result;
    ...
        // 根据长度进行开辟内存
        result = PyObject_MALLOC(offsetof(PyLongObject, ob_digit) +
                                 size*sizeof(digit));
    ...
        // 对内存中的数据进行初始化并添加到refchain链表中。
        return (PyLongObject*)PyObject_INIT_VAR(result, &PyLong_Type, size);
}

// Include/objimpl.h
#define PyObject_NewVar(type, typeobj, n) \
                    ( (type *) _PyObject_NewVar((typeobj), (n)) )
static inline PyVarObject*
    _PyObject_INIT_VAR(PyVarObject *op, PyTypeObject *typeobj, Py_ssize_t size)
{
    assert(op != NULL);
    Py_SIZE(op) = size;
    // 对象初始化
    PyObject_INIT((PyObject *)op, typeobj);
    return op;
}
#define PyObject_INIT(op, typeobj) \
        _PyObject_INIT(_PyObject_CAST(op), (typeobj))
static inline PyObject*
    _PyObject_INIT(PyObject *op, PyTypeObject *typeobj)
{
    assert(op != NULL);
    Py_TYPE(op) = typeobj;
    if (PyType_GetFlags(typeobj) & Py_TPFLAGS_HEAPTYPE) {
        Py_INCREF(typeobj);
    }
    // 对象初始化，并把对象加入到refchain链表。
    _Py_NewReference(op);
    return op;
}

// Objects/object.c
// 维护了所有对象的一个环状双向链表
static PyObject refchain = {&refchain, &refchain};
void
    _Py_AddToAllObjects(PyObject *op, int force)
{
    if (force || op->_ob_prev == NULL) {
        op->_ob_next = refchain._ob_next;
        op->_ob_prev = &refchain;
        refchain._ob_next->_ob_prev = op;
        refchain._ob_next = op;
    }
}
void
    _Py_NewReference(PyObject *op)
{
    _Py_INC_REFTOTAL;
    // 引用计数器初始化为1。
    op->ob_refcnt = 1;
    // 对象添加到双向链表refchain中。
    _Py_AddToAllObjects(op, 1);
    _Py_INC_TPALLOCS(op);
}

引用
value = 69
data = value

 类似于出现这种引用关系时，内部其实就是将对象的引用计数器+1，源码同float类型引用。


销毁
value = 699
del value

 在项目中如果出现这种删除的语句，则内部会将引用计数器-1，如果引用计数器减为0，则直接进行垃圾回收。（int类型是基于小数据池而不是free_list做的缓存，所以不会在销毁时缓存数据）。
 C源码执行流程如下：

// Include/object.h
static inline void _Py_DECREF(const char *filename, int lineno,
                              PyObject *op)
{
    (void)filename; /* may be unused, shut up -Wunused-parameter */
    (void)lineno; /* may be unused, shut up -Wunused-parameter */
    _Py_DEC_REFTOTAL;
    // 引用计数器-1，如果引用计数器为0，则执行 _Py_Dealloc去垃圾回收。
    if (--op->ob_refcnt != 0) {
        #ifdef Py_REF_DEBUG
        if (op->ob_refcnt < 0) {
            _Py_NegativeRefcount(filename, lineno, op);
        }
        #endif
    }
    else {
        _Py_Dealloc(op);
    }
}
#define Py_DECREF(op) _Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op))

// Objects/object.c
void
    _Py_Dealloc(PyObject *op)
{
    // 找到int类型的 tp_dealloc 函数（int类中没有定义tp_dealloc函数，需要去父级PyBaseObject_Type中找tp_dealloc函数）
    // 此处体现所有的类型都继承object
    destructor dealloc = Py_TYPE(op)->tp_dealloc;
    // 在refchain双向链表中摘除此对象。
    _Py_ForgetReference(op);
    // 执行int类型的 tp_dealloc 函数，去进行垃圾回收。
    (*dealloc)(op);
}
void
    _Py_ForgetReference(PyObject *op)
{
    ...
        // 在refchain链表中移除此对象
        op->_ob_next->_ob_prev = op->_ob_prev;
    op->_ob_prev->_ob_next = op->_ob_next;
    op->_ob_next = op->_ob_prev = NULL;
    _Py_INC_TPFREES(op);
}

// Objects/longobjet.c
PyTypeObject PyLong_Type = {
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
        "int",                                      /* tp_name */
        offsetof(PyLongObject, ob_digit),           /* tp_basicsize */
        sizeof(digit),                              /* tp_itemsize */
        0,                                          /* tp_dealloc */
        ...
        PyObject_Del,                               /* tp_free */
};

Objects/typeobject.c
    PyTypeObject PyBaseObject_Type = {
    PyVarObject_HEAD_INIT(&PyType_Type, 0)
        "object",                                   /* tp_name */
        sizeof(PyObject),                           /* tp_basicsize */
        0,                                          /* tp_itemsize */
        object_dealloc,                             /* tp_dealloc */
        ...
        PyObject_Del,                               /* tp_free */
};
static void
    object_dealloc(PyObject *self)
{
    // 调用int类型的 tp_free，即：PyObject_Del去销毁对象。
    Py_TYPE(self)->tp_free(self);
}

迷雾总会解
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python内存管理与垃圾回收机制
这家伙很懒，什么都没有留下
06-13 1272
Python的内存管理主要包括内存分配和内存回收两个方面。Python的内存分配主要由Python解释器负责，它会在需要时自动为对象分配内存，并在对象不再需要时自动回收内存。Python的内存回收主要通过引用计数和垃圾回收机制实现。Python的内存管理与垃圾回收机制是Python语言的重要组成部分。通过引用计数和垃圾回收机制，Python可以有效地管理内存，提高程序的性能和稳定性。然而，我们也需要注意内存泄漏的风险，并采取相应的措施来避免它。
Python内存管理以及垃圾回收机制
fenglepeng的博客
04-30 429
垃圾回收：用通俗的语言解释内存管理和垃圾回收的过程 大管家refchain 在Python的C源码中有一个名为refchain的环状双向链表，这个链表比较牛逼了，因为Python程序中一旦创建对象都会把这个对象添加到refchain这个链表中。也就是说他保存着所有的对象。例如： age = 18 hobby = "python" 引用计数器 在refchain中的所有对象内部都有一...
Python如何进行内存管理?---------- Python垃圾回收机制,以及在何种情况下会发生内存泄漏
cats_miao---python/java
06-28 1117
 Python如何进行内存管理?Python 采用引用计数的方式来管理分配的内存。Python 的每个对象都有一个引用计数，这个引用计数表明了有多少对象在指向它。当这个引用计数为 0 时，释放该对象的内存。为了解决循环引用的问题，Python提供了“标记-清除”法，用于释放循环引用的对象。为了加速Python的执行效率，Python 同时使用了一个内存池机制，用于管理对小块内存的申请和释放。 Py...
c++string 加引号_深入 Python (8) String 对象的结构
weixin_39621075的博客
10-22 97
上一节我们大体认识了 int 对象，在 Python 3 中实际上是以 LongObject 实现的，在 LongObject 的类型定义中，我们根据其类型名称 “int” 确认了这一点。回顾 int 对象的结构：与 Python 2 不同，Python 3 中实现了任意长度的整数，整数的实际数据是紧跟在 PyVarObjectHead 之后的一个连续内存，从整数对象被创建开始，直到香消玉殒的那一...
Linux 安装 gensim 失败问题
qq_42712299的博客
10-27 1466
今天安装gensim一直失败，网上找了各种办法都不得，换了各种python版本，虚拟环境都创建了好几次 numy、scipy都装了也无济于事，正准备放弃时，仔细看了错误信息的后几行 gensim/models/nmf_pgd.c: In function ‘__Pyx_InitGlobals’: gensim/models/nmf_pgd.c:16518:1: warning: ‘PyEval_InitThreads’ is deprecated [-Wdeprecated-declaratio..
推荐收藏系列：一文理解JVM虚拟机（内存、垃圾回收、性能优化）解决面试中遇到问题
wenlinxiang的博客
07-20 674
一. JVM内存区域的划分 1.1 java虚拟机运行时数据区 java虚拟机运行时数据区分布图： JVM栈（Java Virtual Machine Stacks）： Java中一个线程就会相应有一个线程栈与之对应，因为不同的线程执行逻辑有所不同，因此需要一个独立的线程栈，因此栈存储的信息都是跟当前线程（或程序）相关信息的，包括局部变量、程序运行状态、方法返回值、方法出口等等。每一个方法被调...
python基础-变量与内存管理
最新发布
sinat_35893916的博客
04-13 566
​ 变量指的就是随时可变化的量，量通常可以指实物的状态（比如：大树的高度、人的年龄等）。变量的组成通常为：变量名、变量值组成。变量名需要保持唯一性，通过变量名即可以找到对应数据。变量允许被多次更改，在程序运行过程中，实际就是一系列变量值的变化。
python的内存管理和垃圾回收机制详解
09-19
### Python的内存管理和垃圾回收机制详解 #### 一、引言 Python作为一种广泛使用的高级编程语言，其自动化的内存管理机制极大地简化了开发者的负担。本文将深入探讨Python中的内存管理与垃圾回收机制，帮助读者更好...
Python内存管理方式和垃圾回收算法解析
09-21
### Python内存管理方式和垃圾回收算法解析 #### 概述 Python作为一种动态类型的高级编程语言，在内存管理和垃圾回收方面有着独特的设计。为了更好地理解Python如何处理内存中的对象生命周期及其垃圾回收机制，本...
深入理解Python内存管理与垃圾回收，再也不怕问了（二）
12-21
在Python编程语言中，内存管理和垃圾回收是至关重要的概念，它们确保程序的高效运行和内存资源的有效利用。本文将深入探讨这两个主题，特别是关注Python如何处理引用计数、标记清除和分代回收策略。 首先，让我们...
Python垃圾回收与内存管理
普通Gopher
05-09 422
文章目录Python垃圾回收1. 引用计数器1.1 环状双向链表 refchain1.2 类型封装结构体1.3 引用计数器1.4 循环引用的问题2. 标记清除3. 分代回收4. 小结Python缓存1. 池2. free_list Python垃圾回收 引用计数器为主，标记清除和分代回收为辅+缓存机制 1. 引用计数器 1.1 环状双向链表 refchain 在Python程序中创建的任何对象都会放在refchain中 static PyObject refchain = {&r
unicode字符_Cpython源码阅读16-Unicode字符串底层存储结构
weixin_39831170的博客
12-08 340
底层有一个函数叫Py_Unicode_New的函数，为Unicode字符串申请空间，借助这个函数看一下unicode字符串的内存分布情况。像这样的特性API很多。特性API的作用PyObject *PyUnicode_New(Py_ssize_t size, Py_UCS4 maxchar)//这个函数负责为Unicode字符串申请空间{/* 传入两个参数，size表示字符的个数，多出来一个max...
JVM基础学习：基本原理、JVM结构、垃圾回收机制及回收算法、jdk1.8和jdk1.7区别
小喵的博客
03-25 5945
1、JDK的基本概念 我们可以把Java程序设计语言、Java虚拟机、 Java API类库这三部分统称为JDK( Java Development Kit)，JDK是用于支持Java程序开发的最小环境。另外，可以把Java API类库中的Java SE API子集和Java虚拟机这两部分统称为JRE( Java RuntimeEnvironment)，JRE是支持Java程序运行的标准环境。 ...
torchvision的使用(transforms用法介绍)
热门推荐
迷雾总会解
12-17 1万+
介绍 torchvision是pytorch的一个图形库，它服务于PyTorch深度学习框架的，主要用来构建计算机视觉模型。torchvision.transforms主要是用于常见的一些图形变换。以下是torchvision的构成： torchvision.datasets: 一些加载数据的函数及常用的数据集接口； torchvision.models: 包含常用的模型结构（含预训练模型），例如AlexNet、VGG、ResNet等； torchvision.transforms: 常用的图片变换，例如
解决：An HTTP error occurred when trying to retrieve this URL. HTTP errors are often intermittent
迷雾总会解
11-28 1万+
问题描述 在Anaconda下准备下载东西的时候，出现了这样的报错： Solving environment: failed CondaHTTPError: HTTP 000 CONNECTION FAILED for url <https://repo.anaconda.com/pkgs/r/noarch/repodata.json.bz2> Elapsed: - An HTTP error occurred when trying to retrieve this URL. HTTP
李宏毅机器学习作业4——Recurrent Neural Network
迷雾总会解
12-24 4051
​ 本作业来源于李宏毅机器学习作业说明，详情可看???? Homework 4 - Recurrent Neural Network(友情提示，可能需要翻墙) 参考 李宏毅2020机器学习作业4-RNN：句子情感分类 作业要求 通过循环神经网络（Recurrent Neural Networks, RNN）对句子进行情感分类。给定一句句子，判断这句句子是正面还是负面的（正面标1，负面标0） 用到的数据：链接：https://pan.baidu.com/s/1zfigNt2f1n4oTDRyeAZ
李宏毅机器学习作业3——Convolutional Neural Network
迷雾总会解
12-17 2863
本作业来源于李宏毅机器学习作业说明，详情可看???? Homework 3 - Convolutional Neural Network(友情提示，可能需要翻墙) 作业要求 作业要求： 在收集来的资料中均是食物的照片，共有11类，Bread, Dairy product, Dessert, Egg, Fried food, Meat, Noodles/Pasta, Rice, Seafood, Soup, and Vegetable/Fruit.我们要创建一个CNN，用来实现食物的分类。 我们可以借助
python基础 -13- 字符的编码和编码转换(ASCII,GB2312,GBK,Unicode,UTF)
迷雾总会解
08-06 2432
字符编码 介绍  计算机只认识二进制，生活中的数字要想让计算机理解就必须转换成二进制。十进制到二进制的转换只能解决计算机理解数字的问题，那么文字要怎么让计算机理解呢？  于是我们就选择了一种曲线救国的方式，既然数字可以转换成十进制，我们只要想办法把文字转换成数字，这样文字不就可以表示成二进制了么？  可是文字应该怎么转换成数字呢？就是强制转换啊，简单粗暴呀。 我们自己强行约定了一个表，把文字和数字对应上，这张表就相当于翻译，我们可以拿着一个数字来对比对应表找到相应的文字，反之亦然。 ASCII码  这张表
python基础 -04- 数据类型(int,float,str,bool)
迷雾总会解
08-05 2238
数字(int,float) int（整型）  在64位系统上，整数的位数为64位，取值范围为-263～263-1，即-9223372036854775808～9223372036854775807 long（长整型）  跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。  注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值