Главная страница
Навигация по странице:

  • Функция или операция Описание

  • Методы Описание

  • 1. Конструкция if

  • 2. Конструкция if – else

  • 3. Конструкция if – elif – else

  • Операторы break и continue При работе с циклами используются операторы break и continue .Оператор break

  • Лаба1. Лабораторная работа 1 введение в язые программирования python цель и задачи работы


    Скачать 0.6 Mb.
    НазваниеЛабораторная работа 1 введение в язые программирования python цель и задачи работы
    АнкорЛаба1
    Дата12.11.2019
    Размер0.6 Mb.
    Формат файлаpdf
    Имя файлаlab-1-1.PythonIntodution.pdf
    ТипЛабораторная работа
    #94834
    страница2 из 3
    1   2   3
    3. Списки (list)
    Список в Python — это набор разнородных элементов. Элементами списка могут быть числа, строки и другие структуры (в том числе списки и кортежи).
    Самый простой способ сформировать список — перечисление его элементов в квадратных скобках через запятую, например:
    lst=[12,'b',34.6,'derevo']
    В дальнейшем при указании списков всегда будет использоваться сочетание lst (от слова «list», т.е. «список»).
    С использованием допустимой в Python цепочки присваиваний можно элементам списка сразу сопоставить какие-нибудь переменные:
    lst=[x,s1,y,s2]=[12,'b',34.6,'derevo']
    В этом случае элемент списка и соответствующая переменная будут иметь совершенно одинаковые значения, т.е. значение lst[0]
    будет равно значению x
    , а lst[3].
    соответственно,
    s2
    Однако эти переменные могут изменяться независимо от элементов списка.
    Присвоение нового значения переменной s1
    никак не влияет на элемент lst[1]
    . В отличие от кортежа, можно изменять значения элементов списка, добавлять в него элементы и удалять их.
    Список может быть пустым (для его определения нужно написать lst=[]
    ), а может содержать только один элемент (например,
    lst=['domik']
    ).
    Списки являются очень полезными структурами данных в Python, и с использованием списков, операций с ними и их методов можно эффективно решать разнообразные задачи.
    Чтобы использовать списки, их нужно создать. Создать список можно несколькими способами. Например, можно обработать любой итерируемый объект (например, строку) встроенной функцией list:

    13
    list('список')
    Список можно создать и при помощи литерала:
    s = []
    # Пустой список l = ['s', 'p', ['isok'], 2]
    print(s)
    print(l)
    # Результат
    # []
    # ['s', 'p', ['isok'], 2]
    Как видно из примера, список может содержать любое количество любых объектов (в том числе и вложенные списки), или не содержать ничего.
    И еще один способ создать список - это генераторы списков. Генератор списков - способ построить новый список, применяя выражение к каждому элементу последовательности. Генераторы списков очень похожи на цикл for.
    c = [c * 3 for c in 'list']
    print(c)
    # Результат
    #['lll', 'iii', 'sss', 'ttt']
    Возможна и более сложная конструкция генератора списков:
    c = [c * 3 for c in 'list' if c != 'i']
    print(c)
    # Результат
    #['lll', 'sss', 'ttt']
    c = [c + d for c in 'list' if c != 'i' for d in 'spam' if d != 'a']
    print(c)
    # Результат
    #['ls', 'lp', 'lm', 'ss', 'sp', 'sm', 'ts', 'tp', 'tm']
    Но в сложных случаях лучше пользоваться обычным циклом for для генерации списков.
    Основные операции со списками:
    Функция или операция
    Описание
    len(lst)
    Определяется количество элементов списка lst lst1 + lst2
    Объединение списков. Получается новый список, в котором после элементов списка lst1 находятся элементы списка lst2.
    Пример:

    14
    lst1=[1,2,3]
    lst2=['raz','dva']
    lst3=lst1+lst2
    lst3 → [1, 2, 3, 'raz', 'dva']
    lst * n (или n * lst)
    n-кратное повторение списка lst
    Пример:
    lst2=['raz','dva']
    lst2*3 → ['raz', 'dva', 'raz','dva', 'raz', 'dva']
    lst[i]
    Выбор из lst элемента с номером i,
    нумерация начинается с 0 (первый элемент имеет номер 0) Если i<0, отсчёт идёт с конца.
    Пример:
    lst3= [1, 2, 3, 'raz', 'dva']
    lst3[2] → 3
    lst3[2]→ 'raz'
    lst[i]
    Выбор из lst элемента с номером i,
    нумерация начинается с 0 (первый элемент имеет номер 0) Если i<0, отсчёт идёт с конца.
    Пример:
    lst3= [1, 2, 3, 'raz', 'dva']
    lst3[2] → 3
    lst3[2]→ 'raz'
    lst[i:j:k]
    Срез — список, содержащий элементы списка lst с номерами от i до j с шагом k (элемент с номером i входит в итоговый список, а элемент с номером j уже не входит). Если k не указан (использован вариант lst[i:j]), то символы идут подряд (равносильно lst[i:j:1]).
    Пример:
    lst3= [1, 2, 3, 'raz', 'dva']
    lst3[1:4] → [2, 3, 'raz']
    min(lst)
    Определяется элемент с наименьшим значением в соответствии с алфавитным порядком.
    Пример:
    lst3= [1, 2, 3, 'raz', 'dva']
    min(lst3) → 1
    max(lst)
    значением в соответствии с алфавитным порядком.
    Пример:
    lst3= [1, 2, 3, 'raz', 'dva']
    max(lst3) → 'raz'
    lst[i]=x
    Замена элемента списка с номером i на значение x. Если x является списком, то на место элемента списка будет вставлен список.
    Примеры:
    lst3=[1, 2, 3, 'raz', 'dva']
    lst3[2]='tri'
    lst3 → [1, 2, 'tri', 'raz',

    15
    'dva']
    lst3[2]=[7,8]
    lst3 → [1, 2, [7, 8], 'raz','dva']
    del lst[i]
    Удаление из списка элемента с номером i.
    Пример:
    lst3=[1, 2, [7, 8], 'raz', 'dva']
    del lst3[2]
    lst3 → [1, 2, 'raz', 'dva']
    lst[i:j]=x
    Замена среза списка lst на элемент или список x (несколько элементов заменяются на x).
    Примеры:
    lst3=[1, 2, 3, 'raz', 'dva']
    lst3[2:4]='tri'
    lst3 → [1, 2, 't', 'r', 'i',
    'dva']
    lst3[2:4]='a'
    lst3 → [1, 2, 'a', 'i', 'dva']
    Обратите внимание, что строка воспринимается как список!
    del lst[i:j]
    Удаление элементов, входящих в указанный срез («вырезание среза»).
    Пример:
    lst3=[1, 2, 'a', 'i', 'dva']
    del lst3[2:4]
    lst3 → [1, 2, 'dva']
    Важно понимать, что при определении значений минимального и максимального элементов списка используется «словарный» порядок —
    сначала идут числа по возрастанию, затем строки, начинающиеся на цифры в порядке их возрастания, затем строки, начинающиеся на прописные буквы в алфавитном порядке, а затем строки, начинающиеся на строчные буквы также в алфавитном порядке.
    Для списков в Python, как и для строк, определены «внутренние»
    методы.
    Основные методы списков:
    Методы
    Описание
    lst.append(x)
    Добавление элемента x в конец списка lst. x не может быть списком.
    Создания нового списка не происходит.
    Пример:
    lst=['raz','dva','tri',1,2]
    lst.append(3)
    lst → ['raz','dva','tri',1,2,3]
    lst.extend(t)
    Добавление кортежа или списка t в конец списка lst (равносильно объединению списков, но создания нового списка не происходит).

    16
    Пример:
    lst1=[1,2,3]
    lst2=['raz','dva']
    lst1.extend(lst2)
    lst1 → [1,2,3,'raz','dva']
    lst.count(x)
    Определение количества элементов,
    равных x в списке lst.
    Пример:
    lst=[1, 2, 3, 'raz', 'dva',
    'raz', 'dva']
    lst.count('raz') → 2
    lst.index(x)
    Определение первой слева позиции элемента x в списке lst. Если такого элемента нет, возникает сообщение об ошибке.
    Пример:
    lst=[1, 2, 3, 'raz', 'dva',
    'raz', 'dva']
    lst.index('dva') → 4
    lst.remove(x)
    Удаление элемента x в списке lst в первой слева позиции. Если такого элемента нет, возникает сообщение об ошибке.
    Пример:
    lst=[1, 2, 3, 'raz', 'dva',
    'raz', 'dva']
    lst.remove('dva')
    lst → [1,2,3,'raz','raz','dva']
    lst.pop(i)
    Удаление элемента с номером i из списка lst. При этом выдаётся значение этого элемента («извлечение» элемента из списка). Если номер не указан, удаляется последний элемент.
    Примеры:
    lst=[1,2,3,'raz','raz','dva']
    lst.pop(3) → 'raz'
    lst → [1,2,3,'raz','dva']
    lst.pop() → 'dva'
    lst → [1,2,3,'raz']
    lst.insert(i,x)
    Вставка элемента или списка x в позицию i списка lst. Если i>=0, вставка идёт в начало списка. Если i>len(lst), вставка идёт в конец списка. Новый список не создаётся.
    Пример:
    lst= [1,2,3,'raz']
    lst.insert(3,'tri')
    lst → [1,2,3,'tri','raz']
    lst.sort()
    Сортировка списка по возрастанию (в алфавитном порядке). Новый список не создаётся.
    Пример:
    lst=[1,2,3,'tri','raz']
    lst.sort()

    17
    lst → [1,2,3,'raz','tri']
    lst.reverse()
    Замена порядка следования элементов на обратный. Новый список не создаётся.
    Пример:
    lst=[1,2,3,'raz','tri']
    lst.reverse()
    lst → ['tri','raz',3,2,1]
    4. Множества
    Математическое образование разработчика языка Python наложило свой отпечаток на типы данных (классы), которые присутствуют в языке.
    Рассмотрим множество (set) в Python – неупорядоченную коллекцию неизменяемых, уникальных элементов.
    Создадим множество:
    v = {'A', 'C', 4, '5', 'B'}
    print(v)
    {'C', 'B', '5', 4, 'A'}
    Заметим, что полученное множество отобразилось не в том порядке, в каком мы его создавали, т.к. множество – это неупорядоченная коллекция.
    Представим множество схематично:
    Множества в Python обладают интересными свойствами:
    v = {'A', 'C', 4, '5', 'B', 4}
    print(v)
    {'C', 'B', '5', 4, 'A'}
    Видим, что повторяющиеся элементы, которые мы добавили при создании множества, были удалены (элементы множества уникальны).
    Рассмотрим способы создания множеств:
    set([3,6,3,5])
    Множества можно создавать на основе списков. Обратите внимание,
    что в момент создания множества из списка будут удалены повторяющиеся элементы. Это отличный способ очистить список от повторов:

    18
    list(set([3,6,3,5]))
    [3, 5, 6]
    Функция range() позволяет создавать множества из диапазона:
    set(range(10))
    {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    Рассмотрим некоторые операции над множествами:
    s1=set(range(5))
    s2=set(range(2))
    s1
    {0, 1, 2, 3, 4}
    s2
    {0, 1}
    s1.add('5') # добавить элемент s1
    {0, 1, 2, 3, 4, '5'}
    У множеств в Python много общего с множествами из математики s1.intersection(s2) # пересечение множеств через вызов метода (s1 & s2)
    {0, 1}
    s1.union(s2) # объединение множеств через вызов метода (s1 & s2)
    {0, 1, 2, 3, 4, '5'}
    5. Словари
    Следующий тип данных (класс) – словарь (dict). Словарь в Python –
    неупорядоченная изменяемая коллекция или, проще говоря, «список» с произвольными ключами, неизменяемого типа.
    Пример создания словаря, который каждому слову на английском языка будет ставить в соответствие слово на испанском языке.

    19
    eng2sp = dict() # создаем пустой словарь
    >>> eng2sp
    {}
    >>> eng2sp['one']='uno' # добавляем 'uno' для элемента с индексом 'one'
    >>> eng2sp
    {'one': 'uno'}
    >>> eng2sp['one']
    'uno'
    >>> eng2sp['two']='dos'
    >>> eng2sp['three']='tres'
    >>> eng2sp
    {'three': 'tres', 'one': 'uno', 'two': 'dos'}
    В качестве индексов словаря используются неизменяемые строки,
    могли бы воспользоваться кортежами, т.к. они тоже неизменяемые:
    e={}
    >>> e
    {}
    >>> e[(4,'6')]='1'
    >>> e
    {(4, '6'): '1'}
    Результирующий словарь eng2sp отобразился в «перемешанном» виде,
    т.к., по аналогии с множествами, словари являются неупорядоченной коллекцией. Фактически, словарь – это отображение двух множеств:
    множества ключей и множества значений.
    К словарям применим оператор in
    :
    eng2sp
    {'three': 'tres', 'one': 'uno', 'two': 'dos'}
    'one' in eng2sp # поиск по множеству КЛЮЧЕЙ
    True
    Часто словари используются,
    если требуется найти частоту встречаемости элементов в последовательности (списке, строке, кортеже).
    Функция, которая возвращает словарь, содержащий статистику встречаемости элементов в последовательности:

    20
    def histogram(s):
    d = dict()
    for c in s:
    if c not in d:
    d[c]=1
    else:
    d[c]=d[c]+1 # или d[c] += 1
    return d
    Результат вызова функции histogram() для списка, строки, кортежа соответственно:
    histogram([2,5,6,5,4,4,4,4,3,2,2,2,2])
    {2: 5, 3: 1, 4: 4, 5: 2, 6: 1}
    >>> histogram("ywte3475eryt3478e477477474")
    {'4': 6, '8': 1, 'e': 3, '3': 2, '7': 7, '5': 1, 'r': 1, 'y': 2, 'w': 1, 't':
    2}
    >>> histogram((5,5,5,6,5,'r',5))
    {5: 5, 6: 1, 'r': 1}
    3.
    ИНСТРУКЦИИ ВЫБОРА. ЦИКЛЫ
    Условный оператор ветвления if
    Ход выполнения программы может быть линейным, то есть таким,
    когда выражения выполняются друг за другом, начиная с первого и заканчивая последним. Ни одна строка кода программы не пропускается.
    Однако чаще всего в программах бывает не так. При выполнении кода,
    в зависимости от тех или иных условий, некоторые его участки могут быть опущены, в то время как другие – выполнены. Иными словами, в программе может присутствовать ветвление, которое реализуется условным оператором
    – особой конструкцией языка программирования.
    Оператор ветвления if позволяет выполнить определенный набор инструкций в зависимости от некоторого условия. Возможны следующие варианты использования.
    1. Конструкция if
    Синтаксис оператора if выглядит так:
    if выражение:
    инструкция_1
    инструкция_2
    инструкция_n
    Конструкция if логическое_выражение называется заголовком
    условного оператора. Выражения внутри фигурных скобок – телом
    условного оператора. Тело может содержать как множество выражений, так

    21
    и всего одно или даже быть пустым.
    Пример использования условного оператора в языке программирования
    Python:
    if n < 100:
    b = n + a
    В
    Python вместо фигурных скобок используется двоеточие.
    Обособление вложенного кода, т. е. тела оператора, достигается за счет отступов. В программировании принято делать отступ равным четырем пробелам. Однако также можно использовать клавишу табуляции (Tab) на клавиатуре. Большинство сред программирования автоматически делают отступ, как только вы поставите двоеточие и перейдете на новую строку.
    Однако при работе в интерактивном режиме надо делать отступы вручную.
    После оператора if записывается выражение. Если это выражение истинно,
    то выполняются инструкции,
    определяемые данным оператором. Выражение является истинным, если его результатом является число не равное нулю, непустой объект, либо логическое True. После выражения нужно поставить двоеточие “:”.
    Примеры:
    if 1:
    print("hello 1")
    Напечатает: hello 1
    a = 3
    if a == 3:
    print("hello 2")
    2. Конструкция if – else
    Бывают случаи, когда необходимо предусмотреть альтернативный вариант выполнения программы. Т.е. при истинном условии нужно выполнить один набор инструкций, при ложном – другой. Для этого используется конструкция if – else.
    if выражение:
    инструкция_1
    инструкция_2
    инструкция_n else:
    инструкция_a инструкция_b инструкция_x

    22
    Примеры.
    a = 3
    if a > 2:
    print("H")
    else:
    print("L")
    Условие такого вида можно записать в строчку, в таком случае оно будет представлять собой тернарное выражение.
    a = 17
    b = True if a > 10 else False print(b)
    В результате выполнения такого кода будет напечатано: True
    3. Конструкция if – elif – else
    Для реализации выбора из нескольких альтернатив можно использовать конструкцию if – elif – else.
    if выражение_1:
    инструкции_(блок_1)
    elif выражение_2:
    инструкции_(блок_2)
    elif выражение_3:
    инструкции_(блок_3)
    else:
    инструкции_(блок_4)
    Пример.
    a = int(input("введите число:"))
    if a < 0:
    print("Neg")
    elif a == 0:
    print("Zero")
    else:
    print("Pos")
    Если пользователь введет число меньше нуля, то будет напечатано
    “Neg“, равное нулю – “Zero“, большее нуля – “Pos“
    Цикл while
    "While" переводится с английского как "пока". Но не в смысле "до свидания", а в смысле "пока имеем это, делаем то".
    Можно сказать,
    while является универсальным циклом.
    Он присутствует во всех языках,
    поддерживающих структурное программирование, в том числе в Python. Его синтаксис обобщенно для всех

    23
    языков можно выразить так:
    while выражение:
    инструкция_1
    инструкция_2
    инструкция_n
    Это похоже на условный оператор if. Однако в случае циклических операторов их тела могут выполняться далеко не один раз. В случае if, если логическое выражение в заголовке возвращает истину, то тело выполняется единожды. После этого поток выполнения программы возвращается в основную ветку и выполняет следующие выражения, расположенные ниже всей конструкции условного оператора.
    В случае while, после того как его тело выполнено, поток возвращается к заголовку цикла и снова проверяет условие. Если логическое выражение возвращает истину, то тело снова выполняется. Потом снова возвращаемся к заголовку и так далее.
    Цикл завершает свою работу только тогда, когда логическое выражение в заголовке возвращает ложь, то есть условие выполнения цикла больше не соблюдается. После этого поток выполнения перемещается к выражениям, расположенным ниже всего цикла. Говорят, "происходит выход из цикла".
    Пример:
    a = 0
    while a < 7:
    print("A")
    a += 1
    Буква “А” будет выведена семь раз в столбик.
    С циклом while возможны две исключительные ситуации:

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

    Если логическое выражение в заголовке while никогда не возвращает False, а всегда остается равным True, то цикл никогда не завершится, если только в его теле нет оператора принудительного выхода из цикла (break) или вызовов функций выхода из программы – quit(), exit() в случае Python. Если цикл повторяется и повторяется бесконечное количество раз, то в программе происходит зацикливание. В это время она зависает и самостоятельно завершиться не может.
    Пример бесконечного цикла.
    a = 0
    while a == 0:

    24
    print("A")
    Операторы break и continue
    При работе с циклами используются операторы break и continue.
    Оператор break предназначен для досрочного прерывания работы цикла while.
    Пример.
    a = 0
    while a >= 0:
    if a == 7:
    break a += 1
    print("A")
    В приведенном выше коде, выход из цикла произойдет при достижении переменной a значения 7. Если бы не было этого условия, то цикл выполнялся бы бесконечно.
    Оператор continue запускает цикл заново,
    при этом код,
    расположенный после данного оператора, не выполняется.
    Пример.
    a = -1
    while a < 10:
    a += 1
    if a >= 7:
    continue print("A")
    При запуске данного кода символ “А” будет напечатан 7 раз, несмотря на то, что всего будет выполнено 11 проходов цикла.
    Цикл for
    Цикл for в языке программирования Python предназначен для перебора элементов структур данных и некоторых других объектов. Это не цикл со счетчиком, каковым является for во многих других языках.
    Что значит перебор элементов? Например, у нас есть список,
    состоящий из ряда элементов. Сначала берем из него первый элемент, затем второй, потом третий и так далее. С каждым элементом мы выполняем одни и те же действия в теле for. Нам не надо извлекать элементы по их индексам и заботится, на каком из них список заканчивается, и следующая итерация бессмысленна. Цикл for сам переберет и определит конец.
    spisok = [10, 40, 20, 30]

    25
    >>> for element in spisok:
    print(element + 2)
    12 42 22 32
    В ключевого слова for используется переменная под именем element.
    Имя здесь может быть любым. Нередко используют i. На каждой итерации цикла for ей будет присвоен очередной элемент из списка spisok. Так при первой прокрутке цикла идентификатор element связан с числом 10, на второй – с числом 40, и так далее. Когда элементы в spisok заканчиваются,
    цикл for завершает свою работу.
    С английского "for" переводится как "для", "in" как "в". Перевести конструкцию с языка программирования на человеческий можно так: для каждого элемента в списке делать следующее (то, что в теле цикла).
    В примере мы увеличивали каждый элемент на 2 и выводили его на экран. При этом сам список конечно же не изменялся:
    spisok
    [10, 40, 20, 30]
    Нигде не шла речь о перезаписи его элементов, они просто извлекались и использовались. Однако бывает необходимо изменить сам список,
    например, изменить значение каждого элемента в нем или только определенных, удовлетворяющих определенному условию. И тут без переменной, обозначающей индекс элемента, в большинстве случаев не обойтись:
    i = 0
    for element in spisok:
    spisok[i] = element + 2
    i += 1
    spisok
    [12, 42, 22, 32]
    Но если мы вынуждены использовать счетчик, то выгода от использования цикла for не очевидна. Если знать длину списка, то почему бы не воспользоваться while. Длину можно измерить с помощью встроенной в
    Python функции len().
    i = 0
    while i < len(spisok):
    spisok[i] = spisok[i] + 2 # или spisok += 2
    i = i + 1 # или i += 1

    26
    spisok
    [14, 44, 24, 34]
    Кроме того, с циклом while мы избавились от переменной element.
    1   2   3


    написать администратору сайта