Programmez-vous en Python? Pour ceux qui ont une certaine compréhension de la grammaire de base de Python mais veulent aller plus loin, voici quelques techniques intermédiaires et méthodes d'écriture.
Si vous maîtrisez cet article, pouvez-vous devenir un utilisateur Python intermédiaire à partir de demain? Alors, commençons.
En Python, il est possible de définir plusieurs variables sur une seule ligne.
Lors du remplacement normal:
x = 10
y = 12
z = 35
print(x, y, z) # 10 12 35
Lors de la substitution sur une seule ligne:
x, y, z = 10, 12, 35
print(x, y, z) # 10 12 35
Comme mentionné ci-dessus, il est possible de définir des variables sur une seule ligne. La lisibilité de toutes les définitions de variables est réduite d'une ligne, mais la lisibilité des définitions de variables avec certaines relations est améliorée d'une ligne.
De plus, lors de l'affectation de la même valeur à plusieurs variables, il est possible d'écrire comme suit. Cette méthode d'affectation requiert des précautions dans le cas d'objets mutables (variables). Pour plus de détails, veuillez vous référer à l'explication détaillée de M. shiracamus dans la section commentaires de cet article.
x = y = z = 10
print(x, y, z) # 10 10 10
Lors du remplacement du contenu des variables, je pense qu'il est courant d'utiliser des variables temporaires, etc., mais dans le cas de Python, il est plus facile d'écrire.
Lors de l'échange de variables normalement:
x, y = 10, 23
tmp = x
x = y
y = tmp
print(x, y) # 23 10
Lors de l'échange de variables sur une seule ligne:
x, y = 10, 23
x, y = y, x
print(x, y) # 23 10
Je suis surpris que les variables puissent être échangées de cette manière. ..
En Python, il est possible de développer des tableaux, des dictionnaires, etc. en utilisant le symbole * (astérisque).
test = [1, 2, 3]
print([test, 4, 5]) # [[1, 2, 3], 4, 5]
print([*test, 4, 5]) # [1, 2, 3, 4, 5]
Le code ci-dessus utilise un astérisque pour développer et affecter un tableau. Si vous n'utilisez pas l'astérisque, le tableau sera affecté dans un état imbriqué.
Pour les dictionnaires, utilisez deux astérisques.
test = {'apple': 'red', 'remon': 'yellow'}
print({**test,'cherrie': 'pink'}) # {'apple': 'red', 'remon': 'yellow', 'cherrie': 'pink'}
Je pense qu'il existe de nombreux cas où l'instruction IF détermine si la variable est 0 ou Aucune. Cependant, ce n'est pas du code pionique pour écrire la logique qui détermine réellement la valeur booléenne.
Pythonic signifie "comment écrire du code simple et facile à lire comme Python"
Lorsque vous jugez 0 normalement:
test = 0
if test == 0:
print('NG')
else:
print('OK')
Comment écrire des conditions de type Python:
test = 0
if not test:
print('NG')
else:
print('OK')
Dans le code pionique, ce qui est jugé faux est décidé à l'avance, nous n'écrivons donc pas explicitement la logique de jugement pour celui qui a été décidé. Les éléments suivants sont jugés faux. Jugement de valeur de vérité intégré
Les opérateurs de comparaison Python sont == et ʻis`, qui peuvent tous deux être utilisés pour vérifier si les variables à comparer sont les mêmes.
Cependant, sachez que si vous ne comprenez pas la signification des deux, vous pouvez créer des bogues inattendus.
Q. Dois-je utiliser est pour la comparaison avec Aucun?
R. Oui. Mais à moins que vous ne sachiez ce que vous faites, vous obtiendrez les mêmes résultats qu'en utilisant ==
Tout d'abord, le fonctionnement de l'opérateur is sera expliqué. L'opérateur is vérifie si les variables comparées ont le même ID. Quel est l'ID d'une variable est la destination de référence (pointeur) de la variable. Par exemple, si la valeur de destination de référence est la même mais que la destination de référence (pointeur) est différente, l'opérateur is détermine qu'elle est fausse.
Si les variables se réfèrent à la même destination:
test = 'my name is taro' + '.'
test2 = test
print(id(test)) # 140643210401160
print(id(test2)) # 140643210401160
Dans le cas ci-dessus, test2 se voit attribuer une variable appelée test, donc test et test2 pointent vers la même référence. Ainsi, lors de la comparaison avec l'opérateur is, test et test2 sont jugés identiques. Vérifions également l'ID de None (l'ID peut varier en fonction de l'environnement)
test = None
test2 = None
print(id(test)) # 9107296
print(id(test2)) # 9107296
Aucun fait référence au même objet, peu importe où il est défini. Donc, si vous voulez comparer si c'est None ou non, vous pouvez utiliser l'opérateur is pour vérifier si la cible de comparaison est vraiment None. Dans le cas de l'opérateur ==, vous pouvez modifier le comportement de l'opérateur lui-même en utilisant une fonction appelée surcharge d'opérateur, il peut donc ne pas être possible de déterminer exactement s'il s'agit de None ou non. (Sans surcharge d'opérateur, les comparaisons None auront le même résultat avec les opérateurs is et ==)
Q. Ne devrions-nous pas utiliser pour des comparaisons autres que Aucune? R. Oui. L'utilisation de is for non-None comparaisons peut entraîner des bogues inattendus.
En particulier, il est dangereux d'utiliser beaucoup l'opérateur is car il peut se comporter de manière inattendue lors de la comparaison de variables de chaîne de caractères. Par exemple, considérez le code suivant.
test = 'my name is taro' + '.'
test2 = 'my name is taro' + '.'
print(id(test)) # 140196053288256
print(id(test2)) # 140196053288328
print(test) # my name is taro.
print(test2) # my name is taro.
if test is test2:
print('same')
else:
#C'est la sortie
print('not same')
if test == test2:
#C'est la sortie
print('same')
else:
print('not same')
Bien que test et test2 contiennent la même chaîne, ils sont référencés différemment. Ainsi, par rapport à l'opérateur is, les deux variables sont jugées différentes, et l'opérateur == est jugé identique. L'opérateur == a l'inconvénient d'être plus lent que l'opérateur is car il vérifie et juge le contenu de la variable, mais l'utilisation de l'opérateur is prête à confusion pour les comparaisons autres que None. Donc je ne le recommande pas. Cependant, dans des cas exceptionnels, l'opérateur is peut être utilisé pour écrire du code proprement. (Voir le commentaire de justes dans la section commentaires)
D'autres langages ont une méthode d'évaluation de court-circuit, mais Python en a également une. En faisant bon usage de l'évaluation des courts-circuits, il est possible d'écrire intelligemment la logique des instructions IF.
Par exemple, considérez le code suivant.
test = {'age': 20}
if 'age' in test:
if test['age'] >= 20:
print('Je suis adulte')
Tout d'abord, la première instruction IF vérifie si la variable de test a un attribut appelé age. Cela permet d'éviter une erreur si vous accédez à un attribut qui n'existe pas. La deuxième instruction IF confirme si la valeur de l'attribut age est de 20 ou plus.
Réécrivons-le en utilisant l'évaluation des courts-circuits.
test = {'age': 20}
if 'age' in test and test['age'] >= 20:
print('Je suis adulte')
Vous pourriez penser que vous avez simplement connecté les instructions IF avec l'opérateur and. Cependant, si vous permutez la gauche et la droite de l'opérateur and, le comportement que vous entendez changera. Le comportement exact de l'évaluation du court-circuit (et de l'opérateur et / ou de l'opérateur) est que si la première condition est vraie (ou opérateur) ou fausse (et opérateur), le traitement suivant n'est pas effectué. Devenir. Dans le cas ci-dessus, si le résultat de l'évaluation de «'age' in test» est faux, «test ['age']> = 20» ne sera pas évalué. Par conséquent, il est possible de réaliser la condition selon laquelle «test ['age']> = 20» n'est évalué que lorsque l'attribut age existe dans la variable de test.
Je pense qu'il existe de nombreux cas où les valeurs numériques sont comparées comme suit.
x = 10
if x >= 0 and x <= 20:
print('OK')
else:
print('NG')
Cependant, dans le cas de Python, il est possible d'écrire comme suit.
x = 10
if 0 <= x <= 20:
print('OK')
else:
print('NG')
Lors de l'attribution d'une valeur à une variable, je pense qu'il existe de nombreuses situations dans lesquelles vous souhaitez modifier la valeur à attribuer en fonction des conditions. Par exemple, si la variable est None ou s'il s'agit d'une clé spécifique. À ce moment-là, vous pouvez écrire intelligemment en affectant des variables à l'aide de l'opérateur ternaire. La méthode de description de l'opérateur ternaire en Python est la suivante.
(variable) = (Valeur lorsque la condition est vraie) if (Expression conditionnelle) else (Valeur lorsque la condition est fausse)
Code sans l'opérateur ternaire
test = 15
if test >= 0:
message = 'Nombre positif ou 0'
else:
message = 'Est un nombre négatif'
print(message)
Code lors de l'utilisation de l'opérateur ternaire
test = 15
message = 'Nombre positif ou 0' if test >= 0 else 'Est un nombre négatif'
print(message)
Comme mentionné ci-dessus, puisque la partie de l'instruction IF peut être décrite sur une seule ligne, la partie attribuée devient une ligne et la lisibilité du code est améliorée. Notez que dans l'opérateur ternaire, si vous souhaitez créer une branche avec plusieurs conditions (si vous souhaitez utiliser elif), vous devez imbriquer l'opérateur ternaire. Cependant, l'imbrication d'opérateurs ternaires réduit considérablement la lisibilité du code et n'est pas recommandée. Si la condition est compliquée, l'instruction IF peut être utilisée à la place de l'opérateur ternaire.
Je pense qu'il existe quatre façons d'intégrer la valeur d'une variable dans une chaîne en Python.
name = 'taro'
#Chaîne+Concaténer avec l'opérateur
print('je' + name + 'est')
#Utiliser une chaîne f
print(f'je{name}est')
#utiliser la fonction format
print('je{}est'.format(name))
# %Comment utiliser
print('je%s' % name)
La méthode concaténer les chaînes avec l'opérateur + n'est pas recommandée car elle rend le code moins lisible et moins modifiable. (L'opérateur + utilisé pour la concaténation n'a pas de sens en premier lieu, et vous devez écrire l'opérateur + lors de l'ajout d'un nouveau.)
Je me demande si cela n'a pas d'importance si vous utilisez la f string ou la fonction de format. Cependant, vous ne souhaitez pas que les deux descriptions soient utilisées dans le code de votre projet. Je pense qu'il devrait être unifié pour l'un ou l'autre.
Je pense qu'il existe de nombreux cas où un tableau est traité par une instruction FOR. Voici quelques techniques utiles à utiliser dans ce cas.
Lorsque vous utilisez l'instruction FOR normalement:
test = [1, 10, 15, 16]
for index in range(len(test)):
print(test[index], end=' ') # 1 10 15 16
Lors de l'utilisation POUR CHAQUE:
test = [1, 10, 15, 16]
for value in test:
print(value, end=' ') # 1 10 15 16
Avec FOR EACH, la cible à boucler dans l'instruction FOR est l'élément du tableau de l'index. Donc, si vous avez besoin de traiter les éléments d'un tableau un par un, l'utilisation de la notation FOR EACH améliorera la lisibilité de votre code.
Nous rencontrons également souvent des cas où nous voulons utiliser des index dans FOR EACH. Dans ce cas, vous pouvez obtenir à la fois l'élément et l'index du tableau en procédant comme suit, afin que vous puissiez écrire intelligemment.
test = [1, 10, 15, 16]
for index, value in enumerate(test):
# index: 0 value: 1 , index: 1 value: 10 , index: 2 value: 15 , index: 3 value: 16 ,
print('index:', index, 'value:', value, ',', end=' ')
C'est rarement rencontré, mais il mentionne également lorsque vous souhaitez obtenir les éléments d'un tableau dans l'ordre inverse.
Si vous obtenez normalement les éléments d'un tableau dans l'ordre inverse:
test = [1, 10, 15, 16]
for i in range(len(test)-1, -1, -1):
print(test[i], end=' ') # 16 15 10 1
Lors de l'utilisation de la fonction inversée:
test = [1, 10, 15, 16]
for value in reversed(test):
print(value, end=' ') # 16 15 10 1
En plus d'utiliser la fonction inversée, vous pouvez également utiliser des tranches pour inverser les éléments du tableau. Veuillez vous référer au commentaire de c-yan pour plus de détails.
Pour programmer intelligemment en Python, il est important d'avoir une certaine compréhension des fonctions intégrées. Il décrit la fonction de plage, la fonction len, la fonction inversée, etc. utilisées dans cet article. Fonctions intégrées
Je pense que le dictionnaire est souvent traité par l'instruction FOR. Il existe de nombreuses façons d'écrire une instruction FOR dans un dictionnaire, mais fondamentalement, il n'y a pas de problème si vous vous souvenez comment utiliser la fonction items.
Lors du traitement normal d'un dictionnaire avec une instruction FOR:
test = {'apple': 'red', 'remon': 'yellow'}
for key in test:
print('key:', key, 'value:', test[key], ',', end=' ') # key: apple value: red , key: remon value: yellow ,
Lors de l'utilisation de la fonction éléments:
test = {'apple': 'red', 'remon': 'yellow'}
for key,value in test.items():
print('key:', key, 'value:', value, ',', end=' ')
Je ne le rencontre pas très souvent, mais je pense que je le rencontrerai plusieurs fois. Vous pouvez vérifier le contenu du tableau et créer votre propre fonction pour éliminer les doublons, mais vous pouvez supprimer les doublons plus facilement.
test = [1, 2, 3, 3, 5, 1]
test2 = ['a', 'b', 'a', 'd', 'aa']
print(list(set(test))) # [1, 2, 3, 5]
print(list(set(test2))) # ['a', 'd', 'b', 'aa']
Le fait est que la duplication peut être automatiquement éliminée en convertissant en type Set. Après la conversion en type Set, il est de nouveau retourné au type List.
Vous n'implémentez pas vous-même le tri par tableau. Le tri peut être réalisé à l'aide des fonctions existantes.
test = [10, 25, 4, 100, 69]
print(sorted(test)) # [4, 10, 25, 69, 100]
print(sorted(test, reverse=True)) # [100, 69, 25, 10, 4]
Il est également possible de spécifier explicitement ce que vous souhaitez utiliser comme clé de tri.
test = [[10, 25], [4, 100], [69, 71]]
print(sorted(test, key=lambda item: item[1])) # [[10, 25], [69, 71], [4, 100]]
Le code ci-dessus est trié par le deuxième élément du tableau en tant que clé.
Le tri de la fonction triée n'est pas très rapide. Si vous rencontrez des problèmes de vitesse, nous vous recommandons d'utiliser une bibliothèque telle que numpy.
Vous souhaiterez peut-être trier le tableau du dictionnaire. Dans ce cas, vous pouvez le gérer en spécifiant explicitement la clé comme indiqué ci-dessous.
test = [{'name': 'taro', 'age': 18},{'name': 'jiro', 'age': 12}]
# [{'name': 'jiro', 'age': 12}, {'name': 'taro', 'age': 18}]
print(sorted(test, key=lambda item: item['age']))
La notation d'inclusion de liste est très pratique et c'est une méthode de description avec une vitesse de traitement rapide, c'est donc un style d'écriture que vous voulez absolument apprendre. La notation d'inclusion de liste est décrite comme suit.
[(Valeur à ajouter au tableau) for (Un élément de l'objet itérateur) in (Objet Iterator)]
Si vous créez normalement une liste paire:
test = []
for index in range(5):
test.append(index * 2)
print(test) # [0, 2, 4, 6, 8]
Lors de la création d'une liste en notation d'inclusion de liste:
# [0, 2, 4, 6, 8]
print([index * 2 for index in range(5)])
J'ai pu écrire en une seule ligne. Il est également possible d'affiner les conditions en utilisant l'instruction IF (postfix IF).
#Créez un tableau pair qui ne contient pas de multiples de 10
# [2, 4, 6, 8, 12, 14, 16, 18, 22, 24, 26, 28, 32, 34, 36, 38]
print([index * 2 for index in range(20) if (index * 2) % 10])
Dans la notation d'inclusion de liste, il est également possible de brancher la condition avec IF et ELSE. De plus, le dictionnaire a également une notation inclusive, mais cette fois, elle sera omise.
Python a une fonction all qui détermine si tous les éléments sont True et une fonction any qui détermine si un élément est True. En faisant bon usage de toutes et toutes les fonctions, vous pouvez écrire des programmes intelligents.
Par exemple, supposons que vous écriviez un programme qui détermine si le contenu d'un tableau est égal ou supérieur à 0.
Lors de la mise en œuvre normale:
test = [-1, 5, 2]
judge = True
for value in test:
if value < 0:
judge = False
result = 'Tous les contenus sont 0 ou plus' if judge else 'Contient des nombres négatifs'
print(result)
Lors de l'utilisation de la fonction all:
test = [-1, 5, 2]
judge = all(map(lambda item: item >= 0, test))
result = 'Tous les contenus sont 0 ou plus' if judge else 'Contient des nombres négatifs'
print(result) #Contient des nombres négatifs
J'ai pu écrire 3 lignes en 1 ligne.
Maintenant, passons à l'explication du programme.
Tout d'abord, la fonction map est une fonction qui vous permet d'appliquer une fonction à chaque élément du tableau.
Lorsque map (élément lambda: élément> = 0, test) est appliqué, un nouvel objet de carte est créé qui détermine si chaque élément est égal à 0 ou plus. Cela signifie qu'un objet de carte «False, True, True» sera créé.
Ensuite, la fonction all est utilisée pour déterminer si tous les éléments sont True.
Une mise en garde est que la fonction all renvoie un tableau vide comme True, vous devez donc écrire une branche distincte pour voir si le tableau est vide. (Merci pour ton commentaire, marmalade_boy)
Renvoie True si tous les éléments de iterable sont vrais (ou si iterable est vide)
Nous n'entrerons pas dans les détails du gestionnaire de contexte, mais c'est une bonne idée d'en savoir plus sur le bloc with.
Par exemple, supposons que vous souhaitiez ouvrir un fichier. Pour gérer la situation où une exception se produit lors du traitement du fichier et que le fichier n'est pas fermé, placez-le dans une clause try et fermez le fichier définitivement.
fd = open("filename", "r")
try:
file_content = file.read()
raise Exception('test')
finally:
fd.close()
Cependant, il est difficile d'écrire une clause try à chaque fois et de fermer le fichier, donc j'utilise le bloc with.
with open("filename", "r") as fd:
file_content = file.read()
raise Exception('test')
En écrivant comme ci-dessus, le fichier sera automatiquement fermé même si une exception se produit dans le bloc with.
Merci d'avoir lu le long texte. Python est toujours un langage profond, donc ceux présentés ci-dessus ne sont que quelques-uns. Cependant, j'espère que cela vous aidera. Puis (^^ ♪