From 150f2ab9a62628632722bd53e5b3f8c371c74a5f Mon Sep 17 00:00:00 2001 From: daskamalini85 <105573319+daskamalini85@users.noreply.github.com> Date: Wed, 5 Oct 2022 21:29:42 +0530 Subject: [PATCH 1/9] Create Python Functions --- Python Functions | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Python Functions diff --git a/Python Functions b/Python Functions new file mode 100644 index 0000000..ceb4a0e --- /dev/null +++ b/Python Functions @@ -0,0 +1,13 @@ +├── Python +│ ├── Functions in Python (add code and documentation within the new loops in python sub-folder. +│ │ ├── functions.py (Python file showing working of Functions) +| | |-------Python Functions is a block of statements that return the specific task. +| | |-------Syntax: Python Functions +| | |-------def function_name(parameters) +| | | #statement +| | | return expression +| | | +| | | +| | | +| | ├── functions.md (Markdown file for documentation on how your code works) +│ ├── Python.md (Leave this file intact) From 3ed8b44eb6fc3d7002ab33675ac272e936209763 Mon Sep 17 00:00:00 2001 From: daskamalini85 <105573319+daskamalini85@users.noreply.github.com> Date: Sat, 8 Oct 2022 12:32:16 +0530 Subject: [PATCH 2/9] Update Python Functions --- Python Functions | 282 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 275 insertions(+), 7 deletions(-) diff --git a/Python Functions b/Python Functions index ceb4a0e..2798418 100644 --- a/Python Functions +++ b/Python Functions @@ -1,13 +1,281 @@ ├── Python │ ├── Functions in Python (add code and documentation within the new loops in python sub-folder. │ │ ├── functions.py (Python file showing working of Functions) -| | |-------Python Functions is a block of statements that return the specific task. -| | |-------Syntax: Python Functions -| | |-------def function_name(parameters) -| | | #statement -| | | return expression -| | | -| | | + Python Functions is a block of statements that return the specific task. + Syntax: Python Functions + def function_name(parameters) + #statement + return expression + Creating a python function + We can create a python function using def keyword + # A simple Python function + + def fun(): + print("Welcome to GFG") + Calling a Python Function + After creating a function we can call it by using the name of the function followed by parenthesis containing parameters of that particular function. + # A simple Python function + def fun(): + print("Welcome to GFG") + + + # Driver code to call a function + fun() + #Output + Welcome to GFG + Defining and calling a function with parameters + Syntax: Python Function with parameters + + def function_name(parameter: data_type) -> return_type: + """Doctring""" + # body of the function + return expression + #Example + def add(num1: int, num2: int) -> int: + """Add two numbers""" + num3 = num1 + num2 + + return num3 + # Driver code + num1, num2 = 5, 15 + ans = add(num1, num2) + print(f"The addition of {num1} and {num2} results {ans}.") + #Output + The addition of 5 and 15 results 20 + #More Examples + # some more functions + def is_prime(n): + if n in [2, 3]: + return True + if (n == 1) or (n % 2 == 0): + return False + r = 3 + while r * r <= n: + if n % r == 0: + return False + r += 2 + return True + print(is_prime(78), is_prime(79)) + #output + False True + Arguments of a Python Function + In this example, we will create a simple function to check whether the number passed as an argument to the function is even or odd. + # A simple Python function to check + # whether x is even or odd + + + def evenOdd(x): + if (x % 2 == 0): + print("even") + else: + print("odd") + + + # Driver code to call the function + evenOdd(2) + evenOdd(3) + #Output + even + odd + #Types of Arguments + Python supports various types of arguments that can be passed at the time of the function call. + Default arguments + # Python program to demonstrate + # default arguments + + + def myFun(x, y=50): + print("x: ", x) + print("y: ", y) + + + # Driver code (We call myFun() with only + # argument) + myFun(10) + Output + x: 10 + y: 50 + Keyword arguments + The idea is to allow the caller to specify the argument name with values so that caller does not need to remember the order of parameters. + + + # Python program to demonstrate Keyword Arguments + def student(firstname, lastname): + print(firstname, lastname) + + + # Keyword arguments + student(firstname='Kamalini', lastname='Das') + student(lastname='Das', firstname='Kamalini') + #Output + Kamalini Das + Kamalini Das + #Example 1: Variable length non-keywords argument + + + # Python program to illustrate + # *args for variable number of arguments + + + def myFun(*argv): + for arg in argv: + print(arg) + + + myFun('Hello', 'Welcome', 'to', 'Hacktoberfest') + Output + Hello + Welcome + to + Hacktoberfest + Example 2: Variable length keyword arguments + + + # Python program to illustrate + # *kwargs for variable number of keyword arguments + + + def myFun(**kwargs): + for key, value in kwargs.items(): + print("%s == %s" % (key, value)) + + + # Driver code + myFun(first='Welcome', mid='to', last='Hacktoberfest') + #Output + first == Welcome + mid == to + last == Hacktoberfest + Docstring + The below syntax can be used to print out the docstring of a function: + + Syntax: print(function_name.__doc__) + Example: Adding Docstring to the function + + + # A simple Python function to check + # whether x is even or odd + + + def evenOdd(x): + """Function to check if the number is even or odd""" + + if (x % 2 == 0): + print("even") + else: + print("odd") + + + # Driver code to call the function + print(evenOdd.__doc__) + #Output + Function to check if the number is even or odd + #Return statement in Python function + Syntax: + + return [expression_list] + Example: Python Function Return Statement + + + def square_value(num): + """This function returns the square + value of the entered number""" + return num**2 + + + print(square_value(2)) + print(square_value(-4)) + #Output + 4 + 16 + #Pass by Reference or pass by value + # Here x is a new reference to same list lst + def myFun(x): + x[0] = 20 + + + # Driver Code (Note that lst is modified + # after function call. + lst = [10, 11, 12, 13, 14, 15] + myFun(lst) + print(lst) + #Output + [20, 11, 12, 13, 14, 15] + ##When we pass a reference and change the received reference to something else, the connection between the passed and received parameter is broken. For example, consider the below program as follows: + + + def myFun(x): + + # After below line link of x with previous + # object gets broken. A new object is assigned + # to x. + x = [20, 30, 40] + + + # Driver Code (Note that lst is not modified + # after function call. + lst = [10, 11, 12, 13, 14, 15] + myFun(lst) + print(lst) + Output + [10, 11, 12, 13, 14, 15] + ##Another example to demonstrate that the reference link is broken if we assign a new value (inside the function). + + + def myFun(x): + + # After below line link of x with previous + # object gets broken. A new object is assigned + # to x. + x = 20 + + + # Driver Code (Note that lst is not modified + # after function call. + x = 10 + myFun(x) + print(x) + #Output + 10 + ##Anonymous functions in Python Function + # Python code to illustrate the cube of a number + # using lambda function + + + def cube(x): return x*x*x + + cube_v2 = lambda x : x*x*x + + print(cube(7)) + print(cube_v2(7)) + #Output + 343 + 343 + ##Python Function within Functions + # Python program to + # demonstrate accessing of + # variables of nested functions + + def f1(): + s = 'I love Open Source' + + def f2(): + print(s) + + f2() + + # Driver's code + f1() + #Output + I love Open Source + + + + + + + + | | | | | ├── functions.md (Markdown file for documentation on how your code works) │ ├── Python.md (Leave this file intact) From c3a10a965e6909373783da0e72319f3903341331 Mon Sep 17 00:00:00 2001 From: daskamalini85 <105573319+daskamalini85@users.noreply.github.com> Date: Sun, 9 Oct 2022 11:45:03 +0530 Subject: [PATCH 3/9] Update Python Functions --- Python Functions | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/Python Functions b/Python Functions index 2798418..97a7ca9 100644 --- a/Python Functions +++ b/Python Functions @@ -278,4 +278,12 @@ | | | | | ├── functions.md (Markdown file for documentation on how your code works) + The idea is to put some commonly or repeatedly done tasks together and make a function so that instead of writing the same code again and again for different inputs, we can do the function calls to reuse code contained in it over and over again. + We can use return type of the function and data type of the arguments in python. + #Arguments of a Python Function + Arguments are the values passed inside the parenthesis of the function. A function can have any number of arguments separated by a comma. + Types of Arguments + Python supports various types of arguments that can be passed at the time of the function call. + Default arguments + A default argument is a parameter that assumes a default value if a value is not provided in the function call for that argument. │ ├── Python.md (Leave this file intact) From e171dbf54f318df01900cdac9c3df5c24ff9c857 Mon Sep 17 00:00:00 2001 From: daskamalini85 <105573319+daskamalini85@users.noreply.github.com> Date: Sun, 9 Oct 2022 12:57:00 +0530 Subject: [PATCH 4/9] Update Python Functions --- Python Functions | 273 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 272 insertions(+), 1 deletion(-) diff --git a/Python Functions b/Python Functions index 97a7ca9..7657145 100644 --- a/Python Functions +++ b/Python Functions @@ -268,6 +268,18 @@ f1() #Output I love Open Source + Example of a user-defined function + # Program to illustrate + # the use of user-defined functions + + def add_numbers(x,y): + sum = x + y + return sum + + num1 = 5 + num2 = 6 + + print("The sum is", add_numbers(num1, num2)) @@ -279,11 +291,270 @@ | | | | | ├── functions.md (Markdown file for documentation on how your code works) The idea is to put some commonly or repeatedly done tasks together and make a function so that instead of writing the same code again and again for different inputs, we can do the function calls to reuse code contained in it over and over again. + A python function consists of the following functions: + 1.Keyword def that marks the start of the function header. + 2.A function name to uniquely identify the function. Function naming follows the same rules of writing identifiers in Python. + 3.Parameters (arguments) through which we pass values to a function. They are optional. + 4.A colon (:) to mark the end of the function header. + 5.Optional documentation string (docstring) to describe what the function does. + 6.One or more valid python statements that make up the function body. Statements must have the same indentation level (usually 4 spaces). + 7.An optional return statement to return a value from the function. + How to call a function in python? + Once we have defined a function, we can call it from another function, program, or even the Python prompt. To call a function we simply type the function name with appropriate parameters. + Note: In python, the function definition should always be present before the function call. Otherwise, we will get an error. + We can use return type of the function and data type of the arguments in python. #Arguments of a Python Function Arguments are the values passed inside the parenthesis of the function. A function can have any number of arguments separated by a comma. Types of Arguments Python supports various types of arguments that can be passed at the time of the function call. Default arguments - A default argument is a parameter that assumes a default value if a value is not provided in the function call for that argument. + A default argument is a parameter that assumes a default value if a value is not provided in the function call for that argument. + any number of arguments in a function can have a default value. But once we have a default argument, all the arguments to its right must also have default values. + Keyword arguments + The idea is to allow the caller to specify the argument name with values so that caller does not need to remember the order of parameters. + Variable-length arguments + In Python, we can pass a variable number of arguments to a function using special symbols. There are two special symbols: + + *args (Non-Keyword Arguments) + **kwargs (Keyword Arguments) + Docstring + The first string after the function is called the Document string or Docstring in short. This is used to describe the functionality of the function. The use of docstring in functions is optional but it is considered a good practice. + Unless you can remember what you had for dinner last week, always document your code.We generally use triple quotes so that docstring can extend up to multiple lines. This string is available to us as the __doc__ attribute of the function. + Scope and Lifetime of variables + Scope of a variable is the portion of a program where the variable is recognized. Parameters and variables defined inside a function are not visible from outside the function. Hence, they have a local scope.The lifetime of a variable is the period throughout which the variable exists in the memory. + The lifetime of variables inside a function is as long as the function executes. + They are destroyed once we return from the function. Hence, a function does not remember the value of a variable from its previous calls. + On the other hand, variables outside of the function are visible from inside. They have a global scope. + We can read these values from inside the function but cannot change (write) them. In order to modify the value of variables outside the function, they must be declared as global variables using the keyword global. + Return statement in Python function + The function return statement is used to exit from a function and go back to the function caller and return the specified value or data item to the caller. + The return statement can consist of a variable, an expression, or a constant which is returned to the end of the function execution. If none of the above is present with the return statement a None object is returned. + Pass by Reference or pass by value + One important thing to note is, in Python every variable name is a reference. When we pass a variable to a function, a new reference to the object is created. + When we pass a reference and change the received reference to something else, the connection between the passed and received parameter is broken. + Anonymous functions in Python Function + In Python, an anonymous function means that a function is without a name. As we already know the def keyword is used to define the normal functions and the lambda keyword is used to create anonymous functions. + Python Function within Functions + A function that is defined inside another function is known as the inner function or nested function. Nested functions are able to access variables of the enclosing scope. Inner functions are used so that they can be protected from everything happening outside the function. + Python Built-in Functions + Python has several functions that are readily available for use. These functions are called built-in functions. + Python abs() + returns absolute value of a number + + Python all() + returns true when all elements in iterable is true + + Python any() + Checks if any Element of an Iterable is True + + Python ascii() + Returns String Containing Printable Representation + + Python bin() + converts integer to binary string + + Python bool() + Converts a Value to Boolean + + Python bytearray() + returns array of given byte size + + Python bytes() + returns immutable bytes object + + Python callable() + Checks if the Object is Callable + + Python chr() + Returns a Character (a string) from an Integer + + Python classmethod() + returns class method for given function + + Python compile() + Returns a Python code object + + Python complex() + Creates a Complex Number + + Python delattr() + Deletes Attribute From the Object + + Python dict() + Creates a Dictionary + + Python dir() + Tries to Return Attributes of Object + + Python divmod() + Returns a Tuple of Quotient and Remainder + + Python enumerate() + Returns an Enumerate Object + + Python eval() + Runs Python Code Within Program + + Python exec() + Executes Dynamically Created Program + + Python filter() + constructs iterator from elements which are true + + Python float() + returns floating point number from number, string + + Python format() + returns formatted representation of a value + + Python frozenset() + returns immutable frozenset object + + Python getattr() + returns value of named attribute of an object + + Python globals() + returns dictionary of current global symbol table + + Python hasattr() + returns whether object has named attribute + + Python hash() + returns hash value of an object + + Python help() + Invokes the built-in Help System + + Python hex() + Converts to Integer to Hexadecimal + + Python id() + Returns Identify of an Object + + Python input() + reads and returns a line of string + + Python int() + returns integer from a number or string + + Python isinstance() + Checks if a Object is an Instance of Class + + Python issubclass() + Checks if a Class is Subclass of another Class + + Python iter() + returns an iterator + + Python len() + Returns Length of an Object + + Python list() + creates a list in Python + + Python locals() + Returns dictionary of a current local symbol table + + Python map() + Applies Function and Returns a List + + Python max() + returns the largest item + + Python memoryview() + returns memory view of an argument + + Python min() + returns the smallest value + + Python next() + Retrieves next item from the iterator + + Python object() + creates a featureless object + + Python oct() + returns the octal representation of an integer + + Python open() + Returns a file object + + Python ord() + returns an integer of the Unicode character + + Python pow() + returns the power of a number + + Python print() + Prints the Given Object + + Python property() + returns the property attribute + + Python range() + returns a sequence of integers + + Python repr() + returns a printable representation of the object + + Python reversed() + returns the reversed iterator of a sequence + + Python round() + rounds a number to specified decimals + + Python set() + constructs and returns a set + + Python setattr() + sets the value of an attribute of an object + + Python slice() + returns a slice object + + Python sorted() + returns a sorted list from the given iterable + + Python staticmethod() + transforms a method into a static method + + Python str() + returns the string version of the object + + Python sum() + Adds items of an Iterable + + Python super() + Returns a proxy object of the base class + + Python tuple() + Returns a tuple + + Python type() + Returns the type of the object + + Python vars() + Returns the __dict__ attribute + + Python zip() + Returns an iterator of tuples + + Python __import__() + Function called by the import statement + ##What are user-defined functions in Python? + Functions that we define ourselves to do certain specific task are referred as user-defined functions. The way in which we define and call functions in Python are already discussed. + + Functions that readily come with Python are called built-in functions. If we use functions written by others in the form of library, it can be termed as library functions. + + All the other functions that we write on our own fall under user-defined functions. So, our user-defined function could be a library function to someone else. + + Advantages of user-defined functions + User-defined functions help to decompose a large program into small segments which makes program easy to understand, maintain and debug. + If repeated code occurs in a program. Function can be used to include those codes and execute when needed by calling that function. + Programmars working on large project can divide the workload by making different functions. + + + + │ ├── Python.md (Leave this file intact) From 9dd83442b1a1b4451c70020c37ac59adbd2ab0ed Mon Sep 17 00:00:00 2001 From: daskamalini85 <105573319+daskamalini85@users.noreply.github.com> Date: Tue, 11 Oct 2022 23:51:20 +0530 Subject: [PATCH 5/9] Update Python Functions --- Python Functions | 104 +++++++++++++++++++++++++++++++---------------- 1 file changed, 68 insertions(+), 36 deletions(-) diff --git a/Python Functions b/Python Functions index 7657145..d9b452e 100644 --- a/Python Functions +++ b/Python Functions @@ -1,30 +1,33 @@ ├── Python │ ├── Functions in Python (add code and documentation within the new loops in python sub-folder. │ │ ├── functions.py (Python file showing working of Functions) - Python Functions is a block of statements that return the specific task. - Syntax: Python Functions +| | | Python Functions is a block of statements that return the specific task. + ##Syntax: Python Functions def function_name(parameters) #statement return expression - Creating a python function + + ##Creating a python function We can create a python function using def keyword # A simple Python function def fun(): - print("Welcome to GFG") - Calling a Python Function + print("Welcome to Hacktoberfest") + + ##Calling a Python Function After creating a function we can call it by using the name of the function followed by parenthesis containing parameters of that particular function. # A simple Python function def fun(): - print("Welcome to GFG") + print("Welcome to Hacktoberfest") # Driver code to call a function fun() #Output - Welcome to GFG - Defining and calling a function with parameters - Syntax: Python Function with parameters + Welcome to Hacktoberfest + + ##Defining and calling a function with parameters + #Syntax: Python Function with parameters def function_name(parameter: data_type) -> return_type: """Doctring""" @@ -42,8 +45,9 @@ print(f"The addition of {num1} and {num2} results {ans}.") #Output The addition of 5 and 15 results 20 - #More Examples - # some more functions + + ##More Examples + #some more functions def is_prime(n): if n in [2, 3]: return True @@ -58,7 +62,8 @@ print(is_prime(78), is_prime(79)) #output False True - Arguments of a Python Function + + ##Arguments of a Python Function In this example, we will create a simple function to check whether the number passed as an argument to the function is even or odd. # A simple Python function to check # whether x is even or odd @@ -77,8 +82,10 @@ #Output even odd + #Types of Arguments Python supports various types of arguments that can be passed at the time of the function call. + Default arguments # Python program to demonstrate # default arguments @@ -95,6 +102,7 @@ Output x: 10 y: 50 + Keyword arguments The idea is to allow the caller to specify the argument name with values so that caller does not need to remember the order of parameters. @@ -110,6 +118,7 @@ #Output Kamalini Das Kamalini Das + #Example 1: Variable length non-keywords argument @@ -128,7 +137,8 @@ Welcome to Hacktoberfest - Example 2: Variable length keyword arguments + + #Example 2: Variable length keyword arguments # Python program to illustrate @@ -146,7 +156,8 @@ first == Welcome mid == to last == Hacktoberfest - Docstring + + #Docstring The below syntax can be used to print out the docstring of a function: Syntax: print(function_name.__doc__) @@ -169,12 +180,13 @@ # Driver code to call the function print(evenOdd.__doc__) #Output - Function to check if the number is even or odd + Function to check if the number is even or odd + #Return statement in Python function Syntax: return [expression_list] - Example: Python Function Return Statement + #Example: Python Function Return Statement def square_value(num): @@ -188,19 +200,21 @@ #Output 4 16 - #Pass by Reference or pass by value + + ##Pass by Reference or pass by value # Here x is a new reference to same list lst def myFun(x): x[0] = 20 # Driver Code (Note that lst is modified - # after function call. + # after function call.) lst = [10, 11, 12, 13, 14, 15] myFun(lst) print(lst) #Output [20, 11, 12, 13, 14, 15] + ##When we pass a reference and change the received reference to something else, the connection between the passed and received parameter is broken. For example, consider the below program as follows: @@ -213,12 +227,13 @@ # Driver Code (Note that lst is not modified - # after function call. + # after function call.) lst = [10, 11, 12, 13, 14, 15] myFun(lst) print(lst) Output [10, 11, 12, 13, 14, 15] + ##Another example to demonstrate that the reference link is broken if we assign a new value (inside the function). @@ -237,6 +252,7 @@ print(x) #Output 10 + ##Anonymous functions in Python Function # Python code to illustrate the cube of a number # using lambda function @@ -251,6 +267,7 @@ #Output 343 343 + ##Python Function within Functions # Python program to # demonstrate accessing of @@ -268,7 +285,8 @@ f1() #Output I love Open Source - Example of a user-defined function + + ##Example of a user-defined function # Program to illustrate # the use of user-defined functions @@ -280,7 +298,8 @@ num2 = 6 print("The sum is", add_numbers(num1, num2)) - + #output + The sum is 11 @@ -291,7 +310,7 @@ | | | | | ├── functions.md (Markdown file for documentation on how your code works) The idea is to put some commonly or repeatedly done tasks together and make a function so that instead of writing the same code again and again for different inputs, we can do the function calls to reuse code contained in it over and over again. - A python function consists of the following functions: + A python function consists of the following features: 1.Keyword def that marks the start of the function header. 2.A function name to uniquely identify the function. Function naming follows the same rules of writing identifiers in Python. 3.Parameters (arguments) through which we pass values to a function. They are optional. @@ -299,45 +318,57 @@ 5.Optional documentation string (docstring) to describe what the function does. 6.One or more valid python statements that make up the function body. Statements must have the same indentation level (usually 4 spaces). 7.An optional return statement to return a value from the function. - How to call a function in python? + + ##How to call a function in python? Once we have defined a function, we can call it from another function, program, or even the Python prompt. To call a function we simply type the function name with appropriate parameters. Note: In python, the function definition should always be present before the function call. Otherwise, we will get an error. We can use return type of the function and data type of the arguments in python. - #Arguments of a Python Function + ##Arguments of a Python Function Arguments are the values passed inside the parenthesis of the function. A function can have any number of arguments separated by a comma. - Types of Arguments + + #Types of Arguments Python supports various types of arguments that can be passed at the time of the function call. - Default arguments + + #Default arguments A default argument is a parameter that assumes a default value if a value is not provided in the function call for that argument. any number of arguments in a function can have a default value. But once we have a default argument, all the arguments to its right must also have default values. - Keyword arguments + + #Keyword arguments The idea is to allow the caller to specify the argument name with values so that caller does not need to remember the order of parameters. - Variable-length arguments + + #Variable-length arguments In Python, we can pass a variable number of arguments to a function using special symbols. There are two special symbols: *args (Non-Keyword Arguments) **kwargs (Keyword Arguments) - Docstring + + ##Docstring The first string after the function is called the Document string or Docstring in short. This is used to describe the functionality of the function. The use of docstring in functions is optional but it is considered a good practice. Unless you can remember what you had for dinner last week, always document your code.We generally use triple quotes so that docstring can extend up to multiple lines. This string is available to us as the __doc__ attribute of the function. - Scope and Lifetime of variables + + ##Scope and Lifetime of variables Scope of a variable is the portion of a program where the variable is recognized. Parameters and variables defined inside a function are not visible from outside the function. Hence, they have a local scope.The lifetime of a variable is the period throughout which the variable exists in the memory. The lifetime of variables inside a function is as long as the function executes. They are destroyed once we return from the function. Hence, a function does not remember the value of a variable from its previous calls. On the other hand, variables outside of the function are visible from inside. They have a global scope. We can read these values from inside the function but cannot change (write) them. In order to modify the value of variables outside the function, they must be declared as global variables using the keyword global. - Return statement in Python function + + ##Return statement in Python function The function return statement is used to exit from a function and go back to the function caller and return the specified value or data item to the caller. The return statement can consist of a variable, an expression, or a constant which is returned to the end of the function execution. If none of the above is present with the return statement a None object is returned. - Pass by Reference or pass by value + + ##Pass by Reference or pass by value One important thing to note is, in Python every variable name is a reference. When we pass a variable to a function, a new reference to the object is created. When we pass a reference and change the received reference to something else, the connection between the passed and received parameter is broken. - Anonymous functions in Python Function + + ##Anonymous functions in Python Function In Python, an anonymous function means that a function is without a name. As we already know the def keyword is used to define the normal functions and the lambda keyword is used to create anonymous functions. - Python Function within Functions + + ##Python Function within Functions A function that is defined inside another function is known as the inner function or nested function. Nested functions are able to access variables of the enclosing scope. Inner functions are used so that they can be protected from everything happening outside the function. - Python Built-in Functions + + ##Python Built-in Functions Python has several functions that are readily available for use. These functions are called built-in functions. Python abs() returns absolute value of a number @@ -542,6 +573,7 @@ Python __import__() Function called by the import statement + ##What are user-defined functions in Python? Functions that we define ourselves to do certain specific task are referred as user-defined functions. The way in which we define and call functions in Python are already discussed. @@ -549,7 +581,7 @@ All the other functions that we write on our own fall under user-defined functions. So, our user-defined function could be a library function to someone else. - Advantages of user-defined functions + #Advantages of user-defined functions User-defined functions help to decompose a large program into small segments which makes program easy to understand, maintain and debug. If repeated code occurs in a program. Function can be used to include those codes and execute when needed by calling that function. Programmars working on large project can divide the workload by making different functions. From 9778f5cf77b809527b79d6ef345da0b7631eda3b Mon Sep 17 00:00:00 2001 From: daskamalini85 <105573319+daskamalini85@users.noreply.github.com> Date: Thu, 13 Oct 2022 21:27:43 +0530 Subject: [PATCH 6/9] Update Python Functions --- Python Functions | 264 +++++++++++++++++++++++------------------------ 1 file changed, 127 insertions(+), 137 deletions(-) diff --git a/Python Functions b/Python Functions index d9b452e..6be3a62 100644 --- a/Python Functions +++ b/Python Functions @@ -2,133 +2,133 @@ │ ├── Functions in Python (add code and documentation within the new loops in python sub-folder. │ │ ├── functions.py (Python file showing working of Functions) | | | Python Functions is a block of statements that return the specific task. - ##Syntax: Python Functions - def function_name(parameters) - #statement - return expression - - ##Creating a python function - We can create a python function using def keyword - # A simple Python function - - def fun(): - print("Welcome to Hacktoberfest") - - ##Calling a Python Function - After creating a function we can call it by using the name of the function followed by parenthesis containing parameters of that particular function. - # A simple Python function - def fun(): - print("Welcome to Hacktoberfest") - - - # Driver code to call a function - fun() - #Output - Welcome to Hacktoberfest - - ##Defining and calling a function with parameters - #Syntax: Python Function with parameters - - def function_name(parameter: data_type) -> return_type: - """Doctring""" - # body of the function - return expression - #Example - def add(num1: int, num2: int) -> int: - """Add two numbers""" - num3 = num1 + num2 - - return num3 - # Driver code - num1, num2 = 5, 15 - ans = add(num1, num2) - print(f"The addition of {num1} and {num2} results {ans}.") - #Output - The addition of 5 and 15 results 20 - - ##More Examples - #some more functions - def is_prime(n): - if n in [2, 3]: - return True - if (n == 1) or (n % 2 == 0): - return False - r = 3 - while r * r <= n: - if n % r == 0: - return False - r += 2 - return True - print(is_prime(78), is_prime(79)) - #output - False True - - ##Arguments of a Python Function - In this example, we will create a simple function to check whether the number passed as an argument to the function is even or odd. - # A simple Python function to check - # whether x is even or odd - - - def evenOdd(x): - if (x % 2 == 0): - print("even") - else: - print("odd") - - - # Driver code to call the function - evenOdd(2) - evenOdd(3) - #Output - even - odd - - #Types of Arguments - Python supports various types of arguments that can be passed at the time of the function call. - - Default arguments - # Python program to demonstrate - # default arguments - - - def myFun(x, y=50): - print("x: ", x) - print("y: ", y) - - - # Driver code (We call myFun() with only - # argument) - myFun(10) - Output - x: 10 - y: 50 - - Keyword arguments - The idea is to allow the caller to specify the argument name with values so that caller does not need to remember the order of parameters. - - - # Python program to demonstrate Keyword Arguments - def student(firstname, lastname): - print(firstname, lastname) - - - # Keyword arguments - student(firstname='Kamalini', lastname='Das') - student(lastname='Das', firstname='Kamalini') - #Output - Kamalini Das - Kamalini Das - - #Example 1: Variable length non-keywords argument - - - # Python program to illustrate - # *args for variable number of arguments - - - def myFun(*argv): - for arg in argv: - print(arg) +| | | ##Syntax: Python Functions +| | | def function_name(parameters) +| | | #statement +| | | return expression +| | | +| | | ##Creating a python function +| | | We can create a python function using def keyword +| | | # A simple Python function +| | | +| | | def fun(): +| | | print("Welcome to Hacktoberfest") +| | | +| | | ##Calling a Python Function +| | | After creating a function we can call it by using the name of the function followed by parenthesis containing parameters of that particular function. +| | | # A simple Python function +| | | def fun(): +| | | print("Welcome to Hacktoberfest") +| | | +| | | +| | | # Driver code to call a function +| | | fun() +| | | #Output +| | | Welcome to Hacktoberfest +| | | +| | | ##Defining and calling a function with parameters +| | | #Syntax: Python Function with parameters +| | | +| | | def function_name(parameter: data_type) -> return_type: +| | | """Doctring""" +| | | # body of the function +| | | return expression +| | | #Example +| | | def add(num1: int, num2: int) -> int: +| | | """Add two numbers""" +| | | num3 = num1 + num2 +| | | +| | | return num3 +| | | # Driver code +| | | num1, num2 = 5, 15 +| | | ans = add(num1, num2) +| | | print(f"The addition of {num1} and {num2} results {ans}.") +| | | #Output +| | | The addition of 5 and 15 results 20 +| | | +| | | ##More Examples +| | | #some more functions +| | | def is_prime(n): +| | | if n in [2, 3]: +| | | return True +| | | if (n == 1) or (n % 2 == 0): +| | | return False +| | | r = 3 +| | | while r * r <= n: +| | | if n % r == 0: +| | | return False +| | | r += 2 +| | | return True +| | | print(is_prime(78), is_prime(79)) +| | | #output +| | | False True +| | | +| | | ##Arguments of a Python Function +| | | In this example, we will create a simple function to check whether the number passed as an argument to the function is even or odd. +| | | # A simple Python function to check +| | | # whether x is even or odd +| | | +| | | +| | | def evenOdd(x): +| | | if (x % 2 == 0): +| | | print("even") +| | | else: +| | | print("odd") +| | | +| | | +| | | # Driver code to call the function +| | | evenOdd(2) +| | | evenOdd(3) +| | | #Output +| | | even +| | | odd +| | | +| | | ##Types of Arguments +| | | Python supports various types of arguments that can be passed at the time of the function call. +| | | +| | | Default arguments +| | | # Python program to demonstrate +| | | # default arguments +| | | +| | | +| | | def myFun(x, y=50): +| | | print("x: ", x) +| | | print("y: ", y) +| | | +| | | +| | | # Driver code (We call myFun() with only +| | | # argument) +| | | myFun(10) +| | | Output +| | | x: 10 +| | | y: 50 +| | | +| | | Keyword arguments +| | | The idea is to allow the caller to specify the argument name with values so that caller does not need to remember the order of parameters. +| | | +| | | +| | | # Python program to demonstrate Keyword Arguments +| | | def student(firstname, lastname): +| | | print(firstname, lastname) +| | | +| | | +| | | # Keyword arguments +| | | student(firstname='Kamalini', lastname='Das') +| | | student(lastname='Das', firstname='Kamalini') +| | | #Output +| | | Kamalini Das +| | | Kamalini Das +| | | +| | | #Example 1: Variable length non-keywords argument +| | | +| | | +| | | # Python program to illustrate +| | | # *args for variable number of arguments +| | | +| | | +| | | def myFun(*argv): +| | | for arg in argv: +| | | print(arg) myFun('Hello', 'Welcome', 'to', 'Hacktoberfest') @@ -300,13 +300,6 @@ print("The sum is", add_numbers(num1, num2)) #output The sum is 11 - - - - - - - | | | | | ├── functions.md (Markdown file for documentation on how your code works) The idea is to put some commonly or repeatedly done tasks together and make a function so that instead of writing the same code again and again for different inputs, we can do the function calls to reuse code contained in it over and over again. @@ -586,7 +579,4 @@ If repeated code occurs in a program. Function can be used to include those codes and execute when needed by calling that function. Programmars working on large project can divide the workload by making different functions. - - - │ ├── Python.md (Leave this file intact) From 9f130699deafcb8c3d2b26e69a86b57f984fc168 Mon Sep 17 00:00:00 2001 From: daskamalini85 <105573319+daskamalini85@users.noreply.github.com> Date: Thu, 13 Oct 2022 23:49:04 +0530 Subject: [PATCH 7/9] Update Python Functions --- Python Functions | 357 ++++++++++++++++++++++++----------------------- 1 file changed, 185 insertions(+), 172 deletions(-) diff --git a/Python Functions b/Python Functions index 6be3a62..ca87a80 100644 --- a/Python Functions +++ b/Python Functions @@ -23,6 +23,7 @@ | | | | | | # Driver code to call a function | | | fun() +| | | | | | #Output | | | Welcome to Hacktoberfest | | | @@ -42,7 +43,8 @@ | | | # Driver code | | | num1, num2 = 5, 15 | | | ans = add(num1, num2) -| | | print(f"The addition of {num1} and {num2} results {ans}.") +| | | print(f"The addition of {num1} and {num2} results {ans}.") +| | | | | | #Output | | | The addition of 5 and 15 results 20 | | | @@ -60,6 +62,7 @@ | | | r += 2 | | | return True | | | print(is_prime(78), is_prime(79)) +| | | | | | #output | | | False True | | | @@ -79,6 +82,7 @@ | | | # Driver code to call the function | | | evenOdd(2) | | | evenOdd(3) +| | | | | | #Output | | | even | | | odd @@ -99,6 +103,7 @@ | | | # Driver code (We call myFun() with only | | | # argument) | | | myFun(10) +| | | | | | Output | | | x: 10 | | | y: 50 @@ -115,6 +120,7 @@ | | | # Keyword arguments | | | student(firstname='Kamalini', lastname='Das') | | | student(lastname='Das', firstname='Kamalini') +| | | | | | #Output | | | Kamalini Das | | | Kamalini Das @@ -129,177 +135,184 @@ | | | def myFun(*argv): | | | for arg in argv: | | | print(arg) - - - myFun('Hello', 'Welcome', 'to', 'Hacktoberfest') - Output - Hello - Welcome - to - Hacktoberfest - - #Example 2: Variable length keyword arguments - - - # Python program to illustrate - # *kwargs for variable number of keyword arguments - - - def myFun(**kwargs): - for key, value in kwargs.items(): - print("%s == %s" % (key, value)) - - - # Driver code - myFun(first='Welcome', mid='to', last='Hacktoberfest') - #Output - first == Welcome - mid == to - last == Hacktoberfest - - #Docstring - The below syntax can be used to print out the docstring of a function: - - Syntax: print(function_name.__doc__) - Example: Adding Docstring to the function - - - # A simple Python function to check - # whether x is even or odd - - - def evenOdd(x): - """Function to check if the number is even or odd""" - - if (x % 2 == 0): - print("even") - else: - print("odd") - - - # Driver code to call the function - print(evenOdd.__doc__) - #Output - Function to check if the number is even or odd - - #Return statement in Python function - Syntax: - - return [expression_list] - #Example: Python Function Return Statement - - - def square_value(num): - """This function returns the square - value of the entered number""" - return num**2 - - - print(square_value(2)) - print(square_value(-4)) - #Output - 4 - 16 - - ##Pass by Reference or pass by value - # Here x is a new reference to same list lst - def myFun(x): - x[0] = 20 - - - # Driver Code (Note that lst is modified - # after function call.) - lst = [10, 11, 12, 13, 14, 15] - myFun(lst) - print(lst) - #Output - [20, 11, 12, 13, 14, 15] - - ##When we pass a reference and change the received reference to something else, the connection between the passed and received parameter is broken. For example, consider the below program as follows: - - - def myFun(x): - - # After below line link of x with previous - # object gets broken. A new object is assigned - # to x. - x = [20, 30, 40] - - - # Driver Code (Note that lst is not modified - # after function call.) - lst = [10, 11, 12, 13, 14, 15] - myFun(lst) - print(lst) - Output - [10, 11, 12, 13, 14, 15] - - ##Another example to demonstrate that the reference link is broken if we assign a new value (inside the function). - - - def myFun(x): - - # After below line link of x with previous - # object gets broken. A new object is assigned - # to x. - x = 20 - - - # Driver Code (Note that lst is not modified - # after function call. - x = 10 - myFun(x) - print(x) - #Output - 10 - - ##Anonymous functions in Python Function - # Python code to illustrate the cube of a number - # using lambda function - - - def cube(x): return x*x*x - - cube_v2 = lambda x : x*x*x - - print(cube(7)) - print(cube_v2(7)) - #Output - 343 - 343 - - ##Python Function within Functions - # Python program to - # demonstrate accessing of - # variables of nested functions - - def f1(): - s = 'I love Open Source' - - def f2(): - print(s) - - f2() - - # Driver's code - f1() - #Output - I love Open Source - - ##Example of a user-defined function - # Program to illustrate - # the use of user-defined functions - - def add_numbers(x,y): - sum = x + y - return sum - - num1 = 5 - num2 = 6 - - print("The sum is", add_numbers(num1, num2)) - #output - The sum is 11 +| | | +| | | +| | | myFun('Hello', 'Welcome', 'to', 'Hacktoberfest') +| | | +| | | #utput +| | | Hello +| | | Welcome +| | | to +| | | Hacktoberfest +| | | +| | | #Example 2: Variable length keyword arguments +| | | +| | | +| | | # Python program to illustrate +| | | # *kwargs for variable number of keyword arguments +| | | +| | | +| | | def myFun(**kwargs): +| | | for key, value in kwargs.items(): +| | | print("%s == %s" % (key, value)) +| | | +| | | +| | | # Driver code +| | | myFun(first='Welcome', mid='to', last='Hacktoberfest') +| | | +| | | #Output +| | | first == Welcome +| | | mid == to +| | | last == Hacktoberfest +| | | +| | | #Docstring +| | | The below syntax can be used to print out the docstring of a function: +| | | +| | | Syntax: print(function_name.__doc__) +| | | Example: Adding Docstring to the function +| | | +| | | +| | | # A simple Python function to check +| | | # whether x is even or odd +| | | +| | | +| | | def evenOdd(x): +| | | """Function to check if the number is even or odd""" +| | | +| | | if (x % 2 == 0): +| | | print("even") +| | | else: +| | | print("odd") +| | | +| | | +| | | # Driver code to call the function +| | | print(evenOdd.__doc__) +| | | +| | | #Output +| | | Function to check if the number is even or odd +| | | +| | | ##Return statement in python function +| | | Syntax: +| | | +| | | return [expression_list] +| | | #Example: Python Function Return Statement +| | | +| | | def square_value(num): +| | | """This function returns the square +| | | value of the entered number""" +| | | return num**2 +| | | +| | | +| | | print(square_value(2)) +| | | print(square_value(-4)) +| | | +| | | #Output +| | | 4 +| | | 16 +| | | +| | | ##Pass by Reference or pass by value +| | | # Here x is a new reference to same list lst +| | | def myFun(x): +| | | x[0] = 20 +| | | +| | | +| | | # Driver Code (Note that lst is modified +| | | # after function call.) +| | | lst = [10, 11, 12, 13, 14, 15] +| | | myFun(lst) +| | | print(lst) +| | | +| | | #Output +| | | [20, 11, 12, 13, 14, 15] +| | | +| | | ##When we pass a reference and change the received reference to something else, the connection between the passed and received parameter is broken. +| | | For example, consider the below program as follows: +| | | +| | | +| | | def myFun(x): +| | | +| | | # After below line link of x with previous +| | | # object gets broken. A new object is assigned +| | | # to x. +| | | x = [20, 30, 40] +| | | +| | | +| | | # Driver Code (Note that lst is not modified +| | | # after function call.) +| | | lst = [10, 11, 12, 13, 14, 15] +| | | myFun(lst) +| | | print(lst) +| | | +| | | Output +| | | [10, 11, 12, 13, 14, 15] +| | | +| | | ##Another example to demonstrate that the reference link is broken if we assign a new value (inside the function). +| | | +| | | +| | | def myFun(x): +| | | +| | | # After below line link of x with previous +| | | # object gets broken. A new object is assigned +| | | # to x. +| | | x = 20 +| | | +| | | +| | | # Driver Code (Note that lst is not modified +| | | # after function call. +| | | x = 10 +| | | myFun(x) +| | | print(x) +| | | +| | | #Output +| | | 10 +| | | +| | | ##Anonymous functions in Python Function +| | | # Python code to illustrate the cube of a number +| | | # using lambda function +| | | +| | | def cube(x): return x*x*x +| | | +| | | def cube(x): return x*x*x +| | | +| | | print(cube(7)) +| | | print(cube_v2(7)) +| | | +| | | #Output +| | | 343 +| | | 343 +| | | +| | | ##Python Function within Functions +| | | # Python program to +| | | # demonstrate accessing of +| | | # variables of nested functions +| | | +| | | def f1(): +| | | s = 'I love Open Source' +| | | +| | | def f2(): +| | | print(s) +| | | +| | | f2() +| | | +| | | # Driver's code +| | | f1() +| | | #Output +| | | I love Open Source +| | | +| | | #Example +| | | #Program to illustrate +| | | # the use of user-defined functions +| | | +| | | def add_numbers(x,y): +| | | sum = x + y +| | | return sum +| | | +| | | num1 = 5 +| | | num2 = 6 +| | | +| | | print("The sum is", add_numbers(num1, num2)) +| | | #output +| | | The sum is 11 | | | | | ├── functions.md (Markdown file for documentation on how your code works) The idea is to put some commonly or repeatedly done tasks together and make a function so that instead of writing the same code again and again for different inputs, we can do the function calls to reuse code contained in it over and over again. From 205f0e056c8d2491f66371042265fe70565b4575 Mon Sep 17 00:00:00 2001 From: daskamalini85 <105573319+daskamalini85@users.noreply.github.com> Date: Fri, 14 Oct 2022 10:31:18 +0530 Subject: [PATCH 8/9] Update Python Functions --- Python Functions | 571 ++++++++++++++++++++++++----------------------- 1 file changed, 293 insertions(+), 278 deletions(-) diff --git a/Python Functions b/Python Functions index ca87a80..cdbe05f 100644 --- a/Python Functions +++ b/Python Functions @@ -1,5 +1,5 @@ ├── Python -│ ├── Functions in Python (add code and documentation within the new loops in python sub-folder. +│ ├── Functions in Python (add code and documentation within the new loops in python sub-folder.) │ │ ├── functions.py (Python file showing working of Functions) | | | Python Functions is a block of statements that return the specific task. | | | ##Syntax: Python Functions @@ -315,281 +315,296 @@ | | | The sum is 11 | | | | | ├── functions.md (Markdown file for documentation on how your code works) - The idea is to put some commonly or repeatedly done tasks together and make a function so that instead of writing the same code again and again for different inputs, we can do the function calls to reuse code contained in it over and over again. - A python function consists of the following features: - 1.Keyword def that marks the start of the function header. - 2.A function name to uniquely identify the function. Function naming follows the same rules of writing identifiers in Python. - 3.Parameters (arguments) through which we pass values to a function. They are optional. - 4.A colon (:) to mark the end of the function header. - 5.Optional documentation string (docstring) to describe what the function does. - 6.One or more valid python statements that make up the function body. Statements must have the same indentation level (usually 4 spaces). - 7.An optional return statement to return a value from the function. - - ##How to call a function in python? - Once we have defined a function, we can call it from another function, program, or even the Python prompt. To call a function we simply type the function name with appropriate parameters. - Note: In python, the function definition should always be present before the function call. Otherwise, we will get an error. - - We can use return type of the function and data type of the arguments in python. - ##Arguments of a Python Function - Arguments are the values passed inside the parenthesis of the function. A function can have any number of arguments separated by a comma. - - #Types of Arguments - Python supports various types of arguments that can be passed at the time of the function call. - - #Default arguments - A default argument is a parameter that assumes a default value if a value is not provided in the function call for that argument. - any number of arguments in a function can have a default value. But once we have a default argument, all the arguments to its right must also have default values. - - #Keyword arguments - The idea is to allow the caller to specify the argument name with values so that caller does not need to remember the order of parameters. - - #Variable-length arguments - In Python, we can pass a variable number of arguments to a function using special symbols. There are two special symbols: - - *args (Non-Keyword Arguments) - **kwargs (Keyword Arguments) - - ##Docstring - The first string after the function is called the Document string or Docstring in short. This is used to describe the functionality of the function. The use of docstring in functions is optional but it is considered a good practice. - Unless you can remember what you had for dinner last week, always document your code.We generally use triple quotes so that docstring can extend up to multiple lines. This string is available to us as the __doc__ attribute of the function. - - ##Scope and Lifetime of variables - Scope of a variable is the portion of a program where the variable is recognized. Parameters and variables defined inside a function are not visible from outside the function. Hence, they have a local scope.The lifetime of a variable is the period throughout which the variable exists in the memory. - The lifetime of variables inside a function is as long as the function executes. - They are destroyed once we return from the function. Hence, a function does not remember the value of a variable from its previous calls. - On the other hand, variables outside of the function are visible from inside. They have a global scope. - We can read these values from inside the function but cannot change (write) them. In order to modify the value of variables outside the function, they must be declared as global variables using the keyword global. - - ##Return statement in Python function - The function return statement is used to exit from a function and go back to the function caller and return the specified value or data item to the caller. - The return statement can consist of a variable, an expression, or a constant which is returned to the end of the function execution. If none of the above is present with the return statement a None object is returned. - - ##Pass by Reference or pass by value - One important thing to note is, in Python every variable name is a reference. When we pass a variable to a function, a new reference to the object is created. - When we pass a reference and change the received reference to something else, the connection between the passed and received parameter is broken. - - ##Anonymous functions in Python Function - In Python, an anonymous function means that a function is without a name. As we already know the def keyword is used to define the normal functions and the lambda keyword is used to create anonymous functions. - - ##Python Function within Functions - A function that is defined inside another function is known as the inner function or nested function. Nested functions are able to access variables of the enclosing scope. Inner functions are used so that they can be protected from everything happening outside the function. - - ##Python Built-in Functions - Python has several functions that are readily available for use. These functions are called built-in functions. - Python abs() - returns absolute value of a number - - Python all() - returns true when all elements in iterable is true - - Python any() - Checks if any Element of an Iterable is True - - Python ascii() - Returns String Containing Printable Representation - - Python bin() - converts integer to binary string - - Python bool() - Converts a Value to Boolean - - Python bytearray() - returns array of given byte size - - Python bytes() - returns immutable bytes object - - Python callable() - Checks if the Object is Callable - - Python chr() - Returns a Character (a string) from an Integer - - Python classmethod() - returns class method for given function - - Python compile() - Returns a Python code object - - Python complex() - Creates a Complex Number - - Python delattr() - Deletes Attribute From the Object - - Python dict() - Creates a Dictionary - - Python dir() - Tries to Return Attributes of Object - - Python divmod() - Returns a Tuple of Quotient and Remainder - - Python enumerate() - Returns an Enumerate Object - - Python eval() - Runs Python Code Within Program - - Python exec() - Executes Dynamically Created Program - - Python filter() - constructs iterator from elements which are true - - Python float() - returns floating point number from number, string - - Python format() - returns formatted representation of a value - - Python frozenset() - returns immutable frozenset object - - Python getattr() - returns value of named attribute of an object - - Python globals() - returns dictionary of current global symbol table - - Python hasattr() - returns whether object has named attribute - - Python hash() - returns hash value of an object - - Python help() - Invokes the built-in Help System - - Python hex() - Converts to Integer to Hexadecimal - - Python id() - Returns Identify of an Object - - Python input() - reads and returns a line of string - - Python int() - returns integer from a number or string - - Python isinstance() - Checks if a Object is an Instance of Class - - Python issubclass() - Checks if a Class is Subclass of another Class - - Python iter() - returns an iterator - - Python len() - Returns Length of an Object - - Python list() - creates a list in Python - - Python locals() - Returns dictionary of a current local symbol table - - Python map() - Applies Function and Returns a List - - Python max() - returns the largest item - - Python memoryview() - returns memory view of an argument - - Python min() - returns the smallest value - - Python next() - Retrieves next item from the iterator - - Python object() - creates a featureless object - - Python oct() - returns the octal representation of an integer - - Python open() - Returns a file object - - Python ord() - returns an integer of the Unicode character - - Python pow() - returns the power of a number - - Python print() - Prints the Given Object - - Python property() - returns the property attribute - - Python range() - returns a sequence of integers - - Python repr() - returns a printable representation of the object - - Python reversed() - returns the reversed iterator of a sequence - - Python round() - rounds a number to specified decimals - - Python set() - constructs and returns a set - - Python setattr() - sets the value of an attribute of an object - - Python slice() - returns a slice object - - Python sorted() - returns a sorted list from the given iterable - - Python staticmethod() - transforms a method into a static method - - Python str() - returns the string version of the object - - Python sum() - Adds items of an Iterable - - Python super() - Returns a proxy object of the base class - - Python tuple() - Returns a tuple - - Python type() - Returns the type of the object - - Python vars() - Returns the __dict__ attribute - - Python zip() - Returns an iterator of tuples - - Python __import__() - Function called by the import statement - - ##What are user-defined functions in Python? - Functions that we define ourselves to do certain specific task are referred as user-defined functions. The way in which we define and call functions in Python are already discussed. - - Functions that readily come with Python are called built-in functions. If we use functions written by others in the form of library, it can be termed as library functions. - - All the other functions that we write on our own fall under user-defined functions. So, our user-defined function could be a library function to someone else. - - #Advantages of user-defined functions - User-defined functions help to decompose a large program into small segments which makes program easy to understand, maintain and debug. - If repeated code occurs in a program. Function can be used to include those codes and execute when needed by calling that function. - Programmars working on large project can divide the workload by making different functions. - +| | | The idea is to put some commonly or repeatedly done tasks together and make a function so that instead of writing the same code again and again for +| | | different inputs, we can do the function calls to reuse code contained in it over and over again. +| | | A python function consists of the following features: +| | | 1.Keyword def that marks the start of the function header. +| | | 2.A function name to uniquely identify the function. Function naming follows the same rules of writing identifiers in Python. +| | | 3.Parameters (arguments) through which we pass values to a function. They are optional. +| | | 4.A colon (:) to mark the end of the function header. +| | | 5.Optional documentation string (docstring) to describe what the function does. +| | | 6.One or more valid python statements that make up the function body. Statements must have the same indentation level (usually 4 spaces). +| | | 7.An optional return statement to return a value from the function. +| | | +| | | ##How to call a function in python? +| | | Once we have defined a function, we can call it from another function, program, or even the Python prompt. To call a function we simply type the +| | | function name with appropriate parameters. +| | | Note: In python, the function definition should always be present before the function call. Otherwise, we will get an error. +| | | +| | | We can use return type of the function and data type of the arguments in python. +| | | ##Arguments of a Python Function +| | | Arguments are the values passed inside the parenthesis of the function. A function can have any number of arguments separated by a comma. +| | | +| | | #Types of Arguments +| | | Python supports various types of arguments that can be passed at the time of the function call. +| | | +| | | #Default arguments +| | | A default argument is a parameter that assumes a default value if a value is not provided in the function call for that argument. +| | | any number of arguments in a function can have a default value. But once we have a default argument, all the arguments to its right must also have +| | | default values. +| | | +| | | #Keyword arguments +| | | The idea is to allow the caller to specify the argument name with values so that caller does not need to remember the order of parameters. +| | | +| | | #Variable-length arguments +| | | In Python, we can pass a variable number of arguments to a function using special symbols. There are two special symbols: +| | | +| | | *args (Non-Keyword Arguments) +| | | **kwargs (Keyword Arguments) +| | | +| | | ##Docstring +| | | The first string after the function is called the Document string or Docstring in short. This is used to describe the functionality of the function. +| | | The use of docstring in functions is optional but it is considered a good practice.Unless you can remember what you had for dinner last week, +| | | always document your code.We generally use triple quotes so that docstring can extend up to multiple lines. This string is available to us as the +| | | __doc__ attribute of the function. +| | | +| | | ##Scope and Lifetime of variables +| | | Scope of a variable is the portion of a program where the variable is recognized. Parameters and variables defined inside a function are not visible +| | | from outside the function. Hence, they have a local scope.The lifetime of a variable is the period throughout which the variable exists in the memory. +| | | The lifetime of variables inside a function is as long as the function executes. +| | | They are destroyed once we return from the function. Hence, a function does not remember the value of a variable from its previous calls. +| | | On the other hand, variables outside of the function are visible from inside. They have a global scope. +| | | We can read these values from inside the function but cannot change (write) them. In order to modify the value of variables outside the function, +| | | they must be declared as global variables using the keyword global. +| | | +| | | ##Return statement in Python function +| | | The function return statement is used to exit from a function and go back to the function caller and return the specified value or +| | | data item to the caller. +| | | The return statement can consist of a variable, an expression, or a constant which is returned to the end of the function execution. +| | | If none of the above value is present with the return statement a None object is returned. +| | | +| | | ##Pass by Reference or pass by value +| | | One important thing to note is, in Python every variable name is a reference. When we pass a variable to a function, a new reference to the object +| | | is created. When we pass a reference and change the received reference to something else, the connection between the passed and received parameter +| | | is broken. +| | | +| | | ##Anonymous functions in Python Function +| | | In Python, an anonymous function means that a function is without a name. As we already know the def keyword is used to define the normal functions and +| | | the lambda keyword is used to create anonymous functions. +| | | +| | | ##Python Function within Functions +| | | A function that is defined inside another function is known as the inner function or nested function. Nested functions are able to access variables of +| | | the enclosing scope. Inner functions are used so that they can be protected from everything happening outside the function. +| | | +| | | ##Python Built-in Functions +| | | Python has several functions that are readily available for use. These functions are called built-in functions. +| | | Python abs() +| | | returns absolute value of a number +| | | +| | | Python all() +| | | returns true when all elements in iterable is true +| | | +| | | Python any() +| | | Checks if any Element of an Iterable is True +| | | +| | | Python ascii() +| | | Returns String Containing Printable Representation +| | | +| | | Python bin() +| | | converts integer to binary string +| | | +| | | Python bool() +| | | Converts a Value to Boolean +| | | +| | | Python bytearray() +| | | returns array of given byte size +| | | +| | | Python bytes() +| | | returns immutable bytes object +| | | +| | | Python callable() +| | | Checks if the Object is Callable +| | | +| | | Python chr() +| | | Returns a Character (a string) from an Integer +| | | +| | | Python classmethod() +| | | returns class method for given function +| | | +| | | Python compile() +| | | Returns a Python code object +| | | +| | | Python complex() +| | | Creates a Complex Number +| | | +| | | Python delattr() +| | | Deletes Attribute From the Object +| | | +| | | Python dict() +| | | Creates a Dictionary +| | | +| | | Python dir() +| | | Tries to Return Attributes of Object +| | | +| | | Python divmod() +| | | Returns a Tuple of Quotient and Remainder +| | | +| | | Python enumerate() +| | | Returns an Enumerate Object +| | | +| | | Python eval() +| | | Runs Python Code Within Program +| | | +| | | Python exec() +| | | Executes Dynamically Created Program +| | | +| | | Python filter() +| | | constructs iterator from elements which are true +| | | +| | | Python float() +| | | returns floating point number from number, string +| | | +| | | Python format() +| | | returns formatted representation of a value +| | | +| | | Python frozenset() +| | | returns immutable frozenset object +| | | +| | | Python getattr() +| | | returns value of named attribute of an object +| | | +| | | Python globals() +| | | returns dictionary of current global symbol table +| | | +| | | Python hasattr() +| | | returns whether object has named attribute +| | | +| | | Python hash() +| | | returns hash value of an object +| | | +| | | Python help() +| | | Invokes the built-in Help System +| | | +| | | Python hex() +| | | Converts to Integer to Hexadecimal +| | | +| | | Python id() +| | | Returns Identify of an Object +| | | +| | | Python input() +| | | reads and returns a line of string +| | | +| | | Python int() +| | | returns integer from a number or string +| | | +| | | Python isinstance() +| | | Checks if a Object is an Instance of Class +| | | +| | | Python issubclass() +| | | Checks if a Class is Subclass of another Class +| | | +| | | Python iter() +| | | returns an iterator +| | | +| | | Python len() +| | | Returns Length of an Object +| | | +| | | Python list() +| | | creates a list in Python +| | | +| | | Python locals() +| | | Returns dictionary of a current local symbol table +| | | +| | | Python map() +| | | Applies Function and Returns a List +| | | +| | | Python max() +| | | returns the largest item +| | | +| | | Python memoryview() +| | | returns memory view of an argument +| | | +| | | Python min() +| | | returns the smallest value +| | | +| | | Python next() +| | | Retrieves next item from the iterator +| | | +| | | Python object() +| | | creates a featureless object +| | | +| | | Python oct() +| | | returns the octal representation of an integer +| | | +| | | Python open() +| | | Returns a file object +| | | +| | | Python ord() +| | | returns an integer of the Unicode character +| | | +| | | Python pow() +| | | returns the power of a number +| | | +| | | Python print() +| | | Prints the Given Object +| | | +| | | Python property() +| | | returns the property attribute +| | | +| | | Python range() +| | | returns a sequence of integers +| | | +| | | Python repr() +| | | returns a printable representation of the object +| | | +| | | Python reversed() +| | | returns the reversed iterator of a sequence +| | | +| | | Python round() +| | | rounds a number to specified decimals +| | | +| | | Python set() +| | | constructs and returns a set +| | | +| | | Python setattr() +| | | sets the value of an attribute of an object +| | | +| | | Python slice() +| | | returns a slice object +| | | +| | | Python sorted() +| | | returns a sorted list from the given iterable +| | | +| | | Python staticmethod() +| | | transforms a method into a static method +| | | +| | | Python str() +| | | returns the string version of the object +| | | +| | | Python sum() +| | | Adds items of an Iterable +| | | +| | | Python super() +| | | Returns a proxy object of the base class +| | | +| | | Python tuple() +| | | Returns a tuple +| | | +| | | Python type() +| | | Returns the type of the object +| | | +| | | Python vars() +| | | Returns the __dict__ attribute +| | | +| | | Python zip() +| | | Returns an iterator of tuples +| | | +| | | Python __import__() +| | | Function called by the import statement +| | | +| | | ##What are user-defined functions in Python? +| | | Functions that we define ourselves to do certain specific task are referred as user-defined functions. The way in which we define and call functions +| | | in Python are already discussed. +| | | +| | | Functions that readily come with Python are called built-in functions. If we use functions written by others in the form of library, it can be termed +| | | as library functions. +| | | +| | | All the other functions that we write on our own fall under user-defined functions. So, our user-defined function could be a library function +| | | to someone else. +| | | +| | | #Advantages of user-defined functions +| | | User-defined functions help to decompose a large program into small segments which makes program easy to understand, maintain and debug. +| | | If repeated code occurs in a program. Function can be used to include those codes and execute when needed by calling that function. +| | | Programmars working on large project can divide the workload by making different functions. +| | │ ├── Python.md (Leave this file intact) From d72a0853ba31a9966e906296c9922ed54e894dda Mon Sep 17 00:00:00 2001 From: daskamalini85 <105573319+daskamalini85@users.noreply.github.com> Date: Mon, 24 Oct 2022 10:28:43 +0530 Subject: [PATCH 9/9] Add files via upload --- functions.md.docx | Bin 0 -> 19227 bytes functions.py.docx | Bin 0 -> 11158 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 functions.md.docx create mode 100644 functions.py.docx diff --git a/functions.md.docx b/functions.md.docx new file mode 100644 index 0000000000000000000000000000000000000000..5286ea056cea5afdb131fa27f9a086385e601bd7 GIT binary patch literal 19227 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 literal 0 HcmV?d00001