Python_高级特性

文章由Byrx.net分享于2019-03-22 01:03:51评论（24）

Python_高级特性


Python高级特性

author：lxy

\
切片、迭代、列表生成式、生成器


切片
Python中 代码越少越简单越好，
我们要取一个list中的某一部分的元素的我们可以使用判断+循环实现，在Python提供了专门的方法--切片

slice切片，用来获取list中某一段元素

tuple、str等都看做是一种list只是使用切片获取的片段还是他们原来相应的类型

例1、对list进行切片
  1. >>> n = [1,3,2,5,6,8]
  2. >>> n[0:3] #不含尾
  3. [1, 3, 2]
  4. >>> n[-2:] #可以使用倒序的方式截取
  5. [6, 8]
  6. >>> 复制代码
    例2、对tuple进行切片
    1. >>> t = ('a','s','d','d')
    2. >>> t[:3] #默认从0开始截取
    3. ('a', 's', 'd') #tuple切片后还是tuple
    4. >>> 复制代码
      例3、对str进行切片
      1. >>> s = 'dfsafsf'
      2. >>> s[:3]
      3. 'dfs' #字符串切片后还是字符串
      4. >>> #在Python中没有专门对字符串截取操作的函数，只要使用切片就可以完成 复制代码


        迭代
        通过for循环遍历可迭代的对象，称为迭代。
        在c或Java中迭代list等是通过下标来完成的。
        list这样的对象是有下标的我们可以完成迭代，而dict、str等是没有下标的通过Python的for...in一样可以完成迭代
        通过itervalues()可以迭代dict的v
        通过iteritems()可以迭代dict的k_V

        如何判断一个对象是否可迭代
        通过collections模块的iterable类型判断

        例：
        1. >>> from collections import Iterable #获取collections模块的Iterable类型
        2. >>> isinstance('dfdas',Iterable) #判断是否可迭代
        3. True
        4. >>> isinstance(555,Iterable)
        5. False
        6. >>> 复制代码


          在Python中实现下标循环，Python内置的enumerate函数可以把一个list变成 索引--元素
          例：
          1. >>> for i,v in enumerate(('s','d','g')):
          2. print(i,v)
          3. 0 s
          4. 1 d
          5. 2 g
          6. >>> 复制代码

            列表生成式
            range() #
            1、通过range()生成一个连续的整数序列
            2、通过--<表达式> --产生列表


            例1、生成一个整数序列
            1. >>> a = range(3)
            2. >>> for i in a:
            3. print(i)
            4. 0
            5. 1
            6. 2
            7. >>> 复制代码

              例2、生成特殊的数量
              1. >>> c = [x*x for x in range(2,5)]
              2. >>> c
              3. [4, 9, 16]
              4. >>> 复制代码

                列表生成中加if、嵌套
                使用if进行过滤
                例、
                1. >>> a = [x*x for x in range(5) if x>2] #加入if对x进行条件过滤
                2. >>> a
                3. [9, 16]
                4. >>> 复制代码

                  例、
                  1. >>> [m+n for m in 'abc' for n in 'xyz']
                  2. ['ax', 'ay', 'az', 'bx', 'by', 'bz', 'cx', 'cy', 'cz']
                  3. >>> 复制代码

                    例：使用列表生成式，列出当前目录下所有的文件夹和目录名
                    1. >>> import os #导入os模块
                    2. >>> [d for d in os.listdir('.')] #括号内为指定的路径
                    3. ['DLLs', 'Doc', 'include', 'Lib', 'libs', 'Scripts', 'tcl', 'Tools']
                    4. >>> 复制代码

                      生成器Generator
                      但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。
                      Python提供了这一解决方案，列表元素通过某种算法推算出，在循环的过程中不断推算出后续元素，而不必创建完整的list
                      Python保存的是算法，每次调用next()


                      创建generator
                      1、把列表生成式的[]改成()
                      2、在一个普通函数中添加了yield关键字之后,这个函数就不在是一个普通函数，而是一个generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回yield语句处继续执行。

                      例1、
                      1. >>> b = (x for x in range(10))
                      2. >>> b
                      3. at 0x02CB1418>
                      4. >>> next(b) #获取下一元素，由于generator也是可迭代的一般使用for循环进行迭代
                      5. 0
                      6. >>> 复制代码

                        例2、
                        1. >>> def f():
                        2. print('s1')
                        3. yield 1
                        4. print('s2')
                        5. yield 2

                        7. >>> a = f()
                        8. >>> next(a)
                        9. s1
                        10. 1
                        11. >>> next(a)
                        12. s2
                        13. 2
                        14. >>> next(a)
                        15. Traceback (most recent call last):
                        16. File "", line 1, in
                        17. next(a)
                        18. StopIteration #当没有yield可以执行的时候抛出错误
                        19. >>> 复制代码

                          对于函数改造得到的generator，在遇到return或者函数体完成就结束了generator的指令，

                          例：
                          1. >>> def f():
                          2. print('s1')
                          3. yield 1
                          4. return
                          5. print('s2')
                          6. yield 2

                          8. >>> for i in f():
                          9. print(i)


                          12. s1
                          13. 1
                          14. >>> >>> def f():
                          15. print('s1')
                          16. yield 1
                          17. return
                          18. print('s2')
                          19. yield 2

                          21. >>> for i in f():
                          22. print(i)

                          24. s1
                          25. 1
                          26. >>> 复制代码























                            来自群组: Java用户组

相关内容

评论关闭

最新python教程

python~HOT