美文网首页程序员
动态类型是Python语言灵活性的根源

动态类型是Python语言灵活性的根源

作者: 唐大方 | 来源:发表于2017-04-01 22:12 被阅读0次

    如果你接触过C、C++或者JAVA,也许会觉得,Python怎么这么不严谨,使用变量的时候都没有声明变量的类型。
    C语言中:int a = 3,而Python:a = 3
    原来,Python并不会声明脚本中使用对象的确切类型,也不在意特定类型,这样它就非常灵活了,变量a赋值为整型便是整型,赋值为字符串便是字符串,类型都是在运行过程中自动决定的,不需要像C、C++或JAVA这些静态编译类型语言一样,事先需要声明。因此,像Python这样的语言也称为动态类型语言。

    所谓动态类型语言,就是定义变量或参数时,不需要声明其数据类型int、string等。JavaScript、Ruby、Python等都属于动态类型语言。

    静态类型语言(Statically Typed Language)与之相反,它的类型在运行前就已经判断(如编译阶段)。C#、java就是静态类型语言。

    请勿混淆:

    动态/静态类型语言 与 动态/静态语言 是不相同的。

    动态类型语言,声明变量:

    //Python
    x = 1
    y = 2
    sum = x + y
    

    静态类型语言,声明变量:

    //JAVA
    int x = 1;
    int y = 2;
    int sum = x + y;
    

    相关注意,Python中的语句结束符:

    在Python中,当一个物理行只有一个逻辑行时,无需使用分号';'作为结束符,例如:
    x = 1
    y = 2
    当一个物理行有两个或以上逻辑行时:
    x = 1 ; y = 2 ;

    在Python中,变量的数据类型由赋值语句决定:

    x = '1'   #字符串
    x = 5     #整型
    x = True  #布尔型
    

    Python的变量
    Python的变量只是一个名字而已,它的作用仅仅是引用对象,引用任何类型的对象,并不关联类型信息或者约束。

    Python的对象
    对象是分配的一块内存,有足够的空间去表示定义的值。对象类型有Integer、Boolean、Long integer、Floating point real number、Complex number、String、List、Tuple、Dictionary等,都有两个标准的头部信息:一个类型标识符去标识这个对象的类型,一个引用的计数器,用来决定是不是可以回收这个对象。

    Python的赋值
    请思考这样一个问题:

    a = 12
    b = 12
    

    请问这两个赋值语句一共分配了几个存储12的内存?
    答案:是一个。
    赋值的过程是什么样的呢?
    1、创建一个对象来代表12
    2、创建变量a
    3、将变量a与对象12相连接,也就是让a引用12。
    4、创建变量b
    5、将变量b与对象12也进行连接,也就是让b也引用12。
    因此,变量a和b都引用了相同的对象12,也就是说指向了相同的内存空间,这在Python中叫做共享引用----------多个变量名引用同一个对象。

    注意,变量a 和变量b 引用的都是数值类型,如果引用的是字符串、列表、元组或集合,他们仍然指向同一个对象么?

    如何判断不同的变量指向了同一个对象呢?
    这就要了解一下对象的三个基本要素,分别是:id(身份标识)、type(数据类型)和value(值)。
    is 和 ==都是对象操作符:
    is被称为同一性运算符,用来判断不同对象的id是否相同,也就是不同的变量是否指向同一个内存空间。例如:

    a = "woshizifuchuan"
    b = "woshizifuchuan"
    print(a is b)
    

    输出:True or False ?
    也可以通过id函数计算出id值来判断:id(object)
    返回的是对象的“身份证号”:

    id(a)
    140589661955648
    id(b)
    140589661955648
    

    ==是用来比较不同对象的value(值)是否相同:

    a = ('a','bc','g')
    b = ('a','bc','g')
    print(a==b)
    

    输出:True

    在静态类型语言中,变量类型的判断是在编译阶段进行的:

    //JAVA
    int x = 1;
    int y = 2;
    String sum = x + y;
    

    C:\Users\*****\Desktop>javac sum.java
    sum.java:7: 错误: 不兼容的类型: int无法转换为String
    String sum = x + y;

    在Python中,代码是否合法要到运行时才能判断(注意是运行时的类型判断):

    # -*- coding: UTF-8 -*-     
    def add(x, y):       #此处并没有指定参数x、y的数据类型
        sum = x + y
        return "\'{0}+{1}\' 的结果是:{2}".format(x,y,sum)
        #使用format函数进行字符串格式化,不需要指定是字符串还是数字类型
    sum = add(3, 5)      #调用函数add(x, y)时,才能确定参数x、y的数据类型
    print sum
    ----------------------------------------------------------
    C:\Users\*****\Desktop>python sum.py
    '3+5' 的结果是:8
    

    如果要输出中文,需要在文件最上面加上 # -- coding: UTF-8 -- 这行注释,在python 3.x版本中,需要将该py文件存储为UTF-8编码格式,而不是默认的ANSI

    在python 3.x版本中,print 已经成了个内置函数,而不再是语句了,因此需要将print sum 替换为 print(sum)

    函数的参数是在赋值时才能确定其数据类型的。

    sum = add(3, 5)             #均是整型
    sum = add('3', '5')         #均是字符串(string)
    sum = add(3, 5j)            #整型,复数
    sum = add(3.1, 5.3)         #均是浮点型
    sum = add(3.1, 5L)          #浮点型,长整型   注意:python 3版本中只有一种整数类型 int,表示为长整型,没有 python2 中的 Long。
    sum = add(True, True)       #均是布尔型
    sum = add(True, 3)          #布尔型,整型
    sum = add(-True, 3.5)       #布尔型,浮点型
    sum = add('3', 5)           #x是字符串(string),y均是整型   注意:字符串和数值无法相加,也不能联结。
    

    运行过程中,检查代码是否合法:

    C:\Users\******\Desktop>python sum.py
    sum = add(3, 5)-------'3+5' 的结果是:8
    sum = add('3', '5')---'3+5' 的结果是:35      #此处"+"的作用是拼接
    sum = add('3', '5')---'3+5j' 的结果是:(3+5j)
    sum = add(3.1, 5.3)---'3.1+5.3' 的结果是:8.4
    sum = add(3.1, 5L)----'3.1+5' 的结果是:8.1
    sum = add(True, True)-'True+True' 的结果是:2  #True的值是1,False是0
    sum = add(True, 3)----'True+3' 的结果是:4
    sum = add(-True, 3.5)-'-1+3.5' 的结果是:2.5
    sum = add('3', 5)-----Traceback (most recent call last):
      File "sum.py", line 21, in <module>
        sum = add('3', 5)
      File "sum.py", line 3, in add
        sum = x + y
    TypeError: cannot concatenate 'str' and 'int' objects
    

    注意,在运行过程中,x赋值为'3',所指向的对象是字符串类型('str'),y赋值为5,所指向的对象是整型('int'),它们既不能相加,也不能拼接。

    相关文章

      网友评论

        本文标题:动态类型是Python语言灵活性的根源

        本文链接:https://www.haomeiwen.com/subject/htewottx.html