一、AI能高效替代的人工工作：规则化、无主观判断的劳动

1. 机械重复的执行类工作：如数据录入、发票核验、客服标准化咨询、电商基础美工抠图、程序员基础代码编写、行政报表统计、银行柜台基础操作等；
2. 海量数据的处理类工作：如用户行为初步分析、市场数据统计、医疗影像初筛、金融风险初步评估等，AI 能快速处理人类无法在短时间内消化的海量数据，输出基础结论；
3. 固定流程的自动化工作：如制造业的流水线机械操作、物流的路径规划与分拣、办公场景的自动化脚本执行等，AI 能无缝对接流程，减少人工干预。

二、AI几乎无法替代的人工工作：依赖人类独有的核心能力

1. 强创造性的工作：如文学创作、艺术设计、影视编剧、原创音乐、产品创新等。AI 能生成文案、海报、旋律的初稿，但无法创造出有深度情感、独特思想、人文温度的作品 —— 比如 AI 能写一篇写景散文，却无法复刻作家对生活的独特感悟；能生成一幅画作，却无法传递艺术家的精神表达。
2. 高决策性的战略工作：如企业高层管理、行业战略制定、投资核心决策、政策制定等。这类工作需要结合行业经验、人性洞察、突发情况应对、价值判断，而 AI 的分析仅基于历史数据，无法预判未知的市场变化、无法结合组织的文化和人性特点做出最优决策，只能提供数据支撑，最终的拍板必须由人类完成。
3. 强情感与社交的工作：如教师、医生、心理咨询师、律师、高端服务顾问、销售核心岗等。这类工作的核心是人与人之间的情感连接、共情能力和个性化沟通—— 比如医生不仅要诊断病情，还要安抚患者的情绪；教师不仅要传授知识，还要引导学生的价值观；心理咨询师的核心是共情，这些都是 AI 无法模拟的 “人类专属能力”。
4. 需要临场应变的非标工作：如应急救援、设备维修现场处理、线下商务谈判等。这类工作没有固定规则，需要根据现场情况快速反应、灵活变通，而 AI 的行为被训练数据和算法限定，无法应对超出训练范围的突发场景。

三、AI 替代人工的核心边界：永远是 “工具”，而非 “主体”

1. AI 无 “自主意识”：它不会主动思考、不会产生需求、不会做出无数据支撑的判断，所有输出都是基于训练数据的概率性结果，而非 “主观选择”。比如 AI 能写代码，但不会主动思考 “这个功能的业务价值是什么”；能做数据分析，但不会判断 “这个结论是否符合企业的核心诉求”。
2. AI 的能力源于人类：AI 的训练数据来自人类的知识和行为，算法由人类设计，输出的结果需要人类审核、优化、落地—— 比如 AI 生成的营销方案，需要人类结合品牌调性调整；AI 发现的代码 bug，需要人类分析根因并修复；AI 的所有能力，都是人类能力的 “延伸”，而非 “超越”。
3. AI 无法定义 “价值”：工作的核心价值，最终由人类的需求和认知决定 —— 比如一件艺术品的价值，不在于技法的完美，而在于人类赋予的精神内涵；一个产品的价值，不在于功能的齐全，而在于满足人类的真实需求。AI 无法定义这种 “价值”，只能围绕人类定义的价值做执行。

四、最终的职场形态：人机协同，而非 “非此即彼”

• AI 承接低价值、高重复、标准化的工作环节，让人类从机械执行中解放；
• 人类聚焦高价值、创造性、决策性的工作核心，负责定义需求、审核结果、制定战略、创造价值。

一、核心积极影响：效率提升与工作价值回归

1. 替代机械重复劳动，降低时间与人力成本
    
   对于包含大量规则化、重复性、标准化操作的工作，AI 能实现全流程或半流程自动化，且在准确性、效率上远超人工。比如行政岗的报表统计、合同初审，财务岗的发票核验、凭证录入，客服岗的标准化咨询回复，程序员的基础代码编写、bug 初筛，设计岗的素材抠图、版式初稿生成等。这类工作无需复杂的主观判断，AI 能以 “7×24 小时” 的模式完成，既减少了人工失误，也让企业降低了基础人力的投入，让员工从 “机械执行” 中抽身。
2. 提升复杂工作的决策效率与准确性
    
   AI 具备强大的数据分析、趋势预测和多维度整合能力，能为高难度的工作决策提供科学支撑，弥补人类在数据处理规模、速度上的短板。比如企业运营的用户行为分析、市场趋势预判，金融行业的风险评估、投资策略建议，医疗行业的影像初诊、病例数据分析，制造业的设备故障预警、生产流程优化等。人类不再需要花费大量时间整理、分析数据，而是基于 AI 的分析结果进行二次判断和战略决策，让决策更高效、更贴合实际。
3. 推动跨领域能力融合，降低工作门槛
    
   AI 工具的平民化，让非专业人士也能快速掌握原本需要专业技能的工作能力，实现 “低门槛完成专业操作”。比如不懂编程的运营人员，可通过 AI 生成简单的自动化脚本实现工作提效；不会设计的文案人员，能借助 AI 设计工具生成符合需求的海报、短视频；不精通外语的外贸从业者，可通过 AI 实时翻译完成跨语言沟通。这种能力融合，打破了传统岗位的技能壁垒，让员工能更灵活地应对工作中的多元需求。
4. 优化工作协作模式，提升团队协同效率
    
   智能办公工具（如 AI 会议纪要、AI 任务拆解、AI 文档协作）正在重构团队协作的流程：比如会议中 AI 可实时记录要点、生成待办事项并分配责任人，避免人工记录的遗漏；跨部门协作中，AI 可整合各部门的工作数据、进度信息，实现可视化追踪；远程工作中，AI 能实现工作内容的智能同步与反馈。这些工具让协作中的 “沟通成本、信息壁垒” 大幅降低，让团队协作更高效、更顺畅。

二、现实挑战：岗位调整与能力适配的双重压力

1. 基础岗位面临替代与精简，岗位结构重新洗牌
    
   那些高度依赖机械重复、标准化操作的基础型岗位，是 AI 替代的主要对象，这类岗位的需求会大幅缩减，甚至部分岗位会逐步消失。比如传统的电话客服、数据录入员、银行柜台基础操作员、电商基础美工、简单的文案撰稿人等。与之相对的是，AI 相关的新增岗位（如 AI 训练师、AIprompt 工程师、AI 工具运维师）和复合型岗位（如懂 AI 的运营、会用 AI 的程序员、结合 AI 的设计师）需求快速增长，行业的岗位结构从 “基础人力密集型” 向 “技术复合型、决策型” 转型，部分职场人面临 “岗位淘汰” 的风险。
2. 职场人能力要求升级，“AI 适配能力” 成核心竞争力
    
   AI 时代，职场人的核心能力不再是 “熟练掌握某一项基础技能”，而是 **“与 AI 协作的能力”**—— 即能精准向 AI 提需求（写 prompt）、能审核 AI 的输出结果、能将 AI 工具与自身工作结合实现效率提升、能基于 AI 的成果进行创造性优化。对于传统职场人而言，若无法快速掌握 AI 工具的使用方法，无法将自身能力与 AI 结合，就会逐渐失去竞争力。比如同样的文案岗，会用 AI 生成初稿并进行优化的人，效率远高于纯手工撰写的人；同样的程序员，能借助 AI 完成基础编码并聚焦架构设计的人，更受企业青睐。这种能力要求的升级，给职场人带来了持续学习的压力。
3. 部分行业出现 “过度依赖 AI” 的问题，影响工作质量
    
   部分职场人因追求效率，过度依赖 AI 的输出结果，放弃了自身的主观判断和专业思考，导致工作内容出现 “同质化、低质量、脱离实际” 的问题。比如文案创作中，直接照搬 AI 生成的内容，缺乏个性化和品牌调性；设计工作中，完全使用 AI 生成的素材，导致作品缺乏创意和情感；决策工作中，盲目相信 AI 的分析结果，忽略了实际业务的特殊性和人文因素。这种 “AI 依赖症”，不仅会降低工作质量，还会让职场人逐渐丧失自身的核心思考能力。
4. 职业安全感缺失，职场焦虑加剧
    
   面对 AI 的替代风险，很多职场人尤其是基础岗位的从业者，会产生强烈的职业安全感缺失，进而引发职场焦虑。这种焦虑不仅来自 “岗位被替代” 的担忧，还来自 “持续学习的压力”—— 面对不断更新的 AI 工具和技术，职场人需要持续投入时间和精力学习，否则就会被行业淘汰。这种焦虑在中老年职场人中表现得更为明显，部分人因学习能力下降，难以适应 AI 时代的工作要求，陷入 “想转型却无方向” 的困境。

三、差异化影响：行业与岗位的 “冰火两重天”

1. 受 AI 影响较大的行业 / 岗位
    
   主要集中在服务业、金融、行政、制造业、电商等行业中的基础岗位，比如客服、数据录入、基础财务、柜台操作、基础编码、基础美工、简单文案等。这类岗位的工作内容规则化程度高，无需复杂的主观判断，AI 能快速实现自动化替代，岗位需求会持续缩减。
2. AI 以辅助为主，难以替代的行业 / 岗位
    
   主要集中在文化创意、管理决策、教育、医疗、心理咨询、高端服务等行业，比如作家、设计师、企业管理者、医生、教师、心理咨询师、高端律师等。这类岗位的核心价值在于人类的创造性、主观判断、情感沟通、战略思维和人文关怀，而这些能力是当前 AI 难以复刻的 ——AI 能生成文案初稿，但无法创造出有深度、有情感的文学作品；AI 能完成影像初诊，但无法做出最终的临床诊断并与患者进行情感沟通；AI 能生成管理建议，但无法结合企业的文化、团队的特点做出战略决策。
3. AI 推动快速升级的行业 / 岗位
    
   主要集中在互联网、科技、制造业、物流等技术密集型行业，比如程序员、产品经理、运营、工程师、物流规划师等。这类岗位不会被 AI 替代，但 AI 会成为其核心工作工具，推动岗位能力要求升级 —— 从业者需要掌握 AI 工具的使用方法，将 AI 与自身的专业能力结合，实现工作效率和质量的双重提升。

四、应对趋势：职场人与企业的双向适配

1. 职场人：树立 “AI 协作思维”，打造复合型核心能力
    
   一方面，要主动学习 AI 工具，掌握与 AI 协作的基本能力 —— 比如学会写精准的 prompt、学会审核和优化 AI 的输出结果、学会将 AI 工具融入自身的工作流程，让 AI 成为自己的 “工作助手”；另一方面，要聚焦于AI 难以替代的能力培养，比如创造性思维、战略决策能力、情感沟通能力、跨领域整合能力，打造属于自己的 “核心竞争力”。同时，要树立 “终身学习” 的理念，适应 AI 技术的不断更新，避免被行业淘汰。
2. 企业：优化岗位结构，推动 “人机协同” 的工作模式
    
   企业要理性看待 AI 的价值，既不盲目追求 “全自动化” 而大量裁员，也不忽视 AI 的效率价值。一方面，要结合行业特点和岗位需求，逐步优化岗位结构，将基础重复的工作交给 AI，将人力向高价值、创造性的岗位转移；另一方面，要为员工提供 AI 技能培训，帮助员工快速掌握 AI 工具的使用方法，推动 “人机协同” 的工作模式落地。同时，企业要建立相关的规范，避免员工过度依赖 AI，保证工作质量。
3. 行业与社会：完善配套机制，缓解 AI 带来的就业压力
    
   行业和社会层面，要完善相关的配套机制 —— 比如建立 AI 时代的职业技能培训体系，为被 AI 替代的职场人提供转型培训；完善就业保障机制，缓解职场人的职业焦虑；制定 AI 应用的行业规范，避免 AI 的无序发展带来的岗位失衡问题。同时，要鼓励 AI 技术的创新与落地，推动更多新增岗位的出现，实现 “岗位替代” 与 “岗位创造” 的平衡。

一、核心注意事项（按优先级排序）

1. 遵守法律法规与网站规则（最重要）

• robots 协议：几乎所有网站根目录下都有 robots.txt（如 https://www.xxx.com/robots.txt），它规定了网站允许 / 禁止爬虫访问的内容。虽然不具备法律强制力，但遵守它是爬虫开发者的基本操守。
  python

   

  运行

   

  # 示例：查看并解析robots.txt（使用robotparser库）
  from urllib.robotparser import RobotFileParser
  
  rp = RobotFileParser()
  rp.set_url('https://www.baidu.com/robots.txt')
  rp.read()
  # 检查是否允许爬取某个路径
  print(rp.can_fetch('*', 'https://www.baidu.com/s'))  # 返回True/False
  

   
   
• 法律红线：
  • 不得爬取涉及隐私、敏感信息（如用户手机号、身份证、未公开的商业数据）的内容；
  • 不得突破网站的访问限制（如破解登录、绕过反爬措施进行恶意爬取）；
  • 爬取的数据不得用于非法用途（如倒卖、侵权）。
   
• 网站条款：很多网站的 “用户协议” 里明确禁止爬虫，爬取前务必查看。

2. 控制爬取频率，避免给服务器造成压力

• 设置请求间隔：使用 time.sleep() 或更灵活的 random.uniform() 随机间隔，避免高频请求。
  python

   

  运行

   

   

  import time
  import random
  
  # 每次请求后随机等待1-3秒
  time.sleep(random.uniform(1, 3))
  

   
   
• 限制并发数：使用 requests.Session() 保持连接复用，或用 aiohttp 异步爬虫时控制并发量（避免同时发起上百个请求）。
• 避免高峰期爬取：尽量在网站访问低峰期（如凌晨）爬取，减少对服务器的影响。

3. 处理反爬机制

• 设置请求头（Headers）：至少带上 User-Agent（模拟浏览器），必要时补充 Referer、Cookie、Accept 等。
  python

   

  运行

   

  import requests
  
  headers = {
      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
      'Referer': 'https://www.xxx.com/'  # 表示请求来源
  }
  response = requests.get('https://www.xxx.com', headers=headers)
  

   
   
• 使用代理 IP：如果爬取量较大，单一 IP 容易被封禁，可使用免费 / 付费代理池轮换 IP。
  python

   

  运行

   

   

   

   

  proxies = {
      'http': 'http://123.45.67.89:8080',
      'https': 'https://123.45.67.89:8080'
  }
  response = requests.get('https://www.xxx.com', proxies=proxies)
  

   
   
• 处理验证码：简单验证码可使用 ddddocr 识别，复杂验证码（滑块、点选）可考虑第三方打码平台，或直接绕开（如模拟登录后携带 Cookie）。
• 动态渲染页面：如果页面是 JS 动态加载的（如 Ajax、Vue/React 渲染），可使用 Selenium、Playwright 模拟浏览器渲染，或直接抓包获取接口数据（更高效）。

4. 代码健壮性与数据处理

• 异常处理：对网络请求、数据解析、文件读写等环节加异常捕获，避免爬虫中途崩溃。
  python

   

  运行

   

  import requests
  from requests.exceptions import RequestException
  
  try:
      response = requests.get('https://www.xxx.com', timeout=10)
      response.raise_for_status()  # 抛出HTTP状态码异常（如404、500）
      response.encoding = response.apparent_encoding  # 自动识别编码
  except RequestException as e:
      print(f'请求失败：{e}')
  

   
   
• 数据持久化：爬取的数据及时保存（如 CSV、JSON、MySQL），避免爬取完成后数据丢失。
• 去重与校验：对爬取的 URL、数据内容做去重处理，校验数据格式（如手机号、邮箱），保证数据准确性。

5. 其他实用技巧

• 使用 Session 保持会话：爬取需要登录的网站时，用 requests.Session() 保存 Cookie，避免重复登录。
• 日志记录：使用 logging 模块记录爬虫运行日志（如请求成功 / 失败、爬取数量），方便排查问题。
  python

   

  运行

   

   

  import logging
  
  logging.basicConfig(
      level=logging.INFO,
      format='%(asctime)s - %(levelname)s - %(message)s',
      filename='spider.log'  # 日志保存到文件
  )
  logging.info('爬虫启动')
  logging.error('请求失败：IP被封禁')
  

   
   
• 分布式 / 增量爬取：如果爬取量极大，可使用 Scrapy-Redis 实现分布式爬虫；定期爬取时，只爬取新增内容（增量爬取），减少资源消耗。

总结

1. 合规优先：遵守 robots 协议和法律法规，不爬取敏感数据，这是爬虫开发的底线；
2. 模拟真人：控制爬取频率、设置合理请求头、使用代理 IP，避免被网站反爬封禁；
3. 健壮性：做好异常处理、日志记录和数据持久化，保证爬虫稳定运行且数据不丢失。

    location / {
        root /var/www/[项目名]-frontend/dist;
        index index.html;
        try_files $uri $uri/ /index.html; # 解决前端路由刷新404
    }
}
 
3. 部署后端项目
- 若为Node.js后端：上传代码至服务器，安装依赖 npm install --production ，用 pm2 （进程守护工具）启动服务： pm2 start app.js --name [后端服务名] 。
- 若为Java后端：打包为 jar 包，上传后用 nohup java -jar [xxx.jar] & 后台运行；或用 systemd 配置开机自启。
- 确保后端服务监听指定端口（如 3000 ），且服务器防火墙/安全组开放该端口。
4. 配置Nginx反向代理（关键）
为解决跨域问题，在Nginx配置中添加后端接口代理规则，示例：
plaintext   
server {
    listen 80;
    server_name 你的服务器IP/域名;

    # 前端静态资源
    location / {
        root /var/www/[项目名]-frontend/dist;
        index index.html;
        try_files $uri $uri/ /index.html;
    }

    # 后端接口代理
    location /api {
        proxy_pass http://127.0.0.1:3000; # 后端服务地址+端口
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}
 
 
配置完成后，重启Nginx生效： sudo nginx -t && sudo systemctl restart nginx 
5. 验证部署
浏览器访问服务器IP/域名，能正常加载前端页面，且前端调用 /api 接口可成功获取后端数据，即部署完成。
 

一、前提：明确业务需求（避免 “为设计而设计”）

1. 梳理核心业务流程：

    

   用流程图或文字描述软件的关键操作（如电商的 “下单→支付→发货”，社交的 “注册→发动态→评论”），明确每个流程涉及的数据输入、处理和输出。

    

   例：外卖系统核心流程：用户下单→商家接单→骑手取餐→用户确认收货。
2. 提取实体与属性：

    

   从流程中识别核心 “实体”（业务对象），并列出每个实体的 “属性”（特征）：
   • 实体：可理解为 “名词”（用户、订单、商品、骑手等）；
   • 属性：实体的描述信息（用户有手机号、姓名；订单有金额、创建时间等）。
      
     例：外卖系统实体清单：User（用户）、Merchant（商家）、Order（订单）、Food（食品）、Rider（骑手）。
3. 明确实体关系：

    

   确定实体间的关联方式（一对一、一对多、多对多）：
   • 例：User与Order是 “一对多”（一个用户可下多个订单）；
   • Order与Food是 “多对多”（一个订单含多种食品，一种食品可在多个订单中）。

二、步骤 1：概念模型设计（画 ER 图，无关具体数据库）

核心要素：

• 实体（Entity）：用矩形表示，标注实体名称（如User、Order）。
• 属性（Attribute）：用椭圆表示，与实体连接（如User的id、phone、name）。
• 主键（Primary Key）：属性中能唯一标识实体的字段（如User.id），下划线标注。
• 关系（Relationship）：用菱形表示，标注关系类型（如 “下单”“包含”），并注明 cardinality（1:1、1:N、M:N）。

案例：外卖系统简化 ER 图

+--------+       1    +--------+       N    +--------+  
|  User  |<---------->|  Order |<---------->|  Food  |  
+--------+    下单    +--------+    包含    +--------+  
  | id        (1:N)     | id          (M:N)   | id  
  | phone               | amount            | name  
  | name                | status            | price  
                        | create_time       | merchant_id  
                                          +--------+  
+--------+       1     |  OrderFood  |     |Merchant|  
|Rider   |<----------->| (中间表)    |     +--------+  
+--------+    配送     | order_id    |       | id  
  | id          (1:1)  | food_id     |       | name  
  | name               | quantity    |       | address  
  | phone              +-------------+       | status  

三、步骤 2：逻辑模型设计（转化为表结构，数据库无关）

关键操作：

1. 实体→表：每个实体对应一张表，实体名称即为表名（如User实体→user表）。
2. 属性→字段：
   • 为每个字段指定数据类型（遵循 “最小够用” 原则，如手机号用CHAR(11)而非VARCHAR(20)）；
   • 标记约束：NOT NULL（必填）、UNIQUE（唯一）、DEFAULT（默认值）等。
3. 关系→表 / 字段：
   • 1:1 关系：在其中一张表中加外键（如User与UserDetail，在user_detail表加user_id外键关联user.id，并设UNIQUE保证唯一）。
   • 1:N 关系：在 “多” 的表中加外键（如User(1) 与Order(N)，在order表加user_id外键关联user.id）。
   • M:N 关系：新增中间表，存储两个实体的主键（如Order与Food的 M:N 关系，新增order_food表，含order_id和food_id两个外键，联合主键）。

案例：外卖系统逻辑模型（表结构）

四、步骤 3：物理模型设计（适配具体数据库，性能优化）

关键操作：

1. 选择存储引擎（以 MySQL 为例）：
   • 需事务、外键：选InnoDB（支持 ACID、行级锁）；
   • 读多写少的静态数据（如字典表）：可选MyISAM（查询更快，但不支持事务）。
2. 索引设计：
   • 主键索引：默认由数据库自动创建（如user.id）；
   • 外键索引：所有外键必须建索引（如order.user_id，避免 JOIN 时全表扫描）；
   • 业务索引：高频查询字段（如user.phone（登录查询）、order.status（筛选待处理订单））。
   • 联合索引：多字段查询场景（如WHERE merchant_id=1 AND status=2，建(merchant_id, status)）。
3. 分区 / 分表策略（针对大数据量）：
   • 时间维度：订单表order按create_time分区（如每月一个分区），适合历史数据归档；
   • 范围维度：用户表user按id范围分表（如user_1存id=1~100万，user_2存100万~200万）。
4. 字段优化：
   • 敏感字段加密：手机号、身份证号用加密算法（如 AES）存储，避免明文泄露；
   • 大字段拆分：商品详情等超长文本（TEXT类型）拆分到独立表（如product_detail），避免主表查询效率下降。

五、步骤 4：验证与迭代（用原型和测试发现问题）

1. 原型测试：

    

   用工具（如 Navicat、PowerDesigner）生成物理模型，创建测试表，插入模拟数据，执行核心业务 SQL（如 “查询用户 30 天内的订单”“统计商家今日销售额”），检查是否存在：
   • 表关联过多（JOIN 超过 3 张表可能影响性能）；
   • 缺少必要索引（查询耗时过长）；
   • 字段设计不合理（如用VARCHAR存订单状态，无法高效筛选）。
2. 压力测试：

    

   用工具（如 JMeter）模拟高并发场景（如秒杀时的订单创建），观察：
   • 锁冲突（如InnoDB的行锁是否导致插入阻塞）；
   • 索引失效（如大表全表扫描）；
   • 连接数瓶颈（需调整max_connections等参数）。
3. 业务迭代适配：

    

   当业务新增功能（如外卖系统增加 “优惠券”），需同步优化模型：
   • 新增coupon表（优惠券信息）；
   • 新增order_coupon中间表（订单与优惠券的多对多关系）；
   • 调整order表，增加coupon_discount字段（优惠金额）。

六、工具推荐（提高设计效率）

• ER 图工具：PowerDesigner（功能全）、draw.io（免费）、Navicat（自带 ER 图功能）；
• 建模工具：MySQL Workbench（MySQL 官方工具，支持从 ER 图生成 SQL）、dbeaver（跨数据库通用）；
• 版本管理：将建表 SQL（CREATE TABLE）纳入 Git 管理，记录模型变更历史。

核心原则总结

1. 业务优先：模型必须贴合业务，而非强行套用范式；
2. 适度冗余：为高频查询增加冗余字段（如订单表存merchant_name），减少 JOIN；
3. 可扩展性：预留扩展字段（如ext_json存动态属性），避免频繁 ALTER TABLE；
4. 性能平衡：索引不是越多越好（会降低写入速度），需根据查询频率取舍。

一、合理应用范式与反范式，平衡冗余与关联

1. 遵循核心范式（避免数据冗余和异常）

• 第一范式（1NF）：确保每个字段不可再分（原子性）。
   
  例：避免在address字段中存储 “省 + 市 + 区”，应拆分为province、city、district三个独立字段，便于单独查询（如按城市筛选）。
• 第二范式（2NF）：在 1NF 基础上，非主键字段必须完全依赖于主键（消除部分依赖）。
   
  例：订单表order中，product_name不应依赖于product_id（部分依赖），而应将商品信息拆分到product表，订单表仅存product_id（外键关联）。
• 第三范式（3NF）：在 2NF 基础上，非主键字段不依赖于其他非主键字段（消除传递依赖）。
   
  例：用户表user中，area_name不应依赖于area_id（传递依赖），应将地区信息拆分到area表，用户表仅存area_id。

2. 适当反范式（提升查询效率）

• 例：电商订单表order中，冗余存储product_name（而非仅存product_id），避免查询订单详情时必须关联product表。
• 注意：冗余字段需通过触发器、事务或应用层逻辑保证一致性（如商品名称修改时同步更新订单表中的冗余字段）。

二、优化表结构设计，减少存储开销

1. 拆分大表（避免 “万能表”）

• 垂直拆分：将大表按字段关联性拆分为多个小表（适合字段多但访问频率差异大的场景）。
   
  例：用户表user拆分为user_base（存储常用字段：id、name、phone）和user_detail（存储不常用字段：birthday、address、avatar），查询登录信息时只需访问user_base。
• 水平拆分：将大表按行拆分（适合数据量极大的场景），拆分维度通常为时间、地区、用户 ID 等。
   
  例：日志表log按月份拆分为log_202301、log_202302，查询 2023 年 1 月日志时仅需访问对应分表。

2. 选择合适的数据类型（节省空间 + 提升效率）

• 数字类型：优先用INT（4 字节）、BIGINT（8 字节）存整数，避免用VARCHAR（如用户 ID、订单号）；用DECIMAL存金额（如DECIMAL(10,2)），避免FLOAT/DOUBLE的精度丢失问题。
• 字符串类型：固定长度用CHAR（如手机号 11 位用CHAR(11)），可变长度用VARCHAR（如用户名）；超长文本（如文章内容）用TEXT，但需注意：TEXT字段查询较慢，尽量避免作为查询条件。
• 日期类型：用DATE（年月日）、DATETIME（年月日时分秒）、TIMESTAMP（带时区，占 4 字节，比DATETIME更省空间），避免用VARCHAR存日期（无法直接做时间运算，如WHERE create_time > '2023-01-01'）。
• 枚举类型：固定可选值的字段用ENUM（如性别ENUM('male','female','unknown')），比VARCHAR更省空间且查询更快。

三、科学设计索引，加速查询

1. 必建索引的场景

• 主键索引：每张表必须有主键（PRIMARY KEY），推荐用自增INT或BIGINT（避免 UUID 等无序值，防止页分裂）。
• 外键索引：外键字段（如order.product_id关联product.id）需建索引，否则 JOIN 操作会全表扫描。
• 高频查询字段：WHERE、JOIN、ORDER BY、GROUP BY中频繁出现的字段，如用户表的phone（登录查询）、订单表的user_id（查询用户所有订单）。

2. 优化索引结构

• 联合索引：多字段查询时，创建联合索引（需遵循 “最左前缀原则”）。
   
  例：频繁查询WHERE status=1 AND create_time > '2023-01-01'，联合索引(status, create_time)有效，而(create_time, status)无效（不符合最左前缀）。
• 避免冗余索引：若已有联合索引(a,b)，则单独的(a)索引是冗余的（联合索引的前缀字段可被单独使用）。
• 控制索引数量：单表索引建议不超过 5 个，新增索引前需评估查询收益与写入损耗。

3. 不适合建索引的场景

• 低频查询字段（如一年才查一次的remark备注字段）；
• 字段值重复率高（如gender性别，区分度低，索引效果差）；
• 小表（数据量 < 1 万行，全表扫描比索引查询更快）。

四、设计合理的关系与约束，保证数据完整性

1. 明确表关系（避免混乱关联）

• 一对一：如user与user_passport（一个用户对应一个护照），可将其中一张表的主键设为另一张表的外键（并加唯一约束UNIQUE）。
• 一对多：如user与order（一个用户多个订单），在 “多” 的表（order）中加外键user_id关联user.id。
• 多对多：如student与course（一个学生选多门课，一门课有多个学生），需创建中间表student_course，存储student_id和course_id（联合主键）。

2. 合理使用约束（减少脏数据）

• 非空约束（NOT NULL）：必填字段（如user.name、order.amount）设为NOT NULL，避免NULL值导致的查询异常（如NULL != NULL）。
• 唯一约束（UNIQUE）：需唯一的字段（如user.phone、product.sku）设为UNIQUE，数据库层面防止重复。
• 检查约束（CHECK）：限制字段值范围（如order.amount > 0、user.age BETWEEN 0 AND 150），避免无效数据。

五、针对大数据量的特殊优化

1. 分区表（拆分大表为逻辑子表）

• 范围分区：按时间（如create_time）或数字范围（如user_id）分区，适合日志、订单等时序数据。
   
  例：CREATE TABLE order (id INT, create_time DATETIME) PARTITION BY RANGE (TO_DAYS(create_time)) (PARTITION p202301 VALUES LESS THAN (TO_DAYS('2023-02-01')));
• 列表分区：按枚举值（如area_id）分区，适合地区、状态等固定分类数据。

2. 分库分表（突破单库性能瓶颈）

• 水平分库：按用户 ID 哈希将数据分散到多个数据库（如db_0、db_1），降低单库压力。
• 垂直分库：按业务模块拆分（如用户库、订单库、商品库），避免单库资源竞争。

六、适配查询模式，减少低效操作

1. 避免 “大而全” 的查询

• 例：电商商品列表页只需id、name、price、img_url，则将这些字段放在product主表，而description（详情）、specs（规格）等字段放在子表，减少列表查询的数据传输量。

2. 优化分页与排序

• 分页查询：避免LIMIT 100000, 10（会扫描前 100010 行），改用 “基于主键的跳页”（如WHERE id > 100000 LIMIT 10）。
• 排序字段：确保ORDER BY的字段有索引，避免无索引排序导致的临时表或文件排序（性能极低）。

七、其他关键优化

• 避免使用触发器和存储过程：逻辑复杂时难以维护，且可能成为性能瓶颈（建议移至应用层实现）。
• 预留扩展字段：对变化频繁的业务（如用户标签），可预留ext_json字段（存储 JSON 格式的动态数据），避免频繁 ALTER TABLE（锁表影响性能）。
• 定期维护：通过EXPLAIN分析慢查询，重建碎片化索引（OPTIMIZE TABLE），归档历史数据（如将 3 年前的订单迁移至历史库）。

总结

一、基础连接类报错（最常见）

1. 报错提示：Can't connect to MySQL server on 'xxx.xxx.xxx.xxx' (10060)

• 原因：目标 MySQL 服务器的 IP / 端口无法访问（网络不通或服务未启动）。
  • 可能 1：MySQL 服务未在目标服务器上启动；
  • 可能 2：服务器防火墙 / 安全组拦截了 MySQL 默认端口（3306）；
  • 可能 3：Navicat 中填写的 IP 或端口错误（如端口被修改为非 3306）。
• 处理步骤：
  1. 检查 MySQL 服务状态（目标服务器操作）：
     • Windows：打开「服务」（Win+R 输入 services.msc），找到「MySQL」服务，确认状态为「正在运行」，若未运行则右键「启动」。
     • Linux：执行命令 systemctl status mysql（或 mysqld），若显示 inactive，则执行 systemctl start mysql 启动服务。
  2. 验证 IP 和端口正确性：
     • 确认 Navicat「连接属性」中「主机」是目标服务器的正确 IP（本地连接用 localhost 或 127.0.0.1，远程连接用公网 / 内网 IP）；
     • 确认「端口」与 MySQL 配置一致（默认 3306，若修改过需填实际端口，可通过 MySQL 配置文件 my.cnf/my.ini 中的 port 项查看）。
  3. 测试网络连通性（本地电脑操作）：
     • 打开 CMD/PowerShell（Windows）或 Terminal（Mac/Linux），执行 ping 目标IP，确认能 ping 通（排除 IP 错误或服务器离线）；
     • 执行 telnet 目标IP 端口（如 telnet 192.168.1.100 3306），若提示「无法打开连接」，说明端口被拦截，需配置防火墙 / 安全组。
  4. 开放端口（服务器操作）：
     • Windows：打开「高级防火墙设置」→「入站规则」→「新建规则」，选择「端口」，输入 3306，允许连接。
     • Linux（以 CentOS 为例）：执行 firewall-cmd --zone=public --add-port=3306/tcp --permanent，再执行 firewall-cmd --reload 生效；若用云服务器（阿里云 / 腾讯云），需在「安全组」中添加「允许 3306 端口入站」规则。

2. 报错提示：Access denied for user 'root'@'localhost' (using password: YES)

• 原因：账号密码错误，或账号不允许在当前主机（localhost/远程 IP）登录。
  • 可能 1：Navicat 中输入的「用户名」或「密码」错误（如密码大小写错误、遗忘密码）；
  • 可能 2：账号仅允许特定 IP 登录（如 root 默认仅允许 localhost 登录，远程连接时被拒绝）。
• 处理步骤：
  1. 验证账号密码正确性：
     • 直接在 MySQL 服务器上登录验证：Windows 打开「MySQL Command Line Client」，Linux 执行 mysql -u 用户名 -p，输入密码后若能登录，说明密码正确（否则需重置密码）。
  2. 重置遗忘的密码（以 root 账号为例）：
     • Windows：
       1. 停止 MySQL 服务（服务中右键「停止」）；
       2. 打开 CMD，切换到 MySQL 的 bin 目录（如 cd C:\Program Files\MySQL\MySQL Server 8.0\bin）；
       3. 执行 mysqld --console --skip-grant-tables --shared-memory（跳过权限验证启动服务）；
       4. 新打开一个 CMD，执行 mysql -u root（无密码登录）；
       5. 执行命令更新密码：
          sql

           

           

           

           

           

          FLUSH PRIVILEGES; -- 刷新权限
          ALTER USER 'root'@'localhost' IDENTIFIED BY '新密码'; -- 重置本地密码
          

           
           
       6. 关闭所有 CMD 窗口，重启 MySQL 服务，用新密码连接。
     • Linux：
       1. 执行 systemctl stop mysql 停止服务；
       2. 执行 mysqld_safe --skip-grant-tables & 跳过权限启动；
       3. 执行 mysql -u root 登录，后续步骤与 Windows 一致（第 5 步相同 SQL）。
  3. 允许账号远程登录（若为远程连接场景）：
     • 登录 MySQL 后，执行以下 SQL，允许 root 账号从任意 IP 登录（或指定 IP，将 % 改为具体 IP）：
       sql

        

        

        

        

        

       CREATE USER 'root'@'%' IDENTIFIED BY '密码'; -- 新建远程账号（若不存在）
       GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' WITH GRANT OPTION; -- 赋予远程权限
       FLUSH PRIVILEGES; -- 刷新权限
       

        
        

二、MySQL 版本与配置兼容类报错

1. 报错提示：Authentication plugin 'caching_sha2_password' cannot be loaded

• 原因：MySQL 8.0+ 默认使用 caching_sha2_password 加密方式，而 Navicat 12 及以下版本不支持该加密方式（仅支持旧版 mysql_native_password）。
• 处理步骤：
  1. 方案 1：升级 Navicat（推荐）：
     • 下载 Navicat 15+ 版本（官网或可信渠道），新版本已支持 caching_sha2_password 加密，直接连接即可。
  2. 方案 2：修改 MySQL 账号加密方式（兼容旧 Navicat）：
     • 登录 MySQL 后，执行以下 SQL，将账号加密方式改为 mysql_native_password：
       sql

        

        

        

        

        

       -- 查看当前账号加密方式
       SELECT user, host, plugin FROM mysql.user WHERE user = 'root';
       -- 修改加密方式并重置密码
       ALTER USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY '你的密码';
       FLUSH PRIVILEGES; -- 刷新权限
       

        
        
     • 重启 Navicat，重新连接即可。

2. 报错提示：Too many connections

• 原因：MySQL 允许的最大连接数（max_connections）已达上限，无法新建立连接。
• 处理步骤：
  1. 临时调整最大连接数（立即生效，重启服务后失效）：
     • 登录 MySQL，执行 SET GLOBAL max_connections = 1000;（默认通常为 151，可根据需求调整）；
     • 执行 SHOW VARIABLES LIKE 'max_connections'; 验证是否修改成功。
  2. 永久调整最大连接数（需修改配置文件）：
     • Windows：找到 MySQL 配置文件 my.ini（通常在 C:\ProgramData\MySQL\MySQL Server 8.0），在 [mysqld] 下添加 max_connections = 1000，保存后重启 MySQL 服务。
     • Linux：找到配置文件 my.cnf（通常在 /etc/mysql/），同样在 [mysqld] 下添加 max_connections = 1000，执行 systemctl restart mysql 重启服务。
  3. 排查连接泄漏：
     • 执行 SHOW PROCESSLIST; 查看当前所有连接，若存在大量闲置连接，可执行 KILL 连接ID; 关闭（连接 ID 对应 Id 列的值）。

三、文件权限与服务异常类报错

1. 报错提示：MySQL server version for the right syntax to use near...

• 原因：Navicat 执行的 SQL 语句语法与 MySQL 版本不兼容（如 MySQL 5.x 与 8.0 的语法差异）。
  • 示例：MySQL 8.0 不支持 PASSWORD() 函数（用于加密密码），若执行 SELECT PASSWORD('123456'); 会报错。
• 处理步骤：
  1. 确认 MySQL 版本：登录 MySQL 后执行 SELECT VERSION(); 查看版本；
  2. 调整 SQL 语法以适配版本：
     • 如密码加密：MySQL 5.x 用 PASSWORD('密码')，MySQL 8.0 用 SHA2('密码', 256) 或 ALTER USER 语句；
     • 如 GROUP BY 语法：MySQL 5.7+ 默认开启 only_full_group_by 模式，需确保 GROUP BY 后的字段包含非聚合列，或执行 SET sql_mode = ''; 临时关闭该模式（永久关闭需修改配置文件 my.cnf/my.ini，添加 sql_mode = ""）。

2. 报错提示：The server is configured with lower_case_table_names=0 ...

• 原因：MySQL 配置的 lower_case_table_names（表名大小写敏感）参数与操作系统不匹配，导致表名识别错误。
  • Windows 系统默认 lower_case_table_names=1（表名不区分大小写）；
  • Linux 系统默认 lower_case_table_names=0（表名区分大小写）；
  • 若手动修改该参数后未正确重启，或跨系统迁移数据库，会出现此报错。
• 处理步骤：
  1. 停止 MySQL 服务；
  2. 修改配置文件 my.cnf（Linux）或 my.ini（Windows）：
     • Windows：在 [mysqld] 下添加 lower_case_table_names=1；
     • Linux：若需表名不区分大小写，添加 lower_case_table_names=1（需确保数据库目录下无已存在的表，否则需迁移数据后修改）；
  3. 保存配置文件，重启 MySQL 服务，重新连接。

四、其他小众但关键的报错

1. 报错提示：Lost connection to MySQL server at 'reading initial communication packet', system error: 0

• 原因：MySQL 服务器的 bind-address 配置限制了仅允许特定 IP 连接，或网络不稳定导致握手失败。
• 处理步骤：
  1. 修改 MySQL 配置文件 my.cnf/my.ini，找到 bind-address 项：
     • 若为远程连接，将 bind-address = 127.0.0.1 改为 bind-address = 0.0.0.0（允许所有 IP 连接）；
  2. 保存后重启 MySQL 服务，重新测试连接。

2. 报错提示：Navicat 连接超时（无具体代码，仅提示超时）

• 原因：MySQL 服务响应慢，或 Navicat 连接超时设置过短。
• 处理步骤：
  1. 在 Navicat「连接属性」→「高级」中，将「连接超时」从默认的 10 秒改为 30 秒或更长；
  2. 检查 MySQL 服务器负载（如 CPU、内存使用率），若负载过高，需优化 SQL 或升级服务器配置。

五、排查通用步骤（所有报错通用）

1. 确认基础环境：MySQL 服务是否启动、IP / 端口是否正确、网络是否通畅（用 ping 和 telnet 验证）；
2. 验证账号权限：在 MySQL 服务器本地登录账号，确认密码正确且有连接权限；
3. 查看 MySQL 日志：日志中会记录详细错误原因（路径在配置文件 my.cnf/my.ini 的 log-error 项中）；
4. 升级软件版本：若为版本兼容问题，升级 Navicat 或 MySQL 到稳定版本（如 MySQL 8.0+ 搭配 Navicat 15+）。

1. 登录宝塔面板
   • 通过服务器 IP:8888 访问宝塔登录页面
   • 输入用户名和密码登录
2. 创建网站
   • 在左侧菜单找到「网站」并点击
   • 点击「添加站点」按钮
   • 填写域名（如果没有域名，可填写服务器 IP）
   • 根目录可保持默认或自定义（建议使用默认路径）
   • 静态网页无需数据库，所以数据库选项选择「无」
   • PHP 版本选择「纯静态」
   • 点击「提交」完成网站创建
3. 上传静态文件
   • 网站创建完成后，点击该网站的「文件」按钮进入文件管理
   • 进入网站根目录（通常是 /www/wwwroot/ 你的域名）
   • 删除目录中默认的文件（如 index.html、404.html 等）
   • 点击「上传」按钮，选择你的静态网页文件（HTML、CSS、JS、图片等）
   • 可以选择上传压缩包后解压，或直接上传整个文件夹
4. 设置默认首页
   • 回到网站列表，点击该网站的「设置」
   • 进入「默认文档」选项卡
   • 确保你的首页文件（通常是 index.html）在默认文档列表中，并且位于靠前位置
   • 点击「保存」
5. 访问网站
   • 在浏览器中输入你的域名或服务器 IP
   • 如果配置正确，应该能看到你的静态网页内容

• 确保文件名和路径正确，特别是引用 CSS、JS 和图片的路径
• 如果使用了路由功能，可能需要配置伪静态规则
• 若网页涉及跨域请求，可能需要在宝塔的 Nginx 配置中添加跨域允许规则

核心思想：爬虫是什么？

简单来说，网络爬虫就是一个自动化的程序，它模仿人类浏览网页的行为，但速度更快、规模更大。它的基本工作流程是：
1.  **发送请求**：向目标网站的服务器发送一个请求（比如“请把百度首页的内容给我”）。
2.  **获取响应**：服务器返回网页的源代码（通常是HTML格式）。
3.  **解析数据**：从一大堆HTML代码中，提取出我们需要的具体信息（如文章标题、价格、链接等）。
4.  **保存数据**：将提取出的信息保存到文件（如CSV、JSON）或数据库中。

---

 第一步：必备库介绍

Python有几个库是爬虫的“神器”，你需要先安装它们。

```bash
# 在命令行/终端中使用pip安装
pip install requests
pip install beautifulsoup4
pip install lxml  # 这是一个解析器，BeautifulSoup需要它来快速解析HTML
```

- **`requests`**： 用于发送HTTP请求，获取网页源代码。简单易用，是爬虫的基础。
- **`BeautifulSoup`** (来自 `bs4`)： 用于解析HTML和XML文档，从复杂的标签中提取数据，就像在汤里捞取你想要的“菜”（数据）一样，故名“美丽的汤”。

---

第二步：一个完整的入门实例（静态页面爬取）

我们以爬取**豆瓣电影Top250**的第一页电影名和评分为例。

```python
import requests
from bs4 import BeautifulSoup

# 1. 目标网址
url = 'https://movie.douban.com/top250'

# 2. 模拟浏览器访问（添加请求头，避免被网站识别为简单爬虫）
headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
}

# 3. 发送GET请求，获取网页源代码
response = requests.get(url, headers=headers)
# 检查请求是否成功（状态码200表示成功）
if response.status_code == 200:
    html_text = response.text  # 得到网页的HTML文本
else:
    print(‘请求失败，状态码：', response.status_code)
    exit()

# 4. 使用BeautifulSoup解析HTML
soup = BeautifulSoup(html_text, 'lxml')  # 指定使用lxml解析器

# 5. 查找和提取数据
# 在浏览器中打开豆瓣Top250，按F12打开开发者工具，使用“检查”功能找到电影名所在的HTML标签。
# 我们发现每个电影项都在一个 class="item" 的div中，电影名在 <span class="title"> 里。
movie_list = soup.find_all('div', class_='item')

for movie in movie_list:
    # 查找电影名（只取中文名，第一个span.title）
    title_tag = movie.find('span', class_='title')
    title = title_tag.get_text() if title_tag else "未找到标题"

    # 查找评分（在 <span class="rating_num"> 里）
    rating_tag = movie.find('span', class_='rating_num')
    rating = rating_tag.get_text() if rating_tag else "未找到评分"

    # 6. 打印结果
    print(f"电影：{title}， 评分：{rating}")

print("爬取完成！")
```

**运行这段代码，你就能看到第一页25部电影的名称和评分了！**

---

第三步：关键技巧与概念

1. 如何找到需要的数据？（核心技能）
这是爬虫最关键的一步。你需要使用浏览器的**开发者工具（按F12）**。
- 在网页上右键点击你想爬取的内容（比如电影名），选择“检查”或“审查元素”。
- 开发者工具会高亮显示对应的HTML代码。
- 观察它的标签（如 `div`, `span`, `a`）和属性（特别是 `class` 和 `id`），然后用 `find` 或 `find_all` 来定位。

 2. 处理动态加载的内容（Ajax）
有些网站（如淘宝、微博）的内容是通过JavaScript动态加载的，直接用 `requests.get()` 得到的HTML里没有这些内容。这时你有两个选择：

- **方案A：找Ajax接口**
    - 按F12打开“网络(Network)”选项卡。
    - 刷新页面，筛选XHR或JS类型的请求。
    - 找到真正包含数据的请求，这个接口返回的往往是JSON格式，直接用 `requests` 请求这个接口会更简单。

- **方案B：使用Selenium**
    - `Selenium` 是一个自动化测试工具，可以模拟真实浏览器操作（点击、滚动等）。
    - 它能等到JavaScript执行完毕后再获取页面内容，但速度较慢。
    ```python
    from selenium import webdriver
    driver = webdriver.Chrome()  # 需要先下载ChromeDriver
    driver.get(url)
    page_source = driver.page_source  # 此时已包含动态加载的内容
    # ... 然后用BeautifulSoup解析page_source
    driver.quit()
    ```

3. 遵守规则，做“好人”
- **查看 `robots.txt`**：访问 `网站域名/robots.txt`（如 `https://www.douban.com/robots.txt`），看网站允许爬虫爬取哪些内容。
- **设置延迟**：在请求之间使用 `time.sleep(1)` 暂停一下，减轻服务器压力。
- **识别反爬虫机制**：常见的反爬措施有：
    - **User-Agent检查**：我们上面已经通过添加 `headers` 解决了。
    - **IP频率限制**：同一个IP短时间请求太多次会被封。解决方法：使用代理IP池。
    - **验证码**：复杂情况下需要接入打码平台或使用机器学习识别。

---

第四步：进阶学习路径

1.  **爬取多页数据**：分析翻页URL规律（如 `?start=25`），用循环遍历所有页面。
2.  **保存数据**：将结果保存到文件。
    - **CSV文件**：使用内置的 `csv` 模块。
    - **JSON文件**：使用 `json` 模块。
    - **数据库**：学习使用 `sqlite3`（轻量级）或 `pymysql`/`pymongo` 连接数据库。
3.  **使用Scrapy框架**：当项目变得庞大复杂时，`Scrapy` 是一个专业的爬虫框架，它提供了强大的异步处理、管道、中间件等功能，效率远高于手动编写。
4.  **学习正则表达式**：有时用正则表达式提取数据更灵活，可以配合 `re` 模块使用。

总结

| 步骤 | 核心操作 | 常用工具 |
| **1. 获取页面** | 发送HTTP请求 | `requests`， `selenium` |
| **2. 解析页面** | 从HTML/JSON中提取数据 | `BeautifulSoup`， `lxml`， `json` |
| **3. 存储数据** | 保存到文件或数据库 | `csv`， `json`， `pymysql` |

**给你的建议：**
从简单的静态网站（如豆瓣、知乎、新闻网站）开始练习，熟练掌握 `requests` + `BeautifulSoup` 这套组合拳。然后逐步挑战有动态内容、有反爬机制的网站。

祝你爬虫之旅愉快！记得要负责任地使用爬虫，尊重网站的规定。

一、签证与入境

1. 签证政策
   • 中国公民需提前通过日本驻华使领馆指定的代办机构申请旅游签证日本国驻华大使馆。2025 年春季起，日本对中国游客放宽签证政策，包括设立 10 年多次旅游签证、延长团队游停留天数至 30 天等，具体申请条件可咨询代办机构。
   • 入境时需填写海关申报单（可提前在网上下载模板），避免携带肉类、水果、植物等违禁品，如实申报药品和贵重物品中国领事服务网。
2. 健康与疫苗
   • 日本已取消所有入境防疫限制，无需提供疫苗接种证明或核酸阴性报告。建议提前接种常规疫苗（如流感、麻疹），并携带常用药品（如感冒药、肠胃药）。

二、交通出行

1. 交通规则
   • 日本车辆靠左行驶，过马路需注意右侧来车。东京地铁 “左站右行”，大阪则 “左行右站”，但近年部分地区呼吁减少行走以确保安全，建议留意当地标识。
   • 铁路道口复杂，通过时务必确认安全，切勿在道口内停留中国领事服务网。
2. 交通卡推荐
   • Suica/Pasmo：覆盖东京、大阪等主要城市的地铁、JR 和便利店消费。2025 年 3 月起恢复销售，需支付 500 日元押金（可退）东日本旅客铁道株式会社。
   • ICOCA：适用于关西地区，与 Suica 通用。

三、文化与礼仪

1. 基本礼仪
   • 脱鞋文化：进入日式旅馆、寺庙、部分餐厅需脱鞋，注意保持袜子整洁。
   • 鞠躬问候：初次见面以鞠躬代替握手，弯腰程度视场合而定（一般 15°-30°）。
   • 公共场合：电车内禁止大声喧哗或打电话，手机调至静音；排队时保持间距，避免拥挤日本国家旅游局。
2. 饮食礼仪
   • 用餐前说 “いただきます”（Itadakimasu），餐后说 “ごちそうさまでした”（Gochisousama deshita）。吃面时可发出声音，表示对食物的喜爱。
   • 寿司可用手或筷子取食，避免将米饭直接蘸酱油；高档餐厅需注意礼仪细节。
3. 垃圾分类
   • 日本垃圾分类严格，常见分为可燃垃圾（如厨余、纸张）、不可燃垃圾（如塑料、玻璃）、资源垃圾（如瓶罐、衣物）等。部分地区需在指定日期投放，建议提前向酒店或民宿咨询。
   • 丢弃大件垃圾（如行李箱）需购买 “粗大垃圾处理券”，或联系回收公司。

四、安全与应急

1. 紧急电话
   • 110（警察）、119（消防 / 急救）、118（海上事故）。中文报警可拨打 + 81-3-3501-0110中国领事服务网。
   • 外交部全球领事保护与服务应急热线：+86-10-12308。
2. 安全提示
   • 避免深夜单独出行，远离游行、示威等人群聚集区域中国领事服务网。
   • 参与登山、潜水等高风险活动前，确认天气和安全措施，购买旅游保险中国领事服务网。
   • 保管好护照、现金等贵重物品，随身携带复印件以备查验中国领事服务网。

五、住宿与餐饮

1. 住宿选择
   • 酒店和民宿需提前预订，旺季（樱花季、红叶季）房源紧张。日式旅馆（Ryokan）提供榻榻米和温泉，需注意入浴礼仪（如先冲洗身体再泡汤）。
   • 部分民宿或酒店要求严格的入住 / 退房时间，建议提前沟通。
2. 饮食过敏
   • 日本常见过敏原为虾、蟹、小麦、鸡蛋、牛奶等，点餐时可使用 “食物过敏沟通卡”（可提前打印），或要求查看菜单成分标注。
   • 餐厅通常不接受外带食物，剩菜可能被视为不礼貌。

六、消费与支付

1. 货币与汇率
   • 日本流通日元（JPY），建议提前在国内兑换，部分小店和自动贩卖机仅接受现金。大城市商场、便利店可使用信用卡或移动支付（如 Suica、PayPay）东日本旅客铁道株式会社。
2. 消费税与退税
   • 消费税为 10%，部分商品（如化妆品、家电）可在标有 “免税” 的商店退税（需满足最低消费金额）。退税时需出示护照，部分商店收取手续费。

七、其他实用信息

1. 语言与沟通
   • 日语为主要语言，大城市酒店、景点和交通枢纽的工作人员基本能用英语交流。建议下载翻译 APP（如 Google 翻译），并学习简单问候语（如 “こんにちは” 你好、“ありがとう” 谢谢）。
2. 电器与网络
   • 日本电压为 100V，插头为 A 型（两脚扁插），建议携带转换插头。部分酒店提供免费 WiFi，或购买预付费 SIM 卡（如 Docomo、SoftBank）。
3. 购物与礼仪
   • 购物时避免触摸未明确允许的商品，尤其是古董或工艺品日本国家旅游局。
   • 议价文化不普遍，但部分市场（如大阪黑门市场）可尝试礼貌询问价格。

出发前准备清单

• 证件：护照（有效期 6 个月以上）、签证、往返机票、酒店预订单。
• 物品：轻便行李、舒适鞋子、防晒用品、折叠伞、转换插头、充电宝。
• 其他：交通卡、适量日元现金、旅游保险单、紧急联系方式。

一、开发阶段：构建优质产品基础
注册与开发准备‌
申请小程序账号并获取AppID，安装微信开发者工具创建项目。建议选择微信云开发模式，可快速实现数据库、存储和云函数等后端能力。
核心技术规范‌
配置服务器域名（HTTPS请求、WebSocket等）
遵守内容审核规则，避免名称/简介侵权或含敏感词
优化首屏加载速度，压缩资源文件体积

二、流量获取策略：全域触达网络
搜索优化‌
名称含核心关键词（如“宠物美容|专业护理”）
简介前30字突出服务亮点，匹配用户搜索习惯
社交裂变设计‌
拼团、分销等玩法（参考连咖啡“拼团免费喝”模式）
分享奖励机制（如瑞幸咖啡“邀请得20元券”）
跨平台引流‌
抖音通过外链跳转小程序（需配置合规跳转链接）
公众号关联导流，图文插入小程序卡片

三、运营提升：用户留存与转化
会员体系搭建‌
成长等级+专属权益（如华住酒店小程序复购率提升40%）
内容社区运营‌
UGC内容激励（小红书式种草笔记+商城联动）
数据驱动优化‌
分析用户路径（热图工具追踪点击行为）
A/B测试不同页面版本提升转化率

四、成功案例参考
Tiffany AR试戴‌：通过虚拟试戴技术提升购买转化
蘑菇街直播电商‌：“社交+直播”模式单月新增用户300万
腾讯乘车码‌：LBS服务+实时公交信息打造高频工具

关键提醒‌：避免违反微信政策，如滥用关键词或诱导分享。新注册小程序有30天搜索观察期，需持续优化服务质量。

实现步骤：

1. 在首页的合适位置（通常是页面右下角）添加一个按钮。
2. 设置按钮的样式，使其固定在页面右下角，并默认隐藏。
3. 监听页面滚动事件，当滚动距离超过一定值时显示按钮，否则隐藏。
4. 为按钮添加点击事件，点击时平滑滚动到页面顶部。

注意：由于是App，我们可能需要考虑使用React Native或原生开发，但问题描述中提到了“app的首页”，且没有明确是原生还是跨平台。
由于问题是用中文提出的，且没有指定技术栈，我将提供一种通用的Web前端实现（假设是混合开发或WebApp）。如果是原生开发，则实现方式会有所不同。

以下是一个基于Web前端的实现示例（使用HTML、CSS和JavaScript）：

App首页顶部效果设计

我将为您设计一个现代、响应式的App首页顶部效果，包含导航栏、搜索功能和用户信息。

设计思路

• 使用固定定位的顶部导航栏，确保随时可访问
• 添加渐变背景和微妙阴影提升视觉效果
• 整合搜索功能和用户快捷操作
• 确保在各种屏幕尺寸上的响应式表现

实现代码

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>App首页 - 顶部设计</title>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }
    body {
        background-color: #f8f9fa;
        color: #333;
        line-height: 1.6;
        padding-top: 80px; /* 为固定顶部栏留出空间 */
    }

    /* 顶部导航栏样式 */
    .top-nav {
        position: fixed;
        top: 0;
        left: 0;
        width: 100%;
        background: linear-gradient(135deg, #6a11cb 0%, #2575fc 100%);
        color: white;
        padding: 15px 20px;
        display: flex;
        justify-content: space-between;
        align-items: center;
        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
        z-index: 1000;
        transition: all 0.3s ease;
    }

    /* 导航栏滚动效果 */
    .top-nav.scrolled {
        padding: 10px 20px;
        background: rgba(106, 17, 203, 0.95);
        backdrop-filter: blur(10px);
    }

    /* Logo样式 */
    .logo {
        display: flex;
        align-items: center;
        font-weight: 700;
        font-size: 1.5rem;
    }

    .logo i {
        margin-right: 10px;
        font-size: 1.8rem;
    }

    /* 搜索框样式 */
    .search-container {
        flex: 1;
        max-width: 500px;
        margin: 0 20px;
        position: relative;
    }

    .search-box {
        width: 100%;
        padding: 10px 15px 10px 40px;
        border: none;
        border-radius: 50px;
        background: rgba(255, 255, 255, 0.15);
        color: white;
        transition: all 0.3s ease;
    }

    .search-box:focus {
        outline: none;
        background: rgba(255, 255, 255, 0.25);
    }

    .search-box::placeholder {
        color: rgba(255, 255, 255, 0.7);
    }

    .search-icon {
        position: absolute;
        left: 15px;
        top: 50%;
        transform: translateY(-50%);
        color: rgba(255, 255, 255, 0.7);
    }

    /* 用户操作区样式 */
    .user-actions {
        display: flex;
        align-items: center;
    }

    .action-btn {
        background: transparent;
        border: none;
        color: white;
        font-size: 1.2rem;
        margin-left: 15px;
        cursor: pointer;
        position: relative;
        transition: all 0.3s ease;
    }

    .action-btn:hover {
        transform: translateY(-2px);
    }

    .notification-badge {
        position: absolute;
        top: -5px;
        right: -5px;
        background: #ff4757;
        color: white;
        font-size: 0.7rem;
        width: 18px;
        height: 18px;
        border-radius: 50%;
        display: flex;
        justify-content: center;
        align-items: center;
    }

    .user-avatar {
        width: 40px;
        height: 40px;
        border-radius: 50%;
        margin-left: 15px;
        cursor: pointer;
        border: 2px solid rgba(255, 255, 255, 0.3);
        transition: all 0.3s ease;
    }

    .user-avatar:hover {
        border-color: white;
    }

    /* 主内容区域样式 */
    .content {
        max-width: 1200px;
        margin: 0 auto;
        padding: 20px;
    }

    .section {
        background: white;
        border-radius: 12px;
        padding: 25px;
        margin-bottom: 25px;
        box-shadow: 0 5px 15px rgba(0, 0, 0, 0.05);
    }

    .section h2 {
        margin-bottom: 15px;
        color: #2d3436;
    }

    .card-container {
        display: grid;
        grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
        gap: 20px;
        margin-top: 20px;
    }

    .card {
        background: #f8f9fa;
        border-radius: 10px;
        overflow: hidden;
        transition: transform 0.3s ease;
    }

    .card:hover {
        transform: translateY(-5px);
    }

    .card-img {
        height: 160px;
        background: linear-gradient(45deg, #74ebd5, #9face6);
        display: flex;
        justify-content: center;
        align-items: center;
        color: white;
        font-size: 3rem;
    }

    .card-content {
        padding: 15px;
    }

    /* 响应式设计 */
    @media (max-width: 768px) {
        .search-container {
            display: none;
        }

        .top-nav {
            padding: 12px 15px;
        }

        .logo span {
            display: none;
        }
    }

    /* 汉堡菜单 */
    .menu-toggle {
        display: none;
        background: transparent;
        border: none;
        color: white;
        font-size: 1.5rem;
        cursor: pointer;
    }

    @media (max-width: 576px) {
        .menu-toggle {
            display: block;
        }

        .action-btn:nth-child(2),
        .action-btn:nth-child(3) {
            display: none;
        }
    }
</style>

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>App首页 - 顶部设计</title>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
        }
    body {
        background-color: #f8f9fa;
        color: #333;
        line-height: 1.6;
        padding-top: 80px; /* 为固定顶部栏留出空间 */
    }

    /* 顶部导航栏样式 */
    .top-nav {
        position: fixed;
        top: 0;
        left: 0;
        width: 100%;
        background: linear-gradient(135deg, #6a11cb 0%, #2575fc 100%);
        color: white;
        padding: 15px 20px;
        display: flex;
        justify-content: space-between;
        align-items: center;
        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
        z-index: 1000;
        transition: all 0.3s ease;
    }

    /* 导航栏滚动效果 */
    .top-nav.scrolled {
        padding: 10px 20px;
        background: rgba(106, 17, 203, 0.95);
        backdrop-filter: blur(10px);
    }

    /* Logo样式 */
    .logo {
        display: flex;
        align-items: center;
        font-weight: 700;
        font-size: 1.5rem;
    }

    .logo i {
        margin-right: 10px;
        font-size: 1.8rem;
    }

    /* 搜索框样式 */
    .search-container {
        flex: 1;
        max-width: 500px;
        margin: 0 20px;
        position: relative;
    }

    .search-box {
        width: 100%;
        padding: 10px 15px 10px 40px;
        border: none;
        border-radius: 50px;
        background: rgba(255, 255, 255, 0.15);
        color: white;
        transition: all 0.3s ease;
    }

    .search-box:focus {
        outline: none;
        background: rgba(255, 255, 255, 0.25);
    }

    .search-box::placeholder {
        color: rgba(255, 255, 255, 0.7);
    }

    .search-icon {
        position: absolute;
        left: 15px;
        top: 50%;
        transform: translateY(-50%);
        color: rgba(255, 255, 255, 0.7);
    }

    /* 用户操作区样式 */
    .user-actions {
        display: flex;
        align-items: center;
    }

    .action-btn {
        background: transparent;
        border: none;
        color: white;
        font-size: 1.2rem;
        margin-left: 15px;
        cursor: pointer;
        position: relative;
        transition: all 0.3s ease;
    }

    .action-btn:hover {
        transform: translateY(-2px);
    }

    .notification-badge {
        position: absolute;
        top: -5px;
        right: -5px;
        background: #ff4757;
        color: white;
        font-size: 0.7rem;
        width: 18px;
        height: 18px;
        border-radius: 50%;
        display: flex;
        justify-content: center;
        align-items: center;
    }

    .user-avatar {
        width: 40px;
        height: 40px;
        border-radius: 50%;
        margin-left: 15px;
        cursor: pointer;
        border: 2px solid rgba(255, 255, 255, 0.3);
        transition: all 0.3s ease;
    }

    .user-avatar:hover {
        border-color: white;
    }

    /* 主内容区域样式 */
    .content {
        max-width: 1200px;
        margin: 0 auto;
        padding: 20px;
    }

    .section {
        background: white;
        border-radius: 12px;
        padding: 25px;
        margin-bottom: 25px;
        box-shadow: 0 5px 15px rgba(0, 0, 0, 0.05);
    }

    .section h2 {
        margin-bottom: 15px;
        color: #2d3436;
    }

    .card-container {
        display: grid;
        grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
        gap: 20px;
        margin-top: 20px;
    }

    .card {
        background: #f8f9fa;
        border-radius: 10px;
        overflow: hidden;
        transition: transform 0.3s ease;
    }

    .card:hover {
        transform: translateY(-5px);
    }

    .card-img {
        height: 160px;
        background: linear-gradient(45deg, #74ebd5, #9face6);
        display: flex;
        justify-content: center;
        align-items: center;
        color: white;
        font-size: 3rem;
    }

    .card-content {
        padding: 15px;
    }

    /* 响应式设计 */
    @media (max-width: 768px) {
        .search-container {
            display: none;
        }

        .top-nav {
            padding: 12px 15px;
        }

        .logo span {
            display: none;
        }
    }

    /* 汉堡菜单 */
    .menu-toggle {
        display: none;
        background: transparent;
        border: none;
        color: white;
        font-size: 1.5rem;
        cursor: pointer;
    }

    @media (max-width: 576px) {
        .menu-toggle {
            display: block;
        }

        .action-btn:nth-child(2),
        .action-btn:nth-child(3) {
            display: none;
        }
    }
</style>

设计特点

1. 固定定位导航栏 - 始终保持在页面顶部，方便用户随时访问
2. 渐变背景 - 使用现代渐变色提升视觉吸引力
3. 响应式设计 - 在小屏幕设备上自动调整布局
4. 功能性元素 - 包含搜索框、通知徽章和用户菜单
5. 滚动效果 - 页面滚动时导航栏有微妙的变化效果
6. 卡片式布局 - 内容区域使用卡片设计，增强可读性和交互性

这个设计既美观又实用，可以根据您的品牌颜色和需求进一步调整样式。

以下是完整操作流程，适合新手快速上手：

1. 准备工作

• 服务器要求：已安装宝塔面板（Linux系统，推荐 CentOS 7+/Ubuntu 18+）
• 静态网页文件：HTML/CSS/JS 等资源（确保入口文件为 index.html）
• 域名（可选）：若需绑定域名，提前完成域名解析（A记录指向服务器IP）

2. 登录宝塔面板

• 访问地址：http://你的服务器IP:8888
• 输入安装宝塔时生成的用户名和密码（若遗忘，SSH执行 bt default 查看）

3. 创建网站

1. 点击左侧菜单 【网站】→【添加站点】
2. 填写信息：
   • 域名：填写你的域名（无域名可直接填服务器IP）
   • 根目录：默认 /www/wwwroot/你的域名（可自定义）
   • PHP版本：选择 纯静态（无需PHP支持）
   • 取消勾选 FTP 和 数据库（静态网页无需）
   • 点击 提交

(截图仅为示意，实际界面可能略有不同)

4. 上传网页文件

• 方法1：宝塔文件管理器

  1. 进入 【文件】→ 找到站点根目录（如 /www/wwwroot/your-domain.com）
  2. 删除默认的 index.html（如有）
  3. 点击 【上传】 按钮，拖入你的静态网页文件
  4. 确保入口文件命名为 index.html

• 方法2：FTP工具

  1. 宝塔面板创建FTP账号：【FTP】→【添加FTP】
  2. 使用 FileZilla/WinSCP 连接服务器（端口21）
  3. 上传文件到站点根目录

• 方法3：SSH命令（推荐高效）

  # 压缩本地文件为 zip
  zip -r site.zip *
  
  # 上传到服务器（替换IP和路径）
  scp site.zip root@服务器IP:/www/wwwroot/your-domain.com/
  
  # SSH登录服务器解压
  unzip site.zip -d /www/wwwroot/your-domain.com/

5. 配置访问权限

• 检查文件权限：
  1. 进入文件管理器，选中所有文件
  2. 点击 【权限】，设置为：
     • 权限：755（目录） / 644（文件）
     • 所有者：www

6. 测试访问

• 浏览器打开：http://你的域名 或 http://服务器IP
• 若显示空白/403错误：
  • 确认根目录存在 index.html
  • 检查文件权限是否正确
  • 清除浏览器缓存或使用无痕模式

7. 进阶配置（可选）

• HTTPS 证书：

  1. 点击站点右侧 【SSL】
  2. 选择 Let's Encrypt，勾选域名→申请证书→开启强制HTTPS

• 自定义错误页面：

  1. 在根目录创建 404.html
  2. 宝塔面板：【站点设置】→【配置文件】 中添加：

     error_page 404 /404.html;

• CDN加速：

  • 推荐使用 Cloudflare 或腾讯云CDN，提升访问速度。

常见问题解决

提示：

• 若需绑定多个域名，在站点设置中 【域名管理】 添加。
• 网站流量较大时，开启宝塔 【静态缓存】（Nginx环境）可显著提升性能。

按照以上步骤操作，10分钟内即可完成部署！如有疑问，可查看宝塔官方文档或社区支持。

1. 创建 Google Cloud 项目并启用翻译 API

1. 登录 Google Cloud Console
   访问 https://console.cloud.google.com/，使用 Google 账号登录。
2. 创建新项目
   • 点击顶部导航栏的项目下拉菜单 → 新建项目。
   • 填写项目名称（如 translation-demo），点击 创建。
3. 启用翻译 API
   • 搜索并进入 翻译 API 页面。
   • 点击 启用。

2. 创建 API 凭证

1. 进入凭证页面
   • 左侧导航栏 → API 和服务 → 凭证。
   • 点击 创建凭证 → API 密钥。
2. 保存 API 密钥
   • 系统会生成一串密钥（如 AIzaSyDtxXxxXxXxXxXxXxXxXxXxXxXxXxX），立即复制并妥善保管（密钥只会显示一次）。

3. 代码实现（以 Python 为例）

以下是使用 Python 调用 Google 翻译 API 的示例代码：

python

运行

import os
import requests

# 设置 API 密钥（建议使用环境变量，而非硬编码）
os.environ["GOOGLE_API_KEY"] = "你的_API_密钥"
API_KEY = os.environ["GOOGLE_API_KEY"]
API_URL = "https://translation.googleapis.com/language/translate/v2"

def translate_text(text, target_language="zh-CN", source_language="auto"):
    """调用 Google 翻译 API 翻译文本"""
    try:
        # 构建请求参数
        params = {
            "key": API_KEY,
            "q": text,
            "target": target_language,
            "source": source_language,
            "format": "text"
        }

        # 发送 POST 请求
        response = requests.post(API_URL, data=params)
        result = response.json()

        # 检查响应状态
        if response.status_code == 200 and "data" in result:
            translated_text = result["data"]["translations"][0]["translatedText"]
            return translated_text
        else:
            error_msg = result.get("error", {}).get("message", "未知错误")
            raise Exception(f"翻译失败: {error_msg}")

    except Exception as e:
        print(f"请求出错: {e}")
        return None

# 示例用法
if __name__ == "__main__":
    text_to_translate = "Hello, world!"
    translation = translate_text(text_to_translate, target_language="zh-CN")
    print(f"原文: {text_to_translate}")
    print(f"译文: {translation}")

4. 关键参数说明

• API 密钥：通过环境变量 GOOGLE_API_KEY 传递，避免硬编码。
• 目标语言（target_language）：ISO 639-1 代码（如 zh-CN 表示中文简体）。
• 源语言（source_language）：默认为 auto（自动检测）。

5. 注意事项

1. 安全建议
   • 不要在公开代码或前端暴露 API 密钥，建议在后端服务中调用 API。
   • 使用 Google Cloud 的 IAM 权限管理 限制 API 访问范围。
2. 计费
   • Google 翻译 API 按字符计费（定价详情），免费额度为每月 50 万字符。
   • 启用 预算警报 避免意外费用。
3. 错误处理
   • API 可能返回 403 Forbidden（密钥无效）、429 Too Many Requests（超出配额）等错误，需在代码中处理。

6. 其他语言实现

如果你需要其他编程语言（如 Java、JavaScript）的实现，可以参考 Google 官方文档：
https://cloud.google.com/translate/docs/quickstarts

通过以上步骤，你可以成功对接 Google 翻译 API 并实现文本翻译功能。

一、连接失败（错误代码 2003/1005）

现象：
Can't connect to MySQL server on 'xxx.xxx.xxx.xxx' (2003) 或超时。

可能原因：

1. MySQL 服务未启动。
2. 端口被防火墙/安全组拦截。
3. IP 或端口配置错误。

解决办法：

1. 检查 MySQL 服务状态：

   # Windows
   net start mysql
   # Linux
   systemctl status mysqld

2. 确认端口开放：
   • 默认端口为 3306，检查是否被修改（如 my.cnf 中的 port 配置）。
   • 开放防火墙端口：

     # Linux
     ufw allow 3306
     # Windows 防火墙设置中添加入站规则

3. 验证连接信息：
   • 确保输入的 IP、端口正确。远程连接时需使用公网 IP，而非 localhost 或 127.0.0.1。

二、身份验证错误（错误代码 1045/2059）

现象：
Access denied for user 'xxx'@'xxx' (using password: YES) 或 Authentication plugin 'caching_sha2_password' 报错。

可能原因：

1. 密码错误或用户权限不足。
2. MySQL 8.0+ 默认使用 caching_sha2_password 插件，旧版 Navicat 不支持。

解决办法：

1. 重置密码或授权用户：

   -- 修改密码
   ALTER USER '用户名'@'主机名' IDENTIFIED BY '新密码';
   -- 授予远程访问权限（示例）
   GRANT ALL PRIVILEGES ON *.* TO '用户名'@'%' WITH GRANT OPTION;
   FLUSH PRIVILEGES;

2. 兼容身份验证插件：
   • 升级 Navicat 至 v12+ 以支持新插件。
   • 修改 MySQL 用户插件（需谨慎，降低安全性）：

     ALTER USER '用户名'@'主机名' IDENTIFIED WITH mysql_native_password BY '密码';

三、远程连接被拒绝

现象：
仅能本地连接，远程无法访问。

可能原因：

1. MySQL 未绑定公网 IP 或禁止远程访问。
2. 用户权限限制为 localhost。

解决办法：

1. 修改 MySQL 绑定地址：编辑 my.cnf/my.ini，将 bind-address = 127.0.0.1 改为 0.0.0.0 或注释此行。
2. 创建远程访问用户：

   CREATE USER '用户名'@'%' IDENTIFIED BY '密码';
   GRANT ALL PRIVILEGES ON 数据库名.* TO '用户名'@'%';
   FLUSH PRIVILEGES;

四、SSL 连接问题（错误代码 2026）

现象：
SSL connection error: SSL_CTX_set_tmp_dh failed。

可能原因：
Navicat 启用了 SSL 但服务器未正确配置。

解决办法：

1. 临时关闭 SSL（不推荐长期使用）：
   • 在 Navicat 连接设置中取消勾选 SSL 选项卡。
2. 正确配置 SSL 证书：
   • 在 MySQL 服务器生成证书，并在 Navicat 中配置 CA、证书和密钥路径。

五、其他常见问题

1. 连接超时

• 检查网络是否稳定。
• 在 Navicat 的“高级”设置中增大 连接超时 和 执行超时 时间。

2. 客户端版本兼容性

• 确保 Navicat 版本与 MySQL 版本兼容（如 MySQL 8.0+ 需 Navicat 12+）。

3. 配置文件错误

• 检查 my.cnf 中是否误启用 skip-networking（会禁用 TCP/IP 连接）。

六、通用排查步骤

1. 查看 MySQL 日志：

   # 日志路径通常为 /var/log/mysql/error.log 或通过以下命令查看
   SHOW VARIABLES LIKE 'log_error';

2. 使用命令行测试连接：

   mysql -u 用户名 -h 服务器IP -P 端口 -p

3. 逐步验证配置：
   • 服务状态 → 用户权限 → 网络/防火墙 → SSL 设置 → 客户端版本。

通过以上步骤，可覆盖 Navicat 连接 MySQL 的大部分问题。若仍无法解决，建议提供具体的错误信息进一步分析。

一、准备工作

1. 安装 Navicat前往官网下载对应版本并安装：https://www.navicat.com

2. 获取数据库信息

   • 数据库类型（如 MySQL、PostgreSQL 等）
   • 主机名/IP 地址（如 localhost 或 127.0.0.1）
   • 端口号（默认端口参考下方具体数据库）
   • 用户名和密码
   • 数据库名称（部分数据库需要）

二、连接不同数据库的具体步骤

1. 连接 MySQL/MariaDB

• 默认端口：3306
• 步骤：
  1. 点击左上角 连接 → 选择 MySQL。
  2. 填写信息：
     • 连接名：自定义（如 MyLocalDB）
     • 主机/IP：localhost（本地）或服务器 IP
     • 端口：3306
     • 用户名/密码：数据库账号密码
  3. 测试连接 → 成功 → 点击 确定。

2. 连接 PostgreSQL

• 默认端口：5432
• 步骤：
  1. 点击 连接 → 选择 PostgreSQL。
  2. 填写信息：
     • 主机：localhost 或服务器 IP
     • 端口：5432
     • 初始数据库：可选（如 postgres）
     • 用户名/密码：数据库账号密码
  3. 高级选项中可设置 SSL 或 SSH（按需配置）。

3. 连接 SQL Server

• 默认端口：1433
• 步骤：
  1. 点击 连接 → 选择 SQL Server。
  2. 填写信息：
     • 主机：localhost 或服务器 IP
     • 身份验证：SQL Server 身份验证 或 Windows 身份验证
     • 用户名/密码：数据库账号密码（SQL Server 身份验证时）
     • 数据库：可选（可连接后选择）
  3. 高级选项中可配置连接超时等参数。

4. 连接 Oracle

• 默认端口：1521
• 步骤：
  1. 点击 连接 → 选择 Oracle。
  2. 填写信息：
     • 主机：localhost 或服务器 IP
     • 端口：1521
     • 服务名/SID：根据 Oracle 配置填写（如 ORCL）
     • 用户名/密码：数据库账号密码
  3. 测试连接 → 确认是否需配置 Oracle 客户端。

5. 连接 SQLite

• 无需网络和端口，直接操作本地文件。
• 步骤：
  1. 点击 连接 → 选择 SQLite。
  2. 点击 数据库文件 右侧的 ... → 选择本地 SQLite 文件（如 .db 或 .sqlite）。
  3. 点击 确定 完成连接。

三、高级配置（按需）

1. SSH 隧道连接

若数据库通过 SSH 跳板机访问：

1. 在连接设置中切换到 SSH 选项卡。
2. 勾选 使用 SSH 通道。
3. 填写 SSH 主机、端口、用户名及认证方式（密码或私钥文件）。

2. SSL 加密连接

部分数据库支持 SSL 加密传输：

1. 在连接设置中切换到 SSL 选项卡。
2. 勾选 使用 SSL。
3. 上传 CA 证书、客户端证书和密钥（根据数据库配置）。

四、常见问题解决

1. 连接失败

   • 检查网络是否通畅（如 telnet IP 端口）。
   • 确认数据库服务已启动。
   • 检查防火墙是否放行端口。
   • 核对用户名/密码是否正确。

2. Navicat 报错 "Access denied"

   • 确保数据库用户允许从当前 IP 连接（如 MySQL 需配置 GRANT 权限）。

3. Oracle 连接报错 "ORA-12541"

   • 确认 Oracle 监听服务已启动。

4. SQL Server 无法连接

   • 启用 SQL Server 的 TCP/IP 协议（通过 SQL Server 配置管理器）。

五、总结

1. 根据数据库类型选择对应的连接方式。
2. 确保主机、端口、账号密码正确。
3. 复杂环境需配置 SSH 或 SSL。
4. 通过 测试连接 功能快速验证配置。

遇到问题可查阅 Navicat 日志（菜单栏 帮助 → 日志文件）或联系数据库管理员。

一、核心工具与库

1. HTTP请求库

   • Requests：简洁易用的HTTP库，处理接口请求

   import requests
   response = requests.get("https://api.example.com/data")

2. 测试框架

   • unittest：Python内置单元测试框架
   • pytest：更灵活的测试框架，支持参数化和插件

   # pytest示例
   def test_api_status_code():
      response = requests.get("https://api.example.com/health")
      assert response.status_code == 200

3. 数据驱动测试

   • ddt (Data-Driven Tests) 或 pytest参数化

   # pytest参数化
   import pytest
   @pytest.mark.parametrize("user_id, expected_code", [(1, 200), (999, 404)])
   def test_get_user(user_id, expected_code):
      response = requests.get(f"https://api.example.com/users/{user_id}")
      assert response.status_code == expected_code

4. 测试报告

   • Allure：生成美观的HTML报告
   • HTMLTestRunner：传统HTML报告生成器

二、接口自动化测试框架设计

1. 目录结构

project/
├── config/           # 配置文件
│   └── settings.py
├── testcases/        # 测试用例
│   └── test_api.py
├── utils/            # 工具类
│   ├── logger.py     # 日志管理
│   └── request_util.py  # 封装Requests
├── data/             # 测试数据（JSON/YAML）
├── reports/          # 测试报告
└── conftest.py       # pytest全局配置

2. 封装请求工具

# utils/request_util.py
import requests

class RequestUtil:
    def __init__(self, base_url="https://api.example.com"):
        self.base_url = base_url
        self.session = requests.Session()

    def send_request(self, method, endpoint, params=None, data=None, headers=None):
        url = f"{self.base_url}/{endpoint}"
        response = self.session.request(method, url, params=params, json=data, headers=headers)
        response.raise_for_status()  # 自动抛出HTTP错误
        return response.json()

三、实战案例：用户登录与数据查询

1. 编写测试用例

# testcases/test_user_api.py
import pytest
from utils.request_util import RequestUtil

@pytest.fixture(scope="module")
def api_client():
    return RequestUtil(base_url="https://api.example.com")

def test_login(api_client):
    """测试登录获取Token"""
    payload = {"username": "testuser", "password": "securepass"}
    response = api_client.send_request("POST", "login", data=payload)
    assert "token" in response
    return response["token"]

@pytest.mark.usefixtures("test_login")
def test_get_user_profile(api_client, test_login):
    """测试获取用户信息"""
    headers = {"Authorization": f"Bearer {test_login}"}
    response = api_client.send_request("GET", "user/profile", headers=headers)
    assert response["username"] == "testuser"
    assert "email" in response

2. 执行测试

# 运行测试并生成Allure报告
pytest testcases/ --alluredir=./reports
allure serve ./reports

四、最佳实践

1. 环境隔离

   • 使用 pytest-base-url管理不同环境（开发/测试/生产）

   pytest --base-url https://dev-api.example.com

2. 数据管理

   • 使用YAML/JSON文件存储测试数据

   # data/login_cases.yaml
   - case: valid_login
    input: {username: "user1", password: "Pass123"}
    expected: {status: 200, has_token: true}
   - case: wrong_password
    input: {username: "user1", password: "wrong"}
    expected: {status: 401}

3. 认证处理

   • 自动处理Token刷新（通过 pytest fixture）

   @pytest.fixture(scope="session")
   def auth_token(api_client):
      # 获取并缓存Token
      return api_client.login()

4. 异常处理

   • 捕获并记录接口异常

   def send_request(self, method, endpoint, **kwargs):
      try:
          response = self.session.request(method, url, **kwargs)
          response.raise_for_status()
      except requests.exceptions.HTTPError as e:
          logger.error(f"API请求失败: {str(e)}")
          raise

五、高级技巧

1. Mock服务

   • 使用 responses或 pytest-mock模拟接口响应

   import responses
   
   @responses.activate
   def test_mock_api():
      responses.add(
          responses.GET, "https://api.example.com/data",
          json={"data": "mocked"}, status=200
      )
      response = requests.get("https://api.example.com/data")
      assert response.json()["data"] == "mocked"

2. 性能测试集成

   • 使用 locust进行简单压力测试

   from locust import HttpUser, task
   
   class ApiUser(HttpUser):
      @task
      def test_login(self):
          self.client.post("/login", json={"username":"test", "password":"test"})

六、持续集成（CI/CD）

1. GitHub Actions配置示例

   name: API Tests
   on: [push]
   jobs:
    test:
      runs-on: ubuntu-latest
      steps:
      - uses: actions/checkout@v2
      - name: Run Tests
        run: |
          pip install -r requirements.txt
          pytest --alluredir=./reports
      - name: Upload Report
        uses: actions/upload-artifact@v2
        with:
          name: allure-report
          path: ./reports

通过以上方案，你可以快速构建可维护的Python接口自动化测试框架。关键点：清晰的架构设计、数据驱动测试、合理的异常处理、与CI/CD的集成。

一、常用工具

1. Postman

   • 特点：简单易用的图形化工具，支持 REST、SOAP、GraphQL 等协议。
   • 功能：手动测试、自动化测试（Collection Runner）、Mock Server、生成测试报告。
   • 适用场景：快速调试、接口文档编写、团队协作。

2. JMeter

   • 特点：开源工具，主要用于性能测试，但也可用于接口功能测试。
   • 功能：支持 HTTP/HTTPS、FTP、JDBC 等协议，参数化、断言、分布式测试。
   • 适用场景：高并发接口测试、性能压测。

3. Swagger/OpenAPI

   • 特点：基于接口文档生成测试用例。
   • 功能：通过 YAML/JSON 定义接口规范，生成 Mock 数据或自动化测试脚本。
   • 适用场景：结合 API 文档快速验证接口规范性。

4. RestAssured（Java）

   • 特点：基于 Java 的 DSL（领域特定语言），适合代码驱动的测试。
   • 功能：支持 RESTful API 测试，集成 TestNG/JUnit，断言灵活。
   • 适用场景：自动化测试框架开发。

5. Requests（Python）

   • 特点：Python 的 HTTP 库，轻量灵活。
   • 功能：结合 pytest/unittest 实现自动化测试，支持 JSON/XML 解析。
   • 适用场景：快速编写脚本或与 CI/CD 集成。

6. SoapUI

   • 特点：专注于 SOAP 和 REST 协议，支持复杂场景测试。
   • 功能：数据驱动测试、安全测试（SQL 注入、XSS）、Mock 服务。
   • 适用场景：企业级 Web Service 测试。

7. Apifox

   • 特点：国产工具，集接口文档、Mock、测试于一体。
   • 功能：自动化测试、团队协作、多协议支持。
   • 适用场景：替代 Postman + Swagger + JMeter 的组合。

二、常用方法

1. 手动测试

   • 工具：Postman、浏览器插件（如 Talend API Tester）。
   • 步骤：输入 URL、参数、Header，发送请求并验证响应结果。

2. 自动化测试

   • 框架：RestAssured（Java）、Requests + pytest（Python）、Newman（Postman CLI）。
   • 流程：
     1. 编写测试脚本（参数化、断言）。
     2. 集成到 CI/CD（如 Jenkins、GitHub Actions）。
     3. 生成测试报告（Allure、ExtentReport）。

3. 数据驱动测试

   • 实现：通过 CSV、Excel 或数据库管理测试数据，实现多场景覆盖。
   • 示例：JMeter 的 CSV 参数化，Postman 的 Data Files。

4. 关联参数处理

   • 场景：接口依赖（如 Token、SessionID）。
   • 方法：使用正则表达式或 JSON 提取器获取变量，传递给后续请求。

5. 边界值与异常测试

   • 覆盖点：
     • 参数边界（如最大值、最小值、空值）。
     • 错误码（404、500 等）。
     • 非法输入（特殊字符、超长字符串）。

6. 性能测试

   • 工具：JMeter、LoadRunner。
   • 关注指标：响应时间、吞吐量、错误率、服务器资源占用。

7. 安全测试

   • 内容：SQL 注入、XSS、越权访问、敏感信息泄露。
   • 工具：OWASP ZAP、Burp Suite。

8. Mock 测试

   • 场景：依赖接口未完成时模拟响应。
   • 工具：Postman Mock Server、WireMock、Moco。

1. 实名认证：用户需通过支付宝或手机号实名认证，禁止冒用他人身份。
2. 一账号一主体：禁止同一用户注册多账号进行违规操作（如刷单、恶意竞争）。
3. 账号安全：妥善保管账号密码，避免外借、出租或买卖账号。

二、商品发布规范

1. 禁止售假：不得发布假冒品牌、盗版商品（如高仿奢侈品、盗版软件）。
2. 违禁品限制：严禁交易法律禁止的商品（如药品、枪支、野生动物制品、虚拟货币等）。
3. 信息真实：商品描述需真实，禁止虚假宣传、夸大功效或使用误导性图片。
4. 分类明确：商品需发布至正确类目，禁止乱挂类目（如将服务类商品挂在实物类目）。

三、交易行为规范

1. 禁止虚假交易：不得刷单、刷好评或利用技术手段伪造交易记录。
2. 合规沟通：聊天中禁止诱导用户脱离平台交易（如要求微信转账、银行卡付款）。
3. 履约责任：卖家需按约定发货，买家需及时确认收货，避免恶意退货或拖延付款。
4. 价格合理：不得哄抬价格或发布明显低于市场价的虚假信息（如“0元引流”）。

四、沟通与评价规范

1. 文明用语：禁止辱骂、骚扰、威胁他人，或发布色情、暴力内容。
2. 客观评价：禁止利用差评威胁索要财物，或虚构好评/差评。
3. 隐私保护：聊天中不得索要他人隐私信息（如身份证号、银行卡号）。

五、安全与风险提示

1. 防诈骗提醒：
   • 警惕“保证金”“解冻金”等转账骗局。
   • 交易全程使用平台担保支付，拒绝线下交易。
2. 信息保护：
   • 商品图片中避免泄露个人信息（如快递单号、家庭住址）。
   • 谨慎分享社交账号（如微信、QQ），以防引流诈骗。

六、违规处罚机制

1. 轻度违规：删除商品、限制发布、扣除信用分。
2. 重度违规：冻结账号、永久封禁、配合司法机关追责。
3. 申诉流程：对处罚有异议可通过平台客服申诉，提供证据材料。

七、其他注意事项

• 遵守法律法规：不得利用平台从事洗钱、传销等违法行为。
• 未成年人保护：未成年用户需在监护人指导下使用。
• 社会责任：禁止发布歧视性、煽动性内容或传播谣言。

1. 用户需求分析
   • 痛点挖掘：通过用户访谈、行为数据分析（如热力图、埋点）识别真实需求，例如教育类App发现用户对「错题智能分类」需求强烈。
   • 优先级排序：运用Kano模型或MoSCoW法则区分「必须功能」与「增值功能」，避免功能堆砌。
2. 信息架构设计
   • 功能模块化：采用原子设计理论拆分功能颗粒度，如电商App的「商品详情页」需集成SKU选择、AR试穿、社交分享等原子组件。
   • 流程闭环设计：确保用户路径可回溯，例如外卖App从下单到售后评价的全链路闭环。
3. 交互与体验平衡
   • 认知负荷控制：遵循「7±2法则」限制菜单层级，如微信将高频功能（支付、扫一扫）置于一级界面。
   • 情感化设计：通过微交互（如点赞动效）、空状态插画提升用户愉悦感。
4. 技术可行性验证
   • 架构选型：选择React Native或Flutter需权衡开发效率与原生性能。
   • 技术债管理：采用灰度发布策略逐步验证高风险功能。

二、设计流程演进

1. 双钻模型实践
   • 发散阶段：通过Design Sprint工作坊快速产出概念原型，如共享单车App的「无桩借还」方案验证。
   • 收敛阶段：利用A/B测试量化方案效果，某社交软件通过按钮颜色测试提升15%转化率。
2. 敏捷协作模式
   • 设计系统构建：建立如Ant Design的标准化组件库，确保跨团队协作一致性。
   • 持续交付机制：采用Figma+Jira实现设计与开发实时同步，缩短迭代周期。

三、行业趋势与挑战

1. 智能化设计工具
   • AI辅助生成UI（如Galileo AI）、自动代码转换（Figma to Code）正在重构设计工作流。
2. 全场景体验融合
   • 多端无缝衔接成为标配，如智能家居App需同时适配手机、智能屏、车载系统。
3. 伦理设计责任
   • 防沉迷系统（如《原神》45分钟强制休息）、无障碍设计（苹果VoiceOver）成为产品准入门槛。
4. 数据与隐私博弈
   • GDPR合规性设计倒逼产品重构数据采集策略，如iOS ATT框架导致广告归因模型变革。

• 语法简单：Python 的语法接近自然语言，代码可读性高，学习成本低。
• 丰富的测试框架：如 pytest（灵活强大）、unittest（Python 自带）、Robot Framework（关键字驱动）等，简化测试流程。
• 强大的生态支持：
  • Web 自动化：Selenium、Playwright、Puppeteer。
  • 接口测试：Requests、HTTPX、FastAPI TestClient。
  • 移动端测试：Appium。
  • 性能测试：Locust。
• 社区活跃：遇到问题容易找到解决方案，文档和教程丰富。

2. 学习路径建议

第一步：掌握 Python 基础

• 变量、条件语句、循环、函数、文件操作等基础语法。
• 学习使用 pip 安装和管理第三方库。

第二步：理解测试基础概念

• 测试类型：单元测试、集成测试、端到端测试（E2E）。
• 测试金字塔：优先覆盖单元测试，其次是接口测试，最后是 UI 测试。
• 断言（Assert）：验证代码行为是否符合预期。

第三步：选择一个测试框架

• 推荐 pytest：
  • 更简洁的语法（相比 unittest）。
  • 支持参数化测试、Fixture 依赖管理。
  • 丰富的插件生态（如 pytest-html 生成报告）。

第四步：实践具体场景

• Web 自动化：用 Selenium 或 Playwright 控制浏览器，模拟用户操作。
  python

  复制

  from selenium import webdriver
  driver = webdriver.Chrome()
  driver.get("https://www.example.com")
  assert "Example" in driver.title
  driver.quit()

• 接口测试：用 Requests 发送 HTTP 请求并验证响应。
  python

  复制

  import requests
  response = requests.get("https://api.example.com/data")
  assert response.status_code == 200
  assert response.json()["key"] == "value"

• 单元测试：用 pytest 测试函数逻辑。
  python

  复制

  def add(a, b):
    return a + b
  
  def test_add():
    assert add(2, 3) == 5

主要用于模拟用户操作（点击、输入、滑动等），验证界面交互功能。

常用工具

1. Selenium（主流Web UI自动化工具）
   • 支持多种浏览器（Chrome/Firefox/Edge等）
   • 支持多语言（Python/Java等）
2. PyAutoGUI（跨平台，支持桌面应用和Web）
3. Appium（移动端App自动化）

Selenium 示例

python

复制

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# 1. 启动浏览器
driver = webdriver.Chrome()  # 需下载对应版本的chromedriver并配置环境变量

# 2. 打开页面
driver.get("https://www.baidu.com")

# 3. 定位元素并操作（显式等待优化稳定性）
search_box = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, "kw"))
)
search_box.send_keys("Python自动化测试")

# 4. 点击搜索按钮
driver.find_element(By.ID, "su").click()

# 5. 验证结果
WebDriverWait(driver, 10).until(
    EC.title_contains("Python自动化测试")
)
assert "Python自动化测试" in driver.title

# 6. 关闭浏览器
driver.quit()

最佳实践

• 使用 WebDriverWait 显式等待，避免硬性等待（如 time.sleep）
• 采用 Page Object 模式（PO设计模式）分离页面元素和测试逻辑
• 结合 pytest 或 unittest 管理测试用例

二、接口自动化测试

验证API的功能、性能及数据正确性。

常用工具

1. Requests（发送HTTP请求）
2. unittest/pytest（测试框架）
3. Pytest + Requests（主流组合）
4. FastAPI/Flask Test Client（测试自身开发的API）

接口测试示例（Pytest + Requests）

python

复制

import requests
import pytest

# 定义测试用例
def test_get_api():
    url = "https://api.example.com/users/1"
    response = requests.get(url)
    assert response.status_code == 200
    assert response.json()["username"] == "test_user"

def test_post_api():
    url = "https://api.example.com/login"
    data = {"username": "admin", "password": "123456"}
    response = requests.post(url, json=data)
    assert response.status_code == 200
    assert "token" in response.json()

# 使用pytest运行测试
# 命令行执行: pytest test_api.py

增强功能

1. 参数化测试（多组输入验证）：
   python

   复制

   @pytest.mark.parametrize("user_id, expected_username", [
      (1, "user1"),
      (2, "user2"),
   ])
   def test_multiple_users(user_id, expected_username):
      response = requests.get(f"https://api.example.com/users/{user_id}")
      assert response.json()["username"] == expected_username

2. 环境配置分离（通过配置文件或 .env 管理不同环境URL）
3. 数据清理（如测试后删除测试数据）

三、进阶工具链

1. 测试报告：
   • Allure Framework：生成美观的HTML报告
   • pytest-html：简单生成测试报告
2. 持续集成（CI/CD）：
   • 集成到 Jenkins、GitHub Actions 或 GitLab CI
3. Mock 服务：
   • 使用 unittest.mock 或 pytest-mock 模拟依赖接口

四、注意事项

1. UI测试：
   • 元素定位优先使用 ID 或 XPath，避免依赖不稳定的CSS类名
   • 注意动态加载内容的等待策略
2. 接口测试：
   • 关注状态码、响应时间、数据格式和业务逻辑正确性
   • 对敏感接口添加鉴权（如Token验证）

在开始之前，先了解常见的自动化测试类型：

• 单元测试（Unit Testing）：测试代码的最小单元（如函数、类）。
• 集成测试（Integration Testing）：测试多个模块的协作。
• 端到端测试（E2E Testing）：模拟用户操作，测试完整流程（如 Web 应用、移动应用）。
• API 测试：验证 API 的请求和响应。
• 性能测试：评估系统在高负载下的表现。

2. Python 自动化测试常用框架

(1) 单元测试框架

• unittest（Python 内置）

  • 基于 JUnit 设计，支持测试用例、测试套件、断言等。
  • 示例：
    python

  复制

  import unittest
  
  def add(a, b):
      return a + b
  
  class TestMath(unittest.TestCase):
      def test_add(self):
          self.assertEqual(add(2, 3), 5)
  
  if __name__ == '__main__':
      unittest.main()

• pytest

  • 更简洁灵活，支持参数化测试、插件扩展。
  • 示例：
    python

  复制

  def add(a, b):
      return a + b
  
  def test_add():
      assert add(2, 3) == 5

  • 运行命令：pytest test_math.py

(2) Web 自动化测试

• Selenium

  • 用于浏览器自动化，支持 Chrome、Firefox 等。
  • 示例：
    python

  复制

  from selenium import webdriver
  
  driver = webdriver.Chrome()
  driver.get("https://www.google.com")
  search_box = driver.find_element("name", "q")
  search_box.send_keys("Python自动化测试")
  search_box.submit()
  driver.quit()

• Playwright（推荐）

  • 新一代浏览器自动化工具，支持多浏览器、无头模式、网络拦截等。
  • 示例：
    python

  复制

  from playwright.sync_api import sync_playwright
  
  with sync_playwright() as p:
      browser = p.chromium.launch()
      page = browser.new_page()
      page.goto("https://www.google.com")
      page.fill("input[name=q]", "Python自动化测试")
      page.press("input[name=q]", "Enter")
      browser.close()

(3) API 测试

• requests + pytest

  • 发送 HTTP 请求并验证响应。
  • 示例：
    python

  复制

  import requests
  
  def test_api_status_code():
      response = requests.get("https://api.example.com/users")
      assert response.status_code == 200

• FastAPI TestClient（针对 FastAPI 应用）

  • 示例：
    python

  复制

  from fastapi.testclient import TestClient
  from myapp.main import app
  
  client = TestClient(app)
  
  def test_read_item():
      response = client.get("/items/1")
      assert response.status_code == 200

(4) 移动端测试

• Appium
  • 支持 Android 和 iOS 应用的自动化测试。
  • 示例代码类似 Selenium。

3. 测试最佳实践

• 保持测试独立：每个测试用例不依赖其他测试结果。
• 清晰的命名：测试函数名应描述测试目标（如 test_login_with_invalid_password）。
• 数据驱动测试：使用参数化测试（如 @pytest.mark.parametrize）覆盖多组输入。
• Mock 外部依赖：使用 unittest.mock 或 pytest-mock 模拟数据库、API 调用等。
• 持续集成（CI）：将测试集成到 CI/CD 流程（如 GitHub Actions、Jenkins）。

4. 常用工具和库

• 覆盖率报告：使用 coverage 库生成代码覆盖率报告。
  • 命令：coverage run -m pytest && coverage report
• 测试报告：使用 pytest-html 生成 HTML 测试报告。
  • 命令：pytest --html=report.html
• 环境管理：用 virtualenv 或 poetry 隔离项目依赖。

5. 示例：完整的 pytest + Selenium 测试

python

复制

# test_web.py
import pytest
from selenium import webdriver

@pytest.fixture(scope="module")
def browser():
    driver = webdriver.Chrome()
    yield driver
    driver.quit()

def test_google_search(browser):
    browser.get("https://www.google.com")
    search_box = browser.find_element("name", "q")
    search_box.send_keys("Python自动化测试")
    search_box.submit()
    assert "Python自动化测试" in browser.title

运行命令：

bash

复制

pytest test_web.py -v

6. 持续集成（CI）示例

在 GitHub Actions 中配置自动化测试：

yaml

复制

# .github/workflows/tests.yml
name: Python Tests

on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: '3.9'
      - name: Install dependencies
        run: pip install -r requirements.txt
      - name: Run tests
        run: pytest

一、必游景点推荐

1. 张大千纪念馆
   • 内江是国画大师张大千的故乡，纪念馆展示了他的生平、艺术成就和珍贵作品，是艺术爱好者必打卡之地。
   • 地址：内江市东兴区东桐路圆顶山。
2. 隆昌石牌坊群
   • 全国重点文物保护单位，现存明清石牌坊17座，雕刻精美，记录了古代“孝、节、忠、义”的文化故事。
   • 特色：南关古镇、云峰关牌坊群，适合拍照和感受历史。
   • 地址：隆昌市金鹅镇。
3. 圣水寺
   • 川南著名古刹，始建于唐代，寺内有千年古树和灵泉“圣水”，建筑古朴，香火旺盛。
   • 地址：内江市市中区圣江路。
4. 古宇湖
   • 国家4A级景区，湖面宽阔，冬季是候鸟栖息地，适合环湖骑行、观鸟或泛舟。
   • 地址：隆昌市古湖街道。
5. 资中罗泉古镇
   • 千年盐业古镇，保留明清建筑风格，推荐参观盐神庙、罗泉会议遗址，感受慢生活。
   • 特色美食：罗泉豆腐宴。
6. 威远骑龙坳
   • 被称为“川南最美云雾之乡”，雨后清晨常现云海，是摄影爱好者的天堂。
   • 最佳季节：5-10月雨季。

二、特色美食推荐

1. 内江牛肉面
   • 麻辣鲜香，面条筋道，牛肉软糯，本地人早餐首选。推荐店铺：寡妇面、蔡氏牛肉面。
2. 油炸粑
   • 糯米包裹绿豆馅油炸而成，外酥里嫩，街头常见小吃。
3. 王记牛肉干
   • 内江老字号，麻辣、五香口味可选，适合作为伴手礼。
4. 黄老五花生酥
   • 威远特产，酥脆香甜，非物质文化遗产。
5. 蜜饯
   • 内江传统甜食，橘饼、冬条、樱桃蜜饯等，甜而不腻。

三、交通指南

• 外部交通
  • 高铁：成渝高铁经停内江北站，成都/重庆出发约1小时可达。
  • 自驾：成都出发约2小时，重庆约2.5小时。
• 市内交通
  • 公交车覆盖主要景点，出租车起步价5元；建议自驾或包车前往周边景点（如隆昌、资中）。

四、住宿推荐

• 市区：选择东兴区或市中区，推荐星级酒店如内江万达嘉华酒店，或性价比高的连锁酒店。
• 隆昌/资中：若计划深度游，可住当地特色民宿或商务酒店。

五、最佳旅游季节

• 春秋季（3-5月、9-11月）：气候宜人，适合户外活动。
• 夏季：可到古宇湖、骑龙坳避暑，但需注意防晒。
• 冬季：古宇湖观鸟，但天气较阴冷。

六、行程建议

• 一日游：张大千纪念馆 + 圣水寺 + 内江老街（品牛肉面、蜜饯）。
• 两日游：
  • Day1：内江市区（张大千纪念馆、圣水寺）→ 隆昌石牌坊群、古宇湖。
  • Day2：资中罗泉古镇 → 威远骑龙坳（摄影或云雾观赏）。

七、温馨提示

1. 内江景点相对分散，建议提前规划路线，预留充足时间。
2. 尊重当地文化，参观寺庙、牌坊时注意礼仪。
3. 夏季多雨，备好雨具；冬季潮湿，注意保暖。
4. 若时间充裕，可顺路游览周边自贡（恐龙博物馆）、宜宾（蜀南竹海）等地。

希望这份攻略能助你玩转内江，感受这座“甜城”的独特魅力！

iOS平台

• APNs (Apple Push Notification Service)
  • 必须集成，是iOS唯一官方推送通道。
  • 实现步骤：
    1. 生成APNs证书或密钥（需Apple开发者账号）。
    2. 服务端通过APNs API发送推送（支持HTTP/2或基于Token的认证）。
    3. 客户端注册设备Token并回传服务器。
  • 特点：系统级通道，应用关闭时仍可送达，但依赖网络状态。

Android平台

• FCM (Firebase Cloud Messaging)
  • 谷歌官方推送服务，海外Android设备主要依赖此通道。
  • 缺点：国内因网络限制无法稳定使用。
  • 替代方案：需集成国内厂商推送通道。

2. 国内安卓厂商推送通道

国内主流手机厂商均提供自有推送服务，需逐个集成以提高推送到达率：

• 华为推送（HMS Push）
• 小米推送（Mi Push）
• OPPO推送
• vivo推送
• 荣耀推送
• 魅族推送

实现方式：

• 为每个厂商单独申请开发者账号，集成对应SDK。
• 服务端根据设备厂商类型调用不同API发送推送。
• 优点：系统级通道，应用进程关闭时仍可唤醒。
• 缺点：维护成本高，需适配多套接口。

3. 第三方推送平台（推荐）

为简化多厂商推送适配，可采用第三方推送服务商，例如：

• 个推（Getui）
• 极光推送（JPush）
• 友盟推送（UMeng）
• 腾讯移动推送（TPNS）
• 阿里云移动推送

优势：

• 统一API：一次集成，自动分发到各厂商通道。
• 数据统计：支持推送到达率、点击率等分析。
• 节省成本：避免维护多个厂商后台。

实现步骤：

1. 集成第三方SDK到客户端。
2. 服务端调用第三方API发送推送。
3. SDK自动根据设备厂商选择最优通道。

4. 自建长连接推送（可选）

适用于对实时性要求极高或需完全自主控制的场景：

• 技术方案：
  • 使用协议：MQTT、WebSocket、TCP长连接。
  • 客户端维持与服务器的持久连接，及时接收消息。
• 挑战：
  • 电量消耗较高。
  • 安卓系统后台限制（需结合保活策略，但可能影响用户体验）。
  • 高并发下的服务器稳定性。

5. 推送策略优化

• 用户分群：根据用户行为、标签发送个性化推送。
• 定时推送：选择用户活跃时间段发送。
• A/B测试：对比不同文案的点击率。
• 沉默用户唤醒：结合短信、邮件等多渠道触达。
• 合规性：遵循《个人信息保护法》，提供用户关闭推送选项。

6. 关键注意事项

1. 权限引导：首次启动时请求通知权限，并提供引导说明。
2. 厂商限制：
   • 部分厂商（如小米、OPPO）要求应用上架商店后才开放推送权限。
   • 厂商通道可能有每日推送限额。
3. 推送内容规范：
   • 避免敏感词，防止被厂商拦截。
   • iOS需符合Apple推送内容政策（禁止广告、诱导点击等）。
4. 数据安全：
   • 用户设备信息加密传输。
   • 避免推送中包含敏感数据。

7. 技术实现流程示例

1. 客户端：
   • 集成第三方SDK（如个推）。
   • 注册设备Token并上传至服务端。

2. 服务端：

   • 存储设备Token及关联的用户ID。

   • 调用第三方API发送推送，示例代码（Python）：
     python

     复制

     import requests
     
     url = "https://restapi.getui.com/v2/{app_id}/push/single"
     headers = {
      "Content-Type": "application/json",
      "token": "your_token"
     }
     data = {
      "audience": {"cid": "client_id"},
      "push_message": {
          "notification": {
              "title": "新消息",
              "body": "您有一条未读通知"
          }
      }
     }
     response = requests.post(url, json=data, headers=headers)

3. 运维监控：
   • 监控推送成功率，失败时自动重试。
   • 分析用户关闭推送的原因，优化推送策略。

8. 常见问题排查

• 推送未到达：
  • 检查设备Token是否失效（如用户重装App或禁用通知）。
  • 厂商通道是否配置正确（如华为推送需配置agconnect-services.json）。
• 延迟过高：
  • 切换长连接或优化服务端推送队列。
• 合规风险：
  • 确保用户可一键退订，避免频繁打扰。

1. Requests + BeautifulSoup

• 适用场景：静态网页抓取（无复杂 JavaScript）。

• 示例代码：
  python

  import requests
  from bs4 import BeautifulSoup
  
  url = 'https://example.com'
  response = requests.get(url)
  if response.status_code == 200:
    soup = BeautifulSoup(response.text, 'html.parser')
    titles = soup.find_all('h1')
    for title in titles:
        print(title.text)

2. 正则表达式（Regex）

• 适用场景：快速提取特定模式的文本。
  python

  import re
  text = '<h1>Hello World</h1>'
  match = re.search(r'<h1>(.*?)</h1>', text)
  if match:
    print(match.group(1))  # 输出: Hello World

二、动态网页爬取

1. Selenium

• 适用场景：需要模拟浏览器操作（如点击、滚动、登录）。

• 示例代码：
  python

  from selenium import webdriver
  from selenium.webdriver.common.by import By
  
  driver = webdriver.Chrome()
  driver.get('https://example.com')
  element = driver.find_element(By.TAG_NAME, 'h1')
  print(element.text)
  driver.quit()

2. Playwright

• 更高效的浏览器自动化工具：
  python

  from playwright.sync_api import sync_playwright
  
  with sync_playwright() as p:
    browser = p.chromium.launch()
    page = browser.new_page()
    page.goto('https://example.com')
    print(page.inner_text('h1'))
    browser.close()

三、爬虫框架

1. Scrapy

• 适用场景：大型项目，支持异步、中间件、数据管道。

• 创建项目：
  bash

  scrapy startproject myproject
  scrapy genspider example example.com

• Spider 示例：
  python

  import scrapy
  
  class ExampleSpider(scrapy.Spider):
    name = 'example'
    start_urls = ['https://example.com']
  
    def parse(self, response):
        yield {'title': response.css('h1::text').get()}

2. PySpider

• 可视化分布式爬虫框架，适合中等规模项目。

四、反爬虫策略与应对

1. 常见反爬手段：
   • User-Agent 检测
   • IP 封禁
   • 验证码
   • 请求频率限制

2. 应对方法：

   • 设置请求头：
     python

     headers = {
      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
     }
     requests.get(url, headers=headers)

   • 使用代理 IP：
     python

     proxies = {'http': 'http://10.10.1.10:3128'}
     requests.get(url, proxies=proxies)

   • 降低请求频率：
     python

     import time
     time.sleep(2)  # 每次请求间隔 2 秒

   • 处理验证码：使用 OCR 库（如 Tesseract）或第三方 API。

五、数据存储

1. 保存到文件：
   python

   import csv
   with open('data.csv', 'w', newline='') as f:
      writer = csv.writer(f)
      writer.writerow(['Title'])
      writer.writerow(['Example Title'])

2. 保存到数据库（如 MongoDB）：
   python

   from pymongo import MongoClient
   client = MongoClient('localhost', 27017)
   db = client['mydatabase']
   collection = db['mycollection']
   collection.insert_one({'title': 'Example'})

六、注意事项

1. 遵守法律法规：
   • 查看目标网站的 robots.txt（如 https://example.com/robots.txt）。
   • 避免侵犯隐私或版权数据。
2. 道德爬虫：
   • 控制请求频率，避免对服务器造成压力。
   • 标注数据来源。

七、高级技巧

1. 异步爬虫（aiohttp + asyncio）：
   python

   import aiohttp
   import asyncio
   
   async def fetch(url):
      async with aiohttp.ClientSession() as session:
          async with session.get(url) as response:
              return await response.text()
   
   urls = ['https://example.com/page1', 'https://example.com/page2']
   tasks = [fetch(url) for url in urls]
   pages = asyncio.run(asyncio.gather(*tasks))

2. 使用 API：

   • 直接调用网站提供的 API 接口（如 https://api.example.com/data）。

1. 官方渠道查询

• 访问官网：建议直接访问骏河屋的官方网站（https://www.suruga-ya.jp），查看是否有“开发者支持”或“API文档”相关页面。通常这类信息会位于网站底部或“企业合作”栏目中。
• 联系客服：若官网上无明确说明，可通过邮件或电话联系其客服团队（需使用日语），询问是否有提供API服务的计划或合作方式。

2. 可能的替代方案

• 合作伙伴计划：部分企业会为合作伙伴或批发客户提供内部API接口。如果你是商家或企业用户，可以尝试通过商业合作的形式申请。
• 爬虫技术：如果没有API，部分开发者会通过网页爬虫（Web Scraping）获取数据，但需注意：
  • 合法性：需仔细阅读骏河屋的《利用规约》，确认是否允许自动化访问。
  • 道德风险：频繁请求可能对服务器造成压力，建议控制频率并遵守 robots.txt规则。

3. 其他资源

• 第三方平台：某些日本电商聚合平台（如価格.com、Rakuten等）可能提供商品数据API，可间接获取部分信息。
• 开发者论坛：在技术社区（如GitHub、Stack Overflow、日本2ch论坛）搜索是否有非官方API或开源项目分享。

微信官方对小程序中的“打赏”功能有严格限制，主要原因包括：

• 支付场景合规性：微信要求所有支付行为必须与实际商品或服务交易绑定，而“打赏”属于用户对内容创作者的赠予行为，不符合微信支付的定义。
• 内容生态管控：防止通过打赏功能变相支持违规内容（如诱导转发、低俗内容等）。
• 风险防范：避免资金流向不透明，防范洗钱等违法行为。

政策依据

• 微信小程序《运营规范》明确要求：
  • 支付需关联真实交易：所有支付必须对应明确的商品或服务，不得支持无实质内容的“赠予”行为。
  • 禁止虚拟支付：2020年起，微信进一步收紧了虚拟支付权限，除特定行业（如教育、政务）外，普通小程序无法开通虚拟支付功能。

替代方案

若需实现类似打赏的效果，可尝试以下合规方式：

1. 内容付费：将内容包装为知识商品（如文章合集、音频课程），用户通过购买后获取内容。
2. 赞赏码引导：在小程序内展示微信“赞赏码”，引导用户跳转到微信个人转账页面。
3. 公众号关联：通过关联公众号，在公众号文章中使用微信原生“喜欢作者”功能（需符合公众号打赏条件）。

2. 支付宝小程序：部分场景支持

支付宝对打赏功能的限制相对宽松，但需符合以下条件：

• 绑定真实服务：打赏需与具体服务（如咨询、创作内容）关联，不能是纯赠予。
• 企业资质要求：需完成企业认证，并开通「当面付」或「电脑网站支付」权限。
• 报备审核：需向平台说明打赏的具体用途和场景，通过审核后方可上线。

3. 其他平台（字节跳动小程序、百度小程序）

• 字节跳动（抖音）小程序：明确禁止无实质交易的支付行为，打赏功能需通过平台“直播打赏”等原生功能实现，不可在小程序内自定义。
• 百度小程序：政策类似微信，要求支付必须绑定商品或服务，不支持纯打赏功能。

4. 合规建议

• 避免直接使用“打赏”字样：可改用“支持作者”“购买内容”等表述，并通过商品交易形式实现。
• 跳转至其他平台：引导用户通过外部链接（如H5页面、公众号）完成赠予行为。
• 关注政策更新：各平台规则可能调整，需定期查看最新开发者文档。

总结

• 微信小程序：明确禁止直接打赏，需通过合规的支付场景间接实现。
• 其他平台：部分允许但需严格绑定服务，且对企业资质要求较高。
• 推荐方案：优先使用平台原生内容变现功能（如微信公众号赞赏、抖音直播打赏），或通过商品化内容满足合规要求。

• 服务端推送：可以通过极光提供的 REST API 或 SDK 直接调用接口发送消息。
• 控制台推送：登录极光官网的控制台，手动创建推送任务（适合测试或运营人员）。
• 客户端测试：在客户端集成 SDK 后，确保设备已成功注册并获取到有效的 Registration ID。

2. 推送前需确认的关键点

(1) 客户端配置

• SDK 集成：确保客户端正确集成了极光 SDK（Android/iOS/Web 等），并配置了 AppKey。
• 权限配置：
  • Android：确认 AndroidManifest.xml 中配置了正确的包名、权限、通知渠道等。
  • iOS：上传正确的 APNs 证书到极光后台，并确保 Bundle ID 匹配。
• 设备注册成功：检查客户端日志，确认设备已成功注册并获取到 Registration ID（极光后台可查）。

(2) 服务端配置

• API 权限：若通过服务端调用 API，需使用 AppKey 和 Master Secret 生成签名（官方文档）。
• 推送目标设置：指定推送的受众（如所有用户、特定标签、别名或 Registration ID）。

(3) 网络和证书

• APNs 证书：iOS 推送需确保极光后台的 APNs 证书有效且未过期。
• 防火墙：服务端调用极光 API 时，确保网络未拦截 https://api.jpush.cn 的请求。

3. 快速测试推送的方法

(1) 通过控制台手动推送

1. 登录极光控制台 → 选择应用 → 创建推送。
2. 填写推送内容，选择“全量推送”或指定设备。
3. 发送后，在客户端查看通知栏是否收到消息。

(2) 通过 API 调用（示例）

使用 curl 测试推送：

bash

复制

curl --location --request POST 'https://api.jpush.cn/v3/push' \
--header 'Authorization: Basic YOUR_BASE64_ENCODED_AUTH_STRING' \  # 格式为 Base64(AppKey:MasterSecret)
--header 'Content-Type: application/json' \
--data-raw '{
    "platform": "all",
    "audience": "all",
    "notification": {
        "alert": "Hello, JPush!"
    }
}'

(3) 客户端日志检查

• 查看客户端日志，确认收到推送回调（如 onReceive 事件）。
• 极光控制台的“推送记录”中可查看推送状态和送达率。

4. 常见问题排查

• 收不到推送：
  1. 检查客户端是否成功注册（查看 Registration ID 是否存在）。
  2. 检查 APNs 证书是否配置正确（iOS）。
  3. 确认推送目标（Audience）是否匹配设备标签/别名。
  4. 检查网络是否允许极光域名（如企业内网限制）。
• 服务端返回错误：
  • 401 错误：AppKey 或 Master Secret 错误。
  • 403 错误：推送权限未开通或配额不足。

5. 总结

只要客户端 SDK 集成正确、服务端 API 参数无误，且设备已注册成功，极光推送配置完成后可以直接发起推送。建议首次使用时通过控制台手动推送测试，再逐步接入服务端自动化流程。若遇到问题，可结合极光控制台的“推送记录”和客户端日志定位原因。

简单易用：其语法简洁直观，即便是刚接触的新手也能快速上手，轻松地实现各种功能，例如只需要简单几行代码就能完成一个 HTTP 请求的发送与响应获取操作。
功能全面：全面支持如 GET、POST、PUT、DELETE 等多种常见的 HTTP 请求方法，无论是获取资源信息的 GET 请求，还是会修改服务器资源的 POST 请求等，都可以方便地通过它来进行操作。
灵活强大：能够方便地添加请求头、表单数据、JSON 数据等各类请求相关信息，以此来满足不同场景下接口测试的多样化需求。
安装 Requests 库十分便捷，常用的方式是通过 pip 进行安装，只需在命令行中输入 “pip install requests” 即可。若担心下载速度过慢，还可以配置国内镜像源，比如使用国内的一些知名镜像站点，来加快安装的速度。

    使用 Requests 库发送常见的 HTTP 请求也较为简单，下面以 GET 和 POST 请求为例进行介绍：

GET 请求：可以使用requests.get()方法来发送 GET 请求，它有一个必传的参数url，用于指定请求的地址，像访问一个网页获取数据时就可以这样操作。例如想要获取某个网页的内容，代码可能类似如下形式：
import requests
response = requests.get('https://www.example.com')
print(response.text)
上述代码中，通过requests.get()向指定的Example Domain这个 URL 发送 GET 请求，然后使用response.text获取返回的文本内容（也就是网页的 HTML 源码等信息）。而且如果有请求参数需要传递，还可以通过params参数以字典等形式来传入，参数会自动按照规则拼接在 URL 后面。

POST 请求：当需要向服务器提交数据，比如用户注册、登录等场景涉及修改服务器数据时，常使用 POST 请求，通过requests.post()方法来实现。例如模拟用户登录的 POST 请求示例如下：
import requests
login_url = 'https://www.example.com/login'
login_data = {'username': 'testuser', 'password': '123456'}
response = requests.post(login_url, data=login_data)
print(response.text)
这里指定了登录的 URL 以及以字典形式提供的用户名和密码等登录数据，使用requests.post()将数据发送给服务器，进而可以根据返回的响应内容判断登录是否成功等情况。

    总之，Requests 库在 Python 接口自动化测试中扮演着十分重要的基础角色，为后续的测试工作提供了有力的支持。

（二）PyTest 框架
PyTest 框架是 Python 接口自动化测试中备受青睐的一个工具，具备诸多实用的功能特点。

    首先，它在编写和运行测试用例方面表现出色。编写测试用例时，规则较为简单灵活，测试文件通常以test_开头（以_test结尾也可以），测试类以Test开头且不能带__init__方法，测试函数以test_开头，断言使用基本的assert即可，这种简洁的规范使得测试用例的编写清晰易懂，容易上手。

    在运行测试用例上，方式也多种多样。可以通过命令行运行，比如指定执行的测试文件（常用 “pytest 路径 /py 文件名” 这种形式，默认搜索的是test开头的文件，Test开头的类，小写的test开头的方法），还可以带其他参数运行，像 “pytest 路径 /py 文件名 -v” 可以显示测试的详细参数信息，“pytest 路径 /py 文件名 -s” 能显示测试执行的输出信息等；也可以在脚本里通过pytest.main()来执行测试用例。

    其次，PyTest 框架在生成测试报告方面功能强大，支持生成多种形式的测试报告，并且有许多第三方插件与之配合来扩展其功能，例如pytest-html插件可以完美生成 html 测试报告，方便查看测试结果的详细情况；pytest-rerunfailures插件能实现失败 case 的重试功能，有助于更全面地排查问题；还有pytest-xdist插件可进行多 CPU 分发，提升测试执行的效率等。

    另外，PyTest 框架具备自动发现测试的能力，只要遵循其用例编写规范，它就能自动找到并执行相关的测试用例，无需复杂的配置过程。同时，其丰富的断言机制让测试人员可以方便地对接口返回结果等进行验证，判断是否符合预期。而且插件机制十分灵活，除了上述提到的一些常用插件外，还可以根据具体项目需求自定义扩展插件，使其能够更好地适配不同的测试场景。

    总的来说，PyTest 框架以其简单灵活、功能丰富等优势，在 Python 接口自动化测试中发挥着重要的作用，大大提高了测试工作的效率和质量。

（三）Unittest 框架
Python 内置的 Unittest 框架为接口自动化测试提供了有力的支持，有着自己独特的功能和应用场景。

    它提供了编写测试用例的类和方法，测试用例需要定义在继承自unittest.TestCase的类中，在这个类里，可以定义一些特殊的方法来进行用例执行前的初始化操作以及用例执行后的清理操作。比如setUp()方法会在每个测试用例执行前运行，可以在这里进行如实例化相关类、初始化一些数据等操作；tearDown()方法则在每个测试用例执行后运行，用于清理资源、还原环境等。如果希望这些初始化和清理操作只在整个测试类开始和结束时执行一次，还可以使用类方法setUpClass()和tearDownClass()来替代。

    Unittest 框架支持测试套件（TestSuite）的功能，通过TestSuite可以灵活地组织和选择要执行的测试用例，例如可以将相关的一组测试用例添加到TestSuite中，然后统一执行，方便对不同功能模块的接口测试进行分类管理和执行控制。

    在生成测试报告方面，虽然本身内置的报告形式相对基础，但可以结合一些第三方库（如HTMLTestRunner等）来生成更加美观、详细的 HTML 格式等的测试报告，便于直观地查看测试结果以及分析测试情况。

    在接口自动化测试的实际应用场景中，Unittest 框架常用于对接口的功能性、稳定性等方面进行测试。例如对于一个具有多个接口的项目，可以针对每个接口编写对应的测试用例类，利用setUp()等方法准备好接口请求的相关前置条件（如设置请求的 URL、请求参数等），在测试用例方法中发送接口请求并通过断言来验证接口返回的数据是否符合预期，最后通过测试套件来组织这些用例按照需求进行执行，进而生成测试报告来总结整个测试过程中发现的问题以及接口的质量情况等。

    总之，Unittest 框架凭借其内置的功能特性以及与其他库结合的扩展性，在 Python 接口自动化测试领域有着广泛的应用和重要的地位。

（四）其他常用工具
除了上述的几个主要工具外，在 Python 接口自动化测试中还有一些其他常用的工具也发挥着不可忽视的作用。

    Beautiful Soup 是一个用于解析 HTML 和 XML 文档的 Python 库，在自动化测试中，尤其是涉及到对网页内容进行解析验证的场景时非常有用。例如在测试一个接口返回的 HTML 页面数据是否正确时，通过 Beautiful Soup 可以方便地提取页面中的文本、链接、图片、表格等各种元素，然后与预期的结果进行对比。它提供了简单而直观的 API，支持多种解析器（如 Python 标准库的解析器、lxml、html5lib 等），可以根据具体的需求和性能要求来选择合适的解析器进行文档解析，进而实现对网页内容的高效遍历、搜索和数据提取操作。

    PyCurl 是一个功能强大的库，主要用于处理 HTTP 请求，它底层基于 libcurl 库，能够实现很多复杂的 HTTP 相关操作，像支持多种协议、可以进行文件上传下载、设置复杂的请求头和代理等功能，在需要对接口进行一些高级的、定制化的 HTTP 请求操作时，PyCurl 可以提供很好的支持。

    JSONPath 则是专门用于解析 JSON 数据的工具，在接口自动化测试中，由于很多接口返回的数据格式都是 JSON，使用 JSONPath 可以方便快捷地从复杂的 JSON 数据结构中提取出想要验证的具体数据节点，比如提取某个特定字段的值来判断接口返回的业务数据是否准确，或者验证某个数组中的元素是否符合预期等，极大地提高了对 JSON 格式接口数据的处理和验证效率。

    这些工具在不同的测试场景下，从不同的角度帮助测试人员更好地开展 Python 接口自动化测试工作，拓宽了测试的手段和覆盖范围，提升了整体的测试效果和质量。

1. 核心功能模块

• 文本分类与情感分析
  DeepSeek 通过动态稀疏注意力机制处理长文本数据，支持预训练模型微调，可快速实现高性能的文本分类（如新闻分类、情感分析）4。
• 数据预处理与模型训练
  提供完整的数据清洗、特征提取工具，支持端到端的模型训练流程，并内置自动化评估指标（如准确率、F1值）4。

2. 实用操作技巧

• 高效指令应用
  用户可通过25个高效指令快速完成代码生成、数据分析等任务，例如使用 “生成Python递归函数示例”直接获取代码片段2。
• 角色设定模式
  通过指令让DeepSeek扮演特定角色（如资深程序员、学术导师），获得更专业的回答，例如输入 “你是一位数据分析师，请解释线性回归原理”3。

3. 扩展与优化

• 模型轻量化部署
  未来计划通过剪枝、量化技术压缩模型，适配边缘设备，降低计算资源需求。
• 多语言与领域适配
  正在扩展多语言支持，并针对医疗、法律等领域优化模型，提升垂直场景的准确性

一、快速入门（5分钟掌握基础）

1. 通过引用[1]可知，DeepSeek提供极速入门指南，帮助用户快速完成基础配置。建议首先完成账号注册并体验核心交互功能
2. 初始使用建议关注：
   • 基础指令格式识别
   • 数学表达式书写规范（如E=mc2E=mc2）
   • 代码块交互功能1

二、系统学习教程（蓝皮书指南）

引用[2]详细说明了DAC出品的《DeepSeek使用教程蓝皮书》，该教程包含：

1. 核心功能模块解析
2. 交互式学习方法
3. 本地/云端部署指南
4. 典型应用场景演示（含代码示例）

建议按章节顺序学习，重点掌握API调用规范和错误处理机制2

三、API开发实践

引用[3]提供API使用专项指南：

# API调用示例
import deepseek
api = deepseek.connect(api_key="your_key")
response = api.generate("解释量子计算原理")

需特别注意认证机制和请求频率限制3

四、高级功能拓展

引用[4]指导用户构建知识库：

1. 数据准备规范：建议采用TF−IDFTF−IDF算法预处理文本

2. 自定义指令训练：通过y=σ(Wx+b)y=σ(Wx+b)

   等机器学习模型优化响应

3. 专业场景适配：结合∇⋅E=ρϵ0∇⋅E=ϵ0ρ等专业公式增强STEM领域应答

✅正确操作：
① 加身份标签：
“我是个每天坐办公室的会计，腰椎不好不能剧烈运动，怎么安排减脂饮食？”

② 加具体阻碍：
“孩子总挑食不吃蔬菜，有没有5分钟能搞定的隐藏蔬菜食谱？”

原理：就像你去医院不会只说“我不舒服”，AI也需要知道你的“症状细节”。

你需要把你的需求说清楚，如果你给 AI 是一个模棱两可的问题，那么 AI 也会给你一个大而全的答案！

2. 复杂问题玩“分解游戏”
   不要一次性问：
   “我要开奶茶店，告诉我所有注意事项”

试着拆解：

第一阶段：
“在三四线城市小学附近开奶茶店，主打10元以下价位，需要优先考虑哪3个成本项？”

第二阶段：
“针对小学生群体，除了珍珠奶茶，还有哪些健康替代配料方案？”

实测效果：分步提问获得的建议，比一次性的大段回答实用2倍以上。

3. 学会给AI“打补丁”
   当AI第一次没答到点上，别放弃！用这三句话挽救：

“刚才的方案里，‘找供应商’这步能不能展开说？”
“如果预算只有500元，第三点提到的设备能换成更便宜的吗？”
“我是烘焙小白，请用‘完全不会揉面’都能听懂的方式解释第二步”
类比场景：就像网购时和客服沟通，补充信息越多，解决方案越精准。

4. 警惕“正确的废话”

如果得到这种回答：
“要保持良好作息，注意饮食均衡，适当运动…”

立即追加：
“请直接给我一个可执行的方案，比如：
周一早餐：xx+xx（具体到克数）
周三运动：xx动作（附跟练视频链接）”

核心逻辑： AI默认会给出安全但宽泛的回答，需要你用具体需求“激活”它的深度能力。

5. 重要事项加“双重确认”
   涉及医疗、法律等专业领域时，务必追加：
   “请确认这个建议是否符合2024年最新《xx条例》规定？”
   “以上药物配伍是否存在禁忌？请分点列出风险项”

保护机制： AI可能遗漏时效性信息，这点和人类专家沟通同理。

6. 用“土味例子”理解专业概念
   想弄明白区块链？别直接问定义，试试：
   “用菜市场王阿姨记账本的故事，解释区块链怎么防止作假”

需要理解财报术语？可以问：
“把毛利率、净利率的区别，用烧烤摊进货卖串的利润来比喻”

效果验证： 用生活场景提问，理解效率提升60%以上。

7. 给AI“穿职业装”
   在问题前加角色设定，回答会瞬间专业：
   普通提问：
   “帮我写个工作周报”

升级版：
“假设你是外企市场总监，用数据驱动型思维帮我润色这份周报，重点突出用户增长策略的迭代效果”

角色库推荐： 心理咨询师、资深HR、小说编辑、营养师等垂直领域专家。

8. 把AI当“杠精朋友”
   重要决策前，试试这样提问：
   “如果我要在老家县城开火锅店，请分别列出：

最可能成功的3个理由
最容易失败的3个隐患
用SWOT分析框架对比”
进阶用法：在每轮对话后追问“还有其他可能性吗？”，能挖掘更多隐藏角度。

9. 家庭场景的妙用
   ① 调解矛盾：
   “孩子沉迷手机，用非暴力沟通话术设计一段睡前对话”

② 生活妙招：
“家里木地板被泡水翘边，在不请工人的情况下，列出分步骤应急处理方案”

③ 亲情维系：
“帮我将这段文字改写成给父母的手写信格式，语气要亲切自然，避免网络用语”

10. 终极心法：把它当“实习生”
    记住这个关系公式：

模糊指令=低质量反馈
具体需求+场景细节=超预期产出
就像你不会对新来的实习生说：“做个好看的PPT”，而会说：“这是市场部的季度数据，用蓝色系商务风格，重点标出环比增长超过15%的部分”。

划重点
遇到AI反复答非所问时：

检查是否用了太多专业术语
把长段落改成1-2行的短需求
加入“不要理论，只要操作步骤”等明确限制
刚开始需要刻意练习，但大约对话20次后，你会形成自己的“提问肌肉记忆”。

现在就从最简单的需求开始试一句：“教我用XXX，我的顾虑是 XXX，请使用大白话表达”——你会发现，用好AI的关键，在于像对待人一样对待它。

清晰表达需求：提问时要明确具体的目标、背景和要求，避免模糊和笼统的表述。例如，不要说“帮我写个方案”，而要说“作为跨境电商创业者，我需要制定亚马逊新品推广方案，请按以下框架展开……”。

二、提问技巧
场景化模板：明确目标、对象、效果和问题。例如，“我要设计一个PPT框架，要给一批50岁左右的制造业老板分享，主题是传统工厂出海战略布局……”。

术语破解模板：用简单的语言解释专业术语，例如“用小学生能听懂的话解释RLHF”。

风格迁移模板：模仿特定作家或文体进行创作，例如“用金庸的武侠小说风格，描写一段程序员使用DeepSeek-R1高效编程的场景”。

三、优化提问结构
4步提问法：明确身份、具体任务、细节约束和输出格式。例如，“作为市场专员，请对比2024年Q4比亚迪与特斯拉的社交媒体声量，分析用户对‘降价策略’的情绪倾向，用表格呈现”。

分步骤提问：对于复杂问题，将其拆分为多个简单步骤，逐步提问。例如，“第一步：总结社交媒体营销的五大趋势；第二步：针对我们的产品，挑选三个最适合的趋势；第三步：设计一套实施计划……”。

四、提供背景信息
背景信息的重要性：提供背景信息可以帮助DeepSeek更好地理解问题的上下文，从而给出更精准的回答。例如，“我正在准备英语四级考试，请用简单词汇解释这篇科技文章的重点”。
五、追问和反馈
追问技巧：通过追问可以进一步挖掘问题的细节和深度。例如，“基于这个方案，可能遇到哪些实施风险？给出应对策略”。

反馈修正：如果回答不符合预期，可以通过补充信息或调整问题来修正回答。例如，“刚才的回答太专业了，请用买菜阿姨能懂的话再说一遍”。

六、指定输出格式
明确输出要求：告诉DeepSeek你希望得到的回答形式，例如列表、表格、分点说明等。例如，“请用对比表格形式展示微波炉vs空气炸锅的加热原理、适用场景和能耗区别”。
七、避免常见错误
避免模糊提问：避免使用过于模糊或笼统的提问方式，例如“这个怎么做？”或“那个东西怎么样？”。

避免多问题同时问：尽量一次只问一个问题，避免同时提出多个问题，以免让回答变得混乱。

避免缺乏关键信息：在提问时提供足够的关键信息，例如在询问代码问题时附上代码和错误信息。

八、高级玩法
角色代入法：让DeepSeek扮演特定角色来回答问题，例如“你是一位资深程序员，请帮我解释一下Python中的递归函数”。

跨模态融合：结合图片、文字、数据等多种模态进行提问，例如“解读这张用户行为热图，点出三个用户流失的关键点，并用箭头标出改进方向”。

逆向提问技巧：当不确定具体需求时，让DeepSeek帮助你列出关键问题，例如“我现在打算开展某个项目，但不太确定具体需求应该怎么描述，请你帮我列出5个关键问题，协助我理清思路”。

九、隐藏功能
直接处理数据：将CSV数据直接粘贴到DeepSeek中，让其进行分析或生成图表代码。

翻译对比：同时要求DeepSeek以不同风格翻译同一句话，例如“把这句话用GPT风格和DeepSeek风格分别翻译成英文”。

当搜索引擎用：通过添加特定关键词（如site:知乎或site:``arxiv.org）让DeepSeek搜索特定网站的信息。

十、避坑指南
简化回答：如果回答过于复杂或专业，可以要求DeepSeek用更简单的方式解释，例如“用小学生能听懂的话解释”。

代码报错：遇到代码问题时，直接粘贴错误信息和代码，让DeepSeek帮助调试。

避免冗长回答：如果不需要详细回答，可以要求DeepSeek只输出核心步骤或关键结论。

十一、总结
把DeepSeek当作一个聪明但没常识的新同事：在提问时要明确具体的目标、背景和要求，避免让其猜测，同时提供足够的信息以帮助其更好地理解问题。

高效提问公式：“身份+任务+要求+例子”，例如“作为健身教练（身份），帮我制定减肥食谱（任务），要一周不重样（要求），像这样（例子）……”。

核心理念：明确告诉DeepSeek你想要什么、参考什么资料、做成什么样子以及避开哪些雷区，这样可以大大提高其回答的准确性和实用性。

1. 技术性价比革命
   ✅ 混合专家架构（MoE）：仅激活370亿参数即可实现GPT-4级别性能，推理成本降低80%

✅ 中文优化：文言文翻译准确率92.3%，远超国际开源模型
✅ 多模态支持：支持PDF/Word/图片解析，一键生成数据可视化图表

2. 全场景覆盖能力
   领域 典型应用 效果示例
   教育 教案生成/作业批改 5分钟产出《牛顿定律》三维教学目标框架
   开发 代码补全/调试 自动修复Python的SettingWithCopyWarning并提供3种优化方案
   创作 新媒体文案/视频脚本 生成50条小红书爆款标题，阅读量提升300%
3. 部署零门槛
   ✅ 网页端免安装：https://chat.deepseek.com

✅ 移动端轻量化：微信小程序/APP双端同步，8G内存流畅运行

二、功能速览：三大核心模块
模块 功能亮点 错误示范 正确操作
智能问答 多轮对话溯源验证 "怎么写论文？" → 空泛建议 "生成Transformer架构创新点对比表，附LaTeX公式"
代码助手 全栈开发支持 "写个排序算法" → 生成Python2过时代码 "用Python3.10实现快速排序，添加类型注解与doctest用例"
数据分析 可视化报告生成 "分析销售数据" → 仅文字结论 上传CSV自动生成带热力地
三、正确vs错误示范对照表
场景1：论文写作
❌ 错误提问：

"帮我改论文"
→ 回复："建议多查文献"（无效指导）

✅ 正确公式：

"我是机械专业本科生，需优化文献综述部分：

1. 突出近3年柔性机器人传感器突破
2. 用学术语言重写并标注参考文献DOI
3. 按《计算机学报》格式排版"
   → 生成带权威引用的段落，查重率直降15%

场景2：职场周报
❌ 错误提问：

"写份工作总结"
→ 生成"加强学习"等套路内容

✅ 正确操作：

"作为审计顾问，用STAR法则整理年度工作：

1. 突出3个IPO项目风险控制贡献
2. 量化节省客户时间成本（精确到小时）
3. 提出2025年CPA学习计划"
   → 输出可直接提交的总结，获合伙人好评

四、DeepSeek+跨场景解决方案

1. DeepSeek+教学
   [指令模板]
   "设计《散步》课文3分钟导入环节：

• 结合学生家庭生活案例
• 包含小组讨论+情景模拟
• 输出带时间轴的互动流程表"
  → 生成可直接打印的教案框架

2. DeepSeek+开发

复杂问题分步求解

第一轮："Pandas出现SettingWithCopyWarning怎么办？"第二轮："请修改以下代码并提供3种预防方案：[粘贴代码]"第三轮："生成该问题的技术文档模板"3. DeepSeek+自媒体
"生成智能手表营销视频脚本：

1. 分'通勤/运动/睡眠'三大场景
2. 每场景包含产品特写镜头描述
3. 结尾设计'抽奖+晒单'双重转化"
   → 自动输出MidJourney提示词+剪映剪辑建议

五、避坑指南（血泪经验！）
隐私防护：避免输入身份证/银行卡信息，改用"假设45岁男性患者..."等虚拟案例

信息验证：对学术结论使用"请提供DOI编号"二次验证

格式规范：添加"用Markdown表格/代码块/标题分级"等约束条件

其实，这并不是DeepSeek本身的问题，而是很多人在使用它时，方法不对，导致“宝刀未老，误用其锋”。这就像是拿着超强的武器，却没有找到合适的战斗方式，白白浪费了它的潜力。

今天，我就给大家带来9个超级实用的DeepSeek使用技巧。通过这些技巧，你会发现，DeepSeek比你想象的要强大得多！

DeepSeek学习交流区，长期更新

一、DeepSeek三大模式解析：选择适合的武器，才能事半功倍
DeepSeek有三个核心模式，分别是：基础模型（V3）、深度思考（R1）、联网搜索。这三种模式可以帮助你在不同的场景下获得最佳效果。

1. 基础模型（V3）：快速回答，低门槛的AI助理

基础模型（V3）可以看作是DeepSeek的基础武器。它不需要勾选，一开始默认就是这个模型。自从去年12月进行升级后，V3的性能得到了大幅提升，甚至可以媲美GPT-4、Claude-3.5等业界顶尖模型。

V3的优势在于它简单、高效、低门槛，特别适合用来解答一些常见的百科类问题。如果你只是想了解某个基本知识点，或者需要一个快速的文本生成，V3绝对能轻松应对。

比如，你想知道“什么是量子力学”，V3可以给你一个简洁、准确的回答。无需太多复杂推理，它的最大优势就是“快”和“准”。

2. 深度思考（R1）：推理高手，复杂问题的解题神器
   R1是DeepSeek的深度思考模型，专为那些需要复杂推理、深度分析的问题设计。比如，涉及数理逻辑推理、编程代码分析等任务时，R1的表现就非常出色。

R1的参数达到了660B，采用了强化学习（RL）和后训练方法，这使得它能够从多个维度进行分析，给出经过精密推理的解决方案。它更像是一个专家型AI，不仅能给出结论，还能清晰地解释每一步的思路。

例如，当你询问一个编程问题时，R1能够为你提供具体的代码实现、优化方案，甚至详细的错误分析。R1的“深度”就是它的强大所在，如果你有复杂问题需要解决，R1绝对是你的不二之选。

3. 联网搜索：实时获取最新信息，回答不仅限于知识库
   联网搜索模式是DeepSeek的亮点之一，它依赖于RAG（检索增强生成）技术。这意味着，DeepSeek不仅仅依赖自己的知识库，还能从互联网上实时检索到最新的信息来回答问题。

这样一来，DeepSeek不仅能回答2024年7月之前的问题，还能根据网络上的新信息，回答时效性更强的问题。它会把最新的新闻、技术动态、甚至社交平台的热议话题带入你的答案中，增强了回答的实用性和准确性。

例如，你问DeepSeek：“2025年春晚有哪些节目？”DeepSeek就能通过联网搜索为你找到最相关的资料，并给出最新的节目安排。

二、与GPT对标：DeepSeek如何成为最强竞争者？
DeepSeek的三个核心模式，不仅仅是一个工具，而是与行业内其他顶级模型直接对标。它的这些对标优势，能帮助你做出更明智的选择。

1. V3对标GPT-4：快速、简洁的“百科全书”
   V3和GPT-4是直接竞争的对象。V3采用了Moe架构，拥有671B参数，能够快速响应并提供高效的答案，特别是在百科类问题上，性能非常接近GPT-4。无论你是需要了解某个历史事件，还是快速处理一个简单的文本生成任务，V3都能做到高效且精准。
2. R1对标o1：推理领域的高手
   R1和OpenAI的o1模型很相似，但R1在推理和深度分析上表现得更为出色。R1的660B参数，配合强化学习技术，能够在复杂问题的处理上，提供更深入的分析和更高精度的答案。它的推理能力甚至超越了o1模型，尤其在逻辑推理和复杂问题的解析上，R1无疑更胜一筹。

三、如何让DeepSeek充分发挥它的潜力？
要充分利用DeepSeek的强大功能，技巧比工具本身更重要。下面是一些技巧，帮助你用最简单的方式，获得最精准的答案。

1. 不需要复杂提示词，简洁明了就是最好的
   很多AI使用者总爱准备复杂的提示词模板，但在DeepSeek面前，你根本不需要这么麻烦。你只需用简单的、直白的语言描述需求，它就能精准理解并给出答案。

比如，如果你需要一段蛇年拜年祝福语，直接告诉它：“帮我写一段蛇年拜年祝福语”，DeepSeek立马就能生成多个版本供你选择。

这里有一个关键点：与DeepSeek的对话越接地气，结果越精准。所以，别刻意使用太过正式的语言，越简单、越自然，它能理解得越清楚。

2. “小学生”沟通技巧：让AI说人话
   有时，DeepSeek的回答可能会让你觉得过于抽象。这时，可以通过“小学生”沟通技巧来解决。你可以给它一个提示：“请用小学生能听懂的话解释什么是大模型。”

这种方法会让DeepSeek用更通俗易懂的语言来回应你，避免那些“八股文”式的官方回答。

3. 持续追问，让问题更清晰
   如果你对一个复杂问题不够理解，不妨通过持续追问来深入挖掘更多细节。比如你问：“如何写好提示词？”然后根据答案继续追问，逐步挖掘出具体的步骤和技巧，最后整理成清单格式。

   这种方法能够帮助你更加全面、系统地了解一个复杂的概念或操作，让你对问题有更深入的理解。

   4. 联网搜索：快速了解时事热点
      联网搜索是DeepSeek的秘密武器之一，利用它可以随时获取最新的互联网信息。如果你有一些关于新兴技术、最新新闻的疑问，DeepSeek都能为你提供实时的答案。就算是一些2024年7月之后的事件，它也能通过联网搜索得到最准确的回答。

   当然，网络安全问题时有发生，最近由于国外网络攻击，DeepSeek的联网搜索暂时不可用，但这绝对是它的一大亮点，等恢复后，你可以轻松获取最新信息。

4. 5. 上传附件：让DeepSeek处理你的私密资料

DeepSeek还支持上传附件功能，最大支持上传50个文件，每个文件最大100MB。你可以上传自己的知识库、文档，甚至一些需要深度分析的材料，让DeepSeek基于这些内容进行分析和推理。

6. R1的透明度：深度理解推理过程

R1模型的思维链完全开放，用户可以看到推理过程的每一步。通过这种方式，你不仅仅能看到最终答案，还能理解AI是如何得出这个结论的。这种

开放性极大提升了用户对AI思维的理解，也让AI变得更加可信。

不少人兴冲冲注册，结果一上来就开始硬憋提示词，仿佛回到了写命令代码的时代，生怕AI听不懂。有人翻着各种“终极提示词秘籍”，一遍遍优化措辞，“请用批判性思维分析……”“请结合苏格拉底式提问法……”结果AI还是答非所问，气得摔键盘。

别折腾了！DeepSeek压根不需要这么复杂的“暗号”，它就喜欢“人话”！你正常说话，它比谁都懂。甚至只要一句“给我讲讲这个”，它都能瞬间进入最佳状态。

这篇文章，给你个DeepSeek的高效使用技巧，彻底摆脱提示词焦虑，让AI真正成为你的“最强大脑”！

一、彻底抛弃提示词模板，DeepSeek更爱“人话”
很多人用DeepSeek，总觉得要写得“专业”一点，生怕AI不明白自己想要什么，结果提示词一写就是半张A4纸，生怕AI智商不够，得“培训”它一下。

但其实，DeepSeek压根不吃这套，它比你想象中聪明得多，根本不需要你拿“套路”教它做人。真正高效的提示词就一条原则：用人话！

最简单的万能公式——你是谁 + 背景 + 你的目标，直接说出需求，DeepSeek能给你最精准的回答。

反面例子：
❌ “你是一个精通心理学的专家，现在请结合马斯洛需求层次理论，帮助我分析一个年轻人选择在大城市工作的心理动机，并用专业术语阐述。”

太啰嗦，AI当然能回答，但它会照本宣科，给你一堆教科书般的废话。

正确做法：
✅ “我25岁，在北京工作，但总觉得压力很大，想回老家又有点不甘心。能不能帮我分析一下，这是不是正常的心理？”

二、输出晦涩难懂？一句“我是小学生”让AI秒变贴心讲解员
很多人吐槽DeepSeek回答太学术，明明就想问个简单问题，结果AI一本正经地整出一篇论文，让人看了头疼。但问题不是AI太高冷，而是你没告诉它“用人话”说！

秘诀很简单：自降身份，让AI别端着。直接在开头加一句“我是小学生”，或者更具体点，比如“请用大白话解释”，AI的输出立马变得接地气。

错误示范：
❌ “请介绍一下区块链的工作原理。”DeepSeek可能会给你来一段“去中心化分布式账本共识机制”的专业解读，看着就累。

正确打开方式：
✅ “我是个完全不懂区块链的小白，你能不能用最简单的比喻，告诉我它是怎么回事？”这时候AI的回答会变成：“区块链就像一本大家都能看的记账本，每个人记的账都一样，谁都改不了。”一下子就懂了吧？

三、DeepSeek的中文写作能力，远超你的想象
DeepSeek的中文写作能力，可能比你想象的还要狠！无论是文艺煽情、犀利讽刺，还是知乎大V式的知识输出，它统统能拿捏。关键是，你得告诉它怎么写！

进阶玩家：
✅ “用王小波的幽默风格，写一个社恐男生暗恋女神的故事。” 结果，DeepSeek一出手，分分钟让你怀疑王小波穿越了。

四、如何让DeepSeek思考得更深？深度思考万能提示词
很多人用DeepSeek，就是丢个问题，等着AI端上答案。但AI不是搜索引擎，真正的价值在于推理，而不仅仅是列清单！想让DeepSeek思考更深入？这句万能提示词送给你：

“请在你的思考分析过程中进行批判性思考、同时反面考虑你的回答，并且要对回答进行多次深入复盘，务必详尽。”

五、DeepSeek的3个使用禁区，别踩坑！
DeepSeek再强，也有三个“雷区”，踩了只会徒增烦恼！

长文杀手？4000字以上逻辑容易崩！
DeepSeek写短文是高手，但让它写部4000字的深度长文？你可能会看到前后矛盾、自我打脸的内容。想写长篇大论？Claude 200K更适合。

敏感内容？一键蒸发！
DeepSeek有后置审核机制，可能刚生成的内容还在，过几秒就突然“蒸发”。破解方法？改提问、多点几次复制按钮，甚至换个AI（GPT-4、Claude）试试。

个人风格？别太指望
DeepSeek擅长结构化写作、模仿名家文风，但要写出100%符合你个人风格的文章？还是要自己润色，AI是工具，不是你的文笔外挂！

（二）熟悉界面布局
操作步骤：登录成功后，进入 DeepSeek 主界面。界面顶部是菜单栏，包含新建对话、历史记录、个人设置等选项；中间是对话输入框和输出区域，你在输入框输入问题或指令，DeepSeek 会在输出区域给出回答；底部可能2. 有快捷功能按钮，比如切换模式、查看帮助文档等。
关联工具：这一步主要是熟悉 DeepSeek 自身界面，无需额外工具。
二、选择合适的模式
（一）新手模式选择
操作步骤：首次使用的话，点击 “新建对话”，在弹出的模式选择框中，选择 “新手引导模式” 或 “基础模式”。这些模式会提供简单的模板和引导话术，帮助你快速了解 DeepSeek 的基本功能和提问方式。例如在新媒体写作场景下，选择 “新媒体写作” 模板，系统会生成包含开头、正文、结尾框架的写作模板，你只需按提示填入关键信息。
关联工具：主要依赖 DeepSeek 自身的模式设置功能，无需外部工具。
（二）专业模式探索
操作步骤：对 DeepSeek 有一定了解后，可尝试切换到 “高级模式” 或 “专业模式”。在这些模式下，你能输入更复杂的指令，实现更精准的需求。比如在学术研究时，输入 “请梳理量子计算在金融领域应用的研究现状，列出近五年重要文献及核心观点，并对比不同研究方法的优劣”，DeepSeek 能给出更专业、深入的分析。
关联工具：主要是掌握 DeepSeek 的指令输入技巧，无需特定外部工具。
三、编写高效提示词
（一）明确需求与指令结构
操作步骤：在输入框输入提示词时，要明确自己的需求。一个完整的指令通常包含主题、目标、要求等要素。比如 “请帮我写一篇关于健康饮食的科普文章，目标读者是中老年人，要求语言通俗易懂，包含常见食物的营养成分介绍和合理搭配建议”。
关联工具：可以使用文本编辑工具，如 Windows 自带的记事本、Mac 的备忘录等，先梳理好需求，再复制粘贴到 DeepSeek 输入框，避免输入错误或遗漏关键信息。
（二）参考提示词库
操作步骤：如果不知道如何编写提示词，可以在网上搜索 “DeepSeek 提示词库”，找到一些公开的优秀提示词示例。比如在文案创作中，参考 “请以 [产品名称] 为例，创作一段朋友圈推广文案，突出产品的 [核心卖点]，语言风格幽默风趣，能吸引年轻消费者” 这样的模板，结合自己的产品信息进行修改。
关联工具：使用浏览器搜索提示词库，一些在线文档平台，如百度文库、豆丁网等，可能有相关资源。
四、内容生成与优化
（一）生成内容
操作步骤：输入提示词后，点击 “发送” 或 “生成” 按钮，DeepSeek 会根据指令生成内容。等待过程中，注意观察进度条，生成时间根据内容复杂程度而定，简单指令可能几秒完成，复杂的研究报告等可能需要更长时间。
关联工具：主要依赖 DeepSeek 的运算和生成能力，无需外部工具。
（二）优化内容
操作步骤：
篇幅调整：如果生成的内容过长或过短，使用 DeepSeek 自带的 “扩写”“精简” 功能。比如点击 “扩写这段内容，增加一些案例和细节”，或 “精简这段文字，去除冗余表述”。
语言优化：对于口语化或表述不准确的地方，点击 “改写” 按钮，让 DeepSeek 优化语言，使其更正式、专业或符合特定风格。
内容丰富：输入 “请补充相关数据”“添加一些实际案例” 等指令，让内容更具说服力和可读性。
关联工具：可以使用 Grammarly 辅助检查语法错误和拼写错误。将 DeepSeek 生成的内容复制到 Grammarly 中，它会实时检测并给出修改建议，提升内容质量。
五、多场景应用与协作
（一）多场景应用
操作步骤：在不同场景下灵活运用 DeepSeek。工作中撰写项目策划书时，输入 “为 [项目名称] 制定一份详细的项目策划书，包括项目背景、目标、执行步骤、预算分配和风险评估”；学习中准备考试复习资料时，输入 “帮我总结 [学科名称][章节名称] 的重点知识点，制作思维导图大纲”。
关联工具：在项目管理场景中，可以结合 Trello 进行任务管理。将 DeepSeek 生成的项目计划任务添加到 Trello 中，通过 Trello 的卡片和列表形式，直观跟踪任务进度，设置截止日期和提醒等。
（二）协作分享
操作步骤：如果需要与团队成员协作，可以使用 DeepSeek 的分享功能。点击 “分享” 按钮，生成分享链接或二维码，将内容分享给同事、同学等。对方点击链接即可查看生成的内容，还能在评论区提出修改建议和意见。
关联工具：配合飞书多维表格进行内容协作管理。将 DeepSeek 生成的内容相关信息，如文章主题、创作进度、负责人等，记录在飞书多维表格中，团队成员可以实时同步信息，共同推进内容创作或项目进展。
通过以上步骤和关联工具的配合使用，相信你已经能熟练使用 DeepSeek，在各个领域发挥其强大功能，提高工作、学习和创作效率。快行动起来，开启你的 DeepSeek 高效之旅吧！

DeepSeek R1正式入驻Azure AI Studio，成为首个直连全球GPU资源池的中国大模型。这记重拳直接击碎"东西方AI生态隔离"的幻想——当华盛顿还在讨论技术封锁法案时，中国AI已用代码轰开微软帝国的大门，聪明的中国用户早已用DeepSeek写完周报、搞定投标书、甚至生成年会相声剧本。

今天给大家介绍一下DeepSeek到底该如何使用，让大家更快的掌握DeekSeek使用方法。

1、跨文档处理

同时上传PDF+Excel+网页链接，输入：

“对比三份材料中的2024营销预算差异，用颜色标注矛盾点”

2、AI翻译官模式

输入：“将下方合同译为英文，保留法律术语准确性，用Markdown标注重点条款”

3、私人知识库

在控制台上传企业手册/产品文档

提问：“根据Q4技术白皮书，列举三项竞品不具备的核心优势”

4、代码生成优化

输入：“写Python爬虫抓取微博热搜，每小时自动去重存储到MySQL，附加异常处理模块”

5、学术研究神器

输入：“用APA格式综述近三年AIGC伦理研究，标注中英文文献比例”

追加：“制作文献演进时间轴，突出中美学派分歧点”

6、文风克隆术

输入：“模仿《舌尖上的中国》解说词风格，描写武汉热干面的制作过程”。

），已成为办公、学习、编程等场景的必备工具。其最新R1满血版支持128K长文本处理，生成速度达60 TPS，堪称效率神器。

二、快速上手指南

1. 访问入口
   网页端：DeepSeek官网 或 官网平替
   手机端：应用商店搜索"DeepSeek"（认准蓝色鲸鱼LOGO）
   API调用：开发者平台
2. 注册登录

注册流程演示

1. 点击右上角「笑脸图标」
2. 选择「邮箱/手机注册」
3. 接收验证码完成认证
4. 设置高强度密码（建议含大小写+数字）
   三、核心功能详解
5. 智能对话
   黄金提问公式：背景 + 任务 + 要求 + 补充

示例：
【背景】我是新媒体运营新人
【任务】需要撰写公众号推文
【要求】语言活泼，带emoji表情
【补充】产品是智能咖啡机，目标用户是都市白领

2. 文件处理
   支持PDF/Word/Txt上传，三大神级指令：

/总结：提取文档核心观点
/对比：分析多文档差异
/制表：将条款转为表格

3. 代码生成

生成爱心图案代码（带进度条）

import requests
from tqdm import tqdm

def download_image(url, save_path):
response = requests.get(url, stream=True)
total_size = int(response.headers.get('content-length', 0))

with open(save_path, 'wb') as f, tqdm(
    desc=save_path,
    total=total_size,
    unit='iB',
    unit_scale=True
) as bar:
    for data in response.iter_content(chunk_size=1024):
        size = f.write(data)
        bar.update(size)

提示：输入"/注释"可让AI解释代码逻辑

四、高阶使用技巧

1. 深度思考模式
   勾选输入框旁的「深度思考」开关

，AI会展示完整推理过程：

用户问题 → 意图分析 → 知识检索 → 方案生成 → 效果预判

2. 魔法指令集
   指令 功能 示例
   /续写 继续未完成内容 适合长文创作中断时使用
   /简化 复杂内容转大白话 解读专业报告
   /示例 生成带案例的解决方案 营销方案设计
   /检查 排查文档错误 合同条款审核
3. 本地部署方案
   通过Ollama工具实现：

安装部署命令

ollama run deepseek-r1:32b # 32B参数版需24G显存
ollama run deepseek-r1:8b # 8B参数版适配家用显卡9
五、应用场景案例

1. 职场效率提升
   会议纪要：自动生成带重点标记的摘要
   数据分析：上传Excel自动生成可视化报告
   邮件撰写：输入"/正式"切换商务语气
2. 学习研究助手
   论文阅读：上传PDF自动生成综述报告
   解题辅导：展示分步推导过程（数学题准确率79.8%）
   语言学习：实时翻译支持338种编程语言
   六、避坑指南
   警惕"10万元本地部署教程"，官方声明从未授权收费服务
   超过50页文档建议先拆分处理，避免解析失败
   手机端卡顿时可切换「纳米AI」使用满血版
   重要内容务必人工复核，AI可能产生幻觉

在当今信息爆炸的时代，数据无处不在，如何有效地抓取、处理和分析这些数据成为了许多开发者的必修课。本篇博客将深入探讨如何使用Python中的两个强大工具：BeautifulSoup和Scrapy来抓取网页数据。我们将从基础知识开始，逐步深入到实际应用，最终实现一个完整的爬虫项目。

1. 什么是爬虫？

网络爬虫（Web Crawler）是一种自动访问互联网并提取信息的程序。它可以帮助我们从网站上获取大量数据，进行分析和处理。爬虫的应用非常广泛，比如搜索引擎、数据分析、市场调研等。

2. 准备工作

在开始之前，我们需要确保已经安装了Python及其相关库。可以使用pip进行安装：

pip install requests beautifulsoup4 scrapy

pip install requests beautifulsoup4 scrapy

pip install requests beautifulsoup4 scrapy

pip install requests beautifulsoup4 scrapy

• requests：用于发送网络请求。
• beautifulsoup4：用于解析HTML和XML文档。
• scrapy：一个强大的网络爬虫框架。

3. 使用BeautifulSoup抓取网页数据

3.1. BeautifulSoup简介

BeautifulSoup是一个用于解析HTML和XML的Python库。它可以将复杂的网页结构转化为一个易于操作的树形结构，使得我们能够轻松提取网页中的信息。

3.2. 示例：抓取豆瓣电影排行榜

在这个示例中，我们将抓取豆瓣电影排行榜的前10部电影及其评分。

3.2.1. 发送请求

首先，我们需要发送一个HTTP请求来获取网页的HTML内容。

import requests
from bs4 import BeautifulSoup

url = 'https://movie.douban.com/chart'
response = requests.get(url)
html_content = response.text

import requests
from bs4 import BeautifulSoup

url = 'https://movie.douban.com/chart'
response = requests.get(url)
html_content = response.text

import requests
from bs4 import BeautifulSoup

url = 'https://movie.douban.com/chart'
response = requests.get(url)
html_content = response.text

import requests
from bs4 import BeautifulSoup

url = 'https://movie.douban.com/chart'
response = requests.get(url)
html_content = response.text

3.2.2. 解析HTML

接下来，我们使用BeautifulSoup来解析HTML内容。

soup = BeautifulSoup(html_content, 'html.parser')

soup = BeautifulSoup(html_content, 'html.parser')

soup = BeautifulSoup(html_content, 'html.parser')

soup = BeautifulSoup(html_content, 'html.parser')

3.2.3. 提取数据

我们将查找电影标题和评分，并将结果存储在一个列表中。

movies = []

for item in soup.select('.item'):
    title = item.select_one('.title').text
    rating = item.select_one('.rating_num').text
    movies.append({'title': title, 'rating': rating})

print(movies)

movies = []

for item in soup.select('.item'):
    title = item.select_one('.title').text
    rating = item.select_one('.rating_num').text
    movies.append({'title': title, 'rating': rating})

print(movies)

movies = []

for item in soup.select('.item'):
    title = item.select_one('.title').text
    rating = item.select_one('.rating_num').text
    movies.append({'title': title, 'rating': rating})

print(movies)

movies = []

for item in soup.select('.item'):
    title = item.select_one('.title').text
    rating = item.select_one('.rating_num').text
    movies.append({'title': title, 'rating': rating})

print(movies)

3.3. 完整代码

将上述代码整合成一个完整的爬虫程序：

import requests
from bs4 import BeautifulSoup

def get_movies():
    url = 'https://movie.douban.com/chart'
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    movies = []

    for item in soup.select('.item'):
        title = item.select_one('.title').text
        rating = item.select_one('.rating_num').text
        movies.append({'title': title, 'rating': rating})

    return movies

if __name__ == '__main__':
    movie_list = get_movies()
    for movie in movie_list:
        print(movie)

import requests
from bs4 import BeautifulSoup

def get_movies():
    url = 'https://movie.douban.com/chart'
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    movies = []

    for item in soup.select('.item'):
        title = item.select_one('.title').text
        rating = item.select_one('.rating_num').text
        movies.append({'title': title, 'rating': rating})

    return movies

if __name__ == '__main__':
    movie_list = get_movies()
    for movie in movie_list:
        print(movie)

import requests
from bs4 import BeautifulSoup

def get_movies():
    url = 'https://movie.douban.com/chart'
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    movies = []

    for item in soup.select('.item'):
        title = item.select_one('.title').text
        rating = item.select_one('.rating_num').text
        movies.append({'title': title, 'rating': rating})

    return movies

if __name__ == '__main__':
    movie_list = get_movies()
    for movie in movie_list:
        print(movie)

import requests
from bs4 import BeautifulSoup

def get_movies():
    url = 'https://movie.douban.com/chart'
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    movies = []

    for item in soup.select('.item'):
        title = item.select_one('.title').text
        rating = item.select_one('.rating_num').text
        movies.append({'title': title, 'rating': rating})

    return movies

if __name__ == '__main__':
    movie_list = get_movies()
    for movie in movie_list:
        print(movie)

4. 使用Scrapy抓取网页数据

4.1. Scrapy简介

Scrapy是一个功能强大的爬虫框架，适合进行大规模数据抓取和处理。它提供了许多高级特性，如异步处理、请求调度和数据管道等。

4.2. 创建Scrapy项目

我们可以使用Scrapy命令行工具创建一个新的爬虫项目：

scrapy startproject douban_movies

scrapy startproject douban_movies

scrapy startproject douban_movies

scrapy startproject douban_movies

这将创建一个名为 douban_movies的文件夹，里面包含项目的基本结构。

4.3. 编写爬虫

在项目中，我们需要创建一个新的爬虫文件，比如 douban.py，并实现爬虫的逻辑。

4.3.1. 编写爬虫代码

在 spiders目录下创建 douban.py文件，内容如下：

import scrapy

class DoubanSpider(scrapy.Spider):
    name = 'douban'
    start_urls = ['https://movie.douban.com/chart']

    def parse(self, response):
        for item in response.css('.item'):
            yield {
                'title': item.css('.title::text').get(),
                'rating': item.css('.rating_num::text').get(),
            }

import scrapy

class DoubanSpider(scrapy.Spider):
    name = 'douban'
    start_urls = ['https://movie.douban.com/chart']

    def parse(self, response):
        for item in response.css('.item'):
            yield {
                'title': item.css('.title::text').get(),
                'rating': item.css('.rating_num::text').get(),
            }

import scrapy

class DoubanSpider(scrapy.Spider):
    name = 'douban'
    start_urls = ['https://movie.douban.com/chart']

    def parse(self, response):
        for item in response.css('.item'):
            yield {
                'title': item.css('.title::text').get(),
                'rating': item.css('.rating_num::text').get(),
            }

import scrapy

class DoubanSpider(scrapy.Spider):
    name = 'douban'
    start_urls = ['https://movie.douban.com/chart']

    def parse(self, response):
        for item in response.css('.item'):
            yield {
                'title': item.css('.title::text').get(),
                'rating': item.css('.rating_num::text').get(),
            }

4.4. 运行爬虫

我们可以通过以下命令运行爬虫，并将结果保存到JSON文件中：

scrapy crawl douban -o movies.json

scrapy crawl douban -o movies.json

scrapy crawl douban -o movies.json

scrapy crawl douban -o movies.json

5. 数据存储

在爬虫抓取数据后，我们通常需要将数据存储到数据库或文件中。Scrapy提供了数据管道（Item Pipeline）来处理数据存储。我们可以在 settings.py中配置管道，使用SQLite或MongoDB等数据库进行存储。

6. 处理反爬虫机制

许多网站都有反爬虫机制，比如IP封禁、用户代理检查等。我们可以通过以下方式来绕过这些限制：

6.1. 设置用户代理

在Scrapy的设置中，我们可以自定义用户代理：

USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36'
1'运行运行

USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36'
1'运行运行

USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36'
1'运行运行

USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36'
1'运行运行

6.2. 设置代理IP

使用代理IP可以有效防止IP封禁，Scrapy也支持在请求中设置代理。

7. 实践：爬取多个页面

在实际应用中，我们往往需要爬取多个页面的数据。我们可以在Scrapy中使用 start_requests方法来实现这一点。

7.1. 修改爬虫代码

修改 DoubanSpider中的 start_requests方法，实现分页抓取：

def start_requests(self):
    for page in range(0, 10):  # 抓取前10页
        yield scrapy.Request(url=f'https://movie.douban.com/chart?start={page * 10}', callback=self.parse)
123'运行运行

def start_requests(self):
    for page in range(0, 10):  # 抓取前10页
        yield scrapy.Request(url=f'https://movie.douban.com/chart?start={page * 10}', callback=self.parse)
123'运行运行

def start_requests(self):
    for page in range(0, 10):  # 抓取前10页
        yield scrapy.Request(url=f'https://movie.douban.com/chart?start={page * 10}', callback=self.parse)
123'运行运行

def start_requests(self):
    for page in range(0, 10):  # 抓取前10页
        yield scrapy.Request(url=f'https://movie.douban.com/chart?start={page * 10}', callback=self.parse)
123'运行运行

8. 数据清洗和分析

抓取到的数据往往需要进行清洗和分析。我们可以使用Pandas库来处理数据，进行数据清洗、统计分析和可视化等操作。

8.1. 安装Pandas

使用以下命令安装Pandas库：

pip install pandas

pip install pandas

pip install pandas

pip install pandas

8.2. 数据清洗示例

以下是一个简单的数据清洗示例：

import pandas as pd

# 读取抓取的数据
data = pd.read_json('movies.json')

# 数据清洗
data['rating'] = data['rating'].astype(float)  # 将评分转为浮点数
cleaned_data = data.dropna()  # 删除缺失值

# 打印清洗后的数据
print(cleaned_data)

import pandas as pd

# 读取抓取的数据
data = pd.read_json('movies.json')

# 数据清洗
data['rating'] = data['rating'].astype(float)  # 将评分转为浮点数
cleaned_data = data.dropna()  # 删除缺失值

# 打印清洗后的数据
print(cleaned_data)

import pandas as pd

# 读取抓取的数据
data = pd.read_json('movies.json')

# 数据清洗
data['rating'] = data['rating'].astype(float)  # 将评分转为浮点数
cleaned_data = data.dropna()  # 删除缺失值

# 打印清洗后的数据
print(cleaned_data)

import pandas as pd

# 读取抓取的数据
data = pd.read_json('movies.json')

# 数据清洗
data['rating'] = data['rating'].astype(float)  # 将评分转为浮点数
cleaned_data = data.dropna()  # 删除缺失值

# 打印清洗后的数据
print(cleaned_data)

9. 总结

通过本文的学习，我们了解了如何使用BeautifulSoup和Scrapy两个强大的工具来抓取网页数据。BeautifulSoup适合快速、小规模的数据抓取，而Scrapy则更适合大规模、复杂的网站抓取。掌握这两种工具可以帮助我们更高效地进行数据获取与分析。

在实际开发中，我们还需注意网站的Robots协议，确保我们的爬虫行为不违反网站的使用条款。此外，反爬虫机制的处理也是爬虫开发中需要重点关注的内容。

二、requests常用语法
1、基本请求方法，包含参数传递
（1）get参数传递，示例：

url=“xxxxx”
xx={
"xxx":"xx"
"xxxxx":1
}
r=requests.get(url，params=xx)
print(r.text)#解析返回结果并打印出来

（2）post参数传递，示例：

url=“xxxxx”
xx={
"xxx":"xx"
"xxxxx":1
}
r=requests.post(url，data=xx)
print(r.text)#解析返回结果并打印出来
print(r.json())#josn格式打印出来，适用于返回是json内容

（3）文件传输，示例：

url=“xxxxx”
data1={
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
}
filexxxx ={
"filexxxxxxxx":open('xxx.jpg','rb')#文件内容根据实际路径修改
}
r=requests.get(url，data=data1，files=filexxxx)
print(r.text)#解析返回结果并打印出来

（4）断言，示例：

url=“xxxxx”
xx={
"xxx":"xx"
"xxxxx":1
}
r=requests.get(url，params=xx)
print(r.text)#解析返回结果并打印出来
assert r.status_code == 200#断言操作，将响应值与200作对比

（5）获取token值并传入需要用到的地方，示例：

url1 = "https://xx.xx/xx/xx/2.1.0/token/sign"
r1=requests.post(url1)
t = r1.json()["token"]#返回结果是json，只取json（）内容里token值并赋值到t中

上图可以看出r1.json（）返回的内容还有别的参数

三、实例

import random
import requests
def test_zhuce():
url = "https://xx.xx/xx/xx/2.0.0/visitor/insert/user/"
url1 = "https://xx.xx/xx/xx/2.1.0/token/sign"
r1=requests.post(url1)
t = r1.json()["token"]
b=random.randint(1,100000)
date = {
"companyId" : "a9a4828204054088bb520df1e1d5b69f",
"deadLineTime": "2020-10-22T16:00:00.000Z",

"fields": "[{\"fieldName\":\"code\",\"fieldType\":9,\"fieldValue\":\"C:\Users\Administrator\aaaaa.jpg\",\"fieldId\":999}]",

"groupId": "aab59cf9edb542e7a2e9e6d415ae311b",
"headPath":"/Z",#照片路径，我这边是直接获取以前上传过的照片路径，取服务器端的值，你可以自己使用文件上传的方式上传你的照片，采用上面的二中的（3）方法
"msToken": t,
"name": "接口注册%d"%b,
"propertyId": "f8ff8ea63c3440eb85b81cbccacddef0",
"registerType":1,
"userType": 2
}

header = {

#

}

r2=requests.post(url,files=file)

print(r2.json())

r = requests.post(url, data=date)

r=requests.post(url)

print('\n'"状态：",r.text)
print('\n'"头部信息：",r.headers)
print('\n'"cookie信息：",r.cookies)
print('\n'"token信息：",t)

assert r.status_code == 200

运行运行
注意：
当后端返回结果为415状态时，“status”:415,“error”:“Unsupported Media Type”,如下问题：

注意查看代码中的url是否正确，可适当对后面的路径进行删除修改！！！

通过继承unittest.TestCase来创建一个测试用例。

2、 Doctest
doctest 模块会搜索那些看起来像交互式会话的 Python 代码片段，然后尝试执行并验证结果.即使从没接触过 doctest，我们也可以从这个名字中窥到一丝端倪。“它看起来就像代码里的文档字符串（docstring）一样” 如果你这么想的话，就已经对了一半了。

3、pytest
pytest是python的一种单元测试框架，与python自带的unittest测试框架类似，但是比unittest框架使用起来更简洁，效率更高。根据pytest的官方网站介绍，它具有如下特点： ①非常容易上手，入门简单，文档丰富，文档中有很多实例可以参考 ②能够支持简单的单元测试和复杂的功能测试 ③支持参数化 ④执行测试过程中可以将某些测试跳过，或者对某些预期失败的case标记成失败 ⑤支持重复执行失败的case ⑥支持运行由nose, unittest编写的测试case ⑦具有很多第三方插件，并且可以自定义扩展 ⑧方便的和持续集成工具集成

4、Nose
Nose是对unittest的扩展，使得python的测试更加简单。nose自动发现测试代码并执行，nose提供了大量的插件，比如测试输出的xUnitcompatible，覆盖报表等等。

nose的详细文档： https://nose.readthedocs.org/en/latest/

5、tox
最大的特色，是自动最测试环境的管理以及使用多个解析器配置进行测试。

tox的详细文档： http://testrun.org/tox/latest/

6、Unittest2
是unitest的升级版。对API进行了改善以及更好的诊断语法。

unittest2的详细文档：https://pypi.python.org/pypi/unittest2

7、mock unittest.
mock是用来测试python的库。在python3.3版本以后，这个是一个标准库。对老版本来说，使用pip install mock进行安装。

mock的精髓在于，你可以使用模拟的对象来替代你的系统的一部分，然后验证后续的执行是否正确。mock的详细文档：http://www.voidspace.org.uk/python/mock/

结语
也就是说，如果你对自动化测试有你的期望值，那么就肯定是要付出相应的代价和精力的。好的东西也是需要优秀的人花大量的时间去完成的。在正式进入到自动化测试的领域之前，先要建立这样的价值观才能在软件测试这条路上走的更远。

看完上述内容，你们掌握7个超实用的Python自动化测试框架分别是什么的方法了吗？如果还想学到更多技能或想了解更多相关内容，关注我不迷路哦。

主要有以下几个特点：

简单灵活，容易上手；
支持参数化；
能够支持简单的单元测试和复杂的功能测试，还可以结合selenium、requests做自动化测试；
pytest具有很多第三方插件，并且可以自定义扩展。
安装：pip install pytest

官方文档：https://docs.pytest.org

2.第一个pytest用例
def test01():
assert 1 == 1
3.pytest命名规范
测试模块：以 test 开头命名，如：test_login.py，或以 _test 结尾；

测试类：必须以Test开头命名，且测试类中不能有 init 方法；

测试方法/测试函数：必须以test开头。

4.常用参数
可以通过pytest -h来查看所有可用参数。pytest的参数有很多，下面是归纳一些常用的参数：

无参数：读取路径下符合条件的所有类、函数、方法全部执行；
-v：打印详细运行日志；
-s：输出调试信息，包括print打印的信息；命令行输入：pytest -s;
-x：运行用例失败立即停止运行

–maxfail
用例失败数达到某个设定的值停止运行
pytest --maxfail=[num]

-m 运行所有@pytest.mark.[标记名] 标记的用例

比如：用例标记 @pytest.mark.high

pytest -m=hign 或者 pytest -m hign。# 表示只执行有此标记hight的case。

pytest -m="hign or smoke" 或者 pytest -m "hign or smoke" # 表示两种标记都执行

–reruns=num：失败用例重跑num次。需要安装 pytest-rerunfailures 插件模块。

-n参数，启用多线程或分布式运行测试用例。需要安装pip install pytest-xdist 插件模块。
命令行输入：pytest -vs -n=2

-k： 指定运行某个或某些用例
pytest -k ‘类名’
pytest -k ‘方法名’
pytest -k ‘类名 and not 方法名’ # 运行类里所有方法，不包含某个方法
命令行输入：pytest -vs -k=01

python程序运行pytest：

caseNameString = " or ".join(caseNameList)
cmd = f"python -m pytest -k \"{caseNameString}\" --alluredir ./allure --clean-alluredir"
os.system(cmd)
-k的值支持中文的哟~
参数-n，启用多线程或分布式运行测试用例。需要安装pip install pytest-xdist 插件模块。
命令行输入：pytest -vs -n=2

5.实现数据驱动
Pytest 测试框架的数据驱动是由 pytest 自带的pytest.mark.parametrize()来实现的。

@pytest.mark.parametrize() 装饰器接收两个参数：
第一个参数以字符串的形式存在，它代表能被测试函数所能接受的参数，如果被测试函数有多个参数，则以逗号分隔；
第二个参数用于保存测试数据。如果只有一组数据，以列表的形式存在，如果有多组数据，以列表嵌套元组的形式存在（例如： [1,1]或者[(1,1), (2,2)]）。

实例

class Test01:
@pytest.mark.parametrize('a,b,expect',[(1,1,1),(2,3,5)])
def test_001(self,a,b,expect):
print('测试a+b的结果')
assert a+b==expect

@pytest.mark.parametrize('c,d,expect', [(2, 4, 2), (9, 10, 1)])
def test_002(self,c,d,expect):
    assert d-c==expect

if name == 'main':
pytest.main([file, '-k','test_001'])
6.pytest fixtures
6.1 fixture用途

fixture主要用来做初始化环境以及测试结束后的数据清除。
pytest fixture与setup,teardown功能一样，但比之更加灵活，完全可以代替setup,teardown。
6.2 fixture参数详解

@pytest.fixture(scope='function',params=None,autouse=False,ids=None,name=None)
yield

fixture装饰器，相当于setup，测试用例的前置

• scope: 有四个级别参数'function（默认）'、'class'、'module'、'session'。
• params：一个可选的参数列表，列表中每个数据都可以作为用例的输入。也就说有多少数据，就会形成多少用例。可以通过request.param来获取该次调用的参数。
• autouse：如果True，自动调用fixture功能。如果为False则需要调用fixture。
• ids：每个字符串id的列表，每个字符串对应于params这样他们就是测试ID的一部分。如果没有提供ID它们将从params自动生成。
• name：fixture的名称。这默认为装饰函数的名称。如果fixture在定义它的统一模块。
  yield：这个关键字之后的代码相当于teardown，测试用例的后置。

6.3 fixture的作用范围

fixture里面有个scope参数可以控制fixture的作用范围：session>module>class>function
-function：每一个函数或方法都会调用
-class：每一个类调用一次，一个类中可以有多个方法
-module：每一个.py文件调用一次，该文件内又有多个function和class
-session：是多个文件调用一次，可以跨.py文件调用，每个.py文件就是module

6.4 调用fixture的三种方法

方式1：函数或类里直接传fixture的函数名称

@pytest.fixture()
def test_fixture(self):
    print('\n用例开始执行fix1\n')
    yield
    print('\n用例执行结束fix1\n')

def test_a(self, test_fixture):
    print('runing')
    assert 1 == 1

方式2： 使用装饰器@pytest.mark.usefixtures()修饰需要运行的用例（可以叠加使用多个装饰器）

@pytest.fixture()
def test_fixture(self):
    print('\n用例开始执行fix1\n')
    yield
    print('\n用例执行结束fix1\n')

@pytest.fixture()
def test_fixture2(self):
    print('\n用例开始执行fix2\n')
    yield
    print('\n用例执行结束fix2\n')

@pytest.mark.usefixtures('test_fixture')
@pytest.mark.usefixtures('test_fixture2')
def test_b(self):
    assert 1==1

执行结果

7.skip – 跳过测试
7.1 pytest.skip() 用于函数内，跳过测试用例

@pytest.mark.parametrize('a,b,expect',[(1,1,1),(2,3,5)])
def test_001(self,test1,a,b,expect):
pytest.skip('跳过此测试用例')
assert a+b==expect
用于函数外，跳过测试用例

@pytest.mark.skip(reason="功能未实现")
@pytest.mark.parametrize('a,b,expect',[(1,1,1),(2,3,5)])
def test_001(self,test1,a,b,expect):
assert a+b==expect
用在函数外，条件condition为True时，跳过用例

@pytest.mark.skipif(condition=True,reason="功能未实现")
@pytest.mark.parametrize('a,b,expect',[(1,1,1),(2,3,5)])
def test_001(self,test1,a,b,expect):
assert a+b==expect

8.rerunfailure–失败重跑，插件pytest-rerunfailures
安装

前提条件： pytest (>=5.3) 和python >=3.6
安装：pip install pytest-rerunfailures
查看安装版本：pip show pytest-rerunfailures
pytest-rerunfailures 使用

命令行参数： --reruns n（重新运行次数）–reruns-delay m（等待运行秒数）
使用装饰器： @pytest.mark.flaky(reruns=5, reruns_delay=2)
命令行实例

!/usr/bin/env python3

!coding:utf-8

import pytest
import random

def test_simple_assume():

每次case运行的值为1或者2，具有随机性

r = random.randint(1, 3)
assert r == 1

if name == 'main':
pytest.main(['Test_demo01.py', '-v', '--reruns=2', '--reruns-delay 2'])
配置执行次数越多（如--reruns=2），执行的成功率越高。

命令行参数：
--reruns n（重新运行次数），--reruns-delay m（等待运行秒数）

9.Mark装饰器之order执行顺序
需要先安装插件

cmd命令窗口：pip install pytest-ordering
在pycharm中File-->settings-->Project-->Python Interpreter-->点击+号-->搜索pytest-ordering安装。

查看安装版本：pip show pytest-ordering

使用方法：

控制用例执行顺序的方法；
在需要调整用例执行顺序的函数（或方法）前增加，如@pytest.mark.run(order=x)，x表示数字；
执行顺序，由小到大、由正到负、未标记的在正数后、负数前执行，顺序为：1，2，3，无标记，-3，-2，-1；
实例

import pytest

class Test_Class3():
@pytest.mark.run(order=2)
def test_case1(self):
print("测试方法1")

@pytest.mark.run(order=1)
def test_case2(self):
    print("测试方法2")

@pytest.mark.run(order=3)
def test_case3(self):
    print("测试方法3")

if name == 'main':
pytest.main(['Test_demo02.py' '-s'])

10.setup、teardown
setup_class()和 teardown_class()函数
需要定义在测试类中，定义在类外不起作用。
setup_class()定义场景，比如：创建日志对象，创建数据库的连接，创建接口的请求对象等。
teardown_class()定义场景，比如：销毁日志对象，销毁数据库的连接，销毁接口的请求对象。
"""
函数需要定义在测试类中，定义在类外不起作用。
setup_method()和 teardown_method(),在每个测试方法之前/之后执行。定义场景，比如：打开浏览器/关闭浏览器。
setup_class()定义场景，比如：创建日志对象，创建数据库的连接，创建接口的请求对象等。
teardown_class()定义场景，比如：销毁日志对象，销毁数据库的连接，销毁接口的请求对象。
"""

import pytest

class Test_setUp_tearDown:

# 方法级，前置函数
def setup_method(self):
    # print("setup_method(self):在每个测试方法之前执行")
    print("在每个测试方法之前执行")

# 方法级，后置函数
def teardown_method(self):
    # print("teardown_method(self):在每个测试方法之后执行\n")
    print("在每个测试方法之后执行")

# 类级，前置函数
def setup_class(self):
    # print("setup_class(self)：每个测试类之前执行一次\n")
    print("每个测试类之前执行一次")

# 类级，后置函数
def teardown_class(self):
    # print("teardown_class(self)：每个测试类之后执行一次")
    print("每个测试类之后执行一次")

# 测试用例a
def test_a(self):
    print("test_a方法")
    assert True

# 测试用例b
def test_b(self):
    print("test_b方法")
    assert True

if name == 'main':
pytest.main()
pytest钩子函数

在pytest中，钩子函数是一种特殊的函数，用于在测试执行过程中的特定阶段插入自定义逻辑。pytest提供了许多内置的钩子函数，这些钩子函数允许您在测试的不同阶段进行自定义操作。以下是pytest中常用的钩子函数及其作用

1.作用在类以外的钩子函数
1 setup()/tear_down()
def setup(): print("这是一个setup")
def teardown(): print("这是一个teardown")
2 setup_module()/teardown_module()

    setup_module()：在测试模块开始之前运行，用于设置模块级别的资源或配置。可以在该钩子函数中执行一次性的模块设置。

    teardown_module()：在测试模块结束之后运行，用于清理模块级别的资源或配置。可以在该钩子函数中执行一次性的模块清理。

    def setup_module(self):
        print("这个是模块级别的setup_module")

    def teardown_module(self):
        print("这个是模块级别的teardown_module")

3 setup_function/teardown_function

每条用例执行前执行一次，不会作用于class中的test_case

    setup_function()：在每个测试函数开始之前运行，用于设置单个测试函数的资源或配置。可以在该钩子函数中执行每个测试函数的准备工作。

    teardown_function()：在每个测试函数结束之后运行，用于清理单个测试函数的资源或配置。可以在该钩子函数中执行每个测试函数的清理工作。      

    def setup_function()

        print("setup_function模块中每条用例执行前执行一次！")
    def teardown_function():
        print("teardown_function 模块中每条用例执行后执行一次！") 

2.作用在类中的钩子函数
setup_class()：在每个测试类开始之前运行，用于设置单个测试类的资源或配置。可以在该钩子函数中执行每个测试类的准备工作。

    teardown_class()：在每个测试类结束之后运行，用于清理单个测试类的资源或配置。可以在该钩子函数中执行每个测试类的清理工作。

    setup_method()：在每个测试方法开始之前运行，用于设置单个测试方法的资源或配置。可以在该钩子函数中执行每个测试方法的准备工作。

    teardown_method()：在每个测试方法结束之后运行，用于清理单个测试方法的资源或配置。可以在该钩子函数中执行每个测试方法的清理工作。

3.pytest_runtest_makereport 钩子函数
pytest_runtest_makereport 是一个重要的钩子，它在测试运行期间被调用，用于生成测试报告。通过覆盖这个钩子，你可以自定义测试报告的行为，例如在测试失败时执行某些操作，或者收集额外的信息。

示例

import pytest

@pytest.hookimpl(tryfirst=True, hookwrapper=True)
def pytest_runtest_makereport(item, call):

execute all other hooks to get the report object

outcome = yield
rep = outcome.get_result()

# we only look at actual failing test calls, not setup/teardown
if rep.when == "call" and rep.failed:
    # 自定义逻辑：当测试失败时的操作
    print(f"Test {item.name} failed")
    # 你可以在这里添加更多的逻辑，例如记录日志、发送邮件等

在这个示例中，我们使用 @pytest.hookimpl 装饰器定义了一个 pytest_runtest_makereport 钩子函数。参数 tryfirst=True 表示这个钩子应该尽可能早地被调用，而 hookwrapper=True 表示这是一个钩子包装器，它会先执行其他注册的钩子函数，然后执行自己的逻辑。

钩子详解

item：当前正在运行的测试项。
call：当前测试阶段（setup、call 或 teardown）。
rep：测试报告对象，包含测试的结果信息。
示例中的逻辑

outcome = yield：这部分代码使用 yield 来执行其他注册的钩子函数，并获取它们的结果。这是 hookwrapper 的典型用法。
rep = outcome.get_result()：获取测试报告对象。
条件判断：if rep.when == "call" and rep.failed: 检查当前阶段是否为测试执行阶段（而非 setup 或 teardown），并且测试是否失败。
自定义逻辑：在测试失败时执行自定义的逻辑，例如打印一条消息。
完整的插件示例

如果你需要将这个钩子放入一个插件中，可以创建一个 .py 文件（例如 my_plugin.py），并在其中定义这个钩子：

import pytest

class MyPlugin:
@pytest.hookimpl(tryfirst=True, hookwrapper=True)
def pytest_runtest_makereport(self, item, call):

execute all other hooks to get the report object

outcome = yield
rep = outcome.get_result()

    # we only look at actual failing test calls, not setup/teardown
    if rep.when == "call" and rep.failed:
        # 自定义逻辑：当测试失败时的操作
        print(f"Test {item.name} failed")
        # 你可以在这里添加更多的逻辑，例如记录日志、发送邮件等

def pytest_configure(config):
config.pluginmanager.register(MyPlugin(), "my_plugin")

def pytest_unconfigure(config):
plugin = getattr(config, "my_plugin", None)
if plugin is not None:
config.pluginmanager.unregister(plugin)
在这个示例中，我们定义了一个 MyPlugin 类，并在其中实现了 pytest_runtest_makereport 钩子。我们还在 pytest_configure 和 pytest_unconfigure 函数中注册和注销插件。

通过这种方式，你可以轻松地扩展 pytest 的功能，自定义测试报告的行为。

4 pytest_sessionfinish(session, exitstatus) 钩子函数
pytest_sessionfinish 是 pytest 提供的一个钩子（hook），它允许你在整个测试会话结束时执行一些操作。这个钩子在所有测试项运行完毕后被调用，但在此之前所有测试收集、设置（setup）、执行以及清理（teardown）都已经完成。这意味着你可以利用这个钩子来做一些总结性的工作，比如输出一些统计信息，关闭资源，清理环境等。

这个钩子有两个参数：

session: 一个 Session 对象，提供了对当前测试会话的信息访问。
exitstatus: 一个整数，表示测试会话的退出状态码。这可以用来决定脚本的退出状态，例如是否成功执行。
如何使用 pytest_sessionfinish

下面是一个简单的例子来展示如何使用 pytest_sessionfinish 钩子：

import pytest

def pytest_sessionfinish(session, exitstatus):

在这里添加你的逻辑

print("All tests have finished.")
print(f"Exit status: {exitstatus}")

你也可以根据 exitstatus 决定做一些不同的事情

if exitstatus == 0:
print("All tests passed.")
else:
print("Some tests did not pass.")
更复杂的用法

如果你想要创建一个插件，可以像这样定义 pytest_sessionfinish 钩子：

import pytest

class MyPlugin:
def pytest_sessionfinish(self, session, exitstatus):
print("All tests have finished.")
print(f"Exit status: {exitstatus}")

def pytest_configure(config):

注册插件

config.pluginmanager.register(MyPlugin(), "my_plugin")

def pytest_unconfigure(config):

清理插件

plugin = getattr(config, "my_plugin", None)
if plugin is not None:
del config.my_plugin
config.pluginmanager.unregister(plugin)
Session 对象

session 参数是一个 pytest.Session 实例，它提供了许多有用的方法和属性来访问关于测试会话的信息。例如，你可以使用 session.items 获取测试项列表，session.testsfailed 获取失败的测试数量，以及其他有用的统计信息。

Exit Status

exitstatus 是一个整数，表示测试会话的退出状态。常见的值包括：

0: 所有测试通过。
1: 测试失败或命令行选项无效。
2: 用户中断（Ctrl+C）。
5: 内部错误。
你可以根据这个状态码来决定后续的动作，例如发送通知或更新数据库的状态。

通过使用 pytest_sessionfinish 钩子，你可以确保在测试会话结束后执行一些必要的清理工作或通知操作。

pytest+allure测试报告(图文详解)
0.入口python文件执行pytest程序，并生成报告展示
os.system('python -m pytest --alluredir ./allure --clean-alluredir')
time.sleep(3)
os.system('allure serve ./allure')
说明：

    python -m pytest： -m使用pytest模块执行

   --alluredir ./allure：将测试结果保存到 allure目录中.(或者使用 --alluredir=./allure)，是pytest-allure-adaptor插件中的选项。

   --clean-alluredir：在保存测试结果之前先清理 allure 目录，是插件pytest-allure-adaptor 中的选项。

————————————————

                        版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/qadnkz/article/details/136333732

1. 不能完全取代手工测试。（自动化永远不能替代手工测试，只是提高测试效率）
2. 手工测试比自动化测试发现的缺陷更多，自动化测试不容易发现新的BUG。

GET请求和POST请求的区别：

1. GET请求一般是 从后台服务器上获取数据用于前端页面的展示（例如：看到列表页面等），POST请求是 向服务器传送数据（登录、注册、上传文件、发布文章）。什么时候用GET，什么时候用POST取决于开发。无论用POST请求还是GET请求，都能完成对数据的增删改查，分不同的请求方式更多的是一种约定。
2. GET请求的 请求参数是拼接在url后面的，只能以文本的形式传递参数，请求参数会显示在地址栏，数据长度受限于url的长度，传递的数据量小（4KB左右，不同浏览器会有差异），POST请求的 请求参数是放在request body里面，传递数据量大（默认8M），对数据长度也没有要求。GET请求可以在浏览器中直接访问，而POST请求只能借助工具完成（比如：postman、jmeter）。
3. GET请求速度快，安全性不高；POST请求一般用于像登录这种安全性要求高的场合，请求不会被缓存，也不会保留在浏览器的历史记录中。

前后端分离

开发模式

以前老的方式：

• 产品经理 / 领导 / 客户提出需求（提出文字需求）
• UI做出设计图
• 前端工程师做html页面（用户能看到的页面）
• 后端工程师将html页面套成jsp页面（前后端强依赖，后端必须要等到前端的html页面做好才能套jsp。如果html发生变更，就很麻烦，开发效率低）
• 集成出现问题
• 前端返工
• 后端返工
• 二次集成
• 集成成功
• 交付

新的方式：

• 产品经理 / 领导 / 客户提出需求（提出文字需求）
• UI做出设计图
• 前后端约定接口 & 数据 & 参数
• 前后端并行开发（无强依赖，可前后端并行开发，如果需求变更，只要接口 & 参数不变，就不用两边都修改代码，开发效率高）
• 前后端集成
• 前端页面调整
• 集成成功
• 交付

🤑通过F12打开浏览器开发者工具进行抓包，返回数据是json格式的就是前后端分离，返回时html页面就是没有前后端分离。

微服务的概念：

将大模块切分成小模块。减少代码的耦合度，从而降低模块与模块之间的影响。原先是一个jar包里面包含所有模块，改一个模块就有可能影响其他模块，现在是将一个一个的模块都打成一个一个的jar包，模块与模块之间的交互通过接口，哪个模块出了问题，只需要修改那个模块的jar包，避免因为修改一个模块的代码导致其他模块出错。

(2)Python requests框架讲解

接口自动化requests环境搭建

接口自动化核心库：requests

安装requests库的方法：

方法一：

命令行安装，打开cmd或者终端，输入以下命令：

方法二：
在pycharm中安装，settings --> Project --> Project Interpreter --> 点击“+”号 --> 输入request安装

测试环境是否ok

import requests

url_toutiao = “https://www.ixigua.com/tlb/comment/article/v5/tab_comments/?tab_index=0&count=10&group_id=6914830518563373581&item_id=6914830518563373581&aid=1768”

方式一：
result_toutiao = requests.get(url_toutiao)
方式二：
result_toutiao = requests.get(url=url_toutiao)

方式三：
result_toutiao = requests.get(
“https://www.ixigua.com/tlb/comment/article/v5/tab_comments/?tab_index=0&count=1&group_id=6914830518563373581&item_id=6914830518563373581&aid=1768”)
print(result_toutiao.json())
print(type(result_toutiao.json())) # <class ‘dict’>
result = result_toutiao.json()
print(result)
expect_result = “华晨金杯汽车花朵朵”
actual_result = result[“data”][0][“comment”][“user_name”]
print(actual_result)
if expect_result == actual_result:
print(“pass!”)
else:
print(“failed!”)

本质就是模拟get与post请求 安装 dos命令窗口

pip install requests

要是下载慢的话 在 pip install 包名 后面加上 -i + 镜像地址，这样 pip 安装时即可成倍的提速了 pip 安装时提速的格式如下：

pip install 包名 -i https://pypi.tuna.tsinghua.edu.cn/simple

国内主要镜像地址如下：

清华：

https://pypi.tuna.tsinghua.edu.cn/simple

阿里云：

http://mirrors.aliyun.com/pypi/simple/

中国科技大学:

https://pypi.mirrors.ustc.edu.cn/simple/

华中理工大学：

http://pypi.hustunique.com/

山东理工大学：

http://pypi.sdutlinux.org/

豆瓣：

http://pypi.douban.com/simple/

二、模拟get请求

模拟get请求

第一步导入requests模块

第二步模拟get请求

import requests

get()放法就是用来模拟get请求 url就是请求地址

reponse获取响应对象 对象名称 包含所有的响应信息

reponse= requests.get(url="http://192.168.0.17/phpwind" )

print(reponse.status_code) #响应状态码获取
print(reponse.reason) #响应信息获取
print(reponse.headers) #响应头部信息获取
print(reponse.text) #响应正文获取

三、模拟带参数的get请求

模拟带参数的get请求

import requests

方式一：把url参数写在请求地址后面

reponse=requests.get(url='http://192.168.0.17/phpwind/read.php?tid=2&fid=2')

print(reponse.text)

方式二：把url参数做成字典，然后在get()方法中 使用参数params传入字典

url_params={
"tid":2,
"fid":2

}
reponse=requests.get(url='http://192.168.0.17/phpwind/read.php',
params=url_params)
print(reponse.text)

四、解析json数据

pyhton处理json数据

在python中 字典类型的数据就是json的键值对形式 列表类型就是json数组形式

json数据 必须使用双引号""

import json

字符串和json数据的相互转换

str_01='{"name":"张三","age":20}'

str_01="" #json数据必须使用双引号 否则会报错

json_obj_01=json.loads(str_01) #loads 把字符串转换成json数据 前提字符串必须是json数据
print(json_obj_01)
print(type(json_obj_01))

json_obj_02 = {"name":"张三","age":20}

会自动把中文转换成unicode编码

str_02 = json.dumps(json_obj_02,ensure_ascii=False) #使用ensure_ascii会关闭自动转换
print(str_02)
print(type(str_02))

json数据解析

import jsonpath #jsonpath通用的json数据解析模块 java python 都有这个包
json_obj_03={"name":"张三","age":20}
value=jsonpath.jsonpath(json_obj_03,'$.name')[1]
print(value)

五、模拟post请求

模拟post请求编辑标签

import requests,j son,jsonpath

url aprams={"access token":"57135BrbDZbsPz0iM9LP4icmRRMuRubgXA- rBbKXkvE5HT4fqRT}

post_ data = {"tag" : {"id":103，"name" :“北京老帽”}}

先将json数据转换成字符串

post_ str = json.dumps(postdata,ensure ascii=False)

response = requests.post(url ="https:/ /api.weixin.qq.com/cgi-bin/tags/update",Darams= urL_ aprams,

json=post_ data #json必须传 json数据

利用data传入字符串数据 用encode('utf-8.)解决乱码格式

data=post_ str .encode('utf-8'))
print (response. text)

六、获取响应正文text/content/json()/raw

获取响应信息

响应行 响应头 响应正文

import requests
response=requests.get(url="http://www.baidu.com")
print(response.url) #获取url
print(response.headers) #.get() []去获取单独的头
print(response.encoding) #获取网页编码格式1

requests根据 响应信息头中的 charset 字段判断网页编码格式 如果没有该字段 则默认为ISO-8859-1 具体表现为乱码

print(response.apparent_encoding) #获取网页编码格式2

requests根据 响应正文中的 charset 进行获取网页编码格式

response.encoding=response.apparent_encoding

把响应正文的编码类型设置为由响应正文的charset字段获取

print(response.text) #以字符串文本的方式获取响应正文

以二进制的方式获取响应正文 (普通网页、下载文件、图片、视频等二进制文件 )

print(response.content.decode('utf-8'))

响应正文为二进制数据

import requests
from PIL import Image #pil操作图片
from io import BytesIO #字节流

response=requests.get(url="https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fimg.mp.itc.cn%2Fupload%2F20170719%2F2f4b26eebc3c4c63b25b7e98d65a0cb1_th.jpg&refer=http%3A%2F%2Fimg.mp.itc.cn&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1655610368&t=75ee6522d3101672a7ae0667b676c6e6")
img_bytes=BytesIO(response.content) #把获取的二进制图片对象转换成字节流
img_ogj=Image.open(img_bytes) #创建图像对象 打开字节流图片
img_ogj.save('test.png') #保存图片

响应正文为json数据

import requests,jsonpath
url_params={
"grant_type":"client_credential",
"appid":"wxb61e6693c7244793",
"secret":"c146872139641af2be50a94a01aee9a7"
}

response=requests.get(url="https://api.weixin.qq.com/cgi-bin/token"
,params=url_params)

如果已知道返回的数据格式是json格式的正文 可以直接返回json对象

json_body=response.json()
token_value=jsonpath.jsonpath(json_body,"$.access_token")[0]
print(token_value)

响应正文返回原始数据 raw 几乎不用

import requests

response=requests.get(url="https://www.baidu.com",stream=True)
print(response.raw.read(10)) #返回原始套接字内容

七、pil 操作图片
import requests
from PIL import Image #pil操作图片
from io import BytesIO #字节流

response=requests.get(url="https://gimg2.baidu.com/image_search/src=http%3A%2F%2Fimg.mp.itc.cn%2Fupload%2F20170719%2F2f4b26eebc3c4c63b25b7e98d65a0cb1_th.jpg&refer=http%3A%2F%2Fimg.mp.itc.cn&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=auto?sec=1655610368&t=75ee6522d3101672a7ae0667b676c6e6")
img_bytes=BytesIO(response.content) #把获取的二进制图片对象转换成字节流
img_ogj=Image.open(img_bytes) #创建图像对象 打开字节流图片
img_ogj.save('test.png') #保存图片

八、代理设置

requests 设置代理 必须有代理服务器打开

import requests

proxy_server={
"http":"http://127.0.0.1:8888",
"https":"https://127.0.0.1:8888"
}

response=requests.get(url="http://192.168.0.17/phpwind",
proxies=proxy_server)

带密码的代理 http://用户名:密码@127.0.0.1:8888

九、超时处理

超时设置

import requests

reponse = requests.get(url="http://192.168.0.17/phpwind",

timeout=0.001)#timeout 设置的是float 响应时间是响应超时设置

timeout=(0.05, 0.04)) # timeout 设置的是tuple

0.05是链接服务器超时时间 0.04表示响应超时时间设置

print(reponse.text)

十、重定向

requests 是默认支持重定向操作

import requests

allow_redirects 默认设置为true 支持重定向 true打开 false关闭

response=requests.get(url="http://www.360buy.com",allow_redirects=False)
print(response.history) #查看重定向过程
print(response.content.decode('utf-8'))

requests在模拟https请求时

如果要模拟的系统需要进行证书认证（极少网站）才能访问

那么此时汇报如下错误 SSL error

处理方式： 处理方式一：使用verifyFalse 忽略证书认证过程

新版本的urllib3 不支持 要使用方式一 需要降级urllib3

pip install urllib3==1.25.7
1
处理方式二：使用cert=证书路径 来解决

十一、自带的异常处理

requests自带的异常处理

Exception 是所有异常类的父类

RequestException 是requests 包 异常类的父类

import requests

from requests.exceptions import InvalidURL
from requests.exceptions import RequestException
try:
response = requests.get(url="https: //www.baidu.com")
except InvalidURL as e: #子--子
print('无效的url连接')
except RequestException as e: #子
print('请求异常，具体原因未知')
except Exception as e: #父
print('系统异常，具体原因未知')

print(response.text)

最后： 可以在公众号：伤心的辣条 ！ 自行领取一份216页软件测试工程师面试宝典文档资料【免费的】。以及相对应的视频学习教程免费分享！，其中包括了有基础知识、Linux必备、Shell、互联网程序原理、Mysql数据库、抓包工具专题、接口测试工具、测试进阶-Python编程、Web自动化测试、APP自动化测试、接口自动化测试、测试高级持续集成、测试架构开发测试框架、性能测试、安全测试等。

使用先决条件
在使用Robot Framework(RF)之前，您需要先安装Python 2.7.14及以上的版本。我推荐您使用Python 3.6.4，以确保适当的注释能够被添加到代码段中，并能够跟踪程序的更改。同时，您还需要安装Python包管理器–pip。

当然，您也必须下载相应的开发框架，例如：在开发者圈子里比较流行的PyCharm社区版。另外，由于其代码段本身并不依赖于任何IDE，因此您完全可以沿用手头既有的IDE工具。

优点
通过使用关键字驱动测试(keyword-driven-test)的方法，它能够帮助测试人员轻松地创建具有可读性的测试用例，进而简化了整个自动化的过程。
用户能够轻松地测试数据中的语法。
因为是由各种通用工具和测试库所组成，所以它不但拥有庞大的生态系统，而且可以在单独的项目中使用其各个元素。
由于拥有许多类型的API，因此该框架具有高度的可扩展性。
虽然并非内置功能，但是Robot可以通过Selenium Grid来帮助用户运行各种并行测试
缺点
虽然有着上述各种便利，但是Robot Framework在创建自定义的HTML报告方面比较繁琐。您顶多能用它来生成xUnit格式的简短报告。

另外，Robot Framework在并行测试方面也并不见长。

Robot的特点与竞品比较
由于Robot具有丰富的内置库，并能使用更为简单的面向测试的DSL(Domain Specific Language)，因此如果您是自动化测试领域的新手，并且缺乏开发经验的话，那么将它作为Python测试框架要比下面将要提到的Pytest或Pyunit，更容易上手一些。当然，如果您需要开发复杂的自动化框架，那么还请使用Pytest、或其他类型的Python框架。

2.Pytest
适用于多种软件测试的Pytest，是另一个Python类型的自动化测试框架。凭借着其开源和易学的特点，该工具经常被QA(质量分析)团队、开发团队、个人团队、以及各种开源项目所使用。鉴于Pytest具有“断言重写(assertrewriting)”之类的实用功能，许多大型互联网应用，如Dropbox和Mozilla，都已经从下面将要提到的unittest(Pyunit)切换到了Pytest之上。

使用先决条件
除了基本的Python知识，用户并不需要更多的技术储备。另外，用户只需要有一台带有命令行界面的测试设备，并且安装好了Python包管理器、以及可用于开发的IDE工具。

优点
过去，开发人员必须将他们的测试包含在各种大型的类中。如今，Pytest可以让用户写出更为紧凑的测试套件。
其他的测试工具会要求开发或测试人员使用调试器，或以日志检查的方式检测某个特定值的来源。而用户在用Pytest来编写测试用例时，完全可以将所有的值都存储在测试用例之中，直到再获悉有哪些值失败了、以及哪些值得到了断言。
由于涉及到的样板代码(boilerplate code)并不多，因此用户能够容易地编写和理解各种测试。
测试夹具(Fixture)函数常被用来向测试函数添加某个参数，并返回不同的值。在Pytest中，您可以通过使用一个夹具来模块化另外一个。同时，用户可以使用多个夹具，在无需重写测试用例的情况下，将测试覆盖到所有参数的组合。
Pytest开发人员通过发布各种实用插件，来保持框架的可扩展性。例如：pytest-xdist可以在不使用其他测试器的情况下，被用于执行并行测试。同时，单元测试也可以在无需复制任何代码的情况下，实现参数化。
通过为开发人员提供各种特殊的例程，它能够使得测试用例的编写更为简单、更不易出错，同时代码也会变得更短、更易被理解。
缺点
上述提及的特殊例程，也意味着用户必须放弃一定的兼容性。虽然方便了用户编写测试用例，但是这些用例却无法与任何其他的测试框架一起被使用。

Pytest的特点与竞品比较
就编写功能性测试用例和开发复杂的框架而言，Pytest胜过下面将要提到的UnitTest。不过，它和Robot Framework类似，仅适用于开发出简单的测试框架。

3.UnitTest/PyUnit
受到了JUnit启发的UnitTest/PyUnit，也是一种标准化的针对单元测试的Python类自动化测试框架。它的基类TestCase提供了各种断言方法、以及所有清理和设置的例程。因此，TestCase子类中的每一种方法都是以“test”作为名词前缀，以标识它们能够被作为测试用例所运行。用户可以使用load方法和TestSuite类来分组、并加载各种测试。

当然，您也可以通过联合使用，来构建自定义的测试运行器。正如我们使用Junit去测试Selenium那样，UnitTest也会用到UnitTest-sml-reporting、并能生成各种XML类型的报告。

使用先决条件
由于UnitTest默认使用了Python，因此我们并不需要什么先决条件。除了需要具备Python框架的基本知识，您也可以额外地安装pip、以及用于开发的IDE工具。

优点
开发人员并不需要安装任何其他的模块。
UnitTest是xUnit的衍生产品，其工作原理与其他xUnit框架十分类似。因此对于那些没有过硬Python背景的人来说，也能很快地上手。
用户能够以更为简单的方式运行单个测试用例。您只需在终端上预定好名称，该框架便可灵活地执行各种用例的测试，并产生精炼的输出。
它能够在几毫秒内生成各种测试报告。
缺点
虽然该框架常用snake_case来命名各种Python代码，但是由于它源自Junit，因此仍保留了一些传统的camelCase命名方法。这往往会让人产生混淆。

由于它过多地支持了抽象方法，因此造成了测试代码的目的有时不够清晰。需要大量的样板代码。

PyUnit的特点与竞品比较
和部分Python开发人员的观点相似，我认为：Pytest能够培养测试人员以非常紧凑的方式编写出更好的自动化代码，这一编程习惯。尽管UnitTest是Python默认的自动化测试框架，但是其工作原理、及命名规则仍与标准的Python代码略有不同。同时，它也需要太多的样板代码。因此该框架并不太受欢迎。

4.Behave
我们都知道：行为驱动开发(behavior-driven
development，BDD)，是一种基于敏捷软件开发的方法。它能够鼓励开发人员、业务参与者和QA人员，三者之间的协作。作为另一种Python测试框架，Behave允许团队避开各种复杂的情况，去执行BDD测试。从本质上说，该框架与SpecFlow和Cucumber非常相似，常被用于执行自动化测试。用户可以通过简单易读的语言来编写测试用例，并能够在其执行期间粘贴到代码之中。而且，那些被设定的行为规范与步骤，也可以被重用到其他的测试方案中。

使用先决条件
任何具备Python基础知识的人都可以使用Behave。其他先决条件还包括：

您必须先安装Python 2.7.14及以上的版本。

需要通过Python包管理器或pip来与Behave协作。

大多数开发人员会选择Pycharm作为开发环境，当然您也可以选用其他的IDE工具。

优点
由于系统行为使用了半正式(semi-formal)语言、以及域词汇表(domain
vocabulary)，因此Behave有助于在组织中保持一致性的行为。
让那些工作在不同模块上的开发团队，通过协调处理来具有类似的特征。
其构建的各个功能块能够执行各种测试用例。
由于具有更多值得用户推理和思考的细节，因此目标产品会具有更好的规范性。
根据类似的规范格式，它能够让项目经理和利益相关者，对开发团队和QA团队的输出具有更清楚地了解。
缺点
只适用于黑盒测试。

Behave的特点与竞品比较
Behave最适合于诸如简单Web测试之类的黑盒测试。但是，对于那些具有复杂场景的集成测试与单元测试而言，Behave并不是一个很好的选择。作为Behave的替代品，一些开发与测试人员会推荐使用pytest-bdd。该工具融合了Pytest的所有优点，并实现了各种行为驱动测试的场景。

5.Lettuce
Lettuce是另一种基于Cucumber和Python的行为驱动类自动化工具。Lettuce主要专注于那些具有行为驱动开发特征的普通任务。它不但简单易用，而且能够使得整个测试过程更流畅、甚至更有趣。

使用先决条件
您需要安装带有IDE的Python 2.7.14、及以上的版本。当然，您也可以使用Pycharm或任何其他IDE工具。同时，您还需要安装Python包管理器。

优点
和其他BDD测试框架类似，Lettuce能够让开发人员创建多个场景，并用简单的自然语言去描述不同的功能。
根据类似的规范格式，开发与QA团队能够协调共事。
对于黑盒测试而言，Lettuce非常适合于那些行为驱动的测试用例
缺点
为了成功地实现行为驱动测试，开发团队、QA人员以及利益相关者之间需要持续进行沟通。倘若缺乏此类沟通，则会产生流程模糊不清，并让团队遇到问题。竞品比较

在普通开发人员和自动化测试人员看来，Cucumber在执行BDD测试方面更为实用。而在Python开发和QA人员看来，Pytest-bdd才是的。Pytest的强大之处在于：其框架实现了紧凑且易于理解的代码，并能紧密地结合到行为驱动的测试之中。

，我们先说说框架吧，常用的Python自动化测试框架有Robot Framework、Pytest、UnitTest/PyUnit、Behave、Lettuce。软件测试的自动化在预设条件下运行系统或应用程序，评估运行结果，预先条件应包括正常条件和异常条件。自动化测试以人为驱动的测试行为转化为机器执行的一种过程。

实现软件测试自动化得用到一些Python自动化测试框架和工具，让我们看看都有哪些？

Web UI test automation Web UI 自动化
libraries 各种库

selenium webdriver - 浏览器自动化工具
splinter - 简单的web自动化工具，让元素定位，表单提交等更加容易
mechanize - 有状态可编程的浏览器
frameworks and wrappers 框架和封装
py.saunter - 有主见的自动化测试框架，使用了selenium RC和webdriver api
moz-web-qa - py.test的插件，为Mozilla的WebQA项目提供了额外功能
testutils sst - A web test framework that uses Python to generate functional browser-based tests.
wtframework - 让web测试可以配置的框架
holmium.core - Page Object及其他工具库支持
robotframework-selenium2library - Robot Framework的selenium扩展
gocept.selenium - selenium RC的API, 适合编写基于WSGI, Plone, Zope 2, ZTK, or Grok 应用的测试用例
webium - 基于python的一个Page Object实现
robotframework-anywherelibrary - Robot Framework的扩展库，使用selenium2测试web应用，使用appium测试移动应用
robotframework-pageobjects - 一个不错的Page Object实现，可以脱离robot framework单独使用。 具体看这里
elementium - 用jQuery风格的语法糖来实现浏览器的自动化测试用例
slickqa - slick-webdriver-python 项目是python selenium binding的一个封装
selene - Concise UI 测试用例，使用python实现支持Ajax,PageObjects和Widgets
hitch - 编写基于service的应用的测试用例
Needle - Needle是基于图片比对的测试工作，它可以对web应用的一部分进行截图，然后跟预期结果的图片进行比对
PyPOM - PyPOM是另一个Page Object库，适用于Selenium和Splinter测试
POM - POM是Page-Object-Model 微框架，目的是让Web UI测试更加简单，快速和有乐趣
websmith - Web测试的一套DSL
pages - 轻量的page object库和组建
widgetastic - RedHat UI widget 组建框架
navmazing - PageObjects based navigation from RedHat
nightwatch - 基于python和selenium的UI 自动化测试框架. 灵感来源于nightwatch.js
extensions 扩展：
webdriver_manager - 主要目的是让不同版本的浏览器driver管理起来更加方便

pytest_splinter - pytest spinter 和 selenium的集成

lettuce_webdriver - Selenium webdriver 的 lettuce封装

Browsermob Proxy - python的Browsermob Proxy封装

FireRobot - 一个Firefox的扩展,让你可以更高效的编写基于robot framework的selenium用例

pytractor - Python的selenium扩展，以便更好的测试angular.js应用

Selenium-Requests - 扩展 Selenium WebDriver类，包含了Requests库的一些功能，可以更方便的处理cookie和请求头

selenium-respectful - selenium的封装，可以并行访问站点

Mobile test automation 移动端自动化测试工具
appium - 开源的自动化测试框架，可以测试native/hybrid/mobile web应用。核心是基于webdriver协议进行了扩展
Winium.StoreApps - 开源的自动化测试用具，用来测试Windows Store应用，实现了Selenium Remote WebDriver
robotframework-androidlibrary - Robot Framework用来测试android应用的扩展库
robotframework-appiumlibrary - appium的RobotFramework扩展
robotframework-ioslibrary -Robot的ios测试扩展库
uiautomator - Android uiautomator的python封装, 支持 Android 4.1+
ATX - 智能机自动化测试工具. 支持 iOS, Android, WebApp 和游戏
Windows UI test automation Windows的UI测试工具
Winium.Desktop - 测试Windows应用(主要是基于WinForms和WPF平台)的自动化测试工具实现了Selenium Remote WebDriver协议
PyAutoGUI - 跨平台的GUI测试工具，支持通过python脚本控制键盘和鼠标
robotframework-autoitlibrary - Robot Framework的windows GUI测试扩展
autopy - 简单跨平台的GUI测试工具集
UISoup - 支持windows和MacOS平台的UI自动化(仅工作在x86平台)
pywinauto - 非常有python面向对象风格的GUI测试库，现已支持64位机器以及py2和py3
SikuliX - 基于OpenCV的 GUI 测试框架, 使用图片识别技术，支持python2.7
Unix \ Linux UI test automation
ldtp - 跨平台的linux GUI测试项目
fMBT - 支持多平台的python GUI测试库
SikuliX - 基于OpenCV的 GUI 测试框架, 使用图片识别技术，支持python2.7
MacOS UI test automation MacOS UI自动化测试工具
ATOMac - 通过Apple Accessibility API来测试Mac应用的python库
PyAutoGUI - 跨平台的GUI测试工具，支持通过python脚本控制键盘和鼠标
SikuliX - 基于OpenCV的 GUI 测试框架, 使用图片识别技术，支持python2.7
PS:这些都各有各的特点，自动化测试工具个人还是较喜欢这两个：

windows上网页用Selenium
移动app上用AirtestIDE

基本概念

字符集：是一个系统支持的所有抽象字符的集合，计算机中储存的信息都是用二进制数表示的。
字符编码（Character Encoding）：是一套法则，使用该法则能够对自然语言的字符的一个集合（如字母表或音节表），与其他东西的一个集合（如号码或电脉冲）进行配对。即在符号集合与数字系统之间建立对应关系，它是信息处理的一项基本技术。以计算机为基础的信息处理系统则是利用元件（硬件）不同状态的组合来存储和处理信息的。元件不同状态的组合能代表数字系统的数字，因此字符编码就是将符号转换为计算机可以接受的数字系统的数，称为数字代码。
常用的字符集合字符编码
常见字符集名称：ASCII字符集、GB2312字符集、BIG5字符集、GB18030字符集、Unicode字符集等。计算机要准确的处理各种字符集文字，需要进行字符编码，以便计算机能够识别和存储各种文字。
UTF-8（8-bit Unicode Transformation Format）是一种针对Unicode的可变长度字符编码（定长码），也是一种前缀码。它可以用来表示Unicode标准中的任何字符，且其编码中的第一个字节仍与ASCII兼容，这使得原来处理ASCII字符的软件无须或只须做少部份修改，即可继续使用。因此，它逐渐成为电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组（IETF）要求所有互联网协议都必须支持UTF-8编码。
有时我们看到页面上的乱码，可能就是字符集不一致导致的。
变量(variable)变量就是代表某个数据(值)的名称。python是一种动态类型语言，在赋值的执行中可以绑定不同类型的值，这个过程叫做变量赋值操作，赋值同时确定了变量类型。
静态类型语言是指在编译时变量的数据类型即可确定的语言，多数静态类型语言要求在使用变量之前必须声明数据类型，某些具有类型推导能力的现代语言可能能够部分减轻这个要求.
动态类型语言是在运行时确定数据类型的语言。变量使用之前不需要类型声明，通常变量的类型是被赋值的那个值的类型。

python中变量的定义

1、变量名可以包括字母、数字、下划线，但是数字不能做为开头。例如：name1是合法变量名，而1name就不可以。
2、系统关键字不能做变量名使用
3、除了下划线之个，其它符号不能做为变量名使用
4、Python的变量名是区分大小写的，例如：name和Name就是两个变量名，而非相同变量哦。
5、中文也能定义变量名，单实际当中不这样运用

python的数据类型

1）整型——int——数字
python有5种数字类型，最常见的就是整型int，例如：a = 123 或 b = -123 等号左边是变量名，右边是要赋的值

2）布尔型——bool——用符号==表示
布尔型是一种比较特殊的python数字类型，它只有True和False两种值，它主要用来比较和判断，所得结果叫做布尔值。例如：3==3 给出True，3==5给出False

3）字符串——str——用' '或" "表示
例如：URL='www.iplaypy.com'或者name="lijing"

4）列表——list——用[ ]符号表示
例如：num=[1,2,3,4]

5）元组——tuple——用( )符号表示
例如：（'d',300）

6）字典——dict——用{ }符号表示
例如：｛'name':'coco','country':'china'｝

实战演练

安装python，安装pycharm编码软件进行编码。

1、hello world！

python中输出函数print函数，字符串和数值类型的可以直接输出，如下

print('hello world')
print(1)
输出内容：

输出字符串内容可以用‘’，也可以用“”，当输出的字符串中包含‘’时，则字符串用“”；当输出的字符串中包含“”号时，则字符串用‘’；当输出的字符串中‘’和“”都包含时，则字符串用‘’‘ ‘’’来输出；如下

print("你真的很'帅'！")
print('你真的很"帅"！')
print(''''哇！'你真的很"帅"！''')
输出内容：

输出变量类型

x='hello world!'
print(x)
s=13
print(s)
l=[1,2,3,'p']
print(l)

格式化输出

输出的内容中包含定义的参数时，

name=input('请输入你的姓名：')
time='2017年12月19日'
print('%s欢迎光临！'%name)
输出内容

%字符：标记转换说明符的开始 ，s表示格式转换类型为字符串，f表示十进制浮点数，d表示带符号的十进制整数

当有两个输出参数的使用，在%(参数1，参数2)列出需要传参的参数名

name=input('请输入你的姓名：')
time='2017年12月19日'
print('%s欢迎光临！'%name)
print('%s欢迎光临！时间是：%s'%(name,time))
输出内容：