python函数

Python基础——函数入门

不羁的心 — Sat, 02 Jan 2021 15:38:13 +0000

Python基础——函数入门不羁的心 2021-01-02 23:38:13

一、函数的定义

1、函数的格式 def 函数名（参数）: 例如： def a(x,y):

函数代码块以 def关键字开头，+函数名（参数）冒号。回车后，第一行内容应该缩进，然后写逻辑代码。

2、return关键字代表函数执行完返回的值

pass关键字代表什么都不做

exit（）强行退出

3、函数的参数

参数 *args 代表tuple类型（即：一个*代表是tuple类型）

参数 **kwargs 代表dict 字典类型（即：两个**代表是dic类型）

4、简单举例：（加法计算）

结果：

5、匿名函数lambda

匿名函数就是没有名字的函数，为什么设置匿名函数呢？

lambda 函数是一种快速定义单行的最小函数，可以用在任何需要函数的地方。

例如： def fun(x,y) 等同于 r = lambda x,y:x*y

return x*y

二、高阶函数

1、map(fun,list)

接收一个函数fun 和一个list，并通过函数 fun 依次作用在list的每个元素上，得到一个新的list并返回。

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

因为list可以包含任意类型的元素，因此map函数可以包含任意类型的list，只要fun函数可以处理即可。

Python2 例如：

Python2 结果：

Python3 例如：

Python3 结果：

注意：Python2 与 Python3 在运行map函数时有区别。

Python2 不需要 list() 转换。Python3 需要list() 转化。

Python3中不进行list转换运行结果为：

2、reduce(fun,list)

接收一个函数fun 和一个 list。但是函数 fun 必须是两个参数，reduce() 对list的每个元素反复调用函数fun，并返回最终结果。

注意：reduce 函数存在于Python2的全局变量中。在Python3中，它被放置于fucntools 模块中。

3、sorted 函数

来源：oschina

链接：https://my.oschina.net/u/3821557/blog/1794693

标签

python函数

高阶函数

python面向对象中类对象、实例对象、类变量、实例变量、类方法、实例方法、静态方法

好久不见. — Wed, 08 Apr 2020 04:26:48 +0000

python面向对象中类对象、实例对象、类变量、实例变量、类方法、实例方法、静态方法好久不见. 2020-04-08 12:26:48

1. 类对象和实例对象

　　Python中一切皆对象，Python类本身也是一种对象，类定义完成后，会在当前作用域中定义一个以类名为名字的命名空间。类对象具有以下两种操作：

可以通过“类名()”的方式实例化一个对象。
可以通过“类名.类属性”的方式来访问一个类属性。

　　如果说类时一种概念性的定义，是一种类别，那么实例对象就是对这一类别的具体化、实例化，即实例化对象是类对象实例化之后的产物。

class Person:# 声明一个类对象

    pass

p1 = Person()#声明一个实例对象

print(Person)#输出结果：<class '__main__.Person'>

print(p1)#<__main__.Person object at 0x0000015F7F94D0F0>

2 类变量与实例变量

2.1 概念上的区别

　　类变量是指是指该类的所有实例说共有的数据，实例变量是该类每一个实例所特有的数据。这么说的话可能还是很抽象，我们拿人类（Person类）来打比方，人类能移动（move=True），这是每一个人（张三、李四）都能做的，所以我们可以说人类能移动，张三能移动，李四也能移动，这里的移动（move）就是一个类变量。但每一个人都可能有不同的姓名（name）和年龄（age），张三可能20岁，李四可能30岁，但是我们不能说人类（Person）都是20岁或30岁，这里的姓名（name）和年龄（age）就是实例变量。

class Person:

    move = True    # 这是类变量

    def __init__(self , name , age):

        self.name = name  # 这是实例变量

        self.age = age  # 这是实例变量

2.2 声明上的区别

　　类变量声明通常在类内部，但函数体外，不需要用任何关键字修饰。实例变量一般声明在实例方法内部（其他方法内部也不行），且用self关键字修饰。

class Person:

    move = True    # 这是类变量，


    def __init__(self , name):

        self.name = name  # 这是实例变量，必须声明在实例函数内，用self关键字修饰

        # move = True  # 类变量不能再函数体内声明，在这个位置声明的又没有self关键字修饰，只能是一个局部变量


    # self.age = age  # 这是错误的，实例变量不能再这里声明

　　 eat = True  # 这是类变量，可以在函数体外，类内部任意位置

　　上面的变量绑定都是在对象声明过程中绑定的，但事实上类变量和实例变量都可以在类或者实例都可以在对象声明结束之后再绑定。“类名.变量名”绑定的是类变量，“实例名.变量名”绑定的是实例变量。

class Person:

    move = True   

    def __init__(self , name , age):

        self.name = name 

        self.age = age 

 

p1 = Person('张三' , 20)

p1.gender='男' # 声明实例对象结束之后再绑定一个实例变量

Person.eat = True  # 声明类对象结束之后再绑定一个类变量

print(p1.gender)  # 输出结果：男

print(p1.eat)  #输出结果：True

　　注：虽然可以在对象声明之后再绑定对象，但是这种方式最好不要使用。

2.3 访问上的区别

　　类变量可以通过“类名.变量名”和“实例名.变量名”的方式访问。实例变量只能通过“实例名.变量名”的方式来访问。

class Person:

    move = True    # 这是类变量

    def __init__(self , name , age):

        self.name = name  # 这是实例变量

        self.age = age  # 这是实例变量


p1 = Person('张三' , 20)

print(p1.name  , p1.age) # 通过“实例名.变量名”的方式访问实例变量

print(p1.move) # 通过“实例名.变量名”的方式访问实例变量

print(Person.move)  # 通过“类名.变量名”方式访问类变量

# print(Person.name) # 这是错误的

　　注：虽然可以通过“实例名.类变量名”的方式访问类变量，但是并不推荐，最好还是通过“类名.类变量名”来访问类变量。

2.4 存储上的区别

　　类变量只会在用class关键字声明一个类时创建，且也只会保存在类的命名空间中，这个类的实例的命名空间中是没有的。通过“实例名.类变量名”访问类变量时，实际访问的是类命名空间中数据，所以所有实例访问到的数据都是同一个变量。实例变量保存在实例各自的命名空间中。

class Person:

    move = True    # 这是类变量

    def __init__(self , name , age):

        self.name = name  # 这是实例变量

        self.age = age  # 这是实例变量

p1 = Person('张三' , 20)

p2 = Person('李四' , 30)

# 通过id()函数查询move内存地址

print(id(p1.move))   # 输出结果为：1622667424

print(id(p1.move))   # 输出结果为：1622667424

3 静态方法、类方法、实例方法

3.1 静态方法

　　静态方法是指在定义时，使用@staticmethod装饰器来修饰，无序传入self或cls关键字即可进行创建的方法。在调用过程时，无需将类实例化，直接通过“类名.方法名（）”方式调用方法。当然，也可以在实例化后通过“实例名.方法名（）”的方式调用。在静态方法内部，只能通过“类名.类变量名”的方式访问类变量。

class Person:

    move = True

    def __init__(self , name , age):

        self.name = name

        self.age = age

    @staticmethod

    def static_fun(): # 声明一个静态方法

        print(Person.move)

p1 = Person('张三' , 20)

p1.static_fun() #输出结果：这是静态方法

Person.static_fun() #输出结果：这是静态方法

3.2 类方法

　　类方法需要使用@classmethod装饰器来修饰，且传入的第一个参数为cls，指代的是类本身。类方法在调用方式上与静态方法相似，即可以通过“类名.方法名（）”和“实例名.方法名（）”两种方式调用。但类方法与静态方法不同的是，类方法可以在方法内部通过cls关键字访问类变量。在类方法内部，既能通过“类名.类变量名”的方式访问类变量，也能通过“cls.类变量名”的方式访问类变量。

class Person:

    move = True

    def __init__(self , name , age):

        self.name = name

        self.age = age

    @classmethod

    def class_fun(cls): # 声明一个类方法

        print(cls.move)

        print(Person.move)# cls 指的就是Person类，等效

p1 = Person('张三' , 20)

p1.class_fun() #输出结果：True True

Person.class_fun() #输出结果：True True

3.3 实例方法

　　在一个类中，除了静态方法和类方法之外，就是实例方法了，实例方法不需要装饰器修饰，不过在声明时传入的第一个参数必须为self，self指代的就是实例本身。实例方法能访问实例变量，静态方法和类方法则不能。在实例方法内部只能通过“类名.类变量名”的方式访问类变量。在调用时，实例方法可以通过“实例名.实例方法名”来调用，如果要通过类来调用，必须必须显式地将实例当做参数传入。

class Person:

    move = True

    def __init__(self , name , age):

        self.name = name

        self.age = age

    def instance_fun(self): # 声明一个实例方法

        print(Person.move) # 访问类变量

        print(self.name , self.age)

p1 = Person('张三' , 20)

p1.instance_fun()

Person.instance_fun(p1) #通过类访问实例方法时，必须显式地将实例当做参数传入

来源：https://www.cnblogs.com/chenhuabin/p/10055316.html

标签

python基础知识之函数与函数式编程

允我心安 — Wed, 08 Apr 2020 04:25:21 +0000

python基础知识之函数与函数式编程允我心安 2020-04-08 12:25:21

3种编程方式：

　　1.面向对象（最火的）。（过去大部分的编程方式）；》》主要是依靠：类》》class ，就是具有逻辑的过程，说话的方式描述

　　2.面向过程。主要是过程》》def 过程是没有返回值的函数，但是python也会返回none 基本与函数式编程没有区别了，最小的单元是一个一个的def定义的过程，一个一个逻辑是def定义的过程

　　3.函数式编程。编的函数更接近数学中的函数是一种编程规范也就是如何编程的方法论主要是函数》》def 例如lisp #hashshell erlang# 三种语言可以真正较纯粹的使用函数式编程来编写程序。

示例：（1+2）*3-4

传统编程方法：var a =1+2;

　　　　　　 var b =1*3;

　　　　　　　var c =b-4;

函数式编程则要求使用函数进行，把不同的运算定义成不同函数进行计算，写成下面的形式来进行：

var result = subtract（multiplely（add（1，2），3），4）；

python中的函数式编程是：逻辑结构化和过程化的一种编程方法

一，函数基础介绍（day3 22）【funt_test.PY】

def func1():#函数
    '''文档介绍'''
    print('in the func1')#过程
    return 0#返回值

def func2():#过程
'''文档介绍'''
print('in the func2')#函数体

x=func1()
y=func2()
print(x)
print(y)

重用函数的优点，可以让老代码，快速得到再次利用。

重要函数的优点，可以扩展方便，修改功能更方便，保持一致性。

return %s %s》》终止函数继续运行，并返回结果一定是一个值，但若写多个值则，多个值则是打包成一个元组返回（% %）

函数返回值的作用是：告诉使用者，这个函数调用后的结果是什么，让后来的人知道函数的运行结果，能够根据这个结果做出相应的反应。

def test(x,y,z):

　　pass

#中x和y为函数中的形参（也叫位置参数），这个x和y不是真实存在的，只是一个引导量中间量，不占用内存空间的，相当于一个内存空间的标识，即房子的门牌号。

而调用这个函数时text(1,2)中这个1和2则是实参要占相应的内存的，要占x和y所代表的两个内存。相当于向x和y这个门牌号写的房子里丢1和2这两个东西。

函数有关键字调用赋值，的位置参数调用赋值

即test(y=1,x=2,z=3)和test(x,y)#位置调用必须按照顺序写，关键字可以不按顺序写。

　　#注意#在调用时关键参数调用是不能写在位置参数前面的。例如可以写text(1,z=6,y=8)但是不能写成text(1,y=8,8)

def text(x,y=2):

　　pass

#这个y便是默认参数，在调用时有没有赋值y都是可以的默认参数可以不赋值#注意#但没有赋值默认参数时则按照默认的值运行，但是形参即位置参数必须有赋值。

##附加##但写pass时这个后面的过程可直接忽略，不报错#方便下次继续扩展。

def text(*args):

　　pass

#当这么定义函数的形参后，则赋值时可以传很多的值进去如text(5,1,4,6,5,46,6,5)也可text(*[1,5,156,648,3])，它会将其打包成一个元组再赋值给形参args。

##即将n个参数转换成元组的方式传进去##

def text(**kwargs):

　　print(kwargs)

##**kwargs的作用是，把n个关键字参数变成字典传进去## 如text(**{'N'=1,'M'='SOO'}) 或者text(name=‘i’,age=8)

*args和**args也可以混合使用

二，函数，局部/全局变量（day3 23）

小贴士：选中再CTRL+/ 则批量注释

局部变量只在函数里生效，例如：

在语法块（定义的函数里）里定义的就是局部变量

school=1#这个就是全局变量，在没有缩进的地方定义的是全局变量#而且全局变量是不能被语法块里定义的局部变量改变的，但是这样仅仅是指数字和字符串，其他数据类型是可以修改的。def change_name(name):
    global school#但是如果加上global则可以在函数里改全局变量，注意一般不要这样使用，因为这样改了之后不好调试。
    school = "Mage Linux"
    print("before change",name,school)
    name ="Alex li" #这个函数就是这个变量的作用域
    age =23
    print("after change",name)
print("school:",school)

name = "alex"
change_name(name)
print(name)

》》Traceback (most recent call last):
  File "C:/Users/home9/PycharmProjects/task1/day3/局部变量.py", line 27, in <module>
    print("school:",school)
NameError: name 'school' is not defined'''全局变量和局部变量，在子程序中定义的变量称为局部变量，在程序的一开始定义的称为全局变量。全局变量的作用域是整个程序，而局部变量的作用域是定义该变量的子程序特别注意：当全局变量与局部变量重名时，在定义局部变量的子程序内，局部变量起作用；在其他地方全局变量起作用。'''

三，函数，递归（day3，25）

递归特性：

1.必须有一个明确的结束条件。

2.每次进入更深一层递归时，问题的规模相对比上一次递归都有所减少，减的越多则算法的效率越高。

3.递归效率不高，递归层数过多会导致栈溢出（在计算机中函数的调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回栈就会减少一层栈帧。由于栈的大小不是无限的，所以递归调用的次数过多，会导致栈溢出）（python里最多是999次）

小贴士：程序调试，用pycharm的断点功能，一步一步的看执行过程。（—------》》14：15）

四，高阶函数（day3，26）

变了能指向函数，函数的参数能接受变量，那么一个函数就可以接受另一个函数作为参数，这种函数就称之为高阶函数。

def add(a,b):

　　return a+b

简单的函数》》》》高阶函数》》》》def (a,b,c):

def add(a,b,f):

　　return f(a)+f(b)#函数调用一个其他函数进去

res = abs(3,-6,abs)#也可用传函数名进去执行这个函数。

print(res)

来源：https://www.cnblogs.com/home979/p/7853854.html

标签

《Python从菜鸟到高手》已经出版，开始连载了，购买送视频课程

▼魔方西西 — Wed, 08 Apr 2020 04:12:39 +0000

《Python从菜鸟到高手》已经出版，开始连载了，购买送视频课程 ▼魔方西西 2020-04-08 12:12:39

好消息，《Python从菜鸟到高手》已经出版！！！

JetBrains官方推荐图书！JetBrains官大中华区市场部经理赵磊作序！送2400分钟同步视频课程！500个案例，400道Python练习题，电子书，10万行源代码，6个实战项目！

本书完整目录

购买地址：

当当

京东

随书赠送的视频课程1
随书赠送的视频课程2

李宁老师的视频课程

购买《Python从菜鸟到高手》一书，5分好评，评语不得低于20字，将截图发到2720687566@qq.com，赠送Python同步视频课程1年观看期限。

Python为何能上位碾压Java？

《Python从菜鸟到高手》转载文章

《Python从菜鸟到高手》知识结构图。

扫描二维码关注“极客起源”公众号，技术文章、视频课程应有尽有

欢迎关注“Python战地笔记”公众号

来源：51CTO

作者：androidguy

链接：https://blog.51cto.com/androidguy/2165688

标签

Python基础

荒凉一梦 — Wed, 08 Apr 2020 03:48:10 +0000

Python基础荒凉一梦 2020-04-08 11:48:10

1.输出

print('hello world')

2.定义变量

variable=5

variable2='hello'

3.用户输入

　　user_input=input('提示内容')

4.逻辑运算符

　　and　　#两个都为true则为true

　　or 　　#一个条件为true则为true

　　not　　#取反

5.赋值运算符　　

num=5
　　num+=1 #num=num+1
　　num-=1  #num=num-1
　　num*=1  #num=num*1
　　num/=1  #num=num/1
　　num//=1 #整除num=num//1
　　num**=1 #num=num**1
　　num%=1  #num=num%1

6.while循环  注意：在Python中while不是用{}表示代码的结束 是用间距来表示 一般是tab一下

语法：　　while 条件：　　　　......　　else：　　　　#在Python中for循环 while循环结尾可以加else，表示循环结束后执行

#例子：输出0-100之间所有偶数相加
　　num=1
　　size=0
　　while num<=100:　　#条件成立执行
　　　　if num%2==0:
　　　　　 size+=num
　　　       num+=1
　　　　    print(size)
    else:
　　　    print('循环结束')

7.for 循环

　 语法：

　　　　for i in 条件：

　　　　　　　　.....

#例子：　

for i in range(0,101,2):  # range函数 参数1：从什么开始；参数2：截止；参数3：步长 一次增长多少
    print(i)

8.if if elif 选择结构

age=int(input("输入年龄"))
#逻辑运算符 not and or

print(5>6 and 4>9) #两个都为true则为true
print(5>6 or 4>9) #一个条件为true则为true
print(not 5>6)  #取反

if age>=18 and age<60:
    print("你成年了")
    print("你成年了")
    print("你成年了")
elif age>=60:
    print("老咯")
else:
    print("未成年")

9.list集合

a = ['one', 'two', 'three']  # 初始化
print(a[0:])  # 截取

print(a[0:2])  # 取第一个元素和第二个元素，取值范围是 包头不包尾

a.append("four")  # 在最后添加一个元素
print(a)

a.insert(1, "five")  # 将元素插在小标1的前面
print(a)

a.remove("five")  # 1.删除指定元素
print(a)
dele = a.pop(1)  # 2.指定下表删除  可以返回删掉的元素
print(dele)
# del a #直接删除下表元素 或者直接删除集合
# a.clear  #清空元素

print(a.index("one"))  # 指定元素下表

print(a.count("one"))  # 指定元素个数
print(len(a))  # 集合长度

print("one"in a)  # 判断one在不在a中

a.reverse()  # 倒序排列
print(a)

x = [4, 8, 2, 6, 7, 1, 3, 9, 44]
x.sort(reverse=True)  # 冒泡排序默认小到大reverse=False  reverse=True大到小排序
print(x)

print(type(a) is list)  # 判断类型a是不是list类型

10.元组

　　和集合差不多，但是里面的元素不能修改。一般存放不想让用户修改的数据

# tupel 不能修改 只读

tup1 = (5,)  # 只有一个元素建议加逗号
tup2 = (5, 1, 2, 3)

11.字典

　　Python中唯一一个键值对的存储环境类似于java的json

# 键值对
dic={'name':'yangzhuxian','age':18,'sex':'男'}
dic['name']='zzh'
print(dic['name'])

dic['xxx']=0
print(dic)

dic.setdefault('oo',99)  # 去找oo这个元素 没有就创建 有就把以及存在的值返回出来（不插入新值）
print(dic)

print(dic.keys())  # dic.keys() 查看所有的键
print(dic.values())  # dic.keys() 查看所有的值
print(dic.items())  # 把所有key-value元素以元组形式显示出来

del dic['oo']  # 删除字典指定元素
print(dic)

12.格式化输出字符串

#  %s占位符
#  %d整数占位符，不符合报错
#  %f浮点数占位符，自动补充精度（30.000000）
msg='''
    ---------------
    Name:%s
    Age:%s
    ------------
    '''%(name,age)
print(msg)

13.字符串内置方法

st = 'helle pythen {name}'

print(st.count('l'))   # 'l'在字符串的个数

print(st.capitalize())  # 首字母大写

print(st.center(50, '-'))  # 将字符串设置指定长度，本身长度不够就用‘-’在字符串左右填充

print(st.startswith('he'))  # 判断以什么元素开头 返回布尔类型

print(st.endswith('en'))  # 以什么元素结尾 返回布尔类型

print(st.find('p'))  # 查找到第一个元素，返回索引值。没找到返回-1

print(st.format(name='yangzhuxian'))  # 给字符串中的占位符赋值
print(st.format_map({'name':'jjc'}))  # 给字符串中的占位符赋值

print(st.index('l'))  # 作用和find一样，但是找不到会报错。find不会报错

print(st.isalnum())  #

print(st.replace("{name}",""))  # 替换

print('*'.join(['ty','yy']))  # 将数组以什么东西组合成字符串

print(st.rfind('l'))  # 从右边往左边找 返回索引位置

print('My Name is YZX'.split(" "))  # 将字符串以什么为分割对象分开 变成集合['My', 'Name', 'is', 'YZX']

print('my name is YZX'.title())  # My Name Is Yzx 转化成title规则

print('\tMy Name is\n yzx    '.strip())  # 去空格

print('My Name is yzx'.lower())  # 转化小写

print('My Name is yzx'.upper())  # 转化大写

来源：https://www.cnblogs.com/yangzhuxian/p/12658609.html

标签

Python3 撸代码窍门,怎样用 Map, Filter, Reduce 代替 For 循环.

拈花ヽ惹草 — Wed, 08 Apr 2020 02:52:24 +0000

Python3 撸代码窍门,怎样用 Map, Filter, Reduce 代替 For 循环. 拈花ヽ惹草 2020-04-08 10:52:24

感谢作者分享-http://bjbsair.com/2020-04-07/tech-info/30736.html

你是否有过这样的经历，你查看自己写的代码并看到满眼的 for 循环？你发现你必须斜着你的眼睛，并将脑袋前倾到你的显示器，以看得更清楚。

反正我有过这样的经历。

for 循环就像是一把瑞士军刀，它可以解决很多问题，但是，当你需要扫视代码，快速搞清楚代码所做的事情时，它们可能会让人不知所措。

map、filter 和 reduce 这三种技术可以提供描述迭代原因的函数替代方案，以便避免过多的 for 循环。我之前在 JavaScript 中写过这些技术的入门文章，但是它们在 Python 中的实现略有不同。

我们将简要介绍这三种技术，主要介绍它们在 JavaScript 和 Python 中的语法差异，然后给出如何转换 for 循环的示例。

什么是 Map、Filter 和 Reduce？

回顾我以前编写的代码，我意识到 95% 的时间都花在遍历字符串或数组上。在这种情况下，我会执行以下操作之一：将一系列语句映射到每个值，筛选满足特定条件的值，或将数据集减少为单个聚合值。

有了这种洞察力，你就可以识别和实现这三种方法，即循环遍历通常属于这三种功能类别之一：

Map：对每个项应用相同的步骤集，存储结果
Filter：应用验证条件，存储计算结果为 True 的项
Reduce：返回一个从元素传递到元素的值

为什么 Python Map/Filter/Reduce 会不一样？

在 Python 中，这三种技术作为函数存在，而不是数组或字符串类的方法。这意味着，你将编写 map (function, my_list)，而不是编写 my_array.map（function）。

此外，每个技术都需要传递一个函数，该函数将执行每个项目。通常，该函数是作为匿名函数（在 JavaScript 中称为 arrow 头函数）编写的。但是，在 Python 中，你经常看到被使用的是 lambda 表达式。

lambda 表达式和 arrow 函数之间的语法实际上非常相似。将 => 替换为：并确保使用关键字 lambda，其余的几乎相同。

// JavaScript Arrow Functionconst square = number => number * number;

// Python Lambda Expressionsquare = lambda number: number * number

arrow 函数和 lambda 表达式之间的一个关键区别是，arrow 函数能够通过多个语句扩展成完整的函数，而 lambda 表达式仅限于返回的单个表达式。因此，在使用 map（）、filter（）或 reduce（）时，如果需要对每个项执行多个操作，请先定义函数，然后再包含它。

def inefficientSquare(number): result = number * number return result

map(inefficientSquare, my_list)

替换 for 循环

好了，下面来点好东西。下面是三个常见的 for 循环示例，它们将被 map、filter 和 reduce 替换。我们的编程目标：计算列表中奇数平方和。

首先，使用基本的 for 循环示例。注意：下面的代码纯粹是为了演示，即使没有 map/filter/reduce 也有改进空间。

numbers = [1,2,3,4,5,6]odd_numbers = []squared_odd_numbers = []total = 0

filter for odd numbersfor number in numbers: if number % 2 == 1: odd_numbers.append(number)

square all odd numbersfor number in odd_numbers: squared_odd_numbers.append(number * number)

calculate totalfor number in squared_odd_numbers: total += number

calculate average

让我们将每个步骤转换为这三个函数的其中之一：

from functools import reduce

numbers = [1,2,3,4,5,6]

odd_numbers = filter(lambda n: n % 2 == 1, numbers)

squared_odd_numbers = map(lambda n: n * n, odd_numbers)

total = reduce(lambda acc, n: acc + n, squared_odd_numbers)

有几个重要的语法要点要强调。

map（）和 filter（）本机可用。但是，reduce（）必须从 Python 3 以上版本中的函数库导入
lambda 表达式是所有三个函数中的第一个参数，iterable 是第二个参数
reduce（）的 lambda 表达式需要两个参数：累加器（传递给每个元素的值）和单个元素本身

记住，for 循环在代码中确实是很重要的，但是扩展工具包从来都不是坏事。

如果你处于想学Python或者正在学习Python，下面是2020年最新Python教程学习一部分大纲：共分为4季，里面详细的讲解了Python的方方面面、学完可直接到达手写神经网络的地步**！**

----------------------------------感谢作者分享-http://bjbsair.com/2020-04-07/tech-info/30736.html

你是否有过这样的经历，你查看自己写的代码并看到满眼的 for 循环？你发现你必须斜着你的眼睛，并将脑袋前倾到你的显示器，以看得更清楚。

反正我有过这样的经历。

for 循环就像是一把瑞士军刀，它可以解决很多问题，但是，当你需要扫视代码，快速搞清楚代码所做的事情时，它们可能会让人不知所措。

我们将简要介绍这三种技术，主要介绍它们在 JavaScript 和 Python 中的语法差异，然后给出如何转换 for 循环的示例。

什么是 Map、Filter 和 Reduce？

有了这种洞察力，你就可以识别和实现这三种方法，即循环遍历通常属于这三种功能类别之一：

Map：对每个项应用相同的步骤集，存储结果
Filter：应用验证条件，存储计算结果为 True 的项
Reduce：返回一个从元素传递到元素的值

为什么 Python Map/Filter/Reduce 会不一样？

在 Python 中，这三种技术作为函数存在，而不是数组或字符串类的方法。这意味着，你将编写 map (function, my_list)，而不是编写 my_array.map（function）。

lambda 表达式和 arrow 函数之间的语法实际上非常相似。将 => 替换为：并确保使用关键字 lambda，其余的几乎相同。

// JavaScript Arrow Functionconst square = number => number * number;

// Python Lambda Expressionsquare = lambda number: number * number

def inefficientSquare(number): result = number * number return result

map(inefficientSquare, my_list)

替换 for 循环

好了，下面来点好东西。下面是三个常见的 for 循环示例，它们将被 map、filter 和 reduce 替换。我们的编程目标：计算列表中奇数平方和。

首先，使用基本的 for 循环示例。注意：下面的代码纯粹是为了演示，即使没有 map/filter/reduce 也有改进空间。

numbers = [1,2,3,4,5,6]odd_numbers = []squared_odd_numbers = []total = 0

filter for odd numbersfor number in numbers: if number % 2 == 1: odd_numbers.append(number)

square all odd numbersfor number in odd_numbers: squared_odd_numbers.append(number * number)

calculate totalfor number in squared_odd_numbers: total += number

calculate average

让我们将每个步骤转换为这三个函数的其中之一：

from functools import reduce

numbers = [1,2,3,4,5,6]

odd_numbers = filter(lambda n: n % 2 == 1, numbers)

squared_odd_numbers = map(lambda n: n * n, odd_numbers)

total = reduce(lambda acc, n: acc + n, squared_odd_numbers)

有几个重要的语法要点要强调。

map（）和 filter（）本机可用。但是，reduce（）必须从 Python 3 以上版本中的函数库导入
lambda 表达式是所有三个函数中的第一个参数，iterable 是第二个参数
reduce（）的 lambda 表达式需要两个参数：累加器（传递给每个元素的值）和单个元素本身

记住，for 循环在代码中确实是很重要的，但是扩展工具包从来都不是坏事。

----------------------------------感谢作者分享-http://bjbsair.com/2020-04-07/tech-info/30736.html

你是否有过这样的经历，你查看自己写的代码并看到满眼的 for 循环？你发现你必须斜着你的眼睛，并将脑袋前倾到你的显示器，以看得更清楚。

反正我有过这样的经历。

for 循环就像是一把瑞士军刀，它可以解决很多问题，但是，当你需要扫视代码，快速搞清楚代码所做的事情时，它们可能会让人不知所措。

我们将简要介绍这三种技术，主要介绍它们在 JavaScript 和 Python 中的语法差异，然后给出如何转换 for 循环的示例。

什么是 Map、Filter 和 Reduce？

有了这种洞察力，你就可以识别和实现这三种方法，即循环遍历通常属于这三种功能类别之一：

Map：对每个项应用相同的步骤集，存储结果
Filter：应用验证条件，存储计算结果为 True 的项
Reduce：返回一个从元素传递到元素的值

为什么 Python Map/Filter/Reduce 会不一样？

在 Python 中，这三种技术作为函数存在，而不是数组或字符串类的方法。这意味着，你将编写 map (function, my_list)，而不是编写 my_array.map（function）。

lambda 表达式和 arrow 函数之间的语法实际上非常相似。将 => 替换为：并确保使用关键字 lambda，其余的几乎相同。

// JavaScript Arrow Functionconst square = number => number * number;

// Python Lambda Expressionsquare = lambda number: number * number

def inefficientSquare(number): result = number * number return result

map(inefficientSquare, my_list)

替换 for 循环

好了，下面来点好东西。下面是三个常见的 for 循环示例，它们将被 map、filter 和 reduce 替换。我们的编程目标：计算列表中奇数平方和。

首先，使用基本的 for 循环示例。注意：下面的代码纯粹是为了演示，即使没有 map/filter/reduce 也有改进空间。

numbers = [1,2,3,4,5,6]odd_numbers = []squared_odd_numbers = []total = 0

filter for odd numbersfor number in numbers: if number % 2 == 1: odd_numbers.append(number)

square all odd numbersfor number in odd_numbers: squared_odd_numbers.append(number * number)

calculate totalfor number in squared_odd_numbers: total += number

calculate average

让我们将每个步骤转换为这三个函数的其中之一：

from functools import reduce

numbers = [1,2,3,4,5,6]

odd_numbers = filter(lambda n: n % 2 == 1, numbers)

squared_odd_numbers = map(lambda n: n * n, odd_numbers)

total = reduce(lambda acc, n: acc + n, squared_odd_numbers)

有几个重要的语法要点要强调。

map（）和 filter（）本机可用。但是，reduce（）必须从 Python 3 以上版本中的函数库导入
lambda 表达式是所有三个函数中的第一个参数，iterable 是第二个参数
reduce（）的 lambda 表达式需要两个参数：累加器（传递给每个元素的值）和单个元素本身

记住，for 循环在代码中确实是很重要的，但是扩展工具包从来都不是坏事。

来源：oschina

链接：https://my.oschina.net/u/4478364/blog/3224465

标签

Keras学习手册(一),开篇-使用 Python3 的Deep Learning 库

跟風遠走 — Wed, 08 Apr 2020 00:31:19 +0000

Keras学习手册(一),开篇-使用 Python3 的Deep Learning 库跟風遠走 2020-04-08 08:31:19

感谢作者分享-http://bjbsair.com/2020-04-07/tech-info/30656.html

===

你恰好发现了 Keras。

Keras 是一个用 Python 编写的高级神经网络 API，它能够以 TensorFlow, CNTK, 或者 Theano 作为后端运行。Keras 的开发重点是支持快速的实验。能够以最小的时延把你的想法转换为实验结果，是做好研究的关键。

如果你在以下情况下需要深度学习库，请使用 Keras：

允许简单而快速的原型设计（由于用户友好，高度模块化，可扩展性）。
同时支持卷积神经网络和循环神经网络，以及两者的组合。
在 CPU 和 GPU 上无缝运行。

查看文档，请访问 Keras.io。

Keras 兼容的 Python 版本: Python 2.7-3.6。

指导原则

用户友好。 Keras 是为人类而不是为机器设计的 API。它把用户体验放在首要和中心位置。Keras 遵循减少认知困难的最佳实践：它提供一致且简单的 API，将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
模块化。 模型被理解为由独立的、完全可配置的模块构成的序列或图。这些模块可以以尽可能少的限制组装在一起。特别是神经网络层、损失函数、优化器、初始化方法、激活函数、正则化方法，它们都是可以结合起来构建新模型的模块。
易扩展性。 新的模块是很容易添加的（作为新的类和函数），现有的模块已经提供了充足的示例。由于能够轻松地创建可以提高表现力的新模块，Keras 更加适合高级研究。
基于 Python 实现。 Keras 没有特定格式的单独配置文件。模型定义在 Python 代码中，这些代码紧凑，易于调试，并且易于扩展。

快速开始：30 秒上手 Keras

Keras 的核心数据结构是 model，一种组织网络层的方式。最简单的模型是 Sequential 顺序模型，它由多个网络层线性堆叠。对于更复杂的结构，你应该使用 Keras 函数式 API，它允许构建任意的神经网络图。

Sequential 模型如下所示：

from keras.models import Sequential  
  
model = Sequential()

可以简单地使用 .add() 来堆叠模型：

from keras.layers import Dense  
  
model.add(Dense(units=64, activation='relu', input_dim=100))  
model.add(Dense(units=10, activation='softmax'))

在完成了模型的构建后, 可以使用 .compile() 来配置学习过程：

model.compile(loss='categorical_crossentropy',  
              optimizer='sgd',  
              metrics=['accuracy'])

如果需要，你还可以进一步地配置你的优化器。Keras 的核心原则是使事情变得相当简单，同时又允许用户在需要的时候能够进行完全的控制（终极的控制是源代码的易扩展性）。

model.compile(loss=keras.losses.categorical_crossentropy,  
              optimizer=keras.optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True))

现在，你可以批量地在训练数据上进行迭代了：

# x_train 和 y_train 是 Numpy 数组 -- 就像在 Scikit-Learn API 中一样。  
model.fit(x_train, y_train, epochs=5, batch_size=32)

或者，你可以手动地将批次的数据提供给模型：

model.train_on_batch(x_batch, y_batch)

只需一行代码就能评估模型性能：

loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

或者对新的数据生成预测：

classes = model.predict(x_test, batch_size=128)

构建一个问答系统，一个图像分类模型，一个神经图灵机，或者其他的任何模型，就是这么的快。深度学习背后的思想很简单，那么它们的实现又何必要那么痛苦呢？

有关 Keras 更深入的教程，请查看：

开始使用 Sequential 模型
开始使用函数式 API

在代码仓库的 examples 目录中，你会找到更多高级模型：基于记忆网络的问答系统、基于栈式 LSTM 的文本生成等等。

安装指引

在安装 Keras 之前，请安装以下后端引擎之一：TensorFlow，Theano，或者 CNTK。我们推荐 TensorFlow 后端。

TensorFlow 安装指引。
Theano 安装指引。
CNTK 安装指引。

你也可以考虑安装以下可选依赖：

cuDNN (如果你计划在 GPU 上运行 Keras，建议安装)。
HDF5 和 h5py (如果你需要将 Keras 模型保存到磁盘，则需要这些)。
graphviz 和 pydot (用于可视化工具绘制模型图)。

然后你就可以安装 Keras 本身了。有两种方法安装 Keras：

使用 PyPI 安装 Keras (推荐)：

sudo pip install keras

如果你使用 virtualenv 虚拟环境, 你可以避免使用 sudo：

pip install keras

或者：使用 GitHub 源码安装 Keras：

首先，使用 git 来克隆 Keras：

git clone https://github.com/keras-team/keras.git

然后，cd 到 Keras 目录并且运行安装命令：

cd keras  
sudo python setup.py install

配置你的 Keras 后端

默认情况下，Keras 将使用 TensorFlow 作为其张量操作库。请跟随这些指引来配置其他 Keras 后端。

技术支持

你可以提出问题并参与开发讨论：

Keras Google group。
Keras Slack channel。使用这个链接向该频道请求邀请函。

你也可以在 GitHub issues 中发布漏洞报告和新功能请求（仅限于此）。注意请先阅读规范文档。

为什么取名为 Keras?

Keras (κέρας) 在希腊语中意为号角。它来自古希腊和拉丁文学中的一个文学形象，首先出现于《奥德赛》中，梦神 (Oneiroi, singular Oneiros) 从这两类人中分离出来：那些用虚幻的景象欺骗人类，通过象牙之门抵达地球之人，以及那些宣告未来即将到来，通过号角之门抵达之人。它类似于文字寓意，κέρας (号角) / κραίνω (履行)，以及 ἐλέφας (象牙) / ἐλεφαίρομαι (欺骗)。

Keras 最初是作为 ONEIROS 项目（开放式神经电子智能机器人操作系统）研究工作的一部分而开发的。

"Oneiroi 超出了我们的理解 - 谁能确定它们讲述了什么故事？并不是所有人都能找到。那里有两扇门，就是通往短暂的 Oneiroi 的通道；一个是用号角制造的，一个是用象牙制造的。穿过尖锐的象牙的 Oneiroi 是诡计多端的，他们带有一些不会实现的信息；那些穿过抛光的喇叭出来的人背后具有真理，对于看到他们的人来说是完成的。" Homer, Odyssey 19. 562 ff (Shewring translation).

为什么选择 Keras？

在如今无数深度学习框架中，为什么要使用 Keras 而非其他？以下是 Keras 与现有替代品的一些比较。

Keras 优先考虑开发人员的经验

Keras 是为人类而非机器设计的 API。Keras 遵循减少认知困难的最佳实践: 它提供一致且简单的 API，它将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
这使 Keras 易于学习和使用。作为 Keras 用户，你的工作效率更高，能够比竞争对手更快地尝试更多创意，从而帮助你赢得机器学习竞赛。
这种易用性并不以降低灵活性为代价：因为 Keras 与底层深度学习语言（特别是 TensorFlow）集成在一起，所以它可以让你实现任何你可以用基础语言编写的东西。特别是，tf.keras 作为 Keras API 可以与 TensorFlow 工作流无缝集成。

Keras 被工业界和学术界广泛采用

Deep learning 框架排名，由 Jeff Hale 基于 7 个分类的 11 个数据源计算得出

截至 2018 年中期，Keras 拥有超过 250,000 名个人用户。与其他任何深度学习框架相比，Keras 在行业和研究领域的应用率更高（除 TensorFlow 之外，且 Keras API 是 TensorFlow 的官方前端，通过 tf.keras 模块使用）。

您已经不断与使用 Keras 构建的功能进行交互 - 它在 Netflix, Uber, Yelp, Instacart, Zocdoc, Square 等众多网站上使用。它尤其受以深度学习作为产品核心的创业公司的欢迎。

Keras也是深度学习研究人员的最爱，在上载到预印本服务器 arXiv.org 的科学论文中被提及的次数位居第二。Keras 还被大型科学组织的研究人员采用，特别是 CERN 和 NASA。

Keras 可以轻松将模型转化为产品

与任何其他深度学习框架相比，你的 Keras 模型可以在更广泛的平台上轻松部署：

在 iOS 上，通过 Apple’s CoreML（苹果为 Keras 提供官方支持）。这里有一个教程。
在 Android 上，通过 TensorFlow Android runtime，例如：Not Hotdog app。
在浏览器中，通过 GPU 加速的 JavaScript 运行时，例如：Keras.js 和 WebDNN。
在 Google Cloud 上，通过 TensorFlow-Serving。
在 Python webapp 后端（比如 Flask app）中。
在 JVM 上，通过 SkyMind 提供的 DL4J 模型导入。
在 Raspberry Pi 树莓派上。

Keras 支持多个后端引擎，不会将你锁定到一个生态系统中

你的 Keras 模型可以基于不同的深度学习后端开发。重要的是，任何仅利用内置层构建的 Keras 模型，都可以在所有这些后端中移植：你可以用一种后端训练模型，再将它载入另一种后端中（例如为了发布的需要）。支持的后端有：

谷歌的 TensorFlow 后端
微软的 CNTK 后端
Theano 后端

亚马逊也正在为 Keras 开发 MXNet 后端。

如此一来，你的 Keras 模型可以在 CPU 之外的不同硬件平台上训练：

NVIDIA GPU
Google TPU，通过 TensorFlow 后端和 Google Cloud
OpenCL 支持的 GPU, 比如 AMD, 通过 PlaidML Keras 后端

Keras 拥有强大的多 GPU 和分布式训练支持

Keras 内置对多 GPU 数据并行的支持。
优步的 Horovod 对 Keras 模型拥有一流的支持。
Keras 模型可以被转换为 TensorFlow Estimators 并在 Google Cloud 的 GPU 集群上训练。
Keras 可以在 Spark（通过 CERN 的 Dist-Keras）和 Elephas 上运行。

Keras 的发展得到深度学习生态系统中的关键公司的支持

Keras 的开发主要由谷歌支持，Keras API 以 tf.keras 的形式包装在 TensorFlow 中。此外，微软维护着 Keras 的 CNTK 后端。亚马逊 AWS 正在开发 MXNet 支持。其他提供支持的公司包括 NVIDIA、优步、苹果（通过 CoreML）等。

感谢作者分享-http://bjbsair.com/2020-04-07/tech-info/30656.html

===

你恰好发现了 Keras。

如果你在以下情况下需要深度学习库，请使用 Keras：

允许简单而快速的原型设计（由于用户友好，高度模块化，可扩展性）。
同时支持卷积神经网络和循环神经网络，以及两者的组合。
在 CPU 和 GPU 上无缝运行。

查看文档，请访问 Keras.io。

Keras 兼容的 Python 版本: Python 2.7-3.6。

指导原则

用户友好。 Keras 是为人类而不是为机器设计的 API。它把用户体验放在首要和中心位置。Keras 遵循减少认知困难的最佳实践：它提供一致且简单的 API，将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
模块化。 模型被理解为由独立的、完全可配置的模块构成的序列或图。这些模块可以以尽可能少的限制组装在一起。特别是神经网络层、损失函数、优化器、初始化方法、激活函数、正则化方法，它们都是可以结合起来构建新模型的模块。
易扩展性。 新的模块是很容易添加的（作为新的类和函数），现有的模块已经提供了充足的示例。由于能够轻松地创建可以提高表现力的新模块，Keras 更加适合高级研究。
基于 Python 实现。 Keras 没有特定格式的单独配置文件。模型定义在 Python 代码中，这些代码紧凑，易于调试，并且易于扩展。

快速开始：30 秒上手 Keras

Sequential 模型如下所示：

from keras.models import Sequential  
  
model = Sequential()

可以简单地使用 .add() 来堆叠模型：

from keras.layers import Dense  
  
model.add(Dense(units=64, activation='relu', input_dim=100))  
model.add(Dense(units=10, activation='softmax'))

在完成了模型的构建后, 可以使用 .compile() 来配置学习过程：

model.compile(loss='categorical_crossentropy',  
              optimizer='sgd',  
              metrics=['accuracy'])

model.compile(loss=keras.losses.categorical_crossentropy,  
              optimizer=keras.optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True))

现在，你可以批量地在训练数据上进行迭代了：

# x_train 和 y_train 是 Numpy 数组 -- 就像在 Scikit-Learn API 中一样。  
model.fit(x_train, y_train, epochs=5, batch_size=32)

或者，你可以手动地将批次的数据提供给模型：

model.train_on_batch(x_batch, y_batch)

只需一行代码就能评估模型性能：

loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

或者对新的数据生成预测：

classes = model.predict(x_test, batch_size=128)

有关 Keras 更深入的教程，请查看：

开始使用 Sequential 模型
开始使用函数式 API

在代码仓库的 examples 目录中，你会找到更多高级模型：基于记忆网络的问答系统、基于栈式 LSTM 的文本生成等等。

安装指引

在安装 Keras 之前，请安装以下后端引擎之一：TensorFlow，Theano，或者 CNTK。我们推荐 TensorFlow 后端。

TensorFlow 安装指引。
Theano 安装指引。
CNTK 安装指引。

你也可以考虑安装以下可选依赖：

cuDNN (如果你计划在 GPU 上运行 Keras，建议安装)。
HDF5 和 h5py (如果你需要将 Keras 模型保存到磁盘，则需要这些)。
graphviz 和 pydot (用于可视化工具绘制模型图)。

然后你就可以安装 Keras 本身了。有两种方法安装 Keras：

使用 PyPI 安装 Keras (推荐)：

sudo pip install keras

如果你使用 virtualenv 虚拟环境, 你可以避免使用 sudo：

pip install keras

或者：使用 GitHub 源码安装 Keras：

首先，使用 git 来克隆 Keras：

git clone https://github.com/keras-team/keras.git

然后，cd 到 Keras 目录并且运行安装命令：

cd keras  
sudo python setup.py install

配置你的 Keras 后端

默认情况下，Keras 将使用 TensorFlow 作为其张量操作库。请跟随这些指引来配置其他 Keras 后端。

技术支持

你可以提出问题并参与开发讨论：

Keras Google group。
Keras Slack channel。使用这个链接向该频道请求邀请函。

你也可以在 GitHub issues 中发布漏洞报告和新功能请求（仅限于此）。注意请先阅读规范文档。

为什么取名为 Keras?

Keras 最初是作为 ONEIROS 项目（开放式神经电子智能机器人操作系统）研究工作的一部分而开发的。

"Oneiroi 超出了我们的理解 - 谁能确定它们讲述了什么故事？并不是所有人都能找到。那里有两扇门，就是通往短暂的 Oneiroi 的通道；一个是用号角制造的，一个是用象牙制造的。穿过尖锐的象牙的 Oneiroi 是诡计多端的，他们带有一些不会实现的信息；那些穿过抛光的喇叭出来的人背后具有真理，对于看到他们的人来说是完成的。" Homer, Odyssey 19. 562 ff (Shewring translation).

为什么选择 Keras？

在如今无数深度学习框架中，为什么要使用 Keras 而非其他？以下是 Keras 与现有替代品的一些比较。

Keras 优先考虑开发人员的经验

Keras 是为人类而非机器设计的 API。Keras 遵循减少认知困难的最佳实践: 它提供一致且简单的 API，它将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
这使 Keras 易于学习和使用。作为 Keras 用户，你的工作效率更高，能够比竞争对手更快地尝试更多创意，从而帮助你赢得机器学习竞赛。
这种易用性并不以降低灵活性为代价：因为 Keras 与底层深度学习语言（特别是 TensorFlow）集成在一起，所以它可以让你实现任何你可以用基础语言编写的东西。特别是，tf.keras 作为 Keras API 可以与 TensorFlow 工作流无缝集成。

Keras 被工业界和学术界广泛采用

Deep learning 框架排名，由 Jeff Hale 基于 7 个分类的 11 个数据源计算得出

Keras 可以轻松将模型转化为产品

与任何其他深度学习框架相比，你的 Keras 模型可以在更广泛的平台上轻松部署：

在 iOS 上，通过 Apple’s CoreML（苹果为 Keras 提供官方支持）。这里有一个教程。
在 Android 上，通过 TensorFlow Android runtime，例如：Not Hotdog app。
在浏览器中，通过 GPU 加速的 JavaScript 运行时，例如：Keras.js 和 WebDNN。
在 Google Cloud 上，通过 TensorFlow-Serving。
在 Python webapp 后端（比如 Flask app）中。
在 JVM 上，通过 SkyMind 提供的 DL4J 模型导入。
在 Raspberry Pi 树莓派上。

Keras 支持多个后端引擎，不会将你锁定到一个生态系统中

谷歌的 TensorFlow 后端
微软的 CNTK 后端
Theano 后端

亚马逊也正在为 Keras 开发 MXNet 后端。

如此一来，你的 Keras 模型可以在 CPU 之外的不同硬件平台上训练：

NVIDIA GPU
Google TPU，通过 TensorFlow 后端和 Google Cloud
OpenCL 支持的 GPU, 比如 AMD, 通过 PlaidML Keras 后端

Keras 拥有强大的多 GPU 和分布式训练支持

Keras 内置对多 GPU 数据并行的支持。
优步的 Horovod 对 Keras 模型拥有一流的支持。
Keras 模型可以被转换为 TensorFlow Estimators 并在 Google Cloud 的 GPU 集群上训练。
Keras 可以在 Spark（通过 CERN 的 Dist-Keras）和 Elephas 上运行。

Keras 的发展得到深度学习生态系统中的关键公司的支持

感谢作者分享-http://bjbsair.com/2020-04-07/tech-info/30656.html

===

你恰好发现了 Keras。

如果你在以下情况下需要深度学习库，请使用 Keras：

允许简单而快速的原型设计（由于用户友好，高度模块化，可扩展性）。
同时支持卷积神经网络和循环神经网络，以及两者的组合。
在 CPU 和 GPU 上无缝运行。

查看文档，请访问 Keras.io。

Keras 兼容的 Python 版本: Python 2.7-3.6。

指导原则

用户友好。 Keras 是为人类而不是为机器设计的 API。它把用户体验放在首要和中心位置。Keras 遵循减少认知困难的最佳实践：它提供一致且简单的 API，将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
模块化。 模型被理解为由独立的、完全可配置的模块构成的序列或图。这些模块可以以尽可能少的限制组装在一起。特别是神经网络层、损失函数、优化器、初始化方法、激活函数、正则化方法，它们都是可以结合起来构建新模型的模块。
易扩展性。 新的模块是很容易添加的（作为新的类和函数），现有的模块已经提供了充足的示例。由于能够轻松地创建可以提高表现力的新模块，Keras 更加适合高级研究。
基于 Python 实现。 Keras 没有特定格式的单独配置文件。模型定义在 Python 代码中，这些代码紧凑，易于调试，并且易于扩展。

快速开始：30 秒上手 Keras

Sequential 模型如下所示：

from keras.models import Sequential  
  
model = Sequential()

可以简单地使用 .add() 来堆叠模型：

from keras.layers import Dense  
  
model.add(Dense(units=64, activation='relu', input_dim=100))  
model.add(Dense(units=10, activation='softmax'))

在完成了模型的构建后, 可以使用 .compile() 来配置学习过程：

model.compile(loss='categorical_crossentropy',  
              optimizer='sgd',  
              metrics=['accuracy'])

model.compile(loss=keras.losses.categorical_crossentropy,  
              optimizer=keras.optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True))

现在，你可以批量地在训练数据上进行迭代了：

# x_train 和 y_train 是 Numpy 数组 -- 就像在 Scikit-Learn API 中一样。  
model.fit(x_train, y_train, epochs=5, batch_size=32)

或者，你可以手动地将批次的数据提供给模型：

model.train_on_batch(x_batch, y_batch)

只需一行代码就能评估模型性能：

loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

或者对新的数据生成预测：

classes = model.predict(x_test, batch_size=128)

有关 Keras 更深入的教程，请查看：

开始使用 Sequential 模型
开始使用函数式 API

在代码仓库的 examples 目录中，你会找到更多高级模型：基于记忆网络的问答系统、基于栈式 LSTM 的文本生成等等。

安装指引

在安装 Keras 之前，请安装以下后端引擎之一：TensorFlow，Theano，或者 CNTK。我们推荐 TensorFlow 后端。

TensorFlow 安装指引。
Theano 安装指引。
CNTK 安装指引。

你也可以考虑安装以下可选依赖：

cuDNN (如果你计划在 GPU 上运行 Keras，建议安装)。
HDF5 和 h5py (如果你需要将 Keras 模型保存到磁盘，则需要这些)。
graphviz 和 pydot (用于可视化工具绘制模型图)。

然后你就可以安装 Keras 本身了。有两种方法安装 Keras：

使用 PyPI 安装 Keras (推荐)：

sudo pip install keras

如果你使用 virtualenv 虚拟环境, 你可以避免使用 sudo：

pip install keras

或者：使用 GitHub 源码安装 Keras：

首先，使用 git 来克隆 Keras：

git clone https://github.com/keras-team/keras.git

然后，cd 到 Keras 目录并且运行安装命令：

cd keras  
sudo python setup.py install

配置你的 Keras 后端

默认情况下，Keras 将使用 TensorFlow 作为其张量操作库。请跟随这些指引来配置其他 Keras 后端。

技术支持

你可以提出问题并参与开发讨论：

Keras Google group。
Keras Slack channel。使用这个链接向该频道请求邀请函。

你也可以在 GitHub issues 中发布漏洞报告和新功能请求（仅限于此）。注意请先阅读规范文档。

为什么取名为 Keras?

Keras 最初是作为 ONEIROS 项目（开放式神经电子智能机器人操作系统）研究工作的一部分而开发的。

"Oneiroi 超出了我们的理解 - 谁能确定它们讲述了什么故事？并不是所有人都能找到。那里有两扇门，就是通往短暂的 Oneiroi 的通道；一个是用号角制造的，一个是用象牙制造的。穿过尖锐的象牙的 Oneiroi 是诡计多端的，他们带有一些不会实现的信息；那些穿过抛光的喇叭出来的人背后具有真理，对于看到他们的人来说是完成的。" Homer, Odyssey 19. 562 ff (Shewring translation).

为什么选择 Keras？

在如今无数深度学习框架中，为什么要使用 Keras 而非其他？以下是 Keras 与现有替代品的一些比较。

Keras 优先考虑开发人员的经验

Keras 是为人类而非机器设计的 API。Keras 遵循减少认知困难的最佳实践: 它提供一致且简单的 API，它将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
这使 Keras 易于学习和使用。作为 Keras 用户，你的工作效率更高，能够比竞争对手更快地尝试更多创意，从而帮助你赢得机器学习竞赛。
这种易用性并不以降低灵活性为代价：因为 Keras 与底层深度学习语言（特别是 TensorFlow）集成在一起，所以它可以让你实现任何你可以用基础语言编写的东西。特别是，tf.keras 作为 Keras API 可以与 TensorFlow 工作流无缝集成。

Keras 被工业界和学术界广泛采用

Deep learning 框架排名，由 Jeff Hale 基于 7 个分类的 11 个数据源计算得出

Keras 可以轻松将模型转化为产品

与任何其他深度学习框架相比，你的 Keras 模型可以在更广泛的平台上轻松部署：

在 iOS 上，通过 Apple’s CoreML（苹果为 Keras 提供官方支持）。这里有一个教程。
在 Android 上，通过 TensorFlow Android runtime，例如：Not Hotdog app。
在浏览器中，通过 GPU 加速的 JavaScript 运行时，例如：Keras.js 和 WebDNN。
在 Google Cloud 上，通过 TensorFlow-Serving。
在 Python webapp 后端（比如 Flask app）中。
在 JVM 上，通过 SkyMind 提供的 DL4J 模型导入。
在 Raspberry Pi 树莓派上。

Keras 支持多个后端引擎，不会将你锁定到一个生态系统中

谷歌的 TensorFlow 后端
微软的 CNTK 后端
Theano 后端

亚马逊也正在为 Keras 开发 MXNet 后端。

如此一来，你的 Keras 模型可以在 CPU 之外的不同硬件平台上训练：

NVIDIA GPU
Google TPU，通过 TensorFlow 后端和 Google Cloud
OpenCL 支持的 GPU, 比如 AMD, 通过 PlaidML Keras 后端

Keras 拥有强大的多 GPU 和分布式训练支持

Keras 内置对多 GPU 数据并行的支持。
优步的 Horovod 对 Keras 模型拥有一流的支持。
Keras 模型可以被转换为 TensorFlow Estimators 并在 Google Cloud 的 GPU 集群上训练。
Keras 可以在 Spark（通过 CERN 的 Dist-Keras）和 Elephas 上运行。

Keras 的发展得到深度学习生态系统中的关键公司的支持

感谢作者分享-http://bjbsair.com/2020-04-07/tech-info/30656.html

===

你恰好发现了 Keras。

如果你在以下情况下需要深度学习库，请使用 Keras：

允许简单而快速的原型设计（由于用户友好，高度模块化，可扩展性）。
同时支持卷积神经网络和循环神经网络，以及两者的组合。
在 CPU 和 GPU 上无缝运行。

查看文档，请访问 Keras.io。

Keras 兼容的 Python 版本: Python 2.7-3.6。

指导原则

用户友好。 Keras 是为人类而不是为机器设计的 API。它把用户体验放在首要和中心位置。Keras 遵循减少认知困难的最佳实践：它提供一致且简单的 API，将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
模块化。 模型被理解为由独立的、完全可配置的模块构成的序列或图。这些模块可以以尽可能少的限制组装在一起。特别是神经网络层、损失函数、优化器、初始化方法、激活函数、正则化方法，它们都是可以结合起来构建新模型的模块。
易扩展性。 新的模块是很容易添加的（作为新的类和函数），现有的模块已经提供了充足的示例。由于能够轻松地创建可以提高表现力的新模块，Keras 更加适合高级研究。
基于 Python 实现。 Keras 没有特定格式的单独配置文件。模型定义在 Python 代码中，这些代码紧凑，易于调试，并且易于扩展。

快速开始：30 秒上手 Keras

Sequential 模型如下所示：

from keras.models import Sequential  
  
model = Sequential()

可以简单地使用 .add() 来堆叠模型：

from keras.layers import Dense  
  
model.add(Dense(units=64, activation='relu', input_dim=100))  
model.add(Dense(units=10, activation='softmax'))

在完成了模型的构建后, 可以使用 .compile() 来配置学习过程：

model.compile(loss='categorical_crossentropy',  
              optimizer='sgd',  
              metrics=['accuracy'])

model.compile(loss=keras.losses.categorical_crossentropy,  
              optimizer=keras.optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True))

现在，你可以批量地在训练数据上进行迭代了：

# x_train 和 y_train 是 Numpy 数组 -- 就像在 Scikit-Learn API 中一样。  
model.fit(x_train, y_train, epochs=5, batch_size=32)

或者，你可以手动地将批次的数据提供给模型：

model.train_on_batch(x_batch, y_batch)

只需一行代码就能评估模型性能：

loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

或者对新的数据生成预测：

classes = model.predict(x_test, batch_size=128)

有关 Keras 更深入的教程，请查看：

开始使用 Sequential 模型
开始使用函数式 API

在代码仓库的 examples 目录中，你会找到更多高级模型：基于记忆网络的问答系统、基于栈式 LSTM 的文本生成等等。

安装指引

在安装 Keras 之前，请安装以下后端引擎之一：TensorFlow，Theano，或者 CNTK。我们推荐 TensorFlow 后端。

TensorFlow 安装指引。
Theano 安装指引。
CNTK 安装指引。

你也可以考虑安装以下可选依赖：

cuDNN (如果你计划在 GPU 上运行 Keras，建议安装)。
HDF5 和 h5py (如果你需要将 Keras 模型保存到磁盘，则需要这些)。
graphviz 和 pydot (用于可视化工具绘制模型图)。

然后你就可以安装 Keras 本身了。有两种方法安装 Keras：

使用 PyPI 安装 Keras (推荐)：

sudo pip install keras

如果你使用 virtualenv 虚拟环境, 你可以避免使用 sudo：

pip install keras

或者：使用 GitHub 源码安装 Keras：

首先，使用 git 来克隆 Keras：

git clone https://github.com/keras-team/keras.git

然后，cd 到 Keras 目录并且运行安装命令：

cd keras  
sudo python setup.py install

配置你的 Keras 后端

默认情况下，Keras 将使用 TensorFlow 作为其张量操作库。请跟随这些指引来配置其他 Keras 后端。

技术支持

你可以提出问题并参与开发讨论：

Keras Google group。
Keras Slack channel。使用这个链接向该频道请求邀请函。

你也可以在 GitHub issues 中发布漏洞报告和新功能请求（仅限于此）。注意请先阅读规范文档。

为什么取名为 Keras?

Keras 最初是作为 ONEIROS 项目（开放式神经电子智能机器人操作系统）研究工作的一部分而开发的。

"Oneiroi 超出了我们的理解 - 谁能确定它们讲述了什么故事？并不是所有人都能找到。那里有两扇门，就是通往短暂的 Oneiroi 的通道；一个是用号角制造的，一个是用象牙制造的。穿过尖锐的象牙的 Oneiroi 是诡计多端的，他们带有一些不会实现的信息；那些穿过抛光的喇叭出来的人背后具有真理，对于看到他们的人来说是完成的。" Homer, Odyssey 19. 562 ff (Shewring translation).

为什么选择 Keras？

在如今无数深度学习框架中，为什么要使用 Keras 而非其他？以下是 Keras 与现有替代品的一些比较。

Keras 优先考虑开发人员的经验

Keras 是为人类而非机器设计的 API。Keras 遵循减少认知困难的最佳实践: 它提供一致且简单的 API，它将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
这使 Keras 易于学习和使用。作为 Keras 用户，你的工作效率更高，能够比竞争对手更快地尝试更多创意，从而帮助你赢得机器学习竞赛。
这种易用性并不以降低灵活性为代价：因为 Keras 与底层深度学习语言（特别是 TensorFlow）集成在一起，所以它可以让你实现任何你可以用基础语言编写的东西。特别是，tf.keras 作为 Keras API 可以与 TensorFlow 工作流无缝集成。

Keras 被工业界和学术界广泛采用

Deep learning 框架排名，由 Jeff Hale 基于 7 个分类的 11 个数据源计算得出

Keras 可以轻松将模型转化为产品

与任何其他深度学习框架相比，你的 Keras 模型可以在更广泛的平台上轻松部署：

在 iOS 上，通过 Apple’s CoreML（苹果为 Keras 提供官方支持）。这里有一个教程。
在 Android 上，通过 TensorFlow Android runtime，例如：Not Hotdog app。
在浏览器中，通过 GPU 加速的 JavaScript 运行时，例如：Keras.js 和 WebDNN。
在 Google Cloud 上，通过 TensorFlow-Serving。
在 Python webapp 后端（比如 Flask app）中。
在 JVM 上，通过 SkyMind 提供的 DL4J 模型导入。
在 Raspberry Pi 树莓派上。

Keras 支持多个后端引擎，不会将你锁定到一个生态系统中

谷歌的 TensorFlow 后端
微软的 CNTK 后端
Theano 后端

亚马逊也正在为 Keras 开发 MXNet 后端。

如此一来，你的 Keras 模型可以在 CPU 之外的不同硬件平台上训练：

NVIDIA GPU
Google TPU，通过 TensorFlow 后端和 Google Cloud
OpenCL 支持的 GPU, 比如 AMD, 通过 PlaidML Keras 后端

Keras 拥有强大的多 GPU 和分布式训练支持

Keras 内置对多 GPU 数据并行的支持。
优步的 Horovod 对 Keras 模型拥有一流的支持。
Keras 模型可以被转换为 TensorFlow Estimators 并在 Google Cloud 的 GPU 集群上训练。
Keras 可以在 Spark（通过 CERN 的 Dist-Keras）和 Elephas 上运行。

Keras 的发展得到深度学习生态系统中的关键公司的支持

感谢作者分享-http://bjbsair.com/2020-04-07/tech-info/30656.html

===

你恰好发现了 Keras。

如果你在以下情况下需要深度学习库，请使用 Keras：

允许简单而快速的原型设计（由于用户友好，高度模块化，可扩展性）。
同时支持卷积神经网络和循环神经网络，以及两者的组合。
在 CPU 和 GPU 上无缝运行。

查看文档，请访问 Keras.io。

Keras 兼容的 Python 版本: Python 2.7-3.6。

指导原则

用户友好。 Keras 是为人类而不是为机器设计的 API。它把用户体验放在首要和中心位置。Keras 遵循减少认知困难的最佳实践：它提供一致且简单的 API，将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
模块化。 模型被理解为由独立的、完全可配置的模块构成的序列或图。这些模块可以以尽可能少的限制组装在一起。特别是神经网络层、损失函数、优化器、初始化方法、激活函数、正则化方法，它们都是可以结合起来构建新模型的模块。
易扩展性。 新的模块是很容易添加的（作为新的类和函数），现有的模块已经提供了充足的示例。由于能够轻松地创建可以提高表现力的新模块，Keras 更加适合高级研究。
基于 Python 实现。 Keras 没有特定格式的单独配置文件。模型定义在 Python 代码中，这些代码紧凑，易于调试，并且易于扩展。

快速开始：30 秒上手 Keras

Sequential 模型如下所示：

from keras.models import Sequential  
  
model = Sequential()

可以简单地使用 .add() 来堆叠模型：

from keras.layers import Dense  
  
model.add(Dense(units=64, activation='relu', input_dim=100))  
model.add(Dense(units=10, activation='softmax'))

在完成了模型的构建后, 可以使用 .compile() 来配置学习过程：

model.compile(loss='categorical_crossentropy',  
              optimizer='sgd',  
              metrics=['accuracy'])

model.compile(loss=keras.losses.categorical_crossentropy,  
              optimizer=keras.optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True))

现在，你可以批量地在训练数据上进行迭代了：

# x_train 和 y_train 是 Numpy 数组 -- 就像在 Scikit-Learn API 中一样。  
model.fit(x_train, y_train, epochs=5, batch_size=32)

或者，你可以手动地将批次的数据提供给模型：

model.train_on_batch(x_batch, y_batch)

只需一行代码就能评估模型性能：

loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

或者对新的数据生成预测：

classes = model.predict(x_test, batch_size=128)

有关 Keras 更深入的教程，请查看：

开始使用 Sequential 模型
开始使用函数式 API

在代码仓库的 examples 目录中，你会找到更多高级模型：基于记忆网络的问答系统、基于栈式 LSTM 的文本生成等等。

安装指引

在安装 Keras 之前，请安装以下后端引擎之一：TensorFlow，Theano，或者 CNTK。我们推荐 TensorFlow 后端。

TensorFlow 安装指引。
Theano 安装指引。
CNTK 安装指引。

你也可以考虑安装以下可选依赖：

cuDNN (如果你计划在 GPU 上运行 Keras，建议安装)。
HDF5 和 h5py (如果你需要将 Keras 模型保存到磁盘，则需要这些)。
graphviz 和 pydot (用于可视化工具绘制模型图)。

然后你就可以安装 Keras 本身了。有两种方法安装 Keras：

使用 PyPI 安装 Keras (推荐)：

sudo pip install keras

如果你使用 virtualenv 虚拟环境, 你可以避免使用 sudo：

pip install keras

或者：使用 GitHub 源码安装 Keras：

首先，使用 git 来克隆 Keras：

git clone https://github.com/keras-team/keras.git

然后，cd 到 Keras 目录并且运行安装命令：

cd keras  
sudo python setup.py install

配置你的 Keras 后端

默认情况下，Keras 将使用 TensorFlow 作为其张量操作库。请跟随这些指引来配置其他 Keras 后端。

技术支持

你可以提出问题并参与开发讨论：

Keras Google group。
Keras Slack channel。使用这个链接向该频道请求邀请函。

你也可以在 GitHub issues 中发布漏洞报告和新功能请求（仅限于此）。注意请先阅读规范文档。

为什么取名为 Keras?

Keras 最初是作为 ONEIROS 项目（开放式神经电子智能机器人操作系统）研究工作的一部分而开发的。

"Oneiroi 超出了我们的理解 - 谁能确定它们讲述了什么故事？并不是所有人都能找到。那里有两扇门，就是通往短暂的 Oneiroi 的通道；一个是用号角制造的，一个是用象牙制造的。穿过尖锐的象牙的 Oneiroi 是诡计多端的，他们带有一些不会实现的信息；那些穿过抛光的喇叭出来的人背后具有真理，对于看到他们的人来说是完成的。" Homer, Odyssey 19. 562 ff (Shewring translation).

为什么选择 Keras？

在如今无数深度学习框架中，为什么要使用 Keras 而非其他？以下是 Keras 与现有替代品的一些比较。

Keras 优先考虑开发人员的经验

Keras 是为人类而非机器设计的 API。Keras 遵循减少认知困难的最佳实践: 它提供一致且简单的 API，它将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
这使 Keras 易于学习和使用。作为 Keras 用户，你的工作效率更高，能够比竞争对手更快地尝试更多创意，从而帮助你赢得机器学习竞赛。
这种易用性并不以降低灵活性为代价：因为 Keras 与底层深度学习语言（特别是 TensorFlow）集成在一起，所以它可以让你实现任何你可以用基础语言编写的东西。特别是，tf.keras 作为 Keras API 可以与 TensorFlow 工作流无缝集成。

Keras 被工业界和学术界广泛采用

Deep learning 框架排名，由 Jeff Hale 基于 7 个分类的 11 个数据源计算得出

Keras 可以轻松将模型转化为产品

与任何其他深度学习框架相比，你的 Keras 模型可以在更广泛的平台上轻松部署：

在 iOS 上，通过 Apple’s CoreML（苹果为 Keras 提供官方支持）。这里有一个教程。
在 Android 上，通过 TensorFlow Android runtime，例如：Not Hotdog app。
在浏览器中，通过 GPU 加速的 JavaScript 运行时，例如：Keras.js 和 WebDNN。
在 Google Cloud 上，通过 TensorFlow-Serving。
在 Python webapp 后端（比如 Flask app）中。
在 JVM 上，通过 SkyMind 提供的 DL4J 模型导入。
在 Raspberry Pi 树莓派上。

Keras 支持多个后端引擎，不会将你锁定到一个生态系统中

谷歌的 TensorFlow 后端
微软的 CNTK 后端
Theano 后端

亚马逊也正在为 Keras 开发 MXNet 后端。

如此一来，你的 Keras 模型可以在 CPU 之外的不同硬件平台上训练：

NVIDIA GPU
Google TPU，通过 TensorFlow 后端和 Google Cloud
OpenCL 支持的 GPU, 比如 AMD, 通过 PlaidML Keras 后端

Keras 拥有强大的多 GPU 和分布式训练支持

Keras 内置对多 GPU 数据并行的支持。
优步的 Horovod 对 Keras 模型拥有一流的支持。
Keras 模型可以被转换为 TensorFlow Estimators 并在 Google Cloud 的 GPU 集群上训练。
Keras 可以在 Spark（通过 CERN 的 Dist-Keras）和 Elephas 上运行。

Keras 的发展得到深度学习生态系统中的关键公司的支持

感谢作者分享-http://bjbsair.com/2020-04-07/tech-info/30656.html

===

你恰好发现了 Keras。

如果你在以下情况下需要深度学习库，请使用 Keras：

允许简单而快速的原型设计（由于用户友好，高度模块化，可扩展性）。
同时支持卷积神经网络和循环神经网络，以及两者的组合。
在 CPU 和 GPU 上无缝运行。

查看文档，请访问 Keras.io。

Keras 兼容的 Python 版本: Python 2.7-3.6。

指导原则

用户友好。 Keras 是为人类而不是为机器设计的 API。它把用户体验放在首要和中心位置。Keras 遵循减少认知困难的最佳实践：它提供一致且简单的 API，将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
模块化。 模型被理解为由独立的、完全可配置的模块构成的序列或图。这些模块可以以尽可能少的限制组装在一起。特别是神经网络层、损失函数、优化器、初始化方法、激活函数、正则化方法，它们都是可以结合起来构建新模型的模块。
易扩展性。 新的模块是很容易添加的（作为新的类和函数），现有的模块已经提供了充足的示例。由于能够轻松地创建可以提高表现力的新模块，Keras 更加适合高级研究。
基于 Python 实现。 Keras 没有特定格式的单独配置文件。模型定义在 Python 代码中，这些代码紧凑，易于调试，并且易于扩展。

快速开始：30 秒上手 Keras

Sequential 模型如下所示：

from keras.models import Sequential  
  
model = Sequential()

可以简单地使用 .add() 来堆叠模型：

from keras.layers import Dense  
  
model.add(Dense(units=64, activation='relu', input_dim=100))  
model.add(Dense(units=10, activation='softmax'))

在完成了模型的构建后, 可以使用 .compile() 来配置学习过程：

model.compile(loss='categorical_crossentropy',  
              optimizer='sgd',  
              metrics=['accuracy'])

model.compile(loss=keras.losses.categorical_crossentropy,  
              optimizer=keras.optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True))

现在，你可以批量地在训练数据上进行迭代了：

# x_train 和 y_train 是 Numpy 数组 -- 就像在 Scikit-Learn API 中一样。  
model.fit(x_train, y_train, epochs=5, batch_size=32)

或者，你可以手动地将批次的数据提供给模型：

model.train_on_batch(x_batch, y_batch)

只需一行代码就能评估模型性能：

loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

或者对新的数据生成预测：

classes = model.predict(x_test, batch_size=128)

有关 Keras 更深入的教程，请查看：

开始使用 Sequential 模型
开始使用函数式 API

在代码仓库的 examples 目录中，你会找到更多高级模型：基于记忆网络的问答系统、基于栈式 LSTM 的文本生成等等。

安装指引

在安装 Keras 之前，请安装以下后端引擎之一：TensorFlow，Theano，或者 CNTK。我们推荐 TensorFlow 后端。

TensorFlow 安装指引。
Theano 安装指引。
CNTK 安装指引。

你也可以考虑安装以下可选依赖：

cuDNN (如果你计划在 GPU 上运行 Keras，建议安装)。
HDF5 和 h5py (如果你需要将 Keras 模型保存到磁盘，则需要这些)。
graphviz 和 pydot (用于可视化工具绘制模型图)。

然后你就可以安装 Keras 本身了。有两种方法安装 Keras：

使用 PyPI 安装 Keras (推荐)：

sudo pip install keras

如果你使用 virtualenv 虚拟环境, 你可以避免使用 sudo：

pip install keras

或者：使用 GitHub 源码安装 Keras：

首先，使用 git 来克隆 Keras：

git clone https://github.com/keras-team/keras.git

然后，cd 到 Keras 目录并且运行安装命令：

cd keras  
sudo python setup.py install

配置你的 Keras 后端

默认情况下，Keras 将使用 TensorFlow 作为其张量操作库。请跟随这些指引来配置其他 Keras 后端。

技术支持

你可以提出问题并参与开发讨论：

Keras Google group。
Keras Slack channel。使用这个链接向该频道请求邀请函。

你也可以在 GitHub issues 中发布漏洞报告和新功能请求（仅限于此）。注意请先阅读规范文档。

为什么取名为 Keras?

Keras 最初是作为 ONEIROS 项目（开放式神经电子智能机器人操作系统）研究工作的一部分而开发的。

"Oneiroi 超出了我们的理解 - 谁能确定它们讲述了什么故事？并不是所有人都能找到。那里有两扇门，就是通往短暂的 Oneiroi 的通道；一个是用号角制造的，一个是用象牙制造的。穿过尖锐的象牙的 Oneiroi 是诡计多端的，他们带有一些不会实现的信息；那些穿过抛光的喇叭出来的人背后具有真理，对于看到他们的人来说是完成的。" Homer, Odyssey 19. 562 ff (Shewring translation).

为什么选择 Keras？

在如今无数深度学习框架中，为什么要使用 Keras 而非其他？以下是 Keras 与现有替代品的一些比较。

Keras 优先考虑开发人员的经验

Keras 是为人类而非机器设计的 API。Keras 遵循减少认知困难的最佳实践: 它提供一致且简单的 API，它将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
这使 Keras 易于学习和使用。作为 Keras 用户，你的工作效率更高，能够比竞争对手更快地尝试更多创意，从而帮助你赢得机器学习竞赛。
这种易用性并不以降低灵活性为代价：因为 Keras 与底层深度学习语言（特别是 TensorFlow）集成在一起，所以它可以让你实现任何你可以用基础语言编写的东西。特别是，tf.keras 作为 Keras API 可以与 TensorFlow 工作流无缝集成。

Keras 被工业界和学术界广泛采用

Deep learning 框架排名，由 Jeff Hale 基于 7 个分类的 11 个数据源计算得出

Keras 可以轻松将模型转化为产品

与任何其他深度学习框架相比，你的 Keras 模型可以在更广泛的平台上轻松部署：

在 iOS 上，通过 Apple’s CoreML（苹果为 Keras 提供官方支持）。这里有一个教程。
在 Android 上，通过 TensorFlow Android runtime，例如：Not Hotdog app。
在浏览器中，通过 GPU 加速的 JavaScript 运行时，例如：Keras.js 和 WebDNN。
在 Google Cloud 上，通过 TensorFlow-Serving。
在 Python webapp 后端（比如 Flask app）中。
在 JVM 上，通过 SkyMind 提供的 DL4J 模型导入。
在 Raspberry Pi 树莓派上。

Keras 支持多个后端引擎，不会将你锁定到一个生态系统中

谷歌的 TensorFlow 后端
微软的 CNTK 后端
Theano 后端

亚马逊也正在为 Keras 开发 MXNet 后端。

如此一来，你的 Keras 模型可以在 CPU 之外的不同硬件平台上训练：

NVIDIA GPU
Google TPU，通过 TensorFlow 后端和 Google Cloud
OpenCL 支持的 GPU, 比如 AMD, 通过 PlaidML Keras 后端

Keras 拥有强大的多 GPU 和分布式训练支持

Keras 内置对多 GPU 数据并行的支持。
优步的 Horovod 对 Keras 模型拥有一流的支持。
Keras 模型可以被转换为 TensorFlow Estimators 并在 Google Cloud 的 GPU 集群上训练。
Keras 可以在 Spark（通过 CERN 的 Dist-Keras）和 Elephas 上运行。

Keras 的发展得到深度学习生态系统中的关键公司的支持

感谢作者分享-http://bjbsair.com/2020-04-07/tech-info/30656.html

===

你恰好发现了 Keras。

如果你在以下情况下需要深度学习库，请使用 Keras：

允许简单而快速的原型设计（由于用户友好，高度模块化，可扩展性）。
同时支持卷积神经网络和循环神经网络，以及两者的组合。
在 CPU 和 GPU 上无缝运行。

查看文档，请访问 Keras.io。

Keras 兼容的 Python 版本: Python 2.7-3.6。

指导原则

用户友好。 Keras 是为人类而不是为机器设计的 API。它把用户体验放在首要和中心位置。Keras 遵循减少认知困难的最佳实践：它提供一致且简单的 API，将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
模块化。 模型被理解为由独立的、完全可配置的模块构成的序列或图。这些模块可以以尽可能少的限制组装在一起。特别是神经网络层、损失函数、优化器、初始化方法、激活函数、正则化方法，它们都是可以结合起来构建新模型的模块。
易扩展性。 新的模块是很容易添加的（作为新的类和函数），现有的模块已经提供了充足的示例。由于能够轻松地创建可以提高表现力的新模块，Keras 更加适合高级研究。
基于 Python 实现。 Keras 没有特定格式的单独配置文件。模型定义在 Python 代码中，这些代码紧凑，易于调试，并且易于扩展。

快速开始：30 秒上手 Keras

Sequential 模型如下所示：

from keras.models import Sequential  
  
model = Sequential()

可以简单地使用 .add() 来堆叠模型：

from keras.layers import Dense  
  
model.add(Dense(units=64, activation='relu', input_dim=100))  
model.add(Dense(units=10, activation='softmax'))

在完成了模型的构建后, 可以使用 .compile() 来配置学习过程：

model.compile(loss='categorical_crossentropy',  
              optimizer='sgd',  
              metrics=['accuracy'])

model.compile(loss=keras.losses.categorical_crossentropy,  
              optimizer=keras.optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True))

现在，你可以批量地在训练数据上进行迭代了：

# x_train 和 y_train 是 Numpy 数组 -- 就像在 Scikit-Learn API 中一样。  
model.fit(x_train, y_train, epochs=5, batch_size=32)

或者，你可以手动地将批次的数据提供给模型：

model.train_on_batch(x_batch, y_batch)

只需一行代码就能评估模型性能：

loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

或者对新的数据生成预测：

classes = model.predict(x_test, batch_size=128)

有关 Keras 更深入的教程，请查看：

开始使用 Sequential 模型
开始使用函数式 API

在代码仓库的 examples 目录中，你会找到更多高级模型：基于记忆网络的问答系统、基于栈式 LSTM 的文本生成等等。

安装指引

在安装 Keras 之前，请安装以下后端引擎之一：TensorFlow，Theano，或者 CNTK。我们推荐 TensorFlow 后端。

TensorFlow 安装指引。
Theano 安装指引。
CNTK 安装指引。

你也可以考虑安装以下可选依赖：

cuDNN (如果你计划在 GPU 上运行 Keras，建议安装)。
HDF5 和 h5py (如果你需要将 Keras 模型保存到磁盘，则需要这些)。
graphviz 和 pydot (用于可视化工具绘制模型图)。

然后你就可以安装 Keras 本身了。有两种方法安装 Keras：

使用 PyPI 安装 Keras (推荐)：

sudo pip install keras

如果你使用 virtualenv 虚拟环境, 你可以避免使用 sudo：

pip install keras

或者：使用 GitHub 源码安装 Keras：

首先，使用 git 来克隆 Keras：

git clone https://github.com/keras-team/keras.git

然后，cd 到 Keras 目录并且运行安装命令：

cd keras  
sudo python setup.py install

配置你的 Keras 后端

默认情况下，Keras 将使用 TensorFlow 作为其张量操作库。请跟随这些指引来配置其他 Keras 后端。

技术支持

你可以提出问题并参与开发讨论：

Keras Google group。
Keras Slack channel。使用这个链接向该频道请求邀请函。

你也可以在 GitHub issues 中发布漏洞报告和新功能请求（仅限于此）。注意请先阅读规范文档。

为什么取名为 Keras?

Keras 最初是作为 ONEIROS 项目（开放式神经电子智能机器人操作系统）研究工作的一部分而开发的。

"Oneiroi 超出了我们的理解 - 谁能确定它们讲述了什么故事？并不是所有人都能找到。那里有两扇门，就是通往短暂的 Oneiroi 的通道；一个是用号角制造的，一个是用象牙制造的。穿过尖锐的象牙的 Oneiroi 是诡计多端的，他们带有一些不会实现的信息；那些穿过抛光的喇叭出来的人背后具有真理，对于看到他们的人来说是完成的。" Homer, Odyssey 19. 562 ff (Shewring translation).

为什么选择 Keras？

在如今无数深度学习框架中，为什么要使用 Keras 而非其他？以下是 Keras 与现有替代品的一些比较。

Keras 优先考虑开发人员的经验

Keras 是为人类而非机器设计的 API。Keras 遵循减少认知困难的最佳实践: 它提供一致且简单的 API，它将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
这使 Keras 易于学习和使用。作为 Keras 用户，你的工作效率更高，能够比竞争对手更快地尝试更多创意，从而帮助你赢得机器学习竞赛。
这种易用性并不以降低灵活性为代价：因为 Keras 与底层深度学习语言（特别是 TensorFlow）集成在一起，所以它可以让你实现任何你可以用基础语言编写的东西。特别是，tf.keras 作为 Keras API 可以与 TensorFlow 工作流无缝集成。

Keras 被工业界和学术界广泛采用

Deep learning 框架排名，由 Jeff Hale 基于 7 个分类的 11 个数据源计算得出

Keras 可以轻松将模型转化为产品

与任何其他深度学习框架相比，你的 Keras 模型可以在更广泛的平台上轻松部署：

在 iOS 上，通过 Apple’s CoreML（苹果为 Keras 提供官方支持）。这里有一个教程。
在 Android 上，通过 TensorFlow Android runtime，例如：Not Hotdog app。
在浏览器中，通过 GPU 加速的 JavaScript 运行时，例如：Keras.js 和 WebDNN。
在 Google Cloud 上，通过 TensorFlow-Serving。
在 Python webapp 后端（比如 Flask app）中。
在 JVM 上，通过 SkyMind 提供的 DL4J 模型导入。
在 Raspberry Pi 树莓派上。

Keras 支持多个后端引擎，不会将你锁定到一个生态系统中

谷歌的 TensorFlow 后端
微软的 CNTK 后端
Theano 后端

亚马逊也正在为 Keras 开发 MXNet 后端。

如此一来，你的 Keras 模型可以在 CPU 之外的不同硬件平台上训练：

NVIDIA GPU
Google TPU，通过 TensorFlow 后端和 Google Cloud
OpenCL 支持的 GPU, 比如 AMD, 通过 PlaidML Keras 后端

Keras 拥有强大的多 GPU 和分布式训练支持

Keras 内置对多 GPU 数据并行的支持。
优步的 Horovod 对 Keras 模型拥有一流的支持。
Keras 模型可以被转换为 TensorFlow Estimators 并在 Google Cloud 的 GPU 集群上训练。
Keras 可以在 Spark（通过 CERN 的 Dist-Keras）和 Elephas 上运行。

Keras 的发展得到深度学习生态系统中的关键公司的支持

感谢作者分享-http://bjbsair.com/2020-04-07/tech-info/30656.html

===

你恰好发现了 Keras。

如果你在以下情况下需要深度学习库，请使用 Keras：

允许简单而快速的原型设计（由于用户友好，高度模块化，可扩展性）。
同时支持卷积神经网络和循环神经网络，以及两者的组合。
在 CPU 和 GPU 上无缝运行。

查看文档，请访问 Keras.io。

Keras 兼容的 Python 版本: Python 2.7-3.6。

指导原则

用户友好。 Keras 是为人类而不是为机器设计的 API。它把用户体验放在首要和中心位置。Keras 遵循减少认知困难的最佳实践：它提供一致且简单的 API，将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
模块化。 模型被理解为由独立的、完全可配置的模块构成的序列或图。这些模块可以以尽可能少的限制组装在一起。特别是神经网络层、损失函数、优化器、初始化方法、激活函数、正则化方法，它们都是可以结合起来构建新模型的模块。
易扩展性。 新的模块是很容易添加的（作为新的类和函数），现有的模块已经提供了充足的示例。由于能够轻松地创建可以提高表现力的新模块，Keras 更加适合高级研究。
基于 Python 实现。 Keras 没有特定格式的单独配置文件。模型定义在 Python 代码中，这些代码紧凑，易于调试，并且易于扩展。

快速开始：30 秒上手 Keras

Sequential 模型如下所示：

from keras.models import Sequential  
  
model = Sequential()

可以简单地使用 .add() 来堆叠模型：

from keras.layers import Dense  
  
model.add(Dense(units=64, activation='relu', input_dim=100))  
model.add(Dense(units=10, activation='softmax'))

在完成了模型的构建后, 可以使用 .compile() 来配置学习过程：

model.compile(loss='categorical_crossentropy',  
              optimizer='sgd',  
              metrics=['accuracy'])

model.compile(loss=keras.losses.categorical_crossentropy,  
              optimizer=keras.optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True))

现在，你可以批量地在训练数据上进行迭代了：

# x_train 和 y_train 是 Numpy 数组 -- 就像在 Scikit-Learn API 中一样。  
model.fit(x_train, y_train, epochs=5, batch_size=32)

或者，你可以手动地将批次的数据提供给模型：

model.train_on_batch(x_batch, y_batch)

只需一行代码就能评估模型性能：

loss_and_metrics = model.evaluate(x_test, y_test, batch_size=128)

或者对新的数据生成预测：

classes = model.predict(x_test, batch_size=128)

有关 Keras 更深入的教程，请查看：

开始使用 Sequential 模型
开始使用函数式 API

在代码仓库的 examples 目录中，你会找到更多高级模型：基于记忆网络的问答系统、基于栈式 LSTM 的文本生成等等。

安装指引

在安装 Keras 之前，请安装以下后端引擎之一：TensorFlow，Theano，或者 CNTK。我们推荐 TensorFlow 后端。

TensorFlow 安装指引。
Theano 安装指引。
CNTK 安装指引。

你也可以考虑安装以下可选依赖：

cuDNN (如果你计划在 GPU 上运行 Keras，建议安装)。
HDF5 和 h5py (如果你需要将 Keras 模型保存到磁盘，则需要这些)。
graphviz 和 pydot (用于可视化工具绘制模型图)。

然后你就可以安装 Keras 本身了。有两种方法安装 Keras：

使用 PyPI 安装 Keras (推荐)：

sudo pip install keras

如果你使用 virtualenv 虚拟环境, 你可以避免使用 sudo：

pip install keras

或者：使用 GitHub 源码安装 Keras：

首先，使用 git 来克隆 Keras：

git clone https://github.com/keras-team/keras.git

然后，cd 到 Keras 目录并且运行安装命令：

cd keras  
sudo python setup.py install

配置你的 Keras 后端

默认情况下，Keras 将使用 TensorFlow 作为其张量操作库。请跟随这些指引来配置其他 Keras 后端。

技术支持

你可以提出问题并参与开发讨论：

Keras Google group。
Keras Slack channel。使用这个链接向该频道请求邀请函。

你也可以在 GitHub issues 中发布漏洞报告和新功能请求（仅限于此）。注意请先阅读规范文档。

为什么取名为 Keras?

Keras 最初是作为 ONEIROS 项目（开放式神经电子智能机器人操作系统）研究工作的一部分而开发的。

"Oneiroi 超出了我们的理解 - 谁能确定它们讲述了什么故事？并不是所有人都能找到。那里有两扇门，就是通往短暂的 Oneiroi 的通道；一个是用号角制造的，一个是用象牙制造的。穿过尖锐的象牙的 Oneiroi 是诡计多端的，他们带有一些不会实现的信息；那些穿过抛光的喇叭出来的人背后具有真理，对于看到他们的人来说是完成的。" Homer, Odyssey 19. 562 ff (Shewring translation).

为什么选择 Keras？

在如今无数深度学习框架中，为什么要使用 Keras 而非其他？以下是 Keras 与现有替代品的一些比较。

Keras 优先考虑开发人员的经验

Keras 是为人类而非机器设计的 API。Keras 遵循减少认知困难的最佳实践: 它提供一致且简单的 API，它将常见用例所需的用户操作数量降至最低，并且在用户错误时提供清晰和可操作的反馈。
这使 Keras 易于学习和使用。作为 Keras 用户，你的工作效率更高，能够比竞争对手更快地尝试更多创意，从而帮助你赢得机器学习竞赛。
这种易用性并不以降低灵活性为代价：因为 Keras 与底层深度学习语言（特别是 TensorFlow）集成在一起，所以它可以让你实现任何你可以用基础语言编写的东西。特别是，tf.keras 作为 Keras API 可以与 TensorFlow 工作流无缝集成。

Keras 被工业界和学术界广泛采用

Deep learning 框架排名，由 Jeff Hale 基于 7 个分类的 11 个数据源计算得出

Keras 可以轻松将模型转化为产品

与任何其他深度学习框架相比，你的 Keras 模型可以在更广泛的平台上轻松部署：

在 iOS 上，通过 Apple’s CoreML（苹果为 Keras 提供官方支持）。这里有一个教程。
在 Android 上，通过 TensorFlow Android runtime，例如：Not Hotdog app。
在浏览器中，通过 GPU 加速的 JavaScript 运行时，例如：Keras.js 和 WebDNN。
在 Google Cloud 上，通过 TensorFlow-Serving。
在 Python webapp 后端（比如 Flask app）中。
在 JVM 上，通过 SkyMind 提供的 DL4J 模型导入。
在 Raspberry Pi 树莓派上。

Keras 支持多个后端引擎，不会将你锁定到一个生态系统中

谷歌的 TensorFlow 后端
微软的 CNTK 后端
Theano 后端

亚马逊也正在为 Keras 开发 MXNet 后端。

如此一来，你的 Keras 模型可以在 CPU 之外的不同硬件平台上训练：

NVIDIA GPU
Google TPU，通过 TensorFlow 后端和 Google Cloud
OpenCL 支持的 GPU, 比如 AMD, 通过 PlaidML Keras 后端

Keras 拥有强大的多 GPU 和分布式训练支持

Keras 内置对多 GPU 数据并行的支持。
优步的 Horovod 对 Keras 模型拥有一流的支持。
Keras 模型可以被转换为 TensorFlow Estimators 并在 Google Cloud 的 GPU 集群上训练。
Keras 可以在 Spark（通过 CERN 的 Dist-Keras）和 Elephas 上运行。

Keras 的发展得到深度学习生态系统中的关键公司的支持

来源：https://www.cnblogs.com/lihanlin/p/12657714.html

标签

python函数（二）

我是研究僧i — Tue, 07 Apr 2020 23:02:21 +0000

python函数（二）我是研究僧i 2020-04-08 07:02:21

一：函数对象：函数是第一类对象，即函数可以当作数据传递

=================================
1 可以被引用
2 可以当作参数传递
3 返回值可以是函数
4 可以当作容器类型的元素

=================================

1.函数可以被引用

1 def foo():
2     print('from foo')
3 func=foo
4 
5 print(foo)
6 print(func)
7 func()

执行结果

<function foo at 0x00000000006FF598>
<function foo at 0x00000000006FF598>
from foo

函数名本身表示的就是内存地址，可以被其他对象引用

2.被当做参数传递

def foo():
    print('from foo')

def bar(func):
    print(func)
    func()

bar(foo)

View Code

执行结果

<function foo at 0x000000000082F598>
from foo

3.返回值可以是函数

def foo():
    print('from foo')

def bar(func):
    return func

f=bar(foo)

print(f)

f()

执行结果

<function foo at 0x0000000000A6F598>
from foo

bar(foo)返回的就是foo本身，所有f和foo都指向同一块内存地址

4.可以当做容器类型的元素

def select(sql):
    print('==========select')

def delete(sql):
    print('==========delete')

def insert(sql):
    print('==========insert')

def update(sql):
    print('==========update')


func_dict={
    'select':select,
    'update':update,
    'insert':insert,
    'delete':delete
}

while True:
    in_sql=input('sql>').strip()
    sql=in_sql.split()
    cmd=sql[0]
    if cmd in func_dict:
        func_dict[cmd](sql)
    else:
        print('error')

View Code

二、函数嵌套

1.函数的嵌套定义

def f1():
    def f2():
        print('from f2')
        def f3():
            print('from f3')
        f3()
    f2()

 f1()

View Code

2.函数的嵌套调用

def max2(x,y):
    return x if x > y else y

def max4(a,b,c,d):
    res1=max2(a,b)
    res2=max2(res1,c)
    res3=max2(res2,d)
    return res3

print(max4(10,99,31,22))

View Code

三、名称空间与作用域

（一）名称空间包含有三种

1.内置名称空间

2.全局名称空间

3.局部名称空间

引:名字(名称)的定义

变量

name='larry'

函数

def func():

pass

类

class human:

　　pass

1.内置名称空间

随着解释器的启动而产生

import builtins
for i in dir(builtins):
　　print(i)

2.全局名称空间

文件的执行会产生全局名称空间，指的是文件级别定义的名字都会放入该空间

3.局部名称空间

调用函数时会产生局部名称空间，只在函数调用时临时绑定，调用结束解绑定

x=10000
def func():
    x=1
    print(x)

func()
print(x)

View Code

执行结果

10000

（二）作用域

1.全局作用域:内置名称空间，全局名称空间

2.局部作用域:局部名称空间

名字的查找顺序：局部名称空间---》全局名层空间---》内置名称空间

x=1
def func():
    x=2
    print(x)
    sum=123123
    print(sum)
func()

View Code

执行结果

123123

#查看全局作用域内的名字：gloabls()
#查看局局作用域内的名字：locals()

x=1000
def func():
    x=2
print(globals())
print(locals())
print(globals() is locals())

View Code

执行结果

{'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000000556C18>, '__spec__': None, '__package__': None, '__file__': 'C:/Users/larry/PycharmProjects/python/day04/fun_exc.py', '__cached__': None, '__name__': '__main__', '__doc__': None, 'func': <function func at 0x000000000071D6A8>, 'x': 1000, '__builtins__': <module 'builtins' (built-in)>}
{'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000000000556C18>, '__spec__': None, '__package__': None, '__file__': 'C:/Users/larry/PycharmProjects/python/day04/fun_exc.py', '__cached__': None, '__name__': '__main__', '__doc__': None, 'func': <function func at 0x000000000071D6A8>, 'x': 1000, '__builtins__': <module 'builtins' (built-in)>}
True

x=1000
def func():
    x=2
    print(globals())
    print(locals())
    print(globals() is locals())

func()

View Code

执行结果

{'func': <function func at 0x000000000102D6A8>, '__name__': '__main__', '__doc__': None, '__package__': None, '__spec__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000000006B6C18>, '__file__': 'C:/Users/larry/PycharmProjects/python/day04/fun_exc.py', '__cached__': None, '__builtins__': <module 'builtins' (built-in)>, 'x': 1000}
{'x': 2}
False

#全局作用域：全局有效，在任何位置都能被访问到，除非del删掉，否则会一直存活到文件执行完毕
#局部作用域的名字：局部有效，只能在局部范围调用，只在函数调用时才有效，调用结束就失效

x=1

def f1():
    print(x)

def foo():
    print(x)

def f(x):
    x=4
    def f2():
        x=3
        def f3():
            x=2
            print(x)

        f3()
    f2()

f(4)

View Code

函数调用时局部有效

来源：https://www.cnblogs.com/geek-ace/p/6906569.html

标签

python函数

python

python 核心编程第十四章

和自甴很熟 — Tue, 07 Apr 2020 11:41:37 +0000

python 核心编程第十四章和自甴很熟 2020-04-07 19:41:37

python 运行外部程序或内部动态生成的程序段

函数

内建函数（BIFs）
BIF 属性描述
bif.doc 文档字符串（或 None)
bif.name 字符串类型的文档名字
bif.self 设置为 None（保留给 built-in 方法）
bif.module 存放 bif 定义的模块名字(或 None)
用户定义的函数属性（UDF）
UDF 属性描述
udf.doc 文档字符串(也可以用 udf.func_doc)
udf.name 字符串类型的函数名字（也可以用 udf.func_name)
udf.func_code 字节编译的代码对象
udf.func_defaults 默认的参数元组
udf.func_globals 全局名字空间字典；和从函数内部调用 globals(x)一样
udf.func_dict 函数属性的名字空间
udf.func_doc (见上面的 udf.doc)
udf.func_name (见上面的 udf.name)
udf.func_closure 包含了自由变量的引用的单元对象元组（自用变量在 UDF 中使用，但在别处定义；参见 python[语言]参考手册）

方法

内建方法（BIM）属性
BIM 属性描述
bim.doc 文档字串
bim.name 字符串类型的函数名字
bim.self 绑定的对象
用户自定义的方法（UDM）
UDM 属性描述
udm.doc 文档字符串（与 udm.im_fuc.__doc__相同）
udm.name 字符串类型的方法名字（与 umd.im_func.__name__相同）
udm.module 定义 udm 的模块的名字(或 none)
udm.im_class 方法相关联的类（对于绑定的方法；如果是非绑定，那么为要求 udm 的类）
udm.im_func 方法的函数对象（见 UDFs）
udm.im_self 如果绑定的话为相关联的实例，如果非绑定位为 none

调用类的实例，需要实现__call__方法

代码对象

callable():
确定一个函数是否是可调用对象，也就是是否可以通过函数操作"()"来调用，返回一个布尔值。
compile():代码运行时，生成代码对象。
compile 的三个参数都是必需的，第一参数代表了要编译的 python 代码。第二个字符串，虽然
是必需的，但通常被置为空串。该参数代表了存放代码对象的文件的名字(字符串类型）。compile 的
通常用法是动态生成字符串形式的 Python 代码，然后生成一个代码对象——代码显然没有存放在
任何文件。
最后的参数是个字符串，它用来表明代码对象的类型。有三个可能值：
'eval' 可求值的表达式[和 eval()一起使用]
'single' 单一可执行语句[和 exec 一起使用]
'exec' 可执行语句组[和 exec 一起使用]

eval_code = compile("100+2", "", "eval")
single_code = compile(r"print 'Hello world!'", "", 'single')
exec_code = compile("""
req = input("Count how many numbers?")
for eachNum in range(req):
    print eachNum
""", "", "exec")
eval(eval_code)
exec single_code
exec exec_code


Hello world!
Count how many numbers?3
0
1
2

exec 可以直接使用字符串执行，但如果使用compil（）速度会更快一点。他还可以接受python文件对象

f = open("text.txt")
exec f
f.seek(0)
exec f

之所以使用seek（）的原因是，调用一次exec后文件指针会在文件最末尾，这样在调用一次exec就如同没有效用一样
4. input() 等价于 eval(raw_input())

在python运行时生成和执行python代码

dashes = "\n" + "- " * 50
exec_dict = {"f":"""
for %s in %s:
    print %s""", "s": """
%s = 0
%s = %s
while %s < len(%s):
    print %s[%s]
    %s = %s +1""", "n": """
%s = %d
while %s < %d:
print %s
%s = %s + %d"""}

def main():
    ltype = raw_input("loop type?(For/While)")
    dtype = raw_input("Data type?(Number/Seq)")
    if dtype == "n":
        start = input("Starting value")
        stop = input("Ending value (Non-inclusive)?")
        step = input("stepping value?")
        seq = str(range(start, stop, step))
    else:
        seq = raw_input("enter sequence?")
    var = raw_input("Iterative variable name?")
    if ltype == "f":
        exec_str = exec_dict["f"] % (var, seq, var)
    elif ltype == 'w':
        if dtype == "s":
            svar = raw_input("enter sequence name?")
            exec_str = exec_dict["s"]%(var, svar, seq, var, svar, svar, var, var, var)
        elif dtype == "n":
            exec_str = exec_dict["n"]%(var, start, var, stop, var, var, var, step)
    print dashes
    print exec_str, dashes
    exec exec_str
    print dashes

if __name__ == '__main__':
    main()

有条件的执行代码

def bar():
    return True
def foo():
    "foo() does not do much"
    return True

bar.__doc__ = "bar() does not do much"
foo.tester = """
if foo():
    print 'PASSED'
else:
    print 'FAILED'"""
print dir()
for eachAttr in dir():
    obj = eval(eachAttr)
    if isinstance(obj, type(foo)):
        if hasattr(obj, "__doc__"):
            print "\nfunction '%s' has a doc string:\n\t%s" % (eachAttr, obj.__doc__)
        if hasattr(obj, "tester"):
            print "function '%s' has a tester...executing" % eachAttr
            exec obj.tester
        else:
            print "function '%s' has no tester...skipping" % eachAttr
    else:
        print "%s is not a function" % eachAttr

程序输出

['__builtins__', '__doc__', '__file__', '__name__', '__package__', 'bar', 'foo']
__builtins__ is not a function
__doc__ is not a function
__file__ is not a function
__name__ is not a function
__package__ is not a function

function 'bar' has a doc string:
   bar() does not do much
function 'bar' has no tester...skipping

function 'foo' has a doc string:
   foo() does not do much
function 'foo' has a tester...executing
PASSED

执行其他python程序

execfile()函数
execfile(filename, globals=globals(), locals=locals())

执行其他非python程序

os.system()执行命令行
os.popen()

此章练习跳过

来源：https://www.cnblogs.com/jikeboy/p/6028590.html

标签

《自拍教程55》Python_批量验证1000个apk（附练手素材）

和自甴很熟 — Tue, 07 Apr 2020 11:22:07 +0000

《自拍教程55》Python_批量验证1000个apk（附练手素材）和自甴很熟 2020-04-07 19:22:07

接上一篇案例：Python_批量下载1000个apk，我们只讲了如何下载，
其实市场部提供的表格，不仅仅包含了apk的下载地址，还有apk的版本号，还有MD5信息等，
如何确保你下载的这1000个apk，是下载过程中未出错，版本号对的上，MD5信息也对上？
附:市场部提供的包含apk版本号，md5信息的表。

本案例主要介绍：如何快速地实现对已经下载好的app进行批量地验证。

准备阶段

本篇只讲验证apk的版本号与md5信息，不讲下载。
需要确保aapt已经成功地加入到了环境变量中去
“aapt dump bagding XXX.apk | findstr version”命令可以解析某个apk的versionName信息。
Windows操作系统可以用“certutil -hashfile XXX.apk MD5”命令可以计算某apk的MD5哈希值，
MD5是用于验证文件下载过程完整性的常用的一套计算方法，确保被下载的文件，在网络传输过程中，未被篡改或者损坏。
Linux操作系统可以用“md5sum XXX.apk”命令来计算某个apk的MD5哈希值。
其实Python的hashlib模块，也可以进行MD5哈希值的计算，可不受操作系统影响。
上一篇案例，我们已经下载好了的apk是放在“downloaded_apk”文件下，os.listdir()函数可以列出文件夹下的所有apk文件。
涉及Excel读写操作，依旧推荐openpyxl，需要考虑与原始Excel上的版本号及MD5值自动做对比，
所以我们增加了2列用于做验证对比，如果值相同，我们回填Ok，如果值不相同，我们回填差异值并标记红底色。

Python批处理脚本形式

记住批处理脚本的精髓：批量顺序执行语句

# coding=utf-8

import os
import re
import openpyxl
from openpyxl.styles import PatternFill

# 第一步：再生成整个excel表格的字典，key是apk中文名称，value是一个列表[所在行数, 版本号，MD5]
print("正在生成apk信息索引字典...")
apkinfo_dict = {}
apkname_col = 2
apkversion_col = 4
apkmd5_col = 6
apkversion_col_newadd = 5  # 新加的版本验证列
apkmd5_col_newadd = 7  # 新加的MD5验证列
error_fill = PatternFill(fill_type='solid', fgColor="FF3300")  # 标记红色底色
excel = openpyxl.load_workbook('Top_1000_apks.xlsx')  # 读取excel里边的内容
table = excel.active
rows = table.max_row
for r in range(2, rows + 1):  # 跟excel的第一行标题行无关，从第二行文字内容开始做替换工作
    apk_name = table.cell(row=r, column=apkname_col).value  # 获取apk名称
    apk_version = table.cell(row=r, column=apkversion_col).value  # 获取apk名称
    apk_md5 = table.cell(row=r, column=apkmd5_col).value  # 获取apk名称
    apkinfo_dict[apk_name] = [r, apk_version, apk_md5]
print(apkinfo_dict)

# 第二步：再读取downloaded_apk文件夹下的所有文件，并进行对比及回填操作
curpath = os.getcwd()
apk_dir = os.path.join(curpath, "downloaded_apk")
apk_list = os.listdir(apk_dir)
for apk in apk_list:
    print("正在进行%s的版本和MD5值对比与回填操作..." % apk)
    apk_path = os.path.join(apk_dir, apk)
    file_name = apk.replace(".apk", "")  # 获取apk文件名，去掉后缀
    s1 = os.popen("aapt.exe dump badging %s | findstr version" % apk_path).read()
    version_name = re.findall(r"versionName=\'(.*)\'", s1)[0]
    print(version_name)
    s2 = os.popen("certutil -hashfile %s MD5" % apk_path).read()
    md5_value = s2.splitlines()[1]
    md5_value = md5_value.replace(" ", "")
    print(md5_value)

    r = apkinfo_dict[file_name][0]  # 获得该apk所在行号

    # 假如版本号匹配的上，回填Ok，假如匹配不上，回填新的版本号
    if version_name == apkinfo_dict[file_name][1]:
        table.cell(row=r, column=apkversion_col_newadd).value = "OK"
    else:
        table.cell(row=r, column=apkversion_col_newadd).value = version_name
        table.cell(row=r, column=apkversion_col_newadd).fill = error_fill  # 标记红色底色

    # 假如MD5匹配的上，回填Ok，假如匹配不上，回填新的MD5
    if md5_value == apkinfo_dict[file_name][2]:
        table.cell(row=r, column=apkmd5_col_newadd).value = "OK"
    else:
        table.cell(row=r, column=apkmd5_col_newadd).value = md5_value
        table.cell(row=r, column=apkmd5_col_newadd).fill = error_fill  # 标记红色底色

print("对比及回填结束，并保存到了New_Top_1000_apks.xlsx，请查阅...")
excel.save("New_Top_1000_apks.xlsx")
os.system("pause")

Python面向过程函数形式

面向过程函数的编程思维应该是这样的：
你需要多少个功能（函数），才能做成这个事,
最好把功能（函数）都尽量封装好，只暴露一些的参数接口即可。
在命令行工具熟练运用后，就可以考虑尽量用Python模块来实现命令行工具的功能，
比如certutil或md5sum就尽量不用了，而考虑用hashlib模块来代替，
减少对某个命令行工具的依赖，这样可移植性更强些（减少了对操作系统的限制）。

# coding=utf-8

import os
import re
import openpyxl
from openpyxl.styles import PatternFill
import hashlib

# 定义一些本模块（当前.py文件）可能都需要调用的“全局变量”
apkname_col = 2
apkversion_col = 4
apkmd5_col = 6
apkversion_col_newadd = 5  # 新加的版本验证列
apkmd5_col_newadd = 7  # 新加的MD5验证列
error_fill = PatternFill(fill_type='solid', fgColor="FF3300")  # 标记红色底色


def parse_apk_excel(excel_file):
    '''用于生成apk信息索引字典'''
    print("正在生成apk信息索引字典...")
    apk_info_dict = {}
    excel = openpyxl.load_workbook(excel_file)  # 读取excel里边的内容
    table = excel.active
    rows = table.max_row
    for r in range(2, rows + 1):  # 跟excel的第一行标题行无关，从第二行文字内容开始做替换工作
        apk_name = table.cell(row=r, column=apkname_col).value  # 获取apk名称
        apk_version = table.cell(row=r, column=apkversion_col).value  # 获取apk名称
        apk_md5 = table.cell(row=r, column=apkmd5_col).value  # 获取apk名称
        apk_info_dict[apk_name] = [r, apk_version, apk_md5]
    return apk_info_dict, excel, table


def get_apk_version(apk_path):
    s = os.popen("aapt.exe dump badging %s | findstr version" % apk_path).read()
    version_name = re.findall(r"versionName=\'(.*)\'", s)[0]
    print(version_name)
    return version_name


def get_apk_md5(apk_path):
    with open(apk_path, "rb") as hf:
        apk_md5 = hashlib.md5(hf.read()).hexdigest()
        print(apk_md5)
        return apk_md5


def compare_rewrite(apk_info_dict, excel, table):
    curpath = os.getcwd()
    apk_dir = os.path.join(curpath, "downloaded_apk")
    apk_list = os.listdir(apk_dir)
    for apk in apk_list:
        print("正在进行%s的版本和MD5值对比与回填操作..." % apk)
        file_name = apk.replace(".apk", "")  # 获取apk文件名，去掉后缀
        apk_path = os.path.join(apk_dir, apk)
        version_name = get_apk_version(apk_path)
        md5_value = get_apk_md5(apk_path)
        r = apk_info_dict[file_name][0]  # 获得该apk所在行号

        # 假如版本号匹配的上，回填Ok，假如匹配不上，回填新的版本号
        if version_name == apk_info_dict[file_name][1]:
            table.cell(row=r, column=apkversion_col_newadd).value = "OK"
        else:
            table.cell(row=r, column=apkversion_col_newadd).value = version_name
            table.cell(row=r, column=apkversion_col_newadd).fill = error_fill  # 标记红色底色

        # 假如MD5匹配的上，回填Ok，假如匹配不上，回填新的MD5
        if md5_value == apk_info_dict[file_name][2]:
            table.cell(row=r, column=apkmd5_col_newadd).value = "OK"
        else:
            table.cell(row=r, column=apkmd5_col_newadd).value = md5_value
            table.cell(row=r, column=apkmd5_col_newadd).fill = error_fill  # 标记红色底色

    print("对比及回填结束，并保存到了New_Top_1000_apks.xlsx，请查阅...")
    excel.save("New_Top_1000_apks.xlsx")


apk_info_dict, excel, table = parse_apk_excel("Top_1000_apks.xlsx")  # 获取索引字典
compare_rewrite(apk_info_dict, excel, table)  # 开始对比及回填
os.system("pause")

Python面向对象类形式

面向对象类的编程思维应该是这样的：
如果给你一个空白的世界，在这个世界里你需要哪些种类的事物，
这些种类的事物都具备哪些共有的属性与方法，
这些种类（类）的事物（对象），和其他种类（其他类）的事物（其他对象）有什么关系。
尽量把这些类封装好，只暴露对外的属性（变量）和方法（函数）即可。

# coding=utf-8

import os
import re
import openpyxl
from openpyxl.styles import PatternFill
import hashlib

# 定义一些本模块（当前.py文件）可能都需要调用的“全局变量”
apkname_col = 2
apkversion_col = 4
apkmd5_col = 6
apkversion_col_newadd = 5  # 新加的版本验证列
apkmd5_col_newadd = 7  # 新加的MD5验证列
error_fill = PatternFill(fill_type='solid', fgColor="FF3300")  # 标记红色底色


class ExcelParser():
    def __init__(self, excel_file):
        self._excel_file = excel_file  # 没必要暴露到外界，加_

    def parse_apk_excel(self):  # 这是需要暴露的方法（函数），不能加_
        '''用于生成apk信息索引字典'''
        print("正在生成apk信息索引字典...")
        apk_info_dict = {}
        excel = openpyxl.load_workbook(self._excel_file)  # 读取excel里边的内容
        table = excel.active
        rows = table.max_row
        for r in range(2, rows + 1):  # 跟excel的第一行标题行无关，从第二行文字内容开始做替换工作
            apk_name = table.cell(row=r, column=apkname_col).value  # 获取apk名称
            apk_version = table.cell(row=r, column=apkversion_col).value  # 获取apk名称
            apk_md5 = table.cell(row=r, column=apkmd5_col).value  # 获取apk名称
            apk_info_dict[apk_name] = [r, apk_version, apk_md5]
        return apk_info_dict, excel, table


def get_apk_version(apk_path):
    s = os.popen("aapt.exe dump badging %s | findstr version" % apk_path).read()
    version_name = re.findall(r"versionName=\'(.*)\'", s)[0]
    print(version_name)
    return version_name


def get_apk_md5(apk_path):
    with open(apk_path, "rb") as hf:
        apk_md5 = hashlib.md5(hf.read()).hexdigest()
        print(apk_md5)
        return apk_md5


def compare_rewrite(apk_info_dict, excel, table):
    curpath = os.getcwd()
    apk_dir = os.path.join(curpath, "downloaded_apk")
    apk_list = os.listdir(apk_dir)
    for apk in apk_list:
        print("正在进行%s的版本和MD5值对比与回填操作..." % apk)
        file_name = apk.replace(".apk", "")  # 获取apk文件名，去掉后缀
        apk_path = os.path.join(apk_dir, apk)
        version_name = get_apk_version(apk_path)
        md5_value = get_apk_md5(apk_path)
        r = apk_info_dict[file_name][0]  # 获得该apk所在行号

        # 假如版本号匹配的上，回填Ok，假如匹配不上，回填新的版本号
        if version_name == apk_info_dict[file_name][1]:
            table.cell(row=r, column=apkversion_col_newadd).value = "OK"
        else:
            table.cell(row=r, column=apkversion_col_newadd).value = version_name
            table.cell(row=r, column=apkversion_col_newadd).fill = error_fill  # 标记红色底色

        # 假如MD5匹配的上，回填Ok，假如匹配不上，回填新的MD5
        if md5_value == apk_info_dict[file_name][2]:
            table.cell(row=r, column=apkmd5_col_newadd).value = "OK"
        else:
            table.cell(row=r, column=apkmd5_col_newadd).value = md5_value
            table.cell(row=r, column=apkmd5_col_newadd).fill = error_fill  # 标记红色底色

    print("对比及回填结束，并保存到了New_Top_1000_apks.xlsx，请查阅...")
    excel.save("New_Top_1000_apks.xlsx")


if __name__ == '__main__':
    e_obj = ExcelParser("Top_1000_apks.xlsx")
    apk_info_dict, excel, table = e_obj.parse_apk_excel()  # 获取索引字典
    compare_rewrite(apk_info_dict, excel, table)  # 开始对比及回填
    os.system("pause")

本案例练手素材下载

跳转到自拍教程官网下载素材
武散人出品，请放心下载并使用！

运行方式与效果

确保Android设备通过USB线与电脑连接了，adb设备有效连接，
以上代码的3种实现形式都可以直接运行，比如保存为verify_apks.py并和downloaded_apk文件夹还有Top_1000_apks.xlsx放在同一个文件夹下，
建议python verify_apks.py运行，当然也可以双击运行。
运行效果如下：

最终会新生成一个New_Top_1000_apks.xlsx，其验证及回填效果如下，
红色的是代表实际下载下来的apk与市场部提供的Excel上的版本信息及Md5不一样的标注。

更多更好的原创文章，请访问官方网站：www.zipython.com
自拍教程（自动化测试Python教程，武散人编著）
原文链接：https://www.zipython.com/#/detail?id=f13a1efe25424b679e663a63fb64a10c
也可关注“武散人”微信订阅号，随时接受文章推送。

来源：https://www.cnblogs.com/zipython/p/12655033.html

标签