среда, 26 ноября 2014 г.

Язык программирования Python. Базовые типы данных. (1)

      Файл скрипта имеет расширение .py Запуск сценария производится командой python filename.py Второй способ запуска сценария выглядит так ./filename.py (в этом случае необходимо указать право на исполнение файла chmod +x filename.py и в сценарии первой строкой прописать путь до интерпретатора (пр. #!/usr/bin/python3))
     Python - язык с динамической типизацией.
     В языке предусмотрена возможность индексации в обратном порядке (от конца к началу).


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

Модули
     Модули в широком смысле - это файлы с расширением .py. В узком представлении - это пакет имен переменных. Имена переменных называют атрибутами (модуля,объекта). Модуль импортируется инструкцией:
     import <name_of_module>
Импорт атрибута оределенного модуля выполняется инструкцией:
     from <name_of_module> import <name_of_attributes>
пример:
     import os
     from sys import platform   #  импорт атрибута platform
     from random import *       # импорт всех атрибутов и функций модуля random
     print(os.name)                                       
     print(os.getcwd())      # getcwd является функцией поэтому ставим скобки
     print(platform)


Пакет - каталог с файлами (скриптами), содержащий файл __init__.py. При импорте пакета в первый раз, автоматически выполняется файл __init__.py.
Импорт пакета:
     import pack     (при импорте только пакета импортируется только __init__.py)
Модули импортируются явно!
     from pack import mod

     from pck1.pck2 import mod   (лучший способ импорта)  

Относительный импорт (относительно самого пакета):
     from . import mod1, mod2   (точка означает каталог, в котором лежит импортирующий модуль, две точки - каталогом выше)



повторная загрузка модуля
     from imp import reload                        # импортируем функцию reload
     reload(module)                                     # загружаем модуль

атрибут __name__
     ! Если файл запускается как главный, значением атрибута будет "__main__", если импортируется, значением будет являться имя файла. 

     Посмотреть доступные атрибуты можно функцией dir:  print(dir(module.attributes))
!!! Если ваши модули находятся в не рабочем каталоге, вам необходимо указать нужный каталог в переменной окружения PYTHONPATH: export PYTHONPATH = <path_to_directory>

!!! Чтобы скомпилировать бай-код модуля (.pyc) нужно выполнить команду
     python -m compileall module.py

(базовые модули: sys, os, math, random, re, decimal, pickle, shelve, struct, io, functools, imp)

Числа
Целые: 1, 23, 4565, -87, 0
Вещественные: 1.23, 4,12e-10 (экспоненциальная форма отображения)
Шестнадцатеричные: 0x4ff
Восьмеричные: 0o321
Двоичные: 0b011010
Рациональные: Fraction (2, 3)   # 2 / 3 (предварительный импорт from fractions import Fraction)
Комплексные: 7+5j
     функции
hex(n)                # перевод десятичного числа в шестнадцатеричное
oct(n)                 # перевод десятичного числа в восьмеричное
bin(n)                 # перевод десятичного числа в двоичное
int(str, base)    # преобразовать в целое число строку по основанию
round(n)            # округление
trunc(n)             # усечение дробной части

Строки (неизменяемый объект)
str = "string"             # объявление строки
len(str)                      # длина строки
str[0]                         # первый элемент строки
str[-1]                       # последний элемент строки
str[1:3]                      # срез (результат - tr)
str[1:5:2]                   # срез с шагом 2
str[1:]                        # всё кроме первого элемента
str[:-1]                      # всё кроме последнего элемента
str[::-1]                      # строка наоборот, шаг -1
    методы
str.find('ri')                         # поиск смещения подстроки
str.replace('x','y',2)             # замена 'x' на 'y' в первые два вхождения
'/'.join(['1','2','3'])              # итог  - '1/2/3'  - вывод строки с разделителем '/'
str.split(',')                          # разбитие строки по разделителю
str.upper()  str.lower()        # верхний и нижний регистр
str.isalpha()                         # проверка на буквы

str.isdigit()                          # проверка на цифры
str.rstrip()                           # удаление завершающих пробелов
'{0} and {1}'.format('x','y')   # формат

Синтаксис метода .format
{[имя атрибута|[индекс]][!флаг]:[заполнитель][выравнивание][знак][ширина][,][.точность][тип]}

флаг:  s (str), r (repr), a (ASCII) 
заполнитель: любой символ
выравнивание: "<"(по левому краю) ">"(по правому краю) "="(после знака, перед цифрами) "^"(по центру)
знак: "+"(для всех чисел) "-"(минус для отрицательных) "пробел"(минус для отрицательных, пробел для положительных)
[,] - символ-разделитель разрядов 
тип: b | c | d | e | E | f | F | g | G | n | o | s | x | X | %

примеры:
list = [100, 200, -300]
print('{0[0]:?<+15.2f} and {0[1]:$>-15.3f} and {0[2]:*^ 15.4e}'.format(list))

'{0!s} {0!r}'.format('abc')
'{first} {last}'.format(first='One', last='Two')
'{:{align}{width}}'.format('test', align='^', width='10')

data = {'first': 'one', 'last': 'two'}
'{first} {last}'.format(**data)     # распаковка словаря

     посмотреть все методы строки можно инструкцией dir(str)
     справку о методе можно получит инструкцией help(str.method)

ord('a')              # ASCII - код
chr(97)              # символ из ASCII - кода


Списки (изменяемый объект)
L = [1, '2', 3]                         # объявление списка из трех элементов. 
      Список может содержать элементы разных типов.
len(L)                                    # кол-во элементов списка
L[0]                                       # первый элемент списка
L + [4]                                   # добавляем в конец новый элемент
     У списков как и у строк доступны срезы.
     методы
L.append('5')                         # добавляем в конец новый элемент
L.insert(3,'7')                         # в 4 позицию вставить '7'
L.extend([3,4,5])                    # добавить в конец списка другой список 
L.pop(2)                                 # удаляем 3 элемент
L.sort()                                   # сортировка
L.reverse()                              # сортировка по убыванию
L.count(2)                               # кол-во вхождений 2 в списке
L.index('2')                              # номер индекса по значению
     матрица
M = [[1,2,3],
        [4,5,6],
        [7,8,9]]
M[1][2]                  # вторая строка третий элемент
     диагонали
M2 = [M[x][x] for x in range(len(M))]                                      # [1,5,9]
M3 = [M[x][(len(M))-x-1] for x in range(len(M))]                     # [3,5,7]
M4 = [M[x][x] for x in reversed(range(len(M)))]                      # [9,5,1]
M5 = [M[x][(len(M))-x-1] for x in reversed(range(len(M)))]     # [7,5,3]

     генератор списков (возвращает новый список)
[x+1 for x in L]      # каждый элемент списка увеличить на 1
[x+1 for x in L if x % 3 == 1] # увеличиваем на 1 все элементы списка которые делятся на 3 с остатком 1
[[a,b,c] for a in range(0,x+1) for b in range(0,y+1) for c in range(0,z+1) if (a+b+c) != n]

Словари (изменяемый объект)
     Доступ к объектам словаря осуществляется по ключам.
D = {'name':'Max', 'age':'20','job':'admin'}       # объявление словаря
D['name']                                                                # получить значение ключа name
D = {}                                                                       # пустой словарь
D['name'] = 'Mark'                                               # присвоение значения ключу name,
                                                                                   если нет ключа name то добавляет
del D['name']                                                          # удаление элемента

     вложенность
D = {'notebook':{'cpu': 'intel', 'os': 'linux'}}
D['notebook']['os']                                               # получить значение
     методы
D.keys()                                         # список ключей (возвращает итерируемый объект)
 dkeys = list(D.keys())                  # приводим к списку
D.values()                                      # список значений
D.items()                                        # список и ключей и значений
D.update(D2)                                # слияние
D.get('key', 'default')                   # значение ключа, если нет ключа, возвращает 'default' 
D.pop('key')                                  # удаляет ключ 
D.fromkeys(['a', 'b'], 0)               # вернет {'a': 0, 'b': 0}

D = {x: x+x for x in range(10)}          # генератор словаря
for key in D.keys():                             # обход ключей

for (k, v) in zip(keys, val): D[k] = v    # генератор словаря с помощью фнкции zip
                                                             # keys, val - списки ключей и значений

if  'name' in D:                                    # проверка на вхождение ключей

Кортежи (неизменяемый объект)
T = (1, 2, 3, 4, 5)                                               # объявление кортежа
T+(6, 7)                                                             # добавление элементов в конец
T[0]                                                                   # первый элемент
T = tuple(L)                                                     # создать кортеж из элементов списка L
     методы
T.index(2)                                                         # вхождение
T.count(3)                                                         # количество троек в кортеже

Файлы
f = open('file.txt', 'w')              # создается новый файл для вывода ('r' - на чтение, 'a' , 'w' - на запись, '+'' - на запись и чтение)
f.write('first line\n')                  # запись строки в файл
text = f.read()                           # файл читается целиком в строку
next = f.readline()                    # чтение след. строки
f.seek(2, 0)     # меняет текущую позицию (смещение в байтах; 

                        # 0-от начала файла, 1-от текущей позиции, 2-от конца файла)

f.write(str)                                # запись строки в файл

for line to open('file.txt'):         # итерация построчно по файлу
f.close()                                     # закрываем файл

f.flush()                           # принудительно выталкивает содержимое выходных буферов на диск

модуль pickle (позволяет сохранять любые объекты в файлах)
import pickle
dct = {'color': "red"; 'form': 'circle'}
fle = open('data.dt', 'wb')                     # write binary - запись двоичных данных

pickle.dump(dct, fle)                            # запись в файл
fle.close

fleo = open('data.dt', 'rb')
dcto = pickle.load(fleo)                      # чтение из файла





Множества (изменяемый объект)
     Множества могут содержать только неизменяемые объекты. Чтобы множество поместить в другое множество необходимо первое создать с помощью функции frozenset().
X = {'1','2','3'} или Y = ('abcde')                # объявление множества
X & Y                                                                # пересечение
X | Y                                                                 # объединение
X - Y                                                                 # разность
X ^ Y                                                                # симметрическая разность
     методы
X.add(s)                        # добавить новый элемент
X.clear()                       # удалить все элементы
X.discard(s)                # удалить элемент s
X.isdisjoint(Y)             # True, если множества X и Y не имеют общих элементов
X.update(Y)                 # дабавляет в множество X все элементы множества Y, отсутсвующие в Y
     генератор множества
{x+1 for x in L}

Объект типа bool
     Имеет два значения True и False (соответственно 1 и 0).


Операторы выражений
логические
 x or y           # ИЛИ
 x and y        # И
 not x            # отрицание
 x xor y        #

 для итерируемых объектов
 x in y, x not in y     # проверка на вхождение
 x is y, x is not y     # проверка идентичности объектов

 сравнение
 x > y, x < y, x >= y, x <= y
 x == y, x != y                       # равно, не равно
 x < y < z                               # составное сравнение

 сдвиги
 x << y, x >> y     # сдвиг x влево или вправо на y бит

 математические
 +, -, *, /
                         # деление с остатком, результат остаток
 //                           # деление с округлением вниз
 x ** y                   # x в степени y

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

Отправить комментарий