Python Syntax

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.

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.

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

Numerical Data Types

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

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 parantheses. 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 perform mathematical manipulations and operations to data. Some of the simplest 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

There are other operations that are more complex than these, such as:

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

# Remainder: 
5 % 4  # This will equal 1

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

# Square root: 
sqrt(4)  # This will equal 2

# Euler's number:
exp(1)  # This will equal e^1

Another useful category of operators is known as assignment operators, which 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. For instance, it is possible to add 3 to the value of x and store it in x again like so:

x = x + 3

However, this statement could be simplified into:

x += 3

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

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

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

A loop iterates through each item in a list or range. One use of loops in physics is to update equations. Loops will automatically update the information for you, rather than having to write out the long iterative process yourself. Note that the block of code under a loop must be indented otherwise it will not work as intended.

While Loops

A while loop will often be used in physics to update time. With a while loop, a set of statements can be executed as long as the condition is true. For physics, this is often used when time is below a certain point. Within the while loop, time is incremented to mock the passing of time until the while loop is no longer true.

t = 0
deltat = 0.1
x = 1
while t < 1:
    x += 1
    t += 1

After this is executed, x will equal 10.

For Loops

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

To print each component of a list of animals:

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

To print each letter in the word "yellowjackets":

for x in "yellowjackets":
    print(x)

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

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

Equal Signs

“=” and “==” mean two different things in Python. When assigning a variable to a value, you use one equal sign:

x = 2

However, when you are using it to check if something is equal to another thing (i.e. in an if statement), you use two equal signs:

if x == 2:
	print(“x equals 2")

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

Data and Operatons

Functions

Functions are small parts of repeatable codes that accepts parameters. They help you organize your code and reduce repetition in codes.

Functions

A simple example of a function is:

def currentYear():
    print("2022")
currentYear()

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

def f(x,y):
    return x*y
print(f(2,3))

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

Return Variables

Functions return variables. This is the output of the function and we usually use the print() function to show what is returned.

result = f(2,3)
print(result)

In this example, result is the return value and output of the function.

Lists

List is a collection that can hold many variables. Lists can hold all kinds of variables such as integers, floats, characters, texts, and more.

Empty List

An empty list is a list that contains nothing. We initiate a list by creating an object and letting it equals to a set of empty brackets.

list = []

Define List

Other than an empty list, you can create a list that contains numbers:

list = [1,2,3,4,5]

Or a list that contains characters or strings:

list = ['A','B','C']

To access a certain element in the list, you will need to know the index of the character. The index start with 0 and continues to add up. For example, if we need to access B in the second list, you will write this:

char = list[1]
print(char)

Add to a List

You can create an empty list and add to it. The print statement will result in [1, 2, 3].

list = []
list.append(1)
list.append(2)
list.append(3)
print(list)

Accessing a List

You can access a list using indexing. Python begins indexing from 0. The print statement will result in 1.

list = [1, 2, 3]
print(list[0])

Nested Loops

A loop can contain one or more than one loop. A loop that contains a loop inside it is called a nested loop. The most number of loops we want to contain in a loop is 2 to keep the confusion away. Here is an example of a nested loop: We first create two lists

teachers = ["Sam","Joe","Fred"]
classes = ["physics","math","english"]

we want each of the teachers to teach all the classes:

for teacher in teachers:
    for class in classes:
        print(teacher + "teach" + class)

This nested for-loop goes through every element of both of the loops to get all classes assigned to one teacher.

Try and Except

"Ask for forgiveness, not permission". The try and except statement handles exceptions. Exceptions are error that happens when you run a program. Python, unlike other languages that will tell you what the errors are, will just terminate when an error occurs. This is bad for the developer because you don't know where to start fixing the error and it is also bad for the user because he or she can no longer use the program. Therefore, instead of letting the program immediately stops, 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 needs to catch 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 on 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 an example code:

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

The output of this code is:

exception occurred
continue

Dictionaries

Python dictionaries are another collection and each item in the dictionary contains a key and a value. A dictionary is one-to-one mapping, which means for every key in the dictionary, there is one value. Initiating a Dictionary

Dictionaries are defined as curly brackets. To initiate a diction, you will assign a pair of empty curly bracks to an object, like this:

dict = {}

To access a value in a dictionary, you will need to enter the key to find the value corresponding to the dictionary, like this:

dict[key] = value

Example

Here is an example of a dictionary:

price = {"pasta":12,"salad":5,"steak":30}

This is a dictionary that maps the price of the food to the corresponding dish. To access the price of salad, for example, we would write:

price_salad = price[salad]
print(price_salad)

The output of this function is 5 because 5 is mapped to salad.

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.

See also

• VPython describes the basics of VPython and using it to create 3D models
• The GlowScript wiki page provides detailed instructions for how to use VPython on the GlowScript website

Further reading

• These Introductory Books are a great resource for beginners looking to learn Python
• What exactly can you do with Python? Here are Python's 3 main applications: This article provides several examples of industry applications of Python
• How to build your own Neural Network from scratch in Python gives a comprehensive guide on applying Python to machine learning

External links

• For a more comprehensive guide with getting Python set up, go to https://www.python.org/about/gettingstarted/
• The Python Package Index (PyPI) is a repository of community-created Python software packages that can be easily installed and used with Python code

References

• https://www.python.org/about/
• https://www.glowscript.org/docs/VPythonDocs/index.html
• https://www.geeksforgeeks.org/history-of-python/
• https://docs.python.org/3/tutorial/
• https://pythonbasics.org/
• http://websites.umich.edu/~mejn/cp/chapters/programming.pdf