// Java
class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!"); 
    }
}

// Go
package main
import "fmt"
func main() {
    fmt.Println("Hello, World!")
}

// C++
#include <stdio.h>
int main() {
   printf("Hello, World!");
   return 0;
}

// rust
fn main() {
    println!("Hello World!");
}

• Variables are implicitly typed
  • Type is inferred at runtime, i.e. dynamically typed
• Variables are inherently mutable, constants do not exist!
  • We can redefine a variable to a different type without issues, but this isn't very clean code
• Casting is easy and typically implicit

>>> my_var = 10  # no type declaration needed!
>>> type(my_var)
int
>>> my_var = "hello!"
>>> type(my_var)
str
>>> my_var = 10
>>> str(my_var)
"10"
>>> print(my_var)  # print casts everything to a str implicitly
>>> my_var = "10"
>>> int(my_var)
10
>>> my_var = None  # None is Python's null
>>> type(my_var)
NoneType
>>> type(type(my_var))  # every type is type type :)
type

i = 0
# again note the : token and indentation
while i < 10:
  print(i)
  i += 1
# there is no do-while in Python, instead
while True:
  do_something()
  if condition:
    break  # exit loop

for i in range(0,10):
  print(i)
for i in range(0,10):
  if i % 2 == 0:
    # skip below code and continue loop
    continue  
  print(i)

# two ways to instantiate lists
l = list()
l = list([1,2,3,4,5])  # this is actually a cast!
l = []
l = [1,2,3,4,5]
# retrieving elements is easy
l[0]  # 1
l[-1]  # 5
# we can slice a list
l[1:3]  # [2,3,4]
l[1:]  # [2,3,4,5]
l[:3]  # [1,2,3]
len(l)  # length of object
# a neat trick to instantiate a list
l = [0] * 5  # [0,0,0,0,0]

l = [1,2,3]
# adds an element to end of list
l.append(5)  # [1,2,3,5]
# adds element at the specified index
l.insert(3, 4)  # [1,2,3,4,5]
l.append("6")  # lists can contain multiple types!
elem = l.pop()  # remove and return last element
elem = l.pop(2)  # remove and return element at index
# remove first occurrence of given element
l.remove("thing_to_remove")
# we can concat two lists easily
l + [6,7,8]
l.extend([6,7,8])
l.extend((6,7,8))  # extend takes any iterable

students = ["David", "Ben", "Justin"]
# iteration is done using "for _ in _:"
for s in students:
  print(s)
# you can still do this if you want
for i in range(0, len(s)):
  s = students[i]
  print(s)
# but this is more pythonic
for i, s in enumerate(students):
  print(i, s)

numbers = [7, 4, 12, 20, 16, 1]
# sorted() returns a sorted copy of the original list
sorted(numbers)[0]  # 1
numbers[0]  # still 7
# we can sort in-place as well
numbers.sort()
numbers[0]  # 1
# sorted descending order is easy
sorted(numbers, reverse=True)
numbers.sort(reverse=True)

model = "civic"
make = "honda"
car = (model, make)  # note regular parens
car = model, make  # this also works
# tuple deconstruction is very nice
year, model, make = 2020, "civic", "honda"
# tuple indexing is the same as lists
car[0]
car[0:2]
# neat trick, we can swap variables easily
x, y = 1, 2
x, y = y, x
# same trick as lists works too
t = (0) * 3

• Tuples are immutable
  • Attempting to set car[0] = "accord" would error
  • Gotcha: tuples store the memory locations of its objects. Thus, if the underlying objects are mutated, then the objects the tuple references are mutated.
• We can iterate similarly to lists

# instantiate a set in two ways
students = set()
students = {"David", "Ben", "Justin"}
# adding and removing elements
students.add("Chris") 
students.remove("David")
# checking existence
david_exists = "David" in students
if "David" not in students:
  print("David is not a student")

naturals = {0,1,2,3,4,5,6,7}
primes = {2,3,5,7}
# intersection
naturals.intersection(primes)
naturals & primes
# union
naturals.union(primes)
naturals | primes
# difference
naturals.difference(primes)
naturals - primes

s = "my very long string"
# indexing/slicing is the same as lists
s[0]  # "m"
s[:7]  # "my very"
# a python trick
s[::2]  # "m eyln tig", every 2nd element
# every -1 element, i.e. reversed
s[::-1]  # "gnirts gnol yrev ym"

# checking substrings
if "long" in s:
  print("string contains 'long'")

• If you're not familiar or comfortable with pointers and references, dealing with objects and their locations in memory can get confusing
  • If we have objects in l, then copy may not work as expected. Instead, we can use deepcopy, which copies nested objects recursively.

l = [1,2,3]
l2 = l
l[0] = 100  # both l and l2 are mutated!
print(l, l2)  # [100,2,3] [100,2,3]
from copy import copy, deepcopy
l = [1,2,[3,4]]
l2 = copy(l)
l[2][0] = 100
print(l, l2)  # [1,2,[100,4]] [1,2,[100,4]]
l = [1,2,[3,4]]
l2 = deepcopy(l)
l[2][0] = 100
print(l, l2)  # [1,2,[100,4]] [1,2,[3,4]]

• Python's hash table data structure, i.e. key-value store
• Dictionaries are mutable objects that take a hashable object as a key and any arbitrary object as the value
  • Lists and sets are not hashable, but tuples can be if their elements are

# instatiation
attendance = dict()
attendance = {"David": 5, "Ben": 4}
# setting and getting
attendance["Justin"] = 5
# removing element
del attendance["Ben"]

• If we try to index into a dictionary with a key that doesn't exist we get an error
• Sometimes this is a bit annoying, so we use the defaultdict package
  • We will cover imports and packages later, but defaultdict comes bundled with Python already!

if "Sara" not in attendance:  # not fun :(
  attendance["Sara"] = 0
attendance["Sara"] += 1
from collections import defaultdict
words = [
  "some", "words", "to", "be", 
  "counted", "some", "more", "words",
]
count = defaultdict()
for w in words:  # much nicer!
  count[w] += 1
# defaultdict uses 0 by default, but we can specify the type
defaultdict(str)

• All variables of a class are public and can be defined at runtime
  • In fact, private variables do not exist in Python!
• However, we can "enforce" that certain attributes are set through the constructor
  • Note the double underscore for __init__(). This means it is a reserved function in Python, which we will cover later.

# define using "class" reserved word
class Car:
  pass
# to instantiate object
car = Car()
# note that we don't even need setter/getter methods!
car.model = "civic"
car.make = "honda"
# we can explicitly require these in the constructor
class Car:
  def __init__(self, model, make):
    # note the similarity of `self` and `this` in Java
    self.model = model
    self.make = make

• Inheritance is fairly simple as well, just add the parent class in parentheses
  • If you want to inherit multiple classes, just add commas, e.g. Student(Person, OtherClass)
• Note that name is inherited from Person
• Additionally, note that __init__ is overridden in Student

class Person:
  def __init__(self, name):
    self.name = name
  def say_hello(self):
    print(f"Hi my name is {self.name}!")
class Student(Person):
  def __init__(self, name, grade):
    Person.__init__(self, name)
    self.grade = grade
  def study(self):
    self.grade = min(100, self.grade + 10)
    print(f"{self.name} studied and " + 
          f"their grade is now {self.grade}!")
s = Student("David", 50)
s.say_hello()
s.study()