精华内容
下载资源
问答
  • Python中元组不可变的答:√从年龄看,儿童是( )的主要消费者。答:玩具暗くなりました。だからもうどこ()行きません答:へも下列属于对称加密算法的是答:RSA我国法规要求一些可能对人体有副作用的原料、容易...

    Python中的元组是不可变的

    答:√

    从年龄看,儿童是( )的主要消费者。

    答:玩具

    暗くなりました。だからもうどこ()行きません

    答:へも

    下列不属于对称加密算法的是

    答:RSA

    我国法规要求一些可能对人体有副作用的原料、容易引起过敏的物质需要在包装或说明书上标识出来

    答:√

    奇闻异事是无法用来做决策的,说法是否可信取决于是否有(??)支持\n\n\nA.专家\n\n\nB.计算机\n\n\nC.数据\n\n\nD.图表

    答:数据

    希腊神话中的美惠三女神,包括()

    答:光辉女神、激励女神、欢乐女神

    热处理根据目的和要求不同可分为普通热处理和()两大类

    答:表面热处理

    中国人民银行是由( )三家根据地银行合并而成的。

    答:北海银行 西北农民银行 华北银行 中国农民银行

    请示报告是一种文种。()

    答:×

    陕西历史博物馆是中国保存壁画技术最好的博物馆。()

    答:√

    中国大学MOOC: 学习应该是一个从放到扶的过程。

    答:错

    能与IL-2竞争结合IL-2Rγ链的CK是

    答:IL-4

    属于成人必需氨基酸的有( )种。

    答:8

    印欧语字形是流线型的。

    答:是

    假设某经济社会的消费函数C=100+0.8Y,投资50(单位:10亿美元)。\n(1)求均衡收入,消费和储蓄。若投资增加至100,求增加的收入。\n(2)若消费函数变为C=100+0.9Y,投资仍为50,收入和储蓄各为多少?投资增至100时收入增加多少?\n(3)消费函数变动后,乘数有何变化?

    答:(1)Y=750\nC=700\nS=50\nY变动值=250\n(2)Y=1500\nC=1450\nS=50\nY变动值=500\n(3)投资乘数1=5,投资乘数2=10.

    ()对非法取证进行法律监督

    答:检察机关

    清代朝廷家法是不允许母后涉政的。()

    答:√

    中国大学MOOC: 赫尔巴特将教育学分为管理、教学和训育,其中管理是教育和教学的必要条件。

    答:对

    根据公安部《机关、团体、企业、事业单位消防安全管理规定》,单位的消防安全负责人应当履行( )的消防安全职责。

    答:确定逐级消防安全责任,批准实施消防安全制度和保障消防安全的操作规程 组织防火检查,督促落实火灾隐患整改,及时处理涉及消防安全的重大问题 贯彻执行消防法规,保障单位消防安全符合规定,掌握本单位的消防安全情况 组织制定符合本单位实际的灭火和应急散预案,并实施演练

    藏经洞发现的绢画中,没有水墨山水画。

    答:错

    展开全文
  • index = lst.index(oldval) lst[index]=newval return tuple(lst) print modTupByIndex((1, 1, 3), 1, "a") 它会更改所有旧的发生 正如Hunter McMillen评论所写的那样,元组不可变的,所以你需要创build一...

    首先你需要问,你为什么要这么做?

    但是可以通过:

    t = ('275', '54000', '0.0', '5000.0', '0.0') lst = list(t) lst[0] = '300' t = tuple(lst)

    但是如果你需要改变一些东西的话,那么最好把它保存为一个list

    根据你的问题切片可以是一个非常整洁的解决scheme:

    >>> b = (1, 2, 3, 4, 5) >>> b[:2] + (8,9) + b[3:] (1, 2, 8, 9, 4, 5) >>> b[:2] + (8,) + b[3:] (1, 2, 8, 4, 5)

    这允许你添加多个元素或者replace一些元素(特别是如果它们是“邻居”的话)。在上面的例子中,转换为列表可能更合适,更易读(即使切片符号更短)。

    那么,正如Trufa已经表明的那样,基本上有两种方法来replace给定索引处的元组元素。 将元组转换为列表,replace元素并转换回来,或者通过串联构造一个新的元组。

    In [1]: def replace_at_index1(tup, ix, val): ...: lst = list(tup) ...: lst[ix] = val ...: return tuple(lst) ...: In [2]: def replace_at_index2(tup, ix, val): ...: return tup[:ix] + (val,) + tup[ix+1:] ...:

    那么,哪个方法更好,那就更快了?

    事实certificate,对于短元组(在Python 3.3中),连接实际上更快!

    In [3]: d = tuple(range(10)) In [4]: %timeit replace_at_index1(d, 5, 99) 1000000 loops, best of 3: 872 ns per loop In [5]: %timeit replace_at_index2(d, 5, 99) 1000000 loops, best of 3: 642 ns per loop

    然而,如果我们查看更长的元组,列表转换就是要走的路:

    In [6]: k = tuple(range(1000)) In [7]: %timeit replace_at_index1(k, 500, 99) 100000 loops, best of 3: 9.08 µs per loop In [8]: %timeit replace_at_index2(k, 500, 99) 100000 loops, best of 3: 10.1 µs per loop

    对于很长的元组,列表转换实际上更好!

    In [9]: m = tuple(range(1000000)) In [10]: %timeit replace_at_index1(m, 500000, 99) 10 loops, best of 3: 26.6 ms per loop In [11]: %timeit replace_at_index2(m, 500000, 99) 10 loops, best of 3: 35.9 ms per loop

    而且,连接方法的性能取决于我们replace元素的索引。 对于列表方法,索引是不相关的。

    In [12]: %timeit replace_at_index1(m, 900000, 99) 10 loops, best of 3: 26.6 ms per loop In [13]: %timeit replace_at_index2(m, 900000, 99) 10 loops, best of 3: 49.2 ms per loop

    所以:如果你的元组很短,分片和连接。 如果它很长,做清单转换!

    不是说这是优越的,但如果有人好奇,可以在一行上完成:

    tuple = tuple([200 if i == 0 else _ for i, _ in enumerate(tuple)])

    编辑:这不适用于重复条目的元组呢!

    基于Pooya的想法 :

    如果你打算经常这样做(你不应该这样做,因为元组因为某种原因不能修改),你应该这样做:

    def modTupByIndex(tup, index, ins): return tuple(tup[0:index]) + (ins,) + tuple(tup[index+1:]) print modTupByIndex((1,2,3),2,"a")

    或者基于Jon的想法 :

    def modTupByIndex(tup, index, ins): lst = list(tup) lst[index] = ins return tuple(lst) print modTupByIndex((1,2,3),1,"a")

    基于Jon的想法和亲爱的Trufa

    def modifyTuple(tup, oldval, newval): lst=list(tup) for i in range(tup.count(oldval)): index = lst.index(oldval) lst[index]=newval return tuple(lst) print modTupByIndex((1, 1, 3), 1, "a")

    它会更改所有旧值的发生

    正如Hunter McMillen在评论中所写的那样,元组是不可变的,所以你需要创build一个新的元组来实现这个function。 例如:

    >>> tpl = ('275', '54000', '0.0', '5000.0', '0.0') >>> change_value = 200 >>> tpl = (change_value,) + tpl[1:] >>> tpl (200, '54000', '0.0', '5000.0', '0.0')

    你不能。 如果你想改变它,你需要使用一个列表,而不是一个元组。

    请注意,您可以改为创build一个具有新值的新元组作为其第一个元素。

    我发现编辑元组的最好方法是使用以前的版本作为基础重新创build元组。

    下面是一个例子,我用它来制作一个颜色较浅的版本(当时我已经打开了):

    colour = tuple([c+50 for c in colour])

    它是做什么的,它是通过元组“颜色”读取每个项目,做一些事情,最后把它添加到新的元组中。

    所以你想要的会是这样的:

    values = ('275', '54000', '0.0', '5000.0', '0.0') values = (tuple(for i in values: if i = 0: i = 200 else i = values[i])

    那个具体的一个不起作用,但是这个概念就是你所需要的。

    tuple = (0, 1, 2)

    元组=遍历元组,根据需要更改每个项目

    这是概念。

    首先,问问你自己为什么要改变你的tuple 。 有一个原因,为什么string和元组在Ptyhon中是不可变的 ,如果你想改变你的tuple那么它应该可能是一个list 。

    其次,如果你仍然想改变你的元组,那么你可以将你的tuple转换成一个list然后将其转换回来,并将新元组重新分配给相同的variables。 如果你只是要改变你的元组一次,这是很好的。 否则,我个人认为这是违反直觉的。 因为它基本上是创build一个新的元组,每次如果你想改变元组,你将不得不执行转换。 另外,如果你阅读代码,那么为什么不创build一个list呢? 但这很好,因为它不需要任何库。

    我build议使用mutabletuple(typename, field_names, default=MtNoDefault) 。 我个人认为这种方式更直观 可读。 个人阅读代码会知道作家打算在未来变异这个元组。 与上面的list转换方法相比,缺点是这需要你导入额外的py文件。

    from mutabletuple import mutabletuple myTuple = mutabletuple('myTuple', 'vwxy z') p = myTuple('275', '54000', '0.0', '5000.0', '0.0') print(pv) #print 275 pv = '200' #mutate myTuple print(pv) #print 200

    TL; DR :不要试图改变tuple 。 如果你这样做,它是一次性操作将tuple转换为列表,将它改变,将list变成一个新的tuple ,并重新分配回旧的tuplevariables。 如果愿望tuple并以某种方式想要避免list并想多次mutate,然后创buildmutabletuple 。

    我相信这在技术上回答了这个问题,但是不要在家里这样做。 目前,所有的答案都涉及到创build一个新的元组,但是你可以使用ctypes来修改内存中的元组。 依靠64位系统上CPython的各种实现细节,一种方法如下:

    def modify_tuple(t, idx, new_value): # `id` happens to give the memory address in CPython; you may # want to use `ctypes.addressof` instead. element_ptr = (ctypes.c_longlong).from_address(id(t) + (3 + idx)*8) element_ptr.value = id(new_value) # Manually increment the reference count to `new_value` to pretend that # this is not a terrible idea. ref_count = (ctypes.c_longlong).from_address(id(new_value)) ref_count.value += 1 t = (10, 20, 30) modify_tuple(t, 1, 50) # t is now (10, 50, 30) modify_tuple(t, -1, 50) # Will probably your crash Python runtime

    我做到了这一点:

    list = [1,2,3,4,5] tuple = (list)

    并改变,只是做

    list[0]=6

    你可以改变一个元组:D

    这是从IDLE完全复制

    >>> list=[1,2,3,4,5,6,7,8,9] >>> tuple=(list) >>> print(tuple) [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> list[0]=6 >>> print(tuple) [6, 2, 3, 4, 5, 6, 7, 8, 9]

    展开全文
  • 知道为什么字符串和元组不可变的;使它们不可变的优点和缺点是什么?除了Python解释器的内部实现,这种设计编写程序上是否有很好的意义?(例如,如果元组和字符串是可变的,会更容易吗?)如果是这样,那么...

    我不知道为什么字符串和元组是不可变的;使它们不可变的优点和缺点是什么?

    除了Python解释器的内部实现,这种设计在编写程序上是否有很好的意义?(例如,如果元组和字符串是可变的,会更容易吗?)如果是这样,那么选择不可变元组和列表的例子是什么?(或pherhaps、可变字符串与python字符串)

    有一种称为函数式编程的完整编程风格,其中所有东西都是不可变的。en.wikipedia.org/wiki/functional_编程

    python确实有可变的字符串和元组;它们分别拼写为bytearray和list。

    所谓的fakemutablepython Imagine a语言,你可以在搜索字符串的赋值和年龄使用列表(如mystr[0] = 'a')

    a ="abc"

    这是创建在内存中存储的地址进入0x1,含"ABC",和标识符a指向它。

    现在,说你做的。

    b = a

    本b点创建的标识符和它同一个内存地址0x1

    现在,如果你的字符串是mutable,b变更:

    b[0] = 'z'

    这个年龄的第一个字节的字符串存储在一个z0x1。标识符是从一个a来指向字符串,因此这会改变的,所以……

    print a

    print b

    两个输出..would zbc

    这可以让一些真正奇怪,意想不到的行为。字典的键是一个很好的例子是这样:

    mykey = 'abc'

    mydict = {

    mykey: 123,

    'zbc': 321

    }

    anotherstring = mykey

    anotherstring[0] = 'z'

    现在事情变得fakemutablepython奇,而你的词典中有两个键,"ABC"和"ZBC"。然后你的年龄"abc"字符串(通过"标识符"anotherstringZBC)",因此"双键的安切洛蒂,ZBC"和"ZBC"……

    一个可能的解决方案在本weirdness,每当你分配一个标识符的字符串(或使用它作为一个关键的副本),它是在具备0x1字符串。

    这可防止上面的,但如果你有一个字符串,需要200内存?

    a ="really, really long string [...]"

    b = a

    突然,你的脚本需要启动400MB的记忆?这不是很好。

    我们点什么,如果它同一个内存地址,直到我们修改它?copy on write。这个问题是相当复杂的,可以做的。

    这是immutability是在哪里。而不是要求的.replace()同体复制到一个新的字符串从内存地址,然后修改它的回报。我们只是让所有的不可变的字符串和函数,因此必须创建一个新字符串返回。这解释了以下的代码:

    a ="abc"

    b = a.replace("a","z")

    证明和是由:

    >>> a = 'abc'

    >>> b = a

    >>> id(a) == id(b)

    True

    >>> b = b.replace("a","z")

    >>> id(a) == id(b)

    False

    (id()函数返回的对象的内存地址)

    +1最佳答案。真的?

    我听过最好的解释!

    那么,如果我说a="abc",b="abcd"它会共享abc吗?就像b[:4]是a?

    @Dineshkumar不,我很确定"abc"和"abcd"是不同的,完全无关的,对象-stackoverflow.com/questions/5722006/…

    One is performance: knowing that a

    string is immutable makes it easy to

    lay it out at construction time —

    fixed and unchanging storage

    requirements. This is also one of the

    reasons for the distinction between

    tuples and lists. This also allows the

    implementation to safely reuse string

    objects. For example, the CPython

    implemenation uses pre-allocated

    objects for single-character strings,

    and usually returns the original

    string for string operations that

    doesn’t change the content.

    The other is that strings in Python

    are considered as"elemental" as

    numbers. No amount of activity will

    change the value 8 to anything else,

    and in Python, no amount of activity

    will change the string"eight" to

    anything else.

    effbot.org http:/ / / / why-are-python-strings-immutable.htm pyfaq

    一大优势是,他们制作的不可变的,他们可以被用来作为在一个字典的键。我可以使用内部数据结构词典是由他们的时间点,如果把钥匙是没有改变。

    您可以通过任何用户创建的对象实例(显然是可变的)进行键控。然后"key"可能只是内存地址,如果字符串是可变的,您仍然可以通过它们的唯一内存地址来设置key。

    @triptych不是你想要的字符串——你希望它们按值键,否则字典就没什么用处了……

    @Hejazzman这不是python指令的工作方式。文字字符串值不用作dict键,而是采用字符串的哈希值。用'abc'.__hash__()向自己证明这一点。

    @你说的每一句话都是错的。首先,可以有两个地址不同的相等字符串,因此使用该地址不起作用。第二,当dict使用字符串的散列时,关键是字符串本身——通过显示d.keys()来证明它。您可以很容易地拥有两个具有相同哈希值的字符串,而dict会将它们分开。

    @标记勒索而不是地址,哈希。根据定义,不能有两个具有相同哈希值但具有不同哈希值的字符串进行比较。

    @你八年前的第一次评论是关于记忆地址的,但我当时没有回复。正确的做法是,不能使用相同的字符串和不同的哈希值,但可以使用相同的哈希值使用不同的字符串!散列本身不足以作为密钥,它只是机制的一部分。

    @triptych我知道python dicts是如何工作的(或者任何语言的hashmaps)。这不是我的观点。我的观点是,相同的字符串应该能够指向相同的条目,对于可变的字符串(以及它们作为hashmap中的键的"唯一内存地址")则不是这样。然后需要有完全相同的字符串指针,而不仅仅是相同的字符串内容,才能从字典中获取条目。

    不可变的类型是conceptually多mutable比简单酮。例如,你不constructors测量与复制或const的正确性在C + +类。越是不可变类型,语言变得更容易。因此,在最简单的语言是纯粹的功能状态(因为没有任何一个lambda演算的全球多更容易比图灵机,和同样强大的),虽然很多人不欣赏的人。

    Perl的字符串函数和mutable安切洛蒂似乎只是罚款。上面的手似乎很多rationalization挥手和一个任意的设计决策。

    我的答案的问题,为什么Python Python字符串不可变的安切洛蒂,Guido van Rossum通缉的创造者,因为它现在已经这样,他都是个特殊的legions任意决策和呼吸死亡。

    你可以有类似的姿势的问题为什么Perl没有不可变的字符串和一个完整的人会写在passel知识观的字符串是不可变的,以及为什么它是非常bestest IDEA"(TM)是Perl没有他们。

    Perl实际上没有字符串:它有scalar,可以作为字符串或数字(后者有多种类型)。如果scalar是不可变的,它将成为纯粹的函数Perl,世界各地的Perl开发人员将通过为自己分配UNdef来自杀。

    优点:性能

    缺点:你不能改变mutables。

    专家:你不能改变它们

    展开全文
  • 封面.jpgIntro很多 Python 入门资料会将元组 (tuple) 介绍为 "不可变列表", 因其具备可迭代和可切片的能力, 同时无法修改元组中而得名. 然而这只是元组的其中一个特性而已.元组的本质元组是对数据的一个记录, 每...

    封面.jpg

    Intro

    很多 Python 入门资料会将元组 (tuple) 介绍为 "不可变列表", 因其具备可迭代和可切片的能力, 同时无法修改元组中的值而得名. 然而这只是元组的其中一个特性而已.

    元组的本质

    元组是对数据的一个记录, 每个位置记录了某个字段的值, 位置和字段信息赋予了这组数据的意义. 听起来很像数据库中的某条数据记录, 假如数据的元素不保持某个固定的位置, 你还认为这个数据是可用的吗?

    具名元组 —— 元组特性的最有力体现

    具名元组来自 Python 内置库 collections.nametupled 中, 可以用来构建带字段名的元组和一个相应的类

    使用 nametupled 构建的类的实例所消耗的内存与元组是一致的, 因为字段名都被保存在对应的类里面.

    —— 译自 Fluent Python

    声明方式一

    nametuple 构造函数的首个参数为类名, 第二个参数为字段名信息, 可以是以空格隔开的字符串, 也可以是字符串数组.

    In [14]: from collections import namedtuple

    In [15]: UserInfo = namedtuple('UserInfo', 'username passwor

    ...: d block vip')

    In [16]: coding = UserInfo('coding', 'ShowMeTheCode', '0', '

    ...: 1')

    In [17]: coding.password

    Out[17]: 'ShowMeTheCode'

    In [18]: coding[1]

    Out[18]: 'ShowMeTheCode'

    声明方式二

    这种方式利用了很 Pythonic 的解包方式进行声明

    In [19]: columns = ['name', 'city', 'email']

    In [20]: Contact = namedtuple('Contact', columns)

    In [21]: contact = ['coding', 'Dongguan', 'fesonx@foxmail.co

    ...: m']

    In [22]: coding_contact = Contact(*contact)

    In [23]: coding_contact.city

    Out[23]: 'Dongguan'

    可以用元组进行解包声明, 这里就充分利用了元组的位置信息:

    In [40]: contact_desciption = ('Contact', ['name', 'city', 'email', 'phone'])

    In [41]: Contact = namedtuple(*contact_desciption)

    用途

    面向对象

    在日常开发中, 往往离不开关系型数据库对象和缓存, 以往使用 ORM 框架时, 受益于 ORM 面向对象的思想, 可以很方便的用 instance.field 方式访问对象属性, 但是转化到缓存时, 特别是类似 Redis 这类只保存字节的缓存, 就失去了对象这一概念.

    以往我们常常使用字典来"挽回"一点面向对象的思想, 但是如前文引用所示, 不保存字段名的具名元组实例要比字典占用的内存小, 并且在获取对象属性时要比字典方便多了, 面向对象的思想得到体现.

    In [35]: coding_dict = {"name": "coding", "city": "Dongguan", "email": "fesonx@fox

    ...: mail.com"}

    In [36]: coding_dict.get('name') # 字典

    Out[36]: 'coding'

    In [37]: coding_contact.name # 具名元组

    Out[37]: 'coding'

    转化为(类)字典对象

    日常开发中之所以会使用字典来保存缓存的内容, 很重要的原因是为了方便解析为 json 格式返回, 以往的 ORM 对象 (如 Flask-SQLALchemy) 如不引用外部框架, 一般也不具备转为键值的能力. 而具名字典正有这样的特性, 利用内置的 _asdict() 方法即可:

    In [20]: Contact = namedtuple('Contact', columns)

    In [21]: contact = ['coding', 'Dongguan', 'fesonx@foxmail.co

    ...: m']

    In [22]: coding_contact = Contact(*contact)

    In [26]: coding_contact._asdict()

    Out[26]:

    OrderedDict([('name', 'coding'),

    ('city', 'Dongguan'),

    ('email', 'fesonx@foxmail.com')])

    In [27]: import json

    In [28]: json.dumps(coding_contact._asdict())

    Out[28]: '{"name": "coding", "city": "Dongguan", "email": "fesonx@foxmail.com"}'

    字典可以使用 .keys() 方法来得到键名列表, 而具名元组可以使用 ._fields 属性获得一个字段元组, 用来判断前端传入的排序属性是否存在非常方便:

    In [48]: Contact._fields

    Out[48]: ('name', 'city', 'email', 'phone')

    In [49]: 'city' in Contact._fields

    Out[49]: True

    欢迎关注公众号: 程序员的碎碎念

    展开全文
  • Python元组与列表类似,不同之处在于元组的元素能修改。元组使用小括号,列表使用方括号。...修改元组说明: python中不允许修改元组的数据,包括能删除其中的元素。<3>元组的内置函数count, i...
  • One question that I faced today, which actually tested the immutability of the tuples in Python:Interviewer: Are tuples immutable in Python?Me: YesInterviewer: So what does print(t1) here print?t1 = ...
  • Python不可变序列(元组)1. 元组概述2. tuple 函数3. 元组的基本操作3.1 “ + ” 和 “ * ” 运算3.2 分片操作3.3 in 操作3.4 元组长度、最大、最小值4. 元组的重要性 1. 元组概述 元组也是一种序列,与列表...
  • Python可变类型总结Python中数据类型大致可以分为字符串类型,元组类型,列表类型,字典,集合,整型等等,这个周我们学习了Python语言不可变类型以及相对性的操作。可变类型Python中可变类型有列表类型,字典...
  • Python可变长度元组

    2021-07-19 16:23:27
    [Python 3.1]I'm following up on the design concept that tuples should be of known length (see this comment), and unknown length tuples should be replaced with lists in most circumstances. My question ...
  • 一、元组的介绍元组就是一个不可变的“列表”,按照索引存放多个,只能读,能改;元组也是按照索引获取元组内元素的元组属于按索引聚会不可变数据。使用tuple或()可以定义一个新的元组;使用小括号()定义...
  • 欢迎你来到站长在线的站长学堂学习...但是在元组中,就能说添加元组元素、修改元组元素和删除元组元素了,因为元组不可变的序列,也是一种不可变的列表。当然我们也可以尝试一下修改一个元组元素看看,有什么结.
  • 示例 S = 'hello' print(S) S[0] = 'H' print(S) ...Traceback (most recent call last): File "/Users/ccccc/PycharmProjects/jiratest/studyDemo.py", line 3, in ...你永远能覆盖不可变对象的,但是你...
  • 你可以把它看作是只读的列表,因为元组不可改变,但是要注意,如果元组中含有列表元素,则该列表元素是可变的,通俗地讲就是“儿子不可变,但是孙子可变”。由于元组不可变,所以对于增删改查这四种标准操作来讲只有...
  • 我总是发现对于同一基本数据结构(数组)具有两种完全不同的类型是方便的, 但是实际上这并不是真正的问题。(每种语言都有其缺点, 包括Python, 但这并是那么...创建后, 无论对象是否可变, 都无法更改其位置。(更确...
  • python中元组是什么

    2021-01-14 15:48:51
    Python中将能修改的称为不可变的,不可变的列表则被称为“元组”。Python元组与列表类似,不同之处在于元组的元素能修改。元组使用小括号,列表使用方括号。元组创建很简单,只需要括...
  • 键和可以是任意的数据对象,大多数情况还是以数字和字符串的方式构成字典是无序的,键字典必须是唯一,字典取值的方式是以键寻找相对应的字典是python中的映射数据类型字典支持拼接(concatenation)和...
  • 常常拿元组与列表作对比,他俩相似,都是的集合,最大的区别应该就是 列表是可变类型,元组不可变类型。 1. 创建元组元组由括号组成,并用逗号分隔开 >>> a = (1, 2, 3) >>> a (1,...
  • 下面代码的输出结果是: a = "alex" b = a.capitalize() print(a,end=",") print(b)【单选题】以下关于随机运算函数库的描述,错误的是:【单选题】以下选项,输出结果为False的是【单选题】关于函数局部...
  • Python中元组的使用

    2021-02-05 23:58:37
    Python中元组的使用1 元组1.1 元组的创建1.2 连接操作符 “+” 和重复操作符 “*”1.3 切片1.4 查看索引和出现次数2 命名元组2.1 命名元组的使用 1 元组 元组是使用圆括号"()"来标识的,定义元组后,元组值不能...
  • 一:元组(tuple)的创建:元组也是Python中的一种有序的序列,它和列表非常的相似,不同的是,列表的元素是可以进行修改的,但是元组中的元素是可修改的,即元组不可变的序列。上篇说列表使用括号 [ ] ,...
  • 10个示例带你掌握python中元组

    千次阅读 2021-01-29 06:00:45
    与列表不同,元组的元素是不可变的。不变性可以视为元组的识别特征。我将通过示例解释元组的功能和对其的操作。一、创建元组元组由括号组成,并用逗号分隔开a=(3,4)print(a)print(type(a))...
  • 如何在Python元组中定义重复项?

    千次阅读 2021-04-27 09:47:43
    为此,我可以一直采用手动方式:foo = (1, 2, 2, 2, 3, 4, 4, 5)然而,当列表的项目数量很大时,这会得有点混乱。所以,我想知道哪些方法可以使生成每个项目所需数量的副本的任务自动化。如何确定重复次数?@...
  • python不可变对象

    2021-02-10 07:18:55
    在python对象分类已经 介绍了python不可变对象,下面将列举实例,详细分析:html不可变类型(数字,字符串,元组不可变集合):支持原处修改。python引用shell>>> a=345>>> b=a>>> a...
  • 一、前言 好好学过几天python的小伙伴肯定知道,python有一种数据...但元组中的内容真的是不可改变的吗? 下面的这段代码可能会让你心生疑惑 a = (1, {'key': 1}) a[1]['key'] = 2 print(a) 输出结果: 这结果不是
  • 元组不可变Python对象序列。元组的序列就像列表。唯一的区别是,元组不能被改变,即元组可被修改。元组使用小括号,而列表使用方括号。创建一个元组很简单,只要把不同的逗号分隔,可以把括号的这些逗号...
  • Python:可变长度元组

    2020-12-30 03:58:25
    under what circumstances should I deviate from that [tuples should be of known ...(x,y)坐标,(c,m,y,k)颜色,(纬度,经度)位置等元组具有固定数量的元素,这些元素通常基于问题域和当前问题的细节。设计元...
  • python中可变数据类型和不可变数据类型的区别最近研究某一博主的代码时偶然发现了一个问题,第一反应肯定是小编自己知识上的欠缺。然后经过各种百度啊之类的终于找到了原因。上面就是小编遇到的问题,按照小编的...
  • 为什么字典的key必须是不可变的?字典的哈希表实现使用从键值计算的哈希来查找键。如果键是可变对象,则其可能会发生变化,因此其哈希也会发生变化。但是,由于无论谁更改键对象都无法判断它是否被用作字典...
  • tuple作为不可变对象,每个tuple对象第一次创建后,持有的元素能改变,这是元组的基本概念。但元组解包功能是其中一个很常见的功能点,今天总结下元组解包的几种情况 情况一: 元组赋值给多个变量。 # 元组...
  • python元组怎么排序

    千次阅读 2021-02-03 14:21:58
    Python中的列表是可变对象,对可变对象可以排序,比如说:L.sort()或者sorted(L),但在元组数据结构,因为元组不可变对象,不会提供列表的这些方法,方法就是先将元组转变为列表,对转变后的列表排序后,再转变...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 87,204
精华内容 34,881
关键字:

在python中元组的值是不可变的

python 订阅