Converter For Computer-Type Languages (bin/hex)

PHOTO

Wed Feb 08 2023 20:23:04 GMT+0000 (Coordinated Universal Time)

Saved by @Shivam #python

def string_to_binary(requested_conversion):
    converted_output = []
    for char in requested_conversion:
        converted_output.append(bin(ord(char)))
    print(*converted_output)

def decimal_to_binary(requested_conversion):
    print(bin(requested_conversion))

def binary_to_decimal(requested_conversion):
    requested_conversion = requested_conversion[2:]
    requested_conversion = requested_conversion[::-1]
    concurrent_bit = 0
    bit_power = 0
    decimal_num = 0
    for digit in requested_conversion:
        if requested_conversion[concurrent_bit] == '1':
            decimal_num += 2 ** bit_power
        else:
            decimal_num += 0
        concurrent_bit += 1
        bit_power += 1
    print(decimal_num)

# The function below is a copy of the original but for the purpose of the binary_to_string function and binary_to_hex function.
def binary_to_decimal_special(requested_conversion):
    requested_conversion = requested_conversion[2:]
    requested_conversion = requested_conversion[::-1]
    concurrent_bit = 0
    bit_power = 0
    decimal_num = 0
    for digit in requested_conversion:
        if requested_conversion[concurrent_bit] == '1':
            decimal_num += 2 ** bit_power
        else:
            decimal_num += 0
        concurrent_bit += 1
        bit_power += 1
    return decimal_num

def binary_to_string(requested_conversion):
    requested_conversion = requested_conversion.split(" ")
    list_of_chars_in_string = []
    for char_binary_set in requested_conversion:
        integer_char_code = chr(binary_to_decimal_special(char_binary_set))
        list_of_chars_in_string.append(integer_char_code)
    print(*list_of_chars_in_string, sep="")

def string_to_hex(requested_conversion):
    converted_output = []
    for char in requested_conversion:
        converted_output.append(hex(ord(char)))
    print(*converted_output)
    
def decimal_to_hex(requested_conversion):
    print(hex(requested_conversion))

def hex_to_decimal(requested_conversion):
    requested_conversion = requested_conversion[2:]
    requested_conversion = requested_conversion[::-1]
    concurrent_bit = 0
    bit_power = 0
    decimal_num = 0
    for digit in requested_conversion:
        if requested_conversion[concurrent_bit] == 'a':
            decimal_num += 10 * (16 ** bit_power)
        elif requested_conversion[concurrent_bit] == 'b':
            decimal_num += 11 * (16 ** bit_power)
        elif requested_conversion[concurrent_bit] == 'c':
            decimal_num += 12 * (16 ** bit_power)
        elif requested_conversion[concurrent_bit] == 'd':
            decimal_num += 13 * (16 ** bit_power)
        elif requested_conversion[concurrent_bit] == 'e':
            decimal_num += 14 * (16 ** bit_power)
        elif requested_conversion[concurrent_bit] == 'f':
            decimal_num += 15 * (16 ** bit_power)
        else:
            decimal_num += int(digit) * (16 ** bit_power)
        concurrent_bit += 1
        bit_power += 1
    print(decimal_num)

# The function below is a copy of the original but for the purpose of the hex_to_string function.
def hex_to_decimal_special(requested_conversion):
    requested_conversion = requested_conversion[2:]
    requested_conversion = requested_conversion[::-1]
    concurrent_bit = 0
    bit_power = 0
    decimal_num = 0
    for digit in requested_conversion:
        if requested_conversion[concurrent_bit] == 'a':
            decimal_num += 10 * (16 ** bit_power)
        elif requested_conversion[concurrent_bit] == 'b':
            decimal_num += 11 * (16 ** bit_power)
        elif requested_conversion[concurrent_bit] == 'c':
            decimal_num += 12 * (16 ** bit_power)
        elif requested_conversion[concurrent_bit] == 'd':
            decimal_num += 13 * (16 ** bit_power)
        elif requested_conversion[concurrent_bit] == 'e':
            decimal_num += 14 * (16 ** bit_power)
        elif requested_conversion[concurrent_bit] == 'f':
            decimal_num += 15 * (16 ** bit_power)
        else:
            decimal_num += int(digit) * (16 ** bit_power)
        concurrent_bit += 1
        bit_power += 1
    return decimal_num
    
def hex_to_string(requested_conversion):
    requested_conversion = requested_conversion.split(" ")
    list_of_chars_in_string = []
    for char_hexa_set in requested_conversion:
        integer_char_code = chr(hex_to_decimal_special(char_hexa_set))
        list_of_chars_in_string.append(integer_char_code)
    print(*list_of_chars_in_string, sep="")

def hex_to_binary_decimalversion(requested_conversion):
    requested_conversion = requested_conversion[2:]
    concurrent_bit = 0
    list_of_binary_portions = []
    for digit in requested_conversion:
        if requested_conversion[concurrent_bit] == 'a':
            binary_translation = str(bin(10))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        elif requested_conversion[concurrent_bit] == 'b':
            binary_translation = str(bin(11))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        elif requested_conversion[concurrent_bit] == 'c':
            binary_translation = str(bin(12))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        elif requested_conversion[concurrent_bit] == 'd':
            binary_translation = str(bin(13))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        elif requested_conversion[concurrent_bit] == 'e':
            binary_translation = str(bin(14))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        elif requested_conversion[concurrent_bit] == 'f':
            binary_translation = str(bin(15))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        else:
            binary_translation = str(bin(int(digit)))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        concurrent_bit += 1
    for portion_index in range(len(list_of_binary_portions)):
        if len(list_of_binary_portions[portion_index]) == 1:
            list_of_binary_portions[portion_index] = "000" + list_of_binary_portions[portion_index]
        elif len(list_of_binary_portions[portion_index]) == 2:
            list_of_binary_portions[portion_index] = "00" + list_of_binary_portions[portion_index]
        elif len(list_of_binary_portions[portion_index]) == 3:
            list_of_binary_portions[portion_index] = "0" + list_of_binary_portions[portion_index]
        else:
            list_of_binary_portions[portion_index] = list_of_binary_portions[portion_index]
    list_of_binary_portions.insert(0, "0b")
    print(*list_of_binary_portions, sep="")

# The function below is a copy of the original but for the purpose of the hex_to_binary_stringversion function.
def hex_to_binary_decimalversion_special(requested_conversion):
    requested_conversion = requested_conversion[2:]
    concurrent_bit = 0
    list_of_binary_portions = []
    for digit in requested_conversion:
        if requested_conversion[concurrent_bit] == 'a':
            binary_translation = str(bin(10))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        elif requested_conversion[concurrent_bit] == 'b':
            binary_translation = str(bin(11))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        elif requested_conversion[concurrent_bit] == 'c':
            binary_translation = str(bin(12))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        elif requested_conversion[concurrent_bit] == 'd':
            binary_translation = str(bin(13))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        elif requested_conversion[concurrent_bit] == 'e':
            binary_translation = str(bin(14))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        elif requested_conversion[concurrent_bit] == 'f':
            binary_translation = str(bin(15))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        else:
            binary_translation = str(bin(int(digit)))
            binary_translation = binary_translation[2:]
            list_of_binary_portions.append(binary_translation)
        concurrent_bit += 1
    for portion_index in range(len(list_of_binary_portions)):
        if len(list_of_binary_portions[portion_index]) == 1:
            list_of_binary_portions[portion_index] = "000" + list_of_binary_portions[portion_index]
        elif len(list_of_binary_portions[portion_index]) == 2:
            list_of_binary_portions[portion_index] = "00" + list_of_binary_portions[portion_index]
        elif len(list_of_binary_portions[portion_index]) == 3:
            list_of_binary_portions[portion_index] = "0" + list_of_binary_portions[portion_index]
        else:
            list_of_binary_portions[portion_index] = list_of_binary_portions[portion_index]
    list_of_binary_portions.insert(0, "0b")
    return "".join(list_of_binary_portions)

import math

def binary_to_hex_decimalversion(requested_conversion):
    requested_conversion = requested_conversion[2:]
    requested_conversion = requested_conversion[::-1]
    splitting_iterations = math.floor(len(requested_conversion) / 4)
    split_binary_product = []
    for split in range(splitting_iterations):
        split_binary_product.append(requested_conversion[:4])
        requested_conversion = requested_conversion[4:]
    if len(requested_conversion) > 0:
        split_binary_product.append(requested_conversion)
    index_of_product = 0
    for i in range(len(split_binary_product)):
        split_binary_product[index_of_product] = split_binary_product[index_of_product][::-1]
        index_of_product += 1
    split_binary_product.reverse()
    index_of_product = 0
    for i in range(len(split_binary_product)):
        binary_to_decimal_special(split_binary_product[index_of_product])
        index_of_product += 1
    index_of_product = 0
    split_hex_products = []
    for i in range(len(split_binary_product)):
        split_hex_products.append(int(split_binary_product[index_of_product], 2))
        index_of_product += 1
    
    for portion_num in range(len(split_hex_products)):
        if split_hex_products[portion_num] == 10:
            split_hex_products[portion_num] = 'a'
        elif split_hex_products[portion_num] == 11:
            split_hex_products[portion_num] = 'b'
        elif split_hex_products[portion_num] == 12:
            split_hex_products[portion_num] = 'c'
        elif split_hex_products[portion_num] == 13:
            split_hex_products[portion_num] = 'd'
        elif split_hex_products[portion_num] == 14:
            split_hex_products[portion_num] = 'e'
        elif split_hex_products[portion_num] == 15:
            split_hex_products[portion_num] = 'f'
        else:
            split_hex_products[portion_num] = split_hex_products[portion_num]
    split_hex_products.insert(0, '0x')
    print(*split_hex_products, sep="")
    
# The function below is a copy of the original but for the purpose of the binary_to_hex_stringversion function.
def binary_to_decimal_special_v2(requested_conversion):
    requested_conversion = requested_conversion[::-1]
    concurrent_bit = 0
    bit_power = 0
    decimal_num = 0
    for digit in requested_conversion:
        if requested_conversion[concurrent_bit] == '1':
            decimal_num += 2 ** bit_power
        else:
            decimal_num += 0
        concurrent_bit += 1
        bit_power += 1
    return decimal_num
    
# The function below is a copy of the original but for the purpose of the binary_to_hex_stringversion function.
def binary_to_hex_decimalversion_special(requested_conversion):
    requested_conversion = requested_conversion[2:]
    requested_conversion = requested_conversion[::-1]
    splitting_iterations = math.floor(len(requested_conversion) / 4)
    split_binary_product = []
    for split in range(splitting_iterations):
        split_binary_product.append(requested_conversion[:4])
        requested_conversion = requested_conversion[4:]
    if len(requested_conversion) > 0:
        split_binary_product.append(requested_conversion)
    index_of_product = 0
    for i in range(len(split_binary_product)):
        split_binary_product[index_of_product] = split_binary_product[index_of_product][::-1]
        index_of_product += 1
    split_binary_product.reverse()
    index_of_product = 0
    for i in range(len(split_binary_product)):
        binary_to_decimal_special_v2(split_binary_product[index_of_product])
        index_of_product += 1
    index_of_product = 0
    split_hex_products = []
    for i in range(len(split_binary_product)):
        split_hex_products.append(int(split_binary_product[index_of_product], 2))
        index_of_product += 1
    
    for portion_num in range(len(split_hex_products)):
        if split_hex_products[portion_num] == 10:
            split_hex_products[portion_num] = 'a'
        elif split_hex_products[portion_num] == 11:
            split_hex_products[portion_num] = 'b'
        elif split_hex_products[portion_num] == 12:
            split_hex_products[portion_num] = 'c'
        elif split_hex_products[portion_num] == 13:
            split_hex_products[portion_num] = 'd'
        elif split_hex_products[portion_num] == 14:
            split_hex_products[portion_num] = 'e'
        elif split_hex_products[portion_num] == 15:
            split_hex_products[portion_num] = 'f'
        else:
            split_hex_products[portion_num] = split_hex_products[portion_num]
    split_hex_products.insert(0, '0x')
    for product in range(len(split_hex_products)):
        split_hex_products[product] = str(split_hex_products[product])
    return "".join(split_hex_products)

def hex_to_binary_stringversion(requested_conversion):
    requested_conversion = requested_conversion.split(" ")
    list_of_chars_in_binary_string = []
    for char_hex_set in requested_conversion:
        binary_converted = hex_to_binary_decimalversion_special(char_hex_set)
        list_of_chars_in_binary_string.append(binary_converted)
    print(*list_of_chars_in_binary_string, sep=" ")

def binary_to_hex_stringversion(requested_conversion):
    requested_conversion = requested_conversion.split(" ")
    list_of_chars_in_hex_string = []
    for char_binary_set in requested_conversion:
        hex_converted = binary_to_hex_decimalversion_special(char_binary_set)
        list_of_chars_in_hex_string.append(hex_converted)
    print(*list_of_chars_in_hex_string, sep=" ")

import sys

def MainMenu():
    while True:
      print("Welcome to the compoooter decipherer. This program can meet all your needs regarding the languages of binary, hexadecimal, and regular decimal/string.\n\n")  
      
      print("""So, in terms of conversions, the following methods are available:\n
    string_to_binary → format exemplar: "Hi"
    decimal_to_binary → format exemplar: 10
    decimal_to_hex → format exemplar: 10
    string_to_hex → format exemplar: "Hi"
    binary_to_decimal → format exemplar: "0b1010"
    binary_to_string → format exemplar: "0b01001000 0b01101001"
    hex_to_decimal → format exemplar: "0xa"
    hex_to_string → format exemplar: "4869"
    hex_to_binary_decimalversion → format exemplar: "0xa"
    hex_to_binary_stringversion → format exemplar: "4869"
    binary_to_hex_decimalversion → format exemplar: "0b1010"
    binary_to_hex_stringversion → format exemplar: "0b01001000 0b01101001"\n""")

      print("\nMake sure to go through all of these, and figure out which ones you want to use. In the exemplars, any time a number is involved in conversion, it is the number '10'. Any time a string is involved in conversion, it is the string 'Hi'. So, let's get to converting!\n\n")

      print("_"*10 + "\n\n")
        
      UseConversion()
        
      print("_"*10 + "\n")
      confirmation = str(input("Would you like to perform another conversion?\n\nType 'Y' for if you would like to go back to the menu, or 'N' if you want to terminate the program: "))
      if confirmation.upper() == 'Y':
          print("\nOkay! Redirecting you back to the beginning.\n\n")
          continue
      elif confirmation.upper() == 'N':
          print("\nOkay! Terminating the program.")
          sys.exit()
      else:
        print("\nInvalid input given. Terminating program anyway.")
        sys.exit()

def UseConversion():
    method = str(input("Above was given a list of the different conversion functions which are usable. So, what method would you like to use?\n\nType the function exactly how it said in the list here:\n\n"))
    print("")
    parameters = str(input("All right, so what are you wanting to convert? Type your conversion request in the appropriate format needed here:\n\n"))
    try:
      print("\nVery well then. The conversion has been performed, and your converted request should be below (if it succeeded):\n")
      eval(method + "(" + parameters + ")")
      print("\n\nGo ahead and use that for whatever you need to. Or, use the converter again with this converted product to convert it to something else!\n")
    except NameError:
      print("\nIt seems you spelt the name of the function incorrectly. Go back to the list above, and type out the function you want to use exactly.\n\n")
      UseConversion()
    except TypeError:
      print("\nIt seems you provided an incorrect input to the conversion. Make sure you are providing the exact format you specified with the function you are trying to use. Also, please go back and refer to the format exemplars in the list above to see how each input for each function should be formatted.\n\n")
      UseConversion()

# Run the program
MainMenu()


# Program that generates a random number:
# Use it to flex or test the limits.
"""import random

num_of_digits = int(input())
randomly_generated_num = []

for iteration in range(num_of_digits+1):
    randomly_generated_num.append(random.randint(0, 9))

print(*randomly_generated_num, sep="")"""

Save snippets that work from anywhere online with our extensions

Available in the Chrome Web Store

Get Firefox Add-on

Get VS Code extension

Comments

More like this

Importing images from a directory (Python) to list or dictionary

from PIL import Image
import glob
image_list = []
for filename in glob.glob('yourpath/*.gif'): #assuming gif
    im=Image.open(filename)
    image_list.append(im)

python - Find out the percentage of missing values in each column in the given dataset - Stack Overflow

percent_missing = df.isnull().sum() * 100 / len(df)
missing_value_df = pd.DataFrame({'column_name': df.columns,
                                 'percent_missing': percent_missing})

#python #python #loops #whileloop

Print the name of 7 days in a week - by using while loop

days = 0
week = [‘Monday’, ‘Tuesday’, ‘Wednesday’, ‘Thursday’, ‘Friday’, ‘Saturday’, 3.‘Sunday’]
while day < 7:
print(“Today is” + week[days])
days += 1

Getting the index of an item in a list containing it in Python

>>> ["foo", "bar", "baz"].index("bar")
1

#python #python #strings #vowels #function

Get vowels in strings

This method gets vowels (‘a’, ‘e’, ‘i’, ‘o’, ‘u’) found in a string.
   
#make a function:
def get_vowels(string):

#return is the keyword which means function have to return value: 
 return [each for each in string if each in 'aeiou']


#assign the words and function will return vowels words.
get_vowels('foobar') # ['o', 'o', 'a']


get_vowels('gym') # []

Could not build wheels for tokenizers which use PEP 517 and cannot be installed directly

https://github.com/pydata/bottleneck/issues/281

How To Bypass Cloudflare Bot Protection In Selenium - CodingTutz

options = webdriver.ChromeOptions()
options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option('useAutomationExtension', False)
options.add_argument("--disable-blink-features=AutomationControlled")
driver = webdriver.Chrome(options=options)

#javascript #python #search #historicalcode #google #algorithms

Google’s PageRank Algorithm from 1996 - the origin of internet search

import numpy as np

def pagerank(M, num_iterations=100, d=0.85):
    N = M.shape[1]
    v = np.random.rand(N, 1)
    v = v / np.linalg.norm(v, 1)
    iteration = 0
    while iteration < num_iterations:
        iteration += 1
        v = d * np.matmul(M, v) + (1 - d) / N
    return v

Python Loop through Excel sheets, place into one df - Stack Overflow

import pandas as pd

sheets_dict = pd.read_excel('Book1.xlsx', sheetname=None)

full_table = pd.DataFrame()
for name, sheet in sheets_dict.items():
    sheet['sheet'] = name
    sheet = sheet.rename(columns=lambda x: x.split('\n')[-1])
    full_table = full_table.append(sheet)

full_table.reset_index(inplace=True, drop=True)

print full_table

#python #dates #functions #python3.8

How to parse a String into Datetime in Python

from datetime import datetime

datetime_object = datetime.strptime('Jun 1 2005  1:33PM', '%b %d %Y %I:%M%p')

python - Way to change Google Chrome user agent in Selenium? - Stack Overflow

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from fake_useragent import UserAgent

options = Options()
ua = UserAgent()
userAgent = ua.random
print(userAgent)
options.add_argument(f'user-agent={userAgent}')
driver = webdriver.Chrome(chrome_options=options, executable_path=r'C:\WebDrivers\ChromeDriver\chromedriver_win32\chromedriver.exe')
driver.get("https://www.google.co.in")
driver.quit()

python - How to see the progress bar of read_csv - Stack Overflow

def read_csv_pgbar(csv_path, chunksize, usecols, dtype=object):


    # print('Getting row count of csv file')

    rows = sum(1 for _ in open(csv_path, 'r')) - 1 # minus the header
    # chunks = rows//chunksize + 1
    # print('Reading csv file')
    chunk_list = []

    with tqdm(total=rows, desc='Rows read: ') as bar:
        for chunk in pd.read_csv(csv_path, chunksize=chunksize, usecols=usecols, dtype=dtype):
            chunk_list.append(chunk)
            bar.update(len(chunk))

    df = pd.concat((f for f in chunk_list), axis=0)
    print('Finish reading csv file')

    return df

#python #python #lists #dictionary

Convert two lists into a dictionary

keys, values)) # {'a': 2, 'c': 4, 'b': 3}
 
 
#make a function: def is the keyword for the function:
def to_dictionary(keys, values):
 
 
#return is the keyword that tells program that function has to return value   
return dict(zip(keys, values))
 
  
 
# keys and values are the lists:
 
keys = ["a", "b", "c"]   
 
values = [2, 3, 4]

Convert string to Enum in Python - Stack Overflow

>>> from enum import Enum
>>> class Build(Enum):
...   debug = 200
...   build = 400
... 

Build['debug']

Raising errors in Python

my_list = [27, 5, 9, 6, 8]

def RemoveValue(myVal):
    if myVal not in my_list:
        raise ValueError("Value must be in the given list")
    else:
        my_list.remove(myVal)
    return my_list

print(RemoveValue(27))
print(RemoveValue(27))

Browse more snippets >>