Python的学习笔记--高级特性

发表于

数组的切片

定义一个数组 

1
arr=list(range(100))

  1. 数组取前3个元素 arr[0:3],0可以省略，arr[:3]，打印结果：[0,1,2]

  2. 数组取后面三个元素： arr[-3:0],也可写为：arr[-3:],打印结果：[97,98,99]

  3. 数组取后面三个元素： arr[97:],是跳过前97个数字，打印结果：[97,98,99]

  4. 可以指定取值的间隔 arr[:10:2],打印结果：[0, 2, 4, 6, 8]
    如果在全部范围内查询，可以省略查询的个数，arr[::2]这样打印出来所有的偶数。

  5. 切片的方法同样适用于tuple

  6. 字符串可以看成是字符的数组，可以使用，"ABCDEFG"[:3] 输出结果ABC

迭代循环

  1. list的循环 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
         arr=list(range(10))
         for a in arr: 
              print(a)
         ```   

    2. `dict`循环     
        
         ```python 
         dict={"a":1,"b":2,"c":3}
         for a in dict: 
         print(a)
         ```    

         ```python 
         dict={"a":1,"b":2,"c":3}
         for x,y in dict.items(): 
              print(x,y)
         ```      

         ``` cte 
         a 1
         b 2
         c 3

  2. 字符串循环 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
         for a in "ABCD": 
                print(a)
     
         ```   
    4. 多个变量    
         ```python
         for x, y in [(1, 1), (2, 4), (3, 9)]:
              print(x, y)

         ```     
         打印结果：
         ``` cte
         1 1
         2 4
         3 9

  3. 带索引的循环写法 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    for i, value in enumerate(['A', 'B', 'C']):
          print(i, value)

    ```  
    打印结果：    

    ```cte
     0 A
     1 B
     2 C

  4. 判断能否被迭代 

    1
    2
    3
    from collections import Iterable
    isinstance('abc', Iterable)

列表生成式

列表生成式可以更简单的把生成一个list或者tuple.

定义一个100的数组，arr=list(range(100))

  1. 定义一个100偶数的数组 

    1
    2
    3
    4
    arr=[2 * x for x in list(range(100))]

    或者arr=[x for x in list(range(200)) if x%2==0]

    打印结果：[0,2,4...198]

  2. 定义两个循环生成一个组合

    1
    str=[a+b for a in "ABC"  for b in "XYZ"]

    打印结果：['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

  3. 使用多个变量 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
         dict = {'a': 'A', 'b': 'B', 'c': 'C' }
         dic=[k + '=' + v for k, v in dict.items()]
         print(dic)   
         ```   

         打印结果：`['a=A', 'b=B', 'c=C']`   

    4. 使用函数       

         ``` python
         arr=[x.upper() for x in "abc"]
         print(arr)

         ```   

         打印结果：`['A', 'B', 'C']`   
         
         获得当前路径，可以用一句代码
         ```python
         import os
         fs=[d for d in os.listdir('.')] 
         print(fs)
         ```   


    5. 表达式可以赋值给一个变量，实现延迟加载   

         ``` python 
         g = (2 * x for x in range(10))
         print(next(g))
         print(next(g))
         print(next(g))
         print(next(g))
         print(next(g))

    打印结果：0,2,4,6,8

    也可以使用循环打印：

    1
    2
    3
    g = (2 * x for x in range(10))
    for x in g:
         print(x)