一、认识Python

1、Python起源

人生苦短，我用 Python （Life is short, you need Python）

​ Python创始人吉多·范罗苏姆（Guido van Rossum）

1. 1989 年的圣诞节期间，吉多·范罗苏姆为了在阿姆斯特丹打发时间，决心开发一个新的解释程序，作为 ABC 语言的一种继承（感觉下什么叫牛人）
2. ABC 是由吉多参加设计的一种教学语言，就吉多本人看来，ABC 这种语言非常优美和强大，是专门为非专业程序员设计的。但是 ABC 语言并没有成功，究其原因，吉多认为是非开放造成的。吉多决心在 Python 中避免这一错误，并获取了非常好的效果
3. 之所以选中 Python（蟒蛇） 作为程序的名字，是因为他是 BBC 电视剧——蒙提·派森的飞行马戏团（Monty Python’s Flying Circus）的爱好者
4. 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. 硬盘 * 永久 存储数据* 速度慢* 空间大（单位价格低）程序的作用：程序就是 用来处理数据的。新闻软件提供的 **新闻内容、评论……** 是数据电商软件提供的 **商品信息、配送信息……** 是数据即时通讯软件提供的 **聊天信息、好友信息……** 是数据

程序执行的原理

1. 程序 运行之前，程序是 保存在硬盘 中的
2. 当要运行一个程序时
   • 操作系统会首先让 CPU 把程序复制到 内存 中
   • CPU 执行 内存 中的 程序代码

Python 程序执行原理

1. 操作系统会首先让 CPU 把 Python 解释器 的程序复制到 内存 中
2. Python 解释器 根据语法规则，从上向下 让 CPU 翻译 Python 程序中的代码
3. 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 中的 标识符 是 区分大小写的

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

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

   1. 每个单词都使用小写字母
   2. 单词与单词之间使用 _下划线 连接
   • 例如：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 * weightprint(money)

【3】变量的类型

• 在 Python 中定义变量是 不需要指定类型（在其他很多高级语言中都需要）
• 数据类型可以分为 数字型 和 非数字型
• 数字型 4
  • 整型 (int)
  • 浮点型（float）
  • 布尔型（bool）
    • 真 True 非 0 数 —— 非零即真
    • 假 False 0
  • 复数型 (complex)
    • 主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题
• **非数字型 ** 4
  • 字符串
  • 列表
  • 元组
  • 字典

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

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

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

【4】不同类型变量之间的计算

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

   如果变量是 bool 型，在计算时：True 对应的数字是 1，False 对应的数字是 0

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

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

注意： 数字型变量 和 字符串 之间 不能进行其他计算

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 开始
  • 索引 就是数据在 列表 中的位置编号，索引 又可以被称为 下标

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

列表常用操作

在 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 的 列表 中可以 存储不同类型的数据
• 但是在开发中，更多的应用场景是
  1. 列表 存储相同类型的数据
  2. 通过 迭代遍历，在循环体内部，针对列表中的每一项元素，执行相同的操作

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 会提示 字典 能够使用的函数如下：

# 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. 指定的区间属于 左闭右开 型 [开始索引, 结束索引) ，从 起始 位开始，到 结束位的前一位 结束（不包含结束位本身)
2. 从头开始，开始索引 数字可以省略，冒号不能省略
3. 到末尾结束，结束索引 数字可以省略，冒号不能省略
4. 步长默认为 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）面试题-交换两个数字

题目要求

1. 有两个整数变量 a = 6, b = 100
2. 不使用其他变量，交换两个变量的值

解法 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 randomrandom.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")# 处理计数器 ii = i + 1print("循环结束后的 i = %d" % i)

计算 0 ~ 100 之间 所有 偶数 的累计求和结果

# 0. 最终结果
result = 0
# 1. 计数器
i = 0# 2. 开始循环
while i <= 100:# 判断偶数if i % 2 == 0:print(i)result += i# 处理计数器i += 1print("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")# 列数 + 1col += 1# 一行打印完成的换行print("")# 行数 + 1row += 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_nameif stu_dict["name"] == find_name:print("找到了")# 如果已经找到，直接退出循环，就不需要再对后续的数据进行比较breakelse:print("没有找到")print("循环结束")

8. 函数初体验

【1】 什么是函数

• 所谓函数，就是把 具有独立功能的代码块 组织为一个小模块，在需要的时候 调用
• 函数的使用包含两个步骤：
  1. 定义函数 —— 封装 独立的功能
  2. 调用函数 —— 享受 封装 的成果
• 函数的作用，在开发程序时，使用函数可以提高编写的效率以及代码的 重用

【2】 py中函数的定义

1. def 是英文 define 的缩写
2. 函数名称 应该能够表达 函数封装代码 的功能，见名知意。
3. 函数名称 的命名应该 符合 标识符的命名规则

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】函数的参数

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

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

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

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

• 实参：调用 函数时，小括号中的参数，是用来把数据传递到 函数内部 用的

def sum_2_num(num1, num2):result = num1 + num2print("%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 = 0while 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 编译过 的意思

1. 浏览程序目录会发现一个 __pycache__ 的目录
2. 目录下会有一个 talk.cpython-35.pyc 文件，cpython-35 表示 Python 解释器的版本
3. 这个 pyc 文件是由 Python 解释器将 模块的源码 转换为 字节码
   • Python 这样保存 字节码 是作为一种启动 速度的优化

字节码

• Python 在解释源程序时是分成两个步骤的

  1. 首先处理源代码，编译 生成一个二进制 字节码
  2. 再对 字节码 进行处理，才会生成 CPU 能够识别的 机器码

• 有了模块的字节码文件之后，下一次运行程序时，如果在 上次保存字节码之后 没有修改过源代码，

  Python 将会加载 .pyc 文件并跳过编译这个步骤

• 当 Python 重编译时，它会自动检查源文件和字节码文件的时间戳

• 如果你又修改了源代码，下次程序运行时，字节码将自动重新创建

9. 变量进阶

【1】变量的引用

• 变量 和 数据 都是保存在 内存 中的
• 在 Python 中 函数 的 参数传递 以及 返回值 都是靠 引用 传递的

在 Python 中 引用的概念

• 变量 和 数据 是分开存储的
• 数据 保存在内存中的一个位置
• 变量 中保存着数据在内存中的地址
• 变量 中 记录数据的地址，就叫做 引用
• 使用 id() 函数可以查看变量中保存数据所在的 内存地址

注意：如果变量已经被定义，当给一个变量赋值的时候，本质上是 修改了数据的引用

• 变量 不再 对之前的数据引用
• 变量 改为 对新赋值的数据引用

在 Python 中，函数的 实参/返回值 都是是靠 引用 来传递来的

def test(num):print("-" * 50)print("%d 在函数内的内存地址是 %x" % (num, id(num)))result = 100print("返回值 %d 在内存中的地址是 %x" % (result, id(result)))print("-" * 50)return  resulta = 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 只能使用不可变类型的数据

注意：

1. 可变类型的数据变化，是通过 方法 来实现的
2. 如果给一个可变类型的变量，赋值了一个新的数据，引用会修改
   • 变量 不再 对之前的数据引用
   • 变量 改为 对新赋值的数据引用

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] = 10print("修改数据后的内存地址 %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 = 10print(num)num = 20print("修改后 %d" % num)def demo2():num = 100print(num)demo1()
demo2()print("over")

2）全局变量

全局变量 是在 函数外部定义 的变量，所有函数内部都可以使用这个变量

函数执行需要处理变量时 ：

1. 首先 查找 函数内部 是否存在 指定名称 的局部变量，如果有，直接使用
2. 如果没有，查找 函数外部 是否存在 指定名称 的全局变量，如果有，直接使用
3. 如果还没有，程序报错！

# 定义一个全局变量
num = 10def demo1():print(num)def demo2():print(num)demo1()
demo2()print("over")

1) 函数不能直接修改 全局变量的引用

• 全局变量 是在 函数外部定义 的变量（没有定义在某一个函数内），所有函数 内部 都可以使用这个变量

提示：在其他的开发语言中，大多 不推荐使用全局变量 —— 可变范围太大，导致程序不好维护！

• 在函数内部，可以 通过全局变量的引用获取对应的数据
• 但是，不允许直接修改全局变量的引用 —— 使用赋值语句修改全局变量的值

num = 10def demo1():print("demo1" + "-" * 50)# 只是定义了一个局部变量，不会修改到全局变量，只是变量名相同而已num = 100print(num)def demo2():print("demo2" + "-" * 50)print(num)demo1()
demo2()print("over")

注意：只是在函数内部定义了一个局部变量而已，只是变量名相同 —— 在函数内部不能直接修改全局变量的值

2) 在函数内部修改全局变量的值

• 如果在函数中需要修改全局变量，需要使用 global 进行声明

num = 10def demo1():print("demo1" + "-" * 50)# global 关键字，告诉 Python 解释器 num 是一个全局变量global num# 只是定义了一个局部变量，不会修改到全局变量，只是变量名相同而已num = 100print(num)def demo2():print("demo2" + "-" * 50)print(num)demo1()
demo2()print("over")

3) 全局变量定义的位置

• 为了保证所有的函数都能够正确使用到全局变量，应该 将全局变量定义在其他函数的上方

a = 10def 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 = 200num_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 + numnum += num# num_list.extend(num_list) 由于是调用方法，所以不会修改变量的引用# 函数执行结束后，外部数据同样会发生变化num_list += num_listprint(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)

注意事项

1. 缺省参数的定义位置

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

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

1. 调用带有多个缺省参数的函数

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

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)

提示：多值参数 的应用会经常出现在网络上一些大牛开发的框架中，知道多值参数，

有利于我们能够读懂大牛的代码

演示：计算任意多个数字的和

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

def sum_numbers(*args):num = 0# 遍历 args 元组顺序求和for n in args:num += nreturn numprint(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 = 39print("测量结束...")return tempresult = measure()
print(result)

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

def measure():"""返回当前的温度"""print("开始测量...")temp = 39wetness = 10print("测量结束...")return (temp, wetness)

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

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

【3】函数的递归

• 一个函数 内部 调用自己

• 代码特点

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

  • 当 参数满足一个条件 时，函数不再执行。这个非常重要，通常被称为递归的出口，

    否则 会出现死循环！

  • 在处理 不确定的循环条件时，格外的有用，例如：遍历整个文件目录的结构

def sum_numbers(num):print(num)# 递归的出口很重要，否则会出现死循环if num == 1:returnsum_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 + tempprint(sum_numbers(2))

【Python学习】一、Python基础语法相关推荐

1. Python学习笔记(2)-基础语法

   1 ########### python基础语法 ################### 2 3 #标识符 4 #第一个字符必须是字母表中字母或下划线-- 5 #标识符的其他部分有字母,数字和下划线组 ...

2. python学习笔记：基础语法

   目录 python语言概述 python基础语法 python标准数据类型 1.数字类型 2.字符串类型 3.列表类型 4.元组 5.字典 python基础语法 1.条件判断语句 2.循环语句 3.函 ...

3. Python学习笔记之基础语法--input outpupt json

   基本语法 命令行输入输出 name = input('your name:') gender = input('you are a boy?(y/n)')###### 输入 ###### your n ...

4. python基本语法语句-python学习笔记：基本语法

   原标题:python学习笔记:基本语法 缩进:必须使用4个空格来表示每级缩进,支持Tab字符 if语句,经常与else, elif(相当于else if) 配合使用. for语句,迭代器,依次处理迭代 ...

5. python学习课程 0基础学Python视频教程

   python学习课程,零基础Python初学者应该怎么去学习Python语言编程?python学习路线这里了解一下吧.想python学习课程?学习路线网免费下载海量python教程,上班族也能在家自学 ...

6. Python 实例教学_01_基础语法

   Python 实例教程 教学方法 课前准备 要求 Python 实例教学_01_基础语法 [Python 教学](https://blog.csdn.net/weixin_43955170/categ ...

7. Python学习教程（Python学习路线_Python基础学习教程_Python视频教程）：初学者新手怎样快速入门Python

   Python学习教程(Python学习路线_Python基础学习教程_Python视频教程):初学者新手怎样快速入门Python? 人生苦短,我用Python!!!短短几个字,现在在各大学习类平台随处 ...

8. Python学习day16-模块基础

   <!doctype html>day16 - 博客 Python学习day16-模块基础模块的四种形式import和from-import循环导入模块的搜索路径Python文件的两种用途 ...

9. Python学习笔记_1_基础_2：数据运算、bytes数据类型、.pyc文件（什么鬼）

   Python学习笔记_1_基础_2:数据运算.bytes数据类型..pyc文件(什么鬼) 一.数据运算 Python数据运算感觉和C++,Java没有太大的差异,百度一大堆,这里就不想写了.比较有意思 ...

10. Python学习日记-day1基础篇 字符 输出 注释

    Python学习日记-day1基础篇 字符 输出 注释 by北栀一刺 # -*- coding: utf-8 -*- """ Spyder EditorThis is a ...

最新文章

1. web嵌入到原生的app里需要注意的事项
2. jinfo 的相关使用 || 两个经典的参数： -Xms -Xmx
3. codeforces271D
4. oracle如何查询系统变量数据,Oracle如何对IN子查询使用绑定变量(转)
5. 虚拟机 搭建LVS + DR + keepalived 高可用负载均衡
6. [渝粤教育] 西南科技大学 建筑制图 在线考试复习资料
7. 深入浅出组合逻辑电路（1）
8. dategridview设置下拉框默认值_smtp服务器怎么设置
9. css grid随页面大小_你现在可以玩下这 5 个 CSS 新功能
10. lenovo电脑_诠释什么叫性价比?LENOVO联想ThinkPad P72/P73 ?仅售16200.00元?
11. Word无法读取此文档，文档可能已损坏
12. 腾讯视频 Python 爬虫项目实战
13. 联想g510升级换什么cpu好_联想G510笔记本完全拆机指南（图解）
14. 深海探测机器人——“海洋一号”成功出航！
15. java mail 匿名_java开发邮件发送匿名
16. android系统profile文件路径,Android Profile Tools 入门
17. 7、8系升9系视频教程
18. JavaScript高级教程（25）——ES6
19. 对挣钱与财富等三个问题的思考
20. 计算机辅助齿轮图标注,面向齿轮的计算机辅助设计、制造及检测设计（CAD图纸全套）.doc...

热门文章

1. LeetCode题解：x的平方根
2. 2022-2028全球军用级电脑行业调研及趋势分析报告
3. C语言 带参数宏定义中 # 和 ## 知识点总结、代码分析
4. Stm32的GPIO PB10 驱动固态继电器
5. 树莓派读写单总线设备DS2431
6. 烦人的后台首页index.jsp弄好了
7. java实现第六届蓝桥杯穿越雷区
8. 2017年迄今最新人工智能资源盘点
9. # Linux shell终端设置代理服务器的方法
10. java-php-python-ssm网课信息管理系统计算机毕业设计