python系列文章目录
python基础（01变量&数据类型&运算符）
python基础（02序列共性）
python基础(03列表和元组)
python基础（04字符串&字典）
python基础（05集合set）
python基础（06控制语句）
python基础（07函数）
python基础（08类和对象）
python基础（09闭包&装饰器）
python基础（10异常处理）
python基础（11文件读取）
python基础（12迭代器&生成器）
python基础（13魔法方法介绍）
python基础（14内置函数介绍）
python基础（15多线程编程介绍）
python基础（16面试题附答案一）
文章目录
一、面试题附答案二
21.难度等级2
实现一个函数，判断传入的参数是否为回文
所谓 回文，就是 左右对称的字符 如 "abccba" "abcba"
python
#思路：反向打印 看和原字符串的值是否相同 相同为回文
def judge(a):
if str(a)==str(a)[::-1]:
print(f"{a}这是个回文")
else:
print(f"{a}这不是个回文")
b=judge("abhgcba")
c=judge("abccba")
d=judge("abcba")22.难度等级2
打印 所有水仙花数
所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方
python
#思路：传入的是一个三位数字，先将整数转化成字符串，利用角标获取0，1，2的值，转化成整数进行三次方计算累加对比是否相等
#整数不能使用角标
def judge1(a):
b = str(a)
b1=int(b[0])
b2=int(b[1])
b3=int(b[2])
if a==b1**3+b2**3+b3**3:
print(f"{a}这是个水仙花数")
else:
print(f"{a}这不是个水仙花数")
c=judge1(153)
d=judge1(231)23.难度等级4
用冒泡排序实现 一个无序列表的排序
冒泡排序原理：
每一趟只能确定将一个数归位。即第一趟只能确定将末位上的数归位，
第二趟只能将倒数第 2 位上的数归位，依次类推下去。
如果有 n 个数进行排序，只需将 n-1 个数归位，也就是要进行 n-1 趟操作。
而 "每一趟 " 都需要从第一位开始进行相邻的两个数的比较，将较大的数放后面，
比较完毕之后向后挪一位继续比较下面两个相邻的两个数大小关系，重复此步骤，直到最后一个还没归位的数。
python
#定义函数get_sort():将无序列表从小到大排序打印
def get_sort(lst):
l=len(lst) #获取列表长度
for i in range(0,l):
for j in range(0,l-i-1): #for循环遍历
if lst[j]>lst[j+1]: #相邻位置的字符进行比较
lst[j],lst[j+1]=lst[j+1],lst[j] #内置方法换位置
else:
continue
print(lst)
get_sort([5,6,2,10,8,4,2,1,5])24.难度等级4
用面向对象的思维 实现下列需求
- 士兵 都有 姓名和一把枪
- 士兵 可以 用枪开火
- 枪 能够装填子弹
- 枪 能够发射子弹
python
class Soidier:
def __init__(self, name, gun):
self.name = name
self.gun = gun
def shoot(self):
print(f"{self.name}在用{self.gun}开火")
def add_gun(self):
print(self.gun,"在填装子弹")
def launch_gun(self):
print(self.gun,"在发射子弹")
s1 = Soidier('David',"冲锋枪")
print(s1.name)
print(s1.gun)
s1.shoot()
s1.add_gun()
s1.launch_gun()25.难度等级2
利用多态实现不同的游戏角色出拳的例子
python
class Rose:
def punches_hurt(self):
pass
class Jack(Rose):
def punches_hurt(self):
print("Jack的伤害值为：1000")
class Captain(Rose):
def punches_hurt(self):
print("Captain的伤害值为：500")
class Nami(Rose):
def punches_hurt(self):
print("Nami的伤害值为：100")
j=Jack()
c=Captain()
n=Nami()
def output(obj):
obj.punches_hurt()
output(j)
output(c)
output(n)26.难度等级 II
实现一个装饰器，每次调用函数时，将函数名字 和 调用时间写入到文件 a.txt 中
要求先熟悉 python 文件的操作
函数名可用 name 来获取，如:
def func1():
pass
func1.name
python
#第一步：写一个输出日志功能
import time
def writeLog(func):
#添加一个异常判断
try:
file=open("log.txt",'a',encoding='utf-8')
file.write("访问：")
file.write(func.__name__) #获取函数的名字
file.write("\t")
file.write("时间：") #获取时间
file.write(time.asctime())
file.write("\n")
except Exception as e:
print(e.args)
finally:
file.close() #释放资源
#第二步：写一个装饰器
def funcOut(func):
def funcIn():
writeLog(func) #内部函数引用外部函数
func()
return funcIn
#第三步：装饰器调用
@funcOut #相当于fun1=funcOut(fun1)
def fun1():
print("功能1")
@funcOut
def fun2():
print("功能2")27、难度等级 II
实现选择排序
算法描述：
- 在一个长度为 N 的无序数组中，第一次遍历 n-1 个数找到最小的和第一个数交换。
- 第二次从下一个数开始遍历 n-2 个数，找到最小的数和第二个数交换。
- 重复以上操作直到第 n-1 次遍历最小的数和第 n-1 个数交换，排序完成。
python
def get_sort(lst):
l=len(lst) #获取列表长度
for i in range(0,l-1):
for j in range(0+i,l-1): #for循环遍历
if lst[j]<lst[j+1]: #相邻位置的字符进行比较
lst[j],lst[j+1]=lst[j+1],lst[j] #内置方法换位置
lst[i],lst[l-1]=lst[l-1],lst[i] #每一次遍历后，最小值都是最后一个，依次替换
print(lst)
get_sort([5,6,2,10,8,4,2,1,5])28、.难度等级 II
实现用户登录系统，用户名密码正确，提示登录成功，用户名密码不匹配，提示密码错误，你还有几次登录机会 当用户输入三次密码时，提示不能登录,
用户名，密码存放在字典中 user_dict= {"cc":"123123","jiajia":"123123"}
python
print('''-----------------欢迎来到佳佳的登录系统--------------------''')
user_dict={}
name=input("请设置初始用户名：")
mm=input("请设置初始密码：")
user_dict[name]=mm
user_dict1={}
i=0
while i<3:
i+=1
name1 = input("请重新输入用户名：")
mm1 = input("请重新输入密码：")
user_dict1[name1] = mm1
num=3-i
if name1 in user_dict and user_dict[name]==user_dict1[name1] :
print('恭喜你，登录成功！！')
break
elif num>0:
print(f'密码错误，您还有{num}次机会!!')
else :
print("登录失败！！！")29.难度等级 II
有文件 a.txt(内容不为空，且有多行)
要求：找出出现次数最多的字符
python
#后面的x: x[1] 为对前面的对象中的第二维数据（即value）的值进行排序。reverse=True 降序
f=open(r"e.txt","w")
s=["姓名佳佳\n","佳佳爱测试\n","软件测试\n"]
f.writelines(s)
f.close()
with open(r"e.txt","r") as f:
str=f.read()
str1=str.splitlines() #字符串的行切分 多行并一行 str1
str2=''.join(str1) #多个字符串拼接成一个大字符串 str2
dic={i:str2.count(i) for i in set(str2)} #字典的推导式
dic_sort=sorted(dic.items(),key=lambda x : x[1],reverse=True) #降序排序
print(dic_sort)
print(dic_sort[0][0])30.难度等级 I
选择排序
上课时 从小到大 排序， 现在要求 从大到小进行排序
python
#方法一：
def get_sort(lst):
l=len(lst) #获取列表长度
for i in range(0,l-1):
for j in range(i+1,l-1): #第一个不用排序 始终会被替换，for循环遍历
if lst[j]>lst[j+1]: #相邻位置的字符进行比较
lst[j],lst[j+1]=lst[j+1],lst[j] #内置方法换位置
lst[i],lst[l-1]=lst[l-1],lst[i] #每一次遍历后，最大值都是最后一个，依次替换
print(lst)
get_sort([5,6,2,10,8,4,2,1,5])
#方法二：优化
def get_sort(lst):
l=len(lst) #获取列表长度
for i in range(0,l-1):
max_index=i #记录最大元素的位置
for j in range(i+1,l): #第一个不用排序 始终会被替换，for循环遍历
if lst[j]>lst[max_index]: #遍历字符与最大字符进行比较
max_index=j #最大元素的下标
lst[max_index],lst[i]=lst[i],lst[max_index] #每一次遍历依次把最大值放在0，1，2，3，，，
print(lst)
get_sort([5,6,2,10,8,4,2,1,5])31.难度等级 II
一年份列表 [2002,2004,1999,2000,1986,1992]，
先要用filter()方法得到一个新列表，要求里面的年份都是闰年
python
#闰年:1.能被4整除 不能被100整除 2.能被400整除
def leap_year(n):
return (n%4==0 and n%100 !=0 or n%400==0)
l=filter(leap_year,[2002,2004,1999,2000,1986,1992])
print(list(l))32.难度等级 II
实现个迭代器，要求输入的字符串 正序输出
python
#思路:把正下标换成负下标
class Iter_demo:
def __init__(self,date):
self.date=date
self.index=len(date)+1
def __iter__(self):
return self
def __next__(self):
if self.index == 1:
raise StopIteration
self.index -= 1
return self.date[-(self.index)]
a=Iter_demo("abc")
for s in a:
print(s)33.难度等级 III
实现算法，找出 列表 [3,5,2,8,4]中第二大的数
python
#方法一:列表的排序sort()
x=[3,5,2,8,4]
x.sort()
print(x[-2])
#方法二:内置函数sorted() 降序
sorter=sorted([3,5,2,8,4],reverse=True)
print(sorter[1])
#方法三:选择排序
def get_sort(lst):
l=len(lst) #获取列表长度
for i in range(0,l-1):
max_index=i #记录最大元素的位置
for j in range(i+1,l): #第一个不用排序 始终会被替换，for循环遍历
if lst[j]>lst[max_index]: #遍历字符与最大字符进行比较
max_index=j #最大元素的下标
lst[max_index],lst[i]=lst[i],lst[max_index] #每一次遍历依次把最大值放在0，1，2，3，，，
print(lst[1])
get_sort([3,5,2,8,4])34.难度等级 I
输入一个整数n，用生成器打印出从 0~n 中的所有偶数
python
def even_numbers(num):
for i in range(num):
if i%2==0:
yield i
number=even_numbers(10)
for i in number:
print(i)