30天尝试新事情

李笑来：普通人如何练习做到深入思考

闲聊 • 李魔佛发表了文章 • 0 个评论 • 2856 次浏览 • 2021-05-28 19:21 • 来自相关话题

李笑来：
普通人如何练习做到深入思考？
喜欢和聪明人打交道

1. 聪明人的定义：
对一些清晰，必要，准确的概念，很明白，没必要的东西可能就被抛弃。
聪明不是天生的，而是长期积累，锻炼。
我不相信聪明人赚不到钱。

如何锻炼：

同一个问题，经常去想，就会比别人想的深刻，周全。

对一件事情想象得深刻，并不是靠聪明就可以做得来的。

独立的时间，空间，不干扰。

别忘了问题，天天想，想得比别人多，足够多。查看全部

李笑来：
普通人如何练习做到深入思考？
喜欢和聪明人打交道

1. 聪明人的定义：
对一些清晰，必要，准确的概念，很明白，没必要的东西可能就被抛弃。
聪明不是天生的，而是长期积累，锻炼。
我不相信聪明人赚不到钱。

如何锻炼：

同一个问题，经常去想，就会比别人想的深刻，周全。

对一件事情想象得深刻，并不是靠聪明就可以做得来的。

独立的时间，空间，不干扰。

别忘了问题，天天想，想得比别人多，足够多。

python判断可转债是否强赎

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 2728 次浏览 • 2021-04-02 13:41 • 来自相关话题

占坑，后期把代码整理下放上来。

更新：

制作好了一个接口，用户可以直接调用。
数据来源与集思录。
获取排除满足强赎天数剩余N天的可转债，排除强赎可转债。

比如：DAY=4 ，那么假设强赎满足天数为15天，那么返回市场上强赎强赎倒数天数大于4天的可转债，即返回小于或者等于11天以下的转债。把满足条件还差4天的转债排除掉了，当然，已经公告强赎的也会被排除。

import requests

URL = 'http://11.11.11.11/api/redeem/'
# DAY 强赎倒数剩余天数小于 DAY （4）天，已经公告强赎的也是被排除的
DAY = 4

SIGN = '私信星主获取' # sign和以前一致

data = {'day': DAY,
'sign': SIGN}
r = requests.post(URL, data=data)

print(r.json())
具体用户可以关注知识星球：查看全部

占坑，后期把代码整理下放上来。

更新：

制作好了一个接口，用户可以直接调用。
数据来源与集思录。

获取 排除满足强赎天数剩余N天的可转债，排除强赎可转债。



比如：DAY=4 ，那么假设强赎满足天数为15天，那么返回市场上强赎强赎倒数天数大于4天的可转债，即返回小于或者等于11天以下的转债。把满足条件还差4天的转债排除掉了，当然，已经公告强赎的也会被排除。







import requests



URL = 'http://11.11.11.11/api/redeem/'

# DAY 强赎倒数剩余天数小于 DAY （4）天， 已经公告强赎的也是被排除的

DAY = 4



SIGN = '私信星主获取' # sign和以前一致



data = {'day': DAY,

        'sign': SIGN}

r = requests.post(URL, data=data)



print(r.json())

具体用户可以关注知识星球：

PTrade使用教程新手入门

股票 • 李魔佛发表了文章 • 0 个评论 • 12691 次浏览 • 2021-03-18 08:55 • 来自相关话题

# 更新 Ptrade API 接口文档： http://ptradeapi.com 这样就可以边打开网页，边写代码，不用在ptrade的代码编写和帮助页面来回切换了。
记录一下曾经的入门经验与使用心得：

好像PTrade有几个版本，本人使用的界面如下，基于python写交易策略和回测：

1. 仿真系统的回测可以在交易时间运行，交易系统的回测无法在交易时间运行回测。

2. 在研究板块中，API函数带有研究字样的，可以直接使用，不需要import 导入任何库。比如：#获取当日的股票池
g.stock_list = get_Ashares(g.current_date)可以自己使用。

而get_history(70, '1d', ['close','volume'], g.stock_list, fq='dypre', include=False)
没有带研究字样的，是无法直接在研究板块使用，只能在回测或者实盘使用。

3. 内置的python版本是：
'3.5.1 (default, Nov 1 2016, 01:53:03) \n[GCC 4.8.5 20150623 (Red Hat 4.8.5-4)]'

也就是无法使用fstring的方式格式化字符串
name='jack'
a=f'{name}'

4. log.debug log.error 等调试标记符不会有任何输出，bug！
只能使用log.info 或者print输出，还害我调试了半天，以为程序哪里的问题，导致我的输出不显示。

PTrade新手入门教程二

需要开通Ptrade的朋友，可以扫描二维码开户，并可开通PTrade交易功能。
股票费率万分之一，转债十万分之二。

非诚勿扰。

原创文章，转载请注明出处
http://30daydo.com/article/44151
查看全部

# 更新 Ptrade API 接口文档： http://ptradeapi.com 这样就可以边打开网页，边写代码，不用在ptrade的代码编写和帮助页面来回切换了。
记录一下曾经的入门经验与使用心得：

好像PTrade有几个版本，本人使用的界面如下，基于python写交易策略和回测：

1. 仿真系统的回测可以在交易时间运行，交易系统的回测无法在交易时间运行回测。

2. 在研究板块中，API函数带有研究字样的，可以直接使用，不需要import 导入任何库。比如：

#获取当日的股票池

g.stock_list = get_Ashares(g.current_date)

可以自己使用。

而

get_history(70, '1d', ['close','volume'], g.stock_list, fq='dypre', include=False)

没有带研究字样的，是无法直接在研究板块使用，只能在回测或者实盘使用。

3. 内置的python版本是：
'3.5.1 (default, Nov 1 2016, 01:53:03) \n[GCC 4.8.5 20150623 (Red Hat 4.8.5-4)]'

也就是无法使用fstring的方式格式化字符串
name='jack'
a=f'{name}'

4. log.debug log.error 等调试标记符不会有任何输出，bug！
只能使用log.info 或者print输出，还害我调试了半天，以为程序哪里的问题，导致我的输出不显示。

PTrade新手入门教程二

需要开通Ptrade的朋友，可以扫描二维码开户，并可开通PTrade交易功能。
股票费率万分之一，转债十万分之二。

非诚勿扰。

原创文章，转载请注明出处
http://30daydo.com/article/44151

可转债费率百分之二全市场最便宜

券商万一免五 • 绫波丽发表了文章 • 0 个评论 • 3889 次浏览 • 2021-03-14 02:03 • 来自相关话题

最新消息：

目前根据可转债新规沪市十万分之4.1，深市十万分之4。支持同花顺交易
没有最低5元限制，也没有任何最低限制。

以前旧的费率可转债沪市百万分之二已经不复存在了。大部分券商把存量的用户也提高了。

需要的朋友欢迎扫码加我开户吧

备注：开户
非诚勿扰！
查看全部

最新消息：

目前根据可转债新规沪市十万分之4.1，深市十万分之4。支持同花顺交易
没有最低5元限制，也没有任何最低限制。

以前旧的费率可转债沪市百万分之二已经不复存在了。大部分券商把存量的用户也提高了。

需要的朋友欢迎扫码加我开户吧

备注：开户
非诚勿扰！

a股券商开户万1免五没有最低消费

券商万一免五 • 李魔佛发表了文章 • 0 个评论 • 13348 次浏览 • 2021-03-07 17:51 • 来自相关话题

最近市场上貌似没有几家万一免5的了，之前的银河证券被举报了，免5的费率被取消了。
不过之前还找到一家万一免五的，没有最低费率，用多少算多少，比如买了1000元股票，那么费率只有1000*万分之一，等于1分钱，略等于不用钱哈。
优势杠杆的。

需要的点击下面链接即可开户：注意：当前默认的免五已经取消了，需要开通量化交易权限后可以进行免五操作。

开通ptrade和qmt量化交易接口的条件，入金30万，过3天左右可以开通，开通后可以免五！

交割单：

心动不，赶紧心动吧。

该券商也支持同花顺客户端登录，做量化的使用easytrader也可以友好支持。

如果有疑问，可以扫码咨询。备注：开户

查看全部

最近市场上貌似没有几家万一免5的了，之前的银河证券被举报了，免5的费率被取消了。
不过之前还找到一家万一免五的，没有最低费率，用多少算多少，比如买了1000元股票，那么费率只有1000*万分之一，等于1分钱，略等于不用钱哈。
优势杠杆的。

需要的点击下面链接即可开户：注意：当前默认的免五已经取消了，需要开通量化交易权限后可以进行免五操作。

开通ptrade和qmt量化交易接口的条件，入金30万，过3天左右可以开通，开通后可以免五！

交割单：

心动不，赶紧心动吧。

该券商也支持同花顺客户端登录，做量化的使用easytrader也可以友好支持。

如果有疑问，可以扫码咨询。备注：开户

scrapy源码分析<一>：入口函数以及是如何运行

python爬虫 • 李魔佛发表了文章 • 0 个评论 • 6161 次浏览 • 2019-08-31 10:47 • 来自相关话题

运行scrapy crawl example 命令的时候，就会执行我们写的爬虫程序。
下面我们从源码分析一下scrapy执行的流程：

执行scrapy crawl 命令时，调用的是Command类class Command(ScrapyCommand):

requires_project = True

def syntax(self):
return '[options]'

def short_desc(self):
return 'Runs all of the spiders - My Defined'

def run(self,args,opts):
print('==================')
print(type(self.crawler_process))
spider_list = self.crawler_process.spiders.list() # 找到爬虫类

for name in spider_list:
print('=================')
print(name)
self.crawler_process.crawl(name,**opts.__dict__)

self.crawler_process.start()
然后我们去看看crawler_process，这个是来自ScrapyCommand，而ScrapyCommand又是CrawlerProcess的子类，而CrawlerProcess又是CrawlerRunner的子类

在CrawlerRunner构造函数里面主要作用就是这个 def __init__(self, settings=None):
if isinstance(settings, dict) or settings is None:
settings = Settings(settings)
self.settings = settings
self.spider_loader = _get_spider_loader(settings) # 构造爬虫
self._crawlers = set()
self._active = set()
self.bootstrap_failed = False
1. 加载配置文件def _get_spider_loader(settings):

cls_path = settings.get('SPIDER_LOADER_CLASS')

# settings文件没有定义SPIDER_LOADER_CLASS，所以这里获取到的是系统的默认配置文件，
# 默认配置文件在接下来的代码块A
# SPIDER_LOADER_CLASS = 'scrapy.spiderloader.SpiderLoader'

loader_cls = load_object(cls_path)
# 这个函数就是根据路径转为类对象，也就是上面crapy.spiderloader.SpiderLoader 这个
# 字符串变成一个类对象
# 具体的load_object 对象代码见下面代码块B

return loader_cls.from_settings(settings.frozencopy())
默认配置文件defautl_settting.py# 代码块A
#......省略若干
SCHEDULER = 'scrapy.core.scheduler.Scheduler'
SCHEDULER_DISK_QUEUE = 'scrapy.squeues.PickleLifoDiskQueue'
SCHEDULER_MEMORY_QUEUE = 'scrapy.squeues.LifoMemoryQueue'
SCHEDULER_PRIORITY_QUEUE = 'scrapy.pqueues.ScrapyPriorityQueue'

SPIDER_LOADER_CLASS = 'scrapy.spiderloader.SpiderLoader' 就是这个值
SPIDER_LOADER_WARN_ONLY = False

SPIDER_MIDDLEWARES = {}

load_object的实现# 代码块B 为了方便，我把异常处理的去除
from importlib import import_module #导入第三方库

def load_object(path):
dot = path.rindex('.')
module, name = path[:dot], path[dot+1:]
# 上面把路径分为基本路径+模块名

mod = import_module(module)
obj = getattr(mod, name)
# 获取模块里面那个值

return obj

测试代码：In [33]: mod = import_module(module)

In [34]: mod
Out[34]: <module 'scrapy.spiderloader' from '/home/xda/anaconda3/lib/python3.7/site-packages/scrapy/spiderloader.py'>

In [35]: getattr(mod,name)
Out[35]: scrapy.spiderloader.SpiderLoader

In [36]: obj = getattr(mod,name)

In [37]: obj
Out[37]: scrapy.spiderloader.SpiderLoader

In [38]: type(obj)
Out[38]: type
在代码块A中，loader_cls是SpiderLoader，最后返回的的是SpiderLoader.from_settings(settings.frozencopy())
接下来看看SpiderLoader.from_settings， def from_settings(cls, settings):
return cls(settings)
返回类对象自己，所以直接看__init__函数即可class SpiderLoader(object):
"""
SpiderLoader is a class which locates and loads spiders
in a Scrapy project.
"""
def __init__(self, settings):
self.spider_modules = settings.getlist('SPIDER_MODULES')
# 获得settting中的模块名字，创建scrapy的时候就默认帮你生成了
# 你可以看看你的settings文件里面的内容就可以找到这个值，是一个list

self.warn_only = settings.getbool('SPIDER_LOADER_WARN_ONLY')
self._spiders = {}
self._found = defaultdict(list)
self._load_all_spiders() # 加载所有爬虫

核心就是这个_load_all_spiders：
走起：def _load_all_spiders(self):
for name in self.spider_modules:

for module in walk_modules(name): # 这个遍历文件夹里面的文件，然后再转化为类对象，
# 保存到字典：self._spiders = {}
self._load_spiders(module) # 模块变成spider

self._check_name_duplicates() # 去重，如果名字一样就异常

接下来看看_load_spiders
核心就是下面的。def iter_spider_classes(module):
from scrapy.spiders import Spider

for obj in six.itervalues(vars(module)): # 找到模块里面的变量，然后迭代出来
if inspect.isclass(obj) and \
issubclass(obj, Spider) and \
obj.__module__ == module.__name__ and \
getattr(obj, 'name', None): # 有name属性，继承于Spider
yield obj
这个obj就是我们平时写的spider类了。
原来分析了这么多，才找到了我们平时写的爬虫类

待续。。。。

原创文章
转载请注明出处
http://30daydo.com/article/530
查看全部

运行scrapy crawl example 命令的时候，就会执行我们写的爬虫程序。
下面我们从源码分析一下scrapy执行的流程：

执行scrapy crawl 命令时，调用的是Command类

class Command(ScrapyCommand):



    requires_project = True



    def syntax(self):

        return '[options]'



    def short_desc(self):

        return 'Runs all of the spiders - My Defined'



    def run(self,args,opts):

        print('==================')

        print(type(self.crawler_process))

        spider_list = self.crawler_process.spiders.list() # 找到爬虫类



        for name in spider_list:

            print('=================')

            print(name)

            self.crawler_process.crawl(name,**opts.__dict__)



        self.crawler_process.start()

然后我们去看看crawler_process，这个是来自ScrapyCommand，而ScrapyCommand又是CrawlerProcess的子类，而CrawlerProcess又是CrawlerRunner的子类

在CrawlerRunner构造函数里面主要作用就是这个

      def __init__(self, settings=None):

        if isinstance(settings, dict) or settings is None:

            settings = Settings(settings)

        self.settings = settings

        self.spider_loader = _get_spider_loader(settings) # 构造爬虫

        self._crawlers = set()

        self._active = set()

        self.bootstrap_failed = False

1. 加载配置文件

def _get_spider_loader(settings):



    cls_path = settings.get('SPIDER_LOADER_CLASS')

    

    # settings文件没有定义SPIDER_LOADER_CLASS，所以这里获取到的是系统的默认配置文件，

    # 默认配置文件在接下来的代码块A

    # SPIDER_LOADER_CLASS = 'scrapy.spiderloader.SpiderLoader'    

    

    loader_cls = load_object(cls_path) 

    # 这个函数就是根据路径转为类对象，也就是上面crapy.spiderloader.SpiderLoader 这个

    # 字符串变成一个类对象

    # 具体的load_object 对象代码见下面代码块B



    return loader_cls.from_settings(settings.frozencopy())

默认配置文件defautl_settting.py

# 代码块A

#......省略若干

SCHEDULER = 'scrapy.core.scheduler.Scheduler'

SCHEDULER_DISK_QUEUE = 'scrapy.squeues.PickleLifoDiskQueue'

SCHEDULER_MEMORY_QUEUE = 'scrapy.squeues.LifoMemoryQueue'

SCHEDULER_PRIORITY_QUEUE = 'scrapy.pqueues.ScrapyPriorityQueue'



SPIDER_LOADER_CLASS = 'scrapy.spiderloader.SpiderLoader' 就是这个值

SPIDER_LOADER_WARN_ONLY = False



SPIDER_MIDDLEWARES = {}

load_object的实现

# 代码块B 为了方便，我把异常处理的去除

from importlib import import_module #导入第三方库



def load_object(path):

    dot = path.rindex('.') 

    module, name = path[:dot], path[dot+1:]

    # 上面把路径分为基本路径+模块名

    

    mod = import_module(module)

    obj = getattr(mod, name)

    # 获取模块里面那个值

    

    return obj

测试代码：

In [33]: mod = import_module(module)                                                                                                                                             



In [34]: mod                                                                                                                                                                     

Out[34]: <module 'scrapy.spiderloader' from '/home/xda/anaconda3/lib/python3.7/site-packages/scrapy/spiderloader.py'>



In [35]: getattr(mod,name)                                                                                                                                                       

Out[35]: scrapy.spiderloader.SpiderLoader



In [36]: obj = getattr(mod,name)                                                                                                                                                 



In [37]: obj                                                                                                                                                                     

Out[37]: scrapy.spiderloader.SpiderLoader



In [38]: type(obj)                                                                                                                                                               

Out[38]: type

在代码块A中，loader_cls是SpiderLoader，最后返回的的是SpiderLoader.from_settings(settings.frozencopy())
接下来看看SpiderLoader.from_settings，

    def from_settings(cls, settings):

        return cls(settings)

返回类对象自己，所以直接看__init__函数即可

class SpiderLoader(object):

    """

    SpiderLoader is a class which locates and loads spiders

    in a Scrapy project.

    """

    def __init__(self, settings):

        self.spider_modules = settings.getlist('SPIDER_MODULES') 

        # 获得settting中的模块名字，创建scrapy的时候就默认帮你生成了

        # 你可以看看你的settings文件里面的内容就可以找到这个值，是一个list

        

        self.warn_only = settings.getbool('SPIDER_LOADER_WARN_ONLY')

        self._spiders = {}

        self._found = defaultdict(list)

        self._load_all_spiders() # 加载所有爬虫

核心就是这个_load_all_spiders：
走起：

def _load_all_spiders(self):

        for name in self.spider_modules:            



                for module in walk_modules(name): # 这个遍历文件夹里面的文件，然后再转化为类对象，

                    # 保存到字典：self._spiders = {}       

                    self._load_spiders(module) # 模块变成spider



        self._check_name_duplicates() # 去重，如果名字一样就异常

接下来看看_load_spiders
核心就是下面的。

def iter_spider_classes(module):

    from scrapy.spiders import Spider



    for obj in six.itervalues(vars(module)): # 找到模块里面的变量，然后迭代出来

        if inspect.isclass(obj) and \

           issubclass(obj, Spider) and \

           obj.__module__ == module.__name__ and \

           getattr(obj, 'name', None): # 有name属性，继承于Spider

           yield obj

这个obj就是我们平时写的spider类了。
原来分析了这么多，才找到了我们平时写的爬虫类

待续。。。。

原创文章
转载请注明出处
http://30daydo.com/article/530

发现numpy一个很坑的问题，要一定级别的高手才能发现问题

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 4694 次浏览 • 2019-04-30 00:04 • 来自相关话题

一个二元一次方程：
y=X0**2+X1**2 # **2 是平方def function_2(x):
return x[0]**2+x[1]**2

下面是计算y的偏导数，分布计算X0和X1的偏导def numerical_gradient(f,x):
grad = np.zeros_like(x)
h=1e-4
for idx in range(x.size):
temp_v = x[idx]
x[idx]=temp_v+h
f1=f(x)
print(x,f1)
x[idx]=temp_v-h
f2=f(x)
print(x,f2)
ret = (f1-f2)/(2*h)
print(ret)
x[idx]=temp_v
grad[idx]=ret

return grad
然后调用numerical_gradient(function_2,np.array([3,4]))
计算的是二元一次方程 y=X0**2+X1**2 在点（3,4）的偏导的值
得到的是什么结果？
为什么会得到这样的结果？
小白一般要花点时间才能找到原因。
查看全部

一个二元一次方程：
y=X0**2+X1**2 # **2 是平方

def function_2(x):

    return x[0]**2+x[1]**2

下面是计算y的偏导数，分布计算X0和X1的偏导

def numerical_gradient(f,x):

    grad = np.zeros_like(x)

    h=1e-4

    for idx in range(x.size):

        temp_v = x[idx]

        x[idx]=temp_v+h

        f1=f(x)

        print(x,f1)

        x[idx]=temp_v-h

        f2=f(x)

        print(x,f2)

        ret = (f1-f2)/(2*h)

        print(ret)

        x[idx]=temp_v

        grad[idx]=ret

        

    return grad

然后调用

numerical_gradient(function_2,np.array([3,4]))

计算的是二元一次方程 y=X0**2+X1**2 在点（3,4）的偏导的值
得到的是什么结果？
为什么会得到这样的结果？
小白一般要花点时间才能找到原因。

numpy和dataframe轴的含义，axis为负数的含义

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 5616 次浏览 • 2019-04-28 14:22 • 来自相关话题

比如有数组：
a=np.array([[[1,2],[3,4]],[[11,12],[13,14]]])
a
array([[[ 1, 2],
[ 3, 4]],

[[11, 12],
[13, 14]]])
a有3个中括号，那么就有3条轴，从0开始到2，分别是axis=0,1,2
那么我要对a进行求和,分别用axis=0,1,2进行运行。

a.sum(axis=0)得到：
array([[12, 14],
[16, 18]])意思是去掉一个中括号，然后运行。

同理：
a.sum(axis=1)对a去掉2个中括号，然后运行。
得到：
array([[ 4, 6],
[24, 26]])那么对a.sum(axis=2)的结果呢？读者可以自己上机去尝试吧。

而轴的负数，axis=-3和axis=0的意思是一样的，对于有3层轴的数组来说的话。

a.sum(axis=-3)
array([[12, 14],
[16, 18]])
查看全部

比如有数组：

a=np.array([[[1,2],[3,4]],[[11,12],[13,14]]])

a

array([[[ 1,  2],

        [ 3,  4]],



       [[11, 12],

        [13, 14]]])

a有3个中括号，那么就有3条轴，从0开始到2，分别是axis=0,1,2
那么我要对a进行求和,分别用axis=0,1,2进行运行。

a.sum(axis=0)

得到：

array([[12, 14],

       [16, 18]])

意思是去掉一个中括号，然后运行。

同理：

a.sum(axis=1)

对a去掉2个中括号，然后运行。
得到：

array([[ 4,  6],

       [24, 26]])

那么对a.sum(axis=2)的结果呢？读者可以自己上机去尝试吧。

而轴的负数，axis=-3和axis=0的意思是一样的，对于有3层轴的数组来说的话。

a.sum(axis=-3)

array([[12, 14],

       [16, 18]])

可转债如何配债

股票 • 李魔佛发表了文章 • 0 个评论 • 12971 次浏览 • 2019-03-29 16:24 • 来自相关话题

由于还是有很多人不断问我如何配债的问题，这里以歌尔声学为例简单说明下。

1、如果你在登记日也就是12月11日收盘时还持有一定数量歌尔声学正股的话，那么你在配债日也就是12月12日就会看到账户里有相应数量的歌尔配债。注意这里的单位是张，如图，

由于我只有800股歌尔声学，因此获得了13张配债，1张对应100元，这时双击它，左侧出现了卖出菜单，价格和配债代码都自动填好了，输入13张或者点击全部，然后点“卖出”。（需要注意的是：有些券商这里是买入。）

2、不管是卖出还是买入，然后检查下委托情况和扣款情况，如下图：

可以看到我已经被扣款1300元，这样就算成功完成了这次的13张配债.

可转债低佣金开户，沪市转债费率百分之二，全市场最低。
有兴趣的朋友可以扫描开户：

查看全部

由于还是有很多人不断问我如何配债的问题，这里以歌尔声学为例简单说明下。

1、如果你在登记日也就是12月11日收盘时还持有一定数量歌尔声学正股的话，那么你在配债日也就是12月12日就会看到账户里有相应数量的歌尔配债。注意这里的单位是张，如图，

由于我只有800股歌尔声学，因此获得了13张配债，1张对应100元，这时双击它，左侧出现了卖出菜单，价格和配债代码都自动填好了，输入13张或者点击全部，然后点“卖出”。（需要注意的是：有些券商这里是买入。）

2、不管是卖出还是买入，然后检查下委托情况和扣款情况，如下图：

可以看到我已经被扣款1300元，这样就算成功完成了这次的13张配债.

可转债低佣金开户，沪市转债费率百分之二，全市场最低。
有兴趣的朋友可以扫描开户：

【2019-03-16】市场热度预测 - 通过检测某个论坛（集思录）的热度衡量

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 4 个评论 • 4239 次浏览 • 2019-03-16 18:03 • 来自相关话题

很早前就有这个想法，只是最终实践最近才完成，其实并不是很大难度，只是把这个事情早早抛诸脑后。

首先得有数据，有了数据就可以慢慢分析了。

首先是集思录，把数据进行重新采用，按照周采样，然后绘图：

看到这张图后，瞬间也是震惊了，我觉得应该要逃离了。当然不是马上撤离，但是应该时间不会太久，1-2周就应该空仓了。

感觉这个是不错逃顶抄底指标呀。

文章中的数据每周更新，敬请留意。

原创文章
转载请注明出处：
http://30daydo.com/article/428
查看全部

很早前就有这个想法，只是最终实践最近才完成，其实并不是很大难度，只是把这个事情早早抛诸脑后。

首先得有数据，有了数据就可以慢慢分析了。

首先是集思录，把数据进行重新采用，按照周采样，然后绘图：

看到这张图后，瞬间也是震惊了，我觉得应该要逃离了。当然不是马上撤离，但是应该时间不会太久，1-2周就应该空仓了。

感觉这个是不错逃顶抄底指标呀。

文章中的数据每周更新，敬请留意。

原创文章
转载请注明出处：
http://30daydo.com/article/428

Linux下自制有道词典 - python 解密有道词典JS加密

python爬虫 • 李魔佛发表了文章 • 0 个评论 • 4951 次浏览 • 2019-02-23 20:17 • 来自相关话题

对于爬虫新手来说，JS解密是一道过不去的坎，需要不断地练习。
平时在linux下开发，鉴于没有什么好用翻译软件，打开网易也占用系统资源，所以写了个在控制台的翻译软件接口。

使用python爬虫，查看网页的JS加密方法，一步一步地分析，就能够得到最后的加密方法啦。

直接给出代码：
# -*- coding: utf-8 -*-
# website: http://30daydo.com
# @Time : 2019/2/23 19:34
# @File : youdao.py
# 解密有道词典的JS

import hashlib
import random
import requests
import time

def md5_(word):
s = bytes(word, encoding='utf8')
m = hashlib.md5()
m.update(s)
ret = m.hexdigest()
return ret

def get_sign(word, salt):
ret = md5_('fanyideskweb' + word + salt + 'p09@Bn{h02_BIEe]$P^nG')
return ret

def youdao(word):
url = 'http://fanyi.youdao.com/translate_o?smartresult=dict&smartresult=rule'
headers = {
'Host': 'fanyi.youdao.com',
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:47.0) Gecko/20100101 Firefox/47.0',
'Accept': 'application/json, text/javascript, */*; q=0.01',
'Accept-Language': 'zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3',
'Accept-Encoding': 'gzip, deflate',
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
'X-Requested-With': 'XMLHttpRequest',
'Referer': 'http://fanyi.youdao.com/',
'Content-Length': '252',
'Cookie': 'YOUDAO_MOBILE_ACCESS_TYPE=1; OUTFOX_SEARCH_USER_ID=1672542763@10.169.0.83; JSESSIONID=aaaWzxpjeDu1gbhopLzKw; ___rl__test__cookies=1550913722828; OUTFOX_SEARCH_USER_ID_NCOO=372126049.6326876',
'Connection': 'keep-alive',
'Pragma': 'no-cache',
'Cache-Control': 'no-cache',
}

ts = str(int(time.time()*1000))
salt=ts+str(random.randint(0,10))
bv = md5_("5.0 (Windows)")
sign= get_sign(word,salt)

post_data = {
'i': word,
'from': 'AUTO', 'to': 'AUTO', 'smartresult': 'dict', 'client': 'fanyideskweb', 'salt': salt,
'sign': sign, 'ts': ts, 'bv': bv, 'doctype': 'json', 'version': '2.1',
'keyfrom': 'fanyi.web', 'action': 'FY_BY_REALTIME', 'typoResult': 'false'
}

r = requests.post(
url=url,
headers=headers,
data=post_data
)

for item in r.json().get('smartResult',{}).get('entries'):
print(item)

word='student'
youdao(word)
得到结果：

Github：
https://github.com/Rockyzsu/CrawlMan/tree/master/youdao_dictionary
原创文章，转载请注明出处
http://30daydo.com/article/416 查看全部

对于爬虫新手来说，JS解密是一道过不去的坎，需要不断地练习。
平时在linux下开发，鉴于没有什么好用翻译软件，打开网易也占用系统资源，所以写了个在控制台的翻译软件接口。

使用python爬虫，查看网页的JS加密方法，一步一步地分析，就能够得到最后的加密方法啦。

直接给出代码：

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

# website: http://30daydo.com

# @Time : 2019/2/23 19:34

# @File : youdao.py

# 解密有道词典的JS





import hashlib

import random

import requests

import time





def md5_(word):

    s = bytes(word, encoding='utf8')

    m = hashlib.md5()

    m.update(s)

    ret = m.hexdigest()

    return ret



def get_sign(word, salt):

    ret = md5_('fanyideskweb' + word + salt + 'p09@Bn{h02_BIEe]$P^nG')

    return ret





def youdao(word):

    url = 'http://fanyi.youdao.com/translate_o?smartresult=dict&smartresult=rule'

    headers = {

        'Host': 'fanyi.youdao.com',

        'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:47.0) Gecko/20100101 Firefox/47.0',

        'Accept': 'application/json, text/javascript, */*; q=0.01',

        'Accept-Language': 'zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3',

        'Accept-Encoding': 'gzip, deflate',

        'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',

        'X-Requested-With': 'XMLHttpRequest',

        'Referer': 'http://fanyi.youdao.com/',

        'Content-Length': '252',

        'Cookie': 'YOUDAO_MOBILE_ACCESS_TYPE=1; OUTFOX_SEARCH_USER_ID=1672542763@10.169.0.83; JSESSIONID=aaaWzxpjeDu1gbhopLzKw; ___rl__test__cookies=1550913722828; OUTFOX_SEARCH_USER_ID_NCOO=372126049.6326876',

        'Connection': 'keep-alive',

        'Pragma': 'no-cache',

        'Cache-Control': 'no-cache',

    }



    ts = str(int(time.time()*1000))

    salt=ts+str(random.randint(0,10))

    bv = md5_("5.0 (Windows)")

    sign= get_sign(word,salt)



    post_data = {

        'i': word,

        'from': 'AUTO', 'to': 'AUTO', 'smartresult': 'dict', 'client': 'fanyideskweb', 'salt': salt,

        'sign': sign, 'ts': ts, 'bv': bv, 'doctype': 'json', 'version': '2.1',

        'keyfrom': 'fanyi.web', 'action': 'FY_BY_REALTIME', 'typoResult': 'false'

    }



    r = requests.post(

        url=url,

        headers=headers,

        data=post_data

    )



    for item in r.json().get('smartResult',{}).get('entries'):

        print(item)



word='student'

youdao(word)

得到结果：

Github：
https://github.com/Rockyzsu/CrawlMan/tree/master/youdao_dictionary
原创文章，转载请注明出处
http://30daydo.com/article/416

县城赚钱的暴利生意背后，收割穷人的血汗钱

闲聊 • 李魔佛发表了文章 • 0 个评论 • 4121 次浏览 • 2019-02-14 17:56 • 来自相关话题

文章来源：网上转载的，大部分都同意，除了最后一点。

年关难过年年过，但2019年的年关，着实有些不一样。
赶上年底办公地点搬迁，失去工位的评论君，被迫早早返乡，代号也从5A写字楼的Jeffrey转换成村头的二狗子。
作为长年在外务工人员，每次回乡过年，都是来去匆匆。
这次难得在家呆的时间长，年前穿梭在家乡的江南小城地级市，县城和乡村之间走亲戚。
见到听到的人和事，让我意识到，这个世界的折叠程度，远远超过自己的想象。
最震惊我的，是那些县城里赚钱未遂的人。

01
堂哥的灯具店要关门了
回乡见得第一个亲人，是堂哥。堂哥开了三年的灯具店终于撑不住了，考虑关掉，想听听我的意见。
堂哥是大伯家的独子，刚过而立之年。念书不行，高中毕业就跟着大伯做早餐生意，但起早贪黑，对年轻人来说，确实太难。
三年前，举全家之力，给堂哥在县城开了一家灯具店。
县城的生意逻辑在造势。为此，堂哥在银行贷了15万，把门店装修的很讲究。就这样，毫无灯具经营经验的堂哥一下子当上了老板。
店铺开起来，才知道有那么多活儿。
销售，上门安装，拉业务，催账，堂哥夫妻两根本忙不过来。于是，大伯的早餐店也盘出去，帮忙上门安装灯具，伯母负责做饭。
全家人围着店铺转，可生意还是每况愈下。
三年忙活下来，店铺的灯具品牌，从欧普、美的等知名品牌降级到杂牌产品。店铺租金太高，堂哥重找了个便宜店面。
最要命的是，三年前借的15万一分钱也没还。整个家庭陷入了进退不得的状态，还不如当初开早餐店。
对此，我觉得不可思议。问堂哥：
去年县城的房子不是卖得很不错嘛，怎么装修生意这么难做？
“炒房的太多了，哪有人真的装修。”
堂哥觉得很无力，我感到很震惊。“县城不到30万人，炒啥房！”
堂哥接触到最真实的市场情况，2018年，绝大多数县城的房子，都是被占坑式买房人买走的。
在外打工，听闻房价会涨，赶紧回家占个坑，或者是附近乡村的居民为了孩子念书，提前在县城买房。
这两类购房者，都不买堂哥的灯具。
堂哥的顾客，主要是周边乡镇自建房的农民。但自建房往往上门安装远，账又难收，利润薄如纸。
县城房地产市场火爆，与堂哥的灯具生意不仅毫无关系，还掏空了县城人们的腰包，导致堂哥的品牌灯具滞销，只能卖质差价廉的杂牌灯具。
堂哥盘点了一下，如果8万外账能顺利收回来。加上店里4万的灯具货量。再加上价值3万不到的拉货二手面包车，差不多还掉银行的贷款。
全家四个劳动力，忙活了三年，一分存款也没剩下。
堂哥盘算着：年底把店关了，明年大伯继续做早餐，自己考虑别的营生。
反正不开店不创业了。
如果说堂哥的灯具店的失败，是县城传统行业的缩影。另一件事，让我对县城的未来更担心了。

02
在老家卖水果的小刘
这是一个乡村创业故事，主人翁是我爷爷家隔壁邻居小孩小刘。
爷爷家是一个人口不到20万的乡镇，镇上只有一条街，底下还有七八个自然村，小刘比我小几岁。
我每次暑假回爷爷家，小刘每次就跟着我满田野里跑，他很机灵，但是不会念书。
长大后，我交了更厉害的朋友，便和小刘没了交集。
他成了我躺在好友列表里的微信好友。
通过他的朋友圈，我了解到，小刘初中肄业之后，一直在杭州一家百果园水果店工作。
2018年中，小刘突然微信找我，说自己要回乡创业，想听听我的建议。
我确认他不是借钱之后，松了一口气。正准备以受过高等教育的高级白领身份，好好点拨他。
小刘聊了他的想法，自己的家乡（我爷爷家的小镇）和大多是乡村一样，留守老人孩子多，但不舍得消费水果。
而在杭的老乡群里，很多老乡在外务工，想给家里留守儿童和老人买水果，既买不到，也无法送货上门。
小刘脑袋灵光，这可是一片蓝海。
杭州水果店的工作经验，让他基本摸清了生鲜店的进货渠道，和成本把控的诀窍。
再加上他长年担任门店的熟客微信群群主，对社群营销，更是有独到的见解。
我没想到，小刘的对于to C模式的理解，竟然如此深刻。
在我看来，这是典型的一线城市营销套路，对乡村市场的降维打击，无疑小刘真的是一个奇才。
于是，他决定回小镇开这样一个水果配送店。店很快开起来了。
小刘每天在群里，发当天水果照片和价格。
顾客大多是在外务工的年轻人，他们为尽孝心，也愿意花钱，通过微信转账的方式付款，小刘给客户家里留守老人和孩子配送，并拍视频作为反馈。
全新的营销方式，加上热心肠的小刘的服务态度，水果店的生意非常好。
但没想到，小刘的水果店还是没撑过春节。
自从开店以来，小刘开始每天凌晨进货，早上运营微信群，接单，配送。即使雇了人帮忙，小刘依然累得开车差点睡着。
忙不要紧，但不挣钱的瞎忙，就最致命了。
对生鲜产品来说，乡村的进货成本，远远超过了小刘的预期。为了控制坏果率，小刘每天凌晨，去最近的城市衢州市进货，结果是坏果率没下来，运输成本先上去了。
老家的人口本来就不多，加上很多老人一辈子节约惯了，心疼钱，所以对子女买来的新鲜水果有天然抗性。
人均收入低的乡村，自然客单价也提不上去，两边一挤压，小刘受不了。
这时候，小刘意识到，乡村的生鲜市场，被各大电商抛弃，不是没有原因的。
他在杭州这样的大城市看到的生鲜的刚性需求，到了乡村，一下子就变成伪需求了。
还没撑到车厘子上市的季节，小刘的店就关掉了，小刘重新回到杭州，找了一份月薪4000的工作。

03
县城的消费市场逻辑
不仅仅传统行业，在县城乡村的土壤无法生长，连小刘这样新颖的商业模式，也无法生存。
县城乡村的消费市场为什么如此萎靡？
我在思考，应该是是消费人口的缺失，导致购买力低下引起的。
年轻人是消费的主力军，但村里的上大学的年轻人，留在省会城市工作。没上学的年轻人，去沿海城市打工。
县城，好就好在消费水平低，坏就坏在，只有消费水平低。
县城缺乏机会，没有热钱，人情社会严重，缺乏工作岗位。寥寥的年轻人选择不多，不是挤破头考公务员，就是考教师资格证。
只有公务员和教师，才是体面的工作。
而就算是体面的工作，依然不会是高薪。这注定了县城的日常用品消费总需求固定，利润低。
消费升级的产品，根本没有对应消费人群。
当一线城市的杯均30RMB的喜茶/瑞幸咖啡/鹿角巷等遍地开花的时候，县城卖得最好的茶饮还是古茗，杯均10RMB。
罗胖在演讲里提到古茗成功的秘诀，县城和镇上晚上的灯光一般不够亮，你只要做一个很简单的事：就是把奶茶店门头的灯调得更亮，最好是能成为那条街上的路灯。
这样就能引起消费者的注意。
其实不然，客单价贴合县城的消费水准，才是奶茶店存活的不二法则。
否则，40块一杯的精品咖啡店开在县城，就算是用上疝气大灯照亮，依然没有市场。
我以为我找到了县城消费萎靡的元凶：购买力低下。
但后来的认知告诉我，我被重重地打脸了。

04
在县城，很多人都用力活着，但很少人用脑活着
虽然这么形容很刻薄，但看到人们花钱做出各种看似“无脑”的事情，真的很痛心。
在县城，似乎只有坑蒙拐骗，才能赚到钱。
和初中同学的饭桌上，听闻当年隔壁班的小美，做床垫生意，如今成为了县城排得上号的富婆。
联想到堂哥口中说的，县城里灯具生意，稍贵的品牌灯具卖不出去，只好卖便宜的杂牌灯具。
卖床垫能如此挣钱？我有些质疑真实性。
后来我知道，原来小美卖的，是玉石床垫，要价3万元到5万元不等，买的人络绎不绝。
没错，就是你第一时间想到的坑老年人的保健品床垫。
以送鸡蛋或大米的小恩惠，召集老年人开会、听课，宣传洗脑玉石床垫包治百病的功效，免费体验试睡。
每天大清早都有老人排队，等着免费“试睡”。不愿意排队的，或者觉得确实有功效的，就把养老钱掏出来买回家。
县城每一个赚钱的暴利生意背后，都是靠收割穷人的血汗钱而来的。
第二个血汗钱收割机，就是低价旅游。99元西湖两日游，399元香港三日游，699元三亚双飞豪华游。
这样大城市玩剩下的低价旅游骗局，在地方被受欢迎。结果可想而知，各种被套路买高价乳胶枕，玉石，名贵中药材等等案例遍地开花。
第三个血汗钱收割机，是民间借贷。p2p以及各种高息揽储的项目，你盯着别人的利息，别人看重的却是你的本金。
我爸告诉我，小时候带我练球的乒乓球教练，因为禁不住年化40%利息诱惑，民间借贷借出去200万遭遇爆雷，抛妻弃子，已经跑路了。
我很震惊，也很忿恨。
起早贪黑开球馆，抛去场地和雇教练的成本，净利润也不过年化20%，连腾讯这样的互联网独角兽的财报，净利润也达不到年化30%。
凭什么你会相信，你的全部养老钱可以躺赚年化40%的利润。

05
跳出这个财富链底层的四点劝诫
这个社会里，信息和财富的扩散，像是冲泡一杯蜜水，蜜总是从杯口慢慢渗透到杯底。
因为认知和信息的差距，导致县城和乡村，就是社会这杯蜜水的杯底。
在城市被淘汰的保健品骗局，入侵着这里的老年人。在大城市卖不动的假货，摆满了这里的货架。
这里的人们赚的不多，还最容易被骗。能不能跳出杯底，我有一些劝诫：
第一，保证全家人都能有健康的生活方式。
别说刚过温饱线的家庭，在疾病面前，连中产家庭也显得不堪一击。
ICU的床位费是1万一个晚上，特效药的报销比例接近于零。别听信“酒是粮食精，越喝越年轻”的鬼话。酒精和隔夜菜里的亚硝酸盐一样，都是一类致癌物。
第二，不要创业不要开店。
不要投入50万装修，开当地最大的网咖，因为等待着你的，是遥遥无期的回本之路。
不要开加工厂，一次工伤事故可能会吃掉你一年的利润。
不要试图开衣食住行以外的店，你的一己之力，无法违背市场规律。
小刘和堂哥，都是县城乡村创业的缩影。
作为一个没背景没资源的普通人，尽量找一份依靠技术和资源赚钱的工作，如果非要创业，请选择轻资产创业模式，不要梭哈。
第三，不要投资，不要炒股。
股票，是资本操纵下的负和游戏，穷人根本没有资格上牌桌。
徐翔案被曝光出的交易内幕，以及今年1月4号，央行降准消息发布前，券商入场拉升大盘等事件，都在说明一个真相：
我们生活在一个信息极不对等的世界里，那些先知先觉的人的背后，是一把把明晃晃的镰刀，等待收割散户。
而投资，同样是一件高门槛高风险的事情。
如果你遇到了一笔很容易的投资机会，它一定是个陷阱，包括但不限于p2p，民间借贷，分红型保险，原油螺纹钢等期货。
第四，为了孩子和自己的起点，请在能力范围内，在最高级别的城市，买房置业。
能买北上深，就不买杭广蓉，能买省会，就不买县城和地级市。
三四线房产只有居住属性，无金融属性。
如果还来得及，请卖掉三四线城市投资属性的房子。
未来三四线城市，将迎来滞涨时代查看全部

文章来源：网上转载的，大部分都同意，除了最后一点。

年关难过年年过，但2019年的年关，着实有些不一样。
赶上年底办公地点搬迁，失去工位的评论君，被迫早早返乡，代号也从5A写字楼的Jeffrey转换成村头的二狗子。
作为长年在外务工人员，每次回乡过年，都是来去匆匆。
这次难得在家呆的时间长，年前穿梭在家乡的江南小城地级市，县城和乡村之间走亲戚。
见到听到的人和事，让我意识到，这个世界的折叠程度，远远超过自己的想象。
最震惊我的，是那些县城里赚钱未遂的人。

01
堂哥的灯具店要关门了
回乡见得第一个亲人，是堂哥。堂哥开了三年的灯具店终于撑不住了，考虑关掉，想听听我的意见。
堂哥是大伯家的独子，刚过而立之年。念书不行，高中毕业就跟着大伯做早餐生意，但起早贪黑，对年轻人来说，确实太难。
三年前，举全家之力，给堂哥在县城开了一家灯具店。
县城的生意逻辑在造势。为此，堂哥在银行贷了15万，把门店装修的很讲究。就这样，毫无灯具经营经验的堂哥一下子当上了老板。
店铺开起来，才知道有那么多活儿。
销售，上门安装，拉业务，催账，堂哥夫妻两根本忙不过来。于是，大伯的早餐店也盘出去，帮忙上门安装灯具，伯母负责做饭。
全家人围着店铺转，可生意还是每况愈下。
三年忙活下来，店铺的灯具品牌，从欧普、美的等知名品牌降级到杂牌产品。店铺租金太高，堂哥重找了个便宜店面。
最要命的是，三年前借的15万一分钱也没还。整个家庭陷入了进退不得的状态，还不如当初开早餐店。
对此，我觉得不可思议。问堂哥：
去年县城的房子不是卖得很不错嘛，怎么装修生意这么难做？
“炒房的太多了，哪有人真的装修。”
堂哥觉得很无力，我感到很震惊。“县城不到30万人，炒啥房！”
堂哥接触到最真实的市场情况，2018年，绝大多数县城的房子，都是被占坑式买房人买走的。
在外打工，听闻房价会涨，赶紧回家占个坑，或者是附近乡村的居民为了孩子念书，提前在县城买房。
这两类购房者，都不买堂哥的灯具。
堂哥的顾客，主要是周边乡镇自建房的农民。但自建房往往上门安装远，账又难收，利润薄如纸。
县城房地产市场火爆，与堂哥的灯具生意不仅毫无关系，还掏空了县城人们的腰包，导致堂哥的品牌灯具滞销，只能卖质差价廉的杂牌灯具。
堂哥盘点了一下，如果8万外账能顺利收回来。加上店里4万的灯具货量。再加上价值3万不到的拉货二手面包车，差不多还掉银行的贷款。
全家四个劳动力，忙活了三年，一分存款也没剩下。
堂哥盘算着：年底把店关了，明年大伯继续做早餐，自己考虑别的营生。
反正不开店不创业了。
如果说堂哥的灯具店的失败，是县城传统行业的缩影。另一件事，让我对县城的未来更担心了。

02
在老家卖水果的小刘
这是一个乡村创业故事，主人翁是我爷爷家隔壁邻居小孩小刘。
爷爷家是一个人口不到20万的乡镇，镇上只有一条街，底下还有七八个自然村，小刘比我小几岁。
我每次暑假回爷爷家，小刘每次就跟着我满田野里跑，他很机灵，但是不会念书。
长大后，我交了更厉害的朋友，便和小刘没了交集。
他成了我躺在好友列表里的微信好友。
通过他的朋友圈，我了解到，小刘初中肄业之后，一直在杭州一家百果园水果店工作。
2018年中，小刘突然微信找我，说自己要回乡创业，想听听我的建议。
我确认他不是借钱之后，松了一口气。正准备以受过高等教育的高级白领身份，好好点拨他。
小刘聊了他的想法，自己的家乡（我爷爷家的小镇）和大多是乡村一样，留守老人孩子多，但不舍得消费水果。
而在杭的老乡群里，很多老乡在外务工，想给家里留守儿童和老人买水果，既买不到，也无法送货上门。
小刘脑袋灵光，这可是一片蓝海。
杭州水果店的工作经验，让他基本摸清了生鲜店的进货渠道，和成本把控的诀窍。
再加上他长年担任门店的熟客微信群群主，对社群营销，更是有独到的见解。
我没想到，小刘的对于to C模式的理解，竟然如此深刻。
在我看来，这是典型的一线城市营销套路，对乡村市场的降维打击，无疑小刘真的是一个奇才。
于是，他决定回小镇开这样一个水果配送店。店很快开起来了。
小刘每天在群里，发当天水果照片和价格。
顾客大多是在外务工的年轻人，他们为尽孝心，也愿意花钱，通过微信转账的方式付款，小刘给客户家里留守老人和孩子配送，并拍视频作为反馈。
全新的营销方式，加上热心肠的小刘的服务态度，水果店的生意非常好。
但没想到，小刘的水果店还是没撑过春节。
自从开店以来，小刘开始每天凌晨进货，早上运营微信群，接单，配送。即使雇了人帮忙，小刘依然累得开车差点睡着。
忙不要紧，但不挣钱的瞎忙，就最致命了。
对生鲜产品来说，乡村的进货成本，远远超过了小刘的预期。为了控制坏果率，小刘每天凌晨，去最近的城市衢州市进货，结果是坏果率没下来，运输成本先上去了。
老家的人口本来就不多，加上很多老人一辈子节约惯了，心疼钱，所以对子女买来的新鲜水果有天然抗性。
人均收入低的乡村，自然客单价也提不上去，两边一挤压，小刘受不了。
这时候，小刘意识到，乡村的生鲜市场，被各大电商抛弃，不是没有原因的。
他在杭州这样的大城市看到的生鲜的刚性需求，到了乡村，一下子就变成伪需求了。
还没撑到车厘子上市的季节，小刘的店就关掉了，小刘重新回到杭州，找了一份月薪4000的工作。

03
县城的消费市场逻辑
不仅仅传统行业，在县城乡村的土壤无法生长，连小刘这样新颖的商业模式，也无法生存。
县城乡村的消费市场为什么如此萎靡？
我在思考，应该是是消费人口的缺失，导致购买力低下引起的。
年轻人是消费的主力军，但村里的上大学的年轻人，留在省会城市工作。没上学的年轻人，去沿海城市打工。
县城，好就好在消费水平低，坏就坏在，只有消费水平低。
县城缺乏机会，没有热钱，人情社会严重，缺乏工作岗位。寥寥的年轻人选择不多，不是挤破头考公务员，就是考教师资格证。
只有公务员和教师，才是体面的工作。
而就算是体面的工作，依然不会是高薪。这注定了县城的日常用品消费总需求固定，利润低。
消费升级的产品，根本没有对应消费人群。
当一线城市的杯均30RMB的喜茶/瑞幸咖啡/鹿角巷等遍地开花的时候，县城卖得最好的茶饮还是古茗，杯均10RMB。
罗胖在演讲里提到古茗成功的秘诀，县城和镇上晚上的灯光一般不够亮，你只要做一个很简单的事：就是把奶茶店门头的灯调得更亮，最好是能成为那条街上的路灯。
这样就能引起消费者的注意。
其实不然，客单价贴合县城的消费水准，才是奶茶店存活的不二法则。
否则，40块一杯的精品咖啡店开在县城，就算是用上疝气大灯照亮，依然没有市场。
我以为我找到了县城消费萎靡的元凶：购买力低下。
但后来的认知告诉我，我被重重地打脸了。

04
在县城，很多人都用力活着，但很少人用脑活着
虽然这么形容很刻薄，但看到人们花钱做出各种看似“无脑”的事情，真的很痛心。
在县城，似乎只有坑蒙拐骗，才能赚到钱。
和初中同学的饭桌上，听闻当年隔壁班的小美，做床垫生意，如今成为了县城排得上号的富婆。
联想到堂哥口中说的，县城里灯具生意，稍贵的品牌灯具卖不出去，只好卖便宜的杂牌灯具。
卖床垫能如此挣钱？我有些质疑真实性。
后来我知道，原来小美卖的，是玉石床垫，要价3万元到5万元不等，买的人络绎不绝。
没错，就是你第一时间想到的坑老年人的保健品床垫。
以送鸡蛋或大米的小恩惠，召集老年人开会、听课，宣传洗脑玉石床垫包治百病的功效，免费体验试睡。
每天大清早都有老人排队，等着免费“试睡”。不愿意排队的，或者觉得确实有功效的，就把养老钱掏出来买回家。
县城每一个赚钱的暴利生意背后，都是靠收割穷人的血汗钱而来的。
第二个血汗钱收割机，就是低价旅游。99元西湖两日游，399元香港三日游，699元三亚双飞豪华游。
这样大城市玩剩下的低价旅游骗局，在地方被受欢迎。结果可想而知，各种被套路买高价乳胶枕，玉石，名贵中药材等等案例遍地开花。
第三个血汗钱收割机，是民间借贷。p2p以及各种高息揽储的项目，你盯着别人的利息，别人看重的却是你的本金。
我爸告诉我，小时候带我练球的乒乓球教练，因为禁不住年化40%利息诱惑，民间借贷借出去200万遭遇爆雷，抛妻弃子，已经跑路了。
我很震惊，也很忿恨。
起早贪黑开球馆，抛去场地和雇教练的成本，净利润也不过年化20%，连腾讯这样的互联网独角兽的财报，净利润也达不到年化30%。
凭什么你会相信，你的全部养老钱可以躺赚年化40%的利润。

05
跳出这个财富链底层的四点劝诫
这个社会里，信息和财富的扩散，像是冲泡一杯蜜水，蜜总是从杯口慢慢渗透到杯底。
因为认知和信息的差距，导致县城和乡村，就是社会这杯蜜水的杯底。
在城市被淘汰的保健品骗局，入侵着这里的老年人。在大城市卖不动的假货，摆满了这里的货架。
这里的人们赚的不多，还最容易被骗。能不能跳出杯底，我有一些劝诫：
第一，保证全家人都能有健康的生活方式。
别说刚过温饱线的家庭，在疾病面前，连中产家庭也显得不堪一击。
ICU的床位费是1万一个晚上，特效药的报销比例接近于零。别听信“酒是粮食精，越喝越年轻”的鬼话。酒精和隔夜菜里的亚硝酸盐一样，都是一类致癌物。
第二，不要创业不要开店。
不要投入50万装修，开当地最大的网咖，因为等待着你的，是遥遥无期的回本之路。
不要开加工厂，一次工伤事故可能会吃掉你一年的利润。
不要试图开衣食住行以外的店，你的一己之力，无法违背市场规律。
小刘和堂哥，都是县城乡村创业的缩影。
作为一个没背景没资源的普通人，尽量找一份依靠技术和资源赚钱的工作，如果非要创业，请选择轻资产创业模式，不要梭哈。
第三，不要投资，不要炒股。
股票，是资本操纵下的负和游戏，穷人根本没有资格上牌桌。
徐翔案被曝光出的交易内幕，以及今年1月4号，央行降准消息发布前，券商入场拉升大盘等事件，都在说明一个真相：
我们生活在一个信息极不对等的世界里，那些先知先觉的人的背后，是一把把明晃晃的镰刀，等待收割散户。
而投资，同样是一件高门槛高风险的事情。
如果你遇到了一笔很容易的投资机会，它一定是个陷阱，包括但不限于p2p，民间借贷，分红型保险，原油螺纹钢等期货。
第四，为了孩子和自己的起点，请在能力范围内，在最高级别的城市，买房置业。
能买北上深，就不买杭广蓉，能买省会，就不买县城和地级市。
三四线房产只有居住属性，无金融属性。
如果还来得及，请卖掉三四线城市投资属性的房子。
未来三四线城市，将迎来滞涨时代

python 中文图片文字识别

python • 李魔佛发表了文章 • 0 个评论 • 6855 次浏览 • 2019-02-01 10:47 • 来自相关话题

pytesseract这个库识别率偏低，也就菜鸟才会用。
使用方法很简单，安装好pytesseract（里面很多坑，小白的话不可避免要折腾一番），然后下载一个中文的字库，百度网盘：https://pan.baidu.com/s/1_jom2d95IeR40gsvkhUuvQ

然后把文件放到tesseract的文件夹中 C:\Program Files (x86)\Tesseract-OCR\tessdata
然后就可以拿来识别了：
from PIL import Image
im = Image.open('chinese.jpg')
plt.figure(figsize=(20,20))
plt.imshow(im)

pytesseract.image_to_string(im,lang='chi_sim')
图片的内容是这样的：

然后识别效果如下：

'可L又使用以下的语句i上图片显示大此'
还是不咋地。

那么可以换成大厂的API。试试百度的：
""" 读取图片 """
def get_file_content(filePath):
with open(filePath, 'rb') as fp:
return fp.read()

image = get_file_content('example.jpg')

""" 调用通用文字识别, 图片参数为本地图片 """
client.basicGeneral(image);

""" 如果有可选参数 """
options = {}
options["language_type"] = "CHN_ENG"
options["detect_direction"] = "true"
options["detect_language"] = "true"
options["probability"] = "true"

from aip import AipOcr

""" 你的 APPID AK SK """
APP_ID = '你的 App ID'
API_KEY = '你的 Api Key'
SECRET_KEY = '你的 Secret Key'

client = AipOcr(APP_ID, API_KEY, SECRET_KEY)

""" 带参数调用通用文字识别, 图片参数为本地图片 """
client.basicGeneral(image, options)

url = "https//www.x.com/sample.jpg"

""" 调用通用文字识别, 图片参数为远程url图片 """
client.basicGeneralUrl(url);

""" 如果有可选参数 """
options = {}
options["language_type"] = "CHN_ENG"
options["detect_direction"] = "true"
options["detect_language"] = "true"
options["probability"] = "true"

""" 带参数调用通用文字识别, 图片参数为远程url图片 """
client.basicGeneralUrl(url, options)
先去百度云申请一个API，免费的。
https://cloud.baidu.com/doc/OCR/OCR-Python-SDK.html#.E9.85.8D.E7.BD.AEAipOcr
然后把key复制到上面的代码中就可以了。

然后再调用看看结果：
可以使用以下的语句让图片显示大些正确率明显高很多了。

查看全部

pytesseract这个库识别率偏低，也就菜鸟才会用。
使用方法很简单，安装好pytesseract（里面很多坑，小白的话不可避免要折腾一番），然后下载一个中文的字库，百度网盘：https://pan.baidu.com/s/1_jom2d95IeR40gsvkhUuvQ

然后把文件放到tesseract的文件夹中 C:\Program Files (x86)\Tesseract-OCR\tessdata
然后就可以拿来识别了：

from PIL import Image

im = Image.open('chinese.jpg')

plt.figure(figsize=(20,20))

plt.imshow(im)



pytesseract.image_to_string(im,lang='chi_sim')

图片的内容是这样的：

然后识别效果如下：

'可L又使用以下的语句i上图片显示大 此'

还是不咋地。

那么可以换成大厂的API。试试百度的：

""" 读取图片 """

def get_file_content(filePath):

    with open(filePath, 'rb') as fp:

        return fp.read()



image = get_file_content('example.jpg')



""" 调用通用文字识别, 图片参数为本地图片 """

client.basicGeneral(image);



""" 如果有可选参数 """

options = {}

options["language_type"] = "CHN_ENG"

options["detect_direction"] = "true"

options["detect_language"] = "true"

options["probability"] = "true"



from aip import AipOcr



""" 你的 APPID AK SK """

APP_ID = '你的 App ID'

API_KEY = '你的 Api Key'

SECRET_KEY = '你的 Secret Key'



client = AipOcr(APP_ID, API_KEY, SECRET_KEY)





""" 带参数调用通用文字识别, 图片参数为本地图片 """

client.basicGeneral(image, options)



url = "https//www.x.com/sample.jpg"



""" 调用通用文字识别, 图片参数为远程url图片 """

client.basicGeneralUrl(url);



""" 如果有可选参数 """

options = {}

options["language_type"] = "CHN_ENG"

options["detect_direction"] = "true"

options["detect_language"] = "true"

options["probability"] = "true"



""" 带参数调用通用文字识别, 图片参数为远程url图片 """

client.basicGeneralUrl(url, options)

先去百度云申请一个API，免费的。
https://cloud.baidu.com/doc/OCR/OCR-Python-SDK.html#.E9.85.8D.E7.BD.AEAipOcr
然后把key复制到上面的代码中就可以了。

然后再调用看看结果：

可以使用以下的语句让图片显示大些

正确率明显高很多了。

可转债价格分布堆叠图绘制可视化 python+pyecharts

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 7904 次浏览 • 2019-01-30 10:59 • 来自相关话题

这一节课带大家学习如何利用可视化，更好的呈现数据。
即使你有很多数据，可是，你无法直观地看到数据的总体趋势。使用可视化的绘图，可以帮助我们看到数据背后看不到的数据。比如我已经有每一个可转债的价格，评级。数据如下：

点击查看大图

如果我用下面的图形就可以看出规律：

点击查看大图

横坐标是价格，纵坐标是落在该价格的可转债数量，不同颜色代表不同评级的可转债。

可以看到大部分AA-评级（浅橙色）的可转债价格都在100元以下，而AA（浅蓝色）的可转债价格分布较为平均，从90到110都有。而AA+和AAA的一般都在100以上。

那么如何使用代码实现呢？from setting import get_mysql_conn,get_engine
import pandas as pd
import pymongo
from pyecharts import Geo,Style,Map
engine = get_engine('db_stock',local='local')
# 堆叠图
from pyecharts import Bar
df = pd.read_sql('tb_bond_jisilu',con=engine)

result ={}
for name,grades in df.groupby('评级'):
# print(name,grades[['可转债名称','可转债价格']])
for each in grades['可转债价格']:
result.setdefault(name,)
result[name].append(each)

# 确定价格的范围

value = [str(i) for i in range(85,140)]
ret = [0]*len(value)
ret1 = dict(zip(value,ret))

ret_A_add = ret1.copy()
for item in result['A+']:
for k in ret1:
if float(k)+0.5>item and float(k)-0.5<=item:
ret_A_add[k]+=1

retAA_ = ret1.copy()
for item in result['']:
for k in ret1:
if float(k)+0.5>item and float(k)-0.5<=item:
retAA_[k]+=1

retAA = ret1.copy()
for item in result['AA']:
for k in ret1:
if float(k)+0.5>item and float(k)-0.5<=item:
retAA[k]+=1

retAA_add = ret1.copy()
for item in result['AA+']:
for k in ret1:
if float(k)+0.5>item and float(k)-0.5<=item:
retAA_add[k]+=1

retAAA = ret1.copy()
for item in result['AAA']:
for k in ret1:
if float(k)+0.5>item and float(k)-0.5<=item:
retAAA[k]+=1

bar = Bar('可转债价格分布')
bar.add('A+',value,list(ret_A_add.values()),is_stack=True,yaxis_max=11)
bar.add('',value,list(retAA_.values()),is_stack=True,yaxis_max=11)
bar.add('AA',value,list(retAA.values()),is_stack=True,yaxis_max=11)
bar.add('AA+',value,list(retAA_add.values()),is_stack=True,yaxis_max=11)
bar.add('AAA',value,list(retAAA.values()),is_stack=True,yaxis_max=11)
如果没有安装pyecharts，需要用pip安装即可。

原创文章
转载请注明出处：
http://30daydo.com/article/400

查看全部

这一节课带大家学习如何利用可视化，更好的呈现数据。
即使你有很多数据，可是，你无法直观地看到数据的总体趋势。使用可视化的绘图，可以帮助我们看到数据背后看不到的数据。比如我已经有每一个可转债的价格，评级。数据如下：

点击查看大图

如果我用下面的图形就可以看出规律：

点击查看大图

横坐标是价格，纵坐标是落在该价格的可转债数量，不同颜色代表不同评级的可转债。

可以看到大部分AA-评级（浅橙色）的可转债价格都在100元以下，而AA（浅蓝色）的可转债价格分布较为平均，从90到110都有。而AA+和AAA的一般都在100以上。

那么如何使用代码实现呢？

from  setting import get_mysql_conn,get_engine

import pandas as pd

import pymongo

from pyecharts import Geo,Style,Map

engine = get_engine('db_stock',local='local')

# 堆叠图

from pyecharts import Bar

df = pd.read_sql('tb_bond_jisilu',con=engine)



result ={}

for name,grades in df.groupby('评级'):

#     print(name,grades[['可转债名称','可转债价格']])

    for each in grades['可转债价格']:

        result.setdefault(name,)

        result[name].append(each)

        

        

# 确定价格的范围



value = [str(i) for i in range(85,140)]

ret = [0]*len(value)

ret1 = dict(zip(value,ret))



ret_A_add = ret1.copy()

for item in result['A+']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            ret_A_add[k]+=1

            

retAA_ = ret1.copy()

for item in result['']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAA_[k]+=1



retAA = ret1.copy()

for item in result['AA']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAA[k]+=1

            

retAA_add = ret1.copy()

for item in result['AA+']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAA_add[k]+=1

            

retAAA = ret1.copy()

for item in result['AAA']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAAA[k]+=1



bar = Bar('可转债价格分布')

bar.add('A+',value,list(ret_A_add.values()),is_stack=True,yaxis_max=11)

bar.add('',value,list(retAA_.values()),is_stack=True,yaxis_max=11)

bar.add('AA',value,list(retAA.values()),is_stack=True,yaxis_max=11)

bar.add('AA+',value,list(retAA_add.values()),is_stack=True,yaxis_max=11)

bar.add('AAA',value,list(retAAA.values()),is_stack=True,yaxis_max=11)

如果没有安装pyecharts，需要用pip安装即可。

原创文章
转载请注明出处：
http://30daydo.com/article/400

可转债套利【一】 python找出折价可转债个股

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 9 个评论 • 20537 次浏览 • 2018-03-16 17:17 • 来自相关话题

关于可转债的定义，可以到https://xueqiu.com/6832369826/103042836 这里科普一下。

下面的内容默认你对可转债已经有一定的了解。

可转债的价值=正股价格/转股价格 + 利息，忽略可转债的利息，直接用公式可转债的价值=正股价格/转股价格计算可转债的价值。

如果当前可转债的交易价格（在交易软件上显示的价格）如：

所以万信转债的价格是121.5元，然后万信转债的价值呢？按照上面的公式，万信转债的正股是万达信息，今天万达信息（2018-03-16）的股价是

以收盘价为例，17.25。

而万信转债的股转价格呢？这个可以到万信转债F10页面的公告中找到，为13.11元。所以万信转债的价值是
17.25/13.11 = 1.315 , 可转债单位是100，所以万信转债的内在价值是1.315*100=131.5，而当前的交易价格为 121.5

也就是你用121.5元买到一个价值 131.5的商品，所以相当于打折买到了一个超值的商品，所以当前的万信转债是折价状态。

所以本次任务就是要找出可交易的可转债中折价状态的可转债。

然后直接上干货。上python代码。#-*-coding=utf-8
'''
可转债监控
'''
import tushare as ts
from setting import get_engine
engine = get_engine('db_bond')
import pandas as pd
import datetime
class ConvertBond():

def __init__(self):
self.conn=ts.get_apis()
self.allBonds=ts.new_cbonds(pause=2)
self.onSellBond=self.allBonds.dropna(subset=['marketprice'])
self.today=datetime.datetime.now().strftime('%Y-%m-%d %H:%M')

def stockPrice(self,code):
stock_df = ts.get_realtime_quotes(code)
price = float(stock_df['price'].values[0])
return price

def dataframe(self):
price_list=
for code in self.onSellBond['scode']:
price_list.append(self.stockPrice(code))
self.onSellBond['stock_price']=price_list
self.onSellBond['ratio'] = (
self.onSellBond['marketprice']
/(self.onSellBond['stock_price'] / self.onSellBond['convprice'])-1)*100
self.onSellBond['Updated']=self.today
self.onSellBond.to_sql('tb_bond',engine,if_exists='replace')

def closed(self):
ts.close_apis(self.conn)

def main():
bond=ConvertBond()
bond.dataframe()
bond.closed()
if __name__=='__main__':
main()

上面的setting库，把下面的*** 替换成你自己的Mysql用户和密码即可。import os
import MySQLdb
MYSQL_USER = *********
MYSQL_PASSWORD = ********
MYSQL_HOST = *********
MYSQL_PORT = *****

def get_engine(db):
engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(MYSQL_USER, MYSQL_PASSWORD, MYSQL_HOST, MYSQL_PORT, db))
return engine
上面的少于100行的代码就能够满足你的要求。
运行后会把结果保存在MySQL 数据库。如下图所示：

点击放大
2018-03-16 可转债表格

其中折价率是ratio列。按照ratio列进行排列，只有2个是正，也就是当前市场是只有2只可转债是处于折价状态的，其余的都是溢价状态（价格比内在价值要贵，忽略利息的前提下，如果把4~5%的利息也算进去的话，-3~4%的折价率其实也算小折价吧）

目前万信转债折价10个点，宝信转债折价5.8个点。所以适合低风险投资者建仓。因为可转债有兜底价格，所以出现亏损的概率很低（除非遇到黑天鹅，公司破产了，像遇到乐视这种PPT独角兽公司，欠债不还的。但是A股上能够有资格发行可转债的，本身对公司的盈利，分红都有硬性要求）。

所以可以保存上面的代码，可以每天运行一次，可以很方便地找出折价的个股，当然也可以在盘中一直监测，因为可转债的价格是实时变化的，一旦遇到大跌，跌到折价状态，你也可以择时入手标的。

原文链接：
http://30daydo.com/article/286
转载请注明出处

可转债低费率，沪市百万分之二，深圳十万分之四，免五开户
加微信开通

查看全部

关于可转债的定义，可以到https://xueqiu.com/6832369826/103042836 这里科普一下。

下面的内容默认你对可转债已经有一定的了解。

可转债的价值=正股价格/转股价格 + 利息，忽略可转债的利息，直接用公式可转债的价值=正股价格/转股价格计算可转债的价值。

如果当前可转债的交易价格（在交易软件上显示的价格）如：

所以万信转债的价格是121.5元，然后万信转债的价值呢？按照上面的公式，万信转债的正股是万达信息，今天万达信息（2018-03-16）的股价是

以收盘价为例，17.25。

而万信转债的股转价格呢？这个可以到万信转债F10页面的公告中找到，为13.11元。所以万信转债的价值是
17.25/13.11 = 1.315 , 可转债单位是100，所以万信转债的内在价值是1.315*100=131.5，而当前的交易价格为 121.5

也就是你用121.5元买到一个价值 131.5的商品，所以相当于打折买到了一个超值的商品，所以当前的万信转债是折价状态。

所以本次任务就是要找出可交易的可转债中折价状态的可转债。

然后直接上干货。上python代码。

#-*-coding=utf-8

'''

可转债监控

'''

import tushare as ts

from setting import get_engine

engine = get_engine('db_bond')

import pandas as pd

import datetime

class ConvertBond():



    def __init__(self):

        self.conn=ts.get_apis()

        self.allBonds=ts.new_cbonds(pause=2)

        self.onSellBond=self.allBonds.dropna(subset=['marketprice'])

        self.today=datetime.datetime.now().strftime('%Y-%m-%d %H:%M')



    def stockPrice(self,code):

        stock_df = ts.get_realtime_quotes(code)

        price = float(stock_df['price'].values[0])

        return price



    def dataframe(self):

        price_list=

        for code in self.onSellBond['scode']:

            price_list.append(self.stockPrice(code))

        self.onSellBond['stock_price']=price_list

        self.onSellBond['ratio'] = (

self.onSellBond['marketprice']

/(self.onSellBond['stock_price'] / self.onSellBond['convprice'])-1)*100

        self.onSellBond['Updated']=self.today

        self.onSellBond.to_sql('tb_bond',engine,if_exists='replace')



    def closed(self):

        ts.close_apis(self.conn)



def main():

    bond=ConvertBond()

    bond.dataframe()

    bond.closed()

if __name__=='__main__':

    main()

上面的setting库，把下面的*** 替换成你自己的Mysql用户和密码即可。

import os

import MySQLdb

MYSQL_USER = *********

MYSQL_PASSWORD = ********

MYSQL_HOST = *********

MYSQL_PORT = *****



def get_engine(db):

    engine = create_engine('mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(MYSQL_USER, MYSQL_PASSWORD, MYSQL_HOST, MYSQL_PORT, db))

    return engine

上面的少于100行的代码就能够满足你的要求。
运行后会把结果保存在MySQL 数据库。如下图所示：

点击放大
2018-03-16 可转债表格

其中折价率是ratio列。按照ratio列进行排列，只有2个是正，也就是当前市场是只有2只可转债是处于折价状态的，其余的都是溢价状态（价格比内在价值要贵，忽略利息的前提下，如果把4~5%的利息也算进去的话，-3~4%的折价率其实也算小折价吧）

目前万信转债折价10个点，宝信转债折价5.8个点。所以适合低风险投资者建仓。因为可转债有兜底价格，所以出现亏损的概率很低（除非遇到黑天鹅，公司破产了，像遇到乐视这种PPT独角兽公司，欠债不还的。但是A股上能够有资格发行可转债的，本身对公司的盈利，分红都有硬性要求）。

所以可以保存上面的代码，可以每天运行一次，可以很方便地找出折价的个股，当然也可以在盘中一直监测，因为可转债的价格是实时变化的，一旦遇到大跌，跌到折价状态，你也可以择时入手标的。

原文链接：
http://30daydo.com/article/286
转载请注明出处

可转债低费率，沪市百万分之二，深圳十万分之四，免五开户
加微信开通

dataframe reindex和reset_index区别

量化交易-Ptrade-QMT • 李魔佛发表了文章 • 0 个评论 • 84455 次浏览 • 2017-12-30 15:58 • 来自相关话题

reset_index的作用是重新设置dataframe的index，范围为0~len（df）。 df = pd.DataFrame({'A': [1, 2, 3, 4, 5], 'B': [10, 20, 30, 40, 50]})
df2 = pd.DataFrame({'A': [6], 'B': [60]})
print('df', df)
print('df2', df2)

df_x = [df, df2]
result = pd.concat(df_x)
print('first result ', result)
上面代码把df和df2合并为一个result，但是result的index是乱的。

那么执行result2= result.reset_index()
得到如下的result2：（默认只是返回一个copy，原来的result没有发生改变，所以需要副本赋值给result2）

可以看到，原来的一列index现在变成了columns之一，新的index为[0,1,2,3,4,5]
如果添加参数 reset_index(drop=True) 那么原index会被丢弃，不会显示为一个新列。result2 = result.reset_index(drop=True)

reindex的作用是按照原有的列进行重新生成一个新的df。

还是使用上面的代码
result目前是df和df2的合并序列。
如下：

可以看到index为[0,1,2,3,4,0]
执行 result3 = result.reindex(columns=['A','C'])

可以看到，原index并没有发生改变，而列变成了A和C，因为C是不存在的，所以使用了NaB填充，这个值的内容可以自己填充，可以改为默认填充0或者任意你想要的数据。reindex(columns=..)的作用类似于重新把列的顺序整理一遍，而使用reindex(index=....) 则按照行重新整理一遍。

原文链接：http://30daydo.com/article/257
欢迎转载，注明出处
查看全部

reset_index的作用是重新设置dataframe的index，范围为0~len（df）。

    df = pd.DataFrame({'A': [1, 2, 3, 4, 5], 'B': [10, 20, 30, 40, 50]})

    df2 = pd.DataFrame({'A': [6], 'B': [60]})

    print('df', df)

    print('df2', df2)



    df_x = [df, df2]

    result = pd.concat(df_x)

    print('first result ', result)

上面代码把df和df2合并为一个result，但是result的index是乱的。

那么执行

result2= result.reset_index()

得到如下的result2：（默认只是返回一个copy，原来的result没有发生改变，所以需要副本赋值给result2）

可以看到，原来的一列index现在变成了columns之一，新的index为[0,1,2,3,4,5]
如果添加参数 reset_index(drop=True) 那么原index会被丢弃，不会显示为一个新列。

result2 = result.reset_index(drop=True)

reindex的作用是按照原有的列进行重新生成一个新的df。

还是使用上面的代码
result目前是df和df2的合并序列。
如下：

可以看到index为[0,1,2,3,4,0]
执行

result3 = result.reindex(columns=['A','C'])

可以看到，原index并没有发生改变，而列变成了A和C，因为C是不存在的，所以使用了NaB填充，这个值的内容可以自己填充，可以改为默认填充0或者任意你想要的数据。reindex(columns=..)的作用类似于重新把列的顺序整理一遍，而使用reindex(index=....) 则按照行重新整理一遍。

原文链接：http://30daydo.com/article/257
欢迎转载，注明出处

每天一道leetcode题目 30天尝试新事情

30天新尝试 • 李魔佛发表了文章 • 0 个评论 • 4762 次浏览 • 2017-02-24 12:14 • 来自相关话题

忽然觉得自己基础知识忘了不少。所以打算做做传说中的刷题神器－－leetcode。题目在官网： https://leetcode.com

从接受度排序，先挑战接受度高的题目，然后循序渐进。

每天更新在这个帖子里面。（最近发现另外一个在线编程练习网站lintcode，题目都免费，而且适合国内的公司，也开始在做了，这些题目后面会在这个贴子里更新吧）

Day 1 2017-2-25
leetcode Day1 Two Sum 两数之和
http://30daydo.com/article/145

Day 2 2017-2-26
leetcode Day2 Hamming Distance 海明距离
http://30daydo.com/article/146

Day3 2017-2-27
leetcode Day3 complement number 【补码】
http://30daydo.com/article/147

Day4 2017-2-28
leetcode Day4 Keyboard Row 键盘中的行
http://30daydo.com/article/148

Day4 2017-3-1
Day5 leetcode Next Greater Element 下一个更大的元素
http://30daydo.com/article/150

Day4 2017-3-7
Day6 leetcode Fizz Buzz 字符转换游戏（实在不知道该怎么翻译这个）
http://30daydo.com/article/151

查看全部

忽然觉得自己基础知识忘了不少。所以打算做做传说中的刷题神器－－leetcode。题目在官网： https://leetcode.com

从接受度排序，先挑战接受度高的题目，然后循序渐进。

每天更新在这个帖子里面。（最近发现另外一个在线编程练习网站lintcode，题目都免费，而且适合国内的公司，也开始在做了，这些题目后面会在这个贴子里更新吧）

Day 1 2017-2-25
leetcode Day1 Two Sum 两数之和
http://30daydo.com/article/145

Day 2 2017-2-26
leetcode Day2 Hamming Distance 海明距离
http://30daydo.com/article/146

Day3 2017-2-27
leetcode Day3 complement number 【补码】
http://30daydo.com/article/147

Day4 2017-2-28
leetcode Day4 Keyboard Row 键盘中的行
http://30daydo.com/article/148

Day4 2017-3-1
Day5 leetcode Next Greater Element 下一个更大的元素
http://30daydo.com/article/150

Day4 2017-3-7
Day6 leetcode Fizz Buzz 字符转换游戏（实在不知道该怎么翻译这个）
http://30daydo.com/article/151

撸羊毛系列定期更新 2017-04-20 **

30天新尝试 • 绫波丽发表了文章 • 0 个评论 • 5910 次浏览 • 2016-12-07 02:24 • 来自相关话题

开一个系列的帖子，记录一些常有的撸羊毛的方法，蚊子都是肉呀~ 嘻嘻。（坚决不碰P2P）
更新时间 ***************2017-04-20*******************

立马理财（网易和光大银行一起推出的，信得过）
新注册马上送30元，推荐的注册用户送50元。而且主页有个活动，扫码就可以拿现金奖励。
新人注册会有6.6个点的收益，还有8888的体验金。

百度理财：
推荐新人可以拿到推荐金，为0.45％个点。而且是马上到账的。被推荐的人期间还可以拿9%的双倍年化收益。
以我为例，推荐我亲戚注册并投资了几万块，30天的货币基金。我就拿到360元的奖励（马上到账可以体现）。
而亲戚拿到了200多的9%双倍年化（只送几天），然后还有正常的6%的年化收益。

支付宝提现按照下面的方法可以不花手续费

2016年10月支付宝对提现收取千分之一的手续费。只要你的钱一旦进入支付宝，要出来就要收取手续费。你把钱投入到余额宝，转出来也只能赚到余额，不能直接转回卡里面。所以到时是谁在乱说通过余额宝可以绕开这个提现的手续费的？说出来，我保证不打断你的腿。

阿里旗下有一个浙江的网商银行，在支付宝里面，“我的” 菜单下面，然后在底下有一个网商银行，注册并且绑定银行卡，那么就可以直接把钱从支付宝转出到网商银行（马上到账），然后就可以在网商银行里直接体现，关键是马上到账！！且不收手续费！！

更新时间 ***************2017-01-19 *******************

最近京东理财有送券的，定存一个月，马上送20元现金券（定存1w有20元，定存1k的只有5元），直接发到银行卡。而定存的一个月是按照正常的利息计算，年化大概4个点。

支付宝的福字：有一个福字，爱国福，会有18元的现金券，需要你开通阿里的网商银行，这个开通了马上就可以提现。

最近的年底逆回购利率比较高，可以把平时存在货币基金的钱取出来做做逆回购。

今天1天逆回购最高有15个点的年化收益。

更新时间 *******2016-12-06********

最近微信理财通有一个领取红包的活动，第一次可以免费领取3.99的现金。
首先充1元到理财通，然后就可以获得3.99，然后总共有4.99元，可以马上就体现到银行卡

然后第二次刘涛会发红包给你，需要你投入1000理财金额，就可以获得25元的红包，不过这1025总额要锁定一个月才能取出来，当然1000元每天都有年化2.5%的收益（约等于5分钱）。

更多的讨论可以加QQ群：613194389 查看全部

开一个系列的帖子，记录一些常有的撸羊毛的方法，蚊子都是肉呀~ 嘻嘻。（坚决不碰P2P）
更新时间 ***************2017-04-20*******************

立马理财（网易和光大银行一起推出的，信得过）
新注册马上送30元，推荐的注册用户送50元。而且主页有个活动，扫码就可以拿现金奖励。
新人注册会有6.6个点的收益，还有8888的体验金。

百度理财：
推荐新人可以拿到推荐金，为0.45％个点。而且是马上到账的。被推荐的人期间还可以拿9%的双倍年化收益。
以我为例，推荐我亲戚注册并投资了几万块，30天的货币基金。我就拿到360元的奖励（马上到账可以体现）。
而亲戚拿到了200多的9%双倍年化（只送几天），然后还有正常的6%的年化收益。

支付宝提现按照下面的方法可以不花手续费

2016年10月支付宝对提现收取千分之一的手续费。只要你的钱一旦进入支付宝，要出来就要收取手续费。你把钱投入到余额宝，转出来也只能赚到余额，不能直接转回卡里面。所以到时是谁在乱说通过余额宝可以绕开这个提现的手续费的？说出来，我保证不打断你的腿。

阿里旗下有一个浙江的网商银行，在支付宝里面，“我的” 菜单下面，然后在底下有一个网商银行，注册并且绑定银行卡，那么就可以直接把钱从支付宝转出到网商银行（马上到账），然后就可以在网商银行里直接体现，关键是马上到账！！且不收手续费！！

更新时间 ***************2017-01-19 *******************

最近京东理财有送券的，定存一个月，马上送20元现金券（定存1w有20元，定存1k的只有5元），直接发到银行卡。而定存的一个月是按照正常的利息计算，年化大概4个点。

支付宝的福字：有一个福字，爱国福，会有18元的现金券，需要你开通阿里的网商银行，这个开通了马上就可以提现。

最近的年底逆回购利率比较高，可以把平时存在货币基金的钱取出来做做逆回购。

今天1天逆回购最高有15个点的年化收益。

更新时间 *******2016-12-06********

最近微信理财通有一个领取红包的活动，第一次可以免费领取3.99的现金。
首先充1元到理财通，然后就可以获得3.99，然后总共有4.99元，可以马上就体现到银行卡

然后第二次刘涛会发红包给你，需要你投入1000理财金额，就可以获得25元的红包，不过这1025总额要锁定一个月才能取出来，当然1000元每天都有年化2.5%的收益（约等于5分钱）。

更多的讨论可以加QQ群：613194389

自学能力强大的人在任何领域都会无比强大！

30天新尝试 • 低调的哥哥发表了文章 • 0 个评论 • 10342 次浏览 • 2016-08-06 11:03 • 来自相关话题

每个人身边都会有牛人，似乎这些牛人从来不会为某一件事情而费劲，而某些人却为某些事情费尽九牛二虎之力也无法把事情解决。大学时期班上总有那么几个家伙，可以经常打游戏，打球，泡妞，而最终期末考试成绩却还是名列前茅，让人羡慕妒忌恨。
有部叫做《Hero》的美剧是讲正反两派都是一群有超能力的人，彼此为了某个巨大的阴谋互相撕逼。作为两边的头头，他们自己既不会飞，也不会手上冒火，更不会心灵控制等。但他们却有一种当他们盯着一个超能力者使用自己的力量时，马上能把这个能力复制到自己身上的能力，比如他看到一个人在徒手煎鸡蛋，过了一分钟之后他就说卧槽我也会了......他们只要看到了有人使用超能力，就能马上掌握在手，最后变得无所不能。
这种能力，就叫学习能力。一个会学习的人，在任何领域都能变得强大。

一个人最重要的能力，不是学历多牛逼，不是实习经历多光彩，而是拥有一种强大的学习能力。但很可惜，我们有部分人毕业之后就丧失了如何继续学习的“学习能力”。
那么到底怎样才叫会学习呢？

1.通过观察找到事物的共性

小学课本上有加减乘除的四则运算法则。例如：2*3 -（5-2）- 2=？。如果你去翻答案，可能只有一个孤零零的数字1摆在上面，并没有解题过程。这个时候你可以尝试着用答案来反推解题过程：

2*3 -（5-2）- 2=1，这个等式去掉括号如何才能成立？在试过了几种方向之后，最后会发现只有：2*3-5+2-2=1，这个等式才成立。

进而你会发现，当括号前面是 + 号的时候，去掉括号，括号里面的运算符号不变；

当括号前面是-号的时候，去掉括号，括号里面的运算符号要变成相反。

当你拿着这个结论去验算其他类似的题目，发现全部符合这个规律。这是一个最简单的“演绎归纳”的推理过程，而它背后的逻辑是，通过找到个别事物的特性从而反推找到整体的共性。

在日常的工作生活中，这种方法其实屡见不鲜。

谈恋爱的时候，男生为了讨好女生会在追求的过程中说各种甜言蜜语，可是等到追到手以后就变得不那么上心。这是通过几个个别事例总结出来的事实，然后情感热线专家们据此就会得出一个共性规律：

得不到时才是最好的，得到了就不会懂得珍惜。

在给领导做工作汇报的时候，通常时间都不会超过半个小时，因为领导总是有下一场会议要赶。这是你在做了几次汇报之后发现的一个事实，然后职场热线专家据此就会告诉你一个共性规律：

领导的时间都是有限的，所以汇报工作要精简抓住要点。

这个世界上所有的事情背后都有一套简单的运转规律。会学习的人，首先会通过观察找到事物背后的本质，继而发现共性，最终推论到全局。无论是科学研究，还是世故人情，无论是商业经济，还是生物进化，支撑着这些领域不断向前发展的可能是简单的几条规律，或者说，真理。

牛顿三大定律，摩尔定律，广义相对论，波士顿矩阵，达尔文进化论......这些实际上都是一个东西，规则。聪明人从大量事实中发现共性，总结规则；普通人顺应和利用这些规则，仅此而已。

2.活学活用，举一反百

你身边一定有那种各门考试都很好，但是一遇到没见过的问题就不知道该怎么解的“学霸”，这种叫“死学”。

会学习的人，讲究“活学”。“活学”最大的特征就是，善于跨界地去学习不同领域的知识，并善于各种灵活多变的知识组合，对各种事情进行高效的处理。你在A领域学习到的规则，发现在B领域也基本适用，再修改或者变通下也能在C领域、D领域部分适用。

能量守恒定律最初是物理学规则，但是同样适用于商业领域，于是有了“零和博弈”。

“物竞天择，适者生存”最初是生物进化学的理论，但是推演到任何一个高度竞争的领域都同样适用。在工作中，能力强的人会一路高升，能力差的人一定会被淘汰；在商业竞争中，质量好的商品会收到追捧，质量差的商品会被下架。

“市场供求曲线”最初是经济学的一条规则，但是你在谈恋爱的时候同样适用。

“活学”之人，必会“活用”，再复杂的问题到了他手里都会变的清晰和简单。碰到一个新问题，进行逻辑分析，找出相似性和共性。他们就进入到一个熟悉的领域，问题马上迎刃而解。
3.多领域发展

不管关于这一点是否有争议，但这个世界上“通才”似乎比“专才”往往更能适应竞争。只说一点，“通才”和“专才”最大的区别在于面对急剧变化的形势时的应变能力。

凯文凯利在《失控》说过：

要成长为新物种，你就要经历所有你不会去扮演的角色。

当一个环境开始急剧变化的时候，一定是内部和外部同时发生了改变。如果只是单一内部发生改变，以往过去的规则和经验或许足以应对和解决问题，但是一旦这个冲击变化来自于外部陌生的领域，经验主义就再也不适用了。最好的例子就是近几年来几乎中国所有的实体经济都开始朝着互联网+的方向发展。你会发现，线下超市被电商大规模冲击、逐步有自我学习能力的机器人开始工业和民用领域、工业4.0让制造业变得更加无缝对接、互联网反欺诈让隐形的欺诈者越来越难生存，移动支付让我们省去大量去银行门店处理事务的时间.......这些在过去让人们匪夷所思的事情，背后都蕴含着新的规则和逻辑。

点评：

不论你已经是一位很有名的专家或者专才了，我们都应该保持永久学习的好奇心态，因为世界变化太快。

来自知乎专栏查看全部

每个人身边都会有牛人，似乎这些牛人从来不会为某一件事情而费劲，而某些人却为某些事情费尽九牛二虎之力也无法把事情解决。大学时期班上总有那么几个家伙，可以经常打游戏，打球，泡妞，而最终期末考试成绩却还是名列前茅，让人羡慕妒忌恨。
有部叫做《Hero》的美剧是讲正反两派都是一群有超能力的人，彼此为了某个巨大的阴谋互相撕逼。作为两边的头头，他们自己既不会飞，也不会手上冒火，更不会心灵控制等。但他们却有一种当他们盯着一个超能力者使用自己的力量时，马上能把这个能力复制到自己身上的能力，比如他看到一个人在徒手煎鸡蛋，过了一分钟之后他就说卧槽我也会了......他们只要看到了有人使用超能力，就能马上掌握在手，最后变得无所不能。
这种能力，就叫学习能力。一个会学习的人，在任何领域都能变得强大。

一个人最重要的能力，不是学历多牛逼，不是实习经历多光彩，而是拥有一种强大的学习能力。但很可惜，我们有部分人毕业之后就丧失了如何继续学习的“学习能力”。
那么到底怎样才叫会学习呢？

1.通过观察找到事物的共性

小学课本上有加减乘除的四则运算法则。例如：2*3 -（5-2）- 2=？。如果你去翻答案，可能只有一个孤零零的数字1摆在上面，并没有解题过程。这个时候你可以尝试着用答案来反推解题过程：

2*3 -（5-2）- 2=1，这个等式去掉括号如何才能成立？在试过了几种方向之后，最后会发现只有：2*3-5+2-2=1，这个等式才成立。

进而你会发现，当括号前面是 + 号的时候，去掉括号，括号里面的运算符号不变；

当括号前面是-号的时候，去掉括号，括号里面的运算符号要变成相反。

当你拿着这个结论去验算其他类似的题目，发现全部符合这个规律。这是一个最简单的“演绎归纳”的推理过程，而它背后的逻辑是，通过找到个别事物的特性从而反推找到整体的共性。

在日常的工作生活中，这种方法其实屡见不鲜。

谈恋爱的时候，男生为了讨好女生会在追求的过程中说各种甜言蜜语，可是等到追到手以后就变得不那么上心。这是通过几个个别事例总结出来的事实，然后情感热线专家们据此就会得出一个共性规律：

得不到时才是最好的，得到了就不会懂得珍惜。

在给领导做工作汇报的时候，通常时间都不会超过半个小时，因为领导总是有下一场会议要赶。这是你在做了几次汇报之后发现的一个事实，然后职场热线专家据此就会告诉你一个共性规律：

领导的时间都是有限的，所以汇报工作要精简抓住要点。

这个世界上所有的事情背后都有一套简单的运转规律。会学习的人，首先会通过观察找到事物背后的本质，继而发现共性，最终推论到全局。无论是科学研究，还是世故人情，无论是商业经济，还是生物进化，支撑着这些领域不断向前发展的可能是简单的几条规律，或者说，真理。

牛顿三大定律，摩尔定律，广义相对论，波士顿矩阵，达尔文进化论......这些实际上都是一个东西，规则。聪明人从大量事实中发现共性，总结规则；普通人顺应和利用这些规则，仅此而已。

2.活学活用，举一反百

你身边一定有那种各门考试都很好，但是一遇到没见过的问题就不知道该怎么解的“学霸”，这种叫“死学”。

会学习的人，讲究“活学”。“活学”最大的特征就是，善于跨界地去学习不同领域的知识，并善于各种灵活多变的知识组合，对各种事情进行高效的处理。你在A领域学习到的规则，发现在B领域也基本适用，再修改或者变通下也能在C领域、D领域部分适用。

能量守恒定律最初是物理学规则，但是同样适用于商业领域，于是有了“零和博弈”。

“物竞天择，适者生存”最初是生物进化学的理论，但是推演到任何一个高度竞争的领域都同样适用。在工作中，能力强的人会一路高升，能力差的人一定会被淘汰；在商业竞争中，质量好的商品会收到追捧，质量差的商品会被下架。

“市场供求曲线”最初是经济学的一条规则，但是你在谈恋爱的时候同样适用。

“活学”之人，必会“活用”，再复杂的问题到了他手里都会变的清晰和简单。碰到一个新问题，进行逻辑分析，找出相似性和共性。他们就进入到一个熟悉的领域，问题马上迎刃而解。
3.多领域发展

不管关于这一点是否有争议，但这个世界上“通才”似乎比“专才”往往更能适应竞争。只说一点，“通才”和“专才”最大的区别在于面对急剧变化的形势时的应变能力。

凯文凯利在《失控》说过：

要成长为新物种，你就要经历所有你不会去扮演的角色。

当一个环境开始急剧变化的时候，一定是内部和外部同时发生了改变。如果只是单一内部发生改变，以往过去的规则和经验或许足以应对和解决问题，但是一旦这个冲击变化来自于外部陌生的领域，经验主义就再也不适用了。最好的例子就是近几年来几乎中国所有的实体经济都开始朝着互联网+的方向发展。你会发现，线下超市被电商大规模冲击、逐步有自我学习能力的机器人开始工业和民用领域、工业4.0让制造业变得更加无缝对接、互联网反欺诈让隐形的欺诈者越来越难生存，移动支付让我们省去大量去银行门店处理事务的时间.......这些在过去让人们匪夷所思的事情，背后都蕴含着新的规则和逻辑。

点评：

不论你已经是一位很有名的专家或者专才了，我们都应该保持永久学习的好奇心态，因为世界变化太快。

来自知乎专栏

使用pandas的dataframe数据进行操作的总结

python • 李魔佛发表了文章 • 0 个评论 • 6066 次浏览 • 2016-07-17 16:47 • 来自相关话题

t = df.iloc[0]<class 'pandas.core.series.Series'>

#使用iloc后，t已经变成了一个子集。已经不再是一个dataframe数据。所以你使用 t['high'] 返回的是一个值。此时t已经没有index了，如果这个时候调用 t.index

t=df[:1]
class 'pandas.core.frame.DataFrame'>

#这是返回的是一个DataFrame的一个子集。此时你可以继续用dateFrame的一些方法进行操作。

删除dataframe中某一行

df.drop()

df的内容如下：

df.drop(df[df[u'代码']==300141.0].index,inplace=True)
print df

输出如下

记得参数inplace=True，因为默认的值为inplace=False，意思就是你不添加的话就使用Falase这个值。
这样子原来的df不会被修改，只是会返回新的修改过的df。这样的话需要用一个新变量来承接它
new_df=df.drop(df[df[u'代码']==300141.0].index)

判断DataFrame为None
if df is None:
print "None len==0"
return False
查看全部

t = df.iloc[0]<class 'pandas.core.series.Series'>

#使用iloc后，t已经变成了一个子集。已经不再是一个dataframe数据。所以你使用 t['high'] 返回的是一个值。此时t已经没有index了，如果这个时候调用 t.index

t=df[:1]
class 'pandas.core.frame.DataFrame'>

#这是返回的是一个DataFrame的一个子集。此时你可以继续用dateFrame的一些方法进行操作。

删除dataframe中某一行

df.drop()

df的内容如下：

df.drop(df[df[u'代码']==300141.0].index,inplace=True)
print df

输出如下

记得参数inplace=True，因为默认的值为inplace=False，意思就是你不添加的话就使用Falase这个值。
这样子原来的df不会被修改，只是会返回新的修改过的df。这样的话需要用一个新变量来承接它
new_df=df.drop(df[df[u'代码']==300141.0].index)

判断DataFrame为None

    if df is None:

        print "None len==0"

        return False

python 获取中国证券网的公告

python爬虫 • 李魔佛发表了文章 • 11 个评论 • 21523 次浏览 • 2016-06-30 15:45 • 来自相关话题

中国证券网： http://ggjd.cnstock.com/
这个网站的公告会比同花顺东方财富的早一点，而且还出现过早上中国证券网已经发了公告，而东财却拿去做午间公告，以至于可以提前获取公告提前埋伏。

现在程序自动把抓取的公告存入本网站中：http://30daydo.com/news.php
每天早上8:30更新一次。

生成的公告保存在stock/文件夹下，以日期命名。下面脚本是循坏检测，如果有新的公告就会继续生成。

默认保存前3页的公告。（一次过太多页会被网站暂时屏蔽几分钟）。代码以及使用了切换header来躲避网站的封杀。

修改
getInfo(3) 里面的数字就可以抓取前面某页数据

__author__ = 'rocchen'
# working v1.0
from bs4 import BeautifulSoup
import urllib2, datetime, time, codecs, cookielib, random, threading
import os,sys

def getInfo(max_index_user=5):
stock_news_site =
"http://ggjd.cnstock.com/gglist/search/ggkx/"

my_userAgent = [
'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_8; en-us) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50',
'Mozilla/5.0 (Windows; U; Windows NT 6.1; en-us) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50',
'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0',
'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0)',
'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0)',
'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)',
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.6; rv:2.0.1) Gecko/20100101 Firefox/4.0.1',
'Mozilla/5.0 (Windows NT 6.1; rv:2.0.1) Gecko/20100101 Firefox/4.0.1',
'Opera/9.80 (Macintosh; Intel Mac OS X 10.6.8; U; en) Presto/2.8.131 Version/11.11',
'Opera/9.80 (Windows NT 6.1; U; en) Presto/2.8.131 Version/11.11',
'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Maxthon 2.0)',
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_0) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.56 Safari/535.11',
'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; 360SE)',
'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; SE 2.X MetaSr 1.0; SE 2.X MetaSr 1.0; .NET CLR 2.0.50727; SE 2.X MetaSr 1.0)']
index = 0
max_index = max_index_user
num = 1
temp_time = time.strftime("[%Y-%m-%d]-[%H-%M]", time.localtime())

store_filename = "StockNews-%s.log" % temp_time
fOpen = codecs.open(store_filename, 'w', 'utf-8')

while index < max_index:
user_agent = random.choice(my_userAgent)
# print user_agent
company_news_site = stock_news_site + str(index)
# content = urllib2.urlopen(company_news_site)
headers = {'User-Agent': user_agent, 'Host': "ggjd.cnstock.com", 'DNT': '1',
'Accept': 'text/html, application/xhtml+xml, */*', }
req = urllib2.Request(url=company_news_site, headers=headers)
resp = None
raw_content = ""
try:
resp = urllib2.urlopen(req, timeout=30)

except urllib2.HTTPError as e:
e.fp.read()
except urllib2.URLError as e:
if hasattr(e, 'code'):
print "error code %d" % e.code
elif hasattr(e, 'reason'):
print "error reason %s " % e.reason

finally:
if resp:
raw_content = resp.read()
time.sleep(2)
resp.close()

soup = BeautifulSoup(raw_content, "html.parser")
all_content = soup.find_all("span", "time")

for i in all_content:
news_time = i.string
node = i.next_sibling
str_temp = "No.%s \n%s\t%s\n---> %s \n\n" % (str(num), news_time, node['title'], node['href'])
#print "inside %d" %num
#print str_temp
fOpen.write(str_temp)
num = num + 1

#print "index %d" %index
index = index + 1

fOpen.close()

def execute_task(n=60):
period = int(n)
while True:
print datetime.datetime.now()
getInfo(3)

time.sleep(60 * period)

if __name__ == "__main__":

sub_folder = os.path.join(os.getcwd(), "stock")
if not os.path.exists(sub_folder):
os.mkdir(sub_folder)
os.chdir(sub_folder)
start_time = time.time() # user can change the max index number getInfo(10), by default is getInfo(5)
if len(sys.argv) <2:
n = raw_input("Input Period : ? mins to download every cycle")
else:
n=int(sys.argv[1])
execute_task(n)
end_time = time.time()
print "Total time: %s s." % str(round((end_time - start_time), 4))

github：https://github.com/Rockyzsu/cnstock
查看全部

中国证券网： http://ggjd.cnstock.com/
这个网站的公告会比同花顺东方财富的早一点，而且还出现过早上中国证券网已经发了公告，而东财却拿去做午间公告，以至于可以提前获取公告提前埋伏。

现在程序自动把抓取的公告存入本网站中：http://30daydo.com/news.php
每天早上8:30更新一次。

生成的公告保存在stock/文件夹下，以日期命名。下面脚本是循坏检测，如果有新的公告就会继续生成。

默认保存前3页的公告。（一次过太多页会被网站暂时屏蔽几分钟）。代码以及使用了切换header来躲避网站的封杀。

修改
getInfo(3) 里面的数字就可以抓取前面某页数据

__author__ = 'rocchen'

# working v1.0

from bs4 import BeautifulSoup

import urllib2, datetime, time, codecs, cookielib, random, threading

import os,sys





def getInfo(max_index_user=5):

    stock_news_site =

"http://ggjd.cnstock.com/gglist/search/ggkx/"

 

    my_userAgent = [

        'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_8; en-us) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50',

        'Mozilla/5.0 (Windows; U; Windows NT 6.1; en-us) AppleWebKit/534.50 (KHTML, like Gecko) Version/5.1 Safari/534.50',

        'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0',

        'Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.0; Trident/4.0)',

        'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0)',

        'Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1)',

        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.6; rv:2.0.1) Gecko/20100101 Firefox/4.0.1',

        'Mozilla/5.0 (Windows NT 6.1; rv:2.0.1) Gecko/20100101 Firefox/4.0.1',

        'Opera/9.80 (Macintosh; Intel Mac OS X 10.6.8; U; en) Presto/2.8.131 Version/11.11',

        'Opera/9.80 (Windows NT 6.1; U; en) Presto/2.8.131 Version/11.11',

        'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Maxthon 2.0)',

        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_0) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.56 Safari/535.11',

        'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; 360SE)',

        'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1; Trident/4.0; SE 2.X MetaSr 1.0; SE 2.X MetaSr 1.0; .NET CLR 2.0.50727; SE 2.X MetaSr 1.0)']

    index = 0

    max_index = max_index_user

    num = 1

    temp_time = time.strftime("[%Y-%m-%d]-[%H-%M]", time.localtime())



    store_filename = "StockNews-%s.log" % temp_time

    fOpen = codecs.open(store_filename, 'w', 'utf-8')



    while index < max_index:

        user_agent = random.choice(my_userAgent)

        # print user_agent

        company_news_site = stock_news_site + str(index)

        # content = urllib2.urlopen(company_news_site)

        headers = {'User-Agent': user_agent, 'Host': "ggjd.cnstock.com", 'DNT': '1',

                   'Accept': 'text/html, application/xhtml+xml, */*', }

        req = urllib2.Request(url=company_news_site, headers=headers)

        resp = None

        raw_content = ""

        try:

            resp = urllib2.urlopen(req, timeout=30)



        except urllib2.HTTPError as e:

            e.fp.read()

        except urllib2.URLError as e:

            if hasattr(e, 'code'):

                print "error code %d" % e.code

            elif hasattr(e, 'reason'):

                print "error reason %s " % e.reason



        finally:

            if resp:

                raw_content = resp.read()

                time.sleep(2)

                resp.close()



        soup = BeautifulSoup(raw_content, "html.parser")

        all_content = soup.find_all("span", "time")



        for i in all_content:

            news_time = i.string

            node = i.next_sibling

            str_temp = "No.%s \n%s\t%s\n---> %s \n\n" % (str(num), news_time, node['title'], node['href'])

            #print "inside %d" %num

            #print str_temp

            fOpen.write(str_temp)

            num = num + 1



        #print "index %d" %index

        index = index + 1



    fOpen.close()





def execute_task(n=60):

    period = int(n)

    while True:

        print datetime.datetime.now()

        getInfo(3)

        

        time.sleep(60 * period)

        





if __name__ == "__main__":



    sub_folder = os.path.join(os.getcwd(), "stock")

    if not os.path.exists(sub_folder):

        os.mkdir(sub_folder)

    os.chdir(sub_folder)

    start_time = time.time()  # user can change the max index number getInfo(10), by default is getInfo(5)

    if len(sys.argv) <2:

        n = raw_input("Input Period : ? mins to download every cycle")

    else:

        n=int(sys.argv[1])

    execute_task(n)

    end_time = time.time()

    print "Total time: %s s." % str(round((end_time - start_time), 4))

github：https://github.com/Rockyzsu/cnstock

python 批量获取色影无忌获奖图片

python爬虫 • 李魔佛发表了文章 • 6 个评论 • 16667 次浏览 • 2016-06-29 16:41 • 来自相关话题

色影无忌上的图片很多都可以直接拿来做壁纸的，而且发布面不会太广，基本不会和市面上大部分的壁纸或者图片素材重复。关键还没有水印。这么良心的图片服务商哪里找呀~~

不多说，直接来代码：#-*-coding=utf-8-*-
__author__ = 'rocky chen'
from bs4 import BeautifulSoup
import urllib2,sys,StringIO,gzip,time,random,re,urllib,os
reload(sys)
sys.setdefaultencoding('utf-8')
class Xitek():
def __init__(self):
self.url="http://photo.xitek.com/"
user_agent="Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)"
self.headers={"User-Agent":user_agent}
self.last_page=self.__get_last_page()

def __get_last_page(self):
html=self.__getContentAuto(self.url)
bs=BeautifulSoup(html,"html.parser")
page=bs.find_all('a',class_="blast")
last_page=page[0]['href'].split('/')[-1]
return int(last_page)

def __getContentAuto(self,url):
req=urllib2.Request(url,headers=self.headers)
resp=urllib2.urlopen(req)
#time.sleep(2*random.random())
content=resp.read()
info=resp.info().get("Content-Encoding")
if info==None:
return content
else:
t=StringIO.StringIO(content)
gziper=gzip.GzipFile(fileobj=t)
html = gziper.read()
return html

#def __getFileName(self,stream):

def __download(self,url):
p=re.compile(r'href="(/photoid/\d+)"')
#html=self.__getContentNoZip(url)

html=self.__getContentAuto(url)

content = p.findall(html)
for i in content:
print i

photoid=self.__getContentAuto(self.url+i)
bs=BeautifulSoup(photoid,"html.parser")
final_link=bs.find('img',class_="mimg")['src']
print final_link
#pic_stream=self.__getContentAuto(final_link)
title=bs.title.string.strip()
filename = re.sub('[\/:*?"<>|]', '-', title)
filename=filename+'.jpg'
urllib.urlretrieve(final_link,filename)
#f=open(filename,'w')
#f.write(pic_stream)
#f.close()
#print html
#bs=BeautifulSoup(html,"html.parser")
#content=bs.find_all(p)
#for i in content:
# print i
'''
print bs.title
element_link=bs.find_all('div',class_="element")
print len(element_link)
k=1
for href in element_link:

#print type(href)
#print href.tag
'''
'''
if href.children[0]:
print href.children[0]
'''
'''
t=0

for i in href.children:
#if i.a:
if t==0:
#print k
if i['href']
print link

if p.findall(link):
full_path=self.url[0:len(self.url)-1]+link
sub_html=self.__getContent(full_path)
bs=BeautifulSoup(sub_html,"html.parser")
final_link=bs.find('img',class_="mimg")['src']
#time.sleep(2*random.random())
print final_link
#k=k+1
#print type(i)
#print i.tag
#if hasattr(i,"href"):
#print i['href']
#print i.tag
t=t+1
#print "*"

'''

'''
if href:
if href.children:
print href.children[0]
'''
#print "one element link"

def getPhoto(self):

start=0
#use style/0
photo_url="http://photo.xitek.com/style/0/p/"
for i in range(start,self.last_page+1):
url=photo_url+str(i)
print url
#time.sleep(1)
self.__download(url)

'''
url="http://photo.xitek.com/style/0/p/10"
self.__download(url)
'''
#url="http://photo.xitek.com/style/0/p/0"
#html=self.__getContent(url)
#url="http://photo.xitek.com/"
#html=self.__getContentNoZip(url)
#print html
#'''
def main():
sub_folder = os.path.join(os.getcwd(), "content")
if not os.path.exists(sub_folder):
os.mkdir(sub_folder)
os.chdir(sub_folder)
obj=Xitek()
obj.getPhoto()

if __name__=="__main__":
main()

下载后在content文件夹下会自动抓取所有图片。（色影无忌的服务器没有做任何的屏蔽处理，所以脚本不能跑那么快，可以适当调用sleep函数，不要让服务器压力那么大）

已经下载好的图片：

github: https://github.com/Rockyzsu/fetchXitek (欢迎前来star) 查看全部

色影无忌上的图片很多都可以直接拿来做壁纸的，而且发布面不会太广，基本不会和市面上大部分的壁纸或者图片素材重复。关键还没有水印。这么良心的图片服务商哪里找呀~~

不多说，直接来代码：

#-*-coding=utf-8-*-

__author__ = 'rocky chen'

from bs4 import BeautifulSoup

import urllib2,sys,StringIO,gzip,time,random,re,urllib,os

reload(sys)

sys.setdefaultencoding('utf-8')

class Xitek():

    def __init__(self):

        self.url="http://photo.xitek.com/"

        user_agent="Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)"

        self.headers={"User-Agent":user_agent}

        self.last_page=self.__get_last_page()





    def __get_last_page(self):

        html=self.__getContentAuto(self.url)

        bs=BeautifulSoup(html,"html.parser")

        page=bs.find_all('a',class_="blast")

        last_page=page[0]['href'].split('/')[-1]

        return int(last_page)





    def __getContentAuto(self,url):

        req=urllib2.Request(url,headers=self.headers)

        resp=urllib2.urlopen(req)

        #time.sleep(2*random.random())

        content=resp.read()

        info=resp.info().get("Content-Encoding")

        if info==None:

            return content

        else:

            t=StringIO.StringIO(content)

            gziper=gzip.GzipFile(fileobj=t)

            html = gziper.read()

            return html



    #def __getFileName(self,stream):





    def __download(self,url):

        p=re.compile(r'href="(/photoid/\d+)"')

        #html=self.__getContentNoZip(url)



        html=self.__getContentAuto(url)



        content = p.findall(html)

        for i in content:

            print i



            photoid=self.__getContentAuto(self.url+i)

            bs=BeautifulSoup(photoid,"html.parser")

            final_link=bs.find('img',class_="mimg")['src']

            print final_link

            #pic_stream=self.__getContentAuto(final_link)

            title=bs.title.string.strip()

            filename = re.sub('[\/:*?"<>|]', '-', title)

            filename=filename+'.jpg'

            urllib.urlretrieve(final_link,filename)

            #f=open(filename,'w')

            #f.write(pic_stream)

            #f.close()

        #print html

        #bs=BeautifulSoup(html,"html.parser")

        #content=bs.find_all(p)

        #for i in content:

        #    print i

        '''

        print bs.title

        element_link=bs.find_all('div',class_="element")

        print len(element_link)

        k=1

        for href in element_link:



            #print type(href)

            #print href.tag

        '''

        '''

            if href.children[0]:

                print href.children[0]

        '''

        '''

            t=0



            for i in href.children:

                #if i.a:

                if t==0:

                    #print k

                    if i['href']

                    print link



                        if p.findall(link):

                            full_path=self.url[0:len(self.url)-1]+link

                            sub_html=self.__getContent(full_path)

                            bs=BeautifulSoup(sub_html,"html.parser")

                            final_link=bs.find('img',class_="mimg")['src']

                            #time.sleep(2*random.random())

                            print final_link

                    #k=k+1

                #print type(i)

                #print i.tag

                #if hasattr(i,"href"):

                    #print i['href']

                #print i.tag

                t=t+1

                #print "*"



        '''



        '''

            if href:

                if href.children:

                    print href.children[0]

        '''

            #print "one element link"







    def getPhoto(self):



        start=0

        #use style/0

        photo_url="http://photo.xitek.com/style/0/p/"

        for i in range(start,self.last_page+1):

            url=photo_url+str(i)

            print url

            #time.sleep(1)

            self.__download(url)



        '''

        url="http://photo.xitek.com/style/0/p/10"

        self.__download(url)

        '''

        #url="http://photo.xitek.com/style/0/p/0"

        #html=self.__getContent(url)

        #url="http://photo.xitek.com/"

        #html=self.__getContentNoZip(url)

        #print html

        #'''

def main():

    sub_folder = os.path.join(os.getcwd(), "content")

    if not os.path.exists(sub_folder):

        os.mkdir(sub_folder)

    os.chdir(sub_folder)

    obj=Xitek()

    obj.getPhoto()





if __name__=="__main__":

    main()

下载后在content文件夹下会自动抓取所有图片。（色影无忌的服务器没有做任何的屏蔽处理，所以脚本不能跑那么快，可以适当调用sleep函数，不要让服务器压力那么大）

已经下载好的图片：

github: https://github.com/Rockyzsu/fetchXitek (欢迎前来star)

linux目录跳转利器 z.sh

Linux • 李魔佛发表了文章 • 0 个评论 • 7201 次浏览 • 2016-06-17 17:32 • 来自相关话题

使用linux的朋友，经常要在命令下面运行命令，并且频繁地在不同的目录切换，不断的cd ..,cd ../../../../../../bin,或者cd ../../../../../../../../../, 或者cd ~/Download/bin/

浪费时间且效率低下。

推荐大家使用一个小脚本，可以快速切换目录，不需要经常cd了。

拷贝下面的代码，保存为z.sh，放在用户目录下，/home/xxxx, xxx为用户名, 然后给予 777权限， chmod 777 z.sh

然后修改 .bashrc 文件， vim ~/.bashrc

在文件的最后添加一句 source ~/z.sh

然后保存.bashrc

然后运行 source ~./bashrc , 然后就马上生效了。

然后你进入到某一个目录，比如 /home/user/build/data/bin/hello/，运行 z

系统会纪录你的hello目录一次，

下一次在其他目录比如在/etc/apt/，如果要跳转到 /home/user/build/data/bin/hello/，
直接运行 z hello 就可以了。# Copyright (c) 2009 rupa deadwyler under the WTFPL license

# maintains a jump-list of the directories you actually use
#
# INSTALL:
# * put something like this in your .bashrc/.zshrc:
# . /path/to/z.sh
# * cd around for a while to build up the db
# * PROFIT!!
# * optionally:
# set $_Z_CMD in .bashrc/.zshrc to change the command (default z).
# set $_Z_DATA in .bashrc/.zshrc to change the datafile (default ~/.z).
# set $_Z_NO_RESOLVE_SYMLINKS to prevent symlink resolution.
# set $_Z_NO_PROMPT_COMMAND if you're handling PROMPT_COMMAND yourself.
# set $_Z_EXCLUDE_DIRS to an array of directories to exclude.
# set $_Z_OWNER to your username if you want use z while sudo with $HOME kept
#
# USE:
# * z foo # cd to most frecent dir matching foo
# * z foo bar # cd to most frecent dir matching foo and bar
# * z -r foo # cd to highest ranked dir matching foo
# * z -t foo # cd to most recently accessed dir matching foo
# * z -l foo # list matches instead of cd
# * z -c foo # restrict matches to subdirs of $PWD

[ -d "${_Z_DATA:-$HOME/.z}" ] && {
echo "ERROR: z.sh's datafile (${_Z_DATA:-$HOME/.z}) is a directory."
}

_z() {

local datafile="${_Z_DATA:-$HOME/.z}"

# bail if we don't own ~/.z and $_Z_OWNER not set
[ -z "$_Z_OWNER" -a -f "$datafile" -a ! -O "$datafile" ] && return

# add entries
if [ "$1" = "--add" ]; then
shift

# $HOME isn't worth matching
[ "$*" = "$HOME" ] && return

# don't track excluded directory trees
local exclude
for exclude in "${_Z_EXCLUDE_DIRS[@]}"; do
case "$*" in "$exclude*") return;; esac
done

# maintain the data file
local tempfile="$datafile.$RANDOM"
while read line; do
# only count directories
[ -d "${line%%\|*}" ] && echo $line
done < "$datafile" | awk -v path="$*" -v now="$(date +%s)" -F"|" '
BEGIN {
rank[path] = 1
time[path] = now
}
$2 >= 1 {
# drop ranks below 1
if( $1 == path ) {
rank[$1] = $2 + 1
time[$1] = now
} else {
rank[$1] = $2
time[$1] = $3
}
count += $2
}
END {
if( count > 9000 ) {
# aging
for( x in rank ) print x "|" 0.99*rank[x] "|" time[x]
} else for( x in rank ) print x "|" rank[x] "|" time[x]
}
' 2>/dev/null >| "$tempfile"
# do our best to avoid clobbering the datafile in a race condition
if [ $? -ne 0 -a -f "$datafile" ]; then
env rm -f "$tempfile"
else
[ "$_Z_OWNER" ] && chown $_Z_OWNER:$(id -ng $_Z_OWNER) "$tempfile"
env mv -f "$tempfile" "$datafile" || env rm -f "$tempfile"
fi

# tab completion
elif [ "$1" = "--complete" -a -s "$datafile" ]; then
while read line; do
[ -d "${line%%\|*}" ] && echo $line
done < "$datafile" | awk -v q="$2" -F"|" '
BEGIN {
if( q == tolower(q) ) imatch = 1
q = substr(q, 3)
gsub(" ", ".*", q)
}
{
if( imatch ) {
if( tolower($1) ~ tolower(q) ) print $1
} else if( $1 ~ q ) print $1
}
' 2>/dev/null

else
# list/go
while [ "$1" ]; do case "$1" in
--) while [ "$1" ]; do shift; local fnd="$fnd${fnd:+ }$1";done;;
-*) local opt=${1:1}; while [ "$opt" ]; do case ${opt:0:1} in
c) local fnd="^$PWD $fnd";;
h) echo "${_Z_CMD:-z} [-chlrtx] args" >&2; return;;
x) sed -i -e "\:^${PWD}|.*:d" "$datafile";;
l) local list=1;;
r) local typ="rank";;
t) local typ="recent";;
esac; opt=${opt:1}; done;;
*) local fnd="$fnd${fnd:+ }$1";;
esac; local last=$1; [ "$#" -gt 0 ] && shift; done
[ "$fnd" -a "$fnd" != "^$PWD " ] || local list=1

# if we hit enter on a completion just go there
case "$last" in
# completions will always start with /
/*) [ -z "$list" -a -d "$last" ] && cd "$last" && return;;
esac

# no file yet
[ -f "$datafile" ] || return

local cd
cd="$(while read line; do
[ -d "${line%%\|*}" ] && echo $line
done < "$datafile" | awk -v t="$(date +%s)" -v list="$list" -v typ="$typ" -v q="$fnd" -F"|" '
function frecent(rank, time) {
# relate frequency and time
dx = t - time
if( dx < 3600 ) return rank * 4
if( dx < 86400 ) return rank * 2
if( dx < 604800 ) return rank / 2
return rank / 4
}
function output(files, out, common) {
# list or return the desired directory
if( list ) {
cmd = "sort -n >&2"
for( x in files ) {
if( files[x] ) printf "%-10s %s\n", files[x], x | cmd
}
if( common ) {
printf "%-10s %s\n", "common:", common > "/dev/stderr"
}
} else {
if( common ) out = common
print out
}
}
function common(matches) {
# find the common root of a list of matches, if it exists
for( x in matches ) {
if( matches[x] && (!short || length(x) < length(short)) ) {
short = x
}
}
if( short == "/" ) return
# use a copy to escape special characters, as we want to return
# the original. yeah, this escaping is awful.
clean_short = short
gsub(/\[\[\]\|\]/, "\\\\&", clean_short)
for( x in matches ) if( matches[x] && x !~ clean_short ) return
return short
}
BEGIN {
gsub(" ", ".*", q)
hi_rank = ihi_rank = -9999999999
}
{
if( typ == "rank" ) {
rank = $2
} else if( typ == "recent" ) {
rank = $3 - t
} else rank = frecent($2, $3)
if( $1 ~ q ) {
matches[$1] = rank
} else if( tolower($1) ~ tolower(q) ) imatches[$1] = rank
if( matches[$1] && matches[$1] > hi_rank ) {
best_match = $1
hi_rank = matches[$1]
} else if( imatches[$1] && imatches[$1] > ihi_rank ) {
ibest_match = $1
ihi_rank = imatches[$1]
}
}
END {
# prefer case sensitive
if( best_match ) {
output(matches, best_match, common(matches))
} else if( ibest_match ) {
output(imatches, ibest_match, common(imatches))
}
}
')"
[ $? -gt 0 ] && return
[ "$cd" ] && cd "$cd"
fi
}

alias ${_Z_CMD:-z}='_z 2>&1'

[ "$_Z_NO_RESOLVE_SYMLINKS" ] || _Z_RESOLVE_SYMLINKS="-P"

if type compctl >/dev/null 2>&1; then
# zsh
[ "$_Z_NO_PROMPT_COMMAND" ] || {
# populate directory list, avoid clobbering any other precmds.
if [ "$_Z_NO_RESOLVE_SYMLINKS" ]; then
_z_precmd() {
_z --add "${PWD:a}"
}
else
_z_precmd() {
_z --add "${PWD:A}"
}
fi
[[ -n "${precmd_functions[(r)_z_precmd]}" ]] || {
precmd_functions[$(($#precmd_functions+1))]=_z_precmd
}
}
_z_zsh_tab_completion() {
# tab completion
local compl
read -l compl
reply=(${(f)"$(_z --complete "$compl")"})
}
compctl -U -K _z_zsh_tab_completion _z
elif type complete >/dev/null 2>&1; then
# bash
# tab completion
complete -o filenames -C '_z --complete "$COMP_LINE"' ${_Z_CMD:-z}
[ "$_Z_NO_PROMPT_COMMAND" ] || {
# populate directory list. avoid clobbering other PROMPT_COMMANDs.
grep "_z --add" <<< "$PROMPT_COMMAND" >/dev/null || {
PROMPT_COMMAND="$PROMPT_COMMAND"$'\n''_z --add "$(command pwd '$_Z_RESOLVE_SYMLINKS' 2>/dev/null)" 2>/dev/null;'
}
}
fi 查看全部

使用linux的朋友，经常要在命令下面运行命令，并且频繁地在不同的目录切换，不断的cd ..,cd ../../../../../../bin,或者cd ../../../../../../../../../, 或者cd ~/Download/bin/

浪费时间且效率低下。

推荐大家使用一个小脚本，可以快速切换目录，不需要经常cd了。

拷贝下面的代码，保存为z.sh，放在用户目录下，/home/xxxx, xxx为用户名, 然后给予 777权限， chmod 777 z.sh

然后修改 .bashrc 文件， vim ~/.bashrc

在文件的最后添加一句 source ~/z.sh

然后保存.bashrc

然后运行 source ~./bashrc , 然后就马上生效了。

然后你进入到某一个目录，比如 /home/user/build/data/bin/hello/，运行 z

系统会纪录你的hello目录一次，

下一次在其他目录比如在/etc/apt/，如果要跳转到 /home/user/build/data/bin/hello/，
直接运行 z hello 就可以了。

# Copyright (c) 2009 rupa deadwyler under the WTFPL license



# maintains a jump-list of the directories you actually use

#

# INSTALL:

#     * put something like this in your .bashrc/.zshrc:

#         . /path/to/z.sh

#     * cd around for a while to build up the db

#     * PROFIT!!

#     * optionally:

#         set $_Z_CMD in .bashrc/.zshrc to change the command (default z).

#         set $_Z_DATA in .bashrc/.zshrc to change the datafile (default ~/.z).

#         set $_Z_NO_RESOLVE_SYMLINKS to prevent symlink resolution.

#         set $_Z_NO_PROMPT_COMMAND if you're handling PROMPT_COMMAND yourself.

#         set $_Z_EXCLUDE_DIRS to an array of directories to exclude.

#         set $_Z_OWNER to your username if you want use z while sudo with $HOME kept

#

# USE:

#     * z foo     # cd to most frecent dir matching foo

#     * z foo bar # cd to most frecent dir matching foo and bar

#     * z -r foo  # cd to highest ranked dir matching foo

#     * z -t foo  # cd to most recently accessed dir matching foo

#     * z -l foo  # list matches instead of cd

#     * z -c foo  # restrict matches to subdirs of $PWD



[ -d "${_Z_DATA:-$HOME/.z}" ] && {

    echo "ERROR: z.sh's datafile (${_Z_DATA:-$HOME/.z}) is a directory."

}



_z() {



    local datafile="${_Z_DATA:-$HOME/.z}"



    # bail if we don't own ~/.z and $_Z_OWNER not set

    [ -z "$_Z_OWNER" -a -f "$datafile" -a ! -O "$datafile" ] && return



    # add entries

    if [ "$1" = "--add" ]; then

        shift



        # $HOME isn't worth matching

        [ "$*" = "$HOME" ] && return



        # don't track excluded directory trees

        local exclude

        for exclude in "${_Z_EXCLUDE_DIRS[@]}"; do

            case "$*" in "$exclude*") return;; esac

        done



        # maintain the data file

        local tempfile="$datafile.$RANDOM"

        while read line; do

            # only count directories

            [ -d "${line%%\|*}" ] && echo $line

        done < "$datafile" | awk -v path="$*" -v now="$(date +%s)" -F"|" '

            BEGIN {

                rank[path] = 1

                time[path] = now

            }

            $2 >= 1 {

                # drop ranks below 1

                if( $1 == path ) {

                    rank[$1] = $2 + 1

                    time[$1] = now

                } else {

                    rank[$1] = $2

                    time[$1] = $3

                }

                count += $2

            }

            END {

                if( count > 9000 ) {

                    # aging

                    for( x in rank ) print x "|" 0.99*rank[x] "|" time[x]

                } else for( x in rank ) print x "|" rank[x] "|" time[x]

            }

        ' 2>/dev/null >| "$tempfile"

        # do our best to avoid clobbering the datafile in a race condition

        if [ $? -ne 0 -a -f "$datafile" ]; then

            env rm -f "$tempfile"

        else

            [ "$_Z_OWNER" ] && chown $_Z_OWNER:$(id -ng $_Z_OWNER) "$tempfile"

            env mv -f "$tempfile" "$datafile" || env rm -f "$tempfile"

        fi



    # tab completion

    elif [ "$1" = "--complete" -a -s "$datafile" ]; then

        while read line; do

            [ -d "${line%%\|*}" ] && echo $line

        done < "$datafile" | awk -v q="$2" -F"|" '

            BEGIN {

                if( q == tolower(q) ) imatch = 1

                q = substr(q, 3)

                gsub(" ", ".*", q)

            }

            {

                if( imatch ) {

                    if( tolower($1) ~ tolower(q) ) print $1

                } else if( $1 ~ q ) print $1

            }

        ' 2>/dev/null



    else

        # list/go

        while [ "$1" ]; do case "$1" in

            --) while [ "$1" ]; do shift; local fnd="$fnd${fnd:+ }$1";done;;

            -*) local opt=${1:1}; while [ "$opt" ]; do case ${opt:0:1} in

                    c) local fnd="^$PWD $fnd";;

                    h) echo "${_Z_CMD:-z} [-chlrtx] args" >&2; return;;

                    x) sed -i -e "\:^${PWD}|.*:d" "$datafile";;

                    l) local list=1;;

                    r) local typ="rank";;

                    t) local typ="recent";;

                esac; opt=${opt:1}; done;;

             *) local fnd="$fnd${fnd:+ }$1";;

        esac; local last=$1; [ "$#" -gt 0 ] && shift; done

        [ "$fnd" -a "$fnd" != "^$PWD " ] || local list=1



        # if we hit enter on a completion just go there

        case "$last" in

            # completions will always start with /

            /*) [ -z "$list" -a -d "$last" ] && cd "$last" && return;;

        esac



        # no file yet

        [ -f "$datafile" ] || return



        local cd

        cd="$(while read line; do

            [ -d "${line%%\|*}" ] && echo $line

        done < "$datafile" | awk -v t="$(date +%s)" -v list="$list" -v typ="$typ" -v q="$fnd" -F"|" '

            function frecent(rank, time) {

                # relate frequency and time

                dx = t - time

                if( dx < 3600 ) return rank * 4

                if( dx < 86400 ) return rank * 2

                if( dx < 604800 ) return rank / 2

                return rank / 4

            }

            function output(files, out, common) {

                # list or return the desired directory

                if( list ) {

                    cmd = "sort -n >&2"

                    for( x in files ) {

                        if( files[x] ) printf "%-10s %s\n", files[x], x | cmd

                    }

                    if( common ) {

                        printf "%-10s %s\n", "common:", common > "/dev/stderr"

                    }

                } else {

                    if( common ) out = common

                    print out

                }

            }

            function common(matches) {

                # find the common root of a list of matches, if it exists

                for( x in matches ) {

                    if( matches[x] && (!short || length(x) < length(short)) ) {

                        short = x

                    }

                }

                if( short == "/" ) return

                # use a copy to escape special characters, as we want to return

                # the original. yeah, this escaping is awful.

                clean_short = short

                gsub(/\[\(\)\[\]\|\]/, "\\\\&", clean_short)

                for( x in matches ) if( matches[x] && x !~ clean_short ) return

                return short

            }

            BEGIN {

                gsub(" ", ".*", q)

                hi_rank = ihi_rank = -9999999999

            }

            {

                if( typ == "rank" ) {

                    rank = $2

                } else if( typ == "recent" ) {

                    rank = $3 - t

                } else rank = frecent($2, $3)

                if( $1 ~ q ) {

                    matches[$1] = rank

                } else if( tolower($1) ~ tolower(q) ) imatches[$1] = rank

                if( matches[$1] && matches[$1] > hi_rank ) {

                    best_match = $1

                    hi_rank = matches[$1]

                } else if( imatches[$1] && imatches[$1] > ihi_rank ) {

                    ibest_match = $1

                    ihi_rank = imatches[$1]

                }

            }

            END {

                # prefer case sensitive

                if( best_match ) {

                    output(matches, best_match, common(matches))

                } else if( ibest_match ) {

                    output(imatches, ibest_match, common(imatches))

                }

            }

        ')"

        [ $? -gt 0 ] && return

        [ "$cd" ] && cd "$cd"

    fi

}



alias ${_Z_CMD:-z}='_z 2>&1'



[ "$_Z_NO_RESOLVE_SYMLINKS" ] || _Z_RESOLVE_SYMLINKS="-P"



if type compctl >/dev/null 2>&1; then

    # zsh

    [ "$_Z_NO_PROMPT_COMMAND" ] || {

        # populate directory list, avoid clobbering any other precmds.

        if [ "$_Z_NO_RESOLVE_SYMLINKS" ]; then

            _z_precmd() {

                _z --add "${PWD:a}"

            }

        else

            _z_precmd() {

                _z --add "${PWD:A}"

            }

        fi

        [[ -n "${precmd_functions[(r)_z_precmd]}" ]] || {

            precmd_functions[$(($#precmd_functions+1))]=_z_precmd

        }

    }

    _z_zsh_tab_completion() {

        # tab completion

        local compl

        read -l compl

        reply=(${(f)"$(_z --complete "$compl")"})

    }

    compctl -U -K _z_zsh_tab_completion _z

elif type complete >/dev/null 2>&1; then

    # bash

    # tab completion

    complete -o filenames -C '_z --complete "$COMP_LINE"' ${_Z_CMD:-z}

    [ "$_Z_NO_PROMPT_COMMAND" ] || {

        # populate directory list. avoid clobbering other PROMPT_COMMANDs.

        grep "_z --add" <<< "$PROMPT_COMMAND" >/dev/null || {

            PROMPT_COMMAND="$PROMPT_COMMAND"$'\n''_z --add "$(command pwd '$_Z_RESOLVE_SYMLINKS' 2>/dev/null)" 2>/dev/null;'

        }

    }

fi

抓取知乎日报中的大误系类文章，生成电子书推送到kindle

python爬虫 • 李魔佛发表了文章 • 0 个评论 • 9564 次浏览 • 2016-06-12 08:52 • 来自相关话题

无意中看了知乎日报的大误系列的一篇文章，之后就停不下来了，大误是虚构故事，知乎上神人虚构故事的功力要高于网络上的很多写手啊！！看的欲罢不能，不过还是那句，手机屏幕太小，连续看几个小时很疲劳，而且每次都要联网去看。

所以写了下面的python脚本，一劳永逸。脚本抓取大误从开始到现在的所有文章，并推送到你自己的kindle账号。

# -*- coding=utf-8 -*-
__author__ = 'rocky @ www.30daydo.com'
import urllib2, re, os, codecs,sys,datetime
from bs4 import BeautifulSoup
# example https://zhhrb.sinaapp.com/index.php?date=20160610
from mail_template import MailAtt
reload(sys)
sys.setdefaultencoding('utf-8')

def save2file(filename, content):
filename = filename + ".txt"
f = codecs.open(filename, 'a', encoding='utf-8')
f.write(content)
f.close()

def getPost(date_time, filter_p):
url = 'https://zhhrb.sinaapp.com/index.php?date=' + date_time
user_agent = "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)"
header = {"User-Agent": user_agent}
req = urllib2.Request(url, headers=header)
resp = urllib2.urlopen(req)
content = resp.read()
p = re.compile('<h2 class="question-title">(.*)</h2></br></a>')
result = re.findall(p, content)
count = -1
row = -1
for i in result:
#print i
return_content = re.findall(filter_p, i)

if return_content:
row = count
break
#print return_content[0]
count = count + 1
#print row
if row == -1:
return 0
link_p = re.compile('<a href="(.*)" target="_blank" rel="nofollow">')
link_result = re.findall(link_p, content)[row + 1]
print link_result
result_req = urllib2.Request(link_result, headers=header)
result_resp = urllib2.urlopen(result_req)
#result_content= result_resp.read()
#print result_content

bs = BeautifulSoup(result_resp, "html.parser")
title = bs.title.string.strip()
#print title
filename = re.sub('[\/:*?"<>|]', '-', title)
print filename
print date_time
save2file(filename, title)
save2file(filename, "\n\n\n\n--------------------%s Detail----------------------\n\n" %date_time)

detail_content = bs.find_all('div', class_='content')

for i in detail_content:
#print i
save2file(filename,"\n\n-------------------------answer -------------------------\n\n")
for j in i.strings:

save2file(filename, j)

smtp_server = 'smtp.126.com'
from_mail = sys.argv[1]
password = sys.argv[2]
to_mail = 'xxxxx@kindle.cn'
send_kindle = MailAtt(smtp_server, from_mail, password, to_mail)
send_kindle.send_txt(filename)

def main():
sub_folder = os.path.join(os.getcwd(), "content")
if not os.path.exists(sub_folder):
os.mkdir(sub_folder)
os.chdir(sub_folder)

date_time = '20160611'
filter_p = re.compile('大误.*')
ori_day=datetime.date(datetime.date.today().year,01,01)
t=datetime.date(datetime.date.today().year,datetime.date.today().month,datetime.date.today().day)
delta=(t-ori_day).days
print delta
for i in range(delta):
day=datetime.date(datetime.date.today().year,01,01)+datetime.timedelta(i)
getPost(day.strftime("%Y%m%d"),filter_p)
#getPost(date_time, filter_p)

if __name__ == "__main__":
main()

github： https://github.com/Rockyzsu/zhihu_daily__kindle

上面的代码可以稍作修改，就可以抓取瞎扯或者深夜食堂的系列文章。

附福利：
http://pan.baidu.com/s/1kVewz59
所有的知乎日报的大误文章。（截止2016/6/12日）查看全部

无意中看了知乎日报的大误系列的一篇文章，之后就停不下来了，大误是虚构故事，知乎上神人虚构故事的功力要高于网络上的很多写手啊！！看的欲罢不能，不过还是那句，手机屏幕太小，连续看几个小时很疲劳，而且每次都要联网去看。

所以写了下面的python脚本，一劳永逸。脚本抓取大误从开始到现在的所有文章，并推送到你自己的kindle账号。

# -*- coding=utf-8 -*-

__author__ = 'rocky @ www.30daydo.com'

import urllib2, re, os, codecs,sys,datetime

from bs4 import BeautifulSoup

# example https://zhhrb.sinaapp.com/index.php?date=20160610

from mail_template import MailAtt

reload(sys)

sys.setdefaultencoding('utf-8')



def save2file(filename, content):

    filename = filename + ".txt"

    f = codecs.open(filename, 'a', encoding='utf-8')

    f.write(content)

    f.close()





def getPost(date_time, filter_p):

    url = 'https://zhhrb.sinaapp.com/index.php?date=' + date_time

    user_agent = "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)"

    header = {"User-Agent": user_agent}

    req = urllib2.Request(url, headers=header)

    resp = urllib2.urlopen(req)

    content = resp.read()

    p = re.compile('<h2 class="question-title">(.*)</h2></br></a>')

    result = re.findall(p, content)

    count = -1

    row = -1

    for i in result:

        #print i

        return_content = re.findall(filter_p, i)



        if return_content:

            row = count

            break

            #print return_content[0]

        count = count + 1

    #print row

    if row == -1:

        return 0

    link_p = re.compile('<a href="(.*)" target="_blank" rel="nofollow">')

    link_result = re.findall(link_p, content)[row + 1]

    print link_result

    result_req = urllib2.Request(link_result, headers=header)

    result_resp = urllib2.urlopen(result_req)

    #result_content= result_resp.read()

    #print result_content



    bs = BeautifulSoup(result_resp, "html.parser")

    title = bs.title.string.strip()

    #print title

    filename = re.sub('[\/:*?"<>|]', '-', title)

    print filename

    print date_time

    save2file(filename, title)

    save2file(filename, "\n\n\n\n--------------------%s Detail----------------------\n\n" %date_time)



    detail_content = bs.find_all('div', class_='content')



    for i in detail_content:

        #print i

        save2file(filename,"\n\n-------------------------answer  -------------------------\n\n")

        for j in i.strings:



            save2file(filename, j)



    smtp_server = 'smtp.126.com'

    from_mail = sys.argv[1]

    password = sys.argv[2]

    to_mail = 'xxxxx@kindle.cn'

    send_kindle = MailAtt(smtp_server, from_mail, password, to_mail)

    send_kindle.send_txt(filename)





def main():

    sub_folder = os.path.join(os.getcwd(), "content")

    if not os.path.exists(sub_folder):

        os.mkdir(sub_folder)

    os.chdir(sub_folder)





    date_time = '20160611'

    filter_p = re.compile('大误.*')

    ori_day=datetime.date(datetime.date.today().year,01,01)

    t=datetime.date(datetime.date.today().year,datetime.date.today().month,datetime.date.today().day)

    delta=(t-ori_day).days

    print delta

    for i in range(delta):

        day=datetime.date(datetime.date.today().year,01,01)+datetime.timedelta(i)

        getPost(day.strftime("%Y%m%d"),filter_p)

    #getPost(date_time, filter_p)



if __name__ == "__main__":

    main()

github： https://github.com/Rockyzsu/zhihu_daily__kindle

上面的代码可以稍作修改，就可以抓取瞎扯或者深夜食堂的系列文章。

附福利：
http://pan.baidu.com/s/1kVewz59
所有的知乎日报的大误文章。（截止2016/6/12日）

python 爆解zip压缩文件密码

python • 李魔佛发表了文章 • 0 个评论 • 9337 次浏览 • 2016-06-09 21:43 • 来自相关话题

出于对百度网盘的不信任，加上前阵子百度会把一些侵犯版权的文件清理掉或者一些百度认为的尺度过大的文件进行替换，留下一个4秒的教育视频。为何不提前告诉用户？擅自把用户的资料删除，以后用户哪敢随意把资料上传上去呢?

抱怨归抱怨，由于现在金山快盘，新浪尾盘都关闭了，速度稍微快点的就只有百度网盘了。所以我会把文件事先压缩好，加个密码然后上传。

可是有时候下载下来却忘记了解压密码，实在蛋疼。所以需要自己逐一验证密码。所以就写了这个小脚本。很简单，没啥技术含量。

代码就用图片吧，大家可以上机自己敲敲代码也好。 ctrl+v 代码其实会养成一种惰性。

github: https://github.com/Rockyzsu/zip_crash
查看全部

出于对百度网盘的不信任，加上前阵子百度会把一些侵犯版权的文件清理掉或者一些百度认为的尺度过大的文件进行替换，留下一个4秒的教育视频。为何不提前告诉用户？擅自把用户的资料删除，以后用户哪敢随意把资料上传上去呢?

抱怨归抱怨，由于现在金山快盘，新浪尾盘都关闭了，速度稍微快点的就只有百度网盘了。所以我会把文件事先压缩好，加个密码然后上传。

可是有时候下载下来却忘记了解压密码，实在蛋疼。所以需要自己逐一验证密码。所以就写了这个小脚本。很简单，没啥技术含量。

代码就用图片吧，大家可以上机自己敲敲代码也好。 ctrl+v 代码其实会养成一种惰性。

github: https://github.com/Rockyzsu/zip_crash

python雪球爬虫抓取雪球大V的所有文章推送到kindle

python爬虫 • 李魔佛发表了文章 • 3 个评论 • 21272 次浏览 • 2016-05-29 00:06 • 来自相关话题

30天内完成。开始日期：2016年5月28日

因为雪球上喷子很多，不少大V都不堪忍受，被喷的删帖离开。比如易碎品，小小辛巴。
所以利用python可以有效便捷的抓取想要的大V发言内容，并保存到本地。也方便自己检索，考证（有些伪大V喜欢频繁删帖，比如今天预测明天大盘大涨，明天暴跌后就把昨天的预测给删掉，给后来者造成的错觉改大V每次都能精准预测）。

下面以抓取狂龙的帖子为例（狂龙最近老是掀人家庄家的老底，哈）

https://xueqiu.com/4742988362

2017年2月20日更新：
爬取雪球上我的收藏的文章，并生成电子书。
（PS：收藏夹中一些文章已经被作者删掉了 - -|，这速度也蛮快了呀。估计是以前写的现在怕被放出来打脸）

# -*-coding=utf-8-*-
#抓取雪球的收藏文章
__author__ = 'Rocky'
import requests,cookielib,re,json,time
from toolkit import Toolkit
from lxml import etree
url='https://xueqiu.com/snowman/login'
session = requests.session()

session.cookies = cookielib.LWPCookieJar(filename="cookies")
try:
session.cookies.load(ignore_discard=True)
except:
print "Cookie can't load"

agent = 'Mozilla/5.0 (Windows NT 5.1; rv:33.0) Gecko/20100101 Firefox/33.0'
headers = {'Host': 'xueqiu.com',
'Referer': 'https://xueqiu.com/',
'Origin':'https://xueqiu.com',
'User-Agent': agent}
account=Toolkit.getUserData('data.cfg')
print account['snowball_user']
print account['snowball_password']

data={'username':account['snowball_user'],'password':account['snowball_password']}
s=session.post(url,data=data,headers=headers)
print s.status_code
#print s.text
session.cookies.save()
fav_temp='https://xueqiu.com/favs?page=1'
collection=session.get(fav_temp,headers=headers)
fav_content= collection.text
p=re.compile('"maxPage":(\d+)')
maxPage=p.findall(fav_content)[0]
print maxPage
print type(maxPage)
maxPage=int(maxPage)
print type(maxPage)
for i in range(1,maxPage+1):
fav='https://xueqiu.com/favs?page=%d' %i
collection=session.get(fav,headers=headers)
fav_content= collection.text
#print fav_content
p=re.compile('var favs = {(.*?)};',re.S|re.M)
result=p.findall(fav_content)[0].strip()

new_result='{'+result+'}'
#print type(new_result)
#print new_result
data=json.loads(new_result)
use_data= data['list']
host='https://xueqiu.com'
for i in use_data:
url=host+ i['target']
print url
txt_content=session.get(url,headers=headers).text
#print txt_content.text

tree=etree.HTML(txt_content)
title=tree.xpath('//title/text()')[0]

filename = re.sub('[\/:*?"<>|]', '-', title)
print filename

content=tree.xpath('//div[@class="detail"]')
for i in content:
Toolkit.save2filecn(filename, i.xpath('string(.)'))
#print content
#Toolkit.save2file(filename,)
time.sleep(10)

用法：
1. snowball.py -- 抓取雪球上我的收藏的文章
使用：创建一个data.cfg的文件，里面格式如下：
snowball_user=xxxxx@xx.com
snowball_password=密码

然后运行python snowball.py ，会自动登录雪球，然后在当前目录生产txt文件。

github代码：https://github.com/Rockyzsu/xueqiu 查看全部

30天内完成。开始日期：2016年5月28日

因为雪球上喷子很多，不少大V都不堪忍受，被喷的删帖离开。比如易碎品，小小辛巴。
所以利用python可以有效便捷的抓取想要的大V发言内容，并保存到本地。也方便自己检索，考证（有些伪大V喜欢频繁删帖，比如今天预测明天大盘大涨，明天暴跌后就把昨天的预测给删掉，给后来者造成的错觉改大V每次都能精准预测）。

下面以抓取狂龙的帖子为例（狂龙最近老是掀人家庄家的老底，哈）

https://xueqiu.com/4742988362

2017年2月20日更新：
爬取雪球上我的收藏的文章，并生成电子书。
（PS：收藏夹中一些文章已经被作者删掉了 - -|，这速度也蛮快了呀。估计是以前写的现在怕被放出来打脸）

# -*-coding=utf-8-*-

#抓取雪球的收藏文章

__author__ = 'Rocky'

import requests,cookielib,re,json,time

from toolkit import Toolkit

from lxml import etree

url='https://xueqiu.com/snowman/login'

session = requests.session()



session.cookies = cookielib.LWPCookieJar(filename="cookies")

try:

    session.cookies.load(ignore_discard=True)

except:

    print "Cookie can't load"



agent = 'Mozilla/5.0 (Windows NT 5.1; rv:33.0) Gecko/20100101 Firefox/33.0'

headers = {'Host': 'xueqiu.com',

           'Referer': 'https://xueqiu.com/',

           'Origin':'https://xueqiu.com',

           'User-Agent': agent}

account=Toolkit.getUserData('data.cfg')

print account['snowball_user']

print account['snowball_password']



data={'username':account['snowball_user'],'password':account['snowball_password']}

s=session.post(url,data=data,headers=headers)

print s.status_code

#print s.text

session.cookies.save()

fav_temp='https://xueqiu.com/favs?page=1'

collection=session.get(fav_temp,headers=headers)

fav_content= collection.text

p=re.compile('"maxPage":(\d+)')

maxPage=p.findall(fav_content)[0]

print maxPage

print type(maxPage)

maxPage=int(maxPage)

print type(maxPage)

for i in range(1,maxPage+1):

    fav='https://xueqiu.com/favs?page=%d' %i

    collection=session.get(fav,headers=headers)

    fav_content= collection.text

    #print fav_content

    p=re.compile('var favs = {(.*?)};',re.S|re.M)

    result=p.findall(fav_content)[0].strip()



    new_result='{'+result+'}'

    #print type(new_result)

    #print new_result

    data=json.loads(new_result)

    use_data= data['list']

    host='https://xueqiu.com'

    for i in use_data:

        url=host+ i['target']

        print url

        txt_content=session.get(url,headers=headers).text

        #print txt_content.text



        tree=etree.HTML(txt_content)

        title=tree.xpath('//title/text()')[0]



        filename = re.sub('[\/:*?"<>|]', '-', title)

        print filename



        content=tree.xpath('//div[@class="detail"]')

        for i in content:

            Toolkit.save2filecn(filename, i.xpath('string(.)'))

        #print content

        #Toolkit.save2file(filename,)

        time.sleep(10)

用法：
1. snowball.py -- 抓取雪球上我的收藏的文章
使用：创建一个data.cfg的文件，里面格式如下：
snowball_user=xxxxx@xx.com
snowball_password=密码

然后运行python snowball.py ，会自动登录雪球，然后在当前目录生产txt文件。

github代码：https://github.com/Rockyzsu/xueqiu

python 多线程扫描开放端口

python • 低调的哥哥发表了文章 • 0 个评论 • 10837 次浏览 • 2016-05-15 21:15 • 来自相关话题

为什么说python是黑客的语言？因为很多扫描+破解的任务都可以用python很快的实现，简洁明了。且有大量的库来支持。import socket,sys
import time
from thread_test import MyThread

socket.setdefaulttimeout(1)
#设置每个线程socket的timeou时间，超过1秒没有反应就认为端口不开放
thread_num=4
#线程数目
ip_end=256
ip_start=0
scope=ip_end/thread_num

def scan(ip_head,ip_low, port):
try:
# Alert !!! below statement should be inside scan function. Else each it is one s
ip=ip_head+str(ip_low)
print ip
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((ip, port))
#通过这一句判断是否连通
s.close()
print "ip %s port %d open\n" %(ip,port)
return True
except:
return False

def scan_range(ip_head,ip_range,port):
start,end=ip_range
for i in range(start,end):
scan(ip_head,i,port)

if len(sys.argv)<3:
print "input ip and port"
exit()

ip_head=sys.argv[1]
port=int(sys.argv[2])

ip_range=
for i in range(thread_num):
x_range=[i*scope,(i+1)*scope-1]
ip_range.append(x_range)

threads=
for i in range(thread_num):
t=MyThread(scan_range,(ip_head,ip_range,port))
threads.append(t)
for i in range(thread_num):
threads.start()
for i in range(thread_num):
threads.join()
#设置进程阻塞，防止主线程退出了，其他的多线程还在运行

print "*****end*****"多线程的类函数实现：有一些测试函数在上面没注释或者删除掉，为了让一些初学者更加容易看懂。import thread,threading,time,datetime
from time import sleep,ctime
def loop1():
print "start %s " %ctime()
print "start in loop1"
sleep(3)
print "end %s " %ctime()

def loop2():
print "sart %s " %ctime()
print "start in loop2"
sleep(6)
print "end %s " %ctime()

class MyThread(threading.Thread):
def __init__(self,fun,arg,name=""):
threading.Thread.__init__(self)
self.fun=fun
self.arg=arg
self.name=name
#self.result

def run(self):
self.result=apply(self.fun,self.arg)

def getResult(self):
return self.result

def fib(n):
if n<2:
return 1
else:
return fib(n-1)+fib(n-2)

def sum(n):
if n<2:
return 1
else:
return n+sum(n-1)

def fab(n):
if n<2:
return 1
else:
return n*fab(n-1)

def single_thread():
print fib(12)
print sum(12)
print fab(12)

def multi_thread():
print "in multithread"
fun_list=[fib,sum,fab]
n=len(fun_list)
threads=
count=12
for i in range(n):
t=MyThread(fun_list,(count,),fun_list.__name__)
threads.append(t)
for i in range(n):
threads.start()

for i in range(n):
threads.join()
result= threads.getResult()
print result
def main():
'''
print "start at main"
thread.start_new_thread(loop1,())
thread.start_new_thread(loop2,())
sleep(10)
print "end at main"
'''
start=ctime()
#print "Used %f" %(end-start).seconds
print start
single_thread()
end=ctime()
print end
multi_thread()
#print "used %s" %(end-start).seconds
if __name__=="__main__":
main()

最终运行的格式就是 python scan_host.py 192.168.1. 22
上面的命令就是扫描192.168.1 ip段开启了22端口服务的机器，也就是ssh服务。

github：https://github.com/Rockyzsu/scan_host

查看全部

为什么说python是黑客的语言？因为很多扫描+破解的任务都可以用python很快的实现，简洁明了。且有大量的库来支持。

import socket,sys

import time

from thread_test import MyThread



socket.setdefaulttimeout(1)

#设置每个线程socket的timeou时间，超过1秒没有反应就认为端口不开放

thread_num=4

#线程数目 

ip_end=256

ip_start=0

scope=ip_end/thread_num



def scan(ip_head,ip_low, port):

    try:

        # Alert !!! below statement should be inside scan function. Else each it is one s

        ip=ip_head+str(ip_low)

	print ip

	s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

	s.connect((ip, port))

	#通过这一句判断 是否连通

        s.close()

	print "ip %s port %d open\n" %(ip,port)

        return True

    except:

        return False





def scan_range(ip_head,ip_range,port):

	start,end=ip_range

	for i in range(start,end):

		scan(ip_head,i,port)



if len(sys.argv)<3:

	print "input ip and port"

	exit()



ip_head=sys.argv[1]

port=int(sys.argv[2])





ip_range=

for i in range(thread_num):

	x_range=[i*scope,(i+1)*scope-1]

	ip_range.append(x_range)



threads=

for i in range(thread_num):

	t=MyThread(scan_range,(ip_head,ip_range,port))

	threads.append(t)

for i in range(thread_num):

	threads.start()

for i in range(thread_num):

	threads.join()

	#设置进程阻塞，防止主线程退出了，其他的多线程还在运行



print "*****end*****"

多线程的类函数实现：有一些测试函数在上面没注释或者删除掉，为了让一些初学者更加容易看懂。

import thread,threading,time,datetime

from time import sleep,ctime

def loop1():

	print "start %s " %ctime()

	print "start in loop1"

	sleep(3)

	print "end %s " %ctime()



def loop2():

	print "sart %s " %ctime()

	print "start in loop2"

	sleep(6)

	print "end %s " %ctime()





class MyThread(threading.Thread):

	def __init__(self,fun,arg,name=""):

		threading.Thread.__init__(self)

		self.fun=fun

		self.arg=arg

		self.name=name

		#self.result



	def run(self):

		self.result=apply(self.fun,self.arg)

	

	def getResult(self):

		return self.result



def fib(n):

	if n<2:

		return 1

	else:

		return fib(n-1)+fib(n-2)





def sum(n):

	if n<2:

		return 1

	else:

		return n+sum(n-1)	



def fab(n):

	if n<2:

		return 1

	else:

		return n*fab(n-1)



def single_thread():		

	print fib(12)		

	print sum(12)

	print fab(12)





def multi_thread():

	print "in multithread"

	fun_list=[fib,sum,fab]

	n=len(fun_list)

	threads=

	count=12

	for i in range(n):

		t=MyThread(fun_list,(count,),fun_list.__name__)

		threads.append(t)

	for i in range(n):

		threads.start()



	for i in range(n):

		threads.join()

		result= threads.getResult()

		print result

def main():

	'''

	print "start at main"

	thread.start_new_thread(loop1,())

	thread.start_new_thread(loop2,())

	sleep(10)

	print "end at main"

	'''

	start=ctime()

	#print "Used %f" %(end-start).seconds

	print start	

	single_thread()

	end=ctime()

	print end

	multi_thread()

	#print "used %s" %(end-start).seconds 

if __name__=="__main__":

	main()

最终运行的格式就是 python scan_host.py 192.168.1. 22
上面的命令就是扫描192.168.1 ip段开启了22端口服务的机器，也就是ssh服务。

github：https://github.com/Rockyzsu/scan_host

python爬虫模拟登陆知乎推送知乎文章到kindle电子书获取自己的关注问题

python爬虫 • 低调的哥哥发表了文章 • 0 个评论 • 38715 次浏览 • 2016-05-12 17:53 • 来自相关话题

平时逛知乎，上班的时候看到一些好的答案，不过由于答案太长，没来得及看完，所以自己写了个python脚本，把自己想要的答案抓取下来，并且推送到kindle上，下班后用kindle再慢慢看。平时喜欢的内容也可以整理成电子书抓取下来，等周末闲时看。

#2016-08-19更新：
添加了模拟登陆知乎的模块，自动获取自己的关注的问题id，然后把这些问题的所有答案抓取下来推送到kindle

# -*-coding=utf-8-*-
__author__ = 'Rocky'
# -*-coding=utf-8-*-
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import smtplib
from email import Encoders, Utils
import urllib2
import time
import re
import sys
import os

from bs4 import BeautifulSoup

from email.Header import Header

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

class GetContent():
def __init__(self, id):

# 给出的第一个参数就是你要下载的问题的id
# 比如想要下载的问题链接是 https://www.zhihu.com/question/29372574
# 那么就输入 python zhihu.py 29372574

id_link = "/question/" + id
self.getAnswer(id_link)

def save2file(self, filename, content):
# 保存为电子书文件
filename = filename + ".txt"
f = open(filename, 'a')
f.write(content)
f.close()

def getAnswer(self, answerID):
host = "http://www.zhihu.com"
url = host + answerID
print url
user_agent = "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)"
# 构造header 伪装一下
header = {"User-Agent": user_agent}
req = urllib2.Request(url, headers=header)

try:
resp = urllib2.urlopen(req)
except:
print "Time out. Retry"
time.sleep(30)
# try to switch with proxy ip
resp = urllib2.urlopen(req)
# 这里已经获取了网页的代码，接下来就是提取你想要的内容。使用beautifulSoup 来处理，很方便
try:
bs = BeautifulSoup(resp)

except:
print "Beautifulsoup error"
return None

title = bs.title
# 获取的标题

filename_old = title.string.strip()
print filename_old
filename = re.sub('[\/:*?"<>|]', '-', filename_old)
# 用来保存内容的文件名，因为文件名不能有一些特殊符号，所以使用正则表达式过滤掉

self.save2file(filename, title.string)

detail = bs.find("div", class_="zm-editable-content")

self.save2file(filename, "\n\n\n\n--------------------Detail----------------------\n\n")
# 获取问题的补充内容

if detail is not None:

for i in detail.strings:
self.save2file(filename, unicode(i))

answer = bs.find_all("div", class_="zm-editable-content clearfix")
k = 0
index = 0
for each_answer in answer:

self.save2file(filename, "\n\n-------------------------answer %s via -------------------------\n\n" % k)

for a in each_answer.strings:
# 循环获取每一个答案的内容，然后保存到文件中
self.save2file(filename, unicode(a))
k += 1
index = index + 1

smtp_server = 'smtp.126.com'
from_mail = 'your@126.com'
password = 'yourpassword'
to_mail = 'yourname@kindle.cn'

# send_kindle=MailAtt(smtp_server,from_mail,password,to_mail)
# send_kindle.send_txt(filename)

# 调用发送邮件函数，把电子书发送到你的kindle用户的邮箱账号，这样你的kindle就可以收到电子书啦
print filename

class MailAtt():
def __init__(self, smtp_server, from_mail, password, to_mail):
self.server = smtp_server
self.username = from_mail.split("@")[0]
self.from_mail = from_mail
self.password = password
self.to_mail = to_mail

# 初始化邮箱设置

def send_txt(self, filename):
# 这里发送附件尤其要注意字符编码，当时调试了挺久的，因为收到的文件总是乱码
self.smtp = smtplib.SMTP()
self.smtp.connect(self.server)
self.smtp.login(self.username, self.password)
self.msg = MIMEMultipart()
self.msg['to'] = self.to_mail
self.msg['from'] = self.from_mail
self.msg['Subject'] = "Convert"
self.filename = filename + ".txt"
self.msg['Date'] = Utils.formatdate(localtime=1)
content = open(self.filename.decode('utf-8'), 'rb').read()
# print content
self.att = MIMEText(content, 'base64', 'utf-8')
self.att['Content-Type'] = 'application/octet-stream'
# self.att["Content-Disposition"] = "attachment;filename=\"%s\"" %(self.filename.encode('gb2312'))
self.att["Content-Disposition"] = "attachment;filename=\"%s\"" % Header(self.filename, 'gb2312')
# print self.att["Content-Disposition"]
self.msg.attach(self.att)

self.smtp.sendmail(self.msg['from'], self.msg['to'], self.msg.as_string())
self.smtp.quit()

if __name__ == "__main__":

sub_folder = os.path.join(os.getcwd(), "content")
# 专门用于存放下载的电子书的目录

if not os.path.exists(sub_folder):
os.mkdir(sub_folder)

os.chdir(sub_folder)

id = sys.argv[1]
# 给出的第一个参数就是你要下载的问题的id
# 比如想要下载的问题链接是 https://www.zhihu.com/question/29372574
# 那么就输入 python zhihu.py 29372574

# id_link="/question/"+id
obj = GetContent(id)
# obj.getAnswer(id_link)

# 调用获取函数

print "Done"

#######################################
2016.8.19 更新
添加了新功能，模拟知乎登陆，自动获取自己关注的答案，制作成电子书并且发送到kindle

# -*-coding=utf-8-*-
__author__ = 'Rocky'
import requests
import cookielib
import re
import json
import time
import os
from getContent import GetContent
agent='Mozilla/5.0 (Windows NT 5.1; rv:33.0) Gecko/20100101 Firefox/33.0'
headers={'Host':'www.zhihu.com',
'Referer':'https://www.zhihu.com',
'User-Agent':agent}

#全局变量
session=requests.session()

session.cookies=cookielib.LWPCookieJar(filename="cookies")

try:
session.cookies.load(ignore_discard=True)
except:
print "Cookie can't load"

def isLogin():
url='https://www.zhihu.com/settings/profile'
login_code=session.get(url,headers=headers,allow_redirects=False).status_code
print login_code
if login_code == 200:
return True
else:
return False

def get_xsrf():
url='http://www.zhihu.com'
r=session.get(url,headers=headers,allow_redirects=False)
txt=r.text
result=re.findall(r'<input type=\"hidden\" name=\"_xsrf\" value=\"(\w+)\"/>',txt)[0]
return result

def getCaptcha():
#r=1471341285051
r=(time.time()*1000)
url='http://www.zhihu.com/captcha.gif?r='+str(r)+'&type=login'

image=session.get(url,headers=headers)
f=open("photo.jpg",'wb')
f.write(image.content)
f.close()

def Login():
xsrf=get_xsrf()
print xsrf
print len(xsrf)
login_url='http://www.zhihu.com/login/email'
data={
'_xsrf':xsrf,
'password':'*',
'remember_me':'true',
'email':'*'
}
try:
content=session.post(login_url,data=data,headers=headers)
login_code=content.text
print content.status_code
#this line important ! if no status, if will fail and execute the except part
#print content.status

if content.status_code != requests.codes.ok:
print "Need to verification code !"
getCaptcha()
#print "Please input the code of the captcha"
code=raw_input("Please input the code of the captcha")
data['captcha']=code
content=session.post(login_url,data=data,headers=headers)
print content.status_code

if content.status_code==requests.codes.ok:
print "Login successful"
session.cookies.save()
#print login_code
else:
session.cookies.save()
except:
print "Error in login"
return False

def focus_question():
focus_id=
url='https://www.zhihu.com/question/following'
content=session.get(url,headers=headers)
print content
p=re.compile(r'<a class="question_link" href="/question/(\d+)" target="_blank" data-id')
id_list=p.findall(content.text)
pattern=re.compile(r'<input type=\"hidden\" name=\"_xsrf\" value=\"(\w+)\"/>')
result=re.findall(pattern,content.text)[0]
print result
for i in id_list:
print i
focus_id.append(i)

url_next='https://www.zhihu.com/node/ProfileFollowedQuestionsV2'
page=20
offset=20
end_page=500
xsrf=re.findall(r'<input type=\"hidden\" name=\"_xsrf\" value=\"(\w+)\"',content.text)[0]
while offset < end_page:
#para='{"offset":20}'
#print para
print "page: %d" %offset
params={"offset":offset}
params_json=json.dumps(params)

data={
'method':'next',
'params':params_json,
'_xsrf':xsrf
}
#注意上面那里 post的data需要一个xsrf的字段，不然会返回403 的错误，这个在抓包的过程中一直都没有看到提交到xsrf，所以自己摸索出来的
offset=offset+page
headers_l={
'Host':'www.zhihu.com',
'Referer':'https://www.zhihu.com/question/following',
'User-Agent':agent,
'Origin':'https://www.zhihu.com',
'X-Requested-With':'XMLHttpRequest'
}
try:
s=session.post(url_next,data=data,headers=headers_l)
#print s.status_code
#print s.text
msgs=json.loads(s.text)
msg=msgs['msg']
for i in msg:
id_sub=re.findall(p,i)

for j in id_sub:
print j
id_list.append(j)

except:
print "Getting Error "

return id_list

def main():

if isLogin():
print "Has login"
else:
print "Need to login"
Login()
list_id=focus_question()
for i in list_id:
print i
obj=GetContent(i)

#getCaptcha()
if __name__=='__main__':
sub_folder=os.path.join(os.getcwd(),"content")
#专门用于存放下载的电子书的目录

if not os.path.exists(sub_folder):
os.mkdir(sub_folder)

os.chdir(sub_folder)

main()

完整代码请猛击这里:
github: https://github.com/Rockyzsu/zhihuToKindle
查看全部

平时逛知乎，上班的时候看到一些好的答案，不过由于答案太长，没来得及看完，所以自己写了个python脚本，把自己想要的答案抓取下来，并且推送到kindle上，下班后用kindle再慢慢看。平时喜欢的内容也可以整理成电子书抓取下来，等周末闲时看。

#2016-08-19更新：
添加了模拟登陆知乎的模块，自动获取自己的关注的问题id，然后把这些问题的所有答案抓取下来推送到kindle

# -*-coding=utf-8-*-

__author__ = 'Rocky'

# -*-coding=utf-8-*-

from email.mime.text import MIMEText

from email.mime.multipart import MIMEMultipart

import smtplib

from email import Encoders, Utils

import urllib2

import time

import re

import sys

import os



from bs4 import BeautifulSoup



from email.Header import Header



reload(sys)

sys.setdefaultencoding('utf-8')





class GetContent():

    def __init__(self, id):



        # 给出的第一个参数 就是你要下载的问题的id

        # 比如 想要下载的问题链接是 https://www.zhihu.com/question/29372574

        # 那么 就输入 python zhihu.py 29372574



        id_link = "/question/" + id

        self.getAnswer(id_link)



    def save2file(self, filename, content):

        # 保存为电子书文件

        filename = filename + ".txt"

        f = open(filename, 'a')

        f.write(content)

        f.close()



    def getAnswer(self, answerID):

        host = "http://www.zhihu.com"

        url = host + answerID

        print url

        user_agent = "Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)"

        # 构造header 伪装一下

        header = {"User-Agent": user_agent}

        req = urllib2.Request(url, headers=header)



        try:

            resp = urllib2.urlopen(req)

        except:

            print "Time out. Retry"

            time.sleep(30)

            # try to switch with proxy ip

            resp = urllib2.urlopen(req)

        # 这里已经获取了 网页的代码，接下来就是提取你想要的内容。 使用beautifulSoup 来处理，很方便

        try:

            bs = BeautifulSoup(resp)



        except:

            print "Beautifulsoup error"

            return None



        title = bs.title

        # 获取的标题



        filename_old = title.string.strip()

        print filename_old

        filename = re.sub('[\/:*?"<>|]', '-', filename_old)

        # 用来保存内容的文件名，因为文件名不能有一些特殊符号，所以使用正则表达式过滤掉



        self.save2file(filename, title.string)





        detail = bs.find("div", class_="zm-editable-content")



        self.save2file(filename, "\n\n\n\n--------------------Detail----------------------\n\n")

        # 获取问题的补充内容



        if detail is not None:



            for i in detail.strings:

                self.save2file(filename, unicode(i))



        answer = bs.find_all("div", class_="zm-editable-content clearfix")

        k = 0

        index = 0

        for each_answer in answer:



            self.save2file(filename, "\n\n-------------------------answer %s via  -------------------------\n\n" % k)



            for a in each_answer.strings:

                # 循环获取每一个答案的内容，然后保存到文件中

                self.save2file(filename, unicode(a))

            k += 1

            index = index + 1



        smtp_server = 'smtp.126.com'

        from_mail = 'your@126.com'

        password = 'yourpassword'

        to_mail = 'yourname@kindle.cn'



        # send_kindle=MailAtt(smtp_server,from_mail,password,to_mail)

        # send_kindle.send_txt(filename)



        # 调用发送邮件函数，把电子书发送到你的kindle用户的邮箱账号，这样你的kindle就可以收到电子书啦

        print filename





class MailAtt():

    def __init__(self, smtp_server, from_mail, password, to_mail):

        self.server = smtp_server

        self.username = from_mail.split("@")[0]

        self.from_mail = from_mail

        self.password = password

        self.to_mail = to_mail



        # 初始化邮箱设置



    def send_txt(self, filename):

        # 这里发送附件尤其要注意字符编码，当时调试了挺久的，因为收到的文件总是乱码

        self.smtp = smtplib.SMTP()

        self.smtp.connect(self.server)

        self.smtp.login(self.username, self.password)

        self.msg = MIMEMultipart()

        self.msg['to'] = self.to_mail

        self.msg['from'] = self.from_mail

        self.msg['Subject'] = "Convert"

        self.filename = filename + ".txt"

        self.msg['Date'] = Utils.formatdate(localtime=1)

        content = open(self.filename.decode('utf-8'), 'rb').read()

        # print content

        self.att = MIMEText(content, 'base64', 'utf-8')

        self.att['Content-Type'] = 'application/octet-stream'

        # self.att["Content-Disposition"] = "attachment;filename=\"%s\"" %(self.filename.encode('gb2312'))

        self.att["Content-Disposition"] = "attachment;filename=\"%s\"" % Header(self.filename, 'gb2312')

        # print self.att["Content-Disposition"]

        self.msg.attach(self.att)



        self.smtp.sendmail(self.msg['from'], self.msg['to'], self.msg.as_string())

        self.smtp.quit()





if __name__ == "__main__":



    sub_folder = os.path.join(os.getcwd(), "content")

    # 专门用于存放下载的电子书的目录



    if not os.path.exists(sub_folder):

        os.mkdir(sub_folder)



    os.chdir(sub_folder)



    id = sys.argv[1]

    # 给出的第一个参数 就是你要下载的问题的id

    # 比如 想要下载的问题链接是 https://www.zhihu.com/question/29372574

    # 那么 就输入 python zhihu.py 29372574





    # id_link="/question/"+id

    obj = GetContent(id)

    # obj.getAnswer(id_link)



    # 调用获取函数



    print "Done"

#######################################
2016.8.19 更新
添加了新功能，模拟知乎登陆，自动获取自己关注的答案，制作成电子书并且发送到kindle

# -*-coding=utf-8-*-

__author__ = 'Rocky'

import requests

import cookielib

import re

import json

import time

import os

from getContent import GetContent

agent='Mozilla/5.0 (Windows NT 5.1; rv:33.0) Gecko/20100101 Firefox/33.0'

headers={'Host':'www.zhihu.com',

         'Referer':'https://www.zhihu.com',

         'User-Agent':agent}



#全局变量

session=requests.session()



session.cookies=cookielib.LWPCookieJar(filename="cookies")



try:

    session.cookies.load(ignore_discard=True)

except:

    print "Cookie can't load"



def isLogin():

    url='https://www.zhihu.com/settings/profile'

    login_code=session.get(url,headers=headers,allow_redirects=False).status_code

    print login_code

    if login_code == 200:

        return True

    else:

        return False



def get_xsrf():

    url='http://www.zhihu.com'

    r=session.get(url,headers=headers,allow_redirects=False)

    txt=r.text

    result=re.findall(r'<input type=\"hidden\" name=\"_xsrf\" value=\"(\w+)\"/>',txt)[0]

    return result



def getCaptcha():

    #r=1471341285051

    r=(time.time()*1000)

    url='http://www.zhihu.com/captcha.gif?r='+str(r)+'&type=login'



    image=session.get(url,headers=headers)

    f=open("photo.jpg",'wb')

    f.write(image.content)

    f.close()





def Login():

    xsrf=get_xsrf()

    print xsrf

    print len(xsrf)

    login_url='http://www.zhihu.com/login/email'

    data={

    '_xsrf':xsrf,

    'password':'*',

    'remember_me':'true',

    'email':'*'

    }

    try:

        content=session.post(login_url,data=data,headers=headers)

        login_code=content.text

        print content.status_code

        #this line important ! if no status, if will fail and execute the except part

        #print content.status



        if content.status_code != requests.codes.ok:

            print "Need to verification code !"

            getCaptcha()

            #print "Please input the code of the captcha"

            code=raw_input("Please input the code of the captcha")

            data['captcha']=code

            content=session.post(login_url,data=data,headers=headers)

            print content.status_code



            if content.status_code==requests.codes.ok:

                print "Login successful"

                session.cookies.save()

            #print login_code

        else:

            session.cookies.save()

    except:

        print "Error in login"

        return False



def focus_question():

    focus_id=

    url='https://www.zhihu.com/question/following'

    content=session.get(url,headers=headers)

    print content

    p=re.compile(r'<a class="question_link" href="/question/(\d+)" target="_blank" data-id')

    id_list=p.findall(content.text)

    pattern=re.compile(r'<input type=\"hidden\" name=\"_xsrf\" value=\"(\w+)\"/>')

    result=re.findall(pattern,content.text)[0]

    print result

    for i in id_list:

        print i

        focus_id.append(i)



    url_next='https://www.zhihu.com/node/ProfileFollowedQuestionsV2'

    page=20

    offset=20

    end_page=500

    xsrf=re.findall(r'<input type=\"hidden\" name=\"_xsrf\" value=\"(\w+)\"',content.text)[0]

    while offset < end_page:

        #para='{"offset":20}'

        #print para

        print "page: %d" %offset

        params={"offset":offset}

        params_json=json.dumps(params)



        data={

        'method':'next',

        'params':params_json,

        '_xsrf':xsrf

        }

        #注意上面那里 post的data需要一个xsrf的字段，不然会返回403 的错误，这个在抓包的过程中一直都没有看到提交到xsrf，所以自己摸索出来的

        offset=offset+page

        headers_l={

        'Host':'www.zhihu.com',

        'Referer':'https://www.zhihu.com/question/following',

        'User-Agent':agent,

        'Origin':'https://www.zhihu.com',

        'X-Requested-With':'XMLHttpRequest'

        }

        try:

            s=session.post(url_next,data=data,headers=headers_l)

            #print s.status_code

            #print s.text

            msgs=json.loads(s.text)

            msg=msgs['msg']

            for i in msg:

                id_sub=re.findall(p,i)



                for j in id_sub:

                    print j

                    id_list.append(j)



        except:

            print "Getting Error "





    return id_list



def main():



    if isLogin():

        print "Has login"

    else:

        print "Need to login"

        Login()

    list_id=focus_question()

    for i in list_id:

        print i

        obj=GetContent(i)



    #getCaptcha()

if __name__=='__main__':

    sub_folder=os.path.join(os.getcwd(),"content")

    #专门用于存放下载的电子书的目录



    if not os.path.exists(sub_folder):

        os.mkdir(sub_folder)



    os.chdir(sub_folder)



    main()

完整代码请猛击这里:
github: https://github.com/Rockyzsu/zhihuToKindle

晨跑30分钟 30天

默认分类 • 低调的哥哥发表了文章 • 0 个评论 • 4487 次浏览 • 2016-05-09 21:54 • 来自相关话题

曾经，哦不，是一直到现在，我几乎没有在6点前起过床。然后每天却在叫嚷，时间不够用呀，然后就是熬夜晚睡。虽然知道熬夜等于慢性自杀，可是，和很多人一样，道理都懂，却总是无法彻底执行，每次脑子的两个小人，恶魔总是轻而易举地战胜了天使。而养成一个习惯，至少要30天。

说实话，我本子记录的计划多的不胜枚举，可是真正被窝执行的却寥寥无几。包括标题的这个，6点起床，晨跑30分钟。只不过，这一次把笔记本上的记录搬上自己的网站啦。我不想在众目睽睽之下失信。我觉得这样会让我执行计划的时候更加坚决。

早起去跑步的好处是：

晨跑能迫使人早起。是的，正常的话我要睡到8点，早起跑完步还可以多出一个半小时来做其他事情。

晨跑能够提高人整天的代谢水平，从而是全天的能量消耗达到一个较高值，对减肥来说是很有益的。简单来说，晨跑30分钟全天的总代谢就能上升一个台阶，这个比以同样速度夜跑30分钟要有效的多。

晨跑能让人从一夜的睡眠中清醒过来并维持全天的良好身体状态。

晨跑能迅速提升人体的循环，排出一夜睡眠后积累在体内的代谢废物。跑过晨跑后，代谢废物的排出要比不跑快很多。

看完上面那几条，你是不是也心动想要一起行动呢？是的话赶紧加入吧。和我比比，看谁坚持的时间长哦～查看全部

曾经，哦不，是一直到现在，我几乎没有在6点前起过床。然后每天却在叫嚷，时间不够用呀，然后就是熬夜晚睡。虽然知道熬夜等于慢性自杀，可是，和很多人一样，道理都懂，却总是无法彻底执行，每次脑子的两个小人，恶魔总是轻而易举地战胜了天使。而养成一个习惯，至少要30天。

说实话，我本子记录的计划多的不胜枚举，可是真正被窝执行的却寥寥无几。包括标题的这个，6点起床，晨跑30分钟。只不过，这一次把笔记本上的记录搬上自己的网站啦。我不想在众目睽睽之下失信。我觉得这样会让我执行计划的时候更加坚决。

早起去跑步的好处是：

晨跑能迫使人早起。是的，正常的话我要睡到8点，早起跑完步还可以多出一个半小时来做其他事情。

晨跑能够提高人整天的代谢水平，从而是全天的能量消耗达到一个较高值，对减肥来说是很有益的。简单来说，晨跑30分钟全天的总代谢就能上升一个台阶，这个比以同样速度夜跑30分钟要有效的多。

晨跑能让人从一夜的睡眠中清醒过来并维持全天的良好身体状态。

晨跑能迅速提升人体的循环，排出一夜睡眠后积累在体内的代谢废物。跑过晨跑后，代谢废物的排出要比不跑快很多。

看完上面那几条，你是不是也心动想要一起行动呢？是的话赶紧加入吧。和我比比，看谁坚持的时间长哦～

30天，也许会改变你人生的轨迹

30天新尝试 • 低调的哥哥发表了文章 • 1 个评论 • 5287 次浏览 • 2016-05-09 16:05 • 来自相关话题

30天，在漫长的一生当中，短暂而易逝。就如在不经意间，收到手机的月结扣费短信，然后惊呼 ”这么快又月结扣费。而在某一集TED演讲中，主人公马特·卡茨却用这30天的时间，尝试新事情，完成了一件又一件看似不可能的事情，因此生活发生了很大的改变，而人生的轨迹也不再是原来那样的两点一线。

https://www.bilibili.com/video/BV1Rv411B7fe?share_source=copy_web

看完后，你是否和我一样，有一股冲动，嗯，曾经藏起来的那个儿时的梦想，曾经在脑海中瞬间即逝的疯狂的想法，是否想去尝试一下？

害怕被人笑？害怕失败？没关系，30天之后，又是一条好汉。30天在生命中就如沧海一粟，而你尝试的这些新事情，却会一直印记在脑海中。

30天，每天坚持写1千字，30天，就可以写3万字，这个篇幅，相当于一部短篇小说了。如果能够坚持3个月，说不定你就可以出版一本书了呢。

以后，当你向别人介绍自己时，你不是说，“我是一名软件工程师"，而是“我是某本书的作者”，“我是一名记者"，"我是一名志愿者", "我是一个TED的演讲者"。这本身是一件多么酷的一件事情呀。

所以这个也是我做这个网站的意义所在，旨在鼓励更多的朋友，行动起来，在接下来的30天里，做一件曾经想做却没机会做的事情。你每天不仅仅只是上班下班吃饭睡觉这样的流水线般的过着腐朽的日子，一个有肉有灵魂的人物，为什么不能过的出彩？为什么不去试一试新的事情？

来吧，我已经行动了，我觉得以前错过了很多很多精彩的瞬间，悟以往之不谏，知来者之可追，30天为一个周期，希望能够亡羊补牢吧。

互勉～

2016年5月9日查看全部

30天，在漫长的一生当中，短暂而易逝。就如在不经意间，收到手机的月结扣费短信，然后惊呼 ”这么快又月结扣费。而在某一集TED演讲中，主人公马特·卡茨却用这30天的时间，尝试新事情，完成了一件又一件看似不可能的事情，因此生活发生了很大的改变，而人生的轨迹也不再是原来那样的两点一线。

https://www.bilibili.com/video/BV1Rv411B7fe?share_source=copy_web

看完后，你是否和我一样，有一股冲动，嗯，曾经藏起来的那个儿时的梦想，曾经在脑海中瞬间即逝的疯狂的想法，是否想去尝试一下？

害怕被人笑？害怕失败？没关系，30天之后，又是一条好汉。30天在生命中就如沧海一粟，而你尝试的这些新事情，却会一直印记在脑海中。

30天，每天坚持写1千字，30天，就可以写3万字，这个篇幅，相当于一部短篇小说了。如果能够坚持3个月，说不定你就可以出版一本书了呢。

以后，当你向别人介绍自己时，你不是说，“我是一名软件工程师"，而是“我是某本书的作者”，“我是一名记者"，"我是一名志愿者", "我是一个TED的演讲者"。这本身是一件多么酷的一件事情呀。

所以这个也是我做这个网站的意义所在，旨在鼓励更多的朋友，行动起来，在接下来的30天里，做一件曾经想做却没机会做的事情。你每天不仅仅只是上班下班吃饭睡觉这样的流水线般的过着腐朽的日子，一个有肉有灵魂的人物，为什么不能过的出彩？为什么不去试一试新的事情？

来吧，我已经行动了，我觉得以前错过了很多很多精彩的瞬间，悟以往之不谏，知来者之可追，30天为一个周期，希望能够亡羊补牢吧。

互勉～

2016年5月9日

通知设置新通知

发现