One place for hosting & domains

      Verwenden des SMTP-Servers von Google


      Der Autor hat den COVID-19 Relief Fund dazu ausgewählt, eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Eine wenig bekannte Funktion von Gmail und Google Apps E-Mail ist der portable SMTP-Server von Google. Anstatt Ihren eigenen Postausgangsserver auf Ihrem DigitalOcean-Droplet oder Kubernetes-Cluster verwalten zu müssen, können Sie die SMTP-Servereinstellungen von Google mit einem beliebigen Skript oder Programm konfigurieren, das Sie zum Versenden von E-Mails verwenden möchten. Sie benötigen lediglich entweder (i) ein kostenloses Gmail-Konto oder (ii) ein kostenpflichtiges G Suite-Konto.

      Vorteile

      Sie haben die Möglichkeit, die von Ihnen über den SMTP-Server gesendeten E-Mails von Google speichern und indizieren zu lassen, sodass alle Ihre gesendeten E-Mails auf den Servern von Google durchsuchbar und gesichert sind. Wenn Sie sich entscheiden, Ihr Gmail- oder G Suite-Konto auch für Ihre eingehenden E-Mails zu verwenden, haben Sie alle Ihre E-Mails an einem praktischen Ort. Da der SMTP-Server von Google nicht den Port 25 verwendet, verringern Sie außerdem die Wahrscheinlichkeit, dass ein ISP Ihre E-Mails blockiert oder als Spam kennzeichnet.

      Einstellungen

      Der SMTP-Server von Google erfordert Authentifizierung. Hier erfahren Sie, wie Sie diese in Ihrem Mail-Client oder Ihrer Anwendung einrichten:

      Anmerkung: Bevor Sie beginnen, sollten Sie laut Google die Sicherheitseinstufung Ihres Mail-Clients oder Ihrer Anwendung überprüfen. Wenn Sie ein Programm verwenden, das von Google als nicht sicher eingestuft wird, wird Ihre Nutzung blockiert, es sei denn, Sie aktivieren weniger sichere Anwendungen (eine Sicherheitseinstellung, die von Google nicht empfohlen wird) oder erstellen ein anwendungsspezifisches App-Passwort. Weitere Sicherheitsinformationen finden Sie unter diesem Link zur Ermittlung der besten Vorgehensweise für Ihren Mail-Client oder Ihre Anwendung.

      1. SMTP-Server (d. h., Postausgangsserver): smtp.gmail.com
      2. SMTP-Benutzername: Ihre vollständige Gmail- oder G Suite-E-Mail-Adresse (z. B. example@gmail.com oder example@your_domain)
      3. SMTP-Passwort: Ihr Gmail- oder G Suite-E-Mail-Passwort
      4. SMTP-Port: 465
      5. SMTP TLS/SSL erforderlich: Ja

      Damit Google Ihre gesendeten E-Mails automatisch in den Ordner „Gesendet“ kopiert, müssen Sie außerdem überprüfen, ob der IMAP-Zugriff für Ihr Konto aktiviert ist.

      Gehen Sie dazu in die Gmail-Einstellungen und klicken Sie auf die Registerkarte Weiterleitung und POP/IMAP. Scrollen Sie nach unten zu dem Abschnitt IMAP-Zugriff und stellen Sie sicher, dass der IMAP-Zugriff für Ihr Konto aktiviert ist.

      Anmerkung: Google schreibt die Absenderzeile jeder E-Mail, die Sie über seinen SMTP-Server senden, automatisch in die mit dem Konto verknüpfte Standard-E-Mail-Adresse um, wenn die verwendete Adresse nicht in der Adressenliste E-Mail senden als in den Einstellungen von Gmail oder G Suite enthalten ist. Sie können die Liste überprüfen, indem Sie auf dem Einstellungsbildschirm auf die Registerkarte Konten und Import gehen.

      Sie müssen sich dieser Nuance bewusst sein, da sie sich auf die Darstellung Ihrer E-Mail aus der Sicht des Empfängers auswirkt und auch die Einstellung Antworten an einiger Programme beeinflussen kann.

      Sendebeschränkungen

      Google begrenzt die Menge der E-Mails, die ein Benutzer über den portablen SMTP-Server senden kann. Diese Begrenzung beschränkt die Anzahl der täglich gesendeten Nachrichten auf 99 E-Mails; die Beschränkung wird automatisch 24 Stunden nach Erreichen der Beschränkung aufgehoben.

      Zusammenfassung

      Sie haben nun die Möglichkeit, den SMTP-Server von Google zu verwenden. Wenn diese vereinfachte Option nicht ausreicht, können Sie die Installation und Konfiguration von Postfix als reinen Sende-SMTP-Server in Betracht ziehen.



      Source link

      SOLID: Die ersten 5 Prinzipien des objektorientierten Designs


      Einführung

      SOLID ist ein Akronym für die ersten fünf Prinzipien des objektorientierten Designs (OOD) von Robert C. Martin (auch bekannt als Onkel Bob).

      Anmerkung: Obwohl diese Prinzipien auf verschiedene Programmiersprachen angewendet werden können, wird der in diesem Artikel enthaltene Beispielcode PHP verwendet.

      Diese Prinzipien legen Praktiken fest, die sich für die Entwicklung von Software mit Überlegungen zur Aufrechterhaltung und Erweiterung eignen, wenn das Projekt wächst. Die Übernahme dieser Praktiken kann auch zur Vermeidung von Code Smells, Refactoring von Code und agiler oder adaptiver Softwareentwicklung beitragen.

      SOLID steht für:

      In diesem Artikel werden Sie jedes Prinzip einzeln kennenlernen, um zu verstehen, wie SOLID Ihnen dabei helfen kann, ein besserer Entwickler zu werden.

      Single-Responsibility-Prinzip

      Das Single-Responsibility-Prinzip (SRP) besagt:

      Eine Klasse sollte einen und nur einen Grund haben, sich zu ändern, d. h. eine Klasse sollte nur eine Aufgabe haben.

      Betrachten Sie beispielsweise eine Anwendung, die eine Sammlung von Formen – Kreise und Quadrate – nimmt und die Summe der Fläche aller Formen in der Sammlung berechnet.

      Erstellen Sie zunächst die Formklassen und lassen Sie die Konstruktoren die erforderlichen Parameter einrichten.

      Für Quadrate müssen Sie die length einer Seite kennen:

      class Square
      {
          public $length;
      
          public function construct($length)
          {
              $this->length = $length;
          }
      }
      

      Für Kreise müssen Sie den radius kennen:

      class Circle
      {
          public $radius;
      
          public function construct($radius)
          {
              $this->radius = $radius;
          }
      }
      

      Erstellen Sie anschließend die Klasse AreaCalculator und schreiben Sie dann die Logik, um die Fläche aller bereitgestellten Formen zu summieren. Der Flächeninhalt eines Quadrats wird durch die Länge zum Quadrat berechnet. Der Flächeninhalt eines Kreises wird durch Pi mal Radius zum Quadrat berechnet.

      class AreaCalculator
      {
          protected $shapes;
      
          public function __construct($shapes = [])
          {
              $this->shapes = $shapes;
          }
      
          public function sum()
          {
              foreach ($this->shapes as $shape) {
                  if (is_a($shape, 'Square')) {
                      $area[] = pow($shape->length, 2);
                  } elseif (is_a($shape, 'Circle')) {
                      $area[] = pi() * pow($shape->radius, 2);
                  }
              }
      
              return array_sum($area);
          }
      
          public function output()
          {
              return implode('', [
                '',
                    'Sum of the areas of provided shapes: ',
                    $this->sum(),
                '',
            ]);
          }
      }
      

      Um die Klasse AreaCalculator zu verwenden, müssen Sie die Klasse instanziieren und ein Array von Formen übergeben und die Ausgabe am Ende der Seite anzeigen.

      Hier ist ein Beispiel mit einer Sammlung von drei Formen:

      • Ein Kreis mit einem Radius von 2
      • Ein Quadrat mit einer Länge von 5
      • Ein zweites Quadrat mit einer Länge von 6
      $shapes = [
        new Circle(2),
        new Square(5),
        new Square(6),
      ];
      
      $areas = new AreaCalculator($shapes);
      
      echo $areas->output();
      

      Das Problem mit der Ausgabemethode ist, dass der AreaCalculator die Logik zur Ausgabe der Daten bearbeitet.

      Bedenken Sie ein Szenario, in dem die Ausgabe in ein anderes Format wie JSON konvertiert werden soll.

      Die gesamte Logik würde von der Klasse AreaCalculator bearbeitet werden. Dies würde gegen das Single-Responsibility-Prinzip verstoßen. Die Klasse AreaCalculator sollte nur mit der Summe der Flächen der bereitgestellten Formen befasst sein. Sie sollte sich nicht damit befassen, ob der Benutzer JSON oder HTML wünscht.

      Um dies zu beheben, können Sie eine separate Klasse SumCalculatorOutputter erstellen und diese neue Klasse verwenden, um die Logik zu bearbeiten, die Sie für die Ausgabe der Daten an den Benutzer benötigen:

      class SumCalculatorOutputter
      {
          protected $calculator;
      
          public function __constructor(AreaCalculator $calculator)
          {
              $this->calculator = $calculator;
          }
      
          public function JSON()
          {
              $data = [
                'sum' => $this->calculator->sum(),
            ];
      
              return json_encode($data);
          }
      
          public function HTML()
          {
              return implode('', [
                '',
                    'Sum of the areas of provided shapes: ',
                    $this->calculator->sum(),
                '',
            ]);
          }
      }
      

      Die Klasse SumCalculatorOutputter würde wie folgt funktionieren:

      $shapes = [
        new Circle(2),
        new Square(5),
        new Square(6),
      ];
      
      $areas = new AreaCalculator($shapes);
      $output = new SumCalculatorOutputter($areas);
      
      echo $output->JSON();
      echo $output->HTML();
      

      Jetzt wird die Logik, die Sie zur Ausgabe der Daten an den Benutzer benötigen, von der Klasse SumCalculatorOutputter bearbeitet.

      Das erfüllt das Single-Responsibility-Prinzip.

      Open-Closed-Prinzip

      Das Open-Closed-Prinzip (S.R.P.) besagt:

      Objekte oder Entitäten sollten offen für Erweiterungen, aber geschlossen für Änderungen sein.

      Das bedeutet, dass eine Klasse erweiterbar sein sollte, ohne die Klasse selbst zu modifizieren.

      Gehen wir noch einmal auf die Klasse AreaCalculator ein und konzentrieren uns auf die Methode sum:

      class AreaCalculator
      {
          protected $shapes;
      
          public function __construct($shapes = [])
          {
              $this->shapes = $shapes;
          }
      
          public function sum()
          {
              foreach ($this->shapes as $shape) {
                  if (is_a($shape, 'Square')) {
                      $area[] = pow($shape->length, 2);
                  } elseif (is_a($shape, 'Circle')) {
                      $area[] = pi() * pow($shape->radius, 2);
                  }
              }
      
              return array_sum($area);
          }
      }
      

      Bedenken Sie ein Szenario, in dem der Benutzer die Summe sum zusätzlicher Formen wie Dreiecke, Fünfecke, Sechsecke usw. wünscht. Sie müssten diese Datei ständig bearbeiten und weitere if/else-Blöcke hinzufügen. Das würde das Open-Closed-Prinzip verletzen.

      Eine Möglichkeit, diese Methode sum zu verbessern, besteht darin, die Logik zur Berechnung der Fläche jeder Form aus der Klassenmethode AreaCalculator zu entfernen und sie an die Klasse jeder Form anzuhängen.

      Hier ist die in Square definierte Methode area:

      class Square
      {
          public $length;
      
          public function __construct($length)
          {
              $this->length = $length;
          }
      
          public function area()
          {
              return pow($this->length, 2);
          }
      }
      

      Und hier ist die in Circle definierte Methode area:

      class Circle
      {
          public $radius;
      
          public function construct($radius)
          {
              $this->radius = $radius;
          }
      
          public function area()
          {
              return pi() * pow($shape->radius, 2);
          }
      }
      

      Die Methode sum für AreaCalculator kann dann umgeschrieben werden als:

      class AreaCalculator
      {
          // ...
      
          public function sum()
          {
              foreach ($this->shapes as $shape) {
                  $area[] = $shape->area();
              }
      
              return array_sum($area);
          }
      }
      

      Jetzt können Sie eine andere Formklasse erstellen und diese bei der Berechnung der Summe übergeben, ohne den Code zu verändern.

      Es ergibt sich jedoch ein weiteres Problem. Woher wissen Sie, dass das an den AreaCalculator übergebene Objekt tatsächlich eine Form ist oder ob die Form eine Methode namens area aufweist?

      Die Codierung auf eine Schnittstelle ist ein integraler Bestandteil von SOLID.

      Erstellen Sie ein ShapeInterface, das area unterstützt:

      interface ShapeInterface
      {
          public function area();
      }
      

      Ändern Sie Ihre Formklassen, um das ShapeInterface mit implement zu implementieren.

      Hier ist die Aktualisierung für Square:

      class Square implements ShapeInterface
      {
          // ...
      }
      

      Und hier ist die Aktualisierung für Circle:

      class Circle implements ShapeInterface
      {
          // ...
      }
      

      In der Methode sum für AreaCalculator können Sie überprüfen, ob die bereitgestellten Formen tatsächlich Instanzen des ShapeInterface sind; andernfalls verwenden Sie „throw“ für eine Ausnahme:

       class AreaCalculator
      {
          // ...
      
          public function sum()
          {
              foreach ($this->shapes as $shape) {
                  if (is_a($shape, 'ShapeInterface')) {
                      $area[] = $shape->area();
                      continue;
                  }
      
                  throw new AreaCalculatorInvalidShapeException();
              }
      
              return array_sum($area);
          }
      }
      

      Damit ist das Open-Closed-Prinzip erfüllt.

      Liskovsches Substitutionsprinzip

      Das Liskovsche Substitutionsprinzip besagt:

      Lassen Sie q(x) eine Eigenschaft sein, die für Objekte x von Typ T beweisbar ist. Dann soll q(y) für Objekte y von Typ S beweisbar sein, wobei S ein Untertyp von T ist.

      Das bedeutet, dass jede Unterklasse oder abgeleitete Klasse für ihre Basis- oder übergeordnete Klasse ersetzbar sein sollte.

      Bedenken Sie, aufbauend auf dem Beispiel der Klasse AreaCalculator, eine neue Klasse VolumeCalculator, die die Klasse AreaCalculator erweitert:

      class VolumeCalculator extends AreaCalculator
      {
          public function construct($shapes = [])
          {
              parent::construct($shapes);
          }
      
          public function sum()
          {
              // logic to calculate the volumes and then return an array of output
              return [$summedData];
          }
      }
      

      Erinnern Sie sich daran, dass die Klasse SumCalculatorOutputter dem ähnelt:

      class SumCalculatorOutputter {
          protected $calculator;
      
          public function __constructor(AreaCalculator $calculator) {
              $this->calculator = $calculator;
          }
      
          public function JSON() {
              $data = array(
                  'sum' => $this->calculator->sum();
              );
      
              return json_encode($data);
          }
      
          public function HTML() {
              return implode('', array(
                  '',
                      'Sum of the areas of provided shapes: ',
                      $this->calculator->sum(),
                  ''
              ));
          }
      }
      

      Wenn Sie versuchen würden, ein Beispiel wie dieses auszuführen:

      $areas = new AreaCalculator($shapes);
      $volumes = new VolumeCalculator($solidShapes);
      
      $output = new SumCalculatorOutputter($areas);
      $output2 = new SumCalculatorOutputter($volumes);
      

      Wenn Sie die Methode HTML auf dem Objekt $output2 aufrufen, erhalten Sie einen Fehler E_NOTICE, der Sie über eine Array-zu-String-Konvertierung informiert.

      Um dies zu beheben, geben Sie anstelle der Rückgabe eines Arrays aus der Summenmethode der Klasse VolumeCalculator $summedData zurück:

      class VolumeCalculator extends AreaCalculator
      {
          public function construct($shapes = [])
          {
              parent::construct($shapes);
          }
      
          public function sum()
          {
              // logic to calculate the volumes and then return a value of output
              return $summedData;
          }
      }
      

      Das $summedData können ein Float, Double oder Integer sein.

      Damit ist das Liskovsche Substitutionsprinzip erfüllt.

      Das Interface-Segregation-Prinzip

      Das Interface-Segregation-Prinzip besagt:

      Ein Client sollte nie gezwungen werden, eine Schnittstelle zu implementieren, die er nicht verwendet, oder Clients sollten nicht gezwungen werden, von Methoden abzuhängen, die sie nicht verwenden.

      Weiterhin aufbauend auf dem vorherigen Beispiel ShapeInterface, müssen Sie die neuen dreidimensionalen Formen Cuboid und Spheroid unterstützen, und diese Formen müssen auch das Volumen berechnen.

      Bedenken wir, was passieren würde, wenn Sie das ShapeInterface modifizieren würden, um einen weiteren Vertrag hinzuzufügen:

      interface ShapeInterface
      {
          public function area();
      
          public function volume();
      }
      

      Nun muss jede Form, die Sie erstellen, die Methode volume implementieren, aber Sie wissen, dass Quadrate flache Formen sind und kein Volumen haben, also würde diese Schnittstelle die Klasse Square zwingen, eine Methode zu implementieren, die sie nicht braucht.

      Dies würde das Interface-Segregation-Prinzip verletzen. Stattdessen könnten Sie eine andere Schnittstelle namens ThreeDimensionalShapeInterface erstellen, die den Vertrag volume hat und dreidimensionale Formen können diese Schnittstelle implementieren:

      interface ShapeInterface
      {
          public function area();
      }
      
      interface ThreeDimensionalShapeInterface
      {
          public function volume();
      }
      
      class Cuboid implements ShapeInterface, ThreeDimensionalShapeInterface
      {
          public function area()
          {
              // calculate the surface area of the cuboid
          }
      
          public function volume()
          {
              // calculate the volume of the cuboid
          }
      }
      

      Dies ist ein wesentlich besserer Ansatz, aber ein Fallstrick, auf den Sie achten müssen, wenn Sie diese Schnittstellen mit Typ-Hinweisen versehen. Anstatt ein ShapeInterface oder ein ThreeDimensionalShapeInterface zu verwenden, können Sie eine andere Schnittstelle erstellen, vielleicht ManageShapeInterface, und diese sowohl für die flachen als auch für die dreidimensionalen Formen implementieren.

      Auf diese Weise können Sie eine einzige API für die Verwaltung der Formen haben:

      interface ManageShapeInterface
      {
          public function calculate();
      }
      
      class Square implements ShapeInterface, ManageShapeInterface
      {
          public function area()
          {
              // calculate the area of the square
          }
      
          public function calculate()
          {
              return $this->area();
          }
      }
      
      class Cuboid implements ShapeInterface, ThreeDimensionalShapeInterface, ManageShapeInterface
      {
          public function area()
          {
              // calculate the surface area of the cuboid
          }
      
          public function volume()
          {
              // calculate the volume of the cuboid
          }
      
          public function calculate()
          {
              return $this->area();
          }
      }
      

      In der Klasse AreaCalculator können Sie den Aufruf für die Methode area durch calculate ersetzen und außerdem überprüfen, ob das Objekt eine Instanz des ManageShapeInterface und nicht des ShapeInterface ist.

      Das erfüllt das Interface-Segregation-Prinzip.

      Das Dependency-Inversion-Prinzip

      Das Dependency-Inversion-Prinzip besagt:

      Entitäten müssen von Abstraktionen abhängen, nicht von Konkretionen. Es besagt, dass das Modul auf hoher Ebene nicht vom Modul auf niedriger Ebene abhängen darf, sondern diese von Abstraktionen abhängen sollten.

      Dieses Prinzip ermöglicht die Entkopplung.

      Hier ist ein Beispiel für einen PasswordReminder der sich mit einer MySQL-Datenbank verbindet:

      class MySQLConnection
      {
          public function connect()
          {
              // handle the database connection
              return 'Database connection';
          }
      }
      
      class PasswordReminder
      {
          private $dbConnection;
      
          public function __construct(MySQLConnection $dbConnection)
          {
              $this->dbConnection = $dbConnection;
          }
      }
      

      Zuerst ist die MySQLConnection das Modul auf niedriger Ebene, während der PasswordReminder auf hoher Ebene angesiedelt ist, aber gemäß der Definition von D in SOLID, die besagt, von der Abstraktion abzuhängen und nicht von Konkretionen. Dieses obige Snippet verletzt dieses Prinzip, da die Klasse PasswordReminder gezwungen wird, von der Klasse MySQLConnection abzuhängen.

      Wenn Sie später die Datenbank-Engine ändern würden, müssten Sie auch die Klasse PasswordReminder bearbeiten, und das würde das Open-Close-Prinzip verletzen.

      Die Klasse PasswordReminder sollte sich nicht darum kümmern, welche Datenbank Ihre Anwendung verwendet. Um diese Probleme zu beheben, können Sie an eine Schnittstelle kodieren, da Module auf hoher Ebene und niedriger Ebene von der Abstraktion abhängen sollten:

      interface DBConnectionInterface
      {
          public function connect();
      }
      

      Die Schnittstelle hat eine Verbindungsmethode und die Klasse MySQLConnection implementiert diese Schnittstelle. Anstatt die Klasse MySQLConnection im Konstruktor von PasswordReminder, direkt zu typisieren, geben Sie stattdessen das DBConnectionInterface an, und unabhängig davon, welchen Datenbanktyp Ihre Anwendung verwendet, kann die Klasse PasswordReminder ohne Probleme eine Verbindung zur Datenbank herstellen und das Open-Close-Prinzip wird nicht verletzt.

      class MySQLConnection implements DBConnectionInterface
      {
          public function connect()
          {
              // handle the database connection
              return 'Database connection';
          }
      }
      
      class PasswordReminder
      {
          private $dbConnection;
      
          public function __construct(DBConnectionInterface $dbConnection)
          {
              $this->dbConnection = $dbConnection;
          }
      }
      

      Dieser Code verdeutlicht, dass sowohl die Module auf hoher Ebene als auch auf niedriger Ebene von der Abstraktion abhängen.

      Zusammenfassung

      In diesem Artikel wurden Ihnen die fünf Prinzipien von SOLID Code vorgestellt. Projekte, die sich an die SOLID-Prinzipien halten, können mit weniger Komplikationen mit anderen Mitarbeitern geteilt, erweitert, modifiziert, getestet und refraktorisiert werden.

      Lernen Sie weiter, indem Sie über andere Praktiken für die Agile und Adaptive Softwareentwicklung lesen.



      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