Wednesday, August 27th, 2025¶

Variables¶

Last time, we had just started discussing defining variables in Python.

In [2]:
a = 1

a
Out[2]:
1

Note: Jupyter will display the output of the last line of any cell. We can view the contents of a defined variable by ending a cell with the variable name.

In [3]:
a = 1
b = 3
c = 7

a
b
c
Out[3]:
7

Variable names must:

  • Start with a letter or underscore (_)
  • Contain only letters, numbers, or underscores.
In [4]:
this_is_a_variable = 7
this_is_a_variable
Out[4]:
7
In [5]:
_variable_starting_with_underscore = 5
_variable_starting_with_underscore
Out[5]:
5
In [6]:
5variable_starting_with_number = 10

  Cell In[6], line 1
    5variable_starting_with_number = 10
    ^
SyntaxError: invalid decimal literal
In [7]:
num1 = 1
num5 = 5

num5
Out[7]:
5

Very often, we'll use underscores as spaces to separate words in our variable names. Another style (known as camelcase) uses capital letters to denote the start of a new word.

In [8]:
thisIsACamelCaseVariable = -5
thisIsACamelCaseVariable
Out[8]:
-5

In general, we want to choose concise variable names that helps the reader understand what they represent.

For example, recall the exercise from last class where we performed long-division:

In [9]:
a = 102
b = 42
c = a // b
d = a % b
In [10]:
c
Out[10]:
2
In [11]:
d
Out[11]:
18
In [12]:
c*b + d
Out[12]:
102

In the above, the variable names do not help to illustrate what each variable represents. Let's try to improve on this:

In [13]:
numerator = 102
denominator = 42
quotient = numerator // denominator 
remainder = numerator % denominator
In [14]:
quotient
Out[14]:
2
In [15]:
remainder
Out[15]:
18
In [16]:
quotient * denominator + remainder
Out[16]:
102

We can define several variables simultaneously by separating the variables and their respective defintitions by commas:

In [17]:
a, b, c = 1, 2, 3
In [18]:
a
Out[18]:
1
In [19]:
b
Out[19]:
2
In [20]:
c
Out[20]:
3

This can be very useful if we ever want to swap the meaning of two variables. As an example, suppose we define a = 1 and b = 2, but then want to swap their values.

In [21]:
a = 1
b = 2

old_a = a

a = b
b = old_a
In [22]:
a
Out[22]:
2
In [23]:
b
Out[23]:
1

Alternatively, we can use simultaneous assignment to swap them without an intermediate variable:

In [24]:
a = 1
b = 2

a,b = b,a
In [25]:
a
Out[25]:
2
In [26]:
b
Out[26]:
1

Working with strings¶

In Python, strings are used to hold text data. We can define strings by surrounding some text by double quotes " or single quotes ':

In [27]:
this_is_a_string = 'Hello, welcome to MTH 337.'
In [28]:
this_is_a_string
Out[28]:
'Hello, welcome to MTH 337.'

There are many operations that can be performed on strings. For example:

Addition of strings:

In [29]:
this_is_a_second_string = "I'm having fun!"

this_is_a_string + ' ' + this_is_a_second_string
Out[29]:
"Hello, welcome to MTH 337. I'm having fun!"

Adding strings together concatenates them.

Multiplying a string with an integer:

In [30]:
this_is_a_second_string * 5
Out[30]:
"I'm having fun!I'm having fun!I'm having fun!I'm having fun!I'm having fun!"

Multiplying a string by an integer contatenates that number of copies together.

Multiplying a string with a float?

In [31]:
this_is_a_string * 2.0

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[31], line 1
----> 1 this_is_a_string * 2.0

TypeError: can't multiply sequence by non-int of type 'float'

Multiplying two strings?

In [ ]:
'123' * '456'

Multi-line strings can be used using triple-single-quotes ''' to surround the string:

In [ ]:
multiline_string = '''This is a multi-line string.
Here is line 2.
My name is line 3!'''
In [ ]:
multiline_string

Notice that our multi-line string does not display the way we might hope. If a want to correctly render a multi-line string, we can use the print function.

In [32]:
print(multiline_string)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[32], line 1
----> 1 print(multiline_string)

NameError: name 'multiline_string' is not defined

The print function can be used anytime we want to display some information.

In [33]:
a = 1
b = 2
c = 3

print(a)
print(b)
print(c)
a

1
2
3
Out[33]:
1

Types¶

So far, we've talked about integers, floats, and strings. There are often times where we might want to convert between these datatypes.

  • The int function will try to convert an input to an integer type
  • The float function will try to convert an input to a float type
  • The str function will try to convert an input to a string type
In [34]:
int('123') * 2
Out[34]:
246
In [35]:
str(123) * 2
Out[35]:
'123123'
In [36]:
float(3)
Out[36]:
3.0
In [37]:
float('123')
Out[37]:
123.0

The int function will truncate a float and drop any decimal part.

In [38]:
int(4.5677)
Out[38]:
4
In [39]:
int(-6.8933)
Out[39]:
-6

Sometimes we might want to round to the nearest integer.

In [40]:
round(4.5677)
Out[40]:
5
In [41]:
round(-6.8933)
Out[41]:
-7

Note: Python comes with several built-in functions, like the round function. We can see this when Jupyter changes the name round to green-text. Advice: Try to avoid using these built-in names with your own variables.

In [42]:
print('Hello')

Hello

String formatting¶

Very often, we have some string template that we want to fill in with calculated data. For example, suppose we want to display a product of two numbers and the result.

In [47]:
a = 52
b = 772

my_str = 'The product of ' + str(a) + ' and ' + str(b) + ' is ' + str(a*b) + '.'
print(my_str)

The product of 52 and 772 is 40144.

The print function can take in several inputs, and will display each after the other separted by a space. We can print all of this using a single print statement by separating our inputs by commas:

In [49]:
print('The product of',a,'and',b,'is',a*b,'.')

The product of 52 and 772 is 40144 .

There are several ways that we can accomplish this in a sleeker fashion. One way is by using the .format method. Methods like the .format method are functions that are attached to objects, in this case to a string. This method can be called on some string in following way:

<some string>.format(<format options>).

In the simplest case, we can create a string that contains placeholders denoted by curly braces {}, then supply values to the .format method that will sequentially fill in these placeholders.

In [53]:
my_str = 'The product of {} and {} is {}.'
print(my_str.format(a,b,a*b))

a,b = 7,4
print(my_str.format(a,b,a*b))

The product of 52 and 772 is 40144.
The product of 7 and 4 is 28.
In [55]:
print('The prime factorization of {} is {}.'.format(12, '2*2*3'))

The prime factorization of 12 is 2*2*3.

Working with lists in Python¶

Another datatype in Python are lists which contain ordered collections of objects. To define a list, we surround a comma-separated collection with square brackets.

In [58]:
my_list = [1,2,3,4,5,6]
my_list
Out[58]:
[1, 2, 3, 4, 5, 6]
In [59]:
print(my_list)

[1, 2, 3, 4, 5, 6]

To access elements of a list, we use square brackets again along with an index. Python is a 0-based indexing language, which means the index of each list starts at 0. That is, 0 indicates the first item in the list.

In [60]:
my_list[0]
Out[60]:
1
In [61]:
my_list[3]
Out[61]:
4

We can also access elements of a list by counting backward from the end using negative indices.

  • The -1st index gives the last element.
  • The -2nd index gives the second to last element.
In [63]:
print(my_list)
print(my_list[-1])

[1, 2, 3, 4, 5, 6]
6
In [64]:
print(my_list)
print(my_list[-3])

[1, 2, 3, 4, 5, 6]
4

Note: We will get an error if we access indices beyond the length of the list:

In [66]:
my_list[6]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[66], line 1
----> 1 my_list[6]

IndexError: list index out of range
In [67]:
my_list[-10]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[67], line 1
----> 1 my_list[-10]

IndexError: list index out of range

What sorts of operations can we perform on lists? For arithmetic operations, lists work very similarly to strings.

Addition of lists:

In [69]:
[1,2,3] + [4,5,6,7,8]
Out[69]:
[1, 2, 3, 4, 5, 6, 7, 8]

Multiplying a list and an integer:

In [70]:
[1,2,3] * 6
Out[70]:
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

Lists and strings share many properties. We can convert a string to a list using the list function:

In [71]:
list('1234567')
Out[71]:
['1', '2', '3', '4', '5', '6', '7']

We can find the length of a list (or string) using the len function.

In [72]:
len('1234567')
Out[72]:
7
In [73]:
len([1,2,3,5,6])
Out[73]:
5

What if we want to convert a list of string characters to a string? The str function can be used to convert objects to strings.

In [74]:
my_list = [1,2,3,4,5]
str(my_list)
Out[74]:
'[1, 2, 3, 4, 5]'

Can we freely convert the string '12345' to a list and then back to a string?

In [76]:
my_str = '12345'
my_list = list(my_str)

str(my_list)
Out[76]:
"['1', '2', '3', '4', '5']"

It does not look like this is doing quite what we want, since the resulting includes the list delimitors and element separators.

We can fix this by using the .join method on a string. The .join method takes in a list of strings and concetanates them. However, it uses the object from which it is called to separate each concatenation. If we call the .join method from an empty string '', we will get simple concatenation.

In [78]:
''.join(my_list)
Out[78]:
'12345'

Let's use a separator - between the concatenated elements:

In [79]:
'-'.join(my_list)
Out[79]:
'1-2-3-4-5'
In [82]:
n = 12
fact = ['2','2','3']

print('The prime factorization of {} is {}.'.format(n, '*'.join(fact)))

The prime factorization of 12 is 2*2*3.
In [83]:
print('A',' is a '.join(['gig','gig','gig']))

A gig is a gig is a gig

Working with loops in Python¶

We can perform iterative operations using a for loop. For example, we can iterate through the items in a list and perform some desired operations.

The syntax for writing a for loop is: for (some variable name) in (some iterable object): (do something)

The variable (some variable name) will sequentially take on each of the values stored in (some iterable object), and for each value will (do something).

In [85]:
my_list = [1,2,3,4]

for n in my_list:
    print(n**2)

1
4
9
16

Key info: The spacing in Python is critical!!!. In particular, the spacing decides what operations are part of a for loop and what operations are not.

In [86]:
my_list = [1,2,3,4]

for n in my_list:
    print(n**2)

print('Hello')

1
4
9
16
Hello
In [91]:
my_list = [1,2,3,4]

for n in my_list:
    print(n**2)

    print('Hello')

print('Done')
print('Hello again?')

1
Hello
4
Hello
9
Hello
16
Hello
Done
Hello again?

We can also use for loops inside other for loops. We call these "nested loops".

For example, let's write nested loops that iterate through all combinations of integers from the two lists [1,2,3] and [4,5,6] and prints out the sum for each combination.

In [93]:
for n in [1,2,3]:
    for m in [4,5,6]:
        print('{} + {} = {}'.format(n,m,n+m))
    print('Done with n={}'.format(n))
print('Done')

1 + 4 = 5
1 + 5 = 6
1 + 6 = 7
Done with n=1
2 + 4 = 6
2 + 5 = 7
2 + 6 = 8
Done with n=2
3 + 4 = 7
3 + 5 = 8
3 + 6 = 9
Done with n=3
Done

What if we wanted to iterate through pairs from each list? That is, suppose we want to consider the lists in parallel and iterate through the three pairs (1,4), (2,5), and (3,6).

In [ ]: