-phython is good for calculations ,they can be automated
Unit 1
“Print” - prints statements onto the console
Boolean - True OR False (written exactly like this)
Ex your_mama = False
Unit 2
String - contains numbers letters and symbols
Ex name = “Ryan”
Escaping characters - (\) <- the command
-some time words in stings like’ makes the string un stringly so you gotta add / to it
● len() - gives the number of letters in a string
Ex: parrot = "Norwegian Blue"
print len(parrot)
This print “14”
● lower() - gets rid of capitalization
Ex:
Parrot (the variable from the last).lower()
● upper() - makes stuff uppercase
The same notation as lower
Ex : print parrot.upper()
● len() -checks the length of string ( it starts readin g aty 0 )
]
-
Ex:
● str() - turns non strings strings
ex :
Pi = 3.24
Print str(pi)
● Dot notation (like .upper)
- Dot notation is used only with strings
Parentheses notation (not formal) ex:len() can work on other data types
Parts of code
- Editor: the part where you write code
- console : results of code
String concatenation
- def : Using strings and math operators (+) to print strings
Ex: print "Spam" + " and" + " eggs
Explicit string conversion
-when you printing a string with non string
String formating
● The faster way to add variables to strings
Date time
- datetime.now()
● Shows the exact date and time
- print now.hour
-now.minute
-now.second
-now.year
-now.month
-now.day
Mad libs
-
-m\
raw _input
- lets user types stuff , solely for strings.
- accepts a string, prints it, and then waits for the user to type something and
press Enter (or Return).
Ex: name = raw_input( “enter a name”)
(Go back to a certain lesson i dont think i wrote it down)
Unit 3 : Conditionals an control flow
- Def: Gives the code the ability to choose among outcomes base on what else is
happening in the program.
Comparators (goes with boolens true and false stuff)
- There are 6
● Equal to (==)
● Not equal to (!=)
● Less than (<)
● Less than or equal to(<=)
● Greater than(>)
● Greater than or equal to(>=)
ex : >>> 2 == 2
True
>>> 2 == 5
False
- Compares values
-
-
-
- There’s an order to these operators
Order of operations:
1. not
2. And
3. Or
You can use parentheses to get everything in the order you want
Conditional Statement Syntax
-make sure the stuff uner if else stuff is indented, thats how
If: executes specified code after checking if the expression is true
indentation before the print statement. This space, called white space, is how
Python knows we are entering a new block of code. (you can indent with b4
spaces )
If the indentation from one line to the next is different and there is no command
(like if) that indicates an incoming block then Python will raise an
IndentationError. These errors could mean, for example, that one line had two
spaces but the next one had three. Python tries to indicate where this error
happened by printing the line of code it couldn’t parse and using a ^ to point to
where the indentation was different from what it expected.
Else /if else: if the the if statement is false then the else statement will run.
- Doesnt depend on an expression,like 8>9
Ex:
def black_knight():
if answer == "'Tis but a scratch!":
return True
else:
return False
Elif: a short for else if
Ex: if 8 > 9:
print "I don't get printed!"
elif 8 < 9:
print "I get printed!"
else:
print "I also don't get printed!"
In this ex the elif statement is only checked if the og if statement is
true
Lesson 6,7,8,9
.isalpha()- can be used to check that a string
-if its not a string it will return false
ex:if len(original) > 0 and original.isalpha():
-You can use and to add on to an if statement
Ex: if 8==9
And 0==7
Print “silly”
-notation: s = ‘charlie’
print s[0] (this will print only the c)
Print s[1:4](this will print har,returing everything at
position one to 4)
Set new_word equal to the slice from the 1st index all the way to the end of new_word.
Use [1:len(new_word)] to do this.
When slicing until the end of the string, instead of providing len(new_word), you can
also not supply the second index:
ex:
Python
my_string = "Python"
my_string[1:] # "ython"
%- combines strings with variables
Ex quarter = 0.25
print "A quarter is %f" % (quarter)
The %f will be replaced with % /,,[;
Functions
- Can be used when you want to reuse a piece of code but with diff values.
Def: Function : -the header, optional comment, and the body
header - includes the def key word, the name of the function, and any requirements the function
needs
Comment-just says what its supposed to do
body - describes what the function carries out. Its always indented.
Ex def hello_world():
"""Prints 'Hello World!' to the console."""
print "Hello World!"
After defining a function it must be called to be used
We do this by putting Name_of_fucntion() ←- just like that, at the end of the
function , or where ever you want the function to be used (im guessing on the
last part)
def square(n):
- You can put a variable inbetween the paranties so when your ready to
the function you can put in a values which will carry out any
calculations what was done inside the function
-
Variables are called parameters in code , its an input to teh function
Values of the parameters passed into a function is called arguments
- Usually the arguments are the same number as the parameters
Functions calling functions
def fun_one(n):
return n * 5
def fun_two(m):
return fun_one(m) + 7
Module: A file that contains definitions-including
variables and functions-v that you can use once imported.
How to import modules
- Use the word import then add what ever
module you want (called genric import)
Ex: import math
Print math.sqrt(25) ← will find the square
root of 25
-
Modules
Math
( lets
you
use
math
functi
ons)
Universal modules
- When you dont want to keep tying
math. And such
- Knowing when to use them is
important.
● They fill up your program with
alot of variables and function
names
SO BASICALLY I GOT LOST EL OH EL
Universal imports may look great on the surface, but they’re not a good idea for
one very important reason: they fill your program with a ton of variable and
function names without the safety of those names still being associated with the
module(s) they came from.
If you have a function of your very own named sqrt and you import math, your
function is safe: there is your sqrt and there is math.sqrt. If you do from math
import *, however, you have a problem: namely, two different functions with the
exact same name.
Even if your own definitions don’t directly conflict with names from imported
modules, if you import * from several modules at once, you won’t be able to
figure out which variable or function came from where.
For these reasons, it’s best to stick with either import moduleand type
module.name or just import specific variables and functions from various modules
as needed.
The format is: from module import *
LESSON 12
MAX(): A function that takes any number of arguments
and returns the largest one
-best to use on integers and floats.
Ex: max(1,2,3) -> will return 3
min(): returns the smallest v alue
abs() : absolute values ,only takes single number
type():prits out the type of data type.
Ex print type(42) -> <type ‘int’>
Python 3
-alot of this stuff is the same so im just leav ing it in the same docs
Lists
List: data structure, allows us to work with a
collection of data in a sequence order
Ex: heights = [61, 70, 67, 64]
1. A list begins and ends with square brackets ([and ]).
2. Each item (i.e., 67 or 70) is separated by a comma (,)
3. It’s considered good practice to insert a space ( ) after each comma, but
your code will run just fine if you forget the space.
- Can have strings, numbers, literally any data type
Empty list: we use when we planning to fill it up
later
Ex: my_dog = []
.append(): Adds element at the end of the list
ex:example_list = [1, 2, 3, 4]
#Using Append
example_list.append(5)
- You can even use append with variables ,i found
its easy to make a variable with a list to add
atthed end of the 2d list
● To add multiple items to a list you can use + to
combine two lists(concatenation)
● Index: location of element
● In python it starts from 0
To call an element from a list type number the item
Ex: print(calls[2])
Will out put: Amamre
hen accessing elements of a list, you must use an int as the index.
To solve this problem, you can force the result of your division to be an int by
using the int() function.
Ex: calls[int(4/2)]
● Can use -1 to se;ect the last element in a list
● Modifying elements
● - just assign values using specif index
Ex: garden[2] = "Strawberries"
print(garden)
.remove(): remove element
Ex: shopping_line.remove("Chris"
Two-Dimensional (2D) Lists
-lists in lists
ex:heights = [["Noelle", 61], ["Ava", 70], ["Sam", 67], ["Mia", 64]]
Lesson 2 of lists
.sort() Python list method will sort the contents of whatever list it is called
on. Numerical lists will be sorted in ascending order, and lists of Strings will be
sorted into alphabetical order. It modifies the original list, and has no return
value.
.insert(): allows us add an element to a specific index in a list
It expects two inputs:
1. The index you want to insert into
2. The element you want to insert at the specified index
-will handle shifting over elements and can be used with negative indices.
-When we insert an element into a list, all elements from the specified index and
up to the last index are shifted one index to the right. This does not apply to
inserting an element to the very end of a list as it will simply add an additional
index and no other elements will need to shift.
.pop(): removes items at specific index
The .pop() method takes an optional single input:
The index for the element you want to remove.
-if you dont put the index it will remove the last element in the list .
- will return the value that was removed
If we wanted to know what element was deleted, simply assign a variable to the
call of the .pop()method. In this case, we assigned it to removed_element.(?????)
Passing in an index that does not exist or calling .pop() on an empty list will
both result in an IndexError.
range():takes a single input and generates numbers starting at 0 and ending at
the number before the input
ex:my_range = range(10)
- Too use rangeas a list ya must convert to list using list()
- list():takes in a single input for the object ya want ot convert
ex : print(list(my_range))
It would Output : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
if we want our range to start at diff numerers:
- Just put two numbers in range
- Ex: range(2, 9)
- It will make numbers from 2 till 8
If we want the list to skip in increments we put them in then we can put it at the end
len(): used to find the length of an object
ex : long_list_len = len(long_list)
Range objects do not need to be converted to lists in order to determine their
length
Slicing Lists I
-we often only wnat a portion of a list
Slicing: is when we extract only a portion of a list
The structure of slicing
Variable[start:end]
Ex: sliced_list = letters[1:6]
print(sliced_list)
- The end is gonna be one more than the actual index
You can also slice like
Variable[:x]
It will slice the first x items except the last one (like [:3] will print till 2)
Negative indices can also accomplish taking all but n last elements of a list.
.count():counts the appearances of an element
num_i = letters.count("i")
print(num_i)
It will print a number
ex:um_pairs = number_collection.count([100, 200])
print(num_pairs)
If you want to know how often the sublist [100, 200} appears
.sort(): sorts a list in alphabetical order or numerical
- You can sort in reverse by putting .sort(reverse = True)
- Sort doesnt return a value so it doesntg need to assigned a variable
sorted()
- comes before a list, instead of after as all built-in functions do.
It generates a new list rather than modifying the one that already exists.
-you assign a variable to this one
Ex: sorted(names)
Tuples exist - they are like lists exc ept you cant change them
