Python control syntax, functions (Python learning memo ②)

This time is a learning memo about control syntax and functions.

if statement

point

• There is no swhich (use if, elif, else instead)

#You can wait for input like this
x = int(input("Please enter an integer: "))

if x < 0:
    x = 0
    print ("Negative number is zero")
elif x == 0:
    print("zero")
elif x == 1:
    print("One")
else:
    print("More")

for statement

point

• For items in any sequence (list or string), you can x iterate in the order within that sequence.
• If you need to modify the sequence during the iteration, it is recommended to make a copy and repeat it. It is convenient to use slice notation for this.

#Measure the length of a string
words = ['cat', 'window', 'defenstrate']
for w in words:
    print(w, len(w))

#output
# cat 3
# window 6
# defenstrate 11

#Loop through slice copy of the entire list
words = ['cat', 'window', 'defenstrate']
#Make a shallow copy of the list
for w in words[:]:
    if len(w) > 6:
        words.insert(0, w)
print(words)

#output
# ['defenstrate', 'cat', 'window', 'defenstrate']

range () function

point

• Convenient when repeating a series of numbers
• Does not include the given termination point
• The 10 values generated by range (10) are exactly the indexes for each item in a sequence of length 10 (the sequence can be indexed repeatedly).
• However, in many cases it is convenient to use the ʻenumerate ()` function
• The object returned by range behaves like a list, but is not a list (ʻiterable` object)
• Really save resources by not using lists

#Iteration by range
for i in range(5):
    print(i)

#output
# 0
# 1
# 2
# 3
# 4

#Iteration using sequence index
a = ['Mary', 'had', 'a', 'little', 'lamb']
for i in range(len(a)):
    print(i, a[i])

#output
# 0 Mary
# 1 had
# 2 a
# 3 little
# 4 lamb

break statement and continue statement, else clause in loop

point

• The break statement breaks the for or while loop as in C language
• Like C language, the continue statement skips the rest of the loop and goes to the next iteration.
• You can also specify an else clause for for or while
• For for, else is called when the list is exhausted
• In the case of while, else is called when the conditional expression is not met.

for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, 'equals', x, '*', n//x)
            break
    else:
        #This else depends on for
        #If you can't find a divisor in the loop
        print(n, 'is a prime number')

#output
# 2 is a prime number
# 3 is a prime number
# 4 equals 2 * 2
# 5 is a prime number
# 6 equals 2 * 3
# 7 is a prime number
# 8 equals 2 * 4
# 9 equals 3 * 3

pass statement

point

• The pass statement does nothing
• Use when you need a statement syntactically but you don't need to do anything programmatically
• Also often used to generate the smallest class
• When writing new code, you can put it as a placeholder in the body of a function or condition to help you think about a more abstract level.

while True:
    pass #Do nothing Ctrl+Wait to finish with C

#Generate the smallest class
class MyEmptyClass
    pass

#Function definition
def initLog(*args):
    pass #Erase after implementation

Function definition

point

• You can use a string literal in the first statement of the function body (this will be the function's documentation string). This is a good deed, so make it a habit.
• It is convenient to write a docstring so that the document can be automatically generated.
• Global variables can basically only be referenced in functions
• Values cannot be assigned directly (unless specified in the global statement)
• The actual arguments passed when calling a function are added to the function's local symbol table at the time of the call.
• For objects, a reference to the object is passed
• Functions without a return statement return None

def fib(n):
    """Display Fibonacci series up to n"""
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
    print()

fib(2000)

#output
# 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Further about function definition

Default value of argument

point

• Default value can be defined for argument
• The evaluation of the default value is performed in the scope where the definition is written when the function is defined (Example ①).
• Note that the default value evaluation only happens once
• If the default value is a variable object such as a list or dictionary, this will affect it (Example 2)

#Example ①
i = 5

def f(arg=i):
    print(arg)

i = 6
f()

#output
# 5

#Example ②
def f(a, L=[]):
    L.append(a)
    return L

print(f(1))
print(f(2))
print(f(3))

#output
# [1]
# [1, 2]
# [1, 2, 3]

Keyword arguments

point

• Functions can take keyword arguments
• Whenever you call a function, the positional argument must come first and the keyword argument comes after.
• All keyword arguments must match those written in the formal arguments of the function definition, but the order does not matter.
• Argument can take value only once (duplicate argument specification is invalid)

def parrot(voltage, state='a stiff', action='voom', type='Norwegian Blue'):
    print("-- This parrot wouldn't", action, end=' ');

#You can call in any of the following ways
parrot(1000)                                         #1 positional argument
parrot(voltage=1000)                                 #1 keyword argument
parrot(voltage=100000000, action='VOOOOOM')          #2 keyword arguments
parrot(action='VOOOOOOOM', voltage=1000000)          #2 keyword arguments
parrot('a million', 'bereft of life', 'jump')        #3 positional arguments
parrot('a tousand', state='pushing up the daisies')  #1 positional argument 1 keyword argument

#Next call is invalid
# parrot()                     #Missing required arguments
# parrot(voltage=5.0, 'dead')  #Non-keyword arguments after keyword arguments
# parrot(110, voltage=220)     #Given the same argument twice
# parrot(actor='John Cleese')  #Unknown keyword argument

• If the formal argument ends in the form ** name, this argument receives a dictionary
• This dictionary contains all keyword arguments except for the keywords that correspond to the formal arguments (that is, you can use keywords that are not in the formal arguments).
• Can also be combined with the * name format
• In the example below, the result of the key () method is used when displaying the contents of the keywords dictionary. This fixes the display order of the arguments.

def cheeseshop(kind, *arguments, **keywords):
    print("-- Do you have any", kind, "?")
    print("-- I'm sorry, we're all out of", kind)
    for arg in arguments:
        print(arg)
        print("-" * 40)
        keys = sorted(keywords.keys())
        for kw in keys:
            print(kw, ":", keywords[kw])
            
cheeseshop("Limburger", "It's very runny, sir.",
           "It's really very, VERY runny, sir.",
           shopkeeper="Michael Palin",
           client="John Cleese",
           sketch="Cheese Shop Sketch")

#output
# -- Do you have any Limburger ?
# -- I'm sorry, we're all out of Limburger
# It's very runny, sir.
# ----------------------------------------
# client : John Cleese
# shopkeeper : Michael Palin
# sketch : Cheese Shop Sketch
# It's really very, VERY runny, sir.
# ----------------------------------------
# client : John Cleese
# shopkeeper : Michael Palin
# sketch : Cheese Shop Sketch

List of optional arguments

point

• Can accept a variable number of arguments
• Arguments are grouped into tuples
• Normal arguments can be placed before the variable number of arguments
• Put a variable number of arguments at the end of the formal argument list (because it sucks in all the rest of the arguments passed to the function)
• In the * args format, all formal arguments after this can only be used as keyword arguments, not as positional arguments.

def concat(*args, sep="/"):
    return sep.join(args)

print(concat("earth", "mars", "venus"))

#output
# earth/mars/venus

print(concat("earth", "mars", "venus", sep="."))

#output
# earth.mars.venus

Unpacking the argument list

point

• There is a convenient way in situations where the argument you want is already a list or tuple and you have to unpack it for a function that requires a positioned argument. You can easily unpack lists and tuples using the * range function and the * args format

>>> list(range(3, 6))
[3, 4, 5]

>>> args = [3, 6]
>>> list(range(*args))
[3, 4, 5]

• Similarly, the dictionary can be passed as a keyword argument by using the ** operator.

>>> def parrot(voltage, state='a stiff', action='voom'):
...     print("-- This parrot wouldn't", action, end=' ')
...     print("if you put", voltage, "volts through it.", end=' ')
...     print("E's", state, "!")
...
>>> d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
>>> parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

lambda expression

point

• You can write a small anonymous function using the keyword lambda
• There is a syntactic limitation that this format can only have a single expression

def make_incrementor(n):
    return lambda x: x + n #Returns an anonymous function

f = make_incrementor(42)

f(0) # 42
f(1) # 43

Documentation string (docstring)

point

• The first line should always be a short and concise summary of the object's purpose
• This line starts with a capital letter and ends with a period
• If there is a continuation, leave the second line of the documentation string blank and visually separate the summary from other descriptions.
• The transition line should use paragraphs to describe how to call the Obujuek, side effects, etc.
• The Python parser does not remove the indentation of multi-line string literals, so if you want to remove it, use the documentation tool.

def my_function():
    """Do nothing, but document it.
    
    No, really, it doesn't do anything.
    """
    pass

print(my_function.__doc__)

#output
# Do nothing, but document it.
# 
#     No, really, it doesn't do anything.

Function annotation (function annotation)

point

• Type metadata information can be added
• Stored as a dictionary in the function's __annotations__ attribute and has no effect on other parts of the function
• Argument annotations can be defined by following the argument name with a colon and an expression.
• The return value annotation is defined by inserting a literal -> before the colon at the end of the def statement and between it and the formal argument list.

def f(ham: str, eggs: str = 'eggs') -> str:
    print("Annotations:", f.__annotations__)
    print("Arguments:", ham, eggs)
    return ham + ' and ' + eggs

f('spam')

#output
# Annotations: {'ham': <class 'str'>, 'eggs': <class 'str'>, 'return': <class 'str'>}
# Arguments: spam eggs
# 'spam and eggs'

Coding style

point

• 4 spaces for indentation, no tabs
• Wrap lines with 79 characters or less
• Use blank lines to separate functions, classes, and large blocks within functions
• Make comment lines independent if possible
• Use docstring
• Put a space around the operator and after the comma, but not just inside the parentheses Example: a = f (1, 2) + g (3, 4)
• Use CamelCase for classes and lower_case_with_underscores for functions and methods
• Always use self as the first argument of the method
• Encode using default UTF-8 or ASCII