对python进制转换（二进制、十进制和十六进制）及注意事项感兴趣的小伙伴，下面一起跟随编程之家 jb51.cc的小编两巴掌来看看吧！
使用内置函数实现进制转换实现比较简单，主要用到以下函数：
bin()、oct()、int()、hex()
下面分别详解一下各个函数的使用（附实例）
第一部分：其他进制转十进制
1.二进制转十进制
使用函数：int()
实例：
#结果是4
int("100",2)
# End www.jb51.cc
注意：上述一定不要忘记加引号，因为二进制是一个字符串
如果不加引号会出现如下错误：
Traceback (most recent call last):
File "",line 1,in 
int(100,2)
TypeError: int() can"t convert non-string with explicit base
2.八进制转十进制
使用函数：int()
实例：
#结果是4
int("04",8)
# End www.jb51.cc
注意：上述一定不要忘记加引号，因为八进制是一个字符串
3.十六进制转十进制
使用函数：int()
实例：
#结果是4
int("0x4",16)
# End www.jb51.cc
注意：上述一定不要忘记加引号，因为十六进制是一个字符串
第二部分：十进制转其他进制
1.十进制转二进制
使用函数：bin()
bin()函数是讲整数转换成二进制字符串
实例：
#十进制转二进制,其中int（4,10）表示4是一个十进制整数
bin(int("4",10))
#或者,直接输入一个十进制
bin(4)
#结果是：0b100
# End www.jb51.cc
注意：这里的0b100，其实就是100，0b的b是binary的意思
2.十进制转八进制
使用函数： oct()
#这里也要注意，4要加引号表示是一个字符串
oct(int("4",不转换直接输入十进制数
oct(4)
#结果为：04
# End www.jb51.cc
3.十进制转十六进制
使用函数：hex()
实例：
#十进制转十六进制
hex(int("4",10))
#或者
hex(4)
#结果为：0x4
# End www.jb51.cc

本题要求实现一个函数，将正整数n转换为二进制后输出。
 
函数接口定义：
 
void dectobin(int n);
 
函数dectobin应在一行中打印出二进制的n。建议用递归实现。
 
裁判测试程序样例：
 
#include <stdio.h>
void dectobin(int n);
int main()
{
    int n;
    scanf("%d", &n);
    dectobin(n);
    return 0;
}

/* 你的代码将被嵌在这里 */
 
输入样例：
 
 
 
 
10
 521
 
 
输出样例：
 
 
 
 
1010
 1000001001
 
 
[solution]
 
void dectobin(int n)
{
    int sum = 0;
    int y, x = 1; // y表示余数，x为叠加的系数
    while (n != 0)
    {
        y = n % 2;
        sum += x * y;
        x *= 10;
        n /= 2;
    }
    printf("%d", sum);
}
 
循环示意图：
 

 
 
 
进制转换网站安利：
 
 
在线进制转换
 
进制转换（技术方法）
 
 
 
 
1.短除法
 十进制中的数位排列是这样的…… 万 千 百 十 个 十分 百分 千分…… R进制中的数位排列是这样的……R^4 R3R2 R^1 R^0
 R^-1 R^-2 R^-3…… 可以看出相邻的数位间相差进制的一次方。
 任何进制中，每个数都可以按位权展开成各个数位上的数字乘以对应数位的位权，再相加的形式，如：
 十进制的123=1×100+2×10+3×1
 十进制的9876=9×1000+8×100+7×10+6×1
 问：为啥相应的数位是1000、100、10、1？为啥不是4、3、2、1？
 答：十进制，满十进一，再满十再进一，因此要想进到第三位，得有10×10；第4位得有10×10×10
 这样我们就知道了：
 对10进制，从低位到高位，依次要乘以100，101,102,103……，也就是1、10、100、1000
 对2进制，从低位到高位，依次要乘以20，21,22,23……，也就是1、2、4、8、……
 下面我们开始转换进制（以十进制换成二进制为例）：
 原来十进制咱们的数位叫 千位、百位、十位……
 现在二进制数位变成了八位、四位、二位……
 模仿上面十进制按位权展开的方式，把二进制数1011按权展开： 1011=1×23+0×22+1×21+1×20=1×8+0×4+1×2+1×1=8+2+1=11
 接下来我们进行十进制往二进制的转换：
 比较小的数，直接通过拆分就可以转换回去
 比如13，我们把数位摆好八位、四位、二位，不能写十六了，因为一旦“十六”那个数位上的符号是“1”，那就表示有1个16，即便后面数位上的符号全部是“0”，把这个二进制数按权位展开后，在按照十进制的运算规律计算，得到的数也大于13了。那最多就只能包含“八”这个数位。 13-8=5，5当中有4，5-4=1
 好啦，我们知道13=18+14+02+11 把“1”、“1”、“0”“1”这几个符号放到数位上去：
 八位、四位、二位、一位
 1 1 0 1
 于是十进制数13=二进制数1101
 2.递归原理<“乘基取整法”>
 1）一个十进制数321的末尾是1，意味着一定是……+1，省略号部分一定是10的倍数，所以一个十进制数末尾是1意味着十进制数除以进制10一定余1。所以第一次除以10之后的余数，应该放在十进制的最后一个数位“个位”，也就是说个位上的符号是1。
 类比，一个二进制数111（注意，数值不等于上面十进制的111）末尾是1，意味着一定是……+1，前面的省略号部分都是2的倍数。所以一个二进制数末尾是1，意味着它对应的十进制数除以进制2一定余1。所以第一次除以2之后的余数，应该放在二进制的最后一个数位“一位”，也就是说一位上的符号是1。
 2）如果一个十进制数321“十位”是2，我们希望把它转换为（1）的情况。那么我们把这个十进制数的末尾抹掉，也就是减去“个位”上的1，再除以进制10，得到32。这样原来“十位”上的“2”就掉到了“个位”上。再把32做（1）的处理。
 类比，如果一个二进制数111“二位”是1，我们希望把它转换为（1）的情况，那么我们把这个二进制数的末尾抹掉，也就是减去“一位”上的1，再除以进制2，得到11。这样原来“二位”上的“1”就掉到了“一位”上。再把11做（1）的处理。
 总结：其实这个过程就是把各个数位上的符号求出来的过程。
 现在你应该可以回答以下问题了：为什么短除法可以实现进制的转换呢？为什么每次要除以进制呢？为什么要把余数倒着排列呢？
 R进制转换成十进制就是按权位展开，把展开式放到十进制下，再按照“十进制”的运算规律计算。因为是十进制，所以就允许使用2、3、4、5、6、7、8、9了。所以2的n次方就不用写成指数，而可以用另外的八个符号来表示了。
 十进制—>二进制
 对于整数部分，用被除数反复除以2，除第一次外，每次除以2均取前一次商的整数部分作被除数并依次记下每次的余数。另外，所得到的商的最后一位余数是所求二进制数的最高位。
 
 
 
递归解法
 
void dectobin(int n)
{
    if (n == 0)
        printf("0");
    else if (n == 1)
        printf("1");
    else
    {
        dectobin(n / 2); //利用二进制的原理
        printf("%d", n % 2);
    }
}
 
 
不用函数，采用数组的方式
 
【思路】将余数存放在数组中，倒序输出
 
 
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[])
{
    int i = 0, y, n, l = 0; // l记数组长度；
    int str[1000];
    printf("请输入一个数字： \n");
    scanf("%d", &n);
    if (n == 0)
    {
        printf("输出结果： \n");
        printf("0\n");
    }
    else
    {
        while (n != 0)
        {
            str[i] = n % 2;
            n /= 2;
            l++;
            i++;
        }
        printf("输出结果： \n");
        for (i = l - 1; i >= 0; i--)
            printf("%d", str[i]);
        printf("\n");
    }
    return 0;
}
 
 
进一步的数值转换
十进制转任意进制：
 
AC
 
#include <bits/stdc++.h>
using namespace std;
void convto(char *s, int n, int b)
{
    char bit[] = {"0123456789ABCDEF"};
    int len;
    if (n == 0)
    {
        strcpy(s, " ");
        return;
    }
    convto(s, n / b, b);
    len = strlen(s);
    s[len] = bit[n % b];
    s[len + 1] = '\0';
}
int main()
{
    char s[80];
    int i, base, old;
    cout << "请输入十进制数：" << endl;
    cin >> old;
    cout << "请输入转换的进制：" << endl;
    cin >> base;
    convto(s, old, base);
    cout << "转制后：" << endl;
    cout << s << endl;
    system("pause");
    return 0;
}
 
 
or
 
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
//整数幂运算函数
int int_pow(int x, int y)
{
    int i, result = 1;
    for (i = 1; i <= y; i++)
    {
        result *= x;
    }
    return result;
}
//将十进制数转换为任意进制
//参数 dnum 为十进制数，参数 jz 为目标进制
void dtox(int dnum, int jz)
{
    char xnum[100];
    int i = 0, j = 0;
    while (dnum >= jz)
    {
        if (dnum % jz <= 9)
            xnum[j++] = dnum % jz + 48;
        else
            xnum[j++] = dnum % jz - 10 + 'A';
        dnum /= jz;
    }
    if (dnum <= 9)
        xnum[j] = dnum + '0';
    else
        xnum[j] = dnum - 10 + 'A';
    for (i = j; i >= 0; i--)
    {
        cout << xnum[i];
    }
}

//将输入的数转换为十进制
//参数 num 是一个数组，保存输入的字符串，参数 jz 为源数据的进制
int xtod(char num[], int jz)
{
    int dnum = 0, i, n = 0, b;
    for (i = 0;; i++)
    {
        if (num[i] == '\0')
            break;
        else
            n++;
    }
    for (i = n - 1; i >= 0; i--)
    {
        if (num[n - i - 1] >= 'a')
            b = num[n - i - 1] - 'a' + 10;
        else if (num[n - i - 1] >= 'A')
            b = num[n - i - 1] - 'A' + 10;
        else
            b = num[n - i - 1] - '0';
        dnum += b * int_pow(jz, 1);
    }
    return dnum;
}
//主函数
int main()
{
    char num[100];
    int jz1, jz2;
    printf("输入要转换的数：");
    scanf("%s", num);
    printf("输入数的进制: ");
    scanf("%d", &jz1);
    printf("要转换的进制：");
    scanf("%d", &jz2);
    dtox(xtod(num, jz1), jz2);
    getchar();
    return 0;
}

C语言十进制转换二进制，用顺序栈实现。
 完整代码如下：
 
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 20 //静态顺序栈存储的最大空间 

typedef struct
{
	int data[MAXSIZE];//静态顺序栈可用的最大容量 
	int top;//栈顶
}SqStack;

void InitStack(SqStack &S)//栈的初始化 
{
	S.top = -1;//静态顺序栈中，使S.top=-1便是对栈的初始化 
}

int Push(SqStack &S,int e)//进栈 
{
	if(S.top==MAXSIZE-1)//判断栈是否为满 
	{
		printf("栈满！\n");
		return 0;
	}
	S.data[++S.top]=e;//S.top自加一，使S.top=0,使输入的e值导入栈中 
	return 0; 
}

void Pop(SqStack &S)//使栈顶元素出栈，并输出栈顶元素，且栈长减一 
{
	if(S.top == -1)//判断栈是否为空 
		printf("栈空！\n");
	else 
		printf("%d",S.data[S.top--]);//输出栈顶元素 
}

void Binary(SqStack S)//十进制转二进制函数 
{
	int a,
		i = 0;
	printf("请输入十进制数： "); 
	scanf("%d",&a);//输入任意的十进制数 
	while(a)//循环结束条件是a为0 
	{
		Push(S,a%2);//余数进栈 
		a = a/2;//由于是整数形式，不存在除不尽的状况，假设a=1,除2等于0 
		i++;//记录进栈多少次 ，方便出栈操作 
	}
	while(i)//循环终止条件是i为0 
	{
		Pop(S);//依次输出栈顶元素 
		i--;
	}
}

int main()
{
	SqStack S;
	InitStack(S);//创建一个栈，并初始化 
	Binary(S);//进制转换 
	return 0;
}
 
（完）

1、解题思路
 在纸上做过十进制转二进制的朋友应该都用的都是除二取余的方法，写出每一次的余数知道0为止再从下至上依次读取余数即可，类似下图
 根据观察可知十进制转换为二进制的问题属于我上一篇文章所提到的“套娃问题”且十进制转二进制（整数部分）需要从下往上读也就是可以利用递归向上传递的特点，所以用递归来解决，具体思路为
 1、若当前数小于2则直接输出。
 2、若当前数大于等于2，则通过对当前数（比如上图第一步的20）对2取余的得到该位所对应的数（0或1），再对其除二继续计算直到1为止。
 根据递归的向上传递特点，最终得到的数字会依次从下至上输出并的到结果。
 
2、代码实现
 
#include <stdio.h>

int trans(int x);

int main()
{

    int x;
    scanf("%d",&x);
    trans(x);
    
    return 0;
}

int trans(int num)
{
    int a;
    if(num<2)
    {
        printf("%d",num);
    }
    else
    {
        a=num%2; //取余得到对应的数字
        num=num/2;//除二进行下一步计算
        trans(num);
        printf("%d",a);
    }
    return 0;
}

 
至此问题就解决了，这段代码也可以解决十进制转换为二到九进制的转换，把trans函数中的2改为对应数字即可，原理一样。