Python 注释、变量和常量是编写 Python 代码时非常重要的概念，下面分别介绍它们的基本用法和语法。

Hello World

创建一个 00_helloworld.py 文件，打印 hello world：

1

print("Hello，World!")

执行该文件，会输出结果：

1
2

$ python 00_helloworld.py
Hello，World!

一般在 python 文件的开头第一行，我们都会看到下面的代码行：

1
2
3
4
5
6
7
8
9

# python2
#!/usr/bin/env python
# 或者
#!/usr/bin/python

# python3
#!/usr/bin/env python3
# 或者
#!/usr/bin/python3

这行代码用来指定本脚本用什么解释器来执行。

#!/usr/bin/python 是告诉操作系统执行这个脚本的时候，调用 /usr/bin 下的 python 解释器。

#!/usr/bin/env python 这种用法是为了防止操作系统用户没有将 python 装在默认的 /usr/bin 路径里。当系统看到这一行的时候，首先会到 env 设置里查找 python 的安装路径，再调用对应路径下的解释器程序完成操作。为了增强代码的可移植性，推荐这种写法。

在 00_helloworld.py 添加这行代码：

1
2
3

#!/usr/bin/env python

print("Hello，World!")

然后，修改该文件为可执行属性：

1

chmod +x 00_helloworld.py

就可以这样执行：

1

. 00_helloworld.py

编码格式

Python3 默认的编码格式是 UTF-8（Unicode Transformation Format - 8 bit）。这是一种通用的字符编码，支持几乎所有的字符集，包括 ASCII、Latin、中文、日文、韩文等。

在 Python 3.x 中，所有的字符串都是以 Unicode 编码存储的。当你在 Python 中创建一个字符串时，你可以使用任何 Unicode 字符，而不必担心编码问题。

当你打开一个文本文件时，Python 会自动尝试使用 UTF-8 编码来解析文件内容。如果文件使用其他编码格式，你需要使用相应的编码格式来打开文件，或者在读取文件内容后将其解码为 Unicode。

在 Python 中，你可以使用编码声明（coding declaration）来指定文件的编码格式。编码声明是一个特殊的注释，出现在 Python 文件的第一行或第二行（如果文件的第一行是 shebang，则编码声明必须出现在第二行），格式如下：

1
2
3
4
5

# -*- coding: encoding -*-

# 或者

# coding=utf-8

其中，encoding 是文件的编码格式，可以是 UTF-8、ISO-8859-1 或其他编码格式的名称。编码声明告诉 Python 解释器应该使用指定的编码格式来解析该文件中的文本内容。如果没有编码声明，Python3 默认使用 UTF-8 编码来解析文件内容。

Python 2.x 的默认编码格式是 ASCII，这是一种 7-bit 的字符编码，只能表示最基本的 ASCII 字符集，无法支持多语言和 Unicode 字符。

在 Python 2.x 中，如果你需要使用 Unicode 字符，你需要在字符串前面添加一个 u 字符，以表示该字符串是一个 Unicode 字符串。例如：

1
2
3

# -*- coding: utf-8 -*-
s = u'你好，世界！'
print s

在 Python 2.x 中，如果你需要打开一个非 ASCII 编码的文本文件，你需要在打开文件时指定文件的编码格式。例如：

1
2
3

f = open('filename.txt', 'r')
s = f.read().decode('gbk')  # 读取并解码文件内容
f.close()

在 Python 2.x 中，你可以使用编码声明来指定文件的编码格式：

1

# -*- coding: encoding -*-

其中，encoding 是文件的编码格式，可以是 UTF-8、GBK、ISO-8859-1 或其他编码格式的名称。编码声明告诉 Python 解释器应该使用指定的编码格式来解析该文件中的文本内容。如果没有编码声明，Python 2.x 默认使用 ASCII 编码来解析文件内容。

在终端输入如下命令，查看编码格式：

1
2
3
4
5
6

$ python
Python 3.11.3 (main, Apr  7 2023, 20:13:31) [Clang 14.0.0 (clang-1400.0.29.202)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.getdefaultencoding()
'utf-8'

注释

在 Python 中，注释用于在代码中添加注释、解释或说明。注释通常用于提高代码的可读性，帮助其他人理解你的代码。

Python 支持两种类型的注释：单行注释和多行注释。

单行注释

在 Python 中，单行注释以井号(#)开头，用于在代码行的末尾或者独立一行中添加注释。任何紧随井号后的文本都将被解释器忽略。

例如：

1
2
3
4

# 这是一个单行注释
print("Hello, World!")  # 这也是一个单行注释

text = "# This is not a comment because it's inside quotes."

在这个例子中，第一行是一个独立的单行注释，第二行则是在代码行的末尾添加的单行注释。这些注释不会影响程序的执行，但是可以帮助其他人理解你的代码。

多行注释

Python 中使用以三个单引号或者三个双引号括起来的注释被视为多行注释。多行注释通常用于注释函数、类、模块等。例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

'''
这是一个多行注释，
它可以用于描述函数、类或模块的功能和使用方法。
'''

def add_numbers(a, b):
    """
    这是一个用于计算两个数字之和的函数。
    参数：
    a -- 第一个数字
    b -- 第二个数字
    返回值：
    两个数字的和
    """
    return a + b

注意：

Python 的多行注释实际上是一个字符串字面值，因此如果不被赋值给任何变量，它们将不会对程序产生任何影响。

变量

在 Python 中，变量是用来存储数据的标识符。它们是程序中的一种基本元素，用于操作数据并在程序中引用它们。

Python 中的变量可以存储各种数据类型，包括数字、字符串、列表、元组、字典等。变量的值可以随时更改，因此它们是动态的。

变量的命名规则如下：

  • 变量名必须以字母或下划线开头。
  • 变量名可以包含字母、数字和下划线。
  • 变量名区分大小写。
  • 变量名不能与 Python 的关键字相同。

以下是 Python 3.x 版本中的所有关键字：

1
2
3
4
5
6
7

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

在 Python 2.x 中，还有两个额外的关键字 exec 和 print，但它们在 Python 3.x 中已经被移除。

如果你不确定某个标识符是否是关键字，你可以使用 Python 的 keyword 模块来检查：

1
2
3

import keyword

print(keyword.kwlist)

变量定义和使用

在 Python 中，可以使用赋值语句来创建变量。赋值语句使用等号(=)将变量名和要存储在变量中的值分开。

Python 是动态类型的语言，无须声明变量类型，直接对变量赋值即可使用。

示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 创建一个整型变量 x
x = 5
# 创建一个字符串变量 name
name = "John"
# 创建一个列表变量 my_list
my_list = [1, 2, 3]

# 引用变量 x 的值
print(x)  # 输出 5
# 引用变量 name 的值
print("My name is", name)  # 输出 My name is John
# 引用变量 my_list 的值
print(my_list)  # 输出 [1, 2, 3]

在 Python 中，变量是动态类型的。这意味着变量的类型可以随时更改。例如，一个变量可以在一个时刻存储一个整数，而在下一个时刻存储一个字符串。

1
2
3
4
5
6

# 动态类型示例
x = 5  # x 是一个整数
print(x)  # 输出 5

x = "Hello, world!"  # x 是一个字符串
print(x)  # 输出 Hello, world!

在 Python 中，变量是对象的引用。当一个变量被赋值为一个对象时，它实际上是将这个对象的引用存储到变量中。Python 的内存管理器会自动跟踪和回收不再使用的对象。

一行定义多个变量

在 Python 中可以一行定义多个变量。可以使用逗号将多个变量名分开，并使用等号将它们与相应的值分开。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 在 Python 中可以一行定义多个变量。可以使用逗号将多个变量名分开，并使用等号将它们与相应的值分开。
x, y, z = 5, "John", [1, 2, 3]

# 输出变量值
print(x)  # 输出 5
print(y)  # 输出 John
print(z)  # 输出 [1, 2, 3]

# 一行定义多个变量，使用相同的值
a = b = c = 0

# 输出变量值
print(a)  # 输出 0
print(b)  # 输出 0
print(c)  # 输出 0

变量的作用域

在 Python 中，变量的作用域是指变量在程序中可见和可访问的范围。Python 中有四种作用域：

  • 局部作用域：变量在函数内部定义，只能在函数内部访问。
  • 嵌套作用域：变量在嵌套函数内部定义，可以在嵌套函数内部和外部函数内部访问。
  • 全局作用域：变量在模块内部定义，可以在模块内的任何函数或类中访问。
  • 内置作用域：变量是 Python 内置的函数和对象，可以在任何地方访问。

如果在函数内部访问全局变量，你需要使用 global 关键字来指示变量的作用域。例如：

1
2
3
4
5
6
7
8

x = 10  # 全局变量

def my_func():
    global x  # 使用 global 关键字指示变量的作用域
    x = 20   # 将全局变量 x 的值修改为 20

my_func()
print(x)  # 输出 20

变量解包

在 Python 中，可以使用变量解包（unpacking）语法将一个序列或元组中的值分配给多个变量。变量解包语法使用等号(=)将变量名与序列或元组中的值分开，并使用逗号将变量名分开。

对元组解包

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 定义一个元组
my_tuple = (1, 2, 3)  # 注意：左侧变量的个数必须和待展开的列表长度相等，否则会报错

# 变量解包，将元组中的值分配给多个变量
x, y, z = my_tuple

# 输出变量值
print(x)  # 输出 1
print(y)  # 输出 2
print(z)  # 输出 3

可以将变量解包语法与其他 Python 的语言特性结合使用，例如函数返回值和列表推导式。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# 定义一个函数，返回两个值
def get_name_and_age():
    return "John", 30

# 变量解包，将函数返回的值分配给多个变量
name, age = get_name_and_age()

# 输出变量值
print(name)  # 输出 John
print(age)   # 输出 30

# 使用列表推导式创建一个列表，然后进行变量解包
my_list = [1, 2, 3]
a, b, c = [x * 2 for x in my_list]

# 输出变量值
print(a)  # 输出 2
print(b)  # 输出 4
print(c)  # 输出 6

变量解包语法可以用于嵌套的序列或元组：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# 定义一个嵌套元组
my_tuple = (1, 2, (3, 4))

# 变量解包，将元组中的值分配给多个变量
x, y, (z, w) = my_tuple

# 输出变量值
print(x)  # 输出 1
print(y)  # 输出 2
print(z)  # 输出 3
print(w)  # 输出 4


# 定义一个嵌套列表
my_list = [1, 2, [3, 4]]

# 变量解包，将列表中的值分配给多个变量
x, y, [z, w] = my_list

# 输出变量值
print(x)  # 输出 1
print(y)  # 输出 2
print(z)  # 输出 3
print(w)  # 输出 4

使用变量解包语法进行动态解包。动态解包是指在运行时确定要解包的序列或元组，并将其分配给多个变量。

这通常涉及到使用函数或方法返回的序列或元组，以及不确定序列或元组的长度的情况。

使用一个星号(*)作为变量名称的前缀可以指定一个变量来接收除了已分配变量之外的所有值。这个变量将是一个列表。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 定义一个元组
my_tuple = (1, 2, 3, 4, 5)

# 使用动态解包，将元组前两个值分配给变量 x 和 y，后两个值分配给变量 a 和 b，其他值分配给变量 rest
x, y, *rest, a, b = my_tuple

# 输出变量值
print(x)     # 输出 1
print(y)     # 输出 2
print(rest)  # 输出 [3, 4]
print(a)     # 输出 5
print(b)     # 输出 6

单下划线变量名

在 Python 中，以单个下划线(_)开头的变量名通常表示一个私有变量或占位符变量。

  1. 私有变量：在 Python 中，没有真正的私有变量，但是以单个下划线开头的变量名通常被视为私有变量。这意味着这些变量不应该在模块或类的外部使用，因为它们可能会发生变化或不再存在。但是，它们仍然可以在模块或类的内部使用。

  2. 占位符变量：有时候，在编写代码时，需要使用一个变量来占据一个位置，但是不需要引用变量的值。在这种情况下，可以使用以单个下划线开头的变量名来表示一个占位符变量。

    1
2
3
4
5
6
7
8

    # 忽略展开时的第二个变量
x, _ = [1, 2]

print(x, _)  # 输出 1 2

# 使用占位符变量
for _ in range(10):
    print(_)

可变和不可变对象

在 Python 中，有些对象是可变的，有些对象是不可变的。可变对象是可以修改的，而不可变对象是不能修改的。例如，数字、字符串和元组是不可变的，而列表和字典是可变的。

1
2
3
4
5
6
7
8
9

# 可变对象示例
my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出 [1, 2, 3, 4]

# 不可变对象示例
my_string = "Hello"
my_string += ", world!"
print(my_string)  # 输出 Hello, world!

常量

在 Python 中，常量是指在程序中定义的不可变的值。常量通常用大写字母表示，以便与变量区分开来。Python 中没有内置的常量类型，但是你可以使用以下方式定义常量：

  1. 使用普通变量表示常量。例如：
1

PI = 3.14159265358979323846

在程序中使用 PI 来表示圆周率，这个值不会被修改。

  1. 使用枚举类（Enum）表示常量。枚举类是 Python 中的一种特殊类型，用于定义一组有限的常量。例如：
1
2
3
4
5
6

from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

在程序中使用 Color.RED、Color.GREEN 和 Color.BLUE 来表示三种颜色，这些值不会被修改。

常量是编写可读性好、易于理解和维护的代码的重要组成部分。在编写代码时，应该将常量定义为不可变的值，并尽可能使用常量来表示不变的数据。