Overview

Strings are used to represent character data.
They can be represented as a sequence of characters, blanks, and punctuation characters, enclosed within single quotes.

You can add strings together with +, such that "hello"+"world" will output "helloworld"

You can multiply strings together with *, such that "hello" * 3 will output "hellohellohello

Indexing Strings (filtering characters)

If you would like to pick a specific character, just pass the string variable to the indexing operator [], simply attach [startCharVal : endCharVal] to the end of your variable with the character or section of characters you would like starting from either the beginning, or with - to filter from the end.

mystring = "asparagus"
mystring[0] would return “a”
mystring[0:5] would return “aspara”
mystring[-3] would return “g”
mystring[2:] would return everything after s, so “sparagus”
mystring[1] = g would replace the first letter with G, so “guspragus”
lastly mystring[:2] would return everything including and before s, so “as”

Steps

Add another : and wow! You can control how far Python jumps between characters. Normally, python goes one character at a time, but with a second : and an integer you can tell it to go through every other character, or to go through the string backwards with -1.

mystring = 'asparagus'
print(mystring[0:8:-1] or [::-1])
> # Returns sugarapsa

Absolutely loud correct buzzer and explosion sound effect with this one line function to reverse an input (Google DOES NOT want you to know this one simple trick /j):

print(input()[::-1])

Print command tricks

Commas allow you to print multiple different things, automatically separated by a space

Newlines are always added automatically after the print command finishes outputting the contents fed to it

seperator lets you change what character is inserted between items in a print command,

end lets you change what character is used at the end of a print command.

print("thing1", "thing2", sep = ' and ')
> # Returns "thing1 and thing2"

file lets you set an output file for print, which writes / appends the output to the file. First open a file with open, then set file = outfile.

Undercore Underscore Functions

Underscore functions affect the self, usually using concatenation

String Functions

Cool and rad ways to tot-tot-totally whip up new strings

string.count(target): Returns the number of times the target occurs within a string

string.find(target): Returns the index of the first occurrence of the target in a string

string.index(target): Does the same thing as .find but crashes if it can't find the term you're looking for, while .find simply returns -1

string.lower() OR string.upper() return a copy of the string that is all lowercase or uppercase

string.islower() OR string.isupper() return True if the string is lower or upper case

string.replace(old, new) returns a copy of the string with all occurrences of the old segment replaced with the new one

string.swapcase() uppercases lowercase letters and lowercases uppercase letters.

string.title() uppercases the first letter of each word. It can get a bit jank with commas and apostrophies, so you might prefer string.capwords()

s.split(seperator) returns a list of substrings, split using the set separator which defaults to a space.

ord(character) gives you the number corresponding to the character, and allows you to change the characters by shifting them up one or down one, eg, if shifting up B would become C, C would become D.

chr(number) turns a number into it's corresponding ASCII character, eg, 97 becomes A.

Multi-line strings

Use instead of ' ' to create strings that include newlines

Floats

You should add 0.1 and 0.2 (python will do a great job of adding them normally without any random issues!)

Floating point numbers have a set number of digits with a decimal somewhere in the mix, which is how you can create non-integer numbers.

print(0.1 + 0.2)
> 0.30000000000000004

Wow! It certainly uh.. did math... I think

Integers (ints)

whole number. you're welcome.

print(1 + 2)
> 3

Overview

You can take commands you execute frequently and bundle them up! Instead of calling everything seperatly, just call the bundle.

def myFunction() :
	print('hello world!')

Doc Strings

But! How do we remember what it does? This is where doc strings come in.
You can add a string right below the function declaration, which will appear whenever you run help function(), making it easier for other programmers to learn what your functions do.

def myFunction():
	`Prints hello world when called`
	print('hello world)

Then, you can check your doc string with help.

> help myFunction()
># Prints hello world when called

Pass

Python: So wait- you WANT a function to do nothing? That's not allowed! What are you thinking? You utter microwave
Author: uhhhh pass
Python: fine

def doNothing():
	`World's most productive function`
	pass

Overview

Put things in a list! Many strings! Many ints! And also functions for wrangling your data in lists, and other types too.

Unlike strings, they are mutable, which means they can change over time.
Another note! If you turn a string into an array, each digit in the string will have it's own index.

Insert

adds an item to the beginning of the list, first, optionally tell it the index, then give it the thing to insert.

myList = [0.5, 2.1, 4.5, 3.2, 9.9]
myList.insert(2, 5.6)
myList
> # Returns [0.5, 2.1, 5.6, 4.5, 3.2, 9.9]

Append

adds an item to the end of the list

myList = [0.5, 2.1, 4.5, 3.2, 9.9]
myList.append('cake')
myList
> # Returns [0.5, 2.1, 4.5, 3.2, 9.9, 'cake']

Sort

orders a list from smallest to biggest, but only if you're working with an array of numbers. Strings are a no go.

  myList = [0.5, 2.1, 4.5, 3.2, 9.9]
  myList.sort()
  myList
> # Returns [0.5, 2.1, 3.2, 4.5, 9.9]

Pop

Remove something from an array at a set index and return it. You can use
e taking someone's pizza order receipt off a stack and handing it to them after their order is complete.

  myList = [0.5, 2.1, 4.5, 3.2, 9.9]
  lastThingInList = myList.pop(-1)
  lastThingInList
> # Returns 9.9

Pop removes the last item by default, so we can actually remove the index of -1

  myList = [0.5, 2.1, 4.5, 3.2, 9.9]
  lastThingInList = myList.pop()
  lastThingInList
> # Returns 9.9

Max & Min

Get the largest or smallest thing in an object, such as an array or string.

myList = [0.5, 2.1, 4.5, 3.2, 9.9]
max(myList)
> # Returns 9.9
max(2, 5)
> # Returns 5
min(myList)
> # Returns 0.5

Sum

Add em' up!

myList = [0.5, 2.1, 4.5, 3.2, 9.9]
sum(myList)
> # Returns 20.2

Count

Check how frequently an object appears in a list

myList = [0.5, 2.1, 4.5, 0.5, 9.9]
myList.count(0.5)
> # Returns 2

In

your walls. I mean, your list. Is a thing in your list?

myList = [0.5, 2.1, 4.5, 3.2, 9.9]
2.1 in myList
> # Returns True

Join

Crush the thing into one thing

Iterate through a sequence or range, repeating set code until items are exhausted.

If you don't have a set number of items, you can use the range function with a start, end, and step, to iterate through the values given

Indexed Loops

Goes through an array and opearates on each instance in the array

myList = [0.5, 2.1, 4.5, 3.2, 9.9]
for index in range(len(myList))
	myList[index] +=1
> # Returns [1.5, 3.1, 6.6, 5.5, 4.2, 10.9]

You might have noticed Account.balance(self) is used instead of self.balance, this is because self gets muddy when classes inherit data from other classes, known as a super class. Instead of learning it the quick way (self.balance) and then needing to relearn it later, it's better to learn it once the right way.

__init__ Required, passes initial data into an instance of a class
__str__ This is used if you call print on a python class instance, you can make it do anything as long as it only takes self as an input and returns a string
__repr__ Used if you call eval on a python class instance, should return only the raw data with no pretty formatting
__gt__ Used when greater than operations are called on a class instance
__iter__ Iterator, used when loops are called and allows you to adjust iteration behavior
__next__ Called to get the next value by iterators.

__funcName__ can be called anywhere, even without the class prefix.

Use iter([])!