{"id":259760,"date":"2025-05-13T15:02:51","date_gmt":"2025-05-13T15:02:51","guid":{"rendered":"https:\/\/ded9.com\/?p=259760"},"modified":"2025-10-28T08:19:16","modified_gmt":"2025-10-28T08:19:16","slug":"understanding-classes-and-object-oriented-programming-in-python","status":"publish","type":"post","link":"https:\/\/ded9.com\/tr\/understanding-classes-and-object-oriented-programming-in-python\/","title":{"rendered":"Discover Classes &#038; Object-Oriented Programming in Python"},"content":{"rendered":"<p>In Python, a <strong>class<\/strong> is a blueprint for creating objects\u2014individual instances that combine data (attributes) and behavior (methods). Classes are central to <strong>object-oriented programming (OOP)<\/strong>, a programming paradigm that organizes code into reusable, modular units.<\/p>\n<p>OOP makes complex programs easier to manage, scale, and maintain, powering everything from web applications to machine learning models.<\/p>\n<p>This guide explains what classes are, how they relate to OOP principles, and how to use them in Python. Through examples, you&#8217;ll learn to create courses, instantiate objects, and apply OOP concepts like encapsulation, inheritance, and polymorphism.<\/p>\n<h2>1. What is Object-Oriented Programming?<\/h2>\n<p><iframe title=\"Object Oriented Programming with Python - Full Course for Beginners\" width=\"800\" height=\"450\" src=\"https:\/\/www.youtube.com\/embed\/Ej_02ICOIgs?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe><\/p>\n<p>OOP is a way of structuring code around <strong>objects<\/strong>, which are instances of <strong>classes<\/strong>. Think of a class as a template (e.g., a car blueprint) and an object as a specific instance (e.g., a red Toyota Corolla). OOP emphasizes four key principles:<\/p>\n<ul>\n<li><strong>Encapsulation<\/strong>: Bundling data and methods together, controlling access to protect data.<\/li>\n<li><strong>Inheritance<\/strong>: Allowing one class to inherit attributes and methods from another, promoting code reuse.<\/li>\n<li><strong>Polymorphism<\/strong>: Allowing objects to be treated as instances of a parent class, even if they belong to a subclass, allows flexible behavior.<\/li>\n<li><strong>Abstraction<\/strong>: Hiding complex details and exposing only necessary functionality.<\/li>\n<\/ul>\n<p>Python&#8217;s class system supports these principles, making it a powerful tool for OOP.<\/p>\n<h2>2. What is a Class in Python?<\/h2>\n<h2><img fetchpriority=\"high\" decoding=\"async\" class=\"aligncenter wp-image-259765 size-full\" src=\"https:\/\/ded9.com\/wp-content\/uploads\/2025\/05\/class1.png\" alt=\"What is a Class in Python?\" width=\"1198\" height=\"817\" srcset=\"https:\/\/ded9.com\/wp-content\/uploads\/2025\/05\/class1.png 1198w, https:\/\/ded9.com\/wp-content\/uploads\/2025\/05\/class1-300x205.png 300w, https:\/\/ded9.com\/wp-content\/uploads\/2025\/05\/class1-1024x698.png 1024w, https:\/\/ded9.com\/wp-content\/uploads\/2025\/05\/class1-768x524.png 768w\" sizes=\"(max-width: 1198px) 100vw, 1198px\" \/><\/h2>\n<p>A class defines the structure and behavior of objects. It specifies:<\/p>\n<ul>\n<li><strong>Attributes<\/strong>: Data associated with the object (e.g., a car&#8217;s color).<\/li>\n<li><strong>Methods<\/strong>: Functions that define the object&#8217;s behavior (e.g., a car&#8217;s ability to drive).<\/li>\n<\/ul>\n<h3>Basic Syntax<\/h3>\n<p>Here&#8217;s a simple class definition:<\/p>\n<div class=\"wp-block-codemirror-blocks code-block \">\n<pre class=\"CodeMirror\" data-setting=\"{&quot;mode&quot;:&quot;python&quot;,&quot;mime&quot;:&quot;text\/x-python&quot;,&quot;theme&quot;:&quot;material&quot;,&quot;lineNumbers&quot;:false,&quot;lineWrapping&quot;:false,&quot;styleActiveLine&quot;:false,&quot;readOnly&quot;:true,&quot;align&quot;:&quot;&quot;}\">class Car: def __init__(self, brand, color): self.brand = brand # Instance attribute self.color = color def drive(self): # Instance method return f\"The {self.color} {self.brand} is driving!\"<\/pre>\n<\/div>\n<ul>\n<li><strong><code>class<\/code> Keyword<\/strong>: Declares a class named <code>Car<\/code>.<\/li>\n<li><strong><code>__init__<\/code> Method<\/strong>: The constructor initializes attributes when an object is created.<\/li>\n<li><strong><code>self<\/code><\/strong>: Refers to the instance, allowing access to its attributes and methods.<\/li>\n<li><strong>Attributes<\/strong>: <code>brand<\/code> and <code>color<\/code> store data for each <code>Car<\/code> object.<\/li>\n<li><strong>Methods<\/strong>: <code>drive<\/code> Defines behavior.<\/li>\n<\/ul>\n<h3>Creating Objects<\/h3>\n<p>You instantiate a class to create an object:<\/p>\n<div class=\"wp-block-codemirror-blocks code-block \">\n<pre class=\"CodeMirror\" data-setting=\"{&quot;mode&quot;:&quot;python&quot;,&quot;mime&quot;:&quot;text\/x-python&quot;,&quot;theme&quot;:&quot;material&quot;,&quot;lineNumbers&quot;:false,&quot;lineWrapping&quot;:false,&quot;styleActiveLine&quot;:false,&quot;readOnly&quot;:true,&quot;align&quot;:&quot;&quot;}\">my_car = Car(\"Toyota\", \"Red\") # Create an object print(my_car.brand) # Output: Toyota print(my_car.drive()) # Output: The Red Toyota is driving!<\/pre>\n<\/div>\n<p>Each object (<code>my_car<\/code>) is an independent instance with its attributes.<\/p>\n<h2>3. Classes and OOP Principles<\/h2>\n<p>Classes in Python directly support OOP principles. Let&#8217;s explore with examples.<\/p>\n<h3>Encapsulation<\/h3>\n<p>Encapsulation bundles data and methods, often restricting access to some components to prevent unintended changes. Python uses naming conventions for access control:<\/p>\n<ul>\n<li><strong>Public<\/strong>: Attributes\/methods (e.g., <code>brand<\/code>) are accessible everywhere.<\/li>\n<li><strong>Protected<\/strong>: Attributes with a single underscore (e.g., <code>_brand<\/code>) suggest internal use (convention, not enforced).<\/li>\n<li><strong>Private<\/strong>: Attributes with double underscores (e.g., <code>__brand<\/code>) trigger name mangling, making them harder to access outside the class.<\/li>\n<\/ul>\n<p>Example:<\/p>\n<div class=\"wp-block-codemirror-blocks code-block \">\n<pre class=\"CodeMirror\" data-setting=\"{&quot;mode&quot;:&quot;python&quot;,&quot;mime&quot;:&quot;text\/x-python&quot;,&quot;theme&quot;:&quot;material&quot;,&quot;lineNumbers&quot;:false,&quot;lineWrapping&quot;:false,&quot;styleActiveLine&quot;:false,&quot;readOnly&quot;:true,&quot;align&quot;:&quot;&quot;}\">class BankAccount: def __init__(self, owner, balance): self.owner = owner self.__balance = balance # Private attribute def deposit(self, amount): if amount &gt; 0: self.__balance += amount return f\"Deposited ${amount}. New balance: ${self.__balance}\" return \"Invalid deposit amount\" def get_balance(self): # Public method to access private attribute return self.__balance account = BankAccount(\"Alice\", 1000) print(account.deposit(500)) # Output: Deposited $500. New balance: $1500 print(account.get_balance()) # Output: 1500 # print(account.__balance) # Error: Attribute not directly accessible<\/pre>\n<\/div>\n<p><strong>Why It Matters<\/strong>: Encapsulation protects <code>.__balance<\/code> from external modification, ensuring deposits follow the <code>deposit<\/code> method&#8217;s logic.<\/p>\n<h3>Inheritance<\/h3>\n<p>Inheritance allows a class (child) to inherit attributes and methods from another class (parent), enabling code reuse.<\/p>\n<p>Example:<\/p>\n<div class=\"wp-block-codemirror-blocks code-block \">\n<pre class=\"CodeMirror\" data-setting=\"{&quot;mode&quot;:&quot;python&quot;,&quot;mime&quot;:&quot;text\/x-python&quot;,&quot;theme&quot;:&quot;material&quot;,&quot;lineNumbers&quot;:false,&quot;lineWrapping&quot;:false,&quot;styleActiveLine&quot;:false,&quot;readOnly&quot;:true,&quot;align&quot;:&quot;&quot;}\">class Vehicle:  # Parent class\r\n    def __init__(self, brand):\r\n        self.brand = brand\r\n\r\n    def start_engine(self):\r\n        return f\"{self.brand}'s engine started!\"\r\n\r\nclass Car(Vehicle):  # Child class inherits from Vehicle\r\n    def __init__(self, brand, color):\r\n        super().__init__(brand)  # Call parent's __init__\r\n        self.color = color\r\n\r\n    def drive(self):\r\n        return f\"The {self.color} {self.brand} is driving!\"\r\n\r\nmy_car = Car(\"Honda\", \"Blue\")\r\nprint(my_car.start_engine())  # Output: Honda's engine started!\r\nprint(my_car.drive())  # Output: The Blue Honda is driving!<\/pre>\n<\/div>\n<ul>\n<li><strong><code>super()<\/code><\/strong>Calls the parent class&#8217;s methods.<\/li>\n<li><strong>Extending<\/strong>: <code>Car<\/code> inherits <code>start_engine<\/code> from <code>Vehicle<\/code> and adds its own <code>drive<\/code> method.<\/li>\n<\/ul>\n<p><strong>Why It Matters<\/strong>: Inheritance reduces duplication by sharing standard functionality across related classes.<\/p>\n<h3>Polymorphism<\/h3>\n<p><a href=\"https:\/\/en.wikipedia.org\/wiki\/Polymorphism_(computer_science)\" target=\"_blank\" rel=\"noopener\">Polymorphism<\/a> allows different classes to be treated as instances of a typical parent class, with each class implementing methods.<\/p>\n<p>Example:<\/p>\n<div class=\"wp-block-codemirror-blocks code-block \">\n<pre class=\"CodeMirror\" data-setting=\"{&quot;mode&quot;:&quot;python&quot;,&quot;mime&quot;:&quot;text\/x-python&quot;,&quot;theme&quot;:&quot;material&quot;,&quot;lineNumbers&quot;:false,&quot;lineWrapping&quot;:false,&quot;styleActiveLine&quot;:false,&quot;readOnly&quot;:true,&quot;align&quot;:&quot;&quot;}\">class Motorcycle(Vehicle): def start_engine(self): # Override parent's method return f\"{self.brand}'s motorcycle engine roars!\" vehicles = [Car(\"Toyota\", \"Red\"), Motorcycle(\"Yamaha\")] for vehicle in vehicles: print(vehicle.start_engine()) # Different outputs based on object type<\/pre>\n<\/div>\n<p><strong>Output<\/strong>:<\/p>\n<pre><code>Toyota's engine started!\r\nYamaha's motorcycle engine roars!\r\n<\/code><\/pre>\n<p><strong>Why It Matters<\/strong>: Polymorphism enables flexible code that works with objects of different types, as long as they share a standard interface (e.g., <code>start_engine<\/code>).<\/p>\n<h3>Abstraction<\/h3>\n<p>Abstraction hides complex implementation details, exposing only what&#8217;s necessary. <a href=\"https:\/\/ded9.com\/comprehensive-guide-to-machine-learning-with-python\/\">Python<\/a> supports this through abstract base classes (ABCs) in the <code>abc<\/code> module.<\/p>\n<p>Example:<\/p>\n<div class=\"wp-block-codemirror-blocks code-block \">\n<pre class=\"CodeMirror\" data-setting=\"{&quot;mode&quot;:&quot;python&quot;,&quot;mime&quot;:&quot;text\/x-python&quot;,&quot;theme&quot;:&quot;material&quot;,&quot;lineNumbers&quot;:false,&quot;lineWrapping&quot;:false,&quot;styleActiveLine&quot;:false,&quot;readOnly&quot;:true,&quot;align&quot;:&quot;&quot;}\">from abc import ABC, abstractmethod class Animal(ABC): @abstractmethod def make_sound(self): pass class Dog(Animal): def make_sound(self): return \"Woof!\" class Cat(Animal): def make_sound(self): return \"Meow!\" animals = [Dog(), Cat()] for animal in animals: print(animal.make_sound()) # Output: Woof!, Meow!<\/pre>\n<\/div>\n<ul>\n<li><strong><code>ABC<\/code> and <code>@abstractmethod<\/code><\/strong>Ensure subclasses implement <code>make_sound<\/code>.<\/li>\n<li><strong>Cannot Instantiate <code>Animal<\/code><\/strong>It&#8217;s abstract, enforcing a contract for subclasses.<\/li>\n<\/ul>\n<p><strong>Why It Matters<\/strong>: Abstraction ensures consistent interfaces, simplifying code maintenance.<\/p>\n<h2>4. Practical Example: Library Management System<\/h2>\n<p>Let&#8217;s tie everything together with a more complex example: a simple library system using classes and OOP principles.<\/p>\n<div class=\"wp-block-codemirror-blocks code-block \">\n<pre class=\"CodeMirror\" data-setting=\"{&quot;mode&quot;:&quot;python&quot;,&quot;mime&quot;:&quot;text\/x-python&quot;,&quot;theme&quot;:&quot;material&quot;,&quot;lineNumbers&quot;:false,&quot;lineWrapping&quot;:false,&quot;styleActiveLine&quot;:false,&quot;readOnly&quot;:true,&quot;align&quot;:&quot;&quot;}\">class Book: def __init__(self, title, author, isbn): self.title = title self.author = author self.__isbn = isbn # Private self._is_checked_out = False # Protected def check_out(self): if not self._is_checked_out: self._is_checked_out = True return f\"{self.title} checked out.\" return f\"{self.title} is already checked out.\" def return_book(self): if self._is_checked_out: self._is_checked_out = False return f\"{self.title} returned.\" return f\"{self.title} is not checked out.\" class Library: def __init__(self): self.books = [] def add_book(self, book): self.books.append(book) return f\"Added {book.title} to library.\" def find_book(self, title): for book in self.books: if book.title.lower() == title.lower(): return book return None # Usage library = Library() book1 = Book(\"Python Programming\", \"John Doe\", \"12345\") book2 = Book(\"Data Science\", \"Jane Smith\", \"67890\") print(library.add_book(book1)) # Output: Added Python Programming to library. print(library.add_book(book2)) # Output: Added Data Science to library. print(book1.check_out()) # Output: Python Programming checked out. print(book1.check_out()) # Output: Python Programming is already checked out. print(book1.return_book()) # Output: Python Programming returned. found_book = library.find_book(\"Python Programming\") if found_book: print(f\"Found: {found_book.title} by {found_book.author}\") # Output: Found: Python Programming by John Doe<\/pre>\n<\/div>\n<p><strong>Breakdown<\/strong>:<\/p>\n<ul>\n<li><strong>Encapsulation<\/strong>: <code>.__isbn<\/code> is private, <code>_is_checked_out<\/code> is protected.<\/li>\n<li><strong>Classes<\/strong>: <code>Book<\/code> manages individual books, <code>Library<\/code> manages a collection.<\/li>\n<li><strong>Methods<\/strong>: Clear, reusable functions for checking out\/returning books and managing the library.<\/li>\n<li><strong>Real-World Relevance<\/strong>: It models a practical system that is extensible for more features (e.g., users, due dates).<\/li>\n<\/ul>\n<h2>5. Advanced Class Features<\/h2>\n<h3>Class vs. Instance Attributes<\/h3>\n<ul>\n<li><strong>Instance Attributes<\/strong>: Unique to each object (e.g., <code>self.brand<\/code>).<\/li>\n<li><strong>Class Attributes<\/strong>: Shared across all instances, defined outside <code>__init__<\/code>.<\/li>\n<\/ul>\n<p>Example:<\/p>\n<div class=\"wp-block-codemirror-blocks code-block \">\n<pre class=\"CodeMirror\" data-setting=\"{&quot;mode&quot;:&quot;python&quot;,&quot;mime&quot;:&quot;text\/x-python&quot;,&quot;theme&quot;:&quot;material&quot;,&quot;lineNumbers&quot;:false,&quot;lineWrapping&quot;:false,&quot;styleActiveLine&quot;:false,&quot;readOnly&quot;:true,&quot;align&quot;:&quot;&quot;}\">class Student: school = \"Springfield High\" # Class attribute def __init__(self, name): self.name = name # Instance attribute student1 = Student(\"Alice\") student2 = Student(\"Bob\") print(student1.school, student2.school) # Output: Springfield High, Springfield High Student.school = \"Riverside High\" print(student1.school, student2.school) # Output: Riverside High, Riverside High<\/pre>\n<\/div>\n<h3>Static Methods and Class Methods<\/h3>\n<ul>\n<li><strong>Static Methods<\/strong>: Don&#8217;t access instance\/class data, defined with <code>@staticmethod<\/code>.<\/li>\n<li><strong>Class Methods<\/strong>: Operate on the class itself, defined with <code>@classmethod<\/code>, take <code>cls<\/code> as the first parameter.<\/li>\n<\/ul>\n<p>Example:<\/p>\n<div class=\"wp-block-codemirror-blocks code-block \">\n<pre class=\"CodeMirror\" data-setting=\"{&quot;mode&quot;:&quot;python&quot;,&quot;mime&quot;:&quot;text\/x-python&quot;,&quot;theme&quot;:&quot;material&quot;,&quot;lineNumbers&quot;:false,&quot;lineWrapping&quot;:false,&quot;styleActiveLine&quot;:false,&quot;readOnly&quot;:true,&quot;align&quot;:&quot;&quot;}\">class MathUtils: @staticmethod def square(num): return num * num @classmethod def describe(cls): return f\"This is {cls.__name__}\" print(MathUtils.square(5)) # Output: 25 print(MathUtils.describe()) # Output: This is MathUtils<\/pre>\n<\/div>\n<h3>Property Decorators<\/h3>\n<p>Properties control access to attributes, allowing getter\/setter logic.<\/p>\n<p>Example:<\/p>\n<div class=\"wp-block-codemirror-blocks code-block \">\n<pre class=\"CodeMirror\" data-setting=\"{&quot;mode&quot;:&quot;python&quot;,&quot;mime&quot;:&quot;text\/x-python&quot;,&quot;theme&quot;:&quot;material&quot;,&quot;lineNumbers&quot;:false,&quot;lineWrapping&quot;:false,&quot;styleActiveLine&quot;:false,&quot;readOnly&quot;:true,&quot;align&quot;:&quot;&quot;}\">class Person: def __init__(self, name): self._name = name @property def name(self): return self._name @name.setter def name(self, value): if isinstance(value, str) and value: self._name = value else: raise ValueError(\"Name must be a non-empty string\") person = Person(\"Alice\") print(person.name) # Output: Alice person.name = \"Bob\" # Uses setter print(person.name) # Output: Bob # person.name = \"\" # Raises ValueError<\/pre>\n<\/div>\n<h2>6. Why Use Classes and OOP?<\/h2>\n<p>Classes and OOP shine in scenarios requiring:<\/p>\n<ul>\n<li><strong>Modularity<\/strong>: Break complex systems into manageable components (e.g., <code>Book<\/code> and <code>Library<\/code>).<\/li>\n<li><strong>Reusability<\/strong>: Reuse code via inheritance and polymorphism.<\/li>\n<li><strong>Maintainability<\/strong>: Encapsulation and abstraction make code easier to update.<\/li>\n<li><strong>Scalability<\/strong>: OOP supports large projects by organizing code logically.<\/li>\n<\/ul>\n<p>For example, in a web application, you might use classes to model users, products, and orders, leveraging OOP to keep the codebase clean and extensible.<\/p>\n<h2>7. Best Practices<\/h2>\n<ul>\n<li><strong>Clear Naming<\/strong>: Use descriptive class\/method names (e.g., <code>BankAccount<\/code> over <code>BA<\/code>).<\/li>\n<li><strong>Single Responsibility<\/strong>: Each class should have one primary purpose.<\/li>\n<li><strong>Use Encapsulation<\/strong>: Protect sensitive data with private\/protected attributes.<\/li>\n<li><strong>Document Code<\/strong>: Add docstrings to classes and methods.<\/li>\n<li><strong>Avoid Overcomplication<\/strong>: Keep inheritance hierarchies shallow and simple.<\/li>\n<\/ul>\n<h2>8. Next Steps<\/h2>\n<ul>\n<li><strong>Practice<\/strong>: Extend the <code>Library<\/code> example (e.g., add a <code>User<\/code> class, due dates).<\/li>\n<li><strong>Explore<\/strong>: Study Python&#8217;s standard library classes (e.g., <code>datetime<\/code>, <code>collections<\/code>).<\/li>\n<li><strong>Learn Frameworks<\/strong>: Use OOP in frameworks like Django (models) or Flask.<\/li>\n<li><strong>Read<\/strong>: Check &#8220;Fluent Python&#8221; by Luciano Ramalho for advanced OOP techniques.<\/li>\n<\/ul>\n<h2>Conclusion<\/h2>\n<p>Classes in Python are the foundation of object-oriented programming, enabling you to create modular, reusable, and maintainable code. Classes support encapsulation by defining attributes and methods, while inheritance and polymorphism enhance flexibility and code reuse.<\/p>\n<p>Whether building a simple script or a complex application, mastering classes equips you to write elegant, scalable Python code. Start with small projects, experiment with the examples, and explore OOP&#8217;s power in real-world scenarios.<\/p>\n<h2>FAQ<\/h2>\n<div id=\"rank-math-rich-snippet-wrapper\"><div id=\"rank-math-faq\" class=\"rank-math-block\">\n<div class=\"rank-math-list \">\n<div id=\"faq-1\" class=\"rank-math-list-item\">\n<h3 class=\"rank-math-question \">What is a class in Python?<\/h3>\n<div class=\"rank-math-answer \">\n\n<p>A class is a blueprint that defines attributes and methods which its instances (objects) will have.<\/p>\n\n<\/div>\n<\/div>\n<div id=\"faq-2\" class=\"rank-math-list-item\">\n<h3 class=\"rank-math-question \">What is an object in Python?<\/h3>\n<div class=\"rank-math-answer \">\n\n<p>An object is a specific instance of a class, with its own data (instance attributes) and the ability to use the class\u2019s methods.<\/p>\n\n<\/div>\n<\/div>\n<div id=\"faq-3\" class=\"rank-math-list-item\">\n<h3 class=\"rank-math-question \">What are the main OOP principles used with Python classes?<\/h3>\n<div class=\"rank-math-answer \">\n\n<p>The core principles are encapsulation (bundling data &amp; behavior), inheritance (sub-classes reuse\/extend parent classes), abstraction (hiding complexity), and polymorphism (objects behaving as instances of multiple types).<\/p>\n\n<\/div>\n<\/div>\n<\/div>\n<\/div><\/div>\n","protected":false},"excerpt":{"rendered":"<p>In Python, a class is a blueprint for creating objects\u2014individual instances that combine data (attributes) and behavior (methods). Classes are central to object-oriented programming (OOP), a programming paradigm that organizes code into reusable, modular units. OOP makes complex programs easier to manage, scale, and maintain, powering everything from web applications to machine learning models. This [&hellip;]<\/p>\n","protected":false},"author":6,"featured_media":259761,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[316],"tags":[11937],"class_list":["post-259760","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-python","tag-classes-and-object-oriented-programming"],"acf":[],"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/posts\/259760","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/comments?post=259760"}],"version-history":[{"count":4,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/posts\/259760\/revisions"}],"predecessor-version":[{"id":264089,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/posts\/259760\/revisions\/264089"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/media\/259761"}],"wp:attachment":[{"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/media?parent=259760"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/categories?post=259760"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ded9.com\/tr\/wp-json\/wp\/v2\/tags?post=259760"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}