Python 2 总结

python 2 官方2020年停止维护。
参考文献

基础知识

1. 现代计算机底层元件：晶体管（就是开关）

2. 冯诺伊曼计算机体系结构

   
   
   冯诺依曼体系
3. 编程规则

• 编程前要深思熟虑
• 程序要有可读性（方便自己以后看）

4. Python简介：1989年诞生，开源，最佳实践语言
5. 资源链接

• Python 官网
• 扩展包下载
• EPD（含模块）
• 数值计算 Python(x,y)
• 绘图包(使用前需先下载numpy)

开始使用

1. "Hello World!"：IDLE(GUI)中输入 print "Hello World!"

上面是Python 2.x版本写法，3.x是：print("Hello World!")

2. 快捷键：脚本中 CTRL+ S 保存，之后F5运行
3. 程序组成

• 模块：import math；math.+TAB可见所有备选（如math.pi）
• 表达式（x+5）和语句（x=5）
• 空白：换行符号（\\）
• 注释：单行（#）；多行（用三引号'''上下括起来）

4. 对象命名：字母、数字（数字不能作首字母）和下划线组合

骆驼拼写法：thisIsAnInteger

5. 变量创建：初次使用即创建（与Matlab类似）；type()返回变量类型

• int(整型)： 6
• float(浮点型)：0.66
• complex(复数)： 2+3j
• bool(布尔型)：True(1) or False(0)
• str(字符串)：'abc' or "abc"
• list(列表)：［'abc',4,3.5］
• tuple(元组)：('abc',4,3.5)
• dict(字典)：{"Adam":23,"Bob":24}
• set(集合)：set([1,3,5])

6. 运算符：**（方幂）；a+=2等价于 a=a+2
7. 数值计算符号表示 ：1/12=0 ； 1.0/12 ＝ 0.833...
8. 海龟绘图法

import turtle 
for i in range(4): 
    turtle.forward(50)
    turtle.right(90)

9.帮助：help(functioName)查看函数用法；help('moduleName')查看模块用法

控制语句

1. 语句分组通过缩进进行标识
2. 可使用关系链：0<=a<=5
3. 可多重赋值：a,b,c = 1,2,3
4. 可直接交换：a,b = b,a
5. Bool 关系符

• 非：not x
• 与：and x
• 或：or x

6. if 选择

if Bool expression: ...
else: ...

7. if 复合选择：if - elif - else
8. for 循环：for variable in set: ...
9. range(起始值，终值，步长)

• range(5) = [0,1,2,3,4]
• range(3,5) = [3,4]
• range(1,20,4) = [1,5,9,13,17]

10. while 循环

while Bool expression: ...
else: ... 

11. 跳出循环

• break: 跳出整个循环
• continue: 跳出本次循环
• 判断输入是否出错：变量名.isdigit()，变量是整数则为真

程序设计策略

1. 参与并提交

• 针对问题做好准备，坚持，不轻易放弃
• 找不会被中断的时间工作
• 若效率不高，则改变策略，或稍事休息
• 专注于问题，调整好情绪

2. 了解，然后想象

• 理解问题：陈述，联想已有算法，输入输出等问题
• 问题真实化：举例，图表，尝试

3. 编程之前先思考：拒绝“牛粪球”代码
4. 试验：不必一次完成，多尝试
5. 简化：问题分解，分而治之（“洋葱”法）
6. 停下来思考
7. 放松，休息。

函数

1. 为什么要使用函数 —— 函数的特点

• 分而治之的策略
• 抽象（封装性）：只需会用，不必懂原理
• 重用：可以反复调用
• 共享：别人也可以调用
• 安全性：小段的代码容易检验是否出错
• 简化（可读性）：封装过后的程序更可读

2. 使用：先定义，后调用

def testFunc(Num):
    return Num * 3

3. main：主程序本身也可以作为函数，在Python中创建独立脚本时很有用

def main():
    main()

4. 作用域：包含某个变量的程序语句集合. 每个程序都有自己的命名空间，用来定义变量的作用域.

• 输入已知函数名+'.'+TAB，即可查看相关的方法和变量
• 双下划线是Python的保留属性
  • __name__：与函数相关联的名称
  • __dict__：函数的命名空间
  • __doc__：文档字符串（查询函数） ，math.pi.__doc__

5. Python传递的是对象引用：Python的一切皆为对象，所以每个值的传递都是对象的引用. 对象在这个过程中不可复制.

• 如果对象可变，在函数中所做的更改将反映在对象的外部作用域
• 如果对象不可变，当更新引用时，将指向新的对象

数据结构 1：字符串

1. 以单引号或者双引号表示字符串
2. 三引号：将保存所有字符的格式信息（字符串若跨行，则回车符也会保存）
3. 非显示字符：回车：\n；制表：\t
4. 字符串表示形式：每个字符都以数字形式（ASCII码）存储

• ord('a') = 97
• chr(97) = 'a'
• 索引

'Hello World'[1] = 'e'
Hello World
012345678910

• 扩展索引 'Hello World'[起始位置:结束位置:步长]

5. 分片：字符串序列要包含结束符，即每次分片时要多含一位

• 'Hello World'[0:5] = 'Hello'
• 'Hello World'[6:] = 'Hello World'[6:11] = 'Hello'
• 倒数索引 'Hello World'[-1] = 'Hello World'[10] = 'd'
• 字符串操作
  • ＋：连接
  • *：重复
  • in：检查集合成员

6. 函数：len(myStr)，求长度；方法：myStr.upper()，转成大写
7. 方法链：myStr.upper().find('s')；查找方法：myStr.+TAB
8. 格式化输出：print "format string % (data1,data2,..)
   例：print "%s is %d years old." % ("Bill",25)

• %s 字符串 ；%10s，10个空格（右对齐）
• %d 十进制整数
• %f 浮点小数 ；%.4f，4位有效小数
• %e 浮点指数

9. 字符串集合是不可变的：无法通过索引赋值，必须复制所选内容.

数据结构 2：列表和元组

1. 什么是列表？

• 列表是数据集类型之一，可以混合不同类型元素
• 创建：aList = [1,2,'a',3,14]
• 二维列表：listOfList[1][2]

2. 列表特性

• 列表的索引，分片和运算符与字符串基本一致
• 列表也可用于for循环：for n in [1,3,4,7]
• 可变性：列表对象可发生改变，可对其赋值，如 aList[0] = 1

3. 列表方法（后缀）

• 查找：index()，返回与x相等的第一个索引；
• 统计：count()，统计x出现的次数；
• 添加（末尾）：append()，末尾添加元素；extend()，末尾添加集合；
• 插入：insert(i,x)，在索引i处插入x；
• 删除：pop()，删除末尾元素；remove(x)，删除第一个x；
• 排序：sort()；reverse()，反向排序；

4. 列表与字符串转换

• result = 'I love you'.split() = ['I','love',''you]
• newStr = ''.join(result) = 'I love you'

5. 可变对象及其引用

• 对引用可变对象的变量进行操作，可能会改变对象本身，或者创建一个新的对象；
• 对引用不可变对象的变量进行操作，只会创建新的对象

6. 拷贝（复制）在Python中就是为对象添加新的名字
   注：Python中的命名空间由名字列表和对象列表组成；

L =[1,2,3]
L = L + [9]  #创建了新对象
L.append(9)  #仅改变了对象

7. 列表解析：用紧凑的方式构造列表 ［表达式 + for子句 + if条件］

［i for i in range(10) if i % 2 == 0］
 >>> [0,2,4,6,8]

8. 元组：myTuple = (1,2,3)

• 元组是不可改变的列表
• 单元素原元组：Tuple1 = (1,)
• 为何需要元组：可为需要的地方提供不可变对象（如字典键）
• 从列表到元组：tuple1 = tuple([6,1,3,4])

数据结构 3：字典和集合

1. 字典：可变的数据结构

• 字典可看成是成对元素的列表：dict = {(button,value)}
• 键映射到值，类似于手机通讯录
• 键可为不同元素类型，但只能是不可改变的对象：整数，字符串或元组
• 键的顺序不重要，关键在于键与值的关联
• 创建：contacts = {'Sandy':'123', 'Balian':'456'}
• 引用（利用键） contacts['Sandy']
• 添加 contacts['Piao'] = '789'
• 创建空字典 Dict = { } 或 Dict = dict()

2. 字典方法

• 字典列表：items()
• 键列表：keys()
• 值列表：values()
• 浅拷贝字典：copy()

3. 集合：可变的数据结构

• 集合内元素不限定类型，没有顺序
• 集合上不能索引赋值，但有其他方法可以改变集合内的元素

4. 集合方法

• 交：aSet.intersection(bSet)
• 并：union
• 差：difference， aSet.difference(bSet) = A\B
• 对称差(收集两个集合中不共享的元素)：symmetric_difference
• 子集和超集： A.issubset(B) = B.issubset(A) (A包含于B)
• 添加：add(element)
• 删除：discard(element)；clear()，删除所有元素
• 浅拷贝：copy()

5. 再谈作用域

• 命名空间是名称和对象的关系. 如果有多个命名空间，则可定义搜索顺序，依次在不同的命名空间中来查找某个名称. 这一过程在Python中定义为作用域.
• 作用域搜寻规则：LEGB
  • L(Local)局部：函数内部
  • E(Eclosing)封闭：在函数中定义的函数内部
  • G(Global)全局 __main__模块：函数内使用global语句可将变量声明为全局性质
  • B(Built-in)内置 __builtins__模块
• Python在模块中维护命名空间. 当Python解释器启动时，将自动导入__main__和__builtins__模块. 每个模块自带一个命名空间，用来存放模块中所有的名称和对象.
  • __main__是默认的全局模块，用来存储所有新对象.
  • __builtins__为所有程序和数据类型提供链接.
  • var.__dict__即为命名空间.
• Python指针：使用zip创建字典

keys = ['red', 'white', 'blues']
values = [100,300,500]
d = dict(zip(keys,values)) = {'blues':500, 'white':300,'red':100} 

文件

1. 文件：由字节组成的信息.

• 文本文件：ASCII数据或其他
• 二进制文件：word文档

2. 读取：testFile = open('temp.txt',"r")

• 循环逐行

for line in testFile:
    print line
testFile.close()

• testFile.read()：一次性读取，返回一个字符串
• testFile.readline()：每次读取一行. 如果之后接for循环，则for从readline结束后的位置开始. 主要用于跳过标题行.

3. 写

dataFile = open('temp2.txt',"w")
s = 'first line'
dataFile.write(s)
dataFile.close()

4. 创建与重写

• 模式

模式	操作	若文件不存在	是否覆盖
r	只读	报错	-
r+	可读可写	报错	是
w	只写	创建	是
w+	可读可写	创建	是
a	只写	创建	否，追加写
a+	可读可写	创建	否，追加写

• 通用换行格式：为解决不同操作系统下行结束符号不一致的问题
  fd = open('File.txt','rU')
• 文件内移动（方法）
  tell：找出当前文件位置和文件开始位置之间的相对位置
  seek：将当前文件位置设为文件对象缓冲区中的新位置

5. 关闭文件：open函数在内存中创建缓存区，将磁盘内容复制到此位置. 关闭文件，则内存缓存区的所有内容写回瓷盘，保持同步.
6. CSV文件：是文本文件格式，有CSV拓展模块支持.
7. OS模块（Operating System） —— Python标准模块

• 操作系统的功能之一是维护文件的组织结构.
• 目前操作系统将文件置于目录（Linux或OS-X）或文件夹(Windows)中.
• 目录结构层次 —— 树
  OS-X:/punch/Python/ex1.py
  windows：c: \\punch\\python\\ex1.py
• 若当前目录为 /punch/python/，则：
  . = 当前目录 = /punch/python/
.. = 父目录 = /punch/
• os模块函数
  os.getcwd()：获取当前目录
  os.chdir("...")：更改目录
  os.listdir("...")：列出给定路径的节点中所有文件和目录

类：自定义数据结构和算法

1. 面向对象编程(OOP)：Python基本算是OOP语言

• OOP认为程序由独享组成，每个对象都可与其他对象交互.
• 每个对象都可以：将代表此对象的值集合起来；执行该对象的动作.
• 对象特点：属性（如颜色）；针对自己的命令作出反应（如输出）
• OOP特性
  封装性：封装细节，通过接口访问；
  多态性：运算符或方法根据调用其的对象类型执行不同的操作；
  继承性：允许基于类的特点创建另一个类.

2. 类和实例

• 类（class）是建立新对象的模版.
• 利用类模版创建的对象称为该类的实例（instance）.
• 类定义 class 类名（父对象）：代码块 class myClass(object): pass
• class是第三个能在命名空间建立新关联的关键字（除赋值和def）
• 关键词 pass：表示该代码块为空.
• 创建实例：myInstance = myClass()
• dir(myClass)可查看类和实例包含的属性
• 修改属性（点标记）： myClass.classAttribute = 'hello'
• Python对象作用域规则：先实例，然后类.

3. 对象方法：定义类对象操作的函数称为方法

• 自定义方法：即在类内部定义函数

class myClass (object):
    def myMethod (self,param1)
        print "hello %s"  % (param1)
        self.instanceAttribute = param1
myInstance = myClass()
myInstance.myMethod('world')

4. 融入Python类模型：Python保留了一些方法（开始和结束都是双下划线）
   __init__：初始化
   __str__：字符串方法，常用于输出
5. Python的OOP细节

• OOP的公有与私有：编程世界的三种角色（用户，程序员，类设计者）
  • 程序员只知道类的接口
  • 类设计者需要控制和保护类的内部结构，而不是类提供的方法
  • 私有属性（方法，变量）只提供给类设计者
• 使用双下划线表示私有
  • Python中所有的方法和实例，类设计者和程序员都能访问；
  • 当属性用双下划线作为前缀时，不要试图修改它！
• Python的宗旨是“我们都是成年人”： 类设计者若表示什么是私有的，程序员不要试图修改.
• Python可修改实例：不同于其他OOP语言.

异常处理

1. 错误

myStr = int(raw_input("number:"))
number: a
>>> ValueError

当程序运行出错时，Python先搜索程序员提供的相应错误处理程序. 如果找到，则将控制权交给这些代码；否则，Python会停止运行.

2. 基本的错误处理：try-except语句

try:
    dividend = float(raw_input("dividend: "))
    divisor = float(raw_input("divisor: "))
    result = dividend / divisor
except ZeroDivisionError:
    print "Divided by 0 error"
except ValueError:
    print "Value Error"
print "Continue"

注：先看try代码块，无错误则跳过所有except；有错，则停止在出错行，寻找相应except语句，执行并跳过其他except；找不到则停止运行并报错.

3. except后的错误名是Python给定的. 起始发现错误最简单的方法就是故意产生错误，然后查看Python给出的错误名称.
4. 两种处理错误的方式

• LBYL：三思而后行（新手）

if not isinstance(s,str) or not s.isdigit:
    return None
elif len(s) > 10:
    return None
else:
    return int(str)

• EAFP：要求宽恕

try:
    return int(str)
except (TypeError,ValueError,OverFlowError):
    return None

5. try-except复合语句

try:...
except:...
else: #try代码块不出错，则执行此代码块，并继续
finally: #在try-except(-else)结束后要绝对执行的代码块

6. 应用

• 检查输入：反复输入，直至正确.

while True:
    try:
        alueStr = raw_input("Input integer:")
        alueInt = int(valueStr)
        break
    except ValueError:
        print "Bad input"

• 检查文件打开

while True:
    try:
        fileName = raw_input("Open a file:")
        open(fileName,"r")
    break
    except IOError:
        print "Bad file name"

• raise exceptionName ：可主动引发异常
• 自定义异常：Python中的异常是类. 创建异常，就是产生现有异常的子类.

class NewException(Exception): 
    pass