计算机二级——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}  效果等于对称差集

作者：辛kai瑞