Object and Data Structures

Summary

Name	Type	Description
Integers	int	Whole numbers, such as: 3 300 200
Floating point	float	Numbers with a decimal point: 2.3 4.6 100.0
Strings	str	Ordered sequence of characters: "hello" ' Caleb' "awe" '2020'
Lists	list	Ordered sequence of objects: [10,"hello",200.3]``
Dictionaries	dict	Unordered Key:Value pairs: {"mykey":"val ue","name","Caleb"}
Tuples	tup	Ordered immutable sequence of objects: (10,"hello",200.3)``
Sets	set	Unordered collection of unique objects: {"a","b"}
Booleans	bool	Logical value indicating True or False

Numbers

Basic math

# Addition
2+1

# Subtraction
2-1

# Multiplication
2*2

# Division
3/2

# Preposition (exponentials)
2 ** 3

Modulo or “Mod” Operator

## Mod
# Give the remainder of 7/4
7 % 4

# This gives 0 (nothing left over)
50 % 5

# This results in 1, telling us it's odd
23 % 2

BODMAS

# Result of 105
2 + 10 * 10 + 3

# Result of 156
(2 + 10) * (10 + 3)

Variable Assignment

Rules for Variable Names

• Names can’t start with a number
• There can be no spaces in the name, use _instead.
• Can’t use any of these symbols: :'",<>/?|\()!@#$%^&*~-+
• Best practice (PEP8) that names are lowercase.
• Avoid using words that have special meaning in Python like “list” and “str”

Dynamic Typing

• Python uses Dynamic Typing
• You can reassign variables to different data types
• This makes Python very flexible in assigning data types, this is different than other languages that are “Statically-Typed”

Example of Dynamic Typing in Python

# Assigning a var a different data type (eg) from number to list works in Python,
# but not in other languages, as described above
my_cats = 2
my_cats = ["Coco", "Frosty"]

Example of Static Typing in C++

int my_dog = 1;
my_dog = "Sammy"; //results in error - no longer integer

Pros & Cons of Dynamic Typing

• Pros of Dynamic Typing:
  • Very easy to work with
  • Faster development time
• Cons of Dynamic Typing:
  • May result in bugs of unexpected data types!
  • You need to be aware of type()

Assigning Variables

# assign a as 5
a = 5

# take the current value of a,
# add it to itself and assign its new value
a = a + a

# See value is now 10
a

# assign the new value
a = a + a

# See the value is now 20
a

# see that a is an int
type(a)

# assign a a new data type
a = 30.1

# See that a is now a float
type(a)

int = 4

Example of variable assignment

# Do some math to find your taxes
my_income = 100
tax_rate = 0.1
my_taxes = my_income * tax_rate

# See the value of my taxes
my_taxes

Strings

Basics

Strings are sequences of characters, using the syntax of either single quotes or double quotes:

• ‘howzit’
• “hello”
• " some stuff written here "
• Strings are ordered sequences, so we can use indexing and slicing to grab sub-sections of the string.
• Indexing notation uses [] notation after the string (or variable assigned the string).
• Indexing allows you to grab a single character from the string…
• These actions use []square brackets and a number index to indicate positions of what you wish to grab.
  • Character: h e l l o
  • Index: 0 1 2 3 4
  • Reverse Index: 0 -4 -3 -2 -1
• Slicing allows you to grab a subsection of multiple characters, a “slice” of the string/
• This has the following syntax:
  • [start:stop:step]
• start is a numerical index for the slice start
• stop is the index you will go up to (but not include)
• step is the size of the “jump” you take

Examples of strings

# output some strings y'all
'hello'
"world"

# a space is a char
' this is a string too! '

# enclose in doubles if you've got a single, etc.
"I'm a python master"

# printing strings just shows the output of string
print("string")

# print, escaping a new line
print('hello\nworld')

# print, escaping a tab
print('hello\tworld')

# output length of string (5 in this case)
len('hello')

# output length, notice space counts
len('I am')

Indexing and Slicing

Example of Indexing

# Grab the h from hello
mystring = "hello world"
mystring[0]

# Grab the l from world 
mystring[-2]

Example of Slicing

# Redefine the string
mystring = 'abcdefghijk'

# Slice from 3rd char to end (stop & step undefined)
mystring[2:]

# Slice up to 4th char (not incl.) from beginning (start & step undefined)
mystring[:3]

# Slice 4th to 6th char (get rid of 0-3 & 7-11)
mystring[3:6]

# Slice the string as a whole, valid syntax
mystring[::]

# Slice 2nd char (in jumps of 2)
mystring[::2]

# Slice taking 3rd char up until 8th char (not incl.) in steps of 2
mystring[2:7:2]

# Reverse the order of text - take backwards steps
mystring[::-1]

String Properties and Methods

# String Concatenattion
name = "Sam"
last_letters = name[1:]
'P' + last_letters
Pam

letter = 'z'
letter * 10
zzzzzzzzzz

2 + 3
5

'2' + '3'
23

x = 'Hello World'
x.upper()

Print Formatting with Strings

• Often you will want to "inject a variable into your string for printing. For example:

  • my_name = "Caleb"
  • print("Hello " + my_name)

• There are multiple ways to format strings for printing variables in them.

• This is known as string interpolation.

• Two methods for this:

  • .format() method
  • f-strings (formatted string literals)

# .format() method
print('This is a string {}'.format('INSERTED'))
print('The {} {} {}'.format('fox','brown','quick'))
print('The {2} {1} {0}'.format('fox','brown','quick'))
print('The {q} {b} {f}'.format(f='fox',b='brown',q='quick'))

# Float formatting "{value:width.precision f}"
result = 100/777
print("The result was {}".format(result))
print("The result was {r:1.3f}".format(r=result))

# f-strings method
print(f'Hello, his name is {name}')
name = "Sam"
age = 3
print(f'{name} is {age} years old)

Lists

• Lists are ordered sequences that can hold a variety of object types

• They use [] brackets and commas to separate objects in the list.

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

• Lists support indexing and slicing. Lists can be nested and also have a variety of useful methods that can be called off of them.

my_list = [1,2,3]
my_list = ['string',100,23,2]
len(my_list)
mylist = ['one','two','three']
mylist[0]
mylist[1:]
another_list = ['four','five']
mylist + another_list
mylist[0] = 'ONE'
mylist.append('six')
mylist.pop()
popped_item = mylist.pop()
new_list = ['a','e','x','b','c']
num_list = [4,1,8,3]
new_list.sort()
num_list.revers()

Dictionaries

• Dictionaries are unordered mappings for sorting objects. Previously we saw how lists store objects in an ordered sequence, dictionaries use a key-value pairing instead.

• This key-value pair allows users to quickly grab objects without needing to know an index location.

• Dictionaries use curly braces and colons to signify the keys and their associated values.

  • {'key1':'value1','key2':'value2'

• So when to choose a list and when to choose a dictionary?

• Dictionaries: Objects retrieved by key name.

  • Unordered and can not be sorted.

• Lists: Objects retrieved by location.

  • Ordered Sequence can be indexed or sliced.

# Creating a dictionary
my_dict = {'key1':'value1','key2':'value2'
my_dict['key1']

# A dict can have numbers, lists, and even other dicts
d = {'k1':123,'k2':[0,1,2],'k3':{'insidekey':100}}
d['k3']['insidekey']

# Adding values to dict
d = {'k1': 100, 'k2': 200}
d['k3'] = 300

# Overwriting values
d['k1'] = 'NEW VALUE'

# Return the keys
d.keys()

# Return the values
d.values()

# Return the items
d.items()

Tuples

• Tuples are very similar to lists. However they have one key difference - immutability.
• Once an element is inside a tuple, it cannot be reassigned
• Tuples use parenthesis (1,2,3)

t = (1,2,3)
t = ('one',2)
t = ('a','a','b')
t.count('a')
t.index('a')

Sets and Booleans

Sets

• Sets are unordered collections of unique elements
• Meaning there can only be one representative of the same object.

myset = set()
myset.add(1)
myset

myset.add(2)
myset

myset.add(2)
myset

mylist = [1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3]
set(mylist)

Booleans

• Booleans are operators that allow you to convey True or False statements
• These are very important later on when we deal with control flow and logic!

False
True
type(False)
1 > 2
1 == 1
b = None
b

Files

# Opening a file
myfile = open('myfile.txt')
myfile.read()

# The second time you open, the curser is at the end of the file
myfile.read()

# Seak to 0 to go back to the beginning of the file
myfile.seak(0)

# Read the file, all in one line
contents = myfile.read()

# Read the file all in new lines
myfile.readlines()

# Close the file
myfile.close()

# Read the file and close it after
with open('myfile.txt') as my_new_file:
   contents = my_new_file.read()
contents

# Write to file
with open('myfile.txt',mode='w') as myfile:
   contents = myfile.read()
contents

# Reading
with open('my_new_file.txt',mode='r') as f:
   print(f.read())

# Appending
with open('my_new_file.txt',mode='a') as f:
   f.write('FOUR')

# Writing
with open('sjkdhsakjfj.txt',mode='w') as f:
   f.write('I CREATED THIS FILE')

Reading, Writing, Appending Modes

• mode='r' is read only
• mode='w is write only (will overwrite files or create new)
• mode='a' is append only (will add on to files)
• mode='r+' is reading and writing
• mode='w+' is writing and reading (overwrites existing files or creates a new file)