Archive | GNU/Linux İpuçları

Linux Mint 19.3 Linux Mint 20’ye nasıl yükseltilir?

Öncelikle şunu belirtelim: Linux Mint 19.3’ün hem 32 bit hem de 64 bit sürümleri Nisan 2023’e kadar desteklense de, Linux Mint 20 de dahil olmak üzere yeni Linux Mint sürümleri yalnızca 64 bit olarak kullanılabilecek. Bu nedenle, Linux Mint 20’ye yükseltmek için, Linux Mint 19.3’ün 64 bit sürümünü kullanıyor olmanız gerekiyor. hangi sürümü kullandığınızı anlamak için şu komutu çalıştırabilirsiniz: dpkg --print-architecture. Çıktı amd64 olarak dönerse, sistemi, Linux Mint 20’ye yükseltebilirsiniz. İ386 çıktısını alırsanız, 32 bit sürümünü kullandığınız anlamına gelir. Bu durumda yükseltme yapamazsınız ve Linux Mint 19.3 ile devam etmeniz gerekir. Linux Mint 20’ye yükseltmek için APT ve komut satırı deneyimine sahip olmanız gerekir. Şimdi çalışmaya başlayabiliriz. Öncelikle sisteminizde tüm güncellemelerin tam olarak yapılmış olması gerekir. Öncelikle Menü -> Yönetim -> Güncelleme Yöneticisi ile Güncelleme Yöneticisini açın. “Yenile” düğmesine basın. Yeni paketler çıkarsa, “Tümünü Seç” düğmesine basın ve ardından “Güncellemeleri Yükle” düğmesine basarak güncelleme işlemini gerçekleştirin. Yok, yeni paketler gelmezse, bu sisteminizin güncel olduğunu gösterir, devam edebilirsiniz.

Continue Reading →

Yükseltme sırasında bir sorun oluşursa, en son sistem anlık görüntüsünü geri yükleyerek zamanda geriye gidebilir ve tüm değişiklikleri geri alabilirsiniz. Bir sistem anlık görüntüsü oluşturmak için Timeshift’i “Menü -> Yönetim -> Timeshift” ile başlatıp, anlık görüntüler için bir hedef seçmek üzere sihirbazı izleyebilirsiniz. İlkin yükseltme aracını kurmanız gerekiyor. Bunun için terminale aşağıdaki kodu girin:

apt install mintupgrade

Şİmdi bir kontrol yapmamız gerekiyor. Bunun için terminale aşağıdaki kodu girin:

mintupgrade check

Ardından ekrandaki talimatları izleyin. Bu komut sistemi geçici olarak Linux Mint 20 depolarına yönlendirir ve yükseltmenin etkisini hesaplar. mintupgrade check komutuyla; yükseltmenin mümkün olup olmadığını ve varsa hangi paketlerin yükseltileceğini, yükleneceğini, kaldırılacağını ve saklanacağını öğrenrceksiniz. Artık paket yükseltmelerini indirmeye başlayabiliriz. Bunun için terminale aşağıdaki komutu girin:

mintupgrade download

Bu komutun aslında yükseltmenin kendisini gerçekleştirmez, yalnızca paketleri indirir. İndirme bittikten sonra yükseltmeleri uygulayabiliriz. Bu adım geri alınamaz. Bunu yaptıktan sonra, geri dönmenin tek yolu bir sistem anlık görüntüsünü geri yüklemektir. Yükseltmeleri uygulamak için terminale aşağıdaki komutu yazın:

mintupgrade upgrade

Bazı paketler artık Linux Mint 20’de mevcut değil veya Linux Mint 19.3 sürümünden daha düşük bir sürüme sahip. Düzgün çalışmalarını garanti etmek için indirgenmeleri gerekir. “Menü -> Yönetim -> Yazılım Kaynakları” ndan Yazılım Kaynakları aracını başlatın. “Bakım” sekmesini açın ve “Yabancı Paketleri Eski Sürüme Geç” seçeneğini tıklayın. Tüm yabancı paketleri seçin ve “Eski sürüme geçir” i tıklayın.

Şimdi de yabancı paketleri silmemiz gerekiyor. Bunun için “Menü -> Yönetim -> Yazılım Kaynakları” ndan Yazılım Kaynakları aracını başlatın. “Bakım” sekmesini açın ve “Yabancı Paketleri Kaldır” ı tıklayın. Kendiniz kurduğunuz paketler hariç (3. taraf kaynaklardan), tüm yabancı paketleri seçin ve “Kaldır” a tıklayın.

Yükseltme yapamıyorsanız, lütfen yeni bir kurulum yapın. Yükseltmelerle ilgili Clement Lefebvre’in yazdığı genel talimatları burada ve burada bulabilirsiniz.

0

Arandr nasıl kullanılır?

Bilindiği gibi, Debian Türkiye Forum’un değerli bir üyesi, değerli arkadaşımız Vedat Kılıç; uzun zamandır kendine özgü ISO kalıpları hazırlıyor. Vedat, bunları kendisine ait olan gnulinuxfree.blogspot.com üzerinden yayımlıyor. Bilindiği gibi, daha geniş bir çevreye duyurulması amacıyla bu çalışmaları forum üzerinden ve buradan da sizlere duyurmaya çaba gösteriyoruz. Vedat Kılıç‘ın en son yazdığı “Arandr nasıl kullanılır?” başlıklı yazı, eminim sizinle de bir biçimde alakalı olcaktır. Bu nedenle, yazıyı buraya da almayı uygun gördük. Kılıç, yazısına şu şekilde başlıyor:”Arandr yazılımı iki görev yapar, ekran çözünürlüğü scripti oluşturur ve mevcut çözünürlükleri anlık olarak uygular. Şayet bize lazım olan çözünürlük üzerinde mevcut değilse onu uygulamaz. Ancak yine onun oluşturduğu script içeriğinden değişiklik yaparak istediğimiz çözünürlüğü sağlayabiliriz. Eğer sisteminizdeki araçlarla istediğiniz ekran çözünürlüğü elde edemiyorsanız Arandr ile yapacağımız işlem çözüm olabilir.

Continue Reading →

Yapacağımız işlem bütün dağıtımlar ve bütün ekran kartları için geçerlidir. Hangi dağıtım ve hangi ekran kartı olursa olsun bu işlemi deneyebilirsiniz, herhangi bir yan tesiri yoktur. Bu nedenle önce kullandığınız sistemin paket yöneticisinden kurmanız gerekiyor.
Örneğin, Debian/Ubuntu tabanlarında alttaki komutla kurabilirsiniz.
sudo apt install arandr
Bütün dağıtımlarda kurulum komutunun sonuna arandr yazmanızla kurulur. Kurulumdan sonra sistem menüsündeki simgesine tıklayarak çalıştırabilirsiniz. Pencere açıldığında üst resimdeki gibi görüntü gelir. Arandr bilgisayarınızda bağlı ekran girişlerini algılar ve bunu HDMI1, VGA1 veya daha başka girişleri adıyla gösterir. İster bütün girişleri tek bir scripte isterse tek girişi bir scripte oluşturabilirsiniz, fark etmez. Eğer bir girişi oluşturmak isterseniz alttaki resimdeki gibi Etkin tikini boş bırakarak sadece kullanmak istediğinizi etkin yapabilirsiniz.”

“Örneğin bende HDMI1 ve VGA1 girişi var, VGA1 Etkin tikini boş bırakınca alttaki resimdeki gibi sadece HDMI1 göründü. Buna göre ne gibi bir seçim yaptıysanız ardından Farklı Kaydet tuşuna tıklıyorsunuz. Bir isim vermeniz için açılan pencereye ekran yazıyor ve kaydediyorsunuz.”

“Burada Arandr ile işimiz bitti, pencereyi kapatabilirsiniz. Bu işlemle /home/kullanıcı dizininde .screenlayout adında bir dizin ve bu dizin içinde ekran.sh adında bir script oluştu. Dosya yöneticisini açın, ctrl+h tuşlarıyla gizlileri görünür yapın ve /home/kullanıcı/.screenlayout/ekran.sh dosyasını bir metin editörü ile açın. Dosya içeriği birebir değilse de alttakine benzer olacaktır.
Bizi ilgilendiren kısım yeşil çizgi ile işaretlediğim ekran çözünürlüğü kısmıdır.”

1440×900 yazan yerde sizde farklı çözünürlükler yazabilir. Burayı istediğiniz çözünürlük ile değiştirebilirsiniz. Örneğin benim ekranın çözünürlüğü normalde 1920×1080 çözünürlüktür, ancak kenarlarda taşmayı dengelediği için 1440×900 yaptım.

Belirlediğim yerden istediğiniz ekran çözünürlüğünü yazdıysanız, dosyayı kaydedin ve kapatın. Ardından uçbirimi açın alttaki komut ile çalışma izni verin.
chmod a+rwx $HOME/.screenlayout/ekran.sh
Şu anda Arandr ve script ile işimiz bitti.
Ancak dosyayı ve çözünürlüğü denemek gerekiyor.
Bunun için uçbirime alttaki komutu girin.
sh -c "$HOME/.screenlayout/ekran.sh"
Bu komut ile ekranınız bir anlık kararır ve istediğiniz çözünürlükte olduysa işlem olumlu sonuç verdi demektir.
Eğer işlemi hatasız yapmanıza rağmen olmadıysa bu işlem işe yaramadı demektir.
İşe yaradıysa devam edelim.

Sistem her açılışta dosyanın çalışması için önce alttaki komutu uçbirime girin.
mkdir ~/.config/autostart
autostart dosyası varsa “işlem gerçekleşmedi, aynı dosya zaten var” der, aynı dosya yoksa bir şey demez.

Son olarak alttaki komutu olduğu gibi uçbirime girin.
echo '[Desktop Entry]
Type=Application
Name=ekran
Icon=computer
TryExec=ekran.sh
Exec=sh -c "$HOME/.screenlayout/ekran.sh"
StartupNotify=false
NoDisplay=true
Terminal=false' | tee ~/.config/autostart/ekran.desktop

Bu komutla oluşturduğumuz ekran.desktop dosyası sistem her açılışta oluşturduğunuz scripti çalıştıracaktır.

Arandr yazılımının kullanımı ve ekran çözünürlüğü scripti oluşturma işlemi bu kadar, umarım işinizi görür, kolay gelsin.”

gnulinuxfree.blogspot.com

0

Debian Buster sürümüne Steam nasıl kurulur?

Bilindiği gibi, Debian Türkiye Forum’un değerli bir üyesi, değerli arkadaşımız Vedat Kılıç; uzun zamandır kendine özgü ISO kalıpları hazırlıyor. Vedat, bunları kendisine ait olan gnulinuxfree.blogspot.com üzerinden yayımlıyor. Bilindiği gibi, daha geniş bir çevreye duyurulması amacıyla bu çalışmaları forum üzerinden ve buradan da sizlere duyurmaya çaba gösteriyoruz. Vedat Kılıç‘ın en son yazdığı “Debian Buster sürümüne Steam nasıl kurulur?” başlıklı yazı, eminim sizinle bir biçimde alakalı olcaktır. Bu nedenle, yazıyı buraya da almayı uygun gördük. Kılıç, yazısına şu şekilde başlıyor: “İnternet üzerinden ücretli-ücretsiz, sayısız ve sınırsız oyun oynama imkanı sunan Steam’da oyun oynamak için önce onu sisteme kurmamız gerekiyor. Debian’ın ana deposunda olmadığı için farklı yöntem uygulayacağız.

Continue Reading →

Önce uçbirimi açın, mousepad yerine kullandığınız metin editörü adını yazın ve alttaki komutla sources.list dosyasını açın.

sudo mousepad /etc/apt/sources.list

Açılan dosyada geçen her satırın sonuna alttaki örnekte olduğu gibi contrib non-free yazılarını ekleyin, dosyayı kaydedin ve pencereleri kapatın.

deb http://deb.debian.org/debian/ buster main contrib non-free#deb-src http://deb.debian.org/debian/ buster main contrib non-freedeb http://security.debian.org/debian-security buster/updates main contrib non-free#deb-src http://security.debian.org/debian-security buster/updates main contrib non-freedeb http://deb.debian.org/debian/ buster-updates main contrib non-free#deb-src http://deb.debian.org/debian/ buster-updates main contrib non-free

Ardından uçbirimi açın, alttaki komutla root olun.

sudo -i

Son olarak birden çok komutu tek komut haline getirdiğim alttaki komutun tamamını uçbirime girin.

sh -c "sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys F24AEA9FB05498B7 ; sudo apt update ; sudo dpkg --add-architecture i386 ; sudo apt update ; echo 'deb [arch=amd64,i386] http://repo.steampowered.com/steam/ precise steam' | sudo tee /etc/apt/sources.list.d/steam.list ; sudo apt update ; sudo apt install steam-launcher xterm -y ; sudo apt --fix-broken install -y ; sudo echo 'y' | apt install -f"

Bu komuttan sonra Steam kurulmuş olacak ve sistem menüsüne simgesi gelmiş olacaktır.

gnulinuxfree.blogspot.com

1

Debian Buster sürümüne Virtualbox nasıl kurulur?

Bilindiği gibi, Debian Türkiye Forum’un değerli bir üyesi, değerli arkadaşımız Vedat Kılıç; uzun zamandır kendine özgü ISO kalıpları hazırlıyor. Vedat, bunları kendisine ait olan gnulinuxfree.blogspot.com üzerinden yayımlıyor. Bilindiği gibi, daha geniş bir çevreye duyurulması amacıyla bu çalışmaları forum üzerinden ve buradan da sizlere duyurmaya çaba gösteriyoruz. Vedat Kılıç‘ın en son yazdığı “Debian Buster sürümüne Virtualbox nasıl kurulur?” başlıklı yazı, eminim sizinle bir biçimde alakalı olcaktır. Bu nedenle, yazıyı buraya da almayı uygun gördük. Kılıç, yazısına şu şekilde başlıyor: “Virtualbox geliştiricilerine birlikte çalışma önerisinde bulunan Debian geliştiricileri olumsuz yanıt alınca güvenlik açısından ve haklı olarak Virtualbox yazılımını Debian’ın ana deposundan kaldırdılar. Bu da doğal olarak Debian Stable tabanıyla uyuşma riski taşımasıyla birlikte kurulum için bildiğimiz yöntemler de işe yaramadı. Alternatif yazılımlar ise benim hiç hoşuma gitmedi, sanal makineden ziyade işkence makineleri desem herhalde yeridir. Kimine onlarca komut giriyorsun iso kalıbını beğenmiyor, kiminin penceresi var ortada kendisi yok. Bu yüzden yine en iyi seçenek şimdilik Virtualbox olarak görünüyor. Sizin de sanal makine ihtiyacınız varsa ve Virtualbox diyorsanız, zar-zor ve deneme-yanılma ile bulduğum yönteme başlayalım.

Continue Reading →

Önce uçbirimi açın, mousepad yerine kullandığınız metin editörü adını yazın ve alttaki komutla sources.list dosyasını açın.

sudo mousepad /etc/apt/sources.list

Açılan dosyada geçen her satırın sonuna alttaki örnekte olduğu gibi contrib non-free yazılarını ekleyin, dosyayı kaydedin ve pencereleri kapatın.
deb http://deb.debian.org/debian/ buster main contrib non-free
#deb-src http://deb.debian.org/debian/ buster main contrib non-free
deb http://security.debian.org/debian-security buster/updates main contrib non-free
#deb-src http://security.debian.org/debian-security buster/updates main contrib non-free
deb http://deb.debian.org/debian/ buster-updates main contrib non-free
#deb-src http://deb.debian.org/debian/ buster-updates main contrib non-free

Ardından uçbirime açın, alttaki komutla root olun.
sudo -i

Virtualbox kurulumu için ayrıca işi kolaylaştırdım, komutları uçbirime tek tek girmek yerine alttaki komutu hepsini bir defa uçbirime girmenizle Virtualbox kurulacaktır.

sh -c "wget -q https://www.virtualbox.org/download/oracle_vbox_2016.asc -O- | sudo apt-key add - ; wget -q https://www.virtualbox.org/download/oracle_vbox.asc -O- | sudo apt-key add - ; echo 'deb [arch=amd64] https://download.virtualbox.org/virtualbox/debian buster contrib' | sudo tee /etc/apt/sources.list.d/virtualbox.list ; sudo apt-get update ; sudo apt-get install virtualbox-6.1 -y ; echo 'y' | sudo apt install -f"

Bu komuttan sonra hemen çalıştırırsanız sisteme tam entegre olmadığı için hata uyarısı verebilir, bu yüzden bilgisayarı yeniden başlatın. Debian Buster sürümüne Virtualbox kurulum işlemi bu kadar, aynı şekilde defalarca kurdum, hiç birinde sorun yaşamadım, umarım siz de sorun yaşamadan kullanırsınız.

gnulinuxfree.blogspot.com

0

NumPy where tutorial (With Examples)

Looking up for entries that satisfy a specific condition is a painful process, especially if you are searching it in a large dataset having hundreds or thousands of entries. If you know the fundamental SQL queries, you must be aware of the ‘WHERE’ clause that is used with the SELECT statement to fetch such entries from a relational database that satisfy certain conditions. NumPy offers similar functionality to find such items in a NumPy array that satisfy a given Boolean condition through its ‘where()‘ function — except that it is used in a slightly different way than the SQL SELECT statement with the WHERE clause. In this tutorial, we’ll look at the various ways the NumPy where function can be used for a variety of use cases. Let’s get going.

Continue Reading →

A very simple usage of NumPy where

Let’s begin with a simple application of ‘np.where()‘ on a 1-dimensional NumPy array of integers.
We will use ‘np.where’ function to find positions with values that are less than 5.

We’ll first create a 1-dimensional array of 10 integer values randomly chosen between 0 and 9.

import numpy as np

np.random.seed(42)

a = np.random.randint()

print("a = {}".format(a))

Output:

a = [6 3 7 4 6 9 2 6 7 4]

Now we will call ‘np.where’ with the condition ‘a < 5’ i.e we’re asking ‘np.where’ to tell us where in the array a are the values less than 5. It will return us an array of indices where the specified condition is satisfied.

result = np.where(a < 5)

print(result)

Output:

(array([1, 3, 6, 9]),)

We get the indices 1,3,6,9 as output and it can be verified from the array that the values at these positions are indeed less than 5.
Note that the returned value is a 1-element tuple. This tuple has an array of indices.
We’ll understand the reason for the result being returned as a tuple when we discuss np.where on 2D arrays.

How does NumPy where work?

To understand what goes on inside the complex expression involving the ‘np.where’ function, it is important to understand the first parameter of ‘np.where’, that is, the condition.

When we call a Boolean expression involving NumPy array such as ‘a > 2’ or ‘a % 2 == 0’, it actually returns a NumPy array of Boolean values.

This array has the value True at positions where the condition evaluates to True and has the value False elsewhere. This serves as a ‘mask‘ for NumPy where function.

Here is a code example.

a = np.array([1, 10, 13, 8, 7, 9, 6, 3, 0])

print ("a > 5:")

print(a > 5)

Output:

a > 5:
[false True True True True True True False False]

So what we effectively do is that we pass an array of Boolean values to the ‘np.where’ function which then returns the indices where the array had the value True.

This can be verified by passing a constant array of Boolean values instead of specifying the condition on the array that we usually do.

bool_array = np.array([True, True, True, False, False, False, False, False, False])

print(np.where(bool_array)

Output:

(array([0, 1, 2]),)

Notice how, instead of passing a condition on an array of actual values, we passed a Boolean array and the ‘np.where’ function returned us the indices where the values were True.

2D matrices

Now that we have seen it on 1-dimensional NumPy arrays, let us understand how would ‘np.where’ behave on 2D matrices.

The idea remains the same. We call the ‘np.where’ function and pass a condition on a 2D matrix. The difference is in the way it returns the result indices.
Earlier, np.where returned a 1-dimensional array of indices (stored inside a tuple) for a 1-D array, specifying the positions where the values satisfy a given condition.

But in the case of a 2D matrix, a single position is specified using 2 values — the row index and the column index.
So in this case, np.where will return 2 arrays, the first one carrying the row indices and the second one carrying the corresponding column indices.

Both these rows and column index arrays are stored inside a tuple (now you know why we got a tuple as an answer even in case of a 1-D array).

Let’s see this in action to better understand it.
We’ll write a code to find where in a 3×3 matrix are the entries divisible by 2.

np.random.seed(42)

a = np.random.randint(0,10, size=(3,3))

print("a =\n{}\n".format(a))

result = np.where(a % 2 == 0)

print("result: {}".format(result))

Output:

a =
[[6 3 7]
[4 6 9]
[2 6 7]

result: (array([0, 1, 1, 2, 2]], array([0, 0, 1, 0, 1]))

The returned tuple has 2 arrays, each bearing the row and column indices of the positions in the matrix where the values are divisible by 2.

Ordered pairwise selection of values from the two arrays gives us a position each.
The length of each of the two arrays is 5, indicating there are 5 such positions satisfying the given condition.

If we look at the 3rd pair — (1,1), the value at (1,1) in the matrix is 6 which is divisible by 2.
Likewise, you can check and verify with other pairs of indices as well.

Multidimensional array

Just as we saw the working of ‘np.where’ on a 2-D matrix, we will get similar results when we apply np.where on a multidimensional NumPy array.

The length of the returned tuple will be equal to the number of dimensions of the input array.
Each array at position k in the returned tuple will represent the indices in the kth dimension of the elements satisfying the specified condition.

Let’s quickly look at an example.

np.random.seed(42)

a = np.random.randint(0,10, size=(3,3,3,3)) #4-dimensional array

print("a =\n{}\n".format(a))

result = np.where(a == 5) #checking which values are equal to 5

print("len(result)= {}".format(len(result)))

print("len(result[0]= {})".format(len(result[0])))

Output:

len(result) = 4 indicates the input array is of 4 dimension.

The length of one of the arrays in the result tuple is 6, which means there are six positions in the given 3x3x3x3 array where the given condition (i.e containing value 5) is satisfied.

Using the result as an index

So far we have looked at how we get the tuple of indices, in each dimension, of the values satisfying the given condition.

Most of the time we’d be interested in fetching the actual values satisfying the given condition instead of their indices.

To achieve this, we can use the returned tuple as an index on the given array. This will return only those values whose indices are stored in the tuple.

Let’s check this for the 2-D matrix example.

np.random.seed(42)

a = np.random.randint(0,10, size=(3,3))

print("a =\n{}\n".format(a))

result_indices = np.where(a % 2 == 0)

result = a[result_indices]

print("result: {}".format(result))

Output:

a =
[[6 3 7]
[4 6 9]
[2 6 7]]

result: [6 4 6 2 6]

As discussed above, we get all those values (not their indices) that satisfy the given condition which, in our case, was divisibility by 2 i.e even numbers.

Parameters ‘x’ and ‘y’

Instead of getting the indices as a result of calling the ‘np.where’ function, we can also provide as parameters, two optional arrays x and y of the same shape (or broadcastable shape) as input array, whose values will be returned when the specified condition on the corresponding values in input array is True or False respectively.

For instance, if we call the method on a 1-dimensional array of length 10, and we supply two more arrays x and y of the same length.
In this case, whenever a value in input array satisfies the given condition, the corresponding value in array x will be returned whereas, if the condition is false on a given value, the corresponding value from array y will be returned.

These values from x and y at their respective positions will be returned as an array of the same shape as the input array.

Let’s get a better understanding of this through code.

np.random.seed(42)

a = np.random.randint(0,10, size=(10))

x = a

y = a*10

print("a = {}".format(a))

print("x = {}".format(x))

print("y = {}".format(y))

result = np.where(a%2 == 1, x, y) #if number is odd return the same number else return its multiple of 10.

print("\nresult = {}".format(result))

Output:

This method is useful if you want to replace the values satisfying a particular condition by another set of values and leaving those not satisfying the condition unchanged.
In that case, we will pass the replacement value(s) to the parameter x and the original array to the parameter y.

Note that we can pass either both x and y together or none of them. We can’t pass one of them and skip the other.

Apply on Pandas DataFrames

Numpy’s ‘where’ function doesn’t necessarily have to be applied to NumPy arrays. It can be used with any iterable that would yield a list of Boolean values.

Let us see how we can apply the ‘np.where’ function on a Pandas DataFrame to see if the strings in a column contain a particular substring.

import pandas as pd

import numpy as np

df = pd.DataFrame({"fruit":["apple", "banana", "musk melon",
"watermelon", "pineapple", "custard apple"],
"color": ["red", "green/yellow", "white",
"green", "yellow", "green"]})

print("Fruits DataFrame:\n")

print(df)

Output:

Now we’re going to use ‘np.where’ to extract those rows from the DataFrame ‘df’ where the ‘fruit’ column has the substring ‘apple’

apple_df = df.iloc[np.where(df.fruit.str.contains("apple"))]

print(apple_df)

Output:

Let’s try one more example on the same DataFrame where we extract rows for which the ‘color’ column does not contain the substring ‘yell’.

Note: we use the tilde (~) sign to inverse Boolean values in Pandas DataFrame or a NumPy array.

non_yellow_fruits = df.iloc[np.where(~df.color.str.contains("yell"))]

print("Non Yellow fruits:\n{}".format(non_yellow_fruits))

Output:

Multiple conditions

So far we have been evaluating a single Boolean condition in the ‘np.where’ function. We may sometimes need to combine multiple Boolean conditions using Boolean operators like ‘AND‘ or ‘OR’.

It is easy to specify multiple conditions and combine them using a Boolean operator.
The only caveat is that for the NumPy array of Boolean values, we cannot use the normal keywords ‘and’ or ‘or’ that we typically use for single values.
We need to use the ‘&’ operator for ‘AND’ and ‘|’ operator for ‘OR’ operation for element-wise Boolean combination operations.

Let us understand this through an example.

np.random.seed(42)

a = np.random.randint(0,15, (5,5)) #5x5 matrix with values from 0 to 14

print(a)

Output:

We will look for values that are smaller than 8 and are odd. We can combine these two conditions using the AND (&) operator.

# get indices of odd values less than 8 in a
indices = np.where((a < 8) & (a % 2==1))

#print the actual values
print(a[indices])

Output:

We can also use the OR (|) operator to combine the same conditions. This will give us values that are ‘less than 8’ OR ‘odd values’ i.e all values less than 8 and all odd values greater than 8 will be returned.

# get indices of values less than 8 OR odd values in a
indices = np.where((a < 8) | (a % 2==1))

#print the actual values
print(a[indices])

Output:

Nested where (where within where)

Let us revisit the example of our ‘fruits’ table.

import pandas as pd

import numpy as np

df = pd.DataFrame({"fruit":["apple", "banana", "musk melon",
"watermelon", "pineapple", "custard apple"],
"color": ["red", "green/yellow", "white",
"green", "yellow", "green"]})

print("Fruits DataFrame:\n")

print(df)

Output:

Now let us suppose we wanted to create one more column ‘flag’ which would have the value 1 if the fruit in that row has a substring ‘apple’ or is of color ‘yellow’. We can achieve this by using nested where calls i.e we will call ‘np.where’ function as a parameter within another ‘np.where’ call.

df['flag'] = np.where(df.fruit.str.contains("apple"), 1, # if fruit == 'apple', set 1
np.where(df.color.str.contains("yellow"), 1, 0)) #else if color has 'yellow' set 1, else set 0

print(df)

Output:

The complex expression above can be translated into simple English as:

  1. If the ‘fruit’ column has the substring ‘apple’, set the ‘flag’ value to 1
  2. Else:
    1. If the ‘color’ column has substring ‘yellow’, set the ‘flag’ value to 1
    2. Else set the ‘flag’ value to 0

Note that we can achieve the same result using the OR (|) operator.

#set flag = 1 if any of the two conditions is true, else set it to 0
df['flag'] = np.where(df.fruit.str.contains("apple") |
df.color.str.contains("yellow"), 1, 0)

print(df)

Output:

Thus nested where is particularly useful for tabular data like Pandas DataFrames and is a good equivalent of the nested WHERE clause used in SQL queries.

Finding rows of zeros

Sometimes, in a 2D matrix, some or all of the rows have all values equal to zero. For instance, check out the following NumPy array.

a = np.array([[1, 2, 0],
[0, 9, 20],
[0, 0, 0],
[3, 3, 12],
[0, 0, 0]
[1, 0, 0]])
print(a)

Output:

As we can see the rows 2 and 4 have all values equal to zero. But how do we find this using the ‘np.where’ function?

If we want to find such rows using NumPy where function, we will need to come up with a Boolean array indicating which rows have all values equal to zero.

We can use the ‘np.any()‘ function with ‘axis = 1’, which returns True if at least one of the values in a row is non-zero.

The result of np.any() will be a Boolean array of length equal to the number of rows in our NumPy matrix, in which the positions with the value True indicate the corresponding row has at least one non-zero value.

But we needed a Boolean array that was quite the opposite of this!

That is, we needed a Boolean array where the value ‘True’ would indicate that every element in that row is equal to zero.

Well, this can be obtained through a simple inversion step. The NOT or tilde (~) operator inverts each of the Boolean values in a NumPy array.

The inverted Boolean array can then be passed to the ‘np.where’ function.

Ok, that was a long, tiring explanation.
Let’s see this thing in action.

zero_rows = np.where(~np.any(a, axis=1))[0]

print(zero_rows)

Output:

Let’s look at what’s happening step-by-step:

  1. np.any() returns True if at least one element in the matrix is True (non-zero). axis = 1 indicates it to do this operation row-wise.
  2. It would return a Boolean array of length equal to the number of rows in a, with the value True for rows having non-zero values, and False for rows having all values = 0.
    np.any(a, axis=1)
    Output:

3.The tilde (~) operator inverts the above Boolean array:
~np.any(a, axis=1)
Output:

  1. ‘np.where()’ accepts this Boolean array and returns indices having the value True.

The indexing [0] is used because, as discussed earlier, ‘np.where’ returns a tuple.

Finding the last occurrence of a true condition

We know that NumPy’s ‘where’ function returns multiple indices or pairs of indices (in case of a 2D matrix) for which the specified condition is true.

But sometimes we are interested in only the first occurrence or the last occurrence of the value for which the specified condition is met.

Let’s take the simple example of a one-dimensional array where we will find the last occurrence of a value divisible by 3.

np.random.seed(42)

a = np.random.randint(0,10, size=(10))

print("Array a:", a)

indices = np.where(a%3==0)[0]

last_occurrence_position = indices[-1]

print("last occurrence at", last_occurrence_position)

Output:

Here we could directly use the index ‘-1’ on the returned indices to get the last value in the array.

But how would we extract the position of the last occurrence in a multidimensional array, where the returned result is a tuple of arrays and each array stores the indices in one of the dimensions?

We can use the zip function which takes multiple iterables and returns a pairwise combination of values from each iterable in the given order.

It returns an iterator object, and so we need to convert the returned object into a list or a tuple or any iterable.

Let’s first see how zip works:

a = (1, 2, 3, 4)

b = (5, 6, 7, 8)

c = list(zip(a,b))

print(c)

Output:

So the first element of a and the first element of b form a tuple, then the second element of a and the second element of b form the second tuple in c, and so on.

We’ll use the same technique to find the position of the last occurrence of a condition being satisfied in a multidimensional array.

Let’s use it for a 2D matrix with the same condition as we saw in the earlier example.

np.random.seed(42)

a = np.random.randint(0,10, size=(3,3))

print("Matrix a:\n", a)

indices = np.where(a % 3 == 0)

last_occurrence_position = list(zip(*indices))[-1]

print("last occurrence at",last_occurrence_position)

Output:

We can see in the matrix the last occurrence of a multiple of 3 is at the position (2,1), which is the value 6.

Note: The * operator is an unpacking operator that is used to unpack a sequence of values into separate positional arguments.

Using on DateTime data

We have been using ‘np.where’ function to evaluate certain conditions on either numeric values (greater than, less than, equal to, etc.), or string data (contains, does not contain, etc.)

We can also use the ‘np.where’ function on datetime data.

For example, we can check in a list of datetime values, which of the datetime instances are before/after a given specified datetime.

Let’s understand this through an example.
Note: We’ll use Python’s datetime module to create date objects.

Let’s first define a DataFrame specifying the dates of birth of 6 individuals.

import datetime

names = ["John", "Smith", "Stephen", "Trevor", "Kylie", "Aariz"]

dob = [datetime.datetime(1969, 12, 1),
datetime.datetime(1988, 3, 13),
datetime.datetime(1992, 5, 19),
datetime.datetime(1972, 5, 31),
datetime.datetime(1989, 11, 28),
datetime.datetime(1993, 2, 7)]

data_birth = pd.DataFrame({"name":names, "date_of_birth":dob})

print(data_birth)

Output:

This table has people from diverse age groups!
Let us now specify a condition where we are interested in those individuals who are born on or post-January 1, 1990.

post_90_indices = np.where(data_birth.date_of_birth >= '1990-01-01')[0]

print(post_90_indices)

Output:

Rows 2 and 5 have Smith and Kylie who are born in the years 1992 and 1993 respectively.

Here we are using the ‘greater than or equal to’ (>=) operator on a datetime data, which we generally use with numeric data.
This is possible through operator overloading.

Let’s try one more example. Let’s fetch individuals that were born in May.
Note: Pandas Series provides ‘dt’ sub-module for datetime specific operations, similar to the ‘str’ sub-module we saw in our earlier examples.

may_babies = data_birth.iloc[np.where(data_birth.date_of_birth.dt.month == 5)]

print("May babies:\n{}".format(may_babies))

Output:

Conclusion

We began the tutorial with simple usage of ‘np.where’ function on a 1-dimensional array with conditions specified on numeric data.

We then looked at the application of ‘np.where’ on a 2D matrix and then on a general multidimensional NumPy array.
We also understood how to interpret the tuple of arrays returned by ‘np.where’ in such cases.

We then understood the functionality of ‘np.where’ in detail, using Boolean masks.
We also saw how we can use the result of this method as an index to extract the actual original values that satisfy the given condition.

We looked at the behavior of the ‘np.where’ function with the optional arguments ‘x’ and ‘y’.

We then checked the application of ‘np.where’ on a Pandas DataFrame, followed by using it to evaluate multiple conditions.

We also looked at the nested use of ‘np.where’, its usage in finding the zero rows in a 2D matrix, and then finding the last occurrence of the value satisfying the condition specified by ‘np.where’

Finally, we used ‘np.where’ function on a datetime data, by specifying chronological conditions on a datetime column in a Pandas DataFrame.

0

Pek bilinmeyen altı tane web browser

Bilindiği gibi, Debian Türkiye Forum’un değerli bir üyesi, değerli arkadaşımız Vedat Kılıç; uzun zamandır kendine özgü ISO kalıpları hazırlıyor. Vedat, bunları kendisine ait olan gnulinuxfree.blogspot.com üzerinden yayımlıyor. Bilindiği gibi, daha geniş bir çevreye duyurulması amacıyla bu çalışmaları forum üzerinden ve buradan da sizlere duyurmaya çaba gösteriyoruz. Vedat Kılıç‘ın en son yazdığı “Pek bilinmeyen altı tane web browser” adlı yazı, bu kez farklı, bir o kadar da ilginç bir konu içeriyor. Bu nedenle, bu yazıyı da sizlere aktarmak istedim. Dostumuz yazısına şöyle başlıyor: “GNU/Linux için yapılmış ama henüz dağıtım depolarına girmemiş 7 tane farklı web tarayıcıyı ile tanışacağız. Bu tarayıcıların kimisi muhtemelen zaman içinde depolara girecek, kimisi belki hiç giremeden durdurulacak, o kadarını bilemeyiz ama en azından yenilik adına onlara göz atmakta fayda var.

Continue Reading →

Sielo web browser

Resimde görülen tarayıcının adı Sielo, bir Fransız tarafından geliştirilmiş, Chromium tabanlı, bir kaç dile sahip, henüz Türkçe yok, AppImage paketi olarak paylaşılıyor. AppImage bütün bağımlılıkları kendi içinde olan, üzerine çift tıklamayla çalışan yeni tür kurulmadan çalışan portable paket prensibine dayanıyor. Kurulmadan ve USB’den çalışıyor olması bir çoklarının tercihi olsa da dosya içeriği görülmediği için temel geliştiricilerin bazıları tarafından şiddetle eleştiriliyor ve desteklenmiyor. Lakin konumuz bu olmadığı için burayı geçiyoruz. Dünyaya açılan pencere de denilen web browserler içinde Sielo browserin arayüzü dünyayı gezen pencereye benziyor. Neredeyse bütün tuşları istenen yere taşınabiliyor. Örneğin resimde görülen yuvarlak daire aslında yan panel ama hem yerini hem şeklini değiştirebiliyorsunuz. Bu panel imleci takip ediyor, imleç hangi sayfadaysa anında o sayfaya geçiyor. Resimde bir kısmı görüldüğü gibi sayısız sekmeleri ve sayfaları arayüze döşeyebiliyorsunuz, bunun için sekmeleri istediğiniz bölgeye sürüklemeniz yetiyor. Sielo browserde ayrıca bukelamun gibi her bölgesine, arkaplanına veya sayfalara istediğiniz rengi verebiliyorsunuz. Kendinden reklam engelleyici özelliği de bulunuyor. Sielo browser tamamen hızlı, görsel ve pratik kullanım üzerine geliştirilmiş. Görselliği ve pratik kullanmayı sevenler için denemeye değer. Resmi web sitesi ve indirme adresi: Sielo Browser

 Dissenter web browser

Dissenter browser, Brave browserin birebir kopyası. Hızlılığa, güvenliğe ve tarayıcı arayüzünden mesajlaşmaya ağırlık verilmiş
Chrome eklentileri eklenebiliyor, Türkçe ve görevini iyi yapıyor. Dissenter geliştiricinin anlatımını okuyalım.
‘Dissenter nedir?
Dissenter, reklamverenler için değil, İnsanlar için oluşturulmuş açık kaynaklı bir web tarayıcısıdır. Dissenter, tek tek URL’ler etrafında konuşmalar düzenler ve üzerinde herkesin yorum bırakabileceği genel bir kare oluşturur. Dissenter tarayıcısı, varsayılan olarak reklamları ve izleyicileri engeller, böylece web’de gezinme deneyiminizi geleneksel web tarayıcılarından çok daha hızlı hale getirir. Dissenter, geçişi henüz yapmaya hazır değilseniz ve genel yorum sistemimizi diğer tarayıcılarda test etmek istemeniz durumunda, diğer tarayıcılar için de bir uzantı sunar.’  Buradan indirin: Dissenter Browser

Naver Whale  web browser

Bu tarayıcıyı Koreliler inşa etmiş, güzel bir hedefe sahip. Tarayıcının temelini yükledikten sonra içeriğini yani temel yapısını kendine göre özelleştiriyorsun. API sayfası var, kişisel bütün özelleştirmeler oradan yapılıyor. Sayısız gönüllülerin katılımıyla şekilleniyor, yani siz kurduğunuzda ne görüyorsanız sizin gibi kullanıcıların yaptıklarını görmüş oluyorsunuz. Herkesin katıldığı bir blog sayfası var, herkes önerilerini, görüşlerini ve tarayıcıya yaptığı işlemleri orada paylaşıyor, en çok beğenilenler ana sayfanın en üstünde teşhir ediliyor. Bu tarayıcıdan şikayetin olduğunda muhatabın yine kendin oluyorsun, sorununu blog sayfasında paylaştığında binlerce kullanıcının önerisiyle karşılaşıyorsun. Chromium tabanlı, Chrome eklentileri eklenebiliyor, önemli yerleri Türkçe. Buradan indir: Naver Whale browser

OhHai web browser

OhHai tarayıcı sıfırdan inşa edilmiş, istendiği kadar sekmelerle çalışabilmek amacıyla yapılmış. Bütün sekmeleri yan tarafta tutuyor, ileri-geri alma, yer imine ekleme, yenileme ve yeni sekme açma özelliklerinden ibaret. Şimdilik başka özellik taşımıyor, lakin sorunsuz çalışan ve sade bir tarayıcı isteyenler için iyi bir tercih olabilir. Buradan indirin: OhHai browser

Spez web browser

Spez browser gelişmiş bir tarayıcı olmakla birlikte Epiphany tarayıcının zarif görünümlü bir çatalı. Geliştirici şöyle tanımlamış.
‘Güçlü gizlilik ayarları, basit inteface ve gerçekten güvenilir bir şekilde internette gezinmenizi sağlayan adblock özelliklerine sahip, özgürlüğünüz ve gizliliğiniz için güçlü web tarayıcısı. Web’in özel, sade, temiz, güzel bir görünümünü arıyorsanız, bu sizin için bir tarayıcıdır.’ Buradan indirin: Spez browser

Youtube Music

Bir de sizlere farklı bir tarayıcı tanıtayım, bu tarayıcı internette gezmek için değil, Youtube sitesinde gezmek için. Youtube arayüzünü kendine göre müthiş geliştirmiş, videoları kendi penceresinde ve harici pencerede oynatabiliyor. Bir sanatçıya veya videoya ait ne varsa tarihine, resimlerine kadar bütün bilgileri getiriyor ve sunu şeklinde gösteriyor. Yıllara göre, türe göre ve yerli-yabancı sanatçılara göre kategori oluşturuyor, böylece tercih ve kullanım daha pratik oluyor. Kendi kitaplığını oluşturabiliyor, yorumda ve paylaşımda bulunabiliyorsun. Reklam engelleyici, kısıtlı mod, geçmişi temizleme gibi özelliklere sahip.

Ayrıca AppImage formatlı olduğu için kurmadan kullanabilirsiniz, bunun için indirdiğiniz AppImage dosyasına çift tıklamanız yeterli. Buradan indirin: Youtube Music

0

Exiting/Terminating Python scripts (Simple Examples)

Today, we’ll be diving into the topic of exiting/terminating Python scripts! Before we get started, you should have a basic understanding of what Python is and some basic knowledge about its use. You can use the IDE of your choice, but I’ll use  Microsoft’s Linux Subsystem for Windows (WSL) package this time. For more information on that and how you enable it on Windows 10 go here. The way Python executes a code block makes it execute each line in order, checking dependencies to import, reading definitions and classes to store in memory, and executing pieces of code in order allowing for loops and calls back to the defined definitions and classes. When the Python interpreter reaches the end of the file (EOF), it notices that it can’t read any more data from the source, whether that be the user’s input through an IDE or reading from a file. To demonstrate let’s try to get user input and interrupt the interpreter in the middle of execution!

Continue Reading →

Why does Python automatically exit a script when it’s done?

First, from your bash terminal in your PowerShell open a new file called “input.py”

nano input.py

Then paste the following into the shell by right-clicking on the PowerShell window

name=input("Don't type anything!\n")

print("Hi,",name,"!")

Now, press CTRL+X to save and exit the nano window and in your shell type:

python3 input.py
Don't type anything!

And press CTRL+D to terminate the program while it’s waiting for user input

Traceback (most recent call last):

File "input.py", line 1, in

name=input("Don't type anything!")

EOFError

The EOFError exception tells us that the Python interpreter hit the end of file (EOF) condition before it finished executing the code, as the user entered no input data.

When Python reaches the EOF condition at the same time that it has executed all the code it exits without throwing any exceptions which is one way Python may exit “gracefully.”

Detect script exit

If we want to tell when a Python program exits without throwing an exception, we can use the built-in Python atexit module.

Theatexit handles anything we want the program to do when it exits and is typically used to do program clean up before the program process terminates

To experiment with atexit, let’s modify our input.py example to print a message at the program exit. Open the input.py file again and replace the text with this

import atexit

atexit.register(print,"Program exited successfully!")

name=input("What's your name?\n")

print("Hi,",name,"!")

Type your name and when you hit enter you should get:

What's your name?
Example
Hi, Example !
Program exited successfully!

Notice how the exit text appears at the end of the output no matter where we place the atexit call, and how if we replace the atexit call with a simple print(), we get the exit text where the print() all was made, rather than where the code exits.

Program exited successfully!
What's your name?
Example
Hi, Example !

Graceful exit

There are several ways to exit a Python Program that doesn’t involve throwing an exception, the first was going to try is quit()

You can use the bash command echo $? to get the exit code of the Python interpreter.

python3
Python 3.8.2 (default, Apr 1 2020, 15:52:55)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> quit()
$ echo $?
0

We can also define the type of code the interpreter should exit with by handing quit() an integer argument less than 256

python3
Python 3.8.2 (default, Apr 1 2020, 15:52:55)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> quit(101)
$ echo $?
101

exit() has the same functionality as it is an alias for quit()

python3
Python 3.8.2 (default, Apr 1 2020, 15:52:55)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> exit(101)
$ echo $?
101

Neither quit() nor exit() are considered good practice, as they both require the site module which is meant to be used for interactive interpreters and not in programs. For our programs, we should use something like sys.exit

python3
Python 3.8.2 (default, Apr 1 2020, 15:52:55)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import sys
>>> sys.exit(101)
$ echo $?
101

Notice that we need to explicitly import a module to call exit(), this might seem like its not an improvement but it guarantees that the necessary module is loaded because it’s not a good assumption site will be loaded at runtime. If we don’t want to import extra modules, we can do what exit()quit() and sys.exit() are doing behind the scenes and raise SystemExit

python3
Python 3.8.2 (default, Apr 1 2020, 15:52:55)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> raise SystemExit(101)
$ echo $?
101

Exit with error messages

What if we get bad input from a user? Let’s look back at our input.py script, and add the ability to handle bad input from the user (CTRL+D to pass an EOF character)

nano input.py
try:

name=input("What's your name?\n")

print("Hi, "+name+"!")

except EOFError:

print("EOFError: You didn't enter anything!")

$ python3 input.py
What's your name?
EOFError: You didn't enter anything!

The try statement tells Python to try the code inside the statement and to pass any exception to the except statement before exiting.

Exiting without error

What if the user hands your program an error but you don’t want your code to print an error, or to do some sort of error handling to minimize user impact?

We can add a finally statement that lets us execute code after we do our error handling in catch

nano input.py
try:

name=input("What's your name?\n")

if(name==''):

print("Name cannot be blank!")

except EOFError:

#print("EOFError: You didn't enter anything!")
name="Blankname"

finally:

print("Hi, "+name+"!")

$ python3 input.py
What's your name?
Hi, Blankname!

Notice the user would never know an EOFError occurred, this can be used to pass default values in the event of poor input or arguments.

Exit and release your resources

Generally, Python releases all the resources you’ve called in your program automatically when it exits, but for certain processes, it’s good practice to encase some limited resources in a with block.

Often you’ll see this in open() calls, where failing to properly release the file could cause problems with reading or writing to the file later.

nano openfile.py
with open("testfile.txt","w") as file:

file.write("let's write some text!\n")

$ python3 openfile.py
$ cat testfile.txt
let's write some text!

The with block automatically releases all resources requisitioned within it. If we wanted to more explicitly ensure the file was closed, we can use the atexit.register() command to call close()

$ nano openfile.py
import atexit

file=open("testfile.txt","w")

file.write("let's write some text!\n")

atexit.register(file.close)

If resources are called without using a with block, make sure to explicitly release them in an atexit command.

Exit after a time

If we are worried our program might never terminate normally, then we can use Python’s multiprocessing module to ensure our program will terminate.

$ nano waiting.py
import time

import sys

from multiprocessing import Process

integer=sys.argv[1]

init=map(int, integer.strip('[]'))

num=list(init)[0]

def exclaim(int):

time.sleep(int)

print("You were very patient!")

if __name__ == '__main__':

program = Process(target=exclaim, args=(num,))

program.start()

program.join(timeout=5)

program.terminate()

$ python3 waiting.py 7
$ python3 waiting.py 0
You were very patient!

Notice how the process failed to complete when the function was told to wait for 7 seconds but completed and printed what it was supposed to when it was told to wait 0 seconds!

Exiting using a return statement

If we have a section of code we want to use to terminate the whole program, instead of letting the break statement continue code outside the loop, we can use the return sys.exit() to exit the code completely.

$ nano break.py
import time

import sys

def stop(isTrue):

for a in range(0,1):

if isTrue:

break

else:

print("You didn't want to break!")

return sys.exit()

mybool = False

stop(mybool)

print("You used break!")

Exit in the middle of a function

If we don’t want to use a return statement, we can still call the sys.exit() to close our program and provide a return in another branch. Let’s use our code from break.py again.

$ nano break.py
import time

import sys

def stop(isTrue):

for a in range(0,1):

if isTrue:

word="bird"

break

else:

print("You didn't want to break!")

sys.exit()

mybool = False

print(stop(mybool))

Exit when conditions are met

If we have a loop in our Python code and we want to make sure the code can exit if it encounters a problem, we can use a flag that it can check to terminate the program.

$ nano break.py
import time

import sys

myflag=False

def stop(val):

global myflag

while 1==1:

val=val+1

print(val)

if val%5==0:

myflag=True

if val%7==0:

myflag=True

if myflag:

sys.exit()

stop(1)

$ python3 break.py
2
3
4
5

Exit on keypress

If we want to hold our program open in the console till we press a key, we can use an unbound input() to close it.

$ nano holdopen.py
input("Press enter to continue")
$ python3 holdopen.py
Press enter to continue
$

We can also pass CTRL+C to the console to give Python a KeyboardInterrupt character. We can even handle the KeyboardInterrupt exception like we’ve handled exceptions before.

$ nano wait.py
import time

try:

i=0

while 1==1:

i=i+1

print(i)

time.sleep(1)

except KeyboardInterrupt:

print("\nWhoops I took too long")

raise SystemExit

$ python3 wait.py
1
2
3
^C

Whoops I took too long

Exit a multithreaded program

Exiting a multithreaded program is slightly more involved, as a simple sys.exit() is called from the thread that will only exit the current thread. The “dirty” way to do it is to use os._exit()

$ nano threads.py
import threading

import os

import sys

import time

integer=sys.argv[1]

init=map(int, integer.strip('[]'))

num=list(init)[0]

def exclaim(int):

time.sleep(int)

os._exit(1)

print("You were very patient!")

if __name__ == '__main__':

program = threading.Thread(target=exclaim, args=(num,))

program.start()

program.join()

print("This should print before the main thread terminates!")

$ python3 threads.py 6
$

As you can see, the program didn’t print the rest of the program before it exited, this is why os._exit() is typically reserved for a last resort, and calling either Thread.join() from the main thread is the preferred method for ending a multithreaded program.

$ nano threads.py

import threading

import os

import sys

import time

import atexit

integer=sys.argv[1]

init=map(int, integer.strip('[]'))

num=list(init)[0]

atexit.register(print,"Threads exited successfully!")

def exclaim(int):

time.sleep(int)

print("You were very patient!")

if __name__ == '__main__':

program = threading.Thread(target=exclaim, args=(num,))

program.start()

program.join()

$ python3 threads.py 6
You were very patient!
Threads exited successfully!

End without sys exit

Sys.exit() is only one of several ways we can exit our python programs, what sys.exit() does is raise SystemExit, so we can just as easily use any built-in Python exception or create one of our own!

$ nano myexception.py
class MyException(Exception):

pass

try:

raise MyException()

except MyException:

print("The exception works!")

$ python3 myexception.py
The exception works!

We can also use the os._exit() to tell the host system to kill the python process, although this doesn’t do atexit cleanup.

$ python3
Python 3.8.2 (default, Apr 1 2020, 15:52:55)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import os
>>> os._exit(1)

Exit upon exception

If we want to exit on any exception without any handling, we can use our try-except block to execute os._exit().

Note: this will also catch any sys.exit()quit()exit(), or raise SystemExit calls, as they all generate a SystemExit exception.

$ python3
Python 3.8.2 (default, Apr 1 2020, 15:52:55)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import os
>>> try:
... quit()
... except:
... os._exit(1)
...
$ echo $?
1

Exit and restart

Finally, we’ll explore what we do to exit Python and restart the program, which is useful in many cases.

$ nano restart.py
import atexit

import os

atexit.register(os.system,"python3 restart.py")

try:

n=0

while 1==1:

n=n+1

if n%5==0:

raise SystemExit
except:

print("Exception raised!")

$ python3 restart.py
Exception raised!
Exception raised!
...
Exception raised!
^Z
[3]+ Stopped python3 restart.py

I hope you find the tutorial useful. Keep coming back.

Thank you.

0