Python a un grand nombre de fonctions intégrées (fonctions intégrées) qui vous permettent de faire diverses choses sans importer la bibliothèque. Je voudrais revenir aux bases et organiser comment utiliser les fonctions intégrées.
L'exemple d'exécution est créé avec Python 3.7.5 installé sur Ubuntu 18.04 du sous-système Windows pour Linux 2 (WSL2).
(Remarques) Veuillez noter qu'en raison de la période de mise à jour, les versions mineures et l'environnement d'exécution de Python sont différents des articles jusqu'à la partie 4. De plus, au moment de la rédaction de cet article, Python 3.8.0 a été publié, mais comme cette série est écrite dans la série Python 3.7, veuillez en être conscient également.
Conquérir 69 fonctions intégrées de Python Partie 1 a à b Conquérir 69 fonctions intégrées de Python 2nd c ～ d Conquérir 69 fonctions intégrées de Python 3rd e ～ g Conquérir 69 fonctions intégrées de Python h ～ i Conquérir 69 fonctions intégrées de Python 5th l ～ o
Je décrirai comment utiliser chaque fonction. Je laisserai l'utilisation détaillée à d'autres articles, mais ici je publierai principalement des exemples d'utilisation simples.
pow()
Il calcule la puissance de l'argument donné.
Si vous donnez deux arguments comme pow (x, y), cela équivaut à x ** y.
>>> #Entiers
... pow(2, 3)
8
>>> #Le deuxième argument est une valeur négative
... pow(10, -3)
0.001
>>> #Le deuxième argument est une fraction
pow(3, 2.5)
15.588457268119896
Étant donné un troisième argument, il calcule le reste.
D'après la documentation, pow (x, y, z) est plus efficace que pow (x, y)% z.
>>> #2 à la 3ème puissance de 5 reste
... pow(2, 3, 5)
3
>>> #Si le deuxième argument est négatif, le troisième argument ne peut pas être donné
... pow(2, -3, 5)
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
ValueError: pow() 2nd argument cannot be negative when 3rd argument specified
>>> #Le calcul des résidus nécessite que tous les arguments soient des entiers
... pow(2, 1/2, 3)
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
TypeError: pow() 3rd argument not allowed unless all arguments are integers
En passant, à partir de python3.8, il est possible de calculer le reste même si l'exposant est une valeur négative.
$ docker container run -it python:3.8
Python 3.8.1 (default, Dec 20 2019, 21:56:21)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> pow(2, -3, 5)
2
print()
Convertit l'objet donné en chaîne et l'écrit dans la sortie standard. Vous pouvez transmettre plusieurs valeurs. L'argument sep spécifie le délimiteur et l'argument de fin spécifie la fin de la ligne.
>>> #Un gars célèbre. La valeur par défaut pour end est le caractère de saut de ligne(\n)
... print('Hello, world!')
Hello, world!
>>> #Si vous réussissez plus d'un. La valeur par défaut pour sep est l'espace( )
... print('Good Bye', 'Python2')
Good Bye Python2
>>> #Vous pouvez définir des délimiteurs et des caractères de saut de ligne.
... print('foo', 'bar', 'piyo', 'hoge', sep='!!!, ', end='!?\n')
foo!!!, bar!!!, piyo!!!, hoge!?
>>> #Valeur numérique
... print(1, 1, 2, 3, 5, 8, 13)
1 1 2 3 5 8 13
>>> #liste
... print(['H', 'e', 'l', 'l', 'o'])
['H', 'e', 'l', 'l', 'o']
>>> #Cours Homebrew
... class MyClass1: pass
...
>>> print(MyClass1())
<__main__.MyClass1 object at 0x7f1c8720a450>
>>> # __str__Vous pouvez contrôler la valeur à stringifier en implémentant
... class MyClass2:
... def __str__(self):
... return 'This is ' + self.__class__.__name__
...
>>> print(MyClass2())
This is MyClass2
Par défaut, la fonction print () écrit une valeur dans la sortie standard (sys.stdout), mais vous pouvez changer la destination d'écriture avec l'argument file.
>>> #Ecrire sur la sortie d'erreur standard
... print('Error has occured!!', file=sys.stderr)
Error has occured!!
>>> #Écrire dans un fichier
... with open('hello.txt', 'w') as f:
... print('Hello, my file', file=f)
...
>>> #Il est certainement écrit dans le fichier.
... with open('hello.txt', 'r') as f:
... f.read()
...
'Hello, my file\n'
>>> #Flux de fichiers en mémoire
... import io
>>> memfile = io.StringIO()
>>> print('Into the memory', file=memfile)
>>> memfile.getvalue()
'Into the memory\n'
La valeur sortie par la fonction d'impression peut être mise en mémoire tampon. Par exemple, si la valeur écrite n'a pas de saut de ligne, elle peut ne pas être sortie immédiatement car elle attend la fermeture de données ou de fichiers supplémentaires.
Si vous voulez une sortie immédiate, comme un outil de journalisation, vous pouvez donner flush = True à l'argument afin qu'il soit écrit immédiatement à l'exécution.
$ cat counter.py
import time
def counter(n):
for i in range(1, n+1):
print(i, end=' ') # <==Fin de ligne avec espace au lieu de saut de ligne
time.sleep(1)
counter(10)
$ #Comme il sera mis en mémoire tampon, il sera sorti immédiatement après 10 secondes
$ python3 counter.py
1 2 3 4 5 6 7 8 9 10
$ cat counter2.py
import time
def counter2(n):
for i in range(1, n+1):
print(i, end=' ', flush=True) # <== flush=La sortie est exécutée de force en la définissant sur True
time.sleep(1)
counter2(10)
$ #Les nombres sont affichés toutes les secondes
$ python3 counter2.py
1 2 3 4 5 6 7 8 9 10
property()
Vous voudrez peut-être implémenter les attributs getter, setter et deleter pour réaliser l'encapsulation dans la programmation orientée objet. property () fournit un moyen pratique de les rendre faciles à implémenter.
propriété (document officiel)
Ce qui suit utilise la propriété pour implémenter l'accès public à l'attribut privé _name.
$ cat book.py
class Book:
def __init__(self, name):
self._name = name
def _get_name(self):
"""getter"""
return self._name
def _set_name(self, name):
"""setter"""
self._name = name
def _delete_name(self):
"""deleter"""
del self._name
name = property(_get_name, _set_name, _delete_name, 'This is name property')
>>> from book import Book
>>> book = Book('Clean Code')
>>> # getter
... book.name
'Clean Code'
>>> # deleter
... del book.name
>>> book.name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/home/kotaro/book.py", line 8, in _get_name
return self._name
AttributeError: 'Book' object has no attribute '_name'
>>> # setter
... book.name = 'The Pragmatic Programmer'
>>> book.name
'The Pragmatic Programmer'
Le même processus peut être décrit en utilisant la notation décoratrice comme suit:
class Book:
def __init__(self, name):
self._name = name
@property
def name(self):
"""This is name property"""
return self._name
@name.setter
def name(self, name):
"""setter"""
self._name = name
@name.deleter
def name(self):
"""deleter"""
del self._name
Puisque l'attribut donné à l'argument de propriété est une méthode, vous pouvez également écrire un traitement de conversion de données.
@property
def uppercase(self):
""" uppercase book name"""
return self._name.upper()
>>> book = Book('Clean Code')
>>> book.name
'Clean Code'
>>> book.uppercase
'CLEAN CODE'
range()
À partir de l'argument donné, un objet de type de plage est créé et renvoyé.
Le type de plage prend trois arguments entiers, start, stop et step, et exprime une séquence d'entiers qui modifient l'intervalle de [start, stop) par étapes.
Si un seul argument est donné, start = 0`` step = 1 est défini et une séquence qui augmente de 0 à 1 est générée jusqu'à la valeur d'argument -1.
>>> r1 = range(10)
>>> r1
range(0, 10)
>>> list(r1)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> #Accessible par index
... r1[3]
3
>>> r1[-2]
8
>>> #Peut être tranché. Un nouvel objet de plage de la plage spécifiée est créé.
... r1[2:6]
range(2, 6)
>>> r1[:]
range(0, 10)
>>> r1[100:10000]
range(10, 10)
>>> r1[0:0]
range(0, 0)
>>> #Séquence immuable, donc aucun changement
... r1[1] = 10000
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
TypeError: 'range' object does not support item assignment
>>> #Étant donné une valeur négative, mais pas une boucle infinie
... list(range(-100))
[]
>>> #Il doit s'agir d'une valeur pouvant être gérée comme un type entier.
... range(1.1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'float' object cannot be interpreted as an integer
>>> #Pour 2 arguments, commencez, stop
... list(range(3, 7))
[3, 4, 5, 6]
>>> #Pour 3 arguments, commencez, stop, step
... list(range(1, 10, 2))
[1, 3, 5, 7, 9]
>>> #Gamme décroissante
... list(range(10, -1, -1))
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> #La comparaison est possible. Comparez le contenu de la séquence
... range(10) == range(10)
True
>>> range(10) == range(9)
False
>>> #Les deux sont vrais car la longueur de la séquence est de 0
... range(0) == range(-100)
True
>>> #Les éléments de la séquence sont[1, 3, 5, 7, 9]Donc équivalent
... range(1, 10, 2) == range(1, 11, 2)
True
L'objet range est également souvent utilisé en python pour atteindre un nombre spécifié de boucles.
>>> for i in range(5):
... print(i)
...
0
1
2
3
4
repr()
Génère et renvoie la chaîne de caractères de l'objet passé. Si possible, passez-le à eval () pour en faire une chaîne qui peut être traitée comme le même objet que l'objet d'origine.
>>> #Chaîne
... repr('Hello')
"'Hello'"
>>> eval(repr('Hello'))
'Hello'
>>> #Valeur numérique
... repr(12345)
'12345'
>>> eval(repr(12345))
12345
>>> #liste
... repr(['This', 'is', 'a', 'list', 'object'])
"['This', 'is', 'a', 'list', 'object']"
>>> eval(repr(['This', 'is', 'a', 'list', 'object']))
['This', 'is', 'a', 'list', 'object']
>>> # range
... repr(range(1, 1000))
'range(1, 1000)'
Si une chaîne qui peut être évaluée par eval () ne peut pas être retournée, les informations de l'objet entre «<>» sont affichées.
>>> class MyClass1: pass
...
>>> repr(MyClass1())
'<__main__.MyClass1 object at 0x7f7659690690>'
Vous pouvez contrôler la valeur de retour de repr en implémentant la méthode __repr__ ().
>>> class MyClass2:
... def __repr__(self):
... return self.__class__.__name__ + '()'
...
>>> repr(MyClass2())
'MyClass2()'
>>> eval(repr(MyClass2()))
MyClass2()
reversed()
Le passage d'une séquence renvoie un itérateur qui renvoie la séquence dans l'ordre inverse.
>>> reversed([1, 2, 3])
<list_reverseiterator object at 0x7f76596908d0>
>>> list(reversed([1, 2, 3]))
[3, 2, 1]
>>> reversed(1, 2, 3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: reversed expected 1 arguments, got 3
>>> list(reversed(range(1, 10)))
[9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> import string
>>> for char in reversed(string.ascii_lowercase):
... print(char, end=' ')
...
z y x w v u t s r q p o n m l k j i h g f e d c b a
Même si vous implémentez votre propre classe, vous pouvez utiliser reverse () en implémentant __reversed__ ().
>>> class MySequence:
... def __init__(self):
... self._data = []
... def append(self, value):
... self._data.append(value)
... def __iter__(self):
... return iter(self._data)
... def __reversed__(self):
... return reversed(self._data)
...
>>> sequence = MySequence()
>>> sequence.append(1)
>>> sequence.append(3)
>>> sequence.append(5)
>>> list(sequence)
[1, 3, 5]
>>> reversed(sequence)
<list_reverseiterator object at 0x7f7659699610>
>>> list(reversed(sequence))
[5, 3, 1]
round()
Si une valeur numérique est donnée, l'arrondi sera effectué avec les chiffres fractionnaires spécifiés.
>>> #S'il y a un argument, faites-en un entier
... round(1.1)
1
>>> round(1.5)
2
>>> #3e place après la virgule décimale
... round(3.14159265, 3)
3.142
>>> #5ème place après la virgule décimale
... round(2.71828182846, 5)
2.71828
Veuillez noter que les règles d'arrondi intégrées ne sont ** pas arrondies **.
Arrondi au multiple le plus proche de 0 moins n chiffres; si les deux multiples sont également proches, choisissez un nombre pair (par exemple, round (0,5) et round (-0,5) sont tous les deux) Arrondi à 0, arrondi (1,5) à 2). Document officiel #float
>>> #Notez qu'il n'est pas arrondi
... round(0.5)
0
>>> round(-0.5)
0
>>> round(-1.5)
-2
Notez également que le processus d'arrondi de type flottant provoque une erreur.
>>> # 2.2 au lieu de 68.Devenir 67
... round(2.675, 2)
2.67
Si vous souhaitez effectuer une arithmétique décimale avec plus de précision, vous devriez envisager d'utiliser la bibliothèque standard Decimal type. Il peut y avoir.
La prochaine fois depuis le set ()
Recommended Posts