diff --git a/discord/__main__.py b/discord/__main__.py
index 31c61553..91a3000f 100644
--- a/discord/__main__.py
+++ b/discord/__main__.py
@@ -35,14 +35,16 @@
 
 
 def show_version():
-    entries = []
+    entries = [
+        '- Python v{0.major}.{0.minor}.{0.micro}-{0.releaselevel}'.format(
+            sys.version_info
+        )
+    ]
 
-    entries.append('- Python v{0.major}.{0.minor}.{0.micro}-{0.releaselevel}'.format(sys.version_info))
     version_info = discord.version_info
     entries.append('- discord.py v{0.major}.{0.minor}.{0.micro}-{0.releaselevel}'.format(version_info))
     if version_info.releaselevel != 'final':
-        pkg = pkg_resources.get_distribution('discord.py')
-        if pkg:
+        if pkg := pkg_resources.get_distribution('discord.py'):
             entries.append('    - discord.py pkg_resources: v{0}'.format(pkg.version))
 
     entries.append('- aiohttp v{0.__version__}'.format(aiohttp))
@@ -176,7 +178,7 @@ async def cog_after_invoke(self, ctx):
 }
 
 # NUL (0) and 1-31 are disallowed
-_base_table.update((chr(i), None) for i in range(32))
+_base_table |= ((chr(i), None) for i in range(32))
 
 translation_table = str.maketrans(_base_table)
 
@@ -205,7 +207,7 @@ def newbot(parser, args):
     try:
         new_directory.mkdir(exist_ok=True, parents=True)
     except OSError as exc:
-        parser.error('could not create our bot directory ({})'.format(exc))
+        parser.error(f'could not create our bot directory ({exc})')
 
     cogs = new_directory / 'cogs'
 
@@ -214,27 +216,27 @@ def newbot(parser, args):
         init = cogs / '__init__.py'
         init.touch()
     except OSError as exc:
-        print('warning: could not create cogs directory ({})'.format(exc))
+        print(f'warning: could not create cogs directory ({exc})')
 
     try:
         with open(str(new_directory / 'config.py'), 'w', encoding='utf-8') as fp:
             fp.write('token = "place your token here"\ncogs = []\n')
     except OSError as exc:
-        parser.error('could not create config file ({})'.format(exc))
+        parser.error(f'could not create config file ({exc})')
 
     try:
         with open(str(new_directory / 'bot.py'), 'w', encoding='utf-8') as fp:
             base = 'Bot' if not args.sharded else 'AutoShardedBot'
             fp.write(bot_template.format(base=base, prefix=args.prefix))
     except OSError as exc:
-        parser.error('could not create bot file ({})'.format(exc))
+        parser.error(f'could not create bot file ({exc})')
 
     if not args.no_git:
         try:
             with open(str(new_directory / '.gitignore'), 'w', encoding='utf-8') as fp:
                 fp.write(gitignore_template)
         except OSError as exc:
-            print('warning: could not create .gitignore file ({})'.format(exc))
+            print(f'warning: could not create .gitignore file ({exc})')
 
     print('successfully made bot at', new_directory)
 
@@ -244,7 +246,7 @@ def newcog(parser, args):
     try:
         cog_dir.mkdir(exist_ok=True)
     except OSError as exc:
-        print('warning: could not create cogs directory ({})'.format(exc))
+        print(f'warning: could not create cogs directory ({exc})')
 
     directory = cog_dir / to_path(parser, args.name)
     directory = directory.with_suffix('.py')
@@ -263,12 +265,12 @@ def newcog(parser, args):
                     name = name.title()
 
             if args.display_name:
-                attrs += ', name="{}"'.format(args.display_name)
+                attrs += f', name="{args.display_name}"'
             if args.hide_commands:
                 attrs += ', command_attrs=dict(hidden=True)'
             fp.write(cog_template.format(name=name, extra=extra, attrs=attrs))
     except OSError as exc:
-        parser.error('could not create cog file ({})'.format(exc))
+        parser.error(f'could not create cog file ({exc})')
     else:
         print('successfully made cog at', directory)
 
diff --git a/discord/abc.py b/discord/abc.py
index a202f28c..c2b6dfd7 100644
--- a/discord/abc.py
+++ b/discord/abc.py
@@ -124,19 +124,19 @@ def mention(self):
 
     @classmethod
     def __subclasshook__(cls, C):
-        if cls is User:
-            if Snowflake.__subclasshook__(C) is NotImplemented:
-                return NotImplemented
+        if cls is not User:
+            return NotImplemented
+        if Snowflake.__subclasshook__(C) is NotImplemented:
+            return NotImplemented
 
-            mro = C.__mro__
-            for attr in ('display_name', 'mention', 'name', 'avatar', 'discriminator', 'bot'):
-                for base in mro:
-                    if attr in base.__dict__:
-                        break
-                else:
-                    return NotImplemented
-            return True
-        return NotImplemented
+        mro = C.__mro__
+        for attr in ('display_name', 'mention', 'name', 'avatar', 'discriminator', 'bot'):
+            for base in mro:
+                if attr in base.__dict__:
+                    break
+            else:
+                return NotImplemented
+        return True
 
 class PrivateChannel(metaclass=abc.ABCMeta):
     """An ABC that details the common operations on a private Discord channel.
@@ -162,10 +162,7 @@ def __subclasshook__(cls, C):
                 return NotImplemented
 
             mro = C.__mro__
-            for base in mro:
-                if 'me' in base.__dict__:
-                    return True
-            return NotImplemented
+            return next((True for base in mro if 'me' in base.__dict__), NotImplemented)
         return NotImplemented
 
 class _Overwrites:
@@ -298,14 +295,10 @@ async def _edit(self, options, reason):
                 payload = {
                     'allow': allow.value,
                     'deny': deny.value,
-                    'id': target.id
+                    'id': target.id,
+                    'type': 'role' if isinstance(target, Role) else 'member',
                 }
 
-                if isinstance(target, Role):
-                    payload['type'] = 'role'
-                else:
-                    payload['type'] = 'member'
-
                 perms.append(payload)
             options['permission_overwrites'] = perms
 
@@ -330,7 +323,9 @@ def _fill_overwrites(self, data):
         for index, overridden in enumerate(data.get('permission_overwrites', [])):
             overridden_type = try_enum(PermissionType, overridden.pop('type'))
             if not overridden_type:
-                raise AttributeError('Type type should be 0 - member, or 1 - role not %s' % overridden_type)
+                raise AttributeError(
+                    f'Type type should be 0 - member, or 1 - role not {overridden_type}'
+                )
             overridden_id = int(overridden.pop('id'))
             self._overwrites.append(_Overwrites(id=overridden_id, type=overridden_type.name, **overridden))
 
@@ -345,9 +340,7 @@ def _fill_overwrites(self, data):
                 # swap it to be the first one.
                 everyone_index = index
 
-        # do the swap
-        tmp = self._overwrites
-        if tmp:
+        if tmp := self._overwrites:
             tmp[everyone_index], tmp[0] = tmp[0], tmp[everyone_index]
 
     @property
@@ -369,7 +362,7 @@ def changed_roles(self):
     @property
     def mention(self):
         """:class:`str`: The string that allows you to mention the channel."""
-        return '<#%s>' % self.id
+        return f'<#{self.id}>'
 
     @property
     def created_at(self):
@@ -654,15 +647,14 @@ async def set_permissions(self, target, *, overwrite=_undefined, reason=None, **
             raise InvalidArgument('target parameter must be either Member or Role')
 
         if isinstance(overwrite, _Undefined):
-            if len(permissions) == 0:
+            if not permissions:
                 raise InvalidArgument('No overwrite provided.')
             try:
                 overwrite = PermissionOverwrite(**permissions)
             except (ValueError, TypeError):
                 raise InvalidArgument('Invalid permissions given to keyword arguments.')
-        else:
-            if len(permissions) > 0:
-                raise InvalidArgument('Cannot mix overwrite and keyword arguments.')
+        elif permissions:
+            raise InvalidArgument('Cannot mix overwrite and keyword arguments.')
 
         # TODO: wait for event
 
@@ -1049,14 +1041,13 @@ async def send(self, content=None, *, tts=False, embed=None, embeds=None, compon
                     _components.extend(ActionRow(*[obj for obj in component if isinstance(obj, (Button, SelectMenu))]).to_dict())
             components = _components
 
-        if allowed_mentions is not None:
-            if state.allowed_mentions is not None:
-                allowed_mentions = state.allowed_mentions.merge(allowed_mentions).to_dict()
-            else:
-                allowed_mentions = allowed_mentions.to_dict()
-        else:
+        if allowed_mentions is None:
             allowed_mentions = state.allowed_mentions and state.allowed_mentions.to_dict()
 
+        elif state.allowed_mentions is not None:
+            allowed_mentions = state.allowed_mentions.merge(allowed_mentions).to_dict()
+        else:
+            allowed_mentions = allowed_mentions.to_dict()
         if mention_author is not None:
             allowed_mentions = allowed_mentions or AllowedMentions().to_dict()
             allowed_mentions['replied_user'] = bool(mention_author)
@@ -1085,22 +1076,37 @@ async def send(self, content=None, *, tts=False, embed=None, embeds=None, compon
                 raise InvalidArgument('file parameter must be File')
 
             try:
-                if hidden is not None:
-                    data = await state.http.send_interaction_response(use_webhook=use_webhook,
-                                                                      interaction_id=interaction_id,
-                                                                      token=interaction_token,
-                                                                      application_id=application_id,
-                                                                      deferred=deferred,
-                                                                      files=[file], allowed_mentions=allowed_mentions,
-                                                                      content=content, tts=tts, embeds=embeds,
-                                                                      components=components,
-                                                                      nonce=nonce, message_reference=reference,
-                                                                      flags=64 if hidden is True else None,
-                                                                      followup=followup)
-                else:
-                    data = await state.http.send_files(channel.id, files=[file], allowed_mentions=allowed_mentions,
-                                                       content=content, tts=tts, embeds=embeds, components=components,
-                                                       nonce=nonce, message_reference=reference)
+                data = (
+                    await state.http.send_interaction_response(
+                        use_webhook=use_webhook,
+                        interaction_id=interaction_id,
+                        token=interaction_token,
+                        application_id=application_id,
+                        deferred=deferred,
+                        files=[file],
+                        allowed_mentions=allowed_mentions,
+                        content=content,
+                        tts=tts,
+                        embeds=embeds,
+                        components=components,
+                        nonce=nonce,
+                        message_reference=reference,
+                        flags=64 if hidden is True else None,
+                        followup=followup,
+                    )
+                    if hidden is not None
+                    else await state.http.send_files(
+                        channel.id,
+                        files=[file],
+                        allowed_mentions=allowed_mentions,
+                        content=content,
+                        tts=tts,
+                        embeds=embeds,
+                        components=components,
+                        nonce=nonce,
+                        message_reference=reference,
+                    )
+                )
             finally:
                 file.close()
 
@@ -1130,28 +1136,27 @@ async def send(self, content=None, *, tts=False, embed=None, embeds=None, compon
             finally:
                 for f in files:
                     f.close()
+        elif hidden is not None:
+            data = await state.http.send_interaction_response(use_webhook=use_webhook,
+                                                              interaction_id=interaction_id,
+                                                              token=interaction_token,
+                                                              application_id=application_id,
+                                                              deferred=deferred, allowed_mentions=allowed_mentions,
+                                                              content=content, tts=tts, embeds=embeds,
+                                                              components=components,
+                                                              nonce=nonce, message_reference=reference,
+                                                              flags=64 if hidden is True else None,
+                                                              followup=followup)
         else:
-            if hidden is not None:
-                data = await state.http.send_interaction_response(use_webhook=use_webhook,
-                                                                  interaction_id=interaction_id,
-                                                                  token=interaction_token,
-                                                                  application_id=application_id,
-                                                                  deferred=deferred, allowed_mentions=allowed_mentions,
-                                                                  content=content, tts=tts, embeds=embeds,
-                                                                  components=components,
-                                                                  nonce=nonce, message_reference=reference,
-                                                                  flags=64 if hidden is True else None,
-                                                                  followup=followup)
-            else:
-                data = await state.http.send_message(channel.id, content, tts=tts, embeds=embeds, components=components,
-                                                                          nonce=nonce, allowed_mentions=allowed_mentions,
-                                                                          message_reference=reference)
-        if not hidden is True:
-            if not isinstance(data, dict) and not hidden is None:
+            data = await state.http.send_message(channel.id, content, tts=tts, embeds=embeds, components=components,
+                                                                      nonce=nonce, allowed_mentions=allowed_mentions,
+                                                                      message_reference=reference)
+        if hidden is not True:
+            if not isinstance(data, dict) and hidden is not None:
                 """Thanks Discord that they dont return the message when we send the interaction callback"""
                 data = await state.http.get_original_interaction_response(application_id=application_id, interaction_token=interaction_token)
             ret = state.create_message(channel=channel, data=data)
-            if (delete_after is not None) and (not hidden is True):
+            if delete_after is not None and hidden is not True:
                 await ret.delete(delay=delete_after)
             return ret
 
diff --git a/discord/activity.py b/discord/activity.py
index cf5192ad..76b93c95 100644
--- a/discord/activity.py
+++ b/discord/activity.py
@@ -189,10 +189,7 @@ def __init__(self, **kwargs):
         self.session_id = kwargs.pop('session_id', None)
         self.type = try_enum(ActivityType, kwargs.pop('type', -1))
         emoji = kwargs.pop('emoji', None)
-        if emoji is not None:
-            self.emoji = PartialEmoji.from_dict(emoji)
-        else:
-            self.emoji = None
+        self.emoji = PartialEmoji.from_dict(emoji) if emoji is not None else None
 
     def __repr__(self):
         attrs = (
@@ -205,7 +202,7 @@ def __repr__(self):
             'emoji',
         )
         mapped = ' '.join('%s=%r' % (attr, getattr(self, attr)) for attr in attrs)
-        return '<Activity %s>' % mapped
+        return f'<Activity {mapped}>'
 
     def to_dict(self):
         ret = {}
@@ -332,9 +329,9 @@ def _extract_timestamp(self, data, key):
         try:
             dt = data[key]
         except KeyError:
-            setattr(self, '_' + key, 0)
+            setattr(self, f'_{key}', 0)
         else:
-            setattr(self, '_' + key, dt.timestamp() * 1000.0)
+            setattr(self, f'_{key}', dt.timestamp() * 1000.0)
 
     @property
     def type(self):
@@ -624,7 +621,7 @@ def album_cover_url(self):
         if large_image[:8] != 'spotify:':
             return ''
         album_image_id = large_image[8:]
-        return 'https://i.scdn.co/image/' + album_image_id
+        return f'https://i.scdn.co/image/{album_image_id}'
 
     @property
     def track_id(self):
@@ -737,12 +734,9 @@ def __hash__(self):
         return hash((self.name, str(self.emoji)))
 
     def __str__(self):
-        if self.emoji:
-            if self.name:
-                return '%s %s' % (self.emoji, self.name)
-            return str(self.emoji)
-        else:
+        if not self.emoji:
             return str(self.name)
+        return f'{self.emoji} {self.name}' if self.name else str(self.emoji)
 
     def __repr__(self):
         return '<CustomActivity name={0.name!r} emoji={0.emoji!r}>'.format(self)
@@ -765,9 +759,7 @@ def create_activity(data):
         else:
             return CustomActivity(name=name, **data)
     elif game_type is ActivityType.streaming:
-        if 'url' in data:
-            return Streaming(**data)
-        return Activity(**data)
+        return Streaming(**data) if 'url' in data else Activity(**data)
     elif game_type is ActivityType.listening and 'sync_id' in data and 'session_id' in data:
         return Spotify(**data)
     return Activity(**data)
diff --git a/discord/asset.py b/discord/asset.py
index ea457297..04c73200 100644
--- a/discord/asset.py
+++ b/discord/asset.py
@@ -74,11 +74,11 @@ def _from_avatar(cls, state, user, *, format=None, static_format='webp', size=10
         if not utils.valid_icon_size(size):
             raise InvalidArgument("size must be a power of 2 between 16 and 4096")
         if format is not None and format not in VALID_AVATAR_FORMATS:
-            raise InvalidArgument("format must be None or one of {}".format(VALID_AVATAR_FORMATS))
+            raise InvalidArgument(f"format must be None or one of {VALID_AVATAR_FORMATS}")
         if format == "gif" and not user.is_avatar_animated():
             raise InvalidArgument("non animated avatars do not support gif format")
         if static_format not in VALID_STATIC_FORMATS:
-            raise InvalidArgument("static_format must be one of {}".format(VALID_STATIC_FORMATS))
+            raise InvalidArgument(f"static_format must be one of {VALID_STATIC_FORMATS}")
 
         if user.avatar is None:
             return user.default_avatar_url
@@ -96,7 +96,7 @@ def _from_icon(cls, state, object, path, *, format='webp', size=1024):
         if not utils.valid_icon_size(size):
             raise InvalidArgument("size must be a power of 2 between 16 and 4096")
         if format not in VALID_STATIC_FORMATS:
-            raise InvalidArgument("format must be None or one of {}".format(VALID_STATIC_FORMATS))
+            raise InvalidArgument(f"format must be None or one of {VALID_STATIC_FORMATS}")
 
         url = '/{0}-icons/{1.id}/{1.icon}.{2}?size={3}'.format(path, object, format, size)
         return cls(state, url)
@@ -109,7 +109,7 @@ def _from_cover_image(cls, state, obj, *, format='webp', size=1024):
         if not utils.valid_icon_size(size):
             raise InvalidArgument("size must be a power of 2 between 16 and 4096")
         if format not in VALID_STATIC_FORMATS:
-            raise InvalidArgument("format must be None or one of {}".format(VALID_STATIC_FORMATS))
+            raise InvalidArgument(f"format must be None or one of {VALID_STATIC_FORMATS}")
 
         url = '/app-assets/{0.id}/store/{0.cover_image}.{1}?size={2}'.format(obj, format, size)
         return cls(state, url)
@@ -119,7 +119,7 @@ def _from_guild_image(cls, state, id, hash, key, *, format='webp', size=1024):
         if not utils.valid_icon_size(size):
             raise InvalidArgument("size must be a power of 2 between 16 and 4096")
         if format not in VALID_STATIC_FORMATS:
-            raise InvalidArgument("format must be one of {}".format(VALID_STATIC_FORMATS))
+            raise InvalidArgument(f"format must be one of {VALID_STATIC_FORMATS}")
 
         if hash is None:
             return cls(state)
@@ -132,11 +132,11 @@ def _from_guild_icon(cls, state, guild, *, format=None, static_format='webp', si
         if not utils.valid_icon_size(size):
             raise InvalidArgument("size must be a power of 2 between 16 and 4096")
         if format is not None and format not in VALID_AVATAR_FORMATS:
-            raise InvalidArgument("format must be one of {}".format(VALID_AVATAR_FORMATS))
+            raise InvalidArgument(f"format must be one of {VALID_AVATAR_FORMATS}")
         if format == "gif" and not guild.is_icon_animated():
             raise InvalidArgument("non animated guild icons do not support gif format")
         if static_format not in VALID_STATIC_FORMATS:
-            raise InvalidArgument("static_format must be one of {}".format(VALID_STATIC_FORMATS))
+            raise InvalidArgument(f"static_format must be one of {VALID_STATIC_FORMATS}")
 
         if guild.icon is None:
             return cls(state)
@@ -156,11 +156,11 @@ def _from_sticker_url(cls, state, sticker, *, size=1024):
     @classmethod
     def _from_emoji(cls, state, emoji, *, format=None, static_format='png'):
         if format is not None and format not in VALID_AVATAR_FORMATS:
-            raise InvalidArgument("format must be None or one of {}".format(VALID_AVATAR_FORMATS))
+            raise InvalidArgument(f"format must be None or one of {VALID_AVATAR_FORMATS}")
         if format == "gif" and not emoji.animated:
             raise InvalidArgument("non animated emoji's do not support gif format")
         if static_format not in VALID_STATIC_FORMATS:
-            raise InvalidArgument("static_format must be one of {}".format(VALID_STATIC_FORMATS))
+            raise InvalidArgument(f"static_format must be one of {VALID_STATIC_FORMATS}")
         if format is None:
             format = 'gif' if emoji.animated else static_format
 
@@ -170,9 +170,7 @@ def __str__(self):
         return self.BASE + self._url if self._url is not None else ''
 
     def __len__(self):
-        if self._url:
-            return len(self.BASE + self._url)
-        return 0
+        return len(self.BASE + self._url) if self._url else 0
 
     def __bool__(self):
         return self._url is not None
diff --git a/discord/audit_logs.py b/discord/audit_logs.py
index 00706f89..63f0f1f2 100644
--- a/discord/audit_logs.py
+++ b/discord/audit_logs.py
@@ -55,14 +55,10 @@ def _transform_channel(entry, data):
     return entry.guild.get_channel(int(data)) or Object(id=data)
 
 def _transform_owner_id(entry, data):
-    if data is None:
-        return None
-    return entry._get_member(int(data))
+    return None if data is None else entry._get_member(int(data))
 
 def _transform_inviter_id(entry, data):
-    if data is None:
-        return None
-    return entry._get_member(int(data))
+    return None if data is None else entry._get_member(int(data))
 
 def _transform_overwrites(entry, data):
     overwrites = []
@@ -94,7 +90,7 @@ def __iter__(self):
 
     def __repr__(self):
         values = ' '.join('%s=%r' % item for item in self.__dict__.items())
-        return '<AuditLogDiff %s>' % values
+        return f'<AuditLogDiff {values}>'
 
 class AuditLogChanges:
     TRANSFORMERS = {
@@ -307,7 +303,7 @@ def created_at(self):
     @utils.cached_property
     def target(self):
         try:
-            converter = getattr(self, '_convert_target_' + self.action.target_type)
+            converter = getattr(self, f'_convert_target_{self.action.target_type}')
         except AttributeError:
             return Object(id=self._target_id)
         else:
@@ -340,18 +336,14 @@ def _convert_target_guild(self, target_id):
 
     def _convert_target_channel(self, target_id):
         ch = self.guild.get_channel(target_id)
-        if ch is None:
-            return Object(id=target_id)
-        return ch
+        return Object(id=target_id) if ch is None else ch
 
     def _convert_target_user(self, target_id):
         return self._get_member(target_id)
 
     def _convert_target_role(self, target_id):
         role = self.guild.get_role(target_id)
-        if role is None:
-            return Object(id=target_id)
-        return role
+        return Object(id=target_id) if role is None else role
 
     def _convert_target_invite(self, target_id):
         # invites have target_id set to null
diff --git a/discord/channel.py b/discord/channel.py
index 067470bb..5c0560a1 100644
--- a/discord/channel.py
+++ b/discord/channel.py
@@ -135,7 +135,7 @@ def __repr__(self):
             ('news', self.is_news()),
             ('category_id', self.category_id)
         ]
-        return '<%s %s>' % (self.__class__.__name__, ' '.join('%s=%r' % t for t in attrs))
+        return f"<{self.__class__.__name__} {' '.join('%s=%r' % t for t in attrs)}>"
 
     def _update(self, guild, data):
         self.guild = guild
@@ -688,7 +688,7 @@ def __repr__(self):
             ('user_limit', self.user_limit),
             ('category_id', self.category_id)
         ]
-        return '<%s %s>' % (self.__class__.__name__, ' '.join('%s=%r' % t for t in attrs))
+        return f"<{self.__class__.__name__} {' '.join('%s=%r' % t for t in attrs)}>"
 
     @property
     def type(self):
@@ -811,7 +811,7 @@ def __repr__(self):
             ('user_limit', self.user_limit),
             ('category_id', self.category_id)
         ]
-        return '<%s %s>' % (self.__class__.__name__, ' '.join('%s=%r' % t for t in attrs))
+        return f"<{self.__class__.__name__} {' '.join('%s=%r' % t for t in attrs)}>"
 
     def _update(self, guild, data):
         super()._update(guild, data)
@@ -1239,7 +1239,7 @@ async def _get_channel(self):
         return self
 
     def __str__(self):
-        return 'Direct Message with %s' % self.recipient
+        return f'Direct Message with {self.recipient}'
 
     def __repr__(self):
         return '<DMChannel id={0.id} recipient={0.recipient!r}>'.format(self)
diff --git a/discord/client.py b/discord/client.py
index 632a5beb..3c9e9905 100644
--- a/discord/client.py
+++ b/discord/client.py
@@ -108,7 +108,7 @@ def __repr__(self):
         ]
         if self._exception is not None:
             info.append(('exception', repr(self._exception)))
-        return '<ClientEventTask {}>'.format(' '.join('%s=%s' % t for t in info))
+        return f"<ClientEventTask {' '.join('%s=%s' % t for t in info)}>"
 
 class Client:
     r"""Represents a client connection that connects to Discord.
@@ -288,9 +288,7 @@ def is_ws_ratelimited(self):
 
         .. versionadded:: 1.6
         """
-        if self.ws:
-            return self.ws.is_ratelimited()
-        return False
+        return self.ws.is_ratelimited() if self.ws else False
 
     @property
     def user(self):
@@ -356,10 +354,9 @@ def _schedule_event(self, coro, event_name, *args, **kwargs):
 
     def dispatch(self, event, *args, **kwargs):
         log.debug('Dispatching event %s', event)
-        method = 'on_' + event
+        method = f'on_{event}'
 
-        listeners = self._listeners.get(event)
-        if listeners:
+        if listeners := self._listeners.get(event):
             removed = []
             for i, (future, condition) in enumerate(listeners):
                 if isinstance(future, asyncio.Future):
@@ -374,7 +371,7 @@ def dispatch(self, event, *args, **kwargs):
                         removed.append(i)
                     else:
                         if result:
-                            if len(args) == 0:
+                            if not args:
                                 future.set_result(None)
                             elif len(args) == 1:
                                 future.set_result(args[0])
@@ -387,10 +384,8 @@ def dispatch(self, event, *args, **kwargs):
                     else:
                         for idx in reversed(removed):
                             del listeners[idx]
-                else:
-                    result = condition(*args)
-                    if result:
-                        self._schedule_event(future, method, *args, **kwargs)
+                elif result := condition(*args):
+                    self._schedule_event(future, method, *args, **kwargs)
 
 
         try:
@@ -409,7 +404,7 @@ async def on_error(self, event_method, *args, **kwargs):
         overridden to have a different implementation.
         Check :func:`~discord.on_error` for more details.
         """
-        print('Ignoring exception in {}'.format(event_method), file=sys.stderr)
+        print(f'Ignoring exception in {event_method}', file=sys.stderr)
         traceback.print_exc()
 
     @utils.deprecated('Guild.chunk')
@@ -666,7 +661,7 @@ async def start(self, *args, **kwargs):
         reconnect = kwargs.pop('reconnect', True)
 
         if kwargs:
-            raise TypeError("unexpected keyword argument(s) %s" % list(kwargs.keys()))
+            raise TypeError(f"unexpected keyword argument(s) {list(kwargs.keys())}")
 
         await self.login(*args, bot=bot)
         await self.connect(reconnect=reconnect)
@@ -865,8 +860,7 @@ def get_all_channels(self):
         """
 
         for guild in self.guilds:
-            for channel in guild.channels:
-                yield channel
+            yield from guild.channels
 
     def get_all_members(self):
         """Returns a generator with every :class:`.Member` the client can see.
@@ -883,8 +877,7 @@ def get_all_members(self):
             A member the client can see.
         """
         for guild in self.guilds:
-            for member in guild.members:
-                yield member
+            yield from guild.members
 
     # listeners/waiters
 
@@ -1183,11 +1176,7 @@ async def change_presence(self, *, activity=None, status=None, afk=False):
             if me is None:
                 continue
 
-            if activity is not None:
-                me.activities = (activity,)
-            else:
-                me.activities = ()
-
+            me.activities = (activity, ) if activity is not None else ()
             me.status = status_enum
 
     # Guild stuff
@@ -1580,13 +1569,10 @@ async def fetch_channel(self, channel_id):
             raise InvalidData('Unknown channel type {type} for channel ID {id}.'.format_map(data))
 
         if ch_type in (ChannelType.group, ChannelType.private):
-            channel = factory(me=self.user, data=data, state=self._connection)
-        else:
-            guild_id = int(data['guild_id'])
-            guild = self.get_guild(guild_id) or Object(id=guild_id)
-            channel = factory(guild=guild, state=self._connection, data=data)
-
-        return channel
+            return factory(me=self.user, data=data, state=self._connection)
+        guild_id = int(data['guild_id'])
+        guild = self.get_guild(guild_id) or Object(id=guild_id)
+        return factory(guild=guild, state=self._connection, data=data)
 
     async def fetch_webhook(self, webhook_id):
         """|coro|
diff --git a/discord/colour.py b/discord/colour.py
index fbf9aaef..ef4bc92e 100644
--- a/discord/colour.py
+++ b/discord/colour.py
@@ -61,7 +61,9 @@ class Colour:
 
     def __init__(self, value):
         if not isinstance(value, int):
-            raise TypeError('Expected int parameter, received %s instead.' % value.__class__.__name__)
+            raise TypeError(
+                f'Expected int parameter, received {value.__class__.__name__} instead.'
+            )
 
         self.value = value
 
@@ -78,7 +80,7 @@ def __str__(self):
         return '#{:0>6x}'.format(self.value)
 
     def __repr__(self):
-        return '<Colour value=%s>' % self.value
+        return f'<Colour value={self.value}>'
 
     def __hash__(self):
         return hash(self.value)
diff --git a/discord/components.py b/discord/components.py
index f20e5a78..37f381a0 100644
--- a/discord/components.py
+++ b/discord/components.py
@@ -105,12 +105,10 @@ def __init__(self, label: str = None,
         self.disabled = disabled
 
     def __repr__(self) -> str:
-        return f'<Button {", ".join(["%s=%s" % (k, str(v)) for k, v in self.__dict__.items()])}>'
+        return f'<Button {", ".join([f"{k}={str(v)}" for k, v in self.__dict__.items()])}>'
 
     def __len__(self):
-        if self.label:
-            return len(self.label)
-        return len(self.emoji)
+        return len(self.label) if self.label else len(self.emoji)
 
     def set_label(self, label: str):
         """
@@ -288,7 +286,7 @@ def __init__(self, label: str,
         self.default = default
 
     def __repr__(self):
-        return f'<SelectOption {", ".join(["%s=%s" % (k, v) for (k, v) in self.__dict__.items()])}>'
+        return f'<SelectOption {", ".join([f"{k}={v}" for k, v in self.__dict__.items()])}>'
 
     def set_default(self, value: bool):
         self.default = value
@@ -344,23 +342,23 @@ def __init__(self, custom_id: Union[str, int],
                  min_values: int = 1,
                  max_values: int = 1,
                  disabled: bool = False):
-        if not any([isinstance(obj, SelectOption) for obj in options]):
+        if not any(isinstance(obj, SelectOption) for obj in options):
             raise InvalidArgument("SelectMenu.options must be a list of discord.SelectOption")
         if len(options) > 25:
             raise InvalidArgument('The maximum number of options in a SelectMenu is 25.')
         self.options = options
         if len(custom_id) > 100:
             raise ValueError(
-                'The maximum length of a custom_id is 100 characters; your one is %s long (%s to long).' % (
-                len(custom_id), len(custom_id) - 100))
+                f'The maximum length of a custom_id is 100 characters; your one is {len(custom_id)} long ({len(custom_id) - 100} to long).'
+            )
         if isinstance(custom_id, str) and custom_id.isdigit():
             self.custom_id = int(custom_id)
         else:
             self.custom_id = custom_id
         if placeholder and len(placeholder) > 100:
             raise AttributeError(
-                'The maximum length of a the placeholder is 100 characters; your one is %s long (%s to long).' % (
-                len(placeholder), len(placeholder) - 100))
+                f'The maximum length of a the placeholder is 100 characters; your one is {len(placeholder)} long ({len(placeholder) - 100} to long).'
+            )
         self.placeholder = placeholder
         if 25 < min_values < 0:
             raise ValueError('The minimum number of elements to be selected must be between 1 and 25.')
@@ -372,7 +370,7 @@ def __init__(self, custom_id: Union[str, int],
         self._values = None
 
     def __repr__(self):
-        return f'<SelectMenu {", ".join(["%s=%s" % (k, v) for k, v in self.__dict__.items()])}>'
+        return f'<SelectMenu {", ".join([f"{k}={v}" for k, v in self.__dict__.items()])}>'
 
     @property
     def all_option_values(self):
@@ -444,12 +442,8 @@ def not_selected(self):
 
         :return: List[Union[int, str]]
         """
-        _not_selected = []
         values = self.values
-        for value in self.all_option_values:
-            if value not in values:
-                _not_selected.append(value)
-        return _not_selected
+        return [value for value in self.all_option_values if value not in values]
 
     def update(self, **kwargs):
         self.__dict__.update((k, v) for k, v in kwargs.items() if k in self.__dict__.keys())
@@ -525,7 +519,7 @@ def __init__(self, *components):
             if isinstance(component, (Button, SelectMenu)):
                 self.components.append(component)
             elif isinstance(component, dict):
-                if not component.get('type', None) in [2, 3]:
+                if component.get('type', None) not in [2, 3]:
                     raise InvalidArgument(
                         'If you use an Dict instead of Button or SelectMenu you have to pass an type between 2 or 3')
                 self.components.append(
@@ -535,19 +529,24 @@ def __repr__(self):
         return f'<ActionRow components={self.components}>'
 
     def __iter__(self):
-        for component in self.components:
-            yield component
+        yield from self.components
 
     def to_dict(self) -> Union[list, EmptyActionRow]:
-        base = []
-        base.extend([{'type': 1, 'components': [obj.to_dict() for obj in self.components[five:5:]]} for five in
-                     range(0, len(self.components), 5)])
+        base = [
+            {
+                'type': 1,
+                'components': [obj.to_dict() for obj in self.components[five:5:]],
+            }
+            for five in range(0, len(self.components), 5)
+        ]
         objects = len([i['components'] for i in base])
-        if any([any([part['type'] == 2]) and any([part['type'] == 3]) for part in base]):
+        if any(
+            any([part['type'] == 2]) and any([part['type'] == 3]) for part in base
+        ):
             raise InvalidArgument('An ActionRow containing a select menu cannot also contain buttons')
-        if any([any([part['type'] == 3]) and len(part) > 1 for part in base]):
+        if any(any([part['type'] == 3]) and len(part) > 1 for part in base):
             raise InvalidArgument('An ActionRow can contain only one SelectMenu')
-        if any([len(ar['components']) < 1 for ar in base]):
+        if any(len(ar['components']) < 1 for ar in base):
             raise EmptyActionRow from base
         elif len(base) > 5 or objects > 25:
             raise InvalidArgument(
@@ -622,7 +621,7 @@ def set_component_at(self, index, component: Union[Button, SelectMenu]):
         try:
             _component = self.components[index]
         except IndexError:
-            raise IndexError('component index %s out of range' % index)
+            raise IndexError(f'component index {index} out of range')
         _component = component
         return self
 
@@ -645,7 +644,7 @@ def disable_component_at(self, index):
         try:
             component = self.components[index]
         except IndexError:
-            raise IndexError('component index %s out of range' % index)
+            raise IndexError(f'component index {index} out of range')
         component.disabled = True
         return self
 
@@ -765,10 +764,9 @@ def disable_all_select_menus_if(self, check: Union[bool, typing.Callable], *args
     @classmethod
     def from_dict(cls, data):
         if data.get('type', None) != 1:
-            return InvalidArgument("%s could not be implemented as an ActionRow" % data)
-        else:
-            components = [_component_factory(component) for component in data.get('components', [])]
-            return cls(*components)
+            return InvalidArgument(f"{data} could not be implemented as an ActionRow")
+        components = [_component_factory(component) for component in data.get('components', [])]
+        return cls(*components)
 
 
 def _component_factory(data):
diff --git a/discord/embeds.py b/discord/embeds.py
index f8ae948a..bb268a2d 100644
--- a/discord/embeds.py
+++ b/discord/embeds.py
@@ -52,7 +52,7 @@ def __len__(self):
         return len(self.__dict__)
 
     def __repr__(self):
-        return 'EmbedProxy(%s)' % ', '.join(('%s=%r' % (k, v) for k, v in self.__dict__.items() if not k.startswith('_')))
+        return f"EmbedProxy({', '.join('%s=%r' % (k, v) for k, v in self.__dict__.items() if not k.startswith('_'))})"
 
     def __getattr__(self, attr):
         return EmptyEmbed
@@ -191,7 +191,7 @@ def from_dict(cls, data):
             except KeyError:
                 continue
             else:
-                setattr(self, '_' + attr, value)
+                setattr(self, f'_{attr}', value)
 
         return self
 
@@ -231,7 +231,9 @@ def colour(self, value):
         elif isinstance(value, int):
             self._colour = Colour(value=value)
         else:
-            raise TypeError('Expected discord.Colour, int, or Embed.Empty but received %s instead.' % value.__class__.__name__)
+            raise TypeError(
+                f'Expected discord.Colour, int, or Embed.Empty but received {value.__class__.__name__} instead.'
+            )
 
     color = colour
 
@@ -244,7 +246,9 @@ def timestamp(self, value):
         if isinstance(value, (datetime.datetime, _EmptyEmbed)):
             self._timestamp = value
         else:
-            raise TypeError("Expected datetime.datetime or Embed.Empty received %s instead" % value.__class__.__name__)
+            raise TypeError(
+                f"Expected datetime.datetime or Embed.Empty received {value.__class__.__name__} instead"
+            )
 
     @property
     def footer(self):
diff --git a/discord/emoji.py b/discord/emoji.py
index 02d31b24..b7f161ae 100644
--- a/discord/emoji.py
+++ b/discord/emoji.py
@@ -94,8 +94,7 @@ def _from_data(self, emoji):
         self.animated = emoji.get('animated', False)
         self.available = emoji.get('available', True)
         self._roles = utils.SnowflakeList(map(int, emoji.get('roles', [])))
-        user = emoji.get('user', None)
-        if user:
+        if user := emoji.get('user', None):
             self.user = self._state.get_user(int(user['id']))
         else:
             self.user = None
diff --git a/discord/enums.py b/discord/enums.py
index 10cffda3..5908ad0d 100644
--- a/discord/enums.py
+++ b/discord/enums.py
@@ -63,9 +63,9 @@
 
 
 def _create_value_cls(name):
-    cls = namedtuple('_EnumValue_' + name, 'name value')
+    cls = namedtuple(f'_EnumValue_{name}', 'name value')
     cls.__repr__ = lambda self: '<%s.%s: %r>' % (name, self.name, self.value)
-    cls.__str__ = lambda self: '%s.%s' % (name, self.name)
+    cls.__str__ = lambda self: f'{name}.{self.name}'
     return cls
 
 
@@ -111,35 +111,35 @@ def __new__(cls, name, bases, attrs):
         value_cls._actual_enum_cls_ = actual_cls
         return actual_cls
 
-    def __iter__(cls):
+    def __iter__(self):
         return (cls._enum_member_map_[name] for name in cls._enum_member_names_)
 
-    def __reversed__(cls):
+    def __reversed__(self):
         return (cls._enum_member_map_[name] for name in reversed(cls._enum_member_names_))
 
-    def __len__(cls):
-        return len(cls._enum_member_names_)
+    def __len__(self):
+        return len(self._enum_member_names_)
 
-    def __repr__(cls):
-        return '<enum %r>' % cls.__name__
+    def __repr__(self):
+        return '<enum %r>' % self.__name__
 
     @property
     def __members__(cls):
         return types.MappingProxyType(cls._enum_member_map_)
 
-    def __call__(cls, value):
+    def __call__(self, value):
         try:
-            return cls._enum_value_map_[value]
+            return self._enum_value_map_[value]
         except (KeyError, TypeError):
-            raise ValueError("%r is not a valid %s" % (value, cls.__name__))
+            raise ValueError("%r is not a valid %s" % (value, self.__name__))
 
-    def __getitem__(cls, key):
-        return cls._enum_member_map_[key]
+    def __getitem__(self, key):
+        return self._enum_member_map_[key]
 
-    def __setattr__(cls, name, value):
+    def __setattr__(self, name, value):
         raise TypeError('Enums are immutable.')
 
-    def __delattr__(cls, attr):
+    def __delattr__(self, attr):
         raise TypeError('Enums are immutable')
 
     def __instancecheck__(self, instance):
diff --git a/discord/errors.py b/discord/errors.py
index 1c64d0a2..6a50ad4c 100644
--- a/discord/errors.py
+++ b/discord/errors.py
@@ -66,7 +66,7 @@ def __init__(self):
 def flatten_error_dict(d, key=''):
     items = []
     for k, v in d.items():
-        new_key = key + '.' + k if key else k
+        new_key = f'{key}.{k}' if key else k
 
         if isinstance(v, dict):
             try:
@@ -105,8 +105,7 @@ def __init__(self, response, message):
         if isinstance(message, dict):
             self.code = message.get('code', 0)
             base = message.get('message', '')
-            errors = message.get('errors')
-            if errors:
+            if errors := message.get('errors'):
                 errors = flatten_error_dict(errors)
                 helpful = '\n'.join('In %s: %s' % t for t in errors.items())
                 self.text = base + '\n' + helpful
@@ -195,7 +194,7 @@ def __init__(self, socket, *, shard_id, code=None):
         # aiohttp doesn't seem to consistently provide close reason
         self.reason = ''
         self.shard_id = shard_id
-        super().__init__('Shard ID %s WebSocket closed with %s' % (self.shard_id, self.code))
+        super().__init__(f'Shard ID {self.shard_id} WebSocket closed with {self.code}')
 
 
 class PrivilegedIntentsRequired(ClientException):
diff --git a/discord/ext/commands/bot.py b/discord/ext/commands/bot.py
index 1d2493a6..09967c41 100644
--- a/discord/ext/commands/bot.py
+++ b/discord/ext/commands/bot.py
@@ -46,7 +46,7 @@ def when_mentioned(bot, msg):
 
     These are meant to be passed into the :attr:`.Bot.command_prefix` attribute.
     """
-    return [bot.user.mention + ' ', '<@!%s> ' % bot.user.id]
+    return [f'{bot.user.mention} ', f'<@!{bot.user.id}> ']
 
 def when_mentioned_or(*prefixes):
     """A callable that implements when mentioned or other prefixes provided.
@@ -85,7 +85,7 @@ def inner(bot, msg):
     return inner
 
 def _is_submodule(parent, child):
-    return parent == child or child.startswith(parent + ".")
+    return parent == child or child.startswith(f"{parent}.")
 
 class _DefaultRepr:
     def __repr__(self):
@@ -131,7 +131,7 @@ def __init__(self, command_prefix, help_command=_default, description=None, **op
 
     def dispatch(self, event_name, *args, **kwargs):
         super().dispatch(event_name, *args, **kwargs)
-        ev = 'on_' + event_name
+        ev = f'on_{event_name}'
         for event in self.extra_events.get(ev, []):
             self._schedule_event(event, ev, *args, **kwargs)
         for (func, check) in self.extra_interaction_events.get(event_name, []):
@@ -174,7 +174,7 @@ async def on_command_error(self, context, exception):
         if cog and Cog._get_overridden_method(cog.cog_command_error) is not None:
             return
 
-        print('Ignoring exception in command {}:'.format(context.command), file=sys.stderr)
+        print(f'Ignoring exception in command {context.command}:', file=sys.stderr)
         traceback.print_exception(type(exception), exception, exception.__traceback__, file=sys.stderr)
 
     # global check registration
@@ -695,11 +695,12 @@ def _remove_module_references(self, name):
 
         # remove all the listeners from the module
         for event_list in self.extra_events.copy().values():
-            remove = []
-            for index, event in enumerate(event_list):
-                if event.__module__ is not None and _is_submodule(name, event.__module__):
-                    remove.append(index)
-
+            remove = [
+                index
+                for index, event in enumerate(event_list)
+                if event.__module__ is not None
+                and _is_submodule(name, event.__module__)
+            ]
             for index in reversed(remove):
                 del event_list[index]
 
@@ -962,8 +963,9 @@ async def get_prefix(self, message):
                 if isinstance(ret, collections.abc.Iterable):
                     raise
 
-                raise TypeError("command_prefix must be plain string, iterable of strings, or callable "
-                                "returning either of these, not {}".format(ret.__class__.__name__))
+                raise TypeError(
+                    f"command_prefix must be plain string, iterable of strings, or callable returning either of these, not {ret.__class__.__name__}"
+                )
 
             if not ret:
                 raise ValueError("Iterable command_prefix must contain at least one prefix")
@@ -1023,14 +1025,16 @@ class be provided, it must be similar enough to :class:`.Context`\'s
 
             except TypeError:
                 if not isinstance(prefix, list):
-                    raise TypeError("get_prefix must return either a string or a list of string, "
-                                    "not {}".format(prefix.__class__.__name__))
+                    raise TypeError(
+                        f"get_prefix must return either a string or a list of string, not {prefix.__class__.__name__}"
+                    )
 
                 # It's possible a bad command_prefix got us here.
                 for value in prefix:
                     if not isinstance(value, str):
-                        raise TypeError("Iterable command_prefix or list returned from get_prefix must "
-                                        "contain only strings, not {}".format(value.__class__.__name__))
+                        raise TypeError(
+                            f"Iterable command_prefix or list returned from get_prefix must contain only strings, not {value.__class__.__name__}"
+                        )
 
                 # Getting here shouldn't happen
                 raise
@@ -1067,7 +1071,7 @@ async def invoke(self, ctx):
             else:
                 self.dispatch('command_completion', ctx)
         elif ctx.invoked_with:
-            exc = errors.CommandNotFound('Command "{}" is not found'.format(ctx.invoked_with))
+            exc = errors.CommandNotFound(f'Command "{ctx.invoked_with}" is not found')
             self.dispatch('command_error', ctx, exc)
 
     async def process_commands(self, message):
diff --git a/discord/ext/commands/cog.py b/discord/ext/commands/cog.py
index 90bd103e..8fd8dcda 100644
--- a/discord/ext/commands/cog.py
+++ b/discord/ext/commands/cog.py
@@ -146,16 +146,16 @@ def __new__(cls, *args, **kwargs):
 
         listeners_as_list = []
         for listener in listeners.values():
-            for listener_name in listener.__cog_listener_names__:
-                # I use __name__ instead of just storing the value so I can inject
-                # the self attribute when the time comes to add them to the bot
-                listeners_as_list.append((listener_name, listener.__name__))
-
+            listeners_as_list.extend(
+                (listener_name, listener.__name__)
+                for listener_name in listener.__cog_listener_names__
+            )
         interaction_listeners_as_list = []
         for interaction_listener in cog_interaction_listeners.values():
-            for listener_name, custom_id in interaction_listener.__interaction_listener_names__:
-                interaction_listeners_as_list.append((listener_name, interaction_listener.__name__, custom_id))
-
+            interaction_listeners_as_list.extend(
+                (listener_name, interaction_listener.__name__, custom_id)
+                for listener_name, custom_id in interaction_listener.__interaction_listener_names__
+            )
         new_cls.__cog_listeners__ = listeners_as_list
         new_cls.__cog_interaction_listeners__ = interaction_listeners_as_list
 
diff --git a/discord/ext/commands/context.py b/discord/ext/commands/context.py
index 8df4f730..2d637771 100644
--- a/discord/ext/commands/context.py
+++ b/discord/ext/commands/context.py
@@ -141,8 +141,7 @@ async def invoke(self, *args, **kwargs):
         arguments.append(self)
         arguments.extend(args[1:])
 
-        ret = await command.callback(*arguments, **kwargs)
-        return ret
+        return await command.callback(*arguments, **kwargs)
 
     async def reinvoke(self, *, call_hooks=False, restart=True):
         """|coro|
@@ -218,9 +217,7 @@ async def _get_channel(self):
     def cog(self):
         """Optional[:class:`.Cog`]: Returns the cog associated with this context's command. None if it does not exist."""
 
-        if self.command is None:
-            return None
-        return self.command.cog
+        return None if self.command is None else self.command.cog
 
     @discord.utils.cached_property
     def guild(self):
@@ -295,7 +292,7 @@ async def send_help(self, *args):
 
         cmd = cmd.copy()
         cmd.context = self
-        if len(args) == 0:
+        if not args:
             await cmd.prepare_help_command(self, None)
             mapping = cmd.get_bot_mapping()
             injected = wrap_callback(cmd.send_bot_help)
diff --git a/discord/ext/commands/converter.py b/discord/ext/commands/converter.py
index fdc7649b..9e927337 100644
--- a/discord/ext/commands/converter.py
+++ b/discord/ext/commands/converter.py
@@ -159,9 +159,7 @@ async def query_member_by_id(self, bot, guild, user_id):
 
         # If we're not being rate limited then we can use the websocket to actually query
         members = await guild.query_members(limit=1, user_ids=[user_id], cache=cache)
-        if not members:
-            return None
-        return members[0]
+        return None if not members else members[0]
 
     async def convert(self, ctx, argument):
         bot = ctx.bot
@@ -302,8 +300,7 @@ class MessageConverter(PartialMessageConverter):
     """
     async def convert(self, ctx, argument):
         message_id, channel_id = self._get_id_matches(argument)
-        message = ctx.bot._connection._get_message(message_id)
-        if message:
+        if message := ctx.bot._connection._get_message(message_id):
             return message
         channel = ctx.bot.get_channel(channel_id) if channel_id else ctx.channel
         if not channel:
@@ -586,7 +583,7 @@ async def convert(self, ctx, argument):
         if argument[0] == '#':
             return self.parse_hex_number(argument[1:])
 
-        if argument[0:2] == '0x':
+        if argument[:2] == '0x':
             rest = argument[2:]
             # Legacy backwards compatible syntax
             if rest.startswith('#'):
@@ -594,7 +591,7 @@ async def convert(self, ctx, argument):
             return self.parse_hex_number(rest)
 
         arg = argument.lower()
-        if arg[0:3] == 'rgb':
+        if arg[:3] == 'rgb':
             return self.parse_rgb(arg)
 
         arg = arg.replace(' ', '_')
@@ -625,8 +622,9 @@ async def convert(self, ctx, argument):
         if not guild:
             raise NoPrivateMessage()
 
-        match = self._get_id_match(argument) or re.match(r'<@&([0-9]+)>$', argument)
-        if match:
+        if match := self._get_id_match(argument) or re.match(
+            r'<@&([0-9]+)>$', argument
+        ):
             result = guild.get_role(int(match.group(1)))
         else:
             result = discord.utils.get(guild._roles.values(), name=argument)
@@ -650,8 +648,7 @@ class InviteConverter(Converter):
     """
     async def convert(self, ctx, argument):
         try:
-            invite = await ctx.bot.fetch_invite(argument)
-            return invite
+            return await ctx.bot.fetch_invite(argument)
         except Exception as exc:
             raise BadInviteArgument() from exc
 
@@ -677,8 +674,8 @@ async def convert(self, ctx, argument):
         if result is None:
             result = discord.utils.get(ctx.bot.guilds, name=argument)
 
-            if result is None:
-                raise GuildNotFound(argument)
+        if result is None:
+            raise GuildNotFound(argument)
         return result
 
 class EmojiConverter(IDConverter):
@@ -733,12 +730,10 @@ class PartialEmojiConverter(Converter):
          Raise :exc:`.PartialEmojiConversionFailure` instead of generic :exc:`.BadArgument`
     """
     async def convert(self, ctx, argument):
-        match = re.match(r'<(a?):([a-zA-Z0-9\_]+):([0-9]+)>$', argument)
-
-        if match:
-            emoji_animated = bool(match.group(1))
-            emoji_name = match.group(2)
-            emoji_id = int(match.group(3))
+        if match := re.match(r'<(a?):([a-zA-Z0-9\_]+):([0-9]+)>$', argument):
+            emoji_animated = bool(match[1])
+            emoji_name = match[2]
+            emoji_id = int(match[3])
 
             return discord.PartialEmoji.with_state(ctx.bot._connection, animated=emoji_animated, name=emoji_name,
                                                    id=emoji_id)
@@ -777,37 +772,39 @@ async def convert(self, ctx, argument):
         if self.fix_channel_mentions and ctx.guild:
             def resolve_channel(id, *, _get=ctx.guild.get_channel):
                 ch = _get(id)
-                return ('<#%s>' % id), ('#' + ch.name if ch else '#deleted-channel')
+                return f'<#{id}>', f'#{ch.name}' if ch else '#deleted-channel'
 
             transformations.update(resolve_channel(channel) for channel in message.raw_channel_mentions)
 
         if self.use_nicknames and ctx.guild:
             def resolve_member(id, *, _get=ctx.guild.get_member):
                 m = _get(id)
-                return '@' + m.display_name if m else '@deleted-user'
+                return f'@{m.display_name}' if m else '@deleted-user'
+
         else:
             def resolve_member(id, *, _get=ctx.bot.get_user):
                 m = _get(id)
-                return '@' + m.name if m else '@deleted-user'
+                return f'@{m.name}' if m else '@deleted-user'
+
 
 
         transformations.update(
-            ('<@%s>' % member_id, resolve_member(member_id))
+            (f'<@{member_id}>', resolve_member(member_id))
             for member_id in message.raw_mentions
         )
 
         transformations.update(
-            ('<@!%s>' % member_id, resolve_member(member_id))
+            (f'<@!{member_id}>', resolve_member(member_id))
             for member_id in message.raw_mentions
         )
 
         if ctx.guild:
             def resolve_role(_id, *, _find=ctx.guild.get_role):
                 r = _find(_id)
-                return '@' + r.name if r else '@deleted-role'
+                return f'@{r.name}' if r else '@deleted-role'
 
             transformations.update(
-                ('<@&%s>' % role_id, resolve_role(role_id))
+                (f'<@&{role_id}>', resolve_role(role_id))
                 for role_id in message.raw_role_mentions
             )
 
@@ -842,7 +839,7 @@ def __getitem__(self, params):
             raise TypeError('Greedy[...] expects a type or a Converter instance.')
 
         if converter is str or converter is type(None) or converter is _Greedy:
-            raise TypeError('Greedy[%s] is invalid.' % converter.__name__)
+            raise TypeError(f'Greedy[{converter.__name__}] is invalid.')
 
         if getattr(converter, '__origin__', None) is typing.Union and type(None) in converter.__args__:
             raise TypeError('Greedy[%r] is invalid.' % converter)
diff --git a/discord/ext/commands/cooldowns.py b/discord/ext/commands/cooldowns.py
index 54a53396..749a0b3a 100644
--- a/discord/ext/commands/cooldowns.py
+++ b/discord/ext/commands/cooldowns.py
@@ -88,20 +88,13 @@ def get_tokens(self, current=None):
         if not current:
             current = time.time()
 
-        tokens = self._tokens
-
-        if current > self._window + self.per:
-            tokens = self.rate
-        return tokens
+        return self.rate if current > self._window + self.per else self._tokens
 
     def get_retry_after(self, current=None):
         current = current or time.time()
         tokens = self.get_tokens(current)
 
-        if tokens == 0:
-            return self.per - (current - self._window)
-
-        return 0.0
+        return self.per - (current - self._window) if tokens == 0 else 0.0
 
     def update_rate_limit(self, current=None):
         current = current or time.time()
diff --git a/discord/ext/commands/core.py b/discord/ext/commands/core.py
index 1c22ec0a..ecfdc82b 100644
--- a/discord/ext/commands/core.py
+++ b/discord/ext/commands/core.py
@@ -442,22 +442,19 @@ async def _actual_conversion(self, ctx, converter, argument, param):
             pass
         else:
             if module is not None and (module.startswith('discord.') and not module.endswith('converter')):
-                converter = getattr(converters, converter.__name__ + 'Converter', converter)
+                converter = getattr(converters, f'{converter.__name__}Converter', converter)
 
         try:
             if inspect.isclass(converter):
                 if issubclass(converter, converters.Converter):
                     instance = converter()
-                    ret = await instance.convert(ctx, argument)
-                    return ret
+                    return await instance.convert(ctx, argument)
                 else:
                     method = getattr(converter, 'convert', None)
                     if method is not None and inspect.ismethod(method):
-                        ret = await method(ctx, argument)
-                        return ret
+                        return await method(ctx, argument)
             elif isinstance(converter, converters.Converter):
-                ret = await converter.convert(ctx, argument)
-                return ret
+                return await converter.convert(ctx, argument)
         except CommandError:
             raise
         except Exception as exc:
@@ -473,7 +470,9 @@ async def _actual_conversion(self, ctx, converter, argument, param):
             except AttributeError:
                 name = converter.__class__.__name__
 
-            raise BadArgument('Converting to "{}" failed for parameter "{}".'.format(name, param.name)) from exc
+            raise BadArgument(
+                f'Converting to "{name}" failed for parameter "{param.name}".'
+            ) from exc
 
     async def do_conversion(self, ctx, converter, argument, param):
         try:
@@ -523,7 +522,7 @@ async def transform(self, ctx, param):
         # The greedy converter is simple -- it keeps going until it fails in which case,
         # it undos the view ready for the next parameter to use instead
         if type(converter) is converters._Greedy:
-            if param.kind == param.POSITIONAL_OR_KEYWORD or param.kind == param.POSITIONAL_ONLY:
+            if param.kind in [param.POSITIONAL_OR_KEYWORD, param.POSITIONAL_ONLY]:
                 return await self._transform_greedy_pos(ctx, param, required, converter.converter)
             elif param.kind == param.VAR_POSITIONAL:
                 return await self._transform_greedy_var_pos(ctx, param, converter.converter)
@@ -568,9 +567,7 @@ async def _transform_greedy_pos(self, ctx, param, required, converter):
             else:
                 result.append(value)
 
-        if not result and not required:
-            return param.default
-        return result
+        return param.default if not result and not required else result
 
     async def _transform_greedy_var_pos(self, ctx, param, converter):
         view = ctx.view
@@ -645,9 +642,7 @@ def root_parent(self):
 
         For example in commands ``?a b c test``, the root parent is ``a``.
         """
-        if not self.parent:
-            return None
-        return self.parents[-1]
+        return None if not self.parent else self.parents[-1]
 
     @property
     def qualified_name(self):
@@ -658,9 +653,8 @@ def qualified_name(self):
         ``one two three``.
         """
 
-        parent = self.full_parent_name
-        if parent:
-            return parent + ' ' + self.name
+        if parent := self.full_parent_name:
+            return f'{parent} {self.name}'
         else:
             return self.name
 
@@ -693,7 +687,7 @@ async def _parse_arguments(self, ctx):
             raise discord.ClientException(fmt.format(self))
 
         for name, param in iterator:
-            if param.kind == param.POSITIONAL_OR_KEYWORD or param.kind == param.POSITIONAL_ONLY:
+            if param.kind in [param.POSITIONAL_OR_KEYWORD, param.POSITIONAL_ONLY]:
                 transformed = await self.transform(ctx, param)
                 args.append(transformed)
             elif param.kind == param.KEYWORD_ONLY:
@@ -716,18 +710,14 @@ async def _parse_arguments(self, ctx):
                         break
 
         if not self.ignore_extra and not view.eof:
-            raise TooManyArguments('Too many arguments passed to ' + self.qualified_name)
+            raise TooManyArguments(f'Too many arguments passed to {self.qualified_name}')
 
     async def call_before_hooks(self, ctx):
         # now that we're done preparing we can call the pre-command hooks
         # first, call the command local hook:
         cog = self.cog
         if self._before_invoke is not None:
-            # should be cog if @commands.before_invoke is used
-            instance = getattr(self._before_invoke, '__self__', cog)
-            # __self__ only exists for methods, not functions
-            # however, if @command.before_invoke is used, it will be a function
-            if instance:
+            if instance := getattr(self._before_invoke, '__self__', cog):
                 await self._before_invoke(instance, ctx)
             else:
                 await self._before_invoke(ctx)
@@ -746,9 +736,8 @@ async def call_before_hooks(self, ctx):
     async def call_after_hooks(self, ctx):
         cog = self.cog
         if self._after_invoke is not None:
-            instance = getattr(self._after_invoke, '__self__', cog)
-            if instance:
-                    await self._after_invoke(instance, ctx)
+            if instance := getattr(self._after_invoke, '__self__', cog):
+                await self._after_invoke(instance, ctx)
             else:
                 await self._after_invoke(ctx)
 
@@ -767,8 +756,7 @@ def _prepare_cooldowns(self, ctx):
             dt = ctx.message.edited_at or ctx.message.created_at
             current = dt.replace(tzinfo=datetime.timezone.utc).timestamp()
             bucket = self._buckets.get_bucket(ctx.message, current)
-            retry_after = bucket.update_rate_limit(current)
-            if retry_after:
+            if retry_after := bucket.update_rate_limit(current):
                 raise CommandOnCooldown(bucket, retry_after)
 
     async def prepare(self, ctx):
@@ -979,9 +967,7 @@ def short_doc(self):
         """
         if self.brief is not None:
             return self.brief
-        if self.help is not None:
-            return self.help.split('\n', 1)[0]
-        return ''
+        return self.help.split('\n', 1)[0] if self.help is not None else ''
 
     def _is_typing_optional(self, annotation):
         try:
@@ -1014,23 +1000,26 @@ def signature(self):
                 # do [name] since [name=None] or [name=] are not exactly useful for the user.
                 should_print = param.default if isinstance(param.default, str) else param.default is not None
                 if should_print:
-                    result.append('[%s=%s]' % (name, param.default) if not greedy else
-                                  '[%s=%s]...' % (name, param.default))
+                    result.append(
+                        f'[{name}={param.default}]'
+                        if not greedy
+                        else f'[{name}={param.default}]...'
+                    )
                     continue
                 else:
-                    result.append('[%s]' % name)
+                    result.append(f'[{name}]')
 
             elif param.kind == param.VAR_POSITIONAL:
                 if self.require_var_positional:
-                    result.append('<%s...>' % name)
+                    result.append(f'<{name}...>')
                 else:
-                    result.append('[%s...]' % name)
+                    result.append(f'[{name}...]')
             elif greedy:
-                result.append('[%s]...' % name)
+                result.append(f'[{name}]...')
             elif self._is_typing_optional(param.annotation):
-                result.append('[%s]' % name)
+                result.append(f'[{name}]')
             else:
-                result.append('<%s>' % name)
+                result.append(f'<{name}>')
 
         return ' '.join(result)
 
@@ -1079,12 +1068,12 @@ async def can_run(self, ctx):
                     if not ret:
                         return False
 
-            predicates = self.checks
-            if not predicates:
+            if predicates := self.checks:
+                return await discord.utils.async_all(predicate(ctx) for predicate in predicates)
+            else:
                 # since we have no checks, then we just return True.
                 return True
 
-            return await discord.utils.async_all(predicate(ctx) for predicate in predicates)
         finally:
             ctx.command = original
 
@@ -1776,7 +1765,7 @@ async def test(ctx):
 
     invalid = set(perms) - set(discord.Permissions.VALID_FLAGS)
     if invalid:
-        raise TypeError('Invalid permission(s): %s' % (', '.join(invalid)))
+        raise TypeError(f"Invalid permission(s): {', '.join(invalid)}")
 
     def predicate(ctx):
         ch = ctx.channel
@@ -1801,7 +1790,7 @@ def bot_has_permissions(**perms):
 
     invalid = set(perms) - set(discord.Permissions.VALID_FLAGS)
     if invalid:
-        raise TypeError('Invalid permission(s): %s' % (', '.join(invalid)))
+        raise TypeError(f"Invalid permission(s): {', '.join(invalid)}")
 
     def predicate(ctx):
         guild = ctx.guild
@@ -1829,7 +1818,7 @@ def has_guild_permissions(**perms):
 
     invalid = set(perms) - set(discord.Permissions.VALID_FLAGS)
     if invalid:
-        raise TypeError('Invalid permission(s): %s' % (', '.join(invalid)))
+        raise TypeError(f"Invalid permission(s): {', '.join(invalid)}")
 
     def predicate(ctx):
         if not ctx.guild:
@@ -1854,7 +1843,7 @@ def bot_has_guild_permissions(**perms):
 
     invalid = set(perms) - set(discord.Permissions.VALID_FLAGS)
     if invalid:
-        raise TypeError('Invalid permission(s): %s' % (', '.join(invalid)))
+        raise TypeError(f"Invalid permission(s): {', '.join(invalid)}")
 
     def predicate(ctx):
         if not ctx.guild:
diff --git a/discord/ext/commands/errors.py b/discord/ext/commands/errors.py
index d533d96a..e09bef8d 100644
--- a/discord/ext/commands/errors.py
+++ b/discord/ext/commands/errors.py
@@ -229,7 +229,7 @@ class MemberNotFound(BadArgument):
     """
     def __init__(self, argument):
         self.argument = argument
-        super().__init__('Member "{}" not found.'.format(argument))
+        super().__init__(f'Member "{argument}" not found.')
 
 class GuildNotFound(BadArgument):
     """Exception raised when the guild provided was not found in the bot's cache.
@@ -245,7 +245,7 @@ class GuildNotFound(BadArgument):
     """
     def __init__(self, argument):
         self.argument = argument
-        super().__init__('Guild "{}" not found.'.format(argument))
+        super().__init__(f'Guild "{argument}" not found.')
 
 class UserNotFound(BadArgument):
     """Exception raised when the user provided was not found in the bot's
@@ -262,7 +262,7 @@ class UserNotFound(BadArgument):
     """
     def __init__(self, argument):
         self.argument = argument
-        super().__init__('User "{}" not found.'.format(argument))
+        super().__init__(f'User "{argument}" not found.')
 
 class MessageNotFound(BadArgument):
     """Exception raised when the message provided was not found in the channel.
@@ -278,7 +278,7 @@ class MessageNotFound(BadArgument):
     """
     def __init__(self, argument):
         self.argument = argument
-        super().__init__('Message "{}" not found.'.format(argument))
+        super().__init__(f'Message "{argument}" not found.')
 
 class ChannelNotReadable(BadArgument):
     """Exception raised when the bot does not have permission to read messages
@@ -295,7 +295,7 @@ class ChannelNotReadable(BadArgument):
     """
     def __init__(self, argument):
         self.argument = argument
-        super().__init__("Can't read messages in {}.".format(argument.mention))
+        super().__init__(f"Can't read messages in {argument.mention}.")
 
 class ChannelNotFound(BadArgument):
     """Exception raised when the bot can not find the channel.
@@ -311,7 +311,7 @@ class ChannelNotFound(BadArgument):
     """
     def __init__(self, argument):
         self.argument = argument
-        super().__init__('Channel "{}" not found.'.format(argument))
+        super().__init__(f'Channel "{argument}" not found.')
 
 class BadColourArgument(BadArgument):
     """Exception raised when the colour is not valid.
@@ -327,7 +327,7 @@ class BadColourArgument(BadArgument):
     """
     def __init__(self, argument):
         self.argument = argument
-        super().__init__('Colour "{}" is invalid.'.format(argument))
+        super().__init__(f'Colour "{argument}" is invalid.')
 
 BadColorArgument = BadColourArgument
 
@@ -345,7 +345,7 @@ class RoleNotFound(BadArgument):
     """
     def __init__(self, argument):
         self.argument = argument
-        super().__init__('Role "{}" not found.'.format(argument))
+        super().__init__(f'Role "{argument}" not found.')
 
 class BadInviteArgument(BadArgument):
     """Exception raised when the invite is invalid or expired.
@@ -371,7 +371,7 @@ class EmojiNotFound(BadArgument):
     """
     def __init__(self, argument):
         self.argument = argument
-        super().__init__('Emoji "{}" not found.'.format(argument))
+        super().__init__(f'Emoji "{argument}" not found.')
 
 class PartialEmojiConversionFailure(BadArgument):
     """Exception raised when the emoji provided does not match the correct
@@ -388,7 +388,7 @@ class PartialEmojiConversionFailure(BadArgument):
     """
     def __init__(self, argument):
         self.argument = argument
-        super().__init__('Couldn\'t convert "{}" to PartialEmoji.'.format(argument))
+        super().__init__(f"""Couldn\'t convert "{argument}" to PartialEmoji.""")
 
 class BadBoolArgument(BadArgument):
     """Exception raised when a boolean argument was not convertable.
@@ -404,7 +404,7 @@ class BadBoolArgument(BadArgument):
     """
     def __init__(self, argument):
         self.argument = argument
-        super().__init__('{} is not a recognised boolean option'.format(argument))
+        super().__init__(f'{argument} is not a recognised boolean option')
 
 class DisabledCommand(CommandError):
     """Exception raised when the command being invoked is disabled.
@@ -463,10 +463,12 @@ def __init__(self, number, per):
         self.number = number
         self.per = per
         name = per.name
-        suffix = 'per %s' % name if per.name != 'default' else 'globally'
+        suffix = f'per {name}' if per.name != 'default' else 'globally'
         plural = '%s times %s' if number > 1 else '%s time %s'
         fmt = plural % (number, suffix)
-        super().__init__('Too many people using this command. It can only be used {} concurrently.'.format(fmt))
+        super().__init__(
+            f'Too many people using this command. It can only be used {fmt} concurrently.'
+        )
 
 class MissingRole(CheckFailure):
     """Exception raised when the command invoker lacks a role to run a command.
@@ -521,14 +523,14 @@ class MissingAnyRole(CheckFailure):
     def __init__(self, missing_roles):
         self.missing_roles = missing_roles
 
-        missing = ["'{}'".format(role) for role in missing_roles]
+        missing = [f"'{role}'" for role in missing_roles]
 
         if len(missing) > 2:
-            fmt = '{}, or {}'.format(", ".join(missing[:-1]), missing[-1])
+            fmt = f'{", ".join(missing[:-1])}, or {missing[-1]}'
         else:
             fmt = ' or '.join(missing)
 
-        message = "You are missing at least one of the required roles: {}".format(fmt)
+        message = f"You are missing at least one of the required roles: {fmt}"
         super().__init__(message)
 
 
@@ -550,14 +552,14 @@ class BotMissingAnyRole(CheckFailure):
     def __init__(self, missing_roles):
         self.missing_roles = missing_roles
 
-        missing = ["'{}'".format(role) for role in missing_roles]
+        missing = [f"'{role}'" for role in missing_roles]
 
         if len(missing) > 2:
-            fmt = '{}, or {}'.format(", ".join(missing[:-1]), missing[-1])
+            fmt = f'{", ".join(missing[:-1])}, or {missing[-1]}'
         else:
             fmt = ' or '.join(missing)
 
-        message = "Bot is missing at least one of the required roles: {}".format(fmt)
+        message = f"Bot is missing at least one of the required roles: {fmt}"
         super().__init__(message)
 
 class NSFWChannelRequired(CheckFailure):
@@ -574,7 +576,9 @@ class NSFWChannelRequired(CheckFailure):
     """
     def __init__(self, channel):
         self.channel = channel
-        super().__init__("Channel '{}' needs to be NSFW for this command to work.".format(channel))
+        super().__init__(
+            f"Channel '{channel}' needs to be NSFW for this command to work."
+        )
 
 class MissingPermissions(CheckFailure):
     """Exception raised when the command invoker lacks permissions to run a
@@ -593,10 +597,10 @@ def __init__(self, missing_perms, *args):
         missing = [perm.replace('_', ' ').replace('guild', 'server').title() for perm in missing_perms]
 
         if len(missing) > 2:
-            fmt = '{}, and {}'.format(", ".join(missing[:-1]), missing[-1])
+            fmt = f'{", ".join(missing[:-1])}, and {missing[-1]}'
         else:
             fmt = ' and '.join(missing)
-        message = 'You are missing {} permission(s) to run this command.'.format(fmt)
+        message = f'You are missing {fmt} permission(s) to run this command.'
         super().__init__(message, *args)
 
 class BotMissingPermissions(CheckFailure):
@@ -616,10 +620,10 @@ def __init__(self, missing_perms, *args):
         missing = [perm.replace('_', ' ').replace('guild', 'server').title() for perm in missing_perms]
 
         if len(missing) > 2:
-            fmt = '{}, and {}'.format(", ".join(missing[:-1]), missing[-1])
+            fmt = f'{", ".join(missing[:-1])}, and {missing[-1]}'
         else:
             fmt = ' and '.join(missing)
-        message = 'Bot requires {} permission(s) to run this command.'.format(fmt)
+        message = f'Bot requires {fmt} permission(s) to run this command.'
         super().__init__(message, *args)
 
 class BadUnionArgument(UserInputError):
@@ -708,7 +712,7 @@ class ExpectedClosingQuoteError(ArgumentParsingError):
 
     def __init__(self, close_quote):
         self.close_quote = close_quote
-        super().__init__('Expected closing {}.'.format(close_quote))
+        super().__init__(f'Expected closing {close_quote}.')
 
 class ExtensionError(DiscordException):
     """Base exception for extension related errors.
@@ -808,4 +812,6 @@ def __init__(self, name, *, alias_conflict=False):
         self.name = name
         self.alias_conflict = alias_conflict
         type_ = 'alias' if alias_conflict else 'command'
-        super().__init__('The {} {} is already an existing command or alias.'.format(type_, name))
+        super().__init__(
+            f'The {type_} {name} is already an existing command or alias.'
+        )
diff --git a/discord/ext/commands/help.py b/discord/ext/commands/help.py
index f3324686..49c9fe75 100644
--- a/discord/ext/commands/help.py
+++ b/discord/ext/commands/help.py
@@ -132,7 +132,7 @@ def add_line(self, line='', *, empty=False):
         """
         max_page_size = self.max_size - self._prefix_len - self._suffix_len - 2 * self._linesep_len
         if len(line) > max_page_size:
-            raise RuntimeError('Line exceeds maximum page size %s' % (max_page_size))
+            raise RuntimeError(f'Line exceeds maximum page size {max_page_size}')
 
         if self._count + len(line) + self._linesep_len > self.max_size - self._suffix_len:
             self.close_page()
@@ -190,11 +190,11 @@ async def prepare(self, ctx):
 
         on_error = injected.on_help_command_error
         if not hasattr(on_error, '__help_command_not_overriden__'):
-            if self.cog is not None:
-                self.on_error = self._on_error_cog_implementation
-            else:
+            if self.cog is None:
                 self.on_error = on_error
 
+            else:
+                self.on_error = self._on_error_cog_implementation
         await super().prepare(ctx)
 
     async def _parse_arguments(self, ctx):
@@ -386,7 +386,7 @@ def clean_prefix(self):
         # consider this to be an *incredibly* strange use case. I'd rather go
         # for this common use case rather than waste performance for the
         # odd one.
-        pattern = re.compile(r"<@!?%s>" % user.id)
+        pattern = re.compile(f"<@!?{user.id}>")
         return pattern.sub("@%s" % user.display_name.replace('\\', r'\\'), self.context.prefix)
 
     @property
@@ -430,20 +430,20 @@ def get_command_signature(self, command):
             if not parent.signature or parent.invoke_without_command:
                 entries.append(parent.name)
             else:
-                entries.append(parent.name + ' ' + parent.signature)
+                entries.append(f'{parent.name} {parent.signature}')
             parent = parent.parent
         parent_sig = ' '.join(reversed(entries))
 
         if len(command.aliases) > 0:
             aliases = '|'.join(command.aliases)
-            fmt = '[%s|%s]' % (command.name, aliases)
+            fmt = f'[{command.name}|{aliases}]'
             if parent_sig:
-                fmt = parent_sig + ' ' + fmt
+                fmt = f'{parent_sig} {fmt}'
             alias = fmt
         else:
-            alias = command.name if not parent_sig else parent_sig + ' ' + command.name
+            alias = command.name if not parent_sig else f'{parent_sig} {command.name}'
 
-        return '%s%s %s' % (self.clean_prefix, alias, command.signature)
+        return f'{self.clean_prefix}{alias} {command.signature}'
 
     def remove_mentions(self, string):
         """Removes mentions from the string to prevent abuse.
@@ -506,7 +506,7 @@ def command_not_found(self, string):
         :class:`str`
             The string to use when a command has not been found.
         """
-        return 'No command called "{}" found.'.format(string)
+        return f'No command called "{string}" found.'
 
     def subcommand_not_found(self, command, string):
         """|maybecoro|
@@ -934,9 +934,7 @@ def __init__(self, **options):
 
     def shorten_text(self, text):
         """:class:`str`: Shortens text to fit into the :attr:`width`."""
-        if len(text) > self.width:
-            return text[:self.width - 3] + '...'
-        return text
+        return f'{text[:self.width - 3]}...' if len(text) > self.width else text
 
     def get_ending_note(self):
         """:class:`str`: Returns help command's ending note. This is mainly useful to override for i18n purposes."""
@@ -1033,7 +1031,7 @@ async def send_bot_help(self, mapping):
         no_category = '\u200b{0.no_category}:'.format(self)
         def get_category(command, *, no_category=no_category):
             cog = command.cog
-            return cog.qualified_name + ':' if cog is not None else no_category
+            return f'{cog.qualified_name}:' if cog is not None else no_category
 
         filtered = await self.filter_commands(bot.commands, sort=True, key=get_category)
         max_size = self.get_max_size(filtered)
@@ -1063,8 +1061,7 @@ async def send_group_help(self, group):
         self.add_indented_commands(filtered, heading=self.commands_heading)
 
         if filtered:
-            note = self.get_ending_note()
-            if note:
+            if note := self.get_ending_note():
                 self.paginator.add_line()
                 self.paginator.add_line(note)
 
@@ -1077,8 +1074,7 @@ async def send_cog_help(self, cog):
         filtered = await self.filter_commands(cog.get_commands(), sort=self.sort_commands)
         self.add_indented_commands(filtered, heading=self.commands_heading)
 
-        note = self.get_ending_note()
-        if note:
+        if note := self.get_ending_note():
             self.paginator.add_line()
             self.paginator.add_line(note)
 
@@ -1154,7 +1150,7 @@ def get_opening_note(self):
                "You can also use `{0}{1} [category]` for more info on a category.".format(self.clean_prefix, command_name)
 
     def get_command_signature(self, command):
-        return '%s%s %s' % (self.clean_prefix, command.qualified_name, command.signature)
+        return f'{self.clean_prefix}{command.qualified_name} {command.signature}'
 
     def get_ending_note(self):
         """Return the help command's ending note. This is mainly useful to override for i18n purposes.
@@ -1186,7 +1182,7 @@ def add_bot_commands_formatting(self, commands, heading):
         if commands:
             # U+2002 Middle Dot
             joined = '\u2002'.join(c.name for c in commands)
-            self.paginator.add_line('__**%s**__' % heading)
+            self.paginator.add_line(f'__**{heading}**__')
             self.paginator.add_line(joined)
 
     def add_subcommand_formatting(self, command):
@@ -1220,7 +1216,9 @@ def add_aliases_formatting(self, aliases):
         aliases: Sequence[:class:`str`]
             A list of aliases to format.
         """
-        self.paginator.add_line('**%s** %s' % (self.aliases_heading, ', '.join(aliases)), empty=True)
+        self.paginator.add_line(
+            f"**{self.aliases_heading}** {', '.join(aliases)}", empty=True
+        )
 
     def add_command_formatting(self, command):
         """A utility function to format commands and groups.
@@ -1297,8 +1295,7 @@ async def send_cog_help(self, cog):
         if bot.description:
             self.paginator.add_line(bot.description, empty=True)
 
-        note = self.get_opening_note()
-        if note:
+        if note := self.get_opening_note():
             self.paginator.add_line(note, empty=True)
 
         if cog.description:
@@ -1306,12 +1303,11 @@ async def send_cog_help(self, cog):
 
         filtered = await self.filter_commands(cog.get_commands(), sort=self.sort_commands)
         if filtered:
-            self.paginator.add_line('**%s %s**' % (cog.qualified_name, self.commands_heading))
+            self.paginator.add_line(f'**{cog.qualified_name} {self.commands_heading}**')
             for command in filtered:
                 self.add_subcommand_formatting(command)
 
-            note = self.get_ending_note()
-            if note:
+            if note := self.get_ending_note():
                 self.paginator.add_line()
                 self.paginator.add_line(note)
 
@@ -1322,16 +1318,14 @@ async def send_group_help(self, group):
 
         filtered = await self.filter_commands(group.commands, sort=self.sort_commands)
         if filtered:
-            note = self.get_opening_note()
-            if note:
+            if note := self.get_opening_note():
                 self.paginator.add_line(note, empty=True)
 
-            self.paginator.add_line('**%s**' % self.commands_heading)
+            self.paginator.add_line(f'**{self.commands_heading}**')
             for command in filtered:
                 self.add_subcommand_formatting(command)
 
-            note = self.get_ending_note()
-            if note:
+            if note := self.get_ending_note():
                 self.paginator.add_line()
                 self.paginator.add_line(note)
 
diff --git a/discord/ext/commands/view.py b/discord/ext/commands/view.py
index 7f74c700..7496f5fe 100644
--- a/discord/ext/commands/view.py
+++ b/discord/ext/commands/view.py
@@ -146,19 +146,20 @@ def get_quoted_word(self):
                 if is_quoted:
                     # unexpected EOF
                     raise ExpectedClosingQuoteError(close_quote)
-                return ''.join(result)
+                else:
+                    return ''.join(result)
 
             # currently we accept strings in the format of "hello world"
             # to embed a quote inside the string you must escape it: "a \"world\""
             if current == '\\':
                 next_char = self.get()
                 if not next_char:
-                    # string ends with \ and no character after it
                     if is_quoted:
                         # if we're quoted then we're expecting a closing quote
                         raise ExpectedClosingQuoteError(close_quote)
-                    # if we aren't then we just let it through
-                    return ''.join(result)
+                    else:
+                        # if we aren't then we just let it through
+                        return ''.join(result)
 
                 if next_char in _escaped_quotes:
                     # escaped quote
@@ -176,12 +177,12 @@ def get_quoted_word(self):
             # closing quote
             if is_quoted and current == close_quote:
                 next_char = self.get()
-                valid_eof = not next_char or next_char.isspace()
-                if not valid_eof:
-                    raise InvalidEndOfQuotedStringError(next_char)
+                if valid_eof := not next_char or next_char.isspace():
+                    # we're quoted so it's okay
+                    return ''.join(result)
 
-                # we're quoted so it's okay
-                return ''.join(result)
+                else:
+                    raise InvalidEndOfQuotedStringError(next_char)
 
             if current.isspace() and not is_quoted:
                 # end of word found
diff --git a/discord/ext/tasks/__init__.py b/discord/ext/tasks/__init__.py
index 6a8dcb19..44c3c874 100644
--- a/discord/ext/tasks/__init__.py
+++ b/discord/ext/tasks/__init__.py
@@ -76,7 +76,7 @@ def __init__(self, coro, seconds, hours, minutes, count, reconnect, loop):
             raise TypeError('Expected coroutine function, not {0.__name__!r}.'.format(type(self.coro)))
 
     async def _call_loop_function(self, name, *args, **kwargs):
-        coro = getattr(self, '_' + name)
+        coro = getattr(self, f'_{name}')
         if coro is None:
             return
 
diff --git a/discord/file.py b/discord/file.py
index 442931c3..e3896854 100644
--- a/discord/file.py
+++ b/discord/file.py
@@ -90,7 +90,7 @@ def __init__(self, fp, filename=None, *, spoiler=False):
             self.filename = filename
 
         if spoiler and self.filename is not None and not self.filename.startswith('SPOILER_'):
-            self.filename = 'SPOILER_' + self.filename
+            self.filename = f'SPOILER_{self.filename}'
 
         self.spoiler = spoiler or (self.filename is not None and self.filename.startswith('SPOILER_'))
 
diff --git a/discord/flags.py b/discord/flags.py
index 6940bc31..cc8875ad 100644
--- a/discord/flags.py
+++ b/discord/flags.py
@@ -42,9 +42,7 @@ def __init__(self, func):
         self.__doc__ = func.__doc__
 
     def __get__(self, instance, owner):
-        if instance is None:
-            return self
-        return instance._has_flag(self.flag)
+        return self if instance is None else instance._has_flag(self.flag)
 
     def __set__(self, instance, value):
         instance._set_flag(self.flag, value)
@@ -99,7 +97,7 @@ def __hash__(self):
         return hash(self.value)
 
     def __repr__(self):
-        return '<%s value=%s>' % (self.__class__.__name__, self.value)
+        return f'<{self.__class__.__name__} value={self.value}>'
 
     def __iter__(self):
         for name, value in self.__class__.__dict__.items():
@@ -118,7 +116,7 @@ def _set_flag(self, o, toggle):
         elif toggle is False:
             self.value &= ~o
         else:
-            raise TypeError('Value to set for %s must be a bool.' % self.__class__.__name__)
+            raise TypeError(f'Value to set for {self.__class__.__name__} must be a bool.')
 
 @fill_with_flags(inverted=True)
 class SystemChannelFlags(BaseFlags):
diff --git a/discord/gateway.py b/discord/gateway.py
index 210a8822..d2644597 100644
--- a/discord/gateway.py
+++ b/discord/gateway.py
@@ -78,9 +78,7 @@ def __init__(self, count=110, per=60.0):
 
     def is_ratelimited(self):
         current = time.time()
-        if current > self.window + self.per:
-            return False
-        return self.remaining == 0
+        return False if current > self.window + self.per else self.remaining == 0
 
     def get_delay(self):
         current = time.time()
@@ -102,8 +100,7 @@ def get_delay(self):
 
     async def block(self):
         async with self.lock:
-            delta = self.get_delay()
-            if delta:
+            if delta := self.get_delay():
                 log.warning('WebSocket in shard ID %s is ratelimited, waiting %.2f seconds', self.shard_id, delta)
                 await asyncio.sleep(delta)
 
@@ -760,7 +757,7 @@ async def identify(self):
     @classmethod
     async def from_client(cls, client, *, resume=False):
         """Creates a voice websocket for the :class:`VoiceClient`."""
-        gateway = 'wss://' + client.endpoint + '/?v=4'
+        gateway = f'wss://{client.endpoint}/?v=4'
         http = client._state.http
         socket = await http.ws_connect(gateway, compress=15)
         ws = cls(socket, loop=client.loop)
diff --git a/discord/guild.py b/discord/guild.py
index 51b11f35..a9b06d08 100644
--- a/discord/guild.py
+++ b/discord/guild.py
@@ -213,7 +213,7 @@ def __repr__(self):
         )
         resolved = ['%s=%r' % (attr, getattr(self, attr)) for attr in attrs]
         resolved.append('member_count=%r' % getattr(self, '_member_count', None))
-        return '<Guild %s>' % ' '.join(resolved)
+        return f"<Guild {' '.join(resolved)}>"
 
     def _update_voice_state(self, data, channel_id):
         user_id = int(data['user_id'])
@@ -582,10 +582,14 @@ def premium_subscriber_role(self):
 
         .. versionadded:: 1.6
         """
-        for role in self._roles.values():
-            if role.is_premium_subscriber():
-                return role
-        return None
+        return next(
+            (
+                role
+                for role in self._roles.values()
+                if role.is_premium_subscriber()
+            ),
+            None,
+        )
 
     @property
     def self_role(self):
@@ -763,17 +767,13 @@ def chunked(self):
         offline members.
         """
         count = getattr(self, '_member_count', None)
-        if count is None:
-            return False
-        return count == len(self._members)
+        return False if count is None else count == len(self._members)
 
     @property
     def shard_id(self):
         """:class:`int`: Returns the shard ID for this guild if applicable."""
         count = self._state.shard_count
-        if count is None:
-            return None
-        return (self.id >> 22) % count
+        return None if count is None else (self.id >> 22) % count
 
     @property
     def created_at(self):
@@ -841,14 +841,10 @@ def _create_channel(self, name, overwrites, channel_type, category=None, **optio
             payload = {
                 'allow': allow.value,
                 'deny': deny.value,
-                'id': target.id
+                'id': target.id,
+                'type': 'role' if isinstance(target, Role) else 'member',
             }
 
-            if isinstance(target, Role):
-                payload['type'] = 'role'
-            else:
-                payload['type'] = 'member'
-
             perms.append(payload)
 
         try:
@@ -1172,11 +1168,7 @@ async def edit(self, *, reason=None, **fields):
         except KeyError:
             icon = self.icon
         else:
-            if icon_bytes is not None:
-                icon = utils._bytes_to_base64_data(icon_bytes)
-            else:
-                icon = None
-
+            icon = None if icon_bytes is None else utils._bytes_to_base64_data(icon_bytes)
         try:
             banner_bytes = fields['banner']
         except KeyError:
@@ -1900,10 +1892,7 @@ async def create_role(self, *, reason=None, **fields):
                 raise InvalidArgument('%r is not a valid field.' % key)
 
         data = await self._state.http.create_role(self.id, reason=reason, **fields)
-        role = Role(guild=self, data=data, state=self._state)
-
-        # TODO: add to cache
-        return role
+        return Role(guild=self, data=data, state=self._state)
 
     async def edit_role_positions(self, positions, *, reason=None):
         """|coro|
diff --git a/discord/http.py b/discord/http.py
index 531d79a7..ea22b0a0 100644
--- a/discord/http.py
+++ b/discord/http.py
@@ -157,7 +157,9 @@ async def request(self, route, *, files=None, form=None, **kwargs):
         }
 
         if self.token is not None:
-            headers['Authorization'] = 'Bot ' + self.token if self.bot_token else self.token
+            headers['Authorization'] = (
+                f'Bot {self.token}' if self.bot_token else self.token
+            )
         # some checking if it's a JSON request
         if 'json' in kwargs:
             headers['Content-Type'] = 'application/json'
@@ -389,8 +391,6 @@ def send_typing(self, channel_id):
 
     def send_files(self, channel_id, *, files, content=None, tts=False, embeds=None, components=None, nonce=None, allowed_mentions=None, message_reference=None):
         r = Route('POST', '/channels/{channel_id}/messages', channel_id=channel_id)
-        form = []
-
         payload = {'tts': tts}
         if content:
             payload['content'] = content
@@ -405,7 +405,7 @@ def send_files(self, channel_id, *, files, content=None, tts=False, embeds=None,
         if message_reference:
             payload['message_reference'] = message_reference
 
-        form.append({'name': 'payload_json', 'value': utils.to_json(payload)})
+        form = [{'name': 'payload_json', 'value': utils.to_json(payload)}]
         if len(files) == 1:
             file = files[0]
             form.append({
@@ -415,14 +415,15 @@ def send_files(self, channel_id, *, files, content=None, tts=False, embeds=None,
                 'content_type': 'application/octet-stream'
             })
         else:
-            for index, file in enumerate(files):
-                form.append({
-                    'name': 'file%s' % index,
+            form.extend(
+                {
+                    'name': f'file{index}',
                     'value': file.fp,
                     'filename': file.filename,
-                    'content_type': 'application/octet-stream'
-                })
-
+                    'content_type': 'application/octet-stream',
+                }
+                for index, file in enumerate(files)
+            )
         return self.request(r, form=form, files=files)
 
     async def ack_message(self, channel_id, message_id):
@@ -459,34 +460,32 @@ def edit_interaction_response(self, use_webhook, interaction_id, token, applicat
             r = Route('POST', f'/webhooks/{application_id}/{token}/callback' if use_webhook is True else f"/interactions/{interaction_id}/{token}/callback")
         else:
             r = Route('PATCH', f'/webhooks/{application_id}/{token}/messages/@original')
-        form = []
-        if files is not None:
-            form.append({'name': 'payload_json', 'value': utils.to_json(fields)})
-            if len(files) == 1:
-                file = files[0]
-                form.append({
-                    'name': 'file',
+        if files is None:
+            return self.request(r, json=fields)
+        form = [{'name': 'payload_json', 'value': utils.to_json(fields)}]
+        if len(files) == 1:
+            file = files[0]
+            form.append({
+                'name': 'file',
+                'value': file.fp,
+                'filename': file.filename,
+                'content_type': 'application/octet-stream'
+            })
+        else:
+            form.extend(
+                {
+                    'name': f'file{index}',
                     'value': file.fp,
                     'filename': file.filename,
-                    'content_type': 'application/octet-stream'
-                })
-            else:
-                for index, file in enumerate(files):
-                    form.append({
-                        'name': 'file%s' % index,
-                        'value': file.fp,
-                        'filename': file.filename,
-                        'content_type': 'application/octet-stream'
-                    })
-
-            return self.request(r, form=form, files=files)
-        else:
-            return self.request(r, json=fields)
+                    'content_type': 'application/octet-stream',
+                }
+                for index, file in enumerate(files)
+            )
+        return self.request(r, form=form, files=files)
 
     def send_interaction_response(self, use_webhook, interaction_id, token, application_id, deferred, followup,
                                   *, content=None, tts=False, embeds=None, components=None, files=None, nonce=None,
                                   allowed_mentions=None, message_reference=None, flags=None):
-        form = []
         payload = {'tts': tts}
         if content:
             payload['content'] = content
@@ -507,28 +506,28 @@ def send_interaction_response(self, use_webhook, interaction_id, token, applicat
             r = Route('POST', f'/webhooks/{application_id}/{token}/callback' if use_webhook is True else f"/interactions/{interaction_id}/{token}/callback")
         else:
             r = Route('POST', f'/webhooks/{application_id}/{token}')
-        if files is not None:
-            form.append({'name': 'payload_json', 'value': utils.to_json(payload)})
-            if len(files) == 1:
-                file = files[0]
-                form.append({
-                    'name': 'file',
+        if files is None:
+            return self.request(r, json=payload)
+        form = [{'name': 'payload_json', 'value': utils.to_json(payload)}]
+        if len(files) == 1:
+            file = files[0]
+            form.append({
+                'name': 'file',
+                'value': file.fp,
+                'filename': file.filename,
+                'content_type': 'application/octet-stream'
+            })
+        else:
+            form.extend(
+                {
+                    'name': f'file{index}',
                     'value': file.fp,
                     'filename': file.filename,
-                    'content_type': 'application/octet-stream'
-                })
-            else:
-                for index, file in enumerate(files):
-                    form.append({
-                        'name': 'file%s' % index,
-                        'value': file.fp,
-                        'filename': file.filename,
-                        'content_type': 'application/octet-stream'
-                    })
-
-            return self.request(r, form=form, files=files)
-        else:
-            return self.request(r, json=payload)
+                    'content_type': 'application/octet-stream',
+                }
+                for index, file in enumerate(files)
+            )
+        return self.request(r, form=form, files=files)
 
     def get_original_interaction_response(self, interaction_token, application_id):
         r = Route('GET', f'/webhooks/{application_id}/{interaction_token}/messages/@original')
@@ -701,17 +700,12 @@ def bulk_channel_update(self, guild_id, data, *, reason=None):
         return self.request(r, json=data, reason=reason)
 
     def create_channel(self, guild_id, channel_type, *, reason=None, **options):
-        payload = {
-            'type': channel_type
-        }
-
         valid_keys = ('name', 'parent_id', 'topic', 'bitrate', 'nsfw',
                       'user_limit', 'position', 'permission_overwrites', 'rate_limit_per_user',
                       'rtc_region')
-        payload.update({
+        payload = {'type': channel_type} | {
             k: v for k, v in options.items() if k in valid_keys and v is not None
-        })
-
+        }
         return self.request(Route('POST', '/guilds/{guild_id}/channels', guild_id=guild_id), json=payload, reason=reason)
 
     def delete_channel(self, channel_id, *, reason=None):
diff --git a/discord/interactions.py b/discord/interactions.py
index 31a98c9f..5a925b83 100644
--- a/discord/interactions.py
+++ b/discord/interactions.py
@@ -40,7 +40,7 @@ def __hash__(self):
         return self.__hash__
 
     def __repr__(self):
-        return f"<ButtonClick custom_id={self.custom_id}{', hash='+self.__hash__ if self.__hash__ else ''}>"
+        return f"<ButtonClick custom_id={self.custom_id}{f', hash={self.__hash__}' if self.__hash__ else ''}>"
 
 
 class SelectionSelect:
@@ -95,7 +95,7 @@ def __init__(self, state, data):
 
     def __repr__(self):
         """Represents a :class:`discord.Interaction`-object."""
-        return f'<Interaction {", ".join(["%s=%s" % (a, getattr(self, a)) for a in self.__slots__ if a[0] != "_"])}>'
+        return f'<Interaction {", ".join([f"{a}={getattr(self, a)}" for a in self.__slots__ if a[0] != "_"])}>'
 
     async def defer(self, response_type: Literal[5, 6] = InteractionCallbackType.deferred_update_msg, hidden: bool = False) -> None:
         """
@@ -129,7 +129,9 @@ async def defer(self, response_type: Literal[5, 6] = InteractionCallbackType.def
         if isinstance(response_type, int):
             response_type = InteractionCallbackType.from_value(response_type)
         if response_type not in (InteractionCallbackType.deferred_msg_with_source, InteractionCallbackType.deferred_update_msg):
-            raise ValueError('response_type has to bee discord.InteractionCallbackType.deferred_msg_with_source or discord.InteractionCallbackType.deferred_update_msg (e.g. 5 or 6), not %s.__class__.__name__' % response_type)
+            raise ValueError(
+                f'response_type has to bee discord.InteractionCallbackType.deferred_msg_with_source or discord.InteractionCallbackType.deferred_update_msg (e.g. 5 or 6), not {response_type}.__class__.__name__'
+            )
         if self.deferred:
             return log.warning("\033[91You have already responded to this Interaction!\033[0m")
         base = {"type": response_type.value, "data": {'flags': 64 if hidden else None}}
@@ -140,7 +142,11 @@ async def defer(self, response_type: Literal[5, 6] = InteractionCallbackType.def
             log.warning(f'Unknown Interaction {self.__interaction_id}')
         else:
             self.deferred = True
-            if hidden is True and response_type is InteractionCallbackType.deferred_msg_with_source:
+            if (
+                hidden
+                and response_type
+                is InteractionCallbackType.deferred_msg_with_source
+            ):
                 self.deferred_hidden = True
             return data
 
@@ -151,9 +157,15 @@ async def edit(self, **fields) -> Message:
         """
         if not self.channel:
             self._channel = self._state.add_dm_channel(data=await self._http.get_channel(self.channel_id))
-        await self.message.edit(__is_interaction_response=True, __deferred=False if (not self.deferred or self.callback_message) else True, __use_webhook=False,
-                                __interaction_id=self.__interaction_id, __interaction_token=self.__token,
-                                __application_id=self.__application_id, **fields)
+        await self.message.edit(
+            __is_interaction_response=True,
+            __deferred=bool(self.deferred and not self.callback_message),
+            __use_webhook=False,
+            __interaction_id=self.__interaction_id,
+            __interaction_token=self.__token,
+            __application_id=self.__application_id,
+            **fields
+        )
         self.deferred = True
         return self.message
 
@@ -168,13 +180,28 @@ async def respond(self, content=None, *, tts=False, embed=None, embeds=None, com
         """
         if not self.channel:
             self._channel = self._state.add_dm_channel(data=await self._http.get_channel(self.channel_id))
-        msg = await self.channel.send(content, tts=tts, embed=embed, embeds=embeds, components=components, file=file,
-                                      files=files, delete_after=delete_after, nonce=nonce,
-                                      allowed_mentions=allowed_mentions, reference=reference,
-                                      mention_author=mention_author, hidden=hidden, __is_interaction_response=True,
-                                      __deferred=self.deferred, __use_webhook=False, __interaction_id=self.__interaction_id,
-                                      __interaction_token=self.__token, __application_id=self.__application_id,
-                                      followup=True if self.callback_message else False)
+        msg = await self.channel.send(
+            content,
+            tts=tts,
+            embed=embed,
+            embeds=embeds,
+            components=components,
+            file=file,
+            files=files,
+            delete_after=delete_after,
+            nonce=nonce,
+            allowed_mentions=allowed_mentions,
+            reference=reference,
+            mention_author=mention_author,
+            hidden=hidden,
+            __is_interaction_response=True,
+            __deferred=self.deferred,
+            __use_webhook=False,
+            __interaction_id=self.__interaction_id,
+            __interaction_token=self.__token,
+            __application_id=self.__application_id,
+            followup=bool(self.callback_message),
+        )
 
         if hidden is True:
             self.deferred_hidden = True
diff --git a/discord/invite.py b/discord/invite.py
index a1d794b0..6e3283bc 100644
--- a/discord/invite.py
+++ b/discord/invite.py
@@ -80,7 +80,7 @@ def __repr__(self):
     @property
     def mention(self):
         """:class:`str`: The string that allows you to mention the channel."""
-        return '<#%s>' % self.id
+        return f'<#{self.id}>'
 
     @property
     def created_at(self):
@@ -372,7 +372,7 @@ def id(self):
     @property
     def url(self):
         """:class:`str`: A property that retrieves the invite URL."""
-        return self.BASE + '/' + self.code
+        return f'{self.BASE}/{self.code}'
 
     async def delete(self, *, reason=None):
         """|coro|
diff --git a/discord/iterators.py b/discord/iterators.py
index d18437ca..0b74e7ec 100644
--- a/discord/iterators.py
+++ b/discord/iterators.py
@@ -173,7 +173,7 @@ async def fill_users(self):
         from .user import User
 
         if self.limit > 0:
-            retrieve = self.limit if self.limit <= 100 else 100
+            retrieve = min(self.limit, 100)
 
             after = self.after.id if self.after else None
             data = await self.getter(self.channel_id, self.message.id, self.emoji, retrieve, after=after)
@@ -238,11 +238,7 @@ def __init__(self, messageable, limit,
         if isinstance(around, datetime.datetime):
             around = Object(id=time_snowflake(around))
 
-        if oldest_first is None:
-            self.reverse = after is not None
-        else:
-            self.reverse = oldest_first
-
+        self.reverse = after is not None if oldest_first is None else oldest_first
         self.messageable = messageable
         self.limit = limit
         self.before = before
@@ -270,15 +266,14 @@ def __init__(self, messageable, limit,
                 self._filter = lambda m: int(m['id']) < self.before.id
             elif self.after:
                 self._filter = lambda m: self.after.id < int(m['id'])
+        elif self.reverse:
+            self._retrieve_messages = self._retrieve_messages_after_strategy
+            if (self.before):
+                self._filter = lambda m: int(m['id']) < self.before.id
         else:
-            if self.reverse:
-                self._retrieve_messages = self._retrieve_messages_after_strategy
-                if (self.before):
-                    self._filter = lambda m: int(m['id']) < self.before.id
-            else:
-                self._retrieve_messages = self._retrieve_messages_before_strategy
-                if (self.after and self.after != OLDEST_OBJECT):
-                    self._filter = lambda m: int(m['id']) > self.after.id
+            self._retrieve_messages = self._retrieve_messages_before_strategy
+            if (self.after and self.after != OLDEST_OBJECT):
+                self._filter = lambda m: int(m['id']) > self.after.id
 
     async def next(self):
         if self.messages.empty():
@@ -291,10 +286,7 @@ async def next(self):
 
     def _get_retrieve(self):
         l = self.limit
-        if l is None or l > 100:
-            r = 100
-        else:
-            r = l
+        r = 100 if l is None or l > 100 else l
         self.retrieve = r
         return r > 0
 
@@ -314,8 +306,10 @@ async def flatten(self):
             if self._filter:
                 data = filter(self._filter, data)
 
-            for element in data:
-                result.append(self.state.create_message(channel=channel, data=element))
+            result.extend(
+                self.state.create_message(channel=channel, data=element)
+                for element in data
+            )
         return result
 
     async def fill_messages(self):
@@ -379,11 +373,7 @@ def __init__(self, guild, limit=None, before=None, after=None, oldest_first=None
             after = Object(id=time_snowflake(after, high=True))
 
 
-        if oldest_first is None:
-            self.reverse = after is not None
-        else:
-            self.reverse = oldest_first
-
+        self.reverse = after is not None if oldest_first is None else oldest_first
         self.guild = guild
         self.loop = guild._state.loop
         self.request = guild._state.http.get_audit_logs
@@ -444,10 +434,7 @@ async def next(self):
 
     def _get_retrieve(self):
         l = self.limit
-        if l is None or l > 100:
-            r = 100
-        else:
-            r = l
+        r = 100 if l is None or l > 100 else l
         self.retrieve = r
         return r > 0
 
@@ -541,10 +528,7 @@ async def next(self):
 
     def _get_retrieve(self):
         l = self.limit
-        if l is None or l > 100:
-            r = 100
-        else:
-            r = l
+        r = 100 if l is None or l > 100 else l
         self.retrieve = r
         return r > 0
 
@@ -562,8 +546,7 @@ async def flatten(self):
             if self._filter:
                 data = filter(self._filter, data)
 
-            for element in data:
-                result.append(self.create_guild(element))
+            result.extend(self.create_guild(element) for element in data)
         return result
 
     async def fill_guilds(self):
@@ -627,28 +610,26 @@ async def next(self):
 
     def _get_retrieve(self):
         l = self.limit
-        if l is None or l > 1000:
-            r = 1000
-        else:
-            r = l
+        r = 1000 if l is None or l > 1000 else l
         self.retrieve = r
         return r > 0
 
     async def fill_members(self):
-        if self._get_retrieve():
-            after = self.after.id if self.after else None
-            data = await self.get_members(self.guild.id, self.retrieve, after)
-            if not data:
-                # no data, terminate
-                return
+        if not self._get_retrieve():
+            return
+        after = self.after.id if self.after else None
+        data = await self.get_members(self.guild.id, self.retrieve, after)
+        if not data:
+            # no data, terminate
+            return
 
-            if len(data) < 1000:
-                self.limit = 0 # terminate loop
+        if len(data) < 1000:
+            self.limit = 0 # terminate loop
 
-            self.after = Object(id=int(data[-1]['user']['id']))
+        self.after = Object(id=int(data[-1]['user']['id']))
 
-            for element in reversed(data):
-                await self.members.put(self.create_member(element))
+        for element in reversed(data):
+            await self.members.put(self.create_member(element))
 
     def create_member(self, data):
         from .member import Member
diff --git a/discord/member.py b/discord/member.py
index 102586f3..dcbca1c6 100644
--- a/discord/member.py
+++ b/discord/member.py
@@ -112,7 +112,7 @@ def __repr__(self):
             ('requested_to_speak_at', self.requested_to_speak_at),
             ('channel', self.channel)
         ]
-        return '<%s %s>' % (self.__class__.__name__, ' '.join('%s=%r' % t for t in attrs))
+        return f"<{self.__class__.__name__} {' '.join('%s=%r' % t for t in attrs)}>"
 
 def flatten_user(cls):
     for attr, value in itertools.chain(BaseUser.__dict__.items(), User.__dict__.items()):
@@ -127,8 +127,8 @@ def flatten_user(cls):
         # if it's a slotted attribute or a property, redirect it
         # slotted members are implemented as member_descriptors in Type.__dict__
         if not hasattr(value, '__annotations__'):
-            getter = attrgetter('_user.' + attr)
-            setattr(cls, attr, property(getter, doc='Equivalent to :attr:`User.%s`' % attr))
+            getter = attrgetter(f'_user.{attr}')
+            setattr(cls, attr, property(getter, doc=f'Equivalent to :attr:`User.{attr}`'))
         else:
             # Technically, this can also use attrgetter
             # However I'm not sure how I feel about "functions" returning properties
@@ -295,8 +295,7 @@ def _copy(cls, member):
         return self
 
     async def _get_channel(self):
-        ch = await self.create_dm()
-        return ch
+        return await self.create_dm()
 
     def _update_roles(self, data):
         self._roles = utils.SnowflakeList(map(int, data['roles']))
@@ -325,9 +324,7 @@ def _presence_update(self, data, user):
         }
         self._client_status[None] = sys.intern(data['status'])
 
-        if len(user) > 1:
-            return self._update_inner_user(user)
-        return False
+        return self._update_inner_user(user) if len(user) > 1 else False
 
     def _update_inner_user(self, user):
         u = self._user
@@ -417,8 +414,7 @@ def roles(self):
         result = []
         g = self.guild
         for role_id in self._roles:
-            role = g.get_role(role_id)
-            if role:
+            if role := g.get_role(role_id):
                 result.append(role)
         result.append(g.default_role)
         result.sort()
@@ -427,9 +423,7 @@ def roles(self):
     @property
     def mention(self):
         """:class:`str`: Returns a string that allows you to mention the member."""
-        if self.nick:
-            return '<@!%s>' % self.id
-        return '<@%s>' % self.id
+        return f'<@!{self.id}>' if self.nick else f'<@{self.id}>'
 
     @property
     def display_name(self):
@@ -535,10 +529,7 @@ def guild_permissions(self):
         for r in self.roles:
             base.value |= r.permissions.value
 
-        if base.administrator:
-            return Permissions.all()
-
-        return base
+        return Permissions.all() if base.administrator else base
 
     @property
     def voice(self):
diff --git a/discord/message.py b/discord/message.py
index 8f31878b..1685b70e 100644
--- a/discord/message.py
+++ b/discord/message.py
@@ -62,7 +62,7 @@ def convert_emoji_reaction(emoji):
         emoji = emoji.emoji
 
     if isinstance(emoji, Emoji):
-        return '%s:%s' % (emoji.name, emoji.id)
+        return f'{emoji.name}:{emoji.id}'
     if isinstance(emoji, PartialEmoji):
         return emoji._as_reaction()
     if isinstance(emoji, str):
@@ -222,8 +222,7 @@ async def read(self, *, use_cached=False):
             The contents of the attachment.
         """
         url = self.proxy_url if use_cached else self.url
-        data = await self._http.get_from_cdn(url)
-        return data
+        return await self._http.get_from_cdn(url)
 
     async def to_file(self, *, use_cached=False, spoiler=False):
         """|coro|
@@ -597,7 +596,7 @@ def __init__(self, *, state, channel, data):
 
         for handler in ('author', 'member', 'mentions', 'mention_roles', 'call', 'flags'):
             try:
-                getattr(self, '_handle_%s' % handler)(data[handler])
+                getattr(self, f'_handle_{handler}')(data[handler])
             except KeyError:
                 continue
 
@@ -848,18 +847,18 @@ def clean_content(self):
         """
 
         transformations = {
-            re.escape('<#%s>' % channel.id): '#' + channel.name
+            re.escape(f'<#{channel.id}>'): f'#{channel.name}'
             for channel in self.channel_mentions
         }
 
         mention_transforms = {
-            re.escape('<@%s>' % member.id): '@' + member.display_name
+            re.escape(f'<@{member.id}>'): f'@{member.display_name}'
             for member in self.mentions
         }
 
         # add the <@!user_id> cases as well..
         second_mention_transforms = {
-            re.escape('<@!%s>' % member.id): '@' + member.display_name
+            re.escape(f'<@!{member.id}>'): f'@{member.display_name}'
             for member in self.mentions
         }
 
@@ -868,7 +867,7 @@ def clean_content(self):
 
         if self.guild is not None:
             role_transforms = {
-                re.escape('<@&%s>' % role.id): '@' + role.name
+                re.escape(f'<@&{role.id}>'): f'@{role.name}'
                 for role in self.role_mentions
             }
             transformations.update(role_transforms)
@@ -1001,8 +1000,7 @@ def system_content(self):
     def all_components(self):
         """Returns all :class:`Button`'s and :class:`SelectMenu`'s that are contained in the message"""
         for action_row in self.components:
-            for component in action_row:
-                yield component
+            yield from action_row
 
     @property
     def all_buttons(self):
@@ -1604,8 +1602,7 @@ async def fetch(self):
     def all_components(self):
         """Returns all :class:`Button`'s and :class:`SelectMenu`'s that are contained in the message"""
         for action_row in self.components:
-            for component in action_row:
-                yield component
+            yield from action_row
 
     @property
     def all_buttons(self):
diff --git a/discord/mixins.py b/discord/mixins.py
index afdbc1d0..3cf9f8fd 100644
--- a/discord/mixins.py
+++ b/discord/mixins.py
@@ -31,9 +31,7 @@ def __eq__(self, other):
         return isinstance(other, self.__class__) and other.id == self.id
 
     def __ne__(self, other):
-        if isinstance(other, self.__class__):
-            return other.id != self.id
-        return True
+        return other.id != self.id if isinstance(other, self.__class__) else True
 
 class Hashable(EqualityComparable):
     __slots__ = ()
diff --git a/discord/oggparse.py b/discord/oggparse.py
index a7b9dcd7..f5894554 100644
--- a/discord/oggparse.py
+++ b/discord/oggparse.py
@@ -83,10 +83,8 @@ def _next_page(self):
             raise OggError('invalid header magic')
 
     def _iter_pages(self):
-        page = self._next_page()
-        while page:
+        while page := self._next_page():
             yield page
-            page = self._next_page()
 
     def iter_packets(self):
         partial = b''
diff --git a/discord/opus.py b/discord/opus.py
index 94adf338..bdfdbfef 100644
--- a/discord/opus.py
+++ b/discord/opus.py
@@ -185,7 +185,7 @@ def _load_default():
             _basedir = os.path.dirname(os.path.abspath(__file__))
             _bitness = struct.calcsize('P') * 8
             _target = 'x64' if _bitness > 32 else 'x86'
-            _filename = os.path.join(_basedir, 'bin', 'libopus-0.{}.dll'.format(_target))
+            _filename = os.path.join(_basedir, 'bin', f'libopus-0.{_target}.dll')
             _lib = libopus_loader(_filename)
         else:
             _lib = libopus_loader(ctypes.util.find_library('opus'))
diff --git a/discord/partial_emoji.py b/discord/partial_emoji.py
index 91f85532..07c40212 100644
--- a/discord/partial_emoji.py
+++ b/discord/partial_emoji.py
@@ -86,9 +86,8 @@ def from_string(cls, string: str):
             You can then use what comes out when you add a reaction or similar.
         """
 
-        match = re.match('^<(a?):([\-\w]+):(\d+)>$', string)
-        if match:
-            return cls(animated=bool(match.group(1)), name=match.group(2), id=int(match.group(3)))
+        if match := re.match('^<(a?):([\-\w]+):(\d+)>$', string):
+            return cls(animated=bool(match[1]), name=match[2], id=int(match[3]))
         raise ValueError('The Passed Emoji is not a discord custom-emoji.')
 
     @classmethod
@@ -117,8 +116,8 @@ def __str__(self):
         if self.id is None:
             return self.name
         if self.animated:
-            return '<a:%s:%s>' % (self.name, self.id)
-        return '<:%s:%s>' % (self.name, self.id)
+            return f'<a:{self.name}:{self.id}>'
+        return f'<:{self.name}:{self.id}>'
 
     def __repr__(self):
         return '<{0.__class__.__name__} animated={0.animated} name={0.name!r} id={0.id}>'.format(self)
@@ -127,9 +126,7 @@ def __eq__(self, other):
         if self.is_unicode_emoji():
             return isinstance(other, PartialEmoji) and self.name == other.name
 
-        if isinstance(other, _EmojiTag):
-            return self.id == other.id
-        return False
+        return self.id == other.id if isinstance(other, _EmojiTag) else False
 
     def __ne__(self, other):
         return not self.__eq__(other)
@@ -146,9 +143,7 @@ def is_unicode_emoji(self):
         return self.id is None
 
     def _as_reaction(self):
-        if self.id is None:
-            return self.name
-        return '%s:%s' % (self.name, self.id)
+        return self.name if self.id is None else f'{self.name}:{self.id}'
 
     @property
     def created_at(self):
@@ -156,10 +151,7 @@ def created_at(self):
 
         .. versionadded:: 1.6
         """
-        if self.is_unicode_emoji():
-            return None
-
-        return utils.snowflake_time(self.id)
+        return None if self.is_unicode_emoji() else utils.snowflake_time(self.id)
 
     @property
     def url(self):
diff --git a/discord/permissions.py b/discord/permissions.py
index 3fd0dacf..d23ae999 100644
--- a/discord/permissions.py
+++ b/discord/permissions.py
@@ -96,7 +96,9 @@ class Permissions(BaseFlags):
 
     def __init__(self, permissions=0, **kwargs):
         if not isinstance(permissions, int):
-            raise TypeError('Expected int parameter, received %s instead.' % permissions.__class__.__name__)
+            raise TypeError(
+                f'Expected int parameter, received {permissions.__class__.__name__} instead.'
+            )
 
         self.value = permissions
         for key, value in kwargs.items():
@@ -109,14 +111,18 @@ def is_subset(self, other):
         if isinstance(other, Permissions):
             return (self.value & other.value) == self.value
         else:
-            raise TypeError("cannot compare {} with {}".format(self.__class__.__name__, other.__class__.__name__))
+            raise TypeError(
+                f"cannot compare {self.__class__.__name__} with {other.__class__.__name__}"
+            )
 
     def is_superset(self, other):
         """Returns ``True`` if self has the same or more permissions as other."""
         if isinstance(other, Permissions):
             return (self.value | other.value) == self.value
         else:
-            raise TypeError("cannot compare {} with {}".format(self.__class__.__name__, other.__class__.__name__))
+            raise TypeError(
+                f"cannot compare {self.__class__.__name__} with {other.__class__.__name__}"
+            )
 
     def is_strict_subset(self, other):
         """Returns ``True`` if the permissions on other are a strict subset of those on self."""
diff --git a/discord/player.py b/discord/player.py
index 413e5de6..e0ec33f9 100644
--- a/discord/player.py
+++ b/discord/player.py
@@ -24,6 +24,7 @@
 DEALINGS IN THE SOFTWARE.
 """
 
+
 import threading
 import traceback
 import subprocess
@@ -51,10 +52,7 @@
     'PCMVolumeTransformer',
 )
 
-if sys.platform != 'win32':
-    CREATE_NO_WINDOW = 0
-else:
-    CREATE_NO_WINDOW = 0x08000000
+CREATE_NO_WINDOW = 0 if sys.platform != 'win32' else 0x08000000
 
 class AudioSource:
     """Represents an audio stream.
@@ -115,9 +113,7 @@ def __init__(self, stream):
 
     def read(self):
         ret = self.stream.read(OpusEncoder.FRAME_SIZE)
-        if len(ret) != OpusEncoder.FRAME_SIZE:
-            return b''
-        return ret
+        return b'' if len(ret) != OpusEncoder.FRAME_SIZE else ret
 
 class FFmpegAudio(AudioSource):
     """Represents an FFmpeg (or AVConv) based AudioSource.
@@ -132,9 +128,7 @@ def __init__(self, source, *, executable='ffmpeg', args, **subprocess_kwargs):
         self._process = self._stdout = None
 
         args = [executable, *args]
-        kwargs = {'stdout': subprocess.PIPE}
-        kwargs.update(subprocess_kwargs)
-
+        kwargs = {'stdout': subprocess.PIPE} | subprocess_kwargs
         self._process = self._spawn_process(args, **kwargs)
         self._stdout = self._process.stdout
 
@@ -144,7 +138,7 @@ def _spawn_process(self, args, **subprocess_kwargs):
             process = subprocess.Popen(args, creationflags=CREATE_NO_WINDOW, **subprocess_kwargs)
         except FileNotFoundError:
             executable = args.partition(' ')[0] if isinstance(args, str) else args[0]
-            raise ClientException(executable + ' was not found.') from None
+            raise ClientException(f'{executable} was not found.') from None
         except subprocess.SubprocessError as exc:
             raise ClientException('Popen failed: {0.__class__.__name__}: {0}'.format(exc)) from exc
         else:
@@ -213,10 +207,20 @@ def __init__(self, source, *, executable='ffmpeg', pipe=False, stderr=None, befo
         if isinstance(before_options, str):
             args.extend(shlex.split(before_options))
 
-        args.append('-i')
-        args.append('-' if pipe else source)
-        args.extend(('-f', 's16le', '-ar', '48000', '-ac', '2', '-loglevel', 'warning'))
-
+        args.extend(
+            (
+                '-i',
+                '-' if pipe else source,
+                '-f',
+                's16le',
+                '-ar',
+                '48000',
+                '-ac',
+                '2',
+                '-loglevel',
+                'warning',
+            )
+        )
         if isinstance(options, str):
             args.extend(shlex.split(options))
 
@@ -226,9 +230,7 @@ def __init__(self, source, *, executable='ffmpeg', pipe=False, stderr=None, befo
 
     def read(self):
         ret = self._stdout.read(OpusEncoder.FRAME_SIZE)
-        if len(ret) != OpusEncoder.FRAME_SIZE:
-            return b''
-        return ret
+        return b'' if len(ret) != OpusEncoder.FRAME_SIZE else ret
 
     def is_opus(self):
         return False
@@ -303,18 +305,27 @@ def __init__(self, source, *, bitrate=128, codec=None, executable='ffmpeg',
         if isinstance(before_options, str):
             args.extend(shlex.split(before_options))
 
-        args.append('-i')
-        args.append('-' if pipe else source)
-
+        args.extend(('-i', '-' if pipe else source))
         codec = 'copy' if codec in ('opus', 'libopus') else 'libopus'
 
-        args.extend(('-map_metadata', '-1',
-                     '-f', 'opus',
-                     '-c:a', codec,
-                     '-ar', '48000',
-                     '-ac', '2',
-                     '-b:a', '%sk' % bitrate,
-                     '-loglevel', 'warning'))
+        args.extend(
+            (
+                '-map_metadata',
+                '-1',
+                '-f',
+                'opus',
+                '-c:a',
+                codec,
+                '-ar',
+                '48000',
+                '-ac',
+                '2',
+                '-b:a',
+                f'{bitrate}k',
+                '-loglevel',
+                'warning',
+            )
+        )
 
         if isinstance(options, str):
             args.extend(shlex.split(options))
@@ -419,9 +430,9 @@ async def probe(cls, source, *, method=None, executable=None):
         probefunc = fallback = None
 
         if isinstance(method, str):
-            probefunc = getattr(cls, '_probe_codec_' + method, None)
+            probefunc = getattr(cls, f'_probe_codec_{method}', None)
             if probefunc is None:
-                raise AttributeError("Invalid probe method '%s'" % method)
+                raise AttributeError(f"Invalid probe method '{method}'")
 
             if probefunc is cls._probe_codec_native:
                 fallback = cls._probe_codec_fallback
@@ -431,7 +442,7 @@ async def probe(cls, source, *, method=None, executable=None):
             fallback = cls._probe_codec_fallback
         else:
             raise TypeError("Expected str or callable for parameter 'probe', " \
-                            "not '{0.__class__.__name__}'" .format(method))
+                                "not '{0.__class__.__name__}'" .format(method))
 
         codec = bitrate = None
         loop = asyncio.get_event_loop()
@@ -456,7 +467,11 @@ async def probe(cls, source, *, method=None, executable=None):
 
     @staticmethod
     def _probe_codec_native(source, executable='ffmpeg'):
-        exe = executable[:2] + 'probe' if executable in ('ffmpeg', 'avconv') else executable
+        exe = (
+            f'{executable[:2]}probe'
+            if executable in ('ffmpeg', 'avconv')
+            else executable
+        )
         args = [exe, '-v', 'quiet', '-print_format', 'json', '-show_streams', '-select_streams', 'a:0', source]
         output = subprocess.check_output(args, timeout=20)
         codec = bitrate = None
@@ -479,13 +494,11 @@ def _probe_codec_fallback(source, executable='ffmpeg'):
         output = out.decode('utf8')
         codec = bitrate = None
 
-        codec_match = re.search(r"Stream #0.*?Audio: (\w+)", output)
-        if codec_match:
-            codec = codec_match.group(1)
+        if codec_match := re.search(r"Stream #0.*?Audio: (\w+)", output):
+            codec = codec_match[1]
 
-        br_match = re.search(r"(\d+) [kK]b/s", output)
-        if br_match:
-            bitrate = max(int(br_match.group(1)), 512)
+        if br_match := re.search(r"(\d+) [kK]b/s", output):
+            bitrate = max(int(br_match[1]), 512)
 
         return codec, bitrate
 
@@ -619,7 +632,7 @@ def _call_after(self):
                 exc.__context__ = error
                 traceback.print_exception(type(exc), exc, exc.__traceback__)
         elif error:
-            msg = 'Exception in voice thread {}'.format(self.name)
+            msg = f'Exception in voice thread {self.name}'
             log.exception(msg, exc_info=error)
             print(msg, file=sys.stderr)
             traceback.print_exception(type(error), error, error.__traceback__)
diff --git a/discord/raw_models.py b/discord/raw_models.py
index 7ea67c25..cba3adc5 100644
--- a/discord/raw_models.py
+++ b/discord/raw_models.py
@@ -37,7 +37,7 @@
 class _RawReprMixin:
     def __repr__(self):
         value = ' '.join('%s=%r' % (attr, getattr(self, attr)) for attr in self.__slots__)
-        return '<%s %s>' % (self.__class__.__name__, value)
+        return f'<{self.__class__.__name__} {value}>'
 
 
 class RawMessageDeleteEvent(_RawReprMixin):
@@ -237,8 +237,7 @@ class RawInteractionCreateEvent(_RawReprMixin):
     def __init__(self, data, http=None):
         self.http = http
         self._type = data.get('t', data.get('type', None))
-        d = data.get('d', None)
-        if d:
+        if d := data.get('d', None):
             self.__token = d.get('token', None)
             self._version = d.get('version', None)
             self._type = d.get(type, None)
diff --git a/discord/reaction.py b/discord/reaction.py
index 437c0fe9..28cc33a1 100644
--- a/discord/reaction.py
+++ b/discord/reaction.py
@@ -80,9 +80,7 @@ def __eq__(self, other):
         return isinstance(other, self.__class__) and other.emoji == self.emoji
 
     def __ne__(self, other):
-        if isinstance(other, self.__class__):
-            return other.emoji != self.emoji
-        return True
+        return other.emoji != self.emoji if isinstance(other, self.__class__) else True
 
     def __hash__(self):
         return hash(self.emoji)
diff --git a/discord/role.py b/discord/role.py
index 5fe20fcf..ba84892d 100644
--- a/discord/role.py
+++ b/discord/role.py
@@ -173,18 +173,14 @@ def __lt__(self, other):
 
     def __le__(self, other):
         r = Role.__lt__(other, self)
-        if r is NotImplemented:
-            return NotImplemented
-        return not r
+        return NotImplemented if r is NotImplemented else not r
 
     def __gt__(self, other):
         return Role.__lt__(other, self)
 
     def __ge__(self, other):
         r = Role.__lt__(self, other)
-        if r is NotImplemented:
-            return NotImplemented
-        return not r
+        return NotImplemented if r is NotImplemented else not r
 
     def _update(self, data):
         self.name = data['name']
@@ -248,7 +244,7 @@ def created_at(self):
     @property
     def mention(self):
         """:class:`str`: Returns a string that allows you to mention a role."""
-        return '<@&%s>' % self.id
+        return f'<@&{self.id}>'
 
     @property
     def members(self):
diff --git a/discord/shard.py b/discord/shard.py
index 1ef9e923..8a48b9ea 100644
--- a/discord/shard.py
+++ b/discord/shard.py
@@ -433,8 +433,6 @@ async def connect(self, *, reconnect=True):
                 if isinstance(item.error, ConnectionClosed):
                     if item.error.code != 1000:
                         raise item.error
-                    if item.error.code == 4014:
-                        raise PrivilegedIntentsRequired(item.shard.id) from None
                 return
             elif item.type in (EventType.identify, EventType.resume):
                 await item.shard.reidentify(item.error)
@@ -462,8 +460,10 @@ async def close(self):
             except Exception:
                 pass
 
-        to_close = [asyncio.ensure_future(shard.close(), loop=self.loop) for shard in self.__shards.values()]
-        if to_close:
+        if to_close := [
+            asyncio.ensure_future(shard.close(), loop=self.loop)
+            for shard in self.__shards.values()
+        ]:
             await asyncio.wait(to_close)
 
         await self.http.close()
diff --git a/discord/state.py b/discord/state.py
index d45c043e..3404d0dd 100644
--- a/discord/state.py
+++ b/discord/state.py
@@ -149,18 +149,13 @@ def __init__(self, *, dispatch, handlers, hooks, syncer, http, loop, **options):
 
         status = options.get('status', None)
         if status:
-            if status is Status.offline:
-                status = 'invisible'
-            else:
-                status = str(status)
-
+            status = 'invisible' if status is Status.offline else str(status)
         intents = options.get('intents', None)
-        if intents is not None:
-            if not isinstance(intents, Intents):
-                raise TypeError('intents parameter must be Intent not %r' % type(intents))
-        else:
+        if intents is None:
             intents = Intents.default()
 
+        elif not isinstance(intents, Intents):
+            raise TypeError('intents parameter must be Intent not %r' % type(intents))
         if not intents.guilds:
             log.warning('Guilds intent seems to be disabled. This may cause state related issues.')
 
@@ -181,12 +176,12 @@ def __init__(self, *, dispatch, handlers, hooks, syncer, http, loop, **options):
         cache_flags = options.get('member_cache_flags', None)
         if cache_flags is None:
             cache_flags = MemberCacheFlags.from_intents(intents)
-        else:
-            if not isinstance(cache_flags, MemberCacheFlags):
-                raise TypeError('member_cache_flags parameter must be MemberCacheFlags not %r' % type(cache_flags))
-
+        elif isinstance(cache_flags, MemberCacheFlags):
             cache_flags._verify_intents(intents)
 
+        else:
+            raise TypeError('member_cache_flags parameter must be MemberCacheFlags not %r' % type(cache_flags))
+
         self.member_cache_flags = cache_flags
         self._activity = activity
         self._status = status
@@ -427,11 +422,10 @@ async def _delay_ready(self):
                         if self._guild_needs_chunking(guild):
                             future = await self.chunk_guild(guild, wait=False)
                             states.append((guild, future))
+                        elif guild.unavailable is False:
+                            self.dispatch('guild_available', guild)
                         else:
-                            if guild.unavailable is False:
-                                self.dispatch('guild_available', guild)
-                            else:
-                                self.dispatch('guild_join', guild)
+                            self.dispatch('guild_join', guild)
 
                 for guild, future in states:
                     try:
@@ -556,30 +550,31 @@ def parse_interaction_create(self, data):
         else:
             interaction._channel = self._get_private_channel(interaction.channel_id)
         interaction.message = self._get_message(interaction.message_id) if interaction.message is None else interaction.message
-        if self._get_message(interaction.message_id) is not None:
-            if interaction._interaction_type == InteractionType.Component:
-                if interaction.component_type == 2:
-                    self.dispatch('button_click', interaction, interaction.component)
-                    self.dispatch('raw_button_click', interaction, interaction.component)
-                elif interaction.component_type == 3:
-                    self.dispatch('selection_select', interaction, interaction.component)
-                    self.dispatch('raw_selection_select', interaction, interaction.component)
-        else:
+        if self._get_message(interaction.message_id) is None:
             interaction.message = Message(state=self, channel=interaction.channel, data=interaction._message)
-            if interaction._interaction_type == InteractionType.Component:
-                if interaction.component_type == 2:
+            if interaction.component_type == 2:
+                if interaction._interaction_type == InteractionType.Component:
                     self.dispatch('raw_button_click', interaction, interaction.component)
-                elif interaction.component_type == 3:
+            elif interaction.component_type == 3:
+                if interaction._interaction_type == InteractionType.Component:
                     self.dispatch('raw_selection_select', interaction, interaction.component)
 
+        elif interaction.component_type == 2:
+            if interaction._interaction_type == InteractionType.Component:
+                self.dispatch('button_click', interaction, interaction.component)
+                self.dispatch('raw_button_click', interaction, interaction.component)
+        elif interaction.component_type == 3:
+            if interaction._interaction_type == InteractionType.Component:
+                self.dispatch('selection_select', interaction, interaction.component)
+                self.dispatch('raw_selection_select', interaction, interaction.component)
+
     def parse_message_reaction_add(self, data):
         emoji = data['emoji']
         emoji_id = utils._get_as_snowflake(emoji, 'id')
         emoji = PartialEmoji.with_state(self, id=emoji_id, animated=emoji.get('animated', False), name=emoji['name'])
         raw = RawReactionActionEvent(data, emoji, 'REACTION_ADD')
 
-        member_data = data.get('member')
-        if member_data:
+        if member_data := data.get('member'):
             guild = self._get_guild(raw.guild_id)
             raw.member = Member(data=member_data, guild=guild, state=self)
         else:
@@ -591,9 +586,9 @@ def parse_message_reaction_add(self, data):
         if message is not None:
             emoji = self._upgrade_partial_emoji(emoji)
             reaction = message._add_reaction(data, emoji, raw.user_id)
-            user = raw.member or self._get_reaction_user(message.channel, raw.user_id)
-
-            if user:
+            if user := raw.member or self._get_reaction_user(
+                message.channel, raw.user_id
+            ):
                 self.dispatch('reaction_add', reaction, user)
 
     def parse_message_reaction_remove_all(self, data):
@@ -621,8 +616,7 @@ def parse_message_reaction_remove(self, data):
             except (AttributeError, ValueError): # eventual consistency lol
                 pass
             else:
-                user = self._get_reaction_user(message.channel, raw.user_id)
-                if user:
+                if user := self._get_reaction_user(message.channel, raw.user_id):
                     self.dispatch('reaction_remove', reaction, user)
 
     def parse_message_reaction_remove_emoji(self, data):
@@ -664,8 +658,7 @@ def parse_presence_update(self, data):
                 guild._add_member(member)
         else:
             old_member = Member._copy(member)
-            user_update = member._presence_update(data=data, user=user)
-            if user_update:
+            if user_update := member._presence_update(data=data, user=user):
                 self.dispatch('user_update', user_update[0], user_update[1])
 
             if member.id != self.self_id and flags._online_only and member.raw_status == 'offline':
@@ -826,8 +819,7 @@ def parse_guild_member_update(self, data):
         if member is not None:
             old_member = Member._copy(member)
             member._update(data)
-            user_update = member._update_inner_user(user)
-            if user_update:
+            if user_update := member._update_inner_user(user):
                 self.dispatch('user_update', user_update[0], user_update[1])
 
             self.dispatch('member_update', old_member, member)
@@ -835,9 +827,7 @@ def parse_guild_member_update(self, data):
             if self.member_cache_flags.joined:
                 member = Member(data=data, guild=guild, state=self)
 
-                # Force an update on the inner user if necessary
-                user_update = member._update_inner_user(user)
-                if user_update:
+                if user_update := member._update_inner_user(user):
                     self.dispatch('user_update', user_update[0], user_update[1])
 
                 guild._add_member(member)
@@ -878,9 +868,7 @@ async def chunk_guild(self, guild, *, wait=True, cache=None):
             self._chunk_requests[guild.id] = request = ChunkRequest(guild.id, self.loop, self._get_guild, cache=cache)
             await self.chunker(guild.id, nonce=request.nonce)
 
-        if wait:
-            return await request.wait()
-        return request.get_future()
+        return await request.wait() if wait else request.get_future()
 
     async def _chunk_and_dispatch(self, guild, unavailable):
         try:
@@ -1049,9 +1037,8 @@ def parse_webhooks_update(self, data):
     def parse_voice_state_update(self, data):
         guild = self._get_guild(utils._get_as_snowflake(data, 'guild_id'))
         channel_id = utils._get_as_snowflake(data, 'channel_id')
-        flags = self.member_cache_flags
-        self_id = self.user.id
         if guild is not None:
+            self_id = self.user.id
             if int(data['user_id']) == self_id:
                 voice = self._get_voice_client(guild.id)
                 if voice is not None:
@@ -1060,6 +1047,7 @@ def parse_voice_state_update(self, data):
 
             member, before, after = guild._update_voice_state(data, channel_id)
             if member is not None:
+                flags = self.member_cache_flags
                 if flags.voice:
                     if channel_id is None and flags._voice_only and member.id != self_id:
                         # Only remove from cache iff we only have the voice flag enabled
@@ -1097,8 +1085,7 @@ def parse_typing_start(self, data):
             elif isinstance(channel, TextChannel) and guild is not None:
                 member = guild.get_member(user_id)
                 if member is None:
-                    member_data = data.get('member')
-                    if member_data:
+                    if member_data := data.get('member'):
                         member = Member(data=member_data, state=self, guild=guild)
 
             elif isinstance(channel, GroupChannel):
diff --git a/discord/user.py b/discord/user.py
index 8b2d3a1c..4fae0093 100644
--- a/discord/user.py
+++ b/discord/user.py
@@ -199,7 +199,7 @@ def default_avatar(self):
     @property
     def default_avatar_url(self):
         """:class:`Asset`: Returns a URL for a user's default avatar."""
-        return Asset(self._state, '/embed/avatars/{}.png'.format(self.default_avatar.value))
+        return Asset(self._state, f'/embed/avatars/{self.default_avatar.value}.png')
 
     @property
     def colour(self):
@@ -474,11 +474,7 @@ async def edit(self, **fields):
         except KeyError:
             avatar = self.avatar
         else:
-            if avatar_bytes is not None:
-                avatar = _bytes_to_base64_data(avatar_bytes)
-            else:
-                avatar = None
-
+            avatar = None if avatar_bytes is None else _bytes_to_base64_data(avatar_bytes)
         not_bot_account = not self.bot
         password = fields.get('password')
         if not_bot_account and password is None:
@@ -643,38 +639,31 @@ async def edit_settings(self, **kwargs):
         """
         payload = {}
 
-        content_filter = kwargs.pop('explicit_content_filter', None)
-        if content_filter:
-            payload.update({'explicit_content_filter': content_filter.value})
+        if content_filter := kwargs.pop('explicit_content_filter', None):
+            payload['explicit_content_filter'] = content_filter.value
 
-        friend_flags = kwargs.pop('friend_source_flags', None)
-        if friend_flags:
+        if friend_flags := kwargs.pop('friend_source_flags', None):
             dicts = [{}, {'mutual_guilds': True}, {'mutual_friends': True},
             {'mutual_guilds': True, 'mutual_friends': True}, {'all': True}]
-            payload.update({'friend_source_flags': dicts[friend_flags.value]})
+            payload['friend_source_flags'] = dicts[friend_flags.value]
 
-        guild_positions = kwargs.pop('guild_positions', None)
-        if guild_positions:
+        if guild_positions := kwargs.pop('guild_positions', None):
             guild_positions = [str(x.id) for x in guild_positions]
-            payload.update({'guild_positions': guild_positions})
+            payload['guild_positions'] = guild_positions
 
-        restricted_guilds = kwargs.pop('restricted_guilds', None)
-        if restricted_guilds:
+        if restricted_guilds := kwargs.pop('restricted_guilds', None):
             restricted_guilds = [str(x.id) for x in restricted_guilds]
-            payload.update({'restricted_guilds': restricted_guilds})
+            payload['restricted_guilds'] = restricted_guilds
 
-        status = kwargs.pop('status', None)
-        if status:
-            payload.update({'status': status.value})
+        if status := kwargs.pop('status', None):
+            payload['status'] = status.value
 
-        theme = kwargs.pop('theme', None)
-        if theme:
-            payload.update({'theme': theme.value})
+        if theme := kwargs.pop('theme', None):
+            payload['theme'] = theme.value
 
-        payload.update(kwargs)
+        payload |= kwargs
 
-        data = await self._state.http.edit_settings(**payload)
-        return data
+        return await self._state.http.edit_settings(**payload)
 
 class User(BaseUser, discord.abc.Messageable):
     """Represents a Discord user.
@@ -719,8 +708,7 @@ def __repr__(self):
         return '<User id={0.id} name={0.name!r} discriminator={0.discriminator!r} bot={0.bot}>'.format(self)
 
     async def _get_channel(self):
-        ch = await self.create_dm()
-        return ch
+        return await self.create_dm()
 
     @property
     def dm_channel(self):
@@ -815,9 +803,7 @@ def is_friend(self):
             This can only be used by non-bot accounts.
         """
         r = self.relationship
-        if r is None:
-            return False
-        return r.type is RelationshipType.friend
+        return False if r is None else r.type is RelationshipType.friend
 
     @deprecated()
     def is_blocked(self):
@@ -830,9 +816,7 @@ def is_blocked(self):
             This can only be used by non-bot accounts.
         """
         r = self.relationship
-        if r is None:
-            return False
-        return r.type is RelationshipType.blocked
+        return False if r is None else r.type is RelationshipType.blocked
 
     @deprecated()
     async def block(self):
diff --git a/discord/utils.py b/discord/utils.py
index f1f22cd3..2c2e8761 100644
--- a/discord/utils.py
+++ b/discord/utils.py
@@ -170,15 +170,15 @@ def oauth_url(client_id, permissions=None, guild=None, redirect_uri=None, scopes
     :class:`str`
         The OAuth2 URL for inviting the bot into guilds.
     """
-    url = 'https://discord.com/oauth2/authorize?client_id={}'.format(client_id)
-    url = url + '&scope=' + '+'.join(scopes or ('bot',))
+    url = f'https://discord.com/oauth2/authorize?client_id={client_id}'
+    url = f'{url}&scope=' + '+'.join(scopes or ('bot',))
     if permissions is not None:
-        url = url + '&permissions=' + str(permissions.value)
+        url = f'{url}&permissions={str(permissions.value)}'
     if guild is not None:
-        url = url + "&guild_id=" + str(guild.id)
+        url = f"{url}&guild_id={str(guild.id)}"
     if redirect_uri is not None:
         from urllib.parse import urlencode
-        url = url + "&response_type=code&" + urlencode({'redirect_uri': redirect_uri})
+        url = f"{url}&response_type=code&" + urlencode({'redirect_uri': redirect_uri})
     return url
 
 
@@ -235,10 +235,7 @@ def find(predicate, seq):
         The iterable to search through.
     """
 
-    for element in seq:
-        if predicate(element):
-            return element
-    return None
+    return next((element for element in seq if predicate(element)), None)
 
 
 def get(iterable, **attrs):
@@ -293,21 +290,20 @@ def get(iterable, **attrs):
     if len(attrs) == 1:
         k, v = attrs.popitem()
         pred = attrget(k.replace('__', '.'))
-        for elem in iterable:
-            if pred(elem) == v:
-                return elem
-        return None
-
+        return next((elem for elem in iterable if pred(elem) == v), None)
     converted = [
         (attrget(attr.replace('__', '.')), value)
         for attr, value in attrs.items()
     ]
 
-    for elem in iterable:
-        if _all(pred(elem) == value for pred, value in converted):
-            return elem
-
-    return None
+    return next(
+        (
+            elem
+            for elem in iterable
+            if _all(pred(elem) == value for pred, value in converted)
+        ),
+        None,
+    )
 
 
 def styled_timestamp(timestamp: typing.Union[datetime.datetime, int], style: typing.Union[TimestampStyle, str] = TimestampStyle.short):
@@ -320,8 +316,7 @@ def styled_timestamp(timestamp: typing.Union[datetime.datetime, int], style: typ
 
 def _unique(iterable):
     seen = set()
-    adder = seen.add
-    return [x for x in iterable if not (x in seen or adder(x))]
+    return [x for x in iterable if x not in seen and not seen.add(x)]
 
 
 def _get_as_snowflake(data, key):
@@ -336,7 +331,7 @@ def _get_as_snowflake(data, key):
 def _get_mime_type_for_image(data):
     if data.startswith(b'\x89\x50\x4E\x47\x0D\x0A\x1A\x0A'):
         return 'image/png'
-    elif data[0:3] == b'\xff\xd8\xff' or data[6:10] in (b'JFIF', b'Exif'):
+    elif data[:3] == b'\xff\xd8\xff' or data[6:10] in (b'JFIF', b'Exif'):
         return 'image/jpeg'
     elif data.startswith((b'\x47\x49\x46\x38\x37\x61', b'\x47\x49\x46\x38\x39\x61')):
         return 'image/gif'
@@ -359,21 +354,17 @@ def to_json(obj):
 
 def _parse_ratelimit_header(request, *, use_clock=False):
     reset_after = request.headers.get('X-Ratelimit-Reset-After')
-    if use_clock or not reset_after:
-        utc = datetime.timezone.utc
-        now = datetime.datetime.now(utc)
-        reset = datetime.datetime.fromtimestamp(float(request.headers['X-Ratelimit-Reset']), utc)
-        return (reset - now).total_seconds()
-    else:
+    if not use_clock and reset_after:
         return float(reset_after)
+    utc = datetime.timezone.utc
+    now = datetime.datetime.now(utc)
+    reset = datetime.datetime.fromtimestamp(float(request.headers['X-Ratelimit-Reset']), utc)
+    return (reset - now).total_seconds()
 
 
 async def maybe_coroutine(f, *args, **kwargs):
     value = f(*args, **kwargs)
-    if _isawaitable(value):
-        return await value
-    else:
-        return value
+    return await value if _isawaitable(value) else value
 
 
 async def async_all(gen, *, check=_isawaitable):
@@ -462,8 +453,7 @@ def has(self, element):
 
 def _string_width(string, *, _IS_ASCII=_IS_ASCII):
     """Returns string's width."""
-    match = _IS_ASCII.match(string)
-    if match:
+    if match := _IS_ASCII.match(string):
         return match.endpos
 
     UNICODE_WIDE_CHAR_TYPE = 'WFA'
@@ -488,12 +478,8 @@ def resolve_invite(invite):
     from .invite import Invite  # circular import
     if isinstance(invite, Invite):
         return invite.code
-    else:
-        rx = r'(?:https?\:\/\/)?discord(?:\.gg|(?:app)?\.com\/invite)\/(.+)'
-        m = re.match(rx, invite)
-        if m:
-            return m.group(1)
-    return invite
+    rx = r'(?:https?\:\/\/)?discord(?:\.gg|(?:app)?\.com\/invite)\/(.+)'
+    return m[1] if (m := re.match(rx, invite)) else invite
 
 
 def resolve_template(code):
@@ -515,12 +501,8 @@ def resolve_template(code):
     from .template import Template  # circular import
     if isinstance(code, Template):
         return code.code
-    else:
-        rx = r'(?:https?\:\/\/)?discord(?:\.new|(?:app)?\.com\/template)\/(.+)'
-        m = re.match(rx, code)
-        if m:
-            return m.group(1)
-    return code
+    rx = r'(?:https?\:\/\/)?discord(?:\.new|(?:app)?\.com\/template)\/(.+)'
+    return m[1] if (m := re.match(rx, code)) else code
 
 
 _MARKDOWN_ESCAPE_SUBREGEX = '|'.join(r'\{0}(?=([\s\S]*((?<!\{0})\{0})))'.format(c)
@@ -528,7 +510,10 @@ def resolve_template(code):
 
 _MARKDOWN_ESCAPE_COMMON = r'^>(?:>>)?\s|\[.+\]\(.+\)'
 
-_MARKDOWN_ESCAPE_REGEX = re.compile(r'(?P<markdown>%s|%s)' % (_MARKDOWN_ESCAPE_SUBREGEX, _MARKDOWN_ESCAPE_COMMON), re.MULTILINE)
+_MARKDOWN_ESCAPE_REGEX = re.compile(
+    f'(?P<markdown>{_MARKDOWN_ESCAPE_SUBREGEX}|{_MARKDOWN_ESCAPE_COMMON})',
+    re.MULTILINE,
+)
 
 _URL_REGEX = r'(?P<url><[^: >]+:\/[^ >]+>|(?:https?|steam):\/\/[^\s<]+[^<.,:;\"\'\]\s])'
 
@@ -565,7 +550,7 @@ def replacement(match):
 
     regex = _MARKDOWN_STOCK_REGEX
     if ignore_links:
-        regex = '(?:%s|%s)' % (_URL_REGEX, regex)
+        regex = f'(?:{_URL_REGEX}|{regex})'
     return re.sub(regex, replacement, text, 0, re.MULTILINE)
 
 
@@ -598,13 +583,11 @@ def escape_markdown(text, *, as_needed=False, ignore_links=True):
         def replacement(match):
             groupdict = match.groupdict()
             is_url = groupdict.get('url')
-            if is_url:
-                return is_url
-            return '\\' + groupdict['markdown']
+            return is_url if is_url else '\\' + groupdict['markdown']
 
         regex = _MARKDOWN_STOCK_REGEX
         if ignore_links:
-            regex = '(?:%s|%s)' % (_URL_REGEX, regex)
+            regex = f'(?:{_URL_REGEX}|{regex})'
         return re.sub(regex, replacement, text, 0, re.MULTILINE)
     else:
         text = re.sub(r'\\', r'\\\\', text)
diff --git a/discord/voice_client.py b/discord/voice_client.py
index d24d022b..18c6042e 100644
--- a/discord/voice_client.py
+++ b/discord/voice_client.py
@@ -353,14 +353,12 @@ async def connect(self, *, reconnect, timeout):
                 self.ws = await self.connect_websocket()
                 break
             except (ConnectionClosed, asyncio.TimeoutError):
-                if reconnect:
-                    log.exception('Failed to connect to voice... Retrying...')
-                    await asyncio.sleep(1 + i * 2.0)
-                    await self.voice_disconnect()
-                    continue
-                else:
+                if not reconnect:
                     raise
 
+                log.exception('Failed to connect to voice... Retrying...')
+                await asyncio.sleep(1 + i * 2.0)
+                await self.voice_disconnect()
         if self._runner is None:
             self._runner = self.loop.create_task(self.poll_voice_ws(reconnect))
 
@@ -425,13 +423,12 @@ async def poll_voice_ws(self, reconnect):
                     if exc.code == 4014:
                         log.info('Disconnected from voice by force... potentially reconnecting.')
                         successful = await self.potential_reconnect()
-                        if not successful:
-                            log.info('Reconnect was unsuccessful, disconnecting from voice normally...')
-                            await self.disconnect()
-                            break
-                        else:
+                        if successful:
                             continue
 
+                        log.info('Reconnect was unsuccessful, disconnecting from voice normally...')
+                        await self.disconnect()
+                        break
                 if not reconnect:
                     await self.disconnect()
                     raise
@@ -497,7 +494,7 @@ def _get_voice_packet(self, data):
         struct.pack_into('>I', header, 4, self.timestamp)
         struct.pack_into('>I', header, 8, self.ssrc)
 
-        encrypt_packet = getattr(self, '_encrypt_' + self.mode)
+        encrypt_packet = getattr(self, f'_encrypt_{self.mode}')
         return encrypt_packet(header, data)
 
     def _encrypt_xsalsa20_poly1305(self, header, data):
diff --git a/discord/webhook.py b/discord/webhook.py
index af29a47a..bb36506d 100644
--- a/discord/webhook.py
+++ b/discord/webhook.py
@@ -100,10 +100,12 @@ def edit_webhook(self, *, reason=None, **payload):
         return self.request('PATCH', self._request_url, payload=payload, reason=reason)
 
     def edit_webhook_message(self, message_id, payload):
-        return self.request('PATCH', '{}/messages/{}'.format(self._request_url, message_id), payload=payload)
+        return self.request(
+            'PATCH', f'{self._request_url}/messages/{message_id}', payload=payload
+        )
 
     def delete_webhook_message(self, message_id):
-        return self.request('DELETE', '{}/messages/{}'.format(self._request_url, message_id))
+        return self.request('DELETE', f'{self._request_url}/messages/{message_id}')
 
     def handle_execution_response(self, data, *, wait):
         """Transforms the webhook execution response into something
@@ -339,18 +341,17 @@ def request(self, verb, url, payload=None, multipart=None, *, files=None, reason
 
             # we are being rate limited
             if r.status == 429:
-                if self.sleep:
-                    if not r.headers.get('Via'):
-                        # Banned by Cloudflare more than likely.
-                        raise HTTPException(r, data)
-
-                    retry_after = response['retry_after'] / 1000.0
-                    log.warning('Webhook ID %s is rate limited. Retrying in %.2f seconds', _id, retry_after)
-                    time.sleep(retry_after)
-                    continue
-                else:
+                if not self.sleep:
                     raise HTTPException(r, response)
 
+                if not r.headers.get('Via'):
+                    # Banned by Cloudflare more than likely.
+                    raise HTTPException(r, data)
+
+                retry_after = response['retry_after'] / 1000.0
+                log.warning('Webhook ID %s is rate limited. Retrying in %.2f seconds', _id, retry_after)
+                time.sleep(retry_after)
+                continue
             if self.sleep and r.status in (500, 502):
                 time.sleep(1 + tries * 2)
                 continue
@@ -388,11 +389,7 @@ class _PartialWebhookState:
     def __init__(self, adapter, webhook, parent):
         self._webhook = webhook
 
-        if isinstance(parent, self.__class__):
-            self.parent = None
-        else:
-            self.parent = parent
-
+        self.parent = None if isinstance(parent, self.__class__) else parent
         # Fetch the loop from the adapter if it's there
         try:
             self.loop = adapter.loop
@@ -628,7 +625,7 @@ def __repr__(self):
     @property
     def url(self):
         """:class:`str` : Returns the webhook's url."""
-        return 'https://discord.com/api/webhooks/{}/{}'.format(self.id, self.token)
+        return f'https://discord.com/api/webhooks/{self.id}/{self.token}'
 
     @classmethod
     def partial(cls, id, token, *, adapter):
@@ -697,7 +694,7 @@ def from_url(cls, url, *, adapter):
 
     @classmethod
     def _as_follower(cls, data, *, channel, user):
-        name = "{} #{}".format(channel.guild, channel)
+        name = f"{channel.guild} #{channel}"
         feed = {
             'id': data['webhook_id'],
             'type': 2,
@@ -865,11 +862,7 @@ def edit(self, *, reason=None, **kwargs):
         except KeyError:
             pass
         else:
-            if name is not None:
-                payload['name'] = str(name)
-            else:
-                payload['name'] = None
-
+            payload['name'] = str(name) if name is not None else None
         try:
             avatar = kwargs['avatar']
         except KeyError:
@@ -1062,11 +1055,7 @@ def edit_message(self, message_id, **fields):
             if 'embeds' in payload:
                 raise InvalidArgument('Cannot mix embed and embeds keyword arguments')
 
-            if embed is None:
-                payload['embeds'] = []
-            else:
-                payload['embeds'] = [embed.to_dict()]
-
+            payload['embeds'] = [] if embed is None else [embed.to_dict()]
         allowed_mentions = fields.pop('allowed_mentions', None)
         previous_mentions = getattr(self._state, 'allowed_mentions', None)
 
diff --git a/discord/widget.py b/discord/widget.py
index 252cebe2..966bf979 100644
--- a/discord/widget.py
+++ b/discord/widget.py
@@ -77,7 +77,7 @@ def __repr__(self):
     @property
     def mention(self):
         """:class:`str`: The string that allows you to mention the channel."""
-        return '<#%s>' % self.id
+        return f'<#{self.id}>'
 
     @property
     def created_at(self):
diff --git a/examples.py b/examples.py
index 72e0e6e6..f164e94b 100644
--- a/examples.py
+++ b/examples.py
@@ -91,8 +91,7 @@ def get_pointer(obj: typing.Union[discord.Guild, int]):
         for p in pointers:
             if p.guild.id == obj:
                 return p
-        guild = client.get_guild(obj)
-        if guild:
+        if guild := client.get_guild(obj):
             pointers.append(Pointer(guild))
             return get_pointer(guild)
         return None
diff --git a/setup.py b/setup.py
index 110b1a8d..74b68988 100644
--- a/setup.py
+++ b/setup.py
@@ -8,7 +8,9 @@
 
 version = ''
 with open(f'{HERE}/discord/__init__.py') as f:
-    version += re.search(r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]', f.read(), re.MULTILINE).group(1)
+    version += re.search(
+        r'^__version__\s*=\s*[\'"]([^\'"]*)[\'"]', f.read(), re.MULTILINE
+    )[1]
 
 v = None
 if os.path.isfile('version.txt'):