### 1. 什么是高阶函数 

高阶函数就是传入的参数或者输出的结果中有一个为函数的函数。
或者说：
如果函数传入的参数中，或者输出的结果（函数只有一个结果）中有任意一个为函数，那么这个原函数就是高阶函数。


```python
def counter(base):
    def inc(step=1):
        base += step
        return base
    return inc 
```

1. 函数counter是不是一个高阶函数？
>函数counter是一个高阶函数，因为return中的inc是一个函数。
2. 上面代码有没有问题？如何改进。
>base += step 将会改变变量base的值，base是上层函数的变量。
改进：可以使用nonlocal关键字。产生UnboundLocalError错误。
3. 如何调用完成计算功能？
>foo = counter(11)
4. f1 = counter(5)和f2 =counter(5),f1和f2 是否相等？为什么。
>f1 == f2 is false 
两者id不一样。

**理解不了代码，只能测试一下了。。但是为啥会出现这样的情况呢？**


```python
def counter1(base=20):
    def inc(step=10):
        nonlocal base 
        #print(base)
        #print(step)
        base += step
        #print(base)
        return base  #将base的值再次作为count1的参数传入
    return inc 
```


```python
foo = counter1()
```


```python
foo()  #此处传入的值是内层inc的参数。。虽然不知道为啥，但就是这样表现的。
# 20 是内层函数counter1的参数默认值，
# 10 是外层函数inc的参数默认值
```




    30




```python
# 测试下给foo = counter1（） 赋值  
foo = counter1(40)
```


```python
foo()  #说明此处赋值是给外层函数counter1的参数赋值，内层函数inc的默认值无变化
```




    50




```python
# 测试下给foo() 赋值  
foo = counter1()
```


```python
foo(25)  #说明此处赋值是给内层函数inc的参数赋值，外层函数counter1的默认值无变化
```




    45



**参数传入的问题解决了，但是为什么一直运行foo(25)，值会一直变化呢？**


```python
def coun(base=20):
    def inc(step=10):
        nonlocal base 
        #print(base)
        #print(step)
        base += step
        #print(base)
        return base  #将base的值再次作为count1的参数传入
    return inc 

foo = coun(10)
```


```python
foo(25) #第一次运行
```




    35




```python
foo(25) #第二次运行
```




    60



因为nonlocal关键字将base的变量拿到内层函数inc的内部，然后base += step 将base的值改变了。因为coun函数未结束，所以变量改变的值会一直替换原来的值。
最终这样就实现按照步长（step）一直累加的功能。step = 1 就是简单的计数功能。
由于博客的格式问题，把代码中的#去掉，就可以很明显的看到效果了。

### 2. 实现sort函数的功能

sort将原来的函数进行排序，输出一个新的列表，可以控制正序还是逆序。
思路：
1，两个列表一个原列表（需要进行排序的列表），一个新列表（输出的列表）；
2，依次取出原列表的数字，和新列表的数字进行比较，比较大的放在前面（实现了逆序，从大到小排列）；
3，第一次输出的列表没有值，需要在原列表中取一个直接放入。


#### 1. 实现排序功能 


```python
oldlst = [1,4,5,21,4,22,23,-11]

def sort(lst):
    newlst = []
    for x in oldlst:  #取出x
        for i,y in enumerate(newlst): #取出y和y的索引
            if x>y: #如果x>y
                newlst.insert(i,x) #在列表lst1的索引i位置插入x的值
                break
        else:
            newlst.append(x)
    return newlst
  
    
print(sort(oldlst))

#此处的初始列表为oldlst = [1,4,5,2]
#第一次循环，x=1 newlst=[1] 
#第二次循环，x=4 y = 1 y的索引为0 x>y 将x的值放在索引为0的位置  newlst = [4,1]
#第三次循环，x=5 y1= 4 y1的索引为0  y2 = 1 y2的索引为1 5>4 将x的值放在索引0的位置上 newlst = [5,4,1]
#第四次循环，x=2 y1 = 5 y2 = 4 y3 =1 ==> 2<5 ,2< 4 2>1 将x的值放在索引为2的位置上 newlst = [5,4,2,1]
#返回newlst = [5,4,2,1]



```

    [23, 22, 21, 5, 4, 4, 1, -11]


#### 2. 实现参数控制排序


```python
lst = [1,4,5,2]

def sort(lst,reverse=False):
    lst1 = []
    for x in lst:  
        for i,y in enumerate(lst1): 
            #if reverse:   # reverse 为false 时候 x< y 实现逆序
            #    a= x < y
            #else:
            #    a = x > y  #reverse 为true 时候 x> y 实现正序
            a = x>y if reverse else x<y #等效写法
            
            if a: #如果x>y
                lst1.insert(i,x) 
                break
        else:
            lst1.append(x)
    return lst1
    
print(sort([1,4,5,2]))
```

    [1, 2, 4, 5]


特别说明：

```python
#其中
if reverse:   # reverse 为false 时候 x< y 实现逆序
    a= x < y
else:
    a = x > y  #reverse 为true 时候 x> y 实现正序

#等效于

a = x>y if reverse else x<y

#可以理解为 a = x>y 但是当reverse的值为false时候 a = x < y 
#等效写法
```

控制符号的部分提取出来


```python
def compare(a,b,reverse=False):
    return a>b if reverse else a<b 

 
lst = [1,4,5,2]

def sort(lst):
    lst1 = []
    for x in lst:  
        for i,y in enumerate(lst1): 
            
            if compare(x,y): #把x y的值传入到外部函数，得到一个x>y的结果，再进行后续处理。
                
                lst1.insert(i,x) 
                break
        else:
            lst1.append(x)
    return lst1
    
print(sort([1,4,5,2]))
```

    [1, 2, 4, 5]


#### 3. 把compare函数放在sort函数的参数位置


```python
#引入lambda函数
def sort(lst,compare=lambda a,b : a>b):  #高阶函数
    lst1 = []
    for x in lst:  
        for i,y in enumerate(lst1): 
            
            if compare(x,y): #把x y的值传入到外部函数，得到一个x>y的结果，再进行后续处理。
                
                lst1.insert(i,x) 
                break
                
        else:
            lst1.append(x)
    return lst1
    
print(sort([1,4,5,2]))
```

    [5, 4, 2, 1]


### 3. 柯里化

柯里化（英语：Currying），又译为卡瑞化或加里化，是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。
z = f(x,y) 转换为z=f(x)(y)的形式。


```python
def  add(x,y):
    return x + y

add(1,2)
```




    3




```python
def add(x):
    def _add(y):
        return x + y 
    return _add 

add(5)(6) #5是传入到x  6传入到y
```




    11



**看完还是很懵逼，，在“装饰器”里继续说说吧。。**


python之高阶函数

本文主要介绍python函数的基础知识。
回答了，什么是函数，如何定义函数，函数的调用及函数的作用域等等问题。
本文是博客平时学习总结所得，可能有很多不对的地方，请不吝指教。

### 1.什么是函数？

有两个变量 x 和 y ，当 x 取其变化范围中的每一个特定值时，相应地有唯一的 y 与它对应，则称 y 是 x 的函数。记为 y = f （ x ），其中 x 为自变量， y 为因变量。

可知函数由三部分组成：
>x：输入，一般函数可以有多个输入。
f：function，通过某种特定的方法将x转换为y,function就是这个方法。
y：输出，一般函数只有一个输出，计算机技术中的函数也可以没有输出。

<p id="div-border-left-red">python的函数：由若干个语句块(function)、函数名称、参数列表（输入）构成，完成一个功能（输出）。</p>

### 2.函数的定义及调用

#### 1.函数的定义 

python使用def语句定义函数
```
def 函数名（参数列表）：
    函数体（代码块）
    [return 返回值]

```


>函数名：一般命名要求。
参数列表：放一个标志符占位，叫做<font color=#DC143C >形参</font>。
函数体：代码块，决定函数的参数。
return：默认都会使用return语句，若无默认返回None。

#### 2.函数的调用 

通过前面定义的函数名称进行调用，就可以将函数运行起来，从而得到函数的返回值。
注意：
调用的时候需要在函数名称后加个小括号()括号内填入函数体中需要的参数，传入的参数叫做<font color=#DC143C >实参</font>。
函数传入的参数必须和函数体中需要的函数（实参）保持数量一致，除非原函数参数列表中定义的有默认参数。


```
#定义函数add()
def add(x,y):
    sum = x+y
    return sum

#调用函数add()
add(1,3)
```




    4



### 3.函数的参数

python传入的参数分为两类，一种说根据位置传入的参数叫位置参数，另外一种可以根据形参定义的变量传入的参数叫关键字参数。
**传入的时候，位置参数需放在关键字参数之前。**

#### 1.普通位置参数 

把参数1给x，参数3给y。一一对应，这种就是位置参数。位置参数是按照顺序一一传入。


```
def add(x,y):
    sum = x+y
    return sum


add(1,3)  
```




    4



#### 2.可变位置参数

在普通位置前面加个"\*"，可以一次接受多个参数。使用一个元组（tuple）收集多个实参。


```
def add(*nums):
    sum = 0
    print(type(nums))
    for x in nums:
        sum+=x
    print(sum)

add(3,5,6)
```

    <class 'tuple'>
    14


<div class="note danger no-icon"><p>说明：一般情况下，如果普通参数和可变位置参数一起定时候，需要把普通参数放在位置参数之前。</p></div>



```
def add(x,*nums):
    sum = 0
    print(nums)
    for x in nums:
        sum+=x
    print(sum)

add(3,5,6)
```

    (5, 6)
    11


#### 3.关键字参数

把3传给y，1传给x。按照定义好的关键字传入参数，位置可以随意。


```
def add(x,y):
    sum = x+y
    return sum


add(y=3,x=1) 
```




    4



<div class="note danger no-icon"><p>说明：当位置参数和关键字参数一起传入时候，需要把位置参数放在关键字参数前面。</p></div>


```
def add(x,y):
    sum = x+y
    return sum


add(1,y=1) 
```




    2



#### 4.可变关键字参数

在普通关键字参数前面加两个"\*\*"，可以一次接受多个关键字参数,收集到的实参名称和值组成一个字典(dict)。


```
def showconfig(**kwargs):
    for k,v in kwargs.items():
        print('{} = {}'.format(k, v))
        
showconfig(host='127.0.0.1',port='8080',username='mykernel',password='qwe123')
```

    username = mykernel
    password = qwe123
    port = 8080
    host = 127.0.0.1


<div class="note danger no-icon"><p>说明：当可变参数和普通参数一起定义时，需要把可变参数放在普通参数之后。</p></div>


```
def showconfig(x,y,*args,**kwargs):
        print(x)
        print(y)
        print(args)
        print(kwargs)
    
showconfig('127.0.0.1',8080,'mykernel',password='qwe123')
#此时使用关键字参数给x，y赋值就会报错。
```

    127.0.0.1
    8080
    ('mykernel',)
    {'password': 'qwe123'}


####  5.默认参数 

有些参数很少改变，所以可以在指定形参的时候传入一个默认值，当有新的实参去替换它的时候，新的参数生效。
**默认参数必须放在普通参数之后**


```
#传入默认值参数
def add(x=11,y=111):
    sum = x+y
    return sum


add() #未传入参数，默认参数生效
```




    122




```
#有再次传入参数，替换默认值。
def add(x=11,y=111):
    sum = x+y
    return sum


add(657,y=123) #新传入的参数生效
```




    780



定义一个函数login，参数名称为host、port、username和password。


```
def login(host='127.0.0.1',port='80',username='mykernel',password='123'):
    print('{}:{}\nname:{}\npasswd:{}\n'.format(host,port,username,password))
    
login()
login('192.168.1.1',8080)
login('10.0.0.1',password='qwe123')
```

    127.0.0.1:80
    name:mykernel
    passwd:123
    
    192.168.1.1:8080
    name:mykernel
    passwd:123
    
    10.0.0.1:80
    name:mykernel
    passwd:qwe123
    


####  6.keyword-only参数(python3后引入)

**定义方法一：**在可变位置参数后，出现普通参数。此时这个普通参数就被python视作为keyword-only参数，keyword-only参数在传入时必须使用关键字传参方法传入。

**定义方法二：**def fn(\*, x,y),\*，后跟普通参数，也被视为keyword-only参数，x，y均为keyword-only参数。

####  7.参数定义顺序 </i> <i class="fa fa-star" style="font-size;color:red"></i></i> <i class="fa fa-star" style="font-size;color:red"></i>

<div class="note danger no-icon"><p>参数列表的一般顺序是：普通参数，缺省参数，可变位置参数，keyword-only参数（可带缺省值），可变关键字参数。</p></div>


```
def fn1(x, y, z=3, *args, m=4, n, **kwargs):
    print(x,y)
    print(z)
    print(args)
    print(m,n)
    print(kwargs)
    print(end='\n')

#x，y是普通参数
#z，带默认值，传入时候省略，缺省参数
#*args，可变位置参数
#m=4，keyword-only 缺省参数
#n，keyword-only参数
#**kwargs，可变关键字参数

fn1(1,2,n=4)

fn1(1,2,4,43,123,k=123,m=11,n=13,j='hello')
```

    1 2
    3
    ()
    4 4
    {}
    
    1 2
    4
    (43, 123)
    11 13
    {'j': 'hello', 'k': 123}
    



```
def fn2(x, y, z=3, *, m=4, n, **kwargs):  #定义m，n为keyword-only参数。
    print(x,y)
    print(z)
    print(m,n)
    print(kwargs)
    print(end='\n')
    
fn2(1,2,m=1,n=2)
```

    1 2
    3
    1 2
    {}
    


####  8.参数解构</i> <i class="fa fa-star" style="font-size;color:red"></i>


```
def add(x,y):
    print(x+y)
    print()

add(*(4,6)) #参数解构
# add(*(1,2)) add(*[1,2]) add(*{1,3}) 

add(**{'x':1,'y':11}) #字典参数解构，x，y参数要和定义的对应起来。把x=1，y=11 传入形参，关键字传参。
d = {'a':1,'b':12}

add(*d.keys()) #取k 把取出来的k赋值给形参，位置传参。
add(*d.values()) #取values
```

    10
    
    12
    
    ab
    
    13
    


####  9.函数的返回值

函数返回值的特点：
+ 一个函数只有一个返回值，返回值可以是函数多个结果的集合；
+ python函数使用return语句返回函数的返回值；
+ return语句不一定是函数的最后一条语句；
+ 所有的函数都有返回值，如果不使用return函数，则默认使用return None返回；
+ 如果有多条return函数，当其他任何一条执行了就直接跳出函数，其他部分不再执行；
+ return None 可以简写为return。


<div class="note danger no-icon"><p>说明：函数的返回值是函数执行完后（结束调用）给的一个值，函数的值，是运行这个函数时得到的值。</p></div>

### 4.作用域</i> <i class="fa fa-star" style="font-size;color:red"></i></i> <i class="fa fa-star" style="font-size;color:red"></i></i> <i class="fa fa-star" style="font-size;color:red"></i>

每个python的标识符都有自己的可见范围，这个可见范围就是标识符的作用域（变量的作用域）。

1. 全局作用域，在整个python程序运行的环境中都可以见。
2. 局部作用域，在函数、类等的内部可见，也仅仅其内部可以使用。

#### 1.最小范围定义的变量生效

嵌套函数中，定义同一个变量，最内层的变量生效。但是只是影响当层，不影响其外层的值。


```
def outer1(): 
    o = 65
    def inner():
        print("inner {}".format(o))
        print(chr(o)) #内层inner函数可以使用上层outer1定义的o的变量。
    print("outer {}".format(o))
    inner()
    
outer1()
```

    outer 65
    inner 65
    A



```
def outer2(): 
    o = 65
    def inner():
        o = 97  #inner内定义的o的变量覆盖了上层函数中定义的o的值。
        print("inner {}".format(o))
        print(chr(o))
    print("outer {}".format(o))
    inner()
    
outer2()
```

    outer 65
    inner 97
    a


#### 2.试错

前因：三行代码报错


```
x = 5 
def foo():
    x += 1  #看似没问题的函数报错了。。
    
foo()
```


    ---------------------------------------------------------------------------

    UnboundLocalError                         Traceback (most recent call last)

    <ipython-input-12-4e89701596b1> in <module>()
          3     x += 1
          4 
    ----> 5 foo()
    

    <ipython-input-12-4e89701596b1> in foo()
          1 x = 5
          2 def foo():
    ----> 3     x += 1
          4 
          5 foo()


    UnboundLocalError: local variable 'x' referenced before assignment


a. 难道是外层函数，读取不到x的值？


```
x = 5 
def foo(): 
    print(x)  
foo()  #不会报错，说明foo()函数内可以读取到x的值
```

    5


b. local variable 'x' referenced before assignment(局部变量“x”在赋值前被引用)


```
x = 5
def foo():
    x = 11  #在内层函数再次定义x的值，覆盖外层的x，函数运行成功。
    print(x)
    x = x + 1  
    print(x)
print(x) #测试外部的x是否发生改变
foo()
```

    5
    11
    12


**总结：修改内层函数变量的时候，需要对变量重新赋值，不然会认为你修改的是外层变量的值（超出自己的权限了）。当然也可以使用新的变量来接收值（避免修改原变量）。**

#### 3.global全局变量（慎用）

解决2的问题也可以在函数内部定义一个global全局变量。


```
x =5
def foo():
    global x
    x += 1 
    print(x) #实现了改变x的值，次数x=6
def xoo():  
    print(x)
foo()
xoo() #此时xoo的变量值也改变了，很危险！！！正常情况下x = 5
print(x) #此时外部x的变量值也改变了，很危险！！！
```

    6
    6
    6



```
#del x
def foo():
    x = 5
    global x
    x += 1 
    print(x) 
    
foo()
print(x) #外部没有定义x，使用global函数强行将x提升到全局，很危险！！！
```

    6
    6


    <ipython-input-36-87883300c30d>:4: SyntaxWarning: name 'x' is assigned to before global declaration
      global x



```
del x
```

#### 4. 闭包

如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是**闭包（closure）**。定义在外部函数内的但由内部函数引用或者使用的变量被称为**自由变量**。


```
def print_msg():
    # print_msg 是外部函数
    msg = "zen of python"
    def printer():
        # printer 是内层函数
        print(msg)
    return printer

another = print_msg() #赋值

another() #调用函数

#another（）是什么？
#another = print_msg() ==> return printer  ==> another = printer  ==> another() = printer() ?? 
# printer打印出msg的值，所以another 也可以打印出msg的值。
#但是有什么不一样呢？
```

    zen of python


这里的 another 就是一个闭包，闭包本质上是一个函数，它有两部分组成，printer 函数和变量 msg。闭包使得这些变量的值始终保存在内存中。msg就是自由变量。
自由变量会和这个print_msg函数一同存在，即使已经离开了创造它的环境也不例外。


```
##计数器

def generate_counter():
    CNT = [0]
    def add_one():
        CNT[0] = CNT[0] + 1
        return CNT[0]
    return add_one

counter = generate_counter()

print(counter())   # 1
print(counter())   # 2
print(counter())   # 3

#多次初始化函数，但是CNT内的值没有被重置。 （具体原理还是没理解。。）
```

    1
    2
    3


#### 5. nonloacl关键字

nonlocal关键字，使变量标在上级的**局部作用域**中生效，但该作用域不能为全局作用域。所以一层的函数中不能使用该关键字。


```
def counter():
    count = 0 
    def inc():
        nonlocal count  #把count 这个变量拿到我这个函数的作用域内，让我可以修改。。
        count += 1
        return count
    return inc

foo = counter
foo()
foo()
```




    <function __main__.counter.<locals>.inc()>



#### 6. 默认值的作用域

当默认值是列表时，就会出现这种情况：


```
def foo(xyz=[]):
    xyz.append(1)
    print(xyz)
    
foo()
foo()

foo.__defaults__   #__defaults__是函数foo的一个属性
#当函数第一次运行后，xyz=[]已经变为xyz[1] ，次数__defaults__的值也为[1]。 
#函数执行完成后运行着的foo函数已经调用完成，但是函数的属性依旧还在。
#当第二次调用此函数之前，foo的默认值已经变了。当执行完成后默认值再次发生变化。
```

    [1]
    [1, 1]





    ([1, 1],)



再次说明：


```
def foo(xyz=[],u='abc',z=123):
    xyz.append(11)
    return xyz

print(foo(),id(foo))  
print(1,foo.__defaults__)

print(foo(),id(foo))
print(2,foo.__defaults__)  #函数的id没有变化，说明函数在内存中的位置没有变化，那么函数的属性会一直伴随这foo函数。
#xyz=[] 引用的是一个地址，地址一直没有变化，变化的是索引对应的值。所以看起来的效果就是默认值发生变化了。
```

    [11] 139696905538552
    1 ([11], 'abc', 123)
    [11, 11] 139696905538552
    2 ([11, 11], 'abc', 123)


**tips:函数属性__kwdefaults__ 中保存的是keyword-only参数的默认值。**

如何避免上述的特性呢？

1. 传入默认值的副本


```
def foo(xyz = [],u='abc',z=123):
    xyz = xyz[:] #浅copy
    xyz.append(1)
    print(xyz)

foo()
print(foo.__defaults__)
foo()
print(foo.__defaults__)
foo([10])
print(foo.__defaults__)
foo([10,5])
print(foo.__defaults__)  
```

    [1]
    ([], 'abc', 123)
    [1]
    ([], 'abc', 123)
    [10, 1]
    ([], 'abc', 123)
    [10, 5, 1]
    ([], 'abc', 123)


2. 使用不可变类型的默认值（推荐使用）


```
def foo(xyz=None, u='abc', z=123):
    if xyz is None:
        xyz = []
    xyz.append(1)
    print(xyz)
    
foo()
print(foo.__defaults__)
foo()
print(foo.__defaults__)
foo([10])
print(foo.__defaults__)
foo([10,5])
print(foo.__defaults__)
```

    [1]
    (None, 'abc', 123)
    [1]
    (None, 'abc', 123)
    [10, 1]
    (None, 'abc', 123)
    [10, 5, 1]
    (None, 'abc', 123)


### 5. 函数的销毁

全局函数销毁：
1. 重新定义同名函数
2. del 语句删除函数
3. 程序结束时

局部函数销毁：
1. 重新在上级作用域定义同名函数
2. del 语句删除函数
3. 上级作用域销毁时

### 6. 匿名函数

python借助Lambda表达式构建匿名函数。
匿名函数：没有名字，定义完后马上调用。
格式：
lambda 参数列表：表达式


```
(lambda x : x ** 2)(4) 
```




    16



* 匿名函数的参数列表不需要小括号；
* 冒号是用来分割参数列表和表达式；
* 不需要使用return，表达式的值就是匿名函数的返回值；
* lambda表达式只能在一行上执行，又被称为单行函数。


```
#示例
print(1,(lambda :0)())
print(2,(lambda x, y=3: x + y)(5))
print(3,(lambda x, y=3: x + y)(5, 6))
print(4,(lambda x, *, y=30: x + y)(5))
print(5,(lambda x, *, y=30: x + y)(5, y=10))
print(6,(lambda *args: (x for x in args))(*range(5)))
print(7,(lambda *args: [x+1 for x in args])(*range(5)))
print(8,(lambda *args: {x+2 for x in args})(*range(5)))
```

    1 0
    2 8
    3 11
    4 35
    5 15
    6 <generator object <lambda>.<locals>.<genexpr> at 0x7f0db86a2468>
    7 [1, 2, 3, 4, 5]
    8 {2, 3, 4, 5, 6}



```
[x for x in (lambda *args: map(lambda x: x+1, args))(*range(5))]
```




    [1, 2, 3, 4, 5]




```
[x for x in (lambda *args: map(lambda x: (x+1,args), args))(*range(5))]
```




    [(1, (0, 1, 2, 3, 4)),
     (2, (0, 1, 2, 3, 4)),
     (3, (0, 1, 2, 3, 4)),
     (4, (0, 1, 2, 3, 4)),
     (5, (0, 1, 2, 3, 4))]

python的函数

#####  1，基本语法

列表解析式（list comprehension）
语法：
\[返回值 for 元素 in 可迭代对象 if 条件\] 
返回一个新的列表


```
l=[(i+1)**2 for i in range(10)] 
# 最外层的括号表示最后展示的数据为一个列表所以用[] 标记。
# 解析式前部分为生成元素部分，后半部分为迭代。
# 不能使用else子句
print(l)
print(type(l))

```

    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
    <class 'list'>


使用列表解析式可以大幅提高程序的效率。


```
###复杂的列表解析式
#写法1：
l1 = [(i,j) for i in range(7) if i>4 for j in range(20,25) if j > 23]
#写法2：
l2 = [(i,j) for i in range(7) for j in range(20,25) if i>4 if j>23]
#写法3：
l3 = [(i,j) for i in range(7) for j in range(20,25) if i>4 and j> 23]
print(l1,l2,l3)   #第三种写法最优。
```

    [(5, 24), (6, 24)] [(5, 24), (6, 24)] [(5, 24), (6, 24)]


##### 2，相关习题 


```
#返回1-10平方的列表
l4 = [i**2 for i in range(1,11)]
print(l4)
```

    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]



```
#有一个列表lst=[1,4,9,16,2,5,10,15],生产一个新的列表，求相邻两项的和。
lst = [1,4,9,16,2,5,10,15]
l5 = [lst[i]+lst[i+1] for i in range(len(lst)-1)]
print(l5)
```

    [5, 13, 25, 18, 7, 15, 25]



```
#打印九九乘法表
print('\n'.join([''.join(['%sx%s=%-3s' % (x,y,x*y) for x in range(1,y+1)]) for y in range(1,10)]))
```

    1x1=1  
    1x2=2  2x2=4  
    1x3=3  2x3=6  3x3=9  
    1x4=4  2x4=8  3x4=12 4x4=16 
    1x5=5  2x5=10 3x5=15 4x5=20 5x5=25 
    1x6=6  2x6=12 3x6=18 4x6=24 5x6=30 6x6=36 
    1x7=7  2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49 
    1x8=8  2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64 
    1x9=9  2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81 



python解析式与生成器

##### 1，datetime模块介绍 

datetime模块主要是对日期、时间和时间戳的处理。


```
import datetime  #导入模块（名词空间）
datetime.datetime.now() #获取当前时间 ==>返回一个对象
#说明：第一个datetime叫做名词空间，第二个datetime叫做类，now()返回一个对象。
#名词空间是存储对象的集合
#类方法相当于类的属性。
datetime.datetime.now().timestamp() #返回一个值
#timestamp()是将时间转换为微秒
#timestamp()是datetime.datetime.now()对象的一个方法。
```




    1535529464.27439




```
a = datetime.datetime.fromtimestamp(1535529464.27439) #从时间戳返回一个datetime对象
type(a)

```




    datetime.datetime



###### 构造datetime对象


```
b = datetime.datetime(1993,1,1)
b
```




    datetime.datetime(1993, 1, 1, 0, 0)



###### 取datetime对象的属性


```
b.microsecond  #取year month day hour minute second microsecond b这个对象的属性
```




    0




```
b1 = b.weekday() #判断b是星球几，weekday()是函数，星期一是0  
print(b1)
b2 = b.isoweekday() #判断b是星球几，weekday()是函数，星期一 是1  iso 国际化标准
print(b2)
```

    4
    5


返回date()对象


```
b.date()
```




    datetime.date(1993, 1, 1)



返回time()对象


```
b.time()
```




    datetime.time(0, 0)



###### 修改datetime对象


```
b.replace(2000,1,1)  #返回一个新的对象
```




    datetime.datetime(2000, 1, 1, 0, 0)



##### 2，日期格式化 

###### 类方法 

strptime（date_string,format）返回datetime对象


```
import datetime
dt = datetime.datetime.strptime("21/11/11 17:23","%d/%m/%y %H:%M") 
dt
```




    datetime.datetime(2011, 11, 21, 17, 23)



strptime是datetime.datetime类的方法，所以需要指定时间和格式。

###### 对象方法

strftime(format)返回字符串


```
print(dt.strftime("%Y-%m-%d %H:%M:%S"))
```

    2011-11-21 17:23:00


strftime(format)是对象的方法，仅仅需要指定格式。返回字符串。

###### 字符串format函数格式化

.format()


```
print("{0:%Y}/{0:%m}/{0:%d}::{0:%H}::{0:%M}::{0:%S}".format(dt))
```

    2011/11/21::17::23::00



```
print("{}/{}/{} {}:{}:{}".format(dt.year,dt.month,dt.day,dt.hour,dt.minute,dt.second))  ##建议写法
```

    2011/11/21 17:23:0



```
print("{0:%Y}/{0:%m}/{0:%d}".format(dt))
```

    2011/11/21


##### 3，timedelta对象

说明：
timedelta对象存储的是一个时间的差值。
一个时间对象可以去加或者减去这个时间对象从而得到一个新的时间对象。
构造方法：
datetime.timedelta(days=0,second=0，microseconds=0，minutes=0，hours=0，weeks=0)


```
import datetime
day=datetime.timedelta(days=1)  #构造一个timedelta
day2 = datetime.timedelta(3)
new_time=datetime.datetime.now()-day #使用timedelta计算
new_time2=datetime.datetime.now() - day2

print(new_time)
print(new_time2) # datetime.timedelta(3) 如果不指定时间单位，默认单位为天。
```

    2018-08-29 12:42:02.528002
    2018-08-27 12:42:02.528058



```
day.total_seconds()  #total_seconds()将timedelta转换为秒数。
```




    86400.0



##### 4，python标准库time
    

time.sleep(secs) #参数为秒数，表示将当前进程挂起的秒数。
其他与时候相关的建议使用datetime标准库。


python时间日期相关的标准库

##### 习题1:给一个圆的半径，求圆的周长和面积


```
import math                       #调用math函数，使用pi进行周长和面积的计算

r = int(input('圆的半径为：'))
if r > 0:                         #判断条件可以为True
    C = 2 * math.pi * r
    S = math.pi * r * r
    
    print ("圆周长是{}".format(C) )
    print ("圆面积是{}".format(S) )
    
else:
    print ('输入的半径无意义，请输入一个正数。')
    
```

    圆的半径为：11
    圆周长是69.11503837897544
    圆面积是380.1327110843649


##### 习题2:截取字符串


```
#截取'JAVA_HOME=/usr/bin' 中的 变量名和值
key,value='JAVA_HOME=/usr/bin'.split(sep='=')
print(key)
print(value)
```

    JAVA_HOME
    /usr/bin



```
# 截取基名前一个名称（父目录）
lst=input("请输入合法的路径：")
*_,basename,_= lst.split(sep='/')
print(basename)
```

    请输入合法的路径：/etc/sysconfig/network-script/ifcfg-eth
    network-script


##### 习题3:冒泡法排序


```
# 对列表[1,9,8,5,6,7,4,3,2]使用冒泡法进行排序，要求使用封装和解构来交换数据

lst = [1,9,8,5,6,7,4,3,2]
for i in range(len(lst)):
    for j in range(8-i):
        if lst[j]>lst[j+1]: #靠前位置的值大于靠后位置的值，前位置获取小的值。
            lst[j],lst[j+1]=lst[j+1],lst[j]
print(lst)
        

```

    [1, 2, 3, 4, 5, 6, 7, 8, 9]


##### 习题4:九九乘法表


```
##方法一：
for i in range(1,10):
    for j in range(1,i+1):
        print(j,'*',i,'=',j*i,'\t ',end=' ')
    print()
```

    1 * 1 = 1 	  
    1 * 2 = 2 	  2 * 2 = 4 	  
    1 * 3 = 3 	  2 * 3 = 6 	  3 * 3 = 9 	  
    1 * 4 = 4 	  2 * 4 = 8 	  3 * 4 = 12 	  4 * 4 = 16 	  
    1 * 5 = 5 	  2 * 5 = 10 	  3 * 5 = 15 	  4 * 5 = 20 	  5 * 5 = 25 	  
    1 * 6 = 6 	  2 * 6 = 12 	  3 * 6 = 18 	  4 * 6 = 24 	  5 * 6 = 30 	  6 * 6 = 36 	  
    1 * 7 = 7 	  2 * 7 = 14 	  3 * 7 = 21 	  4 * 7 = 28 	  5 * 7 = 35 	  6 * 7 = 42 	  7 * 7 = 49 	  
    1 * 8 = 8 	  2 * 8 = 16 	  3 * 8 = 24 	  4 * 8 = 32 	  5 * 8 = 40 	  6 * 8 = 48 	  7 * 8 = 56 	  8 * 8 = 64 	  
    1 * 9 = 9 	  2 * 9 = 18 	  3 * 9 = 27 	  4 * 9 = 36 	  5 * 9 = 45 	  6 * 9 = 54 	  7 * 9 = 63 	  8 * 9 = 72 	  9 * 9 = 81 	  



```
##方法二：
for i in range(1,10):  #i的值是[1,10)  i=1 ;  i=2
    line = '   '  #定义一个空的字符串
    for j in range(1,i+1): #[1,i+1) j=1   ; j=1 j=2  
        line += '{0}*{1}={2} '.format(j,i,i*j) #jxi = j*i =1 x1 =1  ; 1x2=2  2x2=4 
    print(line)
```

       1*1=1 
       1*2=2 2*2=4 
       1*3=3 2*3=6 3*3=9 
       1*4=4 2*4=8 3*4=12 4*4=16 
       1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
       1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
       1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
       1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
       1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 


<span id="inline-toc-red">打印倒置的九九乘法表</span>


```
for i in range(1,10):
    print(' '*7*(i-1),end='')
    for j in range(i,10):
        product = i*j
        
        if product < 10:
            end = '  '
        else:
            end = ' '
        print(str(i)+'*'+str(j)+'='+str(i*j),end=end)
    print()
```

    1*1=1  1*2=2  1*3=3  1*4=4  1*5=5  1*6=6  1*7=7  1*8=8  1*9=9  
           2*2=4  2*3=6  2*4=8  2*5=10 2*6=12 2*7=14 2*8=16 2*9=18 
                  3*3=9  3*4=12 3*5=15 3*6=18 3*7=21 3*8=24 3*9=27 
                         4*4=16 4*5=20 4*6=24 4*7=28 4*8=32 4*9=36 
                                5*5=25 5*6=30 5*7=35 5*8=40 5*9=45 
                                       6*6=36 6*7=42 6*8=48 6*9=54 
                                              7*7=49 7*8=56 7*9=63 
                                                     8*8=64 8*9=72 
                                                            9*9=81 


##### 习题5:求素数


```
## 方法一：
#求100内的素数
#思考：
#1，什么是素数？ 又称为质素，是在大于1的自然数中，除了1和它本身以外不再有其他因数。
#对正整数n，如果用2到根号n的之间的所有整数去除，均无法整除，则n为质数。

import math
p1=[2,3,5,7]
n = 100 
for x in range(10,n):
    for i in range(2,math.ceil(math.sqrt(x))):
        if x % i == 0:
            break
    else:
        p1.append(x)
print(p1)
```

    [2, 3, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 37, 41, 43, 47, 49, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]



```
## 方法二：
#合数一定可以分解成几个质素的乘积

import math 
n = 100 
p = []
for x in range(2,n):
    for  i in p:
        if x % i == 0:
            break
    else:
        print(x,end=' ')
        p.append(x)

        
```

    2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 


```
## 方法三： 
# 带flag判断，提高程序效率。
import math
p = []
flag = False
for x in range(2,100): #x=13
    for i in p:   #p=[2,3,5,7]
        if x % i ==0:  # x%i != 0 
            flag = True
            break
        if i >= math.ceil(math.sqrt(x)): #i< math.ceil(math.sqrt(x))
            flag = False
            break
    if not flag: #flag = false  ==> true
        print(x,end=' ')
        p.append(x) 
```

    2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 

##### 习题6:杨辉三角


```
## 方法一：
# 每个数等于它上方两数之和
# 每行数字左右对称，由1开始逐渐变大。
# 第n行的数字有n项。
# 第n行数字和为2n-1。

## 第一次循环 i=2 
t = [[1],[1,1]]
for i in range(2,6): #i=2
    cur = [1]
#    print(cur)
    pre = t[i-1] # t[1] ==> pre = [1,1] len(pre)=2 
#    print(pre)
    for j in range(len(pre)-1): # len(pre)-1 =1 ==> for j in [0,1)
        cur.append(pre[j]+pre[j+1]) # cur = [1].append ([0]+[1])=2  ==>[1,2] 
    cur.append(1) #[1,2,1]
    t.append(cur)# [[1], [1, 1], [1, 2, 1]] 
print(t)

## 第二次循环 i=3 
t_i3 = [[1],[1,1]]
for i in range(2,6): #i=3
    cur = [1] 
#    print(cur)
    pre = t_i3[i-1] # t[2] ==> pre = [1,2,1] ==> len(pre)=3 
#    print(pre)
    for j in range(len(pre)-1): # len(pre)-1 = 2 ==> for j in [0,1,2) 循环2次 j=0 and j=1
        cur.append(pre[j]+pre[j+1]) # cur第一次循环 = [1].append ([0]+[1])=3（pre[0]=1 and pre[1]=2 )) ==>[1,3] 
                                    # cur第二次循环 cur=[1,3].append([1]+[2]=3(pre[1=2 and pre [2]=1 )) ==> [1,3,3]
    cur.append(1) #[1,3,3,1]
    t_i3.append(cur)# [[1], [1, 1], [1, 2, 1],[1, 3, 3, 1]] 
print(t_i3)
```

    [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1]]
    [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1]]



```
## 方法二：
def YangHui (num = 6):
    LL = [[1]]
    for i in range(1,num):
        LL.append([(0 if j== 0else LL[i-1][j-1])+ (0 if j ==len(LL[i-1]) else LL[i-1][j]) for j in range(i+1)])
    return LL
a = YangHui()
print(a)
```

    [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1]]


#####  习题7:打印转置矩阵


```
## 方法一：
def trans(m):

  a = [[] for i in m[0]] #打印两个原始列表
  count = 0
  for i in m: #i=[1,2],拿出第一个列表
    count += 1
    print(a)
    print(i)
    print(m)
    for j in range(len(i)): # j in (0,1)，将列表的数据分别插入到新的列表中
      a[j].append(i[j]) #a[0].append(i[0]) ==> []+1 = [1]  
                        #a[1].append(i[1]) ==> []+2 = [2]
    print(count ) 
  return a

m = [[1, 2,3,5], [3, 4,4,5], [5,4, 6],[0,4,5,3]]  
print(trans(m))
```

    [[], [], [], []]
    [1, 2, 3, 5]
    [[1, 2, 3, 5], [3, 4, 4, 5], [5, 4, 6], [0, 4, 5, 3]]
    1
    [[1], [2], [3], [5]]
    [3, 4, 4, 5]
    [[1, 2, 3, 5], [3, 4, 4, 5], [5, 4, 6], [0, 4, 5, 3]]
    2
    [[1, 3], [2, 4], [3, 4], [5, 5]]
    [5, 4, 6]
    [[1, 2, 3, 5], [3, 4, 4, 5], [5, 4, 6], [0, 4, 5, 3]]
    3
    [[1, 3, 5], [2, 4, 4], [3, 4, 6], [5, 5]]
    [0, 4, 5, 3]
    [[1, 2, 3, 5], [3, 4, 4, 5], [5, 4, 6], [0, 4, 5, 3]]
    4
    [[1, 3, 5, 0], [2, 4, 4, 4], [3, 4, 6, 5], [5, 5, 3]]


##### 习题8.字典扁平化 

要求：把源字典转换为目标字典
源字典：{'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}}
目标字典：{'a.b': 1, 'a.c': 2, 'd.e': 3, 'd.f.g': 4}




```
#dst = {'d.e': 3, 'a.c': 2, 'a.b': 1, 'd.f.g': 4} 
#a,v_a;
#b,v_a
#为什么需要个前缀呢？
#中心思想，递归
#判断v是否为字典，如果是字典则继续分解，如果不是字典就输出


source = {'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}}

def flatmap(src,dest=None,prefix=''):
    if dest == None:
        dest = {}
        
    for k,v in src.items():
        if isinstance(v,(list,dict)): #判断v是否为字典，如果是字典则继续分解，如果不是字典就输出
            flatmap(v,prefix=prefix+k+'.') #把v再次传入flatmap函数，此时参数已经为prfix+.了
        else:
            target[prefix+k] = v
    return dest

flatmap(source)
print(target)
```

    {'a.b': 1, 'a.c': 2, 'd.e': 3, 'd.f.g': 4}



```
source = {'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}}

def flatmap(src):
    def _flatmap(src,dest=None,prefix=''):
        for k,v in src.items():
            key = prefix + k            
            if isinstance(v,(list,dict)): #判断v是否为字典，如果是字典则继续分解，如果不是字典就输出
                _flatmap(v,dest,key+'.') #把v再次传入flatmap函数，此时参数已经为prfix+.了
            else:
                dest[key] =v 
    dest = {}
    _flatmap(src,dest)
    
    return dest



print(flatmap(source))
```

    {'a.b': 1, 'a.c': 2, 'd.e': 3, 'd.f.g': 4}


##### 习题9:给定一个不超过5位的正整数，判断其有几位？使用input函数 


```
num = int(input())

if  (num /10000)>=1  and (num /10000) < 10:
    print('5')
elif (num /1000)>=1  and (num /1000) < 10:
    print('4')    
elif (num /100)>=1  and (num /100) < 10:
    print('3')
elif (num /10)>=1  and (num /10) < 10:
    print('2')
elif num >=1  and  num  < 10:
    print('1')
else:
    print('error')
```

    1123
    4



```
num = int(input())

if  num <= 9 and num >=0:
    print("1")
elif num <= 99:
    print('2')
elif num <= 999:
    print("3")
elif num <= 9999:
    print("4")
else:
    print('error')
```

    112
    3



```
num = int(input())


if num < 100:
    if av <10 and av > 0:
        print('1')
    elif av <100 and av >= 10:
        print('2')
    
elif 100<=num <=9999:
    av = num /100
    if av >= 1 and av < 10:
        print('3')
    elif av >= 10 and av <100:
        print('4')
else:
    print('error')
```

    111111
    error


**while 实现**


```
num =1000000
count = 0

while num >=10: 
    
    
    if num / 10 >= 1:  
        
        num = num / 10
        
        count +=1 
        
print(count+1)

```

    7


统计位数，并且倒序打印出每一位


```
num1 = num  = 12345678

count = 0

while num >= 10:
    if num / 10 >= 1:
        count +=1
        num = num // 10 
        
        print(num1-num*10) 
        num1 = num
        num1 -  num * 10 
    if num <  10 :
        print(num)
        
print('total:',count+1)
```

    8
    7
    6
    5
    4
    3
    2
    1
    total: 8


##### 习题10：打印一个正方形 


```
for i in range(4):
    print('*  '*4)
```

    *  *  *  *  
    *  *  *  *  
    *  *  *  *  
    *  *  *  *  



```
for i in range(1,10):
    if i == 1:
        print('* '*10)
    elif i<9:
        print('*'+' '*17+'*')
    else:
        print('* '*10)
```

    * * * * * * * * * * 
    *                 *
    *                 *
    *                 *
    *                 *
    *                 *
    *                 *
    *                 *
    * * * * * * * * * * 


#####  习题11：求100以内的奇数和


```
sum = 0 
for i in range(1,100,2):
    sum += i
print(sum)    
```

    2500



```
sum = 0 
for i in range(1,100):
    if i % 2 !=0:
        sum += i 
print(sum)
```

    2500


##### 习题12： 求5的阶乘 


```
num = 1
for i in range(1,5):
    num *=i
    
print(num)
```

    24


求1到5的阶乘之和


```
num = 1
a = 0
for i in range(1,6): #5
    
    for n in range(1,i+1): #1-5
        
        num *=n  
       
    a += num
  
    num = 1
print(a)
```

    153



```
num = 1
a = 0
for n in range(1,6): #n= 1 , n =2  n =3   
    num *=n    # num = 1, num = 2 *1 = 2  num = 2 x 3
    a += num # a= 1 a = 1+2  a = 1+2 +6 
    
print(a)
```

    153


##### 习题13：打印菱形


```
for i in range(1,8):
    if i <=4:
        print((4-i)*' '+'*'*(2*i-1))
    else:
        print((i-4)*' '+'*'*(2*(8-i)-1))
```

       *
      ***
     *****
    *******
     *****
      ***
       *



```
for i in range(-3,4): #[-3,3]
    if i < 0:
        p = -i
    else:
        p = i
    print(' '*p+'*'*(7-p*2))
```

       *
      ***
     *****
    *******
     *****
      ***
       *



```
for i in range(1,8):
    print((4-i)*' '+'*'*(2*i-1)) if i <=4   else print((i-4)*' '+'*'*(2*(8-i)-1)) 
```

       *
      ***
     *****
    *******
     *****
      ***
       *



```
a, b, c = 1, 2, 3
if a>b:
    c = a
else:
    c = b
    
## 变异写法==>

c = a if a>b else b
```

##### 习题14：生成0000.zhuajgmncp 形式的的字符串，点号前有序，之后为无序的字符串


```
import random
random_str = ''
str_word = 'abcdefghijklmnopqlstuvwxyz'

for i in range(10):
    str_i=("%04d" % i)
    
    
    lst = list(str_word)
    random_list = random.choices(lst,k=10)
    for tmp_str in random_list:
        random_str+=tmp_str
    
    new = str_i + '.'+random_str
    random_str = ''
    print(new)
```

    0000.dsjvxdnkww
    0001.sjlaeyjpcl
    0002.ucypwqeoah
    0003.ofkllwkdmi
    0004.bujjgomwsl
    0005.ouzvmfngti
    0006.wsqvpxayob
    0007.oqobuqongf
    0008.aqiplnlljx
    0009.mwpmnjjgmj



```
['{:04},{}'.format(n,''.join([random.choice(bytes(range(97,123)).decode()) for _ in range(10)])) for n in range(1,10)]
```




    ['0001,mhtflcfjcj',
     '0002,aiedozjflp',
     '0003,wtnddoeiof',
     '0004,jwimjzeant',
     '0005,nahqnwsozj',
     '0006,jbfbeykmke',
     '0007,brhqtxyits',
     '0008,fzdrthuhuf',
     '0009,slfwnjpfmg']


