Scripting >> Python >> Cheatsheet >> Python 3 cheatsheet

 Go Top

 Go Top

 Go Top

Go Top

 Go Top

 Go Top

 Go Top

Go Top

Construct an immutable array of bytes from:
- an iterable yielding integers in range(256)
- a text string encoded using the specified encoding
- any object implementing the buffer API.
- an integer

Go Top

The enumerate object yields pairs containing a count (from start, which
 |  defaults to zero) and a value yielded by the iterable argument.

>>> L=[2,4,6,8]
>>> for c in enumerate(L,2):
...    print(c)
...
(2, 2)
(3, 4)
(4, 6)
(5, 8)
>>> for c in enumerate(L):
...    print(c)
...
(0, 2)
(1, 4)
(2, 6)
(3, 8)

Go Top

Evaluate the given source in the context of globals and locals.

The source may be a string representing a Python expression or a code object as returned by compile(). The globals must be a dictionary and locals can be any mapping, defaulting to the current globals and locals. If only globals is given, locals defaults to it

example

>>> x = 1 >>> eval('x+1') 2

Convert a number or string to an integer.
If x is not a number or if base is given, then x must be a string

>>> int('8')
8
>>> int(8.0)
8
>>> int('8')
8
>>> int('1000',2)
8
>>> int('FF',16)
255
 

Go Top

Create a new memoryview object which references the given object

>>> randomByteArray = bytearray('ABC', 'utf-8')
>>> mv=memoryview(randomByteArray)
>>> for m in mv:
...    print(m)
...
65
66
67

Go Top

fget : function to be used for getting an attribute value
fset : function to be used for setting an attribute value
fdel :function to be used for del'ing an attribute
doc : docstring

Go Top

range(stop) -> list of integers
    range(start, stop[, step]) -> list of integers
    
    Return a list containing an arithmetic progression of integers.
    range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
    When step is given, it specifies the increment (or decrement).
 

Return the canonical string representation of the object

Go Top

Return a reverse iterator over the values of the given sequence/

>>> L=[1,2]
>>> for l in L:
...    print(l)
...
1
2
>>> for l in reversed(L):
...    print(l)
...
2
1

Round a number to a given precision in decimal digits

>>> round(8,2)
8
>>> round(8.123,2)
8.12
>>> round(8.123)
8

Build an unordered collection of unique elements

Go Top

def FunctionName([parameter1][, parameter2 ...]):
   statements
   [return result1[,result2] ....]

Starts with def and take note the colon : at the end, optionally ends with return statement

Functions without return statement will have resulting value of None

return leaves the current function call with the expression list (or None) as return value

## Example function with no parameters
def MyFunction1():

## Example function with 1 parameter
def MyFunction1(p1):

## Example function with 1 parameter and 1 return value
def MyFunction2(p1):
   result=p1**2
   return result

## Example function with 1 parameter
## and multiple return values
## multiple values returned as data type Tuple
>>> def ConvertSeconds(totalseconds):
...    minutes = totalseconds//60
...    seconds = totalseconds - minutes*60
...    return minutes, seconds
...
>>> print(ConvertSeconds(130))
(2, 10)
>>> result=ConvertSeconds(130)
>>> print(result)
(2, 10)
>>> print(type(result))
<type 'tuple'>
>>>


## Example to specify specific data types
## for the arguments
>>> def mysum(x: int, y: int):
...     result = x+y
...     return result
...
>>> mysum(1,2)
3

## Example to specify specific data type
## for the function return value
>>> def myfloatsum(x: int, y: int) -> float:
...    result = float(x+y)
...    return(result)
...
>>> myfloatsum(1,2)
3.0



Anonymous inline Functions : Lambda

lambda [parameters]: expression

Example, generate a list of squares of numbers 1-10:

>>> squares = map(lambda x: x**2, range(10))
>>> print(squares)
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Method 1

% formatting operator

>>> print('...%s...' % 'Hello')
...Hello...

>>> var1=20
>>> var2=-10
>>> print("%8.2f\t%8.2f" % (var1,var2))

Go Top

Method 2

string.format() method

Syntax:

   "[string_literals]{replacement_field}[string_literals]".format(args)

{replacement_field}

Example 1

>>> print('...{:s}...'.format('Hello'))
...Hello...

or

or

Example 2

>>> var1=20
>>> var2=-10.123
>>> print("{0:8.2f}\t{1:8.2f}".format(var1,var2))

Example 3

name="Tom"
age="30"
print("Your name is {} and you are {} years old".format(name,age)

Example 4

>>> name="Tom"
>>> age="30"
>>> print("Your name is {} and you are {} years old".format(name,age))
Your name is Tom and you are 30 years old
>>> print("Your name is {0} and you are {1} years old".format(name,age))
Your name is Tom and you are 30 years old
>>> print("Your name is {1} and you are {0} years old".format(age,name))
Your name is Tom and you are 30 years old
>>> print("Your name is {pName} and you are {pAge} years old".format(pName=name,pAge=age))
Your name is Tom and you are 30 years old
>>> print("Your name is {pName} and you are {pAge} years old".format(pAge=age,pName=name))
Your name is Tom and you are 30 years old

Go Top

Method 3

formatted string literals (f-strings)

Syntax:

     f"[string_literals]{replacement_field}[string_literals]"

{replacement_field}

     { [field_name] : ![conversion] : [format_spec] }

field_name : variable name
converstion : r,s,a which calls repr(), str() or ascii() respectively
format_spec: see below
 

>>> strHello='Hello'
>>> print(f'...{strHello:s}...')
...Hello...

>>> var1=20
>>> var2=-10

>>> print(f'{var1:+8.2f}\t{var2:+8.2f}')
 

>>> print(f'{var1:-8.2f}\t{var2:-8.2f}')

>>> print(f'{var1:_<8.2f}\t{var2:_>8.2f}')

>>> print(f'{var1:08.2f}\t{var2:08.2f}')

>>> print(f'{var1:_<8d}\t{var2:_>8d}')

>>> print(f'{var1:_<8b}\t{var2:_>8o}')

>>> print(f'{var1:_<#8b}\t{var2:_>#8o}')

 Go Top

Format Specifier (further reference here)

To use variable as width use a nested {} within the replacement field

< align left
> align right
= for numeric types, places padding after sign but before digit e.g. +000000120
^ center align

+ sign should be used for both positive and negative
- sign should be used only for negative
'' space should be used for positive, - should be used for negative

b Binary format
c Character format
d Decimal integer, base 10
e Exponent notation with lowecase e, precision is 6
E Exponent notation with uppercase E
f fixed point notation, default precision 6
F same as F, but converts 'nan' to 'NAN', 'inf' to 'INF'
g General format
G same as g but switches to 'E' if number is too large
n Number format, uses current local setting for number separator
o Octal format, base 8
s String format
x Hex format using lowercase
X Hex format using UPPERCASE
% Percentage format.  Multiples number by 100, uses f format and appends %

S[i]
- return char at index i

S[i:j]
- return slice from index i to (but excluding) index j

S[i:]
- return slice from index i to the end of string

S[-1]
- return slice last char from end of string (first from back)

S[::-1]
- return the string in reverse

>>> S="Hello, World!"
>>> S[2:5:1]
'llo'
>>> S[0:10:2]
'Hlo o'

>>> S[4]
'o'

>>> S[1:4]
'ell'

>>> S[7:]
'World!'

>>> S[-1]
'!'

>>> S[::-1]
'!dlroW ,olleH'

Go Top

string with its first character capitalized and the rest lowercased

str.casefold()

Return a casefolded copy of the string. Casefolded strings may be used for caseless matching.  Different from converting to lowercase, stronger, more agressive,

str.center(width[, fillchar])

Return centered in a string of length width. Padding is done using the specified fillchar (default is an ASCII space). The original string is returned if width is less than or equal to len(s

str.count(sub[, start[, end]])

Return the number of non-overlapping occurrences of substring sub in the range [start, end]. Optional arguments start and end are interpreted as in slice notation.

str.encode(encoding="utf-8", errors="strict")

Return an encoded version of the string as a bytes object. Default encoding is 'utf-8'

str.endswith(suffix[, start[, end]])

Return True; if the string ends with the specified suffix, otherwise return . suffix can also be a tuple of suffixes to look for. With optional start, test beginning at that position. With optional end, stop comparing at that position

str.expandtabs(tabsize=8)

Return a copy of the string where all tab characters are replaced by one or more spaces, depending on the current column and the given tab size. Tab positions occur every tabsize characters (default is 8)

str.find(sub[, start[, end]])

Return the lowest index in str where substring sub is found,
such that sub is contained within S[start:end].  Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.

str.format(*args,**kwargs)

Return a formatted version of str, using substitutions from args and kwargs.  The substitutions are identified by braces ('{' and '}').

str.format_map(mapping)

Similar to "str.format(**mapping)", except that "mapping" is used directly and not copied to a "dict".  This is useful if for example "mapping" is a dict subclass:

str.index(sub[, start[, end]])

Return the lowest index in str where substring sub is found,
such that sub is contained within S[start:end].  Optional
arguments start and end are interpreted as in slice notation.
Raises ValueError when the substring is not found.

str.isalnum()

Return true if all characters in the string are alphanumeric and there is at least one character, false otherwise.  A character "c" is alphanumeric if one of the following returns "True": "c.isalpha()", "c.isdecimal()", "c.isdigit()", or "c.isnumeric()".

str.isalpha()

Return true if all characters in the string are alphabetic and there is at least one character, false otherwise.  Alphabetic characters are those characters defined in the Unicode character database as ôLetterö, i.e., those with general category property being one of ôLmö, ôLtö, ôLuö, ôLlö, or ôLoö.  Note that this is    different from the Alphabetic property defined in the Unicode Standard.

str.isascii()

Return true if the string is empty or all characters in the string are ASCII, false otherwise. ASCII characters have code points in the range U+0000-U+007F.

str.isdecimal()

Return true if all characters in the string are decimal characters and there is at least one character, false otherwise. Decimal characters are those that can be used to form numbers in base 10, e.g. U+0660, ARABIC-INDIC DIGIT ZERO. 

str.isdigit()

Return true if all characters in the string are digits and there is at least one character, false otherwise.  Digits include decimal characters and digits that need special handling, such as the compatibility superscript digits. This covers digits which cannot be used to form numbers in base 10, like the Kharosthi numbers.

str.isidentifier()

Return true if the string is a valid identifier according to the language definition, section Identifiers and keywords.  Use "keyword.iskeyword()" to test for reserved identifiers such as "def" and "class".


str.islower()

Return true if all cased characters [4] in the string are lowercase and there is at least one cased character, false otherwise

str.isnumeric()

Return true if all characters in the string are numeric characters, and there is at least one character, false otherwise. Numeric characters include digit characters, and all characters that have the Unicode numeric value property

str.isprintable()

Return true if all characters in the string are printable or the string is empty, false otherwise. Nonprintable characters are those characters defined in the Unicode character database as “Other” or “Separator”, excepting the ASCII space (0x20) which is considered printable

str.isspace()

Return true if there are only whitespace characters in the string and there is at least one character, false otherwise

str.istitle()

Return true if the string is a titlecased string and there is at least one character, for example uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return false otherwise

str.isupper()

Return true if all cased characters [4] in the string are uppercase and there is at least one cased character, false otherwise

str.join(iterable)

Return a string which is the concatenation of the strings in *iterable*. A "TypeError" will be raised if there are any non- string values in *iterable*, including "bytes" objects.  The separator between elements is the string providing this method.

str.ljust(width[, fillchar])

Return the string left justified in a string of length *width*. Padding is done using the specified *fillchar* (default is an ASCII space). The original string is returned if *width* is less than or equal to "len(s)".

str.lower()

Return a copy of the string with all the cased characters [4] converted to lowercase.

str.lstrip([chars])

Return a copy of the string with leading characters removed. The chars argument is a string specifying the set of characters to be removed. If omitted or None;, the chars argument defaults to removing whitespace. The chars argument is not a prefix; rather, all combinations of its values are stripped.

static str.maketrans(x[, y[, z]])

This static method returns a translation table usable for "str.translate()".  If there is only one argument, it must be a dictionary mapping Unicode ordinals (integers) or characters (strings of length 1) to Unicode ordinals, strings (of arbitrary lengths) or "None". Character keys will then be converted to ordinals. If there are two arguments, they must be strings of equal length, and in the resulting dictionary, each character in x will be mapped to the character at the same position in y.  If there is a third argument, it must be a string, whose characters will be mapped to "None" in the result.

str.partition(sep)

Split the string at the first occurrence of *sep*, and return a 3-tuple containing the part before the separator, the separator itself, and the part after the separator.  If the separator is not found, return a 3-tuple containing the string itself, followed by two empty strings.

str.replace(old, new[, count])

Return a copy of the string with all occurrences of substring *old* replaced by *new*.  If the optional argument *count* is given, only the first *count* occurrences are replaced.


str.rfind(sub[, start[, end]])

Return the highest index in the string where substring *sub* is found, such that *sub* is contained within "s[start:end]". Optional arguments *start* and *end* are interpreted as in slice notation.  Return "-1" on failure.

str.rindex(sub[, start[, end]])

Like "rfind()" but raises "ValueError" when the substring *sub* is not found.


str.rjust(width[, fillchar])

Return the string right justified in a string of length *width*. Padding is done using the specified *fillchar* (default is an ASCII space). The original string is returned if *width* is less than or equal to "len(s)".


str.rpartition(sep)

Split the string at the last occurrence of *sep*, and return a 3-tuple containing the part before the separator, the separator itself, and the part after the separator.  If the separator is not found, return a 3-tuple containing two empty strings, followed by the string itself.


str.rsplit(sep=None, maxsplit=-1)

Return a list of the words in the string, 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 "None", any whitespace string is a separator.  Except for splitting from the right, "rsplit()" behaves like "split()" which is described in detail below.

str.rstrip([chars])

Return a copy of the string with trailing characters removed.  The *chars* argument is a string specifying the set of characters to be removed.  If omitted or "None", the *chars* argument defaults to removing whitespace.  The *chars* argument is not a suffix; rather, all combinations of its values are stripped:



str.split(sep=None, maxsplit=-1)

Return a list of the words in the string, using *sep* as the delimiter string.  If *maxsplit* is given, at most *maxsplit* splits are done (thus, the list will have at most "maxsplit+1" elements).  If *maxsplit* is not specified or "-1", then there is no limit on the number of splits (all possible splits are made).

If *sep* is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings (for example, "'1,,2'.split(',')" returns "['1', '', '2']").  The *sep* argument may consist of multiple characters (for example, "'1<>2<>3'.split('<>')" returns "['1', '2', '3']"). Splitting an empty string with a specified separator returns "['']".

If *sep* is not specified or is "None", a different splitting algorithm is applied: runs of consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the start or end if the string has leading or trailing whitespace.  Consequently, splitting an empty string or a string consisting of just whitespace with a "None" separator returns "[]".


str.splitlines([keepends])

Return a list of the lines in the string, breaking at line boundaries.  Line breaks are not included in the resulting list unless *keepends* is given and true.

This method splits on the following line boundaries.  In particular, the boundaries are a superset of *universal newlines*.
 

\n : Line Feed
\r : Carriage Return
\r\n : Carriage Return + Line Feed
\v or \x0b : Line Tabulation
\f or \x0c : Form Feed
\x1c : File Separator
\x1d : Group Separator
\x1e : Record Separator
\x85 : Next Line
\u2028 : Line Separator
\u2029 : Paragraph Separator

Unlike "split()" when a delimiter string *sep* is given, this method returns an empty list for the empty string, and a terminal line break does not result in an extra line:

str.startswith(prefix[, start[, end]])

Return "True" if string starts with the *prefix*, otherwise return "False". *prefix* can also be a tuple of prefixes to look for. With optional *start*, test string beginning at that position. With optional *end*, stop comparing string at that position.


str.strip([chars])

Return a copy of the string with the leading and trailing characters removed. The *chars* argument is a string specifying the set of characters to be removed. If omitted or "None", the *chars* argument defaults to removing whitespace. The *chars* argument is not a prefix or suffix; rather, all combinations of its values are stripped:


The outermost leading and trailing *chars* argument values are stripped from the string. Characters are removed from the leading end until reaching a string character that is not contained in the set of characters in *chars*. A similar action takes place on the trailing end. For example:

str.swapcase()

Return a copy of the string with uppercase characters converted to lowercase and vice versa. Note that it is not necessarily true that "s.swapcase().swapcase() == s".


str.title()

Return a titlecased version of the string where words start with an  uppercase character and the remaining characters are lowercase.

str.translate(table)

Return a copy of the string in which each character has been mapped through the given translation table.  The table must be an object that implements indexing via "__getitem__()", typically a *mapping* or *sequence*.  When indexed by a Unicode ordinal (an integer), the table object can do any of the following: return a Unicode ordinal or a string, to map the character to one or more other characters; return "None", to delete the character from the return string; or raise a "LookupError" exception, to map the character to itself.

You can use "str.maketrans()" to create a translation map from character-to-character mappings in different formats.


str.upper()

Return a copy of the string with all the cased characters [4] converted to uppercase. 


str.zfill(width)

Return a copy of the string left filled with ASCII "'0'" digits to make a string of length *width*. A leading sign prefix ("'+'"/"'-'") is handled by inserting the padding *after* the sign character rather than before. The original string is returned if *width* is less than or equal to "len(s)".

str.capitalize()

>>> 'hello'.capitalize()
'Hello'

str.casefold()

>>> firstString = "der Fluß"
>>> secondString = "der Fluss"
>>> firstString.casefold()
'der fluss'
>>> secondString.casefold()
'der fluss'

str.center()

>>> 'Hello'.center(20,'_')
'_______Hello________'

str.count()

>>> "abracadabra".count("ab",0)
2

str.encode()

>>> "pythön!".encode()
b'pyth\xc3\xb6n!'
# the b prefix means bytecode

str.endswith()

>>> "Friend".endswith("end")
True
>>> "Friendship".endswith("end")
False

with start parameter:

>>> "Your Friend".endswith("end",8)
True
>>> "My Friend".endswith("end",8)
False

str.expandtabs()

>>> "Name\tAddress\tTel".expandtabs()
'Name    Address Tel'
>>> "Name\tAddress\tTel".expandtabs(tabsize=10)
'Name      Address   Tel'

str.format() example here

str.format_map()
   >>> class Default(dict):
   ...     def __missing__(self, key):
   ...         return key
   ...
   >>> '{name} was born in {country}'.format_map(Default(name='Guido'))
   'Guido was born in country' 

str.index()

>>> S="Hello, world!"
>>> S.index(",")
5
>>> S.index(",",0,10)
5
>>> S.index(",",10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

str.isalnum()

>>> "abc123".isalnum()
True
>>> "a12345".isalnum()
True
>>> "123456".isalnum()
True
>>> "abc123!".isalnum()
False

str.isalpha()

>>> "abc".isalpha()
True
>>> "abc123".isalpha()
False

str.isascii()

>>> chr(0).isascii()
True
>>> chr(127).isascii()
True
>>> chr(128).isascii()
False

str.rstrip()
>>> '   spacious   '.rstrip()
'   spacious'
>>> 'mississippi'.rstrip('ipz')
'mississ'

str.split()

>>> '1,2,3'.split(',')
['1', '2', '3']
>>> '1,2,3'.split(',', maxsplit=1)
['1', '2,3']
>>> '1,2,,3,'.split(',')
['1', '2', '', '3', '']
>>> '1 2 3'.split(maxsplit=1)
['1', '2 3']
>>> '   1   2   3   '.split()
['1', '2', '3']

str.splitlines()
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

str.strip()
>>> '   spacious   '.strip()
'spacious'
>>> 'www.example.com'.strip('cmowz.')
'example'

str.title()
>>> 'Hello world'.title()
'Hello World'

str.zfill()
>>> "42".zfill(5)
'00042'
>>> "-42".zfill(5)
'-0042'

Go Top

Go Top

eg.1

>>> L = list()
>>> L
[]
>>> L.append(1)
>>> L.append(2)
>>> L
[1, 2]

When initialized as empty list with list(), we CANNOT add items by L[index] = value.

eg. 2

>>> L = list("Hello")
>>> L
['H', 'e', 'l', 'l', 'o']

eg. 3

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

eg. 4

>>> L = [] + [1,2,3]
>>> L
[1, 2, 3]
>>> L = [1,2] + [3,4]
>>> L
[1, 2, 3, 4]

eg. 5

>>> L=[11,33,44]
>>> L.insert(1,22)
>>> L
[11, 22, 33, 44]

eg. 6 - Initialize empty list if it does not already exist

if (L is not None):
   L = list()
L.append("apple")


 

e.g. - local all list index where the item equals specific value

>>> L=['a','a','b','d']
>>> NL=[i for i in range(len(L)) if L[i]=='a']
>>> NL
[0, 1]

Go Top

list.append(x)

Add an item to the end of the list. Equivalent to a[len(a):] = [x].

list.clear()

Remove all items from the list. Equivalent to del a[:].

list.copy()

Return a shallow copy of the list. Equivalent to a[:].

list.count(x)

Return the number of times x appears in the list.

list.extend(iterable)

Extend the list by appending all the items from the iterable. Equivalent to a[len(a):] = iterable.

list.index(x[, start[, end]])

Return zero-based index in the list of the first item whose value is equal to x. Raises a ValueError if there is no such item.

The optional arguments start and end are interpreted as in the slice notation and are used to limit the search to a particular subsequence of the list. The returned index is computed relative to the beginning of the full sequence rather than the start argument.

list.insert(i, x)

Insert 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).

list.pop([i])

Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list. (The square brackets around the i in the method signature denote that the parameter is optional, not that you should type square brackets at that position. You will see this notation frequently in the Python Library Reference.)

list.remove(x)

Remove the first item from the list whose value is equal to x. It raises a ValueError if there is no such item.

list.reverse()

Reverse the elements of the list in place.

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

Sort the items of the list in place (the arguments can be used for sort customization, see sorted() for their explanation).  list.sort() does not return a value, but sorts the items in place.  To see the result, call the sort method first and then use the list later

Example data

>>> fruits=['orange','apple','pear','banana','kiwi','apple','banana']

.append() example

>>> fruits.append('grape')
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange', 'grape']

.count()  example

>>> fruits.count('apple')
2

.index()  example
>>> fruits.index('banana')
3
>>> # Find next banana starting a position 4
>>> fruits.index('banana', 4) 
6 

.insert() example

>>> fruits.insert(1,"grape")
>>> print(fruits)
['orange', 'grape', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']

.pop() example

>>> fruits.pop()
'pear'

.reverse() example

>>> fruits.reverse()
>>> fruits
['banana', 'apple', 'kiwi', 'banana', 'pear', 'apple', 'orange']

.sort() examples

>>> # sort using default sort order
>>> fruits.sort()
>>> fruits
['apple', 'apple', 'banana', 'banana', 'grape', 'kiwi', 'orange', 'pear']
>>> # sort using the length of items as key
>>> fruits.sort(key=len)
>>> print(fruits)
['kiwi', 'pear', 'apple', 'apple', 'banana', 'banana', 'orange']
>>> # sort in reverse order using length of items as key
>>> fruits.sort(key=len,reverse=True)
>>> print(fruits)
['orange', 'banana', 'banana', 'apple', 'apple', 'pear', 'kiwi']

List Comprehension

[ expression for variable in sequence ] 

Creates a new list based on the given sequence, each element is the result of the given expressoin

[ expression for variable in sequence if condition ]

Creates a new list based on the given sequence.  Each element is the result of the given expression; elements only get added if the condition is true

Examples

>>> xfive = [x*5 for x in range(1,13)]
>>> xfive
[5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60]

>>> evenxfive= [x*5 for x in range(1,13) if x%2==0]
>>> evenxfive
[10, 20, 30, 40, 50, 60]

D = dict()

D = dict(one=1,two=2,three=3)

D = {'one':1, 'two':2}

D['one'] = 1
D['two'] = 2

D=dict([('one',1),('two',2)])

D=dict(zip(['one', 'two', 'three'], [1, 2, 3]))

keyList=['one','two','three']
valList=[1,2,3]
D=dict(zip(keyList,valList))

Go Top

D=dict(one=1,two=2,three=3)

iterating by the Dictionary keys:-

for k in D.keys():
     # process with key-k, value=D[k]

or just:

for k in D:
    # process with key=k, value=D[k]

iterating by the Dictionary values:

for v in D.values():
     # process each value

iterating by the Dictionary key,value pair:-

for k,v in D.items():
     # process items with key=k, value=v

 Go Top

len(d)

   Return the number of items in the dictionary *d*.

dict(*kwargs)

   Return a new dictionary initialized from an optional positional
   argument and a possibly empty set of keyword arguments.


iter(d)

   Return an iterator over the keys of the dictionary. 
   This is a shortcut for "iter(d.keys())"
 

len()
>>> a = dict(one=1, two=2, three=3)
>>> len(a)
3

dict()
>>> a = dict(one=1, two=2, three=3)
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})


 

Go Top

D.clear()

Remove all items from the dictionary.

D.copy()

Return a shallow copy of the dictionary.

D.fromkeys(seq[, value])

Create a new dictionary with keys from *seq* and values set to  *value*. "fromkeys()" is a class method that returns a new dictionary.  *value* defaults to "None".

D.get(key[, default])

Return the value for *key* if *key* is in the dictionary, else *default*. If *default* is not given, it defaults to "None", so that this method never raises a "KeyError".

D.items()

      Return a new view of the dictionaryÆs items ("(key, value)"
      pairs). See the documentation of view objects.

D.keys()

      Return a new view of the dictionaryÆs keys.  See the
      documentation of view objects.

D.pop(key[, default])

      If *key* is in the dictionary, remove it and return its value,
      else return *default*.  If *default* is not given and *key* is
      not in the dictionary, a "KeyError" is raised.

D.popitem()

      Remove and return a "(key, value)" pair from the dictionary.
      Pairs are returned in LIFO (last-in, first-out) order.

      "popitem()" is useful to destructively iterate over a
      dictionary, as often used in set algorithms.  If the dictionary
      is empty, calling "popitem()" raises a "KeyError".

      Changed in version 3.7: LIFO order is now guaranteed.
      In prior  versions, "popitem()" would return an arbitrary
      key/value pair.

D.setdefault(key[, default])

      If *key* is in the dictionary, return its value.  If not, insert
      *key* with a value of *default* and return *default*.  *default*
      defaults to "None".

D.update([other])

      Update the dictionary with the key/value pairs from *other*,
      overwriting existing keys.  Return "None".

      "update()" accepts either another dictionary object or an
      iterable of key/value pairs (as tuples or other iterables of
      length two).  If keyword arguments are specified, the  
      dictionary is then updated with those key/value pairs:
     "d.update(red=1, blue=2)".

D.values()

      Return a new view of the dictionaryÆs values.  See the
      documentation of view objects.

 

.clear()
>>> d = dict(one=1, two=2, three=3)
>>> d
{'one': 1, 'two': 2, 'three': 3}
>>> d.clear()
>>> d
{}

.copy()
>>> d=dict(one=1, two=2, three=3)
>>> d
{'one': 1, 'two': 2, 'three': 3}
>>> e=d.copy()
>>> e
{'one': 1, 'two': 2, 'three': 3}
 

class ClassName[ ] :
    "doc string for the class, accessible by calling the .__doc__ attr"

Notes:

Functions defined within the class (methods) have self as the first argument, whenever an object calls its method, the object itself is passed as the first argument.

calling a method with a list of n arguments is equivalent to calling the corresponding function with an argument list that is created by inserting the method's object before the first argument

__init__() function is the constructor for the class.  This function gets called whenever a new object of that class is instantiated

__str__() function defines whatt is printed when you call the print() function with the instance of the class as parameter

eg.

open()

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

Open file and return a stream.  Raise OSError upon failure.

Note: For directory related operation see os module

example 1 - read file line by line
file=open('list.txt','r')
for line in file:
     line = line.strip('\n')
     print(line)
file.close()

example 2 - write to a file line by line, overwrite target file

file=open('list.txt','w')
file.write("first\n")
file.write("second\n")
file.close



example 3 - append to existing file

file=open('list.txt','a')
file.write('third\n')
file.close

example 4 - read entire file into a string/array

# read whole file into a string
with open('file.txt', 'r') as file:
    data = file.read()

# read whole file into a string and strip all newlines '\n','')
with open('file.txt', 'r') as file:
    data = file.read().replace('\n','')

# read whole file line by line into an array
with open('file.txt', 'r') as file:
    lines = file.readlines()

 

Tuples may be constructed in a number of ways:

• Using a pair of parentheses to denote the empty tuple: ()

• Using a trailing comma for a singleton tuple: a, or (a,)

• Separating items with commas: a, b, c or (a, b, c)

• Using the tuple() built-in: tuple() or tuple(iterable)

Although you use brackets () to initialize Tuples, when accessing elements of the Tuple, use square brackets [] to slice or obtain value of specific index

e.g.

>>> Numbers=("zero","one","two","three","four")
>>> Numbers[0]
'zero'
>>> Numbers[1:3]
('one', 'two')

as

used with import, except and with

import SomeModule as SomeNamespace:

except SomeException as SomeVariable:

with SomeExpression as SomeTarget:

Examples:

>>> import re as regex
>>> if regex.match(r'^\d+[.]\d+{2}$',"192.16"):
...    print("True")
... else:
...    print("False")
...
True

 Go Top

del

del target

Deletion of a target list recursively deletes each target, from left to right.

Deletion of a name removes the binding of that name from the local or global namespace

See also delattr

e.g.

>>> s=['1','2','3','4','5']
>>> del s[3:]
>>> s
['1', '2', '3']

Go Top

from

used with import, yield

from Module import Identifier [ as identifier ]

yield from Expression

Go Top

global

is a declaration which holds for the entire current code block. It means that the listed identifiers are to be interpreted as global in scope

Allows you to assign values to a global variable

example

when "global" statement is used:

>>> def myfun():
...    global S
...    S = S + " modified"
...    print("Print from inside function : " + S)
...
>>> S="a global variable"
>>> print(S)
a global variable
>>> myfun()
Print from inside function : a global variable modified

when "global" statement not used

>>> def myfun():
...    S = S + " modified"
...    print("Print from inside function : " + S)
...
>>> S="a global variable"
>>> print(S)
a global variable
>>> myfun()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in myfun
UnboundLocalError: local variable 'S' referenced before assignment

Go Top

nonlocal

Makes the value bound to a variable available to the enclosing function in nested functions. 

Introduced from version 3.8

def outer():
    x = "local"
   
    def inner():
        nonlocal x
        x = "nonlocal"
        print("inner:", x)
   
    inner()
    print("outer:", x)

outer()

output

inner: nonlocal
outer: nonloca

pass

pass is a null operation, when it is executed, nothing happens.  It is useful as a placeholder when a statement is required syntactically, but no code needs to be executed.

Examples:

def f(arg):
  pass
  # function that does nothing (yet)

class C:
  pass   
  # class with no methods (yet)

Go Top

raise

the statement to raise an exception

eg. 1

if x < 0:
   raise Exception("You entered a negative number")

eg. 2

if not type(n) is int:
  raise TypeError("Not an integer")

e.g. 3

## raise ValueError if the item to be removed
## is not in the list
def RemoveValue(myVal):
    if myVal not in my_list:
        raise ValueError("Value must be in the given list")
    else:
        my_list.remove(myVal)
    return my_list



 Go Top

with

with smthg_that_returns_context_manager as var:
   # process var

The with statement is used to wrap the execution of a block with methods defined by a context manager

A context manager is an object that defines the runtime context to be established when executing a with statement. The context manager handles the entry into, and the exit from, the desired runtime context for the execution of the block of code

eg. 1

# using with statement
with open('filepath', 'w') as file:
    file.write('some data')

# The with statement will ensure the file is closed at the end of the block.
# no need to explicitly close the file.
 

yield

yield <expr>
yield from <expr>

yield expressions and statements are only used when defining a generator function, and are only used in the body of the generator function.

A generator function, is like a normal function but with yield statement instead of a return statement.

The difference is that, while a return statement terminates a function entirely, yield statement pauses the function saving all its states and later continues from there on successive calls.

Examples:

>>> def MyGen():
...    list=range(5)
...    for i in list:
...       yield i*i
...
>>> for x in MyGen():
...    print(x)
...
0
1
4
9
16
 

Go Top