Python程序设计

章节一：python简介

1. 计算机语言分类

低级语言：机器语言（二进制指令串，计算机可直接执行）和汇编语言（使用助记符，需翻译后执行）。
高级语言：如C++、VB、Python、Java等，接近人类自然语言，需通过编译或解释执行。

2. 程序设计语言的发展阶段

正确顺序：机器语言 → 汇编语言 → 高级语言。脚本语言是高级语言的一个分支，并非独立发展阶段。

3. 汇编语言特性

汇编语言使用助记符（如MOV、ADD）代替二进制指令，但最终仍需翻译为机器码才能执行，不能直接操作计算机硬件。直接操作硬件的是机器语言。

4. 编译与解释的区别

编译型语言（如C、C++）：一次性翻译整个源程序，生成独立可执行文件。
解释型语言（如Python）：每次执行时逐行翻译，不生成独立可执行文件。

5. Python语言的主要特性

是一种面向对象的语言（支持类和对象）。
是一种解释型语言（逐行解释执行）。
是一种跨平台语言（同一份代码可在Windows、Linux、macOS等系统上运行），常被称为“胶水语言”。
是一种脚本语言（通常解释执行，无需显式编译步骤）。

6. IDLE常用快捷键

F5：运行当前脚本（Run → Run Module）。
F1：打开帮助文档。
Ctrl+S：保存文件。
Ctrl+Z：撤销操作。

7. Python文件扩展名规范

源代码文件扩展名为 .py。
编译后的字节码文件扩展名为.pyc（非源代码文件）。
其他扩展名如.pyw（窗口程序）、.pyd（动态链接库）用途不同。

8. 常见Python开发工具特点

IDLE：Python自带的简易IDE，体积小巧，具备代码编辑、运行、调试等基本功能，无需额外安装。
IPython：增强的交互式Python解释器，支持变量自动补全、自动缩进、内置丰富功能。
Jupyter Notebook：基于浏览器的交互式程序编写和运行环境，通过切换后台内核支持多种语言。
PyCharm：由JetBrains打造的专业Python IDE，分为社区版（免费开源） 和专业版（付费试用），因此并非“需要购买才能使用”。

题1（程序基础及Python简介部分）：以下不属于高级程序设计语言的是（C ）。
A. C++ B. VB C. 机器语言 D. Python
题2（程序基础及Python简介部分）：以下关于程序设计语言的描述，错误的选项是（C ）。
A. Python语言是一种脚本编程语言 B. 汇编语言是直接操作计算机硬件的编程语言
C. 程序设计语言经历了机器语言、汇编语言、脚本语言三个阶段
D. 编译和解释的区别是一次性翻译程序还是每次执行时都要翻译程序
- A正确：Python是脚本语言（解释执行）。
- B错误：直接操作硬件的是机器语言，汇编语言需助记符且需翻译才能执行。
- C错误：正确三个阶段是机器语言→汇编语言→高级语言，不是脚本语言。
- D正确：编译是一次性翻译，解释是每次执行时翻译。
题3（程序基础及Python简介部分）：关于Python语言的特点，以下选项描述正确的是（B ）。
A. Python语言不支持面向对象 B. Python语言是解释型语言
C. Python语言是编译型语言
D. Python语言是非跨平台语言
题1（Python开发工具部分，填空题）：在Python内置集成开发环境IDLE中，可以使用快捷键___F5___运行当前打开的源代码程序。
题2（Python开发工具部分，填空题）：Python源代码程序编译之后，文件的扩展名是什么？.pyc
题3（Python开发工具部分）：下面关于Python相关工具描述错误的是（D ）。 A. IDLE是Python解释器自带的一个简易IDE，体积小巧，但功能也相当完备，具备代码编辑、运行、调试等功能
B. ipython可以看作是一个增强的Python Interpreter，支持变量自动补全、自动缩进，内置了许多很有用的功能和函数
C. jupyter notebook是一个基于浏览器的交互式程序编写和运行环境，通过切换后台的内核，支持多种语言 D. pycharm是集成式的Python开发环境，功能强大、完善，但是需要购买才能够使用

第一章：Python基础入门

1.1 注释

Python中单行注释使用 # 开头，用于对代码进行解释说明，不会被程序执行。

# 这是一个单行注释
print("Hello")  # 也可以写在代码后面

1.2 变量

变量用于存储数据，在Python中不需要事先声明类型，直接赋值即可。

变量命名规则：

只能包含字母、下划线、数字
不能以数字开头
区分大小写

# 合法的变量名
myNum = 1
myNumber = 2
_Number = 1
_number = 2
the_name = "name"

# 非法的变量名（会报错）
# 1myNum = 1  # 不能以数字开头

赋值操作： 等号左边是变量名，右边是变量的值。

a = 1         # 把1赋值给变量a
b = 1.2
c = "word"
d = 'word'    # 单引号或双引号都可以表示字符串

1.3 基本数据类型

数据类型	英文名称	示例
整型	int	`a = 1`
浮点型	float	`b = 1.2`
字符串	str	`c = "hello"`
布尔型	bool	`e = True`, `f = False`

布尔值只有两个：True（真）和 False（假）。

1.4 输出（print）

# 输出固定字符串
print("你好，世界")

# 输出变量值
a = 10
print(a)

# 字符串中包含变量（格式化输出）
name = "小明"
print(f"我的名字是{name}")   # 推荐使用f-string
# 或者
print("我的名字是" + name)   # 字符串拼接

特殊字符：

\t：制表符（长空格）
\n：换行 不换行输出：

print("hello", end="")
print("world")
# 输出：helloworld

1.5 输入（input）

# 输入内容，默认是字符串类型
name = input("请输入你的名字：")

# 输入数字，需要转换类型
age = int(input("请输入你的年龄："))

1.6 类型转换

# 强制转换类型
a = 1
b = float(a)     # 1 → 1.0
c = str(a)       # 1 → "1"
d = bool(a)      # 1 → True

1.7 随机数

import random

# 随机整数（包含1和100）
a = random.randint(1, 100)

# 随机小数（指定范围）
b = random.uniform(1, 10)

# 随机小数（0到1之间）
c = random.random()

第二章：运算符与表达式

2.1 算术运算符

运算符	作用	示例
`+`	加法	`a + b`
`-`	减法	`a - b`
`*`	乘法	`a * b`
`/`	除法	`a / b`（结果可能是小数）
`**`	幂运算	`a ** 10`（a的10次方）
`%`	取余（求模）	`a % 2`（a除以2的余数）
`//`	整除	`a // b`（取商的整数部分）

注意： 如果两个整数做除法，结果可能自动转换为浮点型。

2.2 赋值运算符

a = 1
a += 1      # 等价于 a = a + 1
a -= 1      # 等价于 a = a - 1
a *= 2      # 等价于 a = a * 2
a /= 2      # 等价于 a = a / 2
a **= 10    # 等价于 a = a ** 10

2.3 比较运算符

运算符	含义	示例
`==`	等于	`a == b`
`!=`	不等于	`a != b`
`>`	大于	`a > b`
`<`	小于	`a < b`
`>=`	大于等于	`a >= b`
`<=`	小于等于	`a <= b`

注意： = 是赋值，== 是比较是否相等，两者不能混淆。

2.4 布尔运算符（逻辑运算符）

运算符	含义	说明
`and`	与	两边都为True时结果为True
`or`	或	至少一边为True时结果为True
`not`	非	取反，True变False，False变True

a = False
b = not a   # b = True

2.5 运算符优先级

可以使用小括号 () 改变运算顺序，嵌套使用即可。

2.6 字符串运算

# 字符串拼接
s = "hello" + " " + "world"   # "hello world"

# 字符串重复
s = "ha" * 3                  # "hahaha"

# 混合使用
s = "ha" * 3 + "!"           # "hahaha!"

第三章：流程控制

3.1 条件判断（if / elif / else）

基本语法：

if 条件:
    # 条件为True时执行的代码
else:
    # 条件为False时执行的代码

Python缩进规则： 使用一个Tab键或4个空格进行缩进，同一层次的代码缩进量必须一致。

示例：判断是否偶数

a = 10
b = a % 2
if b == 0:
    print("是偶数")
else:
    print("不是偶数")

简化写法：

a = 10
if a % 2 == 0:
    print("是偶数")
else:
    print("不是偶数")

多分支判断（elif）：

score = int(input("请输入你的分数："))

if score < 0 or score > 100:
    print("分数不合法")
elif score < 60:
    print("不合格")
elif score < 80:
    print("合格")
else:
    print("优秀")

分支可以嵌套：

if 条件1:
    if 条件2:
        # 嵌套的代码
    else:
        # 嵌套的代码
else:
    # 代码

3.2 循环语句

3.2.1 while循环

a = 0
while a < 10:
    a += 1
    print(a)
print("end")

注意： while循环一定要有循环变量的变化，否则容易形成死循环。

# 死循环示例
while True:
    print("一直执行")

3.2.2 for循环

for循环在Python中更常用，主要用于遍历一个序列。

# 执行10次
for i in range(10):
    print(i)   # 输出0,1,2,...,9

range()函数：

range(10)：从0到9（左闭右开）
range(5, 10)：从5到9
range(1, 10, 2)：从1开始，每次加2，到9结束（步长为2）

遍历列表：

arr = [1, 2, 3, 4, 5]
for i in arr:
    print(i)

遍历字符串：

for ch in "hello":
    print(ch)   # 输出h,e,l,l,o

3.2.3 break和continue

break：跳出当前整个循环，循环不再执行。
continue：跳过当前这一次循环，继续下一次循环。

# break示例
for i in range(10):
    if i == 5:
        break
    print(i)   # 输出0,1,2,3,4

# continue示例
for i in range(10):
    if i == 5:
        continue
    print(i)   # 输出0,1,2,3,4,6,7,8,9（跳过了5）

3.2.4 循环的else子句

当循环正常结束（没有被break中断）时，会执行else中的代码。

for i in range(5):
    print(i)
    if i == 3:
        break
else:
    print("循环正常结束")   # 如果被break中断，这里不会执行

第四章：数据结构

4.1 字符串（str）

字符串是不可变数据类型，不能直接修改字符串中的某个字符。

4.1.1 索引与切片

s = "my name is xxx"

# 索引（下标从0开始）
print(s[0](@ref)   # 第一个字符 'm'

# 切片：s[起始:结束:步长]
print(s[1:5])     # 下标1到4（不包括5）→ "y na"
print(s[:5])      # 从开头到下标4 → "my na"
print(s[1:])      # 从下标1到结尾 → "y name is xxx"
print(s[:])       # 整个字符串 → "my name is xxx"
print(s[::2])     # 每隔一个取一个
print(s[::-1])    # 反转字符串
print(s[-5:-1])   # 从倒数第5个到倒数第2个（不包括倒数第1个）

4.1.2 常用方法

# 替换
s = s.replace("xxx", "pig")

# 分割（按空格分割成列表）
words = s.split(" ")   # ['my', 'name', 'is', 'pig']

# 拼接（将列表用指定字符串连接）
new_s = " ".join(words)   # "my name is pig"

# 大小写转换
"hello".capitalize()   # 首字母大写 → "Hello"
"hello".title()        # 每个单词首字母大写 → "Hello"
"hello".upper()        # 全部大写 → "HELLO"
"HELLO".lower()        # 全部小写 → "hello"

# 删除空白字符
"  hello  ".lstrip()    # 删除左侧空白 → "hello  "
"  hello  ".rstrip()    # 删除右侧空白 → "  hello"
"  hello  ".strip()     # 删除两侧空白 → "hello"

4.2 列表（list）

列表是可变数据类型，可以随意增删改。

4.2.1 创建列表

arr = [1, 2, 3, 4]
b = 12
mixed = [1, False, "happy", b, [1, 2, 3]]  # 列表可以包含任意类型，甚至可以嵌套

4.2.2 索引与切片

arr = [1, 2, 3, 4]
print(arr[0](@ref)   # 1
print(arr[-1])  # 4（最后一个元素）

# 切片用法与字符串相同
print(arr[1:3])  # [2, 3]

4.2.3 修改元素

arr[0] = 123   # 直接修改（字符串不可以这样操作）

4.2.4 添加元素

arr.append("abc")       # 在末尾添加
arr.insert(1, 't')      # 在下标1的位置插入

4.2.5 删除元素

arr.pop(0)              # 删除并返回下标0的元素
arr.remove("happy")     # 删除匹配到的第一个元素
arr.clear()             # 清空列表
del arr                 # 删除整个列表

4.2.6 排序

a = [4, 2, 1, 3]

# 方式一：直接修改原列表
a.sort()

# 方式二：返回新列表（不修改原列表）
a = sorted(a)

4.2.7 复制列表

a = [1, 2, 3]

# 错误方式（直接赋值，会共享同一份数据）
b = a
a[0] = 100
print(b[0](@ref)   # 100（b也会变）

# 正确方式（使用copy()复制一份新数据）
b = a.copy()
a[0] = 100
print(b[0](@ref)   # 1（b不受影响）

原理说明： 变量名指向内存中的地址，直接赋值相当于让两个变量指向同一块内存区域，修改一个会影响另一个。使用copy()则会创建新的内存区域。

4.2.8 成员判断

arr = [1, False, "happy", 12, [1, 2, 3]]

if 1 in arr:
    print("1在列表中")

if 1 not in arr:
    print("1不在列表中")

4.2.9 嵌套列表的遍历

# 三维列表的遍历
array = [
    [[1, 2, 3], [4, 5, 6], [7, 8, 9]],
    [[3, 2, 5], [4, 5, 8], [7, 8, 9]],
    [[1, 2, 3], [4, 5, 8], [7, 0, 9]]
]

for a in array:
    for b in a:
        for c in b:
            print(c)

4.3 元组（tuple）

元组使用小括号，与列表类似，但不可修改（不可变数据类型）。

c = (1, 2, "22")

元组可以像列表一样通过索引访问，但不能修改元素。

4.4 集合（set）

集合使用大括号，有两个重要特性：

无序性：元素没有顺序
不重复性：自动去重

s = {1, 3, 3, 4}
print(s)   # {1, 3, 4}（重复的3被自动去掉）

4.5 字典（dict）

字典也使用大括号，由键值对组成。

# 创建字典
d = {"name": "pig", "age": 20}

# 获取所有键
print(d.keys())      # ['name', 'age']

# 获取所有值
print(d.values())    # ['pig', 20]

# 获取所有键值对
print(d.items())     # [('name', 'pig'), ('age', 20)]

4.5.1 遍历字典

for k, v in d.items():
    print(k, v)   # name pig / age 20

4.5.2 访问和修改

# 访问
print(d["name"])     # "pig"

# 修改
d["name"] = "fork"

# 删除键值对
del d["name"]

# 清空字典
d.clear()

# 删除整个字典
del d

4.5.3 空字典 vs 空集合

d = {}      # 空字典（优先解释为字典）
s = set()   # 空集合（必须这样写）

第五章：函数

5.1 定义和调用函数

函数使用 def 关键字定义，可以将重复使用的代码封装起来。

# 定义函数
def day():
    print("起床了")
    print("吃早饭")
    print("上班")
    print("回家")
    print("睡觉")

# 调用函数
day()

5.2 参数和返回值

# 判断一个数是否是偶数
def is_even(n):
    if n % 2 == 0:
        return True
    else:
        return False

# 简化写法
def is_even(n):
    return n % 2 == 0

# 调用
result = is_even(15)   # result = False

形参 vs 实参：

n 是形参（定义函数时使用的参数名）
15 是实参（调用函数时传入的具体值）

5.3 作用域

全局变量：在函数外面定义的变量，作用域是整个程序。
局部变量：在函数内部定义的变量，只在函数内部有效。

day = 1   # 全局变量

def change_day():
    global day   # 声明使用全局变量
    day = 2      # 修改全局变量

change_day()
print(day)   # 2

5.4 函数注释

良好的函数注释可以帮助理解函数的功能。

def put_color(img, x_p, y_p, long, color):
    """
    填充一定范围内的颜色
    :param img: 图片名
    :param x_p: 填充正方形的x位置
    :param y_p: 填充正方形的y位置
    :param long: 正方形的边长
    :param color: 填充颜色
    :return: 无返回值
    """
    if long == 0:
        img.putpixel((x_p, y_p), color)
    for n in range(long):
        for m in range(long):
            img.putpixel((x_p + n, y_p + m), color)

5.5 主函数入口

def main():
    for i in range(10):
        a()

def a():
    print("a")
    # 调用b()和c()...

def b():
    pass

def c():
    pass

if __name__ == '__main__':
    main()

if __name__ == '__main__': 的作用：判断当前文件是否是被直接运行的，如果是，则执行main()；如果是被其他文件导入，则不执行。

5.6 递归函数

函数调用自身称为递归，需要注意设置终止条件，否则会造成无限循环。

# 递归示例：计算阶乘
def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n - 1)

5.7 多返回值与拆包

def g():
    return 1, 2, 3

# 接收返回值（返回的是元组）
result = g()          # (1, 2, 3)

# 拆包（分别接收）
a, b, c = g()        # a=1, b=2, c=3

拆包不仅适用于元组，也适用于列表、集合、字典。

5.8 参数类型

5.8.1 不定长参数

# 单星号 *args：接收任意数量的位置参数（打包成元组）
def func(*args):
    print(args)

func(1, 2, 3, 6, 9)   # (1, 2, 3, 6, 9)

# 双星号 **kwargs：接收任意数量的关键字参数（打包成字典）
def func2(**kwargs):
    print(kwargs)

func2(name="张三", age=18)   # {'name': '张三', 'age': 18}

5.8.2 默认参数

def func(age=18):
    print(age)

func()       # 18（使用默认值）
func(20)     # 20（使用传入的值）

5.8.3 参数顺序

四种参数必须按照以下顺序书写：

普通参数
默认参数
包裹位置参数（*args）
包裹关键字参数（**kwargs）

附录：常见问题与提示

Python版本：本文档基于Python 3.7.2编写，建议使用Python 3.x版本。
编辑器：推荐使用PyCharm进行开发，功能强大且免费。
缩进：Python严格要求缩进，建议使用4个空格或1个Tab，保持统一。
字符串不可变：字符串的字符不能直接修改，但可以通过切片、替换等方法生成新的字符串。
列表赋值：直接赋值会共享内存，使用copy()可以复制一份独立的数据。 #期末

章节一：python简介#

第一章：Python基础入门#

1.1 注释#

1.2 变量#

1.3 基本数据类型#

1.4 输出（print）#

1.5 输入（input）#

1.6 类型转换#

1.7 随机数#

第二章：运算符与表达式#

2.1 算术运算符#

2.2 赋值运算符#

2.3 比较运算符#

2.4 布尔运算符（逻辑运算符）#

2.5 运算符优先级#

2.6 字符串运算#

第三章：流程控制#

3.1 条件判断（if / elif / else）#

3.2 循环语句#

3.2.1 while循环#

3.2.2 for循环#

3.2.3 break和continue#

3.2.4 循环的else子句#

第四章：数据结构#

4.1 字符串（str）#

4.1.1 索引与切片#

4.1.2 常用方法#

4.2 列表（list）#

4.2.1 创建列表#

4.2.2 索引与切片#

4.2.3 修改元素#

4.2.4 添加元素#

4.2.5 删除元素#

4.2.6 排序#

4.2.7 复制列表#

4.2.8 成员判断#

4.2.9 嵌套列表的遍历#

4.3 元组（tuple）#

4.4 集合（set）#

4.5 字典（dict）#

4.5.1 遍历字典#

4.5.2 访问和修改#

4.5.3 空字典 vs 空集合#

第五章：函数#

5.1 定义和调用函数#

5.2 参数和返回值#

5.3 作用域#

5.4 函数注释#

5.5 主函数入口#

5.6 递归函数#

5.7 多返回值与拆包#

5.8 参数类型#

5.8.1 不定长参数#

5.8.2 默认参数#

5.8.3 参数顺序#

附录：常见问题与提示#