Documentation

Examples:

Code	Output
print 12	12
print -12.0	-12
print 0b1001	9
print 021	17
print -021	-17
print 0x3A8	936
print 12L	12
print 12345678901234567890123456789012345678901234567890	12345678901234567890123456789012345678901234567890
print 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFL	340282366920938463463374607431768211455
print +12.12345	12.12345
print -12.12345	-12.12345
print 1.2e3	1200
print 1.2e-3	0.0012

Integers can be given in any of four bases:

• Base ten (decimal — what people are most used to): consists of a sequence of digits, not starting with 0
• Base two (binary): consists of 0b followed by 0's and 1's
• Base eight (octal): consists of a 0 followed by digits in the range 0 to 7
• Base sixteen (hexadecimal): consists of 0x followed by digits in the range 0 to 7 or letters in the range A to F (in upper or lower case)

Integers can be preceded by a positive or negative sign. Any integer followed by an L or whose absolute value is greater than some minimum is consider a long integer.

Floating-point numbers consist of a series of digits, a decimal point, and another series of digits. They can be preceded by an optional positive or negative sign. They can be followed by an optional exponent — the letter e, an optional positive or negative sign, and a series of digits.

Syntax:

int(x)

long(x)

float(x)

Examples:

Code	Output
print int()	0
print int('234')	234
print int(1.6)	1
print int(False)	0
print long()	0
print long('234')	234
print long(1.6)	1
print long(False)	0
print float()	0.0
print float('3.89')	3.89
print float('inf')	inf
print float('-inf')	-inf
print float(3)	3.0
print float(False)	0.0

See also:

round() — Rounds to nearest integer

math.trunc() — Rounds to zero (same int() and long() on integers)

math.ceil() — Rounds up

math.floor() — Rounds down

Given a number, int() and long() return the integer part of it, i.e., they round towards zero. Given a Boolean, they return zero (i.e., 0, 0L, or 0.0) for False, and one (i.e., 1, 1L, or 1.0) for True. Given a string containing a printed representation of an integer, int() and long() return that integer. Similarly, given a string containing a printed representation of a number, float() returns that number. Special cases for float() are the inputs "inf" and "-inf", representing positive and negative infinity, respectively. Given any other string, these raise a ValueError.

Syntax:

a + b

Example:

Code	Output
print 3 + 12	15

Returns the sum of a and b. Standard addition operation.

Addition and assignment can be combined with the shorthand a += b, which is equivalent to a = a + b.

Syntax:

a - b

- a

Examples:

Code	Output
print 12 - 3	9
a = 3 print -a	-3

With two arguments, returns the difference of a and b. Standard subtraction operation.

With one argument, return the negation of a. Equivalent to 0 - a.

Subtraction and assignment can be combined with the shorthand a -= b, which is equivalent to a = a - b.

Syntax:

a * b

Example:

Code	Output
print 3 * 12	36

Returns product of a and b. Standard multiplication operation.

Multiplication and assignment can be combined with the shorthand a *= b, which is equivalent to a = a * b.

Syntax:

a / b

a // b

Examples:

Code	Output
print 12 / 3	4
print 11 / 3	3
print 11 // 3	3
print 12.0 / 3.0	4.0
print 11.0 / 3.0	3.6666666666666665
print 11.0 // 3.0	3.0

Example:

• Division

The standard division operation, /, returns the quotient of a and b. When both a and b are integers, then so is the result, i.e., the result is instead the floor of the quotient.

The integer division operation, //, returns the floor of the quotient of a and b, i.e., the integer part. When both a and b are integers, then so is the result, otherwise the result is a floating-point number with no value after the decimal.

Division and assignment can be combined with the shorthand a /= b and a //= b, which are equivalent to a = a / b and a = a // b, respectively.

Syntax:

x % m

Example:

Code	Output
print 11 % 3	2

Example:

• Modulus

Returns the remainder of x // m.

Modulo and assignment can be combined with the shorthand x %= m, which is equivalent to x = x % m.

Syntax:

x ** y

Example:

Code	Output
print 3 ** 4	81

See also:

pow() — Built-in exponentiation function

math.pow() and math.exp() — Similar exponentiation functions

Returns x to the power of y.

Exponentiation and assignment can be combined with the shorthand x **= y, which is equivalent to x = x ** y.

Syntax:

pow(x, y)

pow(x, y, m)

Examples:

Code	Output
print pow(3, 4)	81
print pow(3, 4, 2)	1

See also:

** — Built-in exponentiation operator

math.pow() and math.exp() — Similar exponentiation functions

Given a number m, this returns the remainder of x to the power of y, divided by m. Given no m, this returns x to the power of y, just like x ** y.

Syntax:

abs(x)

Examples:

Code	Output
print abs(3)	3
print abs(-3.0)	3.0

See also:

math.fabs() — Always returns a floating-point number

Returns the absolute value of number x. The result is of the same type as the input.

Syntax:

round(n)

round(n, i)

Examples:

Code	Output
print round(12)	12.0
print round(12.5)	13.0
print round(-12.5)	-12.0
print round(123.4567, 2)	123.46
print round(123.4567, -2)	100.0

See also:

int() and long() — Round to zero

math.trunc() — Rounds to zero

math.ceil() — Rounds up

math.floor() — Rounds down

With one number argument, it returns the floating-point number that represents the integer nearest n.

With two number arguments, it returns the floating-point number that represents n rounded to the nearest unit of 10ⁱ, for integer i. I.e., when i is positive, this is the familiar idea of rounding to i places after the decimal. However, i can be zero or negative, as well.

In either case, a 5 digit is always rounded up.

Syntax:

bin(x)

oct(x)

hex(x)

Examples:

Code	Output
print bin(9)	0b1001
print oct(-17)	-021
print hex(936)	0x3a8

Given an integer, returns a string representing that number in binary, octal, or hexadecimal, respectively. The resulting string is in the same syntax as Python integer constants.

Syntax:

chr(i)

Example:

Code	Output
print chr(97)	a

Returns a string of one character whose ASCII code is the integer i. This is the inverse of ord().

Syntax:

ord(x)

Example:

Code	Output
print ord('a')	97

Given a string of length one, returns an integer representing the Unicode code point of the character when the argument is a unicode object, or the value of the byte when the argument is an 8-bit string. This is the inverse of chr() for 8-bit strings.

Syntax:

~x

x & y

x | y

x ^ y

x << n

x >> n

Examples:

Code	Output
print ~0 # binary: 000	-1 # binary: 111
print ~-1 # binary: 111	0 # binary: 000
print ~13 # binary: 01101	-14 # binary: 10010
print -1 & -1 # binary: 111 & 111	-1 # binary: 111
print 14 & 7 # binary: 01110 & 00111	6 # binary: 00110
print 14 | 7 # binary: 01110 | 00111	15 # binary: 01111
print 14 ^ 7 # binary: 01110 ^ 00111	9 # binary: 01001
print 5 << 3 # binary: 0101 << 3	40 # binary: 0101000
print 23 >> 2 # binary: 010111 << 2	5 # binary: 0101

These operators all use the underlying twos-complement binary representation of the integral part of the numbers x and y.

• ~x : bitwise not (negation) of x
• x & y : bitwise and (conjunction) of x and y
• x | y : bitwise or (disjunction) of x and y
• x ^ y : bitwise exclusive or of x and y
• x << n : bitwise shift left of x by n bits
• x >> n : bitwise shift right of x by n bits

Syntax:

True

False

There are only two Boolean constants, True and False. They must be capitalized as shown.

In addition, the following constants are treated like False in a logical expression:

• None
• 0
• 0L
• 0.0
• ''
• []
• ()
• {}
• set([])

All other values are treated like True in logical expressions.

A values of a user-defined class is treated like False if it has a __nonzero__() method that returns False or if it has a __len__() method that returns 0.

Syntax:

bool(x)

Examples:

Code	Output
print bool(1)	True
print bool(2.3)	True
print bool(0)	False
print bool([])	False
print bool([1, 2, 3])	True
print bool(())	False
print bool((1, 2, 3))	True
print bool('')	False
print bool('abc')	True
print bool({})	False
print bool({1: 2})	True
print bool(set([]))	False
print bool(set([1, 2, 3]))	True

Returns True for any true-like) value, and False for any false-like) value.

Syntax:

x and y

Examples:

Code	Output
print True and True	True
print False and True	False
print 1 and 2	2
print 0 and 2	0

If x is False or any false-like value, then this expression results in x, otherwise this expression results in y.

Syntax:

x or y

Examples:

Code	Output
print True or True	True
print False or True	True
print 1 or 2	1
print 0 or 2	2

If x is False or any false-like value, then this expression results in y, otherwise it results in x.

Note that in English, the word “or” is used in two different ways. This operation represents “inclusive or” (x or y), where the result is True if at least one argument is True. In contrast, the “exclusive or” (x != y) is True if exactly one argument is True.

Syntax:

not x

Examples:

Code	Output
print not True	False
print not False	True
print not 2	False
print not 0	True

If x is False or any false-like value such as 0 or [], then this expression results in True, otherwise it results in False.

Syntax:

any(an_iter)

Examples:

Code	Output
print any([False, False, False])	False
print any([False, True, False])	True
print any([])	False
print any((0, 3))	True
print any('abc')	True

Returns whether bool(x) is True (or true-like) for any element x in the iterable.

Syntax:

all(an_iter)

Examples:

Code	Output
print all([False, True, False])	False
print all([True, True, True])	True
print all([])	True
print all((0, 3))	False
print all('abc')	True

Returns whether bool(x) is True (or true-like) for all elements x in the iterable.

Syntax:

"…"

'…'

"""…"""

'''…'''

r"…"

r'…'

r"""…"""

r'''…'''

Examples:

Code	Output
print ""	# The empty string.
print 'Hello, world.'	Hello, world.
print "Goodbye, cruel world."	Goodbye, cruel world.
print "It's a beautiful day."	It's a beautiful day.
print """This is a multi-line string."""	This is a multi-line string.

Typically, string constants are constructed within a matched pair of single or double quotes. A string with double quotes can contain single quotes, often used as apostrophes. Similarly, a string with single quotes can contain double quotes.

Using a pair of triple-single or triple-double quotes also creates a string, but also allows the string to span over multiple lines. These are primarily used as documentation strings to document the purpose of a function, method, or class definition.

Strings can contain ASCII characters.

Strings can contain escape sequences:

However, raw strings, those preceded by an r, do not recognize escape sequences. Raw strings are typically used for regular expressions.

Syntax:

str(x)

Examples:

Code	Output
print str()	# The empty list
print str(4859202)	4859202
print str(True)	True
print str('abc')	abc
print str(None)	None
print str((1, 2, 3, 4, 5))	(1, 2, 3, 4, 5)
print str([1, 2, 3, 4, 5])	[1, 2, 3, 4, 5]
print str({1: 'a', 2: 'b', 3: 'c'})	{1: 'a', 2: 'b', 3: 'c'}
print str(set([1, 2, 3, 4, 5]))	set([1, 2, 3, 4, 5])
print str(str)	<class 'str'>
class Silly: def __init__(self, x): self.x = x print repr(Silly(3))	<__main__.Silly object>
class Silly: def __init__(self, x): self.x = x def __str__(self): return 'Silly' + str(self.x) print str(Silly(3))	Silly3

See also:

repr() — Emphasizes unambiguity

Returns a string that is a printable representation of object an_obj. The intent is that this string should be human-readable. For built-in types, this is the normal printed representation. For user-defined types, this defaults to a string in angle brackets that includes the type of the object. However, a class can specify what this function returns for its instances by defining a __str__() method.

Syntax:

repr(an_obj)

Examples:

Code	Output
print repr([3, 5, 9])	[3, 5, 9]
class Silly: def __init__(self, x): self.x = x print repr(Silly(3))	<__main__.Silly object>
class Silly: def __init__(self, x): self.x = x def __repr__(self): return 'Silly' + str(self.x) print repr(Silly(3))	Silly3

See also:

str() — Emphasizes readability

Returns a string that is a printable representation of object an_obj. The intent is that this string should be unambiguous. For built-in types, this is the normal printed representation. For user-defined types, this defaults to a string in angle brackets that includes the type of the object. However, a class can specify what this function returns for its instances by defining a __repr__() method.

Syntax:

a_str % value

a_str % a_tuple

a_str % a_dict

Documentation:

• String Formatting Operations

Syntax:

a_str.join([iterable])

Examples:

Code	Output
print ','.join('abcd')	a,b,c,d
print ' '.join(['a', 'bc', 'd'])	a bc d
print 'zz'.join(('a', 'bc', 'd'))	azzbczzd
print ' '.join({'a': 'x', 'b': 'y'})	a b
print ' '.join(set(['a', 'b']))	a b

Returns a string which is the concatenation of the strings in the iterable. The string a_str is concatenated between the other strings as a separator.

Most commonly used to combine a list of strings into a single string.

Syntax:

a_str.capitalize()

Example:

Code	Output
print 'peAr'.capitalize()	Pear

Return a copy of the string a_str with its first character capitalized and the rest lower-cased.

Syntax:

a_str.upper()

a_str.lower()

Examples:

Code	Output
print 'abc123DEF'.upper()	ABC123DEF
print 'abc123DEF'.lower()	abc123def

Returns a copy of the string a_str with all the cased characters converted to upper- or lowercase, respectively

Syntax:

a_str.replace(old, new)

a_str.replace(old, new, maxreplace)

Examples:

Code	Output
print 'abcdabcd'.replace('bc', 'f')	afdafd
print 'abcdabcd'.replace('bc', 'f', 1)	afdabcd
print 'abcdabcd'.replace('g', 'f')	abcdabcd
print 'aaaaa'.replace('aa', 'f')	ffa

Returns a copy of the string a_str with all occurrences of substring old replaced by new. If the optional argument maxreplace is given, then the first at most maxreplace occurrences are replaced.

Syntax:

a_str.find(sub)

a_str.find(sub, start)

a_str.find(sub, start, end)

a_str.rfind(sub)

a_str.rfind(sub, start)

a_str.rfind(sub, start, end)

a_str.index(sub)

a_str.index(sub, start)

a_str.index(sub, start, end)

a_str.rindex(sub)

a_str.rindex(sub, start)

a_str.rindex(sub, start, end)

Examples:

Code	Output
print 'abcdabcd'.find('bc')	1
print 'abcdabcd'.find('bc', 3)	5
print 'abcdabcd'.find('bc', 3, 6)	5
print 'abcdabcd'.rfind('bc')	5
print 'abcdabcd'.rfind('bc', 3)	5
print 'abcdabcd'.find('f')	-1
print 'abcdabcd'.rfind('f')	-1
print 'abcdabcd'.find('bc', 6)	-1
print 'abcdabcd'.rfind('bc', 6)	-1
print 'abcdabcd'.find('bc', 3, 5)	-1

Returns the highest index in the string a_str where substring sub is found, such that sub is contained within a_str[start:end], where start defaults to 0, and end defaults to the length of a_str.

If the substring isn't found, a_str.find() and a_str.rfind() each return -1, while a_str.index() and a_str.rindex() each raise an error.

Syntax:

a_str.partition(sep)

a_str.rpartition(sep)

Examples:

Code	Output
print 'a b c'.partition(' ')	('a', ' ', 'b c')
print 'a b c'.rpartition(' ')	('a b', ' ', 'c')

See also:

a_str.split() — Splits multiple times

re.split() — Splits on more general patterns

?>

Splits the string a_str at the first (partition) or last (rpartition) occurrence of substring sep, and returns a 3-tuple containing the part before the separator, the separator itself, and the part after the separator. If the separator is not found, returns a 3-tuple containing two empty strings, followed by the string itself.

Syntax:

a_str.split()

a_str.split(sep)

a_str.split(sep, maxsplit)

Examples:

Code	Output
print 'a bc d'.split()	['a', 'bc', 'd']
print 'a bc d'.split(None)	['a', 'bc', 'd']
print 'a bc d'.split(' ')	['a', '', '', 'bc', 'd']
print 'a bc d'.split(' ')	['a', ' bc d']
print 'a bc d'.split('b')	['a ', 'c d']
print 'ababbaaaa'.split('a', 2)	['', 'b', 'bbaaaa']

See also:

a_str.partition(), etc. — Splits only once

re.split() — Splits on more general patterns

Returns a list of the words in the string a_str, using sep as the delimiter string. If maxsplit is given, at most maxsplit splits are done, the leftmost ones. If sep is not specified or is None, any whitespace string is a separator.

Syntax:

a_str.isdigit()

Examples:

Code	Output
print ''.isdigit()	False
print '1234'.isdigit()	True
print '1234abc'.isdigit()	False

Returns whether all characters in the string a_str are digits and that there is at least one character in the string.

Syntax:

a_str.center(width)

a_str.center(width, fillchar)

a_str.ljust(width)

a_str.ljust(width, fillchar)

a_str.rjust(width)

a_str.center(width, fillchar)

Examples:

Code	Output
print '*' + 'abcd'.center(30) + '*'	* abcd *
print 'abcd'.ljust(30) + '*'	abcd *
print 'abcd'.rjust(30)	abcd
print '*' + 'abcd'.center(30, 'x') + '*'	*xxxxxxxxxxxxxabcdxxxxxxxxxxxxx*
print 'abcd'.ljust(30, 'x') + '*'	abcdxxxxxxxxxxxxxxxxxxxxxxxxxx*
print 'abcd'.rjust(30, 'x')	xxxxxxxxxxxxxxxxxxxxxxxxxxabcd

Returns a_str aligned in a string of length width. The fill character defaults to a space. a_str.center() centers the string, a_str.ljust() left justifies it, and a_str.rjust() right justifies it.

These are typically used in simple output formatting to produce fixed-width columns.

Syntax:

a_str.startswith(prefix)

Examples:

Code	Output
print 'silly string'.startswith('sil')	True
print 'silly string'.startswith('ing')	False

See also:

a_str.endswith() — Checks suffix

Returns whether the string a_str begins with the string prefix.

Syntax:

a_str.endswith(suffix)

Examples:

Code	Output
print 'silly string'.endswith('sil')	False
print 'silly string'.endswith('ing')	True

See also:

a_str.startswith() — Checks prefix

Returns whether the string a_str ends with the string suffix.

Syntax:

a_str.strip(s)

a_str.strip(s, chars)

a_str.lstrip(s)

a_str.lstrip(s, chars)

a_str.rstrip(s)

a_str.rstrip(s, chars)

Examples:

Code	Output
print ' cde fgh '.strip()	cde fgh
print ' cde fgh '.strip(None)	cde fgh
print 'aaababcdeababfghbaba'.strip('ab')	cdeababfgh
print ' cde fgh '.lstrip()	cde fgh
print 'aaababcdeababfghbaba'.lstrip('ab')	cdeababfghbaba
print ' cde fgh '.rstrip()	cde fgh
print 'aaababcdeababfghbaba'.rstrip('ab')	aaababcdeababfgh

These return a new string like a_str except that leading (a_str.lstrip()), trailing (a_str.rstrip()), or both (a_str.strip()) characters are removed. They remove any characters given in chars, which defaults to any whitespace characters. Also, if chars is None, these also remove whitespace characters.

• Escape sequences \a and octal
• __str__() on built-in types
• __repr__() on built-in types
• eval()
• intern()
• a_str.replace(old, new, count)
• a_str.split(sep, maxsplit)
• a_str.startswith(prefix) with a tuple argument
• a_str.startswith(prefix, start)
• a_str.startswith(prefix, start, end)
• a_str.endswith(suffix) with a tuple argument
• a_str.endswith(suffix, start)
• a_str.endswith(suffix, start, end)
• a_str.decode()
• a_str.encode()
• a_str.expandtabs()
• a_str.format()
• a_str.isalnum()
• a_str.isalpha()
• a_str.islower()
• a_str.isspace()
• a_str.istitle()
• a_str.isupper()
• a_str.rsplit()
• a_str.splitlines()
• a_str.swapcase()
• a_str.title()
• a_str.translate()
• a_str.zfill()
• eval()

Syntax:

[val0, val1, …]

Examples:

Code	Output
print []	[]
print [1, 2, 3, 8, 9]	[1, 2, 3, 8, 9]
print [(1, 2), 'hello', 3, ['a', 'b', 'c']]	[(1, 2), 'hello', 3, ['a', 'b', 'c']]

Lists are constructed with square brackets, separating items with commas.

Syntax:

list()

list(an_iter)

Examples:

Code	Output
print list()	[]
print list('abc')	['a' ,'b', 'c']
print list([1, 2, 3, 4, 5])	[1, 2, 3, 4, 5]
print list((1, 2, 3, 4, 5))	[1, 2, 3, 4, 5]
print list(set([1, 2, 3, 4]))	[1, 2, 3, 4]
print list({1: 2, 3: 4})	[1, 3]
print list(enumerate(['a', 'b', 'c', 'd']))	[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

Converts any iterable or iterator into a list. If the argument is already a list, it returns a copy, i.e., a new list with the same elements.

Syntax:

a_list[index] = value

Example:

Code	Output
numbers = [4, 8, 19, 0] numbers[1] = 27 print numbers	[4, 27, 19, 0]

Mutates the list to now contain the given value at the given index. The index must be within the current range of indices of the list.

Syntax:

range(stop)

range(start, stop)

range(start, stop, step)

Examples:

Code	Output
print range(5)	[0, 1, 2, 3, 4]
print range(1, 10)	[1, 2, 3, 4, 5, 6, 7, 8, 9]
print range(-10, 100, 20)	[-10, 10, 30, 50, 70, 90]
print range(100, -10, -20)	[100, 80, 60, 40, 20, 0]
for i in range(5): print i	0 1 2 3 4

This is a versatile function to create lists containing arithmetic progressions. The step cannot be zero, and it defaults to 1. The start defaults to 0. The full form returns a list of integers [start, start + step, start + 2 * step, …]. If step is positive, the last element is the largest start + i * step less than stop; if step is negative, the last element is the smallest start + i * step greater than stop.

It is often used in for loops, as illustrated in the last example above. It provides a mechanism for looping a specific number of iterations.

Syntax:

a_list.append(x)

Examples:

Code	Output
a_list = [1, 2, 3] a_list.append(4) a_list.append([5, 6, 7]) print a_list	[1, 2, 3, 4, [5, 6, 7]]
list1 = [1, 2, 3] list2 = [1, 2, 3] list1.append([4, 5, 6]) list2.extend([4, 5, 6]) print list1 print list2	[1, 2, 3, [4, 5, 6]] [1, 2, 3, 4, 5, 6]

Add item x to the end of the list a_list.

A common mistake is to confuse a_list.append(x) and a_list.extend(x). As shown in the last example above, the former adds one element to the list, while the latter adds a group of elements.

Syntax:

a_list.extend(an_iter)

Examples:

Code	Output
a_list = [1, 2, 3] a_list.extend([]) print a_list	[1, 2, 3]
a_list = [1, 2, 3] a_list.extend([4, 5, 6]) a_list.extend((7, 8)) a_list.extend('abc') a_list.extend({'d': 'e', 'f': 'g'})	[1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c', 'd', 'f']
list1 = [1, 2, 3] list2 = [1, 2, 3] list1.append([4, 5, 6]) list2.extend([4, 5, 6]) print list1 print list2	[1, 2, 3, [4, 5, 6]] [1, 2, 3, 4, 5, 6]

Add each item from the iterable an_iter onto the end of the list a_list. When the iterable is a list, this is also called concatenation.

A common mistake is to confuse a_list.append(x) and a_list.extend(x). As shown in the last example above, the former adds one element to the list, while the latter adds a group of elements.

Syntax:

a_list.insert(i, x)

Example:

Code	Output
a_list = ['a', 'b', 'c'] a_list.insert(1, 'x') print a_list a_list.insert(0, 'y') print a_list a_list.insert(5, 'z') print a_list	['a', 'x', 'b', 'c'] ['y', 'a', 'x', 'b', 'c'] ['y', 'a', 'x', 'b', 'c', 'z']

Inserts an item at a given position. The first argument is the index of the element before which to insert, so a.insert(0, x) inserts at the front of the list, and a.insert(len(a), x) is equivalent to a.append(x).

Syntax:

a_list.remove(x)

Example:

Code	Output
a_list = ['a', 'b', 'c', 'b'] a_list.remove('b') print a_list	['a', 'c', 'b']

Removes the first item from the list whose value is x. It is an error if there is no such item.

Syntax:

a_list.pop([index])

Example:

Code	Output
a_list = ['a', 'b', 'c'] print a_list.pop(1) print a_list	b ['a', 'c']

Removes the item at the given index in the list a_list, and returns it. If no index is specified, it defaults to the last item.

Syntax:

a_list.reverse()

Example:

Code	Output
a_list = [1, 2, 3] a_list.reverse() print a_list	[3, 2, 1]

Reverses the elements of the list a_list in place.

Syntax:

a_list.sort()

a_list.sort(reverse=rev_bool, key=key_fn)

Examples:

Code	Output
a_list = [2, 1, 3, 2] a_list.sort() print a_list	[1, 2, 2, 3]
a_list = [2, 1, 3, 2] a_list.sort(reverse=True) print a_list	[3, 2, 2, 1]

See also:

sorted() — Sort an iterable

Sorts the items of the list a_list in ascending order in place. I.e., it mutates a_list. It returns None.

By default or when rev_bool is False, the elements are in ascending order. When rev_bool is True, the elements are in descending order. (Bug: It reverses when rev_bool is False, too.) If the elements are of different types, then the ascending or descending ordering is based upon their hash values.

Need to explain and provide examples for key argument.

The sort is guaranteed to be stable. Thus, when multiple elements have the same key, their original order is preserved.

Syntax:

(val0, val1, …)

Examples:

Code	Output
print ()	()
print (1,)	(1,)
t = 1, print t	(1,)
print (1, 2, 3, 8, 9)	(1, 2, 3, 8, 9)
t = 1, 2, 3, 8, 9 print t	(1, 2, 3, 8, 9)
print ((1, 2), 'hello', 3, ['a', 'b', 'c'])	((1, 2), 'hello', 3, ['a', 'b', 'c'])
t = 1, 2, 3 print t	(1, 2, 3)

Tuples are constructed by the comma operator, with or without enclosing parentheses. An empty tuple must have the enclosing parentheses. A single item tuple must have a trailing comma.

Syntax:

tuple()

tuple(an_iter)

Examples:

Code	Output
print tuple()	()
print tuple('abc')	('a' ,'b', 'c')
print tuple([1, 2, 3, 4, 5])	(1, 2, 3, 4, 5)
print tuple((1, 2, 3, 4, 5))	(1, 2, 3, 4, 5)
print tuple(set([1, 2, 3, 4]))	(1, 2, 3, 4)
print tuple({1: 2, 3: 4})	(1, 3)
print tuple(enumerate(['a', 'b', 'c', 'd']))	((0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'))

Converts any iterable into a tuple. If the argument is already a tuple, it returns a copy, i.e., a new tuple with the same elements.

• coerce()

Syntax:

{key0: value0, key1: value1, … }

Examples:

Code	Output
print {}	{}
print {1: 'a', 2: 'b', 9: 'c'}	{1: 'a', 2: 'b', 9: 'c'}
print {1: 'a', (5, 'item'): [100], 'key': {True: 'hello', -9: 0}}	{1: 'a', (5, 'item'): [100], 'key': {True: 'hello', -9: 0}}

A dictionary is an unordered collection of key: value pairs, with each key in a dictionary being distinct.

Syntax:

dict()

dict(an_iter)

Examples:

Code	Output
print dict()	{}
print dict([(1, 'a'), (2, 'b'), (3, 'c')])	{1: 'a', 2: 'b', 3: 'c'}
print dict(((1, 'a'), (2, 'b'), (3, 'c'), (3, 'd')))	{1: 'a', 2: 'b', 3: 'd'}
print dict(set([(1, 'a'), (2, 'b'), (3, 'c')]))	{1: 'a', 2: 'b', 3: 'c'}
print dict({1: 'a', 2: 'b', 3: 'c'})	{1: 'a', 2: 'b', 3: 'c'}
print dict(enumerate(['a', 'b', 'c', 'd']))	{0: 'a', 1: 'b', 2: 'c', 3: 'd'}

Returns a new dictionary with the data from an_iter. The iterable or iterator an_iter must consist of pairs of a valid key (i.e., of immutable type) and value. If any key occurs multiple times, then the last value encountered for that key will be in the resulting dictionary. If an_iter is already a dictionary, it returns a copy, i.e., a new dictionary with the same elements.

Syntax:

a_dict[key]

a_dict.get(key)

a_dict.get(key, default)

Examples:

Code	Output
print {1: 'a', 2: 'b', 3: 'c'}[2]	b
print {1: 'a', 2: 'b', 3: 'c'}.get(2)	b
print {1: 'a', 2: 'b', 3: 'c'}.get(7)	None
print {1: 'a', 2: 'b', 3: 'c'}.get(7, 'not here')	not here

Returns the value associated with the given key the dictionary a_dict.

If the key is not in the dictionary, a_dict[key] raises a KeyError error. However, a_dict.get(key) returns the default value default if provided, and None otherwise.

Syntax:

a_dict[key] = value

Example:

Code	Output
d = {1: 'a', 2: 'b', 3: 'c'} d[2] = 'd' print d d[5] = 'e' print d	{1: 'a', 2: 'd', 3: 'c'} {1: 'a', 2: 'd', 3: 'c', 5: 'e'}

Mutates the dictionary a_dict so that the given key now maps to the given value.

Syntax:

a_dict.has_key(key)

Examples:

Code	Output
print {1: 'a', 2: 'b', 3: 'c'}.has_key(2)	True
print {1: 'a', 2: 'b', 3: 'c'}.has_key(4)	False

Returns whether the given key is a key in the dictionary a_dict. The equivalent key in a_dict is considered better style.

Syntax:

a_dict.pop(key)

a_dict.pop(key, default)

Examples:

Code	Output
d = {1: 'a', 2: 'b', 3: 'c'} print d.pop(1) print d	a {2: 'b', 3: 'c'}
d = {1: 'a', 2: 'b', 3: 'c'} print d.pop(1, 'xyz') print d	a {2: 'b', 3: 'c'}
d = {1: 'a', 2: 'b', 3: 'c'} print d.pop(4) print d	Line 2: KeyError: 4
d = {1: 'a', 2: 'b', 3: 'c'} print d.pop(4, 'xyz') print d	xyz {1: 'a', 2: 'b', 3: 'c'}

If key is a key in the dictionary, this removes it from the dictionary and returns its value. The value default is ignored in this case.

If key is not a key in the dictionary, this returns the value default. If no default is provided, a KeyError is raised.

Syntax:

a_dict.items()

Examples:

Code	Output
print {1: 'a', 2: 'b', 3: 'c'}.items()	[(1, 'a'), (2, 'b'), (3, 'c')]
sample_dict = {1: 'a', 2: 'b', 3: 'c'} for key, value in sample_dict.items(): print key, 'maps to', value	1 maps to a 2 maps to b 3 maps to c

Returns a list of (key, value) pairs, for all the keys in dictionary a_dict.

A common usage is to loop over all key/value pairs in a dictionary, as in the last example above.

Syntax:

a_dict.keys()

Example:

Code	Output
print {1: 'a', 2: 'b', 3: 'c'}.keys()	[1, 2, 3]

Returns a list of the keys in dictionary a_dict.

While you can test if something is a dictionary key explicitly, like key in a_dict.keys(), the simpler expression key in a_dict is equivalent. The same applies to for-loops.

Syntax:

a_dict.values()

Examples:

Code	Output
print {1: 'a', 2: 'b', 3: 'c'}.values()	['a', 'b', 'c']
sample_dict = {1: 'a', 2: 'b', 3: 'c'} for value in sample_dict.values(): print value, 'is a value in the dictionary'	a is a value in the dictionary b is a value in the dictionary c is a value in the dictionary

Returns a list of the values in dictionary a_dict.

A common usage is to loop over all values in a dictionary, as in the last example above.

• dict() with keyword arguments
• a_dict.clear()
• a_dict.copy()
• a_dict.iteritems()
• a_dict.iterkeys()
• a_dict.itervalues()
• a_dict.popitem()
• a_dict.setdefault()
• a_dict.update()

Syntax:

set()

set(an_iter)

Examples:

Code	Output
print set()	set([])
print set('abc')	set(['a' ,'b', 'c'])
print set([1, 2, 3, 4, 5, 3, 5])	set([1, 2, 3, 4, 5])
print set((1, 2, 3, 4, 5))	set([1, 2, 3, 4, 5])
print set(set([1, 2, 3, 4]))	set([1, 2, 3, 4])
print set({1: 2, 3: 4})	set([1, 3])
print set(enumerate(['a', 'b', 'c', 'd']))	set([(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')])

Returns a new set with the values from iterable or iterator an_iter. If the argument is already a set, it returns a copy, i.e., a new set with the same elements.

Syntax:

a_set.union(an_iter)

Example:

Code	Output
print set([1, 2, 3, 4, 5]).union(set([5, 6, 7]))	set([1, 2, 3, 4, 5, 6, 7])

Returns the union of set a_set and the set of elements in iterable an_iter.

Syntax:

a_set.intersection(an_iter)

Example:

Code	Output
print set([1, 2, 3, 4, 5]).intersection(set([5, 6, 7]))	set([5])

Returns the intersection of set a_set and the set of elements in iterable an_iter.

Syntax:

a_set.difference(an_iter)

Example:

Code	Output
print set([1, 2, 3, 4, 5]).difference(set([5, 6, 7]))	set([1, 2, 3, 4])

Returns a set with all elements from set a_set that are not in iterable an_iter.

Syntax:

a_set.symmetric_difference(anInter)

Example:

Code	Output
print set([1, 2, 3, 4, 5]).symmetric_difference(set([5, 6, 7]))	set([1, 2, 3, 4, 6, 7])

Returns a set with all elements that are in exactly one of set a_set and iterable an_iter.

Syntax:

a_set.update(an_iter)

Example:

Code	Output
s = set([1, 2, 3, 4, 5]) s.update(set([5, 6, 7])) print s	set([1, 2, 3, 4, 5, 6, 7])

Mutates a_set to be the union of set a_set and the set of elements in iterable an_iter. Returns None.

Syntax:

a_set.intersection_update(an_iter)

Example:

Code	Output
s = set([1, 2, 3, 4, 5]) s.intersection_update(set([5, 6, 7])) print s	set([5])

Mutates a_set to be the intersection of set a_set and the set of elements in iterable an_iter. Returns None.

Syntax:

a_set.difference_update(an_iter)

Example:

Code	Output
s = set([1, 2, 3, 4, 5]) s.difference_update(set([5, 6, 7])) print s	set([1, 2, 3, 4])

Mutates a_set to be the set difference of set a_set and the set of elements in iterable an_iter. Returns None.

Syntax:

a_set.symmetric_difference_update(an_iter)

Example:

Code	Output
s = set([1, 2, 3, 4, 5]) s.symmetric_difference_update(set([5, 6, 7])) print s	set([1, 2, 3, 4, 6, 7])

Mutates a_set to be a set with all elements that are in exactly one of set a_set and iterable an_iter. Returns None.

Syntax:

a_set.add(x)

Example:

Code	Output
s = set([1, 2, 3, 4, 5]) s.add(5) print s s.add(6) print s	set([1, 2, 3, 4, 5]) set([1, 2, 3, 4, 5, 6])

Adds element x to the set a_set. Returns None.

Syntax:

a_set.remove(x)

a_set.discard(x)

Example:

Code	Output
s = set([1, 2, 3, 4, 5]) s.remove(5) print s s.discard(7) print s s.discard(3) print s	set([1, 2, 3, 4]) set([1, 2, 3, 4]) set([1, 2, 4])

Removes element x from set a_set. If element x is not in a_set, a_set.remove raises an error, while a_set.discard does not. Returns None.

Syntax:

a_set.pop()

Example:

Code	Output
s = set([1, 2, 3, 4, 5]) print s.pop() print s	1 set([2, 3, 4, 5])

Removes and returns an arbitrary element from set a_set. Raises an error if there are no elements to remove.

Syntax:

a_set.issubset(an_iter)

Examples:

Code	Output
s = set([2, 9, 7, 1] print s.issubset(s)	True
print set([2, 9, 7, 1]).issubset(set([1, 7]))	False
print set([2, 9, 7, 1]).issubset(set([1, 2, 3, 4]))	False
print set([2, 9, 7, 1]).issubset(set([1, 2, 3, 4, 5, 6, 7, 8, 9]))	True
print set([2, 9, 7, 1]).issubset([1, 2, 7, 9]	True

Returns whether the set a_set is a subset of the set of elements in iterable an_iter.

Syntax:

a_set.issuperset(an_iter)

Examples:

Code	Output
s = set([2, 9, 7, 1] print s.issuperset(s)	True
print set([2, 9, 7, 1]).issuperset(set([1, 7]))	True
print set([2, 9, 7, 1]).issuperset(set([1, 2, 3, 4]))	False
print set([2, 9, 7, 1]).issuperset(set([1, 2, 3, 4, 5, 6, 7, 8, 9]))	False
print set([2, 9, 7, 1]).issuperset([1, 2, 7, 9]	True

Returns whether the set a_set is a superset of the set of elements in iterable an_iter.

Syntax:

a_set.copy()

Example:

Code	Output
s = set([1, 2, 3, 4, 5]) t = s.copy() print s == t print s is t	True False

Makes a new set with the same elements as a_set.

• |
• &
• -
• ^
• |=
• &=
• -=
• ^=
• s.clear()

Syntax:

def a_func(var0, var1, …): …

Examples:

Code	Output
def is_even(n): '''Returns a Boolean indicating whether n is even.''' return n % 2 == 0 print is_even print is_even(2)	<function is_even> True
def median_3(a, b, c): '''Returns the median (middle) of the three arguments.''' if a <= b: if b <= c: return b elif a <= c: return c else: return a else: if a < c: return a elif b < c: return c else: return b print median_3(5, 9, 2)	5
def swap_list_elts(l, index1, index2): '''Swaps l[index1] and l[index2]''' l[index1], l[index2] = l[index2], l[index1] l = ['a', 'b', 'c', 'd'] print swap_list_elts(l, 1, 3) print l	None ['a', 'd', 'c', 'b']
def add2(n): '''Returns the given value plus 2.''' return n + 2 print map(add2, [1, 3, 5])	[3, 5, 7]

Tutorial:

• Defining Functions

Creates a function named by a_func. When applied to arguments, the code in the function body is run until a return statement is reached or the end of the code is reached. In the former case, the function returns the value specified in the return, while in the latter case, the function returns None.

To be distinct from a generator function, the body must not contain yield statements.

For good style, each named function should also have a documentation string (docstring) immediately after its header, as illustrated in the examples.

Syntax:

lambda var1, var2, …: expr

Examples:

Code	Output
is_even = lambda n : n % 2 == 0 print is_even print is_even(2)	<function <lambda>> True
print map(lambda n: n + 2, [1, 3, 5])	[3, 5, 7]

Tutorial:

• Lambda Forms

Anonymous functions are simplified forms of function definitions. First, they do not have a name. Second, the parameter list is not in parentheses. And third, the function body is just a single expression, which is implicitly returned. This simplicity is convenient especially when the function is simply passed as an argument, as in the last example above.

• Built-in functions and methods are not values.
• Keyword arguments are not supported.
• classmethod()
• staticmethod()
• a_func.func_doc
• a_func.__doc__
• a_func.func_name
• a_func.__name__
• a_func.__module__
• a_func.func_defaults
• a_func.func_code
• a_func.func_globals
• a_func.func_dict
• a_func.func_closure

def squares(n):
    '''Yields the squares from 0 to n-1 squared.'''

    for i in range(n):
        yield i * i

g = squares(4)
print g.next()
print g.next()
print g.next()
print g.next()

0
1
4
9

Creates a generator function named by an_iter. When applied to arguments, the code in the function body is encapsulated and returned as a generator, a type of iterator. Each time the next(), method is applied to the resulting generator, the code is run until the next yield expression, and the yield expression's value is returned from that method call. Thus, the creation of the generator does not wait for all of its elements to be generator, and the generator could even represent an infinite number of elements.

To be distinct from a function definition, the body must contain yield statements, not return statements.

For good style, each generator function should also have a documentation string (docstring) immediately after its header, as illustrated in the example.

Syntax:

a_gen.send(val)

Examples:

Code	Output
def foo(): x = yield 1 print 'Yielded:', x yield 2 bar = foo() print bar.next() print bar.send('Hi!')	1 Yielded: Hi! 2
def add1genf(n): while n != None: print 'Before:', n n = yield n + 1 print 'After:', n add1gen = add1genf(10) print '---' print add1gen.send('This first value is ignored.') print '---' print add1gen.send(3) print '---' print add1gen.send(17)	--- Before: 10 11 --- After: 3 Before: 3 4 --- After: 17 Before: 17 18

Like the next() method, it runs the generator code from where it started (on the first call) or last yielded, stopping at the next yield expression. It returns the value of the yield expression. It also sends the value val back to the generator's yield expression.

• a_gen.throw()
• a_gen.close()

Syntax:

a_file.read()

a_file.read(size)

Examples:

Code	Output
import urllib2 import codeskulptor a_file = urllib2.urlopen(codeskulptor.file2url('assets_sample_text.txt')) print a_file.read()	This is line one. This is line two. This is line three.
import urllib2 import codeskulptor a_file = urllib2.urlopen(codeskulptor.file2url('assets_sample_text.txt')) print a_file.read(7)	This is

See also:

a_file.readline() — Reads one line

a_file.readlines() — Reads multiple lines

With no argument or a negative size argument, this returns a string containing the rest of the file.

With a non-negative size argument, this returns a string containing the next at-most size bytes (characters) of the file. It returns fewer bytes than requested only when there are fewer bytes remaining in the file.

Syntax:

a_file.readline()

a_file.readline(size)

Examples:

Code	Output
import urllib2 import codeskulptor a_file = urllib2.urlopen(codeskulptor.file2url('assets_sample_text.txt')) print a_file.readline()	This is line one.
import urllib2 import codeskulptor a_file = urllib2.urlopen(codeskulptor.file2url('assets_sample_text.txt')) print a_file.read(7) print a_file.readline()	This is line one.

See also:

a_file.read() — Reads

a_file.readlines() — Reads multiple lines

With no argument or a negative size argument, this returns a string containing the rest of the current line in the file. I.e., it returns all the characters up to and including the next newline character '\n' or end of file.

With a non-negative size argument, this returns a string containing the next at-most size bytes (characters) of the file. It returns fewer bytes than requested only when there are fewer bytes remaining in the file.

Syntax:

a_file.readlines()

a_file.readlines(sizehint)

Examples:

Code	Output
import urllib2 import codeskulptor a_file = urllib2.urlopen(codeskulptor.file2url('assets_sample_text.txt')) print a_file.readlines()	['This is line one.\n', 'This is line two.\n', 'This is line three.\n']
import urllib2 import codeskulptor a_file = urllib2.urlopen(codeskulptor.file2url('assets_sample_text.txt')) print a_file.readline() print a_file.readlines()	This is line one. ['This is line two.\n', 'This is line three.\n']

See also:

a_file.read() — Reads

a_file.readline() — Reads one line

Reads the rest of the file, separating its content into a sequence of lines ending in the newline character '\n'. This sequence is returned as a list of strings.

The number sizehint is an estimate of how many bytes remain in the file. Its value does not affect the result.

• list() on file objects
• a_file.close()
• a_file.fileno()
• a_file.flush()
• a_file.isatty()
• a_file.seek()
• a_file.tell()
• a_file.truncate()
• a_file.write()
• a_file.writelines()
• a_file.xreadlines()
• a_file.closed
• a_file.encoding
• a_file.errors
• a_file.mode
• a_file.name
• a_file.newlines
• a_file.softspace

Syntax:

enumerate(an_iter)

enumerate(an_iter, start)

Examples:

Code	Output
print enumerate(['a', 'b', 'c', 'd'])	<enumerate object>
print list(enumerate(['a', 'b', 'c', 'd']))	[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
print list(enumerate(['a', 'b', 'c', 'd'], 5))	[(5, 'a'), (6, 'b'), (7, 'c'), (8, 'd')]

Returns an enumeration object, a type of iterator. Each element of the iterator is a pair of a number and an element from the given iterable or iterator an_iter. The first number is start (or the default zero), and successive numbers are each one greater than the previous.

Syntax:

an_iter.next()

Examples:

Code	Output
i = enumerate(['a', 'b', 'c']) print i.next() print i.next() print i.next()	(0, 'a') (1, 'b') (2, 'c')
def foo(): x = yield 1 print 'Yielded:', x yield 2 bar = foo() print bar.next() print bar.next()	1 Yielded: None 2

Returns the next element of the iterator and removes it from the iterator.

For a generator, it's behavior can be described in more detail. It runs the generator code from where it started (on the first call) or last yielded, stopping at the next yield expression. It returns the value of the yield expression. It also sends the value None back to the generator's yield expression.

• an_iter.next() incorrectly does not raise an error if the iterator is empty.
• an_iter.__iter__()
• iter()
• next()

Syntax:

seq1 + seq2

Examples:

Code	Output
print 'hello' + ' ' + 'world!'	hello world!
print [1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]
print ('a', 'b', 'c') + (1, 2) + ([2, 3, 4], [1])	('a', 'b', 'c', 1, 2, [2, 3, 4], [1])

Returns the concatenation of seq1 and seq2. I.e., it returns a new sequence that contains the contents of the first sequence, then the contents of the second sequence. The two sequences must be of the same type, and the result is of the same type.

Syntax:

a_seq * n

n * a_seq

Examples:

Code	Output
print 'hello' * 2	hellohello
print ['a', 'b', 'c'] * 3	['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
print (1, 2, 3, 4) * 4	(1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4)
x = [[1, 2]] * 3 print x x[0][0] = 3 print x	[[1, 2], [1, 2], [1, 2]] [[3, 2], [3, 2], [3, 2]]

Returns the concatenation of n copies of a_seq. The copies are “shallow” in that if the sequence contains compound objects, the contents of those objects are not copied. In the last example above, each of the sub-lists [1, 2] is the same list; they are not just lists that look alike.

Syntax:

a_seq[i]

a_seq.__getitem__(i)

Examples:

Code	Output
print 'abcde'[2]	c
print (8, 2, 4, 0)[3]	0
print [8, 2, 4, 0][-3]	2

Returns the item in sequence a_seq at integer index i. Given a non-negative index, it starts counting from index 0 on the left. Given a negative index, it starts counting from index -1 on the right.

Syntax:

a_seq[i:j]

a_seq[i:j:k]

Examples:

Code	Output
print 'abcde'[1:3]	bc
print (8, 2, 4, 0)[1:-1]	(2, 4)
print [8, 2, 4, 0][1:]	[2, 4, 0]
print 'abcde'[1:4:2]	bd
print (8, 2, 4, 0)[1::1]	(2, 4, 0)
print [8, 2, 4, 0][::-1]	[0, 4, 2, 8]

Returns a new sequence (a “slice”) of the items in the sequence a_seq starting from integer index i up to integer index j-1, incrementing indices by integer k.

Omitting index i starts the sequence at the leftmost position. Omitting index j ends the sequence at the rightmost position. The step k defaults to 1, i.e., including each element in the indexed range from left to right.

The new sequence is of the same type as a_seq.

Syntax:

a_seq.index(val)

a_seq.index(val, start)

a_seq.index(val, start, end)

Examples:

Code	Output
print ['a', 'b', 'c', 'b', 'a', 'c'].index('c')	2
print ('a', 'b', 'c', 'b', 'a', 'c').index('c')	2
print 'abcbac'.index('c')	2
print 'abcbac'.index('ba')	3
print ['a', 'b', 'c', 'b', 'a', 'c'].index('c', 3)	5
print ('a', 'b', 'c', 'b', 'a', 'c').index('c', 3)	5
print 'abcbac'.index('c', 3)	5

See also:

a_str.find(), etc. — Similar methods

Returns the index in the sequence a_seq[start:end] of the first item whose value is val. If a_seq is a string, then val can be a string of any length, not just a single character. By default, start is 0, and end is the length of the string. It is an error if there is no such item.

A common mistake is to use it to find the next item:

for item in my_list:
   next_item = my_list[my_list.index(item) + 1]
   print item, next_item

Syntax:

a_seq.count(val)

a_str.count(val, start)

a_str.count(val, start, end)

Examples:

Code	Output
print ['a', 'b', 'c', 'b', 'a', 'c'].count('b')	2
print ('a', 'b', 'c', 'b', 'a', 'c').count('b')	2
print 'abcbac'.count('c')	2
print 'abcbac'.count('cb')	1
print 'abcbac'.count('b', 3)	1
print 'abcbac'.count('b', 2, 3)	0

Returns the number of times the value val appears in the sequence a_seq.

For strings only, there are two differences in the method. Additional arguments limit the part of the string to search. Also, val can be a string of any length, not just a single character. Thus, it returns the number of times val is a substring in a_str[start:end]. By default, start is 0, and end is the length of the string.

Syntax:

val in an_iter

Examples:

Code	Output
print 8 in [1, 2, 3, 4, 5, 6, 7]	False
print 'c' in 'abcde'	True
print (1,3) in ('a', 3, 4, (1,2), 'hello')	False
print 3 in {1: 'a', 2: 'b', 3: 'c'}	True
print 3 in {'a': 1, 'b': 2, 'c: 3}	False
print 8 in set([1, 2, 3, 4, 5, 6, 7])	False

Returns True if value val is in the iterable, otherwise returns False.

Syntax:

val not in an_iter

Examples:

Code	Output
print 8 not in [1, 2, 3, 4, 5, 6, 7]	True
print 'c' not in 'abcde'	False
print (1,3) not in ('a', 3, 4, (1, 2), 'hello')	True
print 3 not in {1: 'a', 2: 'b', 3: 'c'}	False
print 3 not in {'a': 1, 'b': 2, 'c': 3}	True
print 8 not in set([1, 2, 3, 4, 5, 6, 7])	True

Returns True if value val is not in the iterable, otherwise returns False.

Syntax:

len(an_iter)

Examples:

Code	Output
print len('')	0
print len([2, 35, -2, 12])	4
print len((2, 35, -2, 12))	4
print len({1: 2, 3: 4})	2
print len(set([2, 35, -2, 12]))	4

Returns the number of items in the iterable.

Syntax:

sum(an_iter)

sum(an_iter, start)

Examples:

Code	Output
print sum([10, 20, 30])	60
print sum((10, 20, 30))	60
print sum({1: 10, 2: 20})	3
print sum(set([10, 20, 30)]))	60
print sum([10, 20, 30], 2)	62

Returns the sum of start, which defaults to 0, and the numbers in the iterable.

Syntax:

max(val1, val2, …)

max(an_iter)

Examples:

Code	Output
print max(2, 35, -2, 12)	35
print max('c', 'x', 'cat', 'father')	x
print max([2, 35, -2, 12])	35
print max(['c', 'x', 'cat', 'father'])	x
print max((2, 35, -2, 12))	35
print max({1: 2, 3: 4})	3
print max(set([2, 35, -2, 12]))	35

Given multiple arguments, it returns the argument with the maximum value. Given a single iterable argument (other than a string), it returns the item in the iterable with maximum value.

Syntax:

min(val1, val2, …)

min(an_iter)

Examples:

Code	Output
print min(2, 35, -2, 12)	-2
print min('c', 'x', 'cat', 'father')	c
print min([2, 35, -2, 12])	-2
print min(['c', 'x', 'cat', 'father'])	c
print min((2, 35, -2, 12))	-2
print min({1: 2, 3: 4})	1
print min(set([2, 35, -2, 12]))	-2

Given multiple arguments, it returns the argument with the minimum value. Given a single iterable argument (other than a string), it returns the item in the iterable with minimum value.

Syntax:

zip(iter1, iter2, …)

Examples:

Code	Output
print zip('abcd', '1234', (5, 6, 7, 8))	[('a', '1', 5), ('b', '2', 6), ('c', '3', 7), ('d', '4', 8)]
print zip([1, 2, 3, 4], ['a', 'b', 'c'])	[(1, 'a'), (2, 'b'), (3, 'c')]
print zip({1: 2, 3: 4}, set([5, 6]))	[(1, 5), (3, 6)]
print zip([1, 2, 3])	[(1,), (2,), (3,)]
print zip()	[]
list1 = ['a', 'b', 'c', 'd', 'e'] list2 = ['z', 'y', 'x', 'w', 'v'] for letter1, letter2 in zip(list1, list2): print letter1 + letter2	az by cx dw ev
zipped_list = [(1, 'a'), (2, 'b'), (3, 'c')] first_elts, second_elts = zip(*zipped_list) print first_elts print second_elts	[1, 2, 3] ['a', 'b', 'c']

Returns a list of tuples, where the i^th tuple contains the i^th element of each iterable. For intuition, picture the action of matching up the two sides of a standard zipper. The result's length is that of the shortest argument. With a single sequence argument, it returns a list of 1-tuples. With no arguments, it returns an empty list.

A common usage of zip() is to iterate over two same-length lists (or other iterables) in lock-step, as shown in the next-to-last example above.

Unzipping: There is no built-in function to do the opposite of zip(). However, one approach is to use function argument unpacking along with zip() to group the desired elements, as shown in the last example above.

Syntax:

sorted(an_iter)

sorted(an_iter, reverse=rev_bool, key=key_fn)

Examples:

Code	Output
print sorted('blue')	['b', 'e', 'l', 'u']
print sorted([2, 1, 3, 2])	[1, 2, 2, 3]
print sorted([2, 1, 3, 2], reverse=True)	[3, 2, 2, 1]

See also:

a_list.sort() — Sort a list in-place

Returns a list of the elements of the iterable in sorted order.

By default or when rev_bool is False, the elements are in ascending order. When rev_bool is True, the elements are in descending order. (Bug: It reverses when rev_bool is False, too.) If the elements are of different types, then the ascending or descending ordering is based upon their hash values.

Need to explain and provide examples for key argument.

The sort is guaranteed to be stable. Thus, when multiple elements have the same key, their original order is preserved.

Syntax:

map(function, an_iter)

Example:

Code	Output
def square(n): return n * n print map(square, [3, 7, 1])	[9, 49, 1]

Applies the user-defined function to the elements of the iterable an_iter, and returns a list of the results. The ith element of the returned list is function(an_iteriter1[i], &hellip).

Syntax:

filter(function, an_iter)

Examples:

Code	Output
def is_positive(n): return n > 0 print filter(is_positive, [3, -7, 1])	[3, 1]
def is_positive(n): return n > 0 print filter(is_positive, (3, -7, 1))	(3, 1)
def is_aorb(x): return x == 'a' or x == 'b' print filter(is_aorb, 'acdba')	'aba'
def is_positive(n): return n > 0 print filter(is_positive, set([3, -7, 1]))	[1, 3]
print filter(None, [set(), 3, {}, 0, False, '', -1, []])	[3, -1]

Applies the user-defined function to the elements of the iterable an_iter, and returns a sequence of those elements for which the function returns a true-like value. If the function is None, then the function is taken to be the identity function — i.e., it returns a sequence of those elements which are true-like values.

If the iterable an_iter is a sequence, then the returned value is of that same type, otherwise the returned value is a list.

Syntax:

reduce(function, an_iter)

reduce(function, an_iter, initializer)

Examples:

Code	Output
def add(x, y): return x + y print reduce(add, [3, -7, 1])	-3
def add(x, y): return x + y print reduce(add, (3, -7, 1), 12)	9
def maximum(x, y): if x >= y: return x else: return y print reduce(maximum, 'acdba', 'a')	'd'
def maximum(x, y): if x >= y: return x else: return y print reduce(maximum, 'acdba', 'z')	'z'
def second(x, y): return y print reduce(second, [1, 2, 3, 4, 5])	5

Combines the elements of the iterable an_iter by repeatedly applying the two-argument function to an accumulator and each respective element in turn. Without an initializer, if the iterable has no elements, then an error is raise, and if the iterable has one element, that element is returned. With an initializer, if the iterable has no elements, the initializer is returned.

Without an initializer, this is equivalent to

def reduce(function, an_iter):
    started = False
    result = False

    if not an_iter:
        raise TypeError('reduce() of empty sequence with no initial value')

    for element in an_iter:
        if not started:
            result = element
            started = True
        else:
            result = function(result, element)

With an initializer, this is equivalent to

def reduce(function, an_iter, initializer):
    result = initializer

    for element in an_iter:
        result = function(result, element)

• max() and min() with key argument.
• map(), filter(), and reduce() on built-in functions.
• __iter__()
• iter()

Syntax:

x < y

x <= y

x > y

x >= y

x == y

x != y

x is y

x is not y

Examples:

Code	Output
print 2 < 3	True
print False < True	True
print 2 < 2	False
print 'abc' <= 'ad'	True
print 2 <= 2	True
print [1, 3] > [1, 2, 3]	True
print 3 > 2	True
print set([1, 3, 4]) > set([3, 4])	True
print 'xyz' >= 'abc'	True
print 2 == 2	True
print set([1, 5, 10]) == set([10, 1, 5])	True
print 2 != 3	True
s = set([1, 5, 10]) print s is s	True
print set([1, 5, 10]) is not set([10, 1, 5])	True

Examples:

• Comparisons
• Comparison Expressions

• x < y : Is x less than y?
• x <= y : Is x less than or equal to y?
• x > y : Is x greater than y?
• x >= y : Is x greater than or equal to y?
• x == y : Is x equal to y?
• x != y : Is x not equal to y? (The != operator is meant to evoke the traditional ≠ symbol.)
• x is y : Is x is the same value as y?
• x is not y : Is x is not the same value as y?

The interpretation of the ordering operators, i.e., <, <=, >, >=, depends upon the type of the arguments. In general, you should only compare values of the same type. Comparing values of different type leads to some consistent ordering, but not necessarily the same ordering as in another implementation.

Numbers (both integers and floating-point) use their standard order. Booleans use the order than False is less than True. Strings can be thought of as using alphabetic order, although that doesn't capture the whole truth. More accurately, strings use lexicographic order with the ASCII character values. Lists use lexicographic order. Sets use subset. Dictionaries cannot be compared by these operators.

The operator is tests whether the two values are the same object, whereas == tests whether they just look alike. For mutable types, if x is y, then mutating x also mutates y.

Syntax:

type(x)

Examples:

Code	Output
print type(3)	<type 'int'>
print type(3.2)	<type 'float'>
print type('Hello')	<type 'str'>
print type(True)	<type 'Bool'>
print type(None)	<type 'NoneType'>
print type([1, 2, 3])	<type 'list'>
print type({1: 2})	<type 'dict'>
print type(set([1, 2, 3]))	<type 'set'>
def f(): return 3 print type(f)	<type 'function'>
print type(int)	<type 'type'>

All values have a type, and this returns the type of the given value. The type is itself a value.

Syntax:

isinstance(x, y)

Examples:

Code	Output
print isinstance(3, type(3))	True
print isinstance(3.1, type(3.1))	True
print isinstance('foo', type('foo'))	True
print isinstance([], type([1, 2, 3]))	True
print isinstance({1: 2}, type({3: 4}))	True
print isinstance(set([1, 4]), type(set[]))	True
print isinstance(3, int)	True
print isinstance(3.1, float)	True
print isinstance('foo', str)	True
print isinstance([], list)	True
print isinstance({1: 2}, dict)	True
print isinstance(set([1, 4]), set)	True
def f(): return 3 def g(x): return x print isinstance(f, type(g))	True

If the second argument is a type, for example, as returned by type(), it returns whether the first argument is of that type. If the second argument is a type constructor, it returns whether the first argument is of the type that results from that type constructor.

Syntax:

dir(x)

Example:

Code	Output
print dir({})	['get', 'has_key', 'items', 'keys', 'values']

Returns a list of strings naming the attributes defined on the object x.

Syntax:

hasattr(an_obj, attr_name)

Examples:

Code	Output
print hasattr([], 'count')	True
print hasattr({1: 2}, 'silly')	False

Returns whether the given object an_obj has an attribute named by the string attr_name.

• dir with no argument
• getattr()
• setattr()
• callable()
• object()
• hash()
• id()
• classmethod()
• staticmethod()
• issubclass()
• super()
• property()
• memoryview()
• unicode()

Also, built-in functions and methods aren't considered values and thus don't have a type — thus, type() and isinstance() aren't supported on these.

Syntax:

math.ceil(x)

Examples:

Code	Output
import math print math.ceil(8)	8.0
import math print math.ceil(8.1)	9.0
import math print math.ceil(-8.1)	-8.0

See also:

int() and long() — Round to zero

round() — Rounds to nearest integer

math.trunc() — Rounds to zero

math.floor() — Rounds down

Returns the “ceiling” of x, i.e., the smallest integral value greater than or equal to x. Returns it as a floating-point value.

Syntax:

math.floor(x)

Examples:

Code	Output
import math print math.floor(8)	8.0
import math print math.floor(8.9)	8.0
import math print math.floor(-8.9)	-9.0

See also:

int() and long() — Round to zero

round() — Rounds to nearest integer

math.trunc() — Rounds to zero

math.ceil() — Rounds up

Returns the “floor” of x, i.e., the largest integral value less than or equal to x. Returns it as a floating-point value.