python 之 面向对象基础(定义类、创建对象,名称空间)

第七章面向对象

1、面向过程编程 核心是”过程“二字,过程指的是解决问题的步骤,即先干什么再干什么 基于该思想编写程序就好比在编写一条流水线,是一种机械式的思维方式

优点:复杂的问题流程化、进而简单化 ? 缺点:可扩展性差

2、面向对象 核心”对象“二字,对象指的是特征(变量)与技能(函数)的结合体,需要创造出一个个的具体存在的对象,程序的执行就是由对象直接交互完成

优点:可扩展性强 ? 缺点:编程的复杂度高于面向过程

7.1 类

7.11 定义类

1、类:对象是特征与技能的结合体,那类就是一系列对象相似的特征与技能的结合体

2、在现实世界中:一定先有对象,后来随着人类文明的发展总结出的类,对象是具体存在的,而类只是一种抽象概念

3、在程序中,务必保证:先定义类,后调用类来产生对象

class OldboyStudent:

    school="Oldboy"                      # 对象们相似的特征

    def learn(self):                     # 对象们相似的技能
        print(‘is learning...‘)

注意:在类定义阶段就会立刻执行类体代码,会产生类的名称空间,将执行类体代码过程中产生的名字存放于类的名称空间

如何查看:

print(OldboyStudent.__dict__)               # 查看类的名称空间,以字典形式显示
?
print(OldboyStudent.__dict__[‘school‘])      # Oldboy
print(OldboyStudent.school)                 # Oldboy
?
print(OldboyStudent.__dict__[‘learn‘])       #<function OldboyStudent.learn at 0x00000146F735BD90>
print(OldboyStudent.learn)                  #<function OldboyStudent.learn at 0x00000146F735BD90>
?
OldboyStudent.__dict__[‘learn‘](123)         # is learning...
OldboyStudent.learn(‘xxx‘)                  # is learning...
OldboyStudent.country=‘China‘               #增
OldboyStudent.school=‘偶的博爱‘              #改
del OldboyStudent.country                   #删
?
print(OldboyStudent.__dict__)

7.12 调用类产生对象

class OldboyStudent:
    school="Oldboy"                 # 用变量表示特征

    def __init__(self,name,age,sex): #self=stu1     name= "马冬梅"   age=18     sex="female"
        self.name=name              # stu1.name = "马冬梅"
        self.age=age                # stu1.age = 18
        self.sex=sex                # stu1.sex = "female"

    def learn(self):                #  用函数表示技能
        print(‘is learning...‘,self)
?
    def choose(self):
        print(‘choose course...‘)

调用类发生哪些事:

1、首先会产生一个空对象stu1 2、会自动触发类内部的__init__函数 3、然后将空对象stu1连同调用类时括号内的参数组成(stu1,"马冬梅",18,‘female‘),将这四个参数一起传给__init__函数

初始化创建对象过程中,设置对象特征

stu1=OldboyStudent("马冬梅",18,‘female‘)  # OldboyStudent.__init__(stu1,"马冬梅",18,‘female‘)
stu2=OldboyStudent("甜蜜蜜",21,‘male‘)    # OldboyStudent.__init__(stu2,"甜蜜蜜",21,‘male‘)
stu3=OldboyStudent("原石开",22,‘male‘)
print(stu1.name,stu1.age,stu1.sex)
print(stu2.name,stu2.age,stu2.sex)
print(stu3.name,stu3.age,stu3.sex)

初始化创建对象过程后,设置对象特征

stu1=OldboyStudent()
stu1.NAME=‘马冬梅‘
stu1.AGE=18
stu1.SEX="female"
?
print(stu1.NAME,stu1.school)

调用类---》产生类的对象,该对象也可以称为类的一个实例,调用类的过程也称为类的实例化

7.13 类名称空间和对象名称空间

#school=‘xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx‘
class OldboyStudent:
    #school=‘oldboy‘
    name=‘axaxaxaxxaaxs‘
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
stu1=OldboyStudent(‘李三胖‘,18,‘male‘) #OldboyStudent.__init__(stu1,‘李三胖‘,18,‘male‘)
print(stu1.name)                      #stu1对象的名称空间和类的名称空间都有name时优先自己的  #李三胖
print(stu1.school)                    #stu1对象的名称空间没有school时,到类的名称空间查找  oldboy
                                    #类的名称空间没有时报错

对象属性的查找顺序 : 先找对象自己的名称空间----》类的名称空间

7.14 绑定方法的特殊之处

class OldboyStudent:
    def learn(self):
        print(‘%s is learning‘ %self.name)

1.类内部定义的变量是给所有对象共享,所有对象指向的都是同一个内存地址

print(id(stu1.school))          #   2143429964384
print(id(stu2.school))          #   2143429964384
print(id(OldboyStudent.school))  #   2143429964384

2.类内部定义的函数,类可以使用,但类来用的时候就是一个普通函数,普通函数有几个参就传几个参数

print(OldboyStudent.learn)      #<function OldboyStudent.learn at 0x000001E46CA5CF28>
OldboyStudent.learn(stu1)       #李三胖 is learning

3.类内部定义的函数,其实是给对象使用的,而且是绑定给对象用,绑定给不同的对象就是不同的绑定方法,内存地址都不一样,但其实指向同一个功能

print(stu1.learn)#<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x000001FC28E2BB38>>
print(stu2.learn)#<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x000001FC28E2BB70>>

绑定方法的特殊之处在于

1、 绑定给谁就应该由谁来调用 2、谁来调用就会把谁当做第一个参数传入,但也可以有其他参数

stu1.learn()        # OldboyStudent.learn(stu1)         #李三胖 is learning
stu2.learn()        # OldboyStudent.learn(stu2)         #王大炮 is learning

7.15 创建对象计数器

class Foo:
    n=0
    def __init__(self):
        Foo.n+=1                # 不要写成 self.n+=1
obj1=Foo()
obj2=Foo()
obj3=Foo()
print(obj1.__dict__)        # {}
print(obj2.__dict__)        # {}
print(obj3.__dict__)        # {}
?
print(obj1.n)               # 3
print(obj2.n)               # 3
print(obj3.n)               # 3

原文地址:https://www.cnblogs.com/mylu/p/11104917.html

时间: 2024-11-05 12:29:37

python 之 面向对象基础(定义类、创建对象,名称空间)的相关文章

附录A培训实习生-面向对象基础(1):类和实例

对象是一个自包含的实体,用一组可识别的特性和行为来标识. 面向对象编程,Object-Oriented Programming,其实就是针对对象进行编程的意思. 类就是具有相同属性和功能的对象的抽象的集合. 在编程过程中注意: 第一,类名称首字母记着要大写.多个单词则各个首字母大写. 第二,对外公开的方法需要用public修饰符. 实例,就是一个真实的对象. 实例化就是创建对象的过程,使用new关键字来创建. 下面是一个例子: 这是一个类, 1 using System; 2 using Sys

C#语言基础-3 枚举和名称空间

1.枚举  枚举是用户定义的整数类型,在声明时指定该枚举类型的实例可以包含的一组可接受的值.  代码编译好之后,枚举就成为基本类型.  枚举继承于基类Sysytem.Enum的结构,表示可以对枚举调用方法.把枚举当做结构不会造成性能损失.  语法定义  enum 枚举名  {      枚举值   }  每个枚举值对应一个数字值,默认从0开始依次加1,如果其中某一个赋值后,后面的值在赋值的基础上依次加1.允许赋值为Int类型的数值,包含负整数.值允许重复  例如:需要使用周一到周日时,可以声明个

Python:面向对象基础

基本理论 什么是对象 万物皆对象 对象是具体的事物 拥有属性.行为 把许多零散的东西,封装成为一个整体 Python中一切东西都是对象,Python是一门特别彻底的面向对象编程语言(OOP) 其他编程语言很多还分基本类型和对象类型,而在python中,只有对象类型 面向过程 & 面向对象 两者都是解决问题的思路.思想,面向对象本身是面向过程的封装 面向过程:在解决问题的时候,关注的是解决问题的每一个过程(步骤) 按照步骤划分 摆一个任务,分解成具体的每一个步骤 面向对象:在解决问题的时候,关注的

python开发面向对象基础:人狗大战学面向对象

一,通过函数写人狗大战这个故事 1 #!/usr/bin/env python 2 #_*_coding:utf-8_*_ 3 4 #1.函数 人模子 5 def person(name,level,life_value): 6 p_dic = { 7 'name':name, 8 'level':level, 9 'life_value':life_value 10 } 11 return p_dic 12 joker = person('joker',100,4000) 13 14 #函数

波哥学JAVA,定义类 创建对象 实例化对象 属性 类调用属性或者方法

定义类 声明对象  创建对象 实例化对象 属性 对象调用属性或者方法 举例,下面定义类了一个类并声明属性,写了一个方法: 创建对象 实例化对象 属性 类调用属性或者方法

python开发面向对象基础:组合&amp;继承

一,组合 组合指的是,在一个类中以另外一个类的对象作为数据属性,称为类的组合      人类装备了武器类就是组合 1.圆环,将圆类实例后传给圆环类 1 #!/usr/bin/env python 2 #_*_coding:utf-8_*_ 3 4 #circle,圆类 5 from math import pi 6 class Circle: 7 def __init__(self,radius): 8 self.radius = radius 9 def perimeter(self): 10

2016/3/21 面向对象: ①定义类 ②实例化对象 ③$this关键字 ④构造函数 ⑤析构函数 ⑥封装 ⑦继承

一:定义类   二:实例化对象 1 //定义类 2 class Ren 3 { 4 var $name; 5 var $sex; 6 var $age; 7 8 function Say() 9 { 10 echo "{$this->name}在说话"; 11 } 12 } 13 //实例化对象 14 $Ren = new Ren(); 15 //调用对象的成员: 16 $Ren->name = "张三"; 17 $Ren->Say(); 显示结果

Python全栈之路----函数进阶----名称空间

又名name space,顾名思义就是存放名字的地方,存什么名字呢?举例说明,若变量x=1,1存放于内存中,那名字x存放在哪里呢?名称空间正是存放名字x与1绑定关系的=地方 名称空间共3种,分别如下 locals:是函数内的名称空间,包括局部变量和形参 globals:全局变量,函数定义所在模块的名称空间 builtins:内置模块的名称空间(Python解释器自带的内置模块) >>> x = 1 >>> locals() #处在该区域,打印该区域所有变量 {'__na

Python全栈__动态参数、名称空间、作用域、作用域链、加载顺序、函数的嵌套、global、nonlocal

1.动态参数 当实参数量与形参数量相等时,参数传递正常. def func1(a, b, c): pass func1(1, 2, 3) 当实参数量与形参数量不相等时,则会报错. def func1(a, b, c): pass func1(1, 2, 3, 4, 5, 6, 6) 用户传入到函数中的实参数量不确定时,或者为了以后扩展,此时要用到动态参数 *args  **kwargs(万能参数). 顺序: 位置参数,*args,默认参数,**kwargs 1.*args *args是接收的是所