Je suis un programmeur Java qui a commencé à étudier Python avec élan car je suis à court de messages en Java. Cliquez ici pour l'article d'étude sur "si, pour, tandis que des phrases" deux fois avant. Cliquez ici pour le précédent article d'étude sur "À propos des moisissures".
De nos jours, je me demande si je devrais étudier Python au lieu d'étudier les qualifications AWS. Après tout, le codage est amusant, n'est-ce pas? (excuse Je suis sérieux cette semaine. (Peut être pas
Cette fois, je vais étudier les fonctions (méthodes).
Commençons par vérifier la forme de la fonction de base (méthode). Avec Java
HelloMethodDemo1.java
static void hello() {
System.out.println("Hello World!");
}
public static void main(String[] args) {
hello();
}
Avec Python,
HelloMethodDemo1.py
def hello():
print('Hello World!')
hello()
Le résultat de l'exécution est l'habituel
Hello World!
Au fait, si vous écrivez avec un motif qui retourne,
HelloMethodDemo2.java
static String hello() {
return "Hello World!";
}
public static void main(String[] args) {
System.out.println(hello());
}
HelloMethodDemo2.py
def hello():
return 'Hello World!'
print(hello())
Python est si élégant que Java ressemble à un mauvais langage redondant. Python est plus rapide à écrire que Java, endetté depuis plus de trois ans. Je suis sur le point de perdre le sens de l'étude de Java. (Exagération
Ce qui est défini dans le module est une fonction, et ce qui est défini dans la classe est une méthode. Donc, ce que nous écrivons ci-dessus est une fonction. La méthode est
HelloMethodDemo3.py
class TestClass:
#Méthode
def hello(self):
print('Hello World!')
Je dis quelque chose comme ça.
Il existe de nombreux cas où vous souhaitez passer un argument à une fonction (méthode) pour traitement. Avec Java
AddDemo.java
static int add(int a, int b) {
return a + b;
}
public static void main(String[] args) {
System.out.println(add(1, 2));
}
Avec Python,
AddDemo.py
def add(a, b):
return a + b
print(add(1, 2))
La seule différence avec Java est la présence ou l'absence de déclaration de type, donc je pourrais comprendre le modèle avec des arguments sans aucun problème.
Dans le Site (Python-izm) auquel j'ai fait référence cette fois, Il y avait une description que la valeur initiale peut être définie dans l'argument. Ce qui suit est un extrait du site de référence.
Si vous spécifiez une valeur initiale pour l'argument, vous pouvez l'omettre lors de l'appel de la fonction.
Je vois. C'est pourquoi je l'ai écrit.
AddDemo2.py
def add(a, b=2):
return a + b
print(add(1)) #Résultat d'exécution: 3
print(add(1, 3)) #Résultat d'exécution: 4
À propos, lorsque je l'ai défini comme premier argument, il a échoué avec une erreur. La valeur initiale ne pouvait être définie que pour le dernier argument.
AddDemo3.py
#Exemple d'erreur
def add(a=1, b):
return a + b
print(add(2))
def add(a=1, b=2):
return a + b
Cette fonctionnalité n'est pas disponible en Java. (C'était tout à fait une fonctionnalité en PHP, C ++, C # et d'autres langages. J'ai utilisé PHP et C # mais je ne l'ai jamais vu ...) C'est ... quel est le meilleur moment pour l'utiliser ...? ?? ?? Il n'y a vraiment pas de scène où le cerveau Java soit utile ...
Vous pouvez également définir tapple etc. dans l'argument. Plus précisément, utilisez * (astérisque).
ArgsDemo.py
def variable(*args):
print(args)
variable('a', 'b', 'c')
Le résultat de l'exécution est
('a', 'b', 'c')
En Python Les variables définies en dehors de la fonction sont des ** variables globales **, Les variables définies dans une fonction sont appelées ** variables locales **. ~~ * Identique à Java ~~
Lors de l'affectation à une variable globale dans une fonction, déclarez-la comme globale avant de l'exécuter. Pour référence uniquement, aucune déclaration globale n'est requise.
Alors, j'ai essayé de l'écrire en code en l'imitant. S'il s'agit d'une image en Java,
IncrementsDemo.java
public class Main {
public static int count = 1;
void increments() {
System.out.println(count);
count++;
System.out.println(count);
}
public static void main(String[] args) throws Exception {
Main main = new Main();
main.increments();
}
}
Le résultat de l'exécution est
1
2
J'ai écrit ceci en python.
IncrementsDemo.py
count = 1
def increments():
print(count)
global count
count += 1
print(count)
increments()
Lançons-le.
Main.py:5: SyntaxWarning: name 'count' is used prior to global declaration
global count
C'est un avertissement, pas une erreur, mais \ (^ o ^) / Eh bien, en recherchant ce genre de choses sur Google, vous pouvez apprendre de nouvelles choses. (Deuxième excuse
C'est pourquoi j'ai cherché sur Google et extrait de le premier site qui est apparu. (En ce qui concerne l'exemple de code, il s'agit de la série Python 2, mais ...)
Notez que le nom qui indique une variable globale dans l'instruction globale ne doit pas être d'abord utilisé comme variable locale dans le même bloc de code. Vous ne pouvez pas avoir de variables locales et globales avec le même nom dans une fonction.
Hé ~ _〆 (・ ∀ ・ *) Donc, cette fois, il semble qu'il est inutile de déclarer global après avoir fait référence à count avec print immédiatement après la fonction.
J'ai donc essayé de le réparer comme ci-dessous.
IncrementsDemo.py
count = 1
def increments():
global count
count += 1
print(count)
print(count)
increments()
Courez à nouveau
1
2
Hmm, c'est fait. Lorsque vous utilisez une variable globale dans une fonction, déclarez-la globale lors de son affectation. Non requis lors du référencement des variables globales. Il semble préférable de s'en souvenir.
class Main:
def __init__(self):
self.count = 1
def increments(self):
print(self.count)
self.count += 1
print(self.count)
@staticmethod
def main():
main = Main()
main.increments()
Main.main()
C'est un gros problème, alors notez ce que vous avez appris du code ci-dessus.
Le trait de soulignement utilisé dans le nom de la fonction a une signification décente. Le site de référence est ici.
Si défini avec deux traits de soulignement, ceux qui ne reçoivent pas de références externes. (Privé à Java?) S'il est défini avec un trait de soulignement, il est d'usage de ne pas y faire référence de l'extérieur, mais il est en fait accessible.
Le site de référence décrit également comment l'utiliser correctement. J'ai l'impression que vous ne pourrez peut-être pas l'utiliser correctement tant que vous ne vous y serez pas habitué personnellement ...
C'est ce qu'on appelle un décorateur. Je l'ai écrit dans l'impression qui sortira plus tard, mais même si je lis différents sites, je ne le comprends pas bien, alors je vais arrêter d'écrire ici ...
Ensuite, à propos de l'expression lambda. Il a été adopté depuis 8 pour Java.
Au fait, Java a une forme comme celle-ci.
LambdaDemo.java
Hoge hoge = (name) -> {
return "Hello " + name + "!";
};
Je suis un putain de petit poisson, Namekuji, qui n'a pas tellement maîtrisé le style Lambda, alors je veux maîtriser le style Lambda ...
Pour revenir à l'histoire, les expressions lambda existent également en Python. Voici le résultat de son utilisation en l'imitant.
LambdaDemo.py
output = lambda name: 'Hello' + name + '!'
print(output('lambda'))
Le résultat de l'exécution est
Hello lambda!
Est-ce plus facile à lire que Java? Je me sens comme. Cependant, j'ai vu un exemple de code que je voulais appliquer au tricot, mais je ne pouvais pas du tout comprendre. Plus tard, je pense qu'il vaut mieux étudier plus dur ...
En Java, c'est une interface qui traite les éléments dans l'ordre avec Map, List, etc. C'est celui qui utilise next (), hasNext (), remove (), etc.
Dans le cas de Python, il semble être utilisé lors du traitement des éléments tels que les listes, les tableaux et les dictionnaires dans l'ordre.
L'idée semble être la même que Java. Cependant, il n'y a presque pas de temps pour écrire explicitement "Iterator" en Java. (Est ce juste moi ...) De plus, Java 8 a ajouté l'API Stream, alors pourquoi ne pas l'utiliser de plus en plus? Je pense.
En Java, je sens que j'écris souvent sous la forme suivante.
java::IteratorDemo.java
List<String> list = new ArrayList<>();
Collections.addAll(list, "Sun.", "Mon.", "Tues.", "Wed.", "Thurs.", "Fri.", "Sat.");
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
java::IteratorDemo.java
List<String> list = new ArrayList<>();
Collections.addAll(list, "Sun.", "Mon.", "Tues.", "Wed.", "Thurs.", "Fri.", "Sat.");
for(Iterator<String> iterator = list.iterator(); iterator.hasNext(); ) {
System.out.println(iterator.next());
}
(On a l'impression que vous pouvez étendre les phrases en tant que Liste!)
Résultat d'exécution
Sun.
Mon.
Tues.
Wed.
Thurs.
Fri.
Sat.
Que se passe-t-il avec Python?
IteratorDemo.py
week = ['Sun.', 'Mon.', 'Tues.', 'Wed.', 'Thurs.', 'Fri.', 'Sat.']
iter_week = iter(week)
for i in iter_week:
print(i)
Ce nombre extrêmement petit de caractères d'entrée! Je trouve assez pratique d'utiliser l'instruction for pour passer à l'itérateur suivant.
week = ['Sun.', 'Mon.', 'Tues.', 'Wed.', 'Thurs.', 'Fri.', 'Sat.']
for i in week:
print(i)
En passant, comme Java, vous pouvez également utiliser la fonction suivante.
IteratorDemo.py
week = ['Sun.', 'Mon.', 'Tues.', 'Wed.', 'Thurs.', 'Fri.', 'Sat.']
iter_week = iter(week)
print(next(iter_week))
print(next(iter_week))
print(next(iter_week))
print(next(iter_week))
print(next(iter_week))
print(next(iter_week))
print(next(iter_week))
Cela se comportera toujours de la même manière que le résultat de l'exécution ci-dessus. Au fait, dans le dernier élément, lorsque j'ai utilisé à nouveau la fonction suivante, j'ai eu une exception ** StopIteration **.
Je ne l'ai pas encore appris, mais il semble qu'il y ait aussi un essai ~ sauf la syntaxe.
Ce n'est pas en Java. Cela semble être un parent de l'itérateur et un objet répétable. Il existe des fonctions de générateur et des expressions de générateur, et la fonction de générateur est appelée générateur. La fonction de générateur peut être réalisée en utilisant le mot-clé yield. Pour être honnête, je ne le comprends pas vraiment, alors je l'ai écrit.
Il imite l'exemple Python-izm.
YieldDemo.py
def func():
yield('Bonjour')
yield('Bonjour')
yield('Bonsoir')
f = func()
print(next(f))
print(next(f))
print(next(f))
Le résultat de l'exécution est
Bonjour
Bonjour
Bonsoir
À propos, lorsque j'ai utilisé à nouveau la fonction suivante, j'ai eu une exception ** StopIteration **.
L'impression est que c'est similaire à la liste.
Ce qui suit est un extrait de l'explication de Python-izm.
Vous pouvez effectuer un traitement en boucle avec> for etc., mais la différence par rapport au traitement itératif avec une liste etc. est que la valeur est générée et renvoyée autant que nécessaire à chaque fois.
Cela semble avoir l'avantage que le générateur consomme moins de mémoire que la liste. De plus, lorsque vous utilisez une grande quantité de données, il semble préférable d'utiliser un générateur qu'une liste. (Je suis un putain de petit programmeur de poissons, donc je ne pense pas que je serai redevable pour le moment ...)
Cette fois, j'ai étudié les fonctions (méthodes). Les itérateurs et les générateurs semblent être assez profonds. Peut-être que lorsque j'ai essayé de l'utiliser, j'ai eu l'impression que ce serait assez difficile.
D'ailleurs, il y avait une introduction du décorateur (@), donc j'ai lu l'explication + j'ai googlé les points que je ne comprends pas. Du coup, je ne comprenais pas du tout ce que je disais, alors j'ai arrêté d'écrire sur les décorateurs cette fois. (Hey Quand je peux le comprendre, je l'ajouterai à cet article ou le posterai comme nouvel article.
De plus, ce serait bien d'avoir une comparaison entre la notation d'inclusion de Python et le traitement Stream forEach de Java + lambda.
J'ai reçu un commentaire. Notation d'inclusion? ?? ?? J'y ai pensé, mais j'étais confus comme "Qu'est-ce que c'est ... l'inclusion? Extension? Je ne sais pas comment ça marche ...". Il semble que celui qui ne peut pas écrire la notation d'inclusion en utilisant Python est inutile. Je ne sais pas si c'est vrai (hey Je pense ajouter ceci à cet article ou le publier comme nouvel article avec le décorateur.
Recommended Posts