• python基础语法回顾

    1 / 1

    python eval函数

    1 / 1

    eval() 函数是 Python 中的一个内置函数，它用于执行一个字符串形式的 Python 表达式，并返回表达式的结果。这个函数接受一个字符串参数，然后将其解析并执行，将结果返回。通常情况下，eval() 用于动态地执行 Python 代码。

    以下是 eval() 函数的基本语法：

    python

    result = eval(expression, globals=None, locals=None)

    • 1
    • expression 是一个字符串，其中包含要执行的 Python 表达式。
    • globals 是一个可选参数，用于指定全局命名空间的字典。如果未提供，将使用当前全局命名空间。
    • locals 也是一个可选参数，用于指定局部命名空间的字典。如果未提供，将使用当前局部命名空间。

    以下是一些示例，演示了如何使用 eval() 函数：

    python

    # 示例 1：执行简单的数学表达式
result = eval("3 + 4")
print(result)  # 输出 7

# 示例 2：执行字符串操作
text = "Hello, " + eval('"world"')
print(text)  # 输出 "Hello, world"

# 示例 3：使用 globals 和 locals 参数
x = 10
y = 20
result = eval("x + y", globals(), {"x": 5, "y": 8})
print(result)  # 输出 13

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

    需要注意的是，eval() 函数具有潜在的安全风险，因为它允许执行任意的 Python 代码。如果从不受信任的来源获取输入并将其传递给 eval()，可能会导致安全漏洞。因此，在使用 eval() 时应格外小心，确保只传递可信的输入。最好避免在生产环境中使用 eval()，并尽量使用更安全的替代方法，如解析器库或其他技术来执行动态代码。

    1 / 1

    介绍python函数得print 格式化输出

    1 / 1

    在 Python 中，您可以使用 print() 函数来输出格式化的文本。格式化输出使您能够将变量的值插入到字符串中，以便更灵活地控制输出的样式。以下是一些常见的方式来进行格式化输出：

    1. 使用占位符： 您可以在字符串中使用占位符，然后使用 % 运算符来将值插入这些占位符。不同类型的值需要不同的占位符，例如 %s 用于字符串，%d 用于整数，%f 用于浮点数等。示例：

      python

      name = "Alice"
age = 30
print("Name: %s, Age: %d" % (name, age))

      • 1
      • 2
      • 3

    2. 使用字符串的 format() 方法： format() 方法允许您使用 {} 占位符，然后使用 .format() 方法来为这些占位符提供值。示例：

      python

      name = "Bob"
age = 25
print("Name: {}, Age: {}".format(name, age))

      • 1
      • 2
      • 3

    3. 使用 f-字符串（Python 3.6+）： f-字符串是一种方便的格式化输出方式，您可以在字符串前加上字母 ‘f’，然后在字符串中使用大括号 {} 来嵌入变量或表达式。示例：

      python

      name = "Charlie"
age = 35
print(f"Name: {name}, Age: {age}")

      • 1
      • 2
      • 3

    4. 使用旧版的字符串格式化（Python 2.x）： 在 Python 2.x 中，您可以使用 % 运算符进行格式化输出，与第一种方法类似。但请注意，Python 2.x 已经不再维护，建议升级到 Python 3.x。

    这些是一些常见的格式化输出方法，您可以根据需要选择其中一种。f-字符串在 Python 3.6+ 中引入，因此在使用之前，请确保您的 Python 版本符合要求。格式化输出使您能够更灵活地控制文本的显示方式，从而满足不同的需求。

    1 / 1

    tem=1<<7什么意思

    1 / 1

    表达式 tem = 1 << 7 是在 Python 中使用位运算符的一种方式，它将二进制数 1 向左移动了 7 位，并将结果赋给变量 tem。

    让我们解释一下这个表达式的意思：

    • 1 表示一个二进制数，它的二进制表示是 00000001。
    • << 是左移位运算符，它将二进制数向左移动指定的位数。
    • 7 是要左移的位数。

    将 1 左移 7 位，将得到一个新的二进制数，其表示为 10000000。

    将这个结果赋给变量 tem，所以 tem 的值现在是 128（因为二进制数 10000000 转换为十进制就是 128）。

    所以，tem = 1 << 7 的意思是将 tem 设置为 128。这是一个常见的位运算操作，用于执行二进制数的位移操作。

    1 / 1

    介绍一下python位运算

    1 / 1

    Python 提供了一组位运算符，这些运算符用于在二进制位级别执行操作。这些位运算符通常用于对整数进行位操作。以下是 Python 中常用的位运算符及其功能：

    1. &（按位与）：

      • 运算符：a & b
      • 功能：对 a 和 b 进行按位与操作，返回一个新整数，其中每个位都是 a 和 b 对应位的逻辑与运算结果。
      • 示例：5 & 3 的结果是 1，因为二进制表示为 0101 & 0011。

    2. |（按位或）：

      • 运算符：a | b
      • 功能：对 a 和 b 进行按位或操作，返回一个新整数，其中每个位都是 a 和 b 对应位的逻辑或运算结果。
      • 示例：5 | 3 的结果是 7，因为二进制表示为 0101 | 0011。

    3. ^（按位异或）：

      • 运算符：a ^ b
      • 功能：对 a 和 b 进行按位异或操作，返回一个新整数，其中每个位都是 a 和 b 对应位的逻辑异或运算结果。
      • 示例：5 ^ 3 的结果是 6，因为二进制表示为 0101 ^ 0011。

    4. ~（按位取反）：

      • 运算符：~a
      • 功能：对整数 a 执行按位取反操作，返回一个新整数，其中每个位都是 a 对应位的逻辑取反结果。
      • 示例：~5 的结果是 -6，因为二进制表示为 ~0101。

    5. <<（左移位）：

      • 运算符：a << n
      • 功能：将整数 a 的二进制表示向左移动 n 位，相当于乘以 2 的 n 次方。
      • 示例：5 << 2 的结果是 20，因为二进制表示为 0101 << 2，左移 2 位后变成 10100。

    6. >>（右移位）：

      • 运算符：a >> n
      • 功能：将整数 a 的二进制表示向右移动 n 位，相当于除以 2 的 n 次方并取整。
      • 示例：16 >> 2 的结果是 4，因为二进制表示为 10000 >> 2，右移 2 位后变成 0001。

    位运算在一些底层编程、优化和数据处理任务中非常有用。它们可以用来掩码、标志操作、压缩数据等。但在通常的应用中，位运算不太常见，因此在编写代码时需要谨慎使用，确保清楚其行为和影响。

    1 / 1

    保留两位小数输出

    1 / 1

    在 Python 中，您可以使用字符串格式化或内置的 round() 函数来保留小数点后的两位小数输出。以下是两种方法的示例：

    使用字符串格式化：

    python

    number = 3.14159265
formatted_number = "{:.2f}".format(number)
print(formatted_number)

    • 1
    • 2
    • 3

    这将输出：

    3.14

    在这个示例中，"{:.2f}" 是一个字符串格式化模板，它指定了要格式化的数字的格式。.2f 表示保留两位小数。

    使用 round() 函数：

    python

    number = 3.14159265
rounded_number = round(number, 2)
print(rounded_number)

    • 1
    • 2
    • 3

    这将输出：

    3.14

    在这个示例中，round() 函数接受两个参数，第一个参数是要舍入的数字，第二个参数是要保留的小数位数。

    无论您选择哪种方法，都可以轻松地将数字保留到两位小数并进行输出。

    1 / 1

    为我介绍更多的字符串格式化模板

    1 / 1

    Python 中的字符串格式化可以使用不同的模板，让您更灵活地控制文本的显示方式。下面是一些常用的字符串格式化模板及其用法：

    1. 占位符格式化：使用 % 运算符和占位符将变量插入字符串中。

      • %s：插入字符串。

        python

        name = "Alice"
print("Hello, %s!" % name)

        • 1
        • 2

      • %d：插入整数。

        python

        age = 30
print("You are %d years old." % age)

        • 1
        • 2

      • %f：插入浮点数。

        python

        price = 19.99
print("The price is %.2f dollars." % price)

        • 1
        • 2

    2. str.format() 方法：使用大括号 {} 来作为占位符，然后使用 str.format() 方法将值插入。

      python

      name = "Bob"
age = 25
print("Name: {}, Age: {}".format(name, age))

      • 1
      • 2
      • 3

      还可以为大括号中的占位符指定索引，用于插入多个值：

      python

      name = "Charlie"
age = 35
print("Name: {0}, Age: {1}".format(name, age))

      • 1
      • 2
      • 3

    3. f-字符串（Python 3.6+）：在字符串前加上字母 ‘f’，然后在字符串中使用大括号 {} 来嵌入变量或表达式。

      python

      name = "David"
age = 40
print(f"Name: {name}, Age: {age}")

      • 1
      • 2
      • 3

    4. 模板字符串：使用 string.Template 类来创建模板字符串，然后使用 substitute() 方法将值插入模板。

      python

      from string import Template

template = Template("Name: $name, Age: $age")
result = template.substitute(name="Eve", age=45)
print(result)

      • 1
      • 2
      • 3
      • 4
      • 5

    这些是一些常用的字符串格式化模板，您可以根据需要选择其中一种，以便更好地控制文本的格式和输出。不同的模板方法在不同的情况下可能更加方便和适用。

    1 / 1

    介绍python中collection

    1 / 1

    在 Python 中，“collections” 是一个包含许多有用的数据结构和容器类型的模块，它位于标准库中。这些数据结构和容器类型可以帮助您更有效地组织和处理数据。下面是 Python 中常用的 collections 模块中的一些重要数据结构和容器：

    1. namedtuple： namedtuple 是一个工厂函数，用于创建具有命名字段的不可变数据对象。它类似于元组，但字段具有名称，可以通过名称或索引访问。

      python

      from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])
p = Point(1, 2)
print(p.x, p.y)  # 输出: 1 2

      • 1
      • 2
      • 3
      • 4
      • 5

    2. deque： deque（双端队列）是一个高效的双端队列数据结构，支持在两端进行添加和删除操作，具有 O(1) 复杂度。

      python

      from collections import deque

d = deque([1, 2, 3])
d.append(4)
d.appendleft(0)
print(d)  # 输出: deque([0, 1, 2, 3, 4])

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

    3. Counter： Counter 是一个用于计数可哈希对象的工具，它返回一个字典，其中包含对象作为键和它们的计数作为值。

      python

      from collections import Counter

fruits = ["apple", "banana", "apple", "cherry", "banana", "apple"]
fruit_counter = Counter(fruits)
print(fruit_counter)  # 输出: Counter({'apple': 3, 'banana': 2, 'cherry': 1})

      • 1
      • 2
      • 3
      • 4
      • 5

    4. defaultdict： defaultdict 是一个字典的子类，它允许您指定默认值类型，以便在访问不存在的键时不会引发 KeyError。

      python

      from collections import defaultdict

d = defaultdict(int)
d["a"] += 1
print(d["a"])  # 输出: 1

      • 1
      • 2
      • 3
      • 4
      • 5

    5. OrderedDict： OrderedDict 是一个有序字典，它会按照元素插入的顺序来维护键-值对的顺序。

      python

      from collections import OrderedDict

d = OrderedDict()
d["one"] = 1
d["two"] = 2
d["three"] = 3
print(d)  # 输出: OrderedDict([('one', 1), ('two', 2), ('three', 3)])

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

    6. ChainMap： ChainMap 允许您将多个字典链接在一起，以便它们可以像一个字典一样访问。如果键在多个字典中存在，将返回第一个匹配的值。

      python

      from collections import ChainMap

dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
combined_dict = ChainMap(dict1, dict2)
print(combined_dict["b"])  # 输出: 2，因为它在 dict1 中找到了匹配

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

    collections 模块提供了这些有用的数据结构和容器，使您能够更轻松地处理不同类型的数据，并提供了更高效的操作。根据您的需求，可以选择适合您的数据结构来提高代码的可读性和性能。

    1 / 1

    介绍lambda函数如何使用

    1 / 1

    Lambda 函数，也称为匿名函数，是在 Python 中创建小型、一次性函数的一种方式。它们通常用于在代码中定义简单的功能，而不必显式地为函数分配名称。Lambda 函数使用 lambda 关键字定义，其语法如下：

    python

    lambda arguments: expression

    • 1
    • arguments 是函数的参数，可以有零个或多个。
    • expression 是函数体，包含了一个表达式，该表达式的结果将作为 Lambda 函数的返回值。

    以下是一些示例，演示了如何使用 Lambda 函数：

    1. Lambda 函数没有参数：

    python

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

    • 1
    • 2
    1. Lambda 函数有一个参数：

    python

    double = lambda x: x * 2
print(double(7))  # 输出: 14

    • 1
    • 2
    1. Lambda 函数有多个参数：

    python

    add = lambda x, y: x + y
print(add(3, 4))  # 输出: 7

    • 1
    • 2
    1. Lambda 函数可以用于列表的排序：

    python

    points = [(1, 2), (3, 1), (5, 3), (2, 8)]
points.sort(key=lambda point: point[1])  # 按照每个元组的第二个元素排序
print(points)  # 输出: [(3, 1), (1, 2), (5, 3), (2, 8)]

    • 1
    • 2
    • 3
    1. Lambda 函数可以用于 filter() 和 map() 等函数：

    python

    numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
doubled_numbers = map(lambda x: x * 2, numbers)

print(list(even_numbers))       # 输出: [2, 4, 6, 8, 10]
print(list(doubled_numbers))    # 输出: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

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

    Lambda 函数通常用于需要短小、简单函数的情况，而不需要为它们分配额外的函数名称。然而，对于复杂的函数，特别是需要多次重复使用的函数，最好使用常规的函数定义来提高代码的可读性和维护性。

    1 / 1

    介绍sort和sorted的区别

    1 / 1

    在 Python 中，sort() 和 sorted() 都是用于对可迭代对象进行排序的函数，但它们之间有一些重要的区别：

    1. sort() 方法：

      • sort() 是列表对象的方法，因此只能用于对列表进行排序。
      • sort() 在原地排序列表，也就是说，它会直接修改原始列表，而不会创建新的排序副本。这可以节省内存，但会改变原始数据的顺序。
      • sort() 方法没有返回值（或者说返回值是 None），它只是直接修改了列表本身。
      • sort() 方法不能用于不可变的序列，如元组和字符串。

      示例：

      python

      numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
numbers.sort()
print(numbers)  # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

      • 1
      • 2
      • 3

    2. sorted() 函数：

      • sorted() 是一个内置函数，可以用于对任何可迭代对象进行排序，包括列表、元组、字符串等。
      • sorted() 不会修改原始对象，而是返回一个新的已排序对象，原始对象保持不变。
      • sorted() 可以接受关键字参数用于自定义排序规则，并可以进行降序排序。

      示例：

      python

      numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
print(numbers)         # 输出: [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] (原列表不变)

      • 1
      • 2
      • 3
      • 4

    总结：

    • 如果您希望对可变对象进行原地排序，并且不需要保留原始对象的顺序，可以使用 sort() 方法。
    • 如果您希望对不可变对象或者需要保留原始对象的顺序进行排序，或者需要自定义排序规则，可以使用 sorted() 函数。 sorted() 返回一个新的已排序对象，不会修改原始对象。

    1 / 1

    为我介绍下python中的组合数据类型

    1 / 2

    在 Python 中，有多种组合数据类型，用于存储和组织多个值的集合。以下是一些常见的组合数据类型：

    1. 列表（Lists）：

      • 列表是有序的、可变的数据结构，可以存储任何类型的值。
      • 列表使用方括号 [] 定义，元素之间用逗号 , 分隔。
      • 列表支持索引和切片操作，可以进行增删改查等操作。

      python

      fruits = ["apple", "banana", "cherry"]

      • 1

    2. 元组（Tuples）：

      • 元组是有序的、不可变的数据结构，可以存储任何类型的值。
      • 元组使用圆括号 () 定义，元素之间用逗号 , 分隔。
      • 元组通常用于表示不可变的数据集合，例如坐标点、日期时间等。

      python

      point = (1, 2)

      • 1

    3. 集合（Sets）：

      • 集合是无序的、可变或不可变的数据结构，用于存储不重复的值。
      • 集合使用花括号 {} 或 set() 构造函数定义。
      • 集合支持集合操作，如并集、交集、差集等。

      python

      colors = {"red", "green", "blue"}

      • 1

    4. 字典（Dictionaries）：

      • 字典是无序的、可变的数据结构，用于存储键-值对。
      • 字典使用花括号 {} 定义，每个键-值对之间用冒号 : 分隔，键和值之间用逗号 , 分隔。
      • 字典中的键必须是不可变的，通常使用字符串或数字作为键。

      python

      person = {"name": "Alice", "age": 30}

      • 1

    5. 命名元组（Named Tuples）：

      • 命名元组是一种具名的元组，与元组类似，但每个元素都具有名称，可以通过名称访问。
      • 命名元组通常用于表示记录或对象。

      python

      from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])
p = Point(1, 2)

      • 1
      • 2
      • 3
      • 4

    6. 默认字典（Default Dictionaries）：

      • 默认字典是字典的一种变体，它在创建时指定默认值类型，当访问不存在的键时不会引发 KeyError。
      • 默认字典通常用于计数、分组等操作。

      python

      from collections import defaultdict

word_counts = defaultdict(int)
word_counts["apple"] += 1

      • 1
      • 2
      • 3
      • 4

    这些组合数据类型在 Python 中非常有用，您可以根据具体的需求选择适当的数据类型来存储和操作数据。每种数据类型都有其自己的特性和适用场景，因此了解它们可以帮助您更好地编写 Python 程序。

    1 / 1

    请更加详细一些，实例代码更多一些

    1 / 1

    当讨论 Python 中的组合数据类型时，让我为您提供更多详细的信息和示例代码。

    1. 列表（Lists）：

      列表是有序的、可变的序列。它们用于存储一系列项目，并且可以根据需要执行添加、删除和修改操作。

      示例代码：

      python

      # 创建一个列表
fruits = ["apple", "banana", "cherry"]

# 添加元素
fruits.append("orange")

# 删除元素
fruits.remove("banana")

# 修改元素
fruits[0] = "grape"

# 遍历列表
for fruit in fruits:
    print(fruit)

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

    2. 元组（Tuples）：

      元组是有序的、不可变的序列。它们用于表示不应该被修改的一组项目。

      示例代码：

      python

      # 创建一个元组
point = (1, 2)

# 访问元组元素
x, y = point
print(f"x: {x}, y: {y}")

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

    3. 集合（Sets）：

      集合是无序的、可变或不可变的容器，用于存储不重复的元素。

      示例代码：

      python

      # 创建一个集合
colors = {"red", "green", "blue"}

# 添加元素
colors.add("yellow")

# 删除元素
colors.remove("green")

# 检查元素是否存在
if "red" in colors:
    print("Red is in the set.")

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

    4. 字典（Dictionaries）：

      字典是无序的、可变的键-值对容器，用于存储键和对应的值。

      示例代码：

      python

      # 创建一个字典
person = {"name": "Alice", "age": 30}

# 访问字典元素
name = person["name"]
age = person.get("age")

# 修改字典元素
person["age"] = 31

# 遍历字典
for key, value in person.items():
    print(f"{key}: {value}")

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

    5. 命名元组（Named Tuples）：

      命名元组是具有命名字段的元组，用于创建具名的记录或对象。

      示例代码：

      python

      from collections import namedtuple

# 创建命名元组类型
Point = namedtuple("Point", ["x", "y"])

# 创建命名元组实例
p = Point(1, 2)

# 访问命名元组字段
x = p.x
y = p.y

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

    6. 默认字典（Default Dictionaries）：

      默认字典是字典的一种变体，用于在创建时指定默认值类型，避免了 KeyError。

      示例代码：

      python

      from collections import defaultdict

# 创建默认字典，值的默认类型是 int
word_counts = defaultdict(int)

# 增加单词计数
word_counts["apple"] += 1
word_counts["banana"] += 2

# 访问不存在的键，不会引发错误，而是返回默认值
count = word_counts["cherry"]

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

    这些组合数据类型在 Python 中非常有用，您可以根据具体的需求选择适当的数据类型来存储和操作数据。这些示例应该能帮助您更深入地理解这些数据类型的用法。

  • 相关阅读:
    直播回顾：Coremail校园邮件安全防护交流会暨新技术应用分享
    部署LVS-NAT群集实验
    前端js调用后端API获取数据的三种方法（2022.7.25）
    lvgl显示中文和自定义图标
    多机器人群体的任务状态与机器人状态同步设计思路
    nginx配置proxy_pass之后返回404问题及Nginx host相关变量说明
    Fiddler的下载安装及使用（包括在测试中的使用）
    Webpack中的plugin插件机制
    Windows系统下常用的网络配置命令
    Linux修改ip
  • 原文地址：https://blog.csdn.net/X131644/article/details/132938807