面试题仅做学习参考,学习者阅后也要用心钻研其中的原理,重要知识需要系统学习、透彻学习,形成自己的知识链。以下五点建议希望对您有帮助,早日拿到一份心仪的offer。
import threading
import time
def sayhi(num): #定义每个线程要运行的函数
print("running on number:%s" %num)
time.sleep(3)
for i in range(10):
t = threading.Thread(target=sayhi,args=('t-%s'%i,))
t.start()
import threading
import time
start_time = time.time()
def sayhi(num): #定义每个线程要运行的函数
print("running on number:%s" %num)
time.sleep(3)
t_objs = [] #将进程实例对象存储在这个列表中
for i in range(50):
t = threading.Thread(target=sayhi,args=('t-%s'%i,))
t.start() #启动一个线程,程序不会阻塞
t_objs.append(t)
print(threading.active_count()) #打印当前活跃进程数量
for t in t_objs: #利用for循环等待上面50个进程全部结束
t.join() #阻塞某个程序
print(threading.current_thread()) #打印执行这个命令进程
print("----------------all threads has finished.....")
print(threading.active_count())
print('cost time:',time.time() - start_time)
import threading
import time
start_time = time.time()
def sayhi(num): #定义每个线程要运行的函数
print("running on number:%s" %num)
time.sleep(3)
for i in range(50):
t = threading.Thread(target=sayhi,args=('t-%s'%i,))
t.setDaemon(True) #把当前线程变成守护线程,必须在t.start()前设置
t.start() #启动一个线程,程序不会阻塞
print('cost time:',time.time() - start_time)
import requests
from concurrent.futures import ThreadPoolExecutor
def fetch_request(url):
result = requests.get(url)
print(result.text)
url_list = [
'https://www.baidu.com',
'https://www.google.com/', #google页面会卡住,知道页面超时后这个进程才结束
'http://dig.chouti.com/', #chouti页面内容会直接返回,不会等待Google页面的返回
]
pool = ThreadPoolExecutor(10) # 创建一个线程池,最多开10个线程
for url in url_list:
pool.submit(fetch_request,url) # 去线程池中获取一个线程,线程去执行fetch_request方法
pool.shutdown(True)
from greenlet import greenlet
def test1():
print(12) #4 gr1会调用test1()先打印12
gr2.switch() #5 然后gr2.switch()就会切换到gr2这个协程
print(34) #8 由于在test2()切换到了gr1,所以gr1又从上次停止的位置开始执行
gr2.switch() #9 在这里又切换到gr2,会再次切换到test2()中执行
def test2():
print(56) #6 启动gr2后会调用test2()打印56
gr1.switch() #7 然后又切换到gr1
print(78) #10 切换到gr2后会接着上次执行,打印78
gr1 = greenlet(test1) #1 启动一个协程gr1
gr2 = greenlet(test2) #2 启动第二个协程gr2
gr1.switch() #3 首先gr1.switch() 就会去执行gr1这个协程
from urllib import request
import gevent,time
from gevent import monkey
monkey.patch_all() #把当前程序所有的I/O操作给我单独做上标记
def f(url):
print('GET: %s' % url)
resp = request.urlopen(url)
data = resp.read()
print('%d bytes received from %s.' % (len(data), url))
#1 并发执行部分
time_binxing = time.time()
gevent.joinall([
gevent.spawn(f, 'https://www.python.org/'),
gevent.spawn(f, 'https://www.yahoo.com/'),
gevent.spawn(f, 'https://github.com/'),
])
print("并行时间:",time.time()-time_binxing)
#2 串行部分
time_chuanxing = time.time()
urls = [
'https://www.python.org/',
'https://www.yahoo.com/',
'https://github.com/',
]
for url in urls:
f(url)
print("串行时间:",time.time()-time_chuanxing)
# 注:为什么要在文件开通使用monkey.patch_all()
# 1. 因为有很多模块在使用I / O操作时Gevent是无法捕获的,所以为了使Gevent能够识别出程序中的I / O操作。
# 2. 就必须使用Gevent模块的monkey模块,把当前程序所有的I / O操作给我单独做上标记
# 3.使用monkey做标记仅用两步即可:
第一步(导入monkey模块): from gevent import monkey
第二步(声明做标记) : monkey.patch_all()
import gevent
def func1():
print('\033[31;1m第一次打印\033[0m')
gevent.sleep(2) # 为什么用gevent.sleep()而不是time.sleep()因为是为了模仿I/O
print('\033[31;1m第六次打印\033[0m')
def func2():
print('\033[32;1m第二次打印\033[0m')
gevent.sleep(1)
print('\033[32;1m第四次打印\033[0m')
def func3():
print('\033[32;1m第三次打印\033[0m')
gevent.sleep(1)
print('\033[32;1m第五次打印\033[0m')
gevent.joinall([ # 将要启动的多个协程放到event.joinall的列表中,即可实现自动切换
gevent.spawn(func1), # gevent.spawn(func1)启动这个协程
gevent.spawn(func2),
gevent.spawn(func3),
])
# 运行结果:
# 第一次打印
# 第二次打印
# 第三次打印
# 第四次打印
# 第五次打印
# 第六次打印
def A(x):
def B():
print(x)
return B
deco(*args,**kwargs):
start_time = time.time()
func(*args,**kwargs) #run test1
stop_time = time.time()
print("running time is %s"%(stop_time-start_time))
return deco
# @timer # test1=timer(test1)
def test1():
time.sleep(3)
print("in the test1")
test1()
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import time
def auth(auth_type):
print("auth func:",auth_type)
def outer_wrapper(func):
def wrapper(*args, **kwargs):
print("wrapper func args:", *args, **kwargs)
print('运行前')
func(*args, **kwargs)
print('运行后')
return wrapper
return outer_wrapper
@auth(auth_type="local") # home = wrapper()
def home():
print("welcome to home page")
return "from home"
home()
import time
t1 = time.time()
g = (i for i in range(100000000))
t2 = time.time()
lst = [i for i in range(100000000)]
t3 = time.time()
print('生成器时间:',t2 - t1) # 生成器时间: 0.0
print('列表时间:',t3 - t2) # 列表时间: 5.821957349777222
#!/usr/bin/python
# -*- coding: utf-8 -*-
def read_big_file_v(fname):
block_size = 1024 * 8
with open(fname,encoding="utf8") as fp:
while True:
chunk = fp.read(block_size)
# 当文件没有更多内容时,read 调用将会返回空字符串 ''
if not chunk:
break
print(chunk)
path = r'C:\aaa\luting\edc-backend\tttt.py'
read_big_file_v(path)
class Foo(object):
instance = None
def __init__(self):
self.name = 'alex'
def __new__(cls, *args, **kwargs):
if Foo.instance:
return Foo.instance
else:
Foo.instance = object.__new__(cls,*args,**kwargs)
return Foo.instance
obj1 = Foo() # obj1和obj2获取的就是__new__方法返回的内容
obj2 = Foo()
print(obj1,obj2) # 运行结果: <__main__.Foo object at 0x00D3B450>
<__main__.Foo object at 0x00D3B450>
# 运行结果说明:
# 这可以看到我们新建的两个Foo()对象内存地址相同,说明使用的•同一个类,没有重复建立类
class D:
def talk(self):
print('D')
class B(D):
pass
# def talk(self):
# print('B')
class C(D):
pass
def talk(self):
print('C')
class A(B,C):
pass
# def talk(self):
# print('A')
a = A()
a.talk()
高阶函数
# -*- coding:utf8 -*-
l1= [11,22,33,44,55]
ret = map(lambda x:x-100 if x % 2 != 0 else x + 100,l1)
print(list(ret))
# 运行结果: [-89, 122, -67, 144, -45]
# lambda x:x-100 if x % 2 != 0 else x + 100
# 如果 "if x % 2 != 0" 条件成立返回 x-100
# 不成立:返回 x+100
def F(x):
if x%2 != 0:
return x-100
else:
return x+100
ret = map(F,l1)
print(list(ret))
# -*- coding:utf8 -*-
'''使用reduce将字符串反转'''
s = 'Hello World'
from functools import reduce
result = reduce(lambda x,y:y+x,s)
# # 1、第一次:x=H,y=e => y+x = eH
# # 2、第二次:x=l,y=eH => y+x = leH
# # 3、第三次:x=l,y=leH => y+x = lleH
print( result ) # dlroW olleH
l1= [11,22,33,44,55]
a = filter(lambda x: x<33, l1)
print(list(a))
# -*- coding:utf8 -*-
def F(x):
if x<33:
return x
b = filter(F,l1)
print(list(b))
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
# [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
print( sorted(students, key=lambda s: s[2], reverse=False) ) # 按年龄排序
# 结果:[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
def f(x):
# ('john', 'A', 15)
return x[2]
print( sorted(students, key=f, reverse=False) ) # 按年龄排序
d = {'k1':1, 'k3': 3, 'k2':2}
# d.items() = [('k1', 1), ('k3', 3), ('k2', 2)]
a = sorted(d.items(), key=lambda x: x[1])
print(a) # [('k1', 1), ('k2', 2), ('k3', 3)]
L1 = ['k1','k2','k3']
L2 = ['v1','v2','v3']
print( list(zip(L1,L2)))
# zip(L1,L2) : [('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')]
# dict( [('k1', 'v1'), ('k2', 'v2'), ('k3', 'v3')] ) = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
(x,y,z):
return x+y+z
f = lambda x:x if x % 2 != 0 else x + 100
print(f(10)) # 110
name = 'Tom' if 1 == 1 else 'fly'
print(omname)
# 运行结果: T
#!/usr/bin/python
# -*- coding: utf-8 -*-
def read_big_file_v(fname):
block_size = 1024 * 8
with open(fname,encoding="utf8") as fp:
while True:
chunk = fp.read(block_size)
# 当文件没有更多内容时,read 调用将会返回空字符串 ''
if not chunk:
break
print(chunk)
path = r'C:\aaa\luting\edc-backend\tttt.py'
read_big_file_v(path)
#1、返回执行状态:0 执行成功
retcode = subprocess.call(['ping', 'www.baidu.com', '-c5'])
#2、返回执行状态:0 执行成功,否则抛异常
subprocess.check_call(["ls", "-l"])
#3、执行结果为元组:第1个元素是执行状态,第2个是命令结果
>>> ret = subprocess.getstatusoutput('pwd')
>>> ret
(0, '/test01')
#4、返回结果为 字符串 类型
>>> ret = subprocess.getoutput('ls -a')
>>> ret
'.\n..\ntest.py'
#5、返回结果为'bytes'类型
>>> res=subprocess.check_output(['ls','-l'])
>>> res.decode('utf8')
'总用量 4\n-rwxrwxrwx. 1 root root 334 11月 21 09:02 test.py\n'
subprocess.check_output(['chmod', '+x', filepath])
subprocess.check_output(['dos2unix', filepath])
#1、先打印'parent process'不等待child的完成
import subprocess
child = subprocess.Popen(['ping','-c','4','www.baidu.com'])
print('parent process')
#2、后打印'parent process'等待child的完成
import subprocess
child = subprocess.Popen('ping -c4 www.baidu.com',shell=True)
child.wait()
print('parent process')
child.poll() # 检查子进程状态
child.kill() # 终止子进程
child.send_signal() # 向子进程发送信号
child.terminate() # 终止子进程
import subprocess
#下面执行命令等价于: cat /etc/passwd | grep root
child1 = subprocess.Popen(["cat","/etc/passwd"], stdout=subprocess.PIPE)
child2 = subprocess.Popen(["grep","root"],stdin=child1.stdout, stdout=subprocess.PIPE)
out = child2.communicate() #返回执行结果是元组
print(out)
#执行结果: (b'root:x:0:0:root:/root:/bin/bash\noperator:x:11:0:operator:/root:/sbin/nologin\n', None)
import subprocess
list_tmp = []
def main():
p = subprocess.Popen(['ping', 'www.baidu.com', '-c5'], stdin = subprocess.PIPE, stdout = subprocess.PIPE)
while subprocess.Popen.poll(p) == None:
r = p.stdout.readline().strip().decode('utf-8')
if r:
# print(r)
v = p.stdout.read().strip().decode('utf-8')
list_tmp.append(v)
main()
print(list_tmp[0])
函数 | 描述 |
---|---|
compile(pattern[, flags]) | 根据正则表达式字符串创建模式对象 |
search(pattern, string[, flags]) | 在字符串中寻找模式 |
match(pattern, 常用模块[, flags]) | 在字符串的开始处匹配模式 |
split(pattern, string[, maxsplit=0]) | 根据模式的匹配项来分割字符串 |
findall(pattern, string) | 列出字符串中模式的所有匹配项并以列表返回 |
sub(pat, repl, string[, count=0]) | 将字符串中所有pat的匹配项用repl替换 |
escape(string) | 将字符串中所有特殊正则表达式字符转义 |
# >> a = 'yms'
# >> b = 'yms'
# >> a == b
# True
>> x = y = [4,5,6]
>> z = [4,5,6]
>> x == y
True
>> x == z
True
>> x is y
True
>> x is z
False
>>
>> print id(x)
3075326572
>> print id(y)
3075326572
>> print id(z)
3075328140
>> a = 1 #a和b为数值类型
>> b = 1
>> a is b
True
>> id(a)
14318944
>> id(b)
14318944
>> a = 'cheesezh' #a和b为字符串类型
>> b = 'cheesezh'
>> a is b
True
>> id(a)
42111872
>> id(b)
42111872
>> a = (1,2,3) #a和b为元组类型
>> b = (1,2,3)
>> a is b
False
>> id(a)
15001280
>> id(b)
14790408
>> a = [1,2,3] #a和b为list类型
>> b = [1,2,3]
>> a is b
False
>> id(a)
42091624
>> id(b)
42082016
>> a = {'cheese':1,'zh':2} #a和b为dict类型
>> b = {'cheese':1,'zh':2}
>> a is b
False
>> id(a)
42101616
>> id(b)
42098736
>> a = set([1,2,3])#a和b为set类型
>> b = set([1,2,3])
>> a is b
False
>> id(a)
14819976
>> id(b)
14822256
Python基础到此就分解完了,有不足的地方请留言,多多支持,持续更新中哦!!