Berk Tunctan - Spring 2024

The Main Idea

Python

Python is an interpreted, high-level programming language. As a general-purpose language, it is used for a variety of applications, which makes it an obvious choice for computational physics models, considering its shallow learning curve and syntactically simplistic features. It is also OS-independent, allowing it to be run on virtually any machine. Python has a unique design through its emphasis on code readability by having a notable use of significant indentation.

Python is primarily used for web development, software development, mathematics, and system scripting. Some more things python can do are:

Be used on a server to create web applications.
Be used alongside software to create a workflow.
Connect to database systems to read and modify files.
Handle big data and perform complex math operations.
Be used for rapid prototyping, otherwise known as production-ready software development.

Python is used over other languages for many various reasons. Its simple syntax allows developers to write programs with fewer lines than some other programming languages. It also runs on an interpreter system, allowing for code to be executed as soon as it is written.

VPython

VPython is an extension of the Python programming language that contains a 3D graphics module called Visual, which allows users to create simple simulations of physics problems. It allows its users to create objects such as spheres and cones and displays these objects in another window. Its primary use is for educational purposes, although it has been used in research before in the past. Although VPython slightly differs from the actual Python programming language, the majority of the functionality remains the same, including all syntax. For the sole purpose of this class, however, it is functionally equivalent to Python, which is why it is imperative to understand the underlying Python language. Most of the labs done this year (which includes any labs requiring the construction of a physics simulation model) will be done using the VPython.

Glowscript

GlowScript is a programming environment for making 3D models and simulations using VPython. Unlike traditional desktop applications, GlowScript runs in the web browser, allowing you to write and run your VPython scripts online without needing to install any software on your computer.

Python in Physics

Python helps with people's understanding of physics concepts and systems through modeling. Python makes it easier for physicists to do calculations with vectors, matrices, and graphs. It is also an easy language that has a fast compiling speed. Creating these computational models help students visualize what is going on in the system. In higher-level physics classes, we will often use python to build computation models for labs and use it to calculate and show concepts such as electric fields, magnetic fields, magnetic forces, and magnet dropping.

Downloading/Installation

Versions

Python has two major versions: Python 2 and 3

However, on January 1st, 2020, version 2.x was officially deprecated and no longer officially supported by the Python Foundation. As a result, the majority of the Python community has already migrated away from the dying version. In any case, Python 2.x has significant syntactical differences that Python 3.x is not backward-compatible with (hence, the major version change), which is why this course will be attempting to adhere to the guidelines set by Python 3. The most current version of Python is Python 3.11.3, which was released on October 24, 2022.

Downloading

The latest stable version of Python 3 available is 3.11.3 (as of April 2023).

Older versions of Python 3 can be found at https://www.python.org/downloads/.

For the purposes of this class, it is not necessary to download and install VPython, as we will be working with VPython through the virtual GlowScript environment.

Python Basics

Syntax

One of the most important components of Python syntax is indentation. Indentation refers to the spaces at the beginning of a line of code, which can also be achieved by using the tab button. While in some programming languages indentation is only used for aesthetic purposes, indentation is necessary for the functionality of code in Python. The number of spaces needed is up to you as the programmer, but it must be at least one. If the indentation is skipped, Python will give the user an error message, and the code will not be able to run. The indentation will be necessary for your if-conditions, for-loops, while-loops, and more.

Comments

Comments are useful when you want to include a note or a quick explanation in your code that will make it easier to understand later. Comments are sections of code that the computer will skip in execution, so it will not actually be executed when your program runs. There are two types of comments that Python uses, single-line comments and multi-line comments.

Single Line Comments

To create a single-line comment (the most common comment in Python) type a hash character (#) at the beginning of anything you would like to comment out. Note, when "#" is in a line of code, the rest of the code following the # will be ignored by the computer when your code runs.

# This is a comment.

a = 4 # and so is this

# b = 4 # and so is this entire line, be careful!

Here is an example of comment use that you might see in a lab:

myTemp = 4 #This is the temperature in Celsius.

Multi-line Comments

To create a multi-line comment (usually reserved for longer explanations or instructions that cannot fit on one line) type three quotation marks (single or double), like so:

""" this 
    is
    a
    multi-line
    comment """

""" this is also an example, but on only one line"""

'''
this
is also
a
multi-line
comment! 
'''

Be careful! Unlike the single line comments, multi-line comments require a start and a stop (if you forget to close your comment or forget the third quotation mark then that will cause an error in your code).

Main Uses

- Longer variable explanation (units, where the data comes from, etc)

- Comment out code (to save for later, instead of deleting it)

- Instructions

- Notes to self

Variables

Variables in Python are named items/containers that allow data to be stored. The variables are only stored during the execution of the program; after the program finishes, the variables are no longer retained. Python is an Object-Oriented Programming (OOP) language, which means that variables can be thought of as "objects" or abstract data types representing various forms of information.

Declaring a Variable

Python has no specific command for declaring a variable. Instead, a variable is created the moment a user assigns a value to it. Variables are assigned with an = (equals) operator. Unlike other programming languages, Python does not require explicit types to be defined when declaring variables. The types are inferred during runtime, as it is an interpreted language. Hence, the only information needed for the assignment is the variable name and data to assign. Python variables can have any name, but they must start with a letter or underscore. It's important to note that the underscore is generally reserved for library variables, so it is best to stick with letters. It also can only contain alphanumeric characters and underscores (A-z, 0-9, and _). Here are a few examples of variable assignments:

x = 7
long_variable_name = [0, 1, 2, 3, 4]
CAPITAL_VARIABLE_NAME = {'apple', 'orange', 'banana'}
_starts_with_underscore = {'yes': 1.0, 'no': 0.0}  # Try to avoid this type of naming if possible!

It is possible to assign a new variable to a variable that has already been assigned as well. The new variable will store the information that the original variable was already assigned.

x = 7
reassigned_variable = x  # Final value of reassigned_variable is 7, because x is 7

Data Types

Variables can be of different types that determine their behavior.

Numerical Data Types

Numerical data types represent numbers and can be to perform mathematical calculations.

Integer

An integer is a whole number. It can be positive or negative but cannot contain any decimals. Integers have unlimited length.

Examples of integers are:

x = 1
y = 3452374791834
z = -289

Float

A float, also known as a "floating point number," is a number that contains one or more decimal. A float can be either positive or negative.

Examples of floats are:

w = 24e4
x = 10.2
y = 1.0
z = -23.9

Note that a whole number can be made a float by adding a .0 at the end of the number. Floats can also be scientific numbers with an "e" to indicate a power of 10.

Complex

Complex numbers are numbers that be expressed in the form a + bi, where a and b are real numbers, and i is a symbol representing the imaginary unit. The imaginary unit satisfies the equation [math]\displaystyle{ i^2=-1 }[/math]. In python, complex numbers are written with a "j" to represent the imaginary part.

Examples of complex numbers are:

x = 3+5j
y = 5j
z = -8j

Boolean

Booleans represent one of two values: True or False. They are a powerful tool to allow the user to control the flow of their code. Comparisons are often evaluated to return a Boolean answer. Some examples of comparisons are:

10 > 9 # True
10 == 9 # False
10 < 9 # False

Note that == is used when seeing if two integers are the same or not. This is because = is reserved for declaring variables. Be careful to not use = in a comparison.

Equivalence in Python is dependent on the value and type of the compared items. The types must correlate for the equivalence to hold true, (i.e., numerical data types must correlate to other numerical data types even if the values appear to be the same).

4 == 4 # True
18 == 18.0 # True

Comparing elements of different types results in false:

a = "9"
b = 9

a == b # False

Booleans in Python are numerical data types, meaning that they represent numbers. They are special type of integer value and can be used to perform arithmetic operations. True == 1 and False == 0.

True + True # 2
True + False # 1

Note that in Python, any data type can be interpreted as a boolean. For example, numerical data types are interpreted as False if they are equivalent to 0 and true otherwise.

31234 == True # True
0 == True # False
0 == False # True

Collections of data are interpreted as False if they are empty and True otherwise.

[0,1,3,4,5] == True # True
[] == False # True

Iterable Data Types

String

Strings are sequences of characters, including alphabetical characters and numerical ones. They are surrounded by either single, double, or triple quotation marks. Strings are immutable, meaning that once they are defined, they cannot be changed. Only certain Python methods such as replace(), join(), or split() can modify strings.

Examples of strings are:

a = "hello"
b = 'c'
c = '934'

Note that while the variable c appears to be made up of numbers, it is still a string because of the quotation marks. Because of this, it is treated as purely text and does not contain any numerical or mathematical data. Therefore, it cannot be used in mathematical operations until it is converted to a numeric type.

Strings can be indexed see List.

List

Lists in Python can be used to store multiple items in a single variable. They are created using square brackets and can contain different data types. Lists are mutable, meaning that the user can change, add, and remove items in the list even after it has been created. They may contain any data type, including other lists.

Examples of lists are:

my_list = ["dog", "cat", "bird"]
number_list = [9, 0, 3, 4]
mixed_list = ["tree", 2, 0, "frog"]
list_list = [[1,2,3],[4,5,6],[7,8,9]]

To access specific elements of the list, Python uses indexing. By indexing into a list, the user can get the data at a specific spot. Note that indexing starts at the number 0, meaning that the first item in the list can only be accessed by using the number 0.

my_list[0] # "dog"
number_list[1] # 0
mixed_list[3] # "frog"
list_list[0] # [1,2,3]

To access the last element of a list, use -1 when indexing.

my_list[-1] # "bird"
number_list[-1] # 4

In lists containing lists, you may double index, treating the list as a 2d array. Treat the first index as the row and the second index as the column.

list_list[0][0] # 1
list_list[2][2] # 9

Since lists are mutable, they can be updated without having to reassign the list.

num_list = []
num_list.append(1)
num_list.append(2)
num_list.append(3)
print(num_list) # [1, 2, 3]

Tuple

Like lists, tuples are also used to store multiple items in a single variable. However, unlike lists, tuples are immutable, meaning that they cannot be changed once created. Tuples are created using parentheses. A comma is necessary in the creation of a tuple. Therefore, to create one item, you have to add a comma after the item, otherwise, Python will not recognize it as a tuple.

Examples of tuples are:

my_tuple = ("cookies", "cake", 1912)
boolean_tuple = (True, False, True)
single_tuple = (5,)

Tuples can also be indexed into like lists.

Misc. Data Types

Dictionaries

Dictionairies are collections of key-value pairs. Keys are used to access elements, but instead of using numbers, the user may use any value. Each key must be unique and is used to store and retrieve the corresponding value. Dictionaries are mutable, which means that you can add, remove, or modify entries after the dictionary has been created. Dictionaries in Python are written with curly braces, with keys and values separated by a colon.

Examples of dictionaries are:

my_dict = {"name": "Alice", "age": 25}
book_info = {"title": "1984", "author": "George Orwell", "published": 1949}
ball = {"mass": 10, "speed": 40}

You can access the value associated with a specific key using the key name inside square brackets:

my_dict["name"]  # Alice

Type Conversion

Some data types in Python can be converted from one type into another with certain methods. It's important to use the same type when using operations in Python. Only numeric data types can be used in mathematical operations. It is possible to convert a string into a number data type with type conversion.

To convert from one type into another, use int() or float() methods.

x = 3 # int
y = 2.9 # float
z = "4" # string

# convert from int to float:
a = float(x)

# convert from float to int:
b = int(y)

# convert from string to int:
c = int(z)

Note that you can only convert strings if they only contain numerical digits.

my_string = "four"
my_num = int(my_string) # ERROR

Operators

Operators are symbols used to transform data.

Arithmetic Operators

Mathematical operations include:

# Addition: 
1 + 2  # This will equal 3

# Subtraction: 
2 - 1  # This will equal 1

# Multiplication: 
2 * 1  # This will equal 2

# Division:
2 / 1  # This will equal 2

# Exponentiation: 
2 ** 2  # This will equal 4

# Remainder: 
5 % 4  # This will equal 1

Methods

# Absolute value:
abs(-3)  # This will equal 3

Assignment Operators

The equal sign = is used to assign a value to a variable and allows it to be reused. The value on the left is the variable, and one on the right is the value to be assigned to the variable. Operation may be used in the assignment of variables.

x = 3
y = 4
z = y + x # z is 7

To update a variable, the variable must be reassigned with the = operator. However, the variable itself may be used in the reassignment. This can be used to perform the specified mathematical operation on a variable, and then store the resulting value back into the variable. In order to use assignment operators, you must specify the variable name, followed by the operator symbol with an = (equals sign), and finally the value.

x = x + 3 # adding 3 to x

When using arithmetic operators, for for ease of convience, this statement could be simplified into:

x += 3 # equivalent to x = x + 3

This will be frequently used in physics simulation models, as variables often needed to be updated in this format.

String Concatenation

Strings of text can be combined using the + operator. a = "hello " b = "world" c = a + b # combines to "hello world"

Note that text containing numbers will not be added together. Instead, they will be attached. a = "5" b = "1" c = a + b # combines to "51", not "6"

Comparison

Comparing elements in Python uses the == operator.

x = 1
y = 1
x == y # outputs True because x equals y
y == 5 # outputs False because y does not equal 5

CAUTION: == and = are not interchangeable and using them as such will lead to errors. == is used only for comparison and checking equivalence while = is used only for assignment.

Boolean Operators

Booleans are a data type that represent truth values. Boolean logic is the chaining of truth values can be represented in Python using the and and or operators.

and

The and operator is used to check if all inputted values are True.

True and True # outputs True because both values are true

If a single input is False, then the entire statement will be False:

True and False # False
False and False # False

or

The or operator is used to check any inputted value is True.

True or True # True
True or False # True
False or False or False or False or False or True # True

If there is not a single input is True, then the entire statement will be False:

False or False # False

Boolean Operators can also be used inconditional expressions.

x = 1
y = 2
(x == 1) and (y == 2) # outputs True because both conditions are true

x = 2
y = 3
(x == 1) or (y == 2) # outputs False because neither condition is true

Print Function

In order to see any of the information we’ve listed above, you have to actually print it. For example, the code below will run but will not provide you with an output.

x = 1 + 1

Instead, you have to print this information in order to see the answer when the code is finished running. You can do this in two ways. First, you can directly embed the code in your print statement.

print(1 + 1)

Or, you can create the variable and then print the variable.

x = 1 + 1
print(x)

Either one is valid! If you would like to print something other than a variable, include quotations around it. For example, if you wanted to print the typical 'Hello, world!', you would code:

print('Hello, world!')

The quotations are the important takeaway here.

Another common use case for the print statement is to display a hard-coded string along with a variable. This can be done by casting the variable to a string and "adding" it to the hardcoded string:

s = 'Hello, world #'
number = 3
print(s + str(number) + '!')  # Hello, world #3!

Uses

Printing is incredibly useful in debugging code. If you are getting an unexpected result, it can be quite difficult to tell what is going on as your code is running. With `print()`, it becomes easier to track what the code is doing and what variables equal at various points in the code's execution.

Conditional

if statement

A conditional involves an “if” statement. “If this thing is true, do this”, for example. Conditionals are useful in physics if you want to perform different things on a variable, depending on certain conditions.

if x > 1:
	print("x is greater than 1")

else statement

If the if condition is False, we can use an else keyword to run code if and only if the if conditional fails.

if x > 1:
	print("x is greater than 1")
else:
   print("x is NOT greater than 1")

elif statement

To chain multiple conditionals, we can use the elif keyword, (i.e., else if).

if x > 2:
	print("x is greater than 2")
elif x == 1:
   print("x is equal to 1")
elif x == 0:
   print("x is equal to 0")
else:
   print("x is less than 2 and not equal to 1 or 0")

Notice the conditional starts with an if statement, followed by a colon. The code inside of the if statement tells the code what to do if the if statement is True and must be indented. If the condition is not met and the if does not equal True, it moves on to the elif statement. elif statements should only used after if statements, and cannot be used independently. There can be any number of elif statements, but only one if statement. Notice this uses the same syntax as the regular if statement. Lastly, if neither the if nor the elif statement(s) are True, there is an else statement. There can also be only one else statement, though it is not required.

Another important issue regarding if and other statements is the code block formatting. Code within the conditional block must be indented.

Loop

Loops are powerful tools that are used to repeated run a block of code without having to rewrite it.

While Loops

A while loop is similar to a repeated if statement. It repeatedly executes a piece of code until a certain condition no longer holds true. In physics, they are most often used to update an object over a certain amount of time.

ball.pos.x = 5 # ball's x position
t = 0
deltat = 0.1
while t < 1:
    ball.pos.x += 1 # ball's x position increases by 1 every 0.1 seconds
    t += deltat

For Loops

A for loop is used when iterating over an iterable sequence, such as a list, tuple, or string. When using for, the program iterates through each element of the sequence

To print each component of a list of animals:

animals = ["dog", "cat", "bird"]
for animal in animals:
    print(animal)

To print each letter in the word "yellowjackets":

for character in "yellowjackets":
    print(character)

To print each number in a range from [0, 5):

for i in range(5):
    print(i)

Nested Loops

A loop may contain loops within them. A loop that contains another loop inside it is called a nested loop. Here is an example of a nested loop:

students = ["Sam","Joe","Fred"]
snacks = ["cookies","chips","candy"]

for student in students:
    for snack in snacks:
        print(student + " got " + snack)

This nested for-loop goes through every element of both of the lists and gives each snack to each student.

Functions

Functions are code blocks that take in an input and execute some code. They help you organize your code and reduce repetition.

A simple example of a function is:

def currentYear():
    print("2022")
currentYear() # This line calls the function to be executed

Functions always start with the def keyword. Once the function is created, it can be reused over and over again. A function must be created before it can be used. An example of that is the print function. The example below is a function that takes in the parameters x and y.

def add(x, y):
   sum = x + y
   print(sum)

This example contains two functions: mult(x, y) and print()

Return Variables

Functions can be used to output a value using the return keyword. This is the output of the function. This value can then be used elsewhere. One common application is to use the print() function to show what is returned.

def mult(x, y):
   return x * y
product = mult(5, 5)
print(product) # will print 25

In this example, product stores the return value of the function mult(x, y).

Error Handling

"Ask for forgiveness, not permission". The try and except statement handles exceptions. Exceptions are errors that happen when you run a program. Sometimes, we want to execute code when an error occurs, and for this, we can use a try and except statement to solve the problems.

Exceptions

Python has built-in exceptions such as the FileNotFoundError, ImportError, and ZeroDivisionError, If an exception occurs, one of the exceptions will be thrown. Developers will need to deal with the exceptions thrown or the program will crash. This is when the try-catch block is used. Here is a sample structure of the try-except block:

try:
    <do something>
except Exception:
    <handle the exception>

try: the code that may have an exceptions. If an exception is raised, this block of code immediately terminates and jumps straight into the except block

except: this block of code executes only if the try block raises an exception. It cannot be on its own and requires a try block before it.

else: this block is only executed if no exceptions are raised in the try block.

finally: the code in this block is always executed at the end whether the try block raises an exception or not. Here is some example code:

def fail():
    1 / 0 # this raises an exception because a number cannot divide by 0
try:
    fail()
except ZeroDivisionError:
    print("cannout divide by 0")
finally:
    print("continue")

The output of this code is as follows:

exception occurred
continue

Import

Import is a special keyword in Python that allows us to external libraries into our code. A library is a collection of functions and other components that can be used to extend the functionality of Python. VPython is an example of such external library.

`math` module

The math module is the one of the most commonly used modules in Python development as it allows you to use more complex math equations. Importing the math module is as follows:

import math

Once imported, you can access all of its functions by prefixing them with math.. Here are some of the most commonly used functions provided by the math module:

math.sqrt(x): Returns the square root of x.
math.pow(x, y): Returns x raised to the power of y. 
math.sin(x): Returns the sine of x (x in radians).
math.cos(x): Returns the cosine of x (x in radians).
math.factorial(x): Returns the factorial of x.
math.log(x, base]): Returns the logarithm of x to the given base, uses the natural logarithm if no base is specified.
math.pi: The mathematical constant π.
math.e: The mathematical constant e, which is the base of natural logarithms.

Here’s a simple example demonstrating how to use some functions from the math module:

import math

# Calculate the square root
print("Square root of 16 is:", math.sqrt(16))

# Calculate power
print("3 raised to the power of 4 is:", math.pow(3, 4))

# Trigonometric functions
angle = math.pi / 4  # 45 degrees in radians
print("Cosine of 45 degrees is:", math.cos(angle))
print("Sine of 45 degrees is:", math.sin(angle))

# Logarithm
print("Natural logarithm of 10 is:", math.log(10))
print("Logarithm base 10 of 100 is:", math.log(100, 10))

# Constants
print("Mathematical constant pi:", math.pi)
print("Mathematical constant e:", math.e)

Examples

This is an example of using Python to implement a mathematical model. For the gravitational principle, it is known that the force of gravity is:

[math]\displaystyle{ |F_{G}| = G \frac{M_{1} M_{2}}{R^{2}} }[/math]

We can use this knowledge to create a variable called gravitational_force, and assign it the magnitude of the gravitational force between objects [math]\displaystyle{ M_{1} }[/math] and [math]\displaystyle{ M_{2} }[/math]. Given variables m1, m2, and r, the Python code would be:

gravitational_force = 6.67 * 10 ** -11 * m1 * m2 / (r ** 2)

Normally, in a Python physics model, we would have an outer loop that updates the variables and values for each iteration, which is where an update statement such as this would go. This could be used to determine the variable gravitational force on a skydiver jumping from a great height, as the force would not remain constant. In a finalized GlowScript model, this would look like this:

GlowScript Simulation

Connectedness

As a high-level and syntactically simple language, Python is an excellent choice for the development of complex systems. Proficient knowledge of Python is critical to implementing scientific models, machine learning algorithms, and much more.

History

The concept of the Python programming language was developed in the late 1980s. In 1991, Guido van Rossum created the first version of the Python programming language, releasing it with the original intent of code readability (thanks to its use of whitespace and indentation).

In 2000, Python 2 was released which contained several new backwards-incompatible features, such as list comprehension and a garbage collection system.

The first version of Python 3 was released in 2008, while Python 2 was still in use, creating a rift between Python developers on version usage.

Finally, on January 1st, 2020, Python 2 reached its end-of-life date, no longer officially supported by the Python Software Foundation.

Python Syntax