Python sklearn-kmeans как получить значения в кластере

Convenience factory functions¶

The module provides factory functions to conveniently create
IP addresses, networks and interfaces:

(address)

Return an or object depending on
the IP address passed as argument. Either IPv4 or IPv6 addresses may be
supplied; integers less than 2**32 will be considered to be IPv4 by default.
A is raised if address does not represent a valid IPv4
or IPv6 address.

>>> ipaddress.ip_address('192.168.0.1')
IPv4Address('192.168.0.1')
>>> ipaddress.ip_address('2001:db8::')
IPv6Address('2001:db8::')
(address, strict=True)

Return an or object depending on
the IP address passed as argument. address is a string or integer
representing the IP network. Either IPv4 or IPv6 networks may be supplied;
integers less than 2**32 will be considered to be IPv4 by default. strict
is passed to or constructor. A
is raised if address does not represent a valid IPv4 or
IPv6 address, or if the network has host bits set.

>>> ipaddress.ip_network('192.168.0.0/28')
IPv4Network('192.168.0.0/28')
(address)

Return an or object depending
on the IP address passed as argument. address is a string or integer
representing the IP address. Either IPv4 or IPv6 addresses may be supplied;
integers less than 2**32 will be considered to be IPv4 by default. A
is raised if address does not represent a valid IPv4 or
IPv6 address.

Tests

The following command lines are executed and verified by clitest, using the command.

First, setup a sample text file:

$ echo 'the quick brown fox' > file.txt
$ cat file.txt
the quick brown fox
$

Now we’ll do some replaces using string matching, which is the default. Note that there are short and long options (/) and that the replacement is performed globally: all occurrences are replaced.

$ ./replace.py --from 'brown' --to 'red' file.txt
the quick red fox
$ ./replace.py -f 'brown' -t 'red' file.txt
the quick red fox
$ ./replace.py -f 'o' -t '◆' file.txt
the quick br◆wn f◆x
$

For more powerfull searches, use or to perform a regular expression match. You have access to the full power of Python’s regex flavor.

$ ./replace.py --regex -f '' -t '◆' file.txt
th◆ q◆◆ck br◆wn f◆x
$ ./replace.py -r -f '' -t '◆' file.txt
th◆ q◆◆ck br◆wn f◆x
$

If necessary, you can also apply the replacements on text coming from STDIN, using as the file name.

$ cat file.txt | ./replace.py -r -f '' -t '◆' -
th◆ q◆◆ck br◆wn f◆x
$

Note that all the previous replaces were not saved to the original file. This is the default behavior (just like ). If you want to edit the original file, use the or options:

$ ./replace.py -r -f '' -t '◆' -i file.txt
Saved file.txt
$ cat file.txt
th◆ q◆◆ck br◆wn f◆x
$

Some boring tests for missing or incomplete command line options:

$ ./replace.py 2>&1 | grep error
replace.py: error: the following arguments are required: FILE
$ ./replace.py README.md
Error: No search pattern (use --from or --from-file)
$ ./replace.py -f '' README.md
Error: No search pattern (use --from or --from-file)
$ ./replace.py -f foo README.md
Error: No replace pattern (use --to or --to-file)
$

OK, we’re done for now.

$ rm file.txt
$

Когда лучше с одним потоком

  • При взаимозависимых вычислениях. Считать что-то в одном потоке и передавать для дальнейшей обработки второму — плохая идея. Возникает лишняя зависимость, которая приводит к снижению производительности, а в случае ошибки  — к ступору и краху программы.
  • При работе через GIL. Это мы уже выяснили выше.
  • Когда важна хорошая переносимость на разных устройствах. Правильно подобрать число потоков для машины пользователя  — задача не из легких. Если вы пишете под известное вам «железо», всё можно решить тестированием. Если же нет  — понадобится дополнительно создавать гибкую систему подстройки под аппаратную часть, что потребует времени и умения.

Аргументы функции

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

>>> def func(a, b, c=2): # c - необязательный аргумент
...     return a + b + c
...
>>> func(1, 2)  # a = 1, b = 2, c = 2 (по умолчанию)
5
>>> func(1, 2, 3)  # a = 1, b = 2, c = 3
6
>>> func(a=1, b=3)  # a = 1, b = 3, c = 2
6
>>> func(a=3, c=6)  # a = 3, c = 6, b не определен
Traceback (most recent call last):
  File "", line 1, in
    func(a=3, c=6)
TypeError: func() takes at least 2 arguments (2 given)

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

>>> def func(*args):
...     return args
...
>>> func(1, 2, 3, 'abc')
(1, 2, 3, 'abc')
>>> func()
()
>>> func(1)
(1,)

Как видно из примера, args — это кортеж из всех переданных аргументов функции, и с переменной можно работать также, как и с кортежем.

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

>>> def func(**kwargs):
...     return kwargs
...
>>> func(a=1, b=2, c=3)
{'a': 1, 'c': 3, 'b': 2}
>>> func()
{}
>>> func(a='python')
{'a': 'python'}

Создание моделей в Peewee

Сейчас я перейду к созданию моделей. В этой статье я использую две таблицы или модели: «Категория» и «Продукт«. Категория может содержать несколько продуктов. Сохраняем как файл models.py

models.py

Python

from peewee import *

class BaseModel(Model):
class Meta:
database = dbhandle

class Category(BaseModel):
id = PrimaryKeyField(null=False)
name = CharField(max_length=100)

created_at = DateTimeField(default=datetime.datetime.now())
updated_at = DateTimeField(default=datetime.datetime.now())

class Meta:
db_table = «categories»
order_by = (‘created_at’,)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

frompeewee import*

classBaseModel(Model)

classMeta

database=dbhandle

classCategory(BaseModel)

id=PrimaryKeyField(null=False)

name=CharField(max_length=100)

created_at=DateTimeField(default=datetime.datetime.now())

updated_at=DateTimeField(default=datetime.datetime.now())

classMeta

db_table=»categories»

order_by=(‘created_at’,)

Сначала я создал BaseModel. Это связанно с тем, что Peewee просит вас передать dbhandle в каждый класс Model. Чтобы избежать лишних движений, я просто создал базовый класс и расширил его. Ознакомиться со всеми типами столбцов в таблице можно тут: 

Хорошо, наша BaseModel и Category созданы. Модель Category состоит из четырех полей:

  1. id, который является полем автоматического прироста;
  2. name содержит имя категории;
  3. updated_at и created_at – поля timestamp, которые определяют настоящее время по умолчанию.

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

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

Python

import peewee
from models import *

if __name__ == ‘__main__’:
try:
dbhandle.connect()
Category.create_table()
except peewee.InternalError as px:
print(str(px))

1
2
3
4
5
6
7
8
9

importpeewee

frommodels import*

if__name__==’__main__’

try

dbhandle.connect()

Category.create_table()

exceptpeewee.InternalError aspx

print(str(px))

После импорта, я подключаюсь к базе данных. Ошибка peewee.OperationalError ссылается на все ошибки, связанные с Peewee. К примеру, если вы введете неправильные учетные данные, вы получите следующее:

Python

(1045, «Access denied for user ‘root1’@’localhost’ (using password: YES)»)

1 (1045,»Access denied for user ‘root1’@’localhost’ (using password: YES)»)

Затем мы вызываем Category.create_table(), которые создает таблицу с указанной ранее собственностью. Если вы передаете safe=True в качестве параметра, то существующая таблица просто перепишется. Это может привести к проблемам в реальной ситуации.

Далее, модель Product:

Python

class Product(BaseModel):
id = PrimaryKeyField(null=False)
name = CharField(max_length=100)
price = FloatField(default=None)
category = ForeignKeyField(Category, related_name=’fk_cat_prod’, to_field=’id’, on_delete=’cascade’,
on_update=’cascade’)
created_at = DateTimeField(default=datetime.datetime.now())
updated_at = DateTimeField(default=datetime.datetime.now())

class Meta:
db_table = «products»
order_by = (‘created_at’,)

1
2
3
4
5
6
7
8
9
10
11
12

classProduct(BaseModel)

id=PrimaryKeyField(null=False)

name=CharField(max_length=100)

price=FloatField(default=None)

category=ForeignKeyField(Category,related_name=’fk_cat_prod’,to_field=’id’,on_delete=’cascade’,

on_update=’cascade’)

created_at=DateTimeField(default=datetime.datetime.now())

updated_at=DateTimeField(default=datetime.datetime.now())

classMeta

db_table=»products»

order_by=(‘created_at’,)

Она аналогична модели Cateogory. Разница только в ForeignKeyField, который указывает, как именно Product должен быть связан с Category. Обновление основы должно выглядеть следующим образом:

Python

if __name__ == ‘__main__’:
try:
dbhandle.connect()
Category.create_table()
except peewee.InternalError as px:
print(str(px))
try:
Product.create_table()
except peewee.InternalError as px:
print(str(px))

1
2
3
4
5
6
7
8
9
10

if__name__==’__main__’

try

dbhandle.connect()

Category.create_table()

exceptpeewee.InternalError aspx

print(str(px))

try

Product.create_table()

exceptpeewee.InternalError aspx

print(str(px))

После запуска указанного выше кода, создается таблица модели product, а также отношение с таблицей categories. Вот скриншот моего клиента sql:

A numeric example

I have another example that quite impressed me at the time.

Where all variables are positive integers, and a is at least as large
as the n’th root of x, this algorithm returns the floor of the n’th
root of x (and roughly doubling the number of accurate bits per
iteration):

while a > (d := x // a**(n-1)):
    a = ((n-1)*a + d) // n
return a

It’s not obvious why that works, but is no more obvious in the «loop
and a half» form. It’s hard to prove correctness without building on
the right insight (the «arithmetic mean — geometric mean inequality»),
and knowing some non-trivial things about how nested floor functions
behave. That is, the challenges are in the math, not really in the
coding.

If you do know all that, then the assignment-expression form is easily
read as «while the current guess is too large, get a smaller guess»,
where the «too large?» test and the new guess share an expensive
sub-expression.

To my eyes, the original form is harder to understand:

while True:
    d = x // a**(n-1)
    if a 

10 *args and **kwargs

用和只是为了方便并没有强制使用它们.

当你不确定你的函数里将要传递多少参数时你可以用.例如,它可以传递任意数量的参数:

>>> def print_everything(*args):
        for count, thing in enumerate(args):
...         print '{0}. {1}'.format(count, thing)
...
>>> print_everything('apple', 'banana', 'cabbage')
. apple
1. banana
2. cabbage

相似的,允许你使用没有事先定义的参数名:

>>> def table_things(**kwargs):
...     for name, value in kwargs.items():
...         print '{0} = {1}'.format(name, value)
...
>>> table_things(apple = 'fruit', cabbage = 'vegetable')
cabbage = vegetable
apple = fruit

你也可以混着用.命名参数首先获得参数值然后所有的其他参数都传递给和.命名参数在列表的最前端.例如:

和可以同时在函数的定义中,但是必须在前面.

当调用函数时你也可以用和语法.例如:

>>> def print_three_things(a, b, c):
...     print 'a = {0}, b = {1}, c = {2}'.format(a,b,c)
...
>>> mylist = 
>>> print_three_things(*mylist)

a = aardvark, b = baboon, c = cat

就像你看到的一样,它可以传递列表(或者元组)的每一项并把它们解包.注意必须与它们在函数里的参数相吻合.当然,你也可以在函数定义或者函数调用时用*.

7 Python中单下划线和双下划线

>>> class MyClass():
...     def __init__(self):
...             self.__superprivate = "Hello"
...             self._semiprivate = ", world!"
...
>>> mc = MyClass()
>>> print mc.__superprivate
Traceback (most recent call last):
  File "", line 1, in module>
AttributeError: myClass instance has no attribute '__superprivate'
>>> print mc._semiprivate
, world!
>>> print mc.__dict__
{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}

:一种约定,Python内部的名字,用来区别其他用户自定义的命名,以防冲突,就是例如,,这些特殊方法

:一种约定,用来指定变量私有.程序员用来指定私有变量的一种方式.不能用from module import * 导入,其他方面和公有一样访问;

:这个有真正的意义:解析器用来代替这个名字,以区别和其他类相同的命名,它无法直接像公有成员一样随便访问,通过对象名._类名__xxx这样的方式可以访问.

Замена в строке

Чтобы в Python заменить в строке одну подстроку на другую, применяют метод replace():
• replace(old, new): подстрока old заменяется на new;
• replace(old, new, num): параметр num показывает, сколько вхождений подстроки old требуется заменить на new.

Пример замены в строке в Python:

    phone = "+1-234-567-89-10"

# дефисы меняются на пробелы
edited_phone = phone.replace("-", " ")
print(edited_phone)     # +1 234 567 89 10

# дефисы удаляются
edited_phone = phone.replace("-", "")
print(edited_phone)     # +12345678910

# меняется только первый дефис
edited_phone = phone.replace("-", "", 1)
print(edited_phone)     # +1234-567-89-10

Обрабатываем строку в Python

Представим, что ожидается ввод числа с клавиатуры. Перед преобразованием введенной нами строки в число можно легко проверить, введено ли действительно число. Если это так, выполнится операция преобразования. Для обработки строки используем такой метод в Python, как isnumeric():

string = input("Введите какое-нибудь число: ")
if string.isnumeric():
    number = int(string)
    print(number)

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

string = "   привет мир!  "
string = string.strip()
print(string)           # привет мир!

Так можно дополнить строку пробелами и выполнить выравнивание:

print("iPhone 7:", "52000".rjust(10))
print("Huawei P10:", "36000".rjust(10))

В консоли Python будет выведено следующее:

iPhone 7      52000
Huawei P10      36000

#3 Интерполяция строк / f-Строки (Python 3.6+)

Python 3.6 Добавил новый подход форматирования строк под названием форматированные строчные литералы, или “f-строки”. Этот новый способ форматирования строк позволяет вам использовать встроенные выражения Python внутрь строковых констант. Вот простой, наглядный пример:

Python

name = ‘Bob’
print(f’Hello, {name}!’)

# Вывод: ‘Hello, Bob!’

1
2
3
4

name=’Bob’

print(f’Hello, {name}!’)

 
# Вывод: ‘Hello, Bob!’

Как вы видите, это добавляет префикс к константе строки с буквой “f” — следовательно, названием становится “f-strings”. Этот новый синтаксис форматирования — очень мощный. Так как вы можете вставлять произвольные выражения Python, вы можете даже проводить встроенную арифметику. Посмотрим на пример:

Python

a = 5
b = 10
print(f’Five plus ten is {a + b} and not {2 * (a + b)}.’)

# Вывод: ‘Five plus ten is 15 and not 30.’

1
2
3
4
5

a=5

b=10

print(f’Five plus ten is {a + b} and not {2 * (a + b)}.’)

 
# Вывод: ‘Five plus ten is 15 and not 30.’

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

Представьте, что у вас есть следующая функция greet(), которая содержит :

Python

def greet(name, question):
return f»Hello, {name}! How’s it {question}?»

print(greet(‘Bob’, ‘going’))

# Вывод: «Hello, Bob! How’s it going?»

1
2
3
4
5
6
7

defgreet(name,question)

returnf»Hello, {name}! How’s it {question}?»

print(greet(‘Bob’,’going’))

 
# Вывод: «Hello, Bob! How’s it going?»

Когда вы разбираете функцию, и смотрите, что происходит за кулисами, вы увидите, что f-строка в функции трансформируется в нечто, похожее на следующее:

Python

def greet(name, question):
return «Hello, » + name + «! How’s it » + question + «?»

1
2

defgreet(name,question)

return»Hello, «+name+»! How’s it «+question+»?»

Python

>>> import dis
>>> dis.dis(greet)
2 0 LOAD_CONST 1 (‘Hello, ‘)
2 LOAD_FAST 0 (name)
4 FORMAT_VALUE 0
6 LOAD_CONST 2 («! How’s it «)
8 LOAD_FAST 1 (question)
10 FORMAT_VALUE 0
12 LOAD_CONST 3 (‘?’)
14 BUILD_STRING 5
16 RETURN_VALUE

1
2
3
4
5
6
7
8
9
10
11

>>>importdis

>>>dis.dis(greet)

2LOAD_CONST1(‘Hello, ‘)

2LOAD_FAST(name)

4FORMAT_VALUE

6LOAD_CONST2(«! How’s it «)

8LOAD_FAST1(question)

10FORMAT_VALUE

12LOAD_CONST3(‘?’)

14BUILD_STRING5

16RETURN_VALUE

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

Python

print(f»Hey {name}, there’s a {errno:#x} error!»)

# Вывод: «Hey Bob, there’s a 0xbadc0ffee error!»

1
2
3

print(f»Hey {name}, there’s a {errno:#x} error!»)

 
# Вывод: «Hey Bob, there’s a 0xbadc0ffee error!»

Новые форматированные строчные литералы аналогичны шаблонным литералам (Template Literals) в JavaScript, которые были добавлены в ES2015. Я думаю это достаточно хорошее нововведение в Python, и я бы с радостью пользовался ими на каждодневной основе (в Python 3). Вы можете узнать больше о форматированных строчных литералах в интернете.

#2 Форматирование строк “По новому” (str.format)

Python 3 предоставил новый способ форматирования, который также был внесен в раннюю версию Python 2.7. Этот “новый стиль” форматирования строк избавляется от специального синтаксиса оператора % и делает синтаксис для форматирования строк более регулярным. Теперь форматирование обрабатывается вызовом .format() в объекте строки.

Вы можете использовать format(), чтобы выполнить простое позиционное форматирование, также, как мы делали это по старинке:

Python

print(‘Hello, {}’.format(name))
# Вывод: ‘Hello, Bob’

1
2

print(‘Hello, {}’.format(name))

# Вывод: ‘Hello, Bob’

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

Python

print(
‘Hey {name}, there is a 0x{errno:x} error!’.format(
name=name, errno=errno
)
)

# Вывод: ‘Hey Bob, there is a 0xbadc0ffee error!’

1
2
3
4
5
6
7

print(

‘Hey {name}, there is a 0x{errno:x} error!’.format(

name=name,errno=errno

)

)
 
# Вывод: ‘Hey Bob, there is a 0xbadc0ffee error!’

Однако, официальная документация Python 3 не делает явных рекомендаций по использованию старого форматирования:

По этому я лично пытаюсь работать str.format при продвижении нового кода. Начав с Python 3.6, есть еще один способ форматирования ваших строк. Рассмотрим его в следующем разделе!

Встроенные строковые методы (или методы строк)

UPD: смотрите более полное описание строковых методов тут>>>.

В Python имеются такие встроенные методы для управление строками:

SN Methods with Description
1

делает первую букву Заглавной;

2

возвращает новую строку, смещенную к центру на указанное количество символов;

3

подсчитывает количество вхождений заданных символов в переданной строке;

4

декодирует строку, используя заданный метод кодировки;

5

кодирует строку, используя заданный метод кодировки;

6

определяет, заканчивается ли строка заданным суффиксом; возвращает истину (true) если да, и ложь (false) в противном случае;

7

увеличивает количество пробелов для табуляции, по-умолчанию — 8;

8

Определяет, содержатся ли заданные символы в в строке, и возвращает их индкс если найдены или -1 если нет;

9

тоже, что и find(), но приводит к ошибке если не найдено;

10

возвращает истину (true), если в строке содержится хотя бы один символ, и все символы являются буквенно-цифровыми;

11

возвращает истину (true), если в строке содержится хотя бы один символ, и все символы являются  буквами;

12

возвращает истину (true), если в строке содержится хотя бы один символ, и все символы являются цифрами;

13

возвращает true, если строка содержит хотя бы один символ и все символы в строке строчные;

14

возвращает true, если unicode-строка содержит только цифры;

15

возвращает true, если строка состоит из пробелов;

16

возвращает true, если строка содержит правильно оформленные заглавные буквы (т.е. — только первые в предложении);

17

возвращает true, если строка содержит хотя бы один форматированный символ и все символы — заглавные;

18

объединяет заданные в последовательности seq объекты в один список с заданным в строке разделителем;

19

возвращает количество символов в строке;

20

Returns a space-padded string with the original string left-justified to a total of width columns

21

меняет все заглавные буквы в строке в строчные;

22

удаляет все пробелы в начале строки;

23

создаёт таблицу для перевода функцией translate();

24

возвращает наибольший (последний) по алфавиту символ из строки (Eng);

25

возвращает наименьший (первый) по алфавиту символ из строки (Eng);

26

меняет заданные символы в строке на новые;

27

тоже, что и find(), но ищет в обратном направлении;

28

тоже, что и index(), о ищет в обратном направлении;

29

Returns a space-padded string with the original string right-justified to a total of width columns.

30

удаляет все пробелы в конце строки;

31

разделяет строку по заданному в str символу и возвращает новые строки (новыми объектами); разделяет максимум = num раз, если указано;

32

Splits string at all (or num) NEWLINEs and returns a list of each line with NEWLINEs removed

33

определяет, начинается ли строка с заданного в str символа; возвращает true если да;

34

выполняет lstrip() и rstrip();

35

изменяет регистр всех символов на обратный;

36

возвращает «заглавную» версию строки, где все слова начинаются с Заглавной буквы, а остальные символы — строчные;

37

переводит строку в соответствии с с таблицей перевода;

38

меняет все строчные символы на прописные;

39

Returns original string leftpadded with zeros to a total of width characters; intended for numbers, zfill() retains any sign given (less one zero)

40

возвращает true, если unicode-строка содержит только десятичные символы;

9 交叉链表求交点

# 使用a,b两个list来模拟链表,可以看出交叉点是 7这个节点
a = 
b = 

for i in range(1,min(len(a),len(b))):
    if i==1 and (a != b):
        print "No"
        break
    else:
        if a != b:
            print "交叉节点:",a
            break
        else:
            pass
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
def node(l1, l2):
    length1, lenth2 = , 
    # 求两个链表长度
    while l1.next:
        l1 = l1.next
        length1 += 1
    while l2.next:
        l2 = l2.next
        length2 += 1
    # 长的链表先走
    if length1 > lenth2:
        for _ in range(length1 - length2):
            l1 = l1.next
    else:
        for _ in range(length2 - length1):
            l2 = l2.next
    while l1 and l2:
        if l1.next == l2.next:
            return l1.next
        else:
            l1 = l1.next
            l2 = l2.next

修改了一下:

#coding:utf-8
class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

def node(l1, l2):
    length1, length2 = , 
    # 求两个链表长度
    while l1.next:
        l1 = l1.next#尾节点
        length1 += 1
    while l2.next:
        l2 = l2.next#尾节点
        length2 += 1

    #如果相交
    if l1.next == l2.next:
        # 长的链表先走
        if length1 > length2:
            for _ in range(length1 - length2):
                l1 = l1.next
            return l1#返回交点
        else:
            for _ in range(length2 - length1):
                l2 = l2.next
            return l2#返回交点
    # 如果不相交
    else:
        return

Произвольные выражения

Так как f-строки оцениваются по мере выражения, вы можете внести любую или все доступные выражения Python в них. Это позволит вам делать интересные вещи, например следующее:

Python

print(f»{2 * 37}»)
# Вывод: ’74’

1
2

print(f»{2 * 37}»)

# Вывод: ’74’

Также вы можете вызывать функции. Пример:

Python

def to_lowercase(input):
return input.lower()

name = «Eric Idle»

print(f»{to_lowercase(name)} is funny.»)
# Вывод: ‘eric idle is funny.’

1
2
3
4
5
6
7

defto_lowercase(input)

returninput.lower()

name=»Eric Idle»

print(f»{to_lowercase(name)} is funny.»)

# Вывод: ‘eric idle is funny.’

Также вы можете вызывать метод напрямую:

Python

print(f»{name.lower()} is funny.»)
# Вывод: ‘eric idle is funny.’

1
2

print(f»{name.lower()} is funny.»)

# Вывод: ‘eric idle is funny.’

Вы даже можете использовать объекты, созданные из классов при помощи f-строки. Представим, что у вас есть следующий класс:

Python

class Comedian:
def __init__(self, first_name, last_name, age):
self.first_name = first_name
self.last_name = last_name
self.age = age

def __str__(self):
return f»{self.first_name} {self.last_name} is {self.age}.»

def __repr__(self):
return f»{self.first_name} {self.last_name} is {self.age}. Surprise!»

1
2
3
4
5
6
7
8
9
10
11

classComedian

def__init__(self,first_name,last_name,age)

self.first_name=first_name

self.last_name=last_name

self.age=age

def__str__(self)

returnf»{self.first_name} {self.last_name} is {self.age}.»

def__repr__(self)

returnf»{self.first_name} {self.last_name} is {self.age}. Surprise!»

Вы могли бы сделать следующее:

Python

new_comedian = Comedian(«Eric», «Idle», «74»)

print(f»{new_comedian}»)
# Вывод: ‘Eric Idle is 74.’

1
2
3
4

new_comedian=Comedian(«Eric»,»Idle»,»74″)

print(f»{new_comedian}»)

# Вывод: ‘Eric Idle is 74.’

Методы __str__() и __repr__() работают с тем, как объекты отображаются в качестве строк, так что вам нужно убедиться в том, что вы используете один из этих методов в вашем определении класса. Если вы хотите выбрать один, попробуйте __repr__(), так как его можно использовать вместо __str__().

Строка, которая возвращается __str__() является неформальным строковым представлением объекта и должна быть читаемой. Строка, которую вернул __str__() — это официальное выражение и должно быть однозначным. При вызове str() и repr(), предпочтительнее использовать __str__() и __repr__() напрямую.

По умолчанию, f-строки будут использовать __str__(), но вы должны убедиться в том, что они используют __repr__(), если вы включаете флаг преобразования !r:

Python

print(f»{new_comedian}»)
# Вывод: ‘Eric Idle is 74.’

print(f»{new_comedian!r}»)
# Вывод: ‘Eric Idle is 74. Surprise!’

1
2
3
4
5

print(f»{new_comedian}»)

# Вывод: ‘Eric Idle is 74.’
 

print(f»{new_comedian!r}»)

# Вывод: ‘Eric Idle is 74. Surprise!’

Если вы хотите прочитать часть обсуждения, в результате которого f-strings поддерживают полные выражения Python, вы можете сделать это здесь.

Именные функции, инструкция def

Функция в python — объект, принимающий аргументы и возвращающий значение. Обычно функция определяется с помощью инструкции def.

Определим простейшую функцию:

def add(x, y):
    return x + y

Инструкция return говорит, что нужно вернуть значение. В нашем случае функция возвращает сумму x и y.

Теперь мы ее можем вызвать:

>>> add(1, 10)
11
>>> add('abc', 'def')
'abcdef'

Функция может быть любой сложности и возвращать любые объекты (списки, кортежи, и даже функции!):

>>> def newfunc(n):
...     def myfunc(x):
...         return x + n
...     return myfunc
...
>>> new = newfunc(100)  # new - это функция
>>> new(200)
300

Функция может и не заканчиваться инструкцией return, при этом функция вернет значение None:

Готовое приложение Сохраняем данные криптовалют от биржи Binance

Допустим у нас уже есть MySQL база данных и существует таблица: coins. Нам нужно создать модель для этой существующей таблице и сохранить полученные json данные от Binance.

Структура базы данных:

MySQL

CREATE TABLE `coins` (
`id` int(11) NOT NULL,
`symbol` varchar(20) NOT NULL,
`priceChange` float NOT NULL,
`priceChangePercent` float NOT NULL,
`weightedAvgPrice` float NOT NULL,
`prevClosePrice` float NOT NULL,
`lastPrice` float NOT NULL,
`lastQty` float NOT NULL,
`bidPrice` float NOT NULL,
`askPrice` float NOT NULL,
`openPrice` float NOT NULL,
`highPrice` float NOT NULL,
`lowPrice` float NOT NULL,
`volume` float NOT NULL,
`quoteVolume` float NOT NULL,
`openTime` int(30) NOT NULL,
`closeTime` int(30) NOT NULL,
`firstId` int(10) NOT NULL,
`lastId` int(10) NOT NULL,
`count` int(10) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf-8;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

CREATETABLE`coins`(

`id`int(11)NOT NULL,

`symbol`varchar(20)NOT NULL,

`priceChange`floatNOT NULL,

`priceChangePercent`floatNOT NULL,

`weightedAvgPrice`floatNOT NULL,

`prevClosePrice`floatNOT NULL,

`lastPrice`floatNOT NULL,

`lastQty`floatNOT NULL,

`bidPrice`floatNOT NULL,

`askPrice`floatNOT NULL,

`openPrice`floatNOT NULL,

`highPrice`floatNOT NULL,

`lowPrice`floatNOT NULL,

`volume`floatNOT NULL,

`quoteVolume`floatNOT NULL,

`openTime`int(30)NOT NULL,

`closeTime`int(30)NOT NULL,

`firstId`int(10)NOT NULL,

`lastId`int(10)NOT NULL,

`count`int(10)NOT NULL

)ENGINE=InnoDBDEFAULTCHARSET=utf8;

Что мы реализуем в нашем приложении:

Ссылка на основную публикацию