三级考级要点
编码与数制
进制概念
- 二进制：有0、1两个基本数码，逢二进一，0b或0B开头
- 八进制：有0、1、2、3、4、5、6、7共8个基本数码，逢八进一，0o或0O开头
- 十六进制：有0、1、2、3、4、5、6、7、8、9、A、B、C、D、 E、F共16个基本数码，逢十六进一，0x或0X开头
十进制转其他进制
十进制转二进制：除以2取余，逆序输出
除以2取余数，直到商为0，将所得余数倒排序
>>> bin(11) '0b1011' # 0b开头的数字代码串，表示一个二进制数十进制转八进制：除以8取余，逆序输出
除以8取余数，直到商为0，将所得余数倒排序
>>> oct(143) '0o217'十进制转十六进制：除以16取余，逆序输出
除以16取余数，直到商为0，将所得余数倒排序
>>> hex(143) '0x8f'
注意：bin、oct、hex方法都是将十进制整数转换为二、八、十六进制数，返回的结果是字符串
其他进制转十进制--int
二进制转十进制：按权展开，逐项相加，权为2^n^ ,n为当前位置数字后面的位数
>>> int("0b1011",2) 11 >>> int("1011",2) 11 #也可以省略0b,与上一行代码等价 >>> int(0b1011) 11 #也可以转二进制整数八进制转十进制：按权展开，逐项相加，权为8^n^ ,n为当前位置数字后面的位数
>>> int('0o217',8) 143 >>> int("127",8) #0o可以省略，与上一行代码等价 87 >>> int(0o217) 143 #也可以转八进制整数十六进制转十进制：按权展开，逐项相加，权为16^n^ ,n为当前位置数字后面的位数
>>> int("0x8f",16) 143 >>> int("8f",16) #0x可以省略，x不区分大小写，基数f也不区分大小写，与上一行代码等价 143 >>> int(0x8f) 143 #也可以转十六进制整数
注意：bin、oct、hex方法都是将十进制整数转换为二、八、十六进制数，返回的结果是字符串
二进制与十六进制
- 十六进制的1位可以转成4位二进制
- 二进制的4位转换成1位十六进制
补充说明
- bin、oct、hex方法不但可以转十进制整数，也可以转其他进制整数
>>> bin(17) #十进制17转二进制
'0b10001'
>>> bin(0o17) #八进制17转二进制
'0b1111'
>>> bin(0x17) #十六进制17转二进制
'0b10111'
- int方法不但可以转数字字符串，也可以转整数（必须带进制表示字符0b、0o或0x）
>>> int('11') #十进制11字符串转十进制
11
>>> int('11',2) #二进制11字符串转十进制
3
>>> int(0b11) #二进制11整数转十进制
3
>>> int('11',16) #十六进制11字符串转十进制
17
>>> int(0x11) #十六进制11整数转十进制
17
文件和数据处理
一般文件的读写：
写文件：
1.第一步：打开文件
#1. 一般方式
f=open('test.txt','w') #test.txt文件和代码文件保存在一个路径下
# whth方式，不需要close()
2. with open('test.txt','w') as f:
2.第二步：写文件
f.write('要写的内容')
f.writelines(序列-比如列表)
3.第三步：关闭文件
f.close()
读文件：
1.打开文件
#1. 一般方式
f=open(r'd:\test.txt','r') #指定文件路径，字符串前面加“r”是为了防止字符转义，
# whth方式，不需要close()
with open(r'd:\test.txt','r') as f:
2.读文件
c=f.read() #读取全部内容到字符串变量c中
c=f.readline() #读取一行，再次调用则读写下一行
c=f.readlines() #读取全部行到列表c中
3.关闭文件
f.close()
csv：
写文件：writer()
import csv
with open('xxxx.csv','w',newline='') as f:
writer = csv.writer(f) #创建初始化写入对象
writer.writerow(['color','red']) # 一行一行写入
writer.writerows([('color','red'), ('size','big'),('male','female')]) #多行写入
注意：在Windows里保存的CSV文件是每空一行存储一条数据，使用newline=”可保证存储的数据没有空行。
读文件：
import csv
with open("xxxx.csv",'r') as f:
rows = list(csv.reader(f))
print(rows)
一维数据的读写
将列表对象输出为CSV格式文件，示例如下。
c=['北京','上海','广州','深圳']
f=open('city.csv','w')
f.write(','.join(c)+'\n')
f.close()
注意：f.close()如果不写，则写的内容不能保存的文件中。
从csv格式文件中读出数据，表示为列表对象，示例如下。
f=open('city.csv','r')
c=f.read().strip().split(',')
f.close()
print(c)
上述代码用with语句改写如下。
with open('city.csv','r') as f:
c=f.read().strip().split(',')
print(c)
二维数据的读写
将列表对象输出为csv格式，示例如下。
c=[
['张三','95','98','78','65'],
['李四','85', '89', '68', '93'],
['王五','99', '89', '86', '90'],
]
f=open('cj.csv','w')
for i in c:
f.write(','.join(i) + '\n')
f.close()
从CSV格式文件读出数据，表示为列表对象，示例如下。
f=open('cj.csv','r')
c=[]
for i in f:
c.append(i.strip('\n').split(','))
f.close()
print(c)
[['张三'，'95', '98', '78', '65'],[
'李四’，’85', '89', '68', '93'],['
王五'99', '89', '86', '90']]
文件打开模式
"w"： 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
"r"： 以只读方式打开文件，文件的指针将会放在文件的开头。
"w+" ：打开一个文件用于读写。
"r+"：打开一个文件用于读写。文件指针将会放在文件的开头。
"a"： 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 "a+"： 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
异常处理
语法规则：
try:
<语句块1>
except 异常类型1:
〈语句块2>
except 异常类型2:
〈语句块2>
except:
〈语句块2>
else:
〈语句块3>
finally:
〈语句块4>
当碰到错误语句时，try代码块的剩余代码将会被忽略，选择except代码块的代码执行；
当try语句块正确时，try代码块执行完毕，执行else语句块；
不管try代码块正确与否，finally代码块均要执行，如下例所示。
try:
a=int(input('输入一个数 '))
b=int(input('输入另一个数'))
m=a/b
print('商是',m)
except ValueError:
print('输入的不是数字！')
except ZeroDivisionError:
print('除数为0!')
except:
print('其他错误！')
else:
print('正确！')
finally:
print('程序结束！')
注意：
- try：必须要有
- except：至少要有一个
- else、finally：可以没有
算法
算法的概念
- 使用计算机解决问题的一般过程
(1) 分析问题，建立模型
(2 ) 设计算法
(3 )实现算法及检验结果
- 算法的特征
（1）有穷性：执行步骤是有限的。
（2）确定性：每个步骤的含义应是确切的。
（3）可行性：每个步骤是可行的，并且能在有限的时间内完成。
（4）有0个或多个输入：初始数据可从外界输入，也可含于算法之中。
（5）有一个或多个输出：算法一定要有结果且以一定方式输出。
- 算法的3种表示方法
（1）自然语言：
（2）流程图：
(3) 程序设计语言
- 算法的3种基本结构
(1) 顺序结构
(2) 选择结构
(3)循环结构
解析算法
(1) 解析：用数学公式描述客观事物间的数量关系。
(2) 解析算法：用解析的方法找出表示问题的前提条件与结果之间关系的数学表达式，并通过表达式的计算来实现问题的求解。
枚举算法
枚举算法又叫穷举算法，其基本思想是把问题所有的解一一地罗列出来
- 枚举算法的程序实现
(1 ) 列举与检验过程既不重复也不遗漏。
(2 )尽可能地使可能解的罗列范围最小，以提高解决问题的效率。
(3) 用循环语句(for语句)在一定范围内列举所有可能的解。
(4) 用选择语句(if语句)判断和选择真正的解。
枚举算法的一般格式：
循环结构：
循环体内判断：
冒泡算法
冒泡排序是在一列数据中把较大（或较小）的数据逐次向右推移的一种排序技术。
- 冒泡程序程序的实现(升序)
a=[1,3,2,5,8,7,6]
count = len(a)
for i in range(0, count-1):
for j in range(0, count-1-i):
if a[j] > a[j+1]:
a[j], a[j+1] = a[j+1], a[j]
print(a)
降序排序，只需将代码：
if a[j] > a[j+1]: 修改为： if a[j] < a[j+1]:
选择排序
选择排序算法是对冒泡排序算法的改进。这种方法是在参加排序的所有元素中找出数值最小（或最大）的元素，如果它不是左侧第一个元素，就使它与左侧第一个元素中数据相互交换位置；
- 选择排序程序实现(升序)
a=[3,4,1,2,0,9,10]
count = len(a)
for i in range(0,count-1):
k = i
for j in range(i + 1, count):
if a[k] > a[j]:
k = j
if k!=i:
a[k],a[i] = a[i],a[k]
print(a)
降序排序，只需将代码：
if a[K] > a[j]: 修改为 if a[k] < a[j]:
插入排序
插入排序的过程：先将待排序数列中的第1个数据看成一个有序的子数列， 然后从第2个数据起，将数据依次（从大到小或从小到大）逐个地插入这个有序 的子数列中，以此类推到最后一个数据。
- 插入排序程序框架(升序)
a=[5,3,5,2,8]
count = len(a)
for i in range(1,count):
key = a[i]
j = i-1
while j>=0 and a[j]>key:
a[j],a[j+1]=a[j+1],a[j] #交换a[j]和a[j+1]
j-=1
print(a)
顺序查找
顺序查找的基本思想是从第一个数据开始，按顺序逐个将数据与给定的数据 （查找键）进行比较，若某个数据和查找键相等，则查找成功，输出所查数据的位置；反之，输出未找到。
在列表中查找元素26。
lst = [32, 17,56, 25, 26, 89, 65, 12]
key = 26 #要查找的元素
b = -1 #要查找元素的索引
m= len(lst) #列表长度
for i in range (0, m):
if lst[i] == key:
b = i
break
if b == -1: #-1代表元素未查找到
print ("要查找的元素["+ str (key) + "]不在列表lst中。")
else:
print ("要查找的元素["+ str (key) + "]的索引是：" + str (b))
对分查找
对分查找又称二分查找，是一种高效的查找方法。对分查找的前提是，被查找的数据序列是有序的（升序或降序）。
对分查找的基本思想是在有序的数列中，首先将要查找的数据与有序数列内处于中间位置的数据进行比较，如果两者相等，则查找成功；否则就根据数据的有序性，再确定该数据的范围应该在数列的前半部分还是后半部分；在新确定的缩小范围内，继续按上述方法进行查找，直到找到要查找的数据，即查找成功；如果要查找的数据不存在，即查找不成功。
我们假设有一个列表lst =[12，17，23，25，26，35，47，68，76，88, 96]，要查找元素 key=25，则其对分查找的程序如下。
lst=[12,17,23,25,26,35,47,68,76,88,96]
key = 25
n = len(lst)
i,j= 0,n- 1
b =-1
while i<= j:
m =(i+j)// 2
if key == lst[m]:
b =m #找到了要找的数，赋值给b
break #找到key，退出循环
elif key > lst[m]:
i = m+1
else:
j= m-1
if b ==-1: #-1代表元素未查找到
print("要查找的元素["+ str(key)+"]不在列表lst中。")
else:
print("要查找的元素["+ str(key)+ "]的索引是∶"+ str(b))
核心函数
- 数学运算函数（7个）
abs(x)：返回数字的绝对值
divmod(a,b)：把除数和余数运算结果结合起来，返回一个包含商和余数的元组（a//b，a%b)
max：求最大值
min：求最小值
sum：求和
pow(x,y)：计算x**y
round(x,n)：返回浮点数x的四舍五入值,n表示从小数点位数
- 类型转换函数（15个）
int：转换为整数类型
float：转换为浮点数类型
str：转换为字符串类型
bool：转换为布尔类型
tuple：转换为元组类型
list：转换为列表类型
dict：转换为字典类型
ord：返回参数所对应的ASCII码值
chr：返回参数所对应的ASCII码字符串
bin：：转换为二进制数据
hex：转换为十六进制数据
range：可创建一个整数列表
object：是Python中所有类的基类
set：创建一个无序不重复元素集
>>> set('Python')
{'h', 'o', 't', 'n', 'P', 'y'}
enumerate：用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引序列，同时列出数据和数据下标
>>> l=[78,98,69,85]
>>> for a,i in enumerate(l):
print( a,i)
0 78
1 98
2 69
3 85
序列操作函数（6个）
all：该函数用于判断给定的可迭代参数中的所有元素是否都为 True，如果是则返回 True，否则返回 False。
元素除了值是0、空、None、False外都算 True。
all相当于逻辑运算符的and：找False，找不到就是True，找到了就是Fasle
any：该函数用于判断给定的可迭代参数是否全部为False，是则返回False，否则返回True。
any相当于逻辑运算符or：找True，找不到就是False，找到了就是True
filter
该函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象。如果要将结果转换为列表，可以使用 list()函数来转换。
该函数接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或False，最后将返回True 的元素放到新列表中。
filter()函数的实例∶过滤出列表中的所有奇数。
def jishu (n): return n%2 ==1 newlist = filter(jishu,[1,2,3,4,5,6,7,8,9,10]) n=list(newlist) print(n)运行结果∶
[1, 3, 5, 7, 9]map
map()是 Python 的内置函数，会根据提供的函数对指定的序列做映射。
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列。
把函数依次作用在列表中的每一个元素上，得到一个新的列表并返回。注意，map()函数不改变原列表，而是返回一个新列表，如下例所示。
def square (x): return x**2 l=list(map(square,[1,2,3,4,5])) print(l)运行结果∶
[1, 4, 9, 16, 25]next：：返回迭代器的下一个项目（了解即可）
sorted ：对列表、字符串、元组等进行排序，返回新的列表
对象操作函数（6个）
- help：该函数用于查看函数或模块用途的详细说明，返回对象为帮助信息（了解即可）
- dir：该函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。（了解即可）
- type：查看对应类型
- ascii：该函数返回一个表示对象的字符串
- format：字符串格式化
- vars：该函数返回对象object的属性和属性值的字典对象如果没有参数，就打印当前调用位置的属性和属性值（了解即可）
交互操作函数（2个）
- print：打印输出
- input：输入
文件操作函数（1个）
- open：打开文件