个人网站做微擎,网站建设公司做销售前景好不好,wordpress查找,个人网站开发是学什么语言文章目录 一、Python简介1.1 为什么学习python1.2 python安装与配置1.3 python解释器1.4 命令行参数1.4.1 sys.argv变量1.4.2 -c和-m选项 1.5 解释器的运行环境1.5.1 编码格式1.5.2 编码声明 二、Python基础语法2.1 行结构2.2 变量#xff08;标识符#xff09;2.3 字节串2.4… 文章目录 一、Python简介1.1 为什么学习python1.2 python安装与配置1.3 python解释器1.4 命令行参数1.4.1 sys.argv变量1.4.2 -c和-m选项 1.5 解释器的运行环境1.5.1 编码格式1.5.2 编码声明 二、Python基础语法2.1 行结构2.2 变量标识符2.3 字节串2.4 转义字符和原字符2.5 分隔符2.6 文本样式 三、程序控制3.1 条件语句3.1.1 if 语句3.1.2 match语句 3.2 循环语句3.2.1 for 循环3.2.2 while 循环3.2.3 循环中的else子句3.2.4 生成器表达式和列表推导式 3.3 跳转语句3.4 pass 语句3.5 循环控制进阶3.5.1 enumerate函数在循环中同时获取索引和元素。3.5.2 zip函数在循环中同时遍历多个序列。3.5.3 reversed 函数可用于对序列进行逆向循环3.5.4 . sorted 函数在不改动原序列的基础上按指定顺序循环序列3.5.5 sort和sorted详解3.5.5.1 基本语法3.5.5.2 key 参数用于复杂排序的各种可能 四、函数4.1 函数的基本定义4.2 作用域、局部变量和全局变量4.3 参数4.3.1 五种函数参数4.3.2 参数使用规则4.3.3 任意实参列表和解包实参列表 4.4 匿名函数lambda4.5 map函数和filter函数4.6 文档字符串和函数注解4.7 编码风格 一、Python简介 Python官网、Python 3.11.5 中文文档、慕课Python语言程序设计 1.1 为什么学习python 在计算机编程中编程是指编写一系列指令以便计算机执行特定的任务。编程语言就像是我们与计算机进行交流的工具它们允许我们用人类可以理解的方式来描述任务和操作。
Python 是一种广泛使用的高级编程语言它的语法简单清晰非常适合初学者入门。Python 可以用来开发各种类型的应用包括 Web 应用、数据分析、人工智能等。
为什么要学习 Python 呢Python 具有以下几个优点
易学易用 Python 的语法简洁明了不需要大量的符号和标记使得它成为编程入门的绝佳选择。广泛应用 Python 在多个领域都有应用从 Web 开发到科学计算都可以使用 Python 来完成任务。强大的社区支持 Python 拥有庞大的社区和丰富的文档你可以轻松找到解决问题的方法和资源。大量的库和框架 Python 生态系统中有许多开源库和框架可以帮助你更快速地完成项目。
1.2 python安装与配置 打开python官网选择合适的python版本进行安装。在windows系统中打开cmd输入where python就可以看到当前系统的python安装目录。 安装之后按照以下步骤配置python的环境变量 在开始菜单中搜索并打开“环境变量”设置。 在系统变量区域找到名为 Path 的变量并双击它。 在弹出的窗口中点击“编辑”然后输入 Python 的安装路径例如我的路径就是C:\Users\LS\AppData\Local\Programs\Python\Python311\python.exe。 配置好环境变量后cmd下输入python --version即可查看当前系统的python版本如果你有多个 Python 版本安装在系统中这个命令会显示默认的 Python 版本。。 有关windows环境变量的详述请参考《Environment Variables》Windows允许在用户级别和系统级别永久配置环境变量或临时在命令提示符中配置环境变量请参考《设置环境变量》 1.3 python解释器 Python 解释器是一种程序它能够读取并执行 Python 代码。每当你编写 Python 代码并运行时实际上是通过解释器将你的代码转换成计算机可以理解的指令。Python 有多个解释器可供选择以下是一些常见的 Python 解释器
Python 解释器有两种主要使用方式 CPython Python 编程语言的官方实现使用C语言开发是最常用的 Python 解释器之一在多数情况下“Python” 指的就是 CPython。 CPython 使用全局解释锁Global Interpreter LockGIL来确保在同一时间只能有一个线程执行 Python 代码。这可以导致在多线程程序中存在一些性能限制在多线程章节会详述。 JythonJython是运行在Java虚拟机JVM上的Python解释器。它允许Python代码与Java代码相互调用可以在Java平台上使用Python进行开发。 IronPython运行在 .NET 平台上 PyPy一个高性能的 JIT 即时编译编译器实现在某些情况下比CPython更快地执行代码。 MicroPython用于 IoT 设备和嵌入式系统专为资源受限的环境设计可以在微控制器和其他小型设备上运行
python解释器主要有两种使用方式
交互式模式 这是一种逐行执行代码的方式。你可以打开一个交互式解释器窗口输入一行代码然后解释器会立即执行并返回结果。这对于测试代码片段和快速实验非常有用。 在cmd中输入python即可进入python交互模式按下Ctrlz后回车即可退出或者是输入quit()。 脚本模式 这是一种将一组代码保存在文件中并一次性运行的方式。你可以创建一个以 .py 结尾的 Python 脚本文件然后在终端或命令提示符中运行它。解释器会按顺序执行文件中的代码。
例如假设你有一个名为 hello.py 的脚本文件其中包含以下代码
print(Hello, world!)你可以在终端中输入以下命令运行脚本
python hello.py1.4 命令行参数
1.4.1 sys.argv变量 当你在命令行中运行一个 Python 脚本时Python 解释器会把你输入的命令行信息转换成一个列表这个列表被称为“命令行参数列表”。这个列表中包含了一些有用的信息比如脚本的名字和其他参数。
假设你有一个名为 script.py 的 Python 脚本当你在命令行中输入以下内容时
python script.py arg1 arg2Python 解释器会将这些内容转换成一个列表并存到 sys 模块的 argv 变量里。
[script.py, arg1, arg2]在这个列表中第一个元素 script.py 是脚本的名字后面的元素 arg1 和 arg2 是其他参数。如果你要访问这个命令行参数列表你可以使用 sys.argv 来进行访问
# 参数列表中至少包含一个元素即脚本的名称
import sys
# 获取脚本名
script_name sys.argv[0]# 获取其他参数
other_args sys.argv[1:]如果你使用特殊的选项例如 -c 或 -mPython 会在列表中提供额外的信息。例如当你运行以下命令时
python -c print(Hello, world!)列表会变成
[-c, print(Hello, world!)]这告诉你使用了 -c 选项并且要执行的代码是 print(Hello, world!)。如果使用选项 -m modulesys.argv[0] 就是包含路径的模块的完整名称。
1.4.2 -c和-m选项 -c 和 -m 是 Python 解释器的命令行选项前者用于执行一行代码后者 用于运行指定模块。
-c 选项 -c commend 选项允许你在命令行中执行一行 Python 代码这在需要快速执行一些简单的操作时很有用而不需要创建一个完整的脚本文件。你可以将要执行的代码放在引号中Python 语句经常包含空格或其他会被 shell 特殊对待的字符通常建议用引号将整个 command 括起来。下面是几个简单示例
简单计算
python -c print(10 20)多行代码块你也可以在一行中编写多行代码只需要使用 ; 分隔
python -c x 5; y 10; print(x y)使用模块你可以导入并使用 Python 的内置模块例如时间模块。
python -c import time; print(time.strftime(%Y-%m-%d))创建列表
python -c my_list [1, 2, 3]; doubled [x * 2 for x in my_list]; print(doubled)条件语句
python -c x 15; y 10; print(x is greater if x y else y is greater)-m选项 -m module表示在 sys.path 中搜索指定模块并以 __main__ 模块执行其内容。module是模块名不包括文件扩展名.py。许多标准库模块都包含在执行时都可以以脚本方式调用的代码例如 timeit 模块
python -m timeit -s setup here benchmarked code here
python -m timeit -h # for details你也可以额外指定模块的路径
# 运行my_package 包中的模块my_module
python -m my_package.my_module有关此部分更多内容请参考《命令行与环境》
1.5 解释器的运行环境
1.5.1 编码格式 编码格式Encoding是一种规则或标准它定义了如何映射字符集中的字符到数字编码以便于将文本和字符转换为二进制数据使计算机可以处理、存储和传输它们。因为计算机内部只能处理二进制数据因此任何文本数据在传输到计算机或存储在磁盘上之前都必须经过编码转换。一些常见的编码格式包括
ASCII美国信息交换标准代码 最早的字符编码标准。ASCII编码定义了128个字符7位二进制数比特流用于表示英文字母大写和小写、数字、标点符号以及一些控制字符如换行、回车、制表符等。以下是一些常见的ASCII字符及其描述
ASCII 值字符描述32空格33!感叹号480数字065A大写字母A97a小写字母a126~波浪号127删除 Unicode 一个更为广泛的字符编码标准用于表示世界上几乎所有语言的字符。Unicode支持数千个字符使用16位或32位的二进制数来表示字符。 UTF-8Unicode Transformation Format - 8-bit 是Unicode的一种编码方式使用8位二进制数表示字符。从 Python 3 开始python源码文件默认编码就是UTF-8因为它具有很好的兼容性和节省空间的特点。 UTF-16 和 UTF-32 也是Unicode的编码方式分别使用16位和32位的二进制数来表示字符。它们用于需要大范围字符支持的应用程序。
1.5.2 编码声明 Python 源码文件的字符编码通常在文件开头通过特殊的注释来指定这个注释称为“编码声明”Encoding Declaration。编码声明使用类似于以下形式的注释
# -*- coding: encoding -*-通常情况下Python 源码文件的编码声明会写在文件的第一行。但是如果源码文件以 UNIX “shebang” 行也称为解释器指令用于指定脚本在执行时要使用的解释器开头那么编码声明应该写在文件的第二行例如
#!/usr/bin/env python
# -*- coding: utf-8 -*-# 这是一个 Python 源码文件的例子它使用 UTF-8 编码def print_unicode():print(你好世界) # 这里包含了中文字符print_unicode()在这个示例中第一行 #!/usr/bin/env python 是 UNIX “shebang” 行它告诉操作系统要使用 env 工具来查找系统中的 Python 解释器。因此编码声明 # -*- coding: utf-8 -*- 被放在文件的第二行。
二、Python基础语法 参考《词法分析》 2.1 行结构
Python 程序可以拆分为多个 逻辑行以下是一些基本概念
物理行Physical Line 物理行是指在实际代码文件中的一行文本。每当你在编辑器中按下回车键创建一个新行就会增加一个物理行。逻辑行Logical Line 逻辑行是指在 Python 解释器中被视为单个语句的一行或多行代码。在 Python 中一个逻辑行可能跨越多个物理行。 显示拼接 Python 可以使用反斜杠\来显式地将多个物理行拼接行为一个逻辑行
if 1900 year 2100 and 1 month 12 \and 1 day 31 and 0 hour 24 \and 0 minute 60 and 0 second 60: # Looks like a valid datereturn 1隐式拼接你也可以使用圆括号、方括号、花括号内的表达式来拼接多个物理行
month_names [Januari, Februari, Maart, # These are theApril, Mei, Juni, # Dutch namesJuli, Augustus, September, # for the monthsOktober, November, December] # of the year注释注释是用来解释代码的说明性文本它不会被解释器执行 单行注释 在 Python 中使用 # 符号来表示单行注释注释会从 # 开始一直延伸到该行的结尾。多行注释文档字符串 在 Python 中使用三个引号 或 来表示多行注释也称为文档字符串docstring。文档字符串可以跨足够多的物理行通常被放置在函数、类或模块的开头以提供相关文档和说明。 编码声明见本文1.5.1章节缩进用于定义语句的层次结构同一个代码块内的所有语句应该具有相同的缩进级别。 可以使用空格或制表符进行缩进但不要混合使用二者。通常情况下每个缩进级别使用 4 个空格或者一个Tab键。
2.2 变量标识符 在 Python 中你可以使用变量来存储数据并在后续的代码中使用。变量名是标识符通常由字母、数字和下划线组成但不能以数字开头。
以下是一些变量的示例
age 25
name Alice
height 1.75
is_student True在这个例子中age 存储整数值name 存储字符串height 存储浮点数is_student 存储布尔值。 Python 有35个的关键字也称为保留字它们具有预定义的含义和功能不能用作标识符例如变量名、函数名等。
FalseclassfinallyisreturnNonecontinueforlambdatryTruedeffromnonlocalwhileanddelglobalnotwithaselififoryieldassertelseimportpassbreakexceptinraiseawaitasync
这些保留字在编写 Python 代码时有特定的含义因此不能用作变量名或函数名等标识符。
2.3 字节串 在 Python 中字符串和字节串是两种表示文本数据的方式它们在处理和表示文本上有一些重要的区别。
字符串String 字符串表示文本数据它是用单引号 或双引号 包裹的一串字符序列。字符串字面值可以包含任何字符包括字母、数字、特殊字符等。例如
string1 Hello, World!
string2 Python is fun.字节串Bytes 字节串表示字节数据它是用单引号 b 或双引号 b 包裹的一串字节序列。字节串用于处理二进制数据如图像、音频等文件。每个字节串中的字符都是 0 到 255 之间的整数。例如
bytes1 bHello, World!
bytes2 b\x48\x65\x6c\x6c\x6f # 使用十六进制表示字节区别与用途 编码方式 字符串是用于表示文本数据的它可以使用不同的编码方式如 UTF-8、ASCII来存储不同语言的字符。字节串是原始的字节序列只能包含 ASCII 字符字节串数值大于等于 128 时必须用转义表示。操作和方法 字符串具有字符串操作和方法如拼接、分割、格式化等。字节串主要用于处理二进制数据不支持字符串的大多数操作和方法。 2.4 转义字符和原字符 在Python中转义字符\...是一些特殊字符序列它们用于表示一些无法直接输入或显示的字符如换行、制表符等。 如果不希望前置 \ 字符转义成特殊字符可以使用 原始字符串raw string在引号前添加 r 即可。原始字符串还有一个微妙的限制一个原始字符串不能以奇数个 \ 字符结束。 下面是Python中常见的转义字符以及它们的原字符对应关系
转义字符原字符描述\\\反斜杠\’’单引号\双引号\n换行换行符\r回车回车符\t制表符水平制表符Tab\b退格退格符\f走纸换页换页符\uXXXXUnicode16进制表示的Unicode字符\UXXXXXXXXUnicode32进制表示的Unicode字符
单引号和双引号 字符串可以用成对的单引号 ...或双引号 ...来标示结果完全相同。要标示引号本身我们需要对它进行“转义”即在前面加一个 \。 或者我们也可以使用不同类型的引号即外层用双引号内层用单引号反过来也可以
print(He said, \Hello\ to me.)
print(She replied, \Hi there!\)
# 也可以外面使用双引号里面使用单引号或者反过来
print(He said, Hello to me.)
print(She replied, Hi there!) He said, Hello to me.
She replied, Hi there!换行符和制表符
print(Hello\nWorld)
print(Hello\tWorld)
print(Hello\bWorld)
print(Hello\rWorld)
print(Hello\fWorld)Hello # 换行符
World
Hello World # 制表符
HellWorld # 退格符
World # 回车符
HelloWorld # 换页符反斜杠反斜杠在字符串中被用于表示转义字符,如果你只使用一个反斜杠Python 会认为你想要输入一个特殊的字符而不是真正的反斜杠。所以想表示一个反斜杠需要使用\\或者是使用原字符r。
print(C:\some\name) # \n被表示成了换行符
print(rC:\some\name)
print(C:\\some\\name)
print(rThis is a raw string with \n ) C:\some
ame
C:\some\name
C:\some\name
This is a raw string with \n 2.5 分隔符
分隔符说明()圆括号用于表示元组、函数调用等[]方括号用于表示列表、索引等{}花括号用于表示字典、集合等,逗号用于分隔列表、元组、字典中的元素等:冒号用于表示切片、字典中的键值对等.点号用于调用对象的属性、方法等;分号用于分隔代码行at 符号用于装饰器、装饰器函数等赋值运算符用于赋值操作-用于定义函数的返回类型
2.6 文本样式
在Unix-like终端中可以使用ANSI转义码来控制文本的前景色、背景色和显示方式。在Python中您可以使用这些转义码来在print函数中设置文本的样式。
前景色背景色颜色显示方式意义3040黑色0终端默认设置3141红色1高亮显示3242绿色4使用下划线3343黄色5闪烁3444蓝色7反白显示3545紫红色8不可见
例如print(\033[4;32;43m Colored Text \033[0m)
\033[4;32;43m这部分设置了显示方式和前景色、背景色。4表示使用下划线显示32表示前景色为绿色43m表示背景色为黄色Colored Text这是文本内容\033[0m这部分将显示方式恢复为默认。
# 设置前景色为红色背景色为蓝色高亮显示方式print(\033[1;31;44m Highlighted Text \033[0m) 请注意这些效果在支持ANSI转义码的终端中才会有效。在不同终端和环境中可能会有不同的效果。在Python中使用ANSI转义码时最后要使用\033[0m来将设置恢复为默认值。
三、程序控制 如果是把一个值与多个常量进行比较或者检查特定类型或属性match 语句更有用。详见 match 语句。 Python的控制语句用于控制程序的执行流程使得程序可以根据不同的条件做出不同的决策。Python中常见的控制语句包括条件语句if语句、循环语句for循环和while循环以及跳转语句break、continue和return。
以下是各种控制语句的详细介绍
3.1 条件语句
3.1.1 if 语句 if语句用于在满足特定条件时执行特定的代码块。它的基本结构如下
if 条件:# 条件成立时执行的代码块
elif 其他条件:# 如果上一个条件不成立但其他条件成立时执行的代码块
else:# 如果所有条件都不成立时执行的代码块if语句可以有零个或多个 elif 部分else 部分也是可选的。你也可以使用更简洁的三元运算符在一行代码中根据条件选择两个不同的值例如
x 10
result x 大于 5 if x 5 else x 小于等于 5
print(result)3.1.2 match语句 如果是把一个值与多个常量进行比较或者检查特定类型或属性match 语句更有用。 match语句是Python 3.10版本引入的一项新特性用于模式匹配即将一个值与多个模式进行比较并执行与匹配的模式相对应的代码块。它提供了一种更简洁、更直观的方式来处理多个条件分支使代码更易于理解和维护。以下是match语句的基本结构
match value:case pattern_1:# 匹配 pattern_1 时执行的代码块case pattern_2:# 匹配 pattern_2 时执行的代码块# ...case _:# 默认情况下执行的代码块在match语句中value是要进行模式匹配的值而pattern则是要匹配的模式。每个case子句都包含一个模式和对应的代码块。模式可以是常量、变量、序列、映射等。以下是一些match语句的使用示例
匹配常量和变量
match value:case 0:print(Zero)case x:print(fNon-zero value: {x})print(result)你也可以使用 | 表示 or在一个模式中组合几个值
def http_error(status):match status:case 400:return Bad requestcase 401 | 403 | 404:return Not allowedcase 404:return Not foundcase 418:return Im a teapotcase _:return Somethings wrong with the internet匹配序列、字典
match sequence:case []:print(Empty sequence)case [x, y]:print(fTwo elements: {x}, {y})case [x, *rest]:print(fFirst element: {x}, Rest: {rest})match data:case {name: Alice, age: age}:print(fName: Alice, Age: {age})case {name: name, age: age}:print(fName: {name}, Age: {age})嵌套匹配
match value:case [x, y] if x y:print(Equal elements)case [x, y]:print(Different elements)case _:print(Other case)使用match表达式
result match value:case 0:Zerocase x:fNon-zero value: {x}print(result)这段代码和第一个示例基本是一样的处理只不过最后会把两种匹配情况下value的值最后赋值给result这个变量。最后print(result)语句将打印result的值这可能是Zero或Non-zero value: x。 更多使用方法可参考 官方文档《4.6 match 语句》。 3.2 循环语句
循环语句用于重复执行一段代码块直到满足某个条件为止。Python支持for循环和while循环。
3.2.1 for 循环
for循环用于遍历序列如列表、元组、字符串等中的每个元素并执行相应的代码块。基本结构如下
for 变量 in 序列:# 循环体对每个元素执行的代码块示例
fruits [apple, banana, cherry]
for fruit in fruits:print(fruit)3.2.2 while 循环
while循环用于在满足条件的情况下重复执行一段代码块直到条件不再满足为止。基本结构如下
while 条件:# 循环体满足条件时执行的代码块示例
count 0
while count 5:print(count)count 13.2.3 循环中的else子句 Python中的循环语句可以附带一个else子句它在循环正常结束时执行但循环被break中断后就不会执行。下面的搜索质数的 for 循环就是一个例子其中else 子句属于 for 循环不属于 if 语句。 循环正常结束在for 循环中就是成功进行最后一次循环迭代没有被break中断在while循环中就是循环条件变为假值后结束循环。 for num in range(2, 10):for i in range(2, num):if num % i 0:print(num, 不是质数)breakelse:print(num, 是质数)3.2.4 生成器表达式和列表推导式 生成器表达式和列表推导式都允许你在一行代码中创建新的序列或者从现有的序列中选择、转换或过滤元素。
生成器表达式生成结果是一个可迭代的生成器只在迭代时才生成元素惰性计算因此在处理大量数据时更节省内存、更高效。
squares (x ** 2 for x in range(10))
evens (x for x in range(10) if x % 2 0)print(list(squares)) # 转换为列表
print(list(evens))列表推导式生成结果是一个列表即一次性生成并存储所有的元素。
squares [x ** 2 for x in range(10)]
even_squares [x ** 2 for x in range(10) if x % 2 0]print(squares)
print(even_squares)生成器表达式使用的语法与列表推导式非常相似只是使用圆括号而不是方括号。在大多数情况下生成器表达式的运行速度更快因为它避免了一次性创建和存储大量元素。如果你需要一次性操作所有元素并创建一个新列表列表推导式是不错的选择。如果你需要按需生成数据并进行迭代生成器表达式更合适。
3.3 跳转语句
跳转语句用于改变程序的执行流程。
break语句break 语句将跳出最近的一层 for 或 while 循环。continue语句用于结束当前循环的这一轮迭代继续执行下一轮循环。return语句用于从函数中返回值并终止函数的执行。
示例
for num in range(10):if num 5:break # 当 num 等于 5 时跳出循环print(num)for num in range(10):if num % 2 0:continue # 当 num 是偶数时跳过本次循环的剩余部分继续下一轮循环print(num)def add(x, y):return x y # 返回 x 和 y 的和并终止函数执行3.4 pass 语句 pass 语句不执行任何动作。语法上需要一个语句但程序毋需执行任何动作时可以使用该语句。这常用于创建一个最小的类
class MyEmptyClass:passpass 还可用作函数或条件语句体的占位符让你保持在更抽象的层次进行思考
def initlog(*args):pass # Remember to implement this!3.5 循环控制进阶
3.5.1 enumerate函数在循环中同时获取索引和元素。
语法enumerate(iterable, start0)。其中iterable是要枚举的可迭代对象如列表、元组、字符串等start是索引的起始值默认为0。
fruits [apple, banana, cherry]
for index, fruit in enumerate(fruits):print(fIndex {index}: {fruit})Index 0: apple
Index 1: banana
Index 2: cherry3.5.2 zip函数在循环中同时遍历多个序列。 zip(iterable1, iterable2, ...)函数返回一个迭代器每次迭代都会返回一个元组其中包含了传入的每个可迭代对象的对应元素
numbers [1, 2]
letters [a, b, c]
zipped zip(numbers, letters) # 创建一个zip对象可用于迭代for item in zipped:print(item) # 输出(1, a)(2, b)在此示例中zipped是一个迭代器每次迭代返回一个元组包含来自numbers和letters对应位置的元素。需要注意的是如果两个输入可迭代对象的长度不一致zip()函数会截断到最短的长度。
3.5.3 reversed 函数可用于对序列进行逆向循环 reversed()函数是Python内置函数之一用于反转序列类型列表、元组、字符串等的数据。需要注意的是reversed()函数返回的是一个迭代器而不是实际的列表或序列这意味着它只能被遍历一次。如果想要创建一个反转后的列表可以使用list()函数将迭代器转换为列表。
for i in reversed(range(1, 10, 2)):print(i) # 输出 9,75,313.5.4 . sorted 函数在不改动原序列的基础上按指定顺序循环序列
basket [apple, orange, apple, pear, orange, banana]
for f in sorted(set(basket)):print(f) # 输出apple,banana,orange,pear
3.5.5 sort和sorted详解
3.5.5.1 基本语法 sort()和sorted()都是Python中用于排序序列如列表的函数它们可以按照升序从小到大或降序从大到小的方式排列元素。
1. sort()方法对列表本身进行原地排序即直接修改原列表不会返回新的列表。基本语法如下
list.sort(keyNone, reverseFalse)key用于指定排序的规则可选参数可以是一个函数它会应用于列表中的每个元素并返回一个用于比较的关键字。reverse指定排序顺序为True时降序排序默认为False。
示例
names [Alice, Bob, Charlie, David]
names.sort(keylen)
print(names) # 输出[Bob, Alice, David, Charlie]2. sorted()函数一个全局函数用于对任何可迭代对象如列表、元组、字符串等进行排序返回一个新的已排序的列表不会修改原始序列。基本语法如下
sorted(iterable, keyNone, reverseFalse)iterable要排序的可迭代对象。key用于指定排序的规则可选参数可以是一个函数它会应用于可迭代对象中的每个元素并返回一个用于比较的关键字。reverse指定排序顺序为True时降序排序默认为False。
使用sorted()函数的示例
names [Alice, Bob, Charlie, David]
sorted_names sorted(names, keylen)
print(sorted_names) # 输出[Bob, Alice, David, Charlie]3.5.5.2 key 参数用于复杂排序的各种可能 key参数在排序时用于指定一个函数这个函数将应用于可迭代对象中的每个元素并返回一个用于比较的关键字。通过key参数您可以实现对复杂对象的排序例如根据对象的某个属性或特征进行排序。下面是一些示例演示了不同类型的key参数的可能性
按照字符串长度排序
names [Alice, Bob, Charlie, David]
sorted_names sorted(names, keylen)
print(sorted_names) # 输出[Bob, Alice, David, Charlie]按照字符串的最后一个字符排序
words [apple, banana, cherry, date]
sorted_words sorted(words, keylambda x: x[-1])
print(sorted_words) # 输出[banana, cherry, apple, date]按照对象的某个属性排序
# 根据每个人的年龄进行排序
class Person:def __init__(self, name, age):self.name nameself.age agepeople [Person(Alice, 25), Person(Bob, 30), Person(Charlie, 22)]
sorted_people sorted(people, keylambda person: person.age)
for person in sorted_people:print(person.name, person.age)Charlie 22
Alice 25
Bob 30按照自定义函数返回值排序
numbers [3, 5, 8, 1, 4]
def custom_key(num):return num % 2 # 奇数在前偶数在后sorted_numbers sorted(numbers, keycustom_key)
print(sorted_numbers) # 输出[3, 5, 1, 8, 4]按照字典中某个键的值排序
# 根据水果价格进行排序
fruits [{name: apple, price: 1.0},{name: banana, price: 0.5},{name: cherry, price: 2.0}
]
sorted_fruits sorted(fruits, keylambda fruit: fruit[price])
for fruit in sorted_fruits:print(fruit[name], fruit[price])banana 0.5
apple 1.0
cherry 2.0四、函数
4.1 函数的基本定义 在编程中函数是一种可重用的代码块用于执行特定任务或操作。通过使用函数我们可以我们能够将一个大问题分解成多个小任务从而简化编程过程可以将代码组织得更加模块化使其易于管理和维护。 在Python中我们使用关键字 def 来定义函数。它可以接受输入参数执行特定操作并返回输出结果。函数定义的基本结构如下
def function_name(parameters):# 函数体# 执行任务的代码return result # 可选的返回值其中
function_name 是函数的名称你可以为函数取一个有意义的名字。parameters 是函数的参数列表它们是函数执行所需的输入。 一旦你定义了函数就可以在代码的其他地方调用它。调用函数时你需要提供参数以便函数可以使用它们来执行操作。下面是一个简单的示例
def greet(name):return Hello, name !# 调用函数
result greet(Alice)
print(result) # 输出Hello, Alice!在上面的示例中我们定义了一个名为 greet 的函数它接受一个参数 name。当我们调用 greet(Alice) 时函数会返回 Hello, Alice!。
4.2 作用域、局部变量和全局变量 在Python中“作用域”Scope是一个指定变量可见性和可访问性的概念。作用域规定了在哪些地方可以访问或引用变量。Python有两种主要的作用域 全局作用域Global Scope全局作用域是程序中所有函数之外的区域通常包括在顶层定义的变量和函数。在全局作用域中声明的变量称之为全局变量可以在整个程序中进行访问。 局部作用域Local Scope函数内部声明的变量默认属于局部变量其作用域就是局部作用域即只能在函数内部进行访问。局部变量仅在函数执行时才存在当函数执行完毕后局部变量会被销毁所以函数外部无法直接访问这些变量。
关于全局变量和局部变量还遵循以下原则
在函数内部尝试修改全局变量的值Python将会创建一个新的局部变量而不会影响全局变量。要在函数内部修改全局变量的值需要使用 global 关键字。在局部作用域中如果有一个与全局作用域同名的变量那么局部作用域的变量会遮蔽覆盖全局作用域的变量但不会影响全局变量的值。局部变量为组合数据类型且未创建时等同于全局变量
以下是一个展示全局变量和局部变量之间关系的例子
global_var 5 # 这是一个全局变量def modify_global():# 如果不使用global关键字那么global_var就是函数内部的一个局部变量且没有预先定义所以程序会报错。global global_var # 使用 global 关键字来引用全局变量global_var 1local_var 10 # 这是一个局部变量print(Inside the function: global_var , global_var)print(Inside the function: local_var , local_var)modify_global()
print(Outside the function: global_var , global_var) # 全局变量的值被修改了
print(Outside the function: local_var , local_var) # 这里会报错因为 local_var 是局部变量函数外部无法访问Inside the function: global_var 6
Inside the function: local_var 10
Outside the function: global_var 6在下面的示例中虽然函数内部的局部变量 global_var 与全局变量 global_var 同名但在函数内部打印时使用的是局部变量 global_var 的值6而在函数外部打印时使用的是全局变量 global_var 的值5。
global_var 5 # 这是一个全局变量def modify_global():global_var 6 # 同名局部变量遮蔽全局变量global_var 1 print(Inside the function: global_var , global_var)modify_global()
print(Outside the function: global_var , global_var) # 外部的全局变量的值没有改变Inside the function: global_var 7
Inside the function: local_var 10
Outside the function: global_var 5当函数内部使用一个未创建的局部变量并且这个局部变量是一个组合数据类型如列表、字典等那么在函数内部对该局部变量的修改会影响到全局变量就好像这个局部变量是全局变量一样。
my_list [1, 2, 3] # 这是一个全局变量def modify_list():my_list.append(4) # 在函数内部使用未创建的局部变量 my_listmodify_list()
print(my_list) # 输出[1, 2, 3, 4]在这个示例中函数 modify_list 内部没有显式地声明 my_list 是局部变量而是直接对其进行了修改。由于 my_list 是一个组合数据类型列表Python 认为它是全局变量并且在函数内部对它的修改实际上影响了全局变量。
4.3 参数
4.3.1 五种函数参数 在编程中函数参数是我们传递给函数的值这些值用于在函数内执行特定操作。按照函数的定义参数可以分为形参和实参
形参Parameters这些是函数定义中列出的参数用于接收输入数据。实参Arguments函数在调用时传递给函数的实际值。
按照参数的传递方式可以分为以下几类
位置参数最常见的参数类型。当我们调用函数时位置参数按照它们在函数定义中的顺序传递。
def greet(name, age):return Hello, name ! You are str(age) years old.result greet(Alice, 25)
print(result) # 输出Hello, Alice! You are 25 years old.在上面的示例中函数 greet 接受两个位置参数name 和 age。当我们调用 greet(Alice, 25) 时参数按照顺序传递给函数。
关键字参数以keyvalue的形式我们可以在调用函数时明确指定每个参数的值而不必遵循位置顺序。这使得代码更具可读性并避免了参数位置的混淆。
def greet(name, age):return Hello, name ! You are str(age) years old.result greet(age30, nameCharlie)
print(result) # 输出Hello, Charlie! You are 30 years old.在上面的示例中我们使用关键字参数来明确指定了参数的值而不受函数定义中的顺序影响。
默认参数有时候我们希望函数的某些参数拥有默认值以便在调用函数时不必总是提供这些参数。我们可以通过为参数设置默认值来实现这一点
def greet(name, age18):return Hello, name ! You are str(age) years old.result greet(Bob)
print(result) # 输出Hello, Bob! You are 18 years old.在上面的示例中参数 age 被设置为默认值 18。如果我们不传递 age 参数函数将使用默认值。 4. 可变参数有时候你可能需要传递不确定数量的参数给函数。Python 提供了两种方式来实现这一点
*args 接收任意数量的位置参数元组形式**kwargs 接收任意数量的关键字参数字典形式
def print_items(*args):for item in args:print(item)print_items(apple, banana, cherry) # 输出apple banana cherrydef print_info(**kwargs):for key, value in kwargs.items():print(key : value)print_info(nameAlice, age30, cityNew York)
# 输出
# name: Alice
# age: 30
# city: New York特殊形参限制了参数传递的方式的形参可以增强代码的可读性并防止参数的错误传递。 仅限位置的形参Position-Only Parameters用 / 标识只能通过位置传递值。仅限关键字的形参Keyword-Only Parameters用 * 标识只能通过关键字参数的方式传递值。
示例
def my_function(a, b, /):# 函数体# a 和 b 是仅限位置的形参只能通过位置传递值。def my_function(*, x, y):# 函数体# x 和 y 是仅限关键字的形参只能通过关键字参数的方式传递值。4.3.2 参数使用规则
函数定义如下
def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2 ):----------- ---------- ----------| | || Positional or keyword || - Keyword only-- Positional only位置参数必须位于关键字参数之前。可变参数通常放在位置参数和关键字参数之后以确保它们能够收集剩余的参数值。
假设你有这样一个函数定义
def complex_function(a, b, c0, *args, **kwargs):# 函数体那么在调用这个函数时可以按照上述顺序传递参数
complex_function(1, 2, 3, 4, 5, x6, y7)错误的调用示例
位置参数放在关键字参数之后
complex_function(a1, b2, 3, x4)关键字参数放在可变位置参数之后
complex_function(1, 2, x3, 4)关键字参数放在可变关键字参数之后
complex_function(1, 2, 3, x4, 5)重复传递相同参数
complex_function(1, 2, 3, 4, 5, x6, x7) # 重复的关键字参数 x4.3.3 任意实参列表和解包实参列表
任意实参列表使用 * 表示的任意实参列表会将传递给函数的所有位置参数收集到一个元组中。这使得你可以在函数内部处理多个参数而不需要提前知道有多少个参数会传递进来。
def concat(*args, sep/):return sep.join(args)concat(earth, mars, venus) # 输出earth/mars/venus
concat(earth, mars, venus, sep.) # 输出earth.mars.venus解包实参列表即使用 * 或**来解包一个可迭代对象列表、元组、字典等将其中的每个元素都当作一个位置参数传递给函数。
def add(a, b):return a bnumbers [3, 5]
result add(*numbers) # 等同于 add(3, 5)
print(r)args [3, 6]
list(range(*args)) # 等同于list(range(3, 6))
[3, 4, 5]同样字典可以用 ** 操作符传递关键字参数
def parrot(voltage, statea stiff, actionvoom):print(-- This parrot wouldnt, action, end )print(if you put, voltage, volts through it., end )print(Es, state, !)d {voltage: four million, state: bleedin demised, action: VOOM}
parrot(**d)
-- This parrot wouldnt VOOM if you put four million volts through it. Es bleedin demised !总结
任意实参列表使用 * 来收集传递给函数的位置参数使函数能够接收任意数量的参数。解包实参列表使用 * 来将一个可迭代对象解包为单独的参数方便将元素传递给函数。
这两种技巧都能够提高函数的灵活性让你可以更方便地处理不确定数量的参数。
4.4 匿名函数lambda lambda 函数是Python中的一种匿名函数它可以在一行内定义简单的函数。它的语法非常简洁通常用于一些简单的操作和表达式。lambda 函数的基本形式如下
lambda arguments: expression其中arguments 是参数列表expression 是函数体的表达式。lambda 函数返回一个函数对象你可以将其赋值给一个变量然后通过这个变量调用这个匿名函数。以下是 lambda 函数的几种常见用法
使用 lambda 函数作为简单的函数
add lambda x, y: x y
result add(5, 3) # 结果为 8在排序时使用 lambda 函数作为键函数
data [(1, apple), (3, banana), (2, cherry)]
sorted_data sorted(data, keylambda x: x[1]) # 按照水果名进行排序在 map()、filter() 等函数中使用 lambda 函数
numbers [1, 2, 3, 4, 5]
squared_numbers map(lambda x: x ** 2, numbers) # 对每个数求平方
even_numbers filter(lambda x: x % 2 0, numbers) # 过滤出偶数使用 lambda 函数创建某些回调函数或小规模的逻辑操作
callbacks [lambda x: x * 2, lambda x: x ** 2]
result1 callbacks[0](5) # 结果为 10
result2 callbacks[1](3) # 结果为 9需要注意的是虽然 lambda 函数在一些场景中很有用但它的使用应该谨慎。对于较为复杂的逻辑最好还是使用普通的命名函数以便代码更易读和维护。
4.5 map函数和filter函数 当你需要对一个可迭代对象如列表、元组等中的每个元素进行操作时map 和 filter 是两个非常有用的Python内置函数。
map 函数 map 函数用于将一个函数应用于可迭代对象中的每个元素返回一个新的可迭代对象其中包含了应用函数后的结果。
def square(x):return x ** 2numbers [1, 2, 3, 4, 5]
squared_numbers map(square, numbers)
# 返回一个 map 对象可以使用 list() 函数将其转换为列表
result list(squared_numbers) # 结果为 [1, 4, 9, 16, 25]也可以使用 lambda 函数来实现相同的功能
numbers [1, 2, 3, 4, 5]
squared_numbers map(lambda x: x ** 2, numbers)
result list(squared_numbers) # 结果为 [1, 4, 9, 16, 25]filter() 函数 filter() 函数用于从可迭代对象中筛选出满足某个条件的元素返回一个新的可迭代对象其中包含了满足条件的元素。
def is_even(x):return x % 2 0numbers [1, 2, 3, 4, 5]
even_numbers filter(is_even, numbers)
# 返回一个 filter 对象可以使用 list() 函数将其转换为列表
result list(even_numbers) # 结果为 [2, 4]同样也可以使用 lambda 函数来实现相同的功能
numbers [1, 2, 3, 4, 5]
even_numbers filter(lambda x: x % 2 0, numbers)
result list(even_numbers) # 结果为 [2, 4]map 和filter函数都可以用于对可迭代对象中的每个元素应用一个函数返回结果也都是可迭代对象。但是前者应用的函数类似一个计算式例如x**2后者是应用的函数是一个条件判断式例如x % 2 0。所以前者会返回所有元素的计算结果而后者是条件筛选后的元素。
4.6 文档字符串和函数注解 文档字符串Docstrings 是位于函数、模块、类或方法定义的第一个语句是用于描述它们用途和功能的说明性文本。文档字符串通常使用三重引号单引号或双引号来定义可以跨越多行。你可以通过特殊的属性如 __doc__来访问它们。以下是编写文档字符串时的一些常见规则和惯例
文档字符串应该提供关于代码元素的清晰、简洁和详细的描述包括以下内容 代码元素的目的和功能。参数的说明包括参数名称、类型、默认值和含义。返回值的说明包括返回值的类型和含义。举例和用法示例以帮助用户理解如何使用该代码元素。可能的异常情况和错误处理方式。
使用标准格式以便能够被文档生成工具如Sphinx和阅读工具如IDE正确解析和渲染。 以一行简要描述开头概括代码元素的主要目的。 使用段落或分节标题来组织文档使其易于阅读。使用缩进或标点符号来突出重要信息。在需要时使用代码示例来说明使用方法。
def calculate_area(length, width):Calculate the area of a rectangle.Args:length (float): The length of the rectangle.width (float): The width of the rectangle.Returns:float: The area of the rectangle.Example: calculate_area(5, 3)15.0return length * widthprint(calculate_area.__doc__)总之遵循一致的文档字符串书写规则和惯例有助于统一团队的文档风格提高代码的可读性和可维护性帮助其他开发者更好的理解和使用你的代码。 函数注解Function Annotations 是Python中的一项特性它允许你为函数的参数和返回值提供额外的元数据信息详见 PEP 3107 和 PEP 484 通常用于指定参数和返回值的数据类型或其他相关信息。函数注解不会影响函数的实际行为但它们提供了有用的元数据可以用于文档、类型检查和其他用途。下面是关于函数注解的详细介绍 语法 函数注解是在函数定义中的参数和返回值后面使用冒号:来指定的。语法如下 def function_name(param1: annotation1, param2: annotation2, ...) - return_annotation:# 函数体param1, param2, …: 这些是函数的参数名。annotation1, annotation2, …: 这些是注解通常用于指定参数的类型。注解可以是任何表达式但通常是数据类型名称。return_annotation: 这是函数的返回值的注解通常用于指定返回值的类型。 类型提示 最常见的用途是使用函数注解来提供参数和返回值的类型提示。这有助于代码的可读性并允许一些类型检查工具如静态类型检查器进行类型验证以减少潜在的类型错误。 注解可以是任何表达式 虽然通常用于类型提示但注解可以是任何合法的Python表达式包括函数、类或常量的引用。这使得你可以将自定义对象用作注解以提供更多元数据信息。 示例 def process_data(data: DataObject) - ProcessedData:# 函数体不影响实际行为 函数注解以字典的形式存放在函数的 __annotations__ 属性中不会改变函数的实际行为它们只是提供了元数据信息。Python解释器不会自动执行类型检查或强制类型转换。
以下是一个简单的示例
def f(ham: str, eggs: str eggs) - str:print(Annotations:, f.__annotations__)print(Arguments:, ham, eggs)return ham and eggsf(spam)
Annotations: {ham: class str, return: class str, eggs: class str}
Arguments: spam eggs
spam and eggs4.7 编码风格 编码风格Coding Style是指编程时采用的一套一致性规则和约定用于指导代码的组织、格式、命名以及注释等方面。编码风格有助于提高代码的可读性、可维护性和可协作性使不同开发者之间的代码具有一致的外观和结构。 PEP 8Python Enhancement Proposal 8是一份被广泛接受的python编码风格指南它推行的编码风格易于阅读、赏心悦目。以下是 PEP 8 中一些重要的编码风格规范
缩进 使用 4 个空格作为缩进。不要使用制表符进行缩进。行长限制 每行代码最好不要超过 79 个字符。对于注释和文档字符串最好不要超过 72 个字符这样换行的小屏阅读体验更好还便于在大屏显示器上并排阅读多个代码文件。空格 在运算符周围使用空格但不要在函数调用和索引的内部使用空格。例如result a b。逗号后要用空格当在函数调用、列表、元组等数据结构中使用逗号分隔元素时建议在逗号后面添加空格以使代码更清晰但是不要直接在括号内使用空格。
my_tuple (1, 2, 3) # 正确写法my_tuple ( 1, 2, 3 ) # 不推荐在括号内部使用了空格空行 使用空行来分隔函数定义、类定义、以及较大的逻辑块。函数内部可以使用空行来分隔不同的逻辑部分。导入 每个导入语句应该单独占一行。导入应该按照标准库、第三方库、自己的模块的顺序排序。避免使用通配符导入from module import *。命名规范 使用小写字母和下划线来命名变量和函数snake_case。使用首字母大写的驼峰命名法来命名类CamelCase。使用全部大写字母和下划线来命名常量CONFIG_FILE_NAME “config.txt” 注释 编写清晰、有意义的注释来解释代码的功能。注释应该使用英文避免使用无意义的注释。函数和方法 函数和方法应该有简洁的、描述性的名称。函数定义后应该有两个空行。函数内部的代码块之间可以使用一个空行分隔。
