0416_Map_Filter_Reduce.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# #https://www.learnpython.org/en/Map%2C_Filter%2C_Reduce\n",
    "\n",
    "# Map, Filter, Reduce：map関数、filter関数、reduce関数\n",
    "# Map, Filter, and Reduce are paradigms of functional programming. \n",
    "# They allow the programmer (you) to write simpler, shorter code, without necessarily needing to bother about intricacies like loops and branching.\n",
    "\n",
    "# Essentially, these three functions allow you to apply a function across a number of iterables, in one fell swoop. \n",
    "# map and filter come built-in with Python (in the __builtins__ module) and require no importing. \n",
    "# reduce, however, needs to be imported as it resides in the functools module. \n",
    "# Let's get a better understanding of how they all work, starting with map.\n",
    "\n",
    "# map、filter、そしてreduce関数は、関数型プログラミングにおいて規範となる「物の見方や捉え方」です。\n",
    "# map、filter、そしてreduce関数はプログラミングをする人(あなた)にとってシンプルで短いコードをloopやbranch(分岐)を気にすることなく書くことができます。\n",
    "\n",
    "# 本質的に、これら3つの関数を使うと、一度に複数のイテラブルに関数を適用できます。\n",
    "# mapとfilterはPythonに組み込まれており（__builtins__ module内）、インポートする必要はありません。\n",
    "# ただし、reduceはfunctoolsモジュールにあるため、インポートする必要があります。それでは、mapの解説から始めて、それぞれの動作をより深く理解していきましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Map\n",
    "# The map() function in python has the following syntax: Pythonのmap()関数は次の構文を持っています：\n",
    "\n",
    "map(func, *iterables)\n",
    "\n",
    "# Where func is the function on which each element in iterables (as many as they are) would be applied on. \n",
    "# Notice the asterisk(*) on iterables? \n",
    "# It means there can be as many iterables as possible, in so far func has that exact number as required input arguments. \n",
    "# Before we move on to an example, it's important that you note the following:\n",
    "\n",
    "# In Python 2, the map() function returns a list. In Python 3, however, the function returns a map object which is a generator object. \n",
    "# To get the result as a list, the built-in list() function can be called on the map object. i.e. list(map(func, *iterables))\n",
    "# The number of arguments to func must be the number of iterables listed.\n",
    "# Let's see how these rules play out with the following examples.\n",
    "\n",
    "# Say I have a list (iterable) of my favourite pet names, all in lower case and I need them in uppercase. \n",
    "# Traditonally, in normal pythoning, I would do something like this:\n",
    "\n",
    "# ここで、func　はiterablesの各要素（いくつあっても良いです）に適用される関数です。\n",
    "# iterablesにアスタリスク（*）が付いているのがわかりますね？\n",
    "# これは、funcに必要な入力引数の数だけ、任意の数のイテラブルを指定できることを意味します。例に進む前に、次の点に注意することが重要です：\n",
    "\n",
    "# Python 2では、map()関数はリストを返します。\n",
    "# 一方、Python 3では、この関数はジェネレーターオブジェクトであるmap objectを返します。\n",
    "# 結果をリストとして取得するには、組み込みのlist()関数をマップオブジェクトに対して呼び出すことができます。\n",
    "# つまり、list(map(func, *iterables))のようにします。\n",
    "# funcへの引数の数は、リストされたiterablesの数と一致する必要があります。\n",
    "# これらのルールが次の例でどのように機能するかを見てみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#(文字数の多さに圧倒されています)\n",
    "\n",
    "# Say I have a list (iterable) of my favourite pet names, all in lower case and I need them in uppercase. \n",
    "# Traditonally, in normal pythoning, I would do something like this:\n",
    "\n",
    "# さて、私の大好きなペットの名前が入っているiterableなリストを作りました。\n",
    "# 全て小文字で、私はそれを大文字にしたいです。\n",
    "# Pythonの伝統的なやり方だと、こんなふうにします。\n",
    "\n",
    "my_pets = ['alfred', 'tabitha', 'william', 'arla']\n",
    "uppered_pets = []\n",
    "\n",
    "for pet in my_pets:\n",
    "    pet_ = pet.upper()\n",
    "    uppered_pets.append(pet_)\n",
    "\n",
    "print(uppered_pets)\n",
    "\n",
    "# Which would then output ['ALFRED', 'TABITHA', 'WILLIAM', 'ARLA']\n",
    "# これで全部大文字に出来ましたね。\n",
    "\n",
    "# ポイント\n",
    ".upper()を使うと、全部大文字にすることができる"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# With map() functions, it's not only easier, but it's also much more flexible. I simply do this:\n",
    "# map関数を使うと、そこまで簡単ではないのですがもっと柔軟にできます。\n",
    "# 今回はこんなふうに書きます。\n",
    "\n",
    "# Python 3\n",
    "my_pets = ['alfred', 'tabitha', 'william', 'arla']\n",
    "\n",
    "uppered_pets = list(map(str.upper, my_pets)) #さっきと異なりmap()の中に str.upper, my_pets　を入れ大文字にしてる\n",
    "\n",
    "print(uppered_pets)\n",
    "\n",
    "# Which would also output the same result. \n",
    "# これでさっきと同じ結果が出ますね。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Note that using the defined map() syntax above, func in this case is str.upper and iterables is the my_pets list -- just one iterable. \n",
    "# Also note that we did not call the str.upper function (doing this: str.upper()), as the map function does that for us on each element in the my_pets list.\n",
    "\n",
    "# What's more important to note is that the str.upper function requires only one argument by definition and so we passed just one iterable to it. \n",
    "# So, if the function you're passing requires two, or three, or n arguments, then you need to pass in two, three or n iterables to it. \n",
    "# Let me clarify this with another example.\n",
    "\n",
    "# ここで注意して欲しいのは、\n",
    "# 上記で定義したmap()の構文を使用すると、この場合のfuncはstr.upperで、iterablesはmy_petsリスト（単一のイテラブル）ということです。\n",
    "# また、map関数がmy_petsリストの各要素に対して行うため、str.upper関数を呼び出していないこと（str.upper()のようにしていないこと）にも注意してください。\n",
    "\n",
    "# さらに重要なのは、\n",
    "# str.upper関数は定義上1つの引数しか必要としないため、1つのイテラブルのみを渡したことです。\n",
    "# つまり、渡す関数が2つ、3つ、またはn個の引数を必要とする場合は、2つ、3つ、またはn個のイテラブルを渡す必要があります。\n",
    "# 別の例でこれを明確にしましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Say I have a list of circle areas that I calculated somewhere, all in five decimal places. \n",
    "# And I need to round each element in the list up to its position decimal places, \n",
    "# meaning that I have to round up the first element in the list to one decimal place, \n",
    "# the second element in the list to two decimal places, the third element in the list to three decimal places, etc. \n",
    "# With map() this is a piece of cake. Let's see how.\n",
    "\n",
    "# Python already blesses us with the round() built-in function that takes two arguments \n",
    "# -- the number to round up and the number of decimal places to round the number up to. \n",
    "# So, since the function requires two arguments, we need to pass in two iterables.\n",
    "\n",
    "# 例えば私がどこかで計算した円の面積のリストを持っていて、その結果のすべてが小数点以下5桁になっているとします。\n",
    "# そして、リストの各要素を小数点以下の桁数に丸める必要があるとします。\n",
    "# ということは、リストの最初の要素を小数点以下1桁に丸め、2番目の要素を小数点以下2桁に丸め、3番目の要素を小数点以下3桁に丸めるなどです。\n",
    "# map()を使えば、とても簡単にできるのでやってみましょう。\n",
    "\n",
    "# Pythonには、丸める数値と丸める小数点以下の桁数の2つの引数を取るround()組み込み関数があります。\n",
    "# したがって、この関数は2つの引数を必要とするので、2つのイテラブルを渡す必要があります。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "\n",
    "circle_areas = [3.56773, 5.57668, 4.00914, 56.24241, 9.01344, 32.00013]\n",
    "\n",
    "result = list(map(round, circle_areas, range(1, 7)))\n",
    "\n",
    "print(result)\n",
    "\n",
    "#[3.6, 5.58, 4.009, 56.2424, 9.01344, 32.00013]が出力される"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# See the beauty of map()? Can you imagine the flexibility this evokes?\n",
    "# The range(1, 7) function acts as the second argument to the round function (the number of required decimal places per iteration). \n",
    "# So as map iterates through circle_areas, during the first iteration, the first element of circle_areas, \n",
    "# 3.56773 is passed along with the first element of range(1,7), 1 to round, making it effectively become round(3.56773, 1). \n",
    "# During the second iteration, the second element of circle_areas, 5.57668 along with the second element of range(1,7), 2 is passed to round making it translate to round(5.57668, 2). \n",
    "# This happens until the end of the circle_areas list is reached.\n",
    "\n",
    "# map()の美しさがわかりますか？この柔軟性がもたらすものを想像できますか？\n",
    "\n",
    "# range(1, 7)関数は、round関数への2番目の引数（イテレーションごとに必要な小数点以下の桁数）として機能します。\n",
    "# なので、mapがcircle_areasを反復処理する際、最初のイテレーションではcircle_areasの最初の要素である3.56773がrange(1,7)の最初の要素である1とともにroundに渡され、\n",
    "# 実質的にround(3.56773, 1)になります。2番目のイテレーションでは、circle_areasの2番目の要素である5.57668とrange(1,7)の2番目の要素である2がroundに渡され、\n",
    "# round(5.57668, 2)になります。これはcircle_areasリストの最後に到達するまで続きます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Odaさんのコメント\n",
    "#適当な気持ちを話すと、\n",
    "# for や while というループを使ってきたと思うのですが、あれはめちゃくちゃ威力が高いんです。\n",
    "# 大まかに「while が1つと、あと条件分岐があれば、どんなプログラムでも書ける」という定理があるくらい、while 1 つの威力は高いです。\n",
    "# 威力があるというのは、悪い点もあります。要するに、色々なことができるということは、読んでいる方としては、何をされるか分からないのです。\n",
    "# そこで、map や reduce など、ループからできることが制限されたものを用意することで、理解しやすく扱いやすくするのが、ここの話です。\n",
    "# あとは、考えるときにも考えやすいです。例えば、下とか。\n",
    "# ⁠leetcode_colorbox⁠"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# I'm sure you're wondering: \"What if I pass in an iterable less than or more than the length of the first iterable? \n",
    "# That is, what if I pass range(1, 3) or range(1, 9999) as the second iterable in the above function\".\n",
    "# And the answer is simple: nothing! Okay, that's not true. \n",
    "# \"Nothing\" happens in the sense that the map() function will not raise any exception, \n",
    "# it will simply iterate over the elements until it can't find a second argument to the function,\n",
    "# at which point it simply stops and returns the result.\n",
    "\n",
    "# 多分あなたは「もし最初のイテラブルの長さより短いまたは長いイテラブルを渡すとどうなるだろう？\n",
    "# 上記の関数の2番目のイテラブルとしてrange(1, 3)またはrange(1, 9999)を渡すとどうなるだろう？」と疑問に思っているかもしれません。\n",
    "\n",
    "# 答えは簡単です：何もありません！Okay厳密には本当ではないんですが「何もない」というのは、map()関数が例外を発生させないという意味です。\n",
    "# 単に、関数への2番目の引数が見つからなくなるまで要素を繰り返し処理し、その時点で単に停止して結果を返します。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# So, for example, if you evaluate result = list(map(round, circle_areas, range(1, 3))), \n",
    "# you won't get any error even as the length of circle_areas and the length of range(1, 3) differ. \n",
    "# Instead, this is what Python does: It takes the first element of circle_areas and the first element of range(1,3) and passes it to round. \n",
    "# round evaluates it then saves the result. Then it goes on to the second iteration, second element of circle_areas and second element of range(1,3), round saves it again. \n",
    "# Now, in the third iteration (circle_areas has a third element), Python takes the third element of circle_areas and then tries to take the third element of range(1,3) but since range(1,3) does not have a third element, \n",
    "# Python simply stops and returns the result, which in this case would simply be [3.6, 5.58].\n",
    "\n",
    "# Go ahead, try it.\n",
    "\n",
    "# たとえば、result = list(map(round, circle_areas, range(1, 3)))を評価しても、\n",
    "# circle_areasの長さとrange(1, 3)の長さが異なっていてもエラーは発生しません。\n",
    "\n",
    "# 代わりに、Pythonは次のように動作します：circle_areasの最初の要素とrange(1,3)の最初の要素を取得してroundに渡します。\n",
    "# roundはそれを評価して結果を保存します。次に2番目のイテレーションに進み、circle_areasの2番目の要素とrange(1,3)の2番目の要素を取得し、roundが再び保存します。\n",
    "# さて、3番目のイテレーション（circle_areasは3番目の要素を持つ）では、Pythonはcircle_areasの3番目の要素を取得し、range(1,3)の3番目の要素を取得しようとしますが、\n",
    "# range(1,3)は3番目の要素を持たないため、Pythonは単に停止して結果を返します。\n",
    "# この場合、結果は単に[3.6, 5.58]になります。\n",
    "\n",
    "# ぜひ試してみてください。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "\n",
    "circle_areas = [3.56773, 5.57668, 4.00914, 56.24241, 9.01344, 32.00013]\n",
    "\n",
    "result = list(map(round, circle_areas, range(1, 3)))\n",
    "\n",
    "print(result)\n",
    "\n",
    "#[3.6, 5.58] が出力される"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The same thing happens if circle_areas is less than the length of the second iterable. \n",
    "# Python simply stops when it can't find the next element in one of the iterables.\n",
    "\n",
    "# To consolidate our knowledge of the map() function, we are going to use it to implement our own custom zip() function. \n",
    "# The zip() function is a function that takes a number of iterables and then creates a tuple containing each of the elements in the iterables. \n",
    "# Like map(), in Python 3, it returns a generator object, which can be easily converted to a list by calling the built-in list function on it. \n",
    "# Use the below interpreter session to get a grip of zip() before we create ours with map()\n",
    "\n",
    "# circle_areasが2番目のイテラブルの長さより短い場合も同じことが起こります。\n",
    "# Pythonは、いずれかのイテラブルで次の要素が見つからなくなると単に停止します。\n",
    "\n",
    "# map()関数の知識を確実にするために、map()を使って独自のカスタムzip()関数を実装します。\n",
    "# zip()関数は、複数のイテラブルを取得し、各イテラブルの要素を含むタプルを作成する関数です。\n",
    "# map()と同様に、Python 3では、ジェネレーターオブジェクトを返します。\n",
    "# これは、組み込みのlist関数を呼び出すことで簡単にリストに変換できます。\n",
    "# 以下のインタープリターセッションを使用して、map()で独自のzip()を作成する前に、zip()の理解を深めてください。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "\n",
    "my_strings = ['a', 'b', 'c', 'd', 'e']\n",
    "my_numbers = [1, 2, 3, 4, 5]\n",
    "\n",
    "results = list(zip(my_strings, my_numbers))\n",
    "\n",
    "print(results)\n",
    "\n",
    "#[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)] が出力される"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# zip関数という新しい関数が出てきたので、調べます。\n",
    "zip()#関数: リストやタプルなどの複数の配列をまとめるための関数\n",
    "#https://qiita.com/kubochiro/items/5daedd51654a8155bc06"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As a bonus, can you guess what would happen in the above session if my_strings and my_numbers are not of the same length? No? try it! \n",
    "# Change the length of one of them.\n",
    "\n",
    "# ここでおまけ情報です。\n",
    "# 上記のセッションでmy_stringsとmy_numbersの長さが同じでない場合に何が起こるかを推測できますか？できないって？\n",
    "# 試してみてください！どちらかの長さを変更してみてください。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#まず、　my_strings = ['a', 'b', 'c', 'd', 'e']　に1つ数字を足してみます。\n",
    "my_strings = ['a', 'b', 'c', 'd', 'e','f']\n",
    "my_numbers = [1, 2, 3, 4, 5]\n",
    "\n",
    "results = list(zip(my_strings, my_numbers))\n",
    "\n",
    "print(results)\n",
    "\n",
    "#[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)] が出力されました。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#次は　my_numbers = [1, 2, 3, 4, 5]　に1つ数字を足してみます。\n",
    "my_strings = ['a', 'b', 'c', 'd', 'e']\n",
    "my_numbers = [1, 2, 3, 4, 5,6]\n",
    "\n",
    "results = list(zip(my_strings, my_numbers))\n",
    "\n",
    "print(results)\n",
    "\n",
    "#[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)] が出力されました。 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# my_stringsとmy_numbersの長さが同じでない場合、\n",
    "# 小さい方の数字(列？)の組み合わせしか出てこないことがわかりました。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Onto our own custom zip() function!\n",
    "# それではzip()関数に移りましょう！\n",
    "\n",
    "# Python 3\n",
    "\n",
    "my_strings = ['a', 'b', 'c', 'd', 'e']\n",
    "my_numbers = [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "results = list(map(lambda x, y: (x, y), my_strings, my_numbers))\n",
    "\n",
    "print(results)\n",
    "\n",
    "#[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)] が出力される"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Just look at that! We have the same result as zip.\n",
    "\n",
    "# Did you also notice that I didn't even need to create a function using the def my_function() standard way? That's how flexible map(),\n",
    "# and Python in general, is! I simply used a lambda function. \n",
    "# This is not to say that using the standard function definition method (of def function_name()) isn't allowed, it still is.\n",
    "# I simply preferred to write less code (be \"Pythonic\").\n",
    "\n",
    "# 見てください!zipと同じ結果が得られました。\n",
    "\n",
    "# def my_function()という標準的な方法で関数を作成する必要がなかったことにも気付きましたか？\n",
    "# それがmap()の柔軟性であり、Pythonの柔軟性なのです！単にlambda関数を使用しました。\n",
    "# これは、標準的な関数定義方法（def function_name()）の使用が許可されていないということではありません。\n",
    "# それでも可能です。単に、より少ないコードを書きたかったのです（「Pythonic」であるために）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# えっPythonicってなに　となったので、調べます。\n",
    "# https://www.pythonic-exam.com/pythonic\n",
    "\n",
    "# A common neologism in the Python community is pythonic, which can have a wide range of meanings related to program style.\n",
    "# To say that code is pythonic is to say that it uses Python idioms well, that it is natural or shows fluency in the language, \n",
    "# that it conforms with Python’s minimalist philosophy and emphasis on readability.\n",
    "# In contrast, code that is difficult to understand or reads like a rough transcription from another programming language is called unpythonic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#次はfilter関数についてです。\n",
    "\n",
    "# Filter\n",
    "# While map() passes each element in the iterable through a function and returns the result of all elements having passed through the function, \n",
    "# filter(), first of all, requires the function to return boolean values (true or false) and then passes each element in the iterable through the function, \n",
    "# \"filtering\" away those that are false. It has the following syntax:\n",
    "\n",
    "# filter(func, iterable)\n",
    "\n",
    "# The following points are to be noted regarding filter():\n",
    "\n",
    "# Unlike map(), only one iterable is required.\n",
    "# The func argument is required to return a boolean type. \n",
    "# If it doesn't, filter simply returns the iterable passed to it. \n",
    "# Also, as only one iterable is required, it's implicit that func must only take one argument.\n",
    "# filter passes each element in the iterable through func and returns only the ones that evaluate to true. \n",
    "# I mean, it's right there in the name -- a \"filter\".\n",
    "# Let's see some examples\n",
    "\n",
    "# map()が各要素を関数に渡し、すべての要素が関数を通過した結果を返すのに対し、filter()は、まず第一に関数がブール値（trueまたはfalse）を返すことを要求し、\n",
    "# 次に各要素をイテラブルの関数に渡し、falseのものを「フィルタリング」して除外します。次のような構文を持っています：\n",
    "\n",
    "filter(func, iterable)\n",
    "\n",
    "filter()#に関して、次の点に注意する必要があります：\n",
    "\n",
    "# map()とは異なり、1つのイテラブルのみが必要です。\n",
    "# func引数はブール型を返す必要があります。そうでない場合、filterは単に渡されたiterableを返します。\n",
    "# また、1つのイテラブルのみが必要なため、funcは1つの引数しか取らないことが暗黙的です。\n",
    "# filterは、イテラブル内の各要素をfuncに渡し、trueと評価されるもの「のみ」を返します。つまり、名前のとおり「フィルター」なのです。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's see some examples\n",
    "\n",
    "# The following is a list (iterable) of the scores of 10 students in a Chemistry exam. \n",
    "# Let's filter out those who passed with scores more than 75...using filter.\n",
    "\n",
    "# 以下は、化学の試験を受けた10人の生徒の点数のリスト（iterable）です。\n",
    "# filterを使用して、75点以上で合格した人をフィルタリングしてみましょう。\n",
    "\n",
    "# Python 3\n",
    "scores = [66, 90, 68, 59, 76, 60, 88, 74, 81, 65]\n",
    "\n",
    "def is_A_student(score):\n",
    "    return score > 75\n",
    "\n",
    "over_75 = list(filter(is_A_student, scores))\n",
    "\n",
    "print(over_75)\n",
    "\n",
    "# [90, 76, 88, 81] が出力される"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The next example will be a palindrome detector. \n",
    "# A \"palindrome\" is a word, phrase, or sequence that reads the same backwards as forwards. \n",
    "# Let's filter out words that are palindromes from a tuple (iterable) of suspected palindromes. \n",
    "\n",
    "# 次の例は、回文検出器です。\n",
    "# 「回文」とは、前から読んでも後ろから読んでも同じになる単語、フレーズ、またはシーケンスのことです。\n",
    "# 回文の疑いがあるタプル（iterable）から回文である単語をフィルタリングしてみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "dromes = (\"demigod\", \"rewire\", \"madam\", \"freer\", \"anutforajaroftuna\", \"kiosk\")\n",
    "\n",
    "palindromes = list(filter(lambda word: word == word[::-1], dromes))\n",
    "\n",
    "print(palindromes)\n",
    "\n",
    "#['madam', 'anutforajaroftuna'] が出力される"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "word == word[::-1]\n",
    "\n",
    "# 回文を調べるためのコードってどうすればいいんだろうと思ったのですが、\n",
    "# ↑が出てきて学習を始めたばかりのときに復習したメモを思い出しました\n",
    "# ⁠leetcode_takasaan⁠"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Odaさんのコメント\n",
    "#たとえば、map と map は融合できます。\n",
    "a = [2, 3, 5, 7, 11, 13, 17, 19]\n",
    "b = map(str, a)\n",
    "c = map(len, b)\n",
    "print(list(c))\n",
    "map(lambda x: len(str(x)), a)\n",
    "\n",
    "[1, 1, 1, 1, 2, 2, 2, 2]\n",
    "\n",
    "#というわけで、for とかで書いていたとしても、なんかそういうことを考えてコードを書いているんですね。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 最後に、reduce()です。\n",
    "# Reduce\n",
    "# reduce applies a function of two arguments cumulatively to the elements of an iterable, optionally starting with an initial argument. \n",
    "# It has the following syntax:\n",
    "\n",
    "reduce(func, iterable[, initial])\n",
    "\n",
    "# Where func is the function on which each element in the iterable gets cumulatively applied to, \n",
    "# and initial is the optional value that gets placed before the elements of the iterable in the calculation, \n",
    "# and serves as a default when the iterable is empty. The following should be noted about reduce(): \n",
    "\n",
    "# 1. func requires two arguments, the first of which is the first element in iterable (if initial is not supplied) and the second element in iterable. \n",
    "# If initial is supplied, then it becomes the first argument to func and the first element in iterable becomes the second element. \n",
    "\n",
    "# 2. reduce \"reduces\" (I know, forgive me) iterable into a single value.\n",
    "\n",
    "# As usual, let's see some examples.\n",
    "\n",
    "# Let's create our own version of Python's built-in sum() function. \n",
    "# The sum() function returns the sum of all the items in the iterable passed to it.\n",
    "\n",
    "# As usual, let's see some examples.\n",
    "\n",
    "# Let's create our own version of Python's built-in sum() function. \n",
    "# The sum() function returns the sum of all the items in the iterable passed to it.\n",
    "\n",
    "# reduceは、イテラブルの要素に累積的に2つの引数の関数を適用し、オプションで初期値から始めます。\n",
    "# 次のような構文を持っています：\n",
    "\n",
    "reduce(func, iterable[, initial])\n",
    "\n",
    "# ここで、funcはiterableの各要素に累積的に適用される関数であり、initialは計算においてイテラブルの要素の前に置かれるオプションの値であり、\n",
    "# イテラブルが空の場合のデフォルトとして機能します。reduce()について注意すべき点は次のとおりです：\n",
    "\n",
    "# funcは2つの引数を必要とします。\n",
    "\n",
    "# 1つ目はiterableの最初の要素（initialが指定されていない場合）で、\n",
    "# 2つ目はiterableの2番目の要素です。\n",
    "# initialが指定されている場合、それがfuncへの最初の引数になり、iterableの最初の要素が2番目の引数になります。\n",
    "# reduceはiterableを単一の値に「縮小」します。\n",
    "\n",
    "# いつものように、いくつか例を見てみましょう。\n",
    "# Pythonの組み込みsum()関数の独自バージョンを作成してみましょう。\n",
    "# sum()関数は、渡されたイテラブル内のすべての項目の合計を返します。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "from functools import reduce\n",
    "\n",
    "numbers = [3, 4, 6, 9, 34, 12]\n",
    "\n",
    "def custom_sum(first, second):\n",
    "    return first + second\n",
    "\n",
    "result = reduce(custom_sum, numbers)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The result, as you'll expect is 68.\n",
    "# So, what happened?\n",
    "\n",
    "# As usual, it's all about iterations: reduce takes the first and second elements in numbers and passes them to custom_sum respectively. \n",
    "# custom_sum computes their sum and returns it to reduce. \n",
    "# reduce then takes that result and applies it as the first element to custom_sum and takes the next element (third) in numbers as the second element to custom_sum.\n",
    "# It does this continuously (cumulatively) until numbers is exhausted.\n",
    "\n",
    "# Let's see what happens when I use the optional initial value.\n",
    "\n",
    "# ご想像のとおり、結果は68です。\n",
    "# 何が起こったのでしょうか？\n",
    "\n",
    "# いつものように、すべてはイテレーションに関係しています：reduceはnumbersの最初と2番目の要素を取り、それぞれcustom_sumに渡します。\n",
    "# custom_sumはそれらの合計を計算してreduceに返します。\n",
    "# 次に、reduceはその結果をcustom_sumへの最初の要素として適用し、numbersの次の要素（3番目）をcustom_sumへの2番目の要素として取ります。\n",
    "# numbersが尽きるまでこれを継続的に（累積的に）行います。\n",
    "\n",
    "# オプションのinitial値を使用するとどうなるか見てみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 3\n",
    "from functools import reduce\n",
    "\n",
    "numbers = [3, 4, 6, 9, 34, 12]\n",
    "\n",
    "def custom_sum(first, second):\n",
    "    return first + second\n",
    "\n",
    "result = reduce(custom_sum, numbers, 10)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The result, as you'll expect, is 78 because reduce, initially, uses 10 as the first argument to custom_sum.\n",
    "# That's all about Python's Map, Reduce, and Filter. \n",
    "# Try on the below exercises to help ascertain your understanding of each function.\n",
    "\n",
    "# ご想像のとおり、結果は78です。\n",
    "# これは、reduceが最初に10をcustom_sumへの最初の引数として使用するためです。\n",
    "# これがPythonのMap、Reduce、Filterに関するすべてです。以下のエクササイズで各関数の理解度を確認してみてください。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Exercise\n",
    "In this exercise, you'll use each of map, filter, and reduce to fix broken code.\n",
    "\n",
    "from functools import reduce \n",
    "\n",
    "# Use map to print the square of each numbers rounded　#mapを使ってそれぞれの数字を丸めて小数点以下3桁で出力する\n",
    "# to three decimal places　　　　　　　　　　　　　　　　　 \n",
    "my_floats = [4.35, 6.09, 3.25, 9.77, 2.16, 8.88, 4.59]\n",
    "\n",
    "# Use filter to print only the names that are less than #filterを使用して、7文字以下の名前のみを出力する\n",
    "# or equal to seven letters\n",
    "my_names = [\"olumide\", \"akinremi\", \"josiah\", \"temidayo\", \"omoseun\"]\n",
    "\n",
    "# Use reduce to print the product of these numbers #reduceを使用して、これらの数値の積を出力する\n",
    "my_numbers = [4, 6, 9, 23, 5]\n",
    "\n",
    "# Fix all three respectively.  #それぞれを修正する\n",
    "map_result = list(map(lambda x: x, my_floats))\n",
    "filter_result = list(filter(lambda name: name, my_names, my_names))\n",
    "reduce_result = reduce(lambda num1, num2: num1 * num2, my_numbers, 0)\n",
    "\n",
    "print(map_result)\n",
    "print(filter_result)\n",
    "print(reduce_result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#今日習った3つの関数　map, filter, reduceを使って、壊れたコードを直します\n",
    "#まずどんなエラーが出ているか見たいです。\n",
    "\n",
    "# これをVS codeで実行すると、以下のエラーが出る\n",
    "\n",
    "TypeError                                 Traceback (most recent call last)\n",
    "Cell In[1], line 16\n",
    "     14 # Fix all three respectively.\n",
    "     15 map_result = list(map(lambda x: x, my_floats))\n",
    "---> 16 filter_result = list(filter(lambda name: name, my_names, my_names))\n",
    "     17 reduce_result = reduce(lambda num1, num2: num1 * num2, my_numbers, 0)\n",
    "     19 print(map_result)\n",
    "\n",
    "TypeError: filter expected 2 arguments, got 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# サイト上で実行してみると、このエラーが出る\n",
    "\n",
    "Traceback (most recent call last):\n",
    "  File \"script.py\", line 16, in <module>\n",
    "    filter_result = list(filter(lambda name: name, my_names, my_names))\n",
    "TypeError: filter expected 2 arguments, got 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#それぞれのコードの期待される答えを想像してみるのが良いのではないかと思いました\n",
    "#mapを使ってそれぞれの数字を丸めて小数点以下3桁で出力する\n",
    "#これは元々の数字がないので、どうやったら小数点以下3桁にできるのか？？なのでちょっと後で考えます\n",
    "my_floats = [4.35, 6.09, 3.25, 9.77, 2.16, 8.88, 4.59]\n",
    "map_result = list(map(lambda x: x, my_floats))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#こちらに関しては、7文字か7文字以下の名前のみなので、[\"olumide\",'josiah', 'omoseun']　が出力されるべき、と思いました\n",
    "#ここだけかろうじて、7文字かそれ以下という指示に書き換えないといけないので <= 7 をどこかに使うんだろうな、とだけ思えました\n",
    "\n",
    "#filterを使用して、7文字か7文字以下の名前のみを出力する\n",
    "my_names = [\"olumide\", \"akinremi\", \"josiah\", \"temidayo\", \"omoseun\"]\n",
    "filter_result = list(filter(lambda name: name, my_names, my_names))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#こちらに関しては、4, 6, 9, 23, 5をかけた数 = 24840　が出力されるのが正しいのかなと思いました\n",
    "\n",
    "#reduceを使用して、これらの数値の積を出力する\n",
    "my_numbers = [4, 6, 9, 23, 5]\n",
    "reduce_result = reduce(lambda num1, num2: num1 * num2, my_numbers, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#答えをみました\n",
    "#### Map\n",
    "from functools import reduce \n",
    "\n",
    "my_floats = [4.35, 6.09, 3.25, 9.77, 2.16, 8.88, 4.59]\n",
    "my_names = [\"olumide\", \"akinremi\", \"josiah\", \"temidayo\", \"omoseun\"]\n",
    "my_numbers = [4, 6, 9, 23, 5]\n",
    "\n",
    "map_result = list(map(lambda x: round(x ** 2, 3), my_floats))\n",
    "filter_result = list(filter(lambda name: len(name) <= 7, my_names))\n",
    "reduce_result = reduce(lambda num1, num2: num1 * num2, my_numbers)\n",
    "\n",
    "print(map_result)\n",
    "print(filter_result)\n",
    "print(reduce_result)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}