apprentissage en python jour6

bloc de code, le mécanisme de mise en cache, la profondeur des copies, un ensemble de

id est, ==

id: numéro d'identification peut être une analogie entre, unique, si on les compare avec les mêmes données d'identification.

#获取数据的内存地址(随机的地址:内存临时加载，存储数据，当程序运行结束后，内存地址即被丢弃）：
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 déterminé id sont les mêmes ( « » == « » juge si la valeur de la même )

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

Le même identifiant, nécessairement la même valeur, la même valeur, identifiant pas nécessairement la même chose.

Bloc: bloc de code de programme python est construit. Block est un programme de script python, qui est exécuté comme une unité. Un module, une fonction, une classe, un fichier sont tous les blocs de code. Et chaque commande comme entrée de commande en mode interactif est un bloc de code. Deux mécanismes : Si dans le même bloc de code en utilisant le même mécanisme pour changer le bloc de cache. Si les blocs de code sont différents, le mécanisme réside petit pool de données est utilisé .
- mécanisme caching avec un bloc de code: contenu du mécanisme: Python lors de l' exécution d' une commande pour initialiser le même bloc de l'objet, vérifie si la valeur existe déjà, le cas échéant, il sera réutilisé. En d' autres termes: Lorsque vous effectuez le même bloc, commande rencontré pour initialiser l'objet, il sera initialisé avec la valeur de cette variable est stockée dans un dictionnaire, en face de nouvelles variables seront d' abord des enregistrements de requête dans le dictionnaire, Si vous avez le même dossier il réutilisera cette valeur avant le dictionnaire, qui est: le même identifiant.
  
  Convient : int (un flotteur) :: un nombre quelconque dans le même bloc de code sont multiplexés.
  
  STR : La quasi - totalité des chaînes se conformer mécanisme de mise en cache (1, chaîne n'a pas été obtenu multiplication satisfont mécanisme de mise en cache ,, chaîne de blocs de codes obtenus en multipliant deux cas: 1. le facteur de multiplicateur vaut 1, une chaîne mécanisme de mise en cache de bloc de code de rencontre, 2. multiplicateur> = 2, contient des majuscules et des lettres minuscules seulement, des chiffres, des traits de soulignement, la longueur totale de <= 20, satisfaisant le bloc de code de mécanisme de cache)
```
s1 = 'iam'*1
s2 = 'iam'*1
print(s1 is s2)
>>>True
```
  BOOL : chemin Vrai et Faux 1,0 existera dans le dictionnaire, et la réutilisation.
  
  Avantages : la possibilité d'augmenter la chaîne de nombre, entier, les performances de traitement de caractères dans le temps et l' espace, exige la même chaîne de valeur, entier, pris directement à partir d' un « dictionnaire » sont multiplexées, pour éviter la création et la destruction fréquente, d' améliorer l' efficacité, la mémoire de sauvegarde.
- Dans un autre mécanisme de cache de bloc de code: petit pool de données, également connu sous forme de petits entiers mécanisme de mise en cache, ou analogue est appelé mécanisme arrêt. Python automatiquement entier -5-256 ont été mis en cache , lorsque vous ces entier attribué à la variable, et ne sera pas recréer l'objet, mais l'utilisation de déjà créé l'objet de cache.
  
  chaîne de python sera certaines règles dans la chaîne piscine réside , créez une copie, lorsque vous ces chaînes assignées à la variable, et ne sera pas recréer l'objet, mais utilisé dans une chaîne réside dans la piscine est créée il objets.
  
  　　En fait, les deux chaînes cache ou à Réside sont faits d'une optimisation de python, est à l'entier de la chaîne, et certaines règles de ~ 5-256, mettre dans un « pool » (conteneurs, ou dictionnaires), si les variables de programme qui indiquent une chaîne ou un nombre entier compris dans ces plages, alors qu'il a cités directement dans le « pool », l'implication est de créer une mémoire de.
  
  Convient pour : int (float) : Nous savons tous que pour les entiers, la gamme de la petite piscine de données est de -5 à 256, si plusieurs variables pointent vers le même (dans cette gamme) numéros, ils sont en mémoire point est une adresse de mémoire.
```
# pycharm 通过运行文件的方式执行下列代码：  这是在同一个文件下也就是同一代码块下，采用同一代码块下的缓存机制。
i1 = 1000
i2 = 1000
print(i1 is i2)  # 结果为True 因为代码块下的缓存机制适用于所有数字
>>>True


#通过交互方式中执行下面代码,这是不同代码块下，则采用小数据池的驻留机制。
>>> i1 = 1000
>>> i2 = 1000
>>> print(i1 is i2)
False  # 不同代码块下的小数据池驻留机制 数字的范围只是-5~256.
```
  STR :. D' une longueur de chaîne de 0 ou 1, le mécanisme par défaut sont employés résident (piscine petite données). 2. La longueur de la chaîne> 1, et ne contient que des lettres minuscules, des chiffres, soulignement, la valeur par défaut résidera. 3. Chaîne multiplication obtenu sous deux conditions: un multiplicateur est égal à 1, la chaîne répond à la règle, réside par défaut. 2. Multiplicateur> = 2: ne contient que des lettres majuscules et minuscules, des chiffres, soulignement, la longueur totale <= 20, réside par défaut.
```
#4.指定驻留
from sys import intern
a = intern('hello!@'*20)
b = intern('hello!@'*20)
print(a is b)
>>>True
#指定驻留是你可以指定任意的字符串加入到小数据池中，让其只在内存中创建一个对象，多个变量都是指向这一个字
```
  bool valeur est Vrai, Faux, peu importe combien de variables que vous créez le point sur True, False, il n'y a qu'un seul dans sa mémoire.
```
# 虽然在同一个文件中，但是函数本身就是代码块，所以这是在两个不同的代码块下，不满足小数据池（驻存机制），则指向两个不同的地址。
def func():
    i1 = 1000
    print(id(i1))  # 2288555806672

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

func()
func2()
```
  Avantages : la capacité d'élever une chaîne, un entier de traitement statistiques de performance en temps et l' espace nécessaire à la valeur de la même chaîne, entier, lorsqu'ils sont amenés directement à partir d' un « pool » en cours d' utilisation, pour éviter de fréquentes créer et de détruire, d' améliorer l' efficacité, la mémoire de sauvegarde

Article de référence: https: //www.cnblogs.com/jin-xin/articles/9439483.html

Collection (set): conteneur de type de données, ce qui nécessite que les éléments de données sont immuables (hashable), mais qui est lui-même un type de données variables (non hachée). Les ensembles sont ordonnés. Dans {} données stockées.

Rôle: à nouveau la liste, les relations essai (intersection, union, ...)

. / 1 la création d'une collection:

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

/ 2 par :. Ajouter mise à jour () # itérations augmente, il est répété Déduplication

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

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

/ 3 supprimé Supprimer :. () (Supprimer élément selon, pop () supprimé au hasard, clear () Suppression du jeu de collection vide del

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 changé: augmentation de suppression puis

Payez, et,

/ 1 intersection. (& Or intersection) une collection de quelques éléments communs

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

/ 2. Union. (| Ou union) l'ensemble de tous les éléments

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

/ 3 ensembles de différence. (- ou différence), l'ensemble précédent d'éléments uniques

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

/ 4. Anti intersection. (Le symmetric_difference ou ^) unique à chaque ensemble d'éléments

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. Sous-ensemble de surensemble

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 () permet la collecte devient le type immuable

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

profondeur copie

copie superficielle,

```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。
```

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

Copie complète, copie besoin de module d'importation
```
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']]
#列表第一个一个的槽位，它储存的是对象的内存地址。深拷贝会创建一个新的对象的内存地址。
```
python fait une profonde optimisation de copie, les types d'objets de données immuables suivent la même adresse mémoire, pour recréer un type d'adresse de mémoire de données variables.

copie superficielle: (liste, dict), le type de données variables imbriquées est le même.

Copie complète: (liste, dict), le type de données variables imbriquées ne sont pas les mêmes.

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

apprentissage en python jour6

Je suppose que tu aimes