笔记——week13_python

最新推荐文章于 2024-09-14 14:43:52 发布
最新推荐文章于 2024-09-14 14:43:52 发布
阅读量49 收藏
点赞数
分类专栏： leetcode刷题笔记 文章标签： 笔记 python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/renzailaodo/article/details/132135981
版权

week13

文章目录

知识点：

float('inf') ：

float('inf') 在 Python 中表示正无穷。它是一个特殊的值，比任何其他可能的数字都大。

原地算法：

原地算法是一种计算机算法，它只在输入数组上进行操作，而不是创建额外的存储空间。这可以节省内存和时间，尤其是在数组很大的情况下。

原地算法的一种常见用途是排序。例如，冒泡排序和插入排序都是原地算法。这些算法可以对数组中的元素进行排序，而无需创建额外的存储空间。

原地算法的另一种常见用途是搜索。例如，二分搜索是一种原地算法，它可以快速地在数组中查找指定的元素。

原地算法是计算机科学中重要的工具。它们可以用于解决各种各样的问题，包括排序、搜索和压缩。

zip() 函数:

在 Python 中，zip() 函数用于将两个或多个序列（列表、元组、字符串等）合并成一个元组列表。

例如，以下代码将两个列表合并成一个元组列表：

Python

list1 = [1, 2, 3]
list2 = [4, 5, 6]

result = list(zip(list1, list2))

print(result)

输出：

[(1, 4), (2, 5), (3, 6)]

zip() 函数的返回值是一个元组列表，其中每个元组包含来自两个原始序列的元素。在上面例子中，每个元组包含一个元素来自 list1 和一个元素来自 list2。

zip() 函数还可以用于将字符串合并成一个元组列表：

Python

str1 = "abc"
str2 = "def"

result = list(zip(str1, str2))

print(result)

输出：

[('a', 'd'), ('b', 'e'), ('c', 'f')]

zip() 函数是一个非常有用的函数，它可以用于将多个序列合并成一个元组列表。它可以用于解决各种各样的问题。

在 Python 中，zip() 函数用于将两个或多个序列（列表、元组、字符串等）合并成一个元组列表。

例如，以下代码将两个列表合并成一个元组列表：

Python

list1 = [1, 2, 3]
list2 = [4, 5, 6]

result = list(zip(list1, list2))

print(result)

输出：

[(1, 4), (2, 5), (3, 6)]

zip() 函数的返回值是一个元组列表，其中每个元组包含来自两个原始序列的元素。在上面例子中，每个元组包含一个元素来自 list1 和一个元素来自 list2。

zip() 函数还可以用于将字符串合并成一个元组列表：

Python

str1 = "abc"
str2 = "def"

result = list(zip(str1, str2))

print(result)

输出：

[('a', 'd'), ('b', 'e'), ('c', 'f')]

zip() 函数是一个非常有用的函数，它可以用于将多个序列合并成一个元组列表。它可以用于解决各种各样的问题。

简单：

448. 找到所有数组中消失的数字

题目描述

给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。

示例 1：

输入：nums = [4,3,2,7,8,2,3,1]
输出：[5,6]
code:
class Solution:
    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
        seen = [False] * (len(nums) + 1)  # 记录出现的值
        result = []  # 记录结果
        for num in nums:  # 标记已出现的数值
            seen[num] = True

        for i in range(1, len(nums) + 1):  # [1, n]
            if seen[i] is False:  # 未出现的数值
                result.append(i)
        return result

class Solution:
    def find_disappeared_numbers(self, nums: List[int]) -> List[int]:
        """
        给定一个含 n 个整数的数组 nums ，找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。

        时间复杂度：O(n)
        空间复杂度：O(1)

        Args:
            nums: 一个含 n 个整数的数组。

        Returns:
            一个包含所有没有出现过的数字的数组。
        """

        # 记录出现的值
        seen = [False] * (len(nums) + 1)

        # 记录结果
        result = []

        # 标记已出现的数值
        for num in nums:
            seen[num] = True

        # 遍历 [1, n]，如果数值没有出现，则添加到结果数组中
        for i in range(1, len(nums) + 1):
            if seen[i] is False:
                result.append(i)

        return result
解题思路：

使用布尔数组 seen 来标记每个数字是否已经出现过。如果数字已经出现过，则将其标记为 True；如果数字没有出现过，则将其标记为 False。遍历完数组后，所有标记为 False 的数字就是所有没有出现过的数字。

  • seen 列表用于存储已经出现过的数字。
  • result 列表用于存储所有没有出现过的数字。
  • 循环遍历数组，如果数字已经出现过，则将其标记为已经出现过。
  • 遍历 [1, n]，如果数值没有出现，则添加到 result 列表中。
  • 最后，返回 result 列表。

121. 买卖股票的最佳时机

题目描述：

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
code:
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        min_price = float('inf')  # 初始最大价格保证最小的买入是在数组中
        max_profit = 0
        for price in prices:
            min_price = min(price, min_price)  # 得到数组最小买入
            max_profit = max(max_profit, price - min_price)  # 更新最大利润
        return max_profit
解题思路：

贪心算法：因为只用一买一出，所以要计算最小的price和最大的price的价格，该算法的好处就像等于将 [ 1 , 2 , 3 , 2 , 6 , 7 ] ⟶ [ [ 1 , 3 ] , [ 2 , 7 ] ] ⟶ [ 2 , 5 ] [1,2,3,2,6,7]\longrightarrow[[1,3],[2,7]]\longrightarrow[2,5] [1,2,3,2,6,7]⟶[[1,3],[2,7]]⟶[2,5]我们要的结果就是5。

118. 杨辉三角

题目描述：

给定一个非负整数 *numRows，*生成「杨辉三角」的前 numRows 行。

在「杨辉三角」中，每个数是它左上方和右上方的数的和。

img

示例 1:

输入: numRows = 5
输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
code:
class Solution:
    def generate(self, num_rows: int) -> List[List[int]]:
        # 初始化结果列表。
        result = []
        for row in range(num_rows):
            # 初始化当前行的列表。
            row_list = []
            for col in range(row + 1):
                # 如果当前列为 0 或行数，则元素为 1。
                if col == 0 or col == row:
                    row_list.append(1)
                # 否则，元素为上两元素之和。
                else:
                    row_list.append(result[row - 1][col - 1] + result[row - 1][col])
            # 添加当前行的列表到结果列表。
            result.append(row_list)

        return result
解题思路：

简单的动态规划，处理每行的结果，在逐一添加答案。

中等：

442. 数组中重复的数据

题目描述：

给你一个长度为 n 的整数数组 nums ，其中 nums 的所有整数都在范围 [1, n] 内，且每个整数出现 一次 或 两次 。请你找出所有出现 两次 的整数，并以数组形式返回。

你必须设计并实现一个时间复杂度为 O(n) 且仅使用常量额外空间的算法解决此问题。

示例 1：

输入：nums = [4,3,2,7,8,2,3,1]
输出：[2,3]
code：
class Solution:
    def findDuplicates(self, nums: List[int]) -> List[int]:
        seen = [False] *(len(nums) + 1)  # 构建hash表
        result = []  # 结果记录
        for num in nums:
            if seen[num]:  # 第二次出现
                result.append(num)
            else:  # 第一次出现
                seen[num] =  True
        return result

class Solution:
    def findDuplicates(self, nums: List[int]) -> List[int]:
        """
        给定一个长度为 n 的整数数组 nums ，找出所有出现 两次 的整数，并以数组形式返回。

        时间复杂度：O(n)
        空间复杂度：O(1)

        Args:
            nums: 一个长度为 n 的整数数组。

        Returns:
            一个包含所有出现 两次 的整数的数组。
        """

        # 构建哈希表
        seen = [False] * (len(nums) + 1)

        # 结果记录
        result = []

        # 遍历数组
        for num in nums:
            # 如果数字已经出现过
            if seen[num]:
                # 将其添加到结果数组中
                result.append(num)
            # 否则
            else:
                # 将其标记为已经出现过
                seen[num] = True

        # 返回结果数组
        return result
解题思路：
  • seen 列表用于存储已经出现过的数字。
  • result 列表用于存储所有出现过两次的数字。
  • 循环遍历数组，如果数字已经出现过，则将其添加到 result 列表中，否则将其标记为已经出现过。
  • 最后，返回 result 列表。

原地hsah表，因为条件限制所以，难度大大下降

  • n == nums.length
  • 1 <= n <= 105
  • 1 <= nums[i] <= n
  • nums 中的每个元素出现 一次 或 两次

55. 跳跃游戏

题目描述：

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标。

示例 1：

输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
code:
class Solution:
    def canJump(self, nums: List[int]) -> bool:
        n = len(nums)
        max_right = 0
        for i in range(n):
            # 如果当前位置可以达到
            if i <= max_right:
                # 更新可以达到的最大位置
                max_right = max(max_right, i + nums[i])
                # 如果可以达到数组的最后一个位置
                if max_right >= n - 1:
                    return True
        return False
解题思路：

贪心算法：在不超过最大界限的范围内，可以达到的最大位置，若超过最大的右边界，则可以跳跃到最后一个下标。

73. 矩阵置零

题目描述：

给定一个 *m* x *n* 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法**。**

示例 1：

img

输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]
输出：[[1,0,1],[0,0,0],[1,0,1]]
code:
class Solution:
    def setZeroes(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        """
        `m` 和 `n` 分别是矩阵的行数和列数。
        `row_has_zero` 是一个布尔列表，表示矩阵中的每一行是否包含 0 元素。
        `col_has_zero` 是一个布尔列表，表示矩阵中的每一列是否包含 0 元素。
        """
        m, n = len(matrix), len(matrix[0])
        row_has_zero = [False] * m
        col_has_zero = [False] * n

        """
        遍历矩阵，并将所有包含 0 元素的行和列的元素置为 0。
        """
        for i in range(m):
            for j in range(n):
                if matrix[i][j] == 0:
                    row_has_zero[i] = True
                    col_has_zero[j] = True

        """
        遍历矩阵，并将所有被标记为 0 的行和列的元素置为 0。
        """
        for i in range(m):
            for j in range(n):
                if row_has_zero[i] or col_has_zero[j]:
                    matrix[i][j] = 0
解题思路：

首先创建两个布尔数组，分别表示矩阵中的行和列是否包含 0 元素。然后，遍历矩阵，并将所有包含 0 元素的行和列的元素置为 0。最后，返回修改后的矩阵。

54. 螺旋矩阵

题目描述：

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

示例 1：

img

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
code：
class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        # 初始位置和界限
        row_start = 0
        row_end = len(matrix) - 1
        col_start = 0
        col_end = len(matrix[0]) - 1
        result = []

        # 开始循环
        while row_start <= row_end and col_start <= col_end:
            # 正向行
            for col in range(col_start, col_end + 1):
                result.append(matrix[row_start][col])

            # 到下一行
            row_start += 1

            # 正向列
            for row in range(row_start, row_end + 1):
                result.append(matrix[row][col_end])

            # 到下一列
            col_end -= 1

            # 反向行
            if row_start <= row_end:
                for col in range(col_end, col_start - 1, -1):
                    result.append(matrix[row_end][col])

                row_end -= 1

            # 反向列
            if col_start <= col_end:
                for row in range(row_end, row_start - 1, -1):
                    result.append(matrix[row][col_start])

                col_start += 1

        return result
解题思路：

模拟算法，模拟数值的添加路线，要注意range的集合是一个左闭右开的区间。

79. 单词搜索

题目描述：

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

示例 1：

img

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true
code:
class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        m, n = len(board), len(board[0])
        for i in range(m):
            for j in range(n):
                if self.dfs(board, word, i, j, m, n):
                    return True
        return False

    def dfs(self, board, word, i, j, m, n):
        if i < 0 or i >= m or j < 0 or j >= n or board[i][j] != word[0]:
            return False
        if len(word) == 1:
            return True
        board[i][j] = '#'
        for choice in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
            if self.dfs(board, word[1:], i + choice[0], j + choice[1], m, n):
                return True
        board[i][j] = word[0]
        return False
解题思路;

逐个字母地比较单词。如果两个字母匹配，则会向右或向下移动一个单元格，并继续比较下一个字母。如果两个字母不匹配，或者到达了网格的边界，则算法会返回 False。

小细节在 dfs 函数中，board[i][j] = '#' 语句将 # 标记符赋值给二维列表 board 的 i 行和 j 列中的元素。这是为了防止单词被多次找到。

48. 旋转图像

题目描述：

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

你必须在** 原地** 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

示例 1：

img

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[[7,4,1],[8,5,2],[9,6,3]]
code:
class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        n = len(matrix)  # 矩阵的维度
        for i in range(n // 2):  # 遍历上半部分行
            for j in range((n + 1) // 2):  # 遍历上半部分列
                # 进行四个元素的位置交换
                matrix[i][j], matrix[n - j - 1][i], matrix[n - i - 1][n - j - 1], matrix[j][n - i - 1] = matrix[n - j - 1][i], matrix[n - i - 1][n - j - 1], matrix[j][n - i - 1], matrix[i][j]
解题思路：

可以观察到，旋转前后，原矩阵左上角的元素，会移动到右上角的位置，右上角的元素会移动到右下角的位置，右下角的元素会移动到左下角的位置，左下角的元素会移动到左上角的位置。因此，我们可以通过对矩阵中的四个元素进行位置交换来实现矩阵的旋转。

具体地，我们从外部的一圈元素开始，每次遍历对应一圈的四个边，对四个边的元素进行位置交换。遍历的终止条件是遍历完所有的圈。

需要注意的是，当矩阵的维度为奇数时，最中间的一行和一列只包含一个元素，不需要进行位置交换。

这样，就能够实现将矩阵顺时针旋转90度的操作。

困难：

41. 缺失的第一个正数

题目描述：

给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。

请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。

示例 1：

输入：nums = [1,2,0]
输出：3
code：
class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        n = len(nums)  # 获取数组的长度
        for i in range(n):
            if nums[i] <= 0:  # 处理非正整数
                nums[i] = n + 1
        for i in range(n):
            num = abs(nums[i])
            if num <= n:  # 处理(1, N)的数
                nums[num - 1] = -abs(nums[num - 1])  # 这里开始使用的是一个简单的负数值，没有考虑到重复的数
        for i in range(n):  # 开始扫描
            if nums[i] > 0:
                return i + 1  
        return n + 1（=
解题思路：

对于一个长度为N的数组，其中没有出现的的最小正整数只能在 [ 1 , N + 1 ] [1, N + 1] [1,N+1]。如果 [ 1 , N ] [1, N] [1,N]都出现了，那么答案就是 N + 1 N+1 N+1，否则就是 [ 1 , N ] [1, N] [1,N]中没有出现的最小正整数。

其他

ass Solution:
def firstMissingPositive(self, nums: List[int]) -> int:
n = len(nums) # 获取数组的长度
for i in range(n):
if nums[i] <= 0: # 处理非正整数
nums[i] = n + 1
for i in range(n):
num = abs(nums[i])
if num <= n: # 处理(1, N)的数
nums[num - 1] = -abs(nums[num - 1]) # 这里开始使用的是一个简单的负数值，没有考虑到重复的数
for i in range(n): # 开始扫描
if nums[i] > 0:
return i + 1
return n + 1（=


#### 解题思路：

对于一个长度为N的数组，其中没有出现的的最小正整数只能在$[1, N + 1]$。如果$[1, N]$都出现了，那么答案就是$N+1$，否则就是$[1, N]$中没有出现的最小正整数。















## 其他
renzailaodo
关注
专栏目录
Python学习笔记——week_3
m0_46651307的博客
06-21 275
关于书籍《Python编程快速上手——让繁琐工作自动化》的自我学习的第四章 列表、第五章 字典和结构化数据 的自学笔记
斯坦福大学吴恩达机器学习教程中文笔记——week9——异常检测，推荐系统
Laic Zhang的博客
04-22 1980
第9周 文章目录第9周@[toc] 十五、异常检测(Anomaly Detection)15.1 问题的动机15.2 高斯分布15.3 算法15.4 开发和评价一个异常检测系统15.5 异常检测与监督学习对比15.6 选择特征15.7 多元高斯分布（选修）15.8 使用多元高斯分布进行异常检测（可选）十六、推荐系统(Recommender Systems)16.1 问题形式化16.2 基于内容的推...
笔记——week15_python
renzailaodo的博客
08-20 1017
解题思路：由于 nums1 内存有足够的空间来承载 nums2 中的元素，可以从后往前遍历，逐比较个 nums1 和 nums2 中的元素，然后将增加的元素放到 nums1 中的元素。在循环中，比较 s[left] 和 s[right]是否符合，如果符合，则将两个指针分别向中间移动一位。的值，如果等于c，则找到了解，返回True。注意，因为数组存在重复数字，如果中点和左端的数字相同，我们并不能确定是左区间全部相同，还是右区间完全相同。数组分布如下图，中间值在左递增区间，向右靠拢，在右边递增区间，向左靠拢。
笔记——week14_python
renzailaodo的博客
08-13 103
观察事例，前两个子串的结尾字符都是该子串的最多字符且是该字符出现的最后一个位置，第三个字串的结尾时该字符出现的最后一个位置，无法再分。然后，从右到左遍历一次，如果前一个人的评分比当前人高，则分配更多的糖果给前一个人，数量取当前情况和加一的情况中的最大值。朵花，从贪心的角度考虑，应该在不打破种植规则的情况下种入尽可能多的花，然后判断可以种入的花的最多数量是否大于或等于。从左到右遍历一次，如果当前人的评分比前一个人高，则分配更多的糖果给当前人，数量为前一个人的糖果数加一。指针再次到达，则链表中存在环。
Python学习笔记——week_7
m0_46651307的博客
07-19 220
关于书籍《Python编程快速上手——让繁琐工作自动化》的自我学习的第十章 调试 和第十一章 从Web抓取信息 的自学笔记
斯坦福大学吴恩达机器学习教程中文笔记——week1——引言，单变量线性回归，线性代数回顾
Laic Zhang的博客
04-21 3056
第1周 文章目录第1周@[toc] 引言(Introduction)1.1 欢迎1.2 机器学习是什么？1.3 监督学习1.4 无监督学习二、单变量线性回归(Linear Regression with One Variable)2.1 模型表示2.2 代价函数2.3 代价函数的直观理解I2.4 代价函数的直观理解II2.5 梯度下降2.6 梯度下降的直观理解2.7 梯度下降的线性回归2.8 接下...
python tkinter 表格_python学习笔记（Tkinter编程利用Treeview实现表格自动更新）
weixin_39688378的博客
11-24 1265
博主今天总结这段时间抽空写的一个GUI编程项目功能是查看本地打印机队列，可选择指定队列重新打印直接上图UI设计包括3个区域左上方，右上方和下方列表区域使用网格grid方法来分配位置下面是界面设计的代码#!/usr/bin/env python# -*- coding: utf-8 -*-from Tkinter import *from printer_pywin32 import Printer...
Python Data Analysis学习笔记【Week3】——Python CSV module
m0_37615469的博客
04-27 284
一、使用csv模块将csv文件保存在嵌套list中 """ Using the csv module. """ import csv def parse(csvfilename): """ Reads CSV file named csvfilename, parses it's content and returns the data within the...
STM32学习笔记（二、初识stm32单片机）
tommorrowwill的博客
09-10 786
首先stm32是意法半导体公司（ST）使用ARM公司的Cortex-M为核心生产的32位的单片机。其中，ST---意法半导体公司，即SOC厂商。M---为Microelectronics的缩写，即微型处理器。32---表示控制器为32位的。103---表示F系列的子系列。
C++学习笔记----6、内存管理（五）---- 智能指针（3）
weixin_71738303的博客
09-11 1160
与指向特定类型的原始指针可以转化为不同类型的指针一样，shared_ptr保存特定的类型可以转化为一个另一种类型的shared_ptr。转化shared_ptr的函数是const_pointer_cast()，dynamic_pointer_cast(),static_pointer_cast()和reinterpret_pointer_cast()。前面简要提过，当拥有共享属主的智能指针，例如shared_ptr不在活动范围或者被重置时，只有它是最后指向的智能指针时才能释放其指向的资源。
UEFI学习笔记（五）：EDK II PCD的概念、类型、使用
qq_44189622的博客
09-11 831
如果在BIOS里面有一些模块是binary方式集成进来的而这些binary又需要用到PCD（用于Binary Release），那么这些Binary集成的要用到的PCD就必须要设置为。PCD的值存在memory里面，下次启动时，上次更改的值丢失了，每次启动都是从default值开始。是存在VPD空间的（在FLASH上，只读），一般是出厂配置。如果platform是从源码build出来的，没有binary在里面的时候，PCD用的都是。作用域在一个模块中（模块级的），可以在Binary Level进行修改。
OJ在线判题系统项目笔记
今天不coding的博客
09-11 771
OJ在线判题系统项目笔记
经验笔记：Web 浏览器存储手段
qq_45831414的博客
09-10 879
以上就是使用 IndexedDB 的基本步骤。IndexedDB 提供了强大的数据存储能力，并且可以通过索引来优化数据检索性能。在实际应用中，可能还需要处理更复杂的场景，比如数据迁移、错误处理等。务必确保你的代码能够妥善处理各种异常情况。
Netty笔记03-组件Channel
weixin_46425661的博客
09-12 749
本文主要讲解Netty中的组件Channel、ChannelFuture和CloseFuture
17、电科院FTU检测标准学习笔记-录波性能
最新发布
sixtome
09-14 546
作者简介：本人从事电力系统多年，岗位包含研发，测试，工程等，具有丰富的经验在配电自动化验收测试以及电科院测试中，本人全程参与，积累了不少现场的经验。
rk3568系统buildroot开发笔记
Reasonss的博客
09-11 1248
构建RK3568系统期间遇到的各种问题,我主要分为编译问题和运行问题
【学习笔记】SSL密码套件之哈希
Taki_UP的博客
09-12 1141
本篇介绍了TLS/SSL密码套件中常用的哈希算法，包括Poly1305、SHA384、SHA256、SHA、MD5
JS笔记
2201_76100326的博客
09-11 513
Math对象属于Javascript内置对象，无需实例化（不需要添加new ），可以直接使用。只有一个Math.PI的属性。
python学习笔记011——内置函数__sizeof__()
06-10
好的，你的问题是关于 Python 内置函数 `__sizeof__()` 的。这个函数的作用是返回一个对象占用的内存大小（单位为字节）。你可以在 Python 中的任何对象上调用这个函数，比如： ```python a = 10 print(a.__sizeof_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值