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

# Simple values and complex objects

In a technical sense, every value in Python is an object. In practice, there is a distinction between simple values and more complex objects. Numbers and Booleans can be considered simple values.

Let's say, we have two values: `a` and `b`. If the value in variable `a` is simple, and you execute the assignment `b = a`, the value is _**copied**_ from `a` into `b`. You can subsequently change the value in either `a` or `b` without affecting the value in the other variable. 

However, consider the following scenario:

a = [1, 2, 3]
b = a
b[1] = 99
print(a)  # prints [1, 99, 3]

In this example, `a` is a list, and lists are a kind of object. This list is not actually stored _**in**_ `a`. It is stored somewhere else in memory, and what is stored in `a` is a _**pointer**_ (also known as a _**link**_, _**reference**_, or _**address**_) to the object.

You can think of it this way: A variable can really hold only a simple value, meaning a value that can be held in eight or fewer bytes. Examples of simple values include numbers, Booleans, and pointers. Lists, sets, dictionaries, strings, and other objects are not simple, and they require more than eight bytes.

This means that if `a` holds a **simple value**, such as **5**, then `b = a` copies the value **5** into `b`. However, if the value of `a` is a **complex object**, such as a list, then `a` holds a pointer to that object, and `b = a` copies the _**pointer**_ into `b`. The result is that both `b` and `a` hold a pointer to _**the same list**_.

If another list is then assigned to `a`, that is fine. `a` gets a new pointer in it, but `b` isn't changed. However, if some element of the list gets changed, for example by `b[3] = 17`, that change is visible to every variable that holds a pointer to the list.

Consider the following function:

```python
def f(x, y):
 x[1] = 99
 y = sorted(y)
```

Now, execute the following statements to see what happens:

In this lesson, you'll learn about the concept of references in Python.

Introduction

The Absolute Bare Minimum

Better Tools

Classes

Getting Fancy

Testing

Graphical User Interfaces

Modules

Appendix

I Guess We're Doing Python Now Exam

References

Simple values and complex objects