notas Day6

一, id es ==

# id
# s = 'Jason'
# print(id(s))  # id的值是随机的
#
# l1 = [1, 2, 3]
# l2 = [1, 2, 3]
# print(l1 == l2)  # 结果为True，== 比较的是两边的值是否相等

# is 判断的是内存地址是否相同
l1 = [1, 2, 3]
l2 = [1, 2, 3]
print(l1 is l2)  # 结果为false，因为l1和l2分别创建了两个内存地址

s1 = 'Jason'
s2 = 'Jason'
print(s1 is s2)  # 结果为True，因为字符串只占一个内存地址

"""
id相同，值肯定相同；
值相同，id不一定相同
"""

En segundo lugar, el bloque de código

Python bloque de código de programa se construye. bloque de texto es un programa Python, que se ejecuta como una unidad.
Bloquear: un módulo, una función, una clase, un archivo, etc., es un bloque de código.
Como la interacción (CMD en el intérprete de Python) es una entrada de comando para cada bloque.

Dos mecanismos: la misma siguiente bloque de código, hay un mecanismo; diferentes bloques de código, siga otro mecanismo.

1. El mismo mecanismo de caché bloque siguiente código:

Cuando el comando para inicializar el objeto encontrado en el mismo bloque de código va a inicializar las variables y valores en un diccionario, de cara a una nueva variable, primer diccionario para encontrar allí el mismo valor, si hay , el uso repetido del valor.

Ventajas: mejorar el rendimiento, ahorro de memoria

adecuado

int (float): cualquier número en el mismo bloque de código se multiplexan.

i1 = 1
i2 = 1
i3 = 1
print(i1 is i2 is i3)
# 结果为True

str:

Cadena no está satisfecho se obtienen mecanismo de código de multiplicación bloque de caché:

s1 = '三上悠亚 aloha\t!@#*('
s2 = '三上悠亚 aloha\t!@#*('
s3 = '三上悠亚 aloha\t!@#*('
print(s1 is s2 is s3)
# 结果为True

Cuando el factor multiplicador es 1, satisfaciendo cualquier mecanismo de código de cadena de bloque de caché:

s1 = '三上悠亚 aloha\t!@#*(' * 1
s2 = '三上悠亚 aloha\t!@#*(' * 1
s3 = '三上悠亚 aloha\t!@#*(' * 1
print(s1 is s2 is s3)
# 结果为True

Multiplicador> = 2: cadena contiene sólo letras minúsculas, números subrayados, multiplicando por la longitud total de <= 20, para cumplir con mecanismo de código de bloque de caché:

s1 = '三上悠亚 aloha\t!@#*(' * 2
s2 = '三上悠亚 aloha\t!@#*(' * 2
s3 = '三上悠亚 aloha\t!@#*(' * 2
print(s1 is s2 is s3)
# 结果为False

s1 = 'Aloha_' * 3
s2 = 'Aloha_' * 3
s3 = 'Aloha_' * 3
print(s1 is s2 is s3)
# 结果为True

bool: verdadero y falso camino 1,0 existirán en el diccionario, y la reutilización

2. El mecanismo de caché en diferentes bloques de código: piscina pequeña de datos

Pueden ser multiplexados cadenas digitales de diferentes bloques de código de las -5 en 256 y con una regla determinada.
Ventajas: mejorar el rendimiento, ahorro de memoria

En tercer lugar, la colección (juego)

Colección es un proceso iterativo, desordenado, la estructura de datos no puede contener elementos duplicados
La recolección de datos es un tipo de contenedor
Elementos de la colección son elemento inmutable (hashable), y la colección en sí es un tipo de datos variable.

Es decir, no hay lista (lista) establece, el diccionario (dict), una colección (juego), se puede poner un digital (int), una cadena (str), Boolean (bool)
El papel de la colección: 1 Lista de deduplicación

2. Prueba de la relación: intersección, unión, diferencia

Uso de la lista para establecer la propiedad al peso, pero no puede mantener la secuencia original

list1 = [1, 2, 2, 2, 2, 3, 3, 3, 'jason', 'jason']
set1 = set(list1)
list1 = list(set1)
print(list1)

Conjunto de CRUD

#集合的创建
set1 = {1, 3, 'jason', True, False}
print(set1)


set1 = {'jason', 'carly', 'aloha'}
# 增
# add()
set1.add('sb')
print(set1)
# update()迭代增加
set1.update('abc')
print(set1)

# 删
# remove()按照元素删除
set1.remove('aloha')
print(set1)
# pop()随机删除
set1.pop()
print(set1)
# clear()清空集合
set1.clear()
print(set1)
# del 删除集合
del set1

# 改（变相改值，先删再加）

Colección de intersección, unión, diferencia, intersección anti

set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 5, 6, 7}

# 交集
print(set1 & set2)
print(set1.intersection(set2))

# 并集
print(set1 | set2)
print(set1.union(set2))

# 差集
print(set1 - set2)
print(set2 - set1)
print(set1.difference(set2))
print(set2.difference(set2))

# 反交集
print(set1 ^ set2)
print(set1.symmetric_difference(set2))

Subconjunto del conjunto, un superconjunto

set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5, 6}

# 子集
print(set1 < set2)
print(set1.issubset(set2))

# 超集
print(set2 > set1)
print(set2.issuperset(set1))

En cuarto lugar, la profundidad copia

1. Los operadores de asignación

Al igual que el operador de asignación para hacer dos listas de direcciones de memoria, esa misma identificación, por lo que si las modificaciones list1 o modificar lista2, otra lista cambiará

list1 = [1, 2, 3, [11, 22, 33]]
list2 = list1
print(id(list1) == id(list2))
# 结果为True，此时list1 和list2 的id是一样的
list1.insert(-1, 666)
list2.pop(1)
list1[-1].append(888)
list2[-1].append(999)
print(list1)
print(list2)   # list1 和 list2 结果一样

2. copia superficial

list1 = [1, 2, [11, 22]]
list2 = list1.copy()
print(list1 == list2)  # True
print(id(list1) == id(list2))  # False
# 浅copy: 值相同，但是id不同

Cuando se creó lista1, se creó en la memoria 1, 2 y [11, 22] estos tres elementos,
que se puede entender como estos tres elementos en un cierto espacio en la memoria.
La lista1 ID 11111111 supone, es tres ranuras hacia el espacio de 1,2, [11, 22]
En este momento, los lista1 copia obtenida pálido 22222222 id de la list2,
tres ranuras son también list2 apunta al espacio 1,2, [11, 22]

# 情况一、如果我们在list1这个列表进行修改，比如追加一个元素，删除一个元素,甚至是清空list1，仅仅是对id为11111111的list1进行了修改，而放在该空间中的1，2，[11, 22]并没有变化。
# 此时list2中的各个槽位指向的仍是该空间中的1，2，[11, 22],因此list2不会改变。
list1 = [1, 2, [11, 22]]
list2 = list1.copy()
list1.append(3)
print(list1)  # 结果为[1, 2, [11, 22], 3]
print(list2)  # 结果为[1, 2, [11, 22]]

# 情况二、如果我们对list1中的[11, 22]进行修改，此时对应在内存中的[11, 22]也会改变。
# 而list2中的[11, 22]也是指向内存中的[11, 22], 内存中的[11, 22]改变了，因此list2中的[11, 22]也随之改变
list1 = [1, 2, [11, 22]]
list2 = list1.copy()
list1[2].append(666)
print(list1)
print(list2)

3. copia profunda necesidad de importar el módulo de copia

import copy
list1 = [1, 2, [11, 22]]
list2 = copy.deepcopy(list1)
print(list1 == list2)
print(id(list1) == id(list2))
# 和浅copy一样，值相同，内存地址不同

tiempo lista1 se crea se crea en la memoria 2, [11, 22] de los tres elementos, como podemos entender estos tres elementos en un espacio de memoria que
se supone ID lista1 de 11.111.111, es tres ranuras que apuntan a un espacio dentro de la 1,2, [11, 22]
en este momento, la profundidad copia lista1 obtenido de la ID 22222222 Lista2, copia superficial es diferente, en este caso se crea una memoria 1,2 , [11, 22] de los tres elementos, y en la que dos espacio de memoria
en este momento hay tres ranuras list2 dos puntos dentro del espacio 2, [11, 22]
en este momento, para modificar la lista1, no importa cómo modificado, lista2 es siempre la misma, ya que lista1 y lista2 en este momento no existe una asociación

import copy
list1 = [1, 2, [11, 22]]
list2 = copy.deepcopy(list1)
list1.append(3)
list1[2].append(666)
print(list1)  # 结果为[1, 2, [11, 22, 666], 3]
print(list2)  # 结果为[1, 2, [11, 22]]

Nota: Lo anterior apreciarse que dichos dos espacios son 1,2, [11, 22], que es el caso normal de una copia en profundidad.
Pero la pitón está optimizado para ahorrar espacio en la memoria, en Python, int (float), str, bool tipo de datos que hay un inmutable sólo en la memoria, ya que son el mismo id.

pitón day6 base