One place for hosting & domains

      Python

      How To Use the all, any, max, and min Functions in Python


      The author selected the COVID-19 Relief Fund to receive a donation as part of the Write for DOnations program.

      Introduction

      Python includes a number of built-in functions—these are global Python functions that can be called from any Python code without importing additional modules. For example, you can always call the print built-in function to output text.

      Several of the built-in functions (all, any, max, and min among them) take iterables of values as their argument and return a single value. An iterable is a Python object that can be “iterated over”, that is, it will return items in a sequence such that you can use it in a for loop. Built-in functions are useful when, for example, you want to determine if all or any of the elements in a list meet a certain criteria, or find the largest or smallest element in a list.

      In this tutorial, you will use the built-in functions all, any, max, and min.

      Prerequisites

      To get the most out of this tutorial, it is recommended to have:

      Using all

      The built-in function all checks if every element in an iterable is True. For example:

      all([True, True])
      

      If you run the previous code, you will receive this output:

      Output

      True

      In this first example, you call all and give it a list with two elements (two True Boolean values). Since every element in the iterable is True, the output was True.

      all will return False if one or more elements in the given iterable is False:

      all([True, False, True])
      

      If you run the previous code, you’ll receive this output:

      Output

      False

      You call all with a list containing three elements including one False Boolean value. Since one of the elements in the iterable was False, the output of the call to all was False.

      Notably, all stops iterating and immediately returns False as soon as it encounters the first False entry in an iterable. So, all can be useful if you want to check successive conditions that may build on each other, but return immediately as soon as one condition is False.

      A special case to be aware of is when all is given an empty iterable:

      all([])
      

      If you run the previous code, you’ll receive this output:

      Output

      True

      When you give all an empty iterable (for example, an empty list like all([])), its return value is True. So, all returns True if every element in the iterable is True or there are 0 elements.

      all is particularly helpful when combined with generators and custom conditions. Using all is often shorter and more concise than if you were to write a full-fledged for loop. Let’s consider an example to find out whether there are elements in a list that start with "s":

      animals = ["shark", "seal", "sea urchin"]
      all(a.startswith("s") for a in animals)
      

      If you run the previous code, you will receive this output:

      Output

      True

      You call all with a generator as its argument. The generator produces a Boolean for each element in the animals list based on whether or not the animal starts with the letter s. The final return value is True because every element in the animals list starts with s.

      Note: You can often use Generator expressions in place of list comprehensions as a way of saving memory. For example, consider all(i < 8 for i in range(3)) and all([i < 8 for i in range(3)]). Both statements return True because 0, 1, 2 are all less than 8. The second example (which uses a list comprehension), however, has the added overhead of implicitly creating a list three entries long ([True, True, True]) and then passing that list to the all function. The first example (which uses generator expressions), by contrast, passes a generator object to the all function, which the all function iterates over directly without the overhead of an intermediary list.

      Consider that the equivalent code written using a full-fledged for loop would have been significantly more verbose:

      animals = ["shark", "seal", "sea urchin"]
      
      def all_animals_start_with_s(animals):
          for a in animals:
              if not a.startswith("s"):
                  return False
          return True
      
      print(all_animals_start_with_s(animals))
      

      Without all, your code for determining if all the animals start with the letter s requires several more lines to implement.

      Next, you’ll look at the sibling function to all: any.

      Using any

      You can use the built-in function any to check if any element in an iterable is True. For example:

      any([False, True])
      

      If you run the previous code, you’ll receive this output:

      Output

      True

      You call any and give it a list with two elements (a False Boolean value and a True Boolean value). Since one or more element in the iterable was True, the output was also True.

      any will return False if, and only if, 0 of the elements in the given iterable are True:

      all([False, False, False])
      

      If you run the previous code, you’ll receive this output:

      Output

      False

      You call any with a list containing three elements (all False Boolean values). Since 0 of the elements in the iterable is True, the output of the call to any is False.

      Notably, any stops iterating and immediately returns True as soon as it encounters the first True entry in an iterable. So, any can be useful if you want to check successive conditions, but return immediately as soon as one condition is True.

      any—like its sibling method all—is particularly helpful when combined with generators and custom conditions (in place of a full for loop). Let’s consider an example to find out whether there are elements in a list that end with "urchin":

      animals = ["shark", "seal", "sea urchin"]
      any(s.endswith("urchin") for s in animals)
      

      You will receive this output:

      Output

      True

      You call any with a generator as its argument. The generator produces a Boolean for each element in the animals list based on whether or not the animal ends with urchin. The final return value is True because one element in the animals list ends with urchin.

      Note: When any is given an empty iterable (for example, an empty list like any([])), its return value is False. So, any returns False if there are 0 elements in the iterable or all the elements in the iterable are also False.

      Next, you’ll review another built-in function: max.

      Using max

      The built-in function max returns the largest element given in its arguments. For example:

      max([0, 8, 3, 1])
      

      max is given a list with four integers as its argument. The return value of max is the largest element in that list: 8.

      The output will be the following:

      Output

      8

      If given two or more positional arguments (as opposed to a single positional argument with an iterable), max returns the largest of the given arguments:

      max(1, -1, 3)
      

      If you run the previous code, you will receive this output:

      Output

      3

      max is given three individual arguments, the largest of which being 3. So, the return value of the call to max is 3.

      Just like any and all, max is particularly helpful because it requires fewer lines to use than equivalent code written as a full for loop.

      max can also deal with objects more complex than numbers. For example, you can use max with dictionaries or other custom objects in your program. max can accommodate these objects by using its keyword argument named key.

      You can use the key keyword argument to define a custom function that determines the value used in the comparisons to determine the maximum value. For example:

      entries = [{"id": 9}, {"id": 17}, {"id": 4}]
      max(entries, key=lambda x: x["id"])
      

      The output will be the following:

      Output

      {'id': 17}

      You call max with a list of dictionaries as its input. You give an anonymous lambda function as the key keyword argument. max calls the lambda function for every element in the entries list and returns the value of the "id" key of the given element. The final return value is the second element in entries: {"id": 17}. The second element in entries had the largest "id" value, and so was deemed to be the maximum element.

      Note that when max is called with an empty iterable, it refuses to operate and instead raises a ValueError:

      max([])
      

      If you run this code, you will receive the following output:

      Output

      Traceback (most recent call last): File "max.py", line 1, in <module> max([]) ValueError: max() arg is an empty sequence

      You call max with an empty list as its argument. max does not accept this as a valid input, and raises a ValueError Exception instead.

      max has a counterpart called min, which you’ll review next.

      Using min

      The built-in function min returns the smallest element given in its arguments. For example:

      min([8, 0, 3, 1])
      

      You give min a list with four integers as its argument. The return value of min is the smallest element in that list: 0.

      The output will be:

      Output

      0

      If given two or more positional arguments (as opposed to a single positional argument with an iterable), min returns the smallest of the given arguments:

      min(1, -1, 3)
      

      If you run the previous code, you will receive this output:

      Output

      -1

      You give min three individual arguments, the smallest of which being -1. So, the return value of the call to min is -1.

      Like max, min supports the keyword argument named key so that you can pass objects more complex than numbers into it. Using the key argument allows you to use the min function with any custom objects your program might define.

      You can use the key keyword argument to define a custom function that determines the value used in the comparisons to determine the minimum value. For example:

      entries = [{"id": 9}, {"id": 17}, {"id": 4}]
      min(entries, key=lambda x: x["id"])
      

      Output

      {'id': 4}

      You call min with a list of dictionaries as its input. You give an anonymous lambda function as the key keyword argument. min calls the lambda function for every element in the entries list and returns the value of the "id" key of the given element. The final return value is the third element in entries: {"id": 4}. The third element in entries had the smalled "id" value, and so was deemed to be the minimum element.

      Like max, when you call min with an empty iterable, it refuses to operate and instead raises a ValueError:

      min([])
      

      If you run the previous code, you will receive this output:

      Output

      Traceback (most recent call last): File "min.py", line 1, in <module> min([]) ValueError: min() arg is an empty sequence

      You call min with an empty list as its argument. min does not accept this as a valid input, and raises a ValueError Exception instead.

      Conclusion

      In this tutorial, you used the Python built-in functions all, any, max, and min. You can learn more about the functions all, any, max, and min and other Python built-in in the Python docs.

      For more information on other Python built-ins, you can also check out Built-in Python 3 Functions for Working with Numbers, How To Use the Python Map Function, and How To Use the Python Filter Function.



      Source link

      Python 3をインストールしUbuntu 20.04サーバーにプログラミング環境を設定する方法


      はじめに

      Pythonは初心者から経験豊富な開発者まで人気が高まりつつあるプログラミング言語です。Pythonは、スクリプティング、自動化、データ分析、機械学習、バックエンド開発に適した、柔軟で汎用性の高いプログラミング言語です。 1991年にイギリスのコメディグループMonty Pythonに触発された名前で最初に公開された開発チームは、Pythonを楽しく使用できる言語にしたいと考えていました。

      このチュートリアルでは、Ubuntu 20.24 サーバーでPython 3のプログラミング環境をセットアップする方法を学びます。サーバーでのプログラミングには多くの利点があり、開発プロジェクト間のコラボレーションをサポートします。このチュートリアルの一般原則はDebian Linuxのディストリビューションに適用されます。

      必要条件

      このチュートリアルを完了するには、Ubuntu 20.04サーバーにsudo権限を持つ非rootユーザーが必要です。このセットアップを実現する方法については、初期サーバー設定ガイドを参照してください。

      ターミナル環境にまだ慣れていない場合は、「Linuxターミナルの紹介」を参照すると、ターミナルの理解に役立ちます。

      サーバーとユーザーのセットアップが完了したら、準備を始めましょう。

      ステップ1 — Python 3のセットアップ

      Python 3をプレインストールして出荷されたDebian LinuxのUbuntu 20.04とその他のバージョンUbuntuのAPT(Advanced Packaging Tool)のaptコマンドで、システムを更新およびアップグレードして、Python 3が最新バージョンであることを確認します。

      • sudo apt update
      • sudo apt -y upgrade

      -yフラグは、すべてのアイテムがインストールされることに同意することを確認しますが、Linuxのバージョンによっては、システムを更新・アップグレード中に追加で同意を求められるかもしれません。

      プロセス完了後、次のように入力して、システムにインストールされているPython 3のバージョンを確認します。

      バージョン番号が端末ウィンドウで出力されます。バージョン番号は様々ですが、出力は次のようになります。

      Output

      Python 3.8.2

      Pythonのソフトウェアパッケージを管理するには、開発プロジェクトで使用するプログラミングパッケージをインストールおよび管理するツールであるpipをインストールしましょう。pipでインストールできるモジュールやパッケージについては、「Python 3でモジュールをインポートする方法」で詳しく説明しています。

      • sudo apt install -y python3-pip

      Pythonパッケージは、次のように入力してインストールできます。

      • pip3 install package_name

      ここで、package_nameは、Web開発用のDjangoや科学計算用のNumPyなど、任意のPythonパッケージまたはライブラリを参照できます。したがって、NumPyをインストールする場合は、コマンド pip3 install numpy を使用してインストールできます。

      プログラミング環境の堅牢なセットアップを確保するために、インストールするパッケージと開発ツールがいくつかあります。

      • sudo apt install -y build-essential libssl-dev libffi-dev python3-dev

      Pythonをセットアップし、pipおよびその他のツールをインストールしたら、開発プロジェクト用の仮想環境をセットアップできます。

      ステップ2 —仮想環境のセットアップ

      仮想環境を使用すると、Pythonプロジェクト用にサーバー上に隔離されたスペースが確保できます。これにより、各プロジェクトが、他のプロジェクトを中断させない独自の依存関係を持つことができます。

      プログラミング環境をセットアップすると、Pythonプロジェクトやパッケージのさまざまなバージョンの処理方法をより詳細に制御できます。これは、サードパーティのパッケージを使用する場合に特に重要です。

      必要な数のPythonプログラミング環境がセットアップできます。各環境は基本的に、サーバーを環境として機能させるためのいくつかのスクリプトを含むサーバー上のディレクトリまたはフォルダーです。

      Pythonでプログラミング環境を構築する方法はいくつかありますが、ここでは、標準のPython 3ライブラリの一部であるvenvモジュールを使用します。次を入力してvenvをインストールしましょう。

      • sudo apt install -y python3-venv

      これをインストールすると、環境を作成する準備ができました。Pythonプログラミング環境を配置するディレクトリを選択するか、次のようにmkdirで新しいディレクトリを作成します。

      • mkdir environments
      • cd environments

      環境が存在するディレクトリに移動したら、次のコマンドを実行して環境を作成できます。1

      基本的に、pyvenvは、lsコマンドで表示できるいくつかのアイテムを含む新しいディレクトリを設定します。

      Output

      bin include lib lib64 pyvenv.cfg share

      これらのファイルを一緒に使用すると、プロジェクトがローカルマシンのより広範なコンテキストから分離され、システムファイルとプロジェクトファイルが混在しなくなります。これは、バージョン管理のため、および各プロジェクトが必要な特定のパッケージに確実にアクセスできるようにするための良い方法です。Pythonのビルドパッケージ形式であるPython Wheelsは、コンパイルの必要回数を減らすことでソフトウェアの生産をスピードアップすることができ、Ubuntu20.04の share ディレクトリに配置されます。

      この環境を使用するには、activate スクリプトを呼び出す次のコマンドを入力して起動します。

      • source my_env/bin/activate

      これで、コマンドプロンプトの前に環境の名前が追加されます。この場合は、 my_envという名前です。実行しているDebian Linuxのバージョンによって、プレフィックスの表示が多少異なる場合がありますが、括弧内の環境の名前が最初に表示されるはずです。

      このプレフィックスにより、環境が現在アクティブになっていることがわかります。つまり、ここでプログラムを作成すると、この特定の環境の設定とパッケージのみが使用されます。

      注: 仮想環境で使うコマンドは、必要に応じてpython3ではなくpythonが、pip3ではなくpipが使用できます。外部環境でPython 3を使用する場合は、python3pip3コマンドしか使えません。

      これらの手順を実行すると、仮想環境が使用できるようになります。

      ステップ3 —「Hello、World」プログラムの作成

      仮想環境が設定されたので、恒例の「Hello, World!」プログラムを作成しましょう。これにより、環境をテストし、まだPythonに慣れていない場合はPythonに慣れる機会が得られます。

      これを行うには、nanoなどのコマンドラインテキストエディタを開き、新しいファイルを作成します。

      ターミナルウィンドウでテキストファイルが開いたら、プログラムを入力します。

      print("Hello, World!")
      

      CTRL キーと X キーを押してnanoを終了し、ファイルの保存を求められたら y を押します。

      nanoを終了してシェルに戻ったら、プログラムを実行しましょう。

      作成したばかりの hello.py プログラムにより、ターミナルは次の出力を生成します。

      Output

      Hello, World!

      環境を終了するには、コマンド deactivate を入力するして元のディレクトリに戻ります。

      まとめ

      おめでとうございます。この時点で、Ubuntu LinuxサーバーにPython 3プログラミング環境がセットアップされ、コードプロジェクトを開始できます。

      サーバーではなくローカルマシンを使用している場合は、「Python 3用のローカルプログラミング環境をインストールして設定する方法」シリーズでオペレーティングシステムに関連するチュートリアルを参照してください。

      サーバーでソフトウェア開発の準備ができたら、無料の* Python 3 でコードする方法*eBookをお読みになるか、Pythonのチュートリアルを参照して、Pythonのコーディング学習を継続できます。



      Source link

      Cara Menginstal Python 3 dan Menyiapkan Lingkungan Pemrograman pada Server Ubuntu 20.04


      Pengantar

      Bahasa pemrograman Python adalah pilihan yang semakin populer baik bagi para pemula dan pengembang berpengalaman. Fleksibel dan serbaguna, Python memiliki kekuatan dalam pembuatan skrip, automasi, analisis data, pemelajaran mesin, dan pengembangan back-end. Pertama diterbitkan pada tahun 1991 dengan nama yang terinspirasi oleh grup lawak Inggris Monty Python, tim pengembangan ingin membuat Python sebagai suatu bahasa yang menyenangkan untuk digunakan.

      Tutorial ini akan menyiapkan server Ubuntu 20.04 Anda bersama dengan lingkungan pemrograman Python 3. Pemrograman pada suatu server memiliki banyak keuntungan dan mendukung kolaborasi dengan berbagai proyek pengembangan. Prinsip umum tutorial ini akan berlaku pada distribusi Linux Debian versi manapun.

      Prasyarat

      Untuk menyelesaikan tutorial ini, Anda harus memiliki pengguna non-root dengan privilese sudo pada server Ubuntu 20.04. Untuk mempelajari cara melaksanakan penyiapan ini, ikuti panduan penyiapan server awal kami.

      Jika Anda belum terbiasa dengan lingkungan terminal, Anda dapat menemukan artikel berjudul “An Introduction to the Linux Terminal” yang bermanfaat untuk lebih membiasakan diri Anda dengan terminal.

      Dengan server dan pengguna Anda yang sudah disiapkan, Anda siap untuk memulai.

      Langkah 1 — Menyiapkan Python 3

      Ubuntu 20.04 dan versi lain dari Debian Linux dilengkapi dengan Python 3 yang sudah terinstal. Untuk memastikan bahwa versi kita adalah yang terbaru, mari kita perbarui dan tingkatkan sistem dengan perintah apt untuk bekerja dengan Advanced Packaging Tool (Alat Pengemasan Tingkat Lanjut) dari Ubuntu:

      • sudo apt update
      • sudo apt -y upgrade

      Bendera -y akan mengonfirmasi bahwa kita menyetujui semua butir yang akan diinstal, tetapi tergantung pada versi Linux Anda, Anda perlu mengonfirmasi pertanyaan tambahan saat sistem Anda diperbarui dan ditingkatkan.

      Setelah proses ini selesai, kita bisa memeriksa versi Python 3 yang terinstal di dalam sistem dengan mengetik:

      Anda akan menerima keluaran di jendela terminal yang akan memberi tahu nomor versi kepada Anda. Walaupun nomor ini dapat bervariasi, keluaran akan serupa seperti ini:

      Output

      Python 3.8.2

      Untuk mengelola paket perangkat lunak untuk Python, mari kita instal pip, alat yang akan menginstal dan mengelola paket pemrograman yang mungkin kita ingin gunakan dalam proyek pengembangan kita. Anda dapat mempelajari lebih lanjut tentang modul atau paket yang dapat Anda instal dengan pip dengan membaca “How To Import Modules in Python 3”.

      • sudo apt install -y python3-pip

      Paket Python dapat diinstal dengan mengetik:

      • pip3 install package_name

      Di sini, package_name dapat merujuk ke paket atau pustaka Python apa pun, seperti Django untuk pengembangan web atau NumPy untuk komputasi ilmiah. Jadi, jika Anda ingin menginstal NumPy, Anda dapat melakukannya dengan perintah pip3 instal numpy.

      Ada beberapa paket dan alat pengembangan lain yang akan diinstal untuk memastikan bahwa kita memiliki konfigurasi yang kokoh untuk lingkungan pemrograman kita:

      • sudo apt install -y build-essential libssl-dev libffi-dev python3-dev

      Setelah Python disiapkan, dan pip serta alat-alat lain sudah terinstal, kita dapat menyiapkan suatu lingkungan virtual untuk proyek pengembangan kita.

      Langkah 2 — Menyiapkan Lingkungan Virtual

      Lingkungan virtual memungkinkan Anda untuk memiliki ruang terisolasi pada server Anda untuk proyek Python, yang memastikan bahwa setiap proyek Anda dapat memiliki set dependensi sendiri yang tidak akan mengganggu proyek Anda yang lain.

      Mengatur suatu lingkungan pemrograman menyediakan kontrol yang lebih besar atas proyek Python dan tentang bagaimana versi paket yang berbeda ditangani. Ini sangat penting saat bekerja dengan paket pihak ketiga.

      Anda dapat menyiapkan sebanyak mungkin lingkungan pemrograman Python sesuai keinginan Anda. Setiap lingkungan pada dasarnya adalah suatu direktori atau folder pada server Anda yang memiliki beberapa skrip di dalamnya untuk membuatnya bertindak sebagai suatu lingkungan.

      Walaupun ada beberapa cara untuk menciptakan suatu lingkungan pemrograman di dalam Python, kita akan menggunakan modul venv di sini, yang merupakan bagian dari pustaka Python 3 standar. Mari kita instal venv dengan mengetik:

      • sudo apt install -y python3-venv

      Dengan venv sudah terinstal, kita siap untuk menciptakan lingkungan. Mari kita pilih di direktori mana kita ingin menaruh lingkungan pemrograman Python kita, atau menciptakan direktori baru dengan mkdir, seperti:

      • mkdir environments
      • cd environments

      Setelah Anda berada di direktori di mana Anda ingin lingkungan itu berada, Anda dapat menciptakan suatu lingkungan dengan menjalankan perintah berikut:

      Pada dasarnya, pyvenv menyiapkan suatu direktori baru yang berisi beberapa butir di dalamnya yang dapat kita lihat dengan perintah ls:

      Output

      bin include lib lib64 pyvenv.cfg share

      Secara bersama, berkas-berkas ini bekerja untuk memastikan proyek Anda terisolasi dari konteks server yang lebih luas, sehingga berkas sistem dan proyek tidak bercampur. Ini adalah praktik yang baik untuk kontrol versi dan untuk memastikan bahwa setiap proyek Anda memiliki akses ke paket tertentu yang dibutuhkannya. Python Wheels, format paket bawaan untuk Python yang dapat mempercepat produksi perangkat lunak Anda dengan cara mengurangi frekuensi yang dibutuhkan untuk mengompilasi, akan berada di dalam direktori share Ubuntu 20.04.

      Untuk menggunakan lingkungan ini, Anda perlu mengaktifkannya, yang Anda dapat laksanakan dengan mengetik perintah berikut yang memanggil skrip aktivasi:

      • source my_env/bin/activate

      Prompt perintah Anda sekarang akan diawali dengan nama lingkungan Anda, dalam hal ini disebut my_env. Tergantung pada versi Debian Linux yang Anda jalankan, prefiks Anda mungkin tampak agak berbeda, tetapi nama lingkungan Anda di dalam kurung harus menjadi hal pertama yang Anda lihat di baris Anda:

      Prefiks ini memungkinkan kita mengetahui bahwa lingkungan my_env saat ini sedang aktif, artinya bahwa saat kita menciptakan program di sini, program itu hanya akan menggunakan pengaturan dan paket dari lingkungan khusus ini.

      Catatan: Di dalam lingkungan virtual, Anda dapat menggunakan perintah python alih-alih python3, dan pip alih-alih pip3 jika Anda lebih menyukainya. Jika Anda menggunakan Python 3 pada mesin Anda di luar suatu lingkungan, Anda perlu menggunakan perintah python3 dan pip3 secara eksklusif.

      Setelah mengikuti langkah-langkah ini, lingkungan virtual Anda siap digunakan.

      Langkah 3 — Menciptakan Program “Hello, World”

      Sekarang, setelah kita menata lingkungan virtual kita, mari kita ciptakan sebuah program “Halo, World!“ tradisional. Ini akan memungkinkan kita menguji lingkungan kita dan memberi kita kesempatan untuk menjadi lebih familiar dengan Python jika sebelumnya kita belum akrab.

      Untuk melakukan ini, kita akan membuka suatu editor teks baris-perintah seperti nano dan menciptakan berkas baru:

      Setelah berkas teks dibuka di dalam jendela terminal, kita akan mengetikkan program kita:

      print("Hello, World!")
      

      Keluarlah dari nano dengan menekan tombol CTRL dan X, dan saat diminta menyimpan berkas, tekan y.

      Setelah keluar dari nano dan kembali ke shell Anda, mari kita jalankan program:

      Program hello.py yang baru Anda buat dapat menyebabkan terminal Anda menghasilkan keluaran berikut:

      Output

      Hello, World!

      Untuk keluar dari lingkungan, ketik perintah deactivate dan Anda akan kembali ke direktori asli Anda.

      Kesimpulan

      Selamat! Di titik ini Anda memiliki suatu lingkungan pemrograman Python 3 yang disiapkan pada server Linux Ubuntu Anda dan Anda dapat memulai proyek pengodean!

      Jika Anda menggunakan mesin lokal dan bukannya server, lihat tutorial yang relevan untuk sistem operasi Anda di seri “How To Install and Set Up a Local Programming Environment for Python 3” kami.

      Dengan server Anda telah siap untuk pengembangan perangkat lunak, Anda dapat terus belajar lebih banyak tentang pengodean di Python dengan membaca buku-el How To Code in Python 3 gratis kami, atau membuka tutorial Python kami.



      Source link