python基础以及面向对象

python基础

第一单元 Python解释器和IDE的安装和初步使用

一、昨日知识点回顾

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学Python全彩版》，第1章 初识Python，页码区间<1，22>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.Python的应用领域
2.Python安装
3.Pycharm安装
4.Pycharm中创建项目名称、包名、项目存放地址
5.使用Pycharm输出第一个Python“Hello World”程序

（Ⅱ）能力目标

1.能够对Python编程语言有初步了解
2.能够独立搭建Python开发环境
3.能够写出简单的输出字符串的程序

---

四、本单元知识详讲

1.1 计算机介绍

1.1.1 计算机发展史 ★★

第一台计算机

第一台计算机介绍

诞生原因：美国奥伯丁武器试验场为了满足计算弹道需要而研制成的

诞生时间：1946年2月14日

名字：ENIAC

组成元件：电子管

地点：宾夕法尼亚大学

计算机之父：约翰.冯·诺依曼

计算机之父介绍

简介：冯·诺依曼（1903－1957），美藉匈牙利人，物理学家，数学家，发明家，在发明电子计算机中所起到关键性作用，提出计算机内部以二进制数形式进行存储，基本工作原理是存储程序和程序控制，冯·诺依曼被称为“计算机之父”。

1.1.2 计算机组成 ★★★

用手机作类比，计算机由硬件和软件组成

计算机的硬件组成部分

概念：是组成计算机系统的各种物理设备的总称（看得见，摸得着的）

组成：

输入设备：鼠标、键盘、摄像头、麦克风

输出设备：显示器、音响、打印机

运算器：计算机中执行各种算术和逻辑运算操作的部件

控制器：是整个计算机系统的控制中心，它指挥计算机各部分协调的工作，保证计算机按照预先规定的目标和步骤有条不紊的进行操作及处理。运算器和控制器统称为中央处理器（CPU）

存储器：是计算机系统中的记忆设备，用来存放程序和数据。分为内存和外存

计算机的软件组成部分

概念:计算机软件(Computer Software，也称软件，软体)是指计算机系统中的程序及其文档

分类：

​ 系统软件：操作系统（OS）

​ 操作系统：Windows，Linux，Mac，DOS，Unix，Android，IOS

​ 应用软件：QQ、微信、office办公软件、游戏软件

1.2 Python概述

1.2.1 了解Python语言 ★★

Python的作者，Guido van Rossum（吉多·范·罗苏姆，中国Python程序员都叫他 龟叔），荷兰人。1982年，龟叔从阿姆斯特丹大学获得了数学和计算机硕士学位。然而，尽管他算得上是一位数学家，但他更加享受计算机带来的乐趣。用他的话说，虽然拥有数学和计算机双料资质，他总趋向于做计算机相关的工作，并热衷于做任何和编程相关的事情。

Python就是一门编程语言，而且是现在世界上最流行的编程语言之一。

1.2.2 Python的应用领域 ★★★

Web开发

Python经常被用于Web开发。比如，通过mod_wsgi模块，Apache可以运行用Python编写的Web程序。Python定义了WSGI标准应用接口来协调Http服务器与基于Python的Web程序之间的通信。一些Web框架，如Django，TurboGears，web2py，Zope等，可以让程序员轻松地开发和管理复杂的Web程序。

自动化运维开发

在很多操作系统里，Python是标准的系统组件。 大多数Linux发行版以及NetBSD、OpenBSD和Mac OS X都集成了Python，可以在终端下直接运行Python。有一些Linux发行版的安装器使用Python语言编写，比如Ubuntu的Ubiquity安装器,Red Hat Linux和Fedora的Anaconda安装器。Gentoo Linux使用Python来编写它的Portage包管理系统。Python标准库包含了多个调用操作系统功能的库。通过pywin32这个第三方软件 包，Python能够访问Windows的COM服务及其它Windows API。使用IronPython,Python程序能够直接调用.Net Framework。一般说来，Python编写的系统管理脚本在可读性、性能、代码重用度、扩展性几方面都优于普通的shell脚本。

网络爬虫

Python有大量的HTTP请求处理库和HTML解析库，并且有成熟高效的爬虫框架Scrapy和分布式解决方案scrapy-redis，在爬虫的应用方面非常广泛。

科学计算

NumPy、SciPy、Pandas、Matplotlib可以让Python程序员编写科学计算程序。

服务器软件(网络软件)

Python对于各种网络协议的支持很完善，因此经常被用于编写服务器软件、网络爬虫。第三方库Twisted支持异步网络编程和多数标准的网络协议(包含客户端和服务器)，并且提供了多种工具，被广泛用于编写高性能的服务器软件。

游戏开发

很多游戏使用C++编写图形显示等高性能模块，而使用Python或者Lua编写游戏的逻辑、服务器。相较于Python，Lua的功能更简单、体积更小；而Python则支持更多的特性和数据类型。

1.2.3 Python的版本 ★★

python自发布以来，主要有三个版本

1994年发布的 Python1.0版本(已过时)

2000年发布的 Python2.0版本

2008年发布的 Python3.0版本

1.3 Python解释器和IDE安装

1.3.1 Python安装 ★★★

1.勾选添加环境变量并安装

2.等待安装完场即可

3.点击close关闭即可

1.3.2 Pycharm安装 ★★★

1.将Pycharm安装包直接打开，点击Next进行下一步

2.勾选之后点击Next

3.点击Next进入下一步

4.直接点击Install进行安装即可

5.在该窗口勾选“Run Pycharm”，然后点击"Finish按钮"完成安装

1.4 第一个Python“Hello World”程序

1.4.1 Pycharm中创建项目名称、包名、项目存放地址 ★★★

1.打开 Pycharm，选择 Create New Project，创建一个新项目

2.选择Pure Python表示创建一个纯Python程序项目，Location 表示该项目保存的路径，Interpreter 表示使用的Python解释器版本，最后点击Create 创建项目。

3.右击项目，选择New，再选择Python File

4.在弹出的对话框中输入的文件名HelloPython，点击OK，表示创建一个Python程序的文本文件，文本文件后缀名默认.py

1.4.2 使用Pycharm输出第一个Python “Hello World”程序 ★★★

1.输入以下代码，并右击空白处，选择Run运行，表示打印一个字符串"Hello World!"。

2.运行成功后，Pycharm Console窗口将显示我们的输出结果。

---

五、本单元知识总结

1. Python安装
2. Pycharm使用方法
3. Pycharm输出简单的demo

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第一单元，选择题，填空题，简答题、技能题

（Ⅲ）预习作业

1.预习第二单元，Python中变量及简单数据类型知识点
2.预习教材，Python语言基础

预习附录：

1.参见教材：第二章<24，54>页

第二单元 Python中变量及简单数据类型

一、昨日知识点回顾

1. 什么是Python？
2. 如何搭建Python开发环境？
3. 如何安装Python？
4. 如何安装Pycharm？
5. 如何在Pycharm中创建项目？
6. 如何在Pycharm中输出第一个‘Hello World’程序？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学Python全彩版》，第2章 Python语言基础，页码区间<24,54>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.变量的定义、类型、输出
2.标识符的命名规则、命名方法、关键字
3.Python中的输入与格式化输出
4.Python中的运算符
5.Python中的常用的数据类型的转换

（Ⅱ）能力目标

1.掌握变量的定义和作用
2.掌握标识符的命名规则和命名方法
3.掌握Python输入函数和常用的格式化输出符号 
4.掌握Python中运算符
5.掌握Python中常用的强转方法

---

四、本单元知识详讲

2.1 变量

2.1.1 变量的定义 ★★★★

在程序中，有时我们需要对2个数据进行求和，那么该怎样做呢？

大家类比一下现实生活中，比如去超市买东西，往往咱们需要一个菜篮子，用来进行存储物品，等到所有的物品都购买完成后，在收银台进行结账即可

如果在程序中，需要把2个数据，或者多个数据进行求和的话，那么就需要把这些数据先存储起来，然后把它们累加起来即可

在Python中，存储一个数据，需要一个叫做变量的东西，如下示例:

num1 = 100  # num1就是一个变量，就好一个小菜篮子

num2 = 87  # num2也是一个变量

result = num1 + num2  # 把num1和num2这两个"菜篮子"中的数据进行累加，然后放到 result变量中

说明:

• 所谓变量，可以理解为菜篮子，如果需要存储多个数据，最简单的方式是有多个变量，当然了也可以使用一个

• 程序就是用来处理数据的，而变量就是用来存储数据的

  想一想：我们应该让变量占用多大的空间，保存什么样的数据？

2.1.2 变量的类型 ★★★★

生活中的类型的例子:

程序中：

怎样知道一个变量的类型呢？

• 在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要咱们开发者主动的去说明它的类型，系统会自动辨别
• 可以使用type(变量的名字)，来查看变量的类型

2.1.3 变量的输出 ★★★

前面我们学习了变量。我们定义一个变量后，该如何输出这个变量呢？我们这时就需要print()这个函数。

如果输出内容的话，把内容添加在括号里，并用双引号引起来，像print(“Hello World!”)，

如果我们输出一个变量的话，把变量名添加到括号里面就可以了。

这里我们定义一个变量name,并输出这个变量。

这个变量打印出来了，但现在我觉得，这样输出有点单调，我们可以这样，给它修改一下（图1.3），

在变量前加一些提示语，这样显得语句更通顺。

2.2 标识符

什么是标识符，看下图:

• 开发人员在程序中自定义的一些符号和名称
• 标识符是自己定义的,如变量名 、函数名等

2.2.1 标识符的命名规则 ★★★★★

• 标识符由字母、下划线和数字组成，且数字不能开头

  思考：下面的标识符哪些是正确的，哪些不正确为什么

  fromNo12
  
  from#12
  my_Boolean
  my-Boolean
  Obj2
  2ndObj
  myInt
  test1
  Mike2jack
  My_tExt
  _test
  test!32
  haha(da)tt
  int
  jack_rose
  jack&rose
  GUI
  G.U.I
  

• python中的标识符是区分大小写的

  

  命名规则

  见名知意

  起一个有意义的名字，尽量做到看一眼就知道是什么意思(提高代码可 读性) 比如: 名字 就定义为 name , 定义学生 用 student

2.2.2 标识符的命名方法 ★★★★★

• 小驼峰式命名法（lower camel case）： 第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog
• 大驼峰式命名法（upper camel case）： 每一个单字的首字母都采用大写字母，例如：FirstName、LastName
• 还有一种命名法是用下划线“_”来连接所有的单词，比如send_buf

Python的命令规则遵循PEP8标准，这个在后面会慢慢讲到。

2.2.3 Python中的关键字 ★★★★★

什么是关键字

python一些具有特殊功能的标识符，这就是所谓的关键字 关键字，是python已经使用的了，所以不允许开发者自己定义和关键字相同的名字的标识符

查看关键字

'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'

可以在Python Shell通过以下命令进行查看当前系统中python的关键字

>>> import keyword
>>> keyword.kwlist

关键字的学习以及使用，咱们会在后面的课程中一一进行学习。

2.3 Python中的输入与格式化输出

2.3.1 常用的格式化输出符号的介绍★★★

格式化操作的目的

比如有以下代码:

pirnt("我今年10岁")  
pirnt("我今年11岁")  
pirnt("我今年12岁")

• 想一想:

  在输出年龄的时候，用了多次"我今年xx岁"，能否简化一下程序呢？？？

• 答:

  字符串格式化

什么是格式化

看如下代码:

age = 10  
print("我今年%d岁" % age)  

age += 1  
print("我今年%d岁" % age)  

age += 1  
print("我今年%d岁" % age)  

在程序中，看到了%这样的操作符，这就是Python中格式化输出。

age = 18  
name = "xiaohua"  
print("我的姓名是%s, 年龄是%d" % (name, age))

常用的格式符号

下面是完整的，它可以与％符号使用列表:

格式符号	转换
%c	字符
%s	字符串
%d	有符号十进制整数
%u	无符号十进制整数
%o	八进制整数
%x	十六进制整数（小写字母0x）
%X	十六进制整数（大写字母0X）
%f	浮点数
%e	科学计数法（小写’e’）
%E	科学计数法（大写“E”）
%g	％f和％e 的简写
%G	％f和％E的简写

换行输出

在输出的时候，如果有\n那么，此时\n后的内容会在另外一行显示

print("1234567890-------") # 会在一行显示  
 
print("1234567890\n-------") # 一行显示1234567890，另外一行显示-------

练一练

编写代码完成以下名片的显示

==========我的名片==========  
 姓名: jiyun  
 QQ:xxxxxxx  
 手机号:185xxxxxx  
 公司地址:北京市xxxx

2.3.2 输入函数的介绍 ★★★★

咱们在银行ATM机器前取钱时，肯定需要输入密码，对不？

那么怎样才能让程序知道咱们刚刚输入的是什么呢？？

大家应该知道了，如果要完成ATM机取钱这件事情，需要先从键盘中输入一个数据，然后用一个变量来保存，是不是很好理解啊。

在Python中，获取键盘输入的数据的方法是采用 input 函数（至于什么是函数，咱们以后的章节中讲解），那么这个 input 怎么用呢?

>>> a = input() 
123
>>> a
123
>>> type(a)
<type 'int'>
>>> a = input()
abc
Traceback (most recent call last):
  File "", line 1, in <module>
  File "", line 1, in <module>
NameError: name 'abc' is not defined
>>> a = input()
"abc"
>>> a
'abc'
>>> type(a)
<type 'str'>
>>> a = input()
1+3
>>> a
4
>>> a = input()
"abc"+"def"
>>> a
'abcdef'
>>> value = 100
>>> a = input()
value
>>> a
100

input()接受表达式输入，并把表达式的结果赋值给等号左边的变量

2.4 Python中的运算符

2.4.1 算术运算符 ★★★★★

下面以a=10 ,b=20为例进行计算

运算符	描述	实例
+	加	两个对象相加 a + b 输出结果 30
-	减	得到负数或是一个数减去另一个数 a - b 输出结果 -10
*	乘	两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/	除	b / a 输出结果 2
//	取整除	返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
%	取余	返回除法的余数 b % a 输出结果 0
**	指数	a**b 为10的20次方， 输出结果 100000000000000000000

示例：

a = 21
b = 10
c = 0
 
c = a + b
print "1 - c 的值为：", c
 
c = a - b
print "2 - c 的值为：", c 
 
c = a * b
print "3 - c 的值为：", c 
 
c = a / b
print "4 - c 的值为：", c 
 
c = a % b
print "5 - c 的值为：", c
 
# 修改变量 a 、b 、c
a = 2
b = 3
c = a**b 
print "6 - c 的值为：", c
 
a = 10
b = 5
c = a//b 
print "7 - c 的值为：", c

运行结果：

1 - c 的值为： 31
2 - c 的值为： 11
3 - c 的值为： 210
4 - c 的值为： 2
5 - c 的值为： 1
6 - c 的值为： 8
7 - c 的值为： 2

注意：混合运算时，优先级顺序为： ** 高于 * / % // 高于 + - ，为了避免歧义，建议使用 () 来处理运算符优先级。

并且，不同类型的数字在进行混合运算时，整数将会转换成浮点数进行运算。

>>> 10 + 5.5 * 2
21.0
>>> 10 + (5.5 * 2)
21.0

2.4.2 赋值运算符 ★★★★★

运算符	描述	实例
=	赋值运算符	把 = 号右边的结果 赋给 左边的变量，如 num = 1 + 2 * 3，结果num的值为7

# 单个变量赋值
>>> num = 10
>>> num
10

# 多个变量赋值
>>> num1, num2, f1, str1 = 100, 200, 3.14, "hello"
>>> num1
100
>>> num2
200
>>> f1
3.14
>>> str1
"hello"

2.4.3 复合赋值运算符 ★★★★★

运算符	描述	实例
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

示例:

a = 21
b = 10
c = 0
 
c = a + b
print "1 - c 的值为：", c
 
c += a
print "2 - c 的值为：", c 
 
c *= a
print "3 - c 的值为：", c 
 
c /= a 
print "4 - c 的值为：", c 
 
c = 2
c %= a
print "5 - c 的值为：", c
 
c **= a
print "6 - c 的值为：", c
 
c //= a
print "7 - c 的值为：", c

运算结果：

1 - c 的值为： 31
2 - c 的值为： 52
3 - c 的值为： 1092
4 - c 的值为： 52
5 - c 的值为： 2
6 - c 的值为： 2097152
7 - c 的值为： 99864

2.5 Python中常见的数据类型转换

2.5.1 掌握常用的强转方法 ★★★★★

常用的数据类型转换

函数	说明
int(x [,base ])	将x转换为一个整数
float(x )	将x转换为一个浮点数
complex(real [,imag ])	创建一个复数，real为实部，imag为虚部
str(x )	将对象 x 转换为字符串
repr(x )	将对象 x 转换为表达式字符串
eval(str )	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )	将序列 s 转换为一个元组
list(s )	将序列 s 转换为一个列表
chr(x )	将一个整数转换为一个Unicode字符
ord(x )	将一个字符转换为它的ASCII整数值
hex(x )	将一个整数转换为一个十六进制字符串
oct(x )	将一个整数转换为一个八进制字符串
bin(x )	将一个整数转换为一个二进制字符串

举例

>>> # int(): 将数据转换为 int 类型

>>> str1 = "10"
>>> # int() 默认按10进制转换后显示
>>> num1 = int(str1)
>>> 
>>> # int() 处理浮点数，只留下整数部分，舍弃小数部分（并不是四舍五入操作）
>>> num2 = int(3.74)
>>> print(num2)
3
>>> 
>>> """
... num1 = int(str1, 8) # 第二个参数为8，表示按8进制转换后显示，结果为 8
... num1 = int(str1, 16) # # 第二个参数为16，表示按16进制转换后显示，结果为 16
... # 01 02 03 04 05 06 07 10
... # 01 02 ... 0B 0C 0D 0E 0F 10
... print(num1)
... """
>>> 
>>> # float() 将数据转化为浮点数
>>> str2 = "3.14"
>>> f1 = float(str2)
>>> print(type(f1))
<class 'float'>
>>> 
>>> f2 = float(10)
>>> print(f2)
10.0
>>> 
>>> # complex() 创建复数: 第一个参数是复数的实部，第二个参数是复数的虚部
>>> c1 = 10 + 4j
>>> c2 = complex(10, 4)
>>> 
>>> print(c1)
(10+4j)
>>> print(c2) # 等同与c1
(10+4j)
>>> 
>>> # str() : 转换为 字符串类型
>>> num1 = 10
>>> f1 = 3.14
>>> 
>>> print(type(str(num1)))
<class 'str'>
>>> print(type(str(f1)))
<class 'str'>
>>> 
>>> # repr()： 转换为表达式字符串
>>> num1 = 10
>>> print(type(repr(num1)))
<class 'str'>
>>> 
>>> 
>>> # eval(): 将字符串形式的数据，转换为原本的类型
>>> str1 = "3.14"
>>> print(type(eval(str1)))
<class 'float'>
>>> 
>>> str2 = "[10, 20, 30]"
>>> l = eval(str2)
>>> print(type(l))
<class 'list'>
>>> 
>>> 
>>> # chr: 将一个整数转换为对应的 Unicode 字符
>>> s = chr(1065)
>>> print(s)
Щ
>>> 
>>> # ord ：将一个字符转换为对应的字符编码数字
>>> n = ord("A")
>>> print(n)
65
>>> 
>>> # bin: 将一个整数转换为二进制
>>> print(bin(1024)) # 0b 开头表示二进制数
0b10000000000
>>> 
>>> # oct：将一个整数转换为八进制
>>> print(oct(1024)) # 0o 开头表示八进制数
0o2000
>>> 
>>> # hex: 将一个整数转换为十六进制
>>> print(hex(1024)) # 0x 开头表示十六进制
0x400
>>>

附录：常用字符与ASCII码对照表

---

五、本单元知识总结

1.变量的定义、类型、输出
2.标识符的命名规则、命名方法、关键字
3.Python中的输入与格式化输出
4.Python中的运算符
5.Python中的常用的数据类型的转换

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第二单元，选择题，填空题，简答题(1,2,4)、技能题（1、2、3）
2.完成教材第二章节，课后习题(实战一,实战二,实战三,实战四)

（Ⅲ）预习作业

1.预习第三单元，判断语句
2.预习教材，第三章 流程控制语句

预习附录：

1.参见教材：第五章<55,66>页

第三单元 判断语句

一、昨日知识点回顾

1. Python中运算符有哪些？
2. Python中常用的强转方法有哪些？
3. 变量的定义和作用？
4. Python输入函数和常用的格式化输出符号有哪些？
5. 掌握标识符的命名规则和命名方法？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学Python(全彩版)》，第3章 流程控制语句，页码区间<56,66>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.if判断语句
2.多项选择判断
3.if嵌套

（Ⅱ）能力目标

1.掌握if判断的格式
2.掌握if-else的格式
3.掌握if-elif-else的应用格式
4.掌握if嵌套的应用

---

四、本单元知识详讲

3.1 常见运算符

3.1.1 比较运算符 ★★★★★

python中的比较运算符如下表

运算符	描述	示例
==	检查两个操作数的值是否相等，如果是则条件变为真。	如a=3,b=3，则（a == b) 为 True
!=	检查两个操作数的值是否相等，如果值不相等，则条件变为真。	如a=1,b=3，则(a != b) 为 True
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立。	如a=7,b=3，则(a > b) 为 True
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立。	如a=7,b=3，则(a < b) 为 False
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3，则(a >= b) 为 True
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。	如a=3,b=3，则(a <= b) 为 True

>>> ## 关系运算符
... 
>>> # == 等于：表示左右两个操作数是否相等，如果相等则整个表达式的值为 True；不相等则为False
... num1 = 15
>>> num2 = 20
>>> 
>>> print(num1 == num2)
False
>>> 
>>> # != 不等于
... print(num1 != num2)
True
>>> 
>>> # > 大于
... print(num1 > num2)
False
>>> 
>>> # < 小于
... print(num1 < num2)
True
>>> 
>>> # >= 大于等于: num1 大于 或者 等于 num2 ，条件都成立
... print(num1 >= num2)
False
>>> 
>>> # <= 小于等于： num1 小于 或者 等于 num2 ，条件都成立
... print(num1 <= num2)
True
>>> 
>>> if num1 >= num2:
...     print("条件成立！")
... 
>>>

3.1.2 逻辑运算符 ★★★★★

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与"：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。	True and False， 返回 False。
or	x or y	布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值。	False or True， 返回 True。
not	not x	布尔"非"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not True 返回 False, not False 返回 True

>>> ## 逻辑运算符
... 
>>> # and : 左右表达式都为True，整个表达式结果才为 True
... if (1 == 1) and (10 > 3):
...     print("条件成立！")
... 
条件成立！

>>> # or : 左右表达式有一个为True，整个表达式结果就为 True
... if (1 == 2) or (10 > 3):
...     print("条件成立！")
... 
条件成立！

>>> # not：将右边表达式的逻辑结果取反，Ture变为False，False变为True
... if not (1 == 2):
...     print("条件成立！")
... 
条件成立！>>>

3.2 判断语句的介绍

3.2.1 生活中的判断场景 ★★★

​ 火车站安检

上网吧

密码判断

3.2.2 开发中的判断场景 ★★★★★

小总结：

• 如果某些条件满足，才能做某件事情；条件不满足时，则不能做，这就是所谓的判断。
• 不仅生活中有，在软件开发中"判断"功能也经常会用到

3.2.3 if判断语句的格式介绍 ★★★★★

• if语句是用来进行判断的，其使用格式如下：

if 要判断的条件:        
    条件成立时，要做的事情

• demo1:（demo的中文意思：演示、案例）

age = 30

print("------if判断开始------")

if age >= 18:        
    print("我已经成年了")    

    print("------if判断结束------")

• 运行结果:

------if判断开始------
我已经成年了
------if判断结束------

• demo2:

age = 16

print("------if判断开始------")

if age >= 18:        
    print("我已经成年了")  

    print("------if判断结束------")

• 运行结果:

------if判断开始------    
------if判断结束------

小总结：

• 以上2个demo仅仅是age变量的值不一样，导致结果却不同；能够看得出if判断语句的作用：就是当满足一定条件时才会执行代码块语句，否则就不执行代码块语句。
• 注意：代码的缩进为一个tab键，或者4个空格

3.3 if-else介绍

3.3.1 if-else使用场景介绍 ★★★★★

想一想：

在使用if的时候，它只能做到满足条件时要做的事情。那万一需要在不满足条件的时候，做某些事，该怎么办呢？

答：

使用 if-else

3.3.2 if-else案例演示 ★★★★★

if-else的使用格式如下:

if 条件:        
    满足条件时要做的事情1
    满足条件时要做的事情2
    满足条件时要做的事情3
    ...(省略)...    
else:        
    不满足条件时要做的事情1
    不满足条件时要做的事情2
    不满足条件时要做的事情3
    ...(省略)...

demo1

chePiao = 1 # 用1代表有车票，0代表没有车票

if chePiao == 1:        
	print("有车票，可以上火车")        
	print("终于可以见到Ta了，美滋滋~~~")    
else:        
	print("没有车票，不能上车")        
	print("亲爱的，那就下次见了"）

结果1：有车票的情况

有车票，可以上火车    
终于可以见到Ta了，美滋滋~~~

结果2：没有车票的情况

没有车票，不能上车    
亲爱的，那就下次见了

3.4 elif使用介绍

3.4.1 elif 使用场景介绍 ★★★★★

想一想:

if能完成当xxx时做事情

if-else能完成当xxx时做事情1，否则做事情2

如果有这样一种情况：当xxx1满足时做事情1；当xxx1不满足、xxx2满足时做事情2；当xxx2不满足、xxx3满足时做事情3，那该怎么实现呢？

答:

使用elif

3.4.2 elif 案例演示 ★★★★★

elif的使用格式如下:

if xxx1:        
	事情1
elif xxx2:        
	事情2
elif xxx3:        
	事情3

说明:

• 当xxx1满足时，执行事情1，然后整个if结束
• 当xxx1不满足时，那么判断xxx2，如果xxx2满足，则执行事情2，然后整个if结束
• 当xxx1不满足时，xxx2也不满足，如果xxx3满足，则执行事情3，然后整个if结束

demo:

score = 77

if score>=90 and score<=100:        
	print('本次考试，等级为A')    
elif score>=80 and score<90:        
	print('本次考试，等级为B')    
elif score>=70 and score<80:        
	print('本次考试，等级为C')    
elif score>=60 and score<70:        
	print('本次考试，等级为D')    
elif score>=0 and score<60:        
	print('本次考试，等级为E')

3.4.3 elif使用注意点 ★★★★★

• 可以和else一起使用

if 性别为男性:       
	输出男性的体重       
	...   
elif 性别为女性:       
	输出女性的体重       
	...   
else:       
	第三种性别的体重       
	...

说明:

• 当 “性别为男性” 满足时，执行 “输出男性的体重”的相关代码
• 当 “性别为男性” 不满足时，如果 “性别为女性”满足，则执行 “输出女性的体重”的相关代码
• 当 “性别为男性” 不满足，“性别为女性”也不满足，那么久默认执行else后面的代码，即 “第三种性别的体重”相关代码

elif必须和if一起使用，否则出错

else 一般用在最后，即所有条件都不满足时使用

3.5 if嵌套

3.5.1 if嵌套使用场景介绍 ★★★★★

通过学习if的基本用法，已经知道了

• 当需要满足条件去做事情的这种情况需要使用if
• 当满足条件时做事情A，不满足条件做事情B的这种情况使用if-else

想一想：

坐火车或者地铁的实际情况是：
先进行安检如果安检通过才会判断是否有车票，或者是先检查是否有车票之后才会进行安检;即实际的情况某个判断是再另外一个判断成立的基础上进行的，这样的情况该怎样解决呢？

答：

使用if嵌套

3.5.2 if嵌套格式介绍 ★★★★★

if 条件1:        
	满足条件1 做的事情1
	满足条件1 做的事情2

if 条件2:            
	满足条件2 做的事情1
	满足条件2 做的事情2

说明

• 外层的if判断，也可以是if-else
• 内层的if判断，也可以是if-else
• 根据实际开发的情况，进行选择

3.5.3 if嵌套案例应用 ★★★★★

demo：

chePiao = 1     # 用1代表有车票，0代表没有车票
daoLenght = 9     # 刀子的长度，单位为cm

if chePiao == 1:    
    print("有车票，可以进站")    
    if daoLenght < 10:        
        print("通过安检")        
        print("终于可以见到Ta了，美滋滋~~~")    
    else:        
        print("没有通过安检")        
        print("刀子的长度超过规定，等待警察处理...")
else:    
    print("没有车票，不能进站")    
    print("亲爱的，那就下次见了")

结果1：chePiao = 1;daoLenght = 9

有车票，可以进站    
通过安检    
终于可以见到Ta了，美滋滋~~~

结果2：chePiao = 1;daoLenght = 20

有车票，可以进站    
没有通过安检    
刀子的长度超过规定，等待警察处理...

结果3：chePiao = 0;daoLenght = 9

没有车票，不能进站    
亲爱的，那就下次见了

结果4：chePiao = 0;daoLenght = 20

没有车票，不能进站    
亲爱的，那就下次见了

想一想:为什么结果3和结果4相同？？？

五、本单元知识总结

1.if判断语句
2.多项选择判断
3.if嵌套

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第三单元，选择题，填空题，简答题(1,2,3,4)、技能题（1,2,3,4）
2.完成教材第3章节，课后习题(1,2)

（Ⅲ）预习作业

1.预习第四单元，循环知识点
2.预习教材，循环知识点

预习附录：

1.参见教材：第三章<66,76>页

第四单元 循环语句和跳转语句

一、昨日知识点回顾

1. 判断语句格式是什么？
2. if-else使用在哪些场景？
3. elif使用注意哪些事项？
4. if嵌套格式是什么？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学Python全彩版》，第3章 流程控制语句，页码区间<66，78>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.while循环格式及while循环嵌套
2.for循环格式及for循环嵌套

（Ⅱ）能力目标

1.掌握while循环及无限循环的使用格式
2.掌握while循环嵌套的格式
3.掌握for循环的格式
4.掌握for循环嵌套的格式
5.掌握break和continue的用法

---

四、本单元知识详讲

4.1 循环介绍

4.1.1 生活中的循环场景 ★★

跑道

风扇

CF加特林

4.1.2 软件开发中的循环场景 ★★★

跟媳妇承认错误，说一万遍"媳妇儿，我错了"

print("媳妇儿，我错了")    
print("媳妇儿，我错了")    
print("媳妇儿，我错了")    
...(还有99997遍)...

使用循环语句一句话搞定

i = 0
while i < 10000:        
	print("媳妇儿，我错了")        
	i += 1

总结

while和if的用法基本类似，区别在于：if 条件成立，则执行一次； while 条件成立，则重复执行，直到条件不成立为止。

一般情况下，需要多次重复执行的代码，都可以用循环的方式来完成

循环不是必须要使用的，但是为了提高代码的重复使用率，所以有经验的开发者都会采用循环

4.2 while循环的介绍及案例

4.2.1 while循环格式介绍 ★★★★★

while循环格式

while 条件:        
    条件满足时，做的事情1
    条件满足时，做的事情2
    条件满足时，做的事情3
    ...(省略)...

demo

i = 0
while i < 5:        
	print("当前是第%d次执行循环" % (i + 1))        
	i+=1

效果如下

当前是第1次执行循环    
i=0    
当前是第2次执行循环    
i=1    
当前是第3次执行循环    
i=2    
当前是第4次执行循环    
i=3    
当前是第5次执行循环    
i=4

4.2.2 while循环应用案例之计算1–100之间的整数和 ★★★★

i = 1
sum = 0
while i <= 100:    
    sum = sum + i    
    i += 1
print("1~100的累积和为:%d" % sum)

效果如下

1~100的累积和为:5050

4.2.3 while循环应用案例之计算1–100之间的偶数和 ★★ ★★

i = 1
sum = 0
while i <= 100:    
    if i % 2 == 0:        
    sum = sum + i    
    i+=1
print("1~100的累积和为:%d" % sum)

效果如下

1~100的累积和为:2550

4.2.4 while循环之无限循环（死循环）及小明拨电话案例讲解 ★★★★

循环循环是指重复执行一段代码若干次，为什么要有循环？ 因为循环可以避免大量的代码重复。 死循环当一个循环可以执行无限次，也就是没有终止条件，我们称这个循环是死循环。用python实现一个死循环非常简单

案例

# 小明为他的手机设定了自动拨号 ? 
# 按 1:拨爸爸的号 按 2:拨妈妈的号 按 3:拨爷爷的号 按 4:拨奶奶的号
while True:
    phone = input(请输入:)
    if phone=="1":
        print("拨爸爸的号")
    elif phone=="2":
        print("拨妈妈的号")
    elif phone=="3":
        print("拨爷爷的号")
    elif phone=="4":
        print("拨奶奶的号")
    else:
        print("您拨的号不存在")

4.3 while循环嵌套介绍及案例

4.3.1 while循环应用案例之打印正三角 ★★★★★

i = 1
while i <= 5:    
    j = 1
    while j <= i:        
        print("* ", end = '')        
        j += 1
    print("\n")    
    i += 1

效果如下

*    
* *    
* * *    
* * * *    
* * * * *

4.3.2 while循环应用案例之打印倒三角 ★★★★★

i = 1
while i <= 5:    
    j = 5
    while j >= i:        
        print("* ", end = '')        
        j -= 1
    print("\n")    
    i += 1

效果如下

* * * * *    
* * * *   
* * *     
* *     
* 

4.3.3 while循环应用案例之打印九九乘法表 ★★★★★

i = 1
while i<=9:    
    j=1
    while j<=i:        
        print("%d*%d=%-2d " % (j, i, i*j), end = '')        
        j+=1
    print()    
	i+=1

效果如下

1*1=1  
1*2=2  2*2=4  
1*3=3  2*3=6  3*3=9  
1*4=4  2*4=8  3*4=12 4*4=16 
1*5=5  2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6  2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7  2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8  2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

4.4 for循环介绍及案例

4.4.1 for循环的格式 ★★★★★

像while循环一样，for可以完成循环的功能。

在Python中 for循环可以遍历任何序列的项目，如一个列表或者一个字符串等。

for 临时变量 in 列表或者字符串等可迭代对象:    
    循环满足条件时执行的代码

4.4.2 for循环应用案例之遍历字符串 ★★★★

name = 'beijing'
for x in name:    
    print(x)

效果如下

b
e
i
j
i
n
g

4.4.3 for循环应用案例之遍历列表 ★★★★★

name=["安其拉","李白","鲁班","后裔"]
for x in name:
	print(x)

效果如下

安其拉
李白
鲁班
后裔

4.4.4 for循环应用案例之range()函数 ★★★★★

# range(5) 在python高级班中进行讲解,会牵扯到迭代器的知识，
# 作为刚开始学习python的我们，此阶段仅仅知道range(5)表示可以循环5次即可
for i in range(5):    
    print(i)
'''
效果等同于 while 循环的：
i = 0
while i < 5:    
    print(i)    
    i += 1
'''

效果如下

0
1
2
3
4

4.5 for循环嵌套及案例

4.5.1 for循环嵌套格式介绍 ★★★★★

for 临时变量 in 列表或者字符串等可迭代对象:    
    for 临时变量 in 列表或者字符串等可迭代对象:

4.5.2 for循环嵌套应用案例之九九乘法表 ★★★★

for i in range(1,10):
    for j in range(1,i+1):
        print("%d*%d=%-2d " % (j, i, i * j), end='')
    print()

效果如下

1*1=1  
1*2=2  2*2=4  
1*3=3  2*3=6  3*3=9  
1*4=4  2*4=8  3*4=12 4*4=16 
1*5=5  2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6  2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7  2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8  2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 

4.6 跳转语句break和continue

4.6.1 break介绍 ★★★★★

break:跳出循环，不在执行

Python break语句，就像在C语言中，打破了最小封闭for或while循环。

break语句用来终止循环语句，即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。

break语句用在while和for循环中。

如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码

4.6.2 for循环break应用案例 ★★★★★

name = 'beijing'
for x in name:      
        if x == 'e':         
           break
    print(x)
else:    
    print("==for循环过程中，如果没有执行break退出，则执行本语句==")

效果如下

b

总结

break的作用：立刻结束break所在的循环

4.6.3 while循环break应用案例 ★★★★★

i = 0
while i<5:    
    i +=1   
    if i==3:        
        break
    print(i)
else:    
    print("==while循环过程中，如果没有执行break退出，则执行本语句==")

效果如下

1
2

4.6.4 continue介绍 ★★★★★

continue:跳出本次循环，执行下一次

Python continue 语句跳出本次循环，而break跳出整个循环。

continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。

continue语句用在while和for循环中。

4.6.5 for循环continue应用案例 ★★★★★

name = 'beijing'
for x in name:  
    print('----') 
    if x == 'e':         
        continue
    print(x)

效果如下

----
b
----
----
i
----
j
----
i
----
n
----
g
----

4.6.6 while循环continue应用案例 ★★★★★

i = 0
while i<5:    
    i = i+1
    print('----')    
    if i==3:        
        continue
    print(i)

效果如下

----
1
----
2
----
----
4
----
5

总结

continue的作用：用来结束本次循环，紧接着执行下一次的循环

4.6.7 break和continue的区别 ★★★★★

break的作用：满足条件时，立刻结束break所在的循环

continue的作用：当满足条件时,用来结束本次循环，紧接着执行下一次的循环

注意点：

1. break/continue只能用在循环中，除此以外不能单独使用
2. break/continue在嵌套循环中，只对最近的一层循环起作用

---

五、本单元知识总结

1. for循环格式及嵌套
2. while循环格式及嵌套
3. break和continue用法及区别

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第四单元，选择题，填空题，简答题(1,2,4,5)、技能题（1、2、3）

（Ⅲ）预习作业

1.预习第五单元，常见数据类型之字符串常见操作
2.预习教材，序列的应用

预习附录：

1.参见教材：第四章<80,83>页

第五单元 常见数据类型之字符串常见操作

一、昨日知识点回顾

1. while循环及无限循环的使用格式是什么？
2. while循环嵌套的格式是什么？
3. for循环的格式是什么？
4. for循环嵌套的格式是什么？
5. break和continue如何使用?

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学Python全彩版》，第2章 Python语言基础，页码区间<128,141>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.字符串的格式
2.字符串的输入与输出
3.通过下标索引获取字符
4.字符串的切片
5.常用的字符串操作方法

（Ⅱ）能力目标

1.掌握字符串的格式
2.掌握字符串的输入与输出
3.掌握通过下标索引获取字符
4.掌握字符串的切片
5.掌握常用的字符串操作方法

---

四、本单元知识详讲

5.1 字符串的介绍

5.1.1 字符串的格式介绍 ★★★★★

如下定义的变量a，存储的是数字类型的值

 num = 100

如下定义的变量b，存储的是字符串类型的值

 str_1 = "hello usian.cn"
 或者
 str_2 = 'hello usian.cn'

小总结：

• 双引号或者单引号中的数据，就是字符串

5.2 字符串的输入与输出

5.2.1 字符串的输入 ★★★★

之前在学习input的时候，通过它能够完成从键盘获取数据，然后保存到指定的变量中；

注意：input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存

demo:

    userName = input('请输入用户名:')
    print("用户名为：%s" % userName)

    password = input('请输入密码:')
    print("密码为：%s" % password)

结果：（根据输入的不同结果也不同）

    请输入用户名: usian

    用户名为： usian
    请输入密码:haohaoxuexitiantianxiangshang
    密码为： haohaoxuexitiantianxiangshang

5.2.2 字符串的输出 ★★★★

格式化输出

    name = '犇哥'
    position = '讲师'
    address = '北京市'

    print('--------------------------------------------------')
    print("姓名：%s" % name)
    print("职位：%s" % position)
    print("公司地址：%s" % address)
    print('--------------------------------------------------')

结果：

    --------------------------------------------------
    姓名： 犇哥
    职位： 讲师
    公司地址： 北京市
    --------------------------------------------------

5.3 下标索引

5.3.1 下标索引介绍★★★★★

所谓下标，就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间

• 生活中的 下标

  超市储物柜

  

  高铁二等座

  

  高铁一等座

  

列表与元组支持下标索引好理解，字符串实际上就是字符的数组，所以也支持下标索引。

5.3.2 根据下标获取字符串中的字符案例讲解 ★★★★★

如果有字符串:name = 'abcdef'，在内存中的实际存储如下:

如果想取出部分字符，那么可以通过下标的方法，（注意python中下标从 0 开始）

   name = 'abcdef'

   print(name[0])
   print(name[1])
   print(name[2])

运行结果：

a
b
c

5.4 字符串的切片介绍

5.4.1 切片语法介绍

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

切片的语法：[起始:结束:步长]

注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔。

5.4.2 字符串切片格式介绍及案例讲解 ★★★★★

我们以字符串为例讲解。

如果取出一部分，则可以在中括号[]中，使用:

 name = 'abcdef'

 print(name[0:3])  # 取下标0~2 的字符

运行结果：

abc

案例一:
name = 'abcdef'

print(name[0:5])  # 取下标为0~4 的字符

运行结果：

abcde

# 案例二:
name = 'abcdef'


print(name[2:])  # 取下标为2开始到最后的字符

运行结果：

cdef

# 案例三:
name = 'abcdef'
print(name[::-1])  # 从后向前，按步长为1进行取值

运行结果：

fedcba

 # 案例四:
 name = 'abcdef'
 print(name[1:-1])  # 取 下标为1开始 到 最后第2个之间的字符

运行结果：

bcde

5.5 字符串中常见操作方法

5.5.1 index() 方法及案例讲解 ★★★★★

描述：查找字符串中第一次出现的子字符串的位置，可以规定字符串的索引查找范围[star,end)。若无则会报错。

语法：

str.index(sub, start, end) -> int 返回整数
参数：
    sub —— 查找的子字符串。
    start —— 索引的起始位置，默认为0。
    end —— 索引的结束位置，默认为字符串的长度。

示例：

"I love python".index("o")  # 默认索引整个字符串


"I love python".index("o",4)  # 索引 ve python
11


"I love python".index("o",4,12)  # 索引 ve pytho
11


"I love python".index("love")  # 索引多个字符
2
"I love python".index("k")   # 索引字符串不存在，报错
ValueError: substring not fou

5.5.2 count() 方法及案例讲解 ★★★★★

描述：统计字符串里某个字符出现的次数。可以选择字符串索引的起始位置和结束位置。

语法：

my_str.count(str, start=0, end=len(mystr))
参数：
    str —— 为要统计的字符(可以是单字符，也可以是多字符)。
    star —— 为索引字符串的起始位置，默认参数为0。
    end —— 为索引字符串的结束位置，默认参数为字符串长度即      			len(str)。

示例：

'abc--qo-ab'.count('ab')
2
# 从第二位开始查找
'abc--qo-ab'.count('ab',1)
1
# 不包括边界
'abc--qo-ab'.count('ab',1,9)

5.5.3 replace()方法及案例讲解 ★★★★★

描述：把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.

语法：

my_str.replace(str1, str2,  mystr.count(str1))

示例：

s = "我的小伙伴张三"
s.replace("张三","马云")
'我的小伙伴马云'


s = "I love python"
# 默认字符串中的全部"o" 全部替换为"w"
s.replace("o","w") 
'I lwve pythwn'


# 只替换一个"o" 
s.replace("o","w",1)
'I lwve python'


# 子字符串可以是多个字符。
s.replace("python","java")
'I love jav

5.5.4 split()方法与其他常见方法及案例讲解 ★★★★★

1.split()：拆分字符串。通过指定分隔符sep对字符串进行分割，并返回分割后的字符串列表。

语法：

 str.split(sep=None, maxsplit=-1) [n] 
 参数：
	sep —— 分隔符，默认为空格,但不能为空即('')。
	maxsplit —— 最大分割参数，默认参数为-1。
	[n] —— 返回列表中下标为n的元素。列表索引的用法。

示例：

# 默认空格分割
str1 = "I love python"
str1.split()
['I', 'love', 'python']


# 取第三位
str1.split()[2]
'python'


# 以"."为分隔符,maxsplit默认为-1
str2 = '列夫·尼古拉耶维奇·托尔斯泰'
str2.split('·')
['列夫', '尼古拉耶维奇', '托尔斯泰']


# 以"."为分隔符,只分割一次。
str2.split('·',1)
 ['列夫', '尼古拉耶维奇·托尔斯泰']

2.capitalize(): 将字符串的第一个字母变成大写，其余字母变为小写。

语法：str.capitalize()

示例：

"i Love python".capitalize()
'I love python'

"i Love pYthoN".capitalize()
'I love python'

3.title(): 返回一个满足标题格式的字符串。即所有英文单词首字母大写，其余英文字母小写。

语法：str.title()

示例：

"i am very love python".title()
'I Am Very Love Python'

4.lower(): 将字符串中的所有大写字母转换为小写字母。

语法：str.lower()

示例：

"我爱pythoN Python!".lower()
'我爱python python!'

5.upper(): 将字符串中的所有小写字母转换为大写字母。

语法： str.upper()

示例：

"i am very love python".upper()
'I AM VERY LOVE PYTHON'

6.center(): 返回一个长度为width,两边用fillchar(单字符)填充的字符串，即字符串str居中，两边用fillchar填充。若字符串的长度大于width,则直接返回字符串str。

语法：str.center(width , “fillchar”)

• width —— 指定字符串长度。
• fillchar —— 要填充的单字符，默认为空格。

示例：

'shuai'.center(10)

'  shuai   '


'shuai'.center(10,'*')
'**shuai***'

7.ljust(): 返回一个原字符串左对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

语法： str.ljust(width, fillchar) -> str 返回一个新的字符串

• width —— 指定字符串的输出长度。
• fillchar—— 将要填充的单字符，默认为空格。

示例：

'shuai'.ljust(10)
'shuai     '


'shuai'.ljust(10,'*')
'shuai*****'

8.rjust(): 返回一个原字符串右对齐,并使用fillchar填充(默认为空格)至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

语法： str.ljust(width, fillchar)

• width —— 指定字符串的输出长度。
• fillchar—— 将要填充的单字符，默认为空格。

示例：

'shuai'.rjust(10)
'     shuai'


'shuai'.rjust(10,'*')
'*****shuai

9.find(): 找字符串中指定的子字符串sub第一次出现的位置，可以规定字符串的索引查找范围。若无则返回 -1。

语法：str.find(sub,start,end) -> int 返回整数

参数：

• sub —要索引的子字符串。
• start —索引的起始位置。默认值为0。
• end —索引的结束位置。默认值为字符串长度len(str)。[start,end) 不包括end。

示例：

# 查找子字符串"o"
"I love python".find('o')
3


# 索引起始位置为4 索引范围为：ve python
"I love python".find('o',4)
11


# 索引起始位置为4,结束位置为12 索引范围为：ve pytho
"I love python".find('o',4,12)
11


"I love python".find('o',4,11)  # 不包括11位的'o',返回-1

10.rfind(): 查找字符串中指定的子字符串sub最后一次出现的位置，可以规定字符串的索引查找范围。若无则返回 -1。

语法：str.rfind(sub,start,end) -> int 返回整数

参数：

• sub —要索引的子字符串。
• start —索引的起始位置。默认值为0。
• end —索引的结束位置。默认值为字符串长度len(str)。[start,end) 不包括end。

注：rfind()函数用法与find()函数相似，rfind()函数返回指定子字符串最后一次出现的位置，find()函数返回指定子字符串第一次出现的位置。

示例：

# 查找子字符串"o"
"I love python".find('o')
3


# 索引起始位置为4 索引范围为：ve python
"I love python".find('o',4)
11


# 索引起始位置为4,结束位置为12 索引范围为：ve pytho
"I love python".find('o',4,12)

11. endswith(): 判断字符串是否以指定字符或子字符串结尾。

语法：str.endswith(“suffix”, start, end) 或str[start,end].endswith(“suffix”) 用于判断字符串中某段字符串是否以指定字符或子字符串结尾。—> bool 返回值为布尔类型（True,False）

参数：

• suffix — 后缀，可以是单个字符，也可以是字符串，还可以是元组（"suffix"中的引号要省略，常用于判断文件类型）。
• start —索引字符串的起始位置。
• end — 索引字符串的结束位置。

注意：空字符的情况。返回值通常为True

示例：

"I love python".endswith('n')
True

"I love python".endswith("python")
True

"I love python".endswith("n",0,6)  # 索引 i love 是否以“n”结尾。
False

"I love python".endswith("")  # 空字符
True

"I love python".endswith(("n","z"))  # 遍历元组的元素，存在即返回True，否者返回False
True

"I love python".endswith(("k","m"))
False

12.startswith(): 判断字符串是否以指定字符或子字符串开头。

语法：str.endswith(“suffix”, start, end) 或

str[start,end].endswith(“suffix”) 用于判断字符串中某段字符串是否以指定字符或子字符串结尾。

—> bool 返回值为布尔类型（True,False）

参数：

• suffix — 后缀，可以是单个字符，也可以是字符串，还可以是元组（"suffix"中的引号要省略）。
• start —索引字符串的起始位置。
• end — 索引字符串的结束位置。

注意：空字符的情况。返回值通常也为True

示例：

"hello,i love python".startswith("h")
True
"hello,i love python".startswith("l",2,10)  # 索引 llo,i lo 是否以“l”开头。
True
"hello,i love python".startswith("")  # 空字符
True
"hello,i love python"[0:6].startswith("h")  # 只索引  hello,
True
"hello,i love python"[0:6].startswith("e")
False
"hello,i love python"[0:6].startswith("")
True
"hello,i love python".startswith(("h","z"))  # 遍历元组的元素，存在即返回True，否者返回False
True
"hello,i love python".startswith(("k","m"))
False

13.isalnum(): 检测字符串是否由字母和数字组成。str中至少有一个字符且所有字符都是字母或数字则返回 True,否则返回 False

语法：str.isalnum() -> bool 返回值为布尔类型（True,False）

参数：

示例：

"seven-11".isalnum()
False


"seven11".isalnum()
True


"seven".isalnum()
True


"11".isalnum()
True

14.isalpha(): 检测字符串是否只由字母组成。字符串中至少有一个字符且所有字符都是字母则返回 True,否则返回 False。

语法：str.isalpha() -> bool 返回值为布尔类型（True,False）

参数：无

示例：

"I love python".isalpha()  # 存在空格返回False
False

"Ilovepython".isalpha()
True

"Ilovepython123".isalpha()
False

15.isdigit(): 检测字符串是否只由数字组成.字符串中至少有一个字符且所有字符都是数字则返回 True,否则返回 False。

语法：str.isdigit() -> bool 返回值为布尔类型（True,False）

参数：无

注：能判断“①”，不能判断中文数字。但 isnumeric() 函数可以。

示例：

"python".isdigit()  # 全为字母
False


"123".isdigit()  # 全为数字
True

"python666".isdigit()  # 字母和数字的组合
False

"一二三四五六七".isdigit()  # 中文数字输出False
False

16.islower(): 检测字符串中的字母是否全由小写字母组成。（字符串中可包含非字母字符）字符串中包含至少一个区分大小写的字符，且所有这些区分大小写的字符都是小写，则返回 True，否则返回 False。

语法：str.islower() -> bool 返回值为布尔类型（True,False）

参数：无

示例：

# 字符串中的字母全为小写
"i love python".islower()  
True

 # 字符串中的字母全为小写，也存在非字母的字符
"我爱python！".islower() 
True

# 字符串中有大写字符
"I love python".islower() 
False

17.isupper(): 检测字符串中的字母是否全由大写字母组成。（字符串中可包含非字母字符）。字符串中包含至少一个区分大小写的字符，且所有这些区分大小写的字符都是大写，则返回 True，否则返回 False。

语法：str.isupper() -> bool 返回值为布尔类型（True,False）

参数：无

示例：

"I LOVE PYTHON".isupper() # 全为大写字母
True

"i LOVE PYTHON".isupper()  # 存在小写字母
False

"我爱PYTHON".isupper()  # 存在非字母的字符
True

18.isspace(): 检测字符串是否只由空格组成。若字符串中只包含空格，则返回 True，否则返回 False。

语法：str.isspace() -> bool 返回值为布尔类型（True,False）

参数：无

示例：

str1 = "   "  # 空格
str2 = "i love python" 
print(str1.isspace())
True
print(str2.isspace())
False
print(str2[1].isspace())  # 字符串str2 的第二个字符为空格
True

19.istitle(): 检测判断字符串中所有单词的首字母是否为大写，且其它字母是否为小写，字符串中可以存在其它非字母的字符。若字符串中所有单词的首字母为大写，且其它字母为小写，则返回 True，否则返回 False.

语法：str.istitle() -> bool 返回值为布尔类型（True,False）

参数：无

示例：

"I Love Python".istitle()  # 各单词的首字母均为大写，其余字母为小写
True
"I love python".istitle() 
False

"I LOVE PYTHON".istitle()
False

"我爱Python".istitle()  # 存在其它非字母字符，
True

20.strip(): 该函数的作用是去除字符串开头和结尾处指定的字符，不会去除字符串中间对应的字符

语法：str.strip(chars)

参数：chars – 要去除的字符 默认为空格或换行符。

示例：

# 默认参数，去除了空格，\n \t \r字符，且未除去字符串中间相应的字符
a = ' \n111 aaa  '
print(a.strip())
111 aaa


# 去除两端的指定字符
b='.-.word:我很帅.-.'
print(b.strip('.-.'))
word:我很帅


c='参考：来自公众号AI入门学习'
print(c.strip('参考：'))
来自公众号AI入门学

21.lstrip(): lstrip() 方法用于截掉字符串左边的空格或指定字符。

语法：str.lstrip(chars)

参数：chars–要去除的字符 默认为空格或换行符。

示例：

# 去除左边指定字符
a = '--我爱Python--'
a.lstrip('--')
'我爱Python--'


# 重复的值只需要写一个
a.lstrip('-')
'我爱Python--'

22.rstrip(): 删除 str 字符串末尾的指定字符（默认为空格）

语法：str.rstrip(chars)

参数：chars --要去除的字符 默认为空格或换行符。

示例：

# 去除左边指定字符
a = '6234412134445533-456'
a.rstrip('-456')
'6234412134445533'


# 对一个列表所有的字符串进行去除
ls = ['34667777777-456','62344121344433-456','28993333455-456']
[i.rstrip('-456') for i in ls]
['34667777777', '62344121344433', '28993333']

23.join(): 将iterable变量的每一个元素后增加一个str字符串。

语法： sep.join(iterable)

• sep——分隔符。可以为空。
• iterable—— 要连接的变量 ，可以是 字符串，元组，字典，列表等。

示例：

python中经常看到join，特别是在自然语言处理的时候，分词什么的，但是很多初学者不理解其中的意思，这里进行详细的介绍，希望对大家能有帮助。
将可迭代对象(iterable)中的字符串使用string连接起来。注意，iterable中必须全部是字符串类型，否则报错。如果你还是python的初学者，还不知道iterable是什么，却想来看看join的具体语法，那么你可以暂时将它理解为：字符串string、列表list、元组tuple、字典dict、集合set。当然还有生成器generator等也可以用该方法。


1）字符串
L='python'
'_'.join(L)
'p_y_t_h_o_n'
'_uu_'.join(L)
'p_uu_y_uu_t_uu_h_uu_o_uu_n'


2）元组
L1=('1','2','3')
'_'.join(L1)
'1_2_3'


3）集合。注意，集合无序。
L2={
     'p','y','t','h','o','n'}
'_'.join(L2)
't_n_o_h_y_p'


4）列表
L2=['py','th','o','n']
'_'.join(L2)
'py_th_o_n'


5）字典
L3={
     'name':"malongshuai",'gender':'male','from':'China','age':18}
'_'.join(L3)
'name_gender_from_age'

---

五、本单元知识总结

1.字符串的格式
2.字符串的输入与输出
3.通过下标索引获取字符
4.字符串的切片
5.常用的字符串操作方法

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第五单元，选择题，填空题，简答题(1,2,3、4、5)、技能题（1、2、3、4、5）
2.完成教材第四章节(实例02,实例03,实例04,实例05)

（Ⅲ）预习作业

1.预习第单元，常见数据类型之列表常见操作
2.预习教材，第四章 序列的应用 4.2 列表

预习附录：

1.参见教材：第五章<84,98>页

第六单元 常见数据类型之列表常见操作

一、昨日知识点回顾

1. 字符串的输入与输出有哪些？
2. 字符串的切片有哪些？
3. 常用的字符串操作方法有哪些？
4. 怎么通过下标索引获取字符串内容？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学python(全彩版)》，第4章 列表，页码区间<84,100>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1. 列表的格式
2. 列表的常见操作
3. 列表的嵌套操作

（Ⅱ）能力目标

1.掌握列表的格式
2.熟练掌握列表的常见操作
3.熟练掌握列表的嵌套操作

---

四、本单元知识详讲

6.1 列表介绍

6.1.1 列表格式介绍 ★★★★★

变量A的类型为列表

namesList = ['xiaoWang','xiaoZhang','xiaoHua']

比C语言的数组强大的地方在于列表中的元素可以是不同类型的

testList = [1, 'a']

6.1.2 列表根据索引取值介绍及案例讲解 ★★★★★

demo:

namesList = ['xiaoWang','xiaoZhang','xiaoHua']    
print(namesList[0])    
print(namesList[1])    
print(namesList[2])

结果：

xiaoWang    
xiaoZhang    
xiaoHua

6.1.3 列表元素的遍历及案例讲解 ★★★★★

1. 使用for循环

为了更有效率的输出列表的每个数据，可以使用循环来完成

demo:

namesList = ['xiaoWang','xiaoZhang','xiaoHua']    
for name in namesList:        
	print(name)

结果:

xiaoWang    
xiaoZhang    
xiaoHua

2. 使用while循环

为了更有效率的输出列表的每个数据，可以使用循环来完成

demo:

namesList = ['xiaoWang','xiaoZhang','xiaoHua']    
length = len(namesList)

i = 0

while i<length:        
	print(namesList[i])        
	i+=1

结果:

xiaoWang    
xiaoZhang    
xiaoHua

6.2 列表常见操作

6.2.1列表添加元素的几种方法及案例讲解 ★★★★★

• append

通过append可以向列表添加元素

demo:

# 定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']    
print("-----添加之前，列表A的数据-----")    
for tempName in A:        
	print(tempName)    

# 提示、并添加元素
temp = input('请输入要添加的学生姓名:')    
A.append(temp)    

print("-----添加之后，列表A的数据-----")    
for tempName in A:        
	print(tempName)

结果:

-----添加之前，列表A的数据-----
xiaoWang
xiaoZhang
xiaoHua
请输入要添加的学生姓名:xiaoqiang
-----添加之后，列表A的数据-----
xiaoWang
xiaoZhang
xiaoHua
xiaoqiang

• extend

通过extend可以将另一个集合中的元素逐一添加到列表中

>>> a = [1, 2]
>>> b = [3, 4]
>>> a.append(b)
>>> a[1, 2, [3, 4]]
>>> a.extend(b)
>>> a[1, 2, [3, 4], 3, 4]

• insert

insert(index, object) 在指定位置index前插入元素object

>>> a = [0, 1, 2]
>>> a.insert(1, 3)
>>> a[0, 3, 1, 2]

6.2.2 列表删除元素的几种方法及案例讲解 ★★★★★

类比现实生活中，如果某位同学调班了，那么就应该把这个条走后的学生的姓名删除掉；在开发中经常会用到删除这种功能。

列表元素的常用删除方法有：

• del：根据下标进行删除
• pop：删除最后一个元素
• remove：根据元素的值进行删除

demo:(del)

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']    
print('------删除之前------')    
for tempName in movieName:        
    print(tempName)    
del movieName[2]

print('------删除之后------')    
for tempName in movieName:        
	print(tempName)

结果:

------删除之前------    
加勒比海盗    
骇客帝国    
第一滴血    
指环王    
霍比特人    
速度与激情    
------删除之后------    
加勒比海盗    
骇客帝国    
指环王    
霍比特人    
速度与激情

demo:(pop)

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']    
print('------删除之前------')    
for tempName in movieName:        
    print(tempName)    
movieName.pop()

print('------删除之后------')    
for tempName in movieName:        
	print(tempName)

结果:

------删除之前------    
加勒比海盗    
骇客帝国    
第一滴血    
指环王    
霍比特人    
速度与激情    
------删除之后------    
加勒比海盗    
骇客帝国    
第一滴血    
指环王    
霍比特人

demo:(remove)

movieName = ['加勒比海盗','骇客帝国','第一滴血','指环王','霍比特人','速度与激情']    
print('------删除之前------')    
for tempName in movieName:        
    print(tempName)    
movieName.remove('指环王')    
print('------删除之后------')    
for tempName in movieName:        
	print(tempName)

结果:

------删除之前------    
加勒比海盗    
骇客帝国    
第一滴血    
指环王    
霍比特人    
速度与激情    
------删除之后------    
加勒比海盗    
骇客帝国    
第一滴血    
霍比特人    
速度与激情

6.2.3 列表修改元素方法及案例讲解 ★★★★★

修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改

demo:

# 定义变量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']    
print("-----修改之前，列表A的数据-----")    
for tempName in A:
    print(tempName)    

# 修改元素
A[1] = 'xiaoLu'

print("-----修改之后，列表A的数据-----")    
for tempName in A:        
	print(tempName)

结果:

-----修改之前，列表A的数据-----    
xiaoWang    
xiaoZhang    
xiaoHua    
-----修改之后，列表A的数据-----    
xiaoWang    
xiaoLu    
xiaoHua

6.2.4 列表查询元素的方法及案例讲解 ★★★★★

所谓的查找，就是看看指定的元素是否存在

• in, not in

  python中查找的常用方法为：

  • in（存在）,如果存在那么结果为true，否则为false
  • not in（不存在），如果不存在那么结果为true，否则false

demo

# 待查找的列表
nameList = ['xiaoWang','xiaoZhang','xiaoHua']  # 获取用户要查找的名字
findName = input('请输入要查找的姓名:')  # 查找是否存在
if findName in nameList:        
    print('在字典中找到了相同的名字')    
else:        
	print('没有找到')

说明：in的方法只要会用了，那么not in也是同样的用法，只不过not in判断的是不存在

• index, count

index和count与字符串中的用法相同

>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3)  # 注意是左闭右开区间
Traceback (most recent call last):  File "", line 1, in <module>ValueError: 'a' is not in list
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

6.2.5 列表元素排序与反转及案例讲解 ★★★★★

sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。

reverse方法是将list逆置。

>>> a = [1, 4, 2, 3]
>>> a[1, 4, 2, 3]
>>> a.reverse()
>>> a[3, 2, 4, 1]
>>> a.sort()
>>> a[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a[4, 3, 2, 1]

6.3 列表的嵌套

6.3.1 列表嵌套8大名校案例讲解 ★★★★★

类似while循环的嵌套，列表也是支持嵌套的

一个列表中的元素又是一个列表，那么这就是列表的嵌套

schoolNames = [['北京大学', '清华大学'],
               ['南开大学', '天津大学', '天津师范大学'],
               ['山东大学', '中国海洋大学']]

五、本单元知识总结

1. 列表的格式
2. 列表的常见操作
3. 列表的嵌套操作

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第六单元，选择题，填空题，简答题(1,2,3,4)、技能题（1、2、3）

（Ⅲ）预习作业

1.预习第七单元，元组知识点
2.预习教材，元组知识点

预习附录：

1.参见教材：第五章<101,109>页

第七单元 常见数据类型之元组与字典

一、昨日知识点回顾

1. 列表添加有几种方法？
2. 列表删除有几种方法？
3. 怎样修改列表中的元素？
4. 怎样查找列表中的元素？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学python全彩版》，第4章 序列的应用，页码区间<79,126>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.元组的内置函数
2.字典的常见操作
3.字典的遍历

（Ⅱ）能力目标

1.掌握元组的下标取值
2.掌握元组元素的遍历
3.掌握元组内置函数应用
4.掌握字典的格式
5.掌握字典的增删改查操作
6.掌握字典的遍历操作
7.掌握字典的常见的操作方法

---

四、本单元知识详讲

7.1 元组的介绍

7.1.1 元组格式的介绍 ★★★★

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

aTuple = (1,"王者荣耀","鲁班")

7.1.2 元组的下标取值及案例讲解 ★★★★★

aTuple = (1,"王者荣耀","鲁班")
print(aTuple[0])
print(aTuple[1])
print(aTuple[2])

效果如下

1
王者荣耀
鲁班

7.1.3 元组中元素的遍历及案例讲解 ★★★★★

aTuple = (1,"王者荣耀","鲁班")
for i in aTuple:
	print(i)

效果如下

1
王者荣耀
鲁班

7.2 元组的内置函数

7.2.1 index()方法及案例讲解 ★★★★★

index(): 用于从元组中找出某个对象第一个匹配项的索引位置，如果这个对象不在元组中会抛出一个异常。

aTuple = ("王者荣耀","吃鸡","英雄联盟","王者荣耀")
x = aTuple.index("王者荣耀")
j = aTuple.index("安其拉")
print(x)
print(j)

效果如下

0
Traceback (most recent call last):
  File "C:/练习/day04/正式上课/day06/12day/总结.py", line 20, in <module>
    j = aTuple.index("安其拉")
ValueError: tuple.index(x): x not in tuple

7.2.2 count()方法及案例讲解 ★★★★★

count(): 返回指定值在元组中出现的次数

aTuple = ("王者荣耀","吃鸡","英雄联盟","王者荣耀")
x = aTuple.count("王者荣耀")
j = aTuple.count("安其拉")
print(x)
print(j)

效果如下

2
0

7.3 字典的介绍

7.3.1 字典的格式介绍 ★★★★★

字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号**{}**中 ,格式如下所示：

dict = {
     key1 : value1, key2 : value2}

7.3.2 字典键值对介绍 ★★★★★

键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

dict = {
     'name': '安其拉', 'sex': '女', 'address': '王者峡谷'}

7.3.3 字典根据键获取值 ★★★★★

生活中的字典

开发中的字典

info = {
     'name':'安其拉', 'id':100, 'sex':'女', 'address':'王者峡谷'}

说明：

​ 1.字典和列表一样，也能够存储多个数据

​ 2.列表中找某个元素时，是根据下标进行的

​ 4.字典中找某个元素时，是根据’名字’（就是冒号前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）

​ 5.字典的每个元素由2部分组成，键与值。例如 ‘name’:‘安其拉’ ,'name’为键，'安其拉’为值

根据键访问值

info = {
     'name':'安其拉','id':100,'sex':'女','address':'王者峡谷'}
print(info['name'])
print(info['address'])

效果如下

安其拉
王者峡谷

若访问不存在的键，则会报错

print(info['age'])

效果如下

Traceback (most recent call last):  File "", line 1, in <module>KeyError: 'age'

7.3.4 get()方法 ★★★★★

在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值

age = info.get('age')
print(age) 
age = info.get('age', 18) 
print(age)

效果如下

None  # 'age'键不存在，所以age为None
18  # 若info中不存在'age'这个键，就返回默认值18

7.4 字典的常见操作（基础）

7.4.1 字典中增加元素方法及案例讲解 ★★★★★

如果在使用 变量名[‘键’] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素

添加新的元素

info = {
     'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}    
newId = input('请输入新的ID:')    
info['id'] = newId    
print('添加之后的ID为:%d' % info['id'])

效果如下

请输入新的ID:188    
添加之后的ID:188

7.4.2 字典中修改元素方法及案例讲解 ★★★★★

字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

info = {
     'name':'安其拉', 'id':100, 'sex':'女', 'address':'王者峡谷'}        
newId = input('请输入新的ID:')    
info['id'] = int(newId)    
print('修改之后的ID为%d:' % info['id'])

效果如下

请输入新的ID:101
修改之后的ID:101

7.4.3 字典中查询元素方法及案例讲解 ★★★★★

除了直接使用key查找数据，还可以使用get来获取数据

info = {
     'name':'安其拉','age':4}    
print(info['age'])  # 获取年龄
print(info['sex'])  # 获取不存在的key，会发生异常
print(info.get('sex'))  # 获取不存在的key，获取到空的内容，不会出现异常

效果如下

4
Traceback (most recent call last):
  File "C:/练习/day04/正式上课/11day/01.py", line 3, in <module>
    print(info['sex'])  # 获取不存在的key，会发生异常
KeyError: 'sex'
None

7.4.4 字典中删除元素方法及案例讲解 ★★★★★

对字典进行删除操作，有以下几种

1.del：删除指定的元素

info = {
     'name':'安其拉','sex':'女','address':'王者峡谷'}
print('删除前,%s' % info['name'])    
del info['name']    
print('删除后,%s' % info['name'])

效果如下

删除前,安其拉
Traceback (most recent call last):
  File "/Users/mac/PycharmProjects/Month1/0000.py", line 89, in <module>
    print('删除后,%s' % info['name'])
KeyError: 'name'

2.del：删除整个字典

info = {
     'name':'安其拉','sex':'女','address':'王者峡谷'}   
print('删除前,%s' % info)    
del info    
print('删除后,%s' % info)

效果如下

删除前,{
     'name':'安其拉','sex':'女','address':'王者峡谷'}
Traceback (most recent call last):
  File "/Users/mac/PycharmProjects/Month1/0000.py", line 88, in <module>
    print('删除后,%s' % info)
NameError: name 'info' is not defined

3.clear：清空整个字典

info = {
     'name':'安其拉','sex':'女','address':'王者峡谷'}     
print('清空前,%s' % info)    
info.clear()    
print('清空后,%s' % info)

效果如下

清空前,{
     'name':'安其拉','sex':'女','address':'王者峡谷'}
清空后,{
     }

7.5 字典的常见操作（高级）

7.5.1 字典常见操作之len()方法及案例讲解 ★★★★★

len(): 测量字典中，键值对的个数

dict={
     "name":"安其拉","sex":"女"}
print(len(dict))

效果如下

2

7.5.2 字典常见操作之keys()方法及案例讲解 ★★★★★

keys(): 返回一个包含字典所有key的对象

dict={
     "name":"安其拉","sex":"女"}
print(dict.keys())

效果如下

dict_keys(['name', 'sex'])

7.5.3 字典常见操作之values()方法及案例讲解 ★★★★★

values(): 返回一个包含字典所有value的对象

dict={
     "name":"安其拉","sex":"女"}
print(dict.values())

效果如下

dict_values(['安其拉', '女'])

7.5.4 字典常见操作之items()方法及案例讲解 ★★★★★

items(): 返回一个包含所有（键，值）元组的对象

dict={
     "name":"安其拉","sex":"女"}
print(dict.items())

效果如下

dict_items([('name', '安其拉'), ('sex', '女')])

7.6 字典的遍历

7.6.1 字典的几种遍历方法及案例讲解 ★★★★★

1.遍历字典的key（键）

dict={
     "name":"安其拉","sex":"女"}
for i in dict.keys():
    print(i)

效果如下

name
sex

2.遍历字典的value（值）

dict={
     "name":"安其拉","sex":"女"}
for i in dict.values():
    print(i)

效果如下

安其拉
女

3.遍历字典的项（元素）

dict={
     "name":"安其拉","sex":"女"}
for i in dict.items():
    print(i)

效果如下

('name', '安其拉')
('sex', '女')

4.遍历字典的key-value（键值对）

dict={
     "name":"安其拉","sex":"女"}
for i,j in dict.items():
    print(i,j)

效果如下

name 安其拉
sex 女

7.6.2 带索引的遍历方法讲解及案例讲解 ★★★★★

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

chars = ['a', 'b', 'c', 'd']
for i, chr in enumerate(chars):
	print i, chr

效果如下

0 a
1 b
2 c
3 d

---

五、本单元知识总结

1. 元组下标取值
2. 字典增删改查
3. 字典遍历

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第八单元，选择题，填空题，简答题(1,2,4,5)、技能题（1、2、3）

（Ⅲ）预习作业

1.预习第九单元，常见数据类型之集合与公共方法和内置函数

预习附录：

1.参见教材：第四章<119,123>页

第八单元 常见数据类型之集合与公共方法和内置函数

一、昨日知识点回顾

1. 元组的格式是什么？
2. 怎么遍历元组？
3. 元组的内置函数如何使用？
4. 字典的格式是什么？
5. 字典的增删改查如何实现？
6. 字典如何遍历？
5. 字典常见的操作方法有哪些？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学Python全彩版》，第四章 序列的应用，页码区间<119,123>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.集合的格式
2.集合的无序性和唯一性
3.集合的操作
4.集合的交集和并集
5.Python中的内置函数

（Ⅱ）能力目标

1.掌握集合的无序性和唯一性
2.了解集合的常见操作
3.掌握公共方法
4.掌握Python内置函数

---

四、本单元知识详讲

8.1 集合的介绍

8.1.1 集合格式介绍 ★★★

集合是无序的，集合中的元素是唯一的，集合一般用于元组或者列表中的元素去重。

定义空集合：

  set1 = set()  
  # 注意以下写法会创建一个空字典  
  set2 = {
     }

8.1.2 集合的无序性介绍 ★★★★

集合里的元素是无序的

set_2 = {
     '老王',1,'abc'}

print(set_2)       

效果如下

{
     1, '老王', 'abc'}

8.1.3 集合的唯一性介绍 ★★★

集合里的元素是唯一的

set_2 = {
     1,2,3,4,1,2,3,4}
print(set_2)       

效果如下

{
     1, 2, 3, 4}

8.2 集合的常见操作

8.2.1 集合的常见操作之添加元素方法及案例讲解

1.add: 添加元素

set1 = {
     1, 2, 4, 5}
# 添加元素
set1.add(8)

2.update: 把要传入的元素拆分，做为个体传入到集合中

set1 = {
     1, 2, 4, 5}
# 是把要传入的元素拆分，做为个体传入到集合中
set1.update("abcd")

8.2.2 集合的常见操作之删除元素方法及案例讲解

1.remove: 删除集合中的元素 如果有 直接删除 如果没有 程序报错

set1 = {
     1, 2, 4, 5}

# 使用remove删除集合中的元素 如果有 直接删除 如果没有 程序报错
set1.remove(22)

2.pop: 随机删除集合中的元素 如果set1没有元素程序报错

set1 = {
     1, 2, 4, 5}

# 使用pop删除是随机删除集合中的元素 如果set1没有元素程序报错
set1.pop()

3.discard: 删除 如果元素存在 直接删除 如果元素不存在 不做任何操作

set1 = {
     1, 2, 4, 5}

# 使用discard删除 如果元素存在 直接删除 如果元素不存在 不做任何操作
set1.discard(2)

8.2.3 集合的交集和并集 ★★★★★

1.交集( & )

set1 = {
     1, 2, 3, 4}
set2 = {
     3, 4, 5, 6}
new_set = set1 & set2
print(new_set) 

效果如下:

{
     3, 4}

2.并集( | )

set1 = {
     1, 2, 3, 4}

set2 = {
     3, 4, 5, 6}
new_set = set1 | set2
print(new_set)

效果如下

{
     1, 2, 3, 4, 5, 6}

8.3 公共方法

8.3.1 公共方法的介绍★★★★★

运算符	Python 表达式	结果	描述	支持的数据类型
+	[1, 2] + [3, 4]	[1, 2, 3, 4]	合并	字符串、列表、元组
*	[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	复制	字符串、列表、元组
in	3 in (1, 2, 3)	True	元素是否存在	字符串、列表、元组、字典
not in	4 not in (1, 2, 3)	True	元素是否不存在	字符串、列表、元组、字典

8.3.2 公共方法的案例讲解 ★★★★

1.+: 合并

>>> "hello " + "beijing"

'hello beijing'
>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> ('a', 'b') + ('c', 'd')
('a', 'b', 'c', 'd')

2.*: 复制

 >>> 'ab' * 4
'ababab'
>>> [1, 2] * 4
[1, 2, 1, 2, 1, 2, 1, 2]
>>> ('a', 'b') * 4
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')

3.in: 元素是否存在

>>> 'hello' in 'hello python'
True
>>> 3 in [1, 2]
False
>>> 4 in (1, 2, 3, 4)
True
>>> "name" in {
     "name":"Delron", "age":24}
True

注意，in在对字典操作时，判断的是字典的键

4. not in: 元素是否不存在

>>> 'hello' not in 'hello python'
False
>>> 3 in [1, 2]
True

8.4 Python内置函数

8.4.1 Python内置函数的介绍 ★★★★★

Python包含了以下内置函数：

序号	方法	描述
1	len(item)	计算容器中元素个数
2	max(item)	返回容器中元素最大值
3	min(item)	返回容器中元素最小值
4	del(item)	删除变量

8.4.2 Python内置函数的案例讲解★★★★★

1.len: 计算容器中元素个数

>>> len("hello python")
12
>>> len([1, 2, 3, 4])
4
>>> len((3,4))
2
>>> len({
     "a":1, "b":2})
2

注意：len在操作字典数据时，返回的是键值对个数。

2.max: 返回容器中元素最大值

>>> max("hello python")
'y'
>>> max([1,4,522,3,4])
522
>>> max({
     "a":1, "b":2})
'b'
>>> max({
     "a":10, "b":2})
'b'
>>> max({
     "c":10, "b":2})
'c'

3.min:返回容器中元素最小值

>>> min([1, 2, 3, 4])
1
>>> min([1,4,522,3,4])
1

4.del: 删除变量

del有两种用法，一种是del加空格，另一种是del()

>>> a = 1
>>> a
1
>>> del a
>>> a
Traceback (most recent call last):
  File "", line 1, in <module>
NameError: name 'a' is not defined
>>> a = ['a', 'b']
>>> del a[0]
>>> a
['b']
>>> del(a)
>>> a
Traceback (most recent call last):
  File "", line 1, in <module>
NameError: name 'a' is not defined

---

五、本单元知识总结

1.集合的格式
2.集合的无序性和唯一性
3.集合的操作
4.集合的交集和并集
5.Python中的内置函数

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第八单元，选择题，填空题，简答题(1,2,3，4)、技能题（1、2、3，4）
2.完成教材第四章节，课后习题(实例12,实例13,实例14)

（Ⅲ）预习作业

1.预习第九单元，函数基础
2.预习教材，第六章 函数

预习附录：

1.参见教材：第五章<160,180>页

第九单元 函数基础

一、昨日知识点回顾

1. 集合的常见操作有哪些？
2. Python的公共方法有哪些？
3. Python内置函数有哪些？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学Python(全彩版)》，第6章 函数，页码区间<159,173>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.函数的参数基本操作
2.函数的返回值应用
3.四种常见的函数类型
4.函数的嵌套调用及应用

（Ⅱ）能力目标

1.掌握函数的参数基本操作
2.掌握函数的返回值应用
3.掌握四种常见的函数类型
4.掌握函数的嵌套调用及应用

---

四、本单元知识详讲

9.1 函数的介绍

9.1.1 函数的定义 ★★★★★

定义函数的格式如下：

def 函数名():
    代码

demo:

# 定义一个函数，能够完成打印信息的功能
def printInfo():
    print('------------------------------------')    
    print('         人生苦短，我用Python')    
    print('------------------------------------')

9.1.2 函数的调用 ★★★★★

定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它

调用函数很简单的，通过 函数名() 即可完成调用

demo:

# 定义完函数后，函数是不会自动执行的，需要调用它才可以
printInfo()

9.1.3 函数的文档说明 ★★★

>>> def test(a,b):
...     "用来完成对2个数求和"
...     print("%d"%(a+b))
... 
>>> 
>>> test(11,22)
33

如果执行以下代码

>>> help(test)

能够看到test函数的相关说明

Help on function test in module __main__:

test(a, b)    
    用来完成对2个数求和
(END)

9.2 函数的参数

9.2.1 函数参数的介绍 ★★★★★

思考：

现在需要定义一个函数，这个函数能够完成2个数的加法运算，并且把结果打印出来，该怎样设计？下面的代码可以吗？有什么缺陷吗？

def add2num():
    a = 11
    b = 22
    c = a+b       
    print c

为了让一个函数更通用，即想让它计算哪两个数的和，就让它计算哪两个数的和，在定义函数的时候, 可以让函数接收数据，就解决了这个问题，这就是 函数的参数

9.2.2 函数的参数之形参与实参介绍及案例讲解 ★★★★★

示例代码如下：

def add2num(a, b):  # a和b被称为函数add2num的形参
    c = a+b    
    print c

以调用上面的add2num(a, b)函数为例:

def add2num(a, b):
    c = a+b    
    print c

add2num(11, 22) # 调用带有参数的函数时，需要在小括号中传递数据, 传递的数据即为实参

调用带有参数函数的运行过程：

9.3函数的返回值

9.3.1 函数的返回值介绍 ★★★★★

现实生活中的场景:

假如父亲给儿子10块钱，让他帮忙买包烟。这个例子中，10块钱是父亲给儿子的，就相当于调用函数时传递的参数，让儿子买烟这个事情最终的目标是，让他把烟带回来然后给父亲对么? 此时烟就是返回值

开发中的场景：

定义了一个函数，完成了获取室内温度，想一想是不是应该把这个结果给调用者，只有调用者拥有了这个返回值，才能够根据当前的温度做适当的调整

综上所述：所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果

9.3.2 函数的返回值应用及案例讲解 ★★★★★

想要在函数中把结果返回给调用者，需要在函数中使用return

如下示例:

def add2num(a, b):
    c = a + b    
    return c

或者

def add2num(a, b):
    return a + b

9.3.3 保存函数的返回值及案例讲解 ★★★★★

在本小节刚开始的时候，说过的“买烟”的例子中，最后儿子给父亲烟时，父亲一定是从儿子手中接过来, 对么? 程序也是如此，如果一个函数返回了一个数据，那么想要用这个数据，就需要保存

保存函数的返回值示例如下:

# 定义函数
def add2num(a, b):
    return a + b

# 调用函数，顺便保存函数的返回值
result = add2num(100,98)

# 因为result已经保存了add2num的返回值，所以接下来就可以使用了
print(result)

结果:

198

9.4 函数的类型

9.4.1 有参数有返回值的函数介绍及案例讲解 ★★★★★

此类函数，不仅能接收参数，还可以返回某个数据，一般情况下，像数据处理并需要结果的应用，用此类函数

# 计算1~num的累加和
def calculate_num(num):
    result = 0
    i = 1
    while i <= num:        
        result = result + i        
        i += 1
    return result

result = calculate_num(100)
print('1~100的累加和为:%d' % result)

结果:

1~100的累加和为:5050

9.4.2 有参数无返回值的函数介绍及案例讲解 ★★★★★

此类函数，能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数

# 计算1~num的累加和
def calculate_num(num):
    result = 0
    i = 1
    while i <= num:        
        result = result + i        
        i += 1
    print('1~100的累加和为:%d' % result)

calculate_num(100)

结果:

1~100的累加和为:5050

9.4.3 无参数有返回值函数介绍及案例讲解 ★★★★★

此类函数，不能接收参数，但是可以返回某个数据，一般情况下，像采集数据，用此类函数

# 获取温度
def get_temperature():
    # 这里是获取温度的一些处理过程
    # 为了简单起见，先模拟返回一个数据
    return 24

temperature = get_temperature()
print('当前的温度为:%d' % temperature)

结果:

当前的温度为:24

9.4.4 无参数无返回值函数介绍及案例讲解 ★★★★★

此类函数，不能接收参数，也没有返回值，一般情况下，打印提示等类似的功能，使用这类函数

def print_menu():
    print('--------------------------')    
    print('      xx涮涮锅 点菜系统')    
    print('')    
    print('  1.  羊肉涮涮锅')    
    print('  2.  牛肉涮涮锅')    
    print('  3.  猪肉涮涮锅')    
    print('--------------------------')

9.5 函数的嵌套调用与应用

9.5.1 函数的嵌套调用介绍及案例讲解 ★★★★★

def testB():
    print('---- testB start----')    
    print('这里是testB函数执行的代码...(省略)...')    
    print('---- testB end----')

def testA():
    print('---- testA start----')    
    testB()    
    print('---- testA end----')

testA()

结果：

---- testA start----
---- testB start----
这里是testB函数执行的代码...(省略)...
---- testB end----

小总结：

• 一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用
• 如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次 函数A执行的位置
  

9.5.2 函数的应用案例 ★★★★★

目标

• 感受函数的嵌套调用
• 感受程序设计的思路,复杂问题分解为简单问题

思考&实现1

1. 写一个函数打印一条横线
2. 打印自定义行数的横线

参考代码1

# 打印一条横线
def print_one_line():
    print("-" * 30)

# 打印多条横线
def print_num_line(num):
    i = 0
    # 因为print_one_line函数已经完成了打印横线的功能，
    # 只需要多次调用此函数即可
    while i < num:        
        print_one_line()        
        i += 1

print_num_line(3)

思考&实现2

1. 写一个函数求三个数的和
2. 写一个函数求三个数的平均值

参考代码2

# 求3个数的和
def sum3number(a, b, c):
    return a + b + c 
    # return 的后面可以是数值，也可是一个表达式

# 完成对3个数求平均值
def average3number(a, b, c):

    # 因为sum3number函数已经完成了3个数的就和，所以只需调用即可
    # 即把接收到的3个数，当做实参传递即可
    sum_result = sum3number(a, b, c)    
    ave_result = sum_result/3.0
    return ave_result

# 调用函数，完成对3个数求平均值
result = average3number(11, 2, 55)
print("average is %d" % result)

---

五、本单元知识总结

1.函数的参数基本操作
2.函数的返回值应用
3.四种常见的函数类型
4.函数的嵌套调用及应用

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第九单元，选择题，填空题，简答题(1,2,3,4)、技能题（1,2,3,4）
2.完成教材第6章节，课后习题(1,2)

（Ⅲ）预习作业

1.预习第十单元，函数高级知识点
2.预习教材，函数高级知识点

预习附录：

1.参见教材：第六章<174,180>页

第十单元 函数高级

一、昨日知识点回顾

1. 函数的参数是什么？
2. 函数的返回值是什么？
3. 函数的类型有哪几种？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学python全彩版》，第6章 函数，页码区间<159,180>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.函数的局部变量和全局变量
2.函数的返回值
3.拆包

（Ⅱ）能力目标

1.掌握全局变量和局部变量
2.掌握函数的返回值和参数
3.掌握拆包和交换变量的值
4.掌握可变类型和不可变类型

---

四、本单元知识详讲

10.1 函数的局部变量和全局变量

10.1.1 局部变量介绍及案例讲解 ★★★★★

什么是局部变量?

如下图所示

总结

• 局部变量，就是在函数内部定义的变量
• 其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的
• 因为其作用范围只是在自己的函数内部，所以不同的函数可以定义相同名字的局部变量（打个比方，把你、我当做成函数，把局部变量理解为每个人手里的手机，你可有个iPhone8，我当然也可以有个iPhone8了， 互不相关）
• 局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储
• 当函数调用时，局部变量被创建，当函数调用完成后这个变量就不能够使用了

10.1.2 全局变量介绍及案例讲解 ★★★★★

什么是全局变量？

如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量，打个比方：有2个兄弟各自都有手机，各自有自己的小秘密在手机里，不让另外一方使用（可以理解为局部变量）；但是家里的电话是2个兄弟都可以随便使用的（可以理解为全局变量）

# 定义全局变量
a = 100
def test1():
    print(a)  # 虽然没有定义变量a但是依然可以获取其数据
def test2():
    print(a)  # 虽然没有定义变量a但是依然可以获取其数据
# 调用函数
test1()
test2()

效果如下

100
100

总结

• 在函数外边定义的变量叫做全局变量
• 全局变量能够在所有的函数中进行访问

10.1.3 全局变量和局部变量名字相同的情况介绍及案例讲解 ★★★★

总结

• 当函数内出现局部变量和全局变量相同名字时，函数内部中的变量名 = 数据，此时理解为定义了一个局部变量，而不是修改全局变量的值

10.1.4 修改全局变量及案例讲解 ★★★★

在函数中进行使用的全局变量可否进行修改呢？

总结

• 如果在函数中出现global 全局变量的名字, 那么这个函数中即使出现和全局变量名相同变量名 = 数据也理解为对全局变量进行修改，而不是定义局部变量

• 如果在一个函数中需要对多个全局变量进行修改，那么可以使用如下方式:

  # 可以使用一次global对多个全局变量进行声明
  global a, b  # 还可以用多次global声明都是可以的
  # global a
  # global b
  

10.2 函数的返回值（升级）

10.2.1 return的作用 ★★★★★

1.用来返回函数的返回值

2.结束函数

10.2.2 函数的返回值及案例讲解（升级） ★★★★★

def create_nums():
    print("---1---")    
    return 1  # 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数
    print("---2---")    
    return 2
    print("---3---")

效果如下

---1---

总结

• 一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处
• 如果程序设计如下所示是可以的, 因为不同的场景下执行不同的return

def create_nums(num):
      print("---1---")      
      if num == 100:          
          print("---2---")          
          return num+1  # 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数
      else:          
          print("---3---")          
          return num+2
      print("---4---")  

  result1 = create_nums(100)  
  print(result1) 
  result2 = create_nums(200)  
  print(result2)  

效果如下

---1---
---2---
101
---1---
---3---
202

10.3 拆包和交换变量的值

10.3.1 对返回的数据直接拆包的介绍及案例讲解 ★★★★★

# 定义一个函数get_my_info, 其内部定义单个局部变量, 并使用return将三个变量返回
def get_my_info():
    heigh = 178
    weight = 100
    age = 18
    return high, weight, age

# 调用get_my_info可以获取到三个变量, 分别用my_heigh, my_weight, my_age来进行接收
my_heigh, my_weight, my_age = get_my_info()
print(my_heigh)
print(my_weight)
print(my_age)

效果如下

178
100
18

总结

• 拆包时要注意，需要拆的数据的个数要与变量的个数相同，否则程序会异常
• 除了对元组拆包之外，还可以对列表、字典等拆包
• 如果接收一个返回值但在后续代码中并不使用它, 可以用 _ 来接收该返回值, 在工作中可能会遇见此情形

10.3.2 对元组拆包的介绍及案例讲解 ★★★★★

name, sex = ("李白", "男")  
print(name)  
print(sex)  

效果如下

李白
男

10.3.3 对列表拆包的介绍及案例讲解 ★★★★★

name, sex = ["李白", "男"]  
print(name)  
print(sex) 

效果如下

李白
男

10.3.4 对字典拆包的介绍及案例讲解 ★★★★★

name, sex = {
     "name":"李白", "sex":"男"}  # 取出来的是key，而不是键值对
print(name)
print(sex)

效果如下

name
sex

10.3.5 交换变量的值的介绍及案例讲解 ★★★★★

# 第1种方式
num1 = 4
num2 = 5
num3 = 0
num3 = num1
num1 = num2
num2 = num3
print(num1)
print(num2)

效果如下

5
4

# 第2种方式
num1 = 4
num2 = 5
num1 = num1+num2  # num1=9, num2=5
num2 = num1-num2  # num1=9, num2=4
num1 = num1-num2  # num1=5, num2=4
print(num1)
print(num2)

效果如下

5
4

# 第3种方式
num1, num2 = 4, 5
num1, num2 = num2, num1
print(num1)
print(num2)

效果如下

5
4

10.4 可变类型与不可变类型

10.4.1 可变类型和不可变类型介绍及案例讲解 ★★★★★

总结

• 所谓可变类型与不可变类型是指：数据能否直接进行修改，如果能直接修改那么就是可变，否则是不可变
• 可变类型有： 列表、字典、集合
• 不可变类型有： 数字、字符串、元组

10.4.2 函数使用注意事项 ★★★★

1.自定义函数

(1).无参数无返回值

def 函数名():
    语句

(2).无参数有返回值

def 函数名():
    语句    
    return 需要返回的数值

注意:

• 一个函数到底有没有返回值，就看有没有return，因为只有return才可以返回数据
• 在开发中往往根据需求来设计函数需不需要返回值
• 函数中，可以有多个return语句，但是只要执行到一个return语句，那么就意味着这个函数的调用完成了

(3).有参数无返回值

def 函数名(形参列表):    
    语句

(4).有参数有返回值

def 函数名(形参列表):    
    语句    
    return 需要返回的数值

注意：

• 在调用函数时，如果需要把一些数据一起传递过去，被调用函数就需要用参数来接收
• 参数列表中变量的个数根据实际传递的数据的多少来确定
• 在同一个程序中函数名与函数名或函数名与变量名不能相同, 否则返回出现问题

2.调用函数

(1).调用的方式为

函数名([实参列表])

(2).调用时到底写不写实参?

如果调用的函数 在定义时有形参，那么在调用的时候就应该传递参数

调用时实参个数和先后顺序应该和定义函数中要求一致,如果调用的函数有返回值，那么可以用一个变量来保存这个返回值

3.作用域

在一个函数中定义的变量只能在本函数中用(局部变量)

在函数外定义的变量,可以在所有函数中使用(全局变量)

---

五、本单元知识总结

1. 函数的全局变量和局部变量
2. 函数的返回值
3. 拆包和交换变量的值
4. 可变类型与不可变类型

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第十一单元，选择题，填空题，简答题(1,2,4,5)、技能题（1、2、3）

（Ⅲ）预习作业

1.预习第十一单元，函数实战
2.预习教材，参数传递知识点

预习附录：

2.参见教材：第五章<163,169>页

第十一单元 函数实战

一、昨日知识点回顾

1. 函数的全局变量和局部变量是什么？
2. 函数的返回值和参数是什么？
3. 如何拆包和交换变量的值？
4. 可变类型和不可变类型都有哪些？
5. 函数使用注意事项有哪些？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学Python全彩版》，第六章 函数，页码区间<167,169>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.函数的缺省参数和不定长参数
2.使用函数实现线上学生管理系统
3.列表推导式

（Ⅱ）能力目标

1.掌握函数缺省参数基础应用
2.掌握函数不定长参数基础应用
3.掌握简单列表推导式的构建
4.掌握函数实现线上学生管理系统

---

四、本单元知识详讲

11.1 函数的参数（升级）

11.1.1 函数参数之缺省参数介绍及案例讲解 ★★★★★

调用函数时，缺省参数的值如果没有传入，则取默认值。

示例：

def printinfo(name, age=35):
   # 打印任何传入的字符串
   print("name: %s" % name)   
   print("age %d" % age)

# 调用printinfo函数
printinfo(name="miki")  # 在函数执行过程中 age去默认值35
printinfo(age=9 ,name="miki")

效果如下：

name: miki
age: 35
name: miki
age: 9

11.1.2 函数参数之不定长参数介绍及案例讲解 ★★★★★

有时可能需要一个函数能处理比当初声明时更多的参数, 这些参数叫做不定长参数，声明时不会命名。

基本语法如下：

def functionname([formal_args,] *args, **kwargs):
   """函数_文档字符串"""
   function_suite   
   return [expression]    

注意：

• 加了星号（*）的变量args会存放所有未命名的变量参数，args为元组
• 而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典

>>> def fun(a, b, *args, **kwargs):
...     """可变参数演示示例"""
...     print("a =%d" % a)
...     print("b =%d" % b)
...     print("args:")
...     print(args)
...     print("kwargs: ")
...     print(kwargs)

>>> fun(1, 2, 3, 4, 5, m=6, n=7, p=8)  # 注意传递的参数对应
a =1
b =2
args:
(3, 4, 5)
kwargs: 
{
     'm': 6, 'n': 7, 'p': 8}
>>>
>>>
>>>
>>> c = (3, 4, 5)
>>> d = {
     "m":6, "n":7, "p":8}
>>> fun(1, 2, *c, **d)    # 注意元组与字典的传参方式
a =1
b =2
args:
(3, 4, 5)
kwargs: 
{
     'm': 6, 'n': 7, 'p': 8}
>>>
>>>
>>>
>>> fun(1, 2, c, d) # 注意不加星号与上面的区别
a =1
b =2
args:
((3, 4, 5), {
     'm': 6, 'n': 7, 'p': 8})
kwargs: 
{
     }
>>>
>>>

11.1.3 引用的介绍及案例讲解 ★★★★★

在python中，值是靠引用来传递的。

我们可以用id()来判断两个变量是否为同一个值的引用。 我们可以将id值理解为那块内存的地址标示。

>>> a = 1
>>> b = a
>>> id(a) 
13033816
>>> id(b)   # 注意两个变量的id值相同, 即代表a与b为同一个引用
13033816
>>> a = 2
>>> id(a)   # 注意a的id值已经变了, 因为变量a引用了新的值
13033792
>>> id(b)   # b的id值不变
13033816

>>> a = [1, 2]
>>> b = a
>>> id(a)
139935018544808
>>> id(b)
139935018544808
>>> a.append(3)
>>> a
[1, 2, 3]
>>> id(a)
139935018544808
>>> id(b)       # 注意对于可变数据类型来说, a与b始终指向同一个地址
139935018544808

总结：之前为了更好的理解变量，咱们可以把a=100理解为变量a中存放了100，事实上变量a存储是100的引用（可理解为在内存中的一个编号）

11.2 函数综合案例讲解

11.2.1 使用函数实现线上学生管理系统需求分析与设计思路讲解 ★★★★

思维导图：

11.2.2 使用函数实现线上学生管理系统案例实战 ★★★★

list_student = []
def menu():
    print("学生管理信息系统")
    print("1、添加学生")
    print("2、删除学生")
    print("3、修改学生")
    print("4、查找学生")
    print("5、显示所有学生信息")
    print("6、退出系统")

def add_student():
    global list_student
    new_name = input('请输入学生姓名')
    new_age = input('请输入学生年龄')
    new_sex = input('请输入学生性别')
    # 需要判断  学生是否存在  1、循环列表  2、判断每个字典的name键相对应的值是否等于要插入的学生的姓名
    # 当学生不存在的时候
    # 1、需要创建一个字典  通过字典名['键名'] = 值的方法 将数据存储到字典中

    # 2、将字典追加到列表中
    for i in list_student:
        if i['name'] == new_name:
            print('学生已存在，请重新输入')
            return  # 结束函数

    info = {
     }   # 创建一个字典
    info['name'] = new_name
    info['age'] = new_age
    info['sex'] = new_sex
    list_student.append(info)
    print('添加成功')
    print(list_student)
def del_student():
    global list_student
    # 根据下标删除
    num = int(input('请输入要删除的序号'))
    if  0 <= num < len(list_student):
        meg = input('是否要删除Yes No')
        if meg == 'Yes':
            # del list_student[num]
            list_student.pop(num)
            print('删除成功')
    else:
        print('输入有误，请重新输入')

def modify_student():
    global list_student
    # 根据下标修改
    for i,x in enumerate(list_student):   # 查看所有信息的序号和内容
        print('序号',i,'内容',x)   # x 是字典
    num = int(input('请输入要修改的序号'))
    if  0 <= num < len(list_student):
        # 修改之前先先输出 要修改学生的信息 防止修改错误
        print('要修改学生的信息:')
        print( '姓名:',list_student[num]['name'],
               '年龄:',list_student[num]['age'],
               '性别:',list_student[num]['sex'],
              )
        # 修改   通过字典名['键名'] = 新值
        list_student[num]['name'] = input('请输入姓名')
        list_student[num]['age'] = input('请输入年龄')
        list_student[num]['sex'] = input('请输入性别')
        print('修改成功')
        print(list_student)
    else:
        print('输入有误，请重新输入')
def find_student():  # 查找学生
    find_name = input('请输入要查找学生的姓名：')
    # 判断学生是否存在
    for i in list_student:
        if i['name'] == find_name:
            print('姓名',i['name'],'性别',i['sex'],'年龄',i['age'])
            return   # 查找成功 结束循环
    else:
        print('输入有误')
def show_student():
    for i,x in enumerate(list_student):   # 查看所有信息的序号和内容
        print('序号',i,'姓名',x['name'],'年龄',x['age'],'性别',x['sex'])   # x 是字典

def exit_student():
    meg = input('走了？yes or  no')
    if meg == 'yes':
        print('系统结束')
        exit(0)

def main():
    while 1:
        menu()
        num = int(input('请输入要进行的操作'))
        if  num == 1:
            add_student()  # 增加学生
        elif num == 2:
            del_student()  # 删除学生 
        elif num == 3:
            modify_student()  # 修改学生
        elif num == 4:
            find_student()  # 查找学生
        elif num == 5:
            show_student()  # 显示所有学生信息
        elif num == 6:
            exit_student()  # 退出系统
        else:
            print('输入有误，请重新输入')
main()

11.3 列表推导式

11.3.1 列表推导式格式讲解 ★★★★

列表推导式(list comprehension)是指循环创建列表.

for循环有非常广的应用场景,也可以用来创建一个列表,而列表推导式就相当于for循环创建列表的简化版.

# for 循环
list_a = list()
for a in range(5):
    list_a.append(a)
print(list_a)

# 列表推导式
list_b = [b for b in range(5)]
print(list_b)

上面分别是用for循环和列表推导式创建列表的代码,list_a和list_b的结果是一样的,都是[0, 1, 2, 3, 4].

11.3.2 列表推导式应用案例之1–100整数和 ★★★★

代码如下：

list_3 = [i for i in range(0,101)]

print('1--100整数和是:%d' % sum(list_3))

效果如下：

1--100整数和是:5050

11.3.3 列表推导式应用案例之1–100奇数和 ★★★★

代码如下：

list_4 = [i for i in range(1,101,2)]
print('1--100奇数和是:%d' % sum(list_4))

效果如下：

1--100奇数和是:2500

11.3.4 复杂列表推导式应用案例讲解 ★★★★

# in后面跟其他可迭代对象,如字符串
list_c = [7 * c for c in "python"]
print(list_c)
 
# 带if条件语句的列表推导式
list_d = [d for d in range(6) if d % 2 != 0]
print(list_d)
 
# 多个for循环
list_e = [(e, f * f) for e in range(3) for f in range(5, 15, 5)]
print(list_e)
 
# 嵌套列表推导式,多个并列条件
list_g = [[x for x in range(g - 3, g)] for g in range(22) if g % 3 == 0 and g != 0]
print(list_g)

---

五、本单元知识总结

1.掌握函数缺省参数基础应用
2.掌握函数不定长参数基础应用
3.掌握简单列表推导式的构建
4.掌握函数实现线上学生管理系统

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第十一单元，选择题，填空题，简答题(1,2,3)、技能题（1、2、3、4、5）
2.完成教材第六章节，课后习题(实例03)

（Ⅲ）预习作业

1.预习第十二单元 文件的相关操作
2.预习教材，第十章 文件及目录操作

预习附录：

1.参见教材：第十章<238,264>页

第十二单元 文件的相关操作

一、昨日知识点回顾

1. 函数缺省参数是什么？
2. 函数不定长参数是什么？
3. 列表推导式怎么构建？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学python(全彩版)》，第10章 文件及目录操作，页码区间<237,264>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.文件的基本操作
2.文件的读写操作
3.文件与文件夹的操作

（Ⅱ）能力目标

1.掌握文件的基本操作
2.掌握文件的读写操作
3.掌握文件与文件夹的操作

---

四、本单元知识详讲

12.1 文件的操作介绍

想一想：

如果想用word编写一份简历，应该有哪些流程呢？

1. 打开word软件，新建一个word文件
2. 写入个人简历信息
3. 保存文件
4. 关闭word软件

同样，在操作文件的整体过程与使用word编写一份简历的过程是很相似的

1. 打开文件或者新建立一个文件
2. 读/写数据
3. 关闭文件

12.1.1 文件的打开操作 ★★★★

在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件

open(文件名，访问模式)

demo:

f = open('test.txt', 'w')  # f被称为文件操作符

12.1.2 访问模式 ★★★★

在文件打开时，需要指定访问模式：

访问模式	说明
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

12.1.3 文件的关闭 ★★★★

close( )

demo:

f = open('test.txt', 'w')  # 新建一个文件，文件名为:test.txt
f.close()  # 关闭这个文件

12.2 文件的读写

12.2.1 文件写数据之write() ★★★★★

使用write()可以完成向文件写入数据

demo:

新建一个文件 file_write_test.py,向其中写入如下代码:

f = open('test.txt', 'w')
f.write('hello world, i am here!')
f.close()

运行之后会在file_write_test.py文件所在的路径中创建一个文件test.txt,其中数据如下:

hello world, i am here!

**注意：**如果文件不存在，那么创建；如果存在，那么就先清空，然后写入数据

12.2.2 文件读数据之read() ★★★★★

使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据

demo:

新建一个文件file_read_test.py，向其中写入如下代码:

f = open('test.txt', 'r')
content = f.read(5)  # 最多读取5个数据
print(content)
print("-"*30)  # 分割线，用来测试

content = f.read()  # 从上次读取的位置继续读取剩下的所有的数据
print(content)
f.close()  # 关闭文件，这个可以是个好习惯哦

运行现象：

hello
------------------------------ 
world, i am here!

**注意：**如果用open打开文件时，如果使用的"r"，那么可以省略，即只写 open('test.txt')

12.2.3 文件读数据之readlines() ★★★★★

就像read没有参数时一样，readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素

demo:

# coding=utf-8
# 打开文件
f = open('test.txt', 'r')
# 读取文件内容
content = f.readlines()
print(type(content))

i = 1
for temp in content:    
    print("%d:%s" % (i, temp))    
    i += 1

f.close()

运行现象：

1:hello world, i am here! 

12.2.4 文件读数据之readline() ★★★★★

readline可以按照行的方式，把整个文件中的内容每次读取一行内容，并且返回的是一个字符串

demo:

# coding=utf-8

f = open('test.txt', 'r')

content = f.readline()
print("1:%s" % content)

content = f.readline()
print("2:%s" % content)

f.close()

运行现象：

1:hello world, i am here!
2:

12.3 文件与文件夹的相关操作

有些时候，需要对文件进行重命名、删除等一些操作，python的os模块中都有这些功能

12.3.1 常用的文件操作方法 ★★★★

1. 文件重命名

os模块中的rename()可以完成对文件的重命名操作

rename(需要修改的文件名, 新的文件名)

import os
os.rename("毕业论文.txt", "毕业论文-最终版.txt")

2. 删除文件

os模块中的remove()可以完成对文件的删除操作

remove(待删除的文件名)

import os
os.remove("毕业论文.txt")

12.3.2 常用的文件夹操作方法 ★★★★

1. 创建文件夹

import os
os.mkdir("张三")

2. 获取当前目录

import os
os.getcwd()

3. 改变默认目录

import os
os.chdir("../")

4. 获取目录列表

import os
os.listdir("./")

5. 删除文件夹

import os
os.rmdir("张三")

12.4 文件拷贝综合案例实战

**任务描述：**输入文件的名字，然后程序自动完成对文件的备份操作

12.4.1 文件拷贝逻辑讲解 ★★★★

根据需要实现的功能，将整个案例拆解为以下几步:

• 获取需要拷贝的文件名
• 打开原文件，获取文件内容
• 打开新文件，将读取的原有内容写入即可
• 关闭所有文件即可

12.4.2 文件拷贝综合案例实战 ★★★★

# 提示输入文件
oldFileName = input("请输入要拷贝的文件名字:")

# 以读的方式打开文件
oldFile = open(oldFileName,'rb')

# 提取文件的后缀
fileFlagNum = oldFileName.rfind('.')
if fileFlagNum > 0:    
    fileFlag = oldFileName[fileFlagNum:]

# 组织新的文件名字
newFileName = oldFileName[:fileFlagNum] + '[复件]' + fileFlag

# 创建新文件
newFile = open(newFileName, 'wb')

# 把旧文件中的数据，一行一行的进行复制到新文件中
for lineContent in oldFile.readlines():    
    newFile.write(lineContent)

# 关闭文件
oldFile.close()
newFile.close()

---

五、本单元知识总结

1.掌握文件的基本操作
2.掌握文件的读写操作
3.掌握文件与文件夹的操作

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第十二单元，选择题，填空题，简答题(1,2,3,4)、技能题（1,2,3,4）
2.完成教材第十章节章节，课后习题(1,2,3,4,5,6)

（Ⅲ）预习作业

1.预习第十三单元，面向对象知识点
2.预习教材，面向对象知识点

预习附录：

1.参见教材：第七章<182,192>页

第十三单元 面向对象基本概念与实现

一、昨日知识点回顾

1. 文件的访问模式有哪些？
2. 读取文件方法有哪些？
3. 常用的文件夹操作方法有哪些？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学python》，第7章 面向对象设计程序，页码区间<181,202>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.面向对象介绍
2.类和对象的区别
3.定义类
4.创建对象
5.添加和获取对象的属性

（Ⅱ）能力目标

1.掌握类的定义
2.掌握对象的创建
3.掌握方法内通过self获取对象属性

---

四、本单元知识详讲

13.1 面向对象简介

13.1.1 面向对象介绍 ★★★★

1.菜鸟买电脑的故事

两种方式如下:

第一种方式:

​ 1)在网上查找资料

​ 2)根据自己预算和需求定电脑的型号 MacBook 15 顶配 1W8

​ 3)去市场找到苹果店各种店无法甄别真假 随便找了一家

​ 4)找到业务员,业务员推荐了另外一款 配置更高价格便宜,也是苹果系统的 1W

​ 5)砍价30分钟 付款9999

​ 6)成交

​ 回去之后发现各种问题

第二种方式:

​ 1)找一个靠谱的电脑高手

​ 2)给钱交易

菜鸟给我的启示

面向对象和面向过程都是解决问题的一种思路而已

• 买电脑的第一种方式:
  • 强调的是步骤、过程、每一步都是自己亲自去实现的
  • 这种解决问题的思路我们就叫做面向过程
• 买电脑的第二种方式:
  • 强调的是电脑高手, 电脑高手是处理这件事的主角,对我们而言,我们并不必亲自实现整个步骤只需要调用电脑高手就可以解决问题
  • 这种解决问题的思路就 是面向对象
• 用面向对象的思维解决问题的重点
  • 当遇到一个需求的时候不用自己去实现，如果自己一步步实现那就是面向过程
  • 应该找一个专门做这个事的人来做
  • 面向对象是基于面向过程的

2.解决吃啤酒鸭的问题

两种方式如下:

​ 第一种方式（面向过程）:

​ 1)养鸭子

​ 2)鸭子长成

​ 3)杀

​ 4)作料

​ 5)烹饪

​ 6)吃

​ 7)卒

第二种方式（面向对象）:

​ 1)找个卖啤酒鸭的人

​ 2)给钱 交易

​ 3)吃

​ 4)胖6斤

面向对象相关概念:

面向对象(object-oriented ;简称: OO) 至今还没有统一的概念 我这里把它定义为: 按人们 认识客观世界的系统思维方式,采用基于对象(实体) 的概念建立模型,模拟客观世界分析、设 计、实现软件的办法。

面向对象编程(Object Oriented Programming-OOP) 是一种解决软件复用的设计和编程方法。 这种方法把软件系统中相近相似的操作逻辑和操作 应用数据、状态,以类的型式描述出来,以对象实例的形式在软件系统中复用,以达到提高软件开发效率的作用。

13.1.2 类的介绍 ★★★★

面向对象编程的2个非常重要的概念：类和对象

对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另外一个新的概念——类

类就相当于制造飞机时的图纸，用它来进行创建的飞机就相当于对象

人以类聚 物以群分。具有相似内部状态和运动规律的实体的集合(或统称为抽象)。 具有相同属性和行为事物的统称
类是抽象的,在使用的时候通常会找到这个类的一个具体的存在,使用这个具体的存在。一个类可以找到多个对象

13.1.3 对象的介绍 ★★★★★

某一个具体事物的存在 ,在现实世界中可以是看得见摸得着的。可以是直接使用的。

13.1.4 类和对象区别 ★★★★★

总结：类就是创建对象的模板

1.月饼与做月饼的模具
月饼的模具 --- 类
月饼 --- 对象

2.楼房的图纸与楼房
楼房的图纸 --- 类
楼房 --- 对象

13.1.5 类的构成 ★★★★★

类(Class) 由3个部分构成

• 类的名称:类名
• 类的属性:一组数据
• 类的方法:类提供的可以进行一定操作的方法 (行为)

举例：

1）人类设计,只关心3样东西:

• 事物名称(类名):人(Person)
• 属性:身高(height)、年龄(age)
• 方法(行为/功能):跑(run)、打架(fight)

2）狗类的设计

• 类名:狗(Dog)
• 属性:品种 、毛色、性别、名字、 腿儿的数量
• 方法(行为/功能):叫 、跑、咬人、吃、摇尾巴

13.1.6 类的抽象 ★★★★★

如何把日常生活中的事物抽象成程序中的类?

拥有相同(或者类似)属性和行为的对象都可以抽像出一个类

方法:一般名词都是类(名词提炼法)

<1> 坦克发射3颗炮弹轰掉了2架飞机

• 坦克–》可以抽象成 类
• 炮弹–》可以抽象成类
• 飞机-》可以抽象成类

<2> 小明在公车上牵着一条叼着热狗的狗

• 小明–》 人类
• 公车–》 交通工具类
• 热狗–》 食物类
• 狗–》 狗类

13.2 面向对象实战

13.2.1 定义类 ★★★★★

定义一个类，格式如下：

class 类名:
    方法列表

定义一个英雄类

# class Hero:  # 经典类（旧式类）定义形式
# class Hero():
class Hero(object):  # 新式类定义形式
    def info(self):
        print("英雄各有见，何必问出处。")

说明：

• 定义类时有2种形式：新式类和经典类，上面代码如果在python3中Hero全为新式类; 前两行注释部分在python2中则为经典类, 最后一中再python2中还是新式类；
• object 是Python3里所有类的最顶级父类；
• 类名的命名规则建议按照"大驼峰命名法"；
• info 是一个实例方法，第一个参数一般是self，表示实例对象本身，当然了可以将self换为其它的名字，其作用是一个变量, 这个变量指向了实例对象

13.2.2 创建对象 ★★★★★

python中，可以根据已经定义的类去创建出一个或多个对象。

创建对象的格式为:

对象名1 = 类名()
对象名2 = 类名()
对象名3 = 类名()

创建对象

class Hero(object):  # 新式类定义形式
    """info 是一个实例方法，类对象可以调用实例方法，实例方法的第一个参数一定是self"""
    def info(self):
        """当对象调用实例方法时，Python会自动将对象本身的引用做为参数，传递到实例方法的第一个参数self里"""
        print(self)         
        print("self各不同，对象是出处。")
# Hero这个类 实例化了一个对象  taidamier(泰达米尔)
taidamier = Hero()
# 对象调用实例方法info()，执行info()里的代码
# . 表示选择属性或者方法
taidamier.info()
print(taidamier)  # 打印对象，则默认打印对象在内存的地址，结果等同于info里的print(self)
print(id(taidamier))  # id(taidamier) 则是内存地址的十进制形式表示

效果如下

<__main__.Hero object at 0x00000000021342B0>
self各不同，对象是出处。
<__main__.Hero object at 0x00000000021342B0>
34816688

说明：

• 当创建一个对象时，就是用一个模子，来制造一个实物

问题：

对象既然有实例方法，是否也可以有自己的属性?

13.2.3 添加和获取对象属性 ★★★★★

class Hero(object):
    """定义了一个英雄类，可以移动和攻击"""
    def move(self):
        """实例方法"""
        print("正在前往事发地点...")    
    
    def attack(self):
        """实例方法"""
        print("发出了一招强力的普通攻击...")
# 实例化了一个英雄对象 泰达米尔
taidamier = Hero()
# 给对象添加属性，以及对应的属性值
taidamier.name = "泰达米尔"  # 姓名
taidamier.hp = 2600  # 生命值
taidamier.atk = 450  # 攻击力
taidamier.armor = 200  # 护甲值
# 通过.成员选择运算符，获取对象的属性值
print("英雄 %s 的生命值 :%d" % (taidamier.name, taidamier.hp))
print("英雄 %s 的攻击力 :%d" % (taidamier.name, taidamier.atk))
print("英雄 %s 的护甲值 :%d" % (taidamier.name, taidamier.armor))
# 通过.成员选择运算符，获取对象的实例方法
taidamier.move()
taidamier.attack()

效果如下

英雄 泰达米尔 的生命值 :2600
英雄 泰达米尔 的攻击力 :450
英雄 泰达米尔 的护甲值 :200
正在前往事发地点...
发出了一招强力的普通攻击...

问题：

对象创建并添加属性后，能否在类的实例方法里获取这些属性呢？如果可以的话，应该通过什么方式？

13.2.4 方法内通过self获取对象属性 ★★★★★

class Hero(object):
    """定义了一个英雄类，可以移动和攻击"""
    def move(self):
        """实例方法"""
        print("正在前往事发地点...")    
    def attack(self):
        """实例方法"""
        print("发出了一招强力的普通攻击...")            
    def info(self):
        """在类的实例方法中，通过self获取该对象的属性"""
        print("英雄 %s 的生命值 :%d" % (self.name, self.hp))            
        print("英雄 %s 的攻击力 :%d" % (self.name, self.atk))        
        print("英雄 %s 的护甲值 :%d" % (self.name, self.armor))
# 实例化了一个英雄对象 泰达米尔
taidamier = Hero()
# 给对象添加属性，以及对应的属性值
taidamier.name = "泰达米尔"  # 姓名
taidamier.hp = 2600  # 生命值
taidamier.atk = 450  # 攻击力
taidamier.armor = 200  # 护甲值
# 通过.成员选择运算符，获取对象的实例方法
taidamier.info()  # 只需要调用实例方法info()，即可获取英雄的属性
taidamier.move()
taidamier.attack()

效果如下

英雄 泰达米尔 的生命值 :2600
英雄 泰达米尔 的攻击力 :450
英雄 泰达米尔 的护甲值 :200
正在前往事发地点...
发出了一招强力的普通攻击...

---

五、本单元知识总结

1. 定义类
2. 创建对象
3. 添加和获取对象属性
4. 方法内通过self获取对象属性

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第十三单元，选择题，填空题，简答题(1,2,4,5)、技能题（1、2、3）

（Ⅲ）预习作业

1.预习第十四单元，面向对象-常用魔法方法及综合扩展案例

预习附录：

1.参见教材：第七章<199,200>页

第十四单元 面向对象-常用魔法方法及综合扩展案例

一、昨日知识点回顾

1. 什么是面向对象？
2. 什么是类？
3. 对象如何创建？
4. 如何获取对象的属性？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学Python全彩版》，第七章 面向对象程序设计，页码区间<186,192>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1. __init__方法
2. __str__方法
3. __del__方法
4. __new__方法
5. 烤地瓜案例

（Ⅱ）能力目标

1. 掌握魔法方法特征
2. 掌握__init__()魔法方法作用及使用
3. 掌握__str__()魔法方法作用及使用
4. 掌握__del__()魔法方法作用及使用
5. 掌握__new__()魔法方法作用及使用

---

四、本单元知识详讲

14.1 常用的魔法方法

14.1.1 魔法方法 : __init__()方法★★★★★

​ Python 的类里提供的，两个下划线开始，两个下划线结束的方法，就是魔法方法, __init__()就是一个魔法方法，通常用来做属性初始化 或 赋值 操作。
​ 如果类面没有写__init__方法，Python会自动创建，但是不执行任何操作， 如果为了能够完成自己想要的功能，可以自己定义__init__方法，所以一个类里无论自己是否编写__init__方法 一定有__init__方法。
示例：

class Hero(object):
    """定义了一个英雄类，可以移动和攻击"""
    def __init__(self):
        """ 方法，用来做变量初始化 或 赋值 操作，在类实例化对象的时候，会被自动调用"""
        self.name = "泰达米尔" # 姓名
        self.hp = 2600 # 生命值
        self.atk = 450  # 攻击力
        self.armor = 200  # 护甲值

    def move(self):
        """实例方法"""
        print("正在前往事发地点...")    
        
    def attack(self):
        """实例方法"""
        print("发出了一招强力的普通攻击...")


# 实例化了一个英雄对象，并自动调用__init__()方法
taidamier = Hero()

# 通过.成员选择运算符，获取对象的实例方法
taidamier.move()
taidamier.attack()

效果如下：

正在前往事发地点...
发出了一招强力的普通攻击..

说明：

__init__() 方法，在创建一个对象时默认被调用，不需要手动调用

​ __ init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去

14.1.2 魔法方法 : __str__()方法★★★★★

这个方法是一个魔法方法 (Magic Method) ，用来显示信息该方法需要 return 一个数据，并且只有self一个参数，当在类的外部 print(对象) 则打印这个数据。

基本语法如下：

class Hero(object):
    """定义了一个英雄类，可以移动和攻击"""

    def __init__(self, name, skill, hp, atk, armor):
        """ __init__() 方法，用来做变量初始化 或 赋值 操作"""
        # 英雄名
        self.name = name  # 实例变量
        # 技能
        self.skill = skill        # 生命值：
        self.hp = hp   # 实例变量
        # 攻击力
        self.atk = atk        # 护甲值
        self.armor = armor    
       
    def move(self):
        """实例方法"""
        print("%s 正在前往事发地点..." % self.name)    
        
    def attack(self):
        """实例方法"""
        print("发出了一招强力的%s..." % self.skill)    

    def __str__(self):
        """这个方法是一个魔法方法 (Magic Method) ，用来显示信息该方法需要 return 一个数据，并且只有self一个参数，当在类的外部 print(对象) 则打印这个数据"""
        return "英雄 <%s> 数据： 生命值 %d, 攻击力 %d, 护甲值 %d" % (self.name, self.hp, self.atk, self.armor)
        
taidamier = Hero("泰达米尔", "旋风斩", 2600, 450, 200)
gailun = Hero("盖伦", "大宝剑", 4200, 260, 400)

# 如果没有__str__ 则默认打印 对象在内存的地址。
# 当类的实例化对象 拥有 __str__ 方法后，那么打印对象则打印 __str__ 的返回值。
print(taidamier)
print(gailun)

效果如下：

英雄 <泰达米尔> 数据： 生命值 2600, 攻击力 450, 护甲值 200
英雄 <盖伦> 数据： 生命值 4200, 攻击力 260, 护甲值 400
定义了一个英雄类，可以移动和攻击

说明：

• 在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法
• 当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了__str__(self)方法，那么就会打印从在这个方法中 return 的数据
• __str__方法通常返回一个字符串，作为这个对象的描述信息

14.1.3 魔法方法 : __del__()方法★★★★★

创建对象后，python解释器默认调用__init__()方法

当删除对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法

class Hero(object):

    # 初始化方法
    # 创建完对象后会自动被调用
    def __init__(self, name):
        print('__init__方法被调用')        
        self.name = name    # 当对象被删除时，会自动被调用
    def __del__(self):
        print("__del__方法被调用")        
        print("%s 被 GM 干掉了..." % self.name)


# 创建对象
taidamier = Hero("泰达米尔")

# 删除对象
print("%d 被删除1次" % id(taidamier))
del(taidamier)

print("--" * 10)

gailun = Hero("盖伦")
gailun1 = gailun
gailun2 = gailun

print("%d 被删除1次" % id(gailun))
del(gailun)

print("%d 被删除1次" % id(gailun1))
del(gailun1)

print("%d 被删除1次" % id(gailun2))
del(gailun2)

效果如下:

__init__方法被调用
1676689199344 被删除1次
__del__方法被调用
泰达米尔 被 GM 干掉了...
--------------------
__init__方法被调用
1676689199736 被删除1次
1676689199736 被删除1次
1676689199736 被删除1次
__del__方法被调用
盖伦 被 GM 干掉了...

14.1.4 魔法方法 : __new__()方法★★★★★

__new__和__init__的作用

class A(object):
    def __init__(self):
        print("这是 init 方法")

    def __new__(cls):
        print("这是 new 方法")
        return object.__new__(cls)

A()

效果如下

这是 new 方法
这是 init 方法

**总结: **

• __new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
• __new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例
• __init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值
• 我们可以将类比作制造商，__new__方法就是前期的原材料购买环节，__init__方法就是在有原材料的基础上，加工，初始化商品环节

14.2 扩展案例

14.2.1 扩展案例(烤地瓜) ★★★★

为了更好的理解面向对象编程，下面以“烤地瓜”为案例，进行分析

1. 分析“烤地瓜”的属性和方法

示例属性如下:

• cookedLevel : 这是数字；0~3表示还是生的，超过3表示半生不熟，超过5表示已经烤好了，超过8表示已经烤成木炭了！我们的地瓜开始时是生的
• cookedString : 这是字符串；描述地瓜的生熟程度
• condiments : 这是地瓜的配料列表，比如番茄酱、芥末酱等

示例方法如下:

• cook() : 把地瓜烤一段时间
• addCondiments() : 给地瓜添加配料
• __init__() : 设置默认的属性
• __str__() : 让print的结果看起来更好一些

2. 定义类，并且定义__init__()方法

# 定义`地瓜`类
class SweetPotato:
    """这是烤地瓜的类"""

    # 定义初始化方法
    def __init__(self):
        self.cookedLevel = 0
        self.cookedString = "生的"
        self.condiments = []

3. 添加"烤地瓜"方法

 # 烤地瓜方法
    def cook(self, time):
        self.cookedLevel += time
        if self.cookedLevel > 8:
            self.cookedString = "烤成灰了"
        elif self.cookedLevel > 5:
            self.cookedString = "烤好了"    
        elif self.cookedLevel > 3:
            self.cookedString = "半生不熟"
        else:
            self.cookedString = "生的"

4. 基本的功能已经有了一部分，赶紧测试一下

把上面2块代码合并为一个程序后，在代码的下面添加以下代码进行测试

mySweetPotato = SweetPotato()
print(mySweetPotato.cookedLevel)
print(mySweetPotato.cookedString)
print(mySweetPotato.condiments)

完整的代码为:

class SweetPotato:
    """这是烤地瓜的类"""

    # 定义初始化方法
    def __init__(self):
        self.cookedLevel = 0
        self.cookedString = "生的"
        self.condiments = []

    # 烤地瓜方法
    def cook(self, time):
        self.cookedLevel += time
        if self.cookedLevel > 8:
            self.cookedString = "烤成灰了"
        elif self.cookedLevel > 5:
            self.cookedString = "烤好了"    
        elif self.cookedLevel > 3:
            self.cookedString = "半生不熟"
        else:
            self.cookedString = "生的"

# 用来进行测试
mySweetPotato = SweetPotato()
print(mySweetPotato.cookedLevel)
print(mySweetPotato.cookedString)
print(mySweetPotato.condiments)

效果如下

0
生的
[]

5. 测试cook方法是否好用

在上面的代码最后面添加如下代码:

print("------接下来要进行烤地瓜了-----")
mySweetPotato.cook(4) #烤4分钟
print(mySweetPotato.cookedLevel)
print(mySweetPotato.cookedString)

效果如下

------接下来要进行烤地瓜了-----
4
半生不熟

6. 定义addCondiments()方法和__str__()方法

  def __str__(self):
        msg = self.cookedString + " 地瓜"
        if len(self.condiments) > 0:
            msg = msg + "("
            for temp in self.condiments:
                msg = msg + temp + ", "
            msg = msg.strip(", ")

            msg = msg + ")"
        return msg

    def addCondiments(self, condiments):
        self.condiments.append(condiments)

7. 再次测试

完整的代码如下:

class SweetPotato:
    """这是烤地瓜的类"""

    # 定义初始化方法
    def __init__(self):
        self.cookedLevel = 0
        self.cookedString = "生的"
        self.condiments = []

    # 定制print时的显示内容
    def __str__(self):
        msg = self.cookedString + " 地瓜"
        if len(self.condiments) > 0:
            msg = msg + "("

            for temp in self.condiments:
                msg = msg + temp + ", "
            msg = msg.strip(", ")

            msg = msg + ")"
        return msg

    # 烤地瓜方法
    def cook(self, time):
        self.cookedLevel += time
        if self.cookedLevel > 8:
            self.cookedString = "烤成灰了"
        elif self.cookedLevel > 5:
            self.cookedString = "烤好了"    
        elif self.cookedLevel > 3:
            self.cookedString = "半生不熟"
        else:
            self.cookedString = "生的"

    # 添加配料
    def addCondiments(self, condiments):
        self.condiments.append(condiments)

# 用来进行测试
mySweetPotato = SweetPotato()
print("------有了一个地瓜，还没有烤-----")
print(mySweetPotato.cookedLevel)
print(mySweetPotato.cookedString)
print(mySweetPotato.condiments)
print("------接下来要进行烤地瓜了-----")
print("------地瓜经烤了4分钟-----")
mySweetPotato.cook(4) #烤4分钟
print(mySweetPotato)
print("------地瓜又经烤了3分钟-----")
mySweetPotato.cook(3) #又烤了3分钟
print(mySweetPotato)
print("------接下来要添加配料-番茄酱------")
mySweetPotato.addCondiments("番茄酱")
print(mySweetPotato)
print("------地瓜又经烤了5分钟-----")
mySweetPotato.cook(5) #又烤了5分钟
print(mySweetPotato)
print("------接下来要添加配料-芥末酱------")
mySweetPotato.addCondiments("芥末酱")
print(mySweetPotato)

效果如下：

------有了一个地瓜，还没有烤-----
0
生的
[]
------接下来要进行烤地瓜了-----
------地瓜经烤了4分钟-----
半生不熟 地瓜
------地瓜又经烤了3分钟-----
烤好了 地瓜
------接下来要添加配料-番茄酱------
烤好了 地瓜(番茄酱)
------地瓜又经烤了5分钟-----
烤成灰了 地瓜(番茄酱)
------接下来要添加配料-芥末酱------
烤成灰了 地瓜(番茄酱, 芥末酱)

---

五、本单元知识总结

1.掌握魔法方法特征
2.掌握__init__()魔法方法作用及使用
3.掌握__str__()魔法方法作用及使用
4.掌握__del__()魔法方法作用及使用
5.掌握__new__()魔法方法作用及使用

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第十四单元，选择题，填空题，简答题(1,2,3)、技能题（1、2、3、4）
2.完成教材第七章节，课后习题(实例01、实例02)

（Ⅲ）预习作业

1.预习第十五单元 面向对象-继承
2.预习教材，第七章 面向对象程序设计

预习附录：

1.参见教材：第十章<196,200>页

第十五单元 面向对象-继承

一、昨日知识点回顾

1.什么是魔法方法？
2.常用的魔法方法有哪些？
3.常用的魔法方法的作用分别是什么？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学python(全彩版)》，第7章 面向对象程序设计，页码区间<196,200>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.继承的概念
2.单继承和多继承
3.子类重写/调用父类同名的属性和方法
4.多层继承
5.super()调用父类方法

（Ⅱ）能力目标

1.掌握继承的概念
2.掌握单继承和多继承
3.掌握子类重写/调用父类同名的属性和方法
4.掌握多层继承
5.掌握通过super()调用父类方法

---

四、本单元知识详讲

15.1 继承

15.1.1 继承的概念 ★★★★★

1. 现实中的继承

在现实生活中，继承一般指的是子女继承父辈的财产，如下图

搞不好,结果如下…

2. 程序中的继承

• 在程序中，继承描述的是多个类之间的所属关系。
• 如果一个类A里面的属性和方法可以复用，则可以通过继承的方式，传递到类B里。
• 那么类A就是基类，也叫做父类；类B就是派生类，也叫做子类。

# 父类
class A(object):
    def __init__(self):
        self.num = 10

    def print_num(self):
        print(self.num + 10)


# 子类
class B(A):
    pass


b = B()
print(b.num)
b.print_num()

执行结果：

10
20

15.1.2 单继承 ★★★★★

故事情节：

煎饼果子老师傅在煎饼果子界摸爬滚打几十年，拥有一身精湛的煎饼果子技术，并总结了一套"古法煎饼果子配方"。

可是老师傅年迈已久，在嗝屁之前希望把自己的配方传承下去，于是老师傅把配方传给他的徒弟大猫…

# 定义一个Master类
class Master(object):
    def __init__(self):
        # 属性
        self.kongfu = "古法煎饼果子配方"  # 实例方法

    def make_cake(self):
        print("按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


# 定义Prentice类，继承了 Master，则Prentice是子类，Master是父类。
class Prentice(Master):
    # 子类可以继承父类所有的属性和方法，哪怕子类没有自己的属性和方法，也可以使用父类的属性和方法。
    pass


# laoli = Master()
# print(laoli.kongfu)
# laoli.make_cake()

damao = Prentice()  # 创建子类实例对象
print(damao.kongfu)  # 子类对象可以直接使用父类的属性
damao.make_cake()  # 子类对象可以直接使用父类的方法

执行结果：

古法煎饼果子配方
按照 <古法煎饼果子配方> 制作了一份煎饼果子...

说明：

• 虽然子类没有定义__init__方法初始化属性，也没有定义实例方法，但是父类有。所以只要创建子类的对象，就默认执行了那个继承过来的__init__方法

总结：

• 子类在继承的时候，在定义类时，小括号()中为父类的名字
• 父类的属性、方法，会被继承给子类

剧情发展：

大猫掌握了师傅的配方，可以制作古法煎饼果子。但是大猫是个爱学习的好孩子，他希望学到更多的煎饼果子的做法，于是通过百度搜索，找到了一家煎饼果子培训学校。（多继承）

15.1.3 多继承 ★★★★★

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"  # 实例变量，属性

    def make_cake(self):  # 实例方法，方法
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)

    def dayandai(self):
        print("师傅的大烟袋..")


class School(object):
    def __init__(self):
        self.kongfu = "现代煎饼果子配方"

    def make_cake(self):
        print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)

    def xiaoyandai(self):
        print("学校的小烟袋..")


# class Prentice(School, Master):  # 多继承，继承了多个父类（School在前）
#     pass

# damao = Prentice()
# print(damao.kongfu)
# damao.make_cake()
# damao.dayandai()
# damao.xiaoyandai()


class Prentice(Master, School):  # 多继承，继承了多个父类（Master在前）
    pass


damao = Prentice()

print(damao.kongfu)  # 执行Master的属性
damao.make_cake()  # 执行Master的实例方法

# 子类的魔法属性__mro__决定了属性和方法的查找顺序
print(Prentice.__mro__)

damao.dayandai()  # 不重名不受影响
damao.xiaoyandai()

执行结果：

古法煎饼果子配方
[古法] 按照 <古法煎饼果子配方> 制作了一份煎饼果子...
(<class '__main__.Prentice'>, <class '__main__.Master'>, <class '__main__.School'>, <class 'object'>)
师傅的大烟袋..
学校的小烟袋..

说明：

• 多继承可以继承多个父类，也继承了所有父类的属性和方法
• 注意：如果多个父类中有同名的 属性和方法，则默认使用第一个父类的属性和方法（根据类的魔法属性mro的顺序来查找）
• 多个父类中，不重名的属性和方法，不会有任何影响。

剧情发展：

大猫掌握了 师傅的配方 和 学校的配方，通过研究，大猫在两个配方的基础上，创建了一种全新的煎饼果子配方，称之为 “猫氏煎饼果子配方”。（子类重写父类同名属性和方法）

15.2 继承应用实战

15.2.1 子类重写父类同名的属性和方法 ★★★★

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"

    def make_cake(self):
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class School(object):
    def __init__(self):
        self.kongfu = "现代煎饼果子配方"

    def make_cake(self):
        print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class Prentice(School, Master):  # 多继承，继承了多个父类
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"

    def make_cake(self):
        print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


# 如果子类和父类的方法名和属性名相同，则默认使用子类的
# 叫 子类重写父类的同名方法和属性
damao = Prentice()
print(damao.kongfu)  # 子类和父类有同名属性，则默认使用子类的
damao.make_cake()  # 子类和父类有同名方法，则默认使用子类的

# 子类的魔法属性__mro__决定了属性和方法的查找顺序
print(Prentice.__mro__)

执行结果:

猫氏煎饼果子配方
[猫氏] 按照 <猫氏煎饼果子配方> 制作了一份煎饼果子...
(<class '__main__.Prentice'>, <class '__main__.School'>, <class '__main__.Master'>, <class 'object'>)

剧情发展：

大猫的新配方大受欢迎，但是有些顾客希望也能吃到古法配方和现代配方的煎饼果子…（子类调用父类的同名属性和方法）

15.2.2 子类调用父类同名的属性和方法 ★★★★★

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"  # 实例变量，属性

    def make_cake(self):  # 实例方法，方法
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class School(object):
    def __init__(self):
        self.kongfu = "现代煎饼果子配方"

    def make_cake(self):
        print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class Prentice(School, Master):  # 多继承，继承了多个父类
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"

    def make_cake(self):
        print("执行子类的__init__方法前，self.kongfu属性：%s" % self.kongfu)
        self.__init__()  # 执行本类的__init__方法，做属性初始化 self.kongfu = "猫氏...."
        print("执行子类的__init__方法前，self.kongfu属性：%s" % self.kongfu)
        print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)  # 调用父类方法格式：父类类名.父类方法(self)

    def make_old_cake(self):
        # 不推荐这样访问父类的实例属性，相当于创建了一个新的父类对象
        # print("直接调用Master类的kongfu属性：%s" % Master().kongfu)

        # 可以通过执行Master类的__init__方法，来修改self的属性值
        print("执行Master类的__init__方法前，self.kongfu属性：%s" % self.kongfu)
        Master.__init__(self)  # 调用了父类Master的__init__方法 self.kongfu = "古法...."

        print("执行Master类的__init__方法后，self.kongfu属性：%s" % self.kongfu)
        Master.make_cake(self)  # 调用父类Master的实例方法

    def make_new_cake(self):
        # 不推荐这样访问类的实例属性，相当于创建了一个新的父类对象
        # print("直接调用School类的kongfu属性：%s" % School().kongfu)

        # 可以通过执行School类的__init__方法，来修改self的属性值
        print("执行School类的__init__方法前，self.kongfu属性：%s" % self.kongfu)
        School.__init__(self)  # 调用了父类School的__init__方法 self.kongfu = "现代...."

        print("执行School类的__init__方法后，self.kongfu属性：%s" % self.kongfu)
        School.make_cake(self)  # 调用父类School的实例方法


# 实例化对象，自动执行子类的__init__方法
damao = Prentice()
damao.make_cake()  # 调用子类的方法（默认重写了父类的同名方法）

print("--" * 10)
damao.make_old_cake()  # 进入实例方法去调用父类Master的方法

print("--" * 10)
damao.make_new_cake()  # 进入实例方法去调用父类School的方法

print("--" * 10)
damao.make_cake()  # 调用本类的实例方法

执行结果：

执行子类的__init__方法前，self.kongfu属性：猫氏煎饼果子配方
执行子类的__init__方法前，self.kongfu属性：猫氏煎饼果子配方
[猫氏] 按照 <猫氏煎饼果子配方> 制作了一份煎饼果子...
--------------------
执行Master类的__init__方法前，self.kongfu属性：猫氏煎饼果子配方
执行Master类的__init__方法后，self.kongfu属性：古法煎饼果子配方
[古法] 按照 <古法煎饼果子配方> 制作了一份煎饼果子...
--------------------
执行School类的__init__方法前，self.kongfu属性：古法煎饼果子配方
执行School类的__init__方法后，self.kongfu属性：现代煎饼果子配方
[现代] 按照 <现代煎饼果子配方> 制作了一份煎饼果子...
--------------------
执行子类的__init__方法前，self.kongfu属性：现代煎饼果子配方
执行子类的__init__方法前，self.kongfu属性：猫氏煎饼果子配方
[猫氏] 按照 <猫氏煎饼果子配方> 制作了一份煎饼果子...

核心点：

无论何时何地，self都表示是子类的对象。在调用父类方法时，通过传递self参数，来控制方法和属性的访问修改。

剧情发展：

大猫的煎饼果子店非常红火，终于有一天，他成了世界首富！！

但是他也老了，所以他希望把 师傅的配方 和 学校的配方 以及自己的配方 继续传承下去…（多层继承）

15.2.3 多层继承 ★★★★★

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"

    def make_cake(self):
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class School(object):
    def __init__(self):
        self.kongfu = "现代煎饼果子配方"

    def make_cake(self):
        print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


class Prentice(School, Master):  # 多继承，继承了多个父类
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"
        self.money = 10000  # 亿美金

    def make_cake(self):
        self.__init__()  # 执行本类的__init__方法，做属性初始化 self.kongfu = "猫氏...."
        print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)  # 调用父类方法格式：父类类名.父类方法(self)

    def make_old_cake(self):
        Master.__init__(self)  # 调用了父类Master的__init__方法 self.kongfu = "古法...."
        Master.make_cake(self)  # 调用了父类Master的实例方法

    def make_new_cake(self):
        School.__init__(self)  # 调用了父类School的__init__方法 self.kongfu = "现代...."
        School.make_cake(self)  # 调用父类School的实例方法，


class PrenticePrentice(Prentice):  # 多层继承
    pass


pp = PrenticePrentice()
pp.make_cake()  # 调用父类的实例方法
pp.make_new_cake()
pp.make_old_cake()
print(pp.money)

执行结果：

[猫氏] 按照 <猫氏煎饼果子配方> 制作了一份煎饼果子...
[现代] 按照 <现代煎饼果子配方> 制作了一份煎饼果子...
[古法] 按照 <古法煎饼果子配方> 制作了一份煎饼果子...
10000

剧情发展：

大猫觉得配方传承下去没问题，但是钱是辛辛苦苦挣得血汗钱，不想传给徒弟。（私有权限）

15.2.4 熟悉通过 super() 调用父类方法 ★★★★★

问题：

参考以下代码，调用父类方法时，如果直接指明父类名，存在代码臃肿的问题，怎么解决？

class Master(object):
    def __init__(self):
        self.kongfu = "古法煎饼果子配方"  # 实例变量，属性

    def make_cake(self):  # 实例方法，方法
        print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)


# 父类是 Master类
class School(Master):
    def __init__(self):
        self.kongfu = "现代煎饼果子配方"

    def make_cake(self):
        print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
        super().__init__()  # 执行父类的构造方法
        super().make_cake()  # 执行父类的实例方法


# 父类是 School 和 Master
class Prentice(School, Master):  # 多继承，继承了多个父类
    def __init__(self):
        self.kongfu = "猫氏煎饼果子配方"

    def make_cake(self):
        self.__init__()  # 执行本类的__init__方法，做属性初始化 self.kongfu = "猫氏...."
        print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)

    def make_all_cake(self):
        # 方式1. 指定执行父类的方法（代码臃肿）
        # School.__init__(self)
        # School.make_cake(self)
        #
        # Master.__init__(self)
        # Master.make_cake(self)
        #
        # self.__init__()
        # self.make_cake()

        # 方法2. super() 带参数版本，只支持新式类
        # super(Prentice, self).__init__() # 执行父类的 __init__方法
        # super(Prentice, self).make_cake()
        # self.make_cake()

        # 方法3. super()的简化版，只支持新式类
        super().__init__()  # 执行父类的 __init__方法
        super().make_cake()  # 执行父类的 实例方法
        self.make_cake()  # 执行本类的实例方法


damao = Prentice()
damao.make_cake()
damao.make_all_cake()

print(Prentice.__mro__)

执行结果:

[猫氏] 按照 <猫氏煎饼果子配方> 制作了一份煎饼果子...
[现代] 按照 <现代煎饼果子配方> 制作了一份煎饼果子...
[古法] 按照 <古法煎饼果子配方> 制作了一份煎饼果子...
[猫氏] 按照 <猫氏煎饼果子配方> 制作了一份煎饼果子...
(<class '__main__.Prentice'>, <class '__main__.School'>, <class '__main__.Master'>, <class 'object'>)

知识点：

子类继承了多个父类，如果父类类名修改了，那么子类也要涉及多次修改。而且需要重复写多次调用，显得代码臃肿。

使用super() 可以逐一调用所有的父类方法，并且只执行一次。调用顺序遵循 __mro__ 类属性的顺序。

注意：如果继承了多个父类，且父类都有同名方法，则默认只执行第一个父类的(同名方法只执行一次，目前super()不支持执行多个父类的同名方法)

super() 在Python2.3之后才有的机制，用于通常单继承的多层继承。

---

五、本单元知识总结

1.继承的概念
2.单继承和多继承
3.子类重写/调用父类同名的属性和方法
4.多层继承
5.super()调用父类方法

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第十五单元，选择题，填空题，简答题(1,2,3,4)、技能题（1、2、3）
2.完成教材第七章节，课后习题(1,2,3,4)

（Ⅲ）预习作业

1.预习第十六单元，面向对象-相关属性和方法知识点
2.预习教材，面向对象-相关属性和方法知识点

预习附录：

1.参见教材：第七章<193,195>页

第十六单元 面向对象-相关属性和方法

一、昨日知识点回顾

1. 什么是单继承？
2. 什么是多继承？
3. 子类怎么调用父类同名的属性和方法？
4. 什么是多层继承？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学Python全彩版》，第7章 面向对象对象程序设计，页码区间<181,202>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.私有属性和私有方法
2.类属性和实例属性
3.类方法和静态方法

（Ⅱ）能力目标

1.掌握私有属性
2.掌握私有方法
3.掌握修改私有属性的值
4.掌握多态
5.掌握类属性和实例属性应用
6.掌握类方法和静态方法

---

四、本单元知识详讲

16.1 私有属性和私有方法

16.1.1 私有属性 ★★★★★

私有属性：只需要在初始化时，在属性名前加__

class Cup(object):
    #构造函数，初始化属性值
    def __init__(self,capacity,color):
        #私有属性，只需要在属性名字前加__
        self.__capacity=capacity
        self.color=color
    def retain_water(self):
        print("杯子颜色："+self.color+"，杯子容量："+self.__capacity+",正在装水.")
    def keep_warm(self):
        print("杯子颜色："+self.color+"，杯子容量："+self.__capacity+",正在保温.")
currentCup=Cup('50ml','紫色')
currentCup.retain_water()
print(currentCup.capacity)

效果如下

Traceback (most recent call last):
  File "C:/练习/day04/正式上课/day06/12day/考试.py", line 17, in <module>
    print(currentCup.capacity)
AttributeError: 'Cup' object has no attribute 'capacity'
杯子颜色：紫色，杯子容量：50ml,正在装水.

16.1.2 私有方法 ★★★★★

私有方法：只需要在方法名前加__

class Cup(object):
    # 构造函数，初始化属性值
    def __init__(self,capacity,color):
        # 私有属性，只需要在属性名字前加__
        self.__capacity=capacity
        self.color=color
    # 私有方法，只需要在方法名前加__
    def __retain_water(self):
        print("杯子颜色："+self.color+"，杯子容量："+self.__capacity+",正在装水.")
    def keep_warm(self):
        print("杯子颜色："+self.color+"，杯子容量："+self.__capacity+",正在保温.")
currentCup=Cup('50ml','紫色')
# 外部调用失败，因为__retain_water()方法是私有的
currentCup.__retain_water()
currentCup.keep_warm()

效果如下

Traceback (most recent call last):
  File "C:/练习/day04/正式上课/day06/12day/考试.py", line 14, in <module>
    currentCup.__retain_water()
AttributeError: 'Cup' object has no attribute '__retain_water'
杯子颜色：紫色，杯子容量：50ml,正在保温.

关于私有属性和私有方法的总结:

私有权限：在属性和方法名前边加上两个下划线 __

1. 类的私有属性 和 私有方法，都不能通过对象直接访问，但是可以在本类内部访问；
2. 类的私有属性 和 私有方法，都不会被子类继承，子类也无法访问；
3. 私有属性 和 私有方法 往往用来处理类的内部事情，不通过对象处理，起到安全作用。

16.1.3 修改私有属性的值 ★★★★★

如果需要修改一个对象的属性值，通常有2种方法

1.对象名.属性名 = 数据 ----> 直接修改

2.对象名.方法名() ----> 间接修改

私有属性不能直接访问，所以无法通过第一种方式修改，一般的通过第二种方式修改私有属性的值：定义一个可以调用的公有方法，在这个公有方法内访问修改。

class Person(object):
    def __init__(self):
        self.name = "小明"
        self.__age = 20
    # 获取私有属性的值
    def get_age(self):
        return self.__age 
    # 设置私有属性的值
    def set_age(self, new_age):
        self.__age = new_age
# 定义一个对象
p = Person()
# 强行获取私有属性
print(p.__age)
print(p.name)
# 想在类的外面获取对象的属性
ret = p.get_age()
print(ret) 
# 想在类的外面修改对象私有属性的值
p.set_age(30)
print(p.get_age())

效果如下

Traceback (most recent call last):
  File "C:/练习/day04/正式上课/day06/12day/考试.py", line 14, in <module>
    print(p.__age)
AttributeError: 'Person' object has no attribute '__age'
小明
20
30

16.2 多态、类属性、实例属性

16.2.1 掌握多态 ★★★★★

所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态 ，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

鸭子类型：虽然我想要一只"鸭子"，但是你给了我一只鸟。 但是只要这只鸟走路像鸭子，叫起来像鸭子，游泳也像鸭子，我就认为这是鸭子。

Python的多态，就是弱化类型，重点在于对象参数是否有指定的属性和方法，如果有就认定合适，而不关心对象的类型是否正确。

class F1(object):
    def show(self):
        print('F1.show')
class S1(F1):
    def show(self):
        print('S1.show')
class S2(F1):
    def show(self):
        print('S2.show')
def Func(obj):  
    # python是弱类型，即无论传递过来的是什么，obj变量都能够指向它，这也就没有所谓的多态了（弱化了这个概念）
    print(obj.show())
s1_obj = S1()
Func(s1_obj) 
s2_obj = S2()
Func(s2_obj)

效果如下

S1.show
None
S2.show
None

16.2.2 掌握类属性和实例属性 ★★★★★

类属性:就是类对象所拥有的的属性，他被所有的类对象和实例对象所共用

实例属性:就是实例对象所拥有的的属性，类对象不能访问

1.类属性

class People(object):
    name = 'Tom'  # 公有的类属性
    __age = 12  # 私有的类属性
p = People()
print(p.name)  # 正确
print(People.name)  # 正确
print(p.__age)  # 错误，不能在类外通过实例对象访问私有的类属性
print(People.__age) # 错误，不能在类外通过类对象访问私有的类属性

效果如下

Tom
Tom
Traceback (most recent call last):
  File "C:/练习/day04/正式上课/day06/12day/考试.py", line 7, in <module>
    print(p.__age)  # 错误，不能在类外通过实例对象访问私有的类属性
AttributeError: 'People' object has no attribute '__age'

2.实例属性

class People(object):
    address = '山东'  # 类属性
    def __init__(self):
        self.name = 'xiaowang'  # 实例属性
        self.age = 20  # 实例属性
p = People()
p.age = 12  # 实例属性
print(p.address)  # 正确
print(p.name)  # 正确
print(p.age)  # 正确
print(People.address)  # 正确
print(People.name)  # 错误
print(People.age)  # 错误

效果如下

Traceback (most recent call last):
  File "C:/练习/day04/正式上课/day06/12day/考试.py", line 12, in <module>
    print(People.name)  # 错误
AttributeError: type object 'People' has no attribute 'name'
山东
xiaowang
12
山东

3.通过实例对象去修改类属性

class People(object):
    country = 'china'  # 类属性
print(People.country)
p = People()
print(p.country)
p.country = 'japan' 
print(p.country)  # 实例属性会屏蔽掉同名的类属性
print(People.country)
del p.country  # 删除实例属性
print(p.country)

效果如下

china
china
japan
china
china

总结

如果需要在类外修改类属性，必须通过类对象去引用然后进行修改。如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。

16.3 类方法

16.3.1 了解类方法 ★★★★

1.类方法

类方法是类对象所拥有的方法，需要用修饰器**@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以cls作为第一个参数的名字，就最好用cls**了），能够通过实例对象和类对象去访问。

16.3.2 类方法应用实例 ★★★★★

class People(object):
    # 私有类属性
    __country = 'china'
    # 类方法，用classmethod来进行修饰
    @classmethod
    def get_country(cls):
        return cls.__country
p = People()
print(p.get_country())  # 可以用过实例对象引用
print(People.get_country())  # 可以通过类对象引用

效果如下

china
china

类方法还有一个用途就是可以对类属性进行修改

class People(object):
    # 私有类属性
    __country = 'china'
    # 类方法，用classmethod来进行修饰
    @classmethod
    def get_country(cls):
        return cls.__country
    @classmethod
    def set_country(cls,country):
        cls.__country = country
p = People()
print(p.get_country())  # 可以用过实例对象访问
print(People.get_country())  # 可以通过类访问
p.set_country('japan')   
print(p.get_country())
print(People.get_country())

效果如下

china
china
japan
japan

总结

用类方法对类属性修改之后，通过类对象和实例对象访问都发生了改变

16.4 静态方法

16.4.1 了解静态方法 ★★★★★

需要通过修饰器**@staticmethod**来进行修饰，静态方法不需要多定义参数，可以通过对象和类来访问。

16.4.2 静态方法应用实例 ★★★★★

class People(object):
    country = 'china'
    @staticmethod
    #静态方法
    def get_country():
        return People.countryp = People()
# 通过对象访问静态方法
p.get_contry()
# 通过类访问静态方法
print(People.get_country())

效果如下

Traceback (most recent call last):
  File "C:/练习/day04/正式上课/day06/12day/考试.py", line 9, in <module>
    p.get_contry()
AttributeError: 'People' object has no attribute 'get_contry'
china

总结

1. 从类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法；
2. 实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。
3. 静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类实例对象来引用

---

五、本单元知识总结

1.私有属性和私有方法
2.类属性和实例属性
3.类方法和静态方法

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第十六单元，选择题，填空题，简答题(1,2,4,5)、技能题（1、2、3）

（Ⅲ）预习作业

1.预习第十七单元，单例模式及异常捕获
2.预习教材，异常处理及程序调试

预习附录：

1.参见教材：第九章<223,342>页

第十七单元 单例模式及异常捕获

一、昨日知识点回顾

1. 什么是私有属性、私有方法？
2. 如何修改私有属性的值？
3. 什么是多态？
4. 什么是类属性？
5. 什么是类方法、静态方法？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学Python全彩版》，第九章 异常处理及程序调试，页码区间<224,231>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1. 单例模式
2. 异常介绍
3. 异常捕获
4. 自定义异常

（Ⅱ）能力目标

1. 掌握类方法定义和使用
2. 掌握静态方法
3. 掌握单例模式应用场景和实现简单单例模式
4. 掌握通用异常捕获方法
5. 熟悉自定义异常类及使用

---

四、本单元知识详讲

17.1 单例模式

17.1.1 单例模式及企业级单例案例讲解 ★★★★★

什么是单例模式：单例模式即一个类有且仅有一个实例。

为什么要用：
全局变量，因为这比函数的参数传来传去更容易让人理解。确实在很多场景下用全局变量很方便。不过如果代码规模增大，并且有多个文件的时候，全局变量就会变得比较混乱。
你可能不知道在哪个文件中定义了相同类型甚至重名的全局变量，也不知道这个变量在程序的某个地方被做了怎样的操作。
单例模式保证了在程序的不同位置都可以且仅可以取到同一个对象实例：如果实例不存在，会创建一个实例；如果已存在就会返回这个实例。因为单例是一个类，所以你也可以为其提供相应的操作方法，以便于对这个实例进行管理。

python中，一个类创建对象实例是通过调用父类object的__new__(cls)方法来创建对象的，因此我们可以通过重写 __new__(cls)方法去实现类只创建一个实例

class Sun(object):
    __instance=None #定义一个类属性做判断
    def __new__(cls):
        if cls.__instance==None:
            #如果__instance为空证明是第一次创建实例
            #通过父类的__new__(cls)创建实例
            cls.__instance==object.__new__(cls)
            return cls.__instance
        else:
            #返回上一个对象的引用
            return cls.__instance
a = Sun()
print(id(a))
b = Sun()
print(id(b))

效果如下：

140715259292896
140715259292896

17.2 异常介绍

17.2.1 异常类型介绍 ★★★★★

异常类型	异常介绍
BaseException	所有异常的基类
SystemExit	解释器请求退出
KeyboardInterrupt	用户中断执行(通常是输入^C)
Exception	常规错误的基类
StopIteration	迭代器没有更多的值
GeneratorExit	生成器(generator)发生异常来通知退出
StandardError	所有的内建标准异常的基类
ArithmeticError	所有数值计算错误的基类
FloatingPointError	浮点计算错误
OverflowError	数值运算超出最大限制
ZeroDivisionError	除(或取模)零 (所有数据类型)
AssertionError	断言语句失败
AttributeError	对象没有这个属性
EOFError	没有内建输入,到达EOF 标记
EnvironmentError	操作系统错误的基类
IOError	输入/输出操作失败
OSError	操作系统错误
WindowsError	系统调用失败
ImportError	导入模块/对象失败
LookupError	无效数据查询的基类
IndexError	序列中没有此索引(index)
KeyError	映射中没有这个键
MemoryError	内存溢出错误(对于Python 解释器不是致命的)
NameError	未声明/初始化对象 (没有属性)
UnboundLocalError	访问未初始化的本地变量
ReferenceError	弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError	一般的运行时错误
NotImplementedError	尚未实现的方法
SyntaxError	Python 语法错误
IndentationError	缩进错误
TabError	Tab 和空格混用
SystemError	一般的解释器系统错误
TypeError	对类型无效的操作
ValueError	传入无效的参数
UnicodeError	Unicode 相关的错误
UnicodeDecodeError	Unicode 解码时的错误
UnicodeEncodeError	Unicode 编码时错误
UnicodeTranslateError	Unicode 转换时错误
Warning	警告的基类
DeprecationWarning	关于被弃用的特征的警告
FutureWarning	关于构造将来语义会有改变的警告
OverflowWarning	旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning	关于特性将会被废弃的警告
RuntimeWarning	可疑的运行时行为(runtime behavior)的警告
SyntaxWarning	可疑的语法的警告
UserWarning	用户代码生成的警告

什么是异常？

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。

一般情况下，在Python无法正常处理程序时就会发生一个异常。

异常是Python对象，表示一个错误。

当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

17.3 异常捕获

17.3.1 异常捕获格式介绍 ★★★★★

捕捉异常可以使用try/except语句。

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

如果你不想在异常发生时结束你的程序，只需在try里捕获它。

语法：

以下为简单的try…except…else的语法：

try:
	<语句>        # 运行别的代码
except <名字>：
	<语句>        # 如果在try部份引发了'name'异常
except <名字>，<数据>:
	<语句>        # 如果引发了'name'异常，获得附加的数据
else:
	<语句>        # 如果没有异常发生

try的工作原理是，当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。

• 如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。
• 如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印默认的出错信息）。
• 如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。

17.3.2 异常捕获方法介绍及案例演示 ★★★★★

1.捕获异常 try…except…

看如下示例:

try:
    print('-----test--1---')
    open('123.txt','r')
    print('-----test--2---')
except IOError:
    pass

运行结果:

-----test--1---

说明:

• 此程序看不到任何错误，因为用except 捕获到了IOError异常，并添加了处理的方法
• pass 表示实现了相应的实现，但什么也不做；如果把pass改为print语句，那么就会输出其他信息

小总结:

• 把可能出现问题的代码，放在try中
• 把处理异常的代码，放在except中

2. except捕获多个异常

看如下示例:

try:
    print num
except IOError:
    print('产生错误了')

运行结果如下:

Traceback (most recent call last):
  File "/Users/mac/PycharmProjects/Month1/0000.py", line 107, in <module>
    print(num)
NameError: name 'num' is not defined

想一想:

上例程序，已经使用except来捕获异常了，为什么还会看到错误的信息提示？

答:

except捕获的错误类型是IOError，而此时程序产生的异常为 NameError ，所以except没有生效

修改后的代码为:

try:
    print num
except NameError:
    print('产生错误了')

运行结果如下:

产生错误了

实际开发中，捕获多个异常的方式，如下：

#coding=utf-8
try:
    print('-----test--1---')
    open('123.txt','r') # 如果123.txt文件不存在，那么会产生 IOError 异常
    print('-----test--2---')
    print(num)# 如果num变量没有定义，那么会产生 NameError 异常

except (IOError,NameError): 
    #如果想通过一次except捕获到多个异常可以用一个元组的方式

注意：

• 当捕获多个异常时，可以把要捕获的异常的名字，放到except 后，并使用元组的方式仅进行存储

3.获取异常的信息描述

4.捕获所有异常

5. else

咱们应该对else并不陌生，在if中，它的作用是当条件不满足时执行的实行；同样在try…except…中也是如此，即如果没有捕获到异常，那么就执行else中的事情

try:
    num = 100
    print num
except NameError as errorMsg:
    print('产生错误了:%s'%errorMsg)
else:
    print('没有捕获到异常，真高兴')

运行结果如下:

6.try…finally…

try…finally…语句用来表达这样的情况：
在程序中，如果一个段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用finally。 比如文件关闭，释放锁，把数据库连接返还给连接池等

demo:

import time
try:
    f = open('test.txt')
    try:
        while True:
            content = f.readline()
            if len(content) == 0:
                break
            time.sleep(2)
            print(content)
    except:
        #如果在读取文件的过程中，产生了异常，那么就会捕获到
        #比如 按下了 ctrl+c
        pass
    finally:
        f.close()
        print('关闭文件')
except:
    print("没有这个文件")

说明:

• test.txt文件中每一行数据打印，但是我有意在每打印一行之前用time.sleep方法暂停2秒钟。这样做的原因是让程序运行得慢一些。在程序运行的时候，按Ctrl+c中断（取消）程序。
• 我们可以观察到KeyboardInterrupt异常被触发，程序退出。但是在程序退出之前，finally从句仍然被执行，把文件关闭。

17.3.3 异常的传递 ★★★★

1. try嵌套中

import time
try:
    f = open('test.txt')
    try:
        while True:
            content = f.readline()
            if len(content) == 0:
                break
            time.sleep(2)
            print(content)
    finally:
        f.close()
        print('关闭文件')
except:
    print("没有这个文件")

运行结果:

In [26]: import time
    ...: try:
    ...:     f = open('test.txt')
    ...:     try:
    ...:         while True:
    ...:             content = f.readline()
    ...:             if len(content) == 0:
    ...:                 break
    ...:             time.sleep(2)
    ...:             print(content)
    ...:     finally:
    ...:         f.close()
    ...:         print('关闭文件')
    ...: except:
    ...:     print("没有这个文件")
    ...: finally:
    ...:     print("最后的finally")
    ...:     
xxxxxxx--->这是test.txt文件中读取到信息
^C关闭文件
没有这个文件
最后的finally

2. 函数嵌套调用中

def test1():
        print("----test1-1----")
        print(num)
        print("----test1-2----")


    def test2():
        print("----test2-1----")
        test1()
        print("----test2-2----")


    def test3():
        try:
            print("----test3-1----")
            test1()
            print("----test3-2----")
        except Exception as result:
            print("捕获到了异常，信息是:%s"%result)

        print("----test3-2----")



    test3()
    print("------华丽的分割线-----")
    test2()

运行结果:

总结：

• 如果try嵌套，那么如果里面的try没有捕获到这个异常，那么外面的try会接收到这个异常，然后进行处理，如果外边的try依然没有捕获到，那么再进行传递。。。
• 如果一个异常是在一个函数中产生的，例如函数A---->函数B---->函数C,而异常是在函数C中产生的，那么如果函数C中没有对这个异常进行处理，那么这个异常会传递到函数B中，如果函数B有异常处理那么就会按照函数B的处理方式进行执行；如果函数B也没有异常处理，那么这个异常会继续传递，以此类推。。。如果所有的函数都没有处理，那么此时就会进行异常的默认处理，即通常见到的那样
• 注意观察上图中，当调用test3函数时，在test1函数内部产生了异常，此异常被传递到test3函数中完成了异常处理，而当异常处理完后，并没有返回到函数test1中进行执行，而是在函数test3中继续执行

17.3.4 抛出自定义的异常综合案例演示 ★★★★★

class Test(object):
    def __init__(self, switch):
        self.switch = switch #开关
    def calc(self, a, b):
        try:
            return a/b
        except Exception as result:
            if self.switch:
                print("捕获开启，已经捕获到了异常，信息如下:")
                print(result)
            else:
                # 重新抛出这个异常，此时就不会被这个异常处理给捕获到，从而触发默认的异常处理
                raise


a = Test(True)
a.calc(11,0)

print("----------------------华丽的分割线----------------")

a.switch = False
a.calc(11,0)

运行结果:

---

五、本单元知识总结

1. 掌握类方法定义和使用
2. 掌握静态方法
3. 掌握单例模式应用场景和实现简单单例模式
4. 掌握通用异常捕获方法
5. 熟悉自定义异常类及使用

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第十七单元，选择题，填空题，简答题(1,2,3)、技能题（1、2、3、4、5）
2.完成教材第九章节，课后习题(实例01、实例02、实例03)

（Ⅲ）预习作业

1.预习第十八单元 模块和线上图书综合管理系统实战
2.预习教材，第八章 模块

预习附录：

1.参见教材：第八章<204,209>页

第十八单元 模块和线上图书综合管理系统实战

一、昨日知识点回顾

1. 类方法怎么定义和使用？
2. 静态方法怎么实现？
3. 单例模式是什么？
4. 异常怎么自定义以及怎么处理异常？

---

二、本单元知识点概述

（Ⅰ）指定教材

​ 引用自指定教材《零基础学python(全彩版)》，第8章 模块，页码区间<204,223>页

（Ⅱ）知识点概述

（Ⅲ）教学时长

​ 共4课时，180分钟

---

三、本单元教学目标

（Ⅰ）重点知识目标

1.模块制作
2.基本导包方法
3.线上图书综合管理系统需求设计思路及实现

（Ⅱ）能力目标

1.掌握模块制作
2.掌握基本导包方法
3.掌握线上图书综合管理系统需求设计思路
4.实现一个属于自己的线上图书综合管理系统

---

四、本单元知识详讲

18.1 模块

18.1.1 模块的介绍 ★★★★

模块的英文是 Modules,可以认为是一盒(箱)主题积木,通过它可以拼出某一主题的东西。这与前面介绍的函数不同,一个函数相当于一块积木,而一个模块中可以包括很多函数,也就是很多积木,所以也可以说模块相当于一盒积木。如图所示。

在 Python中,一个扩展名为py的文件就称之为一个模块。例如,在之前的学习中创建的 function_bmi.py文件就是一个模块,如图所示。

经过前面的学习,我们知道对于 Python代码可以写到一个文件中。但是随着程序不断变大,为了便于维护,需要将其分为多个文件,这样可以提高代码的可维护性。另外,使用模块还可以提高代码的可重用性。即编写好一个模块后,只要是实现该功能的程序,都可以导入这个模块实现。

18.1.2 Python导包方法 ★★★★★

1.import

在Python中用关键字import来引入某个模块，比如要引用模块math，就可以在文件最开始的地方用import math来引入。

形如:

import module1,mudule2...

当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。

在调用math模块中的函数时，必须这样引用：

模块名.函数名

**想一想:**为什么必须加上模块名调用呢？

**答:**因为可能存在这样一种情况：在多个模块中含有相同名称的函数，此时如果只是通过函数名来调用，解释器无法知道到底要调用哪个函数。所以如果像上述这样引入模块的时候，调用函数必须加上模块名

import math

#这样会报错
print sqrt(2)

#这样才能正确输出结果
print math.sqrt(2)

有时候我们只需要用到模块中的某个函数，只需要引入该函数即可，此时可以用下面方法实现：

from 模块名 import 函数名1,函数名2....

不仅可以引入函数，还可以引入一些全局变量、类等

注意:

• 通过这种方式引入的时候，调用函数时只能给出函数名，不能给出模块名，但是当两个模块中含有相同名称函数的时候，后面一次引入会覆盖前一次引入。也就是说假如模块A中有函数function( )，在模块B中也有函数function( )，如果引入A中的function在先、B中的function在后，那么当调用function函数的时候，是去执行模块B中的function函数。
• 如果想一次性引入math中所有的东西，还可以通过from math import *来实现

2.from…import

Python的from语句让你从模块中导入一个指定的部分到当前命名空间中

语法如下：

from modname import name1[, name2[, ... nameN]]

例如，要导入模块fib的fibonacci函数，使用如下语句：

from fib import fibonacci

**注意:**不会把整个fib模块导入到当前的命名空间中，它只会将fib里的fibonacci单个引入

**3.from … import **

把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：

from modname import *

注意：这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。

4. as

In [1]: import time as tt

In [2]: time.sleep(1)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-2-07a34f5b1e42> in <module>()
----> 1 time.sleep(1)

NameError: name 'time' is not defined

In [3]: 

In [3]: 

In [3]: tt.sleep(1)

In [4]: 

In [4]: 

In [4]: from time import sleep as sp

In [5]: sleep(1)
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-5-82e5c2913b44> in <module>()
----> 1 sleep(1)

NameError: name 'sleep' is not defined

In [6]: 

In [6]: 

In [6]: sp(1)

In [7]:

5.定位模块

当你导入一个模块，Python解析器对模块位置的搜索顺序是：

1. 当前目录
2. 如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录。
3. 如果都找不到，Python会查看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/
4. 模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

18.1.3 制作模块案例演示 ★★★★★

1.定义自己的模块

在Python中，每个Python文件都可以作为一个模块，模块的名字就是文件的名字。

比如有这样一个文件test.py，在test.py中定义了函数add

test.py

def add(a,b):
    return a+b

2.调用自己定义的模块

那么在其他文件中就可以先import test，然后通过test.add(a,b)来调用了，当然也可以通过from test import add来引入

main.py

import test

result = test.add(11,22)
print(result)

3.测试模块

在实际开中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果，这个开发人员会自行在py文件中添加一些测试信息，例如：

test.py

def add(a,b):
    return a+b

# 用来进行测试
ret = add(12,22)
print('int test.py file,,,,12+22=%d' % ret)

如果此时，在其他py文件中引入了此文件的话，想想看，测试的那段代码是否也会执行呢！

main.py

import test

result = test.add(11,22)
print(result)

运行现象：

int test.py file,,,,12+22=34
33

至此，可发现test.py中的测试代码，应该是单独执行test.py文件时才应该执行的，不应该是其他的文件中引用而执行

为了解决这个问题，python在执行一个文件时有个变量__name__

以下是两种运行方式:

(1).直接运行此文件

test.py

def add(a,b):
    return a+b

# 用来进行测试
# ret = add(12,22)
# print('int test.py file,,,,12+22=%d' % ret)

print('int test.py file,__name__ is %s' % __name__)

运行现象：

int test.py file,__name__ is __main__

(2).在其他文件中import此文件

main.py

import test

# result = test.add(11,22)
# print(result)

运行现象：

int test.py file,__name__ is test

**总结：**可以根据__name__变量的结果能够判断出，是直接执行的python脚本还是被引入执行的，从而能够有选择性的执行测试代码

test.py

def add(a,b):
    return a+b

# 用来进行测试
if __name__ == __main__:
    ret = add(12,22)
	print('int test.py file,,,,12+22=%d' % ret)

18.2 线上图书综合管理系统

18.2.1 线上图书综合管理系统需求分析与案例设计思路讲解 ★★★★

业务需求:

随着图书馆规模的不断扩大, 图书数量也相应的增加, 有关图书的各种信息量也成倍增加, 面对着庞大的信息量, 传统的人工方式管理会导致图书馆管理上的混乱, 人力与物力过多浪费, 图书馆管理费用的增加, 从而使图书馆的负担过重,影响整个图书馆的运作和控制管理。因此,必须制定一套合理、有效,规范和实用的图书管理系统,对图书资料进行集中统一的管理。希望通过图书管理系统实现图书管理的系统化、规范化和自动化,实现对图书资料的集中统一的管理。

需求

(1).添加新书: 输入要添加的书名、存放的书架号、价格。

(2).修改图书: 输入要书名，然后对其修改书架号、价格

(3).删除图书: 输入书名，然后对应删除书名、书架号、价格

(4).查询单本图书: 展示所有的书籍

(5).查询所有图书: 查询出所有图书

(5).退出系统: 退出系统

根据业务需求，将整个案例拆解为以下几个功能模块:

• 添加图书
• 删除图书
• 修改图书
• 查询图书
• 显示所有图书
• 保存数据
• 退出系统

18.2.2 线上图书综合管理系统案例实战 ★★★★★

import os, json


class BookInfo(object):
    def __init__(self):
        self.books = self.read_books()

    def read_books(self):
        try:
            with open('books.json', 'r') as f:
                books = json.load(f)
                return books
        except:
            return {
     }

    def is_not_exists(self, title):
        """
        :param title: 图书名称
        :return: 存在，返回False，否则，返回True
        """
        bookInfo = self.books.get(title, "")
        if bookInfo == '':
            return True
        else:
            return False

    def addBookInfo(self):
        """添加图书"""
        title = input("输入图书名称:")
        price = input("输入图书单价:")

        if self.is_not_exists(title):
            try:
                self.books[title] = {
     'title': title, 'price': float(price)}
            except:
                print("图书信息有误")
                return
        else:
            print("添加失败，图书{}已存在".format(title))

    def delBookInfo(self):
        """删除图书"""
        title = input("输入图书名称:")
        if self.is_not_exists(title):
            print("删除失败，图书{}不存在".format(title))
        else:
            del self.books[title]
            print("图书{}删除成功".format(title))

    def updateBookInfo(self):
        """修改图书"""
        title = input("输入图书名称:")
        price = input("输入图书单价:")

        if self.is_not_exists(title):
            print("更新失败，图书{}不存在".format(title))
        else:
            try:
                self.books[title] = {
     'title': title, 'price': float(price)}
            except:
                print("图书信息有误")
                return

    def queryBooksInfo(self):
        """查询图书"""
        title = input("输入图书名称:")

        if self.is_not_exists(title):
            print("查询失败，图书{}不存在".format(title))
        else:
            book = self.books[title]
            print('图书名称为:{},单价为:{}'.format(book['title'], book['price']))

    def listBookInfo(self):
        """显示所有数据"""
        if len(self.books) == 0:
            print("暂无图书数据")
        else:
            for book in self.books.values():
                print('图书名称为:{},单价为:{}'.format(book['title'], book['price']))

    def saveBookInfo(self):
        """保存数据"""
        with open('books.json', 'w') as f:
            json.dump(self.books, f)

    def menu(self):
        while True:
            print("""
            图书管理系统V1.0
            1. 添加图书
            2. 删除图书
            3. 修改图书
            4. 查询图书
            5. 显示所有图书
            6. 保存数据
            7. 退出系统
            """)
            n = input("选择id:")

            if n.isdigit() and 1 <= int(n) <= 7:
                if n == "1":
                    self.addBookInfo()
                elif n == '2':
                    self.delBookInfo()

                elif n == '3':
                    self.updateBookInfo()
                elif n == '4':
                    self.queryBooksInfo()

                elif n == '5':
                    self.listBookInfo()
                elif n == '6':
                    self.saveBookInfo()
                else:
                    os._exit(0)


if __name__ == '__main__':
    """程序入口"""
    book = BookInfo()
    book.menu()

---

五、本单元知识总结

1.掌握模块制作
2.掌握基本导包方法
3.掌握线上图书综合管理系统需求设计思路
4.实现一个属于自己的线上图书综合管理系统

---

六、作业安排

（Ⅰ）课后作业

1.完成练习手册第十五单元，选择题，填空题，简答题(1,2,3,4)、技能题（1,2,3,4）
2.完成教材第八章节章节，课后习题(1,2,3,4,5,6)

（Ⅲ）预习作业

1.无

预习附录：

1.无