精华内容
下载资源
问答
  • 元组集合

    千次阅读 2019-06-07 21:29:46
    元组 列表和字符串有很多通用的属性,例如索引和切割操作。它们是 序列 类型中的两种。因为 Python 是一个在不停进化的语言,也可能会加入其它的序列类型,这 里介绍另一种标准序列类型: 元组 。 一个元组由数个...

    元组

    列表和字符串有很多通用的属性,例如索引和切割操作。它们是 序列 类型中的两种。因为 Python 是一个在不停进化的语言,也可能会加入其它的序列类型,这
    里介绍另一种标准序列类型: 元组 。
    一个元组由数个逗号分隔的值组成,元组就像字符串, 不可变的。通常包含不同种类的元素并通过分拆或索引访问。一对空的括号可以创建空元组;要创建一个单元素元组可以在值后面跟一个逗号(在括号中放入一个单值不够明确)。丑陋,但是有效。

    empty = ()
    singleton = 'Hello',
    doubleton = ('Java','C++')
    print(len(empty))
    print(singleton)
    print(doubleton)
    

    在这里插入图片描述

    集合

    set (集合)。集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。集合对象还支持 |(联合),&(交),-(差)和 ^(对称差集)等数学运算
    大括号或 set() 函数可以用来创建集合。注意:想要创建空集合,你必须使用 set() 而不是 {} 。

    a = set('abracadabra')
    b = set('alacazam')
    print(a)
    print(b)
    print('a-b',a-b)
    print('a|b',a|b)
    print('a&b',a&b)
    print('a^b',a^b)
    

    在这里插入图片描述
    集合推导式

    a = {x for x in 'abracadabra' if x not in 'abc'}
    print(a)
    

    在这里插入图片描述

    展开全文
  • 列表 元组 集合字典区别与函数用法

    千次阅读 2019-09-25 15:31:25
    理解Python中列表,元组,字典,集合的区别 列表,元组,字典,集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。 1.列表(List) 什么是列表呢?我觉得列表就是...

    理解Python中列表,元组,字典,集合的区别

    列表,元组,字典,集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。

    1.列表(List)

    什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单。比如,统计过去一周我们买过的东西,把这些东西列出来,就是清单。
    由于我们买一种东西可能不止一次,所以清单中是允许有重复项的。如果我们扩大清单的范围,统计我们过去一周所有的花费情况,
    那么这也是一个清单,但这个清单里会有类别不同的项,比如我们买东西是一种花费,交水电费也是一种花费,这些项的类型是可以使不同的。
    python的列表个跟清单的道理是一样的,特点就是:可重复,类型可不同。类型不同也是跟数组最本质的区别了。python里的列表用“[]”表示。

    #定义一个列表
    listA = [‘a’, ‘b’, ‘c’, 1, 2]

    listA[1] # ‘b’

    向 list 中增加元素

    1.使用append 向list 的末尾追加单个元素。(把列表当做堆栈使用——后进(后出))

    #listA = [‘a’, ‘b’, ‘c’, 1, 2, 3]
    listA.append(3)

    2.使用 insert 将单个元素插入到list 中。数值参数是插入点的索引

    在下标为3处插入一个元素,listA = [‘a’, ‘b’, ‘c’, ‘d’, 1, 2, 3]

    listA.insert(3, ‘d’)

    3.使用 extend 用来连接 list

    listA = [‘a’, ‘b’, ‘c’, ‘d’, 1, 2, 3, 7, 8]

    listA.extend([7, 8])

    获取列表的长度

    print len(listA) # 9

    在 list 中搜索

    listA.index(3) # index 在 list 中查找一个值的首次出现并返回索引值。
    listA.index(‘100’) # 如果在 list 中没有找到值,Python 会引发一个异常。

    print 5 in listA # 要测试一个值是否在 list 内,使用 in。如果值存在,它返回 True,否则返为 False 。

    从 list 中删除元素

    listA.remove(3) # remove 从 list 中 仅仅 删除一个值的首次出现。如果在 list 中没有找到值,Python 会引发一个异常

    print listA.pop() # pop 它会做两件事:删除 list 的最后一个元素,然后返回删除元素的值。(把列表当做堆栈使用——(后进)后出)

    还有一种把列表当做队列使用,最先进入的元素最先释放(先进先出)

    不过,列表这样用效率不高。相对来说从列表末尾添加和弹出很快;

    在头部插入和弹出很慢(因为,为了一个元素,要移动整个列表中的所有元素)。

    遍历list

    for item in listA:
    print item

    extend (扩展) 与 append (追加) 的看起来类似,但实际上完全不同。

    extend 接受一个参数,这个参数总是一个 list,并且把这个 list 中的每个元素添加到原 list 中。
    append 接受一个参数,这个参数可以是任何数据类型,并且简单地追加到 list 的尾部。

    2.元组(Tuple)

    元组和列表在结构上没有什么区别,唯一的差异在于元组是只读的,不能修改。元组用“()”表示

    #定义一个元组
    tuple1 = (1,2,‘a’,4,‘5’,6)

    定义了一个元组之后就无法再添加或修改元组中的元素

    print tuple1[2] # ‘a’ 元组的元素都有确定的顺序。元组的索引也是以0为基点的
    print tuple1[-1] # ‘5’ 负的索引从元组的尾部开始计数
    print tuple1[1:3] # (2, ‘a’) 元组也可以进行切片操作。对元组切片可以得到(返回)新的元组,原元组不变

    可以使用 in 运算符检查某元素是否存在于元组中。

    print 1 in tuple1 # True

    #使用for in 进行遍历元组
    for item in tuple1:
    print item

    如果需要获取item的序号 可以使用下面的遍历方法:

    for index in range(len(tuple1)): #range(len(tuple1))就是生成一个自然排序列表
    print tuple1[index]

    还可以使用内置的enumerate函数

    for index, item in enumerate(tuple1):
    print ‘%i, %s’ % (index, item)

    3.字典(Dictionary)

    字典定义了键和值之间一对一的关系,但它们是以无序的方式储存的。 Python 中的 dictionary 像 Java 中的 Hashtable 类的实例。定义 Dictionary 使用一对大(花)括号” { } “

    Dictionary 不只是用于存储字符串。Dictionary 的值可以是任意数据类型,包括字符串、整数、对象,甚至其它的 dictionary。
    在单个 dictionary 里,dictionary 的值并不需要全都是同一数据类型,可以根据需要混用和匹配。

    定义一个字典

    dict1 = {‘name’ : ‘yeoman’, ‘age’ : 24, ‘sex’ : ‘Male’}

    dict1[‘name’] = ‘yuanm’ # 为一个已经存在的 dictionary key 赋值,将简单覆盖原有的值。
    dict1[‘Age’] = 25 # 在 Python 中是区分大小写的 age和Age是完全不同的两个key

    从字典中删除元素

    del dict1[‘sex’] # del 允许您使用 key 从一个 dictionary 中删除独立的元素

    dict1.clear() # clear 从一个 dictionary 中清除所有元素

    4.集合(Set)

    Python的集合(set)和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素.
    集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.由于集合是无序的,所以,sets 不支持 索引, 分片, 或其它类序列(sequence-like)的操作。

    集合也存在不可变形式,frozenset为固定集合.
    set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。
    注意:想要创建空集合,你必须使用 set() 而不是 {} ,后者用于创建空字典
    可以通过一个set函数转换成集合,如:

    lst = [ 1, 1, 0]

    lst_set = set( lst ) #lst_set 为1 , 0

    tup = (2, 2, 1)

    tup_set = set( tup) # tup_set为2 , 1

    for item in lst_set:
    print item

    使用 set 函数创建集合

    list1 = [6, 7, 7, 8, 8, 9]
    set2 = set(list1)

    set2.add(10) # 添加新元素
    print set2 # set([8, 9, 10, 6, 7]) 去掉重复内容,而且是无序的

    set3 = frozenset(list1)
    #set3.add(10) # 固定集合不能添加元素,会报错AttributeError: ‘frozenset’ object has no attribute ‘add’

    集合有并集,交集,求差操作

    a & b 并集:intersection() 方法返回一个新集合,包含在两个集合中同时出现的所有元素。

    a | b 交集:union() 方法返回一个新集合,包含在两个 集合中出现的元素。

    a - b 差集:difference() 方法返回的新集合中,包含所有在 集合A出现但未在集合B中的元素。

    a ^ b 对称差集:symmetric_difference() 方法返回一个新集合,包含所有只在其中一个集合中出现的元素。

    删除元素

    set2.discard(6) # 当元素不存在时,不会引发异常
    set2.remove(6) # 与discard的区别在于,如果没有要删除的元素,remove会引发一个异常
    set2.pop() # 因为set是无序的,所以pop会随机的从set中删除一个元素

    展开全文
  • 元组集合

    2021-03-09 19:37:09
    目录元组创建方式原理元组的遍历集合创建方式相关操作集合间的关系集合的数学操作集合生成式 元组 pyhton内置的数据结构之一,是一个不可变序列,没有增删改操作。包括字符串和元组。 可变序列具有增删改操作,且...

    元组

    pyhton内置的数据结构之一,是一个不可变序列,没有增删改操作。包括字符串和元组。

    可变序列具有增删改操作,且经过该操作后,内存地址不发生更改。

    创建方式

    # 直接小括号,元素与元素之间用逗号分隔
    t = ('hello','good','morning')
    t2 = 'hello','good',10 # 小括号可以省略
    print(t)
    print(t2,type(t2))
    
    # 使用内置函数tuple()
    t=tuple(('hello','good','morning'))
    print(t)
    
    # 只包含一个元素的元组需要使用逗号和小括号
    t=(10,) # 逗号不可省略,否则就是原数据类型
    print(t)
    
    # 空元组
    t1=()
    t2=tuple()
    print(t1,t2)
    
    ('hello', 'good', 'morning')
    ('hello', 'good', 10) <class 'tuple'>
    ('hello', 'good', 'morning')
    (10,)
    () ()
    

    原理

    为什么要将元组设计成不可变序列?
    在多任务环境下,同时操作对象时不需要加锁,因此,在程序中尽量使用不可变序列。

    注意事项:元组中存储的是对象的引用

    a)如果元组中对象本身不可对象,则不能再引用其他对象;

    b)如果元组中的对象是可变对象,则可变对象的引用不允许改变,但数据可以改变

    元组的遍历

    # 元组是可迭代对象,可以使用for...in进行遍历
    t = ('hello','good',100)
    for item in t:
        print(item,type(item))
    
    hello <class 'str'>
    good <class 'str'>
    100 <class 'int'>
    
    # 可以根据索引提取元组元素
    t = ('hello','good',100)
    print(t[0])
    
    hello
    

    集合

    python语言提供的内置数据结构,与列表、字典一样都属于可变的序列;集合是没有value的字典

    创建方式

    # 直接{}创建,元素与元素之间用逗号隔开
    s = {'hello','good',100}
    print(s,type(s))
    
    s_1 = {1,2,3,4,4,5,6} # 集合中的元素不可重复
    print(s_1)
    
    {'good', 'hello', 100} <class 'set'>
    {1, 2, 3, 4, 5, 6}
    
    # 使用内置函数set()
    s = set(range(5))
    print(s,type(s))
    s_1=set([1,2,3,4,5]) # 将列表转化为集合
    s_2=set((1,2,3,4,67)) # 将元组转化为集合,集合是无序的
    s_3=set(('python')) # 将转化为集合,集合是无序的
    s_4=set({123,4,5,6,7}) # 将集合转化为集合,集合是无序的
    print(s_1)
    print(s_2)
    print(s_3)
    print(s_4)
    
    {0, 1, 2, 3, 4} <class 'set'>
    {1, 2, 3, 4, 5}
    {1, 2, 67, 3, 4}
    {'t', 'h', 'n', 'p', 'o', 'y'}
    {4, 5, 6, 7, 123}
    
    # 定义一个空集合
    s_5 = set()
    print(s_5,type(s_5))
    
    s_6 = {}  # 创建的是空字典
    print(s_6,type(s_6))
    
    set() <class 'set'>
    {} <class 'dict'>
    

    相关操作

    # 判断某元素是否在集合内,in / not in
    s = set(range(5))
    print(0 in s)
    print(6 not in s)
    
    True
    True
    
    # 新增元素
    
    # 调用add()方法,一次添加一个元素
    s = {1,2,3,4,5,6}
    s.add(9)
    print(s)
    s.update({4,5,6,7,8}) # 重复的不加入,可添加列表/元组
    print(s)
    
    # 调用update()方法至少调价一个元素
    
    {1, 2, 3, 4, 5, 6, 9}
    {1, 2, 3, 4, 5, 6, 7, 8, 9}
    
    # 集合元素的删除操作
    s = {1,2,3,4,5,6}
    
    # 一次删除一个指定元素,若元素不存在则返回KeyError
    s.remove(6) 
    print(s)
    
    # 调用discard()方法,一次删除一个指定元素,若元素不存在,不会报错
    s.discard(99)
    print(s)
    
    {1, 2, 3, 4, 5}
    {1, 2, 3, 4, 5}
    
    # 调用pop()方法,一次只删除一个任意元素
    s.pop()
    print(s)
    
    {2, 3, 4, 5}
    
    # 调用clear()方法,清空集合
    s.clear()
    print(s)
    
    set()
    

    集合间的关系

    # 两个集合是否相等,可以使用==或!=进行判断
    s1 = {1,2,3,4}
    s2 = {3,4,2,1}
    print(s1==s2)
    print(s1!=s2)
    
    True
    False
    
    # 一个集合是否是另一个集合的子集,可以调用方法issubset进行判断
    s1 = {1,2,3}
    s2 = {1,2,3,4,5}
    s3 = {7,5}
    print(s1.issubset(s2))
    print(s3.issubset(s2))
    
    True
    False
    
    # 一个集合是否是另一个集合的超集,可以调用方法issuperset进行判断
    s1 = {1,2,3}
    s2 = {1,2,3,4,5}
    s3 = {7,5}
    print(s2.issuperset(s1))
    print(s2.issuperset(s3))
    
    True
    False
    
    # 两个集合是否没有交集,可以调用方法isdisjoint进行判断
    s1 = {1,2,3}
    s2 = {1,2,3,4,5}
    s3 = {7,5}
    print(s1.isdisjoint(s3))
    print(s2.isdisjoint(s3))
    
    True
    False
    

    集合的数学操作

    s2 = {1,2,3,4,5}
    s3 = {7,5}
    
    # 交集
    print(s2.intersection(s3))
    print(s2 & s3)
    
    {5}
    {5}
    
    # 并集
    s2 = {1,2,3,4,5}
    s3 = {7,5}
    print(s2.union(s3))
    print(s2|s3)
    
    {1, 2, 3, 4, 5, 7}
    {1, 2, 3, 4, 5, 7}
    
    # 差集
    s2 = {1,2,3,4,5}
    s3 = {7,5}
    print(s2.difference(s3))
    print(s2-s3)
    print(s3.difference(s2))
    print(s3-s2)
    
    {1, 2, 3, 4}
    {1, 2, 3, 4}
    {7}
    {7}
    
    # 对称差集
    s2 = {1,2,3,4,5}
    s3 = {7,5}
    print(s2.symmetric_difference(s3))
    print(s2^s3)
    
    {1, 2, 3, 4, 7}
    {1, 2, 3, 4, 7}
    

    集合生成式

    s = {i**2 for i in range(10)}
    print(s, type(s))
    
    {0, 1, 64, 4, 36, 9, 16, 49, 81, 25} <class 'set'>
    

    在这里插入图片描述

    展开全文
  • python列表,元组集合,字典之间互相转换本文着重介绍python 列表(list),元组(tuple),集合(set),字典(dict)四种类型之间的相互... 内置函数list内置函数list可以将字符串,集合元组转换列表a = 'python' ...

    python列表,元组,集合,字典之间互相转换

    本文着重介绍python 列表(list),元组(tuple),集合(set),字典(dict)四种类型之间的相互转换,转换成python列表需要使用list函数,转成元组需要使用tuple函数,转成集合需要使用set函数,转成字典需要使用dict函数

    1. 内置函数list

    内置函数list可以将字符串,集合,元组转换为列表

    a = 'python' # 字符串

    b = {1, 2, 3} # 集合

    c = (1, 2, 3) # 元组

    print(list(a))

    print(list(b))

    print(list(c))

    输出结果是

    ['p', 'y', 't', 'h', 'o', 'n']

    [1, 2, 3]

    [1, 2, 3]

    list函数能否将字典转换成列表呢,这个需要探索一下

    print(list({'a': 3, 'b': 5}))

    输出结果为

    ['a', 'b']

    使用list函数转换字典,得到的是字典里所有的key,并没有获得value

    2. 内置函数set

    set函数可以将字符串,列表转换成集合

    a = 'python' # 字符串

    b = [1, 2, 1, 2] # 列表

    c = {'a': 1, 'b': 2} # 字典

    d = (1, 2, 3, 4) # 元组

    print(set(a))

    print(set(b))

    print(set(c))

    print(set(d))

    程序输出结果

    {'t', 'o', 'n', 'p', 'h', 'y'}

    {1, 2}

    {'b', 'a'}

    {1, 2, 3, 4}

    尝试转换字典时,只能获得由字典的key组成的集合

    3. 内置函数tuple

    a = 'python' # 字符串

    b = [1, 2, 1, 2] # 列表

    c = {'a': 1, 'b': 2} # 字典

    d = {1, 2, 3, 4} # 集合

    print(tuple(a))

    print(tuple(b))

    print(tuple(c))

    print(tuple(d))

    程序输出结果

    ('p', 'y', 't', 'h', 'o', 'n')

    (1, 2, 1, 2)

    ('a', 'b')

    (1, 2, 3, 4)

    尝试将字典转换为元组时,只能得到由字典的key组成的元组,看来字典有些特殊

    4. 内置函数dict

    无法直接使用dict函数将列表,元组,集合转换成字典,这是由字典的结构决定的,字典里的元素永远以key-value对的形式存在,key-value是一个映射关系,知道key,便可以获得value,而其他3种容器类型数据不存在映射关系,因此无法转换。

    dict函数有自己特殊的使用方法

    my_dict = dict(a=1, b=2)

    print(my_dict)

    程序输出结果

    {'a': 1, 'b': 2}

    展开全文
  • 1、列表和集合的区别 列表在遍历数据时对于重复的数据我们不进行过滤,直接输出,对于集合而言,遍历时重复的数字不给予遍历,即不会存储在集合中,在以下代码中会有明显的体现: str1=['ll',1,3.0,3,4] str2={'...
  • 上述集合有4个元素,分别是0、1、{0,1}、{1,2} ,其中元素{0,1}一个集合,它的元素0、1,元素{1,2}也一个集合,它的元素1、2。 优点:集合中的元素是确定的,且可以容纳多种类型的数据。 缺点:集合中...
  • 本篇文章给大家带来的内容是python中什么是元组集合元组集合的介绍。有一定的参考价值,有需要的朋友可以参考一下,希望对你们有所助。学习python的小伙伴们经常会有这样一个疑问,既然有列表里,问什么还要...
  • 一、元组转换数字tu = (1)tu1 = (1,)print(tu,type(tu))print(tu1,type(tu1))执行输出:1 (1,) 字符串tu = ('lao')tu1 = ('lao',)print(tu,type(tu))print(tu1,type(tu1))执行输出:lao ('lao',) 列表tu = ([1,2,3])...
  • 1.列表和元组关系 相同点: 列表和元组可以进行互换,列表和元组都支持切片操作,列表和元组都支持索引和负索引 不同点: 列表是有序的、可变序列,列表使用的是'[]',列表添加新元素是直接加在列表末尾 元组...
  • 字符串、列表、元组、字典1.字符串2.列表 1.字符串 1.1 Python中的字符串可以使用单引号、双引号和三引号(三个单引号或三个双引号)括起来,遇到重复使用时可以使用反斜杠\转义特殊字符。 使用转义字符: my_str = ...
  • 目录主要内容:集合元组字典小总结主要内容:2、集合3、元组4、字典复习:字符串和元组一样,只能读不能写。列表和字典可以嵌套任何东西,列表可以嵌套列表L = list("hello") # L = ['h', 'e', 'l', 'l', 'o']集合、...
  • 1、元组的元素可以元组、列表、集合 tips:列表作为元组的元素时,列表内的值是可以进行改动的 2、列表的元素可以元组、列表、集合 3、字典的元素可以元组、列表、字典、集合 4、集合的元素可以:...
  • 关系型数据库系统的关系模型、关系元组、属性、关系实例概念说明
  • python中的元组集合

    千次阅读 2020-11-30 07:21:04
    一、元组元组的属性:有序不可改,可以通过下标获取元素1、元祖命名可以用(),只有一个元素的时候要加逗号L3=()L2=(1,)L1=(1)print(type(L3))print(type(L2))print(type(L1))2、有序可以通过下标获取元素,且可以循环...
  • python中列表 元组 字典 集合的区别

    千次阅读 2018-12-14 10:23:23
    元组 集合 字典 英文 list tuple set dict 定义 定义[],数据之间使用,分割 定义(),数据之间用,分割 定义用 {} 或 set() 字典的每个键值 key=&gt;value 对用冒号 : 分割,...
  •  集合不支持下标索引,它是可变的数据类型,集合中的元素是唯一的,且不可以存列表和字典,一般用于元组或者列表中的元素去重。 ②打印输出顺序不一样  使用print输出字典的时候,通常输出的顺序和定义的顺序是...
  • Python中的元组集合

    2021-01-10 19:49:55
    集合2.1 什么是集合2.2 集合的创建2.2 集合的增、删、改、查操作2.2.1 集合元素的判断操作2.2.2 集合元素的新增操作2.2.3 集合元素的删除操作2.3 集合生成式2.3.1 集合间的相关关系2.3.2 集合的数据操作2.3.3 集合...
  • 1.列表,元组,字典是有顺序的,而集合是没顺序的 2.列表是以方括号形式表示,元组是以圆括号表示,字典以花括号表示,集合则是以[()]的形式表示 3.列表是可变对象,它支持在原处修改的操作.也可以通过指定的索引和分...
  • 一、定义与特性 1、列表:列表是一组有序存储的数据,它的特性包括:(1、和...2、元组:(1、一经定义内容无法改变;(2、元组元素可以是不同的类型;(3、元组使用圆括号括起来元素。 3、字典:(1、字典是在内存中保...
  • 任意对象的有序集合列表是一组任意类型的值,按照一定顺序组合而成的2.通过偏移读取组成列表的值叫做元素(Elements)。每一个元素被标识一个索引,第一个索引是0,序列的功能都能实现3.可变长度,异构以及任意嵌套...
  • 列表 字典 元组 集合

    2018-11-22 16:25:00
    类型转换 定义列表实际上是借用list()方法生成列表,可以将其他类型转化列表,如字符串元组,字典集合 3、常用操作+内置的方法1、按索引存取值(正向存取+反向存取):即可存也可以取  使用下标索引来访问列表...
  • 1. 集合 1.1 朴素的定义 Definition 1. A set is a collection of elements, and an element is an object in a set. 集合有两种基本的表示法: 列举法 如: A={0,1,2,3,4,5,6,7,8,9}\mathbf{A} = \{0, 1, 2, 3, 4, 5...
  • **python中列表 元组 字典 集合

    千次阅读 2021-01-30 05:45:01
    列表 元组 字典 集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。1.列表列表是以方括号“[]”包围的数据集合,不同成员以“,”分隔。列表的特点:有序,数据可变,...
  • 关系运算及元组演算

    千次阅读 2019-10-10 15:51:11
    计算两个关系集合理论上的并集,即给出关系R和S(两者有相同元/列数),R∪S的元组包括R和S所有元组集合,形式定义如下: 式中 t是元组变量(下同)。显然,R∪S=S∪R。 (2)差。计算两个关系的区别...
  • 关系代数 元组关系演算

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,669
精华内容 19,867
关键字:

关系为元组的集合