Question

我已经使用波形模块从波形文件中读取样本，但是它将样本作为字符串提供，它不在波形中，因此它是小端（例如，\x00）。

将此转换为python整数或numpy.int16类型的最简单方法是什么？（它最终将成为numpy.int16，所以直接进入那里很好。）

代码需要适用于小端和大端处理器。

Answer 1

struct模块将打包数据转换为Python值，反之亦然。

>>> import struct
>>> struct.unpack("<h", "\x00\x05")
(1280,)
>>> struct.unpack("<h", "\x00\x06")
(1536,)
>>> struct.unpack("<h", "\x01\x06")
(1537,)

“h”表示short int或16位int。 “＆LT;”意思是使用little-endian。

Answer 2

如果你必须将一个或少量的2字节字符串转换为整数，那么

struct就可以了，但array和numpy本身是更好的选择。具体来说，numpy.fromstring（使用适当的dtype参数调用）可以直接将字符串中的字节转换为数组（无论dtype是什么）。（如果numpy.little_endian为false，则必须交换字节 - 请参阅here以获取更多讨论，但基本上您需要在数组对象上调用byteswap方法你刚刚用fromstring建立。

Answer 3

Kevin Burke's answer在您的二进制字符串表示单个短整数时，此问题非常有用，但是如果您的字符串包含表示多个整数的二进制数据，则您需要为每个附加整数添加一个附加的“ h”字符串代表。

对于Python 2

转换代表 2个整数

的Little Endian字符串

import struct
iValues = struct.unpack("<hh", "\x00\x04\x01\x05")
print(iValues)

输出：（1024，1281）

转换代表 3个整数

的Little Endian字符串

import struct
iValues = struct.unpack("<hhh", "\x00\x04\x01\x05\x03\x04")
print(iValues)

输出：（1024、1281、1027）

显然，总是猜测需要多少个“ h”字符是不现实的，所以：

import struct

# A string that holds some unknown quantity of integers in binary form
strBinary_Values = "\x00\x04\x01\x05\x03\x04"

# Calculate the number of integers that are represented by binary string data
iQty_of_Values = len(strBinary_Values)/2

# Produce the string of required "h" values
h = "h" * int(iQty_of_Values)

iValues = struct.unpack("<"+h, strBinary_Values)
print(iValues)

输出：（1024、1281、1027）

对于Python 3

import struct

# A string that holds some unknown quantity of integers in binary form
strBinary_Values = "\x00\x04\x01\x05\x03\x04"

# Calculate the number of integers that are represented by binary string data
iQty_of_Values = len(strBinary_Values)/2

# Produce the string of required "h" values
h = "h" * int(iQty_of_Values)

iValues = struct.unpack("<"+h, bytes(strBinary_Values, "utf8"))
print(iValues)

输出：（1024、1281、1027）

Answer 4

package factorielRecursiveTerminale;

import java.math.BigInteger;
import java.util.Scanner; 

public class factorielRecursiveTerminale {  
static BigInteger factoriel(BigInteger n, BigInteger m) {       //calcule le factoriel pour n'importe quel entier.  
    if (n.compareTo(BigInteger.ZERO) < 1) return m;             //    théoriquement valide pour tout entier dont n! < 2^2147483647, mais 
    return factoriel(n.subtract(BigInteger.ONE), n.multiply(m));//    limité par la capacité de la pile (à cause de la récursion). 
}                                                               

static BigInteger fact(int n) {                                 //convertir l'entree en BigInteger et lancer la recursion
    if(n < 0) {
        return BigInteger.valueOf(-1);
    }
    BigInteger b = BigInteger.valueOf(n);
    return factoriel(b, BigInteger.ONE);
}

public static void main(String[] args) {                        //demonstration
    String valeurRecu = "";
    int valeur;
    BigInteger resultat;
    System.out.println("Calcul Factoriel\n");
    while(!valeurRecu.contentEquals("q")){
        System.out.println("Entrer la valeur a calculer (q - quitter) : ");
        Scanner entree = new Scanner(System.in);
        valeurRecu = entree.nextLine();
        if (valeurRecu.contentEquals("q")) entree.close();
        else {
            try {
                valeur = Integer.parseInt(valeurRecu);
            } catch (NumberFormatException e){  
                System.out.println("Pas un entier. Essayer encore.\n");
                continue;
              } 
            try {
                resultat = fact(valeur);
                if(resultat.compareTo(BigInteger.valueOf(-1)) == 0) {
                    System.out.println("Valeur negative. Essayer encore.\n");
                }
                else System.out.println("Factoriel " + valeur + " -> " + fact(valeur) + "\n");
            }
        } catch(StackOverflowError e) {
            System.out.println("Depassement de la pile. Essayer encore.\n");
        }
        }
    }
    System.out.println("Au revoir! :)\n");
  }
}

例如：

Calcul Factoriel

Entrer la valeur a calculer (q - quitter) : 0
Factoriel 0 -> 1

Entrer la valeur a calculer (q - quitter) : 1
Factoriel 1 -> 1

Entrer la valeur a calculer (q - quitter) : 2
Factoriel 2 -> 2

Entrer la valeur a calculer (q - quitter) : 3
Factoriel 3 -> 6

Entrer la valeur a calculer (q - quitter) : 4
Factoriel 4 -> 24

Entrer la valeur a calculer (q - quitter) : 10
Factoriel 10 -> 3628800
    
Entrer la valeur a calculer (q - quitter) : 8000
Factoriel 8000 -> 518418106.......

Entrer la valeur a calculer (q - quitter) : 9050
Factoriel 9050 -> 480838025.......

Entrer la valeur a calculer (q - quitter) : 9100
Factoriel 9100 -> 

Entrer la valeur a calculer (q - quitter) : 31400
Factoriel 31400 -> 

Entrer la valeur a calculer (q - quitter) : 31401
Depassement de la pile. Essayer encore.

int(value[::-1].hex(), 16)反转值（小端），value = b'\xfd\xff\x00\x00\x00\x00\x00\x00' print(int(value[::-1].hex(), 16)) 65533 trabnsform转换为十六进制文字，[::-1]从十六进制文字转换为int base16。

将little endian字符串转换为整数

4 个答案: