Git Product home page Git Product logo

code-in-place-extra's Introduction

Code in Place Spring 2024 - Stanford University

Extra suplemental materials dedicated to Code in Place Spring 2024 with Stanford University

Topics to be covered:

Input Arguments (Week 2: May 03, 2024)

User Input Prompt: remember all data types are still in string 
def main():
  user_name = input("Enter your name: ")
  print("Good morning " + user_name)

Console Programming (Week 3: May 10, 2024)

Conditional Branching

1. IF-ELIF-ELSE Statement 
def main():
  MERCURY_GRAVITY = (37.6 / 100)
  VENUS_GRAVITY = (88.9 / 100)
  MARS_GRAVITY = (37.8 / 100)
  JUPITER_GRAVITY = (236 / 100)
  SATURN_GRAVITY = (108.1 / 100)
  URANUS_GRAVITY = (81.5 / 100)
  NEPTUNE_GRAVITY = (114 / 100)    

  earthWeight = float(input("Enter the object weight: "))
  planetName = input("Enter a planet name: ")
  
  if (planetName == "Mercury"):
    planetWeight = float(earthWeight) * MERCURY_GRAVITY
        
  elif (planetName == "Venus"):
    planetWeight = float(earthWeight) * VENUS_GRAVITY
        
  elif (planetName == "Mars"):
    planetWeight = float(earthWeight) * MARS_GRAVITY

  elif (planetName == "Jupiter"):
    planetWeight = float(earthWeight) * JUPITER_GRAVITY
        
  elif (planetName == "Saturn"):
    planetWeight = float(earthWeight) * SATURN_GRAVITY

  elif (planetName == "Uranus"):
    planetWeight = float(earthWeight) * URANUS_GRAVITY
        
  elif (planetName == "Neptune"):
    planetWeight = float(earthWeight) * NEPTUNE_GRAVITY
    
  else:
    planetWeight = -1.0 # Why put a negative value here?
2. IF Statement 
def main():
  MERCURY_GRAVITY = (37.6 / 100)
  VENUS_GRAVITY = (88.9 / 100)
  MARS_GRAVITY = (37.8 / 100)
  JUPITER_GRAVITY = (236 / 100)
  SATURN_GRAVITY = (108.1 / 100)
  URANUS_GRAVITY = (81.5 / 100)
  NEPTUNE_GRAVITY = (114 / 100)    

  earthWeight = float(input("Enter the object weight: "))
  planetName = input("Enter a planet name: ")
  planetWeight = -1 # Why put a negative value here?

  if (planetName == "Mercury"):
    planetWeight = float(earthWeight) * MERCURY_GRAVITY
        
  if (planetName == "Venus"):
    planetWeight = float(earthWeight) * VENUS_GRAVITY
        
  if (planetName == "Mars"):
    planetWeight = float(earthWeight) * MARS_GRAVITY

  if (planetName == "Jupiter"):
    planetWeight = float(earthWeight) * JUPITER_GRAVITY
        
  if (planetName == "Saturn"):
    planetWeight = float(earthWeight) * SATURN_GRAVITY

  if (planetName == "Uranus"):
    planetWeight = float(earthWeight) * URANUS_GRAVITY
        
  if (planetName == "Neptune"):
    planetWeight = float(earthWeight) * NEPTUNE_GRAVITY
3. MATCH-CASE Statement (Require Python 3.10 or above) 
def main():
  MERCURY_GRAVITY = (37.6 / 100)
  VENUS_GRAVITY = (88.9 / 100)
  MARS_GRAVITY = (37.8 / 100)
  JUPITER_GRAVITY = (236 / 100)
  SATURN_GRAVITY = (108.1 / 100)
  URANUS_GRAVITY = (81.5 / 100)
  NEPTUNE_GRAVITY = (114 / 100)    

  earthWeight = float(input("Enter the object weight: "))
  planetName = input("Enter a planet name: ")
  
  match planetName:
    case "Mercury":
      planetWeight = float(earthWeight) * MERCURY_GRAVITY
  
    case "Venus":
      planetWeight = float(earthWeight) * VENUS_GRAVITY
  
    case "Mars":
      planetWeight = float(earthWeight) * MARS_GRAVITY
  
    case "Jupiter":
      planetWeight = float(earthWeight) * JUPITER_GRAVITY
      
    case "Saturn":
      planetWeight = float(earthWeight) * SATURN_GRAVITY
  
    case "Uranus":
      planetWeight = float(earthWeight) * URANUS_GRAVITY
  
    case "Neptune":
      planetWeight = float(earthWeight) * NEPTUNE_GRAVITY
  
    case other:
      planetWeight = -1.0 # Why put a negative value here?

Printing in Python

1. String Concatenation

  • Notice that both "+" and "," can be used interchangably
  • Concatenate multiple strings with + (plus) or , (comma)
  • All concatenated items have to be converted to the same data type (string)
Examples 
planetName = "Mars"; planetWeight = 175.26
print("The weight on " + planetName + ": " + str(marsWeight))
print("The weight on " , planetName + ": " , str(marsWeight))

2. Reference

  • Notice the .format(,) patten
  • Unlike concatenation method, this method requires no string conversion
  • Use the {} (curly brackets) to place your variable
Examples 
planetName = "Mars"; planetWeight = 175.26
print("The weight on {}: {}".format(planetName, planetWeight))

3. F-word

  • Notice the f letter inside print()
  • Similar to method 2 (reference), but now variable name is placed inside the curly brackets
  • Likewise, no variable casting (conversion) is needed
Examples 
planetName = "Mars"; planetWeight = 175.26
print(f"The weight on {planetName}: {planetWeight}")

Control Flow (Week 4: May 17, 2024)

Writing Functions

1. Returning a Single Output

Example: 
def calculate_mars_weight(earth_weight):
  MARS_GRAVITY = 0.376
  mars_weight = float(earth_weight) * MARS_GRAVITY
  return round(mars_weight, 2)
  
def main():
  earth_test = float(input("Enter the object weight on Earth: "))
  mars_test = calculate_mars_weight(earth_test)

2. Returning More than One Output

Example: 
def calculate_planet_weights(earth_weight):
  MERCURY_GRAVITY = 0.376
  VENUS_GRAVITY = 0.889
  MARS_GRAVITY = 0.378

  mercury_weight = earth_weight * MERCURY_GRAVITY
  venus_weight = earth_weight * VENUS_GRAVITY
  mars_weight = earth_weight * MARS_GRAVITY

  return round(mercury_weight, 2), round(venus_weight, 2), round(mars_weight, 2)
  
def main():
  earth_test = float(input("Enter the object weight on Earth: "))
  mercury_test, venus_test, mars_test = calculate_planet_weights(earth_test)

Canvas, Graphics, and Animation (Week 5: May 24, 2024)

Data Structures (Week 6: May 31, 2024)

Visit: 2024_05_31_DataStructures

1. Calculating Factorial

Using Recursion 
def factorial_recursion(n):
  if (n==0 or n==1):
    return 1

  return n * factorial_recursion(n-1)
Using Iteration 
def factorial_iteration(n):
  result = 1;
  for i in range(n, 1, -1):
    result = i*result

  return result
Using Dynamic Programming (List) 
def factorial_dynamic_programming(n):
  factorial_list = [-1] * (n+1)
  factorial_list[0] = 1

  for i in range(1, n+1, 1):
    factorial_list[i] = factorial_list[i-1] * i

  return factorial_list[n]

2. Revisiting Planetary Weight

  • Becoming familiar with JSON file format
  • Storing, hashing, and accessing dictionary value elements using its key
  • List of dictionary vs Dictionary
Using Conditionals (planet_conditional.py) 
MERCURY_GRAVITY = (37.6 / 100)
VENUS_GRAVITY = (88.9 / 100)
MARS_GRAVITY = (37.8 / 100)
JUPITER_GRAVITY = (236 / 100)
SATURN_GRAVITY = (108.1 / 100)
URANUS_GRAVITY = (81.5 / 100)
NEPTUNE_GRAVITY = (114 / 100)    

def calculate_weight(planetName, earthWeight):
  
  match planetName:
    case "Mercury":
        planetWeight = earthWeight * MERCURY_GRAVITY
  
    case "Venus":
        planetWeight = earthWeight * VENUS_GRAVITY
  
    case "Mars":
        planetWeight = earthWeight * MARS_GRAVITY
  
    case "Jupiter":
        planetWeight = earthWeight * JUPITER_GRAVITY
      
    case "Saturn":
        planetWeight = earthWeight * SATURN_GRAVITY
  
    case "Uranus":
        planetWeight = earthWeight * URANUS_GRAVITY
  
    case "Neptune":
        planetWeight = earthWeight * NEPTUNE_GRAVITY
  
    case "Earth":
        planetWeight = earthWeight

    case other:
        planetWeight = -1.0 # Why put a negative value here?

return planetWeight
  
def main():
  earthWeight = float(input("Enter the object weight: "))
  planetName = input("Enter a planet name: ")
  planetWeight = calculate_weight(planetName, earthWeight)
  
  print("The name of the planet: " + planetName + " with weight: " + str(planetWeight))
Using List of Dictionary (planet_dictionary.py) 
planet_dict = [
  {"mercury": 0.376}, 
  {"venus": 0.889},
  {"earth": 1.0},  
  {"mars": 0.378},
  {"jupiter": 2.36}, 
  {"saturn": 1.081}, 
  {"uranus": 0.815}, 
  {"neptune": 1.14}
]

def calculate_weight(target_planet, earth_weight):
    # TODO: Check the earth weight, make sure >= 0 and numbers only
    # TODO: Check that the target planet name is listed in the dictionary, otherwise return an error

    planet_name = target_planet.lower()
    planet_constant = -1.0
    for i in range( len(planet_dict) ):
        for name, gravity in planet_dict[i].items():
            if (planet_name == name):
                planet_constant = gravity

    planet_weight = planet_constant * earth_weight

    return planet_weight

def main():
  earth_weight = float(input("Enter the object weight: "))
  planet_name = input("Enter a planet name: ")
  
  planet_weight = calculate_weight(planet_name, earth_weight)

  print("The name of the planet: " + planet_name + " with weight: " + str(planet_weight))
Using Dictionary (planet_dictionary.py) 
planet_dict = {
  "mercury": 0.376, 
  "venus": 0.889,
  "earth": 1.0,  
  "mars": 0.378,
  "jupiter": 2.36, 
  "saturn": 1.081, 
  "uranus": 0.815, 
  "neptune": 1.14
  }

def calculate_weight_alternative(target_planet, earth_weight):
    planet_name = target_planet.lower()
    planet_constant = -1.0

    if planet_dict[ planet_name ] is not None:
        planet_constant = planet_dict[planet_name]
    
    planet_weight = planet_constant * earth_weight

    return planet_weight

def main():
  earth_weight = float(input("Enter the object weight: "))
  planet_name = input("Enter a planet name: ")
  
  planet_weight = calculate_weight_alternative(planet_name, earth_weight)

  print("The name of the planet: " + planet_name + " with weight: " + str(planet_weight))

3. Plotting Regression Line

Using List of Dictionary (snow_plot.py) 
from matplotlib import pyplot as plt

snow_yield_dictionary =
[{"Snow": 
[23.1, 32.8, 31.8, 32.0, 30.4, 24.0, 39.5, 24.2, 52.5, 37.9, 30.5, 25.1, 12.4, 35.1, 31.5, 21.1, 27.6]
},
{"Yield": 
[10.5, 16.7, 18.2, 17.0, 16.3, 10.5, 23.1, 12.4, 24.9, 22.8, 14.1, 12.9, 8.8, 17.4, 14.9, 10.5, 16.1]
}]

def plot_the_curve():
    snow_dictionary = snow_yield_dictionary[0]
    yield_dictionary = snow_yield_dictionary[1]

    snow_list = snow_dictionary["Snow"]
    yield_list = yield_dictionary["Yield"]

    plt.title("Plot of Snow vs Yield"); plt.xlabel("Snow"); plt.ylabel("Yield")
    plt.scatter(snow_list, yield_list, c='blue', marker='H')
    plt.show()
    plt.savefig('plot_of_snow_vs_yield.png')

def main():
    plot_the_curve()

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.