• Python is a versatile programming language, but it doesn’t come with all the tools we need
• Packages are collections of functions that extend Python’s capabilities
• There are thousands of packages available, and we can install them using conda install or pip install

• We will also learn about variables and lists
• Variables are containers that store data values
• Lists are collections of items that can be of different types
• Today, we will learn how to create, access, and modify variables and lists

• A Python environment is a self-contained directory that contains a specific Python interpreter and a collection of packages
• It allows you to manage dependencies and avoid conflicts between different projects
• You can create multiple environments with different versions of Python and packages
• Each environment is isolated from others, ensuring that changes in one environment do not affect others
• You can create, activate, and deactivate environments using the command line or Anaconda Navigator
• The default environment is called base, and it is created when you install Anaconda

• For this course, we will use the base environment
• But you are free to create your own environments if you want!
• There are two ways to create environments:
  • Using the command line: conda create -n qtm151 python=3.12
  • Using Anaconda Navigator: Go to the “Environments” tab and click on “Create”
• After creating an environment in the command line, you can activate it using the command line: conda activate qtm151
• To remove a package from an environment, use the command line: conda remove package_name
• To deactivate an environment, use the command line: conda deactivate
• To remove an environment, use the command line: conda remove -n qtm151 --all

# Create a new environment called qtm151
conda create -n qtm151 python=3.12

# Activate the qtm151 environment
conda activate qtm151

# Install the required packages
conda install numpy pandas matplotlib jupyter

# Deactivate the current environment
conda deactivate

# Remove the qtm151 environment
conda remove -n qtm151 --all

• Windows users, please open the Anaconda PowerShell Prompt instead of the regular command line. More info here.
• You can also run the following command in VSCode’s terminal:

conda update conda
conda init

• There are several ways to install packages in Python
• The two most common ways are pip and conda
• pip is the Python package installer, which comes pre-installed with Python
• conda is the package manager that comes with Anaconda, and it is even more user-friendly
• We will use conda to install packages in this course
• You can install packages using the command conda install package in the terminal or go to the Anaconda Navigator and install them from there

• In Anaconda Navigator, you can search for packages in the “Environments” tab
• The main packages we will use are:
  • numpy: for numerical computing
  • pandas: for data manipulation
  • matplotlib: for data visualisation
• You should have them installed already, as they come with the base Anaconda installation
• If not, please try to install them using the Anaconda Navigator

Option 1: Via File Menu - Go to “File” > “New File…”. - Select “Jupyter Notebook” from the options. - Save the new file with a .ipynb extension (e.g., lecture_notes.ipynb).

Option 2: Via Command Palette - Press Cmd + Shift + P (macOS) or Ctrl + Shift + P (Windows/Linux). - Type “Create: New Jupyter Notebook” and select it. - Again, ensure the correct kernel is selected for this new notebook.

VS Code offers several ways to inspect your DataFrame:

• Jupyter Variables Tab:
  • Look for a “Variables” icon or section in the Jupyter interface within VS Code
  • Clicking it shows active variables; double-clicking a DataFrame (like carfeatures) opens it in a new tab for viewing

• Data Wrangler Extension (if installed):
  • This extension provides more advanced tools for data viewing and cleaning
  • You might find a “View Data” button or a right-click option on the DataFrame variable

• To select a single column from a DataFrame, use the column name in square brackets []
• This returns a pandas Series (a one-dimensional array-like object)

# Extracting the 'cylinders' column.
carfeatures['cylinders'].head()

0    8
1    8
2    8
3    8
4    8
Name: cylinders, dtype: int64

• You can also use the dot notation (if the column name doesn’t contain spaces or special characters)

# Using dot notation
carfeatures.cylinders.head()

0    8
1    8
2    8
3    8
4    8
Name: cylinders, dtype: int64

• Note: Dot notation is less flexible than bracket notation, especially for column names with spaces or special characters

• Variables are used to store data values.
• Python is dynamically typed, meaning you don’t need to declare the type of a variable.
• Common Data Types:
  • Integers (int): Whole numbers (e.g., x = 10).
  • Floats (float): Numbers with decimals (e.g., pi = 3.14).
  • Strings (str): Text, enclosed in single ' ' or double " " quotes (e.g., message = "Hello").
  • Booleans (bool): Logical values, either True or False.

• Use type() to check a variable’s data type.
• Use print() to display a variable’s value.

age = 30                            # Integer
price = 19.99                       # Float
student_name = "Alice"              # String
is_enrolled = True                  # Boolean

print(f"Value: {age}, Type: {type(age)}")
print(f"Value: {price}, Type: {type(price)}")
print(f"Value: {student_name}, Type: {type(student_name)}")
print(f"Value: {is_enrolled}, Type: {type(is_enrolled)}")

Value: 30, Type: <class 'int'>
Value: 19.99, Type: <class 'float'>
Value: Alice, Type: <class 'str'>
Value: True, Type: <class 'bool'>

• Assignment: Use the = operator (e.g., user_count = 150).
• Naming Rules & Best Practices:
  • Must start with a letter or underscore (_).
  • Can contain letters, numbers, and underscores.
  • Case-sensitive (myVariable is different from myvariable).
  • Cannot be a Python keyword (e.g., if, for, class).
  • Use descriptive names (e.g., average_score instead of avg).
  • Convention: snake_case (lowercase with underscores) for variables and functions.
• View active variables in VS Code Jupyter using the “Variables” panel or Data Wrangler.

count_apples = 5
item_price = 2.50
user_greeting = "Welcome back!"

print(count_apples)
print(user_greeting)

5
Welcome back!

• Try it yourself!
• Exercise: Create a variable to store the title of your favourite film and print it!

Numeric Operations:

• Addition: +
• Subtraction: -
• Multiplication: *
• Division: / (results in a float)
• Floor Division: // (discards decimal)
• Modulus: % (remainder)
• Exponentiation: ** (e.g., 2**3 is 8)
• Use parentheses () to control the order of operations.

total_cost = 10 * 1.08  # Price * tax
print(f"Total cost: {total_cost}")

base_number = 4
calculation = (base_number + 6) / 2
print(f"Calculation result: {calculation}")

Total cost: 10.8
Calculation result: 5.0

String Concatenation:

• Use the + operator to join strings.

first_name = "Danilo"
last_name = "Freire"
full_name = first_name + " " + last_name
print(full_name)

Danilo Freire

• Try it yourself!
• Exercise: Define variables for your name and major, then print a concatenated string introducing yourself

• matplotlib.pyplot (imported as plt) is Python’s primary plotting library
• plt.hist() creates a histogram. This is useful for visualising the distribution of a single set of numerical data or the frequency of categorical items in a list
• plt.show() displays the generated plot
• Always add labels and a title for clarity:
  • plt.title("My Plot Title")
  • plt.xlabel("X-axis Label")
  • plt.ylabel("Y-axis Label")