GESP 3级 考点

这是一篇关于GESP 3级 考点的思维导图，掌握数据编码、进制转换、位运算等知识，掌握一维数组的、字符串及函数的使用，能够独立使用模拟法枚举法解决对应的算法问题。

GESP 3级

• 目标
  • 掌握数据编码、进制转换、位运算等知识，掌握一维数 组的、字符串及函数的使用，能够独立使用模拟法、 枚举法解决对应的算法问题。
• 内容
  • 数据编码（原码、反码、补码）
    • 正数: 原码/反码/补码就是原始二进制
      • 1
        • 0000 0001 --原码
        • 0000 0001 --反码
        • 0000 0001 ---补码
    • 负数
      • -3
        • 原： 1000 0011
        • 反： 1111 1100
        • 补： 1111 1101
      • -2
        • 1000 0010---
        • 1111 1101 符号位不变，其余各位取反
        • 1111 1110 反码+1
      • -1
        • 原码： 1000 0001 直接换算得到的二进制
        • 反码： 1111 1110 符号位不变，其余各位取反
        • 补码： 1111 1111 反码+1
  • 进制转换（二进制、八进制、十进制、十六进制）
  • 位运算（与（&）、或（|）、非（!）、异或（^）、左移（<<）、右移(>>)）
    • 取反 ～: 对补码每位取反，然后还原为原码
      • ～7
        • 先求补码： 0000 0111
        • 每位取反： 1111 1000
        • 补码变原码： 1000 0101 ---反码---》 1111 1010
      • ～-4：
        • 先求补码： 1000 0100---1111 1011（反）---1111 1100（补）
        • 补码每位取反： 0000 0011
        • 补码变为原码： 0000 0011
      • ～4
        • 0000 0100 -->原码---反码
        • 1111 1011 --补----原码
        • 1111 1010 --反码
        • 1000 0101-- -5
    • 与 &
      • 与（AND）运算符 & 当两个位都为1时，结果位是1；否则为0。 示例： python Copy code a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 c = a & b # 12 = 0000 1100
    • 或 ｜
      • 或（OR）运算符 | 当两个位中至少有一个为1时，结果位是1；否则为0。 示例： python Copy code a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 c = a | b # 61 = 0011 1101
    • 非 ！
      • 非（NOT）运算符 ~ 对数的每个位取反，即把1变为0，把0变为1。Python中的~是按位取反运算符，它对数字的二进制表示中的每一位进行取反操作。 注意，Python中的~操作符实际上返回的是-x-1，这是由于Python使用补码来表示负数。 示例： python Copy code a = 60 # 60 = 0011 1100 c = ~a # -61 = 1100 0011
    • 异或^
      • 异或（XOR）运算符 ^ 在Python中用于进行位级异或操作。异或运算的特点是，对于两个位，如果它们相同则结果为0，如果它们不同则结果为1。换句话说，它只在一个位为1而另一个位为0时返回1。 以下是异或运算的一些特点和示例： 特点 不同为真：两个比较的位不同（一个为1，一个为0）时，结果为1。 相同为假：两个比较的位相同（都为0或都为1）时，结果为0。 自反性：任何数与自身异或的结果为0。 与0的异或：任何数与0异或等于其自身。 示例 python Copy code a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 c = a ^ b # 49 = 0011 0001 在这个例子中，数字60（二进制0011 1100）和13（二进制0000 1101）进行异或操作，结果是49（二进制0011 0001）。
    • 左移 <<
      • 左移运算符 << 把一个数的位向左移动指定的位数（在右边补0）。 python Copy code a = 60 # 60 = 0011 1100 c = a << 2 # 240 = 1111 0000
    • 右移 >>
      • 右移运算符 >> 把一个数的位向右移动指定的位数。 示例： python Copy code a = 60 # 60 = 0011 1100 c = a >> 2 # 15 = 0000 1111
  • 算法的概念与描述（自然语言描述、流程图描述、伪代码描述）
  • 内置数据类型
    • 序列
      • 可变
        • list
          • 概念
            • 可包含任意有序元素
            • 可通过下表索引（偏移位置访问）
            • 可变长度，可任意嵌套
            • 支持原位改变
          • 常用函数
            • 排序
              • l.sort()
              • sorted(l)
                • 子主题
        • 通用操作
          • 改变某个值
            • s[i] =x
          • 改变特定范围元素值
            • s[i:j] = t
            • s[i:j:k] = t
          • 删除元素
            • del s[i]
            • del s[i:j]
            • del s[i:j:k]
            • s.remove(x)
              • 删除第一个值位x的元素
            • s.clear()
              • 清空列表
          • 追加元素
            • s.append(x)
          • 扩展元素
            • s.extend(x)
          • 插入元素
            • s.insert(i,x)
          • 检索并删除特定元素
            • s.pop([i])
          • 反转序列
            • s.reserve()
      • 不可变
        • 元组
          • 可包含任意有序对象的集合
          • 通过下标索引访问
          • 固定长度，可任意嵌套
          • 对象引用数组
        • range范围
        • 文本序列字符串
          • 常用操作
            • str()
            • str.upper()
              • 转为大写
            • str.lower()
              • 转为小写
            • str.startswith("XXXX")
              • 判断是否以xxx开头
            • str.endswith("xxx")
              • 判断是否xxx结尾
            • str.isAlpha()
              • 判断是否是字母
            • str.isnumeric()
              • 判断是否是数字
            • str.lstrip()
              • 删除左边的空格
            • str.rstrip()
              • 删除右边的空格
            • str.strip()
              • 删除左右边的空格
            • str.split()
              • 以xxx分割
            • str.join()
            • str.format()
          • 序列的通用函数字符串都能使用，除开 sum
      • 通用操作
        • 判断是否在序列内
          • x in s
          • x not in s
        • 连接序列
          • s1+s2
        • 重复序列
          • s*n
        • 下标获取元素
          • s[i]
        • 访问指定范围索引
          • s[i:j]
        • 按照步长访问
          • s[i:j:k]
        • 获取序列长度
          • len(s)
        • 获取最小值
          • min(s)
        • 获取最大值
          • max(s)
        • 统计总和
          • sum(s)
        • 检查某个元素第一次出现下标
          • s.index(x)
        • 统计元素出现次数
          • s.count(x)
    • 映射
      • dict
        • 特性
          • 通过key而非索引进行偏移
          • 可以包含任意对象的无序集合
          • 可变长度，任意嵌套
        • 字典声明
          • {}
          • {"1":"2","3":"4"}
          • dict(key=value)
          • dict([(k1,v1),(k2,v2),(k3,v3),])
          • dict.fromkeys([key1,key2,key3,....])
        • 常用操作
          • 访问
          • d.copy()
          • d.clear()
          • d[k]=v
          • d.update(k)
          • del d[k]
          • d.pop(k)
          • d.get(k,默认值)
    • 集合
      • set
        • 集合里面的元素是不能重复的，例如
          • fruits = {'apple', 'banana', 'pear', 'peach', 'apple'}
          • print(fruits)
          • {'banana', 'peach', 'apple', 'pear'}
        • 可以使用 in 来判断集合里面有没有某个元素，例如
          • fruits = {'apple', 'banana', 'pear', 'peach'} print('peach' in fruits) print('panda' in fruits)
        • 可以使用 for 循环来遍历集合里面的每个元素，例如 fruits = {'apple', 'banana', 'pear', 'peach'} for i in fruits: print(i)
          • 输出结果： apple banana peach pear
        • 常用方法
          • in 判断集合里面有没有某个元素
          • add 向集合中添加单个元素
          • discard 删除某个元素
          • len 输出集合中元素的个数
          • clear 清空集合
    • 排序
      • Map
        • 按值排序并返回元组列表: sorted_items = sorted(my_dict.items(), key=lambda item: item[1]) 这将返回一个元组列表，元组中的第一个元素是键，第二个元素是值。
        • 获取排序后的键值对列表: 使用sorted()对字典的键进行排序，然后使用列表推导式来创建一个元组列表，其中包含排序后的键值对。 例子： my_dict = {'b': 2, 'a': 1, 'c': 3} sorted_items = [(k, my_dict[k]) for k in sorted(my_dict)]
      • list
    • 循环列表时候，如果删除元素，如何操作
      • my_list = [1, 2, 3, 4, 5] for i in range(len(my_list) - 1, -1, -1): if my_list[i] == 3: del my_list[i]
  • 算法：枚举法
    • 枚举法，也称为暴力法或穷举法，是一种简单直观的算法设计技术。它指的是为了解决问题而尝试系统地列举所有可能的情况。枚举法通常是解决问题的最直接方法，尽管在某些情况下可能不是最有效率的。 以下是枚举法的一些特点和应用场景： 特点 简单直观：枚举法的实现通常很直接，容易理解。 通用性强：它可以应用于许多不同类型的问题。 效率低：对于复杂问题或大数据集，枚举所有可能性可能非常耗时。 应用场景 搜索和排序问题：在一组数据中查找特定元素或对元素进行排序。 优化问题：寻找满足特定条件的最优解，如旅行商问题（TSP）。 组合问题：列出满足特定条件的所有组合，如生成所有可能的密码。 实现步骤 定义问题的解空间：确定所有可能的解所构成的集合。 枚举解空间：系统地列举解空间中的每一个解。 检验每个解：对于每个枚举出的解，检查它是否满足问题的条件。 记录和输出解：找到符合条件的解后进行记录，最后输出所有有效解或最优解。
    • 假设你要解决一个简单的问题：找出数组中的所有元素对，其和等于给定的数。使用枚举法，你会这样做： def find_pairs(arr, target): n = len(arr) for i in range(n): for j in range(i + 1, n): if arr[i] + arr[j] == target: print(f"Pair found: ({arr[i]}, {arr[j]})") # 示例 arr = [1, 2, 3, 4, 5] target = 6 find_pairs(arr, target)
  • 算法：模拟法
  • 输出格式化
    • 输出2位小数
      • 使用字符串格式化方法 format: 你可以指定小数点后的精度。对于两位小数，使用 .2f。 例子： number = 123.456 print("{:.2f}".format(number))
      • 使用百分号（%）格式化: 这是一种更传统的方法，类似于C语言中的printf。 例子： number = 123.456 print("%.2f" % number)
      • 子主题
• 二级易错点
  • 随机数
    • 随机浮点数
      • random.uniform(1.1,2.2)
      • random.random()
        • 0-1之间浮点数
    • 随机整数
      • random.randint(5,9)
    • 类型转换
      • 浮点型字符串不能直接转为整型，必须先将字符串转为浮点型，然后再将浮点型转为整型： int(float("3.14"))
  • 易错点
    • 逻辑运算符 and : a and b : 如果a为false， a and b = false, 如果a为true 否则返回 b 10 and 20 = 20 0 and 20 = 0 or. a or b: 如果 a 为 true a or b = a 如果 a 为false a or b = b 10 or 20 = 10 0 or 20 = 20 not. Not a : 如果a为true，返回false， 如果a为false，返回 true not 10 = false. Not 0 = true python 中为false的有如下： 0， None， [ ], {}, (), ‘ ‘
    • 运算符： ** 取幂。2*5 = 2*2*2*2*2 5个2相乘 // 取整除 9//2=4 -9//2 = -5 向下取整数
    • 运算符优先级： ** 大于 *,/,%,// > 大于 +,- 大于 and, or