{"id":187,"date":"2019-02-07T01:55:11","date_gmt":"2019-02-07T01:55:11","guid":{"rendered":"https:\/\/www.kindsonthegenius.com\/python\/?p=187"},"modified":"2019-03-02T03:55:07","modified_gmt":"2019-03-02T03:55:07","slug":"15-python-functions","status":"publish","type":"post","link":"https:\/\/www.kindsonthegenius.com\/python\/15-python-functions\/","title":{"rendered":"Python – Functions"},"content":{"rendered":"

A function is a block of code that is executed as a unit. While there are many inbuilt functions in Python, you can also create your own function. This is known as user-defined functions. Once created, you can reuse a function at other parts of your program. Before you can use a function however, you must define it.<\/p>\n

We cover the following:<\/p>\n

    \n
  1. Defining a Function<\/a><\/li>\n
  2. Calling a Function<\/a><\/li>\n
  3. Pass by Value and by Reference<\/a><\/li>\n
  4. Arguments to Functions<\/a><\/li>\n
  5. Required Arguments<\/a><\/li>\n
  6. Keyword Arguments<\/a><\/li>\n
  7. Default Arguments<\/a><\/li>\n
  8. Required Arguments<\/a><\/li>\n
  9. Global and Local Variables<\/a><\/li>\n
  10. Watch the Video<\/a><\/li>\n<\/ol>\n

     <\/p>\n

    1. Defining a Function<\/strong><\/h4>\n

    To define a function, you must follow the rules listed below:<\/p>\n

      \n
    • Function definition begin with the keyword def, followed\u00a0 by the function name, then open and close parentheses.<\/li>\n
    • Input parameters to the function are placed inside the braces<\/li>\n
    • After the braces, then you must add colon (:) before you start writing the function body<\/li>\n
    • The function body must be indented<\/li>\n
    • The last statement in a function is optionally a return statement.<\/li>\n<\/ul>\n

      For example, the function below calculates the sum of two numbers<\/p>\n

      # Function to calculate the sum of two number<\/span>\r\n\r\ndef<\/span> calculatesum<\/span>(a, b):\r\n    sum<\/span> =<\/span> a +<\/span> b\r\n    return<\/span> sum<\/span>\r\n<\/pre>\n
      After creating a function, you can use it by calling it.<\/p>\n
       <\/p>\n
       <\/p>\n
      2. Calling a Function<\/strong><\/h4>\n
      To use a function, you must call it. If it requires parameters, then you must also provide the parameters. For example we can call the calculatesum function using the code below.<\/p>\n
      # Function to calculate the sum of two number<\/span>\r\n\r\ndef<\/span> calculatesum<\/span>(a, b):\r\n    sum<\/span> =<\/span> a +<\/span> b\r\n    print<\/span>(\"The sum of is \"<\/span> +<\/span> str<\/span>(sum<\/span>))\r\n    return<\/span> sum<\/span>\r\n\r\n# Calling the function calculatesum<\/span>\r\ncalculatesum(4<\/span>, 6<\/span>)\r\n<\/pre>\n
       <\/p>\n
      So it is only when a function it called that the program executes the body of the function. One thing to note is that the function call must appear after the function definition (not before!)<\/p>\n
       <\/p>\n
       <\/p>\n
      3. Pass by Value and by Reference<\/strong><\/h4>\n
      In Python, all arguments to a function are passed by reference. This means that the the same variable used in defining a function is reference when calling. So if you change the reference of a parameter within a function, this change is reflected in the calling function.<\/p>\n
      For example,<\/p>\n
      def<\/span> changelist<\/span>(list1):\r\n    list1.<\/span>append([10<\/span>, 20<\/span>, 30<\/span>])\r\n    print<\/span>(\"Changes made Inside the function: \"<\/span> +<\/span> str<\/span>(list1))\r\n    return<\/span>\r\n\r\n\r\nmylist =<\/span> [1<\/span>, 2<\/span>, 3<\/span>]\r\nchangelist(mylist)\r\nprint<\/span>(\"Changes reflect in the calling function: \"<\/span> +<\/span> str<\/span>(mylist))\r\n<\/pre>\n
       <\/p>\n
      In the code above, when the function is called, the argument mylist<\/em> is passed by reference. So inside the function, the same mylist<\/em> is used. So the changes are made to the same mylist<\/em> object.<\/p>\n
      The output of the code above would be:<\/p>\n
      <\/p>\n
      Changes made Inside the function: [1<\/span>, 2<\/span>, 3<\/span>, [10<\/span>, 20<\/span>, 30<\/span>]]\r\nChanges reflect in<\/span> the calling function: [1<\/span>, 2<\/span>, 3<\/span>, [10<\/span>, 20<\/span>, 30<\/span>]]<\/pre>\n
       <\/p>\n
       <\/p>\n
      4. Arguments to Functions<\/strong><\/h4>\n
      You can pass arguments to a function by one of the following types of arguments:<\/p>\n
        \n
      • Required arguments<\/li>\n
      • Keyword arguments<\/li>\n
      • Default arguments<\/li>\n
      • Variable-length arguments<\/li>\n<\/ul>\n
        Let’s now look at each one of these<\/p>\n
         <\/p>\n
         <\/p>\n
        5. Required arguments<\/strong><\/h4>\n
        This are arguments you must pass to a function, otherwise you get an error. When calling a function foo(a, b, c)<\/em> for example, then you must provide the three arguments. Also they must match the correct position of each of parameters in the function definition.<\/p>\n
        Let’s take an example, consider the printdata<\/em> function below:<\/p>\n
        # A function that just prints out the parameter<\/span>\r\ndef<\/span> printdata<\/span>(data):\r\n    print<\/span>(data)\r\n    return<\/span>\r\n<\/pre>\n
        If you are going to call this function, then you better provide the argument, data. Otherwise you get an error. This is required argument<\/p>\n
         <\/p>\n
         <\/p>\n
        6. Keyword Arguments<\/strong><\/h4>\n
        In this case, when you call a function, you use name of the parameter to identify the argument being passed.<\/p>\n
        This means that you can either skip some argument or even place he argument out of other when calling. But the keywords have to match the name of the parameters used in the function definition. Take for example, the function below that takes name and age, then prints them out.<\/p>\n
        def<\/span> nameandage<\/span>(name, age):\r\n    print<\/span>(\"Your name is \"<\/span> +<\/span> name)\r\n    print<\/span>(\"Your age is \"<\/span> +<\/span> str<\/span>(age))\r\n\r\n\r\n# Calling the function using keyword parameters<\/span>\r\nnameandage(name =<\/span> \"Jadon\"<\/span>, age =<\/span> 12<\/span>)\r\n\r\n#this is the same as<\/span>\r\nnameandage( age =<\/span> 12<\/span>, name =<\/span> \"Jadon\"<\/span>)\r\n<\/pre>\n
         <\/p>\n
         <\/p>\n
        7. Default Arguments<\/h4>\n
        In this case you may fail to provide a value for the argument during the function call. Then the argument just assumes a default value.<\/p>\n
        Take for example, the function below. In this case, a default argument is provided at the function definition. So if you omit this argument, the default is used.<\/p>\n
        # default argument specified for age<\/span>\r\ndef<\/span> nameandage<\/span>(name, age =<\/span> 13<\/span>):\r\n    print<\/span>(\"Your name is \"<\/span> +<\/span> name)\r\n    print<\/span>(\"Your age is \"<\/span> +<\/span> str<\/span>(age))\r\n\r\n\r\n# Calling the function without providing argument for age<\/span>\r\nnameandage(name =<\/span> \"Jadon\"<\/span>)\r\n<\/pre>\n
         <\/p>\n
         <\/p>\n
        8. Variable-length arguments<\/strong><\/h4>\n
        This is a situation where you need to provide more arguments than are used during the function definition. To create a variable-length argument, you use the * symbol before the name of the argument. Let’s take an example of a name and a list of scores. While the name is provided, but we would not know how many items are in the scores<\/p>\n
        def<\/span> printdata<\/span>(name, *<\/span>scores):\r\n    print<\/span>(\"Student name: \"<\/span> +<\/span> name)\r\n    print<\/span>(\"Scores are given below\"<\/span>)\r\n    for<\/span> score in<\/span> scores:\r\n        print<\/span>(score)\r\n\r\n\r\nscores =<\/span> [89<\/span>, 84<\/span>, 78<\/span>, 90<\/span>]\r\n\r\n#the variable-length argument is provided<\/span>\r\nprintdata(\"Solace\"<\/span>, scores) \r\n\r\n# the variable-length argument is omitted<\/span>\r\nprintdata(\"Solace\"<\/span>) \r\n<\/pre>\n
         <\/p>\n
        You can see that the variable-length argument can either be provided or omitted. When provided, it is used. But if it is omitted, then it is ignored. Try to run the above code to see the output.<\/p>\n
         <\/p>\n
        9. Global and Local Variables<\/strong><\/h4>\n
        Variables that are defined inside the body of a function are local variables. Therefore, they are available only inside the function block that defines it.<\/p>\n
        However, variables variables defined outside a function are global variables. This means they are available everywhere in the program.
        \n <\/p>\n