15 KiB
Codecademy's Python 2 Course
https://www.codecademy.com/courses/learn-python/lessons/python-syntax/
It's gratis and accepts Python 3 syntax.
Object-oriented
"The main goal of an object oriented language is to make code reusable – we do this through the use of classes and objects. If we want to design a new type of car, we can start with what they all have in common: wheels, seats, a frame. Now that we’ve determined what cars have in common, we can more easily implement any type of car we want by starting from that basic blueprint."
https://discuss.codecademy.com/t/what-does-it-mean-that-python-is-an-object-oriented-language/297314
Errors (ex6, CH1, P3)
"SyntaxError means there is something wrong with the way your program is written — punctuation that does not belong, a command where it is not expected, or a missing parenthesis can all trigger a SyntaxError.
A NameError occurs when the Python interpreter sees a word it does not recognize. Code that contains something that looks like a variable but was never defined will throw a NameError."
SyntaxError example: SyntaxError: EOL while scanning string literal
Linear Regression
One of the projects in my Python 3 course on Codecademy was to calculate the linear regression of any given line in a set. This is my journey of doing just that, following their instructions. The goal, is to calculate the bounciness of different balls with the least error possible.
Starting with y = m*x + b
We can determine the y of a point pretty easily if we have the slope of the line (m) and the intercept (b). Thus, we can write a basic function to calculate the y:
def get_y(m, b, x):
y = m*x + b
return y
print(get_y(1, 0, 7) == 7)
print(get_y(5, 10, 3) == 25)
We can then use that to calculate the linear regression of a line:
def calculate_error(m, b, point):
x_point = point[0]
y_point = point[1]
y2 = get_y(m, b, x_point)
y_diff = y_point - y2
y_diff = abs(y_diff)
return y_diff
To get a more accurate result, we need a function that will parse several points at a time:
def calculate_all_error(m, b, points):
totalerror = 0
for point in points:
totalerror += calculate_error(m, b, point)
return abs(totalerror)
We can test it using their examples:
#every point in this dataset lies upon y=x, so the total error should be zero:
datapoints = [(1, 1), (3, 3), (5, 5), (-1, -1)]
print(calculate_all_error(1, 0, datapoints))
#every point in this dataset is 1 unit away from y = x + 1, so the total error should be 4:
datapoints = [(1, 1), (3, 3), (5, 5), (-1, -1)]
print(calculate_all_error(1, 1, datapoints))
#every point in this dataset is 1 unit away from y = x - 1, so the total error should be 4:
datapoints = [(1, 1), (3, 3), (5, 5), (-1, -1)]
print(calculate_all_error(1, -1, datapoints))
#the points in this dataset are 1, 5, 9, and 3 units away from y = -x + 1, respectively, so total error should be
# 1 + 5 + 9 + 3 = 18
datapoints = [(1, 1), (3, 3), (5, 5), (-1, -1)]
print(calculate_all_error(-1, 1, datapoints))
You can save all possible m and b values between -10 and 10 (m values), as well as -20 and 20 (b values) using:
possible_ms = [mv * 0.1 for mv in range(-100, 100)] #your list comprehension here
possible_bs = [bv * 0.1 for bv in range(-200, 200)] #your list comprehension here
We can find the combination that produces the least error, which is:
m = 0.3
b = 1.7
x = 6
The goal was to calculate the bounciness of different balls with the least error possible. With this data, we can calculate how far a given ball would bounce. For example, a 6 cm ball would bounce 3.5 cm. We know this because we can plug in the numbers like this:
get_y(0.3, 1.7, 6)
Math (ex6)
mirthful_addition = 12381 + 91817
amazing_subtraction = 981 - 312
trippy_multiplication = 38 * 902
happy_division = 540 / 45
sassy_combinations = 129 * 1345 + 120 / 6 - 12
exponents = (16 ** 0.5) # 16 to the 1/2th power. (4)
remainder = (15 % 2) # The remainder (and thus the result) equals 1
Find the remainder of a number using %
is_this_number_odd = 15 % 2
is_this_number_divisible_by_seven = 133 % 7
Updating variables / operators.
sandwich_price += sales_tax
is the same as:
sandwich_price = sandwich_price + sales_tax
but is much shorter.
Comments
Are indicated by # or """This is not for running"""
Numbers
An integer is like 5, a float is a number with a decimal point like 5.0. They can also be in scientific notation like 2.3e7
In Python 2, you need to make sure math like 7/2 = 3.5 is correct is by inputting it into Python like 7./2. or float(7)/2
Limitations of floats
Floats are limited by the number of digits. For example 1/3 = 0.3
>>> format(math.pi, '.12g') # give 12 significant digits
'3.14159265359'
>>> format(math.pi, '.2f') # give 2 digits after the point
'3.14'
Strings
Multi-line strings are marked by
Mulit-
line
strings"""
Booleans (True/False)
True = int(1) False = int(0)
Boolean Expressions
and evaluates true if both are true.
or evaluates true if either are true.
not return the opposite boolean value.
Relational Operators (ch.4, ex. 3)
== returns True if is is equal
!= returns True if is is NOT equal
Here are more of he same kind of operator:
> greater than
< less than
>= greater than or equal to
<= less than or equal to
if, else, if else
elif = if else
Datatypes
Force treating as a string: str(7) Force treating as an integer: int("7") Force treating as a float: float(7)
Check Datatypes
Check datatypes using type(var)
Escaping Characters
Simply add a \ to escape a character that would otherwise cause issues.
Arrays / Indexes
cows = "cows"[0]
This sets the variable cows to the 0th letter of the string "cows" which is c. These indexes start at 0, not 1.
Strings
String Methods
len(var) Get length of string.
var.lower() Force lowercase
var.upper() Force uppercase
str(var) Force treating variable as a string.
If it uses dot notation like .lower(), it works exclusively on strings.
Concatenation
"Ten times a cow is equal to " + result + " with 10 times as many breeding opportunities."
or
print(var, var2, var3)
or
string1 += string2
String Formatting with %
"%s %s - 2020" % (month, day) # Replace %s with a variable. First the month, then the day.
Add %03d to specify a signed integer padded 2 places with zeros. For example, 2 becomes 02.
This is super useful for displaying dates like this: print("%02d-%02d-%02d") % (now.month, now.day, now.year) or time like this: print '%02d:%02d:%04d' % (now.hour, now.minute, now.second) (Ch3, Ex. 4)
Date and Time (Ch3)
Grab the current time:
from datetime import datetime
now = datetime.now()
year = now.year
month = now.month
day = now.day
Function P3 Ch.2
Defining a Function
def greet_customer():
print("Welcome!")
Calling Functions
```
greet_customer()
```
or if it has parameters:
greet_customer(1,ten)
Passing Arguments
greet_customer(special_item):
print(special_item)
greet_customer(beef)
Result:
beef
Using Keyword Arguments
Keyword arguments are nice for specifying a default but changeable argument.
Here's an example from P3, Ch2, ex7
def create_spreadsheet(title, row_count = 1000):
row_count = str(row_count)
print("Creating a spreadsheet called " + title + " with " + row_count +" rows.")
create_spreadsheet("Applications", row_count = 10)
row_count = 1000
is the default
row_count = 10
is the passed argument and thus what is used for a result:
Creating a spreadsheet called Applications with 10 rows.
Returning Stuff
You can return stuff like this to store for later:
def addfour(number, cow):
addedfour = number + 4
cat = number - 4
return addedfour, cat # All returned arguments must be on the same return call.
I'll make it add four to 456
yo, cow = addfour(456)
print ("456 + 4 equals " + str(yo) )
460
You can also do this with multiple arguments:
x_squared, y_squared = square_point(1, 3)
Lists
You can put either strings, integers or other lists in a list, probably other things too.
heights = [['Jenny', 61], ['Alexus', 70], ['Sam', 67], ['Grace', 64]]
Use zip to combine elements from two lists: zip(names, dogs_names) would match dogs and their owners.
But don't forget to turn it into a list before printing print(list(zipvar))
You can append values to lists like this:
orders = ['daisies', 'periwinkle']
orders.append('tulips')
You can add lists like this: ['list1', 'stuff'] + ['list2', 'stuff'] but need to use lst1 + lst2 and not [lst1] + [lst2]
List Comprehensions
Say you only want to allow people over the height of 161 to ride your roller coaster for safety reasons. You could do this to create a list of only those heights about 161.
heights = [161, 164, 156, 144, 158, 170, 163, 163, 157]
can_ride_coaster = []
can_ride_coaster = [height for height in heights if height > 161]
print(can_ride_coaster)
You can manipulate lists with list comprehensions as well:
fahrenheit = [celsius * (9 / 5) + 32 for celsius in celsius]
Print every other element
odd = [odd for odd in lst if lst.index(odd) % 2 == 1]
return odd
Print manipulated numbers in for loop
single_digits = range(10)
squares = []
cubes = [(num ** 3) for num in single_digits]
for single_digits in single_digits:
print(single_digits)
squares.append(single_digits ** 2)
print(squares)
print(cubes)
For example, printing all cuts under $30
cuts_under_30 = [hairstyles[i] for i in range(0, (len(hairstyles) - 1)) if new_prices[i] < 30]
Another example
[lst.append("hi, " + name)]
Make sure starting number is uneven
def delete_starting_evens(lst):
while len(lst) > 0 and lst[0] % 2 == 0:
lst.remove(lst[0])
return lst
#Uncomment the lines below when your function is done
print(delete_starting_evens([4, 8, 10, 11, 12, 15]))
print(delete_starting_evens([4, 8, 10]))
Ranges
You can get a range of numbers using range()
It will give you all numbers under the number you input. For example, range(8) would give you 0-7, range(1, 8) would give you 1-7, and range(1, 8, 2) would give you 1,3,5,7 (2 is the interval and needs no padding) Use print(list(var)) when printing.
Ranges and list manipulation
You can combine range() with list manipulation like this:
for index in range(1, len(lst), 2):
new_list.append(lst[index])
length
Grab length with len(list)
Selecting List elements
Use: listname[indexnumber]
The index starts at 0. Grab the last in an index using list[-1]
Giving values to list elements
lst[index] = indexlst
Cutting the middle of a list (ex3, functions + lists, ch.4)
def remove_middle(lst, start, end):
end = end + 1
return lst[:start] + lst[end:]
print(remove_middle([4, 8, 15, 16, 23, 42], 1, 3))
This prints [4, 23, 42] removing the index 1-3.
If something occurs more than N times, return True
def more_than_n(lst, item, n):
if lst.count(item) > n:
return True
else:
return False
print(more_than_n([2, 4, 6, 2, 3, 2, 1, 2], 2, 3))
More frequency analysis
def more_frequent_item(lst, item1, item2):
if (lst.count(item1)) > (lst.count(item2)):
return item1
if lst.count(item2) > lst.count(item1):
return item2
if lst.count(item1) == lst.count(item2):
return item1
#Uncomment the line below when your function is done
print(more_frequent_item([2, 3, 3, 2, 3, 2, 3, 2, 3], 2, 3))
A creative original solution to grabbing the middle of an index (solving their problem with their names)
def middle_element(lst):
if len(lst) % 2 > 0:
rounded = round(len(lst) / 2)
rounded = int(rounded)
print(rounded)
return lst[rounded]
elif len(lst) % 2 == 0:
position = int((len(lst) / 2) - 1)
position2 = int(len(lst) / 2)
both = (lst[position] + lst[position2]) / 2
return both
print(middle_element([5, 2, -10, -4, 4, 5, 7]))
Add the last two elements, append them. (Ex.8)
def append_sum(lst):
trip = 0
while trip < 3:
lasttwo = lst[-2:]
added = lasttwo[0] + lasttwo[1]
print(added)
lst.append(added)
trip = trip + 1
return lst
#Uncomment the line below when your function is done
print(append_sum([1, 1, 2]))
Sublists
Grab a subset of a list using sublist = letters[1:6] This would give you index 1-5.
You can also do [:5] for all up to index 4, and [5:] for all after index 5. And, you can do [-3:] for the last 3 in an index.
Counting frequency of elements in a list.
var.count('stringtofind')
Sorting strings alphabetically
var.sort()
print(var)
or use
sortedvar = sorted(var)
to produce a new list with sorted contents without changing the original variable.
Sorting strings based on an element in a sublist
Replace 1 with the index you want to sort by.
`pizzas.sort(key=lambda x: x[1])``
Catch Errors
try:
command_may_cause_error
except NameOfError:
print("Nice little message to user.")
Loops
The following assigns an arbitrary name to a temporary variable (tempvar) to the number of elements in sport_games For every element in sport_games, it will print print(tempvar)
for tempvar in sport_games:
print(tempvar)
You can use range() to get lists of arbitrary lengths.
You can also add lists like this:
students_period_A = ["Alex", "Briana", "Cheri", "Daniele"]
students_period_B = ["Dora", "Minerva", "Alexa", "Obie"]
for student in students_period_A:
students_period_B.append(student)
Iterating until we find something
for thing in stuff:
if thing == thing_I_want:
print("Found it!")
break # Stops the loop, executes code outside.
Skip a value in a list.
Ex.5
for age in ages:
if age < 21:
continue
else:
print(age)
```
## Move from list to list
Ex.7
while len(students_in_poetry) < 6: student = all_students.pop(-1) # Remove last element students_in_poetry.append(student) # Add it to students_in_poetry
print(students_in_poetry)
# Nested Loops
for location in sales_data: print(location) for sub in location: scoops_sold += sub
# Fun Projects
Design a shop using Ex7 and Ex9 as a frame:
7:
money_in_wallet = 40 sandwich_price = 7.50 sales_tax = .08 * sandwich_price
sandwich_price += sales_tax money_in_wallet -= sandwich_price
9:
cucumbers = 1 price_per_cucumber = 3.25 total_cost = cucumbers * price_per_cucumber print(total_cost)
`total_price += nice_sweater`
Cool concept from Ch2 Ex15:
name = raw_input("What is your name? ") quest = raw_input("What is your quest? ") color = raw_input("What is your favorite color? ")
print "Ah, so your name is %s, your quest is %s, "
"and your favorite color is %s." % (name, quest, color)