One place for hosting & domains

      Python

      How To Create an Intelligent Chatbot in Python Using the spaCy NLP Library


      The author selected the COVID-19 Relief Fund to receive a donation as part of the Write for DOnations program.

      Introduction

      Interacting with software can be a daunting task in cases where there are a lot of features. In some cases, performing similar actions requires repeating steps, like navigating menus or filling forms each time an action is performed. Chatbots are virtual assistants that help users of a software system access information or perform actions without having to go through long processes. Many of these assistants are conversational, and that provides a more natural way to interact with the system.

      To create a conversational chatbot, you could use platforms like Dialogflow that help you design chatbots at a high level. Or, you can build one yourself using a library like spaCy, which is a fast and robust Python-based natural language processing (NLP) library. spaCy provides helpful features like determining the parts of speech that words belong to in a statement, finding how similar two statements are in meaning, and so on.

      In this tutorial, you will create a chatbot that not only helps users simplify their interactions with a software system, but is also intelligent enough to communicate with the user in natural language (American English in this tutorial). The chatbot will use the OpenWeather API to tell the user what the current weather is in any city of the world, but you can implement your chatbot to handle a use case with another API.

      Prerequisites

      Before you begin, you will need the following:

      This tutorial assumes you are already familiar with Python—if you would like to improve your knowledge of Python, check out our How To Code in Python 3 series. This tutorial does not require foreknowledge of natural language processing.

      Step 1 — Setting Up Your Environment

      In this step, you will install the spaCy library that will help your chatbot understand the user’s sentences.

      Having set up Python following the Prerequisites, you’ll have a virtual environment. Let’s activate that environment.

      Make sure you are in the directory where you set up your environment and then run the following command:

      • source my_env/bin/activate

      Now install spaCy:

      Finally, you will download a language model. spaCy’s language models are pre-trained NLP models that you can use to process statements to extract meaning. You’ll be working with the English language model, so you’ll download that.

      Run the following command:

      • python -m spacy download en_core_web_md

      If you run into an error like the following:

      Output

      ERROR: Failed building wheel for en-core-web-md

      You need to install wheel:

      Then download the English-language model again.

      To confirm that you have spaCy installed properly, open the Python interpreter:

      Next, import spaCy and load the English-language model:

      >>> import spacy
      >>> nlp = spacy.load("en_core_web_md")
      

      If those two statements execute without any errors, then you have spaCy installed.

      Now close the Python interpreter:

      >>> exit()
      

      You now have everything needed to begin working on the chatbot. In the next section, you’ll create a script to query the OpenWeather API for the current weather in a city.

      Step 2 — Creating the City Weather Program

      In this section, you will create a script that accepts a city name from the user, queries the OpenWeather API for the current weather in that city, and displays the response.

      First, create and open a Python file called weather_bot.py with your preferred editor:

      Next, you’ll create a function to get the current weather in a city from the OpenWeather API. This function will take the city name as a parameter and return the weather description of the city.

      Add the following code into your weather_bot.py file:

      weather_bot.py

      import requests
      
      api_key = "your_api_key"
      
      def get_weather(city_name):
          api_url = "http://api.openweathermap.org/data/2.5/weather?q={}&appid={}".format(city_name, api_key)
      
          response = requests.get(api_url)
          response_dict = response.json()
      
          weather = response_dict["weather"][0]["description"]
      
          if response.status_code == 200:
              return weather
          else:
              print('[!] HTTP {0} calling [{1}]'.format(response.status_code, api_url))
              return None
      

      First, you import the requests library, so you are able to work with and make HTTP requests. Make sure to replace your_api_key with your own API key. The next line begins the definition of the function get_weather() to retrieve the weather of the specified city.

      In this function, you construct the URL for the OpenWeather API. This URL returns the weather information (temperature, weather description, humidity, and so on) of the city and provides the result in JSON format. After that, you make a GET request to the API endpoint, store the result in a response variable, and then convert the response to a Python dictionary for easier access.

      On the next line, you extract just the weather description into a weather variable and then ensure that the status code of the API response is 200 (meaning there were no issues with the request). Finally, you return the weather description.

      If there is an issue with the request, the status code is printed out to the console, and you return None.

      To test the script, call the get_weather() function with a city of your choice (for example, London) and print the result. Add the highlighted code following your function:

      ~/weather_bot.py

      import requests
      
      def get_weather(city_name):
      
        ...
      
        return weather
      
      weather = get_weather("London")
      print(weather)
      

      Save and run the script:

      You will receive a result like the following:

      Output

      scattered clouds

      Having completed that successfully, you can now delete the last two lines from the script.

      Open it with:

      Then delete the two highlighted lines at the end of the file:

      ~/weather_bot.py

      import requests
      
      def get_weather(city_name):
      
        ...
      
        return weather
      
      weather = get_weather("London")
      print(weather)
      

      Save and close the file.

      You now have a function that returns the weather description for a particular city.

      In the next step, you’ll create a chatbot capable of figuring out whether the user wants to get the current weather in a city, and if so, the chatbot will use the get_weather() function to respond appropriately.

      Step 3 — Creating the Chatbot

      In the previous two steps, you installed spaCy and created a function for getting the weather in a specific city. Now, you will create a chatbot to interact with a user in natural language using the weather_bot.py script.

      You’ll write a chatbot() function that compares the user’s statement with a statement that represents checking the weather in a city. To make this comparison, you will use the spaCy similarity() method. This method computes the semantic similarity of two statements, that is, how similar they are in meaning. This will help you determine if the user is trying to check the weather or not.

      To begin, open the script:

      Then, import spaCy and load the English language model:

      ~/weather_bot.py

      import spacy
      import requests
      
      nlp = spacy.load("en_core_web_md")
      
      . . .
      
      

      After the get_weather() function in your file, create a chatbot() function representing the chatbot that will accept a user’s statement and return a response.

      Following your definition, add the highlighted code to create tokens for the two statements you’ll be comparing. Tokens are the different meaningful segments of a statement, like words and punctuation. This is necessary to allow spaCy to compute the semantic similarity:

      ~/weather_bot.py

      import spacy
      
      . . .
      
      def chatbot(statement):
        weather = nlp("Current weather in a city")
        statement = nlp(statement)
      

      Here the weather and statement variables contain spaCy tokens as a result of passing each corresponding string to the nlp() function.

      Save and close your file.

      Next you’ll be introducing the spaCy similarity() method to your chatbot() function. The similarity() method computes the semantic similarity of two statements as a value between 0 and 1, where a higher number means a greater similarity. You need to specify a minimum value that the similarity must have in order to be confident the user wants to check the weather.

      For example, if you check the similarity of statements 2 and 3 with statement 1 following, you get:

      1. Current weather in a city
      2. What is the weather in London? (similarity = 0.86)
      3. Peanut butter and jelly (similarity = 0.31)

      To try this for yourself, open the Python interpreter:

      Next, import spaCy and load the English-language model:

      >>> import spacy
      >>> nlp = spacy.load("en_core_web_md")
      

      Now let’s create tokens from statements 1 and 2:

      >>> statement1 = nlp("Current weather in a city")
      >>> statement2 = nlp("What is the weather in London?")
      

      Finally, let’s obtain the semantic similarity of the two statements:

      >>> print(statement1.similarity(statement2))
      

      You will receive a result like this:

      Output

      0.8557684354027663

      Setting a low minimum value (for example, 0.1) will cause the chatbot to misinterpret the user by taking statements (like statement 3) as similar to statement 1, which is incorrect. Setting a minimum value that’s too high (like 0.9) will exclude some statements that are actually similar to statement 1, such as statement 2.

      We will arbitrarily choose 0.75 for the sake of this tutorial, but you may want to test different values when working on your project.

      Let’s add this value to the script. First, open the file:

      Then add the following highlighted code to introduce the minimum value:

      ~/weather_bot.py

      import spacy
      
      . . .
      
      def chatbot(statement):
        weather = nlp("Current weather in a city")
        statement = nlp(statement)
        min_similarity = 0.75
      

      Now check if the similarity of the user’s statement to the statement about the weather is greater than or equal to the minimum similarity value you specified. Add the following highlighted if statement to check this:

      ~/weather_bot.py

      import spacy
      
      . . .
      
      def chatbot(statement):
        weather = nlp("Current weather in a city")
        statement = nlp(statement)
        min_similarity = 0.75
      
        if weather.similarity(statement) >= min_similarity:
          pass
      

      The final step is to extract the city from the user’s statement so you can pass it to the get_weather() function to retrieve the weather from the API call. Add the following highlighted for loop to implement this:

      ~/weather_bot.py

      import spacy
      
      ...
      
      def chatbot(statement):
        weather = nlp("Current weather in a city")
        statement = nlp(statement)
        min_similarity = 0.75
      
        if weather.similarity(statement) >= min_similarity:
          for ent in statement.ents:
            if ent.label_ == "GPE": # GeoPolitical Entity
              city = ent.text
              break
      

      To do this, you’re using spaCy’s named entity recognition feature. A named entity is a real-world noun that has a name, like a person, or in our case, a city. You want to extract the name of the city from the user’s statement.

      To extract the city name, you get all the named entities in the user’s statement and check which of them is a geopolitical entity (country, state, city). To do this, you loop through all the entities spaCy has extracted from the statement in the ents property, then check whether the entity label (or class) is “GPE” representing Geo-Political Entity. If it is, then you save the name of the entity (its text) in a variable called city.

      You also need to catch cases where no city was entered by adding an else block:

      ~/weather_bot.py

      import spacy
      
      ...
      
      def chatbot(statement):
        weather = nlp("Current weather in a city")
        statement = nlp(statement)
        min_similarity = 0.75
      
        if weather.similarity(statement) >= min_similarity:
          for ent in statement.ents:
            if ent.label_ == "GPE": # GeoPolitical Entity
              city = ent.text
              break
            else:
              return "You need to tell me a city to check."
      

      Now that you have the city, you can call the get_weather() function:

      ~/weather_bot.py

      import spacy
      
      ...
      
      def chatbot(statement):
        weather = nlp("Current weather in a city")
        statement = nlp(statement)
        min_similarity = 0.75
      
        if weather.similarity(statement) >= min_similarity:
          for ent in statement.ents:
            if ent.label_ == "GPE": # GeoPolitical Entity
              city = ent.text
              break
            else:
              return "You need to tell me a city to check."
      
          city_weather = get_weather(city)
          if city_weather is not None:
            return "In " + city + ", the current weather is: " + city_weather
          else:
            return "Something went wrong."
        else:
          return "Sorry I don't understand that. Please rephrase your statement."
      

      Recall that if an error is returned by the OpenWeather API, you print the error code to the terminal, and the get_weather() function returns None. In this code, you first check whether the get_weather() function returns None. If it doesn’t, then you return the weather of the city, but if it does, then you return a string saying something went wrong. The final else block is to handle the case where the user’s statement’s similarity value does not reach the threshold value. In such a case, you ask the user to rephrase their statement.

      Having completed all of that, you now have a chatbot capable of telling a user conversationally what the weather is in a city. The difference between this bot and rule-based chatbots is that the user does not have to enter the same statement every time. Instead, they can phrase their request in different ways and even make typos, but the chatbot would still be able to understand them due to spaCy’s NLP features.

      Let’s test the bot. Call the chatbot() function and pass in a statement asking what the weather is in a city, for example:

      ~/weather_bot.py

      import spacy
      
      . . .
      
      def chatbot(statement):
      
      . . .
      
      response = chatbot("Is it going to rain in Rome today?")
      print(response)
      

      Save and close the file, then run the script in your terminal:

      You will receive output similar to the following:

      Output

      In Rome, the current weather is: clear sky

      You have successfully created an intelligent chatbot capable of responding to dynamic user requests. You can try out more examples to discover the full capabilities of the bot. To do this, you can get other API endpoints from OpenWeather and other sources. Another way to extend the chatbot is to make it capable of responding to more user requests. For this, you could compare the user’s statement with more than one option and find which has the highest semantic similarity.

      Conclusion

      You have created a chatbot that is intelligent enough to respond to a user’s statement—even when the user phrases their statement in different ways. The chatbot uses the OpenWeather API to get the current weather in a city specified by the user.

      To further improve the chatbot, you can:



      Source link

      Konvertieren von Datentypen in Python 3


      Einführung

      In Python werden Datentypen verwendet, um einen bestimmten Datentyp zu klassifizieren. Dabei werden die Werte, die Sie dem Typ zuweisen können, sowie die Operationen bestimmt, die Sie darauf ausführen können. Bei der Programmierung kann es vorkommen, dass wir Werte zwischen Typen konvertieren müssen, um Werte auf andere Weise bearbeiten zu können. Beispielsweise kann es sein, dass wir numerische Werte mit Zeichenfolgen verketten oder Dezimalstellen in Zahlen darstellen müssen, die als Ganzzahlwerte initialisiert wurden.

      In diesem Tutorial erfahren Sie mehr über die Konvertierung von Zahlen, Zeichenfolgen, Tupeln und Listen und lernen zudem Beispiele kennen, um sich mit verschiedenen Anwendungsfällen vertraut zu machen.

      Konvertieren von Zahlentypen

      In Python gibt es zwei Datentypen, die Zahlen darstellen: Ganzzahlen und Gleitkommazahlen. Manchmal arbeiten Sie an dem Code von jemand anderem und müssen eine ganze Ganzzahl in eine Gleitkommazahl konvertieren oder umgekehrt; in anderen Fällen stellen Sie möglicherweise fest, dass Sie eine Ganzzahl verwendet haben, obwohl Sie eigentlich eine Gleitkommazahl benötigen. Python verfügt über integrierte Methoden, um Ganzzahlen auf einfache Weise in Gleitkommazahlen und Gleitkommazahlen in Ganzzahlen zu konvertieren.

      Konvertieren von Ganzzahlen in Gleitkommazahlen

      Die Python-Methode float() konvertiert Ganzzahlen in Gleitkommazahlen. Um diese Funktion zu verwenden, fügen Sie innerhalb der Klammern eine Ganzzahl hinzu:

      float(57)
      

      In diesem Fall wird 57 in 57,0 konvertiert.

      Sie können dies auch mit einer Variable tun. Lassen Sie uns f als gleich 57 deklarieren und dann die neue Gleitkommazahl ausdrucken:

      f = 57
      print(float(f))
      

      Output

      57.0

      Durch Verwendung der Funktion float() können wir Ganzzahlen in Gleitkommazahlen konvertieren.

      Konvertieren von Gleitkommazahlen in Ganzzahlen

      Außerdem verfügt Python über eine integrierte Funktion, um Gleitkommazahlen in Ganzzahlen zu konvertieren: int().

      Die Funktion int() funktioniert ähnlich wie die Funktion float(): Sie können innerhalb der Klammern eine Gleitkommazahl hinzufügen, um sie in eine Ganzzahl zu konvertieren:

      int(390.8)
      

      In diesem Fall wird 390,8 in 390 konvertiert.

      Sie können dies auch mit Variablen tun. Lassen Sie uns b als gleich 125,0 und c als gleich 390,8 deklarieren und dann die neuen Gleitkommazahlen ausdrucken:

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

      Output

      125 390

      Bei der Konvertierung von Gleitkommazahlen in Ganzzahlen mit der Funktion int() schneidet Python die Dezimalstelle und die verbleibenden Ziffern einer Gleitkommazahl ab, um eine Ganzzahl zu erzeugen. Auch wenn wir möglicherweise 390,8 auf 391 aufrunden möchten, wird Python dies mit der Funktion int() nicht tun.

      Konvertieren von Zahlen durch Division

      In Python 3 werden relevante Quotienten beim Teilen von Ganzzahlen in Gleitkommazahlen konvertiert, auch wenn sie sich nicht in Python 2 befinden. Wenn Sie 5 durch 2 teilen, erhalten Sie in Python 3 also eine Gleitkommazahl als Antwort (2,5):

      a = 5 / 2
      print(a)
      

      Output

      2.5

      In Python 2 würden Sie, da Sie mit zwei Ganzzahlen gearbeitet haben, stattdessen eine Ganzzahl als Antwort zurückerhalten: 5 / 2 = 2. Lesen Sie Python 2 vs. Python 3: Praktische Erwägungen, um mehr über die Unterschiede zwischen Python 2 und Python 3 zu erfahren.

      Konvertieren mit Zeichenfolgen

      Eine Zeichenfolge ist eine Folge von einem oder mehreren Zeichen (Buchstaben, Zahlen, Symbolen). Zeichenfolgen sind eine häufige Form von Daten in Computerprogrammen, und wir müssen relativ häufig Zeichenfolgen in Zahlen oder Zahlen in Zeichenfolgen konvertieren, insbesondere wenn wir benutzergenerierte aufnehmen.

      Konvertieren von Zahlen in Zeichenfolgen

      Wir können Zahlen in Zeichenfolgen konvertieren, indem wir die Methode str() verwenden. Wir übergeben entweder eine Zahl oder eine Variable in die Klammern der Methode dann wird der numerische Wert in einen Zeichenfolgewert konvertiert.

      Schauen wir uns zuerst die Konvertierung von Ganzzahlen an. Um die Ganzzahl 12 in einen Zeichenfolgewert zu konvertieren, können Sie 12 in die Methode str() übergeben:

      str(12)
      

      Wenn Sie str(12) in der interaktiven Python-Shell mit dem Befehl python in einem Terminalfenster ausführen, erhalten Sie die folgende Ausgabe:

      Output

      '12'

      Die Anführungszeichen um die Zahl 12 bedeuten, dass die Zahl keine Ganzzahl mehr, sondern nun ein Zeichenfolgewert ist.

      Mit Variablen können wir beginnen, zu sehen, wie praktisch es sein kann, Ganzzahlen in Zeichenfolgen zu konvertieren. Nehmen wir an, wir wollen den täglichen Programmierfortschritt eines Benutzers verfolgen und geben ein, wie viele Codezeilen er/sie jeweils schreibt. Wir möchten dem Benutzer dieses Feedback zeigen und gleichzeitig Zeichenfolge- und Ganzzahlwerte ausgeben:

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

      Wenn wir diesen Code ausführen, erhalten wir den folgenden Fehler:

      Output

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

      Wir können Zeichenfolgen und Ganzzahlen in Python nicht verketten, daher müssen wir die variablen lines in einen Zeichenfolgewert konvertieren:

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

      Wenn wir nun den Code ausführen, erhalten wir die folgende Ausgabe, die unserem Benutzer zu seinem/ihrem Fortschritt gratuliert:

      Output

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

      Wenn wir nicht eine Ganzzahl in eine Zeichenfolge, sondern eine Gleitkommazahl in eine Zeichenfolge konvertieren möchten, folgen wir den gleichen Schritten und dem gleichen Format. Wenn wir eine Gleitkommazahl in die Methode str() übergeben, wird ein Wert der Gleitkommazahl zurückgegeben. Wir können entweder den Gleitkommazahlwert selbst oder eine Variable verwenden:

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

      Output

      421.034 5524.53

      Wir können die Richtigkeit testen, indem wir eine Zeichenfolge verketten:

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

      Output

      Sammy has 5524.53 points.

      Wir können sicher sein, dass unsere Gleitkommazahl korrekt in eine Zeichenfolge konvertiert wurde, da die Verkettung fehlerfrei durchgeführt wurde.

      Konvertieren von Zeichenfolgen in Zahlen

      Zeichenfolgen können durch Verwendung der Methoden int() und float() in Zahlen konvertiert werden.

      Wenn Ihre Zeichenfolge keine Nachkommastellen aufweist, werden Sie sie höchstwahrscheinlich in eine Ganzzahl konvertieren wollen, indem Sie die Methode int() verwenden.

      Nehmen wir das Beispiel des Benutzers Sammy, der jeden Tag die geschriebenen Codezeilen verfolgt. Wir möchten diese Werte vielleicht mit Mathematik manipulieren, um dem Benutzer ein interessantes Feedback zu bieten, aber diese Werte werden derzeit in Zeichenfolgen gespeichert:

      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'

      Da die beiden numerischen Werte in Zeichenfolgen gespeichert wurden, haben wir einen Fehler erhalten. Der Operand - für Subtraktion ist kein gültiger Operand für zwei Zeichenfolgewerte.

      Ändern wir den Code so, dass er die Methode int() enthält, die die Zeichenfolgen in Ganzzahlen konvertiert und uns erlaubt, mit diesen Werten, die ursprünglich Zeichenfolgen waren, zu rechnen.

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

      Output

      58

      Die Variable lines_more ist automatisch eine Ganzzahl und entspricht in diesem Beispiel dem numerischen Wert 58.

      Wir können die Zahlen in dem obigen Beispiel auch in Gleitkommazahlen konvertieren, indem wir die Methode float() anstelle der Methode int() verwenden. Statt der Ausgabe von 58 erhalten wir dann die Ausgabe von 58,0, einer Gleitkommazahl.

      Der Benutzer Sammy sammelt Punkte in Nachkommawerten.

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

      Output

      5524.5345.30

      In diesem Fall ist die Verwendung des Operanden + mit zwei Zeichenfolgen eine gültige Operation, aber es werden zwei Zeichenfolgen verkettet und nicht zwei numerische Werte addiert. Unsere Ausgabe sieht also ungewöhnlich aus, da die beiden Werte einfach nebeneinander platziert.

      Wir werden diese Zeichenfolgen in Gleitkommazahlen konvertieren wollen, bevor wir mit der Methode float() rechnen:

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

      Output

      5569.83

      Nachdem wir nun die beiden Zeichenfolgen in Gleitkommazahlen konvertiert haben, erhalten wir das erwartete Ergebnis, das 45,30 zu 5524,53 hinzufügt.

      Wenn wir versuchen, einen Zeichenfolgewert mit Nachkommastellen in eine Ganzzahl zu konvertieren, erhalten wir einen Fehler:

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

      Output

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

      Wenn wir einen Nachkommawert in einer Zeichenfolge an die Methode int() übergeben, erhalten wir einen Fehler, da er nicht in eine Ganzzahl konvertiert wird.

      Das Konvertieren von Zeichenfolgen in Zahlen ermöglicht uns, den Datentyp, mit dem wir arbeiten, schnell zu ändern, sodass wir Operationen mit numerischen Werten durchführen können, die ursprünglich Zeichenfolgen waren.

      Konvertieren in Tupel und Listen

      Sie können die Methoden list() und tuple() verwenden, um die an sie übergebenen Werte in den Datentyp „Liste“ bzw. „Tupel“ zu konvertieren. In Python:

      • ist eine Liste eine veränderbare geordnete Reihenfolge von Elementen, die in eckigen Klammern [ ] enthalten ist.
      • ist ein Tupel eine nicht veränderbare geordnete Reihenfolge von Elementen, die in Klammern () enthalten ist.

      Konvertieren in Tupel

      Beginnen wir mit der Konvertierung einer Liste in ein Tupel. Die Konvertierung einer List in ein Tupel kann, da es sich um einen unveränderlichen Datentyp handelt, eine erhebliche Optimierung der von uns erstellten Programme ermöglichen. Wenn wir die Methode tuple() verwenden, gibt sie die Tupel-Version des übergebenen Wertes zurück.

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

      Output

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

      Wir sehen, dass in der Ausgabe ein Tupel ausgegeben wird, da die Elemente nun in Klammern und nicht eckigen Klammern enthalten sind.

      Verwenden wir tuple() mit einer Variable, die eine Liste darstellt:

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

      Output

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

      Auch hier sehen wir, dass der Listenwert in einen Tupelwert umgewandelt wird, angezeigt durch die Klammern. Wir können jeden iterierbaren Typ in ein Tupel konvertieren, einschließlich Zeichenfolgen:

      print(tuple('Sammy'))
      

      Output

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

      Da wir durch Zeichenfolgen iterieren können, können wir sie mit der Methode tuple() in Tupel konvertieren. Bei nicht iterierbaren Datentypen, wie Ganzzahlen und Gleitkommazahlen, erhalten wir jedoch einen Typfehler:

      print(tuple(5000))
      

      Output

      TypeError: 'int' object is not iterable

      Zwar ist es möglich, die Ganzzahl in eine Zeichenfolge zu konvertieren und dann in ein Tupel zu konvertieren, wie in tuple(str(5000)), aber es ist besser, sich für lesbaren Code zu entscheiden anstatt für komplizierte Konvertierungen.

      Konvertieren in Listen

      Die Konvertierung von Werten, insbesondere Tupel, in Listen kann nützlich sein, wenn Sie eine veränderbare Version dieses Wertes haben müssen.

      Wir werden die Methode list() verwenden, um das folgende Tupel in eine Liste zu konvertieren. Da die Syntax zur Erstellung einer Liste Klammern verwendet, stellen Sie sicher, dass Sie die Klammern der Methode list() und in diesem Fall die Methode print() einbeziehen:

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

      Output

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

      Die eckigen Klammern signalisieren, dass aus dem ursprünglichen Tupelwert, der über die Methode list() übergeben wurde, eine Liste zurückgegeben wurde.

      Um den Code lesbarer zu machen, können wir eines der Klammerpaare entfernen, indem wir eine Variable verwenden:

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

      Wenn wir list(coral) ausgeben, würden wir die gleiche Ausgabe wie oben erhalten.

      Genau wie Tupel können auch Zeichenfolgen in Listen konvertiert werden:

      print(list('shark'))
      

      Output

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

      Hier wurde die Zeichenfolge shark’ in eine Liste konvertiert, wodurch eine veränderbare Version des ursprünglichen Wertes hergestellt wird.

      Zusammenfassung

      In diesem Python-Tutorial wurde gezeigt, wie einige der wichtigen nativen Datentypen in andere Datentypen konvertiert werden, vor allem durch integrierte Methoden. Die Möglichkeit, Datentypen in Python zu konvertieren bietet Ihnen zusätzliche Flexibilität beim Schreiben Ihrer Programme.



      Source link

      What is Python?


      Python is a flexible programming language that prioritizes the clarity and readability of code. A good choice for many software development use cases, Python is often used for scripting, automation, data analysis, machine learning, and back-end development. Popular libraries and frameworks include Django, Flask, NumPy, and scikit-learn.

      Python was first published in 1991. Its name was inspired by the British comedy group Monty Python due to the development team’s mission to create a language that was fun to use. Python 3 is the most current version of the language and is considered to be the future of Python.

      If you’re interested in learning Python, it is a great choice for both beginner and experienced developers. Below, find a number of resources to help you get started:

      For more resources, check out our complete list of educational materials under the Python tag.



      Source link