DATENWISSENSCHAFT

Erstellen Sie ein Marimo-Notizbuch mithilfe der NetworkX-Python-Bibliothek und decken Sie die verborgenen Strukturen in Victor Hugos Meisterwerk auf

In diesem Beitrag führe ich Sie durch die Erstellung eines interaktiven Marimo-Notizbuchs für die Analyse sozialer Netzwerke unter Verwendung der NetworkX-Python-Bibliothek und des Les Misérables Datensatz für soziale Netzwerke. Durch die Implementierung von Techniken zur Analyse sozialer Netzwerke können wir Erkenntnisse darüber gewinnen, wie die Verbindungen zwischen den verschiedenen Charakteren des Romans die Geschichte prägen, und Themen wie Gerechtigkeit, Liebe und Opfer aufdecken, die die Erzählung des Romans bestimmen.

Sicherlich, Les Misérables ist eine der großartigsten Geschichten, die jemals erzählt wurden. Ich liebe buchstäblich jede Model und Variation davon – das Buch, die Filme, die Fernsehserie, das Musical – alles.

Geschrieben im Jahr 1862, Les Misérables erforscht die Konzepte von Gerechtigkeit, Erlösung, Liebe und Opfer im gesellschaftlichen und kulturellen Rahmen Frankreichs des 19. Jahrhunderts. Die Erzählung folgt dem Leben verschiedener Charaktere, insbesondere Jean Valjean, einem ehemaligen Sträfling, der Erlösung sucht, und Inspektor Javert, der …

Bild vom Autor | Canva

Als Programmierer verlassen wir uns oft auf verschiedene externe Bibliotheken, um verschiedene Probleme zu lösen. Diese Bibliotheken werden von erfahrenen Entwicklern erstellt und bieten Lösungen, die uns Zeit und Mühe sparen. Aber haben Sie jemals gedacht, „Kann ich auch meine eigenen benutzerdefinierten Bibliotheken erstellen?“ Die Antwort ist ja! Dieser Artikel erläutert die notwendigen Schritte, die Ihnen dabei helfen, dies zu erreichen, egal ob Sie ein professioneller Entwickler sind oder gerade erst anfangen. Vom Schreiben und Strukturieren Ihres Codes bis hin zur Dokumentation und Veröffentlichung deckt dieser Leitfaden alles ab.

Schritt-für-Schritt-Anleitung zum Erstellen einer Bibliothek

Schritt 1: Initialisieren Sie Ihr Projekt

Beginnen Sie mit der Erstellung eines Stammverzeichnisses für Ihr Projekt.

Schritt 2: Erstellen Sie ein Verzeichnis für Ihr Paket

Der nächste Schritt besteht darin, innerhalb des Verzeichnisses Ihres Projekts ein Verzeichnis für Ihr Paket zu erstellen.

multiples_library/
└──multiples/

Schritt 3: Hinzufügen __init.py__

Fügen Sie nun die __init.py__ im Verzeichnis Ihres Pakets. Diese Datei ist der primäre Indikator für Python, dass das Verzeichnis, in dem sie sich befindet, ein Paket ist. Sie enthält Initialisierungscode (sofern vorhanden) und wird automatisch ausgeführt, wenn ein Paket oder eines seiner Module importiert wird.

multiples_library/
└── multiples/
    └──__init__.py

Schritt 4: Module hinzufügen

Jetzt müssen Sie dem Verzeichnis des Pakets Module hinzufügen. Diese Module bestehen normalerweise aus Klassen und Funktionen. Es empfiehlt sich, jedem Modul einen aussagekräftigen Namen zu geben, der seinen Zweck beschreibt.

multiples_library/
│
└── multiples/
    ├── __init__.py
    ├── is_multiple_of_two.py
    └── is_multiple_of_five.py

Schritt 5: In die Module schreiben

In diesem Schritt definieren Sie die Funktionalität jedes Moduls. In meinem Fall beispielsweise:

Modul: multiple_of_two.py

def is_multiple_of_two(quantity):
    """ Verify if a quantity is a a number of of two. """
    return quantity % 2 == 0

Modul: multiple_of_five.py

def is_multiple_of_five(quantity):
    """ Verify if a quantity is a a number of of 5. """
    return quantity % 5 == 0

Schritt 6: setup.py hinzufügen

Der nächste Schritt besteht darin, eine weitere Datei namens setup.py zum Verzeichnis Ihres Pakets hinzuzufügen.

multiples_library/
│
├── multiples/
│   ├── __init__.py
│   ├── is_multiple_of_two.py
│   └── is_multiple_of_five.py
│
└──setup.py

Diese Datei enthält Metadaten zu Ihrem Paket, wie etwa Title, Abhängigkeiten, Autor, Model, Beschreibung und mehr. Sie definiert auch, welche Module enthalten sein sollen, und enthält Anweisungen zum Erstellen und Installieren des Pakets.

from setuptools import setup, find_packages

setup(
    identify="multiples_library",  # Substitute together with your package deal’s identify
    model='0.1.0',
    packages=find_packages(),
    install_requires=(
        # Checklist your dependencies right here
    ),
    creator="Your identify",  
    author_email="Your e-mail",
    description='A library for checking multiples of two and 5.',
    classifiers=(
        'Programming Language :: Python :: 3',
        'License :: OSI Authorised :: MIT License',  # License sort
        'Working System :: OS Unbiased',
    ),
    python_requires=">=3.6",

)

Schritt 7: Checks und andere Dateien hinzufügen (non-obligatory)

Dieser Schritt ist nicht notwendig, aber eine gute Vorgehensweise, wenn Sie eine fehlerfreie und professionelle Bibliothek erstellen möchten. In diesem Schritt ist die Projektstruktur endgültig und sieht ungefähr so ​​aus:

multiples_library/
│
├── multiples/
│   ├── __init__.py
│   ├── is_multiple_of_two.py
│   └── is_multiple_of_five.py
│
│
├── exams/ 
│   ├── __init__.py   
│   ├── test_is_multiple_of_two.py
│   └── test_is_multiple_of_five.py
│
├── docs/
│
├── LICENSE.txt
├── CHANGES.txt
├── README.md
├── setup.py
└── necessities.txt

Nun erkläre ich Ihnen, welchen Zweck die optionalen Dateien und Ordner haben, die im Stammverzeichnis aufgeführt sind:

• Checks/: Enthält Testfälle für Ihre Bibliothek, um sicherzustellen, dass sie sich wie erwartet verhält.
• Dokumente/: Enthält Dokumentation für Ihre Bibliothek.
• LICENSE.txt: Enthält die Lizenzbedingungen, unter denen andere Ihren Code verwenden können.
• ÄNDERUNGEN.txt: Protokolliert Änderungen an der Bibliothek.
• README.md: Enthält die Beschreibung Ihres Pakets und Installationsanweisungen.
• necessities.txt: Listet die externen Abhängigkeiten auf, die Ihre Bibliothek benötigt. Sie können diese Pakete mit einem einzigen Befehl installieren (pip set up -r necessities.txt).

Diese Beschreibungen sind ziemlich unkompliziert und Sie werden den Zweck der optionalen Dateien und Ordner in kürzester Zeit verstehen. Ich möchte jedoch ein wenig auf das optionale Testverzeichnis eingehen, um seine Verwendung zu verdeutlichen.

exams/ Verzeichnis

Es ist wichtig zu beachten, dass Sie ein Testverzeichnis innerhalb Ihres Stammverzeichnisses hinzufügen können, d. h. multiples_libraryoder im Verzeichnis Ihres Pakets, d. h. multiples. Die Entscheidung liegt bei Ihnen. Ich bevorzuge es jedoch, es auf der obersten Ebene im Stammverzeichnis zu belassen, da ich denke, dass dies eine bessere Möglichkeit ist, Ihren Code zu modularisieren.

Mehrere Bibliotheken helfen Ihnen beim Schreiben von Testfällen. Ich werde die bekannteste und meine persönliche Lieblingsbibliothek „unittest“ verwenden.

Unit-Check/s für is_multiple_of_two

Der/die Testfall(e) für dieses Modul ist/sind enthalten im test_is_multiple_of_two.py Datei.

import unittest
import sys
import os

sys.path.insert(0, os.path.abspath(os.path.be a part of(os.path.dirname(__file__), '..')))

from multiples.is_multiple_of_two import is_multiple_of_two


class TestIsMultipleOfTwo(unittest.TestCase):

	def test_is_multiple_of_two(self):
		self.assertTrue(is_multiple_of_two(4))
if __name__ == '__main__': 
      unittest.predominant()

Unit-Check/s für is_multiple_of_five

Der/die Testfall(e) für dieses Modul ist/sind enthalten im test_is_multiple_of_five.py Datei.

import unittest
import sys
import os
sys.path.insert(0, os.path.abspath(os.path.be a part of(os.path.dirname(__file__), '..')))

from multiples.is_multiple_of_five import is_multiple_of_five


class TestIsMultipleOfFive(unittest.TestCase):

	def test_is_multiple_of_five(self):
		self.assertTrue(is_multiple_of_five(75)) 

if __name__ == '__main__':
      unittest.predominant()

Die oben aufgeführten Komponententests sind ziemlich unkompliziert, ich werde jedoch zur weiteren Verdeutlichung zwei Funktionen erläutern.

• self.assertTrue(expression) prüft, ob der Ausdruck „Wahr“ ergibt. Der Check ist nur erfolgreich, wenn das Ergebnis des Ausdrucks „Wahr“ ist.
• unittest.predominant() Funktion wird aufgerufen, um alle in der Datei definierten Testfälle auszuführen.

Schritt 8: Verteilen Sie Ihr Paket mit PyPI

Um Ihre Bibliothek für andere leicht zugänglich zu machen, können Sie sie auf PyPI hochladen. Befolgen Sie diese Schritte, um Ihr Paket zu verteilen:

• Erstellen Sie ein Konto auf PyPI und aktivieren Sie die Zwei-Faktor-Authentifizierung.
• Erstellen Sie ein API-Token indem Sie einen Token-Namen vergeben und den Geltungsbereich auf „Gesamtes Konto“ auswählen. Kopieren Sie ihn dann sorgfältig, da er nur einmal vorkommt.
• Jetzt müssen Sie eine .pypirc-Datei erstellen.
  Für MacOS/Linuxöffnen Sie das Terminal und führen Sie den folgenden Befehl aus:

Für Home windowsöffnen Sie die Eingabeaufforderung und führen Sie den folgenden Befehl aus:

cd %USERPROFILE%
sort NUL > .pypirc

Die Datei wird erstellt und befindet sich unter ~/.pypirc (bei MacOS/Linux) und unter %USERPROFILE%/.pypirc (bei Home windows).

• Bearbeiten .pypirc Datei, indem Sie die folgende Konfiguration kopieren und einfügen:

(distutils)
index-servers =
    pypi

(pypi)
username = __token__
password = pypi-

Ersetzen mit dem tatsächlichen API-Token, das Sie von PyPI generiert haben. Vergessen Sie nicht, das Präfix pypi- einzuschließen.

• Stellen Sie sicher, dass Sie eine Datei „setup.py“ im Stammverzeichnis Ihres Projekts haben. Führen Sie den folgenden Befehl aus, um Verteilungsdateien zu erstellen:

python3 setup.py sdist bdist_wheel

• Twine ist ein Device zum Hochladen von Paketen auf PyPI. Installieren Sie Twine, indem Sie den folgenden Befehl ausführen:
• Laden Sie jetzt Ihr Paket auf PyPI hoch, indem Sie den folgenden Befehl ausführen:

Schritt 9: Installieren und Verwenden der Bibliothek

Sie können die Bibliothek mit dem folgenden Befehl installieren:

pip set up (your-package)

In meinem Fall:

pip set up multiples_library

Nun können Sie die Bibliothek wie folgt verwenden:

from multiples.is_multiple_of_five import is_multiple_of_five
from multiples.is_multiple_of_two import is_multiple_of_two

print(is_multiple_of_five(10))
# Outputs True
print(is_multiple_of_two(11))
# Outputs False

Einpacken

Kurz gesagt, das Erstellen einer Python-Bibliothek ist sehr interessant und ihre Verbreitung macht sie für andere nützlich. Ich habe versucht, alles, was Sie zum Erstellen einer Bibliothek in Python benötigen, so klar wie möglich abzudecken. Wenn Sie jedoch an irgendeinem Punkt nicht weiterkommen oder verwirrt sind, zögern Sie bitte nicht, im Kommentarbereich Fragen zu stellen.

Kanwal Mehreen Kanwal ist Ingenieurin für maschinelles Lernen und technische Autorin mit einer tiefen Leidenschaft für Datenwissenschaft und die Schnittstelle zwischen KI und Medizin. Sie ist Mitautorin des E-Books „Maximizing Productiveness with ChatGPT“. Als Google Era Scholar 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie ist außerdem als Teradata Variety in Tech Scholar, Mitacs Globalink Analysis Scholar und Harvard WeCode Scholar anerkannt. Kanwal ist eine leidenschaftliche Verfechterin des Wandels und hat FEMCodes gegründet, um Frauen in MINT-Fächern zu stärken.

Bild vom Autor | Leonardo AI & Canva

Datenserialisierung ist ein grundlegendes Programmierkonzept mit großem Nutzen in alltäglichen Programmen. Es bezieht sich auf die Konvertierung komplexer Datenobjekte in ein Zwischenformat, das gespeichert und problemlos wieder in seine ursprüngliche Type zurückkonvertiert werden kann. Die gängigen Python-Bibliotheken zur Datenserialisierung wie JSON und Pickle sind jedoch in ihrer Funktionalität sehr eingeschränkt. Bei strukturierten Programmen und objektorientierter Programmierung benötigen wir stärkere Unterstützung für den Umgang mit Datenklassen.

Marshmallow ist eine der bekanntesten Datenverarbeitungsbibliotheken, die von Python-Entwicklern häufig zur Entwicklung robuster Softwareanwendungen verwendet wird. Es unterstützt die Datenserialisierung und bietet eine starke abstrakte Lösung für die Datenvalidierung in einem objektorientierten Paradigma.

In diesem Artikel verwenden wir ein laufendes Beispiel, das unten aufgeführt ist, um zu verstehen, wie Marshmallow in bestehenden Projekten verwendet wird. Der Code zeigt drei Klassen, die ein einfaches E-Commerce-Modell darstellen: Product, BuyerUnd Order. Jede Klasse definiert ihre Parameter minimal. Wir werden sehen, wie man eine Instanz eines Objekts speichert und ihre Korrektheit sicherstellt, wenn wir versuchen, es in unserem Code erneut zu laden.

from typing import Listing

class Product:
    def __init__(self, _id: int, identify: str, worth: float):
    	self._id = _id
    	self.identify = identify
    	self.worth = worth

class Buyer:
    def __init__(self, _id: int, identify: str):
    	self._id = _id
    	self.identify = identify

class Order:
    def __init__(self, _id: int, buyer: Buyer, merchandise: Listing(Product)):
    	self._id = _id
    	self.buyer = buyer
    	self.merchandise = merchandise

Erste Schritte mit Marshmallow

Set up

Marshmallow ist als Python-Bibliothek bei PyPI verfügbar und kann einfach mit pip installiert werden. Um die Marshmallow-Abhängigkeit zu installieren oder zu aktualisieren, führen Sie den folgenden Befehl aus:

pip set up -U marshmallow

Dadurch wird die aktuelle stabile Model von Marshmallow in der aktiven Umgebung installiert. Wenn Sie die Entwicklungsversion der Bibliothek mit allen neuesten Funktionen wünschen, können Sie diese mit dem folgenden Befehl installieren:

pip set up -U git+https://github.com/marshmallow-code/marshmallow.git@dev

Erstellen von Schemas

Beginnen wir mit der Erweiterung des Product Klasse. Wir müssen eine neue Klasse erstellen, die ein Schema darstellt, eine Instanz der Product Klasse folgen muss. Stellen Sie sich ein Schema wie eine Blaupause vor, die die Variablen in der Product Klasse und der Datentyp, zu dem sie gehören.

Lassen Sie uns den folgenden Basiscode aufschlüsseln und verstehen:

from marshmallow import Schema, fields

class ProductSchema(Schema):
    _id = fields.Int(required=True)
    identify = fields.Str(required=True)
    worth = fields.Float(required=True)

Wir erstellen eine neue Klasse, die erbt von der Schema Klasse in Marshmallow. Dann deklarieren wir die gleichen Variablennamen wie unsere Product Klasse und definieren Sie ihre Feldtypen. Die Klasse „Felder“ in Marshmallow unterstützt verschiedene Datentypen. Hier verwenden wir die primitiven Typen Int, String und Float.

Serialisierung

Nachdem wir nun ein Schema für unser Objekt definiert haben, können wir nun eine Python-Klasseninstanz zur Serialisierung in eine JSON-Zeichenfolge oder ein Python-Wörterbuch konvertieren. Hier ist die grundlegende Implementierung:

product = Product(_id=4, identify="Take a look at Product", worth=10.6)
schema = ProductSchema()
    
# For Python Dictionary object
end result = schema.dump(product)

# kind(dict) -> {'_id': 4, 'identify': 'Take a look at Product', 'worth': 10.6}

# For JSON-serializable string
end result = schema.dumps(product)

# kind(str) -> {"_id": 4, "identify": "Take a look at Product", "worth": 10.6}

Wir erschaffen ein Objekt unserer ProductSchemadas ein Produktobjekt in ein serialisierbares Format wie JSON oder ein Wörterbuch konvertiert.

Beachten Sie den Unterschied zwischen dump Und dumps Funktionsergebnisse. Eines gibt ein Python-Wörterbuchobjekt zurück, das mit Pickle gespeichert werden kann, und das andere gibt ein Zeichenfolgenobjekt zurück, das dem JSON-Format folgt.

Deserialisierung

Um den Serialisierungsprozess umzukehren, verwenden wir die Deserialisierung. Ein Objekt wird gespeichert, damit es später geladen und abgerufen werden kann, und Marshmallow hilft dabei.

Ein Python-Wörterbuch kann mit der Ladefunktion validiert werden, die die Variablen und ihre zugehörigen Datentypen überprüft. Die folgende Funktion zeigt, wie es funktioniert:

product_data = {
    "_id": 4,
    "identify": "Take a look at Product",
    "worth": 50.4,
}
end result = schema.load(product_data)
print(end result)  	

# kind(dict) -> {'_id': 4, 'identify': 'Take a look at Product', 'worth': 50.4}

faulty_data = {
    "_id": 5,
    "identify": "Take a look at Product",
    "worth": "ABCD" # Flawed enter datatype
}
end result = schema.load(faulty_data) 

# Raises validation error

Das Schema überprüft, ob das Wörterbuch die richtigen Parameter und Datentypen enthält. Wenn die Überprüfung fehlschlägt, wird ein ValidationError ist angehoben, so ist es wichtig, die load perform in einem Attempt-Besides-Block. Wenn es erfolgreich ist, ist das Ergebnisobjekt immer noch ein Wörterbuch, wenn das ursprüngliche Argument auch ein Wörterbuch ist. Nicht so hilfreich, oder? Was wir im Allgemeinen wollen, ist, das Wörterbuch zu validieren und es wieder in das ursprüngliche Objekt zu konvertieren, aus dem es serialisiert wurde.

Um dies zu erreichen, verwenden wir die post_load Dekorateur bereitgestellt von Marshmallow:

from marshmallow import Schema, fields, post_load

class ProductSchema(Schema):
    _id = fields.Int(required=True)
    identify = fields.Str(required=True)
    worth = fields.Float(required=True)

@post_load
def create_product(self, knowledge, **kwargs):
    return Product(**knowledge)

Wir erstellen eine Funktion in der Schemaklasse mit dem post_load Dekorator. Diese Funktion nimmt das validierte Wörterbuch und konvertiert es zurück in ein Produktobjekt. Einschließlich **kwargs ist wichtig, da Marshmallow zusätzliche notwendige Argumente über den Dekorator übergeben kann.

Diese Änderung der Ladefunktion stellt sicher, dass das Python-Wörterbuch nach der Validierung an den post_load Funktion, die eine Product Objekt aus dem Wörterbuch. Dadurch ist es möglich, ein Objekt mit Marshmallow zu deserialisieren.

Validierung

Oft benötigen wir zusätzliche Validierungen, die speziell auf unseren Anwendungsfall zugeschnitten sind. Obwohl die Datentypvalidierung wichtig ist, deckt sie nicht alle Validierungen ab, die wir möglicherweise benötigen. Selbst in diesem einfachen Beispiel ist eine zusätzliche Validierung für unseren Product Objekt. Wir müssen sicherstellen, dass der Preis nicht unter 0 liegt. Wir können auch weitere Regeln definieren, beispielsweise sicherstellen, dass unser Produktname zwischen 3 und 128 Zeichen lang ist. Diese Regeln helfen sicherzustellen, dass unsere Codebasis einem definierten Datenbankschema entspricht.

Sehen wir uns nun an, wie wir diese Validierung mit Marshmallow implementieren können:

from marshmallow import Schema, fields, validates, ValidationError, post_load

class ProductSchema(Schema):
    _id = fields.Int(required=True)
    identify = fields.Str(required=True)
    worth = fields.Float(required=True)

@post_load
def create_product(self, knowledge, **kwargs):
    return Product(**knowledge)


@validates('worth')
def validate_price(self, worth):
    if worth <= 0:
        elevate ValidationError('Value should be larger than zero.')

@validates('identify')
def validate_name(self, worth):
    if len(worth) < 3 or len(worth) > 128:
        elevate ValidationError('Identify of Product should be between 3 and 128 letters.')

Wir modifizieren die ProductSchema Klasse, um zwei neue Funktionen hinzuzufügen. Eine validiert den Preisparameter und die andere validiert den Namensparameter. Wir verwenden den Validates-Funktionsdekorator und kommentieren den Namen der Variable, die die Funktion validieren soll. Die Implementierung dieser Funktionen ist unkompliziert: Wenn der Wert falsch ist, lösen wir eine ValidationError.

Verschachtelte Schemas

Nun mit den grundlegenden Product Klassenvalidierung: Wir haben alle grundlegenden Funktionen der Marshmallow-Bibliothek abgedeckt. Lassen Sie uns nun die Komplexität erhöhen und sehen, wie die anderen beiden Klassen validiert werden.

Der Buyer Klasse ist ziemlich unkompliziert, da sie die grundlegenden Attribute und primitiven Datentypen enthält.

class CustomerSchema(Schema):
    _id = fields.Int(required=True)
    identify = fields.Int(required=True)

Die Definition des Schemas für die Order Klasse zwingt uns, ein neues und erforderliches Konzept von verschachtelten Schemas zu lernen. Eine Bestellung wird einem bestimmten Kunden zugeordnet und der Kunde kann eine beliebige Anzahl von Produkten bestellen. Dies wird in der Klassendefinition definiert, und wenn wir die Order Schema müssen wir auch validieren die Product Und Buyer an ihn übergebene Objekte.

Anstatt alles neu zu definieren im OrderSchemavermeiden wir Wiederholungen und verwenden verschachtelte Schemata. Das Bestellschema ist wie folgt definiert:

class OrderSchema(Schema):
    _id = fields.Int(require=True)
    buyer = fields.Nested(CustomerSchema, required=True)
    merchandise = fields.Listing(fields.Nested(ProductSchema), required=True)

Innerhalb der Order Schema, wir schließen die ProductSchema Und CustomerSchema Definitionen. Dadurch wird sichergestellt, dass die definierten Validierungen für diese Schemata automatisch angewendet werden, gemäß den DRY (Wiederholen Sie sich nicht) Prinzip in der Programmierung, welches die Wiederverwendung von bestehendem Code ermöglicht.

Einpacken

In diesem Artikel haben wir den Schnellstart und den Anwendungsfall der Marshmallow-Bibliothek behandelt, einer der beliebtesten Serialisierungs- und Datenvalidierungsbibliotheken in Python. Obwohl sie Pydantic ähnelt, bevorzugen viele Entwickler Marshmallow aufgrund ihrer Schemadefinitionsmethode, die Validierungsbibliotheken in anderen Sprachen wie JavaScript ähnelt.

Marshmallow lässt sich problemlos in Python-Backend-Frameworks wie FastAPI und Flask integrieren und ist daher eine beliebte Wahl für Internet-Frameworks und Datenvalidierungsaufgaben sowie für ORMs wie SQLAlchemy.

Kanwal Mehreen Kanwal ist Ingenieurin für maschinelles Lernen und technische Autorin mit einer tiefen Leidenschaft für Datenwissenschaft und die Schnittstelle zwischen KI und Medizin. Sie ist Mitautorin des E-Books „Maximizing Productiveness with ChatGPT“. Als Google Era Scholar 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie ist außerdem als Teradata Range in Tech Scholar, Mitacs Globalink Analysis Scholar und Harvard WeCode Scholar anerkannt. Kanwal ist eine leidenschaftliche Verfechterin des Wandels und hat FEMCodes gegründet, um Frauen in MINT-Fächern zu stärken.