pyhon学习笔记(1): 数据类型之普通类型

写在前边：

      python是有名的简单，易用，强大的语言。前两天需要用了，花了一点时间去学习。然后写了下边这个学习笔记。目的就是想让没有看过的而有C基础的人一目十行的看过。如果说一个标明自己简单的语言还需要学个10天半月才会用的话，那就太对不起他的简单 标签，特别是对于那些有了一定C或者其他的语言基础的程序员们，我们已经不需要从hello world学起了，我们需要整体的把握。这个语言我认为就是在C上做了一层包装，提供了强大的内嵌类型及其操作。如果都是说都是一样的用户自定义的面向对象类型，谁能比谁强？ 还有一个不能不说的是他的开放。也就是所有的一切开源,就像php,perl,lua....开放的语言很快找到了自己的fans，开放的架构使他的容纳性、适应性、扩展性都有了极大的资源补充，这使得很多人可以共享他人的知识，大大减少自己开发的工程量。 这就是为什么他说自己强大。
 
    我这里只写下整体的印象。让没有学习过的人有整体的印象。 具体那个函数干什么，还是去看看他的在线帮助手册。 什么，哪里有这样的手册？哦，my god。 Google or baidu knows that. 呵呵。
 
 python的英文本意是：巨蟒。
 
 Have fun!  

首先说一下python的内嵌数据类型。在这之前需要说一点：python没有变量定义， 所有的变量都是直接赋值。 赋值的过程就是定义类型分配内存的过程。
  1. 赋值就是定义。赋值就是开辟内存。
   name = "i love you too!"
  2. 1完成以后，del可以删除这个变量，同时删除他的内存空间.
  3. 2完成以后，如果变量没有重新赋值就使用，会造成NameError
  4. 再次的赋值，会再次给他分配内存空间。
  
  总之，不用你去操心内存的事情。 内存池的事情都是底层帮你做的。

1. 数字类型
       1. 类型：
            1. 整数。
                 相当于C语言里边的长整数
   
             2. 长整数。a=99999999999999999999999999999999999999999999999L
                 据说可以支持无限长。 省的你自己去写支持这种长整数的类了。
   
            3. 进制
                 八进制:
                     0开头
                16进制：
                    0x开头
  
            4. 复数
                    4+5j
   
            5. 浮点型
                    精度是C的double类型
      2. 操作：
           1. C都是一样的。
                   1. +，-，*，/， 
                   2. 位操作，移位操作
                          AND,XOR,OR，
                         <<,>>
                  3. 布尔操作
                         <,>,<=,>=
                
                >>> a=1
                >>> b=2
                >>> print a>=b
                False
                >>> print a>b
                False
                >>> print a                True
                >>> print a<=b
                True 

           2. 位操作，移位操作
                  AND,XOR,OR，
                  <<,>>
           3. 类型提升和转换
                   数字运算符的优先顺序和C的相同。呵呵，拿不准就加括号。
                 两个数字进行计算的时候，如果不是同种类型，则把低类型往高类型提升。然后计算。
                 顺序是
                       复数
                       浮点数
                       长整数
    
           4. 内建函数
                 1. 转换型
                           int(),float(),complex()
                      看名而知意。
    
                 2. 操作型
                        coerce:把两个数字调整成一个类型。 顺序按照上边提到过的提升顺序。
                        例子：
                            >>>coerce(1.3,134L)
                             >>>1.3,134.0
     
                        round,pow
    
                3. 进制的转换
                         hex()
                         oct()
    
               4. ascii码转换：
                        chr()
                        ord()

2. 序列类型
    简单的说，我们可以把序列类型看成一个数组，他们的访问模型是一样的：他的内容可以通过下标和下标的范围取得。位置从0开始。通过下标取得一个内容称之为索引，一个范围取得，称之为切片。我们平时用的字符串是序列类型。他有几种重要的操作。也可以这么说，序列是一个支持同样操作的一类数据类型的称呼。
 
    1. 是序列操作？序列中内容的遍历。
        for eachNo in strABC:
            printf eachNo
   
    2. 合并操作
        sequence1+sequence2
        例子：
        >>>>str1="12345"
        >>>>str2="34567"
        >>>>str1+str2
        1234534567
  
    3. 重复操作
        s1*b
        s1重复b次。
  
    4. 索引和切片操作
        1. []:类似数组的下标操作
        2. [x:y]:
            x,y为位置。 可以直接取序列的一个范围。x如果不写，就从0开始。y如果不写，默认到末尾。比如字符串可以取出一端出来。
   
            >>>str=123456"
            >>>print str[1:3]
            234
 
    具体的数据类型：
        1. 字符串  
            对于字符串要多说一点。在python中是没有字符概念的。统统都是字符串。单个的字符？不就是长度为1的字符串吗？呵呵
            'abc'+"9"
            "abs"+"9"
            "abs"+'9'
            'abs'+'9'
           都是一样的意思。

        2. 列表和表列 
  
        序列每一个位置对应的都是一个桶。 字符串里边的每一个位置是一个字符。而列表和表列对应的可以是python的对象。
        列表和表列的区别是，列表用[]"定义"(如前所述，赋值和定义同时进行的 :) )其中的元素和长度可以变化。表列用()定义，其中的元素和长度定义以后不能再变化。
  
        说不如做。看几个例子就知道了。
        1. 改变字符串的值。
            >>> str="12345"
            >>> str[0]=2
   
            Traceback (most recent call last):
                File "", line 1, in
                str[0]=2
            TypeError: 'str' object does not support item assignment
            >>> str="2"+str[1:]
            >>> print str
            22345
           
   
            字符串不支持对元素的赋值。也就是一旦定义以后，这个字符串的单个item不能被更改。 只能用一个新的字符串给他赋值。这叫做不可更改性。
        2.  列表可以对item赋值
            >>> obj=[1,2,"nihao","tahao"]
            >>> obj[1]="first"
            >>> print obj
            [1, 'first', 'nihao', 'tahao']
   
   
        3. 表列不可以。 顺便看一下序列的遍历操作。其他的序列也支持这样的操作。
            >>> obj=(1,2,"nihao","tahao")
            >>> obj[1]="first"
   
            Traceback (most recent call last):
            File "", line 1, in
                obj[1]="first"
            TypeError: 'tuple' object does not support item assignment
   
            >>>for eachItem in obj:
                print eachItem
            输出结果：
                1
                2
                nihao
                tahao
                >>>
        4. 列表(list)和表列
            表列是列表的只读版本，用它来当作传递的只读参数最合适不过了。
            python也提供了对他们的转换的操作
            list():把一个表列转换成列表
           tuple():把一个列表转换成表列。
           
            例子：
            >>> obj1=[1,2,3,4]
            >>> obj2=(4,5,6,7)
            >>> obj3=list(obj1)
            >>> obj3=list(obj2)
            >>> obj4=tuple(obj1)
            >>> print obj4
            (1, 2, 3, 4)
            >>> print obj3
            [4, 5, 6, 7]
            >>> obj4[2]=3
           
            Traceback (most recent call last):
              File "", line 1, in
                obj4[2]=3
            TypeError: 'tuple' object does not support item assignment
            >>> obj3[3]=3
            >>> print obj3
            [4, 5, 6, 3] 
3. 字典类型
 相当于哈希表类型。也就是(key,value)值。他的key可以是数字，字符串。这是python里边唯一的映射类型。
 >>> dic={}   #定义，赋值创建
 #添加内容
    >>> dic['0001']=10
    >>> dic['0002']='earch'
    >>> for eachNo in dic:  #遍历
     print eachNo
   
    输出结果：  
    0001
    0002 
   
    访问他的值 dic['0001']
   
    但是他不允许改变关键字。只能改变关键字对应的值。也不允许关键字对应一个以上的值。 赋值的时候，如果键值已经存在过，直接就把旧值给覆盖了。
    删除一个key
    del dic['0001']
   
    删除整个的字典类型
    del dic
   
       
   

python所有的内嵌类型都已经在上边了。 不过细心的你可能发现，他没有明确的数组类型。数组类新让列表和表列给代替了。呵呵。 数组就是序列吗。 名字不一样，桶里边的内容不一样。 python的更加强大。

       
几个重要的内建函数，可以对所有的内嵌类型做这些操作。
1. len()
    返回一个变量的长度。
2. str()
    把一个变量变成字符串的形式输出。
3. cmp，比较。 不过，对于python的容器类型好像没有多大的意义。 看看知道有这么回事也就完了。
    1. 序列
        1. 遍历元素。尽量按照同类型的比较。是在不行按照字符串的比较办法比。
        2. 如果一个遍历完了，另外一个还没有完毕。则长的大。
        3. 返回0
    2. 字典       
        两个字典的比较是非常有意思的。两个字典类型进行比较的时候得先确定按照什么都是比。下边的步骤一个符合了就不再往下进行了。
        1. 长度不一致，按照长度比。
        2. 关键字不一致，按照关键字比。 这是字符串的比较
        3. 键值不一致？按照键值比。
        4. 返回0：相等。
4. type
    >>> dic={}
    >>> print type(dic)
    输出结果
       

关于内嵌的数据类型的介绍就到这里。 当然，这肯定不是python内嵌类型的全部。还有很多细节。比如,字典类型支持的那些方法。你用的时候再查查资料吧。看多了也记不住。 用的多了自然就记住了。