Regarding the main question, yes, many options exist some of which are simple, such as the BIP39 Tool noted in a prior answer, hosted by Ian Coleman (disclosure: I am a contributor to that tool on Github), however, that will generate a mnemonic and resulting crypto vault (using BIP39, then BIP32 and BIP44), and not just a single private-public key pair.
Again, most wallets now use BIP32 which is a Hierarchal Deterministic (HD) wallet that uses extended public/private keys that can derive up to 2 billion wallet addresses (and if using BIP44, this is 2 billion per supported cryptocurrency), versus generating a single address tied to a public/private key pair.
Nonetheless, for the sake of the main question, below I provided an example program that can be run as a .py file in Python 3 that will generate a single private key and derive an ethereum address.
Regarding the Myetherwallet reference: The JSON file you described is a Keystore that is AES-encrypted, and what you pasted are the ciphertext and algorithm parameters such as salt and initialization vector (and all of which are need to decrypt, together with the password). The reason why sites will export it like this after forcing you to choose a password, is so that you only keep encrypted data on your device and not the plaintext which a hacker could steal.
Here is an example light program that can be run in Python (including offline) that will generate a cryptographically-secure random number (using the secrets library) to seed the private key, and then computes the public key and its Keccak_256 hash to derive an ethereum address based on the trailing 40 hex characters of that hash digest. See here to learn more about how ethereum addresses are generated.
The eth_keys library (from the Ethereum Foundation) is used in the below program and also contains error checking to make sure the private key is valid, in terms of elliptic curve secp256k1 which is for used in Ethereum, together with the hashing algorithm Keccak_256 (which comes from the below sha3 library).
import secrets
import sha3
import eth_keys
from eth_keys import keys
private_key = str(hex(secrets.randbits(256))[2:])
private_key_bytes = bytes.fromhex(private_key)
public_key_hex = keys.PrivateKey(private_key_bytes).public_key
public_key_bytes = bytes.fromhex(str(public_key_hex)[2:])
keccak256_of_public_key_bytes = sha3.keccak_256(public_key_bytes).hexdigest()
public_address = keys.PublicKey(public_key_bytes).to_address()
checksum = keys.PublicKey(public_key_bytes).to_checksum_address()
print('\n Private_key:',private_key,
'\n Private_key_bytes:',private_key_bytes,
'\n Public_key_hex:',public_key_hex,
'\n Public_key_bytes:',public_key_bytes,
'\n Full_Keccak_digest:',keccak256_of_public_key_bytes,
'\n Ethereum address:',public_address,
'\n Checksum Format of Above Ethereum:',checksum)
Note: The use of single private-public key pairs is not supported in many wallets, as most wallets use BIP39 which allow a user to derive up to 2 billion addresses per supported cryptocurrency. Nonetheless, if you understand the risks and convenience/security trade-offs, having a single private key that controls only one address (compared to having a single mnemonic that controls and entire crypto vault), then it could have its place in a portfolio of crypto assets.
Also, in some networks such as bitcoin, such addresses shouldn't be used unless sending nothing less than the entire balance, as the lack of a return "change" address can result in a total loss of the difference (i.e. remaining amount not sent) depending on the software used (and is another reason why brain wallets are not widely used anymore).
