Added all docs for Module 8

Author: Showndarya

Args.md

@@ -0,0 +1,38 @@
+## Args and Kwargs
+```python
+The purpose of *args is that, *args are used to help the developer passing a variable number 
+of arguments to a function.
+The symbol * makes args iterable which means that you can run a for loop and process 
+every argument inside the args list.
+```
+### Example
+![Code1](/images/A1.png)
+```
+Now what if you want to pass a list and print every number in the list
+```
+![Code2](/images/A2.png)
+```python
+The list is getting printed in one line as the whole list is taken as 1 parameter.
+Suppose if you want to print each element of the list then while passing parameters in call add * before list name.
+```
+![Code3](/images/A3.png)
+```
+**kwargs help the developer to give arbitrary keyworded arguments to a
+function and access them later in a dictionary.
+We will see an example where we are passing 2 parameters to a
+function with 2 parameters and to a function with kargs parameter.
+```
+![Code4](/images/A4.png)
+```
+We can see that in the former case it is printing 1 1 so we cannot identify which is x and which is y, But in the latter case it is easily recognizable.
+
+What if we only want to print the value of x then:
+```
+![Code5](/images/A5.png)
+```
+Now if we want to use *args and **kwargs together:
+First we should see to it that *args should always be before 
+**kwargs or else it will throw an error message.
+```
+![Code6](/images/A6.png)
+![Code7](/images/A7.png)

Format_Function.md

@@ -0,0 +1,27 @@
+### Format Function
+```python
+The .format() method of the str type is an extremely convenient way to format text exactly the way you want it.
+Here is the general form: 
+template.format(p0, p1, ..., k0=v0, k1=v1, ...)
+The arguments to the .format() method are of two types. The list starts with zero or more positional arguments pi, followed by zero or more keyword arguments of the form ki=vi, where each ki is a name with an associated value vi.
+```
+### Example
+```
+1.Here we could see that if there are are no values in the curly brackets it directly maps according to the position. And if there are are position given in the curly brackets then it maps them according to the given index.
+```
+![Code1](/images/F1.png)
+```
+2.If you want to shift a no to right then you can include the no of spaces required after the colon
+```
+![Code2](/images/F2.png)
+```
+3.For printing a no its square and its cube we can use the formatting techniques.
+```
+![Code3](/images/F3.png)
+```
+We could see the difference when we use the formatting tools. The 1st one uses formatting functions.
+```
+![Code4](/images/F4.png)
+```
+4.We can use it for rounding of some values to given decimal points.
+```

Logging.md

@@ -0,0 +1,59 @@
+## Logging
+```python
+When you transfer money, there are transfer records.
+If something goes wrong, people can read the log and has a chance to figure out what happened. 
+Likewise, logging is important for system developing, debugging and running. 
+When a program crashes, if there is no logging record, you have little chance to understand what happened.
+You can use the logging functions by just importing logging.
+```
+### Logging Levels
+```
+There are many logging levels. 
+The numeric values of logging levels are given in the following table. 
+These are primarily of interest if you want to define your own levels, and need them to have specific values relative to the predefined levels. 
+If you define a level with the same numeric value, it overwrites the predefined value; the predefined name is lost.
+```
+|Level| Numeric value|
+|-----|------|
+CRITICAL|50
+ERROR|40
+WARNING|30
+INFO|20
+DEBUG|10
+NOTSET|0
+```python
+They are usually used with:
+logging.basciConfig(level=logging.DEBUG)  Or
+logging.basciConfig(level=logging.INFO)
+```
+### Steps
+```python
+Create a file and enter the logging code and then run the code , output will appear on the shell.
+If you are using any file name like:
+logging.basicConfig(filename='example.log',level=logging.DEBUG)
+Then you can see your output in the file named ‘example’ .
+However the default level is WARNING
+```
+#### Case 1
+```python
+If no level was mentioned:
+It does not take the .info information
+```
+![Code1](/images/LO1.png)
+![Code2](/images/LO2.png)
+#### Case 2
+```python
+When level was debug, all the statements were executed.
+```
+![Code3](/images/LO3.png)
+![Code4](/images/LO4.png)
+```python
+Here we can see that logging is similar to print statements
+But..
+It works when the program is a simple script, but for complex systems, you better not to use this approach. First of all, you cannot leave only important messages in the log, you may see a lots of garbage messages in the log, but can’t find anything useful.You also cannot control those print statements without modifying code, you may forgot to remove those unused prints.
+
+It can be used with some formatting functions also:
+```
+![Code5](/images/LO5.png)
+![Code6](/images/LO6.png)
+