python类的详解_python 类详解 - CSDN
精华内容
参与话题
  • 是面向对象中的对象;掌握的基本使用极为重要 一、创建 class Dog(): def __init__(self, name, age): # 类似于构造方法,初始化时传入参数,并自动加载 self.name = name # 在__init__中采用self...

    类是面向对象中的对象;掌握类的基本使用极为重要

    一、创建类

    class Dog():
        
        def __init__(self, name, age):  # 类似于构造方法,类初始化时传入参数,并自动加载
            self.name = name # 在__init__中采用self声明全局变量
            self.age = age
        
        def sit(self):
            print(self.name + " is " + str(self.age) + " years old and is sitting!")
    
    
    myDog = Dog('wangcai', 2)
    myDog.age = 4 #修改对象中属性的值
    myDog.sit() #调用对象中的方法

    注意:在类的编写中,注意空格和tab的统一以及缩进的层级关系;如果出现 IndentationError: unexpected indent;则是空格与tab键出了问题;

    二、继承

    class Dog():
        
        def __init__(self, name, age):  # 类似于构造方法,类初始化时传入参数,并自动加载
            self.name = name # 在__init__中采用self声明全局变量
            self.age = age
        
        def sit(self):
            print(self.name + " is " + str(self.age) + " years old and is sitting!")
    
    
    
    class hashiqi(Dog): # 哈士奇继承Dog
        
        def __init__(self, name, age):
            super().__init__(name, age)
        
        def sit(self): # 重写父类的方法
            print("哈士奇 is sitting!")
        
        def crazy(self):
            print("Only 哈士奇 can crazy!")
    
    myDog = hashiqi('wangcai', 2)
    myDog.sit() 
    myDog.crazy() 
    

    另一点需要注意的是python2.x继承的方式会有稍许不同,其子类在__init__构造方法中,需要添加两个super方法的实参:第一个为子类名,第二个是self。

    class Car(object):
        def __init__(self, make):
            print "Parent"
    
        
    class ElecCar(Car):
        def __init__(self,make):
            super(ElecCar, self).__init__(make)
            print "Child"

    三、类的导入

    类的导入与函数的导入基本一致。

    可参考: https://blog.csdn.net/lanluyug/article/details/103651384

    四、python标准库

    from collections import OrderedDict
    from random import randint
    dict = OrderedDict()
    num = randint(1,6)

    其中OrderedDict和randint都是标准库中的函数,导入后可直接使用;

     

    展开全文
  • python(类详解)

    2018-11-22 23:24:54
    面向对象,面向过程的区别: 面向过程开发,以函数作为基本结构使用: 面向对象的开发,以对象作为基本结构使用 语言中对象结构的特色:高内聚,低耦合。 的定义 是一个实物的特征的集合,是抽象的概念。 ...

    面向对象,面向过程的区别:
    面向过程开发,以函数作为基本结构使用:
    面向对象的开发,以对象作为基本结构使用
    语言中对象结构的特色:高内聚,低耦合。
    类的定义
    类是一个实物的特征的集合,是抽象的概念。
    类和对象的关系 类是多个对象归纳总结而来的,是一种概念,包含所有对象。

    由对象总结出类的过程,叫做抽象化 对象是类的具体实现或者实施而来,他是真实的,特指某个事物
    由类制作出对象的过程,叫做实例化 如何书写类文件 推荐使用驼峰命名法来书写文件
    定义规则:
    类名:每个单词的首字母大写
    函数名 /变量:除了第一个单词之外首字母大写
    类的组成:
    一个文件如果是一个单独的类,那么直接使用类名来当作文件名即可
    类的组成 类中只有2种内容:成员属性和成员方法
    成员属性: 用于描述类的特征的变量就是成员属性
    成员方法: 用于描述类的功能的函数就是成员方法
    类的书写规则 1.必须使用class关键字来声明一个类
    2.类的名称需要符合驼峰命名法(规范)
    3.类中只能存在2种内容,成员属性和成员方法,除此之外,所有的代码都禁止出现!
    4.声明成员属性时,所有成员属性必须有值,如果没值会报错!,推荐使用None等值代替
    5.成员方法只需要按照函数的规则声明即可实例化对象 实例化对象格式
    注意:在定义类的成员方法的时候,方法的参数至少有一个self。相当于c++中的this指针
    class A():
    def fun():
    print(“我和石头做游戏”)
    编译报错:
    File “E:/project/作业_20180821.py”, line 199
    path = “D:\”"
    ^
    SyntaxError: EOL while scanning string literal

    init(self):python中的构造方法
    除类self之外,还可以传入其他参数。通过重写方法制定这些初始化操作

    私有,公有
    私有: 在变量和函数名前加上两个下划线(__)就可以类
    注意:私有变量在类外不能进行访问和修改,只能通过内部访问和修改(调用get,set函数)

    继承 lass 子类(父类) :
    #继承操作的关键步骤 pass 继承的特征
    1.所有类都是继承自object类(object类对应的对象就是object对象,也是万物皆对象)
    2.子类继承父类则可以访问父类的所有成员。(私有成员除外)
    3.子类继承父类并不会将父类的所有成员复制到子类当中去,访问父类成员是间接通过父类来访问的,
    4.子类可以具有自己独有的属性和方法
    5.子类可以重载父类中的方法,只需要设置和父类指定成员相同的名称即可实现重载,重载之后的成员,子类只会访问当前类中的成员,而不会调用父类中同名的成员
    6.子类中如果重载父类的方法,并且还想将重载的父类方法借调过来使用,可以在重载的方法中使用如下方法 父类名.方法()或者 super().方法() 单继承和多继承 单继承:每个类只能继承一个类的方式称为单继承。
    7.父类中的私有化方法和属性不能被继承
    父类名.方法(self) :调用未绑定的父类方法
    格式:父类名.方法(self)
    注意:当使用这种方法调用父类的方法时候,父类的方法的参数是子类的实例化对象
    super(). :使用super()函数
    格式:super().父类名.方法()
    注意:这里不需要将自对象的实例化参数self传入
    注意:对于你定义的每一个类,python会计算出一个方法解析顺序(MRO)列表,这个MRO列表就是一个简单的所有基类的线性顺序列表,python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。
    补充: 类名.mro()可以查看该类对应的MRO表
    多重继承:
    Class 类名(要继承的类1,要继承的类2):
    子类的代码块
    注意:当子类继承类多个类的时候,当多个父类的成员方法名不相同时候,则子类都可以进行访问调用,如果多个父类的成员方法的方法名是相同的时候,则当子类调用时候,只按照继承顺序的先后进行调用,调用一次后,不会在调用。
    Eg:
    class Base1:
    def fool(self):
    print(“我是Bool1”)
    class Base2:
    def fool(self):
    print(“我是Bool2”)
    class C(Base1, Base2):
    pass
    c = C()
    c.fool()
    实行结果:我是Bool1
    类的组合:把类的实例化放到新类里面,一般是把几个不是继承关系的类放到一起(没有纵向关系(继承关系),有横向关系)
    补充:一个类的成员变量可以是另一个类的实例化对象(两个类之间没有继承关系)
    Eg:
    class Turtle:
    def init(self, x):
    self.num = x
    class Fish:
    def init(self, x):
    self.num = x
    class Pool:
    def init(self, x, y):
    self.turtle = Turtle(x)
    self.fish = Fish(y)
    def display(self):
    print(self.turtle.num, self.fish.num, sep="\t")
    pool = Pool(2,9)
    pool.display()
    实行结果:2 9
    注解:Pool类中的成员变量分别是Turtle和Fish的实例化对象
    程序调用顺序:
    1.Pool实例化对象,调用Pool的构造函数,将两个参数传入,在构造函数中,对Turtle和Fish分别实例化对象,将传入Pool构造函数的两个参数传入到Turtle和Fish实例化的构造函数中,实例化turtle和fish作为Pool的实例化对象pool的成员变量.pool调用display()函数时,又分别访问了turtle和fish的成员变量num。
    继承有两种用途:
    一:继承基类的方法,并且做出自己的改变或者扩展(代码重用)
    二:声明某个子类兼容于某基类,定义一个接口类Interface,接口类中定义了一些接口名(就是函数名)且并未实现接口的功能,子类继承接口类,并且实现接口中的功能

    补充:
    当类之间有显著不同,并且较小的类是较大的类所需要的组件时,用组合比较好
    类,类对象,实例对象
    1.对象属性,实例化对象属性
    以下代码中,类:C 类对象:CC 实例化对象:a,b,d
    class C:
    count = 0
    a = C()
    b = C()
    d = C()
    print(a.count, b.count, d.count) # 1
    d.count += 10
    print(a.count, b.count, d.count) # 2 修改的是d的实例化对象属性,发生变化的是d的count属性,a和b是分别实例化的它们的值不会修改
    C.count = 100
    print(a.count, b.count, d.count) # 3 修改的是类C的静态属性值,a和c没对其实例化属性修改过,而d之前对实例化对象的属性赋值,覆盖了类的静态属性
    实行结果:
    0 0 0
    0 0 10
    100 100 10

    2.实例化对象的属性和方法相同,则属性覆盖方法
    class A:
    def display(self):
    print(“AAAAA”)
    a = A()
    a.display()
    a.display = 1 #python中对象不需要声明,直接赋值就是定义。给实例化对象a的display属性直接赋值,该属性和方法名相同,则属性名直接将方法名覆盖掉
    a.display()
    实行结果:
    AAAAA
    Traceback (most recent call last):
    File “E:/project/作业_20180821.py”, line 372, in
    a.display()
    TypeError: ‘int’ object is not callable

    Python中约定俗成的规定:
    1.不要试图在一个类里定义所有能想到的特性和方法,应该利用继承和组合机制进行拓展
    2.用不同的词性命名,如属性名用名词,方法名用动词
    绑定
    定义:python严格要求方法需要有实例才能被调用,这种限制就是绑定
    1.
    class A:
    def display():
    print(“AAAAA”)
    A.display() # 类对象A直接调用displa方法不会报错
    a = A()
    a.display() # 实例化对象a直接调用display方法会报错,因为调用display时把a当作参数传进去了,完整的调用方法a.display(a)
    实行结果:
    AAAAA
    Traceback (most recent call last):
    File “E:/project/作业_20180821.py”, line 379, in
    a.display()
    TypeError: display() takes 0 positional arguments but 1 was given
    2.
    class CC:
    def setXY(self, x, y):
    self.x = x
    self.y = y
    def printXY(self):
    print(self.x, self.y)
    dd = CC()
    print(“dd:dict”, dd.dict) # 查看对象所有的属性,返回一个字典的类型。字典中只有实例对象的属性,不显示类属性和特殊属性(魔术方法)
    print(“CC:dict”, CC.dict) # 键表示属性名,值就是属性的值
    dd.setXY(4, 6)
    print(“dd:dict”, dd.dict) # 这x,y只属于dd这个实例化对象
    print(“CC:dict”, CC.dict) # 类属性中,没有4和6,这归功于绑定,实例化对象dd调用setxy(4,5)实际上将自身当作参数传入进去,完整的函数是dd.setxy(dd,4,6),在函数中赋值是dd.x = 4,dd.y = 6,所以4,6只属于dd
    del CC

    ee = CC() # 出错,类对象已经删除

    dd.printXY()

    实行结果:
    dd:dict {}
    CC:dict {‘module’: ‘main’, ‘setXY’: <function CC.setXY at 0x00000000029D7598>, ‘printXY’: <function CC.printXY at 0x00000000029D7620>, ‘dict’: <attribute ‘dict’ of ‘CC’ objects>, ‘weakref’: <attribute ‘weakref’ of ‘CC’ objects>, ‘doc’: None}
    dd:dict {‘x’: 4, ‘y’: 6}
    CC:dict {‘module’: ‘main’, ‘setXY’: <function CC.setXY at 0x00000000029D7598>, ‘printXY’: <function CC.printXY at 0x00000000029D7620>, ‘dict’: <attribute ‘dict’ of ‘CC’ objects>, ‘weakref’: <attribute ‘weakref’ of ‘CC’ objects>, ‘doc’: None}
    4 6

    注意:类中定义的属性和方法是静态变量,就算类对象被删除了,它们还是存放在内存中,只有在程序退出时候,它们才会被释放。(建议编程时使用实例属性,不要使用类属性)
    与类,对象相关的BIF(内置函数)
    1.issubclass(class1,class2)
    如果class1是class2的子类就返回True
    注意:1.检查是非严格行的检查(一个类也是本身的子类)
    2.class2类对象组成的元组,只要class1是其中任何一个候选类的子类则返回True
    3.其他情况会抛出一个TypeError异常
    2.isinstance(class1,class2)
    注意:1.如果第一个参数传的不是对象类型,则永远返回False
    2.第二个参数不是类或者不是由类组成的元组,则抛出一个TypeError的异常
    3.第一个参数是一个类的实例化对象,第二个是这个类对象时,返回True
    3.hasattr(object,name)
    查询对象是否有指定的属性
    第一个是对象,第二个是属性名,用双引号串起来,否则报错
    4.getattr(object,name[,default])
    返回对象指定的属性值,如果该对象没有其属性,则返回制定的默认值,如果没有属性还有没有设定默认返回值,则抛出一个AttrbuteError异常
    5.setattr(object,name,value)
    如果对象没有属性值,则设定对象指定的属性值,
    6.delattr(object,name)
    删除对象是否有指定的属性,如果对象没有其属性值,则抛出一个AttrbuteError异常
    注意:object可为实例化对象,也可为类对象
    7.property(fget = None , fset=None , fdel = None, doc=None)
    含义:通过属性来设置属性,第一个参数获得属性的方法,第二个参数设置属性的方法,第三个参数删除属性的方法。
    优点:不需要修改接口a,只需要修改函数名和property的参数名,通过一个或多个魔术发方法实现
    class DD:
    def init(self, x = 10):
    self.x = x
    def getx(self):
    return self.x
    def setx(self, x):
    self.x = x
    def delx(self):
    del self.x
    a = property(getx, setx, delx)

    dd = DD()
    print(dd.getx())
    print(dd.x)
    print(dd.a)
    dd.a = 19
    print(dd.getx())
    print(dd.x)
    print(dd.a)
    del dd.a
    print(dd.getx()) #运行时会报错
    print(dd.x)
    print(dd.a)
    实行结果:
    10
    10
    10
    19
    19
    19

    展开全文
  • python类的实例方法、静态方法和方法区别及其应用场景 一、先看语法,python 语法中有三种方法,实例方法,静态方法,方法。 ps.python中self,cls的区别 普通实例方法,第一个参数需要是self,它表示一...

    python类的实例方法、静态方法和类方法区别及其应用场景

    一、先看语法,python 类语法中有三种方法,实例方法,静态方法,类方法。

     

    ps.python中self,cls的区别

    普通实例方法,第一个参数需要是self,它表示一个具体的实例本身。
    如果用了staticmethod,那么就可以无视这个self,而将这个方法当成一个普通的函数使用。
    而对于classmethod,它的第一个参数不是self,是cls,它表示这个类本身。

    # coding:utf-8
    class Foo(object):
        """类三种方法语法形式"""
    
        def instance_method(self):
            print("是类{}的实例方法,只能被实例对象调用".format(Foo))
    
        @staticmethod
        def static_method():
            print("是静态方法")
    
        @classmethod
        def class_method(cls):
            print("是类方法")
    
    foo = Foo()
    foo.instance_method()
    foo.static_method()
    foo.class_method()
    print('----------------')
    Foo.static_method()
    Foo.class_method()

    运行结果如下

    是类<class '__main__.Foo'>的实例方法,只能被实例对象调用
    是静态方法
    是类方法
    ----------------
    是静态方法
    是类方法

    说明:

    实例方法只能被实例对象调用,静态方法(由@staticmethod装饰的方法)、类方法(由@classmethod装饰的方法),可以被类或类的实例对象调用。

    实例方法,第一个参数必须要默认传实例对象,一般习惯用self。
    静态方法,参数没有要求。

    类方法,第一个参数必须要默认传类,一般习惯用cls。

    二、静态方法、类方法使用区别或者说使用场景

     

    1、类方法用在模拟java定义多个构造函数的情况。

     由于python类中只能有一个初始化方法,不能按照不同的情况初始化类。

    参考django https://docs.djangoproject.com/en/1.9/ref/models/instances/ 请看下面的代码。

    # coding:utf-8
    class Book(object):
    
        def __init__(self, title):
            self.title = title
    
        @classmethod
        def class_method_create(cls, title):
            book = cls(title=title)
            return book
    
        @staticmethod
        def static_method_create(title):
            book= Book(title)
            return book
    
    book1 = Book("use instance_method_create book instance")
    book2 = Book.class_method_create("use class_method_create book instance")
    book3 = Book.static_method_create("use static_method_create book instance")
    print(book1.title)
    print(book2.title)
    print(book3.title)

    结果:

    use instance_method_create book instance
    use class_method_create book instance
    use static_method_create book instance
    
    Process finished with exit code 0

    特别说明,静态方法也可以实现上面功能,当静态方法每次都要写上类的名字,不方便。

    2、类中静态方法方法调用静态方法和类方法调用静态方法例子。
    下面的代码,静态方法调用另一个静态方法,如果改用类方法调用静态方法,可以让cls代替类,

    让代码看起来精简一些。也防止类名修改了,不用在类定义中修改原来的类名。

    # coding:utf-8
    class Foo(object):
        X = 1
        Y = 2
    
        @staticmethod
        def averag(*mixes):
            return sum(mixes) / len(mixes)
    
        @staticmethod
        def static_method():  # 在静态方法中调用静态方法
            print "在静态方法中调用静态方法"
            return Foo.averag(Foo.X, Foo.Y)
    
        @classmethod
        def class_method(cls):  # 在类方法中使用静态方法
            print "在类方法中使用静态方法"
            return cls.averag(cls.X, cls.Y)
    
    foo = Foo()
    print(foo.static_method())
    print(foo.class_method())

    结果:

    在静态方法中调用静态方法
    1
    在类方法中使用静态方法
    1

    3、继承类中的区别 

    从下面代码可以看出,如果子类继承父类的方法,子类覆盖了父类的静态方法,
    子类的实例继承了父类的static_method静态方法,调用该方法,还是调用的父类的方法和类属性。

    子类的实例继承了父类的class_method类方法,调用该方法,调用的是子类的方法和子类的类属性。

    # coding:utf-8
    class Foo(object):
        X = 1
        Y = 14
    
        @staticmethod
        def averag(*mixes):  # "父类中的静态方法"
            return sum(mixes) / len(mixes)
    
        @staticmethod
        def static_method():  # "父类中的静态方法"
            print "父类中的静态方法"
            return Foo.averag(Foo.X, Foo.Y)
    
        @classmethod
        def class_method(cls):  # 父类中的类方法
            print "父类中的类方法"
            return cls.averag(cls.X, cls.Y)
    
    
    class Son(Foo):
        X = 3
        Y = 5
    
        @staticmethod
        def averag(*mixes):  # "子类中重载了父类的静态方法"
            print "子类中重载了父类的静态方法"
            print "666 ",mixes
            return sum(mixes) / 3
    
    p = Son()
    print "result of p.averag(1,5)"
    print (p.averag(1,5))
    print "result of p.static_method()"
    print(p.static_method())
    print "result of p.class_method()"
    print(p.class_method())

    结果如下:

    result of p.averag(1,5)
    子类中重载了父类的静态方法
    666  (1, 5)
    2
    result of p.static_method()
    父类中的静态方法
    7
    result of p.class_method()
    父类中的类方法
    子类中重载了父类的静态方法
    666  (3, 5)
    2

    Process finished with exit code 0

    参考网址:https://zhuanlan.zhihu.com/p/21101992

    展开全文
  • python类详解

    2020-05-10 17:44:45
    python(方法、静态方法、结构) 一、方法 方法:针对对象定义的方法 在方法内部可以直接访问属性或者调用其他的方法 属性:针对对象定义的属性 使用赋值语句在class关键字下可以定义属性 属性...

    python(类方法、静态方法、类结构)

    一、类方法
    类方法:针对类对象定义的方法 在类方法内部可以直接访问类属性或者调用其他的类方法
    类属性:针对类对象定义的属性 使用赋值语句在class关键字下可以定义类属性
    类属性用于记录与这个类相关的特性

    class Toy(object):
        # 1.使用赋值语句定义类属性,记录所有玩具的数量
        count = 0
        def __init__(self,name):
            self.name = name
            # 让类属性 +1
            Toy.count += 1
        @classmethod
        def show_toy_count(cls):
            print('玩具对象的数量 %d' %(cls.count))
    # 创建玩具对象
    toy1 = Toy('乐高')
    #toy2 = Toy('泰迪熊')
    # 调用类方法
    Toy.show_toy_count()
    

    二、静态方法
    静态方法:
    在开发中,如果需要在一个类中封装一个方法 这个方法
    既不需要访问实例属性或者调用实例方法
    也不需要访问类属性或者调用类方法
    这个时候,我们就可以把这个方法封装成一个镜头方法

    class Cat(object):
        @staticmethod
        def call():
            print('喵喵~')
    # 通过 类名. 调用静态方法
    Cat.call()
    

    不需要创建对象,直接就可以使用

    三、类的结构

    术语–实例
    1.使用面向对象开发,第一步是设计类

    2.使用 类名() 创建对象,创建对象的动作有两步
    (1)在内存中为对象分配空间
    (2)调用初始化方法__init___ 为对象初始化

    3.对象创建后,内存中就有了一个对象的实实在在的存在–实例
    因此:
    (1)创建出来的对象叫做类的实例
    (2)创建对象的动作叫做实例化
    (3)对象的属性叫做实例属性
    (4)对象调用的方法叫做实例方法

    在程序执行时:
    1.对象各自拥有自己的实例属性
    2.调用对象的方法,可以通过self
    访问自己的属性
    调用自己的方法

    结论:
    1.每一个对象都有自己独立的内存空间,保存各自不同的属性
    2.多个对象的方法,在内存中之有一份,在调用方法时,需要把对象的引用传递到方法内部

    Python类中调用内部方法的两种方式

    class std():
        def un1(self):
            print("sssd")
        def un2(self):
            std.un1(self) #①
    t = std()
    t.un2()
    

    输出结果:sssd
    在①处,我们调用的是非绑定类方法,但是我们是通过类访问的,非绑定类方法只有在对象实例传入时才会将self替换,而类并不会所以我们需要在调用时传入参数self(self在实例化类之后,就相当于对象实例了t了),所以un1有了参数,可以执行

    class std():
        def un1(self):
            print("sssd")
        def un2(self):
            self.un1()
    t = std()
    t.un2()
    

    输出结果:sssd
    这里就很好理解了,因为调用方法时会自动将对象作为参数传给方法(注意,无论目标方法是非绑定类方法还是绑定类方法都会传),所以当t传入un2时,替换掉了self,代码就可以理解为t.un1()了,就是一个un1的方法调用,这里将t作为参数传给了un1,有了参数,可以执行

    python实现类之间的方法互相调用

    all.py

    from son import *
    class ALL():
     def __init__(self):
      self.mSon = SON(self)
     def getAll(self):
      print "=================getall---------------"
      return self.mSon.getSon()
     def getAlltest(self):
      print "=================getAlltest---------------"
    Instance = ALL()
    Instance.getAll()
    

    son.py

    class SON():
     def __init__(self, instance):
     self.mBattle = instance
     def getSon(self):
     return self.mBattle.getAlltest()
    

    son.py和all.py在同一个文件夹下面,可以通过from son import *或者 import son 来互相调用。

    可以动态实例化son.py里面的SON类,而且也可以把ALL的实例通过参数传递给SON,从而调用ALL类的方法。

    python:类内变量

    • 类变量

    • 成员变量

    • 成员函数

    • 局部变量

    class A:
    	v1 = 100  # 类变量
    	def __init__(self):
    		self.v2 = 200 # 成员变量
    		v3 = 300 # 局部变量
    

    类变量可以由类名统一修改:

    A.v1 = 300
    # 则每一个A实例里v1都变成300
    

    成员变量只能由实例自己改变:

    A.v2 # 这个是错的。
    a = A()
    a.v2 # 这个是可以访问的。
    

    局部变量只在函数内部生效

    Python类变量和实例变量区别

    类变量:可在类的所有实例之间共享的值(也就是说,它们不是单独分配给每个实例的)。
    实例变量:实例化之后,每个实例单独拥有的变量。

    class student():
        age = 0
        name = 'stu'
        # age,name是类变量
        def __init__(self,age,name):
            self.age = age
            self.name = name
        # 访问实例变量(用self.age  self.name)
    

    student1 = student(18,‘hello’)
    print(student1.name)
    # 打印实例变量,输出hello
    print(student.name)
    # 打印类变量,输出stu

    在这里插入图片描述

    Python类的变量(类变量和实例对象变量)以某种方式在某地方被赋值,即存在,可被读写

    1. Python类变量被赋值
      (1)类的设计里,
      class里def外,通过变量名能被赋值
      def里通过类对象即类名字的点运算变量名可被赋值
      (2)程序里
      通过类对象(类名字)的点运算类名字也可被赋值
    2. Python实例对象变量被赋值
      (1)类的设计时
      def里通过self点运算变量名能被赋值,不一定非在init里,其他已被调用的方法函数里也行
      (2)程序里
      通过实例对象的点运算变量名可被赋值

    类变量和实例变量的区别在于:类变量是所有对象共有,其中一个对象将它值改变,其他对象得到的就是改变后的结果;而实例变量则属对象私有,某一个对象将其值改变,不影响其他对象

    展开全文
  • 主要介绍了python 类详解及实例的相关资料,需要的朋友可以参考下
  • 是面向对象编程的核心概念,面向对象程序设计是在面向过程程序设计的基础上发展而来的,它比面对过程编程具有更强的灵活性和扩展性。在此提醒初学者:想要在编程这条路上走的比别人远,就一定要掌握面向对象编程...
  • Python类详解

    万次阅读 多人点赞 2018-04-30 20:04:13
    :用来描述具有相同属性和方法的对象的集合 一 的命名方式 大驼峰 首字母大写 见名之意 区分大小写 实例 class Women: sex = '女' faceValue = "高" height = "168" weight...
  • python多线程详解(超详细)

    万次阅读 多人点赞 2020-03-30 09:13:40
    python中的多线程是一个非常重要的知识点,今天为大家对多线程进行详细的说明,代码中的注释有多线程的知识点还有测试用的实例。 import threading from threading import Lock... python多线程详解 什么是线程? ...
  • python类的调用方式详解

    万次阅读 2018-02-20 10:23:34
    python类的调用模式详解 这里简单的认为创建完对象,eat方法,drink方法就在对象中,其实根据了解,这些方法应该存在空间中,对象中保存了引用指向中的方法 (开始的教程也是这么说的:暂时认为存放在对象...
  • Python tkinter入门详解教程

    万次阅读 多人点赞 2019-09-14 16:21:47
    基于tkinter入门资料太少,特录制了这套入门详解课程,希望能帮助初学者快速掌握tkinter的基础知识和实战技巧,对于伸手党和资料收集党,做了一个门槛限制,希望大家理解 本课程涉及到tkinter的高级控件讲解,ttk...
  • Python之33个关键字详解

    万次阅读 多人点赞 2017-11-10 17:06:33
    关键字详解
  • Python3 list 排序函数详解

    万次阅读 2020-09-07 16:07:16
    Python3 list 排序函数详解 一、列表的sort排序函数 函数原型: list.sort(key=None,reverse=False) 函数功能: 对原列表进行排序,完成排序后,原列表变为有序列表。默认情况(不传入任何参数时)按字典顺序...
  • Python必学的OS模块详解

    万次阅读 多人点赞 2018-07-04 15:54:22
    面试经典题目:什么是os?第一个:系统操作import os print (os.sep) print (os.name) print (os.getenv('path')) print (os.getcwd())执行结果如下:第二个:目录操作-增删改查如图:输出当前的目录下的所有文件和...
  • python冒泡排序详解

    千次阅读 2018-09-04 20:09:32
    详解 比较相邻的两个元素,如果顺序有误则把他们交换位置. 原理:每一趟只能将一个数归位,如果有n个数进行排序,只需将n-1个数归位,也就是说要进行n-1趟,所以时间复杂度为O(n²). 代码 def bubbleSort(nums): ...
  • 我们不生产水,我们只做大自然的...超详细的解释,由浅入深,比廖雪峰那个教程要详细一些(不过峰哥整体教程还是挺好的,很适合入门,也适合我们回头复习Python),下面奉上超详细的Python装饰器解释,保证能看懂。 ...
  • Python-文件对象的newline参数详解

    万次阅读 2018-12-30 12:05:43
    Python-文件对象的newline参数详解 python open函数newline用法
  • [Python3]pandas.concat用法详解

    万次阅读 多人点赞 2019-06-06 08:41:34
    前面给大家分享了pandas.merge用法详解,这节分享pandas数据合并处理的姊妹篇,pandas.concat用法详解,参考利用Python进行数据分析与pandas官网进行整理。
  • Python3开发详解

    万人学习 2019-12-18 15:09:51
    Python3 开发详解,课程从基础的环境搭建讲起,详细讲述了Python开发的方方面面,内容包括:编程基础、函数、数据结构、异常处理、字符串、数字、网络编程、多线程、数据库处理等。
  • python递归函数的详解及案例

    万次阅读 2018-10-14 15:54:30
    1.递归函数的概念: 直接或间接的调用自身的函数,称为递归函数。 每调用一次自身,相当于复制一份该函数,只不过参数有变化,参数的变化,就是重要的结束条件 注意: 一定要注意结束条件。...
  • python使用setsockopt

    万次阅读 2013-07-11 17:55:29
    默认的socket选项不够用的时候,就必须要使用setsockopt来调整。就是使用setsockopt。 首先看一下socket的setsockopt 函数的定义: socket.setsockopt(level, optname, value) Set the value of the given socket ...
1 2 3 4 5 ... 20
收藏数 100,761
精华内容 40,304
关键字:

python类的详解