Python基础教程(微课版)林子雨课后习题

---

第一章课后习题

1. Python语言具有哪些优点？具有哪些缺点？

答：优点：语言简洁明了、跨平台、面向对象、开源免费、强大的生态系统。
缺点：执行速度相对来说较慢、多线程瓶颈、代码不能加密、2.x和3.x不兼容。

2. Python语言可以应用到哪些领域？

答：Python语言发展到今天，已经被广泛应用于数据科学、人工智能、网站开发、系统管理和网络爬虫等领域。

3. Python2.x和Python3.x有哪些区别？

答：Python官方网站目前同时发行Python2.x和Python3.x两个不同系列的版本，并且彼此之间不兼容，除了输入输出方式有所不同，很多内置函数的实现和使用方式也有较大差别。总体而言，在语法层面，二者的主要区别表现在以下几个方面：
（1）在Python2.x中，print语句被Python3.x中的print()函数所代替；
（2）在Python3.x中，整数之间的相除（采用除法运算符“/”实现），结果是浮点数，而在Python2.x中结果是整数；
（3）Python3.x源码文件默认使用UTF-8编码，所以支持直接写入中文，而Python2.x默认编码是ASCII，直接写入中文会被转换成ANSI编码。所以在Python2.x中需要进行相应的转换；
（4）在Python3.x中将range()与xrange()函数整合为一个range()函数，所以在Python3.x中不存在xrange()函数，而在Python2.x中这个两个函数是并存的。

4. 请阐述什么时候适合用Python2.x？

答：Python2.x提供了丰富的第三方库，Python3.x目前还在不断丰富完善中，有些在Python2.x中提供的第三方库，可能暂时无法在Python3.x中获得支持，这个时候就需要使用Python2.x。(不建议使用2.x版本，因为已经放弃更新了。)

5. 常见的Python第三方开发工具有哪些？

答：Pycharm、eclipse、vscode等…

6. 在Python中如何进行注释？

答： #单行、‘’’ ‘’’ 或 “”" “”"多行注释

7. 请举出IDLE中几个常用的快捷键。

答：F1 打开Python帮助文档
F5 运行Python代码文件
Ctrl+] 缩进代码块
Ctrl+[ 取消代码块缩进
Ctrl+Z 撤销一步操作
Ctrl+Shift+Z 恢复上一次的撤销操作
Ctrl+S 保存文件
Alt+3 注释代码块
Alt+4 取消代码块注释

8. 请阐述如何实现代码的缩进。

答：Tab 或 4个 Space

第二章课后题

1．请列举Python 语言中的10 个关键字。

答：if、elif、for、while、break、continue、input、print、pass、global…

2．请阐述Python 标识符的具体命名规则。

答：（1）一个标识符可以由几个单词连接而成，以表明它的意思；
（2）标识符由一个或多个字母（A~Z 和 a~z）、数字、下划线（_）构成，并且第一个字符不能是数字，没有长度限制；
（3）标识符不能是关键字；
（4）标识符中的字母是严格区分大小写的；
（5）标识符中不能包含空格、@、%和$等特殊字符；
（6）应该避免标识符的开头和结尾都使用下划线的情况，因为Python中大量采用这种名字定义了各种特殊方法和变量。

3．请给出合法标识符和非法标识符的几个实例。

答：legal:Akon、Exo、Max_num、Min_num…
illegal:857Name、$name、for…

4．请阐述变量的命名规则。

答：（1）变量名必须是一个有效的标识符；
（2）变量名不能使用Python中的关键字；
（3）应选择有意义的单词作为变量名。

5．请阐述Python 3.x 中有哪6 个标准数据类型，并说明其中哪些是基本数据类型，哪
些是组合数据类型。

答：基本数据类型：数字、字符串
组合数据类型：列表、元组、字典、集合

6．请给出十进制整数、八进制整数、十六进制整数和二进制整数的具体实例。

答：十进制：0,-3,10这些
八进制：使用0,1,2,3,4,5,6,7来表示数字，并且必须以0o开头，比如0o43、-0o123
十六进制：0,1,2,3,4,5,6,7,8,a,b,c,d,e,f组成，必须以0x/0X开头，比如0x36、0Xa21f
二进制：0101就完事了

7．请给出几个常用的转义字符并说明其含义。

\n：换行
\t：制表符
\：
\r：回车符

8．请给出几个常用的数据类型转换函数并说明其含义。

int(x)：转整形
float(x)：转浮点型
str(x)：转字符串
touple(x)：转元组
set(x)：转集合

9．请举例说明input()和print()函数的用法。

答：input()：接受一个键盘输入的值作为参数，返回一个字符串类型的参数;
print()：打印输出结果

s = inpit("Enter your name:") #假如说键盘输入了:Love
print(s) #打印Love

10．请说明运算符的优先级与结合性。
答：

第三章课后题

1.编写程序，功能如下：判断输入的一个整数能否同时被2和3整除，若能，则输出“Yes”；否则输出“No”。（可使用input和eval函数进行数据的输入）

num = int(input("请输入数字，判断是否能被2和3同时整除:"))

if num%2==0 and num%3==0:
    print("yes")
else:
    print("no")

2.空气质量问题一直是社会所关注的，一种简化的判别空气质量的模式如下：PM2.5数值0-35为优，35-75为良，75以上为污染，请编写程序实现如下功能：输入PM2.5的值，输出当日的空气质量情况。

pm = float(input("Pm2.5的值，判断空气质量:"))

if pm > 0 and pm <= 35:
    print("优")
elif pm > 35 and pm <= 75:
    print("良")
elif pm > 75:
    print("污染")

3.编写程序，实现分段函数的计算，分段函数如下：

x = eval(input("请输入一个数:"))
if x < 5:
    y = 0
elif x>=5 and x<10:
    y = 5*x-25
else:
    y = pow(x-5,2)
print(y)

4.编程实现如下功能：输入层数x，打印出类似下面的等腰三角形（图中x=5）

     *
    ***
   *****
  *******
 *********

x = int(input("请输入层数:"))
for i in range(1,x+1):
    print(' ' * (x - i) + "*" * (2 * i- 1))

5.求1到10000内的所有完美数，完美数：这个数的所有真因子（即除了自身的所有因子）的和恰好等于它本身。例如：6（6 = 1 + 2 + 3）和28（28 = 1 + 2 + 4 + 7 + 14）就是完美数。

# 求1~10000的完美数，即这个数的所有真因子的和恰好等于它本身
perfact_num = [];
for number in range(2, 10000):
    factor_sum = 1 #初始化因子总和1
    for i in range(2, int(number ** 0.5) + 1):
        if (number % i == 0):
            factor_sum += i
            # 避免重复计算相同的因子
            if (i != number // i):
                factor_sum += number // i

    if factor_sum == number:
        perfact_num.append(number)

print("1~10000的回文数:{}".format(perfact_num))

6.编程找出15个由1，2，3，4四个数字组成的各位不相同的三位数（如123，341，反例如442，333），要求用break控制个数

# 找出15个由1，2，3，4组成的三位数
count = 0
for i in range(1,5):
    for j in range(1,5):
        for k in range(1,5):
            num = i*100+j*10+k
            print(num)
            count+=1
    if (count >= 15):
        break

7.一张纸的厚度大约是0.08mm，编程求对折多少次之后能达到珠穆朗玛峰的高度（8848.13米）？

# 一张0.08mm的纸叠多少次达到8848.13米？
paper = 0.08
mount = 8848.13
count = 0

while( paper < mount ):
    paper = paper*2
    count+=1

print(count)

8."百马百担"问题：一匹大马能驮3担货，一匹中马能驮2担货，两匹小马能驮1担货，如果用一百匹马驮一百担货，问有大、中、小马各几匹？

# 白马白担问题 大马 3、中马 2、小马 1/2
cargo = 100

for i in range(101):
    for j in range(101):
        for k in range(101):
            if i+j+k == cargo and 3*i+2*j+k/2 == cargo:
                print(i,j,k)
                break

9.编程实现一个猜数字游戏，要求如下：
在1到1000中随机生成一个数赋值给sys_num
控制台输入一个整数 赋值给 user_num
判断user_num与sys_num的关系
如果 user_num 大于 sys_num 提示 猜大了
如果 user_num 小于 sys_num 提示 猜小了
如果两者相等 提示 恭喜你 中奖啦
要求： 只要没中奖 就需要一直猜
提示：随机生成数可以调用random库实现（import random）
这个太简单了就不写了

import random

sys_num = random.randint(1,1000)
#拿着sys_num外边一个死循环，里边几个if语句就可以了

第四章题目

1.设计三个字典dict_a、dict_b和dict_c，每个字典中存储了一个学生的信息，包括name和id，然后把这三个字典存储到一个列表student中，遍历这个列表，将其中每个人的所有信息都打印出来。

dict_a = {"name":"王二狗","id":1}
dict_b = {"name":"王二狗","id":2}
dict_c = {"name":"王二狗","id":3}

list_s = [dict_a,dict_b,dict_c]

for i in range(len(list_s)):
    for key,value in list_s[i].items():
        print("{}:{}".format(key,value))
    print()

2.使用列表编写一个程序，用户输入一个月份，程序输出该月份对应的英文单词。

list_m = ["January","February","March","April","May","June",
          "July","August","September","October","November","December"]

srd = int(input("输入一个数字月份输出对应的英文年份:"))
if(1<=srd<=12):
    edm = list_m[srd-1]
    print("输入的数字{}对应的英文月份是{}".format(srd,edm))
else:
    print("输入有误.")

3.编写一个用户登录程序，把多个用户的用户名和密码信息事先保存到列表当中，当用户登录时，首先判断用户名是否存在，如果不存在，就要求用户重新输入用户名（最多给3次机会）；如果用户名存在，就继续判断密码是否正确，如果正确，就提示登录成功，如果密码错误，就提示重新输入密码（最多给3次机会）。

list_userinfo = [
    {"user":"admin","psw":"admin"},
    {"user":"root","psw":"rootaccess"},
    {"user":"system","psw":"."}
]

max_attempts = 3

def login():
    for attempt in range(max_attempts):
        #要求用户输入用户名
        username = input("请输入用户名:")

        #check
        user_found = False
        for user in list_userinfo:
            if user["user"] == username:
                user_found = True
                break

        if user_found:
            password_attempts = 0
            while password_attempts < max_attempts:
                password = input("请输入密码:")
                #check
                for user in list_userinfo:
                    if user["psw"] == password:
                        print("登陆成功!")
                        return
                print("密码错误，重新输入密码")
                password_attempts+=1
            print("密码超过最大次数")
        else:
            print("用户名不存在重新输入")

    print("登陆失败，用户名操作最大次数")

login()

4.有一个列表nums = [3, 6, 10, 14, 2, 7]，请编写一个程序，找到列表中任意相加等于9的元素集合，如：[(3, 6), (2, 7)]。

nums = [3,6,10,14,2,7]
s1 = set()

for i in range(len(nums)):
    for j in range(i+1,len(nums)):
        if nums[i]+nums[j]==9:
            s1.add((nums[i],nums[j]))
print(list(s1))

5.请使用字典编写一个程序，让用户输入一个英文句子，然后统计每个单词出现的次数。

str_s = input("输入一个句子，判断出现单词的个数:")
words = str_s.split()
# print(words)

words_dict = {}

for word in words:
    if word in words_dict:
        words_dict[word] += 1
    else:
        words_dict[word] = 1

print(words_dict)
for word,count in words_dict.items():
    print(word,count)

6.创建一个名为universities的字典，其中将三所大学作为键。对于每所大学，都创建一个字典，设置两个键province和type，分别保存该大学的省份和类型。最后对universities字典进行遍历，打印出每所大学及其省份和类型信息。

college = {"太平洋大学":{"province":"太平洋","type":"marine"},
           "东南亚大学":{"province":"东南亚","type":"monkey"},
           "北斗大学":{"province":"北极","type":"star"}
           }

for item,info in college.items():
    print("colleae:{}, province:{}, type:{}".format(item,info["province"],info["type"]))

7.通过for循环创建201条数据，数据格式如下：
xiaoming1 xiaoming1@china.com pwd1
xiaoming2 xiaoming2@china.com pwd2
xiaoming3 xiaoming3@china.com pwd3
提示用户输入页码，当用户输入指定页码时，显示该页面内的数据（每页显示10条数据）。

list_info = []

for i in range(1, 202):
    name = {"xiaoming{}".format(i)}
    email = {"xiaoming{}@china.com".format(i)}
    psw = {"psw{}".format(i)}
    list_info.append((name, email, psw))

pagecode = int(input("输入页码，查看数据(1~21):"))

if 1 <= pagecode <=21:
    star_index = (pagecode-1)*10
    end_index = min(pagecode*10,len(list_info))

    for i in range(star_index,end_index):
        name,email,psw = list_info[i]
        print("name:{},email{},psw{}".format(name,email,psw))

else:
    print("输入有误，重新开始")

8.设计一个程序为参加歌手大赛的选手计算最终得分。评委给出的分数是0-10分。选手最后得分为：去掉一个最高分，去掉一个最低分，计算其余评委的打分的平均值。

# 设计一个程序为参加歌手大赛的选手计算最终得分。评委给出的分数是0-10分。
# 选手最后得分为：去掉一个最高分，去掉一个最低分，计算其余评委的打分的平均值。

def Score():
    list_sc = []

    Pingwei = int(input("一共有几个评委?请输入:"))

    for i in range(1,Pingwei+1):
        print("当前是第{}位评委".format(i))
        sc = int(input("输入分数开始评分:"))
        list_sc.append(sc)
    maxS = list_sc[0]
    minS = list_sc[0]
    for i in range(len(list_sc)):
        if(maxS<list_sc[i]):
            maxS = list_sc[i]

        if(minS>list_sc[i]):
            minS = list_sc[i]
    list_sc.remove(maxS)
    list_sc.remove(minS)
    print(sum(list_sc)/len(list_sc))

Score()

第五章题目

1．从1 计数至1000，并且以进度条的形式显示计数进度（提示：此题在Windows 命
令行模式下执行比较简单）。

from tqdm import tqdm
import time

# 使用tqdm创建进度条
for i in tqdm(range(1, 1001), unit="count"):
    # 模拟一些耗时操作
    time.sleep(1)
    

2. 试着用写成一行的字符串，输出以下内容：

    堂堂
  堂堂堂堂
堂堂食堂堂堂
  堂堂堂堂
  堂堂门堂
str = "    堂堂\n  堂堂堂堂\n堂堂食堂堂堂\n  堂堂堂堂\n  堂堂门堂"
print(str)

3．任意给定一个字符串，在不使用Python 自带的字符串切片方法的前提下，使用代码进行字符串切片，输出结果；再用Python 自带的字符串切片方法对该字符串切片，也输出结果。

aString = "string";
m = 1;
n = 2;

length = len(aString);
while (m < length):
    print(aString[m],end="");
    m = m + n;
print();
print(aString[1::2]);


for i in range(1,length,2):
    print(aString[i],end="")
#题目表达不清晰，都不知道要干嘛？

4．编写代码验证每种字符串拼接方法的效率。

import time

start_time = time.perf_counter()

#+、format、f""、join、%、*...

end_time = time.perf_counter()
elapsed_time = end_time - start_time
print(f"操作耗时：{elapsed_time:.6f}秒")

5．找出“你好！世界！”的Unicode 字符，并用字符串输出。

text = "你好！世界！"

# 使用列表推导式获取每个字符的Unicode码点
unicode_points = [ord(char) for char in text]

# 将Unicode码点列表转换回字符串
unicode_string = "".join([chr(point) for point in unicode_points])

print(unicode_string)

6．编程输出下图。其中，0、1、2、⋯⋯和−1、−2、−3、⋯⋯都是字符串的索引值，字符串需要由变量指定，每一个框都是由加号和减号组成的，箭头是大于号和小于号。

str = "Hello Python!"

star = 0
print("正向索引 >>>")
for letter in str:
    print(f"{star:<4}",end="")
    star+=1
print()

for letter in str:
    print(f"+---",end="")
print("+")
for letter in str:
    print(f"| {letter} ",end="")
print("|")
for letter in str:
    print(f"+---",end="")
print("+")

length = -len(str)
print(" ",end="")
for letter in str:
    print(f"{length:>4}",end="")
    length+=1
print()
print(f"{'<<< 反向索引':>{len(str)*4-1}}")

print()

第六章题目

1．编写函数，返回斐波那契数列的列表。注：斐波那契数列指的是这样一个数列：
0,1,1,2,3,5,8,13,21,34,⋯。在数学上，斐波那契数列以如下递归的方法定义：F(0)=0，
F(1)=1, F(n)=F(n − 1)+F(n − 2)（n≥2，n ∈N）。

def FBNC(num):
    if num==0:
        return 0
    elif num==1:
        return 1
    return FBNC(num-1)+FBNC(num-2)
list_Fb = []

for i in range(10):
    list_Fb.append(FBNC(i))

print(list_Fb)

2．编写函数，打印n 行的金字塔。

def print_pyramid(num):
    for i in range(1,num+1):
        print(' ' * (num - i) + "*" * (2 * i- 1))

print_pyramid(5)

3．编写函数，用非递归形式实现冒泡排序。

#冒泡排序
def bubble_sort(a):
    n = len(a)
    for i in range(n-1,-1,-1):
        for j in range(0,i):
            if a[j]>a[j+1]:
                a[j],a[j+1] = a[j+1],a[j]
    print(a)

arr = [-5, 9, 11, 13, 32, 4, 1, 10, 88, 2, 8, 3, 16, 14];

bubble_sort(arr)

#选择排序
def select_sort(arr):
    n = len(arr)
    for i in range(0, n - 1):
        min = i
        for j in range(i + 1, n):
            if arr[j] > arr[min]:
                min = j
        arr[i], arr[min] = arr[min], arr[i]
    print(arr)

a = [11,69,7894,26,7916,987]
select_sort(a)

#插入排序
def innerSort(a):
    n = len(a)
    for i in range(1,n):
        x = a[i]
        j = i-1
        while(j>=0):
            if x <= a[j]:
                a[j+1] = a[j]
                j-=1
            else:
                break

        a[j+1] = x
    print(a)

arr = [-5, 9, 11, 13, 32, 4, 1, 10, 88, 2, 8, 3, 16, 14];
innerSort(arr)

4．编写函数，用递归形式实现汉诺塔问题。

def hanoi(n, oragin, auxiliary, target):
    count = 0
    if n == 1:
        count += 1
        print(f"移动{n}从{oragin}到{target}")
    else:
        count += hanoi(n - 1, oragin, target, auxiliary)
        count += 1
        print(f"移动{n}从{oragin}到{auxiliary}")
        count += hanoi(n - 1, auxiliary, oragin, target)
    return count


total_moves = hanoi(5, "A", "B", "C")
print(f"总共移动 {total_moves} 次")

第七章题目

一、简答题

1. 简单描述保护属性安全性的一般处理方式。

设置私有属性，添加getset方法

2. 简单描述什么是多重继承。

一个子类有多个直接父类。

3. 简单描述什么是方法的重写。

子类采用同样的方法签名修改继承自父类的方法。

二、 编程题
1.定义一个类判断给定字符串中的括号（包括“<>”、“（）”、“[ ]”、“{ }”四种类型的括号）是否正确配对。例如：“()adafd{)}” 是错误配对，“()adafd{(<>)}” 是正确配对，"{[({})]}"是正确配对。
2.实现一个名为“Rectangle”的表示矩形的类，该类包含两个公有的实例属性width和height，分别表示矩形的宽和高，同时还有一个名为aera的公有方法，该方法返回矩形的面积。

class Rectangle:
    def __init__(self,width,height):
        self.width = width
        self.height = height

    def area(self):
        return self.width*self.height

3.修改习题2中的Rectangle类，将实例属性width和height改为可读写的property，并且在写操作时检查是否为正值，将area方法改为一个只读的property。下面是测试代码：

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    @property
    def width(self):
        return self.width

    @width.setter
    def width(self, width):

        if (width <= 0):
            print("<0")
        else:
            print("successd!width")
            self.width = width

    @property
    def height(self):
        return self.height

    @height.setter
    def height(self, height):

        if (height <= 0):
            print("<0")
        else:
            print("successd!height")
            self.height = height

    def area(self):
        return self.width * self.height

>>> a = Rectangle(3,4)
>>> a.width = -5 # 输出错误提示
>>> a.width = 5
>>> a.height = 0 # 输出错误提示
>>> a.height = 2
>>> a.area   # 返回10
>>> a.area = 12 # 输出“AttributeError: can't set attribute”

4.创建一个User类，其包含一个name的实例属性，由构造函数初始化，还包含一个名为count的类属性用于统计用户数目（创建的实例数）。下面是测试代码：

class User(object):
    count = 0

    def __init__(self, name):
        self.name = name
        self.count += 1

>>> a = User('Mike')
>>> User.count  # 输出1
>>> b = User('Tom')
>>> User.count # 输出2
>>> c = User('Jack') 
>>> User.count # 输出3

5.定义一个名为Calculator的类，使用静态方法定义四个表示加减乘除的运算。测试代码如下：

class Calculator:
    @staticmethod
    def add(x,y):
        return x+y
    @staticmethod
    def subtract(x,y):
        return x-y
    @staticmethod
    def multiply(x,y):
        return x*y
    @staticmethod
    def divide(x,y):
        return x/y

>>> Calculator.add(10, 5) # 返回 15
>>> Calculator.subtract(10, 5) # 返回 5
>>> Calculator.multiply(10, 5) # 返回 50
>>> Calculator.divide(10, 5) # 返回 2

6.请修改下面的Point类，通过重写相应魔法方法使其支持如下运算符操作：
p1+p2, 用两个点的x、y坐标分别相加，返回一个新的Point对象；
p1-p2, 用两个点的x、y坐标分别相减，返回一个新的Point对象；
p*n, 用点的x、y坐标分别乘以数值n，返回一个新的Point对象；
p/n, 用点的x、y坐标分别除以数值n，返回一个新的Point对象。

class Point: # 请直接修改该类的定义
    def __init__(self,x,y):
        self.x = x
        self.y = y
    def __str__(self):
        return 'Point(' + str(self.x) + ',' + str(self.y) + ')'

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

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

    def __mul__(self, other):
        return Point(self.x*n,self.y*n)

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

if __name__ == '__main__':  # 这是测试代码
    a,b=Point(4,5),Point(2,3)
    print(a+b) # 输出结果为'Point(6,8)'
    print(a-b) # 输出结果为'Point(2,2)'
    print(a*2) # 输出结果为'Point(8,10)'
    print(a/2) # 输出结果为'Point(2.0,2.5)'

7.请继承习题3中的Rectangle类来实现一个名为Square的正方形类，使得可以用Square(边长)的方式实例化该类，并重写父类中width和height的写方法，实现长和高的同时修改。测试代码如下：

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    @property
    def width(self):
        return self.width

    @width.setter
    def width(self, width):

        if (width <= 0):
            print("<0")
        else:
            print("successd!width")
            self.width = width

    @property
    def height(self):
        return self.height

    @height.setter
    def height(self, height):

        if (height <= 0):
            print("<0")
        else:
            print("successd!height")
            self.height = height

    def area(self):
        return self.width * self.height

class Square(Rectangle):
    def __init__(self,width):
        super().__init__(width,width)

    @Rectangle.height.setter
    def height(self,height):
        if(height<=0):
            print('>0')
        else:
            print('height设置成功')
            self._height = height
            self._width = height

    @Rectangle.width.setter
    def width(self,width):
        if(width<=0):
            print('>0')
        else:
            print('width设置成功')
            self._width = width
            self._height = width

>>> a = Square(5)
>>> a.width = 10  # 同时修改height
>>> a`.height # 输出 10
>>> a.height = 20 # 要求同时修改width
>>> a.width  # 输出 20
>>> a.area  # 输出400

8.继承内建的字符串类，实现对字符串的左右循环移动给定整数位（正数代表左移，负数代表右移）。

class MoveableStr(str):
    def move(self,n):
        temp = n % len(self)
        return self[temp : ] + self[ : temp]

9.请用继承的方法完成习题6的要求。

class Point: 
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
    def __str__(self): 
        return 'Point('+str(self.x)+','+str(self.y)+')'

class Point1(Point): 
    def __add__(self,other):
        return Point1(self.x+other.x,self.y+other.y)
    
    def __sub__(self,other):
        return Point1(self.x-other.x,self.y-other.y)
    
    def __mul__(self,n):
        return Point1(self.x*n,self.y*n)
    
    def __truediv__(self,n):
        return Point1(self.x/n,self.y/n)

10.考虑如下一个简单的图形绘制程序。定义一个Point类表示二维平面上的点（可以借鉴第6题）。所有图形实体的基类为Shape，其包含一个Point类型的position实例属性，用于表示图形的位置。Shape类有一个方法move_to将图形的位置移动到新的位置，shape还包括一个draw方法，打印输出Shape对象的字符串表示。继承Shape类的具体图形类型包括线段类Line和圆类Circle。Line类初始化的第一个参数为一个端点，也是其位置，另一个参数表示另一个端点，作为另一个实例属性。Circle类初始化的第一个参数表示其圆心，也是其位置，另一个参数表示其半径，作为另一个实例属性。如下的代码已经给出了Shape类的定义，请完成Point类、Line类和Circle类的定义。Line类需要重写move_to方法，在移动位置的同时修改另一个端点的坐标。另外，Line类和Circle类都要求对__str__重写实现，以得到更直观的draw效果，其中类Line的输出信息样式为“Line:第一个端点的坐标–第二个端点的坐标)”，类Circle的输出信息样式为“Circle center:圆心坐标,R=半径”。部分例程和测试代码如下：

#请实现类 Point、Line、Circle

class Shape: 
		# 不要修改该类
    def __init__(self):
        self.position = Point(0,0)
    def draw(self):
        print(str(self))
    def move_to(self,position):
        print("moving to ",str(position))

#下面是测试代码      
if __name__ == '__main__':
    l = Line(Point(0,0),Point(20,20))
    l.draw()
    l.move_to(Point(3,5)) # 移动到一个新的点
    l.draw()
    c= Circle(Point(10,10),5)
    c.draw()
    c.move_to(Point(30,20))
    c.draw()

# 下面是脚本的期望输出
Line:(0,0)----(20,20)
moving to  (3,5)
Line:(3,5)----(23,25)
Circle center:(10,10),R=5
moving to  (30,20)
Circle center:(30,20),R=5

class Point:  
    def __init__(self,x,y):
             self.x = x
             self.y = y
    def __str__(self):
            return '('+str(self.x)+','+str(self.y)+')'
    def __add__(self,other):
        return Point(self.x+other.x,self.y+other.y)
    
    def __sub__(self,other):
        return Point(self.x-other.x,self.y-other.y)
    
    def __mul__(self,n):
        return Point(self.x*n,self.y*n)
    
    def __truediv__(self,n):
        return Point(self.x/n,self.y/n)

class Shape:
    def __init__(self):
        self.position = Point(0,0)
    def draw(self):
        print(str(self))
    def move_to(self,position):
        print("moving to ",str(position))
        self.position = position

class Line(Shape):
    def __init__(self,position,end):
        self.position = position
        self.end = end

    def move_to(self,position):
        deltap = position - self.position
        super().move_to(position)
        self.end += deltap
    def __str__(self):
        return 'Line:'+str(self.position)+'----'+str(self.end)

class Circle(Shape):
    def __init__(self,center,radius):
        self.position = center
        self.radius = radius
    def __str__(self):
        return 'Circle center:'+str(self.position)+',R='+str(self.radius)       
if __name__ == '__main__':
    l = Line(Point(0,0),Point(20,20))
    l.draw()
    l.move_to(Point(3,5)) # 移动到一个新的点
    l.draw()
    c= Circle(Point(10,10),5)
    c.draw()
    c.move_to(Point(30,20))
    c.draw()