Введение в научный Python-1. Введение в научный Python
 Скачать 6.2 Mb.
|
|
Операторы сравнения используются в логических выражениях. Перечислим эти операторы: == (равно), != (не равно), <,<=,>,>= (меньше, меньше или равно, больше, больше или равно), in (проверка того, является ли элемент членом последовательности), is (проверка того, ссылаются ли две переменные на один и тот же объект). При этом в логическом выражении можно указывать сразу несколько условий: >>> x=5 >>> 1 Несколько логических выражений можно объединить в одно с помощью операторов and (логическое И) и or (логическое ИЛИ). >>> x1=5; x2=3 >>> x1==x2 or x1!=x2 True Кроме того, значение логического выражения можно инвертировать с помощью оператора not. >>> x=True >>> y=not x >>> y False 2.2 Списки, кортежи, словари и строки В этом параграфе мы будем говорить о типах Python, которые могут хранить последовательности данных: о списках, кортежах и строках. Есть еще типы bytes и bytearray, которые также могут хранить последовательности данных, но о них мы поговорим в другом месте. Используя термин последовательность, мы будем иметь в виду любой из этих типов. Любой набор чисел или других объектов, заключенный в квадратные скобки, интерпретируется как список, и над ним можно выполнять преобразования естественные для такого типа данных. Списки могут содержать объекты любых типов и в одном списке могут быть объекты разных типов. Списки являются изменяемыми объектами, т.е. элементы списка можно изменить с помощью операции присваивания. >>> L=[1,2,3] >>> L[1]=11 >>> L [1, 11, 3] Кортеж (tuple) – это нумерованный набор объектов, заключенный в круглые скобки, элементы которого нельзя менять. Кортеж, по сути – это неизменяемый список. Можно получить элемент кортежа по индексу, но изменить его нельзя: >>> K=(4,5,6) >>> print(K[1]) 38 5 >>> K[1]=11 Ошибка! Если кортеж единственный объект в правой части присваивания, то скобки ставить не обязательно. >>> t=1,2,3 >>> t (1, 2, 3) Работать с кортежами можно так же, как со списками. Нельзя только изменять их. Многие функции, в частности функции модуля math не могут принимать в качестве аргумента списки и кортежи. Чтобы применить какую–либо функцию f ко всем элементам списка (кортежа) и получить список результатов, следует задействовать встроенную функцию map(f,список), где f это имя функции (без аргументов). В результате возвращается «итератор», объект, который можно преобразовать в список с помощью функции list(). >>> import math as m >>> list(map(m.sin,[0,m.pi/6,m.pi/4, m.pi/2])) [0.0,0.49999999999999994, 0.7071067811865475, 1.0] >>> def f(x): return x** 2 >>> list(map(f, [0, 1, 2, 3, 4])) [0, 1, 4, 9, 16] Списки и кортежи являются упорядоченными последовательностями элементов и поддерживают обращение к элементам по индексу. Нумерация элементов начинается с 0. В качестве индекса можно указать отрицательное значение. В этом случае смещение будет отсчитываться от конца последовательности, или точнее, индекс будет определяться как разность длины и индекса (с учетом знака). >>> L [1, 11, 3] >>> L[-1] # последний элемент 3 >>> L[len(L)-1] # последний элемент 3 Здесь функция len() вычисляет длину (количество элементов) списка. Перебрать элементы списка можно с помощью цикла for. >>> L=[10,20,30,40,50,60] >>> for elem in L: print(elem,end=" ") 10 20 30 40 50 60 К спискам применимы операции конкатенации (оператор +), повторения (оператор *), проверки на вхождение (оператор in). >>> L2=[4,5,6] >>> L+L2 # конкатенация (соединение) списков [1, 11, 3, 4, 5, 6] 39 >>> L*3 # повторение списка L три раза [1, 11, 3, 1, 11, 3, 1, 11, 3] >>> 11 in L # проверка того, что число 11 имеется в списке True >>> 12 in L False >>> K2=(7,8,9) >>> K+K2 # конкатенация кортежей (4, 5, 6, 7, 8, 9) >>> K*2 # повторение кортежа K два раза (4, 5, 6, 4, 5, 6) >>> 5 in K # проверка того, что число 5 содержится в кортеже True Допустимы операции составного присваивания типа список+=список или список*=целое_число. >>> L=[10,20,30] >>> L+=[1,2,3];L [10, 20, 30, 1, 2, 3] >>> L=[10,20,30,40] >>> L*=2; L [10, 20, 30, 40, 10, 20, 30, 40] Перед использованием списка или кортежа его нужно создать. Самый простой способ – это перечислить все элементы списка внутри квадратных скобок. >>> lst=['one',2, "three",4] >>> lst ['one', 2, 'three', 4] Функция list() позволяет преобразовать любую последовательность, указанную в ее аргументе, в список. Если параметр не указан, то создается пустой список. >>> list("Hello") # преобразуем строку в список ['H', 'e', 'l', 'l', 'o'] >>> list() # создаем пустой список [] >>> list((10,11,12,13,14,15)) # преобразуем кортеж в список [10, 11, 12, 13, 14, 15] У списков есть методы, которые позволяют их модифицировать. Метод append() добавляет элемент в конец списка. >>> L=[10,20,30,40]; L.append(100); L [10, 20, 30, 40, 100] Используя этот метод в цикле, можно строить список поэлементно >>> L=[ ] >>> for i in range(10): L.append(i**2) >>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 40 Но более элегантно такой список создается с помощью генератора списка (list comprehension). >>> [i**2 for i in range(10)] # квадратные скобки обязательны [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] Здесь цикл for находится внутри квадратных скобок. Другой особенностью является то, что инструкция, выполняемая внутри цикла, находится перед циклом. Генераторы списков могут иметь сложную структуру, например, состоять из нескольких вложенных циклов for или содержать условный оператор if. >>> [ [ a, b ] for a in range(3) for b in range(2)] [[0, 0], [0, 1], [1, 0], [1, 1], [2, 0], [2, 1]] В генерируемый список можно включать не все элементы >>> [ elem**2 for elem in range(10) if elem != 5 ] [0, 1, 4, 9, 16, 36, 49, 64, 81] При присваивании одного списка другому создается новая ссылка на тот же список, а не его копия. >>> L=[10,20,30,40,50,60] >>> M=L; M[2]=33; M [10, 20, 33, 40, 50, 60] >>> L [10, 20, 33, 40, 50, 60] В следующей команде операция is проверяет, являются ли M и L одним и тем же объектом (разными именами, которые ссылаются на одну и ту же область памяти). >>> M is L True Чтобы изменять списки M и L независимо, нужно присвоить переменной M не список L, а его копию. Тогда это будут два различных списка, содержащие в начальный момент одни и те же элементы. Для этого используется команда M=L[:], где L[:] – это подсписок списка L от начала до конца, а подсписок всегда копируется. >>> L=[10,20,30,40,50,60]; M=L[:]; M [10, 20, 30, 40, 50, 60] >>> M is L False Операция „==‟ может проверить, совпадают ли списки поэлементно. >>> M==L True >>> M[2]=33 >>> M==L False Другой способ создания копии списка состоит в использовании функции list(). >>> L=[10,20,30,40,50,60] >>> M=list(L) 41 >>> M is L # результат False показывает, что L и M разные объекты False Однако следует помнить, что функция list() и операция среза (: двоеточие) создают лишь поверхностную копию, т.е. копию внешнего одномерного списка. Если списки вложенные, то для создания полной копии следует воспользоваться функцией deepcopy() из модуля copy. >>> import copy >>> L=[[1,2,3],[4,5,6]] >>> M=copy.deepcopy(L) # или M=list(L) >>> M[1][1]=555 >>> M [[1, 2, 3], [4, 555, 6]] >>> L # использование list() приводит к изменению элемента L[1][1] [[1, 2, 3], [4, 5, 6]] Функция deepcopy() создает полную копию любого объекта Python, а не только списка. Последовательности (списки, строки, кортежи и т.д.), кроме обращения к элементам по индексу, поддерживают операцию получения среза, которая возвращает фрагмент последовательности. Операция имеет следующий формат: объект[начало : конец : шаг] Все параметры являются необязательными. Если параметр Начало не указан, то используется значение 0. Если параметр Конец не указан, то возвращается фрагмент до конца последовательности. Если параметр Шаг не указан, то используется значение 1. Значения параметров могут быть отрицательными. >>> L=[10,20,30,40,50,60,70,80,90] >>> L[2:5] [30, 40, 50] >>> L[1:9:2] [20, 40, 60, 80] Заметим, что символ с индексом, указанным в параметре Конец, не входит в возвращаемый фрагмент. Фактически, в параметрах начало и конец указываются не номера элементов, а номера «промежутков» между ними, где нулевым промежутком считается позиция перед первым элементом последовательности. Вот еще несколько примеров использования операции среза. >>> L[ : ] # Возвращается фрагмент от позиции 0 до конца списка [10, 20, 30, 40, 50, 60, 70, 80, 90] Здесь начало не указано (значит 0), конец не указан (значит до конца), шаг не указан (значит 1), т.е. L[:] возвращает список целиком, а точнее, возвращает копию списка (можно использовать запись L[::]). >>> L=[10,20,30,40,50,60]; M=L[:]; M[2]=33; M [10, 20, 33, 40, 50, 60] >>> L # список L не изменился [10, 20, 30, 40, 50, 60] 42 >>> L[ : : -1] # список в обратном порядке [60, 50, 40, 30, 20, 10] >>> M=[11]+L[1:] # M отлично от L значением первого элемента списка >>> M [11, 20, 30, 40, 50, 60] >>> M=L[:-1]; M # удаление последнего элемента списка [10, 20, 30, 40, 50] >>> M=L[-1:]; M # получить последний элемент списка, а точнее # получить фрагмент от len(L)-1 до конца списка [60] >>> L[:4] [10, 20, 30, 40] >>> L[4:] [50, 60] >>> L[:4]+L[4:] [10, 20, 30, 40, 50, 60] Можно заменить какой-нибудь подсписок новым списком (в том числе другой длины) >>> L[2:4]=[' a','b','c'];L # заменить второй и третий элементы [10, 20, 'a', 'b', 'c', 50, 60] >>> L[2:4]=[ ]; L # удалить второй и третий элементы [10, 20, 'c', 50, 60] >>> L[2:3]=[ 1,2,3];L # заменить второй элемент элементами из списка [10, 20, 1, 2, 3, 50, 60] Некоторые из этих операций могут быть записаны в другой форме. >>> L=[1,2,3,4,5,6,7,8] >>> del L[2:4]; L [1, 2, 5, 6, 7, 8] Элементами списка могут быть другие списки >>> L=[[1,2,3],[4,5,6]] >>> L[1][1] 5 Поскольку выражение в скобках может располагаться на нескольких строках, то последнее присваивание можно записать так: >>> L=[[1,2,3], [4,5,6]] Количество вложений списков не ограничено. Вложенные списки можно создавать с помощью генераторов списков, а затем, если нужно, менять или добавлять элементы. >>> lst=[ [ ] for a in range(3)] >>> lst [[], [], []] >>> lst[0].append(100) >>> lst [[100], [], []] >>> lst[1].append(222) 43 >>> lst [[100], [222], []] Как мы видели, переменная может ссылаться на список. Но и слева от операции присваивания может стоять список переменных. >>> [x,y,z]=[[1,2],[3,4],[5,6]] >>> x [1, 2] >>> y [3, 4] >>> z [5, 6] Вообще, по обе стороны оператора присваивания могут стоять последовательности, содержащие одинаковое количество элементов. >>> x,y="12 " >>> x '1' >>> y '2' >>> [x,y,z]=["Hello",[1,2,3],[[1,2],[3,4]]] >>> x 'Hello' >>> y [1, 2, 3] >>> z [[1, 2], [3, 4]] Существует возможность сохранения в элементе левого списка лишних элементов правого, если количество элементов справа от знака присваивания больше количества элементов левого списка. Для этого перед именем переменной левого списка указывается звездочка(*). >>> [x,y,*z]=[1,2,3,4] >>> print(x,y,z) 1 2 [3, 4] >>> [x,*y,z]=["Hello",[1,2,3],123,[[1,2],[3,4]]] >>> x 'Hello' >>> y [[1, 2, 3], 123] >>> z [[1, 2], [3, 4]] Переменная, перед которой указана звездочка, всегда содержит список. Если для этой переменной не хватило значений, то ей присваивается пустой список. >>> [х, у, *z]= [10, 20] >>> z [] Звездочку можно указать только перед одной переменной, иначе возникает неоднозначность, и интерпретатор выводит сообщение об ошибке. 44 Списки являются объектами и, следовательно, они имеют методы. >>> L=[1,2,3,4,5,6,7,8] >>> L.insert(3,0); L # вставить на 3-ю позицию ноль [1, 2, 3, 0, 4, 5, 6, 7, 8] >>> L.append(10); L # добавить число 10 в конец списка [1, 2, 3, 0, 4, 5, 6, 7, 8, 10] Метод extend(Последовательность) добавляет в конец списка элементы последовательности (другого списка, кортежа и т.д.). Метод изменяет текущий список и ничего не возвращает. >>> L.extend([12,13,14]); L [1, 2, 3, 0, 4, 5, 6, 7, 8, 10, 12, 13, 14] Метод remove(x) удаляет первый элемент в списке, имеющий значение x. >>> L=[1,7,3,4,5,7,5,3] >>> L.remove(7); L [1, 3, 4, 5, 7, 5, 3] Метод pop(i) удаляет i-ый элемент из списка и возвращает его. Если индекс не указан, удаляется последний элемент >>> x=L.pop() >>> L [1, 3, 4, 5, 7, 5] >>> x 3 >>> L.pop(2) 4 >>> L [1, 3, 5, 7, 5] Метод index(x,[start[,end]]) возвращает положение первого элемента x в диапазоне от start до end. >>> L.index(5) 2 Метод count возвращает количество элементов списка со значением x. >>> L.count(5) 2 Есть еще метод sort() – сортировка списка, reverse() – обращение порядка элементов в списке, clear() – очистка списка, copy() – поверхностная копия списка. Заметим, что многие описанные методы изменяют сам список. Функции min(список) и max(список) возвращают наименьший и наибольший элементы. Функция zip(...) принимает набор последовательностей (списков, кортежей и т.д.) и возвращает итератор по кортежам, где i–й кортеж содержит i–й элемент каждой из последовательностей. >>> a = [1,2] >>> b = [3,4] >>> list(zip(a,b)) # преобразуем итератор в список [(1, 3), (2, 4)] 45 Здесь функция zip() соединяет списки парами. Итератор завершается, когда исчерпана кратчайшая из последовательностей. >>> list(zip([1, 2, 4], [4, 5], [5, 7])) [(1, 4, 5), (2, 5, 7)] >>> c = [5,6] >>> tuple(zip(a,b,c)) # преобразуем итератор в кортеж ((1, 3, 5), (2, 4, 6)) Мы уже упоминали функцию map(fun,list). Она применяет функцию fun к элементам списка list и возвращает итератор, который можно преобразовать в список. >>> def f(x): return x*x >>> list(map(f, [0.5,0.9,1.9])) [0.25, 0.81, 3.61] В функцию map(fun,...) можно передать несколько списков. Тогда функция fun должна принимать столько аргументов, сколько передано списков в функцию map. >>> def f(x, y): return x*y >>> a = [1,3,4] >>> b = [3,4,5] >>> list(map(f, a, b)) [3, 12, 20] Функция filter(fun,list) возвращает список только из тех элементов списка list, для которых функция fun возвращает истину. >>> filter(lambda x: 2 >>> list(_) # преобразовать в список результат последней секции [3, 4, 5] Все, что говорилось в этом параграфе о списках, относится и к кортежам, за исключением того, что кортеж – это список, доступный только для чтения. Поэтому все функции и методы, не меняющие содержимое, можно применять и к кортежам. Некоторые особенности мы опишем здесь. Функция tuple(последовательность) позволяет преобразовать любую последовательность в кортеж. Если параметр не указан, то создается пустой кортеж. >>> L=[1,2,3,4,5,6,7,8] >>> t=tuple(L); t (1, 2, 3, 4, 5, 6, 7, 8) Чтобы задать кортеж из одного элемента, необходимо в конце последовательности внутри круглых скобок указать запятую. Именно запятые формируют кортеж, а не круглые скобки. 46 >>> t=(5,); type(t) >>> r=(5); type(r) >>> q=3,"str",[1,2] >>> type(q) Последний пример подтверждает, что не скобки формируют кортеж, а запятые. В левой части присваивания можно написать несколько переменных через запятую, а в правой кортеж. Результатом является одновременное присваивание значений нескольким переменным. >>>x,y,z=10,20,30 >>>y 20 При этом, сначала вычисляется кортеж в правой части, исходя из старых значений переменных (до присваивания). Потом одновременно всем переменным левой части присваиваются новые значения из этого кортежа. Так можно обменять значения нескольких переменных. >>>x,y,z=z,x, y >>>x,y,z (30, 10, 20) Строки. Одним из наиболее часто используемых типов данных является строка. Строки в Python являются упорядоченными последовательностями символов и относятся к неизменяемым типам данных. Иными словами, можно получить символ строки по индексу, но изменить его нельзя. Поэтому большинство строковых методов в качестве значения возвращают новую строку, а не модернизируют текущую. Строку можно задать, используя одинарные или двойные кавычки. >>> s1="Hello" >>> s2='world' >>> s1+s2 'Helloworld' В языке Python никакого отличия между строкой в апострофах и строкой в кавычках нет. Если строка содержит кавычки, то ее лучше заключить в апострофы и наоборот. Чтобы расположить строку в нескольких строчках, следует перед символом перевода строки указать символ \ (слэш). >>> print("Привет \ мир") Привет мир Строки могут содержать специальные (управляющие) символы, такие как \n (символ новой строки), \t (табуляция) и некоторые другие. Если перед строкой поместить модификатор r, то специальные символы внутри строки будут выводиться как есть. 47 >>> print(r"Привет\nмир") Привет\nмир Иначе они (специальные символы) управляют отображением сроки. >>> print("Привет\nмир") Привет мир Сложение строк (оператор +) означает конкатенацию (соединение), а умножение на целое число (с любой стороны) – повторение строки несколько раз. >>> 3*s1 'HelloHelloHello' Строка, размещенная между утроенными кавычками, сохраняет свое форматирование. >>> s="""Привет мир""" >>> s 'Привет\nмир' >>> print(s) Привет мир Строки, разделѐнные только пробелами, автоматически объединяются в одну строку (неявная конкатенация). >>> print('Эта\n' 'строка\n' 'слипается') Эта строка слипается Операция in проверяет, содержится ли символ (или подстрока) в строке. >>> 'M' in s1 False >>> 'ell' in s1 True >>> "a" not in s1 True Длину строки можно получить с помощью функции len(). >>> len(s) 5 Функция len() применима не только к строкам, но и к спискам, словарям и многим другим типам, про объекты которых разумно спрашивать, какая у них длина. Функция str(объект) возвращает строковое представление объекта. >>> a=5+3j >>> str(a) '(5+3j)' 48 В Python нет специального типа char, его роль играют строки длины 1. В Python 3 строки содержат символы в Unicode и, следовательно, могут содержать одновременно русские, латинские, греческие буквы и даже иероглифы. >>> s=' Текст + \u03C0 \u03A3 \u2154 \u2660 \u263A \u222B';print(s) Текст + π Σ ⅔ ♠ ☺ ∫ Функция ord(символ) возвращает код символа, а функция chr(код) возвращает символ (строку длины 1). >>> ord('D') # код английской буквы D 68 >>> c=ord ('Б'); c # код русской буквы Б 1041 >>> chr(1043) # строка из одного символа 'Г' Символы в строке индексируются с 0. >>> s='Mathematics' >>> s[0] 'M' Отрицательные индексы используются для отсчѐта с конца. >>> s[-4] 't' Можно перебрать элементы строки в цикле. >>> for i in range(len(s)): print(s[ i], end=" ") M a t h e m a t i c s Можно просто указать строку в качестве последовательности цикла. >>> for ch in s: print(ch, end=" ") M a t h e m a t i c s Можно выделить подстроку, указав диапазон индексов. Подстрока включает начальный символ диапазона, и не включает конечный. >>> s[2:5] 'the' Шаг диапазона может быть отрицательным >>> s='Mathematics' >>> s[::-1] # строка в обратном порядке (отрицательный шаг) 'scitamehtaM' >>> ' H'+s[1:] # замена первого символа 'Hathematics' Строки являются неизменяемым типом данных. Создав строку, нельзя изменить в ней один или несколько символов. >>> s="Hello" >>> s[1]='N' Ошибка! У объектов строк имеется множество методов. Например, метод upper() возвращает строку, целиком состоящую из прописных букв. Метод lower() возвращает строку из строчных букв. 49 >>> s3=s.upper(); s3 'HELLO' Метод split() возвращает список, элементами которого являются все слова строки. По умолчанию расщепление производится по пустым промежуткам (пробелам, табуляциям и символам конца строки). >>> a ="Это тестовое предложение" >>> L=a.split(); L ['Это', 'тестовое', 'предложение'] Метод строка.join(список_строк) создает строку из всех элементов списка, между которыми вставляется «базовая» строка. >>> s4=" ".join(L); s4 # слова объединяются через пробел 'Это тестовое предложение' >>> s5="+++".join(L) ; s5 # слова объединяются через ‟+++‟ 'Это+++тестовое+++предложение' Метод lstrip() удаляет все пустые промежутки (пробелы, табуляции и символы конца строки) в начале строки; метод rstrip() – в конце; метод strip() – с обеих сторон. >>> s=" Привет родной ВУЗ " >>> s.lstrip() 'Привет родной ВУЗ ' >>> s.rstrip() ' Привет родной ВУЗ' >>> s.strip() 'Привет родной ВУЗ' Имеются методы, которые проверяют, содержит ли строка символы какого либо типа. >>> s="123" >>> s.isdigit() # возвращает True, если все символы цифры True >>> s.isalpha() # возвращает False, если хотя бы один символ не буква False >>> s=" привет" >>> s.isalpha() # возвращает True, если все символы буквы True >>> s.islower() # возвращает True, если все буквы строчные True >>> s.isupper() # возвращает True, если все буквы прописные False При написании программ возникают ситуации, когда нужно создать строку, подставив в ее определенные места некоторые данные. Это можно сделать, используя оператор „%‟ или метод format(). Оператор „%‟ имеет следующий формат: Строка_со_спецификаторами_форматирования % данные Например, >>> string="Peter" 50 >>> 'Hello, %s' % string 'Hello, Peter' Здесь в строке 'Hello, %s' использован спецификатор %s, означающий, что вместо него будет выведена строка string (не путайте спецификатор формата с оператором форматирования, для обозначения которых используется одинаковый символ „%‟). Строка со спецификаторами форматирования может содержать два типа объектов: обычные символы, которые копируются в результирующую строку без изменений, и спецификаторы формата. Спецификаторы формата начинаются символом „%‟ (процент), и преобразуют очередной аргумент к строковому представлению, зависящему от этого спецификатора. >>> 'Нам %d лет' % 11 # %d – вывод целой части числа 'Нам 11 лет' >>> import math >>> 'Число e =%e' % math.e # %e – вывод числа с плавающей точкой 'Число e =2.718282e+00' >>> 'Число e =%f' % math.e # %f – вывод числа в обычном формате 'Число e =2.718282' Можно задать ширину поля вывода, указав количество символов для отображения данных. >>> 'Число e =%12f' % math.e 'Число e = 2.718282' >>> '%10f' % 15 ' 15.000000' Строка форматирования может содержать несколько различных спецификаторов форматирования. >>> "Золотое сечение это деление какой-либо величины \ приблизительно в отношении %d к %d или %5.3f" % (62,38,1.618) 'Золотое сечение это деление какой-либо величины приблизительно в отношении 62 к 38 или 1.618' Метод format() выполняет функции, аналогичные оператору форматирования % , и имеет следующую форму: Строка = Строка_со_спецификаторами_формата.format(данные) В параметре Строка_со_спецификаторами_формата для указания места отображения данных используются фигурные скобки { }. >>> string="Peter" >>> "Hello, { }".format(string) 'Hello, Peter' >>> s=" Число pi ={ }".format(math.pi) >>> s 'Число pi =3.141592653589793' В параметре строка_со_спецификаторами_формата внутри фигурных скобок можно указывать спецификаторы форматирования >>> s=" Число pi ={:e}".format(math.pi); s 'Число pi =3.141593e+00' |