None

None

What ever the value of the variable "true" is. Use True to represent a boolean value.

and

or

not

Cast it to int: print(int(19))

Cast it to float: float() or enter it as a float: 2.24 or 2.0

TypeError: unsupported operand type(s) for +: 'float' and 'str'.

Python does not automatically convert types like Javascript does.

Math.pow() is Javascript. ** is Python

// is integer division in Python

The reverse of modulo, where the answer is rounded:

'''. Then line breaks will be preserved:

    print('''My instructions are very long so to make them
    more readable in the code I am putting them on
    more than one line.  I can even include "quotes"
    of any kind because they won't get confused withthe end of the string!''')

Yes, but convention is to reserve """ for multi-line comments and function doc strings.

    def print_hello(name):
    """
    This is a docstring that explains what the function does.
    It can be multiple lines, handy!
    You can use any combination of ' and " in these becausepython is looking for ending triple " characters
    to determine the end.
    """
    print(f"Hello, {name}")

    print_hello('Mary')

    Output:
        Hello, Mary.

len("Spaghetti") -> returns 9

print ("Spaghetti"[-1])

print("Spaghetti"[1:])

print("Spaghetti"[4:-1])

No!

Yes! IndexError: string index out of range

No!

IndexError: string index out of range

Spaghetti

Spaghetti

An empty string

An empty string. Remember, the last argument is one past the index you want.

"mystring".index("s")

print("Spaghetti".count("t")) : prints 2

print("gold" + "fish")

print("Your name is {0} {1}".format(first_name, last_name))

print(f'Your name is {first_name} {last_name}')

s.upper()

s.lower()

s.islower()

is.upper()

s.startswith("He")

s.endswith("lo")

s.split() : This is like Javascript split, but no input is considered splitting on spaces.

s.split("-")

No. Your original string remains intact. s.upper() returns a copy of the string, converted to upper case

s.isalpha()

isdecimal()

isalnum()

isspace()

istitle()

It is better to ask for forgiveness, than ask for permission.

If it looks like a duck and quacks like a duck, then it must be a duck

This is where <try> blocks should be used to enforce data integrity

Variables are block scoped.

Yes. Much like let in javascript

Yes

No. Use ==

Nope. They're the same

• Negative signs (not) are applied first (part of each number)
• Multiplication and division (and) happen next
• Addition and subtraction (or) are the last step

print (a == (not b)) not must either be on the left of the expression, or must be separated with parens. Otherwise python will try to evaluate (a == not) first. (Left to right)

Yes.

When the left side of the comparison determines the outcome, the right side is not evalutated

Yes

No

No

Yes

• **=
• //=

    if name == 'Monica':
      print('Hi, Monica.')
    elif: age < 12:
      print('You are not Monica, kiddo.')
    else:
      print('You are neither Monica nor a little kid.')

    for c in "abcdefg":
        print(c)

for i in range(5):

    a = range(5)
    print(list(a))

Dictionaries

{}. Think Dictionaries are the same as Javascript key/value pairs - and they are Javascript objects.

    spam = {'color': 'red', 'age': 42}
    for v in spam.values():
      print(v)

    spam = [('color', 'red'), ('age', 42) ]

    for k, v in spam:
      print('Key: ' + k + ' Value: ' + str(v))

continue

break

    spam = 0
    while True:
      print('Hello, world.')
      spam += 1
      if spam < 5:
        continue
      break

Replace the "function" keyword in Javascript with the "def" keyword. Also add a ":" at the end of the function declaration.

    def printCopyright():
      print("Copyright 2020. Me, myself and I. All rights reserved.")

    def add (num1, num2):
      return (num1 + num2)

    print(add(2, 3)) # <= 5

    def greeting(name, saying="Hello"):
      print(saying, name)

    greeting("Monica") #=> Hello Monica
    greeting("Monica", saying="Hi") #=> Hi Monica

Using a mutable object for a default parameter will yield unexpected results. All invocations of the function reference the same mutable object:

    print(appendItem('notebook')) #=> ['notebook']
    print(appendItem('pencil)) #=> ['notebook', 'pencil']
    print(appendItem('eraser')) #=> ['notebook', 'pencil', 'eraser']

Lambda

    toUpper = lambda s: s.upper()

    toUpper('hello') #=> HELLO

Lambda functions, although they may be written as multi-line functions, it is considered bad form to write a multi-line Lambda function. If they can't be written on one line, better to use a regular function in Python.

Unlike Javascript, Python will throw an error.

# => TypeError: average() takes 2 positional arguments but 3 were given

    def add(a, b, *args):
        total = a +
        for n in args:
          total += n
        return total

add(1, 2)  # Args is none, returns 3
add(2, 3, 4, 5) #args is 4 and 5, returns 14

Keyword arguments use the name of the params in the function declaration to assign values in the function call.

    def my_function(child3, child2, child1):
        print("The youngest child is " + child3)

    my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")

Yes. You can pass your arguments in any order when you're using keyword arguments.

    # kwargs would be:
    #  {
    #    'Monica': 'Sweden',
    #    'Charles': 'British Virgin Islands',
    #    'Carlo': Portugal
    # }

    # prints:
    #Hi Monica from Sweden
    #Hi Charles from British Virgin Islands
    #Hi Carlo from Portugal

{'Monica': 'Sweden', 'Charles': 'British Virgin Islands', 'Carlo': 'Portugal'}

Yes. arg_1, arg_2 are positional parameters. *args would take the rest of the unnamed arguments, kw_1 and kw_2 are default keyword args, and the rest of the args go into kwargs.

    arg_1:  Arg1
    arg_2:  Arg2
    *args:  ('args1', 'args2', 'args3')
    kw_1:  myShark
    kw_2:  blowfish
    kwargs:  {'Hello': 'Hello', 'Monica': 'Sweden', 'Charles': 'British Virgin Islands'}

Yes!

print(1 in [1, 2, 3]) #>True

specials = list()

empty_list = []

Unordered collection of distinct objects

Sets use curlies like dictionaries: school_bag = {'book', 'paper', 'pencil' }

The same way you test an element is in a dictionary:
Print(1 in {1, 1, 2, 3}) #> True

Tuples are immutable lists of items

    a = { 1, 2, 3 } # > Create a set
    a = tuple(a)    # > Cast it to a tuple

Tuple. You can declare a tuple with or without parenthesis.

The same way you test a value is in a set or dictionary: print(1 in (1, 2, 3)) # > True

A range is an immutable list of numbers. Often they are used in for loops

• start : 0 if not supplied. The first number in the sequence
• stop : the next number past the last number in the sequence
• step: 1 if not supplied; the difference between each number in the sequence

Only the stop param is required.

    range(5)  # > range(0,5) ... or list(range(5)) yields [0, 1, 2, 3, 4]

range(0,25,5) # > [0, 5, 10, 15, 20]

    def isOdd(num):
        return num % 2
    filtered = filter(isOdd, [1,2,3,4])   # > <filter object at 0x10d565a90>

    print(list(filtered))                 # > [1, 3]

    def toUpper(str):
      return str.upper()

    upperCased = map(toUpper, ['a', 'b', 'c'])    # > >map object at 0x10d5658b0<

    print(list(upperCased))                       # => ['A', 'B', 'C']

    sortedItems = sorted(['Banana', 'orange', 'apple'], key=str.lower, reverse=True)

    quarters = ['First', 'Second', 'Third', 'Fourth']
    enumerate(quarters)                                # > >enumerate object at 0x10d585080>
    print(enumerate(quarters, start=1))                # [(0, 'First'), (1, 'Second'), (2, 'Third'), (3, 'Fourth')]

Use zip:

    coords = zip(x_coords, y_coords, z_coords)
    print(list(coords))                         # => [ (0, 2, 3), (1, 3, 5), (2, 5, 2), (3, 3, 1), (4, 5, 4)]

len([1, 2, 3]) # => 3

len({ 'Name': 'Bob', 'Email': 'bob@bob.com'}) # > 2

max[1, 4, 6, 2]

min([1, 4, 6,2])

sum(1, 2, 3)

any([True, False, False]) : This applies to truthy/falsey values as well

all(['a','b','c']) # > True

dir()

['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']

Without a __init__.py in your import directory: from tree import Node

With an __init__.py in your import directory: from .tree import Node

In your math directory, add the file named __init__.py Then add the following lines to __init__.py:

    from .addition import add
    from .subtraction import subtract
    from .division import divide
    from .multiplication import multiply

from math import add

    class AngryBird:
        def __init__(self, x=0, y=0):
          self._x = x
          self._y = y

    #Getter
    @property
    def x(self):
        return self._x

    #Setter
    @x.setter
    def x(self, value)
        if value < 0:
            value = 0
        self._x = value

    #Dunder Repr ... called by 'print'
    def __repr++(self):
        return f"<AngryBird ({self._x}, {self._y})>" "

def __init__(self):

super().__init__()

They are a way to transform a list from one format to another. They are a Pythonic alternative to using map or filter

Remember, the format for a list comprehension is: newList = [value loop condition]

    squares = [i**2 for i in range(10)]   # => Where i**2 is the value, and for i in range(10) is the loop

Remember, the format for a list comprehension is: newList = [value loop condition

Here the value is the character we're printing, the loop is for each character in the sentence, and the condition is the if statement

    sentence = 'the rocket came back from mars'
    vowels = [character for character in sentence if character in 'aeiou']

    print(vowels)   # => ['e', 'o', 'e', 'a', 'e', 'a', 'o', 'a']

    newPerson = { key.title(): value for key, value in person.items() }

First, what will the for-loop look like to do this?

    for key, value in person.items():                 # To get the key and the value, use the items() method
        newPerson = { key.title() : value.title() }   # Title case both the key and the value
        print(newPerson)                              # Just so we can see what we've done to confirm

  {'Firstname': 'Corina'}
  {'Lastname': 'Jones'}
  {'Hometown': 'Concord'}

newList = [value loop condition]

value:  { key.title() : value.title() }
loop:  for key, value in person.items()

    newPerson = { key.title(): value.title() for key, value in person.items() }
    print(newPerson)

    #prints:  {'Firstname': 'Corina', 'Lastname': 'Jones', 'Hometown': 'Concord'}