精华内容
下载资源
问答
  • 关系元组中不允许出现重复元组 我怎么感觉这句话是错的啊?? 比如我再Sql server2005中 向数据库中的table1中插入了2个相同元组,也没有报错啊? 请问倒底是书本错了?还是我理解的有偏差?? ...
  • 元组

    2021-01-13 23:30:30
    如果想要存储多个数据,但是这些数据是不能修改的,这个时候就需要使用元组,因为列表的数据允许修改 注意:如果定义的元组只有⼀个数据,那么这个数据后⾯面也好添加逗号,否则数据类型为唯⼀元素的数据类型 ...

    元组使用场景

    如果想要存储多个数据,但是这些数据是不能修改的,这个时候就需要使用元组,因为列表的数据允许修改

    注意:如果定义的元组只有⼀个数据,那么这个数据后⾯面也好添加逗号,否则数据类型为唯⼀元素的数据类型

    元组的特点

    定义元组使用小括号,且逗号隔开各个数据,数据可以是不同的数据类型,这与列表相同

    可以看到,元组中的元素不能被修改!!

    元组的常见操作

    1.查找

    • 按下标查找

    • index():查找某个数据,如果数据存在返回对应的下标,否则报错,语法和列表、字符串串的index方法相同

    • count():统计某个数据在当前元组出现的次数

    • len():统计元组中数据的个数

    2.修改

    元组中的数据不可修改,但是如果元组中有列表,则列表中的元素可以修改

    这种做法不推荐!!!

     

     

     


     

    展开全文
  • Python 元组

    千次阅读 2017-05-17 20:51:23
    在 Python 中,元组(Tuple)与列表类似。两者之间的区别在于:元组不能更改,列表可以。也就是说,一旦被分配,就不能从元组中添加、更改或删除元素。

    简述

    在 Python 中,元组(Tuple)与列表类似。两者之间的区别在于:元组不能更改,列表可以。也就是说,一旦被分配,就不能从元组中添加、更改或删除元素。

    | 版权声明:一去、二三里,未经博主允许不得转载。

    元组的优点

    既然和列表类似,那元组的作用到底是什么呢?用列表代替不就可以了?

    与列表相比,元组有很多优点:

    • 通常将元组用于不同的数据类型,将列表用于相同(或相似)的数据类型。
    • 由于元组不可变,所以遍历元组比列表要快(较小的性能提升)。
    • 元组可以用作字典的 key,而列表不行。因为字典的 key 必须是不可变的,元组本身就是不可变的。
    • 如果数据不需要更改,将其作为元组来实现,可以确保“写保护”。
    • 元组可以被用在字符串格式化中。

    元组

    在 Python 中,元组由内置的 tuple 类型定义。

    要创建元组,需要将所有项(元素)放在括号(())内,以逗号(,)分隔。

    注意: 括号是可选的,但还是建议写上。

    >>> tup = ('P', 'y', 't', 'h', 'o', 'n')
    >>> type(tup)
    <class 'tuple'>

    元组中的元素可以是任意数量,还可以是不同类型(例如:数字、字符串、列表等)。

    >>> tup = ()  # 空元组
    >>> 
    >>> tup = ('P', 'y', 't', 'h', 'o', 'n')   # 字符串类型元组
    >>> 
    >>> tup = (1, 5.5, 'Python')   # 混合类型元组
    >> 
    >>> tup = (6, 'Python', ('P', 'y', 't', 'h', 'o', 'n'))  # 嵌套元组
    >>> 
    >>> tup = 1, 5.5, 'Python'   # 创建元组时可以没有括号,也称为元组包装
    >>> tup
    (1, 5.5, 'Python')
    >>> 
    >>> a, b, c = tup  # 元组解包
    >>> a
    1
    >>> b
    5.5
    >>> c
    'Python'

    构造包含一个元素的元组比较特殊,括号内只包含一个元素是不够的,还需要在元素后添加一个逗号。

    >>> tup = ('Python')  # 只有括号
    >>> type(tup)
    <class 'str'>
    >>> 
    >>> tup = ('Python',)  # 在元素后面添加逗号
    >>> type(tup)
    <class 'tuple'>

    可以看出,没有逗号就不是元组,加了逗号才是。

    索引和切片

    有了前面关于字符串和列表的基础知识,元组很容易掌握。因为它们都属于序列,因此,基本操作是一样的。

    可以使用索引操作符([]) 来访问元组中的一个元素,使用切片操作符(:)来访问元组中的一系列元素。

    Tuple

    >>> tup = ('P', 'y', 't', 'h', 'o', 'n')
    >>>
    >>> tup[0]  # 第 1 个元素
    'P'
    >>>
    >>> tup[-2]  # 第 5 个元素(反向索引)
    'o'
    >>>
    >>> tup = (6, 'Python', ('P', 'y', 't', 'h', 'o', 'n'))  # 嵌套元组
    >>> 
    >>> tup[2][3]  # 嵌套索引
    'h'
    >>>
    >>> tup = ('P', 'y', 't', 'h', 'o', 'n')
    >>> 
    >>> tup[1:4]  #  第 2 个到第 4 个元素
    ('y', 't', 'h')
    >>> 
    >>> tup[:-3]  # 开始到第 3 个元素
    ('P', 'y', 't')

    其他的一些基本操作,例如:连接(+)、重复(*)、成员测试(in)、遍历(for)等,就不再一一展示了,请参考:Python 列表

    更改元组

    元组是不可变的,也就是说,元组中的元素在被赋值后不能改变。

    但是,如果元素本身是一个可变数据类型的列表,那么其嵌套项可以被改变。

    >>> tup = (6, 'Python', ['P', 'y', 't', 'h', 'o', 'n'])
    >>> 
    >>> tup[0] = 8  # 不能改变元素
    ...
    TypeError: 'tuple' object does not support item assignment
    >>> 
    >>> tup[2][3] = 's'  # 可变的元素可以被改变
    >>> tup
    (6, 'Python', ['P', 'y', 't', 's', 'o', 'n'])

    删除元组

    如上所述,不能更改元组中的元素,这也意味着无法删除元组中的元素。

    但是,使用关键字 del 可以删除整个元组。

    >>> tup = ('P', 'y', 't', 'h', 'o', 'n')
    >>> 
    >>> del tup[2]  # 无法删除元素
    ...
    TypeError: 'tuple' object doesn't support item deletion
    >>> 
    >>> del tup  # 可以删除整个元组
    >>> tup
    ...
    NameError: name 'tup' is not defined

    列表和元组互转

    列表和元组之间可以进行相互转换,分别使用 list() 和 tuple() 实现:

    >>> tup = ('P', 'y', 't', 'h', 'o', 'n')
    >>> listx = list(tup)
    >>> listx
    ['P', 'y', 't', 'h', 'o', 'n']
    >>> 
    >>> l = ['H', 'e', 'l', 'l', 'o']
    >>> tupx = tuple(l)
    >>> tupx
    ('H', 'e', 'l', 'l', 'o')

    既然可以互转,那么要改变元组,可以先将其转化为列表,对列表进行更改,然后再将列表转换为元组。

    例如,删除元组中的元素:

    >>> tup = ('P', 'y', 't', 'h', 'o', 'n')
    >>> listx = list(tup)  # 将元组转换为列表
    >>> listx.remove('h')  # 删除列表中的元素
    >>> tup = tuple(listx)  # 再将列表转换为元组
    >>> tup
    ('P', 'y', 't', 'o', 'n')

    注意: 元组本身是不可变的。这里说的并不是传统意义的改变,相当于元组的重新赋值。

    元组的方法

    元组中的方法相对较少,可以通过 dir() 来查看方法列表:

    >>> dir(tuple)
    ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

    可以看到,有两个可用的方法:

    方法 描述
    index() 返回第一个匹配项的索引
    count() 统计某个元素在列表中出现的次数

    使用很简单,也非常好记。

    >>> tup = ('P', 'y', 't', 'h', 'o', 'n')
    >>> 
    >>> tup.index('h')  # 返回第一个匹配 'h' 的索引
    3
    >>> 
    >>> tup.count('o')  # 统计 'o' 在元组中出现的次数
    1

    注意: 元组不可变,所以添加或删除元素的方法不适用于元组。

    元组与内置函数

    下述内置函数通常与元组一起使用,来执行不同的任务。

    函数 描述
    all() 如果元组中的所有元素都是 True(或者元组为空),则返回 True。
    any() 如果元组中的所有元素都是 True,则返回 True;如果元组为空,则返回 False。
    enumerate() 返回一个枚举对象,其中包含了元组中所有元素的索引和值(配对)。
    len() 返回元组的长度(元素个数)
    max() 返回元组中的最大项
    min() 返回元组中的最小项
    sorted() 返回一个新的排序元组(不排序元组本身)
    sum() 返回元组的所有元素之和
    tuple() 将 iterable(字符串、列表、集合、字典)转换为元组
    展开全文
  • 列表和元组都属于有序序列,支持使用双向索引访问其中的元素、使用内置函数len()统计元素个数、使用运算符in测试是否包含某个元素、使用count()方法统计指定元素的出现次数和index()方法获取指定元素的索引。...

    列表和元组都属于有序序列,支持使用双向索引访问其中的元素、使用内置函数len()统计元素个数、使用运算符in测试是否包含某个元素、使用count()方法统计指定元素的出现次数和index()方法获取指定元素的索引。虽然有着一定的相似之处,但列表和元组在本质上和内部实现上都有着很大的不同。

    元组属于不可变(immutable)序列,一旦创建,不允许修改元组中元素的值,也无法为元组增加或删除元素。因此,元组没有提供append()、extend()和insert()等方法,无法向元组中添加元素;同样,元组也没有remove()和pop()方法,也不支持对元组元素进行del操作,不能从元组中删除元素。元组也支持切片操作,但是只能通过切片来访问元组中的元素,而不允许使用切片来修改元组中元素的值,也不支持使用切片操作来为元组增加或删除元素。从一定程度上讲,可以认为元组是轻量级的列表,或者“常量列表”。

    Python的内部实现对元组做了大量优化,访问速度比列表更快。如果定义了一系列常量值,主要用途仅是对它们进行遍历或其他类似用途,而不需要对其元素进行任何修改,那么一般建议使用元组而不用列表。元组在内部实现上不允许修改其元素值,从而使得代码更加安全,例如调用函数时使用元组传递参数可以防止在函数中修改元组,而使用列表则很难做到这一点。

    最后,作为不可变序列,与整数、字符串一样,元组可用作字典的键,也可以作为集合的元素,而列表则永远都不能当做字典键使用,也不能作为集合中的元素,因为列表不是不可变的,或者说不可哈希。

    展开全文
  • 元组类型

    2018-12-26 14:33:00
    元组(Tuple) 元组也是序列结构,但是是一种不可变序列,你可以简单的理解为内容不可变的列表。除了在内部元素不可修改的区别外,元组和列表的...元组中不允许的操作,确切的说是元组没有的功能: 修改、新增元...

    元组(Tuple)

    元组也是序列结构,但是是一种不可变序列,你可以简单的理解为内容不可变的列表。除了在内部元素不可修改的区别外,元组和列表的用法差不多。

    元组与列表相同的操作

    • 使用方括号加下标访问元素
    • 切片(形成新元组对象)
    • count()/index()
    • len()/max()/min()/tuple()

    元组中不允许的操作,确切的说是元组没有的功能

    • 修改、新增元素
    • 删除某个元素(但可以删除整个元组)
    • 所有会对元组内部元素发生修改动作的方法。例如,元组没有remove,append,pop等方法。

    元组与列表类似的特殊操作:

     如下实例:

    tup1 = ('Google', 'Runoob', 1997, 2000)
    tup2 = (1, 2, 3, 4, 5 )
    tup3 = "a", "b", "c", "d"

    创建空元组

    tup1 = ()

     元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用:

    >>> tup1 = (50)
    >>> type(tup1)     # 不加逗号,类型为整型
    <class 'int'>
     
    >>> tup1 = (50,)
    >>> type(tup1)     # 加上逗号,类型为元组
    <class 'tuple'>

    元组与字符串类似,下标索引从0开始,可以进行截取,组合等。

     访问元组

    tup1 = ('Google', 'Runoob', 1997, 2000)
    tup2 = (1, 2, 3, 4, 5, 6, 7 )
     
    print ("tup1[0]: ", tup1[0])
    print ("tup2[1:5]: ", tup2[1:5])

    以上实例输出结果:

    tup1[0]:  Google
    tup2[1:5]:  (2, 3, 4, 5)

    修改元组

    元组中的一级元素是不允许修改的(如果元组中的元素有列表,这个列表中的元素可以修改),但我们可以对元组进行连接组合,如下实例:

    >>> tu = (111,"wss",[1,2],)
    >>> print(tu)
    (111, 'wss', [1, 2])
    >>> tu[2][0]= 1111
    >>> print(tu)
    (111, 'wss', [1111, 2])

    连接组合:

    tup1 = (12, 34.56);
    tup2 = ('abc', 'xyz')
     
    # 以下修改元组元素操作是非法的。
    # tup1[0] = 100
     
    # 创建一个新的元组
    tup3 = tup1 + tup2;
    print (tup3)

    以上实例输出结果:

    (12, 34.56, 'abc', 'xyz')

     删除元组

    元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组,如下实例:

    tup = ('Google', 'Runoob', 1997, 2000)
     
    print (tup)
    del tup;
    print ("删除后的元组 tup : ")
    print (tup)

    以上实例元组被删除后,输出变量会有异常信息,输出如下所示:

    删除后的元组 tup :
    Traceback (most recent call last):
      File "test.py", line 8, in <module>
        print (tup)
    NameError: name 'tup' is not defined

    元组索引,截取(切片)

    因为元组也是一个序列,所以我们可以访问元组中的指定位置的元素,也可以截取索引中的一段元素,如下所示:

    元组:

    L = ('Google', 'Taobao', 'Runoob')
    Python 表达式结果描述
    L[2] 'Runoob!' 读取第三个元素
    L[-2] 'Taobao' 反向读取;读取倒数第二个元素
    L[1:] ('Taobao', 'Runoob!') 截取元素,从第二个开始后的所有元素

     运行实例如下:

    >>> L = ('Google', 'Taobao', 'Runoob')
    >>> L[2]
    'Runoob'
    >>> L[-2]
    'Taobao'
    >>> L[1:]
    ('Taobao', 'Runoob')

    元祖转换字符串

    1.元祖中只有字符串,使用join方法

    tu = ("123", "wss")
    v = "".join(tu)
    print(v)

    输出结果:

    123wss

    2.元祖中既有字符串又有数字,写for循环处理

    tu = (11, 22, 33, "123", "wss")
    s = ""
    for i in tu:
        s = s + str(i)
    print(s)

    输出结果:

    112233123wss

    元组内置函数

    Python元组包含了以下内置函数:

    序号方法及描述
    1 count(obj)
    统计某个元素在元祖中出现的次数
    2 index(obj[,start=0[,end=len(tuple)]])
    从元祖中找出某个对象第一个匹配项的索引位置
    3 max(T)
    返回元组中元素最大值
    4 min(T)
    返回元组中元素最小值
    5 tuple(iterable)
    将可迭代对象转换为元组

    转载于:https://www.cnblogs.com/xiaohei001/p/10177968.html

    展开全文
  • Python元组

    2020-09-10 18:43:12
    列表可以一次性存储多个数据,但是列表中的数据允许更改 num_list=[10,20,30] num_list[0]=100 一个元组可以存储多个数据,元组内的数据是不能修改的。 二,定义元组 元组特点:定义元组使用小括号,且逗号隔开各个...
  • 列表和元组都属于有序序列,支持使用双向索引访问其中的元素、使用内置函数len()统计元素个数、使用运算符in测试是否包含某个元素、使用count()方法统计指定元素的出现次数和index(...
  • python元组相加a = (1,2)b = (3,4)a + b元组运用乘法(1,2) * 4#在这里边,元组不会被当成数字来计算,而是输出4次给字母类型的元组拍t = (bb,dd,aa,cc)tm = list(t)tm.sort()#然后输出tmt = tuple(tm)用f...
  • python-元组

    2021-07-07 10:36:27
    列表可以一次性存储多个数据,但是列表中的数据允许更改。 num_list = [10, 20, 30] num_list[0] = 100 一个元组可以存储多个数据,元组内的数据是不能修改的。 二. 定义元组 元组特点:定义元组使用小括号,且逗号...
  • 本片目录元组tuple元组的介绍元组的创建元组与列表相同的操作元组中不允许的操作元组与列表之间的转换字典dict集合set下一篇文章 元组tuple 元组的介绍 元组也是序列结构,但是是一种不可变的序列,可以简单理解为...
  • python中不允许修改元组的数据,包括不能删除其中的元素 常用操作 index():查找某个数据,如果数据存在返回对应的下标,否则报错,语法和列表、字符串的index方法相同。 count():统计某个数据在当前元组出现的...
  • Python:元组使用

    2019-05-19 15:04:23
    元组(tuple) (1)创建元组 (2)元组的使用 (3)打包和拆包 (4)函数的参数与元组 (5)元组的操作 创建元组 表达式:(元组对象,…) 描述元组时,有时也可以不写对象(e.g. (1,2,3)与 1...
  • Python——元组

    2018-12-03 20:25:41
    1.元组: •Tuple(元组)与列表类似,不同之处在于元组的一级元素不能修改(二级元素可以) •元组 表示多个元素组成的序列 •元组 在 Python 开发中,有特定的应用场景 •用于存储 一串 信息,数据 之间使用 , ...
  • python元组操作

    2018-12-08 16:53:28
    元组也是一组有序数据的组合,和列表唯一的不同是,元组不可修改 列表 = 用铅笔写的清单(能擦能改) 元组 = 用钢笔写的清单(不能擦改) 创建元组 创建空元组 方式1: 变量 = () 方式2: 变量 = tuple() 创建单个元素的...
  • Python3 元组

    2019-02-11 16:00:20
    元祖中元素的类型可以 不相同,它支持数字,字符串甚至可以包含列表 元组是写在小括号 () 之间、用逗号 , 分隔开的元素列表 元祖可以 被索引和截取,被截取后返回一个包含所需元素的新元祖。 二、访问元祖中的值 ...
  • python 元组操作总结

    2018-02-14 22:25:00
    2、元组中的值是不允许修改的,但是可以对元组进行连接组合 元组中包含列表元素,列表元素内容可以修改 3、元组中的元素是不允许删除,但是可以使用del语句来删除整个元组 4、元组之间可...
  • 列表与元组

    2020-03-18 18:21:25
    列表和元组 内容描述:序列常用方法、列表、元组,列表的常用方法以及元组的常用方法。 一、序列概述 1、概念:(1)索引:从0开始,最后是-1,数据类型为整型(int) (2)元素:列表和元组的元素可以是不同数据...
  • 2021-6.元组

    2021-01-05 09:46:44
    元组 Python的元组与列表类似,...说明: python中不允许修改元组的数据,包括不能删除其中的元素。 三、count, index index和count与字符串和列表中的用法相同 1、count()语法 Python中的count() 方法用于统计某个元
  • python中元组使用

    2021-01-16 21:29:11
    列表可以⼀次性存储多个数据,但是列表中的数据允许更改。 num_list = [10, 20, 30] num_list[0] = 100 ⼀个元组可以存储多个数据,元组内的数据是不能修改的。 ⼆. 定义元组 元组特点:定义元组使⽤⼩括号,...
  • python列表和元组

    2021-03-13 17:50:23
    一、列表 ...列表中的具有相同值的元素允许出现多次 [1, 2, 1, 1, 1, 1, 3, 3, 2] 2. 创建列表 3. 嵌套的列表 列表中可包含 python 中任何类型的元素(对象),当然也可以包括一个或多个列表 li = [['
  • Python元组相关知识

    2020-07-12 14:54:48
    Python元组相关知识 1.  元组简介 1.1 元组基本介绍 Python 的元组与列表类似,不同之处在于元组的元素不能修改。 元组表现形式tuple。 元组是⼀个不可变序列(⼀般当我们希望数据不改变时,我们使⽤元组,...
  • python中的元组操作

    2019-07-15 16:28:49
    元组操作 元组也是一组有序数据的组合,和列表唯一的不同是,元组不可修改 列表 = 用铅笔写的清单(能擦能改) 元组 = 用钢笔写的清单(不能擦改) 创建元组 创建空元组 方式1: 变量 = () 方式2: 变量 = tuple() ...
  • python笔记——元组

    2021-07-22 14:46:29
    元组 元组是python的内置数据结构之一,与字符串...#t1和t2创建的元组相同 t1 = ('python', 'hello', '98') t2 = 'python', 'hello', 98 只包含一个元素的元组需要使用逗号和小括号,缺一不可! t = ('python', )
  • 数据库 元组关系演算

    千次阅读 2019-02-17 21:47:37
    数据库 元组关系演算
  • [数据库]元组关系演算

    万次阅读 2014-11-18 13:53:11
     为了讨论方便,先允许关系的基数是无限的。然后再对这种情况下定义的演算作适当的修改,保证关系演算中的每一个公式表示的是有限关系。 在元组关系演算系统中,称 {t|Φ(t)} 为元组演算表达式。其中 t
  • 列表列表是可变的(mutable)——可以改变列表的内容,这不同于字符串和元组,字符串和元组都是不可变的。接下来讨论一下列表所提供的方法。list函数可以使用list函数来创建列表:list('Hello')['H', 'e', 'l', 'l', '...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,650
精华内容 10,660
关键字:

允许出现相同的元组