Share
Explore

Python Tutorial Level 1

Prerequisites to do this Lab:

Have Anaconda PYTHON Installed:
IDE: Visual Studio Code Installed
Watch this Video to understand why we are learning PYTHON in a Cisco Networking Class

image.png

PYTHON is the Network Administrator’s programming language - This is why we are using it to make a Router to deliver the course project.

Python with Wireshark.

Wireshark itself is a network protocol analyzer, and it provides a command-line tool called tshark. Python, being a versatile programming language, can be used to interact with Wireshark or tshark through various libraries and modules.
One such module is the Pyshark library, which acts as a Python wrapper for tshark, allowing you to utilize Wireshark's powerful network traffic analysis capabilities from within Python.
Here's a simple example of how you can use Pyshark to analyze network traffic in Python:
python
import pyshark
# Capture live network traffic cap = pyshark.LiveCapture(interface='eth0')
# Print out each packet for packet in cap: print(packet)
This is just a basic demonstration of capturing and printing network packets using Pyshark. You can perform various data analysis and processing tasks on captured packets using Python's extensive libraries and Pyshark's functionalities.
It's important to note that using Python with Wireshark or tshark requires understanding of network protocols and a strong grasp of Python programming. Also, proper permissions and administrative rights might be required to capture live network traffic.
If you have specific goals or tasks in mind for using Python with Wireshark, feel free to provide more details so that I can offer a more customized explanation or solution.

Python Learner's Pledge

We, the aspiring Python enthusiasts,
In our quest for knowledge and skill,
Pledge our commitment to the Pythonic way,
Where simplicity and clarity reign supreme.
We vow to embrace the challenges,
To debug with patience and persistence,
To share our knowledge and learn from our peers,
Uniting in the spirit of open source and community.
With each line of code, we shall strive,
For elegance, efficiency, and truth,
Honoring those who code before us,
And inspiring those who code after.
In this journey of loops, functions, and classes,
We pledge to uphold the values of Python,
To write code that not only works,
But speaks with clarity and purpose.
Together, in the spirit of Python,
We commit to this path of discovery and growth,
For the betterment of ourselves, our community,
And the world that interacts through the language of technology.
This pledge is meant to encapsulate the spirit of Python programming - focusing on clarity, community, and continuous learning. It's a fun and engaging way to remind students of the values and practices that make Python a beloved programming language.
Diagram providing a Big Picture Overview of how programming languages work:

Purpose / Next Steps:

Use Python Programming to create TCP IP Network Management tools

Install Ananconda Python

Work Flow for this Lab:


Step 1: Start Visual Studio Code IDE
Step 2: Make a Project Directory for your Work
OPEN A terminal: Menu Path View → Terminal
image.png
VSC provides extensions to add additional tooling to our workflow:
image.png

Let's start with a small introduction to Python programming and then delve into three basic exercises.

Guido van Rossum, the creator of Python, was born in 1956 in the Netherlands. He developed a fascination with computers in secondary school when the institution acquired a computer. Guido further delved into his interest in computers by studying mathematics and computer science at the University of Amsterdam.

In university, he was introduced to the ABC programming language, which, although influential, Guido found it lacked in extensibility and flexibility. These limitations inspired him to create a programming language that would surpass them and meet the needs of programmers more proficiently.
Guido created Python during his time at the Netherlands’ National Research Institute for Mathematics and Computer Science (CWI), with its implementation starting in December 1989. He designed Python to prioritize readability and simplicity, drawing inspiration from other programming languages such as ABC, Modula-3, C, and Lisp.
The initial release of Python, version 0.9.0 in February 1991, already had classes with inheritance, exception handling, functions, and the core datatypes of list, dict, str, and so on. It drew considerable praise from the programming community for its versatility, and with each new release, Python progressively became more powerful, flexible, and useful.
Guido led the development of Python for nearly three decades while fostering a community-driven approach to its evolution. He held a role called the Benevolent Dictator For Life (BDFL), deciding the direction of Python until his resignation in 2018. Despite stepping down from his leadership role, he continues to contribute to the Python community.
image.png

image.png
Python is a popular high-level, interpreted programming language known for its easy syntax and readability.
Python is versatile and powerful, used in various domains:
web development
data analysis
artificial intelligence
game development.

Lab tutorial workbook: Using Jupyter Notebook for Python:

**Lab Tutorial Workbook: Introduction to Jupyter Notebook**
1. Installing Jupyter Notebook
image.png
Start by installing Python on your machine if you haven't already. You can download Python from the official Python website. - Once Python is installed, open your command prompt or terminal and run the following command to install Jupyter Notebook: ``` pip install jupyterlab ```
**2. Launching Jupyter Notebook** - Open your command prompt or terminal and navigate to the desired directory where you want to create your notebook. - Run the following command to launch Jupyter Notebook: ``` jupyter notebook ``` - This will open Jupyter Notebook in your default web browser.
**3. Creating a New Notebook** - In the Jupyter Notebook interface, click on the "New" drop-down menu on the right side and select "Python" to create a new Python notebook. - A new tab will open with an empty notebook.
**4. Notebook Cells** - A Jupyter Notebook is made up of cells, which can contain code, text, or visualizations. - By default, the first cell is a code cell. You can write Python code in it. - To add a new cell, click on the "+" button in the toolbar or press the "B" key on your keyboard while in command mode (press "Esc" to activate command mode). - To change the cell type, select the cell and go to the toolbar and select either "Code" or "Markdown" from the drop-down menu.
**5. Running Code** - To run a code cell, select the cell and press "Shift + Enter" or click the "Run" button in the toolbar. - Output from the code will appear below the cell. - You can also use shortcuts like "Ctrl + Enter" to run the cell and stay on the same cell.
**6. Editing and Formatting Text** - To add text to a notebook, create a markdown cell. - Double click on a markdown cell to edit its contents. - You can use Markdown syntax to format your text. For example: - To create headers, use "#" (e.g., "# Heading 1"). - To create bullet points, use "-" or "*" (e.g., "- Item 1").
**7. Saving and Exporting Notebooks** - To save your notebook, go to "File" and click on "Save and Checkpoint" or use the shortcut "Ctrl + S". - To export your notebook, go to "File", select "Download As", and choose the desired format (e.g., "Notebook (.ipynb)", "Python (.py)").
**8. Restarting and Clearing Output** - To restart the Python kernel (clear all variables and reset the notebook), go to "Kernel" and click on "Restart" or use the shortcut "0, 0" (press "0" twice). - To clear the output of a cell, select the cell and go to "Cell" and click on "Clear Output" or use the shortcut "Shift + O".
**9. Additional Resources** - Jupyter Notebook documentation: [https://jupyter-notebook.readthedocs.io/](https://jupyter-notebook.readthedocs.io/) - Jupyter Notebook tutorials: [https://www.datacamp.com/community/tutorials/tutorial-jupyter-notebook](https://www.datacamp.com/community/tutorials/tutorial-jupyter-notebook)
This lab tutorial workbook provides a basic introduction to Jupyter Notebook for Python. Explore the capabilities of Jupyter Notebook further to unlock its full potential for data analysis, visualization, and more. Happy coding!

Exercise 1: Hello, World!

The first program in any language is the classic "Hello, World!" program, designed to introduce the syntax for outputting information.
```python print("Hello, World!") ```

image.png

Let’s start by getting strong on the basics:
The File System
The Command Prompt
video:

To run this code: 1. Open your Python environment (for instance IDLE or Anaconda, or use an online Python compiler like Repl.it or Jupyter Notebook). 2. Copy and paste this code into the Python shell. 3. Press Enter, and it should print "Hello, World!".

Exercise 2: Variables and Types

Variables are containers for storing data values: The results of Intermediate Computations.

Unlike other programming languages, Python doesn't require declaring the variable type.

```python x = 20 y = 20.5 z = "Hello, Python" ```
In this example, `x` is an integer, `y` is a float (a number that allows for decimal points), and `z` is a string. You can check the type of any object with the `type()` function in python like this:
```python print(type(x))
Whatever occurs between the round brackets in PYTHON is a EXPRESSION which is evaluated.
Expressions are customarily assigned to Variables.
image.png

Below is an example Python program using fruits and arrays to demonstrate filtering and sorting based on their colors:

class Fruit: def __init__(self, name, color): self.name = name self.color = color
fruits = [Fruit("Apple", "red"), Fruit("Banana", "yellow"), Fruit("Grapes", "green"), Fruit("Orange", "orange"), Fruit("Blueberry", "blue")]
# Filtering fruits by color ​def filter_fruits_by_color(fruit_list, target_color): return [fruit for fruit in fruit_list if fruit.color == target_color]
# Sorting fruits by name def sort_fruits_by_name(fruit_list): return sorted(fruit_list, key=lambda x: x.name)
# Sorting fruits by color def sort_fruits_by_color(fruit_list): return sorted(fruit_list, key=lambda x: x.color)
# Filtering and sorting def filter_and_sort_fruits(fruit_list, target_color): filtered_fruits = filter_fruits_by_color(fruit_list, target_color) sorted_fruits = sort_fruits_by_name(filtered_fruits) return sorted_fruits
target_color = "red" filtered_and_sorted_fruits = filter_and_sort_fruits(fruits, target_color) ​for fruit in filtered_and_sorted_fruits: print(fruit.name, fruit.color) ```
In this example, we have a `Fruit` class to represent a fruit's name and color.
We then create a list of fruits with their respective colors.
The program includes functions for filtering fruits by color, as well as for sorting them by name and color.
Finally, we demonstrate the filtering and sorting process for fruits with the color "red" and display the results.

**Exercise 3: Conditional Statements**
Let's finish with an example of a conditional statement. Here, we'll use the `if` statement.
```python x = 10 y = 20 if y > x: print("y is greater than x") else: print("x is greater than y") ```
In this example, since 20 is greater than 10, the output will be "y is greater than x".
Take your time to practice and experiment with these exercises. Remember, the key to learning programming is consistent practice. Happy coding!

Epoch 1: Introduction to Python and Basic Programming
Introduction to Python
History and evolution of Python
Why Python is popular in enterprise IT and data analysis
Setting Up the Python Environment
Installing Python
Setting up an Integrated Development Environment (IDE)
Writing and executing the first Python script: "Hello, World!"
Basic Python Syntax and Variables
Python indentation and code structure
Variables: declaration, assignment, and data types
Control Structures: Conditional Statements
if, elif, and else statements
Simple program: A basic calculator
Control Structures: Loops
for and while loops
Simple program: Generating a Fibonacci sequence
Functions in Python
Defining and calling functions
Parameters and return values
Simple program: A function to check if a number is prime
Data Structures: Lists and Dictionaries
Lists: definition, indexing, and basic operations
Dictionaries: definition, keys, values, and basic operations
Simple program: A contact book using lists and dictionaries
File Input/Output
Reading from and writing to files
Handling different file formats (txt, csv)
Simple program: A basic file-based note-taking application
Epoch 2: Intermediate Python and Object-Oriented Programming
Introduction to Object-Oriented Programming (OOP)
Concepts: Classes, Objects, Inheritance, Polymorphism
Why OOP is crucial for enterprise applications
Defining Classes and Objects in Python
Creating classes and instantiating objects
Attributes and methods
Inheritance and Polymorphism in Python
Extending classes and overriding methods
Using polymorphism for flexible code design
Modeling the Enterprise Business Domain
Understanding business requirements
Designing classes to represent entities like Employees, Products, Orders, etc.
Simple program: A basic inventory management system
Error Handling and Exceptions
Understanding exceptions in Python
try, except, finally blocks
Creating custom exceptions
Modules and Packages
Organizing code using modules and packages
Importing and using external libraries
Epoch 3: Advanced Python and Enterprise Application Development
Advanced Data Structures: Sets and Tuples
Sets: definition and operations
Tuples: definition and use cases
Database Integration with Python
Introduction to SQL databases
Using Python to connect, query, and update databases
Simple program: A CRUD application for an enterprise database
Web Development with Python
Introduction to web frameworks like Flask or Django
Building a basic web application to showcase enterprise data
Data Analysis with Python
Introduction to libraries like Pandas and NumPy
Analyzing enterprise data to derive insights
Testing and Debugging in Python
Writing unit tests using unittest
Debugging techniques and tools
Deploying Python Applications in an Enterprise Environment
Understanding deployment options: local servers, cloud platforms, containers
Best practices for secure and scalable deployment
This outline provides a comprehensive journey from understanding Python's basics to deploying enterprise applications. Each step can be expanded upon with lectures, hands-on exercises, and projects to ensure a deep understanding of the concepts.

Epoch 4: Advanced Topics and Specialized Use-Cases
Python and Cloud Integration
Introduction to cloud platforms (e.g., AWS, Azure, Google Cloud)
Leveraging Python SDKs to interact with cloud services
Simple program: Automating cloud resource management using Python
Python for Data Visualization
Introduction to libraries like Matplotlib, Seaborn, and Plotly
Creating interactive dashboards and reports for enterprise stakeholders
Python and Machine Learning
Introduction to machine learning concepts
Using Python libraries like Scikit-learn for building ML models
Simple program: Predictive analytics for enterprise sales data
Python and API Development
Building RESTful APIs using frameworks like Flask and FastAPI
Securing, versioning, and deploying APIs for enterprise consumption
Concurrency and Parallelism in Python
Understanding threads, processes, and asynchronous programming
Leveraging Python for concurrent tasks in enterprise applications
Python and IoT (Internet of Things)
Introduction to IoT and its relevance in the enterprise domain
Using Python to interact with IoT devices and sensors
Simple program: Monitoring and reporting IoT device data in an enterprise setup
Python Best Practices and Code Optimization
Writing clean, efficient, and maintainable Python code
Performance optimization techniques and tools
Python and Cybersecurity
Understanding common security threats in enterprise applications
Secure coding practices in Python and vulnerability assessment
Python in DevOps and Automation
Using Python for infrastructure automation and CI/CD pipelines
Leveraging tools and frameworks like Ansible and Jenkins with Python
Final Project and Capstone Presentation
Students will identify a real-world enterprise challenge
Design, develop, and deploy a Python-based solution
Present their solution, highlighting the Python features and libraries used, challenges faced, and the impact of their solution on the enterprise
This extended outline delves deeper into specialized areas of Python, ensuring students are well-equipped to tackle a wide range of enterprise challenges. Each topic can be supplemented with in-depth lectures, workshops, and real-world case studies to provide a holistic learning experience.

Epoch 5: Specializations and Emerging Trends
Python in Big Data and Distributed Systems
Introduction to Big Data concepts and challenges
Using Python with frameworks like Hadoop and Spark
Simple program: Processing large datasets with PySpark
Python and Blockchain Development
Basics of blockchain and its enterprise implications
Developing smart contracts and decentralized apps using Python
Python in Augmented Reality (AR) and Virtual Reality (VR)
Overview of AR/VR technologies
Leveraging Python for AR/VR applications in enterprise scenarios
Python and Natural Language Processing (NLP)
Basics of NLP and its enterprise applications
Using Python libraries like NLTK and spaCy for text analysis
Simple program: Sentiment analysis for customer feedback
Python in Robotics and Automation
Introduction to robotics and its relevance in industries
Programming robots and automation tools using Python
Serverless Architectures with Python
Understanding serverless computing and its benefits
Deploying Python functions as serverless applications on platforms like AWS Lambda
Python and Edge Computing
Basics of edge computing and its significance
Developing Python applications for edge devices in enterprise networks
Advanced Python Metaprogramming
Understanding metaclasses, decorators, and context managers
Leveraging metaprogramming for dynamic code generation and optimization
Python and Quantum Computing
Introduction to quantum computing concepts
Exploring Python libraries like Qiskit for quantum programming
Future of Python: Trends and Predictions
Discussion on the evolving landscape of Python
Identifying emerging libraries, frameworks, and paradigms
Preparing students for continuous learning in the ever-evolving tech landscape
Wrap-Up and Career Guidance
Review of the comprehensive journey from Python basics to advanced specializations
Guidance on Python certifications, further studies, and career paths
Networking opportunities, industry interactions, and mentorship programs
This final epoch ensures that students are not only grounded in the foundational and intermediate aspects of Python but are also exposed to the cutting-edge applications and trends. This holistic approach prepares them to be industry-ready and adaptable to the rapid changes in the tech world.
Want to print your doc?
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
CtrlP
) instead.