Example Code:

# Author: Huahua
class MyListIterator:
  def __init__(self, my_list, index=0):
    self.my_list = my_list
    self.index = index

  def __next__(self):
    if self.index < len(self.my_list.data):
      val = self.my_list.data[self.index]
      self.index += 1
      return val
    else:
      raise StopIteration()

  def __iter__(self):
    return MyListIterator(self.my_list, self.index)
    # return self

class MyList:
  def __init__(self, data):
    self.data = list(data)

  def __getitem__(self, index):
    return self.data[index]

  def __len__(self):
    return len(self.data)

  def __iter__(self):
    return MyListIterator(self)

my_list = MyList([1,2,3,4,5])
it = iter(my_list)
next(it)
it2 = iter(it)
next(it)
print('--- it ---')
for x in it:
  print(x) # 3, 4, 5
print('--- it2 ---')
for x in it2:
  print(x) # 2, 3, 4, 5

The post Iterables in Python appeared first on Huahua's Tech Road.

// Author: Huahua
import re
import io

# Example 1:
a = [0] * 100
if len(a) > 10:
  print(f"List is too long ({len(a)} elements, expected <= 10)")

n = len(a)
if n > 10:
  print(f"List is too long ({n} elements, expected <= 10)")

if (x := len(a)) > 10:
  print(f"List is too long ({x} elements, expected <= 10)")

# Example 2, bad
ads = "Now 20% off till 6/18"

m1 = re.search(r'(\d+)% off', ads)
discount1 = float(m1.group(1)) / 100 if m1 else 0.0

discount2 = float(m2.group(1)) / 100 if (m2 := re.search(r'(\d+)% off', ads)) else 0.0

print(f'{discount1 = }, {discount2 = }')

# Example 3
f1 = io.StringIO("123456789")
x1 = f1.read(4)
while x1 != '':
  print(x1)
  x1 = f1.read(4)

f2 = io.StringIO("123456789")
while (x2 := f2.read(4)) != '':
  print(x2)

# Example 4
prog_langs = {'c++', 'python', 'java'}
langs = ['C++', 'Java', 'PYthon', 'English', '中文']

l1 = [lang.lower() for lang in langs if lang.lower() in prog_langs]
print(l1)

l2 = [l for lang in langs if (l := lang.lower()) in prog_langs]
print(l2)

The post := 海象运算符 Walrus Operator – Python Weekly EP2 appeared first on Huahua's Tech Road.

name = 'Huahua'
score = 123.456789

print('name = ' + name + ', score = ' + str(score))
print('name = %s, score = %.3f' % (name, score))
print('name = {name}, score = {score:.3f}'.format(name=name, score=score))
print('name = {name}, score = {score:.3f}'.format(name='Huahua', score=123.456789))

print(f'name = {name}, score = {score:.3f}') # Python 3.6
print(f'{name = }, {score = :.3f}') # Python 3.8

def add(a, b):
  return a + b

k = 1
print(f'{k = }, {add(k, 2) = }') # k = 1, add(k, 2) = 3

The post f-String in Python3 appeared first on Huahua's Tech Road.

我们知道Python中也有int类，而且非常好用，原生支持高精度计算。但是Python中的一个整型到底占用多少字节呢？我相信绝大多数的Python程序员从未想过这一点，越是习以为常的东西越是不会在意它的存在。

在Python中，如果想要知道一个对象所占用的内存大小，只需要使用sys.getsizeof这个API就可以了。那就让我们来试一下不同的整数

print(sys.getsizeof(0))        # 24
print(sys.getsizeof(1))        # 28 
print(sys.getsizeof(2))        # 28
print(sys.getsizeof(2**15))    # 28
print(sys.getsizeof(2**30))    # 32
print(sys.getsizeof(2**128))   # 44

从上面的小实验可以看出，一个整型最少要占24字节(0)，1开始就要占用28个字节，到了2的30次方开始要占用32个字节，而2的128次方则要占用44个字节。我们可以得到两点规律，1. 字节数随着数字增大而增大。2. 每次的增量是4个字节。 好像至此已经回答了我们的题目中的问题：Python中的整型占多少个字节？答案是：变长的（相对于int32的定长），而且最少24个字节。

你以为本文到这里就结束了吗？那你就图样图森破了。一个整型数2，居然要占用28个字节！这完全了颠覆了我的认知，我一定搞清楚为什么。 在哥们的帮助下，我找到了Python的源码。 https://github.com/python/cpython

Python的官方实现是C语言，所以叫cpython。这也就意味着只要Python还在，C就会不消失。其他实现还有jython(Java), IronPython (.Net), PyPy (Python)。

第一件事情要搞清楚的是Python中int类型在cpython的名字是什么？看了半天，在 longobject.h 中发现了一个叫 PyLongObject 的结构体。然而它只是一个马甲，是 _longobject的别名。在longintrepr.h中找到了 _longobject 的定义如下：

struct _longobject {
     PyObject_VAR_HEAD
     digit ob_digit[1];
 };

在文件的开头就看到了typedef uint32_t digit;，digit就是unit32_t, 每个元素占4个字节。但PyObject_VAR_HEAD又是什么鬼？在object.h中发现了它是个宏，上面的注释倒是挺有意思的。

/* PyObject_VAR_HEAD defines the initial segment of all variable-size
 container objects.  These end with a declaration of an array with 1
 element, but enough space is malloc'ed so that the array actually
 has room for ob_size elements.  Note that ob_size is an element count,
 not necessarily a byte count.
 */ 
 define PyObject_VAR_HEAD      PyVarObject ob_base;

等一下，PyVarObject又是什么？还好定义就在下面。

typedef struct {
     PyObject ob_base;
     Py_ssize_t ob_size; /* Number of items in variable part */
 } PyVarObject;

又一层嵌套，是不是已经晕了，继续查看PyObject的定义，这次反而在上面了。

typedef struct _object {
     _PyObject_HEAD_EXTRA
     Py_ssize_t ob_refcnt;
     struct _typeobject *ob_type;
 } PyObject;

有完没完啊？_PyObject_HEAD_EXTRA又是什么？看了一下发现它只在debug build中有定义，这里就不展开了。Py_ssize_t等于ssize_t如果有定义的话， ssize_t在64位的机器上就是long。_typeobject又是什么？感觉应该非常大，不然就不会用指针了。不过话说回来，既然用了指针，我又何必去关心它是什么呢？反正就是8个字节而已，指向一个内存地址。至此真相大了一个白，如果我们把structs flatten, PyLongObject 定义如下：

struct PyLongObject {
  long ob_refcnt;                // 8 bytes
  struct _typeobject *ob_type;   // 8 bytes
  long ob_size;                  // 8 bytes
  unsigned int ob_digit[1];      // 4 bytes * abs(ob_size)
};

ob_refcnt引用计数 8个字节，ob_type类型信息 8个字节（指针），ob_size变长部分元素的个数，8个字节。ob_digit变长的数据部分，字节数为4*abs(ob_size)，ob_size可以为0，所以最少8+8+8=24字节，每次增量都是4 (unsigned int) 的倍数。这和我们之前观察到的实验结果吻合。

以上都是基于64位的Python，对于32位的版本，定义如下：

struct PyLongObject {
  int ob_refcnt;                // 4 bytes
  struct _typeobject *ob_type;  // 4 bytes
  int ob_size;                  // 4 bytes
  unsigned short ob_digit[1];   // 2 bytes * abs(ob_size)
};

32位就要比64位小很多了，最少12个字节，增量为2个字节。

好了，今天就写到这里。相信你对整型数或者Python有了一个新的认识。下面一篇我们会将会介绍整型数在Python中的表示和计算。

The post Python中的整型占多少个字节？ appeared first on Huahua's Tech Road.