文章目录
一、认识Python
1、Python起源
人生苦短,我用 Python (Life is short, you need Python)
Python创始人吉多·范罗苏姆(Guido van Rossum)
- 1989 年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的解释程序,作为 ABC 语言的一种继承(感觉下什么叫牛人)
- ABC 是由吉多参加设计的一种教学语言,就吉多本人看来,ABC 这种语言非常优美和强大,是专门为非专业程序员设计的。但是 ABC 语言并没有成功,究其原因,吉多认为是非开放造成的。吉多决心在 Python 中避免这一错误,并获取了非常好的效果
- 之所以选中 Python(蟒蛇) 作为程序的名字,是因为他是 BBC 电视剧——蒙提·派森的飞行马戏团(Monty Python’s Flying Circus)的爱好者
- 1991 年,第一个 Python 解释器 诞生,它是用 C 语言实现的,并能够调用 C 语言的库文件
解释器:计算机不能直接理解任何除机器语言以外的语言,所以必须要把程序员所写的程序语言翻译成机器语言,计算机才能执行程序。将其他语言翻译成机器语言的工具,被称为编译器
编译器翻译的两种方式:一个是编译,另外一个是解释。两种方式之间的区别在于翻译时间点的不同。当编译器以解释方式运行的时候,也称之为解释器
编译型语言:程序在执行之前需要一个专门的编译过程,把程序编译成为机器语言的文件,运行时不需要重新翻译,直接使用编译的结果就行了。程序执行效率高,依赖编译器,跨平台性差些。如 C、C++
解释型语言:解释型语言编写的程序不进行预先编译,以文本方式存储程序代码,会将代码一句一句直接运行。在发布程序时,看起来省了道编译工序,但是在运行程序的时候,必须先解释再运行
对比:
执行速度 —— 编译型语言 > 解释型语言
跨平台性 —— 解释型语言 > 编译型语言
Python 的设计哲学:优雅、明确、简单、
同一样问题,用不同的语言解决,代码量差距还是很多的,一般情况下 Python
是 Java
的 1/5。
2、语言特点
- Python 是完全面向对象的语言
- 函数、模块、数字、字符串都是对象,在 Python 中一切皆对象
- 完全支持继承、重载、多重继承
- 支持重载运算符,也支持泛型设计
- Python 拥有一个强大的标准库,核心包含 数字、字符串、列表、字典、文件 等常见类型和函数,而由 Python 标准库提供了 系统管理、网络通信、文本处理、数据库接口、图形系统、XML 处理 等额外的功能
- Python 社区提供了大量的第三方模块,使用方式与标准库类似。它们的功能覆盖 科学计算、人工智能、机器学习、Web 开发、数据库接口、图形系统 多个领域
面向对象的思维方式:
- 面向对象 是一种 思维方式,也是一门 程序设计技术
- 要解决一个问题前,首先考虑 由谁 来做,怎么做事情是 谁 (对象 )的职责,最后把事情做好。
- 要解决复杂的问题,就可以找多个不同的对象,各司其职,共同实现,最终完成需求
3、优缺点
优点:面向对象、丰富的库、可扩展性 , 缺点:运行速度。
可扩展性:如果需要一段关键代码运行得更快或者希望某些算法不公开,可以把这部分程序用 C
或 C++
编写,然后在 Python
程序中使用它们
4、HelloPython
linux环境下演示操作
【1】源程序
创建HelloPython.py文件,书写下面的内容,解释器运行之。
$ python HelloPython.py
print("hello python")
print("hello world")
Python 源程序就是一个特殊格式的文本文件,可以使用任意文本编辑软件做 Python
的开发。
Python 程序的 文件扩展名 通常都是 .py
。
【2】Python 2.x 与 3.x版本简介
- Python 2.x 是 过去的版本
- 解释器名称是 python
- 默认不支持中文
- Python 3.x 是 现在和未来 主流的版本
- 解释器名称是 python3
- 相对于
Python
的早期版本,这是一个 较大的升级 - 为了不带入过多的累赘,
Python 3.0
在设计的时候 没有考虑向下兼容- 许多早期
Python
版本设计的程序都无法在Python 3.0
上正常执行
- 许多早期
- Python 3.0 发布于 2008 年
- 到目前为止,Python 3.0 的稳定版本已经有很多年了
- Python 3.3 发布于 2012
- Python 3.4 发布于 2014
- Python 3.5 发布于 2015
- Python 3.6 发布于 2016
- 为了照顾现有的程序,官方提供了一个过渡版本 —— Python 2.6
- 基本使用了
Python 2.x
的语法和库 - 同时考虑了向
Python 3.0
的迁移,允许使用部分Python 3.0
的语法与函数 - 2010 年中推出的
Python 2.7
被确定为 最后一个Python 2.x 版本
- 基本使用了
如果开发时,无法立即使用 Python 3.0(还有极少的第三方库不支持 3.0 的语法)
建议:
- 先使用
Python 3.0
版本进行开发- 然后使用
Python 2.6
、Python 2.7
来执行,并且做一些兼容性的处理
【3】执行 Python 程序方式
1) 解释器
Python 的解释器 如今有多个语言的实现,包括:
CPython
—— 官方版本的 C 语言实现Jython
—— 可以运行在 Java 平台IronPython
—— 可以运行在 .NET 和 Mono 平台PyPy
—— Python 实现的,支持 JIT 即时编译
# 使用 python 2.x 解释器
$ python xxx.py
# 使用 python 3.x 解释器
$ python3 xxx.py
2) 交互式运行
在 Python 的 Shell
中直接输入 Python 的代码,会立即看到程序执行结果
代码不能保存,不适合运行太大的程序,退出直接输入 exit()
或ctrl + d
3) IPython
IPython 中 的 “I” 代表 交互 interactive
IPython 是一个 python 的 交互式 shell,比默认的 python shell
好用得多,基于 BSD 开源。
- Python 2.x 使用的解释器是 ipython
- Python 3.x 使用的解释器是 ipython3
【4】程序执行原理
计算机中的三大件:
1. CPU
* 中央处理器,是一块超大规模的集成电路
* 负责处理数据/计算
2. 内存
* 临时 存储数据(断电之后,数据会消失)
* 速度快
* 空间小(单位价格高)
3. 硬盘
* 永久 存储数据
* 速度慢
* 空间大(单位价格低)
程序的作用:程序就是 用来处理数据的。
新闻软件提供的 **新闻内容、评论……** 是数据
电商软件提供的 **商品信息、配送信息……** 是数据
即时通讯软件提供的 **聊天信息、好友信息……** 是数据
程序执行的原理
- 程序 运行之前,程序是 保存在硬盘 中的
- 当要运行一个程序时
- 操作系统会首先让 CPU 把程序复制到 内存 中
- CPU 执行 内存 中的 程序代码
Python 程序执行原理
- 操作系统会首先让 CPU 把 Python 解释器 的程序复制到 内存 中
- Python 解释器 根据语法规则,从上向下 让 CPU 翻译 Python 程序中的代码
- CPU 负责执行翻译完成的代码
【5】PyCharm 开发工具
PyCharm 的官方网站地址是:https://www.jetbrains.com/pycharm/
专业版下载地址:https://www.jetbrains.com/pycharm/download/#section=linux
二、Python起程
任何语言的程序员,编写出符合规范的代码,是开始程序生涯的第一步
关于代码规范:
Python
官方提供有一系列 PEP(Python Enhancement Proposals) 文档,
其中第 8 篇文档专门针对 Python 的代码格式 给出了建议,也就是俗称的 PEP 8
PEP 8中文文档:http://zh-google-styleguide.readthedocs.io/en/latest/google-python-styleguide/python_style_rules/
1、注释
【1】单行注释(行注释)
#
后面建议先添加一个空格,保证代码的可读性
# 这是第一个单行注释
print("hello python")
保证代码的可读性**,**注释和代码之间 至少要有 两个空格
print("hello python") # 输出 `hello python`
【2】多行注释(块注释)
用 一对 连续的 三个 引号(单引号和双引号都可以)
"""
这是一个多行注释
在多行注释之间,可以写很多很多的内容……
"""
print("hello python")
【3】函数的文档注释
- 在开发中,如果希望给函数添加注释,应该在 定义函数 的下方,使用 连续的三对引号
- 在 连续的三对引号 之间编写对函数的说明文字
- 在 函数调用 位置,使用快捷键
Ctrl + Q
可以查看函数的说明信息
【4】什么时候使用注释
(注释不是越多越好)
一目了然的代码,不需要添加注释
非一目了然的代码,应在其行尾添加注释
复杂的操作,应该在操作开始前写上若干行注释
2、变量
程序是用来处理数据的,而变量是用来存储数据的
【1】变量的命名
1)标示符
程序员定义的 变量名、函数名,名字 需要有 见名知义 的效果。
- 标示符可以由 字母、下划线 和 数字 组成
- 不能以数字开头,(字母、下划线可以开头)
- 不能与关键字重名
2)关键字
- 关键字 就是在
Python
内部已经使用的标识符 - 关键字 具有特殊的功能和含义
- 开发者 不允许定义和关键字相同的名字的标示符
In [1]: import keyword
In [2]: print(keyword.kwlist)
In [3]: print(len(keyword.kwlist))
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kBE1vedK-1625660757637)(Python基础语法.assets/image-20210707140408737.png)]
3)变量的命名规则
Python
中的 标识符 是 区分大小写的
-
在定义变量时,为了保证代码格式,
=
的左右应该各保留一个空格 -
在
Python
中,如果 变量名 需要由 二个 或 多个单词 组成时,可以按照以下方式命名- 每个单词都使用小写字母
- 单词与单词之间使用
_
下划线 连接
- 例如:
first_name
、last_name
、qq_number
、qq_password
【2】变量定义
变量名 = 值
在 Python 中,每个变量 在使用前都必须赋值,变量 赋值以后 该变量 才会被创建
# 定义 qq 号码变量
qq_number = "1234567"
# 定义 qq 密码变量
qq_password = "123"
# 在程序中,如果要输出变量的内容,需要使用 print 函数
print(qq_number)
print(qq_password)
=====================================================
# 定义苹果价格变量
price = 8.5
# 定义购买重量
weight = 7.5
# 计算金额
money = price * weight
print(money)
【3】变量的类型
- 在
Python
中定义变量是 不需要指定类型(在其他很多高级语言中都需要) - 数据类型可以分为 数字型 和 非数字型
- 数字型 4
- 整型 (
int
) - 浮点型(
float
) - 布尔型(
bool
)- 真
True
非 0 数
—— 非零即真 - 假
False
0
- 真
- 复数型 (
complex
)- 主要用于科学计算,例如:平面场问题、波动问题、电感电容等问题
- 整型 (
- **非数字型 ** 4
- 字符串
- 列表
- 元组
- 字典
提示:在 Python 2.x 中,整数 根据保存数值的长度还分为:
int
(整数)long
(长整数)
- 使用
type
函数可以查看一个变量的类型 type(name)
【4】不同类型变量之间的计算
-
数字型变量之间可以直接计算
如果变量是
bool
型,在计算时:True
对应的数字是1
,False
对应的数字是0
-
字符串变量之间使用
+
拼接字符串 -
字符串变量 可以和 整数 使用
*
重复拼接相同的字符串
注意: 数字型变量 和 字符串 之间 不能进行其他计算
first_name = "zhang"
x = 10
x + first_name
-------------------------------
TypeError: unsupported operand type(s) for +: 'int' and 'str'
【5】变量常用函数
函数 | 说明 |
---|---|
print(x) | 将 x 输出到控制台 |
type(x) | 查看 x 的变量类型 |
字符串变量 =input(“提示信息:”) | 键盘输入 |
int(x) | 将 x 转换为一个整数 |
float(x) | 将 x 转换到一个浮点数 |
演示1
# 1. 输入苹果单价
price_str = input("请输入苹果价格:")
# 2. 要求苹果重量
weight_str = input("请输入苹果重量:")
# 3. 计算金额
# 1> 将苹果单价转换成小数(浮点数)
price = float(price_str)
# 2> 将苹果重量转换成小数
weight = float(weight_str)
# 3> 计算付款金额
money = price * weight
# 输出打印金额
print(money)
演示2(函数能够嵌套使用)
定义 一个 浮点变量 接收用户输入的同时使用 float
函数进行转换
price = float(input("请输入价格:"))
weight = float(input("请输入苹果重量:"))
money = price * weight
print(money)
【6】变量的格式化输出
如果希望输出文字信息的同时,一起输出 数据,就需要使用到 格式化操作符
%
被称为 格式化操作符,专门用于处理字符串中的格式
- 包含
%
的字符串,被称为 格式化字符串 %
和不同的 字符 连用,不同类型的数据 需要使用 不同的格式化字符
格式化字符 | 含义 |
---|---|
%s | 字符串 |
%d | 有符号十进制整数,%06d 表示输出的整数显示位数,不足的地方使用 0 补全 |
%f | 浮点数,%.2f 表示小数点后只显示两位 |
%% | 输出 % |
print("苹果单价 %.02f 元/斤,购买 %.02f 斤,需要支付 %.02f 元" % (price, weight, money))
print("数据比例是 %.02f%%" % (scale * 100))
name = input("请输入姓名:")
company = input("请输入公司:")
title = input("请输入职位:")
phone = input("请输入电话:")
email = input("请输入邮箱:")
print("*" * 50)
print(company)
print()
print("%s (%s)" % (name, title))
print()
print("电话:%s" % phone)
print("邮箱:%s" % email)
print("*" * 50)
【7】高级变量类型
1)列表
List
(列表) 是Python
中使用 最频繁 的数据类型,在其他语言中通常叫做 数组- 专门用于存储 一串 信息
- 列表用
[]
定义,数据 之间使用,
分隔 - 列表的 索引 从
0
开始- 索引 就是数据在 列表 中的位置编号,索引 又可以被称为 下标
注意:从列表中取值时,如果 超出索引范围,程序会报错
![image-20210707135858083](https://i-blog.csdnimg.cn/blog_migrate/8a4c9ffd7b34e055973d5a409b570ceb.png)
列表常用操作
在 ipython3
中定义一个 列表,例如:name_list = []
输入 name_list.
按下 TAB
键,ipython
会提示 列表 能够使用的 方法 如下
name_list = ["zhangsan", "lisi", "wangwu"]
name_list.append name_list.count name_list.insert name_list.reverse
name_list.clear name_list.extend name_list.pop name_list.sort
name_list.copy name_list.index name_list.remove
应用场景
- 尽管
Python
的 列表 中可以 存储不同类型的数据 - 但是在开发中,更多的应用场景是
- 列表 存储相同类型的数据
- 通过 迭代遍历,在循环体内部,针对列表中的每一项元素,执行相同的操作
2)元组
Tuple
(元组)与列表类似,不同之处在于元组的 元素不能修改- 元组 表示多个元素组成的序列
- 元组 在
Python
开发中,有特定的应用场景
- 用于存储 一串 信息,数据 之间使用
,
分隔 - 元组用
()
定义 - 元组的 索引 从
0
开始- 索引 就是数据在 元组 中的位置编号
# 创建空元组
info_tuple = ()
# 元组中 只包含一个元素时,需要 **在元素后面添加逗号**
info_tuple = (50, )
# 元组中 包含多个元素时
info_tuple = ("zhangsan", 18, 1.75)
元组操作
- 在
ipython3
中定义一个 元组,例如:info = ()
- 输入
info.
按下TAB
键,ipython
会提示 元组 能够使用的函数如下:
info.count info.index
应用场景
- 尽管可以使用
for in
遍历 元组 - 但是在开发中,更多的应用场景是:
- 函数的 参数 和 返回值,一个函数可以接收 任意多个参数,或者 一次返回多个数据
- 有关 函数的参数 和 返回值,在后续 函数高级 给大家介绍
- 格式字符串,格式化字符串后面的
()
本质上就是一个元组 - 让列表不可以被修改,以保护数据安全
- 函数的 参数 和 返回值,一个函数可以接收 任意多个参数,或者 一次返回多个数据
info = ("zhangsan", 18)
print("%s 的年龄是 %d" % info)
3)字典
dictionary
(字典) 是 除列表以外Python
之中 最灵活 的数据类型- 字典同样可以用来 存储多个数据
- 通常用于存储 描述一个
物体
的相关信息
- 通常用于存储 描述一个
- 和列表的区别
- 列表 是 有序 的对象集合
- 字典 是 无序 的对象集合
- 字典用
{}
定义 - 字典使用 键值对 存储数据,键值对之间使用
,
分隔- 键
key
是索引 - 值
value
是数据 - 键 和 值 之间使用
:
分隔 - 键必须是唯一的
- 值 可以取任何数据类型,但 键 只能使用 字符串、数字或 元组
- 键
student = {"name": "小明",
"age": 18,
"gender": True,
"height": 1.75}
字典常用操作
- 在
ipython3
中定义一个 字典,例如:student= {}
- 输入
student.
按下TAB
键,ipython
会提示 字典 能够使用的函数如下:
![image-20210707142746328](https://i-blog.csdnimg.cn/blog_migrate/af742946a34fbf9729bb913dc45b8a58.png)
# for 循环内部使用的 `key 的变量` in 字典
for k in student:
print("%s: %s" % (k, student[k])
应用场景
- 尽管可以使用
for in
遍历 字典 - 但是在开发中,更多的应用场景是:
- 使用 多个键值对,存储 描述一个
物体
的相关信息 —— 描述更复杂的数据信息 - 将 多个字典 放在 一个列表 中,再进行遍历,在循环体内部针对每一个字典进行 相同的处理
- 使用 多个键值对,存储 描述一个
card_list = [{"name": "张三",
"qq": "12345",
"phone": "110"},
{"name": "李四",
"qq": "54321",
"phone": "10086"}
]
4)字符串
- 字符串 就是 一串字符,是编程语言中表示文本的数据类型
- 在 Python 中可以使用 一对双引号
"
或者 一对单引号'
定义一个字符串- 虽然可以使用
\"
或者\'
做字符串的转义,但是在实际开发中:- 如果字符串内部需要使用
"
,可以使用'
定义字符串 - 如果字符串内部需要使用
'
,可以使用"
定义字符串
- 如果字符串内部需要使用
- 虽然可以使用
- 可以使用 索引 获取一个字符串中 指定位置的字符,索引计数从 0 开始
- 也可以使用
for
循环遍历 字符串中每一个字符
大多数编程语言都是用
"
来定义字符串
string = "Hello Python"
for c in string:
print(c)
字符串的常用操作
- 在
ipython3
中定义一个 字符串,例如:hello_str = ""
- 输入
hello_str.
按下TAB
键,ipython
会提示 字符串 能够使用的 方法 如下:
提示:正是因为 python 内置提供的方法足够多,才使得在开发时,能够针对字符串进行更加灵活的操作!应对更多的开发需求!
1) 判断类型 - 9
方法 | 说明 |
---|---|
string.isspace() | 如果 string 中只包含空格,则返回 True |
string.isalnum() | 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True |
string.isalpha() | 如果 string 至少有一个字符并且所有字符都是字母则返回 True |
string.isdecimal() | 如果 string 只包含数字则返回 True,全角数字 |
string.isdigit() | 如果 string 只包含数字则返回 True,全角数字 、⑴ 、\u00b2 |
string.isnumeric() | 如果 string 只包含数字则返回 True,全角数字 ,汉字数字 |
string.istitle() | 如果 string 是标题化的(每个单词的首字母大写)则返回 True |
string.islower() | 如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回 True |
string.isupper() | 如果 string 中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是大写,则返回 True |
2) 查找和替换 - 7
方法 | 说明 |
---|---|
string.startswith(str) | 检查字符串是否是以 str 开头,是则返回 True |
string.endswith(str) | 检查字符串是否是以 str 结束,是则返回 True |
string.find(str, start=0, end=len(string)) | 检测 str 是否包含在 string 中,如果 start 和 end 指定范围,则检查是否包含在指定范围内,如果是返回开始的索引值,否则返回 -1 |
string.rfind(str, start=0, end=len(string)) | 类似于 find(),不过是从右边开始查找 |
string.index(str, start=0, end=len(string)) | 跟 find() 方法类似,不过如果 str 不在 string 会报错 |
string.rindex(str, start=0, end=len(string)) | 类似于 index(),不过是从右边开始 |
string.replace(old_str, new_str, num=string.count(old)) | 把 string 中的 old_str 替换成 new_str,如果 num 指定,则替换不超过 num 次 |
3) 大小写转换 - 5
方法 | 说明 |
---|---|
string.capitalize() | 把字符串的第一个字符大写 |
string.title() | 把字符串的每个单词首字母大写 |
string.lower() | 转换 string 中所有大写字符为小写 |
string.upper() | 转换 string 中的小写字母为大写 |
string.swapcase() | 翻转 string 中的大小写 |
4) 文本对齐 - 3
方法 | 说明 |
---|---|
string.ljust(width) | 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串 |
string.rjust(width) | 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串 |
string.center(width) | 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串 |
5) 去除空白字符 - 3
方法 | 说明 |
---|---|
string.lstrip() | 截掉 string 左边(开始)的空白字符 |
string.rstrip() | 截掉 string 右边(末尾)的空白字符 |
string.strip() | 截掉 string 左右两边的空白字符 |
6) 拆分和连接 - 5
方法 | 说明 |
---|---|
string.partition(str) | 把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面) |
string.rpartition(str) | 类似于 partition() 方法,不过是从右边开始查找 |
string.split(str="", num) | 以 str 为分隔符拆分 string,如果 num 有指定值,则仅分隔 num + 1 个子字符串,str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格 |
string.splitlines() | 按照行(’\r’, ‘\n’, ‘\r\n’)分隔,返回一个包含各行作为元素的列表 |
string.join(seq) | 以 string 作为分隔符,将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
5)切片操作
切片 方法适用于 字符串、列表、元组
- 切片 使用 索引值 来限定范围,从一个大的 字符串 中 切出 小的 字符串
- 列表 和 元组 都是 有序 的集合,都能够 通过索引值 获取到对应的数据
- 字典 是一个 无序 的集合,是使用 键值对 保存数据
字符串[开始索引:结束索引:步长] `开始索引 >= 范围 < 结束索引`
- 指定的区间属于 左闭右开 型
[开始索引, 结束索引)
,从起始
位开始,到结束
位的前一位 结束(不包含结束位本身) - 从头开始,开始索引 数字可以省略,冒号不能省略
- 到末尾结束,结束索引 数字可以省略,冒号不能省略
- 步长默认为
1
,如果连续切片,数字和冒号都可以省略
索引的顺序和倒序
- 在 Python 中不仅支持 顺序索引,同时还支持 倒序索引
- 所谓倒序索引就是 从右向左 计算索引,最右边的索引值是 -1,依次递减
num_str = "0123456789"
# 1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])
# 2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])
# 3. 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])
# 4. 截取完整的字符串
print(num_str[:])
# 5. 从开始位置,每隔一个字符截取字符串
print(num_str[::2]
# 6. 从索引 1 开始,每隔一个取一个
print(num_str[1::2])
=====================================
# 倒序切片
# -1 表示倒数第一个字符
print(num_str[-1])
# 7. 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])
# 8. 截取字符串末尾两个字符
print(num_str[-2:])
# 9. 字符串的逆序(面试题)
print(num_str[::-1])
6)元组与列表的转换
- 使用
list
函数可以把元组转换成列表
list(元组)
- 使用
tuple
函数可以把列表转换成元组
tuple(列表)
7)面试题-交换两个数字
题目要求
- 有两个整数变量
a = 6
,b = 100
- 不使用其他变量,交换两个变量的值
解法 1 —— 使用其他变量
# 解法 1 - 使用临时变量
c = b
b = a
a = c
解法 2 —— 不使用临时变量
# 解法 2 - 不使用临时变量
a = a + b
b = a - b
a = a - b
解法 3 —— Python 专有,利用元组
a, b = b, a
3. 运算符
数学符号表链接:https://zh.wikipedia.org/wiki/数学符号表
【1】 算数运算符
- 是完成基本的算术运算使用的符号,用来处理四则运算
运算符 | 描述 | 实例 |
---|---|---|
+ | 加 | 10 + 20 = 30 |
- | 减 | 10 - 20 = -10 |
* | 乘 | 10 * 20 = 200 |
/ | 除 | 10 / 20 = 0.5 |
// | 取整除 | 返回除法的整数部分(商) 9 // 2 输出结果 4 |
% | 取余数 | 返回除法的余数 9 % 2 = 1 |
** | 幂 | 又称次方、乘方,2 ** 3 = 8 |
- 在 Python 中
*
运算符还可以用于字符串,计算结果就是字符串重复指定次数的结果
【2】关系运算符
运算符 | 描述 |
---|---|
== | 检查两个操作数的值是否 相等,如果是,则条件成立,返回 True |
!= | 检查两个操作数的值是否 不相等,如果是,则条件成立,返回 True |
> | 检查左操作数的值是否 大于 右操作数的值,如果是,则条件成立,返回 True |
< | 检查左操作数的值是否 小于 右操作数的值,如果是,则条件成立,返回 True |
>= | 检查左操作数的值是否 大于或等于 右操作数的值,如果是,则条件成立,返回 True |
<= | 检查左操作数的值是否 小于或等于 右操作数的值,如果是,则条件成立,返回 True |
Python 2.x 中判断 不等于 还可以使用
<>
运算符
!=
在 Python 2.x 中同样可以用来判断 不等于
【3】 逻辑运算符
运算符 | 逻辑表达式 | 描述 |
---|---|---|
and | x and y | 只有 x 和 y 的值都为 True,才会返回 True 否则只要 x 或者 y 有一个值为 False,就返回 False |
or | x or y | 只要 x 或者 y 有一个值为 True,就返回 True 只有 x 和 y 的值都为 False,才会返回 False |
not | not x | 如果 x 为 True,返回 False 如果 x 为 False,返回 True |
【4】 赋值运算符
- 在 Python 中,使用
=
可以给变量赋值 - 在算术运算时,为了简化代码的编写,
Python
还提供了一系列的 与 算术运算符 对应的 赋值运算符 - 注意:赋值运算符中间不能使用空格
运算符 | 描述 | 实例 |
---|---|---|
= | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
+= | 加法赋值运算符 | 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 |
【5】 运算符的优先级
- 以下表格的算数优先级由高到最低顺序排列
运算符 | 描述 |
---|---|
** | 幂 (最高优先级) |
* / % // | 乘、除、取余数、取整除 |
+ - | 加法、减法 |
<= < > >= | 比较运算符 |
== != | 等于运算符 |
= %= /= //= -= += *= **= | 赋值运算符 |
not or and | 逻辑运算符 |
4. 公共方法
【1】Python 内置函数
函数 | 描述 | 备注 |
---|---|---|
len(item) | 计算容器中元素个数 | |
del(item) | 删除变量 | del 有两种方式 |
max(item) | 返回容器中元素最大值 | 如果是字典,只针对 key 比较 |
min(item) | 返回容器中元素最小值 | 如果是字典,只针对 key 比较 |
cmp(item1, item2) | 比较两个值,-1 小于/0 相等/1 大于 | Python 3.x 取消了 cmp 函数 |
- 字符串 比较符合以下规则: “0” < “A” < “a”
【2】 切片
描述 | Python 表达式 | 结果 | 支持的数据类型 |
---|---|---|---|
切片 | “0123456789”[::-2] | “97531” | 字符串、列表、元组 |
- 切片 使用 索引值 来限定范围,从一个大的 字符串 中 切出 小的 字符串
- 列表 和 元组 都是 有序 的集合,都能够 通过索引值 获取到对应的数据
- 字典 是一个 无序 的集合,是使用 键值对 保存数据
【3】成员运算符
成员运算符用于 测试 序列中是否包含指定的 成员
运算符 | 描述 | 实例 |
---|---|---|
in | 如果在指定的序列中找到值返回 True,否则返回 False | 3 in (1, 2, 3) 返回 True |
not in | 如果在指定的序列中没有找到值返回 True,否则返回 False | 3 not in (1, 2, 3) 返回 False |
运算符 | 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 | 元素是否不存在 | 字符串、列表、元组、字典 |
> >= == < <= | (1, 2, 3) < (2, 2, 3) | True | 元素比较 | 字符串、列表、元组 |
in
在对 字典 操作时,判断的是 字典的键in
和not in
被称为 成员运算符
【4】身份运算符
身份运算符用于 比较 两个对象的 内存地址 是否一致 (是否是对同一个对象的引用)
在 Python
中针对 None
比较时,建议使用 is
判断
运算符 | 描述 | 实例 |
---|---|---|
is | is 是判断两个标识符是不是引用同一个对象 | x is y,类似 id(x) == id(y) |
is not | is not 是判断两个标识符是不是引用不同对象 | x is not y,类似 id(a) != id(b) |
is 与 == 区别:
is
用于判断 两个变量 引用对象是否为同一个
==
用于判断 引用变量的值 是否相等
>>> a = [1, 2, 3]
>>> b = [1, 2, 3]
>>> b is a
False
>>> b == a
True
5. if判断语句
【1】if
if
语句以及缩进部分是一个 完整的代码块
# 1. 定义年龄变量
age = 18
# 2. 判断是否满 18 岁
# if 语句以及缩进部分的代码是一个完整的代码块
if age >= 18:
print("成年了~~~")
# 3. 无论条件是否满足都会执行
print("始终执行的语句~~~")
【2】if
和 else
if
和 else
语句以及各自的缩进部分共同是一个 完整的代码块
# 1. 输入用户年龄
age = int(input("今年多大了?"))
# 2. 判断是否满 18 岁
# if 语句以及缩进部分的代码是一个完整的语法块
if age >= 18:
print("成年了, 可以自己旅行了~~~")
else:
print("你还没长大,要家长陪同!")
# 3. 思考!- 无论条件是否满足都会执行
print("始终执行的语句~~~")
【3】运算符+if语句
# 练习1: 定义一个整数变量 age,编写代码判断年龄是否正确
age = 100
# 要求人的年龄在 0-120 之间
if age >= 0 and age <= 120:
print("年龄正确")
else:
print("年龄不正确")
==================================================
# 练习2: 定义两个整数变量 python_score、c_score,编写代码判断成绩
python_score = 50
c_score = 50
# 要求只要有一门成绩 > 60 分就算合格
if python_score > 60 or c_score > 60:
print("考试通过")
else:
print("再接再厉!")
==================================================
# 练习3: 定义一个布尔型变量 `is_employee`,编写代码判断是否是本公司员工
is_employee = True
# 如果不是提示不允许入内
if not is_employee:
print("非公勿内")
【4】if 语句的嵌套、
演示1:火车站安检
# 定义布尔型变量 has_ticket 表示是否有车票
has_ticket = True
# 定义整数型变量 knife_length 表示刀的长度,单位:厘米
knife_length = 20
# 首先检查是否有车票,如果有,才允许进行 安检
if has_ticket:
print("有车票,可以开始安检...")
# 安检时,需要检查刀的长度,判断是否超过 20 厘米
# 如果超过 20 厘米,提示刀的长度,不允许上车
if knife_length >= 20:
print("不允许携带 %d 厘米长的刀上车" % knife_length)
# 如果不超过 20 厘米,安检通过
else:
print("安检通过,祝您旅途愉快……")
# 如果没有车票,不允许进门
else:
print("大哥,您要先买票啊")
演示2:石头剪刀布
# 从控制台输入要出的拳 —— 石头(1)/剪刀(2)/布(3)
player = int(input("请出拳 石头(1)/剪刀(2)/布(3):"))
# 电脑 随机 出拳 - 假定电脑永远出石头
computer = 1
# computer = random.randint(1,3)
# print(computer)
# 比较胜负
# 如果条件判断的内容太长,可以在最外侧的条件增加一对大括号
# 再在每一个条件之间,使用回车,PyCharm 可以自动增加 8 个空格
if ((player == 1 and computer == 2) or
(player == 2 and computer == 3) or
(player == 3 and computer == 1)):
print("噢耶!!!电脑弱爆了!!!")
elif player == computer:
print("心有灵犀,再来一盘!")
else:
print("不行,我要和你决战到天亮!")
随机数的处理
首先需要导入 随机数 的 模块 —— “工具包”
导入模块后,可以直接在 模块名称 后面敲一个 .
然后按 Tab
键,会提示该模块中包含的所有函数
random.randint(a, b) ,返回 [a, b]
之间的整数,包含 a
和 b
import random
random.randint(12, 20) # 生成的随机数n: 12 <= n <= 20
random.randint(20, 20) # 结果永远是 20
random.randint(20, 10) # 该语句是错误的,下限必须小于上限
6. while循环
【1】程序的三大流程
- 顺序 —— 从上向下,顺序执行代码
- 分支 —— 根据条件判断,决定执行代码的 分支
- 循环 —— 让 特定代码 重复 执行
【2】while基本语法
初始条件设置 —— 通常是重复执行的 计数器
while 条件(判断 计数器 是否达到 目标次数):
条件满足时,做的事情1
条件满足时,做的事情2
条件满足时,做的事情3
...(省略)...
处理条件(计数器 + 1)
演示:打印5次Hello Python
# 1. 定义重复次数计数器
i = 1
# 2. 使用 while 判断条件
while i <= 5:
# 要重复执行的代码
print("Hello Python")
# 处理计数器 i
i = i + 1
print("循环结束后的 i = %d" % i)
计算 0 ~ 100 之间 所有 偶数 的累计求和结果
# 0. 最终结果
result = 0
# 1. 计数器
i = 0
# 2. 开始循环
while i <= 100:
# 判断偶数
if i % 2 == 0:
print(i)
result += i
# 处理计数器
i += 1
print("0~100之间偶数求和结果 = %d" % result)
死循环:
由于程序员的原因,忘记 在循环内部 修改循环的判断条件,导致循环持续执行,程序无法终止!
常见的两种计数方法:
自然计数法(从
1
开始)—— 更符合人类的习惯程序计数法(从
0
开始)—— 几乎所有的程序语言都选择从 0 开始计数
【3】while嵌套(九九乘法表)
end=""
表示向控制台输出内容结束之后,不会换行
# 定义起始行
row = 1
# 最大打印 9 行
while row <= 9:
# 定义起始列
col = 1
# 最大打印 row 列
while col <= row:
# end = "",表示输出结束后,不换行
# "\t" 可以在控制台输出一个制表符,协助在输出文本时对齐
print("%d * %d = %d" % (col, row, row * col), end="\t")
# 列数 + 1
col += 1
# 一行打印完成的换行
print("")
# 行数 + 1
row += 1
字符串中的转义字符
\t
在控制台输出一个 制表符,协助在输出文本时 垂直方向 保持对齐\n
在控制台输出一个 换行符
制表符 的功能是在不使用表格的情况下在 垂直方向 按列对齐文本
转义字符 | 描述 |
---|---|
\\ | 反斜杠符号 |
\’ | 单引号 |
\" | 双引号 |
\n | 换行 |
\t | 横向制表符 |
\r | 回车 |
7. for循环遍历
【1】基本循环遍历
-
遍历 就是 从头到尾 依次 从 列表 中获取数据
- 在 循环体内部 针对 每一个元素,执行相同的操作
-
在
Python
中为了提高列表的遍历效率,专门提供的 迭代 iteration 遍历 -
使用
for
就能够实现迭代遍历
name_list = ["小明", "小红"]
# for 循环内部使用的变量 in 列表
for name in name_list:
# 循环内部针对列表元素进行操作
print(name)
【2】完整的 for 循环语法
- 在
Python
中完整的for 循环
的语法如下:
for 变量 in 集合:
# 循环体代码
else:
# 没有通过 break 退出循环,循环结束后,会执行的代码
应用场景
- 在 迭代遍历 嵌套的数据类型时,例如 一个列表包含了多个字典
- 需求:要判断 某一个字典中 是否存在 指定的 值
- 如果 存在,提示并且退出循环
- 如果 不存在,在 循环整体结束 后,希望 得到一个统一的提示
students = [
{"name": "小明",
"age": 20,
"gender": True,
"height": 1.7,
"weight": 75.0},
{"name": "小美",
"age": 19,
"gender": False,
"height": 1.6,
"weight": 45.0},
]
find_name = "小美"
for stu_dict in students:
print(stu_dict)
# 判断当前遍历的字典中姓名是否为find_name
if stu_dict["name"] == find_name:
print("找到了")
# 如果已经找到,直接退出循环,就不需要再对后续的数据进行比较
break
else:
print("没有找到")
print("循环结束")
8. 函数初体验
【1】 什么是函数
- 所谓函数,就是把 具有独立功能的代码块 组织为一个小模块,在需要的时候 调用
- 函数的使用包含两个步骤:
- 定义函数 —— 封装 独立的功能
- 调用函数 —— 享受 封装 的成果
- 函数的作用,在开发程序时,使用函数可以提高编写的效率以及代码的 重用
【2】 py中函数的定义
def
是英文define
的缩写- 函数名称 应该能够表达 函数封装代码 的功能,见名知意。
- 函数名称 的命名应该 符合 标识符的命名规则
def 函数名():
# 函数封装的代码
……
代码演示:通过 函数名()
即可完成对函数的调用
name = "小明"
# 解释器知道这里定义了一个函数
def say_hello():
print("hello 1")
print("hello 2")
print("hello 3")
print(name)
# 只有在调用函数时,之前定义的函数才会被执行
# 函数执行完成之后,会重新回到之前的程序中,继续执行后续的代码
say_hello()
print(name)
问题:能否将 函数调用 放在 函数定义 的上方?
- 不能!
- 因为在 使用函数名 调用函数之前,必须要保证
Python
已经知道函数的存在 - 否则控制台会提示
NameError: name 'say_hello' is not defined
(名称错误:say_hello 这个名字没有被定义)
注:因为 函数体相对比较独立,函数定义的上方,应该和其他代码(包括注释)保留 两个空行
【3】函数的参数
-
函数把 具有独立功能的代码块 组织为一个小模块,在需要的时候 调用
-
函数的参数,增加函数的 通用性,针对 相同的数据处理逻辑,能够 适应更多的数据
- 在函数 内部,把参数当做 变量 使用,进行需要的数据处理
- 函数调用时,按照函数定义的参数顺序,把 希望在函数内部处理的数据,通过参数 传递
-
形参:定义 函数时,小括号中的参数,是用来接收参数用的,在函数内部 作为变量使用
-
实参:调用 函数时,小括号中的参数,是用来把数据传递到 函数内部 用的
def sum_2_num(num1, num2):
result = num1 + num2
print("%d + %d = %d" % (num1, num2, result))
sum_2_num(50, 20)
【4】函数的返回值
- 返回值 是函数 完成工作后,最后 给调用者的 一个结果
- 在函数中使用
return
关键字可以返回结果 - 调用函数一方,可以 使用变量 来 接收 函数的返回结果
注意:
return
表示返回,后续的代码都不会被执行
def sum_2_num(num1, num2):
"""对两个数字的求和"""
return num1 + num2
# 调用函数,并使用 result 变量接收计算结果
result = sum_2_num(10, 20)
print("计算结果是 %d" % result)
【5】函数的嵌套调用
一个函数里面 又调用 了 另外一个函数,就是 函数嵌套调用
调用函数 test2
,其又调用了函数 test1
-
那么执行到调用
test1
函数时,会先把函数test1
中的任务都执行完 -
才会回到
test2
中调用函数test1
的位置,继续执行后续的代码
def test1():
print("*" * 50)
print("test1~~~")
print("*" * 50)
def test2():
print("-" * 50)
print("test2~~~")
test1()
print("-" * 50)
test2()
定义一个函数能够打印 5 行 的分隔线,分隔线要求符合任意重复次数 的分隔线
def print_line(char, times):
print(char * times)
def print_lines(char, times):
row = 0
while row < 5:
print_line(char, times)
row += 1
【6】模块中的函数
模块是 Python 程序架构的一个核心概念
- 模块 就好比是 工具包,要想使用这个工具包中的工具,就需要 导入 import 这个模块
- 每一个以扩展名
py
结尾的Python
源代码文件都是一个 模块 - 在模块中定义的 全局变量 、 函数 都是模块能够提供给外界直接使用的工具
模块函数初体验
注: 模块名也是一个标识符
定义talk模块
name = "小明";
def print_line(char, times ,say):
print(char * times)
print(say+"/n")
print(char * times)
创建测试模块test.py
import talk
# 导入之后,就可以使用 `模块名.变量 或 模块名.函数` 的方式,使用这个模块中定义的变量或者函数
print(talk.name)
talk.print_line("-", 10, hello)
【7】pyc 文件(了解)
C
是compiled
编译过 的意思
- 浏览程序目录会发现一个
__pycache__
的目录 - 目录下会有一个
talk.cpython-35.pyc
文件,cpython-35
表示Python
解释器的版本 - 这个
pyc
文件是由 Python 解释器将 模块的源码 转换为 字节码-
Python
这样保存 字节码 是作为一种启动 速度的优化
-
字节码
-
Python
在解释源程序时是分成两个步骤的- 首先处理源代码,编译 生成一个二进制 字节码
- 再对 字节码 进行处理,才会生成 CPU 能够识别的 机器码
-
有了模块的字节码文件之后,下一次运行程序时,如果在 上次保存字节码之后 没有修改过源代码,
Python 将会加载 .pyc 文件并跳过编译这个步骤
-
当
Python
重编译时,它会自动检查源文件和字节码文件的时间戳 -
如果你又修改了源代码,下次程序运行时,字节码将自动重新创建
9. 变量进阶
【1】变量的引用
- 变量 和 数据 都是保存在 内存 中的
- 在
Python
中 函数 的 参数传递 以及 返回值 都是靠 引用 传递的
在 Python
中 引用的概念
- 变量 和 数据 是分开存储的
- 数据 保存在内存中的一个位置
- 变量 中保存着数据在内存中的地址
- 变量 中 记录数据的地址,就叫做 引用
- 使用
id()
函数可以查看变量中保存数据所在的 内存地址
注意:如果变量已经被定义,当给一个变量赋值的时候,本质上是 修改了数据的引用
- 变量 不再 对之前的数据引用
- 变量 改为 对新赋值的数据引用
在 Python
中,函数的 实参/返回值 都是是靠 引用 来传递来的
def test(num):
print("-" * 50)
print("%d 在函数内的内存地址是 %x" % (num, id(num)))
result = 100
print("返回值 %d 在内存中的地址是 %x" % (result, id(result)))
print("-" * 50)
return result
a = 10
print("调用函数前 内存地址是 %x" % id(a))
r = test(a)
print("调用函数后 实参内存地址是 %x" % id(a))
print("调用函数后 返回值内存地址是 %x" % id(r))
【2】 可变和不可变类型
-
不可变类型,内存中的数据不允许被修改:
- 数字类型
int
,bool
,float
,complex
,long(2.x)
- 字符串
str
- 元组
tuple
- 数字类型
-
可变类型,内存中的数据可以被修改:
- 列表
list
- 字典
dict
- 列表
**注意:**字典的 key
只能使用不可变类型的数据
注意:
- 可变类型的数据变化,是通过 方法 来实现的
- 如果给一个可变类型的变量,赋值了一个新的数据,引用会修改
- 变量 不再 对之前的数据引用
- 变量 改为 对新赋值的数据引用
demo_list = [1, 2, 3]
print("定义列表后的内存地址 %d" % id(demo_list))
demo_list.append(999)
demo_list.pop(0)
demo_list.remove(2)
demo_list[0] = 10
print("修改数据后的内存地址 %d" % id(demo_list))
demo_dict = {"name": "小王"}
print("定义字典后的内存地址 %d" % id(demo_dict))
demo_dict["age"] = 18
demo_dict.pop("name")
demo_dict["name"] = "老王"
print("修改数据后的内存地址 %d" % id(demo_dict))
【3】哈希 hash()函数
Python
中内置有一个名字叫做hash(o)
的函数- 接收一个 不可变类型 的数据作为 参数
- 返回 结果是一个 整数
哈希
是一种 算法,其作用就是提取数据的 特征码(指纹)- 相同的内容 得到 相同的结果
- 不同的内容 得到 不同的结果
- 在
Python
中,设置字典的 键值对 时,会首先对key
进行hash
已决定如何在内存中保存字典的数据,以方便 后续 对字典的操作:增、删、改、查- 键值对的
key
必须是不可变类型数据 - 键值对的
value
可以是任意类型的数据
- 键值对的
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2qlnaJ3Y-1625660757648)(Python基础语法.assets/image-20210707155443243.png)]
【4】局部变量和全局变量
- 局部变量 是在 函数内部 定义的变量,只能在函数内部使用
- 全局变量 是在 函数外部定义 的变量(没有定义在某一个函数内),所有函数 内部 都可以使用这个变量
提示:在其他的开发语言中,大多 不推荐使用全局变量 —— 可变范围太大,导致程序不好维护!
1)局部变量
-
局部变量 是在 函数内部 定义的变量,只能在函数内部使用
-
函数执行结束后,函数内部的局部变量,会被系统回收
-
不同的函数,可以定义相同的名字的局部变量,但是 彼此之间 不会产生影响
-
在函数内部使用,临时 保存 函数内部需要使用的数据
局部变量的生命周期
- 所谓 生命周期 就是变量从 被创建 到 被系统回收 的过程
- 局部变量 在 函数执行时 才会被创建
- 函数执行结束后 局部变量 被系统回收
- 局部变量在生命周期 内,可以用来存储 函数内部临时使用到的数据
def demo1():
num = 10
print(num)
num = 20
print("修改后 %d" % num)
def demo2():
num = 100
print(num)
demo1()
demo2()
print("over")
2)全局变量
全局变量 是在 函数外部定义 的变量,所有函数内部都可以使用这个变量
函数执行需要处理变量时 :
- 首先 查找 函数内部 是否存在 指定名称 的局部变量,如果有,直接使用
- 如果没有,查找 函数外部 是否存在 指定名称 的全局变量,如果有,直接使用
- 如果还没有,程序报错!
# 定义一个全局变量
num = 10
def demo1():
print(num)
def demo2():
print(num)
demo1()
demo2()
print("over")
1) 函数不能直接修改 全局变量的引用
- 全局变量 是在 函数外部定义 的变量(没有定义在某一个函数内),所有函数 内部 都可以使用这个变量
提示:在其他的开发语言中,大多 不推荐使用全局变量 —— 可变范围太大,导致程序不好维护!
- 在函数内部,可以 通过全局变量的引用获取对应的数据
- 但是,不允许直接修改全局变量的引用 —— 使用赋值语句修改全局变量的值
num = 10
def demo1():
print("demo1" + "-" * 50)
# 只是定义了一个局部变量,不会修改到全局变量,只是变量名相同而已
num = 100
print(num)
def demo2():
print("demo2" + "-" * 50)
print(num)
demo1()
demo2()
print("over")
注意:只是在函数内部定义了一个局部变量而已,只是变量名相同 —— 在函数内部不能直接修改全局变量的值
2) 在函数内部修改全局变量的值
- 如果在函数中需要修改全局变量,需要使用
global
进行声明
num = 10
def demo1():
print("demo1" + "-" * 50)
# global 关键字,告诉 Python 解释器 num 是一个全局变量
global num
# 只是定义了一个局部变量,不会修改到全局变量,只是变量名相同而已
num = 100
print(num)
def demo2():
print("demo2" + "-" * 50)
print(num)
demo1()
demo2()
print("over")
3) 全局变量定义的位置
- 为了保证所有的函数都能够正确使用到全局变量,应该 将全局变量定义在其他函数的上方
a = 10
def demo():
print("%d" % a)
print("%d" % b)
print("%d" % c)
b = 20
demo()
c = 30
注意
- 由于全局变量 c,是在调用函数之后,才定义的,在执行函数时,变量还没有定义,所以程序会报错!
代码结构示意图如下
4) 全局变量命名的建议
为了避免局部变量和全局变量出现混淆,在定义全局变量时,有些公司会有一些开发要求,
例如:局变量名前应该增加 g_
或者 gl_
的前缀
提示:具体的要求格式,各公司要求可能会有些差异
10. 函数进阶
定义函数时,是否接收参数,或者是否返回结果,是根据 实际的功能需求 来决定的!
无参数,无返回值
无参数,有返回值
有参数,无返回值
有参数,有返回值
【1】函数的入参
1)不可变和可变的参数
问题 1:在函数内部,针对参数使用 赋值语句,会不会影响调用函数时传递的 实参变量?不会!
- 无论传递的参数是 可变 还是 不可变 ,只要 针对参数 使用 赋值语句,
- 会在 函数内部 修改 局部变量的引用,不会影响到 外部变量的引用
def demo(num, num_list):
print("函数内部")
# 赋值语句
num = 200
num_list = [1, 2, 3]
print(num)
print(num_list)
print("函数代码完成")
gl_num = 99
gl_list = [4, 5, 6]
demo(gl_num, gl_list)
print(gl_num)
print(gl_list)
问题 2:如果传递的参数是 可变类型,在函数内部,使用 方法 修改了数据的内容,
同样会影响到外部的数据,不会修改变量的引用。。
def mutable(num_list):
# num_list = [1, 2, 3]
num_list.extend([1, 2, 3])
print(num_list)
gl_list = [6, 7, 8]
mutable(gl_list)
print(gl_list)
面试题 :在 python
中,列表变量调用 +=
本质上是在执行列表变量的 extend
方法,不会修改变量的引用。
def demo(num, num_list):
print("函数内部代码")
# num = num + num
num += num
# num_list.extend(num_list) 由于是调用方法,所以不会修改变量的引用
# 函数执行结束后,外部数据同样会发生变化
num_list += num_list
print(num)
print(num_list)
print("函数代码完成")
gl_num = 9
gl_list = [1, 2, 3]
demo(gl_num, gl_list)
print(gl_num)
print(gl_list)
2)缺省参数
- 定义函数时,可以给 某个参数 指定一个默认值,具有默认值的参数就叫做 缺省参数
- 调用函数时,如果没有传入 缺省参数 的值,则在函数内部使用定义函数时指定的 参数默认值
- 函数的缺省参数,将常见的值设置为参数的缺省值,从而 简化函数的调用
演示:对列表排序的方法
gl_num_list = [6, 3, 9]
# 默认就是升序排序,因为这种应用需求更多
gl_num_list.sort()
print(gl_num_list)
# 只有当需要降序排序时,才需要传递 `reverse` 参数
gl_num_list.sort(reverse=True)
print(gl_num_list)
注意事项
- 缺省参数的定义位置
- 必须保证 带有默认值的缺省参数 在参数列表末尾
- 所以,以下定义是错误的!
def print_info(name, gender=True, title):
- 调用带有多个缺省参数的函数
- 在 调用函数时,如果有 多个缺省参数,需要指定参数名,
- 这样解释器才能够知道参数的对应关系!
def print_info(name, title="", gender=True):
"""
:param title: 职位
:param name: 班上同学的姓名
:param gender: True 男生 False 女生
"""
gender_text = "男生"
if not gender:
gender_text = "女生"
print("%s%s 是 %s" % (title, name, gender_text))
# 提示:在指定缺省参数的默认值时,应该使用最常见的值作为默认值!
print_info("小明")
print_info("老王", title="班长")
print_info("小美", gender=False)
3)多值参数
-
有时可能需要 一个函数 能够处理的参数 个数 是不确定的,这个时候,就可以使用 多值参数
-
python
中有 两种 多值参数:- 参数名前增加 一个
*
可以接收 元组 - 参数名前增加 两个
*
可以接收 字典
- 参数名前增加 一个
-
一般在给多值参数命名时,习惯使用以下两个名字
*args
—— 存放 元组 参数,前面有一个*
**kwargs
—— 存放 字典 参数,前面有两个*
-
args
是arguments
的缩写,有变量的含义 -
kw
是keyword
的缩写,kwargs
可以记忆 键值对参数
def demo(num, *args, **kwargs):
print(num)
print(args)
print(kwargs)
demo(1, 2, 3, 4, 5, name="小明", age=18, gender=True)
提示:多值参数 的应用会经常出现在网络上一些大牛开发的框架中,知道多值参数,
有利于我们能够读懂大牛的代码
演示:计算任意多个数字的和
- 定义一个函数
sum_numbers
,可以接收的 任意多个整数 - 功能要求:将传递的 所有数字累加 并且返回累加结果
def sum_numbers(*args):
num = 0
# 遍历 args 元组顺序求和
for n in args:
num += n
return num
print(sum_numbers(1, 2, 3))
元组和字典的拆包
- 在调用带有多值参数的函数时,如果希望:
- 将一个 元组变量,直接传递给
args
- 将一个 字典变量,直接传递给
kwargs
- 将一个 元组变量,直接传递给
- 就可以使用 拆包,简化参数的传递,拆包 的方式是:
- 在 元组变量前,增加 一个
*
- 在 字典变量前,增加 两个
*
- 在 元组变量前,增加 一个
def demo(*args, **kwargs):
print(args)
print(kwargs)
# 需要将一个元组变量/字典变量传递给函数对应的参数
gl_nums = (1, 2, 3)
gl_xiaoming = {"name": "小明", "age": 18}
# 会把 num_tuple 和 xiaoming 作为元组传递个 args
# demo(gl_nums, gl_xiaoming)
demo(*gl_nums, **gl_xiaoming)
【2】函数的返回值
- 返回值 是函数 完成工作后,最后 给调用者的 一个结果
- 在函数中使用
return
关键字可以返回结果 - 调用函数一方,可以 使用变量 来 接收 函数的返回结果
问题:一个函数执行后能否返回多个结果?
- 假设要开发一个函数能够同时返回当前的温度和湿度
- 先完成返回温度的功能如下:
def measure():
"""返回当前的温度"""
print("开始测量...")
temp = 39
print("测量结束...")
return temp
result = measure()
print(result)
- 在利用 元组 在返回温度的同时,也能够返回 湿度
- 改造如下:
def measure():
"""返回当前的温度"""
print("开始测量...")
temp = 39
wetness = 10
print("测量结束...")
return (temp, wetness)
提示:如果一个函数返回的是元组,括号可以省略
- 在
Python
中,可以 将一个元组 使用 赋值语句 同时赋值给 多个变量 - 注意:变量的数量需要和元组中的元素数量保持一致
![image-20210707192052632](https://i-blog.csdnimg.cn/blog_migrate/a68f8a111231ce8910cbea614e506565.png)
【3】函数的递归
-
一个函数 内部 调用自己
-
代码特点
-
函数内部的 代码 是相同的,只是针对 参数 不同,处理的结果不同
-
当 参数满足一个条件 时,函数不再执行。这个非常重要,通常被称为递归的出口,
否则 会出现死循环!
-
在处理 不确定的循环条件时,格外的有用,例如:遍历整个文件目录的结构
-
def sum_numbers(num):
print(num)
# 递归的出口很重要,否则会出现死循环
if num == 1:
return
sum_numbers(num - 1)
sum_numbers(3)
递归案例 —— 计算数字累加
def sum_numbers(num):
if num == 1:
return 1
# 假设 sum_numbers 能够完成 num - 1 的累加
temp = sum_numbers(num - 1)
# 函数内部的核心算法就是 两个数字的相加
return num + temp
print(sum_numbers(2))