{
  "trx_id": "fd4d8d50af3547d67edc589688e0148a603ae042",
  "block": 106144360,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2026-05-18T01:00:57",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "7939.489661 VESTS"
    }
  ]
}

{
  "trx_id": "ad86e86c94c71fa87087d197e47c77eba413db8c",
  "block": 105979412,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2026-05-12T06:55:57",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "5227.279256 VESTS"
    }
  ]
}

{
  "trx_id": "d2f29532590b1fc56bf4ea45620062f5617d15a7",
  "block": 105511987,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2026-04-26T00:20:30",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "7952.005417 VESTS"
    }
  ]
}

{
  "trx_id": "2a3b6a7fb0c07ceb3cc3ddebf44dbde4fffaa5e5",
  "block": 102854260,
  "trx_in_block": 1,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2026-01-23T09:50:42",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "5268.826075 VESTS"
    }
  ]
}

{
  "trx_id": "51bb523566f74e4e34ad5f063c684593323dbe15",
  "block": 91300643,
  "trx_in_block": 2,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2024-12-17T05:08:51",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "5433.045272 VESTS"
    }
  ]
}

{
  "trx_id": "3121c16d86a47d291d757f4b52a2e05f57d945be",
  "block": 79854833,
  "trx_in_block": 7,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2023-11-13T20:51:15",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "5602.178804 VESTS"
    }
  ]
}

{
  "trx_id": "6b7a7a1439bfe5e8c0d1f009de36d1fb6dd445be",
  "block": 78348903,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2023-09-21T22:43:39",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "8539.457590 VESTS"
    }
  ]
}

{
  "trx_id": "09eda145bf3685c0bdbfd1c83ab1c7f879db28b7",
  "block": 69114100,
  "trx_in_block": 3,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2022-11-03T12:24:18",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "8761.139028 VESTS"
    }
  ]
}

{
  "trx_id": "ecd797976528dd126bc888794c17ca32d8cd10a8",
  "block": 60810198,
  "trx_in_block": 11,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2022-01-17T11:36:45",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "8981.672259 VESTS"
    }
  ]
}

{
  "trx_id": "6a524d7714aa29590781133276581e62c47561e9",
  "block": 54608545,
  "trx_in_block": 11,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2021-06-14T01:30:09",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "9165.440917 VESTS"
    }
  ]
}

{
  "trx_id": "b27109c50b25eb8803de16bfd408f72f15b957a5",
  "block": 49355973,
  "trx_in_block": 1,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-12-11T11:47:51",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "9352.862891 VESTS"
    }
  ]
}

{
  "trx_id": "61ea38b570bcd71c2fce0e1618a7056da922185d",
  "block": 49207533,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-12-06T05:25:00",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "1912.543513 VESTS"
    }
  ]
}

{
  "trx_id": "8a5ea1af1557f86e1997b3ec3c6280c64d177977",
  "block": 49191067,
  "trx_in_block": 25,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-12-05T15:25:48",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "9359.070745 VESTS"
    }
  ]
}

{
  "trx_id": "619ebc3ffa9385e34e42a54262c0488f4f572f1e",
  "block": 48259437,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-11-02T17:01:42",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "1920.017158 VESTS"
    }
  ]
}

{
  "trx_id": "b0c8ae4d4b1f2d2d8fdb9a549cce6d9b4a3ab2e4",
  "block": 43217792,
  "trx_in_block": 5,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-05-09T06:23:00",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "9561.876104 VESTS"
    }
  ]
}

{
  "trx_id": "c907d84b87f3617aa78c9108907589d0bd6fd8f9",
  "block": 43194010,
  "trx_in_block": 10,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-05-08T10:05:24",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "1953.311140 VESTS"
    }
  ]
}

{
  "trx_id": "a8d96036222d77c0d7140d49ee71cfa278fbba40",
  "block": 41614301,
  "trx_in_block": 14,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-03-13T11:20:45",
  "op": [
    "comment",
    {
      "parent_author": "hashaki",
      "parent_permlink": "win",
      "author": "steemitboard",
      "permlink": "steemitboard-notify-hashaki-20200313t112045000z",
      "title": "",
      "body": "Congratulations @hashaki! You received a personal award!\n\n<table><tr><td>https://steemitimages.com/70x70/http://steemitboard.com/@hashaki/birthday2.png</td><td>Happy Steem Birthday! - You are on the Steem blockchain for 2 years!</td></tr></table>\n\n<sub>_You can view [your badges on your Steem Board](https://steemitboard.com/@hashaki) and compare to others on the [Steem Ranking](https://steemitboard.com/ranking/index.php?name=hashaki)_</sub>\n\n\n**Do not miss the last post from @steemitboard:**\n<table><tr><td><a href=\"https://steemit.com/steemitboard/@steemitboard/downvote-challenge-add-up-to-3-funny-badges-to-your-board\"><img src=\"https://steemitimages.com/64x128/https://steemitimages.com/0x0/![](https://cdn.steemitimages.com/DQmUuJkZdnSpHVWssxF82ntymqXg4Pvk6K6bYvckUYVRsnj/image.png)\"></a></td><td><a href=\"https://steemit.com/steemitboard/@steemitboard/downvote-challenge-add-up-to-3-funny-badges-to-your-board\">Downvote challenge - Add up to 3 funny badges to your board</a></td></tr></table>\n\n###### [Vote for @Steemitboard as a witness](https://v2.steemconnect.com/sign/account-witness-vote?witness=steemitboard&approve=1) to get one more award and increased upvotes!",
      "json_metadata": "{\"image\":[\"https://steemitboard.com/img/notify.png\"]}"
    }
  ]
}

{
  "trx_id": "fce09bb0e677aeeb19df4756ebf6f531fd99c933",
  "block": 38620867,
  "trx_in_block": 2,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2019-11-30T07:03:54",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "9651.161441 VESTS"
    }
  ]
}

{
  "trx_id": "ea70bf981e0e4bbc4ff882d4f3dcf20213ed36a6",
  "block": 31377314,
  "trx_in_block": 38,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2019-03-22T13:24:45",
  "op": [
    "vote",
    {
      "voter": "bitming",
      "author": "hashaki",
      "permlink": "vnpy",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "fe6e1922bcd31881b7e4b2b12dc5d298e59156fb",
  "block": 31123366,
  "trx_in_block": 6,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2019-03-13T17:37:12",
  "op": [
    "comment",
    {
      "parent_author": "hashaki",
      "parent_permlink": "win",
      "author": "steemitboard",
      "permlink": "steemitboard-notify-hashaki-20190313t173711000z",
      "title": "",
      "body": "Congratulations @hashaki! You received a personal award!\n\n<table><tr><td>https://steemitimages.com/70x70/http://steemitboard.com/@hashaki/birthday1.png</td><td>Happy Birthday! - You are on the Steem blockchain for 1 year!</td></tr></table>\n\n<sub>_You can view [your badges on your Steem Board](https://steemitboard.com/@hashaki) and compare to others on the [Steem Ranking](http://steemitboard.com/ranking/index.php?name=hashaki)_</sub>\n\n\n**Do not miss the last post from @steemitboard:**\n<table><tr><td><a href=\"https://steemit.com/drugwars/@steemitboard/drugwars-early-adopter\"><img src=\"https://steemitimages.com/64x128/https://cdn.steemitimages.com/DQmYGN7R653u4hDFyq1hM7iuhr2bdAP1v2ApACDNtecJAZ5/image.png\"></a></td><td><a href=\"https://steemit.com/drugwars/@steemitboard/drugwars-early-adopter\">Are you a DrugWars early adopter? Benvenuto in famiglia!</a></td></tr></table>\n\n###### [Vote for @Steemitboard as a witness](https://v2.steemconnect.com/sign/account-witness-vote?witness=steemitboard&approve=1) to get one more award and increased upvotes!",
      "json_metadata": "{\"image\":[\"https://steemitboard.com/img/notify.png\"]}"
    }
  ]
}

{
  "trx_id": "a611f19bbf783e845756e2b36f42e132921d7ba2",
  "block": 29092989,
  "trx_in_block": 7,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2019-01-02T04:11:48",
  "op": [
    "custom_json",
    {
      "required_auths": [],
      "required_posting_auths": [
        "hashaki"
      ],
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"hashaki\",\"following\":\"kamada3\",\"what\":[\"blog\"]}]"
    }
  ]
}

{
  "trx_id": "e1d5edea2006403194934b0d8601b97458dfac19",
  "block": 28940240,
  "trx_in_block": 17,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-12-27T20:49:27",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "9848.292194 VESTS"
    }
  ]
}

{
  "trx_id": "1722af302ab2b7705e8de31a383b3d43a09d926d",
  "block": 28044222,
  "trx_in_block": 18,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-11-26T17:44:03",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "30005.591983 VESTS"
    }
  ]
}

{
  "trx_id": "6b5eed28fceba581b6d57896f6ada8eb82abdad5",
  "block": 26320675,
  "trx_in_block": 6,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-09-27T20:25:24",
  "op": [
    "vote",
    {
      "voter": "quencore",
      "author": "hashaki",
      "permlink": "win",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "d0acace635d2ebeacb3abc71fd564e76f18b9930",
  "block": 26320661,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-09-27T20:24:42",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "cn",
      "author": "hashaki",
      "permlink": "win",
      "title": "win上设置全局代理",
      "body": "1，下载proxifiter:\n地址：https://www.proxifier.com/\n激活KEY：\nJCZBX-A3N3F-9DWY5-327V5-DKUXX \nLPZLA-FW4R4-NV52E-Q9RYW-PH3ZY \n\n设置：\n![1.jpg](https://cdn.steemitimages.com/DQmPZ11BnCxundzCijPv7WQEbkv33qb4w8STL9wQDbF6twm/1.jpg)\n\na,添加服务器：\n![2.jpg](https://cdn.steemitimages.com/DQmUpv5rDVotfo83j3cqn6nUSoDENjbtSQ95ydM3evkeGJJ/2.jpg)\n\nb,编辑链接方式：\n![3.jpg](https://cdn.steemitimages.com/DQmRKHADgaXN56AUEHdR2bkjNQQ82nahL2SHmucgeQYuwhv/3.jpg)\n\nc,DNS污染：\n![4.jpg](https://cdn.steemitimages.com/DQmPVdoTvvPrc7doXjCNxvqvkrXnfJuZnrqccicKgjdDFJU/4.jpg)\n\n\n2，服务器选择-蓝灯\n下载地址：https://github.com/getlantern/download\n\n在蓝灯中找到http和socks端口，记下来，写到第一步的a中。\n![5.jpg](https://cdn.steemitimages.com/DQmSRNjYDJFtM8UHyHNhnE16r8jwbRvQ2JMSBh9qzyjmwN8/5.jpg)",
      "json_metadata": "{\"tags\":[\"cn\",\"blog\"],\"image\":[\"https://cdn.steemitimages.com/DQmPZ11BnCxundzCijPv7WQEbkv33qb4w8STL9wQDbF6twm/1.jpg\",\"https://cdn.steemitimages.com/DQmUpv5rDVotfo83j3cqn6nUSoDENjbtSQ95ydM3evkeGJJ/2.jpg\",\"https://cdn.steemitimages.com/DQmRKHADgaXN56AUEHdR2bkjNQQ82nahL2SHmucgeQYuwhv/3.jpg\",\"https://cdn.steemitimages.com/DQmPVdoTvvPrc7doXjCNxvqvkrXnfJuZnrqccicKgjdDFJU/4.jpg\",\"https://cdn.steemitimages.com/DQmSRNjYDJFtM8UHyHNhnE16r8jwbRvQ2JMSBh9qzyjmwN8/5.jpg\"],\"links\":[\"https://www.proxifier.com/\",\"https://github.com/getlantern/download\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "b2135a25c507e5b97d78c1ff9f9476bb968ec940",
  "block": 26037833,
  "trx_in_block": 62,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-09-17T12:13:06",
  "op": [
    "vote",
    {
      "voter": "ygrj",
      "author": "hashaki",
      "permlink": "python3",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "1bfd3801bb4829a6aab2bf1772d9c24a5daffe1a",
  "block": 26032733,
  "trx_in_block": 13,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-09-17T07:11:57",
  "op": [
    "comment",
    {
      "parent_author": "introduce.bot",
      "parent_permlink": "introduce-bot-re-hashaki5nqzcn",
      "author": "hashaki",
      "permlink": "re-introducebot-introduce-bot-re-hashaki5nqzcn-20180917t071150808z",
      "title": "",
      "body": "No ,thank Q",
      "json_metadata": "{\"tags\":[\"cn\"],\"app\":\"steemit/0.1\"}"
    }
  ]
}

{
  "trx_id": "0c08c956edde888b64e309ad4c716dd59bd96201",
  "block": 26032724,
  "trx_in_block": 13,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-09-17T07:11:30",
  "op": [
    "comment",
    {
      "parent_author": "hashaki",
      "parent_permlink": "5nqzcn",
      "author": "introduce.bot",
      "permlink": "introduce-bot-re-hashaki5nqzcn",
      "title": "",
      "body": " @hashaki, I gave you a vote!<br>If you follow me, I will also follow you in return!",
      "json_metadata": ""
    }
  ]
}

{
  "trx_id": "e00c7af402a197465b8e1d8fe0bfa6e4b0181991",
  "block": 26032723,
  "trx_in_block": 43,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-09-17T07:11:27",
  "op": [
    "vote",
    {
      "voter": "introduce.bot",
      "author": "hashaki",
      "permlink": "5nqzcn",
      "weight": 100
    }
  ]
}

{
  "trx_id": "6e233553fe250c85233c40fe39372ac42bc145a0",
  "block": 26032722,
  "trx_in_block": 14,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-09-17T07:11:24",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "cn",
      "author": "hashaki",
      "permlink": "5nqzcn",
      "title": "如何使用常鸿量化机",
      "body": "按照我上一篇blog安装好python开发环境后，现在来使用常鸿量化机\n\n快乐版常鸿量化机源码下载地址：\n\nhttps://gitee.com/CCHChenChangHong/practice_code_field\n\n![码云.jpg](https://cdn.steemitimages.com/DQmfHQ3m7K4ucBLCT922SFPfK1pFoeSB5fE6vwTK5tH4fTD/%E7%A0%81%E4%BA%91.jpg)\n\n下载并解压：\n![下载好的快乐.jpg](https://cdn.steemitimages.com/DQmdGC2CVukuyDRu698eGGNxzTJ9vzfMzRAHEfRxtDMDFS1/%E4%B8%8B%E8%BD%BD%E5%A5%BD%E7%9A%84%E5%BF%AB%E4%B9%90.jpg)\n\n点进python->数字货币量化01：\n![最终量化机.jpg](https://cdn.steemitimages.com/DQmXtTLXwdQcUBTPmHKquDSC6NpbXN6Fp6KBcpg2ASwvj8U/%E6%9C%80%E7%BB%88%E9%87%8F%E5%8C%96%E6%9C%BA.jpg)\n\n用回上一篇用到得命令行模式，win键+R 输入cmd进入命令行模式，然后输入python加一个空格，然后把这个\n\nrun.py的位置复制进命令行里面，按回车即可运行\n![最终.jpg](https://cdn.steemitimages.com/DQmRFngAN1ANfuVszPEKXNdeCJmjeo4TmNJo2mymE1SDHGY/%E6%9C%80%E7%BB%88.jpg)",
      "json_metadata": "{\"tags\":[\"cn\",\"blog\",\"python\"],\"image\":[\"https://cdn.steemitimages.com/DQmfHQ3m7K4ucBLCT922SFPfK1pFoeSB5fE6vwTK5tH4fTD/%E7%A0%81%E4%BA%91.jpg\",\"https://cdn.steemitimages.com/DQmdGC2CVukuyDRu698eGGNxzTJ9vzfMzRAHEfRxtDMDFS1/%E4%B8%8B%E8%BD%BD%E5%A5%BD%E7%9A%84%E5%BF%AB%E4%B9%90.jpg\",\"https://cdn.steemitimages.com/DQmXtTLXwdQcUBTPmHKquDSC6NpbXN6Fp6KBcpg2ASwvj8U/%E6%9C%80%E7%BB%88%E9%87%8F%E5%8C%96%E6%9C%BA.jpg\",\"https://cdn.steemitimages.com/DQmRFngAN1ANfuVszPEKXNdeCJmjeo4TmNJo2mymE1SDHGY/%E6%9C%80%E7%BB%88.jpg\"],\"links\":[\"https://gitee.com/CCHChenChangHong/practice_code_field\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "f02d3cac9c403cd2896482d316d552ad4761058a",
  "block": 26032456,
  "trx_in_block": 37,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-09-17T06:58:06",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "cn",
      "author": "hashaki",
      "permlink": "python3",
      "title": "搭建python3开发环境",
      "body": "为了让用户使用常鸿量化机而写的搭建python开发环境的教程。\n\n我建议直接安装anaconda环境包，一键安装，省事省心，anaconda下载地址：(请选择适合你电脑系统的版本）\n\nhttps://www.anaconda.com/download/\n\n![anaconda.jpg](https://cdn.steemitimages.com/DQmePTe93eaFtkZLpzhC7ke2JEysAMMNL6wLmsRBXQa55cj/anaconda.jpg)\n\n一路next安装，当然安装位置是可以自己选择的，安装完成后，如果你是window用户，按住shift,然后在桌面空白\n\n处点击鼠标右键，然后找到打开DOS窗口（或者叫命令行窗口）。如果找不到，就按住win键+R，在输入框输入\n\ncmd进入win命令行\n\n![命令行.jpg](https://cdn.steemitimages.com/DQmdrWkACj9WoPhSbNnmjeScb2tvFpyAKocZvqdfiipYc9k/%E5%91%BD%E4%BB%A4%E8%A1%8C.jpg)\n\n进入命令行后输入python,如果安装成功就可以看到python的版本，以及python的交互输入>>>\n\n![命令行python.jpg](https://cdn.steemitimages.com/DQmVKK46oyGrjen6GcbDVJ7HnV2z6uepuo45uFuw4iZB3f5/%E5%91%BD%E4%BB%A4%E8%A1%8Cpython.jpg)\n\n\n到此，python算是安装完成。",
      "json_metadata": "{\"tags\":[\"cn\",\"python\",\"blog\"],\"image\":[\"https://cdn.steemitimages.com/DQmePTe93eaFtkZLpzhC7ke2JEysAMMNL6wLmsRBXQa55cj/anaconda.jpg\",\"https://cdn.steemitimages.com/DQmdrWkACj9WoPhSbNnmjeScb2tvFpyAKocZvqdfiipYc9k/%E5%91%BD%E4%BB%A4%E8%A1%8C.jpg\",\"https://cdn.steemitimages.com/DQmVKK46oyGrjen6GcbDVJ7HnV2z6uepuo45uFuw4iZB3f5/%E5%91%BD%E4%BB%A4%E8%A1%8Cpython.jpg\"],\"links\":[\"https://www.anaconda.com/download/\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "645b9bf4ce32325863fd9f52831253b1feee5da0",
  "block": 25663394,
  "trx_in_block": 34,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-09-04T11:18:12",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "cn",
      "author": "hashaki",
      "permlink": "python",
      "title": "python多进程多线程",
      "body": "进程是孤立的，但可以批次通信，成为进程间通信（Interprocess Communication,IPC）。进程间通信最常见形式是基于消息传递，一条消息就是一块原始字节的缓存，然后就可以使用像send()和recv()这样的操作，通过I/O通道（如管道或网络套接字)来传递或接受信息。另一种不太常见的IPC机制依赖于内存映射区域，借助内存映射，进程可以创建共享的内存区域，如果对这些内存区域进行修改，那么查看这些区域的所有进程都能看到这些修改。\n\n在大多数系统上，python同时支持消息传递和基于线程的并发编程。尽管大多数程序员熟悉的往往是线程接口，实际上python线程收到限制很多，python解释器使用了内部GIL(Global Interpreter Lock,全局解释器锁定），在任意指定的时刻只允许单个python线程执行，无论有多少个可用的CPU。\n\n如果要在python中进行各种类型的并行编程，消息传递很可能是必须熟练掌握的概念，即便使用线程，常用的方法也是将应用程序的结构设计为大量独立的线程集合，这些线程通过消息队列交换数据，这种方法极大地减少了对使用锁和其他同步手段的需求，消息传递还会自然扩展到网络和分布式系统中。\n\nmultiprocessing模块\nmultiprocessing模块为在子进程中运行任务，通信和共享数据，以及执行各种形式的同步提供支持。这个编程接口有意模仿threading模块中线程的编程接口，但和线程不同，进程没有任何共享状态。\n\n下面重点描述multiprocessing\nProcess([group [, target [, name [, args [,  [kwargs]]]]])\ntarget为进程启动时执行的可调用对象，args是传递给target位置参数的元组，而kwargs是传递给target的关键字参数的字典。如果省略args和kwargs参数，将不带参数调用target,name是为进程指定描述性名称的字符串，group参数未使用，始终为None。\n\nProcess实例具有以下方法：\np.is_alive()      如果p仍在运行，返回True\n\np.join([timeout])   等待进程p终止，timeout是可选的超时期限，进程可以被连接无数次，但如果连接自身则会出错。\n\np.run()    进程启动时运行的方法，默认情况下，会调用传递给Process构造函数target，定义进程的了另一种方法是从Process类继承并重新实现run()函数。\n\np.start()    启动进程，这将运行代表进程的子进程，并调用该子进程的p.run()函数。\n\np.terminate()    强制终止进程，如果调用此函数，进程p将被立刻终止，同时不会进行任何清理动作，如果进程p创建了它自己的子进程，这些进程将变为僵死进程，使用此方法需要特别小心，如果p保存一个锁定或者通过进程间通信被调用，那么终止它可能会导致死锁或I/O崩溃。\n\nProcess实例具有以下数据属性\np.authkey     进程的身份验证键，除非显式设定这是由os.urandom()函数生成32字符的字符串，这个键的用途是为涉及网络连接的底层进程间通信提供安全性。这类连接只有在两端具有相同的身份验证键时才能成功。\n\np.daemon一个boolean标志，指示进程是否是后台进程。当创建它的python进程终止时，后台(Daemonic)进程将自动终止，另外，禁止后台进程创建自己的新进程。p.daemon的值必须在使用p.start()函数启动之前进行设置。\n\np.exitcode进程的整数退出代码，如果进程仍然在运行，它的值为None，如果值为负数，-N表示进程由信号N所终止。\n\np.name进程的名字\n\np.pid进程的整数进程ID\n\n进程间通信\nmultiprocessing模块支持进程间通信的两种主要形式：管道和队列。这两种方法都是使用消息传递实现的，但队列接口有意模仿线程程序中常见的队列用法。\n\nQueue([maxsize])\n创建共享的进程队列。maxsize是队列中允许的最大项数，如果省略此参数，则无大小限制，底层队列使用管道好锁定实现。另外，还需要运行支持线程以便将队列中的数据传输到底层管道中。\n\nQueue实例具有以下方法：\nq.cancel_join_thread()    不会在进程退出自动连接后台线程。这可以防止join_thread()方法阻塞\n\nq.close()    关闭队列，防止队列中加入更多数据，调用此方法时，后台线程将继续写入那些已入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将自动调用此方法。关闭队列不会在队列使用者中生成任何类型的数据结束信号或异常，例如，如果某个使用者正在被阻塞在get()操作上，关闭生产者中的队列不会导致get()方法返回错误\n\n\nq.empty()    如果调用此方法时q为空，返回True,如果其他进程或线程正在往队列中添加项目，结果是不可靠的，也就是说，在返回和使用结果之间，队列可能已经加入了新的项目。\n\n\nq.full()     如果q已满，返回True，由于线程的存在，结果也可能不可靠\n\n\nq.get([block [, timeout]])    返回q中的一个项目，如果q为空，此方法将阻塞，知道队列中有项目可用为止。block用于控制阻塞行为，默认为True，如果设置为False，将引发Queue.Empty异常（定义在Queue库模块中）。timeout是可选超时间，用于阻塞模式中。如果在指定的时间间隔内没有项目变为可用，将引发Queue.Empty异常。\n\n\nq.get_nowait()    同q.get(False)\n\nq.join_thread()    连接队列的后台线程，此方法用于调用q.close()方法之后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread()方法可以禁止这种行为。\n\n\nq.put(item [,block [, timeout]])     将item放入队列，如果队列已满，此方法将阻塞至有空间可有为止。block控制阻塞行为，默认为True,如果设置为False,将引发Queue.Empty异常（定义在Queue库模块中）。timeout指定在阻塞模式中等待可用空间的时间长短。超时后将引发Queue.Full异常。\n\n\nq.qsize()     返回队列中目前项目的正确数量。此函数的结果并可靠，因为在返回结果和在稍后程序中使用结果之间，队列中可能添加或删除了项目。某些系统上，此方法可能引发NotImplementedError异常。\n\n\nJoinableQueue([maxsize])     创建可连接的共享进程队列，这就是一个Queue对象，但队列允许项目的使用者通知生产者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现。\n\n\n\nq.task_done()     使用者使用此方法发出信号，表示q.get()返回的项目已经被处理。如果调用此方法的次数大于从队列中删除的项目数量，将引发ValueError异常。\n\n\nq.join()       生产者使用此方法进行阻塞，直到队列中的所有项目均被处理。阻塞将持续到为队列中的每一个项目均调用q.task_done()方法为止",
      "json_metadata": "{\"tags\":[\"cn\",\"python\",\"blog\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "2735cf4678dca9edc372ae78e0985b0d5972c84b",
  "block": 25661421,
  "trx_in_block": 23,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-09-04T09:39:33",
  "op": [
    "vote",
    {
      "voter": "steeming-hot",
      "author": "hashaki",
      "permlink": "python",
      "weight": 50
    }
  ]
}

{
  "trx_id": "9685455ccff2b121c2d6177158ea5b0302eb391f",
  "block": 25661403,
  "trx_in_block": 29,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-09-04T09:38:39",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "cn",
      "author": "hashaki",
      "permlink": "python",
      "title": "python多进程多线程",
      "body": "进程是孤立的，但可以批次通信，成为进程间通信（Interprocess Communication,IPC）。进程间通信最常见形式是基于消息传递，一条消息就是一块原始字节的缓存，然后就可以使用像send()和recv()这样的操作，通过I/O通道（如管道或网络套接字)来传递或接受信息。另一种不太常见的IPC机制依赖于内存映射区域，借助内存映射，进程可以创建共享的内存区域，如果对这些内存区域进行修改，那么查看这些区域的所有进程都能看到这些修改。\n\n在大多数系统上，python同时支持消息传递和基于线程的并发编程。尽管大多数程序员熟悉的往往是线程接口，实际上python线程收到限制很多，python解释器使用了内部GIL(Global Interpreter Lock,全局解释器锁定），在任意指定的时刻只允许单个python线程执行，无论有多少个可用的CPU。\n\n如果要在python中进行各种类型的并行编程，消息传递很可能是必须熟练掌握的概念，即便使用线程，常用的方法也是将应用程序的结构设计为大量独立的线程集合，这些线程通过消息队列交换数据，这种方法极大地减少了对使用锁和其他同步手段的需求，消息传递还会自然扩展到网络和分布式系统中。\n\nmultiprocessing模块\nmultiprocessing模块为在子进程中运行任务，通信和共享数据，以及执行各种形式的同步提供支持。这个编程接口有意模仿threading模块中线程的编程接口，但和线程不同，进程没有任何共享状态。\n\n下面重点描述multiprocessing\nProcess([group [, target [, name [, args [,  [kwargs]]]]])\ntarget为进程启动时执行的可调用对象，args是传递给target位置参数的元组，而kwargs是传递给target的关键字参数的字典。如果省略args和kwargs参数，将不带参数调用target,name是为进程指定描述性名称的字符串，group参数未使用，始终为None。\n\nProcess实例具有以下方法：\np.is_alive()      如果p仍在运行，返回True\n\np.join([timeout])   等待进程p终止，timeout是可选的超时期限，进程可以被连接无数次，但如果连接自身则会出错。\n\np.run()    进程启动时运行的方法，默认情况下，会调用传递给Process构造函数target，定义进程的了另一种方法是从Process类继承并重新实现run()函数。\n\np.start()    启动进程，这将运行代表进程的子进程，并调用该子进程的p.run()函数。\n\np.terminate()    强制终止进程，如果调用此函数，进程p将被立刻终止，同时不会进行任何清理动作，如果进程p创建了它自己的子进程，这些进程将变为僵死进程，使用此方法需要特别小心，如果p保存一个锁定或者通过进程间通信被调用，那么终止它可能会导致死锁或I/O崩溃。\n\nProcess实例具有以下数据属性\np.authkey     进程的身份验证键，除非显式设定这是由os.urandom()函数生成32字符的字符串，这个键的用途是为涉及网络连接的底层进程间通信提供安全性。这类连接只有在两端具有相同的身份验证键时才能成功。\n\np.daemon一个boolean标志，指示进程是否是后台进程。当创建它的python进程终止时，后台(Daemonic)进程将自动终止，另外，禁止后台进程创建自己的新进程。p.daemon的值必须在使用p.start()函数启动之前进行设置。\n\np.exitcode进程的整数退出代码，如果进程仍然在运行，它的值为None，如果值为负数，-N表示进程由信号N所终止。\n\np.name进程的名字\n\np.pid进程的整数进程ID",
      "json_metadata": "{\"tags\":[\"cn\",\"python\",\"blog\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "f2e38152c937e7f64cd506925d4b22d891e2d07f",
  "block": 25617870,
  "trx_in_block": 11,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-09-02T21:20:24",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "cn",
      "author": "hashaki",
      "permlink": "2geevx-vnpy",
      "title": "vnpy遇到的问题",
      "body": "1,python相对包导入，ImportError: attempted relative import with no known parent package\n__future__包没什么用的，即使是在同一文件夹下，即使编译器都能识别相关包，但是运行还是报错\n解决方法：用绝对路径，从最顶层一路一层层导入即可，比如导入api里面fcoin的vnfcoin.py里面的class：from api.fcoin.vnfcoin import class\n\n2,在一些文件中有常量的调用，但是却没有加载常量的包，导致变量没有识别，疑惑为什么作者没有调用包，应该不会是py2和py3不同原因吧\n解决方法：直接导入定义常量变量的包\n\n3,有些加载包根本就没有，比如VtLogData,是从trader.vtGateway那里import来的，可是在vtGateway里就没有这个命名，在vtEngine里可以看到VtLogData，VtOrderData的实例化，但是没有找到从哪里import的这个类。\n除了VtLogData之外，还需要在trader.vtGateway实现VtSubscribeReg,VtOrderReg,VtCancelOrderReg。\n解决方法：那些类在vtObject.py里面。。。我真是服了。。。\n\n4，缺少trader.app 的AppEngine的包，该包在ctaStrategy里的ctaEngine.py调用，但是并没有该文件。\n\n5,vnpy把常量命名放在language的text.py和constant.py中，其他地方调用并不直接调用该包，而是通过trader.vtConstant包import text.py和constant.py，vtConstant.py是一个循环读取text.py和constant.py里面的变量并判断是否有违规命名，比如__开头的变量。\n然而在其他程序中调用vtConstant.py，编译器不能加载出text.py和constant.py里的变量。（这个问题和2类似）\n\n6,火币API：AttributeError: 'NoneType' object has no attribute 'send'\nline 566, in sendReq self.ws.send(stream)\n\n7，同样是火币API,py3中for循环内部变量是局部作用于域，在class DataApi的run的expect中stream没有定义的，用py2应该是没问题\n\n8,疑惑：在examples的CoinapiDataService中，是下载币安的k线数据，它自己都没有调用自己的币安API层。。。。\n\n9，币安API函数返回的都是第几个任务数。。。。\n\n10,在vtObject.py中，VtBarData中，成交量和持仓量是int类型，但实际上在数字货币交易中成交量和持仓量为float，因为你可以买0.几个数字货币，类似冻结量也是同样问题。",
      "json_metadata": "{\"tags\":[\"cn\",\"blog\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "d53e050bfc6a0f244722b8e9310ddc8244bab811",
  "block": 25536409,
  "trx_in_block": 2,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-31T01:25:06",
  "op": [
    "vote",
    {
      "voter": "brysj22952",
      "author": "hashaki",
      "permlink": "vnpy",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "a8310943f87b45654d3c45b1e5fdc09ec9401665",
  "block": 25535987,
  "trx_in_block": 6,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-31T01:04:00",
  "op": [
    "vote",
    {
      "voter": "haiyangdeperci",
      "author": "hashaki",
      "permlink": "vnpy",
      "weight": 2000
    }
  ]
}

{
  "trx_id": "0b002eb46b6d7f1859e5fd776ec7860b979b046d",
  "block": 25535408,
  "trx_in_block": 4,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-31T00:35:03",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "cn",
      "author": "hashaki",
      "permlink": "vnpy",
      "title": "vnpy开源量化系统源码初探",
      "body": "Vnpy基本是由py2写的，vnpy正在向py3改，我预计这工程挺大。。。\n为什么还是要求32位的系统。。\n所以我想把vnpy结合到我py3开发的量化机上。\n\nVnpy有很多功能，但实际应用上，我只用某一部分，既然是开源项目，那么我就试着把vnpy个性化。\n\n从阅读vnpy的源码开始。\nVnpy板块分为：api,data,event,pricing,rpc,trader\nVnpy.api接口基本覆盖国内外所有常规交易品种（股票、期货、期权、外汇、外盘、数字货币）\n传统金融：\n•\tCTP（ctp）\n•\t飞马（femas）\n•\t中泰证券XTP（xtp）\n•\t中信证券期权（cshshlp）\n•\t金仕达黄金（ksgold）\n•\t金仕达期权（ksotp）\n•\t飞鼠（sgit）\n•\t飞创（xspeed）\n•\t飞创证券（sec)\n•\tQDP（qdp）\n•\t上海直达期货（shzd）\n•\tInteractive Brokers（ib）\n•\t福汇（fxcm）\n数字货币：\n•\tOKEX（okex)\n•\t火币（huobi)\n•\t币安（binance)\n•\tBitMEX (bitmex)\n•\tBitfinex (bitfinex)\n•\tCoinbase Pro (coinbase)\n•\tFCoin (fcoin)\n•\tBigOne (bigone)\n•\tLBank（lbank）\n•\tCCXT (ccxt)\nVnpy.event为事件驱动型交易程序的核心\nVnpy.rpc是服务端数据推送，用于实现多线程分布式架构的交易系统\nVnpy.trader就是交易平台，vnpy.trader.app中实现以下功能：\n•\t同时登录多个交易接口，在一套界面上监控多种市场的行情和多种资产账户的资金、持仓、委托、成交情况\n•\t支持跨市场套利（CTP期货和XTP证券）、境内外套利（CTP期货和IB外盘）、多市场数据整合实时预测走势（CTP的股指期货数据、IB的外盘A50数据、Wind的行业指数数据）等策略应用\n•\tCtaStrategy，CTA策略引擎模块，在保持易用性的同时，允许用户针对CTA类策略运行过程中委托的报撤行为进行细粒度控制（降低交易滑点、实现高频策略）\n•\tSpreadTrading，价差交易模块，根据用户的配置自动实现价差组合的深度行情以及持仓变化计算，同时内置的交易算法SniperAlgo可以满足大部分到价成交策略的需求，用户也可以基于AlgoTemplate开发更复杂的价差算法\n•\tOptionMaster，期权交易模块，强大的期权投资组合管理功能，结合基于Cython开发的高效期权定价模型，支持毫秒级别的整体希腊值持仓风险计算，用户可以基于期权交易引擎OmEngine快速开发各类复杂期权交易应用\n•\tAlgoTrading，算法交易模块，提供多种常用的智能交易算法：TWAP、Sniper、BestLimit、Iceberg、Arbitrage等等，支持数据库配置保存、CSV文件加载启动以及RPC跨进程算法交易服务\n•\tRiskManager，前端风控模块，负责在交易系统将任何交易请求发出到柜台前的一系列标准检查操作，支持用户自定义风控规则的扩展\n•\tDataRecorder，实盘行情记录，支持Tick和K线数据的落地，用于策略开发回测以及实盘运行初始化\n•\tRpcService，RPC跨进程调用服务，基于MainEngineProxy组件，用户可以如同开发单一进程应用搬开发多进程架构的复杂交易应用\n•\tRtdService，EXCEL RTD服务组件，通过pyxll模块提供EXCEL表格系统对VnTrader系统内所有数据的访问和功能调用（未完成）\n![traderapp.jpg](https://cdn.steemitimages.com/DQmVhYzhdnWD6zyYPYpz3ckbnA1swgVBA29gvRNDy6L9Cd6/traderapp.jpg)\n\nVnpy.data是数据相关的API接口，用于构建好更新历史行情数据库\n\n\n以官方例子CryptoTrader作为入口去理解vnpy的结构。\n\nCryptoTrader下共三个py文件，run.py，uiCryptoWidget.py，uiCryptoWindow.py\n\n其中uiCryptoWidget.py，uiCryptoWindow.py是UI文件，我比较奇怪为什么vnpy会把功能代码也加进UI代码里，可是pyqt好处就是界面与功能代码分离啊。\n\n也许是pyqt4与pyqt5差别比较大吧，UI我并不是很熟悉。\n\nrun.py是运行入口，main()里面先实例化UI然后创建事件引擎。\n在run.py里import了sys,importlib,platform,vnpy.event,vnpy.trader.vtEngine,vnpy.trader.uiQt,vnpy.trader.gateway,vnpy.trader.app以及自身的UI uiCryptoWindow.py\n![2.jpg](https://cdn.steemitimages.com/DQmaUdNYASFESYr3fnrg4mJEp5XDtNsZQg9ENqRwET12Qb1/2.jpg)\n\nVnpy github说明说，event是事件驱动程序.\n所有的计算机程序都可以大致分为两类：脚本型（单次运行）和连续运行型（直到用户主动退出）。\n脚本型\n脚本型的程序包括最早的批处理文件以及使用Python做交易策略回测等等，这类程序的特点是在用户启动后会按照编程时设计好的步骤一步步运行，所有步骤运行完后自动退出。\n连续运行型\n连续运行型的程序包含了操作系统和绝大部分我们日常使用的软件等等，这类程序启动后会处于一个无限循环中连续运行，直到用户主动退出时才会结束。\n连续运行型程序\n我们要开发的交易系统就是属于连续运行型程序，而这种程序根据其计算逻辑的运行机制不同，又可以粗略的分为时间驱动和事件驱动两种。\n时间驱动\n时间驱动的程序逻辑相对容易设计，简单来说就是让电脑每隔一段时间自动做一些事情。这个事情本身可以很复杂、包括很多步骤，但这些步骤都是线性的，按照顺序一步步执行下来。\n事件驱动\n与时间驱动对应的就是事件驱动的程序：当某个新的事件被推送到程序中时（如API推送新的行情、成交），程序立即调用和这个事件相对应的处理函数进行相关的操作。\nEvent文件夹里只有两个py文件，eventEngine.py,eventType.py\neventType.py是一个常量命名文件，我之前在写回测的时候就想过，如果我的量化机要让别人用，别人要写策略该怎么办，总不能告诉别人我的策略应该写在那个程序文件的哪个函数里，让他们打开IDE还得熟悉我的传入的数据，这个很不现实。\nVnpy的答案就是，先设定好变量，就是说与使用者约定好，比如说：HIGH就是最高价，LOW就是最低价，我们约定好，并写好说明文档告诉使用者什么变量代表什么，这样使用者就不需要熟悉我在程序里写的东西，他们只要按照他们想法去排列我们约定好的变量即可完成策略。\neventType.py就是干上面这些事，在trader\\language\\下有chinese,english里面constant.py,包含了近百个常量定义，eventEngine.py中import的库基本都是标准库(queue,threading,time,collections)，除了标准库还有一个pyqt和eventType。\nEventEngine.py\n定义了三个类，eventEngine,eventEngine2,event以及一个测试函数。eventEngine和eventEngine2两个类用的方法有一点点不一样，先看eventEngine定义了事件驱动引擎，\n![loadCSV.jpg](https://cdn.steemitimages.com/DQmX3tshpazJLzwCFavRyE2puxHbn5so7BSYgYjxG7LovwW/loadCSV.jpg)\n\n![backtrading.jpg](https://cdn.steemitimages.com/DQmdomZYCbXaUDerSYhhAZwBqYcPEExBfqFZ1kyZyPSBvqS/backtrading.jpg)\n\n看看trader里程序，其中vtGlobal.py导入的是get_JsonPath()方法，作用是获取JSON配置文件的路径，就vtGlobal.py而言，她获取的是VT_setting.json的路径，一般你可以在\\vnpy\\trader找到，打开VT_setting.json,可以看到里面包含一些设置，后面会用到。\nVtGlobal.py\n该文件就是将VT_setting.json里面的配置变成python可读取和使用的字典形式，并赋值给globalSetting，将它作为全局配置的字典。\nVtConstant.py\n从constant.py导入了常量，并把它们添加到vtConstant.py的局部字典中。\nVtObject.py\n定义了几种 数据基础类\nvtEvent.py\n基于vnpy.event.eventType并添加更多字段。\nVtGateway.py\n定义了vtGateway类作为交易接口，类方法都是关于事件的推送\n注意到一个细节，以onTick(self,tick)为例，参数tick是不是传入的是类vtTickData的实例。\nVtFunction.py\n包含一些开发中常用的函数，检查接口数据是否正确，获取本机的时间，加载程序图标，获取存放临时文件的路径，获取JSON配置文件路径，加载JSON配置。",
      "json_metadata": "{\"tags\":[\"cn\",\"blog\",\"python\"],\"image\":[\"https://cdn.steemitimages.com/DQmVhYzhdnWD6zyYPYpz3ckbnA1swgVBA29gvRNDy6L9Cd6/traderapp.jpg\",\"https://cdn.steemitimages.com/DQmaUdNYASFESYr3fnrg4mJEp5XDtNsZQg9ENqRwET12Qb1/2.jpg\",\"https://cdn.steemitimages.com/DQmX3tshpazJLzwCFavRyE2puxHbn5so7BSYgYjxG7LovwW/loadCSV.jpg\",\"https://cdn.steemitimages.com/DQmdomZYCbXaUDerSYhhAZwBqYcPEExBfqFZ1kyZyPSBvqS/backtrading.jpg\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "bf1c94cb795e10a2e798af726dbbb8a93bb7978f",
  "block": 25454924,
  "trx_in_block": 56,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-28T05:28:15",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "cn",
      "author": "hashaki",
      "permlink": "python-1-python",
      "title": "高性能python（1）必须知道的python短板",
      "body": "现在电脑一般都是多核，总体计算能力提高，无须等待内存障碍让单个核心可以跑得更快。\n\n但是给CPU增加更多核心并不一定能提升程序运行的速度，阿姆达尔定律认为：如果一个可以运行在多核上的程序有某些执行路径必须运行在单核上，那么这些路径就会成为瓶颈导致最终速度无法通过增加更多核心来提高。\n\n比如，假如东京热要拍年度影片，这个影片需要100个女忧参与，一个女优在影片中出镜时长为3分钟，如果只有一个男优参与该影片并且每次出镜只能有一个女优，不考虑演员身体的折损的理想情况下，东京热要拍完这部影片至少需要100*3分钟，因为女优就像队列一样，男优只有与一名女优合作结束之后才能与下一名女优拍戏，而女优也必须等待前面的女优拍完才能轮到她。\n\n如果东京热有两名男优，那么影片完成时间就可以减少一半，因为两位男优是独立完成工作没有依赖关系。为了继续提速，如果有100名男优，那么影片只需要3分钟就可以完成，也就是单人完成任务的极限时间，如果用超过100人数的男优，效率也不会再增加，只能提高单人的执行效率来提高。\n\n对于CPU也是一样，我们可以增加更多的核心直到某个必须单核执行的任务成为瓶颈，也就是说任何并行计算的瓶颈最终都会落到在其顺序执行的那部分上。\n\n另外，对于python而言，充分利用多核性能的阻碍主要在于python的全局解释器锁(GIL)。GIL确保python进程一次只能执行一条指令，无论当前有多少个核心。这意味着即使某些python代码可以使用多个核心，在任意时间点仅有一个核心在执行python的指令。用东京热的例子来说，有100个女优而只有一个男优，这是一个严重的效率阻碍，特别是在计算机发展拥有更多而非更快的计算单元的时候，因为单个计算单元已经到了物理级限制，也就是晶体管到达物理极限了，也只能通过架构和集群来提高运算速度。\n\n尽管python在这方面有重大阻碍，但也是有解决办法的比如标准库的multiprocessing,numexpr,Cython和分布式模型等。\n\n大多数问题似乎都证明python并不适合解决性能问题，但这不是真的，原因有两点，首先所有这些“高性能要素”中，我们忽略一个至关重要的:开发者。另外，高性能python可以通过各种模块（比如用numpy处理矩阵）和原理来帮助减轻遇到的高性能问题。\n\n理想计算模型和python虚拟机：\n先看一段判断质数的代码：\nimport math\ndef check_prime(number):\n__sqrt_number=math.sqrt(number)\n__number_float=float(number)\n__for i in range(2,int(sqrt_number)+1):\n____if (number_float/i).is_integer():\n______return False\n__return True\n在代码的开头，我们将number的值保存于RAM中。为了计算sqrt_number和number_float，我们需要将该值存入CPU。理想情况下我们只需要传一次，它被保存在CPU的L1/L2缓存中，然后CPU会进行两次计算并将结果传回RAM保存。这是一个理想情况，因为我们令从RAM中读取number的值的次数最少，转而以快很多的L1/L2缓存的读取代替。将数据保持在需要的地方并尽量少移动这一场景对优化来说至关重要。所谓“沉重数据”的概念指的是移动数据需要花费时间，而这就是我们需要避免的。\n\nCPU是支持矢量计算的，且我们也不需要上面代码返回的所有数据，我们只需要一个结果，我们可以让程序一次对多个i值进行除法而不是对每一个i进行独立操作。\n\npython虚拟机：\npython解释器为了抽离底层用到的计算元素做了很多工作。让编程人员无须考虑如何分配内存，如何组织内存以及用什么样的顺序将内存传入CPU，这是python的优势，让你能够集中在算法的实现上，然而它有个巨大的性能代价。\n\n举两个例子：\ndef search_fast(haystack,needle):\n__for item in haystack:\n____if item==needle:\n______return True\n__return False\n\ndef search_slow(haystack,needle):\n__return_value=False\n__for item in haystack:\n____if item==needle:\n______return_value= True\n__return return_value\n\n虽然上面都是复杂度相同的程序，但是执行效率不一样的，因为search_fast版本提前结束了循环，减少不必要的计算。\n\nPython虚拟机抽象层的影响之一就是矢量操作变得不是直接可用了。我们最初的质数函数会循环遍历i的每一个值而不是将多次遍历组合成一个矢量操作。而我们抽象以后的矢量代码并不是合法的python代码，因为我们不能用一个列表去除一个浮点，不过我们有numpy这样的外部库可以通过增加矢量化的数学操作。\n\n另外，python抽象还影响了任何需要为下一次计算保存L1/L2缓存中的相关数据的优化。这有很多原因，首先是python对象不再是内存中最优化的布局。这是因为python是一种垃圾收集语言，内存会被自动分配并在需要的时候释放，这会导致内存碎片并影响向CPU缓存传输。另外我们也没有机会去直接改变数据结构在内存的布局，这就意味着就算信息少于总线带宽，总线上的一次传输可能并不包含一次计算的所有相关信息。\n\n还有一个问题更基本：\npython并不是一种编译性的语言而且还是动态的，这就是说任何算法上可能的优化机会都会更难实现，因为代码有可能在运行时被改变，解决这个问题主要还是用Cython。",
      "json_metadata": "{\"tags\":[\"cn\",\"blog\",\"python\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "155f87f855be4aab13bcd1a319ab091235fcfcaa",
  "block": 25449572,
  "trx_in_block": 24,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-28T01:00:06",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "blog",
      "author": "hashaki",
      "permlink": "sql-mysql",
      "title": "在SQL上操作MySQL基本操作",
      "body": "@@ -174,17 +174,17 @@\n ate date\n-.\n+,\n sal deci\n",
      "json_metadata": "{\"tags\":[\"blog\",\"cn\",\"mysql\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\",\"image\":[\"https://cdn.steemitimages.com/DQmZcKcfirRitqYoAyLhNzunkUQQxXrSZsAyMeuEnfrhQmA/2.jpg\",\"https://cdn.steemitimages.com/DQmQ8NFCwjgw3GCYJtErM8PtQidXxT7frmwT8VciG6x1pu2/3.jpg\",\"https://cdn.steemitimages.com/DQmZHLuGvGLZyesRPuXHksJNVXHHEsLRsa7qjpn2Cif2J8Z/4.jpg\",\"https://cdn.steemitimages.com/DQmSQXTwWucSJLSyghgef65AUP3m5gnLkgHuCAVA1GFnK26/2.jpg\"]}"
    }
  ]
}

{
  "trx_id": "34e76af657a470191065ecf2f5a6c5811068977e",
  "block": 25449449,
  "trx_in_block": 21,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-28T00:53:54",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "blog",
      "author": "hashaki",
      "permlink": "sql-mysql",
      "title": "在SQL上操作MySQL基本操作",
      "body": "@@ -46,16 +46,17 @@\n database\n+s\n ;%0A%0A%E5%89%8D%E5%BE%80%E6%9F%90%E4%B8%AA%E6%95%B0\n",
      "json_metadata": "{\"tags\":[\"blog\",\"cn\",\"mysql\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\",\"image\":[\"https://cdn.steemitimages.com/DQmZcKcfirRitqYoAyLhNzunkUQQxXrSZsAyMeuEnfrhQmA/2.jpg\",\"https://cdn.steemitimages.com/DQmQ8NFCwjgw3GCYJtErM8PtQidXxT7frmwT8VciG6x1pu2/3.jpg\",\"https://cdn.steemitimages.com/DQmZHLuGvGLZyesRPuXHksJNVXHHEsLRsa7qjpn2Cif2J8Z/4.jpg\",\"https://cdn.steemitimages.com/DQmSQXTwWucSJLSyghgef65AUP3m5gnLkgHuCAVA1GFnK26/2.jpg\"]}"
    }
  ]
}

{
  "trx_id": "df47237f66dcaa78efb136d3778f3cffcd7e509a",
  "block": 25395264,
  "trx_in_block": 12,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-26T03:44:21",
  "op": [
    "vote",
    {
      "voter": "holmesian",
      "author": "hashaki",
      "permlink": "sql-mysql",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "4fe554b09422ce19bc14f40117097eb99397e438",
  "block": 25392705,
  "trx_in_block": 9,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-26T01:36:15",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "blog",
      "author": "hashaki",
      "permlink": "sql-mysql",
      "title": "在SQL上操作MySQL基本操作",
      "body": "@@ -688,16 +688,1180 @@\n e ypl;%0A%0A\n+%E4%BF%AE%E6%94%B9%E5%AD%97%E6%AE%B5%E5%8F%98%E9%87%8F%EF%BC%9Ainsert into JJ(YPL,jj,somedate,deptbo,age) values('2009-01-20',810,'2018-08-26',1,24);%0A                                :insert into JJ values('1994-08-10',520,'1994-08-14',13,14);             %E8%BF%99%E6%98%AF%E7%AE%80%E4%BE%BF%E5%BD%A2%E5%BC%8F,%E4%BD%86%E5%8F%82%E6%95%B0%E8%A6%81%E5%AF%B9%E9%BD%90%0A                                :insert into JJ(deptbo,age) values(666,777);%0A%0A!%5B2.jpg%5D(https://cdn.steemitimages.com/DQmZcKcfirRitqYoAyLhNzunkUQQxXrSZsAyMeuEnfrhQmA/2.jpg)%0A%0A!%5B3.jpg%5D(https://cdn.steemitimages.com/DQmQ8NFCwjgw3GCYJtErM8PtQidXxT7frmwT8VciG6x1pu2/3.jpg)%0A%0A!%5B4.jpg%5D(https://cdn.steemitimages.com/DQmZHLuGvGLZyesRPuXHksJNVXHHEsLRsa7qjpn2Cif2J8Z/4.jpg)%0A%0A%E6%9B%B4%E6%96%B0%E6%95%B0%E6%8D%AE:update JJ set deptbo=24 where YPL='2009-01-20';%0A!%5B2.jpg%5D(https://cdn.steemitimages.com/DQmSQXTwWucSJLSyghgef65AUP3m5gnLkgHuCAVA1GFnK26/2.jpg)%0A%0A%E6%9F%A5%E8%AF%A2%EF%BC%9Aselect * from JJ    *%E8%A1%A8%E7%A4%BA%E6%98%BE%E7%A4%BA%E6%89%80%E6%9C%89%E6%95%B0%E6%8D%AE%EF%BC%8C%E4%BD%86%E6%98%AF%E8%A6%81%E6%9F%A5%E8%AF%A2%E6%9F%90%E9%83%A8%E5%88%86%E5%AD%97%E6%AE%B5%E5%B0%B1%E8%A6%81%E5%88%97%E5%90%8D%E5%AD%97%E5%87%BA%E6%9D%A5%0A%0A%E6%9F%A5%E8%AF%A2%E6%9F%90%E9%83%A8%E5%88%86%EF%BC%9Aselect YPL,age from JJ;%0A%0A%E5%B8%A6%E6%9D%A1%E4%BB%B6%E6%9F%A5%E8%AF%A2%EF%BC%9Aselect YPL,age from JJ where jj=520;%0A                           :select YPL,age from JJ where jj=520 and deptbo%3C20;%0A%0A%E6%8E%92%E5%BA%8F%EF%BC%9Aselect * from JJ order by jj;          %E5%8D%87%E5%BA%8F%E6%8E%92%E5%BA%8F%0A %0A%E9%99%90%E5%88%B6%EF%BC%9Aselect * from JJ order by jj limit 2;            %E5%8F%AA%E5%87%BA%E7%8E%B0%E5%89%8D2%E4%B8%AA%E6%95%B0%E6%8D%AE%0A            : select * from JJ order by jj limit 1,3;                  %E4%BB%8E%E7%AC%AC%E4%BA%8C%E6%9D%A1%E6%95%B0%E6%8D%AE%E5%BC%80%E5%A7%8B%EF%BC%8C%E5%8F%AA%E6%98%BE%E7%A4%BA3%E6%9D%A1%E6%95%B0%E6%8D%AE%0A%0A%E5%88%A0%E9%99%A4%E8%AE%B0%E5%BD%95%EF%BC%9Adelete from JJ where age=777;%0A\n %0A%E5%88%A0%E9%99%A4%E8%A1%A8%E4%B8%AD%E5%AD%97%E6%AE%B5%EF%BC%9A\n",
      "json_metadata": "{\"tags\":[\"blog\",\"cn\",\"mysql\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\",\"image\":[\"https://cdn.steemitimages.com/DQmZcKcfirRitqYoAyLhNzunkUQQxXrSZsAyMeuEnfrhQmA/2.jpg\",\"https://cdn.steemitimages.com/DQmQ8NFCwjgw3GCYJtErM8PtQidXxT7frmwT8VciG6x1pu2/3.jpg\",\"https://cdn.steemitimages.com/DQmZHLuGvGLZyesRPuXHksJNVXHHEsLRsa7qjpn2Cif2J8Z/4.jpg\",\"https://cdn.steemitimages.com/DQmSQXTwWucSJLSyghgef65AUP3m5gnLkgHuCAVA1GFnK26/2.jpg\"]}"
    }
  ]
}

{
  "trx_id": "1363f23340dbec1056103e556d306afbf6eb02c7",
  "block": 25391024,
  "trx_in_block": 19,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-26T00:12:09",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "blog",
      "author": "hashaki",
      "permlink": "sql-mysql",
      "title": "在SQL上操作MySQL基本操作",
      "body": "创建一个数据库：create database hashaki;\n\n显示数据库：show database;\n\n前往某个数据库：use hashaki;\n\n显示该数据库下的表：show tables;\n\nJJU是名字，somedate是日期，sal是数据\n\n创建一个表：create table JJ(JJU varchar(10),somedate date.sal decimal(10,2),deptbo int(2));\n\n显示表：desc JJ;\n\n查看更多的表信息：show create table JJ;   或者：show create table JJ \\G(这个排版会好看点）\n\n修改表，比如修改JJ的JJU的varchar(10)->varchar(20):alter table JJ modify JJU varchar(20);\n\n表中增加字段age：alter table JJ add column age int(3);\n\n字段改名：alter table JJ change JJU jj int(4);                  JJU是JJ里面的一个varchar(20)类型，名字改成jj类型改成int(4)\n\n插入字段到某个字段后：alter table JJ add YPL date after jj;           YPL是新创建的字段，放在字段jj的后面\n\n把某个字段放在第一位：alter table JJ modify YPL date first;\n\n表改名：alter table JJ rename ypl;\n\n\n删除表中字段：alter table JJ drop column age;\n\n删除数据库：drop database name;\n\n删除表：drop table name;",
      "json_metadata": "{\"tags\":[\"blog\",\"cn\",\"mysql\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "77a2656318a20ea915a09ba5aa13b4fc1cc6c050",
  "block": 25389886,
  "trx_in_block": 17,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-25T23:15:12",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "blog",
      "author": "hashaki",
      "permlink": "python-mysql",
      "title": "python 操作MySQL",
      "body": "# build in python3.5.2\n# create a database and create a table in python\nimport pymysql\n\n# connect the database\n# the argvs based on the database you set.\n# Generally speaking, you should change the No. of the port 3306 , because it's easy to be  attack\n# localhost = 127.0.0.1\nconn = pymysql.connect(host='localhost', port=3306, user='root', passwd='231495877')\ncurs = conn.cursor()\n\n# create a database named hashaki\n# Ensure the program can run multiple times,we should use try...exception\ntry:\n    curs.execute('create database hashaki')\nexcept:\n    print('Database hashaki exists!')\nconn.select_db('hashaki')\n# create a table named hashakifields\ntry:\n    curs.execute('create table hashakifields(id int PRIMARY KEY NOT NULL,name text)')\nexcept:\n    print('The table hashakifields exists!')\n\nsql = \"\"\"INSERT INTO EMPLOYEE(FIRST_NAME,\n         LAST_NAME, AGE, SEX, INCOME)\n         VALUES ('Mac', 'Mohan', 20, 'M', 2000)\"\"\"\n\ntry:\n   # 执行sql语句\n   curs.execute(sql)\n   # 提交到数据库执行\n   conn.commit()\nexcept:\n   # 如果发生错误则回滚\n   conn.rollback()\n\nconn.commit()\ncurs.close()\nconn.close()",
      "json_metadata": "{\"tags\":[\"blog\",\"cn\",\"python\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "38e0bf323272a0d97b3db267d4ad38d8746cc1ff",
  "block": 25370861,
  "trx_in_block": 9,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-25T07:23:42",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "blog",
      "author": "hashaki",
      "permlink": "k-nearest-neighbors-in-python-from-scratch",
      "title": "k-Nearest Neighbors in Python From Scratch",
      "body": "@@ -735,16 +735,17 @@\n  too hun\n+g\n ry to in\n",
      "json_metadata": "{\"tags\":[\"blog\",\"python\",\"cn\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "6b3a919d6da2a26d08dd3f717ba4e944af965b41",
  "block": 25353346,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-24T16:46:42",
  "op": [
    "comment",
    {
      "parent_author": "hashaki",
      "parent_permlink": "re-kamada3-77ncsm-20180823t012712211z",
      "author": "kamada3",
      "permlink": "re-hashaki-re-kamada3-77ncsm-20180824t164641040z",
      "title": "",
      "body": "No. I'm still trading manually.",
      "json_metadata": "{\"tags\":[\"japanese\"],\"app\":\"steemit/0.1\"}"
    }
  ]
}

{
  "trx_id": "fc08305583127021d266a9b5ce3bbd6721d89547",
  "block": 25350438,
  "trx_in_block": 44,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-24T14:21:15",
  "op": [
    "comment",
    {
      "parent_author": "hashaki",
      "parent_permlink": "re-littlexiannv-steemit-blogger-20180824t074631125z",
      "author": "ericet",
      "permlink": "re-hashaki-re-littlexiannv-steemit-blogger-20180824t142116707z",
      "title": "",
      "body": "busy.org有收藏，可以试试",
      "json_metadata": "{\"community\":\"busy\",\"app\":\"busy/2.5.6\",\"format\":\"markdown\",\"tags\":[\"cn\"],\"users\":[],\"links\":[],\"image\":[]}"
    }
  ]
}

{
  "trx_id": "1225d5a107a1278798492f62e131929fd4212c51",
  "block": 25348497,
  "trx_in_block": 46,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-24T12:44:09",
  "op": [
    "comment",
    {
      "parent_author": "hashaki",
      "parent_permlink": "k-nearest-neighbors-in-python-from-scratch",
      "author": "steemitboard",
      "permlink": "steemitboard-notify-hashaki-20180824t124411000z",
      "title": "",
      "body": "Congratulations @hashaki! You have completed the following achievement on Steemit and have been rewarded with new badge(s) :\n\n[![](https://steemitimages.com/70x80/http://steemitboard.com/notifications/posts.png)](http://steemitboard.com/@hashaki) Award for the number of posts published\n\n<sub>_Click on the badge to view your Board of Honor._</sub>\n<sub>_If you no longer want to receive notifications, reply to this comment with the word_ `STOP`</sub>\n\n\n\n**Do not miss the last post from @steemitboard:**\n[SteemitBoard and the Veterans on Steemit - The First Community Badge.](https://steemit.com/veterans/@steemitboard/steemitboard-and-the-veterans-on-steemit-the-first-community-badge)\n\n> Do you like [SteemitBoard's project](https://steemit.com/@steemitboard)? Then **[Vote for its witness](https://v2.steemconnect.com/sign/account-witness-vote?witness=steemitboard&approve=1)** and **get one more award**!",
      "json_metadata": "{\"image\":[\"https://steemitboard.com/img/notify.png\"]}"
    }
  ]
}

{
  "trx_id": "2c7d09168bd8b808a976de984d1e39629de10fa2",
  "block": 25342554,
  "trx_in_block": 23,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-24T07:46:48",
  "op": [
    "comment",
    {
      "parent_author": "littlexiannv",
      "parent_permlink": "steemit-blogger",
      "author": "hashaki",
      "permlink": "re-littlexiannv-steemit-blogger-20180824t074631125z",
      "title": "",
      "body": "。。。。steem没有收藏功能，不过mardown这个好找",
      "json_metadata": "{\"tags\":[\"cn\"],\"app\":\"steemit/0.1\"}"
    }
  ]
}

{
  "trx_id": "1765726d968e22dcaf21243561b2a1d7d573d7dd",
  "block": 25341638,
  "trx_in_block": 29,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-24T07:00:57",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "blog",
      "author": "hashaki",
      "permlink": "k-nearest-neighbors-in-python-from-scratch",
      "title": "k-Nearest Neighbors in Python From Scratch",
      "body": "What is k-Nearest Neighbors\n\nThe model for kNN is the entire training dataset. When a prediction is required for a unseen data instance, the kNN algorithm will search through the training dataset for the k-most similar instances. The prediction attribute of the most similar instances is summarized and returned as the prediction for the unseen instance.\n\nThe similarity measure is dependent on the type of data. For real-valued data, the Euclidean distance can be used. Other other types of data such as categorical or binary data, Hamming distance can be used.\n\nIn the case of regression problems, the average of the predicted attribute may be returned. In the case of classification, the most prevalent class may be returned.\n\nI am too hunry to introduce more.I have to go out to find some food: )\nAll code here:\n\nimport math\nimport operator as op\n\na=[1,2,3,3,2,1,'a']\nb=[7,8,9,9,8,7,'b']\nc=[1,1,1,1,1,1]\n# 平方差,计算出两个样本之间的距离\ndef euclieanDistance(instance1,instance2,lengh):\n    distance=0\n    for i in range(lengh):\n        distance+=pow(instance1[i]-instance2[i],2)\n    return math.sqrt(distance)\n\n# 根据距离，找到最近的那堆数据\ndef getNeighbors(trainSet,testInstance,k):\n    distance=[]\n    lengh=len(testInstance)            # 减去label项\n    for i in range(len(trainSet)):\n        dist=euclieanDistance(testInstance,trainSet[i],lengh)\n        distance.append((trainSet[i],dist))\n    distance.sort(key=op.itemgetter(1))    # 按照第二个选项排序 ，从小到大\n    neighbor=[]\n    for j in range(k):\n        neighbor.append(distance[j][0])\n    return neighbor\n\n# 查看最近的数据是哪个标签，靠近的标签排序\ndef getResponse(neighbor):\n    classVote={}\n    for i in range(len(neighbor)):\n        response=neighbor[i][-1]         # 把label选出来,所以response是标签\n        if response in classVote:\n            classVote[response]+=1\n        else:\n            classVote[response]=1\n    sortVote=sorted(classVote.items(),key=op.itemgetter(1),reverse=True)  # 排序数量最多的那个标签,但为什么要反转？\n    return sortVote[0][0]\n\n# 求准确度，相当于预测\ndef getAccuracy(testSet,predictions):\n    correct=0\n    for i in range(len(testSet)):\n        if testSet[i][-1] is predictions[i]:\n            correct+=1\n    return (correct/float(len(testSet)))*100.0\n\n\nif __name__=='__main__':\n    predictions=[]\n    neighbor=getNeighbors([a,b],c,2)\n    print('neighbor',neighbor)\n    response=getResponse(neighbor)\n    print('response',response)\n    predictions.append(response)\n    print('predictions',predictions)\n    print(getAccuracy([[6,6,6,6,6,6,'b']],predictions))\n\n\noutput:\nneighbor [[1, 2, 3, 3, 2, 1, 'a'], [7, 8, 9, 9, 8, 7, 'b']]\nresponse a\npredictions ['a']\n0.0",
      "json_metadata": "{\"tags\":[\"blog\",\"python\",\"cn\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "5d464ae308160a5ab8f073ce2e1e6c931f72a3f9",
  "block": 25318742,
  "trx_in_block": 27,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-23T11:55:09",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "blog",
      "author": "hashaki",
      "permlink": "simple-linear-regression-from-scratch-with-python",
      "title": "Simple Linear Regression From Scratch With Python",
      "body": "In this case,we just use stander python math lib to implement linear reg.\n\nFirst,The line for a simple linear regression model can be written as:\n\ny=b1*x+b0\n\n1,calculate the mean and variance（均值与方差）：\n\nmean=lambda value:sum(value)/int(len(value))\n\nvariance=lambda value,mean:sum([(x-mean)**2 for x in value])\n\n2. Calculate Covariance（协方差）：\n\ndef covariance(x,mean_x,y,mean_y):\n    covar=0.0\n    for i in range(len(x)):\n        covar+=(x[i]-mean_x)*(y[i]-mean_y)\n        return covar\n\n3,make prediction:\nThe simple linear regression model is a line defined by coefficients estimated from training data.\n\n# 预测\ndef prediction(train,test):\n    predictions=[]\n    b0,b1=coeffients(train)\n    for row in test:\n        yhat=b0+b1*row[0]\n        predictions.append(yhat)\n    return predictions\n\nFinal,calculate root mean square error and evaluate:\n\n# 计算平方根误差\ndef root_mean_square_error(actual,predicted):\n    sum_error=0.0\n    for i in range(len(actual)):\n        prediction_error=predicted[i]-actual[i]\n        sum_error+=(prediction_error**2)\n    mean_error=sum_error/float(len(actual))\n    return math.sqrt(mean_error)\n\n# 评估训练集上的回归算法\ndef evaluate_algorithm(dataset,algorithm):\n    test_set=[]\n    for row in dataset:\n        row_copy=list(row)\n        row_copy[-1]=None\n        test_set.append(row_copy)\n    predicted=algorithm(dataset,test_set)\n    print(predicted)\n    actual=[row[-1] for row in dataset]\n    error=root_mean_square_error(actual,predicted)\n    return error\n\n\nAll code are here:\n\n\nimport math\nimport matplotlib.pyplot as plt\ndata={'X':[108,19,13,124,40,57,23,14,45,10,5,48,11,23,7,2,24,6,3,23,6,9,9,3,29,7,4,20,7,4,0,25,6,5,22,11,61,12,4,16,13,60,41,37,55,41,11,27,8,3,17,13,13,15,8,29,30,24,9,31,14,53,26]\n      ,'Y':[392.5,46.2,15.7,422.2,119.4,170.9,56.9,77.5,214,65.3,20.9,248.1,23.5,39.6,48.8,6.6,134.9,50.9,4.4,113,14.8,48.7,52.1,13.2,103.9,77.5,11.8,98.1,27.9,38.1,0,69.2,14.6,40.3,161.5,57.2,217.6,58.1,12.6,59.6,89.9,202.4,181.3,152.8,162.8,73.4,21.3,92.6,76.1,39.9,142.1,93,31.9,32.1,55.6,133.3,194.5,137.9,87.4,209.8,95.5,244.6,187.5]}\n\n# 求均值和方差\nmean=lambda value:sum(value)/int(len(value))\nvariance=lambda value,mean:sum([(x-mean)**2 for x in value])\n\n# 协方差\ndef covariance(x,mean_x,y,mean_y):\n    covar=0.0\n    for i in range(len(x)):\n        covar+=(x[i]-mean_x)*(y[i]-mean_y)\n        return covar\n\n# 计算系数\ndef coeffients(dataset):\n    x=[row[0] for row in dataset]\n    y=[col[1] for col in dataset]\n    x_mean,y_mean=mean(x),mean(y)\n    b1=covariance(x,x_mean,y,y_mean)/variance(x,x_mean)\n    b0=y_mean-b1*x_mean\n    return [b0,b1]\n\n# 预测\ndef prediction(train,test):\n    predictions=[]\n    b0,b1=coeffients(train)\n    for row in test:\n        yhat=b0+b1*row[0]\n        predictions.append(yhat)\n    return predictions\n\n# 计算平方根误差\ndef root_mean_square_error(actual,predicted):\n    sum_error=0.0\n    for i in range(len(actual)):\n        prediction_error=predicted[i]-actual[i]\n        sum_error+=(prediction_error**2)\n    mean_error=sum_error/float(len(actual))\n    return math.sqrt(mean_error)\n\n# 评估训练集上的回归算法\ndef evaluate_algorithm(dataset,algorithm):\n    test_set=[]\n    for row in dataset:\n        row_copy=list(row)\n        row_copy[-1]=None\n        test_set.append(row_copy)\n    predicted=algorithm(dataset,test_set)\n    print(predicted)\n    actual=[row[-1] for row in dataset]\n    error=root_mean_square_error(actual,predicted)\n    return error\n\nresult=evaluate_algorithm([data['X'],data['Y']],prediction)\nprint(result)\nplt.scatter(data['X'],data['Y'],color='orange')\nplt.show()\n![2.jpg](https://cdn.steemitimages.com/DQmNPVHYF4KRBjvCyijfbZbgsR5NgAMEBF4yqYrdvTESjkf/2.jpg)",
      "json_metadata": "{\"tags\":[\"blog\",\"python\",\"cn\"],\"image\":[\"https://cdn.steemitimages.com/DQmNPVHYF4KRBjvCyijfbZbgsR5NgAMEBF4yqYrdvTESjkf/2.jpg\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "e885a95cf1b49abdb7bdc592581186daad215533",
  "block": 25315233,
  "trx_in_block": 20,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-23T08:59:33",
  "op": [
    "vote",
    {
      "voter": "littlexiannv",
      "author": "hashaki",
      "permlink": "pandas-crash-course",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "2315ce5676f70d41fad20c1e23b3a94abe2abd39",
  "block": 25315067,
  "trx_in_block": 26,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-23T08:51:15",
  "op": [
    "vote",
    {
      "voter": "flowering-cycas",
      "author": "hashaki",
      "permlink": "pandas-crash-course",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "9cfbeecb8f97483299f039fa916065b3379cbb70",
  "block": 25312534,
  "trx_in_block": 4,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-23T06:44:33",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "blog",
      "author": "hashaki",
      "permlink": "pandas-crash-course",
      "title": "Pandas Crash Course",
      "body": "Pandas provides data structures and functionality to quickly manipulate and analyze data. The key to understanding Pandas for machine learning is understanding the Series and DataFrame data structures.\nSeries\n\nA series is a one-dimensional array where the rows and columns can be labeled.\n\nimport numpy as np\nimport pandas as pd\n_array=np.array([1,2,3])\nrow_name=['a','b','c']\n_series=pd.Series(_array,row_name)\nprint(_series)\n![2.jpg](https://cdn.steemitimages.com/DQmamYMmwt3ZTUEmEu1ixCre8ZAGebDYNNYm6LcWXPgXULA/2.jpg)\n\nDataFrame\n\nA data frame is a multi-dimensional array where the rows and the columns can be labeled.\n\nimport numpy as np\nimport pandas as pd\n_array=np.array([[1,2,3],[4,5,6]])\nrow_name=['a','b']\ncol_name=['1','2','3']\ndf=pd.DataFrame(_array,index=row_name,columns=col_name)\nprint(df)\n![3.jpg](https://cdn.steemitimages.com/DQmT7bxueKJ1vsHSHyhDwABNZmo1EzkSrpMwuUUCJhSXAZu/3.jpg)",
      "json_metadata": "{\"tags\":[\"blog\",\"python\",\"cn\"],\"image\":[\"https://cdn.steemitimages.com/DQmamYMmwt3ZTUEmEu1ixCre8ZAGebDYNNYm6LcWXPgXULA/2.jpg\",\"https://cdn.steemitimages.com/DQmT7bxueKJ1vsHSHyhDwABNZmo1EzkSrpMwuUUCJhSXAZu/3.jpg\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "9adfd359446ef2543545c4e0d1a8df54718ce531",
  "block": 25310268,
  "trx_in_block": 18,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-23T04:51:15",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "python",
      "author": "hashaki",
      "permlink": "data-visual-by-python-matplotlib",
      "title": "Data Visual by python matplotlib",
      "body": "1,Line Plot\nimport matplotlib.pyplot as plt\n\nx=[1,3,5,7,8,7,6,5,2,4]             # that two are data\ny=[1,2,3,4,5,6,7,8,9,10]\n\nplt.plot(y,x,color='orange',label='line-plot')      # this function is drawing the line\nplt.show()\n![2.jpg](https://cdn.steemitimages.com/DQmYqgR2Eik1bH6xCafETWDQH2fHMchyLsdJtMR2kScoqox/2.jpg)\n\n2,bar chart\nimport matplotlib.pyplot as plt\n\nx=[1,3,5,7,8,7,6,5,2,4]\ny=[1,2,3,4,5,6,7,8,9,10]\n\nplt.bar(y,x)                    # draw the bar\nplt.show()\n![3.jpg](https://cdn.steemitimages.com/DQmeQzB98mkDf1GBjWyFZ1cb1H2v3P1iZpjcCGH5X26mnsd/3.jpg)\n\n3,Histogram Plot\n\nimport numpy as np                        # for making random number\nimport matplotlib.pyplot as plt\n\nhist=np.random.randn(100)\nplt.hist(hist)\nplt.show()\n![4.jpg](https://cdn.steemitimages.com/DQmSFDjvhVvEpbpucDKQ6fB8ceGLfkmT9aAjgzjdRP86hWm/4.jpg)\n\n4,box plot\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nx=[1,3,5,7,8,7,6,5,2,4]\ny=[1,2,3,4,5,6,7,8,9,10]\nhist=np.random.randn(100)\nplt.boxplot([y,x,hist])\nplt.show()\n![5.jpg](https://cdn.steemitimages.com/DQmWmPPDsskFGdsWj5ECNkuAKBGHvSkDrgowqhnWt28roWy/5.jpg)\n\n5scatter\nimport matplotlib.pyplot as plt\nx=[1,3,5,7,8,7,6,5,2,4]\ny=[1,2,3,4,5,6,7,8,9,10]\n\nplt.scatter(y,x)\nplt.show()\n![6.jpg](https://cdn.steemitimages.com/DQmQPYkXmiXobs6xRCnqS5guLyrU2Skfe3SRMd9Y8eYucXb/6.jpg)",
      "json_metadata": "{\"tags\":[\"python\",\"cn\",\"techni\",\"data\"],\"image\":[\"https://cdn.steemitimages.com/DQmYqgR2Eik1bH6xCafETWDQH2fHMchyLsdJtMR2kScoqox/2.jpg\",\"https://cdn.steemitimages.com/DQmeQzB98mkDf1GBjWyFZ1cb1H2v3P1iZpjcCGH5X26mnsd/3.jpg\",\"https://cdn.steemitimages.com/DQmSFDjvhVvEpbpucDKQ6fB8ceGLfkmT9aAjgzjdRP86hWm/4.jpg\",\"https://cdn.steemitimages.com/DQmWmPPDsskFGdsWj5ECNkuAKBGHvSkDrgowqhnWt28roWy/5.jpg\",\"https://cdn.steemitimages.com/DQmQPYkXmiXobs6xRCnqS5guLyrU2Skfe3SRMd9Y8eYucXb/6.jpg\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "5b6a33d83a415d8133159fa15daccda686126e20",
  "block": 25306193,
  "trx_in_block": 25,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-23T01:27:27",
  "op": [
    "comment",
    {
      "parent_author": "kamada3",
      "parent_permlink": "77ncsm",
      "author": "hashaki",
      "permlink": "re-kamada3-77ncsm-20180823t012712211z",
      "title": "",
      "body": "U are quanter?",
      "json_metadata": "{\"tags\":[\"japanese\"],\"app\":\"steemit/0.1\"}"
    }
  ]
}

{
  "trx_id": "6fe1fc021168e1fec3d14b2d1c00a4ad5e79887d",
  "block": 25306186,
  "trx_in_block": 17,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-23T01:27:06",
  "op": [
    "vote",
    {
      "voter": "tropius747",
      "author": "hashaki",
      "permlink": "ng59k",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "1890846334b1b66e8eeb2075141db324c043d5b3",
  "block": 25306158,
  "trx_in_block": 15,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-23T01:25:42",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "python",
      "author": "hashaki",
      "permlink": "ng59k",
      "title": "回测系统编写",
      "body": "想做一个回测系统，一开始选择了开源回测项目backtreader\n这个回测系统确实是很厉害，但对我而言，它是一个未知的框架，我不可能把一个不熟悉的框架放进我的量化系统中。\n于是我开始写，我自己的回测系统\n回测系统共有4个部分：\n1）数据源导入\n2）数据流进策略\n3）策略给出买卖信号(signal)\n4）run\n\n好的，现在开始干活：\n'''\n# build in python3.5.2\n# author hashaki\n# 回测\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# 回测\nclass Strategy:\n    def __init__(self,time,volume,high,low,open=None,close=None):\n        self.time=np.asarray(time)\n        self.volume=volume\n        self.high=high\n        self.low=low\n        self.open=open\n        self.close=close\n\n    # 设置金额\n    def set_money(self,money):\n        self.primiryMoney=money\n        if money==0 or money<0:\n            print( 'wrong input --hashaki')\n\n    # 策略主体\n    def strategy(self):\n        pass\n\n    # 风险过滤\n    def risk_control(self):\n        pass\n\n    def test_buy(self,precent):\n        print(\"Are U sure?\")\n\n    def test_sell(self,precent):\n        print(\"Are U Sure?\")\n\n    def buy(self):\n        print(\"that s real buy\")\n\n    def sell(self):\n        print(\"that s real sell\")\n\n    def run(self):\n        pass\n\n    def plot(self):\n        plt.subplot(2,1,1)\n        plt.plot(self.time,self.volume,color='pink',label='volume')\n        plt.legend()\n        plt.title(\"BackTrade\")\n        plt.show()\n\n    # 传进交易深度\n    def depth(self,buy,sell,depthNum):\n        pass\n'''",
      "json_metadata": "{\"tags\":[\"python\",\"cn\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "cb78ef16900730878dd9e0b154f74b61ecaa646a",
  "block": 25278115,
  "trx_in_block": 14,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-22T02:03:09",
  "op": [
    "account_update",
    {
      "account": "hashaki",
      "memo_key": "STM6bgAnm92EacLfAFVeYotcA7xhJXhA74MYUAEcTh31Vp9XUaNQw",
      "json_metadata": "{\"profile\":{\"profile_image\":\"https://qn-qn-echo-image-cdn.app-echo.com/FlBEj_XjBdsWGdXE1FJJ2kbDWPCD?imageMogr2/auto-orient/quality/100%7CimageView2/0/w/500/q/100\",\"cover_image\":\"https://qn-qn-echo-image-cdn.app-echo.com/FlBEj_XjBdsWGdXE1FJJ2kbDWPCD?imageMogr2/auto-orient/quality/100%7CimageView2/0/w/500/q/100\",\"name\":\"CCH陈常鸿\",\"about\":\"hashaki\",\"location\":\"深圳\",\"website\":\"https://gitee.com/CCHChenChangHong\"}}"
    }
  ]
}

{
  "trx_id": "1d0cf830d806c5d15be9fa3835425164fef0ede7",
  "block": 24703250,
  "trx_in_block": 9,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-08-02T02:50:06",
  "op": [
    "vote",
    {
      "voter": "jacekw.dev",
      "author": "hashaki",
      "permlink": "few-python-code-to-write-the-spider-to-get-lady-spicture-of-playboy",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "8e736b8c09445edd30da9c03ec27b6f65c70589c",
  "block": 24646472,
  "trx_in_block": 39,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-07-31T03:29:12",
  "op": [
    "vote",
    {
      "voter": "alphabot",
      "author": "hashaki",
      "permlink": "few-python-code-to-write-the-spider-to-get-lady-spicture-of-playboy",
      "weight": 100
    }
  ]
}

{
  "trx_id": "0deaddc85bcebb47d2f319a6c0d48e0a80e8a15a",
  "block": 24646469,
  "trx_in_block": 28,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-07-31T03:29:03",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "cn",
      "author": "hashaki",
      "permlink": "few-python-code-to-write-the-spider-to-get-lady-spicture-of-playboy",
      "title": "few python code to write the spider to get lady`spicture of PlayBoy",
      "body": "if U want to run this code.\nI suggest U using Anaconda tool.\nhere is the target webside:http://www.girlsofpb.com\nI don`t post the picture here.U best to check out\n\n# build in python 3.5.2\n__author__='hashaki'\n![2.jpg](https://cdn.steemitimages.com/DQmbbAf934LBXzXXRZp3b16kRJNjJ6dsqy3ZktVFe7BdrKa/2.jpg)",
      "json_metadata": "{\"tags\":[\"cn\",\"teconology\",\"python\",\"spider\",\"beautifullady\"],\"links\":[\"http://www.girlsofpb.com\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\",\"image\":[\"https://cdn.steemitimages.com/DQmbbAf934LBXzXXRZp3b16kRJNjJ6dsqy3ZktVFe7BdrKa/2.jpg\"]}"
    }
  ]
}

{
  "trx_id": "f90b4a28d8df53a25fbef6c06578edef657fa6e6",
  "block": 24646429,
  "trx_in_block": 23,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-07-31T03:27:03",
  "op": [
    "vote",
    {
      "voter": "fastresteem",
      "author": "hashaki",
      "permlink": "few-python-code-to-write-the-spider-to-get-lady-spicture-of-playboy",
      "weight": 100
    }
  ]
}

{
  "trx_id": "4f3cf3831c01c00951e16907dedfecd1e1853c5f",
  "block": 24646426,
  "trx_in_block": 21,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-07-31T03:26:54",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "cn",
      "author": "hashaki",
      "permlink": "few-python-code-to-write-the-spider-to-get-lady-spicture-of-playboy",
      "title": "few python code to write the spider to get lady`spicture of PlayBoy",
      "body": "if U want to run this code.\nI suggest U using Anaconda tool.\nhere is the target webside:http://www.girlsofpb.com\nI don`t post the picture here.U best to check out\n\n# build in python 3.5.2\n__author__='hashaki'\nfrom bs4 import BeautifulSoup\nimport requests\nfrom PIL import Image\nfrom io import BytesIO\n\npath='F:\\playboy/'  #  change the save_file path\npage='/?page='\npage_num=1\ncontent='http://www.girlsofpb.com'    # 后面加女星名字\ndef get_girl_name(content):\n    webdata = requests.get(content).text\n    soup = BeautifulSoup(webdata, 'lxml')\n    link = soup.select(\"div.box2 > a\")  # 符空格有分类作用，去掉空格\n    n=1\n    content = 'http://www.girlsofpb.com'\n    for i in link:\n        href = i.get('href')\n        print(\"传入\", href)\n        get_pic(href,content,n)\n        print(\"完成\",n)\n        n+=1\n\ndef get_pic(href,content,n):\n    global page_num\n    webdata = requests.get(content+href).text\n    soup = BeautifulSoup(webdata, 'lxml')\n    try:\n        link = soup.select(\"img.corners-noie\")\n        m=1\n        for i in link:\n            jpg=i.get('src')\n            pic=requests.get(content+jpg)\n            image = Image.open(BytesIO(pic.content))\n            image.save(path + str(page_num) + '_' + str(n) +'_'+str(m)+ '.jpg')\n            m+=1\n    except:\n        print(\"出错了\")\n        pass\nfor i in range(1,71):\n    get_girl_name(content+page+str(i))",
      "json_metadata": "{\"tags\":[\"cn\",\"teconology\",\"python\",\"spider\",\"beautifullady\"],\"links\":[\"http://www.girlsofpb.com\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "57c8cd63347d02ebb23705c3fd32162b10d2d846",
  "block": 24286147,
  "trx_in_block": 47,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-07-18T14:39:39",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "hashaki",
      "vesting_shares": "30218.441690 VESTS"
    }
  ]
}

{
  "trx_id": "0000000000000000000000000000000000000000",
  "block": 23275402,
  "trx_in_block": 4294967295,
  "op_in_trx": 0,
  "virtual_op": 4,
  "timestamp": "2018-06-13T03:51:21",
  "op": [
    "author_reward",
    {
      "author": "hashaki",
      "permlink": "or",
      "sbd_payout": "0.014 SBD",
      "steem_payout": "0.004 STEEM",
      "vesting_payout": "26.415467 VESTS"
    }
  ]
}

{
  "trx_id": "9bd36c5dc589b5066f28fad1967c7781ccd59bc5",
  "block": 23074600,
  "trx_in_block": 19,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-06-06T04:00:18",
  "op": [
    "comment",
    {
      "parent_author": "hashaki",
      "parent_permlink": "or",
      "author": "yihdashu05630",
      "permlink": "re-or-20180606t040017",
      "title": "",
      "body": "Hi ~ I'm a robot of yihdashu05630.I just upvoted your post! \r\n Please come visit me here: https://steemit.com/@yihdashu05630 \r\n Thanks so much~!!",
      "json_metadata": "{\"app\": \"piston-lib/0.5.7\"}"
    }
  ]
}

{
  "trx_id": "64da51eda845123d0e24ad49a04e415bc9ff3371",
  "block": 23074599,
  "trx_in_block": 43,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-06-06T04:00:15",
  "op": [
    "vote",
    {
      "voter": "yihdashu05630",
      "author": "hashaki",
      "permlink": "or",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "cc1acdfb39c4ac0e0ad62413f7711369038bf24c",
  "block": 23074572,
  "trx_in_block": 25,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-06-06T03:58:54",
  "op": [
    "vote",
    {
      "voter": "coin.info",
      "author": "hashaki",
      "permlink": "or",
      "weight": 694
    }
  ]
}

{
  "trx_id": "4700759dbe0f79741aee108590e4b05f30e9033b",
  "block": 23074571,
  "trx_in_block": 7,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-06-06T03:58:51",
  "op": [
    "comment",
    {
      "parent_author": "hashaki",
      "parent_permlink": "or",
      "author": "coin.info",
      "permlink": "re-hashaki-or-20180606t035849721z",
      "title": "",
      "body": "**Coins mentioned in post:**\n\nCoin | | Price (USD) | 📈 24h | 📈 7d\n- | - | - | - | -\n**BTC** | Bitcoin | 7623.990$ | _2.59%_ | _1.57%_\n**ETH** | Ethereum | 609.255$ | _4.23%_ | _6.89%_\n**MIOTA** | IOTA | 1.754$ | _4.22%_ | _9.33%_\n**SWM** | Swarm | 0.473$ | _-12.75%_ | _59.17%_\n**ZEC** | Zcash | 238.990$ | _2.6%_ | _-5.85%_",
      "json_metadata": "{\"app\":\"coininfo/1.0.0\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "51751cb25a90b43e5d45c8709ceaade4676f73e3",
  "block": 23074436,
  "trx_in_block": 35,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-06-06T03:52:06",
  "op": [
    "comment",
    {
      "parent_author": "hashaki",
      "parent_permlink": "or",
      "author": "cn-cutie.pie",
      "permlink": "20180606t035206500z-post",
      "title": "",
      "body": "@hashaki, 我好欣赏你滴~~~ ![img](https://i.imgur.com/FMrtRXn.png)",
      "json_metadata": "{\"tags\":[\"cn\"]}"
    }
  ]
}

{
  "trx_id": "c63330fc4593eebaa13fff21ac2a2394fdd7ba49",
  "block": 23074435,
  "trx_in_block": 44,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-06-06T03:52:03",
  "op": [
    "vote",
    {
      "voter": "cn-cutie.pie",
      "author": "hashaki",
      "permlink": "or",
      "weight": 7792
    }
  ]
}

{
  "trx_id": "23e7083b6cfdad665a25d20cac76464212d63506",
  "block": 23074424,
  "trx_in_block": 61,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-06-06T03:51:30",
  "op": [
    "vote",
    {
      "voter": "ax3",
      "author": "hashaki",
      "permlink": "or",
      "weight": 100
    }
  ]
}

{
  "trx_id": "b17e0cec1c710f756663533ce64ce80f1ea3d5ca",
  "block": 23074421,
  "trx_in_block": 46,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-06-06T03:51:21",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "cn",
      "author": "hashaki",
      "permlink": "or",
      "title": "深度| 公链的挑战",
      "body": "![封面.jpeg](https://cdn.steemitimages.com/DQmYHzXyk1iBQLEKooyk9QvwVaCrwx6d7Wvdao8KffeVqPk/%E5%B0%81%E9%9D%A2.jpeg)\n毫无疑问，区块链技术具有巨大的潜力。\n\n \n\n去中心化的交易所、预测市场和资产管理平台等都只是区块链开发人员正在探索的几个令人兴奋的应用而已。然而，区块链有几个主要的技术障碍，使得它如今仍不适合被广泛应用。\n\n \n\n区块链中的一些技术障碍包括：\n\n1、有限的可扩增性；\n\n2、有限的隐私； \n\n3、缺乏合约的形式化验证；\n\n4、储存限制； \n\n5、不可持续的共识机制； \n\n6、缺乏治理和标准； \n\n7、开发工具不足；\n\n8、量子计算机威胁；\n\n9、… 还有很多。\n\n \n\n在这篇文章中，我将逐一阐述这些技术障碍，并分享对应的解决方案。\n\n \n\n作为开发者和投资者，我们需要面对的现实情况是，去信任的系统要被大规模广泛应用，还需要很长一段时间。此外，我们需要把注意力从吸引人眼球的ICO新项目，转移到阻碍我们前进的真正的技术挑战上。\n![1.jpeg](https://cdn.steemitimages.com/DQmb9Wn8MdQWVRh2yJSFNPEroeFLCvZ4qt41MnVcnaEnouw/1.jpeg)\n1、有限的可扩增性\n\n \n\n目前，所有的公共区块链共识协议（public blockchain consensus protocols）都有一个限制：网络中每个完全参与的节点都必须处理所有交易。\n\n \n\n由于区块链本质上是“去中心化的”，因此没有中央方负责保护和维护系统。相反，网络上的每个节点都负责通过处理所有交易和维护整个状态（State）的副本来保护系统。\n\n \n\n虽然去中心化的共识机制为我们提供了我们都关心的核心优势--安全保障、政治中立、审查规避，等等。但它是以牺牲可扩增性为代价的，因为按照定义，去中心化限制了区块链在网络中单个完全参与的节点的极限下可处理的交易数量。\n\n \n\n这里有两个实际影响：\n\n \n\n第一、低吞吐量：区块链能处理的交易数量有限。\n\n \n\n第二、延长交易时间：处理一个区块的交易速度很慢。例如，比特币区块要花10分钟，而以太坊区块大约要14秒。高峰时可能要更久。而使用Square或Visa等服务进行交易时几乎是即时完成，读者不妨将二者比较一下。\n\n \n\n因此，公共区块链被迫在低吞吐量和高度中心化之间进行权衡。\n\n \n\n换句话说，随着区块链容量变大，对网络中完全参与的节点所需的存储、带宽和计算能力的需求也随之增加。在某种程度上，它变得很难处理，以至于只有少数几个节点能够提供资源来处理区块，从而导致了集中化的风险。\n\n \n\n关于可扩增性的解决方案\n\n \n\n我们需要一种机制，来限制验证每笔交易的节点数量，同时又要确保每笔真实有效。这听起来可能很简单，但在技术上要做到却非常困难。\n\n \n\n可扩增性是未来平台发展的一个巨大障碍。目前，生态系统中的各个开发团队正在研究一些拟议的解决方案。我对目前的一些解决办法做了简要的总结，如下所示\n![2.jpeg](https://cdn.steemitimages.com/DQmVm5bhCV8cGovNGDsMqi4VbLJYDu3rByp7KkfQjhhxffP/2.jpeg)\n链下支付渠道(Off-chain payment channels)\n\n \n\n小额支付渠道网络背后的理念是让大多数交易在链下进行。它本质上是一种机制，通过这种机制，通常会发生在链上的交互作用会在链下进行。区块链纯粹被用于结算层面，这有助于减轻底层区块链的负担。\n\n \n\n这解决了我们前面讨论的吞吐量问题，因为现在区块链可以处理更多的交易量了。此外，支付渠道一旦开始进行处理，不用等到区块被确认，交易就会发生，微支付渠道解决了交易速度问题，消除了典型的延迟现象。\n\n \n\n分片(Sharding)\n\n \n\n分片背后的思路是，区块链的总体状态（State）被分成不同的“片”（Shard），状态的每个部分由网络中不同的节点存储和处理。每个片只平行处理状态的一小部分。区块链分片类似于传统数据库的分片，但它需要在去中心化的节点集合之间维护安全性和真实性，这是很有挑战性的。\n\n \n\n链下计算(Off-chain computations)\n\n \n\n这与状态通道(state channels)类似，但应用范围更广。其想法是以一种安全和可验证的方式进行链下计算(而不仅仅是代币转账)，否则链上计算的成本会相当高昂。将计算和验证过程从链下转移到单独的协议中，可以获得较高的交易吞吐量。这方面的一个例子是TrueBit。\n\n \n\n有向无环图(DAGs)\n\n \n\nDAG是有向无环图(Directed Acyclic Graph)的简称，是一种具有顶点和边的图形数据结构。(顶点是图上的一个点，边是从一个顶点到另一个顶点的路径。) DAG保证了从一个顶点开始，沿着有序的边，最终无法循环再次回到该顶点(即没有循环)。这样我们就可以按拓扑排序得到一系列节点(或顶点)。 \n![3.jpeg](https://cdn.steemitimages.com/DQmWqAkyH9p3F6oLsc7mw4RkNrjsqhMruUF3yUpkp4YFmn1/3.jpeg)\n例如，基于DAG的协议(例如 IOTA’s Tangle)的前提是完全抛弃整体线性区块链，而使用DAG数据结构来维护系统的状态。为了保护网络安全，这些协议依赖于它们自己的新方法，不用每个节点都以线性的方式来处理所有交易。\n\n \n\n再举个例子，另一种基于DAG的方法，SPECTRE protocol，使用区块的有向无环图，并行地挖掘DAG区块，以允许更多的吞吐量和更多的交易次数。\n\n \n\n目前这些协议还处于起步阶段，还没有得到大规模的实施和使用。坦率地说，它们有一些根本的尚未被解决的局限/弱点，因此也无法成为可行的可扩增性解决方案。\n\n  \n\n2.有限的隐私\n\n \n\n考虑到区块链上的交易并不直接关联到我们的身份，它们似乎更加私密。世界上的任何人都可以匿名创建一个新钱包，并使用它进行交易。\n\n \n\n然而，一切并没有那么简单。\n\n \n\n一方面，这一技术的巨大前景无疑是假名（pseudonymity）：交易记录并存储在一个公开的分布式账本中，但它们与一个仅由数字和字母组成的帐户地址相连。由于这个地址不关联任何真实身份，交易的发起人似乎无从查起。\n\n \n\n然而，这种完全安全的表象是有误导性的。诚然，只要假名不与个人关联，我们就可以保护自己的隐私，但一旦有人进行关联，秘密就会揭晓。类似的一个例子是，执法机构承认他们能够在调查期间识别特定的比特币用户，从而对他们进行反匿名，打破了区块链交易完全不可见的假设。\n\n \n\n这是如何完成的？\n\n \n\n商家网站上的web trackers和cookies使得交易信息很容易在网上泄露，任何人，包括政府、执法机构和恶意用户都可以很容易地利用这些信息。\n\n \n\n此外，用户在以太坊这样的区块链平台上与智能合约进行交互，这些合约处理的不仅仅是简单的价值转移。在以太坊区块链平台上，所有这些智能合约的细节都是公开的，包括发送方和接收方、交易数据本身、执行的代码和存储在合约中的状态。\n\n \n\n许多公司都不会将重要的商业数据上传到区块链中，因为黑客、竞争对手或其他未经授权的各方可以查看这些信息（电子医疗记录、身份识别数据、凭据管理、 财务文件等）。对于关心隐私和个人主权的个人、组织和行业来说，隐私仍然是一个根本障碍。\n\n\n隐私解决方案\n\n \n\n以下是几个不同开发团队一直在努力实现的解决方案。\n\n \n\nElliptic Curve Diffie-Hellman-Merkle (ECDHM)地址\n\n \n\n通过Diffie-Hellman密钥交换，一个可以用于在公共网络中私下交换消息的双方共享的秘密得以建立，发送方和接收方可以公开共享ECDHM地址，然后利用该秘密导出匿名比特币地址。这些比特币地址只被那些拥有这个秘密的人知道。唯一公开可见的是可重复使用的ECDHM地址。因此，用户不必担心交易会被追踪。\n![4.jpeg](https://cdn.steemitimages.com/DQmdPVdBgmUbgFd2S2JCWrXruuEVXQ36xBd5hfEYwv4YxEy/4.jpeg)\n概念图，它通过使用颜色来说明密钥交换的一般概念\n\n(来源： https：//en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange）\n\n \n\n混合器（Mixer）\n\n \n\n混合器背后的想法是，一群人可以将他们的支付混到一个池中，在私人分布式账本中记录债务情况。然后，随着池中的资金被花掉，每一笔支付的来源会变得模糊。任何观察区块链的人都可以看到支付的金额以及收款人，但理论上，具体授权支付的人是无法追踪的。混合器服务的一个例子是CoinJoin。\n![5.jpeg](https://cdn.steemitimages.com/DQmSH8Escp47di7QTrawyAEapjqKMi1rQaVfW4LhLHzdx8n/5.jpeg)\n资料来源：https：/en.wikipara.org/wiki/CoinJoin\n\n \n\n不幸的是，混合器已被证实不是一个可靠的解决方案。例如，研究人员能够很容易地识别CoinJoin交易，并证明只要花费32，000美元，攻击者识别交易匿名性的成功率就能达到90%。此外，研究人员还证明，混合器在应对应对女巫攻击（Sybil attacks）和拒绝服务攻击（Denial-of-Service attacks）上，能力有限。\n\n \n\n更令人不安的是，混合器所谓的私人分布式账本需要由某个中央实体管理，这意味着它需要一个可信的第三方来“混合”交易。\n\n \n\n门罗币（Menoro）\n\n \n\n另一种保护隐私的方法是创建默认私有的加密货币，比如门罗币不是比特币的分叉，它基于一种不同的协议--CryptoNote。门罗币提供的主要功能是另一种环签名（ring signature）方案。\n\n \n\n环签名是一种群签名，群里的每个签名者都有一对私公钥对。传统的密码签名是用来证明交易是由单个签名者使用私钥“批准”的，而群签名则在不公开任何人身份的情况下，证明交易是群里某个签名者批准的。\n\n \n\n零知识证明（Zero-knowledge proofs）\n\n \n\n零知识证明是指，在不直接透露相关知识的情况下，证明者向验证者证实他们知道一些秘密知识。换句话说，证明者通过秘密输入，无需对验证者透漏任何信息。零知识证明提供了可以用来建立隐私保护机制的基本的原语。包括：质询/响应比赛（Challenge / response games）、zkSNARKs、zkSNARKs + Zcash、zkSNARKs+Ethereum、zkSTARKs\n\n等。 \n\n \n\nOracles\n\n \n\n在区块链空间中，oracle负责在智能合约和外部数据源之间传递信息。它本质上充当链上智能合约和链下外部数据源之间的数据载体。因此，保持信息隐私的一种方法就是使用oracles从外部数据源中获取私密信息。\n\n \n\n可信执行环境（Trusted Execution Environments）\n\n \n\n可信执行环境(TEE)是主处理器的一个安全区域。它保证加载的代码和数据在保密和完整性方面能受到保护。TEE可与面向用户的操作系统并行运行，但其比后者更加私密和安全。\n![6.jpeg](https://cdn.steemitimages.com/DQma6kp31CMaqKPN361ZKR5z5v48BxCBjbAYTJ4AFo9s11t/6.jpeg)\n资料来源：https：//www.slideshare.net/JavierGonzlez49/operating-system-support-for-runtime-security-with-a-trusted-execution-environment-phd-thesis\n\n \n\n对TEE初期的的研究和开发仍在进行中，从而确定如何使用这些技术来保护区块链上的隐私。我个人非常高兴有更多的安全专家来解决这些问题。我们确实需要更多的专家来研究这个问题。\n\n \n\n3.缺乏合约的形式化验证\n\n \n\n对智能合约的形式化验证(formally verify)仍然是一个尚未解决的大问题。数学中的形式化证明(formal proof)是指由计算机使用基本数学公理和原始推理规则进行检验的数学证明。\n\n \n\n与软件程序有关的形式化验证是一种能判断程序是否按照规范运行的方法。我们首先在程序中声明一个不变量，然后我们需要对此声明予以证明。\n\n \n\n那么，为什么对智能合约中编码的程序进行形式化验证很重要呢？\n\n \n\n首先，智能合约是不可变的，这意味着一旦将它们部署到主网络上，我们就无法对它们进行修改或升级，我们在现实世界的应用中部署和使用这些合约前，需要保证TEE是可用的。此外，智能合约是开放的，任何人都可以查看存储在智能合约中的东西；任何人也可以调用智能合约的公开方法。虽然这很开放，也很透明，但它也吸引了黑客的攻击。\n\n \n\n事实是，不管你采取了多少预防措施，编写没有bug的可靠的智能合约是很困难的。此外，例如，由于EVM指令的设计方式，在以太坊平台上验证EVM代码是非常困难的。这使得为以太坊构建形式化验证解决方案变得更加困难。无论如何，形式化验证是一种减少bug和攻击的有力方法。相比传统方法(例如测试、同行审查等)，它在正确性方面更有保证，我们迫切需要一些更好的解决方案。\n\n \n\n形式化验证解决方案\n\n \n\n我希望我有更多公开可用的解决方案，能在这一节中炫耀，但不幸的是，方法不多。以太坊基金会的形式化验证工程师YuichiHirai完成了一些非常早期的方案，在验证几个智能合约上他得出了一些初期的成果，其中包括一份小的“契约”合同。虽然很小，但这是我见过的，在定理证明环境中分析过的第一份“真实”的合约。\n\n  \n\n还有一些像Tezos这样的团队，它们完全放弃使用Solidity作为语言，也不将EVM用作VM，而是构建自己的智能合约编程语言和VM，以便于形式化验证。\n\n \n\n无论是对EVM进行全面改造，使形式验证变得更容易，还是构建一种天生更容易验证的全新语言，我们都需要投入更多的努力。我们需要更多的研究人员和开发人员来研究形式化验证。我们可能需要各种编程语言的形式化验证库和标准。\n\n \n\n4.存储限制\n\n \n\n公共区块链上的大多数应用都需要解决存储问题。(用户身份、财务信息等)。\n\n \n\n但是，在公共区块链数据库中存储信息意味着数据是：\n\n \n\n1、由网络中的每个完整节点存储着。\n\n \n\n2、被无限期存储，因为区块链数据库是只能增加，并不可改变的。\n\n \n\n因此，数据存储给去中心化的网络带来了巨大的代价，每个节点都必须储存越来越多的数据。因此，对于任何构建在区块链上的实际应用来说，存储仍然是一个巨大的障碍。\n\n \n\n存储解决方案\n\n \n\n有几个早期项目正在使用不同策略将数据分割成分片，并以去中心化的方式将数据储存在参与的节点中(即分布式存储)。基本前提是，并非由每个节点存储所有东西，而是由一组节点集合拆分或“分布\" 数据。其中一些项目包括：Swarm、Storj、IPFs、Decent等。\n\n \n\n5.不可持续的共识机制\n\n \n\n区块链是“去信任的”。用户不必在交易中信任任何人。这能用户拥有一些吸引人的特性，比如自治、抗审查、真实性和无权限的创新。这种用来保证去信任区块链不易被攻击者破坏的机制被称为“共识协议”。\n\n \n\n工作量证明（proof-of-work）共识\n\n \n\n工作量证明可以用来解决一些难以解决但易于验证的难题。矿工使用自己的算力进行成本高昂的计算，而比特币系统则向给出答案的矿工奖励新比特币和交易费用。矿工拥有的计算能力越多，他们在决定共识上的“贡献”就越大。\n\n \n\n工作量证明的共识使得比特币成为第一种真正被广泛采用的去中心化的数字货币。它无需可信的第三方就能解决“双重支出问题”。然而，工作量证明并不完美，要建立一个更可行的共识机制，仍需进行大量的研究和开发。\n\n \n\n工作量证明有什么问题？\n\n \n\n1.专用硬件才有优势\n\n \n\n工作量证明的一个缺点是使用专门硬件。2013年，一种名为“应用专用集成电路”(ASICs)的设备专门被设计来挖比特币，它将效率提高了10至50倍。从那以后，使用普通计算机CPU和GPU进行挖矿已经变得完全无利可图，而挖矿的唯一方法就是使用自己制造的ASIC或从ASIC制造商那里购入。每个人都应该有机会为网络的安全做出贡献，而ASIC的出现则违背了去中心化的本意。\n\n \n\n为了缓解这一问题，以太坊选择使其PoW算法(Ethhash)在顺序上更难以记忆。这削弱了中心化的风险，并为正在进行验证的节点创造了更公平的竞争环境。当然，这并不是说将来不会有专门为以太坊设计的ASIC。对于PoW算法来说，专用硬件仍是一个巨大的风险。\n\n \n\n2.矿池集中化\n\n \n\n用户单独进行挖矿时，获得区块奖励的机会是很小的，取而代之，他们为矿池挖矿，相应地，矿池给按比例给矿工回报。矿池的问题是，由于它们在网络中有更多的“权重”，所以大矿池回报的方差比单个用户的要低。随着时间的推移，一些矿池开始控制大部分网络，中心化的矿池随着时间推移继续获得更多的算力。例如，目前排名前五的矿池拥有近70%的全网算力。这是很可怕的。\n\n \n\n3.能源浪费\n\n \n\n矿工们花费大量的计算能力来运行PoW的计算，但不幸的是，所有这些计算对社会没有价值。根据 Digiconomist’s Bitcoin Energy Consumption Index ，目前比特币采矿现在用的(浪费的)电力比159个国家用的还多。\n\n \n\n随着使用PoW共识的如比特币等公共区块链不断扩大，越来越多的能源将被浪费。\n\n \n\n共识解决方案\n\n \n\n有用的PoW\n\n \n\n解决能源浪费的一种方法是用PoW函数来解决一些有用的问题。例如，让矿工们用自己的算力来解决困难的人工智能算法，而不是解决PoW所要求的随机的SHA256问题。\n![7.jpeg](https://cdn.steemitimages.com/DQmWUconTY8cWSQZMxHeUdZ88k8m7b9f4wfLqnVxJyc7Cxx/7.jpeg)\n权益证明（Proof-of-stake，PoS）\n\n \n\n解决挖矿中心化的一种方法是完全取消挖矿，转而采用其他机制来计算共识中每个节点的贡献。这就是PoS的目的所在。\n\n \n\n矿工们不再投入算力，而是投入“权益”。正如Vitalik所指出的那样，它不再是“一单位算力一票”，而是“一 枚币一票”。\n\n \n\nPoS消除了对硬件的需求，因此不受上述硬件中心化问题的影响。此外，由于矿工不需要花费大量的能源来计算PoW问题，因此，PoS本质上是更节能的。\n\n \n\n然而，就像任何技术一样，天下没有免费的午餐。PoS有其自身的基本挑战。更具体而言，这些挑战包括：无权益关系问题、远程攻击、 卡特尔的形成等。 \n\n \n\n为了用一种新的可行的共识机制如PoS来代替PoW，我们需要一种算法来解决无权益关系问题和远程攻击问题，而不引入新的共谋风险。\n\n \n\n像Tendermint和以太坊这样的团队在解决这个问题上取得了很大的进步。然而，Tendermint有它自己的缺点。类似地，以太坊在实现PoS方面也取得了很大的进步，但现实情况是，在今天的实时网络上，没有任何东西在运行。\n\n \n\n与PoW不同的是，PoS未经检验，也很难了解。要了解不同设计做出的不同权衡，仍需进一步的研究和实验。因此，在这些早期工作的基础上，我们非常需要协作创建一个更高效、快速和安全的共识体系。\n\n \n\n6.缺乏治理和标准\n\n \n\n不言而喻，一个公共的、去中心化的区块链中，并不存在一个中央权威机构或组织来做决策。一方面，这给了一个我们梦寐以求的完全去信任的、开放的和无权限的系统 ；另一方面，协议实际上没有安全的升级路径，也没有人负责制定和维护标准。\n\n \n\n例如，以太坊当前的特定标准或特性通常是由一两个开发人员主导的。虽然这个模式目前是可行的，但是它也存在缺陷。首先，它并不高效。如果领导这项工作的开发人员忙碌起来，或者有几天或几周忘了响应，标准的推进就会停滞不前，无论这个标准对参与构建公共区块链上的人来说有多重要 。在没有明确领导的情况下制定标准，将会制造混乱，这会使人们很难及时对问题上达成共识，特别是在社区变得更大的时候，这种情况会更严重。\n\n \n\n另一种方法是让区块链完全开放和去中心化。然而，这种做法缺乏效率，将带来长久的危害。\n\n  \n\nTezos旨在利用链上治理从协议内部创建升级协议的能力，尽管它仍然是一个并未存在或被证明的想法。我们需要找到更好的方法。\n\n \n\n总之，区块链治理是一个非常棘手的问题，在中心化和分布式控制之间找到平衡，将是保持正确方向的关键所在。\n\n \n\n7.开发工具不足\n\n \n\n如果开发人员想要高效地完成他们的工作，充足的工具对于他们来说至关重要。使用糟糕的工具后果不堪设想。\n\n \n\n目前用于区块链生态系统的开发工具显然无法让人满意。即使是当下最有经验的开发人员，在区块链上开发一份功能协议或一个去中心化的应用程序也仍是一项艰巨的任务。\n\n \n\n作为一名Solidity和区块链的开发人员，我个人发现生态系统中缺乏的工具包括：能够检查代码错误，且集合了开发智能合约和区块链分析所需插件的IDE、有完整文档且易于使用的构建工具和编译程序、一个还过得去的的部署工具、持续更新的各种API和框架技术文档、测试框架、调试工具、 日志工具、 安全审计工具、 区块浏览器和分析工具。\n\n \n\n8.量子计算威胁\n\n \n\n量子计算机是加密货币和密码学面临的威胁之一。\n\n \n\n虽然如今量子计算机能解决的问题类型仍然有限，但这种情况不会一直这样持续下去。可怕的是，目前最流行的公钥算法能被足够大的量子计算机有效破解。\n\n \n\n当我们设计和构建区块链和及其底层的加密算法时，我们需要考虑如何使这些特性能抵抗量子计算机的攻击，这相当重要。\n\n \n\n抗量子解决方案\n\n \n\n虽然我并不是这方面的专家，但在我有限的理解范围内，后量子密码学的研究目前集中在六种不同的方法上： Lattice-based cryptography, Multivariate cryptography, Hash-based cryptography, Code-based cryptography, Supersingular elliptic curve isogeny cryptography, 和 Symmetric key quantum resistance systems（如 AES 和 SNOW 3G）。\n\n不管最终的解决方案是什么，探寻一种抗量子的密码解决方案都应该是重中之重。\n\n \n\n其它各种挑战\n\n \n\n· 我们需要更强大的解决方案，允许跨链通信，使得我们能在多个链(如比特币、以太币、莱特币等)之间进行无缝通信和交易。\n\n \n\n· 为了顶层的应用程序，我们需要在区块链工具中内置更好的密钥管理系统。\n\n \n\n· 我们需要更有效的签名方案和其他密码系统，使低运算资源的设备可以在不牺牲安全性的情况下处理这些系统。\n\n \n\n· …还有更多。![8.jpeg](https://cdn.steemitimages.com/DQmZndvs7JwipxJRkxLxc36t3k1WXycf4BzgaNXUCP9gsP5/8.jpeg)",
      "json_metadata": "{\"tags\":[\"cn\",\"blockchain\"],\"image\":[\"https://cdn.steemitimages.com/DQmYHzXyk1iBQLEKooyk9QvwVaCrwx6d7Wvdao8KffeVqPk/%E5%B0%81%E9%9D%A2.jpeg\",\"https://cdn.steemitimages.com/DQmb9Wn8MdQWVRh2yJSFNPEroeFLCvZ4qt41MnVcnaEnouw/1.jpeg\",\"https://cdn.steemitimages.com/DQmVm5bhCV8cGovNGDsMqi4VbLJYDu3rByp7KkfQjhhxffP/2.jpeg\",\"https://cdn.steemitimages.com/DQmWqAkyH9p3F6oLsc7mw4RkNrjsqhMruUF3yUpkp4YFmn1/3.jpeg\",\"https://cdn.steemitimages.com/DQmdPVdBgmUbgFd2S2JCWrXruuEVXQ36xBd5hfEYwv4YxEy/4.jpeg\",\"https://cdn.steemitimages.com/DQmSH8Escp47di7QTrawyAEapjqKMi1rQaVfW4LhLHzdx8n/5.jpeg\",\"https://cdn.steemitimages.com/DQma6kp31CMaqKPN361ZKR5z5v48BxCBjbAYTJ4AFo9s11t/6.jpeg\",\"https://cdn.steemitimages.com/DQmWUconTY8cWSQZMxHeUdZ88k8m7b9f4wfLqnVxJyc7Cxx/7.jpeg\",\"https://cdn.steemitimages.com/DQmZndvs7JwipxJRkxLxc36t3k1WXycf4BzgaNXUCP9gsP5/8.jpeg\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}