Operations

The following are simple operations you can perform within python. We start with very basic operations and work up to more complex operations such as defining functions and methods

Operations

The following are simple math expressions that can be done in Python.

Arithmetic

Symbol	Task Performed
+	Addition
-	Subtraction
/	division
%	mod
*	multiplication
//	floor division
**	to the power of

Simple arithmetic calculations can be completed within Python:

# Addition
>>> 1 + 1
2

# Multiplication
>>> 1 * 3
3

# Division
>>> 1 / 2
0.5

# Square
>>> 2 ** 4
16

# Find remainder - called modulus
>>> 4 % 2
0

# Find remainder - called modulus
>>> 5 % 2
1

# BEDMAS
>>> (2 + 3) * (5 + 5)
50

Trigonometry

Trig Function	Name	Description
math.pi	pi	mathematical constant \(\pi\)
math.sin()	sine	sine of an angle in radians
math.cos()	cosine	cosine of an angle in radians
math.tan()	tangent	tangent of an angle in radians
math.asin()	arc sine	inverse sine, ouput in radians
math.acos()	arc cosine	inverse cosine, ouput in radians
math.atan()	arc tangent	inverse tangent, ouput in radians
math.radians()	radians conversion	degrees to radians
math.degrees()	degree conversion	radians to degrees

Trigonometry functions such as sine, cosine, and tangent can also be calculated using Python:

>>> from math import sin

>>> sin(60)
-0.3048106211022167

>>> from math import sin, cos, tan, pi

>>> pi
3.141592653589793

>>> sin(pi/6)
0.49999999999999994

>>> cos(pi/6)
0.8660254037844387

>>> tan(pi/6)
0.5773502691896257

Exponents/Logarithms

Calculating exponents and logarithms with Python is easy. Note the exponent and logarithm functions are imported from the math module just like the trig functions were imported from the math module above.

>>> from math import log, log10, exp, e, pow, sqrt
>>> log(3.0*e**3.4)         # note: natural log
4.4986122886681095

>>> sqrt(3**2 + 4**2)
5.0

# The power function pow() works like the ** operator. pow() raises a number to a power
>>> 5**2
25

>>> pow(5,2)
25.0

Math function	Name	Description
math.e	Euler’s number	mathematical constant \(e\)
math.exp()	exponent	\(e\) raised to a power
math.log()	natural logarithm	log base e
math.log10()	base 10 logarithm	log base 10
math.pow()	power	raises a number to a power
math.sqrt()	square root	square root of a number

Variables

A name that is used to denote something or a value is called a variable. When assigning variables, the variable name should be something meaningful. This way you will remeber what it is for. Variables can not start with a number or special character. In python, variables can be declared and values can be assigned to it as follows:

# I prefer sepearting words in a variable with '_'
>>> name_of_var = 2

# you can also use camelCase
>>> nameOfVar = 2

# Assign numbers to variables. These are now objects in Python.
>>> x = 2
>>> y = 3

# Since they are objects you can now use them to perform operations
>>> z = x + y
>>> z
5

# Multiple variables can be assigned with the same value at once
>>> x = y = 1
>>> print (x,y)
1 1

Variable names in Python must conform to the following rules:

• variable names must start with a letter
• variable names can only contain letters, numbers, and the underscore character _
• variable names can not contain spaces
• variable names can not include punctuation
• variable names are not enclosed in quotes or brackets

String Operations

Strings are sequences of letters, numbers, punctuation, and spaces. Strings are defined by enclosing letters, numbers, punctuation, and spaces in single quotes ' ' or double quotes " ".

# When using strings you can use single quotes or double quotes
>>> single = 'single quotes'
>>> double = "double quotes"

# If you want a string to contain an apostrophe then use double quotes around the string...
>>> apostrophe = " wrap lot's of other quotes"

String Concatenation

Strings can be concatenated or combined using the + operator.

>>> word = "Solution"
>>> another_word = "another solution"
>>> third_word = "3rd solution!"
>>> all_words = word+another_word+third_word
>>> all_words
'Solutionanother solution3rd solution!'

String Comparison

Strings can be compared using the comparison operator; the double equals sign ==.

Note

the comparison operator (double equals ==) is not the same as the assignment operator, a single equals sign =.

>>> name1 = 'Gabby'
>>> name2 = 'Gabby'
>>> name1 == name2
True

>>> name1 = 'Gabby'
>>> name2 = 'Maelle'
>>> name1 == name2
False

Printing variables

One built-in function in Python is print(). The value or expression inside of the parenthesis of a print() function “prints” out to terminal when the print() function is called.

>>> x = 'hello'

# Use the built-in function to print variables/objects out
>>> print(x)
'hello'

# Use the format function to set the values within the string enclosed by curly braces {}
>>> num = 12
>>> name = 'Sam'

# Either of these methods work...
>>> print('My number is: {one}, and my name is: {two}'.format(one=num,two=name))
'My number is: 12, and my name is: Sam'

>>> print('My number is: {}, and my name is: {}'.format(num,name))
'My number is: 12, and my name is: Sam'

Lists

# With only integers
[1,2,3]

# With integers and strings
['hi',1,[1,2]]

# Adding new values to a list
my_list = ['a','b','c']
my_list.append('d')
print(my_list)

# Indexing a list by the items index
my_list[0]

# Indexing using a slice notation :
my_list[1:]

# Replace existing values in list
my_list[0] = 'NEW'
print(my_list)

# You can create nested lists as well
nest = [1,2,3,[4,5,['target']]]
nest[3]
nest[3][2]
nest[3][2][0]

Dictionaries

d = {'key1':'item1','key2':'item2'}
d

d['key1']

Booleans

True

False

Tuples

t = (1,2,3)
t[0]

# You can not assign items to a tuple like you can with a list
t[0] = 'NEW'

Sets

{1,2,3}

{1,2,3,1,2,1,2,3,3,3,3,2,2,2,1,1,2}

Relational Operators

Symbol	Task Performed
==	True, if it is equal
!=	True, if not equal to
<	less than
>	greater than
<=	less than or equal to
>=	greater than or equal to

# False statements
1 > 2
'hi' == 'bye'

# True statements
1 < 2
1 >= 1
1 <= 4
1 == 1

Logic Operators

# Using 'and' to indicate both conditions need to be True
(1 > 2) and (2 < 3)

# Using 'or' to indicate only one conditions needs to be True
(1 > 2) or (2 < 3)

# You can have as many conditional statements as you want
(1 == 2) or (2 == 3) or (4 == 4)

if,elif, else Statements

# IF statement
if 1 < 2:
    print('Yep!')

# IF ELSE statement
if 1 < 2:
    print('first')
else:
    print('last')

if 1 > 2:
    print('first')
else:
    print('last')

# IF, ELIF, ELSE statement
if 1 == 2:
    print('first')
elif 3 == 3:
    print('middle')
else:
    print('Last')

For Loops

seq = [1,2,3,4,5]
for item in seq:
    print(item)

for item in seq:
    print('Yep')

# You can name the iterator whatever you like
for jelly in seq:
    print(jelly+jelly)

While Loops

i = 1
while i < 5:
    print('i is: {}'.format(i))
    i = i+1

range() function

range(5)

# Great for using in For loops
for i in range(5):
    print(i)

# You can use it to create lists
list(range(5))

List comprehension

x = [1,2,3,4]

# Perform operations within a For loop and append the outputs to a list object
out = []
for item in x:
    out.append(item**2)
print(out)

A very useful technique in Python is the one line for loop:

[item**2 for item in x]

Defining functions

def my_func(param1='default'):
    """
    Docstring goes here.
    """
    print(param1)

# To call your function you need to include brackets at the end
my_func

my_func()

Now that you have defined your function with an input you can provide new inputs to the function to perform an operation

# You can either call the defined input varible for your function
my_func(param1='new param')

# Or you can just provide the input, remember if you have multiple function inputs the position of these inputs matter!
my_func('new param')

# Use the 'Return' function to return a value from within your function and assign it to a variable
def square(x):
    return x**2

out = square(2)
print(out)

Lambda, map and filter

Instead of writing a function you can use the lambda function instead:

def times2(var):
    return var*2

times2(2)

# lambda
lambda var: var*2

# map
seq = [1,2,3,4,5]
map(times2,seq)

# Combining lambda and map together you get
list(map(times2,seq))

# Here is more detail
list(map(lambda var: var*2,seq))

# Using the filter function to return values that meet a condition
filter(lambda item: item%2 == 0,seq)
list(filter(lambda item: item%2 == 0,seq))

Methods

One of the most useful aspects of the Python language is that everything is an object and has inherent methods.

string methods

# Assign 'st' to be a string
st = 'hello my name is Sam'

# A string type in Python has several methods
# To return all lowercase
st.lower()

# All uppercase
st.upper()

# Split the string at white spaces
st.split()

# You can use the split method to split at a character you want
tweet = 'Go Sports! #Sports'
tweet.split('#')

# You can return only the part of the string you want after the split method
tweet.split('#')[1]

dictionary methods

d = {'key1': 'item1', 'key2': 'item2'}

# Print the keys in a dictionary
d.keys()

# Print the items in a dictionary
d.items()

list methods

lst = [1,2,3]

lst.pop()
lst

# Find a value within a list
'x' in [1,2,3]

'x' in ['x','y','z']