Python之路【3补充】:Python基础(三)

简介: lambda表达式 学习条件运算时,对于简单的 if else 语句,可以使用三元运算来表示,即: # 普通条件语句if 1 == 1: name = ‘luotianshuai'else: name = 'shuaige' # 三元运算name = 'luotianshuai' if 1 == 1 else 'shuaige'#这个就是if

lambda表达式

学习条件运算时,对于简单的 if else 语句,可以使用三元运算来表示,即:

# 普通条件语句
if 1 == 1:
    name = ‘luotianshuai'
else:
    name = 'shuaige'
  
# 三元运算
name = 'luotianshuai' if 1 == 1 else 'shuaige'

#这个就是if else的一个简写。
#if 条件成立的时候name为'luotianshuai' 不成立的时候为:'shuaige' ,语法糖!

 

那么函数有没有他的简写呢?也是有的lambda表达式!

lambda 和if  else的三元运算一样,是为了简化函数,但是:

1、只能做简单的操作
2、自动return

看下面两个函数的对比:

'''正常函数'''
def func(arg):
    return arg + 1
result = func(100)
print result

'''lambda表达式'''
func2 =  lambda a: a + 1
result = func2(10000)
#这里调用函数的时候就是lambda表达式左边的等号就是他函数的调用!
print result

#执行结果:
#101
#10001

内置函数 二

一、map

遍历序列,对序列中每个元素进行操作,最终获取新的序列。


解释:

在Python中,最基本的数据结构是序列(sequence)。序列中的每个元素被分配一个序号——即元素的位置,也称为索引。第一个索引是 0,第二个则是 1,以此类推。序列中的最后一个元素标记为 -1,倒数第二个元素为 -2,一次类推。        

Python包含 6 中内建的序列,包括列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。

  map例子
'''例子1'''
li =  [11,22,33]

def func1(arg):
    return arg + 1  #这里乘除都可以

new_list = map(func1,li)  #这里map调用函数,函数的规则你可以自己指定,你函数定义成什么他就做什么操作!
print new_list
输出结果:[12, 23, 34]

'''例子2'''
li = ['shuaige','nihao',]
def func1(arg):
    return '%s test string' % arg  #或者使用+进行拼接万恶的+能不用最好不用他会在内存中开辟新的空间!

new_strlist = map(func1,li)
print new_strlist

输出结果:['shuaige test string', 'nihao test string']

'''例子3'''
li = 'abcdefg'
def func1(arg):
    return '%s test string' % arg

new_list = map(func1,li)
print new_list
#结果:['a test string', 'b test string', 'c test string', 'd test string', 'e test string', 'f test string', 'g test string']

map例子

 使用lambda表达式:

  lambda表达式
li = [11,22,33,44,55]
new_li = map(lambda a:a + 100,li)
print new_li

#输出结果:   [111, 122, 133, 144, 155]


#多个列表操作:
l1 = [11,22,33,44,55]
l2 = [22,33,44,55,66]
l3 = [33,44,55,66,77]
print map(lambda a1,a2,a3:a1+a2+a3,l1,l2,l3)
#输出结果:  [66, 99, 132, 165, 198] 
#这里需要注意如果使用map函数列表中的元素必须是相同的才可以!否则就会报下面的错误!
#TypeError: unsupported operand type(s) for +: 'int' and 'NoneType',如果看下面
l1 = [11,22,33,44,55]
l2 = [22,33,44,55,66]
l3 = [33,44,55,66,]
#l3的数据少一个,如果元素里的元素为空那么他调用的时候这个元素就是None

lambda表达式

二、filter

对于序列中的元素进行筛选,最终获取符合条件的序列!



li = [11,22,33,44,55,66,77,88]

print filter(lambda a:a>33,li)
输出结果:[44, 55, 66, 77, 88]

三、reduce

对于序列内所有元素进行累计操作


li = [1,2,3,4,5,6,7,8]
result =  reduce(lambda a1,a2:a1+a2,li) #累乘、除、加、减
print result

# reduce的第一个参数,函数必须要有两个参数,因为他是两两进行操作
# reduce的第二个参数,要循环的序列
# reduce的第三个参数,初始值

#初始值
li = [1,2,3,4,5,6,7,8]
result =  reduce(lambda a1,a2:a1+a2,li,100000) #累乘、除、加、减
print result
默认参数:


yield生成器

yield和return的区别:

    yield跳出函数后会记录当前函数的状态当下次调用的时候,从记录的状态开始!

    return后将直接跳出函数!

1、对比range 和 xrange 的区别

>>> print range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print xrange(10)
xrange(10)

如上代码所示,range会在内存中创建所有指定的数字,而xrange不会立即创建,只有在迭代循环时,才去创建每个数组。

看下下面的例子:(自定义生成器)

def mrange(arg):
    seed = 0
    while True:
        seed = seed +1
        if seed > arg:
            return
        else:
            yield seed
for i in mrange(10):
    print i

 冒泡算法

需求:请按照从小到大对列表 [13, 22, 6, 99, 11] 进行排序


思路:相邻两个值进行比较,将较大的值放在右侧,依次比较!

冒泡算法原理图:


冒泡算法实例:
列表中有5个元素两辆进行比较,然后用中间值进行循环替换!
既然这样,既然这样我们还可以用一个循环把上面的循环进行在次循环,用表达式构造出内部循环!

li = [13,22,6,99,11]
for n in range(1,len(li)):
    for m in range(len(li)-n):
        num1 = li[m]
        num2 = li[m+1]
    if num1 > num2:
        temp = li[m]
        li[m] = num2
        li[m+1] = temp
print li

让的原理和下面一样:

  冒泡算法原理
li = [13,22,6,99,11]

for m in range(4):  #等价于:for m in range(len(li)-1)
    num1 = li[m]
    num2 = li[m+1]
    if num1 > num2:
        temp = li[m]
        li[m] = num2
        li[m+1] = temp
print  li
for m in range(3): #等价于:for m in range(len(li)-2)
    num1 = li[m]
    num2 = li[m+1]
    if num1 > num2:
        temp = li[m]
        li[m] = num2
        li[m+1] = temp
print  li
for m in range(2): #等价于:for m in range(len(li)-3)
    num1 = li[m]
    num2 = li[m+1]
    if num1 > num2:
        temp = li[m]
        li[m] = num2
        li[m+1] = temp
print  li
for m in range(1): #等价于:for m in range(len(li)-4)
    num1 = li[m]
    num2 = li[m+1]
    if num1 > num2:
        temp = li[m]
        li[m] = num2
        li[m+1] = temp
print  li

冒泡算法原理

 装饰器

装饰器是函数,只不过该函数可以具有特殊的含义,装饰器用来装饰函数或类,使用装饰器可以在函数执行前和执行后添加相应操作。

简单的来说在不修改原函数的情况下,在对原函数进行包装!

 

一、初创公司有N个业务部门,1个基础平台部门,基础平台负责提供底层的功能,如:数据库操作、redis调用、监控API等功能。业务部门使用基础功能时,只需调用基础平台提供的功能即可。如下:

 

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
############### 基础平台提供的功能如下 ###############
  
def  f1():
     print  'f1'
  
def  f2():
     print  'f2'
  
def  f3():
     print  'f3'
  
def  f4():
     print  'f4'
  
############### 业务部门A 调用基础平台提供的功能 ###############
  
f1()
f2()
f3()
f4()
  
############### 业务部门B 调用基础平台提供的功能 ###############
  
f1()
f2()
f3()
f4()

 目前公司有条不紊的进行着,但是,以前基础平台的开发人员在写代码时候没有关注验证相关的问题,即:基础平台的提供的功能可以被任何人使用。现在需要对基础平台的所有功能进行重构,为平台提供的所有功能添加验证机制,即:执行功能前,先进行验证。

老大把工作交给 Low B,他是这么做的:

 

1
跟每个业务部门交涉,每个业务部门自己写代码,调用基础平台的功能之前先验证。诶,这样一来基础平台就不需要做任何修改了。

 当天Low B 被开除了...

老大把工作交给 Low BB,他是这么做的:

1
只对基础平台的代码进行重构,让N业务部门无需做任何修改
  修改原基础平台代码
############### 基础平台提供的功能如下 ############### 

def f1():
    # 验证1
    # 验证2
    # 验证3
    print 'f1'

def f2():
    # 验证1
    # 验证2
    # 验证3
    print 'f2'

def f3():
    # 验证1
    # 验证2
    # 验证3
    print 'f3'

def f4():
    # 验证1
    # 验证2
    # 验证3
    print 'f4'

############### 业务部门不变 ############### 
### 业务部门A 调用基础平台提供的功能### 

f1()
f2()
f3()
f4()

### 业务部门B 调用基础平台提供的功能 ### 

f1()
f2()
f3()
f4()

修改原基础平台代码

过了一周 Low BB 被开除了...

老大把工作交给 Low BBB,他是这么做的:

1
只对基础平台的代码进行重构,其他业务部门无需做任何修改
  新建立一个函数把函数应用到原基础函数上
############### 基础平台提供的功能如下 ############### 

def check_login():
    # 验证1
    # 验证2
    # 验证3
    pass


def f1():
    
    check_login()

    print 'f1'

def f2():
    
    check_login()

    print 'f2'

def f3():
    
    check_login()

    print 'f3'

def f4():
    
    check_login()
    
    print 'f4'

新建立一个函数把函数应用到原基础函数上

老大看了下Low BBB 的实现,嘴角漏出了一丝的欣慰的笑,语重心长的跟Low BBB聊了个天:

老大说:

写代码要遵循开发封闭原则,虽然在这个原则是用的面向对象开发,但是也适用于函数式编程,简单来说,它规定已经实现的功能代码不允许被修改,但可以被扩展,即:

  • 封闭:已实现的功能代码块
  • 开放:对扩展开发

如果将开放封闭原则应用在上述需求中,那么就不允许在函数 f1 、f2、f3、f4的内部进行修改代码,老板就给了Low BBB一个实现方案:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def  w1(func):
     def  inner():
         # 验证1
         # 验证2
         # 验证3
         return  func()
     return  inner
  
@w1
def  f1():
     print  'f1'
@w1
def  f2():
     print  'f2'
@w1
def  f3():
     print  'f3'
@w1
def  f4():
     print  'f4'

对于上述代码,也是仅仅对基础平台的代码进行修改,就可以实现在其他人调用函数 f1 f2 f3 f4 之前都进行【验证】操作,并且其他业务部门无需做任何操作。

Low BBB心惊胆战的问了下,这段代码的内部执行原理是什么呢?

老大正要生气,突然Low BBB的手机掉到地上,恰恰屏保就是Low BBB的女友照片,老大一看一紧一抖,喜笑颜开,交定了Low BBB这个朋友。详细的开始讲解了:

单独以f1为例:

1
2
3
4
5
6
7
8
9
10
11
12
def  w1(func):
     def  inner():
         print  'gongneng1'
         func()
         print  'gongneng2'
     return  inner
 
@w1
def  f1():
     print  'f1'
 
f1()

 当执行的时候,python是由上到下执行的,首先执行到def w1(func):这里把def w1(func)加载到内存

当执行到@w1的时候@w1是python的语法糖!他会把他下面的函数进行封装。

把f1这个函数作为def w1(func)的参数传进去!就是:f1()=w1(f1)

然后def w1(func):  == w1(f1)就会执行:

1
2
3
4
5
def  inner():
     print  'gongneng1'
     func()    #func()  == f1()“原函数”
     print  'gongneng2'
return  inner   #然后把封装后的函数输出给原函数

@w1就相当于做了一个替换

def f1()  <==> def inner()

1
2
3
4
5
@w1
def  f1():          #  ==def inner() :
     print  'f1'     #           print 'gongneng1'
                   #           func()
                   #           print 'gongneng2'


二、被装饰的函数如果有参数呢?

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
36
37
38
39
40
41
42
43
def  w1(func):
     def  inner(arg):
         # 验证1
         # 验证2
         # 验证3
         return  func(arg)
     return  inner
 
@w1
def  f1(arg):
     print  'f1'
 
一个参数
 
 
################################
def  w1(func):
     def  inner(arg1,arg2):
         # 验证1
         # 验证2
         # 验证3
         return  func(arg1,arg2)
     return  inner
 
@w1
def  f1(arg1,arg2):
     print  'f1'
 
两个参数
################################
def  w1(func):
     def  inner(arg1,arg2,arg3):
         # 验证1
         # 验证2
         # 验证3
         return  func(arg1,arg2,arg3)
     return  inner
 
@w1
def  f1(arg1,arg2,arg3):
     print  'f1'
 
三个参数

 用动态参数搞定!

1
2
3
4
5
6
7
8
9
10
11
def  w1(func):
     def  inner( * args, * * kwargs):
         # 验证1
         # 验证2
         # 验证3
         return  func( * args, * * kwargs)
     return  inner
  
@w1
def  f1(arg1,arg2,arg3):
     print  'f1'

三、一个函数可以被多个装饰器装饰吗?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def  w1(func):
     def  inner( * args, * * kwargs):
         print  'gongneng1'
         func( * args, * * kwargs)
         print  'gongneng2'
     return  inner
def  w2(func):
     def  inner( * args, * * kwargs):
         print  'gongneng3'
         func( * args, * * kwargs)
         print  'gongneng4'
     return  inner
 
@w1
@w2
def  f1(arg,arg2,arg3):
     print  arg,arg2,arg3
 
f1( 'nihao' , 'tianshuai' , 'shuaige' )

 输出结果:

1
2
3
4
5
gongneng1
gongneng3
nihao tianshuai shuaige
gongneng4
gongneng2

 这个被多个装饰器装饰,其实就是套完一层在套一层!勿把自己绕进去!

 四、还有什么更吊的装饰器吗?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def  Filter (a1,a2):
     def  outer(main_func):
         def  wrapper(request,kargs):
             print  a1
             main_result  =  main_func(request,kargs)
             print  a2
                 return  main_result
         return  wrapper
     return  outer
 
@Filter (f5, f6)
def  Index(request,kargs):
     print  'index'
     
'''
1、第一步:把def Filter(a1,a2): 加载到内存
2、第二步:@Filter(f5, f6)  == 调用了装饰器  == @outer 然后返回给函数
3、第散步:执行outer函数并返回给index函数  Index == wrapper
4、执行wrapper 函数,这样做的意义就是除了原函数给的参数外,装饰器也可以调用自己定义的参数
 
'''

 这样做的意义就是除了原函数给的参数外,装饰器也可以调用自己定义的参数


出处: http://www.cnblogs.com/luotianshuai/  
相关文章
|
前端开发 测试技术
软件测试|selenium+python基础方法封装(二)
软件测试|selenium+python基础方法封装(二)
187 0
软件测试|selenium+python基础方法封装(二)
|
Web App开发 Java 测试技术
软件测试|selenium+python基础方法封装(一)
软件测试|selenium+python基础方法封装(一)
246 0
软件测试|selenium+python基础方法封装(一)
|
C语言 Python
通过题目入门python基础1
简介:本文通过,python的基础题目,带领大家入门python的基础语法,以实用主义为主。
224 0
通过题目入门python基础1
|
数据安全/隐私保护 Python
Python操作ppt和pdf基础
Python操作ppt和pdf基础
349 0
Python操作ppt和pdf基础
|
Python Windows
Python操作word基础
Python操作word基础
233 0
Python操作word基础
|
Python
Python操作excel基础
Python操作excel基础
161 0
Python操作excel基础
|
机器学习/深度学习 存储 人工智能
【paddle领航团基础python课程】三岁水课—结营大作业
【paddle领航团基础python课程】三岁水课—结营大作业
154 0
【paddle领航团基础python课程】三岁水课—结营大作业
|
Java C语言 Python
【paddle领航团基础python课程】三岁水课—python基础
大家好,这里是三岁,别的不会,擅长白话,今天就是我们的白话系列,内容就是大家看的迷迷茫茫的python基础,由于python是自学的,我也翻看了很多的教学视频和书籍,也看过部分的文档,写过自己的心得与笔记,那么接下看看,让我们一起来看看内容
131 0
【paddle领航团基础python课程】三岁水课—python基础
|
分布式计算 Python
python基础进阶 高阶函数基础
大家好,这里是三岁接下来带来的是传说中的高阶函数,如有不足请大家多多指出
136 0
python基础进阶 高阶函数基础