python概述

python解释器
命令行模式和python交互模式
文本编辑器
直接运行python文件：

#!/usr/bin/env python3

python基础

数据类型

静态语言和动态语言：变量类型是否固定
python没有机制保证存储常量
任何数据都是一个对象
pyhon的整形和浮点型在机制上没有大小限制
list/tuple/dict/set之间的区别

字符串编码

各国语言体制 -> Unicode -> UTF-8
bytes类型数据可以用decode转为utf-8等不同类型的数据解释（如果没有特殊业务要求，请牢记仅使用UTF-8编码）

函数

pass可作为占位符跳过一个函数的运行
关于函数参数：必选参数在前，变化大的参数在前
定义默认参数要牢记一点：默认参数必须指向不变对象！
参数类型：必选参数，默认参数，可变参数，关键字参数，命名关键字参数。
可变参数：
- 可以在list/tuple的变量名前加 * 传入可变参数
- **传入的是dict，*传入的是tuple
- 可以限制关键字参数的名字，未填入的参数可以有缺省值。

之前写的kernel函数是否可以用命名关键字参数来限制不同数量参数的传入和处理？

def person(name, age, *, city, job):
    print(name, age, city, job)

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

提示：代码越少，开发效率越高

高级特性

切片/迭代

tuple也可以使用切片，只是不可修改
字符串也可以切片
for循环可以用于一切可迭代对象上

>>> from collections.abc import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

Python内置的enumerate函数可以把一个list变成索引-元素对

>>> for i, value in enumerate(['A', 'B', 'C']):
...     print(i, value)
...
0 A
1 B
2 C

列表生成式/生成器/迭代器

可以套多层循环，可以添加if限制
generator，不必创建完整的list，从而节省大量的空间

generator能不能解决由于向量数据过大显存不足导致的问题？

生成器和生成器函数，生成器函数赋值后才会成为生成器对象
Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用（甚至可以表示一个无限大的数据流），而list等不是Iterator
判断Interable/Interator准则，是否可以被for/next（）作用

函数式编程（Functional Programming）

即面向过程编程，对应到编程语言，就是越低级的语言，越贴近计算机，抽象程度低，执行效率高。函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量。

变量可以指向函数，函数名也是变量
高阶函数：函数作为参数导入
- map（f，Interable）
- reduce（f，Interable）
- filter（f，Interable）
- filter可对一切可迭代对象生效，包括生成器。
- sorted（Interable，key）

能否使用filter函数处理约束优化的点选取？

返回函数：函数作为返回输出
- 每次执行返回函数相当于创建一个新的对象，即每次创建出来的函数实体是不相等的
- 闭包：返回函数的参数不要使用任何后续会发生变化的变量！！
- nonloca：标识变量来自于外部作用域
匿名函数：（python对于匿名函数的支持有限，仅在一些简单的情况下可以使用）
装饰器：在不修改原函数的情况下附加函数功能
- 日志输出、性能验证、验证服务、重试机制、结果转换

import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator
# 使用方法
@log("text")
def now():
	print(f"{text},"time"")

是否可以使用装饰器完成对一些函数的日志输出？

偏函数：固定函数的关键词参数

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

模块

关于模块编写规范
- 可执行文件标识
- utf-8编码标识
- 文件描述
- 模块作者
- 代码
- 测试代码

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

' a test module '

__author__ = 'Michael Liao'

import sys

def test():
    args = sys.argv
    if len(args)==1:
        print('Hello, world!')
    elif len(args)==2:
        print('Hello, %s!' % args[1])
    else:
        print('Too many arguments!')

if __name__=='__main__':
    test()

作用域：变量名开头 _ 或 __ 的是私有变量，不可被外部访问

面向对象编程（OOP）

基础

三个重点：封装、继承、多态

封装：类和实例
- 访问限制：在class内部的数据最好做私有化处理，拉出一个函数接口来获取和修改类参数。这样方便对参数的修改做准入机制。防止无效参数的传入。
- 警告：Python本身没有任何机制阻止你干坏事，一切全靠自觉

把设置相关类的参数做私有化封装！

继承/多态：
- python是动态语言，对类型限制不严格
- 获取对象信息
  - type（），isinstance（）
  - dir（）：获取类型全部属性和函数
- 实例属性/类属性

进阶

可以对实例或类绑定方法：

>>> def set_age(self, age): # 定义一个函数作为实例方法
...     self.age = age
...
>>> from types import MethodType
>>> s.set_age = MethodType(set_age, s) # 给实例绑定一个方法
>>> s.set_age(25) # 调用实例方法

>>> Student.set_score = set_score # 给类绑定一个方法

__ slots __ ：限制可加入的实例属性
- 注意：该方法不会被子类继承
@property装饰器：将一个方法变为属性调用

class Student(object):
    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

>>> s = Student()
>>> s.score = 60 # OK，实际转化为s.score(60)
>>> s.score # OK，实际转化为s.score()
60
>>> s.score = 9999
Traceback (most recent call last):
  ...
ValueError: score must between 0 ~ 100!

多重继承
定制类
- __ str __ ：代替print
- __ iter __ / __ next __
- __ getitem __ ：代替切片（int/slice）
- __ getattr __ ：返回默认设定的不存在属性参数
- __ call __ ：在实例本身上调用某函数
枚举类/元类

错误处理

try：当我们认为某些代码可能会出错时，就可以用try

try:
    print('try...')
    r = 10 / 0
    print('result:', r)
except ZeroDivisionError as e:
    print('except:', e)
finally:
    print('finally...')
print('END')

调用栈/异常栈
记录错误：logging模块

def main():
    try:
        bar('0')
    except Exception as e:
        logging.exception(e)

调试

断言

def foo(s):
    n = int(s)
    assert n != 0, 'n is zero!'
    return 10 / n

logging日志

import logging

s = '0'
n = int(s)
logging.info('n = %d' % n)
print(10 / n)