One place for hosting & domains

      convertir

      Cómo convertir tipos de datos en Python 3


      Introducción

      En Python, los tipos de datos se utilizan para clasificar un tipo específico de datos, determinar los valores que puede asignar al tipo y las operaciones que puede realizar en el mismo. Cuando realice tareas de programación, a veces, deberá aplicar conversiones de valores entre tipos para manipular los valores de forma diferente. Por ejemplo, es posible que debamos concatenar valores numéricos con cadenas o representar posiciones decimales en números que se iniciaron como valores enteros.

      Este tutorial lo guiará a través de la conversión de tipos de datos, incluyendo números, cadenas, tuplas y listas, y también le proporcionará ejemplos para que se familiarice con los diferentes casos de uso.

      Cómo convertir tipos de números

      En Python, existen dos tipos de datos numéricos: números enteros y de punto flotante o flotantes. A veces, trabajará en el código de otra persona y necesitará convertir un entero en un flotante o viceversa, o puede darse cuenta de que está usando un entero cuando lo que realmente necesita es un flotante. Python tiene métodos integrados que le permiten convertir enteros en flotantes y flotantes en enteros de forma sencilla.

      Cómo convertir enteros en flotantes

      El método de Python float() le permitirá convertir los enteros en flotantes. Para utilizar esta función, añada un entero dentro del paréntesis:

      float(57)
      

      En este caso, 57 se convertirá en 57.0.

      También puede utilizar esto con una variable. Declaremos que f es igual a 57 y, luego, imprima el nuevo flotante:

      f = 57
      print(float(f))
      

      Output

      57.0

      Utilizando la función float(), podemos convertir enteros en flotantes.

      Cómo convertir flotantes en enteros

      Python también incluye una función integrada para convertir flotantes en enteros: int().

      La función int() opera de forma similar a la función float(): puede agregar un número de punto flotante dentro del paréntesis para convertirlo en un entero:

      int(390.8)
      

      En este caso, 390.8 se convertirá en 390.

      También puede usar esto con variables. Declaremos que b es igual a 125.0 y que c es igual a 390.8, y, luego, imprima los nuevos flotantes:

      b = 125.0
      c = 390.8
      
      print(int(b))
      print(int(c))
      

      Output

      125 390

      Cuando se convierten flotantes en enteros con la función int(), Python corta el decimal y los números restantes de un flotante para crear un entero. Aunque posiblemente desee redondear 390.8 a 391, Python no lo hará con la función int().

      Conversión de números mediante división

      En Python 3, los cocientes correspondientes se convierten de enteros a flotantes cuando se realizan divisiones, aunque no sucede así en Python 2. Es decir, en Python 3, cuando divide 5 por 2, obtendrá un flotante como respuesta (2.5):

      a = 5 / 2
      print(a)
      

      Output

      2.5

      En Python 2, dado que estaba utilizando dos enteros, obtendrá un entero como respuesta: 5 / 2 = 2. Para obtener más información sobre las diferencias entre Python 2 y Python 3, consulte el artículo “Python 2 vs Python 3: Practical Considerations“ (Python 2 vs Python 3: Consideraciones prácticas).

      Cómo realizar conversiones con cadenas

      Una cadena es una secuencia de uno o más caracteres (letras, números, símbolos). Las cadenas son una forma habitual de datos en los programas informáticos, y es posible que debamos convertir cadenas en números o números en cadenas con bastante frecuencia, sobre todo si tomamos datos generados por el usuario.

      Cómo convertir números en cadenas

      Podemos convertir números en cadenas usando el método str(). Colocaremos un número o una variable en los paréntesis del método, y luego ese valor numérico se convertirá en un valor de cadena.

      Primero, veamos primero cómo convertir enteros. Para convertir el entero 12 a un valor de cadena, puede colocar 12 en el método str():

      str(12)
      

      Cuando ejecuta str(12) en el shell interactiva de Python con el comando python en una ventana del terminal, obtendrá el siguiente resultado:

      Output

      '12'

      Las comillas alrededor del número 12 implican que este ya no es un entero, sino que ahora es un valor de cadena.

      Con las variables, podremos observar la practicidad de la conversión de enteros en cadenas. Supongamos que queremos hacer un seguimiento del progreso en la programación diaria de un usuario e introducimos la cantidad de líneas de código que este escribe a la vez. Queremos mostrar estos comentarios al usuario e imprimiremos los valores de cadenas y enteros al mismo tiempo:

      user = "Sammy"
      lines = 50
      
      print("Congratulations, " + user + "! You just wrote " + lines + " lines of code.")
      

      Cuando ejecutemos este código, veremos el siguiente error:

      Output

      TypeError: Can't convert 'int' object to str implicitly

      No podemos concatenar cadenas ni enteros en Python. Por lo tanto, debemos convertir la variable lines en un valor de cadena:

      user = "Sammy"
      lines = 50
      
      print("Congratulations, " + user + "! You just wrote " + str(lines) + " lines of code.")
      

      Ahora, cuando ejecutemos el código veremos el siguiente resultado en que se felicita a su usuario por su progreso:

      Output

      Congratulations, Sammy! You just wrote 50 lines of code.

      Si queremos convertir un flotante en una cadena, en vez de un entero, aplicaremos los pasos y un formato similares. Cuando colocamos un flotante en el método str(), se mostrará un valor de cadena del flotante. Podemos usar el valor flotante o una variable:

      print(str(421.034))
      
      f = 5524.53
      print(str(f))
      

      Output

      421.034 5524.53

      Podemos realizar una prueba para asegurarnos de que esté bien, realizando una concatenación con una cadena:

      f = 5524.53
      print("Sammy has " + str(f) + " points.")
      

      Output

      Sammy has 5524.53 points.

      Podemos estar seguros de que el flotante se convirtió adecuadamente en una cadena porque la concatenación se realizó sin errores.

      Cómo convertir cadenas en números

      Las cadenas se pueden convertir en números utilizando los métodos int() y float().

      Si su cadena no tiene posiciones decimales, probablemente querrá convertirla en un entero utilizando el método int().

      Utilizaremos el ejemplo del usuario Sammy realizando un seguimiento de las líneas de código escritas cada día. Es posible que queramos manipular esos valores con cálculos matemáticos para proporcionar una respuesta más interesante para el usuario, pero estos valores se almacenan actualmente en cadenas:

      lines_yesterday = "50"
      lines_today = "108"
      
      lines_more = lines_today - lines_yesterday
      
      print(lines_more)
      

      Output

      TypeError: unsupported operand type(s) for -: 'str' and 'str'

      Dado que los dos valores numéricos se hallaban almacenados en cadenas, recibimos un error. El operando - para la sustracción no es un operando válido para dos valores de cadena.

      Modifiquemos el código para incluir el método int() que convertirá las cadenas en enteros, lo que nos permitirá realizar cálculos matemáticos con valores que eran originalmente cadenas.

      lines_yesterday = "50"
      lines_today = "108"
      
      lines_more = int(lines_today) - int(lines_yesterday)
      
      print(lines_more)
      

      Output

      58

      La variable lines_more de manera automática es un entero y, en este ejemplo, es igual al valor numérico de 58.

      En el ejemplo anterior, también podemos convertir los números a valores flotantes utilizando el método float(), en lugar del método int(). En lugar de obtener el resultado de 58, obtendremos el resultado de 58.0, un flotante.

      El usuario Sammy obtiene puntos en valores decimales

      total_points = "5524.53"
      new_points = "45.30"
      
      new_total_points = total_points + new_points
      
      print(new_total_points)
      

      Output

      5524.5345.30

      En este caso, utilizar el operando + con dos cadenas es una operación válida, pero se concatenarán dos cadenas en lugar de sumarse dos valores numéricos. Por lo tanto, nuestro resultado se ve inusual, ya que solo coloca los dos valores juntos.

      Queremos convertir estas cadenas en flotantes antes de realizar cualquier cálculo matemático con el método float():

      total_points = "5524.53"
      new_points = "45.30"
      
      new_total_points = float(total_points) + float(new_points)
      
      print(new_total_points)
      

      Output

      5569.83

      Ahora que convertimos las dos cadenas en flotantes, obtendremos el resultado esperado que suma 45.30 a 5524.53.

      Si tratamos de convertir un valor de cadena con decimales en un entero, obtendremos un error:

      f = "54.23"
      print(int(f))
      

      Output

      ValueError: invalid literal for int() with base 10: '54.23'

      Si pasamos un valor decimal en una cadena al método int(), obtendremos un error porque no se convertirá en un entero.

      Convertir cadenas en números nos permite modificar rápidamente el tipo de datos con el que trabajamos, de forma que podamos realizar operaciones con valores numéricos que originalmente se formularon como cadenas.

      Cómo convertir en tuplas y listas

      Puede usar los métodos list() y tuple() para convertir los valores colocados en ellos al tipo de datos de tupla y lista respectivamente. En Python:

      • una lista es una secuencia ordenada de elementos mutables contenida entre corchetes [ ].
      • una tupla es una secuencia ordenada de elementos inmutables contenida entre paréntesis ( ).

      Cómo convertir en tuplas

      Comencemos convirtiendo una lista en una tupla. Convertir una lista en una tupla, debido a que es un tipo de datos inmutable, puede permitir una optimización significativa a los programas que creamos. Cuando utilizamos el método tuple(), se devolverá la versión en tupla del valor que se coloca en este.

      print(tuple(['pull request', 'open source', 'repository', 'branch']))
      

      Output

      ('pull request', 'open source', 'repository', 'branch')

      Podemos observar que una tupla se imprime en el resultado, ya que los elementos ahora están contenidos en los paréntesis, en lugar de los corchetes.

      Usemos tuple() con una variable que representa una lista:

      sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp']
      print(tuple(sea_creatures))
      

      Output

      ('shark', 'cuttlefish', 'squid', 'mantis shrimp')

      De nuevo, vemos que el valor de la lista se cambia a un valor de tupla, indicado por los paréntesis. Podemos convertir cualquier tipo iterable en una tupla, incluso las cadenas:

      print(tuple('Sammy'))
      

      Output

      ('S', 'a', 'm', 'm', 'y')

      Debido a que podemos iterar las cadenas, podemos convertirlas en tuplas con el método tuple(). Sin embargo, con los tipos de datos que no son iterables, como los enteros y flotantes, obtendremos un error de tipo:

      print(tuple(5000))
      

      Output

      TypeError: 'int' object is not iterable

      Si bien es posible convertir el entero en una cadena y, luego, en una tupla, como con tuple(str(5000)), es mejor optar por un código legible en conversiones complicadas.

      Cómo convertir en listas

      Convertir valores, especialmente las tuplas, en listas puede ser útil cuando necesita tener una versión mutable de ese valor.

      Usaremos el método list() para convertir la siguiente tupla en una lista. Dado que se utilizan paréntesis en la sintaxis para crear una lista, asegúrese de incluir los paréntesis del método list() y, en este caso, también los del método print():

      print(list(('blue coral', 'staghorn coral', 'pillar coral')))
      

      Output

      ['blue coral', 'staghorn coral', 'pillar coral']

      Los corchetes indican que una lista se devolvió a partir del valor original de la tupla que colocó mediante el método list().

      Para hacer que el código sea más legible, podemos eliminar un par de paréntesis usando una variable:

      coral = ('blue coral', 'staghorn coral', 'pillar coral')
      list(coral)
      

      Si imprimimos list(coral), obtendremos el mismo resultado que se muestra arriba.

      Al igual que con las tuplas, las cadenas se pueden convertir en listas:

      print(list('shark'))
      

      Output

      ['s', 'h', 'a', 'r', 'k']

      Aquí la cadena 'shark' se convirtió en una lista y proporcionó una versión mutable del valor original.

      Conclusión

      En este tutorial de Python, se mostró la forma de convertir varios de los tipos importantes de datos nativos en otros tipos de datos, principalmente mediante métodos integrados. Ser capaz de convertir tipos de datos en Python le ofrece más flexibilidad cuando escribe sus programas.



      Source link

      Comment convertir des types de données sous Python 3


      Introduction

      Sous Python, les data types servent à classer un type de données particulier. Ils permettent également de déterminer les valeurs que vous pouvez attribuer au type en question et les opérations que vous pouvez effectuer sur celui-ci. Au moment de la programmation, vous aurez parfois besoin de convertir des valeurs d’un type à l’autre pour pouvoir manipuler les valeurs différemment. Par exemple, il vous arrivera parfois de devoir concaténer des valeurs numériques avec des chaînes de caractères ou d’ajouter une décimale à des chiffres initialisés comme des valeurs entières.

      Ce tutoriel vous guidera à travers le processus de conversion de types de données, notamment les chiffres, les chaines, les tuples et les listes et vous proposera des exemples qui vous permettront de vous familiariser avec différents cas d’utilisation.

      Conversion des types de chiffres

      Sous Python, il existe deux types de données de chiffre : les entiers et les chiffres à virgule ou décimaux. Lorsque vous travaillez sur le code d’une autre personne, il arrive parfois que vous ayez besoin de convertir un chiffre entier en décimal ou vice versa, ou que vous constatiez que vous avez utilisé un entier alors qu’en réalité vous avez besoin d’un décimal. Python intègre des méthodes qui vous permettent de facilement convertir les entiers en décimaux et les décimaux en entiers.

      Conversion des entiers en décimaux

      La méthode float() de Python vous permettra de convertir les entiers en décimaux. Pour utiliser cette fonction, ajoutez un chiffre entier à l’intérieur des parenthèses :

      float(57)
      

      Dans ce cas, nous allons convertir 57 en 57.0.

      Vous pouvez également l’utiliser avec une variable. Disons que f est égal à 57, puis imprimons le nouveau décimal :

      f = 57
      print(float(f))
      

      Output

      57.0

      En utilisant la fonction float(), nous pouvons convertir les entiers en décimaux.

      Conversion des décimaux en entiers

      Python intègre également une fonction pour convertir les décimaux en entiers : int ().

      La fonction int() fonctionne de la même manière que la fonction float() : vous pouvez ajouter un chiffre à virgule à l’intérieur des parenthèses pour le convertir en entier :

      int(390.8)
      

      Dans ce cas, nous allons convertir 390,8 en 390.

      Vous pouvez également l’utiliser avec des variables. Disons que b est égal à 125,0, et que c est égal à 390,8, puis imprimons les nouveaux décimaux :

      b = 125.0
      c = 390.8
      
      print(int(b))
      print(int(c))
      

      Output

      125 390

      Lorsque vous convertissez des décimaux en entiers avec la fonction int(), Python supprime la décimale et les chiffres restants après la virgule pour créer un entier. Même si nous voulions arrondir 390,8 à 391, Python ne pourrait pas le faire avec la fonction int().

      Numéros convertis par division

      Dans Python 3, les quotients correspondants sont convertis d’entiers en décimaux lorsque vous exécuter division bien que cela ne soit pas possible sous Python 2. Autrement dit, dans Python 3, lorsque vous divisez 5 par 2, vous obtenez un chiffre décimal (2,5) :

      a = 5 / 2
      print(a)
      

      Output

      2.5

      Sous Python 2, étant donné que vous avez à faire à deux entiers, vous obtiendrez un entier à la place : 5 / 2 = 2. Consultez notre tutoriel « Python 2 vs Python 3 : considérations pratiques » pour avoir de plus amples informations sur les différences qui existent entre Python 2 et Python 3.

      Conversion avec des chaînes de caractères

      Une chaine de caractères est une séquence d’un ou plusieurs caractères (lettres, chiffres, symboles). Les chaines de caractères sont une forme de données que l’on trouve couramment dans les programmes informatiques. Il nous arrivera parfois de devoir convertir des chaines de caractères en chiffres ou des chiffres en chaines de caractères, spécialement lorsque nous intégrons des données générées par les utilisateurs.

      Conversion de chiffres en chaînes de caractères

      Nous pouvons convertir des chiffres en chaines de caractères en utilisant la méthode str(). Nous allons transmettre un chiffre ou une variable dans les parenthèses de la méthode. Ensuite, cette valeur numérique sera convertie en une valeur de chaine de caractères.

      Concentrons-nous tout d’abord sur la conversion des entiers. Pour convertir l’entier 12 en une valeur de chaine de caractères, vous pouvez placer 12 dans la méthode str() :

      str(12)
      

      En exécutant str(12) dans le shell interactif de Python avec la commande python dans la fenêtre du terminal, vous obtiendrez le résultat suivant :

      Output

      '12'

      Les guillemets qui entourent le chiffre 12 signifient que le nombre n’est plus un entier mais qu’il est maintenant une valeur de chaine de caractères.

      En combinaison avec des variables, nous pouvons commencer à voir à quel point il peut être intéressant de convertir des entiers en chaines de caractères. Supposons que nous voulions faire un suivi du progrès de la programmation quotidienne d’un utilisateur et que nous saisissions le nombre de lignes de code qu’ils écrivent à la fois. Nous voudrions montrer ce feedback à l’utilisateur et imprimerions les valeurs de chaines de caractères et d’entiers en même temps :

      user = "Sammy"
      lines = 50
      
      print("Congratulations, " + user + "! You just wrote " + lines + " lines of code.")
      

      Lorsque nous exécutons ce code, nous obtenons l’erreur suivante :

      Output

      TypeError: Can't convert 'int' object to str implicitly

      Nous ne sommes pas en mesure de concaténer des chaines de caractères et des entiers dans Python. Nous devrons donc convertir les lines de variables en chaines de caractères :

      user = "Sammy"
      lines = 50
      
      print("Congratulations, " + user + "! You just wrote " + str(lines) + " lines of code.")
      

      Maintenant, lorsque nous exécutons le code, nous obtenons le résultat suivant qui félicite notre utilisateur du progrès qu’il a réalisé :

      Output

      Congratulations, Sammy! You just wrote 50 lines of code.

      Si nous cherchons à convertir un décimal en une chaine de caractères plutôt qu’un entier en chaine de caractères, nous devons suivre les mêmes étapes et le même format. Lorsque nous saisissons un décimal dans la méthode de str(), la valeur de chaine de caractères du décimal sera renvoyée. Nous pouvons utiliser soit la valeur du décimal en elle-même ou une variable :

      print(str(421.034))
      
      f = 5524.53
      print(str(f))
      

      Output

      421.034 5524.53

      Nous pouvons tester si elle est correcte en la concaténant avec une chaine de caractères :

      f = 5524.53
      print("Sammy has " + str(f) + " points.")
      

      Output

      Sammy has 5524.53 points.

      Nous pouvons avoir la certitude que notre décimal a été correctement converti en une chaine de caractères car la concaténation a été effectuée sans erreur.

      Conversion de chaines de caractères en chiffres

      Vous pouvez convertir des chaines de caractères en chiffres en utilisant les méthodes int() et float().

      Si votre chaine de caractères ne dispose pas de décimal, vous voudrez très probablement la convertir en un entier en utilisant la méthode int().

      Utilisons l’exemple de l’utilisateur Sammy qui garde un suivi des lignes de code écrites quotidiennement. Nous souhaiterions éventuellement manipuler ces valeurs avec des calculs afin de fournir des commentaires plus intéressants à l’utilisateur. Cependant, ces valeurs sont actuellement stockées dans des chaines de caractères :

      lines_yesterday = "50"
      lines_today = "108"
      
      lines_more = lines_today - lines_yesterday
      
      print(lines_more)
      

      Output

      TypeError: unsupported operand type(s) for -: 'str' and 'str'

      Étant donné que les deux valeurs numériques ont été stockées dans des chaines de caractères, une erreur nous a été renvoyée. L’opérande - pour les soustractions n’est un opérande valable pour deux valeurs de chaines de caractères.

      Modifions le code pour inclure la méthode int() qui convertira les chaines de caractères en entiers et faisons quelques calculs avec les valeurs qui étaient initialement des chaines de caractères.

      lines_yesterday = "50"
      lines_today = "108"
      
      lines_more = int(lines_today) - int(lines_yesterday)
      
      print(lines_more)
      

      Output

      58

      La variable lines_more est automatiquement un entier et égale à la valeur numérique 58 dans cet exemple.

      Nous pouvons également convertir les chiffres dans l’exemple ci-dessus en valeurs décimales en utilisant la méthode float() à la place de la méthode int(). Au lieu de recevoir le résultat de 58, nous obtiendrons le résultat de 58.0, un chiffre décimal.

      L’utilisateur Sammy gagne des points en valeurs décimales

      total_points = "5524.53"
      new_points = "45.30"
      
      new_total_points = total_points + new_points
      
      print(new_total_points)
      

      Output

      5524.5345.30

      Dans ce cas, il est possible d’utiliser l’opérande + avec deux chaines de caractères, mais il concatène deux chaines de caractères au lieu d’additionner deux valeurs numériques. Notre résultat est donc inhabituel car il se contente juste de placer les deux valeurs l’une à côté de l’autre.

      Nous allons devoir convertir ces chaines de caractères en décimaux avant d’effectuer un calcul avec la méthode float() :

      total_points = "5524.53"
      new_points = "45.30"
      
      new_total_points = float(total_points) + float(new_points)
      
      print(new_total_points)
      

      Output

      5569.83

      Maintenant que nous avons converti les deux chaines de caractères en décimaux, nous obtenons le résultat anticipé qui additionne 45.30 et 5524.53.

      Si nous essayons de convertir une valeur de chaines de caractères avec des décimaux en un entier, nous obtiendrons une erreur :

      f = "54.23"
      print(int(f))
      

      Output

      ValueError: invalid literal for int() with base 10: '54.23'

      Si nous plaçons une valeur décimale dans une chaîne de caractères dans la méthode int(), nous obtiendrons une erreur car elle ne se convertira pas en un entier.

      En effet, en convertissant des chaines de caractères en chiffres, nous pouvons rapidement modifier le type de données avec lequel nous travaillons et effectuer des calculs sur des valeurs numériques qui ont été initialement saisies en tant que chaines de caractères.

      Conversion des tuples en listes

      Vous pouvez utiliser les méthodes list() et tuple() pour convertir les valeurs qui leur ont été transmises en type de données de liste et tuple respectivement. Sous Python :

      • une list est une séquence d’éléments ordonnés et altérables entre crochets [ ].
      • un tuple est une séquence d’éléments immuables et ordonnés entre parenthèses ( ).

      Conversion des tuples

      Commençons par convertir une liste en un tuple. Étant donné qu’il s’agit d’un type de données immuable, la conversion d’une liste en tuple peut permettre une optimisation substantielle aux programmes que nous créons. Lorsque nous utilisons la méthode tuple(), le système renverra la version tuple de la valeur qui lui a été soumise.

      print(tuple(['pull request', 'open source', 'repository', 'branch']))
      

      Output

      ('pull request', 'open source', 'repository', 'branch')

      Nous voyons qu’un tuple est imprimé dans le résultat car les éléments sont maintenant entre parenthèses et non entre crochets.

      Utilisons tuple() avec une variable qui représente une liste :

      sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp']
      print(tuple(sea_creatures))
      

      Output

      ('shark', 'cuttlefish', 'squid', 'mantis shrimp')

      À nouveau, nous voyons que la valeur de liste est modifiée en une valeur de tuple, indiquée par les parenthèses. Nous pouvons convertir tout type itérable en tuple, notamment des chaines de caractères :

      print(tuple('Sammy'))
      

      Output

      ('S', 'a', 'm', 'm', 'y')

      Étant donné que nous pouvons itérer des chaines de caractères, nous pouvons les convertir en tuples en utilisant la méthode tuple(). Cependant, en utilisant des types de données qui ne sont pas itérables, comme des entiers et des décimaux, nous obtiendrons une erreur de type :

      print(tuple(5000))
      

      Output

      TypeError: 'int' object is not iterable

      Bien qu’il soit possible de convertir l’entier en une chaîne de caractères et de le convertir ensuite en tuple, comme dans tuple(str(5000)), il est préférable d’opter pour un code lisible plutôt que des conversions compliquées.

      Conversion en listes

      Il est possible de convertir des valeurs, en particulier des tuples, en listes si vous avez besoin d’une version altérable de cette valeur.

      Nous allons utiliser la méthode list() pour convertir le tuple suivant en une liste. Étant donné que la syntaxe de création d’une liste utilise des parenthèses, veillez à bien inclure les parenthèses de la méthode list(), et dans le cas présent de la méthode print() également :

      print(list(('blue coral', 'staghorn coral', 'pillar coral')))
      

      Output

      ['blue coral', 'staghorn coral', 'pillar coral']

      Les crochets signalent qu’une liste a été renvoyée à partir de la valeur du tuple initialement transmise en utilisant la méthode list().

      Pour rendre le code plus lisible, nous pouvons supprimer l’une des paires de parenthèses en utilisant une variable :

      coral = ('blue coral', 'staghorn coral', 'pillar coral')
      list(coral)
      

      Si nous imprimons list(coral), nous obtiendrons le même résultat que celui ci-dessus.

      Tout comme les tuples, vous pouvez convertir des chaines de caractères en listes :

      print(list('shark'))
      

      Output

      ['s', 'h', 'a', 'r', 'k']

      Ici, la chaine de caractères 'shark' a été convertie en une liste, donnant une version altérable de la valeur d’origine.

      Conclusion

      Au cours de ce tutoriel sur Python, vous avez vu comment convertir plusieurs des importants types de données natives en d’autres types de données, en utilisant principalement des méthodes intégrées. Maintenant que vous savez convertir des types de données sous Python, vous disposez d’une plus grande flexibilité pour écrire vos programmes.



      Source link

      Cómo convertir tipos de datos en Go


      Introducción

      En Go, los tipos de datos se utilizan para clasificar un tipo de dato concreto y determinan los valores que puede asignar al tipo y las operaciones que puede realizar en él. Cuando realice tareas de programación, a veces deberá aplicar conversiones de valores entre tipos para manipular los valores de forma diferente. Por ejemplo, es posible que deba concatenar valores numéricos con cadenas o representar lugares decimales en números que se iniciaron como valores enteros. Los datos generados por el usuario a menudo se asignan al tipo de datos de cadena, incluso si consisten en números; para realizar operaciones matemáticas en esta entrada, tendría que convertir la cadena a un tipo de dato numérico.

      Ya que Go es un lenguaje de tipo estático, los tipos de datos se vinculan a variables en lugar de valores. Esto significa que si define una variable como int, solo puede ser int; no puede asignar una string a ella sin convertir el tipo de datos de la variable. En la naturaleza estática de los tipos de datos de Go se da aún más importancia a las formas de convertirlos.

      Este tutorial le servirá como guía para convertir números y cadenas, y en él encontrará ejemplos que lo ayudarán a familiarizarse con los diferentes casos de uso.

      Convertir tipos de números

      Go tiene varios tipos numéricos que puede elegir. Principalmente, se dividen en dos tipos generales: enteros y números de punto flotante.

      Existen muchas situaciones en las cuales posiblemente desee aplicar conversiones entre tipos numéricos. Realizar conversiones a diferentes tamaños de tipos numéricos puede servir para optimizar el rendimiento para clases específicas de arquitecturas de sistema. Si dispone de un entero de otra parte de su código y desea hacer una división en él, es posible que desee convertir el entero a un flotante para preservar la precisión de la operación. Además, para trabajar con duraciones de tiempo normalmente es necesario realizar conversiones de enteros. Para abordar estas situaciones, Go tiene conversiones de tipo integradas para la mayoría de los tipos numéricos.

      Realizar conversiones a tipos de enteros

      Go tiene muchos tipos de datos enteros entre los que se puede elegir. La elección de uno u otro normalmente se relaciona más con el rendimiento; sin embargo, habrá veces en las que necesitará realizar conversiones de un tipo de entero a otro. Por ejemplo, Go a veces genera automáticamente valores numéricos como int, que posiblemente no sea su valor de entrada. Si su valor de entrada fuese int64, no podría usar int y los números int64 en la misma expresión matemática sin antes convertir sus tipos de datos para que coincidan.

      Suponga que tiene un inst8 y debe convertirlo en un int32. Puede hacer esto ajustándolo en la conversión de tipo int32():

      var index int8 = 15
      
      var bigIndex int32
      
      bigIndex = int32(index)
      
      fmt.Println(bigIndex)
      

      Output

      15

      Este bloque de código define index como un tipo de dato int8 y bigIndex como un tipo de dato int32. Para almacenar el valor de index en bigIndex, convierte el tipo de dato en int32. Esto se hace ajustando la conversión de int32() alrededor de la variable index.

      Para verificar sus tipos de datos, podría usar la instrucción fmt.Prntf y el verbo %T con la siguiente sintaxis:

      fmt.Printf("index data type:    %Tn", index)
      fmt.Printf("bigIndex data type: %Tn", bigIndex)
      

      Output

      index data type: int8 bigIndex data type: int32

      Debido a que esto utiliza el verbo %T, la instrucción de impresión produce el tipo para la variable, no el valor real de esta. De esta forma, puede confirmar el tipo de dato convertido.

      También puede realizar conversiones de un entero con un tamaño de bits mayor a un entero con un tamaño de bits menor:

      var big int64 = 64
      
      var little int8
      
      little = int8(big)
      
      fmt.Println(little)
      

      Output

      64

      Tenga en cuenta que al convertir enteros podría superar potencialmente el valor máximo del tipo de datos y del ajuste:

      var big int64 = 129
      var little = int8(big)
      fmt.Println(little)
      

      Output

      -127

      Un ajuste tiene lugar cuando el valor se convierte a un tipo de dato que es demasiado pequeño para contenerlo. En el ejemplo anterior, el tipo de dato de 8 bits int8 no tenía suficiente espacio para contener la variable big de 64 bits. Se debe tener cuidado cuando se realicen conversiones de un tipo de dato numérico más grande a un tipo de dato numérico más pequeño, para no truncar los datos por accidente.

      Convertir enteros en flotantes

      La conversión de enteros en flotantes en Go se asemeja a la conversión de un tipo de entero en otro. Puede usar las conversiones de tipo integradas ajustando float64() o float32() alrededor del entero que convertirá:

      var x int64 = 57
      
      var y float64 = float64(x)
      
      fmt.Printf("%.2fn", y)
      

      Output

      57.00

      Este código declara una variable x de tipo int64 e inicializa su valor en 57.

      var x int64 = 57
      

      Ajustar la conversión float64() alrededor de x convertirá el valor de 57 en un valor flotante de 57.00.

      var y float64 = float64(x)
      

      El verbo de impresión %.2f indica a fmt.Printf que aplique formato al flotante con dos decimales.

      También puede usar este proceso en una variable: Con el siguiente código, se declara f como igual a 57 y luego se imprime el nuevo flotante:

      var f float64 = 57
      fmt.Printf("%.2fn", f)
      

      Output

      57.00

      Usando float32() o float64(), puede convertir enteros en flotantes. A continuación, aprenderá a convertir flotantes en enteros.

      Convertir flotantes en enteros

      Go puede convertir flotantes en enteros, pero el programa perderá la precisión del flotante.

      El ajuste de flotantes en int(), o uno de sus tipos de datos independientes de la arquitectura, funciona de forma similar al que empleó para la conversión de un tipo de entero en otro. Puede añadir un número de punto flotante dentro del paréntesis para convertirlo en un entero.

      var f float64 = 390.8
      var i int = int(f)
      
      fmt.Printf("f = %.2fn", f)
      fmt.Printf("i = %dn", i)
      

      Output

      f = 390.80 i = 390

      Esta sintaxis convertiría el flotante 390.8 en el entero 390 y quitaría el lugar decimal.

      También puede usar esto con variables. Con el siguiente código se declara que b es igual a 125.0 y que c es igual a 390.8, y luego estos se imprimen como enteros. La declaración de variable corta (:=) acorta la sintaxis:

      b := 125.0
      c := 390.8
      
      fmt.Println(int(b))
      fmt.Println(int(c))
      

      Output

      125 390

      Cuando se convierten flotantes en enteros con el tipo int(), Go corta el decimal y los números restantes de un flotante para crear un entero. Tenga en cuenta que, aunque posiblemente desee redondear 390.8 a 391, Go no hará esto a través del tipo int(). En vez de eso, quitará el decimal.

      Números convertidos mediante división

      Cuando se dividan tipos de enteros en Go, el resultado será también un tipo de entero, sin el modulus o resto:

      a := 5 / 2
      fmt.Println(a)
      

      Output

      2

      Si, al realizar la división, cualquiera de los tipos numéricos son un flotante, todos los tipos se declararán automáticamente como flotante:

          a := 5.0 / 2
          fmt.Println(a)
      

      Output

      2.5

      Con esto se divide el flotante 5.0 por el entero 2, y la respuesta 2.5 es un flotante que conserva la precisión decimal.

      A lo largo de esta sección, realizó conversiones entre diferentes tipos de datos numéricos, como tamaños de enteros diferentes y números con punto flotante. A continuación, aprenderá a realizar conversiones de números a cadenas.

      Realizar conversiones con cadenas

      Una cadena es una secuencia de uno o más caracteres (letras, números o símbolos). Las cadenas son una forma de dato común en los programas informáticos y es posible que deba convertir cadenas en números o números en cadenas con bastante frecuencia, sobre todo si toma datos generados por el usuario.

      Convertir números en cadenas

      Puede convertir números en cadenas usando el método strconv.ltoa del paquete strconv de la biblioteca estándar de Go. Si pasa un número o una variable a los paréntesis del método, ese valor numérico se convertirá en un valor de cadena.

      Primero, veremos la forma de convertir enteros. Para convertir el entero 12 a un valor de cadena, puede pasar 12 al método strconv.ltoa:

      package main
      
      import (
          "fmt"
          "strconv"
      )
      
      func main() {
          a := strconv.Itoa(12)
          fmt.Printf("%qn", a)
      }
      

      Al ejecutar este programa, recibirá el siguiente resultado:

      Output

      "12"

      Las comillas alrededor del número 12 implican que este ya no es un entero, sino que ahora es un valor de cadena.

      Utilizó el operador de asignación := para declarar una nueva variable con el nombre a y asignar el valor mostrado de la función strconv.ltoa(). En este caso, asignó el valor 12 a su variable. También usó el verbo %q en la función fmt.Printf, que indica a la función que cite la cadena proporcionada.

      Con las variables podrá observar la practicidad de la conversión de enteros en cadenas. Supongamos que desea realizar un seguimiento del progreso de la programación diaria por parte de un usuario e introduce la cantidad de líneas de código que este escribe a la vez. Desearía mostrar esto al usuario e imprimirá los valores de cadenas y enteros al mismo tiempo:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          user := "Sammy"
          lines := 50
      
          fmt.Println("Congratulations, " + user + "! You just wrote " + lines + " lines of code.")
      }
      

      Cuando ejecute este código, verá el siguiente error:

      Output

      invalid operation: ("Congratulations, " + user + "! You just wrote ") + lines (mismatched types string and int)

      No puede concatenar cadenas ni enteros en Go. Por lo tanto, deberá convertir la variable lines en un valor de cadena:

      package main
      
      import (
          "fmt"
          "strconv"
      )
      
      func main() {
          user := "Sammy"
          lines := 50
      
          fmt.Println("Congratulations, " + user + "! You just wrote " + strconv.Itoa(lines) + " lines of code.")
      }
      

      Ahora, cuando ejecute el código verá el siguiente resultado en el que se felicita a su usuario por su progreso:

      Output

      Congratulations, Sammy! You just wrote 50 lines of code.

      Si desea convertir en una cadena un flotante en vez de un entero, aplicará pasos y un formato similares. Cuando pase un flotante al método fmt.Sprint, desde el paquete fmt de la biblioteca estándar de Go, se mostrará un valor de cadena del flotante. Puede usar el valor flotante o una variable:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          fmt.Println(fmt.Sprint(421.034))
      
          f := 5524.53
          fmt.Println(fmt.Sprint(f))
      }
      

      Output

      421.034 5524.53

      Puede realizar una comprobación para asegurarse de que esté bien realizando una concatenación con una cadena:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          f := 5524.53
          fmt.Println("Sammy has " + fmt.Sprint(f) + " points.")
      }
      

      Output

      Sammy has 5524.53 points.

      Puede estar seguro de que su flotante se convirtió adecuadamente en una cadena porque la concatenación se realizó sin errores.

      Convertir cadenas en números

      Las cadenas pueden convertirse en números usando el paquete strconv de la biblioteca estándar Go. El paquete strconv tiene funciones para convertir tipos numéricos enteros y flotantes. Ésta es una operación muy común al aceptar entradas del usuario. Por ejemplo, si su programa solicitara la edad de una persona, cuando esta escribiera la respuesta se capturaría como una string. Tendría que convertirla en un int para hacer cualquier operación matemática con ella.

      Si su cadena no tiene lugares decimales, probablemente querrá convertirla en un entero usando la función strconv.Atoi. Si sabe que usará el número como un flotante, empleará strconv.ParseFloat.

      Usaremos el ejemplo del usuario Sammy realizando un seguimiento de las líneas de código escritas cada día. Es posible que desee manipular esos valores con cálculos matemáticos para proporcionar una respuesta más interesante para el usuario, pero se almacenan actualmente en cadenas:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          lines_yesterday := "50"
          lines_today := "108"
      
          lines_more := lines_today - lines_yesterday
      
          fmt.Println(lines_more)
      }
      

      Output

      invalid operation: lines_today - lines_yesterday (operator - not defined on string)

      Debido a que los dos valores numéricos se hallaban almacenados en cadenas, vio un error. El operando - para la sustracción no es un operando válido para dos valores de cadena.

      Modifique el código para incluir el método strconv.Atoi() que convertirá las cadenas en enteros, lo que le permitirá realizar cálculos matemáticos con valores que eran originalmente cadenas. Ya que existe la posibilidad de que se produzcan fallas al convertir una cadena en un entero, debe verificar si hay errores. Puede usar una instrucción if para comprobar si su conversión se realizó correctamente.

      package main
      
      import (
          "fmt"
          "log"
          "strconv"
      )
      
      func main() {
          lines_yesterday := "50"
          lines_today := "108"
      
          yesterday, err := strconv.Atoi(lines_yesterday)
          if err != nil {
              log.Fatal(err)
          }
      
          today, err := strconv.Atoi(lines_today)
          if err != nil {
              log.Fatal(err)
          }
          lines_more := today - yesterday
      
          fmt.Println(lines_more)
      }
      

      Debido a que es posible que una cadena no sea un número, el método strconv.Atoi() mostrará el tipo convertido y el posible error. Al realizar una conversión a partir de lines_yesterday con la función strconv.Atoi, debe verificar el valor de retorno err para asegurarse de que el valor se haya convertido. Si err no es nil, significa que strconv.Atoi no pudo convertir correctamente el valor de cadena en un entero. En este ejemplo, usó una instrucción if para verificar si se produjo un error y, si se observó uno, usó log.Fatal para registrarlo y salir del programa.

      Cuando ejecute el código anterior, obtendrá lo siguiente:

      Output

      58

      A continuación, intente convertir una cadena que no sea un número:

      package main
      
      import (
          "fmt"
          "strconv"
      )
      
      func main() {
          a := "not a number"
          b, err := strconv.Atoi(a)
          fmt.Println(b)
          fmt.Println(err)
      }
      

      Observará el siguiente error:

      Output

      0 strconv.Atoi: parsing "not a number": invalid syntax

      Debido a que se declaró b, pero strconv.Atoi no pudo realizar la conversión, nunca se asignó un valor a b. Observe que b tiene el valor 0. Esto se debe a que Go tiene valores predeterminados, conocidos como valores cero en Go. strconv.Atoi proporciona un error en el que se describe la razón por la que no se pudo convertir también la cadena.

      Convertir cadenas y bytes

      Las cadenas en Go se almacenan como un segmento de bytes. En Go, puede realizar conversiones de un segmento de bytes a una cadena ajustándola en las conversiones correspondientes de []byte()​​​1​​​ y string().

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          a := "my string"
      
          b := []byte(a)
      
          c := string(b)
      
          fmt.Println(a)
      
          fmt.Println(b)
      
          fmt.Println(c)
      }
      

      Aquí almacenó un valor de cadena en a, luego lo convirtió a un segmento de bytes b y luego convirtió el segmento de bytes de nuevo en una cadena como c. Después, imprimirá a, b y c en la pantalla:

      Output

      my string [109 121 32 115 116 114 105 110 103] my string

      La primera línea del resultado es la cadena original my string. La segunda línea impresa es el segmento de bytes que forma la cadena original. En la tercera línea se muestra que el segmento de bytes puede convertirse de forma segura en una cadena e imprimirse de nuevo.

      Conclusión

      En este tutorial de Go se demostró la forma de convertir varios de los tipos importantes de datos nativos en otros tipos de datos, principalmente mediante métodos integrados. Poder convertir tipos de datos en Go le permitirá hacer cosas como aceptar la entrada de un usuario y realizar cálculos matemáticos en diferentes tipos numéricos. Posteriormente, cuando utilice Go para escribir programas que acepten datos desde muchas fuentes diferentes como bases de datos y API, usará estos métodos de conversión para asegurarse de poder aplicar acciones a sus datos. También podrá optimizar el almacenamiento convirtiendo datos a tipos de datos más pequeños.

      Si desea ver un análisis más profundo de los tipos de datos de Go, consulte nuestro artículo Información sobre los tipos de datos de Go.



      Source link