# 第一种方法
filename = "/home/tucodec/ZJU.mp4"
str_1 = filename[filename.rindex("."):] # rindex：返回最后一个'.'的位置信息
print(str1) # 输出“.mp4”

# 第二种方法
str_1 = filename.split('.')[-1]

def all_path(dirname):
    result = []
    for maindir, subdir, file_name_list in os.walk(dirname):
        for filename in file_name_list:
            apath = os.path.join(maindir, filename)
            result.append(apath)
    return result

result = [] 
alllist=os.listdir("/Users/wxj/Desktop/1")
for i in alllist:
    if "." in i:
        aa, bb=i.split(".")
        if bb == "txt":
            result.append(aa+"."+bb)

import glob
list_1 = glob.glob('*.jpg')
# ['2.jpg', '1.jpg', '5.jpg']
sorted(list_1)
# ['1.jpg', '2.jpg', '5.jpg']

seq1 = ['hello','good','boy','doiido']
print ' '.join(seq1) # 已空格符连接一个list中的字符串
输出：hello good boy doiido
===============================================
os.path.join('/hello/','good/boy/','doiido') # 合并目录，注意‘/’不能多写
输出：'/hello/good/boy/doiido' # 这样可以正确处理不同操作系统的路径分隔符
===============================================
a = '/hello/'
b = 'good/boy/'
print(a+b)  
输出：'/hello/good/boy/'

line = "我们 大 中国"
line.split()
['我们', '大', '中国']

s.strip(rm)        #删除s字符串中开头、结尾处，位于rm删除序列的字符
s.lstrip(rm)       #删除s字符串中开头处
s.rstrip(rm)      #删除s字符串中结尾处
# rm删除序列是只要边（开头或结尾）上的字符在删除序列内，就删除掉
a = '123abc'
a.strip('21')
a.strip('12')
# 结果是一样的：'3abc'

if True:
    msg = 'I am from Runoob'
print(msg)  # 'I am from Runoob'
#=============global=======nonlocal===================
global str1 # 在给全局变量str1赋值时，需要先声明global，否则str1会被当作新定义的局部变量
str1 = "new year"
str2 = str1 # 全局变量赋值给另一个局部变量时，不需global声明，程序会先找局部变量str1，没得话就去全局变量区域找
def func():
    str1 = "中国"
    def func_1():
        nonlocal str1
        str1 = "南京"  #修改嵌套作用域（函数A的变量作用在子函数B时）中的变量需要使用 nonlocal 关键字

dict1 = {'1':'飞机','2':'自行车','3':'鸟','4':'船','5':'瓶子','6':'公共汽车','7':'车','8':'猫','9':'椅子','10':'牛','11':'餐桌','12':'狗', \
    '13':'马','14':'摩托车','15':'人','16':'植物','17':'羊','18':'沙发','19':'火车','20':'电视'}
    for str_i in list(A):
    List.append(dict1[str_i]) #listA中是一个纯数字列表，LIST中对应其在字典中的真实类别

f.write(name + '\n') # write只能写入str
f.writelines(text) # 自动迭代写入一个字符串列表[str]

import os
f = sorted(os.listdir())
n = 0
for i in f:
    if n < 9:
        oldname = f[n]
        newname = "000"+str(n+1)+".jpg"
        os.rename(oldname, newname)
        print(oldname, "-------->", newname)
    elif n < 99:
        oldname = f[n]
        newname = "00"+str(n+1)+".jpg"
        os.rename(oldname, newname)
        print(oldname, "-------->", newname)
    elif n < 999:
        oldname = f[n]
        newname = "0"+str(n+1)+".jpg"
        os.rename(oldname, newname)
        print(oldname, "-------->", newname)
    n += 1

import socket
HOST, PORT = '', 8888 # Server端网络IP及端口
listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
listen_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
listen_socket.bind((HOST, PORT))
listen_socket.listen(1)  #设置监听，最多有5个端排队等侯
print 'Serving HTTP on port %s ...' % PORT  # 开启了一个侦听socket
while True:
  coon, addr = listen_socket.accept()  # 开启一个永续循环，被动等待客户端连接
  request = coon.recv(1024) # 接收bytes类型数据，每次接收1024b
  accept_data = str(request, encoding="utf8") 
  #print(request)
  print("".join(("接收内容：", accept_data, "    客户端口：", str(addr[1]))))
 
  http_response = "Hello World!"
 
  conn.sendall(bytes(http_response, encoding="utf8"))  # 重新建立连接后，返回一个服务器中预定义的字符串
  coon.close()

import socket
sk = socket.socket()
sk.connect(("192.168.1.136", 8888))  # 与局域网内Server端IP地址Connect
send_data = "Hello Server"
sk.sendall(bytes(send_data, encoding="utf8"))
accept_data = sk.recv(1024)
print(str(accept_data, encoding="utf8")) # 接收到Server端发来的“Hello World!”
sk.close()

import os,socket,hashlib
# ...
# socket监听定义
# ...
while True:
    conn, addr = listen_socket.accept()
    request = conn.recv(1024)
    data = str(request, encoding="utf8")
    print("接收内容：", data)
    filename = "/home/tucodec/ZJU.mp4"
    if os.path.isfile(filename):
        f = open(filename,"rb")
        m = hashlib.md5() # 哈希码用来加密文件
        file_size = os.stat(filename).st_size
        conn.send(str(file_size).encode("utf-8")) # send size to client，计算需要循环多少个1024 byte
        conn.recv(1024) # 联系两个send会发生粘包，加一个recv
        for line in f:
            m.update(line)
            conn.send(line) # 循环发送
        f.close()
    print("send done...")

import socket,hashlib
while True:
	sk = socket.socket()
	sk.connect(("192.168.1.136", 8888))  # 主动初始化与服务器端的连接
	while True:
		strs = input("请输入：")
		if len(strs) == 0:
			continue
		sk.send(bytes(strs, encoding="utf8"))
		server_resp_size = sk.recv(1024)  # 接收send_filesize，bytes类型的数据
		file_total_size = int(server_resp_size.decode()) # 格式转换
		sk.send(bytes("开始接收文件...", encoding="utf8"))
		f = open('new.mp4', "wb")
		m = hashlib.md5()
		recv_size = 0
		while recv_size < file_total_size:
		    if file_total_size - recv_size > 1024:   #最后一次接收之前,接收大小设置为1024
		        size = 1024
		    else:                                    #最后一次不足1024，则只接收文件剩余的部分
		        size = file_total_size - recv_size
		    data = sk.recv(size)
		    recv_size += len(data)
		    f.write(data)
		    m.update(data)
		f.close()
		sk.close()
		break

#!/usr/bin/env python

import asyncio
import websockets

async def hello(websocket, path):
    name = await websocket.recv()
    print("< {}".format(name))

    greeting = "Hello {}!".format(name)
    await websocket.send(greeting)
    print("> {}".format(greeting))

start_server = websockets.serve(hello, '', 8888)

asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

#!/usr/bin/env python

import asyncio
import websockets

async def hello():
    async with websockets.connect('ws://192.168.1.136:8888') as websocket:
        name = input("What's your name? ")
        await websocket.send(name)
        print("> {}".format(name))

        greeting = await websocket.recv()
        print("< {}".format(greeting))

asyncio.get_event_loop().run_until_complete(hello())

def n_similarity(self, ws1, ws2):
    v1 = [self[word] for word in ws1]
    v2 = [self[word] for word in ws2]
    return dot(matutils.unitvec(array(v1).mean(axis=0)), matutils.unitvec(array(v2).mean(axis=0)))

# -*- coding:utf-8 -*-
#!/usr/bin/env Python
from gensim.models import Word2Vec
import sys
import jieba
jieba.load_userdict("dict.txt")
class ResultInfo(object):
    def __init__(self, index, score, text):
        self.id = index
        self.score = score
        self.text = text

target = "target.txt" # 问题集合
model = "./model/word2vec"

model_w2v = Word2Vec.load(model) #加载模型 文字摘要
print ("模型加载成功！")
candidates = []
with open(target) as f:
    for line in f:
        candidates.append(line.strip().split()) # candidates列表中加载所有问题，
并用空格分割
while True:
    text = input("请输入查询指令： ")
    words = list(jieba.cut(text.strip()))
    if len(words) == 0:
        continue
    flag = False
    for w in words:
        if w not in model_w2v.wv.vocab:
            print ("输入指令中词汇“%s”不在字典中" % w)
            flag = True
    if flag:
        continue
    res = []
    index = 0
    for candidate in candidates:
        score = model_w2v.n_similarity(words, candidate)
        res.append(ResultInfo(index, score, " ".join(candidate)))
        index += 1
    res.sort(key=lambda x:x.score, reverse=True)
    for i in res:
        print i.text # 输出相似度最高的语句

# -*- coding:utf-8 -*-

import gensim
import smart_open
import multiprocessing
import logging
from gensim.models.doc2vec import TaggedDocument, Doc2Vec

import sys
reload(sys)
sys.setdefaultencoding('utf-8')

data_set = "pre0"

def read_corpus(fname, tokens_only=False):
    with smart_open.smart_open(fname, encoding="utf-8") as f:
        for i, line in enumerate(f):
            if tokens_only:
                yield gensim.utils.simple_preprocess(line)
            else:
                text = line.split()
                yield TaggedDocument(text[:], [i])


train_data = list(read_corpus(data_set))
print len(train_data)

logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
model = Doc2Vec(size=100, min_count=1, iter=10, workers=multiprocessing.cpu_count())
model.build_vocab(train_data)
model.train(train_data, total_examples=model.corpus_count, epochs=100)
model.save('./model/model_new.doc2vec')

#!/usr/bin/python
# -*- coding: utf-8 -*- 

import sys
import re
import io

reload(sys)
sys.setdefaultencoding('utf-8')

def pre_process(input_file, output_file):
    multi_version = re.compile(ur'-\{.*?(zh-hans|zh-cn):([^;]*?)(;.*?)?\}-')
    punctuation = re.compile(u"[-~!@#$%^&*()_+`=\[\]\\\{\}\"|;':,./<>?·！@#￥%……&*（）——+【】、；‘：“”，。、《》？「『」』]")
    with io.open(output_file, mode = 'w', encoding = 'utf-8') as outfile:
        with io.open(input_file, mode = 'r', encoding ='utf-8') as infile:
            for line in infile:
                line = multi_version.sub(ur'\2', line)
                line = punctuation.sub('', line.decode('utf8'))
                outfile.write(line)

if __name__ == '__main__':
    if len(sys.argv) != 3:
        print "Usage: python pre1.py input_file output_file"
        sys.exit()
    input_file, output_file = sys.argv[1], sys.argv[2]
    pre_process(input_file, output_file)

#!/usr/bin/python
# -*- coding: utf-8 -*-

import sys
import io
import jieba

reload(sys)
sys.setdefaultencoding('utf-8')

jieba.load_userdict("dict.txt") # 如果有的话加载用户自定义词典


def cut_words(input_file, output_file):
    count = 0
    a = 1 # 标识符
    with io.open(output_file, mode = 'w', encoding = 'utf-8') as outfile:
        with io.open(input_file, mode = 'r', encoding = 'utf-8') as infile:
            for line in infile:
                if a == -1:
                    a = a*(-1)
                    continue
                line = line.strip() 
                if len(line) < 1: 
                    continue
                # 移除字符串首尾的\r \n 空格等字符，此处希望一篇文章的所有内容位于一行，使得训练预料更规整
                if line.startswith('doc'):
                    if line == 'doc': 
                        outfile.write(u'\n') 
                        count += 1
                        str = "已完成 %d 篇百科文章转换" % (count)
                        print str 
                    else:
                        a = -1
                        continue
                else:
                    for word in jieba.cut(line):
                        outfile.write(word + ' ')

if __name__ == '__main__':
    if len(sys.argv) < 3:
        print "Terminal Format: python script.py input_file output_file"
        sys.exit()
    input_file, output_file = sys.argv[1], sys.argv[2]
    cut_words(input_file, output_file)

#!/usr/bin/python
# -*- coding: utf-8 -*- 
#程序功能是为了完成判断文件中是否有重复句子
#并将重复句子打印出来

import shutil
res_list = set()
f = open('pre2','r')
w = open('pre3', 'w')
k = 1
index = 0
for line in f.readlines():
    index = index + 1
    if line in res_list:
        k = k + 1
        print("Repeat", k, "All:", index, "Percent: %.5f%%" % (100*k/index))
    else:
        res_list.add(line)
        w.write(line)

#!/usr/bin/python
# -*- coding: utf-8 -*-

import os, sys
import multiprocessing
import gensim  
import logging

reload(sys)
sys.setdefaultencoding('utf-8')

def word2vec_train(input_file, output_file):
    logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
    sentences = gensim.models.word2vec.LineSentence(input_file)
    model = gensim.models.Word2Vec(sentences, size=800, window=5, min_count=3, iter=100,sg=0, workers=multiprocessing.cpu_count())
    # model.train(sentences, total_examples=model.corpus_count, epochs = 100) 默认参数，也可以指定
    model.save(output_file)

if __name__ == '__main__':
    if len(sys.argv) < 3:
        print "Terminal Format: python script.py infile outfile"
        sys.exit()
    input_file, output_file = sys.argv[1], sys.argv[2]
    word2vec_train(input_file, output_file)

#encoding=utf-8
import gensim
from gensim.models import word2vec
model=gensim.models.Word2Vec.load('word2vec')
print "模型加载成功！"
print "----词向量维度------"
print len(model[u'男人'])
print "----跟“滋润”相近的词------"
for i in model.most_similar(u"滋润"):
    print i[0],i[1]

deploy:
  type: git
  repository: git@github.com:Wxjwjj/Wxjwjj.github.io.git  
  branch: master
``` 

##### 保存后，执行如下命令使用git部署，便会同步到Github目录

``` bash
$ npm install hexo-deployer-git --save
$ hexo deploy