0.目录

文章目录

0.目录
1. 面向对象概述（ObjectOriented, OO）
2. 类的基本实现
3. 关于self
4.类相关函数
5.类的成员描述符（属性）
6.类的内置属性
7.类的常用魔术方法
8.类和对象的三种方法
- 实例方法
- 静态方法
- 类方法
9. 抽象类
10.自定义类

面向对象概述（ObjectOriented, OO）
类的基本实现
关于self
类相关函数
类的成员描述符（属性）
类的内置属性
类的常用魔术方法
类和对象的三种方法
抽象类
10.自定义类

1. 面向对象概述（ObjectOriented, OO）

OOP思想
- 接触到任意一个任务，首先想到的是任务这个世界的构成，是由模型构成的
几个名词
- OO：面向对象
- OOA：面向对象的分析
- OOD：面向对象的设计
- OOI：面向对象的实现
- OOP：面向对象的编程
- OOA->OOD->OOI：面向对象的实现过程
类和对象的概念
- 类：抽象名词，代表一个集合，共性的事物
- 对象：具象的东西，单个个体
类跟对象的关系
- 一个具象，代表一类事物的某一个个体
- 一个是抽象，代表的是一大类事物
类中的内容，应该具有两个内容
- 表明事物的特征。叫做属性（变量）
- 表明事物功能或动作，称为成员方法（函数）

2. 类的基本实现

类的名字
- 遵守变量命名的规范
- 大驼峰（有一个或者多个单词构成，每个单词首字母大写，单词跟单词直接相连）
- 尽量避开跟系统命名相似的命名
如何声明一个类
- 必须用class关键字
- 类由属性和方法构成，其他不允许使用
- 成员属性定义可以直接使用变量赋值，如果没有值，允许使用None

class students（）mane="小明"age=20def hiprint(self) :return None

实例化类

  变量 = 类名()   # 实例化了一个对象小明 = students （）print（小明）

访问对象成员
- 使用点操作符
  obj.成员属性名称
  obj.成员方法
可以通过默认内置变量检查类和对象的所有成员
- 对象所有成员检查

# dict前后各有两个下划线obj.__dict__

类所有的成员

# dict前后各有两个下划线class_name.__dict__

# 定义一个空的类
class Student():# 必须使用pass占位pass# 定义一个对象
mingyue = Student()# 在定义一个类，用来描述听Python的学生
class PythonStudent():# 用None给不确定的值赋值name = Noneage = 18course = "Python"#  系统默认由一个self参数def doHomework(self):print("I 在做作业")# 推荐在函数末尾使用return语句return None# 实例化一个叫yueyue的学生，是一个具体的人
yueyue = PythonStudent()
print(yueyue.name)
print(yueyue.age)# 注意成员函数的调用没有传递进入参数
yueyue.doHomework()

# 成员查看
class student():name = 'dana'age = 18def say(self):print('不要惹老子')yueyue = student()
print(yueyue.name)
print(yueyue.__dict__)   ## 查看对象成员
print(student.__dict__)  ## 查看类成员
yueyue.say()>dana
>{}
>{'__module__': '__main__', 'name': 'dana', 'age': 18, 'say': <function student.say at 0x017578A0>, '__dict__': <attribute '__dict__' of 'student' objects>, '__weakref__': <attribute '__weakref__' of 'student' objects>, '__doc__': None}
>不要惹老子

3. 关于self

self在对象的方法中表示当前对象本身，如果通过对象调用一个方法，那么该对象会自动传入到当前方法
的第一个参数中
self并不是关键字，只是一个用于接受对象的普通参数，理论上可以用任何一个普通变量名代替
方法中有self形参的方法成为非绑定类的方法，可以通过对象访问，没有self的是绑定类的方法，只能通过类访问
使用类访问绑定类的方法时，如果类方法中需要访问当前类的成员，可以通过 __class__成员名来访问

## self 就是一个接受对象的普通参数
class Student():name = "dana"age = 18# 注意say的写法，参数由一个selfdef say(self):self.name = "aaaa"self.age = 200print("My name is {0}".format(self.name))print("My age is {0}".format(self.age))def sayAgain(s):## 这里用s代替selfprint("My name is {0}".format(s.name))print("My age is {0}".format(s.age))yueyue = Student()
yueyue.say()
yueyue.sayAgain()>My name is aaaaMy age is 200My name is aaaaMy age is 200

class Teacher():name = "dana"age = 19def say(self):self.name = "yaona"self.age = 17print("My name is {0}".format(self.name))# 调用类的成员变量需要用 __class__print("My age is {0}".format(__class__.age))def sayAgain():print(__class__.name)print(__class__.age)print('hello')t = Teacher()
t.say()
##　调用绑定类函数使用类名
Teacher.sayAgain()>My name is yaona
>My age is 19
>dana
>19
>hello

class student():name = 'dana'age = 18def say(self):self.name = 'nana'print('不要惹老子')yueyue = student()
print(yueyue.name)
print(yueyue.age)
print(yueyue.say())
>dana18不要惹老子None   ##None是函数执行的结果， 因为它没有return所以返回值是None

class A():name = " liuying"age = 18def __init__(self):self.name = "aaaa"self.age = 200def say(self):print(self.name)print(self.age)class B():name = "bbbb"age = 90a = A()
# 此时，系统会默认把a作为第一个参数传入函数
a.say()
#
# 此时，self被a替换
A.say(a)
# 同样可以把A作为参数传入
A.say(A)
#
# 此时，传入的是类实例B，因为B具有name和age属性，所以不会报错
A.say(B)
# 以上代码，利用了鸭子模型>aaaa
>200
>aaaa
>200
>liuying
>18
>bbbb
>90

4.类相关函数

issubclass:检测一个类是否是另一个类的子类
isinstance:检测一个对象是否是一个类的实例
hasattr:检测一个对象是否由成员xxx
getattr: get attribute
setattr: set attribute
delattr: delete attribute
dir: 获取对象的成员列表

案例

# getattr()/setattr()/delattr()/hasattr()class A():name = 'lili'age =18a = A()print(hasattr(a,'name'))    ## 判断a对象是否有name属性
print(hasattr(A,'name'))print(getattr(a,'name'))   ## 获取对象a的name属性值
setattr(a,'name','lucy')   ##设置那么的属性值为lucy
print(getattr(a,'name'))
delattr(A,'name')          ## 删除属性
print(getattr(A,'name','not found'))
delattr(a,'name')
print(getattr(a,'name','not found'))     ## 读取是否有属性name,没有则返回default值'not found'>True
>True
>lili
>lucy
>not found
>not found

5.类的成员描述符（属性）

描述符类
类的成员描述符是为了在类中对类的成员属性进行相关操作而创建的一种方式

get：获取属性的操作
set：修改或者添加属性操作
delete：删除属性的操作

如果想使用类的成员描述符，大概有三种方法

使用类实现描述器
使用属性修饰符
使用property函数
- property函数很简单
- property(fget, fset, fdel, doc)

案例参看notebook

无论哪种修饰符都是为了对成员属性进行相应的控制

类的方式：适合多个类中的多个属性共用用一个描述符
property：使用当前类中使用，可以控制一个类中多个属性
属性修饰符：使用于当前类中使用，控制一个类中的一个属性

# peroperty案例
# 定义一个Person类，具有name，age属性
# 对于任意输入的姓名，我们希望都用大写方式保存
# 年龄，我们希望内部统一用整数保存
# x = property(fget, fset, fdel, doc)
class Person():'''这是一个人，一个高尚的人，一个脱离了低级趣味的人 他还他妈的有属性 '''# 函数的名称可以任意def fget(self):return self._name * 2def fset(self, name):# 所有输入的姓名以大写形式保存self._name = name.upper()def fdel(self):self._name = "NoName"name = property(fget, fset, fdel, "对name进行下下操作啦")p1 = Person()
p1.name = "TuLing" ## 调用fset()
print(p1.name)            ## 调用fget()
print(p1.__dict__)        ## 获取类的成员组成
print(p1.__doc__)         ## 获取类的文档信息
print(Person.__name__)    ## 获取类的名称
print(Person.__bases__)   ## 获取所有父类>TULINGTULING
>{'_name': 'TULING'}
>这是一个人，一个高尚的人，一个脱离了低级趣味的人他还他妈的有属性>Person
>(<class 'object'>,)

6.类的内置属性

__dict__:以字典的方式显示类的成员组成
__doc__: 获取类的文档信息
__name__:获取类的名称，如果在模块中使用，获取模块的名称
__bases__: 获取某个类的所有父类，以元组的方式显示

7.类的常用魔术方法

魔术方法就是不需要人为调用的方法，基本是在特定的时刻自动触发
魔术方法的统一的特征，方法名被前后各两个下滑线包裹
操作类__init__: 构造函数，用于初始化一个类__new__: 对象实例化方法，此函数较特殊，一般不需要使用__call__: 对象当函数使用的时候触发__str__: 当对象被当做字符串使用的时候调用__repr__: 返回字符串，跟__str__具体区别请百度
描述符相关__set____get____delete__
属性操作相关__getattr__: 访问一个不存在的属性时触发__setattr__: 对成员属性进行设置的时候触发参数： self用来获取当前对象被设置的属性名称，以字符串形式出现需要对属性名称设置的值作用：进行属性设置的时候进行验证或者修改注意： 在该方法中不能对属性直接进行赋值操作，否则死循环参看案例
运算分类相关魔术方法__gt__: 进行大于判断的时候触发的函数参数：self第二个参数是第二个对象返回值可以是任意值，推荐返回布尔值

class Person():def __init__(self):print('直接被调用了')def __call__(self, *args, **kwargs):print('使用函数时被调用')def __str__(self):return "当对象被当做字符串使用的时候调用"
p = Person()
p()
print(p)
>直接被调用了
>使用函数时被调用
>当对象被当做字符串使用的时候调用# __gt__s
class Student():def __init__(self, name):self._name = namedef __gt__(self, obj):print("哈哈， {0} 会比 {1} 大吗？".format(self, obj))return self._name > obj._namestu1 = Student("one")
stu2 = Student("two")
print(stu1 > stu2)>哈哈， <__main__.Student object at 0x0000022B5112FEB8> 会比 <__main__.Student object at 0x0000022B51121A58> 大吗？
>False

8.类和对象的三种方法

实例方法

需要实例化对象才能使用的方法，使用过程中可能需要截止对象的其他对象的方法完成

静态方法

不需要实例化，通过类直接访问

类方法

不需要实例化

参看案例
三个方法具体区别自行百度

# 三种方法的案例
class Person:# 实例方法def eat(self):print(self)print("Eating.....")# 类方法# 类方法的第一个参数，一般命名为cls，区别于self  @classmethoddef play(cls):print(cls)print("Playing.....")# 静态方法# 不需要用第一个参数表示自身或者类  @staticmethoddef say():print("Saying....")yueyue = Person()# 实例方法
yueyue.eat()
# 类方法
Person.play()
yueyue.play()
# 静态方法
Person.say()
yueyue.say()
><__main__.Person object at 0x00000299FFF61B70>
>Eating.....
><class '__main__.Person'>Playing.....
><class '__main__.Person'>Playing.....
>Saying....
>Saying....
*********************************************# 属性的三种用法
# 1. 赋值
# 2. 读取
# 3. 删除
class A():def __init__(self):self.name = "haha"self.age = 18a = A()a.name = "Lili"
print(a.name)
del a.name
# print(a.name)    # 报错
>Lili# 类属性 property
# 对变量除了普通的三种操作，还想增加一些附加的操作，那么可以通过property完成
class A():def __init__(self):self.name = "haha"self.age = 18# 此功能，是对类变量进行读取操作的时候应该执行的函数功能def fget(self):print("我被读取了")return self.name# 模拟的是对变量进行写操作的时候执行的功能def fset(self, name):print("我被写入了，但是还可以左好多事情")self.name = "图灵学院：" + name# fdel模拟的是删除变量的时候进行的操作def fdel(self):pass# property的四个参数顺序是固定的# 第一个参数代表读取的时候需要调用的函数# 第二个参数代表写入的时候需要调用的函数# 第三个是删除name2 = property(fget, fset, fdel, "这是一个property的例子")a = A()
print(a.name)
print(a.name2)
>haha
>我被读取了haha

9. 抽象类

[抽象类]http://www.cnblogs.com/asaka/p/6758426.html

抽象方法：没有具体实现内容的方法成为抽象方法
抽象方法的主要意义是规范了子类的行为和接口
抽象类的使用需要借助abc模块
import abc
抽象类：包含抽象方法的类叫抽象类，通常成为ABC类

抽象类的使用
* 抽象类可以包含抽象方法，也可以包含具体方法
* 抽象类中可以有方法也可以有属性
* 抽象类只能被继承，不能被实例化，继承的子类必须实现所有继承来的抽象方法
* 假定子类没有是现实所有继承的抽象方法，则子类也不能实例化
* 抽象类的主要作用是设定类的标准，以便于开发的时候具有统一的规范

import abc
class All_file(metaclass=abc.ABCMeta):all_type = 'file'@abc.abstractmethod #定义抽象方法，无需实现功能def read(self):'子类必须定义读功能'pass@abc.abstractmethoddef write(self):'子类必须定义写功能'passclass Txt(All_file): #子类继承抽象类，但是必须定义read和write方法def read(self):print('文本数据的读取')def write(self):print('文本数据的读取方法')class Process(All_file):  # 子类继承抽象类，但是必须定义read和write方法def read(self):print('进程数据的读取方法')def write(self):print('进程数据的读取方法')wenbenwenjian=Txt()
wenbenwenjian.read()
jinchengwenjian=Process()
jinchengwenjian.read()print(wenbenwenjian.all_type)
print(jinchengwenjian.all_type)>文本数据的读取进程数据的读取方法filefile

10.自定义类

类其实是一个类定义和各种方法的自由组合
可以定义类和函数，然后自己通过类直接赋值
可以借助于MethodType实现
借助于type实现

元类：http://python.jobbole.com/88795/

利用元类实现MetaClass
- 元类是类
- 备用来创造别的类

# 函数名可以当变量使用
def Person(name):print('我的名字是%s'%name)Person('lili')s = Persons('lucy')>我的名字是lili我的名字是lucy# 自己组装一个类
class A():passdef say(self):print('saying......')A.say = say   ## 组装a = A()   ## 实例化
a.say()   ## 调用方法
>saying......
--------------------------------------------------------------------------
# 利用type造一个类# 先定义类应该具有的成员函数
def say(self):print('saying...')def eat(self):print('eating...')
#用type来创建一个类
A = type('name', (object,), {'class_say':say,'class_eat':eat})  ## 组装类A# 访问类
a = A()
a.class_say()
a.class_eat()>saying...eating...--------------------------------------------------------------------------
# 元类演示# 元类写法是固定的，必须继承自type,命名以MetaClass结尾
class AMetaClass(type):# 注意以下写法def __new__(cls, name, bases, attrs):# 自己的业务处理print("哈哈，我是元类呀")attrs['id'] = '000000'attrs['addr'] = "北京海淀区公主坟西翠路12号"return type.__new__(cls, name, bases, attrs)# 元类定义完就可以使用，使用注意写法
class Teacher(object, metaclass=AMetaClass):passt = Teacher()
>哈哈，我是元类呀

python学习——oop-python面向对象,类相关基础相关推荐

python教程400集笔记,Python学习中的笔记--集合相关，python笔记--集合
Python学习中的笔记--集合相关,python笔记--集合集合的基本操作一.可修改的集合set 创建集合 var = set() var = {'a','b','c','d'} 成员检测 va ...
菜菜的Python学习日记 | Python类实验代码分享
系列索引:菜菜的Python学习日记 | Python从入门到入土详解 Python类实验代码分享编写程序,实现以下功能. (1)创建员工类Employee,属性有姓名name.能力值ability ...
Python学习-01（其实是Linus基础）
Python学习-01(其实是Linus基础) 1.操作系统(Operation System) ##1.1操作系统的作用 1. 直接操作计算机硬件(用来管理硬件设备) 2. 把操作硬件的代码封装成一 ...
深圳Python学习：Python几大问，你想知道的答案都在这里！-千锋
深圳Python学习:Python几大问,你想知道的答案都在这里!-千锋人们为什么使用Python? 之所以选择Python的主要因素有以下几个方面: 软件质量:在很大程度上,Python更注重可读 ...
视频教程-爬虫微课5小时 Python学习路线-Python
爬虫微课5小时 Python学习路线十多年的Java和大数据开发和培训,精通Hadoop.Spark和Android开发,对于数据分析和挖掘有比较深的研究.曾在公司独立开发O2O项目e小时.网店项目 ...
Python 学习 02 —— Python如何爬取数据
文章目录系列文章二.Python 爬虫 1.任务介绍 2.简介 3.基本流程 3.1.准备工作 3.1.1.分析页面 3.1.2.编码规范 3.1.3.导入模块 3.1.4.程序流程 3.2.获 ...
python爬虫原理-python学习之python爬虫原理
原标题:python学习之python爬虫原理今天我们要向大家详细解说python爬虫原理,什么是python爬虫,python爬虫工作的基本流程是什么等内容,希望对这正在进行python爬虫学习的 ...
Python学习之Python软件安装教程
Python学习之Python软件安装教程 Python学习之Python软件安装教程
Python学习笔记：面向对象编程（2）
前言最近在学习深度学习,已经跑出了几个模型,但Pyhton的基础不够扎实,因此,开始补习Python了,大家都推荐廖雪峰的课程,因此,开始了学习,但光学有没有用,还要和大家讨论一下,因此,写下这些帖 ...

python学习——oop-python面向对象,类相关基础