Списки и кортежи в python - python самоучитель

Нефиктивные указатели

Рассмотрим кратко ещё один способ работы со списком, когда указатели beg и end
реально ссылаются на первый и последний элементы списка (напрямую, а не через поле nxt).
Оформим его в виде класса List1

function List1(nm)
{
   this.beg = null;             // указатель на первый    элемент списка (пока в никуда)
   this.end = null;             // указатель на последний элемент списка (пока в никуда)

   this.length =  0;            // число узлов в списке

   if(nm !== undefined)         // если есть аргумент nm
      this.push(nm);            // сразу вставляем первый элемент с именем nm фу-ей push
 }

List

List1.prototype.unshift = function (nm)
{
   if(this.length===0){
      this.beg = this.end = { nm: nm };
      this.length= 1;
      return;
   }
   this.length++;
   this.beg = {nm: nm, nxt:this.beg};
}

List.prototype.unshift = function (nm)
{
   this.length++;
   this.beg.nxt = {nm: nm, nxt:this.beg.nxt};
}

List1.prototype.push = function (nm)
{
   if(this.length===0){
      this.beg = this.end = { nm: nm };
      this.length= 1;
      return;
   }
   this.length++;
   this.end = this.end.nxt = {nm: nm};
}

List.prototype.push = function (nm)
{
   this.length++;
   this.end.nm = nm;
   this.end = this.end.nxt = {  };
}

List1ListList

Изменяемый объект в виде значения по умолчанию

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

Не пишите изменяемые объекты в значения по умолчанию.

Почему x = 0 — хорошо, a = [] — плохо?

Потому что эти объекты создаются 1 раз за все время работы программы перед первым вызовом функции.

(Для знающих языки С, С++ или Java — это static объекты).

Каждый новый вызов функции может изменить этот объект.

Что делать? Как исправить?

Значениями по умолчанию делайте только неизменяемые объекты.

— неизменяемый объект.

работает так:

если а — непустой список, то он в выражении будет True и выражение с or дальше вычисляться не будет, значение равно .
если это , то в логическом выражении будет False и выражение будет выполняться дальше, значение равно

Работа со списками

Подытожим.
Методы работы со списками полностью аналогичны методам работы с массивами:

   var res = "";
   var lst = new List2();
   for(var i=0; i ' + lst+'';
   lst.reverse();
   res +=  lst+'';
   res += lst.pop()+ ': ' + lst+'';
   res += lst.node(2).nm + '';
   lst.put(2,"a");      res += lst+'';
   res += lst.get(0)+'';
   lst.insert(0,"b");   res += lst+'';
   res += lst.remove(0) + ": " + lst+'';
   res += lst.remove(2) + ": " + lst+'';
   lst.reverse();
   res += lst+''
   res += ListShow(lst);
   return res;

Чтобы классы List (односторонний список) и List2 (двухсторонний список) стали доступными,
необходимо подключить модуль list.js.
Приведём в справочных целях все методы этих классов:

toString() — вывести список как строку (nm0, nm1, n2,…).
push(nm) — добавить узел с именем nm в конец списка.
unshift(nm) — добавить узел с именем nm в начало списка.
add(nm) — добавить узел с именем nm с начала списка, выдерживая его упорядоченным (функция lt).
pop() — получить поле nm последнего узла и убрать его из списка.
shift() — получить поле nm первого узла и убрать его из списка.
reverse() — перевернуть последовательность узлов в списке.
node(pos) — получить узел под номером pos в списке (начиная с нуля).
get(pos) — получить значение поля nm узла на месте pos в списке (начиная с нуля).
put(pos, nm) — поменять поле nm узла месте pos в списке (начиная с нуля).
insert(pos, nm) — добавить узел с именем nm на место pos в списке (начиная с нуля), сдвинув всё вправо.
remove(pos) — удалить узел на месте pos в списке (начиная с нуля) и вернуть его nm.

Что такое список (list) в Python?

Список () – это структура данных для хранения объектов различных типов. Если вы использовали другие языки программирования, то вам должно быть знакомо понятие массива. Так вот, список очень похож на массив, только, как было уже сказано выше, в нем можно хранить объекты различных типов. Размер списка не статичен, его можно изменять. Список по своей природе является изменяемым типом данных. Про типы данных можно подробно прочитать здесь. Переменная, определяемая как список, содержит ссылку на структуру в памяти, которая в свою очередь хранит ссылки на какие-либо другие объекты или структуры.

Вставка элементов

Напишем теперь функцию, вставляющую элемент с именем nm в начало списка:

List.prototype.unshift = function (nm)
{
   this.length++;                                 // увеличиваем число узлов

   this.beg.nxt = {nm: nm, nxt:this.beg.nxt};     // вставляемый элемент следует за beg
}

lengthnxtbeg.nxtbegbeg.nxt

List.prototype.push = function (nm)
{
   this.length++;                                 // увеличиваем число узлов

   this.end.nm = nm;                              // фиктивный end становится реальным
   this.end = this.end.nxt = { nm:null, nxt:null};// и затем снова фиктивным
}

end.nxtthisend

Графически, последовательная вставка 0, 1, 2 в начало и конец списка выглядит следующим образом:
(первые картинки в каждой строке изображают пустые списки):

# Словари

Словарь в Python похож на ассоциативный массив или хеш-таблицу в других языках. Словари индексируются по неизменяемому ключу. Для создания словаря используются фигурные скобки или функция . Словарь — неупорядоченное множество пар ключ-значение в которых ключ уникален. Пример инициализации словаря:

1234

Основные операции словаря это сохранение значения по ключу и доступ к значению по ключу. Доступ к значению осуществляется через квадратные скобки:

Словари изменяемы: значения связанные с ключами могут менятся, добавлятся и удалятся.

Структуры данных Python не ограничиваются приведёнными в этом разделе. Например, модуль содержит очереди, деки и другие коллекции. В то же время структуры приведённые в этом разделе используются в большинстве приложений на Python.

Используйте функцию help с параметром в виде названия типа данных для детального изучения типа.

1234

Нумерованные списки

В нумерованный список браузер автоматически вставляет номера элементов по порядку, начиная с некоторого значения (обычно 1). Это позволяет вставлять и удалять пункты списка, не нарушая нумерации, так как остальные номера автоматически будут пересчитаны.
Нумерованные списки создаются с помощью блочного элемента <ol> (от англ. Ordered List – нумерованный список). Далее в контейнер <ol> для каждого пункта списка помещается элемент <li> (от англ. List Item – пункт списка). По умолчанию применяется нумерованный список с арабскими числами.
Тег <ol> имеет следующий синтаксис:

Элементы нумерованного списка должны содержать несколько элементов списка, как показано в следующем примере:

Пример: Нумерованный список

Результат
HTML-код
Попробуй сам »

Пошаговая инструкция

Достать ключ
Вставить ключ в замок
Повернуть ключ на два оборота
Достать ключ из замка
Открыть дверь

Иногда при просмотре существующих кодов HTML вы будете встречать аргумент type в элементе <ol>, который используется для указания типа нумерации (буквы, римские и арабские цифры и т.п.). Синтаксис:

Здесь: type – символы списка:

A — прописные латинские буквы (A, B, C . . .);
a — строчные латинские буквы (a, b, c . . .);
I — большие римские цифры (I, II, III . . .);
i — маленькие римские цифры (i, ii, iii . . .);
1 — арабские цифры (1, 2, 3 . . .) (применяется по умолчанию).

Если вы хотите, чтобы список начинался с номера, отличного от 1, следует указать это при помощи атрибута start тега <ol>.
В следующем примере показан нумерованный список с большими римскими цифрами и начальным значением XLIX:

Пример: Применение атрибутов type и start.

Результат
HTML-код
Попробуй сам »

Перепела
Фазаны
Куропатки
Павлины

Нумерацию можно начинать и с помощью атрибута value, который добавляется к элементу <li> следующим образом:

В этом случае последовательная нумерация списка прервётся и с этого пункта нумерация начнётся заново, в данном случае с семи.

Пример использования атрибута value тега <li>, который позволяет изменить номер данного элемента списка:

Пример: Применение атрибута value

Результат
HTML-код
Попробуй сам »

Первый пункт списка
Второй пункт списка
Третий пункт списка

В этом примере «Первый пункт списка» будет иметь номер 1, «Второй пункт списка» – номер 7, а «Третий пункт списка» – номер 8.

Как списки хранятся в памяти?

Как уже было сказано выше, список является изменяемым типом данных. При его создании в памяти резервируется область, которую можно условно назвать некоторым “контейнером”, в котором хранятся ссылки на другие элементы данных в памяти. В отличии от таких типов данных как число или строка, содержимое “контейнера” списка можно менять. Для того, чтобы лучше визуально представлять себе этот процесс взгляните на картинку ниже. Изначально был создан список содержащий ссылки на объекты 1 и 2, после операции a = 3, вторая ссылка в списке стала указывать на объект 3.

Более подробно эти вопросы обсуждались в уроке 3 (Типы и модель данных).

Удаление элементов

Обсудим алгоритмы удаления элементов из списка.
Удаление в правосторонних списках (есть только ссылки nxt) из начала не представляет труда:

List.prototype.shift = function ()
{
   if(this.length===0)
      return;                                     // список пуст - вернём undefined

   this.length--;                                 // уменьшаем число узлов

   this.beg  = this.beg.nxt;                      // фиктивный beg ссылается на второй элемент
   return this.beg.nm;
}

nmnmshiftlst.beg.nm=null

Удаление из конца одностороннего списка, существенно более затратная операция, так как необходимо
получить последний элемент (реальный) о котором указатель end ничего не знает:

List.prototype.pop = function ()
{
   if(this.length === 0)
      return;                                     // список пуст - вернём undefined

   this.length--;                                 // уменьшаем число узлов

   var n = this.beg.nxt;                          // начиная с первого реального узла,
   while(n.nxt !== this.end)                      // ищем реальный последний узел
      n = n.nxt;                                  // переходя каждый раз к следующему

   this.end = n;                                  // фиктивный сдвигаем влево на один
   return n.nm;
}

List2endend.prv

Копировать список

# Copy

l = [100, 200, 300, 400, 500]

t = l
print(«\n# t = l»)
print(«t is l =», t is l) # True
r = l
print(«\n# r = l»)
print(«r is l = «, r is l) # False
print(«r == l = «, r == l) # True

u = l.copy()
print(«\n# u = l.copy()»)
print(«u is l = «, u is l) # False

v = list(l)
print(«\n# v = list(l)»)
print(«v is l = «, v is l) # False

# t = l
t is l = True

# r = l
r is l = False
r == l = True

# u = l.copy()
u is l = False

# v = list(l)
v is l = False

a = [ [1, 2], [3, 4] ]
b = a
print(a is b) # False
print(a == b) # True

print(a[]) #
print(b[]) #

print(a[] is b[]) # True

a[] = [8, 9]
print(a[]) #
print(b[]) #

a[1].append(5)
print(a[1]) #
print(b[1]) #

print(a) # , ]
print(b) # , ]

False
True

True

, ]
, ]

К спискам можно применять умножение

s = [ [-1, +1] ] * 5
print(s)
s[2].append(7)
print(s)

Самое удивительное проявление того, что Python использует просто ссылки на объекты можно наблюдать
как раз при создании списков умножением

s = [ [-1, +1] ] * 5
print(s)
s[2].append(7)
print(s)

, , , , ]
, , , , ]

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

w = «the heihei.ru website was forked from andreyolegovich.ru in 2018 simultaneously with the topbicyle.ru website».split()

print(w)

i = w.index(‘was’)
print(i) # 3
print(w) # was

print(w.count(«the»)) # 2

print(«heihei.ru» in w) # True
print(«urn.su» not in w) # True

3
was
2
True
True

Слайсы / Срезы

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

Слайс задается тройкой чисел, разделенных запятой: .

– позиция с которой нужно начать выборку
– конечная позиция
– шаг.

При этом необходимо помнить, что выборка не включает элемент определяемый stop.

Рассмотрим примеры:

Слайсы можно сконструировать заранее, а потом уже использовать по мере необходимости. Это возможно сделать, в виду того, что слайс – это объект класса . Ниже приведен пример, демонстрирующий эту функциональность:

Нумерованный список

Нумерованный (упорядоченный) список предназначен для элементов, которые следуют в определённом порядке. Нумерованный список начинается с тега <ol> (сокращенное от английского ordered list — упорядоченный список). Каждый элемент списка начинается с тега <li> (элемент списка).

Давайте рассмотрим примеры использования:

<!DOCTYPE html>
<html>
	<head>
		<title>Пример использования тега <ol></title>
	</head>
	<body>
		<ol> 
			<li>Первый пункт</li&gt
			<li>Второй пункт</li>
			<li>Третий пункт</li>
		</оl>
	</body>
</html>

Выглядеть на странице это будет соответственно так:

Первый пункт.
Второй пункт.
Третий пункт.

Если вы хотите, чтобы список начинался с определённого номера (не с 1), то необходимо указать атрибут start для тега <ol>.

<ol start = "101">  <!--список начнётся с номера 101-->

Выглядеть на странице это будет соответственно так:

Первый пункт.
Второй пункт.
Третий пункт.

Ещё один интересный атрибут — type, который позволит Вам задать буквенную нумерацию («A» – большие, «a» – строчные), либо нумерацию из римских цифр («I» – в верхнем регистре, «i» – в нижнем регистре).

Рассмотрим пример в котором представлены все возможные значения атрибута type (отличные от значения по умолчанию):

<!DOCTYPE html>
<html>
	<head>
		<title>Пример использования атрибута type HTML тега <оl></title>
	</head>
	<body>
		<ol type = "A"> <!--указываем, что список формируется в алфавитном порядке заглавными буквами --> 
			<li>Первый пункт</li&gt
			<li>Второй пункт</li>
			<li>Третий пункт</li>
		</оl>
		<ol type = "a"> <!--указываем, что список формируется в алфавитном порядке строчными буквами --> 
			<li>Первый пункт</li&gt
			<li>Второй пункт</li>
			<li>Третий пункт</li>
		</оl>
		<ol type = "I"> <!--указываем, что список формируется римскими цифрами в верхнем регистре --> 
			<li>Первый пункт</li&gt
			<li>Второй пункт</li>
			<li>Третий пункт</li>
		</оl>
		<ol type = "i"> <!--указываем, что список формируется римскими цифрами в нижнем регистре --> 
			<li>Первый пункт</li&gt
			<li>Второй пункт</li>
			<li>Третий пункт</li>
		</оl>
	</body>
</html>

Результат нашего примера:

Рис. 14 Виды нумерованных списков.

Еще один нюанс: при использовании атрибута start с буквами (type = «A» и type = «a»), число, указанное в значении атрибута является порядковым номером буквы в алфавите. Например, start = «4», будет соответствовать букве «D» и список начнётся именно с неё. При использовании значения start = «27» счетчик обнуляется, при этом список становится двухзначным («27» = «AA», «28» = «AB», «29» = «AC»…). Значения должны быть целочисленными, допускается использование отрицательных значений.

Обращаю Ваше внимание, что допускается формировать нумерованные (упорядоченные) списки, вложенные в другие нумерованные списки (внутри элемента списка ):

<!DOCTYPE html>
<html>
	<head>
		<title>Пример нумерованного списка, вложенного в другой нумерованный список</title>
	</head>
	<body>
		<ol> 
			<li>Первый пункт
				<ol>  <!--открываем новый нумерованный список внутри элемента списка--> 
					<li>Первый пункт</li&gt
					<li>Второй пункт</li>
					<li>Третий пункт</li>
				</оl>
			</li&gt
			<li>Второй пункт</li>
			<li>Третий пункт</li>
		</оl>
	</body>
</html>

Выглядеть на странице это будет соответственно так:

Первый пункт.
1. Первый пункт.
2. Второй пункт.
3. Третий пункт.
Второй пункт.
Третий пункт.

Но и это еще не все, атрибут reversed элемента позволяет задать, что порядок в нумерованном (упорядоченном) списке должен идти по убыванию. Атрибут не поддерживается браузерами Internet Explorer и Edge.

Выглядеть на странице это будет соответственно так:

Первый пункт.
Второй пункт.
Третий пункт.

Кортежи

Кортеж (tuple) инициализируется при помощи круглых скобок
() или функции tuple().

1
2
3

# создадим две переменные и поместим в них пустые кортежи

tuple_1,tuple_2=(),tuple()

print(tuple_1,tuple_2)

() ()

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

1
2
3
4
5

# создадим кортеж

letters=(‘a’,’b’,’c’)

# и выведем его первый элемент

letters

‘a’

Основное отличие от списка — кортеж неизменяем. После того как кортеж создан, добавлять или удалять элементы нельзя.

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

1 2	# попробуем заменить первый элемент кортежа letters=’d’

Для этого придется вначале преобразовать кортеж в список.

1
2
3
4
5
6

# преобразуем кортеж в список через функцию list()

letters=list(letters)

# теперь элементы можно изменять

letters=’d’

letters

Создать кортеж из одного элемента можно с помощью запятой.

1 2	let_a=(‘a’,) type(let_a)

tuple

Если запятую не ставить, получится строка.

1 2	let_a=(‘a’) type(let_a)

str

Функция enumerate()

Если с функцией enumerate() использовать не две, , а одну переменную, результатом ее работы будет кортеж, состоящий из индекса и соответствующего элемента списка.

1
2
3
4
5
6
7

# создадим список с названием трех компаний

companies=’Microsoft’,’Apple’,’Tesla’

# и в цикле поместим результат работы функции enumerate()
# в одну переменную company

forcompany inenumerate(companies)

print(company,type(company))

1
2
3

(0, ‘Microsoft’) <class ‘tuple’>
(1, ‘Apple’) <class ‘tuple’>
(2, ‘Tesla’) <class ‘tuple’>

Просмотр элементов словаря

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

1 2	# возьмем уже знакомый нам по вводному курсу словарь с овощами shopping_dict={‘огурцы’2,’помидоры’3,’лук’1,’картофель’2}

1
2
3
4

# пройдемся по ключам и значениям с помощью метода .items(),
# но поместим результат в одну переменную item

foritem inshopping_dict.items()

print(item)

1
2
3
4

(‘огурцы’, 2)
(‘помидоры’, 3)
(‘лук’, 1)
(‘картофель’, 2)

Распаковка кортежей

Распаковать кортеж значит поместить каждый из его элементов в отдельную переменную.

1
2
3
4
5

# если в кортеже три элемента, то и переменных должно быть три

a,b,c=(‘a’,’b’,’c’)

# выведем переменную a

print(a)

Кортежи удобно распаковывать в цикле for.

1
2
3
4
5
6

# снова возьмем список компаний

companies=’Microsoft’,’Apple’,’Tesla’

# однако с функцией enumerate() используем две переменных

fori,company inenumerate(companies)

print(i,company)

1
2
3

0 Microsoft
1 Apple
2 Tesla

С элементами словаря получается то же самое.

1
2
3
4
5

shopping_dict={‘огурцы’2,’помидоры’3,’лук’1,’картофель’2}

# используем две переменных с методом .items()

fork,vinshopping_dict.items()

print(k,v)

1
2
3
4

огурцы 2
помидоры 3
лук 1
картофель 2

Здесь на самом деле ничего нового для нас нет.

Создание кортежа через функцию zip()

Функция zip() принимает два и более списков и формирует объект из кортежей. В первом кортеже содержатся первые элементы каждого из списков, во втором — вторые и так далее.

1
2
3
4
5
6

# создадим два списка, список имен и список доходов

names=’Артем’,’Антон’,’Александр’,’Борис’,’Виктор’,’Геннадий’

income=97000,110000,95000,84000,140000,120000

# передадим эти списки функции zip()

zip(names,income)

1	<zip at 0x7f5ac5d43c30>

Получившийся zip-объект нужно преобразовать в список.

1	list(zip(names,income))

1
2
3
4
5
6

(‘Артем’,97000),

(‘Антон’,110000),

(‘Александр’,95000),

(‘Борис’,84000),

(‘Виктор’,140000),

(‘Геннадий’,120000)

Двухсторонние списки

Элементы (узлы) двухcторонних списков хранят в себе указатели, как на следующий элемент (nxt),
так и на предыдущий (prv):

List2

function List2(nm)
{
   this.end = {  };             // указатель на фиктивный последний элемент списка
   this.beg = { nxt:this.end }; // указатель на фиктивный первый элементы списка
   this.end.prv = this.beg;

   this.length = 0;             // число узлов в списке

   if(nm !== undefined)
      this.push(nm);
}

List2.prototype.unshift = function (nm)
{
   this.length++;
   this.beg.nxt = {nm: nm, prv:this.beg,
                           nxt:this.beg.nxt};
}

List2.prototype.push = function (nm)
{
   this.length++;
   this.end.nm = nm;
   this.end = this.end.nxt = { prv:this.end };
}

List2.prototype.pop = function ()
{
   if(this.length===0)
      return;
   this.length--;

   this.end = this.end.prv;
   return this.end.nm;
}

List2.prototype.shift = function ()
{
   if(this.length===0)
      return;
   this.length--;

   this.beg = this.beg.nxt;
   return this.beg.nm;
}

Как создавать списки

С помощью цикла for

Можно использовать цикл for для создания списка.

Это делается за три шага

Создать пустой список
Пройтись по итерируемому объекту или нескольким объектам.
Дописать каждый элемент в конец списка

Если вы хотите создать список, содержащий первые десять полных квадратов,
то вы можете выполнить эти шаги в трех строках кода:

>>> squares =
>>> for i in range(10):
… squares.append(i * i)
>>> squares

Или даже в двух

>>> squares =
>>> for i in range(10): squares.append(i * i)
>>> squares

Сперва создаётся пустой список, squares.

Затем, с помощью цикла for происходит итерация по range(10).

Наконец, каждое число умножается само на себя и результат добавляется в конец списка.

С помощью map()

map()

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

В map() передаются функция и итерируемый объект и map()
создаёт новый итерируемый объект.

Этот объект содежит вывод, который мог бы получится если бы к каждому элементу
изначального итерируемого объекта применили данную
функцию

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

txns = 1.11, 23.45, 45.5, 61.4
TAX_RATE = .08

def get_price_with_tax(txn):
return txn * (1 + TAX_RATE)

final_prices = map(get_price_with_tax, txns)
print(list(final_prices))

Здесь у вас есть итеративный txns и функция get_price_with_tax(). Вы передаете оба этих аргумента в map() и сохраняете результирующий объект в final_prices.

Вы можете легко преобразовать этот объект карты в список с помощью функции list().

Абстракция списка

List Comprehension — Абстракция списков или списковое включение или генератор списков.

Третий способ создавать списки это абстракция списков.

С помощью этого элегантного похода можно переписать

всего в одну строку:

>>> squares = [i * i for i in range(10)
>>> squares

Подробнее про этот способ вы можете прочитать в статье

«List Comprehension в Python»

Маркированный список.

Маркированный (неупорядоченный) список в HTML определяется тегом <ul> (Unordered List Element). Каждый элемент списка должен начинаться с тега <li> (сокращенное от английского list item — элемент списка).

По умолчанию, маркированные списки отображаются на веб-странице в виде списка, начинающегося с маленького чёрного круга.

Давайте рассмотрим примеры использования:

<!DOCTYPE html>
<html>
	<head>
		<title>Пример использования элемента <ul></title>
	</head>
	<body>
		<ul>
			<li>Светлое</li>
			<li>Тёмное</li>
			<li>Пятница</li>
		</ul>
	</body>
</html>

Выглядеть на странице это будет соответственно так:

Светлое
Тёмное
Пятница

Забегая вперед, скажу, что каждый элемент HTML имеет стиль по умолчанию. Изменение стиля по умолчанию в HTML элементе может быть сделано с использованием глобального атрибута style.
Более подробно этот атрибут будет рассмотрен в следующей статье «HTML стили».

Для изменения типа маркера (стиля) вы можете воспользоваться свойством CSS list-style-type, чтобы определить стиль маркера.
Возможные значения свойства:

Атрибут	Значение
list-style-type:none	Убирает маркер.
list-style-type:disc	Маленький черный круг. Это значение по умолчанию.
list-style-type:circle	Круг пустой внутри.
list-style-type:square	Маркер в виде квадрата.

Ниже приведен пример использования стилей CSS внутри маркированного списка:

<!DOCTYPE html>
<html>
	<head>
		<title>Пример изменения типа маркера маркированного списка</title>
	</head>
	<body>
		<ul style = "list-style-type:none">  <!-- маркер отсутствует -->
			<li>Первый пункт</li>
			<li>Второй пункт</li>
			<li>Третий пункт</li>
		</ul>
		<ul style = "list-style-type:disc">  <!-- маленький черный круг -->
			<li>Первый пункт</li>
			<li>Второй пункт</li>
			<li>Третий пункт</li>
		</ul>
		<ul style = "list-style-type:circle">  <!-- круг пустой внутри -->
			<li>Первый пункт</li>
			<li>Второй пункт</li>
			<li>Третий пункт</li>
		</ul>
		<ul style = "list-style-type:square">  <!-- маркер в форме квадрата -->
			<li>Первый пункт</li>
			<li>Второй пункт</li>
			<li>Третий пункт</li>
		</ul>		
	</body>
</html>

Результат нашего примера:

Рис. 15 Маркированные списки.

Обращаю Ваше внимание, что допускается формировать маркированные (неупорядоченные) списки, вложенные в другие маркированные списки (внутри элемента списка ) при этом элементы вложенного списка по умолчанию будут с пустым кругом внутри, a последующие будут с квадратом:

Первый пункт
- Первый пункт
  - Первый пункт
    - Первый пункт
    - Второй пункт
    - Третий пункт
  - Второй пункт
  - Третий пункт
- Второй пункт
- Третий пункт
Второй пункт
Третий пункт

# Кортежи

Кортеж тоже является последовательностью и создается элементами разделёнными запятыми:

123

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

123

При определении кортежа с одним элементом запятая за ним обязательна.

1234567

Пропуск запятой означает что задано обычное значение, не кортеж.

123456

Кортежи индексируются как списки, но неизменямы.

1234567

В тоже время, если элементом кортежа является изменяемые объект, такой как список, то он может быть изменен.

123456

Копировать список

# Copy

l = [100, 200, 300, 400, 500]

t = l
print(«\n# t = l»)
print(«t is l =», t is l) # True
r = l
print(«\n# r = l»)
print(«r is l = «, r is l) # False
print(«r == l = «, r == l) # True

u = l.copy()
print(«\n# u = l.copy()»)
print(«u is l = «, u is l) # False

v = list(l)
print(«\n# v = list(l)»)
print(«v is l = «, v is l) # False

# t = l
t is l = True

# r = l
r is l = False
r == l = True

# u = l.copy()
u is l = False

# v = list(l)
v is l = False

a = [ [1, 2], [3, 4] ]
b = a
print(a is b) # False
print(a == b) # True

print(a[]) #
print(b[]) #

print(a[] is b[]) # True

a[] = [8, 9]
print(a[]) #
print(b[]) #

a[1].append(5)
print(a[1]) #
print(b[1]) #

print(a) # , ]
print(b) # , ]

False
True

True

, ]
, ]

К спискам можно применять умножение

s = [ [-1, +1] ] * 5
print(s)
s[2].append(7)
print(s)

, , , , ]
, , , , ]

w = «the heihei.ru website was forked from andreyolegovich.ru in 2018 simultaneously with the topbicyle.ru website».split()

print(w)

i = w.index(‘was’)
print(i) # 3
print(w) # was

print(w.count(«the»)) # 2

print(«heihei.ru» in w) # True
print(«urn.su» not in w) # True

3
was
2
True
True

Ещё немного функций

Приведём несколько функций класса List, эффективность которых не столь высока,
по сравнению с вставкой в начало или конец списка.
Так, получение узла под номером pos (начиная с нуля) выглядит следующим образом:

List.prototype.node = function (pos)
{
   var n = this.beg.nxt;                         // бежим от начала
   while(n !== this.end && pos-- > 0)
      n = n.nxt;                                 // переходим к следующему узлу
   return n;
}

JavaScripti— vs. —i

pos—pos = pos — 1послеwhilepos > 0pos—pos .
В этом случае, сначала бы произошло уменьшение переменной, а лишь затем её сравнение с нулём.

Ещё одна функция добавляет узел с именем nm на место pos в списке (начиная с нуля),
сдвигая всё вправо:

List.prototype.insert = function (pos, nm)
{
   if(pos = this.length)                         // добавляем в конец
      return this.push(nm);

   this.length++;                                 // увеличиваем число узлов
   var n = this.node(pos-1);                      // перед вставляемым узлом
   n.nxt = { nm:nm, nxt:n.nxt};
}

Аналогична функция удаления узла на месте pos в списке (начиная с нуля) и возвращения
его поля nm:

List.prototype.remove = function (pos)
{
   if(pos = this.length)                       // удаляем из конца
      return this.pop();

   this.length--;                                 // уменьшаем число узлов
   var n = this.node(pos-1);                      // перед удаляемым узлом
   var nm = n.nxt.nm;
   n.nxt = n.nxt.nxt;
   return nm;
}

Виды списков

В курсовых работах используются списки следующих типов:

маркированные списки;
нумерованные списки;
буквенные списки;
многоуровневые списки.

Нумерованные списки

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

Короткие пункты перечня начинаются с прописной буквы и заканчиваются точкой с запятой «;».

Рисунок 1. Пример нумерованного списка

Маркированные списки

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

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

В курсовой работе лучше использовать какой-то один тип маркеров.

Рисунок 2. Пример маркированного списка

Буквенные списки

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

Если используются прописные буквы в качестве маркера, в конце ставят точку: “А.”. Прописная буква в качестве идентификатора используется, если в пункты списка включены объемные элементы текста.

Если используют строчные буквы, то после них ставят скобку: “а)”. Такой идентификатор списка применяется, если в одной позиции списка содержится небольшой объем текста.

Рисунок 3. Пример использования буквенного списка

Многоуровневые списки

Многоуровневые списки состоят из нескольких видов простых списков. Они позволяют раскрывать несколько подкатегорий в исследуемом объекте.

Оформление многоуровневого списка зависит от тех элементов, которые используются при его составлении.

На рисунке 3 показан пример многоуровневого списка с двумя типами маркеров: буквы и цифры.

Какие есть методы списков в Python?

Метод списка extends

— расширяет список, добавляя элементы переданного итерируемого объекта.

Списки также можно объединять с помощью оператора +. При этом, оператор + не изменяет список, а создает новый.

Метод списка index

— возвращает индекс первого вхождения значения. Если вводного значения нет в списке, возникнет исключение ValueError. Если указан второй аргумент, поиск начнется с указанного индекса.

Метод списка insert

— добавляет значение value непосредственно перед указанным индексом index. После вставки новое значение занимает индекс index.

Метод списка pop

— удаляет и возвращает значение по индексу index. Без аргумента index удаляет и возвращает последний элемент списка.

Метод списка remove

— удаляет первое вхождение указанного значения. Если указанного значения нет в списке, выдаётся исключение ValueError.

Метод списка sort

— сортирует список в числовом и лексическом порядке и возвращает None

Списки также можно сортировать в обратном порядке используя флаг reverse=True в методе sort().

Для сортировки списка по атрибутам элементов, можно использовать аргумент key:

Подведем итог

Мы подробно рассмотрели три относящихся к коллекциям структуры данных, а именно списки, кортежи и множества.

Списки изменяемы и упорядочены. Кортежи упорядочены, но не изменяемы. Множества не упорядочены и не изменяемы. Кроме того, множества всегда содержат только уникальные элементы, повторы не допускаются.

Вопросы для закрепления

Как вывести элемент вложенного списка по его индексу?

Посмотреть правильный ответ

Ответ: вначале нужно указать индекс вложенного списка, а затем индекс элемента внутри этого вложенного списка.

Как выглядит основная схема list comprehension?

Посмотреть правильный ответ

Ответ:
чтоделатьсэлементомциклforприкакомусловииif

Обратите внимание, если мы хотим использовать if-else схема отличается (см. пример выше)

Что такое симметричная разность двух множеств?

Посмотреть правильный ответ

Ответ: симметричная разность двух множеств включает элементы двух множеств, не являющихся для них общими.

В ноутбуке к лекции приведены ⧉.

На следующем занятии мы поговорим про словари в Питоне и на этом завершим разбор коллекций.

Нефиктивные указатели

Изменяемый объект в виде значения по умолчанию

Работа со списками

Что такое список (list) в Python?​

Вставка элементов

# Словари

Нумерованные списки

Пример: Нумерованный список

Пример: Применение атрибутов type и start.

Пример: Применение атрибута value

Как списки хранятся в памяти?​

Удаление элементов

Копировать список

Слайсы / Срезы​

Нумерованный список

Кортежи

Функция enumerate()

Просмотр элементов словаря

Распаковка кортежей

Создание кортежа через функцию zip()

Двухсторонние списки

Как создавать списки

С помощью цикла for

С помощью map()

Абстракция списка

Маркированный список.

# Кортежи

Копировать список

Ещё немного функций

Виды списков

Нумерованные списки

Маркированные списки

Буквенные списки

Многоуровневые списки

Какие есть методы списков в Python?

Метод списка extends

Метод списка index

Метод списка insert

Метод списка pop

Метод списка remove

Метод списка sort

Подведем итог

Вопросы для закрепления

Похожие записи:

Похожие записи:

Что такое список (list) в Python?

Как списки хранятся в памяти?

Слайсы / Срезы