![](\"https://img.shields.io/badge/-Python-brightgreen\"){kind=icon}
\n![](\"https://img.shields.io/badge/-%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90-yellowgreen\"){kind=icon}
\n![](\"https://img.shields.io/badge/-%E7%AE%97%E6%B3%95-yellow\"){kind=icon}
\n![](\"https://img.shields.io/badge/-%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0-lightgrey\"){kind=icon}
\n![](\"https://static01.imgkr.com/temp/c6e10a16c4764dcdb32587760f6769ec.png\")
\n\n\n\n\n\n at 0x0000000005DE75D0, file \"\", line 1>\n \nIn [4]: exec(r)\nhelloworld\n\ns = \"\"\"\ndef f():\n a = 100 % 52\n print(a)\nf()\n\"\"\"\nr = compile(s,\"\", \"exec\")\nexec(r)\n```\n\n输出\n48\n\n[上一个例子](15.md) [下一个例子](17.md) \n"
},
{
"path": "md/160.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/02/27\n```\n### 列表快速复制之坑\n\n在python中`*`与列表操作，实现快速元素复制：\n\n```python\na = [1,3,5] * 3 # [1,3,5,1,3,5,1,3,5]\na[0] = 10 # [10, 2, 3, 1, 2, 3, 1, 2, 3]\n```\n\n如果列表元素为列表或字典等复合类型：\n\n```python\na = [[1,3,5],[2,4]] * 3 # [[1, 3, 5], [2, 4], [1, 3, 5], [2, 4], [1, 3, 5], [2, 4]]\n\na[0][0] = 10 # \n```\n\n结果可能出乎你的意料，其他`a[1[0]`等也被修改为10\n\n```python\n[[10, 3, 5], [2, 4], [10, 3, 5], [2, 4], [10, 3, 5], [2, 4]]\n```\n\n这是因为*复制的复合对象都是浅引用，也就是说id(a[0])与id(a[2])门牌号是相等的。如果想要实现深复制效果，这么做：\n\n```python\na = [[] for _ in range(3)]\n``` \n\n[上一个例子](159.md) [下一个例子](161.md) "
},
{
"path": "md/161.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/02/28\n```\n\n### 字符串驻留\n\n```python\nIn [1]: a = 'something'\n ...: b = 'some'+'thing'\n ...: id(a)==id(b)\nOut[1]: True\n```\n如果上面例子返回`True`，但是下面例子为什么是`False`:\n```python\nIn [1]: a = '@zglg.com'\n\nIn [2]: b = '@zglg'+'.com'\n\nIn [3]: id(a)==id(b)\nOut[3]: False\n```\n这与Cpython 编译优化相关，行为称为`字符串驻留`，但驻留的字符串中只包含字母，数字或下划线。 \n\n[上一个例子](160.md) [下一个例子](162.md) "
},
{
"path": "md/162.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/02/29\n```\n\n### 相同值的不可变对象\n```python\nIn [5]: d = {}\n ...: d[1] = 'java'\n ...: d[1.0] = 'python'\n\nIn [6]: d\nOut[6]: {1: 'python'}\n\n### key=1,value=java的键值对神奇消失了\nIn [7]: d[1]\nOut[7]: 'python'\nIn [8]: d[1.0]\nOut[8]: 'python'\n```\n这是因为具有相同值的不可变对象在Python中始终具有`相同的哈希值`\n\n由于存在`哈希冲突`，不同值的对象也可能具有相同的哈希值。 \n\n[上一个例子](161.md) [下一个例子](163.md) "
},
{
"path": "md/163.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/01\n```\n\n### 对象销毁顺序\n创建一个类`SE`:\n```python\nclass SE(object):\n def __init__(self):\n print('init')\n def __del__(self):\n print('del')\n```\n创建两个SE实例，使用`is`判断：\n```python\nIn [63]: SE() is SE()\ninit\ninit\ndel\ndel\nOut[63]: False\n\n```\n创建两个SE实例，使用`id`判断：\n```python\nIn [64]: id(SE()) == id(SE())\ninit\ndel\ninit\ndel\nOut[64]: True\n```\n\n调用`id`函数, Python 创建一个 SE 类的实例，并使用`id`函数获得内存地址后，销毁内存丢弃这个对象。\n\n当连续两次进行此操作, Python会将相同的内存地址分配给第二个对象，所以两个对象的id值是相同的.\n\n\n但是is行为却与之不同，通过打印顺序就可以看到。 \n\n[上一个例子](162.md) [下一个例子](164.md) "
},
{
"path": "md/164.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/02\n```\n\n### 充分认识for\n\n```python\nIn [65]: for i in range(5):\n ...: print(i)\n ...: i = 10\n0\n1\n2\n3\n4\n```\n为什么不是执行一次就退出？\n\n按照for在Python中的工作方式, i = 10 并不会影响循环。range(5)生成的下一个元素就被解包，并赋值给目标列表的变量`i`. \n\n[上一个例子](163.md) [下一个例子](165.md) "
},
{
"path": "md/165.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/03\n```\n\n### 认识执行时机\n\n```python\narray = [1, 3, 5]\ng = (x for x in array if array.count(x) > 0)\n```\n`g`为生成器，list(g)后返回`[1,3,5]`，因为每个元素肯定至少都出现一次。所以这个结果这不足为奇。但是，请看下例：\n```python\narray = [1, 3, 5]\ng = (x for x in array if array.count(x) > 0)\narray = [5, 7, 9]\n```\n请问,list(g)等于多少？这不是和上面那个例子结果一样吗，结果也是`[1,3,5]`，但是：\n```python\nIn [74]: list(g)\nOut[74]: [5]\n```\n\n这有些不可思议~~ 原因在于：\n\n生成器表达式中, in 子句在声明时执行, 而条件子句则是在运行时执行。\n\n\n所以代码：\n```python\narray = [1, 3, 5]\ng = (x for x in array if array.count(x) > 0)\narray = [5, 7, 9]\n```\n\n等价于：\n```python\ng = (x for x in [1,3,5] if [5,7,9].count(x) > 0)\n``` \n\n[上一个例子](164.md) [下一个例子](166.md) "
},
{
"path": "md/166.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/04\n```\n\n### 创建空集合错误\n\n这是Python的一个集合：`{1,3,5}`，它里面没有重复元素，在去重等场景有重要应用。下面这样创建空集合是错误的：\n\n```python\nempty = {} #NO!\n```\n\ncpython会解释它为字典\n\n使用内置函数`set()`创建空集合：\n\n```python\nempty = set() #YES!\n``` \n\n[上一个例子](165.md) [下一个例子](167.md) "
},
{
"path": "md/167.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/05\n```\n\n### pyecharts传入Numpy数据绘图失败\n\necharts使用广泛，echarts+python结合后的包：pyecharts，同样可很好用，但是传入Numpy的数据，像下面这样绘图会失败：\n\n```python\nfrom pyecharts.charts import Bar\nimport pyecharts.options as opts\nimport numpy as np\nc = (\n Bar()\n .add_xaxis([1, 2, 3, 4, 5])\n # 传入Numpy数据绘图失败！\n .add_yaxis(\"商家A\", np.array([0.1, 0.2, 0.3, 0.4, 0.5]))\n)\n\nc.render()\n```\n\n![](\"./img/image-20200129164119080.png\")
\n\n由此可见pyecharts对Numpy数据绘图不支持，传入原生Python的list:\n\n```python\nfrom pyecharts.charts import Bar\nimport pyecharts.options as opts\nimport numpy as np\nc = (\n Bar()\n .add_xaxis([1, 2, 3, 4, 5])\n # 传入Python原生list\n .add_yaxis(\"商家A\", np.array([0.1, 0.2, 0.3, 0.4, 0.5]).tolist())\n)\n\nc.render()\n```\n\n![](\"./img/image-20200129164339971.png\")
\n\n[上一个例子](166.md) [下一个例子](168.md) "
},
{
"path": "md/168.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/06\n```\n\n### 优化代码异常输出包\n\n一行代码优化输出的异常信息\n```python\npip install pretty-errors\n```\n\n写一个函数测试：\n\n```python\ndef divided_zero():\n for i in range(10, -1, -1):\n print(10/i)\n\n\ndivided_zero()\n```\n\n在没有import这个`pretty-errors`前，输出的错误信息有些冗余：\n\n```python\nTraceback (most recent call last):\n File \"c:\\Users\\HUAWEI\\.vscode\\extensions\\ms-python.python-2019.11.50794\\pythonFiles\\ptvsd_launcher.py\", line 43, in \n main(ptvsdArgs)\n File \"c:\\Users\\HUAWEI\\.vscode\\extensions\\ms-python.python-2019.11.50794\\pythonFiles\\lib\\python\\old_ptvsd\\ptvsd\\__main__.py\",\nline 432, in main\n run()\n File \"c:\\Users\\HUAWEI\\.vscode\\extensions\\ms-python.python-2019.11.50794\\pythonFiles\\lib\\python\\old_ptvsd\\ptvsd\\__main__.py\",\nline 316, in run_file\n runpy.run_path(target, run_name='__main__')\n File \"D:\\anaconda3\\lib\\runpy.py\", line 263, in run_path\n pkg_name=pkg_name, script_name=fname)\n File \"D:\\anaconda3\\lib\\runpy.py\", line 96, in _run_module_code\n mod_name, mod_spec, pkg_name, script_name)\n File \"D:\\anaconda3\\lib\\runpy.py\", line 85, in _run_code\n exec(code, run_globals)\n File \"d:\\source\\sorting-visualizer-master\\sorting\\debug_test.py\", line 6, in \n divided_zero()\n File \"d:\\source\\sorting-visualizer-master\\sorting\\debug_test.py\", line 3, in divided_zero\n print(10/i)\nZeroDivisionError: division by zero\n```\n\n我们使用刚安装的`pretty_errors`，`import`下:\n\n```python\nimport pretty_errors\n\ndef divided_zero():\n for i in range(10, -1, -1):\n print(10/i)\n\ndivided_zero()\n```\n\n此时看看输出的错误信息，非常精简只有2行，去那些冗余信息：\n\n```python\nZeroDivisionError:\ndivision by zero\n```\n\n完整的输出信息如下图片所示：\n\n![](\"./img/errors.png\")
\n\n[上一个例子](167.md) [下一个例子](169.md) "
},
{
"path": "md/169.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/07\n```\n\n#### 图像处理包pillow\n\n两行代码实现旋转和缩放图像\n\n首先安装pillow:\n\n```python\npip install pillow\n```\n\n旋转图像下面图像45度：\n\n![](\"./img/plotly2.png\")
\n\n```python\nIn [1]: from PIL import Image\nIn [2]: im = Image.open('./img/plotly2.png')\nIn [4]: im.rotate(45).show()\n```\n\n旋转45度后的效果图\n\n![](\"./img/image-20200105085120611.png\")
\n\n等比例缩放图像：\n\n```python\nim.thumbnail((128,72),Image.ANTIALIAS)\n```\n\n缩放后的效果图：\n\n\n\n\n\n过滤图像后的效果图：\n\n```python\nfrom PIL import ImageFilter\nim.filter(ImageFilter.CONTOUR).show()\n```\n\n![](\"./img/pillow_filter.png\")
\n \n\n[上一个例子](168.md) [下一个例子](170.md) "
},
{
"path": "md/17.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/2/15\n```\n\n#### 17 计算表达式\n\n将字符串str 当成有效的表达式来求值并返回计算结果取出字符串中内容\n\n```python\nIn [1]: s = \"1 + 3 +5\"\n\nIn [2]: eval(s)\nOut[2]: 9\n\ns = [\"{'小汽车':10, '面包车':8}\", \"{'面包车':5}\"]\nfrom collections import defaultdict\nd = defaultdict(int)\n\nfor item in s:\n my_dict = eval(item)\n print(type(my_dict))\n for key in my_dict:\n d[key] += my_dict[key]\nprint(d)\n\n\n\ndefaultdict(, {'小汽车': 10, '面包车': 13})\n```\n\n[上一个例子](16.md) [下一个例子](18.md) \n"
},
{
"path": "md/170.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/08\n```\n\n### 一行代码找到编码\n\n兴高采烈地，从网页上抓取一段 `content`\n\n但是，一 `print ` 就不那么兴高采烈了，结果看到一串这个：\n\n```markdown\nb'\\xc8\\xcb\\xc9\\xfa\\xbf\\xe0\\xb6\\xcc\\xa3\\xac\\xce\\xd2\\xd3\\xc3Python'\n```\n\n这是啥？ 又 x 又 c 的！\n\n再一看，哦，原来是十六进制字节串 (`bytes`)，`\\x` 表示十六进制\n\n接下来，你一定想转化为人类能看懂的语言，想到 `decode`：\n\n```python\nIn [3]: b'\\xc8\\xcb\\xc9\\xfa\\xbf\\xe0\\xb6\\xcc\\xa3\\xac\\xce\\xd2\\xd3\\xc3Python'.decode()\nUnicodeDecodeError Traceback (most recent call last)\n in \nUnicodeDecodeError: 'utf-8' codec can't decode byte 0xc8 in position 0: invalid continuation byte\n```\n\n马上，一盆冷水泼头上，抛异常了。。。。。\n\n根据提示，`UnicodeDecodeError`，这是 unicode 解码错误。\n\n原来，`decode` 默认的编码方法：`utf-8` \n\n所以排除 b'\\xc8\\xcb\\xc9\\xfa\\xbf\\xe0\\xb6\\xcc\\xa3\\xac\\xce\\xd2\\xd3\\xc3Python' 使用 `utf-8` 的编码方式\n\n可是，这不是四选一选择题啊，逐个排除不正确的！\n\n编码方式几十种，不可能逐个排除吧。\n\n那就猜吧！！！！！！！！！！！！！\n\n**人生苦短，我用Python**\n\n**Python， 怎忍心让你受累呢~**\n\n尽量三行代码解决问题\n\n**第一步，安装 chardet** 它是 char detect 的缩写。\n\n**第二步，pip install chardet**\n\n**第三步，出结果**\n\n```python\nIn [6]: chardet.detect(b'\\xc8\\xcb\\xc9\\xfa\\xbf\\xe0\\xb6\\xcc\\xa3\\xac\\xce\\xd2\\xd3\\xc3Python')\nOut[6]: {'encoding': 'GB2312', 'confidence': 0.99, 'language': 'Chinese'}\n```\n\n编码方法：gb2312\n\n解密字节串：\n\n```python\nIn [7]: b'\\xc8\\xcb\\xc9\\xfa\\xbf\\xe0\\xb6\\xcc\\xa3\\xac\\xce\\xd2\\xd3\\xc3Python'.decode('gb2312')\nOut[7]: '人生苦短，我用Python'\n```\n\n目前，`chardet` 包支持的检测编码几十种。 \n\n[上一个例子](169.md) [下一个例子](171.md) "
},
{
"path": "md/171.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/09\n```\n\n问：子类继承父类的方法吗？\n \n答：子类的实例继承了父类的static_method静态方法，调用该方法，还是调用的父类的方法和类属性。\n\n```python\n# coding:utf-8\n\n\nclass Foo(object):\n X = 1\n Y = 2\n\n @staticmethod\n def averag(*mixes):\n return sum(mixes) / len(mixes)\n\n @staticmethod\n def static_method():\n return Foo.averag(Foo.X, Foo.Y)\n\n @classmethod\n def class_method(cls):\n return cls.averag(cls.X, cls.Y)\n\n\nclass Son(Foo):\n X = 3\n Y = 5\n\n @staticmethod\n def averag(*mixes):\n return sum(mixes) / 3\n\np = Son()\nprint(p.static_method())\nprint(p.class_method())\n# 1.5\n# 2.6666666666666665\n```\n\n[上一个例子](170.md) [下一个例子](172.md) "
},
{
"path": "md/172.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc NumPy 的 pad 填充方法\n@tag NumPy \n@version v1.0\n@date 2020/11/27\n```\n\n今天介绍 NumPy 一个实用的方法 `pad`，实现数组周围向外扩展层的功能。\n\n```python\nIn [1]: import numpy as np \nIn [2]: help(np.pad) \nIn [4]: a = np.ones((3,4)) \nOut[4]: \narray([[1., 1., 1., 1.],\n [1., 1., 1., 1.],\n [1., 1., 1., 1.]])\n```\n\nnp.pad 默认在原数组周边向外扩展 pad_width 层：\n\n```python\nIn [6]: np.pad(a,pad_width=2) \nOut[6]: \narray([[0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0., 1., 1., 1., 1., 0., 0.],\n [0., 0., 1., 1., 1., 1., 0., 0.],\n [0., 0., 1., 1., 1., 1., 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0.]])\n```\n\n此函数在为数组充填值，卷积中有重要应用。\n\n以上就是《python-small-examples》第 172 个小例子：NumPy 的 pad 填充方法。\n\n[上一个例子](171.md) [下一个例子](173.md) "
},
{
"path": "md/173.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc 创建一个下对角线为1、2、3、4的对角矩阵\n@tag\n@version \n@date 2020/03/11\n```\n\n```python\nIn [1]: import numpy as np\n\nIn [2]: Z = np.diag(1+np.arange(4),k=-1)\n ...: print(Z)\n\n[[0 0 0 0 0]\n [1 0 0 0 0]\n [0 2 0 0 0]\n [0 0 3 0 0]\n [0 0 0 4 0]]\n ```\n \n 其中，k 参数：大于0，表示与主对角线上移k，小于0下移k\n\n[上一个例子](172.md) [下一个例子](174.md) "
},
{
"path": "md/174.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc cut 数据分箱\n@tag\n@version \n@date 2020/11/28\n```\n\n第174个小例子：cut 数据分箱\n\n将百分制分数转为A,B,C,D四个等级，bins 被分为 [0,60,75,90,100]，labels 等于['D', 'C', 'B', 'A']：\n\n```python\n# 生成20个[0,100]的随机整数\nIn [30]: a = np.random.randint(1,100,20) \nIn [31]: a \nOut[31]: \narray([48, 22, 46, 84, 13, 52, 36, 35, 27, 99, 31, 37, 15, 31, 5, 46, 98,99, 60, 43])\n\n# cut分箱\nIn [33]: pd.cut(a, [0,60,75,90,100], labels = ['D', 'C', 'B', 'A']) \nOut[33]: \n[D, D, D, B, D, ..., D, A, A, D, D]\nLength: 20\nCategories (4, object): [D < C < B < A]\n```\n\n分箱后，48分对应D，22分对应D，46对应D，84分对应B，...\n\n[上一个例子](173.md) [下一个例子](175.md) "
},
{
"path": "md/175.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc 丢弃空值和填充空值\n@tag\n@version \n@date 2020/03/13\n```\n\n丢弃空值\n\nnp.nan 是 pandas 中常见空值，使用 dropna 过滤空值，axis 0 表示按照行，1 表示按列，how 默认为 any ，意思是只要有一个 nan 就过滤某行或某列，all 所有都为 nan\n\n```python\n# axis 0 表示按照行，all 此行所有值都为 nan\ndf.dropna(axis=0, how='all')\n```\n\n充填空值\n\n空值一般使用某个统计值填充，如平均数、众数、中位数等，使用函数 fillna:\n\n```python\n# 使用a列平均数填充列的空值，inplace true表示就地填充\ndf[\"a\"].fillna(df[\"a\"].mean(), inplace=True)\n```\n\n\n\n[上一个例子](174.md) [下一个例子](176.md) "
},
{
"path": "md/176.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc 一行代码让 pip 安装加速 100 倍\n@tag\n@version \n@date 2020/03/14\n```\n\npip 安装普通方法：\n\n```python\npip install scrapy \n```\n\n这个安装可能是龟速，甚至直接抛出 timeout 异常，然后可能你会加长 socket 延时，通过设置 `defualt-timeout` 参数：\n\n```python\npip --defualt-timeout = 600 install scrapy\n```\n\n但是这不会加快安装速度，直接添加一个参数：\n\n```python\n-i https://pypi.tuna.tsinghua.edu.cn/simple \n```\n\n完整安装命令：\n\n```python\npip --defualt-timeout = 600 install scrapy -i https://pypi.tuna.tsinghua.edu.cn/simple \n```\n\n后面安装你可以直接复制我这行命令，安装包的速度会快很多。\n\n[上一个例子](175.md) [下一个例子](177.md) "
},
{
"path": "md/177.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc 数据分析神器：deepnote\n@tag\n@version \n@date 2020/03/15\n```\n\n一个和 jupyter notebook很像的神器：deepnote\n\njupyter notebook 是运行 python 非常好用的笔记本之一，尤其作数据分析、数据科学领域应用广泛。最近发现一款兼容 jupyter notebook，极好用的notebook: deepnote\n\n使用也是免费！https://deepnote.com/\n\n它的特点：时事协作，运行在云端\n\n上手使用一下，使用shift+enter 执行代码\n\n------\n\n 执行代码，体验很好，很香：\n\n邀请伙伴直接进入你的notebook，多人协作，开发更快：\n\n多了一种选择，调换着使用它们会很不错！\n\n[上一个例子](176.md) [下一个例子](178.md) "
},
{
"path": "md/178.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc apply 方法去掉特殊字符\n@tag\n@version \n@date 2020/03/16\n```\n\n### apply 方法去掉特殊字符\n\n某列单元格含有特殊字符，如标点符号，使用元素级操作方法 apply 干掉它们：\n\n```python\nimport string\nexclude = set(string.punctuation)\n\ndef remove_punctuation(x):\n x = ''.join(ch for ch in x if ch not in exclude)\n return x\n# 原df\nOut[26]: \n a b\n0 c,d edc.rc\n1 3 3\n2 d ef 4\n\n# 过滤a列标点\nIn [27]: df.a = df.a.apply(remove_punctuation) \nIn [28]: df \nOut[28]: \n a b\n0 cd edc.rc\n1 3 3\n2 d ef 4\n```\n\n[上一个例子](177.md) [下一个例子](179.md) "
},
{
"path": "md/179.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc 使用map对列做特征工程\n@tag\n@version \n@date 2020/03/17\n```\n\n**使用map对列做特征工程**\n\n先生成数据：\n\n```python\nd = {\n\"gender\":[\"male\", \"female\", \"male\",\"female\"],\n\"color\":[\"red\", \"green\", \"blue\",\"green\"],\n\"age\":[25, 30, 15, 32]\n}\n\ndf = pd.DataFrame(d)\ndf\n```\n\n\n\n在 `gender` 列上，使用 map 方法，快速完成如下映射：\n\n```python\nd = {\"male\": 0, \"female\": 1}\ndf[\"gender2\"] = df[\"gender\"].map(d)\n```\n\n\n\n[上一个例子](178.md) [下一个例子](180.md) "
},
{
"path": "md/18.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/2/16\n```\n\n#### 18 字符串格式化 \n\n格式化输出字符串，format(value, format_spec)实质上是调用了value的__format__(format_spec)方法。\n\n```\nIn [104]: print(\"i am {0},age{1}\".format(\"tom\",18))\ni am tom,age18\n```\n\n| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |\n| ---------- | ------- | --------- | ---------------------------- |\n| 3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |\n| -1 | {:+.2f} | -1.00 | 带符号保留小数点后两位 |\n| 2.71828 | {:.0f} | 3 | 不带小数 |\n| 5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为2) |\n| 5 | {:x<4d} | 5xxx | 数字补x (填充右边, 宽度为4) |\n| 10 | {:x<4d} | 10xx | 数字补x (填充右边, 宽度为4) |\n| 1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |\n| 0.25 | {:.2%} | 25.00% | 百分比格式 |\n| 1000000000 | {:.2e} | 1.00e+09 | 指数记法 |\n| 18 | {:>10d} | ' 18' | 右对齐 (默认, 宽度为10) |\n| 18 | {:<10d} | '18 ' | 左对齐 (宽度为10) |\n| 18 | {:^10d} | ' 18 ' | 中间对齐 (宽度为10) |\n\n[上一个例子](17.md) [下一个例子](19.md) "
},
{
"path": "md/180.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc category列转数值\n@tag\n@version \n@date 2020/03/18\n```\n\n第 180 个小例子：**category列转数值**\n\n某列取值只可能为有限个枚举值，往往需要转为数值，使用get_dummies，或自己定义函数：\n\n```python\npd.get_dummies(df['a'])\n```\n\n自定义函数，结合 apply:\n\n```python\ndef c2n(x):\n if x=='A':\n return 95\n if x=='B':\n return 80\n\ndf['a'].apply(c2n)\n```\n\n[上一个例子](179.md) [下一个例子](181.md) "
},
{
"path": "md/181.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc rank排名\n@tag\n@version \n@date 2020/03/19\n```\n\n第 181 个小例子：**rank排名**\n\nrank 方法，生成数值排名，ascending 为False，考试分数越高，排名越靠前：\n\n```python\nIn [36]: df = pd.DataFrame({'a':[46, 98,99, 60, 43]} )) \nIn [53]: df['a'].rank(ascending=False) \nOut[53]: \n0 4.0\n1 2.0\n2 1.0\n3 3.0\n4 5.0\n```\n\n[上一个例子](180.md) [下一个例子](182.md) "
},
{
"path": "md/182.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc 完成数据下采样，调整步长由小时为天\n@tag\n@version \n@date 2020/03/20\n第 182 个小例子：**完成数据下采样，调整步长由小时为天**\n```\n\n步长为小时的时间序列数据，有没有小技巧，快速完成下采样，采集成按天的数据呢？先生成测试数据：\n\n```python\nimport pandas as pd\nimport numpy as np\ndf = pd.DataFrame(np.random.randint(1,10,size=(240,3)), \\\ncolumns = ['商品编码','商品销量','商品库存'])\n```\n\n```python\ndf.index = pd.util.testing.makeDateIndex(240,freq='H')\ndf\n使用 resample 方法，合并为天(D)\n```\n\n小技巧，使用 resample 方法，合并为天(D)\n```python\nday_df = df.resample(\"D\")[\"商品销量\"].sum().to_frame()\nday_df\n```\n\n果如下，10行，240小时，正好为 10 days:\n\n\n[上一个例子](181.md) [下一个例子](183.md) "
},
{
"path": "md/183.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc 如何用 Pandas 快速生成时间序列数据？\n@tag\n@version \n@date 2020/03/21\n```\n\n### 第183个小例子：如何用 Pandas 快速生成时间序列数据？\n\n与时间序列相关的问题，平时还是挺常见的。\n\n介绍一个小技巧，使用 `pd.util.testing.makeTimeDataFrame`\n\n只需要一行代码，便能生成一个 index 为时间序列的 DataFrame:\n\n```python\nimport pandas as pd\n\npd.util.testing.makeTimeDataFrame(10)\n```\n\n结果：\n\n```markdown\nA B C D\n2000-01-03 0.932776 -1.509302 0.285825 0.941729\n2000-01-04 0.565230 -1.598449 -0.786274 -0.221476\n2000-01-05 -0.152743 -0.392053 -0.127415 0.841907\n2000-01-06 1.321998 -0.927537 0.205666 -0.041110\n2000-01-07 0.324359 1.512743 0.553633 0.392068\n2000-01-10 -0.566780 0.201565 -0.801172 -1.165768\n2000-01-11 -0.259348 -0.035893 -1.363496 0.475600\n2000-01-12 -0.341700 -1.438874 -0.260598 -0.283653\n2000-01-13 -1.085183 0.286239 2.475605 -1.068053\n2000-01-14 -0.057128 -0.602625 0.461550 0.033472\n```\n\n时间序列的间隔还能配置，默认的 A B C D 四列也支持配置。\n\n```python\nimport numpy as np\n\ndf = pd.DataFrame(np.random.randint(1,1000,size=(10,3)),\n columns = ['商品编码','商品销量','商品库存'])\ndf.index = pd.util.testing.makeDateIndex(10,freq='H')\n```\n\n结果：\n\n```markdown\n 商品编码 商品销量 商品库存\n2000-01-01 00:00:00 99 264 98\n2000-01-01 01:00:00 294 406 827\n2000-01-01 02:00:00 89 221 931\n2000-01-01 03:00:00 962 153 956\n2000-01-01 04:00:00 538 46 374\n2000-01-01 05:00:00 226 973 750\n2000-01-01 06:00:00 193 866 7\n2000-01-01 07:00:00 300 129 474\n2000-01-01 08:00:00 966 372 835\n2000-01-01 09:00:00 687 493 910\n```\n\n[上一个例子](182.md) [下一个例子](184.md) "
},
{
"path": "md/184.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc 如何快速找出 DataFrame 所有列 null 值个数\n@tag\n@version \n@date 2020/12/10\n```\n\n### 第184个小例子：如何快速找出 DataFrame 所有列 null 值个数？\n\n实际使用的数据，null 值在所难免。如何快速找出 DataFrame 所有列的 null 值个数？\n\n使用 Pandas 能非常方便实现，只需下面一行代码：\n\n```python\ndata.isnull().sum()\n```\n\ndata.isnull(): 逐行逐元素查找元素值是否为 null.\n\n.sum(): 默认在 axis 为 0 上完成一次 reduce 求和。\n\n上手实际数据，使用这个小技巧，很爽。\n\n读取泰坦尼克预测生死的数据集\n\n```python\ndata = pd.read_csv('titanicdataset-traincsv/train.csv')\n```\n\n检查 null 值:\n\n```python\ndata.isnull().sum()\n```\n\n结果：\n\n```python\nPassengerId 0\nSurvived 0\nPclass 0\nName 0\nSex 0\nAge 177\nSibSp 0\nParch 0\nTicket 0\nFare 0\nCabin 687\nEmbarked 2\ndtype: int64\n```\n\nAge 列 177 个 null 值\n\nCabin 列 687 个 null 值\n\nEmbarked 列 2 个 null 值\n\n[上一个例子](183.md) [下一个例子](185.md) "
},
{
"path": "md/185.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/23\n```\n\n### 第185个小例子：重新排序 DataFrame 的列\n\n下面给出 2 种简便的小技巧。先构造数据：\n\n```python\ndf = pd.DataFrame(np.random.randint(0,20,size=(5,7)) \\\n,columns=list('ABCDEFG'))\ndf\n```\n\n方法1，直接了当：\n\n```python\ndf2 = df[[\"A\", \"C\", \"D\", \"F\", \"E\", \"G\", \"B\"]]\ndf2\n```\n\n方法2，也了解下：\n\n```python\ncols = df.columns[[0, 2 , 3, 5, 4, 6, 1]]\ndf3 = df[cols]\ndf3\n```\n\n也能得到方法1的结果。\n\n[上一个例子](184.md) [下一个例子](186.md) "
},
{
"path": "md/186.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/24\n```\n\n### 第186个小例子：使用 count 统计词条 出现次数\n\n读入 IMDB-Movie-Data 数据集，1000行数据：\n\n```python\ndf = pd.read_csv(\"../input/imdb-data/IMDB-Movie-Data.csv\")\ndf['Title']\n```\n\n打印 `Title` 列：\n\n```python\n0 Guardians of the Galaxy\n1 Prometheus\n2 Split\n3 Sing\n4 Suicide Squad\n ...\n995 Secret in Their Eyes\n996 Hostel: Part II\n997 Step Up 2: The Streets\n998 Search Party\n999 Nine Lives\nName: Title, Length: 1000, dtype: object\n```\n\n标题是由几个单词组成，用空格分隔。\n\n```python\ndf[\"words_count\"] = df[\"Title\"].str.count(\" \") + 1\ndf[[\"Title\",\"words_count\"]]\n```\n\n\n\n[上一个例子](185.md) [下一个例子](187.md) "
},
{
"path": "md/187.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/25\n```\n\n### 第187个小例子：split 求时分(HH:mm)的分钟差\n\nsplit 是更加高效的实现，同样需要先转化为 str 类型：\n\n```python\ndf['a'] = df['a'].astype(str)\ndf['b'] = df['b'].astype(str)\n```\n\n其次 split：\n\n```python\ndf['asplit'] = df['a'].str.split(':')\ndf['bsplit'] = df['b'].str.split(':')\n```\n\n使用 apply 操作每个元素，转化为分钟数：\n\n```python\ndf['amins'] = df['asplit'].apply(lambda x: int(x[0])*60 + int(x[1]))\ndf['bmins'] = df['bsplit'].apply(lambda x: int(x[0])*60 + int(x[1]))\n```\n\n[上一个例子](186.md) [下一个例子](188.md) "
},
{
"path": "md/188.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/26\n```\n\n### 第188个小例子：melt透视数据小技巧\n\nmelt 方法固定某列为一个维度，组合其他列名为另一个维度，实现宽表融化为长表：\n\n```python\n zip_code factory warehouse retail\n0 12345 100 200 1\n1 56789 400 300 2\n2 101112 500 400 3\n3 131415 600 500 4\n```\n\n固定列`zip_code`，组合`factory`，`warehouse`，`retail` 三个列名为一个维度，按照这种方法凑齐两个维度后，数据一定变长。\n\npandas 的 melt 方法演示如下：\n\n```python\nIn [49]: df = df.melt(id_vars = \"zip_code\") \n```\n\n若melt方法，参数`value_vars`不赋值，默认剩余所有列都是value_vars，所以结果如下：\n\n```python\n zip_code variable value\n0 12345 factory 100\n1 56789 factory 400\n2 101112 factory 500\n3 131415 factory 600\n4 12345 warehouse 200\n5 56789 warehouse 300\n6 101112 warehouse 400\n7 131415 warehouse 500\n8 12345 retail 1\n9 56789 retail 2\n10 101112 retail 3\n11 131415 retail 4\n```\n\n若只想查看 factory 和 retail，则 `value_vars` 赋值为它们即可：\n\n```python\nIn [62]: df_melt2 = df.melt(id_vars = \"zip_code\",value_vars=['factory','reta\n ...: il']) \n```\n\n结果：\n\n```python\nzip_code variable value\n0 12345 factory 100\n1 56789 factory 400\n2 101112 factory 500\n3 131415 factory 600\n4 12345 retail 1\n5 56789 retail 2\n6 101112 retail 3\n7 131415 retail 4\n```\n\nmelt 透视数据后，因为组合多个列为1列，所以数据一定变长。\n\n[上一个例子](187.md) [下一个例子](189.md) "
},
{
"path": "md/189.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/27\n```\n\n### 第189个小例子： pivot 透视小技巧\n\nmelt 是融化数据，而 `pivot` 结冰数据，它们是一对互逆操作。\n\n这是上面 melt 后的数据：\n\n```python\nzip_code variable value\n0 12345 factory 100\n1 56789 factory 400\n2 101112 factory 500\n3 131415 factory 600\n4 12345 retail 1\n5 56789 retail 2\n6 101112 retail 3\n7 131415 retail 4\n```\n\n现在想要还原为：\n\n```python\nvariable factory retail\nzip_code \n12345 100 1\n56789 400 2\n101112 500 3\n131415 600 4\n```\n\n如何实现？\n\n使用 `pivot` 方法很容易做到：\n\n```python\ndf_melt2.pivot(index='zip_code',columns='variable')\n```\n\nindex 设定第一个轴，为 zip_code，columns 设定哪些列或哪个列的不同取值组合为一个轴，此处设定为 variable 列，它一共有 2 种不同的取值，分别为 factory, retail，pivot 透视后变为列名，也就是 axis = 1 的轴\n\npivot 方法没有聚合功能，它的升级版为 `pivot_table` 方法，能对数据聚合。\n\n[上一个例子](188.md) [下一个例子](190.md) "
},
{
"path": "md/19.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/2/20\n```\n\n#### 19 拿来就用的排序函数\n\n排序：\n\n```python\nIn [1]: a = [1,4,2,3,1]\n\nIn [2]: sorted(a,reverse=True)\nOut[2]: [4, 3, 2, 1, 1]\n\nIn [3]: a = [{'name':'xiaoming','age':18,'gender':'male'},{'name':'\n ...: xiaohong','age':20,'gender':'female'}]\nIn [4]: sorted(a,key=lambda x: x['age'],reverse=False)\nOut[4]:\n[{'name': 'xiaoming', 'age': 18, 'gender': 'male'},\n {'name': 'xiaohong', 'age': 20, 'gender': 'female'}]\n```\n\n[上一个例子](18.md) [下一个例子](20.md) "
},
{
"path": "md/190.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc 随机读取文件的K行，生成N个\n@tag\n@version \n@date 2020/03/28\n```\n\n### 第190个小例子： 随机读取文件的K行，生成N个\n\n```python\ndef random_lines_save(filename,gen_file_cnt=10):\n \"\"\"\n 随机选取文件的某些行并保存，想要生成这类文件的个数由参数\n @param: gen_file_cnt 指定 \n \n @param: filename 读入文件的完整路径\n @param: gen_file_cnt 想要产生的文件个数\n \"\"\"\n df = pd.read_excel(filename)\n for i in range(gen_file_cnt):\n n = random.randint(1,len(df))\n dfs = df.sample(n)\n dfs.to_excel(str(n)+\".xlsx\",index=False)\n print(str(n)+\".xlsx\")\n```\n\n这是一个很实用的函数，用于随机生成K行N个文件，使用场景：原来的文件行数较多，想从中随机提取组合N个文件时。\n\n[上一个例子](189.md) [下一个例子](191.md) "
},
{
"path": "md/191.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc 格式化Pandas的时间列\n@tag\n@version \n@date 2020/03/29\n```\n\n### 第191个小例子： 格式化Pandas的时间列\n\n\n\n```python\nimport pandas as pd \nfrom datetime import datetime, time \n\ndef series_dt_fmt(s:pd.Series,fmt:str)-> pd.Series: \n \"\"\"\n 根据fmt格式，格式化s列\n s列是datetime 或者 datetime的str类型，如'2020-12-30 11:44:00' \n \"\"\"\n st = pd.to_datetime(s)\n return st.apply(lambda t: datetime.strftime(t,fmt))\n```\n\n别看只有两行代码，却能实现更加丰富的功能，相比pandas，支持直接返回时分等格式：\n\n```python\ns = pd.Series(['2020-12-30 11:44:00','2020-12-30 11:20:10'])\n\n# 只保留时分\nfmt = '%H:%M'\nseries_dt_fmt(s,fmt)\n\n# 输出结果\n0 11:44\n1 11:20\ndtype: object\n```\n\n[上一个例子](190.md) [下一个例子](192.md) "
},
{
"path": "md/192.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/30\n```\n\n### 192: 创建SQLite连接\n\n编写一个Python程序，创建一个SQLite数据库，并与数据库连接，打印SQLite数据库的版本\n\n一种解决方法：\n\n```python\nimport sqlite3\ntry:\n sqlite_Connection = sqlite3.connect('temp.db')\n conn = sqlite_Connection.cursor()\n print(\"连接到 SQLite.\")\n sqlite_select_Query = \"select sqlite_version();\"\n conn.execute(sqlite_select_Query)\n record = conn.fetchall()\n print(\"SQLite 数据库的版本是 \", record)\n conn.close()\nexcept sqlite3.Error as error:\n print(\"连接到SQLite出错：\", error)\nfinally:\n if (sqlite_Connection):\n sqlite_Connection.close()\n print(\"关闭SQLite连接\")\n```\n\n以上就是第192例，希望对你有用，欢迎点赞支持。\n\n[上一个例子](191.md) [下一个例子](193.md) "
},
{
"path": "md/193.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/03/31\n```\n\n### 193 json对象转python对象\npython的`json`模块`loads`方法将json对象转为字典，如下所示：\n\n```python\nIn [1]: import json \n\nIn [2]: json_obj = '{ \"Name\":\"David\", \"Class\":\"I\", \"Age\":6 }' \n\nIn [3]: python_obj = json.loads(json_obj) \n\nIn [4]: type(python_obj) \nOut[4]: dict\n```\n\n打印查看相关属性\n```python\nprint(\"\\nJSON data:\")\nprint(python_obj)\nprint(\"\\nName: \",python_obj[\"Name\"])\nprint(\"Class: \",python_obj[\"Class\"])\nprint(\"Age: \",python_obj[\"Age\"]) \n```\n\n[上一个例子](192.md) [下一个例子](194.md) "
},
{
"path": "md/194.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/01\n```\n#### 194 python对象转json对象\n\n```python\nimport json\n# a Python object (dict):\npython_obj = {\n \"name\": \"David\",\n \"class\":\"I\",\n \"age\": 6 \n}\nprint(type(python_obj))\n```\n\n使用`json.dumps`方法转化为json对象：\n```\n# convert into JSON:\nj_data = json.dumps(python_obj)\n\n# result is a JSON string:\nprint(j_data)\n```\n\n##### 带格式转为json\n\n若字典转化为json对象后，保证键有序，且缩进4格，如何做到？\n\n```python\njson.dumps(j_str, sort_keys=True, indent=4)\n```\n\n例子：\n\n```python\nimport json\nj_str = {'4': 5, '6': 7, '1': 3, '2': 4}\nprint(json.dumps(j_str, sort_keys=True, indent=4))\n```\n\n\n\n[上一个例子](193.md) [下一个例子](195.md) \n\n"
},
{
"path": "md/195.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/02\n```\n#### 195 发现列表前3个最大或最小数\n\n使用堆模块 heapq 里的 nlargest 方法：\n\n```python\nimport heapq as hq\nnums_list = [25, 35, 22, 85, 14, 65, 75, 22, 58]\n\n# Find three largest values\nlargest_nums = hq.nlargest(3, nums_list)\nprint(largest_nums)\n```\n\n相应的求最小3个数，使用堆模块 heapq 里的 nsmallest 方法：\n\n```python\nimport heapq as hq\nnums_list = [25, 35, 22, 85, 14, 65, 75, 22, 58]\nsmallest_nums = hq.nsmallest(3, nums_list)\nprint(\"\\nThree smallest numbers are:\", smallest_nums)\n```\n\n\n\n\n[上一个例子](194.md) [下一个例子](196.md) "
},
{
"path": "md/196.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/03\n```\n\n### 196 使用堆排序列表为升序\n\n使用 heapq 模块，首先对列表建堆，默认建立小根堆，调用len(nums) 次heapop：\n\n```python\nimport heapq as hq\n\nnums_list = [18, 14, 10, 9, 8, 7, 9, 3, 2, 4, 1]\nhq.heapify(nums_list)\ns_result = [hq.heappop(nums_list) for _ in range(len(nums_list))]\nprint(s_result)\n```\n\n\n[上一个例子](195.md) [下一个例子](197.md) "
},
{
"path": "md/197.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/04\n```\n\n下面正则适用于提取正整数和大于0的浮点数，参看我的，若有疏漏欢迎补充。\n\n```python\n>>> import re\n>>> pat_integ = '[1-9]+\\d*'\n>>> pat_float0 = '0\\.\\d+[1-9]'\n>>> pat_float1 = '[1-9]\\d*\\.d+'\n>>> pat = 'r%s|%s|%s'%(pat_float_0,pat_float_1,pat_integ)\n>>> re.findall(pat, r)\n['0.78', '3446.73', '0.91', '13642.95', '1.06', '2672.12', '3000']\n```\n\n排除这些串：\n\n000\n000100\n0.00\n000.00\n\n\n解释：`*`表示前一个字符出现0次或多次，`+`表示前一个字符出现1次或多次，`\\d`表示数字[0-9]，`[1-9]`表示1,2,3,4,5,6,7,8,9，`\\.`表示小数点\n\n主要考虑：正整数最左侧一位大于0，大于1的浮点数必须以[1-9]开始，大于0小于1的浮点数小数点前只有1个0.\n\n\n\n\nDay163：使用Python正则 提取出输入一段文字中的所有浮点数和整数 #Python拆书1# \n\n例如： 截至收盘，上证指数涨0.78%，报3446.73点，深证成指涨0.91%，报13642.95点，创业板指涨1.06%，报2672.12点。指数午后震荡走高，碳中和概念强者恒强，板块内上演涨停潮，环保、物业、特高压板块午后涨幅扩大，数字货币板块尾盘冲高，钢铁、煤炭、有色板块全天较为低迷，题材股午后整体回暖，两市上涨个股逾3000家，赚钱效益较好。\n\n提取出所有浮点数和整数： 0.78, 3446.73, 0.91,13642.95 等\n\n\n\t\t \n\n[上一个例子](196.md) [下一个例子](198.md) \n"
},
{
"path": "md/198.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/05\n```\n## 1 常见算术运算\n\n```python\nx, y = 3, 2\nprint(x + y) # = 5 \nprint(x - y) # = 1 \nprint(x * y) # = 6 \nprint(x / y) # = 1.5 \nprint(x // y) # = 1 \nprint(x % y) # = 1 \nprint(-x) # = -3 \nprint(abs(-x)) # = 3 \nprint(int(3.9)) # = 3 \nprint(float(x)) # = 3.0 \nprint(x ** y) # = 9\n```\n\n大多数操作符都是不言自明的。注意，`//`运算符执行整数除法。结果是一个向下舍入的整数值（例如，3//2==1）\t\t \n\n[上一个例子](197.md) [下一个例子](199.md) \n"
},
{
"path": "md/199.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc 求两点球面距离\n@tag\n@version \n@date 2020/04/06\n```\n\n```python\nEARTH_RADIUS = 6378.137\n\nimport math\n# 角度弧度计算公式\ndef get_radian(degree):\n return degree * 3.1415926 / 180.0\n# 根据经纬度计算两点之间的距离，得到的单位是 千米\ndef get_distance(lat1,lng1,lat2,lng2):\n radLat1 = get_radian(lat1)\n radLat2 = get_radian(lat2)\n a = radLat1 - radLat2 # 两点纬度差\n b = get_radian(lng1) - get_radian(lng2); # 两点的经度差\n s = 2 * math.asin(math.sqrt(math.pow(math.sin(a / 2), 2) + \n math.cos(radLat1) * math.cos(radLat2) * math.pow(math.sin(b / 2), 2)));\n s = s * EARTH_RADIUS\n return s\n```\t\t \n\n[上一个例子](198.md) [下一个例子](200.md) "
},
{
"path": "md/2.md",
"content": "```markdown\r\n@author jackzhenguo\r\n@desc 进制转化\r\n@date 2019/2/10\r\n```\r\n\r\n#### 2 进制转化\r\n\r\n十进制转换为二进制：\r\n```python\r\nIn [1]: bin(10) \r\nOut[1]: '0b1010'\r\n```\r\n\r\n十进制转换为八进制：\r\n```python\r\nIn [2]: oct(9) \r\nOut[2]: '0o11'\r\n```\r\n\r\n十进制转换为十六进制：\r\n```python\r\nIn [3]: hex(15) \r\nOut[3]: '0xf'\r\n```\r\n\r\n\r\n[上一个例子](1.md) [下一个例子](3.md) "
},
{
"path": "md/20.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/2/20\n```\n\n#### 20 求和函数\n\n求和：\n\n```python\nIn [181]: a = [1,4,2,3,1]\n\nIn [182]: sum(a)\nOut[182]: 11\n\nIn [185]: sum(a,10) #求和的初始值为10\nOut[185]: 21\n```\n\n[上一个例子](19.md) [下一个例子](21.md) "
},
{
"path": "md/200.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc 获取文件编码\n@tag\n@version \n@date 2020/04/07\n```\n\n```python\nimport chardet\nfrom chardet import UniversalDetector\n\ndef get_encoding(file):\n with open(file, \"rb\") as f:\n cs = chardet.detect(f.read())\n return cs['encoding']\n \n detector = UniversalDetector()\n with open(file, \"rb\") as f:\n for line in f.readlines():\n detector.feed(line)\n if detector.done:\n break\n detector.close()\n return detector.result\n```\n\n[上一个例子](199.md) [下一个例子](201.md) "
},
{
"path": "md/201.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc 格式化json串\n@tag\n@version \n@date 2020/04/08\n```\n```python\nimport json\n\n\ndef format_json(json_str: str):\n dic = json.loads(json_str)\n\n js = json.dumps(dic,\n sort_keys=True,\n ensure_ascii=False,\n indent=4,\n separators=(', ', ': '))\n return js\n```\n\t\t \n\n[上一个例子](200.md) [下一个例子](202.md) "
},
{
"path": "md/202.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/09\n```\n\t\t \n\n[上一个例子](201.md) [下一个例子](203.md) "
},
{
"path": "md/203.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/10\n```\n\t\t \n\n[上一个例子](202.md) [下一个例子](204.md) "
},
{
"path": "md/204.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/11\n```\n\t\t \n\n[上一个例子](203.md) [下一个例子](205.md) "
},
{
"path": "md/205.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/12\n```\n\t\t \n\n[上一个例子](204.md) [下一个例子](206.md) "
},
{
"path": "md/206.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/13\n```\n\t\t \n\n[上一个例子](205.md) [下一个例子](207.md) "
},
{
"path": "md/207.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/14\n```\n\t\t \n\n[上一个例子](206.md) [下一个例子](208.md) "
},
{
"path": "md/208.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/15\n```\n\t\t \n\n[上一个例子](207.md) [下一个例子](209.md) "
},
{
"path": "md/209.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/16\n```\n\t\t \n\n[上一个例子](208.md) [下一个例子](210.md) "
},
{
"path": "md/21.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/2/20\n```\n\n#### 21 nonlocal用于内嵌函数中\n\n关键词`nonlocal`常用于函数嵌套中，声明变量`i`为非局部变量；\n如果不声明，`i+=1`表明`i`为函数`wrapper`内的局部变量，因为在`i+=1`引用(reference)时,i未被声明，所以会报`unreferenced variable`的错误。\n\n```python\ndef excepter(f):\n i = 0\n t1 = time.time()\n def wrapper(): \n try:\n f()\n except Exception as e:\n nonlocal i\n i += 1\n print(f'{e.args[0]}: {i}')\n t2 = time.time()\n if i == n:\n print(f'spending time:{round(t2-t1,2)}')\n return wrapper\n```\n\n[上一个例子](20.md) [下一个例子](22.md) "
},
{
"path": "md/210.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/17\n```\n\t\t \n\n[上一个例子](209.md) [下一个例子](211.md) "
},
{
"path": "md/211.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/18\n```\n\t\t \n\n[上一个例子](210.md) [下一个例子](212.md) "
},
{
"path": "md/212.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/19\n```\n\t\t \n\n[上一个例子](211.md) [下一个例子](213.md) "
},
{
"path": "md/213.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/20\n```\n\t\t \n\n[上一个例子](212.md) [下一个例子](214.md) "
},
{
"path": "md/214.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/21\n```\n\t\t \n\n[上一个例子](213.md) [下一个例子](215.md) "
},
{
"path": "md/215.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/22\n```\n\t\t \n\n[上一个例子](214.md) [下一个例子](216.md) "
},
{
"path": "md/216.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/23\n```\n\t\t \n\n[上一个例子](215.md) [下一个例子](217.md) "
},
{
"path": "md/217.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/24\n```\n\t\t \n\n[上一个例子](216.md) [下一个例子](218.md) "
},
{
"path": "md/218.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/25\n```\n\t\t \n\n[上一个例子](217.md) [下一个例子](219.md) "
},
{
"path": "md/219.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/26\n```\n\t\t \n\n[上一个例子](218.md) [下一个例子](220.md) "
},
{
"path": "md/22.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/2/23\n```\n\n#### 22 global 声明全局变量\n\n先回答为什么要有`global`，一个变量被多个函数引用，想让全局变量被所有函数共享。有的伙伴可能会想这还不简单，这样写：\n\n```python\ni = 5\ndef f():\n print(i)\n\ndef g():\n print(i)\n pass\n\nf()\ng()\n\n```\n\nf和g两个函数都能共享变量`i`，程序没有报错，所以他们依然不明白为什么要用`global`.\n\n但是，如果我想要有个函数对`i`递增，这样：\n\n```python\ndef h():\n i += 1\n\nh()\n```\n\n此时执行程序，bang, 出错了！ 抛出异常：`UnboundLocalError`，原来编译器在解释`i+=1`时会把`i`解析为函数`h()`内的局部变量，很显然在此函数内，编译器找不到对变量`i`的定义，所以会报错。\n\n`global`就是为解决此问题而被提出，在函数h内，显式地告诉编译器`i`为全局变量，然后编译器会在函数外面寻找`i`的定义，执行完`i+=1`后，`i`还为全局变量，值加1：\n\n```python\ni = 0\ndef h():\n global i\n i += 1\n\nh()\nprint(i)\n```\n\n[上一个例子](21.md) [下一个例子](23.md) "
},
{
"path": "md/220.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/27\n```\n\t\t \n\n[上一个例子](219.md) [下一个例子](221.md) "
},
{
"path": "md/221.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/28\n```\n\t\t \n\n[上一个例子](220.md) [下一个例子](222.md) "
},
{
"path": "md/222.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/29\n```\n\t\t \n\n[上一个例子](221.md) [下一个例子](223.md) "
},
{
"path": "md/223.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/04/30\n```\n\t\t \n\n[上一个例子](222.md) [下一个例子](224.md) "
},
{
"path": "md/224.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/05/01\n```\n\t\t \n\n[上一个例子](223.md) [下一个例子](225.md) "
},
{
"path": "md/225.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/05/02\n```\n\t\t \n\n[上一个例子](224.md) [下一个例子](226.md) "
},
{
"path": "md/226.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/05/03\n```\n\t\t \n\n[上一个例子](225.md) [下一个例子](227.md) "
},
{
"path": "md/227.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/05/04\n```\n\t\t \n\n[上一个例子](226.md) [下一个例子](228.md) "
},
{
"path": "md/228.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/05/05\n```\n\t\t \n\n[上一个例子](227.md) [下一个例子](229.md) "
},
{
"path": "md/229.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/05/06\n```\n\t\t \n\n[上一个例子](228.md) [下一个例子](230.md) "
},
{
"path": "md/23.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/2/23\n```\n\n#### 23 交换两元素\n\n理解交换两个元素，需要首先明白什么是pack，什么是unpack\n\n```python\nIn [1]: a=[3,1] \n\n# unpack\nIn [2]: a0,a1 = a \n\nIn [3]: a0 \nOut[3]: 3\n\nIn [4]: a1 \nOut[4]: 1\n\n# pack\nIn [5]: b = a0, a1 \n\nIn [6]: b \nOut[6]: (3, 1)\n\n```\n\n所以下面 `b,a = a,b` 交换2个元素的过程，实际是先pack a,b为元组 (a,b)，然后再unpack (a,b) 给 b, a的过程\n\n```python\ndef swap(a, b):\n return b, a\n\n\nprint(swap(1, 0)) # (0,1)\n```\n\n[上一个例子](22.md) [下一个例子](24.md) \n"
},
{
"path": "md/230.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/05/07\n```\n\t\t \n\n[上一个例子](229.md) [下一个例子](231.md) "
},
{
"path": "md/231.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/05/08\n```\n\t\t \n\n[上一个例子](230.md) [下一个例子](232.md) "
},
{
"path": "md/232.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/05/09\n```\n\t\t \n\n[上一个例子](231.md) [下一个例子](233.md) "
},
{
"path": "md/233.md",
"content": "\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date 2020/05/10\n```\n\t\t \n\n[上一个例子](232.md) [下一个例子](234.md) "
},
{
"path": "md/24.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/2/25\n```\n\n#### 24 操作函数对象\n\n```python\nIn [31]: def f():\n ...: print('i\\'m f')\n\nIn [32]: def g():\n ...: print('i\\'m g')\n\nIn [33]: [f,g][1]()\ni'm g\n```\n\n创建函数对象的list，根据想要调用的index，方便统一调用。\n\n[上一个例子](23.md) [下一个例子](25.md) "
},
{
"path": "md/25.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/2/25\n```\n\n#### 25 生成逆序序列\n\n```python\nlist(range(10,-1,-1))\n# [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n```\n\n第三个参数为负时，表示从第一个参数开始递减，终止到第二个参数(不包括此边界)\n\n[上一个例子](24.md) [下一个例子](26.md) "
},
{
"path": "md/26.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/2/27\n```\n\n#### 26 函数的五类参数使用例子\n\npython五类参数：位置参数，关键字参数，默认参数，可变位置或关键字参数的使用。\n\n```python\ndef f(a,*b,c=10,**d):\n print(f'a:{a},b:{b},c:{c},d:{d}')\n```\n\n*默认参数`c`不能位于可变关键字参数`d`后.*\n\n调用f:\n\n```python\nIn [10]: f(1,2,5,width=10,height=20)\na:1,b:(2, 5),c:10,d:{'width': 10, 'height': 20}\n```\n\n可变位置参数`b`实参后被解析为元组`(2,5)`;而c取得默认值10; d被解析为字典.\n\n再次调用f:\n\n```python\nIn [11]: f(a=1,c=12)\na:1,b:(),c:12,d:{}\n```\n\na=1传入时a就是关键字参数，b,d都未传值，c被传入12，而非默认值。\n\n注意观察参数`a`, 既可以`f(1)`,也可以`f(a=1)` 其可读性比第一种更好，建议使用f(a=1)。如果要强制使用`f(a=1)`，需要在前面添加一个**星号**:\n\n```python\ndef f(*,a,**b):\n print(f'a:{a},b:{b}')\n```\n\n此时f(1)调用，将会报错：`TypeError: f() takes 0 positional arguments but 1 was given`\n\n只能`f(a=1)`才能OK.\n\n说明前面的`*`发挥作用，它变为只能传入关键字参数，那么如何查看这个参数的类型呢？借助python的`inspect`模块：\n\n```python\nIn [22]: for name,val in signature(f).parameters.items():\n ...: print(name,val.kind)\n ...:\na KEYWORD_ONLY\nb VAR_KEYWORD\n```\n\n可看到参数`a`的类型为`KEYWORD_ONLY`，也就是仅仅为关键字参数。\n\n但是，如果f定义为：\n\n```python\ndef f(a,*b):\n print(f'a:{a},b:{b}')\n```\n\n查看参数类型：\n\n```python\nIn [24]: for name,val in signature(f).parameters.items():\n ...: print(name,val.kind)\n ...:\na POSITIONAL_OR_KEYWORD\nb VAR_POSITIONAL\n```\n\n可以看到参数`a`既可以是位置参数也可是关键字参数。\n\n[上一个例子](25.md) [下一个例子](27.md) "
},
{
"path": "md/27.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/2/27\n```\n\n#### 27 使用slice对象\n\n生成关于蛋糕的序列cake1：\n\n```python\nIn [1]: cake1 = list(range(5,0,-1))\n\nIn [2]: b = cake1[1:10:2]\n\nIn [3]: b\nOut[3]: [4, 2]\n\nIn [4]: cake1\nOut[4]: [5, 4, 3, 2, 1]\n```\n\n再生成一个序列：\n\n```python\nIn [5]: from random import randint\n ...: cake2 = [randint(1,100) for _ in range(100)]\n ...: # 同样以间隔为2切前10个元素，得到切片d\n ...: d = cake2[1:10:2]\nIn [6]: d\nOut[6]: [75, 33, 63, 93, 15]\n```\n\n你看，我们使用同一种切法，分别切开两个蛋糕cake1,cake2. 后来发现这种切法`极为经典`，又拿它去切更多的容器对象。\n\n那么，为什么不把这种切法封装为一个对象呢？于是就有了slice对象。\n\n定义slice对象极为简单，如把上面的切法定义成slice对象：\n\n```python\nperfect_cake_slice_way = slice(1,10,2)\n#去切cake1\ncake1_slice = cake1[perfect_cake_slice_way] \ncake2_slice = cake2[perfect_cake_slice_way]\n\nIn [11]: cake1_slice\nOut[11]: [4, 2]\n\nIn [12]: cake2_slice\nOut[12]: [75, 33, 63, 93, 15]\n```\n\n与上面的结果一致。\n\n对于逆向序列切片，`slice`对象一样可行：\n\n```python\na = [1,3,5,7,9,0,3,5,7]\na_ = a[5:1:-1]\n\nnamed_slice = slice(5,1,-1)\na_slice = a[named_slice] \n\nIn [14]: a_\nOut[14]: [0, 9, 7, 5]\n\nIn [15]: a_slice\nOut[15]: [0, 9, 7, 5]\n```\n\n频繁使用同一切片的操作可使用slice对象抽出来，复用的同时还能提高代码可读性。\n\n[上一个例子](26.md) [下一个例子](28.md) "
},
{
"path": "md/28.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/2\n```\n\n#### 28 lambda 函数的动画演示\n\n有些读者反映，`lambda`函数不太会用，问我能不能解释一下。\n\n比如，下面求这个 `lambda`函数：\n\n```python\ndef max_len(*lists):\n return max(*lists, key=lambda v: len(v))\n```\n\n有两点疑惑：\n\n- 参数`v`的取值？ \n- `lambda`函数有返回值吗？如果有，返回值是多少？\n\n调用上面函数，求出以下三个最长的列表：\n\n```python\nr = max_len([1, 2, 3], [4, 5, 6, 7], [8])\nprint(f'更长的列表是{r}')\n```\n\n\n结论：\n\n- 参数v的可能取值为`*lists`，也就是 `tuple` 的一个元素。\n\n- `lambda`函数返回值，等于`lambda v`冒号后表达式的返回值。\n\n[上一个例子](27.md) [下一个例子](29.md) "
},
{
"path": "md/29.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/2\n```\n\n#### 29 转为字典 \n\n创建数据字典\n\n```python\n# 方法1：使用dict\nIn [1]: dict()\nOut[1]: {}\nIn [2]: dict(a='a',b='b')\nOut[2]: {'a': 'a', 'b': 'b'}\n\n# 方法2：zip\nIn [3]: dict(zip(['a','b'],[1,2]))\nOut[3]: {'a': 1, 'b': 2}\n\n# 方法3：嵌入元组的列表\nIn [4]: dict([('a',1),('b',2)])\nOut[4]: {'a': 1, 'b': 2}\n\n# 方法4：自典型字符串\nIn [1]: s = \"{'a':1, 'b':2}\" \nIn [2]: eval(s) \nOut[2]: {'a': 1, 'b': 2}\n```\n\n[上一个例子](28.md) [下一个例子](30.md) \n"
},
{
"path": "md/3.md",
"content": "```markdown\r\n@author jackzhenguo\r\n@desc 整数和ASCII互转\r\n@date 2019/2/10\r\n```\r\n\r\n#### 3 整数和ASCII互转\r\n\r\n十进制整数对应的`ASCII字符`\r\n```python\r\nIn [1]: chr(65)\r\nOut[1]: 'A'\r\n```\r\n\r\n查看某个`ASCII字符`对应的十进制数\r\n```python\r\nIn [1]: ord('A')\r\nOut[1]: 65\r\n```\n\n[上一个例子](2.md) [下一个例子](4.md) "
},
{
"path": "md/30.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/4\n```\n\n#### 30 冻结集合 \n\n创建一个不可修改的集合。\n\n```python\nIn [1]: frozenset([1,1,3,2,3])\nOut[1]: frozenset({1, 2, 3})\n```\n\n因为不可修改，所以没有像`set`那样的`add`和`pop`方法\n\n[上一个例子](29.md) [下一个例子](31.md) "
},
{
"path": "md/31.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/4\n```\n\n#### 31 转为集合类型\n\n返回一个set对象，集合内不允许有重复元素：\n\n```python\nIn [1]: a = [1,4,2,3,1]\n\nIn [2]: set(a)\nOut[2]: {1, 2, 3, 4}\n\nIn [3]: b = set(a)\n\nIn [4]: b.add(5)\n\nIn [5]: b\nOut[5]: {1, 2, 3, 4, 5}\n\nIn [6]: b.pop()\nOut[6]: 1\n\nIn [7]: b\nOut[7]: {2, 3, 4, 5}\n\nIn [8]: b.pop()\nOut[8]: 2\n\nIn [9]: b\nOut[9]: {3, 4, 5}\n\n# 注意pop删除集合内任意一个元素\nIn [10]: help(b.pop)\nHelp on built-in function pop:\n\npop(...) method of builtins.set instance\n Remove and return an arbitrary set element.\n Raises KeyError if the set is empty.\n```\n\n[上一个例子](30.md) [下一个例子](32.md) \n"
},
{
"path": "md/32.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/4\n```\n\n#### 32 转元组\n\n `tuple()` 将对象转为一个不可变的序列类型\n\n ```python\n In [16]: i_am_list = [1,3,5]\n In [17]: i_am_tuple = tuple(i_am_list)\n In [18]: i_am_tuple\n Out[18]: (1, 3, 5)\n ```\n\n[上一个例子](31.md) [下一个例子](33.md) "
},
{
"path": "md/33.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/6\n```\n\n#### 33 对象是否可调用 \n\n检查对象是否可被调用\n\n```python\nIn [1]: callable(str)\nOut[1]: True\n\nIn [2]: callable(int)\nOut[2]: True\n```\n\n```python\nIn [18]: class Student(): \n ...: def __init__(self,id,name): \n ...: self.id = id \n ...: self.name = name \n ...: def __repr__(self): \n ...: return 'id = '+self.id +', name = '+self.name \n ...\n\nIn [19]: xiaoming = Student('001','xiaoming') \n\nIn [20]: callable(xiaoming) \nOut[20]: False\n```\n如果能调用`xiaoming()`, 需要重写`Student`类的`__call__`方法：\n\n```python\nIn [1]: class Student():\n ...: def __init__(self,id,name):\n ...: self.id = id\n ...: self.name = name\n ...: def __repr__(self):\n ...: return 'id = '+self.id +', name = '+self.name\n ...: def __call__(self):\n ...: print('I can be called')\n ...: print(f'my name is {self.name}')\n ...: \n\nIn [2]: t = Student('001','xiaoming')\n\nIn [3]: t()\nI can be called\nmy name is xiaoming\n```\n\n[上一个例子](32.md) [下一个例子](34.md) "
},
{
"path": "md/34.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/10\n```\n\n#### 34 ascii 展示对象 \n\n调用对象的 `__repr__` 方法，获得该方法的返回值，如下例子返回值为字符串\n\n```python\n>>> class Student():\n def __init__(self,id,name):\n self.id = id\n self.name = name\n def __repr__(self):\n return 'id = '+self.id +', name = '+self.name\n```\n调用：\n```python\n>>> xiaoming = Student(id='1',name='xiaoming')\n>>> xiaoming\nid = 1, name = xiaoming\n>>> ascii(xiaoming)\n'id = 1, name = xiaoming'\n```\n\n[上一个例子](33.md) [下一个例子](35.md) "
},
{
"path": "md/35.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/10\n```\n\n#### 35 类方法 \n\n`classmethod` 装饰器对应的函数不需要实例化，不需要 `self `参数。\n\n但第一个参数需要是表示自身类的 `cls` 参数，可以来调用类的属性，类的方法，实例化对象等。\n\n```python\nIn [1]: class Student():\n ...: def __init__(self,id,name):\n ...: self.id = id\n ...: self.name = name\n ...: def __repr__(self):\n ...: return 'id = '+self.id +', name = '+self.name\n ...: @classmethod\n ...: def f(cls):\n ...: print(cls)\n```\n\n[上一个例子](34.md) [下一个例子](36.md) "
},
{
"path": "md/36.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/10\n```\n\n#### 36 动态删除属性 \n\n```python\n>>> class Student():\n def __init__(self,id,name):\n self.id = id\n self.name = name\n def __repr__(self):\n return 'id = '+self.id +', name = '+self.name\n```\n调用：\n```python\n>>> xiaoming = Student(id='1',name='xiaoming')\n>>> xiaoming\nid = 1, name = xiaoming\n>>> ascii(xiaoming)\n'id = 1, name = xiaoming'\n```\n\n删除对象的属性\n\n```python\nIn [1]: delattr(xiaoming,'id')\n\nIn [2]: hasattr(xiaoming,'id')\nOut[2]: False\n```\n\n[上一个例子](35.md) [下一个例子](37.md) "
},
{
"path": "md/37.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/10\n```\n\n#### 37 一键查看对象所有方法 \n\n不带参数时返回`当前范围`内的变量、方法和定义的类型列表；带参数时返回`参数`的属性，方法列表。\n\n```python\nIn [96]: dir(xiaoming)\nOut[96]:\n['__class__',\n '__delattr__',\n '__dict__',\n '__dir__',\n '__doc__',\n '__eq__',\n '__format__',\n '__ge__',\n '__getattribute__',\n '__gt__',\n '__hash__',\n '__init__',\n '__init_subclass__',\n '__le__',\n '__lt__',\n '__module__',\n '__ne__',\n '__new__',\n '__reduce__',\n '__reduce_ex__',\n '__repr__',\n '__setattr__',\n '__sizeof__',\n '__str__',\n '__subclasshook__',\n '__weakref__',\n \n 'name']\n```\n\n[上一个例子](36.md) [下一个例子](38.md) "
},
{
"path": "md/38.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/10\n```\n\n#### 38 动态获取对象属性 \n\n获取对象的属性\n\n```python\nIn [1]: class Student():\n ...: def __init__(self,id,name):\n ...: self.id = id\n ...: self.name = name\n ...: def __repr__(self):\n ...: return 'id = '+self.id +', name = '+self.name\n\nIn [2]: xiaoming = Student(id='001',name='xiaoming')\nIn [3]: getattr(xiaoming,'name') # 获取xiaoming这个实例的name属性值\nOut[3]: 'xiaoming'\n```\n\n[上一个例子](37.md) [下一个例子](39.md) "
},
{
"path": "md/39.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/10\n```\n\n#### 39 对象是否有某个属性\n\n```python\nIn [1]: class Student():\n ...: def __init__(self,id,name):\n ...: self.id = id\n ...: self.name = name\n ...: def __repr__(self):\n ...: return 'id = '+self.id +', name = '+self.name\n\nIn [2]: xiaoming = Student(id='001',name='xiaoming')\nIn [3]: hasattr(xiaoming,'name')\nOut[3]: True\n\nIn [4]: hasattr(xiaoming,'address')\nOut[4]: False\n```\n\n[上一个例子](38.md) [下一个例子](40.md) "
},
{
"path": "md/4.md",
"content": "```markdown\r\n@author jackzhenguo\r\n@desc 元素都为真检查\r\n@date 2019/2/10\r\n```\r\n\r\n#### 4 元素都为真检查\r\n\r\n所有元素都为真，返回 `True`，否则为`False`\r\n```python\r\nIn [5]: all([1,0,3,6]) \r\nOut[5]: False\r\n```\r\n```python\r\nIn [6]: all([1,2,3]) \r\nOut[6]: True\r\n```\n\n[上一个例子](3.md) [下一个例子](5.md) "
},
{
"path": "md/40.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/10\n```\n\n#### 40 对象门牌号 \n\n```python\nIn [1]: class Student():\n ...: def __init__(self,id,name):\n ...: self.id = id\n ...: self.name = name\n ...: def __repr__(self):\n ...: return 'id = '+self.id +', name = '+self.name\n\nIn [2]: xiaoming = Student(id='001',name='xiaoming')\n```\n\n返回对象的内存地址\n\n```python\nIn [1]: id(xiaoming)\nOut[1]: 98234208\n```\n\n[上一个例子](39.md) [下一个例子](41.md) "
},
{
"path": "md/41.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/13\n```\n\n#### 41 isinstance\n\n判断*object*是否为类*classinfo*的实例，是返回true\n\n```python\nIn [1]: class Student():\n ...: def __init__(self,id,name):\n ...: self.id = id\n ...: self.name = name\n ...: def __repr__(self):\n ...: return 'id = '+self.id +', name = '+self.name\n\nIn [2]: xiaoming = Student(id='001',name='xiaoming')\n\nIn [3]: isinstance(xiaoming,Student)\nOut[3]: True\n```\n\n[上一个例子](40.md) [下一个例子](42.md) "
},
{
"path": "md/42.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/13\n```\n\n#### 42 issubclass父子关系鉴定\n\n```python\nIn [1]: class undergraduate(Student):\n ...: def studyClass(self):\n ...: pass\n ...: def attendActivity(self):\n ...: pass\n\nIn [2]: issubclass(undergraduate,Student)\nOut[2]: True\n\nIn [3]: issubclass(object,Student)\nOut[3]: False\n\nIn [4]: issubclass(Student,object)\nOut[4]: True\n```\n\n如果class是classinfo元组中某个元素的子类，也会返回True\n\n```python\nIn [1]: issubclass(int,(int,float))\nOut[1]: True\n```\n\n[上一个例子](41.md) [下一个例子](43.md) "
},
{
"path": "md/43.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/15\n```\n\n#### 43 所有对象之根\n\nobject 是所有类的基类\n\n```python\nIn [1]: o = object()\n\nIn [2]: type(o)\nOut[2]: object\n```\n\n[上一个例子](42.md) [下一个例子](44.md) "
},
{
"path": "md/44.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/16\n```\n\n#### 44 创建属性的两种方式\n\n返回 property 属性，典型的用法：\n\n```python\nclass C:\n def __init__(self):\n self._x = None\n\n def getx(self):\n return self._x\n\n def setx(self, value):\n self._x = value\n\n def delx(self):\n del self._x\n # 使用property类创建 property 属性\n x = property(getx, setx, delx, \"I'm the 'x' property.\")\n```\n\n使用python装饰器，实现与上完全一样的效果代码：\n\n```python\nclass C:\n def __init__(self):\n self._x = None\n\n @property\n def x(self):\n return self._x\n\n @x.setter\n def x(self, value):\n self._x = value\n\n @x.deleter\n def x(self):\n del self._x\n```\n\n[上一个例子](43.md) [下一个例子](45.md) "
},
{
"path": "md/45.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/10\n```\n\n#### 45 查看对象类型\n\n*class* `type`(*name*, *bases*, *dict*)\n\n传入一个参数时，返回 *object* 的类型：\n\n```python\nIn [1]: class Student():\n ...: def __init__(self,id,name):\n ...: self.id = id\n ...: self.name = name\n ...: def __repr__(self):\n ...: return 'id = '+self.id +', name = '+self.name\n ...: \n\nIn [2]: xiaoming = Student(id='001',name='xiaoming')\nIn [3]: type(xiaoming)\nOut[3]: __main__.Student\n\nIn [4]: type(tuple())\nOut[4]: tuple\n```\n\n[上一个例子](44.md) [下一个例子](46.md) "
},
{
"path": "md/46.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/4\n```\n\n#### 46 元类使用介绍\n\n`xiaoming`, `xiaohong`, `xiaozhang` 都是学生，这类群体叫做 `Student`. \n\nPython 定义类的常见方法，使用关键字 `class`\n\n```python\nIn [36]: class Student(object):\n ...: pass\n```\n\n`xiaoming`, `xiaohong`, `xiaozhang` 是类的实例，则：\n\n```python\nxiaoming = Student()\nxiaohong = Student()\nxiaozhang = Student()\n```\n\n创建后，xiaoming 的 `__class__` 属性，返回的便是 `Student`类\n\n```python\nIn [38]: xiaoming.__class__\nOut[38]: __main__.Student\n```\n\n问题在于，`Student` 类有 `__class__`属性，如果有，返回的又是什么？\n\n```python\nIn [39]: xiaoming.__class__.__class__\nOut[39]: type\n```\n\n哇，程序没报错，返回 `type`\n\n那么，我们不妨猜测：`Student` 类，类型就是 `type`\n\n换句话说，`Student`类就是一个**对象**，它的类型就是 `type`\n\n所以，Python 中一切皆对象，**类也是对象**\n\nPython 中，将描述 `Student` 类的类被称为：元类。\n\n按照此逻辑延伸，描述元类的类被称为：*元元类*，开玩笑了~ 描述元类的类也被称为元类。\n\n聪明的朋友会问了，既然 `Student` 类可创建实例，那么 `type` 类可创建实例吗？ 如果能，它创建的实例就叫：类 了。 你们真聪明！\n\n说对了，`type` 类一定能创建实例，比如 `Student` 类了。\n\n```python\nIn [40]: Student = type('Student',(),{})\n\nIn [41]: Student\nOut[41]: __main__.Student\n```\n\n它与使用 `class` 关键字创建的 `Student` 类一模一样。\n\nPython 的类，因为又是对象，所以和 `xiaoming`，`xiaohong` 对象操作相似。支持：\n\n- 赋值\n- 拷贝\n- 添加属性\n- 作为函数参数\n\n```python\nIn [43]: StudentMirror = Student # 类直接赋值 # 类直接赋值\nIn [44]: Student.class_property = 'class_property' # 添加类属性\nIn [46]: hasattr(Student, 'class_property')\nOut[46]: True\n```\n\n元类，确实使用不是那么多，也许先了解这些，就能应付一些场合。就连 Python 界的领袖 `Tim Peters` 都说：\n\n“元类就是深度的魔法，99%的用户应该根本不必为此操心。\n\n[上一个例子](45.md) [下一个例子](47.md) "
},
{
"path": "md/47.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/4\n```\n\n#### 47 枚举对象 \n\n返回一个可以枚举的对象，该对象的next()方法将返回一个元组。\n\n```python\nIn [1]: s = [\"a\",\"b\",\"c\"]\n ...: for i ,v in enumerate(s,1):\n ...: print(i,v)\n ...:\n1 a\n2 b\n3 c\n```\n\n[上一个例子](46.md) [下一个例子](48.md) "
},
{
"path": "md/48.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/4\n```\n\n#### 48 查看变量所占字节数\n`getsizeof`查看变量占用字节数\n看到：字典比列表占用更多空间\n\n```python\nIn [1]: import sys\n\nIn [3]: a = [('a',1),('b',2)] \n\nIn [5]: sys.getsizeof(a) \nOut[5]: 88\n\n\nIn [6]: a = {'a':1,'b':2.0} \nIn [7]: sys.getsizeof(a) \nOut[7]: 248\n\n```\n\n[上一个例子](47.md) [下一个例子](49.md) \n"
},
{
"path": "md/49.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/4\n```\n\n#### 49 过滤器 \n\n在函数中设定过滤条件，迭代元素，保留返回值为`True`的元素：\n\n```python\nIn [1]: fil = filter(lambda x: x>10,[1,11,2,45,7,6,13])\n\nIn [2]: list(fil)\nOut[2]: [11, 45, 13]\n```\n\n[上一个例子](48.md) [下一个例子](50.md) "
},
{
"path": "md/5.md",
"content": "```markdown\r\n@author jackzhenguo\r\n@desc 至少一个为真检查\r\n@date 2019/2/10\r\n```\r\n\r\n#### 5 至少一个为真检查 \r\n\r\n至少有一个元素为真返回`True`，否则`False`\r\n```python\r\nIn [7]: any([0,0,0,[]]) \r\nOut[7]: False\r\n```\r\n\r\n```python\r\nIn [8]: any([0,0,1]) \r\nOut[8]: True\r\n```\n\n[上一个例子](4.md) [下一个例子](6.md) "
},
{
"path": "md/50.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/4\n```\n\n#### 50 返回对象哈希值 \n\n返回对象的哈希值，值得注意的是自定义的实例都是可哈希的，`list`, `dict`, `set`等可变对象都是不可哈希的(unhashable)\n\n ```python\nIn [1]: hash(xiaoming)\nOut[1]: 6139638\n\nIn [2]: hash([1,2,3])\n# TypeError: unhashable type: 'list'\n ```\n\n[上一个例子](49.md) [下一个例子](51.md) "
},
{
"path": "md/51.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/4\n```\n\n#### 51 help 一键帮助 \n\n返回对象的帮助文档\n\n```python\nIn [1]: help(xiaoming)\nHelp on Student in module __main__ object:\n\nclass Student(builtins.object)\n | Methods defined here:\n |\n | __init__(self, id, name)\n |\n | __repr__(self)\n |\n | Data descriptors defined here:\n |\n | __dict__\n | dictionary for instance variables (if defined)\n |\n | __weakref__\n | list of weak references to the object (if defined)\n```\n\n[上一个例子](50.md) [下一个例子](52.md) "
},
{
"path": "md/52.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/4\n```\n\n### 52 获取用户输入 \n\n获取用户输入内容\n\n```python\nIn [1]: input()\naa\nOut[1]: 'aa'\n```\n\n[上一个例子](51.md) [下一个例子](53.md) "
},
{
"path": "md/53.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/8\n```\n\n#### 53 创建迭代器\n\n使用`iter(obj, sentinel)`, 返回一个可迭代对象, sentinel可省略(一旦迭代到此元素，立即终止)\n\n```python\nIn [1]: lst = [1,3,5]\n\nIn [2]: for i in iter(lst):\n ...: print(i)\n ...:\n1\n3\n5\n```\n\n```python\nIn [1]: class TestIter(object):\n ...: def __init__(self):\n ...: self.l=[1,3,2,3,4,5]\n ...: self.i=iter(self.l)\n ...: def __call__(self): #定义了__call__方法的类的实例是可调用的\n ...: item = next(self.i)\n ...: print (\"__call__ is called,fowhich would return\",item)\n ...: return item\n ...: def __iter__(self): #支持迭代协议(即定义有__iter__()函数)\n ...: print (\"__iter__ is called!!\")\n ...: return iter(self.l)\nIn [2]: t = TestIter()\nIn [3]: t() # 因为实现了__call__，所以t实例能被调用\n__call__ is called,which would return 1\nOut[3]: 1\n\nIn [4]: for e in TestIter(): # 因为实现了__iter__方法，所以t能被迭代\n ...: print(e)\n ...: \n__iter__ is called!!\n1\n3\n2\n3\n4\n5\n```\n\n[上一个例子](52.md) [下一个例子](54.md) "
},
{
"path": "md/54.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/20\n```\n\n#### 54 文件读写和mode 取值表\n\n返回文件对象\n\n```python\nIn [1]: fo = open('D:/a.txt',mode='r', encoding='utf-8')\n\nIn [2]: fo.read()\nOut[2]: '\\ufefflife is not so long,\\nI use Python to play.'\nIn [3]: fo.close() # 关闭文件对象\n```\n\nmode 取值表：\n\n| 字符 | 意义 |\n| :---- | :------------------------------- |\n| `'r'` | 读取（默认） |\n| `'w'` | 写入，并先截断文件 |\n| `'x'` | 排它性创建，如果文件已存在则失败 |\n| `'a'` | 写入，如果文件存在则在末尾追加 |\n| `'b'` | 二进制模式 |\n| `'t'` | 文本模式（默认） |\n| `'+'` | 打开用于更新（读取与写入） |\n\n文件读操作\n\n```python\nimport os\n# 创建文件夹\n\ndef mkdir(path):\n isexists = os.path.exists(path)\n if not isexists:\n os.mkdir(path)\n# 读取文件信息\n\ndef openfile(filename):\n f = open(filename)\n fllist = f.read()\n f.close()\n return fllist # 返回读取内容\n```\n\n文件写操作\n\n```python\n# 写入文件信息\n# example1\n# w写入，如果文件存在，则清空内容后写入，不存在则创建\nf = open(r\"./data/test.txt\", \"w\", encoding=\"utf-8\")\nprint(f.write(\"测试文件写入\"))\nf.close\n\n# example2\n# a写入，文件存在，则在文件内容后追加写入，不存在则创建\nf = open(r\"./data/test.txt\", \"a\", encoding=\"utf-8\")\nprint(f.write(\"测试文件写入\"))\nf.close\n\n# example3\n# with关键字系统会自动关闭文件和处理异常\nwith open(r\"./data/test.txt\", \"w\") as f:\n f.write(\"hello world!\")\n```\n\n[上一个例子](53.md) [下一个例子](55.md) "
},
{
"path": "md/55.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/10\n```\n\n#### 55 创建range序列\n\n1) range(stop)\n2) range(start, stop[,step])\n\n生成一个不可变序列：\n\n```python\nIn [1]: range(11)\nOut[1]: range(0, 11)\n\nIn [2]: range(0,11,1)\nOut[2]: range(0, 11)\n```\n\n[上一个例子](54.md) [下一个例子](56.md) "
},
{
"path": "md/56.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/20\n```\n\n#### 56 反向迭代器reversed\n\n```python\nIn [1]: rev = reversed([1,4,2,3,1])\n\nIn [2]: for i in rev:\n ...: print(i)\n ...:\n1\n3\n2\n4\n1\n```\n\n[上一个例子](55.md) [下一个例子](57.md) "
},
{
"path": "md/57.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/20\n```\n\n#### 57 zip迭代器\n\n创建一个聚合了来自每个可迭代对象中的元素的迭代器：\n\n```python\nIn [1]: x = [3,2,1]\nIn [2]: y = [4,5,6]\nIn [3]: list(zip(y,x))\nOut[3]: [(4, 3), (5, 2), (6, 1)]\n\nIn [4]: a = range(5)\nIn [5]: b = list('abcde')\nIn [6]: b\nOut[6]: ['a', 'b', 'c', 'd', 'e']\nIn [7]: [str(y) + str(x) for x,y in zip(a,b)]\nOut[7]: ['a0', 'b1', 'c2', 'd3', 'e4']\n```\n\n[上一个例子](56.md) [下一个例子](58.md) "
},
{
"path": "md/58.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/23\n```\n\n#### 58 operator使用举例\n\n```python\nfrom operator import (add, sub)\n\n\ndef add_or_sub(a, b, oper):\n return (add if oper == '+' else sub)(a, b)\n\n\nadd_or_sub(1, 2, '-') # -1\n```\n\n[上一个例子](57.md) [下一个例子](59.md) "
},
{
"path": "md/59.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/25\n```\n\n#### 60 传输json对象\n\n对象序列化，是指将内存中的对象转化为可存储或传输的过程。很多场景，直接一个类对象，传输不方便。\n\n但是，当对象序列化后，就会更加方便，因为约定俗成的，接口间的调用或者发起的 web 请求，一般使用 json 串传输。\n\n实际使用中，一般对类对象序列化。先创建一个 Student 类型，并创建两个实例。\n\n```python\nclass Student():\n def __init__(self,**args):\n self.ids = args['ids']\n self.name = args['name']\n self.address = args['address']\nxiaoming = Student(ids = 1,name = 'xiaoming',address = '北京')\nxiaohong = Student(ids = 2,name = 'xiaohong',address = '南京')\n```\n\n导入 json 模块，调用 dump 方法，就会将列表对象 [xiaoming,xiaohong]，序列化到文件 json.txt 中。\n\n```python\nimport json\n\nwith open('json.txt', 'w') as f:\n json.dump([xiaoming,xiaohong], f, default=lambda obj: obj.__dict__, ensure_ascii=False, indent=2, sort_keys=True)\n```\n\n生成的文件内容，如下：\n\n```json\n[\n {\n \"address\":\"北京\",\n \"ids\":1,\n \"name\":\"xiaoming\"\n },\n {\n \"address\":\"南京\",\n \"ids\":2,\n \"name\":\"xiaohong\"\n }\n]\n```\n\n[上一个例子](58.md) [下一个例子](60.md) "
},
{
"path": "md/6.md",
"content": "```markdown\n@author jackzhenguo\n@desc 判断是真是假\n@date 2019/2/12\n```\n\n#### 6 判断是真是假 \n\n测试一个对象是True, 还是False.\n```python\nIn [9]: bool([0,0,0]) \nOut[9]: True\n\nIn [10]: bool([]) \nOut[10]: False\n\nIn [11]: bool([1,0,1]) \nOut[11]: True\n```\n\n\n[上一个例子](5.md) [下一个例子](7.md) "
},
{
"path": "md/60.md",
"content": "#### 61 不用else和if实现计算器\n\n```python\nfrom operator import *\n\n\ndef calculator(a, b, k):\n return {\n '+': add,\n '-': sub,\n '*': mul,\n '/': truediv,\n '**': pow\n }[k](a, b)\n\n\ncalculator(1, 2, '+') # 3\ncalculator(3, 4, '**') # 81\n```\n\n[上一个例子](59.md) [下一个例子](61.md) "
},
{
"path": "md/61.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/3/25\n```\n\n#### 61 去最求平均\n\n```python\ndef score_mean(lst):\n lst.sort()\n lst2=lst[1:(len(lst)-1)]\n return round((sum(lst2)/len(lst2)),1)\n\nlst=[9.1, 9.0,8.1, 9.7, 19,8.2, 8.6,9.8]\nscore_mean(lst) # 9.1\n```\n\n[上一个例子](60.md) [下一个例子](62.md) "
},
{
"path": "md/62.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/2\n```\n\n#### 62 打印99乘法表\n\n打印出如下格式的乘法表\n\n```python\n1*1=1\n1*2=2 2*2=4\n1*3=3 2*3=6 3*3=9\n1*4=4 2*4=8 3*4=12 4*4=16\n1*5=5 2*5=10 3*5=15 4*5=20 5*5=25\n1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36\n1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49\n1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64\n1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81\n```\n\n一共有10 行，第`i`行的第`j`列等于：`j*i`，\n\n其中,\n\n `i`取值范围：`1<=i<=9`\n\n `j`取值范围：`1<=j<=i`\n\n根据`例子分析`的语言描述，转化为如下代码：\n\n```python\nfor i in range(1, 10):\n for j in range(1, i+1):\n print('%d * %d = %d' % (j, i, j * i) , end=\"\\t\")\n print()\n```\n\n[上一个例子](61.md) [下一个例子](63.md) "
},
{
"path": "md/63.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/2\n```\n\n#### 63 递归版flatten函数\n\n对于如下数组：\n\n```\n[[[1,2,3],[4,5]]]\n```\n\n如何完全展开成一维的。这个小例子实现的`flatten`是递归版，两个参数分别表示带展开的数组，输出数组。\n\n```python\nfrom collections.abc import *\n\ndef flatten(lst, out_lst=None):\n if out_lst is None:\n out_lst = []\n for i in lst:\n if isinstance(i, Iterable): # 判断i是否可迭代\n flatten(i, out_lst) # 尾数递归\n else:\n out_lst.append(i) # 产生结果\n return out_lst\n```\n\n调用`flatten`:\n\n```python\nprint(flatten([[1,2,3],[4,5]]))\nprint(flatten([[1,2,3],[4,5]], [6,7]))\nprint(flatten([[[1,2,3],[4,5,6]]]))\n# 结果：\n[1, 2, 3, 4, 5]\n[6, 7, 1, 2, 3, 4, 5]\n[1, 2, 3, 4, 5, 6]\n```\n\nnumpy里的`flatten`与上面的函数实现有些微妙的不同：\n\n```python\nimport numpy\nb = numpy.array([[1,2,3],[4,5]])\nb.flatten()\narray([list([1, 2, 3]), list([4, 5])], dtype=object)\n```\n\n[上一个例子](62.md) [下一个例子](64.md) "
},
{
"path": "md/64.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/2\n```\n\n#### 64 列表等分\n\n```python\nfrom math import ceil\n\ndef divide(lst, size):\n if size <= 0:\n return [lst]\n return [lst[i * size:(i+1)*size] for i in range(0, ceil(len(lst) / size))]\n```\n\n测试举例：\n\n```python\nr = divide([1, 3, 5, 7, 9], 2)\nprint(r) # [[1, 3], [5, 7], [9]]\n\nr = divide([1, 3, 5, 7, 9], 0)\nprint(r) # [[1, 3, 5, 7, 9]]\n\nr = divide([1, 3, 5, 7, 9], -3)\nprint(r) # [[1, 3, 5, 7, 9]]\n```\n\n\n\n[上一个例子](63.md) [下一个例子](65.md) "
},
{
"path": "md/65.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/6\n```\n\n#### 65 压缩列表\n\n```python\ndef filter_false(lst):\n return list(filter(bool, lst))\n\n\nr = filter_false([None, 0, False, '', [], 'ok', [1, 2]])\nprint(r) # ['ok', [1, 2]]\n\n```\n\n[上一个例子](64.md) [下一个例子](66.md) "
},
{
"path": "md/66.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/6\n```\n\n#### 66 求更长的列表\n\n```python\ndef max_length(*lst):\n return max(*lst, key=lambda v: len(v))\n\n\nr = max_length([1, 2, 3], [4, 5, 6, 7], [8])\nprint(f'更长的列表是{r}') # [4, 5, 6, 7]\n\nr = max_length([1, 2, 3], [4, 5, 6, 7], [8, 9])\nprint(f'更长的列表是{r}') # [4, 5, 6, 7]\n```\n\n[上一个例子](65.md) [下一个例子](67.md) "
},
{
"path": "md/67.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/6\n```\n\n#### 67 求众数\n\n```python\ndef top1(lst):\n return max(lst, default='列表为空', key=lambda v: lst.count(v))\n```\n\n测试举例：\n\n```python\nlst = [1, 3, 3, 2, 1, 1, 2]\nr = top1(lst)\nprint(f'{lst}中出现次数最多的元素为:{r}') \n# [1, 3, 3, 2, 1, 1, 2]中出现次数最多的元素为:1\n```\n\n\n\n[上一个例子](66.md) [下一个例子](68.md) "
},
{
"path": "md/68.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/10\n```\n\n#### 68 所有多个列表的最大值\n```python \ndef max_lists(*lst):\n return max(max(*lst, key=lambda v: max(v)))\n\n\nr = max_lists([1, 2, 3], [6, 7, 8], [4, 5])\nprint(r) # 8\n```\n\n[上一个例子](67.md) [下一个例子](69.md) "
},
{
"path": "md/69.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/10\n```\n\n#### 69 列表检查重复\n\n```python\ndef has_duplicates(lst):\n return len(lst) == len(set(lst))\n\n\nx = [1, 1, 2, 2, 3, 2, 3, 4, 5, 6]\ny = [1, 2, 3, 4, 5]\nhas_duplicates(x) # False\nhas_duplicates(y) # True\n```\n\n[上一个例子](68.md) [下一个例子](70.md) "
},
{
"path": "md/7.md",
"content": "```markdown\n@author jackzhenguo\n@desc 创建复数\n@date 2019/2/13\n```\n\n#### 7 创建复数\n\n创建一个复数\n\n```python\nIn [1]: complex(1,2)\nOut[1]: (1+2j)\n```\n\n\n[上一个例子](6.md) [下一个例子](8.md) "
},
{
"path": "md/70.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/10\n```\n\n#### 70 一行代码实现列表反转\n\n```python\ndef reverse(lst):\n return lst[::-1]\n\n\nr = reverse([1, -2, 3, 4, 1, 2])\nprint(r) # [2, 1, 4, 3, -2, 1]\n```\n\n[上一个例子](69.md) [下一个例子](71.md) "
},
{
"path": "md/71.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/14\n```\n\n#### 71 浮点数等差数列\n\n```python\ndef float_range(start, stop, n):\n start,stop,n = float('%.2f' % start), float('%.2f' % stop),int('%.d' % n)\n step = (stop-start)/n\n lst = [start]\n while n > 0:\n start,n = start+step,n-1\n lst.append(round((start), 2))\n return lst\n```\n\n测试举例：\n\n```python\nfloat_range(1, 8, 10) \n# [1.0, 1.7, 2.4, 3.1, 3.8, 4.5, 5.2, 5.9, 6.6, 7.3, 8.0]\n```\n\n\n\n[上一个例子](70.md) [下一个例子](72.md) "
},
{
"path": "md/72.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/15\n```\n\n#### 72 按条件分组\n\n```python\ndef bif_by(lst, f):\n return [ [x for x in lst if f(x)],[x for x in lst if not f(x)]]\n```\n\n测试举例：\n\n```python\nrecords = [25,89,31,34] \nbif_by(records, lambda x: x<80) # [[25, 31, 34], [89]]\n```\n\n\n\n[上一个例子](71.md) [下一个例子](73.md) "
},
{
"path": "md/73.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/15\n```\n\n#### 73 map实现向量运算\n\n多序列运算函数\n\n`map(function,iterabel,iterable2)`\n\n```python\nlst1=[1,2,3,4,5,6]\nlst2=[3,4,5,6,3,2]\nlist(map(lambda x,y:x*y+1,lst1,lst2))\n### [4, 9, 16, 25, 16, 13]\n```\n\n[上一个例子](72.md) [下一个例子](74.md) "
},
{
"path": "md/74.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/15\n```\n\n#### 74 值最大的字典\n\n```python\ndef max_pairs(dic):\n if len(dic) == 0:\n return dic\n max_val = max(map(lambda v: v[1], dic.items()))\n return [item for item in dic.items() if item[1] == max_val]\n```\n\n测试举例：\n\n```python\nr = max_pairs({'a': -10, 'b': 5, 'c': 3, 'd': 5})\nprint(r) # [('b', 5), ('d', 5)]\n```\n\n\n\n[上一个例子](73.md) [下一个例子](75.md) "
},
{
"path": "md/75.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/15\n```\n\n#### 75 合并两个字典\n\nPython 3.5 后支持的一行代码实现合并字典\n\n```python\ndef merge_dict(dic1, dic2):\n return {**dic1, **dic2} \n```\n\n测试：\n\n```python\nmerge_dict({'a': 1, 'b': 2}, {'c': 3}) \n# {'a': 1, 'b': 2, 'c': 3}\n```\n\n\n\n[上一个例子](74.md) [下一个例子](76.md) "
},
{
"path": "md/76.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/19\n```\n\n#### 76 Topn 字典\n\n返回字典d前n个最大值对应的键\n\n```python\nfrom heapq import nlargest\ndef topn_dict(d, n):\n return nlargest(n, d, key=lambda k: d[k])\n```\n\n测试：\n\n```python\ntopn_dict({'a': 10, 'b': 8, 'c': 9, 'd': 10}, 3) \n# ['a', 'd', 'c']\n```\n\n\n\n[上一个例子](75.md) [下一个例子](77.md) "
},
{
"path": "md/77.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/19\n```\n\n#### 77 异位词\n\n两个字符串含有相同字母，但排序不同，简称：互为变位词\n\n```python\nfrom collections import Counter\n\n# \n\ndef anagram(str1, str2):\n return Counter(str1) == Counter(str2)\n\nanagram('eleven+two', 'twelve+one') # True 这是一对神器的变位词\nanagram('eleven', 'twelve') # False\n```\n\n[上一个例子](76.md) [下一个例子](78.md) "
},
{
"path": "md/78.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/23\n```\n\n#### 78 逻辑上合并字典\n(1) 两种合并字典方法\n这是一般的字典合并写法\n\n```python\ndic1 = {'x': 1, 'y': 2 }\ndic2 = {'y': 3, 'z': 4 }\nmerged1 = {**dic1, **dic2} # {'x': 1, 'y': 3, 'z': 4}\n```\n\n修改merged['x']=10，dic1中的x值`不变`，`merged`是重新生成的一个`新字典`。\n\n但是，`ChainMap`却不同，它在内部创建了一个容纳这些字典的列表。因此使用ChainMap合并字典，修改merged['x']=10后，dic1中的x值`改变`，如下所示：\n\n```python\nfrom collections import ChainMap\nmerged2 = ChainMap(dic1,dic2)\nprint(merged2) # ChainMap({'x': 1, 'y': 2}, {'y': 3, 'z': 4})\n```\n\n[上一个例子](77.md) [下一个例子](79.md) "
},
{
"path": "md/79.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/4/26\n```\n\n#### 79 带名字的元组\n\n定义名字为Point的元祖，字段属性有`x`,`y`,`z`\n\n```python\nfrom collections import namedtuple\nPoint = namedtuple('Point', ['x', 'y', 'z']) \nlst = [Point(1.5, 2, 3.0), Point(-0.3, -1.0, 2.1), Point(1.3, 2.8, -2.5)]\nprint(lst[0].y - lst[1].y)\n```\n\n使用命名元组写出来的代码可读性更好，尤其处理上百上千个属性时作用更加凸显。\n\n[上一个例子](78.md) [下一个例子](80.md) "
},
{
"path": "md/8.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/2/10\n```\n\n#### 8 取商和余数 \n\n分别取商和余数\n\n```python\nIn [1]: divmod(10,3)\nOut[1]: (3, 1)\n```\n\n\n[上一个例子](7.md) [下一个例子](9.md) "
},
{
"path": "md/80.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/5/1\n```\n\n#### 80 sample 样本抽样\n\n使用`sample`抽样，如下例子从100个样本中随机抽样10个。\n\n```python\nfrom random import randint,sample\nlst = [randint(0,50) for _ in range(100)]\nprint(lst[:5])# [38, 19, 11, 3, 6]\nlst_sample = sample(lst,10)\nprint(lst_sample) # [33, 40, 35, 49, 24, 15, 48, 29, 37, 24]\n```\n\n[上一个例子](79.md) [下一个例子](81.md) "
},
{
"path": "md/81.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/5/1\n```\n\n#### 81 shuffle 重洗数据集\n\n使用`shuffle`用来重洗数据集，值得注意`shuffle`是对lst就地(in place)洗牌，节省存储空间。\n\n```python\nfrom random import shuffle\nlst = [randint(0,50) for _ in range(100)]\nshuffle(lst)\nprint(lst[:5]) # [50, 3, 48, 1, 26]\n```\n\n[上一个例子](80.md) [下一个例子](82.md) "
},
{
"path": "md/82.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/5/1\n```\n\n#### 82 10个均匀分布的坐标点\n\nrandom模块中的`uniform(a,b)`生成[a,b)内的一个随机数。\n\n如下生成10个均匀分布的二维坐标点\n\n```python\nfrom random import uniform\nIn [1]: [(uniform(0,10),uniform(0,10)) for _ in range(10)]\nOut[1]: \n[(9.244361194237328, 7.684326645514235),\n (8.129267671737324, 9.988395854203773),\n (9.505278771040661, 2.8650440524834107),\n (3.84320100484284, 1.7687190176304601),\n (6.095385729409376, 2.377133802224657),\n (8.522913365698605, 3.2395995841267844),\n (8.827829601859406, 3.9298809217233766),\n (1.4749644859469302, 8.038753079253127),\n (9.005430657826324, 7.58011186920019),\n (8.700789540392917, 1.2217577293254112)]\n```\n\n[上一个例子](81.md) [下一个例子](83.md) "
},
{
"path": "md/83.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/5/3\n```\n\n#### 83 10个高斯分布的坐标点\n\nrandom模块中的`gauss(u,sigma)`生成均值为u, 标准差为sigma的满足高斯分布的值，如下生成10个二维坐标点，样本误差(y-2*x-1)满足均值为0，标准差为1的高斯分布：\n\n```python\nfrom random import gauss\nx = range(10)\ny = [2*xi+1+gauss(0,1) for xi in x]\npoints = list(zip(x,y))\n### 10个二维点：\n[(0, -0.86789025305992),\n (1, 4.738439437453464),\n (2, 5.190278040856102),\n (3, 8.05270893133576),\n (4, 9.979481700775292),\n (5, 11.960781766216384),\n (6, 13.025427054303737),\n (7, 14.02384035204836),\n (8, 15.33755823101161),\n (9, 17.565074449028497)]\n```\n\n[上一个例子](82.md) [下一个例子](84.md) "
},
{
"path": "md/84.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/5/4\n```\n\n#### 84 chain串联小容器为大容器\n\n`chain`函数串联a和b，兼顾内存效率同时写法更加优雅。\n\n```python\nfrom itertools import chain\na = [1,3,5,0]\nb = (2,4,6)\n\nfor i in chain(a,b):\n print(i)\n### 结果\n1\n3\n5\n0\n2\n4\n6\n```\n\n[上一个例子](83.md) [下一个例子](85.md) "
},
{
"path": "md/85.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/5/5\n```\n\n#### 85 product 案例\n\n```python\ndef product(*args, repeat=1):\n pools = [tuple(pool) for pool in args] * repeat\n result = [[]]\n for pool in pools:\n result = [x+[y] for x in result for y in pool]\n for prod in result:\n yield tuple(prod)\n```\n\n\n调用函数：\n\n```python\nrtn = product('xyz', '12', repeat=3)\nprint(list(rtn))\n```\n\n[上一个例子](84.md) [下一个例子](86.md) "
},
{
"path": "md/86.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/5/6\n```\n\n#### 86 反转字符串的两个方法\n\n```python\nst=\"python\"\n```\n\n方法1：\n\n```python\n''.join(reversed(st))\n```\n\n方法2:\n\n```python\nst[::-1]\n```\n\n\n\n[上一个例子](85.md) [下一个例子](87.md) "
},
{
"path": "md/87.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/5/7\n```\n\n#### 87 join 串联字符串\n\n用逗号连接字符串\n\n```python\nIn [4]: mystr = ['1','2','java','4','python','java','7','8','java','python','11','java','13','14']\n\nIn [5]: ','.join(mystr) #用逗号连接字符串\nOut[5]: '1,2,java,4,python,java,7,8,java,python,11,java,13,14'\n```\n\n[上一个例子](86.md) [下一个例子](88.md) "
},
{
"path": "md/88.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/5/3\n```\n\n#### 88 字符串字节长度\n\n```python\ndef str_byte_len(mystr):\n return (len(mystr.encode('utf-8')))\n```\n\n测试：\n\n```python\nstr_byte_len('i love python') # 13(个字节)\nstr_byte_len('字符') # 6(个字节)\n```\n\n\n\n[上一个例子](87.md) [下一个例子](89.md) "
},
{
"path": "md/89.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/5/10\n```\n\n### 89 正则中字符 `r`是干啥的？\n\n经常见过正则表达式前有一个字符 `r`，它的作用是告诉解释器后面的一串是原生字符串，按照字面意思解释即可。如：\n\n```python\ns1 = r'\\n.*'\nprint(s1) \n```\n\n它告诉编译器s串第一个字符是`\\`，第二个字符是`n`.打印的结果就是它本身：\n\n```python\n\\n.*\n```\n\n而如果不带前缀字符`r`，即：\n\n```python\ns2 = '\\n.*'\nprint(s2)\n```\n\n解释器认为前两个字符`\\n`为转义字符，一个新行的意思，打印结果为一个换行加.*，如下所示：\n\n```python\n.*\n```\n\n[上一个例子](88.md) [下一个例子](90.md) "
},
{
"path": "md/9.md",
"content": "```markdown\n@author jackzhenguo\n@desc 转为浮点类型 \n@date 2019/2/15\n```\n#### 9 转为浮点类型 \n\n将一个整数或数值型字符串转换为浮点数\n\n```python\nIn [1]: float(3)\nOut[1]: 3.0\n```\n\n```python\nIn [1]: float('3')\nOut[1]: 3.0\n```\n\n浮点数最大值\n```python\nimport sys\n\nIn[4]: sys.float_info.max \nOut[4]: 1.7976931348623157e+308\n```\n\n正无穷大、负无穷大\n```python\nfloat('inf') # 正无穷大\nfloat('-inf') # 负无穷大\n```\n\n如果不能转化为浮点数，则会报`ValueError`:\n\n```python\nIn [2]: float('a')\n# ValueError: could not convert string to float: 'a'\n```\n\n[上一个例子](8.md) [下一个例子](10.md) \n"
},
{
"path": "md/90.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/5/15\n```\n\n### 90 什么是一个原子操作？\n\n微观世界中，如果定义原子是组成事物的最基本单元，那么就可理解为原子不能再分了。同理此处，正则的原子操作是指不能再被分割的正则表达式操作。\n\n如正则中的`+`指前面的一个原子操作出现至少1次。\n\n例如：`66+`表示第一个字符为6，第二个字符6和第三个字符+联合起来表示至少出现1次字符6，因此综合起来至少要有2个6紧邻的串才能满足此正则表达式(下面会详细讲到)。\n\n`\\w+`表示*字母数字下划线*中的任意一个字符(`\\w`指代的)至少出现1次，那么`\\w`就是一个原子操作。\n\n因此，普通字符是原子，正则中的通用字符(下面会讲到)也是原子。\n\n大家记住*原子*这个概念。\n\n[上一个例子](89.md) [下一个例子](91.md) "
},
{
"path": "md/91.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/6/3\n```\n\n### 91 怎么理解正则中的转义？\n\n正则世界中，重新定义了几个新的转义字符。\n\n一个转义字符`\\`+一个字符，转义后会改变原字符的意义，它不再是它，而是赋予一个新的含义。\n\n例如，`w`本身就是一个英文字符`w`，没有其他任何含义。但是，前面加一个转义字符 `\\` 后，含义发生重大改变，`w`它不再是`w`，而是`\\`要与`w`连在一起，被解释器解释为匹配以下字符集合中的任意一个：\n\n```python\npat = '\\w'\n```\n\n等于：\n\n```python\npat = '[0123456789\n AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz\n _]'\n```\n\n即匹配数字、大小写字母和下划线`_`字符集合中的任意一个。\n\n你看，一个通用转义字符`\\w`直接就指代上面这一大串，写法多么简便，同时在正则的世界里又经常被用到，故被称为：**通用正则字符**\n\n类似的通用正则字符还有几个，下面也会讲到。\n\n做一件事前，把规则弄清，触类旁通，相信大家理解其他几个也没问题。\n\n[上一个例子](90.md) [下一个例子](92.md) "
},
{
"path": "md/92.md",
"content": "### 92 正则最普通查找\n\n最普通查找就是需要找啥就写啥，没有使用正则的规则。如下是关于小说《灿烂千阳》中的一段话，从中找出单词`friendship`，可能出现多次：\n\n```\ns = \"\"\"\n# Mariam is only fifteen \n# when she is sent to Kabul to marry the troubled and bitter Rasheed,\n# who is thirty years her senior. \n# Nearly two decades later, \n# in a climate of growing unrest, tragedy strikes fifteen-year-old Laila, \n# who must leave her home and join Mariam's unhappy household. \n# Laila and Mariam are to find consolation in each other, \n# their friendship to grow as deep as the bond between sisters, \n# as strong as the ties between mother and daughter. \n# With the passing of time comes Taliban rule over Afghanistan, \n# the streets of Kabul loud with the sound of gunfire and bombs, \n# life a desperate struggle against starvation, brutality and fear, \n# the women's endurance tested beyond their worst imaginings. \n# Yet love can move a person to act in unexpected ways, \n# lead them to overcome the most daunting obstacles with a startling heroism. \n# In the end it is love that triumphs over death and destruction. \n# A Thousand Splendid Suns is an unforgettable portrait of a wounded country and\n# a deeply moving story of family and friendship. \n# It is a beautiful, heart-wrenching story of an unforgiving time, \n# an unlikely bond and an indestructible love.\n\"\"\"\n```\n\n使用正则前，先导入re模块，再定义正则表达式，然后使用`findall`方法找出所有匹配\n\n```python\nimport re\npat = 'friendship'\nresult = re.findall(pat,s)\nprint(result) \n\n# 共找到两处：\n# ['friendship', 'friendship']\n```\n\n以上就是使用正则的最普通例子。如果要找出前缀为grow的单词，比如可能为grows, growing 等，最普通查找实现起来就不方便。\n\n然而，借助于下面介绍的元字符、通用字符和捕获组合起来，便能应对解决复杂的匹配查找问题。\n\n[上一个例子](91.md) [下一个例子](93.md) "
},
{
"path": "md/93.md",
"content": "### 93 使用通用字符查找\n\n在正则的世界里，通用字符指帮助我们更加简便的写出匹配规则的字符。\n\n如上面文字，下面正则匹配串能找出以d开始，[a-z]表示的任意一个小写英文字符，{7}表示小写英文字符出现7次(下面情况3会说到)，也就是匹配出来的子串长度为1+7=8:\n\n```python\npat = 'd[a-z]{7}'\nresult = re.findall(pat,s)\n```\n\n匹配结果为：\n\n```python\n['daughter', 'desperat', 'daunting', 'destruct', 'destruct']\n```\n\n同理，模式串`pat = 'd[a-z]{10}'`匹配的结果为：\n\n```\n['destruction', 'destructibl']\n```\n\n模式串`pat = 'd[a-z]{11}'`匹配的结果为：\n\n```\n[ 'destructible']\n```\n\n你看，通用字符`[a-z]`使用真方便，5个字符一下就表达了所有26个小写的字符，但是注意`[a-z]`匹配26个小写字符的任意**一个**.\n\n类似功能的通用字符还包括：\n\n```\n[A-Z] 匹配大写英文字母\n[0-9] 匹配一个0-9之间的数字\n```\n\n还有更加强大的通用字符：\n\n```\n\\s 匹配空白字符，如\\n \\t \\b等\n\\w 匹配任意字母、数字、下划线 \n\\d 匹配十进制数字0-9\n```\n\n而\\S, \\W, \\D 分别对应 \\s, \\w, \\d匹配字符集的补集，例如\\S 的意思是匹配 \\s 以外的其他任意字符。\n\n\n\n[上一个例子](92.md) [下一个例子](94.md) "
},
{
"path": "md/94.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/7/3\n```\n\n### 94 使用元字符查找\n\n`元`的含义大家不妨理解为用来描述它后面事物的类，如*元类*用来创建描述类的类，*元模型*描述一个模型的模型，因此推而广之，*元字符*用来描述字符的字符。\n\n理解以上后，你再看正则中使用最普遍的一个元字符 `+`，它是用来描述前面一个原子出现次数的字符，表示前一个原子出现1次或多次都可。\n\n例如，在寻找手机靓号时，正则表达式`66+`，表示前一个原子`6`至少出现1次，因此连上第一个6，表示电话号码中至少有两个66紧邻。因此，电话号码`18612652166`、`17566665656`都满足要求，而号码`18616161616`不符合要求。\n\n类似功能的元字符，还包括如下。功能相似，不再赘述：\n\n```\n* 前面的原子重复0次、1次、多次 \n? 前面的原子重复0次或者1次 \n+ 前面的原子重复1次或多次\n{n} 前面的原子出现了 n 次\n{n,} 前面的原子至少出现 n 次\n{n,m} 前面的原子出现次数介于 n-m 之间\n```\n\n[上一个例子](93.md) [下一个例子](95.md) "
},
{
"path": "md/95.md",
"content": "## 95 捕获子串\n\n今天以我写过的《Python 60天》专栏中的一段文字，提取出里面的链接为例，阐述提取子串的实用性。\n\n先贴上文字(有删减改动)，将这段文字赋值给变量 `urls`：\n\n```\nurls = \"\"\"\n基于 Python 的包更是枝繁叶茂，遍地开花，“Tiobe 编程语言排行榜”最新统计显示 Python 是增长最快的语言。\n\n\n\n接下来，与大家，还有远在美国做 AI 博士后研究的 Alicia，一起开始我们的 60 天 Python 探索之旅吧。\n\n所有的这些考虑，都是为了让大家在短时间内掌握 Python 技术栈，多一个生存的本领。拿到理想的 Offer 后，早日过上自己想要的生活。\n\n让我们开始吧。\n\n如下，按照是否为静态/动态语言，弱类型/强类型两个维度，\n\n总结常用的语言分类。\n\n ### 四大基本语法\n\"\"\"\n```\n\n你可能很快写出如下的正则表达式：\n\n```\n# 元字符.表示匹配除\\n字符外的任意一个字符\n# 元字符*表示匹配前面一个原子0次或多次\npat = r'https:.*' \n```\n\n然后导入`re`模块，使用`findall`方法找出所有匹配：\n\n```python\nimport re\nresult = re.findall(pat,urls)\nprint(result)\n```\n\n运行结果显示如下，观察发现2个匹配，但是每个匹配链接都包括冗余字符，因此匹配错误：\n\n```\n['https://images.gitbook.cn\n/2020-02-05-014719.png)',\n\n'https://images.gitbook.cn\n/2020-02-05-080211.png) ### 四大基本语法']\n```\n\n我们再稍微优化原正则表达式为：\n\n```python\n# 添加 \\) 表示待匹配子串以右括号结尾\npat = r'https:.*\\)'\n```\n\n打印结果显示如下，结果确实好一点，但是依然包括右括号，结果还是错误的：\n\n```\n['https://images.gitbook.cn/\n2020-02-05-014719.png)', \n\n'https://images.gitbook.cn/\n2020-02-05-080211.png)']\n```\n\n所以掌握**提取**子串的技能就很重要，实现提取子串也很简单，只需把想要返回的子串加上一对括号就行，如下所示：\n\n```python\n# 把想要返回的子串外面添加一对括号\n\npat = r'(https:.*)\\)'\n```\n\n此时返回结果完全正确，无任何多余字符。想要返回的子串外面添加一对括号还有个专业叫法：**捕获**或**分组**。\n\n[上一个例子](94.md) [下一个例子](96.md) "
},
{
"path": "md/96.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/7/21\n```\n\n#### 96 贪心捕获和非贪心捕获\n\n捕获功能非常实用，使用它需要区分一点，贪婪捕获和非贪婪捕获。前者指在满足匹配模式前提下，返回包括尽可能多的字符匹配模式；后者指满足匹配条件下，尽可能少的捕获。\n\n我们伪造一个理想状况下的案例：\n\n```\nhtmlContent = \"\"\"\n 这是二级标题
这是一个段落>/p>
\n\"\"\"\n```\n\n贪心捕获使用`(.*)`，如下所示：\n\n```\npat = r\"(.*)\"\n\nresult = re.findall(pat,htmlContent)\n```\n\n结果为如下，尽可能长的捕获，而不是遇到第一个``时就终止：\n\n```\n['这是二级标题
这是一个段落>/p>
']\n```\n\n而非贪心捕获的正则表达式为`(.*?)\"`，如下：\n\n```\npat = r\"(.*?)\"\n\nresult = re.findall(pat,htmlContent)\n\nprint(result)\n```\n\n结果为两个元素，遇到第一个``时终止，然后继续捕获出第二子串：\n\n```\n['这是二级标题
', \n ' 这是一个段落>/p>']\n```\n\n以上例子仅仅用作演示两者区别，实际的html结构含有换行符等，环境比上面要复杂的多，贪心和非贪心捕获的写法可能不会导致结果不同，但是我们依然需要理解它们的区别。\n\n
[上一个例子](95.md) [下一个例子](97.md) "
},
{
"path": "md/97.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/8/3\n```\n\n#### 97 使用正则做密码安全检查\n\n密码安全要求：\n\n1)要求密码为6到20位; \n\n2)密码只包含英文字母和数字\n\n```python\npat = re.compile(r'\\w{6,20}') # 这是错误的，因为\\w通配符匹配的是字母，数字和下划线，题目要求不能含有下划线\n# 使用最稳的方法：\\da-zA-Z满足`密码只包含英文字母和数字`\npat = re.compile(r'[\\da-zA-Z]{6,20}')\n```\n选用最保险的`fullmatch`方法，查看是否整个字符串都匹配：\n```python\npat.fullmatch('qaz12') # 返回 None, 长度小于6\npat.fullmatch('qaz12wsxedcrfvtgb67890942234343434') # None 长度大于22\npat.fullmatch('qaz_231') # None 含有下划线\npat.fullmatch('n0passw0Rd')\nOut[4]: \n```\n\n[上一个例子](96.md) [下一个例子](98.md) "
},
{
"path": "md/98.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/8/8\n```\n\n#### 98 爬取百度首页标题\n\n```python\nimport re\nfrom urllib import request\n\n#爬虫爬取百度首页内容\ndata=request.urlopen(\"http://www.baidu.com/\").read().decode()\n\n#分析网页,确定正则表达式\npat=r'(.*?) '\n\nresult=re.search(pat,data)\nprint(result) \n\nresult.group() # 百度一下，你就知道\n```\n\n[上一个例子](97.md) [下一个例子](99.md) "
},
{
"path": "md/99.md",
"content": "```markdown\n@author jackzhenguo\n@desc \n@date 2019/8/12\n```\n\n#### 99 批量转化为驼峰格式(Camel)\n\n数据库字段名批量转化为驼峰格式\n\n分析过程\n\n```python\n# 用到的正则串讲解\n# \\s 指匹配： [ \\t\\n\\r\\f\\v]\n# A|B：表示匹配A串或B串\n# re.sub(pattern, newchar, string): \n# substitue代替，用newchar字符替代与pattern匹配的字符所有.\n```\n\n\n\n```python\n# title(): 转化为大写，例子：\n# 'Hello world'.title() # 'Hello World'\n```\n\n\n\n```python\n# print(re.sub(r\"\\s|_|\", \"\", \"He llo_worl\\td\"))\ns = re.sub(r\"(\\s|_|-)+\", \" \",\n 'some_database_field_name').title().replace(\" \", \"\") \n#结果： SomeDatabaseFieldName\n```\n\n\n\n```python\n# 可以看到此时的第一个字符为大写，需要转化为小写\ns = s[0].lower()+s[1:] # 最终结果\n```\n\n \n\n整理以上分析得到如下代码：\n\n```python\nimport re\ndef camel(s):\n s = re.sub(r\"(\\s|_|-)+\", \" \", s).title().replace(\" \", \"\")\n return s[0].lower() + s[1:]\n\n# 批量转化\ndef batch_camel(slist):\n return [camel(s) for s in slist]\n```\n\n测试结果：\n\n```python\ns = batch_camel(['student_id', 'student\\tname', 'student-add'])\nprint(s)\n# 结果\n['studentId', 'studentName', 'studentAdd']\n```\n\n[上一个例子](98.md) [下一个例子](100.md) "
},
{
"path": "md/batch.py",
"content": "\"\"\"\n@author jackzhenguo\n@desc 批量生成模板文件\n@tag datetime file\n@version v1.2\n@date 2020/8/23\n\"\"\"\n\nimport os\nimport calendar\nfrom datetime import date,datetime\n\ndef getEverydaySince(year,month,day,n=10):\n i = 0\n _, days = calendar.monthrange(year, month)\n while i < n: \n d = date(year,month,day) \n if day == days:\n month,day = month+1,0\n _, days = calendar.monthrange(year, month)\n if month == 13:\n year,month = year+1,1\n _, days = calendar.monthrange(year, month)\n yield d\n day += 1\n i += 1\n\n\ndef batchCreate(ps='.md',start=100,n=100,path='.',year=2020,month=2,day=1):\n \n for i,day in zip(range(start,start+n),\\\n getEverydaySince(year,month,day,n) \\\n ):\n with open(path+'/'+str(i)+ps,'w') as fw:\n \n fw.write(\"\"\"\n```markdown\n@author jackzhenguo\n@desc\n@tag\n@version \n@date {}\n```\n\t\t \"\"\".format(datetime.strftime(day,'%Y/%m/%d'))\\\n\t\t )\n print(day)\n print('done')\n"
},
{
"path": "script/add_nav.py",
"content": "# function: give each *.md example to a navigation in bottom of file\n# author: zhenguo\n# date: 2021.2.27\n# version: 1.0\n\nimport os\n\nfor file in os.listdir('../md'):\n if os.path.splitext(file)[-1] == '.md':\n with open('../md/' + file, 'a') as f:\n file_name = os.path.splitext(file)[0]\n try:\n c = '\\n\\n[上一个例子](%s.md) [下一个例子](%s.md) ' % (str(int(file_name) - 1), str(int(file_name) + 1))\n f.write(c)\n print('文件%s写入成功' % (file,))\n except:\n print(ex)\n"
}
]