Строковые методы .split() и .join()

Разбор Д/З

Ещё немного про списки

Повторение: индексирование, связывание произвольных объектов, .append()/.pop
```
   1 >>> s = ["QWE", [1,2,3], None, 100500, 23.23]
   2 >>> s
   3 ['QWE', [1, 2, 3], None, 100500, 23.23]
   4 >>> s[0]
   5 'QWE'
   6 >>> s[-2]
   7 100500
   8 >>> a = 7
   9 >>> s.append(a)
  10 >>> s.append(a)
  11 >>> s
  12 ['QWE', [1, 2, 3], None, 100500, 23.23, 7, 7]
  13 >>> s.pop()
  14 7
  15 >>> s
  16 ['QWE', [1, 2, 3], None, 100500, 23.23, 7]
  17 
```
Хранение строк в списке
```
   1 >>> table = [ "+-----+","|..!..|","|.#.#.|", "|#...#|", "+-----+"]
   2 >>> for s in table:
   3 ...     print(s)
   4 ... 
   5 +-----+
   6 |..!..|
   7 |.#.#.|
   8 |#...#|
   9 +-----+
  10 
```
Циклический конструктор списка: [ выражение for имя in последовательность ]:
```
   1 >>> l = [i*2+1 for i in range(10)]
   2 >>> l
   3 [1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
   4 >>> l = [c*3 for c in "QwEr"]
   5 >>> l
   6 ['QQQ', 'www', 'EEE', 'rrr']
   7 
```
- Это не оператор цикла, это такой конструктор списка, на него похожий
В конструктор может входить фильтр значений:
```
   1 >>> l = [i*2+1 for i in range(10) if i!=6 ]
   2 >>> l
   3 [1, 3, 5, 7, 9, 11, 15, 17, 19]
   4 
```
- При этом сначала происходит связывание именем, затрем проверка, а затем, если проверка прошла, вычисление очередного элемента

split()/join()

Работа метода строка.split() — создание списка слов (пробельные символы "\t", "\n" и " " выбрасываются)

   1 >>> s = "asd    wer        WER"
   2 >>> s
   3 'asd  \twer \t   WER'
   4 >>> s.split()
   5 ['asd', 'wer', 'WER']
   6 >>> s = """asd          sdf 
   7 ... 
   8 ... sdf sdf       df
   9 ... sdf"""
  10 >>> s
  11 'asd \t\tsdf \n\nsdf sdf \t  df\nsdf'
  12 >>> s.split()
  13 ['asd', 'sdf', 'sdf', 'sdf', 'df', 'sdf']
  14

Работа метода строка.split(разделитель) — каждая строка-разделитель учитывается отдельно, если разделителей несколько подряд, между ними — пустые строки:
```
   1 >>> s = "qwe-sdf--qwer---qwer"
   2 >>> s.split("-")
   3 ['qwe', 'sdf', '', 'qwer', '', '', 'qwer']
   4 >>> s.split("--")
   5 ['qwe-sdf', 'qwer', '-qwer']
   6 
```
Работа метода разделитель.join(последовательность_строк)` — последовательность строк «склеивается», и между склеенными строками вставляется разделитель
```
   1 >>> sep="."
   2 >>> l = "QWE", "asd", "1234"
   3 >>> sep.join(l)
   4 'QWE.asd.1234'
   5 >>> "/".join(["17", "Jan", "2017"])
   6 '17/Jan/2017'
   7 >>> list("Force")
   8 ['F', 'o', 'r', 'c', 'e']
   9 >>> "<-->".join(list("Force"))
  10 'F<-->o<-->r<-->c<-->e'
  11 
```
Работа метода "".join(последовательность_строк)` — строки склеиваются:
```
   1 >>> "12-34-56-67".split("-")
   2 ['12', '34', '56', '67']
   3 >>> "".join("12-34-56-67".split("-"))
   4 '12345667'
   5 
```

Примеры:

Ввести два ФИО, проверить, тёзки ли они
```
   1 >>> n1, n2 = "Zee Som Khan", "Loo Som Yong"
   2 >>> n1.split()
   3 ['Zee', 'Som', 'Khan']
   4 >>> n1.split()[1]
   5 'Som'
   6 
```
- т. е.

   1 >>> n1.split()[1] == n2.split()[1]
   2 True
   3

разбить время "чч:мм:сс" на три числа
```
   1 >>> t = "12:35:28"
   2 >>> t.split(":")
   3 ['12', '35', '28']
   4 '12'
   5 >>> int(t.split(":")[0])
   6 12
   7 >>> [int(e) for e in t.split(":")]
   8 [12, 35, 28]
   9 
```
вывести список строк в виде прямоугольника (с помощью '\n'.join())
```
   1 >>> table = [ "+-----+","|..!..|","|.#.#.|", "|#...#|", "+-----+"]
   2 >>> "\n".join(table)
   3 '+-----+\n|..!..|\n|.#.#.|\n|#...#|\n+-----+'
   4 >>> print("\n".join(table))
   5 +-----+
   6 |..!..|
   7 |.#.#.|
   8 |#...#|
   9 +-----+
  10 
```
заменить каждый пробел точкой (.replace())
```
   1 >>> s = "sd   wer fgh    ty"
   2 >>> s.replace(" ",".")
   3 'sd...wer.fgh....ty'
   4 
```
заменить все последовательные пробелы одной точкой (split+join)
```
   1 >>> s.split()
   2 ['sd', 'wer', 'fgh', 'ty']
   3 >>> ".".join(s.split())
   4 'sd.wer.fgh.ty'
   5 
```
Получить из строки (например, в Д/З — ввести) список чисел через пробел(ы), а не через запятую
```
   1 >>> l = input()
   2 123  567 100500 1
   3 >>> l
   4 '123  567 100500 1'
   5 >>> l.split()
   6 ['123', '567', '100500', '1']
   7 >>> [int(e) for e in l.split()]
   8 [123, 567, 100500, 1]
   9 >>> a,b,c,d = [int(e) for e in l.split()]
  10 >>> a
  11 123
  12 >>> d
  13 1
  14 >>> c
  15 100500
  16 
```
- Другой вариант, при условии, что пробел между числами только один:
```
   1 >>> l = "123 456 100500 1"
   2 >>> l.replace(" ",",")
   3 '123,456,100500,1'
   4 >>> eval(l.replace(" ",","))
   5 (123, 456, 100500, 1)
   6 >>> a,b,c,d = eval(l.replace(" ",","))
   7 >>> a
   8 123
   9 >>> c
  10 100500
  11 >>> b
  12 456
  13 
```

Д/З

Повторить темы про списки и строки: десятая и восьмая главы учебника
EJudge: SumMult 'Сумма произведений'

Ввести строку, содержащую арифметическое выражение, в котором есть только цифры, и, возможно, операции сложения и умножения (других символов, в том числе пробелов, нет). Вывести через пробел все слагаемые в выражении. Пользоваться eval() можно.
Input:
```
0+1+2*3+4*5*6
```
Output:
```
0 1 6 120
```
EJudge: BaseName 'Имя файла'

Ввести строку, вида протокол://путь/к/файлу/имя.файла.расширение (т. е. напоминающую URL). Расширения (т. е. секции, начинающейся на «.») у файла и секции «протокол:» может не быть, но непустое имя точно есть, и путь точно содержит «/». Вывести только имя, отбросив расширение (если оно есть).
Input:
```
https://uneex.org/Python/PsyPython2018/Homework.BaseName.task
```
Output:
```
Homework.BaseName
```
EJudge: DateCmp 'Сравнить даты'

Ввести две даты в формате число-месяц-год, разделённые пробелом. Вывести их в порядке возрастания: сначала более раннюю, затем — более позднюю. Число и месяц могут задаваться одной или двумя цифрами, а год — всегда четырьмя.
Input:
```
1-06-2018 28-2-2018
```
Output:
```
28-2-2018 1-06-2018
```

Python/PsyPython2018/11_SplitJoin (последним исправлял пользователь FrBrGeorge 2018-11-28 01:21:16)