Verification: a143cc29221c9be0

Php check if directory exists

Дзен Python ↑

Из PEP 20 — The Zen of Python:

Пионер Python Тим Петерс (Tim Peters) кратко сформулировал направляющие и руководящие принципы BDFL для разработки на Python в 20-ти афоризмах, но только 19 из них были записаны.

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the tcodeptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implcodeentation is hard to explain, it's a bad idea.
If the implcodeentation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

В переводе на русский:   ↑
  • Красивое лучше, чем уродливое.
  • Явное лучше, чем неявное.
  • Простое лучше, чем сложное.
  • Сложное лучше, чем запутанное.
  • Плоское лучше, чем вложенное.
  • Разреженное лучше, чем плотное.
  • Читаемость имеет значение.
  • Особые случаи не настолько особые, чтобы нарушать правила.
  • При этом практичность важнее безупречности.
  • Ошибки никогда не должны замалчиваться.
  • Если они не замалчиваются явно.
  • Встретив двусмысленность, отбрось искушение угадать.
  • Должен существовать один и, желательно, только один очевидный способ сделать это.
  • Хотя он поначалу может быть и не очевиден, если вы не голландец [^1].
  • Сейчас лучше, чем никогда.
  • Хотя никогда зачастую лучше, чем прямо сейчас.
  • Если реализацию сложно объяснить — идея плоха.
  • Если реализацию легко объяснить — идея, возможно, хороша.
  • Пространства имён — отличная штука! Будем делать их больше!

Основы Python ↑

Математические операторы   ↑

В порядке уменьшения приоритета при вычислениях арифметических выражений:

**

Возведение в степень

2 ** 3 = 8

%

Остаток от деления

22 % 8 = 6

//

Целочисленное деление

22 // 8 = 2

Примеры выражение в интерактивной консоли Python:

>>> 2 + 3 * 6
20
>>> (2 + 3) * 6
30
>>> 2 ** 8
256
>>> 23 // 7
3
>>> 23 % 7
2
>>> (5 - 1) * ((7 + 1) / (3 - 1))
16.0

Типы данных   ↑

Целые

-2, -1, 0, 1, 2, 3, 4, 5

Числа с плавающей точкой

-1.25, -1.0, --0.5, 0.0, 0.5, 1.0, 1.25

Строки

'a', 'aa', 'aaa', 'Hello!', '11 cats'

Конкатенация и репликация строк   ↑

Конкатенация строк:

>>> 'Alice' 'Bob'
'AliceBob'

Примечание. Для конкатенации строк избегайте использования оператора +. Предпочтительнее использовать форматирование строки.

Репликация строк:

>>> 'Alice' * 5
'AliceAliceAliceAliceAlice'

Переменные   ↑

Переменной можно присвоить любое имя, если оно отвечает следующим трем правилам:

  1. Это может быть только одно слово.
  2. Оно может содержать только буквы, цифры и знак подчеркивания (_). Имя не может начинаться с цифры.
  3. Имя переменной, начинающееся с подчеркивания (_), считается «бессмысленным».

Пример:

>>> spam = 'Hello'
>>> spam
'Hello'
>>> _spam = 'Hello'

_spam не надо использовать в коде.

Комментарий в строке:

# Это комментарий

Комментарий в несколько строк:

# Этот комментарий состоит
# из нескольких строк

Комментарий в коде:

a = 1  # инициализация

Пожалуйста, обратите внимание на два пробела перед комментарием.

Самодокументирование функций:

def foo():
    """
    Это строки для описания функции (самодокументирования)
    Можно делать и так:
    ''' Это строка для описания функции (самодокументирования) '''
    """

Функция print()   ↑
>>> print('Hello world!')
Hello world!
>>> a = 1
>>> print('Hello world!', a)
Hello world! 1

Функция input()   ↑

Пример Code:

>>> print('What is your name?')   # ask for their name
>>> myName = input()
>>> print('It is good to meet you, {}'.format(myName))
What is your name?
Al
It is good to meet you, Al

Функция len()   ↑

Вычисляет количество символов в строке:

>>> len('hello')
5

Примечание: не используйте len для проверки наличия символов в строке, элементов в списке, словаре и прочее. Для этого применяйте логические операторы.

>>> a = [1, 2, 3]
>>> if a:
>>>     print("the list is not codepty!")

Функции str(), int() и float()/h3>

Преобразование целого значения в строку или в число с плавающей точкой:

>>> str(29)
'29'
>>> print('Мой возраст - {} лет.'.format(str(29)))
Мой возраст - 29 лет.
>>> str(-3.14)
'-3.14'

Преобразование чисел с плавающей точкой в целые:

>>> int(7.7)
7
>>> int(7.7) + 1
8

Основы Python ↑

Математические операторы   ↑

Управление вычислениями ↑

Операторы сравнения   ↑

В зависимости от операндов эти операторы возвращают значениея True или False.

Примеры:

>>> 42 == 42
True
>>> 40 == 42
False
>>> 'hello' == 'hello'
True
>>> 'hello' == 'Hello'
False
>>> 'dog' != 'cat'
True
>>> 42 == 42.0
True
>>> 42 == '42'
False

Логические выражения   ↑

Никогда не используйте операторы == или != для выполнения логической операции. Используйте для этого только is или is not.

НЕТ (даже если верно в Python):

>>> True == True
True
>>> True != False
True

ДА (даже если верно в Python):

>>> True is True
True
>>> True is not False
True

Эти выражения эквивалентны:

>>> if a is True:
>>>    pass
>>> if a is not False:
>>>    pass
>>> if a:
>>>    pass

и эти то-же:

>>> if a is False:
>>>    pass
>>> if a is not True:
>>>    pass
>>> if not a:
>>>    pass

Логические (булевы) операторы   ↑

Существует всего три булевых оператора: and (И), or (ИЛИ) и not (НЕТ).

Таблица для использования оператора and:

Таблица для использования оператора or:

Таблица для использования оператора not:

Логические операторы и операторы сравнения   ↑
>>> (4 
>>> (4 
>>> (1 == 2) or (2 == 2)
True

Вы также можете использовать несколько логических операторов в выражении вместе с операторами сравнения:

>>> 2 + 2 == 4 and not 2 + 2 == 5 and 2 * 2 == 2 + 2
True

Оператор if   ↑
if name == 'Alice':
    print('Hi, Alice.')

Оператор else   ↑
name = 'Bob'
if name == 'Alice':
    print('Hi, Alice.')
else:
    print('Hello, stranger.')

Оператор elif   ↑
name = 'Bob'
age = 5
if name == 'Alice':
    print('Hi, Alice.')
elif age 
name = 'Bob'
age = 30
if name == 'Alice':
    print('Hi, Alice.')
elif age 

Оператор цикла while   ↑
spam = 0
while spam 

Оператор break   ↑

В циклических конструкциях оператор break немедленно проиводит к выходу из цикла:

while True:
    print('Please type your name.')
    name = input()
    if name == 'your name':
        break
print('Thank you!')

Оператор continue   ↑

В циклических конструкциях оператор continue немедленно возвращается к началу цикла. Таким образом, при опроеделенных условиях можно миновать часть кода тела цикла и продолжить его выполенение.

while True:
    print('Кто ты?')
    name = input()
    if name != 'Джон':
        continue
    print('Привет, Джон. Какой у тебя пароль? (Напоминаю, Рыба.)')
    password = input()
    if password == 'swordfish':
        break
print('Доступ запрещен!')

Оператор цикла for и функция range()   ↑
>>> print('Моё имя')
>>> for i in range(5):
>>>     print('Джимми пять раз ({})'.format(str(i)))
Моё имя
Джимми пять раз (0)
Джимми пять раз (1)
Джимми пять раз (2)
Джимми пять раз (3)
Джимми пять раз (4)

Функция range() может иметь три аргумента. Значения первых двух аргументов start и stop, а третий аргумент — step. Параметр step — величина, на которую увеличивается параметр цикла for после каждой итерации.

>>> for i in range(0, 10, 2):
>>>    print(i)
0
2
4
6
8

Для обратного отсчета можно использовать отрицательное значение параметра step

>>> for i in range(5, -1, -1):
>>>     print(i)
5
4
3
2
1
0

Конструкция for else   ↑

Конструкция позволяет записать оператор для выполнения полного цикла. Полезно, только когда в цикле может возникнуть условие выхода по break:

>>> for i in [1, 2, 3, 4, 5]:
>>>    if i == 3:
>>>        break
>>> else:
>>>    print("выполняется только тогда, когда ни один элемент списка не равен 3")

Импорт модулей   ↑
import random
for i in range(5):
    print(random.randint(1, 10))
import random, sys, os, math
from random import *.

Завершение программы с использованием функции sys.exit()   ↑
import sys

while True:
    print('Type exit to exit.')
    response = input()
    if response == 'exit':
        sys.exit()
    print('You typed {}.'.format(response))

Функции ↑

>>> def hello(name):
>>>     print('Hello {}'.format(name))
>>>
>>> hello('Alice')
>>> hello('Bob')
Hello Alice
Hello Bob

Возвращаемое значение и return   ↑

При создании функции оператором def с помощью оператора return можно указать, каким будет возвращаемое значение. Оператор return используется следующим образом:

  • Ключевое слово return.

  • Значение или выражене, результат которого возвращается вызывающей функции.

import random
def getAnswer(answerNumber):
    if answerNumber == 1:
        return 'Так точно'
    elif answerNumber == 2:
        return 'Решительно так'
    elif answerNumber == 3:
        return 'Да'
    elif answerNumber == 4:
        return 'Ответить смутно. Попробуйте еще'
    elif answerNumber == 5:
        return 'Спросите еще раз'
    elif answerNumber == 6:
        return 'Соберись и спроси снова'
    elif answerNumber == 7:
        return 'Ни как нет'
    elif answerNumber == 8:
        return 'Внешний вид не есть хорошо'
    elif answerNumber == 9:
        return 'Очень сомнительно'

r = random.randint(1, 9)
fortune = getAnswer(r)
print(fortune)

Значение None   ↑
>>> spam = print('Hello!')
Hello!
>>> spam is None
True

Примечание: никогда не сравнивайте None, используя оператор ==. Только is уместно в этом случае.

Ключевое слово Arguments and print()   ↑
>>> print('Привет', end='')
>>> print('Мир')
ПриветМир
>>> print('кошки', 'собаки', 'мыши')
кошки собаки мыши
>>> print('кошки', 'собаки', 'мыши', sep=',')
кошки,собаки,мыши

Локальная и глобальная область   ↑
  • Код, расположенный в глобальной зоне видимости не может использовать какие-либо локальные переменные.

  • Однако, в локальной зоне можно обращаться к глобальным переменным.

  • Код внутри функции не может использовать переменные из любой другой функции кроме зоны глобальной видимости.

  • Различные переменныу могут иметь одинаковые имена, если они находятся в разных зонах видимости. То есть может существовать локальная переменная с именем spam и глобальная переменная с именем spam и это две разные переменные.

Оператор global   ↑

Если внутри функции необходимо изменить глобальную переменную, то используется оператор global:

>>> def spam():
>>>     global eggs
>>>     eggs = 'spam'
>>>
>>> eggs = 'global'
>>> spam()
>>> print(eggs)
spam

Существует четыре правила для определения локальных и глобальных переменных переменных:

  1. Если переменная используется в вне всех функций, в глобальной зоне видимости, то она всегда является глобальной переменной.

  2. Если в функции для переменной использован оператор global, то это глобальная переменная.

  3. В противном случае, если переменная используется в операторе присваивания в функции, она является локальной переменной.

  4. Но если переменная не используется в операторе присваивания, это глобальная переменная.

Функции ↑

>>> def hello(name):
>>>     print('Hello {}'.format(name))
>>>
>>> hello('Alice')
>>> hello('Bob')
Hello Alice
Hello Bob

Возвращаемое значение и return   ↑

Обработка исключений ↑

Основы обработки исключений   ↑
>>> def spam(divideBy):
>>>     try:
>>>         return 42 / divideBy
>>>     except ZeroDivisionError as e:
>>>         print('Error: Invalid argument: {}'.format(e))
>>>
>>> print(spam(2))
>>> print(spam(12))
>>> print(spam(0))
>>> print(spam(1))
21.0
3.5
Error: Invalid argument: division by zero
None
42.0

Final code in exception handling   ↑

Код в секции finally выполняется всегда независимо от того, было ли вызвано исключение или нет, и даже если исключения не было.

>>> def spam(divideBy):
>>>     try:
>>>         return 42 / divideBy
>>>     except ZeroDivisionError as e:
>>>         print('Error: Invalid argument: {}'.format(e))
>>>     finally:
>>>         print("-- division finished --")
>>> print(spam(12))
>>> print(spam(0))
21.0
-- division finished --
3.5
-- division finished --
Error: Invalid argument: division by zero
-- division finished --
None
-- division finished --
42.0
-- division finished --

Списки ↑

>>> spam = ['cat', 'bat', 'rat', 'elephant']

>>> spam
['cat', 'bat', 'rat', 'elephant']

Получение элемента списка по индексу   ↑
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[0]
'cat'
>>> spam[1]
'bat'
>>> spam[2]
'rat'
>>> spam[3]
'elephant'

Отрицательные индексы   ↑
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[-1]
'elephant'
>>> spam[-3]
'bat'
>>> 'The {} is afraid of the {}.'.format(spam[-1], spam[-3])
'The elephant is afraid of the bat.'

Получение фрагментов списков   ↑
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[0:4]
['cat', 'bat', 'rat', 'elephant']
>>> spam[1:3]
['bat', 'rat']
>>> spam[0:-1]
['cat', 'bat', 'rat']
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[:2]
['cat', 'bat']
>>> spam[1:]
['bat', 'rat', 'elephant']

Получения фрагмена списка с помощью копирования полного списка с последующим добавлением:

>>> spam2 = spam[:]
['cat', 'bat', 'rat', 'elephant']
>>> spam.append('dog')
>>> spam
['cat', 'bat', 'rat', 'elephant', 'dog']
>>> spam2
['cat', 'bat', 'rat', 'elephant']

Получение количества элементов списка с использованием len()   ↑
>>> spam = ['cat', 'dog', 'moose']
>>> len(spam)
3

Изменение значений элементов списка по индексу   ↑
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam[1] = 'aardvark'

>>> spam
['cat', 'aardvark', 'rat', 'elephant']

>>> spam[2] = spam[1]

>>> spam
['cat', 'aardvark', 'aardvark', 'elephant']

>>> spam[-1] = 12345

>>> spam
['cat', 'aardvark', 'aardvark', 12345]

Объединение и репликация списков   ↑
>>> [1, 2, 3] + ['A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C']

>>> ['X', 'Y', 'Z'] * 3
['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z']

>>> spam = [1, 2, 3]

>>> spam = spam + ['A', 'B', 'C']

>>> spam
[1, 2, 3, 'A', 'B', 'C']

Удаление элементов списка, используя del   ↑
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat']

Использование цикла for для списков   ↑
>>> supplies = ['pens', 'staplers', 'flame-throwers', 'binders']
>>> for i, supply in enumerate(supplies):
>>>     print('Index {} in supplies is: {}'.format(str(i), supply))
Index 0 in supplies is: pens
Index 1 in supplies is: staplers
Index 2 in supplies is: flame-throwers
Index 3 in supplies is: binders

Циклический просмотр нескольких списков с помощью zip()   ↑
>>> name = ['Pete', 'John', 'Elizabeth']
>>> age = [6, 23, 44]
>>> for n, a in zip(name, age):
>>>     print('{} is {} years old'.format(n, a))
Pete is 6 years old
John is 23 years old
Elizabeth is 44 years old

in и not в операторах   ↑
>>> 'howdy' in ['hello', 'hi', 'howdy', 'heyas']
True
>>> spam = ['hello', 'hi', 'howdy', 'heyas']
>>> 'cat' in spam
False
>>> 'howdy' not in spam
False
>>> 'cat' not in spam
True

Трюк множественного присва́ивания   ↑

Трюк с множественным присва́иванием позволяет назначать нескольким переменным списка в одной строке кода. Например:

>>> cat = ['fat', 'orange', 'loud']

>>> size = cat[0]

>>> color = cat[1]

>>> disposition = cat[2]

Можно ввести следующую строку кода:

>>> cat = ['fat', 'orange', 'loud']

>>> size, color, disposition = cat

Трюк множественного присва́ивания также иможно спользовать для замены значений в двух переменных:

>>> a, b = 'Alice', 'Bob'
>>> a, b = b, a
>>> print(a)
'Bob'
>>> print(b)
'Alice'

Расширенные операторы присваивания   ↑

spam += 1

spam = spam + 1

spam -= 1

spam = spam – 1

spam *= 1

spam = spam * 1

spam /= 1

spam = spam / 1

spam %= 1

spam = spam % 1

Примеры:

>>> spam = 'Hello'
>>> spam += ' world!'
>>> spam
'Hello world!'

>>> bacon = ['Zophie']
>>> bacon *= 3
>>> bacon
['Zophie', 'Zophie', 'Zophie']

Метод index() для поиска значение в списке   ↑
>>> spam = ['Zophie', 'Pooka', 'Fat-tail', 'Pooka']

>>> spam.index('Pooka')
1

Методы append() и insert() для добавления элементов в список   ↑

append():

>>> spam = ['cat', 'dog', 'bat']

>>> spam.append('moose')

>>> spam
['cat', 'dog', 'bat', 'moose']

insert():

>>> spam = ['cat', 'dog', 'bat']

>>> spam.insert(1, 'chicken')

>>> spam
['cat', 'chicken', 'dog', 'bat']

Метод rcodeove() для удаления элементов из списка   ↑
>>> spam = ['cat', 'bat', 'rat', 'elephant']

>>> spam.rcodeove('bat')

>>> spam
['cat', 'rat', 'elephant']

Если в списке есть несколько одинаковых по значению элементов, то по умолчанию удаляется только первый элемент.

Методом sort() для сортировки списка   ↑
>>> spam = [2, 5, 3.14, 1, -7]
>>> spam.sort()
>>> spam
[-7, 1, 2, 3.14, 5]
>>> spam = ['ants', 'cats', 'dogs', 'badgers', 'elephants']
>>> spam.sort()
>>> spam
['ants', 'badgers', 'cats', 'dogs', 'elephants']

Кроме того, можно передать True для параметра reverse для сортировки в обратном порядке:

>>> spam.sort(reverse=True)
>>> spam
['elephants', 'dogs', 'cats', 'badgers', 'ants']

Если вам нужно отсортировать значения в обычном алфавитном порядке, то при вызове метода sort() передайте str.lower в качестве аргумента key:

>>> spam = ['a', 'z', 'A', 'Z']
>>> spam.sort(key=str.lower)
>>> spam
['a', 'A', 'z', 'Z']

Кроме того, для определения нового списка есть функция sorted:

>>> spam = ['ants', 'cats', 'dogs', 'badgers', 'elephants']
>>> sorted(spam)
['ants', 'badgers', 'cats', 'dogs', 'elephants']

Тип данных кортеж   ↑
>>> eggs = ('hello', 42, 0.5)
>>> eggs[0]
'hello'
>>> eggs[1:3]
(42, 0.5)
>>> len(eggs)
3

Главное, чем кортежи отличаются от списков, то, что кортежи, как и строки, неизменны.

Функции list() и tuple()   ↑
>>> tuple(['cat', 'dog', 5])
('cat', 'dog', 5)
>>> list(('cat', 'dog', 5))
['cat', 'dog', 5]
>>> list('hello')
['h', 'e', 'l', 'l', 'o']

Словари и структуры данных ↑

Пример словаря:

myCat = {'size': 'fat', 'color': 'gray', 'disposition': 'loud'}

Методы keys(), values() и itcodes()   ↑

values():

>>> spam = {'color': 'red', 'age': 42}
>>> for v in spam.values():
>>>     print(v)
red
42

keys():

>>> for k in spam.keys():
>>>     print(k)
color
age

itcodes():

>>> for i in spam.itcodes():
>>>     print(i)
('color', 'red')
('age', 42)

Методы keys(), values() и itcodes() в цикле for позволяют итерационно получать в словарях ключи, значения и пары ключ-значение.

>>> spam = {'color': 'red', 'age': 42}
>>>
>>> for k, v in spam.itcodes():
>>>     print('Key: {} Value: {}'.format(k, str(v)))
Key: age Value: 42
Key: color Value: red

Проверка наличия ключа или значения в словаре   ↑
>>> spam = {'name': 'Zophie', 'age': 7}
>>> 'name' in spam.keys()
True
>>> 'Zophie' in spam.values()
True
>>> # You can omit the call to keys() when checking for a key
>>> 'color' in spam
False
>>> 'color' not in spam
True

Метод get()   ↑
>>> picnic_itcodes = {'apples': 5, 'cups': 2}

>>> 'I am bringing {} cups.'.format(str(picnic_itcodes.get('cups', 0)))
'I am bringing 2 cups.'
>>> 'I am bringing {} eggs.'.format(str(picnic_itcodes.get('eggs', 0)))
'I am bringing 0 eggs.'

Метод setdefault()   ↑

Рассмотрим этот код:

spam = {'name': 'Pooka', 'age': 5}

if 'color' not in spam:
    spam['color'] = 'black'

Используя setdefault, можно написать тот же код более лаконично:

>>> spam = {'name': 'Pooka', 'age': 5}
>>> spam.setdefault('color', 'black')
'black'
>>> spam
{'color': 'black', 'age': 5, 'name': 'Pooka'}
>>> spam.setdefault('color', 'white')
'black'
>>> spam
{'color': 'black', 'age': 5, 'name': 'Pooka'}

Красивая печать   ↑
>>> import pprint
>>>
>>> message = 'It was a bright cold day in April, and the clocks were striking
>>> thirteen.'
>>> count = {}
>>>
>>> for character in message:
>>>     count.setdefault(character, 0)
>>>     count[character] = count[character] + 1
>>>
>>> pprint.pprint(count)
{' ': 13,
 ',': 1,
 '.': 1,
 'A': 1,
 'I': 1,
 'a': 4,
 'b': 1,
 'c': 3,
 'd': 3,
 'e': 5,
 'g': 2,
 'h': 3,
 'i': 6,
 'k': 2,
 'l': 3,
 'n': 4,
 'o': 2,
 'p': 1,
 'r': 5,
 's': 3,
 't': 6,
 'w': 2,
 'y': 1}

Объединение двух словарей   ↑
# in Python 3.5+:
>>> x = {'a': 1, 'b': 2}
>>> y = {'b': 3, 'c': 4}
>>> z = {**x, **y}
>>> z
{'c': 4, 'a': 1, 'b': 3}

# in Python 2.7
>>> z = dict(x, **y)
>>> z
{'c': 4, 'a': 1, 'b': 3}

Наборы ↑

Документация для Python 3

Набор — неупорядоченная коллекция элементов с уникальными значениями. Наиболее эффективно применять для проверки членства и устранении дубликатов. Объекты Set поддерживают математические операции, такие как объединение, пересечение, разность и симметричная разность.

Инициализация набора   ↑

Есть несколько способов создания наборов: использование фигурных скобок {} и встроенной функции set()

>>> s = {1, 2, 3}
>>> s = set([1, 2, 3])

При создании пустого набора не используйте фигурные скобки {}, иначе вы получите пустой словарь.

>>> s = {}
>>> type(s)
class 'dict'>

Наборы: неупорядоченные коллекции уникальных элементов   ↑

Из набора автоматически удаляются все повторяющиеся элементы.

>>> s = {1, 2, 3, 2, 3, 4}
>>> s
{1, 2, 3, 4}

И как неупорядоченный тип данных, наборы не индексируются.

>>> s = {1, 2, 3}
>>> s[0]
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'set' object does not support indexing
>>>

Методы add() и update() объекта set   ↑

Используйте метод add() для добавления простого элемента в набор.

>>> s = {1, 2, 3}
>>> s.add(4)
>>> s
{1, 2, 3, 4}

И метод update() для множественной операции добавления.

>>> s = {1, 2, 3}
>>> s.update([2, 3, 4, 5, 6])
>>> s
{1, 2, 3, 4, 5, 6}  # rcodecodeber, sets automatically rcodeove duplicates

Методы rcodeove() и discard() объекта set   ↑

Оба метода удаляют элемент из набора, но rmove() вызовет key error при отсутствии элемента в наборе.

>>> s = {1, 2, 3}
>>> s.rcodeove(3)
>>> s
{1, 2}
>>> s.rcodeove(3)
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 3

discard() не вызовет никаких ошибок.

>>> s = {1, 2, 3}
>>> s.discard(3)
>>> s
{1, 2}
>>> s.discard(3)
>>>

Набор union()   ↑

union() или | создаст новый набор, который содержит все элементы из предоставленных наборов.

>>> s1 = {1, 2, 3}
>>> s2 = {3, 4, 5}
>>> s1.union(s2)  # or 's1 | s2'
{1, 2, 3, 4, 5}

Пересечение наборов   ↑

intersection или & возвращает набор только тех элементов, которые принадлежат всем наборам одновременно.

>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s3 = {3, 4, 5}
>>> s1.intersection(s2, s3)  # or 's1 & s2 & s3'
{3}

Разность наборов   ↑

difference или - возвращает набор тех элементов, которые есть только в одном наборе.

>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.difference(s2)  # or 's1 - s2'
{1}

Симметричная разность наборов   ↑

symetric_difference или ^ возвращает набор из тех элементов, которые не являются общими.

>>> s1 = {1, 2, 3}
>>> s2 = {2, 3, 4}
>>> s1.symmetric_difference(s2)  # or 's1 ^ s2'
{1, 4}

Модуль itertools представляет собой коллекцию инструментов оптимизорованных по скорости и использованию памяти для работы с итераторами(например, списками или словарями).

Из официальной документации Python 3.x:

Модуль стандартизирует основной набор быстрых, эффективных по памяти инструментов, которые полезны сами по себе или в сочетании. Вместе они образуют «алгебру итераторов», позволяющую быстро и эффективно создавать специализированные инструменты в чистом Python.

Модуль itertools есть в стандартнй библиотеке и может быть без проблем импортирован.

Кроме того, будет использоваться модуль operator, который необязателен, но полезен в примерах ниже.

accumulate()   ↑

Создание итератора с функцией итерирования (перебора).

itertools.accumulate(iterable[, func])

Пример:

>>> data = [1, 2, 3, 4, 5]
>>> result = itertools.accumulate(data, operator.mul)
>>> for each in result:
>>>    print(each)
1
2
6
24
120

operator.mul перемножает два числа:

operator.mul(1, 2)
2
operator.mul(2, 3)
6
operator.mul(6, 4)
24
operator.mul(24, 5)
120

Передавать функцию итерирования необязательно:

>>> data = [5, 2, 6, 4, 5, 9, 1]
>>> result = itertools.accumulate(data)
>>> for each in result:
>>>    print(each)
5
7
13
17
22
31
32

Если нет функции, то элементы итератора суммируются:

5
5 + 2 = 7
7 + 6 = 13
13 + 4 = 17
17 + 5 = 22
22 + 9 = 31
31 + 1 = 32

combinations()   ↑

Из элементов итератора создаются все возможные комбинации размером r.

itertools.combinations(iterable, r)

Пример:

>>> shapes = ['circle', 'triangle', 'square',]
>>> result = itertools.combinations(shapes, 2)
>>> for each in result:
>>>    print(each)
('circle', 'triangle')
('circle', 'square')
('triangle', 'square')

combinations_with_replaccodeent()   ↑

Аналогично combinations(), но элементы в комбинациях могут повторятся более одного раза.

itertools.combinations_with_replaccodeent(iterable, r)

Пример:

>>> shapes = ['circle', 'triangle', 'square']
>>> result = itertools.combinations_with_replaccodeent(shapes, 2)
>>> for each in result:
>>>    print(each)
('circle', 'circle')
('circle', 'triangle')
('circle', 'square')
('triangle', 'triangle')
('triangle', 'square')
('square', 'square')

count()   ↑

Создает итератор, который возвращает равномерно распределенные значения, начиная с номера start.

itertools.count(start=0, step=1)

Пример:

>>> for i in itertools.count(10,3):
>>>    print(i)
>>>    if i > 20:
>>>        break
10
13
16
19
22

cycle()   ↑

Эта функция проходит через итератор бесконечно.

itertools.cycle(iterable)

Пример:

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue', 'violet']
>>> for color in itertools.cycle(colors):
>>>    print(color)
red
orange
yellow
green
blue
violet
red
orange

Достигнув конца итерации, она начинается заново с самого начала.

chain()   ↑

Объединяет серию итераций в одну длинную итерацию.

itertools.chain(*iterables)

Пример:

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue']
>>> shapes = ['circle', 'triangle', 'square', 'pentagon']
>>> result = itertools.chain(colors, shapes)
>>> for each in result:
>>>    print(each)
red
orange
yellow
green
blue
circle
triangle
square
pentagon

compress()   ↑

Фильтрует итератор.

itertools.compress(data, selectors)

Пример:

>>> shapes = ['circle', 'triangle', 'square', 'pentagon']
>>> selections = [True, False, True, False]
>>> result = itertools.compress(shapes, selections)
>>> for each in result:
>>>    print(each)
circle
square

dropwhile()   ↑

Создаёт новый итератор, где из исходного итератора элементы удаляются до тех пор, пока predicate == True.

itertools.dropwhile(predicate, iterable)

Пример:

>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1]
>>> result = itertools.dropwhile(lambda x: x>> for each in result:
>>>    print(each)
5
6
7
8
9
10
1

filterfalse()   ↑

Создаёт новый итератор, где из исходного итератора фильтруются элементы для predicate == False.

itertools.filterfalse(predicate, iterable)

Пример:

>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> result = itertools.filterfalse(lambda x: x>> for each in result:
>>>    print(each)
5
6
7
8
9
10

groupby()   ↑

Проще говоря, эта функция группирует элементы вместе.

itertools.groupby(iterable, key=None)

Пример:

>>> robots = [{
    'name': 'blaster',
    'faction': 'autobot'
}, {
    'name': 'galvatron',
    'faction': 'decepticon'
}, {
    'name': 'jazz',
    'faction': 'autobot'
}, {
    'name': 'metroplex',
    'faction': 'autobot'
}, {
    'name': 'megatron',
    'faction': 'decepticon'
}, {
    'name': 'starcream',
    'faction': 'decepticon'
}]
>>> for key, group in itertools.groupby(robots, key=lambda x: x['faction']):
>>>    print(key)
>>>    print(list(group))
autobot
[{'name': 'blaster', 'faction': 'autobot'}]
decepticon
[{'name': 'galvatron', 'faction': 'decepticon'}]
autobot
[{'name': 'jazz', 'faction': 'autobot'}, {'name': 'metroplex', 'faction': 'autobot'}]
decepticon
[{'name': 'megatron', 'faction': 'decepticon'}, {'name': 'starcream', 'faction': 'decepticon'}]

islice()   ↑

Эта функция очень похожа на ножик, который нарезает итератор на кусочки разного размера.

itertools.islice(iterable, start, stop[, step])

Пример:

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue',]
>>> few_colors = itertools.islice(colors, 2)
>>> for each in few_colors:
>>>    print(each)
red
orange

permutations()   ↑
itertools.permutations(iterable, r=None)

Все возможные перестановки элементов итератора

Пример:

>>> alpha_data = ['a', 'b', 'c']
>>> result = itertools.permutations(alpha_data)
>>> for each in result:
>>>    print(each)
('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')

product()   ↑

Создает декартовы произведения из серии итераций.

>>> num_data = [1, 2, 3]
>>> alpha_data = ['a', 'b', 'c']
>>> result = itertools.product(num_data, alpha_data)
>>> for each in result:
    print(each)
(1, 'a')
(1, 'b')
(1, 'c')
(2, 'a')
(2, 'b')
(2, 'c')
(3, 'a')
(3, 'b')
(3, 'c')

repeat()   ↑

Эта функция будет повторять объект снова и снова. Если нет аргумента times.

itertools.repeat(object[, times])

Пример:

>>> for i in itertools.repeat("spam", 3):
    print(i)
spam
spam
spam

starmap()   ↑

Создаёт итератор, используя function, подставляя в неё аргументы из iterable.

itertools.starmap(function, iterable)

Пример:

>>> data = [(2, 6), (8, 4), (7, 3)]
>>> result = itertools.starmap(operator.mul, data)
>>> for each in result:
>>>    print(each)
12
32
21

takewhile()   ↑

Противоположность dropdown(). Создаёт новый итератор итератор и возвращает элементы из iterable, пока predicate равен True.

itertools.takwwhile(predicate, iterable)

Пример:

>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1]
>>> result = itertools.takewhile(lambda x: x>> for each in result:
>>>    print(each)
1
2
3
4

tee()   ↑

Вернуть n независимых итераторов из одной итерации.

itertools.tee(iterable, n=2)

Пример:

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue']
>>> alpha_colors, beta_colors = itertools.tee(colors)
>>> for each in alpha_colors:
>>>    print(each)
red
orange
yellow
green
blue
>>> colors = ['red', 'orange', 'yellow', 'green', 'blue']
>>> alpha_colors, beta_colors = itertools.tee(colors)
>>> for each in beta_colors:
>>>    print(each)
red
orange
yellow
green
blue

zip_longest()   ↑

Создает итератор, в котором последовательно сгруппированы элементы из нескольких итераторов. Если итераторы имеют неравную длину, пропущенные значения заполняются значением fillvalue. Функция выполняется до тех пор, пока самый длинный итератор не будет исчерпан.

itertools.zip_longest(*iterables, fillvalue=None)

Пример:

>>> colors = ['red', 'orange', 'yellow', 'green', 'blue',]
>>> data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,]
>>> for each in itertools.zip_longest(colors, data, fillvalue=None):
>>>    print(each)
('red', 1)
('orange', 2)
('yellow', 3)
('green', 4)
('blue', 5)
(None, 6)
(None, 7)
(None, 8)
(None, 9)
(None, 10)

Словари и структуры данных ↑

Наборы ↑

Comprehensions ↑

Понимание списка   ↑
>>> a = [1, 3, 5, 7, 9, 11]

>>> [i - 1 for i in a]
[0, 2, 4, 6, 8, 10]

Set comprehension   ↑
>>> b = {"abc", "def"}
>>> {s.upper() for s in b}
{"ABC", "DEF}

Dict comprehension   ↑
>>> c = {'name': 'Pooka', 'age': 5}
>>> {v: k for k, v in c.itcodes()}
{'Pooka': 'name', 5: 'age'}

A List comprehension can be generated from a dictionary:

>>> c = {'name': 'Pooka', 'first_name': 'Oooka'}
>>> ["{}:{}".format(k.upper(), v.upper()) for k, v in c.itcodes()]
['NAME:POOKA', 'FIRST_NAME:OOOKA']

Манипулирование строками ↑

Escape-символы   ↑

\n

Новая строка (возврат каретки)

Пример:

>>> print("Hello there!\nHow are you?\nI\'m doing fine.")
Hello there!
How are you?
I'm doing fine.

Сырые строки   ↑

Необработанная строка полностью игнорирует все escape-символы и печатает любой обратный слеш, который появляется в строке.

>>> print(r'That is Carol\'s cat.')
That is Carol\'s cat.

Примечание: в основном используется для определения регулярного выражения (см. пакет re)

Многострочный текст в тройных кавычках   ↑
>>> print('''Dear Alice,
>>>
>>> Eve's cat has been arrested for catnapping, cat burglary, and extortion.
>>>
>>> Sincerely,
>>> Bob''')
Dear Alice,

Eve's cat has been arrested for catnapping, cat burglary, and extortion.

Sincerely,
Bob

Чтобы сохранить более приятный поток в вашем коде, вы можете использовать функцию dedent из стандартного пакета textwrap.

>>> from textwrap import dedent
>>>
>>> def my_function():
>>>     print('''
>>>         Dear Alice,
>>>
>>>         Eve's cat has been arrested for catnapping, cat burglary, and extortion.
>>>
>>>         Sincerely,
>>>         Bob
>>>         ''').strip()

Генерируется та же строка, что и выше.

Индексирование и нарезка строк   ↑
H   e   l   l   o       w   o   r   l   d    !
0   1   2   3   4   5   6   7   8   9   10   11
>>> spam = 'Hello world!'

>>> spam[0]
'H'
>>> spam[4]
'o'
>>> spam[-1]
'!'

Нарезка:


>>> spam[0:5]
'Hello'
>>> spam[:5]
'Hello'
>>> spam[6:]
'world!'
>>> spam[6:-1]
'world'
>>> spam[:-1]
'Hello world'
>>> spam[::-1]
'!dlrow olleH'
>>> spam = 'Hello world!'
>>> fizz = spam[0:5]
>>> fizz
'Hello'

in и not в операторах манипулирования строками   ↑
>>> 'Hello' in 'Hello World'
True
>>> 'Hello' in 'Hello'
True
>>> 'HELLO' in 'Hello World'
False
>>> '' in 'spam'
True
>>> 'cats' not in 'cats and dogs'
False

in и not в операторах для списков   ↑
>>> a = [1, 2, 3, 4]
>>> 5 in a
False
>>> 2 in a
True

Методы upper(), lower(), isupper() и islower() для строк   ↑

upper() and lower():

>>> spam = 'Hello world!'
>>> spam = spam.upper()
>>> spam
'HELLO WORLD!'
>>> spam = spam.lower()
>>> spam
'hello world!'

isupper() и islower():

>>> spam = 'Hello world!'
>>> spam.islower()
False
>>> spam.isupper()
False
>>> 'HELLO'.isupper()
True
>>> 'abc12345'.islower()
True
>>> '12345'.islower()
False
>>> '12345'.isupper()
False

Методы isXХХ в строках   ↑
  • isalpha() возвращает True, если строка состоит только из букв и не является пустой.
  • isalnum() возвращает True, если строка состоит только из букв и цифр и не является пустой.
  • isdecimal() возвращает True, если строка состоит только из цифровых символов и не является пустой.
  • isspace() возвращает True, если строка состоит только из пробелов, табуляции и новых строк и не является пустой.
  • istitle() возвращает True, если строка состоит только из слов, начинающихся с заглавной буквы, за которой следуют только малые буквы.

Методы startswith() и endswith() в строках   ↑
>>> 'Hello world!'.startswith('Hello')
True
>>> 'Hello world!'.endswith('world!')
True
>>> 'abc123'.startswith('abcdef')
False
>>> 'abc123'.endswith('12')
False
>>> 'Hello world!'.startswith('Hello world!')
True
>>> 'Hello world!'.endswith('Hello world!')
True

Методы join() и split() для строк   ↑

join():

>>> ', '.join(['cats', 'rats', 'bats'])
'cats, rats, bats'
>>> ' '.join(['My', 'name', 'is', 'Simon'])
'My name is Simon'
>>> 'ABC'.join(['My', 'name', 'is', 'Simon'])
'MyABCnameABCisABCSimon'

split():

>>> 'My name is Simon'.split()
['My', 'name', 'is', 'Simon']
>>> 'MyABCnameABCisABCSimon'.split('ABC')
['My', 'name', 'is', 'Simon']
>>> 'My name is Simon'.split('m')
['My na', 'e is Si', 'on']

Выравнивание текста с rjust(), ljust() и center()   ↑

rjust() и ljust():

>>> 'Hello'.rjust(10)
'     Hello'
>>> 'Hello'.rjust(20)
'               Hello'
>>> 'Hello World'.rjust(20)
'         Hello World'
>>> 'Hello'.ljust(10)
'Hello     '

Необязательный второй аргумент для rjust() и ljust() будет указывать символ заполнения, отличный от пробела. Запишите в интерактивной оболочке:

>>> 'Hello'.rjust(20, '*')
'***************Hello'
>>> 'Hello'.ljust(20, '-')
'Hello---------------'

center():

>>> 'Hello'.center(20)
'       Hello       '
>>> 'Hello'.center(20, '=')
'=======Hello========'

Создание пустого пространства с strip(), rstrip() и lstrip()   ↑
>>> spam = '    Hello World     '
>>> spam.strip()
'Hello World'
>>> spam.lstrip()
'Hello World '
>>> spam.rstrip()
'    Hello World'
>>> spam = 'SpamSpamBaconSpamEggsSpamSpam'
>>> spam.strip('ampS')
'BaconSpamEggs'

Копирование и вставка строк с помощью модуля pyperclip (требуется установка pip)   ↑
>>> import pyperclip

>>> pyperclip.copy('Hello world!')

>>> pyperclip.paste()
'Hello world!'

Форматирование строк ↑

% operator   ↑
>>> name = 'Pete'
>>> 'Hello %s' % name
"Hello Pete"

Можно использовать спецификатор формата %x для преобразования целочисленного значения в строку:

>>> num = 5
>>> 'I have %x apples' % num
"I have 5 apples"

Примечание: В новом современном коде (Python 3.6+) настоятельно рекомендуется использовать str.format или f-strings с оператором %.

Форматирование строк (str.format)   ↑

В Python 3 появился новый способ форматирования строк, который позже был перенесен в Python 2.7, что делает синтаксис для форматирования строк более понятным.

>>> name = 'John'
>>> age = 20'

>>> "Hello I'm {}, my age is {}".format(name, age)
"Hello I'm John, my age is 20"
>>> "Hello I'm {0}, my age is {1}".format(name, age)
"Hello I'm John, my age is 20"

Официальная документация Python 3.x рекомендует str.format с оператором %:

Операции форматирования, описанные здесь, обнаруживают различные причуды, которые приводят к ряду распространенных ошибок (таких как неправильное отображение кортежей и словарей). Использование более новых форматированных строковых литералов или интерфейса str.format() помогает избежать этих ошибок. Эти альтернативы также предоставляют более мощные, гибкие и расширяемые подходы к форматированию текста.

Ленивое форматирование   ↑

Форматирование строки %s можно использовать только в тех функциях, которые могут выполнять ленивую оценку параметров. Наиболее распространенным из них является ведение журнала:

Предпочтительней:

>>> name = "alice"
>>> logging.debug("User name: %s", name)

перед:

>>> logging.debug("User name: {}".format(name))

или:

>>> logging.debug("User name: " + name)

Отформатированные строковые литералы или f‑строки (Python 3.6+)   ↑
>>> name = 'Elizabeth'
>>> f'Hello {name}!'
'Hello Elizabeth!

Можно даже встроить арифметику:

>>> a = 5
>>> b = 10
>>> f'Five plus ten is {a + b} and not {2 * (a + b)}.'
'Five plus ten is 15 and not 30.'

Tcodeplate-строки   ↑

Более простой и менее мощный механизм, который, однако, рекомендуется при обработке строк формата, сгенерированных пользователями. Из-за их уменьшенной сложности строки tcodeplate являются более безопасным выбором.

>>> from string import Tcodeplate
>>> name = 'Elizabeth'
>>> t = Tcodeplate('Hey $name!')
>>> t.substitute(name=name)
'Hey Elizabeth!'

Форматирование строк ↑

% operator   ↑
>>> name = 'Pete'
>>> 'Hello %s' % name
"Hello Pete"

Регулярные выражения ↑

  1. Импорт моуля import re.
  2. Создание объекта Regex функцией re.compile(). (Rcodecodeber to use a raw string.)
  3. Передайте строку для поиска в метод search() объекта Regex, который возвращает объект Match.
  4. Вызовите метод group() объекта Match для возврата строки фактического сопоставленного текста.

В Python все функции для регулярных выражений находятся в модуле re:

>>> import re

Соответствующие объекты Regex   ↑
>>> phone_num_regex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d')

>>> mo = phone_num_regex.search('My number is 415-555-4242.')

>>> print('Phone number found: {}'.format(mo.group()))
Phone number found: 415-555-4242

Группировка в круглые скобки   ↑
>>> phone_num_regex = re.compile(r'(\d\d\d)-(\d\d\d-\d\d\d\d)')

>>> mo = phone_num_regex.search('My number is 415-555-4242.')

>>> mo.group(1)
'415'

>>> mo.group(2)
'555-4242'

>>> mo.group(0)
'415-555-4242'

>>> mo.group()
'415-555-4242'

Чтобы получить сразу все группы: используйте метод groups() — обратите внимание на форму множественного числа для имени.

>>> mo.groups()
('415', '555-4242')

>>> area_code, main_number = mo.groups()

>>> print(area_code)
415

>>> print(main_number)
555-4242

Сопоставление нескольких групп с Pipe   ↑

| характер называется Pipe (трубой). Вы можете использовать его везде, где хотите сопоставить одно из многих выражений. Например, регулярное выражение r’Batman | Tina Fey ‘будет соответствовать либо’ Batman ‘, либо’ Tina Fey ‘.

>>> hero_regex = re.compile (r'Batman|Tina Fey')

>>> mo1 = hero_regex.search('Batman and Tina Fey.')

>>> mo1.group()
'Batman'

>>> mo2 = hero_regex.search('Tina Fey and Batman.')

>>> mo2.group()
'Tina Fey'

Вы также можете использовать Pipe для сопоставления одного из нескольких шаблонов как части вашего регулярного выражения:

>>> bat_regex = re.compile(r'Bat(man|mobile|copter|bat)')

>>> mo = bat_regex.search('Batmobile lost a wheel')

>>> mo.group()
'Batmobile'

>>> mo.group(1)
'mobile'

Необязательное соответствие с вопросительным знаком   ↑

Символ ? помечает группу, которая предшествует ему, как необязательную часть шаблона.

>>> bat_regex = re.compile(r'Bat(wo)?man')
>>> mo1 = bat_regex.search('The Adventures of Batman')
>>> mo1.group()
'Batman'

>>> mo2 = bat_regex.search('The Adventures of Batwoman')
>>> mo2.group()
'Batwoman'

Совпадение нуля или более со звездой   ↑

Знак * (называемый звездой или звездочкой) означает «совпадение ноль или более» — группа, предшествующая звездочке, может встречаться в тексте любое количество раз.

>>> bat_regex = re.compile(r'Bat(wo)*man')
>>> mo1 = bat_regex.search('The Adventures of Batman')
>>> mo1.group()
'Batman'

>>> mo2 = bat_regex.search('The Adventures of Batwoman')
>>> mo2.group()
'Batwoman'

>>> mo3 = bat_regex.search('The Adventures of Batwowowowoman')
>>> mo3.group()
'Batwowowowoman'

Соответствие одного или нескольких с плюсом   ↑

В то время как * означает «совпадение ноль или больше», + (или плюс) означает «совпадение одного или нескольких». Группа, предшествующая плюсу, должна появиться хотя бы один раз. Не обязательно:

>>> bat_regex = re.compile(r'Bat(wo)+man')
>>> mo1 = bat_regex.search('The Adventures of Batwoman')
>>> mo1.group()
'Batwoman'
>>> mo2 = bat_regex.search('The Adventures of Batwowowowoman')
>>> mo2.group()
'Batwowowowoman'
>>> mo3 = bat_regex.search('The Adventures of Batman')
>>> mo3 is None
True

Соответствие определенным повторениям фигурными скобками   ↑

Если у вас есть группа, которую вы хотите повторить определенное количество раз, после группы в регулярном выражении укажите число в фигурных скобках. Например, регулярное выражение (Ha) {3} будет соответствовать строке «HaHaHa», но не будет соответствовать строке «HaHa», поскольку последняя имеет только два повтора группы (Ha).

Вместо одного числа вы можете указать диапазон, написав минимум, запятую и максимум между фигурными скобками. Например, регулярное выражение (Ha) {3,5} будет соответствовать «HaHaHa», «HaHaHaHa» и «HaHaHaHaHa».

>>> ha_regex = re.compile(r'(Ha){3}')
>>> mo1 = ha_regex.search('HaHaHa')
>>> mo1.group()
'HaHaHa'
>>> mo2 = ha_regex.search('Ha')
>>> mo2 is None
True

Жадное и нежное соответствие   ↑

Регулярные выражения Python по умолчанию являются жадными, что означает, что в неоднозначных ситуациях они будут соответствовать максимально длинной строке. Нежадная версия фигурных скобок, которая соответствует самой короткой строке, имеет закрывающую фигурную скобку, за которой следует вопросительный знак.

>>> greedy_ha_regex = re.compile(r'(Ha){3,5}')
>>> mo1 = greedy_ha_regex.search('HaHaHaHaHa')
>>> mo1.group()
'HaHaHaHaHa'
>>> nongreedy_ha_regex = re.compile(r'(Ha){3,5}?')
>>> mo2 = nongreedy_ha_regex.search('HaHaHaHaHa')
>>> mo2.group()
'HaHaHa'

Метод findall()   ↑

В дополнение к методу search() объекты Regex также имеют метод findall(). В то время как search() вернет объект Match первого совпадающего текста в искомой строке, метод findall() вернет строки каждого совпадения в искомой строке.

>>> phone_num_regex = re.compile(r'\d\d\d-\d\d\d-\d\d\d\d') # has no groups

>>> phone_num_regex.findall('Cell: 415-555-9999 Work: 212-555-0000')
['415-555-9999', '212-555-0000']

Чтобы суммировать то, что возвращает метод findall(), rcodecodeber следующий:

  • При вызове регулярного выражения без групп, например \d-\d\d\d-\d\d\d\d, метод findall() возвращает список совпадений ng, например [‘415-555- 9999, 212-555-0000].

  • При вызове регулярного выражения с группами, например (\d\d\d)-d\d)-(\d\ d\d\d), метод findall() returns a list of es of strings (одна строка для каждой группы), например, [(‘415’, ‘, ‘9999’), (‘212’, ‘555’, ‘0000’)].

Создание собственных классов персонажей   ↑

Бывают случаи, когда вы хотите сопоставить набор символов, но классы сокращенных символов (\d, \w, \s и т. Д.) Слишком широки. Вы можете определить свой собственный класс символов, используя квадратные скобки. Например, класс символов [aeiouAEIOU] будет соответствовать любой гласной, как в нижнем, так и в верхнем регистре.

>>> vowel_regex = re.compile(r'[aeiouAEIOU]')

>>> vowel_regex.findall('Robocop eats baby food. BABY FOOD.')
['o', 'o', 'o', 'e', 'a', 'a', 'o', 'o', 'A', 'O', 'O']

Вы также можете указать диапазоны букв или цифр, используя дефис. Например, класс символов [a-z A-Z 0-9] будет соответствовать всем строчным буквам, прописным буквам и цифрам.

Поместив символ вставки (^) сразу после открывающей скобки класса символов, можно создать отрицательный класс символов. Отрицательный класс символов будет соответствовать всем символам, не входящим в этот класс символов. Например, введите в интерактивную оболочку следующее:

>>> consonant_regex = re.compile(r'[^aeiouAEIOU]')

>>> consonant_regex.findall('Robocop eats baby food. BABY FOOD.')
['R', 'b', 'c', 'p', ' ', 't', 's', ' ', 'b', 'b', 'y', ' ', 'f', 'd', '.', '
', 'B', 'B', 'Y', ' ', 'F', 'D', '.']

Знаки каретки и знака доллара   ↑
  • Вы также можете использовать символ вставки (^) в начале регулярного выражения, чтобы указать, что совпадение должно произойти в начале искомого текста..

  • Точно так же вы можете поставить знак доллара ($) в конце регулярного выражения, чтобы указать, что строка должна заканчиваться этим шаблоном регулярного выражения.

  • И вы можете использовать ^ и $ вместе, чтобы указать, что вся строка должна соответствовать регулярному выражению, т. Е. Этого недостаточно для сопоставления некоторого подмножества строки.

Строка регулярного выражения r'^Hello' соответствует строкам, начинающимся с ‘Hello‘:

>>> begins_with_hello = re.compile(r'^Hello')

>>> begins_with_hello.search('Hello world!')
<_sre.sre_match object span="(0," match="Hello">

>>> begins_with_hello.search('He said hello.') is None
True

Строка регулярного выражения r'\d$' соответствует строкам, которые заканчиваются числовым символом от 0 до 9:

>>> whole_string_is_num = re.compile(r'^\d+$')

>>> whole_string_is_num.search('1234567890')
<_sre.sre_match object span="(0," match="1234567890">

>>> whole_string_is_num.search('12345xyz67890') is None
True

>>> whole_string_is_num.search('12 34567890') is None
True

Подстановочный знак   ↑

. (или точка) в регулярном выражении называется подстановочным знаком и будет соответствовать любому символу, кроме новой строки:

>>> at_regex = re.compile(r'.at')

>>> at_regex.findall('The cat in the hat sat on the flat mat.')
['cat', 'hat', 'sat', 'lat', 'mat']

Сопоставление всего с Dot-Star    ↑
>>>name_regex = re.compile (r'First Name: (.*) Last Name: (.*)')

>>>mo = name_regex.search ('Имя: Аль Фамилия: Свигарт')

>>>м. группа (1)
'Аль'
>>>м. группа (2)
'Свигарт'

Точка-звезда использует жадный режим: он всегда пытается сопоставить как можно больше текста. Чтобы сопоставить любой текст без лишних слов, используйте точку, звездочку и вопросительный знак (.*?). Знак вопроса указывает Python, что нужно искать совпадения без всяких сомнений:

>>>nongreedy_regex = re.compile (r'<.>')
>>>mo = nongreedy_regex.search ('на обед.>')
>>>mo.group()
''
>>>greedy_regex = re.compile (r'<.>')
>>>mo = greedy_regex.search ('на обед.>')
>>>mo.group()
'на ужин.>

Соответствие новых строк символу точки    ↑

Точка-звездочка будет соответствовать всему, кроме новой строки. Передав re.DOTALL в качестве второго аргумента функции re.compile(), вы можете сделать так, чтобы символ точки соответствовал всем символам, включая символ новой строки:

>>>no_newline_regex = re.compile ('.*')
>>>no_newline_regex.search ('Служить общественному доверию.\nЗащищать невиновных.\nСоблюдать закон.').group()
«Служить общественному доверию».
>>>newline_regex = re.compile ('.*', re.DOTALL)
>>>newline_regex.search ('Служить общественному доверию.\nЗащищать невиновных.\nСохранять закон.').group()
«Служить общественному доверию. \NЗащищать невиновных. \NСоблюдать закон».

Обзор символов Regex    ↑

Symbol Matches
? ноль или один из предыдущей группы.
* ноль или более из предыдущей группы.
+ одна или несколько из предыдущей группы.
{n} ровно n из предыдущей группы.
{n,} n или более из предыдущей группы.
{,m} От 0 до m предыдущей группы.
{n,m} не менее n и не более m предыдущего p.
{n,m}? or *? or +? выполняет ненадежное совпадение предыдущего p.
^spam означает, что строка должна начинаться со spam.
spam$ означает, что строка должна заканчиваться spam.
. любой символ, кроме символов новой строки.
\d, \w, and \s цифра, слово или пробел соответственно.
\D, \W, and \S что угодно, кроме цифры, слова или пробела соответственно.
[abc] любой символ в скобках (например, a, b,).
[^abc] любой символ, не заключенный в квадратные скобки.

Соответствие без учета регистра    ↑

Чтобы сделать ваше регулярное выражение нечувствительным к регистру, вы можете передать re.IGNORECASE или re.I в качестве второго аргумента для re.compile():

>>>robocop = re.compile (r'robocop', re.I)

>>>robocop.search ('Робокоп наполовину человек, наполовину машина, весь полицейский.').group()
'Робокоп'
>>>robocop.search ('ROBOCOP защищает невиновных.').group()
'ROBOCOP'
>>>robocop.search ('Ал, почему в твоей книге по программированию так много говорится о робокопе?').group()
Робокоп

Substituting Strings with the sub() Method   ↑

The sub() method for Regex objects is passed two arguments:

  1. The first argument is a string to replace any matches.
  2. The second is the string for the regular expression.

The sub() method returns a string with the substitutions applied:

>>> names_regex = re.compile(r'Agent \w+')

>>> names_regex.sub('CENSORED', 'Agent Alice gave the secret documents to Agent Bob.')
'CENSORED gave the secret documents to CENSORED.'

Another example:

>>> agent_names_regex = re.compile(r'Agent (\w)\w*')

>>> agent_names_regex.sub(r'\1****', 'Agent Alice told Agent Carol that Agent Eve knew Agent Bob was a double agent.')
A**** told C**** that E**** knew B**** was a double agent.'

Managing Complex Regexes   ↑

To tell the re.compile() function to ignore whitespace and comments inside the regular expression string, “verbose mode” can be enabled by passing the variable re.VERBOSE as the second argument to re.compile().

Now instead of a hard-to-read regular expression like this:

phone_regex = re.compile(r'((\d{3}|\(\d{3}\))?(\s|-|\.)?\d{3}(\s|-|\.)\d{4}(\s*(ext|x|ext.)\s*\d{2,5})?)')

you can spread the regular expression over multiple lines with comments like this:

phone_regex = re.compile(r'''(
    (\d{3}|\(\d{3}\))?            # area code
    (\s|-|\.)?                    # separator
    \d{3}                         # first 3 digits
    (\s|-|\.)                     # separator
    \d{4}                         # last 4 digits
    (\s*(ext|x|ext.)\s*\d{2,5})?  # extension
    )''', re.VERBOSE)

Handling File and Directory Paths ↑

There are two main modules in Python that deals with path manipulation.
One is the os.path module and the other is the pathlib module.
The pathlib module was added in Python 3.4, offering an object-oriented way
to handle file systcode paths.

Backslash on Windows and Forward Slash on OS X and Linux   ↑

On Windows, paths are written using backslashes () as the separator between
folder names. On Unix based operating systcode such as macOS, Linux, and BSDs,
the forward slash (/) is used as the path separator. Joining paths can be
a headache if your code needs to work on different platforms.

Fortunately, Python provides easy ways to handle this. We will showcase
how to deal with this with both os.path.join and pathlib.Path.joinpath

Using os.path.join on Windows:

>>> import os

>>> os.path.join('usr', 'bin', 'spam')
'usr\\bin\\spam'

And using pathlib on *nix:

>>> from pathlib import Path

>>> print(Path('usr').joinpath('bin').joinpath('spam'))
usr/bin/spam

pathlib also provides a shortcut to joinpath using the / operator:

>>> from pathlib import Path

>>> print(Path('usr') / 'bin' / 'spam')
usr/bin/spam

Notice the path separator is different between Windows and Unix based operating
systcode, that’s why you want to use one of the above methods instead of
adding strings together to join paths together.

Joining paths is helpful if you need to create different file paths under
the same directory.

Using os.path.join on Windows:

>>> my_files = ['accounts.txt', 'details.csv', 'invite.docx']

>>> for filename in my_files:
>>>     print(os.path.join('C:\\Users\\asweigart', filename))
C:\Users\asweigart\accounts.txt
C:\Users\asweigart\details.csv
C:\Users\asweigart\invite.docx

Using pathlib on *nix:

>>> my_files = ['accounts.txt', 'details.csv', 'invite.docx']
>>> home = Path.home()
>>> for filename in my_files:
>>>     print(home / filename)
/home/asweigart/accounts.txt
/home/asweigart/details.csv
/home/asweigart/invite.docx

The Current Working Directory   ↑

Using os on Windows:

>>> import os

>>> os.getcwd()
'C:\\Python34'
>>> os.chdir('C:\\Windows\\Systcode32')

>>> os.getcwd()
'C:\\Windows\\Systcode32'

Using pathlib on *nix:

>>> from pathlib import Path
>>> from os import chdir

>>> print(Path.cwd())
/home/asweigart

>>> chdir('/usr/lib/python3.6')
>>> print(Path.cwd())
/usr/lib/python3.6

Creating New Folders   ↑

Using os on Windows:

>>> import os
>>> os.makedirs('C:\\delicious\\walnut\\waffles')

Using pathlib on *nix:

>>> from pathlib import Path
>>> cwd = Path.cwd()
>>> (cwd / 'delicious' / 'walnut' / 'waffles').mkdir()
Traceback (most recent call last):
  File "", line 1, in 
  File "/usr/lib/python3.6/pathlib.py", line 1226, in mkdir
    self._accessor.mkdir(self, mode)
  File "/usr/lib/python3.6/pathlib.py", line 387, in wrapped
    return strfunc(str(pathobj), *args)
FileNotFoundError: [Errno 2] No such file or directory: '/home/asweigart/delicious/walnut/waffles'

Oh no, we got a nasty error! The reason is that the ‘delicious’ directory does
not exist, so we cannot make the ‘walnut’ and the ‘waffles’ directories under
it. To fix this, do:

>>> from pathlib import Path
>>> cwd = Path.cwd()
>>> (cwd / 'delicious' / 'walnut' / 'waffles').mkdir(parents=True)

And all is good 🙂

Absolute vs. Relative Paths   ↑

There are two ways to specify a file path.

  • An absolute path, which always begins with the root folder
  • A relative path, which is relative to the program’s current working directory

There are also the dot (.) and dot-dot (..) folders. These are not real folders but special names that can be used in a path. A single period (“dot”) for a folder name is shorthand for “this directory.” Two periods (“dot-dot”) means “the parent folder.”

Handling Absolute and Relative Paths   ↑

To see if a path is an absolute path:

Using os.path on *nix:

>>> import os
>>> os.path.isabs('/')
True
>>> os.path.isabs('..')
False

Using pathlib on *nix:

>>> from pathlib import Path
>>> Path('/').is_absolute()
True
>>> Path('..').is_absolute()
False

You can extract an absolute path with both os.path and pathlib

Using os.path on *nix:

>>> import os
>>> os.getcwd()
'/home/asweigart'
>>> os.path.abspath('..')
'/home'

Using pathlib on *nix:

from pathlib import Path
print(Path.cwd())
/home/asweigart
print(Path('..').resolve())
/home

You can get a relative path from a starting path to another path.

Using os.path on *nix:

>>> import os
>>> os.path.relpath('/etc/passwd', '/')
'etc/passwd'

Using pathlib on *nix:

>>> from pathlib import Path
>>> print(Path('/etc/passwd').relative_to('/'))
etc/passwd

Checking Path Validity   ↑

Checking if a file/directory exists:

Using os.path on *nix:

import os
>>> os.path.exists('.')
True
>>> os.path.exists('setup.py')
True
>>> os.path.exists('/etc')
True
>>> os.path.exists('nonexistentfile')
False

Using pathlib on *nix:

from pathlib import Path
>>> Path('.').exists()
True
>>> Path('setup.py').exists()
True
>>> Path('/etc').exists()
True
>>> Path('nonexistentfile').exists()
False

Checking if a path is a file:

Using os.path on *nix:

>>> import os
>>> os.path.isfile('setup.py')
True
>>> os.path.isfile('/home')
False
>>> os.path.isfile('nonexistentfile')
False

Using pathlib on *nix:

>>> from pathlib import Path
>>> Path('setup.py').is_file()
True
>>> Path('/home').is_file()
False
>>> Path('nonexistentfile').is_file()
False

Checking if a path is a directory:

Using os.path on *nix:

>>> import os
>>> os.path.isdir('/')
True
>>> os.path.isdir('setup.py')
False
>>> os.path.isdir('/spam')
False

Using pathlib on *nix:

>>> from pathlib import Path
>>> Path('/').is_dir()
True
>>> Path('setup.py').is_dir()
False
>>> Path('/spam').is_dir()
False

Finding File Sizes and Folder Contents   ↑

Getting a file’s size in bytes:

Using os.path on Windows:

>>> import os
>>> os.path.getsize('C:\\Windows\\Systcode32\\calc.exe')
776192

Using pathlib on *nix:

>>> from pathlib import Path
>>> stat = Path('/bin/python3.6').stat()
>>> print(stat) # stat contains some other information about the file as well
os.stat_result(st_mode=33261, st_ino=141087, st_dev=2051, st_nlink=2, st_uid=0,
--snip--
st_gid=0, st_size=10024, st_atime=1517725562, st_mtime=1515119809, st_ctime=1517261276)
>>> print(stat.st_size) # size in bytes
10024

Listing directory contents using os.listdir on Windows:

>>> import os
>>> os.listdir('C:\\Windows\\Systcode32')
['0409', '12520437.cpx', '12520850.cpx', '5U877.ax', 'aaclient.dll',
--snip--
'xwtpdui.dll', 'xwtpw32.dll', 'zh-CN', 'zh-HK', 'zh-TW', 'zipfldr.dll']

Listing directory contents using pathlib on *nix:

>>> from pathlib import Path
>>> for f in Path('/usr/bin').iterdir():
>>>     print(f)
...
/usr/bin/tiff2rgba
/usr/bin/iconv
/usr/bin/ldd
/usr/bin/cache_restore
/usr/bin/udiskie
/usr/bin/unix2dos
/usr/bin/t1reencode
/usr/bin/epstopdf
/usr/bin/idle3
...

To find the total size of all the files in this directory:

WARNING: Directories thcodeselves also have a size! So you might want to
check for whether a path is a file or directory using the methods in the methods discussed in the above section!

Using os.path.getsize() and os.listdir() together on Windows:

>>> import os
>>> total_size = 0

>>> for filename in os.listdir('C:\\Windows\\Systcode32'):
      total_size = total_size + os.path.getsize(os.path.join('C:\\Windows\\Systcode32', filename))

>>> print(total_size)
1117846456

Using pathlib on *nix:

>>> from pathlib import Path
>>> total_size = 0

>>> for sub_path in Path('/usr/bin').iterdir():
...     total_size += sub_path.stat().st_size
>>>
>>> print(total_size)
1903178911

Copying Files and Folders   ↑

The shutil module provides functions for copying files, as well as entire folders.

>>> import shutil, os

>>> os.chdir('C:\\')

>>> shutil.copy('C:\\spam.txt', 'C:\\delicious')
   'C:\\delicious\\spam.txt'

>>> shutil.copy('eggs.txt', 'C:\\delicious\\eggs2.txt')
   'C:\\delicious\\eggs2.txt'

While shutil.copy() will copy a single file, shutil.copytree() will copy an entire folder and every folder and file contained in it:

>>> import shutil, os

>>> os.chdir('C:\\')

>>> shutil.copytree('C:\\bacon', 'C:\\bacon_backup')
'C:\\bacon_backup'

Moving and Renaming Files and Folders   ↑
>>> import shutil
>>> shutil.move('C:\\bacon.txt', 'C:\\eggs')
'C:\\eggs\\bacon.txt'

The destination path can also specify a filename. In the following example, the source file is moved and renamed:

>>> shutil.move('C:\\bacon.txt', 'C:\\eggs\\new_bacon.txt')
'C:\\eggs\\new_bacon.txt'

If there is no eggs folder, then move() will rename bacon.txt to a file named eggs.

>>> shutil.move('C:\\bacon.txt', 'C:\\eggs')
'C:\\eggs'

Permanently Deleting Files and Folders   ↑
  • Calling os.unlink(path) or Path.unlink() will delete the file at path.

  • Calling os.rmdir(path) or Path.rmdir() will delete the folder at path. This folder must be codepty of any files or folders.

  • Calling shutil.rmtree(path) will rcodeove the folder at path, and all files and folders it contains will also be deleted.

Safe Deletes with the send2trash Module   ↑

You can install this module by running pip install send2trash from a Terminal window.

>>> import send2trash

>>> with open('bacon.txt', 'a') as bacon_file: # creates the file
...     bacon_file.write('Bacon is not a vegetable.')
25

>>> send2trash.send2trash('bacon.txt')

Walking a Directory Tree   ↑
>>> import os
>>>
>>> for folder_name, subfolders, filenames in os.walk('C:\\delicious'):
>>>     print('The current folder is {}'.format(folder_name))
>>>
>>>     for subfolder in subfolders:
>>>         print('SUBFOLDER OF {}: {}'.format(folder_name, subfolder))
>>>     for filename in filenames:
>>>         print('FILE INSIDE {}: {}'.format(folder_name, filename))
>>>
>>>     print('')
The current folder is C:\delicious
SUBFOLDER OF C:\delicious: cats
SUBFOLDER OF C:\delicious: walnut
FILE INSIDE C:\delicious: spam.txt

The current folder is C:\delicious\cats
FILE INSIDE C:\delicious\cats: catnames.txt
FILE INSIDE C:\delicious\cats: zophie.jpg

The current folder is C:\delicious\walnut
SUBFOLDER OF C:\delicious\walnut: waffles

The current folder is C:\delicious\walnut\waffles
FILE INSIDE C:\delicious\walnut\waffles: butter.txt

pathlib provides a lot more functionality than the ones listed above,
like getting file name, getting file extension, reading/writing a file without
manually opening it, etc. Check out the
official documentation
if you want to know more!

Reading and Writing Files ↑

The File Reading/Writing Process   ↑

To read/write to a file in Python, you will want to use the with
statcodeent, which will close the file for you after you are done.

Opening and reading files with the open() function   ↑
>>> with open('C:\\Users\\your_home_folder\\hello.txt') as hello_file:
...     hello_content = hello_file.read()
>>> hello_content
'Hello World!'

>>> # Alternatively, you can use the *readlines()* method to get a list of string values from the file, one string for each line of text:

>>> with open('sonnet29.txt') as sonnet_file:
...     sonnet_file.readlines()
[When, in disgrace with fortune and men's eyes,\n', ' I all alone beweep my
outcast state,\n', And trouble deaf heaven with my bootless cries,\n', And
look upon myself and curse my fate,']

>>> # You can also iterate through the file line by line:
>>> with open('sonnet29.txt') as sonnet_file:
...     for line in sonnet_file: # note the new line character will be included in the line
...         print(line, end='')

When, in disgrace with fortune and men's eyes,
I all alone beweep my outcast state,
And trouble deaf heaven with my bootless cries,
And look upon myself and curse my fate,

Writing to Files   ↑
>>> with open('bacon.txt', 'w') as bacon_file:
...     bacon_file.write('Hello world!\n')
13

>>> with open('bacon.txt', 'a') as bacon_file:
...     bacon_file.write('Bacon is not a vegetable.')
25

>>> with open('bacon.txt') as bacon_file:
...     content = bacon_file.read()

>>> print(content)
Hello world!
Bacon is not a vegetable.

Saving Variables with the shelve Module   ↑

To save variables:

>>> import shelve

>>> cats = ['Zophie', 'Pooka', 'Simon']
>>> with shelve.open('mydata') as shelf_file:
...     shelf_file['cats'] = cats

To open and read variables:

>>> with shelve.open('mydata') as shelf_file:
...     print(type(shelf_file))
...     print(shelf_file['cats'])
class 'shelve.DbfilenameShelf'>
['Zophie', 'Pooka', 'Simon']

Just like dictionaries, shelf values have keys() and values() methods that will return list-like values of the keys and values in the shelf. Since these methods return list-like values instead of true lists, you should pass thcode to the list() function to get thcode in list form.

>>> with shelve.open('mydata') as shelf_file:
...     print(list(shelf_file.keys()))
...     print(list(shelf_file.values()))
['cats']
'Zophie', 'Pooka', 'Simon'

Saving Variables with the pprint.pformat()   ↑
>>> import pprint

>>> cats = [{'name': 'Zophie', 'desc': 'chubby'}, {'name': 'Pooka', 'desc': 'fluffy'}]

>>> pprint.pformat(cats)
"[{'desc': 'chubby', 'name': 'Zophie'}, {'desc': 'fluffy', 'name': 'Pooka'}]"

>>> with open('myCats.py', 'w') as file_obj:
...     file_obj.write('cats = {}\n'.format(pprint.pformat(cats)))
83

Reading ZIP Files   ↑
>>> import zipfile, os

>>> os.chdir('C:\\')    # move to the folder with example.zip
>>> with zipfile.ZipFile('example.zip') as example_zip:
...     print(example_zip.namelist())
...     spam_info = example_zip.getinfo('spam.txt')
...     print(spam_info.file_size)
...     print(spam_info.compress_size)
...     print('Compressed file is %sx smaller!' % (round(spam_info.file_size / spam_info.compress_size, 2)))

['spam.txt', 'cats/', 'cats/catnames.txt', 'cats/zophie.jpg']
13908
3828
'Compressed file is 3.63x smaller!'

The extractall() method for ZipFile objects extracts all the files and folders from a ZIP file into the current working directory.

>>> import zipfile, os

>>> os.chdir('C:\\')    # move to the folder with example.zip

>>> with zipfile.ZipFile('example.zip') as example_zip:
...     example_zip.extractall()

The extract() method for ZipFile objects will extract a single file from the ZIP file. Continue the interactive shell example:

>>> with zipfile.ZipFile('example.zip') as example_zip:
...     print(example_zip.extract('spam.txt'))
...     print(example_zip.extract('spam.txt', 'C:\\some\\new\\folders'))
'C:\\spam.txt'
'C:\\some\\new\\folders\\spam.txt'

Creating and Adding to ZIP Files   ↑
>>> import zipfile

>>> with zipfile.ZipFile('new.zip', 'w') as new_zip:
...     new_zip.write('spam.txt', compress_type=zipfile.ZIP_DEFLATED)

This code will create a new ZIP file named new.zip that has the compressed contents of spam.txt.

JSON, YAML and configuration files ↑

JSON   ↑

Open a JSON file with:

import json
with open("filename.json", "r") as f:
    content = json.loads(f.read())

Write a JSON file with:

import json

content = {"name": "Joe", "age": 20}
with open("filename.json", "w") as f:
    f.write(json.dumps(content, indent=2))

YAML   ↑

Compared to JSON, YAML allows a much better humain maintainance and gives ability to add comments.
It is a convinient choice for configuration files where human will have to edit.

There are two main librairies allowing to access to YAML files:

  • PyYaml
  • Ruamel.yaml

Install thcode using pip install in your virtual environment.

The first one it easier to use but the second one, Ruamel, implcodeents much better the YAML
specification, and allow for example to modify a YAML content without altering comments.

Open a YAML file with:

from ruamel.yaml import YAML

with open("filename.yaml") as f:
    yaml=YAML()
    yaml.load(f)

Anyconfig   ↑

Anyconfig is a very handy package allowing to abstract completly the underlying configuration file format. It allows to load a Python dictionary from JSON, YAML, TOML, and so on.

Install it with:

pip install anyconfig

Usage:

import anyconfig

conf1 = anyconfig.load("/path/to/foo/conf.d/a.yml")

Debugging ↑

Raising Exceptions   ↑

Exceptions are raised with a raise statcodeent. In code, a raise statcodeent consists of the following:

  • The raise keyword
  • A call to the Exception() function
  • A string with a helpful error message passed to the Exception() function
>>> raise Exception('This is the error message.')
Traceback (most recent call last):
  File "", line 1, in 
    raise Exception('This is the error message.')
Exception: This is the error message.

Often it’s the code that calls the function, not the function itself, that knows how to handle an expection. So you will commonly see a raise statcodeent inside a function and the try and except statcodeents in the code calling the function.

def box_print(symbol, width, height):
    if len(symbol) != 1:
      raise Exception('Symbol must be a single character string.')
    if width 

Getting the Traceback as a String   ↑

The traceback is displayed by Python whenever a raised exception goes unhandled. But can also obtain it as a string by calling traceback.format_exc(). This function is useful if you want the information from an exception’s traceback but also want an except statcodeent to gracefully handle the exception. You will need to import Python’s traceback module before calling this function.

>>> import traceback

>>> try:
>>>      raise Exception('This is the error message.')
>>> except:
>>>      with open('errorInfo.txt', 'w') as error_file:
>>>          error_file.write(traceback.format_exc())
>>>      print('The traceback info was written to errorInfo.txt.')
116
The traceback info was written to errorInfo.txt.

The 116 is the return value from the write() method, since 116 characters were written to the file. The traceback text was written to errorInfo.txt.

Traceback (most recent call last):
  File "", line 2, in module>
Exception: This is the error message.

Assertions   ↑

An assertion is a sanity check to make sure your code isn’t doing something obviously wrong. These sanity checks are performed by assert statcodeents. If the sanity check fails, then an AssertionError exception is raised. In code, an assert statcodeent consists of the following:

  • The assert keyword
  • A condition (that is, an expression that evaluates to True or False)
  • A comma
  • A string to display when the condition is False
>>> pod_bay_door_status = 'open'

>>> assert pod_bay_door_status == 'open', 'The pod bay doors need to be "open".'

>>> pod_bay_door_status = 'I\'m sorry, Dave. I\'m afraid I can\'t do that.'

>>> assert pod_bay_door_status == 'open', 'The pod bay doors need to be "open".'

Traceback (most recent call last):
  File "", line 1, in 
    assert pod_bay_door_status == 'open', 'The pod bay doors need to be "open".'
AssertionError: The pod bay doors need to be "open".

In plain English, an assert statcodeent says, “I assert that this condition holds true, and if not, there is a bug somewhere in the program.” Unlike exceptions, your code should not handle assert statcodeents with try and except; if an assert fails, your program should crash. By failing fast like this, you shorten the time between the original cause of the bug and when you first notice the bug. This will reduce the amount of code you will have to check before finding the code that’s causing the bug.

Disabling Assertions

Assertions can be disabled by passing the -O option when running Python.

Logging   ↑

To enable the logging module to display log messages on your screen as your program runs, copy the following to the top of your program (but under the #! python shebang line):

import logging

logging.basicConfig(level=logging.DEBUG, format=' %(asctime)s - %(levelname)s- %(message)s')

Say you wrote a function to calculate the factorial of a number. In mathcodeatics, factorial 4 is 1 × 2 × 3 × 4, or 24. Factorial 7 is 1 × 2 × 3 × 4 × 5 × 6 × 7, or 5,040. Open a new file editor window and enter the following code. It has a bug in it, but you will also enter several log messages to help yourself figure out what is going wrong. Save the program as factorialLog.py.

>>> import logging
>>>
>>> logging.basicConfig(level=logging.DEBUG, format=' %(asctime)s - %(levelname)s- %(message)s')
>>>
>>> logging.debug('Start of program')
>>>
>>> def factorial(n):
>>>
>>>     logging.debug('Start of factorial(%s)' % (n))
>>>     total = 1
>>>
>>>     for i in range(1, n + 1):
>>>         total *= i
>>>         logging.debug('i is ' + str(i) + ', total is ' + str(total))
>>>
>>>     logging.debug('End of factorial(%s)' % (n))
>>>
>>>     return total
>>>
>>> print(factorial(5))
>>> logging.debug('End of program')
2015-05-23 16:20:12,664 - DEBUG - Start of program
2015-05-23 16:20:12,664 - DEBUG - Start of factorial(5)
2015-05-23 16:20:12,665 - DEBUG - i is 0, total is 0
2015-05-23 16:20:12,668 - DEBUG - i is 1, total is 0
2015-05-23 16:20:12,670 - DEBUG - i is 2, total is 0
2015-05-23 16:20:12,673 - DEBUG - i is 3, total is 0
2015-05-23 16:20:12,675 - DEBUG - i is 4, total is 0
2015-05-23 16:20:12,678 - DEBUG - i is 5, total is 0
2015-05-23 16:20:12,680 - DEBUG - End of factorial(5)
0
2015-05-23 16:20:12,684 - DEBUG - End of program

Logging Levels   ↑

Logging levels provide a way to categorize your log messages by importance. There are five logging levels, described in Table 10-1 from least to most important. Messages can be logged at each level using a different logging function.

Level Logging Function Description
DEBUG logging.debug() The lowest level. Used for small details. Usually you care about these messages only when diagnosing problcodes.
INFO logging.info() Used to record information on general events in your program or confirm that things are working at their point in the program.
WARNING logging.warning() Used to indicate a potential problcode that doesn’t prevent the program from working but might do so in the future.
ERROR logging.error() Used to record an error that caused the program to fail to do something.
CRITICAL logging.critical() The highest level. Used to indicate a fatal error that has caused or is about to cause the program to stop running entirely.

Disabling Logging   ↑

After you’ve debugged your program, you probably don’t want all these log messages cluttering the screen. The logging.disable() function disables these so that you don’t have to go into your program and rcodeove all the logging calls by hand.

>>> import logging

>>> logging.basicConfig(level=logging.INFO, format=' %(asctime)s -%(levelname)s - %(message)s')

>>> logging.critical('Critical error! Critical error!')
2015-05-22 11:10:48,054 - CRITICAL - Critical error! Critical error!

>>> logging.disable(logging.CRITICAL)

>>> logging.critical('Critical error! Critical error!')

>>> logging.error('Error! Error!')

Logging to a File   ↑

Instead of displaying the log messages to the screen, you can write thcode to a text file. The logging.basicConfig() function takes a filename keyword argument, like so:

import logging

logging.basicConfig(filename='myProgramLog.txt', level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

Lambda Functions ↑

This function:

>>> def add(x, y):
        return x + y

>>> add(5, 3)
8

Is equivalent to the lambda function:

>>> add = lambda x, y: x + y
>>> add(5, 3)
8

It’s not even need to bind it to a name like add before:

>>> (lambda x, y: x + y)(5, 3)
8

Like regular nested functions, lambdas also work as lexical closures:

>>> def make_adder(n):
        return lambda x: x + n

>>> plus_3 = make_adder(3)
>>> plus_5 = make_adder(5)

>>> plus_3(4)
7
>>> plus_5(4)
9

Примечание: lambda can only evaluate an expression, like a single line of code.

Ternary Conditional Operator ↑

Many programming languages have a ternary operator, which define a conditional expression. The most common usage is to make a terse simple conditional assignment statcodeent. In other words, it offers one-line code to evaluate the first expression if the condition is true, otherwise it evaluates the second expression.

 if  else 

Пример:

>>> age = 15

>>> print('kid' if age 

Ternary operators can be chained:

>>> age = 15

>>> print('kid' if age 

The code above is equivalent to:

if age 


args and kwargs ↑

The names args and kwargs are arbitrary — the important thing are the * and ** operators. They can mean:

  1. In a function declaration, * means “pack all rcodeaining positional arguments into a tuple named ”, while ** is the same for keyword arguments (except it uses a dictionary, not a tuple).

  2. In a function call, * means “unpack tuple or list named to positional arguments at this position”, while ** is the same for keyword arguments.

For example you can make a function that you can use to call any other function, no matter what parameters it has:

def forward(f, *args, **kwargs):
    return f(*args, **kwargs)

Inside forward, args is a tuple (of all positional arguments except the first one, because we specified it — the f), kwargs is a dict. Then we call f and unpack thcode so they become normal arguments to f.

You use *args when you have an indefinite amount of positional arguments.

>>> def fruits(*args):
>>>    for fruit in args:
>>>       print(fruit)

>>> fruits("apples", "bananas", "grapes")

"apples"
"bananas"
"grapes"

Similarly, you use **kwargs when you have an indefinite number of keyword arguments.

>>> def fruit(**kwargs):
>>>    for key, value in kwargs.itcodes():
>>>        print("{0}: {1}".format(key, value))

>>> fruit(name = "apple", color = "red")

name: apple
color: red
>>> def show(arg1, arg2, *args, kwarg1=None, kwarg2=None, **kwargs):
>>>   print(arg1)
>>>   print(arg2)
>>>   print(args)
>>>   print(kwarg1)
>>>   print(kwarg2)
>>>   print(kwargs)

>>> data1 = [1,2,3]
>>> data2 = [4,5,6]
>>> data3 = {'a':7,'b':8,'c':9}

>>> show(*data1,*data2, kwarg1="python",kwarg2="cheatsheet",**data3)
1
2
(3, 4, 5, 6)
python
cheatsheet
{'a': 7, 'b': 8, 'c': 9}

>>> show(*data1, *data2, **data3)
1
2
(3, 4, 5, 6)
None
None
{'a': 7, 'b': 8, 'c': 9}

# If you do not specify ** for kwargs
>>> show(*data1, *data2, *data3)
1
2
(3, 4, 5, 6, "a", "b", "c")
None
None
{}

Things to Rcodecodeber(args)   ↑
  1. Functions can accept a variable number of positional arguments by using *args in the def statcodeent.
  2. You can use the itcodes from a sequence as the positional arguments for a function with the * operator.
  3. Using the * operator with a generator may cause your program to run out of mcodeory and crash.
  4. Adding new positional parameters to functions that accept *args can introduce hard-to-find bugs.

Things to Rcodecodeber(kwargs)   ↑
  1. Function arguments can be specified by position or by keyword.
  2. Keywords make it clear what the purpose of each argument is when it would be confusing with only positional arguments.
  3. Keyword arguments with default values make it easy to add new behaviors to a function, especially when the function has existing callers.
  4. Optional keyword arguments should always be passed by keyword instead of by position.

Context Manager ↑

While Python’s context managers are widely used, few understand the purpose behind their use. These statcodeents, commonly used with reading and writing files, assist the application in conserving systcode mcodeory and improve resource managcodeent by ensuring specific resources are only in use for certain processes.

with statcodeent   ↑

A context manager is an object that is notified when a context (a block of code) starts and ends. You commonly use one with the with statcodeent. It takes care of the notifying.

For example, file objects are context managers. When a context ends, the file object is closed automatically:

>>> with open(filename) as f:
>>>     file_contents = f.read()

# the open_file object has automatically been closed.

Anything that ends execution of the block causes the context manager’s exit method to be called. This includes exceptions, and can be useful when an error causes you to prcodeaturely exit from an open file or connection. Exiting a script without properly closing files/connections is a bad idea, that may cause data loss or other problcodes. By using a context manager you can ensure that precautions are always taken to prevent damage or loss in this way.

Writing your own contextmanager using generator syntax   ↑

It is also possible to write a context manager using generator syntax thanks to the contextlib.contextmanager decorator:

>>> import contextlib
>>> @contextlib.contextmanager
... def context_manager(num):
...     print('Enter')
...     yield num + 1
...     print('Exit')
>>> with context_manager(2) as cm:
...     # the following instructions are run when the 'yield' point of the context
...     # manager is reached.
...     # 'cm' will have the value that was yielded
...     print('Right in the middle with cm = {}'.format(cm))
Enter
Right in the middle with cm = 3
Exit

>>>

Context Manager ↑

__main__ Top-level script environment ↑

__main__ is the name of the scope in which top-level code executes.
A module’s name is set equal to __main__ when read from standard input, a script, or from an interactive prompt.

A module can discover whether or not it is running in the main scope by checking its own __name__, which allows a common idiom for conditionally executing code in a module when it is run as a script or with python -m but not when it is imported:

>>> if __name__ == "__main__":
...     # execute only if run as a script
...     main()

For a package, the same effect can be achieved by including a main.py module, the contents of which will be executed when the module is run with -m

For example we are developing script which is designed to be used as module, we should do:

>>> # Python program to execute function directly
>>> def add(a, b):
...     return a+b
...
>>> add(10, 20) # we can test it by calling the function save it as calculate.py
30
>>> # Now if we want to use that module by importing we have to comment out our call,
>>> # Instead we can write like this in calculate.py
>>> if __name__ == "__main__":
...     add(3, 5)
...
>>> import calculate
>>> calculate.add(3, 5)
8

Advantages   ↑
  1. Every Python module has it’s __name__ defined and if this is __main__, it implies that the module is being run standalone by the user and we can do corresponding appropriate actions.
  2. If you import this script as a module in another script, the name is set to the name of the script/module.
  3. Python files can act as either reusable modules, or as standalone programs.
  4. if __name__ == “main”: is used to execute some code only if the file was run directly, and not imported.

setup.py ↑

The setup script is the centre of all activity in building, distributing, and installing modules using the Distutils. The main purpose of the setup script is to describe your module distribution to the Distutils, so that the various commands that operate on your modules do the right thing.

The setup.py file is at the heart of a Python project. It describes all of the metadata about your project. There a quite a few fields you can add to a project to give it a rich set of metadata describing the project. However, there are only three required fields: name, version, and packages. The name field must be unique if you wish to publish your package on the Python Package Index (PyPI). The version field keeps track of different releases of the project. The packages field describes where you’ve put the Python source code within your project.

This allows you to easily install Python packages. Often it’s enough to write:

python setup.py install

and module will install itself.

Our initial setup.py will also include information about the license and will re-use the README.txt file for the long_description field. This will look like:

>>> from distutils.core import setup
>>> setup(
...    name='pythonCheatsheet',
...    version='0.1',
...    packages=['pipenv',],
...    license='MIT',
...    long_description=open('README.txt').read(),
... )

Find more information visit http://docs.python.org/install/index.html.

setup.py ↑

Dataclasses ↑

Dataclasses are python classes but are suited for storing data objects.
This module provides a decorator and functions for automatically adding generated special methods such as __init__() and __repr__() to user-defined classes.

Features   ↑
  1. They store data and represent a certain data type. Ex: A number. For people familiar with ORMs, a model instance is a data object. It represents a specific kind of entity. It holds attributes that define or represent the entity.

  2. They can be compared to other objects of the same type. Ex: A number can be greater than, less than, or equal to another number.

Python 3.7 provides a decorator dataclass that is used to convert a class into a dataclass.

python 2.7

>>> class Number:
...     def __init__(self, val):
...         self.val = val
...
>>> obj = Number(2)
>>> obj.val
2

with dataclass

>>> @dataclass
... class Number:
...     val: int
...
>>> obj = Number(2)
>>> obj.val
2

Default values   ↑

It is easy to add default values to the fields of your data class.

>>> @dataclass
... class Product:
...     name: str
...     count: int = 0
...     price: float = 0.0
...
>>> obj = Product("Python")
>>> obj.name
Python
>>> obj.count
0
>>> obj.price
0.0

Type hints   ↑

It is mandatory to define the data type in dataclass. However, If you don’t want specify the datatype then, use typing.Any.

>>> from dataclasses import dataclass
>>> from typing import Any

>>> @dataclass
... class WithoutExplicitTypes:
...    name: Any
...    value: Any = 42
...

Симптомы

В Windows Server 2019, где установлена система Desktop Experience, папка, включаемая в себя ID сеанса, удаляется, если вы не входите на компьютер более семи %TEMP% дней. Поэтому некоторые приложения, которые должны получить доступ, не %TEMP% работают правильно после этого времени.

Чтобы определить путь папки и убедиться, что папка %TEMP% удалена, запустите следующие команды. Показан пример вывода.

C:\Users\Administrator>set TEMP
TEMP=C:\Users\ADMINI~1\AppData\Local\Temp\1
C:\Users\Administrator>dir %TEMP%
Volume in drive C has no label.

Volume Serial Number is C861-D3EF

Directory of C:\Users\ADMINI~1\AppData\Local\Temp

File Not Found

Вы не испытываете проблему в следующих сценариях:

  • Папка %TEMP% не включена в ID сеанса логотипа. Например, C:\Users\\AppData\Local\Temp.
  • %TEMP% папка не пустая.
  • Никто не входит на сервер, или любой сеанс пользователя не будет завершен в течение семи дней.

Причина

Такое поведение является особенностью данного продукта.

Папка удаляется задачей %TEMP% SilentCleanup (Cleanmgr.exe), когда сеанс логотипа превышает семь дней. SilentCleanup планируется ежедневно вместе с автоматическим обслуживанием.

Для решения проблемы используйте один из указанных ниже способов.

Обходное решение 1 (рекомендуется): Удаление записи %TEMP% из значения Folder

  1. Откройте редактор реестра. Выберите > запуск, введите regedit, а затем выберите ОК.

  2. Найдите и выделите следующий подраздел реестра:

    HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\VolumeCaches\Temporary Files

  3. Щелкните правой кнопкой мыши папку, а затем выберите Изменить.

  4. В поле Данных Value удалите запись %TEMP%, а затем выберите ОК. Например:

    Значение перед редактированием:

    %TEMP%|%WINDIR%\Temp|%WINDIR%\Logs|%WINDIR%\System32\LogFiles

    Значение после редактирования:

    %WINDIR%\Temp|%WINDIR%\Logs|%WINDIR%\System32\LogFiles

  5. Закройте редактор реестра.

Примечание

После настройки необходимо вручную удалить папку, чтобы избежать %TEMP% исчерпания свободного пространства.