Python

• python3 my_program

• You can launch a python interpreter from the command line by just typing python or python 3 for python 2 or 3 respectively
• quit() or exit()
  • quit the shell
• iPython
  • basically an interactive shell version of a Jupyter notebook. The basis on which Jupyter Notebook was built.
  • I think I like this as my preferred REPL now. A lot of people use it like Tom Lynch
• bpython
  • alternative python shell
  • https://bpython-interpreter.org/
  • pip install bpython
  • syntax highlighting and completion
  • colors

• I like to alias python to python3 though
• python --version
• -c
  • Tells Python you are going to pass it a string containing Python code.
  • e.g. python -c “import this”

• edit /etc/rc.local
  • “and add a command to execute your script between the commented section and exit 0. Something like:
    • python3 /home/pi/foo.py&
      • The ampersand at the end will run the script as a background process, which will allow all the other services of the Pi to continue booting up.”

• py2exe
• PyInstaller

• Add shebang line to top of script
  • #!/usr/bin/env python3
    • this searches at runtime for your environment
    • you could specify the path to your python but it's a little more portable this way, although the first way isn't fullproof
• Make your script executable
  • chmod +x my_script.py
• You still need to run the script with ./my_script.py because otherwise the shell automatically searches for the program in the PATH variable in which it won’t be able to find your script unless you put it there manually.

• import subprocess
• subprocess.run(['echo', 'hello'])
• mvn = subprocess.run(['mvn', 'clean', 'install'], cwd='/Users/evan/Dropbox/Development/Neighbor Share/neighbor-share') print(mvn)
• cwd='/Users/evan/Dropbox/Development/Neighbor Share/neighbor-share'
• backup = subprocess.run(['ssh', 'neighborshare@neighbor-share.org', 'mv', 'neighbor-share/neighborshare-0.0.2-SNAPSHOT.jar', 'neighbor-share/neighborshare-0.0.2-SNAPSHOT.jar.bak'])
• restart = subprocess.run(['ssh', 'neighborshare@neighbor-share.org', 'sudo', 'systemctl', 'restart', 'neighborshare.service'])
  • systemctl restart allowed without password due to that command being added to the /etc/sudoers.d/ directory
• Make a given BASH command that normally requires a sudo password not require a password ^Linux

• python -c 'print("Hello World!")'

• add alias python='python3' at the end of .bash_profile

• https://docs.python.org/3/library/argparse.html

• CircuitPython

• Gunicorn

• Syntax Highlighting
  • Black - Data & variables
  • Green - Strings
  • Purple - Functions
  • Orange - Commands
  • Blue - User functions
  • Dark Red - Comments
  • Red - Error Messages

• exits function at that point
• Python auto adds return None to end of every defined function that doesn't have a return statement
• basically makes the function evaluate to something from within the function as opposed to just printing it or something so that you can use it with other things more directly and usefully.
• All functions return a value. If no return keyword is used the value returned is None as in the print() function. Similar to how loops implicitly add the continue statement at the end of the loop.
  • e.g., can assign a function to a variable to give that variable the value returned from the function.
• Whenever the function executes a return statement, the function is immediately exited and statements after it won’t be executed.
• You could use return (with no value) to exit the function at that specific point.

• Def f(parameter1, parameter2):
• Determined merely by their position in the function

• Determined by the = sign
• def function(keyword = 0, keyword2 = 2):
  • Both are optional. If the keyword arguments are specified in the function call, that value overwrites the value given in the function definition. Otherwise, the value defaults to 0 and 2 (as specified in the function definition).

• mutates or changes the internal state of the object.

• values, integers, etc.

• things that the object knows about itself

• x, y point example
  • class Point: """ Point class for representing and manipulating x,y coordinates. """ def __init__(self): """ Create a new point at the origin """ self.x = 0 self.y = 0

• some_variable = SomeClass()
• "The combined process of “make me a new object” and “get its settings initialized to the factory default settings” via the __init__ method is called instantiation."
• Instances
  • An object that belongs to a class. The terms instance and object are used interchangeably.
  • Technically you can create a new object with the same variable and the existing object doesn't go away.

• aka fields or ?properties? in other languages
• Variables in a class are called attrbiutes
• Instance Attributes
  • (variables)
  • Instance Attributes
    • owned by the instance
• Class Attributes/Static Attributes
  • Just define them outside of a method
  • Class Attributes
    • owned by the class itself
    • shared by all instances of the class
    • usually placed at top of class definition right below header
    • accessed same way instance attributes are
    • General Example
      • class Shark: animal_type = "fish"
  • Static Attributes
• Delete an object's attribute
  • del someObject.the_answer
• Constants? Final like Java?

• Python does not have a builtin concept of private and public like Java. You can modify any attribute and field.
• static annotation? method?
• _underscore_methods indicate that they are to be treated as private and not messed with/not guaranteed to not change and thus could break your code if you alter them

• super keyword?
• If any new attributes or methods have the same name as an attribute or method in our parent class, it is used instead of the parent one.
• Don't use () when a class is the most super class or doesn't use inheritance. It's ok not to use () but it might be a good practice to stick to since you can deduce that the class is not doing inheritance.
• Subclass
• Superclass
• Parent Class
• Child Class
• Create a subclass of an imported module's class
  • import turtle class StarTurtle(turtle.Turtle): def star(self, numpoints, radius): for i in range(0, numpoints): self.forward(radius) self.back(radius) self.left(360 / numpoints)
• Call a method in another class:
  • Cat.noise(self)
  • vs some_instance.noise() if you wanted noise() from the instance's class. Since self doesn't line up correctly outside its own class, you need to specify the class you want the method from and then pass the self variable as a parameter so it gets passed correctly in that class.

• e.g. print() can print strings, objects, integers, etc.
• e.g. square.draw() and circle.draw() use the same interface/method to draw itself, even though the underlying code is pretty different. You wouldn't need to know which class a given reference is - you can just call .draw() on it and you know it will work.

• Python 3.7

• print(someObject) returns <__main__.SomeClass object> unless there is a __repr__ or __str__ method defined in the object's class
  • In other words, you as the programmer get to choose what a someObject object should look like when it gets printed.
• __repr__
  • def __repr__(self): return "x=" + str(self.x) + ", y=" + str(self.y)
  • It is required that the __repr__ method create and return a string.
• __str__
  • does essentially the same thing as the __repr__ method.
  • the print function would invoke the __str__ method. Technically, this is the first thing it tries to do, and then it falls back on invoking the __repr__ method.
  • the str() type converter function will use whatever __str__ method we provide. We have "overridden" the str()s method functionality for that class.
• Returning a List as a String
  • When trying to return a string from a list in a class via __str__ or __repr__ methods, if the elements in the list are objects from another class, those elements need to be returned via the __repr__ method in that class. If the elements in the list use the __str__ method, the list elements will return <__main__.ClassName object>. I think this is due to how the str() function works on lists - if you want it to apply to each item, str() uses __repr__ to do so, not __str__. The other class that returns the list itself can be either __repr__ or __str__
    • class SomeClass(): def __init__(self, some_list): self.some_list = some_list def __str__(self): return str(self.some_list) class AnotherClass(): def __init__(self, name): self.name = name def __repr__(self): return self.name element1 = AnotherClass("element1") element2 = AnotherClass("element2") some_list = [element1, element2] some_object = SomeClass(some_list) print(some_object)
    • https://stackoverflow.com/questions/727761/python-str-and-lists

• Python has a powerful feature that allows a designer of a class to decide what an operation like == or < should mean. E.g., sometimes the class creator will attach shallow equality semantics, and sometimes deep equality.
• __add__():
  • changes what the + operator does

• aka magic methods or dunder methods
• __someSpecialMethod__
  • dunder naming for special methods in classes
  • e.g.
    • __init__
    • __repr__
    • __str__
    • __add__

• #issue

• # Then, create some instances of classes in the dictionary: dictionary["DoubleSquare 1"] = DoubleSquare(5) dictionary["long rectangle"] = Shape(600,45) #You can now use them like a normal class: print(dictionary["long rectangle"].area()) dictionary["DoubleSquare 1"].authorName("The Gingerbread Man") print(dictionary["DoubleSquare 1"].author)

• Note capital letter
• top level class (no parents)
• has child (below - Inanimate class)

• child of Things class

• also child of Things class

• child of Animate class

• creates object in Animals class & assigns it to variable jerry
• This is an 'instance' of the class Animals, but sometimes just called an 'object' of the Animals class or a 'member' of the class

• creates an object or instance of the Pen class that is provided by the turtle module. So it is basically providing the 'full path' to where the class is located?

• https://www.sqlalchemy.org/

• Displays data type of given variable

• One word
• Letters, numbers, _
• Can’t begin with a number
• Case sensitive
• Python convention is to start variable names with a lower case letter

• cats = [bob, bill, harry,] a, b, c = cats
• a, b, c = 1, 2, 3

• a, b, = b, a

• Code in the global scope cannot use any local variables.
• However, a local scope can access global variables.
• Code in a function’s local scope cannot use variables in any other local scope.
• You can use the same name for different variables if they are in different scopes. That is, there can be a local variable named spam and a global variable also named spam.

• In a function's local scope, unless there is a parameter or assigned variable with the same name, you can read a global variable from a local scope without needing to use global.
• But if you need to modify a global variable from within a function, since you need to use the assignment operator which defaults to local in a function, you would need to use global. I think you just need to use global once since it is defining it for that whole local scope from then on.

• If a variable is being used in the global scope (that is, outside of all functions), then it is always a global variable.
• If there is a global statement for that variable in a function, it is a global variable.
• Otherwise, if the variable is used in an assignment statement in the function, it is a local variable.
• But if the variable is not used in an assignment statement, it is a global variable.

• The two objects point to/refer to the same location in memory.
• i.e. they refer to the same, identical, object.
• E.g., changing a field/property in one object, changes it in both references (because it refers to the same object).

• Two different objects, based on your equals() method implementation, have equal values.

• Since strings are immutable, Python optimizes resources by making two names that refer to the same string value refer to the same object. (like the tentacle analogy for variables)
  • e.g.: string1 ='abc' string2 ='abc' string1 == string2 # returns True string1 is string2 # also returns True
  • Contra lists
    • 2 Lists with the same values/elements are not the same object because the list is an object above the elements of the list. Each element of the list might be the same instances, but the lists would still be different. That is, if 2 lists have the same element values they would == each other, but they would not be the same object (is)
    • e.g.: a = [1, 2, 3] b = [1, 2, 3] a == b # returns True a is b # returns False
      • Here, they are different objects (is), but they == each other because these lists are evaluated via 'deep equality'

• Shallow equality only compares the references, not the contents of the objects.
• ?"Equality of references, or two references that point to the same object."?
• Deep equality compares the values “deep” in the object, not just the reference to the object.
• "Equality of values, i.e., two references that point to objects that have the same value."
• If two variables refer to the same object, they have both shallow and deep equality.
• For example:
  • list1 == list2 checks deep equality (will check if their values are equal and return True if they are, even if they are independent objects (even if list1 is not list 2).
  • But with 2 instances of a class, a == b normally would check shallow equality and return False since they are 2 different references, even if they had the same internal values inside each instance

• copy.copy() & copy.deepcopy()
  • import copy
  • copy.copy()
    • shallow copy
  • copy.deepcopy()
    • deep copy
  • normally a variable given a list value is just a reference to the list. So if you have 2 variables that refer to that same list, changing the list via one list, changes it in the other variable since it is the same list by 2 different names.
  • ?So a copy of a variable with a list value operates in this same way - changing one, changes both. This is called a shadow copy?
  • ?deepcopy() when you want to?

• a = [1, 2, 3] b = a[:] # or b = list(a)
  • 2 independent, separate instances of a list - it was cloned and has the same values after the clone but you are free to edit each list independently because they are not linked in anyway after the clone.
• "So if we don’t want to alias the list, we need another option. If we want to modify a list and also keep the original list intact and unchanged, we need to be able to make a copy of the list itself, not just the reference. This process is sometimes called cloning, to avoid the ambiguity of the word copy. The easiest way to clone a list is to use the slice operator. Taking any slice of a creates a new list. In this case the slice happens to consist of the whole list."

• Will typically return the same id value for the same object, but apparently there are rare cases when it is not synonymous with is.

car1 = Car() u>>> car1.wheels = 4 v>>> car2 =
car1 car2.wheels = 3 print(car1.wheels) 3 Why is the result of the
print statement 3, when we clearly set 4 wheels for car1 at (1)?
Because at (2), both variables car1 and car2 are pointing at the
same object. Now, what about the second print statement?
car3 = copy.copy(car1) car3.wheels = 6 print(car1.wheels) 3 In
this case, car3 is a copy of the object; it’s not labeling the
same object as car1 and car2. So when we set the number of wheels
to 6, it has no effect on car1’s wheels.

• whole number
• int()
  • Changes a data type to an integer

• decimal
• float()
• Floating Point Inaccuracy
  • many scenarios
  • One way to accept approximate equality:
    • abs(a**2 + b**2 - c**2) < 0.001
      • Instead of a ** 2 + b ** 2 == c ** 2 (Pythagorean Theorem) this will result in true if it is within .001

• real and imaginary

• int
  • whole number
• long
  • bigger whole numbers
• float
  • decimals
• complex
  • real and imaginary
• Narrow vs wide types
  • int is narrower than float, float narrower than complex, etc. because you can “fit” narrow types into wider ones
  • When doing operations among different type widths the rule of thumb is that Python converts the narrower type to the wider type and then does the operation
• Dividing whole numbers returns the quotient without the remainder - it doesn’t automatically convert to float or anything, unlike Python3

• When used in conditions, 0, 0.0, and ‘’ (the empty string) evaluate to Boolean False and all other values in those data types evaluate to True.
• So you could check if the user inputted anything for example so it would be True if so, and False if nothing was inputted. They're not exactly Boolean but they work. But best practice is to be more explicit and clear.
• int(True)
  • 1
• int(False)
  • 0
• float(True)
  • 1.0
• float(False)
  • 0.0

• Are boolean True if non-trivial, False if trivial

• common to give boolean functions names that sound like yes/no questions - e.g.,  is_divisible
• can make the function more concise by taking advantage of the fact that the condition of the ifstatement is itself a boolean expression. We can return it directly, avoiding the if statement altogether: def is_divisible(x, y): return x % y == 0
• It might be tempting to write something like if is_divisible(x, y) == True: but the extra comparison is not necessary. 
• Helps make code very expressive and readable

• returns the boolean value of the argument

• num == 5 or 6 or 7, it will not be correct. The or operator must join the results of three equality checks. The correct way to write this is num == 5 or num == 6 or num == 7
• Might be possible now? with chaining?

• Normally represents the absence of a value
• e.g. the return value of print() etc.
• Similar to null in other languages
• Boolean false
• What’s returned when a function doesn’t return anything else
  • either from no return statement
  • or return alone

• print(float("123.45"))

• Most popular way to use/check type annotations

• Alternate between them to avoid syntax errors if you need an apostrophe, quote, double quote, etc. 'This "is" cool' or "That 'is' cool" or "Evan's car"

• use triple “”” or '''
• aka 'multiline string' which can be used for strings, e.g. to include line breaks
• Escapes both ' and " and allows you to include line breaks (which aren't allowed normally) being able to do multiline strings since multiline strings include the newline character which needs to be handled correctly.

• r'some string'
• aka 'raw string literal'
• a backslash, \, is taken as meaning "just a backslash" (except when it comes right before a quote that would otherwise terminate the literal). That is, no "escape sequences" to represent newlines, tabs, backspaces, form-feeds, and so on. In normal string literals, each backslash must be doubled up to avoid being taken as the start of an escape sequence.
• Helps with Regex, e.g.
  • the syntax of regular expression patterns is heavy with backslashes (but never at the end, so the "except" clause above doesn't matter) and it looks a bit better when you avoid doubling up each of them

• Changes a number to a string

• So you can use list methods like slicing, indexing, iterating, len(), etc.
• A bad index in Python, e.g. s[100] for the string "Hello", is a runtime error. However, slices work differently. If an index number in a slice is out of bounds, it is ignored and the slice uses the start or end of the string.

• string1 + string2
• "Hello world" + "!" * 10
  • Hello world!!!!!!!!!!

• \"
• (Invisible characters)
• Space
• New Line Character
  • \n
  • If you evaluate a string that contains a newline character you will see the character represented as \n. If you print a string that contains a newline you will not see the \n, you will just see its effects.
• Tab Character
  • \t
• Interrobang
• Unicode
  • https://unicode-table.com/en/
  • \u20ac
  • \U00008000

• https://docs.python.org/3/library/re.html
• import re
• re.findall()
• re.IGNORECASE
• re.MULTILINE

• ord()
  • Ordinal Value
  • string method
  • print(ord("A"))
    • 65
  • print(ord("B"))
    • 66
  • print(ord("5"))
    • 53
  • print(ord("a"))
    • 97
  • print(ord(" "))
    • 32
• chr()
  • converts integers into their character equivalent. (ordinal to character)
  • print(chr(65))
    • A
  • print(chr(66))
    • B
  • print(chr(49))
    • 1
  • print(chr(53))
    • 5

• u'some string'
• I think this was used in Python2 to specify a string to be encoded with unicode. But with Python3 unicode is the default encoding of strings so it is fairly irrelevant now?

• rjust()
• ljust()
• center()

• Frequency and order does matter (contra dictionaries where order does not matter)
  • Thus, duplicates

• E.g., if you have two variables that are assigned to the same list, when you update the list via one variable, that list is updated for the other variable too.
• Also, if you use a function's local variable to refer to a list, it will work to modify the list since even though the variable is local, it still refers to the list properly.

• example = [“string”, 73, [13, 15]]

• (Or strings)
• Item as Iterator
  • Simplest, but doesn't give you access to index of list
  • for list_item in some_list: print(list_item)
• With range(len(some_list))
  • More flexible since you have access to list index – e.g, you can refer to previous or next item in list with some_list[i-1]
  • for i in range(len(some_list)): print(some_list[i])
• ?With enumerate() to get access to both index and items themselves?

• example = []
• example = [3, 7, 4, 7]
• example = list()
  • creates empty list example

• Sorting Lists
  • .sort()
    • modifies the list in-place
    • return = None
    • sorted(simpsons, reverse=True)
    • sorted(simpsons, key=len)
  • .reverse()
    • return = None
    • list(reversed(weekdays))
    • alternative to [::-1] v
  • Asciibetical
    • easy way to make it regular alphabetical is to pass str.lower for the key keyword argument in the sort() method
    • spam.sort(key=str.lower)
• .insert & .pop
  • Used to add and remove items at certain positions
  • example.insert(4, 62)
    • inserts the number 62 at position 4 and shifts over the elements after that. Ie, no elements are replaced.
  • example.pop()
    • deletes the last item in the list
    • example.pop(5)
      • deletes item at index 5
    • return value = the item deleted
• list()
  • list('Evan')
    • Creates list of E, v, a, and n.
• example.append(9)
  • return = None
• example.remove(15)
  • removes the number 15 from the list (the first value it finds - starting from the first index I think)
  • example.remove("string")

• Inner list is called a 'sublist'
• someList[1][2]
  • Evaluated from left to right, so returns element at index 1, then in that list, returns the sublists index 2 element
• Could also just assign the sublist to a variable and access it like a normal list
• Update a Sublist
  • someList[2][1] = 'c'

• omnioutliner:///open?row=pfaUbAC8UU0

• Canonical way:
  • someList = [1, 2, 3] clonedList = someList[:]
  • clonedList = list(someList) is also just as/more valid
  • Creates 2 independent copies, where changes in each don't affect the other.
  • But will only make a shallow copy, so references inside lists e.g., might be affected. (Use copy.deepcopy())

• del example[3]
  • deletes 4th item in list
  • del alist[1:5]

• omnioutliner:///open?row=d1uf_vHzJQn

• Returns value of 1st item, example[1], the 2nd item etc.

• Returns value of last item on list, example[-2] the 2nd to last etc.

• Removes the element 76 via the .pop() method which gets the index from the .index() method

• example = ()
• example = (3, 7, 4, 7)
• example = tuple()

• Cannot change data in a tuple as opposed to lists - immutable
• can help since you can be confident another part of your program didn't modify it accidentally

• indexing
• slicing
• example[2]
  • accesses the value at that position in the tuple

• comma needed here

• a, b, c = (1, 2, 3,)
• But the variable must match the number of values

• Data items stored within tuples are assigned variable names
• (name, age) = tuple_or_list_name?

• finds the largest or smallest value in a tuple of numbers (integers or floats)

• Create grouped tuples in a list
  • list_name = [("Evan", 100), ("Cayden", 10), ("Bojangles", 4)]
• Access specific position in a tuple that is in a list
  • list_name[0][1]
    • accesses the first item in the list, then returns the second item of the tuple, returns 100

• example = {}
• example = { “length”: 3, “width”: 4}
• example = dict()

• not ordered (contra lists). There is no "first" key-value pair in a dictionary.

• But the key is immutable

• the term "mapping" means linking one object to another, as in a dictionary key-value pair

• phonebook["Emma"]

• my_dict = {}
• my_dict = dict()
• phonebook={'Jenny': 8168972345, 'Johnny': 7893419870}

• Lists dictionary’s keys
• return list-like data types
• "The keys method returns what Python 3 calls a view of its underlying keys. We can iterate over the view or turn the view into a list by using the list conversion function."

• Lists dictionary's values
• return list-like data types

• return list-like data types
• key value pairs returned as tuples
  • e.g., for (k,v) in inventory.items():

• .get(keyName)
  • it's tedious to always have to check if a key exists before getting its value so this helps avoid an error
  • Returns None if no key exists.
• .get(key_name, “what to return if key not found in dictionary”)
  • Instead of returning None, returns the 2nd argument if given.

• returns the value of a key (if the key is in dictionary). If not, it inserts key with a value to the dictionary.

• .update({“key_name”:value})

• .pop(key_name)

• del phonebook['Julie']
  • deletes the 'Julie' entry (including the value, since they operate together, as pairs)

• works as long as that key exists. If key doesn't exist, returns runtime error.
• Thus, .get(), etc.

• adds new entry to the dictionary or changes the value at that key

• for k in eggs.keys()
• for v in eggs.values()
• for k, v in eggs.items()
• for k in inventory: print("Got", k, "that maps to", inventory[k])
• for item in someDictionary
  • implicitly defaults to keys

• copy & deepcopy methods

• key_list = list(inventory.keys())

• message = 'This is a sentence to count.' count = {} #We use .upper method to avoid counting upper and lower case letters differently. for character in message.upper(): count.setdefault(character, 0) count[character] = count[character] + 1

• arr = [1, 3, 5, 3, 3, 3, 5] dict = {} for color in arr: dict.setdefault(color, 0) dict.update({color: dict.get(color) + 1})

• prints dictionaries in a much more readable way, e.g. lined up vertically

• prepopulates

• Throws an error if that value is not in the set

• Doesn’t throw an error if the value isn’t in the set

• Number of items in the set

• Or not in

• https://stackoverflow.com/questions/176011/python-list-vs-array-when-to-use
  • Basically, Python lists are very flexible and can hold completely heterogeneous, arbitrary data, and they can be appended to very efficiently, in amortized constant time. If you need to shrink and grow your array time-efficiently and without hassle, they are the way to go. But they use a lot more space than C arrays. The array.array type, on the other hand, is just a thin wrapper on C arrays. It can hold only homogeneous data, all of the same type, and so it uses only sizeof(one object) * length bytes of memory. Mostly, you should use it when you need to expose a C array to an extension or a system call (for example, ioctl or fctnl).
  • However, if you want to do math on a homogeneous array of numeric data, then you're much better off using NumPy, which can automatically vectorize operations on complex multi-dimensional arrays. To make a long story short: array.array is useful when you need a homogeneous C array of data for reasons other than doing math.

• (Also for strings)
• First number inclusive, second number exclusive, like range
• If 3rd number given it's the step, as in 2, every other number
• Negative numbers count backwards and can be in any position
• example[:5]
  • items up to 5
• example[5:]
  • Items from 5 to the end
• example[-3:]
  • Last 3 items - start from the 3rd to last item until the end
• [1::4]
  • From index 1 to the end, return every 4th index, including index 1.
• [1:-1]
  • from index 1 to the second to last item
• [::-1]
  • When a negative number is used as the step, it counts backwards.
  • Common way to reverse a list or string
• [::2]
  • start at beginning, go to the end, but take every 2nd element
  • so [1, 2, 3, 4][::2] = [1,3]

• -1 to get the last item in the list, -2, second to last, etc.

• strings, lists
• Like find except causes a runtime error if item is not found
• rindex() only works on strings