精华内容
下载资源
问答
  • python的set和其他语言类似, 一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算. sets ...

    参考链接: Python中set clear

    python的set和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.

     sets 支持 x in set, len(set),和 for x in set。作为一个无序的集合,sets不记录元素位置或者插入点。因此,sets不支持 indexing, slicing, 或其它类序列(sequence-like)的操作。

     下面来点简单的小例子说明把。

     >>> x = set('spam')

     >>> y = set(['h','a','m'])

     >>> x, y

     (set(['a', 'p', 's', 'm']), set(['a', 'h', 'm']))

     再来些小应用。

     >>> x & y # 交集

     set(['a', 'm'])

     >>> x | y # 并集

     set(['a', 'p', 's', 'h', 'm'])

     >>> x - y # 差集

     set(['p', 's'])

     记得以前个网友提问怎么去除海量列表里重复元素,用hash来解决也行,只不过感觉在性能上不是很高,用set解决还是很不错的,示例如下:

     >>> a = [11,22,33,44,11,22]

     >>> b = set(a)

     >>> b

     set([33, 11, 44, 22])

     >>> c = [i for i in b]

     >>> c

     [33, 11, 44, 22]

     很酷把,几行就可以搞定。

     1.8 集合

     集合用于包含一组无序的对象。要创建集合,可使用set()函数并像下面这样提供一系列的项:

     s = set([3,5,9,10])      #创建一个数值集合

     t = set("Hello")         #创建一个唯一字符的集合

     与列表和元组不同,集合是无序的,也无法通过数字进行索引。此外,集合中的元素不能重复。例如,如果检查前面代码中t集合的值,结果会是:

     >>> t

     set(['H', 'e', 'l', 'o'])

     注意只出现了一个'l'。

     集合支持一系列标准操作,包括并集、交集、差集和对称差集,例如:

     a = t | s          # t 和 s的并集

     b = t & s          # t 和 s的交集

     c = t – s          # 求差集(项在t中,但不在s中)

     d = t ^ s          # 对称差集(项在t或s中,但不会同时出现在二者中)

     基本操作:

     t.add('x')            # 添加一项

     s.update([10,37,42])  # 在s中添加多项

     使用remove()可以删除一项:

     t.remove('H')

     len(s)

     set 的长度

     x in s

     测试 x 是否是 s 的成员

     x not in s

     测试 x 是否不是 s 的成员

     s.issubset(t)

     s <= t

     测试是否 s 中的每一个元素都在 t 中

     s.issuperset(t)

     s >= t

     测试是否 t 中的每一个元素都在 s 中

     s.union(t)

     s | t

     返回一个新的 set 包含 s 和 t 中的每一个元素

     s.intersection(t)

     s & t

     返回一个新的 set 包含 s 和 t 中的公共元素

     s.difference(t)

     s - t

     返回一个新的 set 包含 s 中有但是 t 中没有的元素

     s.symmetric_difference(t)

     s ^ t

     返回一个新的 set 包含 s 和 t 中不重复的元素

     s.copy()

     返回 set “s”的一个浅复制

     请注意:union(), intersection(), difference() 和 symmetric_difference() 的非运算符(non-operator,就是形如 s.union()这样的)版本将会接受任何 iterable 作为参数。相反,它们的运算符版本(operator based counterparts)要求参数必须是 sets。这样可以避免潜在的错误,如:为了更可读而使用 set('abc') & 'cbs' 来替代 set('abc').intersection('cbs')。从 2.3.1 版本中做的更改:以前所有参数都必须是 sets。

     另外,Set 和 ImmutableSet 两者都支持 set 与 set 之间的比较。两个 sets 在也只有在这种情况下是相等的:每一个 set 中的元素都是另一个中的元素(二者互为subset)。一个 set 比另一个 set 小,只有在第一个 set 是第二个 set 的 subset 时(是一个 subset,但是并不相等)。一个 set 比另一个 set 打,只有在第一个 set 是第二个 set 的 superset 时(是一个 superset,但是并不相等)。

     子 set 和相等比较并不产生完整的排序功能。例如:任意两个 sets 都不相等也不互为子 set,因此以下的运算都会返回 False:ab。因此,sets 不提供 __cmp__ 方法。

     因为 sets 只定义了部分排序功能(subset 关系),list.sort() 方法的输出对于 sets 的列表没有定义。

     运算符

     运算结果

     hash(s)

     返回 s 的 hash 值

     下面这个表列出了对于 Set 可用二对于 ImmutableSet 不可用的运算:

     运算符(voperator)

     等价于

     运算结果

     s.update(t)

     s |= t

     返回增加了 set “t”中元素后的 set “s”

     s.intersection_update(t)

     s &= t

     返回只保留含有 set “t”中元素的 set “s”

     s.difference_update(t)

     s -= t

     返回删除了 set “t”中含有的元素后的 set “s”

     s.symmetric_difference_update(t)

     s ^= t

     返回含有 set “t”或者 set “s”中有而不是两者都有的元素的 set “s”

     s.add(x)

     向 set “s”中增加元素 x

     s.remove(x)

     从 set “s”中删除元素 x, 如果不存在则引发 KeyError

     s.discard(x)

     如果在 set “s”中存在元素 x, 则删除

     s.pop()

     删除并且返回 set “s”中的一个不确定的元素, 如果为空则引发 KeyError

     s.clear()

     删除 set “s”中的所有元素

     请注意:非运算符版本的 update(), intersection_update(), difference_update()和symmetric_difference_update()将会接受任意 iterable 作为参数。从 2.3.1 版本做的更改:以前所有参数都必须是 sets。

     还请注意:这个模块还包含一个 union_update() 方法,它是 update() 方法的一个别名。包含这个方法是为了向后兼容。程序员们应该多使用 update() 方法,因为这个方法也被内置的 set() 和 frozenset() 类型支持。

    展开全文
  • 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

    展开全文
  • 最后来看一个“可变的”tuple:&gt;&gt;&gt; t = ('a', 'b', ['A', 'B']) &gt;&gt;...这个tuple定义的时候有3个元素,分别'a','b'和一个list。不是说tuple一旦定义后就不...

    list列表元素可变方法

    append(' *')后面附加元素;

    insert(index,‘’)某个位置index添加个元素

    pop()删除末尾元素

    pop(index)删除指定位置index元素

    tuple元组不可变

    没有append(),insert()这样的方法

    最后来看一个“可变的”tuple:

    >>> t = ('a', 'b', ['A', 'B'])
    >>> t[2][0] = 'X'
    >>> t[2][1] = 'Y'
    >>> t
    ('a', 'b', ['X', 'Y'])
    

    这个tuple定义的时候有3个元素,分别是'a''b'和一个list。不是说tuple一旦定义后就不可变了吗?怎么后来又变了?

    别急,我们先看看定义的时候tuple包含的3个元素:

    tuple-0

    当我们把list的元素'A''B'修改为'X''Y'后,tuple变为:

    tuple-1

    表面上看,tuple的元素确实变了,但其实变的不是tuple的元素,而是list的元素。tuple一开始指向的list并没有改成别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向'a',就不能改成指向'b',指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!

    理解了“指向不变”后,要创建一个内容也不变的tuple怎么做?那就必须保证tuple的每一个元素本身也不能变。

    小结

    list和tuple是Python内置的有序集合,一个可变,一个不可变。根据需要来选择使用它们。

    展开全文
  • python 集合

    2019-11-22 16:35:44
    因为集合是无序的,所以当集合中存在两个同样的元素的时候,Python只会保存其中的一个(唯一性);同时为了确保其中不包含同样的元素集合中放入的元素只能不可变的对象(确定性)。 集合生成 可以用set()函数...

    集合

    之前看到的列表和字符串都是一种有序序列,而集合 set 是一种无序的序列。

    因为集合是无序的,所以当集合中存在两个同样的元素的时候,Python只会保存其中的一个(唯一性);同时为了确保其中不包含同样的元素,集合中放入的元素只能是不可变的对象(确定性)。

    集合生成

    可以用set()函数来显示的生成空集合:

    In [1]:

    a = set()
    type(a)
    

    Out[1]:

    set

    也可以使用一个列表来初始化一个集合:

    In [2]:

    a = set([1, 2, 3, 1])
    a
    

    Out[2]:

    {1, 2, 3}

    集合会自动去除重复元素 1

    可以看到,集合中的元素是用大括号{}包含起来的,这意味着可以用{}的形式来创建集合:

    In [3]:

    a = {1, 2, 3, 1}
    a
    

    Out[3]:

    {1, 2, 3}

    但是创建空集合的时候只能用set来创建,因为在Python中{}创建的是一个空的字典:

    In [4]:

    s = {}
    type(s)
    

    Out[4]:

    dict

    集合操作

    假设有这样两个集合:

    In [5]:

    a = {1, 2, 3, 4}
    b = {3, 4, 5, 6}
    

    两个集合的并,返回包含两个集合所有元素的集合(去除重复)。

    可以用方法 a.union(b) 或者操作 a | b 实现。

    In [6]:

    a.union(b)
    

    Out[6]:

    {1, 2, 3, 4, 5, 6}

    In [7]:

    b.union(a)
    

    Out[7]:

    {1, 2, 3, 4, 5, 6}

    In [8]:

    a | b
    

    Out[8]:

    {1, 2, 3, 4, 5, 6}

    两个集合的交,返回包含两个集合共有元素的集合。

    可以用方法 a.intersection(b) 或者操作 a & b 实现。

    In [9]:

    a.intersection(b)
    

    Out[9]:

    {3, 4}

    In [10]:

    b.intersection(a)
    

    Out[10]:

    {3, 4}

    In [11]:

    a & b
    

    Out[11]:

    {3, 4}

    In [12]:

    print(a & b)
    
    set([3, 4])
    

    注意:一般使用print打印set的结果与表示方法并不一致。

    a 和 b 的差集,返回只在 a 不在 b 的元素组成的集合。

    可以用方法 a.difference(b) 或者操作 a - b 实现。

    In [13]:

    a.difference(b)
    

    Out[13]:

    {1, 2}

    In [14]:

    a - b
    

    Out[14]:

    {1, 2}

    注意,a - b 与 b - a并不一样,b - a 返回的是返回 b 不在 a 的元素组成的集合:

    In [15]:

    b.difference(a)
    

    Out[15]:

    {5, 6}

    In [16]:

    b - a
    

    Out[16]:

    {5, 6}

    对称差

    a 和b 的对称差集,返回在 a 或在 b 中,但是不同时在 a 和 b 中的元素组成的集合。

    可以用方法 a.symmetric_difference(b) 或者操作 a ^ b 实现(异或操作符)。

    In [17]:

    a.symmetric_difference(b)
    

    Out[17]:

    {1, 2, 5, 6}

    In [18]:

    b.symmetric_difference(a)
    

    Out[18]:

    {1, 2, 5, 6}

    In [19]:

    a ^ b
    

    Out[19]:

    {1, 2, 5, 6}

    包含关系

    假设现在有这样两个集合:

    In [20]:

    a = {1, 2, 3}
    b = {1, 2}
    

    要判断 b 是不是 a 的子集,可以用 b.issubset(a) 方法,或者更简单的用操作 b <= a :

    In [21]:

    b.issubset(a)
    

    Out[21]:

    True

    In [22]:

    b <= a
    

    Out[22]:

    True

    与之对应,也可以用 a.issuperset(b) 或者 a >= b 来判断:

    In [23]:

    a.issuperset(b)
    

    Out[23]:

    True

    In [24]:

    a >= b
    

    Out[24]:

    True

    方法只能用来测试子集,但是操作符可以用来判断真子集:

    In [25]:

    a <= a
    

    Out[25]:

    True

    自己不是自己的真子集:

    In [26]:

    a < a
    

    Out[26]:

    False

    集合方法

    add 方法向集合添加单个元素

    跟列表的 append 方法类似,用来向集合添加单个元素。

    s.add(a)
    
    

    将元素 a 加入集合 s 中。

    In [27]:

    t = {1, 2, 3}
    t.add(5)
    t
    

    Out[27]:

    {1, 2, 3, 5}

    如果添加的是已有元素,集合不改变:

    In [28]:

    t.add(3)
    t
    

    Out[28]:

    {1, 2, 3, 5}

    update 方法向集合添加多个元素

    跟列表的extend方法类似,用来向集合添加多个元素。

    s.update(seq)
    
    

    seq中的元素添加到s中。

    In [29]:

    t.update([5, 6, 7])
    t
    

    Out[29]:

    {1, 2, 3, 5, 6, 7}

    remove 方法移除单个元素

    s.remove(ob)
    
    

    从集合s中移除元素ob,如果不存在会报错。

    In [30]:

    t.remove(1)
    t
    

    Out[30]:

    {2, 3, 5, 6, 7}

    In [31]:

    t.remove(10)
    
    ---------------------------------------------------------------------------
    KeyError                                  Traceback (most recent call last)
    <ipython-input-31-3bc25c5e1ff4> in <module>()
    ----> 1 t.remove(10)
    
    KeyError: 10

    pop方法弹出元素

    由于集合没有顺序,不能像列表一样按照位置弹出元素,所以pop 方法删除并返回集合中任意一个元素,如果集合中没有元素会报错。

    In [32]:

    t.pop()
    

    Out[32]:

    {3, 5, 6, 7}

    In [33]:

    print t
    
    set([3, 5, 6, 7])
    

    In [34]:

    s = set()
    # 报错
    s.pop()
    
    ---------------------------------------------------------------------------
    KeyError                                  Traceback (most recent call last)
    <ipython-input-34-9f9e06c962e6> in <module>()
          1 s = set()
          2 # 报错
    ----> 3 s.pop()
    
    KeyError: 'pop from an empty set'

    discard 方法

    作用与 remove 一样,但是当元素在集合中不存在的时候不会报错。

    In [35]:

    t.discard(3)
    

    In [36]:

    t
    

    Out[36]:

    {5, 6, 7}

    不存在的元素不会报错:

    In [37]:

    t.discard(20)
    

    In [38]:

    t
    

    Out[38]:

    {5, 6, 7}

    difference_update方法

    a.difference_update(b)
    
    

    从a中去除所有属于b的元素:

    展开全文
  • 如果某个成员已经是有序集的成员,那么更新这个成员的分数值,并通过重新插入这个成员元素,来保证该成员在正确的位置上。 分数值可以是整数值或双精度浮点数。 如果有序集合 key 不存在,则创建一个空的有序集并...
  • python集合

    2019-01-14 14:00:00
    因为集合是无序的,所以当集合中存在两个同样的元素的时候,Python只会保存其中的一个(唯一性);同时为了确保其中不包含同样的元素集合中放入的元素只能不可变的对象(确定性)。 集合生成 可以用set()函数来...
  • list一种有序的集合,可以随时添加和删除其中的元素。 比如,列出班里所有同学的名字,就可以用一个list表示: >>> classmates = ['Michael', 'Bob', 'Tracy'] >>> classmates ['Michael',....
  • 最近做的一个东西,需要用python从redis的有序集合中一次性删除多个值; redis的自带方法zrem支持此功能的 # 移除多个元素 redis> ZREM page_rank baidu.com bing.com (integer) 2 python redis 的api...
  • Python内置的一种数据类型列表:list:#注释list一种可变的有序的集合,可以随时添加和删除其中的元素 list里面的元素可以不同的数据类型譬如整数、字符串、嵌套列表 len( )函数:获得list元素的个数 ...
  • python中的列表一种有序数据的集合。其中的元素按照一定的顺序编号存放在存储空间当中,编号从0开始,最后一个编号为n-1,n表示列表中存储数据的数量。值得一提的,列表用方括号(square bracket)括起来,...
  • Python进阶(二)-初识Python数据元素:字典&时间

    万次阅读 多人点赞 2017-03-14 16:40:55
    列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。   字典由键和对应的值组成。字典也被称作关联数组或哈希表。基本语法如下:dict = {'...
  • list一种有序的集合,可以随时添加和删除其中的元素 我们列几个名字,用一个list来表示,举个例子: >>> list1=['张三','jack','李四'] >>> list1 ['张三', 'jack', '李四'] 这里写的list1...
  • Python学习之路1 有序集合和无需集合

    千次阅读 2016-09-09 16:28:05
    1. 集合是指包含一组元素的数据结构,包括: 1. 有序集合:list,tuple,str和unicode; 2. 无序集合:set 3. 无序集合并且具有 key-value 对:dict
  • python的set和其他语言类似, 一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算. sets ...
  • Python集合简介

    2019-05-30 14:19:53
    因为之前是做java开发的,就直接拿java... 和java类似,list是有序的可重复的,set是无序的不可重复的,tuple和list唯一的区别就是tuple是不可变的,一旦创建就不能 更改元素 1)list创建 新建一个非空list: l...
  • 集合是指包含一组元素的数据结构 1. 有序集合:list,tuple,str和unicode; 2. 无序集合:set 3. 无序集合并且具有 key-value 对:dict
  •  set一个无序且不重复的元素集合访问速度快;天生解决元素重复问题 方法: 初始化 >>> s1 = set()>>> print(type(s1))<class 'set'> add() 增加元素 >>> s1.add('tom')&...
  • 有两个有序的集合集合的每个元素一段范围,求其交集,例如集合{[4,8],[9,13]}和{[6,12]}的交集为{[6,8],[9,12]} 思路 循环遍历两个不同集合中的区间,两两作比较,只有一个区间另一个区间的子集的时候,...
  • 两个有序集合集合中每个元素一段范围,求其交集。例如集合{[4,8],[9,13]}和{[6,12]}的交集为{[6,8],[9,12]}。 分析: 方法一:蛮力法 最简单方法就是遍历两个集合,针对集合中每个元素判断是否有交集,...
  • #coding:utf8 import redis r =redis.Redis(host="23.226.74.190",port=63279,... 如果某个成员已经是有序集的成员,那么更新这个成员的分数值,并通过重新插入这个成员元素,来保证该成员在正确的位置上。 分数值...
  • List:Python内置的一种数据类型列表,一种有序的集合, 使用len()来获取list的元素个数 列表中的数据元素类型可以相同也可以不同,可以另一个list >> s = ['python', 'java', ['asp', 'php'], '...
  • 文章目录1.集合1.1创建可变集合1.2修改可变集合...​ 提示:与序列比较,序列中的元素是有序的,可以__重复出现__,而且集合中的元素是无序的,且不能有重复的元素。 序列强调的是有序,集合强调的是不重复,而且当...
  • 序列类型:list、string、tuple,他们中的元素是有序的。 散列类型:set、dict,他们中的元素无序的。(注意:python3.7.0开始字典变成"有序"了) 序列类型有序,可以用索引。而散列类型中的元素是无序的,所以不...
  • python redis详解(七)ZSET有序集合

    千次阅读 2019-07-13 20:13:43
    Redis zset 和 set 一样也string类型元素集合,且不允许重复的成员。 不同的每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。 zset的成员唯一的,但分数(score)...
  • Python集合框架

    2016-08-22 16:36:00
    list:list一种有序的集合 list里面的元素的数据类型也可以不同,list元素也可以另一个list In [28]: array = ['a',1,None,[2,3,4]] In [29]: array Out[29]: ['a', 1, None, [2, 3, 4]]  In [31]:...

空空如也

空空如也

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

python集合元素是有序的

python 订阅