py期末 实验六七八

1 课件

11 面向对象（上）

1，
• 类：封装对象属性（数据抽象）和方法（行为抽象）的载体；
• 对象：类抽象出来的一个实例。
2，
3，类对象只有一个，而实例对象可以有多个
4，如果类中存在相同名称的类属性与实例属性，则通过实例对象只能访问
实例属性
5，构造方法在创建实例对象时被自动调用和执行
析构方法一般用来释放对象占用的资源，在删除对象和收回对象空间时
被自动调用和执行，
6，析构方法名称（del）是固定不变的，如果用户没有定义它，
Python将提供一个默认的析构方法。
• 当使用del语句删除一个对象时，会自动调用析构方法。
• 当程序结束时，Python解释器会自动检测当前是否存在未释放的对
象，如果存在，则自动使用del语句释放其占用的内存，如本例中的
s1对象。
8，

9，
10，字符串可以通过“+”运算符实现字符串连接操作，其本质是通过
__add__方法重载了运算符“+”

11，
12，

13，当对实例对象执行检查成员时，该对象会调用重载的__contains__()方法

11.2 面向对象（下）

1,的封装可以隐藏类的实现细节，迫使用户只能通过方法去访问数据。类似于JAVA私有化
2，Python中通过在属性名前加两个下画线来表明私有属性


3，

多继承按顺序

4，Python中所有的类都继承自object类
5，调用父类方法

6，父类的私有属性和方法是不会被子类继承的。因此，子类不能访问父类的私有成员

多态是指父类的同一个方法在不同子类对象中具有不同的表现
和行为，当调用该方法时，程序会根据对象选择合适的方法。
7，工厂模式主要用来实例化有共同方法的类，它可以动态决定应该实例化
哪一个类，不必事先知道每次要实例化哪一个类

12 文件

使用open()函数打开文件时，默认使用只读模式打开，此时
必须保证文件是存在的，否则会报文件不存在的错误
2，当对文件内容操作完以后，一定要关闭文件，这样才能保证所修改的数据保存到文件中。

使用with-as语句后，就不需要再显式使用close()方法。 另外with-as语句还可以打开多个文件
3，readlines()方法可以读取文件中的所有行
将文件中的每行内容作为一个字符串存入列表中

4，readline()方法可以逐行读取文件的内容
readlines()方法可以读取文件中的所有行
将文件中的每行内容作为一个字符串存入列表中并返回该列表

5，writelines()方法向文件中写入字符串列表

6，pickle模块中dump()函数可以实现序列化操作
pickle模块中load ()函数可以实现反序列化

7，文件指针是指向一个文件的指针变量，用于标识当前读写文件的位置

tell()方法可以获取文件指针的位置
seek()方法可以移动文件指针位置
8，
9，
创建多级目录，可以使用makedirs()函数
os模块的getcwd()函数可以获取当前目录
os模块的listdir()函数可以获取指定目录中包含的文件名与目录
名
10，walk()函数可以遍历目录树

13 异常

1. finally语句块用于清理在try块中执行的操作，如释放其占有的资源（如文件对象、数据库连接、图形句柄等）

2. 

3. 

4. 上例程序只能捕捉except后面的异常类，如果发生其他类型异常，程序依然会终止。
   上例程序只能捕捉except后面的异常类，如果发生其他类型异常，程序依然会终止。

5. 不带任何匹配类型的excep子句，必须作为最后一个except子句。

6. 可以使用as。

7. try-except-else语句用于处理未捕获到异常的情形

8. with-as语句可作为finally语句块的替代.当with内部语句块执行结束后，自动执行必要的清理工作，不管执行过程中有无异常发生。

9. Python允许在异常结构处理的内部嵌套另一个异常处理结构。在发生异常时，内部没有捕捉处理的异常可以被外层捕捉。

10. 

• 通过类名触发异常
  
  -异常类实例化触发异常
  
  

（指定异常信息）
11.
12. 难以直接确定触发异常的代码位置!如果需要确定触发异常的代码位置，可用traceback模块来查看详细信息。image

2 实验六 面向对象

选择

• 创建对象是通过调用构造方法完成的。
  构造方法的名称为__init__
• 隐藏对象的细节通常指的是 封装（Encapsulation）。封装是指将对象的状态（即数据）和行为（即方法）隐藏在类的内部，只允许通过公开的方法来访问或修改数据。
• Python中，不能利用对象访问类的私有成员X
  对于Python类中的私有成员，可以通过对象名._类名__私有成员名的方式来访问。stu._Student__age
• 在Python中，可以为自定义类的对象动态增加新成员。
  -times 是通过值传递的，也就是说 times 在 increment() 函数内的改变不会影响到 main() 函数中的 times 变量。
  myCount.count 是一个对象的属性，它在 increment() 函数中被直接修改，

def main():
    myCount = Count()
    times = 0

    for i in range(0, 100):
        increment(myCount, times)

    print("count =", myCount.count, "times =", times)

def increment(c, times):
    c.count += 1
    times += 1

class Count:
    def __init__(self):
        self.count = 0

main()

• 

class A:
    def __init__(self):
        self.x = 1
        self.__y = 1

    def getY(self):
        return self.__y

a = A()
a.__y = 45
print(a.getY())

• 当 b = B() 被调用时，首先会调用 A 类的 init(self) 方法，因为 B 继承自 A。在 A.init(self) 中，self.i 被初始化为 1。
  

class A:
    def __new__(self):
        self.__init__(self)
        print("A's __new__() invoked")

    def __init__(self):
        print("A's __init__() invoked")

class B(A):
    def __new__(self):
        print("B's __new__() invoked")

    def __init__(self):
        print("B's __init__() invoked")

def main():
    b = B()
    a = A()

main()

• --new--是静态方法，--init--是实例方法
  

编程

0 注意返回类型

      return 0.00
            return "0.00"
         print("%.2f" %a.length())
            #这时需要返回一个数字，如果返回字符串会报错或者不显示
         # print("{:.2f}".format(a.length()))
		 注意输入是float

1

 def toString(self):
        return "({},{})".format(self.x,self.y)
print（a.toString());
#占位符 {} 将被 str.format() 中传入的值所替代。
    #{索引:.2f}
x,y,n=map(int,input().split())
        #input返回字符串，split返回列表，map转化为整数，然后解包赋值
		
#print(a) 时，Python 会自动调用 a 对象的 __str__() 方法。如果你想打印 Point 对象的自定义字符串表示，应该重写 #__str__() 方法，而不是 toString() 方法。
	
#记得传入self
def __init__(self, x,y):

class Point:
    def __init__(self,x,y):
        self.x=x
        self.y=y
    def move(self,a,b):
        self.x+=a
        self.y+=b
    def toString(self):
        return str("(%d,%d)"%(self.x,self.y))

    # return "({},{})".format(self.x, self.y)
#多重输入 while 1和try—except
while 1:
  try:

    x,y,n=map(int,input().split())
    p = Point(x,y)
    for i in range (0,n):
        a,b=map(int,input().split())
        p.move(a,b)
    print(p.toString())
  except:
    break

2 力量

l.append(Girl(x,y))
for i in l:
    if i.x==Min:
        sum+=i.y
        cut+=1

3 立方体

from math import *
class Rect  :
    def __init__(self, l, h, z) :
        #考虑小于0的特殊情况
        if l<=0 or h<=0 or z<=0:
            self.l,self.h,self.z=0.00,0.00,0.00
        else :self.l,self.h,self.z= l,h,z
    def getLength(self) :
        return (self.l + self.h)*2.0
    def getArea(self) :
        return self.l*self.h
class Cubic(Rect) :
    def __init__(self,l,h,z):
        super().__init__(l,h,z)
        #调用父类init，写在子类init里
    def getVolume1(self):
        return self.l*self.h*self.z
    def getArea(self):
        return 2.0*((self.l*self.h)+(self.l*self.z)+(self.h*self.z))
class Pyramid(Rect):
    def __init__(self,l,h,z):
        super().__init__(l,h,z)
    def getVolume2(self,):
        return self.l*self.h*self.z/3.0
    def getArea(self):
        return sqrt(self.z**2+(self.h/2.0)**2)*self.l+sqrt(self.z**2+(self.l/2.0)**2)*self.h+self.l*self.h
 #多组输入while 1 tryexcept
while 1:
    try:
        l,h,z=map(float,input().split())
        #float
        c=Cubic(l,h,z)
        p=Pyramid(l,h,z)
        print("%.2f %.2f %.2f %.2f"%(c.getArea(),c.getVolume1(),p.getArea(),p.getVolume2()))
    except:
        break

4

class Shape:
    def length(self):
        pass
    #用pass

5 租车

注意id要减去1才是列表里的索引

class Car:
    def __init__(self,id,lr,lh,rent):
        self.id=id
        self.lr=lr
        self.lh=lh
        self.rent=rent


n=int(input())
l=[
Car(1,5,0,800),
Car(2,5,0,400),
Car(3,5,0,800),
Car(4,51,0,1300),
Car(5,55,0,1500),
Car(6,5,0.45,500),
Car(7,5,2.0,450),
Car(8,0,3,200),
Car(9,0,25,1500),
Car(10,0,35,2000)
]
ren,huo,pri=0,0,0
if(n==1):
    n=int(input())
    for i in range(n):
        m,n=map(int,input().split())
        # print(m,n)
        ren+=l[m-1].lr*n
        huo+=l[m-1].lh*n
        pri+=n*l[m-1].rent
        # print(pri,"**")
print(ren,str("%.2f"%huo),pri)

3 实验七 文件

选择

• 

• Python中用“a+”模式打开文件时，文件若不存在，就新建一个文件；文件指针在文件末尾，新写入的文件内容是在原来内容的基础上追加写入。

• Python中用“w+”打开文件时，若文件存在，就清空原文件内容；若不存在，就创建一个新文件，新文件可写、可读。

• read，readline返回字符串，readlines返回列表

• Python标准库os.path中isdir()方法用来判断指定路径是否为系统已存在的文件夹。

• 文件对象的tell()方法用来返回文件指针的当前位置。

• Python标准库os.path中isfile()方法用来判断指定文件是否为系统已存在的文

• os.remove() 方法 不能 直接删除带有只读属性的文件。在许多操作系统（例如 Windows）中，如果文件设置为只读属性（read-only），Python 的 os.remove() 方法会引发 PermissionError 异常，因为操作系统阻止修改或删除只读文件。

• Python内置函数___open_____ 用来打开文件。

• 内置函数 open() 的 mode 参数指定了打开文件后的处理方式。

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

• Python标准库os.path中用来判断指定文件或目录是否存在的方法是（ exists ）。

• open() 函数不仅可以打开已经存在的文件，还可以根据指定的模式创建新的文件。具体来说，open() 函数的行为取决于你选择的模式 (mode) 参数。

• read(size) .
  从文件当前位置开始，读取指定 size 大小的数据。如果 size 为负数或者空，则读取到文件结束。
  seek(2) 方法将文件指针移动到文件的第 2 个字节（从 0 开始计数）。

• 对文件进行写入操作之后，( flush)方法用来在不关闭文件对象的情况下将缓冲区内容写入文件。

• 标准库os库的rmdir(path)的作用是删除目录path，该目录中不能有文件或子文件夹

• 在 Python 的标准库 os 模块中，os.listdir() 用于列出指定路径下的所有文件和子文件夹（包括文件和文件夹的名称）

多选

1. 以只读方式打开d:\myfile.txt文件，以下代码正确的是（ ）。 f=open("d:\myfile.txt","r")
   f=open("d:\myfile.txt")

2. 

编程

1

f1=open("example.txt","r");
f2=open("result.txt","w");
str1=f1.read();
#read返回str。ord，chr
for i in str1:
    if 'A'<=i<='Z':
        f2.write(chr(ord(i)-ord('A')+ord('a')));
    elif 'a' <= i <= 'z':
            f2.write(chr(ord(i) - ord('a') + ord('A')));
    else:
        f2.write(i);
# f2.seek(0)
# print(f2.read())
f1.close()
f2.close()
#关闭文件

2

f1=open("letter.txt","r")
str1=f1.read()
num1,num2,num3=0,0,0
for i in str1:
    if 'A'<=i<='Z' or 'a' <= i <= 'z':
       num1+=1
    elif '0' <= i <= '9':
        num2+=1
    else:
        num3+=1
print(num1)
print(num2)
print(num3)
# f2.seek(0)
# print(f2.read())
f1.close()

#关闭文件

3

dic = {}  # 创建一个空字典 dic 用于存储单词及其出现次数
fo = open("dic.txt", "w")  # 打开（或创建）一个名为 dic.txt 的文件，用于写入统计结果

with open("freedom.txt", "r", encoding="utf-8") as f:
    while 1:
        s = f.readline()  # 逐行读取文件内容
        if not s:  # 如果读取到文件末尾返回空字符串，跳出循环
            break

        s=s.lower()
        for i in s:
            if i.isalpha()==False:
                s=s.replace(i," ")
            #如果不是字母就替换
        s=list(s.split())
             #按空格拆分成一个单词列表
        for i in s:
            if i in dic:
                dic[i]+=1
            else:
                dic[i]=1
for k,v in dic.items():
    l=k+":"+str(v)+"\n"
    fo.write(l)
	
	
import collections
score=open('freedom.txt','r',encoding='utf-8')
back=open('dic.txt','w',encoding='utf-8')
#utf防止中文报错

#把字符用“”连接。join返回字符串
#将英文字符变成小写字母
s=''.join([i.lower() if i.isalpha() else i for i in score.read()])
#将所有非英文字符变成空格
s=''.join([' ' if not i.isalpha() else i for i in s])
#将字符串变成单词列表
s=s.split()

#统计单词个数
counter1=dict(sorted(collections.Counter(s).items(),key=lambda x: x[1],reverse=True))
#按照“单词，单词个数”的格式输入到文件中，每个单词一行
'''
Counter 是一个特殊的字典子类，它会将单词作为键，单词出现的次数作为值。
aabc
Counter({'a': 2, 'b': 1, 'c': 1})
items() 返回字典中的键值对 (单词和出现次数)。
[('a', 2), ('b', 1), ('c', 1)]
sorted(..., key=lambda x: x[1], reverse=True) 对字典的项进行排序，排序的依据是每个单词的出现次数 (x[1])，reverse=True 表示按降序排列。
dict(...) 将排序后的项转换回字典，counter 是一个按出现次数排序的字典。
'''
back.write('单词,单词个数\n')   #作为表头的列名之间用英文的逗号隔开才能正确的别分成两列
for k,v in counter1.items():
    s=k+','+str(v)+'\n'
    back.write(s)

score.close()
back.close()

4

dic = {}  # 创建一个空字典，用来存储每个用户（或记录）和计算出的水费。
fo = open("fee.txt", "w")  # 打开 fee.txt 文件用于写入操作，但此行没有实际作用，因为下面的文件会覆盖它。

# 打开 water.txt 文件，读取文件内容
with open("water.txt", "r") as f:
    while 1:
        num = 0  # 初始化一个变量 num 来累加水费。
        s = f.readline()  # 读取水费记录文件的一行。
        if not s: break  # 如果文件读取到末尾（即 s 为空字符串），则退出循环。

        x = s[0:10]  # 提取字符串 s 的前 10 个字符
        s = s.split()  # 按空格分割这一行文本，得到一个列表 s，其中每个元素是分割后的子串。

        # 以下部分计算水费
        for i in range(1, len(s) - 1):  # 从第二个元素开始到倒数第二个元素！！！
            num += int(s[i + 1]) - int(s[i])  # 计算连续两个数字之间的差值，并将其加到 num 上。

        num *= 1.05
        num = round(num, 2)  # 将水费保留两位小数，四舍五入。

        dic.update({x: num})  # 将计算好的水费与对应的用户标识（x）存入字典 dic 中。

5

'''
data.txt中保存若干行文本。
请编写一个程序读取文件中文本，并统计输出文本的有效行数，
然后将结果保存到result.txt中。

程序代码必须保存到test.py中

输出格式：
有效行数为:6行
'''
with open('data.txt',encoding='utf8') as fp:
    txt=fp.readlines()
	//是readlines
num=0
for i in txt:
    if i !='\n':
        num+=1
with open('result.txt','w') as fp:
    #open函数返回一个文件对象
    fp.write(str("有效行数为:%d行"%num))

4 实验八 异常

选择

1. print(3/0) 时，实际上会引发 ZeroDivisionError 异常，而不是 ValueError。
2. ython所有内置异常类的基类是（ ）。
   BaseException
   不是exception
3. 对于具有父、子类关系的异常的排列，下列说法正确的是（ 没有顺序，谁在前谁先捕获 ）。
4. 当程序代码中产生异常，不便于处理时，下列哪种说法是正确的（ ）。
   抛出异常
5. except子句可能有多个

编程

1 带有异常处理的函数

def isPrime(num):
    try:
        num=int(num)
    except:
        return False
    #如果参数不是整数，返回False
    if num<=1:
        return False
    else:
        judge=True
        for i in range(2,num):
            if num%i==0:
                judge=False
                break
        return judge

2

A=input()
try:
    A=int(A)
    t=20/A
    print('20除以%d的结果是: %.2f'%(A,t))
    print('没有出现异常')
except ValueError:
    print('值错误，您必须输入数值')
except ZeroDivisionError:
    # 除0异常
    print("算术错误，您不能输入0")

3

try:
    n=int(input())
    s=0
    for i in range(n):
        a=float(input())
        #用eval
        s+=a
    avg=s/n
except ZeroDivisionError:
    print('除0错误，n不能等0')
except:
    print("数值错误")
else:
    print('正确')
    print('avg=%.2f'%avg)
finally:
    print('程序结束')
	
	
	
	
	
try:
    n=int(input())
    s=0
    for i in range(n):
        a=float(input())
        #用eval
        s+=a
    avg=s/n
except ZeroDivisionError:
    print('除0错误，n不能等0')
except:
    print("数值错误")
else:
    print('正确')
    print('avg=%.2f'%avg)
finally:
    print('程序结束')

4 try except-else-finally

n = int(input())
sum=0
cnt=0
x=0
try:
       for i in range(n):
           x=input()
        #不能直接转化否则后面没办法正常输出x
           sum+=int(x)
           cnt+=1
except:
       # print('Error for data "'+str(x)+'"! Break')
	   #注意里面输出的是双引号！！！！
       print('Error for data "%s"! Break'%x)
if cnt==n:
    print("All OK")
    print("avg grade = %.2f" %(sum/n))
print("Process Completed")

n = int(input())
s = 0
c = n
judge=True
while n>0:
    try:
        x = input()
        s += int(x)
        n-= 1
    except:
        #print(f'Error for data {x}! Reinput')
        print('Error for data '+x+'! Reinput')
        judge=False
        continue
if judge:
    print('All OK')
print('avg grade = %.2f'%(s/c))

5

 except NameError:
        print("NameError")#未定义的变量ab ab+23
    except ZeroDivisionError:
        print("ZeroDivisionError")#除0异常
    except SyntaxError:
        print("SyntaxError")#不是一个有效的浮动数值23+36f