day01回顾:
  变量:
    创建变量(赋值语句)
      变量  = 表达式
    修改变量
      变量  = 表达式
    删除变量
      del 变量名
python 起源
应用领域
优点:
缺点:
  执行速度慢
  不能封闭源代码

www.python.org
版本 python v2 / v3

解释执行器 python3 (CPython)
CPython/Jython/IronPython

运行:
  1. python3 文件名.py
  2. python3 <回车>
     >>>
数据类型:
  数字: 整数int, 浮点型数float, 复数complex, 布尔型数(True/False)
  字符串str: "文字内容"
  列表list
  ...

None 空值对象
运算符:
  + - * /  //  %  **
  is / is not

print() 函数
id(x)  返回对象的内存地址
  变量占用内存吗?  1byte(字节) = 8bit位

复合赋值算术运算符:
  +  -  *  / ...
  += -= *= /= //= %= **=
  day02回顾:
  运算符:
    比较运算符:
      > < >= <= == !=
    布尔运算符
      not  and   or
    bool(x) 为假值的情况:
      None, False, 0, 0.0, 0j  ''  []  ()
    一元运算符:
      + (正号)  -(负号)

  if 语句(分支语句)
    if a > b or c > d:
        ...
    elif  e < f:
        ...
    else:
        ...

条件表达式:
   表达式1 if 真值表达式 else 表达式2

函数:
  函数调用:
    函数名 (调用传参列表)

  int(x=0)/int('字符串', base=10)
  float(x=0)
  complex(real=0.0, image=0.0)
  bool(x)
  abs(x)
  round(x, 位数)
    round(123.456789, 2)
  pow(x, y, z=None)

  输入输出函数:
    input('提示字符串')
    print(value, ....., sep=' ', end='\n')
 
  help(字符串/函数名/类名....) 帮助函数

语句:
  显式换行 \
  隐式换行: ()  []  {}

pass 语句

day03回顾:
  字符串 str
    字符串内存放的是有先后顺序关系的文字编码
  字面值:
    ''
    ""
    ''''''
    """"""  (所见即所得字符串,回车键会自转换为换行)

  转义符号 \
   \n \'  \"  \\  \r  \t  \b
   \0oo   \xXX  \uXXXX  \UXXXXXXXX
   \0   等同于 \x00

   'A'     65  0x41
   'a'     97  0x61
   '0'     48  0x30
   ' '     32  0x20

原始字符串:
  raw字符串
    r''
    r""
    r''''''
    r""""""  ( \ 转义无效)

字符串运算:
  +   +=    *    *=
  < <= > >= == !=
  in  /  not in (返回值是布尔类型)
  索引 []
     正向索引 0 1 2 3  ....
     反向索引 -1 -2 ..... -len(x)
  切片 [:]   [::]
     s[整数开始值: 整数结束值:  整数步长]

函数:
   len(x)   / max(x)   / min(x)
   ord(c)   chr(i)
   bin(x)   oct(x)    hex(x)
   str(x)

字符串的方法:
  S.isalpha()
  S.isdigit()
  S.center(n, fill=' ')
  S.replace(old, new, count)
  S.strip()  支掉空白字符
  S.startswith(ch)
  S.endswith(ch)
  S.count()
  ...
  print(x.count('a'))
print(x.isalpha())
print(x.isdigit())
print(x.center(10))
print(x.find('a',2,6))
print(x.isupper())
print(x.lower())
print(x.strip())
print(x.replace('a',' '))
print(x.startswith('a'))
  详见:
    >>> help(str)
day04回顾:
字符串格式化表达式
  "格式化字符串" % 参数
  "格式化字符串" % (参数1, 参数2,...)
  "%d" % 20  # 生成'20'

  %s  %d   %f  %7.2f
  % [ -  +  0  宽度  .  精度]  类型码

while 语句
  while 布尔表达式:
      语句块1
  else:
      语句块2

break 语句
死循环
   while True:
     if xxxx:
        break
 
循环语句:
  while 语句
  for 语句
day05回顾:
  for 语句
    for 变是列表 in 可迭代对象:
        语句块1(重复执行多次)
    else:
        语句块2(在可迭代不再能提供数据时执行)
  可迭代对象:
    字符串 列表 range(开始,结束,步长)

continue 语句
  while 中
  for 中

语句嵌套:
  if  while for .....
  如:
    if xxx:
        while ....:
            for xxxx:
                if xxxx:
   
    while xxx:
        for yyy:
            ...
            if zzz:
               ....
        else:
            print(...)

    print("hello)

列表 list
   []
   [1, 2, 3. 3.14, True, ...]

序列,可变的, 容器
构造函数
   list()
   list(可迭代对象)

列表的运算:
  运算符:
    + += * *=
    < <= > >= == !=
    in / not in
    索引[] / 切片[:] [::]
      索引和切片支持赋值操作:
        列表[整数列表] = 值
        列表[开始索引:结束索引:步长] = 可迭代对象
day06回顾
  列表
    方法:
      L.append(x) 
      L.extend(iterable)    +=
      L.insert(索引位置,值)
      L.remove(x)  # 删除
      L.clear()
      L.pop([索引])  取出
      L.copy()  复制
      L.count(元素,begin,end)  计数
      L.sort(reverse=False)
      L.reverse()  反转

len(x)  求长度
max(可迭代对象)/max(值1,值2,....)
min(可迭代对象)/min(值1,值2,....)
sum(可迭代对象)  # 求和
any(可迭代对象)
all(可迭代对象)

列表是可变的对象
浅拷贝和深拷贝
  变量1 = 变量2 # 不复制
  变量1 = 列表2.copy()   # 浅拷贝
  import copy
  变量1 = copy.deepcopy(列表2)  # 深拷贝

字符串的方法:
  str.split()
  str.join()

列表推导式:
  [表达式 for 变量1 in 可迭代对象1 if 真值表达式1 for 变量2 in 可迭代对象2 if 真值表达式2 ...]
day07回顾
  元组 tuple
    可以是任意类型的数据(类似于列表)
    元组是不可变的序列(类似于字符串)
     ()     (20,)    (10, 20)
             20,      10, 20
    构造函数tuple()  / tuple(可迭代对象)

  字符串, 列表,元组的运算:
    +  +=  *  *=
    < <= > >= == !=
    in / not in
    索引 index / 切片 slice

    reversed(可迭代对象)  反转序列

  字典 dict
    表示方式
       {}, {1:'一'}, {1:'一', 2:'二'}
    构造函数 dict
      dict()
      dict(可迭代对象)
        dict(["AB", (1,2), [3, 4]])
      dict(关键字传参)
        dict(name="laowei", age=35)
   
    键索引
      字典[键表达式]           # 取值
      字典[键表达式]  = 表达式  # 赋值

      del 字典[键表达式]

   D.clear() 清空
   D.pop(键)  移除
   D.copy()
   D.update(D2)  合并
   D.get(键, default=None)
   D.keys()    # 键 key
   D.values()  # 值 value
   D.items()   # 键值对

   for k, v in D.items():
       pass

字典推导式:
  生成字典:
    {键表达式: 值表达式 for 变量in 可迭代对象 if 条件表达式 .....}
阶段总结:
    数据类型:
        不可变类型
        bool int float complex  str tuple
        frozenset bytes(字节串)
        可变类型
        list dict set bytearray(字节数组)
运算符:
    + -×/ //% < <=  ==
    not in/in
    is / is not
    & |^-
    索引/切片

表达式
1 
1+2
max(1.2.3)+max(4,5,6)
条件表达式 x if x<y else y
全部的推导式: 列表,字典,集合推导式(三种)

语句:
    表达式语句
    赋值语句
    判断语句
    循环语句
    del 语句  if 语句   for 语句 break 语句 continue语句 pass 语句

内建函数
max()
len()
构造函数
int()
float(str())
list()
tuple()
dict()
set()
frozenset()
数值处理函数
abs(x)
round(x)
pow(x,y,z=None)
编码转换
ord()
chr()
进制转换
hex()
bin()
oct()
返回可抵达对象的函数
range(start,stop,step)
reversed(x)
输入输出函数
input()
print()
ay08回顾
两个容器类型
  set (可变集合)
  frozenset (不可变集合)
    存储不可变数据的容器
  无序/不能存在重复元素

运算:
  &交集  |并集  -补集  ^对称补集
  < >  == !=  <=  >=
  in / not in

集合:
  {1,2,3}  / set()
  frozenset({1,2,3})  / frozenset()

方法:
  S.add()
  S.remove()
  S.discard()
  S.clear()
  S.pop()
  S.copy()
  S.update()

集合推导式:
   {x**2 for x in range(10)}
   {x for x in "AABCABC"}  # {'A','B','C'}

函数:
  创建函数的语法:
    def 语句:
      def 函数名(形参变量1, 形参变量2, ...):
          语句块

  函数的调用:
    函数名(实参1, 实参2, ...)
    表达式返回None

return 语句
  语法:
    return  # 相当于return None
    或
    return 表达式
  作用:
    用于终止函数的执行,返回一个对象的引用关系(默认返回None)
day09回顾:
  实参   ----->  形参

参数传递:
  位置传参
    序列传参 (*序列)
  关键传参
    print(1, 2, 3, sep='#')
    字典关键传参(**字典)

形参有四种
  1. 位置形参
  2. *元组形参 (接收多余的位置传参:*args)
  3. 命名关键字形参(强制使用关键字传参)
  4. **字典形参(接收多余的关键传参:**kwargs)

缺省参数:
   def fx(a,b=0,*,c=0,d=0):
       pass
 
全局变量
局部变量
  函数内部创建的变量是局部变量

globals()
locals()
函数变量
  def 函数变量名(形参列表):
      语句块
 
  def f1():
      pass
  f2 = f1  # f2 绑定 f1绑定的函数
  f2 = f1()  调用后返回None

函数可以作为参数传入另一个函数
  def fx(fn):
       ...
  fx(f1)  # 和 fx(f1())  不同
函数可以作为另一个函数的返回值
  def fy():
      return max
  def fz():
      def f2():
          pass
      return f2

函数嵌套定义
python 的四个作用域
  局部                      L
  外部嵌套函数作用域          E
  全局(函数所在模块的作用域)   G
  内建函数作用域              B

global 语句  (声明变量为全局变量)
nonlocal 语句 (声明变量为外部嵌套函数作用域内的变量)

lambda 表达式
  作用:
    创建匿名函数
  语法:
    lambda 形参列表: 表达式

eval(字符串, 全局变量的字典,局部变量的字典)
  返回表达式执行后返回的对象
exec(字符串, 全局变量的字典,局部变量的字典)
  把字符串当成程序解释执行

day11回顾
  函数式编程
    建议使用可重入函数
      可重入函数一定不使用除局部变量以外的变量
  高阶函数:
    map(func, 可迭代对象1, 可迭代对象2,...)
    filter(func, 可迭代对象)
    sorted(可迭代对象, key=None, reverse=False)

递归函数
  函数直接或间接调用自身
 

闭包 closure
  内嵌函数引用了外部变量,返回的内嵌函数叫做闭包
  ay12 回顾:
  装饰器
    def 装饰器函数名(被装饰函数形参):
        创建闭包
        return 闭包

    @装饰器函数名
    def 被装饰函数(形参列表):
        pass

    被装饰函数(实参列表)

  函数的文档字符串:
    def 函数名(...):
        '文档字符串'

    >>> help(函数名)
    __doc__属性
    函数名.__doc__ = '文档字符串'

模块
  模块内通常有 数据,函数,类

四类模块:
  内建模块
  标准库模块
  第三方模块
  自定义模块

模块的导入语句有三种:
  import 语句
      import sys
      sys.path
  from import 语句
      from sys import path
      print(path)
  from import * 语句
      from sys import *
      print(path)

dir() 函数

三个模块:
  math
  time
  sys
day13回顾:
自定义模块
  模块名(标识符).py
    全局变量将成为模块的属性
  导入方式:
    import 语句
    from import 语句
    from import *语句

  搜索:
    1. 内建模块
    2. 当前工作路径
    3. sys.path提供的路径

  import mymod    # 执行 mymod.py

   mymod.py  ---> mymod.pyc ---> python

模块内的序置属性
  __doc__ 属性
  __file__属性
  __name__属性

__all__ 列表
  from import *语句

隐藏属性
  以 _ 开头的 标识符 在 from import *语句导入时不会被导入

随机模块 random

包 pack
  包的导入:
    import 语句
       import 包位置
    from import 语句
       form 包位置 import 子包/模块/属性
            绝对位置 mypack.menu
            相对位置 ..menu
    from import * 语句
       from 包位置 import *

  __init__.py
    文档字符串
    函数
    __all__列表
day14回顾:
  异常 exception
    错误
    异常
  异常相关的语句:
    发出(触发/抛出)异常通知:
      raise 语句
      assert 语句
    捕获异常:
      try-except 语句
        try:
             .... 可以触发异常的语句
        except 类型 as 变量名:
            ...
        except (类型2,类型3,...) as 变量名:
            ...
        except:  (通常放在所有except之后)
            ...
        else:
            ...
        finally:
            ...
    做必须要做的事儿(执行必须要执行语句)
      try-finally语句
        try:
            ...
        finally:
            ...
       
  迭代器 iterator
    iter(可迭代对象)  返回的是迭代器
    next(迭代器)  从可迭代对象中取值
       在没有数据时会触发StopIteration异常

day15回顾
  生成器
    生成器函数
      含有yield 语句的函数
         1. 返回生成器对象(生成器对象也是可迭代对象)
         2. 执行顺序与普通函数不同
           1) 当next(it)函数调用时,生成器函数才执行
           2) 当遇到yield语句时,保存当前函数的执行状态,将yield 表达式 结果返回给next(it) 函数
           3) 生成器的返回会触发StopIteration异常
        def myyield():
            yield 1
            yield 2

    生成器表达式:
      (表达式 for 变量 in 可迭代对象 if ...)

迭代工具函数
  zip(*iterables)
    zip([1,2,3], "ABCDE")
        (1, 'A')
        (2, 'B')
        (3, 'C')
  enumerate(iterable, start=0)
    enumerate("ABC")
        (0, 'A')
        (1, 'B')
        (2, 'C')
    enumerate("ABC", 100)
        (100, 'A')
        (101, 'B')
        (102, 'C')


序列
  字节串 bytes
    不可变序列
    字面值:
      b''   b""    b''''''    b""""""
      b'hello'
  字节数组 bytearray
    可变的序列
  构造函数:
    bytes() / bytearray()
    bytes(整数可迭代对象)/bytearray(整数..)
    bytes(整数n) / bytearray(整数n)
    bytes(字符串,encoding='utf-8') /.....
  运算:
    +  += * *=
    < <= > >= == !=
    in / not in
    索引和切片

  字节
    0(0b00000000) ~ 255(0b11111111)

day16笔记:
文件
  长期存储数据
  单位是字节(byte)
  文件的操作:
    1. 打开文件
    2. 读/写文件
    3. 关闭文件
        释放资源(缓冲区, 内核资源)
  打开文件的函数:
    open(文件路径名, 打开模式)
  方法:
    F.close() 关闭文件
    # 读,仅在'r'模式下可用
    F.read([n]) 读取n个字节/n个字符
    F.readline()
    F.readlines()
    # 写,仅在'w', 'x', 'a' 模式下可用
    F.write(字节串/字符串)
    F.writelines([字节串/字符串元素])
    # 以下两个函数通常只对二进制模式文件操作
    F.seek(偏移量,起始位置)
    F.tell()  # 得到当前读写位置指针
   
    F.flush()  # 清空缓冲区

打开模式:
  二进制模式: 'b'
    把文件看成的字节数据,读写时会直接把磁盘数据以字节串形式返回或写入
   
  文本模式:   't'
    把文件看成是字符数据,读写过程中会自动编/解码(默认是'utf-8'),而且会把换行符进行自动转换


汉字编码
  只有两种:
    GB系列(国家标准)
      GB18030(GBK(GB2312))
    UNICODE系列(国际标准)
      UNICODE32(UNICODE16) <--> UTF-8互转

编码字符串:
   'gb18030', 'gbk', 'gb2312','utf-8', 'ascii' ...

编码注释:
  # -*- coding:gbk -*-

标准输入输出文件:
  sys.stdin
  sys.stdout
  sys.stderr

day17回顾:
面向对象
  对象 object(实例 instance)
    面向对象
  类 class
    类的定义的语句 class 语句

    class 类名(继承列表):
        # 实例方法
        def 实例方法名(self, 方法的形参):
            ...
        def __init__(self, 形参列表):
            ...
        def __del__(self):
            ...
           
           
构造函数:
  类名(调用传参)

对象的特征:
   行为(实例方法)
     吃,睡,
   属性(实例变量)
     姓名,年龄
 
  class Dog:
      pass
  dog1 = Dog()
  dog1.color = "白色"

del 语句:
  删除对象的属性

序置属性:
  __dict__ 属性
    绑定存储此对象的属性的字典
  __class__属性
    绑定创建此对象的类

函数:
  isinstance(对象, 类或元组)  判断对象是否属于某个类或某些类的一个类的实例
  type(对象)  # 返回一个对象的类

day18回顾:
  类
    类变量(类属性)
      特列的类变量
        __slots__ 列表
      预置的类变量:
        __doc__
        __base__
     
    类方法(@classmethod)
        @classmethod
        def get_v(cls):
            pass

  静态方法 @staticmethod
    依懒于类或此类的对象来调用
   
继承/派生
  继承可以直接使用父类的方法
  派生可以添加新的方法

单继承
  class 类名(只有一个父类):
      pass
  示例:
    class A:
       def a(self):
           pass
       def b(self):
           pass
    class B(A):
        pass
覆盖 override
   1.有继承
   2.子类中有同名的方法
   3.子类对象来调用同名的方法
     出现覆盖现象

super(类, 对象)
super()  # 等同于super(当前类, self)
   示例:
      class A:
          def m(self):
             print("A.m")
      class B(A):
          def m(self):
             print("B.m")
      class C(B):
          def m(self):
             print("C.m")
      c = C()
      c.m()  # C.m
      super(C, c).m()  # B.m
      super(B, c).m()  # A.m

day19回顾:
  issubclass(cls, 类或元组)  判断类的父子关系

面向对象编程语句的特征:
  封装
    __ 变量(实例变量(实例属性),类变量(类属性))
  继承
  多态

多继承
  支持多继承的语言(C++,Python)
  方法名冲突

class A:
    pass

__mro__ 类属性

函数重写
  让自定义的类添加相应的方法,让此类的对象能够使用内建函数进行操作
    repr
    str
    len
    abs
    round
    reversed
    int
    float
    bool
    complex
    next(it)    __next__(self)
    iter(obj)   __iter__(self)