python编程题：
一、列表，字符串：
1、如何实现字符串的反转？
需求：如： name = "wupeiqi" 请反转为 name ="iqiepuw"
方法1：
name = "wupeiqi"
list=[]
for i in name:
list.append(i)
list2=''.join(list[::-1])
print(list2)
iqiepuw
Process finished with exit code 0
方法2：
name = "wupeiqi"
list=[]
for i in name:
list.insert(0,i)
print(list)
name=''.join(list)
print(name)
['i', 'q', 'i', 'e', 'p', 'u', 'w']
iqiepuw
Process finished with exit code 0
方法3：
name = "wupeiqi"
#(1)、reverse方法 # 对原列表进行倒序。翻转
a=list(name)
a.reverse()
b=''.join(a)
print(b, ' ', type(b))
#(2)、reversed方法 将一个序列翻转, 返回翻转序列的迭代器
c=list(name)
d=reversed(c)
e=''.join(d)
print(e, ' ', type(b))
iqiepuw <class 'str'>
iqiepuw <class 'str'>
Process finished with exit code 0
考察知识点：
- append作用是列表最后位置添加成员，list[::-1]表示切片步长为-1 可实现反转；
- insert作用是在列表指定位置插入指定的值，insert(0,i)表示每次都是在索引0的位置插入值 可实现反转；
- join()函数
- reverse方法 和 reversed方法 的使用语区别？
join()函数
join()是一个字符串方法，它返回被子字符串连接的字符串。
比如列表，元组，字符串，字典和集合都可以用join（）
-
语法：
string_name.join(iterable) string_name：这是被连接的子字符串。 -
下面的程序解释了join()方法是如何工作的：
（1)返回的字符串用"-"连接
list1 = ['1', '2', '3', '4'] s = "-" s = s.join(list1) print(s) 1-2-3-4 Process finished with exit code 0(2)返回的字符串 用空字符 连接
list1 = ['g','e','e','k', 's'] print("".join(list1)) geeks Process finished with exit code 0
2、python中怎么把一个列表[1,2,3,4]转换成一个数字1234？
list1 = [1,2,3,4]
#方法一：
# for i in list1:
# l=str(i)
# b=int("".join(l))
# print(b,end='')
#方法二：
# for i in list1:
# print(int(i),end='')
#方法三：
print(int(''.join(map(str,[1,2,3,4]))))
1234
Process finished with exit code 0
3、如何实现 “1,2,3” 变成 [‘1’,’2’,’3’]
s1 = '1,2,3'
print(s1.split(',')) #通过str的split()方法返回分割后的字符串列表
['1', '2', '3']
Process finished with exit code 0
#错误方法--直接转换成列表
s1 = '1,2,3'
print(list(s1)) #['1', ',', '2', ',', '3']
考察知识点：
- split() --拆分:
split() 函数
-
拆分字符串。通过指定分隔符对字符串进行切片，并返回分割后的字符串列表（list）
s= '1,2,3,4' # 默认分隔符 print(s.split()) # , 分割 print(s.split(',')) # 分割一次 2次 print(s.split(',',1)) print(s.split(',',2)) # 取出被 , 分割的下标为1的字符串 print(s.split(',',2)[1]) # 分割最多次实际与不加参数一样（默认分割符一样） print(s.split(',',-1)) #分割三次并将分割的字符串保存到三个文件内 s1,s2,s3= s.split(',',2) print(s1) print(s2) print(s3) # 去掉换行符 \n \t c = '''hello world''' print(c) print(c.split('\n')) print(c.split('\t')) ['1,2,3,4'] ['1', '2', '3', '4'] ['1', '2,3,4'] ['1', '2', '3,4'] 2 ['1', '2', '3', '4'] 1 2 3,4 hello world ['hello', ' world'] ['hello\n world'] Process finished with exit code 0
3、如何实现[‘1’,’2’,’3’]变成[1,2,3]
l1 = ['1','2','3']
#print(type(l1[0]))
l2=[]
for i in l1:
i=int(i)
l2.append(i)
print(l2)
#print(type(l2[0]))
[1, 2, 3]
Process finished with exit code 0
考察知识点：
- [‘1’,’2’,’3’]：表示列表中的数据类型是str（字符串）
- [1,2,3] ：表示列表中的数据类型是int（整数）
4.1、以下代码输出是什么? (切片）
list=['a','b','c','d','e'] print list[10:]
list = ['a', 'b', 'c', 'd', 'e']
print( list[10:])
[] # 空集
Process finished with exit code 0
考察知识点：切片
-
语法：
list[start:stop:step] ''' 可以看出对于列表的切片操作有三个参数，分别为： start：起始位置 stop：终止位置 step：步长 三个参数都是可选参数 '''
list=[i for i in range(100)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 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, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
#正着切片
>>> list[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#负索引切片
>>> list[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
#倒着切片
>>> list[10:0:-1]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> list[-1:-10:-1]
[99, 98, 97, 96, 95, 94, 93, 92, 91]
#跳着切片
>>> list[::10]
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
4.2、切片
a=[2,3,4]
print(a[1:]) #[3, 4]
print(a[:1]) #[2]
b=a[1:]+a[:1]
print(b) #[3, 4, 2]
c=list(zip(a,b))
print(c) #[(2, 3), (3, 4), (4, 2)]
print(a[::-1]) #[4, 3, 2]
5、列表去重
需求：现有一列表 list, 请写出两种去除 list 中重复元素的方法, 其中：（难）
（1）要求保持原有列表中元素的排列顺序。
#遍历
list = [4,14,1212,412,4,12412,5,15,1,5,15] # 为了不报错假设一个列表
l1 = []
for i in list:
if i not in l1:
l1.append(i)
print(l1)
[4, 14, 1212, 412, 12412, 5, 15, 1]
Process finished with exit code 0
（2）无需考虑原有列表中元素的排列顺序
#set()方法：
list = [4,14,1212,412,4,12412,5,15,1,5,15]
s = set(list)
print(s)
{1, 4, 5, 14, 15, 1212, 412, 12412}
Process finished with exit code 0
还有一种方法：借助字典键值的唯一性
list1= [4,14,1212,412,4,12412,5,15,1,5,15]
new_dict=dict.fromkeys(list1)
print(new_dict)
obj=new_dict.keys()
print(obj)
new_list=list(obj)
print(new_list)
{4: None, 14: None, 1212: None, 412: None, 12412: None, 5: None, 15: None, 1: None}
dict_keys([4, 14, 1212, 412, 12412, 5, 15, 1])
[4, 14, 1212, 412, 12412, 5, 15, 1]
Process finished with exit code 0
考察知识点:
- set()函数----python中内置函数 转换成集合来去重
- dict.fromkeys()
fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值
-
语法
dict.fromkeys(seq[, value]) ''' 参数: seq – 字典键值列表 value – 可选参数, 设置键序列（seq）的值 '''
6、用 Python 实现 九九乘法表
for x in range(1,10):
for y in range(1,x + 1):
#msg = '{}*{} = {} '.format(y, x, x*y)
msg=f'{y}*{x}={x*y} '
print(msg,"\t", end='')
print()
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
Process finished with exit code 0
或者：
for x in range(1,10):
for y in range(1,x+1):
result=x*y
print(y,"*",x,"=",result," ","\t",end="")
print("")
'''
end="":print默认打印一行，结尾换行。end="" 意思是结尾不换行。加空格
print("")：增加一个换行符
"\t"：制表符，让字符宽度一致
'''
7、利用for循环和range打印列表的索引
l1 = ["alex", "WuSir", "ritian", "barry", "wenzhou"]
for i in range(len(l1)):
print(i, ' ' ,end='')
0 1 2 3 4
Process finished with exit code 0
8、找出100以内所有的偶数
需求：找出100以内所有的偶数并将这些偶数插入到一个新列表中
（1）第一种方法：
l1=[]
for i in range(2,101,2):
l1.append(i)
print(l1)
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]
Process finished with exit code 0
（1）第二种方法：
l2=[]
for i in range(2,101):
if i % 2 ==0:
l2.append(i)
print(l2)
9、从100~10，倒序将所有的偶数添加到一个新列表中
需求：(1)、利用for循环和range从100~10，倒序将所有的偶数添加到一个新列表中，
(2)、然后对列表的元素进行筛选，将能被4整除的数留下来。
l4=[]
for i in range(100,9,-2):
l4.append(i)
if i % 4 != 0:
l4.remove(i)
print(l4)
100 96 92 88 84 80 76 72 68 64 60 56 52 48 44 40 36 32 28 24 20 16 12
Process finished with exit code 0
10、将1-30的数字一次添加到一个列表中，将能被3整除的数改成*
需求：将1-30的数字一次添加到一个列表中，并循环这个列表，将能被3整除的数改成*
l1=[]
for i in range(1,31):
if i % 3 == 0:
l1.append('*')
else:
l1.append(i)
print(l1)
[1, 2, '*', 4, 5, '*', 7, 8, '*', 10, 11, '*', 13, 14, '*', 16, 17, '*', 19, 20, '*', 22, 23, '*', 25, 26, '*', 28, 29, '*']
Process finished with exit code 0
11、移除列表中每个元素的空格，并找出以"A"或者"a"开头
需求：(1)、查找列表li中的元素，移除每个元素的空格，并找出以"A"或者"a"开头
(2)、并以"c"结尾的所有元素，并添加到一个新列表中,最后循环打印这个新列表。
li = ["TaiBai ", "alexC", "AbC ", "egon", " riTiAn", "WuSir", " aqc"]
l1=[]
for i in li:
j=i.strip()
if j[0]=='A' or j[0]=='a':
if j[-1]=='c':
l1.append(j)
print(l1)
['aqc']
Process finished with exit code 0
12、循环打印列表，如遇到列表则再循环打印出它里面的元素
需求：循环打印列表中的每个元素，遇到列表则再循环打印出它里面的元素
li = [1, 3, 4, "alex", [3, 7, 8, "TaiBai"], 5, "RiTiAn"]
for i in li:
if type(i)==list:
for j in i :
print(j,'',end='')
else:
print(i,'',end='')
1 3 4 alex 3 7 8 TaiBai 5 RiTiAn
Process finished with exit code 0
13、1-100以内数字求和
sum=0
for i in range(101):
sum=sum+i
i=i+1 #可以不写
print(sum)
5050
Process finished with exit code 0
14、1-100以内偶数，基数求和
#偶数求和
sum=0
for i in range(101):
if i % 2 ==0:
sum=sum+i
i=i+1 #可以不写
print(sum)
#奇数求和
sum=0
for i in range(101):
if i % 2 !=0:
sum=sum+i
i=i+1 #可以不写
print(sum)
2550
2500
Process finished with exit code 0
15、给定两个列表，A 和 B，找出相同元素和不同元素
#给定两个列表，A 和 B，找出相同元素和不同元素
list_A = [1, 2, 3, 4, 5]
list_B = [4, 5, 6, 7, 8]
list_C = [] #相同元素列表
list_D = [] #不同元素列表
for i in list_A:
if i in list_B:
list_C.append(i)
else:
list_D.append(i)
print(list_C)
for j in list_B:
if j not in list_A:
list_D.append(j)
print(list_D)
[4, 5]
[1, 2, 3, 6, 7, 8]
Process finished with exit code 0
16、合并列表[1,5,7,9]和[2,2,6,8]
#合并列表[1,5,7,9]和[2,2,6,8]
list_A = [1,5,7,9]
list_B = [2,2,6,8]
#方法1
list_C=list_A+list_B
print(list_C)
#方法2
list_A.extend(list_B)
print(list_A)
[1, 5, 7, 9, 2, 2, 6, 8]
[1, 5, 7, 9, 2, 2, 6, 8]
Process finished with exit code 0
17、合并列表 [1,2,3,4] 和 [2,3,4,5] ，并且除去重复的数值
list_A = [1,2,3,4]
list_B = [2,3,4,5]
list_C=list_A+list_B
a=set(list_C)
print(list(a))
[1, 2, 3, 4, 5]
Process finished with exit code 0
18、请写出打印结果
x = [0,1]
i = 0
i , x[i] = 1 , 2 #先看等号右边 等同于 x[1]=2
print(x)
[0, 2]
Process finished with exit code 0
19、is 和 == 的区别？
- 案例1：
a=[1,2,3]
b=a
print(a==b)
print(a is b)
print(id(a)) #1920472785736
print(id(b)) #1920472785736
True
True
Process finished with exit code 0
- 案例2
a=[1,2,3]
b=[1,2,3]
print(a==b)
print(a is b)
print(id(a)) #2103028425544
print(id(b)) #2103029253960
True
False
Process finished with exit code 0
20、输入某年某月某日，判断这一天是这一年的第几天？
分析：以3月5号为例，应该先把前两个月的加起来，然后在加上5天即本年的第几天，，特殊情况，闰年且输入月份大于2是需要考虑多加一天
year=int(input('year:\n'))
month=int(input('month:\n'))
day=int(input('day:\n'))
months=(0,31,59,90,120,151,181,212,243,273,304,334)
if 0< month <=12:
sum=months[month-1]
else:
print('data error')
sum=sum+day
leap=0
if (year%400==0) or (year%4 ==0) and (year%100!=0):
leap=1
if (leap==1)and(month>2):
sum=sum+1
print('it is the {} day'.format(sum))
21、有四个数字：1,2,3,4，能组成多少个互不相同且无重复数字的三位数？各是多少？
for i in range(1,5):
for j in range(1,5):
for k in range(1,5):
if (i !=k) and (i!=j) and (j!=k):
print(i,j,k)
二、字典：
1、将字典的键和值分别追加到两个列表中
需求：将字典的键和值分别追加到 key_list 和 value_list 两个列表中
key_list = []
value_list = []
info = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
for i in info.keys():
key_list.append(i)
print(key_list)
for j in info.values():
value_list.append(j)
print(value_list)
['k1', 'k2', 'k3']
['v1', 'v2', 'v3']
Process finished with exit code 0
考察知识点：
- 可以单独去遍历字典的键和值
2、请循环输出所有的key和value
dic = {'k1': "v1", "k2": "v2", "k3": [11, 22, 33]}
# c. 请循环输出所有的key和value
for key,value in dic.items():
print(key,value)
k1 v1
k2 v2
k3 [11, 22, 33]
Process finished with exit code 0
3、请循环打印字典中 键值(k2) 对应的值中的每个元素
info = {
'k1':'v1',
'k2':[('alex'),('wupeiqi'),('oldboy')],
}
for i in info.get('k2'):
print(i)
alex
wupeiqi
oldboy
Process finished with exit code 0
考察知识点：
字典可以通过dict.get(键) 来获取 对应的值
# 10写代码有如下值 li= [11,22,33,44,55,66,77,88,99,90] ,
# 将所有大于 66 的值保存至字典的第一个key对应的列表中，将小于 66 的值保存至第二个key对应的列表中。
li = [11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
dic = {}
result = {'k1':[],'k2':[]}
for i in li:
if i > 66:
result.get('k1').append(i)
elif i < 66:
result.get('k2').append(i)
print(result)
{'k1': [77, 88, 99, 90], 'k2': [11, 22, 33, 44, 55]}
Process finished with exit code 0
4、验证键或值，是否在某个字典中
需求：1、请用代码验证 "name" 是否在字典的键中？
2、请用代码验证 "alex" 是否在字典的值中？
# 1请用代码验证 "name" 是否在字典的键中？
info = {'name':'王刚蛋','hobby':'铁锤','age':'18'}
print("name" in info.keys())
# 2请用代码验证 "alex" 是否在字典的值中？
info = {'name':'王刚蛋','hobby':'铁锤','age':'18'}
print("alex" in info.values())
True
False
Process finished with exit code 0
5、吃包子（生成器）
需求1：老男孩向楼下卖包子的老板订购了5000个包子.包子铺老板非常实在，一下就全部都做出来了
def func():
l1=[]
for i in range(1,5001):
l1.append(f'{i}号包子')
return l1
ret=func()
print(ret)
需求2：这样做没有问题，但是我们由于学生没有那么多，只吃了2000个左右，剩下的8000个，就只能占着一定的空间，放在一边了。如果包子铺老板效率够高，我吃一个包子，你做一个包子，那么这就不会占用太多空间存储了，完美。（用生成器做）
def eat_func():
for i in range(1,5001):
yield f'{i}号包子'
ret=eat_func()
for i in range(200):
print(next(ret))
考察知识点：
生成器的使用，吃一个包子生产一个，非常的节省内存， 第一种是直接把包子全部做出来，占用内存。
三、函数：
1、man()函数的应用
需求1：用map来处理字符串列表,把列表中所有人都变成sb，比方alex_sb
name=['oldboy','alex','wusir']
ret = map(lambda x,:x + '_sb',name)
print(name)
print(ret)
print(list(ret))
['oldboy', 'alex', 'wusir']
<map object at 0x0000024750D69F60>
['oldboy_sb', 'alex_sb', 'wusir_sb']
Process finished with exit code 0
需求2：用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾
l = [{'name':'alex'},{'name':'y'}]
ret=map(lambda x:x['name'] + 'sb',l)
print(list(ret))
['alexsb', 'ysb']
Process finished with exit code 0
map(str,[1,2,3,4,5,6,7,8,9])输出是什么? (面试题)
- 列表中每个元素，原来是int，现在变成str
reg=map(str,[1,2,3,4,5,6,7,8,9])
print(list(reg))
['1', '2', '3', '4', '5', '6', '7', '8', '9']
Process finished with exit code 0
考察知识点
map()内置函数：
- 会根据提供的函数对指定的序列（可迭代对象）做映射，返回的结果保存在一个迭代器里面
2、写一个函数完成三次登录功能
需求：22.写一个函数完成三次登陆功能：
- 用户的用户名密码从一个文件register中取出。
- register文件包含多个用户名，密码，用户名密码通过|隔开，每个人的用户名密码占用文件中一行。
- 完成三次验证，三次验证不成功则登录失败，登录失败返回False。
- 登陆成功返回True。
- 第一种方法：
def get_user_pwd():
user_dict={}
with open('register', encoding='utf-8') as f:
for line in f:
line_list = line.strip().split('|')
user_dict[line_list[0].strip()]=line_list[1].strip()
return user_dict
def login():
u_dict=get_user_pwd()
count=1
while count < 4 :
username=input('请输入用户名').strip() # strip()去除首尾空格
password=input('请输入密码').strip()
if username in u_dict and password==u_dict[username]:
print('登录成功')
return True
else:
print('用户名或密码错误，请重新登录')
count =count+1
login()
- 第二种方法
def func():
for i in range(3):
username = input('请输入用户名：').strip()
password = input('请输入密码：').strip()
with open('register', encoding='utf-8') as f:
for line in f:
x, y = line.strip().split('|')
if username == x and password == y:
print('登录成功')
return True
else:
print('用户名或者密码错误，请重新登录')
return False
func()
3、再写一个函数完成注册功能
需求：
- 用户输入用户名密码注册。
- 注册时要验证（文件regsiter中）用户名是否存在，如果存在则让其重新输入用户名，如果不存在，则注册成功。
- 注册成功后，将注册成功的用户名，密码写入regsiter文件，并以 | 隔开。
- 注册成功后，返回True,否则返回False。
def func():
while 1:
dic = {}
username = input('请输入用户名：')
with open('register', encoding='utf-8', mode='r+') as f:
for line in f:
x, y = line.strip().split('|')
dic[x] = y
if username in dic:
print('用户名存在，请重新输入')
else:
password = input('请输入密码：')
f.write(f'{username}|{password}\n')
return True
func()
请输入用户名：大壮
用户名存在，请重新输入
请输入用户名：Mike
请输入密码：123
Process finished with exit code 0
- 或者
def re_gister():
name_list = []
with open('register',encoding='utf-8',mode='r+') as f1:
for i in f1:
old_name,old_password = i.strip().split('|')
name_list.append(old_name)
while 1:
new_name = input('请输入你需要注册的名字(q/Q)退出：').strip()
if new_name.upper() == 'Q': break
elif new_name not in name_list:
new_num = input('请输入密码：').strip()
info = '\n'+new_name + '|'+ new_num
f1.write(info)
else:
print('用户名已存在，请重新输入用户名！')
re_gister()
四、装饰器：
1、为函数写一个装饰器，把函数的返回值 +100 然后再返回
def wrapper(f):
def inner(*args,**kwargs):
ret=f(*args,**kwargs)+100
return ret
return inner
@wrapper
def func():
return 7
result=func()
print(result)
107
Process finished with exit code 0
25、请实现一个装饰器，通过一次调用使函数重复执行5次。
def wrapper(f):
def inner(*args,**kwargs):
for i in range(5):
ret=f(*args,**kwargs)
return ret
return inner
@wrapper
def func():
print(111)
func()
2、请实现一个装饰器，每次调用函数时，将函数名以及调用此函数的时间节点写入文件中。
import time
# struct_time = time.localtime()
# print(time.strftime("%Y-%m-%d %H:%M:%S",struct_time)) # 当前时间节点
def wrapper(a):
def inner(*args,**kwargs):
#函数名通过： 函数名.__name__获取。
ret=a(*args,**kwargs)
with open('a', mode='a', encoding='utf-8') as f:
struct_time = time.localtime()
f.write(f'{time.strftime("%Y-%m-%d %H:%M:%S", struct_time)}|{a.__name__}\n')
return ret
return inner
@wrapper
def func():
print(111)
func()
面试题总结：
(1)、python中 id 的使用方式及作用？
-----查看该数据（对象）的内存地址
在Python中，id是什么？id是内存地址，那就有人问了，什么是内存地址呢？ 你只要创建一个数据（对象）那么都会在内存中开辟一个空间，将这个数据临时加在到内存中，那么这个空间是有一个唯一标识的，就好比是身份证号，标识这个空间的叫做内存地址，也就是这个数据（对象）的id，那么你可以利用id（）去获取这个数据的内存地
# 10id的使用方式及作用？
i=100
s='anwen'
print(id(s))
2915525543280
Process finished with exit code 0
(2)、python 中 is 和 == 的区别？
-----is 判断内存地址是否相同。== 比较两边的值是否相等
== 是比较的两边的数值是否相等，而 is 是比较的两边的内存地址是否相等。 如果内存地址相等，那么这两边其实是指向同一个内存地址
(3)、简述深浅拷贝？
---浅copy ：在内存中开辟一个新的空间存放copy的对象（列表 字典） ，
但是里面的所有元素与被copy的对象的里面的元素是公用的
---深copy：内存中创建一个新列表，列表中可变的数据类型是重新创建的，
列表中的不可变的数据类型是公用的
(4)、用你的理解解释一下什么是可迭代对象，什么是迭代器？
---可迭代对象：就是能用for循环遍历的对象就是可迭代对象，内部含有 _ _ iter _ _ 方法的对象
目前学过的可迭代对象：str list tuple dic set range 文件句柄
---迭代器：迭代器可以看作是一个特殊的对象，每次调用该对象时会返回自身的下一个元素，
内部含有‘_ _ iter _ _ ’方法并且含有‘_ _ next_ _’方法的对象
(5)、如何判断一个对象是否是可迭代对象 ？
---通过dir()获取所有方法，如果内部含有'__iter__'方法，就是可迭代对象
l1=[1,2,3]
print(dir(l1))
print('__iter__' in dir(l1)) #打印结果True 就表示可迭代对象
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
True
Process finished with exit code 0
(6)、如何判断一个对象是否是迭代器？
---通过dir()获取所有方法，如果内部含有'__iter__'and '__next__'方法，的对象就是迭代器
#判断文件是否是迭代器
with open('文件1',encoding='utf-8',mode='w') as f1:
print(('__iter__' in dir(f1)) and ('__next__' in dir(f1)))
True
Process finished with exit code 0
(7)、可迭代对象如何转化成迭代器？
---通过'__iter__'方法zhuanghua
s1 = 'fjdag'
obj=iter(s1) #或者：s1.__iter__()
print('__next__' in dir(obj))
True
Process finished with exit code 0
(8)、迭代器如何取值 ？
---通过'__next__'方法取值，一个next 取一个值，多一个next 就会报错
s1 = 'python'
obj=iter(s1)
print(next(obj))
p
Process finished with exit code 0
(9)、要迭代器有什么用？或者说为什么要用迭代器？
---1.可节省内存空间
2.会从容器里面挨个取值，直到取完为止
- 当数据很大的时候，我要考虑如果把这些大批量数据存储起来，会很占用内存，需要节省内存，所以要考虑迭代器。
- 自己理解如何节省内存：比如定义一个列表，那根据内存机制，内存中开辟一个新的空间来保存这个列表中所有数据，即分配内存地址（即id)，如果把这个列表转换为迭代器，这时候next一次，取一个值，然后存储这个值。
(10)、解释下什么是生成器？生成器和迭代器的区别？
---生成器：在 Python 中，使用了 yield 的函数被称为生成器。
---唯一的区别：生成器是我们自己用python代码构建的数据结构。迭代器都是提供的，或者转化得来的
(11)、获取生成器的方式？(三种方式）
---1.生成器函数。
---2.生成器表达式。
---3.python内置函数或者模块提供。
(12)、如何用 生成器函数 获得生成器？
---将函数中的return换成yield，这样func就不是函数了，而是一个生成器函数
读取生成器的内容是，一个next 对应一个yield
#函数
# def func():
# print(111)
# print(222)
# return 3
#
# ret=func()
# print(ret)
#生成器
def func():
print(111)
print(222)
yield 3
yield 4
ret=func()
print(next(ret))
111
222
3
Process finished with exit code 0
(13)、return 和 yield 的区别？
---return：函数中只存在一个return结束函数，并且给函数的执行者返回值。
---yield：只要函数中有yield那么它就是生成器函数而不是函数了。生成器函数中可以存在多个yield，yield不会结束生成器函数，一个 yield对应一个next。
(14)、如何用 生成器表达式 获得生成器？
---生成器表达式和列表推导式的语法上一模一样,只是把[]换成()就行了。
#比如将十以内所有数的平方放到一个生成器表达式中
l11=(i for i in range(1,11))
print(l11)
print(next(l11))
print(next(l11))
<generator object <genexpr> at 0x00000264FE056048>
1
2
Process finished with exit code 0
(15)、如何理解python中万能参数(*args, **kwargs)？
急需要一种形参，可以接受所有的实参。
---万能参数： *args
函数定义时，*代表聚合。 他将所有的 位置参数 聚合成一个元组，赋值给了 args。
位置参数:有时也称必备参数，指的是必须按照正确的顺序将实际参数传到函数中，换句话说，调用函数时传入实际参数的数量和位置都必须和定义函数时保持一致。
---万能参数:**kwargs
函数的定义时： ** 将所有的 关键字参数 聚合到一个字典中，将这个字典赋值给了kwargs
关键字参数:指的是在调用具有参数默认值的函数时，使用参数的关键字来指定为哪个参数赋值
或理解：
用于函数调用，通过“键-值”形式加以指定。调用的时候有位置参数时，位置参数必须在关键字参数的前面
而(*args, **kwargs)可以接受任何类型的参数
#练习题：写一个函数：计算你传入函数的所有的数字的和。
# tu1=(1,2,3,4,5,6,7)
# count=0
# for i in tu1:
# count=count+i
# print(count)
def func(*args):
count = 0
for i in args:
count = count + i
return count
print(func(1,2,3,4,5,6,7))
28
Process finished with exit code 0
def func(**kwargs):
print(kwargs)
func(name='alex',age=73,sex='laddyboy')
{'name': 'alex', 'age': 73, 'sex': 'laddyboy'}
Process finished with exit code 0
def func(*args,**kwargs):
print(args)
print(kwargs)
func({'name': '太白'},{'age': 18})
print('*********')
func(**{'name': '太白'},**{'age': 18}) #等同于 func(name='太白',age=19) 一般关键字参数是通过“键-值”形式指定的
({'name': '太白'}, {'age': 18})
{}
*********
()
{'name': '太白', 'age': 18}
Process finished with exit code 0
(16)、形参角度的参数的顺序
---位置参数,*args,默认参数，仅限关键字参数，**kwargs
def func(a,b,*args,sex='男',c,**kwargs):
(17)、性能用什么工具做，聚合报告有什么内容
---JMeter
---1.存储文件，显示日志内容，配置测试结果文件中需要记录的内容
2.聚合报告列表：包括（请求脚本名称，平均值，50%，90%，95%，99%用户的响应时间，最大，最小响应时间，错误率，吞吐量， 结算数据，发送数据）
(18)、jemter中参数化的方式有几种？
---用户定义的变量，用户参数，CSV文件数据配置，函数助手
---计数器也可以完成参数化，效果类似于随机函数
(19)、jemter中2个接口怎么关联？
---我比较常用的是 正则表达式提取器 和 JSON提取器
比如说正则表达式提取cookie：先添加下正则表达式（设置包括正则表达式.*?，和引用名称)，在登录接口下添加正则表达式提取器，把 提取的cookie放在消息头管理器中，在把消息头管理器放在需要关联的接口里边。
比如说json提取器提取商品id：先添加下json提取器（设置包括json的提取路径和引用名称），然后在第一个接口下添加提取器，获取到 id后，第二个接口引用变量名放到对应的位置就行了（比如${id} 放在请求路径后面）
(20)、jemter中多线程之间怎么共享参数？
思路：创建两个线程组，第一个线程组里面的 “登陆接口” 中登陆成功后获取到的token，要作为第二个线程组的http请求头中的参数信息
---登录接口下添加json提取器，提取到token，在添加Bean Shell取样器（填写setProperty函数——将提取器提取出来的值设置成jmeter本身的内置属性，相当于全局变量），另外一个线程组使用property函数，将Jmeter属性值读取出来。
(21)、性能常见的调优方式有哪些？
---数据库SQL调优，设置慢查询时间，如果SQL语句执行速度大于慢查询时间，会通过日志打印出来。
程序的调优，框架或者代码是否可以优化
网络方方面的调优
其他的调优：cpu、内存，磁盘
(22)、redis的数据结构？
---字符串(String)，列表(List)，哈希(hash)，集合(Set)，有序集合(zset)
(23)、说下linux常用的命令？
cd命令：切换目录
pwd命令：查看当前的工作目录
ls-al命令：查看文件和目录的命令
rm命令：删除一个文件或者目录
cp命令：主要用于复制文件或目录
mv命令：移动文件或者改名
find命令：查找文件
tail命令：查看文件 （动态查看日志：tail - f xxx )
tar命令：打包
chmod命令：改变文件的权限
kill命令：用于终止程序的命令 (强制终止 kill -9)
ps命令：用来列出系统中当前运行的那些进程 (ps-ef 或者动态监控 top -d)
scp命令： 将数据或文件由本机传到远程主机上去
(24)、linux查看文件没权限怎么处理，怎么查看文件？
---先修改文件的查看权限 chomd 777 文件名
然后查看文件 cat 文件名
(25)、linux中某个端口号被占用要杀掉进程怎么处理？
---查看某个端口被占用情况 netstat -apn|grep 9904 (显示程序的pid --- netstat -apn)
或者 lsof -i:9904
---杀掉进程 kill -9 10768 (10768是 pid)
[root@hidata2 hiops-executor]# netstat -apn|grep 9904
tcp 0 0 :::9904 :::* LISTEN 10768/java
[root@hidata2 hiops-executor]# kill -9 10768
(26)、数据库的左连接右链接是什么?
---left join （左连接）：返回包括左表中的所有记录和右表中连接字段相等的记录
right join （右连接）：返回包括右表中的所有记录和左表中连接字段相等的记录。
(27)、索引是什么？索引的作用？怎么添加索引？、视图的作用?
---索引是一种特殊的数据库结构，由数据表中的一列或多列组合而成
索引优点：加快数据查询的速度
索引缺点：占用空间，影响数据更新的效率
创建索引：alter table 表名 add index 索引名
alter table t_dept add index index_name(name);
---视图是一张虚表，不存储数据，实质是一段编译好的SQL
视图的作用：简化了操作，把经常使用的数据定义为视图；
安全性，用户只能查询和修改能看到的数据；
(28)、接口自动化测试数据放在哪里？
1、对于一些一次性消耗的数据，比如注册，可以用随机函数生产
2、对于一个接口有多组测试数据，可以参数化或者ddt,数据放在json，CSV，yaml文件中，我一般放在json文件
3、对于可以反复使用的数据，比如说订单的各种状态需要造数据的情况，可以放到数据库里，每次数据初始化 后，用完可以删除。
4、对于一些动态变化的数据，比如token，可以在配置文件conf中，定义一个全局变量，默认值设置none，然后登 录成功的用例脚本下获取token赋值给这个变量
5，对于一些用例，可能需要配置一些参数，可以用inip配置文件
(29)、如何用Fiddler设置断点
- 进入添加会员的页面，填写正确的手机号码和其他信息
- 设置拦截开关，在 rules (入s) ==》Automatic Breakpoints（欧t ma 太 k -不睿k 泡 in s ） ==》 Before Requests 或者 after responsees
- 回到添加会员界面，点击提交按钮
- 回到Fiddler，修改【请求体】，如修改手机号码内容
- 点击Fiddler中请求下方的绿色按钮“Run to Completion” （看 play 新）
- 关闭Fiddler拦截开关：Rules ==》 Automatic Breakpoints ==》 Disabled
(30)、如何用Fiddler做弱网测试
- 打开Fiddler，设置代理，并允许远程连接
- 手机连接电脑的热点网络，或者同在一个局域网内
-
打开网速模拟模式开关 Rules → Performances(pf门 谁s) → Simulate Modem Speeds (谁米 累t ,谋东,时bs )
-
浏览器访问网络，观察功能响应或者页面刷新速度
-
如果需要自定义网络的速度，需要到自定义规则中配置（Rules → Customize Rules）靠st mai zi
(31)、git使用流程
-
基础操作
-
0.克隆代码： git clone url
-
1.初始化，建立本地版本库
- git init
- 说明：直接clone远程仓库时，不需要在init
-
2.查看版本库状态： git status
-
3.将修改提交至暂存区: git add 文件名
-
4.将修改提交至Git库: git commit -m "提示消息"
-
5.拉取远程仓库: git pull
-
6.推送远程仓库: git push
-
(32)、基于代码实现持续集成
操作步骤：
-
本地提交代码到git仓库
-
创建Jenkins任务并进行设置
（新增一个构建任务，下载插件，进行任务设置，复制github上项目库地址，选择GitHub账号，设置构建命令）
(33)、Python 列表、元组、字典、集合区别？
1、列表
- 特点：
- 列表内元素的个数和元素的值都可以改变；
- 列表可以进行插入、删除、排序、修改操作；
列表于元组的区别：列表内的值是可以修改的，元组不能修改；列表是可变类型而元组是不可变类型
列表与字典区别：列表存储值，而字典存储键值对；列表是有序序列而字典是无序序列
列表与集合区别： 列表是有序序列，集合是无序序列；列表内可以存储重复数据，集合内不能存储重复数据
2、元组
-
特点：
- 元组中的元素不可修改
-
元组与字典区别：元组是不可变类型，字典式可变类型；元组是有序序列，字典是无序序列；元组值不可以更改，字典的值是可以更改的；
-
元组与集合区别：元组是不可变类型，集合是可变类型，元组是有序序列，集合是无序序列；元组存储的值可以重复，集合存储的值不能重复
3、字典
- 特点：
- 键必须是唯一的，但值则可以是任意类型数据，键只能是不可变的，如字符串和数字
- 字典与集合区别：字典存储的值可重复，集合存储的值是不可重复；
4、集合
-
特点：
- 存储类似字典中键的值，不存储value；存储的元素在set中会被自动过滤；
- 是一个无序的不重复元素序列
(34)、python 字典与json的区别？
- json：是一种数据格式，是纯字符串。可以被解析成python的dict或其他形式。
- dict：是一个完整的数据结构，是对hash table这一数据结构的实现，是一套从存储到提取都封装好的方案。它使用内置的hash函数来规划key对应的value的存储位置，从而获得O(1)的数据读取速度。
字典于json的区别：
1）json的key只能是字符串，dict的key可以是任何可hash的对象，例如：字符串、数字、元组等。
2）json的key可以是有序、重复的；dict的key不可重复；
3）json的value只能是字符串、浮点数、布尔值或者null,或者它们构成的数组或者对象；
4）json任意key存在默认值undefined,dict默认没有默认值；
5）json访问方式可以是[],也可以是.,遍历方式分in，of； dict的value仅仅可以下标访问；
6）json的字符串强制用双引号，dict的字符串可以用单引号、双引号；
7）dict可以嵌套tuple,json里只有数组
8）json：true、false、null
9）dict：True、False、None
10）json中文必须是unicode编码，如“\u6211”
11）json的类型时字符串，字典的类型是dict
标签：__,面试题,code,python,list,列表,--,finished,print From： https://www.cnblogs.com/wushaofan/p/17156736.html