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

  • Типы данных в Python 1. Числа

  • Целые числа ( int )

  • Операция Описание

  • Числа с плавающей точкой (float)

  • Дополнительные методы

  • Комплексные числа (complex)

  • 2. Логический тип (Boolean Type)

  • Операция или выражение Описание

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

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

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


    Скачать 0.6 Mb.
    НазваниеЛабораторная работа 1 введение в язые программирования python цель и задачи работы
    АнкорЛаба1
    Дата12.11.2019
    Размер0.6 Mb.
    Формат файлаpdf
    Имя файлаlab-1-1.PythonIntodution.pdf
    ТипЛабораторная работа
    #94834
    страница1 из 3
      1   2   3


    1
    ЛАБОРАТОРНАЯ РАБОТА № 1
    ВВЕДЕНИЕ В ЯЗЫЕ ПРОГРАММИРОВАНИЯ PYTHON
    1.
    ЦЕЛЬ И ЗАДАЧИ РАБОТЫ
    Целью работы является изучение студентами основ языка программирования Python.
    Задачей работы является:
     ознакомление с примерами программного кода на языке Python;
     понимание работы базовых программных конструкций на языке
    Python.
    2.
    ТИПЫ ДАННЫХ И СТРУКТУРА ЯЗЫКА PYTHON
    Основная цель любой программы состоит в обработке данных. Данные различного типа хранятся и обрабатываются по-разному. В любом алгоритмическом языке каждая константа,
    переменная,
    результат вычисления выражения или функции должны иметь определенный тип.
    Тип данных определяет:
     внутреннее представление данных в памяти компьютера;
     множество значений, которые могут принимать величины этого типа;
     операции и функции, которые можно применять к величинам этого типа.
    Python относится к языкам с неявной сильной динамической типизацией.
    Неявная типизация означает, что при объявлении переменной вам не нужно указывать ее тип, при явной - это делать необходимо. В качестве примера языков с явной типизацией можно привести Java, C++.
    Сильная типизация не позволяет производить операции в выражениях с данными различных типов, слабая - позволяет. В языках с сильной типизацией вы не можете складывать строки и числа, нужно все приводить к одному типу. К первой группе можно отнести Python, ко второй - С и С++.
    Типы данных в Python
    1.
    Числа
    Числовой тип данных относится к встроенному типу данных в Python.
    Числа в Python могут быть целыми числами (int), числами с плавающей точкой (float), комплексными числами (complex).
    Для преобразования чисел из вещественных в целые и наоборот в
    Python определены функции int() и float(). Например, int(12.6) даст в результате 12, а float(12) даёт в результате 12.0 (десятичный разделитель –

    2
    точка).
    Целые числа (int)
    Как и в математике, в компьютерном программировании целые числа –
    это натуральные числа,
    которые могут быть положительными,
    отрицательными, или равняться 0 (…,-1, 0, 1, …). Целое число можно отметить как int. Как и в других языках, в python не нужно использовать запятую при написании многозначных чисел (к примеру, тысяча записывается как 1000, а не как 1,000).
    Чтобы вывести целое число, используется синтаксис:
    print(-25)
    Также можно объявить переменную (в данном случае она является символом числа, которое нужно вывести):
    my_int = -25
    print(my_int)
    Python умеет выполнять математические операции с целыми числами:
    int_ans = 116 - 68
    print(int_ans)
    Числа в python поддерживают набор самых обычных математических операции:
    Операция
    Описание
    x + y
    Сложение x - y
    Вычитание x * y
    Умножение x / y
    Деление x // y
    Получение целой части от деления x % y
    Остаток от деления
    -x
    Смена знака числа abs(x)
    Модуль числа divmod(x, y)
    Пара (x // y, x % y)
    x ** y
    Возведение в степень pow(x, y[, z])
    x y
    по модулю (если модуль задан)
    Над целыми числами также можно производить битовые операции:
    Операция
    Описание
    x | y
    Побитовое ИЛИ
    x ^ y
    Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ
    x & y
    Побитовое И
    x << n
    Битовый сдвиг влево x >> y
    Битовый сдвиг вправо

    3

    x
    Инверсия битов
    Системы счисления
    Для перевода из одной сиcтемы счисления в другую Python предоставляет несколько функции:
     int([object], [основание системы счисления]) - преобразование к целому числу в десятичной системе счисления. По умолчанию система счисления десятичная, но можно задать любое основание от 2 до 36
    включительно.
     bin(x) - преобразование целого числа в двоичную строку.
     hex(х) - преобразование целого числа в шестнадцатеричную строку.
     oct(х) - преобразование целого числа в восьмеричную строку.
    Примеры:
    a = int('19') # Переводим строку в число b = int('19.5')
    # Строка не является целым числом
    Traceback (most recent call last):
    File "", line 1, in
    ValueError: invalid literal for int() with base 10: '19.5'
    c = int(19.5)
    # Применённая к числу с плавающей точкой, отсекает дробную часть print(a, c)
    19 19
    bin(19)
    '0b10011'
    oct(19)
    '0o23'
    hex(19)
    '0x13'
    0b10011
    # Так тоже можно записывать числовые константы
    19
    int('10011', 2)
    19
    int('0b10011', 2)
    19
    Числа с плавающей точкой (float)
    Число с плавающей точкой (или float) – это действительное число (это означает, что оно может быть как рациональным, так и иррациональным числом). Числа с плавающей точкой могут содержать дробную часть
    (например, 9.0 или -116.42). Проще говоря, python воспринимает любое число с десятичной точкой как число с плавающей точкой.
    Чтобы вывести число с плавающей точкой, используйте:
    print(17.3)
    Также вы можете объявить переменную:
    my_flt = 17.3

    4
    print(my_flt)
    Как и с целыми числами, python умеет выполнять математические операции с числами с плавающей точкой:
    flt_ans = 564.0 + 365.24
    print(flt_ans)
    При работе с целыми числами и числами с плавающей точкой важно помнить, что 3 и 3.0 – не одно и то же. 3 ≠ 3.0, поскольку 3 – целое число, а
    3.0 – число с плавающей точкой.
    Дополнительные методы
    float.as_integer_ratio() - пара целых чисел, чьё отношение равно этому числу.
    float.is_integer() - является ли значение целым числом.
    float.hex() - переводит float в hex (шестнадцатеричную систему счисления).
    classmethod float.fromhex(s) - float из шестнадцатеричной строки.
    (10.5).hex()
    '0x1.5000000000000p+3'
    float.fromhex('0x1.5000000000000p+3')
    Помимо стандартных выражений для работы с числами (а в Python их не так уж и много), в составе Python есть несколько полезных модулей.
    Модуль math предоставляет более сложные математические функции.
    import math math.pi math.sqrt(85)
    Модуль random реализует генератор случайных чисел и функции случайного выбора.
    import random random.random()
    Комплексные числа (complex)
    Тип данных complex относится к категории неизменяемых и хранит пару значений типа float, одно из которых представляет действительную часть комплексного числа, а другое - мнимую.
    Литералы комплексных чисел записываются как действительная и мнимая части, объединенные знаком "+" или "-", а за мнимой частью следует символ j.
    x = complex(1, 2)
    print(x)

    5
    (1+2j)
    y = complex(3, 4)
    print(y)
    (3+4j)
    z = x + y print(x)
    (1+2j)
    print(z)
    (4+6j)
    z = x * y print(z)
    (-5+10j)
    z = x / y print(z)
    (0.44+0.08j)
    print(x.conjugate())
    # Сопряжённое число
    (1-2j)
    print(x.imag)
    # Мнимая часть
    2.0
    print(x.real)
    # Действительная часть
    1.0
    print(x > y)
    # Комплексные числа нельзя сравнить
    Traceback (most recent call last):
    File "", line 1, in
    TypeError: unorderable types: complex() > complex()
    print(x == y)
    # Но можно проверить на равенство
    False abs(3 + 4j)
    # Модуль комплексного числа
    5.0
    pow(3 + 4j, 2)
    # Возведение в степень
    (-7+24j)
    Функции в модуле math не работают с комплексными числами.
    Если возникает необходимость использовать комплексные числа,
    можно воспользоваться модулем cmath, который содержит комплексные версии больштнства тригонометрических и логарифмических функций,
    присутствующих в
    модуле math,
    плюс ряд функций специально предназначенных для работы с комплексными числами, таких как:
    cmath.phase()
    cmath.polar()
    cmath.rect()
    а также константы:
    cmath.pi cmath.e которые хранят те же самые значения типа float, что и родственные им константы в модуле math.

    6
    2. Логический тип (Boolean Type)
    Логический тип данных (или Boolean) – это примитивный тип данных,
    который принимает одно из двух возможных значений: истину (true) или ложь (false). Этот тип присутствует во многих языках программирования и используется для построения алгоритмов.
    Логические значения получаются в результате логических операций и вычисления логических выражений.
    Основные логические операции и
    выражения:
    Операция или выражение
    Описание
    >
    Условие «больше» (например, проверяем,
    что a > b)
    <
    Условие «меньше» (например,проверяем,
    что a < b)
    ==
    Условие равенства (проверяем, что a равно b)
    !=
    Условие неравенства (проверяем, что a не равно b)
    not x
    Отрицание (условие x не выполняется)
    x and y
    Логическое «И» (умножение). Чтобы выполнилось условие x and y, необходимо,
    чтобы одновременно выполнялись условия x и y.
    x or y
    Логическое «ИЛИ» (сложение). Чтобы выполнилось условие x or y, необходимо,
    чтобы выполнилось одно из условий.
    x in A
    Проверка принадлежности элемента x множеству (структуре) A .
    a < x < b
    Эквивалентно (x > a) and (x < b)
    Структуры данных
    В Python определены такие структуры данных (составные типы) как последовательности и отображения (называемые также словарями). Словари позволяют устанавливать связи (ассоциации) «ключ–значение» (например,
    «Фамилия–Адрес»), поэтому с их помощью создаются так называемые ассоциативные массивы.
    Последовательности, в свою очередь, подразделяются на изменяемые и неизменяемые. Под изменяемостью (изменчивостью) последовательности понимается возможность добавлять или убирать элементы этой последовательности
    (т.е.
    изменять количество элементов последовательности).

    7
    Для структур данных в Python определены функции (операции) и методы, принципиального различия между которыми нет, а есть различие синтаксическое (в правилах написания). Основные функции и методы для каждого типа структур данных приводятся ниже.
    1. Строки (str)
    Строки (последовательности символов – букв и других значков,
    которые можно найти на клавиатуре компьютера) могут состоять из символов английского и любого другого алфавита. Для простоты и определённости в
    качестве значений переменных рекомендуется использовать только символы английского алфавита. В Python строки и символы нужно заключать в кавычки (одиночные или двойные). Элементы
    (символы) в строке нумеруются, начиная с нуля.
    Одиночный символ – буква – является «с точки зрения Python»
    строкой, состоящей из одного элемента.
    Максимально возможное количество символов в строке (длина строки)
    в Python ограничивается только доступным объёмом памяти. Так что текст любого разумного размера (например, несколько тысяч страниц) может быть записан в одну строку Python
    Числа могут быть преобразованы в строки с помощью функции str()
    Например,
    str(123)
    даст строку '123'
    Если строка является последовательностью знаков–цифр, то она может быть преобразована в целое число в помощью функции int()
    (
    int('123')
    даст в результате число 123), а в вещественное – с помощью функции float()
    (
    float('12.34')
    даст в результате число 12.34). Для любого символа можно узнать его номер (код символа) с помощью функции ord()
    (например,
    ord('s')
    даст результат 115). И наоборот,
    получить символ по числовому коду можно с помощью функции chr()
    (например chr(100)
    даст результат 'd').
    Основные операции со строками:
    Операция или выражение
    Описание
    len(s)
    Вычисляется длина строки s s1 + s2
    Конкатенация. К концу строки s1
    присоединяется строка s2, например,
    'вы' + 'года' → 'выгода'
    s * n (или n * s)
    n-кратное повторение строки s, например 'кан'*2 → 'канкан'
    s[i]
    Выбор из s элемента с номером i,
    нумерация начинается с 0 (первый элемент имеет номер 0) Если i<0, отсчёт идёт с конца.
    Пример:

    8
    s= 'дерево'
    s[2] → 'р'
    s[-2] → 'в'
    s[i:j:k]
    Срез — подстрока, содержащая символы строки s с номерами от i до j с шагом k
    (элемент с номером i входит в итоговую подстроку, а элемент с номером j уже не входит). Если k не указан (использован вариант s[i:j]), то символы идут подряд
    (равносильно s[i:j:1]).
    Примеры:
    s='derevo'
    s[3:5] → 'ev'
    s[1:5:2] → 'ee'
    min(s)
    Определяется символ с наименьшим значением (кодом)
    Пример:
    s='derevo'
    min(s) → 'd'
    max(s)
    Определяется символ с наибольшим значением (кодом)
    Пример:
    s='derevo'
    max(s) → 'v'
    Строки, как объекты Python, обладают методами (т.е. функциями,
    внутренне присущими этим объектам). Основные методы перечислены в следующей таблице.
    Пусть строка, к которой применяются эти методы, называется s1.
    Метод
    Описание
    s1.center(n)
    Строка s1 центрируется (дополняется пробелами слева и справа) в пространстве шириной n символов. Если n < len(s1), пробелы не добавляются.
    s1.ljust(n)
    Строка s1 выравнивается по левому краю
    (дополняется пробелами справа) в пространстве шириной n символов. Если n < len(s1), пробелы не добавляются.
    s1.rjust(n)
    Строка s1 выравнивается по правому краю (дополняется пробелами слева) в пространстве шириной n символов. Если n < len(s1), пробелы не добавляются.
    s1.count(s[,i,j])
    Определение количества вхождений подстроки s в строку s1. Можно указать позицию начала поиска i и окончания поиска j (по тем же правилам, что и начало и конец среза).
    Примеры:
    s1='abrakadabra'
    s1.count('ab') → 2
    s1.count('ab',1) → 1

    9
    s1.count('ab',1,3)
    → 0 потому что s1[1:3]→ 'brakada'
    s1.find(s[,i,j])
    Поиск первого (считая слева) вхождения подстроки s в строку s1. Необязательные аргументы i и j определяют начало и конец области поиска (как в предыдущем случае).
    Пример:
    s1='abrakadabra'
    s1.find('br') → 1
    s1.rfind(s[,i,j])
    Поиск последнего (считая слева)
    вхождения подстроки s в строку s1.
    Необязательные аргументы i и j определяют начало и конец области поиска (как в предыдущем случае).
    Пример:
    s1='abrakadabra'
    s1.rfind('br') → 8
    s1.strip()
    Создаётся копия строки, в которой удалены пробелы в начале и в конце
    (если они есть или случайно образовались).
    Пример:
    s1=' breKeKeKeKs '
    s2=s1.strip()
    s2 → 'breKeKeKeKs'
    s1.lstrip()
    Создаётся копия строки, в которой удалены пробелы в начале (если они есть или случайно образовались).
    Пример:
    s1=' breKeKeKeKs '
    s2=s1.lstrip()
    s2 → 'breKeKeKeKs '
    s1.rstrip()
    Создаётся копия строки, в которой удалены пробелы в конце (если они есть или случайно образовались).
    Пример:
    s1=' breKeKeKeKs '
    s2=s1.rstrip()
    s2 → ' breKeKeKeKs'
    s1.replace(s2,s3[,n])
    В строке s1 фрагмент (подстрока) s2
    заменяется на фрагмент s3.
    Необязательный аргумент n указывает количество замен (если требуется заменить не все фрагменты).
    Пример:
    s1='breKeKeKeKs'
    ss=s1.replace('Ke','XoXo',2)
    ss → 'breXoXoXoXoKeKs'
    s1.capitalize()
    Создаётся новая строка, в которой первая буква исходной строки становится заглавной (прописной), а все остальные становятся маленькими (строчными).

    10
    Пример:
    s1='breKeKeKeKs'
    s2=s1.capitalize()
    s2 → 'Brekekekeks'
    s1.swapcase()
    Создаётся новая строка, в которой прописные буквы исходной строки заменяются на строчные и наоборот.
    Пример:
    s1='breKeKeKeKs'
    s2=s1.swapcase()
    s2 → 'BREkEkEkEkS'
    s1.upper()
    Все буквы исходной строки становятся заглавными (прописными).
    Пример:
    s1='breKeKeKeKs'
    s2=s1.upper()
    s2 → 'BREKEKEKEKS'
    s1.lower()
    Все буквы исходной строки становятся маленькими (строчными).
    Пример:
    s1='breKeKeKeKs'
    s2=s1.lower()
    s2 → 'brekekekeks'
    2. Кортеж (tuple)
    Кортеж в Python — это набор разнородных элементов. Элементами кортежа могут быть числа, строки и другие структуры (в том числе и кортежи).
    Кортеж задаётся перечислением его элементов в круглых скобках через запятую, например t=(12,'b',34.6,'derevo')
    С использованием допустимой в Python цепочки присваиваний можно элементам кортежа сразу сопоставить какие-нибудь переменные:
    t=(x,s1,y,s2)=(12,'b',34.6,'derevo')
    В этом случае элемент кортежа и соответствующая переменная будут иметь совершенно одинаковые значения, т.е. значение t[0]
    будет равно значению x
    , а t[3].
    соответственно
    , s2
    Однако эти переменные могут изменяться независимо от элементов кортежа. Присвоение нового значения переменной s1
    никак не влияет на элемент t[1]
    . А вот для элементов кортежа значения изменить уже нельзя.
    Кортеж может быть пустым (для его определения нужно написать t=()
    ), а может содержать только один элемент (например,
    t=('domik',)
    ). Для кортежа из одного элемента обязательно добавлять запятую после имени или значения этого элемента.

    11
    Кортежи могут получаться в результате работы функций Python,
    например, уже упоминавшаяся функция divmod()
    в результате даёт кортеж из двух элементов.
    Кортежи могут использоваться для хранения характеристик каких-то объектов. В частности, в виде кортежа можно записать фамилию ученика и его оценки за полугодие.
    Функция или операция
    Описание
    len(t)
    Определяется количество элементов кортежа t t * n (или n * t)
    n-кратное повторение кортежа t
    Пример:
    t2=('raz','dva')
    t2*3 → ('raz', 'dva', 'raz','dva', 'raz', 'dva')
    t[i]
    Выбор из t элемента с номером i,
    нумерация начинается с 0 (первый элемент имеет номер 0) Если i<0, отсчёт идёт с конца.
    Пример:
    t3= (1, 2, 3, 'raz', 'dva')
    t3[2] → 3
    t3[2]→ 'raz'
    t[i:j:k]
    Срез — кортеж, содержащий элементы кортежа t с номерами от i до j с шагом k (элемент с номером i входит в итоговый кортеж, а элемент с номером j уже не входит). Если k не указан (использован вариант t[i:j]), то элементы идут подряд (равносильно t[i:j:1]).
    Пример:
    t3= (1, 2, 3, 'raz', 'dva')
    t3[1:4] → (2, 3, 'raz')
    min(t)
    Определяется элемент с наименьшим значением в соответствии с алфавитным порядком.
    Пример:
    t3= (1, 2, 3, 'raz', 'dva')
    min(t3) → 1
    max(t)
    Определяется элемент с наибольшим значением в соответствии с алфавитным порядком.
    Пример:
    t3= (1, 2, 3, 'raz', 'dva')
    max(t3) → 'raz'
    Важно понимать, что при определении значений минимального и максимального элементов кортежа используется «словарный» порядок —
    сначала идут числа по возрастанию, затем строки, начинающиеся на цифры в порядке их возрастания, затем строки, начинающиеся на прописные буквы в

    12
    алфавитном порядке, а затем строки, начинающиеся на строчные буквы также в алфавитном порядке.
    При работе с кортежами заменить значение элемента кортежа нельзя,
    поэтому, если возникает такая необходимость, нужно создавать новый кортеж, используя срезы и операцию объединения.
    Кортеж можно получить из строки с помощью функции tuple().
    Пример:
    s='amamam'
    t=tuple(s)
    t → ('a', 'm', 'a', 'm', 'a', 'm')
      1   2   3


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