整合營銷服務(wù)商
電腦端+手機(jī)端+微信端=數(shù)據(jù)同步管理
免費(fèi)咨詢熱線：
電腦端+手機(jī)端+微信端=數(shù)據(jù)同步管理
免費(fèi)咨詢熱線：
篇文章主要介紹了SpringBoot整合FastJson過程解析,文中通過示例代碼介紹得非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友可以參考下
<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的消息轉(zhuǎn)換器刪除.
備注: (1)源碼分析可知，返回json的過程為:
Controller調(diào)用結(jié)束后返回一個(gè)數(shù)據(jù)對象，for循環(huán)遍歷conventers，找到支持application/json的HttpMessageConverter，然后將返回的數(shù)據(jù)序列化成json。
具體參考o(jì)rg.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor的writeWithMessageConverters方法
(2)由于是list結(jié)構(gòu)，我們添加的fastjson在最后。因此必須要將jackson的轉(zhuǎn)換器刪除，不然會(huì)先匹配上jackson，導(dǎo)致沒使用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的字段,默認(rèn)為false,我們將它打開
SerializerFeature.WriteNullListAsEmpty, // 將Collection類型字段的字段空值輸出為[]
SerializerFeature.WriteNullStringAsEmpty, // 將字符串類型字段的空值輸出為空字符串
SerializerFeature.WriteNullNumberAsZero, // 將數(shù)值類型字段的空值輸出為0
SerializerFeature.WriteDateUseDateFormat,
SerializerFeature.DisableCircularReferenceDetect // 禁用循環(huán)引用
?
);
?
fastJsonHttpMessageConverter.setFastJsonConfig(config);
?
// 添加支持的MediaTypes;不添加時(shí)默認(rèn)為*/*,也就是默認(rèn)支持全部
?
// 但是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; // 數(shù)據(jù)刪除標(biāo)記, 0-已刪除 1-有效
以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，喜歡本文的小伙伴記得點(diǎn)贊關(guān)注收藏哦~
么么么么么么么么么么噠！老子愛你們！?( ′???)比心?( ′??? )比心?( ′???` )比心
我們從一段代碼說起，假設(shè)有一段這樣的 JSON 數(shù)據(jù)：
var json={
name: '流火',
blog: 'ued.taobao.org'
};
我們需要根據(jù)這段 JSON 生成這樣的 HTML 代碼：
流火 (blog: ued.taobao.org)
傳統(tǒng)的 JavaScript 代碼一定是這個(gè)樣子：
var html; html='' + json.name + ' (blog: ' + json.blog + ')';
不言而喻，這樣的代碼混雜了 HTML 結(jié)構(gòu)和代碼邏輯，而且代碼不具可讀性，不便于后期維護(hù)，于是便有了這樣一個(gè)函數(shù)：
function sub(str, data) {
return str.replace(/{(.*?)}/igm, function($, $1) {
return data[$1] ? data[$1] : $;
});
}
有了這個(gè)函數(shù)，我們拼接字符串的工作就可以簡化為：
var tpl='{name} (blog: {blog})';
var html=sub(tpl, json);
看到這里，不用我多說，我想通過這個(gè)例子直觀的展現(xiàn)出前端模板引擎的好處所在，這么做能夠完全剝離 HTML 和代碼邏輯，便于多人協(xié)作和后期的代碼維護(hù)。當(dāng)然，當(dāng)我們的業(yè)務(wù)邏輯需要對數(shù)據(jù)源進(jìn)行循環(huán)遍歷，if 判斷等的時(shí)候，這個(gè)簡明的函數(shù)很顯然并不能滿足我們的需求，于是便有了如今這市面上眾多的模板引擎，諸如 Mustache，jQuery tmpl，Kissy template，ejs，doT，nTenjin 等等。
“如無必要，勿增實(shí)體。”
這是著名的奧卡姆剃須刀法則，簡單的說就是避免重復(fù)造輪子。那么就會(huì)有童鞋質(zhì)疑，既然已然有這么多現(xiàn)成的東西可用，為什么還要重新打造一個(gè)呢？
我個(gè)人認(rèn)為一個(gè)完善的模板引擎應(yīng)該兼顧這幾點(diǎn)：
而市面上現(xiàn)有的模板引擎沒有做到兼顧以上幾點(diǎn)，比如 Mustache 支持多種語言，通用性不錯(cuò)，不過性能稍差，而且語法不支持高級特性，例如遍歷的時(shí)候無法做 if 判斷，也無法獲得 index 索引值，jQuery tmpl 依賴 jQuery，缺乏可移植性，Kissy template 雖然依賴 Kissy， 不過性能和語法都值得推薦，doT/nTenjin 性能和靈活性都很不錯(cuò)，但是語法需要用原生的js來寫，寫好的模板代碼可讀性稍差。
魚和熊掌不可兼得，語法的處理，安全性的輸出過濾和錯(cuò)誤處理機(jī)制的引入在一定程度上都會(huì)或多或少降低模板引擎的性能，因此就需要我們權(quán)衡。Juicer 在實(shí)現(xiàn)上首先將性能看做第一個(gè)重要的指標(biāo)，畢竟性能好壞直接影響用戶的感知，同時(shí)兼顧了安全性和錯(cuò)誤處理機(jī)制（即便這樣會(huì)導(dǎo)致性能的略微下降）。
首先來看下 jsperf 上同幾個(gè)主流模板引擎的性能對比。
可以看到，性能上比傳統(tǒng)模板引擎均有提升，下邊的介紹主要從語法、安全性和錯(cuò)誤處理，以及如何使用這幾個(gè)方面介紹下 Juicer.
詳細(xì)的語法請參考 Juicer Docs.
安全性，簡單地說就是對輸出數(shù)據(jù)在輸出前進(jìn)行一次轉(zhuǎn)義過濾，避免 XSS 這樣的腳本注入攻擊，簡單掃下盲，舉個(gè) XSS 的例子。
var json={
output: 'alert("XSS");'
};
如果 JSON 數(shù)據(jù)是第三方接口返回或者含有用戶輸入（像 BBS、評價(jià)）的內(nèi)容，我們?nèi)绻嗦懵愕膶?output 寫到頁面上就會(huì)執(zhí)行惡意的js代碼，所以 Juicer 默認(rèn)是對數(shù)據(jù)輸出做了安全轉(zhuǎn)義的，當(dāng)然如果不想被轉(zhuǎn)義，可以使用 $${varname}。
juicer.to_html('${output}',json);
//輸出：<script>alert("XSS");</script>
juicer.to_html('$${output}',json);
//輸出：<script>alert("XSS");</script>
如果沒有錯(cuò)誤處理，當(dāng)模板引擎編譯（Compile）或者渲染（Render）出錯(cuò)時(shí)候就會(huì)引起后續(xù)js代碼停止執(zhí)行，可想而知，如果因?yàn)橐粋€(gè)逗號或者 JSON 數(shù)據(jù)的偶發(fā)錯(cuò)誤導(dǎo)致整個(gè)頁面掛掉，是我們不能接受的。但是 Juicer 在遇到這些錯(cuò)誤的時(shí)候不會(huì)影響后續(xù)代碼的執(zhí)行，只會(huì)在控制臺(tái)打出一句警告（Warn）告知開發(fā)者模板解析出現(xiàn)錯(cuò)誤。
juicer.to_html('${varname,,,,,,,}', json);
alert('hello, juicer!');
執(zhí)行上邊的代碼就會(huì)看到控制臺(tái)打出的 Juicer Compile Exception: Unexpected token ,，但是不會(huì)因?yàn)殄e(cuò)誤導(dǎo)致后續(xù)的 alert被阻塞掉。
Juicer 對一個(gè)模板的編譯和渲染的過程主要有以下幾個(gè)步驟：
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;
}
是不是已經(jīng)明白了 Juicer 的原理？這個(gè)編譯后的函數(shù)就會(huì)每次幫我們完成從數(shù)據(jù)到 HTML 代碼的拼裝操作。
這里有幾點(diǎn)優(yōu)化的地方值得分享下：
這幾點(diǎn)優(yōu)化在大數(shù)據(jù)量循環(huán)渲染時(shí)候性能提升顯著，不過正因?yàn)榉艞壛?with{} 語句，所以 Juicer 會(huì)在編譯函數(shù)之前對模板進(jìn)行詞法分析，將用到的變量實(shí)現(xiàn)聲明，這樣就能避免 JSON 數(shù)據(jù)外層必須指定 data. 前綴，如果你覺得這點(diǎn)性能的提升不重要，也可以在 options 中指定 loose: false（禁用松散模式），這樣就可以不省去 data. 前綴，這樣做的好處就是性能會(huì)更好一些。
最后介紹下 Options 配置項(xiàng)，左側(cè)為參數(shù)默認(rèn)值。
{
cache: true/false,
loose: true/false,
strip: true/false,
errorhandling: true/false
}
cache 默認(rèn)為 true，即同一個(gè)模板編譯后是否被 Juicer 緩存，也就是說如果緩存開啟的情況下，同一個(gè)模板第一次編譯后，為了縮短耗時(shí)提升性能，后續(xù)不會(huì)再次執(zhí)行編譯的操作而是直接從緩存中去取編譯好的模板函數(shù)。
Juicer 有兩種使用方法，一種是通過
juicer(tpl, data); // 或者 juicer.to_html(tpl, data);
直接根據(jù)提供的數(shù)據(jù)將模板轉(zhuǎn)為 HTML 代碼，另一種是通過 compile 方法先將模板編譯好，在需要的時(shí)候再對模板進(jìn)行數(shù)據(jù)的 Render 操作：
var compiled_tpl=juicer(tpl); compiled_tpl.render(data); // 或者 var compiled_tpl=juicer.compile(tpl); compiled_tpl.render(data);
點(diǎn)贊+轉(zhuǎn)發(fā)，讓更多的人也能看到這篇內(nèi)容（收藏不點(diǎn)贊，都是耍流氓-_-）
關(guān)注 ｛我｝，享受文章首發(fā)體驗(yàn)！
每周重點(diǎn)攻克一個(gè)前端技術(shù)難點(diǎn)。更多精彩前端內(nèi)容私信 我 回復(fù)“教程”
原文鏈接：
作者：admin
于總結(jié)了太多的東西，所以篇幅有點(diǎn)長，這也是作者"縫縫補(bǔ)補(bǔ)"總結(jié)了好久的東西，強(qiáng)烈建議收藏再慢慢看~
Py2 和 Py3 的差別
#枚舉的注意事項(xiàng)
from enum import Enum
class COLOR(Enum):
YELLOW=1
#YELLOW=2#會(huì)報(bào)錯(cuò)
GREEN=1#不會(huì)報(bào)錯(cuò),GREEN可以看作是YELLOW的別名
BLACK=3
RED=4
print(COLOR.GREEN)#COLOR.YELLOW,還是會(huì)打印出YELLOW
for i in COLOR:#遍歷一下COLOR并不會(huì)有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
#枚舉轉(zhuǎn)換
#最好在數(shù)據(jù)庫存取使用枚舉的數(shù)值而不是使用標(biāo)簽名字字符串
#在代碼里面使用枚舉類
a=1
print(COLOR(a))# output:COLOR.YELLOW
py2/3 轉(zhuǎn)換工具
常用庫
不常用但很重要的庫
def isLen(strString):
#還是應(yīng)該使用三元表達(dá)式，更快
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 #相當(dāng)于實(shí)現(xiàn)了__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(函數(shù)名，（參數(shù)）) #此方法不會(huì)阻塞，會(huì)立即返回
task.done()#查看任務(wù)執(zhí)行是否完成
task.result()#阻塞的方法，查看任務(wù)返回值
task.cancel()#取消未執(zhí)行的任務(wù)，返回True或False,取消成功返回True
task.add_done_callback()#回調(diào)函數(shù)
task.running()#是否正在執(zhí)行 task就是一個(gè)Future對象
for data in pool.map(函數(shù)，參數(shù)列表):#返回已經(jīng)完成的任務(wù)結(jié)果列表，根據(jù)參數(shù)順序執(zhí)行
print(返回任務(wù)完成得執(zhí)行結(jié)果data)
from concurrent.futures import as_completed
as_completed(任務(wù)列表)#返回已經(jīng)完成的任務(wù)列表，完成一個(gè)執(zhí)行一個(gè)
wait(任務(wù)列表,return_when=條件)#根據(jù)條件進(jìn)行阻塞主線程，有四個(gè)條件
future=asyncio.ensure_future(協(xié)程) 等于后面的方式 future=loop.create_task(協(xié)程)
future.add_done_callback()添加一個(gè)完成后的回調(diào)函數(shù)
loop.run_until_complete(future)
future.result()查看寫成返回結(jié)果
asyncio.wait()接受一個(gè)可迭代的協(xié)程對象
asynicio.gather(*可迭代對象,*可迭代對象） 兩者結(jié)果相同，但gather可以批量取消，gather對象.cancel()
一個(gè)線程中只有一個(gè)loop
在loop.stop時(shí)一定要loop.run_forever()否則會(huì)報(bào)錯(cuò)
loop.run_forever()可以執(zhí)行非協(xié)程
最后執(zhí)行finally模塊中 loop.close()
asyncio.Task.all_tasks()拿到所有任務(wù) 然后依次迭代并使用任務(wù).cancel()取消
偏函數(shù)partial(函數(shù)，參數(shù))把函數(shù)包裝成另一個(gè)函數(shù)名 其參數(shù)必須放在定義函數(shù)的前面
loop.call_soon(函數(shù),參數(shù))
call_soon_threadsafe()線程安全
loop.call_later(時(shí)間,函數(shù),參數(shù))
在同一代碼塊中call_soon優(yōu)先執(zhí)行，然后多個(gè)later根據(jù)時(shí)間的升序進(jìn)行執(zhí)行
如果非要運(yùn)行有阻塞的代碼
使用loop.run_in_executor(executor,函數(shù)，參數(shù))包裝成一個(gè)多線程，然后放入到一個(gè)task列表中，通過wait(task列表)來運(yùn)行
通過asyncio實(shí)現(xiàn)http
reader,writer=await asyncio.open_connection(host,port)
writer.writer()發(fā)送請求
async for data in reader:
data=data.decode("utf-8")
list.append(data)
然后list中存儲(chǔ)的就是html
as_completed(tasks)完成一個(gè)返回一個(gè),返回的是一個(gè)可迭代對象
協(xié)程鎖
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只能適用于兩個(gè)進(jìn)程
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()設(shè)置系統(tǒng)編碼方式
class A(dict):
def __getattr__(self,value):#當(dāng)訪問屬性不存在的時(shí)候返回
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):# 每個(gè)測試用例執(zhí)行前執(zhí)行
print('本方法開始測試了')
def setUp(self):# 每個(gè)測試用例執(zhí)行之前做操作
print('本方法測試結(jié)束')
@classmethod
def tearDownClass(self):# 必須使用 @ classmethod裝飾器, 所有test運(yùn)行完后運(yùn)行一次
print('開始測試')
@classmethod
def setUpClass(self):# 必須使用@classmethod 裝飾器,所有test運(yùn)行前運(yùn)行一次
print('結(jié)束測試')
def test_a_run(self):
self.assertEqual(1, 1) # 測試用例
for gevent import monkey
monkey.patch_all() #將代碼中所有的阻塞方法都進(jìn)行修改，可以指定具體要修改的方法
co_flags=func.__code__.co_flags
# 檢查是否是協(xié)程
if co_flags & 0x180:
return func
# 檢查是否是生成器
if co_flags & 0x20:
return func
#一只青蛙一次可以跳上1級臺(tái)階，也可以跳上2級。求該青蛙跳上一個(gè)n級的臺(tái)階總共有多少種跳法。
#請問用n個(gè)2*1的小矩形無重疊地覆蓋一個(gè)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級臺(tái)階，也可以跳上2級……它也可以跳上n級。求該青蛙跳上一個(gè)n級的臺(tái)階總共有多少種跳法。
fib=lambda n: n if n < 2 else 2 * fib(n - 1)
import os
os.getenv(env_name,None)#獲取環(huán)境變量如果不存在為None
#查看分代回收觸發(fā)
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]=[] # 可以用于實(shí)現(xiàn)python版反射
# 方法二
for i in list1:
exec(f'{i}=[]') # exec執(zhí)行字符串語句
# bytearray是可變的，bytes是不可變的,memoryview不會(huì)產(chǎn)生新切片和對象
a='aaaaaa'
ma=memoryview(a)
ma.readonly # 只讀的memoryview
mb=ma[:2] # 不會(huì)產(chǎn)生新的字符串
a=bytearray('aaaaaa')
ma=memoryview(a)
ma.readonly # 可寫的memoryview
mb=ma[:2] # 不會(huì)會(huì)產(chǎn)生新的bytearray
mb[:2]='bb' # 對mb的改動(dòng)就是對ma的改動(dòng)
# 代碼中出現(xiàn)...省略號的現(xiàn)象就是一個(gè)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) #其相當(dāng)于執(zhí)行的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將字符串轉(zhuǎn)化為安全的文件名
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
#這里只有l(wèi)ocaltime可以被格式化，time是不能格式化的
time.strftime("%Y-%m-%d",time.localtime())
# 會(huì)報(bào)錯(cuò)，但是tuple的值會(huì)改變，因?yàn)閠[1]id沒有發(fā)生變化
t=(1,[2,3])
t[1]+=[4,5]
# t[1]使用append\extend方法并不會(huì)報(bào)錯(cuò)，并可以成功執(zhí)行
class Mydict(dict):
def __missing__(self,key): # 當(dāng)Mydict使用切片訪問屬性不存在的時(shí)候返回的值
return key
# +不能用來連接列表和元祖，而+=可以（通過iadd實(shí)現(xiàn)，內(nèi)部實(shí)現(xiàn)方式為extends(),所以可以增加元組），+會(huì)創(chuàng)建新對象
#不可變對象沒有__iadd__方法，所以直接使用的是__add__方法，因此元祖可以使用+=進(jìn)行元祖之間的相加
dict.fromkeys(['jim','han'],21) # output:{'jim': 21, 'han': 21}204 No Content //請求成功處理，沒有實(shí)體的主體返回，一般用來表示刪除成功
206 Partial Content //Get范圍請求已成功處理
303 See Other //臨時(shí)重定向，期望使用get定向獲取
304 Not Modified //請求緩存資源
307 Temporary Redirect //臨時(shí)重定向，Post不會(huì)變成Get
401 Unauthorized //認(rèn)證失敗
403 Forbidden //資源請求被拒絕
400 //請求參數(shù)錯(cuò)誤
201 //添加或更改成功
503 //服務(wù)器維護(hù)或者超負(fù)載
# environ：一個(gè)包含所有HTTP請求信息的dict對象
# start_response：一個(gè)發(fā)送HTTP響應(yīng)的函數(shù)
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開頭的，應(yīng)改成：
select id from t where name like 'abc%'
例如：
select id from t where datediff(day, createdate, '2005-11-30')=0 – '2005-11-30';
應(yīng)改為:
不要在 where 子句中的 “=” 左邊進(jìn)行函數(shù)、算術(shù)運(yùn)算或其他表達(dá)式運(yùn)算，否則系統(tǒng)將可能無法正確使用索引
應(yīng)盡量避免在 where 子句中對字段進(jìn)行表達(dá)式操作，這將導(dǎo)致引擎放棄使用索引而進(jìn)行全表掃描
如：
select id from t where num/2=100
應(yīng)改為:
select id from t where num=100*2；
不適合鍵值較少的列（重復(fù)數(shù)據(jù)較多的列）比如：set enum列就不適合(枚舉類型(enum)可以添加null,并且默認(rèn)的值會(huì)自動(dòng)過濾空格集合(set)和枚舉類似，但只可以添加64個(gè)值)
如果MySQL估計(jì)使用全表掃描要比使用索引快，則不使用索引
單例模式
# 方式一
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("單例模式實(shí)現(xiàn)方式二。。。")
single=Single()
del Single # 每次調(diào)用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")
構(gòu)造模式
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 #為了方便鏈?zhǔn)秸{(diào)用
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實(shí)現(xiàn)各種數(shù)據(jù)結(jié)構(gòu)
快速排序
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()
隊(duì)列
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)
好了，今天的分享就到這里，喜歡就點(diǎn)個(gè)贊吧！最后，如果你對軟件測試感興趣，歡迎百度搜索“特斯汀軟件測試騰訊課堂”或關(guān)注公眾號“特斯汀軟件測試”，里面涵蓋很多精彩免費(fèi)視頻或干貨知識(shí)
*請認(rèn)真填寫需求信息，我們會(huì)在24小時(shí)內(nèi)與您取得聯(lián)系。
