Ads and ad measurement. Disabled until you allow it.
ABOUT SITE
All open site tabs
Python · Syntax · Beginner
OOP Basics
11 tasks
Practical exercises on the basics of OOP in Python: creating classes and objects, attributes, methods, __init__, changing object state, and simple entity modeling.
Quick topic start and explanations before exercises (exercises below):
A class is a blueprint. An object is what you build from that blueprint. The same class can produce thousands of objects, each with its own independent data.
Before classes, if you needed to track multiple bank accounts, you would use separate variables for each balance. With a class, you define the structure once and create as many instances as you need — each one carries its own state.
```python
class BankAccount:
def __init__(self, balance):
self.balance = balance
acc1 = BankAccount(100)
acc2 = BankAccount(500)
print(acc1.balance) # 100
print(acc2.balance) # 500
```
acc1 and acc2 are independent objects. Changing acc1.balance does not affect acc2.
Classes group two things together: data (attributes) and behavior (methods). A method is just a function defined inside a class. This grouping is the main idea behind object-oriented programming — keep the data and the code that operates on it in the same place.
__init__ is a special method Python calls automatically when you create a new object. It sets up the initial state of the instance.
```python
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
r = Rectangle(3, 4)
print(r.width, r.height) # 3 4
```
self is a reference to the object being created. When you write self.width = width, you are storing the value on the object itself — not in a local variable that disappears when __init__ finishes. Every attribute you want the object to remember must be assigned to self.
self is always the first parameter of every method, but you never pass it manually. Python passes it automatically. When you call r.area(), Python translates that to Rectangle.area(r) — r becomes self inside the method.
```python
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
r = Rectangle(3, 4)
print(r.area()) # 12
```
The method uses self.width and self.height — the values that were stored during __init__. The method has access to everything the object knows about itself through self.
A method that modifies the object's state — returns nothing, just changes an attribute:
```python
class Counter:
def __init__(self, value):
self.value = value
def increment(self):
self.value += 1
c = Counter(0)
c.increment()
c.increment()
print(c.value) # 2
```
A method that checks a condition and returns a boolean:
```python
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def is_adult(self):
return self.age >= 18
```
A method that computes something from the attributes and returns a value:
```python
class Temperature:
def __init__(self, celsius):
self.celsius = celsius
def to_fahrenheit(self):
return self.celsius * 9 / 5 + 32
```
A method that both mutates state and validates input:
```python
class BankAccount:
def __init__(self, balance):
self.balance = balance
def deposit(self, amount):
self.balance += amount
```
The pattern is always the same: access what you need through self, compute or modify, return only if there is a meaningful value to return.
**Class syntax**
```python
class ClassName:
def __init__(self, param1, param2):
self.attr1 = param1 # store on the object
self.attr2 = param2
def method(self): # self is always first
return self.attr1
obj = ClassName(val1, val2) # create an instance
obj.attr1 # read an attribute
obj.method() # call a method
```
**`self` rules**
| Rule | Why |
|---|---|
| Every method must have `self` as its first parameter | Python passes the object automatically |
| Use `self.name` to store data on the object | plain `name =` is just a local variable |
| Use `self.name` to read data in any method | all methods share the same object |
| Never pass `self` manually when calling a method | `obj.method()` not `obj.method(obj)` |
**Method types**
| Type | Returns | Example |
|---|---|---|
| Mutate state | nothing (`None`) | `self.balance += amount` |
| Check condition | `bool` | `return self.age >= 18` |
| Compute value | result | `return self.w * self.h` |
| Mixed | depends | validate then mutate |
**Common mistakes**
```python
# Forgetting self. — creates a local variable, lost after __init__:
def __init__(self, name):
name = name # wrong — local only
self.name = name # correct
# Forgetting self in a method call:
def area(self):
return width * height # NameError — should be self.width
return self.width * self.height # correct
# Missing self in method signature:
def area(): # wrong — Python passes obj as first arg
def area(self): # correct
```
Create a User class with a name attribute.
Create an object of this class and print its name.
class User:
pass
u = User("Alex")
print(u.name)
Solution
class User:
def __init__(self, name):
self.name = name
u = User("Alex")
print(u.name)
# or you can create a method that returns the name
class User:
def __init__(self, name):
self.name = name
def get_name(self):
return self.name
Create a Counter class with a value attribute.
Add an increment method that increases the value by 1.
class Counter:
pass
c = Counter(0)
c.increment()
print(c.value)
Solution
class Counter:
def __init__(self, value):
self.value = value
def increment(self):
self.value += 1
c = Counter(0)
c.increment()
print(c.value)
# or you can do this: increment may return the new value
class Counter:
def __init__(self):
self.value = 0
def increment(self):
self.value += 1
return self.value
Create a Rectangle class with width and height attributes.
Add an area method that returns the area.
class Rectangle:
pass
r = Rectangle(3, 4)
print(r.area())
Solution
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
r = Rectangle(3, 4)
print(r.area())
# or you can do this: save the area to a variable first
class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
result = self.width * self.height
return result
Create a Temperature class with a celsius attribute.
Add a to_fahrenheit method that returns the temperature
in degrees Fahrenheit. The formula is: celsius * 9 / 5 + 32.
class Temperature:
pass
t = Temperature(0)
print(t.to_fahrenheit())
Write a Formatter class with a string attribute on the object.
When an instance of this class (object) is created, a string is passed there and stored
in this string attribute of the object. This class should have several methods that return modified
versions of this string according to their purpose: - the trim method returns a string trimmed to the specified length at the end with "[...]" (the length of these added characters must be taken into account). - the truncate method returns a string trimmed to the specified length, but it does not "break words", instead it trims by spaces, but not longer than the specified length. This is enough. ATTENTION: - the original string in self.string must always remain unchanged. - do not create any other attributes for results, only return new values. Local variables are of course allowed. - you may create attributes for service data, for example for the string "[...]" Remember that methods are just special functions where the first self parameter automatically receives a reference to the object itself, but
all other rules such as ordinary local variables and so on are the same as in regular functions. That is, inside a method it is not necessary to put everything into self.variable, you can
simply create local variables as in regular functions.
class Formatter():
def __init__(self, string):
pass
def trim(self, length):
pass
def truncate(self, length):
pass
x = Formatter("Эта строка для примера просто используется тут и не имеет другого смысла.")
print(x.trim(15)) # Эта строка[...]
print(x.truncate(15)) # Эта строка для
print(x.string) # Изначальная строка
y = Formatter("Ура у меня получилось!.")
print(y.trim(8)) # Ура[...]
print(y.truncate(3)) # Ура
print(y.string) # Изначальная строка
Solution
class Formatter():
def __init__(self, string):
self.string = string
self.end = "[...]"
def trim(self, length):
return self.string[: length - len(self.end)] + self.end
def truncate(self, length):
if self.string[length] == " ":
return self.string[:length]
return self.string[:length].rsplit(" ", 1)[0]
x = Formatter("Эта строка для примера просто используется тут и не имеет другого смысла.")
print(x.trim(15)) # Эта строка[...]
print(x.truncate(15)) # Эта строка для
print(x.string) # Изначальная строка
y = Formatter("Ура у меня получилось!.")
print(y.trim(8)) # Ура[...]
print(y.truncate(3)) # Ура
print(y.string) # Изначальная строка
No split tab
Cookie preferences
We use necessary cookies to run the site. With your permission, we can also save your site preferences and use analytics and advertising cookies to understand usage and support the project.
Open tools in tabs.Exercises, IDE tools, and trainers stay available as site tabs.
Switch without losing context.Move between explanations, code, and utilities while keeping your place.
Use the sidebar as your map.The left panels hold navigation, settings, files, libraries, and tool controls.
PythonJavaScriptSQLite
One IDE, three practical modes
Python in the browser.Run small scripts, try libraries, and practice API requests without installing anything.
JavaScript for quick experiments.Test browser-friendly code and compare ideas next to your learning materials.
SQLite for data practice.Open the database explorer to inspect tables, write queries, and learn SQL workflows locally.
TopicIDE
Work side by side with split tabs
Keep instructions visible.Open an exercise or reference page beside the IDE instead of jumping back and forth.
Compare tools while you learn.Place regex checks, explanations, and code experiments next to each other when the task needs it.
Close the split when you are done.The workspace returns to a single focused tab, and your open site tabs remain available.
Code Typing Trainer
Or plain text
This trainer is designed for a physical keyboard.Open this section on a laptop or desktop with a wide screen. Touch typing practice will not work correctly on a phone.
Speed: 0 chars/min
0 words/min
Best speed (60s): 0 chars/min
0 words/min
Errors: 0
Total time: 0.0 s
To practice touch typing, avoid looking at your physical keyboard.