1-Python - 疯狂练习题
Python基础
- 简述变量命名规范
- 变量名是由字母,数字,下划线组成
- 变量名不能以数字开头
- 禁止使用python中的关键词
- 变量名要区分大小写,
- 变量名不能使用中文和拼音
- 变量名要有意义
- 推荐写法:驼峰体(
UserName或者userName)或下划线(user_name)
- name = input(“>>>”) name变量是什么数据类型
name = input(">>")
print(type(name)) # str
- if条件语句的基本结构
if
if/if
if/else
if/elif
if/elif/elif
if/elif/.../else
if 嵌套
- 用print打印出下面内容：
⽂能提笔安天下,
武能上⻢定乾坤.
⼼存谋略何⼈胜,
古今英雄唯是君.
print('''
⽂能提笔安天下,
武能上⻢定乾坤.
⼼存谋略何⼈胜,
古今英雄唯是
''')
print("⽂能提笔安天下,\n武能上⻢定乾坤.\n⼼存谋略何⼈胜,\n古今英雄唯是君.")
- 利用if语句写出猜大小的游戏：设定一个理想数字比如：66，让用户输入数字，如果比66大，则显示猜测的结果大了；如果比66小，则显示猜测的结果小了;只有等于66，显示猜测结果正确:
a = input('请输入数字')
if int(a) > 66:
print('大了')
if int(a) < 66:
print('小了')
elif int(a) = 66:
print('对了')
- 提⽰⽤户输入他的年龄, 程序进⾏判断:如果⼩于10, 提⽰⼩屁孩, 如果⼤于10, ⼩于 20, 提⽰青春期叛逆的⼩屁孩. 如果⼤于20, ⼩于30. 提⽰开始定性, 开始混社会的⼩ 屁孩⼉, 如果⼤于30, ⼩于40. 提⽰看老⼤不⼩了, 赶紧结婚⼩屁孩⼉. 如果⼤于40, ⼩ 于50. 提⽰家⾥有个不听话的⼩屁孩⼉. 如果⼤于50, ⼩于60. 提⽰⾃⼰⻢上变成不听 话的老屁孩⼉.如果⼤于60, ⼩于70. 提⽰活着还不错的老屁孩⼉. 如果⼤于70, ⼩于 90. 提⽰⼈⽣就快结束了的⼀个老屁孩⼉. 如果⼤于90以上. 提⽰. 再⻅了这个世界.
s = input('请输入年龄')
s1 = int(s1)
if s1 < 10:
print('小屁孩')
elif 10 < s1 < 20:
print('青春叛逆的小屁孩')
elif 20 < s1 < 30:
print('开始定性,开始混社会的小屁孩')
elif 30 < s1 < 40:
print('老大不小了,赶紧结婚小屁孩')
elif 40 < s1 < 50:
print('青春叛逆的小屁孩')
elif 50 < s1 < 60:
print('开始定性,开始混社会的小屁孩')
elif 60 < s1 < 70:
print('老大不小了,赶
elif 70 < s1 < 80:
print('青春叛逆的小屁孩')
elif 80 < s1 < 90:
print('开始定性,开始混社会的小屁孩')
- 判断下面print的输出结果：
print(1 > 1 or 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) # True
print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) # False
- 打印菱形小星星
"""
*
***
*****
*******
*********
***********
*********
*******
*****
***
*
"""
count = 1
range_num = 13
for i in range(1, range_num):
if range_num / 2 > i: # 当宽的一半小于 i 说明要从小到大，每次加两个*
sign = "*" * count
print(sign.center(range_num, ' '), '-----', 'count == ', count, 'i == ', i, '半数： ', range_num / 2)
count += 2
else:
sign = "*" * count
print(sign.center(range_num, ' '), '+++++++', 'count == ', count, 'i == ', i, '半数： ', range_num / 2)
count -= 2
- 三级菜单
需求
需求：
可依次选择进入各子菜单
可从任意一层往回退到上一层
可从任意一层退出程序
所需新知识点：列表、字典
基础需求：80%
- 可依次选择进入各子菜单
- 可从任意一层往回退到上一层
- 可从任意一层退出程序
所需新知识点：列表、字典
升级需求：10%
- 使用一个while循环，且整体代码量不超过15行
编码规范需求：10%
思路：
字典查询 列表循环
while 循环 加 if 判断
for 循环打印结果
基础版
menu = {
'北京':{
'海淀':{
'五道口':{
'soho':{},
'网易':{},
'google':{}
},
'中关村':{
'爱奇艺':{},
'汽车之家':{},
'youku':{},
},
'上地':{
'百度':{},
},
},
'昌平':{
'沙河':{
'老男孩':{},
'北航':{},
},
'天通苑':{},
'回龙观':{},
},
'朝阳':{},
'东城':{},
},
'上海':{
'闵行':{
"人民广场":{
'炸鸡店':{}
}
},
'闸北':{
'火车战':{
'携程':{}
}
},
'浦东':{},
},
'山东':{},
}
exit_flag = False
while not exit_flag:
for key in menu:
print(key)
choice = input(">:").strip()
if len(choice) == 0 : continue
if choice == 'q':
exit_flag = True
continue
if choice in menu: #省存在，进入此省下一级
while not exit_flag:
next_layer = menu[choice]
for key2 in next_layer:
print(key2)
choice2 = input(">>:").strip()
if len(choice2) == 0: continue
if choice2 == 'b': break
if choice2 == 'q':
exit_flag = True
continue
if choice2 in next_layer: #再进入下一层
while not exit_flag:
next_layer2 = next_layer[choice2]
for key3 in next_layer2:
print(key3)
choice3 = input(">>>:").strip()
if len(choice3) == 0: continue
if choice3 == 'b': break
if choice3 == 'q':
exit_flag = True
continue
if choice3 in next_layer2:
while not exit_flag:
next_layer3 = next_layer2[choice3]
for key4 in next_layer3:
print(key4)
choice4 = input(">>>>:").strip()
if choice4 == 'b':break
if choice4 == 'q':
exit_flag = True
continue
进阶版
menu = {
'北京':{
'海淀':{
'五道口':{
'soho':{},
'网易':{},
'google':{}
},
'中关村':{
'爱奇艺':{},
'汽车之家':{},
'youku':{},
},
'上地':{
'百度':{},
},
},
'昌平':{
'沙河':{
'老男孩':{},
'北航':{},
},
'天通苑':{},
'回龙观':{},
},
'朝阳':{},
'东城':{},
},
'上海':{
'闵行':{
"人民广场":{
'炸鸡店':{}
}
},
'闸北':{
'火车战':{
'携程':{}
}
},
'浦东':{},
},
'山东':{},
}
last_layers = [ menu ] #上一层
current_layer = menu #当前层
while True:
for key in current_layer:
print(key)
choice = input(">>:").strip()
if len(choice)==0:continue
if choice in current_layer: #进入下一层
last_layers.append(current_layer) #当前层添加到列表
current_layer = current_layer[choice] #北京
if choice == "b":
if last_layers:
current_layer = last_layers[-1] #取到上一层，赋值给current_layer
last_layers.pop()
if choice == 'q':
break
函数
- 编写认证功能的装饰器，为多个函数加上认证的功能(用户名和密码)，要求只需要登录成功一次，后续的函数都能自动登录成功：
"""
认证功能的装饰器
"""
certificate_dict = {}
def cert(func):
def wrapper(*args, **kwargs):
if certificate_dict.get('status', False):
print('[{}] 自动登录成功'.format(certificate_dict['user_name']))
return func(*args, **kwargs)
else:
user, pwd = input("user: ").strip(), input("pwd: ").strip()
if user.lower() == 'zhangkai' and pwd == '123': # 这里可以将用户名和密码写在文件中
print("[{}]登录成功".format(user))
certificate_dict['user_name'] = user
certificate_dict['status'] = True
return func(*args, **kwargs)
return wrapper
@cert
def login():
print('login function')
@cert
def index():
print('index page')
@cert
def back():
print('back page')
if __name__ == '__main__':
login()
index()
back()
- 计算
1!+2!+3!+10！的阶乘结果：
def foo1(n):
num, count = 1, 0
for i in range(1, n + 1):
num *= i
count += num
return count
def foo2(n):
count = 0
for i in range(1, n + 1):
tmp = 1
for k in range(1, i + 1):
tmp *= k
count += tmp
return count
if __name__ == '__main__':
print(foo1(10)) # 4037913
print(foo2(10)) # 4037913
- 使用函数完成三次登录，要求是用户名和密码都保存在一个
info.txt中，且info.txt文件中存储有多个用户名和和密码，每个用户名和密码占用一行。三次登录失败即退出程序：
"""
# info.txt
zhangkai|123
likai|234
wangkai|345
"""
PATH = r'./info.txt'
def read_file(path):
with open(path, 'r', encoding='utf-8') as f:
l = []
for i in f:
name, pwd = i.strip().split("|")
l.append({"user": name, "pwd": pwd})
return l
def login():
user_list = read_file(PATH)
count = 1
while count <= 3:
user = input('user: ').strip()
pwd = input('pwd: ').strip()
for i in user_list:
if user == i['user'] and pwd == i['pwd']:
print('login successful')
break
else:
print('login error')
count += 1
if __name__ == '__main__':
login()
- 递归统计指定目录下的文件个数：
import os
def foo(path):
if os.path.isdir(path):
total = 0
for line in os.listdir(path):
tmp_path = os.path.join(path, line)
if os.path.isdir(tmp_path):
total += foo(tmp_path)
else:
total += 1
return total
else:
exit('给定的路径不是目录')
if __name__ == '__main__':
print(foo(r"D:\tmp"))
- 使用相关模块生成6为的验证码，验证码内容包括随机数字、随机小写字符、随机大写字符：
import random
import string
# 法1
def code(n=6):
end = ''
for i in range(n):
num = str(random.randint(0,9))
alpha_up = chr(random.randint(65,90))
alpha_low = chr(random.randint(97,122))
aim = random.choice([num,alpha_up,alpha_low])
end += aim
return end
print(code(8)) # 传几位就生成几位验证码
# 法2
def foo(n):
return ''.join(random.sample(string.digits + string.ascii_lowercase + string.ascii_uppercase, n))
print(foo(6))
- 用map来处理列表,把列表中所有人都变成
xx_666，如张开_666,name = ["张开", "李开", "王开", "赵开"]:
name = ["张开", "李开", "王开", "赵开"]
print(list(map(lambda x: x + '_666', name)))
"""
['张开_666', '李开_666', '王开_666', '赵开_666']
"""
- 使用map来处理列表，将列表中每个人的名字都编程以
xx_666，如张开_666，tmp_list = [{'name': '张开'}, {'name': '李开'}, {'name': '王开'}, {'name': '赵开'}]:
tmp_list = [{'name': '张开'}, {'name': '李开'}, {'name': '王开'}, {'name': '赵开'}]
print(list(map(lambda x: x['name'] + '_666', tmp_list)))
"""
['张开_666', '李开_666', '王开_666', '赵开_666']
"""
- 将下面的列表内的元素以
age升序排序：
tmp_list = [
{'name': '张开', 'age': 18}, {'name': '李开', 'age': 8},
{'name': '王开', 'age': 32}, {'name': '赵开', 'age': 25}
]
tmp_list.sort(key=lambda x: x['age'], reverse=False)
print(tmp_list)
"""
[{'name': '李开', 'age': 8}, {'name': '张开', 'age': 18}, {'name': '赵开', 'age': 25}, {'name': '王开', 'age': 32}]
"""
- 文件操作，使用Python将图片新建一个副本，比如有a.jpg,使用Python得到副本b.jpg:
with open('a.jpg', 'rb') as rf:
with open('b.jpg', 'wb') as wf:
wf.write(rf.read())
- 实现一个统计函数执行时间的装饰器
import time
import random
def timmer(func):
def wrapper(*args, **kwargs):
start = time.time()
res = func(*args, **kwargs)
print('{} running: {}'.format(func.__name__, time.time() - start))
return res
return wrapper
@timmer
def foo():
time.sleep(random.random())
foo()
- 写函数,接收两个数字参数,将较小的数字返回:
def foo(x, y):
return y if x > y else x
print(foo(3, 6))
print(foo(6, 3))
模块与包
- 获取当前的字符串时间(
2020-12-24 11:06:14)，获取三天后的字符串时间(2020-12-24 11:06:14):
import time
# 一天的时间戳时间
one_day_time = 24 * 60 * 60
# 当前时间戳时间 --> 结构化时间 --> 字符串时间
now_timestamp_time = time.time()
now_struct_time = time.localtime(now_timestamp_time)
now_format_time = time.strftime('%Y-%m-%d %H:%M:%S', now_struct_time)
print(now_format_time) # 2020-12-24 11:06:14
# 三天后的字符串时间：当前时间戳时间 + 3天时间戳时间 --> 结构化时间 --> 字符串时间
after_three_days_timestamp_time = now_timestamp_time + one_day_time * 3
after_three_days_struct_time = time.localtime(after_three_days_timestamp_time)
after_three_days_format_time = time.strftime('%Y-%m-%d %H:%M:%S', after_three_days_struct_time)
print(after_three_days_format_time) # 2020-12-27 11:06:14
import datetime
after_three_days_struct_time = datetime.datetime.now() + datetime.timedelta(days=3)
after_three_days_format_time = after_three_days_struct_time.strftime("%Y-%m-%d %H:%M:%S")
print(after_three_days_format_time)
- 请将时间'2018-11-11 11:11:11'转换成时间戳时间
import time
''''
思路：字符串时间 --> 结构化时间 --> 时间戳时间
'''
t = "2018-11-11 11:11:11"
strpt_time = time.strptime(t, '%Y-%m-%d %H:%M:%S')
print(time.mktime(strpt_time)) # 1541905871.0
- 如何获取当前脚本的绝对路径和父级路径：
import os
print(os.path.abspath(__file__))
print(os.path.dirname(os.path.abspath(__file__)))
- 回答：
# 什么是可迭代对象？什么是迭代器？可迭代对象和迭代器的区别是什么？什么是生成器，如何得到一个生成器
# 如果一个对象具有__iter__方法，则称为可迭代对象
# 可迭代对象执行__iter__方法返回的结果称为迭代器
# 可迭代对象只有__iter__方法，而迭代器则有__iter__、__next__两个方法。
# 函数体内包含有yield关键字，那么该函数被称为生成器函数，而该函数执行的结果(返回值generator_obj)为生成器
# https://www.cnblogs.com/Neeo/articles/13200309.html
# https://www.cnblogs.com/Neeo/articles/13200313.html
- 写函数，完成给一个列表去重的功能(不能使用set集合)，
tmp_list = [1, 2, 2, 1, 3, 4, 5, 6]：
def foo(l):
tmp_list = []
for i in l:
if i not in tmp_list:
tmp_list.append(i)
return tmp_list
print(foo([1, 2, 2, 1, 3, 4, 5, 6])) # [1, 2, 3, 4, 5, 6]
异常处理
面向对象
Others
- 求最大可能，也称为求一个集合的所有的子集：
def PowerSetsBinary(items):
#generate all combination of N items
N = len(items)
#enumerate the 2**N possible combinations
for i in range(2**N):
combo = []
for j in range(N):
#test jth bit of integer i
if(i >> j ) % 2 == 1:
combo.append(items[j])
yield combo
for i in PowerSetsBinary('123'):
print(i)
'''
[]
['1']
['2']
['1', '2']
['3']
['1', '3']
['2', '3']
['1', '2', '3']
'''
- Python生成目录树代码，用Python实现类似Windows下的tree命令，获取目录树结构：
import os
import os.path
BRANCH = '├─'
LAST_BRANCH = '└─'
TAB = '│ '
EMPTY_TAB = ' '
def get_dir_list(path, placeholder=''):
folder_list = [folder for folder in os.listdir(path) if os.path.isdir(os.path.join(path, folder))]
file_list = [file for file in os.listdir(path) if os.path.isfile(os.path.join(path, file))]
result = ''
for folder in folder_list[:-1]:
result += placeholder + BRANCH + folder + '\n'
result += get_dir_list(os.path.join(path, folder), placeholder + TAB)
if folder_list:
result += placeholder + (BRANCH if file_list else LAST_BRANCH) + folder_list[-1] + '\n'
result += get_dir_list(os.path.join(path, folder_list[-1]), placeholder + (TAB if file_list else EMPTY_TAB))
for file in file_list[:-1]:
result += placeholder + BRANCH + file + '\n'
if file_list:
result += placeholder + LAST_BRANCH + file_list[-1] + '\n'
return result
if __name__ == '__main__':
print(os.path.dirname(os.getcwd()))
print(get_dir_list(os.path.dirname(os.getcwd())))
- 打印斐波那契数列，斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13,特别指出：第0项是0，第1项是第一个1。从第三项开始，每一项都等于前两项之和。
代码示例
# 1. 利用for循环动态输入一个动态的数列，如输入5，>>> [0, 1, 1, 2, 3]
num = int(input('>>>:'))
fibonacci = [0, 1]
for i in range(num - 2):
fibonacci.append(fibonacci[-2] + fibonacci[-1])
print(fibonacci)
# 2. 使用函数的方式
def fibonacci(num):
result = [0, 1]
for i in range(num-2):
result.append(result[-2] + result[-1])
return result
print(fibonacci(11))
# 3. 递归版本
def r_fibonacci(num):
"""递归版本 """
if num < 2:
return num
return r_fibonacci(num - 1) + r_fibonacci(num - 2)
# print(r_fibonacci(10))
for i in range(11):
print(r_fibonacci(i))
# 4. lambda版
fibonacci = lambda n: 1 if n <= 2 else fibonacci(n - 1) + fibonacci(n - 2)
print(fibonacci(35))
# 生成器版
class Fib(object):
def __init__(self):
self.prev = 0
self.curr = 1
def __iter__(self):
return self
def __next__(self):
self.curr, self.prev = self.prev + self.curr, self.curr
return self.curr
fib = Fib()
for i in range(10):
print(next(fib))
# yield版
def fib():
prev, curr = 0, 1
while True:
yield curr
curr, prev = prev + curr, curr
f = fib()
for i in range(10):
print(next(f))
欢迎斧正，that's all
