《Python编程无师自通》挑战练习答案

---

---

3.17 挑战练习

1. 请打印3个不同的字符串。

a="Hello World!"
b="He said \"Let's go.\""
c="D:\Area\colum"
print(a)
print(b)
print(c)

运行结果如下：

Hello World!
He said "Let's go."
D:\Area\colum

2. 编写程序：如果变量的值小于10，打印一条消息；如果大于或等于10，则打印不同的消息。

a = input("please enter a number:")
b = int(a)
if b < 10 :
     print("xixi")
else:
     print('haha')

运行结果如下：

please enter a number:8
xixi

3. 编写程序：如果变量的值小于或等于10，打印一条消息；如果大于10且小于或等于25，则打印一条不同的消息；如果大于25，则打印另一条不同的消息。

a = input("please enter a number:")
b = int(a)
if b <= 10 :
    print("xixi")
elif b>10 and b <= 25:
    print('haha')
else:
   print('hehe')

运行结果如下：

please enter a number:16
haha

4. 编写一个将两个变量相除，并打印余数的程序。

a=int(input("a="))
b=int(input("b="))
print(a%b)

运行结果如下：

a=9
b=6
3

5. 编写一个将两个变量相除，并打印商的程序。

a=int(input("a="))
b=int(input("b="))
print(a/b)

运行结果如下：

a=15
b=4
3.75

6. 编写程序：为变量age赋予一个整数值，根据不同的数值打印不同的字符串说明。

age = int(input("please enter an integer:"))
if age < 18:
   print("you are so young!")
elif age>18 and age<65:
    print("you are old")
else:
     print("you are so old!")

运行结果如下：

please enter an integer:60
you are old

---

---

4.12 挑战练习

1. 编写一个函数，接受数字作为输入，并返回该数字的平方。

def f(x):
   """
   返回x的平方
   : param x: float
   : return： int, x 的平方
   """
   return x ** 2
a = float(input("please enter a number:"))
print(f(a))

运行结果：

please enter a number:2.4
5.76

2. 编写一个以字符串为参数并将其打印的函数。

def f(s):
   """
   打印字符串
   : param s: string
   : print： string, s
   """
   print (s)
   
s="dog's name: huanhuan"
f(s)

运行结果：

dog's name: huanhuan

3. 编写一个接受3个必选参数、两个可选参数的函数。

def f(x,y,z,n=4,m=5):
   """
   参数：3必选，2可选
   输出：5个参数的累加和
   """
   return x+y+z+n+m
   
f(1,2,3)
print(f(1,2,3))

f(1,2,3,10,20)
print(f(1,2,3,10,20))

运行结果：

15
36

4. 编写一个带两个函数的程序。第一个函数应接受一个整数为参数，并返回该整数除以 2 的值。第二个函数应接受一个整数作为参数，并返回该整数乘以4 的值。调用第一个函数，将结果保存至变量，并将变量作为参数传递给第二个函数。

def f1(x):
   """
   函数1：返回整数x除以 2 
   """
   return x // 2

def f2(y):
   """
   函数2：返回y乘以4
   """
   return y * 4

a = int(input("please enter an integer:"))
b = f1(a)
print(f2(b))

运行结果：

please enter an integer:9
16

5. 编写一个将字符串转换为float对象并返回该结果的函数。使用异常处理来捕获可能发生的异常。

def f(s):
   """
   将字符串转换为float对象
   : param s: string
   : return： float, s
   """
   return float(s)
s=input("type a number:")  

# 使用异常处理来捕获可能发生的异常
try:
   print(f(s))
except ValueError:
   print("Invalid input!")

运行结果：

type a number:56789456
56789456.0

6. 为挑战练习1~5中编写的所有函数添加文档字符串。

如1~5的代码中所示。

---

---

5.7 挑战练习

1. 创建一个你最喜欢歌手的列表。

favourite_singers=["Hugh","Zjie","L Junjie"]

2. 创建一个有元组构成的列表，每个元组包含居住过或旅游过的城市的经纬度。

city_info=[("Hangzhou", "30°15'N", "120°10'E"), ("Nanjing", "30°15'N", "117°22'E")]

3.创建一个包含你的不同属性的字典：身高、最喜欢的颜色和最喜欢的作者等。

person_info = {"height":
               "1.80m",
               "favourite_color":
               "yellow",
               "favourite_author":
               "Luxun"}

4. 编写一个程序，让用户询问你的身高、最喜欢的颜色或最喜欢的作者，并返回上一个挑战中创建的字典。

person_info = {"height":
               "1.80m",
               "favourite_color":
               "yellow",
               "favourite_writer":
               "Luxun"}
s = input("asking: ")
if s == "height":
   print(person_info["height"])
elif s == "favourite_color":
   print(person_info["favourite_color"])
elif s == "favourite_writer":
   print(person_info["favourite_writer"])

运行结果：

asking: height
1.80m

5. 创建一个字典，将最喜欢的歌手映射至你最喜欢的歌。

favourite_singers={"Hugh": "逍遥叹",
                   "Zjie": "逆战",
                   "L Junjie": "小酒窝"}
print(favourite_singers)

                   

运行结果：

{'Hugh': '逍遥叹', 'Zjie': '逆战', 'L Junjie': '小酒窝'}

6. 列表、元组和容器只是Python中内置容器的一部分，自行研究Python中的集合（也是一种容器）在什么情况下可以使用集合？

集合是不同的可哈希对象的无序集合。集合通常用于进行成员资格测试，从序列中删除重复项以及计算数学运算（例如交集，并集，差和对称差等）。

---

---

6.18 挑战练习

1. 打印字符串"Camus"中的所有字符。

s = "Camus"
for i in range(0,len(s)):
    print(s[i])

运行结果：

C
a
m
u
s

2．编写程序，从用户处获取两个字符串，将其插入字符串"Yesterday I wrote a [用户输入1] . I sent it to [用户输入2] ! " 中，并打印新字符串。

# 格式化输出 format
n1 = input("Enter a noun:")
n2 = input("Enter a noun again:")
r = "Yesterday I wrote a {}.I sent it to {}!".format(n1, n2)
print(r)

运行结果：

Enter a noun:letter
Enter a noun again:mother
Yesterday I wrote a letter.I sent it to my mother!

3．想办法将字符串"aldous Huxley was born in 1894."的第一个字符大写，从而使语法正确。

s="aldous Huxley was born in 1894."
print(s.capitalize())
                   

运行结果：

Aldous huxley was born in 1894.

4．对字符串"Where now? Who now? When now?"调用一个方法，返回如下述的列表[“Where now?”,“Who now?”,“When now?”]。

s = "Where now? Who now? When now?"
lis = [(e.strip()).strip("?")+'?' for e in s.split('?',2)]
print(lis)
                 

运行结果：

['Where now?', 'Who now?', 'When now?']

5．对列表[“The”, “fox”,“jumped”,“over”,“the”,“fence”,"."]进行处理，将其变成一个语法正确的字符串。每个单词间以空格符分隔，但是单词fence和句号之间不能有空格符。(别忘了，我们之前已经学过将字符串列表连接为单个字符串的方法。）

words = ["The",
       "fox",
       "jumped",
       "over",
       "the",
       "fence",
       "."]
"""
join方法字符串连接。
得到 The fox jumped over the fence .
注意'e'与'.'有空格

"""
one = " ".join(words)

# strip方法删除字符串首尾" ."

one = one.strip(" .")


# 字符串拼接

print(one+".")

               

运行结果：

The fox jumped over the fence.

6．将字符串"A screaming comes across the sky."中所有的"s"字符替换为美元符号。

# replace方法--字符串替换
s1 = "A screaming comes across the sky."
s1 = s1.replace("s", "$")
print(s1)
          

运行结果：

A $creaming come$ acro$$ the $ky.

7.找到字符串"Hemingway"中字符"m"所在的第一个索引。

# index方法，获得字符串中某个字符，第1次出现的索引。
s1 = "Hemingway"

s1 = s1.index("m")

print(s1)
      

运行结果：

2

8.在你最喜欢的书中找一段对话,将其变成一个字符串。

s1 = ["BMr. liu, would you care for another helping?",
   "No more, thank you. I'm quite full."]
   
s1 = s1[0] + "\n" + s1[1]
print(s1)
                

运行结果：

BMr. liu, would you care for another helping?
No more, thank you. I'm quite full.

9．先后使用字符串拼接和字符串乘法，创建字符串"three three three".

s = "three" + " " + "three" + " " + "three"
print(s)

s1 = "three " * 3
print(s1)    

运行结果：

three three three
three three three 

10．对字符串"It was bright cold day in April, and the clocks were striking thirteen."进行切片，只保留逗号之前的字符。

s = "It was bright cold day in April, and the clocks were striking thirteen."
print(s[:len("It was bright cold day in April")])             

运行结果：

It was bright cold day in April

---

---

7.8 挑战练习

1. 打印以下列表[“The walking Dead”, “Entourage”, “The Sopranos”,“The Vampire Diaries”]中的每个元素。

s = ["The walking Dead", "Entourage", "The Sopranos","The Vampire Diaries"]

for show in s:
    print(show)   
          

运行结果：

The walking Dead
Entourage
The Sopranos
The Vampire Diaries

2. 打印从25到50之间的所有数字。

for n in range(25, 51):
    print(n)
      

运行结果：

25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

3. 打印第一个挑战练习中的每个元素及其索引。

s = ["The walking Dead", "Entourage", "The Sopranos","The Vampire Diaries"]

for show in s:
    print(s.index(show), show)
          

运行结果：

0 The walking Dead
1 Entourage
2 The Sopranos
3 The Vampire Diaries

4. 编写一个包含死循环和数字列表的程序（可选择输入q退出)。每次循环时，请用户猜一个在列表中的数字，然后告知其猜测是否正确。

n = [1, 2, 3, 4, 5]
while True:
    s = input("猜数字：")
    if s == "q":
    	print("游戏结束啦！")
        break
    
    s = int(s)
    if s in n:
        print("回答正确！")
    else:
         print("很遗憾，回答错误。")
                   

运行结果：

猜数字：6
很遗憾，回答错误。
猜数字：3
回答正确！
猜数字：q
游戏结束啦！

5. 将列表[8, 19, 148, 4]中的所有数字，与列表[9, 1, 33, 83]中的所有数字相乘，并将结果添加到第3个列表中。

n1 = [8, 19, 148, 4]
n2 = [9, 1, 33, 83]
n3 = list()

for i in n1:
    for j in n2:
        n3.append(i * j)
        
print(n3)    
              

运行结果：

[72, 8, 264, 664, 171, 19, 627, 1577, 1332, 148, 4884, 12284, 36, 4, 132, 332]

---

---

8.4 挑战练习

1. 调用statistics模块中不同于示例中提到的函数。

import statistics

nums = [1, 3, 6, 9, 6]

# 总体标准差
x = statistics.pstdev(nums)
print(x)

# 总体方差
y = statistics.pvariance(nums)
print(y)
                 

运行结果：

2.756809750418044
7.6

2. 创建一个名为cubed的模块,在其中写一个函数：接受一个数字作为参数，返回该数字的立方。并在另一个模块中导入并调用该函数。

# 创建一个名为cubed的模块
def f(x):
    return x ** 3
           

import cubed

# 调用cubed模块中的f(x)函数。
y=cubed.f(3)
print(y)

运行结果：

27

注意：两个python文件应在同一个文件夹目录下，或许也不吧

---

---

9.6 挑战练习

1．在计算机上找一个文件，并使用Python打印其内容。

文件：


代码：

with open("9.6.1.txt", "r", encoding='utf-8') as f:
    print(f.read())
                  

运行结果：

hi，welcom!

2．编写一个程序来向用户提问，并将回答保存至文件。

代码：

with open("9.6.2.txt", "w", encoding='utf-8') as f:
    a=input("What's your name?")
    b=f.write(a)
                               

”9.6.2.txt“文件通过代码新建：

运行结果：
IDLE交互界面：

打开9.6.2.txt文件

3. 将以下列表中的元素写入一个CSV文件:[[“Top Gun”,“Risky Business”，“Minority Report”]，[ “Titanic”，“The Revenant”， “Inception”]，[ “Training Day”， “Man on Fire”，“Flight”]]。每个列表应该在文件中各占一行，其中元素使用逗号分隔。

import csv


with open("st.csv", "w", encoding='utf-8') as f:
    w=csv.writer(f, delimiter=",")
    w.writerow(["Top Gun",
                "Risky Business",
                "Minority Report"])
    w.writerow(["Training Day",
                "Man on Fire",
                "Flight"])
   
          

运行结果：
用 Excel 打开：

用 记事本 打开：

---

---

10.2 挑战练习

1. 修改本章编写的游戏，要求从一个单词列表中随机选择单词。（Python开发Hangman猜数字游戏）

import random


def hangman (word):
    wrong = 0
    stages = ["",
        "_____      ",
        "|          ",
        "|     |    ",
        "|     0    ",
        "|    /|\   ",
        "|    / \   ",
        "|          "
         ]
    
    rletters = list(word)
    board = ["_"] * len(word)
    win = False
    print("welcome to Hangman")
    
    while wrong < len(stages) - 1:
        
        print("\n")
        msg = "Guess a letter: "
        char = input(msg)
        if char in rletters:
            cind = rletters.index(char)
            board[cind] = char
            rletters[cind] = '$'
        else:
             wrong += 1
        print((" ".join(board)))
        e = wrong + 1
        print("\n".join(stages[0:e]))
        if "_" not in board:
            print("You win!")
            print(" ".join(board))
            win = True
            break
    if not win :
        print("\n".join(stages[0:wrong]))
        print ("You lose! It was {}.".format(word))

# 列表单词
lis = ["cat", "dog", "fish", "bird", "elephant"]
# 随机获得列表中各元素的索引
num = random.randint(0, len(lis) + 1)     
 
hangman(lis[num])
         

运行结果：

welcome to Hangman


Guess a letter: r
_ _ _ _

_____      


Guess a letter: b
_ _ _ _

_____      
|          


Guess a letter: f
f _ _ _

_____      
|          


Guess a letter: i
f i _ _

_____      
|          


Guess a letter: h
f i _ h

_____      
|          


Guess a letter: s
f i s h

_____      
|          
You win!
f i s h

---

---

12.6 挑战练习

1. 定义一个叫 Apple的类，创建4个实例变量，表示苹果的4种属性。

class Apple:
    def __init__(self, w, c, p, d):
        self.weight = w
        self.color = c
        self.price = p
        self.days = d    
        pass

                  

2. 定义一个叫Circle的类，创建 area方法计算其面积。然后创建一个 Circle对象，调用其 area方法，打印结果。可使用 Python 内置的math模块中的pi函数。

import math


class Circle :
    def __init__(self, r):
        self.radius = r
    
        pass
    def area(self):
        return math.pi*self.radius**2
    
        pass
    
a = Circle(2)
print(a.area())

                             

运行结果：

12.566370614359172

3. 定义一个叫 Triangle的类，创建area方法计算并返回面积。然后创建一个Triangle对象，调用其area方法，打印结果。

class Triangle:
    def __init__(self, b, h):
        self.bottom = b
        self.height = h
    
        pass
    def area(self):
        return 0.5*self.bottom*self.height
    
        pass
    
a = Triangle(2, 4)
print(a.area())
                             

运行结果：

4.0

4. 定义一个叫Hexagon的类，创建cacculate_perimeter方法，计算并返回其周长。然后创建一个 Hexagon对象，调用其calculate_perimeter方法，并打印结果。

# 这里仅计算正六边形周长

class Hexagon:
    def __init__(self, s):
        self.side = s
           
        pass
    def cacculate_perimeter(self):
        return 6*self.side
    
        pass
    
a = Hexagon(2)
print(a.cacculate_perimeter())
        
                      

运行结果：

12

---

---

13.7 挑战练习

1．创建Rectangle和Square类，使它们均有一个叫calculate _perimeter的方法，计算其所表示图形的周长。创建Rectangle和Square对象，并调用二者的周长计算方法。

class Rectangle(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def calculate_perimeter(self):
        return (self.a + self.b) * 2
    
        
    pass

class Square(object):
    def __init__(self, c):
        self.c = c
    def calculate_perimeter(self):
        return self.c * 4
        
    

    pass
r = Rectangle(2, 3)

s = Square(2)

print("长方形周长：{}".format(r.calculate_perimeter()))
print("正方形周长：{}".format(s.calculate_perimeter()))

          

                  

运行结果：

长方形周长：10
正方形周长：8

2．在 Square类中，定义一个叫 change_size的方法,支持传入一个数字，增加或减少（数字为负时）Square对象的边长。

with open("9.6.1.txt", "r", encoding='utf-8') as f:
    print(f.read())
                  

运行结果：

hi，welcom!

3．创建一个叫 Shape的类。在其中定义一个叫 what_am_i的方法(,被调用时打印"I am a shape"。调整上个挑战中的Square和Rectangle类，使其继承Shape类，然后创建Square 和 Rectangle对象，并在二者上调用新方法。

class Shape(object):
    def what_am_i(self):
        print("I am a shape")
    pass
    
class Rectangle(Shape):
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def calculate_perimeter(self):
        return (self.a + self.b) * 2
    
        
    pass

class Square(Shape):
    def __init__(self, c):
        self.c = c
    def calculate_perimeter(self):
        return self.c * 4
        
    

    pass
r = Rectangle(2, 3)

s = Square(2)

print("长方形周长：{}".format(r.calculate_perimeter()))
r.what_am_i()
print("正方形周长：{}".format(s.calculate_perimeter()))
s.what_am_i()
          

                  

运行结果：

长方形周长：10
I am a shape
正方形周长：8
I am a shape

4.创建一个叫 Horse的类，以及一个叫Rider 的类。使用组合，表示一批骑手的马。

class Horse(object):
     def __init__(self,
                  name,
                  breed,
                  owner):
        self.name = name
        self.breed = breed
        self.owner = owner
        
     pass
    
class Rider(object):
   
    def __init__(self,
                  name):
        self.name = name
        
        
    pass

To = Rider("TOM")

Jer = Horse("Jerry",
            "White_Horse",
            To)

print("马Jer的主人叫{}".format(Jer.owner.name))

          

运行结果：

马Jer的主人叫TOM

---

---

14.5 挑战练习

1.向Square类中添加一个square_list 类变量，要求每次新创建一个Square 对象时，新对象会被自动添加到列表中。

class Square(object):
    square_list = []
    def __init__(self,
                  a,
                  ):
        self.a = a
        self.square_list.append(self.a)
        
    pass

s1 = Square(2)

s2 = Square(3)

s3 = Square(4)


print(Square.square_list)

运行结果：

[2, 3, 4]

2.修改Square类，要求在打印Square对象时，打印的信息为图形4个边的长度。例如，假设创建一个Square(29)， 则应打印29 by 29 by 29 by 29。

# 魔法方法__str__的使用，__str__方法在object类中定义，现在重写父类中的__str__方法
class Square(object):
   
    def __init__(self,
                  a,
                  ):
        self.a = a
       
        
    pass

    def __str__(self):
        return "{} by {} by {} by {}".format(self.a, self.a, self.a, self.a) 
        
        pass



s = Square(29)



print(s)

运行结果：

29 by 29 by 29 by 29

3.编写一个函数，接受两个对象作为参数，如果为相同的对象则返回True,反之返回False。

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



TOM = Person("Tom")

JERRY = Person("jerry")

same_TOM = TOM

print(TOM is same_TOM)

print(TOM is JERRY)

运行结果：

True
False

---

---

小白入门，恳求批评和指导

持续更新中。。。，请保持关注