精华内容
下载资源
问答
  • 我们今天所要讲的在python集合中,添加元素的两种方法就可以这样理解。一个是整体加入,另一个是拆分加入,下面我们一起看看具体的使用吧。 集合的添加有两种方式,分别是add和update。但是它们在添加元素时是由区别...
  • python中集合和序列

    2020-09-12 20:43:25
    访问集合中的值3. 集合的内置方法4. 集合的转换5. 不可变集合序列1. 针对序列的内置函数 集合 Python 中set与dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。 注意...

    python 训练营打卡第六天

    集合

    Python 中setdict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key

    注意,key为不可变类型,即可哈希的值。

    1. 集合的创建

    • 先创建对象再加入元素。
    • 在创建空集合的时候只能使用s = set(),因为s = {}创建的是空字典。
    basket = set()
    basket.add('apple')
    basket.add('banana')
    print(basket)  # {'banana', 'apple'}
    

    直接把一堆元素用花括号括起来{元素1, 元素2, ..., 元素n}

    • 重复元素在set中会被自动被过滤。
    • 使用set(value)工厂函数,把列表或元组转换成集合。
    a = set('abracadabra')
    print(a)  
    # {'r', 'b', 'd', 'c', 'a'}
    
    b = set(("Google", "Lsgogroup", "Taobao", "Taobao"))
    print(b)  
    # {'Taobao', 'Lsgogroup', 'Google'}
    
    c = set(["Google", "Lsgogroup", "Taobao", "Google"])
    print(c)  
    # {'Taobao', 'Lsgogroup', 'Google'}
    

    解释set

    lst = [0, 1, 2, 3, 4, 5, 5, 3, 1]
    
    temp = []
    for item in lst:
        if item not in temp:
            temp.append(item)
    
    print(temp)  # [0, 1, 2, 3, 4, 5]
    
    a = set(lst)
    print(list(a))  # [0, 1, 2, 3, 4, 5]
    从结果发现集合的两个特点:无序 (unordered) 和唯一 (unique)。
    
    由于 `set` 存储的是无序集合,所以我们不可以为集合创建索引或执行切片(slice)操作,也没有键(keys)可用来获取集合中元素的值,但是可以判断一个元素是否在集合中。
    

    2. 访问集合中的值

    • 可以使用len()內建函数得到集合的大小。
    s = set(['Google', 'Baidu', 'Taobao'])
    print(len(s))  # 3
    
    • 可以使用for把集合中的数据一个个读取出来。
    s = set(['Google', 'Baidu', 'Taobao'])
    for item in s:
        print(item)
        
    # Baidu
    # Google
    # Taobao
    
    • 可以通过innot in判断一个元素是否在集合中已经存在

    • 3. 集合的内置方法

    • set.add(elmnt)用于给集合添加元素,如果添加的元素在集合中已存在,则不执行任何操作。

    • set.update(set)用于修改当前集合,可以添加新的元素或集合到当前集合中,如果添加的元素在集合中已存在,则该元素只会出现一次,重复的会忽略。

    x = {"apple", "banana", "cherry"}
    y = {"google", "baidu", "apple"}
    x.update(y)
    print(x)
    # {'cherry', 'banana', 'apple', 'google', 'baidu'}
    
    y.update(["lsgo", "dreamtech"])
    print(y)
    # {'lsgo', 'baidu', 'dreamtech', 'apple', 'google'}
    
    • set.remove(item) 用于移除集合中的指定元素。如果元素不存在,则会发生错误。

      • set.discard(value) 用于移除指定的集合元素。remove() 方法在移除一个不存在的元素时会发生错误,而 discard() 方法不会。
    • set.pop() 用于随机移除一个元素。

    • 由于 set 是无序和无重复元素的集合,所以两个或多个 set 可以做数学意义上的集合操作。

    • set.intersection(set1, set2) 返回两个集合的交集。

    • set1 & set2 返回两个集合的交集。

    • set.intersection_update(set1, set2) 交集,在原始的集合上移除不重叠的元素。

    a = set('abracadabra')
    b = set('alacazam')
    print(a)  # {'r', 'a', 'c', 'b', 'd'}
    print(b)  # {'c', 'a', 'l', 'm', 'z'}
    
    c = a.intersection(b)
    print(c)  # {'a', 'c'}
    print(a & b)  # {'c', 'a'}
    print(a)  # {'a', 'r', 'c', 'b', 'd'}
    
    a.intersection_update(b)
    print(a)  # {'a', 'c'}
    
    • set.union(set1, set2) 返回两个集合的并集。

    • set1 | set2 返回两个集合的并集。

    • set.difference(set) 返回集合的差集。

    • set1 - set2 返回集合的差集。

    • set.difference_update(set) 集合的差集,直接在原来的集合中移除元素,没有返回值。

    • set.symmetric_difference(set)返回集合的异或。

    • set1 ^ set2 返回集合的异或。

    • set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。

    • set.issubset(set)判断集合是不是被其他集合包含,如果是则返回 True,否则返回 False。

    • set1 <= set2 判断集合是不是被其他集合包含,如果是则返回 True,否则返回 False。

    • set.issuperset(set)用于判断集合是不是包含其他集合,如果是则返回 True,否则返回 False。

    • set1 >= set2 判断集合是不是包含其他集合,如果是则返回 True,否则返回 False。

    • set.isdisjoint(set) 用于判断两个集合是不是不相交,如果是返回 True,否则返回 False。

    • 4. 集合的转换

    【例子】

    se = set(range(4))
    li = list(se)
    tu = tuple(se)
    
    print(se, type(se))  # {0, 1, 2, 3} <class 'set'>
    print(li, type(li))  # [0, 1, 2, 3] <class 'list'>
    print(tu, type(tu))  # (0, 1, 2, 3) <class 'tuple'>
    

    5. 不可变集合

    Python 提供了不能改变元素的集合的实现版本,即不能增加或删除元素,类型名叫frozenset。需要注意的是frozenset仍然可以进行集合操作,只是不能用带有update的方法。

    • frozenset([iterable]) 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。

    【例子】

    a = frozenset(range(10))  # 生成一个新的不可变集合
    print(a)  
    # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
    
    b = frozenset('lsgogroup')
    print(b)  
    # frozenset({'g', 's', 'p', 'r', 'u', 'o', 'l'})
    

    序列

    在 Python 中,序列类型包括字符串、列表、元组、集合和字典,这些序列支持一些通用的操作,但比较特殊的是,集合和字典不支持索引、切片、相加和相乘操作。

    1. 针对序列的内置函数

    • list(sub) 把一个可迭代对象转换为列表。

    【例子】

    a = list()
    print(a)  # []
    
    b = 'I Love LsgoGroup'
    b = list(b)
    print(b)  
    # ['I', ' ', 'L', 'o', 'v', 'e', ' ', 'L', 's', 'g', 'o', 'G', 'r', 'o', 'u', 'p']
    
    c = (1, 1, 2, 3, 5, 8)
    c = list(c)
    print(c)  # [1, 1, 2, 3, 5, 8]
    
    • tuple(sub) 把一个可迭代对象转换为元组。

      • str(obj) 把obj对象转换为字符串
    • len(s) 返回对象(字符、列表、元组等)长度或元素个数。

      • s – 对象。
    • max(sub)返回序列或者参数集合中的最大值

    • min(sub)返回序列或参数集合中的最小值

      • sum(iterable[, start=0]) 返回序列iterable与可选参数start的总和。
      • sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作。
        • iterable – 可迭代对象。
        • key – 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
        • reverse – 排序规则,reverse = True 降序 , reverse = False 升序(默认)。
        • 返回重新排序的列表。
          sorted经常用的到
    x = [-8, 99, 3, 7, 83]
    print(sorted(x))  # [-8, 3, 7, 83, 99]
    print(sorted(x, reverse=True))  # [99, 83, 7, 3, -8]
    
    t = ({"age": 20, "name": "a"}, {"age": 25, "name": "b"}, {"age": 10, "name": "c"})
    x = sorted(t, key=lambda a: a["age"])
    print(x)
    # [{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]
    
    • reversed(seq) 函数返回一个反转的迭代器。
      • seq – 要转换的序列,可以是 tuple, string, list 或 range。

    【例子】

    s = 'lsgogroup'
    x = reversed(s)
    print(type(x))  # <class 'reversed'>
    print(x)  # <reversed object at 0x000002507E8EC2C8>
    print(list(x))
    # ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']
    
    t = ('l', 's', 'g', 'o', 'g', 'r', 'o', 'u', 'p')
    print(list(reversed(t)))
    # ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']
    
    r = range(5, 9)
    print(list(reversed(r)))
    # [8, 7, 6, 5]
    
    x = [-8, 99, 3, 7, 83]
    print(list(reversed(x)))
    # [83, 7, 3, 99, -8]
    
    • enumerate(sequence, [start=0])

    【例子】用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。

    seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    a = list(enumerate(seasons))
    print(a)  
    # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
    
    b = list(enumerate(seasons, 1))
    print(b)  
    # [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
    
    for i, element in a:
        print('{0},{1}'.format(i, element))
    # 0,Spring
    # 1,Summer
    # 2,Fall
    # 3,Winter
    
    • zip(iter1 [,iter2 [...]])
      • 用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。
      • 我们可以使用 list() 转换来输出列表。
      • 如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。

    【例子】

    a = [1, 2, 3]
    b = [4, 5, 6]
    c = [4, 5, 6, 7, 8]
    
    zipped = zip(a, b)
    print(zipped)  # <zip object at 0x000000C5D89EDD88>
    print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
    zipped = zip(a, c)
    print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
    
    a1, a2 = zip(*zip(a, b))
    print(list(a1))  # [1, 2, 3]
    print(list(a2))  # [4, 5, 6]
    

    感觉这个有点超前了。。。

    展开全文
  • Python set与dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set,没有重复的key。 key为不可变类型,即可哈希的值。 num = {} print(type(num)) # <class 'dict'> num = {1, 2...

    集合

    Python 中set与dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。

    key为不可变类型,即可哈希的值。

    num = {}
    print(type(num))  # <class 'dict'>
    num = {1, 2, 3, 4}
    print(type(num))  # <class 'set'>
    

    集合的两个特点:

    无序(unordered)和唯一(unique)
    

    1、集合的创建

    • 先创建对象再加入元素。
    • 在创建空集合的时候只能使用s = set(),因为s = {}创建的是空字典。
    basket = set()
    basket.add('apple')
    basket.add('banana')
    print(basket)  # {'banana', 'apple'}
    
    • 直接把一堆元素用花括号括起来{元素1, 元素2, …, 元素n}。
    • 重复元素在set中会被自动被过滤。
    basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
    print(basket)  # {'banana', 'apple', 'pear', 'orange'}
    
    • 使用set(value)工厂函数,把列表或元组转换成集合。
    a = set('abracadabra')
    print(a)  
    # {'r', 'b', 'd', 'c', 'a'}
    
    b = set(("Google", "Lsgogroup", "Taobao", "Taobao"))
    print(b)  
    # {'Taobao', 'Lsgogroup', 'Google'}
    
    c = set(["Google", "Lsgogroup", "Taobao", "Google"])
    print(c)  
    # {'Taobao', 'Lsgogroup', 'Google'}
    
    • 去掉列表中重复的元素
    #常规更改
    lst = [0, 1, 2, 3, 4, 5, 5, 3, 1]
    
    temp = []
    for item in lst:
        if item not in temp:
            temp.append(item)
    
    print(temp)  # [0, 1, 2, 3, 4, 5]
    
    #利用集合更改
    a = set(lst)
    print(list(a))  # [0, 1, 2, 3, 4, 5]
    

    由于set存储的是无序集合,所以我们不可以为集合创建索引或执行切片(slice)操作,也没有键(keys)可用来获取集合中元素的值,但是可以判断一个元素是否在集合中。

    2、访问集合中的值

    • 使用len()內建函数得到集合的大小
    s = set(['Google', 'Baidu', 'Taobao'])
    print(len(s))  # 3
    
    • 可以通过innot in判断一个元素是否在集合中已经存在
    s = set(['Google', 'Baidu', 'Taobao'])
    print('Taobao' in s)  # True
    print('Facebook' not in s)  # True
    

    3、集合的内置方法

    • set.add(elmnt)用于给集合添加元素,如果添加的元素在集合中已存在,则不执行任何操作。
    fruits = {"apple", "banana", "cherry"}
    fruits.add("orange")
    print(fruits)  
    # {'orange', 'cherry', 'banana', 'apple'}
    
    
    #添加已存在的元素
    fruits.add("apple")
    print(fruits)  
    # {'orange', 'cherry', 'banana', 'apple'}
    
    • set.update(set)用于修改当前集合,可以添加新的元素或集合到当前集合中,如果添加的元素在集合中已存在,则该元素只会出现一次,重复的会忽略。
    x = {"apple", "banana", "cherry"}
    y = {"google", "baidu", "apple"}
    x.update(y)
    print(x)
    # {'cherry', 'banana', 'apple', 'google', 'baidu'}
    
    • set.remove(item)用于移除集合中的指定元素。如果元素不存在,则会发生错误。
    fruits = {"apple", "banana", "cherry"}
    fruits.remove("banana")
    print(fruits)  # {'apple', 'cherry'}
    
    • set.discard(value)用于移除指定的集合元素。remove()方法在移除一个不存在的元素时会发生错误,而 discard()方法不会。
    fruits = {"apple", "banana", "cherry"}
    fruits.discard("orange")
    print(fruits)  # {'apple', 'cherry'}
    
    • set.pop()用于随机移除一个元素。
    fruits = {"apple", "banana", "cherry"}
    x = fruits.pop()
    print(fruits)  # {'cherry', 'apple'}
    print(x)  # banana
    

    由于 set 是无序和无重复元素的集合,所以两个或多个 set 可以做数学意义上的集合操作。

    • set.intersection(set1, set2) 返回两个集合的交集。
    • set1 & set2返回两个集合的交集。
    • set.intersection_update(set1, set2)交集,在原始的集合上移除不重叠的元素。
    a = set('abracadabra')
    b = set('alacazam')
    print(a)  # {'r', 'a', 'c', 'b', 'd'}
    print(b)  # {'c', 'a', 'l', 'm', 'z'}
    
    c = a.intersection(b)
    print(c)  # {'a', 'c'}
    print(a & b)  # {'c', 'a'}
    print(a)  # {'a', 'r', 'c', 'b', 'd'}
    
    a.intersection_update(b)
    print(a)  # {'a', 'c'}
    
    • set.union(set1, set2)返回两个集合的并集。
    • set1 | set2 返回两个集合的并集。
    a = set('abracadabra')
    b = set('alacazam')
    print(a)  # {'r', 'a', 'c', 'b', 'd'}
    print(b)  # {'c', 'a', 'l', 'm', 'z'}
    
    print(a | b)  
    # {'l', 'd', 'm', 'b', 'a', 'r', 'z', 'c'}
    
    c = a.union(b)
    print(c)  
    # {'c', 'a', 'd', 'm', 'r', 'b', 'z', 'l'}
    
    • set.difference(set)返回集合的差集。
    • set1 - set2 返回集合的差集。
    • set.difference_update(set) 集合的差集,直接在原来的集合中移除元素,没有返回值。
    a = set('abracadabra')
    b = set('alacazam')
    print(a)  # {'r', 'a', 'c', 'b', 'd'}
    print(b)  # {'c', 'a', 'l', 'm', 'z'}
    
    c = a.difference(b)
    print(c)  # {'b', 'd', 'r'}
    print(a - b)  # {'d', 'b', 'r'}
    
    print(a)  # {'r', 'd', 'c', 'a', 'b'}
    a.difference_update(b)
    print(a)  # {'d', 'r', 'b'}
    
    • set.symmetric_difference(set)返回集合的异或。
    • set1 ^ set2返回集合的异或。
    • set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。
    a = set('abracadabra')
    b = set('alacazam')
    print(a)  # {'r', 'a', 'c', 'b', 'd'}
    print(b)  # {'c', 'a', 'l', 'm', 'z'}
    
    c = a.symmetric_difference(b)
    print(c)  # {'m', 'r', 'l', 'b', 'z', 'd'}
    print(a ^ b)  # {'m', 'r', 'l', 'b', 'z', 'd'}
    
    print(a)  # {'r', 'd', 'c', 'a', 'b'}
    a.symmetric_difference_update(b)
    print(a)  # {'r', 'b', 'm', 'l', 'z', 'd'}
    
    • set.issubset(set)判断集合是不是被其他集合包含,如果是则返回 True,否则返回 False。
    • set1 <= set2 判断集合是不是被其他集合包含,如果是则返回 True,否则返回 False。
    x = {"a", "b", "c"}
    y = {"f", "e", "d", "c", "b", "a"}
    z = x.issubset(y)
    print(z)  # True
    print(x <= y)  # True
    
    x = {"a", "b", "c"}
    y = {"f", "e", "d", "c", "b"}
    z = x.issubset(y)
    print(z)  # False
    print(x <= y)  # False
    
    • set.issuperset(set)用于判断集合是不是包含其他集合,如果是则返回 True,否则返回 False。
    • set1 >= set2判断集合是不是包含其他集合,如果是则返回 True,否则返回 False。
    x = {"f", "e", "d", "c", "b", "a"}
    y = {"a", "b", "c"}
    z = x.issuperset(y)
    print(z)  # True
    print(x >= y)  # True
    
    x = {"f", "e", "d", "c", "b"}
    y = {"a", "b", "c"}
    z = x.issuperset(y)
    print(z)  # False
    print(x >= y)  # False
    
    • set.isdisjoint(set)用于判断两个集合是不是不相交,如果是返回 True,否则返回 False。
    x = {"f", "e", "d", "c", "b"}
    y = {"a", "b", "c"}
    z = x.isdisjoint(y)
    print(z)  # False
    
    x = {"f", "e", "d", "m", "g"}
    y = {"a", "b", "c"}
    z = x.isdisjoint(y)
    print(z)  # True
    

    4、集合的转换

    例子:

    se = set(range(4))
    li = list(se)
    tu = tuple(se)
    
    print(se, type(se))  # {0, 1, 2, 3} <class 'set'>
    print(li, type(li))  # [0, 1, 2, 3] <class 'list'>
    print(tu, type(tu))  # (0, 1, 2, 3) <class 'tuple'>
    

    5、不可变集合

    Python 提供了不能改变元素的集合的实现版本,即不能增加或删除元素,类型名叫frozenset。需要注意的是frozenset仍然可以进行集合操作,只是不能用带有update的方法。

    • frozenset([iterable])返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。
    a = frozenset(range(10))  # 生成一个新的不可变集合
    print(a)  
    # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
    
    b = frozenset('lsgogroup')
    print(b)  
    # frozenset({'g', 's', 'p', 'r', 'u', 'o', 'l'})
    

    序列

    在 Python 中,序列类型包括字符串、列表、元组、集合和字典,这些序列支持一些通用的操作,但比较特殊的是,集合和字典不支持索引、切片、相加和相乘操作。

    1、针对序列的内置函数

    • list(sub)把一个可迭代对象转换为列表。
    a = list()
    print(a)  # []
    
    b = 'I Love LsgoGroup'
    b = list(b)
    print(b)  
    # ['I', ' ', 'L', 'o', 'v', 'e', ' ', 'L', 's', 'g', 'o', 'G', 'r', 'o', 'u', 'p']
    
    c = (1, 1, 2, 3, 5, 8)
    c = list(c)
    print(c)  # [1, 1, 2, 3, 5, 8]
    
    • tuple(sub)把一个可迭代对象转换为元组。
    a = tuple()
    print(a)  # ()
    
    b = 'I Love LsgoGroup'
    b = tuple(b)
    print(b)  
    # ('I', ' ', 'L', 'o', 'v', 'e', ' ', 'L', 's', 'g', 'o', 'G', 'r', 'o', 'u', 'p')
    
    c = [1, 1, 2, 3, 5, 8]
    c = tuple(c)
    print(c)  # (1, 1, 2, 3, 5, 8)
    
    • str(obj)obj对象转换为字符串
    a = 123
    a = str(a)
    print(a)  # 123
    
    • len(s) 返回对象(字符、列表、元组等)长度或元素个数。
    • s– 对象。
    a = list()
    print(len(a))  # 0
    
    b = ('I', ' ', 'L', 'o', 'v', 'e', ' ', 'L', 's', 'g', 'o', 'G', 'r', 'o', 'u', 'p')
    print(len(b))  # 16
    
    
    • max(sub)返回序列或者参数集合中的最大值
    print(max(1, 2, 3, 4, 5))  # 5
    print(max([-8, 99, 3, 7, 83]))  # 99
    print(max('IloveLsgoGroup'))  # v
    
    • min(sub)返回序列或参数集合中的最小值
    print(min(1, 2, 3, 4, 5))  # 1
    print(min([-8, 99, 3, 7, 83]))  # -8
    print(min('IloveLsgoGroup'))  # G
    
    • sum(iterable[, start=0])返回序列iterable与可选参数start的总和。
    print(sum([1, 3, 5, 7, 9]))  # 25
    print(sum([1, 3, 5, 7, 9], 10))  # 35
    print(sum((1, 3, 5, 7, 9)))  # 25
    print(sum((1, 3, 5, 7, 9), 20))  # 45
    
    • sorted(iterable, key=None, reverse=False)对所有可迭代的对象进行排序操作。

       iterable -- 可迭代对象。
       key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
       reverse -- 排序规则,reverse = True 降序 , reverse = False 升序(默认)。
       返回值 -- 返回重新排序的列表。
      
    x = [-8, 99, 3, 7, 83]
    print(sorted(x))  # [-8, 3, 7, 83, 99]
    print(sorted(x, reverse=True))  # [99, 83, 7, 3, -8]
    
    t = ({"age": 20, "name": "a"}, {"age": 25, "name": "b"}, {"age": 10, "name": "c"})
    x = sorted(t, key=lambda a: a["age"])
    print(x)
    # [{'age': 10, 'name': 'c'}, {'age': 20, 'name': 'a'}, {'age': 25, 'name': 'b'}]
    
    • reversed(seq) 函数返回一个反转的迭代器。
    • seq – 要转换的序列,可以是 tuple, string, list 或 range。
    s = 'lsgogroup'
    x = reversed(s)
    print(type(x))  # <class 'reversed'>
    print(x)  # <reversed object at 0x000002507E8EC2C8>
    print(list(x))
    # ['p', 'u', 'o', 'r', 'g', 'o', 'g', 's', 'l']
    
    • enumerate(sequence, [start=0])用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
    seasons = ['Spring', 'Summer', 'Fall', 'Winter']
    a = list(enumerate(seasons))
    print(a)  
    # [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
    
    b = list(enumerate(seasons, 1))
    print(b)  
    # [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
    
    for i, element in a:
        print('{0},{1}'.format(i, element))
    # 0,Spring
    # 1,Summer
    # 2,Fall
    # 3,Winter
    
    • zip(iter1 [,iter2 [...]])
    • 用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象
    • 我们可以使用 list() 转换来输出列表。
    • 如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。
    a = [1, 2, 3]
    b = [4, 5, 6]
    c = [4, 5, 6, 7, 8]
    
    zipped = zip(a, b)
    print(zipped)  # <zip object at 0x000000C5D89EDD88>
    print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
    zipped = zip(a, c)
    print(list(zipped))  # [(1, 4), (2, 5), (3, 6)]
    
    a1, a2 = zip(*zip(a, b))
    print(list(a1))  # [1, 2, 3]
    print(list(a2))  # [4, 5, 6]
    
    展开全文
  • Python-集合

    2020-09-30 18:02:18
    Python set与dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set,没有重复的key。 集合的创建 先创建对象再加入元素。 在创建空集合的时候只能使用s = set(),因为s = {}创建的是空...

    集合

    Python 中setdict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key

    集合的创建

    • 先创建对象再加入元素。
    • 在创建空集合的时候只能使用s = set(),因为s = {}创建的是空字典。
    • 直接把一堆元素用花括号括起来{元素1, 元素2, ..., 元素n}
    • 重复元素在set中会被自动被过滤。
    • 使用set(value)工厂函数,把列表或元组转换成集合。
      在这里插入图片描述

    集合的两个特点:无序 (unordered) 和唯一 (unique)。

    由于 set 存储的是无序集合,所以我们不可以为集合创建索引或执行切片(slice)操作,也没有键(keys)可用来获取集合中元素的值,但是可以判断一个元素是否在集合中。

    访问集合中的值

    • 可以使用len()內建函数得到集合的大小。
    • 可以使用for把集合中的数据一个个读取出来。
    • 可以通过innot in判断一个元素是否在集合中已经存在

    集合内的内置方法

    • set.add(elmnt)用于给集合添加元素,如果添加的元素在集合中已存在,则不执行任何操作。
    • set.update(set)用于修改当前集合,可以添加新的元素或集合到当前集合中,如果添加的元素在集合中已存在,则该元素只会出现一次,重复的会忽略。
    • set.remove(item) 用于移除集合中的指定元素。如果元素不存在,则会发生错误。
    • set.discard(value) 用于移除指定的集合元素。remove() 方法在移除一个不存在的元素时会发生错误,而 discard() 方法不会。
    • set.pop() 用于随机移除一个元素。

    由于 set 是无序和无重复元素的集合,所以两个或多个 set 可以做数学意义上的集合操作。

    • set.intersection(set1, set2) 返回两个集合的交集。
    • set1 & set2 返回两个集合的交集。
    • set.intersection_update(set1, set2) 交集,在原始的集合上移除不重叠的元素。
    • set.union(set1, set2) 返回两个集合的并集。
    • set1 | set2 返回两个集合的并集。
    • set.difference(set) 返回集合的差集。
    • set1 - set2 返回集合的差集。
    • set.difference_update(set) 集合的差集,直接在原来的集合中移除元素,没有返回值。
    • set.symmetric_difference(set)返回集合的异或。
    • set1 ^ set2 返回集合的异或。
    • set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。
    • set.issubset(set)判断集合是不是被其他集合包含,如果是则返回 True,否则返回 False。
    • set1 <= set2 判断集合是不是被其他集合包含,如果是则返回 True,否则返回 False。
    • set.issuperset(set)用于判断集合是不是包含其他集合,如果是则返回 True,否则返回 False。
    • set1 >= set2 判断集合是不是包含其他集合,如果是则返回 True,否则返回 False。
    • set.isdisjoint(set) 用于判断两个集合是不是不相交,如果是返回 True,否则返回 False。

    不可变集合

    Python 提供了不能改变元素的集合的实现版本,即不能增加或删除元素,类型名叫frozenset。需要注意的是frozenset仍然可以进行集合操作,只是不能用带有update的方法。

    • frozenset([iterable]) 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。
    展开全文
  • python 错误集合

    2018-10-04 13:52:52
    OSError: raw write() returned invalid length 94 (should have been between 0 and 47) 在vscode实验python程序时, 出现上面错误. 解决方法: 安装win_unicode_console: ...在代码中加入: import win_unicode...
    1. OSError: raw write() returned invalid length 94 (should have been between 0 and 47)

    在vscode实验python程序时, 出现上面错误.

    解决方法:

    安装win_unicode_console:

    pip install win_unicode_console
    

    在代码中加入:

    import win_unicode_console
    win_unicode_console.enable()
    
    1. Could not install packages due to an EnvironmentError: raw write() returned invalid length

    在vscode中, 出现这种错误;
    打开cmd, 执行同样的命令即可

    展开全文
  • 练习-python集合set

    2016-04-22 15:53:00
    2 #要求:原来没有的,新加入;原来有的,更新;新的没有,原来的有,删除原来的 3 #无需考虑内部元素改变 4 #数据库原有 5 old_dict = { 6 "#1":{ "hostname":"c1", "cpu_count": 2, "mem_capicity": 80...
  • python中的字典与集合

    2019-10-01 17:32:51
    dict/set 底层都是哈希表 哈希表其实就是一个数组 根据哈希函数快速定位一个元素,平均查找O(1) 非常快 ...解决哈希冲突的方法有链接法和探查法(开放寻址法),在python中采用二次探查法 ...
  • 文章目录06-python中的集合类-02-ChainMapChainMap 的使用ChainMap 删除 增加元素ChainMap 中加入一个新的字典ChainMap 中 获取parents总结参考文档 06-python中的集合类-02-ChainMap 今天 我们继续讲解 Collections...
  • Python基础之集合

    2020-07-30 16:09:27
    DataWhale-Python基础-8.集合 1.集合的创建 先创建对象再加入元素 在创建空集合的时候只能用s=set(),因为s={}创建的是空字典 直接把一对元素用花括号括起来{元素1,元素2,…,元素N} 重复的元素在set会被自动过滤...
  • python-set集合

    2017-03-25 16:57:00
    简介 set是一个无序且不重复的元素集合 s1=set() #创建一个空的set集合 s2=set('python') #创建一个非空的set集合 print (type(s1)) ...注意:如果想要在set集合中加入多个元素,不可使用set('pyth...
  • 集合的创建及性质使用2.1 空集合2.2 集合创建2.2.1 对list和tuple创建2.2.2 `set(only_one_obj)`问题2.3 集合性质:无序和去重2.4 集合中不能加入可变类型数据3. 集合子集和超集3.1 子集真子集3.2 超集真超集4. ...
  • Python-集合类型及操作

    2019-09-26 17:18:44
    集合类型与数学集合概念一致; 集合元素之间无序,每个元素唯一,不存在相同元素; 集合元素不可更改,不能是可变数据类型;(为什么?防止后加入的数据和已有的数据重复); 集合用大括号{}表示,元素间用...
  • python-集合的增删改

    2021-05-27 12:55:28
    # coding:utf-8 ''' 集合的add函数 用于集合中添加一个元素,如果集合中已存在该元素则该函数不执行 ... 加入一个新的集合(或列表,元组,字符串),如新的集合内的元素在原集合中存在则无视 update的用法
  • python学习10:集合

    2020-08-01 00:07:42
    Python set与dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set,没有重复的key。 注意,key为不可变类型,即可哈希的值。 【例子】 num = {} print(type(num)) # <class 'dict'>...
  • python06-集合和序列

    2020-09-12 10:18:42
    Python set与dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set,没有重复的key。 注意,key为不可变类型,即可哈希的值。 1. 集合的创建 先创建对象再加入元素。 在创建空集合的...
  • 可变 有序集合,可以随时在集合中添加和删除元素。 元祖Tuple: 有序列表,和List非常类似,但是不同点是元祖中的数据一旦被定义就无法修改,元祖用于接受多维的元素,在很多时候写法上可以节省很多行。查询方法和...
  • Python基础入门009_集合

    2020-09-12 21:20:30
    Python 中se是一组key的集合,在set中,没有重复的key。(key为不可变类型,即可哈希的值。) 1. 集合的创建 先创建对象再加入元素。...2. 访问集合中的值 可以使用len()內建函数得到集合的大小。 s .
  • 感谢AI蜗牛车-阿里云...集合中的元素必须是不可变类型(可哈希) 1. 集合的创建 先创建对象再加入元素 创建空集合时 只能使用set() {元素1, 元素2, ..., 元素n} set中会自动删除重复元素 2. 访问集合...
  • 上述就是往列表中加入元素的格式 注意:pop删除中若是不指定删除的元素,则默认删除的是列表中的最后一个元素 上述的删除是将列表中的元素删除的格式,而del删除列表是将整个列表删除 列表元素的修改 ...
  • Python Day 3 集合与函数

    2018-07-08 12:19:00
    3.集合中元素必须是不可变类型 s={1,2,9,7,3,4,3,3,4,5} type(s) print(s) #set定义集合相当于for循环 s=set("hello") print(s) s=set(["lzx","lzx","nb"]) print(s) #add加入元素 s.add("3") ...
  • python set与dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set,没有重复的key。 注意,key为不可变类型,即可哈希的值。 【例子】 num = {} print(type(num)) # <class 'dict'>...
  • Python set与dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set,没有重复的key。 注意,key为不可变类型,即可哈希的值。 例子: num = {} print(type(num)) # <class ‘dict’>...
  • Python set与dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set,没有重复的key。 注意,key为不可变类型,即可哈希的值。 【例子】 num = {} print(type(num)) # <class 'dict'>...
  • 集合set 基本数据类型特点(可变:列表,...集合中的元素必须是不可变类型,加入可变的类型会报错 #!/usr/bin/python3 student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'} print(student) #...
  • Python中set与dict类似,也是一组key的集合,但是不存储value。 (由于key不可重复,所以在set没有重复的key) key为不可变类型,即可被hash的值 num = {} print(type(num)) #<calss 'dict') ber = {1, 2, 3, 4...
  • Python set与dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set,没有重复的key。 注意,key为不可变类型,即可哈希的值。 例子: num = {} print(type(num)) # <class 'dict'&...
  • 1)遍历列表每一项元素,对每一项元素进行判断,筛选符合的数据加入到新列表 data = [1,5,-3,-2,6,0,9] res = [] for x in data:  if x &gt;= 0:  res.append(x) print(res) 2)列表推导式 [x for ...
  • Python set与dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set,没有重复的key。 注意,key为不可变类型,即可哈希的值。 【例子】 num = {} print(type(num)) # <class 'dict'>...
  • Python中的一切都是一个对象。每个对象都有自己的数据属性和与之关联的方法。为了有效和恰当地使用一个对象,我们应该知道如何与它们进行交互。 列表、元组和集合是3种重要的对象类型。它们的共同点是,它们被用作...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 361
精华内容 144
关键字:

python集合中加入集合

python 订阅