python学习笔记

基础语法部分

语法

输出语句

​x
1
print("hello python")
2
print("hello world")
3
​
4
print("*", end="")  # 输出后不换行

利用命令行运行文件

1
1
$ python 01-HelloPython.py

常见错误

• 1> 手误，例如使用 pirnt("Hello world")

3
1
NameError: name 'pirnt' is not defined
2
​
3
名称错误：'pirnt' 名字没有定义

• 2> 将多条 print 写在一行

3
1
SyntaxError: invalid syntax
2
​
3
语法错误：语法无效

每行代码负责完成一个动作

• 3> 缩进错误

3
1
IndentationError: unexpected indent
2
​
3
缩进错误：不期望出现的缩进

• Python 是一个格式非常严格的程序设计语言
• 目前而言，大家记住每行代码前面都不要增加空格

• 4> python 2.x 默认不支持中文

目前市场上有两个 Python 的版本并存着，分别是 Python 2.x 和 Python 3.x

• Python 2.x 默认不支持中文，具体原因，等到介绍 字符编码 时给大家讲解
• Python 2.x 的解释器名称是 python
• Python 3.x 的解释器名称是 python3

6
1
SyntaxError: Non-ASCII character '\xe4' in file 01-HelloPython.py on line 3, 
2
but no encoding declared; 
3
see http://python.org/dev/peps/pep-0263/ for details
4
​
5
语法错误： 在 01-HelloPython.py 中第 3 行出现了非 ASCII 字符 '\xe4'，但是没有声明文件编码
6
请访问 http://python.org/dev/peps/pep-0263/ 了解详细信息

• ASCII 字符只包含 256 个字符，不支持中文
• 有关字符编码的问题，后续会讲

• 单词列表

  13
  1
  * error 错误
  2
  * name 名字
  3
  * defined 已经定义
  4
  * syntax 语法
  5
  * invalid 无效
  6
  * Indentation 索引
  7
  * unexpected 意外的，不期望的
  8
  * character 字符
  9
  * line 行
  10
  * encoding 编码
  11
  * declared 声明
  12
  * details 细节，详细信息
  13
  * ASCII 一种字符编码
  

   

注释

单行注释(行注释)

• 以 # 开头，# 右边的所有东西都被当做说明文字，而不是真正要执行的程序，只起到辅助说明作用
• 示例代码如下：

2
1
# 这是第一个单行注释
2
print("hello python")

为了保证代码的可读性，# 后面建议先添加一个空格，然后再编写相应的说明文字

在代码后面增加的单行注释

• 在程序开发时，同样可以使用 # 在代码的后面（旁边）增加说明性的文字
• 但是，需要注意的是，为了保证代码的可读性，注释和代码之间 至少要有 两个空格
• 示例代码如下：

1
1
print("hello python")  # 输出 `hello python`

多行注释(块注释)

• 如果希望编写的 注释信息很多，一行无法显示，就可以使用多行注释
• 要在 Python 程序中使用多行注释，可以用 一对 连续的 三个 引号(单引号和双引号都可以)
• 示例代码如下：

6
1
"""
2
这是一个多行注释
3
​
4
在多行注释之间，可以写很多很多的内容……
5
""" 
6
print("hello python")

运算符

• 在 Python 中 * 运算符还可以用于字符串，计算结果就是字符串重复指定次数的结果

2
1
In [1]: "-" * 50
2
Out[1]: '----------------------------------------' 

优先级

• 以下表格的算数优先级由高到最低顺序排列

变量

变量定义

• 在 Python 中，每个变量 在使用前都必须赋值，变量 赋值以后 该变量 才会被创建

• 等号（=）用来给变量赋值

  • = 左边是一个变量名
  • = 右边是存储在变量中的值

1
1
变量名 = 值

变量定义之后，后续就可以直接使用了

变量类型

• 在内存中创建一个变量，会包括：

  1. 变量的名称
  2. 变量保存的数据
  3. 变量存储数据的类型
  4. 变量的地址（标示）

• 在 Python 中定义变量是 不需要指定类型（在其他很多高级语言中都需要）

• 数据类型可以分为 数字型 和 非数字型

• 数字型

  • 整型 (int)

  • 浮点型（float）

  • 布尔型（bool）

    • 真 True 非 0 数 —— 非零即真
    • 假 False 0

  • 复数型 (complex)

    • 主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题

• 非数字型

  • 字符串
  • 列表
  • 元组
  • 字典

提示：在 Python 2.x 中，整数 根据保存数值的长度还分为：

• int（整数）
• long（长整数）

• 使用 type 函数可以查看一个变量的类型

1
1
In [1]: type(name)

不同类型变量之间的计算

1) 数字型变量 之间可以直接计算

• 在 Python 中，两个数字型变量是可以直接进行 算数运算的

• 如果变量是 bool 型，在计算时

  • True 对应的数字是 1
  • False 对应的数字是 0

2) 字符串变量 之间使用 + 拼接字符串

• 在 Python 中，字符串之间可以使用 + 拼接生成新的字符串

6
1
In [1]: first_name = "三"
2
​
3
In [2]: last_name = "张"
4
​
5
In [3]: first_name + last_name
6
Out[3]: '三张'

3) 字符串变量 可以和 整数 使用 * 重复拼接相同的字符串

2
1
In [1]: "-" * 50
2
Out[1]: '--------------------------------------------------'

4) 数字型变量 和 字符串 之间 不能进行其他计算

12
1
In [1]: first_name = "zhang"
2
​
3
In [2]: x = 10
4
​
5
In [3]: x + first_name
6
---------------------------------------------------------------------------
7
TypeError: unsupported operand type(s) for +: 'int' and 'str'
8
类型错误：`+` 不支持的操作类型：`int` 和 `str`
9
​
10
解决方法：使用字符串转换函数 str()
11
​
12
str(x) + first_name   -->   10first_name

变量的输入

input 函数实现键盘输入

• 在 Python 中可以使用 input 函数从键盘等待用户的输入
• 用户输入的 任何内容 Python 都认为是一个 字符串
• 语法如下：

1
1
字符串变量 = input("提示信息：")

类型转换函数

定义 一个 浮点变量 接收用户输入的同时，就使用 float 函数进行转换

3
1
price = float(input("请输入价格:"))
2
​
3
# 此时输入数据将自动转换成小数。注意：如果输入不是数值将报错。

变量的格式化输出

苹果单价 9.00 元／斤，购买了 5.00 斤，需要支付 45.00 元

• 在 Python 中可以使用 print 函数将信息输出到控制台

• 如果希望输出文字信息的同时，一起输出 数据，就需要使用到 格式化操作符

• % 被称为 格式化操作符，专门用于处理字符串中的格式

  • 包含 % 的字符串，被称为 格式化字符串
  • % 和不同的 字符 连用，不同类型的数据 需要使用 不同的格式化字符

• 语法格式如下：

3
1
print("格式化字符串" % 变量1)
2
​
3
print("格式化字符串" % (变量1, 变量2...))

标识符

标示符就是程序员定义的 变量名、函数名

名字 需要有 见名知义 的效果，见下图：

• 标示符可以由 字母、下划线 和 数字 组成
• 不能以数字开头
• 不能与关键字重名

关键字

• 关键字 就是在 Python 内部已经使用的标识符
• 关键字 具有特殊的功能和含义
• 开发者 不允许定义和关键字相同的名字的标示符

通过以下命令可以查看 Python 中的关键字

2
1
In [1]: import keyword
2
In [2]: print(keyword.kwlist)

提示：关键字的学习及使用，会在后面的课程中不断介绍

• import 关键字 可以导入一个 “工具包”
• 在 Python 中不同的工具包，提供有不同的工具

命名规则

命名规则 可以被视为一种 惯例，并无绝对与强制 目的是为了 增加代码的识别和可读性

注意 Python 中的 标识符 是 区分大小写的

1. 在定义变量时，为了保证代码格式，= 的左右应该各保留一个空格

2. 在 Python 中，如果 变量名 需要由 二个 或 多个单词 组成时，可以按照以下方式命名

   1. 每个单词都使用小写字母
   2. 单词与单词之间使用 _下划线 连接
   • 例如：first_name、last_name、qq_number、qq_password

驼峰命名法

• 当 变量名 是由二个或多个单词组成时，还可以利用驼峰命名法来命名

• 小驼峰式命名法

  • 第一个单词以小写字母开始，后续单词的首字母大写
  • 例如：firstName、lastName

• 大驼峰式命名法

  • 每一个单词的首字母都采用大写字母
  • 例如：FirstName、LastName、CamelCase

逻辑判断（if）

6
1
#使用方法：
2
if 条件1:
3
    条件1满足执行的代码
4
    ……
5
else:
6
    条件1不满足执行的代码

判断的定义

• 如果 条件满足，才能做某件事情，
• 如果 条件不满足，就做另外一件事情，或者什么也不做

正是因为有了判断，才使得程序世界丰富多彩，充满变化！

判断语句 又被称为 “分支语句”，正是因为有了判断，才让程序有了很多的分支

逻辑运算

• 在程序开发中，通常 在判断条件时，会需要同时判断多个条件
• 只有多个条件都满足，才能够执行后续代码，这个时候需要使用到 逻辑运算符
• 逻辑运算符 可以把 多个条件 按照 逻辑 进行 连接，变成 更复杂的条件
• Python 中的 逻辑运算符 包括：与 and／或 or／非 not 三种

and

1
1
条件1 and 条件2

• 与／并且
• 两个条件同时满足，返回 True
• 只要有一个不满足，就返回 False

or

1
1
条件1 or 条件2

• 或／或者
• 两个条件只要有一个满足，返回 True
• 两个条件都不满足，返回 False

not

1
1
not 条件

• 非／不是

if进阶elif

• 在开发中，使用 if 可以 判断条件
• 使用 else 可以处理 条件不成立 的情况
• 但是，如果希望 再增加一些条件，条件不同，需要执行的代码也不同 时，就可以使用 elif
• 语法格式如下：

12
1
if 条件1:
2
    条件1满足执行的代码
3
    ……
4
elif 条件2:
5
    条件2满足时，执行的代码
6
    ……
7
elif 条件3:
8
    条件3满足时，执行的代码
9
    ……
10
else:
11
    以上条件都不满足时，执行的代码
12
    ……

• 对比逻辑运算符的代码

3
1
if 条件1 and 条件2:
2
    条件1满足 并且 条件2满足 执行的代码
3
    ……

注意

1. elif 和 else 都必须和 if 联合使用，而不能单独使用
2. 可以将 if、elif 和 else 以及各自缩进的代码，看成一个 完整的代码块

if 的嵌套

elif 的应用场景是：同时 判断 多个条件，所有的条件是 平级 的

• 在开发中，使用 if 进行条件判断，如果希望 在条件成立的执行语句中 再 增加条件判断，就可以使用 if 的嵌套
• if 的嵌套 的应用场景就是：在之前条件满足的前提下，再增加额外的判断
• if 的嵌套 的语法格式，除了缩进之外 和之前的没有区别
• 语法格式如下：

16
1
if 条件 1:
2
    条件 1 满足执行的代码
3
    ……
4
    
5
    if 条件 1 基础上的条件 2:
6
        条件 2 满足时，执行的代码
7
        ……    
8
        
9
    # 条件 2 不满足的处理
10
    else:
11
        条件 2 不满足时，执行的代码
12
        
13
# 条件 1 不满足的处理
14
else:
15
    条件1 不满足时，执行的代码
16
    ……

随机数的处理

• 在 Python 中，要使用随机数，首先需要导入 随机数 的 模块 —— “工具包”

1
1
import random

• 导入模块后，可以直接在 模块名称 后面敲一个 . 然后按 Tab 键，会提示该模块中包含的所有函数
• random.randint(a, b) ，返回 [a, b] 之间的整数，包含 a 和 b
• 例如：

3
1
random.randint(12, 20)  # 生成的随机数n: 12 <= n <= 20   
2
random.randint(20, 20)  # 结果永远是 20   
3
random.randint(20, 10)  # 该语句是错误的，下限必须小于上限

运算符

01. 算数运算符

• 是完成基本的算术运算使用的符号，用来处理四则运算

• 在 Python 中 * 运算符还可以用于字符串，计算结果就是字符串重复指定次数的结果

2
1
In [1]: "-" * 50
2
Out[1]: '----------------------------------------' 

02. 比较（关系）运算符

Python 2.x 中判断 不等于 还可以使用 <> 运算符

!= 在 Python 2.x 中同样可以用来判断 不等于

03. 逻辑运算符

04. 赋值运算符

• 在 Python 中，使用 = 可以给变量赋值
• 在算术运算时，为了简化代码的编写，Python 还提供了一系列的 与 算术运算符 对应的 赋值运算符
• 注意：赋值运算符中间不能使用空格

05. 运算符的优先级

• 以下表格的算数优先级由高到最低顺序排列

循环基本使用

• 循环的作用就是让 指定的代码 重复的执行
• while 循环最常用的应用场景就是 让执行的代码 按照 指定的次数 重复 执行
• 需求 —— 打印 5 遍 Hello Python
• 思考 —— 如果要求打印 100 遍怎么办？

while 语句基本语法

9
1
初始条件设置 —— 通常是重复执行的 计数器
2
​
3
while 条件(判断 计数器 是否达到 目标次数):
4
    条件满足时，做的事情1
5
    条件满足时，做的事情2
6
    条件满足时，做的事情3
7
    ...(省略)...
8
    
9
    处理条件(计数器 + 1)

注意：

while 语句以及缩进部分是一个 完整的代码块

for语句基本语法

使用 for 就能够实现迭代遍历

6
1
# for 循环内部使用的变量 in 列表
2
for name in name_list:
3
​
4
    循环内部针对列表元素进行操作
5
    print(name)
6
​

Python 中的计数方法

常见的计数方法有两种，可以分别称为：

• 自然计数法（从 1 开始）—— 更符合人类的习惯
• 程序计数法（从 0 开始）—— 几乎所有的程序语言都选择从 0 开始计数

因此，大家在编写程序时，应该尽量养成习惯：除非需求的特殊要求，否则 循环 的计数都从 0 开始

break 和 continue

break 和 continue 是专门在循环中使用的关键字

• break 某一条件满足时，退出循环，不再执行后续重复的代码
• continue 某一条件满足时，不执行后续重复的代码

break 和 continue 只针对 当前所在循环 有效

break

• 在循环过程中，如果 某一个条件满足后，不 再希望 循环继续执行，可以使用 break 退出循环

14
1
i = 0
2
​
3
while i < 10:
4
​
5
    # break 某一条件满足时，退出循环，不再执行后续重复的代码
6
    # i == 3
7
    if i == 3:
8
        break
9
​
10
    print(i)
11
​
12
    i += 1
13
​
14
print("over")

break 只针对当前所在循环有效

continue

• 在循环过程中，如果 某一个条件满足后，不 希望 执行循环代码，但是又不希望退出循环，可以使用 continue
• 也就是：在整个循环中，只有某些条件，不需要执行循环代码，而其他条件都需要执行

17
1
i = 0
2
​
3
while i < 10:
4
​
5
    # 当 i == 7 时，不希望执行需要重复执行的代码
6
    if i == 7:
7
        # 在使用 continue 之前，同样应该修改计数器
8
        # 否则会出现死循环
9
        i += 1
10
​
11
        continue
12
​
13
    # 重复执行的代码
14
    print(i)
15
​
16
    i += 1
17
​

• 需要注意：使用 continue 时，条件处理部分的代码，需要特别注意，不小心会出现 死循环

continue 只针对当前所在循环有效

循环嵌套

• while 嵌套就是：while 里面还有 while

15
1
while 条件 1:
2
    条件满足时，做的事情1
3
    条件满足时，做的事情2
4
    条件满足时，做的事情3
5
    ...(省略)...
6
    
7
    while 条件 2:
8
        条件满足时，做的事情1
9
        条件满足时，做的事情2
10
        条件满足时，做的事情3
11
        ...(省略)...
12
    
13
        处理条件 2
14
    
15
    处理条件 1

字符串中的转义字符

• \t 在控制台输出一个 制表符，协助在输出文本时 垂直方向 保持对齐
• \n 在控制台输出一个 换行符

制表符 的功能是在不使用表格的情况下在 垂直方向 按列对齐文本

2
1
# "\t" 可以在控制台输出一个制表符，协助在输出文本时对齐
2
print(“*”, end="\t")

函数

函数的定义

定义函数的格式如下：

4
1
def 函数名():
2
​
3
    函数封装的代码
4
    ……

1. def 是英文 define 的缩写

2. 函数名称 应该能够表达 函数封装代码 的功能，方便后续的调用

3. 函数名称 的命名应该 符合 标识符的命名规则

   • 可以由 字母、下划线 和 数字 组成
   • 不能以数字开头
   • 不能与关键字重名

函数调用

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

函数的文档注释

• 在开发中，如果希望给函数添加注释，应该在 定义函数 的下方，使用 连续的三对引号
• 在 连续的三对引号 之间编写对函数的说明文字
• 在 函数调用 位置，使用快捷键 CTRL + Q 可以查看函数的说明信息

注意：因为 函数体相对比较独立，函数定义的上方，应该和其他代码（包括注释）保留 两个空行

函数参数的使用

• 在函数名的后面的小括号内部填写 参数
• 多个参数之间使用 , 分隔

8
1
def sum_2_num(num1, num2):
2
​
3
    result = num1 + num2
4
    
5
    print("%d + %d = %d" % (num1, num2, result))
6
​
7
sum_2_num(50, 20)
8
​

参数的作用

• 函数，把 具有独立功能的代码块 组织为一个小模块，在需要的时候 调用

• 函数的参数，增加函数的 通用性，针对 相同的数据处理逻辑，能够 适应更多的数据

  1. 在函数 内部，把参数当做 变量 使用，进行需要的数据处理
  2. 函数调用时，按照函数定义的参数顺序，把 希望在函数内部处理的数据，通过参数 传递

形参和实参

• 形参：定义 函数时，小括号中的参数，是用来接收参数用的，在函数内部 作为变量使用
• 实参：调用 函数时，小括号中的参数，是用来把数据传递到 函数内部 用的

函数的返回值

• 在程序开发中，有时候，会希望 一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
• 返回值 是函数 完成工作后，最后 给调用者的 一个结果
• 在函数中使用 return 关键字可以返回结果
• 调用函数一方，可以 使用变量 来 接收 函数的返回结果

注意：return 表示返回，后续的代码都不会被执行

10
1
def sum_2_num(num1, num2):
2
    """对两个数字的求和"""
3
​
4
    return num1 + num2
5
​
6
# 调用函数，并使用 result 变量接收计算结果
7
result = sum_2_num(10, 20)
8
​
9
print("计算结果是 %d" % result)
10
​

函数的嵌套调用

• 一个函数里面 又调用 了 另外一个函数，这就是 函数嵌套调用

• 如果函数 test2 中，调用了另外一个函数 test1

  • 那么执行到调用 test1 函数时，会先把函数 test1 中的任务都执行完
  • 才会回到 test2 中调用函数 test1 的位置，继续执行后续的代码

18
1
def test1():
2
​
3
    print("*" * 50)
4
    print("test 1")
5
    print("*" * 50)
6
​
7
​
8
def test2():
9
​
10
    print("-" * 50)
11
    print("test 2")
12
    
13
    test1()
14
    
15
    print("-" * 50)
16
​
17
test2()
18
​

函数的模块化使用

模块是 Python 程序架构的一个核心概念

• 模块 就好比是 工具包，要想使用这个工具包中的工具，就需要 导入 import 这个模块
• 每一个以扩展名 py 结尾的 Python 源代码文件都是一个 模块
• 在模块中定义的 全局变量 、 函数 都是模块能够提供给外界直接使用的工具

第一个模块体验

步骤

• 新建 cm_10_分隔线模块.py

  • 复制 cm_09_打印多条分隔线.py 中的内容，最后一行 print 代码除外
  • 增加一个字符串变量

1
1
name = "hello world"

• 新建 hm_10_体验模块.py 文件，并且编写以下代码：

4
1
isinstanceimport cm_10_分隔线模块
2
​
3
cm_10_分隔线模块.print_line("-", 80)
4
print(cm_10_分隔线模块.name)

体验小结

• 可以 在一个 Python 文件 中 定义 变量 或者 函数
• 然后在 另外一个文件中 使用 import 导入这个模块
• 导入之后，就可以使用 模块名.变量 / 模块名.函数 的方式，使用这个模块中定义的变量或者函数

模块可以让 曾经编写过的代码 方便的被 复用！

模块名也是一个标识符

• 标示符可以由 字母、下划线 和 数字 组成
• 不能以数字开头
• 不能与关键字重名

注意：如果在给 Python 文件起名时，以数字开头 是无法在 PyCharm 中通过导入这个模块的

函数进阶

01. 函数参数和返回值的作用

函数根据 有没有参数 以及 有没有返回值，可以 相互组合，一共有 4 种 组合形式

1. 无参数，无返回值
2. 无参数，有返回值
3. 有参数，无返回值
4. 有参数，有返回值

定义函数时，是否接收参数，或者是否返回结果，是根据 实际的功能需求 来决定的！

1. 如果函数 内部处理的数据不确定，就可以将外界的数据以参数传递到函数内部
2. 如果希望一个函数 执行完成后，向外界汇报执行结果，就可以增加函数的返回值

02. 函数的返回值

• 在程序开发中，有时候，会希望 一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
• 返回值 是函数 完成工作后，最后 给调用者的 一个结果
• 在函数中使用 return 关键字可以返回结果
• 调用函数一方，可以 使用变量 来 接收 函数的返回结果

问题：一个函数执行后能否返回多个结果？

示例 —— 温度和湿度测量

• 假设要开发一个函数能够同时返回当前的温度和湿度
• 先完成返回温度的功能如下：

11
1
def measure():
2
    """返回当前的温度"""
3
    
4
    print("开始测量...")
5
    temp = 39
6
    print("测量结束...")
7
    
8
    return temp
9
​
10
result = measure()
11
print(result)

• 在利用 元组 在返回温度的同时，也能够返回 湿度
• 改造如下：

9
1
def measure():
2
    """返回当前的温度"""
3
​
4
    print("开始测量...")
5
    temp = 39
6
    wetness = 10
7
    print("测量结束...")
8
​
9
    return (temp, wetness)

提示：如果一个函数返回的是元组，括号可以省略

技巧

• 在 Python 中，可以 将一个元组 使用 赋值语句 同时赋值给 多个变量
• 注意：变量的数量需要和元组中的元素数量保持一致

1
1
result = temp, wetness = measure()

03. 函数的参数

不可变和可变的参数

问题 1：在函数内部，针对参数使用 赋值语句，会不会影响调用函数时传递的 实参变量？ —— 不会！

• 无论传递的参数是 可变 还是 不可变

  • 只要 针对参数 使用 赋值语句，会在 函数内部 修改 局部变量的引用，不会影响到 外部变量的引用

问题 2：如果传递的参数是 可变类型，在函数内部，使用 方法 修改了数据的内容，同样会影响到外部的数据

在 python 中，列表变量调用 += 本质上是在执行列表变量的 extend 方法，不会修改变量的引用

缺省参数

• 定义函数时，可以给 某个参数 指定一个默认值，具有默认值的参数就叫做 缺省参数
• 调用函数时，如果没有传入 缺省参数 的值，则在函数内部使用定义函数时指定的 参数默认值
• 函数的缺省参数，将常见的值设置为参数的缺省值，从而 简化函数的调用
• 例如：对列表排序的方法

9
1
gl_num_list = [6, 3, 9]
2
​
3
# 默认就是升序排序，因为这种应用需求更多
4
gl_num_list.sort()
5
print(gl_num_list)
6
​
7
# 只有当需要降序排序时，才需要传递 `reverse` 参数
8
gl_num_list.sort(reverse=True)
9
print(gl_num_list)

指定函数的缺省参数

• 在参数后使用赋值语句，可以指定参数的缺省值

7
1
def print_info(name, gender=True):
2
​
3
    gender_text = "男生"
4
    if not gender:
5
        gender_text = "女生"
6
​
7
    print("%s 是 %s" % (name, gender_text))

提示

1. 缺省参数，需要使用 最常见的值 作为默认值！
2. 如果一个参数的值 不能确定，则不应该设置默认值，具体的数值在调用函数时，由外界传递！

缺省参数的注意事项

1) 缺省参数的定义位置

• 必须保证 带有默认值的缺省参数 在参数列表末尾
• 所以，以下定义是错误的！

1
1
def print_info(name, gender=True, title):

2) 调用带有多个缺省参数的函数

• 在 调用函数时，如果有 多个缺省参数，需要指定参数名，这样解释器才能够知道参数的对应关系！

21
1
def print_info(name, title="", gender=True):
2
    """
3
​
4
    :param title: 职位
5
    :param name: 班上同学的姓名
6
    :param gender: True 男生 False 女生
7
    """
8
​
9
    gender_text = "男生"
10
​
11
    if not gender:
12
        gender_text = "女生"
13
​
14
    print("%s%s 是 %s" % (title, name, gender_text))
15
​
16
​
17
# 提示：在指定缺省参数的默认值时，应该使用最常见的值作为默认值！
18
print_info("小明")
19
print_info("老王", title="班长")
20
print_info("小美", gender=False)
21
​

多值参数（知道）

定义支持多值参数的函数

• 有时可能需要 一个函数 能够处理的参数 个数 是不确定的，这个时候，就可以使用 多值参数

• python 中有 两种 多值参数：

  • 参数名前增加 一个 * 可以接收 元组
  • 参数名前增加 两个 * 可以接收 字典

• 一般在给多值参数命名时，习惯使用以下两个名字

  • *args —— 存放 元组 参数，前面有一个 *
  • **kwargs —— 存放 字典 参数，前面有两个 *

• args 是 arguments 的缩写，有变量的含义

• kw 是 keyword 的缩写，kwargs 可以记忆 键值对参数

9
1
def demo(num, *args, **kwargs):
2
​
3
    print(num)
4
    print(args)
5
    print(kwargs)
6
​
7
​
8
demo(1, 2, 3, 4, 5, name="小明", age=18, gender=True)
9
​

提示：多值参数 的应用会经常出现在网络上一些大牛开发的框架中，知道多值参数，有利于我们能够读懂大牛的代码

多值参数案例 —— 计算任意多个数字的和

需求

1. 定义一个函数 sum_numbers，可以接收的 任意多个整数
2. 功能要求：将传递的 所有数字累加 并且返回累加结果

10
1
def sum_numbers(*args):
2
​
3
    num = 0
4
    # 遍历 args 元组顺序求和
5
    for n in args:
6
        num += n
7
​
8
    return num
9
​
10
print(sum_numbers(1, 2, 3))

元组和字典的拆包（知道）

• 在调用带有多值参数的函数时，如果希望：

  • 将一个 元组变量，直接传递给 args
  • 将一个 字典变量，直接传递给 kwargs

• 就可以使用 拆包，简化参数的传递，拆包 的方式是：

  • 在 元组变量前，增加 一个 *
  • 在 字典变量前，增加 两个 *

14
1
def demo(*args, **kwargs):
2
​
3
    print(args)
4
    print(kwargs)
5
​
6
​
7
# 需要将一个元组变量/字典变量传递给函数对应的参数
8
gl_nums = (1, 2, 3)
9
gl_xiaoming = {"name": "小明", "age": 18}
10
​
11
# 会把 num_tuple 和 xiaoming 作为元组传递个 args
12
# demo(gl_nums, gl_xiaoming)
13
demo(*gl_nums, **gl_xiaoming)
14
​

04. 函数的递归

函数调用自身的 编程技巧 称为递归

4.1 递归函数的特点

特点

• 一个函数 内部 调用自己

  • 函数内部可以调用其他函数，当然在函数内部也可以调用自己

代码特点

1. 函数内部的 代码 是相同的，只是针对 参数 不同，处理的结果不同

2. 当 参数满足一个条件 时，函数不再执行

   • 这个非常重要，通常被称为递归的出口，否则 会出现死循环！

示例代码

12
1
def sum_numbers(num):
2
​
3
    print(num)
4
    
5
    # 递归的出口很重要，否则会出现死循环
6
    if num == 1:
7
        return
8
​
9
    sum_numbers(num - 1)
10
    
11
sum_numbers(3)
12
​

4.2 递归案例 —— 计算数字累加

需求

1. 定义一个函数 sum_numbers
2. 能够接收一个 num 的整数参数
3. 计算 1 + 2 + … num 的结果

13
1
def sum_numbers(num):
2
​
3
    if num == 1:
4
        return 1
5
    
6
    # 假设 sum_numbers 能够完成 num - 1 的累加
7
    temp = sum_numbers(num - 1)
8
​
9
    # 函数内部的核心算法就是 两个数字的相加
10
    return num + temp
11
​
12
print(sum_numbers(2))
13
​

提示：递归是一个 编程技巧，初次接触递归会感觉有些吃力！在处理 不确定的循环条件时，格外的有用，例如：遍历整个文件目录的结构

高级变量类型

目标

• 列表
• 元组
• 字典
• 字符串
• 公共方法
• 变量高级

知识点回顾

• Python 中数据类型可以分为 数字型 和 非数字型

• 数字型

  • 整型 (int)

  • 浮点型（float）

  • 布尔型（bool）

    • 真 True 非 0 数 —— 非零即真
    • 假 False 0

  • 复数型 (complex)

    • 主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题

• 非数字型

  • 字符串
  • 列表
  • 元组
  • 字典

• 在 Python 中，所有 非数字型变量 都支持以下特点：

  1. 都是一个 序列 sequence，也可以理解为 容器
  2. 取值 []
  3. 遍历 for in
  4. 计算长度、最大/最小值、比较、删除
  5. 链接 + 和 重复 *
  6. 切片

01. 列表

1.1 列表的定义

• List（列表） 是 Python 中使用 最频繁 的数据类型，在其他语言中通常叫做 数组

• 专门用于存储 一串 信息

• 列表用 [] 定义，数据 之间使用 , 分隔

• 列表的 索引 从 0 开始

  • 索引 就是数据在 列表 中的位置编号，索引 又可以被称为 下标

注意：从列表中取值时，如果 超出索引范围，程序会报错

1
1
name_list = ["zhangsan", "lisi", "wangwu"]

1.2 列表常用操作

• 在 ipython3 中定义一个 列表，例如：name_list = []
• 输入 name_list. 按下 TAB 键，ipython 会提示 列表 能够使用的 方法 如下：

4
1
In [1]: name_list.
2
name_list.append   name_list.count    name_list.insert   name_list.reverse
3
name_list.clear    name_list.extend   name_list.pop      name_list.sort
4
name_list.copy     name_list.index    name_list.remove 

1.3 del 关键字（科普）

• 使用 del 关键字(delete) 同样可以删除列表中元素
• del 关键字本质上是用来 将一个变量从内存中删除的
• 如果使用 del 关键字将变量从内存中删除，后续的代码就不能再使用这个变量了

1
1
del name_list[1]

在日常开发中，要从列表删除数据，建议 使用列表提供的方法

1.4 关键字、函数和方法（科普）

• 关键字 是 Python 内置的、具有特殊意义的标识符

3
1
In [1]: import keyword
2
In [2]: print(keyword.kwlist)
3
In [3]: print(len(keyword.kwlist))

关键字后面不需要使用括号

• 函数 封装了独立功能，可以直接调用

1
1
函数名(参数)

函数需要死记硬背

• 方法 和函数类似，同样是封装了独立的功能
• 方法 需要通过 对象 来调用，表示针对这个 对象 要做的操作

1
1
对象.方法名(参数)

在变量后面输入 .，然后选择针对这个变量要执行的操作，记忆起来比函数要简单很多

1.5 循环遍历

• 遍历 就是 从头到尾 依次 从 列表 中获取数据

  • 在 循环体内部 针对 每一个元素，执行相同的操作

• 在 Python 中为了提高列表的遍历效率，专门提供的 迭代 iteration 遍历

• 使用 for 就能够实现迭代遍历

6
1
# for 循环内部使用的变量 in 列表
2
for name in name_list:
3
​
4
    循环内部针对列表元素进行操作
5
    print(name)
6
​

1.6 应用场景

• 尽管 Python 的 列表 中可以 存储不同类型的数据

• 但是在开发中，更多的应用场景是

  1. 列表 存储相同类型的数据
  2. 通过 迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作

02. 元组

2.1 元组的定义

• Tuple（元组）与列表类似，不同之处在于元组的 元素不能修改

  • 元组 表示多个元素组成的序列
  • 元组 在 Python 开发中，有特定的应用场景

• 用于存储 一串 信息，数据 之间使用 , 分隔

• 元组用 () 定义

• 元组的 索引 从 0 开始

  • 索引 就是数据在 元组 中的位置编号

1
1
info_tuple = ("zhangsan", 18, 1.75)

创建空元组

1
1
info_tuple = ()

只包含一个元素

元组中 只包含一个元素 时，需要 在元素后面添加逗号

1
1
info_tuple = (50, )

2.2 元组常用操作

• 在 ipython3 中定义一个 元组，例如：info = ()
• 输入 info. 按下 TAB 键，ipython 会提示 元组 能够使用的函数如下：

1
1
info.count  info.index

有关 元组 的 常用操作 可以参照上图练习

2.3 循环遍历

• 取值 就是从 元组 中获取存储在指定位置的数据
• 遍历 就是 从头到尾 依次 从 元组 中获取数据

6
1
# for 循环内部使用的变量 in 元组
2
for item in info:
3
​
4
    循环内部针对元组元素进行操作
5
    print(item)
6
​

• 在 Python 中，可以使用 for 循环遍历所有非数字型类型的变量：列表、元组、字典 以及 字符串
• 提示：在实际开发中，除非 能够确认元组中的数据类型，否则针对元组的循环遍历需求并不是很多

2.4 应用场景

• 尽管可以使用 for in 遍历 元组

• 但是在开发中，更多的应用场景是：

  • 函数的 参数 和 返回值，一个函数可以接收 任意多个参数，或者 一次返回多个数据

    • 有关 函数的参数 和 返回值，在后续 函数高级 给大家介绍

  • 格式字符串，格式化字符串后面的 () 本质上就是一个元组

  • 让列表不可以被修改，以保护数据安全

4
1
info = ("zhangsan", 18)
2
​
3
print("%s 的年龄是 %d" % info)
4
​

元组和列表之间的转换

• 使用 list 函数可以把元组转换成列表

1
1
list(元组) 

• 使用 tuple 函数可以把列表转换成元组

1
1
tuple(列表)

03. 字典

字典的定义

• dictionary（字典） 是 除列表以外 Python 之中 最灵活 的数据类型

• 字典同样可以用来 存储多个数据

  • 通常用于存储 描述一个 物体 的相关信息

• 和列表的区别

  • 列表 是 有序 的对象集合
  • 字典 是 无序 的对象集合

• 字典用 {} 定义

• 字典使用 键值对 存储数据，键值对之间使用 , 分隔

  • 键 key 是索引

  • 值 value 是数据

  • 键 和 值 之间使用 : 分隔

  • 键必须是唯一的

  • 值 可以取任何数据类型，但 键 只能使用 字符串、数字或 元组

  • 获取键值对只能用括号运算符（不能用点运算符）

    7
    1
    xiaoming = {"name": "小明",
    2
                "age": 18,
    3
                "gender": True,
    4
                "height": 1.75}
    5
    ​
    6
    xiaoming["name"]   --> “小明”
    7
    xiaoming.name      --> error
    

     

4
1
xiaoming = {"name": "小明",
2
            "age": 18,
3
            "gender": True,
4
            "height": 1.75}

3.2 字典常用操作

• 在 ipython3 中定义一个 字典，例如：xiaoming = {}
• 输入 xiaoming. 按下 TAB 键，ipython 会提示 字典 能够使用的函数如下：

5
1
In [1]: xiaoming.
2
xiaoming.clear       xiaoming.items       xiaoming.setdefault
3
xiaoming.copy        xiaoming.keys        xiaoming.update
4
xiaoming.fromkeys    xiaoming.pop         xiaoming.values
5
xiaoming.get         xiaoming.popitem    

有关 字典 的 常用操作 可以参照上图练习

3.3 循环遍历

• 遍历 就是 依次 从 字典 中获取所有键值对

4
1
# for 循环内部使用的 `key 的变量` in 字典
2
for k in xiaoming:
3
​
4
    print("%s: %s" % (k, xiaoming[k]))