Python list对象常用方法深度分析

Python数据结构: 列表(List)详解 在Python中,列表(List)是一种有序、可变的数据类型,被广泛用于存储和处理多个元素。列表是一种容器,可以包含任意数据类型的元素,包括数字字符串列表字典等。本文将深入讨论列表的各个方面,包括基本语法、常见操作,以及实际应用场景。将覆盖列表的创建访问修改列表推导式和嵌套列表推导式等关键内容。 阅读详情

append()

源文件:Objects/listobject.c

static PyObject *
list_append(PyListObject *self, PyObject *object)
/*[clinic end generated code: output=7c096003a29c0eae input=43a3fe48a7066e91]*/
{
    if (_PyList_AppendTakeRef(self, Py_NewRef(object)) < 0) {
        return NULL;
    }
    Py_RETURN_NONE;
}
​
static inline int
_PyList_AppendTakeRef(PyListObject *self, PyObject *newitem)
{
    assert(self != NULL && newitem != NULL);
    assert(PyList_Check(self));
    Py_ssize_t len = PyList_GET_SIZE(self);
    Py_ssize_t allocated = self->allocated;
    assert((size_t)len + 1 < PY_SSIZE_T_MAX);
    if (allocated > len) {
        PyList_SET_ITEM(self, len, newitem);
        Py_SET_SIZE(self, len + 1);
        return 0;
    }
    return _PyList_AppendTakeRefListResize(self, newitem);
}

简单解释一下:

  • 开始断言,确保传入的参数都不为 NULL,确保传入的 self 参数是一个合法的列表对象
  • 使用 PyList_GET_SIZE() 函数获取当前列表对象的长度,并将其存储在 len 变量中
  • 获取当前列表对象已经分配的内存大小,并将其存储在 allocated 变量中。这个变量可以帮助确定是否需要重新分配更多的内存来容纳新元素
  • 断言当前列表对象的长度加上新元素的长度不会超过 PY_SSIZE_T_MAX,这是一个编译时常量,表示可用于任何一个 Python 对象的最大内存大小。
  • 如果当前分配的内存可以容纳新元素,则将新元素添加到列表对象中,并更新列表对象的长度。
  • 如果当前分配的内存不能容纳新元素,则调用 _PyList_AppendTakeRefListResize() 函数来重新调整列表对象的大小,并添加新元素.
int
_PyList_AppendTakeRefListResize(PyListObject *self, PyObject *newitem)
{
    Py_ssize_t len = PyList_GET_SIZE(self);
    assert(self->allocated == -1 || self->allocated == len);
    if (list_resize(self, len + 1) < 0) {
        Py_DECREF(newitem);
        return -1;
    }
    PyList_SET_ITEM(self, len, newitem);
    return 0;
}

可以看到,应该是调用_list_resize_方法进行扩容的。我看通过源码看看扩容策略

static int
list_resize(PyListObject *self, Py_ssize_t newsize)
{
    PyObject **items;
    size_t new_allocated, num_allocated_bytes;
    Py_ssize_t allocated = self->allocated;
​
    /* Bypass realloc() when a previous overallocation is large enough
       to accommodate the newsize.  If the newsize falls lower than half
       the allocated size, then proceed with the realloc() to shrink the list.
    */
    if (allocated >= newsize && newsize >= (allocated >> 1)) {
        assert(self->ob_item != NULL || newsize == 0);
        Py_SET_SIZE(self, newsize);
        return 0;
    }
​
    /* This over-allocates proportional to the list size, making room
     * for additional growth.  The over-allocation is mild, but is
     * enough to give linear-time amortized behavior over a long
     * sequence of appends() in the presence of a poorly-performing
     * system realloc().
     * Add padding to make the allocated size multiple of 4.
     * The growth pattern is:  0, 4, 8, 16, 24, 32, 40, 52, 64, 76, ...
     * Note: new_allocated won't overflow because the largest possible value
     *       is PY_SSIZE_T_MAX * (9 / 8) + 6 which always fits in a size_t.
     */
    new_allocated = ((size_t)newsize + (newsize >> 3) + 6) & ~(size_t)3;
    /* Do not overallocate if the new size is closer to overallocated size
     * than to the old size.
     */
    if (newsize - Py_SIZE(self) > (Py_ssize_t)(new_allocated - newsize))
        new_allocated = ((size_t)newsize + 3) & ~(size_t)3;
​
    if (newsize == 0)
        new_allocated = 0;
    if (new_allocated <= (size_t)PY_SSIZE_T_MAX / sizeof(PyObject *)) {
        num_allocated_bytes = new_allocated * sizeof(PyObject *);
        items = (PyObject **)PyMem_Realloc(self->ob_item, num_allocated_bytes);
    }
    else {
        // integer overflow
        items = NULL;
    }
    if (items == NULL) {
        PyErr_NoMemory();
        return -1;
    }
    self->ob_item = items;
    Py_SET_SIZE(self, newsize);
    self->allocated = new_allocated;
    return 0;
}
​

简单解释一下源码,关键点:

  1. 当 allocated // 2 <= newsize <= allocated时,列表仅仅插入新元素,不进行扩容;只要newsize不在这个范围内时,才需要执行扩容
  2. 扩容公式:new_allocated =newsize + (newsize >> 3) + 6) & ~(size_t)3,也就是new_allocated =newsize + newsize // 8 + 3 if newsize < 9 else 6

我们可以自己演算一下扩容空间的变化

列表为空时,allocated = 0
new_size    allocated//2 <= newsize <= allocated    newsize//8 + 3 if newsize < 9 else 6    allocated
  1                         false                         0 + 3 = 3                           1 + 3 = 4 
  2~4                       true                          不扩容                               4
  5                         false                         0 + 3 = 3                           5 + 3 = 8 6~8                       true                            不扩容                               8
  9                         false                         1 + 6 = 7                         9 + 7 = 16
  ...

为了验证推测 ,我们加入输出代码重新编译python

static int
list_resize(PyListObject *self, Py_ssize_t newsize)
{
    PyObject **items;
    size_t new_allocated, num_allocated_bytes;
    Py_ssize_t allocated = self->allocated;
​
    /* Bypass realloc() when a previous overallocation is large enough
       to accommodate the newsize.  If the newsize falls lower than half
       the allocated size, then proceed with the realloc() to shrink the list.
    */
    if (allocated >= newsize && newsize >= (allocated >> 1)) {
        assert(self->ob_item != NULL || newsize == 0);
        Py_SET_SIZE(self, newsize);
        return 0;
    }
​
    /* This over-allocates proportional to the list size, making room
     * for additional growth.  The over-allocation is mild, but is
     * enough to give linear-time amortized behavior over a long
     * sequence of appends() in the presence of a poorly-performing
     * system realloc().
     * Add padding to make the allocated size multiple of 4.
     * The growth pattern is:  0, 4, 8, 16, 24, 32, 40, 52, 64, 76, ...
     * Note: new_allocated won't overflow because the largest possible value
     *       is PY_SSIZE_T_MAX * (9 / 8) + 6 which always fits in a size_t.
     */
    new_allocated = ((size_t)newsize + (newsize >> 3) + 6) & ~(size_t)3;
    PyObject *str = PyUnicode_FromString("开始扩容啦");
    PyObject_Print(str, stdout, 0);
    printf("\n");
    printf("new_allocated     = %d\n", new_allocated);
​
    /* Do not overallocate if the new size is closer to overallocated size
     * than to the old size.
     */
    if (newsize - Py_SIZE(self) > (Py_ssize_t)(new_allocated - newsize))
        new_allocated = ((size_t)newsize + 3) & ~(size_t)3;
    // ......
}

重新编译后看看那_append_操作allocated的变化:

l = []
l.append(1) # 开始扩容啦  allocated     = 4
l.append(2) # 未执行该方法
l.append(3) # 未执行该方法
l.append(4) # 未执行该方法
l.append(5) # 开始扩容啦  allocated     = 8
l.append(6) # 未执行该方法
l.append(7) # 未执行该方法
l.append(8) # 未执行该方法
l.append(9) # 开始扩容啦  allocated     = 16

可以看到输出结果和我们的推测结果是一致的。

insert()

源文件:Objects/listobject.c.h

static PyObject *
list_insert(PyListObject *self, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    Py_ssize_t index;
    PyObject *object;
​
    if (!_PyArg_CheckPositional("insert", nargs, 2, 2)) {
        goto exit;
    }
    {
        Py_ssize_t ival = -1;
        PyObject *iobj = _PyNumber_Index(args[0]);
        if (iobj != NULL) {
            ival = PyLong_AsSsize_t(iobj);
            Py_DECREF(iobj);
        }
        if (ival == -1 && PyErr_Occurred()) {
            goto exit;
        }
        index = ival;
    }
    object = args[1];
    return_value = list_insert_impl(self, index, object);
​
exit:
    return return_value;
}

源文件:Objects/listobject.c

static PyObject *
list_insert_impl(PyListObject *self, Py_ssize_t index, PyObject *object)
/*[clinic end generated code: output=7f35e32f60c8cb78 input=858514cf894c7eab]*/
{
    if (ins1(self, index, object) == 0)
        Py_RETURN_NONE;
    return NULL;
}
​
static int
ins1(PyListObject *self, Py_ssize_t where, PyObject *v)
{
    Py_ssize_t i, n = Py_SIZE(self);
    PyObject **items;
    if (v == NULL) {
        PyErr_BadInternalCall();
        return -1;
    }
​
    assert((size_t)n + 1 < PY_SSIZE_T_MAX);
    if (list_resize(self, n+1) < 0)
        return -1;
​
    if (where < 0) {
        where += n;
        if (where < 0)
            where = 0;
    }
    if (where > n)
        where = n;
    items = self->ob_item;
    for (i = n; --i >= where; )
        items[i+1] = items[i];
    Py_INCREF(v);
    items[where] = v;
    return 0;
}

我们看一下关键部分

    if (where < 0) {
        where += n;
        if (where < 0)
            where = 0;
    }
    if (where > n)
        where = n;
    items = self->ob_item;
    for (i = n; --i >= where; )
        items[i+1] = items[i];

如果下标为负数,则+n,如果+n还是小于0,就将where设置为0,也就是插入到列表的头部

如果下标>0,且大于列表长度,就将where设置为列表长度,也就是插入到列表的尾部

最后将插入位置以后的元素逐一往后移动一个位置。

l = [1,2,3]
l.insert(-4,0) 
l # [0, 1, 2, 3]
l.insert(4,0) 
l # [0, 1, 2, 3, 0]

pop()

源文件:Objects/listobject.c.h

static PyObject *
list_pop(PyListObject *self, PyObject *const *args, Py_ssize_t nargs)
{
    PyObject *return_value = NULL;
    Py_ssize_t index = -1;
​
    if (!_PyArg_CheckPositional("pop", nargs, 0, 1)) {
        goto exit;
    }
    if (nargs < 1) {
        goto skip_optional;
    }
    {
        Py_ssize_t ival = -1;
        PyObject *iobj = _PyNumber_Index(args[0]);
        if (iobj != NULL) {
            ival = PyLong_AsSsize_t(iobj);
            Py_DECREF(iobj);
        }
        if (ival == -1 && PyErr_Occurred()) {
            goto exit;
        }
        index = ival;
    }
skip_optional:
    return_value = list_pop_impl(self, index);
​
exit:
    return return_value;
}

从这段源码可以看到,index默认传的-1,也就是默认删除最后一个元素

l = [1,2,3]
l.pop() # 3

源文件:Objects/listobject.c

static PyObject *
list_pop_impl(PyListObject *self, Py_ssize_t index)
/*[clinic end generated code: output=6bd69dcb3f17eca8 input=b83675976f329e6f]*/
{
    PyObject *v;
    int status;
​
    if (Py_SIZE(self) == 0) {
        /* Special-case most common failure cause */
        PyErr_SetString(PyExc_IndexError, "pop from empty list");
        return NULL;
    }
    if (index < 0)
        index += Py_SIZE(self);
    if (!valid_index(index, Py_SIZE(self))) {
        PyErr_SetString(PyExc_IndexError, "pop index out of range");
        return NULL;
    }
    v = self->ob_item[index];
    if (index == Py_SIZE(self) - 1) {
        status = list_resize(self, Py_SIZE(self) - 1);
        if (status >= 0)
            return v; /* and v now owns the reference the list had */
        else
            return NULL;
    }
    Py_INCREF(v);
    status = list_ass_slice(self, index, index+1, (PyObject *)NULL);
    if (status < 0) {
        Py_DECREF(v);
        return NULL;
    }
    return v;
}

如果列表为空,报错

如果下标为负数,则加上列表长度,转化为普通下标

如果下标不合法,报错

如果下标等于列表长度-1,调用list_resize处理,否则调用list_ass_slice删除元素

remove()

源文件:Objects/listobject.c

static PyObject *
list_remove(PyListObject *self, PyObject *value)
/*[clinic end generated code: output=f087e1951a5e30d1 input=2dc2ba5bb2fb1f82]*/
{
    Py_ssize_t i;
​
    for (i = 0; i < Py_SIZE(self); i++) {
        PyObject *obj = self->ob_item[i];
        Py_INCREF(obj);
        int cmp = PyObject_RichCompareBool(obj, value, Py_EQ);
        Py_DECREF(obj);
        if (cmp > 0) {
            if (list_ass_slice(self, i, i+1,
                               (PyObject *)NULL) == 0)
                Py_RETURN_NONE;
            return NULL;
        }
        else if (cmp < 0)
            return NULL;
    }
    PyErr_SetString(PyExc_ValueError, "list.remove(x): x not in list");
    return NULL;
}

通过循环查找要删除的元素,找到后调用_list_ass_slice_删除元素,没找到,报错

copy()

这是一个浅拷贝

源文件:Objects/listobject.c

static PyObject *
list_copy_impl(PyListObject *self)
/*[clinic end generated code: output=ec6b72d6209d418e input=6453ab159e84771f]*/
{
    return list_slice(self, 0, Py_SIZE(self));
}
​
static PyObject *
list_slice(PyListObject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
{
    PyListObject *np;
    PyObject **src, **dest;
    Py_ssize_t i, len;
    len = ihigh - ilow;
    if (len <= 0) {
        return PyList_New(0);
    }
    np = (PyListObject *) list_new_prealloc(len);
    if (np == NULL)
        return NULL;
​
    src = a->ob_item + ilow;
    dest = np->ob_item;
    for (i = 0; i < len; i++) {
        PyObject *v = src[i];
        Py_INCREF(v);
        dest[i] = v;
    }
    Py_SET_SIZE(np, len);
    return (PyObject *)np;
}

可以看到copy方法的本质是进行切片操作

该函数接受三个参数:

a:要切片的列表对象。 ilow:切片的起始索引。 ihigh:切片的结束索引。 该函数首先使用len = ihigh - ilow计算切片的长度。如果len小于或等于0,则使用PyList_New返回一个空列表。

否则,它将使用list_new_prealloc创建一个与切片大小相同的新列表对象,这是list_new的更快版本,允许预分配列表存储以提高性能。

然后,它使用遍历片中的每个项的循环将原始列表中的项复制到新列表中。对于每个项,它使用Py_INCREF增加其引用计数,并使用dest指针将其分配给新列表中的相应位置。

最后,它使用Py_SET_SIZE设置新列表的大小,它更新PyVarObject_HEAD宏中的ob_size字段以反映列表中的项数,并返回新列表。

注意,这个函数不会修改原始列表对象,而是创建一个新对象,它是原始列表对象切片的浅拷贝。

我们知道list对象的结构体中数组保存的是元素的指针,所以使用copy()复制底层数组时,拷贝的也是元素对象的指针,而不是具体的对象。

结合python程序,看看每句话是啥意思

这个函数不会修改原始列表对象,而是创建一个新对象

l1 = [1,[1,2,3]]
id(l1) # 4449821440
l2 = l1.copy()
id(l2) # 4449821440

可以看到内存地址是不一样的。

copy()复制底层数组时,拷贝的也是元素对象的指针,而不是具体的对象

l1 = [1,[1,2,3]]
id(l1[1]) # 4449821376
l2 = l1.copy()
id(l2[1]) # 4449821376
l2[1].append(4)
l2[1] # [1, 2, 3, 4]
l1[1] # [1, 2, 3, 4]
l2[0] = 2
l2 # [2, [1, 2, 3, 4]]
l1 # [1, [1, 2, 3, 4]]

可以看到,元素的内存地址是一样的,这样修改可变对象时,原始列表也会发生改变。修改不可变对象,对原列表无影响

深拷贝

既然浅拷贝会出现一些副作用,那怎么连元素对象一起拷贝呢?可以通过copy模块中的deepcopy()函数可以进行深拷贝

源文件:Lib/copy.py 我自己针对_list_类型进行简化版本

def deepcopy(x, memo=None, _nil=[]):
    if memo is None:
        memo = {}
​
    d = id(x)
    y = memo.get(d, _nil)
    if y is not _nil:
        return y
​
    cls = type(x)
    copier = _deepcopy_dispatch.get(cls)
    if copier is not None:
        y = copier(x, memo)
    # If is its own copy, don't memoize.
    if y is not x:
        memo[d] = y
        _keep_alive(x, memo) # Make sure x lives at least as long as d
    return y
​
_deepcopy_dispatch = d = {}
​
def _deepcopy_atomic(x, memo):
    return x
​
d[int] = _deepcopy_atomic
​
def _deepcopy_list(x, memo, deepcopy=deepcopy):
    y = []
    memo[id(x)] = y
    append = y.append
    for a in x:
        append(deepcopy(a, memo))
    return y
d[list] = _deepcopy_list
​
def _keep_alive(x, memo):
    try:
        memo[id(memo)].append(x)
    except KeyError:
        memo[id(memo)]=[x]
​
l = [1, [1,2,3]]
deepcopy(l)

可以看到会通过递归来复制所有对象,因此可以避免浅拷贝可能引起的数据共享问题。刚兴趣可以_debug_看一下

from copy import deepcopy
l1 = [1,[1,2,3]]
id(l1[1]) # 4450996032
l2 = deepcopy(l1)
id(l2[1]) # 4449860096
l2[1].append(4)
l2 # [1, [1, 2, 3, 4]]
l1 # [1, [1, 2, 3]]
l2[0] = 2
l2 # [2, [1, 2, 3, 4]]
l1 # [1, [1, 2, 3]]

可以看到使用深度拷贝,改变可变对象的数据,对原列表没有影响。

总结: deepcopy()函数仅适用于可变对象,例如列表、字典等。对于不可变对象,例如数字、字符串和元组,深拷贝和浅拷贝没有区别,因为无论是深拷贝还是浅拷贝都将创建一个指向同一内存地址的新对象。

---------------------------END---------------------------

题外话

当下这个大数据时代不掌握一门编程语言怎么跟的上脚本呢?当下最火的编程语言Python前景一片光明!如果你也想跟上时代提升自己那么请看一下.

在这里插入图片描述

感兴趣的小伙伴,赠送全套Python学习资料,包含面试题、简历资料等具体看下方。


👉优快云大礼包🎁:全网最全《Python学习资料》免费赠送🆓!(安全链接,放心点击)

一、Python所有方向的学习路线

Python所有方向的技术点做的整理,形成各个领域的知识点汇总,它的用处就在于,你可以按照下面的知识点去找对应的学习资源,保证自己学得较为全面。

img
img

二、Python必备开发工具

工具都帮大家整理好了,安装就可直接上手!img

三、最新Python学习笔记

当我学到一定基础,有自己的理解能力的时候,会去阅读一些前辈整理的书籍或者手写的笔记资料,这些笔记详细记载了他们对一些技术点的理解,这些理解是比较独到,可以学到不一样的思路。

img

四、Python视频合集

观看全面零基础学习视频,看视频学习是最快捷也是最有效果的方式,跟着视频中老师的思路,从基础到深入,还是很容易入门的。

img

五、实战案例

纸上得来终觉浅,要学会跟着视频一起敲,要动手实操,才能将自己的所学运用到实际当中去,这时候可以搞点实战案例来学习。

img

六、面试宝典

在这里插入图片描述

在这里插入图片描述

简历模板在这里插入图片描述

👉优快云大礼包🎁:全网最全《Python学习资料》免费赠送🆓!(安全链接,放心点击)

若有侵权,请联系删除

Python列表(list)详解 Python 列表list 详细讲解,包含列表list的增删改查。append()、extend()、inset(),del、remove()、pop()、clear(),index(),count()方法详解,列表索引和切片详解 阅读详情

相关推荐

微波无源器件 功分器1 新型方波导双模无功功分器

本名证明了一种基于有着特定功能的(dedicated)T性匹配元件(散射件)的进化结点的新型波导双模两路功分器的可行性。这个散射件,有着面向三个部分的匹配部分,提供了等效功分并且朝着对应的输出端口传输矩形波导的两个TE10/TE01正交模式。所提出的设计紧凑,易于比例变化并且能够级联来获得。

qq_45245770的博客 1394

python的List对象

**PyListObject对象** ```c typedef struct { PyObject_VAR_HEAD PyObject **ob_itemc; Py_ssize_t allocated; } PyListObject; ``` ob_itemc是指向元素列表的一个指针,在PyListObject对象中,有一个allocated字段,那么这个字段与PyObject_VAR_HEAD中的ob_size字段有什么关系呢?实际上,allocated指的是当前对象可容纳的元素的

你呢的博客 2386

fNIRS 公开数据集整理

关注“心仪脑”查看更多脑科学知识的分享。 关键词:数据整理、fNIRS 之前我们向大家推送了 Public Neuroscience Dataset 系列主题的第一期:《EEG公开数据集》,我们同时意识到大家对于神经科学公开数据集的需求。本期是该系列主题的第二期,我们在延续第一期初衷的基础上,整理了功能性近红外光谱(fNIRS)技术的公开数据集。 fNIRS 是一种非侵入性、便携且价格低廉的光学神经成像技术,它具有可观的空间和时间分辨率。因fNIRS技术问世较EEG晚了许多,所以应用此技术开展研究发.

psybrain的博客 4272

Python 中list使用详解

append():向列表末尾添加一个元素。 extend():将一个列表中的元素追加到另一个列表的末尾。 insert():向列表中的指定位置插入一个元素。 remove():删除列表中第一个匹配指定元素的元素。 pop():删除并返回列表中指定位置的元素。 index():返回列表中第一个匹配指定元素的索引。 count():返回列表中指定元素的数量。 sort():原地对列表进行排序。 reverse():原地反转列表中的元素顺序。 copy():返回一个新的列表,包含原始列表中的所有元素。

m0_50816276的博客 4014

R语言计算植物群落重要值:从基础概念到优势种判定

在植被生态学研究中,重要值是衡量物种在群落中地位的核心指标,它综合了相对多度、相对频度与相对显著度三个维度,能够客观反映物种的数量优势、分布广度与空间占据能力。理解重要值的生态学逻辑,是开展群落分类、优势种判定及多样性分析的基础。而R语言凭借其批量处理、可复现和与后续多元统计无缝衔接的优势,成为生态学研究者处理样方数据的高效工具。从野外记录的宽表到标准化长表,再到分组汇总计算相对指标,R语言能够显著提升数据处理效率与准确性。本文以实测群落数据为例,系统梳理重要值的两种算法口径、基于dplyr和tidyr的完

weixin_42634811的博客 269

YOLOv8实例分割实战:从LabelMe标注到模型训练全流程(附完整代码)

本文详细介绍了YOLOv8实例分割的完整实战流程,涵盖从使用LabelMe进行数据标注、格式转换,到构建数据集、配置参数并完成模型训练的全过程。文章提供了详尽的代码示例和常见问题解决方案,旨在帮助开发者高效掌握YOLOv8实例分割技术,快速应用于实际项目。

java5的博客 816

python list 存放对象

Python 列表中存放对象的探索 Python是一种高度灵活且强大的编程语言,它支持使用列表来存储对象。列表是Python内建的一种可变容器,可以存放包括数字、字符串在内的任何对象,甚至是自定义类型的实例。本文将通过代码示例来探索如何在Python列表中存放对象,并展示如何在实际应用中使用这一功能。 1. 理解 Pyth...

weixin_40978399的博客 475

避开SAM3安装大坑:手把手教你用国内镜像和Modelscope权重快速跑通Demo

本文详细介绍了如何在国内环境下快速部署SAM3视觉大模型,包括使用国内镜像加速Python包安装、通过Modelscope获取权重文件以及解决CUDA 11.8等低版本适配问题。手把手教你避开常见安装陷阱,实现高效Demo运行。

weixin_30642561的博客 1407

python调用r语言函数_让R与Python共舞

R(又称R语言)是一款开源的跨平台的数值统计和数值图形化展现工具。通俗点说,R是用来做统计和画图的。R拥有自己的脚本语言和大量的统计、图形库(得益于开源社区),这让她看起来既美又实用。与其他同类软件(如 SPSS)相比,R的特点是纯命令行的,这倒也好,我们更应该把注意力放在数据本身,而非统计工具的UI。R虽说有一套自己的语言,还挺完备,但她最专业的还是做统计和画图,而像连接数据库、文本处理、文件操...

weixin_35730901的博客 6068

SVDD和OCSVM的比较

OCSVM(one class support vector machine)即单类支持向量机,最先提出的文献为:Estimating the support of a high-dimensional distribution.该模型 将数据样本通过核函数映射到高维特征空间,使其具有更良好的聚集性,在特征空间中求解一个最优超平面实现目标数据与坐标原点的最大分离,如图1: 坐标原...

qq_33880788的博客 1万+

为什么桥式传感器(Bridge Sensor)需要用到仪表放大器?

仪表放大器在桥式传感器的应用里起到关键作用,本文介绍桥式传感器的原理、特性,以及信号调理过程,并附上了一个 TINA - TI 的仿真电路。

疯狂的运放 1528

Python for循环的数据类型

可以直接作用于for循环的数据类型有以下几种: 一类是集合数据类型,如list,tuple,dict,set,str等 一类是generator,包括生成器和带yield的generator function 这些可以直接作用于for 循环的对象统称为可迭代对象:Iterable 可以使用isinstance()判断一个对象是否为可Iterable对象 >>> fro...

bl128ve900的博客 3655

vue3 - element-plus表格组件el-table实现鼠标拖曳排序功能,vue3 Table表格拖拽排序,表格每行使用鼠标拖动进行排序功能,表格拖拽排序实现(详细示例代码,一键复制开箱即用

vue3,elementPlus,el-table,typescript,表格组件,Table表格,表格拖动排序,表格拖曳排序,鼠标拖拽表格进行排序功能,elementplus表格如何实现拖动每行进行排序操作,表格拖动改变顺序,鼠标拖曳,表格内的数据项拖拽排序,vue3如何实现element-Plus表格组件进行表格内的数据项拖拽排序,列表拖拽排序效果,实现table动态拖拽,鼠标拖着排序,vue3 element Plus 表格拖曳拖动拖拽 排序,el-table拖拽排序实现,表格内容拖拽重新排序,树形表

✅ 精选推荐文章 1万+

python中list方法与函数学习笔记总结,全面!!

list数据类型在python非常重要,日后学习的数据结构,机器学习等方面都要用到list,list中最重要的部分之一,便是函数与方法,本文将会详细讲解list的函数与方法,相信你一定可以有所收获。

wish_you_luck的博客 3829

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

Python中List的深度解析与智能编程工具的应用

最新接入DeepSeek-V3模型,点击下载最新版本InsCode AI IDE Python中List的深度解析与智能编程工具的应用 Python中的list是开发者最常用的数据结构之一,其灵活性和多功能性使其在各种应用场景中都扮演着重要角色。无论是简单的数据存储、复杂的算法实现,还是大规模的数据处理任务,list都能胜任。然而,随着项目复杂度的增加,手动编写和维护list相关代码可能会变得繁琐...

inscode_055的博客 817

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Python List操作:+、+=、extend的深度解析

本文深入分析了Python中三种列表合并操作:+运算符、+=运算符和extend()方法。+会创建新列表,适合保留原列表的场景但性能较差;+=和extend()都是原地操作,性能更优且支持任意可迭代对象。性能测试显示+最慢,+=和extend()相近。推荐根据需求选择:需要新列表用+,修改列表优先用可读性更好的extend(),简洁场景可用+=。文章还通过实际案例和常见误区,帮助开发者正确选择和使用这三种操作方式。

软件科学-郝学胜 1205

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

【Python】成功解决AttributeError: ‘list‘ object has no attribute ‘split‘

🔥【Python高手之路】轻松搞定AttributeError: ‘list’ object无‘split’属性🔥 你是不是也曾在Python编程中遇到过`AttributeError: 'list' object has no attribute 'split'`的尴尬?别担心,这篇文章将带你一探究竟!从错误原因到解决方案,再到深入理解Python数据类型,让你轻松避开陷阱,成为Python高手!还有实用技巧教你如何排查和调试错误,让你的代码更稳健!赶紧来学,让你在Python道路上越走越顺!#Py

创作高质量博文,分享知识,共同进步! 9736

Python返回数组/List长度的方法

Python获取列表长度主要通过内置函数len()实现,适用于所有可迭代对象。核心要点: 标准用法:len(list)直接获取元素个数,时间复杂度O(1) 嵌套列表:仅统计外层元素,需遍历/递归计算嵌套总元素数 numpy数组:需用.shape或.size获取维度信息 注意事项:非可迭代对象会报错,建议异常处理 len()是最高效的官方推荐方法,避免手动计数。特殊数据结构如numpy数组需使用对应方法获取完整维度信息。

Datafox(数据狐199-7010-8018) 574

深度学习中python常用知识

python包中的__init__.py文件的作用: 参考博客 实际上是为了精简导入路径。

DLUT_yan的博客 764

Python:list.append() 和 list.extend() 的用法

1list.append() append() 追加单个元素到List的尾部,只接受一个参数,参数可以是任何数据类型,被追加的元素在List中保持着原结构类型。 栗子: a=[1,3,4,5] b=(1,2) a.append(b) print(a) # result [1,3,4,5,(1,2)] 2 list.extend() extend() 将一个列表中每个元素分别添加到另一个列表中,只接受一个参数。 栗子: a=[1,3,4,5] b=(1,2) a.extend(b) ..

weixin_40522801的博客 9561

Python [] 竟然比 list() 快3倍!!!

点击上方蓝色小字,关注“涛哥聊Python”重磅干货,第一时间送达作者 |豌豆花下猫来源 | Python猫在日常使用 Python 时,我们经常需要创建一个列表,相信大家都很熟练了吧...

涛哥聊Python 494

Python中List的深度解析与高效应用

最新接入DeepSeek-V3模型,点击下载最新版本InsCode AI IDE 标题:Python中List的深度解析与高效应用 在编程的世界里,数据结构的选择至关重要。对于Python程序员来说,list 是最常用的数据结构之一。它不仅灵活多变,而且功能强大,能够满足各种应用场景的需求。然而,随着项目的复杂度增加,如何高效地管理和操作 list 成为了一个挑战。本文将深入探讨 Python 中...

inscode_094的博客 875

基于Python深度学习/C/C++以及常用环境测试案例

【代码】基于Python深度学习/C/C++以及常用环境测试案例。

leoatliang的博客 829

Python list()与map()深度解析:从基础到高阶的性能优化与实战应用

在Python编程中,可迭代对象和迭代器是处理数据集合的核心概念。可迭代对象实现了__iter__()方法,允许我们遍历其元素;而迭代器则通过__next__()方法实现惰性求值,仅在需要时生成数据,这种机制能显著提升内存效率。理解这些原理对于编写高性能代码至关重要,尤其是在处理大规模数据集或构建数据管道时。list()函数作为序列化工具,能将任何可迭代对象(如元组、集合、字典甚至map对象)转换为列表,支持随机访问和多次遍历,但需警惕其一次性加载全部数据到内存的特性。map()函数则体现了函数式编程思想,

weixin_33980459的博客 444

python中的list如何深度拷贝

在 Python 中,可以使用 copy 模块中的 deepcopy 函数来进行深度拷贝。 示例: import copy original_list =[[1, 2, 3], [4, 5, 6], [7, 8, 9]] copied_list = copy.deepcopy(original_list) ...

weixin_42611177的博客 629

Python内置函数len、list与locals的深度解析与优化实践

Python内置函数是语言核心功能的重要组成部分,其设计遵循鸭子类型和EAFP原则。以len()函数为例,它通过调用对象的__len__魔术方法实现,这种机制使得不同类型的数据结构都能以统一接口获取长度信息,体现了Python的多态特性。在性能优化方面,理解内置函数的底层原理至关重要,例如对于大数据处理场景,避免不必要的list转换可以显著减少内存消耗。locals()函数则展示了Python动态编程的能力,它返回当前作用域的变量字典,在元编程和模板渲染等场景中有特殊价值。掌握这些内置函数的正确使用方式,能

weixin_33971977的博客 310
上一篇: python中函数的返回值详解
下一篇: 【Python脚本】Python大麦抢购源码分享
Python_P叔
博客等级 码龄3年 5454粉丝 827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值