distanceTransform

Calculates the distance to the closest zero pixel for each pixel of the source image.





Python: cv2.distanceTransform(src, distanceType, maskSize[, dst]) → dst



Python: cv.DistTransform(src, dst, distance_type=CV_DIST_L2, mask_size=3, mask=None, labels=None) → None

Parameters:	

src – 8-bit, single-channel (binary) source image.

dst – Output image with calculated distances. It is a 32-bit floating-point, single-channel image of the same size as src .

distanceType – Type of distance. It can be CV_DIST_L1, CV_DIST_L2 , or CV_DIST_C .

maskSize – Size of the distance transform mask. It can be 3, 5, or CV_DIST_MASK_PRECISE (the latter option is only supported by the first function). In case of the CV_DIST_L1 or CV_DIST_C distance type, the parameter is forced to 3 because a  3\times 3 mask gives the same result as  5\times 5 or any larger aperture.

labels – Optional output 2D array of labels (the discrete Voronoi diagram). It has the type CV_32SC1 and the same size as src . See the details below.

labelType – Type of the label array to build. If labelType==DIST_LABEL_CCOMP then each connected component of zeros in src (as well as all the non-zero pixels closest to the connected component) will be assigned the same label. If labelType==DIST_LABEL_PIXEL then each zero pixel (and all the non-zero pixels closest to it) gets its own label.

The functions distanceTransform calculate the approximate or precise distance from every binary image pixel to the nearest zero pixel. For zero image pixels, the distance will obviously be zero.

When maskSize == CV_DIST_MASK_PRECISE and distanceType == CV_DIST_L2 , the function runs the algorithm described in [Felzenszwalb04]. This algorithm is parallelized with the TBB library.



In other cases, the algorithm [Borgefors86] is used. This means that for a pixel the function finds the shortest path to the nearest zero pixel consisting of basic shifts: horizontal, vertical, diagonal, or knight’s move (the latest is available for a 5\times 5 mask). The overall distance is calculated as a sum of these basic distances. Since the distance function should be symmetric, all of the horizontal and vertical shifts must have the same cost (denoted as a ), all the diagonal shifts must have the same cost (denoted as b ), and all knight’s moves must have the same cost (denoted as c ). For the CV_DIST_C and CV_DIST_L1 types, the distance is calculated precisely, whereas for CV_DIST_L2 (Euclidean distance) the distance can be calculated only with a relative error (a 5\times 5 mask gives more accurate results). For a,``b`` , and c , OpenCV uses the values suggested in the original paper:



CV_DIST_C	(3\times 3)	a = 1, b = 1

CV_DIST_L1	(3\times 3)	a = 1, b = 2

CV_DIST_L2	(3\times 3)	a=0.955, b=1.3693

CV_DIST_L2	(5\times 5)	a=1, b=1.4, c=2.1969

Typically, for a fast, coarse distance estimation CV_DIST_L2, a 3\times 3 mask is used. For a more accurate distance estimation CV_DIST_L2 , a 5\times 5 mask or the precise algorithm is used. Note that both the precise and the approximate algorithms are linear on the number of pixels.



The second variant of the function does not only compute the minimum distance for each pixel (x, y) but also identifies the nearest connected component consisting of zero pixels (labelType==DIST_LABEL_CCOMP) or the nearest zero pixel (labelType==DIST_LABEL_PIXEL). Index of the component/pixel is stored in \texttt{labels}(x, y) . When labelType==DIST_LABEL_CCOMP, the function automatically finds connected components of zero pixels in the input image and marks them with distinct labels. When labelType==DIST_LABEL_CCOMP, the function scans through the input image and marks all the zero pixels with distinct labels.



In this mode, the complexity is still linear. That is, the function provides a very fast way to compute the Voronoi diagram for a binary image. Currently, the second variant can use only the approximate distance transform algorithm, i.e. maskSize=CV_DIST_MASK_PRECISE is not supported yet.



Note

An example on using the distance transform can be found at opencv_source_code/samples/cpp/distrans.cpp

(Python) An example on using the distance transform can be found at opencv_source/samples/python2/distrans.py

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

# website: http://30daydo.com

# @Time : 2019/6/30 12:03

# @File : main.py



import requests

import re

import os



url = 'http://180.153.255.6/mobile/v1/album/track/ts-1571294887744?albumId=23057324&device=android&isAsc=true&isQueryInvitationBrand=true&pageId={}&pageSize=20&pre_page=0'

headers = {'User-Agent': 'Xiaomi'}



def download():

    for i in range(1, 3):

        r = requests.get(url=url.format(i), headers=headers)

        js_data = r.json()

        data_list = js_data.get('data', {}).get('list', [])

        for item in data_list:

            trackName = item.get('title')

            trackName = re.sub('[\/\\\:\*\?\"\<\>\|]', '_', trackName)

            # trackName=re.sub(':','',trackName)

            src_url = item.get('playUrl64')

            filename = '{}.mp3'.format(trackName)

            if not os.path.exists(filename):



                try:

                    r0 = requests.get(src_url, headers=headers)

                except Exception as e:

                    print(e)

                    print(trackName)

                    r0 = requests.get(src_url, headers=headers)





                else:

                    with open(filename, 'wb') as f:

                        f.write(r0.content)



                    print('{} downloaded'.format(trackName))



            else:

                print(f'{filename}已经下载过了')



import shutil



def rename_():

    for i in range(1, 3):

        r = requests.get(url=url.format(i), headers=headers)

        js_data = r.json()

        data_list = js_data.get('data', {}).get('list', [])

        for item in data_list:

            trackName = item.get('title')

            trackName = re.sub('[\/\\\:\*\?\"\<\>\|]', '_', trackName)

            src_url = item.get('playUrl64')



            orderNo=item.get('orderNo')



            filename = '{}.mp3'.format(trackName)

            try:



                if os.path.exists(filename):

                    new_file='{}_{}.mp3'.format(orderNo,trackName)

                    shutil.move(filename,new_file)

            except Exception as e:

                print(e)











if __name__=='__main__':

    rename_()

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

# website: http://30daydo.com

# @Time : 2019/6/30 12:03

# @File : main.py



import requests

import re

url = 'https://www.ximalaya.com/revision/play/album?albumId=23057324&pageNum=1&sort=1&pageSize=60'

headers={'User-Agent':'Xiaomi'}



r = requests.get(url=url,headers=headers)

js_data = r.json()

data_list = js_data.get('data',{}).get('tracksAudioPlay',)

for item in data_list:

    trackName=item.get('trackName')

    trackName=re.sub(':','',trackName)

    src_url = item.get('src')

    try:

        r0=requests.get(src_url,headers=headers)

    except Exception as e:

        print(e)

        print(trackName)

    else:

        with open('{}.m4a'.format(trackName),'wb') as f:

            f.write(r0.content)

        print('{} downloaded'.format(trackName))

def iter_demo():



    class DefineIter(object):



        def __init__(self,length):

            self.length = length

            self.data = range(self.length)

            self.index=0



        def __iter__(self):

            return self





        def __next__(self):



            if self.index >=self.length:

                # return None

                raise StopIteration



            d = self.data[self.index]*50

            self.index =self.index + 1



            return d



    a = DefineIter(10)

    print(type(a))

    for i in a:

        print(i)

方式

通过 Live Template 快速添加时间



步骤

1、添加一个 Template Group 命名为 Common

2、添加一个 Live Template 设置如下

Abbreviation： time

Description ： current time

Template Text:  $time$



Edit Variables ->  Expresssion : date("yyyy-MM-dd HH:mm:ss")







3、让设置生效

Define->Everywhere



4、使用

输入 time 后 按下tab键 就能转换为当前时间了

# 拯救损坏的jupyter 文件

import re

import codecs



pattern = re.compile('"source": \[(.*?)\]\s+\},',re.S)

filename = 'tushare_usage.ipynb'

with codecs.open(filename,encoding='utf8') as f:

    content = f.read()

    

source = pattern.findall(content)

for s in source:

    t=s.replace('\\n','')

    t=re.sub('"','',t)

    t=re.sub('(,$)','',t)

    print(t)

    file_path=r'9927_15562445086485238.png'

    file=open(file_path, 'rb').read()

    r=requests.post(url=code_url,data=file)

    print(r.text)

public abstract class Vehicle {

}

 

public interface Flyable {

    public void fly();

}

 

public class FlyableImpl implements Flyable {

    public void fly() {

        System.out.println("I am flying");

    }

} 

 

public class Airplane extends Vehicle implements Flyable {

    private flyable;

 

    public Airplane() {

        flyable = new FlyableImpl();

    }

 

    public void fly() {

        flyable.fly();

    }

}

class Vehicle(object):

    pass

 

class PlaneMixin(object):

    def fly(self):

        print 'I am flying'

 

class Airplane(Vehicle, PlaneMixin):

    pass

• 首先它必须表示某一种功能，而不是某个物品，如同Java中的Runnable，Callable等

• 其次它必须责任单一，如果有多个功能，那就写多个Mixin类
• 然后，它不依赖于子类的实现
• 最后，子类即便没有继承这个Mixin类，也照样可以工作，就是缺少了某个功能。（比如飞机照样可以载客，就是不能飞了^_^）

js=re.sub('\r\n','',js)

async def fetch(session,url, data):

    async with session.post(url=url, data=data, headers=headers) as response:

        return await response.json()

import aiohttp

import asyncio



page = 30



post_data = {

    'page': 1,

    'pageSize': 10,

    'keyWord': '',

    'dpIds': '',

}



headers = {

    

    "Accept-Encoding": "gzip, deflate",

    "Accept-Language": "en-US,en;q=0.9",

    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.108 Safari/537.36",

    "X-Requested-With": "XMLHttpRequest",

}



result=





async def fetch(session,url, data):

    async with session.post(url=url, data=data, headers=headers) as response:

        return await response.json()



async def parse(html):

    xzcf_list = html.get('newtxzcfList')

    if xzcf_list is None:

        return

    for i in xzcf_list:

        result.append(i)



async def downlod(page):

    data=post_data.copy()

    data['page']=page

    url = 'http://credit.chaozhou.gov.cn/tfieldTypeActionJson!initXzcfListnew.do'

    async with aiohttp.ClientSession() as session:

            html=await fetch(session,url,data)

            await parse(html)



loop = asyncio.get_event_loop()

tasks=[asyncio.ensure_future(downlod(i)) for i in range(1,page)]

tasks=asyncio.gather(*tasks)

# print(tasks)

loop.run_until_complete(tasks)

# loop.close()

# print(result)

count=0

for i in result:

    print(i.get('cfXdrMc'))

    count+=1

print(f'total {count}')

import requests

from lxml import etree

import asyncio

import aiohttp

import pandas

import re

import math

import time



loction_info = '''    1→杭州

    2→武汉

    3→北京

    按ENTER确认：'''

loction_select = input(loction_info)

loction_dic = {'1': 'hz',

               '2': 'wh',

               '3': 'bj'}

city_url = 'https://{}.lianjia.com/ershoufang/'.format(loction_dic[loction_select])

down = input('请输入价格下限（万）:')

up = input('请输入价格上限（万）:')



inter_list = [(int(down), int(up))]





def half_inter(inter):

    lower = inter[0]

    upper = inter[1]

    delta = int((upper - lower) / 2)

    inter_list.remove(inter)

    print('已经缩小价格区间', inter)

    inter_list.append((lower, lower + delta))

    inter_list.append((lower + delta, upper))





pagenum = {}





def get_num(inter):

    url = city_url + 'bp{}ep{}/'.format(inter[0], inter[1])

    r = requests.get(url).text

    print(r)

    num = int(etree.HTML(r).xpath("//h2[@class='total fl']/span/text()")[0].strip())

    pagenum[(inter[0], inter[1])] = num

    return num





totalnum = get_num(inter_list[0])



judge = True

while judge:

    a = [get_num(x) > 3000 for x in inter_list]

    if True in a:

        judge = True

    else:

        judge = False

    for i in inter_list:

        if get_num(i) > 3000:

            half_inter(i)

print('价格区间缩小完毕！')



url_lst = []

url_lst_failed = []

url_lst_successed = []

url_lst_duplicated = []



for i in inter_list:

    totalpage = math.ceil(pagenum[i] / 30)

    for j in range(1, totalpage + 1):

        url = city_url + 'pg{}bp{}ep{}/'.format(j, i[0], i[1])

        url_lst.append(url)

print('url列表获取完毕！')



info_lst = []





async def get_info(url):

    async with aiohttp.ClientSession() as session:

        async with session.get(url, timeout=5) as resp:

            if resp.status != 200:

                url_lst_failed.append(url)

            else:

                url_lst_successed.append(url)

            r = await resp.text()

            nodelist = etree.HTML(r).xpath("//ul[@class='sellListContent']/li")

            # print('-------------------------------------------------------------')

            # print('开始抓取第{}个页面的数据,共计{}个页面'.format(url_lst.index(url),len(url_lst)))

            # print('开始抓取第{}个页面的数据,共计{}个页面'.format(url_lst.index(url), len(url_lst)))

            # print('开始抓取第{}个页面的数据,共计{}个页面'.format(url_lst.index(url), len(url_lst)))

            # print('-------------------------------------------------------------')

            info_dic = {}

            index = 1

            print('开始抓取{}'.format(resp.url))

            print('开始抓取{}'.format(resp.url))

            print('开始抓取{}'.format(resp.url))

            for node in nodelist:

                try:

                    info_dic['title'] = node.xpath(".//div[@class='title']/a/text()")[0]

                except:

                    info_dic['title'] = '/'

                try:

                    info_dic['href'] = node.xpath(".//div[@class='title']/a/@href")[0]

                except:

                    info_dic['href'] = '/'

                try:

                    info_dic['xiaoqu'] = \

                    node.xpath(".//div[@class='houseInfo']")[0].xpath('string(.)').replace(' ', '').split('|')[0]

                except:

                    info_dic['xiaoqu'] = '/'

                try:

                    info_dic['huxing'] = \

                    node.xpath(".//div[@class='houseInfo']")[0].xpath('string(.)').replace(' ', '').split('|')[1]

                except:

                    info_dic['huxing'] = '/'

                try:

                    info_dic['area'] = \

                    node.xpath(".//div[@class='houseInfo']")[0].xpath('string(.)').replace(' ', '').split('|')[2]

                except:

                    info_dic['area'] = '/'

                try:

                    info_dic['chaoxiang'] = \

                    node.xpath(".//div[@class='houseInfo']")[0].xpath('string(.)').replace(' ', '').split('|')[3]

                except:

                    info_dic['chaoxiang'] = '/'

                try:

                    info_dic['zhuangxiu'] = \

                    node.xpath(".//div[@class='houseInfo']")[0].xpath('string(.)').replace(' ', '').split('|')[4]

                except:

                    info_dic['zhuangxiu'] = '/'

                try:

                    info_dic['dianti'] = \

                    node.xpath(".//div[@class='houseInfo']")[0].xpath('string(.)').replace(' ', '').split('|')[5]

                except:

                    info_dic['dianti'] = '/'

                try:

                    info_dic['louceng'] = re.findall('\((.*)\)', node.xpath(".//div[@class='positionInfo']/text()")[0])

                except:

                    info_dic['louceng'] = '/'

                try:

                    info_dic['nianxian'] = re.findall('\)(.*?)年', node.xpath(".//div[@class='positionInfo']/text()")[0])

                except:

                    info_dic['nianxian'] = '/'

                try:

                    info_dic['guanzhu'] = ''.join(re.findall('[0-9]', node.xpath(".//div[@class='followInfo']/text()")[

                        0].replace(' ', '').split('/')[0]))

                except:

                    info_dic['guanzhu'] = '/'

                try:

                    info_dic['daikan'] = ''.join(re.findall('[0-9]',

                                                            node.xpath(".//div[@class='followInfo']/text()")[0].replace(

                                                                ' ', '').split('/')[1]))

                except:

                    info_dic['daikan'] = '/'

                try:

                    info_dic['fabu'] = node.xpath(".//div[@class='followInfo']/text()")[0].replace(' ', '').split('/')[

                        2]

                except:

                    info_dic['fabu'] = '/'

                try:

                    info_dic['totalprice'] = node.xpath(".//div[@class='totalPrice']/span/text()")[0]

                except:

                    info_dic['totalprice'] = '/'

                try:

                    info_dic['unitprice'] = node.xpath(".//div[@class='unitPrice']/span/text()")[0].replace('单价', '')

                except:

                    info_dic['unitprice'] = '/'

                if True in [info_dic['href'] in dic.values() for dic in info_lst]:

                    url_lst_duplicated.append(info_dic)

                else:

                    info_lst.append(info_dic)

                print('第{}条:    {}→房屋信息抓取完毕！'.format(index, info_dic['title']))

                index += 1

                info_dic = {}





start = time.time()



# 首次抓取url_lst中的信息，部分url没有对其发起请求，不知道为什么

tasks = [asyncio.ensure_future(get_info(url)) for url in url_lst]

loop = asyncio.get_event_loop()

loop.run_until_complete(asyncio.wait(tasks))



# 将没有发起请求的url放入一个列表，对其进行循环抓取，直到所有url都被发起请求

url_lst_unrequested = []

for url in url_lst:

    if url not in url_lst_successed or url_lst_failed:

        url_lst_unrequested.append(url)

while len(url_lst_unrequested) > 0:

    tasks_unrequested = [asyncio.ensure_future(get_info(url)) for url in url_lst_unrequested]

    loop.run_until_complete(asyncio.wait(tasks_unrequested))

    url_lst_unrequested = []

    for url in url_lst:

        if url not in url_lst_successed:

            url_lst_unrequested.append(url)

end = time.time()

print('当前价格区间段内共有{}套二手房源\(包含{}条重复房源\),实际获得{}条房源信息。'.format(totalnum, len(url_lst_duplicated), len(info_lst)))

print('总共耗时{}秒'.format(end - start))



df = pandas.DataFrame(info_lst)

df.to_csv("ljwh.csv", encoding='gbk')

class First(object):

    def __init__(self):

        print("first")



class Second(First):

    def __init__(self):

        print("second")



class Third(First,Second):

    def __init__(self):

        print("third")

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-6-c90f7b77d3e0> in <module>()

      7         print("second")

      8 

----> 9 class Third(First,Second):

     10     def __init__(self):

     11         print("third")



TypeError: Cannot create a consistent method resolution order (MRO) for bases First, Second

import time

import gevent

import requests

def foo():

    print('Running in foo')



    r=requests.get('http://30daydo.com')

    print(r.status_code)

    print('Explicit context switch to foo again')



def bar():

    print('Explicit context to bar')



    r=requests.get('http://www.qq.com') # 

    print(r.status_code)

    print('Implicit context switch back to bar')



start=time.time()

gevent.joinall([

    gevent.spawn(foo),

    gevent.spawn(bar),

])

print('time used {}'.format(time.time()-start))

import time

import gevent

import requests

def foo():

    print('Running in foo')

    time.sleep(2) # 这样子不起作用

    print('Explicit context switch to foo again')



def bar():

    print('Explicit context to bar')

    time.sleep(2)

    print('Implicit context switch back to bar')



start=time.time()

gevent.joinall([

    gevent.spawn(foo),

    gevent.spawn(bar),

])

print('time used {}'.format(time.time()-start))

import time

import gevent

import requests

def foo():

    print('Running in foo')



    gevent.sleep(2) # 通过它各自yield向对方



    print('Explicit context switch to foo again')



def bar():

    print('Explicit context to bar')



    gevent.sleep(2)



    print('Implicit context switch back to bar')



start=time.time()

gevent.joinall([

    gevent.spawn(foo),

    gevent.spawn(bar),

])

print('time used {}'.format(time.time()-start))

最流行的版本控制软件：git

========================



git已经是当前最流行的版本控制软件之一了。全世界的程序员都在使用它。它出自linus大神之手，现在被用于内

核的版本控制。在最流行的代码托管软件github，你几乎可以找到所有开源项目的代码。



版块控制软件：我需要吗？

-----------------------



的确对于许多人——尤其是非程序员，他们可能不会想到已经出现了专门的版本控制的软件。但其实多人对版本控

制其实都有类似的需求，举个例子，Tom是社团的秘书处成员，他们经常需要做的事情就是写活动文档，然后不停地

改改到大家都觉得可以了。



不幸运的话，Tom可能有个文件夹叫“openSUSE活动策划"，里面有这样的一堆文件”openSUSE活动策划", "活动策

划1", "活动策划2", "活动策划3", "活动策划4" ... "活动策划20" （可怜的Tom，一份文档改了不少于20次）



这种作法很有效，因为我们可能发现第5个版本的策划有问题，我们准备在第3个版本上面重新来过。但是也看到，

这个作法有些很丑陋的地方：一份文件，我们留了20个备份，而且还要注意文件名。



如果可以这样就好了：文件夹上只有一个“openSUSE活动策划"，但当我需要第5个版本的时候，我来一个”给我还

原到第5个版本吧！“，然后这时候我们打开这个文件，它就是第5个版本的了。类似的，我们可以取出任意的版本

。



这就是版本控制。这种事情在程序里面发生的太多了，于是出现了各种版本控制软件。事实上，有些项目已经发展

到第1000+甚至更高的版本数了……



单线的工作流

------------



我们可以把我们的一个项目想象为一个仓库，然后我们可以把我们的东西塞进仓库里面，也可以把想要的东西拿出

来。而git则是仓库的管理员。下面是一个例子，希望有一个直观的印象，不求完全的理解和掌握。



```bash

mkdir myproject // 假设myproject是工作目录

cd myproject    

git init        // git <- (init) ，告诉仓库管理员，在当前目录初始化

echo 'Eat the banana' > file   // 编辑了一个文件

git add file                   // 加入仓库

git commit -m 'add first file' // 提交更改

echo 'Eat the apply' > file    // 修改了这个文件

git add file                   // 加入仓库

git commit -m 'update first file' // 再提交更改

```



这时候我们就有两个commit了，我们来看看工作日志：



```bash

git log



# 以下是输出

# commit ac1371173b4e630ddaebda3f9f5d948b36146c07

# Author: Norman Mo <LTaoist@@@>

# Date:   Thu Jun 27 21:59:10 2013 +0800

#

#     update first file

#

# commit 3c43cc913454f92bb4b80c56ba45e4ffaf556fc0

# Author: Norman Mo <LTaoist6@@@@>

# Date:   Thu Jun 27 21:58:48 2013 +0800

#

#     add first file

```



看到了，我们提交了两次。我们来看看现在file里面是什么：



```bash

cat file # 显然输出是 'Eat the apply'

# 现在，我们来拿回第一个版本的file文件

git checkout 3c43cc913454f92bb4b80c56ba45e4ffaf556fc0 -- file

cat file # 这时候就是eat banana了

```



这种工作的方式是单人使用最常见的方式，写一点代码，提交一下到仓库里面。写一点，提交到仓库里面。然后出

问题的时候就回退过去。git非常强大，基本上你想到的他都可以做到，提交到仓库的数据基本不会丢失，像时间机

器一样控制着代码。



多人协作

--------



git非常强大，上面只是一个功能。考虑Tom的秘书处有两个人，他们在同时写。其中Tom写前6章，他的同伴写第7～

12章。



这时候可以考虑用这种工作的方式：设立一个公共的仓库。Tom维护自己的版本，他的同伴维护自己的版本。然后大

家定期把代码合并到公共仓库上面，然后定期把新的版本取回来合并再提交到公共仓库。



如果他们用纯文本，得益于一些文本分析的方法，几乎不需要校对就可以做到。



```

git commit -m 'finish ch5' // 假设此时Tom写完了第5章

git push // Tom将代码推送到远程仓库

```



```

git commit -m 'finish ch11' // 假设此时Tom的同伴完成了第11章

git pull // pull会将最新版本拉下来，合并，然后推送到远程仓库

```



实际上工作中，为了不混淆，会新开一个分支来开发新的特性，然后对分支进行合并。



代码自动发布

-----------



另一个很强大的功能是可以实现代码的自动发布。事实上，很多云就有使用这个。具体来说，利用git的hooks，当

服务器收到一个push，服务器可以自动运行一些脚本。也可以在客户端使用hooks，当客户端准备push的时候，客户

端先运行一些脚本。



例如，我们希望在每次服务器收到push以后，杀死全部的 `p` 进程，然后重开 `p` 进程。我们可以修改 `hooks/

post-receive` :



```

echo "Killing all p process..."

killall -9 p

echo "Restart p process..."

p

```



更多更多更多……

---------------



这份教程就到这里了，更多的自己马上动手去试试吧！



在openSUSE的安装方法：



```

sudo zypper in git

```



默认应该就装了。



一般linux命令查看帮助都是 `--help` 选项：



```

git --help

```



此外，对一个子命令也是有help看的：



```

git init --help

```



这里有一个交互教程，在浏览器上面跑的模拟git的运行的，有兴趣的试试：



<http://try.github.io/>



github的help文档写得很不错，推荐一下：



<https://help.github.com/>



书籍有个远近闻名的《Pro Git》，而且有中文版的，虽然我认为这本书太厚了。。。但似乎就这么一本书……



<http://git-scm.com/book/zh>



国内有个gitcafe，也是做git托管的，他们也有整理一份help：



<https://gitcafe.com/GitCafe/Help>



记得，上面只是一个演示，多试试push，多尝试。有一天你会喜欢用这个有效的工具的。



很有用！！！

./kafka-server-start.sh -daemon ../config/server.properties

systemctl stop firewalld.service #关闭防火墙

systemctl disable firewalld.service #禁止启动防火墙

<class 'pandas.core.frame.DataFrame'>

RangeIndex: 307 entries, 0 to 306

Data columns (total 7 columns):

日期         307 non-null datetime64[ns]

指数         307 non-null float64

成交额(亿元)    307 non-null float64

涨跌         307 non-null float64

涨跌额        307 non-null float64

转债数目       307 non-null float64

剩余规模       307 non-null float64

dtypes: datetime64[ns](1), float64(6)

memory usage: 16.9 KB

[numpy.datetime64('2017-12-29T00:00:00.000000000'),

 numpy.datetime64('2018-01-02T00:00:00.000000000'),

 numpy.datetime64('2018-01-03T00:00:00.000000000'),

 numpy.datetime64('2018-01-04T00:00:00.000000000'),

 numpy.datetime64('2018-01-05T00:00:00.000000000'),

 numpy.datetime64('2018-01-08T00:00:00.000000000'),

 numpy.datetime64('2018-01-09T00:00:00.000000000'),

 numpy.datetime64('2018-01-10T00:00:00.000000000'),

 numpy.datetime64('2018-01-11T00:00:00.000000000'),

 numpy.datetime64('2018-01-12T00:00:00.000000000'),

 numpy.datetime64('2018-01-15T00:00:00.000000000'),

 numpy.datetime64('2018-01-16T00:00:00.000000000'),

 numpy.datetime64('2018-01-17T00:00:00.000000000'),

b=list(df['日期'].dt.to_pydatetime())

[datetime.datetime(2017, 12, 29, 0, 0),

 datetime.datetime(2018, 1, 2, 0, 0),

 datetime.datetime(2018, 1, 3, 0, 0),

 datetime.datetime(2018, 1, 4, 0, 0),

 datetime.datetime(2018, 1, 5, 0, 0),

 datetime.datetime(2018, 1, 8, 0, 0),

 datetime.datetime(2018, 1, 9, 0, 0),

 datetime.datetime(2018, 1, 10, 0, 0),

 datetime.datetime(2018, 1, 11, 0, 0),

 datetime.datetime(2018, 1, 12, 0, 0),

 datetime.datetime(2018, 1, 15, 0, 0)

['2017-12-29',

 '2018-01-02',

 '2018-01-03',

 '2018-01-04',

 '2018-01-05',

 '2018-01-08',

 '2018-01-09',

 '2018-01-10',

 '2018-01-11',

 '2018-01-12',

 '2018-01-15',

 '2018-01-16',

 '2018-01-17',]

timestamp转换为datetime

要把timestamp转换为datetime，使用datetime提供的fromtimestamp()方法：



>>> from datetime import datetime

>>> t = 1429417200.0

>>> print(datetime.fromtimestamp(t))

2015-04-19 12:20:00

注意到timestamp是一个浮点数，它没有时区的概念，而datetime是有时区的。上述转换是在timestamp和本地时间做转换。



本地时间是指当前操作系统设定的时区。例如北京时区是东8区，则本地时间：



2015-04-19 12:20:00

实际上就是UTC+8:00时区的时间：



2015-04-19 12:20:00 UTC+8:00

而此刻的格林威治标准时间与北京时间差了8小时，也就是UTC+0:00时区的时间应该是：



2015-04-19 04:20:00 UTC+0:00

timestamp也可以直接被转换到UTC标准时区的时间：



>>> from datetime import datetime

>>> t = 1429417200.0

>>> print(datetime.fromtimestamp(t)) # 本地时间

2015-04-19 12:20:00

>>> print(datetime.utcfromtimestamp(t)) # UTC时间

2015-04-19 04:20:00

db.collection.findOneAndUpdate(

   <filter>,

   <update>,

   {

     projection: <document>,

     sort: <document>,

     maxTimeMS: <number>,

     upsert: <boolean>,

     returnNewDocument: <boolean>,

     collation: <document>,

     arrayFilters: [ <filterdocument1>, ... ]

   }

)

>>> db.example.find_one_and_update(

...     {'_id': 'userid'},

...     {'$inc': {'seq': 1}},

...     projection={'seq': True, '_id': False},

...     return_document=ReturnDocument.AFTER)

# Redis集群地址

REDIS_MASTER_NODES = [

    {"host": "192.168.10.233", "port": "30001"},

    {"host": "192.168.10.234", "port": "30002"},

    {"host": "192.168.10.235", "port": "30003"},

]



# 使用的哈希函数数，默认为6  

BLOOMFILTER_HASH_NUMBER = 6



# Bloomfilter使用的Redis内存位，30表示2 ^ 30 = 128MB，默认为22 (1MB 可去重130W URL)  

BLOOMFILTER_BIT = 22



# 不清空redis队列  

SCHEDULER_PERSIST = True  

# 调度队列  

SCHEDULER = "scrapy_redis_cluster.scheduler.Scheduler"  

# 去重 

DUPEFILTER_CLASS = "scrapy_redis_cluster.dupefilter.RFPDupeFilter"  

# queue  

SCHEDULER_QUEUE_CLASS = 'scrapy_redis_cluster.queue.PriorityQueue'

df

       A  B  C  D  E

    0  5  0  3  3  7

    1  9  3  5  2  4

    2  7  6  8  8  1

      A  B  C  D  E

0     5  0  3  3  7

1  1000  3  5  2  4

2  1000  6  8  8  1

class Foobar(object):



    def __init__(self):

        print('class start')



    def __del__(self):

        print('class end')



def main()        

    obj = Foobar()

    print('where is del?')

    print('main end')



main()

    def __init__(self,page=None,*args, **kwargs):

        super(Gaode,self).__init__(*args, **kwargs)

        self.page=page

        

        

    def start_requests(self):

        XXXXXX 调用self.page 即可

        yield Request(XXXX)