Type numérique Python

Aperçu

Notes d'étude pour First Python 3rd Edition

ordre du jour

--Valeur numérique --Expressions et opérateurs Python --Valeurs numériques et exemples d'utilisation --Autres types numériques

Type numérique Python

Valeur numérique

Littéral numérique

** Taille et précision des entiers et des nombres à virgule flottante **

• Un entier Python normal équivaut à un long C
• Le nombre de points flottants équivaut à C double
• La précision dépend de la précision donnée à long et double par le compilateur C utilisé pour créer l'interpréteur Python.

** Entier long **

--Si vous ajoutez l ou L à un littéral entier, il devient un entier long.

• Vous pourrez augmenter la précision à l'infini
• Il est presque inutile d'ajouter L dans la version actuelle

** Hexagonal et octal **

• Pour les entiers octaux, ** préfixe avec zéro (0), puis écrivez un nombre compris entre 0 et 7 **. --Pour les nombres hexadécimaux, ** préfixe avec 0x, suivi d'un nombre compris entre 0 et 9, ou une lettre comprise entre A-F ** (supérieur ou inférieur).

** Nombre complexe **

• Ecrire des nombres complexes au format partie réelle + partie imaginaire --Ajouter j ou J à la fin de la partie imaginaire
• Il peut n'y avoir aucune partie réelle, et la partie imaginaire peut être écrite avant la partie réelle.
• Les nombres complexes sont traités comme une paire de nombres à virgule flottante à l'intérieur du système, mais les opérations utilisant des nombres complexes sont effectuées correctement.

Outils et extensions intégrés

opérateur

--+,*,>>,**, etc.

** Fonction mathématique (fonction intégrée) **

--pow, ʻabs`, etc.

** Module utilitaire **

-- aléatoire, math, etc.

** Compteur numérique pleine échelle **

• NumPy（Numeric Python）
• Les types de données tels que la matrice et les bibliothèques pour le traitement arithmétique avancé sont préparés.
• Des détails peuvent être trouvés sur des sites tels que Vaults of Parnassus

Expressions et opérateurs Python

Opérateur PYthon

Combinaison d'opérateurs (priorité)

――Il est bon de le montrer explicitement --Utilisez des parenthèses pour clarifier les priorités

>>> (x + y) * z

>>> x + (y * z)

Types mixtes dans les formules

--Lorsque plusieurs types sont mélangés dans une expression, Python convertit d'abord les types d'opérande. --Tous les types d'opérandes sont alignés sur le type le plus "complexe" utilisé --Il est également fait pour convertir automatiquement en un entier long lorsque la valeur de l'entier court devient trop grande.

• La conversion de type automatique est effectuée uniquement pour les valeurs numériques --En Python, pré-classement pour le type "complexité"

Surcharge de l'opérateur

• Les opérateurs peuvent être surchargés (ou nouvellement créés) par des classes Python ou des extensions C ――Cette propriété est généralement appelée polymorphisme.
• "La fonction change en fonction du type d'objet à traiter"

Valeurs numériques et exemples d'utilisation

Représentation numérique

• La valeur affichée sans l'instruction print est la sortie exacte de la réponse dérivée du matériel.

Opération de bit

#La valeur de x est 0001
>>> x = 1
>>> x << 2
4

#Décale de 2 bits vers la gauche à 0100
>>> x | 2
3

#OU opération à 0011#ET opération à 0001
>>> x & 1
1

Entier long

• Si vous ajoutez la lettre L (ou l inférieur) à la fin du nombre, il est considéré comme un entier long. --Il existe une fonction dont vous pouvez augmenter la taille (nombre de chiffres) autant que la capacité de la mémoire le permet.

Nombre complexe

--Représenté en Python à l'aide de deux nombres à virgule flottante

• L'un correspond à la partie réelle et l'autre correspond à la partie imaginaire --Pour indiquer que le nombre appartient à la partie imaginaire, ajoutez J (peut être un j inférieur) à la fin, et utilisez + pour combiner la partie réelle et la partie imaginaire.

>>> 1j * 1J
(-1+0j)
>>> 2 + 1j * 3
(2+3j)
>>> (2+1j)*3
(6+3j)

Nombres hexagonaux et octaux

• Pour les nombres octaux, commencez par 0, puis alignez les nombres de 0 à 7. Chaque chiffre correspond à 3 bits. --Pour les nombres hexadécimaux, commencez par 0x ou 0X, suivis des chiffres 0 à 9 ou des alphabets A à F (qui peuvent être inférieurs). Chaque chiffre correspond à 4 bits. ――Même s'il est exprimé en octal ou hexadécimal, l'entier est toujours un entier. --Pour Python, les entiers sont affichés en décimal par défaut
• Certaines fonctions intégrées convertissent les nombres décimaux en nombres octaux et hexadécimaux. --Il existe également une fonction appelée ʻint` qui peut convertir des nombres octaux et hexadécimaux en nombres décimaux. --Il est également possible de convertir des nombres décimaux en nombres octaux et hexadécimaux en utilisant une expression de format de chaîne.

#8 base
>>> 01, 010, 0100
(1, 8, 64)

#Hexadécimal
>>> 0x01, 0x10, 0xFF
(1, 16, 255)

>>> oct(64), hex(64), hex(255)
('0100', '0x40', '0xff')

>>> int('0100'), int('0100', 8), int('0x40', 16)
(100, 64, 64)

>>> eval('100'), eval('0100'), eval('0x40')
(100, 64, 64)

>>> "%o %x %X" % (64, 64, 255)
'100 40 FF'

Outil intégré pour le traitement numérique

module mathématique

>>> import math

#Constantes couramment utilisées
>>> math.pi, math.e
(3.1415926535897931, 2.7182818284590451)

#Signe, cosinus, tangente
>>> math.sin(2 * math.pi / 180)
0.034899496702500969

#racine carrée
>>> math.sqrt(144), math.sqrt(2)
(12.0, 1.4142135623730951)


>>> abs(-42), 2**4, pow(2, 4)
(42, 16, 16)

#Tronquer, rond
>>> int(2.567), round(2.567), round(2.567, 2)
(2, 3.0, 2.5699999999999998)

module aléatoire

>>> import random
>>> random.random()
0.49741978338014803

>>> random.random()
0.49354866439625611

>>> random.randint(1, 10)
5

>>> random.randint(1, 10)
4

>>> random.choice(['Life of Brian', 'Holy Grail', 'Meaning of Life'])
'Life of Brian'

>>> random.choice(['Life of Brian', 'Holy Grail', 'Meaning of Life'])
'Holy Grail'

Autres types numériques

Type fractionnaire

• À partir de Python 2.4, un nouveau type appelé fraction est introduit. --Utiliser en important un module et en appelant une fonction au lieu d'un littéral
• Similaire aux nombres à virgule flottante, sauf que le nombre de chiffres après la virgule décimale est fixe, c'est-à-dire que la précision est fixe.
• Peut provoquer une dégradation des performances par rapport aux nombres à virgule flottante
• Afin d'exprimer une valeur numérique avec une précision constante, comme le calcul du montant total, la précision est également améliorée et le type approprié

Pour le type à virgule flottante

>>> 0.1 + 0.1 + 0.1 - 0.3
5.5511151231257827e-017

>>> print 0.1 + 0.1 + 0.1 - 0.3
5.55111512313e-017

Pour le type fractionnaire

>>> from decimal import Decimal
>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')
Decimal("0.0")

ensemble

>>> x = set('abcde')
>>> y = set('bdxyz')

>>> x
set(['a', 'c', 'b', 'e', 'd'])

#Déterminer si l'ensemble contient des éléments
>>> 'e' in x
True

#Définir la différence
>>> x - y
set(['a', 'c', 'e'])

#Ensembles combinés
>>> x | y set(['a', 'c', 'b', 'e', 'd', 'y', 'x', 'z'])

#Croisement d'ensembles
>>> x & y set(['b', 'd'])

Exemple d'utilisation d'un ensemble

>>> engineers = set(['bob', 'sue', 'ann', 'vic'])
>>> managers = set(['tom', 'sue'])

#Extraire des personnes à la fois ingénieurs et managers
>>> engineers & managers
set(['sue'])

#Extraire les personnes appartenant à n'importe quelle catégorie
>>> engineers | managers
set(['vic', 'sue', 'tom', 'bob', 'ann'])

#Extraire des personnes qui ne sont pas des managers
>>> engineers - managers
set(['vic', 'bob', 'ann'])

Extension tierce

• Nombre raisonnable
• vecteur
• file d'attente