精华内容
下载资源
问答
  • 你有一个误解,hash算法针对元素的内容,并不是针对指针,所以指针不变不等于可hash。如果你想深究细节话,可以看tuple源码:static Py_hash_ttuplehash(PyTupleObject *v){Py_uhash_t x; /* Unsigned for ...

    你有一个误解,hash算法针对的是元素的内容,并不是针对指针,所以指针不变不等于可hash。

    如果你想深究细节的话,可以看tuple的源码:

    static Py_hash_t

    tuplehash(PyTupleObject *v)

    {

    Py_uhash_t x; /* Unsigned for defined overflow behavior. */

    Py_hash_t y;

    Py_ssize_t len = Py_SIZE(v);

    PyObject **p;

    Py_uhash_t mult = _PyHASH_MULTIPLIER;

    x = 0x345678UL;

    p = v->ob_item;

    while (--len >= 0) {

    y = PyObject_Hash(*p++);

    if (y == -1)

    return -1;

    x = (x ^ y) * mult;

    /* the cast might truncate len; that doesn"t change hash stability */

    mult += (Py_hash_t)(82520UL + len + len);

    }

    x += 97531UL;

    if (x == (Py_uhash_t)-1)

    x = -2;

    return x;

    }

    注意这里有一个循环,tuple会对其中每个元素调用PyObject_Hash,将结果进行异或运算再加上一个常量作为整个tuple的hash。

    如果tuple中有一个元素是list,那么PyObject_Hash将调用list的hash算法,然而list定义就表明它根本不实现hash:

    PyTypeObject PyList_Type = {

    PyVarObject_HEAD_INIT(&PyType_Type, 0)

    "list",

    sizeof(PyListObject),

    0,

    (destructor)list_dealloc, /* tp_dealloc */

    0, /* tp_print */

    0, /* tp_getattr */

    0, /* tp_setattr */

    0, /* tp_reserved */

    (reprfunc)list_repr, /* tp_repr */

    0, /* tp_as_number */

    &list_as_sequence, /* tp_as_sequence */

    &list_as_mapping, /* tp_as_mapping */

    PyObject_HashNotImplemented, /* tp_hash */

    ...

    再看 PyObject_HashNotImplemented 的实现:

    Py_hash_t

    PyObject_HashNotImplemented(PyObject *v)

    {

    PyErr_Format(PyExc_TypeError, "unhashable type: "%.200s"",

    Py_TYPE(v)->tp_name);

    return -1;

    }

    这个信息很眼熟吧?

    结论就是,只要tuple中有一个元素是不可hash的(不限于list),那么整个tuple都是不可hash的。

    展开全文
  • 我们今天所要讲的在python集合,添加元素的两种方法就可以这样理解。一个是整体加入,另一个是拆分加入,下面我们一起看看具体的使用吧。 集合的添加有两种方式,分别是add和update。但是它们在添加元素时是由区别...
  • Python中有四种内建数据结构——列表、元组和字典,集合。我们将会学习如何使用它们,以及它们如何使编程变得简单 一、列表list 是处理一组有序项目数据结构,即你可以在一个列表中存储一个 序列 ...

    数据结构基本上就是——它们是可以处理一些 数据 的 结构 。或者说,它们是用来存储一组相关数据的。

     

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

     

     

     

    一、列表list
     

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

     

    而在Python中,你在每个项目之间用逗号分割。列表中的项目应该包括在方括号中,这样Python就知道你是在指明一个列表。

     

    一旦你创建了一个列表,你可以添加、删除或是搜索列表中的项目。由于你可以增加或删除项目,我们说列表是 可变的 数据类型,即这种类型是可以被改变的

    # 购物清单
    shoplist = ['苹果', '芒果', '胡萝卜', '香蕉']
     

    基本操作
    print ('我有', len(shoplist),'个商品在我的购物清单.')
    print ('它们是:'), # 提示

    for item in shoplist:
        print(item)
    print ('我还买了大米.')

    shoplist.append('大米')
    print ('现在我的购物清单是', shoplist)
    # ['苹果', '芒果', '胡萝卜', '香蕉','大米']
    基本操作——增

    append 追加

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li.append('大米')
    print(li)
    # ['苹果', '芒果', '胡萝卜', '香蕉','大米']

    li.append(1)
    # ['苹果', '芒果', '胡萝卜', '香蕉','大米', 1]

    print(li.append('hello'))   
    #None:无返回值,li.append()只是一个方法、动作

    print(li)   
    # ['苹果', '芒果', '胡萝卜', '香蕉','大米', 1 , 'hello']
     

    insert 插入

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li.insert(3,'草莓')

    print(li)   
    # ['苹果', '芒果', '胡萝卜', '草莓', '香蕉']
     

    extend 追加到末尾

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li.extend('cc')
    print(li)
    # ['苹果', '芒果', '胡萝卜', '香蕉', 'c', 'c']

    li.extend([1,2,3])
    print(li)
    # ['苹果', '芒果', '胡萝卜', '香蕉', 'c', 'c', 123]

    li.extend(123) #报错:数字不能迭代
    print(li)   
    #TypeError: 'int' object is not iterable
    应用实例:

    连续输入员工姓名,输入Q/q退出并打印列表

    li = []
    while True:
        username = input("请输入要添加的员工姓名:")
        if username.strip().upper() == 'Q':
            break
        li.append(username)
        print(li)
    print(li)
    运行结果:

     

    列表——删
    remove:按照元素删除

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li.remove('芒果')
    print(li)  
    #  ['苹果', '胡萝卜', '香蕉']
    pop:按照索引删除——有返回值

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    name = li.pop(1)  #有返回值
    print(name,li)
    # 芒果 ['苹果', '胡萝卜', '香蕉']

    name = li.pop()  #不写索引则默认删除最后一个
    print(name,li)
    # 香蕉 ['苹果', '胡萝卜']
     clear: 清空

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li.clear()
    print(li)
    #[]
     

    del:删除

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    del li[2:]
    print(li)
    # ['苹果', '芒果']

    del li  #删除之后,已经不存在,打印报错
    print(li)
     #NameError: name 'li' is not defined
    循环删除

    li = [11,22,33,44,55]
    for i in range(len(li)):
        print(i)
        del li[0]
        print(li)


     

     

    列表——改
    li[索引] = ‘被修改的内容’

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li[0] = '火龙果'  #将索引为0的位置改为‘火龙果’
    print(li)
    # ['火龙果', '芒果', '胡萝卜', '香蕉']
     

    li[切片] = ‘被修改的内容’(迭代式:分成最小的元素,一个一个添加)

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li[0:2] = 'abcd' 
    # 将索引0-2替换为abcd,切片之后迭代处理

    print(li)
    // ['a', 'b', 'c', 'd', '胡萝卜', '香蕉']

    li[0:3]=['我','喜欢','吃','水果']
    print(li)
    // ['我', '喜欢', '吃', '水果', 'd', '胡萝卜', '香蕉'
     

    列表——查
    从头到尾 :for循环

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    for i in li:
        print(i)
    某一个:索引

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    print(li[1])    #芒果
    一段:切片

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    print(li[0:2])    #['苹果', '芒果', '胡萝卜']
    列表——嵌套
    li = ['苹果', '芒果', '胡萝卜', ['a','b','c'],'香蕉']
    print(li[2][1]) #萝
    li[3][0].upper() 
    #把列表中第四个元素列表的第一个元素变为大写

    print(li)
    # ['苹果', '芒果', '胡萝卜', ['a', 'b', 'c'], '香蕉']
    列表——循环打印
    #索引默认从零开始
    li = ['alex','taibai','wusir','egon']
    for i in li:
        print(li.index(i),i)
     
     
    #指定索引从100开始
    for index,i in enumerate(li,100):
        print(index,i)
    运行结果:
     
    其他常用操作
    split:字符串转换成列表 str--->list

    s = 'xcsd_cdc_eht_木木'
    print(s.split('_'))  
    // ['xcsd', 'cdc', 'eht', '木木']

    s1 = 'xc sdc dc eht曾 木木'
    print(s1.split(' '))    
    // ['xc', 'sdc', 'dc', 'eht曾', '木木']
     

    join:列表转换成字符串 list--->str

    join(可迭代对象iterable)   split

    可迭代对象iterable:list,str,元祖

    li = ['xcsd', 'cdc', 'eht', '木木']
    s = ''.join(li)
    print(s)  #xcsdcdceht木木
    s1 = '_'.join(li)
    print(s1)  #xcsd_cdc_eht_木木
    range:顾头不顾尾——相当于有序的数字列表(可以反向,加步长)

    for i in range(2,6):
        print(i)
        
    for i in range(3):   #从0开始,0可省略
    应用实例:

    循环打印,列表里遇到列表也需要循环打印

    li = [1,2,3,5,'alex',[2,3,4,5,'taibai'],'afds']
    for i in li:
        if type(i) == list:
            for n in i:
                print(n)
        else:
            print(i)
    运行结果:

     
    二、元祖
     

    元组和列表十分类似,只不过元组和字符串一样是 不可变的 即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。

    元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候,即被使用的元组的值不会改变

    tu1 = (1)
    tu2 = (1,)
    print(tu1,type(tu1))    #1 <class 'int'>
    print(tu2,type(tu2))    #(1,) <class 'tuple'>
    tu3 = ([1])
    tu4 = ([1],)
    print(tu3,type(tu3))    #[1] <class 'list'>
    print(tu4,type(tu4))    #([1],) <class 'tuple'>
    元组的基本操作
    tu = (1,2,3,'alex','egon')
    print(tu[2])    #3
    print(tu[0:2])  #(1, 2)
    for i in tu:
        print(i)    #循环打印元祖
     

    字典
    字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿,即,我们把键(名字)和值(详细情况)联系在一起。注意,键必须是唯一的,就像如果有两个人恰巧同名的话,你无法找到正确的信息。

    注意,你只能使用不可变的对象(比如字符串)来作为字典的键,但是你可以把不可变或可变的对象作为字典的值。

    基本说来就是,你应该只使用简单的对象作为键。

    键值对在字典中以这样的方式标记:d = {key1 : value1, key2 : value2 }。

    注意它们的键/值对用冒号分割,而各个对用逗号分割,所有这些都包括在花括号中


    dict
        key(键)必须是不可变数据类型,可哈希
        value(值)任意数据类型


    dict 优点:二分查找去查询
        存储大量的关系型数据
    特点:<=3.5版本无序,3.6以后都是有序

     

    1.字典— 增
    dic['键'] = 值

    dic1 = {'age':18,'name':'xc','sex':'female'}
    dic1['height'] = 165
    print(dic1) 
    # 没有键值对,增加
    # {'age': 18, 'name': 'xc', 'sex': 'female', 'height': 165}

    dic1['age'] = 21
    print(dic1) 
    #有键值对,则修改
    #{'age': 21, 'name': 'xc', 'sex': 'female', 'height': 165}

     

    setdefault 设置默认

    # dic1 = {'age':18,'name':'xc','sex':'female'}
    dic1.setdefault('weight',120)
    print(dic1)     
    # 没有键值对,增加
    # {'age': 18, 'name': 'xc', 'sex': 'female', 'weight': 120}

    dic1.setdefault('name','aa')
    print(dic1)      
    #有键值对,不做任何操作
    # {'age': 18, 'name': 'xc', 'sex': 'female', 'weight': 120}
    2. 字典—— 删
    删除优先使用pop(有返回值,要删除的内容不存在时不报错),而不是del

    pop 删除

    dic1 = {'age':18,'name':'xc','sex':'female'}
    print(dic1.pop('age'))  
    #有age直接删除---有返回值,按键删除

    print(dic1)     
    #18   {'name': 'xc', 'sex': 'female'}

    print(dic1.pop('erge','没有此键/None')) 
     #没有erge----可设置返回值:没有此键/None
     
    print(dic1)     
    #没有此键/None    {'name': 'xc', 'sex': 'female'}
    popitem 随机删除

    dic1 = {'age':18,'name':'xc','sex':'female'}
    print(dic1.popitem())  
    #('sex', 'female')
    #随机删除:有返回值-----返回元祖:删除的键值
     clear 清空

    dic1 = {'age':18,'name':'xc','sex':'female'}
    dic1.clear()    #清空字典
    print(dic1)     #{}
    del 删除

    dic1 = {'age':18,'name':'xc','sex':'female'}
    del dic1['name']   
    # 有,则删除
    # del dic1['name1']  #没有,则报错

    print(dic1)     
    #{'age': 18, 'sex': 'female'}
     

    3. 字典—— 改 
    update

    dic = {'age':18,'name':'xc','sex':'female'}
    dic2 = {'name':'alex','weight':'168'}
    dic2.update(dic)      
    #有则更新覆盖,没有则增加

    print(dic)  
    #{'age': 18, 'name': 'xc', 'sex': 'female'}

    print(dic2) 
    #{'name': 'xc', 'weight': '168', 'age': 18, 'sex': 'female'}
     

    4. 字典——查
    keys,values,items

    dic1 = {'age':18,'name':'xc','sex':'female'}

    print(dic1.keys(),type(dic1.keys()))    
    #键 dict_keys(['age', 'name', 'sex']) <class 'dict_keys'>

    print(dic1.values())    
    #值 dict_values([18, 'xc', 'female'])

    print(dic1.items())     
    #元祖 dict_items([('age', 18), ('name', 'xc'), ('sex', 'female')])
    得到键值,首选get

    print(dic1['name'])      #有则打印
    #print(dic1['name1'])    #没有则报错

    print(dic1.get('name'))  
    #有name直接输出---有返回值

    print(dic1.get('name1','没有此键'))  
    #没有name1----可设置返回值:没有此键/None
     

    循环输出

    for i in dic1:
        print(i)    #循环打印键(默认为键)
        
    for i in dic1.keys():
        print(i)    #循环打印键
        
    for i in dic1.values():
        print(i)    #循环打印值
        
    for i in dic1.items():
        print(i)    #循环打印键值对

    for k,v in dic1.items():
        print(k,v)    #打印键和值
    5. 字典的嵌套
    dic = {    'name':['alex','wusir','xinchen'],
        'py9':{
            'time':'1213',
            'study_fee':19800,
            'addr':'CBD',
        },
        'age':21
    }
    dic['age'] = 56 
    # 找到age,再更新为56
    print(dic)

    dic['name'].append('rt')    
    #找到name,在添加名字
    print(dic)

    dic['name'][1] = dic['name'][1].upper() 
    #找到name,再把wusir变为大写
    print(dic)

    dic['py9']['female'] = 6    
    #找到元祖,增加键值对female:6
    print(dic)
     

    应用实例:
    #输入一串字符,遇到字母,转换为‘_’,并打印输出

    info = input('请输入:')
    for i in info:
        if i.isalpha():
            info = info.replace(i,'_')
    print(info)
      运行结果:

     

    四、集合
    集合 类似于列表,但每个元素都必须是独一无二且不可变的:

    它是无序的

     

    基本操作
    print(set1)     
    #{1, 2, 3}

    set2 = {1,2,3,[2,3],{'name':'xc'}}  
    #列表是可变的(不可哈希),所以出错
    print(set2)     
    #TypeError: unhashable type: 'list'
    1. 集合——增 
    add
    set1 = {'alex','wusir','ritian','egon','barry'}
    # (1)add    #因为集合是无序的,所以每次运行结果不一定一样,增加的位置也不一定一样
    set1.add('nvshen')  
    #{'ritian', 'nvshen', 'egon', 'wusir', 'alex', 'barry'}
    print(set1)
    update

    set1.update('xc')   
    #迭代添加,依然是无序的
    print(set1) 
    #{'egon', 'x', 'wusir', 'nvshen', 'c', 'alex', 'ritian', 'barry'}
     

     

    2. 集合——删 
    set1 = {'alex','wusir','ritian','egon','barry'}
    pop--随机删除

    print(set1.pop())   
    #egon:有返回值,返回本次删除的内容

    print(set1)     
    #{'barry', 'alex', 'wusir', 'ritian'}
    remove——指定元素删除

    set1.remove('alex')
    print(set1)    
     #{'egon', 'wusir', 'barry', 'ritian'}
     
    clear——清空

    set1.clear()
    print(set1)     
    #空集合:set()
     

    del

    del set1        

    #删除之后集合不存在,报错
    print(set1)    
     #NameError: name 'set1' is not defined
    3.集合不能改
    集合是无序;

    集合中的元素是不可变数据类型

     

    4. 集合——查
    set1 = {'alex','wusir','ritian','egon','barry'}
    for i in set1:
        print(i)
       运行结果:

     

    5. 集合之间的操作
    set1 = {1,2,3,4,5}
    set2 = {4,5,6,7,8}
    交集

    print(set1 & set2)      
    #(1) {4, 5}

    print(set1.intersection(set2))      
    #(2) {4, 5}
     

    并集

    print(set1 | set2)          
    #(1) {1, 2, 3, 4, 5, 6, 7, 8}

    print(set1.union(set2))     
    #(2) {1, 2, 3, 4, 5, 6, 7, 8}
     
    反交集--除交集以外的其他元素

    print(set1 ^ set2)          
    #(1) {1, 2, 3, 6, 7, 8}

    print(set1.symmetric_difference(set2))     
    #(2) {1, 2, 3, 6, 7, 8}
    差集--前者独有的

    print(set1 - set2)              #(1) {1, 2, 3}
    print(set1.difference(set2))     #(2) {1, 2, 3}
    print(set2 - set1)              #(1) {8, 6, 7}
    print(set2.difference(set1))     #(2) {8, 6, 7}
     

    子集与超集

    set3 = {1,2,3,4,5}
    set4 = {1,2,3,4,5,6,7,8}
    print('------ set3是set4的子集 ------')
    print(set3 < set4)      #True
    print(set3.issubset(set4))   #True

    print('------ set4是set3的超集 ------')
    print(set4 > set3)      #True
    print(set4.issuperset(set3))   #True
     

    五、公共方法
    排序
    正向排序:sort()  

    li = [1,5,4,2,6,7,3]
    li.sort()
    print(li)   #[1, 2, 3, 4, 5, 6, 7]
    倒序排序:li.sort(reverse = True)

    li = [1,5,4,2,6,7,3]
    li.sort(reverse = True)
    print(li)   #[7, 6, 5, 4, 3, 2, 1]
    反转:li.reverse()

    li = [1,5,4,2,6,7,3]
    li.reverse()
    print(li)     #[3, 7, 6, 2, 4, 5, 1]
    补充:
    字符串列表排序——根据字符串的第一个字符对应的ASCII码排序

    li = ['ojhy','asa','cvd','hdk']
    li.sort()
    print(li)   #['asa', 'cvd', 'hdk', 'ojhy']
    count()  数元素出现的次数
    li = ['xcsd', 'cdc', '木木',[1, 5, 2], 'eht', '木木']
    num = li.count('木木')

    print(num)  #2:'木木'出现2次
    len()  计算列表的长度
    li = ['xcsd', 'cdc', '木木',[1, 5, 2], 'eht', '木木']
    l = len(li)
    print(l)   #6:列表长度为6
    li.index('元素')   查看索引
    li = ['xcsd', 'cdc', '辛辰',[1, 5, 2], 'eht', '辛辰']
    print(li.index('eht'))  
    #4:'eht'的索引为4元祖
     
    六. 区别与异同
         列表list    元组  tuple    集合 set     字典 dict
    可否读写     读写     只读    读写     读写
    可否重复    是    是    否    是
    存储方式    值    值    

    (不能重复)

    键值对

    (键不能重复)

    是否有序    有序    有序    无序    自动正序
    初始化    [1,'a']     ('a', 1)    
     set([1,2])
     或 {1,2}

     {'a':1,'b':2}
    添加      append     只读     add     d['key'] = 'value'
    读元素     l[2:]       t[0]     无       d['a']
     
    ————————————————
    版权声明:本文为CSDN博主「曾亲桂林」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/bigzql/article/details/108249658

    展开全文
  • python中集合的操作

    2017-10-15 20:25:19
    python set类是在python的sets模块,大家现在使用的python2.7.x,不需要导入sets模块可以直接创建集合。 >>>set('boy') set(['y', 'b', 'o']) 1、集合添加、删除 python 集合的添加有两种常用方法,...

    一、set


    python set类是在python的sets模块中,大家现在使用的python2.7.x中,不需要导入sets模块可以直接创建集合。

    >>>set('boy')

    set(['y', 'b', 'o'])


    1、集合添加、删除

    python 集合的添加有两种常用方法,分别是add和update。
    1)集合add方法:是把要传入的元素做为一个整个添加到集合中,例如:
    >>> a = set('boy')
    >>> a.add('python')
    >>> a
    set(['y', 'python', 'b', 'o'])


    2)集合update方法:是把要传入的元素拆分,做为个体传入到集合中,例如:
    >>> a = set('boy')
    >>> a.update('python')
    >>> a
    set(['b', 'h', 'o', 'n', 'p', 't', 'y'])


    2、集合删除操作方法:remove
    set(['y', 'python', 'b', 'o'])
    >>> a.remove('python')
    >>> a
    set(['y', 'b', 'o'])



    展开全文
  • python中集合的概念

    2020-12-13 11:53:27
    集合的概念 集合是由一组无序排列且不重复的元素组成,具体示例如下: 集合使用大括号表示,元素类型可以是数字类型、...集合的一个重要用途是将一些数据结构的重复元素去除,如例所示。 运行结果如图所示。 ...

    集合的概念

    集合是由一组无序排列且不重复的元素组成,具体示例如下:
    在这里插入图片描述
    集合使用大括号表示,元素类型可以是数字类型、字符串、元组,但不可以是列表、字典,具体示例如下:
    在这里插入图片描述
    使用大括号创建的集合属于可变集合,即可以添加或删除元素。此外,还存在一种不可变集合,即不允许添加或删除元素。

    接下来演示创建这两种集合的方法,如例所示。
    在这里插入图片描述
    集合的一个重要用途是将一些数据结构中的重复元素去除,如例所示。
    在这里插入图片描述
    运行结果如图所示。
    在这里插入图片描述

    展开全文
  • python中集合的使用以及特点1、应用一:去重 1、应用一:去重 python中集合的其中一种作用是去除字符串或者列表中的重复元素。这一功能是十分有用的。比如: 输出为: 光知道这些是不够的,使用集合去重的时候有几...
  • python中集合的总结

    2019-11-22 21:56:55
    集合内的元素必须是不可变对象; 集合是可迭代对象; 集合是相当于只有键没有值的字典(键则是集合的数据); 集合可以理解为是只有键没有值的字典。 一.创建集合 创建空的集合:set() 创建非空的集合的字面值: s = {1,...
  • Python中集合的用法

    2019-09-12 00:22:42
    文章目录一、集合的定义二、集合的示例三、集合的特性3.1成员操作符(判断元素是否在集合存在)3.2for循环四、集合的常用方法4.1 添加元素4.2 移除元素五、两个集合间的运算 一、集合的定义 集合(set)是一个...
  • 1 """ Python中集合的基本用法 """ 2 "集合是一个无序的不重复元素序列" 3 "创建集合可以使用{}或set(),【注】:创建一个空集合必须用set(),而不能用{},因为{}是用于创建空字典" 4 basket = {'apple', '...
  • 1.集合的创建 可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。 #集合里面的元素是不可重复的 s = {1,2,3,1,2,3,4,5} print(s) print...
  • 1.集合(set)的定义 集合(set)是一个无序的不重复元素序列 可以使用大括号 { } 或者 set( ) 函数创建...3.集合中的元素必须是不可变类型 2.集合的创建 集合里面的元素是不可重复的 s = {1,2,3,1,2,3,4,5}#创建一...
  • python中集合set使用

    2019-04-06 16:02:12
    集set 约定 set翻译为集合 collection翻译为集合类型,是一个大概念 set 是可变的、无序的、不重复的元素集合 ...-set中的元素要求必须可以hash list、set都不能hash 元素不可以使用索引,因为se...
  •  数学上,,把set称做由不同的元素组成的集合集合(set)的成员通常被称做集合元素(set elements)。Python把这个概念引入到它的集合类型对象里。集合对象是一组无序排列的可哈希的值,集合成员可以做字典的键...
  • python中的集合

    2019-07-15 16:31:58
    集合中的元素没有任何顺序 集合中可以使用整数,浮点数,布尔值,复数,字符串,元组,冰冻集合 集合操作 创建集合 创建空集合 变量 = set() 创建多个数据的集合 变量 = {值,值....} 注意:集合是唯一性数据,...
  • Python中的集合

    2018-09-06 11:52:36
    集合可以有任意数量的元素,它们可以是不同的类型(例如:数字、元组、字符串等)。但是,集合不能有可变元素(例如:列表、集合或字典) 3、定义一个空集合 4、集合的应用 # 给列表去重 二、集合的特性 ...
  • 集合有以下特点: 1、Python中的集合为无序的不能有重复元素的序列 ...以下是自己整理的Python中集合的用法。 1、集合的创建 集合可以直接使用{}创建,也可以使用函数set()。 # 1、创建集合 # 定义几个数据类型 ...
  • Python 中的集合操作

    2020-09-17 15:31:18
    集合(set)是一个无序不重复元素序列。 可以使用大括号{ }或者set()函数创建集合,注意:创建一个空集合必须用set()而不是{ },因为{ }是用来创建一个空字典。 创建格式: parame = {value01,value02,...} ...
  • 8、python中的集合

    2018-06-19 22:06:00
    集合是可变的数据结构指集合可以在创建以后对元素进行增删,集合的元素不可变是指元素本身是不可变的数据类型,比如数字、字符串、布尔值等(通常用字符串,就像字典的键一样),所以请把这两种说法分清楚...
  • python中的集合和字典

    2020-11-28 17:02:52
    python中的集合和字典 集合 集合(set)是一个无序不重复元素序列。可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。 创建格式: ...
  • 集合分为可变集合与不可变集合,可变集合创建用set()方法,例如:a=set((1,2,3,4,3))打印a时为{1,2,3,4}会自动去重,但是可变集合的元素可以用add,remove等方法更改;不可变集合顾名思义就是创建之后不能再改变,...
  • 列表不可以作为集合的元素. 集合可以作为列表的元素。 元组(tuple)(可哈希的数据类型)可以作为集合元素的。 集合可以作为元组的元素。 因为字典是可变的数据结构(不可哈希),所以自然也不能作为集合的元素。 ...
  • Python 集合元素及操作

    2020-05-04 21:56:41
    集合是多个元素的无序组合,每个元素唯一(可以用来对其他数据类型去重),且集合中的每一个元素都是不可变元素,例如整数、浮点数、元组等; 集合用{}表示,元素间用逗号分隔,建立一个集合可以用{}和set 例如 a={1...
  • Python集合

    2021-01-20 03:31:35
    集合不同于列表和元组类型,集合存储的元素是无序且不能重复的,同数学的集合一样,集合可以执行集合的并、交、差运算。 集合有两种不同的类型,可变集合和不可变集合,可变集合可以添加或删除元素,但可变集合所...
  • (1)标准类型操作符(所有的集合类型) 成员关系 (in, not in)  就序列而言,Python中的in和not in操作符决定某个元素是否是一个...集合等价/不等价与集合的类型或集合成员的顺序无关,只与集合的元素有关。 子集/超
  • python中的集合简介

    2018-09-06 20:44:29
    集合中的每个元素都是唯一   集合定义 set= {1, 1} 增 : add,update  add: 直接添加到集合中 -&gt;append  update:逐一添加到集合中 - &gt; extend 删: discard pop remove ...

空空如也

空空如也

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

python中集合的元素可以是

python 订阅