Python3 学习笔记1-基础语法

一、编码： 

• 在 Python 3 中，默认情况下源代码文件使用 UTF-8 编码，可以在源代码中直接使用大多数语言的字符而不需要进行额外的编码声明。UTF-8 是一种非常通用的编码方式，支持多种语言的字符。然而，如果需要使用其他编码，比如 Windows-1252，可以在 Python 源文件的顶部添加特殊的注释来指定编码方式。这个注释被称为编码声明，它告诉 Python 解释器使用哪种编码来读取源代码文件。
• 例如，如果文件包含 Windows-1252 编码的字符，可以在文件的顶部添加如下声明：

# -*- coding: cp-1252 -*-

• 这行代码必须放在 Python 文件的第一行或第二行，并且前面不能有任何空格或注释。需要注意的是，尽管可以指定不同的编码，但在大多数情况下，使用 UTF-8 编码是最佳实践，因为它提供了最大的兼容性和支持最广泛的字符集。

二、标识符：

        在 Python 中，标识符是用来命名变量、函数、类、模块和其他对象的名称。以下是 Python 标识符的一些规则：

（1）第一个字符：

• 必须是一个字母（a-z, A-Z），下划线（_）或一个非 ASCII 字符（比如中文字符）。

（2）后续字符：

• 可以包含字母、数字（0-9）和下划线。

（3）大小写敏感：

• Python 中的标识符是区分大小写的。例如，Variable 和 variable 是两个不同的标识符。

（4）非 ASCII 标识符：

• 从 Python 3 开始，使用非 ASCII 字符（如中文、日文、阿拉伯文等）作为标识符是允许的。

（5）关键字：

• 一些单词是 Python 的保留关键字，不能用作标识符，比如 if、for、while、class 等。

（6）命名约定：

• 通常遵循一定的命名约定，比如使用小写字母和下划线来分隔单词（snake_case），例如 my_variable。
• 对于类名，通常使用首字母大写的驼峰式命名（CamelCase），例如 MyClass。

（7）避免使用特殊字符：

• 尽管 Python 允许使用非 ASCII 字符，但在大多数情况下，使用 ASCII 字符作为标识符更为通用和易于理解。

（8）避免与内置函数和变量冲突：

• 不要使用 Python 内置函数或变量的名称作为标识符，这可能会导致意外的行为。

（9）使用中文作为变量名的例子：

变量 = 100
函数 = lambda x: x * 2
类 = "Python"

print(变量)  # 输出: 100
print(函数(5))  # 输出: 10
print(类)  # 输出: Python

三、python保留字：

        在 Python 中，关键字是预定义的保留字，它们具有特殊的意义，因此不能用作变量名、函数名或其他标识符名称。Python 的 keyword 模块提供了一个方便的方式来查看当前 Python 版本中的所有关键字。

import keyword

print(keyword.kwlist)

四、注释：

        在 Python 中，注释是用来解释代码的文字，它们不会被执行。注释对于提高代码的可读性和维护性非常重要。

（1）单行注释

• 单行注释以 # 符号开始，直到行尾都是注释内容。

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

（2）多行注释

• 虽然 Python 没有官方的多行注释语法，但通常使用三个连续的单引号 ''' 或三个连续的双引号 """ 来创建多行字符串，这些字符串可以作为多行注释使用。

'''
这是一个多行注释
可以跨越多行
'''
print("Hello, Python!")

"""
这是另一个多行注释
也可以跨越多行
"""
print("Hello, Python!")

（3）注释的输出

        注释不会影响代码的执行，它们仅用于解释代码。因此，无论代码中有多少注释，输出结果只与执行的代码有关。

五、行与缩进：

        在 Python 中，缩进是非常重要的，因为它用来定义代码块的结构。Python 不使用大括号 {} 或其他语言中的特定符号来标识代码块的开始和结束，而是完全依赖于缩进来区分不同的代码块。

（1）缩进的规则：

• 一致性：

  • 同一代码块中的所有行必须具有相同的缩进级别。通常使用四个空格作为标准缩进，但你也可以使用一个制表符（Tab），只要整个文件中保持一致即可。

• 不允许混用：

  • 不能在同一代码块中混用空格和制表符。这会导致 IndentationError。

• 代码块结构：

  • 缩进用于定义循环、条件语句、函数定义、类定义等的开始和结束。

（2）示例：

#条件语句
if True:
    print("True")  # 正确缩进
    print("Still True")  # 正确缩进
    print("Outside the if statement")  # 正确缩进，与 if 语句同级

#循环
for i in range(5):
    print(i)  # 正确缩进
    if i == 3:
        print("Found 3")  # 正确缩进

#函数定义
def my_function():
    print("Hello from a function")  # 正确缩进

#类定义
class MyClass:
    def __init__(self):
        print("Initializing a new instance")  # 正确缩进

六、多行语句:

        在 Python 中，可以通过在行尾添加反斜杠（\）来将一条语句分成多行，这有助于提高代码的可读性。不过，在某些结构中不需要使用反斜杠。

（1）使用反斜杠进行多行语句

• 当需要将一条长语句分成多行时，可以在行尾添加反斜杠来实现。这通常用于长的条件表达式、函数调用或复杂的列表、字典等。

# 长的条件表达式
if (x > 0 and x < 10 and
    y > 0 and y < 10):
    print("Both x and y are positive and less than 10")

# 长函数调用
result = some_long_function_name_with_many_parameters(
    arg1, arg2, arg3, arg4, arg5,
    arg6, arg7, arg8, arg9, arg10
)

# 长列表
elements = [
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
    11, 12, 13, 14, 15, 16, 17, 18, 19, 20
]

（2）在特定结构中不需要使用反斜杠

• 在某些结构中，如列表、字典、元组、集合、类定义、函数定义、条件语句等，Python 允许在不使用反斜杠的情况下自然地换行。

# 列表
elements = [
    1, 2, 3, 4, 5,
    6, 7, 8, 9, 10
]

# 字典
my_dict = {
    "key1": "value1",
    "key2": "value2",
    "key3": "value3"
}

# 元组
my_tuple = (
    1, 2, 3,
    4, 5, 6
)

# 集合
my_set = {
    1, 2, 3,
    4, 5, 6
}

# 类定义
class MyClass:
    def __init__(self, value):
        self.value = value

# 函数定义
def my_function(arg1, arg2, arg3,
               arg4, arg5, arg6):
    print("Function called with", arg1, arg2, arg3, arg4, arg5, arg6)

# 条件语句
if (x > 0 and x < 10 and
    y > 0 and y < 10):
    print("Both x and y are positive and less than 10")

（3）注意事项：

• 反斜杠：在使用反斜杠时，确保它后面不要有任何字符（包括空格和注释），否则会导致语法错误。
• 可读性：合理使用多行语句可以提高代码的可读性，但过度使用可能会使代码变得难以阅读。
• 一致性：在项目中，保持一致的代码风格非常重要，包括多行语句的使用。

 七、数字(Number)类型:

        在 Python 中，数字类型是用于表示和存储数值的类型。Python 支持以下几种数字类型：

（1）整数（int）：

• 整数类型用于表示没有小数点的数字。
• 在 Python 3 中，整数可以是正数、负数或零。
• 整数类型没有大小限制，它们的大小只受限于机器内存。

num = 10          # 正整数
num = -20         # 负整数
num = 0           # 零

（2）布尔型（bool）：

• 布尔型是整数的子类，有两个可能的值：True 和 False。
• 布尔型通常用于条件表达式和逻辑运算。

is_active = True
is_valid = False

（3）浮点数（float）：

• 浮点数用于表示有小数点的数字。
• 浮点数可以表示非常大或非常小的数，以及科学计数法表示的数。
• 浮点数的精度受限于机器的浮点数表示。

price = 19.99     # 普通浮点数
small = 1.23E-3   # 科学计数法表示的浮点数

（4）复数（complex）：

• 复数类型用于表示实部和虚部的组合。
• 虚部由字母 j 或 J 表示，而不是数学中常见的 i。
• 复数可以用于工程、物理学和其他科学计算。

complex_num = 1 + 2j  # 复数，实部为 1，虚部为 2
another_complex = 1.1 + 2.2j  # 另一个复数，实部和虚部都是浮点数

（5）数字类型的操作

• Python 支持对数字类型进行各种算术运算，包括加法、减法、乘法、除法和幂运算等。

# 整数运算
a = 10
b = 20
print(a + b)  # 输出: 30

# 浮点数运算
x = 3.14
y = 2.71
print(x * y)  # 输出: 8.5494

# 复数运算
z = 1 + 2j
w = 3 - 4j
print(z + w)  # 输出: (4-2j)

（6）注意事项

• 整数和布尔值在 Python 中是同一类型，布尔值 True 等价于整数 1，False 等价于整数 0。

• 浮点数的表示可能会有精度问题，因为它们是基于 IEEE 754 标准实现的。
• 复数在 Python 中是相对较新的类型，支持复数的算术运算。

八、字符串(String):

（1）引号的使用：

• 单引号 ' 和双引号 " 在 Python 中可以互换使用，没有区别。

（2）多行字符串：

• 三引号 ''' 或 """ 允许字符串跨越多行，非常适合表示多行文本，如诗歌、文档等。

（3）转义字符：

• 反斜杠 \ 用作转义字符，可以表示特殊字符，如换行 \n 或制表符 \t。
• 原始字符串：在字符串前加上 r 或 R，表示原始字符串，其中的反斜杠不会被当作转义字符。

（4）字符串连接：

• 使用 + 运算符可以将两个或多个字符串连接成一个字符串。
• 使用 * 运算符可以将字符串重复指定次数。

（5）字符串索引：

• 字符串索引从 0 开始，表示字符串中字符的位置。
• 负数索引从字符串的末尾开始计数，-1 表示最后一个字符。

（6）不可变性：

• 字符串是不可变的，这意味着一旦创建，就不能更改字符串中的字符。

（7）字符和字符串：

• Python 中没有单独的字符类型，字符可以视为长度为 1 的字符串。

（8）字符串切片：

• 切片操作 str[start:end] 允许获取字符串的一部分，start 是切片开始的索引，end 是切片结束的索引（不包含）。
• 切片可以包含步长参数 step，用于指定切片的间隔，如 str[start:end:step]。

（9）字符串方法：

• Python 字符串有许多内置方法，如 upper()、lower()、strip()、split()、join() 等，用于执行常见的字符串操作。

（10）字符串格式化：

• Python 支持多种字符串格式化方法，包括传统的 % 格式化、str.format() 方法和 f-strings（Python 3.6+）。

示例，使用 f-strings 进行字符串格式化：

name = "The_xz"
age = 18
s = f"Hello, my name is {name} and I am {age} years old."
print(s)

九、空行:

（1）代码组织：

• 空行用于将函数、类、方法等代码块分隔开来，使得代码结构更加清晰。

（2）突出入口点：

• 在类定义和方法之间，以及函数定义之间使用空行，可以帮助突出每个函数或方法的开始，使得查找特定代码段更加容易。

（3）逻辑分隔：

• 在逻辑上相关的代码段之间使用空行，可以提高代码的逻辑清晰度，使得阅读者能够更容易地理解代码的流程。

（4）不是必须的：

• 虽然空行对于代码的可读性很有帮助，但它们不是 Python 语法的一部分。即使没有空行，Python 解释器也能正确执行代码。

（5）代码风格：

• 遵循一致的代码风格，包括空行的使用，可以使得代码更加整洁和一致，这对于团队协作尤为重要。

（6）PEP 8 指南：

• PEP 8 是 Python 的官方代码风格指南，它建议在顶层定义（函数、类等）之间使用两个空行，在方法定义之间或在类定义之间使用一个空行。

（7）避免过度使用：

• 虽然空行有助于提高可读性，但过度使用可能会导致代码看起来过于分散。适度使用空行，保持代码的紧凑性。

（8）版本控制：

• 在版本控制系统中，适当的空行使用可以帮助跟踪代码的变更，特别是在比较不同版本时。

（9）编辑器支持：

• 许多代码编辑器和 IDE 提供了自动格式化代码的功能，包括自动插入空行，以符合选定的代码风格。

（10）代码审查：

• 在代码审查过程中，空行的使用可以帮助审查者更快地识别代码的结构和逻辑，从而提高审查的效率。

十、等待用户输入：

       在 Python 中，你可以使用 input() 函数来等待用户的输入。当程序执行到 input() 函数时，它会暂停，等待用户在控制台中输入文本并按下回车键。用户输入的文本将作为字符串返回。

（1）使用 input() 函数等待用户输入：

# -*- coding: utf-8 -*-
# 等待用户输入他们的名字
name = input("Please enter your name: ")

# 打印用户的输入
print(f"Hello, {name}!")

（2）input() 函数还可以接受一个可选的字符串参数，该参数会在等待用户输入之前显示在控制台上，通常用于提示用户输入的信息。

（3）需要注意的是，input() 函数返回的数据总是字符串类型，即使用户输入的是数字。如果需要将输入转换为整数或浮点数，你需要使用 int() 或 float() 函数进行转换。

（4）示例：

# -*- coding: utf-8 -*-
# 等待用户输入一个数字
number = input("Please enter a number: ")

# 尝试将输入转换为整数
try:
    number = int(number)
    print(f"You entered the number {number}.")
except ValueError:
    print("That's not a valid number.")

 

 

十一、同一行显示多条语句:

        在 Python 中，可以在同一行中使用多条语句，只需用分号 ; 将它们分隔开。这种写法在 Python 中是有效的，但它通常不推荐使用，因为它可能会降低代码的可读性。不过，在某些情况下，例如在脚本中快速执行或在交互式解释器中测试代码时，使用分号来分隔同一行中的多条语句可以提高效率。

（1）使用分号在同一行中分隔多条语句的示例：

# -*- coding: utf-8 -*-
# 同一行中声明多个变量
x = 1; y = 2; z = 3

# 同一行中执行多个操作
print("Hello, World!"); x = 5; y = 10;The_xz=x+y;print(The_xz)

 

（2）代码可读性：尽管可以在一行中使用多条语句，但为了保持代码的清晰和可读性，通常建议每条语句单独一行。

（3）代码维护：当代码需要维护或重构时，分行书写的语句更容易理解和修改。

（4）代码风格：遵循 PEP 8 等代码风格指南，通常建议避免在一行中使用多条语句，除非是在交互式解释器中快速测试或在一行内定义多个函数或类。

（5）例外情况：在某些情况下，如循环或条件语句中，使用分号来避免不必要的换行是可以接受的，例如 for i in range(10); print(i): pass，但这种写法仍然不推荐。

（7）交互式使用：在 Python 的交互式解释器中，使用分号可以在一行中快速尝试多个表达式。

十二、多个语句构成代码组:

        在 Python 中，代码组（也称为代码块）是由一系列逻辑上相关的语句组成的，它们共享相同的缩进级别。这些代码组通常用于定义程序的结构，如条件执行、循环、函数定义和类定义等。

（1）代码组（Code Block）：

• 代码组是 Python 中由一系列语句构成的集合，这些语句必须具有相同的缩进级别。Python 使用缩进来创建代码组，而不是像其他语言那样使用大括号 {}。
• 示例：if 语句后面的两行 print 函数调用构成了一个代码组，因为它们具有相同的缩进。

# -*- coding: utf-8 -*-
if True:
    print("This is a code group inside an if statement.")
    print("These statements are part of the same code group.")

（2）子句（Clause）：

• 在 Python 的复合语句中，子句由首行（通常是一个关键字）和随后的代码组组成。子句定义了代码的结构和逻辑。

• 示例：if 和 else 都是子句的开始，每个子句后面跟着一个代码组。

if condition:
    # 条件子句
    do_something()
else:
    # else 子句
    do_something_else()

（3）复合语句：

• 复合语句是由关键字开始的语句，如 if、while、for、def（定义函数）和 class（定义类）。这些语句后面的冒号 : 标志着代码组的开始。
• 示例：def 和 class 关键字后面的冒号 : 后面跟着的缩进的代码构成了代码组。

def my_function():
    # 函数定义子句
    print("This is a function code group.")

class MyClass:
    # 类定义子句
    def __init__(self):
        print("This is a class code group.")

（4）缩进的重要性：

• Python 中的缩进不仅是代码风格的问题，它是语法的一部分。不正确的缩进会导致 IndentationError。

• 错误的缩进示例：

if True:
print("This will cause an IndentationError.")

十三、print 输出:

        在 Python 中，print 函数是用来向控制台输出信息的。默认情况下，每次调用 print 函数后，输出的内容后面会跟一个换行符，导致光标移到下一行开始位置。这意味着，如果连续调用 print 函数，每次输出的内容将会出现在控制台的新的一行上。

（1）print 函数的基本用法：

print("Hello, World!")
print("This is a new line.")

（2）阻止 print 函数自动换行：

• 如果你希望 print 函数在输出后不自动换行，可以通过设置 end 参数来实现。end 参数的默认值是 \n（换行符），但可以将其设置为其他字符或空字符串，来改变或取消这个行为。

print("Hello, World!", end="")
print("This will be on the same line.")

• 第一个 print 调用的 end 参数被设置为空字符串，因此不会自动换行。第二个 print 调用将紧接着第一个输出的内容继续在同一行输出。

（3） 使用 end 参数的其他示例:

• 你可以使用 end 参数来指定任何字符串作为行的结束，而不仅限于换行符或空字符串。这允许你输出特定的分隔符或后缀。

print("Apple", end=", ")
print("Banana", end=", ")
print("Cherry")

 （4）总结：

• print 函数的 end 参数提供了灵活的控制，允许定制输出的结尾，无论是取消换行、添加特定的分隔符还是其他任何字符串。这使得 print 函数在输出日志信息、用户界面消息或其他需要定制输出格式的场景中非常有用。

十四、import 与 from...import:

        在 Python 中，模块是包含所有 Python 代码的文件，通常以 .py 结尾。导入模块可以让你使用其他文件中定义的函数、类和变量。以下是 import 和 from ... import 语句的详细说明和使用场景：

（1）使用 import 导入模块：

• 当使用 import 语句导入一个模块时，需要使用模块名来访问该模块中定义的函数、类和变量。

• 示例：导入了整个 math 模块，并使用 math.sqrt 来调用其中的 sqrt 函数。

import math

# 使用 math 模块的 sqrt 函数
print(math.sqrt(16))

（2）使用 from ... import 导入特定的函数或类：

• 如果想直接使用模块中的某个函数或类，而不是整个模块，可以使用 from ... import 语句。

• 示例：只从 math 模块导入了 sqrt 函数，并且可以直接使用 sqrt 而不是

from math import sqrt

# 直接使用 sqrt 函数
print(sqrt(16))

（3）导入多个特定的函数或类：

• 你可以在一条语句中导入多个函数或类。

• 示例：

from math import sqrt, pow, factorial

# 直接使用 sqrt, pow 和 factorial 函数
print(sqrt(16))
print(pow(2, 3))
print(factorial(5))

（4）导入模块中的所有内容：

• 使用星号 * 可以从模块中导入所有内容，但这种做法通常不推荐，因为它会污染命名空间，使得不清楚变量或函数是从哪里来的。

• 示例：

from math import *

# 可以直接使用 sqrt 等函数，但不建议这样做
print(sqrt(16))
print(pow(2, 3))

（5）给模块或函数重命名：

• 有时，可能会遇到命名冲突或想要给导入的模块或函数起一个别名，可以使用 as 关键字来实现。

• 示例：

import math as m

# 使用别名 m 来调用 math 模块的函数
print(m.sqrt(16))

from math import sqrt as square_root

# 使用别名 square_root 来调用 sqrt 函数
print(square_root(16))

（6）总结：

• 使用 import somemodule 导入整个模块，并通过模块名访问其内容。
• 使用 from somemodule import somefunction 直接导入特定的函数或类。
• 使用 from somemodule import firstfunc, secondfunc 导入多个特定的函数或类。
• 避免使用 from somemodule import *，因为它会导入所有内容，可能导致命名冲突。
• 使用 as 关键字给导入的模块或函数设定别名，以避免命名冲突或简化命名。

十五、命令行参数:

       在 Python 中，命令行参数可以通过 sys 模块的 argv 列表来访问。sys.argv 是一个列表，其中包含了从命令行传递给 Python 脚本的参数。第一个参数 sys.argv[0] 总是脚本的名称，后续的参数则是传递给脚本的其他字符串。

• 在 Python 脚本中使用命令行参数示例：

import sys

# 打印所有命令行参数
for i, arg in enumerate(sys.argv):
    print(f"Argument {i}: {arg}")

# 单独访问参数
script_name = sys.argv[0]
first_arg = sys.argv[1] if len(sys.argv) > 1 else "No first argument"
second_arg = sys.argv[2] if len(sys.argv) > 2 else "No second argument"

print(f"The script name is: {script_name}")
print(f"The first argument is: {first_arg}")
print(f"The second argument is: {second_arg}")

• 将这个脚本保存为 args_example.py 并通过命令行运行：

python args_example.py Hello World

• 输出：

Argument 0: args_example.py
Argument 1: Hello
Argument 2: World
The script name is: args_example.py
The first argument is: Hello
The second argument is: World

• 如果你想要解析命令行参数，使其更加易于使用，你可以使用 Python 标准库中的 argparse 模块。argparse 模块提供了一种方式来处理命令行参数，并且可以自动生成帮助和使用说明，检查参数的有效性等等。
• 使用 argparse 模块的一个示例：

import argparse

# 创建 ArgumentParser 对象
parser = argparse.ArgumentParser(description='Process some integers.')

# 添加参数
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                    help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',
                    const=sum, default=max,
                    help='sum the integers (default: find the max)')

# 解析参数
args = parser.parse_args()

# 使用参数
print(args.accumulate(args.integers))

• 将脚本保存为 argparse_example.py 并通过命令行运行：

python argparse_example.py 1 2 3 4 --sum

• 输出：

10

• 因为 --sum 选项被指定了，所以 accumulate 参数的值设置为 sum 函数，它计算了所有整数的和。如果没有指定 --sum，则默认行为是找到最大值。