一  什么是面向对象,面向对象与类的关系。

  面向对象的程序设计是用来解决扩展性。

  面向过程:根据业务逻辑从上到下写垒代码

  函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可

  面向对象:对函数进行分类和封装,让开发“更快更好更强...”

  简单的来说,如果程序的功能都是由类和对象来实现的,那么就是面向对象编程了。

二 对象与类的关系

  对象是特征与技能的结合体。

  类是一系列对象共同的特征与技能的结合体。

三 类的基本格式

class People:
def __init__(self):
pass
def foo(self):
pass
def bar(self):
pass

  这就定义了一个People类。

四 类的说明

  1.类的定义:关键字 class

  2 实例化:类名+( ),产生一个类的对象或实例。

class People:
def __init__(self):
pass
def foo(self):
pass
def bar(self):
pass p=People()
print(p)

  输出:

<__main__.People object at 0x000001E03DA36F60>

  3 实例化本质,调用__init__函数。

class People:
def __init__(self,name):
pass
def foo(self):
pass
def bar(self):
pass p=People()
print(p)

  输出:

TypeError: __init__() missing 1 required positional argument: 'name'

  因为实际是调用__init__函数,有一个name参数,需要传参。

  传一个参数就ok了

class People:
def __init__(self,name):
pass
def foo(self):
pass
def bar(self):
pass p=People('egon')
print(p)

  4 类的作用

    1 实例化

    2 属性引用 __dict__方法。

五 类与对象的namespace

  1 namespace用__dict__方法。

     是字典格式

class People:
def __init__(self,name):
self.name=name
def foo(self):
pass
def bar(self):
pass p1=People('egon')
print(People.__dict__)

  输出:

{'__module__': '__main__', '__init__': <function People.__init__ at 0x000001E933F0ABF8>, 'foo': <function People.foo at 0x000001E933F0AF28>, 'bar': <function People.bar at 0x000001E933F26048>, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}

  类的名称空间内有很多,定义的foo,bar函数,包括__init__初始化函数。

  对象的namespace

class People:
model='person'
def __init__(self,name):
self.name=name
def foo(self):
pass
def bar(self):
pass p1=People('egon')
print(p1.__dict__)

  输出:

{'name': 'egon'}

  对象的本身并没有动态属性(函数属性),也没有静态属性(类的数据属性),对于这两个,只有绑定关系。  对象只有属于自己的静态属性,即__init__函数初始化的数据。

  总结:类有属于自己的名称空间,每一个生成的对象也都有属于自己的名称空间。类的名称空间里有各种动态属性,静态属性,而对象的名称空间只有属于它自己的静态属性。

     对象的名称空间在类的名称空间之下。对象找不到的静态属性或者动态属性可以去类的名称空间中寻找。

     对象与类的静态属性和动态属性的关系是绑定关系。 详见第六条

  2  类和对象的名称空间都是字典,所以可以对字典进行增删改查。

    1 增

class People:
model='person'
def __init__(self,name):
self.name=name
def foo(self):
pass
def bar(self):
pass p1=People('egon')
print(p1.__dict__)
p1.age=35
print(p1.__dict__)

  输出:

{'name': 'egon'}
{'name': 'egon', 'age': 35}

    2 改

class People:
model='person'
def __init__(self,name):
self.name=name
def foo(self):
pass
def bar(self):
pass p1=People('egon')
print(p1.__dict__)
p1.name='alex'
print(p1.__dict__)

  输出:

{'name': 'egon'}
{'name': 'alex'}

六 对象与类的动态属性和静态属性的关系。

  1 动态属性

class People:
model='person'
def __init__(self,name):
self.name=name
def foo(self):
pass
def bar(self):
pass p1=People('egon')
print('对象调用foo时地址',p1.foo)
print('类调用foo时地址 ',People.foo)

  输出:

对象调用foo时地址 <bound method People.foo of <__main__.People object at 0x000001E5343EEBE0>>
类调用foo时地址 <function People.foo at 0x000001E5343EAF28>

  可以看到类调用函数时 是正儿八经的函数地址,所以需要正常传值,一个参数都不能少,少了就会报错。

  对象调用函数时,对象与函数的关系是绑定关系,实现了自动传值。谁调用,就将这个对象自动传给函数的第一个参数。

  2静态属性

    首先强调的一点是:类的静态属性对象一般不要调用。

    类的静态属性是不可变类型时。

class People:
x=1
def __init__(self,name):
self.name=name
def foo(self):
pass
def bar(self):
pass p1=People('egon')
p1.x=2
print('p1.x:',p1.x,id(p1.x))
print('People.x:',People.x,id(People.x))

  输出:

p1.x: 2 1980286672
People.x: 1 1980286640

    实际上相当去p1在自己的名称空间内新建了一个x的变量。对类的名称空间内的x 完全不一样。

  

    类的静态属性是可变类型是,对象就能够直接调用了。

class People:
l=[1]
def __init__(self,name):
self.name=name
def foo(self):
pass
def bar(self):
pass p1=People('egon')
p1.l.append(2)
print('p1.l:',p1.l,id(p1.l))
print('People.l:',People.l,id(People.l))

  输出:

p1.l: [1, 2] 2917779341960
People.l: [1, 2] 2917779341960

七 类与基本数据类型的关系。

class People:
def __init__(self,name):
self.name=name
def foo(self):
pass
p1=People('egon')
print(type(p1))
print(People) print(int)
print(type(1)) print(str)
print(type(''))

  输出:

<class '__main__.People'>
<class '__main__.People'>
<class 'int'>
<class 'int'>
<class 'str'>
<class 'str'>

  之前学的剧本数据类型就是本质上就是和现在学习的类是一样的。在python3中统一起来的。

  现在再来回顾基本数据类型的用法。

l1=[1,2,3]
l2=list([1,2,3])
print(l1)
print(l2)

  l2就是类的实例化过程。 类名+ ( 传参) 。

  举个例子:列表的追加

l1=[1,2,3]
l2=list([1,2,3])
l1.append(4)
list.append(l2,4)
print(l1,l1.append)
print(l2,list.append)

  输出:

[1, 2, 3, 4] <built-in method append of list object at 0x000001B553228288>
[1, 2, 3, 4] <method 'append' of 'list' objects>

分析:l1 就是作为列表list的一个对象,调用列表的动态属性(函数属性),自动传值。

     l2是类调用动态属性,没有自动传值,必须手动传值。

       两者实现了同样的效果。

八 对象的属性

  1 一开始,通过__init__方法初始化而来的

  2 在类内调用对象的属性, self.属性名

  3 在类外调用对象的属性,对象名.属性名

九 举例

  __init__的作用,在实例化的时候就已经生效了。

class Father:
def __init__(self):
self.name='bb'
def say(self):
print('from bb',self.name)
class Mother:
def __init__(self):
self.name='mm'
def talk(self):
print('from mm',self.name)
class Son(Father,Mother):
pass s=Son()
s.talk()

  输出:

from mm bb

  这个例子说明:

    实例化,先执行__init__方法,以此从自己的,父类的, 多个父类时顺序找第一个有__init__方法的父类。走到这一步时,如果能找到__init__,对象已经有了自己的名称空间,如果都没有那就没有自己的名称空间。

    对象调用方法,如果自己名称空间内有,先从自己名称空间内找。

    厉害了,这个例子。

python 面向对象与类的基本知识的更多相关文章

  1. Python 面向对象之一 类与属性

    Python 面向对象之 类与属性 今天接触了一下面向对象,发现面向对象和之前理解的简直就是天壤之别,在学Linux的时候,一切皆文件,现在学面向对象了,so,一切皆对象. 之前不是一直在学的用面向函 ...

  2. Python面向对象02/类的空间问题、类与对象之间的关系、类与类之间的关系

    Python面向对象02/类的空间问题.类与对象之间的关系.类与类之间的关系 目录 Python面向对象02/类的空间问题.类与对象之间的关系.类与类之间的关系 1. 类的空间问题 2. 类与对象之间 ...

  3. python 面向对象和类成员和异常处理

    python 面向对象 你把自己想象成一个上帝,你要创造一个星球,首先你要把它揉成一个个球,两个直径就能创造一个球 class star: '''名字(name),赤道直径(equatorial di ...

  4. python面向对象(二)——类成员

    Python面向对象    类成员 1.字段         普通字段    属于对象         静态字段    属于类   2.方法 普通方法   触发者是对象    括号里至少一个参数 se ...

  5. python 面向对象(类)--学习笔记

    面向对象是一种编程方式, 主要集中在类和对象的两个概念 python 中的类符合封装, 继承, 多态的特征 类 是一个模板, 是n多函数的集成 对象 是类的实例化 类的成员分为三大类:字段.方法.属性 ...

  6. Python面向对象编程 -- 类和实例、访问限制

    面向对象编程 Object Oriented Programming,简称OOP,是一种程序设计思想.OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数. 面向过程的程序设计把计算机程 ...

  7. Python面向对象编程-类的封装,继承、多态

    面向对象是一种程序设计思想,对象作为程序基本单元,包含了数据和操作数据的函数. 面向对象的三大特点--数据封装.多态和继承. #类的创建,class关键字,类名大写,object表示从哪个类继承而来, ...

  8. python 面向对象(类的成员,属性,绑定和非绑定,)

    面向对象是一种编程方式,此编程方式的实现是基于对 类 和 对象 的使用 类 是一个模板,模板中包装了多个“函数”供使用(可以讲多函数中公用的变量封装到对象中) 对象,根据模板创建的实例(即:对象),实 ...

  9. Python 面向对象(创建类和对象,面向对象的三大特性是指:封装、继承和多态,多态性)

    概念:                                                                                                 ...

随机推荐

  1. PAT (Basic Level) Practise (中文)- 1011. A+B和C (15)

    http://www.patest.cn/contests/pat-b-practise/1011 给定区间[-231, 231]内的3个整数A.B和C,请判断A+B是否大于C. 输入格式: 输入第1 ...

  2. c#自定义类型之间的转换(强制类型转换)

    public class ResultModel { public string PlateNumber { get; set; } public int PlateColor { get; set; ...

  3. java,求1-100以内所有偶数的和。

    package study01; public class Even { public static void main(String[] args) { int sum = 0; for (int ...

  4. 使用 CFile 的子类 CStdioFile 的注意事项

    目前为止只用到了 ReadString,也了解了一下 WriteString. 由于程序需要,本来程序中是用的CFile, 但是需要逐行读取文件数据,所以谷歌找到了 ReadString 类 —— 继 ...

  5. 04Windows中的字符类型

    1. Windows 中常用的数据类型定义 //WinNt.h中定义 typedef unsigned short wchar_t; //A 16-bit character typedef char ...

  6. 第6章 AOP与全局异常处理6.5-6.11 慕课网微信小程序开发学习笔记

    https://coding.imooc.com/learn/list/97.html 目录: 第6章 AOP与全局异常处理6-1 正确理解异常处理流程 13:236-2 固有的处理异常的思维模式与流 ...

  7. yagmail 邮箱的使用

    文章来源:GITHub:https://github.com/kootenpv/yagmail 安装 pip3 install yagmail pip3 install keyring 简单例子 im ...

  8. Python 简单购物程序

    # Author:Eric Zhao# -*- coding:utf-8 -*-'''需求:启动程序后,让用户输入工资,然后打印商品列表允许用户根据商品编号购买商品用户选择商品后,检测余额是否够,够就 ...

  9. python中文件操作的六种模式及对文件某一行进行修改的方法

    一.python中文件操作的六种模式分为:r,w,a,r+,w+,a+ r叫做只读模式,只可以读取,不可以写入 w叫做写入模式,只可以写入,不可以读取 a叫做追加写入模式,只可以在末尾追加内容,不可以 ...

  10. R-data.table

    data.table可以扩展和增强data.frame的功能,在分组操作和组合时访问速度更快. require(data.table) theDT = data.table(A=1:10, B=let ...