Untitled Deck

Question 1

snake_case is used for

Answer 1

variables and functions

Question 2

core types

Answer 2

can be checked with method type()

Question 3

extend()

Answer 3

can concatenate two lists;
list1.extend(list2)

Question 4

identity operators

Answer 4

check for types;
is / is not

Question 5

dictionaries

Answer 5

unordered and mutable

Question 6

tuples

Answer 6

ordered but immutable, allowing duplicates. Should be used for values that will not change.

Question 7

count()

Answer 7

count occurrences of something;
item.count(x)

Question 8

index()

Answer 8

returns position of the first instance of that value;
item.index(x)

Question 9

floor division

Answer 9

rounds down if the result is a decimal

Question 10

list comprehensions

Answer 10

listname = [(process) for x in range(y)];
outputs the result of the process over the range

Question 11

list slicing

Answer 11

list[starting index, ending index + 1];
excludes last number

Question 12

dictionary access / assignment

Answer 12

my_dict[‘key’] = value

Question 13

continue

Answer 13

continue skips the current iteration and moves to the next if condition is/n’t met

Question 14

break

Answer 14

exits the loop if the condition is/n’t met with no more iterations

Question 15

class

Answer 15

a definition for a variable to act a certain way and comply with new functions

Question 16

object

Answer 16

an instance of a class, following the rules of that class with unique data;
object = myClass(a1, a2…)

Question 17

__init__

Answer 17

a constructor; automatically called when an object of a class is created.
initializes (confirms + stores) the unique attributes

Question 18

inheritance

Answer 18

a subclass inherits properties and methods from an existing class; promotes code reuse;
class Animal: …
class Dog(Animal): …
both have function speak(self)

Question 19

super()

Answer 19

within a subclass, super() calls methods from the superclass without adding them to the subclass.
often used in the __init__ method for the subclass to initialize attributes inherited from the superclass

Question 20

encapsulation

Answer 20

the bundling of attributes and methods into a single unit and restricting direct access to come of the object’s components;
coupling attributes into a class to protect the integrity of the data

Question 21

polymorphism

Answer 21

the ability of an object to take on many forms;
methods can be overwritten in subclasses with super().func()

Question 22

refactor

Answer 22

third step of TDD: clean up code after ensuring the tests pass

Question 23

atomic operations

Answer 23

performed as a single, uninterruptible step;
arithmetic, variable assignment, branching statements.jumps,

Question 24

all dictionary operations are

Answer 24

of O(1) time complexity

Question 25

adding and removing items from sets

Answer 25

O(1)

Question 26

list indexing, adding to and popping from lists are

Answer 26

O(1) time complexity

Question 27

list operations at specific indexes

Answer 27

O(n-i) time complexity

Question 28

searching for x in a list

Answer 28

O(n) time complexity

Question 29

list splicing

Answer 29

O(b - a)

Question 30

adding lists

Answer 30

O(n1 + n2)

Question 31

sorting a list

Answer 31

O(n log n)

Question 32

order of time complexities:

Answer 32

O(1), O(log n), O(n), O(n log n), O(n^2), O(n^x), O(2^n), O(n!)

Question 33

methods for reducing time complexity

Answer 33

eliminate unnecessary repeated work, use sets / dictionaries for faster lookups, remove slow parts of the algorithm

Question 34

a loop runs while n > 1, and n // 2 after every iteration

Answer 34

O(log n)

Question 35

nested loops iterating over the same variable

Answer 35

O(n^x)

Question 36

nested loops iterating over different variables

Answer 36

O(n * m)

Question 37

max and min

Answer 37

O(n), if unsorted

Question 38

push(item)

Answer 38

add to top of stack

Question 39

pop()

Answer 39

removes from top of stack

Question 40

peek()

Answer 40

views next removable item without removing

Question 41

enqueue(item)

Answer 41

add to back of queue

Question 42

dequeue()

Answer 42

removes from front of queue

Question 43

implementing stack

Answer 43

list wrapper; python list, append + pop

Question 44

implementing queue

Answer 44

track front with head index; dequeue increments head; cleanup when head > len/2

Question 45

.capitalize()

Answer 45

capitalizes first letter of a string

Question 46

if a subclass has new variables

Answer 46

init separately under def__init__; inherit other variables with super().__init__(var)

Question 47

if a subclass has a similar function

Answer 47

inherit base functionality with super.function(), adding extra conditionals before or after to match

Question 48

unittest formula:

Answer 48

import unittest class TestClassName(unittest.TestCase): def test_func(p1, p2...): # define values + run process self.assertEqual(expected result of process) unittest.main()

Question 49

__str__

Answer 49

returns a readable string representation of an object;

Question 50

.join()

Answer 50

joins iterables by a separator: "separator".join(obj)