Mémo de grammaire de base Python

bloquer

• Les blocs comme {} tels que Java sont représentés par une indentation.

commentaire

• Le commentaire est «#». Avec les guillemets triples, il peut être utilisé comme commentaire sur plusieurs lignes.

variable

--Créer la variable Nom de la variable = Valeur

• Les noms de variables sont généralement séparés par «_», comme «sample_color». --Il n'y a fondamentalement pas de constantes comme const. Nom avec une majuscule et un trait de soulignement, tel que «CONST_VALUE = 100».
• Vous pouvez vérifier le type avec la fonction type ().
• Vous pouvez trouver le numéro d'identification d'un objet avec ʻid (object) `.

Type numérique

• Il existe trois types de types numériques en Python: le type entier (int), le type à virgule flottante (float) et le type de nombre complexe (complexe). --Literal, «5» est un entier, «5.0» est un flottant, «0xff = 255» est un hexadécimal, «0o23 = 19» est un octal, «0b1111 = 15» est un binaire.
• Vous pouvez convertir un type chaîne en un type float avec float (" 160.5 ").
• Expression exponentielle 9.5e3 == 9.5 * 10 ** 3 --Convertir du type caractère au type entier avec ʻint ("5") . Convertissez les nombres hexadécimaux en types entiers avec ʻint ("FFF", 16) . --Convertir du type numérique au type caractère avec str (valeur numérique). Utilisez hex () ʻoct () `` bin () `pour convertir respectivement les types de caractères hexadécimal, octal et binaire.

opérateur

• Les quatre règles sont «+ - * /»
• La puissance doit être `` ** ''
• Division de la troncature, //
• Reste, % --En tant qu'opérateur d'affectation, + = - = * = / = // =% = etc. peut être utilisé. «++ -» ne peut pas être utilisé.

Type de chaîne

--Entrez le type de chaîne entre guillemets simples ou doubles. Échappez-vous avec \.

• Pour décrire une chaîne sur plusieurs lignes, placez-la entre guillemets triples.
• Les chaînes peuvent être combinées avec «+».

fonction d'impression, fonction d'entrée

--Afficher à l'écran avec print (argument 1, argument 2, ...). Évitez les sauts de ligne print (argument 1, argument 2, ..., end =" ") --Pour entrer à partir du clavier, le type de chaîne est renvoyé comme str = input (" Enter: ").

Type de séquence (liste, tapple, chaîne, etc.)

--Créez un type de liste comme hauteur = [180, 165, 159, 171, 155]. --Récupérez le contenu du type de liste comme dans height [0].

• Vous pouvez changer le contenu comme height [1] = 182.
• Obtenez la valeur la plus à droite avec height [-1]. --Retournez la longueur de la liste avec len (hauteur). --Créez un type de tapple comme height_tuple = (180, 165, 159, 171, 155). Taple est une liste dont la valeur ne peut pas être modifiée. () peut être omis. La façon de récupérer la valeur est la même que la liste.
• Vous pouvez convertir entre liste et taple avec list () tuple ().

import

--ʻImport Importe le module avec le nom du module. --Créez une instance de la classe en appelant module name.constructor. --Appeler une méthode avec ʻinstance variable. Nom de la méthode (argument, ...) .

import calendar
cal = calendar.TextCalendar()
cal.prmonth(2016, 1)

--depuis l'importation du nom du module Si vous spécifiez le nom de la classe 1, le nom de la classe 2, ..., vous pouvez omettre le nom du module lors de l'appel de la classe.

from calendar import TextCalendar
cal = TextCalendar()
cal.prmonth(2016, 1)

• Importer des modules de fonction (identique à l'importation de classe) --Lorsque vous importez le nom du module, vous pouvez appeler la fonction avec le nom du module. --à partir de l'importation du nom du module Lorsque le nom de la fonction 1, le nom de la fonction 2, ... , le nom de la fonction peut être appelé directement. --Lisez toutes les fonctions avec from module name import *.

Utilisation de nombres aléatoires

• import random --Avec randint (0,3), générer un nombre aléatoire avec un entier compris entre 0 et 3. --Avec randrange (3). Génère un nombre aléatoire entier de 0 ou plus et de moins de 3.

si déclaration

si expression conditionnelle A:
Processus 1
expression conditionnelle elif B:
Processus 2
else:
Processus 3

--Utilisez ʻand ʻou comme opérateur logique.

• L'expression conditionnelle peut être écrite comme «3 <= mois <5». --Les listes et taples peuvent être déterminées par ʻin`` 3 dans [1, 2, 3, 4] `
• «3 not in [1, 2, 3, 4]» peut être utilisé pour déterminer s'il n'est pas inclus. --ʻIn not in peut également être utilisé pour les chaînes de caractères" jour "dans" Lundi, mardi, mercredi, jeudi, vendredi, samedi et dimanche "` --Il n'y a pas d'instruction switch en Python.
• Vous pouvez utiliser l'opérateur ternaire comme suit.

Valeur 1 si expression conditionnelle sinon valeur 2

msg = "Bonjour" if hour < 18 else "Bonsoir"

Traitement en boucle

--Il n'y a pas de boucle do ~ while en Python --range ([début,] fin [, étape])

#pour déclaration
for l in list:
En traitement

#Répéter 10 fois(i=1〜9)
for i in range(10):
En traitement

#Convertir l'objet de plage en liste
l = list(range(0, 31, 10))
# i=[0, 10, 20, 30]

# while
tandis que l'expression conditionnelle:
En traitement

• Vous pouvez utiliser la fonction enumerate () pour récupérer des paires d'index / élément.

countries = ["France", "Amérique", "Chine" , "Allemagne" , "Japon"]
for index, country in enumerate(countries):
  print(str(index + 1) + ":", country)

• La fonction zip (List 1, List 2, ...) vous permet de récupérer plusieurs valeurs de liste en séquence sous forme de taples jusqu'à ce que l'élément de liste le plus court soit épuisé.

weekday1 = ["Sun", "Mon", "Tue" , "Wed" , "Thu"]
weekday2 = ["journée", "Mois", "Feu" , "eau" , "bois", "Argent", "sol"]
for (eng, jap) in enumerate(weekday1, weekday1):
  print(eng + ":" + jap)

• Vous pouvez écrire le processus lorsque la boucle for se termine par else. Cependant, il ne sera pas exécuté s'il est interrompu par rupture.

pour variable dans un objet itérable:
Corps de boucle
else:
Bloc à exécuter une fois terminé

Gestion des exceptions

--Si vous ne spécifiez pas d'exception sauf, vous pouvez intercepter n'importe quelle exception.

• Sauf, vous pouvez spécifier plusieurs exceptions à l'aide de tapples.
• Vous pouvez décrire le traitement lorsqu'une exception ne se produit pas avec else.

try:
Traitement pouvant provoquer une exception
sauf exception:
Que faire si une exception se produit
else:
Que faire si aucune exception ne se produit

Utilisation de chaînes de caractères

--Saisie des lettres majuscules avec " python ".upper (). --Saisissez les lettres minuscules avec " python ".lower (). --Compte le nombre d'occurrences de la chaîne de caractères spécifiée par " python ".count (" y "). --Retourne True / False si elle se termine par la chaîne spécifiée par " / python / ".startswith (" / "). --Retourne True / False si elle se termine par la chaîne de caractères spécifiée par " / python / ".endswith (" / "). --Retourne True / False si la chaîne spécifiée par " python ".find (" t ") est incluse. --Concatène et renvoie la chaîne de caractères spécifiée par «», «.join (list)» et la liste.

• "Python".replace（"n", "a") # Pythoa --"Apple Orange Ananas" .split ("") # ['Apple', 'Orange', 'Pineapple']Séparer avec un séparateur. -- "Ananas" [4: 9] # pomme Extrait le 4e à 9-1 = 8e à partir de 0. --Vous pouvez omettre la valeur de départ ou la position finale avec [valeur de départ:] et [: position finale]. -- "Mois" dans "Lundi, mardi, mercredi, jeudi, vendredi, samedi et dimanche" # True ʻin pour vérifier s'il est inclus. -- "abcde" .find ("d")) # 3 find ()` renvoie la position où la chaîne a été trouvée. S'il n'est pas trouvé, renvoie -1.
• " Hello {Bienvenue dans le monde des} {} mois {} jours ".format (" Python ", 12, 24) au format # Hello Python Bienvenue dans le monde le 24 décembre, au format{} Vous pouvez intégrer des lettres et des chiffres.
• "Bonjour et bienvenue dans le monde des {2} {0} mois {1} jours" .format (12, 24, "Python") avec un numéro dans le # Hello Python Bienvenue dans le monde 24 décembre `{} , L'ordre peut être spécifié.
• Vous pouvez spécifier le nombre de chiffres de la virgule décimale avec {numéro d'argument: .digit f}.
• Vous pouvez insérer des virgules séparées par 3 chiffres avec {numéro d'argument:,}.

Fonctionnement de base des listes et des taples

--Combinez les listes avec «+». [" Printemps "," Été "] + [" Automne "," Hiver "] # [" Printemps "," Été "," Automne "," Hiver "] (Créer une nouvelle liste)

• Répétez la liste avec «*». [" Printemps "," Été "] * 3 # ['Printemps', 'Été', 'Printemps', 'Été', 'Printemps', 'Été'] (Créer une nouvelle liste)
• Récupère les éléments de la liste [position de départ à partir de 0: numéro suivant après la position de fin à partir de 0].
• Vous pouvez récupérer des éléments pour chaque étape avec [:: Number of Steps]. --Dans «élément de la liste» que vous voulez trouver, retournez True / False s'il existe. Renvoie qu'il n'existe pas avec «not in». --Retourne l'ordre dans list.index (élément à rechercher), mais renvoie une exception ValueError si elle n'est pas trouvée. --Modifiez la valeur de la liste avec list [index] = valeur. Si aucun index n'est trouvé, une exception ʻIndexError` est déclenchée.
• Vous pouvez ajouter des valeurs à la liste avec list.append (valeurs que vous voulez ajouter). Lorsque vous ajoutez une liste, elle est ajoutée en tant qu'élément et la liste est imbriquée.
• Vous pouvez supprimer le premier élément qui correspond à une valeur avec list.remove (valeur que vous souhaitez supprimer)`. (Même s'ils correspondent, le deuxième et les suivants ne seront pas supprimés)
• Vous pouvez supprimer l'élément de l'index spécifié dans del list [index]. --Dans la del list [1: 4], les index 1 à 3 peuvent être supprimés. --max (liste) min (liste) somme (liste) renvoie respectivement les valeurs maximum, minimum et total. --Utilisez l'opérateur == pour voir si les listes ont la même valeur. Utilisez l'opérateur ʻispour déterminer si l'objet est le même. --Utilisezlist.reverse ()` pour inverser la liste elle-même.

Arguments de ligne de commande

• L'argument de ligne de commande peut être obtenu à partir de sys.argv, le 0ème est le nom du fichier du programme d'exécution et le 1er ~.

import sys
#Énumérer pour obtenir le numéro d'index()Utiliser une fonction
for i,a in enumerate(sys.argv):
    print(i,a)

dictionnaire

--Dictionary {Clé 1: Valeur 1, Clé 2: Valeur 2, Clé 3: Valeur 3, ...} --Le nombre d'éléments est len (dictionnaire) --Tapuru peut être utilisé comme clé de dictionnaire {(" Japan "," Tokyo "):" Chiyoda-ku ", (" Japan "," Chiba Prefecture "):" Funabashi City ", (" Japan "," Saitama Prefecture " "):" Kawaguchi City "}

• Récupération de la valeur Dictionary [clé] --Mise à jour de la valeur Dictionary [clé] = Nouvelle valeur
• Ajout d'une paire Dictionary [clé à ajouter] = valeur à ajouter --Supprimer la paire del dictionary [key] --Si vous spécifiez une clé qui n'existe pas, vous obtiendrez une exception KeyError. --Vérifiez si la clé existe `` Clé dans le dictionnaire ''
• Utilisé pour les instructions (itérer)
• Obtenez une liste de clés Dictionary.keys ()
• Obtenez une liste de valeurs Dictionary.values ()
• Obtenez une liste de paires Dictionary.items () --Un programme qui compte le nombre de fruits qui apparaissent dans une chaîne de caractères

fruits = "apple orange strawberry banana orange apple grape strawberry apple"

count = {}

fruits_list = fruits.split(" ")

for f in fruits_list:
    if f in count:
        count[f] += 1
    else:
        count[f] = 1

for k, v in count.items():
    print(k, v)

# apple 3
# orange 2
# strawberry 2
# banana 1
# grape 1

Ensemble

--Une liste qui ne permet pas la duplication est un ensemble, composé de {élément 1, élément 2, élément 3, ...}.

• Un ensemble peut être créé à partir d'une liste avec set (list), éliminant la duplication. --Ajoutez un élément avec set.add (élément à ajouter). --Supprimer les éléments avec set.remove. --Supprimez tous les éléments avec set.clear ().
• Vérifiez s'il est inclus dans ʻin. --set1 | set2 renvoie un nouvel ensemble contenant les deux. --set1 & set2 renvoie un nouvel ensemble avec des éléments communs aux deux. --set1 --set2 renvoie un nouvel ensemble inclus dans set1 et non inclus dans set2. --set1 ^ set2` renvoie un nouvel ensemble contenu dans set1 ou set2.

Notation d'inclusion

--[Expression pour les variables dans les objets itérables]Créer une liste

l = [num ** 2 for num in range(0, 21, 2)]
# [0, 4, 16, 36, 64, 100, 144, 196, 256, 324, 400]

dolls = [1,55,243,445,178]
rate = 106
yens = [d * rate for d in dolls]
# [106, 5830, 25758, 47170, 18868]

--Ajout de ʻif`` [expression pour la variable dans l'objet itérable si expression conditionnelle] `

address = ["Quartier Chiyoda, Tokyo", "Setagaya-ku, Tokyo", "Saitama, préfecture de Saitama", "Préfecture de Kanagawa à Yokohama-City", "Adachi-ku, Tokyo"]
#Sortez uniquement à Tokyo
tokyo = [a for a in address if a.startswith("Tokyo")]
# ['Quartier Chiyoda, Tokyo', 'Setagaya-ku, Tokyo', 'Adachi-ku, Tokyo']

people = [("Suzuki", "femme"), ("Yamada", "Homme"), ("Takahashi", "femme"), ("Sato", "Homme")]
#Sortez le nom d'un seul homme
man = [p[0] for p in people if p[1] == "Homme"]

--Inclusions de dictionnaires {clé: valeur de la variable dans un objet itérable}

en = ["apple", "orange", "cherry", "banana"]
jp = ["pomme", "Orange", "Cerise", "banane"]
fruits = {k: v for k, v in zip(en, jp)}
# {'apple': 'pomme', 'orange': 'Orange', 'cherry': 'Cerise', 'banana': 'banane'}

--Définir la notation d'inclusion (expression de la variable dans l'objet itérable} --Il n'y a pas de notation d'inclusion de tapple.

une fonction

nom de la variable def(Argument 1,Argument 2, ...):
En traitement
return Valeur de retour

• Appelant d'argument de mot-clé: f (p1 = 100, p2 = 200)
• Argument par défaut Côté définition de la fonction: f (a = 1, b =" vide "):
• Les arguments passés à la fonction ne sont pas reflétés à l'appelant même s'ils sont modifiés dans la fonction, mais les changements sont reflétés lorsqu'un argument mutable est passé à la fonction (uniquement les méthodes destructives telles que append).

def change(a):
    a.append(4)

a = [1, 2, 3]
change(a)
print(a)
# [1, 2, 3, 4]

Portée variable

--Variable pour l'ensemble du programme de variables créé en dehors de la fonction de portée globale --Variations créées dans les fonctions de portée locale --S'il y a le même nom, la portée locale a la priorité, donc si vous voulez l'assigner à une variable globale dans la fonction, vous devez la définir avec global global variable name.

Argument de longueur variable

--Lors de la définition d'arguments de longueur variable, préfixez le nom de la variable avec «*». def (* objects, sep = ''): L'argument après la variable de longueur variable doit être un argument de mot-clé. (Parce que je ne sais pas à quelle distance se trouve l'argument de longueur variable)

• Les arguments de longueur variable sont reçus sous forme de taples.

Recevoir des arguments de mots-clés sous forme de dictionnaire

--Si vous ajoutez «**» avant le nom de l'argument formel, vous pouvez recevoir n'importe quel nombre d'arguments spécifié par le mot-clé sous forme de dictionnaire.

def dic(**a):
    print(a)

dic(height=100, width=80, depth=50)
# {'height': 100, 'width': 80, 'depth': 50}

Les fonctions sont aussi des objets

--hello (a) peut être appelé comme my_func (a) en remplaçant my_func = hello.

Style Lambda

--lambda Argument 1, Argument 2, Argument 3, ...: Traitement

• Des arguments de mots clés, des valeurs par défaut et des arguments de longueur variable peuvent également être utilisés.

smaller = lambda n1, n2: n2 if n1 > n2 else n1
print(smaller(9, 2)) # 2
print(smaller(1, 11))  # 1

ave = lambda *n : sum(n) / len(n)
print(ave(1, 5, 10, 50, 1000, 5000, 10000))  # 2295.1428571428573

La fonction map () qui traite les éléments de la liste ensemble

--map (fonction, liste) Renvoie comme objet de carte. (Objet Itetable) --list (map (fonction, liste)) Retourner sous forme de liste

def cm(inch): return inch*2.54

inches = map(cm, [1, 2, 5, 10, 100])

for i in inches:
    print(i)

print(list(map(cm, inches))) # [2.54, 5.08, 12.7, 25.4, 254.0]
#C'est la même chose même si vous écrivez comme suit
print(list(map(lambda inch: inch*2.54, [1, 2, 5, 10, 100]))) # [2.54, 5.08, 12.7, 25.4, 254.0]
#Notation d'inclusion
print([n*2.54 for n in [1, 2, 5, 10, 100]]) # [2.54, 5.08, 12.7, 25.4, 254.0]

La fonction filter () qui filtre les valeurs de la liste

--filter (function, list) Renvoie l'élément qui est True dans la fonction en tant qu'objet itérable.

print(list(filter(lambda n: n % 2 == 0, range(0, 10)))) # [0, 2, 4, 6, 8]
#Notation d'inclusion
print([n for n in range(0, 10) if n % 2 == 0]) # [0, 2, 4, 6, 8]

Trier la liste

--Trier la liste elle-même avec list.sort (). Triez la liste elle-même dans l'ordre inverse avec list.sort (reverse = True). --Renvoie une liste triée par liste triée = triée (liste). --Liste triée = triée (liste avant le tri, clé = str.upper)Trier en majuscules --Liste triée = triée (touche = fonction)Trier par le résultat de la fonction

Trier le dictionnaire

names = {"taro": 2, "jiro": 4, "saburo": 1, "shiro": 3}
#Trier par valeur
print(sorted(names.items(), key=lambda n: n[1])) # [('saburo', 1), ('taro', 2), ('shiro', 3), ('jiro', 4)]
#Trier par valeur (ordre inverse)
print(sorted(names.items(), key=lambda n: n[1], reverse=True)) # [('jiro', 4), ('shiro', 3), ('taro', 2), ('saburo', 1)]

Fonction générateur

• Renvoyer la valeur avec yield au lieu de return
• Récupérez ce qui suit avec la fonction next (). --Si vous le récupérez avec for, aucune exception ne se produira.

def gen(str):
  for c in str.upper():
    yield c

yes = gen("yes")
print(next(yes)) # Y
print(next(yes)) # E
print(next(yes)) # S
print(next(yes)) #Exception StopIteration

for h in gen("hello"):
  print(h, end="")

# HELLO

Type de générateur

--(Expression de la variable dans l'objet itérable)

• À première vue, cela ressemble à une notation d'inclusion de tapple, mais il n'y a pas de notation d'inclusion de tapple.

gen = (c for c in "hello".upper())

for g in gen:
    print(g, end="")

Lecture de fichiers

--Ouvert et fermé --f = open (nom de fichier, mode, encodage)

• La valeur par défaut est mode = "r", encoding = "utf_8"
  • f.close()
• read --str = f.read () Lit le fichier entier sous forme de chaîne --str = f.read (5) Lit le nombre de caractères spécifié. Relisez la suite avec read (nombre de caractères)
• readlines --lines = f.readlines () Lire chaque ligne comme un élément de la liste. Le code de saut de ligne est «\ n». --lines = f.readlines (2) Lire avec une taille limitée
• leadline --f.readline () Lire ligne par ligne sous forme de chaîne de caractères. Renvoie un caractère vide à la fin du fichier.
• Même si vous utilisez pour i, ligne dans enumerate (f), il lira ligne par ligne dans ligne.
• Si vous utilisez l'instruction with, vous n'avez pas besoin de fermer.

with open("hello.txt") as f:
    print(f.read())

with open("hello.txt") as f:
    for i, line in enumerate(f):
        print(i, line, end="")

classe

• Les noms de classe utilisent généralement une majuscule en majuscule comme MyClass --Constructeur def __init __ (soi, argument 1, argument 2, ...): --Mettez une valeur dans une variable d'instance self. Nom de la variable d'instance = valeur --Génération de l'instance Variable = Nom de la classe (argument, ...) Puisque le premier argument self du constructeur se contient automatiquement, spécifiez le deuxième argument et les suivants.
• La variable à laquelle la valeur est affectée dans le constructeur est la variable d'instance, et celle à laquelle la valeur est affectée en dehors de la méthode est la variable de classe.
• La définition de la méthode est def method name (self, argument, ...):
• Les méthodes privées préfixent le nom de la méthode avec «__». Ajoutez _ aux méthodes accessibles de l'extérieur mais auxquelles vous ne souhaitez pas accéder
• Les méthodes getter et setter sont généralement nommées get_name``` set_name. --Définissez les propriétés avec nom de la propriété = propriété ([méthode setter [, méthode getter]])

class Customer:
    #Variable de classe
    bmi = 22

    #constructeur
    def __init__(self, number, name, height=0):
        #Variable d'instance
        self.__number = number
        self.__name = name
        self.__height = height

    #Getter
    def get_name(self):
        return self.__name

    def get_number(self):
        return self.__number

    #Setter
    def set_number(self, number):
        self.__number = number

    def get_height(self):
        return self.__height

    #Calculer le poids standard
    def std_weight(self):
        return Customer.bmi * (self.height / 100) ** 2

    #Paramètres de propriété
    name = property(get_name)
    number = property(get_number, set_number)
    height = property(get_height)


if __name__ == "__main__":
    #Création d'objets
    taro = Customer(101, "Taro Saito", 180)
    #Changer la valeur
    taro.number = 150
    print("No.{}de{}Est le poids standard{:.2f}C'est kg.".format(
        taro.number, taro.name, taro.std_weight()))

# No.Le poids standard de Taro Saito de 150 est de 71.Il pèse 28 kg.

module

• Le nom du module sera le nom du fichier sans l'extension .py. --Lorsque le nom du fichier est «customer_m1.py», «customer_m1» est le nom du module.
• Il est d'usage d'utiliser des lettres minuscules et des traits de soulignement pour les noms de modules et les noms de fichiers. --ʻSi name == Le bloc "main": `est appelé lorsque seul le nom de fichier est spécifié.

Héritage de classe

--Définissez avec nom de la sous-classe de classe (nom de la superclasse).

• Appelez le constructeur de la superclasse avec super () .__ init__ (argument)

Référence: [Basic Python Basic Series](https://www.amazon.co.jp/%E5%9F%BA%E7%A4%8EPython-%E5%9F%BA%E7%A4%8E%E3%82 % B7% E3% 83% AA% E3% 83% BC% E3% 82% BA-% E5% A4% A7% E6% B4% A5-% E7% 9C% 9F-ebook / dp / B01CZDTIKC)