整合營銷服務商
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
篇文章主要介紹了SpringBoot整合FastJson過程解析,文中通過示例代碼介紹得非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.33</version>
</dependency>
@Configuration
public class WebMvcConfig implements WebMvcConfigurer {
/**
* 使用fastjson代替jackson
*
* @param
*/
@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
?
@Override
?
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
?
/*
先把JackSon的消息轉換器刪除.
備注: (1)源碼分析可知，返回json的過程為:
Controller調用結束后返回一個數據對象，for循環遍歷conventers，找到支持application/json的HttpMessageConverter，然后將返回的數據序列化成json。
具體參考org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor的writeWithMessageConverters方法
(2)由于是list結構，我們添加的fastjson在最后。因此必須要將jackson的轉換器刪除，不然會先匹配上jackson，導致沒使用fastjson
*/
for (int i=converters.size() - 1; i >=0; i--) {
if (converters.get(i) instanceof MappingJackson2HttpMessageConverter) {
converters.remove(i);
}
}
FastJsonHttpMessageConverter fastJsonHttpMessageConverter=new FastJsonHttpMessageConverter();
//自定義fastjson配置
FastJsonConfig config=new FastJsonConfig();
config.setSerializerFeatures(
SerializerFeature.WriteMapNullValue, // 是否輸出值為null的字段,默認為false,我們將它打開
SerializerFeature.WriteNullListAsEmpty, // 將Collection類型字段的字段空值輸出為[]
SerializerFeature.WriteNullStringAsEmpty, // 將字符串類型字段的空值輸出為空字符串
SerializerFeature.WriteNullNumberAsZero, // 將數值類型字段的空值輸出為0
SerializerFeature.WriteDateUseDateFormat,
SerializerFeature.DisableCircularReferenceDetect // 禁用循環引用
?
);
?
fastJsonHttpMessageConverter.setFastJsonConfig(config);
?
// 添加支持的MediaTypes;不添加時默認為*/*,也就是默認支持全部
?
// 但是MappingJackson2HttpMessageConverter里面支持的MediaTypes為application/json
?
?
List<MediaType> fastMediaTypes=new ArrayList<>();
MediaType mediaType=MediaType.parseMediaType("text/html;charset=UTF-8");
fastMediaTypes.add(mediaType);
fastMediaTypes.add(MediaType.APPLICATION_JSON_UTF8);
fastJsonHttpMessageConverter.setSupportedMediaTypes(fastMediaTypes);
// fastJsonHttpMessageConverter.setDefaultCharset(Charset.forName("UTF-8"));
converters.add(fastJsonHttpMessageConverter);
}
}
@JSONField(serialize=false)
private String delFlag; // 數據刪除標記, 0-已刪除 1-有效
以上就是本文的全部內容，希望對大家的學習有所幫助，喜歡本文的小伙伴記得點贊關注收藏哦~
么么么么么么么么么么噠！老子愛你們！?( ′???)比心?( ′??? )比心?( ′???` )比心
我們從一段代碼說起，假設有一段這樣的 JSON 數據：
var json={
name: '流火',
blog: 'ued.taobao.org'
};
我們需要根據這段 JSON 生成這樣的 HTML 代碼：
流火 (blog: ued.taobao.org)
傳統的 JavaScript 代碼一定是這個樣子：
var html; html='' + json.name + ' (blog: ' + json.blog + ')';
不言而喻，這樣的代碼混雜了 HTML 結構和代碼邏輯，而且代碼不具可讀性，不便于后期維護，于是便有了這樣一個函數：
function sub(str, data) {
return str.replace(/{(.*?)}/igm, function($, $1) {
return data[$1] ? data[$1] : $;
});
}
有了這個函數，我們拼接字符串的工作就可以簡化為：
var tpl='{name} (blog: {blog})';
var html=sub(tpl, json);
看到這里，不用我多說，我想通過這個例子直觀的展現出前端模板引擎的好處所在，這么做能夠完全剝離 HTML 和代碼邏輯，便于多人協作和后期的代碼維護。當然，當我們的業務邏輯需要對數據源進行循環遍歷，if 判斷等的時候，這個簡明的函數很顯然并不能滿足我們的需求，于是便有了如今這市面上眾多的模板引擎，諸如 Mustache，jQuery tmpl，Kissy template，ejs，doT，nTenjin 等等。
“如無必要，勿增實體?！?/p>
這是著名的奧卡姆剃須刀法則，簡單的說就是避免重復造輪子。那么就會有童鞋質疑，既然已然有這么多現成的東西可用，為什么還要重新打造一個呢？
我個人認為一個完善的模板引擎應該兼顧這幾點：
而市面上現有的模板引擎沒有做到兼顧以上幾點，比如 Mustache 支持多種語言，通用性不錯，不過性能稍差，而且語法不支持高級特性，例如遍歷的時候無法做 if 判斷，也無法獲得 index 索引值，jQuery tmpl 依賴 jQuery，缺乏可移植性，Kissy template 雖然依賴 Kissy， 不過性能和語法都值得推薦，doT/nTenjin 性能和靈活性都很不錯，但是語法需要用原生的js來寫，寫好的模板代碼可讀性稍差。
魚和熊掌不可兼得，語法的處理，安全性的輸出過濾和錯誤處理機制的引入在一定程度上都會或多或少降低模板引擎的性能，因此就需要我們權衡。Juicer 在實現上首先將性能看做第一個重要的指標，畢竟性能好壞直接影響用戶的感知，同時兼顧了安全性和錯誤處理機制（即便這樣會導致性能的略微下降）。
首先來看下 jsperf 上同幾個主流模板引擎的性能對比。
可以看到，性能上比傳統模板引擎均有提升，下邊的介紹主要從語法、安全性和錯誤處理，以及如何使用這幾個方面介紹下 Juicer.
詳細的語法請參考 Juicer Docs.
安全性，簡單地說就是對輸出數據在輸出前進行一次轉義過濾，避免 XSS 這樣的腳本注入攻擊，簡單掃下盲，舉個 XSS 的例子。
var json={
output: 'alert("XSS");'
};
如果 JSON 數據是第三方接口返回或者含有用戶輸入（像 BBS、評價）的內容，我們如果赤裸裸的將 output 寫到頁面上就會執行惡意的js代碼，所以 Juicer 默認是對數據輸出做了安全轉義的，當然如果不想被轉義，可以使用 $${varname}。
juicer.to_html('${output}',json);
//輸出：<script>alert("XSS");</script>
juicer.to_html('$${output}',json);
//輸出：<script>alert("XSS");</script>
如果沒有錯誤處理，當模板引擎編譯（Compile）或者渲染（Render）出錯時候就會引起后續js代碼停止執行，可想而知，如果因為一個逗號或者 JSON 數據的偶發錯誤導致整個頁面掛掉，是我們不能接受的。但是 Juicer 在遇到這些錯誤的時候不會影響后續代碼的執行，只會在控制臺打出一句警告（Warn）告知開發者模板解析出現錯誤。
juicer.to_html('${varname,,,,,,,}', json);
alert('hello, juicer!');
執行上邊的代碼就會看到控制臺打出的 Juicer Compile Exception: Unexpected token ,，但是不會因為錯誤導致后續的 alert被阻塞掉。
Juicer 對一個模板的編譯和渲染的過程主要有以下幾個步驟：
var json={
list: [
{ name: 'benben' },
{ name: 'liuhuo' }
]
};
juicer.set('errorhandling', false); // pre-set option
var tpl='{@each list as value,key}$${value.name}{@/each}';
var compiled_tpl=juicer(tpl);
我們通過compiled_tpl.render.toString()看下編譯后的代碼：
function anonymous(data) {
var data=data || {};
var out='';
out +='';
for (var i0=0, l=data.list.length; i0 < l; i0++) {
var value=data.list[i0];
var key=i0;
out +='';
out +=((value.name));
out +='';
}
out +='';
return out;
}
是不是已經明白了 Juicer 的原理？這個編譯后的函數就會每次幫我們完成從數據到 HTML 代碼的拼裝操作。
這里有幾點優化的地方值得分享下：
這幾點優化在大數據量循環渲染時候性能提升顯著，不過正因為放棄了 with{} 語句，所以 Juicer 會在編譯函數之前對模板進行詞法分析，將用到的變量實現聲明，這樣就能避免 JSON 數據外層必須指定 data. 前綴，如果你覺得這點性能的提升不重要，也可以在 options 中指定 loose: false（禁用松散模式），這樣就可以不省去 data. 前綴，這樣做的好處就是性能會更好一些。
最后介紹下 Options 配置項，左側為參數默認值。
{
cache: true/false,
loose: true/false,
strip: true/false,
errorhandling: true/false
}
cache 默認為 true，即同一個模板編譯后是否被 Juicer 緩存，也就是說如果緩存開啟的情況下，同一個模板第一次編譯后，為了縮短耗時提升性能，后續不會再次執行編譯的操作而是直接從緩存中去取編譯好的模板函數。
Juicer 有兩種使用方法，一種是通過
juicer(tpl, data); // 或者 juicer.to_html(tpl, data);
直接根據提供的數據將模板轉為 HTML 代碼，另一種是通過 compile 方法先將模板編譯好，在需要的時候再對模板進行數據的 Render 操作：
var compiled_tpl=juicer(tpl); compiled_tpl.render(data); // 或者 var compiled_tpl=juicer.compile(tpl); compiled_tpl.render(data);
點贊+轉發，讓更多的人也能看到這篇內容（收藏不點贊，都是耍流氓-_-）
關注 ｛我｝，享受文章首發體驗！
每周重點攻克一個前端技術難點。更多精彩前端內容私信 我 回復“教程”
原文鏈接：
作者：admin
于總結了太多的東西，所以篇幅有點長，這也是作者"縫縫補補"總結了好久的東西，強烈建議收藏再慢慢看~
Py2 和 Py3 的差別
#枚舉的注意事項
from enum import Enum
class COLOR(Enum):
YELLOW=1
#YELLOW=2#會報錯
GREEN=1#不會報錯,GREEN可以看作是YELLOW的別名
BLACK=3
RED=4
print(COLOR.GREEN)#COLOR.YELLOW,還是會打印出YELLOW
for i in COLOR:#遍歷一下COLOR并不會有GREEN
print(i)
#COLOR.YELLOW\nCOLOR.BLACK\nCOLOR.RED\n怎么把別名遍歷出來
for i in COLOR.__members__.items():
print(i)
# output:('YELLOW', <COLOR.YELLOW: 1>)\n('GREEN', <COLOR.YELLOW: 1>)\n('BLACK', <COLOR.BLACK: 3>)\n('RED', <COLOR.RED: 4>)
for i in COLOR.__members__:
print(i)
# output:YELLOW\nGREEN\nBLACK\nRED
#枚舉轉換
#最好在數據庫存取使用枚舉的數值而不是使用標簽名字字符串
#在代碼里面使用枚舉類
a=1
print(COLOR(a))# output:COLOR.YELLOW
py2/3 轉換工具
常用庫
不常用但很重要的庫
def isLen(strString):
#還是應該使用三元表達式，更快
return True if len(strString)>6 else False
def isLen1(strString):
#這里注意false和true的位置
return [False,True][len(strString)>6]
import timeit
print(timeit.timeit('isLen1("5fsdfsdfsaf")',setup="from __main__ import isLen1"))
print(timeit.timeit('isLen("5fsdfsdfsaf")',setup="from __main__ import isLen"))
import types
types.coroutine #相當于實現了__await__
import html
html.escape("<h1>I'm Jim</h1>") # output:'<h1>I'm Jim</h1>'
html.unescape('<h1>I'm Jim</h1>') # <h1>I'm Jim</h1>
from concurrent.futures import ThreadPoolExecutor
pool=ThreadPoolExecutor()
task=pool.submit(函數名，（參數）) #此方法不會阻塞，會立即返回
task.done()#查看任務執行是否完成
task.result()#阻塞的方法，查看任務返回值
task.cancel()#取消未執行的任務，返回True或False,取消成功返回True
task.add_done_callback()#回調函數
task.running()#是否正在執行 task就是一個Future對象
for data in pool.map(函數，參數列表):#返回已經完成的任務結果列表，根據參數順序執行
print(返回任務完成得執行結果data)
from concurrent.futures import as_completed
as_completed(任務列表)#返回已經完成的任務列表，完成一個執行一個
wait(任務列表,return_when=條件)#根據條件進行阻塞主線程，有四個條件
future=asyncio.ensure_future(協程) 等于后面的方式 future=loop.create_task(協程)
future.add_done_callback()添加一個完成后的回調函數
loop.run_until_complete(future)
future.result()查看寫成返回結果
asyncio.wait()接受一個可迭代的協程對象
asynicio.gather(*可迭代對象,*可迭代對象） 兩者結果相同，但gather可以批量取消，gather對象.cancel()
一個線程中只有一個loop
在loop.stop時一定要loop.run_forever()否則會報錯
loop.run_forever()可以執行非協程
最后執行finally模塊中 loop.close()
asyncio.Task.all_tasks()拿到所有任務 然后依次迭代并使用任務.cancel()取消
偏函數partial(函數，參數)把函數包裝成另一個函數名 其參數必須放在定義函數的前面
loop.call_soon(函數,參數)
call_soon_threadsafe()線程安全
loop.call_later(時間,函數,參數)
在同一代碼塊中call_soon優先執行，然后多個later根據時間的升序進行執行
如果非要運行有阻塞的代碼
使用loop.run_in_executor(executor,函數，參數)包裝成一個多線程，然后放入到一個task列表中，通過wait(task列表)來運行
通過asyncio實現http
reader,writer=await asyncio.open_connection(host,port)
writer.writer()發送請求
async for data in reader:
data=data.decode("utf-8")
list.append(data)
然后list中存儲的就是html
as_completed(tasks)完成一個返回一個,返回的是一個可迭代對象
協程鎖
async with Lock():
from multiprocessing import Manager,Process
def add_data(p_dict, key, value):
p_dict[key]=value
if __name__=="__main__":
progress_dict=Manager().dict()
from queue import PriorityQueue
first_progress=Process(target=add_data, args=(progress_dict, "bobby1", 22))
second_progress=Process(target=add_data, args=(progress_dict, "bobby2", 23))
first_progress.start()
second_progress.start()
first_progress.join()
second_progress.join()
print(progress_dict)
from multiprocessing import Pipe,Process
#pipe的性能高于queue
def producer(pipe):
pipe.send("bobby")
def consumer(pipe):
print(pipe.recv())
if __name__=="__main__":
recevie_pipe, send_pipe=Pipe()
#pipe只能適用于兩個進程
my_producer=Process(target=producer, args=(send_pipe, ))
my_consumer=Process(target=consumer, args=(recevie_pipe,))
my_producer.start()
my_consumer.start()
my_producer.join()
my_consumer.join()
from multiprocessing import Queue,Process
def producer(queue):
queue.put("a")
time.sleep(2)
def consumer(queue):
time.sleep(2)
data=queue.get()
print(data)
if __name__=="__main__":
queue=Queue(10)
my_producer=Process(target=producer, args=(queue,))
my_consumer=Process(target=consumer, args=(queue,))
my_producer.start()
my_consumer.start()
my_producer.join()
my_consumer.join()
def producer(queue):
queue.put("a")
time.sleep(2)
def consumer(queue):
time.sleep(2)
data=queue.get()
print(data)
if __name__=="__main__":
queue=Manager().Queue(10)
pool=Pool(2)
pool.apply_async(producer, args=(queue,))
pool.apply_async(consumer, args=(queue,))
pool.close()
pool.join()
# 方法一
True in [i in s for i in [a,b,c]]
# 方法二
any(i in s for i in [a,b,c])
# 方法三
list(filter(lambda x:x in s,[a,b,c]))
import sys
sys.getdefaultencoding() # setdefaultencodeing()設置系統編碼方式
class A(dict):
def __getattr__(self,value):#當訪問屬性不存在的時候返回
return 2
def __getattribute__(self,item):#屏蔽所有的元素訪問
return item
print([[x for x in range(1,101)][i:i+3] for i in range(0,100,3)])
type.__bases__ #(<class 'object'>,)
object.__bases__ #()
type(object) #<class 'type'>
class Yuan(type):
def __new__(cls,name,base,attr,*args,**kwargs):
return type(name,base,attr,*args,**kwargs)
class MyClass(metaclass=Yuan):
pass
class MyTest(unittest.TestCase):
def tearDown(self):# 每個測試用例執行前執行
print('本方法開始測試了')
def setUp(self):# 每個測試用例執行之前做操作
print('本方法測試結束')
@classmethod
def tearDownClass(self):# 必須使用 @ classmethod裝飾器, 所有test運行完后運行一次
print('開始測試')
@classmethod
def setUpClass(self):# 必須使用@classmethod 裝飾器,所有test運行前運行一次
print('結束測試')
def test_a_run(self):
self.assertEqual(1, 1) # 測試用例
for gevent import monkey
monkey.patch_all() #將代碼中所有的阻塞方法都進行修改，可以指定具體要修改的方法
co_flags=func.__code__.co_flags
# 檢查是否是協程
if co_flags & 0x180:
return func
# 檢查是否是生成器
if co_flags & 0x20:
return func
#一只青蛙一次可以跳上1級臺階，也可以跳上2級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
#請問用n個2*1的小矩形無重疊地覆蓋一個2*n的大矩形，總共有多少種方法？
#方式一：
fib=lambda n: n if n <=2 else fib(n - 1) + fib(n - 2)
#方式二：
def fib(n):
a, b=0, 1
for _ in range(n):
a, b=b, a + b
return b
#一只青蛙一次可以跳上1級臺階，也可以跳上2級……它也可以跳上n級。求該青蛙跳上一個n級的臺階總共有多少種跳法。
fib=lambda n: n if n < 2 else 2 * fib(n - 1)
import os
os.getenv(env_name,None)#獲取環境變量如果不存在為None
#查看分代回收觸發
import gc
gc.get_threshold() #output:(700, 10, 10)
def conver_bin(num):
if num==0:
return num
re=[]
while num:
num, rem=divmod(num,2)
re.append(str(rem))
return "".join(reversed(re))
conver_bin(10)
list1=['A', 'B', 'C', 'D']
# 方法一
for i in list1:
globals()[i]=[] # 可以用于實現python版反射
# 方法二
for i in list1:
exec(f'{i}=[]') # exec執行字符串語句
# bytearray是可變的，bytes是不可變的,memoryview不會產生新切片和對象
a='aaaaaa'
ma=memoryview(a)
ma.readonly # 只讀的memoryview
mb=ma[:2] # 不會產生新的字符串
a=bytearray('aaaaaa')
ma=memoryview(a)
ma.readonly # 可寫的memoryview
mb=ma[:2] # 不會會產生新的bytearray
mb[:2]='bb' # 對mb的改動就是對ma的改動
# 代碼中出現...省略號的現象就是一個Ellipsis對象
L=[1,2,3]
L.append(L)
print(L) # output:[1,2,3,[…]]
class lazy(object):
def __init__(self, func):
self.func=func
def __get__(self, instance, cls):
val=self.func(instance) #其相當于執行的area(c),c為下面的Circle對象
setattr(instance, self.func.__name__, val)
return val`
class Circle(object):
def __init__(self, radius):
self.radius=radius
@lazy
def area(self):
print('evalute')
return 3.14 * self.radius ** 2
all_files=[]
def getAllFiles(directory_path):
import os
for sChild in os.listdir(directory_path):
sChildPath=os.path.join(directory_path,sChild)
if os.path.isdir(sChildPath):
getAllFiles(sChildPath)
else:
all_files.append(sChildPath)
return all_files
#secure_filename將字符串轉化為安全的文件名
from werkzeug import secure_filename
secure_filename("My cool movie.mov") # output:My_cool_movie.mov
secure_filename("../../../etc/passwd") # output:etc_passwd
secure_filename(u'i contain cool \xfcml\xe4uts.txt') # output:i_contain_cool_umlauts.txt
from datetime import datetime
datetime.now().strftime("%Y-%m-%d")
import time
#這里只有localtime可以被格式化，time是不能格式化的
time.strftime("%Y-%m-%d",time.localtime())
# 會報錯，但是tuple的值會改變，因為t[1]id沒有發生變化
t=(1,[2,3])
t[1]+=[4,5]
# t[1]使用append\extend方法并不會報錯，并可以成功執行
class Mydict(dict):
def __missing__(self,key): # 當Mydict使用切片訪問屬性不存在的時候返回的值
return key
# +不能用來連接列表和元祖，而+=可以（通過iadd實現，內部實現方式為extends(),所以可以增加元組），+會創建新對象
#不可變對象沒有__iadd__方法，所以直接使用的是__add__方法，因此元祖可以使用+=進行元祖之間的相加
dict.fromkeys(['jim','han'],21) # output:{'jim': 21, 'han': 21}204 No Content //請求成功處理，沒有實體的主體返回，一般用來表示刪除成功
206 Partial Content //Get范圍請求已成功處理
303 See Other //臨時重定向，期望使用get定向獲取
304 Not Modified //請求緩存資源
307 Temporary Redirect //臨時重定向，Post不會變成Get
401 Unauthorized //認證失敗
403 Forbidden //資源請求被拒絕
400 //請求參數錯誤
201 //添加或更改成功
503 //服務器維護或者超負載
# environ：一個包含所有HTTP請求信息的dict對象
# start_response：一個發送HTTP響應的函數
def application(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
return '<h1>Hello, web!</h1>'
例如：
select id from t where substring(name,1,3)='abc' – name;
以abc開頭的，應改成：
select id from t where name like 'abc%'
例如：
select id from t where datediff(day, createdate, '2005-11-30')=0 – '2005-11-30';
應改為:
不要在 where 子句中的 “=” 左邊進行函數、算術運算或其他表達式運算，否則系統將可能無法正確使用索引
應盡量避免在 where 子句中對字段進行表達式操作，這將導致引擎放棄使用索引而進行全表掃描
如：
select id from t where num/2=100
應改為:
select id from t where num=100*2；
不適合鍵值較少的列（重復數據較多的列）比如：set enum列就不適合(枚舉類型(enum)可以添加null,并且默認的值會自動過濾空格集合(set)和枚舉類似，但只可以添加64個值)
如果MySQL估計使用全表掃描要比使用索引快，則不使用索引
單例模式
# 方式一
def Single(cls,*args,**kwargs):
instances={}
def get_instance (*args, **kwargs):
if cls not in instances:
instances[cls]=cls(*args, **kwargs)
return instances[cls]
return get_instance
@Single
class B:
pass
# 方式二
class Single:
def __init__(self):
print("單例模式實現方式二。。。")
single=Single()
del Single # 每次調用single就可以了
# 方式三(最常用的方式)
class Single:
def __new__(cls,*args,**kwargs):
if not hasattr(cls,'_instance'):
cls._instance=super().__new__(cls,*args,**kwargs)
return cls._instance
工廠模式
class Dog:
def __init__(self):
print("Wang Wang Wang")
class Cat:
def __init__(self):
print("Miao Miao Miao")
def fac(animal):
if animal.lower()=="dog":
return Dog()
if animal.lower()=="cat":
return Cat()
print("對不起，必須是：dog,cat")
構造模式
class Computer:
def __init__(self,serial_number):
self.serial_number=serial_number
self.memory=None
self.hadd=None
self.gpu=None
def __str__(self):
info=(f'Memory:{self.memoryGB}',
'Hard Disk:{self.hadd}GB',
'Graphics Card:{self.gpu}')
return ''.join(info)
class ComputerBuilder：
def __init__(self):
self.computer=Computer('Jim1996')
def configure_memory(self,amount):
self.computer.memory=amount
return self #為了方便鏈式調用
def configure_hdd(self,amount):
pass
def configure_gpu(self,gpu_model):
pass
class HardwareEngineer:
def __init__(self):
self.builder=None
def construct_computer(self,memory,hdd,gpu)
self.builder=ComputerBuilder()
self.builder.configure_memory(memory).configure_hdd(hdd).configure_gpu(gpu)
@property
def computer(self):
return self.builder.computer
python實現各種數據結構
快速排序
def quick_sort(_list):
if len(_list) < 2:
return _list
pivot_index=0
pivot=_list(pivot_index)
left_list=[i for i in _list[:pivot_index] if i < pivot]
right_list=[i for i in _list[pivot_index:] if i > pivot]
return quick_sort(left) + [pivot] + quick_sort(right)
選擇排序
def select_sort(seq):
n=len(seq)
for i in range(n-1)
min_idx=i
for j in range(i+1,n):
if seq[j] < seq[min_inx]:
min_idx=j
if min_idx !=i:
seq[i], seq[min_idx]=seq[min_idx],seq[i]
插入排序
def insertion_sort(_list):
n=len(_list)
for i in range(1,n):
value=_list[i]
pos=i
while pos > 0 and value < _list[pos - 1]
_list[pos]=_list[pos - 1]
pos -=1
_list[pos]=value
print(sql)
歸并排序
def merge_sorted_list(_list1,_list2): #合并有序列表
len_a, len_b=len(_list1),len(_list2)
a=b=0
sort=[]
while len_a > a and len_b > b:
if _list1[a] > _list2[b]:
sort.append(_list2[b])
b +=1
else:
sort.append(_list1[a])
a +=1
if len_a > a:
sort.append(_list1[a:])
if len_b > b:
sort.append(_list2[b:])
return sort
def merge_sort(_list):
if len(list1)<2:
return list1
else:
mid=int(len(list1)/2)
left=mergesort(list1[:mid])
right=mergesort(list1[mid:])
return merge_sorted_list(left,right)
堆排序heapq模塊
from heapq import nsmallest
def heap_sort(_list):
return nsmallest(len(_list),_list)
棧
from collections import deque
class Stack:
def __init__(self):
self.s=deque()
def peek(self):
p=self.pop()
self.push(p)
return p
def push(self, el):
self.s.append(el)
def pop(self):
return self.pop()
隊列
from collections import deque
class Queue:
def __init__(self):
self.s=deque()
def push(self, el):
self.s.append(el)
def pop(self):
return self.popleft()
二分查找
def binary_search(_list,num):
mid=len(_list)//2
if len(_list) < 1:
return Flase
if num > _list[mid]:
BinarySearch(_list[mid:],num)
elif num < _list[mid]:
BinarySearch(_list[:mid],num)
else:
return _list.index(num)
好了，今天的分享就到這里，喜歡就點個贊吧！最后，如果你對軟件測試感興趣，歡迎百度搜索“特斯汀軟件測試騰訊課堂”或關注公眾號“特斯汀軟件測試”，里面涵蓋很多精彩免費視頻或干貨知識
*請認真填寫需求信息，我們會在24小時內與您取得聯系。
