python学习——oop-python面向对象,类相关基础_hiprint 函数怎么写-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_46554863/article/details/105928937

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=20
  
  def hi
    print(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 = None
  age = 18
  course = "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 = 18

  def 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的写法，参数由一个self
    def say(self):
        self.name = "aaaa"
        self.age = 200
        print("My name is {0}".format(self.name))
        print("My age is {0}".format(self.age))

    def sayAgain(s):
        ## 这里用s代替self
        print("My name is {0}".format(s.name))
        print("My age is {0}".format(s.age))

yueyue = Student()
yueyue.say()
yueyue.sayAgain()

>My name is aaaa
 My age is 200
 My name is aaaa
 My age is 200

class Teacher():
    name = "dana"
    age = 19

    def say(self):
        self.name = "yaona"
        self.age = 17
        print("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 = 18

    def say(self):
        self.name = 'nana'
        print('不要惹老子')

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

class A():
    name = " liuying"
    age = 18

    def __init__(self):
        self.name = "aaaa"
        self.age = 200

    def say(self):
        print(self.name)
        print(self.age)

class B():
    name = "bbbb"
    age = 90

a = 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 =18

a = 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 * 2

  def 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 = name

    def __gt__(self, obj):
        print("哈哈， {0} 会比 {1} 大吗？".format(self, obj))
        return self._name > obj._name

stu1 = 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  @classmethod
  def play(cls):
        print(cls)
        print("Playing.....")

    # 静态方法
 # 不需要用第一个参数表示自身或者类  @staticmethod
  def 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 = 18

a = 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.abstractmethod
  def write(self):
        '子类必须定义写功能'
  pass

class 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)

>文本数据的读取
 进程数据的读取方法
 file
 file

10.自定义类

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

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

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

# 函数名可以当变量使用
def Person(name):
    print('我的名字是%s'%name)


Person('lili')

s = Person

s('lucy')

>我的名字是lili
 我的名字是lucy


# 自己组装一个类
class A():
    pass

def 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):
    pass


t = Teacher()
>哈哈，我是元类呀