Кабинет информатики

СТАТЬИ:

Материалы по информатике Босова 5-9 классы

Электронные учебники по информатике

Учебник-практикум по информатике для 8-9 классов
Игра — изучение программирования (обезьянка)
Электронное приложение к учебнику «Информатика» для 8 класса
Электронное приложение к учебнику «Информатика» для 9 класса
Электронное приложение к учебнику «Информатика» для 10 класса
Рабочие программы по информатике
Ссылки на бесплатное программное обеспечение
Урок «Безопасность школьников в сети Интернет»
Система программирования КуМир
Изучение программирования
Тренировочный материал для экзаменов
Изучение баз данных
Запросы на выборку в Access

Видеоуроки Microsoft Access 2010

ЕГЭ 2016 Тесты online

ЕГЭ 2015 Тесты online
Сайт с решениями задач ЕГЭ
Банк книг для подготовки к ЕГЭ
Дистанционная школа ЕГЭ и ОГЕ по информатике
Методичка ЕГЭ по информатике 2015. Теория, решение задач.
Банк олимпиадных задач
Законы алгебры логики
Задания и ключи муниципального этапа по Информатике 2015-2016 год
Редактор векторной графики OPENOFFICE DRAW
Операторы Паскаль
Pyton для начинающих
Конструктор сайтов для школьников и учителей WebNode
Создание школьного веб-сервера
Основы языка JavaScript
Online Контрольная работа «Кодирование графики и звука»

 

 

Ссылки на бесплатное программное обеспечение

OpenOffice Скачать

PDF Reader Скачать

PascalABC.NET Скачать…

Бесплатный антивирус 360 Total Security Скачать…

Бесплатный Web-редактор Скачать…

Бесплатный Web-блокнот Скачать…

Paint.NET Скачать…

Киностудия Windows Скачать…

Бесплатные мультимедиа редакторы Скачать…

Урок «Безопасность школьников в сети Интернет»

Цель урока:

Обеспечение информационной безопасности несовершеннолетних обучающихся и воспитанников путем привития им навыков ответственного  и  безопасного поведения в современной информационно-телекоммуникационной среде.

Задачи урока:

  • информировать учащихся о безопасной работе в сети Интернет;
  • изучить принципы безопасной работы в сети Интернет;
  • научить ориентироваться в информационном пространстве, способствовать ответственному использованию online-технологий;
  • сформировать у учащихся принципы информационной культуры, умение самостоятельно находить нужную информацию, пользуясь web-ресурсами;
  • воспитать дисциплинированность при работе в сети.

По окончании урока обучающиеся должны знать и уметь:

  • перечень информационных услуг сети Интернет;
  • правилами безопасной работы в сети Интернет;
  • опасности глобальной компьютерной сети;
  • ответственно относиться к использованию online-технологий;
  • работать с Web-браузером;
  • пользоваться информационными ресурсами;
  • искать информацию в сети Интернет.

 Тип урока:

Урок изучения нового материала.

Методы и формы обучения:

  • словесный (дискуссия, рассказ);
  • видео метод, наглядный (демонстрация);
  • практический;
  • частично-поисковый;
  • проблемный.

 Ссылки на web-ресурсы:

  • http: //kaspersky.ru — антивирус «Лаборатория Касперского»;
  • http://www.onlandia.org.ua/rus/ — безопасная web-зона;
  • http: //saferinternet.ru — портал Российского Оргкомитета по безопасному использованию Интернета;
  • http://www.rgdb.ru — Российская государственная детская библиотека. Этапы урока:

Проведение урока

Организация начала урока. Постановка цели урока.

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

                                                                                                                                                  

Как не стать жертвой сети Интернет? Тема нашего урока — «Безопасный Интернет». Главный вопрос урока: Как сделать работу в сети безопасной?

 Просмотр видеороликов.

 Общий обзор угроз. Рекомендации по безопасности:

http://www.youtube.com/watch?v=OBMIbkxKM6o

Безопасная работа в Интернете: анализ веб-сайтов, безопасный поиск, надежные пароли: http://www.youtube.com/watch?v=c7xp2n83Rko&list=PLbBQWyk6GY0Tu1gdl8os1aAfAxix7Urnh

Защитное ПО. Kaspersky Internet Security:

http://www.youtube.com/watch?v=Zu3FNRvjD7k&index=4&list=PLbBQWyk6GY0Tu1gdl8os1aAfAxix7Urnh

Безопасность в социальных сетях:

http://www.youtube.com/watch?v=_rhltqkftCM&list=PLbBQWyk6GY0Tu1gdl8os1aAfAxix7Urnh&index=10

  • Изучение возможностей интернета. Положительное и отрицательное.
  • Интернет имеет неограниченные возможности дистанционного образования.
  • Интернет — это глобальный рекламный ресурс.
  • Общение в Интернете — это плохо, потому что очень часто подменяет реальное общение виртуальному.
  • Интернет является мощным антидепрессантом.
  • В Интернете можно узнать сведения о человеке (место проживания и адрес электронной почты, номер мобильного телефона).

Опасности сети Интернет — дискуссия по видеоматериалу.

 Учащиеся отвечают на вопросы учителя.

Основополагающий вопрос

  1. Как обеспечить информационную безопасность школьника?

Проблемные вопросы

  1. Чего больше в Интернете для школьника: полезного или вредного? Опасный или безопасный Интернет?

Учебные вопросы

  1. Какие возможности безопасного использования Интернет?
  2. Какие опасности подстерегают учащихся в Интернете?

Просмотр видеоролика: проблема подросткового и детского суицида в современном обществе.

http://www.youtube.com/watch?v=y37Ax5TPc3s&feature=related.

Практическая работа.

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

Internet Explorer, Mozilla Firefox, Opera, Google Chrome.
Настройка параметров антивируса и сетевого экрана системы.

Изучение информационных ресурсов:

  • http: //kaspersky.ru — антивирус «Лаборатория Касперского»;
  • http://www.onlandia.org.ua/rus/ — безопасная web-зона;
  • http: //saferinternet.ru — портал Российского Оргкомитета по безопасному использованию Интернета;
  • http://www.rgdb.ru — Российская государственная детская библиотека.

Безопасная работа с электронной почтой. Изучение электронного ресурса:

http://virkey.ru/councils/69-safetyemail

Безопасность работы в социальных сетях. Изучение информационного ресурса:

http://www.microsoft.com/ru-ru/security/online-privacy/social-networking.aspx

Подведение итогов:

Учитель просит обучающихся сформулировать правила безопасной работы.

Обсуждение найденной информации. Какие правила безопасной работы выбрали обучающиеся, посещая web-сайты?

Закрепление изученного материала.

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

Современный Интернет — это не только обширная, но и настраиваемая среда обитания! В нем хорошо тому, кто может обустроить в нем собственное пространство и научиться управлять им. Записывайте свои впечатления в блог, создавайте галереи своих фотографий и видео, включайте в друзья людей, которым вы доверяете. Тогда вместо бессмысленного блуждания по сети ваше Интернет-общение будет приносить пользу.

Домашнее задание.

 Дать определение понятию «информационная безопасность».

Составить информационный лист «Моя безопасная сеть».

Информационная безопасность — игры для детей от Microsoft

Бесконечный лес

Бескон лес - копия

Новые друзья Ани

Аня

Римская группа

Римская группа

Конфликты и происшествия

Конфликты

 Изучение программирования

 

Изучение баз данных

Тема урока:

Создание базы данных в СУБД Access.

 

Базы данных – таблицы.

Окружающий мир состоит из объектов. Объект – это часть ОМ, воспринимаемая человеком как единое целое. Объекты ОМ характеризуются параметрами и свойствами. Из множества объектов окружающего мира можно выделить объекты, обладающие одинаковыми свойствами. Такие объекты можно объединить в отдельные классы.

Класс объектов – это совокупность объектов обладающих одинаковыми свойствами.

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

Пример: рыбы, млекопитающие, земноводные можно определить в ПО животные;

Ученики, учителя, предметы можно объединить в ПО Школа.

Значение параметров и свойств объекта называются данными об объекте.

Структурирование данных – это процесс, приводящий к определённой форме записи данных об объектах одного класса.

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

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

Базы данных могут иметь разные модели данных. Модель данных – это совокупность взаимосвязанных по определённому типу данных. Различают 3 модели данных.

  • Иерархическую модель данных;
  • Сетевая модель данных;
  • Реляционная модель данных.

 

Чтобы составить базу данных необходимо:

  1. Выбрать предметную область;
  2. Поставить цель изучения;
  3. Разбить предметную область на классы объектов;
  4. Исходя из цели изучения, выбрать для классов перечень необходимых параметров и свойств;
  5. Выбрать модель данных.

Иерархическая модель

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

Сетевая модель

Рассмотрим класс объектов ученики. Цель изучения увлечения:

Реляционная модель данных

Возьмём класс объектов ученики, поставим цель изучения — успеваемость:

№ п/п

Фамилия

Средняя оценка

По предметам

Поведение

Работа

На уроке

Ведение записей

Участие

Во внеклассной работе

1

Петров

4,0

Хорошее

4

5

Участвует

2

Иванов

3,5

Удовлетворительное

4

3

Участвует

3

Сидоров

4,5

Хорошее

4

5

Не участвует

 

 

Microsoft Access 2010

Пример создания базы данных

Основные элементы интерфейса

Заполнение таблиц базы данных

 

Операторы Паскаль

Цель урока: закрепление основных операторов Паскаль.

Оператор вывода на экран:
Write(ln)(переменная);

Оператор ввода:
Read(ln)(переменная);

Оператор присваивания:
“:=” a:=b+c

Составной оператор:
Begin
<Другие операторы>
End.

Условный оператор
IF <условие1> then  <оператор1> ELSE <оператор2>;

Пример:
Даны два числа. Вывести на экран то из них, которое больше.
Код:
1.    program MaxOfTwo;
2.    var
3.      a, b: integer;  
4.    begin
5.      readln(a, b);
6.      if a > b then begin
7.        writeln(a)
8.      end
9.      else begin
10.        writeln(b)
11.      end
12.    end.

Оператор выбора
Case  <Анализируемая переменная> of
<Знач.1>: <Оператор1>;
<Знач.2>: <Оператор2>;
………………………………………
<Знач.N>: <Оператор N>;

Операторы цикла
For <Параметр цикла>:=<Нач. знач.> To <Кон. Знач.> do <Оператор>;
While <Условие> do <Оператор>;
Repeat <Операторы> until <Условие>;  

Пример:
Дано натуральное число. Вывести на экран все натуральные числа до заданного включительно.
Код:
1.    program FromOneToN;
2.    var
3.      i, n: word;
4.    begin
5.      readln(n);
6.      for i := 1 to n do begin
7.        write(i, ‘ ‘)
8.      end
9.    end.

IV.    Повторим:

Основные типы данных среды:

Типы
Структура программы:

стру

Язык программирования Pyton

Python — современный язык программирования, работающий на всех распространенных операционных системах для настольных компьютеров. Язык программирования Питон разрабатывается чуть более 20 лет.

Почему именно Pyton? — простота и популярность!!!

u062ctb4ae3y5y64x0po

Установка Pyton

Дистрибутивы для установки:

Windows http://www.activestate.com/activepython/downloads

После установки необходимо установить интегрированную среду:

Установка интегрированной среды разработки

Для удобства разработки кода программисты используют среды разработки (IDE).

Для обучения программированию на языке Питон рекомендуется среда разработки Wing IDE 101.

Wing IDE 101

Дистрибутив для Windows: http://wingware.com/pub/wingide-101/5.0.9/wingide-101-5.0.9-1.exe

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

Большинство школьных олимпиад по информатике поддерживают язык Python. C 2015 года в текстах задач ЕГЭ примеры приводятся также и на языке Python. 

Практика показывает, что задания ЕГЭ по информатике, в которых требуется написать программу, существенно проще решать с использованием языка Python, чем классических языков Бейсик, Паскаль, C/C++.

Основные принципы синтаксиса языка Python

  1. Конец строки является концом инструкции (точка с запятой не требуется).
    Пример
    a = 5
    b = 3
    print(a + b)
  2. Вложенные инструкции объединяются в блоки по величине отступов. Отступ может быть любым, главное, чтобы в пределах одного вложенного блока отступ был одинаков. 
    Пример
    if a == 5:
            print(‘yes’)
            a += 1

Идентификаторы Pyton

Идентификаторы — это имена переменных или функций.

Идентификатор обязательно есть у каждой переменной, функции, объекта и т.п. Идентификаторы в Питоне не ограничены по длине и чувствительны к регистру. То есть А и а — это разные имена переменных или функций.

В идентификаторах допустимы только символы от «A» до «Z» в верхнем и нижнем регистре, подчеркивание «_» и, кроме первого символа идентификатора, цифры от «0» до «9».

Например, __aAb12_as111_1_4_5 — корректный идентификатор, а 1z — некорректный, т.к. начинается с цифры.

Ключевые слова

Следующие идентификаторы являются зарезервированными или ключевыми словами языка и не могут быть использованы как обычные идентификаторы (имена переменных или функций).

False      class      finally    is     return  None   continue   for   lambda     try  True       def        from       nonlocal   while   and        del        global     not        with as         elif       if         or         yield   assert     else       import     pass   break      except     in         raise

Переменные в Python

Переменную в Python создать очень просто — нужно присвоить некоторому идентификатору значение при помощи оператора присваивания «=»

Пример

a = 10
b = 3.1415926
c = «Hello»
d = [1, 2, 3]

В этом примере используются четыре переменные:

  • переменная a хранит значение типа int (целое число),
  • переменная b — типа float (действительное число),
  • переменная c — типа str (строка),
  • переменная d — типа list (список, в данном случае из трех целых чисел).

Никакого специального объявления переменных не требуется, первое присваивание переменной значения и является ее объявлением. Идентификатор в Python является «ссылкой» на хранимые в памяти данные.

Python — язык с динамической типизацией: каждая переменная в каждый момент времени имеет определенный тип, но этот тип может меняться по ходу выполнения программы, достаточно просто присвоить ей новое значение другого типа.

Типы данных Pyton

В языке Python выделяют несколько типов данных: целые числа, числа с плавающей точкой(вещественные), строки, логический тип

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

Целые числа:

Целое число в Python имеет тип int. Оно записывается как последовательность цифр, перед которой также может стоять знак минус.

Основные операции с целыми числами

  • A + B — сумма;
  • A — B — разность;
  • A * B — произведение;
  • A / B — частное, (результатом этого действия является вещественное число, даже если A нацело делится на B);
  • A % B — взятие остатка от деления A на B;
  • A // B — взятие целой части от деления A на B
  • A ** B — возведение в степень.

Приоритеты операций

Приоритеты операций в Python совпадают с приоритетом операций в математике, а именно:

  1. Выполняются возведения в степень справа налево, то есть 3 ** 3 ** 3 это 3 ** (3 ** 3).
  2. Выполняются унарные минусы (отрицания).

Вещественные числа:

 Вещественное число в Python имеет тип float. Оно записывается как последовательность цифр, перед которой также может стоять знак минус. В качестве разделителя целой и дробной части используется точка.

Основные операции с целыми числами те же что и с целыми числами.

Строки:

Строки в Python имеют тип str. Строкой называется последовательность символов: букв, цифр, знаков препинания и т.д.

Основные операции со строками

  • A + B — конкатенация (строка  B приписывается к строке A);
  • A * n — повторение n раз, значение n должно быть целого типа.

Обмен переменных значениями в Pyton

В Python есть особый и при этом универсальный способ обмена переменных значениями.

(a,b) = (b,a)

Этот способ используется очень часто из-за своей прозрачности.

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

Ввод данных в Pyton

Для считывания строки со стандартного ввода используется функция input(), которая считывает строку с клавиатуры и возвращает значение считанной строки, которое сразу же можно присвоить переменным:

a = input()
b = input()

Правда, функция input возвращает текстовую строку. Если нужно сделать так, чтобы переменные имели целочисленные значения, то сразу же после считывания выполним преобразование типов при помощи функции int, и запишем новые значения в переменные a и b:

a = int(a)
b = int(b)

Лучше объединить считывание строк и преобразование типов, если вызывать функцию int для того значения, которое вернет функция input():

a = int(input())
b = int(input())

Сложнее считать значения переменных, если они записаны в отдельной строке. Здесь нужно применить к считанной строке метод split(), который разделяет строку на части по одному или нескольким пробелам (а также табуляциям и др. пробельным символам). Затем результат выполнения этой функции присвоим двум или нескольким переменным. Например, если в строке вводятся два числа через пробел, то считать их можно так:

a, b = input().split()
a = int(a)
b = int(b)

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

a, b, c = input().split()

Можно также сразу же преобразовать считанные значения в числовой тип (например, int), если воспользоваться функцией map, которая применяет к каждому элементу списка заданную функцию (для преобразования к типу int нужно, соответственно, задать функцию int для применения к каждому элементу). Для начала можно просто запомнить эту конструкцию:

a, b, c = map(int, input().split())

 Вывод данных в Pyton

Для вывода данных используется функция print, которая может выводить не только значения переменных, но и значения любых выражений. Например, допустима запись print(2 + 2 * 2). Также при помощи функции print можно выводить значение не одного, а нескольких выражений, для этого нужно перечислить их через запятую:

a = 1
b = 2
print(a, ‘+’, b, ‘=’, a + b)
 

В данном случае будет напечатан текст 1 + 2 = 3: сначала выводится значение переменной a, затем строка из знака “+”, затем значение переменной b, затем строка из знака “=”, наконец, значение суммы a + b.

Функции print можно передать специальный именованный параметр, называемый sep (от англ. separator — разделитель). По умолчанию параметр sep равен строке из одного пробела и между значениями выводится пробел. Чтобы использовать в качестве разделителя, например, символ двоеточия, нужно передать параметр sep, равный строке ‘:’:

print(a, b, c, sep = ‘:’)

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

print(a, ‘+’, b, ‘=’, a + b, sep = »)

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

print(a, b, sep = ‘\n’)

Символ обратного слэша в текстовых строках является указанием на обозначение специального символа, в зависимости от того, какой символ записан после него. Наиболее часто употребляется символ новой строки ‘\n’. А для того, чтобы вставить в строку сам символ обратного слэша, нужно повторить его два раза: ‘\\’.

Вторым полезным именованным параметром функции print является параметр end, который указывает на то, что выводится после вывода всех значений, перечисленных в функции print. По умолчанию параметр end равен ‘\n’, то есть следующий вывод будет происходить с новой строки. Этот параметр также можно исправить, например, для того, чтобы убрать все дополнительные выводимые символы можно вызывать функцию print так:

print(a, b, c, sep = », end = »)
print(d)

Значения переменных a, b, c, d будут напечатаны без пробелов в одну строку.

Преобразование типов Pyton

Иногда бывает полезно целое число записать как строку. И, наоборот, если строка состоит из цифр, то полезно эту строку представить в виде числа, чтобы дальше можно было выполнять арифметические операции с ней. Для этого используются функции, название которых совпадает с именем типа, то есть int, float, str. Например, int(‘123’) вернет целое число 123, str(123) вернет строку ‘123’, а следующая инструкция:

Функция int также поможет превратить дробное число в целое, отбросив дробную часть: int(12.3) = 12, int(-12.3) = 12.

Еще один полезный пример использования — преобразование строки в список букв:

list(‘abc’) = [‘a’, ‘b’, ‘c’] 

Также преобразование типов активно используется с функцией map и генераторами, например,

numbers = list(map(int, input().split()))

Условная конструкция в Pyton

Условная инструкция в Питоне имеет следующий синтаксис:

if Условие:
    Блок инструкций 1
else:
    Блок инструкций 2

Блок инструкций 1 будет выполнен, если Условие истинно. Если Условие ложно, будет выполнен Блок инструкций 2.

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

if x < 0:
    x = -x
print(x)

!!!Все инструкции, которые относятся к одному блоку, должны иметь равную величину отступа, то есть одинаковое число пробелов в начале строки. Рекомендуется использовать отступ в 4 пробела

Пример:

x = int(input())
y = int(input())
if x > 0:
    if y > 0: # x>0, y>0
        print(«Первая четверть»)
    else: # x>0, y<0
        print(«Четвертая четверть»)
else:
    if y > 0: # x<0, y>0
        print(«Вторая четверть»)
    else: # x<0, y<0
        print(«Третья четверть»)

В этом примере мы использовали комментарии –- текст, который интерпретатор игнорирует. Комментариями в Питоне является символ # и весь текст после этого символа до конца строки.

Операторы сравнения для логических условий

  • <  Меньше — условие верно, если первый операнд меньше второго.
  • >  Больше — условие верно, если первый операнд больше второго.
  • <=  Меньше или равно.
  • >=  Больше или равно.
  • ==  Равенство. Условие верно, если два операнда равны.
  • !=  Неравенство. Условие верно, если два операнда неравны.

Операторы сравнения в Питоне можно объединять в цепочки, например, a == b == c или 1 <= x <= 10.

Операторы для логических условий:

Проверим, что хотя бы одно из чисел a или b оканчивается на 0:

if a % 10 == 0 or b % 10 == 0: — логическое сложение ИЛИ

Проверим, что число a — положительное, а b — неотрицательное:

if a > 0 and not (b < 0): — логическое умножение И и отрицание НЕ

Или можно вместо not (b < 0) записать (b >= 0).

Каскадные условные конструкции

Условная инструкция if-elif-else (её ещё иногда называют оператором ветвления) — основной инструмент выбора в Python. Проще говоря, она выбирает, какое действие следует выполнить, в зависимости от значения переменных в момент проверки условия.

Сначала записывается часть if с условным выражением, далее могут следовать одна или более необязательных частей elif, и, наконец, необязательная часть else. Общая форма записи условной инструкции if выглядит следующим образом:

Пример:

a = int(input())
if a < -5:
    print('Low')
elif -5 <= a <= 5:
    print('Mid')
else:
    print('High')

Трехместное выражение if/else

Следующая инструкция:

if X:
    A = Y
else:
    A = Z

довольно короткая, но, тем не менее, занимает целых 4 строки. Специально для таких случаев и было придумано выражение if/else:

A = Y if X else Z

Решение квадратного уравнения
# Решение квадратного уравнения вида ax2+bx+c=0 
import math 
print('Введите через пробел корни уравнения а,b,с')
a, b, c=map(float,input().split())
d=b**2-4*a*c
print('d=', int(d))
if d>0:
    x1=(-b-math.sqrt(d))/2*a
    x2=(-b+math.sqrt(d))/2*a
    print('Корни уравнения:','x1=',int(x1),'x2=',int(x2))
elif d==0:
    x1=-b/2*a
    print('Корни уравнения равны x1=x2=',int(x1))
else:
    print('корней нет')

Инструкции управления циклом в Pyton

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

i = 1
while i <= 10:
    print(i)
    i += 1
else:
    print(‘Цикл окончен, i =’, i)

Казалось бы, никакого смысла в этом нет, ведь эту же инструкцию можно просто написать после окончания цикла. Смысл появляется только вместе с инструкцией break, использование которой внутри цикла приводит к немедленному прекращению цикла, и при этом не исполняется ветка else. Разумеется, инструкцию break осмысленно вызывать только из инструкции if, то есть она должна выполняться только при выполнении какого-то особенного условия.

Другая инструкция управления циклом — continue (продолжение цикла). Если эта инструкция встречается где-то посередине цикла, то пропускаются все оставшиеся инструкции до конца цикла, и исполнение цикла продолжается со следующей итерации.

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

Цикл for в Pyton

Цикл for, также называемый циклом с параметром, в языке Питон богат возможностями. В цикле for указывается переменная и множество значений, по которому будет пробегать переменная. Множество значений может быть задано списком, кортежем, строкой или диапазоном.

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

i = 1
for color in ‘red’, ‘orange’, ‘yellow’, ‘green’, ‘cyan’, ‘blue’, ‘violet’:
    print(i, ‘-th color of rainbow is ‘, color, sep = »)
    i += 1

В этом примере переменная color последовательно принимает значения ‘red’, ‘orange’ и т.д. В теле цикла выводится сообщение, которое содержит название цвета, то есть значение переменной color, а также номер итерации цикла – число, которое сначала равно 1, а потом увеличивается на один (инструкцией i += 1 с каждым проходом цикла). Где sep — разделитель между выводимыми значениями (по умолчанию — пробел).

Результат работы программы:

1-th color of rainbow is red
2-th color of rainbow is orange
3-th color of rainbow is yellow
4-th color of rainbow is green
5-th color of rainbow is cyan
6-th color of rainbow is blue
7-th color of rainbow is violet

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

for i in 1, 2, 3, ‘one’, ‘two’, ‘three’:
    print(i)

При первых трех итерациях цикла переменная i будет принимать значение типа int, при последующих трех — типа str.

Функция range

Как правило, циклы for используются либо для повторения какой-либо последовательности действий заданное число раз, либо для изменения значения переменной в цикле от некоторого начального значения до некоторого конечного.

Для повторения цикла некоторое заданное число раз n можно использовать цикл for вместе с функцией range:

for i in range(n):
    Тело цикла

В качестве n может использоваться числовая константа, переменная или произвольное арифметическое выражение (например, 2 ** 10). Если значение n равно нулю или отрицательное, то тело цикла не выполнится ни разу.

Если задать цикл таким образом:

for i in range(a, b):
    Тело цикла

то индексная переменная i будеть принимать значения от a до b – 1, то есть первый параметр функции range, вызываемой с двумя параметрами, задает начальное значение индексной переменной, а второй параметр — значение, которая индексная переменная принимать не будет. Если же a≥b, то цикл не будет выполнен ни разу. Например, для того, чтобы просуммировать значения чисел от 1 до n можно воспользоваться следующей программой:

sum = 0
for i in range(1, n + 1):
    sum += i

В этом примере переменная i принимает значения 1, 2, …, n, и значение переменной sum последовательно увеличивается на указанные значения.

Наконец, чтобы организовать цикл, в котором индексная переменная будет уменьшаться, необходимо использовать функцию range с тремя параметрами. Первый параметр задает начальное значение индексной переменной, второй параметр — значение, до которого будет изменяться индексная переменная (не включая его!), а третий параметр — величину изменения индексной переменной. Например, сделать цикл по всем нечетным числам от 1 до 99 можно при помощи функции range(1, 100, 2), а сделать цикл по всем числам от 100 до 1 можно при помощи range(100, 0, -1).

Более формально, цикл for i in range(a, b, d) при d > 0 задает значения индексной переменной i = a, i = a + d, i = a + 2 * d и так для всех значений, для которых i < b. Если же d < 0, то переменная цикла принимает все значения i > b.

Пример — нахождение среднего арифметического n чисел:

print(‘Введите количество цифр’)
n=int(input())
print(‘Вводите цифры поочереди’)
sum=0
for i in range(n):
     a=int(input())
     sum=sum+a
b=sum/n
print(‘Среднее арифметическое равно’, b)

Цикл while

Цикл while (“пока”) позволяет выполнять одну и ту же последовательность действий, пока проверяемое условие истинно.

Условие записывается до тела цикла и проверяется до выполнения тела цикла. Как правило, цикл while используется, когда невозможно заранее определить точно количество шагов.

Синтаксис цикла while в простейшем случае выглядит так:

while условие:
    блок инструкций

Например, следующий фрагмент программы напечатает на экран квадраты всех целых чисел от 1 до 10:

i = 1
while i <= 10:
    print(i)

    i += 1

Результат работы программы:

1
2
3
4
5
6
7
8
9
10

Видно, что цикл while может заменять цикл for … in range(…)

Вот еще один пример использования цикла while для определения количества цифр натурального числа n:

n = int(input())
length = 0

while n > 0:
    n //= 10
    length += 1

В этом цикле мы отбрасываем по одной цифре числа, начиная с конца, что эквивалентно целочисленному делению на 10 (n //= 10), при этом считаем в переменной length, сколько раз это было сделано.

Впрочем, в языке Питон есть и другой способ решения этой задачи: length = len(str(i))

Функции в Pyton

Функции в Python создаются с помощью инструкции def. Это действие создает объект функции и присваивает ему имя, которое становится ссылкой на объект-функцию.

Пример определения функции:

def MyFirstFunction(arg1, arg2, arg3):
    return arg1 + arg2 + arg3

Здесь MyFirstFunction — это имя функции, используемое как для ее определения, так и для ее вызова.

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

В теле функции присутствует (их может быть несколько) инструкция return (может и не быть), которая прерывает выполнение функции возвращает значение в основную ветку программы.

Вызов функции и возврат значения

Пример вызова функции:

x = MyFirstFunction(10, 2, 5)

Передача параметров в функцию

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

При вызове функции в скобках указывается нужное количество переменных или выражений, значения которых будут переданы функции в качестве параметров. Если у функции нет параметров, скобки (пустые) при вызове все равно нужны.

Полиморфизм функций в Python

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

Это важнейшее отличие философии языка Python от языков программирования со статической типизацией, таких как C++ и Java: программный код на языке Python не делает предположений о конкретных типах данных. В противном случае он сможет работать только с теми типами данных, которые ожидались на момент его написания, и он не будет поддерживать объекты других совместимых типов, которые могут быть созданы в будущем. Проверку типа объекта можно выполнить с помощью таких средств, как встроенная функция type, но в этом случае программный код потеряет свою гибкость.

В языке Питон отсутствует полиморфизм функций в модели С++. Разные функции должны иметь разные имена.

Адекватной заменой является полиморфизм по типу объекта, для которого вызывается функция, что требует перенесения функции в объект.

Задача: Будет ли ошибочным следующий код?:

def f(x):
    return x 
* 2

print(f(1) * f(«2»))

print(f(3.) * f(f(4)))

Результат работы программы
2222
96.0

Решение

Нет, не будет.

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

Будет ли ошибочным следующий код:

def f(x):
    return x

def f(x):
    return 2 * x

def f(x):
    return 3 * x

print(f(5))

Результат работы программы:
15

Решение

Нет, не будет. При этом первые две функции, поскольку их имена более недоступны в пространстве имен, фактически перестают существовать.

При вызове print(f(5)) будет вызвана последняя функция, результат вычислений будет равен 15.

Локальные и глобальные переменные в Python

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

def f():
    print(a)
a = 1
f()

Здесь переменной a присваивается значение 1, и функция f печатает это значение, несмотря на то, что выше функции f эта переменная не инициализируется. Но в момент вызова функции f переменной a уже присвоено значение, поэтому функция f может вывести его на экран.

Такие переменные (объявленные вне функции, но доступные внутри функции) называются глобальными.
Но если инициализировать какую-то переменную внутри функции, использовать эту переменную вне функции не удастся.

Например:

def f():
    a = 1
f()
print(a)

Получим NameError: name ‘a’ is not defined. Такие переменные, объявленные внутри функции, называются локальными. Эти переменные становятся недоступными после выхода из функции.

Интересным получится результат, если попробовать изменить значение глобальной переменной внутри функции:

def f():
    a = 1
    print(a)
a = 0
f()
print(a)

Будут выведены числа 1 и 0. То есть несмотря на то, что значение переменной a изменилось внутри функции, то вне функции оно осталось прежним! Это сделано в целях “защиты” глобальных переменных от случайного изменения из функции.

Более формально: интерпретатор Питон считает переменную локальной, если внутри нее есть хотя бы одна инструкция, модифицирующая значение переменной (это может быть оператор =, += и т.д., или использование этой переменной в качестве параметра цикла for,) то эта переменная считается локальной и не может быть использована до инициализации. При этом даже если инструкция, модицифицирующая переменную никогда не будет выполнена: интерпретатор это проверить не может, и переменная все равно считается локальной. Пример:

def f():
    print(a)
    if False:
        a = 0
a = 1
f()

Возникает ошибка: UnboundLocalError: local variable ‘a’ referenced before assignment.

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

def f():
    global a
    a = 1
    print(a)
a = 0
f()
print(a)

В этом примере на экран будет выведено 1 1, так как переменная a объявлена, как глобальная, и ее изменение внутри функции приводит к тому, что и вне функции переменная будет доступна.

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

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

return (a, b)

Тогда результат вызова функции тоже нужно присваивать кортежу:

(n, m) = f(a, b)

Области видимости переменных в Python

По умолчанию все имена, значения которым присваиваются внутри функции, ассоциируются с пространством имен этой функции. Это означает, что:

  • Имена, определяемые внутри инструкции def, видны только программному коду внутри инструкции def. К этим именам нельзя обратиться за пределами функции.
  • Имена, определяемые внутри инструкции def, не вступают в конфликт с именами, находящимися за пределами инструкции def, даже если и там и там присутствуют одинаковые имена. Имя X, которому присвоено значение за пределами данной инструкции def (например, в другой инструкции def или на верхнем уровне модуля), полностью отлично от имени X, которому присвоено значение внутри инструкции def.

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

Значения переменным могут быть присвоены в трех разных местах, соответствующих трем разным областям видимости:

  • Если присваивание переменной выполняется внутри инструкции def, переменная является локальной для этой функции.
  • Если присваивание производится в пределах объемлющей инструкции def, переменная является нелокальной для этой функции.
  • Если присваивание производится за пределами всех инструкций def, она является глобальной для всего файла.

Правила видимости имен

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

Функции образуют локальную область видимости, а модули – глобальную. Эти две области взаимосвязаны между собой следующим образом:

  • Каждый вызов функции создает новую локальную область видимости.
  • Операция присваивания создает локальные имена, если они не были объявлены глобальными или нелокальными. По умолчанию все имена, которым присваиваются значения внутри функции, помещаются в локальную область видимости (пространство имен, ассоциированное с вызовом функции).

Порядок сопоставления имен:

  1. локальные
  2. нелокальные (внутри объемлющей инструкции def)
  3. глобальные (в пространстве имен модуля)
  4. встроенные (предопределенные имена в модуле builtins)

Схема разрешения имен в языке Python иногда называется правилом LEGB, название которого состоит из первых букв названий областей видимости.

Например:

X = 88 # Глобальная переменная X
def func():

    global X

    X = 99 # Глобальная переменная X: за пределами инструкции def

func()

print(X) # Выведет 99

Итак, инструкция global обеспечивает возможность изменения переменных в модуле из функций. Существует также родственная ей инструкция nonlocal, которая обеспечивает возможность изменения переменных в объемлющих функциях.

Строки в Pyton

Строка состоит из последовательности символов.
Тип строки str.

>>> type(‘2’)

<class ‘str’>

В языке Питон нет отдельного символьного типа. Символ — это просто строка длины 1.

Строка считывается со стандартного ввода функцией input().

Для двух строк определена операция сложения (конкатенации), также определена операция умножения строки на число.

>>> ‘Hello’ + ‘World’ 

‘HelloWorld’ 

>>> ‘ABC’ * 10  

‘ABCABCABCABCABCABCABCABCABCABC’

Узнать количество символов (длину строки) можно при помощи функции len (от англ. length — длина):

>>> s = ‘Hello’

>>> print(len(s))

5

Длина строк в Питоне не ограничена или, строго говоря, ограничена объемом выделенной оперативной памяти.

Литералы строк в Python

Литералы строк могут быть записаны в апострофах:

‘spa»m’

В кавычках:

«spa’m»

В тройных апострофах или тройных кавычках:

»’spam»’, «»»spam»»»

Экранированные последовательности:

«s\tp\na\0m»

Неформатированные строки (\символ не воспринимается как управляющая последовательность):

r»C:\new\test\0012″

Как строки байтов (отдельный тип bytes — каждый символ занимает 1 байт):

b’1wd’

Если в строке нужно вывести обратную косую черту, то ее нужно повторить дважды:

‘Symbol \\ can be also used.’

В неформатированных строках не рассматриваются экранированные символы, а все воспринимается как есть:

s=r»C:\new\test\0012″

print(s)

выведет C:\new\test\0012

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

s=»C:\\new\\test\\0012″

Строка из нескольких подряд идущих литералов будет неявно конкатенирована даже при отсутствии знака +:

s = ‘Infinite’ «blue» ‘sky’

Строки в тройных кавычках могут содержать несколько строк текста. Пробелы от начала строки входят в текст:

s = «»»Happy birthday to you,

           My darling Findus!

                     Your hostess.»»»

Можно добиться того же эффекта и в одинарных кавычках, оставляя в конце каждой строки обратный слэш (но рекомендуется так не делать; после \ не должно быть пробела в конце строки):

s = «Happy birthday to you,\

My darling Findus!\

Your hostess.»

Экранированные символы в Python

Экранированные последовательности, также называемые escape-последовательности, могут состоять из одного или нескольких символов после обратной косой черты:

\ в самом конце строки Игнорируется, строка продолжается на новой строке
\\ Сам символ обратного слеша (остается один символ \)
\’ Апостроф (остается один ‘)
Кавычка (остается один символ «)
\n Новая строка (перевод строки)
\r Возврат каретки
\t Горизонтальная табуляция
\u… 16-битовый символ Юникода в 16-ричном представлении
\U… 32-битовый символ Юникода в 32-ричном представлении
\x… 16-ричное значение
\o… 8-ричное значение
\0 Символ Null (не признак конца строки)

Срезы строк в Pyton

Срез (slice) — извлечение из данной строки одного символа или некоторого фрагмента (подстроки).

Есть три формы срезов. Самая простая форма среза: взятие одного символа строки, а именно, S[i] — это срез, состоящий из одного символа, который имеет номер i, при этом считая, что нумерация начинается с числа 0. То есть если S = ‘Hello’, то S[0]==’H’, S[1]==’e’, S[2]==’l’, S[3]==’l’, S[4]==’o’.

Номера символов в строке (а также в других структурах данных: списках, кортежах) называются индексом.
Если указать отрицательное значение индекса, то номер будет отсчитываться с конца, начиная с номера -1. То есть

S[-1]==’o’, S[-2]==’l’, S[-3]==’l’, S[-4]==’e’, S[-5]==’H’.

Или в виде таблицы:

Строка S

H

e

l

l

o

Индекс

S[0]

S[1]

S[2]

S[3]

S[4]

Индекс

S[-5]

S[-4]

S[-3]

S[-2]

S[-1]

Если же номер символа в срезе строки S больше либо равен len(S), или меньше, чем -len(S), то при обращении к этому символу строки произойдет ошибка IndexError: string index out of range.

Срез с двумя параметрами: S[a:b] возвращает подстроку из b-a символов, начиная с символа c индексом a, то есть до символа с индексом b, не включая его. Например, S[1:4]==‘ell’, то же самое получится если написать S[-4:-1]. Можно использовать как положительные, так и отрицательные индексы в одном срезе, например, S[1:-1] — это строка без первого и последнего символа (срез начинается с символа с индексом 1 и заканчиватеся индексом -1, не включая его).
При использовании такой формы среза ошибки IndexError никогда не возникает. Например, срез S[1:5] вернет строку ‘ello’, таким же будет результат, если сделать второй индекс очень большим, например, S[1:100] (если в строке не более 100 символов).

Если опустить второй параметр (но поставить двоеточие), то срез берется до конца строки. Например, чтобы удалить из строки первый символ (его индекс равен 0, то есть взять срез, начиная с символа с индексом 1), то можно взять срез S[1:], аналогично если опустить первый параметр, то срез берется от начала строки. То есть удалить из строки последний символ можно при помощи среза S[:-1]. Срез S[:] совпадает с самой строкой S.

Если задать срез с тремя параметрами S[a:b:d], то третий параметр задает шаг, как в случае с функцией range, то есть будут взяты символы с индексами a, a+d, a+2*d и т.д. При задании значения третьего параметра, равному 2, в срез попадет кажый второй символ, а если взять значение среза, равное -1, то символы будут идти в обратном порядке.

Примеры срезов

На вводе дана строка.

s = input()

Выведем третий символ этой строки.

print(s[2])

Выведем предпоследний символ этой строки.

print(s[-2])

Выведем первые пять символов этой строки.

print(s[0:5])

Выведем всю строку, кроме последних двух символов.

print(s[:-2])

Выведем все символы с четными индексами (считая, что индексация начинается с 0, поэтому символы выводятся начиная с первого).

print(s[::2])

Выведем все символы с нечетными индексами, то есть начиная со второго символа строки.

print(s[1::2])

Выведем все символы в обратном порядке.

print(s[::-1])

Выведем все символы строки через один в обратном порядке, начиная с последнего.

print(s[::-2])

Коды символов в Pyton

В настоящее время для кодирования символов используется стандарт Unicode(16 бит на 1 символ), последняя версия 6.0 которого (октябрь, 2010) включает свыше 109000 различных символов. Естественно, для кодирования Unicode-символов недостаточно одного байта на символ, поэтому используются многобайтовые кодировки (для представления одного символа необходимо несколько байт).

Язык программирования Python — современный язык, поэтому он работает исключительно с Unicode-символами (это относится к версии 3 языка).

Код символа можно определить при помощи функции ord. Эта функция получает на вход строку, которая должна состоять ровно из одного символа. Функция возвращает код этого символа. Например, ord(‘A’) вернет число 65.

Обратная функция получения по числовому коду его номера называется chr.

Сравнение символов

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

Также в питоне определены и операции сравнения строк, которые также сравниваются в лексикографическом порядке.

Задачи поиска, замены и удаления подстроки в строке в Python

Строка (str) в Питоне является неизменяемым объектом, поэтому удалять или заменять символы в той же самой строке невозможно.

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

Выполним обход элементов строки в цикле for:

>>> myjob = ‘hacker’
>>> for c in myjob:
>>>    print(c, end=’ ‘)
>>>
h a c k e r

Проверим факт наличия символа или подстроки при помощи оператора in:

>>> ‘k’ in myjob
True
>>> ‘z’ in myjob
False
>>> ‘spam’ in ‘abcspamdef’
True
 

МЕТОДЫ FIND И RFIND

Метод find находит в данной строке (к которой применяется метод) данную подстроку (которая передается в качестве параметра). Функция возвращает индекс первого вхождения искомой подстроки. Если же подстрока не найдена, то метод возвращает значение -1. Например:

>>> S = ‘Hello’

>>> print(S.find(‘e’))

1

>>> print(S.find(‘ll’))

2

>>> print(S.find(‘L’))

-1

Аналогично, метод rfind возвращает индекс последнего вхождения данной строки (“поиск справа”).

>>> S = ‘Hello’

>>> print(S.find(‘l’))

2

>>> print(S.rfind(‘l’))

3

Если вызвать метод find с тремя параметрами S.find(T, a, b), то поиск будет осуществляться начиная с символа с номером a до символа с номером b (не включительно). Если указать только два параметра S.find(T, a), то поиск будет осуществляться, начиная с a-го элемента до конца строки. Метод S.find(T, a, b) возвращает индекс в строке S, а не индекс относительно начала среза.

МЕТОД REPLACE

Метод replace заменяет все вхождения одной строки на другую. Формат: S.replace(old, new) — заменить в строке S все вхождения подстроки old на подстроку new. Пример:

>>> ‘Hello’.replace(‘l’, ‘L’)

‘HeLLo’

Если методу replace задать еще один параметр: S.replace(old, new, count), то заменены будут не все вхождения, а только не больше, чем первые count из них.

>>> ‘Abrakadabra’.replace(‘a’, ‘A’, 2)

‘AbrAkAdabra’

МЕТОД COUNT

Подсчитывает количество вхождений одной строки в другую строку. Простейшая форма вызова S.count(T)  возвращает число вхождений строки T внутри строки S. При этом подсчитываются только непересекающиеся вхождения, например:

>>> ‘Abracadabra’.count(‘a’)

4

>>> (‘a’ * 100000).count(‘aa’)

50000

При указании трех параметров S.count(T, a, b), будет выполнен подсчет числа вхождений строки T в срез S[a:b].

Удаление подстроки

Удаление подстроки осуществляется заменой подстроки на пустую строку:

>>> ‘Bob was eating tasty plum’.replace(‘tasty’, »)
‘Bob was eating  plum’

Списки в Python

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

Для хранения таких данных можно использовать структуру данных, называемую в Питоне список (в большинстве же языков программирования используется другой термин “массив”). Список представляет собой последовательность элементов, пронумерованных от 0, как символы в строке. Список можно задать перечислением элементов списка в квадратных скобках, например, список можно задать так:

Primes = [2, 3, 5, 7, 11, 13]

Rainbow = [‘Red’, ‘Orange’, ‘Yellow’, ‘Green’, ‘Blue’, ‘Indigo’, ‘Violet’]

В списке Primes — 6 элементов, а именно,

Primes[0] == 2, Primes[1] == 3, Primes[2] == 5, Primes[3] == 7, Primes[4] == 11, Primes[5] == 13.

Список Rainbow состоит из 7 элементов, каждый из которых является строкой.

Также как и символы строки, элементы списка можно индексировать отрицательными числами с конца, например,

Primes[-1] == 13, Primes[-6] == 2.

Длину списка, то есть количество элементов в нем, можно узнать при помощи функции len, например, len(A) == 6.

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

A = []

for i in range(int(input()):

    A.append(int(input())

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

Для списков целиком определены следующие операции: конкатенация списков (добавление одного списка в конец другого) и повторение списков (умножение списка на число). Например:

A = [1, 2, 3]

B = [4, 5]

C = A + B

D = B * 3

В результате список C будет равен [1, 2, 3, 4, 5], а список D будет равен [4, 5, 4, 5, 4, 5]. Это позволяет по-другому организовать процесс считывания списков: сначала считать размер списка и создать список из нужного числа элементов, затем организовать цикл по переменной i начиная с числа 0 и внутри цикла считывается i-й элемент списка:

A = [0] * int(input())

for i in range(len(A)):

    A[i] = int(input())

Вывести элементы списка A можно одной инструкцией print(A), при этом будут выведены квадратные скобки вокруг элементов списка и запятые между элементами списка. Такой вывод неудобен, чаще требуется просто вывести все элементы списка в одну строку или по одному элементу в строке. Приведем два примера, также отличающиеся организацией цикла:

for i in range(len(A)):

    print(A[i])

Здесь в цикле меняется индекс элемента i, затем выводится элемент списка с индексом i.

for elem in A:

    print(elem, end = ‘ ‘)

В этом примере элементы списка выводятся в одну строку, разделенные пробелом, при этом в цикле меняется не индекс элемента списка, а само значение переменной (например, в цикле for elem in [‘red’, ‘green’, ‘blue’] переменная elem будет последовательно принимать значения ‘red’, ‘green’, ‘blue’.

Срезы списков в Python

Со списками, так же как и со строками, можно делать срезы. А именно:

A[i:j] срез из j-i элементов A[i], A[i+1], …, A[j-1].

A[i:j:-1] срез из i-j элементов A[i], A[i-1], …, A[j+1] (то есть меняется порядок элементов).

A[i:j:k] срез с шагом k: A[i], A[i+k], A[i+2*k],… .Если значение k<0, то элементы идут в противоположном порядке.

Каждое из чисел i или j может отсутствовать, что означает “начало строки” или “конец строки”

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

A = [1, 2, 3, 4, 5]

A[2:4] = [7, 8, 9]

Получится список, у которого вместо двух элементов среза A[2:4] вставлен новый список уже из трех элементов. Теперь список стал равен [1, 2, 3, 7, 8, 9, 5].

A = [1, 2, 3, 4, 5, 6, 7]

A[::-2] = [10, 20, 30, 40]

Получится список [40, 2, 30, 4, 20, 6, 10]. Здесь A[::-2] — это список из элементов A[-1], A[-3], A[-5], A[-7], которым присваиваются значения 10, 20, 30, 40 соответственно.

Если не непрерывному срезу (то есть срезу с шагом k, отличному от 1), присвоить новое значение, то количество элементов в старом и новом срезе обязательно должно совпадать, в противном случае произойдет ошибка ValueError.

Операции со списками в Python

x in A Проверить, содержится ли элемент в списке. Возвращает True или False
x not in A То же самое, что not(x in A)
min(A) Наименьший элемент списка
max(A) Наибольший элемент списка
A.index(x) Индекс первого вхождения элемента x в список, при его отсутствии генерирует исключение ValueError
A.count(x) Количество вхождений элемента x в список
A.sort() Сортировка списка (меняет сам список, ничего не возвращает)
sum(A) Возвращает сумму элементов в списке
A.append(x) Добавить элемент x в конец списка
A.extend(L) Добавить все элементы списка L в конец списка A

 

Генераторы списков в Pyton

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

A = [0] * n

Для создания списков, заполненных по более сложным формулам можно использовать генераторы: выражения, позволяющие заполнить список некоторой формулой. Общий вид генератора следующий:

[выражение for переменная in список]

Вот несколько примеров использования генераторов.

Создать список, состоящий из n нулей можно и при помощи генератора:

A = [0 for i in range(n)]

Создать список, заполненный квадратами целых чисел можно так:

A = [i ** 2 for i in range(n)]

Если нужно заполнить список квадратами чисел от 1 до n, то можно изменить параметры функции range на range(1, n + 1):

A = [i ** 2 for i in range(1, n + 1)]

Вот так можно получить список, заполненный случайными числами от 1 до 9 (используя функцию randint из модуля random):

A = [randint(1, 9) for i in range(n)]

А в этом примере список будет состоять из строк, считанных со стандартного ввода: сначала нужно ввести число элементов списка (это значение будет использовано в качестве аргумента функции range), потом — заданное количество строк:

A = [input() for i in range(int(input()))]

 Методы split и join для списка строк в Python

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

В этом случае строку можно считать функцией input(), после этого использовать метод строки split(), возвращающий список строк, разрезав исходную строку на части по пробелам. Пример:

A = input().split()

Если при запуске этой программы ввести строку 1 2 3, то список A будет равен [‘1’, ‘2’, ‘3’]. Обратите внимание, что список будет состоять из строк, а не из чисел. Если хочется получить список именно из чисел, то можно затем элементы списка по одному преобразовать в числа:

for i in range(len(A)):

    A[i] = int(A[i])

Используя функции языка map и list то же самое можно сделать в одну строку:

A = list(map(int, input().split()))

Если нужно считать список действительных чисел, то нужно заменить тип int на тип float.

У метода split есть необязательный параметр, который определяет, какая строка будет использоваться в качестве разделителя между элементами списка. Например, метод split(‘.’) вернет список, полученный разрезанием исходной строки по символам ‘.’. 
Используя “обратные” методы можно вывести список при помощи однострочной команды. Для этого используется метод строки join. У этого метода один параметр: список строк. В результате получается строка, полученная соединением элементов списка

A = [‘red’, ‘green’, ‘blue’]

print(‘ ‘.join(A))

print(».join(A))

print(‘***’.join(A))

выведет строки ‘red green blue’, redgreenblue и red***green***blue.

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

print(‘ ‘.join(map(str, A)))

Двумерные массивы в Python

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

A = [[1, 2, 3], [4, 5, 6]]

Здесь первая строка списка A[0] является списком из чисел [1, 2, 3]. То есть A[0][0] == 1, значение A[0][1] == 2, A[0][2] == 3, A[1][0] == 4, A[1][1] == 5, A[1][2] == 6.

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

for i in range(len(A)):
    for j in range(len(A[i]):
        print(A[i][j], end=’ ‘)
    print()

То же самое, но циклы не по индексу, а по значениям списка:

for row in A:
    for elem in row:
        print(elem, end=’ ‘)
    print()

Естественно для вывода одной строки можно воспользоваться методом join:

for row in A:
    print(‘ ‘.join(list(map(str, row))))

Используем два вложенных цикла для подсчета суммы всех чисел в списке:

S = 0
for i in range(len(A)):
    for j in range(len(A[i])):
        S += A[i][j]

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

S = 0
for row in A:
    for elem in row:
        S += elem

Создание вложенных списков

Пусть даны два числа: количество строк n и количество столбцов m. Необходимо создать список размером n×m, заполненный нулями.
Очевидное решение оказывается неверным:

# Неправильно
A = [[0] * m] * n

Таким образом, двумерный список нельзя создавать при помощи операции повторения одной строки. Что же делать?
Первый способ: сначала создадим список из n элементов (для начала просто из n нулей). Затем сделаем каждый элемент списка ссылкой на другой одномерный список из m элементов:

A = [0] * n
for i in range(n):
    A[i] = [0] * m

Другой (но похожий) способ: создать пустой список, потом n раз добавить в него новый элемент, являющийся списком-строкой:

A = []
for i in range(n):
    A.append([0] * m)

Но еще проще воспользоваться генератором: создать список из n элементов, каждый из которых будет списком, состоящих из m нулей:

A = [[0] * m for i in range(n)]

В этом случае каждый элемент создается независимо от остальных (заново конструируется список [0] * m для заполнения очередного элемента списка), а не копируются ссылки на один и тот же список.

Ввод двумерного массива

Пусть программа получает на вход двумерный массив, в виде n строк, каждая из которых содержит m чисел, разделенных пробелами. Как их считать? Например, так:

A = []
for i in range(n):
    A.append(list(map(int, input().split())))

Или без использования сложных вложенных вызовов функций:

A = []
for i in range(n):
    row = input().split()
    for i in range(len(row)):
        row[i] = int(row[i])
    A.append(row)

Можно сделать то же самое и при помощи генератора:

A = [list(map(int, input().split())) for i in range(n)]

Пример обработки двумерного массива

Пусть дан квадратный массив из n строк и n столбцов. Необходимо элементам, находящимся на главной диагонали, проходящей из левого верхнего угла в правый нижний (то есть тем элементам A[i][j], для которых i=j) присвоить значение 1, элементам, находящимся выше главной диагонали – значение 0, элементам, находящимся ниже главной диагонали – значение 2. То есть получить такой массив (пример для n = 4):

1 0 0 0

2 1 0 0

2 2 1 0

2 2 2 1

Рассмотрим несколько способов решения этой задачи. Элементы, которые лежат выше главной диагонали – это элементы A[i][j], для которых i<j, а для элементов ниже главной диагонали i>j. Таким образом, мы можем сравнивать значения i и j и по ним определять значение A[i][j]. Получаем следующий алгоритм:

for i in range(n):
    for j in range(n):
        if i < j:
            A[i][j] = 0
        elif i > j:
            A[i][j] = 2
        else:
            A[i][j] = 1

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

Сначала заполним главную диагональ, для чего нам понадобится один цикл:

for i in range(n):
    A[i][i] = 1

Затем заполним значением 0 все элементы выше главной диагонали, для чего нам понадобится в каждой из строк с номером i присвоить значение элементам A[i][j] для j=i+1, …, n-1. Здесь нам понадобятся вложенные циклы:

for i in range(n):
    for j in range(i + 1, n):
        A[i][j] = 0

Аналогично присваиваем значение 2 элементам A[i][j] для j=0, …, i-1:

for i in range(n):
    for j in range(0, i):
        A[i][j] = 2

Можно также внешние циклы объединить в один и получить еще одно, более компактное решение:

for i in range(n):
    for j in range(0, i):
        A[i][j] = 2
    A[i][i] = 1
    for j in range(i + 1, n):
        A[i][j] = 0

А вот такое решение использует операцию повторения списков для построения очередной строки списка. i-я строка списка состоит из i чисел 2, затем идет одно число 1, затем идет n-i-1 число 0:

for i in range(n):

    A[i] = [2] * i + [1] + [0] * (n — i — 1)

А можно заменить цикл на генератор:

A = [[2] * i + [1] + [0] * (n — i — 1) for i in range(n)]

Вложенные генераторы двумерных массивов

Для создания двумерных массивов можно использовать вложенные генераторы, разместив генератор списка, являющегося строкой, внутри генератора для строк. Например, сделать список из n строк и m столбцов при помощи генератора, создающего список из n элементов, каждый элемент которого является списком из m нулей:

[[0] * m for i in range(n)]

Но при этом внутренний список также можно создать при помощи, например, такого генератора: [0 for j in range(m)]. Вложив один генератор в другой получим вложенные генераторы:

[[0 for j in range(m)] for i in range(n)]

Но если число 0 заменить на некоторое выражение, зависящее от i (номер строки) и j (номер столбца), то можно получить список, заполненный по некоторой формуле.

Пусть нужно задать следующий массив (для удобства добавлены дополнительные пробелы между элементами):

0 0 0 0 0 0
0 1 2 3 4 5
0 2 4 6 8 10
0 3 6 9 12 15
0 4 8 12 16 20

В этом массиве n = 5 строк, m = 6 столбцов, и элемент в строке i и столбце j вычисляется по формуле: A[i][j] = i * j.
Для создания такого массива можно использовать генератор:

[[i * j for j in range(m)] for i in range(n)]

 

Работа с модулями: создание, подключение инструкциями import и from

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

Каждая программа может импортировать модуль и получить доступ к его классам, функциям и объектам. Нужно заметить, что модуль может быть написан не только на Python, а например, на C или C++.

Подключение модуля из стандартной библиотеки

Подключить модуль можно с помощью инструкции import. К примеру, подключим модуль os для получения текущей директории:

>>>

>>> import os
>>> os.getcwd()
'C:\\Python33'

После ключевого слова import указывается название модуля. Одной инструкцией можно подключить несколько модулей, хотя этого не рекомендуется делать, так как это снижает читаемость кода. Импортируем модули time и random.

>>>

>>> import time, random
>>> time.time()
1376047104.056417
>>> random.random()
0.9874550833306869

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

>>>

>>> import math
>>> math.e
2.718281828459045

Стоит отметить, что если указанный атрибут модуля не будет найден, возбудится исключение AttributeError. А если не удастся найти модуль для импортирования, то ImportError.

>>>

>>> import notexist
Traceback (most recent call last):
  File "", line 1, in
    import notexist
ImportError: No module named 'notexist'
>>> import math
>>> math.Ё
Traceback (most recent call last):
  File "", line 1, in
    math.Ё
AttributeError: 'module' object has no attribute 'Ё'

Использование псевдонимов

Если название модуля слишком длинное, или оно вам не нравится по каким-то другим причинам, то для него можно создать псевдоним, с помощью ключевого слова as.

>>>

>>> import math as m
>>> m.e
2.718281828459045

Теперь доступ ко всем атрибутам модуля math осуществляется только с помощью переменной m, а переменной math в этой программе уже не будет (если, конечно, вы после этого не напишете import math, тогда модуль будет доступен как под именем m, так и под именем math).

Инструкция from

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

from <Название модуля> import <Атрибут 1> [ as <Псевдоним 1> ], [<Атрибут 2> [ as <Псевдоним 2> ] ...]
from <Название модуля> import *

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

>>>

>>> from math import e, ceil as c
>>> e
2.718281828459045
>>> c(4.6)
5

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

>>>

>>> from math import (sin, cos,
...           tan, atan)

Второй формат инструкции from позволяет подключить все (точнее, почти все) переменные из модуля. Для примера импортируем все атрибуты из модуля sys:

>>>

>>> from sys import *
>>> version
'3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)]'
>>> version_info
sys.version_info(major=3, minor=3, micro=2, releaselevel='final', serial=0)

Следует заметить, что не все атрибуты будут импортированы. Если в модуле определена переменная __all__ (список атрибутов, которые могут быть подключены), то будут подключены только атрибуты из этого списка. Если переменная __all__ не определена, то будут подключены все атрибуты, не начинающиеся с нижнего подчёркивания. Кроме того, необходимо учитывать, что импортирование всех атрибутов из модуля может нарушить пространство имен главной программы, так как переменные, имеющие одинаковые имена, будут перезаписаны.

Создание своего модуля на Python

Теперь пришло время создать свой модуль. Создадим файл mymodule.py, в которой определим какие-нибудь функции:

def hello():
    print('Hello, world!')
def fib(n):
    a = b = 1
    for i in range(n - 2):
        a, b = b, a + b
    return b

Теперь в этой же папке создадим другой файл, например, main.py:

import mymodule
mymodule.hello()
print(mymodule.fib(10))

Выведет:

Hello, world!
55

Поздравляю! Вы сделали свой модуль! Напоследок отвечу ещё на пару вопросов, связанных с созданием модулей:

Как назвать модуль?

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

Куда поместить модуль?

Туда, где его потом можно будет найти. Пути поиска модулей указаны в переменной sys.path. В него включены текущая директория (то есть модуль можно оставить в папке с основной программой), а также директории, в которых установлен python. Кроме того, переменную sys.path можно изменять вручную, что позволяет положить модуль в любое удобное для вас место (главное, не забыть в главной программе модифицировать sys.path).

Можно ли использовать модуль как самостоятельную программу?

Можно. Однако надо помнить, что при импортировании модуля его код выполняется полностью, то есть, если программа что-то печатает, то при её импортировании это будет напечатано. Этого можно избежать, если проверять, запущен ли скрипт как программа, или импортирован. Это можно сделать с помощью переменной __name__, которая определена в любой программе, и равна «__main__«, если скрипт запущен в качестве главной программы, и имя, если он импортирован. Например, mymodule.py может выглядеть вот так:

def hello():
    print('Hello, world!')
def fib(n):
    a = b = 1
    for i in range(n - 2):
        a, b = b, a + b
    return b
if __name__ == "__main__":
    hello()
    for i in range(10):
        print(fib(i))

Особенностями разработки графического интерфейса пользователя на основе языка программирования Python

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

from tkinter import *
root = Tk()#инициализация окна
var = DoubleVar()#Считывает информацию
def selb(): #переводит число в двоичную систему и выводит в окне
   n=»
   n=bin(int(var.get()))#функция чтения значения
   selection = «Value = » + n[2:]#пустое место в окне
   label.config(text = selection)#текст комментария
def selo():
   n=»
   n=oct(int(var.get()))   
   selection = «Value = » + n[2:]
   label.config(text = selection)#selection -пустая область
def selh():
   n=»
   n=hex(int(var.get()))   
   selection = «Value = » + n[2:]
   label.config(text = selection)
butb = Button(root,#инициализация кнопки(название любое)
          text=»Bin», #надпись на кнопке
          width=10,height=3, #ширина и высота
          bg=»white»,fg=»black»,command=selb) #цвет фона и надписи
buto = Button(root,
          text=»Oct», #надпись на кнопке
          width=10,height=3, #ширина и высота
          bg=»white»,fg=»black»,command=selo) #цвет фона и надписи
buth = Button(root,
          text=»Hex», #надпись на кнопке
          width=10,height=3, #ширина и высота
          bg=»white»,fg=»black»,command=selh) #цвет фона и надписи
butb.pack()#появление кнопок в окне
buto.pack()
buth.pack()
fra3 = Frame(root,width=500,height=150,bg=»darkblue»)
fra3.pack()
sca1 = Scale(fra3,orient=HORIZONTAL,length=300,
          from_=0,to=100000,tickinterval=100000,resolution=1, variable = var) #палзунок
sca1.pack()
L1 = Label(root, text=»Ввести число»)#подсказка
L1.pack(side = LEFT)
E1 = Entry(root, bd =5,textvariable=var)#поле ввода текста
E1.pack(side = RIGHT)
label = Label(root)#занесение в основное окно
label.pack()
root.mainloop()#зацикливание окна для бесконечности

Графопостроитель по функции

from math import * #подключение математического модуля
from tkinter import * #подключение работы с графическим интерфейсом

f = input(‘f(x):’) #ввод y

root = Tk() #инициализация основного окна

canv = Canvas(root, width = 1000, height = 1000, bg = «white») #инициализация рабочего холста
canv.create_line(500,1000,500,0,width=2,arrow=LAST) #вертикальная линия(ось y)
canv.create_line(0,500,1000,500,width=2,arrow=LAST) #горизонтальная линия(ось x)

First_x = -500;

for i in range(16000): #основной цикл создания графика
    if (i % 800 == 0):
        k = First_x + (1 / 16) * i
        canv.create_line(k + 500, -3 + 500, k + 500, 3 + 500, width = 0.5, fill = ‘black’) #создание черты
        canv.create_text(k + 515, -10 + 500, text = str(k), fill=»purple», font=(«Helvectica», «10»)) #подпись к черте
        if (k != 0):
            canv.create_line(-3 + 500, k + 500, 3 + 500, k + 500, width = 0.5, fill = ‘black’)
            canv.create_text(20 + 500, k + 500, text = str(k), fill=»purple», font=(«Helvectica», «10»))
    try:
        x = First_x + (1 / 16) * i
        new_f = f.replace(‘x’, str(x))
        y = -eval(new_f) + 500
        x += 500
        canv.create_oval(x, y, x + 1, y + 1, fill = ‘black’)
    except:
        pass
canv.pack()    #регистрация холста для использования в окне
root.mainloop() #зацикливание основного окна

Конструктор сайтов для детей и учителей WebNode

http://www.webnode.ru/

webnode

Пример: сайт учителя математики http://nimgirova-inna-nikolaevna.webnode.ru/

Тренировочный материал для экзаменов

Создание школьного ВЕБ-сервера

Безопасность хранимой информации — важное условие её хранения. Где лучше хранить информацию? Есть два варианта:

  1. Воспользоваться хост-услугами популярных компаний
  2. Использовать школьный сервер

У обоих способов есть ряд плюсов и минусов.

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

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

Чтобы развернуть веб-сервер необходимо, установить на компьютер специальное программное обеспечение. Один из вариантов — http://www.wampserver.com/ru/ . 

При удачной установке веб-сервера, у Вас в браузере должна открываться страница в браузере по адресу http://localhost/. А на экране появится следующая картинка:

wamp

 

Самый простой способ создать собственный сайт сегодня — это использовать т.н. CMS — Content Manager System. CMS — это конструктор сайта, деталями которого являются пункты меню, статьи, и т.п. Создать сайт с помощью хорошей CMS можно даже не зная html.

Open-source CMS

Свободные (open-source) CMS — это программное обеспечение, отвечающее следующим условиям: программу можно свободно использовать с любой целью; доступность исходного текста программы; можно свободно распространять копии программы; программу можно свободно улучшать и публиковать свою улучшенную версию.

cms-runet-procent

CMS Официальный Сайт

Joomla!

https://www.joomla.org/

MODX

http://modx.ru/

Drupal

https://www.drupal.org/

WordPress

https://ru.wordpress.org/

Opencart

http://www.opencast.org/
Datalife Engie http://dle-news.ru/

 

Установка wordpress на локальный web сервер.

Затем Вам надо скачать архив WordPress с официального сайта https://ru.wordpress.org/ и распаковать его в папку C:/wamp/www/wordpress. 

Затем необходимо создать базу данных для wordpress на сервере, и продолжить установку WordPress.

Установка joomla на локальный web сервер.

Создаём в папке www нашего web-сервера, папку joomla. Скачиваем с официального сайта архив программы https://www.joomla.org/download.html. Распоковываем архив в нашу папку.

Создаём в MySQL базу данных для нашего конструктор, и через localhost запускаем установку.

 

Основы языка JavaScript

Выбор элемента на странице

 

$ ( ‘селектор’) Выбор элементов страницы с селектором
$ ( ‘элемент’) Выбор элементов страницы
$ ( ‘селектор элемент’ ) Выбор потомков элементов с селектором
$ ( ‘элемент > дочерний элемент’ ) Выбор дочерних элементов
$ ( ‘элемент + элемент» ) Выбор следующего соседнего элемента
$ ( ‘элемент[параметр]’ ) Выбор элемента, имеющего определённый параметр
$ ( ‘элемент[параметр=»значение»]’ ) Выбор элемента, имеющего определённый параметр со значением

$ ( ‘элемент[параметр^=»значение»]’ )  $ ( ‘a[href^=»http://»]’ )

Выбор элемента, имеющего определённый параметр, начинающийся с определённого значения
$ ( ‘элемент[параметр$=»значение»]’ )  $ ( ‘a[href$=».pdf»]’ ) Выбор элемента, имеющего определённый параметр, заканчивающегося с определённого значения
$ ( ‘элемент[параметр*=»значение»]’ )  $ ( ‘a[href*=»eksmo.ru»]’ ) Выбор элемента, имеющего определённый параметр, имеющий в составе определённый набор букв

 

Фильтры

Общая конструкция $( ‘ элемент или селектор:фильтр ‘)

even Поиск чётных строк в таблице
odd Воиск нечётных строк в таблице
first Выбор первого элемента на странице
contains(текст) Выбор элемента, содержащего определённый текст
last Выбор последнего элемента на странице
not([элемент]) Выбор всех элементов и атрибутов, кроме того что в скобках
has([элемент]) Выбор всех элементов и атрибутов, имеющих элемент или значение атрибутов в скобках
hidden Выбирает все скрытые элементы

 

Функции JQuery

Общая конструкция

$( ‘ элемент или селектор ‘).function1().function2()….functionn();

hide() Скрыть элемент
show() Показать скрытый элемент
$(document).ready() Дождатся загрузки html кода страницы
width(число) Ширина элемента в пикселях
height(число) Высота элемента в пикселях
text( ‘текст’ ) Добавление текста на страницу
fadeIn(чило) Проявление невидимого элемента на странице
fadeOut( ) Медленное исчезновение элемента страницы
html()

Копирование кода элемента в буфер, либо замена содержимого блока

на другую строку(внутри функции

append( ‘html-код’) Добавление html-кода после последнего элемента в выбранном блоке
prepend( ‘html-код’) Добавление html-кода первым элементом в выбранном блоке
before( ‘html-код’ ) Добавление html-кода перед выбранным блоком
after ( ‘html-код’ ) Добавление html-кода после выбранного блока
remove() Удаление элемента на странице
replaceWith( ‘html-код’ ) Замена содержимого элемента
addClass( ‘имя класса’ ) Добавление класса к элементам
removeClass( ‘имя класса’ ) Удаление класса элемента
toggleClass( ‘имя класса’ ) Добавление-удаление класса элемента
css( ‘имя свойства’ ‘значение’ ) Добавление css свойства к элемента
parseInt (переменная) Преобразование строки в число
attr ( ‘атрибут тега’ )

Чтение атрибута элемента

removeAttr ( ‘Удалить атрибут’ )

Удаление атрибута элемента

each ( ‘function({ })’ )

Переборка серии элементов в цикле

$(this)

Обработка указанного элемента в цикле

clone ( )

Копирование выбранного элемента со всем содержимым

hover ( function({ }), function({ }))

Наведение — смещение курсора мыши

 preventDefault( )  Отменяет нормальное поведение браузера
return false Возвращает лож функции события
off ( ‘событие’ ) Удаление события для элемента
stopPropagation( ) Препятствие присвоения события элементу предку
next (‘селектор или элемент ‘) Перемещение к следующему элементу после текущего элемента

События JQuery

Общая конструкция

$( ‘ элемент или селектор ‘).on(‘событие’ , селектор, данные, function ({код})); где селектор(дочерний элемент) необязателен, данные — это переманная для функции(тоже не обязателен).

События мыши
click Одиночный щелчок мыши по элементу
dbclick Двойной щелчок мыши по элементу
mousedown Нажатие кнопки мыши без отпускания (для пертаскивания элементов)
mouseup Отпускание кнопки мыши
mouseover Движение мыши по элементу
mouseout Убирание курсора с элемента
mousemove Передвижение курсора
События документа/окна
load конец загрузки всех файлов web-страницы
resize запускается при изменении размера окна браузера
scroll Использование полосы прокрутки, клавишь page, home, end
unload Переход по ссылке на другу страницу
События форм
submit Нажатие на кнопку отправки форм, либо нажатие Enter
reset Нажатие кнопки для отмены изменений и возрата к исходному виду
change Изменение статуса элемента формы
focus Нажатие на элемент формы, или клавиша Tab
blur Противоположно focus
События клавиатуры
keypress Нажатие клавиши
keydown Опускание клавиши
keyup Отпускание клавиши
   

 

Рабочие программы по информатике

  1. Рабочая программа ФГОС 8 класс Босова Скачать…
  2. Рабочая программа ФГОС 9 класс Босова Скачать…
  3. Рабочая программа ФГОС 10 класс Гейн Скачать…
  4. Рабочая программа ФГОС 11 класс Гейн Скачать…
  5. РП индивидувльники  9 класс 17 часов Скачать…
  6. Элективные курсы по информатике 10 класс 1 час Скачать…
  7. Кружок «Юный Информатик» 2 ч 3-4 класс Скачать…
  8. Кружок «Программисты» 4 часа 7-11 класс Скачать…
  9. Кружок «Юный Информатик» 6 ч. 5-7 класс Скачать…
  10. Кружок «Юный Информатик»  6 ч. 9-11 класс Скачать…
  11. Кружок «Юный Информатик» 4 ч. 5-7 класс Скачать…

Вернуться к списку статей


Комментарии: