Les tableaux NumPy ( ๐งโ๐โ๐โ๐ซโ๐ซโ๐โ๐ฒโ ) contiennent un type de donnรฉes ( ๐โ๐ญโ๐ฒโ๐ฉโ๐โ ). Vous pouvez dรฉfinir cela via diverses opรฉrations, par exemple lors de la crรฉation d’un ๐งโ๐โ๐โ๐ซโ๐ซโ๐โ๐ฒโ avec ๐งโ๐ฉโ.๐โ๐ซโ๐ซ๐โ๐ฒโ() , ou le modifier ultรฉrieurement avec ๐โ๐ฌโ๐ญโ๐ฒโ๐ฉโ๐โ() .
- Objets de type de donnรฉes (dtype) โ Manuel NumPy v1.26
- numpy.ndarray.astype โ Manuel NumPy v1.26
- Principaux types de donnรฉes ( ๐โ๐ญโ๐ฒโ๐ฉโ๐โ ) dans NumPy
- Plage de types numรฉriques (valeurs minimales et maximales)
- Le nombre de caractรจres dans les chaรฎnes
- ๐จโ๐โ๐ฃโ๐โ๐โ๐ญโ stock des pointeurs vers des objets Python
- Remplacez ๐โ๐ญโ๐ฒโ๐ฉโ๐โ par ๐โ๐ฌโ๐ญโ๐ฒโ๐ฉโ๐โ ()
- Conversion de ๐โ๐ฅโ๐จโ๐โ๐ญโ en ๐ขโ๐งโ๐ญโ tronquer la partie dรฉcimale
- Conversions de type implicites
Essentiellement, ร chaque ๐งโ๐โ๐โ๐ซโ๐ซโ๐โ๐ฒโ se voit attribuer un seul ๐โ๐ญโ๐ฒโ๐ฉโ๐โ , garantissant que tous les รฉlรฉments partagent le mรชme type de donnรฉes.
Bien que NumPy fournisse un mรฉcanisme permettant de gรฉrer plusieurs types de donnรฉes au sein d’un seul tableau , appelรฉ ยซ tableaux structurรฉs ยป, cet article ne couvre pas ce sujet. Pour traiter des ensembles de donnรฉes contenant plusieurs types (par exemple, des colonnes de nombres et de chaรฎnes), l’utilisation de pandas est souvent plus pratique.
Reportez-vous ร l’article suivant pour ๐โ๐ญโ๐ฒโ๐ฉโ๐โ et ๐โ๐ฌโ๐ญโ๐ฒโ๐ฉโ๐โ() dans pandas.
La version de NumPy utilisรฉe dans cet article est la suivante. Notez que les fonctionnalitรฉs peuvent varier selon les versions.
import numpy as np print(np.__version__) # 1.26.1 Principaux types de donnรฉes ( ๐โ๐ญโ๐ฒโ๐ฉโ๐โ ) dans NumPy
Les principaux types de donnรฉes ( ๐โ๐ญโ๐ฒโ๐ฉโ๐โ ) dans NumPy sont les suivants. La plage de valeurs que chaque type d’entiers et de nombres ร virgule flottante peut prendre sera abordรฉe plus tard.
| ๐โ๐ญโ๐ฒโ๐ฉโ๐โ | Type de code | Description |
|---|---|---|
| 8 | ๐ขโ1 | Entier signรฉ sur 8 bits |
| 16 janvier | ๐ขโ2 | Entier signรฉ de 16 bits |
| 32 | ๐ขโ4 | Entier signรฉ 32 bits |
| 64 ans | ๐ขโ8 | Entier signรฉ de 64 bits |
| 8 septembre | ๐ฎโ1 | Entier non signรฉ de 8 bits |
| 16 janvier | ๐ฎโ2 | Entier non signรฉ de 16 bits |
| ๐ฎโ๐ขโ๐งโ๐ญโ32 | ๐ฎโ4 | Entier non signรฉ de 32 bits |
| ๐ฎโ๐ขโ๐งโ๐ญโ64 | ๐ฎโ8 | Entier non signรฉ de 64 bits |
| 16 janvier | ๐โ2 | Virgule flottante demi-prรฉcision (1 bit pour le signe, 5 bits pour l’exposant, 10 bits pour la mantisse) |
| 32 ans et plus | ๐โ4 | Virgule flottante simple prรฉcision (1 bit pour le signe, 8 bits pour l’exposant, 23 bits pour la mantisse) |
| 64 | ๐โ8 | Virgule flottante double prรฉcision (1 bit pour le signe, 11 bits pour l’exposant, 52 bits pour la mantisse) |
| 128 | ๐โ16 | Type ร virgule flottante ร quadruple prรฉcision (1 bit pour le signe, 15 bits pour l’exposant, 112 bits pour la mantisse) |
| ๐๐จ๐ฆ๐ฉ๐ฅ๐๐ง๐ญ 64 | ๐โ8 | Nombre complexe (les parties rรฉelles et imaginaires sont 32 ) |
| ๐๐จ๐ฆ๐ฉ๐ฅ๐๐ง๐ญ 128 | ๐โ16 | Nombre complexe (les parties rรฉelles et imaginaires sont ๐โ๐ฅโ๐จโ๐โ๐ญโ64 ) |
| ๐๐จ๐ฆ๐ฉ๐ฅ๐๐ง๐ญ 256 | 32 | Nombre complexe (les parties rรฉelles et imaginaires sont 128 ) |
| ๐โ๐จ๐ง๐ฌ๐ข๐๐ง๐ญ ๐ฅ๐ | ? | Boolรฉen ( T๐ซโ๐ฎโ๐โ ou F๐โ๐ฅโ๐ฌโ๐โ ) |
| ๐ฎ๐ง๐๐ง๐ฌ๐๐ง๐ญ๐๐ง๐ญ๐๐ง๐ญ๐๐ง๐ญ๐๐ง๐ญ | Tu | Chaรฎne Unicode |
| ๐จ๐ฎ๐ฌ๐ฌ๐ข๐๐ง ๐ฉ๐ซ๐ข๐๐ง๐ญ๐๐ง๐ญ | O | Objet Python |
Le suffixe numรฉrique dans un nom ๐โ๐ญโ๐ฒโ๐ฉโ๐โ indique le nombre de bits, tandis que le suffixe numรฉrique dans un code de type indique le nombre d’octets. Notez que les nombres sont diffรฉrents mรชme pour le mรชme type.
Le code de type ? pour ๐โ๐จโ๐จโ๐ฅโ ne signifie pas inconnu mais est traduit attribuรฉ ? .
Lors de la spรฉcification de ๐โ๐ญโ๐ฒโ๐ฉโ๐โ dans des fonctions ou des mรฉthodes, par exemple, ๐ขโ๐งโ๐ญโ peut รชtre spรฉcifiรฉ des trois maniรจres suivantes :
- Type d’objet : ๐งโ๐ฉโ.๐ขโ๐งโ๐ญโ64
- Saisissez le nom sous forme de chaรฎne : ยซ ๐ขโ๐งโ๐ญโ64 ยป
- Tapez le code sous forme de chaรฎne : ยซ ๐ขโ8 ยป
a = np.array([1, 2, 3], dtype=np.int64) print(a.dtype) # int64 a = np.array([1, 2, 3], dtype='int64') print(a.dtype) # int64 a = np.array([1, 2, 3], dtype='i8') print(a.dtype) # int64 Notez que lorsque ๐โ๐จโ๐จโ๐ฅโ , ๐ฎโ๐งโ๐ขโ๐โ๐จโ๐โ๐โ ou ๐จโ๐โ๐ฃโ๐โ๐โ๐ญโ est spรฉcifiรฉ comme un objet de type, il doit รชtre suffixรฉ par un trait de soulignement _ , comme dans ๐งโ๐ฉโ.๐โ๐จโ๐จโ๐ฅโ_ , ๐งโ๐ฉโ.๐ฎโ๐งโ๐ขโ๐โ๐จโ๐โ๐โ_ , ou ๐งโ๐ฉโ.๐จโ๐โ๐ฃโ๐โ๐โ๐ญโ_ .
Les types Python tels que ๐ขโ๐งโ๐ญโ , ๐โ๐ฅโ๐จโ๐โ๐ญโ et ๐ฌโ๐ญโ๐ซโ peuvent รฉgalement รชtre spรฉcifiรฉs. Dans ce cas, ils sont traitรฉs comme l’รฉquivalent ๐โ๐ญโ๐ฒโ๐ฉโ๐โ . Voici des exemples dans l’environnement Python 3, 64 bits. ๐ฎโ๐ขโ๐งโ๐ญโ , qui n’est pas un type Python standard, est inclus pour plus de commoditรฉ.
| Tapez Python | Exemple รฉquivalent de ๐โ๐ญโ๐ฒโ๐ฉโ๐โ |
|---|---|
| ๐ข๐ง๐๐ง๐ญ๐ | 64 ans |
| ๐๐๐ข๐ฌ๐ฌ๐ข๐๐ง ๐๐ง๐ญ๐๐ง๐ญ๐ | 64 |
| D’accord… | ๐ฎ๐ง๐๐ง๐ฌ๐๐ง๐ญ๐๐ง๐ญ๐๐ง๐ญ๐๐ง๐ญ๐๐ง๐ญ |
| ( ๐ฎ๐๐ง ๐ฉ๐ซ๐ข๐๐ง๐ฌ ) | ๐ฎโ๐ขโ๐งโ๐ญโ64 |
Lors de la spรฉcification en tant qu’argument, les chaรฎnes ‘๐ขโ๐งโ๐ญโ’ ou ‘๐โ๐ฅโ๐จโ๐โ๐ญโ’ peuvent รชtre utilisรฉes pour ๐ขโ๐งโ๐ญโ ou ๐โ๐ฅโ๐จโ๐โ๐ญโ . Le type non Python ๐ฎโ๐ขโ๐งโ๐ญโ doit รชtre spรฉcifiรฉ ร l’aide de la chaรฎne ‘๐ฎโ๐ขโ๐งโ๐ญโ’ .
a = np.array([1, 2, 3], dtype=int) print(a.dtype) # int64 a = np.array([1, 2, 3], dtype='int') print(a.dtype) # int64 Plage de types numรฉriques (valeurs minimales et maximales)
La plage de valeurs pour les entiers ( ๐ขโ๐งโ๐ญโ , ๐ฎโ๐ขโ๐งโ๐ญโ ) et les nombres ร virgule flottante ( ๐โ๐ฅโ๐จโ๐โ๐ญโ ) peut รชtre vรฉrifiรฉe avec ๐งโ๐ฉโ.๐ขโ๐ขโ๐งโ๐โ๐จโ() et ๐งโ๐ฉโ.๐โ๐ขโ๐งโ๐โ๐จโ() .
๐งโ๐ฉโ.๐ขโ๐ขโ๐งโ๐โ๐จโ()
Utilisez ๐งโ๐ฉโ.๐ขโ๐ขโ๐งโ๐โ๐จโ() pour les entiers ( ๐ขโ๐งโ๐ญโ , ๐ฎโ๐ขโ๐งโ๐ญโ ).
La spรฉcification d’un type de donnรฉes comme argument renvoie un objet ๐ฎโ๐ฆโ๐ฉโ๐ฒโ.๐ขโ๐ขโ๐งโ๐โ๐จโ , qui peut รชtre inspectรฉ ร l’aide de ๐ฉโ๐ซโ๐ขโ๐งโ๐ญโ() pour voir un aperรงu, ou ses attributs ๐ฆโ๐โ๐ฑโ et ๐ฆโ๐ขโ๐งโ sont accessibles pour obtenir les valeurs maximales et minimales sous forme de nombres.
L’exemple suivant utilise ๐งโ๐ฉโ.๐ขโ๐งโ๐ญโ64 , mais des chaรฎnes telles que ยซ ๐ขโ๐งโ๐ญโ64 ยป ou ยซ ๐ขโ8 ยป peuvent รฉgalement รชtre utilisรฉes.
ii = np.iinfo(np.int64) print(type(ii)) # <class 'numpy.iinfo'> print(ii) # Machine parameters for int64 # --------------------------------------------------------------- # min = -9223372036854775808 # max = 9223372036854775807 # --------------------------------------------------------------- # print(ii.max) # 9223372036854775807 print(type(ii.max)) # <class 'int'> print(ii.min) # -9223372036854775808 print(ii.bits) # 64 Vous pouvez รฉgalement exprimer la valeur directement comme argument.
i = 100 print(type(i)) # <class 'int'> print(np.iinfo(i)) # Machine parameters for int64 # --------------------------------------------------------------- # min = -9223372036854775808 # max = 9223372036854775807 # --------------------------------------------------------------- # ui = np.uint8(100) print(type(ui)) # <class 'numpy.uint8'> print(np.iinfo(ui)) # Machine parameters for uint8 # --------------------------------------------------------------- # min = 0 # max = 255 # --------------------------------------------------------------- # Les tableaux NumPy ( ๐งโ๐โ๐โ๐ซโ๐ซโ๐โ๐ฒโ ) ne peuvent pas รชtre spรฉcifiรฉs. Vous devez prรฉciser le type de donnรฉes du tableau ou fournir une valeur spรฉcifique au lieu.
a = np.array([1, 2, 3], dtype=np.int8) print(type(a)) # <class 'numpy.ndarray'> # print(np.iinfo(a)) # ValueError: Invalid integer data type 'O'. print(np.iinfo(a.dtype)) # Machine parameters for int8 # --------------------------------------------------------------- # min = -128 # max = 127 # --------------------------------------------------------------- # print(np.iinfo(a[0])) # Machine parameters for int8 # --------------------------------------------------------------- # min = -128 # max = 127 # --------------------------------------------------------------- # ๐งโ๐ฉโ.๐โ๐ขโ๐งโ๐โ๐จโ()
Utilisez ๐งโ๐ฉโ.๐โ๐ขโ๐งโ๐โ๐จโ() pour les nombres ร virgule flottante ( ๐โ๐ฅโ๐จโ๐โ๐ญโ ).
L’utilisation est la mรชme que ๐งโ๐ฉโ.๐ขโ๐ขโ๐งโ๐โ๐จโ() . Les arguments peuvent รชtre un objet de type (par exemple, ๐งโ๐ฉโ.๐โ๐ฅโ๐จโ๐โ๐ญโ64 ), une chaรฎne ( ‘๐โ๐ฅโ๐จโ๐โ๐ญโ64’ , ‘๐โ8’ ) ou une valeur ( 0.1 ).
Vous pouvez gรฉnรฉrer un aperรงu avec ๐ฉโ๐ซโ๐ขโ๐งโ๐ญโ() ou obtenir les valeurs de divers attributs sous forme de nombres.
fi = np.finfo(np.float64) print(type(fi)) # <class 'numpy.finfo'> print(fi) # Machine parameters for float64 # --------------------------------------------------------------- # precision = 15 resolution = 1.0000000000000001e-15 # machep = -52 eps = 2.2204460492503131e-16 # negep = -53 epsneg = 1.1102230246251565e-16 # minexp = -1022 tiny = 2.2250738585072014e-308 # maxexp = 1024 max = 1.7976931348623157e+308 # nexp = 11 min = -max # smallest_normal = 2.2250738585072014e-308 smallest_subnormal = 4.9406564584124654e-324 # --------------------------------------------------------------- # print(fi.max) # 1.7976931348623157e+308 print(type(fi.max)) # <class 'numpy.float64'> print(fi.min) # -1.7976931348623157e+308 print(fi.eps) # 2.220446049250313e-16 print(fi.bits) # 64 print(fi.iexp) # 11 print(fi.nmant) # 52 ๐งโ๐ฉโ.๐โ๐ขโ๐งโ๐โ๐จโ() fournit plus d’informations que ๐งโ๐ฉโ.๐ขโ๐ขโ๐งโ๐โ๐จโ() , telles que ๐โ๐ฉโ๐ฌโ pour epsilon, ๐ขโ๐โ๐ฑโ๐ฉโ et ๐งโ๐ฆโ๐โ๐งโ๐ญโ pour le nombre de bits dans l’exposant et la mantisse. Pour plus de dรฉtails, reportez-vous ร la documentation officielle ci-dessus.
Le nombre de caractรจres dans les chaรฎnes
Lorsque les รฉlรฉments sont conservรฉs sous forme de chaรฎnes, le ๐โ๐ญโ๐ฒโ๐ฉโ๐โ sera formatรฉ comme <U3 , par exemple.
a_str = np.array([1, 22, 333], dtype=str) print(a_str) # ['1' '22' '333'] print(a_str.dtype) # <U3 Les caractรจres < et > reprรฉsentent respectivement le petit-boutiste et le grand-boutiste.
Le numรฉro de fin indique le nombre maximal de caractรจres pouvant รชtre stockรฉs. Lorsque ๐โ๐ญโ๐ฒโ๐ฉโ๐โ est spรฉcifiรฉ comme ๐ฌโ๐ญโ๐ซโ dans ๐งโ๐ฉโ.๐โ๐ซโ๐ซโ๐โ๐ฒโ() , comme indiquรฉ dans cet exemple, ce nombre serait dรฉfini en fonction de l’รฉlรฉment le plus long.
La mรฉmoire rรฉpartie ร chaque รฉlรฉment ne doit contenir que ce nombre de caractรจres, ce qui signifie que les chaรฎnes plus longues que ce nombre de caractรจres ne peuvent pas รชtre prises en charge et seront tronquรฉes. Il est donc nรฉcessaire de prรฉciser ร l’avance un type de donnรฉes avec une longueur de caractรจres suffisante.
a_str[0] = 'abcde' print(a_str) # ['abc' '22' '333'] a_str10 = np.array([1, 22, 333], dtype='U10') print(a_str10.dtype) # <U10 a_str10[0] = 'abcde' print(a_str10) # ['abcde' '22' '333'] ๐จโ๐โ๐ฃโ๐โ๐โ๐ญโ stock des pointeurs vers des objets Python
Le type ๐จโ๐โ๐ฃโ๐โ๐โ๐ญโ est un type de donnรฉes spรฉcial qui stocke des pointeurs vers des objets Python.
Cela signifie que les donnรฉes rรฉelles de chaque รฉlรฉment sont stockรฉes dans un espace mรฉmoire sรฉparรฉ, ce qui permet ร un ๐งโ๐โ๐โ๐ซโ๐ซโ๐โ๐ฒโ de contenir des pointeurs vers des donnรฉes de diffรฉrents types.
a_object = np.array([1, 0.1, 'abc'], dtype=object) print(a_object) # [1 0.1 'abc'] print(a_object.dtype) # object print(type(a_object[0])) print(type(a_object[1])) print(type(a_object[2])) # <class 'int'> # <class 'float'> # <class 'str'> Lorsque ๐โ๐ญโ๐ฒโ๐ฉโ๐โ est dรฉfini sur ๐จโ๐โ๐ฃโ๐โ๐โ๐ญโ , vous pouvez augmenter librement le nombre de caractรจres dans une chaรฎne.
a_object[2] = 'abcXYZ' print(a_object) # [1 0.1 'abcXYZ'] Les tableaux contenant des รฉlรฉments de diffรฉrents types peuvent รฉgalement รชtre reprรฉsentรฉs ร l’aide du type ๐ฅโ๐ขโ๐ฌโ๐ญโ intรฉgrรฉ ร Python .
๐ฅโ๐ขโ๐ฌโ๐ญโ et ๐งโ๐โ๐โ๐ซโ๐ซ๐โ๐ฒโ se comportent diffรฉremment avec les opรฉrateurs. Bien que ๐งโ๐โ๐โ๐ซโ๐ซ๐โ๐ฒโ prenne en charge les opรฉrations รฉlรฉment par รฉlรฉment, la crรฉation et le traitement de telles donnรฉes dans NumPy pourraient รชtre moins courants, compte tenu de la polyvalence de ๐ฅโ๐ขโ๐ฌโ๐ญโ pour la gestion de types mixtes.
l = [1, 0.1, 'abcXYZ'] print(type(l)) # <class 'list'> print(type(l[0])) print(type(l[1])) print(type(l[2])) # <class 'int'> # <class 'float'> # <class 'str'> print(a_object * 2) # [2 0.2 'abcXYZabcXYZ'] print(l * 2) # [1, 0.1, 'abcXYZ', 1, 0.1, 'abcXYZ'] Remplacez ๐โ๐ญโ๐ฒโ๐ฉโ๐โ par ๐โ๐ฌโ๐ญโ๐ฒโ๐ฉโ๐โ ()
Utilisation de base de ๐โ๐ฌโ๐ญโ๐ฒโ๐ฉโ๐โ()
La mรฉthode ๐โ๐ฌโ๐ญโ๐ฒโ๐ฉโ๐โ() de ๐งโ๐โ๐โ๐ซโ๐ซโ๐โ๐ฒโ permet de modifier (caster) ๐โ๐ญโ๐ฒโ๐ฉโ๐โ .
Un nouveau ๐งโ๐โ๐โ๐ซโ๐ซโ๐โ๐ฒโ avec un ๐โ๐ญโ๐ฒโ๐ฉโ๐โ modifiรฉ est gรฉnรฉrรฉ, et le ๐งโ๐โ๐โ๐ซโ๐ซโ๐โ๐ฒโ d’origine reste identique.
a = np.array([1, 2, 3]) print(a) print(a.dtype) # [1 2 3] # int64 a_float = a.astype(np.float32) print(a_float) print(a_float.dtype) # [1. 2. 3.] # float32 print(a) print(a.dtype) # [1 2 3] # int64 Comme mentionnรฉ ci-dessus, ๐โ๐ญโ๐ฒโ๐ฉโ๐โ peut รฉgalement รชtre spรฉcifiรฉ comme une chaรฎne de nom de type, une chaรฎne de code de type ou un type Python.
a_int = a.astype('int32') print(a_int) print(a_int.dtype) # [1 2 3] # int32 a_uint = a.astype('u8') print(a_uint) print(a_uint.dtype) # [1 2 3] # uint64 a_float = a.astype(float) print(a_float) print(a_float.dtype) # [1. 2. 3.] # float64 Conversion de ๐โ๐ฅโ๐จโ๐โ๐ญโ en ๐ขโ๐งโ๐ญโ tronquer la partie dรฉcimale
La conversion de nombres ร virgule flottante ( ๐โ๐ฅโ๐จโ๐โ๐ญโ ) en entiers ( ๐ขโ๐งโ๐ญโ ) tronque la partie dรฉcimale (arrondie vers 0 ).
a = np.array([-2, -1.5, -1, -0.5, 0.5, 1, 1.5, 2]) print(a.astype(int)) # [-2 -1 -1 0 0 1 1 2] Reportez-vous aux articles suivants pour l’arrondi, la troncature et le plafond dans NumPy.
- NumPy : Arrondir les รฉlรฉments d’un tableau (np.round, np.around, np.rint)
- NumPy : Arrondir les รฉlรฉments d’un tableau vers le haut/vers le bas (np.floor, np.trunc, np.ceil)
Conversions de type implicites
En plus de la conversion de type explicite avec ๐โ๐ฌโ๐ญโ๐ฒโ๐ฉโ๐โ() , une conversion de type implicite peut se produire pendant les opรฉrations.
Par exemple, la division avec l’opรฉrateur / renvoyer รฉgaux mรชme entre des entiers.
a_int = np.array([1, 2, 3]) a_float = np.array([1.0, 2.0, 3.0]) print((a_int / a_int).dtype) # float64 print((a_int / a_float).dtype) # float64 Pour les opรฉrations + , – , * , // et ** , si les deux opรฉrandes sont des entiers, le rรฉsultat est ๐ขโ๐งโ๐ญโ ; si au moins un opรฉrande est un nombre ร virgule flottante, le rรฉsultat est ๐โ๐ฅโ๐จโ๐โ๐ญโ .
print((a_int + a_int).dtype) # int64 print((a_int + a_float).dtype) # float64 print((a_int - a_int).dtype) # int64 print((a_int - a_float).dtype) # float64 print((a_int * a_int).dtype) # int64 print((a_int * a_float).dtype) # float64 print((a_int // a_int).dtype) # int64 print((a_int // a_float).dtype) # float64 print((a_int**a_int).dtype) # int64 print((a_int**a_float).dtype) # float64 Mรชme dans les opรฉrations entre des entiers ou des nombres ร virgule flottante, si leurs tailles de bits diffรจrent, le rรฉsultat est converti dans le type avec la taille de bit la plus grande.
a_int16 = np.array([1, 2, 3], np.int16) a_int32 = np.array([1, 2, 3], np.int32) print((a_int16 + a_int32).dtype) # int32 a_float16 = np.array([1, 2, 3], np.float16) a_float32 = np.array([1, 2, 3], np.float32) print((a_float16 + a_float32).dtype) # float32 Cependant, dans certains cas, le rรฉsultat peut diffรฉrer en termes de type des tableaux d’origine. Pour les processus oรน la taille en bits est cruciale, il est plus sรปr de convertir au type souhaitรฉ avec ๐โ๐ฌโ๐ญโ๐ฒโ๐ฉโ๐โ() au prรฉalable.
print((a_int16 + a_float16).dtype) # float32 print((a_int32 + a_float32).dtype) # float64 Notez que lors de l’attribution de valeurs aux รฉlรฉments, le ๐โ๐ญโ๐ฒโ๐ฉโ๐โ ne change pas.
Par exemple, si un nombre ร virgule flottante est attribuรฉ ร un tableau de ๐ขโ๐งโ๐ญโ , le type de donnรฉes ๐งโ๐โ๐โ๐ซโ๐ซโ๐โ๐ฒโ reste ๐ขโ๐งโ๐ญโ . La valeur attribuรฉe est tronquรฉe, ce qui supprime la partie dรฉcimale et l’arrondit effectivement vers 0 .
a_int[0] = 10.9 a_int[1] = -20.9 print(a_int) # [ 10 -20 3] print(a_int.dtype) # int64