Cet article est l'article du 16e jour du Calendrier de l'Avent Python Partie 2 2015.
Cette fois,
--Nouveau module
Je n'aborderai pas, mais je ne présenterai que les parties proches de l'essence telles que la grammaire Python et les types primitifs. (Puisqu'il y a des parties touchées, veuillez sauter dans ce cas ...)
Vers la fin, je n'ai pas beaucoup de temps et ça devient compliqué, mais pardonnez-moi s'il vous plaît.
Python3.0 -> Python3.1
Présentation de la classe collections.OrderedDict. C'est comme un dictionnaire qui se souvient de l'ordre dans lequel il a été inséré.
Python3.1
from collections import OrderedDict
>>> {2:"a", 1:"b", 3:"c"}.items()
dict_items([(1, 'b'), (2, 'a'), (3, 'c')])
>>>
>>> OrderedDict([(2, "a"), (1, "b"), (3, "c")]).items()
ItemsView(OrderedDict([(2, 'a'), (1, 'b'), (3, 'c')]))
Les fonctions intégrées «format ()» et «str.format ()» peuvent désormais utiliser des spécificateurs de format pour les séparateurs à 3 chiffres. Vous pouvez le spécifier avec une virgule. Prend en charge int, float, complexe, decimal.Decimal.
Python3.1
>>> format(123456789, ',d')
'123,456,789'
>>> format(123456789, ',f')
'123,456,789.000000'
>>> format(123456789, ',.2f')
'123,456,789.00'
>>>
>>> "{0:,d}".format(123456789)
'123,456,789'
>>> "{0:,f}".format(123456789)
'123,456,789.000000'
>>> "{0:,.2f}".format(123456789)
'123,456,789.00'
Non, j'ai honte de savoir que je peux spécifier le format pour la première fois. .. Je me demandais s'il y avait quelque chose à dire, mais je ne l'ai pas vérifié.
Puisque format () s'écrit format (valeur [, format_spec]), je comprends que vous pouvez spécifier le format, mais
Le str.format () ne savait pas où chercher. Pour le type intégré, str.format (* args, ** kwargs)
Je ne comprends pas du tout parce que ça dit seulement.
En disant cela, j'ai réussi à trouver ici. (C'est un secret qu'il y avait un lien directement sous str.format ...)
À propos de petits changements. Je vais le résumer facilement.
Le répertoire contenant \ _ \ _ main \ _ \ _. Py et l'archive zip peuvent être exécutés directement en passant son nom à l'interpréteur.
Umm. C'est difficile à comprendre.
__main__.py
print("Hello World!!")
Créez un fichier comme celui-ci et enregistrez-le avec le chemin python_test / __ main __. Py.
Ensuite, essayez de faire un zip.
$ zip -j python_test.zip python_test/__main__.py
Vérifiez si «__main __. Py» est à la racine.
$ unzip -l python_test.zip
Archive: python_test.zip
Length Date Time Name
--------- ---------- ----- ----
23 2015-12-16 12:34 __main__.py
--------- -------
23 1 file
Alors cours!
$ #Exécuter à partir du dossier
$ python python_test
Hello World!!
$ #Exécuter à partir de l'archive
$ python python_test.zip
Hello World!!
Eh bien, vous pouvez le faire comme ça.
Python3.1
>>> n = 37
>>> bin(n)
'0b100101'
>>> n.bit_length()
6
>>> n = 2**123-1
>>> n.bit_length()
123
Oui. Le nombre de chiffres en binaire sort comme ceci.
format () sont automatiquement numérotés.Python3.1
>>> "{} {}!!".format("Hello", "World")
'Hello World!!'
J'ai aussi appris cela pour la première fois ... C'est pratique!
string.maketrans () est obsolèteNouvellement créé en tant que méthode statique
bytes.maketrans()bytearray.maketrans()Peut être utilisé.
Python3.1
>>> class WithTest:
... def __init__(self, msg):
... self.msg = msg
...
... def __enter__(self):
... print("enter: "+self.msg)
... return self
...
... def __exit__(self, exc_type, exc_value, traceback):
... print("exit: "+self.msg)
... return True
...
>>> with WithTest("hoge") as hoge, WithTest("fuga") as fuga:
... pass
...
enter: hoge
enter: fuga
exit: fuga
exit: hoge
Vous pouvez écrire avec des instructions à la fois sans les imbriquer. Le mouvement est le même que le mouvement imbriqué.
Cette contextlib.nested () est obsolète.
round (x, n) renvoie maintenant un entier si x est un entierIl semble qu'il retournait des points flottants.
Python3.1
>>> round(1234, -2)
1200
>>> round(1234., -2)
1200.0
>>> round(1234, 2)
1234
Si vous passez un entier, il sera renvoyé sous forme d'entier.
Cela reste le titre. La virgule flottante est affichée à l'aide d'un nouvel algorithme.
Python3.0
>>> 1.1
1.1000000000000001
Python3.1
>>> 1.1
1.1
C'était difficile pour moi de parler davantage ~ Dites-moi!
Python3.1 -> Python3.2
Une version mise à niveau du module argparse d'Optparse a été ajoutée.
Prend en charge les arguments de position, les sous-commandes, la validation d'options, etc.
La formule est détaillée sur ce module, donc si vous voulez en savoir plus, veuillez cliquer ici.
Il y avait deux façons de définir le module de journalisation, soit en appelant une fonction, soit en lisant un fichier au format ConfigParser.
Afin de définir ce paramètre de manière flexible, vous pouvez désormais effectuer des paramètres à l'aide d'un dictionnaire. Définissez les informations dans logging.config.dictConfig ()
Il peut être défini en passant le dictionnaire stocké.
Des paramètres flexibles sont possibles en analysant un fichier écrit en JSON ou YAML et en le passant à une méthode.
Cliquez ici pour plus de détails sur le module de journalisation (http://docs.python.jp/3/library/logging.html#module-logging).
Le module concurrent.futures a été ajouté. Ce module fournit une interface de haut niveau pour les objets appelables qui peuvent être exécutés de manière asynchrone.
Vous pouvez utiliser ThreadPoolExecutor pour l'exécuter dans un thread, ou vous pouvez utiliser ProcessPoolExecutor pour l'exécuter dans un autre processus.
Cliquez ici pour plus de détails sur le module concurrent.futures [http://docs.python.jp/3/library/concurrent.futures.html)
Si le fichier .pyc du fichier cache généré par Python est exploité par une autre version de l'interpréteur, le cache existant ne peut pas être utilisé, donc un nouveau fichier cache est créé et écrasé.
Pour gérer cela, le fichier avec la version Python ajoutée à la fin du nom de fichier se trouve maintenant dans le répertoire \ _ \ _ pycache \ _ \ _.
Python3.2
$ touch mymodule.py
$ python -c "import mymodule"
$ ls
__pycache__ mymodule.py
$ ls __pycache__
mymodule.cpython-32.pyc
Le cache du module importé est créé dans le dossier \ _ \ _ pycache \ _ \ _ avec le nom de fichier avec la version.
Les objets partagés sont également des méthodes d'implémentation Python (CPython, Jython, PyPy, etc.) + numéros de version majeurs et mineurs + indicateurs de construction Vous pouvez maintenant placer plusieurs fichiers avec le nom.
Python Web Server Gateway Interface v1.0.1
Ce PEP clarifie la façon dont le protocole WSGI gère les octets et les problèmes de texte. PEP est pour les chaînes d'octets utilisées dans les corps de requête et de réponse Faites la distinction entre les chaînes dites natives utilisées dans les en-têtes de demande / réponse et les métadonnées.
Les chaînes natives sont toujours des chaînes, mais peuvent être converties en octets à l'aide du codage Latin-1 et sont limitées aux points de code entre U + 0000 et U + 00FF. Ces chaînes sont utilisées dans la clé et la valeur dans le dictionnaire des variables d'environnement et dans l'en-tête de réponse et l'état de start \ _response (). Autrement dit, vous devez utiliser les caractères ISO-8891-1 ou le codage MIME RFC 2047.
Les implémenteurs de serveurs de routes CGI-WSGI et d'autres protocoles de style CGI exigent que les utilisateurs utilisent des chaînes natives pour accéder aux variables d'environnement sur différentes plates-formes.
Pour combler cette lacune, le module wsgiref a un nouveau wsgiref.handlers.read_environ () qui convertit les variables CGI de os.environ en chaînes natives et renvoie un nouveau dictionnaire.
Eh bien, j'ai fait de mon mieux pour lire l'anglais, mais je n'ai pas vraiment compris ce qui était important (rires).
L'introduction est longue si wsgiref.handlers.read_environ () voulait dire. Était-ce juste ça ...?
Ceux qui comprennent Help !!
# Ajouté aux spécificateurs de format de format () ʻet str.format () `Python3.2
>>> format(10, 'o')
'12'
>>> format(10, '#o')
'0o12'
>>> format(10, 'b')
'1010'
>>> format(10, '#b')
'0b1010'
>>> format(10, '.0f')
'10'
>>> format(10, '#.0f')
'10.'
str.format_map ()C'est comme le format, la version du dictionnaire.
Python3.2
>>> '{msg1} {msg2}!!'.format_map({"msg1":"Hello", "msg2":"World"})
'Hello World!!'
-qPython3.2
$ python
Python 3.2.6 (default, Dec 9 2015, 17:42:33)
[GCC 5.2.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> exit()
$ python -q
>>>
En ajoutant l'option -q, il est possible de masquer les informations de version au démarrage de l'interpréteur.
hasattr () lève maintenant une exception à l'exécutionhasattr () appellegetattr ()pour voir si une exception est détectée.
Auparavant, le comportement était False si une exception était détectée, mais maintenant les exceptions autres que AttributeError sont transmises.
Python3.1
>>> class C:
... @property
... def f(self):
... return 1//0
... @property
... def g(self):
... return 0
...
>>> c = C()
>>> hasattr(c, 'f')
False
>>> hasattr(c, 'g')
True
>>> hasattr(c, 'h')
False
Python3.2
>>> class C:
... @property
... def f(self):
... return 1//0
... @property
... def g(self):
... return 0
...
>>> c = C()
>>> hasattr(c, 'f')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 4, in f
ZeroDivisionError: integer division or modulo by zero
>>> hasattr(c, 'g')
True
>>> hasattr(c, 'h')
False
L'erreur de division zéro n'apparaît pas dans Python 3.1. À première vue, il semble avoir des attributs, mais à une exception près, le résultat est False.
Il existe des exceptions dans Python 3.2. Cependant, il n'y a aucun AttributeError et le résultat est False.
str () dans complex et float est maintenant le même que repr ()Python3.1
>>> import math
>>> repr(math.pi)
'3.141592653589793'
>>> str(math.pi)
'3.14159265359'
Python3.2
>>> import math
>>> repr(math.pi)
'3.141592653589793'
>>> str(math.pi)
'3.141592653589793'
En 3.1, le résultat de str () est un peu court.
release ()Python3.2
>>> with memoryview(b'abc') as v:
... print(v.tolist())
...
[97, 98, 99]
Les ressources sont libérées en appelant la méthode release ().
De plus, __enter__ () et __exit__ () ont également été implémentés, vous pouvez donc utiliser l'instruction with.
Python3.1
>>> def outer(x):
... def inner():
... return x
... inner()
... del x
...
SyntaxError: can not delete variable 'x' referenced in nested scope
>>>
Python3.2
>>> def outer(x):
... def inner():
... return x
... inner()
... del x
...
>>>
Que dois-je faire avec ça? Je pense qu'il serait utile que vous me donniez une erreur. Pour le moment, ce type de code en 2.6 semble fonctionner.
Python3.2
>>> def f():
... def print_error():
... print(e)
... try:
... pass
... except Exception as e:
... print_error()
>>>
Ce que j'ai appris ici, c'est que e est implicitement del. Bien sûr, je veux que cela fonctionne, mais je suis le seul à penser que je ne devrais pas écrire ce genre de code, non?
Python3.2
>>> isinstance(sys.version_info, tuple)
True
ʻOs.stat () , time.gmtime () , sys.version_info` le renverra.
Vous pouvez le traiter comme un taple nommé.
$ export PYTHONWARNINGS='ignore::RuntimeWarning::,once::UnicodeWarning::'
Il peut également être spécifié avec l'option -W.
Il est désactivé par défaut et doit être activé avec l'option -W pour l'afficher.
Python3.2
$ python -q -Wdefault
>>> f = open("foo", "wb")
>>> del f
__main__:1: ResourceWarning: unclosed file <_io.BufferedWriter name='foo'>
Python3.2
>>> r=range(0,100,2)
range(0, 100, 2)
>>> r.count(10)
1
>>> r.index(10)
5
>>> r[10]
20
>>> r[0:5]
range(0, 10, 2)
Il semble qu'il puisse avoir une valeur supérieure à sys.maxsize.
callable () sont de retourPython3.2
>>> callable(max)
True
>>> callable(1)
False
Une fonction qui peut vérifier si elle peut être appelée.
Il semble que ce soit devenu.
Python3.2 -> Python3.3
Ajout d'un module venv pour l'accès programmatique et d'un script pyvenv pour l'accès programmatique.
Je n'ai utilisé que virtualenv, dois-je l'utiliser? De plus, quand je frappe pyvenv, cela dit venv dans l'utilisation. ..
Python3.3
$ pyvenv
usage: venv [-h] [--system-site-packages] [--symlinks] [--clear] [--upgrade]
ENV_DIR [ENV_DIR ...]
venv: error: the following arguments are required: ENV_DIR
Il semble que ce module de commande ait bénéficié de l'intégration avec le noyau de l'interpréteur, il peut donc être préférable de l'utiliser ici.
Vous n'avez plus besoin de mettre \ _ \ _ init \ _ \ _. Py dans le répertoire du package.
Python3.2
$ ls -R
hoge
./hoge:
fuga.py
$ python -c "import hoge.fuga"
Traceback (most recent call last):
File "<string>", line 1, in <module>
ImportError: No module named hoge.fuga
Python3.3
$ ls -R
hoge
./hoge:
fuga.py
$ python -c "import hoge.fuga"
$
Il semble que Python 3.3 puisse être lu car il n'y a pas d'erreur.
Tous les types d'exception sont désormais OSError. (Les autres noms sont laissés comme alias)
En outre, il est maintenant prêt à compléter des conditions d'erreur spécifiques. Au lieu de rechercher une constante spécifique pour l'attribut errno, vous pouvez compléter la classe dérivée OSError appropriée.
ConnectionError a une classe finement dérivée.
Ceci est un exemple officiel
Python3.2
from errno import ENOENT, EACCES, EPERM
try:
with open("document.txt") as f:
content = f.read()
except IOError as err:
if err.errno == ENOENT:
print("document.txt file is missing")
elif err.errno in (EACCES, EPERM):
print("You are not allowed to read document.txt")
else:
raise
Python3.3
try:
with open("document.txt") as f:
content = f.read()
except FileNotFoundError:
print("document.txt file is missing")
except PermissionError:
print("You are not allowed to read document.txt")
Je peux maintenant écrire. Python3.3 est intelligent! Est-ce que Python 3.2 est un langage C ...
Une déclaration de rendement a été ajoutée.
Un générateur peut déléguer son traitement à un autre générateur.
Python3.3
>>> def g():
... yield from [1,2,3]
... yield from [-1,-2,-3]
...
>>> gen = g()
>>> list(gen)
[1, 2, 3, -1, -2, -3]
En outre, l'instruction yield from peut renvoyer la valeur finale spécifiée dans l'instruction return.
Python3.3
>>> def g():
... yield 1
... yield 2
... yield 3
... return 0
...
>>> def f():
... data = yield from g()
... print('return value: ' + str(data))
...
>>> gen = f()
>>> next(gen)
1
>>> next(gen)
2
>>> next(gen)
3
>>> next(gen)
return value: 0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
Vous pouvez supprimer le contexte d'exception en spécifiant None dans l'instruction rise from.
Python3.3
>>> def f():
... raise Exception('in function')
...
>>> def g1():
... try:
... f()
... except Exception as e:
... raise Exception('test1')
...
>>> def g2():
... try:
... f()
... except Exception as e:
... raise Exception('test2') from None
...
>>> g1()
Traceback (most recent call last):
File "<stdin>", line 3, in g1
File "<stdin>", line 2, in f
Exception: in function
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 5, in g1
Exception: test1
>>> g2()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 5, in g2
Exception: test2
Le contexte exceptionnel est supprimé dans g2.
Vous pouvez maintenant ajouter à nouveau ʻu` au préfixe de chaîne.
Python3.2
>>> u"test"
File "<stdin>", line 1
u"test"
^
SyntaxError: invalid syntax
Python3.3
>>> u"test"
'test'
Vous pouvez obtenir le chemin depuis le niveau supérieur avec l'attribut \ _ \ _ qualname \ _ \ _.
Python3.3
>>> class C:
... class D:
... def f():
... pass
...
>>> C.D.__name__
'D'
>>> C.D.__qualname__
'C.D'
>>> C.D.f.__qualname__
'C.D.f'
print (). Si vrai, le flux sera forcé de se vider.casefold () au type str.Python3.3 -> Python3.4
3.3 à 3.4 sont courts car il n'y a pas de nouvelles fonctionnalités de grammaire.
Cela signifierait que le PIP sera introduit en standard.
C'est vrai.
Cependant, vous pouvez utiliser les méthodes suivantes si vous le souhaitez.
os.get_inheritable(), os.set_inheritable()os.get_handle_inheritable(), os.set_handle_inheritable()socket.socket.get_inheritable(), socket.socket.set_inheritable()--min () etmax ()peuvent renvoyer la valeur spécifiée par l'argument mot-clé s'il n'y a aucun élément à itérer.
--bytes.join () etbyte array.join ()acceptent des objets tampons arbitraires comme arguments.
--Le constructeur int accepte n'importe quel objet avec __index__ ().
Python3.4 -> Python3.5
Quant à 3.5, je n'y ai pas tellement touché, c'est donc une introduction superficielle et je n'ai pas le temps, donc c'est court et facile. .. ..
Utilisez la syntaxe ʻasync def` pour créer une fonction collout.
Python3.5
>>> async def cofunc():
... return 'test'
...
De plus, la syntaxe suivante a été ajoutée.
async forasync withCes syntaxes ne peuvent être utilisées que dans la fonction collout définie par ʻasync def`.
Vous pouvez utiliser l'instruction ʻawaitdans la fonction Koluitin. L'instruction d'attente peut suspendre l'exécution du peuple Kolu jusqu'à ce que la valeur résultante soit valide. Il peut être utilisé en définissant la méthodeawait ()` sur n'importe quel objet.
Vous pouvez multiplier la matrice en utilisant «@».
Il peut être utilisé en implémentant __matmul__ (), __rmatmul__ (), __imatmul__ () dans l'objet.
Il semble être implémenté par numpy. Du doc officiel.
Python3.5
>>> import numpy
>>> x = numpy.ones(3)
>>> x
array([ 1., 1., 1.])
>>> m = numpy.eye(3)
>>> m
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> x @ m
array([ 1., 1., 1.])
Vous pouvez utiliser «*» pour les objets itérateur et «**» pour les dictionnaires.
Python3.5
>>> print(*[1,2], 3, *[4])
1 2 3 4
>>> def f(a, b, c, d):
... print(a,b,c,d)
...
>>> f(**{'a': 1, 'd': 4}, **{'c': 3}, **{'b': 2})
1 2 3 4
>>> *range(4), 4
(0, 1, 2, 3, 4)
>>> [*range(4), 4]
[0, 1, 2, 3, 4]
>>> {*range(4), 4}
{0, 1, 2, 3, 4}
>>> {**{'x': 3}, 'y': 4}
{'x': 3, 'y': 4}
Python3.5
>>> b'test: %d' % 1
b'test: 1'
% b ne prend pas en charge Unicode. Mais vous pouvez utiliser % a.
Python3.5
>>> b'Hello %b!' % b'World'
b'Hello World!'
>>> b'Hello %b!' % 'World'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: %b requires bytes, or an object that implements __bytes__, not 'str'
>>> b'Hello %a!' % 'World'
b"Hello 'World'!"
>>> b'price: %a' % '10€'
b"price: '10\\u20ac'"
Type Hints
Les indices de type ont été introduits. J'écrirai en détail dans un autre article à une date ultérieure. ..
Spécifiez à l'aide de l'annotation de fonction.
Python3.5
>>> def f(num: int) -> int:
... return num+1
...
Une fonction qui itère le contenu d'un répertoire. Cela semble être tôt. Utilisons-le.
ls -a
. .. .hidefile empty hoge
Python3.5
>>> import os
>>> for entry in os.scandir('.'):
... if not entry.name.startswith('.') and entry.is_file():
... print(entry.name)
...
empty
Dans les Pythons précédents, il était nécessaire soit d'ignorer ʻInterruptedError`, soit de fournir un mécanisme pour redémarrer après avoir capturé.
À partir de Python 3.5, les appels système dans EINTR seront automatiquement réexécutés.
Auparavant, l'occurrence d'arrêt de l'itération dans le générateur était déclenchée telle quelle.
Python3.4
>>> def gen():
... next(iter([]))
... yield
...
>>> next(gen())
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in gen
StopIteration
L'importation de Generator_stop de __future__ lèvera une exception en tant que RuntimeError.
Python3.5
>>> from __future__ import generator_stop
>>> def gen():
... next(iter([]))
... yield
...
>>> next(gen())
Traceback (most recent call last):
File "<stdin>", line 2, in gen
StopIteration
The above exception was the direct cause of the following exception:
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
RuntimeError: generator raised StopIteration
math.isclose () a été ajouté.
Python3.5
>>> import math
>>> a = 5.
>>> b = 4.99998
>>> math.isclose(a, b, rel_tol=1e-5)
True
>>> math.isclose(a, b, rel_tol=1e-6)
False
>>> math.isclose(a, b, abs_tol=0.00003)
True
>>> math.isclose(a, b, abs_tol=0.00001)
False
3.4 et 3.5 sont assez approximatifs. .. ..
Puisqu'il s'agit d'une mise à jour mineure, il y a peu de mises à jour grammaticales. Si vous incluez des corrections de bugs, des améliorations et des ajouts de modules, le montant sera comme un démon, donc je l'ai omis cette fois. Cependant, je suis curieux de connaître le module asyncio ajouté en 3.4 et le module de saisie ajouté en 3.5, donc j'écrirai un article plus tard.
J'ai touché à Python 3.3 et je n'ai pas abordé les nouvelles fonctionnalités des versions ultérieures, donc je suis désolé pour la vague explication (´ ・ ω ・ ｀)
Si vous êtes intéressé, veuillez consulter Official doc! !! (À la prochaine
Demain, c'est @ fx-kirin.
Ayons une bonne vie Python3! !!
Recommended Posts