Python基础-月考

1. 8<<2等于？

 #
 # 解释：将8按位左移2位
 # 8    0 0 0 0  1 0 0 0
 # 32  0 0 1 0  0 0 0 0

2. 通过内置函数计算5除以2的余数

 print(divmod(5, 2)[1])

 #(2, 1)  2 = 5 // 2; 1 = 5 % 2

3. s=[1,"h",2,"e",[1,2,3],"l",(4,5),"l",{1:"111"},"o"],将s中的5个字符提取出来并拼接成字符串

 s = [1, "h", 2, "e", [1, 2, 3], "l", (4, 5), "l", {1: ""}, "o"]
 s_g = filter(lambda x: type(x) is str, s)   #由于int类型非可迭代对象，先使用filter过滤掉
 s_new = ''  #拼接字符串变量
 for i in s_g:
     s_new += i
 print(s_new)

#方法2
1 s = [1, "h", 2, "e", [1, 2, 3], "l", (4, 5), "l", {1: ""}, "o"]

 print(''.join([i for i in s if type(i) == str]))

4. 判断"yuan"是否在[123,(1,"yuan"),{"yuan":"handsome"},"yuanhao"],如何判断以及对应结果？

 l = [123, (1, "yuan"), {"yuan": "handsome"}, "yuanhao"]
 l_yuan = str(l)     #将列表转换为字符串
 if 'yuan' in l_yuan:
     print('True')

#方法2 
 1 l =[123, (1, "yuan"), {"yuan": "handsome"}, "yuanhao"]
 def func(l):
     if 'yuan' in l:
         print(l)
     for i in l:
         if type(i) == tuple or type(i) == list:
             func(i)
         if type(i) == dict:
             func(i.keys())
             func(i.values())

 func(l)

 #运行结果
 #(1, 'yuan')
 #dict_keys(['yuan'])

5. 执行结果并解释为什么？

l=[1,2,3]

l2=l.insert(3,"hello")

print(l2)

 执行结果：None
 解释：‘.insert’方法的返回值为‘None’

6. 计算结果以及为什么？

a=[1,2,[3,"hello"],{"egon":"aigan"}]

b=a[:]

a[0]=5

a[2][0]=666

print(a)

print(b)

 a = [1,2,[3,"hello"],{"egon":"aigan"}]
 b = a[:]    #列表b和列表a相同

 a[0] = 5    #将列表a中的第一个元素‘1’变为‘5’
 a[2][0] = 666   #将列表a中的第3个元素‘[3,"hello"]’（同样为列表）的第1个元素变为‘666’

 print(a)    #打印更改后的列表a
 print(b)    #打印列表b，就是列表a更改前的元素

 #执行结果：  [5, 2, [666, 'hello'], {'egon': 'aigan'}]
 #          [1, 2, [666, 'hello'], {'egon': 'aigan'}]

7. 使用文件读取，找出文件中最长的行的长度（用一行代码解决）？

 print(max([len(x) for x in open('test.py', encoding='utf-8')]))    #bug：open文件的次数与for循环一致

#方法2
1 f = open('test.py', encoding='utf-8')        #假设文件已经打开
 print(max([len(i) for i in f]))

 #方法3
 f = open('test.py', encoding='utf-8')

 from functools import reduce

 print(reduce(lambda a, b: a if a > b else b, (len(i) for i in f)))

8. 分析结果

def add(s, x):

return s + x

def generator():

for i in range(4):

yield i

base = generator()

for n in [1, 11]:

base = (add(i, n) for i in base)

print(list(base))

 #结果：[22, 23, 24 ,25]
 #解释：
 #这个可以以管道的思路来理解，首先generator()函数是第一个生成器,下一个是第一次循环的base = (add(i, n) for i in base),
 # 最后一个生成器是第二次循环的base = (add(i, n) for i in base)。 这样就相当于三个管道依次连接,但是水(数据)还没有流过，
 # 现在到了list(base),就相当于驱动器，打开了水的开关，这时候，按照管道的顺序，由第一个产生一个数据，yield 0,
 # 然后第一个管道关闭。 之后传递给第二个管道就是第一次循环,此时执行了add(0, 11),然后水继续流，
 # 到第二次循环，再执行add(11, 11),此时到管道尾巴了，第一个数据22就产生了。此时第一个管道再开放yield 1,　
 # 流程跟上面的一样。依次产生23,24,25; 直到没有数据。 把代码改一下容易理解:
 #由于在打开驱动器（list（base））之前，for循环已经走完了，循环体可以表示为：base = (add(i, n) for i in (add(i, n) for i in base))，所以，最终n=11
 def generator():
     for i in range(4):
         yield i     #第1个管道

 base = (add(i, n) for i in base)    #第2个管道
 base = (add(i, n) for i in base)    #第3个管道

 list(base)      #开关驱动器

参考：python迭代器与生成器小结

9. 如果用py2，py3下在cmd下运行会报错吗？为什么并提出解决方案？ （编码）

test.py (gbk方式保存)：

#coding:GBK

print(“老男孩”)

扩展，但是在python2.x解释器中，会显式乱码，python3.x下正常显式，是因为解释器自动帮我们解码了文件内容：

10. 通过函数化编程实现5的阶乘

 def fn(n):
     x = 1
     if n == 0:    #0的阶乘为1
         x
     else:
         for i in range(1, n+1):
             x *= i
     return x

 print(fn(5))

 #方法2：递归
 def func(n):
     if n == 0 or n == 1:
         return 1
     return n * func(n-1)

 print(func(5))

11. 打印如下图案：

　　　　 *

*＊*

**＊**

****＊**

**＊**

*＊*

*

 def print_star(n):    #n必须为奇数，此程序没有做判断
     s = '*'
     i = 1   #上部分，包含对称行
     j = n   #下部分
     while i < n and i % 2 != 0:
         print((s * i).center(n))
         i += 2
     while j > 0 and j % 2 != 0:
         print((s * j).center(n))
         j -= 2

 print_star(7)

12

def outer():
　　count = 10
　　def inner():
　　　　count = 20
　　　　print(count)
　　　　return count
　　inner()
　　print(count)

outer()

(1). 分析运行结果？

 运行结果：20
         10
 分析：当调用函数outer时，按顺序读函数定义部分，outer函数内部嵌套定义了inner函数，
 读完inner函数的定义，首先调用了inner()，此时inner函数局部变量count为20，故先打印了20，然后打印了outer函数内部变量10

(2).如何让两个打印都是20

 #方法1：将inner函数内部的count变量删除，将outer函数下的count变量赋值为20即可
 def outer():
     count = 20
     def inner():
         print(count)
         return count
     inner()
     print(count)

 outer()

 #方法2：将inner函数内部变量count = 20返回给外部函数outer的变量count
 def outer():
     def inner():
         count = 20
         print(count)
         return count
     count = inner()
     print(count)
 outer()

13. 输入一个年份，判断是否是闰年？

 #闰年:四年一润，百年不润，四百年再润
 def leap_year(y):
     if y % 100 == 0:
         if y % 400 == 0:
             print('leap year')
         else:
             print('not leap year')
     elif y % 4 == 0:
         print('leap year')
     else:
         print('not leap year')

 leap_year(2000)

 #方法2
 judge = lambda year: True if (year %  ==  and year %  != ) or year %  ==  else False
 print(judge())

14. 任意输入三个数，判断大小？

 def max_three(x, y, z):
     return max(max(x, y),z)

 print(max_three(1,2,3))

15. 求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222,几个数相加以及a的值由键盘控制。

 def sum_new(a, n):      #a代表求和的数字，n代表相加的次数
     sum = 0
     a = str(a)
     for i in range(1, n+1):
         x = int(a * i)
         sum += x
     return sum

 print(sum_new(2,3))

16. 请问程序有无bug，怎么解决？

 f=open("a")
 while 1:
     choice=input("是否显示:[Y/N]:")
     if choice.upper()=="Y":
         for i in f:
             print(i)
     else:
         break

 #有bug，
 # 1，只要用户输入非‘y/Y’字符，程序都会结束，这与提示信息不符合
 # 2. ‘y/Y’只一次有效，如果用户想再次查看文件内容，必须得重启程序
 #解决方法：
 f = open("a")
 while 1:
     choice=input("是否显示:[Y/N]:")
     if choice.upper() == "Y":
         for i in f:
             print(i)
         f.seek(0)　　#重置文件位置于文首
     elif choice.upper() == "N":　　#严格要求用户必须输入‘n/N’方可退出程序
         break

17.

 def foo():
     print('hello foo')
     return()
 def bar():
     print('hello bar')

(1). 为这些基础函数加一个装饰器，执行对应函数内容后，将当前时间写入一个文件做一个日志记录。

 def timer(func):
     def wrapper():
         import time
         res = func()
         f = open('log', 'a+')   #以追加的方式打开文件，没有则会创建
         s = time.asctime()      #获取当前时间：Tue Apr 18 21:46:18 2017
         f.write(s + '\n')       #将当前时间写入log文件，并换行
         f.close()               #关闭log文件
         return res
     return wrapper

 @timer
 def foo():
     print('hello foo')
     return ()
 @timer
 def bar():
     print('hello bar')

 foo()

 bar()

(2). 改成参数装饰器，即可以根据调用时传的参数决定是否记录时间，比如@logger(True)

 def logger(choice):
     def timmer(func):
         def wrapper():
             import time
             if choice == True:
                 res = func()
                 f = open('log', 'a+')   #以追加的方式打开文件，没有则会创建
                 s = time.asctime()      #获取当前时间：Tue Apr 18 21:46:18 2017
                 f.write(s + '\n')       #将当前时间写入log文件，并换行
                 f.close()               #关闭log文件
                 return res
             else:
                 pass
         return wrapper
     return timmer

 @logger(True)
 def foo():
     print('hello foo')
     return ()
 @logger(True)
 def bar():
     print('hello bar')

 foo()

 bar()

18. 三次登陆锁定：要求一个用户名密码输入密码错误次数超过三次锁定？

 with open('account',encoding='utf8') as f_account, open('lockedlist', 'a+') as f_locked:
     l = []                  #定义用户名验证列表，存放黑名单数据
     f_locked.seek(0)        #"a+"模式打开后，文件位置位于末尾，要遍历文件内容，需要将指针移至文件起始位置
     for locked_info in f_locked.readlines():    #遍历黑名单
         l.append(locked_info.strip())                   #将黑名单数据添加进列表,注意：需要将文件中的换行符脱掉

     c = []                  #定义用户登录名列表，存储用户尝试的登录名
     count = 1               #登陆次数计数器
     flag = True             #登陆循环控制开关
     while flag and count < 4:
         user = input('Please input username:')      #输入用户名
         pwd = input('Please input password:')       #输入用户密码
         if user in l:                 #用户名在黑名单中
             print("This user is in blacklist,can't log in!")    #打印提示信息
             continue
         c.append(user)
         for info in f_account:                  #用户名不在黑名单中，遍历用户登陆文件
             user_name, user_pwd = info.strip().split(',')       #将文件中的用户名和登陆密码赋值给判定变量
             if user == user_name:               #用户名符合
                 if pwd == user_pwd:             #对应密码符合
                     print('Welcome %s' % user)  #打印登陆成功信息
                     flag = False               #登陆成功，跳出登陆程序
                     break
                 count += 1                      #对应密码不符合，while循环计数器加1
                 break
             count += 1                          #用户名不符合，while循环计数器加1
             break
     if count == 4:                              #如果不同用户名密码输错3次，关闭程序
         print('More than 3 times wrong!')       #打印提示信息
     if len(c) == 3 and c[0] == c[1] == c[2]:    #如果相同用户名密码输错3次，将该用户名加入黑名单，限制登陆
         print('This user has been locked!')
         f_locked.write(user+'\n')               #将错误3次的用户名写入黑名单，注意，加换行符