当前位置:首页 > 编程教程 > Python技术文章 > python中列表长度可变吗

python中列表长度是否可以调节

  • 发布时间:
  • 作者:码农之家
  • 点击:114

这篇文章主要知识点是关于python、列表长度、Python列表的长度调节方法(附代码) 的内容,如果大家想对相关知识点有系统深入的学习,可以参阅以下电子书

ArcGIS下的Python编程
  • 类型:编程设计大小:144 MB格式:PDF作者:包瑞清
立即下载

python中列表长度可变吗

python中列表长度可变吗

 

python中列表长度可变吗?下面给大家介绍一下python中可变和不可变的类型:

可变、不可变
可变/不可变类型,指的是:内存id不变,type也不变的前提下,value是否是可变的。
int()和str()都是不可变类型
列表、字典是可变类型

对于可变对象,比如list,对list进行操作,list内部的内容是会变化的,比如:

>>> a = ['c', 'b', 'a']>>> a.sort()>>> a
['a', 'b', 'c']

相关推荐:《python视频教程》

而对于不可变对象,比如str,对str进行操作呢:

>>> a = 'abc'>>> a.replace('a', 'A')'Abc'>>> a'abc'

虽然字符串有个replace()方法,也确实变出了'Abc',但变量a最后仍是'abc',应该怎么理解呢?

我们先把代码改成下面这样:

>>> a = 'abc'>>> b = a.replace('a', 'A')>>> b'Abc'>>> a'abc'

要始终牢记的是,a是变量,而'abc'才是字符串对象!有些时候,我们经常说,对象a的内容是'abc',但其实是指,a本身是一个变量,它指向的对象的内容才是'abc':

python中列表长度可变吗

当我们调用a.replace('a', 'A')时,实际上调用方法replace是作用在字符串对象'abc'上的,而这个方法虽然名字叫replace,但却没有改变字符串'abc'的内容。相反,replace方法创建了一个新字符串'Abc'并返回,如果我们用变量b指向该新字符串,就容易理解了,变量a仍指向原有的字符串'abc',但变量b却指向新字符串'Abc'了:

python中列表长度可变吗

所以,对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的。

以上就是python中列表长度可变吗的详细内容,更多请关注码农之家其它相关文章!

Python列表的长度调节方法(附代码)

本篇文章给大家带来的内容是关于Python列表的长度调节方法(附代码),有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。

Python 的列表(list)是一个非常灵活的数组,可以随意调整长度。正是因为这种便利,使得我们会情不自禁地去修改数组以满足我们的需求,其中相比于insert, pop 等等而言, append 用法更常见。

有像这样使用:

>>> test = []
>>> test.append(1)
>>> test.append({2})
>>> test.append([3])
>>> print test

# 输出 
[1, set([2]), [3]]

也有像这样使用的:

test = []

for i in range(4):
    test.append(i)
print test

# 输出 
[0, 1, 2, 3]

这样用很开心,也很满足。

但其实只要遇到能够动态修改数据长度场景,我们都应该马上反应过来一点,那就是内存管理的问题。

如果运行效率和便捷性同时满足的话,那简直就是大大的福音呀。

然而,上帝为你开启一扇窗的同时肯定也已经关上了一扇门了!

吝啬的初始化

深受预分配知识的熏陶,我们也是觉得 list 在初始化是有分配一定的长度的,要不然每次都申请内存那得多 ”low“ 啊。

然后实际上 list 真的就是这么 ”low“:

import sys

test = []
test_1 = [1]
print sys.getsizeof(test)
print sys.getsizeof(test_1) - sys.getsizeof(test)

# 输出 
72     # 空列表内存大小,也是 list 对象的总大小
8       # 代表增加一个成员,list 增加的大小

我们的猜测是,list 在定义之后,会预先分配好一个一定大小的池用来塞数据,以避免动不动就申请内存。

但是在上面的实验看出,一个成员的列表,比一个空列表,长度仅仅只是大了 8 字节,如果真的存在这样一个预分配的池,那么在预分配个数之内添加成员,两者的内存大小应该是保持不变才对。

所以可以猜测这块 list 应该是没有这样的一个预分配内存池。这里需要来个实锤

PyObject *
PyList_New(Py_ssize_t size)
{
    PyListObject *op;
    size_t nbytes;

    if (size < 0) {
        PyErr_BadInternalCall();
        return NULL;
    }
    /* Check for overflow without an actual overflow,
     *  which can cause compiler to optimise out */
    if ((size_t)size > PY_SIZE_MAX / sizeof(PyObject *))
        return PyErr_NoMemory();
        
    // list对象指针的缓存
    if (numfree) {
        numfree--;
        op = free_list[numfree];
        _Py_NewReference((PyObject *)op);
    } else {
        op = PyObject_GC_New(PyListObject, &PyList_Type);
        if (op == NULL)
            return NULL;
    }
    
    // list 成员的内存申请
    nbytes = size * sizeof(PyObject *);
    if (size <= 0)
        op->ob_item = NULL;
    else {
        op->ob_item = (PyObject **) PyMem_MALLOC(nbytes);
        if (op->ob_item == NULL) {
            Py_DECREF(op);
            return PyErr_NoMemory();
        }
        memset(op->ob_item, 0, nbytes);
    }
    Py_SIZE(op) = size;
    op->allocated = size;
    _PyObject_GC_TRACK(op);
    return (PyObject *) op;
}

当我们在执行 test = [1] 时,实际上只做了两件事:

根据成员的数目,构建相应长度的空列表;(上述代码)

一个个将这些成员塞进去;

可能有童鞋会觉得,在塞成员的那一步,说不定会触发什么机制使它变大?

很可惜,因为初始化用的方法是 PyList_SET_ITEM, 所以这里是木有的触发什么机制,只是简单的数组成员赋值而已:

#define PyList_SET_ITEM(op, i, v) (((PyListObject *)(op))->ob_item[i] = (v))

所以整个 list 的初始化,还真的就是木有预分配的内存池,直接按需申请,一个萝卜一个坑,实在得狠;

可变长的关键

初始化过程是这样还可以理解,如果运行中还这样的话,那就有点说不过去了。

试想下,在文章开头用 append 的例子中,如果每 append 一个元素就申请一次内存,那么list 可能要被吐槽到怀疑人生了, 所以很明显,在对于内存的申请,它还是有自己的套路的。

在 list 里面,不管是 insert 、pop 还是 append,都会遇到 list_resize,故名思义,这个函数就是用来调整 list 对象的内存占用的。

static int
list_resize(PyListObject *self, Py_ssize_t newsize)
{
    PyObject **items;
    size_t new_allocated;
    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_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().
     * The growth pattern is:  0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ...
     */
    # 确定新扩展之后的占坑数
    new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6);

    /* check for integer overflow */
    if (new_allocated > PY_SIZE_MAX - newsize) {
        PyErr_NoMemory();
        return -1;
    } else {
        new_allocated += newsize;
    }

    if (newsize == 0)
        new_allocated = 0;

    # 申请内存
    items = self->ob_item;
    if (new_allocated <= (PY_SIZE_MAX / sizeof(PyObject *)))
        PyMem_RESIZE(items, PyObject *, new_allocated);
    else
        items = NULL;
    if (items == NULL) {
        PyErr_NoMemory();
        return -1;
    }
    self->ob_item = items;
    Py_SIZE(self) = newsize;
    self->allocated = new_allocated;
    return 0;
}

在上面的代码中,频繁看到两个名词:newsize 和 new_allocated, 这里需要解释下,newsize 并不是 增加/减少 的个数,而是 增加/减少 之后的成员总数目。比方说:

a = [1, 2, 3]
a.append(1)

上面的 append 触发list_resize 时, newsize 是 3 + 1, 而不是 1;这边比较重要,因为在 pop 这类减少列表成员时候,就是传入缩减后的总数目。

在 list 的结构定义中,关于长度的定义有两个,分别是 ob_size(实际的成员数),allocated(总成员数)

它们之间的关系就是:

 0 <= ob_size <= allocated
 len(list) == ob_size

所以 new_allocated 就很好理解了,这个就是新的总坑数。

当名词含义理解得差不多时,我们就能顺藤摸瓜知道一个列表在list_resize 之后,大小会变成怎样?

方法其实从上面注释和代码都说得很明白了,这里再简单整理下:

先确定一个基数:new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6);

判断下 new_allocated + newsize 有没有超过 PY_SIZE_MAX, 如果超过了,直接报错;

最终确定新的总坑数是:new_allocated + newsize, 如果 newsize 是 0, 那么总坑数直接为 0 ;

下面演示下:

#coding: utf8
import sys

test = []
raw_size = sys.getsizeof(test)

test.append(1)
print "1 次 append 减去空列表的内存大小:%s " % (sys.getsizeof(test) - raw_size)

test.append(1)
print "2 次 append 减去空列表的内存大小:%s " % (sys.getsizeof(test) - raw_size)

test.append(1)
print "3 次 append 减去空列表的内存大小:%s " % (sys.getsizeof(test) - raw_size)

test.append(1)
print "4 次 append 减去空列表的内存大小:%s " % (sys.getsizeof(test) - raw_size)

test.append(1)
print "5 次 append 减去空列表的内存大小:%s " % (sys.getsizeof(test) - raw_size)

test.append(1)
print "6 次 append 减去空列表的内存大小:%s " % (sys.getsizeof(test) - raw_size)
# 输出结果
1 次 append 减去空列表的内存大小:32
2 次 append 减去空列表的内存大小:32
3 次 append 减去空列表的内存大小:32
4 次 append 减去空列表的内存大小:32
5 次 append 减去空列表的内存大小:64
6 次 append 减去空列表的内存大小:64

开始简单的代入法一步步算:

其中:

new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6) + newsize (因为下面的 newsize > 0)

当原allocated >= newsize 并且 newsize >= 原allocated / 2 时,不改变 allocated 不申请内存直接返回

第 n 次 append列表原长度新增成员数原 allocatednewsizenew_allocated
10100 + 1 = 13 + 1 = 4
21141 + 1 = 2无需改变
32142 + 1 = 3无需改变
43143 + 1 = 4无需改变
54144 + 1 = 53 + 5 = 8
65185 + 1 = 6无需改变

通过上面的表格,应该比较清楚看到什么时候会触发改变 allocated,并且当触发时它们是如何计算的。为什么我们需要这样关注 allocated?理由很简单,因为这个值决定了整个 list 的动态内存的占用大小;

扩容是这样,缩容也是照猫画虎。反正都是算出新的 allocated, 然后由 PyMem_RESIZE 来处理。

总结

综上所述,在一些明确列表成员或者简单处理再塞入列表的情况下,我们不应该再用下面的方式:

test = []

for i in range(4):
    test.append(i)
print test

而是应该用更加 pythonic 和 更加高效的列表推导式:test = [i for i in range(4)]。

以上就是Python列表的长度调节方法(附代码)的详细内容,更多请关注码农之家其它相关文章!

以上就是本次给大家分享的关于java的全部知识点内容总结,大家还可以在下方相关文章里找到相关文章进一步学习,感谢大家的阅读和支持。

您可能感兴趣的文章:

  • Python list列表中删除多个重复元素的方法实例
  • python遍历列表和数组实例讲解
  • python获取列表最后一个元素的方法总结
  • 《Python编程:从入门到实践》第三章:列表简介
  • python列表长度 相关电子书
    学习笔记
    网友NO.440754

    python面试题之列表声明实例分析

    本文实例讲述了python面试题之列表声明。分享给大家供大家参考,具体如下: 下面程序输出的结果为? val = [['a']*2]*2print valval[0][1]='b'print val 答案为: [['a', 'a'], ['a', 'a']] [['a', 'b'], ['a', 'b']] 而不是 [['a', 'a'], ['a', 'a']] [['a', 'b'], ['a', 'a']] 请看下面的例子: val = ['a']*2 #或者直接声明val = ['a','a']print valprint id(val)print id(val[0])print id(val[1]) 输出的结果为 ['a', 'a'] 39993928 38858384 38858384 可以看到val中的两个'a'是指向的同一个地址: 再看下面的代码: 直接声明的话,不会改变后面的'a' val = [['a','a'],['a','a']]print valprint id(val)print id(val[0][0])print id(val[1][0])val[0][0] = 'b'print valprint id(val)print id(val[0][0])print id(val[1][0]) 结果为: [['a', 'a'], ['a', 'a']] 39405512 38268560 38268560 [['b', 'a'], ['a', 'a']] 39405512 38390280 38268560 而 val = [['a','a']]*2print valprint id(val)print id(val[0][0])print id(val[1][0])val[0][0] =……

    网友NO.109929

    浅谈Python 列表字典赋值的陷阱

    今天在用python刷leetcode 3Sum problem时,调入到了一个大坑中,检查半天并没有任何逻辑错误,但输出结果却总是不对,最终通过调试发现原来python中list和dict类型直接赋值竟然是浅拷贝!!!因此,在实际实验中,若要实现深拷贝,建立新list或dict,使新建的list或dict变量和以前的变量只是具有相同的值,但是却具有不同的存储地址,保证在改变以前的list变量的时候,不会对新的list产生任何影响。 python中的深拷贝的实现需要通过copy.deepcopy函数来实现。 具体操作如下: # python from copy import deepcopy - 关于dict的深浅拷贝实验示例 a=dict() #建立字典 a['e1']=1 #添加字典元素 a['e2']=2 a #查看字典内容,输出如下{'e1': 1, 'e2': 2} b=a #浅拷贝 c=deepcopy(a) #深拷贝 a['e1']=3 #改变字典的内容,观察深浅拷贝变量的变化 a{'e1': 3, 'e2': 2} b{'e1': 3, 'e2': 2} c{'e1': 1, 'e2': 2} - 关于list的深浅……

    网友NO.489723

    Python数据结构与算法之列表(链表,linked list)简单实现

    Python 中的 list 并不是我们传统(计算机科学)意义上的列表,这也是其 append 操作会比 insert 操作效率高的原因。传统列表——通常也叫作链表(linked list)——通常是由一系列节点(node)来实现的,其每一个节点(尾节点除外)都持有一个指向下一个节点的引用。 其简单实现: class Node: def __init__(value, next=None): self.value = value self.next = next 接下来,我们就可使用链表的结构来组织所有节点了。 L = None('a', Node('b', Node('c', Node('d')))) L.next.next.value'c' 这是所谓的单向链表,双向链表的各节点还需要持有一个指向前一节点的引用。 总结 以上就是本文关于Python数据结构与算法之列表(链表,linked list)简单实现的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站:浅谈Python由__dict__和dir()引发的一些思考、python中hashlib模块用法示例等,有什么问……

    网友NO.118752

    Python 修改列表中的元素方法

    如下所示: #打印列表文件def show_magicians(magics) :for magic in magics :print(magic)#修改列表文件def make_great(magics) :length=len(magics)for a in range(1,length+1) :magics[a-1]='the Great'+magics[a-1]#输入信息def input_name(magics) :n=input('请输入魔术师的个数 : ')n=int(n)for a in range(1,n+1) :name=input("请输入魔术师的姓名 : ")magics.append(name)#主函数部分magics=[]input_name(magics)print('修改之前的文件列表:')show_magicians(magics)print('\n')print('修改副本之后的文件列表:')make_great(magics[:])show_magicians(magics)print('\n')print('修改原本之后的文件列表:')make_great(magics)show_magicians(magics)print('\n') 以上这篇Python 修改列表中的元素方法就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持码农之家。 ……

    网友NO.265336

    Python学习小技巧之列表项的拼接

    本文介绍的是关于Python实现列表项拼接的一个小技巧,分享出来供大家参考学习,下面来看看详细的介绍: 典型代码: data_list = ['a', 'b', 'c', 'd', 'e', 'f'] separator = '\t' data_joined = separator.join(data_list) print(data_joined) 其输出为: a b c d e f 应用场景 在实现很多业务需求的时候,需要将列表中的每一项按照某种分隔符拼接成一个串,以完成某种序列化模式,用于网络传输或者日志记录,亦或者是形成某种中间值供后续过程使用。 为什么会当成一个小技巧? 工作过程中,遇到类似的应用场景的时候,通过for循环来完成相关需求几乎就是第一个想到的,但是采用for循环的话,会多处几行代码,会花费多一点儿时间去理解代码的逻辑,特别是还涉及到需要处理最后一个列表项的情况下:我们不希望最终得到的字符串的后缀是一个分隔符。 带来的好处 1. 代码更加紧……

    <
    1
    >

    Copyright 2018-2020 www.xz577.com 码农之家

    版权投诉 / 书籍推广 / 赞助:520161757@qq.com