精华内容
下载资源
问答
  • 列表可以作为集合元素
    千次阅读
    2021-01-29 12:17:21

    【判断题】列表可以作为集合的元素。 (2.0分)

    【判断题】函数中必须包含return语句。 (3.5分)

    【单选题】以下哪条语句定义了一个Python字典( ) (3.0分)

    【判断题】函数是代码复用的一种方式。 (3.5分)

    【单选题】x = Truey = Falsez = Falseif not x or y:

    print(1)elif not x or not y and z:

    print(2)elif not x or y or not y and x:

    print(3)else:

    print(4) 以上代码输出结果为? (2.0分)

    【判断题】元组中的元素不允许删除。 (2.0分)

    【填空题】已知列表 x = [1, 2, 3, 4],那么执行语句 del x[1] 之后x的值为 __ 。 (5.0分)

    【其它】请参考附件中的实验程序说明文档,在完成实验,并获得汇总的班级实验数据之后,撰写实验报告。实验报告的格式请参考模版。 心理旋转实验.docx 实验心理学实验报告模板2019.doc 视觉反应时实验报告.pdf 数据文档: 18应A心理旋转实验数据结果.xlsx

    【单选题】在 if...elif...else 的多个语句块中只会执行一个语句块? (2.0分)

    【判断题】Python集合中的元素可以是元组。 (2.0分)

    【单选题】Python 中,for 和 while 可以有 else 语句? (2.0分)

    【判断题】字典中的值只能够是字符串类型。() (2.0分)

    【填空题】列表ls=[[2,3,7],[[3,5],25],[0,9]],len(ls)的值是 (5.0分)

    【填空题】已知 x=[3,5,7] ,那么执行语句 x[len(x):]=[1,2] 之后, x 的值为 ______________ 。 (5.0分)

    【判断题】字典可以作为集合的元素。 (2.0分)

    【判断题】定义函数时,即使该函数不需要接收任何参数,也必须保留一对空的圆括号来表示这是一个函数。 (3.5分)

    【单选题】字符串是一个字符序列,例如,字符串 s,从右侧向左第二个字符用什么索引? (3.0分)

    【其它】自选题,设计一项心理学实验研究的方案。文档的格式请参考《心理学报》的论文格式标准。 具体要求请见附件中的PPT 实验设计作业要求(2019).ppt

    【单选题】Python不支持的数据类型有 (3.0分)

    【填空题】表达式[1, 2, 3]*3的执行结果为 ____________ 。 (5.0分)

    【判断题】列表的索引是从0开始的。() (2.0分)

    【判断题】在函数内部没有办法定义全局变量。 (3.5分)

    【单选题】“ab”+”c”*2 结果是: (3.0分)

    【单选题】Python 中,如何输出列表example中的第二个元素? (3.0分)

    【其它】实验数据和实验程序说明文档: 18应A差别阈限的数据.sav 用恒定刺激法测量重量差别阈限.pdf 请大家撰写实验报告,并上传。

    【单选题】while 4 == 4: print('4') 以上代码输出的结果是? (2.0分)

    【填空题】对于字典d={"abc":1,"qwe":3,"zxc":2},len(d)的值是 (5.0分)

    【单选题】以下哪个关键字是用于给 if 语句添加其他条件语句的? (2.0分)

    【判断题】加法运算符可以用来连接字符串并生成新字符串。 (3.5分)

    【判断题】Python集合中的元素可以是列表. (2.0分)

    【填空题】在函数定义中调用自身的方式称为 。 (5.0分)

    【判断题】元组可以作为集合的元素。 (2.0分)

    【判断题】函数内部定义的局部变量当函数调用结束后被自动删除。 (3.5分)

    【单选题】以下不能创建一个字典的语句是 (3.0分)

    【单选题】Python 中,以下哪个代码是正确的字典? (3.0分)

    【其它】2018应心ABC反应时任务实验数据.sav 请利用上面的实验数据文档,完成本次实验的报告撰写,并上传。

    【填空题】创建一个元组box1,包括红、绿、蓝三个元素。写出语句: (5.0分)

    【简答题】请大家上传你的总结笔记于此。

    【判断题】定义Python函数时,如果函数中没有return语句,则默认返回空值None。 (3.5分)

    【填空题】有一个数 x 在区间 [-5,0] 内 , 写出其条件表达式 。 (5.0分)

    【判断题】不同作用域中的同名变量之间互相不影响,也就是说,在不同的作用域内可以定义同名的变量。 (3.5分)

    【单选题】for char in 'PYTHON STRING':

    if char == ' ':

    break

    print(char, end='')

    if char == 'O':

    continue 以上代码输出的结果是? (2.0分)

    【单选题】Python 中,以下哪个代码是正确的元组? (3.0分)

    【单选题】对于序列 s,哪个选项能够返回序列s中第i到j以k为步长的元素子序列? (3.0分)

    【填空题】表达式 'ab' in 'acbed' 的值为 ________ 。 (5.0分)

    【判断题】3+4j不是合法的Python表达式。 (3.5分)

    【判断题】通过下标索引可以修改和访问元祖的元素。() (2.0分)

    【判断题】在函数内部直接修改形参的值并不影响外部实参的值。 (3.5分)

    【填空题】表达式 3 ** 2 的值为 ___ 。 (5.0分)

    【判断题】Python列表中所有元素必须为相同类型的数据。 (2.0分)

    更多相关内容
  • 1、列表可以作为集合元素吗? 2、集合可以作为列表元素吗? 3、元组可以作为集合元素吗? 4、集合可以作为元组元素吗? 5、字典可以作为集合元素吗? 对于上面这五个问题,是不是不太懂呢?接下来我会一一...

    1、列表可以作为集合的元素吗?

    2、集合可以作为列表的元素吗?

    3、元组可以作为集合的元素吗?

    4、集合可以作为元组的元素吗?

    5、字典可以作为集合的元素吗?

    对于上面这五个问题,是不是不太懂呢?接下来我会一一解答。

    一、第一个问题:

    首先我们需要知道什么可以作为集合的元素。集合对象是一组无序排列***可哈希***的值,集合成员可以做字典中的键。那么可哈希与不可哈希是什么意思呢?

    简要的说可哈希的数据类型,即不可变的数据结构(字符串str、元组tuple、对象集objects);同理,不可哈希的数据类型,即可变的数据结构 (集合set,列表list,字典dict)

    >>> set1={[1,2,3,4],4,5,6}c
    Traceback (most recent call last):
      File "<pyshell#0>", line 1, in <module>
        set1={[1,2,3,4],4,5,6}
    TypeError: unhashable type: 'list'
    

    注:unhashable是“不可哈希的”的意思

    可见,报错了。所以列表不可以作为集合的元素.

    二、第二个问题:

    那么列表的元素可以有哪些呢?列表没有长度限制,元素类型可以不同,使用非常灵活。看例子:

    >>> list1=[{1,2,3,4},4,5,6]
    >>> list1
    [{1, 2, 3, 4}, 4, 5, 6]
    >>>
    

    说明集合可以作为列表的元素。

    三、第三个问题:

    在第一个小问中说到,元组(tuple)是不可变的数据结构(可哈希的数据类型),因此,是可以作为集合元素的。

    >>> set2={(1,2,3,4,5),6,7,8}
    >>> set2
    {8, (1, 2, 3, 4, 5), 6, 7}
    >>> 
    

    四、第四个问题:

    元组与列表类似,不同之处在于元组的元素不能修改具体用法我这里不在赘述。

    >>> tuple1=({1,2,3,4,5},89,5)
    >>> tuple1
    ({1, 2, 3, 4, 5}, 89, 5)
    >>> 
    

    所以集合可以作为元组的元素。

    五、第五个问题:

    因为字典是可变的数据结构(不可哈希),所以自然也不能作为集合的元素。

    >>> set1={{'Name': 'Runoob', 'Age': 7, 'Class': 'First'},4,5,6}
    Traceback (most recent call last):
      File "<pyshell#0>", line 1, in <module>
        set1={{'Name': 'Runoob', 'Age': 7, 'Class': 'First'},4,5,6}
    TypeError: unhashable type: 'dict'
    >>> 
    

    附上一张表:

    在这里插入图片描述
    观看顺序:ex:字符串可以作为列表的元素 列表可以作为列表的元素…

    如果有错误的地方,还请指正,大家一起学习。

    展开全文
  • 元组(tuple):有序,不更改,可以有重复的成员 集合(set):无序,无索引,没有重复的成员。 字典 (Dictionary):无序,更改,有索引,没有重复的成员 列表[](list)(有序,更改,可以有重复的成员) ...
  • **python中列表 元组 字典 集合

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

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

    1.列表

    列表是以方括号“[]”包围的数据集合,不同成员以“,”分隔。

    列表的特点:有序,数据可变,数据可重复,数据类型可不同,可嵌套。

    创建一个列表:tl = [1, 'Hello', 1, "你好", [2, 'World']]

    初步可以看到它的语法、数据可重复、数据类型可不同、可嵌套等特点,如果用print函数多输出几次就会发现它是有序的,下面我们看一下列表的常用操作,同时也证明列表数据可变。

    (1)list.append()追加成员,添加到末尾

    tl = [1, 'Hello', 1, "你好", [2, 'World']]

    print(tl)

    tl.append('test')

    print(tl)

    输出:

    [1, 'Hello', 1, '你好', [2, 'World']]

    [1, 'Hello', 1, '你好', [2, 'World'], 'test']

    (2)list.pop(i)删除第i个成员,并可将删除的数据赋值给变量

    tl = [1, 'Hello', 1, "你好", [2, 'World']]

    print(tl)

    a = tl.pop(3)

    print(tl)

    print(a)

    输出:

    [1, 'Hello', 1, '你好', [2, 'World']]

    [1, 'Hello', 1, [2, 'World']]

    你好

    (3)list.remove(s)直接删除值为s的成员,如果该值有多个只删除第一个,注意与pop的区别

    tl = [1, 'Hello', 1, "你好", [2, 'World']]

    print(tl)

    tl.remove("你好")

    print(tl)

    输出:

    [1, 'Hello', 1, '你好', [2, 'World']]

    [1, 'Hello', 1, [2, 'World']]

    (4)list.index(x)获得参数x在列表中的位置

    tl = [1, 'Hello', 1, "你好", [2, 'World']]

    print(tl.index([2, 'World']))

    输出:

    4

    (5)list.insert(a,b)向列表中的a位置插入数据b

    tl = [1, 'Hello', 1, "你好", [2, 'World']]

    tl.insert(2, '位置二')

    print(tl)

    输出:

    [1, 'Hello', '位置二', 1, '你好', [2, 'World']]

    (6)list.copy()拷贝列表,两者互相独立

    tx = [1, 'Hello', 1, "你好", [2, 'World']]

    ty = tx.copy()

    print(tx)

    print(ty)

    tx.pop(4)

    print(tx)

    print(ty)

    输出:

    [1, 'Hello', 1, '你好', [2, 'World']]

    [1, 'Hello', 1, '你好', [2, 'World']]

    [1, 'Hello', 1, '你好']

    [1, 'Hello', 1, '你好', [2, 'World']]

    (7)list.extend(L)向列表中追加另一个列表L

    tx = [1, 'Hello', 1, "你好", [2, 'World']]

    ty = [9, 8, 7, 6]

    tx.extend(ty)

    print(tx)

    输出:

    [1, 'Hello', 1, '你好', [2, 'World'], 9, 8, 7, 6]

    (8)list.count(y)计算列表中参数y出现的次数,想知道列表长度可以用len(L)

    ty = [9, 8, 7, 6, 8]

    print(ty.count(8))

    输出:

    2

    (9)list.sort()将列表中的成员排序,前提是成员数据类型一致

    tx = ['1', 'Hello', '1', "你好"]

    ty = [9, 8, 7, 6, 8]

    ty.sort()

    print(ty)

    tx.sort()

    print(tx)

    输出:

    [6, 7, 8, 8, 9]

    ['1', '1', 'Hello', '你好']

    (10)list.reverse()将列表中成员的顺序颠倒

    (11)list.clear()将列表清空

    2.元组

    元组是以圆括号“()”包围的数据集合,不同成员以“,”分隔。

    元组的特点:有序,数据不可变,数据可重复,数据类型可不同,可嵌套。元组通常在需要一组安全稳定的值的时候使用。

    元组和列表的区别除了语法就只有一个:数据不可变,也正是这个特点导致元组没有操作数据的方法,比列表要掌握的东西少得多。

    (1)tuple.index(x)获得参数x在列表中的位置

    (2)tuple.count(y)计算列表中参数y出现的次数

    3.字典

    字典是以大括号“{}”包围的数据集合,成员内部用“:”分隔,不同成员以“,”分隔。

    元组的特点:无序,数据可变,键不可重复,数据类型可不同,可嵌套。通过键来访问成员。

    创建一个字典:td = {'k': 'v', 'g': 'd'},下面我们看一下字典的常用操作:

    (1)dict.get('k') 获取键为'k'的值

    (2)dict.copy() 拷贝字典,两者互相独立

    (3)dict.pop('k') 删除键为'k'的值,并可将删除的值赋值给变量

    (4)dict.popitem() 随机删除一对键值,并可将删除的键值赋给变量,注意此时变量的类型将变成元组

    td = {'k': 'v', 'g': 'd'}

    print(td)

    x = td.popitem()

    print(td)

    print(x, type(x))

    输出:

    {'g': 'd', 'k': 'v'}

    {'k': 'v'}

    ('g', 'd')

    (5)dict.values() 获取字典中所有的“值”

    td = {'k': 'v', 'g': 'd'}

    print(td)

    x = td.values()

    for i in x:

    print(i)

    输出:

    {'g': 'd', 'k': 'v'}

    d

    v

    (6)dict.keys() 获取字典中所有的“键”

    (7)dict.items() 获取字典的所有键值对,以元组返回

    td = {'k': 'v', 'g': 'd'}

    print(td)

    x = td.items()

    for i in x:

    print(i)

    输出:

    {'g': 'd', 'k': 'v'}

    ('g', 'd')

    ('k', 'v')

    (8)dict.fromkeys(seq[,value]))  用于创建一个新字典,以序列seq中元素做字典的键,value为字典所有键对应的初始值。

    a = ('d', 'g', 's')

    b = {}

    b = b.fromkeys(a, 'test')

    print(a, b)

    td = {'k': 'v', 'g': 'd'}

    print(td)

    x = td.fromkeys('k')

    print(x)

    y = td.fromkeys(td.values(), 1000)

    print(y)

    输出:

    ('d', 'g', 's') {'s': 'test', 'd': 'test', 'g': 'test'}

    {'g': 'd', 'k': 'v'}

    {'k': None}

    {'v': 1000, 'd': 1000}

    (9)dict.setdefault('k','v')   和get()方法类似, 如果键不存在于字典中,将会添加键并将值设为默认值。

    dict = {'Name': 'Zara', 'Age': 7}

    print("Value : %s" % dict.setdefault('Age', 10))

    print("Value : %s" % dict.setdefault('Sex', 'f'))

    print(dict)

    输出:

    Value : 7

    Value : f

    {'Name': 'Zara', 'Sex': 'f', 'Age': 7}

    (10)dict.update(dict2) 函数把字典dict2的键/值对更新到dict里,即dict2中的成员是一定会保留的。

    dict1 = {'Name': 'Zara', 'Age': 7}

    dict2 = {'Sex': 'female', 'Age': 11}

    dict1.update(dict2)

    print("Value : %s" % dict1)

    输出:

    Value : {'Sex': 'female', 'Age': 11, 'Name': 'Zara'}

    (11)dict.clear() 清空

    4.集合

    集合的特点:无序,数据可变,数据不可重复,数据类型可不同,不可嵌套。集合最好的应用是去重和关系操作(交集、并集等)。集合没有特殊的表示方法,而是通过一个set函数转换成集合。

    创建一个字典:t = set("Hello"):

    a = set('asdsf')

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    print(a)

    print(b)

    输出:

    {'d', 's', 'f', 'a'}

    {'xx', 5, 7, 8, 10, 'asdf'}

    可以看到将一个字符串转换为集合,会把字符串每个字符分开,最终成为一个集合。

    下面我们看一下字典的常用操作:

    (1)set.add(x) 添加x元素到集合。

    a = set(['asdsf', 10])

    a.add('iis')

    print(a)

    输出:

    {'iis', 'asdsf', 10}

    (2)set.remove(y)  删除集合中的y元素,如果y不存在会报错

    a = set(['asdsf', 10])

    a.remove('asdsf')

    print(a)

    输出:

    {10}

    (3)set.discard(x)  删除集合中的x元素,如果x不存在,不会报错,注意和remove的区别

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    b.discard(9)

    print(b)

    输出:

    {5, 7, 8, 10, 'asdf', 'xx'}

    (4)set.pop()  随机删除一个集合元素,可将删除的元素赋值给变量

    a = set(['asdsf', 10])

    x = a.pop()

    print(a)

    print(x)

    输出:    #注意:删除是随机的,多执行几次结果会有变化

    {'asdsf'}

    10

    (5)set.copy() 拷贝一个集合

    a = set(['asdsf', 10])

    x = a.copy()

    print(a)

    print(x)

    a.remove(10)

    print(a, x)

    x.remove('asdsf')

    print(a, x)

    输出:

    {10, 'asdsf'}

    {10, 'asdsf'}

    {'asdsf'} {10, 'asdsf'}

    {'asdsf'} {10}

    可见,对两个集合的操作互不影响

    (6)set.union()和set.update()  将两个集合取并集,这两个方法效果一样,但是union字面意思好理解一些。

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    a = ['kk','vv']

    b.update(a)

    print(b)

    b.union(a)

    print(b)

    输出:

    {'asdf', 5, 7, 8, 10, 'vv', 'xx', 'kk'}

    {'asdf', 5, 7, 8, 10, 'vv', 'xx', 'kk'}

    (7)set.intersection()  将两个集合取交集。

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    xx = b.intersection(s)

    print(xx)

    输出:

    {10, 'asdf', 5}

    (8)b.intersection_update(s)  将两个集合取交集,并将所取的交集覆盖到集合b中

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    b.intersection_update(s)

    print(b)

    输出:

    {10, 'asdf', 5}

    (9)yy = b.difference(s)  将b中存在但s中不存在的元素放到集合yy中

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    yy = b.difference(s)

    print(yy)

    输出:

    {8, 'xx', 7}

    (10)b.difference_update(s)  将b中存在但s中不存在的元素覆盖到集合b中

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    b.difference_update(s)

    print(b)

    输出:

    {'xx', 7, 8}

    (11)b.issunset(s)  判断b是不是s的子集

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([5, 10, 'asdf'])

    x = b.issubset(s)

    y = s.issubset(b)

    print(x)

    print(y)

    输出:

    True

    False

    (12)set.issuperset()  和上一个相反,判断超集

    (13)x = s.isdisjoint(b)  判断s和b没有交集,没有返回True,有返回False。

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([6, 10, 'asdf'])

    c = set([6, 8, 0])

    x = s.isdisjoint(b)

    y = s.isdisjoint(c)

    print(x)

    print(y)

    输出:

    False

    True

    (14)x = s.symmetric_difference(b)   将s和b两个集合的非重复项合并为一个新的集合。

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([6, 10, 'asdf'])

    x = s.symmetric_difference(b)

    print(x)

    输出:

    {3, 5, 6, 'asdsf', 9}

    (15)s.symmetric_difference_update(b)   将s和b两个集合的非重复项合并为一个新的集合并赋值给s。

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([6, 10, 'asdf'])

    s.symmetric_difference_update(b)

    print(s)

    输出:

    {3, 5, 6, 'asdsf', 9}

    展开全文
  • 列表及方法列表是python内置的数据结构或者说是类型之一,可以包含各种数据类型作为元素.有点类似于C语言里的链表.列表变量是一个引用,还好学过C语言,所以要注意,对于引用的修改就是用指针操作,会直接修改原本的列表...

    列表及方法

    列表是python内置的数据结构或者说是类型之一,可以包含各种数据类型作为元素.有点类似于C语言里的链表.

    列表变量是一个引用,还好学过C语言,所以要注意,对于引用的修改就是用指针操作,会直接修改原本的列表对象,只有部分方法是不修改的.

    list()用来转换列表,另外列表还有列表生成式,是非常灵活的写法,也是很python的写法.

    除了正常的切片,索引,通过赋值修改某个位置的元素,in 等内置方法,还有list类的方法:

    append(p_object)

    列表尾部追加一个元素.修改对象.返回None.

    clear()

    删除列表里的所有元素,返回空列表,直接修改对象,返回None.

    copy()

    赋给一个新变量则得到当前列表的复制,是一个新列表,引用和原来的列表不同.注意这个方法得到的是浅拷贝

    count(value)

    返回value在列表元素中出现的整型次数,不修改原列表

    extend(iterable)

    将一个可迭代对象iterable里的元素增加到列表里.例如b.extend(range(10,21)),本身返回None

    index(value, start=None, stop=None)

    查找值返回索引整型,如果没有会报ValueError

    insert(index, p_object)

    在指定的索引位置插入元素,该索引位置上的原来元素及后边元素向后移动

    pop(index=None)

    弹出某一个索引的元素,返回这个元素,同时将这个元素从原列表里删除,如果不指定索引,则默认弹出最后一个.如果列表为空则报IndexError

    remove(value)

    从列表里去掉查到到的第一个value,如果找不到value,会报ValueError.如果成功去除,返回None.Python删除列表内的元素还可以用del li[index]或者del 切片的方法

    reverse()

    就地倒转列表顺序,直接修改原列表

    sort(key=None, reverse=False)

    就地排序,直接修改原列表,key可以用一个函数或者lambda表达式来做判断,reverse默认是升序,如果是True则降序.内置函数有一个sorted()函数也可以用来排序,但是sorted函数不会修改原列表

    直接赋值 浅拷贝 深拷贝

    直接赋值:其实就是对象的引用(别名)。

    浅拷贝(copy):拷贝父对象,不会拷贝对象的内部的子对象。

    深拷贝(deepcopy):如果需要深拷贝,导入copy模块的deepcopy方法,完全拷贝了父对象及其子对象。

    元组

    元组的类是tuple,元组一般用来传递一组固定结构的数据,可以方便的拆解到变量里使用.

    元组其实是对列表的二次加工,主要的区别就是元素不可被修改,也不能增加或者删除元素.

    用tuple()来生成元组,tuple(iterable)将迭代器的内容拿到一个元组里.

    注意,写元组的时候,一般要在最后一个元组后边加一个逗号,就可以很清楚的看到是元组.这是惯例.

    元组支持索引和切片,切片得到的结果还是一个元组.元组也是一个可迭代对象.

    字符串和列表,元组都可以转换.元组也支持.join方法.

    元组的一级元素不能够被修改,但是一级元素如果是引用,则可以修改元素的内容.就类似于元组是一排玻璃杯,这些玻璃杯不能更换,但是玻璃杯里装多少水,是可以修改的.

    count(self, value)

    count方法,返回次数

    index(value, start=None, stop=None)

    查找值返回索引整型,如果没有会报ValueError

    字典

    字典就是python语言的哈希表,拥有键值对,键key必须是一个可以hash的值,所以列表不能够作为key,字典也不能够作为key,因为这二者都会产生变化.值则没有限制,可以是任何对象.

    字典支持for 循环,但是默认是循环key,in 方法的默认也是判断key.字典是无序的,字典值的索引就是键.

    字典的方法:

    clear()

    返回None,清除整个字典

    copy()

    复制字典,注意这个也是浅复制

    fromkeys(*args, **kwargs)

    这个因为有@staticmethod,这是一个静态方法,也就是通过类名调用的方法,这个方法的内容是用给定的克迭代对象和对应的值来产生一个字典,在下边有示例

    get(k, d=None)

    字典可以直接用key来获得值,但是如果key不存在的话会报错.这时候可以用get方法来取得k对应的值,如果键中没有k,则会返回d,d默认是None,可以自行指定.get函数通常用在结合键值是否在字典内和需要返回一个特殊东西时候的场合

    items()

    返回这个字典里所有的键值对,类似一个集合.很python的写法就是用两个变量来同时接收键和值

    keys()

    返回字典里的所有的key构成的一个类似集合的对象,对迭代器的操作都可以用在返回对象上

    pop(k, d=None)

    按照键k对应的值从字典里弹出.如果找不到k,则返回d,如果d没有指定,则返回KeyError

    popitem()

    从字典里弹出一个键值对,无法控制先弹哪一个,返回的是一个键值对构成的元组.如果字典已经为空,则返回KeyError错误

    setdefault(k, d=None)

    将字典里k的值设置为d.但是如果k已经存在,则不做任何修改.两种情况都返回k对应的值.

    update(E=None, **F)

    更新列表,返回None.更新的机制是可以用k=v来当参数,也可以传一个字典,如果键已经存在,则更新值,否则将键值对更新到字典内.

    values()

    返回字典里所有值构成的一个类似于元组的东西.可以使用迭代器操作.

    用静态方法生成字典

    # 用dict类的静态方法生成字典

    v = dict.fromkeys([1, 2, 3, 4, 5, ], 'test')

    print(v)

    # 结果:

    # {1: 'test', 2: 'test', 3: 'test', 4: 'test', 5: 'test'}

    enumerate的用法

    # enumerate(iterable[, start]),前边是一个可迭代对象,后边是指定开始的索引.

    # enumerate返回一个生成器,给原来迭代器中的每个对象,返回一个(索引,对象)的元组.

    v = dict.fromkeys([1, 2, 3, 4, 5, ], 'test')

    for i in enumerate(v.items(), 99):

    print(type(i), i)

    # 结果:

    # (99, (1, 'test'))

    # (100, (2, 'test'))

    # (101, (3, 'test'))

    # (102, (4, 'test'))

    # (103, (5, 'test'))

    练习

    # 有一个列表 nums = [2,7,11,15,1,8,7],找到列表中任意两个元素相加等于9的元素集合,如[(0,1),(4,5)]

    nums = [2, 7, 11, 15, 1, 8, 7]

    idx = 0

    ls = []

    for i in nums:

    if idx + 1 == len(nums):

    break

    else:

    for j in range(idx + 1, len(nums)):

    if i + nums[j] == 9:

    ls.append((i, nums[j]))

    idx += 1

    print(ls)

    *集合:

    由不同的元素组成,即集合内不能有重复的元素.集合内的元素是无序排列,而且是可哈希的值,也就是不可变类型.这些元素也可以作为字典的key.

    集合的定义,用大括号{}

    直接定义集合用大括号 set_a = {1,2,3,4,5} 集合在生成的过程中会自动去除重复元素.集合无序所以也不支持索引.

    还可以采用set函数生成集合,如果是列表或者元组,会将其中每个元素拆开,如果是字符串,会将每个字符拆开.

    set函数如果对字典使用,只会生成包含键的集合,对列表使用,则列表的元素不能有不可哈希的元素.

    集合的内置方法:

    add(item)

    向集合内增加一个元素,add只接受一个参数

    clear()

    清空集合

    copy()

    这个也是浅复制

    pop()

    弹出集合中的一个元素,如果集合为空,返回KeyError.这个是随机删除.

    remove(item)

    指定删除,参数必须是集合内的元素,如果不存在,返回KeyError

    discard(item)

    指定删除,参数必须是集合内的元素,如果不存在,不做任何事情,也不报错.返回None

    集合的逻辑关系运算

    上边的是单体集合操作的方法,集合主要的用途是进行逻辑判断:

    集合的逻辑运算符有:

    in

    not in

    ==

    !=

    >,>=

    |,|= 合集

    &,&= 交集

    -,-= 差集

    ,=交叉补集

    上边的这些运算,集合也都有方法,详细如下:

    intersection(anotherset)

    求自身和另外一个集合anotherset的交集,符号是&

    union(anotherset)

    求自身和另外一个集合的并集,符号是|

    difference(anotherset)

    求差集,存在于原集合但不存在参数集合的结果.注意差集交换集合的顺序,结果是不同的.符号是-

    symmetric_difference(anotherset)

    交叉补集,首先把两者合并到一起,然后减去两者共有的部分,相当于并集-交集.符号是^

    difference_update(anotherset)

    把属于anotherset里的元素直接从当前集合中去掉.这些带有update的方法都是直接更新调用方法的集合.那些不带update的方法,如果要接受更改之后的集合,需要用另外一个参数去接收,或者用|=这种符号.

    intersection_update(anotherset)

    取交集,然后赋给调用方法的变量,即操作完毕之后,原集合变为交集.

    isdisjoint(s)

    如果两个集合没有交集,返回True,否则返回False

    issubset(s)

    如果s包含当前集合,则返回True,否则返回False.就是看当前集合是否是s的子集,相当于<=

    issuperset(s)

    如果s是当前集合的子集,返回True,否则返回False.相当于>=

    symmetric_difference_update(s)

    update系列方法

    update(s)

    单独的update方法就是用并集更新调用方法的集合.没有union_update方法.另外update可以传可迭代对象,可以将可迭代对象拆解后更新多个值进当前集合.而add只能添加一个值,给add传可迭代对象,会将可迭代对象作为单个元素传进去.

    集合关系运算例子

    # 集合的关系运算

    a = {1, 2, 3, 4, 5, 'a', 'b', 'c'}

    b = {3, 4, 5, 'b', 'c', 'd', 'e'}

    c = {'f','z',32,421}

    d = {'f'}

    print(a.intersection(b))

    print(a | b)

    print(a.union(b))

    print(a-b)

    print(a.difference(b))

    print(b-a)

    print(b.difference(a))

    print(a^b)

    print(a.symmetric_difference(b))

    集合还可以用frozenset()定义不可变集合.这个集合不可修改,除了没有增删改的方法之外,其他方法和关系运算与普通列表一致.IDE里也可以通过ctrl查看frozenset类.

    展开全文
  • python系列之:列表元组集合、字典的区别一、列表元组集合、字典的区别二、for循环遍历列表元组、字典和集合1.遍历列表2.遍历元组3.遍历字典4.遍历集合三、列表元组集合和字典相互转换1.列表元组转化...
  • python中的列表和元组都有哪些区别

    千次阅读 2021-01-15 01:09:05
    列表(list)和元组(tuple)的一些基础listtuple都是一个可以放置任意数据类型的有序集合,都是既可以存放数字、字符串、对象等listtuple都支持负索引In [8]: nums[-2]Out[8]: 'ad'In [9]: tp[-2]Out[9]: '33'list...
  • 列表(有序)添加list.append(元素):在列表末尾添加新的元素list.extend(seq):在列表末尾一次性追加另一个序列中的多个值–seq可以是列表元组、字典,若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾。...
  • python元组和集合的区别

    千次阅读 2021-01-14 04:08:59
    元组和列表是类似的, 只是元组修改内容 注意这里指的是不修改元组元素的指向, 你可以修改内容指向的内容 >>> lst = [1, 2, 3] # 定义列表>>> a = (1, 2, lst, 4) # 注意元组a的a[2]是一个...
  • 只有元组属于不变类型,因此它没有增删查改操作,其余列表、字典和集合都属于变对象。集合和字典不支持索引、切片、相加相乘操作。1. 序列共同特点在 Python 中,序列类型包括字符串、列表元组集合和字典...
  • 本篇文章给大家带来的内容是python中什么是元组和集合 ?...因为列表变的,而元组是不变的。比如我们经常需要传入函数的数据是不变的,这时就要用到元组了。def info(a):a[0] = 'haha'return aa = [1,2...
  • 1、元组元素可以为:元组列表...tips:列表作为元组元素时,列表内的值是可以进行改动的 2、列表元素可以为:元组列表集合 3、字典的元素可以为:元组列表、字典、集合 4、集合元素可以为:元组 ...
  • 本篇主要介绍Python里的数据结构,包括列表元组、字典、集合、字符串的使用,学习这些序列的方法以及性质。
  • 列表中的元素可以是任意类型,甚至是列表类型,也就是说列表可以嵌套 4.变的序列 支持索引、切片、合并、删除等等操作,它们都是在原处进行修改列表 5.对象引用数组 列表可以当成普通的数组,每当用到引用时,...
  • 列表序列是Python中最基本的数据结构。...Python有6个序列的内置类型,但最常见的是列表和元组。序列都可以进行的操作包括索引,切片,加,乘,检查成员。此外,Python已经内置确定序列的长度以及确...
  • python中的元组和集合

    千次阅读 2020-11-30 07:21:04
    一、元组元组的属性:有序不改,可以通过下标获取元素1、元祖命名可以用(),只有一个元素的时候要加逗号L3=()L2=(1,)L1=(1)print(type(L3))print(type(L2))print(type(L1))2、有序可以通过下标获取元素,且可以循环...
  • 列表名.extend(添加的元素)(与apend的区别是在添加多个元素时,append是将添加的多个元素作为一个整体加进去,extend是整合成一个新的列表)insert():插入,在列表的任意索引处插入元素列表名.inser...
  • 前言: Python面试时,面试官必会问这个问题,列表元组、字典、集合之间的区分。 那么我就来简单总结一下。
  • 在某种程度上,元组在索引,嵌套对象重复方面与列表相似,但是与列表不同,元组是不变的。 Set: Set是迭代,变且没有重复元素的无序集合数据类型。Python的集合类表示集合的数学概念。 字典: 在Python...
  • 变长度,异构以及任意嵌套列表中的元素可以是任意类型,甚至是列表类型,也就是说列表可以嵌套4.变的序列支持索引、切片、合并、删除等等操作,它们都是在原处进行修改列表5.对象引用数组列表可以当成普通的数.....
  • 列表元组集合、字典是python中常见得数据类型,其各自的特点如下: 1. 列表 list: (1)用方括号[ ],例如,[ 1, 2, 3 ] 或者[ ‘a’, ‘b’, ‘c’ , ‘d’ ]。 (2)索引也要用方括号[ ],不用圆括号...
  • 字典 字典是另一种变容器模型,且存储任意类型对象。...#值可以取任何数据类型,但键必须是不变的,如字符串,数字或元组。 一个简单的字典实例: dict2 = { ‘abc’: 123, 98.6: 37 } 访问字
  • Python内置函数()可以返回列表元组、字典、集合、字符串以及range对象中元素个数.青岛远洋运输有限公司冷聚吉船长被评为全国十佳海员。()A:错B:对有源逆变是将直流电逆变成其它频率的交流电供负载使用。A:对B:错被...
  • 文章目录列表列表更新元素列表增加元素列表删除元素列表的其他操作元组删除元组元组的其他操作字典字典删除元素字典的其他操作集合集合添加元素集合删除元素其他操作 列表 创建一个列表,只要把逗号分隔的不同的数据...
  • 列表元组,字典,集合的特点

    千次阅读 2020-10-22 20:40:33
    列表元组: 字典: 集合
  • 通过这两篇的讲解(《列表和元组一》、《列表和元组二》),我们知道了:元组列表更加轻量级一些,所以在总体上,元组的性能速度要优于列表。而且,Python在后台,会对静态数据做一些资源缓存(resource caching)。...
  • Python:列表元组,字典,集合

    千次阅读 2019-03-26 17:38:39
    1,列表元组,字典,集合 1.1,概念 列表(list):是长度变有序的数据存储器,通过下标索引取到相应的数据。 元组(tuple):固定长度不变的顺序容器,访问效率高,适合存储一些长常量数据,可以作为...
  • 列表#coding=gbk#元组和列表不要求所含元素种类相同#元组不可变,列表可变#列表#使用[]list()创建列表test=['a','b']print(test)test.append('c')print(test)test2=list()test2.append("test2'str")#使用extend()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,059
精华内容 19,223
关键字:

列表和元组可作为集合的元素