L'explication la plus détaillée de Python sur les types de données

Tutoriel PythonLa colonne présente les types de données associés

Recommandations d'apprentissage gratuites associées : Tutoriel Python (Vidéo )

Chaîne

Pièges des chaînes :

Une chaîne entre guillemets triples sans chaîne entre guillemets doubles au milieu sera sortie comme un double dans l'interpréteur Citations

S'il y a une chaîne de guillemets doubles au milieu d'une chaîne de guillemets triples, elle sera affichée sous forme de guillemets simples

dans l'interpréteur. La chaîne est stockée dans la mémoire sous la forme.

caractères. Opérations sur les chaînes :

Entrée : input()

Sortie : print()

Index : str[index]

Obtenir l'adresse : id(str)

Slicing : str[start: end: step] (taille de pas négative - sélectionner dans l'ordre inverse ; la direction de sélection doit être cohérente, sinon les données ne peuvent pas être sélectionnées)

Find : find() : Syntaxe : str.find(substr, start, end) Remarque : La valeur de retour est la valeur d'index de la première occurrence si la sous-chaîne n'existe pas, elle renvoie -1 et non ; une erreur sera signalée.

Par exemple : mystr = 'hello world et itcast et itheima et Python' print(mystr.find('and')) # 12 print(mystr.find ('and',15,30)) # 23 print( mystr.find('ands')) # -1 la sous-chaîne ands n'existe pas index() :

Syntaxe : str.index(substr, start, end) La valeur de retour est la première La valeur d'index qui apparaît ; si la sous-chaîne n'existe pas, une erreur sera signalée Par exemple : mystr = 'hello world et itcast. et itheima et Python'print(mystr.index('and')) # 12 print(mystr .index('and',15,30)) # 23print(mystr .index('ands')) #Si la sous-chaîne de recherche d'index n'existe pas, une erreur sera signalée count() : Compte le nombre de fois qu'une sous-chaîne apparaît Syntaxe : str.index(substr, tart , fin) Remarque : La valeur de retour est le nombre de fois que la sous-chaîne apparaît. Si la sous-chaîne n'existe pas, elle renvoie 0 et aucune erreur ne sera signalée. Par exemple : mystr = 'hello world et itcast et itheima et Python' print. (mystr.count('and',15,30)) # 1 print(mystr.count('and')) # 3print(mystr .count('and') )) # 0 rfind() : La même fonction que find(), mais le sens de recherche commence par la droite rindex() : La même fonction que index(), mais l'accès à la recherche se fait par la droite Commencez par le côté

Modify:replace() : Syntaxe de remplacement : str.replace (ancienne sous-chaîne, nouvelle sous-chaîne, nombre de remplacements) Remarque : Si vous n'écrivez pas le nombre de remplacements, la valeur par défaut Toutes les anciennes sous-chaînes seront remplacées. Si le nombre de substitutions dépasse le nombre d'occurrences de la sous-chaîne, le nombre de substitutions sera le nombre d'occurrences de la sous-chaîne. Après avoir appelé la fonction de remplacement, on constate que les données de la chaîne d'origine n'ont pas été modifiées. Les données modifiées sont la valeur de retour de la fonction de remplacement. Description : La chaîne est un type de données immuable. Par exemple : mystr = 'hello world. et itcast et itheima et Python ' new_str = mystr.replace('and','he') new_str = mystr.replace('and','he',1) new_str = mystr.replace('and','he' ,10) split() : Syntaxe de fractionnement : str.split (caractère fractionné, num) Remarque : La valeur de retour est une liste. Le caractère fractionné manquant num représente le nombre d'occurrences du caractère fractionné, c'est-à-dire le nombre de données. renvoyé dans le futur est num+1

Par exemple mystr = 'hello world et itcast et itheima et Python' list1 = mystr.split('and') list1 = mystr.split('and',2) join() :

Syntaxe de fusion : caractères Ou sous-chaîne join (séquence de plusieurs caractères) Remarque : Utiliser une sous-chaîne ou une sous-chaîne pour fusionner des chaînes signifie fusionner plusieurs chaînes en une nouvelle chaîne. Par exemple : mylist = ['. aa','bb ','cc'] new_str = '...'.join(mylist) print(new_str)

Conversion de casse capitalize() : Convertit le premier caractère de la chaîne en majuscule Syntaxe : str.capitalize () Remarque : Une fois la fonction capitalize() convertie, seul le premier caractère de la chaîne est en majuscule et tous les autres caractères sont en minuscules

Par exemple : mystr = 'hello world et itcast et itheima et Python' new_str = mystr.capitalize () print(new_str) title() : convertit la première lettre de chaque mot de la chaîne en syntaxe majuscule : str.title()

Par exemple : mystr = 'hello world et itcast et itheima et Python' new_str = mystr.title() print(new_str) lower() : Convertit la chaîne de majuscule en minuscule Syntaxe : str.lower() Remarque : Convertissez tout en minuscule

Pour exemple : mystr = 'hello world et itcast et itheima et Python'new_str = mystr.lower() print(new_str) upper() : Convertit la chaîne des minuscules en majuscules Syntaxe : str.upper() Remarque : Convertissez tout en minuscules

Par exemple : mystr = 'hello world et itcast et itheima et Python' new_str = mystr.upper() print(new_str)

Supprimez les espaces de début et de fin lstrip() : supprimez le blanc caractères sur le côté gauche de la chaîne Syntaxe : str.lstrip() Par exemple : mystr = ' hello world et itcast et itheima et Python ' new_str = mystr.lstrip() print(new_str) rstrip() : supprime les caractères d'espacement sur le côté droit de la chaîne Syntaxe : str.rstrip()

Par exemple : mystr = 'hello world et itcast et itheima et Python ' new_str = mystr.rstrip() print(new_str) strip() : Supprime les caractères d'espacement des deux côtés de la chaîne Syntaxe : str.strip()

Par exemple : mystr = 'hello world et itcast et itheima et Python ' new_str = mystr.strip() print(new_str)

Alignement des chaînes ljust() : renvoie une chaîne originale alignée à gauche et Utiliser les caractères spécifiés (espaces par défaut) pour remplir une nouvelle chaîne à la longueur correspondante Syntaxe : str.ljust (longueur, caractère de remplissage) Par exemple : mystr = "hello" print(mystr.ljust(10,'.')) L'effet est : 'bonjour....' rjust() : renvoie une nouvelle chaîne alignée à droite et remplie de caractères spécifiés (espaces par défaut) à la longueur correspondante. Syntaxe : str.rjust(length, padding materials)<.>

Par exemple : mystr = "hello" print(mystr.rjust(10,'.')) L'effet est : '...hello' center() : Renvoie une chaîne originale alignée au centre et utilisant le caractère spécifié (espace par défaut) est complété à la longueur correspondante de la nouvelle syntaxe de chaîne : str.center (longueur, caractère de remplissage) Par exemple : mystr = "hello" print(mystr.conter(10,'.')) Le l'effet est : '..hello. ..'

Jugez le début et la fin de startwith() : Vérifiez si la chaîne commence par la sous-chaîne spécifiée, si c'est le cas, renvoyez True, sinon renvoyez False. Si les indices de position de début et de fin sont définis, la syntaxe est vérifiée dans la plage spécifiée : str.startswith(substring,start,end)

Par exemple : mystr = 'hello world et itcast et itheima et Python' print( mystr.startswith('hello')) print(mystr.startswith('hel')) print(mystr.startswith('hels')) endswith() : Vérifiez si la chaîne se termine par la sous-chaîne spécifiée, si c'est le cas, renvoie True , sinon il renvoie False. Si vous définissez les indices de position de début et de fin, vérifiez la syntaxe dans la plage spécifiée : str.endswith(substring,start,end)

Par exemple : mystr = 'hello world et itcast et itheima et Python' print ( mystr.endswith('Python')) print(mystr.endswith('Pythons'))

Judge isalpha() : renvoie True si la chaîne contient au moins un caractère et que tous les caractères sont des lettres, sinon renvoie Syntaxe fausse : str.isalpha() Par exemple : mystr = 'hello world et itcast et itheima et Python' print(mystr.isalpha()) isdigit() : renvoie True si la chaîne ne contient que des nombres, sinon renvoie False Syntaxe : str.isdigit()

Par exemple : mystr1 = '12345' print(mystr1.isdigit()) isalnum() : Si la chaîne a au moins un caractère et que tous les caractères sont des lettres ou des chiffres Syntaxe : str. lsalnum ()

Par exemple : mystr2 = 'abc123' print(mystr2.isalnum()) isspace() : Si la chaîne ne contient que des blancs, renvoie True, sinon renvoie False Syntaxe : str.isspace().

Par exemple : mystr3 = ' 'print(mystr3.isspace())

Liste

Pièges de la liste :

La liste est un type de données structure Mode de réalisation spécifique

Le format de la liste [données 1, données 2, données 3]

Au travail, la liste stocke autant que possible le même type de données

Opérations de liste :

append() : Ajouter des données à la fin de la liste Syntaxe : list.append(data) Remarque : Lors de l'ajout de données à la liste, le spécifié les données sont directement ajoutées à la liste d'origine, c'est-à-dire que la liste d'origine est modifiée, la liste est donc des données de type variable. Si les données ajoutées par append() sont une séquence, ajoutez la séquence entière à la liste

Par exemple : name_list = ['Tom','Lily','Rost'] name_list.append('xiaoming' ) print( name_list)

# Résultat : ['Tom','Lily','Rost','xiaoming'] extend() : Ajouter des données à la fin de la liste. , ajoutez les données de cette séquence une par une Syntaxe d'ajout à la liste : list.extend(data)

Par exemple : name_list = ['Tom','Lily','Rost'] name_list.extend(' xiaoming') print(name_list)

# Résultat : ['Tom','Lily','Rost','x','i','a',...] insert() : Spécifiez la position pour ajouter de nouvelles données Syntaxe : list.insert(position Subscript, data) Par exemple : name_list = ['Tom','Lily','Rost'] name_list.insert(1, 'xiaoming') print(name_list) # Résultat : ['Tom','xiaoming' ,'Lily','Rost']

Déterminer si in existe : Syntaxe : str dans la liste

Par exemple : name_list = ['Tom','Lily','Rost' ] print('Lily'

inname_list) # True print('Lilys' in name_list ) # Flase pas dans : Syntaxe : str pas dans la liste Par exemple : name_list = ['Tom','Lily','Rost'] print('Lily' pas dans name_list) # Flase print('Lilys' pas dans name_list) # True

Supprimer del : Syntaxe : exemple de cible del : name_list = ['Tom','Lily','Rost'] del name_list[0] print(name_list) # ['Lily' ,'Rost'] pop() : supprime les données à l'indice spécifié (la valeur par défaut est le dernier) et renvoie les données, que ce soit selon l'indice ou en supprimant le dernier, la fonction pop renverra. les données supprimées Syntaxe : list .pop()

Par exemple : name_list = ['Tom','Lily','Rost'] del_name = name_list.pop(1) print(del_name) # 'Lily' print (name_list) # ['Tom','Rost']

remove() : Supprime le premier élément correspondant d'une certaine donnée dans la liste Syntaxe : list.remove(data)

Par exemple : name_list = ['Tom','Lily','Rose'] name_list.remove('Rose') print(name_list) # ['Tom ','Lily'] clear() : Efface la syntaxe de la liste : list.clear() Par exemple : name_list = ['Tom','Lily','Rost'] name_list.clear() print(name_list) # []

Changer et modifier les données d'indice spécifiées

Par exemple : name_list = ['Tom','Lily','Rost'] name_list[0] = 'aaa'print(name_list) # ['aaa','Lily','Rost'] reverse() : Syntaxe inversée : list.reverse()

Par exemple : num_list = [1,5,2,3,6, 8] num_list.reverse() print(num_list) # [8,6,3,2,5,1]sort() : Syntaxe de tri : list.sort(key=None,reverse=False) Remarque : reverse représente la règle de tri, reverse = Vrai ordre décroissant, reverse = Faux ordre croissant (par défaut)

Par exemple : num_list = [1,5, 2,3,6,8] num_list.sort() print(num_list ) # [1,2,3,5,6,8]

Vérifier l'indice:index() : Renvoie l'indice de l'emplacement des données spécifiées - si les données recherchées ne le sont pas. Si elle existe, une erreur sera signalée. Syntaxe : list.index(data,start,end) Par exemple : name_list = ['Tom'. ,'Lily','Rose'] print(name_list.index('Lily',0,2)) # 1 count() : Compte le nombre de fois où les données spécifiées continuent dans la liste actuelle. Syntaxe : list.count()

Par exemple : name_list = ['Tom','Lily','Rose'] print (name_list.count('Lily')) len() : Accéder à la longueur de la liste, c'est-à-dire le nombre de données dans la liste. Syntaxe : len(list)

Par exemple : name_list = ['Tom','Lily', 'Rose'] print(len(name_list)) # 3

Copier copie() : ouvrir un nouvel espace pour stocker les données Syntaxe : list.copy() Par exemple : name_list = ['Tom' ,'Lily','Rose'] name_li2 = name_list.copy() print(name_li2) # ['Tom','Lily','Rose']

Parcourir while : en séquence Imprime chaque donnée de la liste Par exemple. : name_list = ['Tom','Lily','Rose'] i = 0 tandis que i # Résultat : Tom Lily Rose pour : Imprimez chaque donnée de la liste dans l'ordre : name_list = ['Tom','Lily','Rose'] pour i in name_list : print(i) # Résultat : Tom Lily Rose

Concept d'imbrication de liste : L'imbrication de liste fait référence à une liste contenant d'autres sous-listes

Par exemple : name_list = [ ['Xiao Ming','Xiao Hong','Xiao Lu'],['Tom','Lily','Rose'],['Zhang San','Li Si','Wang Er']] imprimer( name_list[2])

# ['Zhang San','Li Si','Wang Er'] print(name_list[2][1]) # Li Si

Tuple

Pièges du tuple :

Un tuple peut stocker plusieurs données, et les données du tuple ne peuvent pas être modifiées

Format du tuple : (données 1, data 2, data 3)

Si le tuple défini n'a qu'une seule donnée, il est préférable d'ajouter une virgule après les données, sinon le type de données est unique Le type de données de ces données

Au travail, les tuples stockent autant que possible le même type de données

Opérations sur les tuples :

Rechercher pour rechercher des données par indice : Par exemple : tuple1 = ('aa','bb', 'cc','bb') print(tuple1[0])

# aaindex() : Rechercher une certaine donnée, si la donnée existe, renvoyer l'indice correspondant, sinon une erreur sera signalée Syntaxe : La syntaxe est la même que la méthode d'indexation des listes et des chaînes - tuple.index (sous-chaîne) Par exemple : tuple1 = ('aa','bb','cc','bb') print( tuple1.index('aa ')) # 0 count() : Compte le nombre de fois qu'une certaine donnée apparaît dans le tuple actuel Syntaxe : tuple.count(data) Par exemple : tuple1 = ('aa',' bb'. ,'cc','bb') print(tuple1.count('bb')) # 1len() : Compte le nombre de données dans le tuple Syntaxe : len(tuple) Par exemple : tuple1 = ('aa','bb','cc','bb') print(len(tuple1)) # 4

Si vous modifiez les données directes dans le tuple, une erreur sera signalée immédiatement : Par exemple : tuple1 = ('aa','bb','cc','bb') tuple1[0] = 'aaa'. # Signaler une erreur S'il y a une liste dans le tuple, modifiez les données dans la liste Par exemple : tuple2 = (10, 20, ['aa', 'bb', 'cc'], 50, 30) print(tuple2[2]) # Accéder à la liste tuple2[2][0] = 'aaaaa' print(tuple2) # (10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)

Dictionnaire

Pièges du dictionnaire :

Les données dans le dictionnaire apparaissent sous forme de clé -Paires de valeurs. Les données du dictionnaire n'ont rien à voir avec l'ordre des données, c'est-à-dire que le dictionnaire ne prend pas en charge l'indice, peu importe la façon dont les données changent ultérieurement, il vous suffit de trouver les données en fonction du nom de la clé correspondante <.>

Format du dictionnaire : {'key1':value1, 'key2':value2}

Opérations du dictionnaire :

Ajouter un dict[clé] = valeur : Syntaxe : série de dictionnaires [clé ] = valeur Remarque : Si la clé existe, modifiez la valeur correspondant à la clé, si la clé n'existe pas, ajoutez la valeur clé à droite. Le dictionnaire est un type de variable. Par exemple : dict1 = {'name':'Tom', 'age':20; 'gender':'male'} dict1['name'] = 'Rose' print(dict1)

# {'name':'Rose', 'age':20; 'gender':'Male'} dict1['id'] = 110 print(dict1) # {'name': 'Tom' , 'age':20; deux listes Le nombre de données doit être le même. Par exemple : a = [1,2,3,4] b = [1,2,3,4] c = dict(zip(a,b)) print( c) # { 1:1, 2:2, 3:3, 4:4>Supprimer del()/ del : Supprimer le dictionnaire ou supprimer la paire clé-valeur spécifiée dans le dictionnaire Syntaxe : del dict Par exemple : dict1 = {'name':'Tom', 'age':20, 'gender':'male'}

del

dict1['gender'] print( dict1) # {'name':' Tom', 'age':20} clear() : Effacer le dictionnaire Syntaxe : dict.clear() Par exemple : dict1 = {'name':'Tom ', 'age':20, 'gender':'Male '} dict1.clear() print(dict1) # {}Modifier : Syntaxe : Séquence de dictionnaire [clé] = valeur Remarque : Si la clé existe, modifiez la valeur correspondant à la clé, si la clé n'existe pas, ajoutez cette paire clé-valeur Par exemple : dict1 = {'name':'Tom', 'age':20; 'gender':'male'} dict1['name'] = 'Rose' print (dict1)

# {'name':'Rose', 'age':20; 🎜>

Syntaxe de la clé de recherche : dict[key]Remarque : Si la clé actuellement recherchée existe, la valeur correspondante sera renvoyée ; sinon, une erreur sera signalée : Par exemple : dict1 = {'name' : 'Tom', 'age':20; 'gender':'male'} print(dict1['name'] ) # Tom

print(dict1['id'])

# Signaler une erreur syntaxe get() : dictionnaire séquence.get(clé, valeur par défaut) Remarque : Si la clé actuellement recherchée n'existe pas, le deuxième paramètre (valeur par défaut) est renvoyé. Si le deuxième paramètre est omis, Aucun n'est renvoyé. Par exemple : dict1 = {'name':'Tom', 'age':20; 'gender':'male'} print( dict1.get('name')) # Tomprint(dict1 .get('id',100)) # 100 print(dict1.get('id')) # Nonekeys() syntaxe : dict.keys() Par exemple : dict1 = {'nom':'Tom', 'age':20; 'gender':'male'} print(dict1.keys( )) # dict_keys(['name','age','gender ']) syntaxe values() : dict.values() Par exemple : dict1 = {'name':'Tom', 'age ':20; )) # dict1.values(['Tom',20,'']) items() syntaxe : dict1.items ()Par exemple : dict1 = {'name':'Tom', 'age ':20; 'genre':'masculin'} print(dict1.items()) # dict_items([('nom',' Tom'),('age',20),('genre', 'mâle')])

Parcourez les touches du dictionnaire, par exemple, dict1 = {'name':'Tom', 'age':20; 'gender':'male'} for key in dict1 .keys() : print(key) # Résultat : nom âge genre Parcourez les valeurs du dictionnaire Par exemple : dict1 = {'name':'Tom', 'age. ':20; 'gender':'Male '} for key in dict1.values(): print(key) # Résultat : Tom 20 Male Traverse les éléments du dictionnaire. Par exemple : dict1 = {'name ':'Tom', 'age':20; 'gender':'male'} pour clé in dict1 .items(): print(key) # result : ('name','Tom') ('age',20) ('gender','male') Parcourez les paires clé-valeur de le dictionnaire (déballage). Par exemple : dict1 = {'name':'Tom', 'age':20; 'gender':'male'} for key,values ​​​​in dict1.items(): print(f'{key} = {values} ') # Résultat : nom = Tom âge = 20 sexe = homme

Set

Pièges de la collection :

Créez une collection en utilisant {} ou set (), mais si vous souhaitez créer une collection vide, vous ne pouvez utiliser que set(), car utiliser {} crée un dictionnaire

La collection ne prend pas en charge les opérations d'indice, car la collection n'a pas d'ordre

Les données de la collection ont une fonction de déduplication

Opération de collecte :

Syntaxe Add data add() : set.add() Remarque : Étant donné que la collection a une fonction de déduplication, lorsque l'ajout de données à la collection correspond à des données existantes dans la collection actuelle, aucune opération ne sera effectuée par exemple. : s1 = {10,20} s1.add(100) s1.add(10) print(s1) # { 100, 10, 20> update() : Syntaxe : set.update(list) Remarque : Les données ajoutées sont une séquence. Par exemple : s1 = {10, 20} # s1.update(100) # Rapport d'erreur s1.update([100, 200]) s1.update(' abc') print(s1) # {'c', 100, 'a', 200, 10, 20, 'b'}

Supprimer les données remove() Syntaxe : set. remove() Remarque : Supprimez les données spécifiées dans la collection. Si les données n'existent pas, une erreur sera signalée : s1 = {10, 20} s1.remove(10) print(s1) #. {20} s1.remove(10) print(s1) # Report error throw() syntaxe : set.discard() Remarque : supprimez les données spécifiées dans la collection, aucune erreur ne sera signalée si les données n'existent pas. Par exemple : s1 = {10, 20} s1.discard(10) print(s1) s1.discard(10) print(s1) pop() syntaxe : set.pop() Remarque : aléatoirement. supprimez certaines données de la collection et renvoyez ces données. Par exemple : s1 = {10, 20, 30, 40,50} del_num = s1.pop() print(del_num) print(s1)

Rechercher des données. in : Déterminez que les données sont dans la séquence définie not in : Déterminez que les données ne sont pas dans la séquence définie Par exemple : s1 = {10, 20, 30, 40, 50} print(10 in s1) print(10 pas in s1)

Opération publique

Opérateur

Opérateur Description Types de conteneurs pris en charge + fusion chaînes, listes, tuples *Copier la chaîne, la liste, le tuple si l'élément in existe chaîne, liste, tuple, dictionnaire, définir non si l'élément in n'existe pas chaîne, liste, tuple, dictionnaire, définir

Pour exemple :

# +# 1. String str1 ='aa'str2 ='bb'str3 = str1 + str2print(str3)# aabb# 2. List list1 = [1, 2]list2 = [10, 20] list3 = list1 + list2print(list3)# [1, 2, 10, 20]# 3. Tuple t1 = (1, 2)t2 = (10, 20)t3 = t1 + t2print(t3)# (10, 20 , 100, 200)# * # 1. String print('-'* 10)# ----------# 2. List list1 = ['hello']print(list1 * 4)# [ 'bonjour', 'bonjour', 'bonjour', 'bonjour']# 3. Tuple t1 = ('monde',)print(t1 * 4)# ('monde', 'monde', 'monde', 'monde ')# dans ou pas dans # 1. String print('a'in'abcd')# Trueprint('a'notin'abcd')# False# 2. List list1 = ['a','b' ,' c','d']print('a'inlist1)# Trueprint('a'notinlist1)# False# 3. Tuple t1 = ('a','b','c','d') print(' aa'int1)# Falseprint('aa'notint1)# True

Méthode publique

Description de la fonction len() calculer le nombre d'éléments dans le conteneur del ou del() delete max( ) Renvoie la valeur maximale de l'élément dans le conteneur min() Renvoie la valeur minimale de l'élément dans la plage du conteneur (début, fin, étape) Génère un nombre du début à la fin, avec une longueur de pas, à utiliser par l'énumération ( ) fonction dans la boucle for Elle est utilisée pour combiner un objet de données traversable (tel qu'une liste, un tuple ou une chaîne) dans une séquence d'index et répertorier les données et les indices de données en même temps. Elle est généralement utilisée dans une boucle for.

Par exemple :

# len()# 1. String str1 ='abcdefg'print(len(str1))# 7# 2. List list1 = [10,20,30,40]print(len(list1))# 4 # 3. Tuple t1 = (10,20,30,40,50)print(len(t1))# 5# 4. Définissez s1 = {10,20,30}print(len(s1))# 3# 5. Dictionnaire dict1 = {'name':'Rose','age':18}print(len(dict1))# 2# del()# 1. String str1 ='abcdefg'delstr1print(str1)# 2. List list1 = [10,20,30,40]del(list1[0])print(list1)# [20, 30, 40]# max()# 1. String str1 ='abcdefg'print(max(str1 ))# g# 2. Liste list1 = [10,20,30,40]print(max(list1))# 40# min()# 1. String str1 ='abcdefg'print(min(str1))# a# 2. Liste list1 = [10,20,30,40]print(min(list1))# 10# range() -- La séquence générée par range() ne contient pas le numéro de fin # 1 2 3 4 5 6 7 8 9foriinrange( 1, 10,1) : print(i)# 1 3 5 7 9foriinrange(1,10,2) : print(i)# 0 1 2 3 4 5 6 7 8 9foriinrange(10) : print(i)# enumerate () -- enumerate(objet traversable, start=0)list1 = ['a','b','c','d','e']foriinenumerate(list1): print(i)forindex, charinenumerate (list1, start =1) : print(l'indice f' est {index}, le caractère correspondant est {char}')

conversion de type de conteneur

fonction tuple() : Convertir une séquence en tuple, par exemple list1 = [10, 20, 30, 40, 50, 20] s1 = {100, 200, 300, 400, 500} print(tuple(list1)) print(tuple(s1))

Fonction List() : Convertit une séquence en liste. Par exemple : t1 = ('a', 'b', 'c', 'd', 'e') s1 = {100, 200, 300, 400, 500. } Fonction print(list(t1)) print(list(s1))

set() : Convertit une séquence en un ensemble Par exemple : list1 = [10, 20, 30, 40 , 50, 20. ] t1 = ('a', 'b', 'c', 'd', 'e') print(set(list1)) print(set(t1)) # 1. Les ensembles peuvent rapidement terminer la déduplication de liste # 2. Les ensembles ne prennent pas en charge les indices

dérivation - expression générative

fonction de dérivation de liste : utiliser une expression Créer une liste régulière ou contrôler une liste régulière . Par exemple : # implémentation de la boucle while # 1. Préparez une liste vide list1 = [] # Écrivez une boucle et ajoutez-la dans l'ordre Les nombres sont ajoutés à la liste vide list1 i = 0 while i # for implémentation de la boucle list1 = [] for i in range(10): list1.append(i) print(list1) # Implémentation de la compréhension de liste list1 = [i for i in range(10)] print(list1) # Compréhension de liste avec if # Méthode 1 : implémentation de la taille de pas range() list1 = [i for i in range(0,10,2)] print(list1) # Méthode 2 : Compréhension de liste avec if list1 = [i for i inrange(10) if i % 2 == 0] print(list1) # Multiples boucles for pour implémenter la dérivation de liste Formule list1 = [(i, j )pouri dans plage(1, 3)pour j dans plage( 3)] print(list1)

Fonction de dérivation de dictionnaire : fusionnez rapidement des listes dans des dictionnaires ou extrayez des données cibles dans des dictionnaires. Par exemple : # 1. Créez un dictionnaire : les clés du dictionnaire sont les nombres 1 à 5, la valeur est le carré de ce nombre <.> dict1 = {i:i**2 pour i in range(1, 5)} print(dict1) # { 1 : 1, 2 : 4, 3 : 9, 4 : 16} # 2. Fusionner les deux listes dans un dictionnaire list1 = ['name', 'age', 'gender' ] list2 = ['Tom', 20 , 'man'] dict1 = {list1[i]: list2[i] for i inrange(len(list1))} print (dict1) # 3. Extraire les données cibles dans le dictionnaire counts = {'MBP' : 268, 'HP' : 125, 'DELL' : 201, 'Lenovo' : 199, 'acer' : 99 } # Exigence : Extraire les données du dictionnaire pour les ordinateurs mentionnés ci-dessus dont le nombre est supérieur ou égal à 200 count1 = {key: value for key, value in counts.items() if value >= 200} print(count1) # {'MBP':268, 'DELL': 201}

La fonction de dérivation d'ensemble : générer rapidement sets, Les sets ont une fonction de déduplication des données. Par exemple :

# Créez un ensemble, les données sont la 2ème puissance de la liste ci-dessous list1 = [1, 1, 2] list1 = [1, 1, 2] set1 = {i * * 2 for i in list1} print(set1) # {1, 4}

Petit pool d'objets entiers et un grand entier dans le pool d'objets Python Integer, et la différence entre "is" et "=="

Python est un langage de type de variable faible, et il n'est pas nécessaire de déclarer le type de la variable avant de l'utiliser . Il y a trois attributs pour une variable : id (adresse mémoire), type (type de variable), valeur (valeur)

La différence entre =, == et est : = opération d'affectation, ce qui est passé est l'identifiant, type, value== détermine si les valeurs sont égales est détermine si les identifiants sont égaux

Le pool d'objets de petits nombres entiers utilise la technologie de pooling d'objets pour les petits objets entiers. Définissez la plage de petits entiers sur [-5 256]. Les petits entiers dans cette plage, tout entier identique est le même objet. De même, il en va de même pour une seule lettre. Le pool tampon de petits entiers est créé lorsque Python est initialisé, gère les espaces et la possibilité de réutilisation d'un mot. . est grand, donc il est créé une fois. S'il y a des espaces, il est créé plusieurs fois. Cependant, si la longueur de la chaîne est supérieure à 20, elle n'est pas créée une fois. est b # Vrai a = 256 b = 256 a est b # Vrai a = 1000 b = 1000 a est b # True a = 'abc' b = 'abc' a est b # True a = 'helloworld' b = 'helloworld' a estb #Vraia = 'bonjour tout le monde' b = 'bonjour tout le monde' a est b #Faux

Le grand Le pool d'objets entiers au-delà de la plage des petits entiers est un grand entier, à chaque fois Un nouvel objet sera créé. Mais les grands entiers dans un bloc de code sont le même objet. Le terminal est exécuté une fois à chaque fois, donc le grand entier est recréé à chaque fois. Dans pycharm, tous les codes sont chargés dans la mémoire à chaque exécution et appartiennent à un tout, il y aura donc un grand pool d'objets entiers à chaque fois. cette fois, c'est-à-dire que le grand entier dans un bloc de code est le même objet dans pycharm. Chaque fois qu'il est exécuté, tout le code est chargé dans la mémoire et appartient à un tout. Il y aura donc un grand pool d'objets entiers. cette fois, c'est-à-dire le grand entier dans un bloc de code. C'est le même objet a = 1000 b = 1000 a

est b # False a = -1888 b = -1888. a est b #Faux class C1(objet) : a = 100 b = 100 c = 1000 d = 1000 classe C2(objcet) : a = 100 b = 1000 print(C1.a est C1.b) # True print(C1.a est C1.a) # Vrai print(C1.c est C1.d) # Vrai print(C1.d estC1.b) #Falsec

Générateur

La fonction du générateur est de générer des données en boucle

selon les règles fixées par le programmeurLorsque les conditions ne sont pas rempliesla génération des données se termineLes données ne sont pas générées d'un seul coup, au lieu de cela, une est utilisée et une autre est générée, ce qui peut économiser beaucoup. de mémoire

Création de générateurs Dérivation de générateur Dérivation de générateur et compréhension de liste Similaire, mais la compréhension de liste utilise des parenthèses

# pour créer le générateur mon_générateur = (i * 2 pour i in range(5)) print(my_generator)

mot-clé rendement : Caractéristiques du générateur de mot-clé rendement : avoir le mot-clé rendement dans la fonction def

defmon générateur(n): pour je dans plage(n): print('Commencer à générer...') rendement j'imprime(' Terminez une fois...') Remarque : Lorsque le code est exécuté pour produire, il fera une pause puis renverra le résultat la prochaine fois que le générateur sera démarré, il continuera à exécuter le générateur en pause. position. Si les données sont générées et que les données suivantes dans le générateur sont à nouveau obtenues, une exception StopIteration sera levée, indiquant qu'il n'y a pas d'opération de gestion d'exception à l'intérieur de la boucle while et que vous devez ajouter manuellement l'opération de gestion d'exception. L'exception d'arrêt de l'itération est automatiquement gérée à l'intérieur de la boucle for, ce qui est plus pratique à utiliser

Fonction suivante liée au générateurObtenir la valeur suivante dans le générateurboucle forParcourez chaque valeur du générateur

Recommandations d'apprentissage gratuites associées :

Vidéo de programmation

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!