One place for hosting & domains

      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

      Como converter tipos de dados em Python 3


      Introdução

      Na linguagem Python, os tipos de dados são usados para classificar um tipo específico de dados, determinando os valores que você pode atribuir ao tipo e as operações que você pode realizar nele. Ao programar, há momentos em que será necessário converter valores entre os no tipos, no intuito de manipular tais valores de maneira diferente. Por exemplo, talvez seja necessário concatenar valores numéricos com strings, ou representar casas decimais em números que foram inicializados como valores de número inteiro.

      Este tutorial irá ensinar a converter tipos de dados, incluindo números, strings, tuplas e listas, bem como fornecer exemplos para ajudar você a familiarizar-se com diferentes casos de uso.

      Convertendo os tipos de número

      Em Python, existem dois tipos de dados numéricos: inteiros e números de ponto flutuante (float). Às vezes, ao trabalhar no código de outra pessoa, será necessário converter um inteiro para um float ou vice-versa. Em outros casos, você pode estar usando um inteiro quando o que realmente precisa é de um float. O Python possui métodos integrados para permitir a conversão de inteiros em floats e floats em inteiros.

      Convertendo os números inteiros em floats

      O método float() do Python irá converter inteiros em floats. Para usar essa função, adicione um inteiro dentro dos parênteses:

      float(57)
      

      Neste caso, 57 será convertido em 57.0.

      Também é possível usar essa técnica com uma variável. Vamos declarar f como igual a 57, e então imprimir o novo float:

      f = 57
      print(float(f))
      

      Output

      57.0

      Usando a função float(), podemos converter inteiros em floats.

      Convertendo floats em inteiros

      O Python também possui uma função integrada para converter floats em inteiros: int().

      A função int() funciona de maneira semelhante à função float(): é possível adicionar um número de ponto flutuante dentro dos parênteses para convertê-lo em um inteiro:

      int(390.8)
      

      Neste caso, 390.8 será convertido em 390.

      Você também pode usar essa técnica com as variáveis. Vamos declarar b como igual a 125.0, e c como igual a 390.8, e então imprimir os novos floats:

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

      Output

      125 390

      Ao converter os floats em inteiros com a função int(), o Python corta a casa decimal e os números do float que restam são usados para criar um inteiro. Embora talvez você queira arredondar 390,8 para 391, o Python não fará isso através da função int().

      Números convertidos através de divisão

      Em Python 3, quocientes relevantes são convertidos de inteiros para floats ao fazer uma divisão, embora não sejam em Python 2. Ou seja, quando você dividir 5 por 2, em Python 3, você receberá um float como resposta (2.5):

      a = 5 / 2
      print(a)
      

      Output

      2.5

      Em Python 2, como você estava lidando com dois inteiros, você receberia um inteiro de volta como sua resposta: 5 / 2 = 2. Leia “Python 2 vs Python 3: considerações práticas“ para mais informações sobre as diferenças entre o Python 2 e Python 3.

      Uma string é uma sequência de um ou mais caracteres (letras, números ou símbolos). As strings são uma forma comum de dados em programas de computador. Muitas vezes, pode ser necessário converter strings em números e números em strings, especialmente quando estivermos incluindo dados gerados pelo usuário.

      Convertendo números em strings

      Podemos converter números em strings usando o método str(). Vamos passar um número ou uma variável dentro dos parênteses do método e então esse valor numérico será convertido em um valor de string.

      Primeiro, vamos ver como converter inteiros. Para converter o inteiro 12 em um valor de string, passe o número 12 para o método str():

      str(12)
      

      Ao executar str(12) no shell interativo do Python com o comando python em uma janela de terminal, você receberá o seguinte resultado:

      Output

      '12'

      As aspas ao redor do número 12 significam que o número já não é mais um inteiro, mas sim um valor de string.

      Com variáveis, podemos começar a ver como é prático converter inteiros em strings. Vamos supor que queiramos monitorar o progresso diário de um usuário na programação e estamos inserindo quantas linhas de código eles estão escrevendo por vez. Queremos mostrar esse feedback para o usuário. Para tanto, os valores de string e inteiro serão impressos ao mesmo tempo:

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

      Ao executar este código, iremos receber o seguinte erro:

      Output

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

      Não é possível concatenar strings e inteiros em Python, de modo que teremos que converter a variável lines para se tornar um valor de string:

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

      Agora, ao executar o código, iremos receber o resultado a seguir, parabenizando o usuário pelo progresso alcançado:

      Output

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

      Se quisermos converter um float em uma string, ao invés de um inteiro em uma string, seguimos os mesmos passos e formatos. Ao passar um float no método str(), um valor de string do float será retornado. Podemos usar o valor do float em si ou uma variável:

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

      Output

      421.034 5524.53

      Vamos fazer um teste para garantir que tudo está correto, fazendo a concatenação com uma string:

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

      Output

      Sammy has 5524.53 points.

      Agora, temos certeza de que o float foi convertido corretamente em uma string, pois a concatenação foi realizada sem nenhum erro.

      Convertendo strings em números

      As strings podem ser convertidas em números usando os métodos int() e float().

      Se sua string não tiver casas decimais, você provavelmente vai querer convertê-la em um número inteiro, usando o método int().

      Vamos usar o exemplo do usuário Sammy, monitorando as linhas de código escritas a cada dia. Pode ser que queiramos manipular esses valores com operações matemáticas, no intuito de dar um feedback mais interessante para o usuário. Porém, no momento, tais valores estão armazenados em strings:

      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'

      Como os dois valores numéricos foram armazenados em strings, um erro foi emitido. O operando - para a subtração não é um operando válido para dois valores de string.

      Modifique o código para incluir o método int() que converterá as strings em inteiros, permitindo, assim, fazer operações matemáticas com os valores que eram originalmente strings.

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

      Output

      58

      A variável lines_more é automaticamente um inteiro, sendo igual ao valor numérico de 58 neste exemplo.

      Também é possível converter os números no exemplo acima em valores float usando o método float() no lugar do método int(). Em vez de receber o resultado de 58, iremos receber o resultado de 58.0, um float.

      O usuário Sammy está ganhando pontos em valores decimais.

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

      Output

      5524.5345.30

      Neste caso, usar o operando + com duas strings é uma operação válida, mas irá concatenar duas strings ao invés de fazer a adição de dois valores numéricos. Então, nosso resultado parece não convencional, pois apenas coloca os dois valores um ao lado do outro.

      Precisamos converter essas strings em floats antes de executar qualquer operação matemática com o 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

      Agora que convertemos as duas strings em floats, recebemos o resultado esperado que adiciona 45.30 a 5524.53.

      Se tentarmos converter um valor de string com casas decimais em um inteiro, iremos receber um erro:

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

      Output

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

      Se passarmos um valor decimal em uma string para o método int(), iremos receber um erro, pois ele não será convertido em um inteiro.

      Converter strings em números nos permite modificar rapidamente o tipo de dados com o qual estamos trabalhando para que possamos realizar operações com valores numéricos que eram originalmente strings.

      Convertendo em tuplas e listas

      Os métodos list() e tuple() podem ser usados para converter os valores passados a eles nos tipos de dados lista e tupla respectivamente. Em Python:

      • uma lista é uma sequência ordenada mutável de elementos que fica contida dentro de colchetes [ ].
      • uma tupla é uma sequência ordenada imutável de elementos contida dentro de parênteses ( ).

      Convertendo em tuplas

      Vamos começar com a conversão de uma lista em uma tupla. Converter uma lista em uma tupla, que é um tipo de dados imutável, pode permitir uma otimização substancial aos programas que criamos. Quando usamos o método tuple(), ela irá retornar a versão em tupla do valor passado a ele.

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

      Output

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

      Vemos que uma tupla foi impressa no resultado, pois os itens estão agora contidos dentro de parênteses ao invés de colchetes.

      Vamos usar tuple() com uma variável que representa uma lista:

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

      Output

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

      Novamente, vemos que o valor de lista foi alterado para um valor de tupla, indicado pelos parênteses. Podemos converter qualquer tipo iterável em uma tupla, incluindo strings:

      print(tuple('Sammy'))
      

      Output

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

      Considerando que é possível iterar em strings, podemos convertê-las em tuplas com o método tuple(). Entretanto, com tipos de dados que não são iteráveis, como inteiros e floats, iremos receber um erro do tipo:

      print(tuple(5000))
      

      Output

      TypeError: 'int' object is not iterable

      Embora seja possível converter um inteiro em uma string, para então converter em uma tupla, como em tuple(str(5000)), é melhor escolher um código legível ao invés de conversões complicadas.

      Convertendo em listas

      Converter valores, especialmente tuplas, em listas, pode ser útil quando for necessário ter uma versão mutável desse valor.

      Vamos usar o método list() para converter a tupla a seguir em uma lista. Como a sintaxe para criar uma lista usa parênteses, certifique-se de incluir os parênteses do método list() e, neste caso, também o método print():

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

      Output

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

      Os colchetes indicam que uma lista foi retornada a partir do valor de tupla original passado ao método list().

      Para tornar o código mais legível, podemos remover um dos pares de parênteses usando uma variável:

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

      Caso imprimíssemos list(coral), iríamos receber o mesmo resultado que acima.

      Assim como as tuplas, as strings podem ser convertidas em listas:

      print(list('shark'))
      

      Output

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

      Aqui, a string 'shark' foi convertida em uma lista, fornecendo uma versão mutável do valor original.

      Conclusão

      Este tutorial de Python demonstrou como converter vários dos tipos de dados nativos importantes em outros tipos de dados, principalmente através de métodos integrados. Ser capaz de converter tipos de dados em Python fornece uma flexibilidade extra ao escrever seus programas.



      Source link

      Como converter tipos de dados em Go


      Introdução

      Na linguagem Go, os tipos de dados são usados para classificar um tipo específico de dados, determinando os valores que você pode atribuir ao tipo e às operações que você pode realizar com ela. Ao programar, há momentos em que você terá que converter valores entre os no tipos, no intuito de manipular tais valores de maneira diferente. Por exemplo, talvez você necessite concatenar valores numéricos com strings, ou representar casas decimais em números que foram inicializados como valores de número inteiro. Com frequência, o tipo de dados da string é automaticamente atribuído aos dados gerados pelo usuário, mesmo se consistirem em números. Para realizar operações matemáticas nessa entrada, por exemplo, você teria que converter a string para um tipo de dados numéricos.

      Como o Go é uma linguagem de tipagem estática, os tipos de dados são vinculados às variáveis e não aos valores. Isso significa que, se você definir uma variável como int, ela só poderá ser uma int; você não poderá atribuir-lhe uma string sem converter o tipo de dados da variável. A natureza estática dos tipos de dados em Go confere ainda mais importância ao aprendizado das maneiras de convertê-los.

      Este tutorial explicará sobre como converter números e strings, além de fornecer exemplos para ajudar você a se familiarizar com os diferentes casos de uso.

      Convertendo os tipos de número

      O Go tem vários tipos numéricos dentre os quais escolher. Em princípio, eles se dividem em dois tipos gerais: os números inteiros e os números de ponto flutuante.

      Existem várias situações nas quais você pode querer converter entre os tipos numéricos. Converter entre diferentes tamanhos de tipos numéricos pode ajudar a otimizar o desempenho em relação a tipos específicos de arquiteturas de sistema. Se você tiver um número inteiro de outra parte do seu código e quiser fazer uma divisão com ele, você pode querer converter o número inteiro em um float, a fim de preservar a precisão da operação. Além disso, trabalhar com durações do tempo geralmente envolve uma conversão de número inteiro. Para resolver essas situações, o Go tem a função de conversões de tipo integrada para a maioria dos tipos numéricos.

      Convertendo entre os tipos de inteiros

      A linguagem Go tem muitos tipos de dados inteiros dentre os quais escolher. Quando escolher um e não o outro, normalmente, é uma questão de desempenho; no entanto, haverá momentos em que você precisará converter de um tipo de número inteiro para outro. Por exemplo, o Go gera valores numéricos de maneira automática, como int, o qual pode não corresponder ao valor de sua entrada. Se o valor de sua entrada fosse um int64, não seria possível usar números int e int64 na mesma expressão matemática até que você convertesse seus respectivos tipos de dados para que correspondessem.

      Suponha que você tem um int8 e que precisa convertê-lo em um int32. Você pode fazer isso encapsulando-o na conversão de tipo int32():

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

      Output

      15

      Esse bloco de código define index como um tipo de dados int8 e bigIndex como um tipo de dados int32. Para armazenar o valor index no bigIndex, ele converte o tipo de dados para um int32. Isso é feito encapsulando-se conversão de int32() em torno da variável index.

      Para verificar seus tipos de dados, você poderia usar a instrução fmt.Printf e o verbo %T com a seguinte sintaxe:

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

      Output

      index data type: int8 bigIndex data type: int32

      Como esse procedimento usa o verbo %T, a instrução de impressão produz o tipo para a variável e não o valor real da variável. Desta forma, você pode confirmar o tipo de dados convertido.

      Você pode, ainda, converter de um número inteiro de bit maior para um número inteiro de bit menor.

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

      Output

      64

      Lembre-se de que ao converter números inteiros, haveria a possibilidade de você exceder o valor máximo do tipo do dados e do wraparound:

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

      Output

      -127

      Um wraparound ocorre quando um valor é convertido para um tipo de dados de tamanho pequeno demais para contê-lo. No exemplo anterior, o tipo de dados de 8 bits int8 não tinha espaço suficiente para conter a variável de 64 bits big. Ao se converter de um tipo de dados de valor maior para um tipo de dados de valor menor, é necessário sempre tomar cuidado para não truncar acidentalmente os dados.

      Convertendo os números inteiros em floats

      A conversão de números inteiros em floats em Go é parecida com a conversão de um tipo de número inteiro para outro. Você pode usar as conversões de tipo integradas, fazendo com que os tipos float64() ou float32() envolvam o número inteiro que você estiver convertendo:

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

      Output

      57.00

      Esse código declara uma variável x do tipo int64 e inicializa seu valor em 57.

      var x int64 = 57
      

      Com a conversão do float64() envolvendo a variável x, o valor de 57 será convertido a um valor float de 57,00.

      var y float64 = float64(x)
      

      O verbo de impressão %2f diz ao fmt.Printf para formatar o float com dois decimais.

      Também é possível usar esse processo em uma variável. O código a seguir declara um f igual a 57 e, em seguida, imprime o novo float:

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

      Output

      57.00

      Você pode converter inteiros em floats usando tanto o float32() como o float64(). A seguir, você irá aprender como converter de floats em inteiros.

      Convertendo floats em inteiros

      O Go pode converter os floats em inteiros, mas o programa perderá a precisão do float.

      Envolver os floats em int(), ou um de seus tipos de dados de arquitetura independente, funciona de maneira similar à que usou para converter de um tipo inteiro a outro tipo. É possível adicionar um número de ponto flutuante dentro dos parênteses para convertê-lo em um número inteiro:

      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 sintaxe converteria o float 390.8 no número inteiro 390, eliminando a casa decimal.

      Você também pode usar essa técnica com as variáveis. O código a seguir declara b igual a 125.0 e c igual a 390.8; depois, o código os imprime como inteiros. A declaração de variável curta (:=) abrevia a sintaxe:

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

      Output

      125 390

      Ao converter os floats em inteiros com o tipo int(), o Go corta a casa decimal e os números do float que restam são usados para criar um inteiro. Note que, embora talvez você queira arredondar 390,8 para 391, o Go não fará isso através do tipo int(). Em vez disso, ele vai simplesmente eliminar a casa decimal.

      Números convertidos através de divisão

      Ao dividir tipos inteiros em Go, o resultado também será um tipo inteiro, com o modulus (módulo), ou o resto, removido.

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

      Output

      2

      Se, ao dividir, qualquer um dos tipos de número for um float, todos os tipos serão automaticamente declarados como float:

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

      Output

      2.5

      Isso divide o float 5.0 pelo número inteiro 2, tendo como resposta 2.5, que é um float que retém a precisão decimal.

      Nesta seção, você converteu entre os tipos de dados numéricos diferentes, incluindo tamanhos diferentes de inteiros e os números de ponto flutuante. A seguir, você irá aprender como converter entre números e strings.

      Uma string é uma sequência de um ou mais caracteres (letras, números ou símbolos). As strings são uma forma comum de dados em programas de computador. Você pode precisar converter strings em números e números em strings com bastante frequência, especialmente quando estiver incluindo dados gerados pelo usuário.

      Convertendo números em strings

      Você pode converter números em strings, usando o método strconv.Itoa do pacote strconv da biblioteca padrão do Go. Se passar um número ou uma variável entre os parênteses do método, aquele valor numérico será convertido em um valor de string.

      Primeiro, vamos examinar a conversão de de números inteiros. Para converter o inteiro 12 em um valor de string, você pode enviar o número o 12 para o método strconv.Itoa:

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

      Durante a execução deste programa, você receberá o seguinte resultado:

      Output

      "12"

      As aspas ao redor do número 12 significam que o número já não é mais um inteiro, mas sim um valor de string.

      Você usou o operador de instrução := tanto para declarar uma nova variável com o nome de a, como para atribuir o valor retornado pela função strconv.Itoa(). Neste caso, você atribuiu o valor 12 para sua variável. Você também usou o verbo %q na função fmt.Printf, o qual diz à função para citar a string fornecida.

      Com variáveis, você pode começar a ver como é prático converter inteiros em strings. Digamos que você queira monitorar o progresso diário dos usuários na programação, além do número de linhas que eles estão inserindo a cada vez no código que estão escrevendo. Você quer mostrar esse feedback para o usuário. Para tanto, você vai imprimir os valores de string e inteiro ao mesmo tempo:

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

      Ao executar este código, você receberá o seguinte erro:

      Output

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

      Você não pode concatenar strings e inteiros em Go, de modo que terá que converter a variável lines para se tornar um valor de string:

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

      Agora, quando executar o código, receberá o resultado a seguir, parabenizando o seu usuário pelo progresso alcançado:

      Output

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

      Se você tiver planos de converter um float em uma string, em vez de um inteiro em uma string, você seguirá passos e formatos semelhantes. Ao enviar um float para o método fmt.Sprint, a partir do pacote fmt na biblioteca Go padrão, será retornado um valor de string do float. Você pode usar o valor do float em si ou uma variável:

      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

      Você pode fazer um teste para se assegurar de que está correto, fazendo a concatenação com uma string:

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

      Output

      Sammy has 5524.53 points.

      Agora, você pode certificar-se que o float foi devidamente convertido em uma string porque a concatenação foi realizada sem erros.

      Convertendo strings em números

      As strings podem ser convertidas em números, usando-se o pacote strconv da biblioteca padrão do Go. O pacote strconv tem funções para converter tipos de números inteiros e float. Essa é uma operação muito comum quando o programa aceita entradas do usuário. Por exemplo, se você tiver um programa que pede a idade de uma pessoa e a pessoa digita uma resposta, essa resposta é capturada como uma string. Na sequência, você teria que converter a idade em um int para, assim, fazer qualquer operação matemática com ela.

      Se sua string não tiver casas decimais, você provavelmente vai querer convertê-la em um número inteiro, usando a função strconv.Atoi. Se você souber que usará o número como um float, usaria a strconv.ParseFloat.

      Vamos usar o exemplo do usuário Sammy, monitorando as linhas de código escritas a cada dia. Você pode querer manipular esses valores com operações matemáticas, no intuito de dar um feedback mais interessante para o usuário. Porém, no momento, tais valores estão armazenados em strings:

      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)

      Como os dois valores numéricos foram armazenados em strings, você recebeu um erro. O operando - para a subtração não é um operando válido para dois valores de string.

      Modifique o código para incluir o método strconv.Atoi() que converterá as strings em inteiros, permitindo, assim, que você faça operações matemáticas com os valores que eram originalmente strings. Como há uma falha em potencial ao se converter uma string em um inteiro, você tem que verificar se há algum erro. Você pode usar uma instrução if para verificar se sua conversão foi bem-sucedida.

      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)
      }
      

      Como é possível que uma string não seja um número, o método strconv.Atoi() retornará tanto o tipo convertido, quanto um erro em potencial. Ao converter a partir de lines_yesterday com a função strconv.Atoi, você tem que verificar o valor retornado err para assegurar que o valor foi convertido. Se o err não for nil, significa que o strconv.Atoi não conseguiu converter o valor string em um inteiro. Nesse exemplo, você usou uma instrução if para verificar quanto a algum erro. Se um erro foi retornado, você usou o log.Fatal para registrar o erro e sair do programa.

      Ao executar o código anterior, você receberá:

      Output

      58

      Agora, tente converter uma string que não seja um número:

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

      Você receberá o seguinte erro:

      Output

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

      Como o b foi declarado, mas o strconv.Atoi não conseguiu fazer uma conversão, o valor nunca foi atribuído a b. Note que o b tem o valor de 0. Isso acontece porque o Go tem valores padrão referidos como valores de zero em Go. O strconv.Atoi fornece um erro que descreve porque ele também não conseguiu converter a string.

      Convertendo strings e bytes

      As strings em Go são armazenadas em uma fatia de bytes. Na linguagem Go, você pode converter entre uma fatia de bytes e uma string encapsulando-a nas conversões correspondentes de []byte() e 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)
      }
      

      Aqui,você armazenou um valor de string em a; depois, converteu-o em uma fatia de bytes b; na sequência, converteu a fatia de bytes de volta em uma string, como c. Em seguida, imprimiu a, b e c na tela:

      Output

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

      A primeira linha do resultado é a string original my string. A segunda linha imprimida é a fatia byte que compõe a string original. A terceira linha mostra que a fatia byte pode ser convertida de volta com segurança em uma string e imprimida.

      Conclusão

      Este tutorial do Go demonstrou como converter vários dos tipos de dados nativos importantes em outros tipos de dados, principalmente através de métodos integrados. Poder converter tipos de dados em Go permitirá que você faça coisas como aceitar as entradas de usuários e realizar operações matemáticas entre os diferentes tipos de números. Mais tarde, quando estiver usando o Go para escrever programas que aceitam dados de várias fontes diferentes como bancos de dados e APIs, você usará esses métodos de conversão para garantir que possa atuar sobre os seus dados. Também será possível otimizar o armazenamento, convertendo dados em tipos de dados menores.

      Se você quiser uma análise mais profunda dos tipos de dados em Go, verifique nosso artigo Entendendo tipos de dados em Go.



      Source link