Python Flashcards
1
Q
Boolean Values?
A
Assesses the truth value of something. It has only two values: True and False
2
Q
what are tuples?
A
A type of data that is immutable (can’t be modified after its creation) and can hold a group of values. Tuples can contain mixed data types.
3
Q
what are Lists?
A
A type of data that is mutable and can hold a group of values. Usually meant to store a collection of related data.
4
Q
what are Dictionaries?
A
A group of key-value pairs. Dictionary elements are indexed by unique keys which are used to access values.
5
Q
One of the most important aspects of Python is….
A
indentation. Python has no brackets, braces, or keywords to indicate the start and end of certain code blocks such as functions, if statements, and loops. The only delimiter is the colon (:) and the indentation of the code itself.
6
Q
While loops are often used when…
A
we don't know how many times we have to repeat a block of code but we know we have to do it until a certain condition is met.
For loop example:
for count in range(0,5):
print("looping - ", count)
While loop comparison of above:
count = 0
while count < 5: # notice the colon!
print("looping - ", count)
count += 1
7
Q
What does the break statement do?
A
exits the current loop prematurely, resuming execution at the first post-loop statement, just like the traditional break found in C or JavaScript.
8
Q
What does the continue statement do?
A
returns the control to the beginning of the loop. The continue statement rejects – or skips – all the remaining statements in the current iteration of the loop, and continues normal execution at the top of the loop.
9
Q
What does the pass statement do?
A
is used when a statement is required syntactically but you do not want any command or code to execute. The pass statement is a null operation; nothing happens when it executes. The pass is almost never seen in final production, but can be useful in places where your code has not been completed yet.
10
Q
What are the comparison and logic operators for: is equal is not equal greater than less than greater than or equal less than or equal and or not
A
== != > < >= <= and or not
11
Q
What is a function?
A
a named block of code that we can execute to perform a specific task.
12
Q
How do you define a function?
A
def add(a,b): x= a+b return x
13
Q
What does def add(a,b): x= a+b return x do?
A
it defines the function
14
Q
How do you invoke a function?
A
by using the () after the function name. eg:
add(8,9)
15
Q
What’s the difference between a parameter and an argument?
A
in the following example: def add(a,b): x= a+b return x add(8,9)
a and b are the parameters and 8 and 9 are arguments. We define parameters. We pass in arguments into functions.
16
Q
Why is it important to return a value in a function?
A
So we can use the returned value later in our program.
17
Q
What are common string methods?
A
string.upper()
string.lower()
string.count(substring) returns the # of occurences
string.split(char) splits the string by default at every space or at specified delimiter
string.isalnum() returns boolean depending on whether the string’s length is > 0 and all characters are alphanumeric. Strings that contain anything other than alphanumeric characrers return False
similar methods include .isalpha(), isdigit()
string.join(list) returns a string that is concatenated
string.endswith(substring) returns a boolean
18
Q
What are built-in functions for lists and tuples?
A
max(sequence) returns the largest value in the sequence
sum(sequence) return the sum of all values in sequence
map(function, sequence) applies the function to every item in the sequence you pass in. Returns a list of the results.
min(sequence) returns the lowest value in a sequence.
sorted(sequence) returns a sorted sequence
19
Q
What are built-in functions and methods for dictionaries?
A
Python includes the following standalone functions for dictionaries:
len() - give the total length of the dictionary.
str() - produces a string representation of a dictionary.
type() - returns the type of the passed variable. If passed variable is a dictionary, it will then return a dictionary type.
Python includes the following dictionary methods (either dict.method(yourDictionary) or yourDictionary.method() will work):
.clear() - removes all elements from the dictionary
.copy() - returns a shallow copy dictionary
.fromkeys(sequence, [value]) - create a new dictionary with keys from sequence and values set to value.
.get(key, default=None) - for key key, returns value or default if key is not in dictionary.
.items() - returns a view object of dictionary’s (key, value) tuple pairs.
.keys() - return a view object of dictionary keys.
.pop(key) - returns the value associated with the key and removes the key-value pair from the dictionary.
.setdefault(key, default=None) - similar to get(), but will set dict[key]=default if key is not already in dictionary.
.update(dict2) - adds dictionary dict2’s key-values pairs to an existing dictionary.
.values() - returns a view object of dictionary values.
20
Q
What is an anonymous function?
A
a function without a name. They are created with the lambda keyword. They are good for:
~when we need to use the function once
~when we need to break down complex tasks into small, specific task
~convenient as arguments to functions that require functions as parameters
21
Q
Give an example of a lambda functions.
A
def square(num):
x = num ** 2
return x
lambda method: def square(num): lambda num: num ** 2 or lambda num1, num2: num1+num2
22
Q
Use a lambda to create an element in a list
A
# create a new list, with a lambda as an element my_list = ['test_string', 99, lambda x : x ** 2] # access the value in the list print(my_list[2]) # will print a lambda object stored in memory # invoke the lambda function, passing in 5 as the argument my_list[2](5)
23
Q
Pass a lambda to another function as a callback
A
# define a function that takes one input that is a function
def invoker(callback):
# invoke the input pass the argument 2
print(callback(2))
invoker(lambda x: 2 * x)
invoker(lambda y: 5 + y)
24
Q
Store a lambda in a variable.
A
add10 = lambda x: x + 10 # store lambda expression in a variable
add10(2) # returns 12
add10(98) # returns 108
25
Return a lambda by another function.
```
def incrementor(num):
start = num
return lambda x: num + x
```
26
What is a closure function?
```
A function object that remembers values in enclosing scopes even if they are not present in memory. eg:
# Python program to illustrate
# closures
def outerFunction(text):
text = text
```
```
def innerFunction():
print(text)
```
return innerFunction # Note we are returning function WITHOUT parenthesis
```
if __name__ == '__main__':
myFunction = outerFunction('Hey!')
myFunction()
Run on IDE
Output:
Hey!
```
27
What is a Python module?
Python files with the .py extension which implement a set of functions.
28
How do we bring modules into our code?
Modules are imported using the import command.
| import arithmetic
29
How do we make our own modules?
To create a module, we first create a new .py file with the module name in the same directory as the file that will import the module. Then we import it using the import command and the Python file name (without the .py extension)
30
What is a Python package?
a collection of modules in directories that give a package hierarchy.
from my_package.subdirectory import my_functions
31
What is the purpose of having a file called __init__.py in a directory?
Each package in Python is a folder which MUST contain a special file called __init__.py. This file can be empty, and it indicates that the directory containing it is a Python package, so it can be imported the same way a module can be imported.
The __init__.py file can also decide which modules this package will export as an API, while keeping other modules internal, by overriding the __all__ variable, like so:
```
#file __init__.py:
__all__ = ["test_module"]
```
32
What is OOP?
It allows us to create a blueprint for the purpose of reproducing objects.
33
What does instantiate mean?
Once we've created a blueprint for an object, we have to create an instance of the object. In other words create the object using the blueprint provided.
34
What is class?
```
It is how we define our blueprint and are instructions on how to build many objects that share characteristics.
class User:
pass
```
35
How do we instantiate our blueprint class User: pass?
michael = User()
36
What two things do classes include?
Attributes: Characteristics shared by all instances of the class type. Think about what we want to know about our users, for example. We may decide that all users should have a name and an email. We'll show you how to handle this in the next module.
Methods: Actions that an object can perform. A user, for example, might be able to make a purchase. A method is like a function that belongs to a class. It's some instructions that will only work when called on an object that has been created from that class. We'll show you how shortly.
37
Objects can store 2 different types of information. What are they?
Attributes are characteristics of an object while methods are things an object can do. eg:
```
class User:
# the __init__ method is called every time a new object is created
def __init__(self, name, email):
# the following are the object's attributes
self.name = name
self.email = email
self.logged = False
# this is a method we created to help a user login
def login(self):
self.logged = True
print(self.name + " is logged in.")
return self
#now create an instance of the class
new_user = User("Anna","anna@anna.com")
print(new_user.email)
```
38
What is the __init__() method and when is it called?
It is called every time a new object is created. Python's __init__() method is something that's known as a magic method. Magic methods are automatically created and sometimes invoked when a new instance of a class is created. __init__() is useful because it allows us to set some attributes when a new instance is created. Because we know that the __init__() method will run immediately, we can pass in some arguments to that __init__() method upon object creation. We do not have to explicitly call this method. All we do is create our instance and provide the arguments we like, and the rest is done for us. The arguments we provide will be passed on to the __init__() method.
39
What is an object or instance?
A data type built according to specifications provided by the class definition.
40
What is an attribute?
A value. Think of an attribute as a variable that is stored within an object.
41
What is a method?
A set of instructions. Methods are functions that are associated with an object. Any function included in the parent class definition can be called by an object of that class.
42
What does the self parameter do?
The self parameter includes all the information about the individual object that has called the method. Without self, every time we changed one object's attributes, we'd change the attribute for all the items of that type.
43
What is the benefit of being able to chain methods?
It avoids DRY. eg:
| user1.login().show().logout()
44
If we wanted to define a new class we would start with which line
class ClassName:
45
How can we set attributes to an instance of a class
Initializing our attributes with the __init__() function
| We can set individual attributes to each instance - one by one
46
The __init__() function gets called while the object is being constructed?
False
47
Can you define an __init__() function that has parameters?
No
48
How do you pass arguments to the __init__() function?
When creating an object instance you pass the arguments to the specified class you are creating an instance of
49
What is the purpose of an __init__() function?
To prevent you from rewriting the same code each time you create a new object
To set properties required to execute certain instance methods as soon as the object is instantiated
To execute whatever logic we want to for each object that is created
50
A constructor function cannot call any other methods inside the class.
False
51
What is inheritance in the context of OOP and what are its benefits?
is forming new classes using classes that have already been defined. In other words, it allows one class to take on some or even all of its attributes and methods from a parent class. The benefits of inheritance are code reuse and reduction of complexity of a program. The derived classes (descendants) can override or extend the functionality of base classes (ancestors).
52
What is the syntax to indicate that one class inherits from another?
```
When we defined each of our classes, we typed Bike(Vehicle), Car(Vehicle), and Airplane(Vehicle). You could read each of these like "Make a class Bike/Car/Airplane that inherits from Vehicle". This is what is known as the implicit inheritance, which allows us to use inherited attributes and methods of the Vehicle (parent) class in our new subclasses.
eg:
class Parent:
```
class Child(Parent)
53
What does super mean in the context of OOP?
If we want to be able to refer to the parent's __init__() method, because it still handles setting the other attributes the way we want. This can be true for any method or attribute, we may want to refer to the parent's version. We would reference that parent object with the keyword super. Specifically, we can reference a parent's method by calling super().parent_method(). eg:
class Wizard(Human):
def __init__(self):
super().__init__() # use super to call the Human __init__() method
self.intelligence = 10 # every wizard starts off with 10 intelligence, overwriting the 3 from Human
def heal(self):
self.health += 10 # all wizards also get a heal() method
54
Why might a child class need to call a method that belongs to its parent?
because it handles setting the other attributes the way we want.
55
How can a child class call a method that belongs to its parent?
Specifically, we can reference a parent's method by calling super().parent_method().
56
What should we do if a function should be able to accept variable amounts of arguments?
use the splat operator
57
What does the splat operator do?
```
if you want to pass in a variable number of arguments, or want to capture multiple arguments into a single parameter use the splat operator or the asterisk *
eg:
def varargs(arg1, *args):
print("Got "+arg1+" and "+ ", ".join(args))
varargs("one") # output: "Got one and "
varargs("one", "two") # output: "Got one and two"
varargs("one", "two", "three") # output: "Got one and two, three"
```
58
What is test-driven development?
s a method of developing software that provides a structure to write good code and ensure an end product that has been tested in each phase of development. The model of TDD is as follows:
Design a feature
Write a test that fails (RED). This test will model a specific behavior or outcome in your code
Write the code that will make your feature work and test pass (GREEN). Also, make sure that tests prior to the feature you are working on are still passing!
Refactor your code and improve your design
Move to the next feature and repeat the process
59
How is the cycle of test-driven development different from the traditional development cycle?
As you may have noticed, TDD focuses on testing throughout the entire development process rather than the beginning. Without integrated tests, the software will die as it becomes more complex and ugly because developers don't touch code for fear of breaking it.
60
What are the pros and cons of test-driven development?
The Benefits
TDD will allow us to develop in such a way that:
We have a clear picture of how features should work before building it out
We can develop without the fear of breaking our apps
We can encourage improvement and refactoring of the codebase which will lead to cleaner code
Drawbacks
Larger time investment
Additional complexity of code
More code to maintain
61
When should we use TDD?
TDD is generally not worth the cost when working through Dojo assignments -- except perhaps for the largest ones such as your final projects for a stack. Once you understand a technology area, feel free to apply TDD, but in general we recommend that you focus on learning how to actually build applications for now.
62
How do we import the Python testing framework?
```
Python's unit testing framework, which was previously known as "PyUnit", is included in the Python standard library. To import the module type:
import unittest
```
63
How do we use the Python testing framework to write tests for our code?
Create a new file:
test_even.py
```
# our "unit"
# this is what we are running our test on
def isEven(n):
if n % 2 == 0:
return True
else:
return False
# our "unit tests"
# initialized by creating a class that inherits from unittest.TestCase
class IsEvenTests(unittest.TestCase):
# each method in this class is a test to be run
def testTwo(self):
self.assertEqual(isEven(2), True)
# another way to write above is
self.assertTrue(isEven(2))
def testThree(self):
self.assertEqual(isEven(3), False)
# another way to write above is
self.assertFalse(isEven(3))
# any task you want run before any method above is executed, put them in the setUp method
def setUp(self):
# add the setUp tasks
print("running setUp")
# any task you want run after the tests are executed, put them in the tearDown method
def tearDown(self):
# add the tearDown tasks
print("running tearDown tasks")
if __name__ == '__main__':
unittest.main() # this runs our tests
```
64
How do we run the tests we've written?
if __name__ == '__main__':
unittest.main()
By including these two lines, we can run our test code by executing our python file. Running it with no options results in a simple output but running this file with the -v flag will give you the verbose output with information on each test that was run:
65
What are typical test outcomes in TDD?
When we run our tests, there are 3 possible outcomes:
OK - all tests have passed
FAIL - one or more of the tests have failed, and raises an AssertionError exception
ERROR - the test raises an exception other than AssertionError
In the typical TDD workflow:
Think of Feature->Write Tests->Run & Fail->Code->Run & Pass->Refactor->Repeat
66
How do I find the list of functions/assertions available in the unittest framework?
Visit the following site:
| https://docs.python.org/3.6/library/unittest.html#unittest.TestCase
67
What is a bit?
Everything in a computer is 0's and 1's. The bit stores just a 0 or 1: it's the smallest building block of storage.
68
What is a byte?
One byte = collection of 8 bits
e.g. 0 1 0 1 1 0 1 0
One byte can store one character, e.g. 'A' or 'x' or '$'
69
How Many Patterns With N Bits?
Number of bits Different Patterns
1 0 1
2 00 01 10 11
3 000 001 010 011
100 101 110 111
70
In general, if you add 1 bit what happens?
```
You double the number of patterns.
1 bit - 2 patterns
2 bits - 4
3 bits - 8
4 bits - 16
5 bits - 32
6 bits - 64
7 bits - 128
8 bits - 256 - one byte
Mathematically: n bits yields 2n patterns (2 to the nth power)
```
71
What is 1 byte?
1 byte is group of 8 bits
8 bits can make 256 different patterns
How to use the 256 patterns?
How to store a number in a byte?
Start with 0, go up, one pattern per number, until run out of patterns
0, 1, 2, 3, 4, 5, ... 254, 255
One byte can hold a number between 0 and 255
i.e. with 256 different patterns, we can store a number in the range 0..255
Really good for storing characters/letters.
72
```
What is:
A Kilobyte
A Megabyte
A Gigabyte
A Terabyte
A Petabyte
An Exabyte
```
```
Kilobyte, KB, about 1024 bytes
Megabyte, MB, about 1024 KB
Gigabyte, GB, about 1024 MB
Terabyte, TB, about 1024 GB
Petabyte, PB, about 1024 TB
Exabyte, EB, about 1024 PB
Yottabyte, YB, about 1024 EB
```
73
What is ASCII?
```
Abbreviated from American Standard Code for Information Interchange, is a character encoding standard for electronic communication. It is an encoding representing each typed character by a number. Each number is stored in one byte (so the number is in 0..255)
A is 65
B is 66
a is 96
space is 32, etc.
```
74
What is Unicode?
an international encoding standard for use with different languages and scripts, by which each letter, digit, or symbol is assigned a unique numeric value that applies across different platforms and programs.
75
What is a data structure?
A data structure is simply a container that holds values. Data structures can organize large quantities of data and make certain operations run much faster.
76
What is a linked list?
A data structure that stores values in sequential order. Sounds similar to an array, doesn’t it? Yes, but Linked Lists have other strengths that make them more suited for many problems. Specifically, Linked Lists are optimized for Quick Insertion and Deletion.
The Linked List Object itself only has two attributes, the head and the tail of the Linked List. The head is a pointer to the first node in a List. The tail is a pointer to the last node in this List. This node's next will always be None, meaning there are no nodes following the last node in this List.
77
What is a node?
A node is an object that has a number of attributes that are stored. Only two attributes are mandatory for an Object to be a node: value and next. The value attribute stores exactly that, a value such as a string or a number.
The next attribute is a pointer - a reference to the following node object -- the next kid in line.
78
What is a Singly linked list?
When a node has only next pointers, then we call a Linked List of these nodes a Singly Linked List, also known as an SList. Each of these node objects are more accurately called SLNode objects.
79
What is a Doubly linked list?
If the nodes contain both next and previous pointers, then this is a Doubly Linked List, or DList. Accordingly, each of these node objects would more accurately be called DLNode objects.
80
How do you add a new node to a linked list.
```
Start first by writing the node (SLNode) class:
class SLNode:
def __init__(self, value):
self.value = value
self.next = None
Each new node's next is null until we specify what it should point to.
Next, we will create the SList class.
class SList:
def __init__(self):
self.head = None
self.tail = None
Each new list is empty (contains zero nodes) until we add them to the list.
Now we can run the following code…
list = SList()
list.head = SLNode('Alice')
list.head.next = SLNode('Chad')
list.head.next.next = SLNode('Debra')
```
81
What is a hash table?
is a data structure that implements an associative array abstract data type, a structure that can map keys to values. A hash table uses a hash function to compute an index into an array of buckets or slots, from which the desired value can be found.
82
What is a binary search tree?
sometimes called ordered or sorted binary trees, are a particular type of container: data structures that store "items" (such as numbers, names etc.) in memory. They allow fast lookup, addition and removal of items, and can be used to implement either dynamic sets of items, or lookup tables that allow finding an item by its key (e.g., finding the phone number of a person by name).
83
What is a stack?
A stack is a container of objects that are inserted and removed according to the last-in first-out (LIFO) principle. In the pushdown stacks only two operations are allowed: push the item into the stack, and pop the item out of the stack. A stack is a limited access data structure - elements can be added and removed from the stack only at the top. push adds an item to the top of the stack, pop removes the item from the top. A helpful analogy is to think of a stack of books; you can remove only the top book, also you can add a new book on the top.
A stack is a recursive data structure. Here is a structural definition of a Stack:
a stack is either empty or
it consists of a top and the rest which is a stack;
84
Define polymorphism
Polymorphic behavior allows us to specify common methods in an "abstract" level and implement them in particular instances. It is the process of using an operator or function in different ways for different data input.
```
# We'll use the Person class to demonstrate polymorphism
# in which multiple classes inherit from the same class but behave in different ways
class Person:
def pay_bill(self):
raise NotImplementedError
# Millionaire inherits from Person
class Millionaire(Person):
def pay_bill(self):
print("Here you go! Keep the change!")
# Grad Student also inherits from the Person class
class GradStudent(Person):
def pay_bill(self):
print("Can I owe you ten bucks or do the dishes?")
```
85
What are ORMs?
ORMs are used to create a language-specific object oriented representation of a table. When tables are objects, attributes of these objects represent the columns in the database, while methods will correspond to common queries.
The reason that ORMs are useful is so that we can write pure Python code without having to manage long SQL query strings in our logic.
86
What is the ForeignKey statement?
statement is the equivalent of the one-to-many relationship shown in the ERD diagram.
87
What are routes?
A route is much like a variable name we assign to a request. The job of a route is to communicate to the server what kind of information the client needs. This route name is attached to a route on our server that points towards a specific set of instructions. These instructions contain information about how to interpret the data being sent, the operations that need to be completed, and the response that should be sent back. These instructions are the code we'll be creating!
Every route has two parts:
```
HTTP method (GET, POST, PUT, PATCH, DELETE)
URL
```
88
What is the HTTP request/response cylce?
Your browser makes a request to a URL and receives a response from the web server, displaying the HTML, CSS and JavaScript in your browser.
Imagine doing your holiday shopping online. While filling your shopping cart with the gifts you've selected you will do the following:
```
Visit the home page of your retailer of choice
Log into your account
Submit search queries
Browse the items from the resulting list
View select items in detail
Add certain items to your shopping cart
Check out
Receive confirmation of your order
Each one of those steps along the way is a full HTTP request/response cycle. It begins with your browser sending a request, and ends with the browser rendering a response from the server.
```
89
In the HTTP request/response cycle what does it mean to be stateless?
That means that each request/response cycle instance is independent and ignorant of any instances that came before or will come after it. This matters because, along with each request, your favorite retailer always knows and remembers:
Who you are (your account)
What you've searched for
The items in your cart
etc...
90
What is session?
Persistent data storage that allows users to read pieces of data that was stored in previous cycles and write certain valuable pieces of data for use in future cycles. In other words, the user can make decisions that can be tracked so that the server can respond appropriately to create a better user experience.
91
What is a cookie?
used to store data like sessions. sends a packet of information from the server to the client. This packet is known as a cookie. Once your browser has received this cookie, it writes the information contained in it to a small file on your hard drive. Django stores session data in the database, sending only secure keys that can be used to retrieve data from a database only when required.
92
What are hidden input fields?
form fields that are hidden from the user. Hidden input is used, along with other input elements, to transfer information between different pages.
A hidden input is just an ordinary input element but has a type of "hidden", which means there will be no visual representation in the rendered HTML, but the form element IS usable by the method where the form is sent. But know that, even though hidden inputs are invisible to the user, it is actually very visible in the page's source. That means other users can still see and change the values you set in the hidden input. So be very careful in choosing what data you store in there as value, and set appropriate actions if a user tries to change or remove it.
93
What is a database?
Databases are merely collections of organized information that can easily be accessed, managed, and updated.
94
What is ERD?
ERD is short for 'Entity Relationship Diagram'. That's just a fancy way of saying that ERDs are essentially visual blueprints for how your database looks and behaves. ERDs and SQL work together very intimately. An ERD is a map of the structure of how we want to store our data, and SQL is the language we use to manipulate the data as per the relationships we defined in our ERD. Learning database design first will help us visualize how our relational databases look, making it much easier to pick up the actual SQL syntax.
ERD is a process of laying out your tables and establishing relationships between them, making your data relational. Just about any data imaginable can be stored in a relational manner, there really isn't anything you can't do using a relational database like MySQL.
95
What does the acronym DRY mean?
Do Not Repeat Your code or your data
96
What are the types of database relationships?
One to One
One to Many
Many to Many
97
What does it mean to normalize your data?
It means we normalize our tables to insure the data is not repeated and ultimately use our storage space more efficiently. Also we make our database more modular so that we can create more variety of customized tables.
98
What are the 3 forms of database normalization?
First Form
Each Column in your table can only have 1 value.
Ex. You should not have an address column in your table that lists the address, city, state, and zip, all separated by commas.
Second Form
Each Column in your table that is not a key (primary or foreign) must have unique values.
Ex. If you have a movies table with a categories column, you should not have a category repeated more than once.
Third Form
You cannot have a non-key column that is dependent on another non-key column.
99
```
A real world parallel of a primary key would be which one of the following:
Social Security Number
Birthday
Street Address
Last Name
```
Social Security Number
100
Which of the following relationships requires a foreign key?
Many to Many
One to One
One to Many
All of the Above
All of the Above
101
Which of the following is the best example of a many to many relationship
users have many photos and photos have many users
users have many interests and interests have many users
blogs have many posts and posts have many blogs
messages have many comments and comments have many messages
users have many interests and interests have many users
102
Which of the following violates the first form of normalization
Having a column in your products table called assembly which contains the information for how to assemble the product.
Removing the type column from your products table and adding a relationship of 'products has-many types'
Having a column in your products table with a comma-separated list of all the different categories that the product belongs to
Separating out price from the products table to create a prices table with a relationship of 'products has-one price'
Having a column in your products table with a comma-separated list of all the different categories that the product belongs to
103
In a One to One relationship the joining tables are related by having a foreign key in both tables
True
False
False
104
In the relationship of 'states has-many cities', the foreign key that joins the tables together goes in the states table.
False
105
To pass the second form of normalization, you should find any non-key columns that have repeated values and separate them out into another table and create the proper relationship.
True
106
A users table with profile_pic_name and profile_pic_url columns
A pictures table with url and name columns
A many to many relationship without a joining table
Having an interests column in your students table that lists out each students different interests
A users table with profile_pic_name and profile_pic_url columns
107
What is the most important thing to remember about database design?
Making sure we don't repeat data
108
What is the main purpose for Normalization?
Creating a convention for organizing and avoiding the duplication of data
109
Define information hiding.
Allows us to use other people's code without having a deep understanding of how it was written
110
Define modularity.
Breaks down complex logic into smaller components or modules and makes it easier for someone else to read, understand, use and build upon our code.
111
Define abstraction.
When programmers generalize code so that they can reuse the same functions in multiple situations across a project to maximize its usefulness. It reduces a code's complexity, especially for larger projects.
112
what are built-in functons.
functions that python has defined for us.
113
what are optional arguments?
they have default values that they take on unless a different value is provided by the user.
114
When do runtime errors occur?
When the code is actually running, which makes them harder to catch and prevent beforehand. Examples are:
~calling a function before it's defined
~calling a method or attribute that the object doesn't contain
~attempting to convert a value to an incompatible data type
115
What does python's interpreter use to represent errors?
The SyntaxError class and displays the error message after the colon. The interpreter may sometimes struggle to pinpoint the problematic code that caused the error.
116
What is dot notation?
When we import a module, we can access its functions and variables using a period.
eg
my_module.some_function
117
Define namespace
a dictionary that contains all of the names we can refer to in our code. The python interpreter adds all of the objects and functions that are available by default ie print(), list(), etc to the global namespace.
118
how do you open a csv file?
open_csv = open('dataset/myfile.csv', 'r')
| it returns a delimited string
119
why use the csv module?
we can work with csv files more easily. it has a reader() function that takes a file object as its argument and returns an object that represents the data. ie.
import csv
open_csv = open('dataset/myfile.csv', 'r')
csvreader = csv.reader(open_csv) #creates an object
my_data = list(csvreader) #convert to a list
120
What is python's self variable that is used when defining a class?
It is used to refer to the created object so you can interact with the instance. If you didn't have self, then the class wouldn't know where to store the internal data you wanted to keep. By convention self is used to define the instance even though it's possible to use any name.
121
What's a great function to help search and extract both the index and label of a list?
enumerate()
