Python学习题目综合2

y1skkk

已于 2023-08-18 21:51:21 修改

阅读量202

点赞数 1

文章标签：学习

于 2023-08-18 21:03:43 首次发布

本文链接：https://blog.csdn.net/qq_56383190/article/details/132369019

版权

这一部分因为相对而言更加综合，更加复杂了，相比于1而言应该会存在更多问题，谨慎参考。

这一部分主要涉及python面向对象编程和网络编程。

chap4

1.编写python程序完成下列要求：

（1）编写一个圆类，它包括表示半径的变量、构造方法、修改半径的方法、显示半径的方法以及计算圆面积的方法。

（2）继承圆类再编写一个圆柱体派生类，它包括表示高度的变量、构造方法、修改半径和高度的方法、显示半径和高度的方法以及计算圆柱体体积的方法。

（3）编写主模块定义这两个类的对象，并进行适当的赋值，对对象的值进行修改并显示对象的结果。

from math import pi
class circle:
    def __init__(self,radius):
        self.radius = radius
    def change(self,radius):
        self.radius = radius
    def get_square(self):
        square = pi*self.radius*self.radius
        return square
class cylinder(circle):
    def __init__(self, radius,height):
        circle.__init__(self,radius)
        super(cylinder,self).__init__(radius)
        self.height = height
    def change_radius(self,radius):
        self.radius = radius
    def change_height(self,height):
        self.height = height
    def get_volume(self):
        volume = pi*self.radius*self.radius*self.height
        return volume
if __name__ == '__main__':
    cir = circle(5)
    cir.change(2)
    squ = cir.get_square()
    cyl = cylinder(5,4)
    cyl.change_height(5)
    cyl.change_radius(4)
    vol = cyl.get_volume()
    print('圆的面积为',squ)
    print('圆柱的体积为',vol)

2.编写一个类ladd，它重载了“+”号，可以完成两个list对象的对应位相加，如：

ladd1=ladd([1,2,3]), ladd2=[3,4,5], ladd3=addd1+addd2，则ladd3为[4,6,8]

class ladd(object):                                      #面向对象编程
    def __init__(self,lst):                 
        self.data = lst                                 #导入列表
    def __add__(self,sec):                              #重载＋
        if len(self.data) != len(sec.data):             #当且仅当长度相同才可相加
            print("长度不等，无法相加！")
        else:
            ladd3 = ladd([])                 
            for i in range(len(self.data)):
                ladd3.data.append(self.data[i] + sec.data[i])#对应相加
            return lst3.data
    def print(self):                                    #由于ladd3为lst类，无法直接打印，故需要定义打印函数
        print(self.data)

if __name__ == '__main__':
    ladd1 = ladd([1,2,3])
    ladd2 = ladd([3,4,5])
    ladd3 = ladd(lst1+lst2)
    ladd3.print()

3.请编写一个人员类person，要求如：

（1）属性包含：身份证号、姓名和出生日期

（2）构造函数对属性进行初始化

（3）成员函数setPer可以重新设置其各个属性

（4）成员函数show可以显示其属性

（5）录入规则：身份证号必须为18位，姓名不低于1个汉字，高于16个汉字，出生日期不能高于当前日期，违反上述规，则报异常

（6）编写一个调用函数，利用人员类person，录入多人信息，形成人员列表。此程序允许用户不间断使用，即计算完毕一次询问用户是否继续计算，用户输入“是”，则继续；输入“否”，则终止录入。

（7）录入结束后，统计并输出某一年龄段的人，如大于18岁的人。

from datetime import datetime
class person:
    def __init__(self,ID,name,date_of_birth):
        assert len(ID) == 18,'身份证号必须为18位'                                       #运用断言报异常
        assert len(name) >1 and len(name) < 16,'姓名不低于一个汉字且不高于十六个汉字'
        format_pattern = '%Y-%m-%d'                                                    #定义标准格式
        cur_time = datetime.now()                                                      #获取当前时间
        cur_time = cur_time.strftime(format_pattern)                                   #当前时间标准化
        difference = (datetime.strptime(date_of_birth, format_pattern) - datetime.strptime(cur_time, format_pattern))
        assert difference.days < 0 ,'出生日期不得高于当前日期'                           #实现出生日期不能高于当前日期
        self.ID = ID
        self.name = name
        self.date_of_birth = date_of_birth
    def setPer(self,ID,name,date_of_birth):
        assert len(ID) == 18,'身份证号必须为18位'                                       #修改亦需要满足录入规则
        assert len(name.decode("utf-8")) >1 and len(name.decode("utf-8")),'姓名不低于一个汉字且不高于十六个汉字'
        format_pattern = '%Y-%m-%d'
        cur_time = datetime.now()
        cur_time = cur_time.strftime(format_pattern)
        difference = (datetime.strptime(date_of_birth, format_pattern) - datetime.strptime(cur_time, format_pattern))
        assert difference.days < 0 ,'出生日期不得高于当前日期'
        self.ID = ID
        self.name = name
        self.date_of_birth = date_of_birth
    def show(self):
        print('姓名:',self.name)
        print('身份证号:',self.ID)
        print('出生日期:',self.date_of_birth)

if __name__ == '__main__':
    information = []                                                                    #用列表存储信息
    infor_name = []
    infor_ID = []
    infor_date = []

    def record():                                                                       #用函数调用person
        switch = '是'                                                                   #判断是否继续的开关
        while switch == '是':
            name = str(input('请输入姓名(汉字):'))
            ID = str(input('请输入身份证号(18位):'))
            date_of_birth_y = str(input('请输入出生年份:'))
            date_of_birth_m = str(input('请输入出生月份:'))
            date_of_birth_d = str(input('请输入出生日:'))
            date_of_birth = '%s-%s-%s' %(date_of_birth_y,date_of_birth_m,date_of_birth_d)#将出生日期格式化
            person(ID,name,date_of_birth)
            infor_date.append(date_of_birth)                                            #将相关信息录入
            infor_ID.append(ID)
            infor_name.append(name)
            switch = str(input('是否继续录入(是/否):'))
            if switch == '否':
                break
    record()                                                                            #调用record函数
    information.append(infor_name)
    information.append(infor_ID)
    information.append(infor_date)                                                      #将信息都存储到一个列表
    format_pattern = '%Y-%m-%d'
    cur_time = datetime.now()
    cur_time = cur_time.strftime(format_pattern)
    print()
    print('大于18岁的如下:')
    for i in range(len(infor_date)):                                                    #遍历
        difference = (datetime.strptime(cur_time, format_pattern) - (datetime.strptime(infor_date[i], format_pattern)))
        if difference.days >= 6570:                                                     #18*365=6570
            print('姓名:',infor_name[i])
            print('身份证号:',infor_ID[i])
            print('出生日期:',infor_date[i])

chap5

1.利用TCP协议编写一个小型交互软件，要求如下：

（1）建立文件TCPT.py，在该文件中定义类TCPTalk,其析构函数传入ip地址和端口号，成为其私有属性；

（2）定义类TCPTalk的成员函数ServerU,建立一个服务器端应用，用于接收客户端的信息，并输出客户端发来的信息；

（3）定义类TCPTalk的成员函数ClientU,建立一个客户端应用，用于向服务器端发送信息

（4）建立文件STT.py，在该文件中引入TCPTalk类，并定义一个ServerApp函数，在该函数中声明一个该类的对象，调用ServerU函数，创建接收信息服务器，运行这个函数，等待客户端发来信息。

（5）建立文件CTT.py，在该文件中引入TCPTalk类，并定义一个ClientApp函数，声明一个该类的对象，调用ClientU函数，向（4）中的服务器发信息。运行这个函数，向服务器发送信息。

TCPT.py

#TCPT.py
from socket import *
from time import ctime

class TCPTalk:
    def __init__(self,ip,port) :
        self.__ip = ip
        self.__port = port
    def ServerU(self):
        
        setdefaulttimeout(500)
        host=self.__ip
        port=self.__port
        Buf=1024
        addr=(host,port)
        s=socket(AF_INET,SOCK_STREAM,0)
        s.bind(addr)
        s.listen(20)

        while True:
            print('等待客户连接...\r\n')
            cs,caddr=s.accept()
            print('...连接来自于:',caddr)
            data='欢迎你的到来！\r\n'
            cs.sendall(bytes(data,'utf-8'))
            while True:
                data=cs.recv(Buf).decode('utf-8')
                if data:
                    data='[%s]%s\r\n'%(ctime(),data)
                    cs.sendall(bytes(data,'utf-8'))
                    print(data)
                if not data:                    
                    break    
            print('连接断开！')
            cs.close()   
            break
        s.close()
    def ClientU(self):
        buf=1024
        addr=(self.__ip, self.__port)
        cs=socket(AF_INET,SOCK_STREAM,0)
        cs.connect(addr)
        data=cs.recv(buf).decode('utf-8')
        if data:
            print(data)
        while True:
            data=input('请输入内容:')
            if data:
                
                cs.sendall(bytes(data,'utf-8'))
                data=cs.recv(buf).decode('utf-8')
                if data:
                    print(data)
            else:
                break
        cs.close()

STT.py

#STT.py
from TCPT import TCPTalk
def ServerAPP():
    ip = '127.0.0.1'
    port = 8520
    link = TCPTalk(ip,port)
    link.ServerU()
ServerAPP()

CTT.py

#CTT.py
from TCPT import TCPTalk
def ClientApp():
    ip = '127.0.0.1'
    port = 8520
    link = TCPTalk(ip,port)
    link.ClientU()
ClientApp()

2.编写一个爬取网页信息的类，要求如下：

（1）构造函数中包含网页地址。

（2）编写一个接收网页头部信息的函数revhead()，返回网页的头部信息并打印。

（3）编写一个接收网页信息的函数revbody(file)，其中file本地文件的名称，接收到的网页信息可以存储在file文件中

（4）编写析构函数，输出“退出”字样。

（5）编写测试函数testWeb()，测试爬取网页信息。

import urllib.request
class crawl:
    def __init__(self,link) :
        self.link = link
    def revhead(self):
        content = urllib.request.urlopen(self.link)
        print("http header:",content.info())
    def revbody(self,file):
        content=urllib.request.urlretrieve(self.link,file)
        print(content)
    def __del__(self):
        print('退出')
def testWeb():
    cra = crawl('https://tieba.baidu.com/')
    cra.revhead()
    cra.revbody('D:\\Python\\experiment5\\crawl2.htm')
    cra.__del__()
testWeb()

在学习的过程中，参考了不少已有的分享，表示衷心感谢！

相关链接：Python学习题目综合1

相关链接：Python题3(泰坦尼克数据分析)