Python - 进阶（持续更新 ing）

Python - 面向对象

第一章 面向对象基础

1.1 面向对象的概念

• 类、对象、属性、方法
• 类的特性：封装、继承（单继承、多继承）、多态
  • 封装：对类中的方法进行的操作
  • 继承
    
  • 多态
    
• 通过终端进入python环境
  

1.2 定义类

• 定义类

class className:
	statement1
	...
	statementN

• 构造函数只有一个 , 参数列表最长的一个覆盖其他的构造函数

def __init__(self,[...):

• 析构函数

def __del__(self,[...):

• 历史遗留问题（新式类与老式类）

Old Style Class
class OldStyle:
	pass
New Style Calss
class NewStyle(object):
	pass

• 两个内建函数

dir()	# 返回类的属性
type()	# 返回类的类型

1.3 定义类的属性

• 直接在类里定义类的属性

class className(object):
	sex = 'male'

• 在构造函数里定义属性

class className(object):
	def __init__(self, name, sex):
		self.name = name
		self.sex = sex

• 实例的属性可以像普通变量一样进行操作

xiaohong.grade = xiaohong.grade + 1

• 注意 : python中不提供私有属性的访问设置

class className(object):
	def __init__(self, name, sex, age):
		self.name = name	# 可以公开访问
		self._sex = sex		# 私有属性,此类的对象均可访问此属性
		self.__age = age	# 类似私有属性,只有此类之内可访问,外部也可通过别的方法访问

• 实例

class Program(object):
    name = 'Mike' # 这是类的属性 , 由于Python是动态语言 , 类属性也是可以动态添加和修改的

    def __init__(self, age, sex, weight):
        self.age = age
        self._sex = sex
        self.__weight = weight

    def get_weight(self):
        return self.__weight


if __name__ == '__main__':
    Program = Program(22, 'male', 50) # 初始化
    print(Program.name)
    print(Program.age)
    print(Program._sex)
    print(Program.get_weight())
    print(Program._Program__weight)

1.4 定义类的方法

• 函数与方法的区别
  函数 : 直接通过函数名称调用
  方法 : 属于某个类 , 通过对象调用
• 对于方法的访问控制也是不提供的 , 类似于对属性的设置

class className(object):
	def one(self):
		pass
	def _two(self):
		pass
	def __three(self):
		pass

• 几个装饰器
  @classmethod : 调用时 , 通过类名直接调用 , 不用通过声明类的对象间接调用
  @property : 像调用属性一样调用方法 , 不用写方法后的括号

1.5 类的继承

• 定义类的继承

class DerivedClassName(BaseClassName):
	<statement1>
	...
	<statementN>

• 继承的子类
  • 会继承父类的属性与方法
  • 也可以重新自定义方法 , 覆盖父类的属性与方法
• 用super()调用父类的方法

class A(object):
	def AMethod(self, args):
		pass
class B(A):
	def BMethon(self, args):
		super(B, self).AMethod(args)

• 子类的类型判断
  • isinstance(B, A)
    如果对象B的类型与A的类型相同则返回 True , 否则返回 False
    object – 实例对象
    classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组
  • issubclass(B, A)
    如果 B 是 A 的子类返回 True , 否则返回 False
    class – 类
    classinfo – 类
• python支持多继承

1.6 类的多态

• 多态的要素
  • 继承
  • 重写方法
• 实例

class Program(object):
    name = 'Mike'

    def __init__(self, age, sex, weight):
        self.age = age
        self._sex = sex
        self.__weight = weight

    def intro(self):
        print('my name is ', self.name)
        print('my age is ', self.age)


class BProgram(Program):
    def __init__(self, age, sex, weight, language):
        super(BProgram, self).__init__(age, sex, weight)
        self.language = language

    def intro(self):
        print('my age is %s\nmy language is %s' % (self.age, self.language))


def introduction(program):
    if isinstance(program, Program):
        program.intro()


if __name__ == '__main__':
    program = Program(12, 'female', 34)
    bProgram = BProgram(22, 'male', 50, 'python')
    introduction(program)
    introduction(bProgram)

1.7 多继承

• Python允许从多个父类继承 , 称为多重继承

class A(object):
    def __init__(self, a):
        print 'init A...'
        self.a = a

class B(A):
    def __init__(self, a):
        super(B, self).__init__(a)
        print 'init B...'

class C(A):
    def __init__(self, a):
        super(C, self).__init__(a)
        print 'init C...'

class D(B, C):
    def __init__(self, a):
        super(D, self).__init__(a)
        print 'init D...'

多重继承通过 super()调用__init__()方法时 , A 虽然被继承了两次，但__init__()只调用一次

• 实例

class Person(object):
    pass

class Student(Person):
    pass

class Teacher(Person):
    pass

class SkillMixin(object):
    pass

class BasketballMixin(SkillMixin):
    def skill(self):
        return 'basketball'

class FootballMixin(SkillMixin):
    def skill(self):
        return 'football'

class BStudent(Student, BasketballMixin):
    pass

class FTeacher(Teacher, FootballMixin):
    pass


if __name__ == '__main__':
		s = BStudent()
		print(s.skill())
		t = FTeacher()
		print(t.skill())

第二章 Python的Magic Method

2.1 Magic Method

• 是什么
  它是python面向对象的一整套方法 , 从对象的建立到属性的访问 , 到对运算符的支持 , 对特殊语法的支持
• 形式
  方法名前后后两个_ , 如 : def __init__(self):

2.2 对象的创建与初始化

• 对象实例化的过程
  • 创建类的对象 : def __new__(cls)
  • 初始化对象 : def __init__(self)
  • new方法在调用init方法之前被调用 , 返回一个类的初始对象 , 可以进行重写 , 但是要返回对象 , cls表示当前类
• 回收对象
  def __del__() : 实际并不会调用这个方法进行回收 , python的回收机制会自动调用此方法进行回收
• 实例

# 首先调用new方法 , 用于返回自身的一个对象 , 然后将对象交给init方法
class Program(object):

    def __new__(cls, *args, **kwargs):
        print('call_new_method')
        print(args)
        return super(Program, cls).__new__(cls)

    def __init__(self, name, age, language):
        print('call_init_method')
        self.name = name
        self.age = age
        self.language = language


if __name__ == '__main__':
    program = Program('John', 22, 'python')
    print(program.__dict__)

对于*args与**kwargs参数的含义详见*args与**kwargs

2.3 类的属性控制

• 设置对象属性
  __setattr__(self, name, value):

def __setattr__(self, name, value):
	self.__dict__[name] = value

• 查询对象属性
  __getattr__(self, name): 访问这个属性时 , 在没有查找到相应实例属性时被调用
  __getattribute__(self, name): 每次访问属性时被调用 , 更容易引起无限递归情况 , 使用时小心
  详见getattr与getattribute
• 删除对象属性
  __delattr__(self, name):
• 实例

class Program(object):

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __getattribute__(self, name):
        # return getattr(self, name) # 引起无限递归
        # return self.__dict__[name] # 引起无限递归
        return super(Program, self).__getattribute__(name)

    def __setattr__(self, name, value):
        self.__dict__[name] = value

    def __setattr__(self, age, value):
        self.__dict__[age] = value

    def __getattr__(self, age):
        return super(Program, super).__getattr__(age)


if __name__ == '__main__':
    p = Program('mike', 22)
    print(p.name)
    print(p.age)

2.4 类的展现

• 将对象转换为字符串
  __str__ :将对象转换成适合人可以看懂的字符串 , 用于显示给用户 , 当打印一个类的实例对象时，会自动调用str方法，并返回回来一个字符串
  __repr__ : 将对象转换 为适合机器解读的字符串 , 用于显示给开发人员
  __unicode__ : 详见unicode与str
• 展现类的属性
  __dir__ :可以直接调用此方法 , 展现所有的属性 , 也可以根据需求自定义此方法
• 实例

class Program(object):

    def __init__(self, name, age):
        self.name = name
        if isinstance(age, int):
            self.age = age
        else:
            raise Exception("age must be int")


    def __dir__(self):
        return self.__dict__.keys()


if __name__ == '__main__':
    p = Program('mike', 22)
    print(p)
    print(dir(p))

• 获取对象的信息

class Person(object):
    def __init__(self, name, gender, **kwargs):
        self.name = name
        self.gender = gender
        # 任意数量的参数 , 并通过 setattr() 绑定属性
        for k, v in kwargs.items():
            setattr(self, k, v)


if __name__ == '__main__':
        p = Person('Bob', 'Male', age=18, course='Python')
        print(p.age)
        print(p.course)
        getattr(p, 'name') # 获取那么属性值
        print(p.name)
        setattr(p, 'name', 'Adam') # 设置name属性值为Adam
        print(p.name)
        getattr(p, 'age', 20) # 获取age属性 , 如果属性不存在 , 就返回默认值20
        print(p.age)

2.5 类的运算符

• 比较运算符
  __cmp__(self, other) : 包含两个对象比较的所有情况
  __eq__(self, other) : 判断两个对象是否相等
  __It__(self, other) : 判断前者是否小于后者
  __gt__(self, other) : 判断前者是否大于后者
• 数字运算符
  __add__(self, other) : 加
  __sub__(self, other) : 减
  __mul__(self, other) : 乘
  __div__(self, other) : 除
• 逻辑运算符
  __or__(self, other) : 或运算
  __and__(self, other) : 和运算
• 实例

class Program(object):

    def __init__(self, name, age):
        self.name = name
        if isinstance(age, int):
            self.age = age
        else:
            raise Exception("age must be int")

    def __eq__(self, other):
        if isinstance(other, Program):
            if self.age == other.age:
                return True
            else:
                return False
        else:
            raise Exception("the type of object must be Program")

    def __add__(self, other):
        if isinstance(other, Program):
            return self.age + other.age
        else:
            raise Exception("the type of object must be Program")


if __name__ == '__main__':
    p1 = Program('mike', 21)
    p2 = Program('john', 20)
    print(p1 == p2)
    print(p1 + p2)

第三章 函数式编程

3.1 函数式编程简介

• 什么是函数式编程
  函数式是一种编程范式
• 函数式编程特点
  把计算看做是函数而不是一系列指令
  纯函数式编程不需要变量 , 测试简单
  支持高阶函数 , 代码简洁
• Python支持的函数式编程的特点
  不是纯函数式编程 , 支持有变量存在
  支持高阶函数 , 函数可以作为变量传入
  支持闭包 , 有了闭包就可以返回函数
  有限度的支持匿名函数

3.2 Python中的高阶函数

• 高阶函数 : 可以接收函数作为参数的函数就是高阶函数
  • 变量可以指向函数
  • 函数名就是指向函数的变量
  • 函数的参数可以接收变量
  • 一个函数可以接收另一个函数作为参数
• 实例

import math


def add(x, y, f):
    return f(x) + f(y)


def sqrt(i, j, k):
    return k(i) + k(j)


if __name__ == '__main__':
    print(add(-5, 9, abs))
    print(sqrt(9, 16, math.sqrt))

3.3 Python中的map()函数

• map()函数
  它是python内置的高阶函数 , 接收一个函数 f 和一个 list , 并通过把函数 f 依次作用在 list 的每个元素上 , 得到一个新的 list 并返回
• 实例

def trans(x):
    return x*x


if __name__ == '__main__':
    print(list(map(trans, [1, 2, 3, 4, 5, 6, 7, 8, 9])))

• 注意
  • map()函数不改变原有的 list , 而是返回一个新的 list
  • 利用map()函数 , 可以把一个 list 转换为另一个 list , 只需要传入转换函数
  • list包含的元素可以是任何类型 , 因此 , map() 不仅仅可以处理只包含数值的 list , 事实上它可以处理包含任意类型的 list , 只要传入的函数f可以处理这种数据类型

3.4 Python中的reduce()函数

• reduce()函数
  是Python内置的一个高阶函数 , reduce()函数接收的参数和 map()类似 , 一个函数 f , 一个list , 但行为和 map()不同 , reduce()传入的函数 f 必须接收两个参数 , reduce()对list的每个元素反复调用函数f , 并返回最终结果值
• 实例

from functools import reduce


def trans_sum(x, y):
    return x + y


if __name__ == '__main__':
    print(reduce(trans_sum, [1, 2, 3, 4]))

• 注意
  • reduce函数实际上是对 list 的所有元素求和
  • reduce()还可以接收第3个可选参数，作为计算的初始值

3.5 Python中的filter()函数

• filter()函数
  是python内置的高阶函数 , filter()函数接收一个函数 f 和一个list , 这个函数 f 的作用是对每个元素进行判断 , 返回 True或 False , filter()根据判断结果自动过滤掉不符合条件的元素 , 返回由符合条件元素组成的新list
• 实例

# 实例1
def is_odd(x):
    return x % 2 == 1


if __name__ == '__main__':
    print(list(filter(is_odd, [1, 2, 3, 4, 5])))


# 实例2
# s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符 , 当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')
def is_not_empty(s):
    return s and len(s.strip()) > 0


if __name__ == '__main__':
    print(list(filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])))

3.6 Python中自定义排序函数

• sorted()函数可对list进行排序

>>>sorted([36, 5, 12, 9, 21])
[5, 9, 12, 21, 36]

• sorted()也可以对字符串进行排序 , 字符串默认按照ASCII大小来比较
• sorted(iterable, key=None, reverse=False)
  iterable – 可迭代对象
  key – 主要是用来进行比较的元素 , 只有一个参数 , 具体的函数的参数就是取自于可迭代对象中 , 指定可迭代对象中的一个元素来进行排序
  reverse – 排序规则 , reverse = True 降序 , reverse = False 升序（默认）
• 实例

# 方法1
def cmp_ignore_case(x):
    return x.upper()


if __name__ == '__main__':
    print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=cmp_ignore_case))

# 方法2    
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=lambda x: x.upper()))

lambda详见 : lambda

3.7 Python中返回函数

• Python的函数不但可以返回int、str、list、dict等数据类型 , 还可以返回函数
• 举例说明

def f():
    print('call f()...')
    def g():
        print('call g()...')
    return g

函数 f 内部又定义了一个函数 g , 由于函数 g 也是一个对象 , 函数名 g 就是指向函数 g 的变量 , 所以 , 最外层函数 f 可以返回变量 g , 也就是函数 g 本身

3.8 Python中闭包

3.9 Python中匿名函数

3.10 Python中decorator装饰器

3.11 Python中编写无参数decorator

3.12 Python中编写有参数decorator

3.13 Python中完善decorator

3.14 Python中偏函数

本文章参考课程链接
https://www.imooc.com/video/13273
https://www.imooc.com/video/6042