Python语言程序设计实验报告

第二章：Python变量与数据类型
一、实验目的：
1.了解Python变量的概念与相关含义；
2.学习Python中的数据类型；
二、实验环境：
1.笔记本电脑
2.PyCharm Community Edition 2022.2.3工具

三、实验内容：
1.将字符串“Nice To Meet You !”中的大写字母全部改为小写字母。

实验源代码：

str1 = "Nice To Meet You !"
str2 = "WWW.jrcg.com"
print(str1)
print("转换后:",str1.lower())
print(str2)
print("转换后:",str2.lower())

实验结果：
在这里插入图片描述

2.找出字符串“nice to meet you !”中t 的个数和位置。

实验源代码：

def get_1_pos(string):
    onePos = []
    try:
        onePos = list(((pos, int(val)) for pos, val in enumerate(string) if val == 't'))
    except:
        pass
    return onePos


def get_1_num(string):
    return len(list(get_1_pos(string)))


def get_char_pos(string, char):
    chPos = []
    try:
        chPos = list(((pos, char) for pos, val in enumerate(string) if (val == char)))
    except:
        pass
    return chPos


def get_char_num(string, char):
    return len(list(get_char_pos(string, char)))


if (__name__ == "__main__"):
    str0 = "10101010101010101"
    str1 = "nice to meet you !"
    lt = get_1_pos(str0)
    print(lt)
    lt = get_1_pos(str1)
    print(lt)
    num = get_1_num(str0)
    print(num)
    lt = get_char_pos(str1, 't')
    print(lt)
    num = get_char_num(str1, 't')
    print(num)

实验结果：
在这里插入图片描述

3.用random.randint()函数生成100个[1，100]的随机整数，去掉重复的元素，然后从小到大排序并输出。

实验源代码：

import random
NumList=[]
new_num_list=[]
for i in range(100):#生成100个随机数
    NumList.append(random.randint(1,100))
for i in NumList:#列表去重
    if i not in new_num_list:
        new_num_list.append(i)
new_num_list.sort()#从小到达排序
print(new_num_list)

实验结果：
在这里插入图片描述

4.请用户输入月份，然后返回该月份属于哪个季节。

实验源代码：

print("-------月份判断开始-------")
spring = [3,4,5]
summer = [6,7,8]
fall = [9,10,11]
winter = [12,1,2]
month = int(input("请输入月份判断该月季节:"))
if month in spring:
    print("{}月，为春季，春暖花开！".format(month))
elif month in summer:
    print("{}月，为夏季，夏日炎炎！".format(month))
elif month in fall:
    print("{}月，为秋季，秋高气爽！".format(month))
elif month in winter:
    print("{}月，为冬季，银装素裹！".format(month))
else :
    print("输入的月份有误")

实验结果：
在这里插入图片描述

第三章：Python流程控制语句
一、实验目的：
1.了解Python流程控制语句；
2.学习列表推导式；
二、实验环境：
1.笔记本电脑
2.PyCharm Community Edition 2022.2.3工具
三、实验内容：
1.显示斐波那契数列

实验源代码：

# 斐波那契数列
nterms = int(input("你需要几项？"))

# 第一和第二项
n1 = 0
n2 = 1
count = 2

# 判断输入的值是否合法
if nterms <= 0:
    print("请输入一个正整数。")
elif nterms == 1:
    print("斐波那契数列：")
    print(n1)
else:
    print("斐波那契数列：")
    print(n1, ",", n2, end=" , ")
    while count < nterms:
        nth = n1 + n2
        print(nth, end=" , ")
        # 更新值
        n1 = n2
        n2 = nth
        count += 1

实验结果：
在这里插入图片描述

2.找出100以内能被3或7整除的，但不能同时被3和7整除的自然数。

实验源代码：

num = 1
count = 0
# 循环条件
while num < 100:
    # 循环体，设置条件
    # 补全代码
    if (num % 3 == 0 or num % 7 == 0) and num % 21 != 0:
        count = count + 1

    num = num + 1
print(count)

实验结果：
在这里插入图片描述

3.输出九九乘法表。

实验源代码：

for i in range(1,10):

    for j in range(1,i+1):

        a=i*j

        """把待输出的结果按要求格式保存成字符串"""

        string=str(j)+'x'+str(i)+'=' +str(a) +'\t'

        """把字符串打印到屏幕上,但不输出换行符"""

        print(string,end='')

    """换行"""

print('')

实验结果：
在这里插入图片描述
4.给定一个正整数rows,生成rows行杨辉三角。

实验源代码：

def main():
    num = int(input('Number of rows: '))
    yh = [[]] * num
    for row in range(len(yh)):
        yh[row] = [None] * (row + 1)
        for col in range(len(yh[row])):
            if col == 0 or col == row:
                yh[row][col] = 1
            else:
                yh[row][col] = yh[row - 1][col] + yh[row - 1][col - 1]
            print(yh[row][col], end='\t')
        print()


if __name__ == '__main__':
    main()

实验结果：
在这里插入图片描述

第四章：函数、模块和包
一、实验目的：
1.了解Python模块化概念与相关含义；
2.学习Python模块化技术及其标准模块；
二、实验环境：
1.笔记本电脑
2.PyCharm Community Edition 2022.2.3工具

三、实验内容：
1.定义一个名为add_two_numbers的函数，有两个参数：a和b，计算并返回a和b的和。
实验源代码：

def add_two_numbers(a,b):
     sum=a+b
     return sum

c=add_two_numbers(a=4,b=5)
print(f'the sum of 4 and 5 is {c}')

实验结果：
在这里插入图片描述

2.Python解释器根据变量定义的位置判断变量是全局变量还是局部变量。
实验源代码：

x=10
def outer():
    x=20
    def inner():
        x=30
        print("From inner():x{0:d}".format(x))
    inner()
    print("From outer():x={0:d}".format(x))

outer()
print("From module:x={0:d}".format(x))

实验结果：
在这里插入图片描述

3.创建名为calculator的模块范例，里面包括语句，函数和类。
实验源代码：

print("hello from caculator.py!")

def add(a,b):
    return a+b

class striangle:
    
     pass

实验结果：
在这里插入图片描述

4.用calendar模块实现闰年检测。

实验源代码：

from calendar import isleap
y = int(input("请输入要判断的年份："))
if isleap(y):
    print("是闰年")
else:
    print("不是闰年")

实验结果：
在这里插入图片描述

第五章：文件与目录操作
一、实验目的：
1.了解Python中的文件操作；
2.学习Python中的目录操作以及路径操作；
二、实验环境：
1.笔记本电脑
2.PyCharm Community Edition 2022.2.3工具

三、实验内容：

1.打开“write_example.txt”文件后，依次实现读取全部字符，读取三个字符，读取一行，读取三行，读取所有行。
实验源代码：

fo=open('D:\Download\write_example.txt','r',encoding='utf-8')
fo.read()
fo.seek(0)
fo.read(3)
fo.tell()
fo.seek(0)
fo.readline()
length=len('line\n'.strip())
fo.readlines(length*3)
fo.seek(0)
fo.readlines()

实验结果：
在这里插入图片描述

2：新建一个“write_example.txt”然后依次写入‘123456’，‘hello，world！’‘line1\n’,‘line2\n’,‘line3\n’
实验源代码：

fow= open ('D:\Download\write_example.txt','w',encoding='utf-8')

fow.write('123456')
fow.write('hello,world!\n')

fow.writelines(['line1\n','line2\n','line3\n'])

fow.close()

实验结果：
在这里插入图片描述

3：用with语句打开“write_example.txt”文件并读取全部行。
实验源代码：

with open ('D:\Download\write_example.txt','r',encoding='utf-8') as fo:
    for line in fo.readlines():
        print(line,end='')

fo.closed()
True

实验结果：
在这里插入图片描述

4：关闭文件对象的close()方法实现。
实验源代码：

fo=open('D:\Download\write_example.txt','r',encoding='utf-8')
fo.closed
False
fo.read()
'hello,world!'
fo.close()

fo.closed
True
fo.read()

实验结果：
在这里插入图片描述

第六章：类和对象
一、实验目的：
1.了解什么是类，如何定义和使用类；
2.学习类的高级操作；
二、实验环境：
1.笔记本电脑
2.PyCharm Community Edition 2022.2.3工具

三、实验内容：
1.定义一个圆类，属性有：半径r，初始值为1.0；方法有：设置半径值，获取半径值，计算周长，计算面积。
实验源代码：

from math import pi
class Circle():
    def _init_(self,r=1.0):
        self.r=r

    def get_radies(self):
        return self.r

    def set_radius(self,r):
     self.r=r

    def calc_circumference(self):
     return 2*pi*self.r

     def calc_area(self):
      return pi*self.r**2

实验结果：

在这里插入图片描述

2.Person类有属性name和age，方法say_hi()/Child类继承Person，并实例化一个Tony对象，执行say_hi方法。

实验源代码：

class Person():
 def __init__(self,name,age):
        self.name=name
        self.age=age
 def say_hi(self):
            print("Hi,I am {0:s} ,{1:d} years old.".format(self.name,self.age))

class Child(Person):
    pass
Tony=Child('Tony',5)

Tony.say_hi()

实验结果：
在这里插入图片描述

3.实例化一个Person类的时候，传入一个错误的年龄-20，这个错误无法被检查出来并处理，导致出现明显的错误。

实验代码：

class Person():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def say_hi(self):
            print("I am {0:s},{1:d} years old.".format(self.name,self.age))

Tony =Person('Tony',-20)

Tony.say_hi()

实验结果：
在这里插入图片描述

4.用@property装饰器实现上题Person类中age属性的访问。
实验代码：

1：
class Person():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    @property
    def age(self):
        return self._age
    @age.setter
    def age(self,age):
        if age<0:
            self._age=0
        elif age>200:
            self._age = 200
        else:
            self._age=age

    def say_hi(self):
            print("I am {0:s},{1:d} years old.".format(self.name,self.age))

Tony =Person('Tony',5)

Tony.say_hi()

2：
class Person():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    @property
    def age(self):
        return self._age
    @age.setter
    def age(self,age):
        if age<0:
            self._age=0
        elif age>200:
            self._age = 200
        else:
            self._age=age

    def say_hi(self):
            print("I am {0:s},{1:d} years old.".format(self.name,self.age))

Tony =Person('Tony',5)
Tony.say_hi()

Tom=Person('Tom',-5)
Tom.say_hi()

Amy=Person('Amy',230)
Amy.say_hi()

print(Tony.age+Tom.age+Amy.age)

实验结果：
1：
在这里插入图片描述

2：
在这里插入图片描述

第七章：网络编程
一、实验目的：
1.了解网络编程的基础知识；
2.学习socket模块中套接字类和内建方法；
3.学习如何使用socket模块开发TCP服务器，UDP服务器和客户端程序；
二、实验环境：
1.笔记本电脑
2.PyCharm Community Edition 2022.2.3工具

三、实验内容：
1.查看Python的套接字socket模块提供的套接字类和套接字对象内置方法。

实验代码：

import socket
tcp_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
print(type(tcp_socket))

print(dir(socket.socket))

实验结果：
在这里插入图片描述

2.TCP服务器端范例代码。

实验源代码：

import socket
HOST='127.0.0.1'
PORT=65432
tcp_server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
tcp_server.bind((HOST,PORT))
tcp_server.listen()
print("Server starts listening ...")
conn,addr=tcp_server.accept()
print("Connected by",addr)
while True:
    data =conn.recv(1024)
    if data ==b'close':
          print('Server is closed!')
          break
    print(data)
    conn.sendall(data)
conn.close()
tcp_server.close()

实验结果：
在这里插入图片描述

3.用request库实现HTTP客户端抓取网页信息。
实验源代码：

import requests
HEADERS={
    'User-Agent':
     'Mozilla/5.0 (Windows NT 10.0; Win64;x64) AppleWebKit/537.36(KHTML,like Gecko)Chrome/52.0.2743.116 Safari/537.36 Edge/15.15063'}
URL="http://www.baidu.com"

r=requests.get(url=URL,headers=HEADERS)
print(f"status code:{r.status_code};encoding:{r.encoding}")
print("HTTP Source Code:")
print(r.content.decode())

实验结果：
在这里插入图片描述

4.基于ThreadingTCPServer类的多线程并发服务器范例。

实验源代码：

import socketserver
class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
         conn=self.request
         conn.sendall(b"Welcome ThreadTCPServer!")
         while True:
              data=conn.recv(1024)
              if data==b"close":
                    print('Connection is closed!')
                    break
              print("Recieve %s from %s" %(data,self.client_address))
              conn.sendall(data)
if __name__=='__main__':
 server=socketserver.ThreadingTCPServer(('127.0.0.1',65432),MyServer)
 print("Start ThreadTCPServer!")
server.serve_forever()

实验结果：
在这里插入图片描述

第八章：并发编程
一、实验目的：
1.了解进程和线程概念与相关含义；
2.学习基于并发编程的Process类和基于线程并发教程的Thread类；
3.学习多线程与多进程执行不同任务的性能比较；
二、实验环境：
1.笔记本电脑
2.PyCharm Community Edition 2022.2.3工具

三、实验内容：
1.使用Condition对象实现线程同步范例，创建一个生产者和五个消费者，五个消费者必须先等待生产者先生产，当生产者完成生产后，通知消费者消费。
实验源代码：

from threading import Thread,Condition
g_sum=0
def consumer(con,id):
    global g_sum
    with con:
        print('Consumer %s waiting ...'%(id))
        con.wait()
        g_sum-=1
        print('Consumer %s consumed one resource'%(id))
def producer(con):
    global g_sum
    with con:
        print('Producer produce ten resources')
        g_sum+=10
        con.notifyAll()
if __name__ == '__main__':
    con=Condition()
    cs=[Thread(target=consumer,args=(con,i))for i in range(5)]
    p=Thread(target=producer,args=(con,))
    for c in cs:
           c.start()
    p.start()
    for c in cs:
        c.join()
print("g_num is left:%s.Exit..." %(g_sum))

实验结果：
在这里插入图片描述

2.Lock对象实现线程同步的范例
实验源代码：
没有使用线程同步机制

from threading import  Thread
g_sum=0
sum=499995000000
def child_thread():
    global g_sum
    for i in range(100000):
        g_sum=g_sum+i

if __name__ == "__main__":
     threads=[Thread(target=child_thread)for i in range(100)]
     for t in threads:
         t.start()
     for t in threads:
         t.join()
     print("g_sum should be:%s;g_sum:%s" %(sum,g_sum))

使用线程同步机制

from threading import  Thread,Lock
g_sum=0
sum=499995000000
def child_thread():
    global g_sum
    lock.acquire()
    for i in range(100000):
        g_sum=g_sum+i
    lock.release()

if __name__ == "__main__":
     threads=[Thread(target=child_thread)for i in range(100)]
     lock = Lock()
     for t in threads:
            t.start()
     for t in threads:
            t.join()
            print("g_sum should be:%s;g_sum:%s" %(sum,g_sum))

实验结果：
没有使用线程同步机制
在这里插入图片描述

使用线程同步机制
在这里插入图片描述

3.使用pool类创建多进程的第二种方法是使用map_async（）方法，把任务应用到可迭代对象的每一个元素上。
实验源代码：

from multiprocessing import Pool
import os,time
def task(id):
     print('child process %s works on the task %s' %(os.getpid(),id))
     time.sleep(2)

if __name__== "__main__":
      print("Parent Process %s starts" %os.getpid())
      p=Pool()
      p.map_async(task,range(20))
      p.close()
      p.join()
      print("Parent Process ends")

实验结果：
在这里插入图片描述

4.创建两个线程，一个线程负责向队列写入数据，命名为producer(生产者）；一个线程负责从队列读取数据，命名为consumer(消费者）；设置从队列读取数据的时间为2秒，若未能读取数据，则抛出异常。
实验源代码：

from threading import Thread
from queue import Queue
import os,time

def producer_task(q):
    for i in range(3):
        if not q.full():
            msg = "msg" + str(i)
            q.put(msg)
            print("producer puts:%s" % (msg))
        time.sleep(0.1)


def consumer_task(q):
    for i in range(3):
        msg = q.get(timeout=2)
        print("consumer gets:%s" %(msg))
        time.sleep(0.1)


if __name__=="__main__":
    print("Parent Process %s starts " %(os.getpid()))
    q = Queue()
    producer = Thread(target=producer_task, args=(q, ),name='producer')
    consumer = Thread(target=consumer_task, args=(q, ),name='consumer')

    producer.start()
    consumer.start()
    producer.join()
    consumer.join()
    print("Parent Process ends")

实验结果：

在这里插入图片描述

心得体会：
Python语言或许更适合作为一门入门语言。首先从从语法上讲，Python语言比现在很多作为第一编程语言（C/C++、Visual Basic等）要简单很多。其次，这种解释语言的机制，更能让初学者体验到学习成果，不需要了解很多东西，也能编出个小程序来，这个过程比其他语言要快和简单很多。再次，从自学或者教学的角度来讲，搭建Python的基础开发环境再简单不过了，只要安装一个十几兆的程序，就得到了一个命令行工具，一个简单的GUI的IDEL，还有其他文档等，这样不必把时间太多用在开发工具上了，而像学习C++等一般还要去逐步熟悉Visual C++等工具。此外，还有一点就是Python的学习很有弹性，你学一点就能做点东西，而想要深入研究仍然有无穷的方向可以选择，因为Python的应用范围就是很广阔。