Python Diary

1 Python基本语法元素

1.1 程序设计的基本方法

1.1.1 编译和解释
  源代码：采用某种编程语言编写的计算机程序，人类可读
    例：result = 2 + 3
  目标代码：计算机可直接执行，人类不可读（专家除外）
    例：11010010 00111011
  编译：将源代码一次性转换成目标代码的过程

  解释：将源代码逐条转换成目标代码同时逐条运行的过程

  静态语言：使用编译执行的编程语言，编译器一次性生成目标代码，优化更充分，程序运行速度更快
    例：C  C++  Java
  脚本语言：使用解释执行的编程语言，执行程序时需要源代码，维护更灵活，可跨多个操作系统平台
    例：Python  Javascript  PHP

1.1.2 程序的基本编写方法
  IPO
    Input输入，程序输入
    Process处理，程序的主要逻辑
    Output输出，程序的的输出
  编程解决问题步骤
    （1）分析问题：分析问题的计算部分
    （2）划分边界：划分问题的功能边界，规划IPO
    （3）设计算法：设计问题的求解算法
    （4）编写程序：编写问题的计算程序，编程
    （5）调试测试：调试程序使正确运行，运行调试
    （6）升级维护：适应问题的升级维护，更新完善

1.2 Python开发环境配置

1.2.1Python的两种编程方式
  交互式：对每个输入语句即使运行结果，适合语法练习
  文件式：批量执行一组语句并运行结果，编程的主要方式

1.3 Python程序语法元素

1.3.1程序的格式框架
  代码高亮：编程的色彩辅助体系，不是语法要求
  缩进：一行代码开始前的空白区域，表达程序的格式框架
     严格明确：缩进是语法的一部分，缩进不正确程序运行错误
     所属关系：表达代码见包含和层次关系的唯一手段
     长度一致：程序内一致即可，一般用4个空格或1个TAB（单程序中缩进长度一致）
  注释：不被执行的辅助性说明信息
     单行注释：以#开头，其后为注释语句
     多行注释：以'''开头和结尾
  命名：变量采用标识符来表示，关联标识符的过程叫命名。
     规则：大小写字母，数字，下划线和汉字等字符及组合
     注意：大小写敏感，首字符不能是数字，不与保留字相同 
  保留字：被编程语言内部定义并保留似乎用的标识符，33个保留字

2 Python基本图形绘制

2.1 Turtle库

2.1.1 Turtle库简介
  Turtle库是turtle绘图体系的Python实现，是Python语言的标准库之一

2.1.2 Turtle绘图窗体
  turtle.setup(width, height, startx, starty)      左上角为屏幕原点

2.1.3 Turtle窗体空间坐标系
  绘图窗体中心为坐标原点，向右为x正方向，向上为y正方向

2.1.4 Turtle窗体海龟坐标系
  当前位置分为前后左右四个方向

2.1.5 Turtle窗体角度坐标系
   与平面坐标系角度划分相同  

2.1.6 RGB色彩模式   
  RGB指红蓝绿三个通道的颜色组合，覆盖视力所能感知的所有颜色，RGB每色取值范围0-255整数或0-1小数

2.2 Turtle库的使用

2.2.1 库引用 import
  扩充Python程序功能的方式，使用import保留字完成，采用<a>.<b>()编码风格
      import <库名>
      <库名>.<函数名>(<函数参数>)

  使用from和import保留字共同完成
      from <库名>import<函数名>
  或 from <库名>import*
      <函数名>(<函数参数>)

  使用import和as保留字共同完成
      import<库名>as<库别名>
      <库别名>.<函数名>(<函数参数>)

2.2.2 画笔函数
   画笔操作后一直有效，一般成对出现
      turtle.penup()  =  turtle.pu()      开始
      turtle.pendown() = turtle.pd()     结束

  画笔设置后一直有效，直至下次重新设置
      turtle.pensize(width)  =  turtle.width(width)    控制画笔宽度

  画笔设置后一直有效，直至下次重新设置
      turtle.pencolor(color)    color 为颜色字符串或RGB值

2.2.3 运动控制函数
   直线：turtle.forward(d)  =  turtle.fd(d)     d为型近距离，可为负数
   曲线：turtle.circle(r,extent=None)     根据半径r绘制extent角度的弧形
             r：默认圆心在海龟左侧r距离的位置
             extent：绘制角度，默认是360度整圆

2.2.4 方向控制函数
    绝对角度控制：turtle.srtheading(angle)  =  turtle.seth(angle)    改变行进方向
                           angle：改变行进方向，海龟走角度
    海归角度控制：turtle.left(angle)     左转
                           turtle.right(angle)    右转
                           angle：旋转的角度

3 基本数据类型

3.1 数字类型及其操作

 3.1.1 整数类型
     十进制：1010，99，-217
     二进制：以0b / 0B 开头，  0b010，-0B101
     八进制：以0o / 0O 开头，  0o123，-0O456
     十六进制：以0x / 0X 开头，0x9a， -0X89
     注：整数无限制
            pow(x,y) : x的y次幂

 3.1.2 浮点类型
     浮点数-->实数
     浮点数的取值范围和小数精度存在限制，常规计算可忽略
     取值范围：-10^308---10^308
     精度：10^-16
     注：浮点数间运算存在不确定尾数
     round(x,d): 对x四舍五入，d是小数截取的位数
     科学计数法：<a>e<b> 表示 a*10^b
                          4.3e-3 = 0.0043
 
  3.1.3 复数类型
     a+bj
     j^2 = -1
 
   3.1.4 数值运算符
       加：+
       减：-
       乘：*
       除：/     整数的商为浮点型      10 / 3 = 3.3333333335
       整数除：//  商为整型         10 // 3 = 3
       模运算：%
       幂运算：**       x**y   表示x的y次幂
       二元操作和C语言相同

   3.1.5 数字类型关系
       类型间可进行混合运算没生成结果为 最宽 类型
       整数<浮点数<复数

   3.1.6 数字类型操作函数
        abs(x)  绝对值函数
        divmod(x,y)  商余函数  同时输出商和余数   divmod(10,3) = (3,1)
        pow(x,y[,z])   幂余函数  (x**y)%z          [..] 表示内容可省略
        round(x[,d])   四舍五入函数，d是保留小数位数，默认值为0
        max(x1,x2,...,xn)    最大值函数，n无限
        min(x1,x2,...,xn)     最小值函数，n无限
        int(x)     整数函数    将x变成整数，舍弃小数部分      int(123.45) = 123    int("123")=123
        float(x)    浮点函数   将x变成浮点数，增加小数部分    float(12) = 12.0     float("1.23")=1.23
        complex(x)   复数函数   将x变成负数，增加虚数部分   complex(4) = 4 + 0j

3.2 字符串类型及其操作

3.2.1 字符串类型表示
  由一对单引号或双引号表示，仅表示单行字符串
  由一对三引号或三双引号表示，可表示多行字符串
  注：正向递增序号 和 反向递减序号
         使用[]获取字符串中一个或多个字符
  字符串切片：
        <字符串>[M:N]    M缺失表示至开头，N缺失表示至结尾
        <字符串>[M:N:K]    根据步长K对字符串切片
         注 [::-1] 可使字符串逆序
  转义字符
         "\b"  回退
         "\n"  换行
         "\r"   回车
         
3.2.2 字符串操作符
   x + y    连接两个字符串x和y
   n * x 或 x * n  复制n次字符串x
   x in s    如果x是s的字串，返回True，否则返回False
   
3.2.3 字符串处理函数
   len(x)  长度函数
   str(x)   字符串转化函数       str(1.23)="1.23"
   hex(x)     十六进制转换函数     hex(425) = "0x1a9"
   oct(x）    八进制转换函数        oct(x) = "0o651"
   
3.2.4 字符串处理方法
   str.lower()                      小写函数          "ABCD".lower() = "abcd"
   str.upper()                      大写函数
   str.split(sep=None)         返回列表函数  由str根据sep被分割的部分组成     "A,B,C".split(",") = ['A','B','C']
   str.count(sub)                 计数函数   sub在str中出现的次数    "an apple a  day".count("a") = 4
   str.replace(old,new)        替换函数   将所有old字串被替换为new   "python".replace("n","n123.io") = "python123.io"
   str.center(width[,fillchar])   字符串str根据宽度width居中，fillchar可选    "python".center(20,"=") = '========python======'
   str.strip(chars)                 从str中去掉在其左侧和右侧chars中列出的字符     "= python=".strip(" =np") = "ytho"
   str.join(iter)                     在iter变量除最后元素外每个元素后增加一个str      ",".join("12345") = "1,2,3,4,5"

3.2.5字符串类型的格式化
  <模板>.format()
   槽 {}  
   填充：{:=}
   对齐：<左对齐    >右对齐    ^居中对齐
   宽度：{:number}
   <,>: 数字千位分割符
   精度：{:.0f}
   类型：整型：b,c,d,o,x,X,         浮点型：e,E,f,%

3.3 time库的使用

3.3.1 time库简介
  time库是Python中处理时间的标准库
  三种功能：
     计算机时间的表达
     提供获取系统时间并格式化输出功能
     提供系统级精确计时功能，用于程序性能分析
  调用格式：
  import time
  time.<b>()

3.3.2 time 库使用
  时间获取：time()    ctime()    gmtime()
  时间格式化：strftime()    strtime()
  程序计时：sleep()     perf_counter()

3.3.3 时间获取
   time()     获取当前时间截，即计算机内部的时间值，浮点数
   ctime()    获取当前时间并以易读的方式表示，返回字符串      time.ctime() = 'Fri Jan 26 12:11:16 2018'
   gmtime()   获取当前时间，表示为计算机可处理的时间格式

3.3.4 时间格式化    
   将时间以合理的方式展示出来
   strftime(tpl,ts)    spl是格式化模板字符串，用来定义输出效果   ts是计算机内部时间内类型变量
                             t = time.gmtime()
                             time.strftime("%Y-%m-%d %h:%M:%S",t)
                             '2018-04-26 12:55:20'
      注：%Y        年份                   0000~9999
             %m      月份                    01~12
             %B       月份名称             January~December
             %b       月份名称缩写      Jan~Dec
             %d       日期                   01~31
             %A       星期                   Monday~Sunday
             %a       星期缩写             Mon~Sun
             %H      小时（24h制）    00~23
             %I       小时（12h制）     01~12
             %p      上/下午                00~23
             %M     分钟                     00~59
             %S       秒                        00~59
             
 3.3.5 程序计时
    参加鞥需及时指测量起止动作所经历时间的过程,在cpu中获取时间，精确ms
    perf_counter()       返回一个CPU级别的精确时间计数值，单位为秒，由于这个计数值起点不确定，连续调用差值才有意义
                                 start = time_counter()
                                 end = time_counter()
                                 end - start
   sleep(s)                  s拟休眠的时间，单位是秒，可以是浮点数
                                 def wait():
                                       time.sleep(3.3)
                                  wait()          #程序等待3.3秒后退出

4 程序的控制结构

4.1 程序的分支结构

4.1.1 单分支结构
    if <条件>:
       <语句>
    if Ture：   一定执行
    
4.1.2 二分支结构 
    if <条件>:
       <语句>
    else:
       <语句>  
    紧凑形式：<表达式1> if <条件> else <表达式2>  
                   
4.1.3 多分支结构
    if <条件1>:
       <语句1>
    elif <条件2>:
        <语句2>
     .
     .
     .
    else:
        <语句n>  
        
4.1.4 条件判断及组合
    <               小于
    <=            小于等于
    >              大于
    >=            大于等于
    ==            等于
    !=             不等于
    and           逻辑与
    or              逻辑或
    not            逻辑非

4.1.5 异常处理
    try:
         <语句块1>
    except <异常类型>:
         <语句块2>
     else :
           <语句块3>
     finally：
            <语句块4>

4.2 程序的循环结构

4.2.1 遍历循环
   for  <循环变量>  in  <遍历结构>:
         <语句块>
     
   计数循环：
          for i in range(M,N,K):
                <语句块>
          注：M 起点
                 N 终点
                 K 步长
                 M<=i<N
        
    字符串遍历循环：
           for  c  in  s :
                 <语句块>
           注：s字符串

    列表遍历循环：
          for  item  in  ls :
                 <语句块>
          注：ls 列表
       
     文件遍历循环：
         for  line  in fi :
                 <语句块>

  4.2.2 无限循环
     while <条件>:
              <语句块>
      
  4.2.3  循环控制保留字
      break 跳出并结束当前循环，执行循环后的语句
      continue 结束当此循环，继续执行后续次数循环
  
  4.2.4 循环的扩展
    for  <循环变量>  in  <遍历结构>:
          <语句块1>     
     else:
           <语句块2>     


     while <条件>:
              <语句块1>
      else:
           <语句块2>   

      注：当循环没有遇到被break语句退出时，执行else语句

4.3 Random库的使用

4.3.1 Random库概述
   random库是使用随机数的Python标准库
   伪随机数：采用梅森旋转算法生成的（伪）随机序列中元素

4.3.2 Random 基本随机函数
    随机数种子-->梅森旋转算法-->随机序列（确定的）
    
    seed(a = None)    初始化给定的随机数种子，默认为当前系统时间
    random()               生成一个[0.0,1.0)之间的随即小数    
 
4.3.3 Random 扩展随机函数
    randint(a,b)                    生成一个[a,b]之间的整数
    randrange(m,n[,k])        生成一个[m,n)之间以k为步长的随机整数
    getrandbits(k)                生成一个K比特长的随机整数
    uniform(a,b)                   生成一个[a,b]之间的随即小数
    choice(seq)                     从序列seq中随机选择一个元素
    shuffle(seq)                     将序列seq中元素随机排列，返回打乱后的序列

5 函数和代码复用

5.1 函数的定义与使用

5.1.1 函数的定义
  函数是一段具有特定功能的，可重用的语句组
  函数是一种功能的抽象，一般函数表达特定的功能
  两个作用：降低变成难度 和 代码复用
  
  def <函数名> (<参数(0个或多个)>) ：
        <函数体>
        return <返回值>

5.1.2 函数的调用
  调用是运行函数代码的方式
  
5.1.3 函数的参数传递
  函数可以有参数，也可以没有，但必须保留括号

  可选参数传递：
        函数定义时可以为某些参数指定默认值，构成可选参数
        def <函数名> (<非可选参数>,<可选参数>) ：
             <函数体>
             return <返回值>

  可变函数传递：
        函数定义时可以设计可变数量参数，既不确定参数总数量
        def <函数名> (<参数>，*b) ：
              <函数体>
              return <返回值>

  参数传递的两种方式：
         位置传递，名称传递

5.1.4 函数的返回值
   函数可以返回0个或多个结果
   return可以传递0个返回值，也可以传递任意多个返回值
      return  a,b,c....      返回为 元组类型   （a,b,c...)

5.1.5 局部变量和全局变量
   局部变量：函数内部使用的变量
   全局变量：函数内外部整个程序使用的变量
   注：函数运算结束后，局部变量被释放
          局部变量和全局变量可以重名，但也是不同的变量，作用范围不同
   global 声明变量为全局变量
   局部变量为组合数据类型且未创建，等同于全局变量

5.1.6 lambda 函数
   lambda函数返回函数名作为结果
   注：lambda函数是一种匿名函数，即没有名字的函数
          使用lambda保留字定义，函数名是返回结果
          lambda函数用于定义简单的，能够在一行内表示的函数
   <函数名> = lambda <参数> : <表达式>

5.2 代码复用与函数递归
  5.2.1 代码复用与模块化设计
    代码资源化，代码抽象化
    代码复用：函数 和 对象 是代码复用的两种主要形式
    模块化设计：通过函数或对象封装将程序划分为模块及模块间的表达，具体包括主程序，子程序和子程序间的关系
    紧耦合：两个部分之间交流很多，无法独立存在
    松耦合：两个部分之间交流较少，可以独立存在
    模块内部紧耦合，模块之间松耦合

  5.2.2 函数递归的理解
    链条：计算过程存在递归链条
    基例：存在一个或多个不需要再次递归的基例

  5.2.3 函数递归的调用
    函数 + 分支语句

5.3 PyInstaller 库的使用

5.3.1 PyInstaller 概述
   将.py源代码转换成无需源代码的可执行文件
   Windows：.py->.exe

5.3.2 PyInstaller 使用说明
   (cmd命令) pyinstaller -F <文件名.py>
   常用参数：
          (cmd命令) pyinstaller -h                              查看帮助
          (cmd命令) pyinstaller --clean                      清理打包过程中的临时文件
          (cmd命令) pyinstaller -D,--onedir               默认值，生成dist文件夹
          (cmd命令) pyinstaller -i <图标文件名.ico>  指定打包程序使用的图标（ico）文件