python高阶函数学习.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#--*encoding:utf-8--*\n",
    "#高阶函数\n",
    "#map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。\n",
    "def f(x):\n",
    "    return x*x\n",
    "r=map(f,[1,2,3])\n",
    "list(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算\n",
    "from functools import reduce\n",
    "def add(x, y):\n",
    "    return x + y\n",
    "\n",
    "reduce(add, [1, 3, 5, 7, 9])\n",
    "#返回1+2+3+4+5=25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "123"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# str to int\n",
    "from functools import reduce\n",
    "\n",
    "DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}\n",
    "\n",
    "def char2num(s):\n",
    "    return DIGITS[s]\n",
    "\n",
    "def str2int(s):\n",
    "    return reduce(lambda x, y: x * 10 + y, map(char2num, s))\n",
    "str2int(\"123\")\n",
    "\n",
    "#解释\n",
    "#str2int(\"123\")=reduce(lambda x, y: x * 10 + y, map(char2num, “123”))\n",
    "#123转换为数字1 2 3\n",
    "# 1*10+2=12 12*10+3=123"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python内建的filter()函数用于过滤序列。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A', 'B', 'C']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "#把一个序列中的空字符串删掉，可以这么写：\n",
    "\n",
    "def not_empty(s):\n",
    "    return s and s.strip()\n",
    "\n",
    "list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 用filter求素数\n",
    "![title](img/sushu.png)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n",
      "13\n",
      "17\n",
      "19\n",
      "23\n",
      "29\n",
      "31\n",
      "37\n",
      "41\n",
      "43\n",
      "47\n",
      "53\n",
      "59\n",
      "61\n",
      "67\n",
      "71\n",
      "73\n",
      "79\n",
      "83\n",
      "89\n",
      "97\n"
     ]
    }
   ],
   "source": [
    "def _odd_iter():\n",
    "    n = 1\n",
    "    while True:\n",
    "        n = n + 2\n",
    "        yield n\n",
    "def _not_divisible(n):\n",
    "    return lambda x: x % n > 0\n",
    "def primes():\n",
    "    yield 2\n",
    "    it = _odd_iter() # 初始序列\n",
    "    while True:\n",
    "        n = next(it) # 返回序列的第一个数\n",
    "        yield n\n",
    "        it = filter(_not_divisible(n), it) # 构造新序列\n",
    "\n",
    "# 打印1000以内的素数:\n",
    "for n in primes():\n",
    "    if n < 100:\n",
    "        print(n)\n",
    "    else:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 回数\n",
    "回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用filter()筛选出回数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99]\n"
     ]
    }
   ],
   "source": [
    "#way 1\n",
    "def is_palindrome(n):\n",
    "    nn = str(n) #转成字符串\n",
    "    return nn == nn[::-1] #反转字符串并对比原字符串返回true/false\n",
    "print (list(filter(is_palindrome,range(1,100))))\n",
    "#way 2\n",
    "print (list(filter(lambda n : str(n)==str(n)[::-1],range(1,100)))) #str(n)同上"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "@property装饰器就是负责把一个方法变成属性调用的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "60\n"
     ]
    }
   ],
   "source": [
    "class Student(object):\n",
    "\n",
    "    @property\n",
    "    def score(self):\n",
    "        return self._score\n",
    "\n",
    "    @score.setter\n",
    "    def score(self, value):\n",
    "        if not isinstance(value, int):\n",
    "            raise ValueError('score must be an integer!')\n",
    "        if value < 0 or value > 100:\n",
    "            raise ValueError('score must between 0 ~ 100!')\n",
    "        self._score = value\n",
    "s = Student()\n",
    "s.score = 60 # OK，实际转化为s.set_score(60)\n",
    "print(s.score) # OK，实际转化为s.get_score()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "exercise",
   "language": "python",
   "name": "exercise"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}