python操作es

❶ python-ES即時刷新file system cache

概要

原理

解決
對於需要寫入後實時查詢的數據，可以通過手動 refresh 操作將 memory buffer 的數據立即寫入到 File system cache 。當然，該解決方案的代價就是降低了ES的寫性能。

源碼提供的方法支持refresh參數，默認False，可傳True，wait_for。
wait_for：隻影響當前用戶處理的請求，其他用戶並發的操作並不影響；
true：影響所有用戶正在處理的請求，會更新所有分片，效率最低；
false：更新數據之後不立刻刷新，在返回結果之後的某個時間點會自動刷新，也就是隨機的；

實時性要求較高，犧牲效率滿足。
應用場景，根據自己項目需求來。

❷ python查詢ES

注意：elasticsearch 的版本不能太高，建議安裝7.13.0

pip install elasticsearch ==7.13.0

from elasticsearch import Elasticsearch

import logging

logger = logging.getLogger("inquiry_es")

logging.basicConfig(filename="logs/logging.txt",

                    level=logging.INFO,

                    format='{"time":"%(asctime)s","script":"%(name)s","thread":"%(thread)d",'

                          '"threadName":"%(threadName)s","loglevel":"%(levelname)s"} - %(message)s')

class search_es:

    def __init__(self,host,port="9200",user=None,passwd=None):

        self.host = host

        self.user = user

        self.passwd = passwd

        self.port = port

        self.es = Elasticsearch([f"{self.host}:{self.port}"]) if user is None else \

            Elasticsearch([f"{self.host}:{self.port}"],http_auth=(self.user, self.passwd))

    # 獲取所有的index

    def get_indices(self):

        # for index in self.es.indices.get('*'):

        #    print(index)

        # indices = self.es.indices.get('*')

        indices = self.es.indices.get_alias().keys()

        indices = sorted(indices)

        # print(indices)

        return indices

    # 查詢index

    def get_es(self,index,body={"size":10000,"query": {"match_all":{}}}):

        """

        提交查詢參數，返回結果

        :return: es_data

        """

        try:

            logger.info(f"開始查詢:{index}")

            # print(self.es.index)

            es_data = self.es.search(index=index,  body=body)

            logger.info(es_data)

            return es_data

        except Exception as e:

            logger.error(f"error:{e}", exc_info=True, stack_info=True)

            return {}

❸ espython索引保存到文件

、es庫連接

from elasticsearch import Elasticsearch
es = Elasticsearch(["x.x.x.x: 9200"])
2、將文檔(txt、word、excel)內容存入到es庫

存儲思路：不同類型的文檔設置不同的額索引名稱，從es庫中查詢文檔時相對比較方便，將文件名稱、文件內容處理成字元串存入到es庫
文件內容讀取方式：

word文檔使用 Document() 方法；txt文檔使用open()方法；excel使用 xlrd.open_workbook()方法

3、根據關鍵字從es庫獲取到相關文檔

將關鍵字參數放在es.search()方法中即可查詢到在哪些文檔中出現過該關鍵字

es.search(index="XX", doc_type="XX", body={"query": {"match": {"word_info": "關鍵字參數"}}}, filter_path=['hits.hits._source'])

❹ pythones關閉連接

在try中進行ssh連接及sftp連接，並進行連接後的操作，except中捕獲異常，finally中無論兩個連接對象獲取是否成功都會執行，關閉ssh及sftp連接。

先使用hasattr方法及callable判斷對象是否存在close方法且是否可調用，再調用close方法關閉連接對象，避免某個連接失敗時調用close方法出現錯誤。

以上方式同樣適用於其他連接，比如MySQL的連接對象及游標對象的關閉。

❺ python3種數據類型

Python3 中有六個標準的數據類型：Number（數字） + String（字元串） + List（列表） + Tuple（元組） + Sets（集合） + Dictionary（字典）。
Number（數字）
數字類型是顧名思義是用來存儲數值的，需要記住的是，有點和Java的字元串味道差不多，如果改變了數字數據類型的值，將重新分配內存空間。
可以使用del語句刪除一些數字對象的引用：del var1[,var2[,var3[....,varN]]]]。
Python 支持三種不同的數值類型：
1.整型(Int) - 通常被稱為是整型或整數，是正或負整數，不帶小數點。Python3 整型是沒有限制大小的，可以當作 Long 類型使用，所以 Python3 沒有 Python2 的 Long 類型。
2.浮點型(float) - 浮點型由整數部分與小數部分組成，浮點型也可以使用科學計數法表示（2.5e2 = 2.5 x 102 = 250）
3.復數( (complex)) - 復數由實數部分和虛數部分構成，可以用a + bj,或者complex(a,b)表示， 復數的實部a和虛部b都是浮點型。
數字類型轉換
1.int(x) 將x轉換為一個整數。
2.float(x) 將x轉換到一個浮點數。
3.complex(x) 將x轉換到一個復數，實數部分為 x，虛數部分為 0。
4.complex(x, y) 將 x 和 y 轉換到一個復數，實數部分為 x，虛數部分為 y。x 和 y 是數字表達式。
額外說明
和別的語言一樣，數字類型支持各種常見的運算，不過python的運算比別的大多數常見語言都更加豐富，此外，還有大量豐富的方法，提供更高效的開發。
String（字元串）
創建字元串
創建字元串可以使用單引號、雙引號、三單引號和三雙引號，其中三引號可以多行定義字元串，有點類似ES6中的反引號。
Python 不支持單字元類型，單字元也在Python也是作為一個字元串使用。
訪問字元串中的值
和ES一樣，可以使用方括弧來截圖字元串，例子如下：
val_str='yelloxing'

print(val_str[0]) #y

print(val_str[1:3]) #el

print(val_str[:3]) #yel

print(val_str[:5]) #yello

字元串運算符
除了上面已經說明的方括弧，還有一些別的字元串運算，具體查看文檔。
字元串格式化
temp="我叫 %s 今年 %d 歲!" % ('心葉', 7)

print('['+temp+']') #[我叫 心葉 今年 7 歲!]

如上所示，字元串支持格式化，當然，出來上面用到的%s和%d以外，還有一些別的，具體看文檔；是不是感覺有點C語言的味道。
額外說明
所有的字元串都是Unicode字元串（針對python3），有很多有用的方法，真的很有ES和C結合體的味道。
List（列表）
序列是Python中最基本的數據結構。序列中的每個元素都分配一個數字 - 它的位置，或索引，第一個索引是0，第二個索引是1，依此類推。
Python有6個序列的內置類型（列表、元組、字元串、Unicode字元串、buffer對象和xrange對象）。
列表其實類似數組，具體的一些操作就很像字元串（類似ES中數組和字元串的關系）。
常見運算
下面用一個例子來展示一些常見的運算：
val_arr=['Made','in','China']

del val_arr[1]

print(val_arr) #['Made', 'China']

print(len(val_arr)) #2

val_newarr=val_arr+[':information']

print(val_newarr) #['Made', 'China', ':information']

val_arr=val_arr*2

print(val_arr) #['Made', 'China', 'Made', 'China']

print('in' in val_arr) #False

print('Made' in val_arr) #True

for row in val_newarr:

print(row, end=" - ") #Made - China - :information -

print(val_newarr[-1]) #:information

print(val_newarr[1:]) #['China', ':information']

再來看一個有用的例子：
cols=3

rows=2

list_2d = [[0 for col in range(cols)] for row in range(rows)]

print(list_2d) #[[0, 0, 0], [0, 0, 0]]

嵌套列表
使用嵌套列表即在列表裡創建其它列表，例如：
loop_arr=['yelloxing','心葉']

result_arr=[loop_arr,'同級別']

print(result_arr) #[['yelloxing', '心葉'], '同級別']

列表的嵌套就很靈活，此外隨便提一下：和前面說的一樣，也有很多方法提供高效的開發。
Tuple（元組）
元組與列表類似，不同之處在於元組的元素不能修改，元組使用小括弧，列表使用方括弧。
創建
元組中只包含一個元素時，需要在元素後面添加逗號，否則括弧會被當作運算符使用
tup1 = ('Google', 'Runoob', 1997, 2000);

tup2 = (1, 2, 3, 4, 5 );

tup3 = "a", "b", "c", "d";

print(tup1) #('Google', 'Runoob', 1997, 2000)

print(tup2) #(1, 2, 3, 4, 5)

print(tup3) #('a', 'b', 'c', 'd')

基本操作
和列表的操作很相似，下面說一個幾天特殊的地方：
1.del可以刪除某個元組，不過不可以刪除元組的某個條目。
2.不可以修改，或許元組會更快，感覺的，沒有實際測試。
3.由於元組不可以修改，雖然同樣有一些方法，不過和修改相關的方法就沒有了。
Sets（集合）
回想一下數學裡面的集合，合、交、差、補等運算是不是一下子回想起來了，這里的集合也有這些方法。
和Java的集合類似，一個無序不重復元素集（與列表和元組不同，集合是無序的，也無法通過數字進行索引）。
更具體的說明，如果必要會在單獨說明。
Dictionary（字典）
字典是另一種可變容器模型，且可存儲任意類型對象。
字典的每個鍵值(key=>value)對用冒號(:)分割，每個對之間用逗號(,)分割，整個字典包括在花括弧({})中，鍵必須是唯一的，但值則不必。
和ES中的JSON的差不多，操作也很像，不過區別也很大，內置方法很多，具體還是一樣，看文檔去。
刪除字典元素
可以用del刪除一個條目或字典，也可以用clear()方法清空字典（比如現在有欄位dict，就是：dict.clear()）。

❻ python自帶及pandas、numpy數據結構(一)

1.python自帶數據結構：序列（如list）、映射（如字典）、集合（set）。
以下只介紹序列中的list：
創建list：
list1 = []
list1 = [1,2,3,4,5,6,7,8,9] #逗號隔開
list2 = [[1,2],[3,4],[5,6],[7,8]] #list2長度(len(list2))為2,list2[0] = [1,2]
liststring = list(「thisisalist」) #只用於創建字元串列表
索引list：
e = list1[0] #下標從零開始，用中括弧
分片list：
es = list1[0:3]
es = list1[0:9:2] #步長在第二個冒號後
list拼接（list1.append(obj)、加運算及乘運算）：

list長度：

list每個元素乘一個數值：
list2 = numpy.dot(list2,2)
list類似矩陣相乘（每個元素對應相乘取和）：
list3 = numpy.dot(list1,list1)
#要求相乘的兩個list長度相同
list3 = numpy.dot(list2,list22)
#要求numpy.shape(list2)和numpy.shape(list22)滿足「左行等於右列」的矩陣相乘條件，相乘結果numpy.shape(list3)滿足「左列右行」

2.numpy數據結構：

Array：
產生array：
data=np.array([[1, 9, 6], [2, 8, 5], [3, 7, 4]])
data=np.array(list1)
data1 = np.zeros(5) #data1.shape = (5,),5列
data1 = np.eye(5)
索引array:
datacut = data[0,2] #取第零行第二列，此處是6
切片array：
datacut = data[0:2,2] # array([6, 5])
array長度：
data.shape
data.size
np.shape(data)
np.size(data)
len(data)
array拼接：
#括弧內也有一個括弧（中括弧或者小括弧）！
d = np.concatenate((data,data))
d = np.concatenate((data,data),axis = 1) #對應行拼接
array加法：逐個相加
array乘法：
d = data data #逐個相乘
d = np.dot(data,data) #矩陣相乘
d = data 3 #每個元素乘3
d = np.dot(data,3) #每個元素乘3
array矩陣運算：
取逆 : np.linalg.inv(data)
轉置：data.T
所有元素求和 : np.sum(data)
生成隨機數：np.random.normal(loc=0, scale=10, size=None)
生成標准正態分布隨機數組：np.random.normal(size=(4,4))
生成二維隨機數組：
np.random.multivariate_normal([0,0],np.eye(2))
生成范圍在0到1之間的隨機矩陣(M,N)：
np.random.randint(0,2,(M,N))

Matrix:
創建matrix：
mat1 = np.mat([[1, 2, 3], [4, 5, 6]])
mat1 = np.mat(list)
mat1 = np.mat(data)
matrix是二維的，所有+，-，*都是矩陣操作。
matrix索引和分列：
mat1[0:2，1]
matrix轉置：
np.transpose(mat1)
mat1.transpose()
matrix拼接：
np.concatenate([mat1,mat1])
np.concatenate([mat1,mat1],axis = 1)

numpy數據結構總結：對於numpy中的數據結構的操作方法基本相同：
創建：np.mat(list),np.array(list)
矩陣乘：np.dot(x,y)
轉置：x.T or np.transpose(x)
拼接：np.concatenate([x,y],axis = 1)
索引：mat[0:1,4],ary[0:1,4]

3.pandas數據結構:
Series:
創建series：
s = pd.Series([[1,2,3],[4,5,6]],index = [『a』,『b』])
索引series：
s1 = s[『b』]
拼接series：
pd.concat([s1,s1],axis = 1) #也可使用s.append(s)

DataFrame:
創建DaraFrame:
df = pd.DataFrame([[1,2,3],[1,2,3]],index = ['a','b'],columns = ['x','y','z'])
df取某一列：
dfc1 =df.x
dfc1 = df[『x』]
dfc2 = df.iloc[:,0] #用.iloc方括弧里是數字而不是column名！
dfc2 = df.iloc[:,0:3]
df取某一行：
dfr1 = df.iloc[0]
df1 = df.iloc[0:2]
df1 = df[0:2] #這種方法只能用於取一個區間
df取某個值：
dfc2 = df.iloc[0,0]
dfc2 = df.iloc[0:2,0:3]