BeautifulSoup, Pandas- Github.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import bibliotek\n",
    "import requests\n",
    "from bs4 import BeautifulSoup\n",
    "import pandas as pd\n",
    "import csv\n",
    "from time import sleep\n",
    "import ipywidgets as widgets\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# funkcja wykorzystana w kodach:\n",
    "\n",
    "def zmiana_na_float (cecha):\n",
    "    \"\"\" \n",
    "    Funkcja do zmiany danych poszczegolnych cech na float z odcięciem jednostki.\n",
    "      \n",
    "    Parametry:\n",
    "    ----------\n",
    "    cecha (str): Liczba podana jako ciąg znaków \n",
    "  \n",
    "    Wynik:\n",
    "    ------\n",
    "    float: Ciąg znaków zamieniony na float.\n",
    "    \n",
    "    Przykład:\n",
    "    ---------\n",
    "    zmiana_na_float('50,2 m2')->50.2\n",
    "      \n",
    "    \"\"\"\n",
    "    \n",
    "    if isinstance (cecha, str): # jeśli cecha jest stringiem\n",
    "        return float(cecha.rsplit(' ',1)[0].replace(' ','').replace(',','.'))     #rsplit-rozdzielam po spacji, ale tylko jednej spacji licząc od końca. Jeśli w stringu będzie kilka spacji, to podzieli tylko po tej ostatniej \n",
    "    else:\n",
    "        return cecha"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Kod do pobrania szczegółów ogłoszeń (widocznych z poziomu strony głównej)-MIESZKANIA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- najpierw nałożyłam filtr na Otodom, jakie nieruchomosci mnie interesują ( np. wg.lokalizacji, rodzaju nieruchomości - w tym wypadku mieszkania, powierzchni itd)\n",
    "- po nałożeniu filtrów, Otodom zwrócił mi kilka stron z ogłoszeniami odpowiadającymi moim kryteriom\n",
    "- w tym kodzie zaczytam jedynie dane z pierwszej strony zwróconej przez Otodom. Są to dane widoczne z poziomu tej strony ( bez zagłębiania się w szczegóły, które można zobaczyć tylko po wejściu w konkretne oferty)\n",
    "- w dalszych kodach pobiorę dane z kolejnych stron zwróconych przez Otodom, jak również szczegółowe dane widoczne tylko po wejściu w konkretną ofertę \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Podaj adres strony www: https://www.otodom.pl/sprzedaz/mieszkanie/swarzedz/?search%5Bdist%5D=0&search%5Bsubregion_id%5D=458&search%5Bcity_id%5D=81\n"
     ]
    }
   ],
   "source": [
    "# pobieram pierwszą stronę z ofertami ( najpierw nałożyłam filtr na otodom i to jest link do odfiltrowanej strony)\n",
    "adres_strony=input('Podaj adres strony www: ')\n",
    "zawartosc = requests.get(adres_strony)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tworzę obiekt BS, w którym są zawarte dane z wybranej strony www\n",
    "soup = BeautifulSoup(zawartosc.content, 'html.parser')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = csv.writer(open('oferty_mieszkania.csv', 'w'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wszystkie_oferty = soup.find(class_='col-md-content section-listing__row-content') ### klasa, w ktorej są wszystskie oferty wyszukane na otodom\n",
    "wszystkie_oferty_items = wszystkie_oferty.find_all(class_=\"offer-item-details\")## klasa, w której są szczegóły poszczególnych ofert\n",
    "\n",
    "\n",
    "for item in wszystkie_oferty_items: # dla każdej cechy, którą chcę wydobyć, szukam jej klasy na stronie Otodom\n",
    "    naglowek=item.find(class_='text-nowrap hidden-xs').get_text()\n",
    "    liczba_pokoi=item.find(class_=\"offer-item-rooms hidden-xs\").get_text()\n",
    "    powierzchnia=item.find(class_=\"hidden-xs offer-item-area\").get_text()\n",
    "    cena=item.find(class_=\"offer-item-price\").get_text()\n",
    "    cena_zlm2=item.find(class_=\"hidden-xs offer-item-price-per-m\").get_text()\n",
    "    strony_www=item.find_all('a')\n",
    "    for item in strony_www:\n",
    "        adres_www=item.get('href') ## pobieram link do każdej oferty\n",
    "        \n",
    "    # poniższe cechy zamieniam na float wg.wczesniej napisanej funkcji\n",
    "    liczba_pokoi=zmiana_na_float(liczba_pokoi)\n",
    "    powierzchnia=zmiana_na_float(powierzchnia)\n",
    "    cena=zmiana_na_float(cena.strip())\n",
    "    cena_zlm2 =zmiana_na_float(cena_zlm2)\n",
    "\n",
    "    print('tytuł: ', naglowek)\n",
    "    print('liczba_pokoi: ', liczba_pokoi)\n",
    "    print('powierzchnia (m2): ', powierzchnia)\n",
    "    print('cena (zł): ', cena)\n",
    "    print('cena (zl_m2): ', cena_zlm2)\n",
    "    print(adres_www, '\\n')\n",
    "    \n",
    "    f.writerow([naglowek, liczba_pokoi,powierzchnia, cena, cena_zlm2, adres_www ]) ## zapisanie do csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## zapisanie do CSV\n",
    "f.writerow(['tytuł', 'liczba_pokoi', 'powierzchnia','cena', 'cena_zlm2', 'adres_www' ])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Kod do pobrania szczegółów zawartych wewnątrz konkretnych ogłoszeń  - MIESZKANIA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- najpierw nałożyłam filtr na Otodom, jakie nieruchomosci mnie interesują ( np. wg.lokalizacji, powierzchni, rodzaju nieruchomości - w tym wypadku mieszkania, itd)\n",
    "- po nałożeniu filtrów, Otodom zwrócił mi kilka stron z ogłoszeniami odpowiadającymi moim kryteriom\n",
    "- w tym kodzie zaczytam dane z pierwszej strony zwróconej przez Otodom, przy czym są to dane szczegółowe widoczne po otwarciu konkretnych ofert\n",
    "- po pobraniu danych, zapisuję je do pliku w formacie CSV\n",
    "- w dalszych kodach pobiorę dane z kolejnych stron zwróconych przez Otodom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Podaj adres strony www: https://www.otodom.pl/sprzedaz/mieszkanie/swarzedz/?search%5Bdist%5D=0&search%5Bsubregion_id%5D=458&search%5Bcity_id%5D=81\n"
     ]
    }
   ],
   "source": [
    "# pobieram pierwszą stronę z ofertami ( najpierw nałożyłam filtr na otodom i to jest link do odfiltrowanej strona)\n",
    "adres_strony=input('Podaj adres strony www: ')\n",
    "zawartosc = requests.get(adres_strony)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zawartosc.status_code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tworzę obiekt BS, w którym są zawarte dane z wybranej strony www\n",
    "soup = BeautifulSoup(zawartosc.content, 'html.parser')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# kod do zaczytania szczegółów zawartych w ofertach (przy przeglądaniu strony www widoczne są tylko po wejściu w daną ofertę)\n",
    "wszystkie_oferty = soup.find(class_='col-md-content section-listing__row-content') ### klasa, w ktorej są wszystskie oferty wyszukane na otodom\n",
    "wszystkie_oferty_items = wszystkie_oferty.find_all(class_=\"offer-item-details\")## klasa, w której są szczegóły poszczególnych ofert\n",
    "\n",
    "for item in wszystkie_oferty_items:\n",
    "    strony_www=item.find_all('a')\n",
    "    for item in strony_www:\n",
    "        adres_www=item.get('href') ## pobieram link do każdej oferty\n",
    "        zawartosc2=requests.get(adres_www)\n",
    "        soup2=BeautifulSoup(zawartosc2.content, 'html.parser')\n",
    "        szczegoly=soup2.find_all(class_='article-offer')\n",
    "        for item in szczegoly:       \n",
    "            adres=item.find(class_='address-lane').get_text()\n",
    "            powierzchnia=item.find(class_='big').get_text()\n",
    "            cena=item.find(class_=\"box-price-value\").get_text()\n",
    "            try:# piętro nie zawsze jest podane w ofercie i wówczas zwraca błąd. Aby uniknąć zatrzymania kodu, wprowadziłam try \n",
    "                pietro=item.find(class_='param_floor_no').get_text()\n",
    "            except AttributeError:\n",
    "                pietro='brak informacji'\n",
    "            liczba_pokoi=item.find(class_='room-lane').get_text()\n",
    "            opis=item.find(itemprop='description').get_text()\n",
    "\n",
    "\n",
    "        powierzchnia=zmiana_na_float(powierzchnia)   \n",
    "        cena=zmiana_na_float(cena.strip())\n",
    "        cena_zl_m2=round(cena/powierzchnia,2)\n",
    "        liczba_pokoi=[int(s) for s in liczba_pokoi.split() if s.isdigit()]\n",
    "\n",
    "\n",
    "\n",
    "    print('adres: ', adres.strip())\n",
    "    print('powierzchnia (m2): ', powierzchnia)\n",
    "    print('cena (zł): ', cena)\n",
    "    print('cena (zł/m2): ', cena_zl_m2)\n",
    "    print('pietro: ', pietro)\n",
    "    print('liczba_pokoi: ', liczba_pokoi[0])\n",
    "    print('opis: ', opis)\n",
    "    print(adres_www, '\\n')\n",
    "\n",
    "    f.writerow([adres, powierzchnia,cena, cena_zl_m2, pietro, liczba_pokoi[0], opis ]) ## zapisanie do csv\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  3. Kod do pobrania ofert z kilku stron - MIESZKANIA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- najpierw nałożyłam filtr na Otodom, jakie nieruchomosci mnie interesują ( np. wg.lokalizacji, rodzaju nieruchomości - w tym wypadku mieszkania, powierzchni itd)\n",
    "- po nałożeniu filtrów, Otodom zwrócił mi kilka stron z ogłoszeniami odpowiadającymi moim kryteriom\n",
    "- w poprzednich kodach czytałam jedynie dane widoczne na pierwszej stronie zwrócoej przez Otodom, teraz zaczytam dane z wielu stron. Zrobię to na 2 sposoby:\n",
    "    - w pierwszym kodzie użytkownik sam będzie podawał, z ilu stron chce uzyskać dane ( np. Otodom zwróci 10 stron, a użytkownik uzna, że chce dane tylko z 2 stron). Poza tym użytkownik będzie mógł wybrać, z których stron chce otrzymać dane, wpisując linki do tych stron\n",
    "    - w drugim kodzie automatycznie zaczytam dane z wszystkich stron zwróconych przez Otodom\n",
    "- dodatkowo uporządkuję pobrane dane wyorzystując bibliotekę Pandas (do csv będą eksportowane uporządkowane dane)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3a. Użytkownik podaje, z których stron chce pobrać dane "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "strony=[]\n",
    "for strona in range(0,int(input(\"Podaj, ile stron chcesz przejrzeć: \"))):\n",
    "    strona=input(str(\"Wpisz pełen adres strony- cały link: \"))\n",
    "    strony.append(strona)\n",
    "    print('strony: ', strony)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "adresy=[]\n",
    "powierzchnie=[]\n",
    "ceny=[]\n",
    "ceny_zlm2=[]\n",
    "pietra=[]\n",
    "pokoje=[]\n",
    "dodatkowe=[]\n",
    "opisy=[]\n",
    "\n",
    "    \n",
    "for item in strony:\n",
    "    zawartosc = requests.get(item)\n",
    "    soup=BeautifulSoup(zawartosc.content, 'html.parser')\n",
    "    \n",
    "    wszystkie_oferty = soup.find(class_='col-md-content section-listing__row-content') ### klasa, w ktorej są wszystskie oferty\n",
    "    wszystkie_oferty_items = wszystkie_oferty.find_all(class_=\"offer-item-details\")## klasa, w której są szczegóły poszczególnych ofert\n",
    "\n",
    "    \n",
    "    for item in wszystkie_oferty_items:\n",
    "        strony_www=item.find_all('a')\n",
    "        for item in strony_www:\n",
    "            adres_www=item.get('href') ## pobieram link do każdej oferty\n",
    "            zawartosc2=requests.get(adres_www)\n",
    "            soup2=BeautifulSoup(zawartosc2.content, 'html.parser')\n",
    "            szczegoly=soup2.find_all(class_='article-offer')\n",
    "            for item in szczegoly:       \n",
    "                adres=item.find(class_='address-lane').get_text()\n",
    "                powierzchnia=item.find(class_='big').get_text()\n",
    "                cena=item.find(class_=\"box-price-value\").get_text()\n",
    "                try:# piętro nie zawsze jest podane w ofercie i wówczas zwraca błąd. Aby uniknąć zatrzymania kodu, wprowadziłam try \n",
    "                    pietro=item.find(class_='param_floor_no').get_text()\n",
    "                except AttributeError:\n",
    "                    pietro='brak informacji'\n",
    "                liczba_pokoi=item.find(class_='room-lane').get_text()\n",
    "                opis=item.find(itemprop='description').get_text()\n",
    "                dodatkowe_parametry=soup2.find_all(class_='sub-list')\n",
    "                slownik={}\n",
    "                for item in dodatkowe_parametry: \n",
    "                    wszystko=item.find_all('li')\n",
    "                    for e in wszystko:\n",
    "                        klucz,wartosc=e.text.split(':', maxsplit=1)#maxsplit=1 dzieli tylko po pierwszym dwukropku\n",
    "                        slownik[klucz]=wartosc\n",
    "                \n",
    "\n",
    "                    powierzchnia=zmiana_na_float(powierzchnia)   \n",
    "                    cena=zmiana_na_float(cena.strip())\n",
    "                    cena_zl_m2=round(cena/powierzchnia,2)\n",
    "                    liczba_pokoi=[int(s) for s in liczba_pokoi.split() if s.isdigit()]\n",
    "                    \n",
    "\n",
    "                    print('adres: ', adres.strip())# strip rozdziela ciąg znaków i zwraca listę \n",
    "                    print('powierzchnia (m2): ', powierzchnia)\n",
    "                    print('cena (zł): ', cena)\n",
    "                    print('cena (zł/m2): ', cena_zl_m2)\n",
    "                    print('pietro: ', pietro)\n",
    "                    print('liczba_pokoi: ', liczba_pokoi[0])\n",
    "                    for klucz,wartosc in slownik.items():\n",
    "                        print(klucz,': ',wartosc)\n",
    "                    print('opis: ', opis)\n",
    "                    print(adres_www, '\\n')\n",
    "\n",
    "                    # zapisuję wyciągnięte dane do takiej postaci, abym mogła je dalej zapisać w Pandas\n",
    "                    adresy.append(adres.strip())\n",
    "                    powierzchnie.append(powierzchnia)\n",
    "                    ceny.append(cena)\n",
    "                    ceny_zlm2.append(cena_zl_m2)\n",
    "                    pietra.append(pietro)\n",
    "                    pokoje.append(liczba_pokoi[0])\n",
    "                    opisy.append(opis)\n",
    "                    dodatkowe.append(slownik)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Obróbka  danych - Pandas - MIESZKANIA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "oferty=pd.DataFrame()\n",
    "for x in range(0,len(adresy)):\n",
    "    sr=pd.Series([adresy[x],powierzchnie[x],ceny[x],ceny_zlm2[x], pietra[x],pokoje[x], opisy[x] ],\\\n",
    "                 index=['adres','powierzchnia (m2)','cena (zł)','Cena (zł/m2)', 'pietro', 'liczba_pokoi', 'opis'])\n",
    "    sr_dodatkowe=pd.Series(dodatkowe[x])\n",
    "    sr=pd.concat([sr,sr_dodatkowe])\n",
    "    oferty=pd.concat([oferty,sr],axis=1,ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Cena (zł/m2)', 'Forma własności', 'Okna', 'Rodzaj zabudowy',\n",
       "       'Rok budowy', 'Rynek', 'adres', 'cena (zł)', 'liczba_pokoi', 'opis',\n",
       "       'pietro', 'powierzchnia (m2)'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oferty.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "oferty=oferty.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "kolejnosc_kolumn=['adres','Rynek','powierzchnia (m2)','cena (zł)','Cena (zł/m2)','Forma własności',\\\n",
    "'liczba_pokoi', 'pietro', 'Rodzaj zabudowy', 'Stan wykończenia', 'Czynsz', 'opis']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ustawiam kolumny w wybranej kolejności. \n",
    "#Jeśli nieruchomość nie posiada danych w zakresie określonej cechy, w odpowiedniej komórce pojawi się 'Nan'\n",
    "mieszkania_oferty=oferty.reindex(columns=kolejnosc_kolumn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "mieszkania_oferty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# usuwam duplikaty\n",
    "mieszkania_oferty.drop_duplicates(subset=['powierzchnia (m2)', 'cena (zł)','pietro','liczba_pokoi' ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "#usuwam wyraz'Piętro' z kolumny 'pietro'\n",
    "mieszkania_oferty['pietro']=mieszkania_oferty['pietro'].apply(lambda x: x.replace('Piętro',''))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# usuwam 'escape characters' z kolumny 'opis'\n",
    "mieszkania_oferty.loc[:,'opis'] = mieszkania_oferty.opis.str.replace('\\n','',regex=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# zapisanie pobranych ofert do pliku CSV\n",
    "# mieszkania.to_csv(r'/home/kinga/python/Web_scrapping/mieszkania_oferty.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3b. Kod, który automatycznie  pobiera dane ze wszystkich stron zwróconych przez Otodom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wpisz adres strony internetowej: https://www.otodom.pl/sprzedaz/mieszkanie/swarzedz/?search%5Bfilter_float_m%3Ato%5D=55&search%5Bdescription%5D=1&search%5Bdist%5D=0&search%5Bsubregion_id%5D=458&search%5Bcity_id%5D=81\n",
      "liczba stron:  3\n"
     ]
    }
   ],
   "source": [
    "strona=input('Wpisz adres strony internetowej: ')\n",
    "strony=[strona]\n",
    "page=requests.get(strona)\n",
    "soup=BeautifulSoup(page.content, 'html.parser')\n",
    "\n",
    "cala_strona=soup.find(class_='col-md-content section-listing__row-content') # dane całej strony\n",
    "wiersz_dot_stron=cala_strona.find_all(class_='pager')\n",
    "\n",
    "\n",
    "for item in wiersz_dot_stron: # sprawdzam, ile stron z ogłoszeniami zostało znalezionych wg.wybranych kryteriów\n",
    "    liczba_str=item.find(class_='current').get_text()\n",
    "    print ('liczba stron: ', liczba_str)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#i=1\n",
    "for i in range(2,int(liczba_str)+1): ## zaczynam od 2 dlatego, że dodawanie numerów w adresie strony zaczyna się od 2  \n",
    "    strony.append(strona +'&page=' + str(i))  # każda kolejna strona ma końcówkę '&page=(nr_str)' w stosunku do strony pierwszej, poczynając od '&page=2' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "adresy=[]\n",
    "powierzchnie=[]\n",
    "ceny=[]\n",
    "ceny_zlm2=[]\n",
    "pietra=[]\n",
    "pokoje=[]\n",
    "dodatkowe=[]\n",
    "opisy=[]\n",
    "\n",
    "    \n",
    "for item in strony:\n",
    "    zawartosc = requests.get(item)\n",
    "    soup=BeautifulSoup(zawartosc.content, 'html.parser')\n",
    "    \n",
    "    wszystkie_oferty = soup.find(class_='col-md-content section-listing__row-content') ### klasa, w ktorej są wszystskie oferty\n",
    "    wszystkie_oferty_items = wszystkie_oferty.find_all(class_=\"offer-item-details\")## klasa, w której są szczegóły poszczególnych ofert\n",
    "\n",
    "    \n",
    "    for item in wszystkie_oferty_items:\n",
    "        strony_www=item.find_all('a')\n",
    "        for item in strony_www:\n",
    "            adres_www=item.get('href') ## pobieram link do każdej oferty\n",
    "            zawartosc2=requests.get(adres_www)\n",
    "            soup2=BeautifulSoup(zawartosc2.content, 'html.parser')\n",
    "            szczegoly=soup2.find_all(class_='article-offer')\n",
    "            for item in szczegoly:       \n",
    "                adres=item.find(class_='address-lane').get_text()\n",
    "                powierzchnia=item.find(class_='big').get_text()\n",
    "                cena=item.find(class_=\"box-price-value\").get_text()\n",
    "                if soup2.find_all(class_='param_floor_no'):\n",
    "                    pietro=item.find(class_='param_floor_no').get_text().replace('Piętro','')\n",
    "                else:\n",
    "                    pietro='brak informacji'   \n",
    "                if soup2.find_all(class_='room-lane'):\n",
    "                    liczba_pokoi=item.find(class_='room-lane').get_text()\n",
    "                    liczba_pokoi=[int(s) for s in liczba_pokoi.split() if s.isdigit()][0]\n",
    "                if soup2.find_all(itemprop='description'):\n",
    "                    opis=item.find(itemprop='description').get_text()\n",
    "                else:\n",
    "                    opis='brak informacji'  \n",
    "                dodatkowe_parametry=soup2.find_all(class_='sub-list')\n",
    "                slownik={}\n",
    "                for item in dodatkowe_parametry: \n",
    "                    wszystko=item.find_all('li')\n",
    "                    for e in wszystko:\n",
    "                        klucz,wartosc=e.text.split(':', maxsplit=1)#maxsplit=1 dzieli tylko po pierwszym dwukropku\n",
    "                        slownik[klucz]=wartosc\n",
    "                                          \n",
    "                \n",
    "\n",
    "                    powierzchnia=zmiana_na_float(powierzchnia)   \n",
    "                    cena=zmiana_na_float(cena.strip())\n",
    "                    cena_zl_m2=round(cena/powierzchnia,2)\n",
    "                  \n",
    "                    \n",
    "\n",
    "                    print('adres: ', adres.strip())# strip rozdziela ciąg znaków i zwraca listę \n",
    "                    print('powierzchnia (m2): ', powierzchnia)\n",
    "                    print('cena (zł): ', cena)\n",
    "                    print('cena (zł/m2): ', cena_zl_m2)\n",
    "                    print('pietro: ', pietro)\n",
    "                    print('liczba_pokoi: ', liczba_pokoi)\n",
    "                    for klucz,wartosc in slownik.items():\n",
    "                        print(klucz,': ',wartosc)\n",
    "                    print('opis: ', opis)\n",
    "                    print(adres_www, '\\n')\n",
    "\n",
    "                    # zapisuję wyciągnięte dane do takiej postaci, abym mogła je dalej zapisać w Pandas\n",
    "                    adresy.append(adres.strip())\n",
    "                    powierzchnie.append(powierzchnia)\n",
    "                    ceny.append(cena)\n",
    "                    ceny_zlm2.append(cena_zl_m2)\n",
    "                    pietra.append(pietro)\n",
    "                    pokoje.append(liczba_pokoi)\n",
    "                    opisy.append(opis)\n",
    "                    dodatkowe.append(slownik)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Kod do pobrania ofert dla różnego typu nieruchomości: MIESZKANIA, DOMY, LOKALE UŻYTKOWE, DZIAŁKI "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- kod pobiera oferty w.w. typów nieruchomości ( dostępne są różne atrybuty w zależności od rodzaju nieruchomości)\n",
    "- po pobraniu dane są umieszczane w tabeli tworzonej przy wykorzystaniu biblioteki Pandas. Dla każdego typu nieruchomości tworzona jest inna tabela\n",
    "- po obróbce, dane zapisywane są w określonej lokalizacji w pliku o nazwie wybranej przez użytkownika"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wpisz adres strony internetowej: https://www.otodom.pl/wynajem/lokal/radom/?search%5Bfilter_enum_use_types%5D%5B0%5D=services&search%5Bfilter_enum_use_types%5D%5B1%5D=office&search%5Bfilter_enum_use_types%5D%5B2%5D=retail&search%5Bfilter_enum_use_types%5D%5B3%5D=gastronomy&search%5Bdescription%5D=1&search%5Bdist%5D=0&search%5Bsubregion_id%5D=419&search%5Bcity_id%5D=196\n",
      "Podaj, ile stron chcesz przejrzeć: 6\n",
      "Podaj nazwę pliku, do którego chcesz zapisać: Radom_nowe1\n",
      "Liczba wybranych stron to:  6\n",
      "liczba dostępnych stron to:  6\n",
      "GOTOWE :) Plik został zapisany w lokalizacji:  /home/kinga/python/Web_scrapping/Radom_nowe1.xlsx\n"
     ]
    }
   ],
   "source": [
    "strona=input('Wpisz adres strony internetowej: ')\n",
    "strony=[strona]\n",
    "liczba_wybranych_str=int(input(\"Podaj, ile stron chcesz przejrzeć: \"))\n",
    "plik_wynikowy=input(\"Podaj nazwę pliku, do którego chcesz zapisać: \")\n",
    "\n",
    "page=requests.get(strona)\n",
    "soup=BeautifulSoup(page.content, 'html.parser')\n",
    "\n",
    "cala_strona=soup.find(class_='col-md-content section-listing__row-content') # dane całej strony\n",
    "wiersz_dot_stron=cala_strona.find_all(class_='pager') \n",
    "\n",
    "\n",
    "for item in wiersz_dot_stron: # sprawdzam, ile stron z ogłoszeniami zostało znalezionych wg.wybranych kryteriów\n",
    "    liczba_str=int(item.find(class_='current').get_text())\n",
    "    print ('Liczba wybranych stron to: ', liczba_wybranych_str)\n",
    "    print ('liczba dostępnych stron to: ', liczba_str)\n",
    "\n",
    "    # ograniczenie- użytkownik może pobrać maksymalnie 10 stron\n",
    "    if liczba_wybranych_str<=liczba_str and liczba_wybranych_str<=10:\n",
    "        for i in range(2,liczba_wybranych_str+1):\n",
    "            strony.append(strona +'&page=' + str(i))\n",
    "    else:\n",
    "        for i in range(2,11):\n",
    "            strony.append(strona +'&page=' + str(i))\n",
    "        print('Maksymalnie możesz pobrać 10 stron- tyle zostanie pobranych!')\n",
    "\n",
    "\n",
    "\n",
    "adresy=[]\n",
    "powierzchnie=[]\n",
    "ceny=[]\n",
    "ceny_zlm2=[]\n",
    "pietra=[]\n",
    "pokoje=[]\n",
    "wielkosc_dzialki=[]\n",
    "rodzaj_dzialki=[]\n",
    "dodatkowe=[]\n",
    "opisy=[]\n",
    "\n",
    "\n",
    "for item in strony:\n",
    "    zawartosc = requests.get(item)\n",
    "    soup=BeautifulSoup(zawartosc.content, 'html.parser')\n",
    "\n",
    "    wszystkie_oferty = soup.find(class_='col-md-content section-listing__row-content') ### klasa, w ktorej są wszystskie oferty\n",
    "    wszystkie_oferty_items = wszystkie_oferty.find_all(class_=\"offer-item-details\")## klasa, w której są szczegóły poszczególnych ofert\n",
    "\n",
    "\n",
    "    for item in wszystkie_oferty_items:\n",
    "        strony_www=item.find_all('a')\n",
    "        for item in strony_www:\n",
    "            adres_www=item.get('href') ## pobieram link do każdej oferty\n",
    "            zawartosc2=requests.get(adres_www)\n",
    "            soup2=BeautifulSoup(zawartosc2.content, 'html.parser')\n",
    "            szczegoly=soup2.find_all(class_='article-offer')\n",
    "            for item in szczegoly:       \n",
    "                adres=item.find(class_='address-lane').get_text()\n",
    "                powierzchnia=item.find(class_='big').get_text()\n",
    "                cena=item.find(class_=\"box-price-value\").get_text()                     \n",
    "                if soup2.find_all(class_='param_floor_no'):\n",
    "                    pietro=item.find(class_='param_floor_no').get_text().replace('Piętro','')\n",
    "                else:\n",
    "                    pietro='brak informacji'      \n",
    "                if soup2.find_all(class_='room-lane'):\n",
    "                    liczba_pokoi=item.find(class_='room-lane').get_text()\n",
    "                    liczba_pokoi=[int(s) for s in liczba_pokoi.split() if s.isdigit()][0]\n",
    "                else: \n",
    "                    liczba_pokoi='brak informacji' \n",
    "                if soup2.find_all(class_='param_terrain_area'):\n",
    "                    powierzchnia_dzialki=item.find(class_='param_terrain_area').get_text().replace('Powierzchnia działki ','').replace('m²','')\n",
    "                else:\n",
    "                    powierzchnia_dzialki='brak informacji'\n",
    "                if soup2.find_all(class_='param_type'):\n",
    "                    typ_dzialki=item.find(class_='param_type').get_text().replace('Typ działki', '')\n",
    "                else:\n",
    "                    typ_dzialki='brak informacji'\n",
    "                if soup2.find_all(itemprop='description'):\n",
    "                    opis=item.find(itemprop='description').get_text()\n",
    "                else:\n",
    "                    opis='brak informacji'   \n",
    "\n",
    "                dodatkowe_parametry=soup2.find_all(class_='sub-list')\n",
    "                slownik={}\n",
    "                for item in dodatkowe_parametry: \n",
    "                    wszystko=item.find_all('li')\n",
    "                    for e in wszystko:\n",
    "                        klucz,wartosc=e.text.split(':', maxsplit=1)#maxsplit=1 dzieli tylko po pierwszym dwukropku\n",
    "                        slownik[klucz]=wartosc\n",
    "\n",
    "\n",
    "\n",
    "                    powierzchnia=zmiana_na_float(powierzchnia)   \n",
    "                    cena=zmiana_na_float(cena.strip())\n",
    "                    cena_zl_m2=round(cena/powierzchnia,2)\n",
    "\n",
    "                    # zapisuję dane do takiej postaci, abym mogła je dalej zapisać w Pandas\n",
    "                    adresy.append(adres.strip())\n",
    "                    powierzchnie.append(powierzchnia)\n",
    "                    ceny.append(cena)\n",
    "                    ceny_zlm2.append(cena_zl_m2)\n",
    "                    pietra.append(pietro)\n",
    "                    pokoje.append(liczba_pokoi)\n",
    "                    wielkosc_dzialki.append(powierzchnia_dzialki)\n",
    "                    rodzaj_dzialki.append(typ_dzialki)\n",
    "                    opisy.append(opis)\n",
    "                    dodatkowe.append(slownik)\n",
    "\n",
    "oferty=pd.DataFrame()\n",
    "for x in range(0,len(adresy)):\n",
    "    sr=pd.Series([adresy[x],powierzchnie[x],ceny[x],ceny_zlm2[x], pietra[x],pokoje[x], wielkosc_dzialki[x], rodzaj_dzialki[x], opisy[x] ],\\\n",
    "                 index=['Adres','Powierzchnia (m2)','Cena (zł)','Cena (zł/m2)', 'Pietro', 'Liczba_pokoi','Powierzchnia działki (m2)', 'Typ działki', 'Opis'])\n",
    "    sr_dodatkowe=pd.Series(dodatkowe[x])\n",
    "    sr=pd.concat([sr,sr_dodatkowe])\n",
    "    oferty=pd.concat([oferty,sr],axis=1,ignore_index=True, sort=False)\n",
    "\n",
    "oferty=oferty.T\n",
    "\n",
    " # usuwam 'escape characters' z kolumny 'opis'\n",
    "oferty.loc[:,'Opis'] = oferty.Opis.str.replace('\\n','',regex=True)\n",
    " # usuwam duplikaty\n",
    "oferty.drop_duplicates()\n",
    "\n",
    "\n",
    "# Tworzę odpowiedni data frame w zależności od typu nieruchomości\n",
    "if oferty[oferty['Adres'].str.contains('Mieszkanie')].shape[0]>0:\n",
    "    kolejnosc_kolumn=['Adres','Rynek','Powierzchnia (m2)','Cena (zł)','Cena (zł/m2)','Forma własności',\n",
    "                      'Liczba_pokoi', 'Pietro', 'Rodzaj zabudowy', 'Stan wykończenia', 'Czynsz', 'Opis']\n",
    "    oferty=oferty.reindex(columns=kolejnosc_kolumn)\n",
    "elif oferty[oferty['Adres'].str.contains('Dom ')].shape[0]>0:\n",
    "    kolejnosc_kolumn=['Adres','Rynek','Powierzchnia (m2)','Powierzchnia działki (m2)','Cena (zł)',\n",
    "                      'Cena (zł/m2)', 'Rodzaj zabudowy','Stan wykończenia', 'Opis' ]\n",
    "    oferty=oferty.reindex(columns=kolejnosc_kolumn)\n",
    "elif oferty[oferty['Adres'].str.contains('Działka')].shape[0]>0:\n",
    "    kolejnosc_kolumn=['Adres', 'Powierzchnia (m2)', 'Cena (zł)', 'Cena (zł/m2)', 'Typ działki', 'Opis']\n",
    "    oferty=oferty.reindex(columns=kolejnosc_kolumn)\n",
    "elif oferty[oferty['Adres'].str.contains('użytkowy')].shape[0]>0:\n",
    "    kolejnosc_kolumn=['Adres','Rynek','Powierzchnia (m2)','Cena (zł)','Cena (zł/m2)','Piętro','Stan wykończenia', \n",
    "                      'Przeznaczenie lokalu', 'Rok budowy', 'Opis']\n",
    "    oferty=oferty.reindex(columns=kolejnosc_kolumn)\n",
    "\n",
    "\n",
    "sciezka='/home/kinga/python/Web_scrapping/'+plik_wynikowy+'.xlsx'\n",
    "# zapisanie do pliku Excel \n",
    "oferty.to_excel(sciezka, index=False)\n",
    "print ('GOTOWE :) Plik został zapisany w lokalizacji: ', sciezka)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Kod do pobierania ofert po zmianie strony intrnetowej"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- kod działa w oparciu o zmienioną stronę Otodom\n",
    "- kod pobiera oferty różnych typów nieruchomości ( dostępne są różne atrybuty w zależności od rodzaju nieruchomości)\n",
    "- dodatkowo dodano pasek postępu, który pokazuje, ile stron zostało sparsowanych\n",
    "- po pobraniu dane są umieszczane w tabeli tworzonej przy wykorzystaniu biblioteki Pandas. Dla każdego typu nieruchomości tworzona jest inna tabela\n",
    "- po obróbce, dane zapisywane są w określonej lokalizacji w pliku o nazwie wybranej przez użytkownika"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wpisz adres strony internetowej: https://www.otodom.pl/sprzedaz/lokal/poznan/?search%5Bdist%5D=0&search%5Bsubregion_id%5D=462&search%5Bcity_id%5D=1\n",
      "Podaj, ile stron chcesz przejrzeć: 3\n",
      "Podaj nazwę pliku, do którego chcesz zapisać: lokale_uzytkowe\n",
      "Liczba wybranych stron to:  3\n",
      "liczba dostępnych stron to:  15\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a5645505c74641548e88eeabdcf20094",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Label(value='Liczba pobranych stron', layout=Layout(width='auto')), IntProgress(value=0, max=3)…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GOTOWE :) Plik został zapisany w lokalizacji:  /home/kinga/python/Web_scrapping/lokale_uzytkowe.xlsx\n"
     ]
    }
   ],
   "source": [
    "strona=input('Wpisz adres strony internetowej: ')\n",
    "strony=[strona]\n",
    "liczba_wybranych_str=int(input(\"Podaj, ile stron chcesz przejrzeć: \"))\n",
    "plik_wynikowy=input(\"Podaj nazwę pliku, do którego chcesz zapisać: \")\n",
    "\n",
    "page=requests.get(strona)\n",
    "soup=BeautifulSoup(page.content, 'html.parser')\n",
    "\n",
    "\n",
    "cala_strona=soup.find(class_='col-md-content section-listing__row-content') # dane całej strony\n",
    "wiersz_dot_stron=cala_strona.find_all(class_='pager') \n",
    "\n",
    "\n",
    "for item in wiersz_dot_stron: # sprawdzam, ile stron z ogłoszeniami zostało znalezionych wg.wybranych kryteriów\n",
    "    liczba_str=int(item.find(class_='current').get_text())\n",
    "    print ('Liczba wybranych stron to: ', liczba_wybranych_str)\n",
    "    print ('liczba dostępnych stron to: ', liczba_str)\n",
    "\n",
    "    # ograniczenie- użytkownik może pobrać maksymalnie 10 stron\n",
    "    if liczba_wybranych_str<=liczba_str and liczba_wybranych_str<=10:\n",
    "        for i in range(2,liczba_wybranych_str+1):\n",
    "            strony.append(strona +'&page=' + str(i))\n",
    "    else:\n",
    "        for i in range(2,11):\n",
    "            strony.append(strona +'&page=' + str(i))\n",
    "        print('Maksymalnie możesz pobrać 10 stron- tyle zostanie pobranych!')\n",
    "\n",
    "\n",
    "rodzaje_nieruchomosci=[]\n",
    "adresy=[]\n",
    "ceny=[]\n",
    "dodatkowe=[]\n",
    "opisy=[]\n",
    "\n",
    "x=0\n",
    "pasek_postepu = widgets.IntProgress(min=x, max=liczba_wybranych_str) # pasek postępu \n",
    "opis_paska_postepu= widgets.Label(value='Liczba pobranych stron',layout=widgets.Layout(width='auto') )\n",
    "liczba_sparsowanych_stron =widgets.Label() \n",
    "kontener_paska_postepu= widgets.HBox([opis_paska_postepu,pasek_postepu, liczba_sparsowanych_stron])\n",
    "display(kontener_paska_postepu)\n",
    "\n",
    "\n",
    "\n",
    "for item in strony:\n",
    "    zawartosc = requests.get(item)\n",
    "    soup=BeautifulSoup(zawartosc.content, 'html.parser')\n",
    "\n",
    "    wszystkie_oferty = soup.find(class_='col-md-content section-listing__row-content') ### klasa, w ktorej są wszystskie oferty\n",
    "    wszystkie_oferty_items = wszystkie_oferty.find_all(class_=\"offer-item-details\")## klasa, w której są szczegóły poszczególnych ofert\n",
    "\n",
    "\n",
    "    for item in wszystkie_oferty_items:\n",
    "        rodzaj_nieruchomosci=item.find(class_='text-nowrap hidden-xs').get_text().split(':')[0]\n",
    "        cena=zmiana_na_float(item.find(class_=\"offer-item-price\").get_text().strip()) # strip - usuwam spacje na początku i końcu\n",
    "        strony_www=item.find_all('a')\n",
    "        for item in strony_www:\n",
    "            adres_www=item.get('href') \n",
    "            zawartosc2=requests.get(adres_www)\n",
    "            soup2=BeautifulSoup(zawartosc2.content, 'html.parser')\n",
    "            szczegoly=soup2.find_all(id='root') \n",
    "            for item in szczegoly:       \n",
    "                adres=item.find (class_='css-xpo2mg-baseStyle-Address-contentStyle').get_text()      \n",
    "                if soup2.find_all(class_='section-description'): \n",
    "                    opis=item.find(class_='section-description').get_text()\n",
    "                else:\n",
    "                    opis='brak informacji'   \n",
    "                dodatkowe_parametry=soup2.find_all(class_='css-1v9yl6n-AdOverview-className') \n",
    "                slownik={}\n",
    "                for item in dodatkowe_parametry: \n",
    "                    wszystko=item.find_all('li')\n",
    "                    for e in wszystko:\n",
    "                        klucz,wartosc=e.text.split(':', maxsplit=1)#maxsplit=1 dzieli tylko po pierwszym dwukropku\n",
    "                        slownik[klucz]=wartosc\n",
    "                    \n",
    "#                     print('Rodzaj nieruchomości: ', rodzaj_nieruchomosci)\n",
    "#                     print('Adres: ', adres)\n",
    "#                     print('Cena (zł): ', cena)\n",
    "#                     for klucz,wartosc in slownik.items():\n",
    "#                         print(klucz,': ',wartosc)\n",
    "#                     print('Opis: ', opis)\n",
    "#                     print(adres_www, '\\n')\n",
    "\n",
    "                    # zapisuję dane do takiej postaci, abym mogła je dalej zapisać w Pandas\n",
    "                    rodzaje_nieruchomosci.append(rodzaj_nieruchomosci)\n",
    "                    adresy.append(adres)\n",
    "                    ceny.append(cena)\n",
    "                    opisy.append(opis)\n",
    "                    dodatkowe.append(slownik)\n",
    "    x=x+1\n",
    "    pasek_postepu.value=x\n",
    "    liczba_sparsowanych_stron.value=str(x) # Label musi być stringiem\n",
    "\n",
    "oferty=pd.DataFrame()\n",
    "for x in range(0,len(adresy)):\n",
    "    sr=pd.Series([rodzaje_nieruchomosci[x],adresy[x],ceny[x], opisy[x] ],\\\n",
    "                 index=['Rodzaj nieruchomosci','Adres','Cena (zł)', 'Opis'])\n",
    "    sr_dodatkowe=pd.Series(dodatkowe[x])\n",
    "    sr=pd.concat([sr,sr_dodatkowe])\n",
    "    oferty=pd.concat([oferty,sr],axis=1,ignore_index=True, sort=False)\n",
    "\n",
    "oferty=oferty.T\n",
    "\n",
    " # usuwam 'escape characters' z kolumny 'opis'\n",
    "oferty.loc[:,'Opis'] = oferty.Opis.str.replace('\\n','',regex=True)\n",
    " # usuwam duplikaty\n",
    "oferty.drop_duplicates()\n",
    "oferty.rename(columns={'Powierzchnia': 'Powierzchnia (m2)'}, inplace=True)\n",
    "oferty['Powierzchnia (m2)']=oferty['Powierzchnia (m2)'].apply(lambda x: zmiana_na_float(x)) # zmieniam powierzchnię na float i usuwam 'm2'\n",
    "oferty['Cena (zł/m2)']=oferty.apply(lambda x: round(x['Cena (zł)']/x['Powierzchnia (m2)'],2),axis=1)\n",
    "\n",
    "# Tworzę odpowiedni data frame w zależności od typu nieruchomości\n",
    "if oferty[oferty['Rodzaj nieruchomosci'].str.contains('Mieszkanie')].shape[0]>0:\n",
    "    kolejnosc_kolumn=['Rodzaj nieruchomosci','Adres','Rynek','Powierzchnia (m2)','Cena (zł)','Cena (zł/m2)',\n",
    "                      'Forma własności','Liczba_pokoi', 'Piętro', 'Rodzaj zabudowy', 'Stan wykończenia', \n",
    "                      'Czynsz', 'Opis']\n",
    "    oferty=oferty.reindex(columns=kolejnosc_kolumn)\n",
    "elif oferty[oferty['Rodzaj nieruchomosci'].str.contains('Dom ')].shape[0]>0:\n",
    "    oferty.rename(columns={'Powierzchnia działki': 'Powierzchnia działki (m2)'}, inplace=True)\n",
    "    oferty['Powierzchnia działki (m2)']=oferty['Powierzchnia działki (m2)'].apply(lambda x: zmiana_na_float(x))\n",
    "    kolejnosc_kolumn=['Rodzaj nieruchomosci','Adres','Rynek','Powierzchnia (m2)','Powierzchnia działki (m2)',\n",
    "                      'Cena (zł)','Cena (zł/m2)', 'Rodzaj zabudowy','Stan wykończenia', 'Opis' ]\n",
    "    oferty=oferty.reindex(columns=kolejnosc_kolumn)\n",
    "elif oferty[oferty['Rodzaj nieruchomosci'].str.contains('Działka')].shape[0]>0:\n",
    "    kolejnosc_kolumn=['Rodzaj nieruchomosci','Adres', 'Powierzchnia (m2)', 'Cena (zł)', 'Cena (zł/m2)', \n",
    "                      'Typ działki', 'Opis']\n",
    "    oferty=oferty.reindex(columns=kolejnosc_kolumn)\n",
    "elif oferty[oferty['Rodzaj nieruchomosci'].str.contains('użytkowy')].shape[0]>0:\n",
    "    kolejnosc_kolumn=['Rodzaj nieruchomosci','Adres','Rynek','Powierzchnia (m2)','Cena (zł)','Cena (zł/m2)',\n",
    "                      'Piętro','Stan wykończenia', 'Przeznaczenie lokalu', 'Rok budowy', 'Opis']\n",
    "    oferty=oferty.reindex(columns=kolejnosc_kolumn)\n",
    "\n",
    "\n",
    "sciezka='/home/kinga/python/Web_scrapping/'+plik_wynikowy+'.xlsx'\n",
    "# zapisanie do pliku Excel \n",
    "oferty.to_excel(sciezka, index=False)\n",
    "print ('GOTOWE :) Plik został zapisany w lokalizacji: ', sciezka)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Rodzaj nieruchomosci</th>\n",
       "      <th>Adres</th>\n",
       "      <th>Rynek</th>\n",
       "      <th>Powierzchnia (m2)</th>\n",
       "      <th>Cena (zł)</th>\n",
       "      <th>Cena (zł/m2)</th>\n",
       "      <th>Piętro</th>\n",
       "      <th>Stan wykończenia</th>\n",
       "      <th>Przeznaczenie lokalu</th>\n",
       "      <th>Rok budowy</th>\n",
       "      <th>Opis</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Lokal użytkowy na sprzedaż</td>\n",
       "      <td>Poznań, Starołęka</td>\n",
       "      <td>pierwotny</td>\n",
       "      <td>180.00</td>\n",
       "      <td>1.6e+06</td>\n",
       "      <td>8888.89</td>\n",
       "      <td>parter</td>\n",
       "      <td>gotowy</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2016</td>\n",
       "      <td>OpisNa sprzedaż lokal handlowo-usługowy o powi...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Lokal użytkowy na sprzedaż</td>\n",
       "      <td>Poznań, Dębiec</td>\n",
       "      <td>pierwotny</td>\n",
       "      <td>257.27</td>\n",
       "      <td>1.3e+06</td>\n",
       "      <td>5053.06</td>\n",
       "      <td>parter</td>\n",
       "      <td>gotowy</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2015</td>\n",
       "      <td>OpisSprzedam lokal o powierzchni 257,27 m2 prz...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Lokal użytkowy na sprzedaż</td>\n",
       "      <td>Poznań, wielkopolskie</td>\n",
       "      <td>wtórny</td>\n",
       "      <td>845.70</td>\n",
       "      <td>3.25e+06</td>\n",
       "      <td>3842.97</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>1989</td>\n",
       "      <td>OpisOBIEKT PRZEMYSŁOWY - HALA MAGAZYNOWA - BIU...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Lokal użytkowy na sprzedaż</td>\n",
       "      <td>Poznań, Stare Miasto</td>\n",
       "      <td>wtórny</td>\n",
       "      <td>68.00</td>\n",
       "      <td>600000</td>\n",
       "      <td>8823.53</td>\n",
       "      <td>parter</td>\n",
       "      <td>gotowy</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2015</td>\n",
       "      <td>OpisSprzedam lokal użytkowy położony na parter...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Lokal użytkowy na sprzedaż</td>\n",
       "      <td>Poznań, wielkopolskie</td>\n",
       "      <td>pierwotny</td>\n",
       "      <td>1100.00</td>\n",
       "      <td>5.5e+06</td>\n",
       "      <td>5000.00</td>\n",
       "      <td>parter</td>\n",
       "      <td>gotowy</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2017</td>\n",
       "      <td>OpisOferuję do sprzedaży dochodową nieruchomoś...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Rodzaj nieruchomosci                  Adres       Rynek  \\\n",
       "0  Lokal użytkowy na sprzedaż      Poznań, Starołęka   pierwotny   \n",
       "1  Lokal użytkowy na sprzedaż         Poznań, Dębiec   pierwotny   \n",
       "2  Lokal użytkowy na sprzedaż  Poznań, wielkopolskie      wtórny   \n",
       "3  Lokal użytkowy na sprzedaż   Poznań, Stare Miasto      wtórny   \n",
       "4  Lokal użytkowy na sprzedaż  Poznań, wielkopolskie   pierwotny   \n",
       "\n",
       "   Powierzchnia (m2) Cena (zł)  Cena (zł/m2)   Piętro Stan wykończenia  \\\n",
       "0             180.00   1.6e+06       8888.89   parter           gotowy   \n",
       "1             257.27   1.3e+06       5053.06   parter           gotowy   \n",
       "2             845.70  3.25e+06       3842.97      NaN              NaN   \n",
       "3              68.00    600000       8823.53   parter           gotowy   \n",
       "4            1100.00   5.5e+06       5000.00   parter           gotowy   \n",
       "\n",
       "   Przeznaczenie lokalu Rok budowy  \\\n",
       "0                   NaN       2016   \n",
       "1                   NaN       2015   \n",
       "2                   NaN       1989   \n",
       "3                   NaN       2015   \n",
       "4                   NaN       2017   \n",
       "\n",
       "                                                Opis  \n",
       "0  OpisNa sprzedaż lokal handlowo-usługowy o powi...  \n",
       "1  OpisSprzedam lokal o powierzchni 257,27 m2 prz...  \n",
       "2  OpisOBIEKT PRZEMYSŁOWY - HALA MAGAZYNOWA - BIU...  \n",
       "3  OpisSprzedam lokal użytkowy położony na parter...  \n",
       "4  OpisOferuję do sprzedaży dochodową nieruchomoś...  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oferty.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Aktualizacja maj 2020"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import bibliotek\n",
    "import requests\n",
    "from bs4 import BeautifulSoup\n",
    "import pandas as pd\n",
    "import csv\n",
    "from time import sleep\n",
    "import ipywidgets as widgets \n",
    "from datetime import date\n",
    "\n",
    "# wykorzystana funkcja:\n",
    "\n",
    "def zmiana_na_float (cecha):\n",
    "    if isinstance (cecha, str): # jeśli cecha jest stringiem\n",
    "        return float(cecha.rsplit(' ',1)[0].replace(' ','').replace(',','.'))     #rsplit-rozdzielam po spacji, ale tylko jednej spacji licząc od końca. Jeśli w stringu będzie kilka spacji, to podzieli tylko po tej ostatniej \n",
    "    else:\n",
    "        return cecha\n",
    "\n",
    "\n",
    "strona=input('Wpisz adres strony internetowej: ')\n",
    "strony=[strona]\n",
    "liczba_wybranych_str=int(input(\"Podaj, ile stron chcesz przejrzeć: \"))\n",
    "plik_wynikowy=input(\"Podaj nazwę pliku, do którego chcesz zapisać: \")\n",
    "\n",
    "page=requests.get(strona)\n",
    "soup=BeautifulSoup(page.content, 'html.parser')\n",
    "\n",
    "cala_strona=soup.find(class_='col-md-content section-listing__row-content') # dane całej strony\n",
    "wiersz_dot_stron=cala_strona.find_all(class_='pager') # w tym jest klasa 'page-counter' i 'page_next'\n",
    "\n",
    "przycisk_przewijania_stron=cala_strona.find_all(class_='pager-next')\n",
    "\n",
    "for item in wiersz_dot_stron: # sprawdzam, ile stron z ogłoszeniami zostało znalezionych wg.wybranych kryteriów\n",
    "    liczba_dostepnych_stron=item.find_all('li')\n",
    "    liczba_dostepnych_stron=int(list(liczba_dostepnych_stron)[-2].get_text())\n",
    "    \n",
    "    print ('Liczba wybranych stron to: ', liczba_wybranych_str)\n",
    "    print ('liczba dostępnych stron to: ', liczba_dostepnych_stron)\n",
    "\n",
    "    # ograniczenie liczby pobranych stron do 10\n",
    "    if liczba_wybranych_str<=liczba_dostepnych_stron and liczba_wybranych_str<=10:  \n",
    "        for i in range(2,liczba_wybranych_str+1):\n",
    "            strony.append(strona +'&page=' + str(i))\n",
    "    else:\n",
    "        for i in range(2,11):\n",
    "            strony.append(strona +'&page=' + str(i))\n",
    "        print('Maksymalnie możesz pobrać 10 stron- tyle zostanie pobranych!')\n",
    "        \n",
    "\n",
    "numery_ogloszen=[]\n",
    "daty_dodania=[]\n",
    "data_pobrania_oferty=date.today()\n",
    "rodzaje_nieruchomosci=[]\n",
    "adresy=[]\n",
    "ceny=[]\n",
    "dodatkowe=[]\n",
    "opisy=[]\n",
    "    \n",
    "x=0\n",
    "pasek_postepu = widgets.IntProgress(min=x, max=liczba_wybranych_str) # pasek postępu \n",
    "opis_paska_postepu= widgets.Label(value='Liczba pobranych stron',layout=widgets.Layout(width='auto') )\n",
    "liczba_sparsowanych_stron =widgets.Label() \n",
    "kontener_paska_postepu= widgets.HBox([opis_paska_postepu,pasek_postepu, liczba_sparsowanych_stron])\n",
    "display(kontener_paska_postepu)\n",
    "\n",
    "\n",
    "for item in strony:\n",
    "    zawartosc = requests.get(item)\n",
    "    soup=BeautifulSoup(zawartosc.content, 'html.parser')\n",
    "    wszystkie_oferty = soup.find(class_='col-md-content section-listing__row-content') ### klasa, w ktorej są wszystskie oferty\n",
    "    wszystkie_oferty_items = wszystkie_oferty.find_all(class_=\"offer-item-details\")## klasa, w której są szczegóły poszczególnych ofert\n",
    "    for item in wszystkie_oferty_items:\n",
    "        try: \n",
    "            cena=zmiana_na_float(item.find(class_=\"offer-item-price\").get_text().strip()) # strip - usuwam spacje na początku i końcu\n",
    "        except:\n",
    "            continue # niektóre ogłoszenia nie mają podanej ceny, pomijam te oferty\n",
    "        \n",
    "        rodzaj_nieruchomosci=item.find(class_='hidden-xs').get_text().split(':')[0]\n",
    "        lokalizacja = item.find('span', {'class': 'hidden-xs'})\n",
    "        powierzchnia= zmiana_na_float(item.find(class_=\"hidden-xs offer-item-area\").get_text().split(' ')[0]) # żeby było bez m2\n",
    "        strony_www=item.find_all('a')\n",
    "        for item in strony_www:\n",
    "            adres_www=item.get('href') \n",
    "            try:\n",
    "                zawartosc2=requests.get(adres_www)\n",
    "            except:\n",
    "                #print('brak url')\n",
    "                break # przerywa i uruchamia kod od nowa, w przeciwnym wypadku pobrałby każdą ofertę 2 razy\n",
    "            soup2=BeautifulSoup(zawartosc2.content, 'html.parser')\n",
    "            szczegoly=soup2.find_all(id='root') \n",
    "            for item in szczegoly:       \n",
    "                lokalizacja=item.find(class_='css-1ub7gzr').get_text().split(';}')[-1]\n",
    "                try:\n",
    "                    numer_oferty=item.find(class_='css-kos6vh').get_text().split(': ')[1]\n",
    "                except:\n",
    "                    'brak danych'\n",
    "                try:\n",
    "                    data_dodania=item.find(class_=\"css-lh1bxu\").get_text().split(': ')[1].split('D')[0]\n",
    "                except:\n",
    "                    'brak danych'\n",
    "                if soup2.find_all(class_='section-description'): \n",
    "                    opis=item.find(class_='section-description').get_text().split('underline;}')[1]\n",
    "                else:\n",
    "                    opis='brak informacji'   \n",
    "                dodatkowe_parametry=soup2.find_all(class_='css-1ci0qpi')                               \n",
    "                slownik={}\n",
    "                for item in dodatkowe_parametry: \n",
    "                    wszystko=item.find_all('li')\n",
    "                    for e in wszystko:\n",
    "                        klucz,wartosc=e.text.split(':', maxsplit=1)#maxsplit=1 dzieli tylko po pierwszym dwukropku\n",
    "                        slownik[klucz]=wartosc\n",
    "\n",
    "                    print('Rodzaj nieruchomości: ', rodzaj_nieruchomosci)\n",
    "                    print('Lokalizacja: ', lokalizacja)\n",
    "                    print('id: ',numer_oferty)\n",
    "                    print('data_dodatnia: ', data_dodania)\n",
    "                    print('Cena (zł): ', cena)\n",
    "                    for klucz,wartosc in slownik.items():\n",
    "                        print(klucz,': ',wartosc)\n",
    "                    print('Opis: ', opis)\n",
    "                    print(adres_www, '\\n')\n",
    "                    \n",
    "                # zapisuję dane do takiej postaci, abym mogła je dalej zapisać w Pandas\n",
    "                    numery_ogloszen.append(numer_oferty)\n",
    "                    daty_dodania.append(data_dodania)\n",
    "                    rodzaje_nieruchomosci.append(rodzaj_nieruchomosci)\n",
    "                    adresy.append(lokalizacja)\n",
    "                    ceny.append(cena)\n",
    "                    opisy.append(opis)\n",
    "                    dodatkowe.append(slownik)\n",
    "    x=x+1\n",
    "    pasek_postepu.value=x\n",
    "    liczba_sparsowanych_stron.value=str(x) # Label musi być stringiem\n",
    "\n",
    "oferty=pd.DataFrame()\n",
    "for x in range(0,len(numery_ogloszen)):\n",
    "    sr=pd.Series([numery_ogloszen[x], daty_dodania[x], data_pobrania_oferty,\n",
    "                  rodzaje_nieruchomosci[x],adresy[x],ceny[x], opisy[x] ],\\\n",
    "                     index=['Nr oferty', 'Data dodania','Data pobrania oferty',\n",
    "                            'Rodzaj nieruchomosci','Adres','Cena (zł)', 'Opis'])\n",
    "    sr_dodatkowe=pd.Series(dodatkowe[x])\n",
    "    sr=pd.concat([sr,sr_dodatkowe])\n",
    "    oferty=pd.concat([oferty,sr],axis=1,ignore_index=True, sort=False)\n",
    "\n",
    "oferty=oferty.T\n",
    "\n",
    "# usuwam 'escape characters' z kolumny 'opis'\n",
    "oferty.loc[:,'Opis'] = oferty.Opis.str.replace('\\n','',regex=True)\n",
    "# usuwam duplikaty\n",
    "oferty.drop_duplicates(subset=['Nr oferty','Rynek','Powierzchnia', 'Cena (zł)' ], inplace=True)\n",
    "oferty.rename(columns={'Powierzchnia': 'Powierzchnia (m2)'}, inplace=True)\n",
    "oferty['Powierzchnia (m2)']=oferty['Powierzchnia (m2)'].apply(lambda x: zmiana_na_float(x)) # zmieniam powierzchnię na float i usuwam 'm2'\n",
    "oferty['Cena (zł/m2)']=oferty.apply(lambda x: round(x['Cena (zł)']/x['Powierzchnia (m2)'],2),axis=1)\n",
    "\n",
    "# Tworzę odpowiedni data frame w zależności od typu nieruchomości\n",
    "if oferty[oferty['Rodzaj nieruchomosci'].str.contains('Mieszkanie')].shape[0]>0:\n",
    "    kolejnosc_kolumn=['Nr oferty', 'Data dodania','Data pobrania oferty','Rodzaj nieruchomosci',\n",
    "                      'Adres','Powierzchnia (m2)','Cena (zł)','Cena (zł/m2)','Liczba pokoi','Rynek', \n",
    "                      'Rodzaj zabudowy', 'Piętro','Liczba pięter', 'Materiał budynku','Okna', 'Ogrzewanie', \n",
    "                      'Rok budowy', 'Stan wykończenia', 'Czynsz', 'Forma własności','Opis']\n",
    "    oferty=oferty.reindex(columns=kolejnosc_kolumn)\n",
    "elif oferty[oferty['Rodzaj nieruchomosci'].str.contains('Dom ')].shape[0]>0:\n",
    "    oferty.rename(columns={'Powierzchnia działki': 'Powierzchnia działki (m2)'}, inplace=True)\n",
    "    oferty['Powierzchnia działki (m2)']=oferty['Powierzchnia działki (m2)'].apply(lambda x: zmiana_na_float(x))\n",
    "    kolejnosc_kolumn=['Nr oferty', 'Data dodania','Data pobrania oferty',\n",
    "                      'Rodzaj nieruchomosci','Adres','Rynek','Powierzchnia (m2)','Powierzchnia działki (m2)',\n",
    "                    'Cena (zł)','Cena (zł/m2)', 'Rodzaj zabudowy','Stan wykończenia', 'Opis' ]\n",
    "    oferty=oferty.reindex(columns=kolejnosc_kolumn)\n",
    "elif oferty[oferty['Rodzaj nieruchomosci'].str.contains('Działka')].shape[0]>0:\n",
    "    kolejnosc_kolumn=['Nr oferty', 'Data dodania','Data pobrania oferty',\n",
    "                      'Rodzaj nieruchomosci','Adres', 'Powierzchnia (m2)', 'Cena (zł)', 'Cena (zł/m2)', \n",
    "                          'Typ działki', 'Opis']\n",
    "    oferty=oferty.reindex(columns=kolejnosc_kolumn)\n",
    "elif oferty[oferty['Rodzaj nieruchomosci'].str.contains('użytkowy')].shape[0]>0:\n",
    "    kolejnosc_kolumn=['Nr oferty', 'Data dodania','Data pobrania oferty',\n",
    "                      'Rodzaj nieruchomosci','Adres','Rynek','Powierzchnia (m2)','Cena (zł)','Cena (zł/m2)',\n",
    "                          'Piętro','Stan wykończenia', 'Przeznaczenie lokalu', 'Rok budowy', 'Opis']\n",
    "    oferty=oferty.reindex(columns=kolejnosc_kolumn)\n",
    "\n",
    "sciezka='/home/kinga/python/Web_scrapping/'+plik_wynikowy+'.xlsx'\n",
    "# zapisanie do pliku Excel \n",
    "oferty.to_excel(sciezka, index=False)\n",
    "print ('GOTOWE :) Plik został zapisany w lokalizacji: ', sciezka)\n",
    "\n",
    "        "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}