精华内容
下载资源
问答
  • 列表list处理一组有序项目的数据结构,即你可以在一个列表中存储一个序列的项目。假想你有一个购物列表,上面记载着你要买的东西,你就容易理解列表了。只不过在你的购物表上,可能每样东西都独自占有一行,而在...

    在Python中有三种内建的数据结构——列表、元组和字典。我们将会学习如何使用它们,以及它们如何使编程变得简单。

    列表

    list是处理一组有序项目的数据结构,即你可以在一个列表中存储一个序列的项目。假想你有一个购物列表,上面记载着你要买的东西,你就容易理解列表了。只不过在你的购物表上,可能每样东西都独自占有一行,而在Python中,你在每个项目之间用逗号分割。  列表中的项目应该包括在方括号中,这样Python就知道你是在指明一个列表。一旦你创建了一个列表,你可以添加、删除或是搜索列表中的项目。由于你可以增加或删除项目,我们说列表是 可变的 数据类型,即这种类型是可以被改变的。

    使用列表#!/usr/bin/python

    # Filename: using_list.py

    # This is my shopping list

    shoplist = ['apple','mango','carrot','banana']

    print 'I have',len(shoplist),'items to purchase.'

    print 'These items are:',

    # Notice the comma at end of the line

    for item in shoplist:

    print item,

    print '\nI also have to buy rice.'

    shoplist.append('rice')

    print 'My shopping list is now', shoplist

    print 'I will sort my list now'

    shoplist.sort()

    print 'Sorted shopping list is', shoplist

    print 'The first item I will buy is', shoplist[0]

    olditem = shoplist[0]

    del shoplist[0]

    print 'I bought the', olditem

    print 'My shopping list is now', shoplist

    如何工作

    变量shoplist是某人的购物列表。

    在shoplist中,我们只存储购买的东西的名字字符串,但是你可以在列表中添加任何种类的对象包括数甚至其他列表。

    使用了for..in循环在列表中各项目间递归。

    列表是一个序列。

    注意,我们在print语句的结尾使用了一个 逗号 来消除每个print语句自动打印的换行符。

    接下来,我们使用append方法在列表中添加了一个项目,然后我们通过打印列表的内容来检验这个项目是否确实被添加进列表了。打印列表只需简单地把列表传递给print语句,我们可以得到一个整洁的输出。

    再接下来,我们使用列表的sort方法来对列表排序。需要理解的是,这个方法影响列表本身,而不是返回一个修改后的列表——这与字符串工作的方法不同。

    这就是我们所说的列表是 可变的 而字符串是 不可变的 。

    最后,但我们完成了在市场购买一样东西的时候,我们想要把它从列表中删除。我们使用del语句来完成这个工作。这里,我们指出我们想要删除列表中的哪个项目,而del语句为我们从列表中删除它。我们指明我们想要删除列表中的第一个元素,因此我们使用del shoplist[0](记住,Python从0开始计数)。

    展开全文
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼列表的一些特点:列表是最常用的线性数据结构list是一系列元素的有序组合list是可变的列表的操作,增:append、extend、insert删:clear、pop、remove改:reverse、sort...

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    列表的一些特点:

    列表是最常用的线性数据结构

    list是一系列元素的有序组合

    list是可变的

    列表的操作,

    增:append、extend、insert

    删:clear、pop、remove

    改:reverse、sort

    查:count、index

    其他:copy

    >>> [a for a in dir(list) if not a.startswith('__')]

    ['append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']定义与初始化列表

    lst = list() # 使用list函数定义空列表

    lst = [] # 使用中括号定义空列表

    a = [1, 2, 3] # 使用中括号定义带初始值的列表

    lst = list(range(1, 10)) # 使用list函数把可迭代对象转化为列表

    a_ref = aa[2] = 100列表的访问

    可以通过下标访问列表中的元素,下标从0开始。当下标超出范围时,会抛出IndexError异常。下标可以是负数,负数下标从右开始,与正数下标刚好相反。负数下标从-1开始。不管是正数的下标还是负数的下标,只要超出范围,就会抛出异常。

    lst = [1, 2, 3]

    print(lst[0])

    print(lst[2])

    # print(lst[3])列表常用操作

    我们可以通过列表的下标(或索引)找到相应的元素,也可以通过列表元素找到其相应的索引。列表提供了index方法可以实现此需求,接下来我们就看一下如何使用列表的index方法。

    lst = [1, 2, 3, 2, 5]help(lst.index) : Help on built-in function index: : : index(...) method of builtins.list instance : L.index(value, [start, [stop]]) -> integer -- return first index of value. : Raises ValueError if the value is not present. :

    index可以有其他两个参数,start,stop可以为负数,但是总是从左往右查找。

    index方法根据值返回第一个索引。

    a_copy = a[:]

    a.append(300) # 在列表的末尾增加一个元素

    a.insert(1, 50) # 在指定位置增加一个元素,如果索引超出范围,如果是正索 # 引,等效于append,如果索引为负数,等效于insert(0, object)。

    a.pop() # 默认从列表最后移除一个元素,可以指定索引;索引不能超出范围

    a.sort() # 排序方法a.reverse() # 反转方法

    a.remove(value) # 移除列表中第一次出现的value,如果value不存在,则抛出ValueError异常

    del a[1]

    列表的count方法用于返回列表里出现元素的个数,如果没有就返回0。

    lst = [1, 2, 3, 2, 3, 5]

    print(lst.count(2))

    print(lst.count(5))

    # there was no element 0

    print(lst.count(0))

    count方法的原型:

    def count(lst, value): c = 0 for x in lst: if x == value: c += 1 return c

    index和count的时间复杂度是O(n)线性复杂度(效率与数据规模成线性相关)。

    由于列是可变的数据结构,因此可以对列表的元素可以进行修改。修改列表的元素直接使用下标操作取出元素并对其赋值即可。

    lst = [1, 2, 3, 2, 4, 3, 5]

    print(lst[2])

    lst[2] = 5

    print(lst[2])

    # 对超出范围的索引修改元素,会抛出IndexError异常

    # lst[7] = 7

    增加列表元素,使用修改列表元素的方法不能增加列表元素。可以使用append方法来增加列表的元素,

    lst = [1, 3, 5, 7]

    lst.append(9)

    print(lst)

    lst.extend([1, 2, 3])

    print(lst)

    lst.extend(range(3))

    print(lst)

    # remove

    # 根据值来删除

    # 从左到右删除第一次出现的元素

    lst.remove(1)

    print(lst)

    # 删除一个不存在的值时,会抛出ValueError异常

    # lst.remove(10)# pop

    # 默认返回并删除最后一个元素

    lst.pop()

    print(lst)

    # pop可以有参数

    # 返回并删除索引所在位置的元素

    lst.pop(1)

    print(lst)

    # 当pop不存在的索引时,抛出IndexError异常

    # lst.pop(100)

    运行结果为:

    : [1, 3, 5, 7, 9] : [1, 3, 5, 7, 9, 1, 2, 3] : [1, 3, 5, 7, 9, 1, 2, 3, 0, 1, 2] : [3, 5, 7, 9, 1, 2, 3, 0, 1, 2] : [3, 5, 7, 9, 1, 2, 3, 0, 1] : [3, 7, 9, 1, 2, 3, 0, 1]

    append与extend的对比:

    append原地修改列表,返回None

    extend原地修改,返回None

    append操作单个元素

    extend操作可迭代对象

    pop与remove的对比:

    pop是弹出索引对应的值

    remove是删除最左边的第一次出现的值

    pop针对的是索引

    remove针对的是值

    pop不传递index参数时,其时间复杂度为O(1)

    pop传递index参数时,其时间复杂度为O(n)

    insert可以在指定的位置处插入元素。当insert时,索引超出范围时:

    索引是负数,会在第0个元素前插入元素

    索引是正数,会在最后一个元素后插入元素

    lst = [1, 3, 5, 7]

    lst.insert(2, 'm')

    print(lst)

    lst.insert(10, 'e')

    print(lst)

    lst.insert(-10, 'a')

    print(lst)

    运行结果为:

    : [1, 3, 'm', 5, 7]

    : [1, 3, 'm', 5, 7, 'e']

    : ['a', 1, 3, 'm', 5, 7, 'e']

    insert操作的时间复杂度是O(n),append操作的时间复杂度是O(1)。

    列表有copy的方法,

    lst1 = [1, 3, 2, 5, 7]

    lst2 = lst1 # 赋值操作,对可变对象是引用传递,对不可变对象是传值

    print(lst2)

    lst2.remove(2)

    print(lst2)

    print(lst1)

    lst1 = [1, 3, 2, 5, 7]

    lst2 = lst1.copy() # 影子拷贝

    lst2.remove(2)

    print(lst2)

    print(lst1)

    运行结果为:

    : [1, 3, 2, 5, 7]

    : [1, 3, 5, 7]

    : [1, 3, 5, 7]

    : [1, 3, 5, 7]

    : [1, 3, 2, 5, 7]

    赋值操作传递的是引用,也叫浅拷贝。

    copy方法的原型:

    def copy(lst): tmp = [] for i in lst: tmp.append(i) return tmp

    清除列表,

    lst.clear() # 删除所有元素

    求list的长度,

    lst = []

    print(len(lst))

    lst = list(range(4))

    print(len(lst))

    列表反转,

    列表排序,原地修改,返回None。默认是顺序排列,

    lst.sort()

    lst.sort(reverse=True)

    去除列表中重复元素,

    L1 = ['b', 'c', 'd', 'b', 'c', 'a', 'a']

    L2 = []

    [L2.append(i) for i in L1 if not i in L2]

    print(L2)

    : ['b', 'c', 'd', 'a']iter = (x ** 2 for x in range(10) if x % 2 == 0)

    iter

    at 0x1056b42b0>>>>

    for el in iter: print(el)

    0

    4

    16

    36

    64

    ###>>> print [(x, y) for x in (1, 2, 3, 4) for y in (10, 15, 3, 22) if x * y > 25]

    [(2, 15), (2, 22), (3, 10), (3, 15), (3, 22), (4, 10), (4, 15), (4, 22)]

    来看几个跟列表应用的例子,

    # 求素数的列表使用法lst = []for n in range(2, 101): for x in lst: if n % x == 0: break else: lst.append(n) print(n)一个例子

    一个可以输出直方图的例子,代码如下:

    (venv) [lavenliu@VM_171_247_centos mysite]$ cat hist.py

    # 从一个列表中创建一个直方图

    values = [] # 首先创建一个空列表# 我们输入10个整数

    print("Enter 10 integers:")

    for i in range(10): newValue = int(input("Enter integer %d: " % (i+1))) values += [newValue]

    # 创建直方图

    print("\nCreating a histogram from values:")

    print("%s %10s %10s" % ("Element", "Value", "Histogram"))

    for i in range(len(values)): print("%7d %10d %s" % (i, values[i], "*" * values[i]))

    运行结果为:

    (venv) [lavenliu@VM_171_247_centos mysite]$ python hist.py Enter 10 integers:Enter integer 1: 10Enter integer 2: 8Enter integer 3: 23Enter integer 4: 15Enter integer 5: 2Enter integer 6: 5Enter integer 7: 7Enter integer 8: 9Enter integer 9: 6Enter integer 10: 4Creating a histogram from values:Element Value Histogram

    0 10 **********

    1 8 ********

    2 23 ***********************

    3 15 ***************

    4 2 **

    5 5 *****

    6 7 *******

    7 9 *********

    8 6 ******

    9 4 ****

    想知道更多的可以加我群:599411652 或者加我q:2327243380

    展开全文
  • 如果我们认为在接口方面,忽略了实现细节,方块是否矩形的子类型?子类型的定义取决于liskov代换原理。为了成为一个子类型,它必须能够完成超级类型所做的一切。如何定义矩形的接口?zope.interface import ...

    让我们首先考虑正方形和长方形。如果我们认为在接口方面,忽略了实现细节,方块是否是矩形的子类型?

    子类型的定义取决于liskov代换原理。为了成为一个子类型,它必须能够完成超级类型所做的一切。

    如何定义矩形的接口?

    zope.interface import interface

    class irectangleinterface:

    get_length:

    """squares can do that"""

    get_width:

    """squares can do that"""

    set_dimensions length width:

    """uh oh"""

    如果这是定义,则方块不能是矩形的子类型;它们不能响应set_dimensions方法,如果长度和宽度不同。

    另一种方法是选择制作矩形。不变.

    class irectangleinterface:

    get_length:

    """squares can do that"""

    get_width:

    """squares can do that"""

    with_dimensions length width:

    """returns a new rectangle"""

    现在,一个正方形可以是一个矩形。它可以返回一个新的矩形(通常不是正方形)with_dimensions被称为,但它不会停止成为一个正方形。

    这似乎是一个学术问题-直到我们考虑到,从某种意义上说,正方形和长方形是它们两边的容器。在我们理解了这个例子之后,更实际的情况是使用更传统的容器。例如,考虑随机访问数组.

    我们有isquare和irectangle,和isquare是irectangle.

    我们希望在随机访问数组中放置矩形:

    class iarrayofrectanglesinterface:

    get_element i:

    """returns rectangle"""

    set_element i rectangle:

    """'rectangle' can be any irectangle"""

    我们也想把正方形放在一个随机存取数组中:

    class iarrayofsquareinterface:

    get_element i:

    """returns square"""

    set_element i square:

    """'square' can be any isquare"""

    即使isquare是irectangle,任何数组都不能实现这两者。iarrayofsquare和iarrayofrectangle.

    为什么不行?假设bucket实现两者。

    >>> rectangle make_rectangle

    >>> bucket.set_element rectangle # this is allowed by iarrayofrectangle

    >>> thing bucket.get_element # that has to be a square by iarrayofsquare

    >>> assert thing.height thing.width

    traceback most recent call last:

    file "" line module

    assertionerror

    两者都不能实现,这意味着两者都不是另一种类型的子类型,尽管isquare是irectangle。问题是set_element方法:如果我们有一个只读数组,iarrayofsquare的子类型iarrayofrectangle.

    可变性,都是可变的。irectangle接口和可变iarrayof接口使得对类型和子类型的思考变得更加困难-而放弃的能力意味着我们期望类型之间的直观关系实际上仍然有效。

    突变也可以非局部效果。当两个地方之间的共享对象被一个突变时,就会发生这种情况。典型的例子是一个线程与另一个线程交互一个共享对象,但是即使在一个单线程程序中,在相距很远的地方之间共享也很容易。考虑到在python中,大多数对象都可以从许多地方访问:作为一个模块全局,或者在堆栈跟踪中,或者作为一个类属性。

    如果我们不能限制共享,我们可能会考虑限制可变。

    下面是一个不可变的矩形,它利用autos库:

    attr.frozen

    class rectangeobject:

    length attr.

    width attr.

    classmethod

    with_dimensionscls length width:

    return clslength width

    这里是一个正方形:

    attr.frozen

    class squareobject:

    side attr.

    classmethod

    with_dimensionscls length width:

    return rectanglelength width

    使用frozen参数,我们可以很容易地创建一个不可变的类。所有艰苦的写作工作__setitem__正确的做法是别人做的,对我们来说是完全看不见的。

    修改对象仍然是容易的,改变它们几乎是不可能的

    too_long rectangle

    reasonable attr.evolvetoo_long length

    可靠的包装允许我们有不可变的容器

    # vector of integers

    a = pyrsistent.v(1, 2, 3)

    # not a vector of integers

    b = a.set(1, "hello")

    当b不是整数的向量,任何东西都不会停止。a从成为一个。

    万一a一百万个元素长了吗?是b要复制999 999份吗?pyrsistent附带“大o”性能保证:所有操作都采用o(log n)时间到了。它还附带了一个可选的c扩展,以提高性能超越大o。

    为了修改嵌套对象,它附带了“转换器”的概念:

    blog pyrsistent.

    title"my blog"

    linkspyrsistent."github" "twitter"

    postspyrsistent.

    pyrsistent.title"no updates"

    content"i'm busy"

    pyrsistent.title"still no updates"

    content"still busy"

    new_blog blog.transform"posts" "content"

    "pretty busy"

    new_blog将成为不可变的等价物。

    'links': 'github' 'twitter'

    'posts': 'content': "i'm busy"

    'title': 'no updates'

    'content': 'pretty busy'

    'title': 'still no updates'

    'title': 'my blog'

    但blog还是一样的。这意味着任何引用旧对象的人都没有受到影响:转换只有本土化效果。

    当分享猖獗时,这是有用的。例如,考虑默认参数:

    silly_suma b extrav :

    extra extra.extenda b

    return extra

    在这篇文章中,我们了解了为什么不变性对于思考我们的代码是有用的,以及如何在没有昂贵的性能代价的情况下实现它。

    总结

    以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对萬仟网的支持。如果你想了解更多相关内容请查看下面相关链接

    如您对本文有疑问或者有任何想说的,请点击进行留言回复,万千网友为您解惑!

    展开全文
  • 一、分类数值int float complex bool序列对象字符串 str列表 list元组 tuple键值对集合 set字典 dict二、数值型数值型int flaot complex bool 都class,即数字都对象实例int: python3 的int就是长整型,且没有...

    一、分类

    数值int float complex bool

    序列对象字符串 str

    列表 list

    元组 tuple

    键值对集合 set

    字典 dict

    二、数值型

    数值型int flaot complex bool 都是class,即数字都是对象实例

    int: python3 的int就是长整型,且没有大小限制,受限于存储区的大小

    float:由整数部分和小数部分组成。支持十进制和科学记数法表示。只有双精度型

    complex:由实数和虚部组成,实数和虚部都是浮点数,3+2.4J

    bool:int的子类,仅有两个实例True和False,即1和0,可以和整数直接运算

    类型转换int(x)返回一个整型

    float(x)返回一个浮点数

    complex(x)返回一个复数

    bool(x)返回一个布尔值

    数字的处理函数

    round()——四舍六入五去偶

    math 模块、floor()地板——向下取整、ceil()天花板——向上取整

    int()——取整数部分、//——整除且向下取整

    举例

    min()——最小值

    max()——最大值

    pow(x,y)——x**y

    math.sqrt()——算数平方根

    进制函数,返回值是字符串bin()

    oct()

    hex()

    math.pi——π

    math.e——自然常数

    三、数据类型判断

    type(obj)——返回类型,而不是字符串

    isinstance(obj,class or tuple)

    举例

    四、列表list

    一个队列,一个排列整齐的队伍

    列表内的个体称作元素,由若干元素组成列表

    元素可以是任意对象(数字,字符串,对象,列表等)

    列表内的元素是有顺序的,可以使用索引

    线性的数据结构

    列表是可变的

    列表list 定义初始化

    list()——创建一个新的空列表

    list()——用一个可迭代对象创建新的列表

    列表不能一开始就定义大小

    举例:

    列表索引访问

    索引:也叫下标

    正索引:从左至右,从0开始,为列表中的每一个元素编号

    负所引:从右至左,从-1开始

    索引不可以越界,即index<=len(list)-1,否则会引发IndexError

    索引访问:list[index], index为索引,使用中括号访问

    列表查询

    index(vlaue,[start,[stop]])通过值value,从指定区间查找列表内的元素是否匹配

    匹配第一个值就立即返回索引

    匹配不到就立即抛出异常ValueError

    count(value)返回列表中匹配value的次数

    时间复杂度index和count都是O(n)

    随着列表的规模增大,效率下降

    len()返回列表长度,即列表元素个数

    列表元素修改

    索引访问修改list[index] = value

    索引不可以越界

    列表增加、插入元素

    append(obj)列表尾部追加元素,返回None

    返回None就意味着没有新的列表产生,就地修改

    时间复杂度O(1)

    insert(index,obj)在指定位置index插入元素object

    返回None就意味着没有新的列表产生就地修改

    时间复杂度,O(n)

    索引可以越界超越上界,头部追加

    超越下界,尾部追加

    extend(iteratable)将可迭代对象的元素追加进来,返回None

    就地修改

    +链接操作,将两个列表连接起来

    产生新的列表,原列表不变

    本质上调用的是__add__()方法

    *重复操作,将本列表元素重复n次,返回新的列表

    列表删除元素

    remove(value)从左至右查找第一个匹配value的值,移出该元素,返回None

    就地修改

    pop(index)不指定索引,就从列表尾部弹出一个元素

    指定索引,就从索引处弹出一个元素,索引越界抛出IndexError异常

    clear()清除列表所有元素,剩下空列表

    列表其他操作

    reverse()将列表元素翻转,返回None

    就地修改

    sort(key=None,reverse=False)对列表元素进行排序,就地修改,默认升序

    key一个函数,指定key如何排序lst.sort(key=fun)

    in[3,4] in [1,2,[3,4]]

    for x in [1,2,3,4]

    列表复制

    我们先来看一段代码:

    上述代码解析:

    第一行lst0 = [0,1,2,3];

    第二行lst2 = [0,1,2,3];

    第三行判断两个列表是否相等,由于两个列表中的元素对应相等,所以结果为True

    第四行将lst0赋值给了 lst1;

    第五行对lst1的第三个元素进行了修改,修改为10,此时lst1 = [0,1,10,3,];

    由于第四行的赋值实际上是将lst0的引用(也就是内存中的地址)复制给了lst1所以此时lst0和lst1实际上为真正的相等,元素相等,内存地址相等;而lst0和lst2两个列表虽然元素相等,但是仅为表面上的相等,内存地址不想等,为两个不相同变量;

    综上所述:在Python中的"=="是一种表面上的判断相等,而"="在赋值的过程中是一种复杂类型的引用复制,复制了原变量的内存地址,通俗理解从根上给挖了过去。所以第三问的答案:没有元素的复制过程,只有地址的复制过程。

    赋值、浅拷贝、深拷贝

    赋值:b=a默认浅拷贝,只是复杂类型引用的复制传递,原始类型改变,被赋值变量也会改变。

    fdbfb986cfc5ddb89ae21b6e133d4203.pnga,b都指向同一父对象,而父对象存放的是子对象的引用

    浅拷贝:b = a.copy() 拷贝与被拷贝者,都是独立对象,但子对象还是指向同一对象(同一子对象内存 地址)

    bec2d5b3c471571c3e0da03ff4539d88.png

    深拷贝:c = copy.deepcopy(a) c和a为完全独立的两个对象,且c内部的子对象也是独立的。

    3693be00e0995ef41abfc013e391e7d0.png

    列表解析List Comprehension

    例子:现在生成一个列表,元素0-9,对每一个元素自增1后求平方返回新列表

    你可能会这样写:

    这样写起来还是不够优雅,不够简洁!现在就需要我们的列表解析式上线了:

    是不是顿时觉得 眼前一亮呢!

    语法[返回值 for 元素 in 可迭代对象 if 条件]

    使用[],内部是for 循环,if条件可选

    返回一个新的列表列表解析式是一种语法糖编译器会优化,不会因为简写而影响效率,反而因为优化提高了效率

    减少了程序的书写量,减少出错

    简化了代码,可读性增强

    列表解析进阶

    [expr for item in iterable if cond1 if cond2]

    等价于:

    ret = []

    for item in iterable:

    if cond1:

    if cond2:

    ret.append(expr)求20以内,既能被2整除又能被3整除的数[i for i in range(20) if i%2 == 0 and i%3 == 0]

    [i for i in range(20) if i%2 == 0 if i%3 == 0]

    [expr for i in iterable1 for j in iterable2]

    等价于ret = []for i initerable1:

    for j in iterable2:

    ret.append(expr)

    举例

    [(x, y) for x in 'abcde' for y in range(3)]

    [[x, y] for x in 'abcde' for y in range(3)]

    [{x: y} for x in 'abcde' for y in range(3)]

    生成器表达式Generator expression

    语法(返回值 for 元素 in 可迭代对象 if 条件)

    列表解析式的中括号换成小括号就行了

    返回一个生成器

    和列表解析式的区别生成器表达式是按需计算(或惰性求值、延迟计算),需要的时候才计算值

    列表解析式是立即返回值

    生成器可迭代对象

    迭代器

    总结:

    延迟计算

    返回迭代器,可以迭代

    从前到最后走完一遍后,不能回头

    生成器表达式和列表解析式对比

    计算方式生成表达式延迟计算,列表解析式立即计算

    内存占用单从返回值本身来说,生成器表达式省内存,列表解析式返回新的列表

    生成器没有数据,内存占用极少,但是使用的时候,虽然一个个返回数据,但合起来占用的数据和列表解析式差不多

    列表解析式构造新的列表需要占用内存

    计算速度单看计算时间,生成器表达式耗时非常短,列表解析式耗时长

    但是生成器本身并没有返回值,只返回了一个生成器对象

    列表解析式构造并返回了一个新的列表

    展开全文
  • 简要的说可哈希的数据类型,即不可变的数据结构(字符串str、元组tuple、对象集objects);...首先列表与集合都是不可变的。 其次元祖是可变的,集合是不可变的。 字典和集合都是不可变的。 不可变可以作为可变的集
  • 11.1.2.2 使用不可变数据结构   为了演示了以不可变风格,写相同的代码,但不一定必须使用函数式列表;即使使用标准的 List 类型,我们一样能够避免修改集合。然而,不幸的,要确保不意外修改列表,可能很难。 ...
  • Scala入门_不可变列表与可变列表

    千次阅读 2020-02-08 14:19:02
    列表是scala中最重要的、也是最常用的数据结构。List具备以下性质: 可以保存重复的值 有先后顺序 在scala中,也有两种列表,一种是不可变列表、另一种是可变列表 定义 不可变列表就是列表的元素、长度都是不...
  • 【分录题】12日, 甲公司从银行提取现金1 000元;【判断题】55.无序列表的各个列表项之间,虽然没有顺序级别之分,但是存在主从关系。...在HTML中常用的列表有三种,其中有序列表是指有排列顺序的列表,其...
  • 一、range() 函数返回的一个迭代对象(类型对象),而不是列表类型, 所以打印的时候不会打 印列表。 print(range(10)) 输出结果: range(0, 10) 如果想把range对象变成列表,可以使用list()函数对range...
  • scala的不可变列表

    千次阅读 2020-02-09 19:26:06
    列表是scala中最重要的、也是最常用的数据结构。List具备以下性质: 可以保存重复的值 有先后顺序 在scala中,也有两种列表,一种是不可变列表、另一种是可变列表 定义 不可变列表就是列表的元素、长度都是不可变的...
  • Python的列表是:任意对象的有序集合通过偏移读取可变长度、异构以及任意嵌套属于可变序列的分类对象引用数组(列表中的存储的是对象的引用,而不是对象的拷贝)实际应用中的列表>>基本列表操作由于列表是序列,...
  • 摘要:当我们考虑到数据太大而能装入主存,就要考虑磁盘的读取次数了。如果使用开放地址探测法或者分离链表探测,最主要的问题在一次Find操作期间。冲突可能引起多块磁盘区域被考察。而且当磁盘的过满时,它...
  • 在Python中有三种内建的数据结构——列表list、元组tuple和字典dict列表中的项目包括在方括号中,项目之间用逗号分割元组和列表十分类似,只不过元组和字符串一样是不可变的 即你不能修改元组。元组通过圆括号中用...
  • Python的列表是:任意对象的有序集合通过偏移读取可变长度、异构以及任意嵌套属于可变序列的分类对象引用数组(列表中的存储的是对象的引用,而不是对象的拷贝)实际应用中的列表>>基本列表操作由于列表是序列,...
  • python数据结构列表

    2020-11-09 19:01:25
    本文的文字及图片来源于网络,仅供学习、交流...Python中列表是可变的,这是它区别于字符串和元组的最重要的特点,一句话概括即:列表可以修改,而字符串和元组能。 以下是 Python 中列表 >>> a = [66.25,
  • Python中列表是可变的,这是它区别于字符串和元组的最重要的特点,一句话概括即:列表可以修改,而字符串和元组能 将列表当做堆栈使用 列表方法使得列表可以很方便的作为一个堆栈来使用,堆栈作为特定的数据结构,...
  • 其中,列表是可变的(可以进行修改),而元组和字符串是不可变的(一旦创建了就是固定的)。序列中包含6种内建的序列,包括列表、元组、字符串、Unicode字符串、buffer对象、xrange对象。列表的声明:mylist = []2.列表...
  • 六、数据结构列表

    2019-10-13 14:12:44
    本文有很多函数调用案例,大部分只有代码,没有输出结果,请自行复制...3)分类:可变序列和不可变序列。 4)列表属于可变序列。 <2.列表的创建 方法一: lis=['a','b','c','d','e'] 方法二: lis=list(...
  • 相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的 列表有序可变 字典无序不可变(key也不可变) 元组有序不可变 集合无序不可变 数字不可变 字符串不可变 列表list 列表是具【有顺序...
  • 上一节课为大家讲解了Python中的列表,它是一种容器型数据类型,我们可以通过定义列表类型的变量来保存和操作多个元素。...元组和列表的不同之处在于,元组是不可变类型,这就意味着元组类型的变量一旦定义...
  • 本节内容:列表元组字符串集合字典本节先介绍列表。...列表是可变对象,支持在原处修改。列表的可变变现在其内部的每一个元素存储在列表中不是对象本身,而是对象的引用。因此其修改的是对象的引用。he...
  • 列表是可变对象,它支持原地修改的操作。 Python的列表是: 任意对象的有序集合 通过偏移读取 可变长度、异构以及任意嵌套 属于可变序列的分类 对象引用数组(列表中的存储的是对象的引用,而不是对象的拷贝) ...
  • 其中,列表是可变的(可以进行修改),而元组和字符串是不可变的(一旦创建了就是固定的)。序列中包含6种内建的序列,包括列表、元组、字符串、Unicode字符串、buffer对象、xrange对象。 列表的声明: mylist = ...
  • 1.序列 1.1 序列 基本概念:序列python中最常见的基本数据类型。序列就是有序存放的一组数据,这些数据有一个个独立的元素组成。每一个元素被分配一个需要元素的位置—,亦称“ 索引 ”,首个索引...不可变序列...
  • 列表是可变的,而元组是不可变的,这标志着两者之间的关键差异。 我们可以修改列表的值,但是不修改元组的值。 列表 向列表添加元素的3种方法: append() 这种方法是将元素添加在列表的尾部。 extend() extend的...
  • 与元组不同,列表的长度是可变的,它所包含的内容可以修改的,用中括号[] 将值包起来。、 1.创建 (1) 用中括号[] 来定义列表: In [1]: list = [1,2,3,None] list Out [1]: [1, 2, 3, None] (2) 用list()...
  • 函数式数据结构-列表

    2021-01-12 08:38:46
    在开始之前我们先了解几个名词: 1、什么函数式编程:函数式编程属于"结构化编程"的一种,主要思想把运算过程尽量写成一系列嵌套的函数调用,可以说是面向过程的程序设计。...函数式数据结构被定义为不可变的。
  • 列表是可变的 列表在内存中要求连续,适合增删,检索元素方便 链表数据不一定连续,适合频繁数据增删,寻找数据麻烦 队列允许中间操作,先进先出后进后出,能在内部进行操作只能 栈 后进先出 允许中间操...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,776
精华内容 710
关键字:

列表是不可变数据结构

数据结构 订阅