Notes pour les débutants en Python ayant de l'expérience dans d'autres langues 12 (+1) éléments par fonction

introduction

J'ai évoqué d'autres langages, mais je suis une introduction récente à Python. Dans le processus d'apprentissage, j'ai choisi certaines fonctions qui m'intéressaient par rapport à d'autres langues et les ai résumées en 12 éléments (+ 1 supplémentaire).

Chaque élément est presque indépendant, vous pouvez donc l'ignorer et le lire. (Qiita a une table des matières, il est donc facile de sauter la lecture!)

L'opération a été confirmée avec l'interpréteur de Python 3.5.1.

Définir une fonction vide (instruction pass)

Lors de la définition d'une fonction vide, etc., s'il s'agit d'un langage qui utilise des parenthèses ondulées ({}) pour entourer le corps de la fonction, il n'y a aucun doute, mais Python exprime des blocs avec des retraits sans utiliser de parenthèses. Donc je ne sais pas intuitivement quoi faire.

En conclusion, utilisez l'instruction pass. Au fait, bien que cela ne soit pas écrit ici, il en va de même pour les ** classes vides **.

7.4 Instruction pass (7. instruction simple - Documentation Python 3.5.1) http://docs.python.jp/3/reference/simple_stmts.html#the-pass-statement

>>> def foo():
...     pass
...
>>> foo()
>>>

Même si j'écris une ligne vide avec un retrait sur la deuxième ligne, l'erreur suivante se produit. Vous obtiendrez la même erreur sans écrire la deuxième ligne. (Dans l'exemple, je ne sais pas s'il est vide, alors j'ai mis un commentaire.)

>>> def foo():
...      #
...
  File "<stdin>", line 3

    ^
IndentationError: expected an indented block
>>>

Si vous n'écrivez que la valeur appropriée sans écrire return, cela semble fonctionner de la même manière que dans le cas de l'instruction pass, mais comme la signification d'une fonction vide n'est pas claire, la méthode est × Je suppose.

>>> def foo():
...     pass
...
>>> foo()
>>> def bar():
...     0
...
>>> type(foo())
<class 'NoneType'>
>>> type(bar())
<class 'NoneType'>
>>>

Bien sûr, pass est une ** instruction **, donc il ne peut pas être utilisé comme un objet.

>>> o = pass
  File "<stdin>", line 1
    o = pass
           ^
SyntaxError: invalid syntax
>>>

Importation et espace de noms

Supposons que vous ayez un fichier appelé foo / bar.py qui ressemble à ceci: (La description au début est omise)

import inspect

def baz():
	print('module=', __name__, ', func=', inspect.currentframe().f_code.co_name)

def qux():
	print('module=', __name__, ', func=', inspect.currentframe().f_code.co_name)

(ʻInspect.currentframe (). F_code.co_name` est le code pour obtenir le nom de la fonction à l'intérieur de la fonction.)

Remarque: Il semble que vous deviez mettre un fichier appelé __init __. Py dans le répertoire foo / pour utiliser this foo comme un paquet, car il peut être vide. Cependant, cet exemple fonctionne sans __init __. Py.

Et si vous souhaitez y appeler la fonction, il doit s'agir du nom complet. Seul le module est importé, pas l'espace de noms.

>>> import foo.bar
>>> bar.baz()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'bar' is not defined
>>> foo.bar.baz()
module= foo.bar , func= baz
>>> foo.bar.qux()
module= foo.bar , func= qux
>>>

Pour importer bar comme espace de noms depuis foo from foo import bar ça ira. De plus, les noms longs sont difficiles à utiliser, vous pouvez donc leur donner un alias avec ʻas`. Bien sûr, vous pouvez également combiner les deux.

>>> from foo import bar
>>> import foo.bar as fb
>>> from foo import bar as b
>>> bar.baz()
module= foo.bar , func=baz
>>> bar.qux()
module= foo.bar , func=qux
>>> fb.baz()
module= foo.bar , func=baz
>>> fb.qux()
module= foo.bar , func=qux
>>> b.baz()
module= foo.bar , func=baz
>>> b.qux()
module= foo.bar , func=qux
>>>

Si vous utilisez from foo.bar import baz, vous pouvez importer directement la fonction baz, mais il est généralement préférable de ne pas l'utiliser car l'espace de noms est confus sauf pour certaines fonctions standard. Ça va être bien. (À propos, la fonction qux n'est pas importée dans ce cas.)

Cette section décrit comment appeler votre propre module (local), mais même si vous utilisez la bibliothèque installée, la différence est que vous spécifiez la position relative du chemin de recherche du module à partir de chaque répertoire, mais d'autres choses Est spécifié de la même manière.

Je souhaite réécrire une variable globale à partir d'une autre portée

Les variables définies dans un module qui ne sont pas fermées dans des blocs sont des variables globales.

(Je ne suis pas sûr de la définition exacte de cette zone. Je me demande si l'espace de noms par défaut est le module main.)

Si vous définissez nouvellement une variable avec le même nom que la variable globale dans la fonction, elle devient une variable locale. Cela signifie que si vous essayez de réécrire (réaffecter) une variable globale dans une fonction, elle sera traitée comme une variable locale.

Que faire si je souhaite réécrire des variables globales dans une fonction?

>>> gv = 'global'
>>> def foo():
...     gv = 'local'
...     print(gv)
...
>>> gv
'global'
>>> foo()
local
>>> gv
'global'
>>>

Vous pouvez utiliser le mot-clé «global» pour déclarer que vous souhaitez utiliser des variables globales dans cette portée.

>>> gv = 'global'
>>> def foo():
...     global gv
...     gv = 'reassign'
...     print(gv)
...
>>> gv
'global'
>>> foo()
reassign
>>> gv
'reassign'
>>>

prime: Les fonctions «globals ()» et «locals ()» renvoient respectivement des dictionnaires de variables globales et locales. Il existe de nombreuses variables globales, veuillez donc les essayer.

Comportement lorsque la valeur par défaut de l'argument formel est un objet variable

En Python, vous pouvez écrire une valeur dans un argument formel et définir une valeur par défaut.

>>> def foo(arr=[]):
...     arr.append('A')
...     print(arr)
...
>>> foo(['X', 'Y'])
['X', 'Y', 'A']
>>> foo()
['A']
>>>

Jusqu'à présent, je pense que le comportement est comme prévu.

Ensuite, appelons la fonction foo, en omettant également l'argument.

>>> foo()
['A', 'A']
>>> foo()
['A', 'A', 'A']
>>>

Pas ce à quoi je m'attendais ...

Apparemment, en Python, la valeur par défaut spécifiée pour l'argument formel est initialisée lorsque la fonction est déclarée, donc la même instance est toujours utilisée quel que soit le nombre de fois qu'elle est appelée. Par conséquent, si vous spécifiez un objet mutable, il ressemblera à ceci.

Si vous spécifiez une valeur par défaut, veillez à spécifier un objet immuable.

De plus, la référence 1 a introduit une méthode de jugement par l'instruction «if» en utilisant «None» comme valeur par défaut. (Définissez la valeur par défaut sur une touche vide et utilisez la fonction list pour la lister, n'est-ce pas?)

Comportement lors du partage des valeurs capturées des fermetures

Ce n'est pas un problème et c'est une opération de fermeture normale comme prévu.

Il semble qu'il soit en état de partage de la référence de la variable capturée.

>>> def foo():
...     a = []
...     def bar():
...         a.append(1)
...     def baz():
...         a.append(2)
...     return a, bar, baz
...
>>> a, bar, baz = foo()
>>> bar()
>>> a
[1]
>>> baz()
>>> a
[1, 2]
>>> bar()
>>> a
[1, 2, 1]
>>>

Je veux ajouter un nouvel argument à une fonction avec des arguments de longueur variable

Je veux ajouter un nouvel argument à une fonction qui prend un argument de longueur variable, mais même si je l'ajoute après, il est passé comme argument de longueur variable, et si je l'ajoute avant, la compatibilité devient étrange, alors que dois-je faire?

Cela peut être plus facile si vous le savez, car il existe d'autres langues prises en charge (je ne sais pas exactement laquelle).

La réponse est de ** ajouter un argument avec une valeur par défaut et de le spécifier au "format mot-clé" lors de l'appel **.

Vous pouvez simplement voir l'exemple avec la fonction intégrée max.

Fonction max (2. Fonction intégrée - Documentation Python 3.5.1) http://docs.python.jp/3/library/functions.html?highlight=%E7%B5%84%E3%81%BF%E8%BE%BC%E3%81%BF#max

Fonction max (2. Fonction intégrée - Documentation Python 2.7.x) http://docs.python.jp/2/library/functions.html?highlight=%E7%B5%84%E3%81%BF%E8%BE%BC%E3%81%BF#max

Dans la fonction max, la fonction ordinale clé ne peut pas être spécifiée en moins de Python2.5, mais c'est possible dans Python2.5 ou version ultérieure. key ne peut être spécifié qu'au format mot-clé, mais il peut être étendu tout en maintenant la compatibilité. Mais bon, l'interface d'une fonction comme max sera spécifiée au format mot-clé même si elle a clé depuis le début.

Le code suivant est un exemple de déclaration d'une fonction avec une structure d'argument similaire à la fonction max.

>>> def foo(*args, opt=None):
...     print('args=', args, ', opt=', opt)
...
>>> foo(1, 2, 3)
args= (1, 2, 3) , opt= None
>>> foo(1, 2, 3, opt='hello')
args= (1, 2, 3) , opt= hello
>>>

Propriétés

Vous pouvez raccorder l'accès aux attributs de classe (variables membres), tels que les propriétés C #, les accesseurs dans les beans Java, etc.

Lorsque la classe Foo a un attribut appelé text, vous pouvez déclarer des propriétés en utilisant la fonction property.

>>> class Foo:
...     def __init__(self, text):
...         self.__text = text
...     def get_text(self):
...         print('get_text')
...         return self.__text
...     def set_text(self, text):
...         print('set_text')
...         self.__text = text
...     text = property(get_text, set_text)
...
>>> foo = Foo('foo')
>>> foo.text
get_text
'foo'
>>> foo.text = 'FOO'
set_text
>>> foo.text
get_text
'FOO'
>>>

En passant, si vous ajoutez deux traits de soulignement (__) au début du nom, vous ne pourrez pas y accéder avec le même nom. Il ne peut pas être complètement caché comme un membre privé d'une langue à accès contrôlé, mais il peut transmettre l'intention de ne pas l'exposer.

>>> foo.__text
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Foo' object has no attribute '__text'
>>> foo._Foo__text
'FOO'
>>>

Les propriétés peuvent également être définies dans le décorateur. C'est ** un nouveau style **.

Juste un peu sur les décorateurs. Le décorateur ressemble aux attributs C # et aux annotations Java, mais je pense que cela ressemble plus à une macro ou à un AOP. Veuillez google pour plus de détails.

>>> class Bar:
...     def __init__(self, text):
...         self.__text = text
...     @property
...     def text(self):
...         print('property')
...         return self.__text
...     @text.setter
...     def text(self, text):
...         print('text.setter')
...         self.__text = text
...
>>> bar = Bar('bar')
>>> bar.text
property
'bar'
>>> bar.text = 'BAR'
text.setter
>>> bar.text
property
'BAR'
>>>

Relation entre liste et taple

Puisque Python est un langage typé dynamiquement, les deux peuvent être utilisés de la même manière que les séquences en principe, sauf que les listes sont variables et les taples sont immuables.

À propos, les taples Python peuvent être écrits sans parenthèses à l'exception des taples vides, mais il est préférable de mettre des parenthèses pour indiquer clairement qu'il s'agit de taples.

>>> t1 = (1, 2, 3)
>>> t2 = 1, 2, 3
>>> t1
(1, 2, 3)
>>> t2
(1, 2, 3)
>>> type(t1)
<class 'tuple'>
>>> type(t2)
<class 'tuple'>
>>>

Les listes et les taples peuvent être convertis les uns aux autres en utilisant les fonctions list et tuple.

>>> a = [1, 2, 3]
>>> type(a)
<class 'list'>
>>> aa = tuple(a)
>>> aa
(1, 2, 3)
>>> type(aa)
<class 'tuple'>
>>> b = (4, 5, 6)
>>> type(b)
<class 'tuple'>
>>> bb = list(b)
>>> bb
[4, 5, 6]
>>> type(bb)
<class 'list'>
>>>

Format de format de chaîne

Le format de style «printf» semble être un style ancien. Cependant, les anciens styles ne sont pas obsolètes, il semble que les anciens styles sont simplement figés dans leurs fonctionnalités et que les nouveaux styles sont plus flexibles à écrire.

Les anciens styles sont écrits sous la forme de format string``% `` value taple.

>>> 'x=%d, y=%d' % (10, 20)
'x=10, y=20'
>>>

Le nouveau style utilise la méthode des chaînes format. Ce style peut être utilisé de manière flexible de différentes manières, par exemple en modifiant l'ordre de passage et en passant un dictionnaire en tant qu'argument.

>>> dict = {'x': 10, 'y': 20, 'z': 30}
>>> 'z={z:d}, y={y:d}, x={x:d}'.format(**dict)
'z=30, y=20, x=10'
>>>

Il existe également une chaîne de caractères de modèle, mais je ne savais pas comment l'utiliser.

>>> from string import Template
>>> s = Template('--- $foo --- $bar ---')
>>> s.substitute(foo='Foo', bar='Bar')
'--- Foo --- Bar ---'
>>> d = {'foo': 100, 'bar': 200}
>>> s.substitute(d)
'--- 100 --- 200 ---'
>>>

Voir la référence ci-dessous pour plus d'informations.

6.1.3.2. Exemple de spécification de format (6.1. Chaîne - opérations générales sur les chaînes - documentation Python 3.5.1) http://docs.python.jp/3/library/string.html#format-examples

6.1.4. Chaîne de modèle (6.1. Chaîne - manipulation générale des chaînes - documentation Python 3.5.1) http://docs.python.jp/3/library/string.html#template-strings

Définir une représentation sous forme de chaîne d'un objet

Comment définir des méthodes telles que to_s dans Ruby et toString en Java et JavaScript?

Les classes Python ont des méthodes spéciales, __str__ et __repr__, que vous pouvez implémenter pour définir une représentation sous forme de chaîne d'un objet.

__str__ définit la représentation sous forme de chaîne lors de la conversion en chaîne avec la fonction str ou lors de l'impression avec la fonction print.

__repr__ est unique à Python et définit une représentation sous forme de chaîne sur l'interpréteur. (Abréviation de représentation?)

>>> class Foo:
...     def __init__(self, text):
...         self.text = text
...     def __str__(self):
...         return self.text
...     def __repr__(self):
...         return '%s(\'%s\')' % (self.__class__.__name__, self.text)
...
>>> Foo('foo')
Foo('foo')
>>> print(Foo('foo'))
foo
>>> str(Foo('foo'))
'foo'
>>>

Tout d'abord, le résultat de la méthode __repr__ est affiché sous forme de représentation sur l'interpréteur. La seconde est la représentation sous forme de chaîne de Foo (), c'est-à-dire que le résultat de la méthode __str__ est généré par la fonction print. Troisièmement, le résultat de la méthode «str» est également converti en chaîne par la fonction «str» et produit en tant que représentation sur l'interpréteur.

Vous pouvez utiliser la fonction repr pour obtenir le résultat de la méthode __repr__ sous forme de chaîne de caractères.

>>> s = repr(Foo())
>>> s
"Foo('foo')"
>>>
```


## Modèle de prêt (dossier ouvert)

 Utilisez l'instruction `with`.
 Vous pouvez le faire avec «try-finally», mais «with» est plus concis.

 8.5. Avec instruction (8. instruction composée - Documentation Python 3.5.1)
[http://docs.python.jp/3/reference/compound_stmts.html#with](http://docs.python.jp/3/reference/compound_stmts.html#with)


 Les données suivantes

```
1,2,3
4,5,6
7,8,9
```

 En supposant que vous ayez un fichier texte appelé `data.txt` avec, convertissons-le en une liste de taples numériques.

```pycon
>>> with open('data.txt', 'r') as f:
...     a = [tuple(map(int, line.split(','))) for line in f.read().split()]
...
>>> a
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
>>>
```

 → On m'a appris à écrire ces deux lignes de manière plus concise. Veuillez vous référer à la section des commentaires.
 Merci, @shiracamus.

 J'ai beaucoup emballé, mais je n'expliquerai pas chacun d'eux.
 Notez la ligne de l'instruction «with».


## Je souhaite utiliser un dictionnaire qui gère la commande enregistrée

 Si vous avez besoin d'un dictionnaire qui peut être itéré dans l'ordre que vous avez enregistré, comme `LinkedHashMap` en Java
 Utilisez le module `collections` ʻOrderedDict` au lieu du dictionnaire intégré.

```pycon
>>> from collections import OrderedDict
>>> d = dict([('y', 0), ('e', 0)])
>>> d
{'e': 0, 'y': 0}
>>> d['s'] = 0
>>> d
{'s': 0, 'e': 0, 'y': 0}
>>> for x in d:
...     print(x)
...
s
e
y
>>> od = OrderedDict([('y', 0), ('e', 0)])
>>> od
OrderedDict([('y', 0), ('e', 0)])
>>> od['s'] = 0
>>> od
OrderedDict([('y', 0), ('e', 0), ('s', 0)])
>>> for x in od:
...     print(x)
...
y
e
s
>>>
```

 Si vous voulez en savoir plus sur d'autres collections, consultez la documentation du module `collections`.

 8.3.Collections - Type de données de conteneur - Documentation Python 3.5.1
[http://docs.python.jp/3/library/collections.html](http://docs.python.jp/3/library/collections.html)


## prime

 Un peu sur les idées et les règles Python.

 PEP 8

 Il existe une règle de codage appelée PEP 8. Vous devriez suivre ceci pour le moment.
 ~~ (Ce n'est pas une fonctionnalité standard.) ~~
 → Vous avez souligné que PEP 8 lui-même est une directive (document), et il est étrange de dire que ce n'est pas une fonction standard.
 `Pep8`, qui vérifie les règles de PEP 8, et ʻautopep8`, qui sera décrit plus tard, doivent être installés avec` pip`, etc., donc ces outils devraient avoir été écrits comme des" fonctionnalités non standard ".
 Merci d'avoir souligné, @ryunix.


 Introduction - Documentation pep8-ja 1.0
[https://pep8-ja.readthedocs.io/ja/latest/](https://pep8-ja.readthedocs.io/ja/latest/)

 Conforme à la norme de codage Python PEP8 - Qiita
[http://qiita.com/ynakayama/items/8616f4c0c6e372de9a42](http://qiita.com/ynakayama/items/8616f4c0c6e372de9a42)

 Il peut également être appliqué automatiquement avec un outil appelé ʻautopep8`.
 (Tant que vous ne faites pas de travail que les humains n'ont pas à faire.)


 Postscript: Il semble que la commande `pep8` ait été renommée en` pycodestyle`.
 Consultez la section des commentaires pour plus d'informations.
 Merci, @matobaa.


 PEP 20

 PEP 20 est quelque chose sous une forme poétique qui exprime l'idée de Python. Les détails sont ci-dessous.

 Idées sur Python: PEP 20 - La vie avec Python
[http://www.lifewithpython.com/2013/01/pep-20-the-zen-of-python.html](http://www.lifewithpython.com/2013/01/pep-20-the-zen-of-python.html)


### Qu'est-ce que PEP

 PEP signifie Python Enhancement Proposition.
 Pour plus de détails, reportez-vous à la section "Développement" de Python dans la version anglaise de Wikipedia.

Python (programming language) - Wikipedia, the free encyclopedia
 #Development
[https://en.wikipedia.org/wiki/Python_(programming_language)#Development](https://en.wikipedia.org/wiki/Python_(programming_language)#Development)


### Compatibilité avec Python 2

 Les séries Python2 et Python3 ne sont pas compatibles.

 Dans mon expérience, qui est encore superficielle, j'ai senti que la gestion des chaînes de caractères avait considérablement changé.

 Veuillez noter qu'il existe de nombreux exemples de code dispersés sur le Web dont vous ne savez pas qui est Python2 et lequel est Python3.


## en conclusion

 La rédaction de cet article est devenue beaucoup de pratique.
 Les fonctionnalités mentionnées ici ne sont que les parties très basiques de Python, donc à partir de maintenant, j'aimerais me battre avec de nombreuses bibliothèques, outils et frameworks et utiliser Python sérieusement.

 Jusqu'à la fin Merci d'avoir lu.


## Les références

 #1
 Premiers pas avec Python3 (O'REILLY)

 #2
 Documentation Python 3.5.1
[http://docs.python.jp/3/](http://docs.python.jp/3/)

 Beaucoup d'autres