计算机二级——Python

第一章 程序设计的基本方法

本章大纲

1. 程序设计语言

2. Python语言的概述

3. Python开发环境配置

4. 程序的基本编写方法

一、程序设计语言

程序设计语言也叫编程语言。计算机程序按照程序设计语言规则组织起来的一组计算机指令

程序设计语言发展经历了机器语言、汇编语言、高级语言的3个阶段

二、编译和解释

高级语言根据计算机执行机制的不同分为两类：静态语言和脚本语言，静态语言采用编译方式执行，脚本语言采用解释方式执行

编译是将源代码转换成目标代码的过程。源代码是高级语言代码，目标代码是机器语言代码，执行编译的计算机程序称为编译器

解释是将源代码逐句转换成目标代码同时逐句运行目标代码的过程。执行解释的计算机程序称为解释器

编译和解释的区别在于编译是一次性的翻译，一旦程序悲编译，不在需要编译程序或者源代码。解释则在每次程序运行时都需要解释器和源代码

采用编译方式执行的编程语言是静态语言，如C语言、Java等；采用解释方式执行的编程语言是脚本语言，如JavaScript语言、PHP语言等。Python语言是一种被广泛使用的高级通用脚本编程语言，采用解释方式执行，但他的解释器也保留了编译器的部分功能，随着程序运行，解释器也会生成一个完整的目标代码。

三、Python语言的诞生

2008年，Python3.x

四、Python开发环境的配置

手工选择矩形框内的“Add Python 3.5 to PATH”

Python解释器有两个重要的工具：

• IDLE：Python集成开发环境，用来编写和调试Python代码

• pip：Python第三方库安装工具，用来在当前计算机上安装第三方库

五、Python的最小程序

使用Python语言编写的Hello程序

  print("Hello World")

">>>"是Python语言运行环境的提示符

六、Python程序的运行方式

Python程序有两种运行方式：交互式和文件式

1. 交互式利用Python解释器即时响应用户输入的代码，给出输出结果

2. 文件式将Python程序写在一个或多个文件中，启动Python解释器批量执行文件中的代码。

   交互式一般用于调试少量代码，文件式是最常用的编程方式

IDLE中快捷键

• Ctrl+N：在IDLE交互界面下用来启动IDLE文件式编辑器

• Atrl+3：在IDLE编辑器内注释选中区域文本

• Atrl+4：在IDLE编辑器内，解除注释选中区域文本

• F5：在IDLE编辑器内，执行Python程序

七、IPO程序编写方法

在程序设计中，每个程序都有统一的运算模式：输入数据、处理数据和输出数据。我们称为IPO程序设计方法

输入（input）：输入是一个程序的开始

处理（Process）：处理是程序对输入数据进行计算产生输出结果的过程

输出（output）：输出是程序展示运算结果的方式

Python程序的特点

Python语言是一种被广泛使用的高级通用脚本编程语言，具有很多区别于其他语言的特点

第二章 Python语言基本语法元素

本章大纲

1. 基本语法元素

2. 基本输入输出

3. 源程序书写风格

一、基本的语法元素

1.缩进

Python语言采用严格的“缩进”来表明程序的格式框架。缩进指每一行代码开始前的空白区域，用来表示代码之间的包含和层次关系

1. 1个缩进 = 4个空格

2. 缩进是Python语言中表明程序框架的唯一手段

当表达分支、循环、函数、类等程序含义时，在if、while、for、def、class、等保留字所在完整语句后通过英文冒号(:)结尾并在之后进行缩进，表明后续代码与紧邻无缩进语句的所属关系

缩进错误：当代码执行遇到了“unexpected indent”错误，就表示代码缩进有问题，我们就可以去查看程序的缩进是否正确

2.注释

注释是代码中的辅助性文字，会被编译或解释器略去，不被计算机执行，一般用于程序员对代码的说明。Python语言采用#表示一行注释的开始，多行注释需要再每行开始都是用#，或‘’‘或“”“

Python程序中的非注释语句将按顺序执行，注释语句将被解释器过滤掉，不被执行。注释一般用于在代码中标明作者和版权信息，或解释代码原理及用途，或通过注释单行代码辅助程序调试

3.续行符

Python程序是逐行编写的，每行代码长度无限制。续行符由反斜杠（\）符号表达

  
  s = "Whether you come or not,\
  I'll be waiting for you there."
  # 等价于
  s = "Whether you come or not,I'll be waiting for you there."

注意

• 续行符后不能存在空格

• 续行符后必须直接换行

二、语法元素的名称

1.标识符

• 由一串字符串组成，字符可以是任意字母、数字、下划线、汉字，不能以数字开头

• 不能与关键字同名，关键字也被称为“保留字”

2.变量

• 在运行过程中可以被修改的量被称为变量

• 变量名必须符合标识符的构成规则

3.常量

• 一旦赋值就不能改变值的标识符，Python中无法定义常量

4.保留字

三、数据类型

1.数据类型概述

计算机对数据进行运算时需要明确数据的含义和类型

Python语言支持多种数据类型

2.数字类型

表示数字或数值的数据类型称为数字类型，Python提供3种数字类型：整数、浮点数和复数

3.字符串类型

计算机程序经常用于处理文本信息，文本信息在程序中使用字符串类型表示。字符串是字符的序列

用一对双引号 “” 或者一对单引号 ’‘ 括起来。字符串包括两种序列体系：正向递增和反向递减

四、程序语句元素

1.表达式

• 产生或计算新数据值的代码片段称为表达式，一般由数据和操作符等构成

2.赋值语句

• 对变量进行赋值的一行代码被称为赋值语句

语法格式：<变量> = <表达式>

3.引用

通过引用，Python可以使用当前程序之外已有的功能代码，从而提高编程效率

【引用方式】import <功能库库名>

引用功能库之后，采用<功能库名称>.<函数名>() 方法去调用具体功能。当然除此之外还有其他方式，后续

4.其他语句

1.分支语句

• 分支语句是控制程序运行的一种语句，他的作用是根据判断条件选择程序执行路径

分支语句包括单分支、二分支和多分支

单分支语句，使用方式如下：

  
  if <条件>:
      <语句块>

任何能够产生True和False的语句都可以作为条件，当条件为真时，执行语句块中的内容

二分支语句，使用方式如下：

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

当条件为True时，执行语句块1；当条件为False时，执行语句块2

2.循环语句

循环语句是控制程序的一类重要语句，他的作用是根据判断条件确定一段程序是否再次执行一次或者多次。循环包括：遍历循环和条件循环

条件循环的基本过程

  
  while (<条件>):
      <语句块1>
  <语句块2>

当条件为True时，执行语句块1，再次判断条件，当条件为False时，退出循环，执行语句块2

3.input()输入函数

• 使用方式：<变量> = input(<提示性文字>)

• 无论用户输入的是字符还是数字，input()函数统一按照字符类型输出

4.eval()

• 使用方式：<变量> = eval(<字符串>)

• 去掉字符串最外侧的引号，并按照Python语句方式执行去掉引号后的字符内容

5.print()输入函数

• 使用方式：

  • 仅输出字符串：print(<待输出字符串>)

  • 仅用于输出一个或多个变量：print(<变量1>,<变量2>,...,<变量n>)

  • 用于混合输出字符串和变量值：print(<输出字符串模版>.format((<变量1>,<变量2>,...,<变量n>)))

• print()函数输出文本时默认在最后增加一个换行，如若不希望在最后增加换行，或者是想要输出其他内容，可以对print()函数的end参数值进行赋值

第三章 基本数据类型

第一节 变量

初始化赋值语句：变量名 = 表达式

示例：

• x = 3

变量：通过变量名代表或引用某个值

= 赋值运算符

变量赋值过程

  x = 1
  x = x + 10
  ​
  name1 = 'leilei'
  name2 = name1
  ​
  name1 = 'leilei'
  name1 = 'meimei'

进阶的赋值方法

  # 同时给多个变量赋值同一个内容
  a = b = c = 100
  ​
  # 同时给多个变量赋予不同的内容
  a , b , c = 1 , 2 , 3

变量名的命名规则

• 大小写英文、数字和_的结合，且不能用数字开头

• 系统关键字不能做变量名使用

  • 获取关键字列表：help('keywords')

• Python中的变量名区分大小写

• 变量名不能包含空格，但可使用下划线来分隔其中的单词

• 不要使用Python的内置函数名称做变量名

第二节 初识数据类型

Python中的基础数据类型

• 布尔型

• 数字型

• 字符串

• 元组

• 字典

• 集合

• 列表

1.数字型

  a = 1
  print(type(a))
  # <class 'int'>
  b = 2.0
  print(type(b))
  # class <'float'>

2.字符串

  a = "Hello World"
  print(type(a))
  # <class 'str'>

3.列表

  a = [1,'two',3.0,'four']
  print(type(a))
  # <class 'list'>

4.元组

  a = (1,'two',3.0,'four')
  print(type(a))
  # <class 'tuple'>

5.字典

  
  a = {1:'one',2:'two'}
  print(type(a))
  # <class 'dict'>

6.集合

  
  a = set([1,2,2,3,2,6,2,1,16,5])
  print(type(a))
  # <class 'set'>

7.布尔型

  
  a = True
  b = False
  print(type(a))
  print(type(b))
  # <class 'bool'>
  # <class 'bool'>

第三节 数字型

• 整数（int）

• 浮点数（float）

1.整数类型

整数类型的4种进制表示

进制种类	引导符号	描述
二进制	0b或0B	由字符0和1组成，例：0b1010
八进制	0o或0O	由字符0到7组成，例：0o1010
十进制	无	默认情况，例：1010
十六进制	0x或0X	由字符09，af或A~F组成，例：0x1010

2.浮点数类型

一般表示法和科学计数法

0.1或1e-1

浮点数计算并不是完全精确的

不要直接比较两个浮点数是否相等

一种解决方法：round()进行四舍五入保留一定位数后再判断

  
  round(0.1+0.2 , 5) == round(0.3 , 5)
  # True

3.数值运算操作符

操作符	描述符
x + y	求两数之和
x - y	求两数之差
x * y	求两数之积
x / y	求两数之商，结果为浮点数
x // y	求两数的整数商
x % y	两数的余数
x ** y	x的y次幂，即xy
-x	一个数的负数
+x	一个数的本身

基本规则

• 整数和浮点数混合运算，输出结果为浮点数

• 整数之间运算，产生结果类型与操作符相关

• 整数或浮点数与复数运算，输出结果是复数

4.增强操作运算符

操作符	描述
x += y	等价于：x = x + y
x -= y	等价于：x = x - y
x *= y	等价于：x = x * y
x /= y	等价于：x = x / y
x //= y	等价于：x = x // y
x %= y	等价于：x = x % y
x**= y	等价于：x = x ** y

5.数值运算函数

函数	描述
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位小数，无参则返回x的整数，“奇进偶不进”
max(x1,x2,x3,···,xn)	任意数量的最大值
min(x1,x2,x3,···,xn)	任意数量的最小值

第四节 字符串

1.字符串

字符串是由字母、数字和特殊字符来组成的序列

从左到右索引默认0开始的，最大范围是字符串长度少1

从右到左索引默认-1开始的，最大范围是字符串开头

创建字符串——使用单引号，双引号或三引号

  
  name = 'leilei'
  number = "12"
  paragraph = '''Hello World
              Hello'''

2.字符串长度

len()函数：返回字符串中的字符长度或者字符数

  
  s1 = 'hello world'
  s2 = 'makerbean'
  print(len(s1))
  print(len(s2))

isinstance()判断类型

  
  s = 'hello'
  isinstance(s , str)
  # True

3.转义字符

转义字符	描述含义
\b	退格，把光标移到前一列的位置
\f	换页符
\n	换行符
\r	回车
\t	水平制表符
\v	垂直制表符

4.format()方法的基本使用

字符串使用方式：<模版字符串>.format(<逗号分隔的参数>)

其中模版字符串是一个由字符串和槽组成的字符串，用来控制字符串和变量的显示效果

  
  "{}那么大，{}想去看看。".format("世界","我")
  # 世界那么大，我想去看看

语法格式为：

{<参数序号>:<格式控制标记>}

5.输出整数和浮点数类型的格式规则

整数：

• b：输出整数的二进制方式

• C：输出整数对应的unicode字符

• d：输出整数的十进制方式

• o：输出整数的八进制方式

• x：输出整数的十六进制方式

• X：输出整数的大写十六进制方式

浮点数：

• e：输出浮点数对应的小写字母e的指数形式

• E：输出浮点数对应的大写字母E的指数形式

• f：输出浮点数的标准浮点型形式

• %：输出浮点数的百分比形式

6.字符串类型的操作

x + y	连接两个字符串
x * n 或 n * x	复制n次字符x
x in s

7.字符串处理函数

函数	描述
len(x)	返回字符串x的长度或者是其他组合类型的元素个数
str(x)	把任意类型转换为字符串形式
chr(x)	返回Unicode编码对应的单字符
ord(x)	返回单个字符对应的Unicode编码
hex(x)	返回整数x对应的十六进制的小写形式
oct(x)	回整数x对应的八进制的小写形式

8.字符串处理方法

方法	描述
str.lower()	以小写的方式全部返回str的副本
str.upper()	以大写的方式返回str的副本
str.split(sep=None)	返回一个列表，以sep作为分隔点，sep默认为空格
str.count(sub)	返回sub子串出现的次数
str.replace(old,new)	返回字符串str的副本，所有old子串被替换为new
str.center(width,fillchar)	字符串居中函数，fillchar参数可选
str.strip(chars)	从字符串str中去掉在其左侧和右侧chars中列出的字符
str.join(iter)	将iter变量的每一个元素后面增加一个str字符串

9.类型转换函数

int(x):将x转换为整数

float(x):将x转换为浮点数

str(x):将x转换为字符串

第五节 列表

1.列表结构

利用中括号表示列表

列表内的元素用逗号隔开

注意是英文输入法下的逗号

  
  student1 = ['leilei',18,'class01',201901]
  student2 = ['meimei',19,'class02',201902]

2.获取列表中的某个元素

编程语言中通常第一个位置的编号是0

中括号内数字指定元素位置

  
  grade = [98,99,95,80]
  print(grade[0]) # 98
  print(grade[0] + grade[3])  # 178

3.修改列表中的某个元素

找到需要修改的元素编号

列表名 [编号] = 新值

  
  name = ['leilei','meimei']
  print(name) # ['leilei','meimei']
  name[0] = 'dongdong'
  print(name) # ['dongdong','meimei']

4.列表的操作函数

列表类型继承序列类型特点，有一些通用的操作函数

操作函数	描述
len(ls)	列表ls的元素个数（长度）
min(ls)	列表ls中的最小元素（内部数据可比较）
max(ls)	列表ls中的最大元素（内部数据可比较）
list(x)	将x转变成列表类型

5.列表的操作方法

列表类型存在一些操作方法，使用语法形式是：

<列表变量>.<方法名称>(<方法参数>)

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

可以使用Python保留字del对列表元素或片段进行删除

del <列表变量>[<索引序号>]

del <列表变量>[<索引起始>:<索引结束>]

6.列表的加法与乘法

加法：两个列表相加合成一个新列表

乘法：列表循环重复几次形成一个新列表

  
  [1,2] + [3,4]
  # [1,2,3,4]
  [1,2]*3
  # [1,2,1,2,1,2]

第六节 字典

1.字典

• 用花括号表示字典

• 字典内每一项都有两个元素组成：key和value

• 各个项用逗号隔开

  
  phone_numbers = {'leilei':'1234','meimei':'3456'}
  print(phone_numbers['leilei'])
  # {key:value,key:value}

• key和value一一对应，同一个键只能有一个对应的值

• 键的类型是不可变的

2.访问字典里的数据

利用中括号加要查询的key

  
  grade = {'leilei':'98','meimei':'99'}
  print(grade['leilei'])

3.更新字典里的元素

  
  grade = {'leilei':'98','meimei':'99'}
  grade['meimei'] = 100   # 更新字典中的键值对
  print(grade)
  grade['dongdong'] = '95'    # 添加一个键值对
  print(grade)

4.字典的删除操作

  
  grade = {'leilei':'98','meimei':'99','dongdong':'95'}
  print(grade)
  del grade['leilei'] # 删除字典里的某一项
  print(grade)
  grade.clear()   # 删除了字典里的每一项
  print(grade)
  del grade   # 删除了字典本身
  print(grade)

5.判断字典是否存在某个key

通过in来判断

  
  d = {'小明':'99','小红':'100'}
  print('小明' in d)

6.字典的操作函数

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

7.字典的操作方法

语法形式：<字典变量>.<方法名称>(<方法参数>)

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

第七节 数字及字符串进阶

1.数字型的第三种类型——复数

  
  a = 1 + 3j
  b = 2 + 4j
  c = a + b
  print(c)
  # 3+7j
  d = a * b
  print(d)
  # -10+10j
  type(a)
  # <class 'complex'>

复数的基本使用方法

提取实数部分：z.real

提取虚数部分：z.imag

  
  z = 1 + 2j
  print(z.real)   # 1.0
  print(z.imag)   # 2.0
  type(z.real)    # <class 'float'>
  type(z.imag)    # <class 'float'>

2.字符串

1.字符串的切片

  
  name = 'meimei'
  print(name[2:4])    #切2-3，包括左边不包括右边
  print(name[1:5:2])  #2为步长，每2个取一个
  print(name[::-1])   #倒序排列输出
  print(name[::-2])   #倒序步长为2输出

第一个冒号左侧不写—默认从0开始；第一个冒号右侧不写—默认取到最后

2.字符串的不可变性

一个创建出来的字符串是不可以进行二次修改的

如果想改变某些内容需要新建一个字符串

  
  s = 'Hello Python'
  s1 = 'Hi' + s[5:]
  print(s1)   # 'Hi Python'

第八节 列表及字典进阶

1.切片获取列表中连续的几个元素

与字符串的切片操作一样

  
  numbers = [0,1,2,3,4,5,6,7,8,9]
  print(numbers[2:6]) # 2为从几号开始，起始位置；6为结束为止
  # [2,3,4,5]
  print(numbers[1:5:2])   # 步长为2
  # [1,3]
  print(numbers[::-1])    # 倒序

2.列表的分片赋值

一次性为多个元素赋值

  
  name = list('Python')
  print(name)
  #['P', 'y', 't', 'h', 'o', 'n']
  name[2:] = list('abc')
  print(name)
  # ['P', 'y', 'a', 'b', 'c']
  numbers = [1,5]
  numbers[1:1] = [2,3,4]
  print(numbers)
  # [1, 2, 3, 4, 5]
  numbers[1:4] = []
  print(numbers)
  # [1, 5]

3.用dict函数创建字典

根据其他序列新建字典

  
  message = [('leilei',98),('meimei',99)]
  d = dict(message)
  print(d)

根据关键字参数新建字典

  
  d = dict(leilei = 98 ,meimei = 99)
  print(d)

4.字典与列表的互相嵌套

由字典构成的列表

  
  student1 = {'name':'leilei','age':18,'grade':98}
  student2 = {'name':'meimei','age':19,'grade':99}
  student3 = {'name':'dongdong','age':18,'grade':95}
  student = [student1,student2,student3]
  print(student)
  # [{'name': 'leilei', 'age': 18, 'grade': 98}, 
  # {'name': 'meimei', 'age': 19, 'grade': 99}, 
  # {'name': 'dongdong', 'age': 18, 'grade': 95}]

在字典中存储列表

  
  favorite_class = {
      'leilei':['数学','英语'],
      'meimei':['语文'],
      'dongdong':['计算机','物理','数学'],
  }
  print(favorite_class['leilei'])
  # ['数学', '英语']
  print(favorite_class['leilei'][0])
  # 数学

第九节 元组及集合

1.列表和元组的对比

区别：

• 列表中，元素用方括号[]包裹；在元组中，元素用圆括号()包裹

• 元组中的元素可以被修改、添加、删除，即列表是可变的数据类型，元组是不可变的数据类型

2.元组可以取值、切片

  b = (2,'leilei',19)
  print(b)
  # (2, 'leilei', 19)
  print(b[2])
  # 19
  print(b[0:2])
  # (2, 'leilei')

元组内的元素如果是可变结构，任然是有可能被修改的

  l = [1,2,3]
  t = (1,2,l)
  print(t)
  # (1, 2, [1, 2, 3])
  l[0] = 5
  print(t)
  # (1, 2, [5, 2, 3])

3.创建集合

直接用花括号创建集合

  
  set1 = {1,2,4,5,8}

使用set()方法

  
  set1 = set([1,2,4,1,2,8,5,5])
  set2 = set([1,9,3,2,5])
  print(set1)
  # {1, 2, 4, 5, 8}
  print(set2)
  # {1, 2, 3, 5, 9}

集合内元素不可重复

4.集合的交集

交集：求两个集合中都拥有的元素

用&运算符实现

  set1 = {1,2,4,5,8}
  set2 = {1,2,3,5,9}
  print(set1 & set2)
  # {1, 2, 5}

5.集合的并集

并集：求两个集合总共有哪些元素

用|运算符实现

  set1 = {1,2,4,5,8}
  set2 = {1,2,3,5,9}
  print(set1 | set2)
  # {1, 2, 3, 4, 5, 8, 9}

6.集合的差集

差集：set1 和set2 的差集时，会返回在set1中但不在set2中的元素

用-运算符实现

  set1 = {1,2,4,5,8}
  set2 = {1,2,3,5,9}
  print(set1 - set2)
  # {8, 4}

7.集合的对称差集

对称差集：求set1和set2的对称差集时，会返回在set1或在set2中，但不同时存在于两个集合中的元素

用^运算符实现

  set1 = {1,2,4,5,8}
  set2 = {1,2,3,5,9}
  print(set1 ^ set2)
  # {3, 4, 8, 9}

  set1 = {1,2,4,5,8}
  set2 = {1,2,3,5,9}
  print((set1 | set2) - (set1 & set2))
  # {8, 9, 3, 4}  效果等于对称差集