} } }

    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=[JanuaryFebruaryMarchAprilMayJuneJulyAugustSeptemberOctober    NovemberDecember]   #按照指定的年代日以数字情势打印出日期
    
    >>> endings=[stndrd]+17[th]+[stndrd]+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=[jasonjamesjzhou]
    >>> raw_input (enter your name:in users
    enter your name:jzhou
    True



         序列成员资格示例:



    database=[[jason42],[james45],[jzhou22]]
    
    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
    [
    hello]
    >>> x=[1,1,1]
    >>> x[1]=2 #可以改变列表为元素赋值
    >>> x[2]=3
    >>> x
    [
    1, 2, 3]
    >>> names=[jamesjasonjzhouliwear] #可以删除列表中的元素
    >>> del names[3]
    >>> names
    [
    jamesjasonjzhou]
    >>> name=list(jzhou
    >>> name
    [
    jzhou]
    >>> name[2:]=list(1314) #可以分片赋值
    >>> name
    [
    jz1314]





    >>> 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]


    >>> [tobeorto].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=[wearegoodstudent]
    >>> 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=[tobeornottobe]
    >>> x.remove (be) #remove用于移除列表中某个值的第一个匹配项
    >>> x #值得重视的是remove办法是没有返回值的原地位改变办法,重视和pop的差别
    [
    toornottobe]
    >>> 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码排序
    
    [
    Phnoty]


       若是想把一些元素按相反的次序排出,可以先用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
    abc
    >>> 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)(把序列转换成元组)



                                                                      (转)

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