python进修笔记（二）

    添加时间:2013-5-14 点击量:

    　python数据布局


    　　学一门说话，最根蒂根基和首要的就是数据布局了，而在python中最根蒂根基的数据布局是序列，也可以懂得为数组，但貌似比数组强大。



    >>> jason=[jason，42]

    >>> james=[james，45]

    >>> database=[jason，james]

    >>> database

    [[    jason， 42]， [james， 45]]

    >>>


        索引：




    >>> greeting=hello

    >>> greeting[0]

    h

    >>> greeting[-1]  ==>反着的时辰从-1而不是0开端开端

    o

    >>> digital=raw_input （year:）[3]

    year:    2013

    >>> digital

    3



        索引示例：




    >>> months=[January，February，March，April，    May，June，July，August，September，October    November，December]   ＃按照指定的年代日以数字情势打印出日期

    >>> endings=[st，nd，rd]+17[th]+[st，nd，rd]+7[th]+[st] ＃以1-31的数字作为结尾的列表

    >>> year=raw_input （Year:）

    Year:    2013

    >>> month=raw_input（Month（1-12）:）

    Month（    1-12）:3

    >>> day=raw_input（Day（1-31）:）

    Day（    1-31）:30

    >>> month_num=int（month）

    >>> day_num=int（day）

    >>> month_name=months[month_num-1]   ==>重视这里索引要减1

    >>> ordinal=day+endings[day_num-1]

    >>> print month_name + +ordinal + ， + year

    March 30th，     2013

    >>>



    　　分片：


       应用索引能接见单个元素，应用分片能接见必然局限的元素，分片经由过程冒号相隔的两个索引来实现。



    >>> tag=<a href=http://www.python.org>Python web site</a>

    >>> tag[9:30]

    http://www.python.org

    >>> tag[32:-4]

    Python web site>>> 




    >>> numbers=[1，2，3，4，5，6，7，8，9，10]

    >>> numbers[3:6]

    [    4， 5， 6]

    >>> numbers[-3:-1]

    [    8， 9]

    >>> numbers[-3:0]  ＃分片中的最左边的索引比它右边索引的晚呈如今序列中，成果就是一个空序列

    []

    >>> numbers[-3:] ＃默认到最后

    [    8， 9， 10]

    >>> numbers[:3] ＃默认从第一个开端

    [    1， 2， 3]

    >>> numbers[:]   ＃默认全部

    [    1， 2， 3， 4， 5， 6， 7， 8， 9， 10]



    　　很显然，分片操纵的实现须要供给两个索引作为鸿沟，第一个索引的元素包含在分片内，而第二个不包含在分片内。


    　　分片步长：默认步长没有写，是1，分片格局：上鸿沟：下鸿沟：步长




    >>> numbers[0:10:1]  ＃默认步长是1

    [    1， 2， 3， 4， 5， 6， 7， 8， 9， 10]

    >>> numbers[0:10:2]   ＃步长设为2

    [    1， 3， 5， 7， 9]

    >>> numbers[3:6:3]   ＃步长设为3

    [    4]

    >>> numbers[::4]  

    [    1， 5， 9]

    >>> numbers[8:3:-1]   ＃步长不克不及为0，因为不会向下履行，可认为负数，向前履行

    [    9， 8， 7， 6， 5]

    >>> numbers[10:0:-2]  ＃当步长为负数时，开端索引必须大于停止索引

    [    10， 8， 6， 4， 2]

    >>> numbers[0:10:-2]

    []

    >>> numbers[::-2]

    [    10， 8， 6， 4， 2]

    >>> numbers [5::-2]

    [    6， 4， 2]

    >>> numbers[:5:-2]

    [    10， 8]

    >>>



         序列相加：




    >>> [1，2，3]+[4，5，6]

    [    1， 2， 3， 4， 5， 6]

    >>> [1，2，3]+world   ＃列表和字符串都是序列，然则不克不及连在一路，两种同类型的序列才干进行连接操纵

    

    Traceback （most recent call last）:

      File <pyshell＃141>， line 1， in <module>

        [1，2，3]+world

    TypeError: can only concatenate list （not str） to list

    >>>



         序列乘法：



    >>> python5

    pythonpythonpythonpythonpython

    >>> [25]10

    [    25， 25， 25， 25， 25， 25， 25， 25， 25， 25]


    　　空列表可以简单的经由过程[ ]默示，但若想要创建一个占用十个元素空间，却不包含任何有效的有效的内容列表。这时须要应用None，None是Python的内建值，初始化一个长度为10的列表如下：



    >>> sequence=[None]10

    >>> sequence

    [None， None， None， None， None， None， None， None， None， None]


         序列乘法示例：（存在脚本中运行）




    sentence=raw_input （Sentence:）

    screen_width    =60

    text_width    =len（sentence）

    box_width    =text_width+6

    left_margin    =（screen_width-box_width）//2

    print

    print    left_margin + + + -  （box_width-2）  + +

    print    left_margin + |    +    text_width  + |

    print    left_margin + |    +          sentence + |

    print    left_margin + |    +    text_width  + |

    print    left_margin + + + -  （box_width-2）  + +

    print

    raw_input（）



    成果如下：



    　　in运算符：搜检一个值是否在序列中




    >>> permission=rwx   ＃有木有感觉这个像断定Linux中某个文件的履行权限，确切可以这么断定

    >>> w in permission

    True

    >>> xx in permission

    False

    >>> users=[jason，james，jzhou]

    >>> raw_input （enter your name:） in users

    enter your name:jzhou

    True



         序列成员资格示例：



    database=[[jason，42]，[james，45]，[jzhou，22]]

    username    =raw_input（Username:）

    age    =raw_input（Age:）

    if [username，age] in database:

            print OK，right

    raw_input（）


         内建函数len、min、max




    >>> numbers

    [    1， 2， 3， 4， 5， 6， 7， 8， 9， 10]

    >>> len（numbers）

    10

    >>> max（numbers）

    10

    >>> min（numbers）

    1

    >>>



      　　列表：


     列表不合于元组和字符串，列表是可变的，并且列表有很多专门的办法。字符串不克不及像列表一样被批改，然则列表中的list函数可以实现批改。列表的常用用法：




    >>> list（hello）

    [    h， e， l， l， o]

    >>> x=[1，1，1]

    >>> x[1]=2    ＃可以改变列表为元素赋值

    >>> x[2]=3

    >>> x

    [    1， 2， 3]

    >>> names=[james，jason，jzhou，liwear]  ＃可以删除列表中的元素

    >>> del names[3]

    >>> names

    [    james， jason， jzhou]

    >>> name=list（jzhou）

    >>> name

    [    j， z， h， o， u]

    >>> name[2:]=list（1314）   ＃可以分片赋值

    >>> name

    [    j， z， 1， 3， 1， 4]





    >>> numbers=[1，5]  ＃分片赋值可以在不须要调换任何元素的景象下插入新元素

    >>> numbers[1:1]=[2，3，4]

    >>> numbers

    [    1， 2， 3， 4， 5]

    >>> numbers[1:4]=[]  ＃也可以变相的删除元素

    >>> numbers

    [    1， 5]



    　　列表的办法首要有append， count，extend，index，，pop，remove，reverse，sort，简单用法如下：




     >>> list=[1，2，3]
     >>> list .append（4）  ＃ append用于在列表末尾追加新对象
     >>> list
     [1， 2， 3， 4]


    >>> [to，be，or，to].count（to）  ＃count用于统计某个元素在列表中呈现的次数

    2

    >>> x=[[1，2]，1，1，[2，1，[1，2]]]

    >>> x.count（1）

    2

    >>> x.count（[1，2]）

    1

    >>> a=[1，2，3]

    >>> b=[4，5，6]

    >>> a.extend（b）   ＃extend在列表的末尾一次性追加另一个序列的多个值，扩大原有列表

    >>> a

    [    1， 2， 3， 4， 5， 6]   ＃重视这个操纵与连接操纵不合，extend批改了被扩大的序列即a，而连接只是姑且显示并没有变

    >>> a=[1，2，3]

    >>> b=[4，5，6]

    >>> a[len（a）:]=b   ＃也可以经由过程分片赋值来扩大，然则可读性不强

    >>> a

    [    1， 2， 3， 4， 5， 6]

    >>> sentence=[we，are，good，student]

    >>> sentence.index （are）    ＃index用于从列表中找出某个值第一个匹配项的索引地位

    1

    >>> numbers=[1，2，3，4，5，6，7]

    >>> numbers.（3，four）  ＃用于将对象插入列表中，和数据布局中的链表操纵很是类似

    >>> numbers

    [    1， 2， 3， four， 4， 5， 6， 7]

    >>> numbers=[1，2，3，4，5，6，7]

    >>> numbers[3:3]=[four]   ＃也可以应用分片赋值的办法实现，然则可读性不强

    >>> numbers

    [    1， 2， 3， four， 4， 5， 6， 7]

    >>> x=[1，2，3]   

    >>> x.pop（）  ＃出栈操纵，和数据布局中的栈操纵一样，即移除列表中的最后一个，并且返回该元素的值

    3

    >>> x

    [    1， 2]

    >>> x.pop（）

    2

    >>> x=[1，2，3]

    >>> x.append（x.pop（））   ＃这个操纵和数据布局中的push、pop是一样的，追加方才出栈的值，很有趣，最后获得的还是是本来的值

    >>> x

    [    1， 2， 3]

    >>> x=[to，be，or，not，to，be]

    >>> x.remove （be）  ＃remove用于移除列表中某个值的第一个匹配项

    >>> x         ＃值得重视的是remove办法是没有返回值的原地位改变办法，重视和pop的差别

    [    to， or， not， to， be]

    >>> x=[1，2，3]

    >>> x.reverse （）  ＃将列表中的元素反向存放，重视这种办法改变了列表但没有返回值

    >>> x

    [    3， 2， 1]

    >>> x=[4，5，6，7，1，2，3]

    >>> x.sort（）  ＃sort用于在原地位对列表进行排序，也改变了序列的值，然则没有返回值

    >>> x

    [    1， 2， 3， 4， 5， 6， 7]

    >>>



    　　重视以上办法除了count和index，都是会使列表的内容的产生变更。


     　　介于sort办法批改列表然则没有返回值的景象有待细说一下：



    >>> x=[4，6，2，1，7，9]

    >>> y=x.sort（）   ＃因为x.sort（）不反回值，所以y并没有赋到值

    >>> print y

    None

    >>>


    　　　看下正确的做法吧，其实也就是将步调拆开罢了：（sort函数不反回值的特点决意了不克不及在它的后面持续后续操纵，比如x.sort（）.reverse（），然则serted（x）.reverse（）是正确的）




    >>> x=[4，6，2，1，7，9]

    >>> y=x[:]   ＃先将x复制给y

    >>> y.sort（） ＃将y排序

    >>> x

    [    4， 6， 2， 1， 7， 9]

    >>> y

    [    1， 2， 4， 6， 7， 9]

    >>> x=y>>> x

    [    1， 2， 4， 6， 7， 9]

    >>> y

    [    1， 2， 4， 6， 7， 9]



    　　另一种获取已排序的列表副本的办法是应用sorted函数：



    >>> x=[4， 6， 2， 1， 7， 9]

    >>> y=sorted（x）

    >>> x

    [    4， 6， 2， 1， 7， 9]

    >>> y

    [    1， 2， 4， 6， 7， 9]


         sorted函数可以用于任何序列，却老是返回一个列表：



    >>> sorted（Python）   ＃默认按ASCII码排序

    [    P， h， n， o， t， y]


     　　若是想把一些元素按相反的次序排出，可以先用sort或者sorted函数，在调用reverse函数。嵌套应用的功能很强大。


    　　关于高等排序：元素能遵守特定的体式格式进行排序，可以应用compare（x，y）自定义斗劲函数，compare（x，y）函数会在x<y时返回负值，x>y时返回正值，x=y时返回0。定义好该函数之后，就可以供给给sort办法作为参数了。




    >>> cmp（42，23）

    1

    >>> cmp（99，100）

    -1

    >>> cmp（1，1）

    0

    >>> numbers=[5，2，6，7]

    >>> numbers.sort（cmp）    ＃这个机制之后会介绍

    >>> numbers

    [    2， 5， 6， 7]



    　　 元组——不成变序列


    　　元组和列表一样，也是一种序列，独一的不合是元组不克不及批改，字符串也是如此；创建元素很简单，用逗号分隔一些值，就主动创建了元组：




    >>> 1，2，3

    （    1， 2， 3）

    >>> （1，2，3）

    （    1， 2， 3）

    >>> （42，）  ＃ 逗号申明它是一个元组，不然加括号（如：（42））也没用

    （    42，）

    >>> 3（40+2）  ＃这个例子说了然逗号的首要性，42和（42）是完全一样的

    126

    >>> 3（40+2，）    

    （    42， 42， 42）

    >>>



    　　tuple函数：


    　　 tuple函数的功能与list函数根蒂根基一样：以一个序列作为参数把它转换为元组。若是参数是数组，那么该参数就会被原样返回：



    >>> tuple（[1，2，3]）

    （    1， 2， 3）

    >>> tuple（abc）

    （    a， b， c）

    >>> tuple（（1，2，3））

    （    1， 2， 3）


    　　元组其实就是数组，除了创建和接见之外，没有太多操纵，和其他类型的序列操纵类似：



    >>> x=1，2，3

    >>> x[1]

    2

    >>> x[0:2]  ＃元组的分片还是元组，就像列表的分片还是列表一样

    （    1， 2）


    　　那么元组的存在意义是什么呢，起首元组可以在映射中当做键应用，而列表不可；其次，元组作为很多内建函数和办法的返回值存在。只要不涉及到批改元组，大项目组景象下和列表根蒂根基功能雷同。一般来说，列表可更能满足对序列的所有请求。



      　　


           用到的函数总结：cmp（x，y）、len（seq）（返回序列长度）、list（seq）（把序列转换成列表）、max（args）、min（args）、reverse（seq）（对序列进行反向迭代）、sorted（seq）（返回已排序的包含seq所有元素的列表）、tuple（seq）（把序列转换成元组）



    　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　（转）

    彼此相爱，却不要让爱成了束缚：不如让它成为涌动的大海，两岸乃是你们的灵魂。互斟满杯，却不要同饮一杯。相赠面包，却不要共食一个。一起歌舞欢喜，却依然各自独立，相互交心，却不是让对方收藏。因为唯有生命之手，方能收容你们的心。站在一起却不要过于靠近。—— 纪伯伦《先知》
    分享到：