不同文件为入口文件时

  • 文件一（fruit.py）：

    1
    2
    3
    4
    5
    6
    7
    # file: fruit.py
    class Apple:
    	def __init__(self):
    		name = "HongFuShi"

    apple = Apple()
    print apple.__class__

  • 文件二（run.py）：

    1
    2
    # file: run.py
    import fruit

  • 考虑一个文件名为 fruit.py 的文件夹中定义了一个类Apple，同时初始化一个对象apple

    • 若执行 python fruit.py：
      • 输出 “main.Apple”
    • 若将当前文件导入到另一个文件 run.py 中，然后执行python run.py：
      • 输出 “fruit.Apple”
    • 也就是说，执行不同文件，类 Apple 的前缀不同

跨文件类中isinstance函数的困境

  • 困境说明：isinstance的困境：看起来是同一个类，但执行isinstance后返回False

  • 文件一（fruit.py）：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    # file: fruit.py
    class Apple(object):
    	pass

    if __name__ == "__main__":
    	from getapple import get_apple # 注意，这里 import 必须放到 "__main__" 中，不能放到外面，否则会发生文件的递归依赖，出现初始化错误
    	apple1 = Apple() 
    	print apple1.__class__ # <class '__main__.Apple'>
    	apple2 = get_apple()
    	print apple2.__class__ # <class 'fruit.Apple'>
    	print isinstance(apple2, Apple) # False

  • 文件二（getapple.py）：

    1
    2
    3
    4
    5
    6
    7
    # file: getapple.py
    from fruit import Apple

    def get_apple():
    	apple = Apple()
    	print apple.__class__ # <class 'fruit.Apple'>
    	return apple

  • 此时执行 python getapple.py，无任何输出（符合预期，因为这里 getapple.py 只是用于定义函数）

  • 若执行 python fruit.py，则输出如下：

    1
    2
    3
    4
    <class '__main__.Apple'>
    <class 'fruit.Apple'>
    <class 'fruit.Apple'>
    False
    • 此时 fruit.py 是程序的入口文件
    • 在入口文件中执行 apple1 = Apple() 后得到的类将是 __main__.Apple
    • 在入口文件被导入到 getapple.py 文件中后，执行 apple2 = Apple() 后得到的类将是 fruit.Apple
    • 此时，由于下面的原因造成 isinstance(apple2, Apple) 返回 False
      • apple2 的类别是 fruit.Apple（在 getapple.py 中定义的）
      • Apple 是 __main__.Apple（在 fruit.py 中定义的）

  • isinstance的困境总结：看起来是同一个类，但执行isinstance后返回False

C++中不同类型的数字有自己不同的边界和范围,Python中呢?如何判断边界问题?

最大最小整数

C++

1
2
int minInt = 0x80000000;
int maxInt = 0xffffffff

Python

1
2
minInt = -0xffffffff
maxInt = 0xffffffff

  • Python中int大小为24个字节,数字太大时不会越界,会变为long类型,long类型的字节占位可以非常大(24以下为int,之后为long,分别可以为36,44,52,60等,每次8位递加?),不会越界

    • 测试:当一个数字太大时,使用int(a)强制字符转换也不能将数字转换为int类型,将一直为long类型
    • 测试: Python中24个字节存储一个int类型对象,但是并不是所有空间都存值,只有一部分用来存储数值
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      MinInt = int(0x80000000000000000)
      print MinInt
      import sys
      print sys.getsizeof(MinInt)
      print type(int(MinInt))

      # output:
      147573952589676412928
      36
      <type 'long'>

  • Python中定义最小负数时可以使用float最小值或者是很大的整数的负数,而不是像C++一样

最大最小浮点数

Python

1
2
minFloat = float("-inf")
maxFloat = float("inf")