03-python-sequences.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python: sekwencje"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Typ znakowy\n",
    "\n",
    "W Python dostępne typem znakowym jest `str`.\n",
    "\n",
    "Jest to jeden z *sekwencyjnych* typów danych, co oznacza, że w pojedynczej zmiennej można przechowywać wiele wartości."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'To jest napis'\n",
    "long_text = \"\"\"To jest\n",
    "bardzo długi\n",
    "napis\"\"\"\n",
    "print(text)\n",
    "print(long_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# konwersja do typu str\n",
    "five = str(5.0)\n",
    "print(five)\n",
    "\n",
    "# długość napisu\n",
    "print(len(five))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# konwersja znaków do kodów ASCII\n",
    "print(ord('5'))\n",
    "print(chr(54))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# znaki specjalne/wyjścia escape characters zaczynają się od \\\n",
    "print('Niektóre \\t znaki np. \\\\t\\nmają znaczenie \\'specjalne\\' \\U0001F600')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# surowe łańcuchy znaków\n",
    "raw = r'Niektóre \\t znaki np. \\\\t\\nmają znaczenie \\'specjalne\\' \\U0001F600'\n",
    "print(raw)\n",
    "raw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# znaków ' i \" można używać zamiennie dla wygody\n",
    "print(\"Niektóre znaki mają znaczenie 'specjalne'\")\n",
    "print('Niektóre znaki mają znaczenie \"specjalne\"')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# łączenie i powielanie napisów\n",
    "hello = 'hello'\n",
    "world = 'world'\n",
    "hello_world = hello + ' ' + world\n",
    "print(hello_world)\n",
    "hello_world += '!' * 3\n",
    "print(hello_world)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# napis jest sekwencją znaków\n",
    "text = 'To jest napis'\n",
    "\n",
    "# indeksowanie\n",
    "print(text[0])  # indeksujemy od 0 (pierwszy znak)\n",
    "print(text[1])\n",
    "print(text[-1]) # ujemne wartości oznaczają indeksację od końca"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "text = 'To jest przykładowy napis'\n",
    "\n",
    "# wycinki (slices)\n",
    "print(text[1:5])    # od - do (przedział lewostronnie zamknięty)\n",
    "\n",
    "print(text[0:])     # brak wartości oznacza wartość skrajną\n",
    "print(text[:])      # brak wartości oznacza wartość skrajną (jak wyżej)\n",
    "\n",
    "print(text[:-1])    # ujemne wartości oznaczają indeksację od końca\n",
    "print(text[6:12:2]) # co drugi znak od znaku szóstego do dwunastego\n",
    "\n",
    "print(text[-1::-1]) # sekwencja od końca\n",
    "print(text[::-1])   # sekwencja od końca (jak wyżej)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Przetwarzanie napisów"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# formatowanie\n",
    "print('MAŁE LiterY'.lower())\n",
    "print('duże lITERy'.upper())\n",
    "print('tak jak w zdaniu'.capitalize())\n",
    "print('zmiana liter na początku wszystkich WYRAZÓW'.title())\n",
    "print('zamiana LITER'.swapcase())\n",
    "print('programujemy w pythonie'.center(80, '*'))\n",
    "print('programujemy w pythonie'.rjust(80))\n",
    "print('programujemy w pythonie'.ljust(80, '.'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# usuwanie białych znaków\n",
    "print('  \\tbiałe znaki\\t')\n",
    "print('  \\tbez białych znaków\\t'.strip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# wyszukiwanie\n",
    "print('czy zaczyna się od'.startswith('d'))\n",
    "print('czy kończy się na'.endswith('na'))\n",
    "print('gdzie występuje pierwsze'.find('i'))\n",
    "print('gdzie występuje ostatnie'.rfind('i'))\n",
    "print('zliczanie wystąpień'.count('i'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# wybrane właściwości ciągu\n",
    "print('alfa numeryczne 0'.isalnum()) # czy wartości alfanumeryczne\n",
    "print('2²'.isdigit())    # czy tylko cyfry\n",
    "print('2²'.isnumeric())  # czy wartości numeryczne (np. słowa w innych językach)\n",
    "print('2²'.isdecimal())  # czy cyfry dziesiętne\n",
    "print('tylko znaki'.isalpha())\n",
    "print('tylko małe litery'.islower())\n",
    "print('TYLKO WIELKIE'.isupper())\n",
    "print('\\t '.isspace())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# podmiana\n",
    "text = 'być albo nie być – oto jest pytanie'\n",
    "text.replace('być', 'Python')\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# metody można łączyć\n",
    "name = input('Podaj swoje imię: ')\n",
    "name = name.strip().capitalize()\n",
    "print(f'Dzień dobry {name}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lista\n",
    "\n",
    "Lista to jedna z kolekcji w Python. Lista jest typem reprezentującym uporządkowaną strukturę danych, która:\n",
    "- jest sekwencją\n",
    "- jest tworzona za pomocą nawiasów kwadratowych `[]` lub `list`\n",
    "- może przechowywać elementy różnych typów, elementy mogą się powtarzać\n",
    "- jest mutowalna, można zmieniać jej zawartość"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_list = []\n",
    "print(empty_list)\n",
    "empty_list = list()\n",
    "print(empty_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "miscs = ['Python', 16, 3.14, True]\n",
    "print(len(miscs))\n",
    "\n",
    "# dodanie elementu na końcu listy\n",
    "miscs.append(None)\n",
    "print(miscs)\n",
    "miscs.append(['12'])\n",
    "miscs.extend(list('34'))\n",
    "print(miscs)\n",
    "\n",
    "# pobranie i usunięcie ostatniego elementu\n",
    "last = miscs.pop()\n",
    "print(last)\n",
    "print(miscs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# wstawienie elementu na danej pozycji\n",
    "miscs.insert(0, 'big')\n",
    "miscs.insert(1, 'data')\n",
    "print(miscs)\n",
    "\n",
    "# usunięcie elementu\n",
    "miscs.remove('Python')\n",
    "print(miscs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# modyfikacja elementu\n",
    "miscs[2] **= 2\n",
    "print(miscs)\n",
    "\n",
    "# odwrócenie listy\n",
    "miscs.reverse()\n",
    "print(miscs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# wycinki\n",
    "print(miscs[2:4])\n",
    "print(miscs[:-3:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# listy mogą być wynikiem i parametrem różnych operacji\n",
    "name = input('Podaj imiona: ')\n",
    "names = name.split() # dzieli ciąg znaków na poszczególne wartości\n",
    "print(names)\n",
    "print(f'Witajcie {\", \".join(names)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Krotka\n",
    "\n",
    "Krotka jest typem reprezentującym kolekcję uporządkowaną, która:\n",
    "- jest sekwencją\n",
    "- jest tworzona za pomocą nawiasów okrągłych `()` (można je pominąć) lub `tuple`\n",
    "- może przechowywać elementy różnych typów, elementy mogą się powtarzać\n",
    "- jest niemutowalna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty_tuple = ()\n",
    "print(empty_tuple)\n",
    "empty_tuple = tuple()\n",
    "print(empty_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nawiasy nie są wymagane, szczególnym przypadkiem jest krotka jednoelementowa\n",
    "val = 1\n",
    "print(type(val))\n",
    "val = (1)\n",
    "print(type(val))\n",
    "val = 1,\n",
    "print(type(val))\n",
    "val = 1, 2\n",
    "print(type(val))\n",
    "val = (1,)\n",
    "print(type(val))\n",
    "val = ('value')\n",
    "print(type(val))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "miscs = 'Python', 16, 3.14, True\n",
    "print(len(miscs))\n",
    "miscs += 5,\n",
    "print(miscs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Typ bytes i bytearray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Typy `bytes` i `bytearray` przeznaczone są do przechowywania tablic bajtów (wartości od 0 do 255). Typ `bytes` jest niemutowalny, `bytearray` pozwala na zmianę wartości."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bytes_text = bytes('zażółć gęślą jaźń', 'utf-8')\n",
    "print(bytes_text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bytearray_text = bytearray('zażółć gęślą jaźń', 'utf-8')\n",
    "print(bytearray_text)\n",
    "bytearray_text[0] = ord('Z')\n",
    "print(bytearray_text.decode())"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}