Python courses teaching user guide (the easy way)
Python programming is simple: with only a few lines of code, you can do incredible things. Adopting just the most essential aspects, on the other hand, has a disadvantage: it is difficult to expand. This is not to argue that the software cannot handle large amounts of data; it certainly can.
Rather, it means that it will be impossible to expand to a bigger and larger codebase. To put it another way, if you don't start using classes, you'll end up with a jumbled file full of spaghetti code. We'll go over everything you need to know about classes, objects, and instances in this Python Classes Tutorial. With this in mind, you'll be able to write great code in no time.
Table of Contents about Python courses teaching user guide (the easy way)
Here’s what we are going to cover today:- Python Classes Tutorial: the basics
- Python Classes are Required
- Python Classes are now available.
- Python Classes Tutorial: an example
- Wrapping it up
- Conclusion
Python Classes Tutorial: the basics[ps2id id='Python Classes Tutorial: the basics' target=''/]
We should have a notion of the theory before developing the code. Don't worry if you're still puzzled after reading the next parts. When you get to the code, you'll see how everything fits together.Python Classes are Required[ps2id id='Python Classes are Required' target=''/]
Think about how you would manage a file, like we did in this session. You'll need to open a file, read some of its contents, perhaps write something, and then close it. Python does, in fact, provide file-handling procedures, but for the sake of this explanation, let's assume it doesn't. You'd have to construct a function that opens the file and returns a variable that lets you read and write to it. Then you may implement some read, write, and close functions that account for that variable. Your routines will work as shown in the following example.file_handler = open("filename.txt")
some_text = read(file_handler)
write(file_handler, "Some other text..")
close(file_handler)
read function will necessarily need a file handler, provided by the outer scope. And the same is true for the write and close functions. We can say the following about this code:
With functions, you separate the logic (the functions) from the data (the variables). However, you separate also the logic from the data it strictly needs in order to be functional.In other words, our final goal here is to get some text from the file and write some other text to the file. However, we are also handling a
file_handler variable in our outer scope to do that, in order to do what we need.
Read More: The Complete Tutorial on Creating Python Modules
Python Classes are now available.[ps2id id='Python Classes are now available.' target=''/]
We wish to separate the logic and the intermediate data it requires from the data using classes. As a result, this is a legitimate Python class definition. A class is the specification of an entity that is represented by its data and the logic that must be applied to that data.
An object, or instance, of a class is a variable that has the class as type.We already know that a variable could be a string, an integer, a list, and so on. If its type is a class, then this variable is an object (or instance) of that class.
Python Classes Tutorial: an example[ps2id id='Python Classes Tutorial: an example' target=''/]
Instead of defining a class to handle files, we can define a class to handle subscribers. Imagine our application handles the subscriber to a newsletter, for example. Back in the old days, the definition of a subscriber could look something like this.sub1 = 'name': 'John', 'surname': 'Doe', 'mail': 'john.doe@example.com'
name, surname, and mail.
Using a class
With a class, we could force the outer scope to provide this information. To define a class, we use theclass keyword.
class Subscriber:
def __init__(self, name, surname, mail):
self.name = name
self.surname = surname
self.mail = mail
sub1 = Subscriber('John', 'Doe', 'john.doe@example.com')
__init__ function of the Subscriber class, known as the constructor. Each class must have one, and only one. This is a special function, and you cannot use the return keyword in it. Take a look at the previous snippet where we defined the constructor. It takes four parameters, the first being self. In Python, self is a special keyword that represents this very object (not this class).
Understanding “self” and attributes
This object can have attributes, that you can call by using a dot.An attribute is a variable part of the class, and that can have a different value for each class instance.So, in this case, the constructor takes three parameters and assign them to three attributes of the current object. Put the definition of the class in a file, and then add the following code below.
sub1 = Subscriber('John', 'Doe', 'john.doe@example.com')
sub2 = Subscriber('Jane', 'Doe', 'jane.done@example.com')
print(sub1.name)
print(sub2.name)
C:\Users\aless\Desktop>python myscript.py
John
Jane
self acts somehow like a placeholder. For sub1, means exactly sub1; for sub2 it means sub2. This way, the class definition is truly generic and can adapt every time to different data. Thus, the output of the name is different for our two subscribers, even if the code executed to set it was always self.name = name.
Class Members
Besides attributes, classes can have members as well.A member is a function that is part of a class, that will be executed in its instances.We can expand our code as follows.
class Subscriber:
def __init__(self, name, surname, mail):
self.name = name
self.surname = surname
self.mail = mail
def recap(self):
return self.name + " " + self.surname + " <" + self.mail + ">"
sub1 = Subscriber('John', 'Doe', 'john.doe@example.com')
sub2 = Subscriber('Jane', 'Doe', 'jane.done@example.com')
print(sub1.recap())
print(sub2.recap())
recap. It takes just one parameter, self. Just like the constructor, this simply tells Python the meaning of the self keyword inside the function. You don’t need to pass it from outside. Furthermore, you need to have at least self as a parameter for all member functions.
The member function will access object attributes through the self keyword, just like the constructor. Thus, our code will output the following.
C:\Users\aless\Desktop>python myscript.py
John Doe <john.doe@example.com>
Jane Doe <jane.done@example.com>
Back to our file handler…
We started the article with the problem of a file handler. Using classes, accessing a file could look something like the following.file = File('file.txt')
text = file.read()
file.write('Some other text')
file.close()
Read More: The Complete Tutorial on Creating Python Modules
Wrapping it up[ps2id id='Wrapping it up' target=''/]
Best practices
Start working with Python the right way. Python programmers agree on conventions that tell how you should write the code (read this style guide for more info). However, we extracted the most significant points.- The name of the class should be capitalized. If the class name consists of two or more words, capitalize each one (for example, MySampleClass).
- If the class name contains an uppercase acronym, it should be written in full uppercase (as in HTTPHandler).
- Members and attributes should be given lowercase names, with underscores used to separate multiple words (like normal functions and variables).
- Start a member's name with an underscore if you want it to be called by other members of the same class but not by anybody else.
- In the constructor, you should set all of a class's attributes to a value.
- A class should only represent one thing. Classes such as Payer and Team are OK; however, classes such as Players and HTTPAndFTPHandler are not.
- Python is a language for Object-Oriented Programming (OOP). This suggests it was created expressly to operate with objects. Don't be frightened to make advantage of this feature!
Conclusion[ps2id id='Conclusion' target=''/]
Mastering classes take time. The only thing that will help you is practicing, over and over. Try to rewrite some of your scripts using classes, or to solve basic problems with them. Here we have the most important points of this article.- A class is the definition of logic and related data.
- An object or instance is a class with valorized data.
- An attribute is a variable defined in a class and tied to its objects.
- A member is a function defined in a class and tied to its objects.
- You can define a class with the
classkeyword. - To define the constructor, define the member
__init__. - All members need to have
selfas a first parameter, including the constructor.
Comments
Post a Comment