Что такое кэширование и как оно работает | AWS

Узнайте о различных отраслях и примерах использования кэширования

Мобильные технологии

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

AWS Mobile Hub – это объединенная консоль для удобного поиска, настройки и использования облачных сервисов AWS, предназначенных для разработки и тестирования мобильных приложений, а также мониторинга их использования.

Интернет вещей (IoT)

Интернет вещей – это концепция сбора информации с устройств и из физического мира с помощью датчиков и ее передачи в Интернет или в приложения, которые принимают эти данные. Ценность IoT заключается в способности понимать собранные данные в режиме, близком к реальному времени, что в конечном счете позволяет системе и приложениям, принимающим эти данные, быстро реагировать на них. Возьмем, к примеру, устройство, которое передает свои GPS-координаты. Ваше приложение IoT может предложить интересные места, которые находятся поблизости от этих координат. Кроме того, если вы сохранили предпочтения пользователя устройства, то можете подобрать наиболее подходящие рекомендации для этого пользователя. В этом отдельном примере скорость ответа приложения на полученные координаты критически важна для достижения качественного взаимодействия с пользователем. Кэширование может сыграть в нем важную роль. Интересные места и их координаты можно хранить в хранилище пар «ключ – значение», например в Redis, чтобы обеспечить их быстрое получение. С точки зрения разработки вы можете запрограммировать свое приложение IoT, чтобы оно реагировало на любое событие, если для этого существуют программные средства. При создании архитектуры IoT необходимо рассмотреть некоторые очень важные вопросы, в том числе время ответа при анализе полученных данных, создание архитектуры решения, масштаб которого охватывает N устройств, и экономичность архитектуры.

AWS IoT – это управляемая облачная платформа, которая позволяет подключенным устройствам просто и безопасно взаимодействовать с облачными приложениями и другими устройствами.

Дополнительные сведения: Managing IoT and Time Series Data with Amazon ElastiCache for Redis

Рекламные технологии

Современные приложения в сфере рекламных технологий особо требовательны к производительности. Примером важной области развития в этой сфере является торг в режиме реального времени (RTB). Это подход к трансляции рекламы на цифровых экранах в режиме реального времени, основанный на принципе аукциона и работающий со впечатлениями на самом подробном уровне. RTB был преобладающим способом проведения транзакций в 2015 году, учитывая то, что 74,0 процента рекламы было куплено программными средствами, что в США соответствует 11 миллиардам долларов (согласно eMarketer Analysis). При создании приложения для торгов в режиме реального времени важно учитывать то, что одна миллисекунда может решать, было ли предложение предоставлено вовремя, или оно уже стало ненужным. Это значит, что нужно крайне быстро получать данные из базы. Кэширование баз данных, при использовании которого можно получать данные о торгах за считанные доли миллисекунды, – это отличное решение для достижения такой высокой производительности.

Игровые технологии

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

Подробнее о разработке игр см. здесь.

Мультимедиа

Мультимедийным компаниям часто требуется передавать клиентам большое количество статического контента при постоянном изменении количества читателей или зрителей. Примером является сервис потоковой передачи видео, например Netflix или Amazon Video, которые передают пользователям большой объем видеоконтента. Это идеальный случай для использования сети доставки контента, в которой данные хранятся на серверах кэширования, расположенных во всем мире. Еще одним аспектом медиаприложений является пикообразная и непредсказуемая нагрузка. Возьмем, к примеру, публикацию в блоге на веб-сайте, о которой некоторая знаменитость только что отправила сообщение в Twitter, или веб-сайт футбольной команды во время Суперкубка. Такой высокий пик спроса на маленькое подмножество контента – вызов для многих баз данных, потому их пропускная способность для отдельных ключей ограничена. Поскольку пропускная способность оперативной памяти гораздо выше, чем у дисков, кэш базы данных помогает решить эту проблему путем перенаправления запросов чтения в кэш в памяти.

Интернет-коммерция

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

Приложения для социальных сетей взяли мир штурмом. У таких социальных сетей, как Facebook, Twitter, Instagram и Snapchat, очень много пользователей, и объем контента, который они потребляют, все больше растет. Когда пользователи открывают свои ленты новостей, они ожидают, что увидят свежий персонализированный контент в режиме реального времени. Это не статический контент, поскольку у каждого пользователя разные друзья, фотографии, интересы и т. д., за счет чего обостряется необходимость в усложнении платформы, на которой основано приложение. Кроме того, приложения для социальных сетей подвержены пикам использования во время крупных развлекательных мероприятий, спортивных и политических событий. Устойчивость к пиковым нагрузкам и высокая производительность в режиме реального времени возможны благодаря использованию нескольких уровней кэширования, включая сети доставки контента для статического контента, например изображений, кэш сеансов для учета данных текущих сессий пользователей и кэш баз данных для ускорения доступа к часто запрашиваемому контенту, например последним фотографиям и свежим новостям от близких друзей.

Здравоохранение и здоровый образ жизни

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

Подробнее о создании приложений для сферы здравоохранения на AWS см. здесь.

Финансы и финансовые технологии

За последние годы потребление финансовых сервисов очень изменилось. Существуют приложения для доступа к банковским и страховым услугам, функциям выявления мошенничества, сервисам инвестирования, оптимизации капитальных рынков с использованием алгоритмов, которые работают в режиме реального времени, а также многие другие приложения. Очень сложно предоставлять доступ к финансовым данным клиента и возможность проведения таких транзакций, как перевод средств или совершение платежей, в режиме реального времени. Во-первых, к приложениям для этой сферы применяются те же ограничения, что и к приложениям для других сфер, в которых пользователю требуется взаимодействовать с приложением в режиме, близком к реальному времени. Кроме того, финансовые приложения могут предъявлять дополнительные требования, например относительно повышенной безопасности и выявления мошенничества. Для того чтобы производительность отвечала ожиданиям пользователя, крайне важно создать эффективную архитектуру с использованием стратегии многоуровневого кэширования. В зависимости от требований приложения уровни кэширования могут включать кэш сеансов для хранения данных о сессиях пользователя, сеть доставки контента для передачи статического контента и кэш базы данных для передачи часто запрашиваемых данных, таких как последние 10 покупок клиента.

Подробнее о финансовых приложениях на AWS см.  здесь.

что это такое и как с ним работать – простыми словами

Что такое кэш

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

В чем заключается принцип работы кэша

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

Какие существуют способы кэширования

• Аппаратный. В этом случае временные файлы записываются на само устройство в специально отведенные для этого участки памяти. Например, аппаратное кэширование в центральном процессоре выполняется в трех видах cache-памяти – L1, L2 и L3. Это позволяет программам быстро извлечь их при необходимости без обращения к иным устройствам в системе.
• Программный. Кэширование этого типа осуществляется в выделенный участок памяти в операционной системе (как правило, он имеет вид обычной папки). Расположение кэша у различных программ может быть разным. Например, браузеры сохраняют свои временные файлы в свои папки в разделе Document and Settings.

Независимо от того, какой из способов кэширования применяется, этот процесс обеспечивает:

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

Что такое кэш-память

Кэш-память представляет собой интегрированный в устройство выделенный раздел памяти для сохранения в нем временных рабочих данных и быстрого их извлечения. Она имеется в процессорах и иных устройствах (оперативной памяти, жестком диске) и обеспечивает существенный рост производительности и скорости обработки информации за счет оперативного доступа к нужным файлам. На флеш-накопителях (SSD) ее размер составляет до 4 Гб, на хард-дисках (HHD) – до 256 Мб.

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

Как происходит очистка кэша

Удаление временных рабочих файлов в ОС выполняется, за редким исключением, автоматически и не нуждается в контроле пользователя. Например, для очистки кэша браузера достаточно одновременно нажать комбинацию клавиш Ctrl + F5 на открытой интернет-странице.

В других программах удаление временных данных осуществляется в настройках. Для этого необходимо зайти в соответствующий раздел меню и очистить кэш вручную. В операционной системе Windows таким образом выполняется очистка, как правило, только у браузеров. В iOS на iPhone или iPad данный процесс выполняется в полностью автоматическом режиме, а вот пользователям устройств с ОС Android часто нужно осуществлять его вручную. Однако с выходом каждой новой версии этой операционной системы процедура очистки временных файлов становится более понятной и автоматизированной.

Нужно ли чистить кэш

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

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

В заключение

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

Другие термины на букву «К»

AdSenseAJAXAllSubmitterAltApacheAPIBegunBlogunCAPTCHACMSCookieCopylancerCPACPCCPLCPMCPOCPSCPVCRMCS YazzleCSSCTR, CTB, CTI, VTRDescriptionDigital-агентствоDigital-маркетингDMOZDoS и DDoS атакиEmailFaviconFeedBurnerFTPGoGetLinksGoogle AdWordsGoogle AnalyticsGoogle ChromeGoogle MapsGoogle webmasters toolsGoogle Мой бизнесhCardhProducthRecipehreflanghtaccessHTTP-заголовкиHTTP-протоколHTTPS-протоколInternet ExplorerIP-адресJavaScriptJoomlaKeywordsKPILanding PageLiexLiveinternetLTVMash-upMiralinksMozilla FirefoxMSNNofollow и noindexOperaPageRank и тИЦPerformance MarketingPHPPinterestPPAPPCPush-уведомленияRobots. txtROI (ROMI)RookeeRotapostRSSSafariSapeSEO-продвижениеSEO-трафикSeoPultSeozavrSERPSidebarSitemap.xmlSMMSocial Media OptimizationSSL сертификатыSubcribe.ruSubscribe.DirectTextbrokerTitleTwitterUTMWeb-порталWebMoneyWhoisWordpressXenuXML выдача ЯндексаXSS атакиYouTubeАватарАвторизацияАГСАдаптивность сайтаАдминистраторАккаунтАлгоритмы ЯндексаАнкорАпдейтАпрувАутентификацияБагБаза данныхБайнетБаннерная рекламаБаннерная слепотаБидБиржа ссылокБитые ссылкиБуржунетБыстрые ссылкиБэки поплылиВеб-аналитикаВеб-сервисВебвизорВейтерВирусный маркетингВнешние ссылкиВнутренняя перелинковкаВнутрякВодаВоронка продажВыпадение сайтаГенератор дорвеевГестбукГлубина просмотраГолосовой поискГрабберДампед ранкДенверДизамбигуацияДокументные операторы ЯндексаДоменДорвейДорвейщикДубли страницИдентификаторы сессийИндексация сайтаИнтернет-маркетингИнтернет-сайтИнтерфейсИнформеры ЯндексаИсследование юзабилитиКлишеКлоноводКоды ошибокКоды перенаправленияКоллтрекингКомьюнитиКонверсияКонтекстная рекламаКонтентЛидЛинкаторМаркетинговая стратегияМаркетинговый аудитМассфолловингМедийная рекламаМетатегиМикроданныеМикроформатыМисспелМобильный трафикМодераторМордоворотНПСОбфускацияОптимизация сайтаОтложенная конверсияПартизанский маркетингПартнерские программыПоведенческие факторыПоддержка сайтовПодкастингПоисковые роботыПоисковый аудитПоисковый спамПоказатель отказовПресс-релизыПрокси-серверыРанжированиеРегистратор доменаРелевантностьРепутационный маркетингРерайтингРетаргетингРеферерРСЯСемантическое ядроСервисы «вопрос – ответ»Сети сайтовСинонимайзерСквозная аналитикаСклейка зеркалСловоформаСниппетыСоциальные сетиСплит-тестированиеСсылкаСтатические URLТехнический анализ сайтаТизерная рекламаТрастовость сайтаТрафикУникальность контентаУТП: уникальное торговое предложениеФильтры GoogleФильтры ЯндексаФишингФлеймФлудФорумыФреймворкФреймыХостингЦитируемость сайтаЧПУ-адресаЮзабилитиЮзабилити-аудит сайтаЯзык запросов ЯндексаЯзык сценариевЯндекс ИКСЯндекс КаталогЯндекс. ВебмастерЯндекс.ВидеоЯндекс.Метрика

Все термины SEO-Википедии

Теги термина

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

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

Интернет вещей (IoT)

Интернет вещей — это концепция сбора и доставки информации с устройства и физического мира через датчики устройства в Интернет или приложения, потребляющие данные. Ценность Интернета вещей заключается в возможности понимать захваченные данные с интервалами, близкими к реальному времени, что в конечном итоге позволяет потребляющей системе и приложениям быстро реагировать на эти данные. Возьмем, к примеру, устройство, которое передает свои GPS-координаты. Ваше приложение IoT может ответить, предложив точки интереса относительно близости этих координат. Кроме того, если бы у вас были сохранены настройки, связанные с пользователем устройства, вы могли бы точно настроить эти рекомендации с учетом этого человека. В этом конкретном примере скорость, с которой приложение может реагировать на координаты, имеет решающее значение для достижения наилучшего взаимодействия с пользователем. Кэширование может сыграть здесь важную роль, например, точки интереса вместе с географическими координатами могут храниться в хранилище ключей/значений, таком как Redis, для обеспечения быстрого поиска. С точки зрения разработки приложений вы можете, по сути, запрограммировать свое приложение IoT так, чтобы оно реагировало на любое событие, если для этого есть программные средства. Важные соображения, которые необходимо учитывать при построении архитектуры IoT, включают время отклика, связанное с анализом полученных данных, проектированием решения, которое может масштабироваться на N устройств, и созданием экономически эффективной архитектуры.

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

Дополнительная литература: Управление данными Интернета вещей и временных рядов с помощью Amazon ElastiCache для Redis

Рекламные технологии

Современные приложения Ad Tech особенно требовательны к производительности. Примером значительной области роста в AdTech являются торги в реальном времени (RTB), которые представляют собой аукционный подход к транзакциям цифровой медийной рекламы в режиме реального времени с максимально детализированным уровнем показов. RTB был доминирующим методом транзакций в 2015 году, на его долю приходилось 74,0% рекламы, приобретаемой программным путем, или 11 миллиардов долларов в США (по данным eMarketer Analysis). При создании приложения для ставок в реальном времени миллисекунда может быть разницей между подачей заявки вовремя и тем, что она станет неактуальной. Это означает, что получение информации о торгах из базы данных должно быть чрезвычайно быстрым. Кэширование базы данных, которое может получить доступ к деталям ставок за доли миллисекунды, является отличным решением для достижения такой высокой производительности.

Игры

Интерактивность является краеугольным камнем практически любой современной игры. Ничто так не расстраивает игроков, как медленная или неотзывчивая игра, и они редко достигают успеха. Требования к производительности еще более высоки для мобильных многопользовательских игр, где действие, которое совершает один игрок, должно быть передано другим в режиме реального времени. Кэширование играет решающую роль в поддержании плавности игры, предоставляя ответ на запрос часто используемых данных за доли миллисекунды. Также полезно облегчить проблемы с горячими клавишами, когда одни и те же данные запрашиваются несколько раз, например, «кто в настоящее время входит в 10 лучших игроков по счету?»

Чтобы узнать больше о разработке игр на AWS, нажмите здесь.

Медиа

Медиакомпании часто сталкиваются с необходимостью передачи большого количества статического контента своим клиентам с постоянно меняющимся числом читателей/зрителей. Примером может служить служба потокового видео, такая как Netflix или Amazon Video, которая передает зрителям большой объем видеоконтента. Это идеально подходит для сети доставки контента, где данные хранятся на глобально распределенном наборе кэширующих серверов. Другой аспект медиа-приложений заключается в том, что нагрузка имеет тенденцию быть скачкообразной и непредсказуемой. Представьте себе блог на веб-сайте, о котором знаменитость только что написала в Твиттере, или веб-сайт футбольной команды во время Суперкубка. Такой большой всплеск спроса на небольшое подмножество контента является проблемой для большинства баз данных, поскольку они ограничены в своей пропускной способности для каждого ключа. Поскольку пропускная способность памяти намного выше, чем у диска, кеш базы данных решит проблему, перенаправляя операции чтения в кеш в памяти.

Электронная коммерция

Современные приложения электронной коммерции становятся все более сложными, предлагая персонализированный опыт покупок, включая рекомендации в реальном времени на основе данных пользователя и истории покупок. К ним часто также относится просмотр социальной сети пользователя и предоставление рекомендаций на основе того, что понравилось или купило его друзьям. В то время как количество данных, необходимых для обработки, увеличивается, терпение клиентов не иссякает. Таким образом, поддержание работоспособности приложения в режиме реального времени — это не роскошь, а необходимость; хорошо реализованная стратегия кэширования является критическим аспектом производительности приложения и может быть разницей между успехом или неудачей приложения, между совершением продажи или потерей клиента.

Приложения для социальных сетей покорили мир. Социальные сети, такие как Facebook, Twitter, Instagram и Snapchat, имеют огромное количество пользователей, которые потребляют постоянно растущее количество контента. Когда пользователь открывает свою ленту, он ожидает увидеть свой последний персонализированный контент практически в режиме реального времени. Это не статичный контент, поскольку у каждого пользователя разные друзья, изображения, интересы и т. д., что усугубляет потребности в инженерной сложности базовой платформы. Приложения для социальных сетей также очень часто используются в связи с крупными развлекательными, спортивными и политическими событиями. Такая пиковая устойчивость и производительность в режиме реального времени достигаются за счет нескольких уровней кэширования, включая сеть доставки контента для статического контента, такого как фоновые изображения, кэш сеанса для отслеживания данных текущего сеанса пользователя и кэш базы данных для хранения часто используемых данных, таких как как последние новости от самых близких друзей и последние несколько удобных изображений.

Здравоохранение и хорошее самочувствие

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

Чтобы узнать больше о создании приложений Healthcare на AWS, нажмите здесь.

Финансы и финансовые технологии

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

Чтобы узнать больше о приложениях Financial Services на AWS, нажмите здесь.

functools — Функции и операции высшего порядка над вызываемыми объектами — Документация по Python 3.11.3

Исходный код: Lib/functools.py

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

9Модуль 0066 functools определяет следующие функции:

@functools.cache( user_function )

Простой облегченный неограниченный кэш функций. Иногда называется
«запоминать».

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

Например:

 @кэш
Защитный факториал (n):
    вернуть n * factorial(n-1), если n иначе 1
>>> factorial(10) # ранее не кэшированный результат, делает 11 рекурсивных вызовов
3628800
>>> factorial(5) # просто ищет результат кэшированного значения
120
>>> factorial(12) # делает два новых рекурсивных вызова, остальные 10 кэшируются
47
00
 

Кэш является потокобезопасным, поэтому обернутую функцию можно использовать в нескольких
потоки.

Новое в версии 3.9.

@functools.cached_property( функция )

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

Пример:

Набор данных класса

:
    def __init__(self, sequence_of_numbers):
        self. _data = кортеж (sequence_of_numbers)
    @cached_property
    деф stdev(я):
        вернуть статистику.stdev(self._data)
 

Механизм cached_property() несколько отличается от
свойство() . Атрибут обычного свойства блокирует запись, если только
сеттер определен. Напротив, cached_property разрешает запись.

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

Кэшированное значение можно очистить, удалив атрибут. Этот
позволяет снова запустить метод cached_property .

Обратите внимание, этот декоратор мешает работе PEP 412
словари с совместным использованием ключей. Это означает, что экземпляры словарей
может занимать больше места, чем обычно.

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

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

Набор данных класса

:
    def __init__(self, sequence_of_numbers):
        self._data = sequence_of_numbers
    @свойство
    @кэш
    деф stdev(я):
        вернуть статистику. stdev(self._data)
 

Новое в версии 3.8.

functools.cmp_to_key( функция )

Преобразование функции сравнения старого стиля в ключевую функцию. Использовал
с инструментами, которые принимают ключевые функции (например, sorted() , min() ,
max() , куча.nlargest() , куча.nsmalest() ,
itertools.groupby() ). Эта функция в основном используется как переход
инструмент для программ, конвертируемых из Python 2, который поддерживал использование
функции сравнения.

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

Пример:

 sorted(iterable, key=cmp_to_key(locale. strcoll)) # порядок сортировки с учетом локали
 

Примеры сортировки и краткое руководство по сортировке см. в разделе Сортировка.

Новое в версии 3.2.

@functools.lru_cache( user_function )

@functools.lru_cache( maxsize=128 , typed=False )

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

Кэш является потокобезопасным, поэтому обернутую функцию можно использовать в нескольких
потоки.

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

Отдельные шаблоны аргументов могут рассматриваться как отдельные вызовы с
отдельные записи кэша. Например, f(a=1, b=2) и f(b=2, a=1)
отличаются порядком аргументов ключевого слова и могут иметь два отдельных кеша
записи.

Если указана user_function , она должна быть вызываемой. Это позволяет
lru_cache декоратор, применяемый непосредственно к пользовательской функции, оставляя
maxsize со значением по умолчанию 128:

 @lru_cache
def count_vowels (предложение):
    возвращаемая сумма (sentence.count (гласный) для гласного в «AEIOUaeiou»)
 

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

Если для typed установлено значение true, аргументы функции разных типов будут
кэшируется отдельно. Если набрал ложь, реализация обычно
рассматривать их как эквивалентные вызовы и кэшировать только один результат. (Некоторый
такие типы, как str и int , могут кэшироваться отдельно, даже если набрал
неверно.)

Примечание. Типоспецифичность применяется только к непосредственным аргументам функции.
а не их содержание. Скалярные аргументы, Десятичный(42) и
Fraction(42) рассматриваются как отдельные вызовы с разными результатами.
Напротив, аргументы кортежа ("ответ", Decimal(42)) и
("ответ", Fraction(42)) считаются эквивалентными.

Обернутая функция оснащена cache_parameters()
функция, которая возвращает новый dict , показывающий значения для maxsize
и набрал . Это только для информационных целей. Изменение значений
не имеет никакого эффекта.

Чтобы помочь измерить эффективность кэша и настроить максимальный размер
параметр, обернутая функция оснащена cache_info()
функция, которая возвращает именованный кортеж, показывающий попаданий , промахов ,
maxsize и currsize .

Декоратор также предоставляет функцию cache_clear() для очистки или
инвалидация кеша.

Исходная базовая функция доступна через
__wrapped__ атрибут. Это полезно для самоанализа, т.
для обхода кеша или для перепаковки функции с другим кешем.

Кэш хранит ссылки на аргументы и возвращаемые значения до тех пор, пока они не устареют.
из кэша или пока кэш не будет очищен.

Если метод кэшируется, аргумент экземпляра self включается в
кеш. См. Как кэшировать вызовы методов?

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

Как правило, кэш LRU следует использовать только тогда, когда вы хотите повторно использовать
ранее вычисленные значения. Соответственно кэшировать нет смысла
функции с побочными эффектами, функции, которые должны создавать отдельные изменяемые
объекты при каждом вызове или нечистые функции, такие как time() или random().

Пример кэша LRU для статического веб-контента:

 @lru_cache (максимальный размер = 32)
защита get_pep (число):
    «Получить текст предложения по улучшению Python»
    ресурс = 'https://peps.python.org/pep-%04d/' % число
    пытаться:
        с urllib.request.urlopen(resource) как s:
            вернуть s.read()
    кроме urllib.error.HTTPError:
        вернуть «Не найдено»
>>> для п в 8, 290, 308, 320, 8, 218, 320, 279, 289, 320, 9991:
... бодрость духа = get_pep (n)
... печать (n, len (pep))
>>> get_pep.cache_info()
CacheInfo (попадания = 3, промахи = 8, maxsize = 32, currsize = 8)
 

Пример эффективного вычисления
Числа Фибоначчи
использование кэша для реализации
динамическое программирование
техника:

 @lru_cache(maxsize=Нет)
деф фиб(п):
    если n < 2:
        вернуть н
    вернуть фиб (n-1) + фиб (n-2)
>>> [fib(n) для n в диапазоне (16)]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]
>>> fib.cache_info()
CacheInfo (попадания = 28, промахи = 16, maxsize = нет, currsize = 16)
 

Новое в версии 3. 2.

Изменено в версии 3.3: Добавлена ​​опция , напечатанная .

Изменено в версии 3.8: Добавлена ​​опция user_function .

Новое в версии 3.9: Добавлена ​​функция cache_parameters()

@functools.total_ordering

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

Класс должен определить один из __lt__() , __le__() ,
__gt__() или __ge__() .
Кроме того, класс должен предоставлять метод __eq__() .

Например:

 @total_ordering
Ученик класса:
    def _is_valid_operand (я, другой):
        return (hasattr(другое, "фамилия") и
                hasattr(другое, "имя"))
    def __eq__(я, другой):
        если не self._is_valid_operand(другое):
            вернуть нереализованный
        return ((self. lastname.lower(), self.firstname.lower()) ==
                (другое.фамилия.нижний(), другое.имя.нижний()))
    def __lt__(я, другой):
        если не self._is_valid_operand(другое):
            вернуть нереализованный
        return ((self.lastname.lower(), self.firstname.lower()) <
                (другое.фамилия.нижний(), другое.имя.нижний()))
 

Примечание

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

Примечание

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

Новое в версии 3.2.

Изменено в версии 3.4: Возврат NotImplemented из базовой функции сравнения для
теперь поддерживаются нераспознанные типы.

functools.partial( func , / , *args , **ключевые слова )

Возвращает новый частичный объект, который при вызове
будет вести себя как func , вызванный с позиционными аргументами args
и ключевые слова аргументы ключевые слова . Если для
вызов, они добавляются к args . Если дополнительные аргументы ключевого слова
предоставлены, они расширяют и переопределяют ключевых слов .
Примерно эквивалентно:

 def partial(func, /, *args, **keywords):
    def newfunc(*fargs, **fkeywords):
        новые ключевые слова = {**ключевые слова, **fключевые слова}
        return func(*args, *fargs, **newkeywords)
    newfunc.func = функция
    newfunc.args = аргументы
    newfunc.keywords = ключевые слова
    вернуть
 

partial() используется для приложения частичной функции, которое «зависает»
некоторая часть аргументов функции и/или ключевых слов, приводящая к созданию нового объекта
с упрощенной подписью. Например, partial() можно использовать для создания
вызываемый объект, который ведет себя как функция int() , где аргумент base
по умолчанию два:

 >>> из functools частичного импорта
>>> basetwo = partial(int, base=2)
>>> basetwo.__doc__ = 'Преобразовать строку с основанием 2 в целое число.'
>>> по основанию два('10010')
18
 

class functools.partialmethod( func , /, *args , **ключевые слова )

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

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

Когда func является дескриптором (например, обычной функцией Python,
classmethod() , staticmethod() , abstractmethod() или
другой экземпляр partialmethod ), вызовы __get__
делегируется базовому дескриптору, и соответствующий
частичный объект, возвращенный в качестве результата.

Когда func является вызываемым без дескриптора, соответствующий связанный метод
создается динамически. Это ведет себя как обычная функция Python, когда
используется как метод: аргумент self будет вставлен первым
позиционный аргумент, даже до аргументов и ключевых слов , предоставленных для
конструктор частичного метода .

Пример:

 >>> класс Ячейка:
... защита __init__(я):
... self._alive = Ложь
...     @свойство
... по определению жив(я):
... вернуть self._alive
... определение set_state (я, состояние):
... self._alive = логическое значение (состояние)
... set_alive = частичный метод (set_state, True)
... set_dead = partialmethod(set_state, False)
...
>>> с = ячейка ()
>>> c.живой
ЛОЖЬ
>>> c.set_alive()
>>> c.живой
Истинный
 

Новое в версии 3.4.

functools.reduce ( функция , итерация [ инициализатор ])

Применить функцию двух аргументов кумулятивно к элементам iterable , от
слева направо, чтобы уменьшить итерацию до одного значения. Например,
уменьшить(лямбда x, y: x+y, [1, 2, 3, 4, 5]) вычисляет ((((1+2)+3)+4)+5) .
Левый аргумент, x , представляет собой накопленное значение, а правый аргумент — 9.0075 г , это
значение обновления из итерации . Если присутствует необязательный инициализатор ,
он помещается перед элементами итерации в вычислении и служит
значение по умолчанию, когда итерируемый объект пуст. Если инициализатор не задан и
iterable содержит только один элемент, возвращается первый элемент.

Примерно эквивалентно:

 по определению уменьшить (функция, итерация, инициализатор = нет):
    это = итер (повторяемый)
    если инициализатор None:
        значение = следующее (оно)
    еще:
        значение = инициализатор
    для элемента в нем:
        значение = функция (значение, элемент)
    возвращаемое значение
 

См. itertools.accumulate() для итератора, который выдает все промежуточные
ценности.

@functools.singledispatch

Преобразование функции в универсальную функцию с одной отправкой.

Чтобы определить общую функцию, украсьте ее @singledispatch
декоратор. При определении функции с использованием @singledispatch обратите внимание, что
рассылка происходит по типу первого аргумента:

 >>> из functools импортировать singledispatch
>>> @singledispatch
... def fun(arg, verbose=False):
... если подробно:
... print("Позвольте мне сказать,", end=" ")
... печать (аргумент)
 

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

 >>> @fun.register
... def _(arg: int, verbose=False):
... если подробно:
... print("Сила в цифрах, а?", end=" ")
... печать (аргумент)
. ..
>>> @fun.register
... def _(arg: list, verbose=False):
... если подробно:
... print("Перечислите это:")
... для i элемент в перечислении (аргумент):
... печать (я, элемент)
 

Типы

. Типы UnionType и . Можно также использовать Union :

 >>> @fun.register
... def _(arg: int | float, verbose=False):
... если подробно:
... print("Сила в цифрах, а?", end=" ")
... печать (аргумент)
...
>>> от ввода импортного союза
>>> @fun.register
... def _(arg: Union[list, set], verbose=False):
... если подробно:
... print("Перечислите это:")
... для i элемент в перечислении (аргумент):
... печать (я, элемент)
...
 

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

 >>> @fun.register(сложный)
... def _(arg, verbose=False):
... если подробно:
... print("Лучше, чем сложно.", end=" ")
... print(arg.real, arg.imag)
...
 

Чтобы разрешить регистрацию лямбда-выражений и ранее существовавших функций,
атрибут register() также может использоваться в функциональной форме:

 >>> ничего по определению (arg, verbose=False):
. .. печатать("Ничего.")
...
>>> fun.register(type(None), ничего)
 

Атрибут register() возвращает недекорированную функцию. Этот
включает укладку декоратора, травление и создание
юнит-тестов для каждого варианта отдельно:

 >>> @fun.register(с плавающей запятой)
... @fun.register(десятичный)
... def fun_num(arg, verbose=False):
... если подробно:
... print("Половина вашего числа:", end=" ")
... печать (аргумент / 2)
...
>>> fun_num — это весело
ЛОЖЬ
 

При вызове универсальная функция выполняет диспетчеризацию по типу первого
аргумент:

 >>> fun("Привет, мир.")
Привет, мир.
>>> fun("test.", verbose=True)
Скажу так, тест.
>>> весело(42, многословно=правда)
Сила в количестве, а? 42
>>> fun(['спам', 'спам', 'яйца', 'спам'], verbose=True)
Перечислите это:
0 спам
1 спам
2 яйца
3 спам
>>> весело(Нет)
Ничего.
>>> весело(1.23)
0,615
 

Если для конкретного типа не зарегистрирована реализация, его
Порядок разрешения метода используется для поиска более общей реализации.
Оригинальная функция, украшенная @singledispatch зарегистрирован
для базы тип объекта , значит используется если не лучше
реализация найдена.

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

 >>> из collections.abc import Mapping
>>> @fun.register
... def _(arg: Mapping, verbose=False):
... если подробно:
... print("Ключи и значения")
... для ключа, значение в arg.items():
... печать (ключ, "=>", значение)
...
>>> весело({"а": "б"})
а => б
 

Чтобы проверить, какую реализацию выберет универсальная функция
заданный тип, используйте атрибут dispatch() :

 >>> fun.dispatch(float)
<функция fun_num по адресу 0x1035a2840>
>>> fun.dispatch(dict) # примечание: реализация по умолчанию
<функция fun по адресу 0x103fe0000>
 

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

 >>> fun. registry.keys()
dict_keys([<класс 'NoneType'>, <класс 'int'>, <класс 'объект'>,
          <класс 'десятичный.Десятичный'>, <класс 'список'>,
          <класс 'плавающий'>])
>>> fun.registry[float]
<функция fun_num по адресу 0x1035a2840>
>>> fun.registry[объект]
<функция fun по адресу 0x103fe0000>
 

Новое в версии 3.4.

Изменено в версии 3.7: Атрибут register() теперь поддерживает использование аннотаций типов.

Изменено в версии 3.11: Атрибут register() теперь поддерживает типов. UnionType
и typing.Union как аннотации типов.

класс functools.singledispatchmethod( func )

Преобразование метода в универсальную функцию с одной отправкой.

Чтобы определить общий метод, украсьте его @singledispatchmethod
декоратор. При определении функции с использованием @singledispatchmethod обратите внимание
что рассылка происходит по типу первого не- self или не- cls
аргумент:

 класс Негатор:
    @singledispatchmethod
    def отрицательный (я, аргумент):
        поднять NotImplementedError("Невозможно отрицать a")
    @нег. регистр
    def _(я, аргумент: целое):
        возврат -аргумент
    @нег.регистр
    def _(я, аргумент: логическое значение):
        вернуть не аргумент
 

@singledispatchmethod поддерживает вложение с другими декораторами, такими как
@classmethod . Обратите внимание, что для разрешения
dispatcher.register , singledispatchmethod должен быть самым внешним
декоратор. Вот класс Negator с методами neg , привязанными к
класс, а не экземпляр класса:

 класс Негатор:
    @singledispatchmethod
    @классметод
    def отрицательный (cls, arg):
        поднять NotImplementedError("Невозможно отрицать a")
    @нег.регистр
    @классметод
    def _(cls, аргумент: целое):
        возврат -аргумент
    @нег.регистр
    @классметод
    def _(cls, аргумент: логическое значение):
        вернуть не аргумент
 

Этот же шаблон можно использовать для других подобных декораторов:
@staticmethod ,
@abstractmethod и другие.

Новое в версии 3.8.

functools.update_wrapper ( обертка , обернутая , назначенная = WRAPPER_ASSIGNMENTS , обновленная = WRAPPER_UPDATES )

Обновить функцию-оболочку , чтобы она выглядела как функция-оболочка . Необязательный
аргументы — это кортежи, чтобы указать, какие атрибуты исходной функции
присваивается непосредственно совпадающим атрибутам функции-оболочки и
атрибуты функции-оболочки обновляются соответствующими атрибутами
от исходной функции. Значения по умолчанию для этих аргументов
константы уровня модуля WRAPPER_ASSIGNMENTS (который присваивает оболочке
функции __module__ , __name__ , __qualname__ , __annotations__
и __doc__ , строка документации) и WRAPPER_UPDATES (который
обновляет __dict__ функции-оболочки, то есть словарь экземпляра).

Чтобы разрешить доступ к исходной функции для самоанализа и других целей
(например, обход декоратора кэширования, такого как lru_cache() ), эта функция
автоматически добавляет атрибут __wrapped__ к оболочке, которая ссылается на
заворачиваемая функция.

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

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

Новое в версии 3.2: Автоматическое добавление атрибута __wrapped__ .

Новое в версии 3.2: Копирование атрибута __annotations__ по умолчанию.

Изменено в версии 3. 2: Отсутствующие атрибуты больше не вызывают AttributeError .

Изменено в версии 3.4: Атрибут __wrapped__ теперь всегда относится к обернутому
функцию, даже если эта функция определила атрибут __wrapped__ .
(см. бпо-17482)

@functools.wraps( завернуто , назначено = WRAPPER_ASSIGNMENTS , обновлено = WRAPPER_UPDATES )

Это удобная функция для вызова update_wrapper() в качестве
декоратор функции при определении функции-оболочки. Это эквивалентно
частичное (update_wrapper, обернутое = обернутое, назначенное = назначенное, обновленное = обновленное) .
Например:

 >>> из functools import wraps
>>> определение my_decorator(f):
... @обертывания(f)
... обертка def (*args, **kwds):
... print('Вызов оформленной функции')
... вернуть f(*args, **kwds)
... возвратная обертка
...
>>> @my_decorator
... пример определения():
... """Строка документации"""
. .. print('Пример вызова функции')
...
>>> пример()
Вызов декорированной функции
Вызываемая примерная функция
>>> пример.__имя__
'пример'
>>> пример.__doc__
"Строка документации"
 

Без использования этой фабрики декораторов имя примера функции
было бы 'wrapper' , а строка документации оригинального example()
был бы потерян.

partial объектов являются вызываемыми объектами, созданными partial() . Они
иметь три атрибута только для чтения:

частичная.функция

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

частичное.аргументы

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

частичное.ключевые слова

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

This entry was posted in Популярное