python笔记(复习题)

1、常用字符串格式化有哪些?并说明他们的区别
format:直接调用函数,%s：语法糖,%r
2、请写出【元祖,列表,字典,集合】的定义方法、新增方法、更改方法、删除方法
3、利用 python打印前一天的本地时间,格式为‘2018-01-30(面试题)
时间戳时间 - (606024)转换成格式化时间strftime

4、python中 search()和 match()的区别(面试题)
相同点：接收两个参数（正则表达式，带匹配字符串），只匹配一个符合条件的项
区别：search根据所写的正则匹配符合条件的第一个，match:根据所写正则从头开始匹配，相当于在正则表达式的开始位置加一个^

5、什么是lambda函数,有什么好处
简单明了，可以和内置函数合用，有效的减小代码
6、说明__init_和__neW__的作用
__init__初始化方法(self)
new 构造方法(cls) 创建对象
__del__析构方法，删除一个对象之前执行的方法
7、简述反射是怎么回事?
getattr(A,‘b’)用字符串数据类型的变量名或函数名来调用对应的属性
8、解释 python中深拷贝和浅拷贝的区别
深拷贝：不管一个数据类型有多少层，都另外开辟新的空间来存储一份和原来一模一样的数据
浅拷贝：只是重新开辟一块空间copy第一层的数据
9、用最简洁的方式生成这样一个列表【4,16,32,64,128】
print([2**i for i in range(2,8) if i != 3])
10、python中如何实现随机数并打印,默认的随机数范围是多少?
random.random() 0-1
11、新式类和金典类(旧式类)的区别(一种一分)
新式类：默认继承object
在继承的过程中，寻找一个方法遵循广度优先
内置mro方法来标识广度优先的顺序
经典类：在继承过程中，寻找一个方法遵循深度优先
12、装饰器什么时候被执行的
被装饰的函数调用的时候
加载函数的时候被执行
13、什么是” 并发“?什么是”并行“?
并发：多线程，看起来一起执行 GIL在同一时刻限制了多个线程只能有一个线程被CPU执行
并行：多进程，多个进程在同一时刻可占用多个CPU,是真正意义上的在同一时间执行任务
14、以个人理解描述Event的执行原理
有一个状态控制wait方法是否阻塞
15、什么是粘包,如何避免?
TCP:面向连接的字节流传输，数据是无边界的
如何避免：自定义协议，struct模块，把一定范围的数据打包成四字节的字符串
UDP:面向报文的传输
16、什么是进程?
运行中的程序，是最小的资源分配单位，为多个任务之间的数据安全和内存隔离做约束
17、什么是线程?
cpu调度的最小单位，轻量级的进程，是进程的一部分，可以共享进程中的数据
18、简述你对管道、队列的理解;
管道：双向通信的数据容器，多进程的IPC中用到了，数据不安全
队列：先进先出，基于管道和锁实现的一个数据在线程\进程之间安全的容器
19、编程题;写一个装饰器实现功能:打印程序的运行时间

import time
def timer(func):
    def inner(*args,**kwargs):
        start = time.time()
        ret = func(*args,**kwargs)
        print(time.time()-start)
        return ret
    return inner

@timer #wahaha = timer(wahaha)
def wahaha(a,b):
    time.sleep(0.5)
    return a*b

print(wahaha(3,5))

20、读以下代码,写出答案并简述原因(面试题建议不使用电脑)下面代码会输出什么

def f(x,l=[]):
    for i in range(x):
        l.append(i*i)
    print(l)
f(2)
f(3,[3,2,1])
f(3)#用到了第一个的输出列表
输出结果：
[0, 1]
[3, 2, 1, 0, 1, 4]
[0, 1, 0, 1, 4]

21、使用 python简单实现打印九九乘法表

l = []
for i in range(1,10):
    for j in range(1,i+1):
        n = '%s*%s=%s'%(i,j,i*j)
        l.append(n)
    print(l)
    l.clear()

22、简述python GIL的概念,以及它对 python多线程的影响?(2)
GIL：全局解释器，属于Cpython解释器，
用来在Cpython解释器解释一段多线程的代码时,约束线程在同一时刻只能有一个线程访问CPU
它对 python多线程的影响:在Cpython解释器下启动的多线程并不能真正实现并行
23、写一个单例模式
24、编程题:将以下1ist3的格式转换成list4格式(8)

list3=[{"name":"alex","hobby":"抽烟"},
       {"name":"alex","hobby":"喝酒"},
       {"name":"alex","hobby":"烫头"},
       {"name":"alex","hobby":"Massage"},
       {"name":"egon","hobby":"喊麦"},
       {"name":"egon","hobby":"街舞"}
]

如何把上面的列表转换成下方的列表?

list4=[{"name":"alex"," hobby_list":["抽烟","喝酒","烫头"," Massage"]},
       {"name":"egon"," hobby_1ist":["喊麦","街舞"]}
       ]

自己写的：

man1 = {}
man2 = {}
a = []
e = []
for item in list3:
    if item['name'] == 'alex':
        a.append(item['hobby'])
        man1['name'] = 'alex'
        man1['hobby_list'] = a
    else:
        e.append(item['hobby'])
        man2['name'] = 'egon'
        man2['hobby_list'] = e

list4 = [man1,man2]
print(list4)

老师讲的：

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

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():
    def __init__(self,name,age,tar):
        self.name = name
        self.age  = age
        self.tar  = tar
    def get_name(self):
        return self.name
    def get_age(self):
        return int(self.age)
    def get_course(self):
        return max(self.tar)
long = Student('xiaolonglong',21,[100,81,90,78])
print(long.get_name())
print(long.get_age())
print(long.get_course())

26、写一个 socket客户端和服务端进行异步通讯
27、什么是异步,什么是异步阻塞?
在同一时间可以同时做两件事情 多线程 多进程
异步阻塞：在同一时刻各自的线程或者进程中存在IO操作而不影响其他线进程
t.start()
28、写一个程序,包含十个线程,子线程必须等待主线程sleep10秒钟之后才执行,并打印当前时间

from threading import Timer
import time
def func():print(time.localtime())
for i in range(10):Timer(10,func).start()

29、你所了解的锁都有哪些？
互斥锁：在同一个线程或者进程之间，当两个acquire的时候，就会产生阻塞，死锁
递归锁：在同一个线程或进程之间，无论acquire多少次都不会产生阻塞
30、threading. RLock和 threading.Lock的区别
互斥锁 在同一个线程或者进程之间，当有两个acquire的时候，就会产生阻塞，死锁
递归锁：在同一个线程或进程之间，无论acquire多少次都不会产生阻塞