python类的相关操作

已于 2022-12-12 18:08:01 修改
阅读量244 收藏 3
点赞数
分类专栏： # python基础 文章标签： class
于 2019-08-26 22:39:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zsx1314lovezyf/article/details/100087391
版权

python类的相关用法

  • 定义一个类

    class Cat:
    #属性

    #方法
    def eat(self):
        print('猫在吃鱼....')
    def drink(self):
        print('猫正喝可乐.....')

  • 创建一个对象

    class Cat:
    #属性

    #方法
    def eat(self):
        print('猫在吃鱼....')
    def drink(self):
        print('猫正喝可乐.....')


#创建一个对象
tom = Cat()#执行Cat()反回对象的引用

  • 调用对象的方法

    class Cat:
    #属性

    #方法
    def eat(self):
        print('猫在吃鱼....')
    def drink(self):
        print('猫正喝可乐.....')


#创建一个对象
tom = Cat()#执行Cat()反回对象的引用
tom.eat()
tom.drink()

# 运行结果 
猫在吃鱼....
猫正喝可乐.....

  • 添加属性

    class Cat:
    #属性

    #方法
    def eat(self):
        print('猫在吃鱼....')
    def drink(self):
        print('猫正喝可乐.....')


#创建一个对象
tom = Cat()#执行Cat()反回对象的引用

#调用tom指向的对象中的  方法
tom.eat()
tom.drink()

#给对象添加属性
tom.name ="汤姆"
tom.age = 40

# 运行结果 但是这个tom对象多了name和age属性
猫在吃鱼....
猫正喝可乐.....

  • 获取对象的属性

    class Cat:
    #属性

    #方法
    def eat(self):
        print('猫在吃鱼....')
    def drink(self):
        print('猫正喝可乐.....')
    def introduce(self):
        print('%s的年龄是:%d'%(tom.name,tom.age))


#创建一个对象
tom = Cat()#执行Cat()反回对象的引用

#调用tom指向的对象中的  方法
tom.eat()
tom.drink()

#给tom指向的对象添加2个属性
tom.name ="汤姆"
tom.age = 40

#获取属性的第一种方式
#print('%s的年龄是:%d'%(tom.name,tom.age))

#获取属性的第二种方式
tom.introduce()

# 运行结果 
猫在吃鱼....
猫正喝可乐.....
汤姆的年龄是:40

  • 多个对象

    class Cat:
    #属性

    #方法
    def eat(self):
        print('猫在吃鱼....')
    def drink(self):
        print('猫正喝可乐.....')
    def introduce(self):
        print('%s的年龄是:%d'%(tom.name,tom.age))


#创建一个对象
tom = Cat()#执行Cat()反回对象的引用

#调用tom指向的对象中的  方法
tom.eat()
tom.drink()

#给tom指向的对象添加2个属性
tom.name ="汤姆"
tom.age = 40

#获取属性的第一种方式
#print('%s的年龄是:%d'%(tom.name,tom.age))

#获取属性的第二种方式
tom.introduce()


#blue_Cat指向了 Cat()反回的引用
blue_Cat = Cat()

blue_Cat.name = '蓝猫'
blue_Cat.age = 10

blue_Cat.introduce()

# 运行结果 
猫在吃鱼....
猫正喝可乐.....
汤姆的年龄是:40
汤姆的年龄是:40

  • self

    class Cat:
    #属性

    #方法
    def eat(self):
        print('猫在吃鱼....')
    def drink(self):
        print('猫正喝可乐.....')
    def introduce(self):
        #print('%s的年龄是:%d'%(tom.name,tom.age))
        print('%s的年龄是:%d'%(self.name,self.age))#self你通过那个对象调用的self就指向谁


#创建一个对象
tom = Cat()#执行Cat()反回对象的引用

#调用tom指向的对象中的  方法
tom.eat()
tom.drink()

#给tom指向的对象添加2个属性
tom.name ="汤姆"
tom.age = 40

#获取属性的第一种方式
#print('%s的年龄是:%d'%(tom.name,tom.age))

#获取属性的第二种方式
tom.introduce()#相当于 tom.introduce(tom)


#blue_Cat是没有tom这个对象的 name 和 age 这两个属性的  需要自己添加
blue_Cat = Cat()

blue_Cat.name = '蓝猫'
blue_Cat.age = 10

blue_Cat.introduce()

# 运行结果 
猫在吃鱼....
猫正喝可乐.....
汤姆的年龄是:40
蓝猫的年龄是:10

  • __init__方法

    class Cat:
    def __init__(self,new_name,new_age): #这里有两个参数 Cat()创建对象的时候也需要两个参数
        self.name = new_name             #那个对想指向这个引用就是为那个对象创建属性
        self.age = new_age
        
    def eat(self):
        print('猫在吃鱼...')

    def drink(self):
        print('猫在喝可乐...')

    def introduce(self):
        print('%s的年龄是:%d'%(self.name,self.age))

tom = Cat("汤姆",40)        #1.创建对象
tom.eat()                   #2.python自动调用__init__()方法 self指向这个对象的引用 给这个对象创建属性
tom.drink()                 #3.然后把这个引用反回 给tom
tom.introduce()


bule_Cat = Cat("蓝猫",10)
bule_Cat.introduce()

# 运行结果 
猫在吃鱼...
猫在喝可乐...
汤姆的年龄是:40
蓝猫的年龄是:10

  • __str__方法

    class Cat:
    '''定义了一个Cat类'''
    #初始化对象
    def __init__(self,new_name,new_age): #这里有两个参数 Cat()创建对象的时候也需要两个参数
        self.name = new_name             #那个对想指向这个引用就是为那个对象创建属性
        self.age = new_age
   
    #描述信息
    def __str__(self):#想用str方法必须用 return
        return '%s的年龄是:%d'%(self.name,self.age) #这是self指向的对象的属性

    #方法
    def eat(self):
        print('猫在吃鱼...')

    def drink(self):
        print('猫在喝可乐...')

    def introduce(self):
        print('%s的年龄是:%d'%(self.name,self.age))

tom = Cat("汤姆",40)    

#每一个对象都是自立门户的  每一个对象的内存地址都不同

blue_Cat = Cat("蓝猫",10)

print(tom) #当我要获取tom的描述信息的时候 self就指向了这个对象
print(blue_Cat) #当我想获取blue_Cat的描述信息的时候 self就指向了这个对象

# 运行结果
汤姆的年龄是:40
蓝猫的年龄是:10

  • 烤地瓜

    class SweetPotato:

    def __init__(self):
        self.cookedString = "生的" #地瓜默认生的
        self.cookedLevel = 0       #考地瓜的时间
        self.condiments = []       #考地瓜添加的材料

    def __str__(self):
        return "当前地瓜:%s(%d),添加的作料有:%s"%(self.cookedString,self.cookedLevel,str(self.condiments))

    def cook(self,cooked_time):

            
        if cooked_time >= 0 and cooked_time < 3:
            self.cookedString = "生的"
            self.cookedLevel = cooked_time 

        elif cooked_time >= 3 and cooked_time < 5:
            self.cookedString = "半生不熟"  #属性 相当于全局变量
            self.cookedLevel = cooked_time
        
        elif cooked_time >= 5 and cooked_time < 8:
            self.cookedString = "熟了"
            self.cookedLevel = cooked_time

        elif cooked_time >= 8:
            self.cookedString = "烤糊了"
            self.cookedLevel = cooked_time

    def addCondiments(self,item):
        self.condiments.append(item)


def main():
    #创建了一个地瓜对象
    di_gua = SweetPotato()
    print(di_gua)
    while True:
        #开始烤地瓜
        time = int(input("请输入你要考的时间(分钟):"))
        di_gua.cook(time)

        #查看地瓜当前状态
        vegetables_name = input("请输入调料:")
        di_gua.addCondiments(vegetables_name)
        print(di_gua)
        print("*"*50)
        #是否继续
        y_n = input("是否继续(y/n):")
        if y_n == 'n':
            break
main()    

# 运行结果
当前地瓜:生的(0),添加的作料有:[]
请输入你要考的时间(分钟):10
请输入调料:辣椒
当前地瓜:烤糊了(10),添加的作料有:['辣椒']
**************************************************
是否继续(y/n):y
请输入你要考的时间(分钟):5
请输入调料:鸡精 
当前地瓜:熟了(5),添加的作料有:['辣椒', '鸡精 ']
*********************************************

  • 存放家具

    class Home:

    def __init__(self,new_area,new_type,new_addr):
        self.area = new_area
        self.type = new_type
        self.addr = new_addr
        self.left_area = new_area
        self.furniture = []

    def __str__(self):
        msg = "房子的大小:%d,房子的可用面积:%d,房子的类型:%s,房子的位置:%s"%(self.area,self.left_area,self.type,self.addr)
        msg+= "现在房子的家具有:%s"%(str(self.furniture))
        return msg

    def residual_area(self,item):
        #self.left_area -= item.area
        #self.furniture.append(item.name)
        self.left_area -= item.get_area()
        self.furniture.append(item.get_name())

class Bed:

    def __init__(self,new_name,new_area):
        self.name = new_name
        self.area = new_area

    def __str__(self):
        return "%s床的大小%d"%(self.name,self.area)

    def get_area(self):
        return self.area

    def get_name(self):
        return self.name

def main():
    home = Home(129,"三室一厅","北京市 朝阳区 长安街 666号")
    print(home)

    bed1 = Bed("希姆斯",4)
    print(bed1)
    home.residual_area(bed1)
    print(home)
    bed2 = Bed("赛巴特",6)
    print(bed2)
    home.residual_area(bed2)
    print(home)

main()

# 运行结果
房子的大小:129,房子的可用面积:129,房子的类型:三室一厅,房子的位置:北京市 朝阳区 长安街 666号现在房子的家具有:[]
希姆斯床的大小4
房子的大小:129,房子的可用面积:125,房子的类型:三室一厅,房子的位置:北京市 朝阳区 长安街 666号现在房子的家具有:['希姆斯']
赛巴特床的大小6
房子的大小:129,房子的可用面积:119,房子的类型:三室一厅,房子的位置:北京市 朝阳区 长安街 666号现在房子的家具有:['希姆斯', '赛巴特']

  • 类的多个对象的注意点

    类  不管你创建多少对象 对象怎么添加属性了  那只是那对象指向的那快内存添加了属性
你在创建对象指向 类的引用的时候  类会从新划分一个区域 类之前怎么定义的 定义的右那些  你现在指向他的就有那些
列:

class Cat:
    def eat(self):
        print('吃')
    def drink(self):
        print('喝')
    def introduce(self):
        print("%s的年龄是:%d"%(self.name,self.age))

只是tom指向的这个内存有这两个属性
tom = Cat()
tom.eat() 
tom.drink()
tom.name = '汤姆'   这只是添加到tom这个对象里了
tom.age = 18


blue指向的内存是没有name age 这两个属性的 但是Cat类的方法全有
blue = Cat()  blue这个对象是没有的

  • 隐藏属性

    class Dog:

    def set_age(self,new_age):
        if new_age > 0 and new_age < 100:
            self.age = new_age
        else:
            self.age = 0

    def get_age(self):
        return self.age


dog = Dog()
#这种方式给属性赋值不安全
#dog.Dog = -10
#dog.name = "小白"
#print(dog.age)


#这种安全
dog.set_age(10)
age = dog.get_age()
print(age)

# 运行结果
10

  • 私有方法

    class Dog:

    def __send_msg(self):
        print("------短信发送中------")
    
    def send_msg(self,new_money):
        if new_money > 100000:
            self.__send_msg()
        else:
            print("余额不足,请先充值,在来发送短信...")

dog = Dog()
dog.send_msg(1000000000)

# 运行结果
------短信发送中------

  • __del__方法

    class Dog:
    
    def __del__(self):
        print("----英雄死亡----")


dog1 = Dog()
dog2 = dog1  #dog2 dog1 同时指向了这个对象


#不会调用 __del__方法,因为这个对象 还有其他的变量指向它,即 引用计算不是0
del dog1 



#此时会调用__del__方法,因为没有变量指向它
del dog2  

print("========================")

#如果在程序结束时,有些对象还存在,那么python解释器会自动调用它们的__del__方法来完成清理工作

# 运行结果 
----英雄死亡----
========================

  • 测量对象的引用个数

    import sys
class Dog:
    
    def __del__(self):
        print("----英雄死亡----")


dog1 = Dog()
dog2 = dog1  #dog2 dog1 同时指向了这个对象


#不会调用 __del__方法,因为这个对象 还有其他的变量指向它,即 引用计算不是0
del dog1 

#测量对象的引用个数,只要吧指向这个对象的变量放进去就行  得出来的引用个数 比实际的引用个数多1
count = sys.getrefcount(dog2)
print(count-1)


#此时会调用__del__方法,因为没有变量指向它
del dog2  

print("========================")

#如果在程序结束时,有些对象还存在,那么python解释器会自动调用它们的__del__方法来完成清理工作

# 运行结果
1
----英雄死亡----
========================

  • 继承

    class Animal:  #猫的基类  也就是   父类

    def eat(self):
        print("----吃----")
    def drink(self):
        print("----喝----")
    def sleep(self):
        print("----睡觉----")
    def run(self):
        print("----跑----")

class Dog(Animal): #继承  父类

    def bark(self):
        print("----汪汪叫----")


class Cat(Animal):

    def catch(self):
        print("----捉老鼠----")

dog = Dog() #dog 只能用 Dog和Animal类中的方法
dog.eat()

cat = Cat() #cat 只能用 Cat和Animal类中的方法
cat.eat()


# 不允许出现, dog使用Cat类中的方法 或着 cat使用Dog类中的方法

# 运行结果
----吃----
----吃----

  • 继承-扩展

    class Animal:  #猫的基类  也就是   父类

    def eat(self):
        print("----吃----")
    def drink(self):
        print("----喝----")
    def sleep(self):
        print("----睡觉----")
    def run(self):
        print("----跑----")

class Dog(Animal): #继承  父类

    def bark(self):
        print("----汪汪叫----")


class Xiaotq(Dog):

    def fly(self):
        print("----飞----")


xiaotq = Xiaotq()

xiaotq.fly() #继承 可以是多层继承
xiaotq.bark()
xiaotq.eat()

# 运行结果
----飞----
----汪汪叫----
----吃----

  • 重写

    class Animal:  #猫的基类  也就是   父类

    def eat(self):
        print("----吃----")
    def drink(self):
        print("----喝----")
    def sleep(self):
        print("----睡觉----")
    def run(self):
        print("----跑----")

class Dog(Animal): #继承  父类

    def bark(self):
        print("----汪汪叫----")


class Xiaotq(Dog):

    def fly(self):
        print("----飞----")

    def bark(self):  #方法重写必须名字相同
        print("----狂叫----")

xiaotq = Xiaotq()

xiaotq.fly() #继承 可以是多层继承
xiaotq.bark() # 它会在自己本地的类里找这个方法  如果没有  就会找父类
xiaotq.eat()

# 运行结果
----飞----
----狂叫----
----吃----

  • 调用被重写的方法

    class Animal:  #猫的基类  也就是   父类

    def eat(self):
        print("----吃----")
    def drink(self):
        print("----喝----")
    def sleep(self):
        print("----睡觉----")
    def run(self):
        print("----跑----")

class Dog(Animal): #继承  父类

    def bark(self):
        print("----汪汪叫----")


class Xiaotq(Dog):

    def fly(self):
        print("----飞----")

    def bark(self):  #方法重写必须名字相同
        print("----狂叫----")

        #第一种调用被重写的父类的方法
        # Dog.bark(self) #调用父类的汪汪叫 self必须写

        #第二种
        super().bark()  # super相当于一个方法  实际上它是一个类 调用super()他有一个结果
        #这个结果 .bark() 就是 Dog里的bark()方法

xiaotq = Xiaotq()

xiaotq.fly() #继承 可以是多层继承
xiaotq.bark() # 它会在自己本地的类里找这个方法  如果没有  就会找父类
xiaotq.eat()

# 运行结果
----飞----
----狂叫----
----汪汪叫----
----吃----

  • 私有方法-私有属性在继承中的表现

    class A:

    def __init__(self):
        self.num = 100
        self.__num = 200

    def test1(self):
        print('----哈哈----')

    def __test2(self):
        print('----呵呵----')

    
    def test3(self):                #如果调用的是 继承的父类中的 公有方法 可以在这个公有方法中访问父类
        print(self.__num)           #中的私有属性和私有方法
        self.__test2()

class B(A):
    def test4(self):                #但是 如果在子类中实现了一个公有方法,那么这个方法是不能够调用继承的父类中
        print(self.__num)           #的私有方法和私有属性的
        self.__test2()

b = B()
#b.test1()
#b.__test2() #私有方法和属性并不会被继承
#print(b.num)
#print(b.__num)
b.test3()
b.test4()

# 运行结果
200
----呵呵----
Traceback (most recent call last):
  File "09-私有方法-私有属性在继承中的表现.py", line 29, in <module>
    b.test4()
  File "09-私有方法-私有属性在继承中的表现.py", line 20, in test4
    print(self.__num)           #的私有方法和私有属性的
AttributeError: 'B' object has no attribute '_B__num'

  • 多继承

    class Base(object):
    def test(self):
        print("----Base")

class A(Base):
    def test1(self):
        print("----A")

class B(Base):
    def test2(self):
        print("----B")

class C(A,B): #多继承 多继承可以继承 无数个类  只要你用逗号隔开就行  
    pass


c = C()
c.test()
c.test1()
c.test2()

# 运行结果
----Base
----A
----B

  • 多继承-注意点

    class Base(object):
    def test(self):
        print("----Base")

class A(Base):
    def test(self):
        print("----A")

class B(Base):
    def test(self):
        print("----B")

class C(A,B): #多继承 多继承可以继承 无数个类  只要你用逗号隔开就行  
    pass


c = C()
c.test() 
print(C.__mro__) #决定这 调用一个方法的时候,搜索的顺序,如果在某个类中找到了方法,那么就停止搜索

# 运行结果
----A
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>)

  • 多态

    class Dog(object):
    def print_self(self):
        print("大家好,我是Q弟,希望大家以后多多关照...")

class Xiaotq(Dog):
    def print_self(self):
        print("hello everbody,我是你们的老大,我是哮天犬...")

def introduce(temp):        
    temp.print_self() # temp这个对象是谁我就调谁 这就是多态
#多态是  当你定义的时候不确定调用那些功能 而是等到真正调用的时候才知道是调用子类的方法 还是父类的方法的时候
#这就是多态

dog1 = Dog()
introduce(dog1)

dog2 = Xiaotq()
introduce(dog2)

# 运行结果
大家好,我是Q弟,希望大家以后多多关照...
hello everbody,我是你们的老大,我是哮天犬...

  • 类属性-实列属性

    class Tool(object):
    
    #类属性
    num = 0
    
    #方法
    def __init__(self,new_name):

        #实列属性
        self.name = new_name

        #类属性+=1      
        Tool.num+=1


t1 = Tool("锹")
t2 = Tool("鞋子")
t3 = Tool("裤子")
print(Tool.num)
print(t1.num)# 同理 t2,t3 也可以

# 运行结果
3
3

  • 实列方法-类方法-静态方法

    #对实列属性操作记得用实列方法 不要直接用 指向那个实列对象的变量名.实列属性改值  不安全
#同理类也是一样的
#如果又不需要对类属性进行操作  也不对实列属性进行操作  那么就用静态方法
#一用类就全用类 别用类了  又用函数




class Game(object):

    num = 0

    def __init__(self): #实列方法 必有一个参数 这个参数名可以不用写self 不过一般都写self
        #实列属性
        self.name = "狗狗"

    #类方法
    @classmethod
    def add_num(cls): #类方法 必须有一个参数 这个参数名可以不用写cls  不过一般都写 cls
        cls.num = 100

    #静态方法
    @staticmethod
    def print_menu(): #静态方法可以有参数可以没有 主要是看调用的时候  有没有参数
        print("----------------")
        print("   穿越火线V11.1")
        print("   1.开始游戏")
        print("   2.结束游戏")
        print("----------------")


game = Game()
#Game.add_num() #可以通过类的名字调用类的方法
game.add_num()#还可以通过这个类创建出来的对象 去调用这个类方法
print(Game.num)

#Game.print_menu()#通过类 去调用静态方法
game.print_menu() #通过实列对象 去调用静态方法

# 运行结果
100
----------------
   穿越火线V11.1
   1.开始游戏
   2.结束游戏
----------------

  • 设计4s店类-代码讲解-工厂方法模式

    class Store(object): #店铺
    def select_car(self):
        pass

    def order(self,car_type):
        return self.select_car(car_type)



class BMWCarStore(Store):
    def select_car(self,car_type):
        return BMWFactory().select_car_by_type(car_type)

class CarStore(Store):
    def select_car(self,car_type):
        return Factory().select_car_by_type(car_type)

class BMWFactory(object):
    def select_car_by_type(self,car_type):
        if car_type == "720li":
            return Li()

        elif car_type == "mili":
            return Mini()

        elif car_type == "x6":
            return X6()

class Factory(object):
    def select_car_by_type(self,car_type):
        if car_type == "索纳塔":
            return Suolata()

        elif car_type == "名图":
            return Mingto()

        elif car_type == "ix35":
            return Ix35()

class Car(object):  #车
	def move(self):
		print("车在移动...")
	def music(self):
		print("正在听音乐...")
	def stop(self):
		print("车在停止...")
	

class Suolata(Car):
    pass

class Mingto(Car):
    pass


class Ix35(Car):
	pass

class Mini(Car):
    pass

class X6(Car):
    pass


class Li(Car):
    pass


car_store = CarStore()  # 创建店铺

car = car_store.order("索纳塔") # 预定
#car 指向了 Car()这个对象
car.move()#开
car.music()#音乐
car.stop()#停

bmw_store = BMWCarStore()
bmw = bmw_store.order("720li")
bmw.move()#开
bmw.music()#音乐
bmw.stop()#停

print(CarStore.__mro__)    

# 运行结果
车在移动...
正在听音乐...
车在停止...
车在移动...
正在听音乐...
车在停止...
(<class '__main__.CarStore'>, <class '__main__.Store'>, <class 'object'>)

  • __new__方法

    class Dog(object):                                                #init和new方法合起来就是C++里面的构造方法创建并初始化

    def __init__(self): #init方法只负责初始化 
        print("----init方法----")

    def __str__(self):
        print("----str方法----")
        return "对象的描述信息"

    def __del__(self):
        print("----del方法----")

    def __new__(cls):#cls此时是Dog指向的那个类对象
        #print(id(cls))
        print("----new方法----")  #new方法只负责创建对象
        return object.__new__(cls)

#print(id(Dog))
xtq = Dog()
#Dog() 相当于要做3件事情:
# 1.调用__new__方法来创建对象,然后找了一个变量来接收__new__的返回值,这个返回值表示 创建出来的对象的引用
# 2.__init__(刚刚创建出来的对象的引用)
# 3.返回对象的引用

# 运行结果
----new方法----
----init方法----
----del方法----

  • 创建一个单列

    class Dog(object):

    __instance = None

    def __new__(cls):
        if cls.__instance == None:
            cls.__instance = object.__new__(cls)
            return cls.__instance
        else:
            return cls.__instance #反回上次创建的对象的引用

a = Dog()
print(id(a))

b = Dog()
print(id(b))

# 运行结果
4338845232
4338845232

  • 只初始化1次

    class Dog(object):

    __instance = None
    
    __initialization = 0
    def __new__(cls,new_name,new_age):
        if cls.__instance == None:
            cls.__instance = object.__new__(cls)
            return cls.__instance
        else:
            return cls.__instance #反回上次创建的对象的引用

    def __init__(self,new_name,new_age):
        if self.__initialization == 0: #这里可以用self可以调用__initialization 虽然它类属性 类属性调用 Dog.__initialization
            self.__initialization = 1
            self.name = new_name
            self.age = new_age

    def __str__(self):
        return "%s的年龄为:%d"%(self.name,self.age)

a = Dog("狗",4)
print(id(a))
print(a)

b = Dog("犬",5)
print(id(b))
print(b)

# 运行结果
4330702104
狗的年龄为:4
4330702104
狗的年龄为:4
只因为你温柔
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【笔记】python中的继承：子类的方法 _init_()、给子类定义属性和方法、重写父类的方法、将实例用作属性
qq_51843109的博客
03-29 3327
文章目录一、继承1.子类的方法 _init_()2.给子类定义属性和方法3.重写父类的方法4.将实例用作属性5.模拟实物 一、继承 1.子类的方法 init() 2.给子类定义属性和方法 3.重写父类的方法 4.将实例用作属性 5.模拟实物 ...
python用类实现栈
ass_assinator的博客
09-05 1131
python用类实现栈栈是一种数据结构，最后入栈的元素出栈时会首先拿出来，即后入先出。用python编写脚本，使用类的功能，采用面对对象编程，实现栈的功能。该脚本中初始栈为空栈。 该脚本如下所示：class stack(object): def __init__(self): self.stack = [] def enstack(self,item):
python中类的使用详解
weixin_63318044的博客
12-31 4069
可以使用类去封装属性，并基于类创建出一个个的对象来使用。class是关键字，表示要定义类了类的属性，即定义在类中的变量（成员变量)类的行为，即定义在类中的函数（成员方法)创建类对象的语法：对象=类名称（）在类中定义成员方法和定义函数基本一致，但仍有细微区别:def 方法名(self，形参1，......，形参N):方法体self关键字self关键字是成员方法定义的时候，必须填写的。它用来表示类对象自身的意思当我们使用类对象调用方法的是，self会自动被python传入。
Python--类（讲解）
热门推荐
生而无畏，战至终章
04-03 1万+
创建（定义）类。创建类的实例对象，通过实例对象实现特定的功能。class 类名：多个（≥ 0 ）类属性 . . . 多个（≥ 0 ）类方法 . . .注意：无论类属性还是类方法，都不是必须的，还有就是类属性和类方法的位置是任意的，没有固定的先后顺序。但一般都是属性在前，方法在后。
Python 中常用的数据类型及相关操作详解
全栈若城,专注知识分享
06-19 983
本文详细介绍了 Python 中常用的数据类型，包括列表、元组、字符串、集合和字典等，以及它们的创建方法和常见操作。通过阅读本文，你将学会如何创建、访问、添加、修改和删除这些数据类型中的元素，并能够熟练地运用它们进行编程。
15个超级实用的Python操作，肯定有你意想不到的！
2301_80241064的博客
11-29 983
1）映射代理（不可变字典）2）dict 对于类和对象是不同的 3) any() 和 all()4) divmod()5) 使用格式化字符串轻松检查变量......
python中类的使用
月夜的博客
11-25 242
类(Class):用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。在所有的def之外定义的 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。实例变量：在类的声明中，属性是用变量来表...
Python3实现的Mysql数据库操作封装类
09-09
在Python3中，为了提高代码的可重用性和模块化，我们常常会将数据库操作封装成一个类。这个类通常包含了连接数据库、执行SQL查询、更新数据以及关闭连接等基本功能。以下是一个关于Python3实现的Mysql数据库操作封装...
python写日志文件操作类与应用示例
09-19
主要介绍了python写日志文件操作类与应用,结合实例形式分析了Python日志文件操作类的定义与使用相关操作技巧,需要的朋友可以参考下
Python面向对象之类的封装操作示例
09-19
主要介绍了Python面向对象之类的封装操作,结合具体实例形式分析了Python面向对象程序设计中类方法的定义与使用相关操作技巧,需要的朋友可以参考下
Python中类的创建和实例化操作示例
09-19
主要介绍了Python中类的创建和实例化操作,涉及Python面向对象程序设计中类的定义、实例化、方法调用等相关操作技巧,需要的朋友可以参考下
什么是python类属性
09-16
总结来说，Python的类属性提供了一种方便的方式来管理和控制与类相关的数据，同时提供了数据保护和灵活性。通过使用`@property`装饰器，我们可以实现属性的访问控制，确保数据的安全性。理解并熟练使用类属性是...
python中常用的类,python 类的用法
gk12336的博客
03-13 1073
方法 _init_() 接受这些形参的值，并将它们赋值给根据这个类创建的实例的属性。这行代码让python调用Car类的方法 _init_() ，让ElectricCar 实例包含这个方法中定义的所有属性。在这里，命名约定很有用：通常可认为首字母大写的名称（如Dog）指的是类，而小写的名称（如my_dog）指的是根据类创建的实例。我们可以按照需求根据一个类创建任意数量的实例，条件是将每个实例都存储在不同的变量中，或者占用列表或字典的不同位置。简要的描述类的功能，并遵守编写函数的文档字符串时采用的格式约定。
PYTHON基础-面向对象编程（OOP）基础语法
weixin_46039021的博客
11-03 237
PYTHON基础之介绍面向对象编程的基本语法
Python类的概念和使用以及继承等用法—十分详细清楚
m0_74055982的博客
04-23 1181
在python中，类表示具有相同属性和方法的对象的集合，属性可以看成是一些对象可以是变量也可以是别的，方法就是在类中定义的函数，在使用类的时候，需要先定义类，然后再创建类的实例，通过类的实例就可以访问类中的属性和方法了，可以理解成类是一个集合里面包含有很多变量以及函数，但是又有一些便捷的操作和方法。类的定义使用class关键字来实现。
python中变量命名规则
大学生活与学习一站式解决方案.
01-17 187
Python中变量的命名规则
python利用面向对象的思想实现功能代码练习
kermit0327的博客
03-12 1706
1.利用面向对象的思想，实现以下功能： (1)创建一个猫（Cat）类，其包含属性：名字（name）、品种（type）、 价格（price）、颜色（color），并定义适当构造、析构的方法 (2)创建一个老鼠(Mouse)类，其包含属性：名字（name）、颜色（color）， 并定义适当的构造、析构方法 (3)在Cat类中定义一个属性cat_num，该属性存储的值为当前已实例化的猫的个数 #(4)在...
qt练习控件label控件-lineEdit控件样例代码
最新发布
07-30
qt练习控件label控件-lineEdit控件样例代码
python 类连贯操作没有智能提示
08-30
Python类的连贯操作指的是对同一个类的多个方法的连续调用，以链式语法的方式进行操作，可以使代码更简洁，可读性更好。然而，Python中的连贯操作确实不提供智能提示的功能。 智能提示是指在编码过程中，IDE或编辑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

只因为你温柔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值