”工欲善其事,必先利其器。“—孔子《论语.录灵公》
首页 > 编程 > Python OOPS 基础

Python OOPS 基础

发布于2024-11-03
浏览:722

In real world everything is Object and every object have 2 things behaviour and attribute. Attribute contains data stored in variable and behaviour is defined as method which is nothing but functions(what's needs to be done)

Imagine there is some kind of phone company manufacturing phone but designed once but created multiple handset. Here design or blueprint is a class and object is a real stuff or entity or instance of class.

class Computer:
    def config(self):
        print("i5, 15gb, 1Tb")

comp1=Computer()
Computer.config()


Output:
D:\Testing Document Sample>C:/Python312/python.exe "d:/Testing Document Sample/calc.py"
Traceback (most recent call last):
  File "d:\Testing Document Sample\calc.py", line 7, in 
    Computer.config()
TypeError: Computer.config() missing 1 required positional argument: 'self'

one class have multiple object. this config method will change it's behaviour based on it's object, because different object has different behaviour. If I am calling config, for which object I am calling, like if I say "hey walk" for which object I am calling.
So I have to mention "Hey! Ravi walk" , "Hey! Mukesh walk"
In the same way when I am calling the Computer.config we must say for which object we are talking about, and I am talking about comp1, which means " Hey! I want the config for comp1"
thus writing the update code and run

class Computer:
    def config(self):
        print("i5, 15gb, 1Tb")

comp1=Computer()
Computer.config(comp1)


Output:
D:\Testing Document Sample>C:/Python312/python.exe "d:/Testing Document Sample/calc.py"
i5, 15gb, 1Tb

Here we are calling Computer.config(comp1) where comp1 is passed as arguement to the parameter self under config method. So from there self came up, self is the paramter to pass the object.

If I want to call config for comp2 then. If I run this code we get the same output twice, as we are not changing data as per different object.

class Computer:
    def config(self):
        print("i5, 15gb, 1Tb")

comp1=Computer()
comp2=Computer()
Computer.config(comp1)
Computer.config(comp2)


Output:
D:\Testing Document Sample>C:/Python312/python.exe "d:/Testing Document Sample/calc.py"
i5, 15gb, 1Tb
i5, 15gb, 1Tb

Another to call the method, the first 2 is for Computer.config(comp1) and 2nd two is for comp1.config()

class Computer:
    def config(self):
        print("i5, 15gb, 1Tb")

comp1=Computer()
comp2=Computer()
Computer.config(comp1)
Computer.config(comp2)
comp1.config()
comp2.config()

Output:
D:\Testing Document Sample>C:/Python312/python.exe "d:/Testing Document Sample/calc.py"
i5, 15gb, 1Tb
i5, 15gb, 1Tb
i5, 15gb, 1Tb
i5, 15gb, 1Tb

Now for behind this what's happening. when we use these, as already object is reference with class at time of creation. So behind this scene, config will take comp1/comp2 as arguement and pass to parameter as self. thus most of the code we see this below type of syntax not the old one.

comp1.config()
comp2.config()

ctrl click bit_length for below example. calling bit_length it will not passing it. so this 'a' is an object it act as arguement and pass it as parameter to self.

eg:
a=3
a.bit_length()

So this is the way that we can create object

Let move further, suppose I want to create different cpu and ram configuration, which require 2 variables, which is cpu and ram. so how to find that.
That's where the picture came special method and variable having underscores (method/variable)

below example as we call config twice the output under init shows twice because we have created 2 objects, which automatically calls the init

class Computer:
    def __init__(self):         //  act as contructor which get called when object created.
        print("initalize init")  
    def config(self):
        print("i5, 15gb, 1Tb")

comp1=Computer()
comp2=Computer()

comp1.config()
comp2.config()


Output:
D:\Testing Document Sample>C:/Python312/python.exe "d:/Testing Document Sample/calc.py"
initalize init
initalize init
i5, 15gb, 1Tb
i5, 15gb, 1Tb

Now Supppose I want to get values based on cpu and ram with respect to object comp1/comp2 so we need to pass the argument mentioning cpu and ram and create variable in init method.
Now since I want cpu and ram values are need to be part of object thus so here is the code for below.

class Computer:
    def __init__(self,cpu,ram):    // self represent object name thus having 3 parameter (self=comp1,cpu='i5',ram=16)
        self.cpu = cpu                // as we need to assign value to object thus using self.cpu=cpu as self is object 
        self.ram = ram
    def config(self):
        print("config is", self.cpu, self.ram)      // Since this CPU and ram is belongs to object thus using self.cpu/self.ram

comp1=Computer('i5',16)
comp2=Computer('Ryzen 3',8)    // passing two arguments to __init__ method

comp1.config()
comp2.config()


Output:
D:\Testing Document Sample>C:/Python312/python.exe "d:/Testing Document Sample/calc.py"
config is i5 16
config is Ryzen 3 8

Thus for the above the data and methods work together i.e binding data with every method so one object has it's own method and has it's own variable.

Comp1 is object or referring to an cbject. I our system we have a special memory called Heap memory. Heap memory will contain all objects. so I might have some address in heap memory the way to print the address is :

class computer:
    pass
c1=computer()

print(id(c1))

Output:
D:\Testing Document Sample>C:/Python312/python.exe "d:/Testing Document Sample/demo.py"
2509775964640     // this is an address

What will be size of object?
It's depend upon the size of variable and number of variable

who allocate the memory to object ?
Constructor

we can also change the value of one object from different object

Example:

class computer:
    def __init__(self):
        self.name = "navin"
        self.age = 28

c1=computer()
c2=computer()

c1.name="rashi"
c2.age= 12

print (c1.name)
print (c2.name)
print (c1.age)
print (c2.age)

Output:
D:\Testing Document Sample>C:/Python312/python.exe "d:/Testing Document Sample/demo.py"
rashi
navin
28   
12

in the above code we can not only assign the different values to object explicitly but can change it also

Why do we need this self?
To explain that lets take one more method called update which is used to update the age
When update is called it will update the age in class computer, but here is catch we have two objects which value needs to be changed, as we called it we have not passed any arguement c1 or c2.
So when calling update how do pointer know which object we are calling about weather c1 age or c2 age and that's where we are using self is directing to c1 and c2 based on calling by object. If we are using c1.update then in the bracket it will pass c1, then self will assign to c1, that's the important of self which is referring to the object.

class computer:
    def __init__(self):
        self.name = "navin"
        self.age = 28

    def update(self):
        self.age = 30


c1=computer()
c2=computer()

c1.name="rashi"
c2.age= 12

c1.update()      // this calls the update method. In the 

print (c1.name)
print (c2.name)
print (c1.age)
print (c2.age)


Output:
D:\Testing Document Sample>C:/Python312/python.exe "d:/Testing Document Sample/demo.py"
rashi
navin
30
12

Let's compare the object for above: In below python don't know how to compare object. thus In this I will use seperate function to do that.

class computer:
    def __init__(self):
        self.name = "navin"
        self.age = 28

#   def update(self):
#      self.age = 30

    def compare(self,other):     // here c1 becomes self as object used to call and c2 become others passed as arguement
        if self.age==other.age:
            return true
        else:
            return false

c1=computer()
c1.age=30
c2=computer()

# if c1==c2:            // I don't want to compare address but want to compare their values(age) name doesn't matter

if c1.compare(c2):     // Since it's not an in build function thus we need to create it 
    print("They are same")

else:
    print("They are Different")

#c1.update()

print (c1.age)
print (c2.age)


Output:
D:\Testing Document Sample>C:/Python312/python.exe "d:/Testing Document Sample/demo.py"
They are Different
30
28

Types of variable in OOPS

  1. Instance Variables (Object Attributes)

Definition: These variables are tied to a specific instance of a class. Each object of the class can have different values for these variables.
Scope: They are accessible only within the instance they belong to, not across all instances of the class.
How to Define: Defined inside the constructor method (init()) and are prefixed with self.

Example:

class Car:
    def __init__(self, model, color):
        self.model = model  # Instance variable
        self.color = color  # Instance variable

car1 = Car("Tesla", "Red")
car2 = Car("BMW", "Blue")

print(car1.model)  # Output: Tesla
print(car2.model)  # Output: BMW

Here, model and color are instance variables that are specific to each instance of the Car class.
  1. Class Variables (Static Variables)

Definition: These are variables that are shared across all instances of the class. They are defined inside the class but outside of any instance methods.
Scope: They belong to the class itself and not to individual objects. Changes made to class variables affect all instances of the class.
How to Define: Declared within the class, but outside of any method. They are accessed using the class name or through any instance of the class.

Example:

class Car:
    wheels = 4  # Class variable

    def __init__(self, model, color):
        self.model = model
        self.color = color

car1 = Car("Tesla", "Red")
car2 = Car("BMW", "Blue")

print(Car.wheels)  # Output: 4 (Accessed through class)
print(car1.wheels)  # Output: 4 (Accessed through an instance)

Here, wheels is a class variable shared by all instances of the Car class. Both car1 and car2 will have access to this variable.
  1. Instance Methods (Method Variables)

Definition: Variables declared inside instance methods (other than init) are method variables, and they are local to that specific method.
Scope: These variables are created and exist only within the method where they are defined. They are not accessible outside the method.
How to Define: Defined inside any method of a class using standard variable declaration without self.

Example:

class Car:
    def display_info(self):
        speed = 120  # Method variable
        print(f"Speed is {speed}")

car1 = Car()
car1.display_info()  # Output: Speed is 120

Here, speed is a method variable and is local to the display_info() method. It cannot be accessed outside this method.
  1. Static Methods Variables

Definition: Variables defined inside static methods are local to that method, similar to instance methods. Static methods don’t have access to instance (self) or class variables unless passed explicitly.
Scope: Local to the static method.
How to Define: Defined inside a static method, typically declared with the @staticmethod decorator.

Example:

class Car:
    wheels = 4  # Class variable

    @staticmethod
    def show_description():
        description = "This is a car"  # Static method variable
        print(description)

Car.show_description()  # Output: This is a car

Here, description is a variable local to the static method show_description() and cannot be accessed outside this method.
  1. Class Methods Variables

Definition: Variables defined inside class methods are similar to static method variables, but class methods can access and modify class variables. Class methods are defined using the @classmethod decorator.
Scope: Variables are local to the class method, but the method has access to class variables via the cls parameter.
How to Define: Declared within class methods, typically with the @classmethod decorator.

Example:

class Car:
    wheels = 4  # Class variable

    @classmethod
    def set_wheels(cls, count):
        cls.wheels = count  # Class method variable

Car.set_wheels(6)
print(Car.wheels)  # Output: 6

Here, count is a variable within the class method set_wheels, and the method can access and modify the class variable wheels.

Key Difference :

  1. Instance Variables

Definition: Variables that are unique to each object (instance) of a class.
Scope: Available only within the instance they belong to.
Access: Accessed via self (i.e., self.variable_name).
Storage: Stored within each object; each instance has its own copy of instance variables.
Lifecycle: Created when an object is instantiated and destroyed when the object is deleted.
Modification: Each object can have its own unique values for instance variables.
Key Point: Instance variables are unique to each instance. For example, different Car objects can have different model and color.

  1. Class Variables

Definition: Variables that are shared across all instances of a class.
Scope: Belongs to the class itself and is shared by all instances.
Access: Accessed using ClassName.variable_name or via instances (though the preferred way is through the class name).
Storage: Stored in the class, not in the individual object instances.
Lifecycle: Created when the class is defined and exists for the lifetime of the class.
Modification: Modifying a class variable through the class affects all instances, whereas modifying it through an instance creates a new instance variable for that particular object.
Key Point: Class variables are shared across all instances. If wheels is changed through the class, it affects all instances unless overridden at the instance level.

  1. Method Variables (Local Variables)

Definition: Variables defined inside a method, and they are local to that method.
Scope: Available only within the method where they are defined.
Access: Can only be accessed within the method; not accessible outside the method or across instances.
Storage: Stored temporarily in the method call stack and are discarded once the method execution finishes.
Lifecycle: Created when the method is called and destroyed once the method finishes execution.
Modification: Each method call gets a fresh set of method variables.
Key Point: Method variables are local to the method and do not persist beyond the method's execution.

  1. Static Variables (Variables in Static Methods)

Definition: Variables defined inside a static method, local to the method itself, similar to method variables.
Scope: Confined to the static method where they are defined.
Access: Static methods do not have access to class or instance variables unless they are passed as arguments.
Storage: Stored temporarily during the execution of the static method.
Lifecycle: Created when the static method is called and destroyed once it finishes execution.
Modification: Modifying static method variables only affects that specific method execution.
Key Point: Static method variables are local to the static method and do not interact with class or instance variables unless explicitly passed.

Python OOPS basic


Types of Methods in oops:

  1. Instance Methods:

Definition: Instance methods are the most common type of method in a class. They operate on instances of the class (i.e., objects) and can access or modify object attributes.
How to Define: Instance methods must have self as their first parameter, which refers to the instance of the class. They can access both instance variables and class variables.
Use Case: These methods are used to manipulate object-specific data.

Example:

class Car:
    def __init__(self, model, color):
        self.model = model  # Instance variable
        self.color = color  # Instance variable

    def display_info(self):  # Instance method
        print(f"Car model: {self.model}, Color: {self.color}")

car1 = Car("Tesla", "Red")
car1.display_info()  # Output: Car model: Tesla, Color: Red

Here, display_info is an instance method that operates on the instance car1 and accesses its instance variables (model and color).
  1. Class Methods

Definition: Class methods are methods that operate on the class itself rather than on instances of the class. They can access or modify class variables but cannot modify instance variables.
How to Define: Class methods are defined using the @classmethod decorator, and they take cls as their first parameter, which refers to the class itself.
Use Case: These methods are used to work with class-level data and can be called without creating an instance of the class.

Example
class Car:
    wheels = 4  # Class variable

    @classmethod
    def change_wheels(cls, count):  # Class method
        cls.wheels = count

Car.change_wheels(6)
print(Car.wheels)  # Output: 6

In this example, change_wheels is a class method that modifies the class variable wheels and can be called on the class itself, not on individual objects.
  1. Static Methods:

Definition: Static methods are methods that don’t operate on instances or the class itself. They do not take self or cls as their first parameter and cannot modify object state or class state. Static methods behave like regular functions but are bound to a class for organizational purposes.
How to Define: Static methods are defined using the @staticmethod decorator.
Use Case: Static methods are used when you need a function that logically belongs to the class but doesn’t need to access or modify any class or instance variables.

Example:

class Car:
    @staticmethod
    def is_motorized():  # Static method
        return True

print(Car.is_motorized())  # Output: True

Here, is_motorized is a static method that doesn’t rely on any class or instance data and can be called directly on the class.

Key Differences:

Instance Methods:
Access both instance and class variables.
The self parameter allows access to object-specific data.

Class Methods:
Access only class variables.
The cls parameter allows access to class-level data and can modify it.

Static Methods:
Don’t access or modify class or instance variables.
Behave like regular functions, but are logically grouped inside a class.

Python OOPS basic


版本声明 本文转载于:https://dev.to/indrasen_9d014cf224a46c4a/python-oops-basic-24aa?1如有侵犯,请联系[email protected]删除
最新教程 更多>
  • 为什么使用Firefox后退按钮时JavaScript执行停止?
    为什么使用Firefox后退按钮时JavaScript执行停止?
    导航历史记录问题:JavaScript使用Firefox Back Back 此行为是由浏览器缓存JavaScript资源引起的。要解决此问题并确保在后续页面访问中执行脚本,Firefox用户应设置一个空功能。 警报'); }; alert('inline Alert')...
    编程 发布于2025-04-08
  • 如何处理PHP文件系统功能中的UTF-8文件名?
    如何处理PHP文件系统功能中的UTF-8文件名?
    在PHP的Filesystem functions中处理UTF-8 FileNames 在使用PHP的MKDIR函数中含有UTF-8字符的文件很多flusf-8字符时,您可能会在Windows Explorer中遇到comploreer grounder grounder grounder gro...
    编程 发布于2025-04-08
  • Python读取CSV文件UnicodeDecodeError终极解决方法
    Python读取CSV文件UnicodeDecodeError终极解决方法
    在试图使用已内置的CSV模块读取Python中时,CSV文件中的Unicode Decode Decode Decode Decode decode Error读取,您可能会遇到错误的错误:无法解码字节 在位置2-3中:截断\ uxxxxxxxx逃脱当CSV文件包含特殊字符或Unicode的路径逃...
    编程 发布于2025-04-08
  • 您可以使用CSS在Chrome和Firefox中染色控制台输出吗?
    您可以使用CSS在Chrome和Firefox中染色控制台输出吗?
    在javascript console 中显示颜色是可以使用chrome的控制台显示彩色文本,例如红色的redors,for for for for错误消息?回答是的,可以使用CSS将颜色添加到Chrome和Firefox中的控制台显示的消息(版本31或更高版本)中。要实现这一目标,请使用以下模...
    编程 发布于2025-04-08
  • 为什么在我的Linux服务器上安装Archive_Zip后,我找不到“ class \” class \'ziparchive \'错误?
    为什么在我的Linux服务器上安装Archive_Zip后,我找不到“ class \” class \'ziparchive \'错误?
    class'ziparchive'在Linux Server上安装Archive_zip时找不到错误 commant in lin ins in cland ins in lin.11 on a lin.1 in a lin.11错误:致命错误:在... cass中找不到类z...
    编程 发布于2025-04-08
  • 在程序退出之前,我需要在C ++中明确删除堆的堆分配吗?
    在程序退出之前,我需要在C ++中明确删除堆的堆分配吗?
    在C中的显式删除 在C中的动态内存分配时,开发人员通常会想知道是否有必要在heap-procal extrable exit exit上进行手动调用“ delete”操作员,但开发人员通常会想知道是否需要手动调用“ delete”操作员。本文深入研究了这个主题。 在C主函数中,使用了动态分配变量(H...
    编程 发布于2025-04-08
  • 如何使用Python理解有效地创建字典?
    如何使用Python理解有效地创建字典?
    在python中,词典综合提供了一种生成新词典的简洁方法。尽管它们与列表综合相似,但存在一些显着差异。与问题所暗示的不同,您无法为钥匙创建字典理解。您必须明确指定键和值。 For example:d = {n: n**2 for n in range(5)}This creates a dicti...
    编程 发布于2025-04-08
  • PHP阵列键值异常:了解07和08的好奇情况
    PHP阵列键值异常:了解07和08的好奇情况
    PHP数组键值问题,使用07&08 在给定数月的数组中,键值07和08呈现令人困惑的行为时,就会出现一个不寻常的问题。运行print_r($月)返回意外结果:键“ 07”丢失,而键“ 08”分配给了9月的值。此问题源于PHP对领先零的解释。当一个数字带有0(例如07或08)的前缀时,PHP将其...
    编程 发布于2025-04-08
  • 为什么我的CSS背景图像出现?
    为什么我的CSS背景图像出现?
    故障排除:CSS背景图像未出现 ,您的背景图像尽管遵循教程说明,但您的背景图像仍未加载。图像和样式表位于相同的目录中,但背景仍然是空白的白色帆布。而不是不弃用的,您已经使用了CSS样式: bockent {背景:封闭图像文件名:背景图:url(nickcage.jpg); 如果您的html,css...
    编程 发布于2025-04-08
  • 如何解决由于Android的内容安全策略而拒绝加载脚本... \”错误?
    如何解决由于Android的内容安全策略而拒绝加载脚本... \”错误?
    Unveiling the Mystery: Content Security Policy Directive ErrorsEncountering the enigmatic error "Refused to load the script..." when deployi...
    编程 发布于2025-04-08
  • 如何在Java中正确显示“ DD/MM/YYYY HH:MM:SS.SS”格式的当前日期和时间?
    如何在Java中正确显示“ DD/MM/YYYY HH:MM:SS.SS”格式的当前日期和时间?
    如何在“ dd/mm/yyyy hh:mm:mm:ss.ss”格式“ gormat 解决方案: args)抛出异常{ 日历cal = calendar.getInstance(); SimpleDateFormat SDF =新的SimpleDateFormat(“...
    编程 发布于2025-04-08
  • 在Ubuntu/linux上安装mysql-python时,如何修复\“ mysql_config \”错误?
    在Ubuntu/linux上安装mysql-python时,如何修复\“ mysql_config \”错误?
    mysql-python安装错误:“ mysql_config找不到”“ 由于缺少MySQL开发库而出现此错误。解决此问题,建议在Ubuntu上使用该分发的存储库。使用以下命令安装Python-MysqldB: sudo apt-get安装python-mysqldb sudo pip in...
    编程 发布于2025-04-08
  • 如何检查对象是否具有Python中的特定属性?
    如何检查对象是否具有Python中的特定属性?
    方法来确定对象属性存在寻求一种方法来验证对象中特定属性的存在。考虑以下示例,其中尝试访问不确定属性会引起错误: >>> a = someClass() >>> A.property Trackback(最近的最新电话): 文件“ ”,第1行, AttributeError: SomeClass...
    编程 发布于2025-04-08
  • 如何在鼠标单击时编程选择DIV中的所有文本?
    如何在鼠标单击时编程选择DIV中的所有文本?
    在鼠标上选择div文本单击带有文本内容,用户如何使用单个鼠标单击单击div中的整个文本?这允许用户轻松拖放所选的文本或直接复制它。 在单个鼠标上单击的div元素中选择文本,您可以使用以下Javascript函数: function selecttext(canduterid){ if(do...
    编程 发布于2025-04-08
  • 为什么PYTZ最初显示出意外的时区偏移?
    为什么PYTZ最初显示出意外的时区偏移?
    与pytz 最初从pytz获得特定的偏移。例如,亚洲/hong_kong最初显示一个七个小时37分钟的偏移: 差异源利用本地化将时区分配给日期,使用了适当的时区名称和偏移量。但是,直接使用DateTime构造器分配时区不允许进行正确的调整。 example pytz.timezone(...
    编程 发布于2025-04-08

免责声明: 提供的所有资源部分来自互联网,如果有侵犯您的版权或其他权益,请说明详细缘由并提供版权或权益证明然后发到邮箱:[email protected] 我们会第一时间内为您处理。

Copyright© 2022 湘ICP备2022001581号-3