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

# Comparing objects in Python

The equality (`==`) and inequality (`!=`) operators work well with Python’s built-in object types. However, when you define your own classes, `==` will always return `False` when comparing two objects.

When we talk about drawing comparison between two objects, it is important to keep in mind the distinction between _equal_ and _identical_. 

* Two objects, `a` and `b`, are **equal** if every part of `a` is the same as the corresponding part of `b`. If you change `a`, `b` might or might not change. **Testing for equality** requires testing all the parts.

*  However, if `a` and `b` are **identical** then they are just two different names for the same object. Changing that object by doing something to `a` means that `b` also undergoes the change. **Testing for identity** just involves testing whether `a` and `b` both refer to the same location in memory.

When comparing objects in Python, keep in mind the following points:

- The assignment `a = b` **never** makes a **copy** of an object `b`. It only makes `a` refer to the same object as `b`.

- When you use an **object as an argument** to a function, the function gets a **reference** to the **original** object, **not** a copy.

- `a is b` tests whether `a` and `b` refer to the **same** object. `a is not b` tests whether they are **different** (but possibly equal) objects.

# Built-in equality class methods

For your own class, you can easily define **equality** and **ordering** by defining some special methods in the class, which you can find below: 

> **Note**: All these names use double underscores.

- `__eq__(self, other)` should return `True` if you consider the `self objects` and `other` to be **equal** and `False` otherwise. **Identical** objects should be considered to be equal (you can test identity with the `is` operator). This method will be called when your objects are compared using `==`.

- `__ne__(self, other)` will be called when objects are compared using `!=`.

- `__lt__(self, other)` will be called when objects are compared using `<`.

- `__le__(self, other)` will be called when objects are compared using `<=`.

- `__ge__(self, other)` will be called when objects are compared using `>=`.

- `__gt__(self, other)` will be called when objects are compared using `>`.

**These methods are all independent**. Defining some of them does _not_ automatically define others. For example, if you define an `__eq__` method, `__ne__` does not magically pop into being. If you wish to use any of the comparison operators (`==`, `!` `=`, etc.) for your objects, you must define the corresponding method. If you don’t, you will get the default behavior for the operators, which will almost certainly be incorrect.

The following examples makes use of these operators:

Here, you'll learn how to compare different objects with one another 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

Comparing Objects

Comparing objects in Python