Quiz 3- Chapter’s 9-11 Flashcards
define a dictionary
an object that stores a collection of data.
elements are ordered, changeable and DO NOT allow duplicates
KEY VALUE PAIRS are elements
Is a key immutable or mutable
Key’s are immutable
are dictionaries mutable?
yes
How do you retrieve a specific value from a dictionary?
You use the key associated with it
Dictionaries are ordered. What does that mean
that the items have a defined order and that order will not change. Unordered means that the items do not have a defined order and you cannot refer to an item by using an index
dictionary format:
{key1:val1,key2:val2,key3:val3}
What will this do?
variable = {}
What built-in function will accomplish the same thing?
It will create an empty dictionary.
dict() will accomplish the same thing
what will this do?
cars = {‘’brand’’:’’Ford’’,’’model’’:’’Mustang’’,’’year’’:1964}
print(cars)
it will display the dictionary.
What will this do?
dictionary[key] = value
Add the new element to the dictionary. If the key already exists it will change the value associated with it
dictionary[key]
What will this do?
retrieve the value from the dictionary. If key is in the dictionary, otherwise KeyError exception is raised.
What’s a way to test and see if a key is in a dictionary?
using the in and not in operators.
if ‘’model’’ in cars:
print(‘’Yes, ‘model’ is a key’’)
cars = {‘’brand’’:’’Ford’’,’’model’’:’’Mustang’’,’’year’’:1964}
x = cars.values()
print(x)
What is the output?
dict_values([‘Ford’,’Mustang’,1964])
How do you retrieve elements from a dictionary?
cars = {‘’brand’’:’’Ford’’,’’model’’:’’Mustang’’,’’year’’:1964}
x = cars.items()
print(x)
it will display the key value pair
del dictionary[key]
Will do what?
delete the key-value pair in the dictionary. If key is not in dictionary, KeyError exception is raised.
What does the len function do?
Used to obtain the number of elements in a dictionary.
Key must be immutable but values can be any type of object.
One dictionary can include keys of several different immutable tuples.
Values stored in a single dictionary can be of different types
clear method
deletes all the elements in a dictionary, leaving it empty
format: dictionary.clear()
What does the get method do?
gets a value associated with a specified key from dictionary
format: dictionary.get(key,default)
default is returned if key is not found
alternative to [] operator
CANNOT RAISE KEYERROR EXCEPTION
items method:
returns all the dictionaries keys and values
format: dictionary.items()
returned as dictionary view
each element in dictionary view is a tuple which contains a key and its value
USE A FOR LOOP to iterate over the tuples in the sequence
keys method:
returns all the dictionary keys as a sequence
format: dictionary.keys()
pop method:
returns value with specified key and removes that key-value pair from the dictionary
format: dictionary.pop(key,default)
default is returned if key is not found
popitem method:
returns, as a tuple, the key value pair that was last added to the dictionary. The method also removes the pair from the dictionary.
format: dictionary.popitem()
KEY VALUE PAIR RETURNED AS TUPLE
values method:
returns all the dictionary values as a sequence
format: dictionary.values()
use for loop to iterate over values
dictionary comprehension:
an expression that reads a sequence of input elements and uses those input elements to produce a dictionary
what is this an example of:
squares = {item:item**2 for item in numbers}
dictionary comprehension.
The results expressions is item:item**2
the iteration expression is for item in numbers
names = { ‘Jeremy’, ‘Kate’,’Peg’}
variable = {item:len(item) for item in names}
variable
What will the output produce?
It will display the length of each name for each item in the list
{‘Jeremy’:6,’Kate’,:4,’Peg’:3}
dict1 = {‘A’:1,’B‘:2,’C’:3}
dict2 = {k:v for k,v in dict1.items()}
dict 2
What will this do?
produce a copy of the first dictionary
{‘A’:1,’B‘:2,’C’:3}
Can you use an if clause in dictionary comprehension statements?
Yes, to select only certain elements of the input sequence.
set:
an object that stores a collection of data in same ways as mathematical set
-all items must be unique (no duplicates)
-set is unordered
- elements can be of different data types
set function:
used to create a set
for empty set: call set()
for non empty set: call set(argument) where argument is an object that contains iterable elements. (ex: list, string, tuple, can all be argument) but if the argument is a string each character becomes a set element. For set of strings, pass them to the function as a list.
if argument contains duplicates, only one of the duplicates will appear in the list
len function for a set:
returns the number of elements in a set
Are sets mutable or immutable?
mutable
add method (for a set)
adds an element to a set
update method (for a set)
updates a group of elements to a set. (arguments must be a sequence containing iterable elements and each of the elements is added to the set)
remove and discard method both do what? (for a set)
remove the specified item from the set.
The item that should be removed is passed to both methods as an argument.
Behave differently when THE SPECIFIED ITEM IS NOT FOUND IN THE SET
what error does remove method raise when specified item is not found in a set?
KeyError exception
What error does discard method raise when the specified item is not found in the set?
IT DOES NOT RAISE AN EXCEPTION
clear method (for a set):
clears all the elements of the set.
What kind of loop can be used to iterate over each element in a set?
how many times does the loop iterate for each item in the set?
A for loop. Once.
format: for item in set:
What operator can test whether a value is in set or not?
in, not in
Union of 2 sets:
a set that contains all the elements of both sets
How do you find the union of 2 sets:
use the union methodL
format: set1.union(set2)
or
use the | operator
format: set1 | set2
BOTH RETURN A NEW SET WHICH CONTAINS THE UNION OF BOTH SETS
Intersection of 2 sets:
a set that contains only the elements found in both sets
How do you find the intersection of 2 sets?
use the intersection method:
format: set1.intersection(set2)
or
use the & operator
format: set1 & set2
BOTH TECHNIQUES RETURN A NEW SET WHICH CONTAINS THE INTERSECTION OF BOTH SETS
Difference of 2 sets:
a set that contains elements that appear in the first set but do not appear in the second set
How do you find the difference of 2 sets:
Use the difference method:
Format: set1.difference(set2)
or
Use the - operator:
format: set1 - set2
Symmetric difference of 2 sets:
a set that contains the elements that are not shared by the 2 sets
How to find the symmetric difference of 2 sets:
use the symmetric_difference method:
format: set1.symmetric_difference(set2)
or
use the ^ operator:
format: set1 ^ set2
When is set A a subset of set B?
if all the elements in set A are included in set B
To determine whether set A is a subset of set B:
use the issubset method:
format: setA.issubset(setB)
or
use the <= operator:
format: setA <= setB
set A is a superset of set B if
it contains all the elements of set B
To determine whether set A is a superset of set B:
use the issuperset method:
format: setA.issuperset(setB)
use the >= operator
format: setA >= setB
set comprehension:
a concise expression that creates a new set by iterating over the elements of a sequence.
Set comprehensions are written like comprehensions except they are enclosed in curly brackets {}
serializing objects:
convert the object to a stream of bytes that can easily be stored in a file
pickling:
serializing an object
Procedural programming
writing programs made of functions that perform specific tasks.
data items commonly passed from one procedure to the next
Is python an object-oriented programming language?
Yes, almost everything in python is an object
object-oriented programming
focused on creating objects
object:
entity that contains data and procedures
data is known as
data attributes
procedures are known as
methods
What do methods do?
perform operations on the data attributes
encapsulation:
combining data and code into a single object
data hiding (object?)
data attributes are hidden from code outside the object
outside code does NOt need to know the internal structure of the object,
PROTECTS AGAINST ACCIDENTAL CORRUPTION
object reusability:
the same object can be used in different programs
data attributes:
define the state of an object:
ex: clack would have second, minute, and hour attributes
public methods:
allow external code to manipulate the object
private methods:
used for object’s inner workings
class:
code that specifies the data attributes and methods of a particular type of object (blueprint, cookie cutter)
instance
an object created from a class
there can be many instances of 1 class
class: set of instructions for how to make an instance
class Cookie():
does what
creates a class named Cookie
Class definitions:
set of statements that define a class’s methods and data attributes
format: class Class_Name:
class names often begin with uppercase letter
self parameter:
required in every method in the class_references the specific object that the method is working on
initializer method:
automatically executed when an instance of the class is created:
format: def__init__(self):
usually first method in class definition
DOES NOT HAVE TO BE CALLED SELF
What will this do?
car = class_name()
create an instance of a class
to call a class what notation do you use
dot notation:
my_instance.method()
what does this do
self.__current_minute
?
makes sure that the object’s data attributes are private by placing two underscores in front of the attribute
accessing attributes is done through?
dot notation
ex: self.name
you call method using
dot notation
ex: my_cat.play()
The self parameter is a reference to
the current instance of the class
self (in classes) is used to
access variables that belongs to the class.
the parameter does not have to be named self but it must be the first parameter of any function in teh class
Pure or Accessor methods:
a function which creates an object, initializes its attributes, and returns a reference to the new object
ex: get_model is an accessor method
Modifiers or Mutator methods
a function which modifies the objects it gets as parameters where the changes are visible to the caller
ex: set_model
Mutator methods are sometimes called____ and accessor methods are sometimes called ____
Mutator: “setters”
accessor: “getters”
modifier:
a function that modifies the object it gets as parameter.
Changes are visible to the caller (function)
Object properties can be modified and deleted?
yes:
p1 = Person(“john”,36)
p1.age = 40
print(p1.age)
40
del p1.age
print(p1.age). gives you an AttributeError (object person has no attribute age)
Object oriented programming languages usually require what kind of functions?
pure functions:
programs are faster and less error-prone
Can class definitions be empty?
No, but you can use the pass method to avoid the error message (same as functions)
Instance dictionary :
an interval value used by classes
object’s state:
the values of the object’s attributes at any given moment
__str__(self) helps you do what
control what information gets printed for a class.
UML stands for what
unified modeling language
UML definition:
standard diagram for graphically depicting object-oriented systems
top: name of class
middle: attributes
bottom: methods
Inheritance:
when one class inherits from another. It takes on the attributes and methods of the 1st class
parent class:
the original class
child class:
the new class which inherits any or all of the attributes and methods of its parent class AND is also free to define new methods and attributes
“Is a” relationship:
exists when 1 object is a specialized version of another object
-the specialized object has all the characteristics of the general object plus unique characteristics
ex: rectangle is a shape, daisy is a flower
Inheritance is used to create what kind of relationship between classes
“is a” relationship
Superclass (base or parent class)
a general class
subclass( derived or child class)
a specialized class that is an extended version of the superclass but can have its own new attributes and methods added.
Using __init__ for child will initialize any attributes that were defined in the parent __int__() which makes:
all or selected attributes available in the child class
polymorphism:
an objects ability to take different forms
what are some essential ingredients of polymorphic behavior?
- ability to define a method in a superclass and override it in a subclass
(subclass defines method with same name) - ability to call the correct version of overridden method depending on the type of object that called for it
does polymorphism provide great flexibility when designing programs?
yes
AttributeError exception:
raised when a method receives an object which is not an instance of the right class
isinstance function
determines whether an object is an instance of a class
format: isinstance(object, class)
__init__ is short for, and does what
“initialization”, and it is a special method that gets invoked when an object is instantiated
__str__() does what
it is a special method that is supposed to return a string representation of an object
when you print an object python invokes the str method implicitly.
The __str__ method is useful for debugging
polymorphism:
functions that work with several types and encourages code reuse (AKA the intent of object oriented programming CODE REUSE)
