Functions And Modules

Question 1

Function arguments?

Answer 1

Required
Keyword
Default
Variable-Length
(Positional Argument assigned based on its position and keyword: based on parameter name)

Question 2

Keyword arguments

Answer 2

PRO:
1. change the order of parameters when calling than while defining.

The argument should not receive value more than once and no argument should be left behind.

Question 3

Default arguments

Answer 3

Assumes a default value if no value assigned when calling. c is an example.
Default arguments should not be followed by non-default while declaring the function.
Syntax
def func(a,b,c= 'value'):

Question 4

Variable-length Arguments

Answer 4

Syntax:
def func(a,*b):

1. The arbitrary no. of arguments passed, form a tuple.
2. Should be last in the list of a formal parameter only keyword arguments can be after it.

Question 5

Lambda Functions

Answer 5

• can take any no. of args.
• no explicit return statement but always returns an expression.
• can be passed as arg to a func.
  (also look at example 5.28, 204)

Question 6

Nested lambda functions

Answer 6

name = lambda args: exp
name2 = lambda x,y,z: x*(name(y,z))

print ( ( lambda x,y,z : x*(lambda x,y: x+y)(y,z) ) (1,2,3))

The occurrence of recursion and runtime error of recursion depth may occur.

Question 7

The number of expressions in lambda functions.

Answer 7

1

Question 8

Use of lambda function?

Answer 8

usually when created only, hence called thrown away.

Question 9

Syntax of lambda

Answer 9

lambda arguments: expression

Question 10

passing args to lambda

Answer 10

(lambda x:x2) (9) # 9 being the arg passed.
OR
twice = lambda x:x2
print ( twice(9) )

Question 11

Documentation Strings

Answer 11

Explain code, same as a comment but are retained throughout the runtime of the program. So users can inspect during program execution.

Question 12

Docstring declaration

Answer 12

def func():
    "Func \_\_docdtring\_\_"

• triple quotes to extend it to multiline.
• in case of multiline second line should be blank.
• first non blank line after first line of docstring determines indentation’s amt for rest of docstring.

Question 13

Docstring good rules

Answer 13

• First line: short n concise highlighting summary n purpose.
• objects name n type info NOT needed.
• begin with capital letter n end with period.
• describe objects calling conventions, its side effects.

Question 14

how to know what a function does?

Answer 14

functionName.__doc__

Question 15

Recursive function

Answer 15

A function that calls itself to solve a smaller version of its task until a final call is made which does not require a call to itself.

Question 16

parts of recursive function:

Answer 16

1. A base case: here problem in its simplest to solve without calling itself.
2. Recursive Case: Problem here divided into subparts and calls itself with subparts and then the result is obtained by combining the result from simpler subparts.

Question 17

what error if no base case in recursive function?

Answer 17

infinite stack.

Question 18

The technique utilisez by recursion?

Answer 18

Divide n conquer.

Question 19

Base case significance:

Answer 19

It acts as a terminating condition so it doesn’t call itself infinitely.

Question 20

factorial by recursive:

Answer 20

Base case: if n==0 or n ==1:
return 1
Recursive case: factorial = n * factorial (n-1)

Question 21

Greatest common denominator by recursive:

Answer 21

return b, if a%b==0

GCD( b , a%b )

Question 22

Exponent ( x, y ) by recursive:

Answer 22

if n == 0, return 1
else:
x*exp(x,y-1)

Question 23

The Fibonacci Series:

Answer 23

if n <2: return 1
return fib(n-1)+fib(n-2)

then use for i in range: print fib(i) to print out the series.

Question 24

Recursion Vs Iteration

approach type:

Answer 24

R is a top-down, original problem divided in smaller problems.
Itr is bottom-up.

Question 25

Recursion economics

Answer 25

1. require substantial amt of run-time overload.
2. In recursive function during execution before moving to smaller parameter, all the information ( original parameters, local variables, return address of calling function ) are stored on the SYSTEM STACK.
3. So time is required to first push the information on the stack and then again to retrieve the stored information on the stack when control passes back to calling function.

Question 26

Recursive Pros

Answer 26

1. recursive solutions tend to be simpler.
2. The code is neat to use.
3. uses the original formula to solve.
4. follows divide n conquer.
5. some (limited) instances recursion may be more efficient.

Question 27

Recursion Cons:

Answer 27

1. Some programmes find it hard to grasp.
2. System stack is used which is limited and deeper level recursion will be difficult to implement.
3. Aborting it in midstream slow and nasty.
4. difficult to find bugs particularly when using global variables.

Question 28

Good programming practices:

Answer 28

1. 4 spaces instead of tabs.
2. insert blank lines to separate functions and classes, and statements blocks inside functions.
3. Wherever required, use comments to explain the function.
4. use docstrings that explain the purpose of the function.
5. use spaces around operators and commas.
6. name of the class should be like ‘ ClassName ‘
7. name of the function should be lowercase with underscores to separate words.
8. Don’t use non-ASCII chars in function names or any other identifier.

Question 29

Module

Answer 29

a file with .py extension, that has definitions of all functions and variables that might be used in other programs.
pre-written pieces of code that are used to perform common tasks like generating random numbers..etc.

Question 30

How to use the module and access its functions?

Answer 30

add in ur first line of the program:
import module_name
to access var:
module_name.var

Question 31

sys significance:

Answer 31

functionality related to its interpreter and its environment.

Question 32

sys.path and where to save modules?

Answer 32

directories ka address, python first checks in current working directory and then in these directories to import module.
If u want the module to be available to other programs as well then save it in the directory specified by PYTHONPATH, or store in python installation lib directory.

Question 33

.pyc and ways to make it

Answer 33

compiled version of the module, created after loading once.

reload() function can force to create new .pyc

Question 34

the from.. import statement

Answer 34

to import >1 item from module_name use ‘ , ‘.

from module_name import item1, item2

to import all:
from sys import*
- * does not include private identifiers ( ones starting with ' \_\_ ' )
(this use creates confusion in variables in ur code with vars in external module so void it)

Question 35

import item1 but give it diff name to use:

Answer 35

from math import sqrt as square_root

Question 36

Pass command line arguments:

Answer 36

import sys
print(sys.argv)

go to the command prompt
C:\Python34> python main.py Hello World

Output
[‘main.py’ , ‘Hello’, ‘World’]
——————————————————————–
a = int( sys.argv[1] ); b = int( sys.argv [2] )

Question 37

Exit python using sys module:

Answer 37

sys.exit()

the argument is optional, can be int giving exit status or another type of object. zero implies successful termination and non zero doesn’t.

Question 38

Name of Module

Answer 38

print(__name__)
to get the name of the current module, usually, __main__ is the name for every standalone program written by user.
and they named by lowercase and _ to separate

Question 39

Making your own Modules

Answer 39

Every python program ( file tht u save as .py ) is a module.

recall storing modules to avoid ImportError.

Question 40

dir() function:

Answer 40

A built-in function that lists the identifiers defined in a module. identifiers include : function, classes, variables.
Synatax:
»>dir(Module_name)
if used in a file and no argument passed then works on file. ( u get __doc__ , __file__ , __package__ , __builtins__ , __name__ along with the one defined in module. )

Question 41

The python Module:

Answer 41

Main module has a special name __main__ which imports any number of modules but it cannot be imported to other modules.

Question 42

Modules and Namespaces:

Answer 42

A namespace is a container that provides a named context for identifiers.
- Avoid potential name clashes by associating identifiers with namespace from which it origins.
——————————————————–
module_name.identifierName

Question 43

how many Namespaces are there and who are they and describe them?

Answer 43

3
Local : currently executing function.
Global : Identifiers of currently executing module.
Built-in : Contains names of all builtin functions, constants..etc already defined in python.

Question 44

Module private variables:

Answer 44

All identifiers are public by default ( accessed by importing modules).
(__): Identifiers who start with 2 underscores are private, not accessed from outside module.

Question 45

Advantages of Module:

Answer 45

• benefits of modular design
• Reusability of code
• std lib which contains a set of modules allows u to logically organize the code so that it becomes easier to use and understand.

Question 46

module keypoints:

Answer 46

1. loaded once even if imported more.
2. module can import other modules.
3. not mandatory to place all import statements on top.

Question 47

Packages are what? its rules?

Answer 47

A hierarchical file directory structure tht has modules and other packages in it.
Every package is a directory which must have a special file called __init__.py
that file may not have a single line of code, but its there to indicate its not ordinary and contains python package.

Question 48

what makes a directory diff from package?

Answer 48

Every package is a directory which must have a special file called __init__.py
that file may not have a single line of code, but its there to indicate its not ordinary and contains python package.

Question 49

Importing package:

Answer 49

import Package.Module

OR

from Package import Module

Question 50

__init__.py file

Answer 50

• It may be used to execute initialisation.
• ## Determines which modules the package exports as the API ( application program interface ), while keeping other modules internal, by overriding the __all__ variables__init__.py
  __all__ = [“Module”]

Question 51

Where to store package?

Answer 51

in paths specified by sys.path

Question 52

__path__ attribute associated with package:

Answer 52

Initialised with a list having name of directory holding the package. Can be modified to change the future searches for modules and sub-packages stored in it.
Allows package in multiple directories.

Question 53

import item.subitem.subitem

Answer 53

item : package
on its right can be a subpackage or submodules
on its right the function name (optional)

Question 54

__all__

Answer 54

A list defined in package, it is taken to be the list of module names that should be imported when from package import * is encountered.

Question 55

Standard library Modules:

Answer 55

Pre-Installed modules. Some written in python and some written in C.
string, re, datetime, math, random, os, multiprocessing, subprocess, socket, email, json, doctest, unitest, pdb, argparse, sys.

Question 56

3 types of modules:

Answer 56

1. Written by user.
2. Installed from external sources.
3. pre-installed in python.

Question 57

locals()

Answer 57

called within a function, returns names tht can be accessed locally from that function.

Returns names using dictionary, names can be extracted using keys() function.

Question 58

globals()

Answer 58

called within a function, return all the names accessed globally from that function.

Returns names using dictionary, names can be extracted using keys() function.

Question 59

Reload()

Answer 59

reload ( module_name)

to re execute top level code in module, as module is executed only once.
- Imports a module that was previously imported.

Question 60

Function Redefinition:

Answer 60

x = 5.6
:
x = ‘Hello’
Just like we redefine variables, functions can be redefined as well.

Question 61

Scope of variable

Answer 61

Part of program in which var is accessible

Question 62

Lifetime of variable:

Answer 62

Duration for which it is accessible.