CS50 Intro to Python

• This is CS50's Introduction to Programming with Python, taught by Dr. David Meen.
• The course is designed for students with or without prior programming experience.
• The course focuses specifically on programming in Python.

Course Topics

• Functions and variables: mechanisms to write code that solves smaller problems, composed into solutions for larger problems.
• Conditionals: expressing logic in code to do something if a question is true or false.
• Loops: the ability in code to do something again and again some number of times.
• Exceptions: handling errors in code defensively so users don't see them.
• Libraries: using third-party code to avoid reinventing the wheel.
• Unit tests: writing code to test your code, ensuring correctness and preventing breakage from future changes.
• File I/O (input/output): storing information persistently to files and folders.
• Regular expressions: defining patterns in Python to validate data and extract data from datasets.
• Object-oriented programming: representing real-world entities in code.
• Procedural programming: writing functions/procedures top to bottom to solve problems step by step.
• Functional programming: writing programs using the principles of functional programming.

Course Structure

• Each week includes lectures introducing concepts.
• Each week includes problem sets (programming projects) to apply the lessons learned.
• The course equips students with tools and skills to solve real-world problems.

Week 1: Functions and Variables

• The lecture introduces functions and variables in Python.
• Visual Studio Code (VS Code) is a popular program for writing code.
• A text editor is needed to write code, as code is essentially text.

Writing and Running a Simple Program

• Programs in Python have a file name ending in .py.
• Example: print("hello, World") is a simple program that prints "hello, World".
• The terminal window is a command-line interface (CLI) for interacting with the computer.
• To run a Python program, use the command python hello.py.
• Python is an interpreter that translates code into zeros and ones that the computer understands.
• Functions are actions or verbs that allow the program to do something.

Functions and Arguments

• The print function is used to display text on the screen.
• An argument is an input to a function that influences its behavior.
• The program's output on the screen is called a side effect.

Bugs

• A bug is a mistake in a program.
• Syntax errors occur when the code doesn't follow the language's rules.

Improving the Program

• The program can be improved to be more interactive by asking the user for their name.
• The input function is used to get input from the user.
• The input function takes a string as an argument, prompting the user for input.
• Functions can have return values.
• A variable is a container for storing a value in the computer's memory.

Variables and Assignment

• The equal sign (=) is the assignment operator, copying the value from right to left.
• Example: name = input("What's your name? ") stores the user's input in the variable name.

Comments

• Comments are notes to yourself in your code, ignored by the computer.
• In Python, comments start with the hash symbol (#).
• Comments are used to explain what the code is doing.

Pseudo Code

• Pseudo code is using English or another human language to outline a program.
• It helps to break down a bigger program into smaller tasks.

String Data Type

• According to its documentation, the input function will return a string that is a sequence of text be it in English or any other human language
• String - str is term for a sequence of text in python.
• The plus operator (+) is used for concatenation of strings.
• Functions take arguments that influence their behavior.

Python Official Documentation

• Python's official documentation is located at python.org.
• The documentation contains available functions with specific documentation.
• Reading the documentation is crucial for learning a programming language to find answers, but it requires practice.

Print Function Parameters

• "print(*objects, sep=' ', end='\n')" is the official documentation syntax for the print function.
• Parameters are the potential arguments a function can take, while arguments are the actual values passed when the function is used, but they refer to the same thing.
• *objects indicates the print function can take any number of objects (zero, one, or multiple strings).

Separator Parameter (sep)

• sep is a parameter for "separator," with a default value of a single blank space (" ").
• Determines separation between multiple arguments passed to print.
• Overriding the default sep value changes the separator between printed arguments.
• Example: sep="???" results in arguments separated by "???".

End Parameter (end)

• end is a parameter with a default value of \n (newline character).
• By default, the print function ends every line with a new line.
• Overriding the default end value changes what is added at the end of the line after printing.
• Example: end="" overrides the default newline, causing the next print statement to continue on the same line.

Positional vs. Named Parameters

• Positional parameters are based on the order they are passed to the function.
• Named parameters can be passed in any order by calling them by name, and are optional.
• sep and end are named parameters.

Printing Quotation Marks

• To include literal quotation marks in a string, you can use single quotes as the outer quotes and double quotes within.
• Alternatively, use backslashes () to escape the inner double quotes, indicating they are literal quotes.

Format Strings (F-strings)

• F-strings are a relatively new feature in Python that allows embedding and formatting variables directly within string literals.
• To use an f-string, prefix the string with the letter "f" (e.g., f"Hello, {name}").
• Variables or expressions within curly braces {} inside the string are evaluated and their values are inserted into the string.

String Manipulation

• Input from users may contain errors, like unintentional spaces or incorrect capitalization.
• Strings in Python have built-in functionality (methods) for manipulation and cleaning.

Strip Method

• The .strip() method removes whitespace (spaces, tabs, newlines) from the beginning and end of a string.
• name = name.strip() assigns the stripped value back to the original variable.
• The equal sign (=) in programming means right to left assignment, not equality
• The value of variables can be changed using the assignment operator (=).

Capitalization of User Names in Python

• Capitalize function only capitalizes the first letter of a string
• Title function capitalizes the first letter of each word in a string, like in a book title or person's name

Combining String Functions

• Multiple string functions can be chained together for more concise code
• Chaining involves applying functions sequentially from left to right
• Example: name.strip().title() first removes whitespace, then title-cases the string

Readability vs. Conciseness

• Combining too many functions in one line can reduce readability due to complexity and line length
• Breaking code into multiple lines might improve understanding, especially for complex operations

Removing Whitespace

• Strip function removes whitespace from both ends of a string.
• Lstrip removes whitespace from the left side of a string.
• Rstrip removes whitespace from the right side of a string.
• Strip does not remove spaces between/within words

Splitting Strings

• Split function divides a string into multiple substrings based on a delimiter.
• Example: name.split(" ") splits the name string into first and last names, based on space
• Python allows assigning multiple values from a sequence to variables at once using first, last = name.split(" ")

Integers in Python

• Integers (int) are whole numbers without decimal points.
• Python supports common mathematical operations on integers such as addition (+), subtraction (-), multiplication (*), division (/), and modulo (%)

Interactive Mode in Python

• Python has an interactive mode:
  • Code is executed immediately without needing to save to a file
  • Useful for quick testing and calculations
• Accessed by running python in the command line without specifying a file
• The >>> prompt indicates interactive mode

Calculator Program Example

• A simple calculator program can be created in Python to perform addition
• Variables can be declared to store numbers and the result of the addition
• Print function is used to display the result to the user

Interactive Calculator Program

• A basic calculator program is introduced, initially performing a fixed calculation of 1 + 2 = 3.
• The program evolves to accept user input for the values of x and y, making it more interactive.
• The input() function is used to receive values from the user.

String Concatenation Issue

• Initially, the program concatenates user inputs as strings instead of adding them numerically
• The + operator behaves differently for strings (concatenation) compared to numerical values (addition).
• User input is received as text (string) by default, even if it looks like a number.

Type Conversion with int()

• The int() function is introduced to convert string inputs to integers
• Conversion is necessary for performing mathematical operations on user-provided numbers.
• The int() function can convert a string to an integer if the string represents a valid number.
• The corrected program uses int(x) + int(y) to perform addition correctly.

Code Optimization

• The removal of the z variable is discussed as a potential optimization.
• The code is refactored to directly print the sum x + y without storing it in an intermediate variable.
• Nested functions: int() inside input()
• The refactored code uses nested function calls: int(input()).
• Arguments for the print function can make code more intuitive and less cluttered

One-line Code Consideration

• Combining the entire calculator program into a single line of code is possible but discouraged.
• Readability is prioritized over conciseness, especially when multiple function calls are nested.
• The example one-liner uses nested int and input functions in the print statement

Introduction to Floats

• A float is defined as a number with a decimal point.
• Python supports floats, integers, and strings.
• The calculator program is modified to support floating-point numbers using the float() function for type conversion.
• By changing int() to float(), the program can now handle floating point numbers.

Rounding with round()

• The round() function is introduced to round floating-point numbers to the nearest integer.
• Square brackets in documentation indicate optional parameters
• round(number) rounds to the nearest integer by default.
• round(number, digits) rounds to a specific number of digits after the decimal point.