Campamento de entrenamiento Alibaba Cloud Python (día 6)

---

Introducción

Establecer en Python es similar a dict. También es un conjunto de claves, pero no almacena valor. Dado que la clave no se puede repetir, no hay una clave duplicada en el conjunto. Tenga en cuenta que la clave es un tipo inmutable, es decir, un valor hash.
Los tipos de secuencia incluyen cadenas, listas, tuplas, conjuntos y diccionarios. Estas secuencias admiten algunas operaciones comunes, pero lo que es más especial es que los conjuntos y diccionarios no admiten operaciones de indexación, división, suma y multiplicación.

---

Uno, colección

1. Creación de colecciones

先创建对象再加入元素。
在创建空集合的时候只能使用s = set()，因为s = {}创建的是空字典。

El código de demostración es el siguiente:

basket = set()
basket.add('zmt')
basket.add('zgk')
print(basket)  
# {'zmt', 'zgk'}

直接把一堆元素用花括号括起来{元素1, 元素2, ..., 元素n}。
重复元素在set中会被自动被过滤。

El código de demostración es el siguiente:

basket = {
    
    'zmt', 'zgk', 'zmt', 'wj'}
print(basket)  
# {'zmt', 'zgk', 'wj'}

使用set(value)工厂函数，把列表或元组转换成集合。

El código de demostración es el siguiente:

a = set('abracadabra')
print(a)  
# {'r', 'b', 'd', 'c', 'a'}

b = set(("wj", "wj", "zmt", "zgk"))
print(b)  
# {'wj', 'zmt', 'zgk'}

Ejemplo: eliminar elementos duplicados de la lista

El código de demostración es el siguiente:

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]

De los resultados se encuentran dos características de la colección:

无序 (unordered) 
唯一 (unique)。

Dado que set almacena una colección desordenada, no podemos crear índices o realizar operaciones de corte para la colección, y no hay claves para obtener el valor de los elementos en la colección, pero podemos juzgar si un elemento está en la colección.

2. Accede a los valores de la colección.

1. Puede usar la función incorporada len () para obtener el tamaño de la colección.
2. Puede utilizar para leer los datos de la colección uno por uno.
3. Puede juzgar si un elemento ya existe en la colección en o no en

El código de demostración es el siguiente:

s = set(['Google', 'Baidu', 'Taobao'])
print(len(s)) 
# 3

s = set(['Google', 'Baidu', 'Taobao'])
for item in s:
    print(item)
# Baidu
# Google
# Taobao

s = set(['Google', 'Baidu', 'Taobao'])
print('Taobao' in s)  # True
print('Facebook' not in s)  # True

3. Métodos de recopilación integrados

(1) .set.add (elmnt) se usa para agregar elementos a la colección. Si el elemento agregado ya existe en la colección, no se realiza ninguna operación.

El código de demostración es el siguiente:

fruits = {
    
    "apple", "banana", "cherry"}
fruits.add("orange")
print(fruits)  
# {'orange', 'cherry', 'banana', 'apple'}

(2) .set.update (set) se usa para modificar la colección actual. Puede agregar nuevos elementos o colecciones a la colección actual. Si el elemento agregado ya existe en la colección, el elemento solo aparecerá una vez y el duplicado se ignorará .

El código de demostración es el siguiente:

x = {
    
    "apple", "banana", "cherry"}
y = {
    
    "google", "baidu", "apple"}
x.update(y)
print(x)
# {'cherry', 'banana', 'apple', 'google', 'baidu'}

(3).

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

El código de demostración es el siguiente:

fruits = {
    
    "apple", "banana", "cherry"}
fruits.remove("banana")
print(fruits)  # {'apple', 'cherry'}


fruits = {
    
    "apple", "banana", "cherry"}
fruits.discard("banana")
print(fruits)  # {'apple', 'cherry'}


fruits = {
    
    "apple", "banana", "cherry"}
x = fruits.pop()
print(fruits)  # {'cherry', 'apple'}
print(x)  # banana

(4).

Dado que un conjunto es un conjunto de elementos desordenados y sin elementos repetidos, dos o más conjuntos pueden realizar operaciones de conjuntos en un sentido matemático.

set.intersection(set1, set2) 返回两个集合的交集。
set1 & set2 返回两个集合的交集。
set.intersection_update(set1, set2) 交集，在原始的集合上移除不重叠的元素。

El código de demostración es el siguiente:

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'}

(5).

set.union(set1, set2) 返回两个集合的并集。
set1 | set2 返回两个集合的并集。

El código de demostración es el siguiente:

a = set('abracadabra')
b = set('alacazam')
c = a.union(b)
print(c)  
# {'c', 'a', 'd', 'm', 'r', 'b', 'z', 'l'}


print(a | b)  
# {'l', 'd', 'm', 'b', 'a', 'r', 'z', 'c'}

(6).

set.difference(set) 返回集合的差集。
set1 - set2 返回集合的差集。
set.difference_update(set) 集合的差集，直接在原来的集合中移除元素，没有返回值。

El código de demostración es el siguiente:

a = set('abracadabra')
b = set('alacazam')

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'}

(7).

 set.symmetric_difference(set)返回集合的异或。
 set1 ^ set2 返回集合的异或。
 set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

El código de demostración es el siguiente:

a = set('abracadabra')
b = set('alacazam')

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'}

(8).

set.issubset(set)判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。

El código de demostración es el siguiente:

x = {
    
    "a", "b", "c"}
y = {
    
    "f", "e", "d", "c", "b", "a"}
z = x.issubset(y)
print(z)  # True

x = {
    
    "a", "b", "c"}
y = {
    
    "f", "e", "d", "c", "b"}
z = x.issubset(y)
print(z)  # False
print(x <= y)  # False

(9).

set.issuperset(set)用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
set1 >= set2 判断集合是不是包含其他集合，如果是则返回 True，否则返回 False.

El código de demostración es el siguiente:

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

(10) .set.isdisjoint (set) se utiliza para juzgar si dos conjuntos son disjuntos. Si lo es, devuelve True, de lo contrario, devuelve False.

El código de demostración es el siguiente:

x = {
    
    "f", "e", "d", "c", "b"}
y = {
    
    "a", "b", "c"}
z = x.isdisjoint(y)
print(z)  # False

4. Colecciones inmutables

Python proporciona una versión de implementación de un conjunto que no puede cambiar elementos, es decir, no se pueden agregar ni eliminar elementos. El tipo se denomina frozenset. Cabe señalar que frozenset aún puede realizar operaciones de recolección, pero no se puede usar el método con actualización.

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

El código de demostración es el siguiente:

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'})

En segundo lugar, la secuencia

Funciones integradas para secuencias

(1). Función de conversión

list(sub) 把一个可迭代对象转换为列表。
tuple(sub) 把一个可迭代对象转换为元组。
str(obj) 把obj对象转换为字符串.

No hay código para estas tres funciones de conversión.

(2).

len(s) 返回对象（字符、列表、元组等）长度或元素个数。
max(sub)返回序列或者参数集合中的最大值
min(sub)返回序列或参数集合中的最小值
sum(iterable[, start=0]) 返回序列iterable与可选参数start的总和。

El código de demostración es el siguiente:

c = 'I Love LsgoGroup'
print(len(c))  # 16

print(max([-8, 99, 3, 7, 83]))  
# 99

print(min('IloveLsgoGroup'))  
# G

print(sum([1, 3, 5, 7, 9], 10))  
# 35

(3).

sorted(iterable, key=None, reverse=False) 对所有可迭代的对象进行排序操作。iterable -- 可迭代对象。
  key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
  reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
  返回重新排序的列表。

El código de demostración es el siguiente:

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'}]

(4)

reversed(seq) 函数返回一个反转的迭代器。
  seq -- 要转换的序列，可以是 tuple, string, list 或 range。

El código de demostración es el siguiente:

r = range(5, 9)
print(list(reversed(r)))
# [8, 7, 6, 5]

(5) .enumerate (secuencia, [inicio = 0]) se usa para combinar un objeto de datos transitable (como una lista, tupla o cadena) en una secuencia de índice, y enumerar datos y subíndices de datos al mismo tiempo, generalmente usado En el bucle for.

El código de demostración es el siguiente:

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
a = list(enumerate(seasons))
print(a)  
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

(6).

zip(iter1 [,iter2 [...]])
  用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
  我们可以使用 list() 转换来输出列表。
  如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

El código de demostración es el siguiente:

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]

---

Tres, resumen

En TASK2, aprendí una serie de contenedores de Python para almacenar datos. Lo más importante es que aprendí muchos métodos integrados, lo que me dio mucho conocimiento. El mayor problema ahora es cómo recordar todos los métodos integrados. Todavía tengo algunos Recuerde, en estudios futuros, voy a estudiar la parte de atrás mientras reviso el frente. ¡Venga!