python知识点全复习-USB迷|专注于互联网分享

python知识点全复习

第一章
第一课时：

print("Hello World! 大家好")sum=99999*99999
print(sum)months="JanFebMarAprMayJunJulAugSepOctNovDev"
n=4
monthAbbrev=months[(n-1)*3:(n-1)*3+3]
print(monthAbbrev)def mean(numbers):s=0.0for num in numbers:s=s+numreturn s/len(numbers)
nums=[0,1,2,3,4,5,6,7,8,8]
print(mean(nums))from random import random
rnd=random()*10
print(rnd)

关于启动：
方法一：
启动windows命令行工具，输入python
方法二：
调用IDLE来启动Python图形化运行环境

方法三：
按照语法格式编写代码，编写可以用任何文本编辑器，保存为.py文件。

方法四：
打开IDLE，点击Ctrl+N打开一个新的窗口，输入语句并保存，使用快捷键F5即可运行该程序

方法五：
将Python集成到Eclipse、PyCharm等面向较大规模项目开发的集成开发环境中

采用上述的某个方法，执行：

Python2.x与Python3.x的区别：

本章实例：
我将该实例进行扩展进行对图像的灰度化、二值化、灰度变换
灰度化前的图片：

灰度化后的图片：

二值化的图片：

代码：


from PIL import Image
# import matplotlib.pyplot as plt
import numpy as np
im=Image.open("C:\\Users\\lenovo\\Desktop\\lty.jpg")
im_gray=im.convert('L')
im_1=im.convert('1')
im_p=im.convert('P')
im.show()
im_gray.show()
im_1.show()
im_p.show()

第二课时：
实例程序分析：
温度转换实例：
代码：

val=input("请输入带温度表示符号的温度值（例如：32C）:")
if val[-1] in ['C','c']:f=1.8*float(val[0:-1])+32print("转换后的温度为：%.2fF"%f)
elif val[-1] in ['F','f']:c=(float(val[0:-1])-32)/1.8print("转换后的温度为：%.2fC"%c)
else:print("输入有误")

在命令cmd上运行的程序截图：

在pycharm上的运行结果截图：

在IDLE上运行程序：

命名与保留字：

同步赋值语句可以同时给多个变量赋值：可以极大简化代码：

input()函数：

eval（）函数：

程序运行截图：

输出函数：
print()函数用来输出字符信息，或以字符形式输出变量。
print()函数可以输出各种类型变量的值。
print()函数通过%来选择要输出的变量。
实例训练：

循环语句：控制程序运行，根据判断条件或计数条件确定一段程序的运行次数。

for循环实例：

早就配置好Python环境和IDE
运行课本的P29的练习1.1，1.2，1.4.
练习1.1：

str1=input("请输入一个人的名字：")
str2=input("请输入一个国家的名字：")
print("世界这么大，{}想去{}看看。".format(str1,str2))

练习1.2：

n=input("请输入整数N:")
sum=0
for i in range(int(n)):sum+=i+1
print("1到N求和结果：",sum)

练习1.4：

sum,tmp=0,1
for i in range(1,11):tmp*=isum+=tmp
print("运算结果是：{}".format(sum))

运行截图：

第三课时：
Python第三方库的安装：

pip支持安装（install）、下载（download）、卸载（Uninstall）、查看（list）、查找（search）等一系列安装和维护子命令。
安装jieba库：
install:

list:

unstall:

等等一些指令；
如果官方安装太慢可以选择python国内源替代之：

pip的使用：
自动生成和安装requirements,txt的方法：
1、生成requirements.txt文件：
2、安装requirements.txt依赖库：
实例截图：

其他安装指令的教程：
自定义安装：

文件安装：

另外一些安装方法：

一些python包的用途：

实现一些python库的批量安装的实现实例：

第二章python实例解析：
实例代码：

import os
libs={"numpy","matplotlib","pillow","sklearn","requests"\"jieba","beautifulsoup4","wheel","networkx","sympy",\"pyinstaller","django","flask","werobot","PyQt5",\"panda","pyopeng1","pypdf2","docopt","pygame"}
try:for lib in libs:os.system("pip install "+lib)print("Successful")
except:print("Failed Somehow")

效果图：


import turtle
import turtle
def drawSnake(rad,angle,len,neckrad):for i in range(len):turtle.circle()# 函数让小乌龟沿着一个圆形爬行#         # 参数rad描述圆形轨迹半径的位置#         # 这个半径在小乌龟运行的左侧rad远位置处，如果rad为负值，则半径在小乌龟运行的右侧#         # 参数angle表示小乌龟沿着圆形爬行的弧度值turtle.circle(rad,angle)turtle.circle(-rad,angle)turtle.circle(rad,angle/2)turtle.fd(rad)turtle.fd()# 函数也可以用turtle.forward()# 表示乌龟向前直线爬行移动# 表示小乌龟向前直线爬行移动，它有一个参数表示爬行的距离turtle.circle(neckrad+1,180)turtle.fd(rad*2/3)
# main()函数给出了小乌龟爬行的窗体大小，爬行轨迹颜色和宽度以及初始爬行的方位。
# 最后，调用drawSnake函数启动绘制蟒蛇功能。
# drawSnake函数有四个参数，根据调用时给出的参数，分别将40传递给rad、80给angle，5给len，15给neckrad
def main():turtle.setup(1300,800,0,0) #蟒蛇程序代码启动一个1300像素宽、800像素高的窗口，该窗口的左上角是屏幕的左上角pythonsize=30  #它包含一个输入参数，这里我们把它设为30像素，用pythonsize变量表示。turtle.pensize(pythonsize) #Turtle中的turtle.pensize()函数表示小乌龟运动轨迹的宽度。turtle.pencolor("blue")  #Turtle中的turtle.pencolor()函数表示小乌龟运动轨迹的颜色。# 它包含一个输入参数，这里我们把它设为蓝色，blue，其他颜色单词也可以使用。# Turtle采用RGB方式来定义颜色，如果希望获得和图片中颜色一致的小蛇，请输入turtle.pencolor(“#3B9909”)turtle.seth(-40)
#Turtle中的turtle.seth(angle)函数表示小乌龟启动时运动的方向。它包含一个输入参数，是角度值。
#其中，0表示向东，90度向北，180度向西，270度向南；负值表示相反方向。
#程序中，我们让小乌龟向-40度启动爬行，即：向东南方向40度#注：和极轴有关drawSnake(40,80,5,pythonsize/2)
main()def main():

程序运行：

Python小蛇实例：
turtle.setup(width,height,startx,starty)
分别是：启动窗口的宽度和高度
表示窗口启动时，窗口左上角在屏幕中的坐标位置。

Python对象和引用：
数据表示为对象：
对象本质是一个内存块，拥有特定的值，支持特定的值，支持特定类型的运算操作。每个对象由标识（identity）、类型（type）和值（value）标识

程序实例证明：

Python创建对象：
字面量创建实例对象
Python提供使用字面量直接创建实例对象的语法。
使用类对象创建实例对象
通过直接调用类对象，创建实例对象。
实例解析：

表达式的结果也可以创建对象，def创建函数对象，class创建类对象

变量和对象引用：
Python对象是位于计算机内存数据块；
为了引用对象，必须通过赋值语句，把对象赋值给变量（也称之为把对象绑定到变量）；
指向变量的引用即变量。

Python是动态类型语言
即变量不需要显式声明数据类型
根据变量的赋值，解释器自动确定其数据类型
通过标识符和赋值运算符（=），可以指定某个变量指向某个对象，即引用该对象。
运行实例程序截图：

Python是强类型语言
每个变量指向的对象均属于某个数据类型，即只支持该类型允许的运算操作。
实例程序运行截图：

Python对象内存示意图
Python程序运行时，在内存中会创建各种对象（位于堆内存），通过赋值语句，将对象绑定到变量（位于栈内存），通过变量引用对象进行各种操作；
多个变量可以引用同一个对象；
如果一个对象不再被任何有效作用域中变量引用，则会通过自动垃圾回收机制，回收该对象占用的内存。

Python对象值比较和引用判别
==运算判断两个变量指向的对象的值（value）是否相同
is 运算符判断两个变量是否指向同一个对象（id）
实例程序截图：

Python可变对象和不可变对象
可变对象 mutable ,值可以被修改
不可变对象 immutable ，值不可以被修改

Python命名规则：

Python变量赋值
①、链式赋值用于为多个变量赋值同一个值

②、同步赋值同步交换变量进行赋值

③、复合赋值简化程序代码，提高程序效率

注意：Python没有类似i++这种自增或自减的操作

python复合赋值运算：

python运算符优先级

python语句书写规则：
用换行符分隔，一般情况一行一条语句
从第一列开始，前面不能有任何空格
反斜杠（\）用于一条代码跨越多行时续行的情况
分号（;）用于在一行书写多条语句
实例程序截图：

Python复合语句书写规则：
复合语句：由多行代码组成的语句：
头部语句由相应的关键字开始，构造体语句块则为下一行开始的一行或多行缩进代码
通常缩进是相对头部语句缩进4个空格（也可以是任意个空格），但同一构造体代码块的多条语句缩进的空格数必须一致对齐。
如果条件语句、循环语句、函数定义和类定义比较短，可以放在放在同一行。
课堂练习：
一、P56练习2.2：
略：
二、P56练习2.5：
略：
OJ上有代码
第三章：
基本数据类型
数字类型：
程序元素：010/10，存在多种可能
表示十进制整数值10
类似人名一样的字符串
数字类型对Python语言中数字的表示和使用进行了定义和规范。
python语言包括三种数字类型：
整数类型 int
浮点数类型 float
复数类型 complex
整数类型：

浮点数类型
带有小数点及小数的数字
python语言中浮点数的数值范围存在限制，小数精度也存在限制。这种限制与在不同计算机系统有关
实例程序的截图：

实例程序截图：

浮点数类型：
浮点数的精确表示问题描述
浮点数类型直接表示或科学计数法中表示的系数最长可输出16个数字，浮点数的运算结果中最长可输出17个数字，然而，根据sys.float_info结果，计算机能够提供15个数字的准确性，最后一位由计算机根据二进制计算结果确定误差。
实例程序截图：

浮点数的精确表示解决办法：
采用整数计算而不直接采用浮点数运算
使用decimal库进行高精确浮点数运算

实例程序截图：

复数类型：
与数学中的复数概念一致：Z=a+bj,a是实数部分，b是虚数部分，a和b都是浮点数类型，虚数部分用j或者J标识

对于复数Z可以用Z.real获得实数部分，Z.imag获得虚数部分
实例程序截图：

数字类型的操作
内置的数值运算操作符
三种类型存在一种逐渐“扩展”的关系：
整数->浮点数->复数
（整数是浮点数特例，浮点数是复数特例）
不同数字类型之间可以进行混合运算，运算后生成结果为最宽类型

内置的数值运算操作符：

内置的数值运算操作符：
数字类型之间相互运算所生成的结果是“更宽”的类型基本规则是：
整数之间运算，若数学意义上的结果是小数，结果是浮点数；
整数之间运算，若数学意义上的结果是整数，结果是整数；
整数和浮点数混合运算，输出解果是浮点数；
整数或浮点数与复数运算，输出解果是复数。
实例程序截图：

内置的数值运算函数：
Python解释器提供了一些内置函数，在这些内置函数之中，有六个函数与数值运算相关
数字类型的转换
数值运算操作符可以隐式地转换输出结果的数字类型
例如，两个整数采用运算符“/”的除法将可能输出浮点数的结果。此外，通过内置的数字类型转换函数可以显式地在数字类型之间进行转换。

三种类型可以相互转换
函数：int(),float(),complex()
示例：

实例程序：

函数：type(x),返回x的类型，适用于所有类型的判断
实例程序截图：

math库的使用：
math库是python提供的内置数学类函数库
math库不支持复数类型
math库一共提供了4个数学常数和44个函数。
44个函数共分为4类，包括：16个数值表示函数、8个幂对数函数、16个三角对数函数和4个高等特殊函数
首先使用保留字import引用该库
第一种：import math
对math库中函数采用math.()形式使用
第二种，from math import <函数名>
对math库中的函数可以采用<函数名>()形式使用
实例程序截图：

实例3：天天向上的力量：

题设：

代码：


import math
dayup=math.pow((1.0+0.001),365)
daydown=math.pow((1.0-0.001),365)
print("向上：%.2f,向下：%.2f."%(dayup,daydown))

程序运行截图：

代码：

import math
dayup=math.pow((1.0+0.005),365)
daydown=math.pow((1.0-0.005),365)
print("向上：%.2f,向下：%.2f."%(dayup,daydown))

程序运行截图：

代码：

import math
dayfactor=0.01
dayup=math.pow((1.0+dayfactor),365)
daydown=math.pow((1.0-dayfactor),365)
print("向上：%.2f,向下：%.2f."%(dayup,daydown))

运行程序截图：

代码：

dayup,dayfactor=1.0,0.01
for i in range(365):if i%7 not in [6,0]:dayup=dayup*(1+dayfactor)else:dayup=dayup*(1-dayfactor)
print("向上5天向下2天的力量：{:.2f}.".format(dayup))

程序运行截图：

代码：

def dayUp(df):dayup=1.0for i in range(365):if i%7 in [6,0]:dayup=dayup*(1-0.01)else:dayup=dayup*(1+df)return dayup
dayfactor=0.01
while(dayUp(dayfactor)<37.78):dayfactor+=0.001
print("每天的努力参数是：%.3f."%dayfactor)

程序运行截图：

字符串类型及其操作：
字符串类型
字符串是用双引号“”或者单引号‘’括起来的一个或多个字符。
字符串可以保存在变量中，也可以单独存在。
可以用type()函数测试一个字符串的类型
python语言转义符：
输出带有引号的字符串，可以使用转义符
实例程序运行截图：

字符串是一个字符序列：字符串最左端位置标记为0，依次增加。字符串中的编号叫做“索引”

单个索引辅助访问字符串中特定的位置：
格式为[<索引>]
两个索引值确定一个位置的范围，返回这个范围的子串。格式：[:]
实例程序截图：

字符串之间可以通过+或进行连接
加法操作（+）将两个字符串连接成为一个新的字符串
乘法操作（）生成一个由其本身字符串重复连接而成的字符串
实例程序截图：

len()函数返回一个字符串的长度
实例程序截图：

注意：字符串以Unicode编码，因此字符串的英文字符和中文字符都算一个字符。
字符串的类型转换
大多数数据类型都可以通过str()函数转换为字符串
实例程序截图：

字符串使用实例：
将所有月份名称缩写存储在字符串中

months="JanFebMarAprMayJunJulAugSepOctNovDec"

在字符串中截取适当的子串来查找特定月份
找出在哪里切割子串
每个月份的缩写都由3个字母组成，如果pos表示一个月份的第一个字母，则months[pos:pos+3]表示这个月份的缩写，即：

monthAbbrev=months[pos:pos+3]

字符串使用实例：
代码：

months="JanFebMarAprMayJunJulAugSepOctNovDec"
n=input("请输入月份数（1-12）：")
pos=(int(n)-1)*3
monthAbbrev=months[pos:pos+3]
print("月份简称是"+monthAbbrev+".")

实例运行截图：

字符串的操作
可以通过for和in组成的循环来遍历字符串中每个字符
格式如下：

实例程序截图：

用转义字符可以在字符串中表达一些不可直接打印的信息
例如：用\n表示换行
字符串“Hello\nWorld\n\nGoodbye 32\n”
用print()函数打印后的输出结果如下：

实例程序代码：

plaincode=input("请输入明文：")
for p in plaincode:if ord("a")<=ord(p)<=ord("z"):print(chr(ord("a")+(ord(p)-ord("a")+3)%26),end='')else:print(p,end='')

实例运行截图：

内置字符串的处理方法：

字符串类型的格式化
字符串format()方法的基本使用格式是：
<模板字符串>.format(<逗号分隔得参数>)

format()方法的格式控制
format()方法中模板字符串的槽包括参数序号和格式控制信息，样式如下：{<参数序号>:<格式控制标记>}
其中，格式控制标记用来控制参数显示时的格式，可选字段包括：<填充><对齐><宽度>，<精度><类型>

实例程序运行截图：

文本进度条
利用print()函数实现简单的非刷新文本进度条
基本思想是按照任务执行百分比将整个任务划分100个单位，每执行N%输出一次进度条。每一行输出包含进度百分比，代表已完成的部分（**）和未完成的部分（…）的两种字符，以及一个跟随完成度前进的小箭头，风格如下：
调用Python标准时间库time,采用for循环和print()函数构成程序的主体部分。
多行动态刷新：
代码：

import time
scale=20
print("------执行开始------")
for i in range(scale+1):a,b='**'*i,'..'*(scale-i)c=(i/scale)*100print("%{:^3.0f}[{}->{}]".format(c,a,b))time.sleep(0.1)
print("------执行结束------")

实例运行程序截图：

单行动态刷新：
每一行输出都固定在同一行，并不断地用新生成的字符串覆盖之前的输出，形成进度条不断刷新的动态效果。
代码：

import time
for i in range(101):print("\r{:2}%".format(i),end="")time.sleep(0.05)

在IDLE中运行效果图：

为什么输出没有单行刷新？
这是因为IDLE本身屏蔽了单行刷新功能，如果希望获得刷新效果，请使用控制台命令行执行e4.2TextProgressBar.py程序。
以Windows系统为例，启动命令行工具（<Windows系统安装目录>\system32\cmd.exe）,选择到e4.2TextProgressBar.py文件所在目录执行
带刷新的文本进度条
代码：

import time
scale=50
print("执行开始".center(scale//2,'-'))
t=time.clock()
for i in range(scale+1):a='*'*ib='.'*(scale-i)c=(i/scale)*100t-=time.clock()print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,-t),end='')time.sleep(0.05)
print("\n"+"执行结束".center(scale//2,'-'))

采用命令行的执行上述文件，效果如下：

五花八门的进度条设计函数：

第四章程序的控制结构
程序的基本结构：
程序流程图用一系列图形、流程线和文字说明描述程序的基本操作和控制流程，它是程序分析和过程描述的最基本的方式。
流程图的基本元素包括7种：

程序的基本结构
顺序结构是程序的基础，但单一的顺序结构不可能解决所有问题。
程序有三种基本结构组成：
顺序结构
分支结构
循环结构
这些基本结构都有一个入口和一个出口，任何程序都由这三种基本结构组合而成。
顺序结构是程序按照线性顺序依次执行的一种运行方式，其中语句块S1和语句块S2表示一个或一组顺序执行的语句

分支结构是程序根据条件判断结果而选择不同向前执行路径的一种运行方式，包括单分支结构和二分支结构。由二分支结构会组合形成多分支结构。

循环结构是程序根据条件判断结果向后反复执行的一种运行方式，根据循环体触发条件不同，包括条件循环和遍历循环结构。

程序的基本结构实例
对于一个计算问题，可以用IPO描述、流程图描述或者直接以Python代码方式描述。
微实例4.1：圆面积和周长的计算
输入：圆半径R
处理：
圆面积：S=π * R * R
圆周长：L=2 * π * R
输出：圆面积S、周长L
问题IPO描述
代码：

R=eval(input("请输入圆半径："))
S=3.1415*R*R
L=2*3.1415*R
print("面积和周长：",S,L)

实例程序截图：

微实例4.2：实数绝对值的计算

微实例4.3:整数累加

程序的基本结构实例：
IPO描述主要用于区分程序的输入输出关系，重点在于结构划分，算法主要采用自然语言描述流程图描述侧重于描述算法的具体流程关系；
流程图的结构化关系相比自然语言描述更进一步，有助于阐述算法的具体操作过程；
Python代码描述是最终的程序产出，最为细致。

程序的分支结构：
单分支结构：if语句：
Python中if 语句的语法格式如下：

语句块是if条件满足后执行的一个或多个语句序列
语句块中语句通过与if所在行形成缩进表达包含关系
if语句首先评估<条件>的结果值，如果结果为True,则执行语句块里的语句序列，然后控制转向程序的下一条语句。如果结果为False，语句块里的语句会被跳过。
if语句
if语句中语句块执行与否依赖于条件判断。但无论什么情况，控制都会转到if语句后与该语句同级别的下一条语句

if语句中<条件>部分可以使用任何能够产生True或False的语句
形成判断条件最常见的方式是采用关系操作符
python语言共有6个关系操作符

微实例4.4：PM 2.5空气质量提醒（1）
输入：接收外部输入PM2.5值
处理：
if PM2.5值>=75,打印空气污染警告
if 35 <=PM2.5值<75,打印空气污染警告
if PM2.5值<35,打印空气质量优，建议户外运动
输出：打印空气质量提醒
代码：

PM=eval(input("请输入PM2.5数值："))
if 0<=PM<35:print("空气优质，快去户外运动！")
if 35<=PM<75:print("空气优质，适度户外运动！")
if 75<=PM:print("空气污染，请小心！")

实例程序运行截图：

二分支结构：if-else语句
Python中if-else语句用来形成二分支结构，语法格式如下：

实例程序代码：

PM=eval(input("请输入PM2.5数值："))
if PM >= 75:print("空气存在污染，请小心！")
else:print("空气没有污染，可以开展户外运动！")

程序运行截图：

二分支结构还有一种更简洁的表达方式，适合通过判断返回特定值，语法格式如下：

实例程序代码：

PM=eval(input("请输入PM2.5数值："))
print("空气{}污染！".format("存在"if PM >= 75 else "没有"))

程序运行截图：

if…else的紧凑结构非常适合对特殊值处理的情况，如下：

Python的if-elif-else描述多分支结构，语句格式如下：

多分支结构是二分支结构的扩展，这种形式通常用于设置同一个判断条件的多条执行路径。
Python依次评估寻找第一个结果为True的条件，执行该条件下的语句块，同时结束后跳过整个if-elif-else结构，执行后面的语句。如果没有任何条件成立，else下面的语句块被执行。else子句是可选的。
实例程序代码：

PM=eval(input("请输入PM2.5数值："))
if 0<=PM<35:print("空气优质，快去户外运动！")
elif 35<=PM<75:print("空气优质，快去户外运动！")
else:print("空气污染，请小心！")

实例运行截图：

身体质量指数BMI实例：

代码：

height,weight=eval(input("请输入身高（米）和体重（公斤）[逗号隔开]："))
bmi=weight/pow(height,2)
print("BMI数值为：{:.2f}".format(bmi))
wto,dom="",""
if bmi < 18.5:wto="偏瘦"
elif bmi<25:wto="正常"
elif bmi<30:wto="偏胖"
else:wto="肥胖"
if bmi<18.5:dom="偏瘦"
elif bmi<24:dom="正常"
elif bmi<28:dom="偏胖"
else:dom="肥胖"
print("BMI指标为：国标'{0}',国内'{1}'".format(wto,dom))

运行程序截图：

程序的循环结构：
遍历循环：for语句：
遍历循环：
‘根据循环执行次数的确定性，循环可以分为确定次数循环和非确定次数循环。确定次数循环指循环体对循环次数有明确的定义循环次数采用遍历结构中元素个数来体现。
Python通过保留字for实现“遍历循环”：

遍历结构可以是字符串、文件、组合数据类型或range()函数：
一、遍历文件：
代码：

for content in open("C:\\Users\\lenovo\\Desktop\\lty.txt"):print(content)

代码运行截图：

二、遍历字符串：
代码：

for str in 'abcd':print(str)

运行程序截图：

三、遍历整个列表
代码：

fruits=['apple','orange','banana']
for fruit in fruits:print(fruit)

运行程序截图：

四、for循环实现1到9相乘
代码：

sum=1
for i in list(range(1,10)):sum*=i
print('1*2...*10='+str(sum))

程序运行截图：

当for循环正常执行之后，程序会继续执行else语句只在循环正常执行之后才执行并结束，因此可以在<语句块2>中放置判断循环执行情况的语句。
代码：

for s in "BIT":print("循环进行中："+s)
else:s="循环正常结束"
print(s)

程序运行结果：
无限循环：while语句：
无限循环：
无限循环一直保持循环操作直到特定循环条件不被满足才结束，不需要提前知道确定循环次数。
Python通过保留字while实现无限循环，使用方法如下：

无限循环：while语句：
无限循环也有一种使用保留字else的扩展模式：

实例程序代码：

s,idx="BIT",0
while idx < len(s):print("循环进行中："+s[idx])idx+=1
else:s="循环正常结束"
print(s)

程序截图：

循环结构有两个辅助保留字：break和continue,它们用来辅助控制循环执行。
break用来跳出最内层for或while循环，脱离该循环后程序从循环后代码继续执行；
其中，break语句跳出了最内层for循环，但仍然继续执行外层循环。每个break语句只有能力跳出当前层次循环
实例程序代码：

for s in "BIT":for i in range(10):print(s,end="")if s=="I":break

实例程序截图：

continue用来结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。
对于while循环，继续求解循环条件。而对于for循环，程序流程接着遍历循环列表。
实例程序代码：

for  s in "PYTHON":if s=="T":continueprint(s,end="")

实例程序截图：

实例程序代码：

for s in "PYTHON":if s=="T":breakprint(s,end="")

实例程序运行截图：

for循环和while循环中都存在一个else扩展用法；
else中的语句块只在一种条件下执行，即for循环正常遍历了所有内容没有因为break或return而退出。
continue保留字对else没有影响，看下面两个例子：
实例代码：

for s in "PYTHON":if s=="T":continueprint(s,end="")
else:print("正常退出")

实例程序运行截图：

实例对比程序的代码：

for s in "PYTHON":if s=="T":breakprint(s,end="")
else:print("正常退出")

实例程序运行截图：

random库的使用：
随机数在计算机应用中十分常见，Python内置的random库主要用于产生各种分布的伪随机数序列。random库采用梅森旋转算法（Mersenne twister）生成伪随机数序列，可用于除随机性要求更高的加密解密算法外的大多数工程应用。
使用random库主要目的是生成随机数，因此，读者只需要查阅该库的随机数生成函数，找到符合使用场景的函数使用即可。这个库提供了不同类型的随机数函数，所有函数都是基于最基本的random.random()函数扩展而来。

对random库的引用方法与math库一样，采用下面两种方式实现：

在IDLE上进行对random库进行试验：

生成随机数之前可以通过seed()函数指定随机数种子，随机种子一般是一个整数，只要种子相同，每次生成的随机数序列也相同。这种情况便于测试和同步数据。
实例代码运行截图：

课堂练习：
1、随机生成100以内的10个整数；、
代码：

from random import*
for i in range(10):print(randint(0,100))

实例程序截图：

2、随机选取0到100之间的奇数：
代码：

from random import*
l=[]
for i in range(101):if i%2!=0:l.append(i)
print(choice(l))

实例程序截图：

3、从字符中‘abcdefghij’中随机选取4个字符；
代码：

from random import*
s="abcdefghij"
t=sample(s,4)
for i in t:print(i)

实例程序截图：

4、随机选取列表[‘apple’,‘pear’,‘orange’]中的一个字符。
代码：

from random import*
l=['apple','pear','orange']
print(choice(l))

实例程序截图：

课堂标准代码：

from random import*
for i in range(10):print(randint(1,100),end=' ')print(randrange(1,100,2))print(sample('abcdefghij',4))myls=['apple','pear','peach','orange']
print(sample(myls,1))

实例：Π的计算：
代码：

from random import random
from math import sqrt
from time import clock
DARTS=1000000
hits=0.0
clock()
for i in range(1,DARTS+1):x,y=random(),random()dist=sqrt(x**2+y**2)if dist<=1.0:hits=hits+1
pi=4*(hits/DARTS)
print("PI值是{}.".format(pi))
print("运行时间是：{:5.5}s".format(clock()))

运行程序截图：

异常处理机制
观察下面的这段小程序：

异常处理：try-except语句：
Python异常信息中最重要的部分是异常类型，它表明了发生异常的原因，也是程序处理异常的依据。
python使用try-except语句实现异常处理，基本的语法格式如下：

实例代码：

try:num = eval(input("请输入一个整数："))print(num ** 2)
except NameError:print("输入错误，请输入一个整数！")

实例程序效果图：

异常和错误：
相同点：都属于程序没有考虑到的例外情况，可能导致退出
异常：可以预见的例外情况称为异常，经过妥善处理后可以继续执行。
错误：不可预见的例外情况称为错误，发生后程序无法恢复执行，而且程序本不该处理这类可能的例外。

python内置的异常类：

try-except语句可以支持多个except语句，语法格式如下：

异常的高级用法：
最后一个except语句没有指定任何类型，表示它对应的语句块可以处理所有其他的异常。这个过程与if-elif-else语句类似，是分支结构的一种表达方式，一段代码如下：
代码：

while True:try:alp = "ABCEFGHIJKLMNOPQRSTUVWXYZ"idx = eval(input("请输入一个整数："))print(alp[idx])except NameError:print("输入错误，请输入一个整数！")except:print("其他错误")

实例程序截图：

除了try-except保留字外，异常语句还可以与else和finally保留字配合使用，语法格式如下：

代码：

while True:try:alp = "ABCEFGHIJKLMNOPQRSTUVWXYZ"idx = eval(input("请输入一个整数："))print(alp[idx])except NameError:print("输入错误，请输入一个整数！")except:print("其他错误")else:print("没有发生异常")finally:print("程序执行完毕，不知道是否发生了异常")

程序截图：

raise抛出异常：
大部分程序错误而发生的错误和异常，一般由Python虚拟机自动抛出。此外也可以创建相应的异常类的对象，并通过raise语句主动抛出异常。
实例运行结果：

一旦执行了raise语句，raise之后的语句不再执行；
如果加入了try…except,那么except里的语句会被执行。
实例代码：

try:strA=None# strA='123'if strA is None:print('strA是空对象')raise NameErrorprint('strA长度为：%s'%len(strA))
except Exception:print('空对象没有长度')

代码运行结果截图：

断言处理：

断言的主要功能是帮助程序调试程序，以保证程序运行的正确性；
断言一般在开发调试阶段使用。即调试模式时断言有效，优化模式运行时，自动忽略断言。assert condition的意义是令程序测试condition，并在condition测试结果为false的时候抛出异常。
assert语句和AssertionError类：
python解释器有两种运行模式：调试模式和优化模式。通过为调试模式，内置只读变量_debug_为True；
使用选项-o运行时（即python.exe -O）为优化模式，此时内置只读变量_debug_为False;
实例代码：


```python
a=int(input("请输入整数a:"))
b=int(input("请输入整数b："))
assert b!=0,'除数不能为0！'
c=a/b
print(a,'/','=',c)

运行结果截图：

通常python运行调试模式，程序中的断言语句可以帮助程序调错
正式运行时，使用运行选项-O,以优化模式运行来禁用断言
实例运行效果图：

pdb是python自带的一个包，为python程序提供了一种交互的源代码调试功能，主要特性包括设置断点、单步调试、进入函数调试】查看当前代码、查看栈片段、动态改变变量的值等。

课堂练习：
①、最大公约数，见课本P121页练习4.3
②、猜数游戏，见课本P121页练习4.5
略，已做

第五章函数和代码的复用：
函数的基本使用
函数的定义：

Python定义一个函数使用def保留字，语法形式如下：

实例代码：

f=lambda x,y : x+y
print(type(f))
print(f(10,12))

实例程序运行截图：

函数的参数传递
必选参数：
定义函数时，要求必选参数在调用时必须传入实参的值

定义函数时，有些参数可以存在默认值（默认参数，放在最后）

可变数量参数*
在函数定义时，可以设计可变数量参数，通过参数前增加星号（*）实现.(函数的参数接收时自动组装为元组tuple)

关键字参数**

强制命名参数

python提供了按照形参名称输入实参的方式，调用如下：

由于调用函数时指定了参数名称，所以参数之间的顺序可以任意调整。

变量的返回值：
return语句用来退出函数并将程序回到函数被调用的位置继续执行。
return语句同时可以将0个、1个或多个函数运算完的结果返回给函数被调用出的变量，例如：

函数可以没有return，此时函数并不返回值，如微实例5.1的happy()函数。函数也可以用return返回多个值，多个值以元组类型保存，例如：

一个程序中的变量包括两类：全局变量和局部变量。
全局变量指在函数之外定义的变量，一般没有缩进，在程序执行全过程有效。
局部变量指在函数内部使用的变量，仅在函数内部有效，当函数退出时变量将不存在。

函数func()内部使用了变量n,并且将变量参数b赋值给变量n,为何全局变量n没有改变？
如果希望让func()函数将n当做全局变量，需要在变量n使用前显式声明该变量为全局变量，代码如下：

如果此时的全局变量不是整数n,而是列表类型ls,会怎么样呢？理解如下代码：

如果func()函数内部存在一个真实创建过且名称为ls的列表，则func()将操作该列表而不会修改全局变量，例子如下。

非局部语句nonlocal
函数体中可以定义嵌套函数，如果要定义为上级函数体的局部变量赋值，可以使用nonlocal语句，表明变量不是所在块的局部变量，而是在上级函数体中定义的局部变量。

python函数对变量的作用遵守如下原则：
简单数据类型变量无论是否与全局变量重名，仅在函数内部创建和使用，函数退出后变量会被释放；
简单数据类型变量在用global保留字声明后，作为全局变量；
对于组合数据类型的全局变量，如果在函数内部没有被真实创建的同名变量，则函数内部可直接使用并修改全局变量的值；
如果函数内部真实创建了组合数据类型变量，无论是否有同名的全局变量，函数仅对局部变量进行操作。

分辨局部与全局变量
如果有global关键字修饰变量a，则a为全局变量；
否则，假如a是参数或者出现在等号左边，则a是局部变量；
否则，a与函数f外层的变量a的属性相同。

python变量作用域的查找顺序：

扩展：闭包
如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就认为是闭包（closure）

datetime库的使用：
一不同格式显示日期和时间是程序中最常用到的功能。
python提供了一个处理时间的标准函数库datetime,它提供了一系列由简单到复杂的时间处理方法。datetime库可以从系统中获得时间，并以用户选择的格式输出

datetime对象有三个常用的时间格式化方法，如表所示：

strftime()格式化字符串的数字左侧会自动补零，上述格式化也可以与print()的格式化函数一起使用

扩展time库

七段数码管绘制
代码：

import turtle,datetime
def drawLine(draw):turtle.pendown() if draw else turtle.penup()turtle.fd(40)turtle.right(90)
def drawDigit(digit):drawLine(True) if digit in [2,3,4,5,6,8,9] else drawLine(False)drawLine(True) if digit in [0,1,3,4,5,6,7,8,9] else drawLine(False)drawLine(True) if digit in [0,2,3,5,6,8,9] else drawLine(False)drawLine(True) if digit in [0,2,6,8] else drawLine(False)turtle.left(90)drawLine(True) if digit in [0,4,5,6,8,9] else drawLine(False)drawLine(True) if digit in [0,2,3,5,6,8,9] else drawLine(False)drawLine(True) if digit in [0,1,2,3,4,7,8,9] else drawLine(False)turtle.left(180)turtle.penup()turtle.fd(20)
def drawDate(date):for i in date:drawDigit(eval(i))
def main():turtle.setup(800,350,200,200)turtle.penup()turtle.fd(-300)turtle.pensize(5)drawDate(datetime.datetime.now().strftime("%Y%m%d"))turtle.hideturtle()
main()

代码效果图：

改进的代码：

import turtle,time
def drawGap(): #绘制数码管间隔turtle.penup()turtle.fd(5)
def drawLine(draw):   #绘制单段数码管drawGap()turtle.pendown() if draw else turtle.penup()turtle.fd(40)drawGap()turtle.right(90)
def drawDigit(d): #根据数字绘制七段数码管drawLine(True) if d in [2,3,4,5,6,8,9] else drawLine(False)drawLine(True) if d in [0,1,3,4,5,6,7,8,9] else drawLine(False)drawLine(True) if d in [0,2,3,5,6,8,9] else drawLine(False)drawLine(True) if d in [0,2,6,8] else drawLine(False)turtle.left(90)drawLine(True) if d in [0,4,5,6,8,9] else drawLine(False)drawLine(True) if d in [0,2,3,5,6,7,8,9] else drawLine(False)drawLine(True) if d in [0,1,2,3,4,7,8,9] else drawLine(False)turtle.left(180)turtle.penup()turtle.fd(20)
def drawDate(date):turtle.pencolor("red")for i in date: #根据设置的符号分隔年月日if i == '-':turtle.write('年',font=("Arial", 18, "normal"))turtle.pencolor("green")turtle.fd(40)elif i == '=':turtle.write('月',font=("Arial", 18, "normal"))turtle.pencolor("blue")turtle.fd(40)elif i == '+':turtle.write('日',font=("Arial", 18, "normal"))else:drawDigit(eval(i))
def main():turtle.setup(800, 350, 200, 200) #设置画布窗口大小以及位置turtle.penup()turtle.fd(-350)turtle.pensize(5)t=time.gmtime() #获取系统当前时间drawDate(time.strftime('%Y-%m=%d+',t))turtle.hideturtle()turtle.done()
main()

效果图：

代码复用和模块化设计：
函数是程序的一种基本抽象方式，它将一系列代码组织起来通过命名供其他程序使用。函数封装的直接好处是代码复用，任何其他代码只要输入参数即可调用函数，从而避免相同功能代码在被调用处重复编写。代码复用产生了另一个好处，当更新函数功能时，所有被调用处的功能都被更新。
函数的递归
函数作为一种代码封装，可以被其他程序调用，当然，也可以被函数内部代码调用。这种函数定义中调用函数自身的方式称为递归。就像一个人站在装满镜子的房间中，看到的影像就是递归的结果。递归在数学和计算机应用上非常强大，能够非常简洁的解决重要问题。

微实例5.21：阶乘的计算。
根据用户输入的整数n,计算并输出n的阶乘值。

递归分析：

微实例5.32：字符串反转：
对于用户输入的字符串s,输出反转后的字符串。
解决这个问题的基本思想是把字符串看作一个递归对象。

科赫曲线绘制

自然界有很多图形很规则，符合一定的数学规律，例如，蜜蜂蜂窝是天然的等边六边形等。科赫（koch）曲线在众多金典数学曲线中非常出名，由瑞典数学家冯.科赫于1904年提出，由于其形状类似雪花，也被称为雪花曲线。

python解释器提供了68个内置函数，其中，前36个已经或将在后面课程出现，需要掌握。
python内置函数：

代码：略：
第六章组合数据类型
组合数据类型概述

计算机不仅对单个变量表示的数据进行处理更多情况，计算机需要对一组数据进行批量处理，一些例子包括：
给定一组单词{python,data,function,list,loop},计算并输出每个单词的长度；
给定一个学院学生信息，统计一下男女生比例；
一次实验产生了很多数据，对这些大量数据进行分析

序列类型是一维元素向量，元素之间存在先后关系，通过序号访问。
当需要访问序列中某特定值时，只需通过下标标出即可。
由于元素之间存在顺序关系，所以序列中可以存在相同数值但位置不同的元素。序列类型支持成员关系操作符（in）、长度计算函数（len()）、分片（[]），元素本身也可以序列类型。
python语言中很多数据类型都是序列类型，其中比较重要的是：str(字符串)、tuple(元组)和list(列表)。
元组是包括0个或多个数据项的不可变序列类型。元组生成后是固定的，其中任何数据项不能替换或删除。
列表则是一个可以修改数据项的序列类型，使用也最灵活。

元组（turple）是序列类型中比较特殊的类型，因为它一旦创建就不能被修改。元组类型在表达固定数据项、函数多返回值、多变量同步赋值、循环遍历等情况下十分有用。
python中元组采用逗号和圆括号（可选）来表示。

集合类型与数学中集合的概念一致，即包含0个或多个数据项的无序组合。集合中元素不可重复，元素类型只能是固定数据类型，例如:整数、浮点数、字符串、元组等。
列表、字典和集合类型本身都是可变的数据类型，不能作为集合的元素出现。
由于集合是无序组合，它没有索引和位置的概念，不能分片，集合中元素可以动态增加或删除。集合用大括号（{}）表示。可以用赋值语句生成一个集合。

由于集合元素是无序的，集合的打印效果与定义顺序可以不一致。由于集合元素独一无二，使用集合类型能够过滤掉重复元素。set(x)函数可以用于生成集合。

集合类型主要用于三个场景：成员关系测试、元素去重和删除数据项，例子如下：

集合类型与其他类型最大的不同在于它不包含重复元素，因此，当需要对一维数据进行去重或进行数据重复处理时，一般通过集合来完成。
映射类型：
映射类型是“键-值”数据项的组合，每个元素是一个键值对，即元素是（key,value）,元素之间是无序的。键值对（key,value）是二元关系。在python中，映射类型主要以字典（dict）体现。

列表的类型和操作：
列表（list)是包括0个或多个对象引用的有序序列，属于序列类型。与元组不同，列表的长度和内容都是可变的，可自由对列表中数据项进行增加、删除或替换。
列表没有长度限制，元素类型可以不同，使用灵活。
列表用中括号([])表示，也可以通过list()函数将元组或字符串转化成列表。直接使用list()函数会返回一个空列表。