Python官网、Python 3.11.5 中文文档、慕课:Python语言程序设计
在计算机编程中,编程是指编写一系列指令,以便计算机执行特定的任务。编程语言就像是我们与计算机进行交流的工具,它们允许我们用人类可以理解的方式来描述任务和操作。
Python 是一种广泛使用的高级编程语言,它的语法简单清晰,非常适合初学者入门。Python 可以用来开发各种类型的应用,包括 Web 应用、数据分析、人工智能等。
为什么要学习 Python 呢?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允许在用户级别和系统级别永久配置环境变量,或临时在命令提示符中配置环境变量,请参考《设置环境变量》
Python 解释器是一种程序,它能够读取并执行 Python 代码。每当你编写 Python 代码并运行时,实际上是通过解释器将你的代码转换成计算机可以理解的指令。Python 有多个解释器可供选择,以下是一些常见的 Python 解释器:
Python 解释器有两种主要使用方式:
CPython
:Python 编程语言的官方实现,使用C语言开发,是最常用的 Python 解释器之一,在多数情况下,“Python” 指的就是 CPython
。
CPython
使用全局解释锁(Global Interpreter Lock,GIL)来确保在同一时间只能有一个线程执行 Python 代码。这可以导致在多线程程序中存在一些性能限制(在多线程章节会详述)。
Jython
:Jython是运行在Java虚拟机(JVM)上的Python解释器。它允许Python代码与Java代码相互调用,可以在Java平台上使用Python进行开发。
IronPython
:运行在 .NET 平台上
PyPy
:一个高性能的 JIT (即时编译)编译器实现,在某些情况下比CPython更快地执行代码。
MicroPython
:用于 IoT 设备和嵌入式系统,专为资源受限的环境设计,可以在微控制器和其他小型设备上运行
python解释器主要有两种使用方式:
在cmd中,输入python即可进入python交互模式,按下Ctrl+z后回车,即可退出,或者是输入
quit()
。
.py
结尾的 Python 脚本文件,然后在终端或命令提示符中运行它。解释器会按顺序执行文件中的代码。例如,假设你有一个名为 hello.py 的脚本文件,其中包含以下代码:
print("Hello, world!")
你可以在终端中输入以下命令运行脚本:
python hello.py
当你在命令行中运行一个 Python 脚本时,Python 解释器会把你输入的命令行信息转换成一个列表,这个列表被称为“命令行参数列表”。这个列表中包含了一些有用的信息,比如脚本的名字和其他参数。
假设你有一个名为 script.py
的 Python 脚本,当你在命令行中输入以下内容时:
python script.py arg1 arg2
Python 解释器会将这些内容转换成一个列表,并存到 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
或 -m
,Python 会在列表中提供额外的信息。例如,当你运行以下命令时:
python -c "print('Hello, world!')"
列表会变成:
['-c', "print('Hello, world!')"]
这告诉你使用了 -c
选项,并且要执行的代码是 "print('Hello, world!')"
。如果使用选项 -m module
,sys.argv[0]
就是包含路径的模块的完整名称。
-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 -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
有关此部分更多内容,请参考《命令行与环境》
编码格式(Encoding)是一种规则或标准,它定义了如何映射字符集中的字符到数字编码,以便于将文本和字符转换为二进制数据,使计算机可以处理、存储和传输它们。因为计算机内部只能处理二进制数据,因此任何文本数据在传输到计算机或存储在磁盘上之前,都必须经过编码转换。一些常见的编码格式包括:
ASCII 值 | 字符 | 描述 |
---|---|---|
32 | 空格 | |
33 | ! | 感叹号 |
48 | 0 | 数字0 |
65 | A | 大写字母A |
97 | a | 小写字母a |
126 | ~ | 波浪号 |
127 | 删除 |
Unicode: 一个更为广泛的字符编码标准,用于表示世界上几乎所有语言的字符。Unicode支持数千个字符,使用16位或32位的二进制数来表示字符。
UTF-8(Unicode Transformation Format - 8-bit): 是Unicode的一种编码方式,使用8位二进制数表示字符。从 Python 3 开始,python源码文件默认编码就是UTF-8,因为它具有很好的兼容性和节省空间的特点。
UTF-16 和 UTF-32: 也是Unicode的编码方式,分别使用16位和32位的二进制数来表示字符。它们用于需要大范围字符支持的应用程序。
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 程序可以拆分为多个 逻辑行,以下是一些基本概念:
\
)来显式地将多个物理行拼接行为一个逻辑行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 date
return 1
month_names = ['Januari', 'Februari', 'Maart', # These are the
'April', 'Mei', 'Juni', # Dutch names
'Juli', 'Augustus', 'September', # for the months
'Oktober', 'November', 'December'] # of the year
#
符号来表示单行注释,注释会从 #
开始一直延伸到该行的结尾。'''
或 """
来表示多行注释,也称为文档字符串(docstring)。文档字符串可以跨足够多的物理行,通常被放置在函数、类或模块的开头,以提供相关文档和说明。在 Python 中,你可以使用变量来存储数据,并在后续的代码中使用。变量名是标识符,通常由字母、数字和下划线组成,但不能以数字开头。
以下是一些变量的示例:
age = 25
name = "Alice"
height = 1.75
is_student = True
在这个例子中,age
存储整数值,name
存储字符串,height
存储浮点数,is_student
存储布尔值。
Python 有35个的关键字(也称为保留字),它们具有预定义的含义和功能,不能用作标识符(例如变量名、函数名等)。
False |
class |
finally |
is |
return |
None |
continue |
for |
lambda |
try |
True |
def |
from |
nonlocal |
while |
and |
del |
global |
not |
with |
as |
elif |
if |
or |
yield |
assert |
else |
import |
pass |
break |
except |
in |
raise |
await |
async |
这些保留字在编写 Python 代码时有特定的含义,因此不能用作变量名或函数名等标识符。
在 Python 中,字符串和字节串是两种表示文本数据的方式,它们在处理和表示文本上有一些重要的区别。
''
或双引号 ""
包裹的一串字符序列。字符串字面值可以包含任何字符,包括字母、数字、特殊字符等。例如:string1 = 'Hello, World!'
string2 = "Python is fun."
b''
或双引号 b""
包裹的一串字节序列。字节串用于处理二进制数据,如图像、音频等文件。每个字节串中的字符都是 0 到 255 之间的整数。例如:bytes1 = b'Hello, World!'
bytes2 = b'\x48\x65\x6c\x6c\x6f' # 使用十六进制表示字节
区别与用途:
- 编码方式: 字符串是用于表示文本数据的,它可以使用不同的编码方式(如 UTF-8、ASCII)来存储不同语言的字符。字节串是原始的字节序列,只能包含 ASCII 字符;字节串数值大于等于 128 时,必须用转义表示。
- 操作和方法: 字符串具有字符串操作和方法,如拼接、分割、格式化等。字节串主要用于处理二进制数据,不支持字符串的大多数操作和方法。
在Python中,转义字符\...
是一些特殊字符序列,它们用于表示一些无法直接输入或显示的字符,如换行、制表符等。
如果不希望前置 \
字符转义成特殊字符,可以使用 原始字符串(raw string),在引号前添加 r 即可。原始字符串还有一个微妙的限制:一个原始字符串不能以奇数个 \
字符结束。
下面是Python中常见的转义字符以及它们的原字符对应关系:
转义字符 | 原字符 | 描述 |
---|---|---|
\\ | \ | 反斜杠 |
\’ | ’ | 单引号 |
\" | " | 双引号 |
\n | 换行 | 换行符 |
\r | 回车 | 回车符 |
\t | 制表符 | 水平制表符(Tab) |
\b | 退格 | 退格符 |
\f | 走纸换页 | 换页符 |
\uXXXX | Unicode | 16进制表示的Unicode字符 |
\UXXXXXXXX | Unicode | 32进制表示的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 # 换页符
\\
,或者是使用原字符r。print('C:\some\name') # \n被表示成了换行符
print(r'C:\some\name')
print('C:\\some\\name')
print(r"This is a raw string with \n ")
C:\some
ame
C:\some\name
C:\some\name
This is a raw string with \n
分隔符 | 说明 |
---|---|
() | 圆括号,用于表示元组、函数调用等 |
[] | 方括号,用于表示列表、索引等 |
{} | 花括号,用于表示字典、集合等 |
, | 逗号,用于分隔列表、元组、字典中的元素等 |
: | 冒号,用于表示切片、字典中的键值对等 |
. | 点号,用于调用对象的属性、方法等 |
; | 分号,用于分隔代码行 |
@ | at 符号,用于装饰器、装饰器函数等 |
= | 赋值运算符,用于赋值操作 |
-> | 用于定义函数的返回类型 |
在Unix-like终端中,可以使用ANSI转义码来控制文本的前景色、背景色和显示方式。在Python中,您可以使用这些转义码来在print函数中设置文本的样式。
前景色 | 背景色 | 颜色 | 显示方式 | 意义 |
---|---|---|---|---|
30 | 40 | 黑色 | 0 | 终端默认设置 |
31 | 41 | 红色 | 1 | 高亮显示 |
32 | 42 | 绿色 | 4 | 使用下划线 |
33 | 43 | 黄色 | 5 | 闪烁 |
34 | 44 | 蓝色 | 7 | 反白显示 |
35 | 45 | 紫红色 | 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)。
以下是各种控制语句的详细介绍:
if
语句用于在满足特定条件时执行特定的代码块。它的基本结构如下:
if 条件:
# 条件成立时执行的代码块
elif 其他条件:
# 如果上一个条件不成立,但其他条件成立时执行的代码块
else:
# 如果所有条件都不成立时执行的代码块
if
语句可以有零个或多个 elif
部分,else
部分也是可选的。你也可以使用更简洁的三元运算符,在一行代码中根据条件选择两个不同的值,例如:
x = 10
result = "x 大于 5" if x > 5 else "x 小于等于 5"
print(result)
如果是把一个值与多个常量进行比较,或者检查特定类型或属性,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(f"Non-zero value: {x}")
print(result)
你也可以使用 |
(表示 or)在一个模式中组合几个值:
def http_error(status):
match status:
case 400:
return "Bad request"
case 401 | 403 | 404:
return "Not allowed"
case 404:
return "Not found"
case 418:
return "I'm a teapot"
case _:
return "Something's wrong with the internet"
match sequence:
case []:
print("Empty sequence")
case [x, y]:
print(f"Two elements: {x}, {y}")
case [x, *rest]:
print(f"First element: {x}, Rest: {rest}")
match data:
case {"name": "Alice", "age": age}:
print(f"Name: Alice, Age: {age}")
case {"name": name, "age": age}:
print(f"Name: {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:
"Zero"
case x:
f"Non-zero value: {x}"
print(result)
这段代码和第一个示例基本是一样的处理,只不过最后会把两种匹配情况下value的值,最后赋值给result这个变量。最后,print(result)
语句将打印result
的值,这可能是Zero
或Non-zero value: x
。
更多使用方法,可参考 官方文档《4.6 match 语句》。
循环语句用于重复执行一段代码块,直到满足某个条件为止。Python支持for循环和while循环。
for循环用于遍历序列(如列表、元组、字符串等)中的每个元素,并执行相应的代码块。基本结构如下:
for 变量 in 序列:
# 循环体,对每个元素执行的代码块
示例:
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
while循环用于在满足条件的情况下重复执行一段代码块,直到条件不再满足为止。基本结构如下:
while 条件:
# 循环体,满足条件时执行的代码块
示例:
count = 0
while count < 5:
print(count)
count += 1
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, "不是质数")
break
else:
print(num, "是质数")
生成器表达式和列表推导式都允许你在一行代码中创建新的序列,或者从现有的序列中选择、转换或过滤元素。
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)
生成器表达式使用的语法与列表推导式非常相似,只是使用圆括号而不是方括号。在大多数情况下,生成器表达式的运行速度更快,因为它避免了一次性创建和存储大量元素。如果你需要一次性操作所有元素并创建一个新列表,列表推导式是不错的选择。如果你需要按需生成数据并进行迭代,生成器表达式更合适。
跳转语句用于改变程序的执行流程。
示例:
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 的和,并终止函数执行
pass
语句不执行任何动作。语法上需要一个语句,但程序毋需执行任何动作时,可以使用该语句。这常用于创建一个最小的类:
class MyEmptyClass:
pass
pass
还可用作函数或条件语句体的占位符,让你保持在更抽象的层次进行思考:
def initlog(*args):
pass # Remember to implement this!
enumerate
函数:在循环中同时获取索引和元素。语法:enumerate(iterable, start=0)
。其中,iterable是要枚举的可迭代对象(如列表、元组、字符串等),start是索引的起始值(默认为0)。
fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits):
print(f"Index {index}: {fruit}")
Index 0: apple
Index 1: banana
Index 2: cherry
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()
函数会截断到最短的长度。
reversed
函数:可用于对序列进行逆向循环 reversed()
函数是Python内置函数之一,用于反转序列类型(列表、元组、字符串等)的数据。需要注意的是,reversed()
函数返回的是一个迭代器,而不是实际的列表或序列,这意味着它只能被遍历一次。如果想要创建一个反转后的列表,可以使用list()
函数将迭代器转换为列表。
for i in reversed(range(1, 10, 2)):
print(i) # 输出 9,7,5,3,1
sorted
函数:在不改动原序列的基础上,按指定顺序循环序列basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
print(f) # 输出apple,banana,orange,pear
sort
和sorted
详解 sort()
和sorted()
都是Python中用于排序序列(如列表)的函数,它们可以按照升序(从小到大)或降序(从大到小)的方式排列元素。
1. sort()
方法:对列表本身进行原地排序,即直接修改原列表,不会返回新的列表。基本语法如下:
list.sort(key=None, reverse=False)
key
:用于指定排序的规则(可选参数),可以是一个函数,它会应用于列表中的每个元素,并返回一个用于比较的关键字。reverse
:指定排序顺序,为True
时降序排序(默认为False
)。示例:
names = ["Alice", "Bob", "Charlie", "David"]
names.sort(key=len)
print(names) # 输出:['Bob', 'Alice', 'David', 'Charlie']
2. sorted()
函数:一个全局函数,用于对任何可迭代对象(如列表、元组、字符串等)进行排序,返回一个新的已排序的列表(不会修改原始序列)。基本语法如下:
sorted(iterable, key=None, reverse=False)
iterable
:要排序的可迭代对象。key
:用于指定排序的规则(可选参数),可以是一个函数,它会应用于可迭代对象中的每个元素,并返回一个用于比较的关键字。reverse
:指定排序顺序,为True
时降序排序(默认为False
)。使用sorted()
函数的示例:
names = ["Alice", "Bob", "Charlie", "David"]
sorted_names = sorted(names, key=len)
print(sorted_names) # 输出:['Bob', 'Alice', 'David', 'Charlie']
key
参数在排序时用于指定一个函数,这个函数将应用于可迭代对象中的每个元素,并返回一个用于比较的关键字。通过key
参数,您可以实现对复杂对象的排序,例如根据对象的某个属性或特征进行排序。下面是一些示例,演示了不同类型的key
参数的可能性:
names = ["Alice", "Bob", "Charlie", "David"]
sorted_names = sorted(names, key=len)
print(sorted_names) # 输出:['Bob', 'Alice', 'David', 'Charlie']
words = ["apple", "banana", "cherry", "date"]
sorted_words = sorted(words, key=lambda x: x[-1])
print(sorted_words) # 输出:['banana', 'cherry', 'apple', 'date']
# 根据每个人的年龄进行排序
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
people = [Person("Alice", 25), Person("Bob", 30), Person("Charlie", 22)]
sorted_people = sorted(people, key=lambda 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, key=custom_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, key=lambda fruit: fruit["price"])
for fruit in sorted_fruits:
print(fruit["name"], fruit["price"])
banana 0.5
apple 1.0
cherry 2.0
在编程中,函数是一种可重用的代码块,用于执行特定任务或操作。通过使用函数,我们可以我们能够将一个大问题分解成多个小任务,从而简化编程过程;可以将代码组织得更加模块化,使其易于管理和维护。
在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!"
。
在Python中,“作用域”(Scope
)是一个指定变量可见性和可访问性的概念。作用域规定了在哪些地方可以访问或引用变量。Python有两种主要的作用域:
全局作用域(Global Scope):全局作用域是程序中所有函数之外的区域,通常包括在顶层定义的变量和函数。在全局作用域中声明的变量称之为全局变量,可以在整个程序中进行访问。
局部作用域(Local Scope):函数内部声明的变量默认属于局部变量,其作用域就是局部作用域,即只能在函数内部进行访问。局部变量仅在函数执行时才存在,当函数执行完毕后,局部变量会被销毁,所以函数外部无法直接访问这些变量。
关于全局变量和局部变量,还遵循以下原则:
global
关键字。以下是一个展示全局变量和局部变量之间关系的例子:
global_var = 5 # 这是一个全局变量
def modify_global():
# 如果不使用global关键字,那么global_var就是函数内部的一个局部变量,且没有预先定义,所以程序会报错。
global global_var # 使用 global 关键字来引用全局变量
global_var += 1
local_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_list
modify_list()
print(my_list) # 输出:[1, 2, 3, 4]
在这个示例中,函数 modify_list 内部没有显式地声明 my_list 是局部变量,而是直接对其进行了修改。由于 my_list 是一个组合数据类型(列表),Python 认为它是全局变量,并且在函数内部对它的修改实际上影响了全局变量。
在编程中,函数参数是我们传递给函数的值,这些值用于在函数内执行特定操作。按照函数的定义,参数可以分为形参和实参
按照参数的传递方式,可以分为以下几类:
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)
时,参数按照顺序传递给函数。
key=value
的形式,我们可以在调用函数时明确指定每个参数的值,而不必遵循位置顺序。这使得代码更具可读性,并避免了参数位置的混淆。def greet(name, age):
return "Hello, " + name + "! You are " + str(age) + " years old."
result = greet(age=30, name="Charlie")
print(result) # 输出:Hello, Charlie! You are 30 years old.
在上面的示例中,我们使用关键字参数来明确指定了参数的值,而不受函数定义中的顺序影响。
def greet(name, age=18):
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 cherry
def print_info(**kwargs):
for key, value in kwargs.items():
print(key + ": " + value)
print_info(name="Alice", age="30", city="New York")
# 输出:
# name: Alice
# age: 30
# city: New York
/
标识,只能通过位置传递值。*
标识,只能通过关键字参数的方式传递值。示例:
def my_function(a, b, /):
# 函数体
# a 和 b 是仅限位置的形参,只能通过位置传递值。
def my_function(*, x, y):
# 函数体
# x 和 y 是仅限关键字的形参,只能通过关键字参数的方式传递值。
函数定义如下:
def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2 ):
----------- ---------- ----------
| | |
| Positional or keyword |
| - Keyword only
-- Positional only
假设你有这样一个函数定义:
def complex_function(a, b, c=0, *args, **kwargs):
# 函数体
那么在调用这个函数时,可以按照上述顺序传递参数:
complex_function(1, 2, 3, 4, 5, x=6, y=7)
错误的调用示例:
complex_function(a=1, b=2, 3, x=4)
complex_function(1, 2, x=3, 4)
complex_function(1, 2, 3, x=4, 5)
complex_function(1, 2, 3, 4, 5, x=6, x=7) # 重复的关键字参数 x
*
表示的任意实参列表,会将传递给函数的所有位置参数收集到一个元组中。这使得你可以在函数内部处理多个参数,而不需要提前知道有多少个参数会传递进来。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 + b
numbers = [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, state='a stiff', action='voom'):
print("-- This parrot wouldn't", action, end=' ')
print("if you put", voltage, "volts through it.", end=' ')
print("E's", state, "!")
d = {"voltage": "four million", "state": "bleedin' demised", "action": "VOOM"}
parrot(**d)
-- This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !
总结:
*
来收集传递给函数的位置参数,使函数能够接收任意数量的参数。*
来将一个可迭代对象解包为单独的参数,方便将元素传递给函数。这两种技巧都能够提高函数的灵活性,让你可以更方便地处理不确定数量的参数。
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, key=lambda 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
函数在一些场景中很有用,但它的使用应该谨慎。对于较为复杂的逻辑,最好还是使用普通的命名函数,以便代码更易读和维护。
当你需要对一个可迭代对象(如列表、元组等)中的每个元素进行操作时,map
和 filter
是两个非常有用的Python内置函数。
map
函数: map
函数用于将一个函数应用于可迭代对象中的每个元素,返回一个新的可迭代对象,其中包含了应用函数后的结果。def square(x):
return x ** 2
numbers = [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 == 0
numbers = [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)。所以前者会返回所有元素的计算结果,而后者是条件筛选后的元素。
文档字符串(Docstrings) 是位于函数、模块、类或方法定义的第一个语句,是用于描述它们用途和功能的说明性文本。文档字符串通常使用三重引号(单引号或双引号)来定义,可以跨越多行。你可以通过特殊的属性(如 __doc__
)来访问它们。以下是编写文档字符串时的一些常见规则和惯例:
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.0
"""
return length * width
print(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 ' + eggs
f('spam')
Annotations: {'ham': <class 'str'>, 'return': <class 'str'>, 'eggs': <class 'str'>}
Arguments: spam eggs
'spam and eggs'
编码风格(Coding Style)是指编程时采用的一套一致性规则和约定,用于指导代码的组织、格式、命名以及注释等方面。编码风格有助于提高代码的可读性、可维护性和可协作性,使不同开发者之间的代码具有一致的外观和结构。
PEP 8(Python Enhancement Proposal 8)是一份被广泛接受的python编码风格指南,它推行的编码风格易于阅读、赏心悦目。以下是 PEP 8 中一些重要的编码风格规范:
result = a + b
。my_tuple = (1, 2, 3) # 正确写法
my_tuple = ( 1, 2, 3 ) # 不推荐,在括号内部使用了空格
from module import *
)。