小学期学习Python编程实训实验报告3

1.编写函数计算圆的面积

def area(r):                    #定义一个函数，接收圆的半径，返回圆的面积
    '''accept an integer r.
        return the area of circle.'''
    pi = 3.14
    return pi*r*r

r = int(input('圆的半径为:'))
s = area(r)                     #调用函数计算圆的面积
print('圆的面积为:',s)

2.假设一段楼梯共15个台阶，小明一步最多能上3个台阶，那么小明上这段楼梯一共有多少种方法？编写函数实现

def fun(n):                         #定义一个函数，接收台阶数，返回方法的数量
    '''recive an integer r.
        return the number of ways'''
    x=1
    y=2
    z=4
    for i in range(n-3):            #递推计算方法数量
        z,y,x=x+y+z,z,y
    return z

n=15
number = fun(n)                     #调用函数计算方法数量
print('共有',number,'种方式')

3.自定义集合。模拟Python内置集合类型，实现元素添加、删除以及并集、交集、对称差集等基本运算

class Newmode:
    '''自定义一个类，模拟Python内置集合类型，
        实现元素添加、删除以及并集、交集、对称差集等基本运算。'''

    #定义一个方法，以自动传入参数
    def __init__(self, *args):
        if not args:
            self.value = {}
        else:
            self.value = set(args)

    #定义一个方法，实现集合的元素添加   
    def set_add(self, n):
        self.value.add(n)
        return self.value

    #定义一个方法，实现集合的元素删除
    def set_remove(self, n):
        if n not in self.value:
            print('error!集合中不含该元素!')
        else:
            self.value.remove(n)
            return self.value
        
    #定义一个方法，实现集合的并集
    def set_union(self, set2):
        return self.value | set2.value

    #定义一个方法，实现集合的交集
    def set_inter(self, set2):
        return self.value & set2.value

    #定义一个方法，实现集合的差集
    def set_dif(self, set2):
        return self.value - set2.value

    #定义一个方法，实现集合的对称差集
    def set_symdif(self, set2):
        return self.value^set2.value
        
#提示用户使用方式
if __name__ == '__main__':
    print('Please use me as a module.')

4.编程检查并判断密码字符串的安全强度。通过键盘输入字符串，如果该字符串中包含字符少于6个，则密码等级输出为weak。如果字符串长度不少于6个字符，且包含数字、大写字母、小写字母、其他符号（这里考虑如下符号,.!;?<>），密码等级将根据包含字符的类型进行判断。如果包含任意两种字符，比如输入密码为12345a，则密码等级为below middle；如果包含任意三种字符，比如输入密码为ASD1ab，则密码等级为above middle；如果包含四种字符，比如输入密码为ASD<1ab，则密码等级为strong

#定义一个函数，判断字符串中是否含有数字
def number(x):
    for i in x:
        if i.isdigit() == True:
            return 1
    return 0
#定义一个函数，判断字符串中是否含有大写字母
def upletter(x):
    for i in x:
        if i.isupper() == True:
            return 1
    return 0
#定义一个函数，判断字符串中是否含有小写字母
def lowletter(x):
    for i in x:
        if i.islower() == True:
            return 1
    return 0
#定义一个函数，判断字符串中是否含有字符
def sign(x):
    n=",.!;?<>"
    for i in x:
        if i in n:
            return 1
    return 0

x=input()
l=len(x)            #获取输入的字符串的长度
level = 0
if number(x) == 1:
    level+=1
if upletter(x) == 1:
    level+=1
if lowletter(x) == 1:
    level+=1
if sign(x) == 1:
    level+=1
if l < 6:
    level = 1
if level == 1:
    print('weak')
elif level == 2:
    print('below middle')
elif level == 3:
    print('above middle')
elif level == 4:
    print('strong')

5.编写函数，判断一个整数是否为素数，并编写主程序调用该函数

import sys  						#调用sys模块

x = int(input())

if x > 1:
    for i in range(2,x):       		#遍历2到x-1，判断是否有因数
        if (x % i) == 0:
            print(x, '不是素数')
            sys.exit()          	#找到除了1和本身外的其他因数时，结束程序
    print(x, '是素数')
else:
    print(x, '不是素数')

6.编写函数，接收一个字符串，分别统计大写字母、小写字母、数字、其他字符的个数，并以元组的形式返回结果

#定义一个函数，接收一个字符串，判断其中大小写字母、数字和字符的个数
def judge(str):
    num = [0,0,0,0]
    for i in str:
        if i.isupper() == True:     		#判断大写字母个数
            num[0] += 1
        elif i.islower() == True: 	    #判断小写字母个数
            num[1] += 1
        elif i.isdigit() == True:  	    #判断数字个数
            num[2] += 1
        else:                        #判断其他字符个数
            num[3] += 1
    num = tuple(num)                #将列表转换为元组
    return num

x = input()
n = judge(x)
print(n)

7.编写函数，可以接收任意多个整数并输出其中的最大值和所有整数之和

#定义一个函数，接收若干个整数，返回最大值和整数之和
def inti(n):
    m = max(n)              #获取最大值
    s = sum(n)              #获取整数之和
    l = []
    l.append(m)
    l.append(s)
    return l

x = input().split()         #输入若干个整数并拆分为列表
for i in range(0,len(x)):   #遍历所有数转为整型
    x[i] = int(x[i])
l = inti(x)
print('最大值为:', l[0],',和为:', l[1] )

8.编写函数，模拟内置函数sum()

#定义一个函数，模拟内置函数sum
def newsum(x):
    s = 0
    for i in range(0, len(x)):
        s += x[i]
    return s

x = input().split()         #将输入的数拆分为列表
for i in range(0, len(x)):  #遍历每一个数转为整型
    x[i] = int(x[i])
s = newsum(x)
print(s)

9.编写函数，模拟内置函数sorted()

#定义一个函数，模拟内置函数sorted
def newsorted(old):
    new = []                    #定义一个空列表，存储排序后的列表
    for i in range(0,len(old)): #遍历原列表中每个数
        x = min(old)            #找出最小数
        new.append(x)           #将最小数加入空列表
        old.remove(x)           #删除原列表中最小数
    return newsorted            #返回排序后的列表
        
x = input().split()             #输入若干个数，切片存入列表
y = newsorted(x)
print(y)

10.设计一个三维向量类，并实现向量的加法、减法以及向量与标量的乘法和除法运算

class Vector:
    '''定义一个关于三维向量的类，接收一个向量，
        实现向量的加法、减法以及向量与标量的乘法和除法运算'''

    #定义一个方法，以自动传入参数
    def __init__(self, *args):
        if not args:
            self.value = ()
        else:
            for i in args:                  #判断输入的向量中是否都是数字
                if not self.isnumber(i):
                    print('每个元素都需要是数字！')
                    return
            if len(args) != 3:              #判断输入是否是三维向量
                print('请输入三维向量！')
                return 
            else:
                self.value = tuple(args)

    #定义一个方法，判断输入是否是数据
    def isnumber(self, n):
        return isinstance(n, (int, float, complex))

    #定义一个方法，实现向量的加法
    def vec_add(self, n):
        b = []                                  #定义一个空列表保存向量的和
        for i, j in zip(self.value, n.value):   #将两个向量对应位置元素相加
            b.append(i + j)                     #将相加后的元素存入列表
        return tuple(b)                         #将列表转为元组

    #定义一个方法，实现向量的减法
    def vec_sub(self, n):
        b = []                                  #定义一个空列表保存向量的和
        for i, j in zip(self.value, n.value):   #将两个向量对应位置元素相减
            b.append(i - j)                     #将相减后的元素存入列表
        return tuple(b)                         #将列表转为元组
 

#定义一个方法，实现向量与标量的乘法
    def vec_mul(self, n):
        if not isinstance(n, (int, float, complex)):#判断标量的数据输入是否正确
            print('标量请输入数字！')
            return
        b= []                                   #定义一个空列表保存向量和标量的乘积
        for i in self.value:                    #将向量对应位置元素与标量相乘
            b.append(i * n)                     #将相乘后的元素存入列表
        return tuple(b)                         #将列表转为元组

    #定义一个方法，实现向量与标量的除法
    def vec_div(self, n):
        if not isinstance(n, (int, float, complex)):#判断标量的数据输入是否正确
            print('标量请输入数字！')
            return
        if n == 0:                              #判断标量是否为0
            print('除数不能为0！')
            return
        b= []                                   #定义一个空列表保存向量和标量的商
        for i in self.value:                    #将向量对应位置元素与标量相除
            b.append(i / n)                     #将相除后的元素存入列表
        return tuple(b)                         #将列表转为元组

#提示用户使用方式
if __name__ == '__main__':
    print('Please use me as a module.')