高中信息技术python讲义

本讲义适用于高中信息技术会考、教师资格考试及教师招聘考试。python的所有符号(**'',"",[],(),,**等)都要在英文状态下输入常量和变量常量概念：指程序运行过程中其值始终不发生变化的量。通常是固定的数值或者字符串。举例：45,"Hello"变量概念：指程序运行过程中其值可以发生变化的量。有标识符(变量名)和值两部分组成。格式：标识符 = 值，等号代表赋值举例：a=3,其中a是变量名，

信息技术王凤龙

18322人浏览 · 2022-03-26 15:24:27

信息技术王凤龙 · 2022-03-26 15:24:27 发布

本讲义适用于高中信息技术会考、教师资格考试及教师招聘考试。

python的所有符号( '',"",[],(),, 等)都要在英文状态下输入

常量和变量

常量

概念：指程序运行过程中其值始终不发生变化的量。通常是固定的数值或者字符串。
举例：45,"Hello"

变量

概念：指程序运行过程中其值可以发生变化的量。有标识符(变量名)和值两部分组成。
格式：标识符 = 值，等号代表赋值
举例：a=3,其中a是变量名，3是值

a = 3 # 定义一个变量，变量名为a，变量值为3
print(a) # 输出变量a的值，即 3
a = 4 # 因为变量的值是可以变化的，所以我们可以重新赋值
print(a) # 输出 4

标识符命名规则

标识符由字母(a-z,A-Z)、数字(0-9)以及下划线(_)组成。
标识符第一个字符可以是字母或下划线，但不能是数字。例如：1abc是非法的，而_abc是合法的
标识符字母区分大小写。例如：name和Name是两个不同的变量名
尽量不要与系统函数名冲突，例如len，print不要使用
尽量按照英文命名，例如姓名使用name而不是xingming

注释

注释不会执行，仅用于对编写的代码用于说明，能够使我们更方便的阅读和修改代码。对于较长的程序代码，适当的注释是必要的。

注释分为单行注释和多行注释
单行注释 # 开头
多行注释用三个单引号 ''' 或者三个双引号 """ 将注释括起来

# 我是单行注释，我不会执行
"""
我是多行注释
我也不会执行
"""

数据类型1（掌握）

1、数值Number

有整数(int)、小数/浮点数(float)、复数(complex)三种数值组成。
举例：100,3.14,1+2j

2、字符串String

使用单引号'或者双引号"括起来的任意文本
举例：'abc',"abc"

操作	说明	举例	结果
获取	字符串[索引/切片]	参加下方”索引与切片“知识点
连接	使用乘号“*”重复字符串	“Hello" + " World"	“Hello World”
重复	使用乘号“*”重复字符串	“Hello” * 3	“HelloHelloHello”
长度	len(”Hello“)	len(a)	5

3、列表List

如果你学过其他语言，那么python的列表和其他语言中的数组是十分相似的。

写在方括号[]之间、用逗号分割的元素列表。其元素可以是不同类型
举例：[2,4,6,8],[100,'abc',200,'def']

操作	格式	说明
获取	列表[索引/切片]	参加下方”索引与切片“知识点
新增	列表.append(值)	末尾追加一个元素
修改	列表[索引] = 值
删除	列表.pop()	删除末尾元素
长度	len(列表)	得到列表的元素个数

a = ["red","green","blue","white","black"] # 定一个一个具有五个元素的列表，并赋值给变量a
print(a[0]) # 输出：red
print(a[-1]) # 输出：black
print(a[1:3]) # 输出：['green', 'blue']
a[1] = "purple" # 修改a[1]的值
print(a) # 输出：['red', 'purple', 'blue', 'white', 'black']
a.append("yellow") # 末尾追加一个元素
print(a) # 输出：['red', 'purple', 'blue', 'white', 'black', 'yellow']
a.pop()  # 删除末尾元素
print(a) # 输出：['red', 'purple', 'blue', 'white', 'black']

索引与切片

索引与切片的对象可以是字符串、列表以及下文讲到的元组

索引

索引index即元素在列表中的位置，我们可以根据元素获取指定位置的值，格式[索引]

索引是从0开始的，后一个是1，以此类推。不仅仅是python，几乎所有程序都是从0开始计数的。
索引也可使用负数，负数从最后一个是-1开始，前一个是-2，以此类推。参加下表

a = ["red","green","blue","white","black"]
print(a[0]) # 获取第一个元素
print(a[1]) # 获取第二个元素
print(a[3]) # 获取第四个元素
print(a[-1]) # 获取最后一个元素

切片

切片可以获取指定范围内的多个元素，切片以索引为基础。

切片共分为三种情况，如下：

[start:end] ：获取从索引start~end范围的元素（不包含end，左闭右开原则）
[start:]：省略end，获取从索引start到最后一个范围的元素（包含最后一个）
[:end]：省略start，获取从第一个到索引end范围的元素（不包含end）

a = ["red","green","blue","white","black"]
print(a[1:3]) # 输出：['green', 'blue']
print(a[1:]) # 输出：['green', 'blue', 'white', 'black']
print(a[:3]) # 输出：['red', 'green', 'blue']

数据类型2（认识）

4、元组Tuple

写在圆括号()之间，操作同列表一样，但与列表的不同之处在于元组不能修改(不能新增、删除和改变值)
举例：(2,4,6,8),(100,'abc',200,'def')

5、集合Set

写在方括号{}之间、用逗号分割的元素列表。
集合是一个无序且不重复的序列。顾名思义，适用于集合与集合之间 交&、并|、差- 的运算。
创建一个空集合必须使用set()

a = {10,20,30,40}
b = {10,30,50,70}
print(a&b) # 并集 {10, 30}
print(a|b) # 交集 {70, 40, 10, 50, 20, 30}
print(a-b) # 差集 {40, 20}

6、字典Dictionary

写在方括号{}之间、用逗号分割的键(key)值(value)对无序列表。
键一定是唯一的(有则改之，无则加之)。

操作	格式	说明
获取	字典[键]
新增	字典[键] = 值	键不存在
修改	字典[键] = 值	键已存在
删除	字典.pop(键)

a = {"name":"张三","sex":"男"} # 定义一个字典，其中包含两个键值对
print(a["name"]) # 输出键对应的值,输出：张三
a["age"] = 18 # 无则新增
print(a) # 输出：{'name': '张三', 'sex': '男', 'age': 18}
a["name"] = "李四" # 有则改之
print(a) # 输出：{'name': '李四', 'sex': '男', 'age': 18}
a.pop("sex") # 删除”sex“对应的键值对
print(a) # 输出：{'name': '李四', 'age': 18}

类型转换

因为在程序中是不允许字符串和数值进行连接或者计算的，所以我们需要进行类型转换

int() 转换为整数，还可以直接取出小数的整数部分(非四舍五入)
float() 转换为小数(浮点数)
str() 转换为字符串类型

"""基本操作"""
print(int("100")) # 将字符串“100”转换为整数100
print(int(3.14)) # 取出3.14的整数部分3
print(float("3.14")) # 将字符串“3.14”转换为小数3.14
print(str(100)) # 将整数100转换成字符串“100”
"""实际应用"""
print("18"+22) # 这句代码错误，字符串不能和数值进行计算
print(int("18")+22) # 转换为数值之后就可以计算了
print("小明的年龄是："+18) # 这句代码错误，字符串不能和数值进行连接
print("小明的年龄是："+str(18)) # 转换为字符串之后就可以连接了

输入输出

输出print()

格式：
方括号[]代表其中的内容是可选的，可以省略。如果所有都省略即print()则代表换行
输出内容可以是常量、变量等，多个内容使用逗号分割。
sep代表每个输出内容之间的分隔符，默认是空格space。
end代表输出的结尾，默认是\n换行（这也就是为什么print正常不会同一行输出的原因），如果我们需要不换行输出，只需要指定end=""即可。

name = "小明" # 定义一个变量name并赋值为字符串"小明"
age = 18 # 定义一个变量age并赋值为整数18
print(name,"的年龄是",age) # 小明 的年龄是 18(默认空格隔开)
print(name,end="") # 输出小明但不换行
print(age) # 输出：小明18(因为上一个未换行，所以18直接接着上一行输出)
print() # 单纯的换行
print("a","b","c","d",sep="*") # 输出：a*b*c*d

在这里插入图片描述

输出内容的常见方式：
1. 字符串拼接，字符串不能直接与数字拼接，需要str转换
2. 使用逗号分割，默认空格隔开，通过sep=""去除空格
3. 使用format()函数，花括号{}和format()的参数一一对应

name = "小明" # 定义一个变量name并赋值为字符串"小明"
age = 18 # 定义一个变量age并赋值为整数18
print(name+"的年龄是"+str(age)) # 输出方式1：小明的年龄是18
print(name,"的年龄是",age,sep="")#  输出方式2：：小明的年龄是18(指定分隔符为空字符串)
print("{}的年龄是{}".format(name,age)) # 输出方式3：小明的年龄是18

输入input()

格式：
input函数默认的返回结果是字符串，如果需要输入整数需要使用int转换，小数使用float转换。见下：

name = input("请输入你的姓名：") # 接收一个字符串姓名
age = int(input("请输入你的年龄：")) # 接收一个数值年龄，需要int转换
print(name,"的年龄是",age) # 逗号分割输出
print(name+"的年龄是"+str(age)) # 字符串拼接输出

结果如下：

在这里插入图片描述

运算符与表达式

对常量或变量进行运算或处理的符号称为运算符，比如加号+。由运算符连接的式子称为表达式，比如3+7

1、算术运算符

+、-、*、/：加、减、乘、除
%：求余数
//：整除
**：幂运算

print(5 * 2) # 输出：10
print(5 / 2) # 输出：2.5
print(5 // 2) # 输出：2，等价于int(5/2)
print(10 % 3) # 输出：1，因为10除3等于3余数1
print(10 % 5) # 输出：0，因为10除3等于1余数0，代表10可以被5整除
print(5 % 2) # 输出：1，可以利用求余2是否等于0判断奇偶性
print(5 ** 2) # 输出：25，5的平方

2、关系运算符

关于运算符的结果只有两种，既True(真)和False(假)

>、>=、<、<=：大于、大于或等于、小于、小于或等于
==：判断是否两边是否相等
!=：判断是否不相等

print(2 < 1) # 输出：False
print(1 >= 1) # 输出：True
print(5+5 == 10) # 输出：True
print(2 != 5) # 输出：True

3、逻辑运算符

逻辑运算符包括and,or,not共三个，见下：

运算符	描述	举例	结果
and	两边都为True才为True，否则为False	True and False	False
or	两边有一个为True即为True，都为False才为False	True or False	True
not	True返回False，False返回True	not False	True

print(1>2 and 4>3) # 输出：False
print(2>1 and 4>3) # 输出：True
print(1>2 or 4>3) # 输出：True
print(2<1 or 4<3) # 输出：False
print(not 4<3) # 输出：True
print(not 4>3) # 输出：False

4、赋值运算符

赋值运算符	描述	实例	说明
=	赋值运算符	a = 10
+=	加法赋值	a += 20	等价于 a = a + 20
%=	求余赋值	a %= 3	等价于 a = a % 3
*-=、=、/=、//=、=	同上

a = 10 # 给变量a赋值为10
print(a) # 输出：10
a = b = 10 # 将a和b同时赋值为10
print(a,b) # 输出：10 10
a,b = 10,20 # a赋值10，b赋值20
print(a,b) # 输出：10 20
a = a + 10 # 将a的值加10，a变为20
a += 10 # 等价于 a = a + 10，a变为30
print(a) # 输出：30
a %= 4 # 等价于 a = a % 4，30除4的余数为2
print(a) # 输出：4

5、成员运算符

判断序列中是否有某个成员，序列可以是字符串、列表、元组等

成员运算符	描述
in	x in y，如果x是序列y的成员，返回True，否则返回False
not in	x not in y，如果x不是序列y的成员，返回True，否则返回False

print('a' in 'abcdedg') # 输出：True
print(1 in [1,2,3,4]) # 输出：True
print(5 in [1,2,3,4]) # 输出：False
print(5 not in [1,2,3,4]) # 输出：True

6、运算符优先级

括号()的优先级一定是最大的，有括号先算括号
算数运算符>关系运算符>赋值运算符>成员运算符>逻辑运算符
逻辑运算符中：not>and>or

内置函数

函数是Python语言程序的基石，是组织好的、可重复利用的、用来实现单一功能或相关联功能的代码段。Python默认带有一些常用的函数，称为“内置函数”，见下表：

函数名称	使用说明	举例	结果
len(x)	返回x的长度，x可以使字符串、列表等	len(“python”)	6
abs(x)	返回x的绝对值	abs(-100)	100
pow(x,y)	返回x^y，等价于x**y	pow(5,3)	125
min(x)	返回x的最小值，x可以是列表、元组等	min([11, 20, 13])	11
max(x)	返回x的最大值，x可以是列表、元组等	max([1, 20, 13])	20
sum(x)	返回x的和，x可以是列表、元组等	sum([1, 20, 13])	34
round( x [, n=0] )	对x进行小数四舍五入，n表示小数位数，默认是0	round(3.1415,2)	3.14
divmod(a,b)	以元组的形式返回a除b的商和余数	divmod(10,3)	(3,1)
bin(x)	返回x的二进制数字	bin(10)	0b1010
chr(x)	返回整数x对应的ASCII码字符	chr(65)	A
ord(x)	返回ASCII码字符x对应的整数	ord(“A”)	65
int()、float()、str()	参加上方”类型转换“知识点
print()，input()	参加上方” 输入输出 “知识点
math.pi	返回圆周率	math.pi	3.1415926……
math.sqrt(x)	返回 $\sqrt{x}$	math.sqrt(64)	8.0
random.random()	返回一个 0 <= N < 1 的随机数N	random.random()	不唯一
random.randint(a,b)	返回一个a <= N <= b的随机整数N	random.randint(1,10)	不唯一
random.choice(x)	随机返回序列x中的一个值，序列可以是字符串、列表、元组等	random.choice([‘a’,‘b’,‘c’])	不唯一

print(len("python")) # 输出：6
print(len(["red","green","blue","white","black"])) # 输出：5
"""使用math一定要先导入math"""
import math # 使用math必须先导入
print(math.pi) # 输出：3.141592653589793
print(round(math.pi,2)) # 输出 3.14
print(math.sqrt(64)) # 输出：8.0
"""使用random一定要先导入random"""
import random # 使用random必须先导入
print(random.random()) # 输出一个[0.0, 1.0)的随机数
print(random.randint(1,100)) # 输出一个[1, 100]的随机整数
print(random.choice(["red","green","blue","white","black"])) # 随机返回列表中的一个元素

自定义函数

python中的系统函数不能满足实际中不断变化的需求，我们可以通过自定义函数来将这些功能具体且经常使用的代码段封装成函数。

格式：
说明：
- def是定义一个函数的标志，属于系统保留字，不能用作变量名、方法名、参数名；
- 若用户定义的函数名和系统函数恰好重名，则使用用户定义的函数覆盖系统函数；
- 参数
  - 参数可以是零个到多个；
  - 当参数个数为0是我们称为无参函数，但def 后的括号()依然要书写；
  - 参数分为形参和实参，创建函数的参数我们称为形参，调用函数的参数我们称为实参；
  - 形参的改变并不会影响基本数据类型(字符串、列表)的实参；
```
"""定义一个函数，接收两个参数，返回两个数的平方和"""
def test(a,b): # 这里的a,b是形参，形参a、b修改并不影响是实参a、b的值
	a = a ** 2
	b = pow(b,2)
    print(a,b) # 输出 25 100
	return a + b
"""调用函数，传递两个参数"""
a = 5 # 这里的a,b是形参
b = 10
print("两个数的平方和是:",test(a,b)) # 输出：两个数的平方和是: 125
print(a,b) # 输出：5 10，实参的值没有发生改变
```
- return
  - return语句可以省略，可以出现在函数体的任意位置；
  - return一旦执行，就代表函数执行完成，不会再往下继续执行了；
举例：定义一个求两个数字的最大值函数？

"""定义一个函数，接收两个参数，返回两个参数的最大值"""
def max(a,b): 
    if a > b:
        return a
    else:
        return b
"""调用函数，传递两个参数"""
a = int(input("请输入第一个整数：")) 
b = int(input("请输入第二个整数：")) 
print("两个数中最大的数是:",max(a,b))

顺序结构

顺序结构是最常用、最简单的程序结构，其语句时自上而下，依次执行的

例如下方的程序，一定是先等用户输入数字后再输出计算结果的。

a = int(input("请输入第一个整数：")) # 第一步
b = int(input("请输入第二个整数：")) # 第二步
c = a + b # 第三步
print("两个整数的和是",c) # 第四步

选择结构

在解决问题的过程中，常常需要对事物进行判断和选择。在程序设计中，主要使用条件语句 if 来进行判断和选择。包括下列三种选择结构：

1、单分支选择结构

格式：
执行过程：语句组只有在条件表达式的值为真True时才会执行，否则为假False不执行
说明：
- if后面加空格后接条件表达式，条件表达式后一定要加冒号:
- 语句组可以是一行代码，也可以是多行代码，代码前要有缩进(单个或多个空格)。
- 无论是语句还是语句组都要严格遵循相同的缩进(空格个数相同)
举例：输出用户输入的数字的绝对值？

a = int(input("请输入一个整数："))
if a<0:
    a = -a # 如果小于0就取a的相反数，大于等于0就不执行；可以看到语句前面有明显的缩进
print("输入数字的绝对值是：",a)

2、双分支选择结构

格式：
执行过程：条件表达式为真True执行语句组A，否则为假False执行语句组B
举例：判断用户输入的数字是奇数还是偶数？

a = int(input("请输入一个整数："))
if a % 2 == 0: # 如果求余2等于0就是偶数，否则就是奇数
    print("是偶数")
else:
    print("是奇数")

3、多分支选择结构

当有三个及以上的选择是，可以使用多分支选择结构

格式：
执行过程：条件表达1为真True执行语句组1，否则依次判断表达式2、3……N，只要其中有一个为真True，即执行对应的语句组并不在进行接着判断，如果所有表达式都为假False，执行else后的语句组
举例：根据用户的成绩输出对应的等级？(90分及以上为A，80-89分为B，70-79分为C，60-69分为D，69分以下为E)

a = float("请输入你的成绩：") 
if a>=90:			   # 90分及以上为A
    print("A")
elif a>=80 and a<= 89: # 80-89分为B
    print("B")
elif a>=80 and a<= 89: # 70-79分为C
    print("C")
elif a>=80 and a<= 89: # 60-69分为D
    print("D")
else: 				   # 69分以下为E
    print("E")

循环结构

程序的循环结构时程序设计中常用到的基本结构之一。循环是让计算机自动完成重复工作的常见方式。for循环和while循环是两种常用的循环方式。

1、for循环结构

格式：
说明：
- 序列可以是字符串、列表、元组、range()函数等
- 循环变量是序列中每次循环的值
执行过程：依次读取序列中值赋值给循环变量，直到序列的所有值读取完成后，才结束循环。
使用：
1. 循环列表或字符串
```
"""循环字符串，依次读取字符串中的字符赋值给i"""
for i in "python":
    print(i)
"""循环列表，依次读取列表中的元素赋值给i"""
for i in ["red","green","blue","white","black"]:
	print(i)
```
1. 循环range()函数
  
  range函数可以快速的帮助我们生成有序的可循环的数字序列，从而是我们更方便的控制for循环
  - 格式：
  - 说明：
    - 从start开始，每次增加step，直到stop结束（不包括 stop）
    - start：start代表生成序列的起始位置，省略默认是0；例如：range(10)等价于range(0,10)
    - stop：stop代表生成序列的结束位置，但不包括 stop(左闭右开原则)。例如：range（2,6）是[2, 3, 4,5]没有6
    - step：
      - 步长，省略默认为1。例如：range（1,10,2）是 [1, 3, 5, 7, 9]，从1开始每次增加2
      - step可以为负数，负数代表生成降序的数字序列，此时应start>stop。例如：range(5,0,-1)，是[5, 4, 3, 2, 1]，从5开始每次增加-1
```
# 依次输出：0, 1, 2, 3, 4, 5, 6, 7, 8, 9
for i in range(10):
    print(i)
# 依次输出：2, 3, 4, 5
for i in range(2,6):
    print(i)
# 依次输出：1, 3, 5, 7, 9
for i in range(1,10,2):
    print(i)
# 依次输出：5, 4, 3, 2, 1
for i in range(5,0,-1):
    print(i)
```

举例：求前100项(含100)正整数和？

s = 0 # 用来保存求和的值
for i in range(1,101): # 不包含101
    s = s + i
print("前100项正整数和是：",s)

2、while循环结构

使用for循环的前提是：“明确的知道循环的列表或者循环的次数”。那对于不明确的循环次数我们怎么办呢？这时候我们就可以使用while循环来解决，因为while循环是根据循环的条件来执行的，而不是次数。

格式：
执行过程：只要条件表达式为True循环就一直执行，直到条件表达式为假False，才结束循环。
举例：已知S = 1+2+3+4……+n，若S小于等于1000，求n的最大值？（明显的不知道具体的循环次数，但知道循环条件，即S<=100）

s = 0 # 用来保存求和的值
n = 0 # 每次递增求和的值，即1,2,3……
while s <= 1000:
    n = n + 1
    s = s + n
print("n的最大值为：", n - 1) # 因为加上最后一个数大于1000,所以取最后一个数的前一个

3、循环嵌套

单独使用for循环或while循环单循环语句，往往无法解决复杂的问题。如需要解决类似“工作要做很多遍，而每一遍工作都是需要重复做一些事情”的问题，就要用到多重循环，即"嵌套循环"。

举例1：我国古代数学家张丘建在《算经》一书中提出的数学问题：“鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？”
翻译：公鸡一只5元，母鸡一只3元，小鸡三只1元，用100元买了100只鸡，问公鸡、母鸡、小鸡各有多少只？
分析问题：公鸡、母鸡、小鸡分别用x、y、z表示，则满足x+y+z = 100, 5x+3y+3/z = 100，方程无法直接求出解，利用穷举法对x,y,z的所有可能解进行循环尝试，x的循环范围是1-20，y的循环范围1-33，z = 100-x-y
设计算法：
1. 公鸡x从1-20循环
2. 母鸡y从1-33循环
3. 小鸡z = 100-x-y
4. 若x5 + y3 + z/3 == 0，则输出结果，即x、y、z的值

for x in range(1,21): # 公鸡最多100/5,即20个
    for y in range(1,34): # 母鸡最多33个
        z = 100-x-y
        if x*5 + y*3 + z/3 == 100:
            print("鸡翁:",x,"鸡母:",y,"鸡雏：",z)

举例2：打印九九乘法表
分析：需要两层循环，第一层循环控制行，第二层循环控制每行的列。

for i in range(1, 10):
    for j in range(1, i+1):
        print("{}*{}={}\t".format(j,i,i*j),end="") # \t代表制表符，即4个空格
    print() # 换行

4、循环控制

break是直接结束整个循环，后面所有循环都不再执行。循环结束。
countinue是仅跳出本次循环，而直接进入下一次循环，本次循环countinue后面的语句不再执行。循环没有结束。
举例：

"""break测试"""
a1 = []
for i in range(1,10):
    if i % 3 == 0:
        break # 遇到break直接结束整个循环
    else:
        a1.append(i)
print(a1) # 输出：[1, 2]

"""continue测试"""
a2 = []
for i in range(1,10):
    if i % 3 == 0:
        continue # 遇到countinue直接进入下一次循环
    else:
        a2.append(i)
print(a2) # 输出：[1, 2, 4, 5, 7, 8]

for … else

在 python 中，for … else 表示这样的意思：for 中的语句组和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。

执行过程：若循环没有执行break语句就执行else，若循环执行break语句就不执行else。即break和else只能有一个执行。
举例：

"""执行else不执行break,输出1-9"""
for i in range(1,10):
    print(i) 
    if i > 10: # 条件不可能成立，break不可能执行，循环结束后会执行else
        print("我是break我要被执行了")
        break
else:
    print("我是else我被执行了")

"""执行break不执行else,输出1-3"""
for i in range(1,10):
    print(i)
    if i % 3 == 0: # i=3时条件成立，break会执行,else不会被执行
        print("我是break我要被执行了")
        break
else:
    print("我是else我被执行了")