1. Toy模板网首页
  2. > Toy博客

Python学习——类与对象

7月前 作者：wuliwuliClemence 分类：Toy博客 阅读(23) 违法举报

这篇具有很好参考价值的文章主要介绍了Python学习——类与对象。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、编程的两大思想
（1）面向过程
事物比较简单，用简单的线性思维即可解决
（2）面向对象
事物比较复杂，用简单的线性思维无法解决
（3）两者之间的关系
在面对复杂的问题时，宏观上是使用面向对象，但具体到微观操作，还是要用面向过程的方式来进行解决。
二、类的定义
类就是类别，使用类的方法能够帮助我们快速理解和判断事物的性质。例如我们之前学习过的数据类型，不同的数据类型属于不同的类，可以使用内置函数type查看数据类型。
三、对象的定义
相同的类中的不同的个例，就称为实例或者是对象。
四、类的创建
（1）类名
创建类，首先需要一个类名，类名可以由一个单词组成，也可以有多个单词组成，但每个单词的首字母需要大写。
（2）类的组成
①类属性
②实例方法
③静态方法
④类方法
⑤初始化方法

#类的创建
class Student:
    location='湖北'   #直接写在类里面的变量，成为类属性
    #初始化方法
    def__init__(self,name,age)
         self.name=name
         self.age=age

    #在类之内定义的是方法，在类之外定义的是函数
    #实例方法
    def study(self):#这里的self必须得加
        print('学生在学习')


    #静态方法
    @staticmethod
     def method():#在静态方法中可以不加self
        print('静态方法')


    #类方法
    @classmethod
    def cm(cls):#类方法里面要加cls
      print('类方法')
#在类之外定义的，下面这个就是函数
def play:
    print('学生想玩耍')

五、对象的创建
对象的创建又被称为类的实例化
格式：实例名=类名（）

#类的创建
class Student:
    location='湖北'   #直接写在类里面的变量，成为类属性
    #初始化方法

    def __init__(self,name,age):
        self.name=name
        self.age=age

    #在类之内定义的是方法，在类之外定义的是函数
    #实例方法
    def study(self):#这里的self必须得加
        print('学生在学习')


    #静态方法
    @staticmethod
    def method():#在静态方法中可以不加self
        print('静态方法')


    #类方法
    @classmethod
    def cm(cls):#类方法里面要加cls
      print('类方法')
#在类之外定义的，下面这个就是函数
def play():
    print('学生想玩耍')

student1=Student('A',18)
#实例方法
print(student1.name)
print(student1.age)
#实例属性
#方法一，对象名加实例方法名
student1.study()
#方法二，类名.实例方法名（对象名）
Student.study(student1)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
六、类属性、类方法、静态方法
（1）类属性：类中方法外的变量称为类属性，可以被该类的所有对象所共享。
（2）类方法：就是使用@classmethod修饰的方法，使用类名直接访问的方法。
（3）静态方法：就是使用@staticmethod修饰的方法，使用类名直接访问的方法。

（4）访问类属性
根据上面的代码的这一块

class Student:
    location='湖北'   #直接写在类里面的变量，成为类属性
    #初始化方法
def ``````

因为location是在类中方法外的变量，所以location就是类属性，也就是说可以被该类的所有对象所共享。

#类的创建
class Student:
    location='湖北'   #直接写在类里面的变量，成为类属性
    #初始化方法

    def __init__(self,name,age):
        self.name=name
        self.age=age

    #在类之内定义的是方法，在类之外定义的是函数
    #实例方法
    def study(self):#这里的self必须得加
        print('学生在学习')


    #静态方法
    @staticmethod
    def method():#在静态方法中可以不加self
        print('静态方法')


    #类方法
    @classmethod
    def cm(cls):#类方法里面要加cls
      print('类方法')
#在类之外定义的，下面这个就是函数
def play():
    print('学生想玩耍')

student1=Student('A',18)
#实例方法
print(student1.name)
print(student1.age)
#实例属性

print(student1.location)
#对类属性进行修改
Student.location='武汉'
print(student1.location)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
（5）调用类方法
形式：类名.类方法名

#类的创建
class Student:
    location='湖北'   #直接写在类里面的变量，成为类属性
    #初始化方法

    def __init__(self,name,age):
        self.name=name
        self.age=age

    #在类之内定义的是方法，在类之外定义的是函数
    #实例方法
    def study(self):#这里的self必须得加
        print('学生在学习')


    #静态方法
    @staticmethod
    def method():#在静态方法中可以不加self
        print('restday')


    #类方法
    @classmethod
    def cm(cls):#类方法里面要加cls
      print('好想休息')
        
#在类之外定义的，下面这个就是函数
def play():
    print('学生想玩耍')

student1=Student('A',18)
#调用类方法
Student.cm()

运行结果：
Python学习——类与对象,Python学习,python,学习,开发语言
（6）调用静态方法
形式：类名.静态方法名

#类的创建
class Student:
    location='湖北'   #直接写在类里面的变量，成为类属性
    #初始化方法

    def __init__(self,name,age):
        self.name=name
        self.age=age

    #在类之内定义的是方法，在类之外定义的是函数
    #实例方法
    def study(self):#这里的self必须得加
        print('学生在学习')


    #静态方法
    @staticmethod
    def sm():#在静态方法中可以不加self
        print('restday')


    #类方法
    @classmethod
    def cm(cls):#类方法里面要加cls
      print('好想休息')

#在类之外定义的，下面这个就是函数
def play():
    print('学生想玩耍')

student1=Student('A',18)
#调用静态方法
Student.sm()

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
静态方法没有任何默认参数，类方法有默认参数。
七、动态绑定属性和方法
一个类可以创建多个属于该类的实例对象，每个实例对象的属性值不同。
（1）Python是动态语言，在创建对象之后，可以动态的绑定属性，例如：

#动态绑定属性和方法
#首先定义类
class Student:
    #初始化方法
    def __init__(self,name,age):
        self.name=name
        self.age=age
   #在类里面定义的函数叫做方法
    def study(self):
        print(self.name,'在学习')

#定义实例化对象
student1=Student('A',18)
student2=Student('B', 20)

#为stu1动态绑定新的属性，比如说成绩属性
student1.scores=500 #创建对象后，在初始化方法之后进行的绑定

print(student1.name,student1.age,student1.scores)
print(student2.name,student2.age,student2.scores)

运行结果Python学习——类与对象,Python学习,python,学习,开发语言
解释,name和age是在初始化定义里面定义的属性，所以说是所有对象都有的属性。在创建完成之后，新绑定的属性只属于当前所绑定的对象。
（2）除了能够动态绑定属性外，还可以动态绑定方法。
类里面的方法，是所有实例对象都可以用的。
例如，定义在类里的方法，所有实例对象都可以调用。

#动态绑定属性和方法
#首先定义类
class Student:
    #初始化方法
    def __init__(self,name,age):
        self.name=name
        self.age=age
   #在类里面定义的函数叫做方法
    def study(self):
        print(self.name,'在学习')

#定义实例化对象
student1=Student('A',18)
student2=Student('B', 20)

#动态绑定方法
#首先是调用在类里面定义的方法
student1.study()
student2.study()

# def show():
#     print('定义在类之外的，称为函数')
# #绑定
# student1.show=show  #仅仅将show绑定student1,而不绑定student2
#
# student1.show()
# student2.show()

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
例如，定义在类之外的函数，只有绑定实例对象之后，才能使用。

#动态绑定属性和方法
#首先定义类
class Student:
    #初始化方法
    def __init__(self,name,age):
        self.name=name
        self.age=age
   #在类里面定义的函数叫做方法
    def study(self):
        print(self.name,'在学习')

#定义实例化对象
student1=Student('A',18)
student2=Student('B', 20)

#动态绑定方法
#首先是调用在类里面定义的方法
student1.study()
student2.study()

def show():
    print('定义在类之外的，称为函数')
#绑定
student1.show=show  #仅仅将show绑定student1,而不绑定student2

student1.show()
student2.show()

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
即student2并没有绑定show方法。
八、面向对象编程语言的特征
（1）封装
封装的目的是提高程序的安全性。它指得是将属性和方法包装到对象中。然后在方法内部对属性进行操作，在类对象的外部调用方法。

class Atm:
    #(1)将属性和方法包装到对象中
   def __init__(self,money):
       self.money=money
    #在类内部定义的是方法
   def draw(self):
       print('正在取款中')

atm=Atm('1w')
#在类对象的外部调用方法。
atm.draw()
print(atm.money)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
如果某个属性不希望在类对象的外部被访问，那么使用两个–,来表示该属性的私有。

class Student:
    def __init__(self,name,age):
        self.name=name
        #不希望在类对象的外部被访问,但是在内部是可以访问的
        self.__age=age
    def display(self):
        print(self.name,self.__age)
#创建实例对象
student1=Student('A',18)
#因为show是类内部的方法，所以说年龄可以显示
student1.display()

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
尝试在外部访问类属性

class Student:
    def __init__(self,name,age):
        self.name=name
        #不希望在类对象的外部被访问,但是在内部是可以访问的
        self.__age=age
    def display(self):
        print(self.name,self.__age)
#创建实例对象
student1=Student('A',18)
#因为show是类内部的方法，所以说年龄可以显示
# student1.display()

print(student1.name)
print(student1.__age)

它会显示名字是A，但是没有年龄这个属性。
运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
但这不代表不能使用，只是使用的方法和直接使用name这个属性是不同的。
使用方法，第一步找到实例化对象的所有属性

#第一步，找到实例化对象的所有属性
print(dir(student1))

发现有一个_Student__age的属性Python学习——类与对象,Python学习,python,学习,开发语言
使用

print(student1._Student__age)

进行访问
完整代码

class Student:
    def __init__(self,name,age):
        self.name=name
        #不希望在类对象的外部被访问,但是在内部是可以访问的
        self.__age=age
    def display(self):
        print(self.name,self.__age)
#创建实例对象
student1=Student('A',18)
#因为show是类内部的方法，所以说年龄可以显示
# student1.display()

print(student1.name)

#第一步，找到实例化对象的所有属性
# print(dir(student1))
#第二步根据属性提示进行访问
print(student1._Student__age)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
但是看到使用__不希望被访问的对象，最好还是不要进行访问。
（2）继承
①继承则提高了代码的复用性
Python支持多继承，也就是说一个子类，可以有多个父类。在定义子类时，必须在其构造函数中调用父类的构造函数。如果一个类没有继承任何类，那么就默认继承object。语法格式如下。

#语法格式
class 子类类名 (父类1，父类2):
    pass

示例

#继承
#定义父类，person类
class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)

#学生——子类
class Student(Person):
    def __init__(self,name,age,scores):
        super().__init__(name,age)#继承person父类
        self.scores=scores

#教师——子类
class Teacher(Person):
    def __init__(self,name,age,techyear):
        super().__init__(name,age)#继承person父类
        self.techyear=techyear

#创建不同类的实例对象
student=Student('a',18,500)
teacher=Teacher('b',50,30)

student.info()#继承父类里面的方法
teacher.info()

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
像姓名和年龄都是从父类中继承过来的。

②除此之外，还有多继承的方式
例如

class A(object):
    pass

class B(object):
    pass

class(A,B):
    pass

③方法重写
方法重写的意思是如果子类对继承来自于父类的某个属性或者是对父类的方法不满意，那么可以在子类中对方法进行重新编写。子类重写后的方法中可以通过super（）.xxx()调用父类中被重写的方法。
比如说，在本文最开始继承的实例代码中，调用父类中的方法，只输出了名字和年龄，为了输出其他信息，就需要进行方法重写。

#继承
#定义父类，person类
class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)

#学生——子类
class Student(Person):
    def __init__(self,name,age,scores):
        super().__init__(name,age)#继承person父类
        self.scores=scores
        #方法重写
    def info(self):
         print(self.scores)

#教师——子类
class Teacher(Person):
    def __init__(self,name,age,techyear):
        super().__init__(name,age)#继承person父类
        self.techyear=techyear

#创建不同类的实例对象
student=Student('a',18,500)
teacher=Teacher('b',50,30)

student.info()#继承父类里面的方法
teacher.info()

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
根据运行结果发现，方法重写后，只出现了分数，之前从父类继承过来的方法和年龄都没有了，根据之前的讲解，如果需要这些信息，子类重写后的方法中可以通过super（）.xxx()调用父类中被重写的方法。

#继承
#定义父类，person类
class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)

#学生——子类
class Student(Person):
    def __init__(self,name,age,scores):
        super().__init__(name,age)#继承person父类
        self.scores=scores
        #方法重写
    def info(self):
         super().info()
         print(self.scores)

#教师——子类
class Teacher(Person):
    def __init__(self,name,age,techyear):
        super().__init__(name,age)#继承person父类
        self.techyear=techyear

#创建不同类的实例对象
student=Student('a',18,500)
teacher=Teacher('b',50,30)

student.info()#继承父类里面的方法
teacher.info()

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
同理，再给教师添加一些信息。

#继承
#定义父类，person类
class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)

#学生——子类
class Student(Person):
    def __init__(self,name,age,scores):
        super().__init__(name,age)#继承person父类
        self.scores=scores
        #方法重写
    def info(self):
         super().info()
         print(self.scores)

#教师——子类
class Teacher(Person):
    def __init__(self,name,age,techyear):
        super().__init__(name,age)#继承person父类
        self.techyear=techyear
    def info(self):
        super().info()
        print(self.techyear)

#创建不同类的实例对象
student=Student('a',18,500)
teacher=Teacher('b',50,30)

student.info()#继承父类里面的方法
teacher.info()

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
④object类
object类是所有类的父类，也就是说所有类都有object类的属性和方法。这里我们可以定义一个类，但是不创建属性，使用内置函数dir（）去查看属性。

#创建类
class Student:
    pass
#实例化对象
stu=Student()
#使用内置函数dir查看属性
print(dir(stu))

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
不查不知道，一查吓一跳，为什么没有创建属性，为什么还有那么多的属性呢。这是因为object（）是所有类的父类，所有类都可以继承object的属性。

对于object有一个__str__()方法，用于返回一个对于“对象的描述”。对应于内置函数str()经常用于print（）方法，利用该方法可以查看对象的信息，因此，经常会使用__str__()进行重写。
例如：
现在使用print(),输出的是内存地址，

#创建类
class Student:
    def 
#实例化对象
stu=Student()

print(stu)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
现在需要输出属性值，那么我们就采用__str__方法进行重写。

#创建类
class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
         return "我叫'%s',今年%d岁了"%(self.name,self.age)

#实例化对象
stu=Student('a',18)

print(stu)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
（3）多态
多态则提高了程序的可扩展性和可维护性。多态，顾名思义，就是具有多种形态。也就是说即便不知道一个变量所引用的对象是什么类型，仍然可以通过变量调用的方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法。
动态语言的特征，不需要去关注对象是哪个类，只需要关心对象的行为
例如

class Animal(object):
    def eat(self):
        print('动物会吃')

#定义子类,继承父类
class Dog(Animal):
    #方法重写
    def eat(self):
        print('狗吃骨头')

class Cat(Animal):
    # 方法重写
    def eat(self):
        print('猫吃鱼')

class Person(object):
    def eat(self):
       print('人吃饭')

#定义函数，调用类里面的eat方法
def fun(object):
    object.eat()

#调用函数
fun(Animal())
fun(Dog())
fun(Cat())
#不关注对象有没有类，只关注对象的行为
fun(Person())

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
九、特殊方法
（1）_ _ add _ _
通过方法重写，使得对象具有加法的性质。
没有使用_ _ add _ _重写，进行相加。

class Student():
    def __init__(self,name):
        self.name=name

student1=Student('A')
student2=Student('B')

c=student1+student2
print(c)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
不支持这种相加操作。
使用add方法重写

class Student():
    def __init__(self,name):
        self.name=name
    def __add__(self, other):
        return self.name+other.name

student1=Student('A')
student2=Student('B')

c=student1+student2
print(c)
print(student1.__add__(student2))

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
（2）_ _len _ _
可以通过方法重写，得到对象的长度。
未进行方法重写。

class Student():
    def __init__(self,name):
        self.name=name
    # def __len__(self):
    #     return len(self.name)

student1=Student('张三')
print(len(student1))

运行结果，报错
没有长度
Python学习——类与对象,Python学习,python,学习,开发语言
进行方法重写

class Student():
    def __init__(self,name):
        self.name=name
    def __len__(self):
        return len(self.name)


student1=Student('张三')
print(len(student1))

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
（3）_ _ new _ _ 用于创建对象
（4） _ _ add _ _ 用于对创建的对象进行初始化
十、特殊属性
（1） _ _ dict _ _
获得类对象或者实例对象所绑定的所有属性和方法，输出结果是一个字典

class A:
    pass
class B:
    pass
class Student(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age

#创建实例对象
student=Student('A',18)

#查看实例对象的属性
print(student.__dict__)
#查看类对象的属性
print(Student.__dict__)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
具体分析，如果是一个实例化对象，就是看到了属性。
Python学习——类与对象,Python学习,python,学习,开发语言
如果是一个类对象，那就可以查看属性和方法
Python学习——类与对象,Python学习,python,学习,开发语言
（2）_ _ class_ _
输出的是实例化对象所属的类

class A:
    pass
class B:
    pass
class Student(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age

#创建实例对象
student=Student('A',18)

#输出实例化对象所属的类
print(student.__class__)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
（3）bases
输出类对象所属的父类

class A:
    pass
class B:
    pass
class Student(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age

#创建实例对象
student=Student('A',18)

#输出类对象所属的父类
print(Student.__bases__)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
（4）base
输出离得近的那个父类

class A:
    pass
class B:
    pass
class Student(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age

#创建实例对象
student=Student('A',18)

#输出类对象所属的最近父类
print(Student.__base__)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
（5）mro
输出类的层次结构

class A:
    pass
class B:
    pass
class Student(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age

#创建实例对象
student=Student('A',18)

#输出类对象所属的最近父类
print(Student.__mro__)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
（6）subclasses
查看某一个类的子类

class A:
    pass
class B:
    pass
class Student(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age

#创建实例对象
student=Student('A',18)

#输出类对象所属的最近父类
print(A.__subclasses__())

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
十一、类的赋值
变量之间的赋值操作，只是形成两个变量，但是实际上还是指向同一个对象，内存地址都还是相同的。

class Name:
    pass
class Age:
    pass
class Student:
    def __init__(self,nama,age):
        self.name=name
        self.age=age

#创建实例化对象
name1=Name()
#将name1的值赋值给name2
name2=name1
print(name1)
print(name2)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
十二、浅拷贝
python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象。

class Name:
    pass
class Age:
    pass
class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age

#创建实例化对象
name=Name()
#将name1的值赋值给name2

age=Age()
student1=Student(name,age)

#浅拷贝
import  copy
student2=copy.copy(student1)
print(student1,student1.name,student1.age)
print(student2,student2.name,student2.age)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
根据运行结果发现student1和student2是不同的对象，但包含的子对象是相同的，也就是前面所说的源对象与拷贝对象会引用同一个子对象。

十三、深拷贝
使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。（也就是说源对象和拷贝对象都需要重新拷贝一份）

class Name:
    pass
class Age:
    pass
class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age

#创建实例化对象
name=Name()
#将name1的值赋值给name2

age=Age()
student1=Student(name,age)

#深拷贝拷贝
import  copy
student2=copy.deepcopy(student1)
print(student1,student1.name,student1.age)
print(student2,student2.name,student2.age)

运行结果
Python学习——类与对象,Python学习,python,学习,开发语言
发现，不仅源对象和拷贝对象不同，源对象和拷贝对象的子对象也是不同的。
十四、总结
Python学习——类与对象,Python学习,python,学习,开发语言文章来源地址https://www.toymoban.com/news/detail-516643.html

到了这里，关于Python学习——类与对象的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • Python-基础篇-类与对象/面向对象程序设计

    Python-基础篇-类与对象/面向对象程序设计

    “类”是物以类聚的 “类” 类 和 对象 是 面向对象编程的 两个 核心概念 类 是对一群具有 相同 特征 或者 行为 的事物的一个统称，是抽象的， 不能直接使用 特征 被称为 属性 行为 被称为 方法 类 就相当于制造飞机时的 图纸 ，是一个 模板 ，是 负责创建对象的 定义类📚

    2024年01月19日
    浏览(41)
  • Python基础合集 练习19（类与对象3（多态））

    Python基础合集 练习19（类与对象3（多态））

    class Horse: def init (self, name) - None: self.name = name class Monkey: def init (self, name) - None: self.name = name class Mule(Horse, Monkey): def init (self, name, age) - None: super(). init (name) self.age = age mule1 = Mule(‘朵儿’, 2) mule1.mover() # 继承父类horse的move()方法 mule1.speak() # 继承父类donkey的speak()方法 print(mule1

    2024年02月02日
    浏览(31)

  • < Python全景系列-6 > 掌握Python面向对象编程的关键：深度探索类与对象

    欢迎来到我们的系列博客《Python全景系列》！在这个系列中，我们将带领你从Python的基础知识开始，一步步深入到高级话题，帮助你掌握这门强大而灵活的编程语法。无论你是编程新手，还是有一定基础的开发者，这个系列都将提供你需要的知识和技能。 Python全景系列的第六

    2024年02月06日
    浏览(52)
  • Python——狂肝两万字带你学会【类与对象】

    Python——狂肝两万字带你学会【类与对象】

    目录 01-初始对象 生活中的数据组织 程序中的数据组织​ 使用对象组织数据 总结01 02-类的成员方法 类的定义和使用 成员变量和成员方法  成员方法的定义语法  注意事项 成员方法——代码演示  总结02 03-类和对象 现实世界的事物和类 类和对象 使用类和对象描述现实事物

    2024年02月02日
    浏览(57)
  • 【python基础知识】14.图书管理系统的搭建（类与对象实操）

    【python基础知识】14.图书管理系统的搭建（类与对象实操）

    通过这个项目希望你可以学会用类与实例的方法编写程序，掌握面向对象编程的基本思维，为日后能处理更复杂的代码结构打牢基础。 我曾跟你提过，学Python，做项目是进步最快的。我没说的是：做项目总会遇到种种困难，想不通的逻辑，频频报错的代码。 所以,如果你在今

    2024年02月02日
    浏览(39)
  • C++初阶学习第三弹——类与对象（上）——初始类与对象

    C++初阶学习第三弹——类与对象（上）——初始类与对象

    前言： 在前面，我们已经初步学习了C++的一些基本语法，比如内敛函数、函数重载、缺省参数、引用等等，接下来我们就将正式步入C++的神圣殿堂，首先，先给你找个对象 目录 一、类与对象是什么？ 二、类的各部分组成 1、类的定义 2、类的访问限定符及封装 3、类的作用域

    2024年04月26日
    浏览(39)
  • C++初阶类与对象（一）：学习类与对象、访问限定符、封装、this指针

    C++初阶类与对象（一）：学习类与对象、访问限定符、封装、this指针

    入门知识已经梳理完毕了，接下来就进入到面型对象的部分学习了 C语言典型的 面向过程 的，关注的是过程，分析出求解问题的步骤，通过函数调用 逐步解决 问题 C++是典型的基于 面向对象 的，关注的是对象，将一件事情 拆分成不同的对象 ，靠对象之间的交互完成。 将大

    2024年01月19日
    浏览(28)
  • kotlin学习（一）基本概念、数据对象类型、控制流程、空值检验、类与接口

    kotlin学习（一）基本概念、数据对象类型、控制流程、空值检验、类与接口

    kotlin与java语言一样，编译成字节码后，在JVM虚拟机中运行。kotlin语言的特性依赖于kotlin的语法编译器。与kotlin类似的语言还有： Scala：大数据领域开发语言 Groovy：基于 JVM 平台的动态脚本语言， 在安卓开发中用来编写依赖关系、插件等 2019年谷歌宣布Kotlin成为安卓第一开发语

    2024年02月09日
    浏览(31)
  • iOS开发Swift-6-深色模式,类与对象,MVC模式,弹出框,闭包-趣味问答App

    iOS开发Swift-6-深色模式,类与对象,MVC模式,弹出框,闭包-趣味问答App

    1.创建趣味问答App项目  2.创建一个问题文本，水平居中约束。 创建蓝、红两个按钮，放入Stack View中，给StackView水平居中约束，下边约束，设置两按钮间距为20.  设置进度条view与safe View关系为equal width。设置他们的比例为1：13.  3.为系统增加深色模式适配(仅限iOS13以上版本

    2024年02月10日
    浏览(29)
  • 【Python学习】Python学习20- 面向对象（1）

    【Python学习】Python学习20- 面向对象（1）

    目录 文章所属专区 Python学习 本章节主要说明Python的面向对象的处理。Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方

    2024年01月16日
    浏览(46)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包