601 - 650 Flashcards
__get__
Позволяет определить значение, возвращаемое дескриптором.
class Celsius:
def \_\_get\_\_(self, instance, owner):
return 5 * (instance.fahrenheit - 32) / 9
def \_\_set\_\_(self, instance, value):
instance.fahrenheit = 32 + 9 * value / 5
class Temperature:
celsius = Celsius()
def \_\_init\_\_(self, initial_f):
self.fahrenheit = initial_f
t = Temperature(212)
print(t.celsius)
👉 100.0
t.celsius = 0
print(t.fahrenheit)
👉 32.0
del
destructor method which is called as soon as all references of the object are deleted i.e when an object is garbage collected.
class Example:
# Initializing
def \_\_init\_\_(self):
print("Example Instance.")
# Calling destructor
def \_\_del\_\_(self):
print("Destructor called, Example deleted.")
obj = Example()
del obj
👉 Example Instance.
👉 Destructor called, Example deleted.
delete
used to delete the attribute of an instance i.e removing the value of attribute present in the owner class for an instance.
class Example(object):
def \_\_init\_\_(self):
print("Example Instance.")
def \_\_delete\_\_(self, instance):
print ("Deleted in Example object.")
class Foo(object):
exp = Example()
f = Foo()
del f.exp
👉 Example Instance.
👉 Deleted in Example object.
class Example(object):
def \_\_init\_\_(self):
self.value = ''
def \_\_delete\_\_(self, instance):
print ("Inside \_\_delete\_\_")
def \_\_del\_\_(self):
print("Inside \_\_del\_\_")
class Foo(object):
exp = Example()
f = Foo()
del f.exp
👉 Inside \_\_delete\_\_
👉 Inside \_\_del\_\_
property(fget=None, fset=None, fdel=None, doc=None)property(fget=None, fset=None, fdel=None, doc=None)
- fget=None* - функция для получения значения атрибута
- fset=None* - функция для установки значения атрибута
- fdel=None* - функция для удаления значения атрибута
- doc=None* - строка, для строки документации атрибута
декоратор может быть использован для определения методов в классе , которые действуют как атрибуты. Одним из примеров, где это может быть полезно, является предоставление информации, которая может потребовать первоначального (дорогостоящего) поиска и простого поиска после этого
class C:
def \_\_init\_\_(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self.x = value
def delx(self):
del self.x
x = property(getx, setx, delx, "I am the x property.")
Если c является экземпляром C , то:
👉 c.x вызовет метод getx,
👉 c.x = value вызовет setx,
👉 del c.x вызовет delx.
class C():
def \_\_init\_\_(self):
self._x = None
@property
def x(self):
"""I'm the 'x' property."""
print("getter of x called")
return self._x
@x.setter
def x(self, value):
print("setter of x called")
self._x = value
@x.deleter
def x(self):
print("deleter of x called")
del self._x
c = C()
c.x = 'foo' 👉 setter of x called
foo = c.x 👉 getter of x called
del c.x 👉 deleter of x called
pandas.DataFrame.transpose(*args, copy=False)
Transpose index and columns. Reflect the DataFrame over its main diagonal by writing rows as columns and vice-versa.
d1 = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
d1
col1 col2
0 1 3
1 2 4
df1_transposed = d1.transpose() # or you can use d1.T
df1_transposed
0 1
col1 1 2
col2 3 4
sys.getrefcount(object)
возвращает счетчик ссылок объекта.
def a():
pass
x = a()
y = a()
print(sys.getrefcount(a))
👉 2
collections.defaultdict([default_factory[, …]])
представляет собой словарь со значениями по умолчанию.
- default_factory - тип данных или функция, которая возвращает значение по умолчанию для новых значений.
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
d = defaultdict(list)
for k, v in s:
d[k].append(v)
sorted(d.items())
👉 [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
s = 'mississippi'
d = defaultdict(int)
for k in s:
d[k] += 1
sorted(d.items())
👉 [('i', 4), ('m', 1), ('p', 2), ('s', 4)]
s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
d = defaultdict(set)
for k, v in s:
d[k].add(v)
sorted(d.items())
👉 [('blue', {2, 4}), ('red', {1, 3})]
collections.namedtuple(typename, field_names, rename=False, defaults=None, module=None)
typename - строка, имя именованного кортежа.
field_names - последовательность строк, имена элементов кортежа.
rename - bool, авто-переименование повторяющихся имен элементов.
defaults=None - итерируемая последовательность, значения по умолчанию имен кортежа.
module=None - атрибут __module__ именованного кортежа.
—————————————————————–
._make(iterable) - создает новый экземпляр класса namedtuple() из существующей последовательности или итерации iterable.
._asdict()- вернет новый словарь dict, который отображает имена полей в соответствии с их значениями.
._fields - вернет кортеж строк, перечисляющий имена полей.
._replace(kwargs) - вернет новый экземпляр именованного кортежа, заменив указанные поля новыми значениями.
._field_defaults - вернет словарь, который сопоставляет имена полей со значениями по умолчанию.
возвращает новый подкласс кортежа с именем typename. Новый подкласс используется для создания объектов, похожих на кортежи, которые имеют индексируемые и итерируемые поля, доступные для поиска по атрибутам.
t = [11, 22] Point._make(t) 👉 Point(x=11, y=22)
p = Point(x=11, y=22)
p._asdict()
👉 {'x': 11, 'y': 22}
p = Point(x=11, y=22) p._replace(x=33) 👉 Point(x=33, y=22)
Point(x=11, y=22)
Color = namedtuple('Color', 'red green blue')
Pixel = namedtuple('Pixel', Point._fields + Color._fields)
👉 Pixel(11, 22, 128, 255, 0)
👉 Pixel(x=11, y=22, red=128, green=255, blue=0)
Account = namedtuple('Account', ['type', 'balance'], defaults=[0])
Account._field_defaults
👉 {'balance': 0}
Account('premium')
👉 Account(type='premium', balance=0)
Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)
p[0] + p[1]
👉 33
collections.deque
.deque.append(x) - добавляет x к правой стороне (в конец) контейнера deque().
.deque.appendleft(x) - добавляет x к левой стороне (в начало) контейнера deque().
.deque.copy() - создает мелкую копию контейнера deque().
.deque.clear() - удаляет все элементы из контейнера deque(), оставляя его длиной 0.
.deque.count(x) - подсчитывает количество элементов контейнера deque(), равное значению x.
.deque.extend(iterable) - расширяет правую сторону (с конца) контейнера deque(), добавляя элементы из итерируемого аргумента iterable.
.deque.extendleft(iterable) - расширяет левую сторону (с начала) контейнера deque(), добавляя элементы из итерируемого аргумента iterable.
.deque.index(x[, start[, stop]]) - вернет позицию (индекс) первого совпадения значения аргумента x в контейнере deque(), расположенного после необязательного аргумента start и до необязательного аргумента stop.
.deque.insert(i, x) - вставляет значение аргумента x в позицию i контейнера deque().
.deque.pop() - удаляет и возвращает элемент с правой стороны (с конца).
.deque.popleft() - удаляет и возвращает элемент с левой стороны (с начала)
.deque.remove(value) - удаляет первое вхождение значения value в контейнер deque().
.deque.reverse() - разворачивает элементы контейнера deque() на месте и возвращает None.
.deque.rotate(n=1) - разворачивает контейнер deque() на n шагов вправо. Если аргумент n имеет отрицательное значение, то разворачивает контейнер налево.
.deque.maxlen - возвращает максимальный размер maxlen контейнера deque(), если параметр maxlen не задан, то возвращает None.
is preferred over a list in the cases where we need quicker append and pop operations from both the ends of the container, as deque provides an O(1) time complexity for append and pop operations as compared to list which provides O(n) time complexity.
queue = deque(['name','age','DOB']) print(queue) 👉 deque(['name', 'age', 'DOB'])
dq = deque('ghi')
👉 deque(['g', 'h', 'i'])
deque(['g', 'h', 'i'])
dq.append('j')
dq
👉 deque(['g', 'h', 'i', 'j'])
deque(['g', 'h', 'i', 'j'])
dq.appendleft('f')
dq
👉 deque(['f', 'g', 'h', 'i', 'j'])
deque(['f', 'g', 'h', 'i', 'j']) cp_dq = dq.copy() cp_dq 👉 deque(['f', 'g', 'h', 'i', 'j'])
deque(['f', 'g', 'h', 'i', 'j'])
dq.append('g')
dq.count('g')
👉 2
dq
👉 deque(['f', 'g', 'h', 'i', 'j', 'g'])
deque(['f', 'g', 'h', 'i', 'j', 'g'])
dq.extend('jkl')
dq
👉 deque(['f', 'g', 'h', 'i', 'j', 'g', 'j', 'k', 'l'])
deque(['f', 'g', 'h', 'i', 'j', 'g', 'j', 'k', 'l'])
dq.extendleft('ab')
dq
👉 deque(['b', 'a', 'f', 'g', 'h', 'i', 'j', 'g', 'j', 'k', 'l'])
deque(['b', 'a', 'f', 'g', 'h', 'i', 'j', 'g', 'j', 'k', 'l'])
dq.index('g', 2)
👉 3
deque(['b', 'a', 'f', 'g', 'h', 'i', 'j', 'g', 'j', 'k', 'l']) dq.insert(2, 'c') dq 👉 deque(['b', 'a', 'c', 'f', 'g', 'h', 'i', 'j', 'g', 'j', 'k', 'l'])
dq.pop() 👉 'i'
dq.popleft() 👉 'b'
dq.remove('g')
dq
👉 deque(['a', 'c', 'f', 'h', 'i', 'j', 'g', 'j', 'k'])
deque(['a', 'c', 'f', 'h', 'i', 'j', 'g', 'j', 'k']) dq.reverse() dq 👉 deque(['k', 'j', 'g', 'j', 'i', 'h', 'f', 'c', 'a'])
dq.rotate(2) dq 👉 deque(['c', 'a', 'k', 'j', 'g', 'j', 'i', 'h', 'f']) dq.rotate(-4) dq 👉 deque(['g', 'j', 'i', 'h', 'f', 'c', 'a', 'k', 'j']
@decorator
чтобы получить декоратор, в который можно передать аргументы, нужно из функции с параметрами вернуть функциональный объект, который может действовать как декоратор.
def decorator(func):
return func
@decorator
def f(x):
print(f'hello {x}')
f(1)
👉 hello 1
def decorator(func):
def wrapper(x):
print("Before " + func.\_\_name\_\_)
func(x.upper())
print("After " + func.\_\_name\_\_)
return wrapper
@decorator
def user(name):
print(f"Hi, {name}")
user("sam")
👉 Before user
👉 Hi, SAM
👉 After user
def decorator(gretting, farewell):
def decorator_2(func):
def decorator_inner(*args, **kwargs):
print(gretting)
ret = func(*args, **kwargs)
print(farewell)
return ret
return decorator_inner
return decorator_2
@decorator('hello', 'goodbye')
def f(x: int) -> None:
print(f'hello {x}')
f(1)
👉 hello
👉 hello 1
👉 goodbye
pandas.melt(frame, id_vars=None, value_vars=None, var_name=None, value_name=’value’, col_level=None, ignore_index=True)
Unpivot a DataFrame from wide to long format, optionally leaving identifiers set.
df = pd.DataFrame({'A': ['a', 'b', 'c'],
'B': [1, 3, 5],
'C': [2, 4, 6]})
new = pd.melt(df, id_vars=['A'], value_vars=['B'])
print(new)
A variable value
0 a B 1
1 b B 3
2 c B 5
df = pd.DataFrame({'A': ['a', 'b', 'c'],
'B': [1, 3, 5],
'C': [2, 4, 6]})
new_2 = pd.melt(df, id_vars=['A'], value_vars=['B', 'C'])
print(new_2)
A variable value
0 a B 1
1 b B 3
2 c B 5
3 a C 2
4 b C 4
5 c C 6
pandas.wide_to_long(df, stubnames, i, j, sep=’’, suffix=’\d+’)
Unpivot a DataFrame from wide to long format. Less flexible but more user-friendly than melt.
df = pd.DataFrame({
'famid': [1, 1, 1, 2, 2, 2, 3, 3, 3],
'birth': [1, 2, 3, 1, 2, 3, 1, 2, 3],
'ht1': [2.8, 2.9, 2.2, 2, 1.8, 1.9, 2.2, 2.3, 2.1],
'ht2': [3.4, 3.8, 2.9, 3.2, 2.8, 2.4, 3.3, 3.4, 2.9]
})
l = pd.wide_to_long(df, stubnames='ht', i=['famid', 'birth'], j='age')
famid birth age
1 1 1 2.8
2 3.4
2 1 2.9
2 3.8
3 1 2.2
2 2.9
2 1 1 2.0
2 3.2
2 1 1.8
2 2.8
3 1 1.9
2 2.4
3 1 1 2.2
2 3.3
2 1 2.3
2 3.4
3 1 2.1
2 2.9
string.partition(sep)
разбивает строку при первом появлении разделителя sep и вернет кортеж, содержащий часть строки str перед разделителем, сам разделитель sep и часть строки str после разделителя.
x = 'один два три раз, два три раз два три'
sep = 'раз'
x.partition(sep)
('один два три ', 'раз', ' два три раз два три')
x.partition(' ')
('один', ' ', 'два три раз два три раз два три')
x.partition('четыре')
('один два три раз, два три раз два три', '', '')
inspect.signature() and inspect.getargspec()
get the list of parameters name of function or method passed as an argument in one of the methods.
import inspect print(inspect.signature(collections.Counter)) 👉 (*args, **kwds)
def fun(a, b):
return a**b
print(inspect.signature(fun))
👉 (a, b)
print(inspect.signature(len)) 👉 (obj, /)
print(inspect.getargspec(collections.Counter)) 👉 ArgSpec(args=[], varargs=’args’, keywords=’kwds’, defaults=None)
def fun(a, b):
return a**b
print(inspect.getargspec(fun))
👉 ArgSpec(args=[‘a’, ‘b’], varargs=None, keywords=None, defaults=None)
collections.OrderedDict([items])
.move_to_end() - для эффективного перемещения элемента в конечную точку.
.popitem(last=True) - для упорядоченных словарей возвращает и удаляет пару (key, value). Пары (key, value) возвращаются в порядке LIFO, если аргумент last=True или в порядке FIFO, если last=False.
возвращает экземпляр подкласса dict, у которого есть методы, специализированные для изменения порядка словаря. И удления как в списке с помошью pop.
d = OrderedDict.fromkeys('abcde')
d.move_to_end('b')
''.join(d.keys())
👉 'acdeb'
d = OrderedDict.fromkeys('abcde
d.move_to_end('b', last=False)
''.join(d.keys())
👉 'bacde'
od = OrderedDict() od['a'] = 1 od['b'] = 2 od['c'] = 3 od['d'] = 4
collection.ChainMap()
.maps - представляет собой обновляемый пользователем список словарей dict() и должен всегда содержать хотя бы один словарь.
.new_child(m=None) - возвращает новый экземпляр класса ChainMap(), содержащий новый словарь m, за которым следуют все словари в текущем экземпляре.
.parents - возвращает новый экземпляр класса ChainMap(), содержащий все словари в текущем экземпляре, кроме первого. Это полезно для пропуска первого словаря при поиске ключей.
предназначен для быстрого oбъединения нескольких словарей, чтобы их можно было рассматривать как единое целое.
from collections import ChainMap
first = {'two': 22, 'three': 3}
last = {'one': 1, 'two': 2}
d = ChainMap(first, last)
👉 ChainMap({'two': 22, 'three': 3}, {'one': 1, 'two': 2})
d = ChainMap({'two': 22, 'three': 3}, {'one': 1, 'two': 2})
d['four'] = 4
👉 ChainMap({'two': 22, 'three': 3, 'four': 4}, {'one': 1, 'two': 2})
d['one'] = 11
👉 ChainMap({'two': 22, 'three': 3, 'one': 11}, {'one': 1, 'two': 2})
d.maps
👉 [{'three': 3, 'one': 11}, {'one': 1, 'two': 2, 'four': 4}]
d = [{'three': 3, 'one': 11}, {'one': 1, 'two': 2, 'four': 4}]
d['one']
👉 11
d.maps.reverse()
d.maps
👉 [{'one': 1, 'two': 2, 'four': 4}, {'three': 3, 'one': 11}]
d_child = d.new_child()
👉 ChainMap({}, {'one': 0, 'two': 2, 'five': 5}, {'a': 10, 'b': 20})
d_child = d.new_child({'one': 1, 'a': 1})
👉 ChainMap({'one': 1, 'a': 1}, {'one': 0, 'two': 2, 'five': 5}, {'a': 10, 'b': 20})
d_child.parents
👉 ChainMap({'one': 0, 'two': 2, 'five': 5}, {'a': 10, 'b': 20})
d.parents
👉 ChainMap({'a': 10, 'b': 20})
file.open(file, mod=”r”, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
🎯 file - абсолютное или относительное значение пути к файлу или файловый дескриптор открываемого файла.
🎯 mode - необязательно, строка, которая указывает режим, в котором открывается файл.
❗ r - открывает файл только для чтения,
❗ w - открыт для записи (перед записью файл будет очищен),
❗ x - эксклюзивное создание, бросается исключение FileExistsError, если файл уже существует.
❗ a - открыт для добавления в конец файла (на некоторых Unix-системах пишет в конец файла вне зависимости от позиции курсора).
❗ + - символ обновления (чтение + запись).
❗ t - символ текстового режима.
❗ b - символ двоичного режима.
🎯 buffering - необязательно, целое число, используемое для установки политики буферизации.
🎯 encoding - необязательно, кодировка, используемая для декодирования или кодирования файла.
🎯 errors - необязательно, строка, которая указывает, как должны обрабатываться ошибки кодирования и декодирования.
🎯 newline - необязательно, режим перевода строк. Варианты: None, ‘\n’, ‘\r’ и ‘\r\n’. Следует использовать только для текстовых файлов.
🎯 closefd - необязательно, bool, флаг закрытия файлового дескриптора.
🎯 opener - необязательно, пользовательский объект, возвращающий открытый дескриптор файла.
file.read(size)
🎯 size - Optional. The number of bytes to return. Default -1, which means the whole file.
method returns content of the file.
f = open("demofile.txt", "r")
print(f.read())
Hello! Welcome to demofile.txt
This file is for testing purposes.
Good Luck!
f = open("demofile.txt", "r")
print(f.read(33))
Hello! Welcome to demofile.txt
Th
file.seek(offset[, whence])
🎯 file - объект файла
🎯 offset - int байтов, смещение указателя чтения/записи файла.
🎯 whence - int, абсолютное позиционирование указателя.
❗ 0 - означает, что нужно сместить указатель на offset относительно начала файла.
❗ 1 - означает, что нужно сместить указатель на offset относительно относительно текущей позиции.
❗ 2 - означает, что нужно сместить указатель на offset относительно конца файла.
устанавливает текущую позицию в байтах offset для указателя чтения/записи в файле file.
text = b'This is 1st line\nThis is 2nd line\nThis is 3rd line\n'
fp = open('foo.txt', 'bw+')
fp.write(text)
👉 51
fp.seek(20, 0)
👉 20
fp.read(10)
👉 b's is 2nd l'
fp.seek(10, 1)
👉 40
fp.read(10)
👉 b's 3rd line'
fp.seek(-11, 2)
👉 40
fp.read(10)
👉 b's 3rd line'
fp.close()
file.readable()
method returns True if the file is readable, False if not.
f = open("demofile.txt", "r")
print(f.readable())
👉 True
