Как определить, работает ли моя оболочка python в 32-битном или 64-битном режиме на OS X?

Мне нужен способ сказать, в каком режиме оболочка находится внутри оболочки.

Я попытался взглянуть на модуль платформы, но кажется, что он говорит только о "битовой архитектуре и формате связи, используемом для исполняемого файла": хотя двоичный файл скомпилирован как 64-битный (я работаю на OS X 10.6), поэтому Кажется, он всегда сообщает о 64-битном, хотя я использую методы, описанные здесь, чтобы форсировать 32-битный режим).

Источник

19 ответов

Решение

ОБНОВЛЕНО: Один из способов - посмотреть на sys.maxsize как задокументировано здесь:

$ python-32 -c 'import sys;print("%x" % sys.maxsize, sys.maxsize > 2**32)'
('7fffffff', False)
$ python-64 -c 'import sys;print("%x" % sys.maxsize, sys.maxsize > 2**32)'
('7fffffffffffffff', True)

sys.maxsize был введен в Python 2.6. Если вам нужен тест для более старых систем, этот немного более сложный тест должен работать на всех выпусках Python 2 и 3:

$ python-32 -c 'import struct;print( 8 * struct.calcsize("P"))'
32
$ python-64 -c 'import struct;print( 8 * struct.calcsize("P"))'
64

Кстати, вы могли бы испытать желание использовать platform.architecture() за это. К сожалению, его результаты не всегда надежны, особенно в случае OS X универсальных двоичных файлов.

$ arch -x86_64 /usr/bin/python2.6 -c 'import sys,platform; print platform.architecture()[0], sys.maxsize > 2**32'
64bit True
$ arch -i386 /usr/bin/python2.6 -c 'import sys,platform; print platform.architecture()[0], sys.maxsize > 2**32'
64bit False
Источник

При запуске интерпретатора Python в терминале / командной строке вы также можете увидеть строку вроде:

Python 2.7.2 (default, Jun 12 2011, 14:24:46) [MSC v.1500 64 bit (AMD64)] on win32

куда [MSC v.1500 64 bit (AMD64)] означает 64-битный Python. Работает для моей конкретной настройки.

Источник

В основном вариант ответа Мэтью Маршалла (со структурой из std.library):

import struct
print struct.calcsize("P") * 8
Источник

Попробуйте использовать ctypes, чтобы получить размер пустого указателя:

import ctypes
print ctypes.sizeof(ctypes.c_voidp)

Это будет 4 для 32 бит или 8 для 64 бит.

Источник

Откройте консоль Python:

import platform
platform.architecture()[0]

он должен отображать "64-битный" или "32-битный" в зависимости от вашей платформы.

Альтернативно( в случае двоичных файлов OS X):

import sys
sys.maxsize > 2**32 
# it should display True in case of 64bit and False in case of 32bit
Источник

В моей системе Centos Linux я сделал следующее:

1) Запустил интерпретатор Python (я использую 2.6.6)
2) Запустил следующий код:

import platform
print(platform.architecture())

и это дало мне

(64bit, 'ELF')
Источник

Группируем все...

Учитывая, что:

  • Вопрос задается для OSX (у меня старая (и взломанная) ВМ с древней версией Python)
  • Моя главная цель - победа
  • У меня установлена ​​только 32-битная версия на Win (и я построил " урезанную" версию на Lnx)

Я собираюсь привести примеры на всех 3 платформах. Я буду использовать Python3 и Python2. Тем не менее, URL документа будут специфичны для Python3.

  1. Проверьте [Python 3]: sys. maxsize value - сравните его с 0x100000000 (2 ** 32): больше для 64 бит, меньше для 32 бит:
    • OSX 9 x64:
      • Python 2.7.10 x64: 
        >>> import sys
>>> "Python {:s} on {:s}".format(sys.version, sys.platform)
'Python 2.7.10 (default, Oct 14 2015, 05:51:29) \n[GCC 4.8.2] on darwin'
>>> hex(sys.maxsize), sys.maxsize > 0x100000000
('0x7fffffffffffffff', True)
    • Убту 16 х64:
      • Python 3.5.2 x64: 
        >>> import sys
>>> "Python {:s} on {:s}".format(sys.version, sys.platform)
'Python 3.5.2 (default, Nov 23 2017, 16:37:01) \n[GCC 5.4.0 20160609] on linux'
>>> hex(sys.maxsize), sys.maxsize > 0x100000000
('0x7fffffffffffffff', True)
      • Python 3.6.4 x86: 
        >>> import sys
>>> "Python {:s} on {:s}".format(sys.version, sys.platform)
'Python 3.6.4 (default, Apr 25 2018, 23:55:56) \n[GCC 5.4.0 20160609] on linux'
>>> hex(sys.maxsize), sys.maxsize > 0x100000000
('0x7fffffff', False)
    • Выиграй 10 х64:
      • Python 3.5.4 x64: 
        >>> import sys
>>> "Python {:s} on {:s}".format(sys.version, sys.platform)
'Python 3.5.4 (v3.5.4:3f56838, Aug  8 2017, 02:17:05) [MSC v.1900 64 bit (AMD64)] on win32'
>>> hex(sys.maxsize), sys.maxsize > 0x100000000
('0x7fffffffffffffff', True)
      • Python 3.6.2 x86: 
        >>> import sys
>>> "Python {:s} on {:s}".format(sys.version, sys.platform)
'Python 3.6.2 (v3.6.2:5fd33b5, Jul  8 2017, 04:14:34) [MSC v.1900 32 bit (Intel)] on win32'
>>> hex(sys.maxsize), sys.maxsize > 0x100000000
('0x7fffffff', False)


  1. Используйте [Python 3]: struct. calcsize (fmt) для определения размера объекта, созданного в формате (указателя). Другими словами, определяет размер указателя (sizeof(void*)):
    • OSX 9 x64:
      • Python 2.7.10 x64: 
        >>> import struct
>>> truct.calcsize("P") * 8
64
    • Убту 16 х64:
      • Python 3.5.2 x64: 
        >>> import struct
>>> truct.calcsize("P") * 8
64
      • Python 3.6.4 x86: 
        >>> import struct
>>> truct.calcsize("P") * 8
32
    • Выиграй 10 х64:
      • Python 3.5.4 x64: 
        >>> import struct
>>> truct.calcsize("P") * 8
64
      • Python 3.6.2 x86: 
        >>> import struct
>>> truct.calcsize("P") * 8
32


  1. Используйте [Python 3.5]: ctypes - библиотека сторонних функций для Python. Это также сводится к определению размера указателя (sizeof(void*)). Как примечание, ctypes использует # 2. (не обязательно для этой задачи) через "$ {PYTHON_SRC_DIR} / Lib / ctypes / __ init__.py" (вокруг строки № 15):
    • OSX 9 x64:
      • Python 2.7.10 x64: 
        >>> import ctypes
>>> ctypes.sizeof(ctypes.c_void_p) * 8
64
    • Убту 16 х64:
      • Python 3.5.2 x64: 
        >>> import ctypes
>>> ctypes.sizeof(ctypes.c_void_p) * 8
64
      • Python 3.6.4 x86: 
        >>> import ctypes
>>> ctypes.sizeof(ctypes.c_void_p) * 8
32
    • Выиграй 10 х64:
      • Python 3.5.4 x64: 
        >>> import ctypes
>>> ctypes.sizeof(ctypes.c_void_p) * 8
64
      • Python 3.6.2 x86: 
        >>> import ctypes
>>> ctypes.sizeof(ctypes.c_void_p) * 8
32


  1. [Python 3]: платформа. архитектура (исполняемый = sys.executable, bits = '', linkage = '') !!! НЕ надежен на OSX!!! из-за формата многоархивированного исполняемого файла (или .dylib) (в некоторых случаях используется # 2.):
    • OSX 9 x64:
      • Python 2.7.10 x64: 
        >>> import platform
>>> platform.architecture()
('64bit', '')
    • Убту 16 х64:
      • Python 3.5.2 x64: 
        >>> import platform
>>> platform.architecture()
('64bit', 'ELF')
      • Python 3.6.4 x86: 
        >>> import platform
>>> platform.architecture()
('32bit', 'ELF')
    • Выиграй 10 х64:
      • Python 3.5.4 x64: 
        >>> import platform
>>> platform.architecture()
('64bit', 'WindowsPE')
      • Python 3.6.2 x86: 
        >>> import platform
>>> platform.architecture()
('32bit', 'WindowsPE')


  1. Lame workaround (gainarie) - вызвать внешнюю команду ( [man7]: FILE (1)) через [Python 3]: os. система (команда). Ограничения № 4. применить (иногда это может даже не работать):
    • OSX 9 x64:
      • Python 2.7.10 x64: 
        >>> import os
>>> os.system("file {:s}".format(os.path.realpath(sys.executable)))
/opt/OPSWbuildtools/2.0.6/bin/python2.7.global: Mach-O 64-bit executable x86_64
    • Убту 16 х64:
      • Python 3.5.2 x64: 
        >>> import os
>>> os.system("file {:s}".format(os.path.realpath(sys.executable)))
/usr/bin/python3.5: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=59a8ef36ca241df24686952480966d7bc0d7c6ea, stripped
      • Python 3.6.4 x86: 
        >>> import os
>>> os.system("file {:s}".format(os.path.realpath(sys.executable)))
/home/cfati/Work/Dev/Python-3.6.4/python: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=5c3d4eeadbd13cd91445d08f90722767b0747de2, not stripped
    • Выиграй 10 х64:
      • файловой утилиты нет, есть другие сторонние инструменты, которые можно использовать, но я не буду на них настаивать


Выиграть конкретно:

  1. Проверьте env vars (например, % PROCESSOR_ARCHITECTURE% (или другие)) через [Python 3]: os. Окружающая среда:
    • Выиграй 10 х64:
      • Python 3.5.4 x64: 
        >>> import os
>>> os.environ["PROCESSOR_ARCHITECTURE"]
'AMD64'
      • Python 3.6.2 x86: 
        >>> import os
>>> os.environ["PROCESSOR_ARCHITECTURE"]
'x86'


  1. [Python 3]: sys. версия (также отображается в 1- й строке при запуске переводчика)
    • Проверьте № 1.
Источник

Непрограммное решение можно найти в мониторе активности. В нем перечислены архитектуры 64-разрядных процессов как "Intel (64-разрядные)".

Источник

В ОС Windows

Откройте терминал cmd и запустите интерпретатор python, набрав>python, как показано на изображении ниже.

Если информация интерпретатора при запуске содержит AMD64, это 64-разрядная версия, в противном случае - 32-разрядная версия.

Источник

Для 32 бит он вернет 32, а для 64 бит вернет 64

import struct
print(struct.calcsize("P") * 8)
Источник

Попробуй это:

      import platform
platform.architecture()
Источник

Сделать python -VVв командной строке. Он должен вернуть версию.

Источник

platform.architecture() заметки говорят:

Примечание. В Mac OS X (и, возможно, на других платформах) исполняемые файлы могут быть универсальными файлами с несколькими архитектурами.

Чтобы получить "64-битность" текущего интерпретатора, более надежно запросить атрибут sys.maxsize:

import sys
is_64bits = sys.maxsize > 2**32
Источник

Основываясь на ответе abe32,

import sys
n_bits = 32 << bool(sys.maxsize >> 32)

n_bits будет иметь 32 или 64 бита.

Источник

struct.calcsize("P") возвращает размер байтов, необходимых для хранения одного указателя. В 32-битной системе он вернул бы 4 байта. В 64-битной системе он вернул бы 8 байтов.

Таким образом, следующее вернется 32 если вы используете 32-битный Python и 64 если вы работаете с 64-битным питоном:

Python 2

import struct;print struct.calcsize("P") * 8

Python 3

import struct;print(struct.calcsize("P") * 8)
Источник 
import sys
print(sys.version)

3.5.1 (v3.5.1:37a07cee5969, 6 декабря 2015, 01:54:25) [MSC v.1900 64 бит (AMD64)]

Источник 
C:\Users\xyz>python

Python 2.7.6 (default, Nov XY ..., 19:24:24) **[MSC v.1500 64 bit (AMD64)] on win
32**
Type "help", "copyright", "credits" or "license" for more information.
>>>

после удара питона в cmd

Источник

Архитектура платформы не является надежным способом. Вместо нас:

$ arch -i386 /usr/local/bin/python2.7
Python 2.7.9 (v2.7.9:648dcafa7e5f, Dec 10 2014, 10:10:46)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import platform, sys
>>> platform.architecture(), sys.maxsize
(('64bit', ''), 2147483647)
>>> ^D
$ arch -x86_64 /usr/local/bin/python2.7
Python 2.7.9 (v2.7.9:648dcafa7e5f, Dec 10 2014, 10:10:46)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import platform, sys
>>> platform.architecture(), sys.maxsize
(('64bit', ''), 9223372036854775807)
Источник

platform.architecture() проблематично (и дорого).

Удобно проверить sys.maxsize > 2**32 начиная с Py2.6 .

Это надежный тест на фактический (по умолчанию) размер указателя, совместимый по крайней мере с Py2.3: struct.calcsize('P') == 8. Также:ctypes.sizeof(ctypes.c_void_p) == 8.

Примечания: могут быть сборки с опцией gcc -mx32или около того, которые являются приложениями с 64-битной архитектурой, но по умолчанию используют 32-битные указатели (экономия памяти и скорости). 'sys.maxsize = ssize_t' не может строго представлять размер указателя C (обычно это2**31 - 1тем не мение). И были / есть системы, которые имеют разные размеры указателей для кода и данных, и необходимо уточнить, в чем именно заключается цель различения "32-битного или 64-битного режима?"

Источник
Другие вопросы по тегам