为了账号安全,请及时绑定邮箱和手机立即绑定

python进阶

廖雪峰 移动开发工程师
难度中级
时长 3小时33分
学习人数
综合评分91.7
561人评价 查看评价
9.6 内容实用
9.0 简洁易懂
8.9 逻辑清晰
  • 实例的属性和类的属性是不同的,所有实例访问的类属性都是同一个,其值有全局的意味

    class Person(object):
        count=0
        def __init__(self,name):
            self.name=name
            Person.count+=1

    这里count是Person类属性,每次调用一个实例就会使count++

  • 实例属性前加双下划线则该属性不能在外部访问self.__score=score

    这里__score就不能用实例直接在外部访问

  • class Person(object):
        def __init__(self,name,gender,birth,**kw):
            self.name=name
            self.gender=gender
            self.birth=birth
            for k,v in kw.items():
                setattr(self,k,v)
    
    xiaoming = Person('Xiao Ming', 'Male', '1990-1-1', job='Student')

    当类的__init__函数的参数为**kw(字典),给实例定义的方法不能使用:

    for k,v in kw.items():
        self.k=v

    因为类把kw当做一个属性,就如前面的name,gender,birth一样,这里的k和他们是不同级别的

  • 在python类块或者函数块中如果没想好要写什么,可以在块中用pass代替空内容:

    class Person(object):
        pass


  • 在旧版本中使用新版本与旧版本不兼容的特性:

    from __future__ import xxx

    注意:字符串前+u方法在3.x版本已废弃,所有str均为unicode编码

  • 导入模块结合异常处理:

    try:
        import moduel1
    except ImportError:
        import moduel2

    意义是尝试导入moduel1,如果不存在此模块则导入moduel2

  • 类比java:

    python中的模块相当于java中的包

    python中的函数相当于java中的类

    导入模块:
    import moduel(导入了moduel中包含的所有函数)

    from moduel import function(只导入了moduel中的function函数)

    from moduel import function as f(导入函数后重命名为f)

  • 偏函数functools.partial(f,parameter=default_parameter)

    给函数以默认的参数,调用f时不写出parameter则默认为偏函数中给出的default_parameter

    import functools
    
    sorted_ignore_case = functools.partial(sorted,cmp=lambda x,y:cmp(x.upper(),y.upper()))
    
    print sorted_ignore_case(['bob', 'about', 'Zoo', 'Credit'])


  • python中自带的比较字符串函数:cmp(str1,str2)

    返回-1,0,1

  • 使用过decorator之后原函数的部分参数会丢失,为了补救此情形,引入@functools.wraps(f),使用在最内层的decorator的上一行

    import time, functools
    
    def performance(unit):
        def dec_perf(f):
            @functools.wraps(f)
            def wrapper(*args,**kw):
                t1=time.time()
                r=f(*args,**kw)
                t2=time.time()
                if unit=='s':
                    print("call "+f.__name__+"() in "+str(t2-t1)+"s")
                if unit=='ms':
                    print("call "+f.__name__+"() in "+str(1000*(t2-t1))+"ms")
                return r
            return wrapper
        return dec_perf
    
    @performance('ms')
    def factorial(n):
        return reduce(lambda x,y: x*y, range(1, n+1))
    
    print factorial.__name__


  • 执行含参数的decorator:

    三层嵌套函数定义

    在内部两层与无参数decorator的区别是使用到最外层的参数

    import time
    
    def performance(unit):
        def dec_per(f):
            def dec_perf(*args,**kw):
                t1=time.time()
                tmp=f(*args,**kw)
                t2=time.time()
                if(unit=='s'):
                    print("call "+f.__name__+"() in "+str(t2-t1)+"s")
                if(unit=='ms'):
                    print("call "+f.__name__+"() in "+str(100*(t2-t1))+"ms")
                return tmp
            return dec_perf
        return dec_per
    
    @performance('ms')
    def factorial(n):
        return reduce(lambda x,y: x*y, range(1, n+1))
    
    print factorial(10)


  • 高阶函数应用:decorator

    @yourDecoratorName 使用在欲加函数的上一行

    使得函数被永久更改为装饰后的函数

    如果希望装饰器函数适配各种参数数量的函数,则在装饰器内部定义子函数fn(*args,**kw),在此函数内部建立指向f的变量并返回f

    import time
    
    def performance(f):
        def fn(*args,**kw):
            t1=time.time()
            tmp=f(*args,**kw)
            t2=time.time()
            print("call "+f.__name__+"() in "+str(t2-t1))
            return tmp
        return fn
    
    @performance
    def factorial(n):
        return reduce(lambda x,y: x*y, range(1, n+1))
    
    print factorial(10)


  • python中的匿名函数就是lambda表达式:
    格式:lambda parameters:expression

    这里 expression就是匿名函数的返回值

  • 解释这段代码:

    def count():
        fs = []
        for i in range(1, 4):
            def f(j):
                def g():
                    return j*j
                return g
            r=f(i)
            fs.append(r)
        return fs
    
    f1, f2, f3 = count()
    print f1(), f2(), f3()

    为了避免在闭包中子函数定义时使用循环变量,在子函数f中再定义一个子函数g,用g实现乘方的功能

    之后再写一个变量r指向f,f在执行时使用到循环变量是允许的

  • 解释一下这段返回函数的代码:

    def calc_prod(lst):
        def prod():
            cnt=1.0
            for x in lst:
                cnt*=x
            return cnt
        return prod
    
    f = calc_prod([1, 2, 3, 4])
    print f()

    在最外的函数calc_prod(lst)中包含了一个函数prod(),因为最后print f(),可见f指向的函数并不含参数,所以prod作为calc_prod返回的函数也不应含有参数(而calc_prod的参数lst在prod的定义中是可用的

  • sorted(list,f)自定义排序函数

    按照f(elem1,elem2)的返回值作为排序依据

    elem1在elem2前,f返回-1

    elem1在elem2后,f返回1

    如果相等,f返回0

  • filter(f,list)

    要求f函数返回bool值,作为list值是否满足要求的依据

    filter返回包含符合f函数要求的元素的list

  • reduce(f,list,initElem)(第三个参数可以没有)

    f函数必须接受两个参数:第一个参数是上次执行的结果,第二个参数是list元素

    也就是说,list元素鱼贯执行f

首页上一页1234567下一页尾页

举报

0/150
提交
取消
课程须知
本课程是Python入门的后续课程 1、掌握Python编程的基础知识 2、掌握Python函数的编写 3、对面向对象编程有所了解更佳
老师告诉你能学到什么?
1、什么是函数式编程 2、Python的函数式编程特点 3、Python的模块 4、Python面向对象编程 5、Python强大的定制类
意见反馈 邀请有奖 帮助中心 APP下载
官方微信