慕课网

奋斗的狼小胖

怎么看正序和倒序

查看全部

0 采集收起来源：python中自定义排序函数

2019-04-11

慕盖茨030889

import math

def is_sqr(x):

x=math.sqrt(x)

return x and x-int(x)==0

print filter(is_sqr, range(1, 101))

查看全部

0 采集收起来源：python中filter()函数

2019-04-11

怪大文

任务

对字符串排序时，有时候忽略大小写排序更符合习惯。请利用sorted()高阶函数，实现忽略大小写排序的算法。

输入：['bob', 'about', 'Zoo', 'Credit']
输出：['about', 'bob', 'Credit', 'Zoo']

?不会了怎么办

对于比较函数cmp_ignore_case(s1, s2)，要忽略大小写比较，就是先把两个字符串都变成大写（或者都变成小写），再比较。

参考代码:

def cmp_ignore_case(s1, s2):
    u1 = s1.upper()
    u2 = s2.upper()
    if u1 < u2:
        return -1
    if u1 > u2:
        return 1
    return 0
print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)

查看全部

0 采集收起来源：python中自定义排序函数

2019-04-11

怪大文

filter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：

def is_odd(x):
    return x % 2 == 1

然后，利用filter()过滤掉偶数：

filter(is_odd, [1, 4, 6, 7, 9, 12, 17])

结果：[1, 7, 9, 17]

利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：

def is_not_empty(s):
    return s and len(s.strip()) > 0
filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])

结果：['test', 'str', 'END']

查看全部

0 采集收起来源：python中filter()函数

2019-04-11

怪大文

注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。

当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')，如下：

a = '     123'
a.strip()

结果： '123'

a='\t\t123\r\n'
a.strip()

结果：'123'

查看全部

0 采集收起来源：python中filter()函数

2019-04-11

怪大文

reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。

例如，编写一个f函数，接收x和y，返回x和y的和：

def f(x, y):
    return x + y

调用 reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：

先计算头两个元素：f(1, 3)，结果为4；
再把结果和第3个元素计算：f(4, 5)，结果为9；
再把结果和第4个元素计算：f(9, 7)，结果为16；
再把结果和第5个元素计算：f(16, 9)，结果为25；
由于没有更多的元素了，计算结束，返回结果25。

上述计算实际上是对 list 的所有元素求和。虽然Python内置了求和函数sum()，但是，利用reduce()求和也很简单。

reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：

reduce(f, [1, 3, 5, 7, 9], 100)

结果将变为125，因为第一轮计算是：

计算初始值和第一个元素：f(100, 1)，结果为101。

查看全部

0 采集收起来源：python中reduce()函数

2019-04-11

怪大文

upper（）字母变大写

lower （）字母变小写

查看全部

0 采集收起来源：python中map()函数

2019-04-11

怪大文

计算平方根可以用函数：

>>> math.sqrt(2)
1.4142...

查看全部

0 采集收起来源：python把函数作为参数

2019-04-11

宝慕林5301395

python可以把任意变量变成str：任何数据类型的实例都有一个特殊方法【__str__()】。

特殊方法包括：用于print的__str__方法；用于len的__len__方法；用于比较的__cmp__方法。

特殊方法的特点：

定义在class中，不需要直接调用，python的某些函数或操作符会调用相应的特殊方法；有关联性的特殊方法需要同时实现。

查看全部

0 采集收起来源：python中什么是特殊方法

2019-04-11

宝慕林5301395

def __init__(self, name, gender, **kw):

self.name = name

self.gender = gender

for k, v in kw.iteritems():

setattr(self, k, v)

【提供任意额外的关键字参数，并绑定到实例中】

查看全部

0 采集收起来源：python中获取对象信息

2019-04-11

哎呀还好啦

与类和实例无绑定关系的function都属于函数（function）；
与类和实例有绑定关系的function都属于方法（method）。

查看全部

0 采集收起来源：python中方法也是属性

2019-04-11

qq_手牵手握住幸福_0

高阶函数

高阶函数：能接受函数做参数的函数

map函数
map函数不会改变原有的list，而是返回一个新的list

# list的每个元素都作平方
def fn(x):
    return x*x
L = map(fn,[1,2,3])
print L  #==> [1, 4, 9]

reduce函数
reduce()对list的每个元素反复调用函数f，并返回最终结果值。

# 计算list每个元素的以此相乘
def fn(x, y):
    return x*y
print reduce(fn, [1, 2, 3])  #==>6

reduce()还可以接收第3个可选参数，作为计算的初始值。

print reduce(fn, [1, 2, 3], 5)  #==>30

filter函数
filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

# 返回偶数
def fn(x):
    return x%2 == 0
print filter(fn, range(1, 10))  #==>[2, 4, 6, 8]

sorted函数
如果 x 排在 y 的前面，返回 -1，
如果 x 排在 y 的后面，返回 1。
如果 x 和 y 相等，返回 0。

# 对list进行从小到大排序
def fn(x, y):
    if x<y:
        return -1
    if x>y:
        return 1
    return 0  
print sorted([0,5,2,1,8,4], fn)
#==>  [0, 1, 2, 4, 5, 8]

闭包
内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）

#利用闭包计算1x1，2x2，3x3 的结果
def count():
    fs = []
    for i in range(1, 4):
        def fn(s):
            def f():
                return s*s
            fs.append(f)
        fn(i)  
    return fs
f1, f2, f3 = count()
print f1(), f2(), f3()
# ==> 1 4 9

匿名函数

关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。

匿名函数有个限制，只能有一个表达式，不写return，返回值就是该表达式的结果。

def f(x):
    return x * x

fn = lambda x:x*x

这两个函数是等价的

decorator装饰器

#coding=utf-8
import time, functools
def performance(unit):
    def wrapper(fn):
        @functools.wraps(fn)
        def inner(*argus,**kw):
            print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) 
            print unit
            return fn(*argus,**kw)
        return inner        
    return wrapper
# wrapper = performance('ms')
# factorial = wrapper(factorial)
# 等价于 factorial = performance('ms')(factorial) 
@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)
print factorial.__name__

#   结果
2019-06-11 15:43:00
ms
3628800
factorial

functools 把一个函数(fn)的属性复制到另一个函数(inner)。

面向对象编程

类：用于定义抽象类型
实例：根据类的定义被创建出来

类的属性（私有属性），方法

# encoding=utf-8
class Person(object): 
    money = "￥500"
    __count = 0
    @classmethod
    def how_many(cls):
        return cls.__count
    def __init__(self,name):
        self.name = name;
        Person.__count = Person.__count+1;
###属性
print "属性：money=" + Person.money
# print Person.__count; 
# 类的私有属性，只能在Person类内部访问 type object 'Person' has no attribute '__count
###方法 
how_manyp1 = Person('Bob')
print Person.how_many()

实例的属性(私有属性),方法

# encoding: utf-8
class Person(object):
    def __init__(self, name, score):
        self.name = name; 
        self.__score = score;
    def get_grade(self):
        score = self.__score;
        if score>=90:
            return "A-优秀"
        elif score>=60: 
            return "B-及格" 
        else:
            return "C-三挡"

p1 = Person('Bob', 90)
### 属性
print p1.name
# print p1.__score  #私有属性
### 方法
print p1.get_grade()

类属性只是引用地址，类属性和实例属性相同时的优先访问权

# encoding=utf-8
class Person(object):
    count = 0
    def __init__(self,name):
        Person.count = Person.count+1        
        pass

# 类的属性只是一个引用地址，实例可以访问类属性
p1 = Person('Bob')
p2 = Person('Alice')
p3 = Person('Tim')
print Person.count  # ==> 3
Person.count = 0
print p3.count   # ==> 0

# 实例属性和类属性命名相同时，优先读取实例属性
p1.count = 11
print p1.count  # ==> 11
del p1.count
print p1.count  # ==> 0

类的继承

实现一个单继承

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher,self).__init__(name, gender)
        self.course = course
        
passt = Teacher('Alice', 'Female', 'English')
print t.name  #'Alice'
print t.course  #'English'

super(Teacher,self).__init__(name, gender)
super(Teacher,self) 返回父类Person，并且调用__init__构造方法，初始化实例属性

isinstance判断类型

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course
t = Teacher('Alice', 'Female', 'English')
print isinstance(t,Person)   # ==>True
print isinstance(t,Student)  # ==>False 
print isinstance(t,Teacher)  # ==>True
print isinstance(t,object)   # ==>True

多态

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def whoAmI(self):
        return 'I am a Person, my name is %s' % self.name
class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
    
class Teacher(Person):
    def __init__(self, name, gender, course):
        super(Teacher, self).__init__(name, gender)
        self.course = course
    def whoAmI(self):
        return 'I am a Teacher, my name is %s' % self.name
p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')        
print p.whoAmI()  # ==> I am a Person, my name is Tim
print s.whoAmI()  # ==> I am a Person, my name is Bob 
print t.whoAmI()  # ==> I am a Teacher, my name is Alice

子类和父类的方法相同时，优先调用子类的方法。
如果子类没有定义，则顺着继承链向上查找，直到在某个父类中找到为止。如：s.whoAmI()

多重继承

class A(object):
    def __init__(self, a):
        print 'init A...'
        self.a = a

class B(A):
    def __init__(self, a):
        print 'init B...'
        super(B, self).__init__(a)

class C(A):
    def __init__(self, a):
        print 'init C...'
        super(C, self).__init__(a)
        
class D(B, C):
    def __init__(self, a):
        print 'init D...'
        super(D, self).__init__(a)

d = D('d')
#init D...
#init B...
#init C...
#init A...

D 同时继承自 B 和 C，也就是 D 拥有了 A、B、C 的全部功能。多重继承通过 super()调用__init__()方法时，A 虽然被继承了两次，但__init__()只调用一次。

super： super函数返回的代理对象是一个bultin class super，正如它的名字所指，类super代理了子类的父类。
在单继承关系中，super代理的类很容易找到吗，就是子类的唯一父类。在多继承关系中，super除了能代理子类的父类外，还有可能代理子类的兄弟类。

实例化流程

D类继承B和C类，D类中super().__init__()，调用的B类的构造方法
B类中的super().__init__()，其实调用的兄弟类C，而不是基类A
C类中的super().__init__()，其实调用的基类A

对象信息

type函数: 获取变量的类型

type(123)  #==> <type 'int'>

dir函数：获取对象的属性和方法

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
p = Person("li",25)
print dir(p)

# ['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', 
# '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', 
# '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'gender', 'name']

getattr()函数：获取对象属性
setattr( )函数：设置对象属性

 getattr(s, 'name')  # 获取s对象的name属性'Bob'
 setattr(s, 'name', 'Adam') #设置s对象的name属性'Adam'

python中的特殊方法
__str__

class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def __str__(self):
        return '(person: %s,%s)'%(self.name,self.gender)
    __repr__ = __str__
    
s = Person('Bob', 88)
print s     #==>  (person: Bob,88)
print s.__str__()  #==>  (person: Bob,88)

__len__

返回实例的参数的长度

class Students(object):
    def __init__(self, *args):
        self.names = args
    def __len__(self):
        return len(self.names)
f = Students("Bob","hellow","word")
print len(f)  # 3

__slots__ 限制属性

Student的实例只能添加'name', 'gender', 'score'三个属性

class Student(object):
    __slots__ = ('name', 'gender', 'score')
    def __init__(self, name, gender, score):
        self.name = name
        self.gender = gender
        self.score = score

__call__

函数都是可调用对象，一个实例也可以变成可调用对象

class Person(object):
    def __init__(self, name):
        self.name = name
    def __call__(self, friend):
        string = 'My name is %s,My friend is %s' %(self.name, friend)
        return string
p = Person("Bob")
print p("li ming")

@propertpy 属性装饰器
把__score私有属性装饰成对外访问的属性
用@property装饰的score(self)是get方法
用@score.setter装饰的score(self, score)是set方法@score.setter是前一个@property装饰后的副产品

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.__score = score
    @property
    def score(self):
        return self.__score
    @score.setter
    def score(self, score):
        self.__score = score
s = Student('Tom',10)
print s.score
s.score = 99
print s.score

查看全部

0 采集收起来源：python把函数作为参数

2019-06-25

年猪 01:40

高阶函数就是能把函数作为参数的函数

查看全部

0 采集收起来源：python中高阶函数

2019-04-10

宝慕林5301395

导入math模块：

import math

只导入math模块中的某几个函数：

from math import pow, sin, log

模块中函数同名：

from math import log
from logging import log as logger  
 # logging的log现在变成了logger

查看全部

0 采集收起来源：python之导入模块

2019-04-10

宝慕林5301395

将代码分拆放入多个py文件，可以使得同一名字的变量互不影响。

模块的名字就是py文件的文件名。在一个py文件中利用‘import’引用其他模块（py文件）。

为了解决模块名的冲突，将同名模块放入不同的包（文件夹）中。包可以有多级，而且每一层目录都必须有__init__.py 这一文件。

查看全部

0 采集收起来源：python中模块和包的概念

2019-04-10

python进阶

任务

decorator装饰器