Python基础（七）—— 练习题

Python基础（七）

大家可以关注知乎或微信公众号的‘share16’，我们也会同步更新此文章。

十七、Python的应用

17.1 Python在现实中的应用

17.2 Python小练习

(01). 怎样对python中的代码进行注释？

# 表示单行注释；
三单/双引号(英文状态下) 表示多行注释；

(02). python有哪些运算符，这些运算符的优先级是怎样的？

运算符
有算术运算符、比较运算符、逻辑运算符、按位运算符、成员运算符等等；
运算符的优先级
1.一元运算符优于二元运算符，如正负号；
2.先算术运算，后移位运算，最后按位运算；
3.逻辑运算最后结合；

(03). python中 is, is not 与 ==, != 的区别是什么？

is, is not 对比的是两个变量的内存地址；
==, != 对比的是两个变量的值；
假如比较的两个变量，指向的都是地址不可变的类型(str等)，那么is，is not 和 ==，!= 是完全等价的；
假如比较的两个变量，指向的是地址可变的类型(list，dict，tuple等)，则两者是有区别的；

(04). python 中包含哪些数据类型?这些数据类型之间如何转换？

数据类型
int、float、bool、complex
转换方法
int()、float()、complex()、str()

(05). 只出现一次的数字

A ^ A = 0

'''
给定一个 非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。
找出那个只出现了一次的元素
尝试使用按位运算解决此题
'''

# 不使用按位运算
a = input('请输入整数，用英文逗号分隔：')
b = list(eval(a))
c = []
for i in b:
    if b.count(i) == 1:
        c.append(i)
print(c)
# 输入：1, 2, 3, 4, 1, 0, 1, 2
# 输出：[3, 4, 0]


# 使用按位运算、交集、差集
a = input('请输入整数，用英文逗号分隔：')
b = list(eval(a))
c = [] # 储存 只出现一次 的元素
d = [] # 储存 出现次数>1 的元素
k = len(b)
for i in range(k):
    for j in b[ i+1 : ]:
        if b[i] ^ j != 0:
            c.append(b[i])
        else:
            d.append(b[i])
x = set(c)
y = set(d)
print('只出现一次 的元素：', list(x - (x & y)))
# 输入：1,2,3,4,5,6,7,8,2,4,6
# 输出：[1, 3, 5, 7, 8]

'''
此题，大家还有更简单的方法吗？欢迎大家共享～～～
'''

(06). 查找1500～2700之间，既可以被7整除，又可以被5整数的数字

a = []
for i in range(1500,2701):
    if (i%7==0) and (i%5==0):
        a.append(i)
print(a)
# a中有35个数字，此处不现实了～

(07). 龟兔赛跑游戏

小华研究不同兔子和乌龟的赛跑：他发现，兔子一旦发现自己领先t米或以上，它们就会停下来休息s秒；对于不同的兔子，t、s的数值是不同的；但是所有的乌龟却是不到终点决不停止。然而，了解到兔子的速度v1，乌龟的速度v2，以及兔子对应的t、s值，以及赛道的长度l——就能预测出比赛的结果。
请你写一个程序，对于输入的一场比赛的数据v1、v2、t、s、l，预测出该场比赛的结果。

输入：只有一行，包含用空格隔开的五个正整数v1、v2、t、s、l，其中(v1/v2<=100；t<=300；s<=10；l<=10000且为v1v2 的公倍数)
输出：包含两行，第一行输出比赛结果——一个大写字母“T”或“R”或“D”，分别表示乌龟获胜，兔子获胜，或者两者同时到达终点；第二行输出一个正整数，表示获胜者(或双方同时)到达终点所耗费的时间(秒数)

a = input('请输入五个正整数，用英文空格分隔：')
v1, v2, t, s, l = map(lambda x:int(x), a.split())
# v1, v2, t, s, l = map(int, a.split())
# v1 = int(a.split()[0])

t0 = t/(v1-v2)
t1 = s + (l/v1)
t2 = l/v2

if v1 > v2:
    if t1 < t2:
        print('R')
        print('兔子获胜，到达终点所耗费的时间：', t1, '秒。')
    elif t1 > t2:
        print('T')
        print('乌龟获胜，到达终点所耗费的时间：', t2, '秒。')
    else:
        print('D')
        print('双方同时到达，到达终点所耗费的时间：', t2, '秒。')
else:
    print('兔子的速度要快于乌龟的速度，请重新输入！')

# 输入：10 5 5 2 20
# 输出：D
# 输出：双方同时到达，到达终点所耗费的时间： 4.0 秒。

(08). 猜数字游戏

电脑产生一个零到100之间的随机数字，然后让用户来猜，如果用户猜的数字比这个数字大，提示太大，否则提示太小，当用户正好猜中电脑会提示，“恭喜你猜到了这个数是…”；
在用户每次猜测之前程序会输出用户是第几次猜测，如果用户输入的根本不是一个数字，程序会告诉用户"输入无效"。
(获取随机数采用random模块，尝试使用try catch异常处理结构对输入情况进行处理)

import random
m = random.randint(0,100)
count = 1

while True :
    print('第{}次输入：'.format(count))
    count = count + 1
    n = input('请输入0～100的整数：')
    
    try:
        eval(n)
    except:
        print('输入无效')
        continue
        
    if eval(n) > m:
        print('猜大了')
    elif eval(n) < m:
        print('猜小了')
    else:
        print('恭喜你猜对了，这个数是：', m)
        break
        

(09). 列表操作练习

lst = [2, 5, 6, 7, 8, 9, 2, 9, 9]
# 在列表的末尾增加元素15
lst.append(15)
lst
# >> [2, 5, 6, 7, 8, 9, 2, 9, 9, 15]

# 在列表的中间位置插入元素20
lst.insert(len(lst)//2,20) 
#lst.insert(len(lst)//2-1,20) # 可以自己运行看下哦
lst
# >> [2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15]

# 将列表[2, 5, 6]合并到lst中
lst = lst + [2,5,6]
lst.extend([2,5,6]) # 等价于上一句
lst
# >> [2, 5, 6, 7, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]

# 移除列表中索引为3的元素
del lst[3]
lst.remove(lst[3])  # 等价于上一句
lst
# >> [2, 5, 6, 8, 20, 9, 2, 9, 9, 15, 2, 5, 6]

# 翻转列表里的所有元素
lst.reverse()
lst
# >> [6, 5, 2, 15, 9, 9, 2, 9, 20, 8, 6, 5, 2]

# 对列表里的元素进行排序，从小到大一次，从大到小一次
lst.sort() # 默认升序
lst
# >> [2, 2, 2, 5, 5, 6, 6, 8, 9, 9, 9, 15, 20]

lst.sort(reverse=True) # 降序
lst
# >> [20, 15, 9, 9, 9, 8, 6, 6, 5, 5, 2, 2, 2]


a = [[6, 5], [3, 7], [2, 8]]
#二维列表，根据 首元素 排序
sorted(a, key=lambda x:x[0]) 
# >> [[2, 8], [3, 7], [6, 5]]

#二维列表，根据 尾元素 排序
sorted(a, key=lambda x:x[-1]) 
# >> [[6, 5], [3, 7], [2, 8]]

(10). 修改列表

# 请将列表里所有数字修改成原来的两倍
# 注意： list*2 是将列表中的元素重复2次
''' 若列表中，只有int、float、bool和list数据，可用下述函数，将其每个元素翻倍'''
def double_list(lst):
    for index,item in enumerate(lst):
        if isinstance(item,bool):
            continue
        elif isinstance(item,(int,float)):
            lst[index] = lst[index]*2
        elif isinstance(item,list):
            double_list(item)
            
def main():
    lst = [1,[4,6],True]
    double_list(lst)
    print(lst)

main()
# >> [2, [8, 12], True]

(11). 山脉数组的峰顶索引

如果一个数组k符合下面两个属性，则称之为山脉数组。
a. 数组的长度大于等于3；
b. 存在i，0<i<len(k)-1，使得k[0]<k[1]<…<k[i-1]<k[i]>k[i+1]>…k[len(k)-1]；
这个i就是顶峰索引。
现在，给定一个山脉数组，求顶峰索引。

def mountain_list1(lst):
    if (b[0] < b[1]) and (b[1] > b[2]):
        print('是山脉数组')
        print('顶峰是：', b[1])
    else:
        print('不是山脉数组')

def mountain_list2(lst): 
    if (b[0] < b[1]) and (b[k-2] > b[k-1]):
        for i in range(1,k-1):
            if b[i] > b[i-1]:
                c.append(i)
                continue
                if b[i] > b[i+1]:
                    pass
                else:
                    print('不是山脉数组')
                    break
        print('是山脉数组')
        print('顶峰是：', b[max(c)]) 
    else:
        print('不是山脉数组')

if __name__ == '__main__':
    lst = input('请输入数字，用英文逗号分隔：')
    b = list(eval(lst))
    c = []
    k = len(b)
    
    if k < 3:
        print('数字个数要大于等于3，请重新输入！')
    elif k ==3:
        mountain_list1(lst)
    else:
        mountain_list2(lst)       
# >>输入:1,3,4,5,3   输出:是山脉数组   顶峰是： 5
# >> 输入:1, 2, 4, 6, 4, 5   输出:不是山脉数组

(12). 元组操作练习

(1, 2)*2 >> (1, 2, 1, 2)
(1, )*2  >> (1, 1)
(1)*2    >>  2

'''
元组只有一个元素时，必须要有一个逗号；
若无逗号时，小括号不是元组，而是起到优先级的作用；
'''

(13). 拆包

  拆包：就是将一个对象拆为多个对象，拆包实际上可以应用到任何可迭代对象上。唯一的硬性要求是：被可迭代对象中的元素数量必须要跟接受这些元素的元组的空档数一致。如：a, b = 1, 2 就属于拆包；

''' 可迭代对象拆包时，怎么赋值给占位符'''
player_infos = [('Kobe', '24'), ('James', '23'), ('Iverson','3')]
for player_names, _  in player_infos:
    print(player_names)

# >> Kobe
# >> James
# >> Iverson

(14). 字符串操作练习

# 批量替换字符串中的元素
str.replace(old, new [,count=-1])

# 把字符串按照空格进行拆分
str.split(sep=None [,maxsplit=-1])

# 去除字符串首尾的空格
str.strip([chars=None])

# 判断字符串里是否只包含数字0~9
str.isnumeric()

''' sort()是在原序列上排序   sorted()是新建一个序列  '''
m = [4,9,7,11,2,0]
m.sort()
m 
# >> [0, 2, 4, 7, 9, 11]
sorted(m,reverse=True)
# >> [11, 9, 7, 4, 2, 0]

# 快速求1～100的和
sum(range(1,101))
sum([i for i in range(1,101)])
# >> 5050

# 将['x', 'y', 'z'] 和 [1, 2, 3] 转成 [('x',1),('y',2),('z',3)] 的形式
[(a,b)  for a,b in zip(['x', 'y', 'z'],[1, 2, 3])]
# >> [('x', 1), ('y', 2), ('z', 3)]

(15). 最长回文子串

  回文串：是指这个字符串无论从左读还是从右读，所读的顺序是一样的；简而言之，回文串是左右对称的。

def huiwen(lst):
    k = len(lst)
    
# 生成 全部 子串
    for i in range(k):
        for j in range(i, k+1):
            x = lst[i:j]
            if len(x) == 0:
                continue
            else:
                a.append(x)

# 生成 非 回文子串
    for m in a:
        if len(m)%2 != 0:  # 子串长度为奇数
            for n in range((len(m)//2)+1):
                if m[n] != m[len(m)-1-n]:
                    b.append(m)
        else:        # 子串长度为偶数
            for n in range(len(m)//2):
                if m[n] != m[len(m)-1-n]:
                    b.append(m)
                                     

def max_huiwen(a,b):
    c = list(set(a) - set(b))             # 储存 回文子串
    d = [len(item)  for item in c]     # 求回文子串中元素的长度
    for index,value in enumerate(d):# 返回最大元素的所有索引值
        if value == max(d):
            #print(index)       # 返回最大元素的所有索引值
            print(c[index])       # 返回最长回文子串

a = []
b = []
lst = input('请输入字符串：')
huiwen(lst)
max_huiwen(a,b)

# 输入：babad    输出：aba   bab
# 输入：cbbd    输出：bb

(16). 字典操作练习

dic = {'python': 95, 'java': 99, 'c': 100 }

# 字典的长度是3 
len(dic) 

# 修改'java' 这个key对应的value值为98
dic['java'] = 98
dic 
# >> {'python': 95, 'java': 98, 'c': 100}

# 删除 c 这个key
del dic['c']
dic
# >> {'python': 95, 'java': 98}

# 增加一个key-value对，key值为 php, value是90
dic['php'] = 90
dic
# >> {'python': 95, 'java': 98, 'php': 90}

# 获取所有的key值，存储在列表里
list(dic.keys())
# >> ['python', 'java', 'php']

# 获取所有的value值，存储在列表里
list(dic.values())
# >> [95, 98, 90]

# 判断 javascript 是否在字典中
'javascript' in dic
# >> False

# 获得字典里所有value 的和
sum(list(dic.values()))
sum(dic.values()) # 等价于上一句语法
# >> 283

# 获取字典里最大的value
max(list(dic.values()))
max(dic.values()) # 等价于上一句语法
# >> 98

# 获取字典里最小的value
min(list(dic.values()))
min(dic.values())
# >> 90

# 字典 dic1 = {'php': 97}， 将dic1的数据更新到dic中
dic.update({'php': 97})
dic
# >> {'python': 95, 'java': 98, 'php': 97}

(17). 字典中的value

   有一个字典，保存的是学生各个编程语言的成绩，内容如下：各门课程的考试成绩存储方式并不相同，如用字典/列表，但是分数都是字符串类型，请实现函数 transfer_score(score_dict) ，将分数修改成int类型。
递归算法

def transfer_score(dic):
    if isinstance(dic, dict) == True:
        for m,n in list(dic.items()):
            dic[m] = transfer_score(n)
        return dic 
    elif isinstance(dic, list) == True:
        for n in range(len(dic)):
            dic[n] = transfer_score(dic[n])
        return dic
    elif isinstance(dic, str) == True:
        return int(dic)

if __name__ == '__main__':
    data = { 'python': {'上学期': '90', '下学期': '95'},
            'c++': ['95', '96', '97'],
            'java': [{'月考':'90', '期中考试': '94', '期末考试': '98'}] }
    transfer_score(data)
    print(data)

''' 运行结果：
{'python': {'上学期': 90, '下学期': 95},
 'c++': [95, 96, 97],
  'java': [{'月考': 90, '期中考试': 94, '期末考试': 98}]}
'''

(18). 怎么给函数编写文档？

   在def语句后面，把注释文档放在引号(单/双/三引号)里面就行；可以通过function.__doc__访问，可参考Python基础（五）。

(19). 怎么给函数参数和返回值注解？

''' 普通的函数 ''' 
def func1(a, b, c):
    print(a+b+c)
    
func1.__annotations__    
# >> {} (一个空字典)

''' 添加了函数注释的函数 ''' 
def func2(a : int, b : float, c : int) -> int:
    print(a+b+c)
func2.__annotations__
# >> {'a': int, 'b': float, 'c': int, 'return': int} 

(20). 按照以下要求定义一个游乐园门票的类，并尝试计算2个成人+1个小孩平日票价

''' 要求:平日票价100元、周末票价为平日的120%、儿童票半价 '''
class Ticket():
    def func(self, num_aldult, num_child, weekend = False, child = False):
        self.price = 100
        if weekend == True:
            price_weekend = 1.2
        else:
            price_weekend = 1
        
        if child == True:
            price_child = 0.5
        else:
            price_child = 1
        
        print(self.price * price_weekend * num_aldult + self.price * price_child * num_child)

price = Ticket()
price.func(2, 1, weekend = False, child = True)
# >> 250.0

(21). 编写Python程序以选择指定年份的所有星期日

import datetime
from dateutil import parser

def sundays(year):
    sundays = []
    dt_start = parser.parse(year+'0101').date()
    dt_end = parser.parse(year+'1231').date()
    
    if dt_start.isoweekday() != 7:
        dt0 = dt_start + datetime.timedelta(days = (7-dt_start.isoweekday()))
        sundays.append(dt0.strftime('%Y-%m-%d'))
    else:
        sundays.append(dt0.strftime('%Y-%m-%d'))
    
    while dt0 <= dt_end:
        dt0 = dt0 + datetime.timedelta(days = 7)
        if dt0 <= dt_end:
            sundays.append(dt0.strftime('%Y-%m-%d'))
    print(sundays)


def main():
    year = input('请输入年份：')
    sundays(year)
main()

(22). 汉诺塔问题

   分析思路：将这n个盘子从A杆移动到C杆，可做以下三步：(1). 从A杆将 1至n-1号盘 移至B杆；(2). 将A杆中剩下的 第n号盘 移至C杆；(3). 从B杆将 1至n-1号盘 移至C杆；
递归算法

def Hanoi(n, a, b, c):
    if n == 1:
        print(a, '-->', c)
    else:
        Hanoi(n-1, a, c, b) # 将 (1~n-1盘) 从A移到B
        Hanoi(1, a, b, c)    # 将 (第n盘)  从A移到C
        Hanoi(n-1, b, a, c) # 将 (1~n-1盘) 从B移到C

Hanoi(4,'A','B','C')

谢谢大家 🌹