课程名称

计算机与Python程序设计基础

课程编号

0809000070

课程性质

公共基础课，必修课

学分

1.5

教学安排

总学时24。其中讲授 24学时，实验 0学时，上机 0 学时，实训 0 学时

授课时间：第 3周至第 14周

周学时

2

相关课程与环节

配套实验课《计算机与Python程序设计基础》30学时

基本情况

专业

建筑、土木工程、

交通运输、能动

年级

2022

班级

建筑类22-[5-8]班、土木工程22-[7-9]班、交通运输类22-[1-3]班、能动类22-[12-14]班

修读人数

478

授课对象分析

大一新生，具有简单的信息技术基础知识和计算机操作能力。

课程简介与要求

本课程为非计算机专业本科生第一门计算机公共基础课程，要求学生能掌握计算机硬软件理论知识与操作，并且掌握Python语言程序设计理论知识及应用。

课程目标

课程目标

支撑毕业要求指标点

与课程关联度

1.理解信息在计算机内的表示与存储方式，掌握计算机系统的基本组成

1. 掌握计算机的硬件结构与组成原理

高

2.掌握计算机基本工作方式（存储程序原理）

3.理解计算机各基本部件的功能与主要技术指标

4.掌握操作系统的发展及分类，了解操作系统的主要管理功能（进程管理、存储管理、设备管理）

2. 掌握操作系统的功能与其中一些重要概念

高

5.理解文件、目录与路径的概念、文件系统的工作方式

6.理解计算机存储体系及地址变换的概念；了解设备管理的基本概念及常见设备的工作方式

7.了解计算机新技术，包括人工智能、大数据、物联网和其他新技术。

3.了解计算机新技术

高

8.掌握程序设计基础知识和方法；熟悉Python语言的特点、数据类型和相关运算

4. 掌握程序设计的基本方法、编程技能与上机调试能力

高

9. 掌握程序的控制结构（顺序结构、选择结构、循环结构）

10. 掌握字符串、列表、元组、字典、集合常用数据结构的特点和使用方法

11. 综合应用各种数据结构和程序结构编制结构化程序；掌握某些常用的数值计算与非数值计算算法，具有根据给定算法编制程序的能力

5. 通过编程解决应用问题

中

12. 计算机等级证书

6. 职业技能资格证书

中

教学方法

以课堂讲授为主，线上网络教学为辅的教学方法

教学重点

与难点

【重点】

1. 计算机的基本工作原理及结构。

2.英文、数字、中文等在计算机中的表示方法

3. Windows的基本知识和基本操作

4. 文件夹和文件的管理

5. 计算机新技术

6. Python数据类型、运算符与表达式、数据类型判断与转换。

7. 常用内置函数、常用内置模块。

8. 赋值语句、数据的输入输出及输入输出中常用的控制格式。

9. 各种if语句的基本语法及其应用。

10. while循环和for循环语句基本语法及其应用，break、continue语句与else子句的应用。

11. 字符串的索引、切片、内置方法及其应用。

12. 列表、元组的赋值、分片、解析等专有操作。

13. 字典的访问、赋值等基本操作和常用方法；集合的比较运算。

【难点】

1. 计算机冯•诺依漫工作原理、指令和指令系统。

2. 各种进制的表达与相互转换

3. 操作系统的功能与类型、进程与程序的关系

4.数学公式转化为Python语言表达式的基本规则。

5.数据的输入输出及输入输出中常用的控制格式。

6.选择结构语法格式及基本应用。

7. for语句用法，break、 continue以及else语句的基本作用。

8.字符串搜索、拆分与组合等常用方法。

9.利用序列实现数据的排序和检索。

课程各教学环节内容与安排

知识单元

知识点

课内学时

教学方式

作业/测验

课外学习

计算机系统基础

计算机的发展、计算机类型、计算机基本工作原理、计算机硬件系统组成、数据在计算机中的表示

4

讲授

练习册P3-29

4学时

操作系统基础

操作系统概述、WIN操作系统

2

讲授

练习册P31-45

2学时

计算机新技术

人工智能、大数据、物联网、其他新技术

2

讲授

2学时

Python概述

Python的基本特征及程序开发环境

1

讲授

练习册P49-54

1学时

数据类型与常用内置对象

标识符与关键字、数据类型、变量、运算符与表达式、数据类型判断与转换、常用内置函数、常用内置模块

3

讲授

练习册P55-68

3学时

数据输入与输出

数据输入函数、输出函数、语句、顺序结构程序

2

讲授

练习册P69-81

2学时

程序控制结构

选择结构、循环结构

4

讲授

练习册P81-102

4学时

字符串和正则表达式

字符串、正则表达式

2

讲授

练习册P103-110

2学时

组合数据类型

列表、元组、字典、集合

4

讲授

练习册P111-130

4学时

考核项目

考核内容

考核方式

分值或占比

期末考试

课程教学内容

闭卷机试

80

小测验

各知识模块

随堂考试

10

课堂表现

出勤率和课堂参与度

考勤、课堂讨论、课堂展示等

10

推荐教材

1. 《大学计算机—互联网+（第5版）》.蒋加伏、孟爱国等.北京：北京邮电大学出版社, 2020.8

2.《Python程序设计基础》.蒋加伏、孟爱国等.北京：北京邮电大学出版社，2021.8

参考材料

1.《大学计算机基础（第五版）》，龚沛曾、杨志强等.北京：高等教育出版社，2013.4

2.《Python语言程序设计基础（第2版）》.嵩天等. 北京：高等教育出版社，2017.2

3.Wesley Chun著，孙波翔等译.《Python核心编程(第3版)》. 北京：人民邮电出版社，2016.5

课程资源

教务处网络教学综合平台http://pt.csust.edu.cn/meol/homepage/common/

Python123：https://www.python123.io/

廖雪峰的Python官网：https://www.liaoxuefeng.com/wiki/1016959663602400

教材分析与处理

（1）教材《大学计算机》只选取第1章、第2章和第8章的内容，教材中的其它章节如办公自动化、多媒体等属于学生课外自学内容。

（2）教材《Python程序设计》只完成第1~6章内容，该教材注重程序设计基础知识的深入浅出，案例丰富，难度适中。

（3）学校网络教学综合平台作为最重要的信息发布平台，可以发布上机作业、课后作业、布置随堂测试，同时还可以提供教学日历、教学大纲、教学课件、源代码、教学视频等供学生下载学习。

知识单元名称

1、计算机系统基础

课次

第1讲

授课类型

理论课√讨论课□实验课□习题课□其他□

学时

2

课程目标与要求

1.了解早期计算工具、早期计算机、现代计算机、微型计算机的发展及现在计算机研究的热点。

2.掌握计算机产品的分类。

3.掌握计算机的基本工作原理及微型计算机系统结构。

4.了解指令和指令系统、未来的新型计算机发展。

本单元重点

与难点内容

重点：计算机的基本工作原理及结构  

难点：计算机冯•诺依漫工作原理、指令和指令系统

教学内容

1、课程导入：课程的地位、教学目标、计算机等级考试介绍及考试大纲、课程内容、考核方式及配套课程介绍。

2.计算机的发展

（1）早期计算工具的发展

（2）早期计算机的发展：机械式计算机、机电式计算机、电子计算机

（3）现代计算机的发展：根据电子元件组成不同分为4个时代

（4）微型计算机的发展：第一台微型计算机、第一台16位PC机、中国第一台微机

3.计算机的类型

（1）计算机的分类

（2）大型计算机（中国的天河二号、神威太湖之光）、微型计算机、嵌入式系统

4.计算机的基本工作原理及结构

（1）计算机的基本工作原理：冯·诺依曼型计算机及其三个要素

（2）指令和指令系统

（3）微型计算机系统结构：以CPU为中心的控制中心分层结构，即 “1-2-3规则”。

（4）未来的新型计算机：摩尔定律、超导计算机、量子计算机（2017年中国研制成功）、光子计算机、生物计算机、神经网络计算机

教学过程设计：

教学方法及手段、课堂互动题设置、教学改革措施等

教学方法及手段：在多媒体教室进行课堂讲授。

教学改革措施：本次课可进行教学思政。中国的科学家们刻苦钻研、不怕困难，突破层层障碍，不断取得新的科学研究高地，这种吃苦耐劳的科研精神，将激励学生热爱祖国、热爱科学，让学生对中国的科技文化充满自信。

案例1：中国超级计算机“天河二号”2016~2015年连续六年蝉联世界计算机500强冠军，2016~2017年中国自主研制芯片的神威·太湖之光蝉联世界计算机500强冠军。

案例2：2017年中科院院士潘建伟团队研制的量子计算机实验机已大大超过当前的计算机运算速度。

作业与

思考题设置

理论作业：练习册P3-29

实践作业：网上搜索了解我国自主研发的量子计算机情况。

学习效果、学生反馈、反思改进措施等

使用PPT动画展示计算机的基本原理及结构，形象直观，重点突出，教学效果好。由于教室狭长，学生人数多，为增强教学效果，老师需要在教室内走动，对扩音设备维护要求高，经调整，学生对投影和音效满意。

备注

QQ群建设开展，学生管理团队创建。

知识单元名称

计算机系统基础

课次

第2讲

授课类型

理论课√讨论课□实验课□习题课□其他□

学时

2

课程目标与要求

1. 理解计算机软、硬件基本概念及相互关系。

2. 掌握计算机硬件系统的组成，及各种硬件设备的基本概念、功能其性能的主要技术指标。

3. 掌握中英文字符、数值数据在计算机中的表示方法，及各种进制的权值、运算规则、表达方式及相互转换的方法。

4、了解常见的计算机系统软件和应用软件。

本单元重点

与难点内容

重点：英文、数字、中文等在计算机中的表示方法

难点：各种进制的表达与相互转换

教学内容

1. 计算机硬件系统的组成

（1）中央处理器CPU

中央处理器（Central Processing Unit，简记CPU）是微型机硬件系统的核心部件，由运算器、控制器和一组寄存器组成，并集成在一个芯片上。运算器：它的核心部件是算术逻辑单元ALU（Arithmetic Logic Unit），是算术和逻辑运算的功能部件。

控制器：是计算机的神经中枢和指挥中心，它根据程序指令的要求，向其它各部件发出控制信息，控制其它各部件协调一致地工作。

衡量计算机性能的主要指标为运算速度，即计算机每秒钟执行的指令数。影响运算速度的主要因素为：CPU的主频、字长。

（2）主板

（3）存储器

（4）总线与接口

所谓总线（Bus），指的是连接微机系统中各部件的一簇公共信号线，这些信号线构成了微机各部件之间相互传送信息的公用通道。总线通常由地址总线、数据总线和控制总线三部分组成。

（5）输入输出设备：常见的输入设备有键盘、鼠标、光笔、扫描仪、麦克风、数码相机、触摸屏等。 常见的输出设备有显示屏、打印机等。

（6）微型计算机的主要技术指标

2. 数据在计算机中的表示

（1）数值数据的表示：十进制、二进制、十六进制、各种进制之间互相转换

（2）字符数据的表示：英文ASCII编码的规则、中文国标码和机内码规则

3.计算机软件的类型

（1）计算机软件的分类

（2）系统软件的基本类型：操作系统、数据库、程序语言、语言处理程序

（3）应用软件的基本类型：通用型、专门型

教学过程设计：

教学方法及手段、课堂互动题设置、教学改革措施等

教学方法及手段：在多媒体教室进行课堂讲授。

课堂互动题：有没有拆装过电脑主机？

教学改革措施：可进行教学思政。讲好中国龙芯故事，增强家国情怀和科技文化自信。中国科学院大学2019年录取通知书中有一枚龙芯三号实物芯片。介绍中国自主研制的通用CPU龙芯的发展过程，中国拥有自己的芯片，可以勇敢地对美国的科技封锁说“不”，这是多么令人自豪的事情。虽然龙芯与英特尔、AMD还有差距，但进步还是比较明显的。要相信中国芯必能走入世界。

作业与

思考题设置

理论作业：练习册P31-45

实践作业：在网络上搜索计算机配件，虚拟组装一台自己经济能力能承受的电脑，仔细了解各部件的型号、性能、特点，并与同等次其他产品比较，是否有国产品牌，组装出一台性价比高的电脑。

学习效果、学生反馈、反思改进措施等

本章主要介绍计算机硬件和软件系统的组成及数据在计算机中的表示（数字化），是本课程理论性最强的一章节，安排4课时也是很紧张的。如何在课内将数据在计算机中的表示（数字化）讲解清晰，需要老师把握好知识的脉络，做到重点突出，逻辑清晰，容易理解的知识可布置学生自主学习完成。

刚到校园，有很多的学生会配置个人电脑，而这一章中的硬件系统知识对于选购电脑是非常有用的。提供电脑配置和安装教学视频，鼓励学生浏览购买电脑网站或逛逛电脑城，多留心硬件的指标，将课本知识运用到实现中。接到学生来电咨询电脑配置的相关知识也是非常开心的。

备注

完成QQ群建设，大容量教学文件传群共享。

知识单元名称

操作系统基础

课次

第3讲（1）

授课类型

理论课√讨论课□实验课□习题课□其他□

学时

1

课程目标与要求

1. 理解操作系统定义、功能、类型、进程管理；

2. 掌握Windows操作系统的基本操作、文件管理、软件和硬件管理。

本单元重点

与难点内容

重点： Windows的文件夹和文件的管理

难点：操作系统的功能与类型、进程与程序的关系

教学内容

1、操作系统概述

（1）操作系统的基本概念：

操作系统是一组控制和管理计算机软硬件资源、为用户提供便捷使用计算机的程序的集合。操作系统身兼二职：“管家婆”和“服务生”。

操作系统的特征：并发性和共享性是操作系统的基本特征。

（2）操作系统的功能

处理机管理、存储器管理、设备管理、文件系统管理、接口管理。

（3）操作系统的类型

批处理操作系统、分时操作系统、实时操作系统、嵌入式操作系统、网络操作系统、分布式操作系统。

（4）进程管理

进程的概念：

进程是程序的一次执行过程，是一个具有独立功能的程序对数据集的一次执行。

并发性是操作系统最显著的特征，操作系统能同时执行多个程序，只是从宏观的角度来分析，微观上，程序是交替执行。这样必然产生一个争夺CPU时间的问题，那么CPU的时间片（通常不超过50ms)是如何划分的呢？就象内存以字节来划分一样，CPU是以进程为基本单位来进行时间分配的．

进程的特征：

动态性：进程有一定的生命期；

并发性：系统中可以同时有几个进程在活动；

独立性：进程是一个能够独立运行的基本单位；

异步性：进程按各自独立的、不可预知的速度前进

进程的状态和转化：执行状态、就绪状态、阻塞状态

2. Windows 7的基本操作

Windows 7的基本操作、启动、退出和死机处理、鼠标与键盘操作、桌面及其桌面图标、任务栏及其基本操作、使用“开始”菜单、使用窗口 、Windows 7文件管理、Windows 7的软硬件管理。

教学过程设计：

教学方法及手段、课堂互动题设置、教学改革措施等

教学方法及手段：在多媒体教室，边操作演示边讲解win操作系统的主要操作。

课堂互动题：一台裸机首先要安装的软件就是操作系统，同学们有用过哪些操作系统，有什么体会心得？

教学改革措施：进行教学思政，介绍中国国产的操作系统如华为鸿蒙系统、银河麒麟系统，了解国产操作系统的现状、生存环境及面临的问题。

作业与

思考题设置

理论作业：练习册上P31-45。

实践作业：为一台电脑安装操作系统、并添加安装应用程序如office办公软件、photoshop图像处理软件。

学习效果、学生反馈、反思改进措施等

出生于2000年后的学生们，对电脑是不陌生的，再也像早几年的学生如何开机关机都要老师教好几遍。调整教学内容适应学生新的需求是很必要的。

win7操作中的鼠标键盘等基本操作可以省略，而文件的显示与隐藏开关、截屏快捷链、控制面板中属性的设置等等改变操作系统环境的设置学生太多不懂，也很感兴趣。

布置课后安装应用软件也是很必要，督促学生通过课后的摸索提高计算机的操作能力。

备注

制定QQ群管理制度，为网络教学平台学习任务布置提供备用通道。

知识单元名称

计算机新技术

课次

第3讲（2）

授课类型

理论课√讨论课□实验课□习题课□其他□

学时

1

课程目标与要求

1、掌握人工智能技术、数据获取清洗挖掘技术及应用、物联网技术；

2、了解云计算技术、计算社会学、区块链技术等。

本单元重点

与难点内容

重点： 数据获取、清洗、挖掘及应用

难点： 大数据技术的应用

教学内容

1、人工智能

图灵测试、研究流派、深度学习、核心技术（计算机视觉、自然语言处理、活体细胞机器人）

2、大数据

大数据的特点、数据获取技术、数据清洗技术、数据挖掘技术、大数据应用案例

3、物联网

物联网技术特征、物联网关键技术、物联网应用案例

4、其他新技术

云计算技术、计算社会学、区块链技术

教学过程设计：

教学方法及手段、课堂互动题设置、教学改革措施等

教学方法及手段：在多媒体教室进行课堂讲授教学。

课堂互动题：请说说自己或身边人经历过的“智能”故事。

作业与

思考题设置

思考：大数据与Python语言之间的联系

学习效果、学生反馈、反思改进措施等

介绍新技术、新观念，扩充学生视野。鼓励学生参加 “听党话 跟党走 奋进新征程” Office作品大赛，提高学生思政水准，感受伟大的新时代。

备注

制定QQ群管理制度，为网络教学平台学习任务布置提供备用通道。

知识单元名称

Python概述；数据类型

课次

第4讲

授课类型

理论课□讨论课□实验课□习题课□其他□

学时

2

课程目标与要求

了解程序和程序设计的概念，重点掌握Python语言程序开发环境；

掌握Python程序语法元素，数字类型、运算、判断与转换等操作。

本单元重点

与难点内容

重点：Python数据类型、基本运算符、数学公式转化为Python语言表达式的基本规则。

难点：数学公式转化为Python语言表达式的基本规则。

教学内容

第1章 Python概述

1、Python语言特点、简单的Python程序

2、Python程序开发环境

第2章 数据类型与常用内置对象

1、标识符与关键字、命名规则、常量与变量、基本数据类型

2、运算符与表达式

3、类型判断与转换

教学过程设计：

教学方法及手段、课堂互动题设置、教学改革措施等

本课程以计算机投影教学为主。在讲授过程中，考虑到该课程注重动手、注重应用的特点，遵循深入浅出的原则，结合教材及教学大纲制作合适课堂教学的CAI课件，以灵活生动的方式讲述每次课的内容。对概念、原理的解释和描述尽可能地以日常生活所接触到的实际例子和图示加以对比说明，引导学生建立概念之间、原理之间以及应用之间的联系。

对于课程中的难点部分我们将在教学方法上采用启发式、讲解式、引导式、讨论式、提问式及计算机的演示等方式，讲授课程的重点和难点。

介绍编程的四个环节（算法、数据结构、语言工具和运行环境）和三重境界（工具，思维和应用），着重介绍计算机思维，突显“不忘初心，牢记使命”的重大意义。

作业与

思考题设置

练习册相关习题

学习效果、学生反馈、反思改进措施等

由于是面向全校的公共课，学生人数较多，为加强教学效果，在课堂讲授的同时，我们还通过网上教学互动平台 https://pt.csust.edu.cn 进行辅助教学。

采用多种答疑方式使学生掌握计算机与程序设计基础的重点内容，突破难点。学生可以利用课余时间浏览教材及多媒体课件内容，可以复习巩固所学的知识，加深对重点和难点的理解及掌握。

备注

知识单元名称

常用内置函数和模块

课次

第5讲

授课类型

理论课□讨论课□实验课□习题课□其他□

学时

2

课程目标与要求

掌握并能熟练运用常用内置函数和常用内置模块。

本单元重点

与难点内容

重点：转换函数，数学函数，import导入模块，math模块，random模块等。

难点：如何调用常用内置函数和模块。

教学内容

第2章 数据类型与常用内置对象

1、常用内置函数

2、常用内置模块

教学过程设计：

教学方法及手段、课堂互动题设置、教学改革措施等

本课程以计算机投影教学为主。在讲授过程中，考虑到该课程注重动手、注重应用的特点，遵循深入浅出的原则，结合教材及教学大纲制作合适课堂教学的CAI课件，以灵活生动的方式讲述每次课的内容。对概念、原理的解释和描述尽可能地以日常生活所接触到的实际例子和图示加以对比说明，引导学生建立概念之间、原理之间以及应用之间的联系。

对于课程中的难点部分我们将在教学方法上采用启发式、讲解式、引导式、讨论式、提问式及计算机的演示等方式，讲授课程的重点和难点。

本次课融入思政元素有将函数类比于群众，走群众路线，从群众中来，到群众中去，紧密团结和依靠群众，充分调动群众的积极性，推动社会主义事业的发展。

作业与

思考题设置

练习册相关习题

学习效果、学生反馈、反思改进措施等

由于是面向全校的公共课，学生人数较多，为加强教学效果，在课堂讲授的同时，我们还通过网上教学互动平台 https://pt.csust.edu.cn 进行辅助教学。

采用多种答疑方式使学生掌握计算机与程序设计基础的重点内容，突破难点。学生可以利用课余时间浏览教材及多媒体课件内容，可以复习巩固所学的知识，加深对重点和难点的理解及掌握。

备注

知识单元名称

数据的输入与输出

课次

第6讲

授课类型

理论课√讨论课□实验课□习题课□其他□

学时

2

课程目标与要求

(1)         掌握基本的输入输出方法

(2)         掌握程序与外部环境的交互，即程序从外部获得数据，并将结果输出到外部。

(3)         掌握顺序结构和数学表达式的书写。

本单元重点

与难点内容

重点： 掌握Python程序的控制台基本输入输出方法

难点：掌握Python程序的控制台基本输入输出方法

教学内容

基本输入输出方法

3.1 input函数

格式：变量= input(prompt)

功能：等待用户的输入，直到按下回车符结束，输入的内容以字符串类型赋值给右侧变量。

举例：

>>>x=input("请输入一个整数：")

请输入一个整数：290↙

>>>x

‘290’

>>> type(x)   

<class 'str'>

（1）参数prompt：提示信息字符串，可省略。如：x=input( )

（2）输入的数据自动转换成字符串类型str，所以变量x的值为字符串’290’。可用类型转换函数eval( )、int( )、float( )等实现类型的转换。如：

>>> x=eval(input(“请输入一个整数：”))

请输入一个整数：290↙

>>> type(x)

<class 'int'>

（3）不输入任何其它数据，直接按下回车，则返回一个空字符串。

3.2 print 函数

3.2.1 无格式输出

 格式：print(value1,value2,…,sep=’ ’,end=’\n’)

功能：输出各项参数value1,value2,…的值。

举例：

>>>print(“hi”)  

>>>print(12,34) 

print([7,8,9],end=" ")     

3.2.2 %符号格式化数据输出

1、%格式化输出一般格式 

print(“带%格式化操作符的字符串”%(数据项))

功能：输出字符串，字符串中带%的格式化操作符即是占位符又是格式化符，对后面的数据项逐一进行格式化后输出新的字符串。

举例：

>>> print("%e"%(0.001895))

1.895000e-03

字符串中除了%格式化操作符外，还可以包含普通字符，这些字符照原样输出。例如：

>>> str1="book"

>>> print("the length of %s is %d"%(str1,len(str1)))

说明：%格式化输出保留了浓浓的C语言痕迹，在python 3.0以后，该方法基本上不怎么使用。

3.2.3 format格式化数据输出

教学要求：重点掌握

基本格式如下：

 “{参数序号0~n: 格式控制标记}”.format(参数0,参数1,…,参数n)

基本功能：根据大括号{}中的参数序号0~n和冒号（：）后面的格式控制标记格式化format函数中相应序号的参数，格式化后的参数替换字符串中的{}后得到一个新的字符串。

举例：

>>> "恭喜{}：本次考试取得了{}分！".format("郑同学","100")

'恭喜郑同学：本次考试取得了100分！'

如果format函数中有n+1个参数，则字符串{}中的参数序号最大值为n，最小值为0。特别注意事项：

（1）{}中的参数序号可全部省略，则format函数中的参数按照出现顺序依次替换字符串中的{}，得到一个新的字符串。这时{}的个数与参数的个数必须相等，多个参数用逗号分隔。

（2）如果大括号{}里有参数序号，则按照序号与对应的函数参数替换。format函数参数序号从左至右依次递增：0、1、2…

>>> "恭喜{2}：语文{0}分，数学{1}分！".format("118","120","郑同学")

'恭喜郑同学：语文118分，数学120分！'

3）可以用关键字来代替参数序号，这时format函数参数也要添加关键字。

基本格式为：

“{key0~n: 格式控制标记}”.format(key0=参数0, key1=参数1,…, keyn=参数n)

举例：

>>>"恭喜{xm}：语文{yw}分，数学{sx}分！".format(yw="118",sx="120",xm="郑同学")

'恭喜郑同学：语文118分，数学120分！'

>>> "恭喜{xm}：语文{fs}分，数学{fs}分！".format(fs="120",xm="郑同学")

'恭喜郑同学：语文120分，数学120分！'

2、格式控制标记

字符串{}中的格式控制标记可指定参数替换时的填充字符、对齐方式、显示宽度、千位分隔符（,）、小数的精度、数据类型等格式。所有标记都是可选的，可单独使用也可组合使用，以冒号（:）开头。

格式控制标记一般形式如下：

{:<填充字符><对齐方式字符><宽度><,><精度><类型字符>}

>>> "{0}={0:f}={0:e}={0:%}".format(0.09)

'0.09=0.090000=9.000000e-02=9.000000%'

3.3 语句

程序是由一条条语句组成的，语句是用户向计算机发出的操作指令，一条语句经编译后产生若干条机器指令，最终完成一定的操作任务。

Python语句类型：

简单语句包括：表达式语句、赋值语句、import语句、pass空语句、return语句、break语句、continue语句等。

复合语句包括：if语句、while语句、for语句、try语句、with语句等。

3.3.1 语句书写规则

略

3.3.2 注释语句

略

3.4 顺序结构

顺序结构是指程序执行时按各语句出现的先后顺序依次执行

简单的顺序结构程序一般由三部分构成：数据的输入、数据的计算、数据的输出

数据的输入可利用赋值语句直接赋值，或者利用input函数接受用户从键盘的输入。

数据的计算

输出结果

【例3.11】输入一个三位数，要求把这个数的百位数与个位数对调

源程序如下：

m=int(input("请输入一个三位数："))

a=m//10                 #求百位数

b=(m//10)%10            #求十位数

c=m%10                 #求个位数

n=c*100+b*10+a          #重新组合对调后的数

print("百位和个位对调后的数为：%d"%n)

【例3.15】 已知三角形三条边的边长分别为a、b、c，h=(a+b+c)，则可计算三角形的面积，保留2位小数。

import math

a=eval(input("请输入三角形的边长a："))

b=eval(input("请输入三角形的边长b："))

c=eval(input("请输入三角形的边长c："))

h=(a+b+c)/2

s=math.sqrt(h*(h-a)*(h-b)*(h-c))        

print("当三角形三边长为：{}、{}、{}时，面积为：{:.2f}".format(a,b,c,s

向学生讲解Python程序从控制台输入数据和向控制台输出字符串的方法。

采用语法讲解、示例分析与实操演练相结合的方式讲授。

首先，从控制台获取输入字符串的函数input()，同时告诉学生input函数的返回值是字符串，无论你在控制台输入的数据表示是什么类型。若要真正得到期望的输入类型，则需要将字符串转换为对应类型，如int(str)转为整型，float(str)转为浮点等等；

其次，向学生介绍向控制台输出字符串使用print方法，语法为print(v1,v2,…,vN)。可以实现可变参数长度输出，并且其中一个变量可以是格式化字符串，即格式化规格序列%（变量元组），例如，print(“%d__%f” % (100, 0.99))，最后重点强调format格式化数据输出。

掌握Python程序的控制台基本输入输出方法是本课时的教学重点也是难点

介绍语句的书写规则,注释语句的方式和作用。

顺序结构通过举例和要求同学动手，达到掌握顺序结构和数学表达式的书写要求。

教学过程设计：

教学方法及手段、课堂互动题设置、教学改革措施等

首先，从控制台获取输入字符串的函数input()，同时告诉学生input函数的返回值是字符串，无论你在控制台输入的数据表示是什么类型。若要真正得到期望的输入类型，则需要将字符串转换为对应类型，如int(str)转为整型，float(str)转为浮点等等；

其次，向学生介绍向控制台输出字符串使用print方法，语法为print(v1,v2,…,vN)。可以实现可变参数长度输出，并且其中一个变量可以是格式化字符串，即格式化规格序列%（变量元组），例如，print(“%d__%f” % (100, 0.99))，最后重点强调format格式化数据输出。

掌握Python程序的控制台基本输入输出方法是本课时的教学重点也是难点

介绍语句的书写规则,注释语句的方式和作用。

以课堂讲授为主要手段，以动手实操为辅助手段。着重利用提问、思考、讨论等互动式、探索式教学方式达到知识教授的目的。利用多媒体课件中的图例演示基本概念、基本应用方法等，使学生加深印象，更便于理解，同时也便于加大课堂信息量。对难点的解决，主要采用图解、举例和实验的方法进行详细分析，对重点内容进行板书和实操. 顺序结构通过举例和要求同学动手，达到掌握顺序结构和数学表达式的书写要求

本次课融入思政元素有改革开放要结合中国实际，实事求是，坚持中国特色，循序渐进。

作业与

思考题设置

教材P84   一、选择题

教材P85   二、填空题

教材P86   三、编程题 1，2，5

学习效果、学生反馈、反思改进措施等

结合《计算机与Python程序设计基础实验》，通过编程实现相关问题理解程序控制结构内容的顺序结构部分，结合学生理论课、实验课反馈信息思考后续课程授课改进方式。

备注

知识单元名称

程序控制结构

课次

第7讲

授课类型

理论课√讨论课□实验课□习题课□其他□

学时

2

课程目标与要求

了解程序的基本结构，掌握程序的分支结构，运用if语句实现分支结构。

本单元重点

与难点内容

重点：关系运算符与逻辑运算符及其组成的具有逻辑值的表达式、使用if语句构成分支结构的基本方法和应用。

难点：关系表达是与逻辑表达式、二分支语句的格式及基本应用。

教学内容

第4章 程序控制结构

4.1 选择结构

4.1.1 单分支选择结构

4.1.2 双分支选择结构

4.1.3 多分支选择机构

4.1.4 选择机构嵌套

4.1.5 选择结构程序举例

教学过程设计：

教学方法及手段、课堂互动题设置、教学改革措施等

本课程内容以计算机投影教学为主。在讲授过程中，考虑到该课程注重动手、注重应用的特点，遵循深入浅出的原则，结合教材及教学大纲制作合适课堂教学的CAI课件，以灵活生动的方式讲述计算机基础知识和算法与Python语言程序设计的全部内容。

对概念、原理的解释和描述尽可能地以日常生活所接触到的实际例子和图示加以对比说明，引导学生建立概念之间、原理之间以及应用之间的联系。

本次课融入思政元素有共产主义理想是社会进步的正确选择，例：智能机器创造的财富如何分配才更加合理。

作业与

思考题设置

《Python程序设计基础（第2版）》P122 习题4

学习效果、学生反馈、反思改进措施等

结合《计算机与Python程序设计基础实验》，通过编程实现相关问题理解程序控制结构内容的选择结构部分，结合学生理论课、实验课反馈信息思考后续课程授课改进方式。

备注

无

知识单元名称

程序控制结构

课次

第8讲

授课类型

理论课√讨论课□实验课□习题课□其他□

学时

2

课程目标与要求

掌握程序的循环结构，运用for语句和while语句实现循环结构。

本单元重点

与难点内容

重点：使用while语句和for语句构成循环结构，使用break、continue与pass语句进行循环控制。

难点：for语句用法，break、 continue以及pass语句的基本作用。

教学内容

第4章 程序控制结构

4.2 循环结构

4.2.1 while循环语句

4.2.2 for循环语句

4.2.3 continue与break语句

4.2.4 else子句

4.2.5 循环嵌套

4.2.6 循环结构程序举例

教学过程设计：

教学方法及手段、课堂互动题设置、教学改革措施等

本课程内容以计算机投影教学为主。在讲授过程中，考虑到该课程注重动手、注重应用的特点，遵循深入浅出的原则，结合教材及教学大纲制作合适课堂教学的CAI课件，以灵活生动的方式讲述计算机基础知识和算法与Python语言程序设计的全部内容。

对概念、原理的解释和描述尽可能地以日常生活所接触到的实际例子和图示加以对比说明，引导学生建立概念之间、原理之间以及应用之间的联系。

本次课融入思政元素有用穷举、迭代和递归算法强调中国式现代化是社会的进步，是时代的召唤，社会主义和共产主义是历史的必由之路。

作业与

思考题设置

《Python程序设计基础（第2版）》P122 习题4

学习效果、学生反馈、反思改进措施等

结合《计算机与Python程序设计基础实验》，通过编程实现相关问题理解程序控制结构内容的循环结构部分，结合学生理论课、实验课反馈信息思考后续课程授课改进方式。

备注

无

知识单元名称

第五章 字符串和正则表达式

课次

第9讲

授课类型

理论课√讨论课□实验课□习题课□其他□

学时

2

课程目标与要求

1、字符串是程序中最常用的一种数据类型，字符串可以包含英文、中文等任何字符，在内存中以unicode编码存储，但是存储到磁盘中往往采用GBK或UTF-8等别的编码形式。本节重点要求掌握字符串的相关操作。

2、要求能够用正则表达式从文本中提取需要的数据。

本单元重点

与难点内容

重点： 字符串相关操作和正则表达式

难点： 字符串在内存中的存放形式

教学内容

5.1  字符串

5.1.1  字符串基本概念

1、字符串概述

字符串是指用单引号‘或双引号“或三个单引号或三个双引号括起来的任何字符。

str类型：Python 3.x字符串采用Unicode字符集的UTF-8编码

bytes类型：字节型，以b前缀的单引号或双引号表示，如：b'\xe4\xb8\xad\xe5\x9b\xbd'

2、Unicode字符集和编码

计算机数据编码类型：ASCII码、GB-2312汉字编码、GBK、BIG5等等。

Unicode标准编码：为了统一编码方案而设计

Unicode字符集有多种编码方案：

UTF-8（Python、Linux、HTML、浏览器等采用）

UCS-2：window和java支持

UTF-16（Windows、Java语言采用）

str和bytes之间可以通过decode() 和  encode()函数进行转换：

【例5-1】encode()和decode()方法转换

>>> verse="白日依山尽"

>>> byte=verse.encode("GBK")

>>> print("编码转换后",byte)

编码转换后 b'\xb0\xd7\xc8\xd5\xd2\xc0\xc9\xbd\xbe\xa1'

>>> print("解码后:",byte.decode ("GBK"))

解码后: 白日依山尽

5.1.2  索引和切片

1、索引

字符串是一个字符序列，字符序列中所有元素都有相应的编号或索引.

正向索引：从左往右从0开始递增，0、1、2……

反向索引：从右往左从-1开始递减，-1、-2、-3……

>>> words="Python"

>>> words[1]

'y'

2、切片

切片：截取字符串，取子串。

格式如下：

字符串[开始索引：结束索引：步长]

截取包含开始索引字符，不包含结束索引字符的子串，遵循“左闭右开”原则

开始索引：默认值为0；

结束索引：默认值为-1；

步长：默认为1。当步长>0时，正向切片，要求“起始索引号”<“终止索引号”；当步长<0时，反向切片，要求“起始索引号”>“终止索引号”

3、字符串连接

两个字符串可以拼接起来组成一个新的字符串。

>>> 'Hunan'+'Changsha'

'HunanChangsha

5.1.3  字符串内置方法

1、测试字符串

主要讲解isalnum( )、isalpha( ) 、isdigit( ) 、isidentifier( ) 、islower( ) 、isupper( ) 和isspace( )

例5-5】测试字符串案例。

>>> s = "长沙  欢迎您"

>>> s.isalnum( )

False

>>> p = "长沙欢迎您"

>>> p.isalnum( )

True

>>> "2018".isdigit( )

True

>>> "else".isidentifier( )

True

>>> "welcome".islower( )

True

>>> s.isspace( )

False

2、搜索子字符串

主要讲解find(s) 、rfind(s) 、count(substring)、endswith(s1) 和startswith(s1)

【例5-6】字符串搜索方法应用案例

>>> s = "welcome to Python"

>>> s . startswith("good")

False

>>> s . endswith("hon")

True

>>> s.find("come")

3

>>> s.rfind("o")

15

>>> s.count("o")

3

>>> s = "Beautiful is better than ugly."

>>> s.startswith("Be",5)

False

>>> s.startswith("Be",0,5)

True

3、分隔字符串

【例5-7】分隔字符串的函数应用案例

>>> s = " 苹果,樱桃,桔子,香蕉,荔枝"

>>> s1 = s.split(",")

>>> s1

[' 苹果', '樱桃', '桔子', '香蕉', '荔枝']

>>> s.partition(",")

(' 苹果', ',', '樱桃,桔子,香蕉,荔枝')

>>> s.rpartition(",")

(' 苹果,樱桃,桔子,香蕉', ',', '荔枝')

>>> s.rpartition("香蕉")

(' 苹果,樱桃,桔子,', '香蕉', ',荔枝')

>>> s = "2018-9-28"

>>> t = s.split("-")

>>> t

['2018', '9', '28']

4、删除字符串中的空格

【例5-8】删除字符串中空白字符的案例。

>>> s = "  刻苦学习!\t"

>>> s1 = s.lstrip( )

>>> s1

'刻苦学习!\t'

>>> s2 = s.rstrip ( )

>>> s2

'  刻苦学习!'

>>> s3 = s.strip( )

>>> s3

'刻苦学习!'

5、转换字符串

【例5-9】字符串转换案例。

>>> s='Hello World'

>>> s.lower()

'hello world'

>>> s.upper ()

'HELLO WORLD'

>>> s1='an exAmple of a sTring'

>>> s1.capitalize()

'An example of a string'

>>> s1.title()

'An Example Of A String'

>>> s= "this is string example. this is really string"

>>> s.replace('is','was')

'thwas was string example. thwas was really string'

>>> s='aedbacd'

>>> table=' '.maketrans('abcde','efghi')

>>> s.translate (table)

'eihfegh'

5.1.4  字符串应用案例

【例5-11】采用异或运算对字符串进行简单加密和解密。循环使用指定密钥

def crypt(source,key):

   from itertools import cycle

    result = ''

    temp = cycle(key)

    for ch in source:

        result = result+chr(ord(ch)^ord(next(temp)))

    return result

source = '长沙理工大学'

key = ' Yilao'

print("加密前：" + source)

encrypted = crypt(source, key)

print("加密后：" + encrypted)

decrypted = crypt(encrypted, key)

print("解密后：" + decrypted)

【例5-12】使用maketrans()和translate()方法实现凯撒加密和解密

import string

def kaisajiami(s,k):    #加密

  lower=string.ascii_lowercase

  upper=string.ascii_uppercase

  before=lower+upper

  after=lower[3:]+lower[:3]+upper[3:]+upper[:3]

  table=' '.maketrans(before,after)

  return s.translate(table)

def kaisajiemi(s,k):   #解密

    lower=string.ascii_lowercase

    upper=string.ascii_uppercase

    before= lower+upper

    after=lower[-3:]+lower[:-3]+upper[-3:]+upper[:-3]

    table=' '.maketrans(before,after)

    return  s.translate(table)

s=input("请输入加密数据：") 

t=kaisajiami(s,3)

print("加密")

print(t)

print("解密")

print(kaisajiemi(t,3))

5.2  正则表达式

5.2.1  正则表达式概述

正则表达：通常被用来检索、替换那些符合某个模式（规则）的文本。 正则表达式是一个特殊的字符序列，能检查一个字符串是否与某种模式匹配。

Python自带re 模块：匹配字符串的模块，提供了正则表达式操作所需要的功能

5.2.2  正则表达式语法

正则表达式是对字符串和特殊字符进行操作的一种逻辑公式，它是用事先定义好的一些特定字符及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

正则表达式的特殊字符由两部分组成： 1、元字符 2、反斜杠和普通字符

5.2.3  字符与转义字符

最基本的正则表达式由单个或多个普通字符组成，用来匹配字符串中对应的单个或多个普通字符

随着文本内容复杂度的增加，就需要采用元字符进行表示。正则表达式中的元字符有：^、$、*、、?、\、|、{ }、[ ]、( )，它们都有特殊的含义。

例如:

点号 . 表示匹配除换行符之外的任何单个字符

?表示匹配前面子表达式0次或多次

元字符如果需要作为普通字符使用，则需要进行转义处理

【例5-13】

>>> re.findall("Go","Good good God")

['Go', 'Go']

>>> re.findall("2\+2 = 4","ab2+2 = 4mn")

['2+2 = 4’]

【例5-15】多个正则表达式元字符进行组合。

>>> import re

>>> s = '1 12  123  1234 12345'

>>> re.findall( r'\b\d{3}\b' , s )

['123']

>>> re.findall( r'\b\d{2,4}\b' , s )

['12', '123', '1234']

5.2.4  正则匹配算法

1、贪婪和非贪婪

贪婪匹配是指正则表达式一般趋向于最大长度匹配。

如：在"abcaxc"字符串中，使用模式"ab.*c"，就可以匹配整个字符串。

一般情况下默认是贪婪模式

【例5-16】正则表达式的“贪婪”匹配案例

>>> s='绿油油金灿灿'

>>> re.findall(r'绿油*', s)

['绿油油']

>>> re.findall(r'油{1,}', s)

['油油']

正则表达式的非贪婪匹配：匹配到结果就行，取最少的匹配字符。

正则表达式进行“非贪婪”匹配时，当问号（？）出现在正则表达式量词部分之后，就表示非贪婪匹配。

Python中的量词有：量词{m,n}表示m到n个字符；量词“*”表示任意多个字符；量词“+”表示一个到多个字符；量词“？”表示0或1个字符。

【例5-17】正则表达式的“非贪婪”匹配案例

>>> re.findall(r'绿油*?', '绿油油金灿灿')

['绿']

>>> re.findall(r'绿油+?', '绿油油金灿灿')

['绿油']

2、正则表达式的分组

a+ 表示匹配1个或一个以上的a

a?表示匹配0个或1个a

多个字符进行重复：使用小括号"( )"来指定要重复的子表达式

例如：(abc)? 表示0个或1个abc ，这里一 个括号的表达式就表示一个分组 。

正则表达式还可以对前面出现过的分组再进行一次引用，使用默认的分组名称进行向后引用。\1,\2,\3…分别对应第一组、第二组、第三组等

【例5-19】在正则表达式里利用分组引用案例。

>>> s = '商量商量 见识见识 口口声声'

>>> p = re.compile(r'(\w)\1(\w)\2')

>>> print(re.findall(p,s))

[('口', '声')]

>>> p1 = re.compile(r'(\w\w)\1')

>>> re.findall(p1, s)

['商量', '见识']

【例5-23】分组引用案例

import re

s = '见识见识教训教训恋恋不舍'

p = re.compile (r'(\w+?)\1(\w+?)\2')

print("输出")

print(re.search(p,s))

>>>

< _sre.SRE_Match object; span=(0, 8), match='见识见识教训教训'>

【例5-24】匹配字符串中连续出现的两个相同的单词

import re

s = '大自然 天然 天然 优越环境'

p = re.compile(r'\b(\w+)\b\s+\1\b')

print(re.findall(p, s))

>>>

['天然']

5.2.5  re模块的常用方法

1、Python中的正则处理模块re

标准正则表达式模块：re

re模块的常用函数如表5-6所示。

2直接使用re模块中的方法

例5-26】在中英文字符串中提取中文。

>>> import re

>>> str1="Hello China 你好 中国 I have a dream 我有一个梦"

>>> result=re.findall(r'[\u4e00-\u9fa5]+', str1)

>>> print(result)

程序运行结果：

>>>

['你好', '中国', '我有一个梦']

3、使用正则表达式对象

【例5-28】查找字符串中的所有数字。

>>> import re

>>> pattern = re.compile(r'\d+')

>>> m1 =pattern.findall("每年10月1日是中国的国庆日")

>>> print(m1)

['10', '1']

>>> m2 = pattern.findall("农历8月15是中国的中秋节")

>>> print(m2)

['8', '15']

5.2.6  子模式扩展语法

学生自学

5.2.7  匹配选项编译标志 

学生自学

教学过程设计：

教学方法及手段、课堂互动题设置、教学改革措施等

以课堂讲授为主要手段，以动手实操为辅助手段。着重利用提问、思考、讨论等互动式、探索式教学方式达到知识教授的目的。利用多媒体课件演示基本概念、基本应用方法等，使学生加深印象，更便于理解，同时也便于加大课堂信息量。对难点的解决，主要采用举例和实验的方法进行详细分析，对重点内容进行板书。

字符串涉及众多函数和方法，要求学生能够望名知意并注意参数位置和意义，并随堂布置任务检查学生的学习情况。

python中正则表达式在相对晦涩难懂，如果用好了，会极大地提高文本数据处理能力。然而由于课时紧，只能采用以点带面的教学方法，重点突破几点，布置合适的内容和参考资料，通过课外练习和辅导达到掌握主要的方法和基本的正则表达式的应用。

本次课融入思政元素有字符串是由多个字符组成的数据单元，如何从多个字符串中提炼对决策有影响的数据——信息，需要使用正确的正则表达式。强调规则的重要性，强调规矩意识的重要性，强调两个确立的重要性。

作业与

思考题设置

Page145  习题2、5、6、8、12

学习效果、学生反馈、反思改进措施等

结合《计算机与Python程序设计基础实验》，通过编程实现相关问题理解字符串和正则表达式部分，结合学生理论课、实验课反馈信息思考后续课程授课改进方式。

备注

知识单元名称

组合数据类型（1）- 列表、元组

课次

10

授课类型

理论课√讨论课□实验课□习题课□其他□

学时

2

课程目标与要求

掌握组合数据类型列表、元组及操作

本单元重点

与难点内容

重点：序列的计算、拆分等通用操作；序列的赋值、分片、解析等专有操作。

难点：利用序列实现数据的排序和检索。

教学内容

6.1 列表

6.1.1 列表创建与删除

6.1.2 列表访问与切片

6.1.3 列表对象常用方法

6.1.4 列表常用内置函数

6.1.5 列表运算符

6.1.6 列表程序举例

6.2元组

6.2.1 元组与列表的区别

6.2.2 元组基本操作

6.2.3 元组程序举例

重点介绍列表对象的常用方法，列表对运算符和内置函数的支持，以及列表推导式和切片的用法，然后介绍元组的特点及其与列表的区别。

PPT、边讲边练

第十一讲      组合数据类型（1）- 列表、元组

一、教学目标

掌握组合数据类型列表、元组及操作。

二、本讲内容及时间分配

6.1 列表（70分钟）

6.1.1 列表创建与删除（10分钟）

6.1.2 列表访问与切片（10分钟）

6.1.3 列表对象常用方法（20分钟）

6.1.4 列表常用内置函数（10分钟）

6.1.5 列表运算符（10分钟）

6.1.6 列表程序举例（10分钟）

6.2元组（20分钟）

6.2.1 元组与列表的区别（2分钟）

6.2.2 元组基本操作（8分钟）

6.2.3 元组程序举例（10分钟）

三、讲义

组合数据类型（1）- 列表、元组（CH6）

板书：

1. 列表

（1）          列表的概念

（2）          列表创建与删除

讲解：

列表的概念

列表是包含若干元素的有序连续内存空间。在形式上，列表的所有元素放在一对方括号中，相邻元素之间使用逗号分隔。在Python中，同-一个列表中元素的数据类型可以各不相同，可以同时包含整数、实数、字符串等基本类型的元素，也可以包含列表、元组、字典、集合、函数以及其他任意对象。如果只有一对方括号而没有任何元素则表示空列表。

列表创建与删除

1.创建列表

（1）赋值法

使用赋值运算符“=”直接将一个列表赋值给变量。

格式如下：

<列表名>=[元素1，元素2，元素3，…]

说明：

列表的元素用方括号括起，元素之间以逗号分隔。

列表的元素可以是任何类型的对象，如数字、字符串、列表、元组和字典等。

例如：

>>>lst1=[1,2,3]                       

>>>type(lst1)      

<class 'list'>

>>>lst2=["one","two","three"]           

>>>lst3=['a','b','c']                     

>>>lst4=["张三",True,180, "李四",False,165]

>>>lst5=[[1,2],[3,4],[5,6]]               

>>>lst6=[]

1.创建列表
（2）函数法

通过list()函数将字符串、range、元组或其他可迭代对象类型的数据转换成列表。其格式如下：

<列表名>=list(字符串、range、元组或其他可迭代对象)

例如:

>>>lst7=list()      　　                 

>>>lst8=list("python")        

>>>lst8                                

['p', 'y', 't', 'h', 'o', 'n']

>>>lst9=list(range(1,10,2))                 

>>>lst9                                

[1,3,5,7,9] 

例6.1  创建一个计算机语言列表、一个字符串转换的列表和一个10以内（包括10）的偶数列表并输出。

程序代码如下：

langlist = ["python ", " java", " c " , " php "]　  

strlist=list(“我爱你中国”)                  

evenlist=list(range(0,11,2))                 

print(langlist,strlist,evenlist)　

#程序运行结果:

['python ', ' java', ' c ', ' php '] ['我', '爱', '你', '中', '国'] [0, 2, 4, 6, 8, 10]

2.删除列表

当一个列表不再使用时，可以使用del命令将其删除。格式如下：

 del  <列表名>

例如：

>>>lst=[2021,”2021”,[2021]]

>>>del lst   

例6.2 删除计算机语言列表langlist，并查看结果。

程序代码如下：

langlist = ["python ", " java", " c " , " php "]　

del langlist                          

print(langlist)　　　　　　　          

>>>                                      

NameError:name ‘langlist’ is not defined

板书：

1. 列表

（3） 列表访问与切片

（4） 列表对象常用方法

讲解：

6.1.2  列表访问与切片

1.列表的访问

列表是一个可变的、有序的序列。

序列是一个元素向量，元素之间存在先后关系，通过索引号进行访问。

索引有正向索引和反向索引：

在正向索引中，第一个元素索引号为0，第二个元素索引号为1，以此类推；

在反向索引中，最后一个元素索引号为-1，倒数第二个元素索引号为-2，以此类推。

序列的索引图

1.列表的访问

通过索引号引用序列中的元素。其格式如下：

<列表名>[索引号]

例如：

>>>lst=list("python")      

>>>lst[0]     

>>>lst[-1]     

>>>lst[-3]     

>>>lst[3]     

>>>lst['p']     

TypeError: list indices must be integers or slices, not str

>>>lst[6]                 

IndexError: list index out of range

例6.3输出计算机语言列表langlist中的元素c、最后一个元素和其中的字符”j”。

langlist = ["python", "java", "c" , "php"]   

print(langlist [2],end=' ')              

print(langlist [-1],end=' ‘)

print(langlist[1][0],end=' ‘)

#程序运行结果：c php j

例6.4将列表langlist中的所有元素输出。

程序代码如下：

langlist = ["python", "java", "c" , "php"]    　

for i in langlist:                          

      print(i)

#程序运行结果：

python

java

c

php

2.1.列表的切片

切片：截取列表中的任何部分得到一个新列表，或修改和删除列表中的部分元素，或来为列表对象增加元素。

格式如下：

<列表名>.[<起始索引号>:<终止索引号>:<步长>]

遵循“左闭右开”原则：包含左边“起始索引号”引用的元素，不包含右边“终止索引号”引用的元素；

起始索引号：缺省值0，表示从序列的第一个元素开始切片

终止索引号：缺省值-1，表示切片一直延伸到序列的结尾

步长：缺省为1。当步长>0时，表示正向切片，此时要求“起始索引号”<“终止索引号”，否则将得到一个空序列。当步长<0时，则表示反向切片，此时要求“起始索引号”>“终止索引号”。

切片操作可以截取列表中的任何部分得到一个新列表。

例如：

>>>lst=[2,4,6,8,10,12]      

>>>lst[::]                

[2,4,6,8,10,12]

>>>lst[::-1]

[12, 10, 8, 6, 4, 2]

>>>lst[::2]               

[2, 6, 10]

>>> lst[3:1:1]  

[]         

>>> lst[1:4:2]               

[4, 8]

>>>lst[5:2:-2]             

[12, 8]

>>>lst[0:10]               

[2, 4, 6, 8, 10, 12]

>>>lst[3:-5:-1]             

[8, 6]

>>>lst[3:-1]                

[8, 10]

切片操作可增加、修改和删除元素。

例如：

>>> lst=[2,4,6,8,10,12]

>>> lst[0:2]=[1,3]         

>>> lst

[1, 3, 6, 8, 10, 12]

>>> lst[:2]=[]            

>>> lst

[6, 8, 10, 12]

>>> lst[0:0]=[5]       

>>> lst

[5, 6, 8, 10, 12]

例6.5利用切片将列表langlist中的所有元素逆序，并输出在一行上。

程序代码如下：

langlist = ["python", "java", "c" , "php"]    　

lst= langlist[::-1]                         

for i in l:                             

   print(i,end=' ')             

#程序运行结果：

php c java python

例6.6 随机选择一个手机品牌（华为、小米、OPPO、苹果、三星）进行屏幕输出。

程序代码如下：

import random                            

brandlist=['华为','小米','OPPO','苹果','三星']   

random.seed(2)                           

i=random.randint(0,4)                      

name=brandlist[i]                          

print(name)         

#程序运行结果：  华为

6.1.3  列表对象常用方法

1.增加元素

增加列表元素有3个方法：

append()

extend()

insert()

这3个方法都属于原地操作，即处理后的数据替换原来的数据，不改变列表对象的内存地址。

（1）增加一个元素append()

向列表尾部增加一个元素。格式如下：

<列表名>.append(元素) 

例如：

>>>lst = [1,2,3]     

>>>id(lst)     

59804552       

>>> lst.append(4)              

>>> lst.append(['a','b'])          

>>> lst                       

[1, 2, 3, 4, ['a', 'b']]

>>>id(lst)                     

59804552

（2）添加多个元素extend()

extend()方法：在列表尾部添加多个元素。格式如下：

<列表名>.extend(元素列表)  

其中，元素列表若为字典，则将键(key)作为元素依次添加至原列表的末尾。

例如：

>>>lst=[1,2,3]               

>>>lst.extend('456')           

>>>lst.extend(['a','b'])         

>>>L=['789','10']      

>>>lst.extend(L)              

>>>lst        

[1, 2, 3, '4', '5', '6', 'a', 'b', '789', '10']

（3）插入元素insert()

insert（）方法：在指定位置插入元素，该位置后面的所有元素后移，列表的索引号加1。其格式如下：

<列表名>.insert(索引号，元素)

当索引号为正数且大于列表长度时在列表尾部追加元素，

当它为负数且小于列表长度的相反数时则在列表头部插入元素。

例如：

>>>lst=[1,2,3]      

>>>lst.insert(1,'one’) 

>>>lst.insert(-1,'two')     

>>>lst.insert(7,True)  

>>>lst.insert(-7,False) 

>>>lst    

[False, 1, 'one', 2, 'two', 3, True]

2.修改元素

更改列表里的元素格式如下：

<列表名>[索引号]=新的元素

例如：

>>>lst=[1,2,3]   

>>>lst[2]="three"    

>>>lst[-3]="one"     

>>>lst   

['one', 2, 'three']

3.删除元素

删除列表元素有3种方法：

pop()

remove()

clear()

del（）

都是原地操作，不改变列表对象的内存地址。

（1）删除指定位置元素pop()和del

① pop()方法

删除并返回指定位置的元素。格式如下：

<列表名>.pop(索引号)

索引号省略时，表示从列表末尾删除一个元素并返回该值。

>>> lst=[1,2,3,[4]]  

>>> lst.pop(1)   

2

>>> lst.pop(1)      

3

>>> lst.pop()   

[4]

② del命令

格式如下：

del  <列表名>[索引号]

>>> lst=[1]

>>> del lst[0]   

>>> lst    

[]

>>> lst.pop()        

IndexError: pop from empty list

（2）移除第一个匹配元素remove()

remove()方法可删除列表指定内容的元素，格式如下：

<列表名>.remove(元素)

检索是否存在要移除的内容，将遇到的第一个匹配项从列表中删除，并对其后面的元素重新编号。如果没有找到要匹配的项，则出现数值错误异常ValueError。例如：

>>>lst=[1,2,3,[4],1]         

>>>lst.remove(1)           

>>>lst.remove(4)           

ValueError: list.remove(x): x not in list

>>>lst.remove([4])         

>>>lst        

[2, 3, 1]

（3）清空列表元素clear()

用于清空列表中的所有元素。格式如下：

<列表名>.clear()

例如：

>>>lst=[1,2,3] 

>>>lst.clear()

>>>lst

[]

当列表增加或删除元素时，列表对象会自动进行内存的扩展或收缩。

但在列表中间位置增加或删除元素时，不仅效率较低，而且该位置后面所有元素在列表中的索引也会发生变化，因此应尽量从列表尾部进行元素的追加与删除操作。

例6.7  a和b是两个长度相同的列表变量，列表a为[3, 6, 9]，键盘输入列表b， 计算a中元素与b中对应元素的和形成新的列表c，在屏幕上输出。

程序代码如下：

a = [3,6,9]

b =  eval(input("请输入列表，例如[1,2,3]:"))  

c = [] 

for i in range(3):           

    c.append(a[i]+b[i])    

print(c) 

#程序运行结果

请输入列表，例如[1,2,3]:[1,2,3]

[4, 8, 12]

例6.8  a和b是两个列表变量，列表a为[3, 6, 9]，键盘输入列表b，将a列表的三个元素插入到b列表中对应的三个元素的后面，并显示输出在屏幕上。

程序代码如下：

a = [3,6,9] 

b = eval(input("请输入列表，例如[1,2,3]:"))  

j=1                                          

for i in range(3):                               

    b.insert(j,a[i])                               

    j+= 2                                      

print(b) 

#程序运行结果

请输入列表，例如[1,2,3]:[1,2,3]

[1, 3, 2, 6, 3, 9]

4.统计与索引

（1）统计

count()方法：统计某个元素在列表中出现的次数。格式如下：

<列表名>.count(元素)

例如：

>>>lst=[1,'1',2,2,3,3,3]                   

>>>lst.count(1)     

1

>>>lst.count(3)       

3

>>> lst.count(0)     

0

（2）索引

index()方法：返回某个元素在列表中首次出现的位置。格式如下：

<列表名>.index(元素,[,起始索引号[,终止索引号]])

其中，起始索引号和终止索引号表示列表的指定范围内。可省略，表示整个列表。

例如：

>>>lst=[1,'1',2,2,3,3,3]    

>>>lst.index(2)            

2

>>>lst.index(2,0,1)            

ValueError: 2 is not in list

>>>lst.index(2,4)                   

ValueError: 2 is not in list      

5. 排序与反序

(1)排序

格式如下：

<列表名>. sort(key=None,reverse=False)

其中：

key参数：指定排序依据，例如key=len，根据列表元素的长度进行排序；

reverse参数：指定排序规则， reverse = False 表示升序（默认排序方式）；reverse = True 表示降序。

例如：

>>>lst = ['apple', 'A', '1' ,'10' ,'2','B',"banana"]

>>>lst.sort()

>>>lst                                 

['1', '10', '2', 'A', 'B', 'apple', 'banana']

>>> lst.sort(reverse=True)

>>>lst    

['banana', 'apple', 'B', 'A', '2', '10', '1']

>>>lst1.sort(key=len,reverse=False)          

>>>lst1                             

['B', 'A', '2', '1', '10', 'apple', 'banana']

>>>lst2 =list(range(11))               

>>>import random        

>>>random.shuffle(lst2)                    

>>>lst2

[4, 3, 0, 1, 10, 5, 9, 7, 2, 8, 6] 

>>>lst2.sort()                            

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>>lst2.sort(key=str,reverse=True)           

[9, 8, 7, 6, 5, 4, 3, 2, 10, 1, 0]

(2)反序

格式如下：

<列表名>. reverse()

例如：

>>>lst = ['apple', 'A', '1' ,'10' ,'2','B',"banana"]

>>>lst.reverse()                        

>>>lst

['banana', 'B', '2', '10', '1', 'A', 'apple']

>>>L=lst.reverse()                      

>>>L               

注意：

sort()和reverse()方法没有返回值，且为原地操作。执行后列表中原来的顺序会全部丢失。

如果不希望丢失列表的原有顺序，可以使用内置函数sorted()、reversed()。

>>>L=[3,5, 9,1, 7]  

>>>sorted(L)      

[1, 3, 5, 7, 9]      

>>> L

[3, 5, 9, 1, 7]      

>>> list(reversed(L))

[7, 1, 9, 5, 3]      

>>> L

[3, 5, 9, 1, 7]

6.列表复制

格式如下：

<列表名>.copy()

功能：建立一个新副本，对于数值、字符串和元组等不可变数据类型的改变，新列表和原列表之间互不影响。

如果列表元素中包含列表之类的可变数据类型，由于是把子列表的引用复制到新列表中，修改任何一个列表都会对另外一个列表产生影响。

copy()函数

例如：

>>> lst1=[1,2,3,[4]] 

>>> lst2=lst1.copy()

>>> lst1[3].append(5)

>>> lst1.append(6) 

>>> lst2[1]='2'     

>>> lst1          

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

>>> lst2

[1, '2', 3, [4, 5]]

deepcopy()函数

对原列表中的元素进行递归，把所有的值都复制到新列表中，对嵌套的子列表不再是复制引用。例如：

>>> lst1=[1,2,3,[4]]      

>>> import copy           

>>> lst2=copy.deepcopy(lst1) 

>>> lst1[3].append(5)       

>>> lst1.append(6)         

>>> lst2[1]='2'             

>>> lst1                  

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

>>> lst2

[1, '2', 3, [4]]

列表变量赋值

列表复制：把一个列表变量赋值给另一个列表变量。两个列表变量指向同一个列表对象，修改任何一个列表变量的任何元素均会对另一个列表变量产生影响。

>>> lst1=[1,2,3,[4]]  

>>> lst2=lst1         

>>> lst1[3].append(5)   

>>> lst2[1]='2'         

>>> lst1              

[1, '2', 3, [4, 5]]

>>> lst2

[1, '2', 3, [4, 5]]

板书：

1. 列表

（5） 列表常用内置函数

（6） 列表运算符

讲解：

6.1.4  列表常用内置函数

（1）len()：用于返回列表中元素的个数，即列表的长度。

（2）max()：用于返回列表中元素的最大值。

（3）min()：用于返回列表中元素的最小值。

（4）sum()：用于返回列表中所有元素的和。

（5）all()：用于测试列表中是否所有元素的值都等于True。

（6）any()：用于测试列表中是否有一个元素的值等于True。

例如：

>>> lst=[6,10,0,4,8,2]

>>>len(lst)     

6

>>>max(lst)        

10

>>>min(lst)     

0

>>>sum(lst)        

30

>>>all(lst)         

False

>>>any(lst)        

True

（7）zip()

zip([iterable1, iterable2, ...])

重新组合可迭代对象iterable1、 iterable12…。如果可迭代对象的元素个数不一致，以最短的列表个数为准。

>>> lst=[6,10,0,4,8,2]        

>>>list(zip(lst,['a']*6))     

[(6, 'a'), (10, 'a'), (0, 'a'), (4, 'a'), (8, 'a'), (2, 'a')]

>>>list(zip(lst,['a','b']))

[(6, 'a'), (10, 'b’)]

>>>matrix=[[1,2,3],[4,5,6],[7,8,9]]

>>>list(zip(*matrix))        

[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

（8）enumerate()

enumerate(sequence)

用于返回序列sequence中元素的索引号和值。

>>> lst=[6,10,0,4,8,2]        

>>>list(enumerate(lst))

[(0, 6), (1, 10), (2, 0), (3, 4), (4, 8), (5, 2)]

（9）map()

map(function, iterable)

根据提供的函数function对指定序列iterable做映射。返回包含函数调用返回值的迭代对象。

>>> list(map(abs, [-4,-8,3]))

[4, 8, 3]

>>>matrix=[[1,2,3],[4,5,6],[7,8,9]]

>>>list(map(list,zip(*matrix)))    

 [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

（10）filter()

filter(function, iterable)

根据指定函数function的返回值对可迭代对象iterable元素进行过滤。

返回包含函数值为True的元素的迭代对象。

如果使用的函数是None，则返回所有本身可以判断为True的元素。

>>>list(filter(None,[1,0,2,0,3,0]))    

[1,2,3]

例6.9 计算两个列表ls和lt对应元素乘积的和(即向量积)。以及两个列表的最大元素、最小元素及其所在位置（索引号）。
ls = [111,222,333,444,555,666,777,888,999]，lT=[999,777,555,333,111,888,666,444,222]

程序代码如下：

ls = [111, 222, 333, 444, 555, 666, 777, 888, 999] 

lt = [999, 777, 555, 333, 111, 888, 666, 444, 222] 

s = 0                                             

for i in range(len(ls)):                                

        s+=ls[i]*lt[i] 

print("向量积：{}".format(s))                        

print("ls最大元素：{}，索引号：{}".format(max(ls),ls.index(max(ls))))

print("ls最小元素：{}，索引号：{}".format(min(ls),ls.index(min(ls))))

print("lt最大元素：{}，索引号：{}".format(max(lt), lt.index(max(lt))))

print("lt最小元素：{}，索引号：{}".format(min(lt), lt.index(min(lt))))

#程序运行结果

向量积：2402595

ls最大元素:999，索引号：8

ls最小元素：111，索引号：0

lt最大元素：999，索引号：0

ls最小元素：111，索引号：4

6.1.5  列表运算符

1.连接运算符

连接运算符+：连接两个列表，形成一个新的列表。格式如下：

<列表1>+<列表2>

返回新列表，不属于原地操作，效率非常低。

使用复合赋值运算符+=实现原地操作，提高效率。

例如：

>>>lst1=[1,2,3]           

>>>id(lst1)      

61657800

>>>lst1=lst1+[ 'a', 'b', 'c']    

1.连接运算符

>>>lst1                     

[1, 2, 3, 'a', 'b', 'c']

>>>id(lst1)               

61657288

>>>lst2=[[4,5]]            

>>>lst1+= lst2             

>>>lst1                  

[1, 2, 3, 'a', 'b', 'c', [4, 5]]

>>>id(lst1)   

61657800

2. 重复操作符

重复操作符*：将列表重复多次。格式如下：

<列表>*n  或   n*<列表>

其中n是正整数。返回新列表，不属于原地操作，可以使用复合赋值运算符*=提高效率。

例如：

>>>lst=[1,2,3]           

>>>id(lst)         

65012776

>>>lst=lst*2

>>>lst

[1, 2, 3, 1, 2, 3]

>>>id(lst)                

65013672

>>>lst*=2               

>>>lst

[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

>>>id(lst) 

65013672

3. 比较运算符

比较运算符：<、<=、==、!=、>=、>。

比较的是第一对不相等的元素大小，数值按大小比较，字符串按顺序逐个元素进行比较。返回值为逻辑型。

例如：

    [1,2,3] < [1,2,4]        

    [1,3] > [1,2,4]        

    [5] < [5, 0]             

    ["ABC", "123"] > ['abc', '456’]  

    [1, "two"] > ["two", 1]   

    [1, 2] < [3.3, 4]        

[1] < ['2']

比较结果：

True

True

True

False

TypeError

True

TypeError

4.成员关系运算符

成员关系运算符in 或not in可以判断一个元素是否存在于列表中。格式如下：

（1）<元素> in <列表>

如果元素是列表的成员，返回True，否则返回False。

（2）<元素> not in <列表>

如果元素不是列表的成员，返回True，否则返回False。

例如：

>>> 1 in [[1],'2',3]           

False

>>> 2 not in [[1],'2',3]       

True

例6.10 连接两个列表L1=['a'，'b'，'c']，L2=['d'，'b'，'c'，'a'],并将列表中的所有元素重复3次，然后去除列表中的重复元素并输出。

程序代码如下：

L1=['a','b','c']         

L2=['d','b','c','a']  

L3=L1+L2            

L4=L3*3             

L5=[]               

for i in L4:           

    if i not in L5:

        L5.append(i)

print(L5)            

程序运行结果： ['a', 'b', 'c', 'd']

板书：

1. 列表

（7） 列表程序举例

讲解：

6.1.6 列表程序举例

例6.11用户输入以逗号分隔的三个数字，记为a、b、c，以a为起始数值，b为前后相邻数的比值，c为数列长度，产生一个等比数列，将这个数列以逗号分隔的形式输出，最后一个元素输出后无逗号。

程序代码如下：

a,b,c=eval(input("请输入三个数字，逗号分隔:"))

ls=[]                                      

for i in range(c):                            

    ls.append(str(a*(b**i)))                  

print(",".join(ls))                       

请输入三个数字，逗号分隔:1,3,5

1,3,9,27,81

例6.12将定义好的std列表里的姓名和成绩与已经定义好的模板拼成一段话，显示在屏幕上。例如:
小明同学你好，你的考试成绩是:英语90,数学86, Python语言93,总成绩269.特此通知。

程序代码如下：

std = [['小明',90,86,93],['小红',83,80,86],['小玲',73,57,65]]

modl = "{}同学你好, 你的考试成绩是: 英语{}, 数学{}, Python语言{}, 总成绩{}.特此通知."

for st in std:

 s = 0        

    for i in range(3):    

        s += st[i+1]              

print(modl.format(st[0],st[1],st[2],st[3],s)

#程序运行结果

小明同学你好,你的考试成绩是:英语90,数学86,Python语言93,总成绩269.特此通知.

小红同学你好,你的考试成绩是:英语83,数学80,Python语言86,总成绩249.特此通知.

小玲同学你好,你的考试成绩是:英语73,数学57,Python语言65,总成绩195.特此通知.

例6.13 键盘输入一组人员的姓名、性别、年龄等信息，信息间采用空格分隔，每人一行，空行回车结束录入.
示例格式如下:
张三 女21
李四 男23
王五 女18
计算并输出这组人员的平均年龄(保留2位小数)和其中女性人数，格式如下:
平均年龄是20.67女性人数是2

程序代码如下

data = input()                                    

 s=0                      

 n=0                           

 i=0                      

 while data:

     i=i+1

     ls=data.split()           

     s=s+int(ls[2])           

     if ls[1]=='女’: 

          n=n+1

     data = input()  

s=s/i   

print("平均年龄是{:.2f}， 女性人数是{}。".format(s,n))

#程序运行结果

张三 女 21

李四 男 23

王五 女 18

平均年龄是20.67，女性人数是2。

板书：

2. 元组

（1） 元组与列表的区别

讲解：

6.2.1 元组与列表的区别

元组是一个不可变的、有序的序列。元组与列表的区别：

（1）定义符号不一样：元组使用（）定义，而列表使用[]定义。

（2）元组里面的元素不能修改，而列表里的元素能修改。

元组是“常量列表”，无法增加、修改、删除元素。不允许修改其元素值的“写保护”特性，使得代码更加安全。

（3）元组作为不可变序列，与整数、字符串一样，可以用作字典的键，也可以作为集合的元素。列表则不能。

（4） 元组比列表更节省存储空间，访问速度更快。

板书：

2. 元组

（2） 元组基本操作

讲解：

6.2.2 元组基本操作

1.创建元组

（1）赋值法

定义一个元组的格式如下：

元组名=（元素1，元素2，元素3）

其中，元组的元素可以是任何类型的对象，用圆括号括起，元素之间以逗号分隔。

如果元组中只有一个元素，则必须在最后增加一个逗号，否则无法和单个值进行区分。

在不引起语法错误的情况下，用逗号分隔的一组值，系统也会自动创建元组。

例如：

>>>t1=(1,'2',3.0,[4])  

>>>type(t1)        

<class 'tuple'>

>>> t1             

(1, '2', 3.0, [4])

>>>t2=(0,)         

>>>t2  

(0,)

>>>t3=(0)          

>>> t3             

0

>>> t4=4,5,6        

>>> t4

(4, 5, 6)  

>>>t5=()           

()

（2）函数法

通过tuple()函数将字符串、range或其他可迭代对象类型的数据转换成元组。其格式如下：

<元组名>=tuple(字符串、range或其他可迭代对象)

例如:

>>>t6=tuple()                   

>>>t7=tuple("hello world")        

>>>t7                         

('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')

>>>t8=tuple(range(10))           

>>>t8

(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

2.删除元组

元组中的元素不能删除，但是可以用Del命令删除整个元组。格式如下：

 del  <元组名>

例如：

>>>t=(1,'a',2,'b',3,'c')

>>>del t                     

3.访问元组元素

格式如下：

<元组名>[索引号]

例如：

>>>t=(1,'2',3.0,[4]) 

>>>t[0]   

1 

>>>t[-1]         

[4]

>>>t[1]=2

TypeError: 'tuple' object does not support item assignment

遍历元组

格式如下：

for <变量名>  in  <元组名>：

            <语句块 >

例如：

>>>t=(1,'2',3.0,[4]) 

>>>for i in t:

  print (i,end=' ')

#输出结果

1 2 3.0 [4]

其他操作

其他操作：统计、索引、连接、重复、成员关系判断等。

注意：当元组中嵌套可变元素时，该可变元素是可以修改的，元组本身不变。

例如：

>>>t=(1,'2',3.0,[4]) 

>>>id(t)        

64250216

>>>t[3]        

[4]   

>>>t[3].append(5) 

>>>t[3]         

[4, 5]

>>>t            

(1, '2', 3.0, [4, 5])

>>> id(t)         

64250216

板书：

2. 元组

（3） 元组程序举例

讲解：

6.2.3 元组程序举例

例6.14输入一个数，将其转换成中文数字输出。例如，输入“1234567890”，输出“壹贰叁肆伍陆柒捌玖零”。

程序代码如下：

chinese_number=("零","壹","贰","叁","肆","伍","陆","柒","捌","玖")  

number=input("请输入一个数：") 

for i in range(len(number)): 

    if "." in number[i]:    

          print("点",end="")         

    else:                        

          print(chinese_number[int(number[i])],end="")

#程序运行结果

请输入一个数：123.45

壹贰叁点肆伍

例6.15 根据花色和数字生成一副扑克牌。

程序代码如下：

poker_type=("♠","♥","♦","♣")

poker_number=("3","4","5","6","7","8","9","10","J","Q","K","A","2" )

poker_list=[]          

for i in poker_number:        

    for j in poker_type:

        poker_list.append(j+i)     

print(len(poker_list))      

print(poker_list)        

#程序运行结果

52

['♠3', '♥3', '♦3', '♣3', '♠4', '♥4', '♦4', '♣4', '♠5', '♥5', '♦5', '♣5', '♠6', '♥6', '♦6', '♣6', '♠7', '♥7', '♦7', '♣7', '♠8', '♥8', '♦8', '♣8', '♠9', '♥9', '♦9', '♣9', '♠10', '♥10', '♦10', '♣10', '♠J', '♥J', '♦J', '♣J', '♠Q', '♥Q', '♦Q', '♣Q', '♠K', '♥K', '♦K', '♣K', '♠A', '♥A', '♦A', '♣A', '♠2', '♥2', '♦2', '♣2']

例6.16 判断一个日期是这一年的第几天。闰年条件：能被4整除但是不能被100整除或者能被400整除。

程序代码如下：

year=int(input("年："))

month=int(input("月："))

day=int(input("日："))

if year%400==0 or (year%4==0 and year%100!=0):

     days=(31,29,31,30,31,30,31,31,30,31,30,31)

else:

     days=(31,28,31,30,31,30,31,31,30,31,30,31)     

result=sum(days[:month-1])+day                    

print("这是当年的第{}天。".format(result))

#程序运行结果

年：2021

月：2

日：16

这是当年的第47天

教学过程设计：

教学方法及手段、课堂互动题设置、教学改革措施等

本课程内容以计算机投影教学为主。在讲授过程中，考虑到该课程注重动手、注重应用的特点，遵循深入浅出的原则，结合教材及教学大纲制作合适课堂教学的CAI课件，以灵活生动的方式讲述计算机基础知识和算法与Python语言程序设计的全部内容。

对概念、原理的解释和描述尽可能地以日常生活所接触到的实际例子和图示加以对比说明，引导学生建立概念之间、原理之间以及应用之间的联系。

本次课融入思政元素有组合类型类似社会的组织架构，只有符合时代发展的社会架构（社会主义初级阶段到中国式现代化）才能高效推动社会发展。

作业与

思考题设置

作业：《计算机与Python程序设计基础》第6章组合数据类型中选择题1~59、判断题1~19、填空题1~17、编程题1~2。

学习效果、学生反馈、反思改进措施等

结合《计算机与Python程序设计基础实验》，通过编程实现相关问题理解组合数据类型中列表、元组部分，结合学生理论课、实验课反馈信息思考后续课程授课改进方式。

备注

知识单元名称

组合数据类型（2）- 字典、集合

课次

11

授课类型

理论课√讨论课□实验课□习题课□其他□

学时

2

课程目标与要求

掌握组合数据类型字典、集合及操作

本单元重点

与难点内容

重点：字典的访问、赋值等基本操作和常用方法；集合的比较运算。

难点：集合元素的无序性。

教学内容

6.3 字典

6.3.1 字典创建与删除

6.3.2 字典元素的访问

6.3.3 字典元素的增加、修改与删除

6.3.4 字典程序举例

6.4 集合

6.4.1 集合基本操作

6.4.2 集合程序举例

字典对象的创建与删除，字典元素的读取，字典元索的添加与修改。集合对象的创建与常用方法。

PPT、边讲边练

第十二讲      组合数据类型（2）- 字典、集合

一、教学目标

掌握组合数据类型字典、集合及操作。

二、本讲内容及时间分配

6.3 字典（50分钟）

6.3.1 字典创建与删除（15分钟）

6.3.2 字典元素的访问（10分钟）

6.3.3 字典元素的增加、修改与删除（10分钟）

6.3.4 字典程序举例（15分钟）

6.4 集合（40分钟）

6.4.1 集合基本操作（15分钟）

6.4.2 集合程序举例（5分钟）

习题（20分钟）