1-Object and Data Structures.pptx

Python Object and
Data Structure Basics

Datatypes
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" 'Sammy' "2000" "楽しい"
Lists list Ordered sequence of objects: [10,"hello",200.3]
Dictionaries dict Unordered Key:Value pairs: {"mykey" : "value" , "name" : "Frankie"}
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

Datatypes
● There are two main number types we will work
with:
○ Integers which are whole numbers.
○ Floating Point numbers which are numbers
with a decimal.

Python Arithmetic Operators
 Operator Description Example Evaluates To
 + Addition 7 + 3 10
 - Subtraction 7 - 3 4
 * Multiplication 7 * 3 21
 / Division (True) 7 / 3 2.3333333333333335
 // Division (Integer) 7 // 3 2
 % Modulus 7 % 3 1

Variables
● We use the = to assign values to a variable
● For example:
○ my_dogs = 2

Variables
● Rules for variable names
○ Names can not start with a number.
○ There can be no spaces in the name, use _
instead.
○ Can't use any of these symbols
:'",<>/?|()!@#$%^&*~-+

Variables
● Rules for variable names
○ It's considered best practice that names are
lowercase.
○ Avoid using words that have special meaning
in Python like "list" and "str"

Variables
● Python uses Dynamic Typing
● This means 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”

Variables
my_dogs = 2
my_dogs = [ “Sammy” , “Frankie” ]

Variables
int my_dog = 1;
my_dog = “Sammy” ; //RESULTS IN ERROR

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

STRINGS
● Strings are sequences of characters, using the
syntax of either single quotes or double quotes:
○ 'hello'
○ "Hello"
○ " I don't do that "

String Indexing
● Because strings are ordered sequences it
means we can using 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...

String Indexing
● 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

STRINGS
● 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

Python print() Function
 The print() function prints the specified message to the screen, or other standard output device.
 Ex:
 print("Hello World")
 print (5 + 7)

Practice
 Which of the following are legitimate Python identifiers?
a) martinBradley b) C3P_OH c) Amy3 d) 3Right e) Print
 What is the output from the following fragment of Python code?
myVariable = 65
myVariable = 65.0
myVariable = “Sixty Five”
print(myVariable)
 how do you reference the last item in the list?
roster = ["Martin", "Susan", "Chaika", "Ted"]

String Slicing
● 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.

String Slicing
mystring = "Hello World"
print(mystring[0])
print(mystring[3])
print(mystring[3:])
print(mystring[:3])
print(mystring[3:5])
print(mystring[::])
print(mystring[::2])
print(mystring[::4])
print(mystring[2:5:2])
print(mystring[::-1])
Output:
H
L
lo World
Hel
Lo
Hello World
HloWrd
Hor
Lo
dlroW olleH

Concatenation
 We can perform string concatenation Using + operator:
s1 = 'Apple'
s2 = 'Pie'
s3 = 'Sauce'
s4 = s1 + s2 + s3
print(s4)

Concatenation
 concatenation Using * operator:
letter = 'z'
print( letter * 10)
Output:
zzzzzzzzzz

Concatenation
Dynamic datatyping in concatenation:
print ( 2 + 3)
5
print (‘2’ + ‘3’)
23

String Methods
The upper() method returns a string where all characters are in upper case.
mystring = 'hello world'
print( mystring.upper())
HELLO WORLD

String Methods
The lower() method returns a string where all characters are lower case.
mystring = ‘HELLO WORLD'
print( mystring.lower())
hello world

String Methods
The split() method splits a string into a list.
mystring = ‘HELLO WORLD'
print( mystring.split())
[‘HELLO’, ‘WORLD’]

String Methods
Split on a specific character:
mystring = 'hello world'
print( mystring.split('o’))
['hell', ' w', 'rld']

String Formatting for Printing
● Often you will want to “inject” a variable into your
string for printing. For example:
○ my_name = “Jose”
○ print(“Hello ” + my_name)
● There are multiple ways to format strings for
printing variables in them.
● This is known as string interpolation.

String Formatting for Printing
● two methods for this:
○ .format() method ( classic)
○ f-strings (formatted string literals-new in
python 3)

String Formatting for Printing: .format()
The format() method formats the specified value(s) and insert
them inside the string's placeholder.)
{ }

Example:
name = 'Robert'
age = 51
print ("My name is {}, I'm {}".format(name, age))
Output: My name is Robert, I'm 51

Index on .format():
print ("Music scale is: {} {} {} ".format('Re', 'Do', 'Mi’))
Output: Music scale is: Re Do Mi
print ("Music scale is: {1} {0} {2} ".format('Re', 'Do', 'Mi’))
Output: Music scale is: Do Re Mi

Precision format in numbers
{value:width:precision f}
value= 20/300
print("the value is : {}".format(value))
value= 20/300
print("the value is : {x:1.3f}".format(x=value))

String Formatting for Printing: f-strings
name = 'Robert'
print ("My name is {}".format(name))
Output: My name is Robert
name = 'Robert'
print (f'My name is {name}’)
Output: My name is Robert

Precision format in numbers: f-strings
val = 12.3
print(f'{val:.2f}')
print(f'{val:.5f}’)
Output:
12.30
12.30000

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.

Lists
thislist = ["apple", "banana", "cherry"]
print(thislist)
Output: ['apple', 'banana', 'cherry’]
numbers = [1, 2, 5]
print(numbers)
Output: [1, 2, 5]

Lists
print(len(thislist))
Output: 3
print(thislist[1])
Output: banana

Lists: .append method
The append() method adds an item at the end of the list.
numbers = [21, 34, 54, 12]
numbers.append(32)
Print(numbers)
Output: [21, 34, 54, 12, 32]

Lists: .sort method
The sort() method sorts the list ascending by default.
cars = ['Ford', 'BMW', 'Volvo']
cars.sort()
print(cars)
Output: ['BMW', 'Ford', 'Volvo']

Lists: .reverse method
numbers = [2, 3, 5, 7]
numbers.reverse()
print(numbers)
Output: [7, 5, 3, 2]

Dictionaries
● Dictionaries are unordered mappings for storing
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
● 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
thisdict = { "brand": "Ford",
"model": "Mustang",
"year": 1964}
print(thisdict)
Output: {'brand': 'Ford', 'model': 'Mustang', 'year': 1964}

Dictionaries
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict["brand"])
Output: Ford

Dictionaries: Changing values
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict["brand" ]="Cadillac"
print(thisdict["brand"]
Output: Cadillac

.keys & .values methods
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict.keys())
print(thisdict.values()
Output:
dict_keys(['brand', 'model', 'year'])
dict_values(['Ford', 'Mustang', 1964])

Dictionaries
● Dictionaries: Objects retrieved by key name.
Unordered and can not be sorted.
● Lists: Objects retrieved by location.
Ordered Sequence can be indexed or sliced.

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

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

Sets: .add method
thisset = {"apple", "banana", "cherry"}
print(thisset)
Output: {'banana', 'apple', 'cherry’}
thisset = {1,2,2,4}
print(thisset)

Sets
thisset = {"apple", "banana", "cherry"}
thisset.add(strawberry)
print(thisset)
Output: {'strawberry', 'banana', 'cherry', 'apple'}

Boleans
Booleans are operators that allow you to convey
True or False statements.

Boooleans
print (1 > 2)
Output:
False

I/0: Input function
The input() function allows user input.
print('Enter your name:')
x = input()
print('Hello, ' + x)

I/0: Input function
x = input('Enter your name:')
print('Hello, ' + x)

Practice
1) Create a programs that asks for user input about base and height and calculates area of a square.
2) Do the same but to calculate volume of a cube.
3) Do the same but calculate area of a triangle.

Solutions
base = int(input('Enter base:’))
height =int(input('Enter height:’))
area = base * height
print(area)

1-Object and Data Structures.pptx

More Related Content

Similar to 1-Object and Data Structures.pptx (20)

Recently uploaded (20)

1-Object and Data Structures.pptx