网站开发实战作业答案,建设小型网站价钱,wordpress官方中文版,那些做电影视频网站的赚钱吗这篇文章主要介绍了大一python期末简答题#xff0c;具有一定借鉴价值#xff0c;需要的朋友可以参考下。希望大家阅读完这篇文章后大有收获#xff0c;下面让小编带着大家一起了解一下。 期末复习知识点总结 第一章 1.6 Python编程规范与代码优化建议 1.7 模块 模块的导入方…这篇文章主要介绍了大一python期末简答题具有一定借鉴价值需要的朋友可以参考下。希望大家阅读完这篇文章后大有收获下面让小编带着大家一起了解一下。 期末复习知识点总结 第一章 1.6 Python编程规范与代码优化建议 1.7 模块 模块的导入方式 补Python编程规范与代码优化建议 注释 以符号#开始表示本行#之后的内容为注释。 #eg1_2.py codinggbk
n int(input(请输入一个整数))
k1;sum0
for i in range(1,n1):sumsumk
print(sum,sum)缩进 类定义、函数定义、选择结构、循环结构、with快行尾的冒号表示缩进的开始不会c语言直接学python。Python是依靠代码块的缩进来体现代码之间的逻辑关系的缩进结束就表示一个代码块结束了。同一个级别的代码块的缩进量必须相同。以4个空格为基本缩进单位。 最好在每个类、函数定义和一段完整的功能代码之后增加一个空行 def empty(self):self._content []self._current ()def isEmpty(self):return not self._content尽量不要写过长的语句。如果语句确实太长而超过屏幕宽度最好使用续行符\或者使用圆括号将多行代码括起来表示是一条语句。 x 123\45\6
y (123456)虽然Python运算符有明确的优先级但对于复杂的表达式建议在适当的位置使用括号使得各种运算的隶属关系和顺序更加明确、清晰。 每个import语句只导入一个模块最好按标准库、扩展库、自定义库的顺序依次导入。 import csv
import random
import datetime
import pandas as pd
import matplotlib.pyplot as plt模块 模块是一种程序的组织形式。它将彼此具有特定关系的一组Python可执行代码、函数或类组织到一个独立文件中可以供其它程序使用。 模块可以分为标准模块和第三方模块。 标准模块安装好Python后本身就带有的模块被称为标准模块也被称为Python的标准库。第三方模块并不是Python的标准库在使用import语句前必须提前安装到开发环境中。 模块导入的方式 import 模块名 这种方法一次可以导入多个模块。但在使用模块中的类、方法、函数、常数等内容时需要在它们前面加上模块名。 import mathmath.pow(2,3)
8.0import moduleName1 as name2 import math as aa.pow(2,3)
8.0from moduleName import * 这种方法一次导入一个模块中的所有内容。使用时不需要添加模块名为前缀。 from math import*pow(2,3)
8.0sqrt(9)
3.0from moduleName import object1[,object2[...]] 这种方法一次导入一个模块中指定的内容如某个函数。调用时不需要添加模块名为前缀。 from math import pow,ee
2.718281828459045pow(2,3)
8.0第二章 了解变量的命名规则 知道 type函数和isinstance函数功能 input()函数 、eval()函数、 print()函数 2.2.3 命名与保留字 标识符命名规则 标识符由**大小写字母、数字、下划线、汉字**组成变量名**不能以数字**开头变量名是**区分大小写**的变量名不能有空格以及标点符号括号、引号、逗号、斜线、反斜线、冒号、句号、问号等 下列哪些是合法的变量名 A、6a2b、aBc、abc-123、ab_123、_ _、hello world 保留字也称关键字指被编程语言内部定义并保留使用的标识符。 and, elif, import, raise, as, else, in, return, assert, except, is, try, break, finally, lambda, while, class, for, nonlocal, with, continue, from, not, yield, def, global, or, True, del, if, pass, False, None type函数 功能type()函数查看变量类型格式type(变量) a100type(a)
class intisinstance函数 功能isinstance函数判断变量是否为指定的类型 格式isinstance(变量,类型) a100isinstance(a,int)
Trueinput()函数 功能input()函数执行时在屏幕上显示提示字符串用户输入完毕后并将用户输入都以文本形式返回。 格式变量input(提示性文字) xinput(请输入x值)
请输入x值100x
100 # 字符类型input的所有值都是以文本形式表达的 eval()函数 功能eval()函数用于执行一个字符串表达式并返回表达式计算结果值 格式eval(字符串) x 4 3*x
3*xeval(3*x)
12eval(pow(x,2))
16eval(3*x)
3*xprint()函数 功能print()函数用来输出字符信息。print()函数可以输出各种类型变量的值 常用格式 1.print(): 用于输出一个空白行 2.print(表达式): 在屏幕显示表达式的值 3.print(表达式1, 表达式2, …, 表达式n): 将各表达式的值从左到右显示在同一行 [例] print(Hello)
print() # 输出一个空白行
print(32,12,hello)
print(here)
print(32,12,hello,end;) # 用分号作为分隔符把回车符修改掉打在同一行
print(here)程序结果 Hello5 3 hello
here
5 3 hello;her[例] a 有理想
print(a,有担当)
print()
print(有本领,end)
print(青年一代)运行结果 有理想 有担当有本领青年一代思考题#TempConvert_1.py 让用户输入摄氏度C输入对应的华氏度F 公示F C *1.8 32 样例 请输入摄氏度25
25对应的华摄度为77.0C eval(input(请输入摄氏度))
F C * 1.8 32
print(C,对应的华摄度为,F)程序结果 请输入摄氏度25
25 对应的华摄度为 77.0第三章 熟悉 数据类型 3.2.1 算术运算操作符 3.2.2关系运算操作符 3.2.3逻辑运算符 abs(x) divmod(x, y) pow(x, y[, z]) round(x[, ndigits]) max(x1, x2, …, xn) min(x1, x2, …, xn) int(x) float(x) complex(re[, im]) map() 3.5 字符串类型及其操作 3.5.1字符串类型 3.5.2 基本的字符串操作符 * in not in 操作 len(x) str(x) chr(x) ord(x) str.replace() str.split() str.join() str.count() str.find() str.trip() str.upper() str.lower() str.islower() str.isupper 3.2.1 内置的数值运算操作符 操作符描述xyx与y之和x-yx与y之差x*yx与y之积x/yx与y之商x//yx与y之整数商向下取整x%yx与y之商的余数-xx的负值即x*-1xx本身x**yx的y次幂 x y x^y xy等价于pow(3,2) 运算符还可以用于列表、元组、字符串的连接但不支持不同类型的对象之间相加或连接。 [1,2,3][4,5,6] # 连接两个列表
[1, 2, 3, 4, 5, 6](1,2,3)(4,) # 连接两个元组
(1, 2, 3, 4)ab12 # 连接两个字符串
ab12*运算符还可以用于列表、元组、字符串类型与整数的乘法表示序列元素的重复生成新的序列对象。 [1,2,3]*3
[1, 2, 3, 1, 2, 3, 1, 2, 3](1,2,3)*3
(1, 2, 3, 1, 2, 3, 1, 2, 3)abc*3
abcabcabc Python还有赋值运算符、-、*、/、//、**、%等大量复合赋值运算符。 例如x3等价于xx3 练习题 1.语句a(3/4)3%2;运行后a的值为( )。a0.7511.75 2.若x3.5;z8则xz%3/4的值为( ). 3.5(8%3)/43.58%3/43.52/43.50.54.0 3.设fg2.0使f为4.0的表达式是( ). D A. f/g*10 # ff/(g*10)2/200.1 B. f-g2 # ff-g-2-2 C. f*g-6 # ff*(g-6)2 *(2-6)-8 D. fg # f fg4 x1,x*35**2的值为( ) x*x*(325)1*2828 思考与练习 请将下面数学表达式用Python写出来并运算结果。 1. x ( 2 4 7 − 3 × 4 ) 5 x\frac{(2^47-3\times4)}{5} x5(247−3×4) 2. x ( 1 3 2 ) × ( 16 m o d 7 ) / 7 x(13^2)\times(16 mod 7)/7 x(132)×(16mod7)/7 x(2**47-3*4)/5x
2.2 x(13**2)*(16%7)/7x
2.857142857142857关系运算操作符 补充 关系运算符根据表达式的值得真假返回布尔值 (小于)、 (大于)、 (小于等于)、 (大于等于)、 (等于)、!(不等于) Python关系运算符最大的特点是可以连用。如527 a 3a 2
False1a5 # 等价于1a 且 a5
True5a1
False思考 1.让用户输入一个值赋值给x判断x是否为’男‘ 2.让用户输入一个值赋值给x判断x是否在[0,100]间 xinput()
? 男x 男
Truexint(input())
? 450x100
True逻辑运算符 补充 逻辑运算符将表达式连接在一起一般会返回布尔值 and与:两边都是真结果为真 or或只要一个为真结果为真 not非取反 x Falsey Truex or y
Truenot (x or y)
Falsenot x or y
Truei 7j 8ij and ij
Falsea5; b2; c1a-b2 or b c
True习题 1.若希望当a的值为奇数时表达式的值为“真”a的值为偶数时表达式的值为“假”。则不能满足要求的表达式是( ) C A. a%2 1 B. not a%2 0 C. not a%2 # not 8%2 True not 9%2 False D. a%2 2.判断t是否为闰年。闰年的条件年份t能被400整除或者能被4整除但不能被100整除。 t eval(input(请输入年份))
if t%4000 or t%40 and t%100!0:print(str(t)年是闰年)
else:print(str(t)年不是闰年)and和or具有惰性求值或逻辑短路的特点当连接多个表达式时只计算必须要计算的值 35 or a3 # a没有定义
True35 or a3 # a没有定义
Traceback (most recent call last):File input, line 1, in module
NameError: name a is not defined3.2.2 内置的数值运算函数 Python解释器提供了一些内置函数在这些内置函数之中有6个函数与数值运算相关 函数描述abs(x)x的绝对值divmod(x,y)(x//y,x%y)求商和余数,输出为二元组形式也称为元组类型pow(x,y[,z])(x**y)%z 求幂,[…]表示该参数可以省略即pow(x,y),它与x**y相同round(x[,ndigits])对x四舍五入保留ndigits位小数。round(x)返回四舍五入的整数值max(x1,x2,…,xn)求最大值n没有限定min(x1,x2,…,xn)求最小值n没有限定 x-100yabs(x)y
100x10y3zdivmod(x,y)z
(3, 1)x10y2z3mpow(x,y,z)m
1x 3.14159round(x,2)
3.14a [3,0,5]max(a)
5min(a)
0sum(a)
83.2.3 内置的数字类型转换函数 函数描述int(x)将x转换为整数x可以是浮点数或字符串float(x)将x转换为浮点数x是整数或字符串complex(re[,im])生成一个复数实部为re虚部为imre可以是整数、浮点数或字串符im可以是整数或浮点数但不能为字符串 int(123)
123int(0b10)
2int(0o10)
8int(0x10)
16int(-2.34)
-2float(3) # 把整数转换为实数
3.0float(3.5) # 把数字字符串转换为实数
3.5complex(3) # 指定实部
(30j)complex(3,5) # 指定实部和虚部
(35j)map() map()是接收一个函数f依次映射到序列或迭代对象上的每个元素并返回一个map对象。格式 map(函数f,list数据) x,ymap(int,[45,56])x,y
(45, 56)a,bmap(round,[3.4546,4.6757],(3,2))a,b
(3.455, 4.68)round(3.4546,3)
3.455round(4.6757,2)
4.68思考 Exer1:用户输入一个三位自然数计算并输出其百位、十位和个位上的数字。 x int(input(请输入一个三位自然数))
a x//100
b (x-a*100)//10
c x-a*100-b*10
print(百位数字为str(a),十位数字为str(b),个位数字为:str(c))程序结果 请输入一个三位自然数324
百位数字为3 十位数字为2 个位数字为:4xint(input()) # 324
ax//100 # 3
bx//10%10 # 324//10 32 32%102
cx%10 # 324%104
print(a,b,c)iinput(请输入一个三位自然数)
print(百位数字为i[0])
print(十位数字为i[1])
print(个位数字为i[2])xint(input(请输入一个三位数))
a,bdivmod(x,100)
b,cdivmod(b,10)
print(a,b,c)xinput(请输入一个三位数)
a,b,cmap(int,x)
print(a,b,c)3.5 字符串类型及其操作 字符串是用双引号“”或者单引号括起来的一个或多个字符字符串对象是不可变的。字符串对象提供的涉及到字符串”修改“的方法都是返回修改后的新字符串并不对原始字符串做任何修改。 3.5.1 字符串类型的表示 字符串是一个字符序列字符串最左端位置标记为0依次增加。字符串中的编号叫做”索引“。 国无德不兴人无德不立012345678910 单个索引辅助访问字符串中的特定位置 格式为string[索引] 切片通过两个索引值返回一个子串 格式为string[start:end:step] 这个子序列从索引start开始直到索引end结束但不包括end位置。step代表步长 a国无德不兴 人无德不立a[2]
德x8a[x-2]
人a[-7]
兴a[-11:-7]
国无德不a[1:-1]
无德不兴 人无德不a[2:-2:2]
德兴人德 反斜杠字符(\)是一个特殊字符在字符串中表示转义即该字符与后面相邻的一个字符共同组成了新的含义。 \n:表示换行 \\:表示反斜杠 \:表示单引号 \表示双引号 \b:退格把光标移动到前一列位置 \f:换页符 \n:换行符 \r:回车 \v:垂直制表符 \ooo:3位八进制数对应的字符 \xhh:2位十六进制数对应的字符 \uhhhh:4位十六进制数表示的Unicode字符 \t:表示制表符Tab等。 print(Python\n语言\t程序\t设计)
Python
语言 程序 设计print(c:\\now)
c:\nowa Let\s goprint(a)
Lets go3.5.3 基本的字符串操作符 字符串之间可以通过或*进行连接 加法操作()将两个字符串连接成为一个新的字符串 乘法操作(*)生成一个由其本身字符串重复连接而成的字符串 pineapple
pineapple3*pine
pinepinepine操作符描述x in s如果x是s的元素返回True否则返回Falsex not in s如果x不是s的元素返回True否则返回False ccat,dogd in c
Truez in c
Falsez not in c
True思考1A“5”“8” A的值是多少 ’ 58’ 思考2name”志存高远、脚踏实地“name[5:]、name[0:-1]、name[:5]、name[0:-5]的值分别是多少 name志存高远、脚踏实地name[5:]
脚踏实地name[0:-1]
志存高远、脚踏实name[:5]
志存高远、name[0:-5]
志存高远[例]获取星期字符串 程序读入一个表示星期几的数字1~7输出对应的星期字符串名称。例如输入3返回“星期三”。代码如下 weekstr 星期一星期二星期三星期四星期五星期六星期日
weekideval(input(请输入星期数字(1-7):))
pos (weekid-1)*3
print(weekstr[pos:pos3])程序结果 请输入星期数字(1-7):3
星期三3.5.3 内置的字符串处理函数 操作含义len(x)返回字符串x的长度也可返回其他组合数据类型元素个数str(x)返回任意类型x所对应的字符串形式chr(x)Unicode码对应的单个字符ord(x)返回单字符表示的Unicode编码hex(x)返回整数x对应十六进制数的小写形式字符串oct(x)返回整数x对应八进制的小写形式字符串bin(x)整数转换为二进制形式字符串 len(pine)
4len(祖国你好)
6bin(16)
0b10000oct(16)
0o20hex(16)
0x10ord(A)
65chr(65)
Achr(ord(A)1)
B 3.5.4 内置的字符串处理方法 操作含义str.upper()字符串中字母大写str.lower()字符串中字母小写str.islower()判断字符串是否都是小写是时返回True否则Falsestr.isnumeric()判断字符串是否都是数字是时返回True否则Falsestr.isdigit()同str.isnumeric()str.isupper()判断字符串是否都是大写是时返回True否则Falsestr.isspace()当str所有字符都是空格返回True否则返回Falsestr.replace(old,new[,count])返回字符串str的副本所有old子串被替换为new如果count给出则前count次old出现被替换。查找字符串所有匹配项并替换返回字符串。str.split(sepNone,maxsplit-1)返回一个列表由str根据sub子串出现的次数。用来将字符串分隔成序列。如果不指定分隔符则空格、换行符、制表符等都将被认为是分隔符把连续多个空白字符看作一个分隔符。str.join(iterable)用来连接元组、列表等中的元素注意其元素一定要是字符串。返回一个新字符串由组合数据类型iterable变量的每个元素组成元素间用str分隔。str.find()可以在一个较长的字符串中查找子串并返回子串所在位置的左端索引位置如果没有找到则返回-1str.strip([chars])去掉字符串两侧的空格并返回字符串。返回字符串str的副本在其左侧和右侧去掉chars中列出的字符。str.count()统计子字符串出现的次数 aPythona.lower()
pythona.upper()
PYTHONstring Python is a programming language.string.replace(a,A)
Python is A progrAmming lAnguAge.string.split()
[Python, is, a, programming, language.]s2017-10-31s.split(-)
[2017, 10, 31]a[1,2]t.join(a) # t为连接符
1t2bs.split(-)/.join(b)
2017/10/31sapple,peach,banana,peach,pears.find(peach)
6s.find(peach,7) #从7位置字符开始往后找
19 string Python is a programming languagesstring.strip()
Python is a programming languages思考题 xaaa bb c d e fff
b,.join(x.split())
b
结果为aaa,bb,c,d,e,fffb.replace(c,cc).upper()
AAA,BB,CC,D,E,FFF测试题 复数 z_________________________________可获得它的实数部分。 z.real 下面类型中Python不支持的数据类型有 A.double A.double B.int C.float D.list 关于Python内存管理下列说法错误的是 B. A.变量不必事先声明 B.变量无须先创建和赋值而直接使用 C.变量无须指定类型 D.可以使用del释放资源 4.下列表达式的值为True的是 C A.531 B.322 C.5%2 D.‟abc‟ “xyz‟ 5.下列表达式的值为True的是( ) C A.(2**3)(2*3) # 2**3 22^3 x 正常写应该为 a**2 aa^2 ; B.32 and 52 C.11 and 2!1 D.not(11 and 0!1) #括号里头为True但加上 not则为False 6.a3*4**2/8%5a的值是 1 a3 * 4 * * 2/8%53 * 4^2/8%53 * 16/8 %56 % 5 1 7.判断t是否为润年。润年的条件年份t能被400整除或者能被4整除但不能被100整除 (t%4000) or (t%40 and t%100 !0) 8.x3;y4;z5下面选项中哪个值为True B A. x and y B.xy C. z or x D.not x A.4 ;B.True; C.5;D.False 9.请将下面数学表达式用Python写出来并运算结果x(2^47-3×4)/5 x(2^47-3*4)/5(167-12)/5(23-12)/51111/52.2 10.请将下面数学表达式用Python写出来x(13^2)×(16 mod 7)/7 x(13^2)*(16%7)/7(19)*(2)/7(10)*2/720/72.857142 4.5 模块2random库的使用 要点随机运算的标准函数库random共提供9个常用函数 4.5.1 random库概述 Python内置的random库主要用于产生各种分布的伪随机数序列random库采用梅森旋转算法生成伪随机数序列可用于除随机性要求更高的加解密算法外的大多数工程应用这个库提供了不同类型的随机数函数所有函数都是基于random.random()函数扩展而来 函数描述seed(aNone)初始化随机数种子默认值为当前系统时间random()生成一个[0.0,1.0)之间的随机小数randint(a,b)生成一个[a,b]之间的整数getrandbits(k)生成一个k比特长度的随机整数randrange(start,stop[,step])生成一个[start,stop]之间以step为步数的随机整数uniform(a,b)生成一个[a,b]之间的随机小数choice(seq)从序列类型例如列表中随机返回一个元素shuffle(seq)将序列类型中的元素随机排列返回打乱后的序列sample(pop,k)从pop类型中随机选取k个元素以列表类型返回 import random random.random() # 调用系统时间这个种子 每次都会不一样
0.5018134450345285 random.random()
0.032973558931030156random.random()
0.6449492388301401 random.seed(2) # 调用这个种子 可以使产生的随机数一样 即种子一样random.random()
0.9560342718892494 random.seed(2)random.random()
0.9560342718892494 random.uniform(2,5)
3.8885526850015695random.random()*32 # (0,1) 上下两者区别是5是否能取到 random.randint(1,5)
5random.randint(1,5)
2 random.getrandbits(3) # 随机整数占k比特即 000-111之间二进制 1-7
7random.getrandbits(2) # 00-11 1-3
1 random.randrange(0,100,4) # 产生一个[0,100)间能被4整除的随机整数
76random.randrange(0,100,4)
40 random.choice([1,3,6,7,8])
1random.choice(range(1,50))
8 random.sample([1,3,6,7,8],2)
[7, 8] alist(range(1,10))a
[1, 2, 3, 4, 5, 6, 7, 8, 9]random.shuffle(a)a
[8, 3, 9, 7, 6, 4, 5, 1, 2]思考与练习 思考hw3.py编写程序生成一个字符串该字符串由随机生成10个不重复的小写字母组成。输出该字符串。 import random
n0
s[]
while n10: s.append(random.randint(65,90)) nn1
print(s)
h[]
for i in s: achr(i).lower() h.append(a)
print(h) 结果 [88, 68, 72, 65, 66, 78, 80, 78, 80, 87, 87]
[x, d, h, a, b, n, p, n, p, w, w]import random
z
for i in range(0,26):z chr(ord(a)i)
print(.join(random.sample(z,10)))结果 xnkfrscvuqimport random
list1;i0
while i10:cchr(random.randint(ord(a),ord(z)))if c not in list1:i 1list1list1c
print(list1)4.7 程序的异常处理 要点Python通过try、except等保留字提供异常处理功能 4.7.1 异常处理try-except语句 num eval(input(请输入一个整数))
print(num**2)结果 请输入一个整数3
9请输入一个整数NO
Traceback (most recent call last): # Traceback 异常回溯标记File /Users/eve/Desktop/PYTHON/SchoolCourse/第4章 程序控制结构/code/eg444.py, line 1, in module # “/Users...py”异常文件路径 line 1 异常发生的代码行数num eval(input(请输入一个整数))File string, line 1, in module
NameError: name NO is not defined # NameError异常类型 name...defined 异常内容提示 异常是在程序执行过程中发生的影响程序执行的一个事件。异常是Python对象当Python无法正常处理程序时就会抛出一个异常一旦发生异常程序需要捕获并处理它否则程序会终止执行异常处理使程序能够处理完异常后继续它的正常执行不至于使程序因异常导致退出或崩溃 异常处理基本语法如下: try:可能出现异常的语句块 # 正常执行的程序内容
except 异常类name1[as 原因变量] # 当发生异常时执行except保留字后面的语句块异常处理语句块1
# 如果try中的代码抛出异常类name1
# 并被except捕捉就执行这里的代码[例] try:11
except TypeError as t:print(数据类型不一致,t)结果 数据类型不一致 unsupported operand type(s) for : int and str拓展异常和错误 编程语言的异常和错误是两个相似但不同的概念。异常和错误都可能引起程序执行错误而退出它们属于程序没有考虑到的例外情况exception。然而绝大多数不可控因素是可以预见的例如程序期望获得数字输入却得到了其他字符输入、打开一个不存在的文件等。这种可以预见的例外情况称为”异常“checked exception)异常发生后经过妥善处理可以继续执行。另外一些因为程序编码逻辑产生的不可预见的例外情况称为”错误“unchecked exception错误发生后程序无法恢复执行而且程序本不该处理这类可能的例外例如对于一个包含5个字符的字符串程序去索引其中第6个元素这种错误完全可以避免。 思考#si4_5.py: 当输入4、ab’执行结果分别是什么 try:num eval(input(请输入一个整数))print(num**2)
except NameError:print(输入错误请输入一个整数)程序结果 请输入一个整数4
16请输入一个整数ab
输入错误请输入一个整数思考#si4_6.py: 若在执行print(8/0)语句时要捕捉ZeroDivisionError异常并输出系统报错的原因 如何实现代码 try:print(8/0)
except ZeroDivisionError as t:print(t)结果 division by zero矛盾存在于一切事物中并且贯穿于事物发展过程的始终即矛盾无处不在矛盾无时不有善于全面分析矛盾防止片面性 4.7.2 异常的高级用法 除了最基本的try-except用法Python异常还有一些略微高级的用法这些方法在实际程序设计中也十分常用。 try-except语句可以支持多个except语句语法格式如下 try:语句块1
except 异常类型1:语句块2
...
except 异常类型 N:语句块 N1
except:语句块 N2 其中第1到第N个except语句后面都指定了异常类型说明这些except所包含的语句块只处理这些类型的异常。最后一个except语句没有指定任何类型表示它对应的语句块可以处理所有其他异常。这个过程与if-elif-else语句类似是分支结构的一种表达方式例如如下代码 try:alpABCDEFGHIJKLMNOPQRSTUVWXYZidxeval(input(请输入一个整数))printalp[idx]
except NameError: # 当用户输入非整数字符时except NameError异常被捕获到提示用户输入类型错误print(输入错误请输入一个整数)
except: # 当用户输入数字不在0-25之间时异常被except捕获程序打印其他错误信息print(其他错误)请输入一个整数No
输入错误请输入一个整数请输入一个整数100
其他错误除了try和except保留字外异常语句还可以与else和finally保留字配合使用语法格式如下 try:语句块1
except 异常类型1:语句块2
else: #此处的else语句与for循环和while循环中的else一样当try中的语句块1正常执行结束且没有发生异常时else中的语句块3执行可以看作是对try语句块正常执行后的一种追加处理语句块3
finally: # 无论try中的语句块1是否发生异常语句块4都会执行可以将程序执行语句块1的一些收尾工作放这里例如关闭、打开文件等语句块4采用else和finally修改代码如下 try:alpABCDEFGHIJKLMNOPQRSTUVWXYZidxeval(input(请输入一个整数))printalp[idx]
except NameError: # 当用户输入非整数字符时except NameError异常被捕获到提示用户输入类型错误print(输入错误请输入一个整数)
else:print(没有发生异常)
finally:print(程序执行完毕不知道是否发生了异常)执行结果和结果如下
请输入一个整数: 5
F
没有发生异常
程序执行完毕不知道是否发生了异常请输入一个整数NO
输入错误请输入一个整数
程序执行完毕不知道是否发生了异常下面哪个代码不能随机生成100内的1个整数( ) # C A.random.sample(range(0,100),1) # [82] B.random.randint(0,100) # 94 C.random.getrandbits(100) # 618015465451243308573761656840 生成一个k比特长度的随机整数 D.random.randrange(0,101,1) # 55 2.下面代码哪个能随机选取0到100间的奇数 A A.random.randrange(1,101,2) # 1到100 间的奇数 B.random.randint (0,100) # 0到99任意整数 C.int(random.uniform(0,100)) # 0到99任意小数 D.random.choice(range(1,100)) # 1到99 3.下面哪个代码能从字符串’abcdefghij’中随机选取4个字符 A A.random.sample(“abcdefghij”,4) B.random.choice(“abcdefghij”,4) C.random.uniform(“abcdefghij”,4) D.random.random(“abcdefghij”,4) 4.下面哪个代码不能随机选取列表a[‘apple’, ‘pear’, ‘peach’, ‘orange’]中的1个字符串 B A. random.choice(a) B. random.shuffle(a) # 将序列类型中的元素随机排列返回打乱后的序列 C. random.sample(a,1) D. trandom.randint(0,3) a[t] 5.下面哪个代码能随机生成【2 , 6】之间的一个小数 C A.random.random()*42 # 1之间 * 4 4之间的小数 2 6取不到 B.random.randint(2.6) C.random.uniform(2,6) D.random.randrange(2,6) 第五章 5.1.1函数的定义 5.1.2函数调用的过程 5.1.3函数返回值 5.2.1默认值参数和可变数量参数 一个* 5.2.2位置参数和关键参数 变量作用域 global 5.1 函数的基本使用 5.1.1 函数的定义 定义函数是一段具有特定功能的、可重用的语句组用函数名来表示并通过函数名进行功能调用。 使用函数的目的降低编程难度和代码重用。 函数也可以看作是一段具有名字的子程序可以在需要的地方调用执行不需要在每个执行的地方重复编写这些语句。严格地说函数一种功能抽象。 有些函数是用户自己编写的称为自定义函数Python安装包也自带了一些函数和方法包括Python内置的函数如abs()、eval()、Python标准库中的函数如math库中的sqrt()等 Python使用def保留字定义一个函数语法形式如下 def 函数名(参数列表)函数体return返回值列表函数名可以是任何有效的Python标识符 参数列表调用该函数时传递给它的值可以有零个、一个或多个当传递多个参数时各参数逗号分隔当没有参数时也要保留圆括号。 形式参数函数定义中参数列表里面的参数是形式参数简称为”形参“。 函数体函数每次被调用时执行的代码由一行或多行语句组成。 当需要返回值使使用保留字return和返回值列表否则函数可以没有return语句在函数体技术位置将控制权返回给调用者。 函数调用和执行的一般形式如下 函数名(参数列表)实际参数此时参数列表中给出要传入函数内部的参数简称“实参”。 例5.1 生日歌 过生日时要为朋友唱生日歌歌词为 Happy birthday to you! Happy birthday to you! Happy birthday, dear名字 Happy birthday to you! 编写程序为Mike和Lily输出生日歌。最简单的实现方式是重复使用print()语句对Mike的生日歌输出如下 print(Happy birthday to you!)
print(Happy birthday to you!)
print(Happy birthday, dear Mike!)
print(Happy birthday to you!)结果 Happy birthday to you!
Happy birthday to you!
Happy birthday, dear Mike!
Happy birthday to you!为了能够复用语句考虑将代码修改为 #m5.1HappyBirthday.py
def happy():print(Happy birthday to you!)def happyB(name):happy()happy()print(Happy birthday, dear {}!.format(name))happy()happyB(Mike)
print()
happyB(Lily)第5行中定义了一个函数happyB()包括中的name是形参用来指代要输入函数的实际变量并参与完成函数内部功能。第11行和第13行调用两次happyB()函数输入的”Mike“和”Lily“是实参替换name用于函数执行。类似执行了如下语句 name Mike程序输出如下
Happy birthday to you!
Happy birthday to you!
Happy birthday, dear Mike!
Happy birthday to you!Happy birthday to you!
Happy birthday to you!
Happy birthday, dear Lily!
Happy birthday to you!5.1.2 函数的调用过程 程序调用一个函数需要执行以下4个步骤。 1调用程序在调用处暂停执行。 2在调用时将实参复制给函数的形参。 3执行函数体语句。 4函数调用结束给出返回值程序回到调用前的暂停处继续执行。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WJYxtPpt-1593709010936)(https://i.loli.net/2020/05/20/aKz6ilULAwC4oN3.png)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XcTboVje-1593709010938)(https://i.loli.net/2020/05/20/ilugR9QbWDO2eVN.png)] 拓展函数式编程 函数式编程是一种编程范式常见的编程范式还包括命令式编程和面向对象编程等。函数式编程的主要思想是把程序过程尽量写成一系列函数调用通过函数进一步提高封装级别。函数式编程通过使用一系列函数能够使代码编写更简洁、更易于理解是中小规模软件项目中最常见的编程方式。 5.1.3 函数返回值 #eg5_2sum.py
def sum(number1,number2):totalnumber1number2print(sum(1,2))运行结果None 思考5_1: def circle(r):if r0:print(要求输入正数)returnarea3.14*r*rperimeter2*3.14*rreturn area,perimeterr-3
recircle(r)if re!None:print(半径为,r,的面积为,re[0])print(半径为,r,的圆周长为,re[1])运行结果为 要求输入正数5.2 函数的参数传递 要点函数可以定义可选参数使用参数的位置或名称传递参数值根据函数中变量的不同作用域有不同的函数返回值方式。 5.2.1可选参数和可变数量参数 在定义函数时如果有些参数存在默认值即部分参数不一定需要调用程序输入可以在定义函数时直接为这些参数指定默认值。当函数被调用时如果没有传入对应的参数值则使用函数定义时的默认值替代。例如 def dup(str, times2):print(str*times)dup(knock~)
dup(knock~,4)程序输出结果 knock~knock~
knock~knock~knock~knock~由于函数调用时需要按顺序输入参数可选参数必须定义在非可选参数的后面即dup()函数中带默认值得可选参数times必须定义在str参数后面。 只有在形参表末尾的参数可以有默认参数值不能先声明有默认值的形参而后声明没有默认值的形参 如 def func(a,b5)是有效的
def func(a5,b)是无效的在函数定义时也可以设计变量参数通过在参数前增加*实现。带有星号的可变参数只能出现在参数列表的最后。调用时这些参数被当作元组类型传递到函数中实例如下 def vfunc(a,*b):print(type(b))for n in b:a nreturn avfunc(1,2,3,4,5)vfunc()函数定义了可变参数b调用vfunc()函数时输入的(2,3,4,5)被当作元组传给b与a累加后输出。 python的type函数有两个用法当只有一个参数的时候返回对象的类型。当有三个参数的时候返回一个类对象。 例思考下面程序的运行结果 #codingutf-8
def Say(s团结,n2,m1):for i in range(1,n1):print(s*m)Say()
print
Say(合作,3,4)
print
Say(合作)结果 团结
团结
合作合作合作合作
合作合作合作合作
合作合作合作合作
合作
合作可变数量参数在python中若形参可以接收不定个数的参数该形参称为可变数数量参数。 可变长度参数在定义函数时主要有两种形式*parameter和**parameter*parameter方式无论调用时传递了多少实参都放入元组。列如 def all_1(*args):print(有,len(args),个参数,:,args)all_1(团结合作,携手应对)
all_1(团结合作,携手应对,守望相助)形参args此时为一个元组结果 有 2 个参数 : (团结合作, 携手应对)
有 3 个参数 : (团结合作, 携手应对, 守望相助)**parameter方式自动将接受的参数转换为字典。 def all_2(**args):print(args)all_2(xa,yb,z2)
all_2(m3,n4)结果 {x: a, y: b, z: 2}
{m: 3, n: 4}思考5-2课堂 编写一个函数sum_all,参数可以接收任意个的数字返回值为这些参数的和。 #codingutf-8
# 法一
def sum_all(a,*b):for i in b:a ai # 也可写成 a ireturn aprint(sum_all(1,2,3))
print(sum_all(1,2,3,4,5,6))# 法2
def sum_all(*a):n0for i in a:nnireturn nprint(sum_all(1,2,3))
print(sum_all(1,2,3,4,5,6))结果 6
215.2.2 参数的位置和名称传递 函数调用时实参默认采用按照位置顺序的方式传递给函数但当参数很多时这种调用参数的方式可读性较差。 假设func()函数有6个参数它的定义如下其中参数分别表示两组三维坐标值。 func(x1,y1,z1,x2,y2,z2)return
#实际调用如下
result func(1,2,3,4,5,6,)如果仅看实际调用而不看函数定义很难理解这些输入参数的含义。在规模稍大的程序中函数定义可能在函数库中也可能与调用相距很远带来的可读性较差。 为了解决上述问题Python提供了按照形参名称输入实参的方式此时函数调用如下 result func(x24,y25,z26,x11,y12,z13)由于调用函数时指定了参数名称所以参数之间的顺序可以任意调整。 例 def SayHello(s,n):for i in range(1,n1):print(s)SayHello(Hello!,3) #位置参数
SayHello(3,Hello!) #error
SayHello(n3,sHello!) #关键参数位置参数”Hello“对应于s3对应于n Error: Hello!对应于n则下面中的n1无法对应从而出错 关键参数把形参名直接赋值。 实参有两种类型位置参数和关键参数即函数实参是作为位置参数和关键参数被传递的。 当使用位置参数时实参必须和形参在顺序、个数和类型上一一匹配。 传递参数时的序列解包 序列解包是指实参同样也有*和**两种形式。 方式1传递参数时可以通过在实参序列前加*将其解包,然后传递给多个单变量形参。 def demo(a,b,c):print(abc)seq [1,2,3]
tup (1,2,3)
dic {1:a,2:b,3:c}
Set {1,2,3}demo(*seq) #把 seq [1,2,3]打散掉变为 a1,b2,c3
demo(*tup)
demo(*dic) # 把字典的键传过去
demo(*dic.values()) # aa,bb,cc 字典打散掉
demo(*Set)结果 6
6
6
abc
6方式2如果函数实参是字典可以在前面加**进行解包等价于关键参数。 def demo(a,b,c):print(abc)dic {a:1,b:2,c:3}
demo(**dic) #传递字典的值
demo(a1,b2,c3) # 关键参数
demo(*dic.values()) #传递字典的值
demo(*dic) #字典的键结果 6
6
6
abc总结: 实参 位置参数关键参数 f(b4,a3)实参为序列、字典传递参数时解包 形参 默认参数def函数名形参值 可变参数def函数名*形参 引用字典def函数名**形参 全局变量global 5.2.3 函数的返回值 函数返回值 函数不一定要有return语句即使函数无返回值依旧可以获得返回值Nonereturn不带任何参数时也返回None如果函数有返回值使用return来返回值执行return语句意味着函数的终止Python的return语句可以返回多个值 例 #eg5_1sort.py
def sort(number1,number2):if number1number2:return number1,number2else:return number2,number1n1,n2 sort(3,2)
print(n1 is,n1)
print(n2 is,n2)程序结果 n1 is 2
n2 is 3return语句用来退出函数并将程序返回到函数被调用的位置继续执行。return语句可以同时将0个、1个或多个函数运算后的结果返回给函数被调用处的变量。 例如 def func(a, b):return a*bs func(knock~,2)
print(s)程序结果 knock~knock~函数也可以用return返回多个值多个值以元组类型保存如 def func(a,b):return b,as func(knock,2)
print(s,type(s))程序结果 (2, knock) class tuple若没有return例如 def sum(number1,number2):total number1number2print(sum(1,2))程序结果 None加上return则 def sum(number1,number2):total number1number2return totalprint(sum(1,2))程序结果 3例 def circle(r):if r0:print(要求输入整数)return # 类似return None 其中None可省略area 3.14*r*rperimeter2*3.14*rreturn area, perimeter #返回一个元组r-3
recircle(r)
if re!None:print(半径为,r,的圆面积为,re[0])print(半径为,r,的圆周长为,re[1])r3
recircle(r)
if re!None:print(\n半径为,r,的圆面积为,re[0])print(半径为,r,的圆周长为,re[1])程序结果 要求输入整数半径为 3 的圆面积为 28.259999999999998
半径为 3 的圆周长为 18.845.2.4 函数对变量的作用 一个程序中的变量包括两类全局变量和局部变量。 全局变量在函数之外定义的变量一般没有缩进在程序执行全过程有效。 局部变量在函数内部使用的变量仅在函数内部有效当函数退出时变量将不存在。 以下例子说明当函数执行完退出后其内部变量将被释放 n 1 #n 是全局变量
def func(a, b):c a * b # c是局部变量a和b作为函数参数也是局部变量return cs func(knock~,2)
print(c)程序结果 NameError: name c is not defined若函数使用全局变量时 n 1def func(a,b):n a * breturn n s func(knock~,2)print(s,n) #测试一下n值是否改变
(knock~knock~, 1)函数func()内部使用了变量n,并且将变量参数b赋值给变量n为何 n值没有改变因为函数func()有自己的内存空间它将nb语句理解为生成一个局部变量n并将参数b赋值给它此时func()函数没有将n当作全局变量。所以函数退出后局部变量n被释放全局变量n的值没有改变。 如果希望让func()函数将n当作全局变量需要在变量n使用前用global显示声明该变量为全局变量代码如下 n 1 # n是全局变量def func(a,b):global nn b #将局部变量b赋值给全局变量nreturn a*b s func(knock~,2)print(s,n) #测试一下n值是否改变
knock~knock~ 2倘若全局变量不是整数n而是列表类型ls则 ls [] #ls是全局列表变量
def func(a,b):ls.append(b) #将局部变量b增加到全局列表变量ls中return a*bs func(knock~,2)
print(s,ls) # 测试一下ls值是否改变
knock~knock~ [2]列表全局变量在函数func()调用后竟然发生了改变与整数变量n不同。 列表等组合数据类型由于操作多个数据所以它们在使用中有创建和引用的分别。当列表变量被方括号[]无论是否为空赋值时这个列表才被真是穿件否则只是对之前创建列表的一次引用。 上述代码func()函数的ls.append(b)语句执行时需要一个真是创建过的列表此时func()函数专属的内存空间中没有已经创建过且名称为ls的列表因此func()函数进一步去寻找全局内存空间自动关联全局ls列表并修改其内容。当func()函数退出后全局列表ls中的内容被修改。简单地说对于列表类型函数可以直接使用全局列表而不需要采用global进行声明。 但如果func()函数内部存在一个真实创建过且名称为ls的列表则func()函数将操作该列表而不会修改全局变量例如 ls [] #ls是全局列表变量
def func(a,b):ls [] #创建了名称为ls的局部列表变量ls.append(b) #将局部变量b增加到局部列表变量ls中return a*bs func(knock~,2)
print(s,ls)
knock~knock~ []例 def f(s):s[0]helloa[1,2,3,4]
f(a) # sa 指向位置是一样 s[1,2,3,4] 改变s[0]即列表里第一个数字1变为”hello“
print(a) # f()函数内部并没有存在一个真实创建国的列表b[1,2,3,4]
f(b[:]) # sb[:] 拷贝 指向是不同的位置不同地址空间 原本的b并未改变 此处创建了b[:]这个列表
print(b) #结果 [hello, 2, 3, 4]
[1, 2, 3, 4]总结 python函数对变量的作用遵守如下原则 1简单数据类型变量无论是否与全局变量重名仅在函数内部创建和使用函数退出后变量被释放如有全局同名变量其值不变。 2简单数据类型变量在用global保留字声明后作为全局变量使用函数退出后该变量保留且值被函数改变。 3对于组合数据类型的全局变量如果在函数内部没有被真实创建的同名变量则函数内部可以直接使用并修改全局变量的值。 4如果函数内部真实创建了组合数据类型变量无论是否有 同名全局变量函数仅对局部变量进行操作函数退出后局部变量被释放全局变量值不变。 拓展指针和引用 指针保存内存地址的变量一般出现在比较底层的 程序设计语言中如C语言。 引用某一变量的别名用这个名字可以对变量进行操作如python列表类型的引用。 两者主要区别指针直接指向内存地址说明对象已经生成而引用只是别名需要真实创建对象才能操作对象。由于列表类型在Python中十分常用要格外注意该类型真实创建和引用的区别。 Python中定义函数的关键字是 A. A) def B) define C) function D) defunc 如果函数中没有return语句或return语句不带任何返回值那么该函数 B A没有返回值 B)返回值为None C)返回值为Nun D)返回值为Null 判断题函数在调用前不需要定义直接拿来用就行 x x [‘train’, ‘bus’, ‘car’, ‘ship’] 下面哪个选项的值是’car’ A. (A)x[-2] (B) x[3] ©x[2:3] (D)x[-1] x [‘train’, ‘bus’, ‘car’, ‘ship’] 下面哪个选项的值不是[‘train’, ‘bus’, ‘car’, ‘ship’] C. (A)x[:4] (B) x[:] ©x[1:] (D)x x [‘train’, ‘bus’, ‘car’, ‘ship’] 下面哪个选项的值是[‘car’, ‘ship’] C. (A)x[-2:-1] (B) x[-2:0] ©x[-2:] (D)x[2:3] A[‘car’] B[] 步长错误 D[‘car’] x[[‘IBM’,‘Apple’,‘Lenovo’],[‘America’,1]] 下面哪个选项的值不是‘America’ D (A)x[-1][-2] (B) x[1][0] ©x[-1][0] (D)x[-1][1] x[[‘IBM’,‘Apple’,‘Lenovo’],[‘America’,1]] 下面哪个选项的值不是 ‘Am’ D. (A)x[1][0][0:2] (B) x[1][0][:2:1] ©x[1][0][:-5:1] (D)x[1][0][:2:-1] 第6章 列表的操作 字典的操作 6.2.2 列表类型的操作 表6.4 列表类型特有的函数或方法共14个 函数或方法描述ls[i]x替换列表ls第i数据项为xls[i:j]lt用列表lt替换列表ls中第i到第j项数据**不含第j项下同**ls[i:j:k]lt用列表lt替换列表ls中第i到第j项以k为步数的数据del ls[i:j]删除列表ls第i到第j项数据等价于ls[i:j][]del ls[i:j:k]删除列表ls第i到第j项以k为步数的数据lslt 或 ls.extend(lt)将列表lt元素增加到列表ls中ls * n更新列表ls其元素重复n次ls.append(x)在列表ls最后增加一个元素xls.clear()删除ls中的所有元素ls.copy()生成一个新列表复制ls中的所有元素ls.insert(i.x)在列表ls的第i位置增加元素xls.pop(i)将列表ls中的第i项元素取出并删除该元素ls.remove(x)将列表中出现的第一个元素x删除ls.reverse()列表ls中的元素反转 vlist list(range(5))vlist
[0, 1, 2, 3, 4]len(vlist[2:]) # 计算从第3个位置开始到结尾的子串长度
32 in vlist # 判断2是否在列表vlist中
Truevlist[3]PYTHON # 修改序号3的元素值和类型vlist
[0, 1, 2, PYTHON, 4]vlist[1:3][bit,computer] vlist
[0, bit, computer, PYTHON, 4]# 当使用一个列表改变另一个列表值时python不要求两个列表长度一样但遵循”多增少减“的原则vlist[1:3][new_bit,new_computer,123]vlist
[0, new_bit, new_computer, 123, PYTHON, 4]vlist[1:3][fewer]vlist
[0, fewer, 123, PYTHON, 4]与元组一样列表可以通过for-in语句对其元素进行遍历基本语法结构如下 for 任意变量名 in 列表名:语句块for e in vlist:print(e,end)
0 fewer 123 python 46.4 字典类型和操作 要点: 字典是包含0个或多个键值对的集合没有长度限制可以根据检索引值的内容。 6.4.1 字典类型的概念 字典是Python中唯一内建的映射类型可以用来实现通过数据查找关联数据的功能。Python字典中的值没有特殊的顺序是无序集合不能像序列那样通过位置索引来查找成员数据。字典的显示次序由字典在内部的存储结构决定字典每一值都有一个对应的键。字典的用法是通过键key来访问相应的值value。 列表是存储和检索数据的有序序列。当访问列表中的元素时可以通过整数索引来查找它这个索引是元素在列表中的序号列表的索引模式是“整数序号查找被索引内容”。 在编程术语中根据一个信息查找另一个信息的方式构成了“键值对”它表示索引用的键和对应的值构成的成对关系即通过一个特定的键身份证号码来访问值学生信息。实际应用中有很多“键值对”的例子例如姓名和电话号码、用户名和密码、邮政编码和运输成本、国家名称和首都等。由于键不是序号无法使用列表类型进行有效存储和索引。 通过任意键信息查找一组数据中值信息的过程叫映射Python语言中通过字典实现映射。Python语言中的字典可以通过大括号{}建立建立模式如下 {键1:值1, 键2: 值2, ..., 键n: 值n} 键和值通过冒号连接不同键值对通过逗号隔开。从Python设计角度考虑由于大括号{}可以表示集合因此字典类型也具有和集合类似的性质即键值对之间没有顺序且不能重复。简单说可以吧字典看成元素是键值对的集合。 键可以是任何不可修改类型的数据如数值、字符串和元组等键要唯一键对应的值可以是任何类型的数据。 Dcountry{中国:北京美国:华盛顿法国:巴黎}
print(Dcountry)
{中国:北京,美国:华盛顿,法国:巴黎}字典打印出来的顺序与创作之初的顺序不同这不是错误。字典是集合类型的延续所以各个元素并没有顺序之分。如果想要保持一个集合元素的顺序需要使用列表而不是字典。 字典最主要的用法是查找与特定键相对应的值这通过索引符号来实现。例如 Dcountry[中国]
北京一般来说字典中键值对的访问模式如下采用中括号格式 值字典变量[键] Dcountry[中国]大北京
print(Dcountry)
{中国: 大北京法国: 巴黎,美国: 华盛顿}Python语言中字符串、列表、元组等都采用数字索引字典采用字符索引。 country{12:Australia,(2,3):China,DE:Germany,SG:Singapore}country
{12: Australia, (2, 3): China, DE: Germany, SG: Singapore}country{}country
{}用dict函数创建 dict([(键1值1),(键2,值2),...]) adict([(name,limin),(age,18)])a
{name: limin, age: 18}6.4.2 字典类型的操作 字典最主要的用法是查找与特定键相对应的值这通过索引符号来实现。变量[键]查找与特定键相关联的值。如果指定的键在字典中不存在则报错。对变量[键]赋值修改字典中的数据若指定的键不存在相当于向字典中添加新的键值对。 与列表相似Python字典也有非常灵活的操作方法。使用大括号可以创建字典并指定初始值通过中括号可以增加新的元素例如 Dcountry[中国:北京, 美国: 华盛顿, 法国: 巴黎]
Dcountry[英国]伦敦
print(Dcountry)
{中国:北京,法国: 巴黎,美国: 华盛顿, 英国,伦敦}
Dcounty[日本]
报错直接使用大括号({})可以创建一个空的字典并通过中括号([])向其增加元素例如 Dp{}
Dp[2^10]1024
print(Dp)
{2^10: 1024}需要注意的是尽管集合类型也是有用大括号表示直接使用大括号({})生成一个空的字典而不是集合。生成空集合需要使用函数set()。 表6.5 字典类型的函数和方法 函数和方法描述d.keys()返回所有的键信息d.values()返回所有的值信息d.items()返回所有键值对d.get(key,default)键存在则返回相应值否则返回默认值d.setdefault(key,value)键存在返回相应值否则添加元素d.pop(key,default)键存在则返回相应值同时删除键值对否则返回默认值d.popitem()随机从字典中取出一个键值对以元组keyvalue形式返回d.clear()删除所有的键值对del d[key]删除字典中某个键值对key in d如果键在字典中则返回True否则返回False 如果希望keys()、values()、items()方法返回列表类型可以采用list()函数将返回值转换成列表 Dcountry{中国:北京,美国:华盛顿,法国:巴黎}
Dcountry.keys()
dict_keys([中国, 美国, 法国])list(Dcountry.values())
[北京, 华盛顿, 巴黎]Dcountry.items()
dict_items([(中国, 北京), (美国, 华盛顿), (法国, 巴黎)])中国 in Dcountry #只对键进行判断
TrueDcountry.get(美国,悉尼) #美国在字典中存在
华盛顿Dcountry.get(澳大利亚,悉尼) # 澳大利亚在字典中不存在则返回后面那个
悉尼Dcountry.setdefault(英国,伦敦) # 键存在返回相应值否则添加元素
伦敦Dcountry
{中国: 北京, 美国: 华盛顿, 法国: 巴黎, 英国: 伦敦}Dcountry.pop(英国)
伦敦Dcountry.popitem()
(法国, 巴黎)Dcountry
{中国: 北京, 美国: 华盛顿}del Dcountry[美国]Dcountry
{中国: 北京}Dcountry.clear()Dcountry
{}del Dcountry于其他组合数类型一样字典可以通过for...in语句对其元素进行遍历基本语法结构如下 for 变量名 in 字典名:语句块 例如 a{中国:北京,美国:华盛顿,法国:巴黎}
for i in a:print(i)
###运行结果:
中国
美国
法国思考si6_4: 编写程序输入两个分别包含若干整数的列表list1和list2。用list1元素作为键用list2作为值产生一个字典。该字典的元素个数为list1和list2元素较少的那个列表长度输出该字典。 请输入list13,5,6,2,7,346
请输入list24,6,345,65,54,5,2,7
{3:4,5:6,6:345,2:65,7:54,346:5}解 list1eval(input(请输入list1))
list2eval(input(请输入list2))
cdict(zip(list1,list2))
print(c)思考si6_5.py 文件里dict1变量保存的是学生健康打卡信息请在##之间输入代码。 dict1{张三三:[{日期:4月30日,省份:福建,城市:福州,是否健康:是,是否接触过疑似病例:否},\{日期:5月1日,省份:福建,城市:福州,是否健康:是,是否接触过疑似病例:否}], \李四四:[{日期:4月30日,省份:福建,城市:三明,是否健康:是,是否接触过疑似病例:否},\{日期:5月1日,省份:福建,城市:三明,是否健康:是,是否接触过疑似病例:否}],王五五:[{日期:4月30日,省份:福建,城市:泉州,是否健康:是,是否接触过疑似病例:否},\{日期:5月1日,省份:福建,城市:泉州,是否健康:是,是否接触过疑似病例:否}], \}
nameinput(请输入姓名:)
dateinput(请输入日期:)
tempdatadict1.get(name,不存在)
if tempdata不存在:print(name不存在)
else:for i in tempdata:if i[日期]date:print(i)breakelse:print(今日未打卡) 第7章 open() 打开模式 f.close() read() readline() readlines() write() writelines() seek() 7.1 文件的使用 要点Python能够以文本和二进制两种方式处理文件 7.1.1 文件概述 文件是一个存储在辅助存储器上的数据序列可以包含任何数据内容。概念上文件是数据的集合和抽象类似地函数是程序的集合和抽象。用文件形式组织和表达数据更有效也更为灵活。文件包括两种类型文本文件和二进制文件。 文本文件一般由单一特定编码的字符组成如UTF-8编码内容容易统一展示和阅读。大部分文本文件都可以通过文本编辑软件或文字处理软件创建、修改和阅读。由于文本文件存在编码因此它也可以被看作是存储在磁盘上的长字符串例如一个txt格式的文本文件。 二进制文件直接由比特0和比特1组成没有统一字符编码文件内部数据的组织格式与文件用途有关。二进制是信息按照非字符但特定格式形成的文件例如png格式的图片文件、avi格式的视频文件。 区别二进制文件和文本文件最主要的区别在于是否有统一的字符编码。二进制文件由于没有统一字符编码只能当作字节流而不能看作是字符串。 例 首先用文本编辑器生成一个包含“中国是个伟大的国家”的txt格式文本文件命名为7.1.txt。分别用文本文件方式和二进制文件方式读入并打印输出效果代码如下 textFile open(7.1.txt,rt,encodingutf8) # t表示文本文件方式 rt:文本只读模式读入程序算哦在目录中7.1.txt文件 或 textfile open(7.1.txt) 有时出现汉字显示不出来时使用encoding可不用
print(textFile.readline())
textFile.close()
binFile open(7.1.txt,rb) # b 表示二进制文件方式
print(binFile.readline())
binFile.close()输出结果 中国是一个伟大的国家
b\xe4\xb8\xad\xe5\x9b\xbd\xe6\x98\xaf\xe4\xb8\x80\xe4\xb8\xaa\xe4\xbc\x9f\xe5\xa4\xa7\xe7\x9a\x84\xe5\x9b\xbd\xe5\xae\xb6\xef\xbc\x81采用文本方式读入文件文件经过编码形成字串符打印出有含义的字符 采用二进制方式打开文件文件被解析为字节Byte流。由于存在编码字串符中的一个字符由两个字节表示。 7.1.2 文件的打开关闭 Python对文本文件和二进制文件采用统一的操作步骤即“打开—操作—关闭”。即使用文件之前必须先打开文件然后进行引读、写、添加等操作。 Python通过解释器内置的open()函数打开一个文件并实现该文件与一个程序变量的关联open()函数格式如下 变量名open(文件名,打开模式)文件名可以是文件的实际名字也可以是包含完整路径的名字。 打开模式用于控制使用何种方式打开文件。 或 open(name[,mode,buffering,encoding])name必须提供的参数文件的路径 name参数文件的路径可以是绝对路径也可以是相对路径 fopen(d:\\1.txt)
fopen(d:/1.txt)
fopen(1.txt) # 当前目录下只提供给open函数一个参数“name”将范围一个只读的文件对象 mode打开的模式 buffering是否缓冲 buffering参数控制文件读或写时是否需要缓冲。 若取0或false则无缓冲若取1或true则有缓冲若1的数该数则为所取缓存区中的字节大小若取负数则表示使用默认缓存区的大小。buffering的默认参数值为1 encoding编码模式 encoding参数当文件以文本方式打开时文件内容汉字一般设置为“utf8”。若是没有汉字或是以二进制方式打开文件encoding不需要设置。 open()函数提供7种基本的打开模式 文件的打开模式含义‘r’只读模式如果文件不存在返回异常FileNotFoundError默认值‘w‘覆盖写模式文件不存在则创建存在则完全覆’x‘创建写模式文件不存在则创建存在则返回异常值FileNotFoundError’a‘追加写模式文件不存在则创建存在则在文件最后追加内容’b‘二进制文件模式’t‘文本文件模式默认值’‘与r/w/x/a一同使用在原功能基础上增加同时读写功能 打开模式使用字符串方式表示根据字符串定义单引号或者双引号均可。上述打开模式中’r‘、’w‘、’x‘、’a‘和’b‘、’t‘、’‘组合使用形成既表达读写又表达文件模式的方式。 例如,open()函数默认采用’rt‘文本只读模式。 读取一个二进制文件如一张图片、一段视频或一段音乐需要使用文件打开模式’rb‘。 例如打开一个名为music.mp3的音频文件 binfile open(music.mp3,rb)文件的关闭 文件使用结束后要用close()方法关闭释放文件的使用授权该方法的使用方式如下 变量名.close()关闭文件把缓存区的数据写入磁盘释放文件对象当对文件操作完后一定要关闭文件对象这样才能保证所做的任何修改都确实被保存到文件中。 属性含义closed用于判断文件是否关闭若文件处于打开状体则返回Falsemode返回文件的打开模式name返回文件的名称 f open(1.txt) # f是一个文件的对象f.closed
Falsef.mode
rf.name
1.txt7.1.3 文件的读写 当文件以文本文件方式打开时读写按照字符串方式采用当前计算机使用的编码或指定编码 当文件以二进制文件方式打开时读写按照字节流方式。 Python提供4个常用的文件内容读取方法文件打开模式含有“r”“” 操作方法含义.readall()读取整个文件内容返回一个字符串或字节流*.read(size-1)从文件中读入整个文件内容如果给出参数读入前size长度的字符串或字节流.readline(size-1)从文件中读入一行内容如果给出参数读入该行前size长度的字符串或字节流.readlines(hint-1)从文件中读入所有行以每行为元素形成一个列表如果给出参数读入hint行 *字符串或字节流取决于文件打开模式如果是文本方式打开返回字符串否则返回字节流。下同。 f open(fy.txt,r)f.read(3)
1.Tf.read()
he China Manned Space Agency said the flight successfully verified \n2.the overall design and technologies of the new rocket and also marked\n3.the beginning of the third stage in Chinas manned space program, \n4.which aims to put a manned space station into orbit.f.close() f open(fy.txt)f.readline(3)
1.Tf.readline()
he China Manned Space Agency said the flight successfully verified \nf.close() f open(fy.txt,r)f.readlines()
[1.The China Manned Space Agency said the flight successfully verified \n, 2.the overall design and technologies of the new rocket and also marked\n, 3.the beginning of the third stage in Chinas manned space program, \n, 4.which aims to put a manned space station into orbit.] 例文本文件逐行打印 用户输入文件路径以文本文件 方式读入文件内容并逐行打印代码如下 fname input(请输入要打开的文件) # 提示用户输入一个文件名
fo open(fname, r) # 打开文件并赋值给文件对象变量fo
for line in fo.readlines(): # 文件的全部内容通过fo.readline()方法读入到一个列表中print(line) # 列表的每个元素是文件一行的内容然后通过for-in方式历遍列表处理每行内容
fo.close()当读入文件非常大时一次性将内容读取到列表中会占很多内存影响程序执行速度。一个合理的方法时逐行读入内容到内存并逐行处理 python将文件本身作为一个行序列历遍文件的所有行可以直接这样完成 fname input(请输入要打开的文件)
fo open(fname, r)
for line in fo:print(line) # 处理一行数据
fo.close拓展文件的换行符 如果采用二进制方式打开文件换行符只是一个符号对应一个字节表示为“\n”;如果采用文本方式打开文件换行符表示一行的结束辅助程序对文件的处理。文件的换行符是真实存在的一个字符。 Python提供3个与文件内容写入有关的方法如下所示(文件打开模式含有w、a、x、) 方法含义.write(s)向文件写入一个字符串或字节流.writelines(lines)将一个元素全为字符串的列表写入文件.seek(offset)改变当前文件操作指针的位置offset的值0—文件开头1—当前位置2—文件结尾 f open(1.txt,a)f.write(hello)
5
# 代码到此文件1.txt还没“hello”因为它还在缓存区f.close() # 此时文件1.txt在后面加上“hello” f open(1.txt,a)f.write(2a) # 在文件1.txt后面加上2a
2a [1,1,2]f.writelines(a)f.close() # 文件1.txt在文本后面加上了112 P.S. 注意写入后的元素间是没有分隔符的 例向文件写入一个列表 向文件写一个列表类型并打印输出结果代码如下 fname input(请输入要写入的文件)
fo open(fname,w)
ls [唐诗,宋词,元曲]
fo.writelines(ls)
for line in fo:print(line)
fo.close()程序执行结果如下: 请输入要写入的文件test.txt在WriteListFile.py程序的目录中找到text.txt文件打开可以看到其中的内容如下 唐诗宋词元曲列表ls内容被写入文件但为何 for line in fo:print(line)
fo.close()没有将这些内容打印出来呢 因为文件写入内容后当前文件操作指正在写入内容的后面此处的代码从指针开始向后读入并打印内容被写入的内容却在指针前面因此未能被打印出来。 所以为了可以在写入文件后增加一条代码fo.seek(0)将文件操作指针返回到文件开始即可显示写入的内容代码如下 fname input(请输入要写入的文件)
fo open(fname, w)
ls [唐诗, 宋词, 元曲]
fo.writelines(ls)
fo.seek(0)
for line in fo:print(line)
fo.close()程序执行结果如下 请输入要写入的文件test.txt
唐诗宋词元曲fo.writelines()方法并不在列表后面增加换行只是将列表内容直接排列输出。 file.seek(offset[,where])seek方法可以移动指针的位置 where定义指针位置的参照点 0文件开头默认1当前位置文件要以b方式打开2文件结尾文件要以b方式打开 offset参数定义了指针相对于参照点where的具体位置取整数值。 例文件起始位置 f.seek(0)例文件其实位置往文件为方向移动3个字节 f.seek(3)或f.seek(3,0) # 3 往文件方向移动3个字节 0为文件开头例从当前位置开始往文件头方向移动2个字节 f.seek(-2,1) # -2 往文件头方向移动2个字节1 当前位置f.tell(): 返回文件操作标记的当前位置以文件的开头为原点 f open(1.txt,ab)f.tell()
42上下文管理语句with 在实际开发中读写文件应优先考虑使用上下文管理语句with关键字with可以自动管理资源不论因为什么原因哪怕是代码引发了异常跳出了with块总能保证文件被正确关闭。简而言之就是使用with语句可以不用加close() with open(filename,mode,encoding)as fp: #这里写ton过文件对象fp读写文件内容的语句上下文管理语句with还支持下面的用法 with open(1.txt,r)as src, open(1_new.txt,w) as dst:dst.write(src.read())例向文本文件中写入内容然后读出 s Hello world\n文本文件的读取方法\n文本文件的写入方法\nwith open(1.txt,w)as fp:fp.write(s) with open(1.txt)as fp:print(fp.read())Hello world
文本文件的读取方法
文本文件的写入方法 课堂 思考7_1:下面的代码 f open(text.txt,wb) # 打开text.txt文件以覆盖写模式二进制文件模式以及在此基础上同时增加读写功能
f.write(bpython) # 二进制的python写入
f.seek(2,0) # 光标为文件方向的第2个字节光标在文件开头
print(f.read(3)) # 读取光标位置向后数3个字节 光标移动到第5个字节
f.seek(-3,1) # 光标移到方向头为开头3个字节光标在当前位置 从第5个字节移到第2个字节
print(f.read(1)) # 读取文件光标位置向后数1个字节
f.close()结果为 btho
bt思考7_2:复制1.txt文件生成一个名为1_1.txt新的文本文件 答 f1 open(1.txt,r,encodingutf-8)
f2 open(1_1.txt,w)
a f1.read()
f2.write(a)
f1.close()
f2.close()或 f1 open(1.txt,r,encodingutf-8)
f2 open(1_1.txt,w)
for i in f1:f2.write(i)f1.close()
f2.close()思考7_3:生成1至122之间的随机整数数转成对应的字符然后将满足以下条件大写字母、小写字母、数字和一些特殊符号’*‘’‘’^‘’$‘的字符逐一输入写入文本test.txt中当光标位置达到101时停止写入。 判断是否小写字母的方法字符串.islower() 判断是否大写字母的方法字符串.isupper() 判断是否数字的方法字符串.isdigit() 答 产生随机整数 randint() 转成对应的字符 chr chr() in [’*‘’‘’^‘’$‘] 达到101个字节 f.tell() import random
f1open(test.txt,w)
while f1.tell() 101:achr(random.randint(1,122))if a.islower() or a.isupper() or a.isdigit() or a in[*,,^,$]:f1.write(a)f1.close()输出结果 打开text.txt文件 ln7KSuL5qRzQ7LJRmH5O6FOiyrKHCL$^mHwlYoVJo*DmP8MPKQKpH4uun*L*ZE91lEEstdtEKTSrMqxI9BwHb63fefiapy9J^VY1t思考7_4: 逐个字节读取fy.txt’文件输出该文件前10个字节字符和后10个字节字符 fy open(fy.txt,rb) # 注意要使用rb方式打开下面才可进行读写 不然会报错.UnsupportedOperation: cant do nonzero end-relative seeks
fy.seek(0)
print(fy.read(10))
fy.seek(-10,2)
print(fy.read(10))
fy.close()程序结果 b1.The Chin
bnto orbit.思考7_5: 统计‘fy.txt’文件中大写字母、小写字母和数字的个数。可以利用字符串的isupper()、islower()和isdigit()方法。 输入如下所示 大写有6个小写有205个数字有4个答 fopen(fy.txt,r)
af.read()
s0
y0
c0
for i in a:if i.isupper():ss1elif i.islower():yy1elif i.isdigit():cc1else:pass
f.close()
print(大写有str(s)个, 小写有str(y)个, 数字有str(c)个) 程序结果 大写有6个, 小写有205个, 数字有4个代码简化 f open(fy.txt).read() # 字符串
s,y,c0,0,0
while 1:if f.isupper():s1elif f.islower():i1elif f.isdigit():d1if not f:break
f.close()
print(大写有{}个小写有{}个数字有{}个,format(s,y,c))思考与练习 7.1 读写文件需要采用open()函数采用绝对路径打开操作系统中的一个文件。 答 向文件中读写数据的方法 read()readline()readlines()write()writelines()seek()tell() 第八章 8.1 类的定义与使用 8.2 构造函数 8.3 类的属性 8.4 类的方法公有方法、私有方法 8.7 继承 8.9 运算符的重载 raise抛出自己异常 类的定义与使用 类的定义 类是由3部分组成的 类的名称类名比如Cartoon_sheep类的属性一组数据比如姓名类的方法允许进行操作的方法比如说话 类的使用 使用class关键字来声明一个类基本格式如下 本章学习目标 熟练掌握类的设计和使用深入了解类和对象、面向过程和面向对象的方法掌握类的属性、类的方法、构造函数和析构函数、可变对象和不可变对象理解运算符的重载 (考大题比较多) 8.1 类的定义与使用 1、面向过程的程序设计方法将数据与数据操作相独立其中的数据操作通过函数或代码块来描述 2、面向对象程序设计方法将数据与操作封装为一个混合整体——类通过类进行数据的整体操作并且可以保证数据的完整性和一致性。 在面向对象编程中编写表示现实世界中的事物和情景的类并基于这些类来创建对象。编写类时定义一大类对象都有的通用行为。基于类创建对象时每个对象都自动具备这种通用行为然后可根据需要赋予每个对象独特的个性。 类的定义 类是抽象的具有相似特征和行为的事物的集合统称为类 对象是具体的是根据类创建的一个类可以对应多个对象 每一个对象都是以某一个类的实例类是生成对象的模板。 类和对象的关系 具有相似特征和行为的事物的集合统称为类对象是根据类创建的一个类可以对应多个对象类是抽象的而对象是具体的每一个对象都是某一个类的实例类是生成对象的模板 类是由3部分组成的 类的名称类名比如Cartoon_sheep类的属性一组数据比如姓名类的方法允许进行操作的方法比如说话 类的使用 类是在执行class语句时创建的而对象是在调用类的时候创建的每调用一次类就创建一个对象。类只有一个而对象可以有多个。类和每个对象都分别拥有自己的内存空间在各自的内存空间存属于自己的数据。 使用class关键字来声明一个类基本格式如下 class类名类的属性类的方法class类名赋值语句赋值语句……def语句定义函数def语句定义函数……class Cartoon_sheep:racesheep # 类属性def eat(self): # 方法print(我正在享受美食)类名的首字母一般要大写 在类中用赋值语句创建类属性用def定义函数 类属性是在类中方法之外定义的 根据类创建对象的语法格式如下 对象名类名() aCartoon_sheep() 对象要调用类的属性和方法格式如下 对象名.属性 a.race 对象名.方法() a.eat() 思考eg8_1_1下面注释行的语句如何写 class Cartoon_sheep:racesheepdef eat(self,food):print(我正在享受美食,food)def speak(self):# 打印race属性# 创建一个对象sheep1
# 调用speak方法答 class Cartoon_sheep:racesheepdef eat(self,food):print(我正在享受美食,food)def speak(self):print(self.race) # 打印race属性sheep1 Cartoon_sheep() # 创建一个对象sheep1
sheep1.speak() # 调用speak方法类的方法定义与普通函数的差别 类的方法的第一个参数都是selfself代表将来要创建的对象本身在类的方法里访问类的实例属性时需要以self为前缀类的方法是通过对象来调用即object.method() 思考8_1:定义鸟类Bird鸟类的共同属性feather True和reproduction ‘egg’。 该类有一个方法移动move()该方法执行print(‘飞飞飞飞’) 假设养了一只鹦鹉交spring它是Bird的一个对象输出鹦鹉的两个属性并调用move方法 class Bird():feather Truereproduction eggdef __init__(self,name):self.name namedef move(self):print(飞飞飞飞)
bird Bird(spring)
print(bird.feather)
print(bird.reproduction)
bird.move()程序结果 True
egg
飞飞飞飞在Python中所有的数据包括数字和字符串都是对象同一类型的对象都有相同的类型。 内置函数isinstance()来测试一个对象是否为某个类的实例或type()来获取关于对象的类型信息。 type(sheep1)
class__main__.Cartoon_sheep
isinstance(sheep1,Cartoon_sheep)
True8.2 构造函数 __init__, 称为构造函数或初始化方法用来为属性设置初值在建立对象时自动执行。 当创建对象的时候系统会自动调用构造方法从而实现为实例属性设置初值。 如果用户未设计构造函数Python将提供一个默认的构造函数。 [例] class Cartoon_sheep:racesheepdef __init__(self,namevalue,sexvalue,birthdayvalue):self.namenamevalueself.sexsexvalueself.birthdaybirthdayvalueself_energy0def eat(self):print(我正在享受美食)def speak(self):print(self.name,self.birthday)sheep1 Cartoon_sheep(喜洋洋,男,羊历3505年5月25日) # 在对象被建立之后self被用来指向对象。
print(sheep1.name,sheep1.sex,sheep1.birthday)
# sheep1对象sheep1.name喜洋洋sheep1.sex男sheep1.birthday羊历3505年5月25日
sheep1.speak()程序结果 喜洋洋 男 羊历3505年5月25日
喜洋洋 羊历3505年5月25日思考si8_2: 定义Rectangle类表示矩形。该类有两个属性width和height均在构造函数中创建定义方法getArea和getPerimeter计算矩形的面积和周长。 class Rectangle():def __init__(self,width,height):self.width widthself.height heightdef getArea(self):a (int(self.width))*(int(self.height))return adef getPerimeter(self):b (int(self.width))(int(self.height))B 2*breturn Bt1 Rectangle(15,6)
print(t1.getArea())
print(t1.getPerimeter())程序结果 90
42class 类名属性值def __init__(self,形参,形参...)def 方法(self,形参):self.属性对象类名(形参1,形参2,...)
对象.属性
对象.方法(形参)8.3 类的属性 属性有两种类属性和对象属性 类属性是该类所有对象共享不属于任何一个对象。它在类方法之外定义一般通过类.属性访问对象属性通过对象名.属性通过对象名.属性访问一般在构造函数__init__中进行初始化的当然也可以在其他成员方法中定义。同一个类的不同对象的属性之间互不影响。 class Cartoon_sheep:racesheep # 类属性energy1 # 类属性def __init__(self,namevalue,sexvalue,birthdayvalue):self.namenamevalue # 实例属性self.sexsexvalue # 实例属性self.birthdaybirthdayvalue # 实例属性def study(self):Cartoon_sheep.energyCartoon_sheep.energy1 # 类属性sheep1 Cartoon_sheep(喜洋洋,男,羊历3505年5月25日)
sheep1.study()
print(sheep1.energy, Cartoon_sheep.energy) # 此处对sheep1的energy进行赋值它是对象属性自身本身energy 后续不会改变程序结果 2 2修改和增加属性 对于类或对象而言对属性进行赋值修改该属性当给不存在的属性赋值时Python为其创建属性。 对象名.新的属性名 值
类.新的属性名 值class Cartoon_sheep:racesheepdef __init__(self,namevalue,sexvalue,birthdayvalue):self.name namevalueself.sex sexvalueself.birthday birthdayvaluedef study(self):Cartoon_sheep.energyCartoon_sheep.energy 1sheep1 Cartoon_sheep(喜洋洋,男,羊历3505年5月25日)
Cartoon_sheep.energy0 # 创建类属性energy
sheep1.study()
print(sheep1.energy) # 此处对sheep1的energy没有进行赋值操作 它访问的是类属性,后续会改变程序结果为 1若要修改类属性的值必须对类.属性进行赋值若是通过对象.属性,会产生一个同名的对象属性这种方式修改的是对象属性这种方式修改的是对象属性不会影响到类属性并且之后如果通过对象.属性访问时对象.属性会强制屏蔽掉类属性即访问的是对象.属性, 除非del 对象.属性 class Cartoon_sheep:racesheepenergy1def __init__(self,namevalue,sexvalue,birthdayvalue):self.namenamevalueself.sexsexvalueself.brithdaybirthdayvaluedef study(self):Cartoon_sheep.energyCartoon_sheep.energy1 # 内属性self.energyself.energy1 # 对象属性 创建了对象属性 self.energy1中的self.energy为上述Cartoon_sheep.energy2sheep1 Cartoon_sheep(喜羊羊,男,羊历3505年5月25日) # Cartoon_sheep.energy1
sheep1.study() # Cartoon_sheep.energy112; self.energyCartoon_sheep.energy2 self.energy self.energy1213
print(sheep1.energy,Cartoon_sheep.energy) # 3 2程序结果 3 2思考8_3:下面代码的运行结果是什么 class Testclass:data100 # 类属性def setpdata(self,value):self.pdatavaluedef showpdata(self):print(self.pdata,self.pdata)x Testclass()
x.setpdata(与时俱进)
x.showpdata()y Testclass()
y.setpdata(勇于创新)
y.showpdata()
print(y.data) 程序运行结果 self.pdata 与时俱进
self.pdata 勇于创新
100思考8_4: 下面代码的运行结果是什么 class Testclass:data 有信念、有梦想 # 类属性def setdata(self,value):self.datavalue # 创建对象属性def showdata(self):print(self.data) # 打印对象属性xTestclass()
x.data勇于创新
yTestclass()
Testclass.data有奋斗、有奉献 # 更改了类属性
print(x.data) # 对象属性
print(y.data) # 没有对y.data赋值 没有创建对象属性还是修改类属性
print(Testclass.data)程序运行结果 勇于创新
有奋斗、有奉献
有奋斗、有奉献思考8_5:下面代码有1处出错如何修改 class Rectangle:def __init__(self,w,h):self.widthwself.heighthdef getArea(self):return self.width*self.heightdef getPerimeter(self):return (self.widthself.height)*2t1Rectangle(2,3)
print(Rectangle.width) # 内属性答 print(t1.width)类的属性分为公有属性和私有属性 公有属性可以在类的外部方位它是类与用户之间交流的接口。用户可以通过公有变量向类中传递数据也可以通过公有变量获取类中的数据。 私有属性以__(两个下划线)开头不能在类的外部被使用或直接访问。在类内部的方法中使用时的格式为self.__私有属性 Python使用下划线作为变量前缀和后缀来指定特殊变量规则如下 __xxx__:表示系统定义名字 __xxx:表示类中的私有变量名 私有属性在类外面虽然可以通过如下形式访问但不建议这样访问 对象名._类名__私有属性 class Cartoon_sheep:race sheep # 类属性def __init__(self,namevalue,sexvalue,birthdayvalue):self.namenamevalueself.sexsexvalueself.__birthday birthdayvalue ## 私有对象属性self.__energy 0 ## 私有对象属性def study(self):self.__energy self.__energy3return self.__energysheep1 Cartoon_sheep(喜羊羊,男,羊历3505年5月25日)
print(sheep1.study()) # self.__energy self.__energy3033
print(sheep1.__energy) # print(sheep1.__energy) AttributeError: Cartoon_sheep object has no attribute __energy 出错私有属性不能在类外部访问
print(sheep1._Cartoon_sheep__energy) # 私有属性在类外面可以通过这种形式访问但不建议程序结果 3
38.4 类的方法 类中定义的方法都以self作为第一个参数这个参数表示当前是哪一个对象要执行类的方法这个实参由Python隐含地传递给self当对象调用方法时Python解释器会把对象自身作为第1个参数传给self开发者只需传递后面的参数就可以了 类的方法分类 公有方法对象名.公有方法(实参) 在类的内部使用def可为类定义一个方法与一般函数定义不同类方法必须包含参数self且为第一个参数self在Python里不是关键字self代表当前对象调用方式对象名.公有方法(实参)如果在外部通过类名调用属于对象的公有方法需要显式为该方法的self参数传递一个对象名用来明确指定访问哪个对象。私有方法只能在属于对象的方法中通过self调用不能像公有方法一样通过对象名调用。静态方法使用修饰器staticmethod来标识类方法使用修饰器classmethod来标识 思考8_6: class Cartoon_sheep:racesheepdef __init__(self,namevalue,sexvalue,birthdayvalue):self.namenamevalueself.sexsexvalueself.__birthdaybirthdayvalueself._energy0def eat(self,food):print(我正在吃,food)sheep1 Cartoon_sheep(喜羊羊,男,羊历3505年5月25日)下面哪些调用是正确的 a) sheep1.eat(‘草’) # sheep1–self 草–food b) sheep1.eat(sheep1,“草”) c) Cartoon_sheep.eat(‘草’) d) Cartoon_sheep.eat(sheep1,‘草’) # sheep1–self 草–food a) d) 私有方法 由两个下划线__开头声明该方法为私有方法 在类的内部方法调用时格式为 self.__私有方法(实参) 一般不能在类的外部调用但是与私有属性一样在类外面访问方式如下 对象名._类名__私有方法不建议 class Person:pre_name # 类属性def __init__(self,n,y,w,h): # 申明了构造函数self.namen # 公有属性self.yeary # 公有属性self.__weightw # 私有属性self.__heighth # 私有属性def __getBMI(self): # 私有方法bmi1.0*self.__weight/self.__height**2 # 调用了私有属性return bmidef myBMI(self): # 公有方法if 19self.__getBMI()25: # 调用私有方法print(身体质量指数正常)else:print(身体质量指数不正常)pbPerson(Rose,1995,60,1.65)
pb.myBMI()运行结果 身体质量指数正常思考8_7:下面Site的定义共有4处错如何修改 class Site:__number0 # 私有类属性def __init__(namevalue,urlvalue):self.namenamevalueself.__urlurlvalue # 私有对象属性self.numberself.number1 # 由下文可知应为私有属性def printme(self):__privateme(self) # 利用类属性的方法错误print(name:,self.name)print(url:,self.url) # 利用私有对象的方法错误def __privateme(self): # 私有方法print(Site.__number) wz1 Site(福建农林大学,wwww.fafu.edu.cn)
wz1.printme()
wz2 Site(学习强国,www.xuexi.cn)
wz2.printme()修改 class Site:__number0def __init__(self,namevalue,urlvalue): #4self.namenamevalueself.__urlurlvalueSite.__numberSite.__number1 # 1def printme(self):Site.__privateme(self) # 2print(name:,self.name) print(url:,self.__url) # 3def __privateme(self): print(Site.__number)wz1 Site(福建农林大学,wwww.fafu.edu.cn)
wz1.printme()
wz2 Site(学习强国,www.xuexi.cn)
wz2.printme()程序结果 1
name: 福建农林大学
url: wwww.fafu.edu.cn
2
name: 学习强国
url: www.xuexi.cn8.7 继承考一道拉开成绩 继承是用来实现代码复用和设计复用的机制。设计一个新类时如果继承一个己有的设计良好的类然后进行二次开发无疑会大幅度减少开发工作量。在继承关系中已有的、设计好的类称为父类或基类新设计的类称为子类或派生类 python程序中继承使用如下语法格式标注 class 子类名(父类名)假设有一个类为AA派生出了子类B示例如下 class B(A):
class A(object): # 默认是继承自object的例 class Dog:food骨头def __init__(self,n,p):self.speciesnself.__price pdef shout(self):print(汪汪)class Spotty_dog(Dog):pass aSpotty_dog(斑点狗,2000)
a.shout()程序结果 汪汪在Python语言中object类是所有类的最终父类所有类最顶层的根都是object类。在程序中创建一个类时除非明确指定父类否侧默认从python的根类object继承。子类自动继承父类中的公共属性和方法子类不能继承父类的私有属性也无法在子类中访问父类的私有属性。子类可以增加新的属性父类与子类如果同时定义了名称相同的属性名称父类中的属性在子类中将被覆盖。 class Dog:food骨头def __init__(self,n,p):self.speciesnself.__price pdef shout(self):print(汪汪)class Spotty_dog(Dog):color白色 #增加新的属性food狗粮aSpotty_dog(斑点狗,2000)
a.shout()
print(a.food,a.color)
print(a.__price) # 出错 无法在子类中访问父类的私有属性class Dog:food骨头def __init__(self,n,p):self.speciesnself.__price pdef shout(self):print(汪汪)class Spotty_dog(Dog):def __init__(self,h): # 重新写属性self.color白色 #增加新的属性self.food狗粮
aSpotty_dog(200)
print(a.color)
bSpotty_dog(斑点狗,200) # 重写了属性 不会调用父类的属性
print(a.species) 程序结果 白色
Traceback (most recent call last):File /Users/eve/Desktop/PYTHON/SchoolCourse/第8章类/代码/2020-06-11/eg8_7_2.py, line 15, in modulebSpotty_dog(斑点狗,200)
TypeError: __init__() takes 2 positional arguments but 3 were given 思考8-12子类Shark继承Fish类产生Shark对象时能初始化其hungry属性为True请写Shark类代码。 import random
class Fish:def __init__(self):self.xrandom.randint(0,10)self.yrandom.randint(0,10)def move(self):self.x-1print(我的位置是,self.x,self.y)答 import random
class Fish:def __init__(self):self.xrandom.randint(0,10)self.yrandom.randint(0,10)def move(self):self.x-1print(我的位置是,self.x,self.y)
class Shark(Fish):def __init__(self):self.hungryTrueaShark()
print(a.hungry)super()函数 若Shark在产生对象时除了能有自己的hungry属性也想具有Fish类的x和y属性那该如何操作 super()函数:能够自动找到基类的方法而且还传递了self参数。调用方式 super().方法名称(参数)如super().__init__()可以调用父类中的构造函数这样子类也具有父类中构造函数里面的属性。 思考8-13 若Shark在产生对象时除了能有自己的hungry属性也想具有Fish类的x和y属性那该如何操作改进后的代码 import random as ran
class Fish:def __init__(self):self.xran.randint(0,10)self.yran.randint(0,10)def move(self):self.x-1print(我的位置是{},{}.format(self.x,self.y))
class Shark(Fish):def __init__(self):self.hungryTruesuper().__init__()
sShark()
s.move()程序结果 我的位置是0,5思考8_14:下面代码的运行结果是什么 class Foo(object):def __init__(self, a, b):self.a aself.b b
class Bar(Foo):def __init__(self, a, c): super().__init__(a,有担当) # 创建了a,b属性self.c c
n Bar(有理想,有本领)
print (n.a)
print (n.b)
print (n.c)程序运行结果 有理想
有担当
有本领思考8-15下面红色代码哪些是错误的 class Product( ):id 0def __init__(self,name,price):Product.idProduct.id1self.namenameself.__priceprice def getPrice(self): return self.__price def __setPrice(self,value):self.__pricevalue
class MobilePhone(Product):def __init__(self,name,price,standard):####### 一下错误的地方有哪些super().__init__(name,price)self.netstandardstandardprint(self.name)print(self.id)print(self.__price) print(self.getPrice())print(super().__setPrice()) ####### class Product( ):id 0def __init__(self,name,price):Product.idProduct.id1self.namenameself.__priceprice def getPrice(self): return self.__price # 返回数值def __setPrice(self,value):self.__pricevalue
class MobilePhone(Product):def __init__(self,name,price,standard):super().__init__(name,price)self.netstandardstandardprint(self.name)print(self.id)print(self.__price) # 错误 在类的外面print(self.getPrice())print(super().__setPrice()) # 错误 私有方法在外面都不能访问它aMobilePhone(iphone,2000,large) 程序运行 iphone
1
Traceback (most recent call last):File /Users/eve/Desktop/PYTHON/SchoolCourse/第8章类/代码/2020-06-11/si8_15.py, line 21, in moduleaMobilePhone(iphone,2000,large)File /Users/eve/Desktop/PYTHON/SchoolCourse/第8章类/代码/2020-06-11/si8_15.py, line 17, in __init__print(self.__price) # 错误
AttributeError: MobilePhone object has no attribute _MobilePhone__price子类继承父类中的非私有属性和非私有方法子类不能继承父类的私有属性和私有方法也无法在子类中访问父亲的私有属性和私有方法。子类可添加自己的属性和方法子类可重新定义继承父类的方法super()函数可以调用父类的公有属性和方法 Python支持多继承多继承就是子类拥有多个父类并且具有它们共同的特征即子类继承了父类公有的方法和属性 多继承 多继承可以看做是单继承的扩展语法格式如下 class 子类名(父类1,父类2,...)父类里的方法名相同默认从左到右调用括号里的父类 class Person:def __init__(self,myhair,myage):self.hairmyhairself.hand2self.__agemyagedef move(self):print(走路)class Fish:tail1def move(self):print(游泳)class Mermaid(Person,Fish):passaMermaid(长头发,20)
a.move()
print(a.tail)程序结果 走路
1思考 si8_16.py:下面代码的运行结果是什么
class Product(): def testClassicalClass(self):print(执行Product类)
class Computer(Product):def testMethod(self):print(执行Computer类)
class MobilePhone(Product):def testClassicalClass(self):print(执行MobilePhone类)
class SmartMobile (Computer,MobilePhone):def testMethod(self):print(执行SmartMobile类)
s SmartMobile() # Computer,MobilePhone
s.testClassicalClass() # Computer-MobilePhone-testClassicalClass-执行MobilePhone类
s.testMethod() # 父类与子类如果同时定义了名称相同的属性名称父类中的属性在子类中将被覆盖。程序结果 执行MobilePhone类
执行SmartMobile类8.9 运算符的重载 运算符重载对某种方法进行冲写如 23
5
#这边的加号两边是两个数值计算二者的和abcd
abcd
#这边的加法运算在字符串类中被赋予了新的功能这就是运算符重载为运算符定义方法被称为运算符的重载每个运算符都对应着一个函数因此重载运算符就是实现函数。 例如“”运算符是类里提供的__add__这个函数(并不是私有方法)当调用”“实现加法运算的时候实际上是调用了__add__方法 ab.__add__(cd)
abcd
# __add__方法重载了运算符“”
# 即m.__add__(n)与mn是一致的常用的运算符与函数的对应关系 运算符关系型运算符__add__(self,other)-__sub__(self,other)*__mul__(self,other)/__truediv__(self,other)//__floordiv__(self,other)%__mod__(self,other)**__pow__(self,other)__lt__(self,other)__le__(self,other)__eq__(self,other)__gt__(self,other)__ge__(self,other)!__ne__(self,other) [例] 定义Number类使得该类的对象x能与数值进行加法运算。如xNumber(5);x2结果为7 #eg8_10
class Number:def __init__(self,start): # start5self.datastart # self.data5def __add__(self,other): # _add_ return self.dataother # self.dataother 52xNumber(5)
print(x2)程序结果 7倘若想要实现xNumber()5,yNumber(7),print(xy) class Number:def __init__(self,start): # start5 start7self.datastart # xself.data5 yself.data7def __add__(self,other): return self.dataother.data # x.datay.data57xNumber(5) # 传递给self
#print(x2)
yNumber(7) # other的data
print(xy) # x传给selfy传给other程序结果 12#eg8_11
class Number:def __init__(self,a): # aab aabself.dataa # x.dataab y.dataab def __lt__(self,other): # xself yother return self.dataother.data # x.data y.data ababxNumber(ab)
yNumber(ab)
print(xy)程序结果 Falseclass Number:def __init__(self,a):self.dataadef __lt__(self,other):return self.dataother.data#xNumber(ab)
#yNumber(ab)
xNumber(2)
yNumber(4)
print(xy) 程序结果 True常用的运算符与函数的对应关系 运算符方法说明[index]__getitem__(self,index)按照索引取值__setitem__()按照索引赋值in__contains__(self,value)是否为成员len__len__(self)元素个数str__str__(self)与str()\print()对应要求该方法必须返回str类型的数据 [例]定义Number类类的对象x可以进行分片和修改元素的操作。 如:xNumber([1,2,3,4,5]);x[2:4][6] class Number:def __init__(self,a): # a[1,2,3,4,5]self.dataa[:] # 对a进行拷贝 self.data[1,2,3,4,5]def __getitem__(self,index): # 按照索引取值return self.data[index] # x[1,2,6,5]def __setitem__(self,index,value):self.data[index]value # x.data[2:4]6 xNumber([1,2,3,4,5]) # a[1,2,3,4,5] self.data[1,2,3,4,5]
x[2:4][6] # x中的3,4被替换成6了
print(x[:]) # x[1,2,6,5] 程序结果 [1, 2, 6, 5]__str()__重载时必须返回str类型的数据。当运行str(对象)或是print(对象)时会触发该方法。 class test:datal 10
atest()
tstr(a)
print(t) 程序结果 __main__.test object at 0x10ee26fd0class test:datal 10def __str__(self):return Hi, I am test
atest()
tstr(a)
print(t) 程序结果 Hi, I am test思考8_18:下面程序的运行结果是什么 class test:data1100def __init__(self,n):self.data2ndef __str__(self):return data1{},data2{}.format(self.data1,self.data2)
atest(20)
print(a) # print会触发 __str__()这个方法程序结果 data1100,data220思考8_19补充完整Rectangle类使得该类的对象可以进行如下运算 1.ab求出两个矩形的面积和。 2.ab:判断两个面积是否相等若ab,表达式的值为”相等“否则为”不相等“。 3.print(a):打印出该矩形的面积 class Rectangle:###补充完整使其对象能进行,,print操作def __init__(self,w,h):self.widthwself.heighthdef getArea(self):return self.width*self.height############################
aRectangle(2,4)
print(a)
bRectangle(3,6)
print(ab)
print(ab)答 class Rectangle:###补充完整使其对象能进行,,print操作def __init__(self,w,h):self.widthwself.heighthdef getArea(self):return self.width*self.heightdef __add__(self, other):return self.getArea()other.getArea()def __eq__(self, other):if self.getArea()other.getArea():return 相等else:return 不相等def __str__(self):return 该矩形的面积为str(self.getArea())
############################
aRectangle(2,4)
print(a)
bRectangle(3,6)
print(ab)
print(ab) 程序结果 该矩形的面积为8
26
不相等 思考8_19_1: #8_19_1
class Rectangle:def __init__(self,w,h):self.widthwself.heighthdef getArea(self):return self.width*self.heightdef __add__(self,other):return 两矩形的面积和是:str(self.getArea()other.getArea())def __eq__(self,other):if self.getArea()other.getArea():return 相等else:return 不相等def __str__(self):return 该矩形的面积是:str(self.getArea())if __name__ __main__: # 当作主程序运行print(I runs as main)
else: print(__name__,I runs as a module) # 当作模块导入另一文件运行程序结果 I runs as main若代码是主程序__name__值为__main__;若代码作为import模块__name__值为文件名 当被当作模块被导入其他文件运行 from si8_19_1 import Rectangle # 代码模块文件导入
aRectangle(2,4)
print(a)
bRectangle(3,6)
print(ab)
print(ab)程序结果 si8_19_1 I runs as a module
该矩形的面积是:8
两矩形的面积和是:26
不相等补充自定义异常类 有时候需要自定义一些异常类系统无法识别自定义的异常类只能在程序中使用raise抛出异常。raise唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类也就是Exception的子类 #eg8_13:
try: # try ... except 捕捉异常语句raise NameError # raise抛出异常类的子类
except NameError:print(An exception flew by!)程序结果 An exception flew by!思考8_20:运行该程序时输入15或150的结果是什么 def get_age():age int(input(请输入年龄(1-140):)) #15 150if age in range(1,141): #15 is in 150 is not inreturn age # 15 raise ValueError # 150 抛出异常try:age get_age() # 调用这个函数print(用户输入的年龄是, age) #15
except ValueError: print(用户输入的年龄不在1-140之间) # 150 程序结果 请输入年龄(1-140):15
用户输入的年龄是 15请输入年龄(1-140):150
用户输入的年龄不在1-140之间思考8_21:下面程序的运行结果是什么 class MyError(Exception):def __init__(self,value): # 4self.valuevalue # 4def __str__(self):return self.value try:raise MyError(2*2)
except MyError as e :print(An exception flew by!,e.value) 程序结果 An exception flew by! 4总结 类的定义与使用构造方法与析构方法属性公有与私有类属性与实例属性类的方法公有、私有、静态、类方法、抽象方法property内置函数与修饰词继承多态、运算符的重载 实验 一、 实验目的和要求 1类的继承2调用超类的构造方法3运算符重载 4异常处理 【题目描述】 请打开shiyan8_1.py补充完Vecter3的定义进行运算符重载使得该类能进行加法和乘法运算并能打印。程序另存为学号_1.py。程序运行结果如下 5,7,9
10,20,30解 ##请补充完类Vecter3的定义
class Vecter3(object):def __init__(self,x,y,z):self.Xxself.Yyself.Zzdef __add__(self,other):tVecter3(0,0,0)t.Xself.Xother.Xt.Yself.Yother.Yt.Zself.Zother.Zreturn tdef __mul__(self, n):tVecter3(0,0,0)t.Xself.X*nt.Yself.Y*nt.Zself.Z*nreturn tdef __str__(self):return str(self.X),str(self.Y),str(self.Z)
##下面代码请不要修改
if __name____main__:v1Vecter3(1,2,3)v2Vecter3(4,5,6)print(v1v2)print(v1*10) 程序结果 5,7,9
10,20,302.【题目描述】 以r模式打开用户输入的文件。若文件不存在系统会产生异常FileNotFoundError请捕捉该异常类然后输出“该文件不存在”。若文件存在让用户输入字符串保存到该文件中。当用户输入-1结束输入。当用户输入的字符串长度大于10要抛出InvalidError类。请捕捉InvalidError类并产生实例t执行print(t)和fp.close()。请打开shiyan8_2.py文件补充完代码程序另存为学号_2.py。 当输入的文件不存在程序运行结果如下所示 输入文件名ff
文件不存在当输入的文件存在时程序运行结果如下所示 输入文件名f1.txt
输入字符串hello
输入字符串You are welcome
输入的字符串太长长度为15解 class InvalidError(BaseException): def __init__(self,n):super().__init__()self.numndef __str__(self):return 输入的字符串太长,长度为str(self.num)####当文件不存在要能捕捉FileNotFoundError(系统产生的异常类)
####当文件存在用户输入数据保存到文件中
####若输入的字符串长度10抛出InvalidError(自定义的异常类)
####要能捕捉InvalidError
####当用户输入-1结束输入try:filename input(输入文件名:)fp open(filename , r)ch input(输入字符串)while ch!-1:if len(ch)10:fp.write(ch)chinput(输入字符串)else:raise InvalidError(len(ch))
except FileNotFoundError:print(文件不存在)
except InvalidError as t:print(t)fp.close()程序结果 输入文件名:ff
文件不存在输入文件名:f1.txt
输入字符串hello
输入字符串You are welcome
输入的字符串太长,长度为15
