python 全栈开发，Day43(python全栈11期月考题)

python全栈11期月考题

1、常用字符串格式化有哪些?并说明他们的区别
2、请手写一个单例模式（面试题）
3、利用 python 打印前一天的本地时间，格式为‘2018-01-30’（面试题）
4、python 中 search()和 match()的区别(面试题)
5、写一个闭包函数 clo，接收整数参数 n ，返回一个函数 foo，foo 函数的功能是把 foo 参数和 n 相乘并把结果返回。
6、# 取出 html 中的歌手名和歌名
提示：<a href="/2.mp3" singer="任贤齐">沧海一声笑</a>
html = '''<div id="songs-list">
 <h2 class="title">经典老歌</h2>
 <p class="introduction">
 经典老歌列表
 </p>
 <ul id="list" class="list-group">
 <li data-view="2">一路上有你</li>
 <li data-view="7">
 <a href="/2.mp3" singer="任贤齐">沧海一声笑</a>
 </li>
 <li data-view="4" class="active">
 <a href="/3.mp3" singer="齐秦">往事随风</a>
 </li>
 <li data-view="6"><a href="/4.mp3" singer="beyond">光辉岁月</a></li>
 <li data-view="5"><a href="/5.mp3" singer="陈慧琳">记事本</a></li>
 <li data-view="5">
 <a href="/6.mp3" singer="邓丽君">但愿人长久</a>
 </li>
 </ul>
</div>'''
7、请写出函数式编程 filter、map 的实例。
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]过滤出列表的所有奇数(filter)
[1,2,3,4,5]计算出每个元素的平方(map)
8、简述 Python 垃圾回收机制
9、用最简洁的方式生成这样一个列表【4，16，32，64，128】
10、简述 python GIL 的概念， 以及它对 python 多线程的影响?。
11、写一段程序逐行读取一个文本，并在屏幕上输出
12、如何用 Python 删除一个文件,创建一个文件夹
13、什么是”并发“？什么是”并行“？
14、描述 Event 的执行机制
15、什么是粘包，如何避免？
16、叙述 TCP、UDP 的区别
17、叙述 OSI 七层协议是什么，三次握手，四次挥手分别是什么
18、简述你对管道、队列的理解；
19、编程题；写一个装饰器实现功能:打印程序的运行时间
20、写一个简单的 Python socket 服务端和客户端
21、使用 python 简单实现打印九九乘法表
优化版：使用一行代码实现九九乘法表
22、 请找出以下代码的问题。提示：5 处
#Python3 环境
class dummyclass(object):
    def __init__(self):
        self.is_d = True
        pass

class childdummyclass(dummyclass):
    def __init__(self, isman):
        self.isman = isman

    @classmethod
    def can_speak(self): return True

    @property
    def man(self): return self.isman

if __name__ == "__main__":
    object = new childdummyclass(True)
    print object.can_speak()
    print object.man()
    print object.is_d
    
23、爬虫程序中有如下代理池，请随机选择一个代理。
PROXIES = [
 {'ip_port': '111,11,221,32:80', 'user_pass': ''},
 {'ip_port': '12.75.44.55:8120', 'user_pass': ''},
 {'ip_port': '64.34.11.22:3330', 'user_pass': ''},
 {'ip_port': '64.23.4.11:1025', 'user_pass': ''},
 {'ip_port': '55.31.121.11:80', 'user_pass': ''},
]
24、编写程序输入一个字符串，返回倒叙的结果，如:’abcdef’，返回’fedcba’
25、编程题
"""
一：定义一个学生类。有下面的类属性：
1 姓名
2 年龄
3 成绩（语文，数学，英语)[每课成绩的类型为整数]
类方法：
1 获取学生的姓名：get_name() 返回类型:str
2 获取学生的年龄：get_age() 返回类型:int
3 返回 3 门科目中最高的分数。get_course() 返回类型:int
写好类以后，可以定义 2 个同学测试下:
zm = Student('zhangming',20,[69,88,100])
返回结果：
zhangming
20
100
"""
26、描述多进程开发中 join 与 daemon。
27、什么是异步，什么是异步阻塞?
28、写一个程序，包含十个线程，子线程必须等待主线程 sleep 10 秒钟之后才执行，并打印当前时间
29、请解释以下代码的输出结果。
z = [lambda x:x*i for i in range(3)]
x = [o(2) for o in z]
print x
30、写出程序，实现 socket 聊天并发实例，包含服务端、客户端
31、叙述进程、线程、协程的区别
32、
class Foo:
 country = '中国'
 print(country)

 def __init__(self,name,country):
 self.name = name
 self.country = country

alex = Foo('alex','印度')
Foo.country = '泰国'
print(Foo.country)
print(alex.country)
说出打印顺序和内容，并解释原因

 

答案：

1、常用字符串格式化有哪些?并说明他们的区别

1.%s  表示一个字符串占位符,%d表示一个数字
举例：
name = 'alex'
print('%s 在北京'%name)

2.format() 使用格式化函数,{}表示一个占位符
举例：
name = 'alex'
print('{} 在北京'.format(name))


2、请手写一个单例模式（面试题）

class B:
    __instance = None

    def __new__(cls, *args, **kwargs):  # cls表示类
        if cls.__instance is None:  # 判断类变量__instance是否为None
            obj = object.__new__(cls)  # 创建一个实例对象
            cls.__instance = obj  # 赋值
        return cls.__instance  # 返回私有静态属性


a = B()
b = B()
print(a)
print(b)

3、利用 python 打印前一天的本地时间，格式为‘2018-01-30’（面试题）

import datetime
now = datetime.datetime.now()
d2 = now - datetime.timedelta(days=1)
print(d2.strftime("%Y-%m-%d"))

4、python 中 search()和 match()的区别(面试题)
search() 从整个文本中去搜索,结果只会返回一次。如果有多个结果，只会返回第一个结果
match() 从左到右进行匹配,返回结果


5、写一个闭包函数 clo，接收整数参数 n ，返回一个函数 foo，foo 函数的功能是把 foo 参数和 n 相乘并把结果返回。

def clo(n):
    number = n
    def foo(m):
        nonlocal number
        ret = m * number
        return ret
    return foo

n = 3
m = 4
ret = clo(n)
print(ret(m))


6、# 取出 html 中的歌手名和歌名
提示：<a href="/2.mp3" singer="任贤齐">沧海一声笑</a>
html = '''<div id="songs-list">
 <h2 class="title">经典老歌</h2>
 <p class="introduction">
 经典老歌列表
 </p>
 <ul id="list" class="list-group">
 <li data-view="2">一路上有你</li>
 <li data-view="7">
 <a href="/2.mp3" singer="任贤齐">沧海一声笑</a>
 </li>
 <li data-view="4" class="active">
 <a href="/3.mp3" singer="齐秦">往事随风</a>
 </li>
 <li data-view="6"><a href="/4.mp3" singer="beyond">光辉岁月</a></li>
 <li data-view="5"><a href="/5.mp3" singer="陈慧琳">记事本</a></li>
 <li data-view="5">
 <a href="/6.mp3" singer="邓丽君">但愿人长久</a>
 </li>
 </ul>
</div>'''

import re
ret = re.findall('singer=(.*?)>(.*?)<',html)
print(ret)

7、请写出函数式编程 filter、map 的实例。
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]过滤出列表的所有奇数(filter)

li = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
li_new = []
ret = filter(lambda x:x%2 !=1,li)
#print(ret)
for i in ret:
    li_new.append(i)
    #print(i)
print(li_new)

[1,2,3,4,5]计算出每个元素的平方(map)

li_2 = [1,2,3,4,5]
ret = map(lambda x:x**2,li_2)
#print(ret)
li_2_new = []

for i in ret:
    li_2_new.append(i)
    #print(i)
print(li_2_new)

8、简述 Python 垃圾回收机制

当一个变量在指定时间里面，如果没有被调用或者修改。那么python就会销毁这个变量，节约内存。

9、用最简洁的方式生成这样一个列表【4，16，32，64，128】

li_1 = [2]
li_2 = [i for i in range(4,8)]
li_3 = li_1+li_2
li = []
for i in li_3:
    li.append(2**i)
print(li)

10、简述 python GIL 的概念， 以及它对 python 多线程的影响?。

GIL是python解释器全局锁。针对一个进程中，有多个线程时，同一时间，只能有一个线程访问CPU
在多线程中会影响执行效率，为了避免这种问题，需要采用多进程。

11、写一段程序逐行读取一个文本，并在屏幕上输出

with open('gequ',encoding='utf-8') as f:
    for i in f:
        print(i)

12、如何用 Python 删除一个文件,创建一个文件夹

删除文件  os.remove()
创建文件夹 os.mkdir()

13、什么是”并发“？什么是”并行“？

并发是在一段时间内执行的
并行是在同一时刻执行的

14、描述 Event 的执行机制

事件用于主线程控制其他线程的执行
当状态为True，wait方法下面的代码直接执行，当状态为False,wait方法下面的代码就会阻塞

15、什么是粘包，如何避免？

当数据太大,一次性发不完时，就会出现粘包

指定一个协议，包含数据总大小以及每次接收的大小。客户端根据接收大小来接收
当最终接受的数据达到数据总大小就停止

16、叙述 TCP、UDP 的区别

1. TCP是面向连接、可靠的字节流服务
UDP是面向数据包的
2. TCP可靠传输,UDP是不可靠的
3. TCP 连接时，双方之间必须建立一个TCP连接
UDP 双方不需要建立一个连接


17、叙述 OSI 七层协议是什么，三次握手，四次挥手分别是什么
七层协议： 应用层、表示层、会话层、传输层、网络层、数据链路层、物理层
三次握手：
第一次，客户端向服务器发送seq请求,
第二次，服务器收到seq请求，并发送seq+1数据包，再发送ack确认包
第三次,客户端收到ack+1数据包

四次挥手：
第一次：客户端发送fin数据包,表示断开
第二次：服务器收到fin数据包,回复fin+1，表示收到了
第三次：服务器发送fin，表示断开
第四次：客户端收到fin+1，断开连接。

18、简述你对管道、队列的理解；
管道： 支持双向通信，在进程之间通信的工具
队列：它是一个容器，内置了锁来保证队列中的每一个数据都不会被多个进程重复取

19、编程题；写一个装饰器实现功能:打印程序的运行时间

import time
def timmer(f):
    def inner(*args,**kwargs):
        start_time = time.time()
        ret = f(*args,**kwargs)
        end_time = time.time()
        print('函数运行花费了%s'%(end_time-start_time))
        return ret
    return inner

@timmer
def func():
    time.sleep(1)
    return 11

ret = func()
print(ret)

20、写一个简单的 Python socket 服务端和客户端
服务端：
import socket
sk = socket.socket()
sk.bind(('127.0.0.1',9000))
sk.listen()

conn, addr = sk.accept()
msg = conn.recv(1024).decode('utf-8')

print('收到一条消息:%s'%msg)

客户端：
import socket

sk = socket.socket()
sk.connect(('127.0.0.1', 9000))

sk.send('hello'.encode('utf-8'))
ret = sk.recv(1024).decode('utf-8')
print('收到一条消息%s'%ret)
sk.close()

21、使用 python 简单实现打印九九乘法表
优化版：使用一行代码实现九九乘法表

for i in range(1, 10):
    for j in range(1, i + 1):
        print('{}x{}={}\t'.format(j, i, i * j), end='')
    print('\n')

22、 请找出以下代码的问题。提示：5 处
#Python3 环境
class dummyclass(object):
    def __init__(self):
        self.is_d = True
        pass

class childdummyclass(dummyclass):
    def __init__(self, isman):
        self.isman = isman

    @classmethod
    def can_speak(self): return True

    @property
    def man(self): return self.isman

if __name__ == "__main__":
    object = new childdummyclass(True)  # 第一处,实例化语法不对
    print object.can_speak()  # 第二处,print语法不对
    print object.man()  # 第三处,print语法不对。第四处,调用man,不需要加括号。正确的应该是object.man
    print object.is_d  # 第五处,print语法不对

23、爬虫程序中有如下代理池，请随机选择一个代理。
PROXIES = [
 {'ip_port': '111,11,221,32:80', 'user_pass': ''},
 {'ip_port': '12.75.44.55:8120', 'user_pass': ''},
 {'ip_port': '64.34.11.22:3330', 'user_pass': ''},
 {'ip_port': '64.23.4.11:1025', 'user_pass': ''},
 {'ip_port': '55.31.121.11:80', 'user_pass': ''},
]

代码如下:
import random
PROXIES = [
 {'ip_port': '111,11,221,32:80', 'user_pass': ''},
 {'ip_port': '12.75.44.55:8120', 'user_pass': ''},
 {'ip_port': '64.34.11.22:3330', 'user_pass': ''},
 {'ip_port': '64.23.4.11:1025', 'user_pass': ''},
 {'ip_port': '55.31.121.11:80', 'user_pass': ''},
]
print(PROXIES[random.randint(0,len(PROXIES)-1)])


24、编写程序输入一个字符串，返回倒叙的结果，如:’abcdef’，返回’fedcba’


str1 = 'abcdef'
li = list(str1)
li.reverse()  # 翻转
#print(li)
str2 = ''.join(li)
print(str2)


25、编程题
"""
一：定义一个学生类。有下面的类属性：
1 姓名
2 年龄
3 成绩（语文，数学，英语)[每课成绩的类型为整数]
类方法：
1 获取学生的姓名：get_name() 返回类型:str
2 获取学生的年龄：get_age() 返回类型:int
3 返回 3 门科目中最高的分数。get_course() 返回类型:int
写好类以后，可以定义 2 个同学测试下:
zm = Student('zhangming',20,[69,88,100])
返回结果：
zhangming
20
100
"""

class Student(object):
    def __init__(self,name,age,score):
        self.name = name
        self.age = age
        self.score = score

    def get_name(self):
        return self.name
    def get_age(self):
        return int(self.age)
    def get_course(self):
        return max(self.score)

zm = Student('zhangming',20,[69,88,100])
print(zm.get_name())
print(zm.get_age())
print(zm.get_course())

26、描述多进程开发中 join 与 daemon。

join 主线程等待子进程执行完
daemon 表示守护进程，它会随着主进程的结束而结束。

27、什么是异步，什么是异步阻塞?

异步：是不需要等待被依赖的任务完成
异步阻塞： 异步执行时,它依赖一个消息通知，才能执行下一步

28、写一个程序，包含十个线程，子线程必须等待主线程 sleep 10 秒钟之后才执行，并打印当前时间

import time
from threading import Thread

def func():
    print(111)

if __name__ == '__main__':
    print('执行之前',time.strftime('%Y-%m-%d %H:%I:%S'))
    time.sleep(10)
    t_lst = []
    for i in range(10):
        t = Thread(target=func)
        t.start()
        t_lst.append(t)
    for th in t_lst:th.join()
    print('执行之后', time.strftime('%Y-%m-%d %H:%I:%S'))

29、请解释以下代码的输出结果。
z = [lambda x:x*i for i in range(3)]
x = [o(2) for o in z]
print(x)

输出结果为:[4,4,4]
解释：
首先执行：
z = [lambda x:x*i for i in range(3)]
它内部执行了3次，因为range(3)，表示3个数字，分别是0,1,2
第一次i=0，第二次i=1，第三次i=2
最终i=2
所以z是一个列表，列表的每一个元素都是lambda函数,也就是lambda x:x*2
类始于函数
def func(x):
    return x*2

再执行下面这句：
x = [o(2) for o in z]

o(2) 表示给lamba函数传参，参数为2
for o in z 表示遍历z列表，由于列表一个元素都是lambda函数
执行lambda函数时，x为2。相当于执行func函数,return 2*2，所以结果为4
由于z有3个元素，所以执行了3次
那么最终结果为[4,4,4]


30、写出程序，实现 socket 聊天并发实例，包含服务端、客户端

服务端：
import socket
from threading import Thread

sk=socket.socket()
sk.bind(('127.0.0.1',9898))
sk.listen(5)

def action(conn,addr):
    while True:
        data=conn.recv(1024).decode('utf-8')
        print(data)
        conn.send('{}{}{}'.format('server->',addr,data).encode('utf-8'))

if __name__ == '__main__':
    while True:
        conn,addr=sk.accept()
        p=Thread(target=action,args=(conn,addr))
        p.start()

客户端：
import socket

sk=socket.socket()
sk.connect(('127.0.0.1',9898))

while True:
    msg=input('>>: ').strip()
    if not msg:continue

    sk.send('{}{}'.format('client:',msg).encode('utf-8'))
    data=sk.recv(1024).decode('utf-8')
    print(data)

31、叙述进程、线程、协程的区别

将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程

进程是资源分配的最小单位,
线程是CPU调度的最小单位.
每一个进程中至少有一个线程

线程是轻量级的进程
线程的创建和销毁所需要的时间开销都非常小
线程直接使用进程的内存
线程不能独立存在，要依赖于进程

进程是是CPU的
协程比线程更轻量级
协程是线程的一部分
在一个线程中可以开启很多协程
在执行过程中，遇到I/O操作就冻结当前位置

32、
class Foo:
    country = '中国'
    print(country)

    def __init__(self,name,country):
        self.name = name
        self.country = country

alex = Foo('alex','印度')
Foo.country = '泰国'
print(Foo.country)
print(alex.country)

说出打印顺序和内容，并解释原因

输出内容为：
中国
泰国
印度

1.在实例化时，输出中国
2.Foo.country = '泰国'修改了类的静态属性。
print(Foo.country)执行，输出泰国
3.print(alex.country),表示从alex对象中查找country属性。
由于在实例化时,alex对象的属性已经有了country,所以输出 印度

　　

第29题讲解：

z = [lambda x:x*i for i in range(3)]
x = [o(2) for o in z]
print(x)

先来讲一个概念

生成器表达式和列表推导式的区别：
　　生成器表达式是要一个值计算一个值
　　列表表达式是一次把所有的值都拿出来

 

步骤分解：

i = None  # 定义空变量，否则下面引用i会报错
def func(x):  # 模拟lambda表达式
    return x*i
z = []  # 模拟列生成式
for i in range(3):
    z.append(func)  # 追加到列表中

print(z)  # 打印z
for o in z:  # 遍历z
    print(locals())  # 打印局部变量
    print('lambda结果',o(2))  # o(2)表示执行函数func，并传一个参数2

执行输出：

[<function func at 0x0000020B24397F28>, <function func at 0x0000020B24397F28>, <function func at 0x0000020B24397F28>]
{'z': [<function func at 0x0000020B24397F28>, <function func at 0x0000020B24397F28>, <function func at 0x0000020B24397F28>], 'func': <function func at 0x0000020B24397F28>, '__spec__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000020B24707A58>, '__package__': None, '__cached__': None, '__name__': '__main__', 'o': <function func at 0x0000020B24397F28>, '__builtins__': <module 'builtins' (built-in)>, '__doc__': None, '__file__': 'E:/python_script/基础/day43/tst.py', 'i': 2}
lambda结果 4
{'z': [<function func at 0x0000020B24397F28>, <function func at 0x0000020B24397F28>, <function func at 0x0000020B24397F28>], 'func': <function func at 0x0000020B24397F28>, '__spec__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000020B24707A58>, '__package__': None, '__cached__': None, '__name__': '__main__', 'o': <function func at 0x0000020B24397F28>, '__builtins__': <module 'builtins' (built-in)>, '__doc__': None, '__file__': 'E:/python_script/基础/day43/tst.py', 'i': 2}
lambda结果 4
{'z': [<function func at 0x0000020B24397F28>, <function func at 0x0000020B24397F28>, <function func at 0x0000020B24397F28>], 'func': <function func at 0x0000020B24397F28>, '__spec__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000020B24707A58>, '__package__': None, '__cached__': None, '__name__': '__main__', 'o': <function func at 0x0000020B24397F28>, '__builtins__': <module 'builtins' (built-in)>, '__doc__': None, '__file__': 'E:/python_script/基础/day43/tst.py', 'i': 2}
lambda结果 4

 

从结果中，可以看出：每一个lambda 里面的i都是2

那么结果必然是4,4,4

也就是说，

z = [lambda x:x*i for i in range(3)]

执行之后，i已经固定死了。它就是2

看debug，就可以看出来。