|
|
Северенс Ч. - Введение в программирование на Python - 2016. Введение в программирование на Python Ч. Северенс М. Национальный Открытый Университет "интуит", 2016
  ch,ee ses
numbers
 ,e mpty
 
--- □
Hst
Списки на рисунке представлены прямоугольниками со словом список (list) снаружи и элементами списка внутри.
Список индексов работает так же, как и строковые индексы:
Любое целочисленное выражение можно использовать в качестве индекса.
Если вы попытаетесь прочитать или записать элемент, которого не существует, вы получите IndexError.
Если индекс имеет отрицательное значение, он ведет счет в обратном направлении от конца списка.
Оператор iп работает аналогично для списков.
>>> cheeses = ['Cl1eddar', 'Edam', 'Gouda']
>>> 'Edam' iп cheeses
True
>>> 'Brie' in cheeses False
Обход списка
Наи более общий путь обхода элементов списка - использование цикла for.
Похожий синт аксис использ уется для обхода строк:
>>> for cheese n1cheeses : print cheese
C\1eddar Edam Gouda
Это замечательно работает, если вам необходимо прочитать элементы списка. Но если вы хотите записать или обновить элементы, понадобятся индексы. Общий подход, чтобы это сделать - объединить функции range и len:
>>> for i in range(leв(numbers)): nшnbers[i] = nшnbers[i] * 2
>>> prn1t numbers
[34, 10]
Этот цикл обходит список и обновляет каждый элемент. len возвращает число элементов в списке. range возвращает список индексов от О до n- 1, где n - дл ин а списка . За кажд ый шаг в ци кле переменной i присваивается индекс следующего элемента. Выражение присваивания в теле цикла использует i для чтения старого значения элемента и записи нового значения.
При обходе пустого списка в цикле for ни когда не выполнится тело цикла:
>>> for х in empty:
print 'Тrus never happens.'
Хотя список может содержать другой список, вложенный список считается одним элементом. Длина списка будет равна четырем:
>>> leп(['spam', 1, ['Brie', 'Roquefort', 'Pol le Veq'], [1, 2, 3]])
4
Операторы списка
О перато р + объединяет списки:
>>> а = [1,2,3]
>>> Ь = [4,5,6]
>>> с = а+ Ь
>>> priпt с
[1, 2,3,4,5,6]
Аналогичным образом, оператор * повторяет список заданное число раз:
>>> [О]* 4
[О, О, О, О]
>>> [1,2,3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
Срез списка
Операт ор среза также работает для списков:
>>> t = ['а', 'Ь', 'с'' 'd'' 'е', 'f]
>>> t[l:3]
['Ь', 'с']
>>> t[:4]
'
['а ' 'Ь' 'с' 'd']
' '
>>> t[3:]
['d', 'е', 'f ]
Если опустить первый индекс, то срез начнется с начала. Если опустить второй - срез закончится в конце . Если опустить оба значения, то срез будет являться копией всего списка.
>>> t[:]
['а'' 'Ь', 'с' , 'd', 'е', 'f]
Т.к. списки можно изменять то, часто создается копия перед выполнением операций, которые складывают, удлиняют или искажают списки.
Оператор среза в левой части выражения может обновить несколько элементов:
['х','у']
= ' '
>>> t = ['а' 'Ь' 'с' 'd' 'е' 'f]' ' '
>>> t[l:3]
>>> priпt t
' ' ' '
['а '' 'х' 'у' 'd' 'е' 'f]
Методы списков
Python предос тав ляе т методы, которые оперируют со списками . Например,
аррепd добавляет новый элемент в конец списка:
>>> t = ['а', 'Ь', 'с']
>>> t.append('d')
>>> priпt t
['а' ' 'Ь' 'с' 'd']
>>> ' '
exteпd принимает в качестве аргумента список и добавляет все элементы:
>>> t1 = ['а', 'Ь', 'с']
>>> t2 = ['d', 'е']
>>> tl.exteпd(t2)
>>> priпt t1
['а''
'Ь''
,'с' ',d' 'е' ]
sort организует элементы списка от низllШх к высllШм:
>>> t = ['d'' ,'с' 'е'' 'Ь'' 'а']
>>> t.sort()
>>> priпt t
['а'' 'Ь', 'с', 'd', 'е']
Боль1Ш1нство методов списка не имеют типа (void), они и змен яют список и возвращают Nопе. Если вы случайно напишете t = t.sort(), то результат вас разочарует.
Удаление элементов
Существует несколько подходов для удаления элементов из списка. Если известен индекс элемента, можно воспользоваться рор:
>>> t = ['а', 'Ь', 'с']
>>> х = t.pop(l)
>>> priпt t
['а', 'с']
>>> priпt х
ь
>>>
рор изменяет список и возвращает элемент, который был удален. Если не указан индекс, то удаляется и возвращается последний элемент списка.
Если вам не нужно удалять значен ие, можно воспользоваться оператором del
>>> t = ['а', 'Ь', 'с']
>>> del t[l ]
>>> priпt t ['а', 'с']
Если вы знаете элемент, который хотите удалить (но не его индекс), можно воспользоваться remove:
>>> t = ['а', 'Ь', 'с']
>>> t.remove('Ь')
>>> priпtt
['а', 'с']
remove возвращает значение Nопе.
Для Удаления больше, чем одного элемента, можно использовать del со срезом индекса:
>>> t = ['а', 'Ь', 'с'' 'd'' 'е', 'f ]
>>> del t[l :S]
>>> priпtt
['а', 'f ]
Списки и функции
Существует несколько встроенных функций, которые могут быть использованы для списков, они позвол яют быстро просмотреть список без написания собственного цикла:
>>> nшns = [З, 41, 12, 9, 74, 15]
>>> priпtlеп(пшns) 6
>>> priпt rnax(nшns)
74
>>> prh1t mm(пшns)
3
>>> prh1t sшn(пшns) 154
>>> prh1t sшn(nшns)Л.en(nшns) 25.6666666 66666668
Функция sшn() работает только, когда все элеме нты списка числовы е. Другие функции (rnax(), len() и т.д.) работают со списками строк и другими типами, которые могут быть сопоставимы.
Мы можем переписать программу, которая рассчитывала среднее значение чисел в списке с использованием списка.
Сначала программа, подсчитывающая среднее значение, без списка:
total = О сош1t = О
wl1ile ( True ) :
inp = raw_input('Enter а number: ')
if inp == 'dопе' : break value = tloat(inp)
total = total + value count = сош1t + 1 average = tot al / сош1t
priпt 'Average:', average
Можем просто запомнить каждое число, которое вводит пользователь и с использовани ем встроенной функции подсчитать sum и count в конце.
numlist = list() wl1ile ( True ) :
inp = raw_input('Eпter а number: ')
if inp == 'dопе' : break value = tloat(inp) nшnlist.append(valL1e)
average = sшn(пumlist) / leп(numlist) print 'Average:', average
Мы создали пустой список перед началом цикла и затем каждый раз добавляли число в этот список.
Списки и строки
Строка - последоват ельность символов, список - последовательность значений, но список символов - это не тоже самое, что строка. Преобразовать строку в список символов можно с помощью list:
>>> s = 'spam'
>>> t = list(s)
>>> prh1t t
['s', 'р', 'а', 'n1']
Т.к. list - это имя вст роенной фунщии, вы должны избегать его использование в качестве имени переменной. Я избегаю использовать L т.к. это похоже на 1, поэтому я использую t.
Фунщия list разбивает строку на отдельные буквы. Если вы хотите разбить строку на слова, вы можете использовать метод split:
>>> s = 'piпing for the Jjords'
>>> t = s.split()
>>> priпtt
['piniпg', 'for', 'the', 'fjords']
>>> priпtt[2] the
При вызове split можно передать аргумент, который задает разделитель (delirniter), вместо пробела по умолчанию:
>>> s = 'sp am-s pam-spam'
>>> delimite r = '-'
>>> s.split(de lirnite r)
['s pam', 'spam', 'spam']
join - противоположность split, он прини мает список строк и объединяет элементы.
>>> t = ['pining', 'fo r', 'the', 'fjords']
>>> delimite r = ' '
>>> delimite r.joiп(t) ' pining for the Jjo rd s'
В этом случае разделителем является пустая строка, поэтому joiп помещает пробелы между словами. Чтобы соединить строки без пробелов, в качестве разделителя необходимо использовать пустую строку.
Разбор списков
Обычно, когда мы читаем файл, мы хотим что-то сделать, а не просто вывести на экран всю строку. Часто мы хотим найти ''интересн ые
строки", а затем разобрать строки, чтобы найти некоторы е интересные части строки. Как быть, если мы хотим распечатать день недели у тех строк, которые начинаются с ''From ".
Froш stephen.marquard@uct.ac.za Sa t Jan 5 09:14:16 2008
Метод split очень эффективен , когда стал кивается с подобной проблемой. Мы можем написать небольшую программу, которая ищет строки, начинаю щиеся с ''From ", а затем разделить (split) эти строки и распечатать третье слово в строке:
fhand = open('mbox-short.txt') for line ш fhaпd:
line = liпe.rstrip()
if поt line.startswith('From ') : сопtшuе words = line.split()
priпt words[2]
Мы используем условие if которое пропускает все строки,
начинающиеся не с 'From '. '
Результат работы программы будет след ующим:
Sat Fri Fri Fri Fri Fri
Объекты и значения
Если мы выполним эти операторы присваивания:
а = 'Ьanana' Ь = 'Ьanana'
Мы знаем, что а и Ь ссылаются на строку, но мы не знаем, ссылаются ли они на одну и ту же строку. Возможны два варианта:
 
В первом случае, а и Ь ссылаются на два различных объекта, которые имеют некоторое значение. Во втором случае, они ссылаются на один и тот же объект.
Чтобы проверить, ссылаются ли две переменные на один и тот же объект, вы можете использовать оператор is.
>>> а = 'Ьanana'
>>> Ь = 'Ьаnапа'
>>> а isЬ True
В этом примере Python создает только один строковый объект, а и Ь ссылаются на него.
Но когда вы создаете два списка, вы получите два объекта:
>>> а = [1, 2, З]
>>> Ь = [1, 2, З]
>>> а is Ь
False
На диаграмме это выглядит следующим образом:
В этом случае мы можем сказать, что два списка эквивалентны (equivalent), т.к. имеют одинаковые элементы, но не идентичны (identical), т.к. это не один и тот же объект. Если два объекта идентичны, они также эквивалентны, но если они эквивалентны не обязательно, что они идентичны.
До этого момента, мы использовали понятия 'объект' (object) и 'значение' (valнe), как синонимы, но более точно говорить, что объект имеет значение. Если вы выполните а = [1,2,З], то переменная а ссылается на объект-список, значением которого является определенная последовательность элементов.
Псевдонимы (Aliasing)
Если а ссылается на объект, и вы присваиваете Ь = а то, затем обе переменные ссылаются на один и тот же объект:
>>> а = [1, 2, 3]
>>> Ь = а
>>> Ь is а True
Схема выглядит следующим образом:
Ассоциация переменной с объектом называется ссылкой (reference). В этом примере две ссылки на один объект. Объект с более чем одной ссылкой имеет больше одного имени, поэтому мы говорим, что объект имеет псевдонимы (aliased).
Если псевдоним объекта изменяется, то эти изменения касаются других псевдонимов:
>>> Ь[О] = 1 7
>>> priпtа
(17, 2, З]
Хотя такое поведение может быть полезным, существует вероятность 0IШ1биться. В общем, более безопасно избегать псевдонимов при работе с изменяемыми объектами.
Для неизменяемых объектов, таких как строки, псевдонимы не являются большой проблемой.
Список аргументов
Когда вы пер едаете список в функцию, функция получает ссылку на список.
Если функция изменяет параметр-список, вызывающий видит изменения.
Например, delete_head удаляет первый элемент из списка:
>>> def delete_hea d(t):
del t[O]
>>> letters = ['а', 'Ь', 'с']
>>> delete_head(letters)
>>> priпtletters
['Ь', 'с']
Параметр t и переменная letters - псевдонимы дл я одного и того же объекта. Схема стека выглядит следующим образом:
|
|
|
Скачать 0.65 Mb.