C'est la fin des bases.

Fonctions, fonctions intégrées

Vous pouvez définir et utiliser un groupe de programmes en tant que fonction.

En outre, les fonctions prédéfinies en python lui-même C'est ce qu'on appelle une fonction intégrée.

Considérez-le comme le numéro de programme de la variable

Méthode

Une méthode est une méthode qui effectue un traitement sur une valeur spécifique.

`Méthode`


valeur.Nom de la méthode()

Je vais l'écrire sous la forme de.

Il existe également une variable d'instance qui récupère les éléments de valeur et ainsi de suite. Les variables d'instance n'ont pas d'arguments car ce sont des variables et non des fonctions.

`Variable d'instance`


valeur.Nom de la variable d'instance

Écrivez dans le format.

Prenant append comme exemple, c'est comme suit.

`append`


# append()Est une méthode à utiliser lorsque vous souhaitez ajouter un seul nouvel élément à la liste.

alphabet = ["a","b","c","d","e"]
alphabet.append("f")
print(alphabet) 
# ["a", "b", "c", "d", "e", "f"]Est sortie

Méthode de type chaîne (supérieure / nombre)

Une méthode pour agrandir et compter les caractères.

city = "Tokyo"
print(city.upper()) #"TOKYO" est sorti
print(city.count("o")) #"2" est émis.

Méthode de type chaîne (format)

La méthode format () est une méthode qui peut être utilisée pour les types chaîne, et vous pouvez incorporer des variables dans des chaînes. Il est principalement utilisé lors de l'insertion de la valeur d'une variable dans un modèle. Spécifiez l'emplacement où vous souhaitez incorporer la valeur avec {}. L'argument n'a pas besoin d'être de type chaîne.

print("je{}naissance,{}Élevé".format("Tokyo", "Saitama"))
#"Je suis né à Tokyo et j'ai grandi à Saitama" est sortie


# {}La valeur à insérer peut également spécifier l'ordre d'insertion. Vous pouvez également insérer la même valeur à plusieurs reprises.

print("je{1}naissance,{0}Grandir{1}Résident".format("Tokyo", "Saitama"))
#"Je suis né à Saitama, j'ai grandi à Tokyo et je vis à Saitama" est sortie

Méthode du type de liste (index)

Le type de liste a un numéro d'index.

Le numéro d'index est le nombre lorsque le contenu de la liste est compté dans l'ordre à partir de 0.

En tant que méthode pour savoir dans quel numéro d'index se trouve l'objet cible

index()

il y a. De plus, le type de liste a été traité plus tôt.

count()

Peut être utilisé.


alphabet = ["a", "b", "c", "d", "d"]
print(alphabet.index("a")) 
#Puisqu'il est dans le 0ème numéro d'index, "0" est affiché.
print(alphabet.count("d")) 
# "d"Est dans les 3e et 4e numéros d'index, donc "2" est émis.

Méthodes de type liste (tri, inverse, trié)

sort()

Cela triera la liste par ordre croissant.

reverse()

Cela peut être utilisé pour inverser l'ordre des éléments dans la liste.

En guise de mise en garde

Utilisez les méthodes sort () ou reverse () pour modifier directement le contenu de la liste.
Puisqu'il ne prend pas de valeur de retour, None est retourné même si vous imprimez (list.sort ()).

Si vous voulez simplement voir la liste triée, utilisez la fonction intégrée sorted () qui renvoie le tableau trié.

soted()

Voici un exemple d'utilisation.

# sort()Exemple d'utilisation

list = [1, 10, 2, 20]
list.sort()
print(list) # [1, 2, 10, 20]Il sera affiché.

# reverse()Exemple d'utilisation

list = ["Ah", "je", "U", "e", "Oh"]
list.reverse()
print(list) # ["Oh", "e", "U", "je", "Ah"]Il sera affiché.

une fonction

Créez comme suit.

"Nom de la fonction Def(): 」

Les fonctions peuvent organiser le traitement nécessaire, ce qui simplifie le programme. Il a l'avantage de faciliter la compréhension du mouvement global.

Le même processus peut être réutilisé à plusieurs endroits, ce qui entraîne une réduction de la quantité de description et une amélioration de la lisibilité.

def sing():
    print ("chanter!")

#L'étendue du traitement est spécifiée par indentation.
#En outre, l'appel à la fonction définie est "nom de fonction".()".

sing() 
 #Résultat de sortie chanter!

argument

Si vous définissez un argument lors de la définition d'une fonction, Vous pourrez utiliser cette valeur dans la fonction.

nom de la fonction def(argument):

def introduce(n):
    print(n + "est")

introduce("Yamada")
#"It's Yamada" est sorti
#À ce stade, si vous spécifiez l'argument en tant que variable, vous pouvez modifier le résultat de sortie sans modifier directement l'argument.

def introduce(n):
    print(n + "est")

name = "Yamada"
introduce(name) #"It's Yamada" est sorti

name = "Tanaka"
introduce(name) #"C'est Tanaka" est sorti
#Notez que les variables et arguments définis dans la fonction ne peuvent être utilisés que dans la fonction.

Arguments multiples

Vous pouvez spécifier plusieurs arguments séparés par des virgules.

def introduce(first, family):
    print("Le nom de famille est" + family + "Et le nom est" + first + "est.")

introduce("taro", "Yamada") 
#"Le nom de famille est Yamada et le nom est taro." Est sortie.

Valeur initiale de l'argument

Si vous définissez la valeur initiale (par défaut) dans l'argument Si l'argument est vide, la valeur initiale sera définie automatiquement. Argument = Défini sous la forme d'une valeur initiale.

def introduce(family="Yamada", first="Taro"):
    print("Le nom de famille est" + family + "Et le nom est" + first + "est.")


introduce("Suzuki")
#"Le nom de famille est Suzuki et le prénom est Taro."
#Dans ce cas, seul le premier est défini comme valeur initiale et la famille est"Suzuki"Il a été remplacé par.

#Introduisez si vous voulez passer uniquement le premier argument(first="Jiro")Il vous suffit de préciser.

#De plus, il est nécessaire de toujours définir la valeur initiale dans l'argument après l'argument pour lequel la valeur initiale est définie.
#Par conséquent, il est possible de définir la valeur initiale uniquement pour le dernier argument comme suit.

def introduce(family, first="Taro"):
    print("Le nom de famille est" + family + "Et le nom est"+ first + "est.")
#Toutefois, si vous ne définissez pas la valeur initiale uniquement pour l'argument précédent et la définissez pour le dernier argument comme suit, une erreur se produira.

def introduce(family="Suzuki", first):
    print("Le nom de famille est" + family + "Et le nom est" + first + "est.")
#La sortie d'erreur dans ce cas est non-L'argument par défaut suit l'argument par défaut.

return

Les variables et arguments définis dans une fonction ne peuvent pas être utilisés en dehors de la fonction. Cependant, vous pouvez utiliser return pour transmettre la valeur de retour à l'appelant de la fonction.

`error`


def introduce(family = "Yamada", first = "Taro"):
    comment = "Le nom de famille est" + family + "Et le nom est" + first + "est."

print(introduce("Suzuki")) 
#Aucun n'est émis
#Il n'y a pas de valeur de retour ici, donc le résultat de sortie est Aucun(Aucun)Sera.


def introduce(family = "Yamada", first = "Taro"):
    comment = "Le nom de famille est" + family + "Et le nom est" + first + "est."
    return comment #Passez la valeur de retour à la fonction

print(introduce("Suzuki")) 
#"Le nom de famille est Suzuki et le prénom est Taro."

De cette façon, vous pouvez utiliser return pour transmettre la valeur de retour à l'appelant de la fonction.

Importation de fonctions (packages, sous-packages, modules)

Plus récemment à partir d'un module en tant qu'importation de fonction C'est un format pour sortir l'unité de l'emballage.

Il existe des packages scipy et des modules horaires.

Package: une collection de modules connexes dans un répertoire
Sous-packages: il peut y avoir plus de packages imbriqués dans le package. Dans ce cas, le package imbriqué est appelé.
Module: Un fichier qui combine plusieurs processus fréquemment exécutés et les rend disponibles à un autre code source.

Lors de l'utilisation d'un package ou d'un module dans un programme, le processus d'importation suivant est requis.

import scipy #Importez le package scipy
import time #Importer le module horaire

#Lors de l'utilisation des méthodes dans le package importé
#Généralement, le nom du package.Nom du sous-paquet.Écrivez-le comme nom de méthode. N'oubliez pas que cela fonctionne comme une méthode.

import scipy.linalg

scipy.linalg.norm([1,1])

>Résultat de sortie
1.4142135623730951

Dans l'exemple ci-dessous, l'heure actuelle est sortie à l'aide de la méthode temporelle du module horaire.

import time

now_time = time.time() #Heure actuelle maintenant_Remplacer le temps

print(now_time) #L'heure actuelle est sortie

De plus, à partir du nom du package. Vous pouvez également charger la méthode directement. Dans ce cas, lors de l'appel de la méthode Le nom du package et le nom du sous-package peuvent être omis.

from scipy.linalg import norm

norm([1, 1]) #Le nom du package / nom du module peut être omis

#Résultat de sortie
1.4142135623730951

du nom du module Vous pouvez omettre le nom du module en écrivant le nom de la méthode d'importation.

from time import time #Importer la méthode de temps du module de temps

now_time = time() #Le nom du module peut être omis

print(now_time) #L'heure actuelle est sortie

En utilisant le nom du package d'importation comme nom Vous pouvez appeler le package avec n'importe quel nom.


from time import time as t 
#Importez la méthode de temps du module de temps et manipulez-la avec le nom t

now_time = t()

print(now_time) #L'heure actuelle est sortie

classe

objet

Python est un langage orienté objet. Un objet est une collection de données et de procédures (méthodes) pour ces données.

Une procédure décrit le traitement d'un objet. L'image de l'objet est un dessin de conception. Instancier un objet Le traitement est effectué lorsqu'un message (instruction) est envoyé.

Méthode de réutilisation d'un programme en capturant la cible de traitement en tant qu'objet et en la modularisant. Cela s'appelle orienté objet.

classe

C'est comme un plan pour la structure d'un objet. Si vous le dites en grand format.

Classe: Type Instance: grand format Objet: ensemble grand format (classe + instance)

Contenu de la classe

Les classes incluent les initialiseurs, les méthodes, les variables membres, etc.

Initialiseur: processus qui a lieu immédiatement après la création d'une instance à partir d'une classe. Il est essentiellement appelé une seule fois. Si vous le faites avec le nom suivant, c'est décidé par la syntaxe.

__init__()

Méthode: comme expliqué précédemment
Les variables membres sont des variables utilisées dans la classe.


class MyProduct: #Définir la classe
    def __init__(self, name, price): #Définir l'initialiseur
        self.name = name #Stocker les arguments dans les membres
        self.price = price
        self.stock = 0
        self.sales = 0
#Créer une instance à partir de la classe définie

#Appelez MyProduct et créez product1
product1 = MyProduct("cake", 500)

print(product1.name) #Nom de sortie du produit1
cake

print(product1.price) #Prix de sortie du produit1
500

Règles de classe (self, initializer)

Mettez en majuscule la première lettre du nom de la classe S'il est habituel et contient plusieurs mots Capitalisez chaque début, tel que Mon produit.
Initialisation (init, selfz) La classe étant un dessin de conception, elle doit être initialisée lors de la création d'une instance. L'initialiseur est défini avec le nom init Il existe une convention selon laquelle le premier argument est le soi.

 class MyProduct: #Définir la classe
    def __init__(self,argument): #Définir l'initialiseur

Utilisation de soi

self fait référence au corps de l'instance (MyProduct dans ce cas) Vous pouvez utiliser self pour obtenir d'autres variables membres de l'instance Vous pouvez appeler la méthode.

`Exemple`


class MyProduct: #Définir la classe
    def __init__(self, name, price): #Définir l'initialiseur
        self.name = name #Stocker les arguments dans les membres
        self.price = price
        self.stock = 0 # stock,les ventes sont initialisées avec 0
        self.sales = 0
#Ensuite, créez une instance à partir de la classe définie.
#En instanciation, classe(MyProduct)Pour affecter à une variable.

#Appelez MyProduct et créez product1
product1 = MyProduct("cake", 500)

print(product1.name) #Nom de sortie du produit1
>Résultat de sortie
cake

print(product1.price) #Prix de sortie du produit1
>Résultat de sortie
500

print(product1.stock)
>Résultat de sortie
0

Classe (méthode)

Il existe trois types de méthodes qui peuvent être définies dans une classe:

Méthode normale ... Le premier argument est self.
Méthode de classe ... Fait fonctionner toute la classe.
Méthode statique (méthode statique) ... Peut être exécutée sans arguments.

class MyClass:  #nom de la classe
    def __init__(self,Argument 2,Argument 3, …):  #Initialiseur
        self.Nom de variable=valeur initiale#Initialiser les variables

    def normal_method(self,Argument 2,Argument 3, …):  #Méthode normale
        self.name = name
        return name

    @classmethod  #Méthode de classe
    #Les méthodes de classe ont une règle selon laquelle le premier argument est cls.
    def class_method(cls,Argument 2,Argument 3, …):
        cls.name = cname
        return cname

    @staticmethod  #Méthode statique
    #Les méthodes statiques ne sont pas conventionnelles et les arguments eux-mêmes ne sont pas nécessaires.
    def static_method(Argument 1,Argument 2,Argument 3, …):
Argument 1.name = sname
        return sname

Les méthodes de classe ont une règle selon laquelle le premier argument est cls Les méthodes statiques ne sont pas conventionnelles et les arguments eux-mêmes ne sont pas nécessaires.

En outre, l'appel de méthode est écrit sous le nom object.method.

Objet.Nom de la méthode

Classe (héritage, remplacement, super)

Héritage: hérite du contenu de la classe.
Override: Remplacer la méthode de la classe héritée par la classe héritée
Classe parente, super classe, classe de base: classe héritière
Classes enfants, sous-classes, classes dérivées: classes héritées


#Classe parent
class MyProduct:
    def __init__(self, name, price, stock):
        self.name = name
        self.price = price
        self.stock = stock
        self.sales = 0

    def buy_up(self, n): #Méthode d'achat
        self.stock += n

    def get_name(self): #Méthode du nom du produit
        return self.name

    def sell(self, n): #Méthode de vente
        self.stock -= n
        self.sales += n * self.price

    def summary(self): #Méthode de présentation
        message = "called summary().\n name: " + self.name + \
        "\n price: " + str(self.price) + \
        "\n price: " + str(self.get_price_with_tax()) + \
        "\n sales: " + str(self.sales)
        print(message)

#La procédure d'héritage est la suivante.


#Définissez MyProductSalesTax en héritant de la classe MyProduct
class MyProductSalesTax(MyProduct):

    #Définir le taux de taxe à la consommation comme quatrième argument de l'initialiseur
    def __init__(self, name, price, stock, tax_rate):
        #Appelez l'initialiseur de la classe parent
        super().__init__(name, price, stock)
        self.tax_rate = tax_rate

    #MyProduct obtenir_Remplacer le nom
    def get_name(self):
        return self.name + "(taxe inclu)"

    #get_price_with_ajouter une taxe
    def get_price_with_tax(self):
        return int(self.price * (1 + self.tax_rate))
# super()Vous pouvez appeler la méthode de la classe parent avec. Lorsque ce programme est exécuté, ce sera comme suit.

product_3 = MyProductSalesTax("phone", 30000, 100, 0.1)
print(product_3.get_name())
print(product_3.get_price_with_tax())
#Appelez la méthode de résumé de MyProduct
product_3.summary()

phone(taxe inclu) #Sortie comme prévu
33000      #Sortie comme prévu
called summary() 
name: phone
price: 30000
stock: 100
sales: 0

Spécification du format de chaîne de caractères

Le format de la chaîne de caractères sortie vers la console peut être formaté à l'aide de la "méthode format". Voici quelques-uns des formats utilisés pour organiser les parties numériques contenues dans une chaîne de caractères.

: d données de type int affichées en notation décimale : .0f Type flottant Les données affichent uniquement une partie entière : .2f Données de type flottant jusqu'à la deuxième décimale Utilisez ces formats comme indiqué dans le code ci-dessous.

#Définir une approximation du rapport de circonférence
pi = 3.141592
 #Définissez le rapport de circonférence sur 3
pi2 = 3
print("Le rapport de circonférence est{:d}".format(pi2)) # 「Le rapport de circonférence est3」と出力される
print("Le rapport de circonférence est{:.0f}".format(pi)) # 「Le rapport de circonférence est3」と出力される
print("Le rapport de circonférence est{:.2f}".format(pi)) # 「Le rapport de circonférence est3.14 "est émis.

Les bases de Python ③

Fonctions, fonctions intégrées

Méthode

Méthode

Variable d'instance

append

Méthode de type chaîne (supérieure / nombre)

Méthode de type chaîne (format)

Méthode du type de liste (index)

Méthodes de type liste (tri, inverse, trié)

une fonction

argument

Arguments multiples

Valeur initiale de l'argument

error

Importation de fonctions (packages, sous-packages, modules)

classe

objet

classe

Contenu de la classe

Règles de classe (self, initializer)

Exemple

Classe (méthode)

Classe (héritage, remplacement, super)

Spécification du format de chaîne de caractères

`Méthode`

`Variable d'instance`

`append`

`error`

`Exemple`