• 第一章python科学编程入门

    简单梳理一下python的基本编码规范

    Python的基本编码规范主要遵循PEP 8——Python Enhancement Proposal #8。它为Python代码的编写提供了一个风格指南，以确保代码具有一致的风格，便于阅读和维护。以下是一些关键的编码规范以及代码示例：

    缩进

    • 使用4个空格来进行缩进，不要使用制表符（Tab）。
    • 续行应该与其包裹元素的括号、中括号或大括号内的第一个非空白字符对齐，或者使用垂直对齐的方式。

    行宽

    • 每行代码不应超过79个字符，这样可以在小屏幕上阅读，也便于多个代码文件并排显示。
    • 对于具有较少结构限制的长文本（如文档字符串或注释），行宽可以达到72个字符。

    空白

    • 在逗号、冒号、分号前面不要加空格，但其后面需要加空格。
    • 函数的参数列表、列表、字典、集合中，紧跟其后的括号前不应有空格。
    • 赋值（=）、比较（==, <, >, !=, <>, <=, >=, in, not in, is, is not）和布尔运算符（and, or, not）前后应该有一个空格，但在传递参数或赋值参数时，不在=前后加空格。

    注释

    • 注释应该是完整的句子。如果注释是一个短语或句子，其首字母应该大写，除非它是以小写字母开头的标识符。
    • 如果注释短到可以放在一行内，注释符号与注释文本之间应该跟随至少两个空格。

    命名约定

    • 函数名、变量名应该是小写的，如果有多个单词，使用下划线分隔。
    • 类名应该采用首字母大写的方式。
    • 对于私有或受保护的成员变量，使用一个下划线开头。

    示例代码

    class MyClass:
    def __init__(self, name, identifier):
        self.name = name          # 正确的空格使用
        self._identifier = identifier  # 私有变量以一个下划线开头

    def say_hello(self):
        """以友好的方式打招呼"""
        print(f"Hello, {self.name}!")

def calculate_sum(x, y):
    # 确保每个操作符前后都有空格
    return x + y

# 使用逗号后面加空格
numbers = [1, 2, 3, 4, 5]

# 字典中的元素：紧跟其后的大括号前不应有空格
person = {"name": "Alice", "age": 30}

if __name__ == "__main__":
    obj = MyClass("Bob", 123)
    obj.say_hello()
    result = calculate_sum(5, 3)
    print(f"Sum: {result}")

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

    关键字

    Python中的关键字是保留的词汇，它们具有特定的语法意义。关键字不能用作任何标识符名称。Python语言的关键字可能随版本变化有所不同，但以下是一般常见的Python关键字列表及其用法示例：

    Python 关键字列表

    1. False - 布尔值假。
    2. True - 布尔值真。
    3. None - 表示空值或无值。
    4. and - 逻辑与运算。
    5. or - 逻辑或运算。
    6. not - 逻辑非运算。
    7. assert - 用于调试目的，测试条件，如果条件为假，则触发异常。
    8. break - 跳出当前最内层循环。
    9. continue - 跳过当前循环的剩余部分，继续下一次循环。
    10. class - 用于定义类。
    11. def - 用于定义函数或方法。
    12. if - 条件语句。
    13. elif - 条件语句，else if的缩写。
    14. else - 条件语句，其他情况。
    15. try - 指定异常处理，尝试执行语句。
    16. except - 捕获异常。
    17. finally - 无论是否发生异常都将执行的代码块。
    18. for - for循环。
    19. while - while循环。
    20. import - 导入模块。
    21. from - 从模块中导入特定部分。
    22. as - 创建别名。
    23. pass - 空语句，一条什么也不做的命令。
    24. return - 返回函数结果。
    25. yield - 用于从函数返回一个生成器。
    26. with - 用于简化异常处理。
    27. lambda - 创建匿名函数。
    28. global - 声明全局变量。
    29. nonlocal - 声明非局部变量。
    30. del - 删除对象。
    31. in - 检查序列中是否包含特定的值。
    32. is - 测试两个变量是否引用自同一个对象。
    33. raise - 引发异常。

    示例代码

    以下是一些关键字的示例用法：

    # if, elif, else
if x > 10:
    print("x is greater than 10")
elif x == 10:
    print("x is 10")
else:
    print("x is less than 10")

# for, break, continue
for i in range(5):
    if i == 3:
        continue  # 跳过当前循环，继续下一次循环
    if i == 4:
        break  # 跳出循环
    print(i)

# def, return
def add(x, y):
    return x + y

# class
class MyClass:
    def __init__(self, name):
        self.name = name

# try, except, finally
try:
    x = 1 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")
finally:
    print("This will always execute")

# with (used for resource management, e.g., opening files)
with open("file.txt", "r") as file:
    contents = file.read()

# lambda
square = lambda x: x ** 2
print(square(5))

# global
x = 5
def func():
    global x
    x = 10
func()
print(x)  # Output: 10

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    常量与变量

    标识符

    在Python中，区分常量和变量主要依靠命名约定和编程实践，因为Python本身不像某些语言（如C++或Java）那样有内置的常量类型。下面将介绍如何在Python中使用变量和常量，并提供相应的示例。

    变量

    变量是可以更改值的标识符。在Python中，你可以直接给变量赋值，并且可以随时更改变量的值。变量命名应遵循标识符命名规则，即使用字母、数字和下划线，但不能以数字开头。

    变量示例
    # 定义变量
age = 30
name = "Alice"
is_student = True

# 使用变量
print(age)  # 输出: 30
print(name)  # 输出: Alice
print(is_student)  # 输出: True

# 更改变量的值
age = 31
name = "Bob"
is_student = False

# 再次使用变量
print(age)  # 输出: 31
print(name)  # 输出: Bob
print(is_student)  # 输出: False

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

    常量

    在Python中，常量是一种约定俗成的概念，通常用全部大写字母表示。虽然这种方式不能阻止常量的值被更改，但按照约定，开发者应该把它们视为不变的值。

    常量示例
    # 定义常量
PI = 3.14159
MAX_SIZE = 100
API_KEY = "XYZ123"

# 使用常量
print(PI)  # 输出: 3.14159
print(MAX_SIZE)  # 输出: 100
print(API_KEY)  # 输出: "XYZ123"

# 尽管以下操作在技术上是可能的，但不应更改常量的值
# PI = 3.14  # 不推荐这样做

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

    模块级常量

    如果你需要在多个文件中使用相同的常量，一个好的实践是将它们定义在一个单独的文件（例如constants.py）中，然后在其他模块中导入它们。

    constants.py
    # 定义常量
PI = 3.14159
MAX_SIZE = 100

    • 1
    • 2
    • 3
    使用常量的模块
    # 导入常量
from constants import PI, MAX_SIZE

# 使用常量
print(PI)  # 输出: 3.14159
print(MAX_SIZE)  # 输出: 100

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    这种方法有助于维护和管理在多处使用的常量值，确保它们的一致性并且容易更新。

    运算符

    Python中的运算符用于执行各种运算。以下是Python中常用运算符的类型和示例。

    算术运算符

    用于执行数学运算。

    • + 加法
    • - 减法
    • * 乘法
    • / 除法
    • % 求余
    • ** 求幂
    • // 整除
    示例：
    x = 10
y = 3

print(x + y)  # 输出: 13
print(x - y)  # 输出: 7
print(x * y)  # 输出: 30
print(x / y)  # 输出: 3.3333333333333335
print(x % y)  # 输出: 1
print(x ** y)  # 输出: 1000
print(x // y)  # 输出: 3

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    赋值运算符

    用于为变量赋值。

    • = 赋值
    • += 加后赋值
    • -= 减后赋值
    • *= 乘后赋值
    • /= 除后赋值
    • %= 模后赋值
    • **= 幂后赋值
    • //= 整除后赋值
    示例：
    x = 10
x += 3  # 相当于 x = x + 3
print(x)  # 输出: 13

x -= 3  # 相当于 x = x - 3
print(x)  # 输出: 10

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    比较运算符

    用于比较两个值。

    • == 等于
    • != 不等于
    • > 大于
    • < 小于
    • >= 大于等于
    • <= 小于等于
    示例：
    x = 10
y = 12

print(x == y)  # 输出: False
print(x != y)  # 输出: True
print(x > y)   # 输出: False
print(x < y)   # 输出: True
print(x >= y)  # 输出: False
print(x <= y)  # 输出: True

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    逻辑运算符

    用于组合条件语句。

    • and 与
    • or 或
    • not 非
    示例：
    x = True
y = False

print(x and y)  # 输出: False
print(x or y)   # 输出: True
print(not x)    # 输出: False

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    成员运算符

    用于测试序列中是否包含指定的成员。

    • in 存在
    • not in 不存在
    示例：
    x = [1, 2, 3, 4, 5]

print(3 in x)     # 输出: True
print(6 not in x) # 输出: True

    • 1
    • 2
    • 3
    • 4

    身份运算符

    用于比较两个对象的存储单元。

    • is 是同一个对象
    • is not 不是同一个对象
    示例：
    x = [1, 2, 3]
y = [1, 2, 3]
z = x

print(x is z)     # 输出: True
print(x is y)     # 输出: False
print(x == y)     # 输出: True
print(x is not y) # 输出: True

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    数据类型

    Python中的数据类型可以大致分为内置数据类型和自定义数据类型。内置数据类型包括数字（整数、浮点数、复数）、字符串、列表、元组、字典和集合等。每种数据类型都有其特定的用途和操作方法。下面将详细介绍这些内置数据类型及其使用示例。

    数字

    Python支持整数、浮点数和复数。

    示例
    # 整数
x = 10
print(x, type(x))  # 输出: 10 

# 浮点数
y = 20.5
print(y, type(y))  # 输出: 20.5 

# 复数
z = 2 + 3j
print(z, type(z))  # 输出: (2+3j) 

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

    字符串

    字符串是由字符组成的序列，用单引号或双引号括起来。

    示例
    name = "Alice"
message = 'Hello, "Bob"!'
print(name, type(name))  # 输出: Alice 
print(message)  # 输出: Hello, "Bob"!

    • 1
    • 2
    • 3
    • 4

    列表

    列表是有序的元素集合，元素可以是不同的数据类型，列表是可变的。

    示例
    numbers = [1, 2, 3, 4, 5]
mixed = [1, "Hello", 3.14, [1, 2, 3]]
print(numbers, type(numbers))  # 输出: [1, 2, 3, 4, 5] 
print(mixed)  # 输出: [1, 'Hello', 3.14, [1, 2, 3]]

    • 1
    • 2
    • 3
    • 4

    元组

    元组与列表类似，但元组是不可变的。

    示例
    coordinates = (10, 20)
print(coordinates, type(coordinates))  # 输出: (10, 20) 

    • 1
    • 2

    字典

    字典存储键值对，键是唯一的。

    示例
    person = {"name": "Alice", "age": 30}
print(person, type(person))  # 输出: {'name': 'Alice', 'age': 30} 

    • 1
    • 2

    集合

    集合是无序的、不重复的元素集合。

    示例
    fruits = {"apple", "banana", "cherry"}
print(fruits, type(fruits))  # 输出: {'banana', 'cherry', 'apple'} 

    • 1
    • 2

    布尔值

    布尔值表示真或假。

    示例
    is_student = True
is_sunny = False
print(is_student, type(is_student))  # 输出: True 
print(is_sunny)  # 输出: False

    • 1
    • 2
    • 3
    • 4

    内置函数

    Python的内置函数是不需要任何特殊导入即可使用的函数，提供了许多基本功能，从而使得日常编程任务变得更加简单。这些函数包括类型转换、数学计算、序列操作等。以下是一些常用的内置函数及其示例：

    类型转换函数

    • int(x[, base]): 将x转换为一个整数。可选参数base表示数的进制，默认为十进制。
    • float(x): 将x转换为一个浮点数。
    • str(x): 将对象x转换为字符串。
    • bool(x): 将x转换为布尔值。
    示例
    print(int("10"))        # 输出: 10
print(float("10.5"))    # 输出: 10.5
print(str(20))          # 输出: "20"
print(bool(0))          # 输出: False

    • 1
    • 2
    • 3
    • 4

    数学相关函数

    • abs(x): 返回x的绝对值。
    • round(number[, ndigits]): 四舍五入，ndigits表示小数点后保留的位数。
    • sum(iterable[, start]): 计算iterable的总和，如果提供start，则从这个值开始加。
    示例
    print(abs(-10.5))       # 输出: 10.5
print(round(10.456, 2)) # 输出: 10.46
print(sum([1, 2, 3], 10)) # 输出: 16

    • 1
    • 2
    • 3

    序列操作函数

    • len(s): 返回对象（字符、列表、元组等）的长度或项目数。
    • range(start, stop[, step]): 生成一个数值序列。
    • enumerate(iterable, start=0): 返回一个枚举对象。
    • sorted(iterable, key=None, reverse=False): 返回排序后的列表。
    示例
    print(len("hello"))            # 输出: 5
print(list(range(0, 10, 2)))   # 输出: [0, 2, 4, 6, 8]
for i, v in enumerate(['a', 'b', 'c']):
    print(f"{i}: {v}")
# 输出:
# 0: a
# 1: b
# 2: c
print(sorted([3, 1, 2]))       # 输出: [1, 2, 3]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    输入输出函数

    • print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False): 打印对象到文本流或文件。
    • input(prompt): 用于获取用户输入。
    示例
    print("Hello", "World", sep="-")  # 输出: Hello-World
name = input("Enter your name: ") # 用户输入
print(f"Hello, {name}!")

    • 1
    • 2
    • 3

    其他常用函数

    • help(object): 调用内置的帮助系统。
    • type(object): 返回对象的类型。
    示例
    print(type(10))    # 输出: 
# 使用help函数可以获取更多信息，例如：help(range)

    • 1
    • 2

    在这里插入图片描述
    在这里插入图片描述

  • 相关阅读:
    Redis 的持久化
    Elasticsearch7 入门 & 进阶
    排序之插入排序
    技术干货｜昇思MindSpore NLP模型迁移之Bert模型—文本匹配任务（二）：训练和评估
    深度卷积神经网络是什么,卷积神经网络结构设计
    猿创征文｜创作工具一览
    Docker-基础命令使用
    Java 基础面试题，JVM 内存模型？
    InstructionGPT
    C Primer Plus(6) 中文版 第1章 初识C语言 1.1 C语言的起源 1.2 选择C语言的理由 1.3 C语言的应用范围
  • 原文地址：https://blog.csdn.net/weixin_50503886/article/details/136749917