Python
Python二级考试笔记
前言 考试题型
1.1 单选题
公共基础 10分
python语言理论 30分
单选必须超过20分
1.2 操作题
基本操作题 15分（3道小题）
简单应用题 25分（2道小题）
综合应用题 20分（1道大题分两问）
考后45天出成绩
考试时间120分钟
第1章 程序设计基本方法
高级编程语言根据执行机制不同分为：静态语言和脚本语言
静态语言采用编译方式执行，脚本语言采用解释方式执行。例如，C语言是静态语言，Python语言是脚本语言。
静态=编译=文件 脚本=解释=交互
Python程序有两种运行方式：交互式和文件式
IPO程序编写方法：
输入数据（Input）
处理数据（Process）
输出数据（Output）
Python由C语言编辑而成。
Python只有33个保留字。
示例1：斐波那契数列的计算
# CalFibonacci.py
a,b = 0,1
while a < 1000: # 输出不大于1000的斐波那契序列
print(a,end = ',')
a,b = b,a+b
示例2：根据圆的半径计算圆的面积
# CalCircleArea.py
r = 25 # 圆的半径是25
area = 3.14*r*r
print(area)
第2章 Python语言基本语法元素
Python语言采用严格的缩进来表明程序的格式框架。用来表示代码之间的包含和层次关系。
一个缩进（tab键） = 4个空格
变量是保存和表示数据值的一种语法元素。
命名不能以数字开头，不能出现空格，对大小写敏感。
注：保留字不能作为变量命名。
数字类型：整数、浮点数和复数
十六进制：0x
八进制：0o
二进制：0b
字符串
Python语言中，字符串是用两个双引号“ ”或者单引号‘ ’ 引住的一个或多个字符。
示例1：字符串切片
a = "中国人民解放军"
a[2:4] # 将输出“人民”，切片规则从0开始，不包括右端取值，-1表示最后一个位置
input()函数
示例2：input()函数的使用
>>> a = input("请输入一个小数： ")
请输入一个小数： 123.456
>>> print(a)
123.456
注：通过input()函数输入的数据为字符串型，可以利用type()函数查看其类型
eval()函数
eval函数能够以Python表达式的方式解析并执行字符串，将返回结果输出
示例3：
>>> a = eval("1.2 + 3.4")
>>> a
4.6 # 类似于脱帽
>>> type(a)
<class 'float'>
eval()函数与input()函数一起使用
示例4：
>>> value = eval(input("请输入要计算的数值："))
请输入要计算的数值：1024256
>>> print(value*2)
2048512
print()函数
示例5：
>>> a = 24
>>> print(a, end = '.')
24.
print(<输出字符串模板>).format(<变量1>，<变量2>,...<变量n>)
示例6：
>>> a,b = 123.456,1024
>>> print("数字{}和数字{}的乘积是{}.".format(a,b,a*b))
数字123.456和数字1024的乘积是126418.944.
示例7：反向输出一段文本
# Example_2_1.py
s = input("请输入一段文本：")
i = len(s)-1 # len()查看字符串的长度
while i >=0:
print(s[i], end = "")
i = i-1
第3章 基本数据类型
不同进制的整数之间可以直接运算
bin oct hex
填充、对齐和宽度
>>> s = "等级考试"
>>> "{:>15}".format(s) # 右对齐
' 等级考试'
>>> "{:*>15}".format(s) # 右对齐且填充*号
'***********等级考试'
>>> "{:>.3}".format(s) # 截取前三位
'等级考'
>>> "{:.2f}".format(123.456) # f表示以浮点数表示，e表示以科学计数法表示
'123.46' # 此处保留两位小数
a = "abcdefg"
a[1:6:2] # 1为起点，6为终点，2为步长
'bdf'
字符串类型的操作
| 操作符 | 描述 |
|---|---|
| x+y | 连接字符串x与y |
| x*n或n*x | 复制n次字符串x |
| x in s | 如果x是s的子串，返回True，否则返回False |
示例1：
>>> name = "Python语言" + "程序设计"
>>> name
'Python语言程序设计'
示例2：
>>> "等级考试！"*3
'等级考试！等级考试！等级考试！'
示例3：
>>> "语言" in name
True
>>> 'Y' in name
False
字符串处理函数
Python语言提供了一些对字符串处理的内置函数
| 函数 | 描述 |
|---|---|
| len(x) | 返回字符串x的长度，也可返回其他组合数据类型的元素个数 |
| str(x) | 返回任意类型x所对应的字符串形式 |
| chr(x) | 返回Unicode编码x对应的单字符 |
| ord(x) | 返回单字符x表示的Unicode编码 |
| hex(x) | 返回整数x对应十六进制数的小写形式字符串 |
| oct(x) | 返回整数x对应八进制数的小写形式字符串 |
示例4：
>>> chr(65)
'A'
>>> ord("A")
65
>>> hex(17)
'0x11'
>>> oct(9)
'0o11'
字符串处理方法
| 方法 | 描述 |
|---|---|
| str.lower() | 返回字符串str的副本，全部字符小写 |
| str.upper() | 返回字符串str的副本，全部字符大写 |
| str.split(sep=None) | 返回一个列表，由str根据sep被分割的部分构成 |
| str.count(sub) | 返回sun子串出现的次数 |
| str.replace(old,new) | 返回字符串str的副本，所有old字符串被替换为new |
| str.center(width,fillchar) | 字符串居中函数，fillchar参数可选 |
| str.strip(chars) | 从字符串str中去掉在其左侧和右侧chars中列出的字符 |
| str.join(iter) | 在iter变量的每一个元素后增加一个str字符串 |
示例4：
n = eval(input('请输入一个数字：'))
if type(n) == type(123):
print("输入的数字是整数。")
elif type(n) == type(12.3):
print("输入的数字是浮点数。")
else:
print("无法判断其类型。")
通过内置的函数可以显示地将数字类型进行转换
| 函数 | 描述 |
|---|---|
| int(x) | 将x转换为整数，x可以是浮点数或字符串 |
| float(x) | 将x转换为浮点数，x可以是整数或字符串 |
| str(x) | 将x转换为字符串，x可以是整数或浮点数 |
示例5：凯撒密码的加密算法程序
# CaesarEncode.py
ptxt = input("请输入一段明文文本：")
for p in ptxt:
if "a" <= p <= "z":
print(chr(ord('a')+(ord(p)-ord('a')+3)%26),end = '')
elif "A" <= p <= "Z":
print(chr(ord('A')+(ord(p)-ord('A')+3)%26),end = '')
else:
print(p,end='')
示例6：凯撒密码的解密算法程序
# CaesarDecode.py
ptxt = input("请输入一段明文文本：")
for p in ptxt:
if "a" <= p <= "z":
print(chr(ord('a')+(ord(p)-ord('a')-3)%26),end = '')
elif "A" <= p <= "Z":
print(chr(ord('A')+(ord(p)-ord('A')-3)%26),end = '')
else:
print(p,end='')
作业一：输入一个浮点数，将它的整数部分连续输出三次。
a = eval(input("请输入一个浮点数："))
print(str(int(a))*3)
作业二：输入两个字符串，判断其中一个字符串在另一个字符串中出现的次数。
a = input("请输入第一个字符串：")
b = input("请输入第二个字符串：")
print(a.count(b))
第4章 程序的控制结构
程序由三种基本结构组成：顺序结构、分支结构和循环结构。
Python提供两个循环控制符break和continue，对循环的执行过程进行控制。break控制符用来结束当前循环，continue控制符用来结束当前循环的当次循环过程。
单分支结构：if语句
示例1：判断一个数是奇数还是偶数
a = eval(input("请输入一个整数："))
if a%2 == 0:
print("{}是偶数".foramt(a))
else:
print("{}是奇数".format(a))
多分支结构：if-elif-else语句
示例2：输入一个成绩，判断它属于哪个层次
a = eval(input("请输入一个成绩："))
if a >= 90:
print("优秀")
elif a >= 80:
print("良好")
elif a >= 60:
print("及格")
else:
print("不及格")
程序的循环结构 for <循环变量> in range(<循环次数>)：
示例3：对1到10求和
s = 0
for i in range(11):
s = s+i
print(i) # 此处是查看哪些数字进行求和，可省略
print(s)
示例4：对任意一个数到另一个数之间的求和
a = eval(input("请输入一个起始数："))
b = eval(input("请输入一个终止数："))
for i in range(a+1,b+1):
a = a+i
print(a)
示例5：判断一个数是否为素数（质素），也就是只能被1和本身整除的数
s = eval(input("请输入一个数："))
i = 2
while i<s:
if s%i==0:
print("{}是非素数。".format(s))
break
i+=1
else:
print("{}是素数。".format(s))
示例6：输入一个数，输出从2开始到这个数之间的素数
s = eval(input("请输入一个数："))+1
for j in range(2,s):
i = 2
while i<j:
if j%i==0:
print("{}是非素数。".format(j))
break
i+=1
else:
print("{}是素数。".format(j))
示例7：猜数字游戏
import random
target = random.randint(1,1000)
count = 0
while True:
try:
guess = eval(input("猜数字游戏，请输入一个1到1000的整数："))
except:
print("输入有误，请重新输入，不计入次数噢！")
count +=1
if guess > target:
print("你猜的有点大了噢，请再试一次！")
elif guess < target:
print("你猜的有点小了噢，请再试一次！")
else:
print("恭喜你，猜对啦！")
break
print("本轮猜测的次数是：",count)
作业一：求1到30之间的素数之和，并输出每个素数。
s = 31
last_sum = 0
for j in range(1,s):
i = 2
while i<j:
if j%i==0:
break
i+=1
else:
print(j,end=',')
last_sum = last_sum + j
print(last_sum)
第5章 函数和代码复用
函数的基本使用
def <函数名> (<参数列表>)：
<函数体>
return<返回值列表> # 可以没有
示例1：函数定义及使用
txt = """
人生得意须尽欢,莫使金樽空对月.天生我材必有用,千金散尽还复来.
"""
linewidth = 30
def linesplit(line):
plist = [',','.','?','!','，','。','？','！']
for p in plist:
line = line.replace(p,'\n')
return line.split('\n')
def lineprint(line):
global linewidth
print(line.center(linewidth,chr(12288)))
newlines = linesplit(txt)
for newline in newlines:
print(newline)
作业一：利用函数，从三个数中找最大值
def max(a,b):
if a > b:
return a
else:
return b
print(max(max(4,5),6)) # 两次调用max函数
作业二：编写一个函数，利用递归计算出斐波那契数列第n个数并返回
def fab(n):
if 0 < n <= 1:
return 0
elif n < 3:
return 1
return fab(n-1) + fab(n-2)
print(fab(10))
作业三：编写一个函数，计算字符串中数字，字母，空格及其它字符的个数
def count(str1):
num_number = char_number = space_number = other_number = 0
for char in str1:
if char.isdigit():
num_number += 1
elif char.isalpha():
char_number += 1
elif char == ' ':
space_number += 1
else:
other_number += 1
print("数字个数：{}，字母个数：{}，空格个数:{},其它字符个数：{}".format(num_number,
char_number, space_number, other_number))
count("haopvoi oagi io124366sahgjb asfjag&*&5")
第6章 组合数据类型
Python语言中最常用的组合类型有3大类，分别是集合类型、序列类型和映射类型。
集合型是一个元素集合，元素之间无序，相同元素在集合中唯一存在。
序列类型是一个元素向量，元素之间存在先后关系，通过序号访问，元素之间不排他。序列类型的典型代表是字符串类型和列表类型。
映射类型是“键-值”数据项的组合，每个元素是一个键值对，表示为(key,value)。映射类型的典型代表是字典类型。
集合类型
| 操作符的运算 | 描述 |
|---|---|
| S - T | 集合做差 |
| S & T | 求集合的共同元素 |
| S ^ T | 返回一个集合，包括集合S和T中非共同元素 |
| S|T | 返回一个集合，包括集合S和T中所有元素 |
| 函数或方法 | 描述 |
|---|---|
| s.add(x) | 将x增加到s中 |
| s.remove(x) | 移除s中的x元素 |
| s.clear(x) | 移除s中所有数据项 |
| len(s) | 求s的元素个数 |
| x in s | x在s中，返回True，否则返回False |
| x not in s | x不在s中，返回True，否则返回False |
序列类型
元组（tuple）是一种不可变序列，以小括号()表示
列表（list），以中括号[]表示，有序，可重复
s.index(x) # 序列s中第一次出现元素x的位置
s.count(x) # 序列s中出现x的总次数
易错题：
以下选项中，不是具体的Python序列类型的是（D）
A.字符串类型 B.元组类型 C.列表类型 D.数组类型
示例1：
ls = [1010,"1010",[1010,"1010"],1010]
for i in ls:
print(i*2)
# 输出结果如下：
2020
10101010
[1010, '1010', 1010, '1010']
2020
列表操作方法
| 方法 | 描述 |
|---|---|
| ls.append(x) | 在列表ls最后增加一个元素 |
| ls.insert(i,x) | 在列表ls第i个位置增加元素x |
| ls.clear(x) | 删除ls中所有元素 |
| ls.pop(i) | 将列表ls中第i项元素去除并删除该元素 |
| ls.remove(x) | 将列表中出现的第一个元素x删除 |
| ls.reverse(x) | 列表ls中元素反转 |
| ls.copy() | 生成一个新列表，复制ls中所有元素 |
字典类型
字典，以大括号{}表示，属于映射类型
dict() # 生成一个新字典
list() # 生成一个新列表
set() # 生成一个新集合
tuple() # 生成一个新元组
a.get("key") # 获得键对应的值
第7章 文件和数据格式化
文件的打开
>>> f = open("C:\\Users\\Administrator\\python_work\\moby_dict.txt","rt") # t表示文本文件方式
>>> a = f.readline() # 读取文件的第一行
>>> a
'锘縏he Project Gutenberg EBook of Moby Dick; or The Whale, by Herman Melville\n'
>>> f.close() # 关闭文件
a.read() # 读取整个文档的内容并作为一个字符串
a.readline() # 把当前行的内容作为一个字符串
a.readlines() # 读取所有数据，每行作为一个字符串，组成列表型数据
a.seek(0) # 光标回到最初位置
r # 只读模式
w # 覆盖模式，没有即新建
x # 新建文件，存在即报错
a # 追加模式，没有即新建
写文件
a.write()
a.writelines()
数据组织的维度
>>> ls = ['北京','上海','天津','重庆']
>>> a = open('city.csv','w')
>>> a.write(",".join(ls)+"\n")
12
>>> a.close()
一维数据的处理
>>> f = open("city.csv",'r')
>>> ls = f.read().strip("\n").split(",")
>>> print(ls)
['北京', '上海', '天津', '重庆']
二维数据的处理
二维数据由一维数据组成，用csv格式文件存储。
二维列表对象输出为csv格式文件方法，采用遍历循环和字符串的join()方法相结合。
>>> ls = [['学号','姓名'],['01','张三'],['02','李四']]
>>> f = open("C:\\Users\\Administrator\\python_work\\abc.csv",'w')
>>> for ll in ls:
f.write(",".join(ll)+'\n')
>>> f.close()
从csv格式文件输入二维数据：
>>> f = open("C:\\Users\\Administrator\\python_work\\abc.csv",'r')
>>> ls = []
>>> for l in f:
ls.append(l.strip("\n").split(","))
>>> ls
[['学号', '姓名'], ['01', '张三'], ['02', '李四']]
第8章 计算思维
计算思维的本质是抽象和自动化。
自定而下，逐层细化
23集有一个案例
如何更改默认路径
>>> import os
>>> os.getcwd() # 查看路径
'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python38'
>>> os.chdir("C:\\Users\\Administrator\\python_work") # 更改路径
>>> os.getcwd()
'C:\\Users\\Administrator\\python_work'
实例解析：Web页面元素提取
24集有一个案例
第9章 Python标准库概览
引入turtle
import turtle # 绘制图形
>>> turtle.circle(200) # 绘制一个直径为200的圆
from turtle import*
circle(200)
import turtle as t
t.circle(200)
窗体函数
turtle.setup(width,height,startx,starty)
画笔状态函数tuttle
| 函数 | 描述 |
|---|---|
| pendown() | 放下画笔 |
| penup() | 提起画笔 |
| pensize(width) | 设置画笔粗细 |
| color() | |
| begin_fill() | 开始填充 |
| end_fill() | 结束填充 |
| filling() | |
| clear() | 清除当前画布 |
| reset() | 画笔回到圆心点 |
| screensize() |
示例1：绘制五角星
import turtle
turtle.pensize(4)
turtle.pencolor('yellow')
turtle.fillcolor("red")
turtle.begin_fill()
for i in range(5):
turtle.forward(200) # 画笔向前移动200个像素
turtle.right(144)
turtle.end_fill()
示例2：绘制五边形
import turtle
turtle.pensize(3)
turtle.penup()
turtle.color("red")
turtle.goto(-100,-180) # 设置画笔起始坐标
turtle.pendown()
turtle.begin_fill() # 开始填充
turtle.circle(40,steps=5) # step=5表示为五边形
turtle.end_fill() # 结束填充
引入random
from random import *
默认随机数为0-1之间的数，更改要使用随机种子seed()
示例3：编写一个6位数的验证码
import random
list1 = []
for i in range(6):
num = random.randrange(0,10)
list1.append(str(num))
str1 = "".join(list1) # 将六个字符串连接成一个字符串
print(str1)
示例4：编写一个6位数的验证码，由字母和数字组成
import random
list1 = []
for i in range(6):
b = random.randrange(0,10)
if b<5:
num1 = random.randrange(65,91)
list1.append(chr(num1))
else:
num = random.randrange(0,10)
list1.append(str(num))
str1 = "".join(list1)
print(str1)
time库概述
# 获取当前时间
>>> time.gmtime()
time.struct_time(tm_year=2020, tm_mon=2, tm_mday=6, tm_hour=5, tm_min=42, tm_sec=9, tm_wday=3, tm_yday=37, tm_isdst=0)
>>> time.ctime()
'Thu Feb 6 13:43:23 2020'
# 三个函数，分别测试三个函数运行所花的时间
import time
def coreloop():
limit = 10**8
while (limit>0):
limit -= 1 # 此循环要运行10**8次
def otherloop1():
time.sleep(0.2)
def otherloop2():
time.sleep(0.4)
def main():
startTime = time.localtime()
print('程序开始时间：', time.strftime('%Y-%m-%d %H:%M:%S', startTime))
stratPerfCounter = time.perf_counter()
otherloop1()
otherloop1PerCounter = time.perf_counter()
otherloop1Perf = otherloop1PerCounter - stratPerfCounter
coreloop()
coreloopPerfCounter = time.perf_counter()
coreloopPerf = coreloopPerfCounter - otherloop1PerCounter
otherloop2()
otherloop2PerCounter = time.perf_counter()
otherloop2Perf = otherloop2PerCounter - coreloopPerfCounter
endPerfCounter = time.perf_counter()
totalPerf = endPerfCounter - stratPerfCounter
endTime = time.localtime()
print("模块1运行的时间是：{}秒。".format(otherloop1Perf))
print("核心模块运行的时间是：{}秒。".format(coreloopPerf))
print("模块2运行的时间是：{}秒。".format(otherloop2Perf))
print("程序结束时间：", time.strftime('%Y-%m-%d %H:%M:%S', endTime))
main()
# 输出结果如下：
程序开始时间： 2020-02-06 14:11:24
模块1运行的时间是：0.19924129999999995秒。
核心模块运行的时间是：9.3878391秒。
模块2运行的时间是：0.39956389999999864秒。
程序结束时间： 2020-02-06 14:11:34
实例解析：雪景艺术绘图
# 绘制雪景，将分为三块来实现
# 1，绘画窗口
# 2，绘制雪花
# 3，绘制雪地
from turtle import *
from random import *
# 绘制雪花
def drawsnow():
hideturtle()
pensize(2)
for i in range(100):
r,g,b = random(),random(),random()
pencolor(r,g,b) # 把笔的颜色设置成随机色
penup()
setx(randint(-350,350))
sety(randint(1,270))
pendown()
k = randint(8,12) # 雪花片的瓣数
snowsize = randint(10,14) # 雪花片的长度
# 具体来绘制一朵雪花
for j in range(k):
forward(snowsize)
backward(snowsize)
right(360/k)
# 绘制雪地
def drawgroud():
hideturtle()
for i in range(200):
pensize(randint(3,10))
x = randint(-400,350)
y = randint(-280,-1)
r,g,b = -y/280, -y/280, -y/280
pencolor(r,g,b)
penup()
goto(x,y)
pendown()
forward(randint(40,100))
# 绘制窗口
setup(800,600,200,200)
tracer(False) # 把绘制过程关闭
bgcolor("black")
drawsnow()
drawgroud()
第10章 Python第三方库概览
在命令提示行里输入pip list查看已安装的第三库
pip工具（在终端中进行）
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple package # 在清华镜像中安装第三方库
# 本地使用pip安装第三方库，此处安装词云
cd python_work
python_work>python -m pip install --user wordcloud-1.6.0-cp38-cp38-win_amd64.whl
附链接：wordcloud齿轮下载地址
PyInstaller程序打包
打包应用程序，在终端中，输入
PyInstaller -F package # 在dist文件夹中查看生成的程序
jieba（结巴）库概述
>>> a = "我是中国人民我爱中国"
>>> import jieba
>>> jieba.lcut(a) # 分模式
['我', '是', '中国', '人民', '我', '爱', '中国']
>>> jieba.lcut(a,cut_all=True) # 全模式
['我', '是', '中国', '国人', '人民', '我', '爱', '中国']
>>> jieba.lcut_for_search(a) # 引擎模式
['我', '是', '中国', '人民', '我', '爱', '中国']
wordcloud库概述
生成词云图片
from wordcloud import WordCloud
t = "i like python i am learning python"
word = WordCloud().generate(t)
word.to_file("aaaa.png")
效果如图：
示例1：
# CalStoryOfStone.py
import jieba
f = open("红楼梦.txt","r",encoding = 'UTF-8')
txt = f.read()
f.close()
words = jieba.lcut(txt) # 分词为列表型数据
counts = {} # 字典型变量
for word in words:
if len(word)==1: # 把一个字的忽略
continue
else:
counts[word] = counts.get(word,0)+1
items = list(counts.items())
items.sort(key = lambda x:x[1],reverse = True)
for i in range(15):
word,count = items[i]
print("{0:<10} {1:>5}".format(word,count))
示例2：删除相应的关键词
# CalStoryOfStone2.py
import jieba
excludes = {"什么","一个","我们","那里","你们",\
"说道","知道"}
f = open("红楼梦.txt","r",encoding = 'UTF-8')
txt = f.read()
f.close()
words = jieba.lcut(txt) # 分词为列表型数据
counts = {} # 字典型变量
for word in words:
if len(word)==1: # 把一个字的忽略
continue
else:
counts[word] = counts.get(word,0)+1
for word in excludes:
del(counts[word])
items = list(counts.items())
items.sort(key = lambda x:x[1],reverse = True)
示例3：以词云的方式输出
# CalStoryOfStone3.py
import jieba
excludes = {"什么","一个","我们","那里","你们",\
"说道","知道"}
f = open("红楼梦.txt","r",encoding = 'UTF-8')
txt = f.read()
f.close()
words = jieba.lcut(txt) # 分词为列表型数据
newtxt = ' '.join(words)
wd = WordCloud(backgroud_color = "white",\
width = 800,height = 600,\
font_path = "msyh.ttf",\
max_words = 200,\
max_font_size = 80,\
stopwords = excludes,\
).generate(newtxt)
wd.to_file("红楼梦基本词云.png")
二级公共基础知识部分
第1章 数据结构与算法
算法的基本概念
算法是指解题方案的准确而完整的描述。
算法不等于程序，也不等于计算机方法，程序的编制不可能优于算法的设计。
算法的基本特征
1.可行性
2.确定性：每一个步骤都必须有明确的定义，不允许模棱两可，不允许有多义性。
3.有穷性：算法必须能在有限的时间内做完，即能在执行有限个步骤后终止，包括合理的执行时间的含义。
4.拥有足够的情报
算法的复杂度
1.算法时间复杂度：执行算法所需要的工具量，执行过程中所需基本运算的执行次数来度量算法的工作量。
2.算法空间复杂度：执行算法过程中所需的内存空间。
3.算法的时间复杂度与空间复杂度没有直接关系。
逻辑结构和存储结构
数据的逻辑结构：数据集合中各元素之间所固有的逻辑关系
数据的存储结构：对数据进行处理时，各数据元素在计算机中的存储关系。
数据的逻辑结构在计算机存储空间中的存放形式成为存储结构（或数据的物理结构）。
一种数据的逻辑结构根据需要可以表示成多种存储结构，而采用不同的存储结构，其数据处理的效率是不同的。
数据结构的图形表示
在数据结构中，没有前件的结点称为根节点；没有后件的结点成为终端结点。
插入和删除是数据结构的两种基本运算。
线性结构与非线性结构
线性结构：有且只有一个根节点，每一个结点最多有一个前件，也最多有一个后件。
非线性结构：不满足线性结构条件的数据结构。
线性表及其顺序存储结构
非空线性表的结构特征：
1.有且只有一个根节点a1，它无前件；有且只有一个终端结点an，它无后件；
2.除根节点与终端结点外，其他所有结点有且只有一个前件，也有且只有一个后件。n为线性表的长度，当 \(n=0\)时，称为空表。
线性表的顺序结构具有两个基本特点：
1.线性表中所有元素的所占存储空间是连续的，在插入或删除过程中需要移动大量的数据元素。
2.线性表中各数据元素在存储空间中是按逻辑顺序依次存放的。
栈和队列
栈实践上也是一个线性表，只不过是一种特殊的线性表。
一端开口，一段封死的线性表。一次只能插入或删除一个元素，先进后出，后进先出。
在栈中，栈底指针不变，栈中元素随栈顶指针的变化而动态变化。
队列也是一种特殊的线性表
两端开口，入队就是插入运算，出队就是删除运算，先进先出，后进后出。
循环队列
如果\(rear>front\)，元素个数 = \(rear-front\)
如果\(rear<front\)，元素个数 = 总空间数\(-(front-rear)\)
树与二叉树
树是一种简单的非线性结构，所有元素之间有明显的层次特征。
没有后件的结点称为叶子结点。
树的度为树的最大层次。
二叉树
特点：
非空二叉树只有一个结点；每一个结点最多有两个子树，分 别称为左子树和右子树。
基本性质：
1.在二叉树的第K层上，最多有\(2^{k-1}\)（\(k>=1\)）个结点。
2.深度为\(m\)的二叉树最多有\(2^m-1\)个结点；深度为\(m\)的二叉 树是指二叉树共有\(m\)层。
3.在任意一棵二叉树中，度为0的结点（即叶子结点）总比度 为2的结点多一个。
完全二叉树的叶子结点个数：
当总结点n为偶数时，叶子结点为\(\frac{n}{2}\)；
当总结点n为奇数时，叶子节点为\(\frac{n+1}{2}\)。
通常采用链式存储结构。
二叉树的遍历
前序遍历：根\(\rightarrow\)左\(\rightarrow\)右
中序遍历：左\(\rightarrow\)根\(\rightarrow\)右
后序遍历：左\(\rightarrow\)右\(\rightarrow\)根
查找技术
1.顺序查找，使用情况：线性表为无序表；有序线性表采用链式存储结构
2.二分法查找，适用于有序表，对于长度为n的有序线性表，最坏情况只需比较\(\log_2{n}\)次。
排序技术
排序是指将一个无序列表整理成按值非递减顺序的有序序列。
交换类排序
1.冒泡排序法：是一种最简单的交换类排序方法，它是通过相邻数据元素的交换逐步将线性表变成有序。
假设线性表的长度是n，在最坏的情况下需要比较的次数为\(\frac{n(n-1)}{2}\).
2.快速排序法：\(\frac{n(n-1)}{2}\).
插入类排序法
1.简单插入排序法：最坏情况需要\(\frac{n(n-1)}{2}\)次比较。
2.希尔排序法：最坏情况需要O(\(n^{1.5}\))
选择类排序法
1.简单选择排序法：最坏情况需要\(\frac{n(n-1)}{2}\)次比较。
2.堆排序法：最坏情况需要O(\(n\log_2{n}\))次比较。
第2章 程序设计基础
程序设计方法和风格
程序设计方法和技术的发展而言，主要经历了结构化程序设计和面向对象的程序设计。
养成良好的程序设计风格，主要考虑以下因素：
1.源程序文档化：清晰第一、效率第二
2.数据说明的方法
3.语句的结构
4.输入和输出
结构化程序设计
原则：自顶向下、逐步求精、模块化和限制使用goto语句
基本结构和特点：
1.顺序结构
2.选择结构
3.重复（重复）结构
面向对象的程序设计
基本原理是使用现实世界的概念抽象地思考问题从而自然地解决问题。
对象的基本特点：标识唯一性、分类性、多态性、封装性和模块独立性好
第3章 软件工程应用
软件定义与软件特点
计算机软件是计算机系统中与硬件相互依存的另一部分，包括程序、数据和相关文档的完整集合。
软件可以按功能分为：应用软件、系统软件和支撑软件（工具软件），操作系统是软件的核心。
软件危机与软件工程
“软件危机是”指计算机软件的开发和维护过程中所遇到的一系列严重问题，主要表现在成本、质量、生产率等问题。
软件工程过程与软件生命周期
1.基本概念
软件周期，软件产品从提出、实现、使用维护到停止使用退役的过程。
分为3个时期8个阶段：
软件定义期：问题定义、可行性研究和需求分析
软件开发期：概要设计、详细设计、实现和测试
软件维护期：运行维护阶段。最后一个阶段，也是持续时间 最长，花费代价最大的一个阶段。
需求分析与需求分析方法
需求分析工作可以概括为四个方面：需求获取、需求分析、编写需求规格说明书、需求评审。
结构化分析方法
面向数据流的结构化分析方法的定义：结构化分析就是使用数据流图（DFD）、数据字典（DD）、判定表和判定树等工具，来建立一种新的、称为结构化规格说明的目标文档。
注：数据流程图中的箭头代表的是数据流。
软件设计的基础
1.技术观点上看，软件设计包括软件结构设计、数据设计、接口设计和过程设计。
2.工程管理角度看，软件设计分两步完成：概要设计和详细设计。
软件设计的基本原理
1.基本原理：抽象、模块化、信息隐蔽和模块独立性
2.软件模块独立性使用耦合性和内聚性两个定性的试题标准。
注：在程序结构中，各模块的内聚性越强，耦合性越弱。
优秀软件应高内聚，低耦合。
软件概要设计的基本任务是：
设计软件系统结构、数据结构及数据库设计、编写概要设计文档和概要设计文档评审。
常用的软件设计工具是结构（SC）也称程序结构图。
注：程序结构图中箭头代表的是调用关系。
详细设计
常见过程设计工具有：
图形工具：程序流程图（PFD）、N-S（结构化程序流程图）、PAD（问题分析图）、HIPO
表格工具：判定表
语言工具：PDL（伪码）
注：程序流程图中的箭头代表的是控制流。
软件测试的目的和准则
软件测试的目的是为了发现程序中的错误而执行程序的过程，主要分为白盒测试（内部功能）和黑盒测试（外部功能）。
程序的调试
程序调试的任务是诊断和改正程序中的错误，主要是在开发阶段进行。主要调试方法有：
1.强行排错法
2.回溯法
3.原因排除法
第4章 数据库应用
数据库系统的基本概念
数据（data）、数据库（database）、数据库管理系统（DBMS）
数据库技术的根本目标是解决数据共享问题。数据库管理系统是数据库系统的核心。
数据定义语言（DDL）：负责数据的模式定义与数据的物理存储构建。
数据操纵语言（DML）：负责数据的操纵，如查询、增、删、改等。
DB包含DB和DBMS。
关系数据库系统阶段的特点：共享性大，冗余度小，具有高度的物理独立和一定的逻辑独立性、特定的数据模型。
数据库系统的基本特点
数据的集成性、数据的共享性与低冗余性、数据独立性（物理独立性与逻辑独立性）、统一管理与控制。
数据库系统的内部结构体系
1.概念模式，也称逻辑模式，一个数据库只有一个概念模式。
2.外模式，也称子模式，用户能够看见和，一个概念模式可以由若干个外模式。
3.内模式，也称物理模式，索引属于内模式。
数据模型
数据模型通常由数据结构、数据操作和数据约束三部分组成。
E-R模型
一对一，一对多，多对多。
关系模型
二维表，一个二维表就是一个关系。
关系代数
交、并、差、笛卡尔积
浙公网安备 33010602011771号