GESP 3级考纲和注意事项

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

GESP 3级

• 目标
  • 掌握数据编码、进制转换、位运算等知识，掌握一维数 组的、字符串及函数的使用，能够独立使用模拟法、 枚举法解决对应的算法问题。
• 内容
  • 数据编码（原码、反码、补码）
  • 进制转换（二进制、八进制、十进制、十六进制）
  • 位运算（与（&）、或（|）、非（!）、异或（^）、左移（<<）、右移(>>)）
    • 与 &
    • 或 ｜
    • 非 ！
    • 异或^
    • 左移 <<
    • 右移 >>
  • 算法的概念与描述（自然语言描述、流程图描述、伪代码描述）
  • 内置数据类型
    • 序列
      • 可变
        • 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)
    • 集合
      • 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)
      • 子主题