houses0.

py

1 # Filters out duplicate houses using loop

2
3 students = [
4 {"name": "Hermione", "house": "Gryffindor"},
5 {"name": "Harry", "house": "Gryffindor"},
6 {"name": "Ron", "house": "Gryffindor"},
7 {"name": "Draco", "house": "Slytherin"},
8 {"name": "Padma", "house": "Ravenclaw"},
9 ]
10
11 houses = []
12 for student in students:
13 if student["house"] not in houses:
14 houses.append(student["house"])
15
16 for house in sorted(houses):
17 print(house)
 houses1.py

1 # Filters out duplicate houses using set

2
3 students = [
4 {"name": "Hermione", "house": "Gryffindor"},
5 {"name": "Harry", "house": "Gryffindor"},
6 {"name": "Ron", "house": "Gryffindor"},
7 {"name": "Draco", "house": "Slytherin"},
8 {"name": "Padma", "house": "Ravenclaw"},
9 ]
10
11 houses = set()
12 for student in students:
13 houses.add(student["house"])
14
15 for house in sorted(houses):
16 print(house)
 bank0.py

1 # Implements a bank account

2
3 balance = 0
4
5
6 def main():
7 print("Balance:", balance)
8
9
10 if __name__ == "__main__":
11 main()
 bank1.py

1 # UnboundLocalError
2
3 balance = 0
4
5
6 def main():
7 print("Balance:", balance)
8 deposit(100)
9 withdraw(50)
10 print("Balance:", balance)
11
12
13 def deposit(n):
14 balance += n
15
16
17 def withdraw(n):
18 balance -= n
19
20
21 if __name__ == "__main__":
22 main()
 bank2.py

1 # Uses global
2
3 balance = 0
4
5
6 def main():
7 print("Balance:", balance)
8 deposit(100)
9 withdraw(50)
10 print("Balance:", balance)
11
12
13 def deposit(n):
14 global balance
15 balance += n
16
17
18 def withdraw(n):
19 global balance
20 balance -= n
21
22
23 if __name__ == "__main__":
24 main()
 bank3.py

1 # Uses class
2
3
4 class Account:
5 def __init__(self):
6 self._balance = 0
7
8 @property
9 def balance(self):
10 return self._balance
11
12 def deposit(self, n):
13 self._balance += n
14
15 def withdraw(self, n):
16 self._balance -= n
17
18
19 def main():
20 account = Account()
21 print("Balance:", account.balance)
22 account.deposit(100)
23 account.withdraw(50)
24 print("Balance:", account.balance)
25
26
27 if __name__ == "__main__":
28 main()
 meows0.py

1 # Demonstrates a constant
2
3 MEOWS = 3
4
5 for _ in range(MEOWS):
6 print("meow")
 meows1.py

1 # Demonstrates a class constant

2
3
4 class Cat:
5 MEOWS = 3
6
7 def meow(self):
8 for _ in range(Cat.MEOWS):
9 print("meow")
10
11
12 cat = Cat()
13 cat.meow()
 meows2.py

1 # Demonstrates TypeError
2
3
4 def meow(n):
5 for _ in range(n):
6 print("meow")
7
8
9 number = input("Number: ")
10 meow(number)
 meows3.py

1 # Argument ... has incompatible type

2
3
4 def meow(n: int):
5 for _ in range(n):
6 print("meow")
7
8
9 number = input("Number: ")
10 meow(number)
 meows4.py

1 # Incompatible types in assignment

2
3
4 def meow(n: int):
5 for _ in range(n):
6 print("meow")
7
8
9 number: int = input("Number: ")
10 meow(number)
 meows5.py

1 # Success
2
3
4 def meow(n: int):
5 for _ in range(n):
6 print("meow")
7
8
9 number: int = int(input("Number: "))
10 meow(number)
 meows6.py

1 # Prints None because mistakes meow as having a return value

2
3
4 def meow(n: int):
5 for _ in range(n):
6 print("meow")
7
8
9 number: int = int(input("Number: "))
10 meows: str = meow(number)
11 print(meows)
 meows7.py

1 # Annotates return value, ... does not return a value

2
3
4 def meow(n: int) -> None:
5 for _ in range(n):
6 print("meow")
7
8
9 number: int = int(input("Number: "))
10 meows: str = meow(number)
11 print(meows)
 meows8.py

1 # Success
2
3
4 def meow(n: int) -> str:
5 return "meow\n" * n
6
7
8 number: int = int(input("Number: "))
9 meows: str = meow(number)
10 print(meows, end="")
 meows9.py

1 # Adds docstring to function.

2
3
4 def meow(n):
5 """Meow n times."""
6 return "meow\n" * n
7
8
9 number = int(input("Number: "))
10 meows = meow(number)
11 print(meows, end="")
 meows10.py

1 # Uses Sphinx docstring format

2
3
4 def meow(n):
5 """
6 Meow n times.
7
8 :param n: Number of times to meow
9 :type n: int
10 :raise TypeError: If n is not an int
11 :return: A string of n meows, one per line
12 :rtype: str
13 """
14 return "meow\n" * n
15
16
17 number = int(input("Number: "))
18 meows = meow(number)
19 print(meows, end="")
 meows11.py

1 # Uses command-line argument

2
3 import sys
4
5 if len(sys.argv) == 1:
6 print("meow")
7 elif len(sys.argv) == 3 and sys.argv[1] == "-n":
8 n = int(sys.argv[2])
9 for _ in range(n):
10 print("meow")
11 else:
12 print("usage: meows11.py [-n NUMBER]")
 meows12.py

1 # Uses command-line argument

2
3 import argparse
4
5 parser = argparse.ArgumentParser()
6 parser.add_argument("-n")
7 args = parser.parse_args()
8
9 for _ in range(int(args.n)):
10 print("meow")
 meows13.py

1 # Adds description, help

2
3 import argparse
4
5 parser = argparse.ArgumentParser(description="Meow like a cat")
6 parser.add_argument("-n", help="number of times to meow")
7 args = parser.parse_args()
8
9 for _ in range(int(args.n)):
10 print("meow")
 meows14.py

1 # Adds default, type; removes int()

2
3 import argparse
4
5 parser = argparse.ArgumentParser(description="Meow like a cat")
6 parser.add_argument("-n", default=1, help="number of times to meow", type=int)
7 args = parser.parse_args()
8
9 for _ in range(args.n):
10 print("meow")
 unpack0.py

1 # Unpacks a list
2
3 first, _ = input("What's your name? ").split(" ")
4 print(f"hello, {first}")
 unpack1.py

1 # Passes positional arguments as usual

2 # https://harrypotter.fandom.com/wiki/Wizarding_currency
3
4
5 def total(galleons, sickles, knuts):
6 return (galleons * 17 + sickles) * 29 + knuts
7
8
9 print(total(100, 50, 25), "Knuts")
 unpack2.py

1 # Indexes into list

2
3
4 def total(galleons, sickles, knuts):
5 return (galleons * 17 + sickles) * 29 + knuts
6
7
8 coins = [100, 50, 25]
9
10 print(total(coins[0], coins[1], coins[2]), "Knuts")
 unpack3.py

1 # Unpacks a list
2
3
4 def total(galleons, sickles, knuts):
5 return (galleons * 17 + sickles) * 29 + knuts
6
7
8 coins = [100, 50, 25]
9
10 print(total(*coins), "Knuts")
 unpack4.py

1 # Passes named arguments as usual

2
3
4 def total(galleons, sickles, knuts):
5 return (galleons * 17 + sickles) * 29 + knuts
6
7
8 print(total(galleons=100, sickles=50, knuts=25), "Knuts")
 unpack5.py

1 # Indexes into a dict

2
3
4 def total(galleons, sickles, knuts):
5 return (galleons * 17 + sickles) * 29 + knuts
6
7
8 coins = {"galleons": 100, "sickles": 50, "knuts": 25}
9
10 print(total(coins["galleons"], coins["sickles"], coins["knuts"]), "Knuts")
 unpack6.py

1 # Unpacks a dict
2
3
4 def total(galleons, sickles, knuts):
5 return (galleons * 17 + sickles) * 29 + knuts
6
7
8 coins = {"galleons": 100, "sickles": 50, "knuts": 25}
9
10 print(total(**coins), "Knuts")
 unpack7.py

1 # Prints positional arguments

2
3
4 def f(*args, **kwargs):
5 print("Positional:", args)
6
7
8 f(100, 50, 25)
 unpack8.py

1 # Prints named arguments

2
3
4 def f(*args, **kwargs):
5 print("Named:", kwargs)
6
7
8 f(galleons=100, sickles=50, knuts=25)
 yell0.py

1 # Prints a word in uppercase

2
3
4 def main():
5 yell("This is CS50")
6
7
8 def yell(word):
9 print(word.upper())
10
11
12 if __name__ == "__main__":
13 main()
 yell1.py

1 # Passes a list
2
3
4 def main():
5 yell(["This", "is", "CS50"])
6
7
8 def yell(words):
9 uppercased = []
10 for word in words:
11 uppercased.append(word.upper())
12 print(*uppercased)
13
14
15 if __name__ == "__main__":
16 main()
 yell2.py

1 # Prints arbitrarily many args in uppercase

2
3
4 def main():
5 yell("This", "is", "CS50")
6
7
8 def yell(*words):
9 uppercased = []
10 for word in words:
11 uppercased.append(word.upper())
12 print(*uppercased)
13
14
15 if __name__ == "__main__":
16 main()
 yell3.py

1 # Uses map
2
3
4 def main():
5 yell("This", "is", "CS50")
6
7
8 def yell(*words):
9 uppercased = map(str.upper, words)
10 print(*uppercased)
11
12
13 if __name__ == "__main__":
14 main()
 yell4.py

1 # Uses list comprehension

2
3
4 def main():
5 yell("This", "is", "CS50")
6
7
8 def yell(*words):
9 uppercased = [arg.upper() for arg in words]
10 print(*uppercased)
11
12
13 if __name__ == "__main__":
14 main()
 gryffindors0.py

1 # Filters by house using loop

2
3 students = [
4 {"name": "Hermione", "house": "Gryffindor"},
5 {"name": "Harry", "house": "Gryffindor"},
6 {"name": "Ron", "house": "Gryffindor"},
7 {"name": "Draco", "house": "Slytherin"},
8 ]
9
10 gryffindors = []
11 for student in students:
12 if student["house"] == "Gryffindor":
13 gryffindors.append(student["name"])
14
15 for gryffindor in sorted(gryffindors):
16 print(gryffindor)
 gryffindors1.py

1 # Filters by house using list comprehension

2
3 students = [
4 {"name": "Hermione", "house": "Gryffindor"},
5 {"name": "Harry", "house": "Gryffindor"},
6 {"name": "Ron", "house": "Gryffindor"},
7 {"name": "Draco", "house": "Slytherin"},
8 ]
9
10 gryffindors = [
11 student["name"] for student in students if student["house"] == "Gryffindor"
12 ]
13
14 for gryffindor in sorted(gryffindors):
15 print(gryffindor)
 gryffindors2.py

1 # Uses filter and key with lambda

2
3 students = [
4 {"name": "Hermione", "house": "Gryffindor"},
5 {"name": "Harry", "house": "Gryffindor"},
6 {"name": "Ron", "house": "Gryffindor"},
7 {"name": "Draco", "house": "Slytherin"},
8 ]
9
10
11 def is_gryffindor(s):
12 return s["house"] == "Gryffindor"
13
14
15 gryffindors = filter(is_gryffindor, students)
16
17 for gryffindor in sorted(gryffindors, key=lambda s: s["name"]):
18 print(gryffindor["name"])
 gryffindors3.py

1 # Uses filter with lambda

2
3 students = [
4 {"name": "Hermione", "house": "Gryffindor"},
5 {"name": "Harry", "house": "Gryffindor"},
6 {"name": "Ron", "house": "Gryffindor"},
7 {"name": "Draco", "house": "Slytherin"},
8 ]
9
10
11 gryffindors = filter(lambda s: s["house"] == "Gryffindor", students)
12
13 for gryffindor in sorted(gryffindors, key=lambda s: s["name"]):
14 print(gryffindor["name"])
 gryffindors4.py

1 # Creates list of dicts using loop

2
3 students = ["Hermione", "Harry", "Ron"]
4
5 gryffindors = []
6
7 for student in students:
8 gryffindors.append({"name": student, "house": "Gryffindor"})
9
10 print(gryffindors)
 gryffindors5.py

1 # Uses dictionary comprehension instead

2
3 students = ["Hermione", "Harry", "Ron"]
4
5 gryffindors = [{"name": student, "house": "Gryffindor"} for student in students]
6
7 print(gryffindors)
 gryffindors6.py

1 # Uses dictionary comprehension instead

2
3 students = ["Hermione", "Harry", "Ron"]
4
5 gryffindors = {student: "Gryffindor" for student in students}
6
7 print(gryffindors)
 gryffindors7.py

1 # Iterates over a list by index

2
3 students = ["Hermione", "Harry", "Ron"]
4
5 for i in range(len(students)):
6 print(i + 1, students[i])
 gryffindors8.py

1 # Uses enumerate instead

2
3 students = ["Hermione", "Harry", "Ron"]
4
5 for i, student in enumerate(students):
6 print(i + 1, student)
 sleep0.py

1 # Prints n sheep
2
3 n = int(input("What's n? "))
4 for i in range(n):
5 print("🐑" * i)
 sleep1.py

1 # Adds main
2
3
4 def main():
5 n = int(input("What's n? "))
6 for i in range(n):
7 print("🐑" * i)
8
9
10 if __name__ == "__main__":
11 main()
 sleep2.py

1 # Returns n sheep from helper function

2
3
4 def main():
5 n = int(input("What's n? "))
6 for i in range(n):
7 print(sheep(i))
8
9
10 def sheep(n):
11 return "🐑" * n
12
13
14 if __name__ == "__main__":
15 main()
 sleep3.py

1 # Returns a list of sheep

2
3
4 def main():
5 n = int(input("What's n? "))
6 for s in sheep(n):
7 print(s)
8
9
10 def sheep(n):
11 flock = []
12 for i in range(n):
13 flock.append("🐑" * i)
14 return flock
15
16
17 if __name__ == "__main__":
18 main()
 sleep4.py

1 # Uses yield
2
3
4 def main():
5 n = int(input("What's n? "))
6 for s in sheep(n):
7 print(s)
8
9
10 def sheep(n):
11 for i in range(n):
12 yield "🐑" * i
13
14
15 if __name__ == "__main__":
16 main()
 say.py

1 import cowsay
2 import pyttsx3
3
4 engine = pyttsx3.init()
5 this = input("What's this? ")
6 cowsay.cow(this)
7 engine.say(this)
8 engine.runAndWait()