1.listEttupleLa différence entre

list Est une longueur variable,Séquence avec contenu variable
tuple Est une longueur immuable,Une séquence de contenu immuable,Mais,Si une liste ou une autre séquence variable est appliquée dans un Tuple,Parce que les listes et autres séquences variables sont variables,Donc une fois la liste changée,,La liste des tuples change également,Provoque un changement de Tuple.

2.Quelles sont les séquences apprises?

str String
byte Octets
tuple Tuple
list Liste
dict Dictionnaire

3.listUtilisation de toutes les méthodes

 |  append(self, object, /)
 |      Append object to the end of the list.
 |  	# InlistAjouter un élément à la fin de
    	""" list_var = [1, 2, 3] list_var.append(4) print(list_var) """
 |  clear(self, /)
 |      Remove all items from list.
 |  	# SupprimerlistTous les éléments de
		list_var = [1, 2, 3]
        list_var.clear()
        print(list_var)

 |  copy(self, /)
 |      Return a shallow copy of the list.
 |  	# 
 |  count(self, value, /)
 |      Return number of occurrences of value.
 |  	#  Nombre d'occurrences de l'élément statistique （ Aucune erreur ne sera signalée si elle n'est pas trouvée au moment de l'exécution ）
    	""" list_var = [1, 2, 3, 1] number = list_var.count(1) print(number) """
 |  extend(self, iterable, /)
 |      Extend list by appending elements from the iterable.
    	#  Liste des extensions   Mettre un objet itérable （Séquence）Ajouter àlistEn arrière.
        """ list_var = [1, 2, 3, 1] str_var = "123456789" byte_var = b'123456789' tuple_var = (1, 2, 3, 4) list_var1 = [1, 2, 3, 1] list_var1.extend(str_var) print(list_var1) list_var1.extend(list_var) print(list_var1) list_var1.extend(byte_var) print(list_var1) list_var1.extend(tuple_var) print(list_var1) """
 |  
 |  index(self, value, start=0, stop=9223372036854775807, /)
 |      Return first index of value.
 |      #  Renvoie l'indice de la première occurrence de l'élément （Si la valeur n'existe pas,Des erreurs seront signalées）
 |      Raises ValueError if the value is not present.
		""" list_var1 = [1, 2, 3, 1] print(list_var1.index(1, 1, 4)) """
 |  	
 |  insert(self, index, object, /)
 |      Insert object before index.
 |  	#  Ajouter un élément à l'indice spécifié （index,value）
    	""" list_var1 = [1, 2, 4] list_var1.insert(2, 3) print(list_var1) """
 |  pop(self, index=-1, /)
 |      Remove and return item at index (default last).
		#  La valeur de l'indice correspondant apparaît 
 |      """ list_var = [1, 2, 3] number = list_var.pop() print(number) print(list_var) list_var1 = [1, 2, 3] number1 = list_var1.pop(1) print(number1) print(list_var1) """
 |      Raises IndexError if list is empty or index is out of range.
 |  
 |  remove(self, value, /)
 |      Remove first occurrence of value.
 |      # Supprimer les valeurs entrantes（Le premier）,La valeur n'existe pas,Une erreur sera signalée
    	""" list_var = [1, 2, 2, 3] list_var.remove(2) print(list_var) """
 |      Raises ValueError if the value is not present.
 |  
 |  reverse(self, /)
 |      Reverse *IN PLACE*.
 |  	#  Inversion inversée (Ne pas trier)
		""" list_var = [1, 3, 2] list_var.reverse() print(list_var) """
 |  sort(self, /, *, key=None, reverse=False)
 |      Sort the list in ascending order and return None.
 |      # Tri vers l'avant
    	""" list_var = [1, 3, 5, 4, 6, 9, 8] list_var.sort() print(list_var) """
        #  Changer les règles par vous - même 
        """ def sort1(str_data): return str_data[-1], str_data[-2], str_data[-1] # return str_data[-1] str_list = ['banana', "drain", "pineapple", "cherry", "strawberry", "kiwifruit", "peach", "grape"] str_list.sort() print(str_list) str_list.sort(reverse=True) print(str_list) str_list.sort(key=sort1) print(str_list) """
 |      The sort is in-place (i.e. the list itself is modified) and stable 	(i.e. the order of two equal elements is maintained).
 |      
 |      If a key function is given, apply it once to each list item and sort them,ascending or descending, according to their function values.
 |      
 |      The reverse flag can be set to sort in descending order.

extend Et appendLa différence entre

​ extend Est de stocker chaque élément d'une séquence dans une liste

​ append Est de mettre une séquence （Un élément） Stocker comme élément dans la liste

tuple_var = (1, 2, 3, 4)
list_var1 = [1, 2, 3, 1]
list_var1.extend(tuple_var)
print(list_var1)
list_var1.append(tuple_var)
print(list_var1)

4.Convertir les tuples et les listes en dictionnaire

dict() key: value Séquence( Chaque élément contient une séquence de deux éléments ) Il devrait contenir deux parties , Une partie correspond au dictionnaire key, Une partie correspond au dictionnaire value

tuple_var = ((1, 2), (3, 4))
list_var = [[1, 2], [3, 4]]
dict_var1 = dict(tuple_var)
dict_var2 = dict(list_var)
print(dict_var1)
print(dict_var2)

5.dictUtilisation de toutes les méthodes

	clear(...)
 |      D.clear() -> None.  Remove all items from D.
		# Vider le dictionnaire
    	""" dict_var = {1: 2, 2: 3} print(dict_var) dict_var.clear() print(dict_var) """
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
		# Copie
 |  
 |  get(self, key, default=None, /)
 |      Return the value for key if key is in the dictionary, else default.
 |  	# Je l'ai.keyPour？Valeur de,SikeyN'existe pas,RetourNone
    	""" dict_var = {1: 2, 2: 3} print(dict_var) var = dict_var.get(1) var1 = dict_var.get(3) print(var, var1) """
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
        #  Renvoie toutes les paires de valeurs clés dans le Dictionnaire 
 |  	""" a = {'Mathématiques': 95, 'Langues': 89, 'Anglais': 90} print(a.items()) """
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  	#  Utilisé pour renvoyer toutes les clés du Dictionnaire .
    	""" a = {'Mathématiques': 95, 'Langues': 89, 'Anglais': 90} print(a.keys()) """
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  	#  Dans le dictionnaire pop - up keyLa valeur correspondante
		""" dict_var = {1: (1, 2, 3), 2: 3} var = dict_var.pop(1) print(var) print(dict_var) """


 |  popitem(self, /)
 |      Remove and return a (key, value) pair as a 2-tuple.
 |      #  Pop up the last Key value Pair in the dictionary , Et pour les tuples 
    	''' dict_var = {1: (1, 2, 3), 2: 3, 7: 4} var = dict_var.popitem() print(var) print(dict_var) '''
 |      Pairs are returned in LIFO (last-in, first-out) order.
 |      Raises KeyError if the dict is empty.
 |  
 |  setdefault(self, key, default=None, /)
 |      Insert key with a value of default if key is not in the dictionary.
 |      
 |      Return the value for key if key is in the dictionary, else default.
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
		#  Renvoie la valeur de toutes les clés du Dictionnaire 
    	""" a = {'Mathématiques': 95, 'Langues': 89, 'Anglais': 90} print(a.values()) """
   

6.listOudictCroquis à copie peu profonde avec explication de code

b = a.copy(): Copie peu profonde, a Et b Est un objet autonome,Mais leurs sous - objets pointent toujours vers l'objet unifié（C'est une citation.）
a,b Tant que l'un d'eux change , Les deux ont changé

a = {
    1: [1,2,3]}
b = a.copy()
print(a, b)
# {1: [1, 2, 3]}, {1: [1, 2, 3]}
a[1].append(4)
print(a, b)
# {1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]}
print(id(a[1]), id(b[1]))
# 2698953608384, 2698953608384

b = copy.deepcopy(a): Copie en profondeur, a Et b Copie complète de l'objet parent et de ses enfants,Les deux sont totalement indépendants.
a, b Peu importe si l'un d'eux change ,Aucune influence mutuelle.
Copie profonde

import copy
a = {
    1: [1,2,3]}
b = copy.deepcopy(a)
print(a, b)
# {1: [1, 2, 3]}, {1: [1, 2, 3]}
a[1].append(5)
print(a, b)
# {1: [1, 2, 3, 4, 5]}, {1: [1, 2, 3, 4]}
print(id(a[1]), id(b[1]))
# 2307260074176 2307259917760