Share
Explore
Python Tutorial Level 1
Prerequisites to do this Lab:
Watch this Video to understand why we are learning PYTHON in a Cisco Networking Class
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
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
VSC provides extensions to add additional tooling to our workflow:
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.
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
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!")
```
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.
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
Epoch 2: Intermediate Python and Object-Oriented Programming
Epoch 3: Advanced Python and Enterprise Application Development
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
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
Want to print your doc?
This is not the way.
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
CtrlP
) instead.