首页 \ 问答 \ Python二进制操作 - 组合高位和低位(Python binary operations - combine higher and lower order bits)

Python二进制操作 - 组合高位和低位(Python binary operations - combine higher and lower order bits)

 我有两个十六进制值（作为字符串提供）：  
 
  00000000fe000000 < - 高位32位  
  000000000001009f < - 低位32位  
 
 他们需要合并成一个单一的值，理想情况下 - 像值[0:15]（返回0到15，从右到左）方便地处理。  
 在Python中做这件事的最好方法是什么？ 

I have two hex values (provided as strings): 
 
 00000000fe000000 <- high order 32-bits 
 000000000001009f <- low order 32-bits 
 
They need to be combined into a single value, and ideally - conveniently addressed like value[0:15] (returning bits 0 to 15, right to left). 
What is the best way to do this in Python?

原文：https://stackoverflow.com/questions/50451184

更新时间：2023-09-09 16:09

最满意答案

 以下是我要做的事情的草图：  
// Beware, brain-compiled code ahead
template< typename T >
class typed_container
{
  typedef std::vector<T> data_t;
public:
  typedef data_t::iterator iterator;
  iterator begin() {return data_.begin();}
  iterator end  () {return data_.end();}
private:
  data_t data_;
};

typedef my_type_list<A,B,C> types_t;

class master : public derive_from< typed_container, types_t > {
  template< typename T >
  struct traits {
    typedef typename typed_container<T>::iterator iterator;
    iterator begin(typed_container<T>& c) {return c.begin();}
    iterator end  (typed_container<T>& c) {return c.end  ();}
  };
public:
  template< typename T > 
  typename traits<T>::iterator begin() {return traits<T>::begin(*this);}
  template< typename T > 
  typename traits<T>::iterator end  () {return traits<T>::end  (*this);}

  typedef my_assembling_iterator<types_t> iterator;

  iterator begin() {return my_assembling_iterator<types_t>.begin(*this);}
  iterator end  () {return my_assembling_iterator<types_t>.end  (*this);}
};
 
 这让你实现my_type_list （相当简单）， derive_from （不是那么简单，但也不是太难）， my_assembling_iterator （我还没有需要做这样的事情）。  
 
 你可以在这里找到一个可用的C ++ 03类型列表实现。 它最多只需要9个模板参数（但这很容易扩展），而且你必须写  
typedef my_type_list<A,B,C>::result_t types_t
 
 但它很简单，免费，我知道它的工作原理（因为我自己在使用这个库）。  
 derive_from模板看起来像这样：  
//Beware, brain-compiled code ahead!
template< template<typename> class C, class  >
struct derive_from;

template< template<typename> class C >
struct derive_from< C, nil > {};

template< template<typename> class C, typename Head, typename Tail >
struct derive_from< C, my_type_list<Head,Tail> > : public C<Head>
                                                 , public derive_from<C,Tail> {};
 
 这留下了迭代器。 你有什么需要呢？ 它必须是一个随机访问迭代器（硬）还是一个前向迭代器就足够了？ 你是否需要任何特定的顺序来遍历元素？ 

Here's a sketch of what I would do:  
// Beware, brain-compiled code ahead
template< typename T >
class typed_container
{
  typedef std::vector<T> data_t;
public:
  typedef data_t::iterator iterator;
  iterator begin() {return data_.begin();}
  iterator end  () {return data_.end();}
private:
  data_t data_;
};

typedef my_type_list<A,B,C> types_t;

class master : public derive_from< typed_container, types_t > {
  template< typename T >
  struct traits {
    typedef typename typed_container<T>::iterator iterator;
    iterator begin(typed_container<T>& c) {return c.begin();}
    iterator end  (typed_container<T>& c) {return c.end  ();}
  };
public:
  template< typename T > 
  typename traits<T>::iterator begin() {return traits<T>::begin(*this);}
  template< typename T > 
  typename traits<T>::iterator end  () {return traits<T>::end  (*this);}

  typedef my_assembling_iterator<types_t> iterator;

  iterator begin() {return my_assembling_iterator<types_t>.begin(*this);}
  iterator end  () {return my_assembling_iterator<types_t>.end  (*this);}
};
 
That leaves you to implement my_type_list (rather simple), derive_from (not as simple, but not too hard either), and my_assembling_iterator (I hadn't had a need to do something like that yet).  
 
You can find a working C++03 type list implementation here. It only takes up to nine template arguments (but that's easily extended), and you'll have to write  
typedef my_type_list<A,B,C>::result_t types_t
 
but it's simple and free and I know it works (because I'm using this library myself).  
The derive_from template would look something like this:  
//Beware, brain-compiled code ahead!
template< template<typename> class C, class  >
struct derive_from;

template< template<typename> class C >
struct derive_from< C, nil > {};

template< template<typename> class C, typename Head, typename Tail >
struct derive_from< C, my_type_list<Head,Tail> > : public C<Head>
                                                 , public derive_from<C,Tail> {};
 
That leaves the iterator. What are your needs regarding it? Does it have to be a random-access iterator (hard) or would a forward iterator suffice? Do you need any particular order to iterate over the elements?

Python二进制操作 - 组合高位和低位(Python binary operations - combine higher and lower order bits)

最满意答案

相关问答

为什么我们需要容器？(Why do we need containers?)[2022-11-08]

在Delphi XE中使用通用容器 - 总是？(Using Generic containers in Delphi XE - always?)[2021-08-10]

从STL容器继承实现而不是委托吗？(Is it okay to inherit implementation from STL containers, rather than delegate?)[2022-03-06]

2个泊坞容器在1个容器中运行(2 docker containers run in 1 container)[2024-01-30]

docker：是否可以从其他容器运行容器？(docker: is it possible to run containers from an other container?)[2022-08-23]

这个容器的最简洁的实现是什么？(What's the cleanest implementation of this container of typed containers?)[2022-09-03]

ANSI K中的Linux Kernel container_of宏和通用容器(The Linux Kernel container_of macro and generic containers in ANSI-C)[2023-10-31]

包含对象和容器的容器(Container containing Objects and Containers)[2023-04-24]

Eigen的实现是否依赖于标准容器？(Does the implementation of Eigen depend on standard containers?)[2023-05-15]

使用Castle Typed Factory Facility获得具体实施(Using Castle Typed Factory Facility to get specific implementation)[2023-06-29]

相关文章

最新问答