Python3——2019年全国大学生计算二级考试

Python语言程序设计二级重点（2019年版）

第一章 程序设计基本方法

1. IPO程序编写方法 ：输入(input)，输出(output)，处理(process)；
2. Python程序的特点:
   
   （1）语法简介；（2）生态丰富；（3）多语言集成；（4）跨平台；（5）强制可读；（6）支持中文；（7）模式多样；（8）类库便捷。

第二章 Python语言基本语法

1. 程序的格式框架
   
   (1)缩进(4个空格)；(2)注释(#)；(3)续行符(\)；
2. 语法元素的名称

(1)变量：变量是保存和表示数据值的一种语法元素，变量的值是可以改变的，能够通过赋值(=)方式被修改例如：

>>>a = 99
>>>a = a + 1
>>>print(a)
100

(2)命名：给变量或其他程序元素关联名称或标识符的过程

Python采用大小写字母、数字、下划线和汉字等字符及其组合进行命名，但名字的首字符不能是数字，标识符中间不能出现空格

(3)保留字：也叫关键字共有35个，大小写敏感。

and 、 as、 assert 、break、 class、 continue、 def、 del、 elif、 else、 except、 False、 Ture、 finally、 for、 from、 global、 if、 import、 in、 is、 lambda、 None、 nonlocal、 not、 or、 pass、 raise、 return、 try、 while、 with、 yield、 async、 await

1. 数据类型
   
   (1)数字类型: 整数，浮点数，复数
   
   整数：一个整数值可以表示为十进制(1010)、十六进制(0x3F2)、八进制(0o1762)、二进制(0b001111110010)。
   
   浮点数：只有科学计数法(1.23456e2)和十进制形式
   
   (2)字符串类型：在Python语言中采用一对双引号""或者一对单引号''括起来的一个或多个字符表示。
   
   作为字符序列，字符串可以对其中单个字符或字符片段进行检索。字符串包括两种序号体系：正向递增序号(最左侧序号为0)和反向递减序列(最右侧序号为-1)

>>>"对酒当歌，人生几何？"[1]
酒
>>>"对酒当歌，人生几何？"[-1]
?
>>>"对酒当歌，人生几何？"[2:4]
当歌
>>>"对酒当歌，人生几何？"[5:-2]
人生几
>>>"对酒当歌，人生几何？"[2:2]
''

1. 程序的语句元素
   
   (1)表达式

>>>1024*32
32768
>>>"对酒当歌，人生几何？"+"譬如朝露，去日苦多。"
对酒当歌，人生几何？譬如朝露，去日苦多。
>>>1024>32
True

(2)赋值语句(<变量>=<表达式>)

(3)引用: import <功能库名称>

(4)其他语句：详细介绍请看第四章

分支语句 循环语句

单分支

>>>#判断输入整数是否在[0,100]之间
>>>num = eval(imput("请输入一个整数："))
>>>if 0 <= num <=100:      #判断[0,100]
>>>    print("输入的整数在0到100之间")
>>>

二分支

>>>num = eval(input("请输入一个数字："))
>>>if num > 100:
>>>    print("输入的数字大于100")
>>>else:
>>>    print("输入的数字小于等于100。")
>>>

多分支

 >>>num = eval(imput("请输入一个整数："))
 >>>if num > 100:
 >>>   print("输入的数字大于100")
 >>>elif num = 100:
 >>>   print("输入的数字等于100")
 >>>else:
 >>>   print("输入的数字小于100")

1. 基本输入输出函数
   
   输入：input()
   
   转换：eval(s) #去掉字符串s最外侧的引号并执行去掉引号后的字符内容

>>>a = "1+2"
>>>print(a)
'1+2'
>>>b = eval("1+2")
>>>print(b)
3

输出：print()

第三章 基本数据类型

1. 数字类型
   
   整数类型：十进制、二进制(0b)、八进制(0o)、十六进制(0x)
   
   浮点数类型：十进制或科学记数法表示 ； 必须带有小数部分，小数部分可以为0
   
   复数类型：基本单位元素为j，实部和虚部都是浮点类型，可用z.real和z.imag分别获得它的实部部分和虚部部分

2. 数值运算操作符：

操作符及运算	描述
x + y	x与y之和
x - y	x与y之差
x * y	x与y之积
x / y	x与y之商，产生结果为浮点数
x // y	x与y之整数商，即：不大于x与y之商的最大整数
x % y	x与y的最大余数，也称为模运算
-x	x的负值，即：x * (-1)
+x	x本身
x ** y	x的y次幂

数值运算的基本规则：

整数和浮点数混合运算，输出的结果是浮点数；
整数之间运算，产生的结果类型与操作符想过，除法运算(/)的结果是浮点数；
整数或浮点数与复数运算，输出结果是复数；
所有的二元运算操作符（+、- 、* 、/ 、// 、% 、** ）都可以与赋值符号(=)相连，形成增强赋值操作符   #增强赋值操作符中的二元运算操作符与赋值符号之间没有空格。

1. 数值运算函数
   
   Pythin内置函数：

函数	描述
abs(x)	x的绝对值
divmod(x, y)	( x//y, x%y ),输出为二元组形式（也称为元组类型）
pow(x, y) 或 pow(x, y, z)	x ** y 或 (x ** y) % z, 幂运算
round(x) 或 round(x, d)	对x四舍五入，保留d位小数，无参数d则返回四舍五入的整数值
max(x1 ,x2, ··· ,xn)	x1,x2,···,xn的最大值，n没有限定，可以任意数量
min(x1 ,x2, ··· ,xn)	x1,x2,···,xn的最小值，n没有限定，可以任意数量

1. 字符串类型及格式化
   
   单行字符串：用一对单引号(') 或 双引号(")作为边界表示；
   
   多行字符串：用一对三引号(''') 或 三双引号(""")作为边界表示；

字符串的索引方式如下:

<字符串或字符串的变量>[序号]

>>>"青青子衿，悠悠我心。"[-5]      #注意：标点符号也是字符
'悠'
>>>s = "青青子衿，悠悠我心。"
>>>s [5]
'悠'
>>>

字符串的切片：

<字符串或字符串变量>[N:M] 切片获取字符串从N到M(不包括M)的子字符串

>>>"青青子衿，悠悠我心。"[1:4]
'青子衿'
>>>"青青子衿，悠悠我心。"[8:4]
''
>>>"青青子衿，悠悠我心。"[:4]
'青青子衿'
   print("青青子衿，悠悠我心。"[5:])
悠悠我心。

format()方法的基本使用：

<模板字符串>.format(<逗号分隔的参数>)，模板字符串是由字符串和槽({})组成的字符串，例如：

>>>"{}曰:学而时习之，不亦说乎。".format("孔子")
'孔子曰:学而时习之，不亦说乎。'
>>>"{}曰:学而时习之，不亦{}。".format("孔子","说乎")
'孔子曰:学而时习之，不亦说乎。'
>>>"{1}曰:学而时习之，不亦{0}。".format("说乎"，"孔子")
'孔子曰:学而时习之，不亦说乎。'
>>>

1. 字符串类型的操作
   
   基本的字符串操作符：

操作符	描述
x + y	连接两个字符串 x与y
x * n 或 n * x	复制n次字符串x
x in s	如果x是s的子串，返回True，否者返回False

字符串处理函数：

函数	描述
len(x)	返回字符串x的长度，也可以返回其他组合数据类型的元素个数
str(x)	返回任意类型x所对应的字符串形式
chr(x)	返回Unicode编码x对应的单字符
ord(x)	返回单字符x表示的Unicode编码
hex(x)	返回整数x对应十六进制数的小写形式字符串
oct(x)	返回整数x对应八进制数的小写形式字符串

字符串处理方法：

方法	描述
str.lower()	返回字符串str的副本，全部字符小写
str.upper()	返回字符串str的副本，全部字符大写
str.split( sep = None)	返回一个列表，通过指定分隔符对字符串进行切片，省略sep默认以空格分隔
str.count(sub)	返回sub子串出现的次数
str.replace(old, new)	返回字符串str的副本，所有的old子串被替换为new
str.center(width, fillchar)	字符串居中函数，fillchar参数可选
str.strip(chars)	用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列
str.join(iter)	将iter 变量的每一个元素后增加一个str字符串

1. 类型判断和类型间转换

函数	描述
int(x)	将x转换为整数，x可以是浮点数或字符串
float(x)	将x转换为浮点数，x可以是整数或字符串
str(x)	将x转换为字符串，x 可以是整数或浮点数

第四章 程序的控制结构

1. 程序的三种控制结构
   
   顺序结构、分支结构、循环结构
   
   分支结构：
   
   单分支

>>>#判断输入整数是否在[0,100]之间
>>>num = eval(imput("请输入一个整数："))
>>>if 0 <= num <=100:      #判断[0,100]
>>>    print("输入的整数在0到100之间")
>>>

二分支

>>>num = eval(input("请输入一个数字："))
>>>if num > 100:
>>>    print("输入的数字大于100")
>>>else:
>>>    print("输入的数字小于等于100。")

多分支

>>>num = eval(imput("请输入一个整数："))
>>>if num > 100:
       print("输入的数字大于100")
>>>elif num = 100:
>>>    print("输入的数字等于100")
>>>else:
>>>    print("输入的数字小于100")

循环结构：

遍历循环(for)

for <循环变量> in <遍历结构>:
    <语句块>

>>>for c in "Python":
>>>    print(c)
P
y
t
h
o
n
>>>for i in range(5):
>>>    print(i)
0
1
2
3
4
>>>

for <循环变量> in <遍历结构>:
    <语句块1>
else:
    <语句块2>

>>>for s in "PY":
>>>    print("循环执行中：" + s)
>>>else:
>>>    s = "循环正常结束"
>>>print(s)
#执行后
循环执行中：P
循环执行中：Y
循环正常结束
>>>

无限循环(while):

while <条件>:
    <语句块>

>>>n = 0
>>>while n < 10:
>>>    print(n)
       n = n + 3
0
3
6
9

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

>>>s, idx = "PY", 0
>>>while idx < len(s):
>>>    print("循环执行中：" + s[idx])
>>>    idx += 1
>>>else:
>>>    s = "循环正常结束"
>>>print(s)
#执行后
循环执行中：P
循环执行中：Y
循环正常结束

循环控制（break和continue）：

break用来跳出最内层for或while循环，脱离该循环后程序继续执行循环后续代码。如果有两层或多层循环，break退出最内层循环

>>>while True:
>>>    s = input("请输入一个名字(按Q退出)：")
>>>    if s == "Q":
>>>        break
>>>    print("输入的名字是：", s)
>>>print("+++程序退出+++")
>>>
#执行后
请输入一个名字(按Q退出)：赵广健
输入的名字是：赵广健
请输入一个名字(按Q退出)：董继坤
输入的名字是：董继坤
请输入一个名字(按Q退出)：Q
+++程序退出+++

continue用来结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。

>>>for s in "PYTHON":
>>>    if s == "Y":
>>>        continue
>>>    print(s,end='')
>>>
#执行
PTHON

continue语句和break语句的区别是：continue语句只结束本次循环，不终止整个循环的执行。break语句具备结束整个当前循环的能力。

1. 程序的异常处理

try:
    <语句块1>
except:
    <语句块2>

>>>try:
>>>    for i in range(5):
>>>        print(10/i, end='')
>>>except ZeroDivisionError:
>>>    print("除数为0，产生了除0错误！")
>>>except:
>>>    print("某种原因，出错了！")
>>>
#执行
除数为0，产生了除0错误！

第五章 函数和代码复用

使用函数的两个目的：降低编程难度和增加代码复用

1. 函数的基本使用
   
   定义函数:

  def <函数名> (<参数列表>):
      <函数体>
      return <返回值列表>       ==当函数没有return时，仅表示执行一段代码功能==

  #定义一个对整数n求阶乘的函数
>>>def fact(n):
>>>    s = 1
>>>    for i in range(1, n+1):
>>>        s *= i
>>>    return s

函数的调用

>>>def fact(n):
>>>    s = 1
>>>    for i in range(1, n+1):
>>>        s *= i
>>>    return s
 #调用函数
>>>print(fact(100))

函数的使用可分为4个步骤：

函数定义、函数调用、函数执行、函数返回

1. 函数的参数传递
   
   可选参数传递：

def <函数名>(<非可选参数列表>, <可选参数> = <默认值> ):
    <函数体>
    return <返回值列表>

>>>def multiply(x, y = 10):
>>>    print(x * y)
>>>multiply(99)
990
>>>multiply(99, 2)
198

参数名称传递：

>>>def multiply(x, y = 10):
>>>    print(x * y)
>>>multiply(x = 99)
990
>>>multiply(y = 2, x = 99)
198

函数的返回值(return)：

>>>def multiply(x, y = 10):
>>>    return x * y, x+y
>>>s = multiply(99, 2)
>>>    print(s)
(198, 101)
>>>a,b = multiply(99, 2)
>>>print(a)
198
>>>print(b)
101

1. 变量的作用域
   
   局部变量：是指在函数内部定义的变量，仅在函数内部有效，当函数退出时变量将不再存在。

>>>def multiply(x, y = 10):
>>>    z = x * y     # z是函数内部的局部变量
>>>    return z
>>>s = multiply(99, 2)
>>>print(s)
198
>>>print(z)   #函数外z不存在，所以报错。
Traceback (most recent call last):
  File "XXX/XXX/XXX", line 6, in <module>
    print(z)
NameError: name 'z' is not defined

全局变量：是指在函数之外定义的变量，在程序执行全过程有效，但在函数内部使用时需要提前用保留字 global 声明。

>>>n = 2   # n是全局变量
>>>def multiply(x, y = 10):
>>>    global n
>>>    return x * y * n     #使用全局变量
>>>s = multiply(99, 2)
>>>print(s)
369

1. 代码复用
   
   定义：将函数封装起来供给其他代码或程序调用，从而避免相同功能代码在被调用处重复编写。
   
   模块化设计：使用函数对程序合理划分为功能模块，并基于模块设计程序。
   
   模块化设计的基本要求：紧耦合、松耦合

紧耦合：尽可能合理划分功能块，功能块内部耦合紧密
   
   松耦合：模块间关系尽可能简单，功能块之间耦合度低

第六章 组合数据类型

1. 三大组合数据类型： 集合类型、序列类型、映射类型
   
   集合类型("{}")： 是一个元素集合（set），元素之间无序，相同元素在集合中唯一存在。

集合中的元素类型只能是不可变数据类型，例如：整数、浮点数、字符串、元组等。列表、字典和集合类型本身都是可变数据类型，不能作为集合的元素出现。

集合类型的操作符：

操作符及运算	描述
S - T	返回一个新集合，包括在集合S但不在集合T中的元素
S & T	返回一个新集合，包括同时在集合S和T中的元素
S ^ T	返回一个新集合，包括集合S和T中非共同元素
S | T	返回一个新集合，包括集合S和T中所有元素

集合类型常用的操作函数或方法：

操作符及运算	描述
S.add(x)	如果数据项x不再集合 S 中，将 x 增加到 S
S.remove(x)	如果 x 在集合 S 中，移除该元素，不再则产生KeyError 异常
S.clear()	移除集合 S 中的所有数据项
len(S)	返回集合 S 元素个数
x in S	如果 x 是 S 的元素，返回True；否者返回False
x not in S	如果 x 不是 S 的元素，返回True；否者返回False
set(x)	将其他组合数据类型变成集合类型， set() 函数也可以生成空集合变量

序列类型：包括字符串类型、列表类型、元组类型等；序列类型的索引体系与字符串类型一样，即正向递增和反向递减。

序列类型的操作符和函数：

操作符及运算	描述
x in s	如果 x 是 s 的元素，返回True；否者返回False
x not in s	如果 x 不是 s 的元素，返回True；否者返回False
s + t	连接 s 和 t
s * n 或 n * s	将序列 s 复制 n 次
s[ i ]	索引，返回序列的第 i 个元素
s[ i : j ]	切片，返回包含序列 s 第 i 到第 j 个元素的子序列（不包含第 j 个元素）
s[ i : j: k ]	步骤切片，返回包含序列 s 第 i 到第 j 个元素以 k 为步数的子序列
len(S)	返回集合 S 元素个数(长度)
min(s)	序列 s 中最小元素
max(s)	序列 s 中最大元素
s.index(x)	序列 s 第一次出现元素 x 的位置
s.count(x)	序列 s 中出现 x 的总次数

元组类型：是序列类型的重要组成之一,在 Python 语言中表示为 tuple，一般用小括号()和逗号,进行组织。

元组类型一旦定义就不能修改，在编程中不够灵活，同时元组类型的所有操作都可以由列表类型实现。因此，在一般编程中，如果需要自定义变量，通常以列表类型代替元组类型使用。

映射类型： 映射类型是序列类型的扩展。键(key)值(value)对将映射关系结构化，用于存储和表达。

列表类型：列表[] 或 list(x)包含0个或多个元组的有序序列，属于序列类型（所以序列类型的操作符及运算也适用于列表）。列表可以进行元素增加、删除、替换、查找等操作。

列表的操作方法：

方法	描述
ls.append( x )	在列表 ls 最后增加一个元素 x
ls.insert(i, x)	在列表 ls 第 i 位置增加元素 x
ls.clear()	删除 ls 中所有元素
ls.pop( i )	将列表 ls 中第 i 项元素取出并从 ls 中删除该元素
ls.remove( x )	将列表中出现的第一个元素 x 删除
ls.reverse()	列表 ls 元素反转
ls.copy()	生成一个新列表， 复制 ls 中所有元素

字典类型： 用大括号{}建立，每个元素是一个键(key)值(value)对。

>>>d = {"201901":"小明", "201902":"小红"}
>>>print(d)
{'201901':'小明', '201902':'小红'}

字典和集合都用大括号表示，但是如果直接使用大括号`{}`,则生成字典类型，而不是集合类型。

1. 字典的索引

>>>d = {"201901":"小明", "201902":"小红"}
>>>print(d["201902"])
小红
>>>d["201902"] = '新小红'
>>>print(d)
{'201901':'小明'，'201902':'新小红'}
#使用大括号创建字典
>>>t = {}
>>>t["201903"] = "小绿"
>>>print(t)
{'201903':'小绿'}

1. 字典的操作函数：

操作函数	描述
len(d)	字典 d 的元素个数(长度)
min(d)	字典 d 中键的最小值
max(d)	字典 d 中键的最大值
dict()	生成一个空字典

1. 字典的操作方法：

操作方法	描述
d.keys()	返回所有的键信息
d.values()	返回所有的值信息
d.items()	返回所有的键值对
d.get( key, default)	键存在则返回相应值，否者返回默认值 default
d.pop(key, default)	键存在则返回相应值，同时删除该键值对，否者返回默认值 default
d.popitem()	随机从字典中取出一个键值对，以元组(key, value)形式返回，同时将该键值对从字典中删除
d.clear()	删除所有键值对，清空字典

第七章 文件和数据格式化

1. 文件的使用
   
   文件是存储在辅助存储器上的一组数据序列，可以包含任何数据内容。概念上，文件是数据的集合和抽象。文件包括文本文件和二进制文件两种类型
   
   文本文件和二进制文件采用统一的操作步骤，即：打开--->操作--->关闭
   
   <变量名> = open(<文件路径及文件名>, <打开模式>)

>>>f = open("路径/a.txt", "rt")    #文件打开，分别对应文件的位置，文件的打开模式和文件类型
>>>print(f.readline())          #文件的读取方法
>>>f.close()                  #关闭文件
>>>

open()函数的7种打开模式：

打开模式	含义
'r'	只读模式，如果文件不存在，返回异常 FileNotFoundError，默认值
'w'	覆盖写模式，文件不存在则创建，存在则完全覆盖原文件
'x'	创建写模式，文件不存在则创建，存在则返回异常 FileExistsError
'a'	追加写模式，文件不存在则创建，存在则在原文件最后追加内容
'b'	二进制文件模式
't'	文本文件模式， 默认值
'+'	与 r/w/x/a 一同使用，在原功能的基础上增加同时读写功能

打开模式中，'r'、'w'、'x'、'b'可以和'b'、't'、'+' 组合使用，形成即表达读写又表达文件模式的方式。
1.以文本方式只读打开一个文件，读入后不能对文件进行修改。
<变量名> = open(<文件名>, 'r')     或 <变量名> = open(<文件名>)
2.以文本方式可读写地打开一个文件，可以读入并修改文件。
<变量名> = open(<文件名>, 'r+')
3.以文本方式打开一个空文件，准备写入一批内容，并保存为新文件。
<变量名> = open(<文件名>, 'w')
4.以文本方式打开一个空文件或已有文件，追加形式写入一批内容，更新原文件。
<变量名> = open(<文件名>, 'a+')
5.以二进制方式只读打开一个文件，读入后不能对文件进行修改。
<变量名> = open(<文件名>, 'rb')
6.文件关闭，释放文件的使用权
<变量名>.close()

文件的读取方法：

方法	含义
f.read( size = -1)	从文件中读入整个文件内容。参数可选，如果给出，读入前 size 长度的字符串或字节流
f.readline( size = -1)	从文件中读入一行内容。参数可选，如果给出，读入改行前 size 长度的字符串或字节流
f.readlines( hint = -1)	从文件中读入所有行，以每行为元素形成一个列表。参数可选，如果给出，读入 hint 行
f.seek( offset)	改变当前文件操作指针的位置，offset 的值：0 为文件开头，2为文件结尾

文件打开后，对文件的读写有一个读取指针，当从文件读入内容后，读取指针将向前推进，再次读取的内容将从指针的新位置开始

文件写入方法：

方法	含义
f.write(s)	向文件写入一个字符串或字节流
f.writelines(lines)	将一个元素为字符串的列表整体写入文件

1. 数据组织的维度
   
   定义：

一组数据在被计算机处理前需要进行一定的组织，表明数据之间的基本关系和逻辑，进而形成“数据的维度”。根据数据的关系不同，数据组织可以分为：一维数据、二维数据和高维数据

一维数据：一维数据由对等关系的有序或无序数据构成，采用线性方式组织，对应于数学中的数组的概念，任何表现为序列或集合的内容都可以看做是一维数据。

二维数据：也称表格数据，由关联关系数据构成，采用二维表格方式组织，对用于数学中的矩阵，常见的表格都属于二维数据。

高维数据： 由键值对类型的数据构成，采用对象方式组织，可以多层嵌套。

高维数据在 Web 系统中十分常用，作为当今 Internet 组织内容的主要方式，高维数据衍生出 HTML、XML、JSON 等具体数据组织的语法结构。
高维数据相比一维和二维数据能表达更加灵活和更加复杂的数据关系。

1. 一维数据的处理
   
   一维数据的表示：在Python语言中主要采用列表[]形式表示。
   
   一维数据的存储： (1)采用空格分隔元素、(2)采用逗号分隔元素、(3)采用换行分隔元素、(4)其他特殊符号分隔，例如分号分隔。其中用逗号分隔的存储格式叫作 CSV 格式
   
   一维数据的处理：

首先，从 CSV 文件读入一维数据，并将其表示为列表对象。由于从 CSV 文件中获得内容时，最后一个元素后面包含一个换行符( "\n" )。对于数据的表达和使用来说，这个换行符是多余的，需要采用字符串的 strip() 方法去掉尾部的换行符，进一步使用 split() 方法以逗号进行分割。

>>>f = open("city.csv", "r")
>>>ls = f.read().strip('\n').split(",")
>>>f.close()
>>>print(ls)

1. 二维数据的处理
   
   二维数据的表示：二维数据由多个一维数据构成，可以看作一维数据的组合形式。可以采用二维列表表示（二维数据一般采用相同的数据类型存储数据，便于操作）
   
   二维数据的存储：由一维数据组成，用 CSV 格式文件存储。CSV 文件的每一行是一维数据，整个 CSV 文件是一个二维数据。
   
   二维列表对象输出为 CSV 格式文件方法如下：

# ls 代表二维列表，此处省略
>>>f = open("cpi.csv", "w")
>>>for row in ls:
>>>    f.write(",".join(row)+ "\n")
>>>f.close()

二维数据的处理：首先从 CSV 格式文件读入二维数据，并将其表示为二维列表对象。

#以列表形式读取
>>>f = open("cpi.csv", "r")
>>>ls = []
>>>for line in f:
>>>    ls.append(line.strip('\n').split(","))
>>>f.close()
>>>print(ls)

#对二维数据进行格式化输出，打印成表格形状
>>>for row in ls:
>>>    line = ""
>>>    for item in row:
>>>        line += "{:10} \t".format(item)
>>>    print(line)

第八章 Python 计算生态

1. 计算思维
   
   计算思维的本质是 抽象 和 自动化
   
   计算机思维是人类科学思维活动的重要组成部分。人类在认识世界、改造世界的过程中表现出三种基本的思维特征：
   
   以实验和验证为特征的实证思维，以物理学科为代表；
   
   以推理和演绎为特征的逻辑思维，以数学学科为代表；
   
   以设计和构造为特征的计算思维，以计算机学科为代表。计算思维主要反映在理解问题的计算特性，将计算特性抽象为计算问题、通过程序设计语言实现问题的自动求解等几个方面。

2. 程序设计方法论

自顶向下的设计方法 和 自底向上的执行过程

自顶向下的设计方法最重要的就是顶层设计，整个过程可以概括为4个步骤：

步骤 1 ： 将算法表达为一系列小问题；

步骤 2 ： 为每个小问题设计接口；

步骤 3 ： 通过将算法表达为接口关联的多个小问题来细化算法；

步骤 4 ：为每个小问题重复上述过程。

自底向上执行来调试程序，将程序分成小部分自下而上逐个测试，有助于定位错误。

1. 基本的 Python 内置函数

函数名称	函数说明
abs( x )	x 的绝对值，如果 x 是复数，返回复数的模
all( x )	组合类型变量 x 中所有元素都为真是返回 True，否则返回False；若 x 为空，返回 True
any( x )	组合类型变量 x 中任意一元素都为真是返回 True，否则返回False；若 x 为空，返回 False
bin( x )	将整数 x 装换为等值的二进制字符串，如 bin(1010) 的结果是 '0b1111110010'
bool( x )	将 x 装换为 Boolean 类型。 即 True 或 False。 如 bool('') 的结果是 False
chr( i )	返回 Unicode 为 i 的字符。 如chr(9996) 的结果是 ’‘
complex( r, i)	创建一个复数。如 complex( 10, 10) 的结果是 10 + 10j
dict()	创建字典类型。如 dict() 的结果是一个空字典 {}
divmod(a, b)	返回 a 和 b 的商及余数。如 divmod(10, 3) 的结果是一个(3, 1)
eval( s )	计算字符串 s 作为Python 表达式的值
exec( s )	计算字符串 s 作为 Python 语句的值。如exec(' a = 1+999') 运行后，变量 a 的值为 1000
float( x )	将 x 转换成浮点数。如float(1010) 的结果是1010.0
hex( x )	用于将一个指定数字转换为 16 进制数
input( s )	获取用户输入，其中 s 是字符串，作为提示信息，s 可选。
int( x )	int() 函数用于将一个字符串或数字转换为整数
len( x )	返回对象（字符、列表、元组等）长度或项目个数
list( x )	创建或将变量 x 转换成一个列表类型
max(a1, a2, ...)	返回参数的最大值
min(a1, a2 , ...)	返回参数的最小值
oct( x )	将整数 x 转换为等值的八进制字符串形式
open(fname, m)	打开文件，包括文本方式和二进制方式等。
ord( c )	返回一个字符的 Unicode 编码值。
pow(x ,y)	返回 x 的 y 次幂。如pow(2, 3) 的结果是8
print( x )	打印变量或字符串 x
range(a, b, s)	从 a 到 b(不含) 以 s 为步长产生一个序列。如 list(range(1, 10, 3)) 的结果是[1, 4, 7]
reversed( r )	返回组合类型 r 的逆序迭代类型。
round( n )	四舍五入方式计算 n 。如 round(10.6)的结果是 11
set( x )	将组合数据类型 x 转换为集合类型。
sorted( x )	对组合数据类型 x 进行排序默认从小到大。
str( x )	将 x 转换为等值的字符串类型。如 str(0x1010) 的结果是 '4112'
sum( x )	对组合数据类型 x 计算求和结果
type( x )	返回变量 x 的数据类型。

第九章 Python标准库

1. turtle 库（必选）
   
   turtle 库的引入：

      #第一种
>>>import turtle
>>>turtle.circle(200)

     #第二种
>>>from turtle import *
>>>circle(200)

    #第三种
>>>import turtle as t
>>>t.circle(200)

turtle库的窗体函数：作用：设置主窗体的大小和位置

turtle.setup(width, height, startx, starty)

width ：窗口宽度，如果值是整数，表示的像素值；如果值 是小数，表示窗口宽度与屏幕的比例； height:：窗口高度，如果值是整数，表示的像素值；如果 值是小数，表示窗口高度与屏幕的比例； startx：窗口左侧与屏幕左侧的像素距离，如果值是None ，窗口位于屏幕水平中央；

starty：窗口顶部与屏幕顶部的像素距离，如果值是None ，窗口位于屏幕垂直中央；

画笔状态函数：

函数	描述
pendown()	放下画笔
penup()	提起画笔，与pendown()配对使用
pensize(width)	设置画笔线条的粗细为指定大小
pencolor()	设置画笔的颜色
color()	设置画笔和填充颜色
begin_fill()	填充图形前，调用该方法
end_fill()	填充图形结束
filling()	返回填充的状态，True为填充，False为未填充
clear()	清空当前窗口，但不改变当前画笔的位置
reset()	清空当前窗口，并重置位置等状态为默认值
screensize()	设置画布的长，宽和背景颜色
hideturtle()	隐藏画笔的turtle形状
showturtle()	显示画笔的turtle形状
isvisible()	如果turtle可见，则返回True
write(str, font = None)	输出 font 字体的字符串

画笔运动函数：

函数	描述
forward( distance )	沿着当前方向前进指定距离
backward( distance )	沿着当前相反方向后退指定距离
right( angle )	向右旋转angle角度
left( angle )	向左旋转angle角度
goto( x,y )	移动到绝对坐标（x,y）处
setx( x )	将当前x轴移动到指定位置
sety( y )	将当前y轴移动到指定位置
setheading(angle)	设置当前朝向为angle角度
home()	设置当前画笔位置为原点，朝向东。
circle(radius, e)	绘制一个指定半径r和角度e的圆或弧形
dot(r, color)	绘制一个指定半径r和颜色color的圆点
undo()	撤销画笔最后一步动作
speed()	设置画笔的绘制速度，参数为0-10之间

1. random 库：主要目的是生成随机数
   
   random 库采用梅森旋转算法生成伪随机数序列。可用于除随机性要求更高的加解密算法外的大多数工程应用。
   
   基本函数： random.random() 他生成一个[0.0, 1.0 ]之间的随机小数，其他随机函数都是基于这个函数扩展而来。

random 库的常用函数：

函数	描述
seed( a = None)	初始化随机数种子，默认值为当前系统时间
random()	生成一个[0.0, 1.0 ]之间的随机小数
randint(a, b)	生成一个[ a, b] 之间的整数
getrandbits( k )	生成一个 k 比特长度的随机整数
randrange(start, stop[, step])	生成一个[start, stop)之间以step为步数的随机整数
uniform(a, b)	生成一个[a, b]之间的随机小数
choice(seq)	从序列类型(例如：列表)中随机返回一个元素
shuffle(seq)	将序列类型中元素随机排列，返回打乱后的序列
sample(pop, k)	从pop类型中随机选取k个元素，以列表类型返回

1. time 库

第十章 Python第三方库概览

1. 第三方库的获取和安装
   
   pip 工具安装 、 自定义安装 、文件安装

2. PyInstaller 库（必选）

3. jieba 库（必选）

4. wordcloud 库（可选）

第十一章 Python 第三方库纵览

只要求了解第三方库的名称、分类

网络爬虫

request 、 scrapy

数据分析

numpy、scipy、pandas

Web开发

Django、 Pyramid、Flask

文本处理

pdfminer、 penpyxl、python-docx、beautifulsoup4

游戏开发

Pygame、Panda3D、cocos2d

用户图形界面

PyQt5、wxPython、PyGTK

数据可视化

matplotlib、TVTK、mayavi

机器学习

scikit-learn、TensorFlow、Theano

更多第三方库

PIL、SymPy、NLTK、WeRoBot、MyQR