考试题

1.常用字符串格式化有哪些？说明区别
format
%s __str__
2.写出 元祖，列表，字典，集合的定义方法，增，删，改
答：列表
    l1.append('a')
    l1.insert(1,'s')
    l1.extend('sss')
    l1.remove('s')
    字典
    d1.update()
    d1.setdefault('key1','1')
    集合
    s1.add(3)
    s1.update('laoshi')
    s1.remove(2)
    s1.pop()
    s1.clear()
    print(s1 & s2)
    print(s1 | s2)
    print(s1 - s2)
    print(s1 ^ s2)
    print(s1 > s2)
3.利用python打印前一天的本地时间，格式'2018-01-30'(面试)
    import time
    t1 = time.time() - 60*60*24
    print(time.strftime('%Y-%m-%d %X',time.localtime(t1)))
    timestamp------------>struct_time------------->format time
              localtime                 strftime
             <------------           <-------------
               mktime                    strptime
4.python中search和match区别（面试）
re.search  匹配到第一个返回，group获取
re.match 只尝试匹配第一个字符是否符合
re.split
re.sub
re.subn
    obj = re.compile()
    ret = obj.search()
    ret.group()
re.finditer()
5.什么是lambda函数，好处？
匿名函数，与内置函数配合 简化代码
lambda x:x   区分调用与定义
map
zip
max/min
列表推导式
6.说明__init__和__new__的作用
__init__ 初始化方法
__new__ 构造方法
__del__ 析构方法 删除一个对象前执行
7.简述反射
用字符串数据类型的变量名或者函数名来调用对应的属性

8.解释python中的深拷贝和浅拷贝的区别
deepcopy 开辟新的空间存储数据，原数据改变不影响deepcopy内容
copy浅拷贝 只开辟空间来copy第一层的数据，
           没有拷贝子对象，原数据改变，子对象会改变，新增加的内容不变
直接赋值= 传递对象引用，原列表的任何变换都会做出相应改变

9.用最简洁的方式生成列表【4,16,32,64,128】
print([2**i for i in range(2,8) if i!=3])
print([pow(2,i) for i in range(2,8) if i!=3])

10.python中如何实现随机数并打印，默认的随机数范围是多少？
import random
print(random.random())   0-1

11.新式类和经典类的区别
1.新式类：在继承中，寻找方法是遵循广度优先
          默认继承object
          内置mro方法
  经典类：深度优先

12.装饰器什么时候被执行
加载函数的时候被执行
from functools import wraps
def deco(func):
    @wraps(func)
    def inner(*args,**kwargs):
        print('up')
        re = func(*args,**kwargs)
        print('down')
        return re
    return inner
# @deco
def index(a):
    print('index',a)
index = deco(index)
index('a')
print(index.__name__)

13.什么是并发？什么是并行？
并发：同一时刻，一个cpu执行任务                     多线程，gil锁，同一时刻限制了多个线程只能有一个线程被cpu执行
并行：真正意义上，同一时刻，多个cpu在处理任务        多进程，多进程在同一时刻可以占用多个cpu

14.描述event的执行原理
一个状态控制wait方法是否阻塞
多进程的event基于ipc通信

15.什么是黏包？如何避免？
tcp协议：面向链接的流传输，数据是无边界的
避免：自定义协议，struct模块，
udp协议：

16.什么进程？
运行中的程序
最小的资源分配单位
为多个任务之间的数据安全和内存隔离做约束

17.什么是线程
cpu 调度的最小单位
轻量级的进程
是进程的一部分
线程间可以共享数据

18.管道，队列的理解？
管道：双向通信的数据容器，多进程的IPC中用到，数据不安全
队列：基于管道，锁实现的，保证数据在进程/线程间安全传输的容器

19.写一个装饰器实现：打印程序的运行时间
import time
def time_print(func):
    def inner(*args,**kwargs):
        start = time.time()
        re = func(*args,**kwargs)
        print('执行时间：',time.time() -start)
        return re
    return inner

@time_print
def func(a):
    time.sleep(1)
    print('func over',a)
    return 'ok'

print(func('alex'))

20.默认参数陷阱
def f(x,l=[]):
    for i in range(x):
        l.append(i*i)
    print(l)
f(2)    #  [0,1]
f(3,[3,2,1])   # [3,2,1,0,1,4]
f(3)      # [0,1,0,1,4]

21.使用python简单实现打印99乘法表
for i in range(1,10):
    print()
    for j in range(1,10):
        if i>= j:
            print('%s*%s=%s'%(i,j,i*j),end=',')

22.GIL 概念，以及对多线程的影响？
全局解释锁
属于Cpython解释器
在Cpython解释一段多代码时，约束线程在同一时刻只能有一个线程访问CPU
影响：多线程并不能真正实现并行

23.单例模式
class Singleton:
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'_instance'):
            cls._instance = object.__new__(cls)
        return cls._instance
one = Singleton()
two = Singleton()
two.a = 3
print(one.a)

24.使list3 = [
    {'name':'alex', 'hobby':'抽烟'},
    {'name':'alex', 'hobby':'喝酒'},
    {'name':'alex', 'hobby':'烫头'},
    {'name':'alex', 'hobby':'Massage'},
    {'name':'egon', 'hobby':'喊麦'},
    {'name':'egon', 'hobby':'街舞'},
]变成list4 = [
    {'name':'alex', 'hobby':['抽烟','喝酒','烫头','Massage']},
    {'name':'egon', 'hobby':['喊麦','街舞']},
]

list4 = []
for item in list3:
    for dic in list4:
        if item['name'] == dic['name']:
            dic['hobby'].append(item['hobby'])
            break
    else:
        list4.append({'name':item['name'],'hobby':[item['hobby']]})
print(list4)

25.class Student:
    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 int(max(self.score))
zm = Student('zhangming',20,[69,88,100])
print(zm.get_name())
print(zm.get_age())
print(zm.get_course())

26.

27.什么是异步？异步阻塞？
异步：同一时间，同时执行两个任务， 多线程，多进程
异步阻塞：在各自的线程中，涉及io操作，

28.
from threading import Timer
def func():
    print('func')

for i in range(10):
    Timer(10,func).start()
29.
lock 互斥锁，同一个线程或进程之间，当有两个acquire时，阻塞（锁死）
Rlock 递归锁，同一个线程或进程之间，无论acquire多少次，都不会阻塞