{"id":451,"date":"2025-05-20T04:51:26","date_gmt":"2025-05-20T04:51:26","guid":{"rendered":"https:\/\/buhave.com\/courses\/?p=451"},"modified":"2025-05-20T12:56:49","modified_gmt":"2025-05-20T12:56:49","slug":"functions","status":"publish","type":"post","link":"https:\/\/buhave.com\/courses\/python\/functions\/","title":{"rendered":"Functions"},"content":{"rendered":"

Defining and calling functions<\/strong>
\n<\/span><\/h2>\n

What Are Functions?<\/strong><\/p>\n

A function is a block of reusable code that performs a specific task. You define functions to avoid repeating code, enhance readability, and make your code more modular.<\/p>\n

1. Defining a Function<\/h3>\n

To define a function, you use the def keyword followed by the function name, parentheses, and a colon (:). The indented code that follows is the body of the function, where the logic happens.<\/p>\n

Syntax:<\/strong><\/p>\n

def function_name(parameters):<\/em>
\n# function body<\/em>
\n# code to be executed<\/em><\/p>\n

Example 1:<\/strong> A Simple Function<\/p>\n

def greet():<\/em>
\nprint(“Hello, welcome!”)<\/em><\/p>\n

    \n
  • def defines the function.<\/li>\n
  • greet() is the function name.<\/li>\n
  • The body contains the print() statement.<\/li>\n<\/ul>\n

    This function doesn\u2019t accept any parameters and simply prints a message when called.<\/p>\n

    2. Calling a Function<\/h3>\n

    After defining a function, you can call it by using its name followed by parentheses.<\/p>\n

    Syntax:<\/strong><\/p>\n

    function_name()<\/em><\/p>\n

    Example 2:<\/strong> Calling the greet() function<\/p>\n

    greet()<\/em><\/p>\n

    Output:<\/strong><\/p>\n

    Hello, welcome!<\/em><\/p>\n

    The function greet() is executed when called, and it prints the message.<\/p>\n

    3. Functions with Parameters<\/h3>\n

    Functions can accept parameters \u2014 values that are passed into the function when it\u2019s called.<\/p>\n

    Syntax:<\/strong><\/p>\n

    def function_name(parameter1, parameter2):<\/em>
    \n# code<\/em><\/p>\n

    Example 3:<\/strong> Function with Parameters<\/p>\n

    def greet(name):<\/em>
    \nprint(f”Hello, {name}!”)<\/em><\/p>\n

    Calling the Function with an Argument<\/strong><\/p>\n

    greet(“Alice”)<\/em><\/p>\n

    Output:<\/strong><\/p>\n

    Hello, Alice!<\/em><\/p>\n

    The function greet() accepts a name parameter and prints a personalized greeting.<\/p>\n

    4. Functions with Return Values<\/h3>\n

    Functions can return a value using the return keyword, allowing you to send results back to where the function was called.<\/p>\n

    Syntax:<\/strong><\/p>\n

    def function_name():<\/em>
    \nreturn value<\/em><\/p>\n

    Example 4:<\/strong> Function with a Return Value<\/p>\n

    def add(a, b):<\/em>
    \nreturn a + b<\/em><\/p>\n

    Calling the Function and Using the Return Value<\/strong><\/p>\n

    result = add(5, 3)<\/em>
    \nprint(result)<\/em><\/p>\n

    Output:<\/strong><\/p>\n

    8<\/em><\/p>\n

    The add() function returns the sum of a and b, and the result is stored in the result variable, which is then printed.<\/p>\n

    5. Functions with Multiple Parameters and Default Values<\/h3>\n

    Functions can also have default parameters, meaning that if no value is passed for them, a default value will be used.<\/p>\n

    Syntax:<\/strong><\/p>\n

    def function_name(param1, param2=default_value):<\/em>
    \n# code<\/em><\/p>\n

    Example 5:<\/strong> Function with a Default Parameter<\/p>\n

    def greet(name, greeting=”Hello”):<\/em>
    \nprint(f”{greeting}, {name}!”)<\/em><\/p>\n

    Calling the Function with and without Default Parameter<\/strong><\/p>\n

    greet(“Bob”) # Uses default greeting<\/em>
    \ngreet(“Alice”, “Good morning”) # Custom greeting<\/em><\/p>\n

    Output:<\/strong><\/p>\n

    Hello, Bob!<\/em>
    \nGood morning, Alice!<\/em><\/p>\n

    Summary of Key Points:<\/strong><\/p>\n

      \n
    • Defining a function: Use def followed by the function name and parameters.<\/li>\n
    • Calling a function: Simply write the function name followed by parentheses.<\/li>\n
    • Parameters: Functions can accept inputs (parameters) to customize their behavior.<\/li>\n
    • Return values: Use return to send results from a function back to the caller.<\/li>\n
    • Default values: Parameters can have default values in case no argument is provided.<\/li>\n<\/ul>\n

      Example of Multiple Concepts:<\/strong><\/p>\n

      def multiply(a, b=2):<\/em>
      \nreturn a * b<\/em><\/p>\n

      result1 = multiply(5) # Uses default value for b<\/em>
      \nresult2 = multiply(5, 3) # Custom value for b<\/em><\/p>\n

      print(result1) # Output: 10<\/em>
      \nprint(result2) # Output: 15<\/em><\/p>\n

      Parameters, arguments, and return values<\/h2>\n

      1. Parameters<\/h3>\n

      Parameters are variables that are defined in a function\u2019s signature (the function definition). They act as placeholders for values that are passed into the function when it is called.<\/span><\/p>\n

      Parameters let you write generic, reusable functions that can handle different inputs.<\/p>\n

      Syntax for Parameters:<\/strong><\/p>\n

      def function_name(parameter1, parameter2):<\/em>
      \n# function body<\/em><\/p>\n

      Example:<\/strong> Parameters in Action<\/p>\n

      def greet(name, greeting=”Hello”):<\/em>
      \nprint(f”{greeting}, {name}!”)<\/em><\/p>\n

        \n
      • name and greeting are parameters.<\/li>\n
      • greeting has a default value (“Hello”), so it’s optional when calling the function.<\/li>\n<\/ul>\n

        Key Points:<\/strong><\/p>\n

          \n
        • Parameters define the inputs a function requires.<\/li>\n
        • Parameters are used within the function body.<\/li>\n<\/ul>\n

          2. Arguments<\/h3>\n

          Arguments are the actual values that you pass into a function when you call it. The function receives arguments and uses them to perform its tasks.<\/p>\n

          Arguments are provided in the function call and match the function\u2019s parameters in order.<\/p>\n

          Syntax for Arguments:<\/strong><\/p>\n

          function_name(argument1, argument2)<\/em><\/p>\n

          Example:<\/strong> Passing Arguments<\/p>\n

          greet(“Alice”, “Good morning”)<\/em><\/p>\n

            \n
          • “Alice” and “Good morning” are arguments.<\/li>\n
          • “Alice” is passed to the name parameter, and “Good morning” is passed to the greeting parameter.<\/li>\n<\/ul>\n

            Key Points:<\/strong><\/p>\n

              \n
            • Arguments are the real values passed to the function when it is called.<\/li>\n
            • Arguments replace parameters with actual data.<\/li>\n<\/ul>\n

              3. Return Values<\/h3>\n

              A return value is the result that a function sends back after it completes its task. A function can return any kind of value \u2014 numbers, strings, lists, etc.<\/p>\n

              The return keyword is used to send a value back from a function. Once return is executed, the function exits, and the returned value can be used or stored outside of the function.<\/p>\n

              Syntax for Return Values:<\/strong><\/p>\n

              def function_name():<\/em>
              \nreturn value<\/em><\/p>\n

              Example:<\/strong> Function with Return Value<\/p>\n

              def add(a, b):<\/em>
              \nreturn a + b<\/em><\/p>\n

                \n
              • The add() function returns the sum of a and b.<\/li>\n
              • When the function finishes, it sends the result back to the caller.<\/li>\n<\/ul>\n

                Key Points:<\/strong><\/p>\n

                  \n
                • A function can return a value using return.<\/li>\n
                • The function stops executing after a return statement.<\/li>\n<\/ul>\n

                  Example of Using Parameters, Arguments, and Return Value Together:<\/strong><\/p>\n

                  def multiply(a, b=1):<\/em>
                  \nreturn a * b<\/em><\/p>\n

                  # Calling the function with arguments:<\/em>
                  \nresult1 = multiply(5) # Uses default b=1<\/em>
                  \nresult2 = multiply(5, 3) # Custom b=3<\/em><\/p>\n

                  print(result1) # Output: 5 (5 * 1)<\/em>
                  \nprint(result2) # Output: 15 (5 * 3)<\/em><\/p>\n

                    \n
                  • Parameters: a and b are defined in the function signature.<\/li>\n
                  • Arguments: 5 and 3 are passed when calling the function.<\/li>\n
                  • Return Value: The result of a * b is returned and stored in result1 and result2.<\/li>\n<\/ul>\n

                    Key Takeaways:<\/strong><\/p>\n

                      \n
                    • Parameters: Variables defined in the function to receive inputs.<\/li>\n
                    • Arguments: Values passed to the function when calling it (matching parameters).<\/li>\n
                    • Return Values: The result that the function sends back after completing its task, allowing you to use the output outside the function.<\/li>\n<\/ul>\n

                      Variable scope<\/h2>\n

                      What is Variable Scope?<\/h3>\n

                      Variable scope refers to the region of a program where a variable can be accessed. In Python, the scope is influenced by where the variable is declared and where it is used.<\/p>\n

                      Types of Scope in Python<\/strong><\/p>\n

                        \n
                      • Local Scope<\/li>\n
                      • Enclosing Scope<\/li>\n
                      • Global Scope<\/li>\n
                      • Built-in Scope<\/li>\n<\/ul>\n

                        1. Local Scope<\/h3>\n

                        A variable has local scope if it is defined inside a function or a block of code. This means it is only accessible within that function or block.<\/p>\n

                          \n
                        • Local variables are created when the function is called and destroyed when the function finishes execution.<\/li>\n<\/ul>\n

                          Example of Local Scope:<\/strong><\/p>\n

                          def my_function():<\/em>
                          \nx = 10 # x is local to my_function<\/em>
                          \nprint(x)<\/em><\/p>\n

                          my_function() # Output: 10<\/em>
                          \n# print(x) # This would cause an error because x is local to my_function<\/em><\/p>\n

                          In the example, x is local to my_function(), and trying to access x outside the function will raise a NameError.<\/p>\n

                          2. Enclosing Scope (Nonlocal)<\/h3>\n

                          Enclosing scope refers to the scope of a function within another function. Variables defined in the outer (enclosing) function are accessible to the inner (nested) function.<\/p>\n

                            \n
                          • These variables are not local to the inner function but can be modified using the nonlocal keyword.<\/li>\n<\/ul>\n

                            Example of Enclosing Scope:<\/strong><\/p>\n

                            def outer_function():<\/em>
                            \nx = 20 # x is in the enclosing scope<\/em>
                            \ndef inner_function():<\/em>
                            \nprint(x) # Can access x from the enclosing function<\/em>
                            \ninner_function()<\/em><\/p>\n

                            outer_function() # Output: 20<\/em><\/p>\n

                            Here, inner_function() can access x from the outer_function() because x is in an enclosing scope.<\/p>\n

                            3. Global Scope<\/h3>\n

                            A variable has global scope if it is defined at the top level of the script or module (outside any function). Global variables can be accessed from any part of the program, including inside functions (but not always modified directly without the global keyword).<\/p>\n

                              \n
                            • Global variables exist throughout the life of the program.<\/li>\n<\/ul>\n

                              Example of Global Scope:<\/strong><\/p>\n

                              x = 50 # x is a global variable<\/em><\/p>\n

                              def my_function():<\/em>
                              \nprint(x) # Can access global x inside the function<\/em><\/p>\n

                              my_function() # Output: 50<\/em>
                              \nprint(x) # Output: 50<\/em><\/p>\n

                              In this example, x is defined in the global scope and can be accessed inside the function my_function().<\/p>\n

                              Modifying a Global Variable:<\/strong><\/p>\n

                              To modify a global variable inside a function, use the global keyword:<\/p>\n

                              x = 50 # Global variable<\/em><\/p>\n

                              def my_function():<\/em>
                              \nglobal x<\/em>
                              \nx = 100 # Modifies the global x<\/em><\/p>\n

                              my_function()<\/em>
                              \nprint(x) # Output: 100<\/em><\/p>\n

                              Without the global keyword, trying to assign to x inside the function would create a local variable x instead of modifying the global one.<\/p>\n

                              4. Built-in Scope<\/h3>\n

                              Built-in scope refers to the names that are available in Python\u2019s built-in namespace, which includes functions like print(), len(), sum(), and more. These names are available throughout the entire program.<\/p>\n

                                \n
                              • Built-in variables and functions are part of Python’s core language and are always accessible.<\/li>\n<\/ul>\n

                                Example of Built-in Scope:<\/strong><\/p>\n

                                print(len(“Hello”)) # ‘len’ is a built-in function<\/em><\/p>\n

                                In this example, print() and len() are built-in functions, available globally without needing to be imported or defined.<\/p>\n

                                LEGB Rule (Local, Enclosing, Global, Built-in)<\/strong><\/p>\n

                                When you reference a variable, Python follows the LEGB rule to look for it:<\/p>\n

                                  \n
                                • Local: First, Python looks for the variable in the local function scope.<\/li>\n
                                • Enclosing: If it’s not found, Python checks in any enclosing functions (from outer to inner).<\/li>\n
                                • Global: If it\u2019s not found in enclosing scopes, Python searches for the variable in the global scope.<\/li>\n
                                • Built-in: If the variable is still not found, Python checks the built-in scope for the variable.<\/li>\n<\/ul>\n

                                  Example of LEGB Rule:<\/strong><\/p>\n

                                  x = 5 # Global variable<\/em><\/p>\n

                                  def outer_function():<\/em>
                                  \nx = 10 # Enclosing variable<\/em>
                                  \ndef inner_function():<\/em>
                                  \nx = 15 # Local variable<\/em>
                                  \nprint(x) # Prints the local x, not global or enclosing<\/em>
                                  \ninner_function()<\/em><\/p>\n

                                  outer_function() # Output: 15<\/em>
                                  \nprint(x) # Output: 5 (global x remains unaffected)<\/em><\/p>\n

                                  Here, inside inner_function(), Python uses the local x because it\u2019s closest. The enclosing and global x are not used.<\/p>\n

                                  Modifying Variables in Different Scopes<\/strong><\/p>\n

                                    \n
                                  • Local variable: Can be modified directly within the function.<\/li>\n
                                  • Enclosing variable: Can be modified using the nonlocal keyword.<\/li>\n
                                  • Global variable: Can be modified using the global keyword.<\/li>\n<\/ul>\n

                                    Key Takeaways:<\/strong><\/p>\n

                                      \n
                                    • Local scope: Variables are accessible only inside the function where they are defined.<\/li>\n
                                    • Enclosing scope: Variables are accessible in nested functions.<\/li>\n
                                    • Global scope: Variables are accessible throughout the program.<\/li>\n
                                    • Built-in scope: Python’s core functions and variables.<\/li>\n
                                    • The LEGB rule determines where Python looks for a variable<\/li>\n<\/ul>\n

                                      Lambda functions<\/h2>\n

                                      What Is a Lambda Function?<\/h3>\n

                                      A lambda function is a small, anonymous function defined using the lambda keyword instead of def. It is used to create throwaway functions \u2014 typically for short, simple operations \u2014 without naming them.<\/p>\n

                                      Syntax of a Lambda Function:<\/strong><\/p>\n

                                      lambda arguments: expression<\/em><\/p>\n

                                        \n
                                      • lambda: Keyword that defines the function.<\/li>\n
                                      • arguments: Input parameters (can be zero or more).<\/li>\n
                                      • expression: A single expression to evaluate and return.<\/li>\n<\/ul>\n

                                        Note:<\/strong> The body of a lambda must be a single expression, not multiple lines or statements.<\/p>\n

                                        Example 1:<\/strong> Basic Lambda<\/p>\n

                                        square = lambda x: x * x<\/em>
                                        \nprint(square(4)) # Output: 16<\/em><\/p>\n

                                        This defines a lambda that returns the square of x. It behaves like:<\/p>\n

                                        def square(x):<\/em>
                                        \nreturn x * x<\/em><\/p>\n

                                        Example 2:<\/strong> Lambda with Multiple Arguments<\/p>\n

                                        add = lambda a, b: a + b<\/em>
                                        \nprint(add(3, 5)) # Output: 8<\/em><\/p>\n

                                        Example 3:<\/strong> Lambda with No Parameters<\/p>\n

                                        greet = lambda: “Hello!”<\/em>
                                        \nprint(greet()) # Output: Hello!<\/em><\/p>\n

                                        Lambda vs Regular Functions:<\/strong><\/p>\n\n\n\n\n\n\n\n\n\n
                                        Feature<\/strong><\/th>\ndef Function<\/strong><\/th>\nLambda Function<\/strong><\/th>\n<\/tr>\n<\/thead>\n
                                        Name<\/td>\nYes (named function)<\/td>\nNo (anonymous unless assigned to variable)<\/td>\n<\/tr>\n
                                        Multi-line support<\/td>\nYes (multiple statements)<\/td>\nNo (single expression only)<\/td>\n<\/tr>\n
                                        Use cases<\/td>\nReusable, complex logic<\/td>\nOne-time, short operations<\/td>\n<\/tr>\n
                                        Return<\/td>\nExplicit return<\/code> statement<\/td>\nImplicit return of expression result<\/td>\n<\/tr>\n
                                        Best for<\/td>\nFunctions called multiple times<\/td>\nSimple operations passed as arguments<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

                                        Where Are Lambda Functions Commonly Used?<\/strong><\/p>\n

                                        Lambda functions are often used with other functions that accept functions as arguments (like map(), filter(), sorted(), etc.).<\/p>\n

                                        Example 4:<\/strong> Using lambda with map()<\/p>\n

                                        nums = [1, 2, 3, 4]<\/em>
                                        \nsquares = list(map(lambda x: x**2, nums))<\/em>
                                        \nprint(squares) # Output: [1, 4, 9, 16]<\/em><\/p>\n

                                        Example 5:<\/strong> Using lambda with filter()<\/p>\n

                                        nums = [1, 2, 3, 4, 5]<\/em>
                                        \nevens = list(filter(lambda x: x % 2 == 0, nums))<\/em>
                                        \nprint(evens) # Output: [2, 4]<\/em><\/p>\n

                                        Example 6:<\/strong> Sorting with Lambda<\/p>\n

                                        people = [(“Alice”, 30), (“Bob”, 25), (“Eve”, 35)]<\/em>
                                        \nsorted_people = sorted(people, key=lambda person: person[1])<\/em>
                                        \nprint(sorted_people) # Sorted by age<\/em>
                                        \n# Output: [(‘Bob’, 25), (‘Alice’, 30), (‘Eve’, 35)]<\/em><\/p>\n

                                        When to Use Lambda Functions<\/strong><\/p>\n

                                        Use a lambda when:<\/p>\n

                                          \n
                                        • You need a small, quick function.<\/li>\n
                                        • It\u2019s used only once or in a limited scope.<\/li>\n
                                        • You\u2019re passing it as an argument to a higher-order function.<\/li>\n<\/ul>\n

                                          Avoid lambda when:<\/p>\n

                                            \n
                                          • The function is complex or involves multiple steps.<\/li>\n
                                          • You need to reuse or debug it.<\/li>\n<\/ul>\n

                                            Summary:<\/strong><\/p>\n

                                              \n
                                            • Lambda functions are anonymous, one-line functions.<\/li>\n
                                            • Use lambda args: expression.<\/li>\n
                                            • Great for quick tasks, especially with map(), filter(), sorted(), etc.<\/li>\n
                                            • They simplify short, functional-style code but should not replace full def functions for more complex logic.<\/li>\n<\/ul>\n

                                              Want to explore lambda with custom sorting, combining with list comprehensions, or higher-order functions like reduce()? Just say the word!<\/p>\n","protected":false},"excerpt":{"rendered":"

                                              Defining and calling functions What Are Functions? A function is a block of reusable code that performs a specific task. You define functions to avoid repeating code, enhance readability, and make your code more modular. 1. Defining a Function To define a function, you use<\/p>\n","protected":false},"author":1,"featured_media":768,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[9],"tags":[],"class_list":["post-451","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python"],"yoast_head":"\nFunctions - Python Course<\/title>\n<meta name=\"description\" content=\"Functions are reusable blocks of code that perform specific tasks when called; they help organize code and avoid repetition.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/buhave.com\/courses\/python\/functions\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Functions - Python Course\" \/>\n<meta property=\"og:description\" content=\"Functions are reusable blocks of code that perform specific tasks when called; they help organize code and avoid repetition.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/buhave.com\/courses\/python\/functions\/\" \/>\n<meta property=\"og:site_name\" content=\"BUHAVE\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/BeYouHave\/\" \/>\n<meta property=\"article:author\" content=\"https:\/\/www.facebook.com\/naveedsafdarawan\/\" \/>\n<meta property=\"article:published_time\" content=\"2025-05-20T04:51:26+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-05-20T12:56:49+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/04\/Functions.webp\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/webp\" \/>\n<meta name=\"author\" content=\"Naveed Safdar\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Naveed Safdar\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"10 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/functions\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/functions\\\/\"},\"author\":{\"name\":\"Naveed Safdar\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#\\\/schema\\\/person\\\/04fe0254e118521c9fbb3da39de5acca\"},\"headline\":\"Functions\",\"datePublished\":\"2025-05-20T04:51:26+00:00\",\"dateModified\":\"2025-05-20T12:56:49+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/functions\\\/\"},\"wordCount\":2011,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/functions\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/buhave.com\\\/courses\\\/wp-content\\\/uploads\\\/2025\\\/04\\\/Functions.webp\",\"articleSection\":[\"Python Course\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/functions\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/functions\\\/\",\"url\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/functions\\\/\",\"name\":\"Functions - Python Course\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/functions\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/functions\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/buhave.com\\\/courses\\\/wp-content\\\/uploads\\\/2025\\\/04\\\/Functions.webp\",\"datePublished\":\"2025-05-20T04:51:26+00:00\",\"dateModified\":\"2025-05-20T12:56:49+00:00\",\"description\":\"Functions are reusable blocks of code that perform specific tasks when called; they help organize code and avoid repetition.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/functions\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/functions\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/functions\\\/#primaryimage\",\"url\":\"https:\\\/\\\/buhave.com\\\/courses\\\/wp-content\\\/uploads\\\/2025\\\/04\\\/Functions.webp\",\"contentUrl\":\"https:\\\/\\\/buhave.com\\\/courses\\\/wp-content\\\/uploads\\\/2025\\\/04\\\/Functions.webp\",\"width\":1200,\"height\":628,\"caption\":\"Functions\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/python\\\/functions\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Courses\",\"item\":\"https:\\\/\\\/buhave.com\\\/courses\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Python Course\",\"item\":\"https:\\\/\\\/buhave.com\\\/courses\\\/learn\\\/python\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Functions\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#website\",\"url\":\"https:\\\/\\\/buhave.com\\\/courses\\\/\",\"name\":\"BUHAVE\",\"description\":\"Courses - Learn Online for Free\",\"publisher\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/buhave.com\\\/courses\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#organization\",\"name\":\"BUHAVE\",\"url\":\"https:\\\/\\\/buhave.com\\\/courses\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/buhave.com\\\/courses\\\/wp-content\\\/uploads\\\/2025\\\/03\\\/buhave-course.webp\",\"contentUrl\":\"https:\\\/\\\/buhave.com\\\/courses\\\/wp-content\\\/uploads\\\/2025\\\/03\\\/buhave-course.webp\",\"width\":375,\"height\":75,\"caption\":\"BUHAVE\"},\"image\":{\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/BeYouHave\\\/\",\"https:\\\/\\\/www.linkedin.com\\\/company\\\/buhave\",\"https:\\\/\\\/www.youtube.com\\\/@buhave\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/buhave.com\\\/courses\\\/#\\\/schema\\\/person\\\/04fe0254e118521c9fbb3da39de5acca\",\"name\":\"Naveed Safdar\",\"description\":\"I\u2019m Naveed Safdar - SEO Manager with over 10 years of experience in SEO and Digital Marketing. I\u2019ve had the privilege of working with leading national and international companies including Grafdom, PakWheels, Systems Limited, Confiz, Educative, and Dubizzle Labs. My expertise spans technical SEO, content strategy, organic growth, and performance analytics - helping businesses improve visibility, traffic, and ROI.\",\"sameAs\":[\"https:\\\/\\\/www.linkedin.com\\\/in\\\/naveedsafdar\\\/\",\"https:\\\/\\\/www.facebook.com\\\/naveedsafdarawan\\\/\",\"https:\\\/\\\/www.youtube.com\\\/@naveedsafdar\"],\"url\":\"https:\\\/\\\/buhave.com\\\/courses\\\/author\\\/naveed-safdar\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Functions - Python Course","description":"Functions are reusable blocks of code that perform specific tasks when called; they help organize code and avoid repetition.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/buhave.com\/courses\/python\/functions\/","og_locale":"en_US","og_type":"article","og_title":"Functions - Python Course","og_description":"Functions are reusable blocks of code that perform specific tasks when called; they help organize code and avoid repetition.","og_url":"https:\/\/buhave.com\/courses\/python\/functions\/","og_site_name":"BUHAVE","article_publisher":"https:\/\/www.facebook.com\/BeYouHave\/","article_author":"https:\/\/www.facebook.com\/naveedsafdarawan\/","article_published_time":"2025-05-20T04:51:26+00:00","article_modified_time":"2025-05-20T12:56:49+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/04\/Functions.webp","type":"image\/webp"}],"author":"Naveed Safdar","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Naveed Safdar","Est. reading time":"10 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/buhave.com\/courses\/python\/functions\/#article","isPartOf":{"@id":"https:\/\/buhave.com\/courses\/python\/functions\/"},"author":{"name":"Naveed Safdar","@id":"https:\/\/buhave.com\/courses\/#\/schema\/person\/04fe0254e118521c9fbb3da39de5acca"},"headline":"Functions","datePublished":"2025-05-20T04:51:26+00:00","dateModified":"2025-05-20T12:56:49+00:00","mainEntityOfPage":{"@id":"https:\/\/buhave.com\/courses\/python\/functions\/"},"wordCount":2011,"commentCount":0,"publisher":{"@id":"https:\/\/buhave.com\/courses\/#organization"},"image":{"@id":"https:\/\/buhave.com\/courses\/python\/functions\/#primaryimage"},"thumbnailUrl":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/04\/Functions.webp","articleSection":["Python Course"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/buhave.com\/courses\/python\/functions\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/buhave.com\/courses\/python\/functions\/","url":"https:\/\/buhave.com\/courses\/python\/functions\/","name":"Functions - Python Course","isPartOf":{"@id":"https:\/\/buhave.com\/courses\/#website"},"primaryImageOfPage":{"@id":"https:\/\/buhave.com\/courses\/python\/functions\/#primaryimage"},"image":{"@id":"https:\/\/buhave.com\/courses\/python\/functions\/#primaryimage"},"thumbnailUrl":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/04\/Functions.webp","datePublished":"2025-05-20T04:51:26+00:00","dateModified":"2025-05-20T12:56:49+00:00","description":"Functions are reusable blocks of code that perform specific tasks when called; they help organize code and avoid repetition.","breadcrumb":{"@id":"https:\/\/buhave.com\/courses\/python\/functions\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/buhave.com\/courses\/python\/functions\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/buhave.com\/courses\/python\/functions\/#primaryimage","url":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/04\/Functions.webp","contentUrl":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/04\/Functions.webp","width":1200,"height":628,"caption":"Functions"},{"@type":"BreadcrumbList","@id":"https:\/\/buhave.com\/courses\/python\/functions\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Courses","item":"https:\/\/buhave.com\/courses\/"},{"@type":"ListItem","position":2,"name":"Python Course","item":"https:\/\/buhave.com\/courses\/learn\/python\/"},{"@type":"ListItem","position":3,"name":"Functions"}]},{"@type":"WebSite","@id":"https:\/\/buhave.com\/courses\/#website","url":"https:\/\/buhave.com\/courses\/","name":"BUHAVE","description":"Courses - Learn Online for Free","publisher":{"@id":"https:\/\/buhave.com\/courses\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/buhave.com\/courses\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/buhave.com\/courses\/#organization","name":"BUHAVE","url":"https:\/\/buhave.com\/courses\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/buhave.com\/courses\/#\/schema\/logo\/image\/","url":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/03\/buhave-course.webp","contentUrl":"https:\/\/buhave.com\/courses\/wp-content\/uploads\/2025\/03\/buhave-course.webp","width":375,"height":75,"caption":"BUHAVE"},"image":{"@id":"https:\/\/buhave.com\/courses\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/BeYouHave\/","https:\/\/www.linkedin.com\/company\/buhave","https:\/\/www.youtube.com\/@buhave"]},{"@type":"Person","@id":"https:\/\/buhave.com\/courses\/#\/schema\/person\/04fe0254e118521c9fbb3da39de5acca","name":"Naveed Safdar","description":"I\u2019m Naveed Safdar - SEO Manager with over 10 years of experience in SEO and Digital Marketing. I\u2019ve had the privilege of working with leading national and international companies including Grafdom, PakWheels, Systems Limited, Confiz, Educative, and Dubizzle Labs. My expertise spans technical SEO, content strategy, organic growth, and performance analytics - helping businesses improve visibility, traffic, and ROI.","sameAs":["https:\/\/www.linkedin.com\/in\/naveedsafdar\/","https:\/\/www.facebook.com\/naveedsafdarawan\/","https:\/\/www.youtube.com\/@naveedsafdar"],"url":"https:\/\/buhave.com\/courses\/author\/naveed-safdar\/"}]}},"_links":{"self":[{"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/posts\/451","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/comments?post=451"}],"version-history":[{"count":1,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/posts\/451\/revisions"}],"predecessor-version":[{"id":452,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/posts\/451\/revisions\/452"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/media\/768"}],"wp:attachment":[{"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/media?parent=451"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/categories?post=451"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/buhave.com\/courses\/wp-json\/wp\/v2\/tags?post=451"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}