pitón day6 aprendizaje basado

bloque de código, el mecanismo de almacenamiento en caché, la profundidad de copias, un conjunto de

Identificación, es decir, ==

id: número ID puede ser analogía a, único, si se compara con los mismos datos de identificación.

#获取数据的内存地址(随机的地址:内存临时加载，存储数据，当程序运行结束后，内存地址即被丢弃）：
i = 'a'
print(id(i))
>>>2047746570672  
print(id(i))
>>>2020558633392
print(id(i))
print(id(i))
>>>1908036008368
1908036008368

l1 = [1,2,3]
l2 = [1,2,3]
print(l1 == l2)
>>>True    #比较的是两边的值是否相等。

está decidido ID son los mismos ( '' == '' jueces si el valor de la misma )

l1 = [1,2,3]
l2 = [1,2,3]
print(l1 is l2)
>>>False   #判断的是内存地址是否相同。

print(id(l1))
print(id(l2))
>>>2648963830216
2648963830728

l1 = [1,2,3]
l2 = l1
print(l1 is l2)
print(id(l1))
print(id(l2))
>>>True
2053863395784
2053863395784


s1 = 'iam'
s2 = 'iam'
print(s1 is s2)
>>>True

print(id(s1))
print(id(s2))
>>>2188534085552
2188534085552

El mismo ID, necesariamente el mismo valor, el mismo valor, de la identificación no necesariamente el mismo.

Bloquear: Pitón bloque de código de programa se construye. Block es un programa script en Python, que se ejecuta como una unidad. Un módulo, una función, una clase, un archivo son todos los bloques de código. Y cada comando como un modo interactivo de entrada de comandos es un bloque de código. Dos mecanismos : Si en el mismo bloque de código que utiliza el mismo mecanismo para cambiar el bloque de caché. Si los bloques de código son diferentes, el mecanismo reside se utiliza la piscina pequeña de datos .
- Almacenamiento en caché de mecanismo con un bloque de código: contenido Mecanismo: el Python al ejecutar un comando para inicializar el mismo bloque del objeto, comprueba si el valor ya existe, si está presente, se puede reutilizar. En otras palabras: Al realizar el mismo bloque, comandos encontrado para inicializar el objeto, que será inicializado con el valor de esta variable se almacena en un diccionario, en vista de las nuevas variables primeros registros de la consulta en el diccionario, Si tiene el mismo registro a continuación, se volverá a utilizar este valor antes del diccionario, que es: el mismo id.
  
  Adecuado : int (un flotador) :: cualquier número en el mismo bloque de código se multiplexan.
  
  STR : Casi todas las cadenas cumpliría el almacenamiento en caché mecanismo (1, cadena no se obtiene la multiplicación mecanismo de caché satisfacen ,, serie de bloques de código obtenidos por la multiplicación de dos casos: 1. el factor multiplicador es 1, cualquier cadena el almacenamiento en caché mecanismo para bloque de código se encuentran, 2. multiplicador> = 2, contiene sólo letras mayúsculas y minúsculas, números, subrayados, la longitud total de <= 20, que satisfacen el bloque de almacenamiento en caché de código de mecanismo)
```
s1 = 'iam'*1
s2 = 'iam'*1
print(s1 is s2)
>>>True
```
  BOOL : verdadero y falso camino 1,0 existirá en el diccionario, y la reutilización.
  
  Ventajas : la capacidad de aumentar la cadena de números, número entero, el rendimiento de procesamiento de caracteres en tiempo y espacio; requiere la misma cadena de valor, número entero, cuando se toma directamente de un 'diccionario' se multiplexan, para evitar la creación y la destrucción frecuente, mejorar la eficiencia, Guardar la memoria.
- En un mecanismo de bloque de código caché diferente: la piscina pequeña de datos, también conocido como el almacenamiento en caché mecanismo enteros pequeños, o similares se llama permanencia mecanismo. Python automáticamente número entero de -5 a la tecnología 256 fueron en caché , cuando éstos entero asignado a la variable y no se vuelve a crear el objeto, pero el uso del ya creado el objeto de caché.
  
  cadena de Python será ciertas reglas en la cadena reside piscina , crear una copia, cuando estas cadenas asignados a la variable, y no volvió a crear el objeto, sino que se utiliza en una cadena reside en la piscina se crea se objetos.
  
  　　De hecho, tanto las cadenas de caché oa la piscina reside el son de una optimización del pitón, es número entero de cuerdas, y ciertas reglas de ~ 5-256, poner en un contenedor (o diccionarios) 'piscina', si las variables del programa que apuntan a una cadena o un entero dentro de estos rangos, luego citó directamente en el 'pool', la implicación es crear una memoria de.
  
  Adecuado para : int (float) : Así que todos sabemos que para los enteros, el intervalo del grupo pequeño de datos es de -5 a 256, si múltiples variables apuntan a la misma (dentro de este rango) números, que están en la memoria punto es una dirección de memoria.
```
# pycharm 通过运行文件的方式执行下列代码：  这是在同一个文件下也就是同一代码块下，采用同一代码块下的缓存机制。
i1 = 1000
i2 = 1000
print(i1 is i2)  # 结果为True 因为代码块下的缓存机制适用于所有数字
>>>True


#通过交互方式中执行下面代码,这是不同代码块下，则采用小数据池的驻留机制。
>>> i1 = 1000
>>> i2 = 1000
>>> print(i1 is i2)
False  # 不同代码块下的小数据池驻留机制 数字的范围只是-5~256.
```
  STR residente de una longitud de cadena de 0 o 1, se empleó el mecanismo por defecto (la piscina pequeña de datos):.. 2. La longitud de la cadena> 1, y sólo contiene letras minúsculas, números, subrayado, el valor predeterminado residirá. 3. multiplicación cadena obtiene bajo dos condiciones: un multiplicador es 1, los satisface cadena la regla, reside el defecto. 2. Multiplicador> = 2: contiene sólo letras mayúsculas y minúsculas, números, subrayados, la longitud total de <= 20, reside predeterminados.
```
#4.指定驻留
from sys import intern
a = intern('hello!@'*20)
b = intern('hello!@'*20)
print(a is b)
>>>True
#指定驻留是你可以指定任意的字符串加入到小数据池中，让其只在内存中创建一个对象，多个变量都是指向这一个字
```
  bool valor es verdadero, falso, no importa cuantas variables que se crea el punto en Verdadero, Falso, entonces sólo hay una en su memoria.
```
# 虽然在同一个文件中，但是函数本身就是代码块，所以这是在两个不同的代码块下，不满足小数据池（驻存机制），则指向两个不同的地址。
def func():
    i1 = 1000
    print(id(i1))  # 2288555806672

def func2():
    i1 = 1000
    print(id(i1))  # 2288557317392

func()
func2()
```
  Ventajas : la capacidad de levantar un poco de cadena, entero procesamiento de las cifras de rendimiento en tiempo y espacio; necesidad de valor de la misma cadena, entero, cuando se traslada directamente de un 'pool' en uso, para evitar frecuentes crear y destruir, mejorar la eficiencia, Guardar la memoria

Artículo de referencia: https: //www.cnblogs.com/jin-xin/articles/9439483.html

Colección (conjunto): tipo de datos contenedor, que requiere que los elementos de datos son inmutables (hashable), pero que en sí es un tipo de datos variable (no hash). Los conjuntos son desordenada. En {} datos almacenados.

Papel: para volver a la lista; prueba de las relaciones (intersección, unión, ...)

. / 1 la creación de una colección:

set = {1,2，'a'}
#空集合的表示：
set1 = set()   #set1 = {}表示空字典

/ 2 por :. Agregar actualización (deduplicación), # repeticiones aumenta, se repite

set1 = {1,2}
set1.add('a')
print(set1)
>>>{'a', 1, 2}  #集合无序

set1.update('asdfdsa')
print(set1)
>>>{'a', 1, 2, 'f', 's', 'd'}

/ 3 :. borrado Eliminar () (Eliminar elemento de acuerdo, pop () elimina al azar, claro () Retire conjunto de la colección del vacío

set1 = {'a', 1, 2, 'f', 's', 'd'}
set1.remove('a')
print(set1)
>>>{1, 2, 's', 'f', 'd'}

set1.pop()
print(set1)
>>>{2, 's', 'f', 'd'}

set1.clear()
print(set1)
>>>{}

del set1

. / 4 cambiado: aumento de borrado y luego

Pago y,

/ 1 intersección. (Y o intersección) una colección de algunos elementos comunes

set1 = {1,2,3}
set2 = {2,3,4}
print(set1 & set2) #or print(set1.intersection)
>>>{2,3}

/ 2. Unión. (| O unión) el conjunto de todos los elementos

set1 = {1,2}
set2 = {2,3}
print(set1 | set2) #or print(set1.union(set2))
>>>{1,2,3}

/ 3 series diferencia. (- o diferencia), el conjunto anterior de elementos únicos

set1 = {1,2,3,4,5}
set2 = {2,4,6}
print(set1 - set2) #or print(set1.difference(set2))
>>>{1,3,5}

/ 4. intersección anti. (El symmetric_difference o ^) único para cada conjunto de elementos

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
print(set1 ^ set2) #or print(set1.symmetric_difference(set2))
>>>{1,2,6,7}

/ 5. Subconjunto de superconjunto

set1 = {1,2}
set2 = {1,2,3}
print(set1 < set2)
>>>True
print(set1.issubset(set2))    #set1是set2的子集
>>>True

print(set2 > set1)
>>>True
print(set2.issuperset(set1)) #set2是set1的超集
>>>True

/ 6. frozenset () permite que la colección se convierte en tipo inmutable

s = frozenset('qweasd')
print(s,type(s))
>>>frozenset({'q', 'e', 'w', 's', 'a', 'd'}) <class 'frozenset'>

profundidad de una copia

copia superficial,

```python
l1 = [1,2]
l2 = l1
l1.append(3)
print(l2)
>>>[1,2,3] #l1,l2两变量指向同一个id（数据）


#浅copy
l3 = [1,2,['a']]
l4 = l3.copy()
l3.append(3)   
print(l3)
>>>[1,2,['a'],3]
print(l4)
>>>[1,2,['a']]


l3[-2].append(4)    #or l4[-1].append(4)
print(l3)
>>>[1, 2, ['a', 4], 3]
print(l4)  
>>>[1,2,['a',4]] #l4与l3列表中的数据id是相同的，但l4与l3列表id不相同,即l3中的每个元素与l4中的每个元素使用的是相同的一个id，但l4与l3用的不是同一个id。
```

其实列表第一个一个的槽位，它储存的是对象的内存地址。浅拷贝**仍然使用原来的对象的内存地址**。对储存的可变对象可以进行更改；若改变不可变类型，则改变的不是不可变类型本身，而是变量的指向关系

copia profunda, copiar necesidad de módulo de importación
```
import copy
l3 = [1,2,['a']]
l4 = copy.deepcopy(l3)
l3[-1].append(3)
print(l3)
>>>[1,2,['a',3]]
print(l4)
>>>[1,2,['a']]
#列表第一个一个的槽位，它储存的是对象的内存地址。深拷贝会创建一个新的对象的内存地址。
```
pitón hizo una optimización copia profunda, los tipos de objetos de datos inmutables siguen la misma dirección de memoria, sólo para volver a crear un tipo de dirección de memoria de datos variables.

copia superficial: (list, dict), anidada tipo de datos variable es la misma.

copia profunda: (list, dict), anidada tipo de dato variable no es la misma.

l1 = [1,2,['a']]
l2 = l1[:]
l1[-1].append(3)
print(l2)
>>>[1,2,['a',3]]  #切片是浅copy

pitón day6 aprendizaje basado

Supongo que te gusta