1面向对象基本用法

1.1基本格式

  1. class 类名:
  2. def __init__(self,x):
  3. self.x = x
  4. def 方法名字 (self): #函数在类里称为方法,self就是固定参数,必须写self
  5. print('方法')
  6. return
  7. def 方法名字 (self):
  8. print('方法')
  9. return
  10. #实例化一个类的对象
  11. v1 = 类(可以传参)
  12. v2.方法()
  • 单例模式: 无论实例化多少次,都用第一次实例化的对象.

  • 标准格式

    • __new__创建一个实例化对象,并且在init之前执行
    1. class Singleton(object):
    2. instance= None
    3. def __new__ (cls,*args,**kwargs):
    4. if not cls.instance:
    5. cls.instance= object.__new__(cls)
    6. return cls.instance

1.2调用方法

  1. 创建类的对象(实例化对象)

    obj=类名() #创建了一个Account类的对象

  2. 使用对象调用类的方法

    obj.函数名字()调用时方法是有返回值的,与函数类似

  • 应用场景:
  1. - 函数(业务功能)比较多,可以使用面向对象来进行归类。
  2. - 想要做数据封装(创建字典存储数据时,面向对象)。
  3. - 游戏示例:创建一些角色并且根据角色需要再创建人物。

1.3对象的作用

  • 存储一些值,方便自己使用

    1. class file:
    2. def read(self):
    3. with open(self.xxx, mode='mode='r', encoding='utf-8') as f:
    4. data = f.read()
    5. return data
    6. def write(self,content):
    7. with open(self.xxx, mode='mode='a', encoding='utf-8') as f:
    8. f.write(content)
    9. # 实例化一个file的对象
    10. v1 = file()
    11. # 在对象中写了一个xxx='test.log'
    12. v1.xxx = 'test.log'
    13. # 通过对象调用类中的read方法,read方法中的self就v1:
    14. #v1.read()
    15. obj1.write('alex')

1.4类的初始化方法

  • 类() 实例化对象,自动执行此类中的 __ init __方法。
  • __ init __ 初始化方法(构造方法),为对象内部做初始化
  • 如果有一个反复使用的公共值,课可以放到对象中
  1. class Person:
  2. def __init__ (self,n,a,g):
  3. self.name=n
  4. self.age =a
  5. self.gender= g
  6. def show(self):
  7. temp= '我是%s,今年%s,性别%s'%(self.name,self.age,self.gender)
  8. print(temp)
  9. # 类() 实例化对象,自动执行此类中的 __init__方法。
  10. p1 = Person('bigox',20,'男')
  11. p1 = show()

2.面向对象的三大特性

2.1封装

  1. class File:
  2. def read(self):
  3. pass
  4. def write(self):
  5. pass
  1. class Person:
  2. def __init__(sef,name,age):
  3. self.name = name
  4. self.age = age
  5. p = Person('alex',19)

2.2继承

  1. #基本格式
  2. class Base:
  3. pass
  4. class Foo(Base):
  5. pass
  • 在多个类中如果有公共的方法,可以使用继承,增加代码的重用性.

  • 继承关系中查找方法的顺序

    • self是谁?
    • self是哪个类创建的,就从此类开始找,自己没有就找父类
  • 多继承就从左往右

    1. # 父类(基类)
    2. class Base:
    3. def f1(self):
    4. pass
    5. # 子类(派生类)
    6. class Foo(Base):
    7. def f2(self):
    8. pass
    9. # 创建了一个字类的对象
    10. obj = Foo()
    11. # 执行对象.方法时,优先在自己的类中找,如果没有就是父类中找。
    12. obj.f2()
    13. obj.f1()
    14. # 创建了一个父类的对象
    15. obj = Base()
    16. obj.f1()
  • 继承扩展

    • 单继承 :字类可以使用父类的方法
    • 多继承: 查找顺序
      • 深度优先: 对每一个可能的分支路径深入到不能再深入为止,而且每个结点只能访问一次。
      • 广度优先:从上往下对每一层依次访问,在每一层中,从左往右(也可以从右往左)访问结点,访问完一层就进入下一层,直到没有结点可以访问为止。
    1. # 新式类和经典类
    2. # py2 继承object就是新式类
    3. # 默认是经典类
    4. # py3 都是新式类,默认继承object
    5. # 新式类
    6. # 继承object
    7. # 支持super
    8. # 多继承 广度优先C3算法
    9. # mro方法
    10. # 经典类
    11. # py2中不继承object
    12. # 没有super语法
    13. # 多继承 深度优先
    14. # 没有mro方法

2.3多态

  • 一个类表现出来的多种状态 --> 多个类表现出相似的状态
  1. #经典例题题,什么是鸭子模型
  2. 对于一个函数,python对于参数的类型不会限制,传入参数时就可以是各种类型,但是在函数中如果有类似于索引等特有方法,就会对传入的参数类型有一个限制(类似于字符串的.append.send方法)
  3. 类似于上述的函数我们认为只要能呱呱叫的就是鸭子(只要有.send方法,就是我们要想的类型)
  4. # Python
  5. def func(arg):
  6. v = arg[-1] # arg.append(9)
  7. print(v)
  8. # java
  9. def func(str arg):
  10. v = arg[-1]
  11. print(v)

3面向对象成员

=成员

  • 类成员

    • 类变量
    • 绑定方法
    • 类方法
    • 静态方法
    • 属性
  • 实例成员(对象)
    • 实例变量

3.1实例变量

  • 类实例化后的对象内部的变量

3.2类变量

  • 类中的变量,写在类的下一级和方法同一级。

  • 访问方法:

    • 类.类变量名称(推荐)
    • 对象.类变量名称
  • 经典例题:

    • 总结:找变量优先找自己,自己没有找 类 或 基类;修改或赋值只能在自己的内部设置。
    1. class Base:
    2. x = 1
    3. obj = Base()
    4. print(obj.x) # 先去对象中找,没有再去类中找。
    5. obj.y = 123 # 在对象中添加了一个y=123的变量。
    6. print(obj.y)
    7. obj.x = 123
    8. print(obj.x)
    9. print(Base.x)

3.3绑定方法/普通方法

  • 定义:至少有一个self参数

  • 执行:先创建对象,由对象.方法()。

    1. class Foo:
    2. def func(self,a,b):
    3. print(a,b)
    4. obj = Foo()
    5. obj.func(1,2)
    6. # ###########################
    7. class Foo:
    8. def __init__(self):
    9. self.name = 123
    10. def func(self, a, b):
    11. print(self.name, a, b)
    12. obj = Foo()
    13. obj.func(1, 2)

3.4静态方法

  • 定义:

    • @staticmethod装饰器
    • 参数无限制
  • 调用:
    • 类.静态方法名()
    • 对象.静态方法名()不推荐
  • 在方法不进行传参时使用
  1. class Foo:
  2. def __init__(self):
  3. self.name = 123
  4. def func(self, a, b):
  5. print(self.name, a, b)
  6. @staticmethod
  7. def f1():
  8. print(123)
  9. obj = Foo()
  10. obj.func(1, 2)
  11. Foo.f1()
  12. obj.f1() # 不推荐

3.5类方法

  • 定义:

    • @classmethod装饰器
    • 至少有cls一个参数,当前类
  • 执行

    • .方法()
    • 对象.类方法()不推荐
    1. class Foo:
    2. def __init__(self):
    3. self.name = 123
    4. def func(self, a, b):
    5. print(self.name, a, b)
    6. @staticmethod
    7. def f1():
    8. print(123)
    9. @classmethod
    10. def f2(cls,a,b):
    11. print('cls是当前类',cls)
    12. print(a,b)
    13. obj = Foo()
    14. obj.func(1, 2)
    15. Foo.f1()
    16. Foo.f2(1,2)
  • 经典例题

    1. # 问题: @classmethod和@staticmethod的区别?
    2. """
    3. 一个是类方法一个静态方法。
    4. 定义:
    5. 类方法:用@classmethod做装饰器且至少有一个cls参数。
    6. 静态方法:用staticmethod做装饰器且参数无限制。
    7. 调用:
    8. 类.方法直接调用。
    9. 对象.方法也可以调用。
    10. """

3.6属性

  • 定义:

    • @property装饰器
    • 只有一个self参数
  • 调用:
    • 对象.方法 不加括号
  1. class Foo:
  2. @property
  3. def func(self):
  4. print(123)
  5. return 666
  6. obj = Foo()
  7. result = obj.func
  8. print(result)
  • 属性的应用

    1. # 属性的应用
    2. class Page:
    3. def __init__(self, total_count, current_page, per_page_count=10):
    4. self.total_count = total_count
    5. self.per_page_count = per_page_count
    6. self.current_page = current_page
    7. @property
    8. def start_index(self):
    9. return (self.current_page - 1) * self.per_page_count
    10. @property
    11. def end_index(self):
    12. return self.current_page * self.per_page_count
    13. USER_LIST = []
    14. for i in range(321):
    15. USER_LIST.append('alex-%s' % (i,))
    16. # 请实现分页展示:
    17. current_page = int(input('请输入要查看的页码:'))
    18. p = Page(321, current_page)
    19. data_list = USER_LIST[p.start_index:p.end_index]
    20. for item in data_list:
    21. print(item)

4成员修饰符

4.1 公有

  • 公有,所有地方都能访问到。

    1. class Foo:
    2. def __init__(self, name):
    3. self.__name = name
    4. def func(self):
    5. print(self.__name)
    6. obj = Foo('alex')
    7. # print(obj.__name)
    8. obj.func()

4.2 私有

  • 私有,只有自己可以访问到。

    1. class Foo:
    2. __x = 1
    3. @staticmethod
    4. def func():
    5. print(Foo.__x)
    6. # print(Foo.__x)
    7. Foo.func()
    8. #---------------------------------------------
    9. class Foo:
    10. def __fun(self):
    11. print('msg')
    12. def show(self):
    13. self.__fun()
    14. obj = Foo()
    15. # obj.__fun()
    16. obj.show()

4.3强制访问私有成员

  1. # 强制访问私有成员
  2. class Foo:
  3. def __init__(self,name):
  4. self.__x = name
  5. obj = Foo('alex')
  6. print(obj._Foo__x) # 强制访问私有实例变量

4.4内容补充py2/3区别

  • py2/3区别:

    1. class Foo:
    2. pass
    3. class Foo(object):
    4. pass
    5. # 在python3中这俩的写法是一样,因为所有的类默认都会继承object类,全部都是新式类。
    6. # 如果在python2中这样定义,则称其为:经典类
    7. class Foo:
    8. pass
    9. # 如果在python2中这样定义,则称其为:新式类
    10. class Foo(object):
    11. pass
    12. class Base(object):
    13. pass
    14. class Bar(Base):
    15. pass

4.5嵌套

  • 类/方法/对象都可以当做变量或嵌套到其他类型中.
  • 函数的参数可以是任意类型.
  • 可哈希(不可变)数据类型可以做字典的key.
  • 类和对象可以做字典的key.
  1. class School(object):
  2. def __init__(self,title,addr):
  3. self.title = title
  4. self.address = addr
  5. class ClassRoom(object):
  6. def __init__(self,name,school_object):
  7. self.name = name
  8. self.school = school_object
  9. s1 = School('北京','沙河')
  10. s2 = School('上海','浦东')
  11. s3 = School('深圳','南山')
  12. c1 = ClassRoom('全栈21期',s1)
  13. c1.name
  14. c1.school.title
  15. c1.school.address
  16. # ############################################
  17. v = [11,22,33,{'name':'山海','addr':'浦东'}]
  18. v[0]
  19. v[3]['name']

5 特殊方法(8个)

  • 补充:

    • 类的类变量可以直接操作输出,方法内不可以

      1. class fun:
      2. print(123)
      3. def func(self):
      4. print(1234)
      5. class fuu(self):
      6. print(456)
      7. #输出 123 456
  • __init__ #初始化方法: 用于给对象赋值

    1. class Foo:
    2. """
    3. 类是干啥的。。。。
    4. """
    5. def __init__(self,a1):
    6. """
    7. 初始化方法
    8. :param a1:
    9. """
    10. self.a1 = a1
    11. obj = Foo('alex')
  • __new__ #构造方法: 在init之前用于创建对象

    1. class Foo(object):
    2. def __init__(self):
    3. """
    4. 用于给对象中赋值,初始化方法
    5. """
    6. self.x = 123
    7. def __new__(cls, *args, **kwargs):
    8. """
    9. 用于创建空对象,构造方法
    10. :param args:
    11. :param kwargs:
    12. :return:
    13. """
    14. return object.__new__(cls)
    15. obj = Foo()
  • __call__ 对象后面加()执行cal方法;

    1. class Foo(object):
    2. def __call__(self, *args, **kwargs):
    3. print('执行call方法')
    4. # obj = Foo()
    5. # obj()
    6. Foo()()
  • __getitem__ __setitem__ __delitem__

    1. class Foo(object):
    2. def __setitem__(self, key, value):
    3. pass
    4. def __getitem__(self, item):
    5. return item + 'uuu'
    6. def __delitem__(self, key):
    7. pass
    8. obj1 = Foo()
    9. obj1['k1'] = 123 # 内部会自动调用 __setitem__方法
    10. val = obj1['xxx'] # 内部会自动调用 __getitem__方法
    11. print(val)
    12. del obj1['ttt'] # 内部会自动调用 __delitem__ 方法
  • __str__打印一个对像时,str返回什么打印什么

    1. class Foo(object):
    2. def __str__(self):
    3. """
    4. 只有在打印对象时,会自动化调用此方法,并将其返回值在页面显示出来
    5. :return:
    6. """
    7. return 'asdfasudfasdfsad'
    8. obj = Foo()
    9. print(obj)
  • __dict__

    1. class Foo(object):
    2. def __init__(self,name,age,email):
    3. self.name = name
    4. self.age = age
    5. self.email = email
    6. obj = Foo('alex',19,'xxxx@qq.com')
    7. val = obj.__dict__ # 去对象中找到所有变量并将其转换为字典
    8. print(val)
  • 上下文管理<<经典例题>>

    1. class Foo(object):
    2. def do_something(self):
    3. print('内部执行')
    4. class Context:
    5. def __enter__(self):
    6. print('进入')
    7. return Foo()
    8. def __exit__(self, exc_type, exc_val, exc_tb):
    9. print('推出')
    10. with Context() as ctx:
    11. print('内部执行')
    12. ctx.do_something()
  • __add__两个对象相加(经典例题)

    1. val = 5 + 8
    2. print(val)
    3. val = "alex" + "sb"
    4. print(val)
    5. class Foo(object):
    6. def __add__(self, other):
    7. return 123
    8. obj1 = Foo()
    9. obj2 = Foo()
    10. val = obj1 + obj2
    11. print(val)
    • 特殊成员:就是为了能够快速实现执行某些方法而生。

6 内置函数补充

importlib 用字符串的形式导入模块

  1. 模块 = importlib.import_module('utils.redis')
  • 示例:
  1. import importlib
  2. #用字符串的模式导入模块
  3. redis = importlib.import_module("utils.redis")
  4. #用字符串的形式去对象(模块)找到他的成员
  5. getattr(redis,"func")()

7 栈与队列初识

  • 栈:类似弹夹,先进后出
  • 队列:类似水管,先进先出
  1. class Stack(object):
  2. """
  3. 先进后出
  4. """
  5. def __init__(self):
  6. self.data_list=[]
  7. def push(self,val):
  8. """
  9. 向栈中压入一个数据(入栈)
  10. """
  11. self.data_list.append(val)
  12. def pop(self):
  13. """
  14. 从栈中拿走一个数据(出栈)
  15. """
  16. return self.data_list.pop()

8 可迭代对象

  • 表象:可以被for循环的对象就是可迭代对象

  • 在类中实现__iter__方法且返回一个迭代器(生成器)

    1. class Foo:
    2. def __iter__(self):
    3. return iter([1,2,3,4])
    4. obj = Foo()
    5. class Foo:
    6. def __iter__(self):
    7. yield 1
    8. yield 2
    9. yield 3
    10. obj = Foo()

9 约束

  • 约束子类内必须使用方法,不然主动异常

    1. class BaseMessage(object):
    2. def send(self,a1):
    3. raise NotImplementedError('字类中必须有send方法')
    4. class Msg(BaseMessage):
    5. def send(self):
    6. pass
    7. class Email(BaseMessage):
    8. def send(self):
    9. pass
    10. class Wechat(BaseMessage):
    11. def send(self):
    12. pass
    13. class DingDing(BaseMessage):
    14. def send(self):
    15. print('钉钉')
    16. obj = Email()
    17. obj.send()

10反射

  • python一切皆对象,所以想要通过字符串的形式操作内部成员都可以通过反射去完成操作.

  • py文件 包 类 对象...

  • 反射:根据字符串的形式去某个对象操作对象的成员.

    • getattr(对象名,"方法名")

      • 根据字符串的形式去某个对象中获取对象的成员.
      • attribute属性
      1. class Foo(object):
      2. def __init__(self,name):
      3. self.name = name
      4. def login(self):
      5. pass
      6. obj = Foo('alex')
      7. # 获取变量
      8. v1 = getattr(obj,'name')
      9. # 获取方法
      10. method_name = getattr(obj,'login')
      11. method_name()
    • setattr(对象名称,"变量",值 )

      • 根据字符串的形式去某个对象中设置成员.
      1. class Foo:
      2. pass
      3. obj = Foo()
      4. obj.k1 = 999
      5. setattr(obj,'k1',123) # obj.k1 = 123
      6. print(obj.k1)
    • hasattr(对象名称,"方法名")

      • 根据字符串的形式去某个对象中判断是否含有某成员.返回布尔类型
      1. class Foo:
      2. pass
      3. obj = Foo()
      4. obj.k1 = 999
      5. hasattr(obj,'k1')
      6. print(obj.k1)
    • delattr(对象,"方法名")

      • 根据字符串的形式去某个对象中删除某成员.
      1. class Foo:
      2. pass
      3. obj = Foo()
      4. obj.k1 = 999
      5. delattr(obj,'k1')
      6. print(obj.k1)

补充:

  • 模块importlib

    • importlib 用字符串的形式导入模块
    1. 模块 = importlib.import_module('utils.redis')
    • 示例:
    1. import importlib
    2. #用字符串的模式导入模块
    3. redis = importlib.import_module("utils.redis")
    4. #用字符串的形式去对象(模块)找到他的成员
    5. getattr(redis,"func")()
  1. self.MIDDLEWARE_CLASSES = [
  2. 'utils.session.SessionMiddleware',
  3. 'utils.auth.AuthMiddleware',
  4. 'utils.csrf.CrsfMiddleware',
  5. ]
  6. for mes in self.MIDDLEWARE_CLASSES:
  7. module_path,class_name=mes.rsplit('.',maxsplit=1) #切割路径和类名
  8. module_object = importlib.import_module(module_path) #插入模块-字符串操作
  9. cla=getattr(module_object,class_name) #根据模块对象找到类名(字符串操作-反射)
  10. obj = cla() #实例化对象
  11. obj.process() #运行内部函数process

python面向对象--快速入门的更多相关文章

  1. Python pandas快速入门

    Python pandas快速入门2017年03月14日 17:17:52 青盏 阅读数:14292 标签: python numpy 数据分析 更多 个人分类: machine learning 来 ...

  2. Python 3 快速入门 1 —— 数据类型与变量

    本文假设你已经有一门面向对象编程语言基础,如Java等,且希望快速了解并使用Python语言.本文对重点语法和数据结构以及用法进行详细说明,同时对一些难以理解的点进行了图解,以便大家快速入门.一些较偏 ...

  3. Python 3 快速入门 2 —— 流程控制与函数

    本文假设你已经有一门面向对象编程语言基础,如Java等,且希望快速了解并使用Python语言.本文对重点语法和数据结构以及用法进行详细说明,同时对一些难以理解的点进行了图解,以便大家快速入门.一些较偏 ...

  4. Python 3 快速入门 3 —— 模块与类

    本文假设你已经有一门面向对象编程语言基础,如Java等,且希望快速了解并使用Python语言.本文对重点语法和数据结构以及用法进行详细说明,同时对一些难以理解的点进行了图解,以便大家快速入门.一些较偏 ...

  5. 懂一点Python系列——快速入门

    本文面相有 一定编程基础 的朋友学习,所以略过了 环境安装.IDE 搭建 等一系列简单繁琐的事情. 一.Python 简介 Python 英文原意为 "蟒蛇",直到 1989 年荷 ...

  6. 转:Python requests 快速入门

    迫不及待了吗?本页内容为如何入门Requests提供了很好的指引.其假设你已经安装了Requests.如果还没有, 去 安装 一节看看吧. 首先,确认一下: ·Requests 已安装 ·Reques ...

  7. Python Requests快速入门

    迫不及待了吗?本页内容为如何入门Requests提供了很好的指引.其假设你已经安装了Requests.如果还没有, 去 安装 一节看看吧. 首先,确认一下: Requests 已安装 Requests ...

  8. Python语言快速入门

    Python的主提示符(>>>):是解释器告诉你它正在等待你输入的下一个语句 Python的次提示符(...):告诉你解释器正在等待你输入当前语句的其他部分 [简介] Python( ...

  9. 第一阶段——CentOS6_Python3.6.1笔记(尚学堂-Python基础快速入门)+ 【补充】麦子-Python程序入门与进阶

    虚拟机环境: 设置网络 .修改网络地址 .设置网卡为nat模式 .确保物理机启动dhcp.net服务 .编辑文件:vim /etc/sysconfig/network-scripts/ifcfg-et ...

随机推荐

  1. 企业为什么需要BI报表工具?

    企业一旦成规模运作起来,数据量是数以万计的,无论数据还是报表都需要协同管理不断更新.面对各大OA\ERP\CRM系统的数据,传统用Excel处理数据效率是很低下的.要想快速出报表,快速取数,快速做业务 ...

  2. 你真的会做数据分析吗?如果不会我推荐思迈特软件Smartbi

    你是否还在被以下问题所困扰? 辛苦辛苦地拿到了一堆数据,却不知道从何下手分析? 因为不会统计数据分析伤透脑筋,而打消考博的梦想? 数据分析求助无门,涌现出想要放弃学位的念头? 突然开天眼般的想到了一个 ...

  3. Java课程设计---浏览学生(实现根据姓名查询)

    1.修改窗口 2.在StudentDao中增加根据姓名查找的方法 public List<Student> getStudent(String name)throws SQLExcepti ...

  4. 洛谷P4322.最佳团体

    题目大意 一个 \(n(1\leq n\leq 2500)\) 个节点的森林,每个点 \(i\) 有权值 \(s_{i},p_{i}(0<s_{i},p_{i}\leq 10^4)\) 以及父亲 ...

  5. 前端好用API之getBoundingClientRect

    前情 在前端开发需求中,经常需要获取元素的尺寸位置相关的属性,以往的做法是调用不同api获取相关属性的. getBoundingClientRect介绍 getBoundingClientRect() ...

  6. gdb调试快速入门

    编译指令 gcc test.c -o test -g -g是加入调试信息,加入源码信息 启动gdb调试 gdb test 进入gdb中 设置参数 set args 10 20 显示参数show age ...

  7. webgl未使用独立显卡报告

    0x00 楔子 最近客户在使用我们的的三维可视化平台的时候,总是会出现浏览器崩溃,webgl context lost的情况. 这种请一般出现在电脑配置很低的电脑上,比如没有独显,只有很小现存的集成显 ...

  8. tp5 (自写) 实现redis消息队列 + 排行榜

    1:小皮开启redis, 控制器按Ctrl 点击new Redis 进入 redis.php 进行封装 //向队列添加数据 // LPUSH key value1 [value2] //将一个或多个值 ...

  9. Laravel 自定命令以及生成文件

    以创建service层为例子 1.执行命令 php artisan make:command ServiceMakeCommand 2.在app\Console\Commands 下就会多出一个 Se ...

  10. ASP.NET Core 6框架揭秘实例演示[21]:如何承载你的后台服务

    借助 .NET提供的服务承载(Hosting)系统,我们可以将一个或者多个长时间运行的后台服务寄宿或者承载我们创建的应用中.任何需要在后台长时间运行的操作都可以定义成标准化的服务并利用该系统来承载,A ...