Retrait
import os
def function():
#Le retrait est PEP8(*)Selon, 4 espaces demi-largeur
print('Hello world')
(*)PEP8(Python Enhancement Proposal) https://www.python.org/dev/peps/pep-0008/ Indentation Use 4 spaces per indentation level.
Déclaration de variable
#Valeur numérique
num = 1
#Chaîne
name = 'Tanaka'
#liste
list = [1, 2, 3, 4, 5]
#Déclaration de type explicite
num: int = 1
name: str = 'Tanaka'
#Conversion de type
old_num = '1' #Type de chaîne
new_num = int(num) #Convertir en type entier et nouveau_Attribuer à num
commentaire
#Commentaire ligne par ligne
"""
Plusieurs lignes
collecte
commentaire
"""
Docstring
def test_function(param1, param2):
"""Test qui ajoute deux arguments et retourne_function
Args:
param1(int):Explication du premier argument
param2(int):Explication du deuxième argument
Returns:
Renvoie le résultat de l'addition de param1 et param2
"""
return param1 + param2
Calcul numérique
#Addition d'entiers
>>> 1 + 1
2
#Soustraction d'entiers
>>> 2 - 1
1
#Multiplier les entiers
>>> 5 * 6
30
#Division d'un entier * La division renvoie toujours une virgule flottante
>>> 6 / 5
1.2
#L'ordre d'évaluation est le même que les mathématiques
>>> 50 - 5 * 6
20
>>> (50 - 5 * 6) / 4
5.0
#La division standard renvoie le flottant
>>> 17 / 3
5.666666666666667
# 「//": La division arrondie arrondit à la décimale inférieure
>>> 17 // 3
5
# 「%": Renvoie le reste (reste de la division)
>>> 17 % 3
2
>>>
#5 au carré
>>> 5 ** 2
25
#2 à la 7e puissance
>>> 2 ** 7
128
#Arrondir après la virgule décimale(Arrondir après la virgule décimale de 2 chiffres)
>>> pie = 3.1415926535
>>> pie
3.1415926535
>>> round(pie, 2)
3.14
Chaîne
#Entourez avec une seule citation
>>> print('Hello world')
Hello world
#Entourer de guillemets doubles
>>> print("Hello world")
Hello world
#Sous forme de chaîne de caractères "'Lors de l'utilisation(Entourer de guillemets doubles)
>>> print("I'm from Japan.")
I'm from Japan.
'
#Sous forme de chaîne de caractères "'Lors de l'utilisation(Échapper)
>>> print('I\'m from Japan.')
I'm from Japan.
'
#Commencer sur une nouvelle ligne(\n)
>>> print('Hello! \nHow are you doing?')
Hello!
How are you doing?
#Empêcher l'interprétation en tant que caractère spécial(「\Puisque la partie "n" est interprétée comme un saut de ligne, elle est traitée comme des données brutes.)
>>> print(r'C:\name\name')
C:\name\name
#Sortie multiligne(「"""Entouré par)
>>> print("""
... line1
... line2
... line3
... """)
line1
line2
line3
#Ne pas casser(「\Décrire)
>>> print("""\
... line1
... line2
... line3\
... """)
line1
line2
line3
#Répéter les caractères
>>> print('Yes.' * 3 + '!!!')
Yes.Yes.Yes.!!!
#Concaténation de chaînes(Les littéraux sont "+Est OK sans)
>>> print('Py''thon')
Python
#Concaténation de chaînes(variable+Le littéral est "+"Est nécessaire)
>>> prefix = 'Py'
>>> print(prefix + 'thon')
Python
Index de chaîne/Tranchage
#Définition variable
>>> word = 'Python'
#Obtenez le caractère à la 0ème position du mot
>>> print(word[0])
P
#Obtenez le caractère en 5ème position du mot
>>> print(word[5])
n
#Obtenir le caractère en première position à partir de la fin du mot(Depuis le début, 0,1,2 ... de la fin-1,-2,-3 ...)
>>> print(word[-1])
n
#Récupère le caractère en troisième position à partir de la fin du mot(Depuis le début, 0,1,2 ... de la fin-1,-2,-3 ...)
>>> print(word[-3])
h
#mot 0(Y compris 0)À partir de 2(2 n'est pas inclus)Amenez les personnages à la position de
>>> print(word[0:2])
Py
#mot 2(2 dont)À partir de 5(5 non inclus)Amenez les personnages à la position de
>>> print(word[2:5])
tho
#2 depuis le début du mot(2 dont)Amenez les personnages à la position de
>>> print(word[:2])
Py
#mot 2(2 dont)Obtenez le personnage de la position à la fin
>>> print(word[2:])
thon
#Obtenez les caractères du début à la fin du mot
>>> print(word[:])
Python
Méthode liée aux caractères
#Définir la chaîne s
>>> s = 'Hello Tom. How are you doing.'
>>> print(s)
Hello Tom. How are you doing.
#Vérifiez si la chaîne contient une chaîne spécifique
>>> print(s.startswith('Hello'))
True
>>> print(s.startswith('Tom'))
False
#Caractères spécifiques dans la chaîne(ou chaîne de caractères)Vérifiez la position où(Depuis le début)
>>> print(s.find('o'))
4
#Caractères spécifiques dans la chaîne(ou chaîne de caractères)Vérifiez la position où(À partir de la fin)
>>> print(s.rfind('o'))
24
#Caractères spécifiques contenus dans la chaîne(ou chaîne de caractères)Vérifiez le nombre de
>>> print(s.count('o'))
5
#Convertit la première lettre de la chaîne en majuscule
>>> print(s.capitalize())
Hello tom. how are you doing.
#Convertit la première lettre de chaque mot de la chaîne en majuscules
>>> print(s.title())
Hello Tom. How Are You Doing.
#Convertir les chaînes en majuscules
>>> print(s.upper())
HELLO TOM. HOW ARE YOU DOING.
#Convertir la chaîne en chaîne inférieure
>>> print(s.lower())
hello tom. how are you doing.
#Remplacer une chaîne spécifique
>>> print(s.replace('Tom', 'Bob'))
Hello Bob. How are you doing.
Branche conditionnelle(if déclaration)
si expression conditionnelle 1:
Traitement à exécuter lorsque l'expression conditionnelle 1 est vraie
expression conditionnelle elif 2:
Traitement à exécuter lorsque l'expression conditionnelle 1 est fausse et que l'expression conditionnelle 2 est vraie
else:
Traitement à exécuter lorsque toutes les expressions conditionnelles sont fausses
--if est évalué dans l'ordre à partir du haut, et le traitement de la première clause true est exécuté. Si l'expression conditionnelle 1 est vraie, le traitement de l'expression conditionnelle 2 n'est pas exécuté même si le résultat de l'expression conditionnelle 2 est vrai.
Une valeur qui est fausse dans l'expression conditionnelle
- None
- False
-Type numérique zéro, 0, 0.0 、 0j(Nombre complexe)
-Objets vides d'objets conteneurs tels que chaînes, listes, dictionnaires, ensembles, etc.
-Méthode__bool__()Renvoie False
-Méthode__bool__()N'est pas défini et la méthode__len__()Objet qui renvoie 0
Comparaison numérique
#Vrai si équivalent
>>> 1 == 1
True
#Vrai sinon équivalent
>>> 1 != 1
False
#Vrai si le côté gauche est grand
>>> 1 > 0
True
#Vrai si le côté droit est grand
>>> 1 < 0
False
#Vrai si le côté gauche est grand ou équivalent
>>> 1 >= 0
True
#Vrai si le côté droit est grand ou équivalent
>>> 1 <= 0
False
# x < y and y <Équivalent à z
>>> x, y, z = 1, 2, 3
>>> x < y < z
True
Comparaison d'objets
>>> x = 'red'
>>> y = 'green'
#Vrai si équivalent
>>> x == y
False
#Vrai sinon équivalent
>>> x != y
True
#Vrai pour le même objet
>>> x is None
False
#Vrai sinon le même objet
>>> x is not None
True
>>> items = ['pen', 'note', 'book']
#En éléments'book'Vrai si est inclus
>>> 'book' in items
True
#En éléments'note'Vrai si n'est pas inclus
>>> 'note' not in items
False
pour déclaration
>>> items = [1, 2, 3]
>>> for i in items:
... print(f'La valeur de la variable i est{i}')
...
La valeur de la variable i est 1
La valeur de la variable i est 2
La valeur de la variable i est 3
# range()une fonction
>>> for i in range(3):
... print(f'{i}Deuxième processus')
...
0ème processus
Premier processus
Deuxième processus
# enumerate()une fonction
>>> chars = 'word'
>>> for count, char in enumerate(chars):
... print(f'{count}Le deuxième caractère est{char}')
...
Le 0ème caractère est w
La première lettre est o
Le deuxième caractère est r
Le troisième caractère est d
#Boucle de dictionnaire(items()Méthode)
>>> sports = {'baseball': 9, 'soccer': 11, 'tennis': 2}
>>> for k, v in sports.items():
... print(k, v)
...
baseball 9
soccer 11
tennis 2
#Boucle simultanée de deux séquences(zip()une fonction)
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue' ]
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
Comportement de la clause else de l'instruction for
>>> nums = [2, 4, 6, 8]
>>> for n in nums:
... if n % 2 == 1:
... break
... else:
... print('Il n'y a pas d'étrange')
...
Il n'y a pas d'étrange
--Dans la clause else, décrivez le processus que vous souhaitez exécuter une seule fois après la fin de l'instruction for. --Si la clause else est utilisée, le bloc de la clause else est exécuté lorsque l'instruction break n'est pas utilisée pendant le traitement de l'instruction for ou while.
instruction try
try:
Traitement pouvant provoquer une exception
sauf la classe d'exception que vous voulez attraper:
Que se passe-t-il lorsque l'exception que vous souhaitez intercepter
else:
Traitement exécuté uniquement lorsqu'aucune exception ne se produit
finally:
Le processus que vous souhaitez exécuter indépendamment du fait qu'une exception se produise
Clause --try: décrit le traitement qui peut provoquer une exception entre les clauses try-except.
try-sauf clause
#Accédez à un élément qui n'a pas de tableau, déclenchez une exception et interceptez-le dans la clause except.
>>> l = [1, 2, 3]
>>> i = 5
>>> try:
... l[i]
... except:
... print('It is no problem')
...
It is no problem
#Attraper une exception spécifique dans la clause except
>>> try:
... l[i]
... except IndexError:
... print('You got an IndexError')
...
You got an IndexError
#Afficher la cause de l'exception
>>> try:
... l[i]
... except IndexError as ex:
... print('You got an IndexError : {}'.format(ex))
...
You got an IndexError : list index out of range
#Attrapez toutes les exceptions
>>> try:
... () + l
... except IndexError:
... print('You got an IndexError')
... except BaseException as ex:
... print('You got an Exception : {}'.format(ex))
...
You got an Exception : can only concatenate tuple (not "list") to tuple
Hiérarchie des classes d'exception https://docs.python.org/ja/3/library/exceptions.html#exception-hierarchy
Clause --else: décrit le traitement à exécuter lorsqu'une exception ne se produit pas dans la clause else.
clause else
#Décrivez le traitement à exécuter lorsqu'une exception ne se produit pas dans la clause else.
>>> try:
... 1 + 1
... except BaseException:
... print('You got an Exception.')
... else:
... print('There are no Exceptions!')
...
2
There are no Exceptions!
--finally clause: Décrivez dans la clause finally le processus à exécuter indépendamment du fait qu'une exception se produise ou non.
clause enfin
#Décrivez dans la clause finally le processus à exécuter, qu'une exception se produise ou non.
>>> try:
... raise NameError('It is a NameError!!!')
... except NameError as ne:
... print(ne)
... finally:
... print('NameError Program finished!!!')
...
It is a NameError!!!
NameError Program finished!!!
augmenter la déclaration
#Vous pouvez relancer une exception en mentionnant simplement augmenter. (Si vous voulez savoir comment envoyer une exception, mais ne la traitez pas sur place)
>>> try:
... raise NameError('It is a NameError!!!')
... except NameError:
... print('Name Error.')
... raise
...
Name Error.
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
NameError: It is a NameError!!!
Type de liste
#Définition de la liste "l"
>>> l = [1, 2, 3, 4, 5]
>>> print(l)
[1, 2, 3, 4, 5]
#Obtenez un élément spécifique de la liste
>>> print(l[0])
1
>>> print(l[-1])
5
#Troisième depuis le début de la liste(0e, 1er, 2e)Jusqu'à l'élément de(N'inclut pas le troisième)Avoir
>>> print(l[:3])
[1, 2, 3]
#Troisième à partir de la fin de la liste(3 comprend)Aller de l'élément à la fin
>>> print(l[-3:])
[3, 4, 5]
#Obtenez tous les éléments de la liste
>>> print(l[:])
[1, 2, 3, 4, 5]
#Rejoindre la liste
>>> l2 = [6, 7, 8, 9, 10]
>>> print(l + l2)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
#Modifier les éléments de la liste
>>> l[2] = 300
>>> print(l)
[1, 2, 300, 4, 5]
Manipuler la liste
#Ajouter des éléments de liste(Dernier ajouté)
>>> l.append(600)
>>> print(l)
[1, 2, 300, 4, 5, 600]
#Ajouter des éléments de liste(Ajouter au début: Ajouter "0" au 0ème index)
>>> l.insert(0, 0)
>>> print(l)
[0, 1, 2, 300, 4, 5, 600]
#Obtenir des éléments de liste(Obtenir le dernier élément, disparaître de la liste)
>>> l.pop()
600
>>> print(l)
[0, 1, 2, 300, 4, 5]
#Obtenir un élément de liste (supprimer le 0e élément, disparaître de la liste)
>>> l.pop(0)
0
>>> print(l)
[1, 2, 300, 4, 5]
#Supprimer des éléments de liste(Supprimer le deuxième élément)
>>> del l[2]
>>> print(l)
[1, 2, 4, 5]
#Supprimer la liste (supprimer toute la liste)
>>> del l
>>> print(l)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'l' is not defined
#Supprimer tous les éléments de la liste (ne pas supprimer la liste)
>>> print(l)
[['A', 'B', 'C'], [1, 2, 3]]
>>> l.clear()
>>> print(l)
[]
#Supprime les éléments qui correspondent à la valeur spécifiée dans la liste
>>> l = [0, 1, 2, 3, 3, 3, 4, 5]
>>> l.remove(3)
>>> print(l)
[0, 1, 2, 3, 3, 4, 5]
#Supprimer l'élément qui correspond à la valeur spécifiée dans la liste (une erreur se produira s'il n'y a pas d'élément correspondant)
>>> l.remove(3)
>>> l.remove(3)
>>> l.remove(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>> print(l)
[0, 1, 2, 4, 5]
#Obtenez le nombre d'éléments dans la liste
>>> print(len(l))
5
#Imbrication de listes (création de listes avec des listes comme éléments)
>>> l1 = ['A', 'B', 'C']
>>> l2 = [1, 2, 3]
>>> l = [l1, l2]
>>> print(l)
[['A', 'B', 'C'], [1, 2, 3]]
#Obtenir l'index correspondant à la valeur spécifiée (erreur si l'élément n'existe pas)
>>> l = [1, 2, 3, 4, 5]
>>> l.index(3)
2
>>> l.index(6)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 6 is not in list
#Obtenir le nombre d'éléments qui correspondent à la valeur spécifiée
>>> l.count(4)
1
#Modifier les éléments de la liste dans l'ordre inverse
>>> print(l)
[1, 2, 3, 4, 5]
>>> l.reverse()
>>> print(l)
[5, 4, 3, 2, 1]
#Trier les éléments de la liste par ordre croissant
>>> l = [4, 5, 2, 1, 3]
>>> print(l)
[4, 5, 2, 1, 3]
>>> l.sort(key=None, reverse=False)
>>> print(l)
[1, 2, 3, 4, 5]
#Trier les éléments de la liste par ordre décroissant
>>> l = [4, 5, 2, 1, 3]
>>> print(l)
[4, 5, 2, 1, 3]
>>> l.sort(key=None, reverse=True)
>>> print(l)
[5, 4, 3, 2, 1]
#Stocker dans une liste séparée par des caractères spécifiques
>>> s = 'Hi, Tom. How are you doing?'
>>> print(s.split(' '))
['Hi,', 'Tom.', 'How', 'are', 'you', 'doing?']
>>> print(s.split('.'))
['Hi, Tom', ' How are you doing?']
Type de taple
#Déclaration Tupple(Défini comme un tapple avec ou sans parenthèses)
>>> t = (1, 2, 3, 4, 5)
>>> print(t)
(1, 2, 3, 4, 5)
>>> t2 = 1, 2, 3
>>> print(t2)
(1, 2, 3)
#Déclaration de tapple (à la fin de la définition ",Notez qu'il est défini comme un taple s'il y a
#Même s'il n'y a qu'un seul élément, ",Il faut décrire.
>>> t3 = 1,
>>> t3
(1,)
>>> type(t3)
<class 'tuple'>
#Contrairement aux listes, les taples ne peuvent pas changer leurs valeurs
>>> t[0] = 100
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
#Stockez la liste dans un taple et changez la valeur de la liste
>>> t = ([1, 2, 3], [4, 5, 6])
>>> t
([1, 2, 3], [4, 5, 6])
>>> t[0][0]
1
>>> t[0][0] = 100
>>> t
([100, 2, 3], [4, 5, 6])
Déballage Taple
#Attribuer la valeur du taple à une variable
>>> t = (1, 2, 3)
>>> t
(1, 2, 3)
>>> x, y, z = t
>>> print(x, y, z)
1 2 3
#Efficace lors de l'échange des valeurs de variables spécifiques, etc.
>>> X = 100
>>> Y = 200
>>> print(X, Y)
100 200
>>> X, Y = Y, X
>>> print(X, Y)
200 100
Type de dictionnaire (type de dictionnaire)
#Déclaration de type de dictionnaire (type de dictionnaire) ①
>>> d = {'x': 10, 'y': 20, 'z': 30}
>>> d
{'x': 10, 'y': 20, 'z': 30}
#Déclaration de type de dictionnaire (type de dictionnaire) ②
>>> dict(a=100, b=200, c=300)
{'a': 100, 'b': 200, 'c': 300}
#Obtention de la valeur d'une clé spécifique de type dictionnaire (type dictionnaire)
>>> d['y']
20
#Ajout de clés et de valeurs au type de dictionnaire (type de dictionnaire)
>>> d['a'] = 40
>>> d
{'x': 10, 'y': 20, 'z': 30, 'a': 40}
#Suppression de clés de type dictionnaire spécifique (type dictionnaire)
>>> del d['a']
>>> d
{'x': 10, 'y': 20, 'z': 30}
Opération de type de dictionnaire (type de dictionnaire)
#Acquisition de la liste de clés de type dictionnaire (type dictionnaire)
>>> d
{'x': 10, 'y': 20, 'z': 30}
>>> d.keys()
dict_keys(['x', 'y', 'z'])
>>> list(d.keys())
['x', 'y', 'z']
#Mise à jour du type de dictionnaire (type de dictionnaire) (combinaison)
#Mettez à jour la valeur de l'élément avec la clé, ajoutez la clé et la valeur de l'élément sans la clé
>>> d
{'x': 10, 'y': 20, 'z': 30}
>>> d2
{'x': 100, 'a': 1, 'b': 2}
>>> d.update(d2)
>>> d
{'x': 100, 'y': 20, 'z': 30, 'a': 1, 'b': 2}
#Obtenir la valeur d'une clé spécifique
>>> d.get('x')
100
#Obtenir la valeur d'une clé spécifique (la clé et la valeur récupérées ne sont plus dans la définition du dictionnaire)
>>> d
{'x': 100, 'y': 20, 'z': 30, 'a': 1, 'b': 2}
>>> d.pop('a')
1
>>> d.pop('b')
2
>>> d
{'x': 100, 'y': 20, 'z': 30}
#Vérifier si une clé spécifique est incluse dans le dictionnaire
>>> d
{'x': 100, 'y': 20, 'z': 30}
>>> 'x' in d
True
définir le type
>>> items = {'note', 'notebook', 'pen'}
>>> type(items)
<class 'set'>
>>> items
{'notebook', 'note', 'pen'}
#Les éléments en double en seront un
>>> items = {'note', 'notebook', 'pen', 'pen', 'note'}
>>> items
{'notebook', 'note', 'pen'}
#Ajouter un élément
>>> items.add('book')
>>> items
{'notebook', 'note', 'pen', 'book'}
#Supprimer l'élément
>>> items.remove('pen')
>>> items
{'notebook', 'note', 'book'}
#Extraire des éléments et les supprimer de l'ensemble
#Puisqu'il n'y a pas d'ordre, les éléments à récupérer sont indéfinis
>>> items.pop()
'notebook'
>>> items
{'note', 'book'}
--Le type frozenset est un type qui rend le type d'ensemble invariant (un type qui gère un ensemble invariant).
type de set figé
>>> items = frozenset(['note', 'notebook', 'pen'])
>>> type(items)
<class 'frozenset'>
>>> items
frozenset({'notebook', 'note', 'pen'})
#Ne peut pas être modifié car il s'agit d'un type immuable
>>> items.add('book')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
Définir le calcul
>>> set_a = {'note', 'notebook', 'pen'}
>>> set_b = {'note', 'book', 'file'}
#Ensemble de somme
>>> set_a | set_b
{'notebook', 'note', 'file', 'book', 'pen'}
>>> set_a.union(set_b)
{'notebook', 'note', 'file', 'book', 'pen'}
#Ensemble de différences
>>> set_a - set_b
{'notebook', 'pen'}
>>> set_a.difference(set_b)
{'notebook', 'pen'}
#Ensemble de produits
>>> set_a & set_b
{'note'}
>>> set_a.intersection(set_b)
{'note'}
#Différence de symétrie
>>> set_a ^ set_b
{'notebook', 'book', 'file', 'pen'}
>>> set_a.symmetric_difference(set_b)
{'notebook', 'book', 'file', 'pen'}
#Juger s'il s'agit d'un sous-ensemble
>>> {'note', 'pen'} <= set_a
True
>>> {'note', 'pen'}.issubset(set_a)
True
Notation d'inclusion de liste(Créer une liste)
#Créer une liste à l'aide de l'instruction for
>>> numbers = []
>>> for i in range(10):
... numbers.append(str(i))
...
>>> numbers
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
#Création d'une liste à l'aide de la notation d'inclusion de liste
>>> [str(v) for v in range(10)]
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
#Notation inclusive de la liste imbriquée
#Description utilisant l'instruction for
>>> tuples = []
>>> for x in [1, 2, 3]:
... for y in [4, 5, 6]:
... tuples.append((x, y))
...
>>> tuples
[(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]
#Création d'une liste imbriquée à l'aide de la notation d'inclusion de liste
>>> [(x, y) for x in [1, 2, 3] for y in [4, 5, 6]]
[(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]
#Notation d'inclusion avec instruction if
#Description utilisant l'instruction for
>>> even = []
>>> for i in range(10):
... if i % 2 == 0:
... even.append(i)
...
>>> even
[0, 2, 4, 6, 8]
#Description utilisant la notation d'inclusion
>>> [x for x in range(10) if x % 2 == 0]
[0, 2, 4, 6, 8]
Définition des fonctions
#Définition de la fonction (sans argument)
>>> def say_hello():
... print('Hello')
...
>>> say_hello()
Hello
#Définition de fonction (avec arguments)
>>> def say_something(str):
... print(str)
...
>>> say_something('Good morning')
Good morning
#Définition de fonction (avec arguments, avec arguments par défaut)
>>> def say_something(str='Hi!'):
... print(str)
...
#Si aucun argument n'est spécifié, l'argument par défaut est utilisé
>>> say_something()
Hi!
#Si un argument est spécifié, cet argument est utilisé.
>>> say_something('Hello')
Hello
#Définition de la fonction (avec valeur de retour)
>>> def increment(num):
... return num + 1
...
>>> increment(1)
2
--Lorsque l'instruction return est exécutée dans la fonction, le traitement s'arrête là, de sorte que le traitement suivant n'est pas exécuté.
Arguments de fonction
#Argument de position->Stocké dans les variables dans l'ordre passé lors de l'appel de la fonction(Erreur si le nombre d'arguments est différent)
>>> def increment(num1, num2):
... return num1 + num2
...
>>> increment(2, 4)
6
#Argument de mot-clé->Spécifiez les arguments de mot-clé lors de l'appel(L'ordre n'a pas d'importance)
>>> def greeting(name, str):
... print(str + ', ' + name + '!')
...
>>> greeting(str='Hello', name='Tom')
Hello, Tom!
#Argument par défaut->Une valeur par défaut peut être spécifiée pour l'argument formel (cependant, l'argument formel avec la valeur par défaut doit être décrit après l'argument formel sans la valeur par défaut).
>>> def greeting(name, str='Hi'):
... print(str + ', ' + name + '!')
...
>>> greeting('Tom')
Hi, Tom!
#Argument de position de longueur variable->Peut accepter n'importe quel nombre d'arguments (la position spécifiée est à la fin de l'argument positionnel et avant l'argument avec la valeur par défaut)
>>> def say_something(name, *args):
... for str in args:
... print("I'm " + name + ". " + str + "!")
...
>>> say_something('Tom', 'Hello', 'Hi', 'Good morning')
I'm Tom. Hello!
I'm Tom. Hi!
I'm Tom. Good morning!
'
#Argument de mot-clé de longueur variable->Reçoit les arguments de mot-clé qui n'ont pas été affectés à des arguments formels dans le type de dictionnaire (la position spécifiée est la dernière)
>>> def print_birthday(family_name, **kwargs):
... print("Birthday of " + family_name + " family")
... for key, value in kwargs.items():
... print(f'{key}: {value}')
...
>>> print_birthday('Smith', Nancy='1990/1/1', Tom='1993/1/1', Julia='2010/1/1')
Birthday of Smith family
Nancy: 1990/1/1
Tom: 1993/1/1
Julia: 2010/1/1
#Arguments positionnels et mots-clés de longueur variable->Peut gérer n'importe quel appel d'argument
>>> def say_something(*args, **kwargs):
... for s in args:
... print(s)
... for key, value in kwargs.items():
... print(f'{key}: {value}')
...
>>> say_something('Hello', 'Hi', 'Bye', Nancy='29 years old', Tom='26 years old')
Hello
Hi
Bye
Nancy: 29 years old
Tom: 26 years old
#Argument de mot clé uniquement->Arguments qui nécessitent un nom d'argument formel lorsqu'ils sont appelés
# 「*Seuls les mots clés sont des arguments après "
>>> def increment(num, lsat, *, ignore_error=False):
... pass
...
#Une erreur se produira avec un argument positionnel
>>> increment(1, 2, True)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: increment() takes 2 positional arguments but 3 were given
#Ne peut être spécifié qu'avec des arguments de mot-clé
>>> increment(1, 2, ignore_error=True)
>>>
#Argument de position uniquement->Arguments pour lesquels un nom d'argument formel ne peut pas être spécifié au moment de l'appel
# 「/Seule la position est l'argument avant. Si un nom d'argument formel est spécifié dans la fonction abs, une erreur se produit.
>>> help(abs)
abs(x, /)
Return the absolute value of the argument.
>>> abs(x=-1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: abs() takes no keyword arguments
Déballage de la liste d'arguments
#Passez la valeur stockée dans la liste comme argument
>>> def greeting(x, y, z):
... print(x)
... print(y)
... print(z)
...
>>> contents = ['Hello', 'Good morning', 'Bye']
#Lors de l'appel d'une fonction, "*Développer les arguments de la liste avec l'opérateur
>>> greeting(*contents)
Hello
Good morning
Bye
#Passez la valeur stockée dans le dictionnaire comme argument
>>> def say_something(name, greeting):
... print(name)
... print(greeting)
...
>>> dict = {'greeting': 'Hello'}
#Lors de l'appel d'une fonction, "**Développer les arguments du dictionnaire avec l'opérateur
>>> say_something('Julia', **dict)
Julia
Hello
syntaxe d'expression lambda
argument lambda 1,Argument 2,Argument 3, ...:Expression qui devient la valeur de retour
Exemple d'expression lambda
>>> increment = lambda num1, num2: num1 + num2
>>> increment(1, 2)
3
#Synonyme de
>>> def increment(num1, num2):
... return num1 + num2
...
>>> increment(1, 2)
3
#Seuls restent ceux dont la fonction de premier argument est vraie.
>>> nums = ['one', 'two', 'three']
>>> filterd = filter(lambda x: len(x) == 3, nums)
>>> list(filterd)
['one', 'two']
--Ajoutez des informations de type à la fonction avec une annotation.
Syntaxe pour donner des informations de type
nom de la fonction def(arg1:Type d'arg1, arg2:Type d'arg2, ...) ->Type de retour:
#Le processus que vous souhaitez exécuter avec la fonction
return Valeur de retour
>>> def say_something(name: str, age: int) -> str:
... print(name)
... print(age)
... return name
...
>>> say_something('Tom', 29)
Tom
29
'Tom'
Définition de classe
nom de classe de classe(Nom de la classe de base):
nom de la méthode def(Argument 1,Argument 2, ...):
Le processus que vous souhaitez exécuter dans la méthode
return Valeur de retour
>>> class Person(object):
... def say_something(self):
... print('Hello!!!')
...
#Instancier la classe
>>> person = Person()
#Invocation de la méthode d'instance
>>> person.say_something()
Hello!!!
Initialisation de l'instance
>>> class Person:
... def __init__(self):
... print('Init completed!')
... def say_something(self):
... print('Hello!!!')
...
#Processus d'initialisation lors de la création d'une instance(__init__Traitement défini dans)Est appelé
>>> person = Person()
Init completed!
>>> person.say_something()
Hello!!!
@property(setter)
>>> class Person:
... @property
... def name(self):
... return self._name
... @name.setter
... def name(self, name):
... self._name = name
...
>>> person = Person()
>>> person.name = 'Tom'
>>> person.name
'Tom'
--Attribut commençant par un trait de soulignement (_name): indique qu'il s'agit d'un attribut privé. --Attribut commençant par 2 traits de soulignement (\ _ \ _ nom): la modification du nom est effectuée. (Exemple: Convertissez la variable "\ _ \ _name" de la classe Person en "\ _Person__name".) Utilisé pour éviter les conflits de nom dans les sous-classes.
Héritage de classe
>>> class Person:
... def greeting(self):
... print('Hello')
... def say_something(self):
... print('I am human')
...
>>> class Man(Person):
... #Remplacement de méthode
... def say_something(self):
... print('I am a man')
...
>>> man = Man()
>>> man.say_something()
I am a man
#Classe de base(Classe de personne)La méthode est également disponible
>>> man.greeting()
Hello
--Un fichier .py avec code
Création d'un module (nom du module: exemple.py）
import sys
def say_something_upper(s):
#Convertir en majuscules
upper_s = s.upper()
return upper_s
str = sys.argv[1]
print(say_something_upper(str))
module(sample.py)Appel
$ python sample.py hello
HELLO
$
Écrire du code qui ne fonctionne que lorsqu'il est exécuté directement
import sys
def say_something_upper(s):
#Convertir en majuscules
upper_s = s.upper()
return upper_s
def main():
str = sys.argv[1]
print(say_something_upper(str))
if __name__ == '__main__':
main()
__init__.py
#Le fichier vide est OK
python_programming/sample.py
from python_package import hello
def say_hello():
print(hello.return_hello())
def main():
say_hello()
if __name__ == '__main__':
main()
python_programming/python_package/hello.py
def return_hello():
return 'Hello!!!'
Résultat d'exécution
$ python sample.py
Hello!!!
$
--Comment écrire l'importation
Comment écrire l'importation
#Importer un package
nom du package d'importation
import sample_package
#Importer un module spécifique à partir d'un package(de non spécifié)
nom du package d'importation.Nom du module
import sample_package.greeting
#Importer un module spécifique à partir d'un package(de spécifié)
à partir du nom du package nom du module d'importation
from sample_package import greeting
#Importez uniquement des attributs spécifiques à partir de packages et de modules
du nom du package/Importation du nom du module Nom de la fonction
from sample_package.greeting import say_something
#Paquet importé/module/Donnez à la fonction un alias
à partir du nom du package importer le nom du module comme alias
from sample_package.greeting import say_something as s
Importation en masse
#Caractère générique (*) Pour importer par lots
depuis l'importation du nom du package*
from sample_package import *
__init__.py
__all__ = ["morning", "evening", "night"]
Prémisse: Il existe de nombreux modules dont" matin "," soir "," nuit "dans sample_package
Les fonctions intégrées sont des fonctions intégrées à Python qui peuvent être utilisées sans rien importer.
--isinstance (): renvoie True si l'objet d'instance passé dans le premier argument appartient à la classe passée dans le deuxième argument.
isinstance()
>>> d = {}
#Le premier argument est un objet d'instance
>>> isinstance(d, dict)
True
#Si le deuxième argument est un taple, il sera comparé dans plusieurs classes en même temps.
>>> isinstance(d, (list, int, dict))
True
--issubclass (): presque identique à isinstance (), mais prend un objet de classe comme premier argument.
issubclass()
#Le premier argument est un objet de classe
>>> issubclass(dict, object)
True
#le type booléen est une sous-classe de type int
>>> issubclass(bool, (list, int, dict))
True
--callable (): juge les objets appelables (fonctions, classes, méthodes, etc. qui peuvent être appelées avec ())
callable()
>>> callable(isinstance) #une fonction
True
>>> callable(Exception) #classe
True
>>> callable(''.split) #Méthode
True
--getattr () / setattr () / delattr (): manipuler les attributs d'objet
getattr()/setattr()/delattr()
#Exemple de définition de classe
>>> class Mutable:
... def __init__(self, attr_map):
... for k, v in attr_map.items():
... setattr(self, str(k), v)
...
#Définir les attributs sur m
>>> m = Mutable({'a': 1, 'b': 2})
>>> m.a
1
>>> attr = 'b'
#Obtenez de la valeur
>>> getattr(m, attr)
2
#Supprimer la valeur
>>> delattr(m, 'a')
>>> m.a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Mutable' object has no attribute 'a'
# getattr()Peut également obtenir des méthodes
>>> str = 'python'
>>> instance_method = getattr(str, 'upper')
>>> instance_method()
'PYTHON'
--zip (): renvoie plusieurs éléments itérables en même temps
zip()
#Résumer les i-èmes éléments de chaque itérable
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> zip(a, b)
<zip object at 0x10827a7d0>
>>> list(zip(a, b))
[(1, 4), (2, 5), (3, 6)]
# zip()Renvoie les résultats uniquement jusqu'à la plus courte longueur itérable
>>> d = [1, 2, 3]
>>> e = [4, 5, 6, 7, 8]
>>> f = [9, 10]
>>> zip(d, e, f)
<zip object at 0x10827a7d0>
>>> list(zip(d, e, f))
[(1, 4, 9), (2, 5, 10)]
#Si vous souhaitez adapter le plus long iterable, la bibliothèque standard itertools.zip_longest()Utiliser la fonction
>>> from itertools import zip_longest
>>> list(zip_longest(d, e, f, fillvalue=0))
[(1, 4, 9), (2, 5, 10), (3, 6, 0), (0, 7, 0), (0, 8, 0)]
--sort (): Trier les éléments de l'itérable
sorted()
>>> a = [3, 2, 5, 1, 4]
>>> b = [2, 1, 4, 5, 3]
# list.sort()Se trie
>>> a.sort()
>>> a
[1, 2, 3, 4, 5]
# sorted()Renvoie une nouvelle liste
>>> sorted(b)
[1, 2, 3, 4, 5]
>>> b
[2, 1, 4, 5, 3]
# reverse=Si True est spécifié, l'ordre sera inversé.
>>> sorted(b, reverse=True)
[5, 4, 3, 2, 1]
Puisque sorted () compare les éléments directement, une erreur se produira si les nombres et les chaînes sont mélangés
Voir ci-dessous pour d'autres fonctions intégrées
Liste des fonctions intégrées Python https://docs.python.org/ja/3/library/functions.html
Une méthode spéciale est une méthode avec deux traits de soulignement (__) avant et après le nom de la méthode, et est implicitement appelée depuis Python.
Méthode spéciale
#Dans la classe "Word", une méthode spéciale, "__init__」「__str__」「__len__Définir
>>> class Word(object):
... def __init__(self, text):
... self.text = text
... def __str__(self):
... return 'Word!!!'
... def __len__(self):
... return len(self.text)
#Instancier la classe
>>> w = Word('test')
#Lorsque vous essayez de traiter w comme une chaîne de caractères, implicitement "__str__Est appelé
>>> print(w)
Word!!!
#Quand j'essaye de lancer "len" pour obtenir la longueur de w, je dis implicitement "__len__Est appelé
>>> print(len(w))
4
#Méthode de description originale (accédez au texte d'attribut de l'instance w et récupérez la valeur de len)
>>> print(len(w.text))
4
Voir ci-dessous pour d'autres méthodes spéciales
Nom de la méthode spéciale Python https://docs.python.org/ja/3/reference/datamodel.html#special-method-names
open()Ecrire un fichier en utilisant
#Le premier argument est le nom du fichier et le deuxième argument est le mode
#Mode (l'argument est facultatif, omis pour "r")
#"R": lecture seule
#"W": exportation uniquement
#"A": Ajout (ajout à la fin du fichier)
# 「r+": Lecture et écriture
>>> f = open('test.txt', 'w')
>>> f.write('Test!')
>>> f.close()
#Comme suit "test."txt" est généré et "Test"!"Est écrit.
[localhost]$ cat test.txt
Test!
[localhost]$
#Il est également possible d'écrire dans un fichier avec print
>>> f = open('test.txt', 'w')
>>> print('Print!', file=f)
>>> f.close()
#Comme suit "test."txt" est généré et "Imprimer"!"Est écrit.
[localhost]$ cat test.txt
Print!
[localhost]$
#Options lors de l'utilisation de l'impression
>>> f = open('test.txt', 'w')
>>> print('My', 'name', 'is', 'Tom', sep='###', end='!!!', file=f)
>>> f.close()
#Le délimiteur est "" spécifié en sep.###(La valeur par défaut est un espace demi-largeur), et enfin "" spécifié par end!!!"Est écrit.
[localhost]$ cat test.txt
My###name###is###Tom!!!
[localhost]$
read()Lire des fichiers avec
#En guise de préparation préliminaire, "test.txt "préparé
>>> f = open('test.txt', 'w')
>>> print('My', 'name', 'is', 'Tom', end='!\n', file=f)
>>> print('My', 'name', 'is', 'Nancy', end='!\n', file=f)
>>> print('My', 'name', 'is', 'Julia', end='!\n', file=f)
>>> f.close()
[localhost]$ cat test.txt
My name is Tom!
My name is Nancy!
My name is Julia!
[localhost]$
# read()Lisez le contenu du fichier en utilisant
>>> f = open('test.txt', 'r')
>>> f.read()
'My name is Tom!\nMy name is Nancy!\nMy name is Julia!\n'
>>> f.close()
# readline()Lire ligne par ligne en utilisant
>>> f = open('test.txt', 'r')
>>> f.readline()
'My name is Tom!\n'
>>> f.readline()
'My name is Nancy!\n'
>>> f.readline()
'My name is Julia!\n'
>>> f.close()
Manipuler des fichiers à l'aide de l'instruction with
# with open()Lorsque vous manipulez un fichier avec()Aucun traitement n'est requis.
>>> with open('test.txt', 'a') as f:
... print('with open statement!', file=f)
...
>>>
[localhost]$ cat test.txt
My name is Tom!
My name is Nancy!
My name is Julia!
with open statement!
[localhost]$
--Lors de l'exploitation d'un fichier avec open (), la mémoire est utilisée jusqu'à ce que close () soit exécuté, il est donc nécessaire de libérer la mémoire en fermant () à la fin. D'un autre côté, dans le cas de with open (), lorsque le traitement dans le retrait de la clause with open () est terminé, il se fermera () sans permission, vous n'oublierez donc pas de fermer ().
Recommended Posts