Gain insights into Python by exploring basic to advanced concepts, including loops, classes, and GUIs with Tkinter. Delve into testing and become a productive Python programmer.

complete.tar.gz

InputN-copy

Error-copy

In this course, you will get a comprehensive overview of Python. You will start by laying the foundation and learning the introductory topics like operators, conditional statements, functions, loops, assignment statements, and more. You will then move onto more advanced topics such as classes and inheritance, iterators, list comprehensions, and dictionaries. Along with this, you will also get to explore the concept of testing and take a look at how GUI applications can be designed using Tkinter, Python's standard GUI library. 

By the time you're done, you'll be able to hit the ground running and be equipped with the tools that will allow you to be productive in Python.

Python 3: From Beginner to Advanced

# Parameters vs arguments

With no additional syntax, **arguments** (expressions in a function call) are matched to **parameters** (variables in a function definition) by position. The first parameter gets the value of the first expression, and so on.

# Introduction to parameters

**Parameters** in a function definition may be:

* A simple variable that is matched to an argument by position. Positional parameters must precede any other parameters.
* `variable=value`: to give a default value for missing arguments.
* `*args` - to accept multiple arguments as a single tuple. By convention, the name `args` is usually used for this purpose.
* `**kwargs`: to accept multiple keyword arguments as a dictionary. By convention, the name `kwargs` (keyword arguments) is usually used for this purpose.

`*args` or `**kwargs` can only be used as last parameters because they collect all remaining arguments.

# Introduction to arguments

**Arguments** in a function call can be:

* An expression
* `name=value`: to give a value to the parameter with that name. This is called a **named argument** or **keyword argument**. If both positional and keyword arguments are used, all positional arguments must precede keyword arguments.
* `*tuple`: to pass a tuple as separate arguments.
* `**dictionary`: to pass in values to multiple parameters by name.

## Positional vs keyword arguments

Starting with **Python 3.8**, arguments can be forced to be positional only. A single slash, `/`, in place of a parameter, means that all earlier arguments must be **positional**. An asterisk, `*`, in place of a parameter means that all following arguments must be **keywords**. For example, given the function below:

```python
def foo(a, b, /, c, d, *, e, f):
	print(a, b, c, d, e, f)
```
Arguments for `a` and `b` must be by position only, and arguments for `e` and `f` must be keywords. Arguments for `c` and `d` may be either (but since positional arguments must precede keyword arguments, `d` cannot be positional if `c` is keyword).

Many of the functions described in the official Python documentation appear to have a single asterisk as a parameter. For example: 
```python
os.remove(path, *, dir_fd=None)
``` 
This is a documentation convention to indicate that the subsequent arguments can only be given as named arguments. It does not mean you should put an asterisk in the function call.

# Parameters and arguments examples

* The following is an example of passing both **positional** and **keyword** arguments in functions:

You’ll learn about what parameters and arguments are in Python in this lesson.

Introduction

The Absolute Bare Minimum

Better Tools

Classes

Getting Fancy

Testing

Graphical User Interfaces

Modules

Appendix

I Guess We're Doing Python Now Exam

Parameters and Arguments

Parameters vs arguments

Introduction to parameters