Python3

Front 1

Floor division

Back 1

>>> //

Front 2

Modulus

Back 2

>>> x % y

Front 3

Convert to string

Back 3

>>> str(x)

Front 4

Convert to integer

Back 4

>>> int(x)

Front 5

Convert to float

Back 5

>>> float(x)

Front 6

Length of string

Back 6

>>> len("string")

#returns the number of characters in the string

Front 7

Convert string to lowercase

Back 7

>>> string.lower()

Front 8

Convert string to uppercase

Back 8

>>> string.upper()

Front 9

User input

Back 9

>>> input("User prompt: ")

#This is changed from Python2, and fulfills the function of raw_input()

Front 10

Display current date/time (datetime)

Back 10

>>> from datetime import datetime

>>> date = datetime.now()

>>> print ("%02d/%02d/%04d" % (date.month, date.day, date.year))

>>> print ("%02d:%02d:%02d" % (date.hour, date.minute, date.second))

Front 11

CPython

Back 11

CPython is Guido van Rossum's reference version of the Python computing language. It's most often called simply "Python"; speakers say "CPython" generally to distinguish it explicitly from other implementations.

Front 12

Jython

Back 12

Jython is a Python interpreter implemented in Java. It can be fully integrated into existing Java applications; alternatively, Python applications can be compiled into a collection of Java classes. Python programs running on the Jython virtual machine have full access to the Java classes and APIs.

Front 13

IronPython

Back 13

IronPython is an open source implementation of Python for the .NET CLR and Mono, originally created by Jim Hugunin. IronPython is a Python compiler. It compiles Python code to in memory bytecode before execution (which can be saved to disk, making binary only distributions possible).

Front 14

Stackless

Back 14

An enhanced Python implementation that doesn't use the C stack and is oriented toward concurrency. It is easier to port to small stack architectures, provides efficient multiprocessing options, and fosters novel programming structures such as coroutines.

Front 15

PyPy

Back 15

PyPy is an alternative implementation of Python. It often runs faster because it is a just-in-time compiler. Functionally, PyPy is designed around the technique known as meta-tracing, which transforms an interpreter into a tracing just-in-time compiler. Since interpreters are usually easier to write than compilers, but run slower, this technique can make it easier to produce efficient implementations of programming languages.

Front 16

Cython

Back 16

Cython is a programming language that aims to be a superset of the Python programming language, designed to give C-like performance with code that is written mostly in Python with optional additional C-inspired syntax

Front 17

Shed Skin

Back 17

Shed Skin is a Python to C++ programming language compiler. It is experimental, and can translate pure, but implicitly statically typed Python programs into optimized C++. It can generate stand-alone programs or extension modules that can be imported and used in larger Python programs.

Front 18

Psyco

Back 18

Psyco was a specializing just-in-time compiler for Python originally developed by Armin Rigo and further maintained and developed by Christian Tismer. Development ceased in December, 2011. It was not just another Python implementation, but rather a component that extends the byte code execution model to make programs run faster.

Front 19

Frozen Binaries

Back 19

Frozen binaries bundle together the byte code of your program files, along with the PVM (interpreter) and any Python support files your program needs, into a single package. There are some variations on this theme, but the end result can be a single binary executable program that can easily be shipped to customers. (pythonstudio.us)

Front 20

Import module & attributes

Back 20

>>> import module #Grab the whole module

>>> from module import attribute #Import specific

>>> exec(open("module.py").read() #executes the module once without importing it

Front 21

Reload module

Back 21

>>> reload(module)

#reloads for file changes

Front 22

Fetch module names

Back 22

>>> dir(module)

#fetches a list of names available in a module

Front 23

Python Hierarchy

Back 23

1. Programs are composed of modules

2. Modules contain statements

3. Statements contain expressions

4. Expressions create and process objects

Front 24

Numbers (example literals)

Back 24

1234, 3.1415, 3+4j, 0b111, Decimal(), Fraction()

Front 25

Strings (example literals)

Back 25

'spam'

"Monty's"

'Monty\'s'

b'a\x01c'

u'sp\xc4m'

Front 26

Lists (example literals)

Back 26

[1, [2, 'three'], 4.5], list(range(10))

Front 27

Dictionaries (example literals)

Back 27

{'food': 'spam', 'taste': 'yum'}, dict(hours=10)

Front 28

Tuples (example literals)

Back 28

(1, 'spam', 4, 'U'), tuple('spam'), namedtuple

Front 29

Files (example literals)

Back 29

open('eggs.txt'), open(r'C:\ham.bin', 'wb')

Front 30

Sets (example literals)

Back 30

set('abc'), {'a', 'b', 'c'}

Front 31

Printing/returning floats

Back 31

# Like many objects, there is a precise and user-friendly form

>>> 3.1415 * 2; 6.283000000000004 #repr: as code

>>> print(3.1415 * 2); 6.283 #str: user-friendly

Front 32

Indexing strings

Back 32

>>> string_var[0] #first character in string

>>> string_var[-1] #last character in string

(OR: string_var[len(string_var) - 1] #the 'hard way'

>>> string_var[-2] #second-to-last

Front 33

Slicing strings

Back 33

#string[first_index_inclusive:to_last_index_noninclusive]

>>> string_var = "string"

>>> string_var[1:4]; "tri"

>>> string_var[:3] #prints index 0-2

>>> string_var[:-1] #prints all but the last

>>> string_var[:] # all of string_var as a top-level copy (0:len(S))

Front 34

String concatenation

Back 34

>>> 'string one' + ' and two'

>>> string.__add__('and two') #the underlying method, not recommended for use

Front 35

String immutability

Back 35

Strings are immutable; a new variable must always be assigned, or a new string is always created.

>>> string[0] = 'x' #WRONG

TypeError: 'str' object does not support item assignment

>>> string = 'x' + string[1:] #RIGHT

Front 36

Immutable objects

Back 36

Numbers, strings, and tuples are immutable; they cannot be changed in place after they are created.

Front 37

Find offset in string

Back 37

>>> string = 'string'

>>> string.find('tr'); 1

Front 38

Replace occurrence in a string

Back 38

>>> string.replace(substring, replacement)

>>> string = 'string'

>>> string.replace('i', 'o')

>>> string; 'strong'

Front 39

Split string on a delimiter into a list of substrings

Back 39

>>> string.split(delimiter)

>>> string = 's,t,r,i,n,g'

>>> string.split(','); ['s', 't', 'r', 'i', 'n', 'g']

Front 40

Content tests on strings

Back 40

returns True or False

>>> string.isalpha()

#test for alphabetic

>>> string.isdigit()

#test for numeric

Front 41

String - strip characters

Back 41

string.xstrip("chars") #"chars" is optional

>>> string = 'sstrings'

>>> string.rstrip() #removes whitespace from right side

>>> string.lstrip("s"); "trings" #removes "s"s from left side

>>> string.strip("s"); "tring" #removes "s"s from both sides

>>> string.strip("s").split("i"); ["tr", "ng"] #combining operations

Front 42

Formatting expressions

Back 42

>>> '%s, eggs, and %s' % ('spam', 'SPAM!')

>>> '{0}, eggs, and {1}'.format('spam', 'SPAM!')

>>> '{}, eggs, and {}'.format('spam', 'SPAM!')

>>> '{x}, eggs, and {y}'.format(x='spam', y='SPAM!')

Front 43

Formatting digit strings

Back 43

>>> '{:,.2f}'.format(296999.2567)

'296,999.26' # Separators, decimal digits

>>> '%.2f | %+05d' % (3.14159, -42)

'3.14 | -0042' # Digits, padding, sign

Front 44

Paragraph formatting in strings

Back 44

\n : end-of-line

\t : tab

Front 45

Unicode formatting in strings

Back 45

>>> u'sp\xc4m'; 'spÄm' #Unicode

>>> b'a\x01c'; b'a\x01c' #byte

>>> u'sp\u00c4m'; 'spÄm' #2.X Unicode, works in 3.3+

>>> string.encode('utf8') #encode to 4 bytes in UTF-8

>>> string.encode('utf16') #encode to 10 bytes in UTF-16

Front 46

List

Back 46

General sequence, ordered collection of arbitrarily typed objects. Mutable and no fixed size.

>>> list = [item, 'item', 1734]

Front 47

Indexing lists

Back 47

>>> list[0] # index by position

>>> list[:-1] #slicing returns a new list

Front 48

Concatenating lists

Back 48

>>> list = [1, 2, 3]

>>> list + [4, 5, 6]

[1, 2, 3, 4, 5, 6] #generates a new list

>>> list * 2

[1, 2, 3, 1, 2 ,3]

Front 49

Add object to end of list

Back 49

>>> list.append(object)

Front 50

Delete object from list

Back 50

>>> list.pop(2) #removes object at index 2

>>> del list[2] #also works

Front 51

Nested lists and matrices

Back 51

>>> list = [[1, 2, 3],

. . . [4, 5, 6],

. . . [7, 8, 9]]

Front 52

List comprehension expression on matrices

Back 52

>>> matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

>>> column2 = [row[1] for row in matrix]

[2, 5, 8] # finding a column

>>> [row[1] + 1 for row in matrix if row[1] != 2]

[6, 9] #complex expressions

>>> diagonal = [matrix[i][i] for i in [0, 1, 2]]

[1, 5, 9] #finding a diagonal

Front 53

List comprehension/iteration over a string

Back 53

>>> string = 'string'

>>> doubled = [c * 2 for c in string]

['ss', 'tt', 'rr', 'ii', 'nn', 'gg']

Front 54

Range

Back 54

list(range(start_inclusive, end_noninclusive, interval))

>>> list(range(-6, 7, 2)

[-6, -4, -2, 0, 2, 4, 6]

Front 55

Add together all items in an iterable

Back 55

sum(iterable, start) #the 'start' is a number to be added in addition to objects in the iterable (default 0)

>>> list = [1, 2, 3]

>>> sum(list); 6

>>> sum(list, 1); 7

Front 56

Reverse a list or tuple

Back 56

>>> list[::-1] #the most idiomatic way

Front 57

Check that x is a multiple of y

Back 57

>>> if x % y == 0

Front 58

Pure vs impure functions

Back 58

Pure functions return a value that depends on only their arguments.

>>>def pure_function(x, y): temp = x + 2*y return temp / (2*x + y)

>>> some_list = []

>>> def impure(arg):

. . . some_list.append(arg)

Front 59

Reasons for using pure functions

Back 59

Using pure functions has both advantages and disadvantages. Pure functions are:

- easier to reason about and test.

- more efficient. Once the function has been evaluated for an input, the result can be stored and referred to the next time the function of that input is needed, reducing the number of times the function is called. This is called memoization. - easier to run in parallel.

Front 60

Map

Back 60

The function map takes a function and an iterable as arguments, and returns a new iterable with the function applied to each argument.

>>> list_result = list(map(func, iterable))

>>> result2 = map(lambda, iterable))

Front 61

Filter

Back 61

The function filter filters an iterable by removing items that don't match a predicate (a function that returns a Boolean).

>>> filtered_list = list(filter(function, iterable))

Front 62

Magic methods for operators

Back 62

__sub__ for -

__mul__ for *

__truediv__ for /

__floordiv__ for //

__mod__ for %

__pow__ for **

__and__ for &

__xor__ for ^

__or__ for |

Front 63

r Methods

Back 63

:)

Front 64

Magic methods for comparisons

Back 64

__lt__ for <

__le__ for <=

__eq__ for ==

__ne__ for !=

__gt__ for >

__ge__ for >=

If __ne__ is not implemented, it returns the opposite of __eq__.

Front 65

Garbage collection

Back 65

The process of deleting objects when they are no longer needed

Front 66

Using lists as stacks

Back 66

>>> list.append(item)

>>> list.pop()

Front 67

Using lists as queues

Back 67

SLOW method:

>>> queue.insert(0, item)

>>> queue.pop(0)

PREFERRED method:

>>> from collections import deque

>>> queue = deque(["Eric", "John", "Michael"])

>>> queue.append("Terry")

>>> queue.popleft()

'Eric'

>>> queue

deque(['Michael', 'Terry', 'Graham'])

Front 68

List comprehension

Back 68

>>> squares = []

>>> for x in range(10):

... squares.append(x**2)

# leaves behind a variable x

>>> squares = list(map(lambda x: x**2, range(10))

# Cleaner.

# Or, equivalently:

>>> squares = [x**2 for x in range(10)]

Front 69

Join items in list

Back 69

>>>seperator.join(list)

>>> print(", ".join(["spam", "eggs", "ham"]))#prints "spam, eggs, ham"

Front 70

Replace substring

Back 70

>>> string.replace(substring, replacement)

>>> print("Hello ME".replace("ME", "world"))#prints "Hello world"

Front 71

Check if a string starts or ends with a particular substring

Back 71

>>> string.startswith(substring))

>>> string.endswith(substring))

#returns Boolean

Front 72

Find the minimum or maximum of numbers in a list or tuple

Back 72

>>> min[1, 2, 3] #1

>>> max(1, 2, 3) #3

Front 73

Find the absolute value

Back 73

>>> abs(-47) # 47

Front 74

iterate through the values and indices of a list simultaneously

Back 74

>>> list = [1, 2, 10]

>>> for value in enumerate(list): print(value)

(0, 1); (1, 2); (2, 10)

Front 75

Higher-order functions

Back 75

Functions that take other functions as arguments

>>> def hi_func(func, arg):

Front 76

Extend list by appending all items from the iterable

Back 76

>>> list.extend(iterable)

Front 77

Insert an item at a given position in a list

Back 77

>>> list.insert(index, item)

Front 78

Remove first item from a list whose value is x

Back 78

>>> list.remove(x)
#raises a ValueError if there is no such item

Front 79

Remove an item at a given position in a list and return it

Back 79

>>> list.pop(index)

>>> list.pop() #removes and returns the last item by default

# "del list[index]" removes without returning

Front 80

Remove all items from a list

Back 80

>>> list.clear()

or:

>>> del list[:]

Front 81

Return the index of the first item in a list with value x

Back 81

>>> list.index(x, index_start, index_end)

# start and end, which act as slices, are optional

>>> list.index(x)

Front 82

Return the number of times x appears in a list

Back 82

>>> list.count(x)

Front 83

Sort the items of a list in place

Back 83

>>> list.sort()

# Has two optional arguments:

>>> list.sort(key=None, reverse=False)

# key: Default value is None. "specifies a function of one argument that is used to extract a comparison key from each element in the iterable"

# reverse: is a Boolean value. If set to True, the list is sorted in reverse

Front 84

Reverse the elements of a list in place

Back 84

>>> list.reverse()

Front 85

Return a shallow copy of a list

Back 85

>>> list.copy()

#equivalent to "a[:]"

Front 86

Remove an item from a list without returning that item

Back 86

>>> del list[index]

Front 87

Remove a slice from a list

Back 87

>>> del list[index_start: index_end]

Front 88

Create a one-item tuple

Back 88

>>> singleton_tuple = item,

Front 89

Create an empty tuple

Back 89

>>> ()

Front 90

Create a tuple

Back 90

>>> tuple = item_1, item_2

Front 91

Create a set

Back 91

>>> set = {item, item ... }

# or

>>> set(item, item ... )

Front 92

Create an empty set

Back 92

>>> set()

#Note: "{}" will create an empty dictionary, not an empty set

Front 93

Create a dictionary

Back 93

>>> {'key1': item1, 'key2', item2, ...}

# or build one via "dict()"

>>> dict([key, item], [key, item], ... )

{'key': item, 'key': item, ...}

# or use a dict comprehension

>>> {x: x**2 for x in (2, 4, 6)}

{2: 4, 4: 16, 6: 36}

Front 94

Loop through a dictionary and retrieve key-value pairs

Back 94

>>> for key, item in dict.items():

. . . print(key, item)

Front 95

Loop through a sequence and retrieve index-value pairs

Back 95

>>> for index, item in enumerate(iterable):

. . . print(index, item)

Front 96

Loop over 2+ sequences at a time

Back 96

>>> sequence1 = ['1', '2', '3']

>>> sequence2 = ['a', 'b', 'c']

>>> for num, lett in zip(sequence1, sequence2):

. . . print(num, lett)

1 a

2 b

3 c

Front 97

Loop over a sequence in reverse

Back 97

>>> for item in reversed(sequence):

. . .

Front 98

Loop over a sequence in sorted order

Back 98

>>> for item in sorted(sequence):

. . .

Front 99

Compound data types

Back 99

- strings: loosey compound in that they're composed of substrings/characters, immutable

- lists: composed of items, mutable

- tuples: composed of items, immutable

- sets: composed of items, not ordered, no duplicates

- dictionaries: consists of key:value pairs, mutable

Front 100

Determining if a string comes alphabetically before another

Back 100

>>> if string1 > string2:

. . .

# capital letters come alphabetically before lowercase, so make sure the words match upper or lower

Front 101

Fetch unique id of a value

Back 101

id(value)

Front 102

String search

Back 102

str.find(string, substring, starting_index)