实验2 Python函数与类

实验2.1：公式计算

题目描述：编写三个函数fz(n), fm(n), sum_(n)分别计算下列公式的分子和，分母积以及公式总和值。

提示：采用函数嵌套实现

def sum(n):
    def fm(n):
        sum1 = 1
        for i in range(1, n+1):
            sum1 *= i
        return sum1

    def fz(n):
        sum2 = 0
        for i in range(1, n+1):
            sum2 += i
        return sum2

    sum3 = 1
    for i in range(2, n+1):

        sum3 += fz(i) / fm(i)

    return sum3
n = int(input("请输入一个正整数："))
print(sum(n))

实验2.2：阶乘计算
题目描述：编写一个函数fac(n )求给定整数的阶乘，调用此函数实现以下公式。

提示：采用递归实现

def fac(n):
    if n == 0:
        return 1
    sum = 1
    for i in range(1, n+1):
        sum *= i
    return sum


print("请输入两个数字，前大，后小")
a, b = map(int, input().split())
c = fac(a)/(fac(b)*fac(a-b))
print(int(c))

实验2.3：回文数判断
题目描述：编写一个函数isHui(n)，用以实现对正整数n判断是否是回文数。
提示：回文数定义：是指顺读与倒读数字相同的正整数。如12321。说明如下：
（1）求字符串长度函数len(s)
（2）当前位置为i，则其对称位置为j=len(s)-1-i
（3）切片方法取出字符判断是否相对：s[i:i+1]==s[j:j+1]

def isHui(n):
    len1 = len(n)
    flag = 1
    for i in range(0, len1//2+1):
        if n[i] == n[len1-i-1]:
            continue
        else:
            flag = 0
            break
    return flag


a = input("请输入一个数字:")
if isHui(a):
    print(a, "是回文数")
else:
    print(a, "不是回文数")

实验2.4：找最长单词
题目描述：编写一个函数maxWord(s)，用以找出已知字符串s中的最长单词。
提示：输入“I am a student and my name is wpf!”，输出“student”。相关说明如下：
（1）查找空格函数i=s.find(’ ')，通过while i>0循环查找
（2）取出当前单词：tempword=s[ ：i]
（3）剔除单词，重新赋值句子：s=s[i+1：]

def maxWord(s):
    i = s.find(' ')
    temp = ' '
    while i > 0:
        tempword = s[: i]
        
        if(len(tempword)>len(temp)):
            temp = tempword

        s = s[i+1:]
        i = s.find(' ')
    print(temp)


s = input("请输入一串字符:")
maxWord(s)

实验2.5：类的定义
题目描述：定义一个dog类，包含name、age、weight等属性，设计一个构造函数对这些属性记性初始化，然后实现并测试这个类。

class dog:
    def __init__(self, name, age, weight):
        self.name = name
        self.age = age
        self.weight = weight

    def printme(self):
        print('name:', self.name)
        print('age:', self.age)
        print('weight:', self.weight)
    
do = dog('mmm','2','20')
do.printme()

实验2.6：类的单继承
题目描述：定义一个 person基类，包含公有属性：姓名name、年龄age，具有speak()公有方法；从person类中派生出一个teacher子类，该类新增私有属性：专业profession、职称title、主讲课程course，并定义重写基类speak( )方法。
提示：实例测试
​​
结果输出：

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def speak(self):
        print("My name is %s,I am %d years old" %(self.name,self.age))

class Teacher(Person):
    def __init__(self,name,age,profession,title,course):
        Person.__init__(self,name,age)
        self.profession = profession
        self.title = title
        self.course = course
    def speak(self):
        print("My name is %s,I am %d years old.And my profession is %s,my title is %s,my master course is %s" %(self.name,self.age,self.profession,self.title,self.course))

s = Teacher('xxx',42,'computer science and technology','associate professor','Python programming desiging')
s.speak()

实验2.7：类的多继承
题目描述：定义一个student基类，包含公有属性：学号sid、班级class_，具有study()公有方法；再定义一个teacher基类，包含公有属性：工号tid、学院dept，具有teach()公有方法；然后从student和teacher两个基类公共派生出一个doctor子类，该类新增公有属性：姓名name、年龄age，具有introduce()公有方法，不需要重写两个基类方法。
提示：实例测试
​​
结果输出：
​​

class student:
    def __init__(self,id,class_):
        self.id = id
        self.class_ = class_
    def study(self):
        print("My student'id is %s" %(self.id))
        print("I major in  %s" %(self.class_))

class teacher:
    def __init__(self,tid,dept):
        self.tid = tid
        self.dept = dept
    def teach(self):
        print("And my teacher'id is %s" %(self.tid))
        print("I am %s" %(self.dept))

class doctor(student,teacher):
    def __init__(self,id,class_,tid,dept,name,age):
        student.__init__(self,id,class_)
        teacher.__init__(self,tid,dept)
        self.name = name
        self.age = age

    def introduce(self):
        print("My name is %s,I am %d years old" %(self.name,self.age))
        
d1 = doctor('2011038','Agricultural machinery engineering','2001020','college of imformations','xxx',34)
d1.introduce()
d1.study()
d1.teach()       

实验2.8：类的运算符重载
题目描述：定义一个三维向量类Vector3，并定义相应的特殊方法实现两个该类对象之间的加、减运算（要求支持运算符+、-），实现该类对象与标量的乘、除运算（要求支持运算符*、/），以及向量长度的计算（要求使用属性实现，其中向量长度是向量所有分量平方和的平方根）。
提示：通过类的专有方法__add__()、 __ sub__ ()、__ mul() 、 truediv() __ 分别实现+、-、、/运算符重载；通过类的专有方法__ str __ ()查看向量，格式化显示向量坐标分量；通过自定义方法length(self)计算向量长度，并@property方法将向量长度设置为属性值。具体做法如下：
（1）定义向量构造方法：__ init __ (self, x, y, z)，实现向量初始化Vector3(x, y, z)
（2）定义向量与另一个向量的加法+运算：__ add __ (self, anotherPoint)
（3）定义向量与另一个向量的加法-运算：__ sub__ (self, anotherPoint)
（4）定义向量与某一个标量的乘法运算：__ mul __ (self, n)
（5）定义向量与某一个标量的除法/运算：__ truediv __ (self, n)，注意：此处不是__ div __
（6）定义向量查看方法：__ str __(self)，格式化显示向量坐标分量
（7）定义向量长度计算方法：length(self)，实现向量所有分量平方和的平方根。
（8）实例测试：
​​
结果输出：
​​

class Vector3:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    def __add__(self, other):
        return Vector3(self.x + other.x, self.y + other.y, self.z + other.z)

    def __sub__(self, other):
        return Vector3(self.x - other.x, self.y - other.y, self.z - other.z)

    def __mul__(self, n):
        return Vector3(self.x * n, self.y*n, self.z*n)

    def __truediv__(self, n):
        return Vector3(self.x / n, self.y/n, self.z/n)

    def __str__(self):
        return "Vector3(%d,%d,%d)" % (self.x, self.y, self.z)
    @property
    def length(self):
        return (self.x**2 + self.y**2 + self.z**2) ** 0.5


v1 = Vector3(3, 4, 5)
v2 = Vector3(5, 6, 7)
print(v1+v2)
print(v1-v2)
print(v1*3)
print(v2/2)
print(v1.length)