精华内容
下载资源
问答
  • Python 定义与使用

    千次阅读 2019-09-05 14:32:44
    变量:在整个实例化的对象中是公用的,变量定义中且在函数体之外,变量通常不作为实例变量使用 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的 覆盖(override)...

    2019-9-6Python类的定义与使用

    • 类:描述具有相同属性和方法的对象的集合
    • 类变量:在整个实例化的对象中是公用的,类变量定义在类中且在函数体之外,类变量通常不作为实例变量使用
    • 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的
    • 覆盖(override),也称为方法的重写
    • 局部变量:定义在方法中的变量,只作用于当前实例的类
    • 实例变量:在类的声明中,属性是用变量来表示的,是在类声明的内部但是在类的其他成员方法之外声明的
    • 继承:即一个派生类继承基类的字段和方法
    • 实例化:创建一个类的实例,类的具体对象
    • 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法

    1、类的定义
    语法:

    class <类名称>:
      ["文件字符串"] #类文档字符串
    <语句> #类体,由类成员、方法、数据属性组成
    
    class Car(object):  #定义一个类,派生自object类
      def infor(self): #定义成员方法
          print("This is a car")
    

    2、构造方法

    • 类的构造方法或初始化方法,当创建了这个类的实例时就会调用该方法
    • 实例化对象时时可以传入参数的,这些参数会自动传入_ init _()方法中,可以通过重写这个方法来定义对象的初始化操作
    • 定义构造方法时,self是必要的参数且为第一个参数
    • 若在Python中定义类时没有定义_init_()方法,则在实例化时系统会自动调用默认的构造方法(无参的_init_()方法)
    • 一个类中可以定义多个构造方法,但是实例化类时只会实例化最后的构造方法,即后面的构造方法会覆盖前面的构造方法,并且需要根据最后一个构造方法的形式进行实例化(参数与最后一个构造方法的参数一致),因此一个类中最好只定义一个构造方法
    • 初始化实例包括:定义和初始化实例属性或调用类的一些方法
      语法:
    def_init_(self):
      <语句>
    
    class Myclass:
       i=612
       def __init__(self,you):
          self.you=you
       def func(self,me):
          self.me=me
          return self.me+" like "+self.you
    user=Myclass("lion") 
    print("调用类的属性:",user.i) 
    print("调用类的方法:",user.func("monkey"))
    

    调用类的属性:612
    调用类的方法:monkey like lion

    分析这段代码,一开始看着有点打脑壳,跟Java面向对象类的定义存在很多不一样。在定义类中函数时,通常需要将函数的第一个参数定义成self,而self指向对象本身。下面一个例子

    class Breakfast:
      def set_name(self,name):
        self.name=name
      def get_name(self):
        return self.name
    a=Breakfast()
    b=Breakfast()
    a.set_name("milk")
    b.set_name("bread")
    print(a.get_name())
    print(b.get_name())
    

    milk
    bread

    对象a,b在分别调用set_name()和get_name()方法时,self分别指向了a,b,即对象自身。

    3、内置类属性
    ①_dict_:类的属性(包含一个字典,由类的数据属性组成)
    ②_doc_:类的文档字符串
    ③_name_:类名
    ④_module_:类定义所在的模块(类的全名称是’_ main _.className’,如果类位于一个导入模块mymod中,那么className._module _等于mymod)
    ⑤_bases _:类的所有父类构成元素(包含了由父类组成的元组)

    4、类的实例
    ①创建类实例

    car = Car() #实例化对象
    car.infor() #调用对象的成员方法
    //这里输出:This is a car
    

    ②内置函数isinstance()
    作用:测试一个对象是否为某个类的实例

    >>>isinstance(car,Car)
    True
    

    ③内置函数type()
    作用:查看对象类型

    >>>type(car)
    <class'_ _main_ _.Car'>
    
    展开全文
  • Python类定义使用

    万次阅读 多人点赞 2019-03-06 10:35:18
    为了代码的编写方便简洁,引入了定义; 一般,使用 class 语句来创建一个新,class之后为的名称(通常首字母大写)并以冒号结尾,例如: class Ticket(): def __init__(self,checi,fstation,tstation,fdate,...

    为了代码的编写方便简洁,引入了类的定义;
    一般,使用 class 语句来创建一个新类,class之后为类的名称(通常首字母大写)并以冒号结尾,例如:

    class Ticket():
        def __init__(self,checi,fstation,tstation,fdate,ftime,ttime):
            self.checi=checi
            self.fstation=fstation
            self.tstation=tstation
            self.fdate=fdate
            self.ftime=ftime
            self.ttime=ttime
        def printinfo(self):
            print("车次:",self.checi)
            print("出发站:", self.fstation)
            print("到达站:", self.tstation)
            print("出发时间:", self.fdate)
    

    #类中可以定义所使用的方法,类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self;
    #init()方法是一种特殊的方法,被称为类的初始化方法,当创建这个类的实例时就会调用该方法;
    #self 代表类的实例,self 在定义类的方法时是必须有的,虽然在调用时不必传入相应的参数;
    接下来是类的对象的创建:

    #创建a1对象
    a1=Ticket("G11","xian","beijing",'2019-01-20','13:00','18:00')
    #创建a2对象
    a2=Ticket("T11","xian","beijing",'2019-01-21','13:00','19:00')
    ``
    

    最后是对象属性的访问:

    a1.printinfo()
    a2.printinfo()
    

    输出结果如下:
    在这里插入图片描述
    现在,用类的方式爬虫12306的车站信息:

    import requests
    class Station():
        #__init__()方法是一种特殊的方法,被称为类的初始化方法,当创建这个类的实例时就会调用该方法
        # self 代表类的实例,self 在定义类的方法时是必须有的,虽然在调用时不必传入相应的参数
        def __init__(self,code,cn,qp,jp):
            self.code=code
            self.cn=cn
            self.qp=qp
            self.jp=jp
        #类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
        def printinfo(self):
            print(self.code,self.cn,self.jp,self.qp)
        #self代表类的实例,表示当前对象的地址  self.__class__ 则指向类
        def test(self):
            print(self)
            print(self.__class__)
    url="https://kyfw.12306.cn/otn/resources/js/framework/station_name.js?station_version=1.9077"
    #url='https://kyfw.lesson10_1.cn/otn/resources/js/framework/station_name.js?station_version=1.9090'
    html_text=requests.get(url).text
    infos=html_text[:-2].split("@")[1:]
    stations=[]
    
    for info in infos:
        station_list=info.split("|")
        #直接将类的对象添加到列表中,通过__init__()方法接受参数
        stations.append(Station(station_list[2],station_list[1],station_list[3],station_list[4]))
    #遍历列表,每个元素为类的一个对象
    for i in stations[:10]:
        i.printinfo()
        i.test()
    

    结果如下:
    在这里插入图片描述
    嗯嗯~~就这样啦!

    展开全文
  • Python__定义使用类

    万次阅读 多人点赞 2019-05-11 21:53:50
    由于 Python 对面向对象有着良好的支持,因此在 Python 中定义和使用类并不复杂。类的定义和使用跟函数的定义和使用有很多相似之处。 一、类的定义 在 Python 中,类的定义与函数的定义类似,所不同的是,类的...

     

    由于 Python 对面向对象有着良好的支持,因此在 Python 中定义和使用类并不复杂。类的定义和使用跟函数的定义和使用有很多相似之处。

    一、类的定义

    在 Python 中,类的定义与函数的定义类似,所不同的是,类的定义是使用关键字 "class"。与函数定义相同的是,在定义类时也要使用缩进的形式,以表示缩进的语句属于该类。类的定义形式如下。

    class <类名>:
        <语句1>
        <语句2>
        ...
        <语句3>

    与函数定义相同,在使用类之前必须先定义类。类的定义一般放在脚本的头部。在 Python 中也可以在 if 语句的分支或者函数定义中定义类。下面的代码定义了一个 human 类,并定义了相关的属性。

    class human:    # 定义 human 类
        age = 0     # 定义 age 属性
        sex = ''    # 定义 sex 属性
        height = 0  # 定义 height 属性
        weight = 0  # 定义 weight 属性
        name = ''   # 定义 name 属性

    类还可以通过继承的形式来进行定义。通过类继承来定义类的基本形式如下。

    class <类名>(父类名):
        <语句1>
        <语句2>
        ...
        <语句3>

    其中圆括号中的父类名就是要继承的类。以下所示的代码是通过继承 human 类来生成一个新类。

    class student(human):    # 通过继承 human 类创建 student 类
        school = ''          # 定义 weight 属性
        number = 0           # 定义 weight 属性
        grade = 0            # 定义 weight 属性

    上述通过 human 继承而来的 student 类,自动继承了 human 中的属性。同时在上面的代码中又为 student 类定义了其他的属性。

    类定义后就产生了一个名字空间,与函数类似。在类内部使用的属性,相当于函数中的变量名,还可以在类的外部继续使用。类的内部与函数的内部一样,相当于一个局部作用域。不同类的内部也可以使用相同的属性名。

    二、类的使用

    类在定义后必须先实例化才能使用。类的实例化与函数调用类似,只要使用类名加圆括号的形式就可以实例化一个类。

    类实例化后会生成一个对象。一个类可以实例化成多个对象,对象与对象之间并不会相互影响。类实例化后就可以使用其属性和方法等。下面的代码首先定义了一个 book 类,然后将其实例化。

    class book:  # 定义 book 类
        author = ''  # 定义 author 属性
        name = ''  # 定义 name 属性
        pages = 0  # 定义 pages 属性
        price = 0  # 定义 price 属性
        press = ''  # 定义 press 属性
    
    
    a = book()  # book 类实例化
    print(a)  # 查看对象 a
    print(a.author)  # 访问 author 属性
    print(a.pages)  # 访问 pages 属性
    print(a.price)  # 访问 price 属性
    
    a.author = 'Tutu'  # 设置 author 属性
    a.pages = 300  # 设置 pages 属性
    a.price = 25  # 设置 price 属性
    print(a.author)  # 重新访问 author 属性
    print(a.pages)  # 重新访问 pages 属性
    print(a.price)  # 重新访问 price 属性
    
    b = book()  # 将 book 类实例化生成 b 对象
    print(b.author)  # 访问 b 对象的 author 属性
    print(b.price)  # 访问 b 对象的 price 属性
    b.author = 'Butter'  # 设置 b 对象的 author 属性
    b.price = 15  # 设置 b 对象的 price 属性
    
    print(b.price)  # 访问 b 对象的 price 属性
    print(a.price)  # 访问 a 对象的 price 属性,没有发生改变
    print(b.author)  # 访问 b 对象的 author 属性
    print(a.author)  # 访问 a 对象的 author 属性,没有发生改变
    print(b.pages)  # 访问 b 对象的 pages 属性
    print(a.pages)  # 访问 a 对象的 pages 属性
    

    上面的脚本输出结果如下:

    上述例子只定义了类的属性,并在类实例化后重新设置其属性。从代码中可以看出,类的实例化相当于调用一个函数,这个函数就是类。函数返回一个类的实例对象,返回后的对象就具有了类所定义的属性。上述例子生成了两个 book 实例对象,设置其中一个对象的属性,并不会影响到另一个对象的属性,也就是说,这两个对象是相互独立的。

    在 Python 中需要注意的是,虽然类首先需要实例化,然后才能使用其属性。但实际上当创建一个类以后就可以通过该类名访问其属性。如果直接使用类名修改其属性,那么将影响已经通过该类实例化的其他对象。演示代码如下。

    class A:            # 定义类 A
        name = 'A'      # 定义属性 name 将其赋值为 'A'
        num = 2         # 定义 num 属性将其赋值为 2
    
    
    print(A.name)       # 直接使用类名访问类的属性
    print(A.num)        # 直接使用类名访问类的属性
    
    a = A()             # 生成 a 对象
    print(A.name)       # 查看 a 的 name 属性
    
    b = A()             # 生成 b 对象
    print(b.name)       # 查看 b 的 name 属性
    
    A.name = 'B'        # 使用类名修改 name 属性
    print(a.name)       # a 对象的 name 属性被修改
    print(b.name)       # b 对象的 name 属性也被修改
    

    每一次的 print 输出如下:

    展开全文
  • Python类定义变量实例变量

    千次阅读 2018-01-19 11:02:01
    学过JAVA或C++等语言的程序员再去学Python设计时感觉非常不适应,因为Python是在太自由了,让人无所适从,来python定义类时的变量来说,其定义方式、作用域、操作方法都上述两种语言有更大的可操作空间。...

    学过JAVA或C++等语言的程序员再去学Python类设计时感觉非常不适应,因为Python是在太自由了,让人无所适从,来python定义类时的变量来说,其定义方式、作用域、操作方法都与上述两种语言有更大的可操作空间。

    Python类中定义的变量分为类变量和实例变量(也叫成员变量、对象变量),类变量直接定义在类里面(不在函数里面),前面不会有一个self修饰;相反,实例变量大都定义在实例函数里面,通过“self.变量名”的方式进行定义。当然,也有例外,应该类变量和实例变量都可以在类定义之后在定义(这个功能让我目瞪口呆)。

    一、类变量及实例变量的定义

    先看看正常的:

    class Person():
        person = 'alive' #这是类变量
        def __init__(self,name ,age):
            self.name = name #这是实例变量
            self.age = age   #这是实例变量
            self.gender = '男' #这是实例变量
            #a = 456     #不能写这里,会出错
        place = ['地球','中国'] #这是类变量

    从上述代码也可以看出,Python定义类时,不对定义类变量与实例变量之间的顺序做出约束,也可以看出类变量不能定义在函数体里面。

    再来看看返厂的,也就是在类定义之后在定义变量:

    class Student():#创建一个空的类
        pass
    
    #Student
    s1 = Student()
    #为p1添加一个name属性
    s1.name = 'chb' #这个name属性是一个实例变量
    print(s1.name) #输出结果:chb
    #为Person类添加一个类变量
    Student.behavior = 'study' #这是一个类变量
    print(Student.behavior)#输出结果:study
    print(s1.behavior)#输出结果:study

    所以说,Python类的定义是很自由的,对于变量,既可以在定义类时定义,也可以在类定义完成之后定义。上述两块代码讲述了类变量和实例变量在定义上面的区别。下面说说类变量与实例变量在使用上的区别。

    二、类变量与实力变量的使用

    结合上述第一个代码块中定义的Person类进行说明。

    1. 类变量可以通过“类名.类变量名”、“实例名.类变量名”两种方式读取,即类和实例都能读取类变量。

    if __name__=="__main__":
        p = Person('chb' , 18)
        print(Person.person)#输出结果:alive
        print(p.person)     #输出结果:alive

    2实例变量只能通过“实例名.实例变量名”的方式访问,类无权访问实例名。

    if __name__=="__main__":
        p = Person('chb' , 18)
        print(p.name)#输出结果:chb
        print(Person.name)     #错误:AttributeError: type object 'Person' has no attribute 'name'

    3. “类名.类变量名”、“实例名.类变量名”访问的实际上是同一个命名空间的变量,所以类变量具有“一改全改”的特点。

    if __name__=="__main__":
        p = Person('chb' , 18)
        Person.person = 'die'
        print(p.person)#输出结果:die
        print(Person.person#输出结果:die

    4. 采用‘实例名.类变量名’的方式对类变量进行赋值时,若该类变量是可变数据类型,则可以成功赋值该类变量,否则会在该实例变量所在的名称空间中创建一个与该类变量同名的实例变量进行赋值,并不会对类变量进行赋值,此时也无法再通过‘实例名.类变量名’的方式读取该类变量。但若‘实例名.类变量名’赋值的是可变数据类型,则可以对类变量进行赋值操作。

    if __name__=="__main__":
        p = Person('chb' , 18)
        p.person = 'die'
        print(p.person)#输出结果:die
        print(p.__dict__)#输出结果:{'gender': '男', 'person': 'die', 'age': 18, 'name': 'chb'}
        print(Person.person#输出结果:alive
        p.place[1] = '北京'
        print(p.place)#输出结果:['北京' , '北京']
        print(Person.place)#输出结果:['北京' , '北京']

     

     

    展开全文
  • 定义 class MyClass(object): # object 为基类,可以是其他继承于 object 的基类,但继承基类不是必须的 # 可读可写属性 # 此处定义的属性既是实例属性又是属性, # 即可以通过访问也可以通过实例访问...
  • python中class 类定义与使用

    千次阅读 多人点赞 2020-02-02 19:40:08
    python中class 类定义与使用 在学习python这一部分也是非常常用的,的定义类似于函数却又不同于函数,class 定义一个, 后面的类别首字母推荐以大写的形式定义,比如Calculator. class可以先定义自己的属性...
  • Python定义与使用

    千次阅读 2019-05-14 16:08:55
    Python定义与使用 转自:https://www.cnblogs.com/chenxiaoyong/p/6279874.html 目标:  1.的定义  2.父类,子类定义,以及子类调用父类  3.的组合使用  4.内置功能 1.的定义 代码如下: ...
  • Python 定义类和属性

    千次阅读 2020-07-25 20:13:06
    类定义动物是自然界一个庞大的群体,下面演示使用OOP建模动物使用Python语言创建动物的基本语法如下,使用class关键字定义一个动物:classAnimal(): ...
  • PYTHON 类定义,属性,初始化

    千次阅读 2020-05-01 17:12:02
    文章目录PYTHON 类定义,属性,初始化类定义类的私有属性方法的初始化和析构初始...中可以定义使用的方法,的方法普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名...
  • Python定义类方法

    千次阅读 2019-07-31 22:29:40
    方法也分实例方法和方法, 属性类似 在class中定义的全部是实例方法,实例方法第一个参数 self 是实例本身。 在class中定义类方法,需要这么写: class Person(object): count = 0 @classmethod def how_many...
  • Python中函数和定义使用(1)

    千次阅读 2020-07-01 10:29:07
    Python中函数和定义使用 python 一个.py文件如何调用另一个.py文件中的和函数 在调用另一个函数或者时 ,为了区分调用哪个函数或者,需要在函数名后加点。 例如: 调用car中定义的函数get_descriptive...
  • Python中,定义类的关键字是

    千次阅读 2021-04-27 01:34:27
    Python中,定义类的关键字是答:class;劳动生产率分为:实物劳动生产率、工时劳动生产率、货币劳动生产率。答:正确总的来说,全球通用卡交易金额、交易笔数在近十年来,低于全球经济的增速答:错以下单词中的浊音...
  • python中怎么定义一个

    千次阅读 2020-12-28 20:21:23
    定义类,语法格式如下:class ClassName:...python使用class关键字来定义类的命名规则是每个单词的首字母都要大写。对象对象支持两种操作:属性引用和实例化。属性引用使用Python 中所有的属性引用一样...
  • 第7.10节 Python类中的实例变量定义与使用

    千次阅读 多人点赞 2019-06-14 19:02:35
    在前面章节已经引入介绍了变量和实例变量,体中定义的变量为变量,默认属于本身,实例变量是实例方法中定义的self对象的变量,对于每个实例都是独有数据,而变量是该所有实例共享的属性和方法。...
  • Python类定义

    千次阅读 2018-07-23 18:13:40
    变量通常不作为实例变量使用。 实例变量:定义在方法中的变量,只作用于当前实例的。 数据成员:变量或者实例变量用于处理及其实例对象的相关数据。 方法:定义的函数。在内...
  • Python类class的定义、属性及其实例化

    千次阅读 2019-08-10 11:42:47
    是某一具有通用特点的事务的统称 定义 的三要素是类名、属性、方法 (Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是的实例。 方法:中...
  • Python class定义类Python类定义(入门必读)

    千次阅读 多人点赞 2019-07-04 11:19:52
    在面向对象的程序设计过程中有两个重要概念:(class)和对象(object,也被称为实例,instance),其中...Python 定义类的简单语法如下: class 类名: 执行语句… 零个到多个变量… 零个到多个方法… ...
  • Q1:python函数里的数组如何在函数外调用出来使用返回值的方法有两种:可以直接把调用的函数作为变量使用可以用调用函数给一个变量赋值第一种情况见如下例子:l = [1,2,3,4,5]def add_element(list, element):list....
  • Python定义使用抽象及抽象方法
  • python-定义类的属性

    千次阅读 2019-01-12 16:06:50
    #conding: utf-8 #定义类的属性 class Programer(object): #定义了一个Programer hobby = "Play Computer" #直接在里面直接定义一个属性hobby def __init__(self, name, age, weight): #在...
  • python类的方法中定义函数

    千次阅读 2020-08-01 22:40:04
    代码: class A(): def run(self): ...注意中方法和普通函数的区别,python类的方法必须要带self参数,否则会报错xxx() takes 0 positional arguments but 1 was given,原因:Python定义.
  • python如何定义类

    千次阅读 2018-09-12 20:29:49
    注:文章内容有转载部分,侵权删   ...在内部,使用 def 关键字来定义一个方法,一般函数定义不同,方法必须包含参数 self, 且为第一个参数,self 代表的是的实例。 举例: class ...
  • Python中的定义和对象的创建

    万次阅读 多人点赞 2018-08-16 17:35:59
    1. :对一事物的描述,是抽象的、概念上的定义。比如做石膏像的模型 2.对象:实际存在的该事物的每个个体,因而也称实例(instance)。比如石膏像 二者的关系:对象是由派生的、创建的。一个可以创建无穷多...
  • Python中字典的定义与简单使用实例

    千次阅读 2017-02-13 08:35:19
    #coding=utf8 print ''' Python中的字典映射数据类型是由键值...Python中字典的值可以是任意类型的Python对象,字典元素用大括号{}包裹。 ''' dicDefine={ 'Name':'ewang', 'Age': 28, 'Sex': 'famale', 'BirthDay'
  • 1.如何定义类 模板:class 类名(继承):pass(属性、方法) 注意类名的命名中没有下划线,这一点和变量的命名不同 2.创建对象的过程称为实例化,把抽象的具体化 模板:对象名 (任意)= 类名(参数1、参数2…参数n...
  • Python 使用type来定义类

    千次阅读 2018-04-06 20:37:04
    我们先来看一张图仔细观察: 我们使用 class 定义了 Class,然后实例化给 cls 观察cls的类型,它的类型指向 Class 那么Class的类型指向谁呢?指向type仔细思考,会不会Class是由type来定义的呢?是的,其实Class...
  • Python定义类并创建实例(一)

    千次阅读 2019-07-23 15:19:54
    Python中,通过 class 关键字定义。以 Person 为例,定义一个Person如下: class Person(object): pass 类名以大写字母开头(如Person)并且如果有两个单词组成的类名,第二个单词的首字母也应该大写(如...
  • python需要定义变量吗

    千次阅读 2020-12-16 01:47:12
    python定义一个变量不需要声明,直接复制便可初始化一个变量1、变量声明声明变量的时候,直接使用例如a = 1这样的方式即可。既不用像js语言那样使用一个通用的var或者let之方式表示声明,也不需要像c++语言那样...
  • python 如何定义抽象和抽象方法

    千次阅读 2020-01-10 13:00:05
    文章目录(一)python 如何定义抽象和抽象方法(二)python中的多态(三)的组合 (一)python 如何定义抽象和抽象方法 在python 通过继承metaclass = ABCmeta来创建抽象,抽象是包含抽象方法的,...
  • Python 方法定义中下划线的使用

    千次阅读 2020-01-11 17:50:36
    __foo__: 定义的是特殊方法,一般是系统定义名字 ,如 __init__() 之的。 _foo: 以单下划线开头的表示的是 protected 类型的变量,即保护类型只能允许其本身子类进行访问,不能用于 from module import * __...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,100,608
精华内容 440,243
关键字:

python类的定义与使用

python 订阅
友情链接: li2016.rar