CodeSkulptor3

Examples:

Code	Output
print(12)	12
print(-12.0)	-12
print(0b1001)	9
print(021)	17
print(-021)	-17
print(0x3A8)	936
print(12345678901234567890123456789012345678901234567890)	12345678901234567890123456789012345678901234567890
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.

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)

float(x)

Examples:

Code	Output
print(int())	0
print(int('234'))	234
print(int(1.6))	1
print(int(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() on integers)

math.ceil() — Rounds up

math.floor() — Rounds down

Given a number, int() returns the integer part of it, i.e., they round towards zero. Given a Boolean, they return zero (i.e., 0, or 0.0) for False, and one (i.e., 1, or 1.0) for True. Given a string containing a printed representation of an integer, int() returns 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

Examples:

Code	Output
print(3 + 12)	15
print(3.0 + 12)	15.0
print(3 + 12.0)	15.0

Returns the sum of a and b. The result is an integer if both inputs are; otherwise, it is a floating-point. 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
print(12.0 - 3)	9.0
print(12 - 3.0)	9.0
a = 3 print(-a)	-3

With two arguments, returns the difference of a and b. The result is an integer if both inputs are; otherwise, it is a floating-point. 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

Examples:

Code	Output
print(3 * 12)	36
print(3.0 * 12)	36.0
print(3 * 12.0)	36.0

Returns product of a and b. The result is an integer if both inputs are; otherwise, it is a floating-point. 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.0
print(11 / 3)	3.6666666666666665
print(11 // 3)	3
print(12 / 3.0)	4.0
print(11.0 / 3)	3.6666666666666665
print(11.0 // 3.0)	3.0

Example:

• Division

The standard division operation, /, returns the quotient of a and b. The result is a floating-point number.

The integer division operation, //, returns the floor of the quotient of a and b, i.e., the integer part. The result is an integer if both inputs are; otherwise, it is a floating-point.

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

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

Examples:

Code	Output
print(3 ** 4)	81
print(3.0 ** 4)	81.0
print(3 ** 4.0)	81.0

See also:

pow() — Built-in exponentiation function

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

Returns x to the power of y. The result is an integer if both inputs are; otherwise, it is a floating-point.

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.0, 4))	81.0
print(pow(3, 4.0))	81.0
print(pow(3, 4, 2))	1

See also:

** — Built-in exponentiation operator

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

Given no m, this returns x to the power of y, just like x ** y. Given a integer m, this returns the remainder of integer x to the power of integer y, divided by m. The result is an integer if all inputs are; otherwise, it is a floating-point.

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
print(round(12.5))	13
print(round(-12.5))	-12
print(round(123.4567, 2))	123.46
print(round(123.4567, -2))	100.0

See also:

int() — Round to zero

math.trunc() — Rounds to zero

math.ceil() — Rounds up

math.floor() — Rounds down

With one number argument, it returns 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
• 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

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

Style:

Use only with Boolean expressions.

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

Style:

Use only with Boolean expressions.

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

Style:

Use only with Boolean expressions.

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:

x if b else y

Examples:

Code	Output
print(1 if True else 2)	1
print(1 if False else 2)	2

Style:

Use only for very simple examples. Conditional statements are generally more readable.

If the Boolean condition b is False is true (or true-like), then the result is x. Otherwise, the result is y.

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 string
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 = xprint(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 = xprint(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.format(...)

Documentation:

• New-style String Formatting

Examples:

Code	Output
new_style = 'The best instructors are {0} and {1}.'.format('Scott', 'Joe') print(new_style)	The best instructors are Scott and Joe.
new_style = 'The best instructor is {1}.'.format('Scott', 'Joe') print(new_style)	The best instructor is Joe.

Return a copy of a_str with each instance of the substring "{n}" replaced by the n+1st argument to format. CodeSkulptor also supports old-style string formatting old-style string formatting. See this example for instances of both new-style and old-style string formatting.

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 rightmost 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.

Syntax:

b"…"

b'…'

b"""…"""

b'''…'''

Examples:

Code	Output
print(b"")	b'' # The empty bytes object.
print(b'Hello, world.')	b'Hello, world.'
print(b"Goodbye, cruel world.")	b'Goodbye, cruel world.'
print(b"It's a beautiful day.")	b'It's a beautiful day.'
print(b"""This is a multi-line bytes object.""")	b'This is\na multi-line\nbytes object.'

Bytes constants can be constructed within a matched pair of single or double quotes preceeded by a 'b' character. A bytes object with double quotes can contain single quotes, often used as apostrophes. Similarly, a bytes object with single quotes can contain double quotes.

Using a pair of triple-single or triple-double quotes preceeded by a 'b' character also creates a bytes object, but also allows the bytes object to span over multiple lines.

Bytes objects can contain escape sequences:

Syntax:

bytes(x)

Examples:

Code	Output
print(bytes())	b'' # The empty bytes object
print(bytes("abc", "ascii"))	b'abc'
print(bytes([64, 65, 66]))	b'@AB'
print(bytes(4))	b''

Returns a bytes object that contains the sequence of bytes represented by the input. A string can be converted into bytes, as long as the optional second argument is provided indicating the character encoding of the string ("ascii" or "utf-8"). Regardless of the encoding, however, all characters in the input string must be ASCII characters. A list of numbers (which all must be between 0 and 255) can be used to indicate the exact sequence of bytes. A single number can be used to create a bytes object with the given number of bytes, each with the value 0.

Syntax:

a_bytes.decode(encoding)

a_bytes.decode(encoding, errors)

Examples:

Code	Output
print(b"abc".decode("ascii"))	abc
print(bytes([65, 66, 200]).decode("utf-8", "replace"))	AB�

See also:

a_bytes.hex() — Returns a string with hexidecimal values

Returns a string decoded from the given bytes. Possible encodings to use are "utf-8" and "ascii". The optional second argument indicates how to deal with data in the bytes object that are not valid string characters. Possible values are "string" (the default), meaning invalid characters raise an error, "ignore", meaning invalid characters will be ignored and not appear in the output string, and "replace", meaning invalid characters will be replaced with the Unicode replacement character (U+FFFD).

Syntax:

a_bytes.hex()

Example:

Code	Output
print(b"\xab\xf3\x08".hex())	'abf308'

See also:

a_bytes.decode() — Returns a string with the characters decoded from the given bytes

Return a string containing two hexidecimal digits for each byte.

Syntax:

a_bytes.join([iterable])

Examples:

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

Returns a bytes object which is the concatenation of the bytes objects in the iterable. The bytes object a_bytes is concatenated between the other bytes objects as a separator.

Most commonly used to combine a list of bytes objects into a single bytes object.

Syntax:

a_bytes.capitalize()

Example:

Code	Output
print(b'peAr'.capitalize())	b'Pear'

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

Syntax:

a_bytes.upper()

a_bytes.lower()

Examples:

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

Returns a copy of the bytes object a_bytes with all the cased characters converted to upper- or lowercase, respectively

Syntax:

a_bytes.replace(old, new)

a_bytes.replace(old, new, maxreplace)

Examples:

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

Returns a copy of the bytes object a_bytes 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_bytes.find(sub)

a_bytes.find(sub, start)

a_bytes.find(sub, start, end)

a_bytes.rfind(sub)

a_bytes.rfind(sub, start)

a_bytes.rfind(sub, start, end)

a_bytes.index(sub)

a_bytes.index(sub, start)

a_bytes.index(sub, start, end)

a_bytes.rindex(sub)

a_bytes.rindex(sub, start)

a_bytes.rindex(sub, start, end)

Examples:

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

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

If the bytes aren't found, a_bytes.find() and a_bytes.rfind() each return -1, while a_bytes.index() and a_bytes.rindex() each raise an error.

Syntax:

a_bytes.partition(sep)

a_bytes.rpartition(sep)

Examples:

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

Splits the bytes object a_bytes 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 bytes objects, followed by the bytes object itself.

Syntax:

a_bytes.startswith(prefix)

Examples:

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

See also:

a_bytes.endswith() — Checks suffix

Returns whether the bytes object a_bytes begins with the bytes prefix.

Syntax:

a_bytes.endswith(suffix)

Examples:

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

See also:

a_bytes.startswith() — Checks prefix

Returns whether the bytes object a_bytes ends with the bytes suffix.

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(list(range(5)))	[0, 1, 2, 3, 4]
print(list(range(1, 10)))	[1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(range(-10, 100, 20)))	[-10, 10, 30, 50, 70, 90]
print(list(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 a generator-like object representing progressions. The step cannot be zero, and it defaults to 1. The start defaults to 0. As a list, the full form consists of 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.

Note that range does not return a list in Python 3. To create the corresponding list, one should use an expression of the form list(range(...)). range is often used in for loops, as illustrated in the last example above, and does not need to be converted to a list first in order to do so. 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]
words = 'This is a test string from Andrew.'.split() words.sort(key=str.lower print(words)	['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

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. If the elements are of different types, then the ascending or descending ordering is based upon their hash values.

The key argument to sort is a function that is called on each element before sorting. The result of the key function is used in the sort, but the original values in the list are put into the output.

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

Syntax:

[expr for var1 in for_expr1 …]

[expr for var1 in for_expr1 … if if_expr]

Examples:

Code	Output
print([x*x for x in range(4)])	[0, 1, 4, 9]
print([x+y for x in [1,2,5] for y in [6,2,1] if y!=x])	[7, 3, 8, 3, 11, 7, 6]

See also:

{key_expr: val_expr for … if …} — Dictionary comprehension

{expr for … if …} — Set comprehension

(expr for … if …) — Generator expression

Such a list comprehension iterates over each of for_expr1, …. For each combination of loop variables var1, …, that passes any condition if_expr, the value expr is put in the resulting list.

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, value)

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

Style:

Avoid using a_dict.get(key) without a default.

If the key is in the dictionary, these each return the value associated with the given key the dictionary a_dict.

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

Syntax:

a_dict[key] = value

a_dict.__setitem__(key, value)

a_dict.setdefault(key)

a_dict.setdefault(key, value)

Examples:

Code	Output
d = {1: 'a', 2: 'b', 3: 'c'} d[3] = 'd' d[4] = 'e' print(d)	{1: 'a', 2: 'b', 3: 'd', 4: 'e'}
d = {1: 'a', 2: 'b', 3: 'c'} d.setdefault(3, 'd') d.setdefault(4, 'e') print(d)	{1: 'a', 2: 'b', 3: 'c', 4: 'e'}

Style:

Avoid using a_dict.__setitem__().

a_dict[key] = value and a_dict.__setitem__() each mutate the dictionary a_dict so that the given key now maps to the given value.

a_dict.setdefault(key, value) similarly mutates the dictionary, but only if the key does not exist in the dictionary. The value defaults to None.

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 an iterable 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 an iterable consisting 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 an iterable consisting 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.

Syntax:

a_dict.clear()

Example:

Code	Output
d = {1: 'a', 2: 'b', 3: 'c'} d.clear() print(d)	{}

Mutates a dictionary to be empty. Returns None.

Syntax:

a_dict.update(another_dict)

Example:

Code	Output
d = {1: 'a', 2: 'b', 3: 'c'} d.update({3: 'd', 4: 'e'}) print(d)	{1: 'a', 2: 'b', 3: 'd', 4: 'e'}

Mutates a_dict to have the key/value pairs in another_dict. Returns None.

Syntax:

{key_expr: val_expr for var1 in for_expr1 …}

{key_expr: val_expr for var1 in for_expr1 … if if_expr}

Examples:

Code	Output
print({x: x*x for x in range(4)})	{0: 0, 1: 1, 2: 4, 3: 9}
print({(x,y): x+y for x in [1,2,5] for y in [6,2,1] if y!=x})	{(1, 6): 7, (1, 2): 3, (2, 6): 8, (2, 1): 3, (5, 6): 11, (5, 2): 7, (5, 1): 6}

See also:

[expr for … if …] — List comprehension

{expr for … if …} — Set comprehension

(expr for … if …) — Generator expression

Such a dictionary comprehension iterates over each of for_expr1, …. For each combination of loop variables var1, …, that passes any condition if_expr, the key/value pair key_expr:val_expr is put in the resulting dictionary.

• dict() with keyword arguments
• a_dict.copy()
• a_dict.popitem()

Syntax:

{value0, value1, …}

Examples:

Code	Output
print({1, 2, 3, 4, 5, 3, 5})	set([1, 2, 3, 4, 5])
print({'abc', 'def'})	set(['abc', 'def'])

See also:

set — Old style of set constants

Style:

New style of set constants. Doesn't allow representation of empty set.

Returns a new set with the listed values.

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')])

See also:

Sets-constants — New style of set constants

Style:

Old style of set constants

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 Expressions

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

Syntax:

(expr for var1 in for_expr1 …)

(expr for var1 in for_expr1 … if if_expr)

Examples:

Code	Output
print((x*x for x in range(4)))	<generator object <genexpr>>
print((x*x for x in range(4)).next())	0
print(list(x*x for x in range(4)))	[0, 1, 4, 9]
print(list(x+y for x in [1,2,5] for y in [6,2,1] if y!=x))	[7, 3, 8, 3, 11, 7, 6]

See also:

[expr for … if …] — List comprehension

{key_expr: val_expr for … if …} — Dictionary comprehension

{expr for … if …} — Set comprehension

Such a generator expression iterates over each of for_expr1, …. For each combination of loop variables var1, …, that passes any condition if_expr, the value expr is put in the resulting list.

Syntax:

def a_genfunc(var0, var1, …): … yield … …

Example:

Code	Output
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

See also:

def … return — Function definition

Style:

A generator function should have a documentation string (docstring) immediately after its header, as illustrated in the example.

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.

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 urllib.request import codeskulptor a_file = urllib.request.urlopen(codeskulptor.file2url('assets_sample_text.txt')) print(a_file.read())	b'This is line one.\nThis is line two.\nThis is line three.\n'
import urllib.request import codeskulptor a_file = urllib.request.urlopen(codeskulptor.file2url('assets_sample_text.txt')) print(a_file.read(7))	b'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 bytes object containing the rest of the file.

With a non-negative size argument, this returns a bytes object 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 urllib.request import codeskulptor a_file = urllib.request.urlopen(codeskulptor.file2url('assets_sample_text.txt')) print(a_file.readline())	b'This is line one.\n'
import urllib.request import codeskulptor a_file = urllib.request.urlopen(codeskulptor.file2url('assets_sample_text.txt')) print(a_file.read(7)) print(a_file.readline())	b'This is' b' line one.\n'

See also:

a_file.read() — Reads

a_file.readlines() — Reads multiple lines

With no argument or a negative size argument, this returns a bytes object 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 ' ' or end of file.

With a non-negative size argument, this returns a bytes object 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 urllib.request import codeskulptor a_file = urllib.request.urlopen(codeskulptor.file2url('assets_sample_text.txt')) print(a_file.readlines())	[b'This is line one.\n', b'This is line two.\n', b'This is line three.\n']
import urllib.request import codeskulptor a_file = urllib.request.urlopen(codeskulptor.file2url('assets_sample_text.txt')) print(a_file.readline()) print(a_file.readlines())	b'This is line one.\n' [b'This is line two.\n', b'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 bytes objects.

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:

next(an_iter)

next(an_iter, value)

an_iter.__next__()

Examples:

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

Style:

Avoid using an_iter.__next__().

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

If the iterator has no next element, then an error is raised, except when using next(an_iter, value), in which case the value is returned.

For a generator defined by a generator function, these operations' behavior can be described in more detail. The generator's code runs from where it started (on the first call) or last yielded, stopping at the next yield expression. The generator returns the value of the yield expression. The operation 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()

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

Style:

Avoid using a_seq.__getitem__().

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

See also:

not in — Complement

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

See also:

in — Complement

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