In this course, you’ll explore object-oriented programming in Python by building a social media app using classes, inheritance, and encapsulation.

python12.tar.gz

Python3.12

code widget

This course offers a comprehensive introduction to object-oriented programming (OOP) in Python, a paradigm shift from procedural programming after you’ve learned the language basics.

Starting with the fundamentals of classes, objects, and methods, you’ll learn how to structure code for better organization, scalability, and readability. You’ll explore essential OOP concepts like encapsulation, inheritance, and polymorphism through hands-on examples, including a micro social media platform called Chirpy. You’ll practice creating private data attributes to protect your code from unintended interference, supporting the principle of abstraction and encapsulation.

By the end, you’ll develop a solid understanding of Python’s OOP features and gain confidence in designing and building real-world applications that are easy to extend. This journey prepares you to tackle advanced topics and larger projects, strengthening your foundation in Python’s object-oriented best practices.

Object-Oriented Programming in Python

from user import User
from post import Post

class VerifiedUser(User):
    def __init__(self, username, display_name, password):
        # Inherit attributes from User
        super().__init__(username, display_name, password)
        # Mark the user as verified
        self.verification_badge = True

    def get_verification_status(self):
        return "Verified ✅" if self.verification_badge else "Regular"

    # Overriding create_post() to add a "✅ " prefix to the content
    def create_post(self, content):
        # Add a special flair to posts created by verified users
        verified_content = "✅  "+  content
        post = Post(verified_content, self)
        self._posts.append(post)
        return post

class Comment:
    def __init__(self, text, commenter):
        self._text = text              # The text content of the comment (private)
        self._commenter = commenter    # The User who made the comment (private)

    def display_comment(self):
        # Accessing the private attributes internally within the class
        print(self._commenter.display_name + " commented: '" + self._text + "'")

class SocialNetwork:
    def __init__(self):
        self._users = [ ]   # Private list to store User objects
        self._posts = [ ]   # Private list to store Post objects

    def add_user(self, user):
        if self.search_user_by_username(user.username):
            print("\nUser with username", user.username, "already exists!\n")
        else:
            self._users.append(user)
            print(user.display_name, "has been added to Chirpy.")

    def add_post(self, post):
        self._posts.append(post)

    def search_user_by_username(self, username):
        for user in self._users:
            if user.username == username:
                return user
        return None

    def remove_user(self, username):
        user_to_remove = self.search_user_by_username(username)
        if user_to_remove:
            self._users.remove(user_to_remove)
            print("\n", user_to_remove.display_name, "has been removed from Chirpy.")
        else:
            print("\nUser with username", username, "not found!")

    def list_all_posts(self):
        if not self._posts:
            print("\nNo posts to display.")
        else:
            for post in self._posts:
                print(post.author.display_name + " posted: '" + post.content + "'")

from post import Post  
import random

class User:
    total_users = 0  

    def __init__(self, username, display_name, password):
        self._username = username                    # Private attribute
        self._display_name = display_name            # Private attribute with controlled access
        self._password = password                    # Private attribute for security and abstraction
        self._posts = [ ]                             # Private attribute
        User.total_users += 1

    # Getter for username (read-only property)
    @property
    def username(self):
        return self._username

    # Getter for display_name
    @property
    def display_name(self):
        return self._display_name

    # Setter for display_name
    @display_name.setter
    def display_name(self, value):
        if not value:
            raise ValueError("Display name cannot be empty.")
        if len(value) > 20:
            raise ValueError("Display name cannot be longer than 20 characters.")
        self._display_name = value

    def show_profile(self):
        print("User:", self.display_name, "(@" + self.username + ")")

    def create_post(self, content):
        post = Post(content, self)
        self._posts.append(post)
        return post

    def like_post(self, post):
        post.like_post(self)

    @classmethod
    def create_guest_user(cls):
        random_number = random.randint(100, 999)
        username = "guest" + str(random_number)
        display_name = "Guest"  
        return cls(username, display_name, "guestpass")

    def change_password(self, new_password):
        if len(new_password) >= 6:
            self._password = new_password
            print("Password updated successfully!")
        else:
            print("Error: Password must be at least 6 characters long.")

    def check_password(self, input_password):
        return input_password == self._password
    
    # User-friendly representation of the User object
    def __str__(self):
        return "<User: %s (%s)>" % (self.display_name, self.username)

from comment import Comment  

class Post:
    total_posts = 0

    def __init__(self, content, author):
        self._content = content                  # Private attribute to store content
        self._author = author                    # Private attribute to store author
        self._likes = [ ]                         # Private attribute to store likes
        self._like_count = 0                     # Private attribute for counting likes
        self._comments = [ ]                      # Private attribute to store comments
        Post.total_posts += 1

    # Getter for content
    @property
    def content(self):
        return self._content

    # Setter for content with validation
    @content.setter
    def content(self, new_content):
        if len(new_content) > 280:
            raise ValueError("Chirp content cannot exceed 280 characters.")
        self._content = new_content

    # Getter for author (read-only)
    @property
    def author(self):
        return self._author

    # Method to handle liking a post
    def like_post(self, user):
        if user not in self._likes:
            self._likes.append(user)
            self._like_count += 1
            print(user.display_name, "liked this post!")
        else:
            print(user.display_name, "has already liked this post!")

    # Getter for like count
    def get_like_count(self):
        return self._like_count

    # Method to add a comment
    def add_comment(self, text, commenter):
        comment = Comment(text, commenter)
        self._comments.append(comment)
        print(comment.commenter.display_name, "added a comment on", self.author.display_name + "'s post.")
        return comment

    # Getter for comments
    @property
    def comments(self):
        return self._comments.copy()  # returns a copy to maintain encapsulation

    # Static method to validate content length without needing an instance
    @staticmethod
    def validate_content_length(content):
        return len(content) <= 280

    # Debugging-friendly representation of a Post object
    def __repr__(self):
        snippet = self._content if len(self._content) <= 30 else self._content[:27] + "..."
        return "<Post by %s: '%s', Likes: %d>" % (self._author.username, snippet, self._like_count)

from user import User
from verified_user import VerifiedUser
from social_network import SocialNetwork

# Create an instance of the Chirpy social network
chirpy_network = SocialNetwork()

# Create a regular user and a verified user
regular_user = User("alex123", "Alex", "secret123")
verified_user = VerifiedUser("emma8", "VerifiedEmma", "secret456")

# Add both users to the network
chirpy_network.add_user(regular_user)
chirpy_network.add_user(verified_user)

# Regular user creates a post
regular_post = regular_user.create_post("Hello world! This is my first chirp.")
chirpy_network.add_post(regular_post)

# Verified user creates a special post
verified_post = verified_user.create_post("I am here to share my thoughts!")
chirpy_network.add_post(verified_post)

# Display a friendly representation (user-friendly) of a user profile
print("\nUser Profile:")
print(regular_user)  # Invokes User.__str__ to provide user-friendly representation

# Display debugging-friendly information (developer-focused) about posts
print("\nDebugging Information for Posts:")
for post in chirpy_network._posts:
    print(repr(post))  # Invokes Post.__repr__ for detailed debugging info

# Display a clean and structured list of all posts in the network
print("\nAll Chirpy Posts:")
chirpy_network.list_all_posts()

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


Introduction to OOP

Core Classes and Objects

Organize and Protect Data

Enhance Functionality with Advanced OOP Concepts

Code Organization and Final Review

Conclusion

Polishing and Refactoring

Fixing private data members