DEV Community: Cecília Coelho

How to code a price tracker using Python - clearly explained (beginner's friendly)

Cecília Coelho — Thu, 02 Dec 2021 12:05:30 +0000

In this beginner's friendly tutorial we will be coding a simple Python script to track the prices of your most wanted products 🤑 (this way you'll never miss those sweet deals 😉) in 5 simple steps:

1-creating a CSV file to store your wishlist and each item's target prices;
2-getting the price of an item using an URL;
3-checking if the price is below a target value;
4-checking all items of a wishlist;
5-automatic script running (Windows and Linux).

In the end you'll have a script that builds a wishlist in a file by adding new items and checks the price of all items in it, warning you if it's the perfect time to spend your money (no more infinite tabs to check every once in a while).
You'll feel like a hacker after this! 🕵️ 👩‍💻

Let's go!

Python libraries we need:

For this project you'll need some Python libraries 🐍, I'll go through them briefly so you get a general idea about them (more exploration is encouraged 🔍).
Make sure you have these installed, if not you can pay a visit to our best friend "The" shell (or terminal).

-requests: allows you to make HTTP requests, meaning getting the content of a webpage;

-BeautifulSoup4: parses the content extracted from a webpage;

-csv: library to read and write CSV (Comma-Separated Values) format files;

-re: package to use regular expression matching operations. Very powerful to filter strings by matching a specific pattern;

-os: provides ways to interact with your operating system (removing files, changing current directory, etc.).

Step 1: Creating a CSV wishlist

First we need to store our wanted items in a wishlist. This way our script will be able to check the prices of every item without us moving a finger (laziness intensifies 😏).
But what information should the wishlist hold?
Short answer, whatever you want and/or need. In this tutorial we'll be using 3 features to describe each item: the name of the item as in the web page; its web address; and the maximum price we are willing to pay for it (let's call it target price).
To avoid creating a CSV file by hand with our wishlist with the following information,



item's name , in store url , target price

we can make the script create and add new items to the list for us.
So, what's the strategy? 🤔
We are going to start implementing our price tracker function. To make it create and modify the wishlist for us we need to give it some information as input: the path where we want to store the wishlist; the url of the item we want to add; the maximum price we want to pay for that item.



import requests 
import bs4 
import csv 
import re 
from os.path import exists
def tracker(filepath , item='' , target=0):

Wait a second... 😑
Did we just forget to define the item's name as an input? Well, if you want you can add it but with the URL we can retrieve that information easily.

Our function is named tracker and receives a mandatory argument, the path to store the CSV (filepath), and 2 optional arguments, the item to be added and the target price.
The first optional input argument of our function, item, receives a string which corresponds to the url of the item we want to add to our wishlist. To add the item, first we need to check if there is a wishlist in the path given by the user or a new one will be created:



    if len(item) != 0:

        if not exists(filepath):
            f = open(filepath , 'w' , encoding='UTF8')
        else:
            f = open(filepath , 'a')

        writer = csv.writer(f)

Remember that we want to have 3 features for each item. The function took as input 2 of them, the URL and the target price (0 if not specified by the user). We are missing the item's name... The process of getting it from the URL is the same as retrieving it's current price so let's get to the powerful part of the tutorial! 🐱‍🏍

Step 2: Getting information of an item using an URL

Who has ever randomly pressed a keyboard key while browsing and something really weird (and scary 😬) came up on the side of the webpage? 🙋‍♀️


Figure 1. Weird scary stuff that pops up on the browser.

The F12 key opens the browser's Developer Tools and, to make it simple, it allows everyone to see the code that is behind a webpage. This includes every piece of text that is being displayed (which is what we are looking for). So, what we want is Python to have access to the code shown in the Developer Tools and get the information we want.
First, we need Python to mimic us when we open an URL and copy the code behind it. This can be done with the requests library:



rq = requests.get(item , headers=({'User-Agent': 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36', 'Accept-Language': 'en-US, en;q=0.5'}))

where item is the url. You don't need to worry much about the headers argument of the get() but if you are curious on why we are passing that information read the note below, else just skip it. ⏩

NOTE: When we use a browser to access a webpage, the servers hosting the page know which browser the user is using so it can send the page optimized to that specific browser. If this information is not available then we may run into some problems: the code gotten from the request is not the same as the one we see in our browser; the server can block unrecognized traffic so it prevents Python to get the info. In this tutorial we are pretending to be using Mozilla Firefox 😉. In addition to this, we want to get the webpage in English despite of our system's preferences.

This code line outputs a Response object, to easily access the information it contains we use BeautifulSoup so everything stays nice and pretty in a nested structure which makes it a breeze to navigate. 🧭



 info = bs4.BeautifulSoup(rq.content , features='lxml')

and if we print the variable (or store in a file) we will get something like this:


Figure 2. Retrieved information in a nested structure.

Now that we have all the code behind the webpage let's extract what we want. First we are going to find out how to retrieve the item's name, to do this you need to find the id tag that holds that piece of information.
Open the url on your browser and press F12 to unveil the secrets of the universe! (not really... but it's something 😅).
Use the find command (ctrl+f) to search for the item's name, the one you can see in the webpage, and check the id, that's what we are going to use.
Remember the code we extracted from the webpage right before this? With the id that holds the item's name we can search the retrieved information using the following line of code (the strip() makes sure to remove all extra spaces):



name = info.find(id = "productTitle").get_text().strip()

Similarly, to get the item's price you just have to follow the same steps.



price = info.find(id = "price_inside_buybox").get_text().strip()

If you print the price variable you'll notice that it comes not only with numeric info but also the currency identifier (example: 'USD9.99'). This makes it impossible to compare it with a target price or do any kind of statistical approach, boring...🥱.
Let's get rid of it! To do that, we can split the price variable by a regular expression and keep the last bit ('9.99'). The goal is to split the string on the first number that appears. Adding this to the code line above comes:



price = re.split(r'(^[^\d]+)', info.find(id = "price_inside_buybox").get_text().strip())[-1]

Now we have all information needed to add the item into the CSV wishlist so let's do it.



writer.writerow([name , item , target , price])

In addition to the features of the item (name, url, target price), we'll also write the price we just retrieved. This way you can keep the price history (this can be used for lot's of cool stuff like a Machine Learning model to predict future price drops 🤩).

Step 3: Checking if it's time to buy

We added the item to our wishlist, now it's time for difficult decisions. Are we ready to drop the money? 🙄
If we declared the maximum amount of money we want to spend then, the target input variable will hold it and store a value different from 0 or negative (sorry to ruin the party but no one is going to pay you to get something 🤯 or is it... 😶) . Our Python script should let us know when the current price is under our buying limit.



if target > 0 and price <= target: 
    print("BUY IT NOW!!!!!!!!!!!!!!!!!!!")

Step 4: Checking all items of a wishlist

We are almost done, hang in there! 💪
Imagine we added 5 items into our wishlist and we want to check if any gets in our price range. To do this we have to: open the CSV file; extract every item's URL and target price; use the same code of Step 2 and Step 3; (bonus) store the current price on the CSV file.



        fread = open(filepath , 'r')
        items = list(csv.reader(fread))
        fread.close()

        fwrite = open(filepath , 'w')
        wr = csv.writer(fwrite)

        for i in range(len(items)):

            rq = requests.get(items[i][1] , headers=({'User-Agent': 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36', 'Accept-Language': 'en-US, en;q=0.5'}))
            info = bs4.BeautifulSoup(rq.content , features='lxml') 

            price = re.split(r'(^[^\d]+)', info.find(id = "price_inside_buybox").get_text().strip())[-1]
                items[i].append(price)

            if items[i][2] > 0 and price <= items[i][2]:
                print("BUY IT NOW!!!!!!!!!!!!!!!!!!!")


        wr.writerows(items)
        fwrite.close()

⚠ WARNING ⚠
If you run this script a considerable amount of times you can get an error stating that the id couldn't be found don't worry, this happens because the server hosting an URL has blocked you 🙁 . Each time you run this script a request is sent from your IP address to the target server, if the server gets several requests from you in a very short period of time it will classify your traffic as not normal and block your access. In this case just wait till the next day 😉.
To prevent the script from crashing if a URL is blocked, and still check the others, we can add some try and except blocks. Check the full code below.



import requests
import bs4
import csv
import re
from os.path import exists

def tracker(filepath , item='' , target=0):

    if len(item) != 0:

        if not exists(filepath):
            f = open(filepath , 'w' , encoding='UTF8')
        else:
            f = open(filepath , 'a')

        writer = csv.writer(f)
        rq = requests.get(item , headers=({'User-Agent': 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36', 'Accept-Language': 'en-US, en;q=0.5'}))
        info = bs4.BeautifulSoup(rq.content , features='lxml') 

        try:
            name = info.find(id = "productTitle").get_text().strip()
            price = re.split(r'(^[^\d]+)', info.find(id = "price_inside_buybox").get_text().strip())[-1]

            if target > 0 and price <= target:
                print("BUY IT NOW!!!!!!!!!!!!!!!!!!!")

            writer.writerow([name , item , target , price])

        except:
            raise Exception("Couldn't retrieve product's info")

    else:
        fread = open(filepath , 'r')
        items = list(csv.reader(fread))
        fread.close()

        fwrite = open(filepath , 'w')
        wr = csv.writer(fwrite)

        for i in range(len(items)):

            rq = requests.get(items[i][1] , headers=({'User-Agent': 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.36', 'Accept-Language': 'en-US, en;q=0.5'}))
            info = bs4.BeautifulSoup(rq.content , features='lxml') 

            try:
                price = re.split(r'(^[^\d]+)', info.find(id = "price_inside_buybox").get_text().strip())[-1]
                items[i].append(price)

                if items[i][2] > 0 and price <= items[i][2]:
                    print("BUY IT NOW!!!!!!!!!!!!!!!!!!!" + items[i][1])

            except:
                raise Exception("Couldn't retrieve product's info")

        wr.writerows(items)
        fwrite.close()

tracker("items.csv")

Step 5: Automatic script running

To have our script running everyday, without us worrying about it, we can schedule it to run at specific times.

Windows users

First you need to create an executable which will run the script. To do that create a text file and change it's extention to .bat ;
Inside the file, add the path to the Python executable in your computer and the path to the script in the following format: ```

pause

The *pause* prevents the terminal from closing after completion, you can remove it if you want. If you click the *.bat* file it will now run the script! To automatize the clicking action we will use the Windows Task Scheduler.

- Use the searcher to find Task Scheduler and click "Create Basic Task" ;
- Choose the task's name, occurrence frequency and trigger time;
- Give the path to the *.bat* file we just created;
- Finish!

|![Figure](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7jjnctm8gf069ljzdhzo.png)|
|:--:| 
| **Figure 3.**  Steps to schedule a task on Windows.|


#### 🐧 **Linux users**

First we you need to make sure you have *cron* installed and enable to start on boot. If not, for fedora, do:

dnf install cronie cronie-anacron
systemctl enable crond
chkconfig crond on


Now we need to schedule the task using *cron*.

- Go to the terminal and do ```crontab

 -e

``` to open the file where all scheduled tasks are, if any;
- Add a line with the following ```0

 10 * * * python/path price/tracker/path

```. This means the script will run every day at 10a.m. To mess with the scheduling time you can use https://crontab.guru/ ;
- Save and exit. You should see this output on the terminal ```crontab:

 installing new crontab

Finish!

All set! Goodbye missed deals! 👏😁

❗BONUS TIP ❗
With this script you can do awesome things, just let your imagination run wild! I'll list some below, have fun! 🤗

-price predicter;
-price variation analysis;
-restock alerts;
-price comparison between several stores.

How to host a worldwide private Git server 🌍 on a Raspberry Pi - clearly explained (beginner's friendly)

Cecília Coelho — Mon, 30 Aug 2021 14:14:56 +0000

In this beginner's friendly tutorial we will be setting up a Raspberry Pi (aka Pi) to host your very own private Git server that will be staying in the comfort of your home 🏡. This way you can have your (very important highly secret 😈) projects backed-up and accessible without relying on external agents (like GitHub, GitLab, etc) in 5 simple steps:

1-Git installation
2-Mounting a USB drive
3-Initializing a Git repository
4-Add/Commit/Push into your Raspberry Pi
5-Using your Git server anywhere

Before we start, I'm assuming you already have setup your Pi and have SSH enabled. If you don't follow this guide: https://dev.to/ceciliacoelho/how-to-setup-a-headless-raspberry-pi-clearly-explained-beginner-s-friendly-4aph

📝 What we will be using:

Laptop
Raspberry Pi 4
USB (any size you need)
Internet Router

Step 1: Git installation

SSH into your Raspberry Pi using your laptop (or use VNC Viewer and open the terminal in the desktop). First we are going to make sure everything is up-to-date,

sudo apt-get update
sudo apt-get upgrade
and reboot sudo reboot.

Again, access your Pi to install Git,
sudo apt-get install wget git
When it's finished turn off the Pi.

Step 2: Mounting a USB drive

Plug your USB drive into the Raspberry Pi (make sure it's formatted as FAT) and turn the Pi back on and SSH into it.
Now we are going to create and assign a directory to this USB so every time we want to access our projects we know exactly where they are 📌. To create the directory do
mkdir usbdrv
and now we need to map the USB to it. To do that first let's get the USB info, do
sudo blkid
you should get something like this:

/dev/mmcblk0p1: LABEL_FATBOOT="boot" LABEL="boot" UUID="5DE4-665C" TYPE="vfat" PARTUUID="225e7479-01"
/dev/mmcblk0p2: LABEL="rootfs" UUID="7295bbc3-bbc2-4267-9fa0-099e10ef5bf0" TYPE="ext4" PARTUUID="225e7479-02"
/dev/mmcblk0: PTUUID="225e7479" PTTYPE="dos"
/dev/sda1: LABEL="GITPI" UUID="F234-F2DF" TYPE="vfat" PARTUUID="0f6f2c0f-01"

When I formatted my USB I gave it the label "GITPI" so the last line of the above block corresponds to the information I'm looking for, you should have something similar for yours.
Let's tell the Pi that our USB contents should go to the created "usbdrv" directory by editing the "systems table" file, do
sudo nano /etc/fstab
A file should have popped up in a text editor, in the end of the file add this line (my USB was at /dev/sda1 as you can see in the output of sudo blkid, make sure to replace by whatever you got):
/dev/sda1 /home/pi/usbdrv vfat uid=pi,gid=pi,umask=0022,sync,auto,nosuid,rw,nouser 0 0
to save and close the file Ctrl-x -> Y -> return.
Once more, it's reboot time! 😅

Step 3: Initializing a Git repository

Now go to your laptop where you "work" **cough cough** 🙄, you can create a blank folder to start a new project or you already have one full of juice 😉, the step is the same. Initialize a Git repository in the folder using git init.
Back to the Pi 🥧, create a folder with the .git extension to hold the repository, do (replace projectname by the name you want to give your repository)
mkdir usbdrv/projectname.git
Go into the directory you just created
cd usbdrv/projectname.git
and create an empty repository,
git init --bare
you should get this output:

Initialized empty Git repository in /home/pi/usbdrv/projectname.git/

❗❗ If you get permission denied while executing these commands try and add sudo to the beginning of each.

Step 4: Add/Commit/Push into your Raspberry Pi

Finally the magic is going to happen!!!!! 🧙‍♂️

Go to your laptop and create a file if the folder is empty, otherwise we already have stuff to push into our private Git, how exciting! 😁
First we need to add the remote, do
$ git remote add pi pi@192.168.50.166:/home/pi/usbdrv/projectname.git
where the first "pi" will be the name we'll be using when pushing. Don't forget to plug in your Raspberry Pi address (the same you use to ssh) and the name of your git folder (created in step 3).

Now, for the main event, the Add/Commit/Push triathlon! 🏊‍🚴‍♂️🏃‍♂️💨

git add .
git commit -m "first commit: is this really working?"
git push pi master It is going to ask for your Raspberry Pi password for the user you are currently using, I'm using pi. If everything went well you should get this output:

Enumerating objects: 3, done.
Counting objects: 100% (3/3), done.
Writing objects: 100% (3/3), 222 bytes | 222.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
To 192.168.50.166:/home/pi/usbdrv/projectname.git
 * [new branch]      master -> master

Looks like a success right? 🤔
If you are like me and you want to be sure your stuff is really on that USB and make sure if something happens with your Pi you can just plug the USB on any laptop and you'll have access to everything then stay with me!🧐

Turn off the Raspberry Pi and unplug the USB;
Plug the USB into your laptop;
Go to the USB and open everything your eyes see; 😦
Fail to find anything that looks like what you just push; 😨
Panic! 😱😱😱😱😱

Wait a second!

The USB has a Git repository so you won't be able to see your files like that 😏.
Use the terminal to navigate to somewhere you want to put your stuff in and do,
git clone pathToUSB/projectname.git
This command will clone your repository and when it's over you should see what you were expecting, your files! 🤗

Step 5: Using your Git server anywhere 🌍

The steps explained above will only work in case the laptop you are using to access the Git server is on the same network of the Raspberry Pi hosting it, meaning both have to be connected to the same router (via Wi-Fi or LAN).

HOW LAME! 😒

What we want is a Git server that we can use anywhere, outside and inside the Raspberry's network. To do this we need what is called port forwarding and the steps to setting it up will depend on the router you have. Note that port forwarding is considered dangerous since it gives access to your local network from the outside, make sure you use strong passwords at least.
The steps to perform the above instructions on your router can be found in the user manual or online:

Assign a static IP address for the Raspberry Pi: this will prevent us from losing the address of the Pi due to router reassignment. To do this you need to access your router's through a web browser by using its IP address and navigate to the page where you can manually assign IP, Figure 1.


Figure 1. Page to assign a static IP address.

After adding the Raspberry Pi, reboot.

Port forwarding: launch the router's configuration web page again and look for the port forwarding page, Figure 2.


Figure 2. Port forwarding page.

Fill in the required information and make sure the Port is 22, this is the SSH port used by the Raspberry Pi, and use Protocol TCP.

Now we will setup the remote of the git repository to be the universal address of the Pi, that you will be able to access from anywhere! Go back to the project you setup in step 4 and do (where "222" is the value you chose for Port Range):

$ git remote add remotepi pi@192.168.40.16:222/home/pi/usbdrv/projectname.git

Everything is set now, get on the next plane to wherever and let's try! 🛫😎

git add .
git commit -m "commit from the North pole!" ⛄
git push remotepi master

That's it, first push outside the Raspberry Pi's network!

Success! You are now ready to build some awesome projects!!! 🤩💪🎉🎉🎉🎉🎉🎉🎉

If you run into any problems just leave a comment. 😉

How to setup a headless Raspberry Pi - clearly explained (beginner's friendly)

Cecília Coelho — Fri, 20 Aug 2021 18:34:05 +0000

In this beginner's friendly tutorial we will be setting up a Raspberry Pi (aka Pi) without an external monitor and keyboard (some of us just have a laptop 🤷‍♀️) in 4 simple steps:

1-getting an OS into the microSD card;
2-allowing remote access in a local network;
3-discovering the address and connecting in terminal;
4-viewing the desktop.

Also, a small discussion on how to choose an Operating System (OS) for a headless setup is also given, so you can later play around if you wish too 😉.

📝 What we will be using:

Laptop
Raspberry Pi 4
MicroSD card (whatever size you want, bigger is better)
Power supply
Ethernet cable (optional but recommended)

Step 1: Getting an OS in the microSD card

Install an imaging utility that will get an OS into our microSD card. The easiest, and thanks to the Raspberry Pi Foundation team, is to use the official Raspberry Pi Imager (get it here: https://www.raspberrypi.org/blog/raspberry-pi-imager-imaging-utility/).
After installing, insert your microSD card into your laptop and open the Raspberry Pi Imager, you will be greeted by the screen in Figure 1 (a).
To see the given OS options click the "choose OS" button (Figure 1 (b)), the most straightforward option is to go with the recommended Raspberry Pi OS (32-bit). That's us! 🙋‍♀️🙋‍♂️
Choose the microSD as storage, click the write button and wait till a pop-up message appears stating to remove the card.
Note that the Imager has a whole lot of options including: two more versions of the Raspberry OS (Figure 1 (c)); other general OS (Figure 1 (d)) and several focused OS that we will skip (for now at least).


Figure 1. Raspberry Pi Imager interface: (a) main window; (b) choose OS options; (c) Raspberry Pi OS options; (d) other general OS options.

If you are feeling adventurous you can go ahead and pick other OS, the steps will be identical, you just need to pay attention to some details:

❗ You can jump to step 2 if you don't want details about OS choices ❗

Headless friendly - Since we are doing a headless setup (no monitor), we need to make sure the OS supports it or you won't be able to access your Pi, in the first boot up, using your laptop. I learned this the hard way after some experimentation (and a lot of headaches) 😓. The only OS option you need to be careful with is the Manjaro-ARM Linux. If you want to try it make sure to choose the minimal version since all others will require a monitor to do the initial setup. (To check if an OS has headless setup you can check the documentation of the release);
Different distributions - All OS available in the Imager are Debian except Manjaro, which is Arch based. The commands used with Debian won't work when using Manjaro;
Storage - If you are running low on resources (4GB microSD card) or you are "The Scrooge McDuck" 🤑 of storage, you may have noticed that there are options that take roughly half the space of others! The Raspberry Pi OS has three versions: Lite, that doesn't include a Graphical User Interface (GUI) so you can only use the terminal (hacker style!); the recommended includes a GUI; Full includes a GUI and some pre-installed software. If you are a beginner and want to try a no-GUI version but are not sure if you will regret it, don't worry, you can always install a GUI using the terminal (coming soon); 😉
Usage - Are you a beginner that wants to discover Linux or have a specific project in mind? If you want to use you Raspberry Pi to host a Git server, a cloud storage or something similar, you won't be needing a GUI, and doing so will just waste resources, so you can choose a version without a desktop environment (like Raspberry Pi OS Lite or Manjaro ARM Minimal).

Step 2: Allowing remote access in a local network

Insert the microSD card into your laptop so we can modify it to tell our Pi we are going to access remotely, using what is called SSH.
Open the file explorer, you will see a bunch of folders and files, create a new file without extension called "ssh", you should see something like Figure 2.


Figure 2. The created SSH file should look like this.

This file will make the Pi enable SSH when it turns on, and thus making it possible for us to access it using our laptop's terminal when both are on the same network.

To connect the Pi to the same network as your laptop you can use:

Ethernet cable: Plug the cable onto the Pi and your internet router and you're ready to go!
Wifi: Just like the ssh file, create a file named "wpa_supplicant.conf". This will store your wifi's name and password so the Pi will read this file when starting and connect to your wifi. Open the created file and copy/paste the following and substitute the "WIFI_NAME" and "WIFI_PASSWORD" fields with the login details:

ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev

 update_config=1

country=US

network={

    ssid="WIFI_NAME"

    psk="WIFI_PASSWORD"

    scan_ssid=1
}

Step 3: Discovering the address and connecting in terminal

Remove the microSD card from your laptop, plug it into your Raspberry Pi and connect a power supply. You will see a green light turning on, this means our Pi is now alive! 🤗
Now, go to your laptop and open the terminal (in Windows it's called Command Prompt).
Now we are going to check if the Pi was able to connect to our network, use the command ping raspberrypi and you should see something like this:

Pinging raspberrypi.local [192.168.50.166] with 32 bytes of data:
Reply from 192.168.50.166: bytes=32 time<1ms TTL=64
Reply from 192.168.50.166: bytes=32 time<1ms TTL=64
Reply from 192.168.50.166: bytes=32 time<1ms TTL=64
Reply from 192.168.50.166: bytes=32 time<1ms TTL=64

Ping statistics for 192.168.50.166:
    Packets: Sent = 4, Received = 4, Lost = 0 (0% loss),
Approximate round trip times in milli-seconds:
    Minimum = 0ms, Maximum = 0ms, Average = 0ms

This is like the Pi shouting "I'm alive!" 🎉 and it tells where its home is in case we want to go over and say hi (don't forget the 🥧), mine lives at 192.168.50.166.
You now know your Pi's address so let's access it using ssh pi@192.168.50.166. It will ask you for a password, since it's the first login then it has to be the default one, use raspberry (the prompt won't move, it's normal). If you were successful the location on your terminal should have changed to pi@raspberrypi:~ $, this means we are now working in the Raspberry Pi!

❗ Note that if you choose an OS other than Raspberry Pi OS (also referred as Raspbian), the default user (pi) and password (raspberry) may be different, you know who to ask 🧐.

Step 4: Viewing the desktop

The terminal is great but we want to see the Graphical User Interface to play around with Linux in a more friendly way. To do this we need a software that allows to control a remote desktop, we are going to use VNC Server.
First let's make sure our Pi has the latest updates, on the terminal do,
pi@raspberrypi:~ $ sudo apt-get update
pi@raspberrypi:~ $ sudo apt-get upgrade
and wait (quick, run and grab some coffee 🏃‍♂️☕).
Now we need to install the VNC Server using sudo apt–get install realvnc–vnc–server realvnc–vnc–viewer (if it gives an error and you copy/paste the command try rewriting the dashes, sometimes it pastes a double dash 🙄).
When the installation finishes we need to enable it, do,
sudo raspi-config
a pop-up window will appear, Figure 3. Use the arrows and return button to go to "3: Interface Options" -> "P3 VNC" and select "Yes".


Figure 3. Configuration options pop-up window.

Almost done! Now we have to install the VNC Viewer in our laptop, I use RealVNC (find it here: https://www.realvnc.com/en/connect/download/viewer/).
After installing, launch the software and write your Pi address on the top bar and hit enter, Figure 4. A pop-up window will ask for your credentials to access, after that you will be able to see your Raspberry Pi's desktop!


Figure 4. Accessing the Raspberry Pi desktop with VNC Viewer by entering its address. After doing this the first time, an icon will appear to ease future accesses.

❗❗ If all you can see is a black screen go back to the Pi's terminal and do sudo raspi-config. Navigate to "Display Options" -> "Resolution" and choose an option other than "default". Reboot you Pi sudo reboot and try accessing again on the VNC Viewer. It should work now!

That's it! Now it's play time! 🥳🥳🥳🥳

DEV Community: Cecília Coelho

How to code a price tracker using Python - clearly explained (beginner's friendly)

Let's go!

Python libraries we need:

Step 1: Creating a CSV wishlist

Step 2: Getting information of an item using an URL

Step 3: Checking if it's time to buy

Step 4: Checking all items of a wishlist

Step 5: Automatic script running

Windows users

How to host a worldwide private Git server 🌍 on a Raspberry Pi - clearly explained (beginner's friendly)

📝 What we will be using:

Step 1: Git installation

Step 2: Mounting a USB drive

Step 3: Initializing a Git repository

Step 4: Add/Commit/Push into your Raspberry Pi

Finally the magic is going to happen!!!!! 🧙‍♂️

Now, for the main event, the Add/Commit/Push triathlon! 🏊‍🚴‍♂️🏃‍♂️💨

Wait a second!

Step 5: Using your Git server anywhere 🌍

Everything is set now, get on the next plane to wherever and let's try! 🛫😎

That's it, first push outside the Raspberry Pi's network!

Success! You are now ready to build some awesome projects!!! 🤩💪🎉🎉🎉🎉🎉🎉🎉

How to setup a headless Raspberry Pi - clearly explained (beginner's friendly)

📝 What we will be using:

Step 1: Getting an OS in the microSD card

Step 2: Allowing remote access in a local network

Step 3: Discovering the address and connecting in terminal

Step 4: Viewing the desktop

That's it! Now it's play time! 🥳🥳🥳🥳

Don't worry, if you mess up something you can always redo all this steps and you'll have a fresh OS to destroy again! 😈🔪