Intro to Python - Step 2 Review

Title: Python Step 2: Intermediate Basics for New Python Programmers

Author: Jessica McPhaul
Date: December 3, 2022
Output: HTML Notebook

---

Lesson Overview

This lesson will build on the fundamental concepts you learned in Step 1. It aims to introduce you to essential tools and practices for effective Python programming, including:

1. Setting Up Visual Studio Code (VS Code)
2. Basic Python Constructs: Variables, input/output, and operations.
3. Working with Functions: Defining and calling reusable pieces of code.
4. Using the Command Line: Navigating your system through VS Code.
5. Advanced Concepts: Variable scope, side effects, and improving your understanding of code organization.

---

Python Step 2 Concepts and Code

1. Setting Up VS Code

VS Code is an Integrated Development Environment (IDE) that allows you to code, debug, and run your programs all in one place.

What is an IDE?
An IDE helps programmers write code by providing useful features such as: - Syntax Highlighting: Makes reading code easier. - Error Checking: Points out potential issues while typing. - Integrated Terminal: Allows running code directly.

Steps to Set Up VS Code: - Install VS Code: Go to https://code.visualstudio.com/ and download. - Install Python Extension: Search for “Python” in the Extensions Marketplace (icon on the left sidebar). - Create a Python File: Open VS Code, click “New File”, and save it with the .py extension (e.g., hello.py).

Example Code:

# hello.py
print("Hello, world!")  # This line prints text to the console

# To run this script, open the Terminal in VS Code and type:
# python hello.py

2. Basic Python Constructs

Now that you have VS Code set up, let’s revisit some basic constructs.

Variables, Input, and Output

• Variables: Containers for storing values.
  • Example: age = 25 assigns the value 25 to age.
• Input and Output:
  • input(): Gathers input from the user.
  • print(): Displays information to the screen.

Example Code:

# Getting the user's name and age
name = input("What's your name? ")  # Input is always a string
age = input("How old are you? ")  # Collecting age as a string

# Output using formatted strings (f-strings)
print(f"Hello, {name}! You are {age} years old.")

Data Types

Python has different types of data: - Strings (str): Textual data (e.g., "Hello") - Integers (int): Whole numbers (e.g., 25) - Floats (float): Decimal numbers (e.g., 3.14)

You can convert data types:

# Convert age to an integer to perform math operations
age = int(age)  # Now age is an integer
print(f"Next year, you'll be {age + 1} years old.")

3. Working with Functions

Functions help us organize code into reusable blocks.

Function Basics: - Use the def keyword to create a function. - Functions can accept parameters and return values.

Example Code:

# Defining a function that greets a user
def greet_user(name):
    """
    Greet the user with their name.
    :param name: str - The user's name
    :return: str - A personalized greeting
    """
    return f"Hello, {name}!"

# Call the function
user_name = input("Enter your name: ")
print(greet_user(user_name))

Why Use Functions? - Reusability: Write code once, use it multiple times. - Readability: Break down complex tasks into smaller, easier parts.

4. Using the Command Line in VS Code

The command line is a powerful way to interact with your computer. In VS Code, you can use the Terminal to execute commands.

Basic Commands to Know: - ls: Lists all files and folders in the current directory. - cd <directory>: Changes the current working directory. - mkdir <folder_name>: Creates a new folder. - rm <file_name>: Deletes a file. - clear: Clears the terminal output for a cleaner workspace.

Example Walkthrough: - Open VS Code’s terminal (usually accessible with Ctrl + `` or from the menu). - Typemkdir my_new_projectto create a new folder. - Usecd my_new_projectto navigate into your new folder. - Typetouch my_script.py(in Linux/macOS) orNew-Item -Path my_script.py -ItemType File` (in Windows) to create a Python file.

5. Advanced Concepts: Scope and Side Effects

Scope in Python

Scope refers to where a variable can be accessed or modified.

• Local Scope: Variables defined inside a function only exist within that function.
• Global Scope: Variables defined outside all functions can be accessed by any code in the file.

Example Code:

greeting = "Hello"  # This is a global variable

def greet():
    local_greeting = "Hi"  # This variable is local to the function
    print(local_greeting)

greet()  # Output: Hi
print(greeting)  # Output: Hello
# print(local_greeting)  # Error: local_greeting is not defined here

Side Effects in Functions

Side Effects occur when a function modifies something outside its scope.

Example Code with Side Effects:

# Global variable
mood = ":("

def change_mood(new_mood):
    global mood  # Declare that you are using the global variable
    mood = new_mood

change_mood(":D")  # Now the global `mood` variable is ":D"
print(f"The current mood is {mood}")  # Output: The current mood is :D

Using global variables should be done with caution as it can make code harder to debug.

Additional Practice: Create a Python Script

Now that you’ve learned these concepts, create a Python script that: - Takes the user’s name and favorite number. - Defines a function to calculate the square of that number. - Prints a personalized message using the user’s inputs.

Example Solution:

# Function to calculate the square of a number
def square_number(num):
    return num * num

# Collecting user information
name = input("What's your name? ")
fav_num = int(input("What's your favorite number? "))

# Outputting a personalized message
print(f"Hello, {name}! The square of your favorite number is {square_number(fav_num)}.")

Summary

In Python Step 2, you learned: 1. Setting Up VS Code: How to install and use it for Python development. 2. Basic Constructs: Variables, input/output, and basic operations. 3. Functions: Defining, calling, and understanding parameters and return values. 4. Command Line Basics: Navigating with commands like ls, cd, and mkdir. 5. Advanced Concepts: Local and global scope, and understanding side effects in functions.

Additional Resources

• Python Documentation: https://docs.python.org/3/
• VS Code Documentation: https://code.visualstudio.com/docs
• CS50 Python Course: https://cs50.harvard.edu/python/

---

I’d like to make a lesson that feels like a tutor is talkiing directly to me. However my syntax will flip flop and not be consistent in narration audience. If you are reading this and you aren’t me. SOrry. (shrug) I want this to be super practical, hands-on, and easy to follow.

---

1. Basic Python Constructs: Variables, Input/Output, and Operations

1.1 Variables

Alright, so let’s start with the basics: variables. Imagine them as storage boxes. When I want to store something—like a name, a number, or even a list of things—I just put them in these “boxes” and give each box a name. That way, I know what’s inside.

Example:

name = "Jessica"    # String (text)
age = 25            # Integer (whole number)
height = 5.6        # Float (decimal number)

print(name)         # Outputs: Jessica
print(age)          # Outputs: 25
print(height)       # Outputs: 5.6

So, I just put "Jessica" in the box called name, and I can pull it out whenever I want by calling print(name).

1.2 Input and Output

Next up, input and output. This is just getting data from the user (input) and displaying it (output).

• print() is like me shouting out what’s inside the box.
• input() is me asking you for something, and what you give back goes right into a box.

Example:

# Getting input from the user
user_name = input("Enter your name: ")
print(f"Hello, {user_name}!")  # Uses an f-string to combine text and variables

With input(), I’m asking for your name. Whatever you type gets put in the box called user_name. Then, with print(), I use an f-string (which is just a fancy way to add variables to text) to say hello.

1.3 Basic Operations

You can also do math with variables. It’s like turning Python into a calculator.

Basic Math Operators are: - + for addition - - for subtraction - * for multiplication - / for division

Example:

# Simple calculator
x = 10
y = 5

print(x + y)  # Outputs: 15
print(x - y)  # Outputs: 5
print(x * y)  # Outputs: 50
print(x / y)  # Outputs: 2.0

I can use input() to get numbers and do calculations with them too:

num1 = int(input("Enter the first number: "))  # Convert input to an integer
num2 = int(input("Enter the second number: "))

result = num1 + num2
print(f"The sum of {num1} and {num2} is {result}")

Here, I used int() to convert the input from a string (text) to an integer (a whole number). That way, I can do math with it.

2. Working with Functions: Defining and Calling Reusable Code

Let’s talk about functions. Functions are one of my favorite things because they make my life easier. They’re like a recipe card: and I love cooking. I write the instructions once, and then every time I need that dish, I can just follow the same steps.

2.1 Defining Functions

To make a function, I use def, then give it a name, add parentheses, and a colon. Everything I want the function to do is indented below it.

Example:

def greet():
    print("Hello, world!")

# Calling the function
greet()  # Outputs: Hello, world!

So, here, greet() is my recipe card. Anytime I want to say “Hello, world!”, I just call greet().

2.2 Functions with Parameters

But what if I want to greet someone specific? That’s where parameters come in.

Example:

def greet_user(name):
    print(f"Hello, {name}!")

# Calling the function with an argument
greet_user("Jessica")  # Outputs: Hello, Jessica!

I’m passing in "Jessica" to the function, and it uses that to personalize the greeting.

2.3 Return Values

Sometimes, I need a function to give me back a result. For that, I use return.

Example:

def add_numbers(a, b):
    return a + b

# Calling the function and storing the result
sum_result = add_numbers(5, 10)
print(f"The sum is {sum_result}")  # Outputs: The sum is 15

The function add_numbers() adds two numbers and gives me the result with return. I then store that result in sum_result and print it.

3. Using the Command Line: Navigating in VS Code

Now let’s jump into using the command line. It’s basically a way to talk to your computer without clicking around. In VS Code, it’s super handy for running Python files, managing folders, etc.

3.1 Common Command Line Commands

• ls: This lists everything in the current folder.
• cd <directory>: This changes where you are in the computer’s file system.
• mkdir <folder_name>: This creates a new folder.
• rm <file_name>: This deletes a file.
• clear: This clears out all the text in the terminal.

Example of Using the Terminal in VS Code: 1. Open Terminal: Use `Ctrl + `` (that’s the backtick under Esc). 2. Commands to Try: sh mkdir my_python_project # Create a new folder cd my_python_project # Move into that folder touch hello.py # Create a new Python file called 'hello.py' 3. To run my Python script: sh python hello.py And that’s how I run the code I’ve written in a terminal.

4. Advanced Concepts: Variable Scope, Side Effects, and Code Organization

4.1 Variable Scope

Scope is where my variables live and where they can be used.

• Local Scope: Variables that I create inside a function. They can only be used within that function.
• Global Scope: Variables I create outside of functions that can be used anywhere in the program.

Example:

greeting = "Hello"  # Global variable

def greet():
    local_greeting = "Hi"  # Local variable
    print(local_greeting)

greet()             # Outputs: Hi
print(greeting)     # Outputs: Hello
# print(local_greeting)  # This would cause an error because local_greeting only lives inside greet()

So, local_greeting only exists inside greet(). Outside of greet(), it’s gone.

4.2 Side Effects

Side Effects happen when I use a function that changes something outside its own scope. It’s like when I mess around with a global variable inside a function.

Example of a Side Effect:

mood = ":("  # Global variable representing a mood

def change_mood(new_mood):
    global mood  # I use 'global' to tell Python I’m changing the global variable
    mood = new_mood

change_mood(":D")  # I call the function to change the mood
print(f"The current mood is {mood}")  # Outputs: The current mood is :D

I have to be careful when doing this because changing global variables can lead to bugs that are hard to find.

4.3 Organizing Code with Functions

Functions really shine when I’m trying to keep my code organized. Instead of a huge mess of commands, I break things down into little steps (functions), making it easier to manage.

Example:

# Function to collect user details
def get_user_details():
    name = input("Enter your name: ")
    age = int(input("Enter your age: "))
    return name, age

# Function to display greeting
def display_greeting(name, age):
    print(f"Hello, {name}! You are {age} years old.")

# Main function to run the program
def main():
    user_name, user_age = get_user_details()
    display_greeting(user_name, user_age)

# Call the main function to start the program
main()

Breaking things down this way helps me keep my brain from getting overwhelmed, and I can focus on solving one part of the problem at a time.

Summary

In this lesson, I covered: 1. Basic Constructs: How to use variables, get input, display output, and do math. 2. Functions: How to write reusable blocks of code, use parameters, and get return values. 3. Command Line in VS Code: How to move around your files and run Python scripts. 4. Advanced Concepts: The idea of scope (local vs global), side effects, and keeping code organized with functions.

Practice Challenge

• Create a Python script where you:
  1. Ask for a user’s name and their favorite number.
  2. Write a function that doubles the number.
  3. Use a global variable to count how many times the program has been run.
  4. Print out the doubled number and how many times the script has been executed.

The goal is to be able to write python code without even thinking about it.

review and review and practice this lesson, implementing other tactics and comparing results. Finger muscle memory and habits need to be built. Keep at it. JESSICA YOU MUST FUCKING PRACTICE. JESSICA. KEEP AT IT. YOU WILL NEVER RELY ON ANYONE TO TAKE CARE OF YOU. IN ORDER TO BE SUCCESSFUL YOU MUST BE DRIVEN PRACTCE IS THE KEY TO MASTERING THIS SHIT! YOU CAN DO IT. THIS IS NOT JUST FOR YOU - ITS ALSO FOR YOUR KIDS. YOU NEED THIS. WE DON’T BREAK. WE ACCELARATE AND MOVE FORWARD ON A BETTER PATH THAN BEFORE. NOW TAKE 5 THEN DO THIS ALL AGAIN.