python函数前言,Python函数语句

Python分组

前言分组原理

核心：

1.不论分组键是数组、列表、字典、Series、函数，只要其与待分组变量的轴长度一致都可以传入groupby进行分组。

2.默认axis=0按行分组，可指定axis=1对列分组。

对数据进行分组操作的过程可以概括为：split-apply-combine三步：

1.按照键值（key）或者分组变量将数据分组。

2.对于每组应用我们的函数，这一步非常灵活，可以是python自带函数，可以是我们自己编写的函数。

3.将函数计算后的结果聚合。

1 分组模式及其对象

1.1 分组的一般模式

三个要素:分组依据、数据来源、操作及其返回结果

df.groupby(分组依据)[数据来源].使用操作

1.2 分组依据的本质

1.3Groupby 对象

通过 ngroups 属性，可以访问分为了多少组:

通过 groups 属性，可以返回从 组名映射到 组索引列表的字典:

当 size 作为 DataFrame 的属性时，返回的是表长乘以表宽的大小，但在 groupby 对象上表示统计每个组的 元素个数:

通过 get_group 方法可以直接获取所在组对应的行，此时必须知道组的具体名字:

1.4 分组的三大操作

分组的三大操作:聚合、变换和过滤

2.聚合函数

2.1内置聚合函数

包括如下函数: max/min/mean/median/count/all/any/idxmax/idxmin/mad/nunique/skew/quantile/sum/std/var/sem/size/prod

2.2agg 方法

【a】使用多个函数

当使用多个聚合函数时，需要用列表的形式把内置聚合函数的对应的字符串传入，先前提到的所有字符串都是合法的。

【b】对特定的列使用特定的聚合函数

对于方法和列的特殊对应，可以通过构造字典传入 agg 中实现，其中字典以列名为键，以聚合字符串或字符串列表为值。

【c】使用自定义函数

在 agg 中可以使用具体的自定义函数，需要注意传入函数的参数是之前数据源中的列，逐列进行计算

【d】聚合结果重命名 如果想要对结果进行重命名，只需要将上述函数的位置改写成元组，元组的第一个元素为新的名字，第二个位置为原来的函数，包括聚合字符串和自定义函数

3 变换和过滤

3.1 变换函数与 transform 方法

变 换 函 数 的 返 回 值 为 同 长 度 的 序 列， 最 常 用 的 内 置 变 换 函 数 是 累 计 函 数:cum- count/cumsum/cumprod/cummax/cummin ，它们的使用方式和聚合函数类似，只不过完成的是组内 累计操作。

3.2 组索引与过滤

过滤在分组中是对于组的过滤，而索引是对于行的过滤

组过滤作为行过滤的推广，指的是如果对一个组的全体所在行进行统计的结果返回 True 则会被保留，False 则该组会被过滤，最后把所有未被过滤的组其对应的所在行拼接起来作为 DataFrame 返回。

在 groupby 对象中，定义了 filter 方法进行组的筛选，其中自定义函数的输入参数为数据源构成的 DataFrame 本身，在之前例子中定义的 groupby 对象中，传入的就是 df[['Height', 'Weight']] ，因此所有表方法和属性 都可以在自定义函数中相应地使用，同时只需保证自定义函数的返回为布尔值即可。

4 跨列分组

4.1 apply 的引入

4.2 apply 的使用

在设计上，apply 的自定义函数传入参数与 filter 完全一致，只不过后者只允许返回布尔值

【a】标量情况:结果得到的是 Series ，索引与 agg 的结果一致

【b】Series 情况:得到的是 DataFrame ，行索引与标量情况一致，列索引为 Series 的索引

【c】DataFrame 情况:得到的是 DataFrame ，行索引最内层在每个组原先 agg 的结果索引上，再加一层返 回的 DataFrame 行索引，同时分组结果 DataFrame 的列索引和返回的 DataFrame 列索引一致

如何用python

把之前教程的地址移过来

合并帖子的内容：【整理】【多图详解】如何在Windows下开发Python：在cmd下运行Python脚本+如何使用Python Shell（command line模式和GUI模式）+如何使用Python IDE

为出版而整理：每章都加了摘要，每章都完善了架构。

整理章节的架构；整理第一章的内容

添加Python学习资料目录

前言

1. 本文目的

2. 看此文之前你所要掌握的知识

1. Python简介

1.1. 什么是Python

1.1.1. Python这个单词的本意是蟒蛇

1.1.2. Python是一种计算机语言

1.1.3. 作为计算机语言的Python的各种叫法的含义

1.1.3.1. Python是一种脚本语言

1.1.3.2. Python是一种交互性的语言

1.1.3.3. Python是一门解释性的语言

1.1.3.4. Python是一种面向对象的语言

1.1.3.5. Python是一种高级语言

1.2. Python能干什么

1.3. Python的特点

1.3.1. 作为解释性语言的Python的优缺点

1.3.1.1. Python的优点

1.3.1.2. Python的缺点

1.3.2. Python语言自身的特点

1.4. Python相关的必备知识

1.4.1. Python文件的后缀是py

1.4.2. Python的缩写和简称

1.4.3. Python的官网

1.4.4. Python的logo图案

2. 选择并下载合适的版本的Python

2.1. 为何要注意选择合适版本的Python

2.2. 如何选择正确版本的Python

2.2.1. 明确当前所处平台版本的信息

2.2.2. 选择可用和速度快的下载源

2.2.3. 选择合适的版本的Python

3. 如何安装Python

3.1. 如何在Windows系统中安装Python

3.1.1. 在Win7中安装Python

3.2. 如何在Linux系统中安装Python

3.2.1. 在Ubuntu中安装Python

3.3. 如何在Mac中安装Python

4. 选择合适的Python开发环境

4.1. 如何在Windows环境下开发Python

4.1.1. Python的最原始的开发方式是什么样的

4.1.1.1. 找个文本编辑器，新建个.py文件，写上Python代码

4.1.1.2. 打开Windows的cmd，并且切换到对应的python脚本所在目录

4.1.1.2.1. 方法1：手动打开cmd，并cd到对应路径

4.1.1.2.2. 方法2：通过Notepad++的Open current dir cmd

4.1.1.3. 在cmd中去运行你的Python脚本（.py文件）

4.1.2. 利用Python的shell进行交互式开发又是什么样的

4.1.2.1. 命令行版本的Python Shell – Python (command line)

4.1.2.2. 带图形界面的Python Shell – IDLE (Python GUI)

4.1.2.3. 关于（command line或GUI版本的）Python Shell的用途

4.1.3. 利用第三方Python的IDE进行Python开发又是怎么回事

4.1.3.1. 为何会有Python的IDE

4.1.3.2. 目前常见的一些Python的IDE

4.1.3.3. Python的IDE和Python代码编辑器，Windows的cmd，等的关系

4.1.3.4. 使用IDE时所遇到的一些常见的问题

4.1.3.4.1. IDE只能够打开了文件，并不代表就已经在shell中运行了该文件

4.1.3.4.2. 需要注意，确保有可以运行的Python起始部分的代码

4.1.4. 总结：到底使用哪种环境去开发Python

4.1.4.1. 对初学者的建议：如何选用Python的开发环境

4.1.5. 如何在Windows环境下使用Python脚本

4.1.5.1. 如何在Windows下的cmd中运行BlogsToWordpress.py

4.2. 如何在Linux环境下开发Python

4.3. 如何在Mac环境下开发Python

5. Python的基本语法和基础知识

5.1. 一张图片入门Python

5.2. Python中的2.x版本和3.x版本

5.3. Python文件编码声明

5.4. Python中的缩进

5.5. Python中基本变量的声明和定义

5.5.1. Python中变量的作用域

5.5.2. Python中变量与C语言中的变量对比

5.6. Python中的分支结构

5.7. Python中的函数

5.8. Python中的面向对象编程

6. 继续学习Python的思路和方法

6.1. 如何继续深入学习Python

6.2. 如何利用Python相关资源

6.2.1. 如何利用Python自带的手册

6.2.2. 如何利用一些在线的Python资源

7. Python常见问题及解答

常见问题

7.1. 在window的cmd中运行python结果却调用了文本编辑器去打开了，而不是去调用Python解析器去运行python文件

8. Python相关资源

参考书目

插图清单

4.1. 在Windows下的cmd下面运行Python脚本的样子

4.2. 开始菜单中找到的Python (Command Line)

4.3. Python (Command Line)的界面

4.4. 动画演示如何在Windows的cmd中运行Python脚本BlogsToWordpress.py

4.5. 在Mac下的Terminal中运行Python脚本：BlogsToWordpress

5.1. Quick Python Script Explanation

5.2. 一张图入门Python中文版

7.1. 安装Python时选择Register Extensions

范例清单

4.1. 举例：用Python的IDLE去做URL解码

公式清单

4.1. 什么是IDE

4.2. 什么是Python的IDE

python 形参没有被定义？？？感觉遇到鬼了。。。

一、前言

在python中，函数参数的定义和传递有以下几种方式：

语法

意义  

def func(name)

普通参数，可以根据位置匹配，也可以根据key来匹配  

def func(name=value)

默认参数，当参数没有传递时，使用默认值

def func(*iteratable)

将所有剩下的未匹配的参数收集至一个tuple中

def func(**dictionary)

将剩下未匹配的参数收集值一个dict中

def func(*, name)

必须使用key来匹配参数

def func(*other, name)

必须使用key来匹配参数

func(value)

函数调用，参数值按传递的参数顺序匹配  

func(name=value)

函数调用，参数值根据key来匹配  

func(*iteratable)

函数调用，将iteratable容器中的参数展开，按位置匹配对应的函数参数  

func(**dictionary)

函数调用，将dict中的参数展开，按key值来匹配对应的函数参数  

在python中，参数可以按照顺序传递，在调用函数时，参数的值按照传递的顺序，从左到右依次匹配。并且还可以给参数传递默认值，这都很好理解，因为在C、C++、Java等许多语言中，函数的参数传递都是按照这种方法来传递的。

但python的参数定义和传递除了按照顺序传递以及可以给默认值外，它还有其它的一些特点，在进一步讲解之前，首先说明python中函数调用中参数匹配的顺序：

按照顺序，给没有key的参数赋值，意味着传递参数时，需按顺序匹配的参数必须出现在按key匹配的参数之前；

给按照key匹配的参数赋值；

将多余的按照顺序匹配但未匹配的参数值归入*name的tuple中；

将多余未匹配上的按照key进行匹配的参数值归入**name的dict对象中；

将为匹配上的且具有默认值的参数赋默认值

二、按key匹配参数

对于C、C++这种语言，在调用函数时，系统会首先将函数地址压入堆栈，其次按参数的从右往左的顺序，一次压入堆栈。因此，C、C++这种语言它们只支持按顺序匹配形参。而python的做法不同，参数除了可以按顺序匹配，还可以按照参数名称来匹配。如：

def func(name, age):

print(name, age)

对于这个函数，以下的调用时等价的：

func('rechar', 27)    #按顺序匹配

func(name = 'rechar', age = 27)    #按参数名称匹配，在运行时告诉系统参数name的值为‘rechar’，age的值为27

func(age = 27, name = 'rechar')    #按参数名称匹配

func('rechar', age = 27)    #name是按顺序匹配，age按名称匹配

在python中，当按照参数名称进行匹配参数是，参数传递的顺序是可以任意的，不要求按照函数定义中参数的顺序进行传递。在使用名称匹配时，如果需要混合使用按顺序匹配规则，则按顺序匹配的参数必须出现在按key匹配的参数前，否则会报错：

func(name = 'rechar', 27)

以上调用会报如下错误：

三、函数定义中的”*name“

python在给按顺序匹配和按key匹配的参数赋完值后，如果发现调用者传入的参数仍有未匹配上的会发生什么情况呢？看一下下面的例子：

func('rechar', 27, 32)

运行时我们看到如下错误：

Traceback (most recent call last):

File "E:\tmp\tt.py", line 5, in module

func('rechar', 27, 32)

TypeError: func() takes 2 positional arguments but 3 were given

哦，python会抱怨我们传递的参数太多了。那如果确实在一些情况下，我们无法保证传递的参数数量一定和函数需要的参数数相等怎么办呢？这是就是*iterable这种参数该登场的时候了，假如在定义函数定义是，我们增加了一个参数，这个参数以一个”*“开始，那么这个参数实际上是一个tuple类型。假如传递的参数比需要的多，那那些多余的参数会被放入这个tuple中。例如，

def func(name, age, *other):

print(name, age, other)

那么,

func('rechar', 27, 32)

这个调用的输出如下：

rechar 27 (32,)

四、函数定义中的”**name“

python在将所有未匹配上的非按名称匹配的参数装入参数中的tuple之后，假如还有未匹配上的按名称匹配的参数那情况会怎样呢？首先来看一下下面的示例：

def func(name, age):

print(name, age)

func(name = 'rechar', age = 27, pay='1800')

执行时，python又抱怨了：

Traceback (most recent call last):

File "E:\tmp\tt.py", line 5, in module

func(name = 'rechar', age = 27, pay='1800')

TypeError: func() got an unexpected keyword argument 'pay'

它说func这个函数没有名称为”pay“的参数，这种情况或许出现在我们函数重构之后，原来函数时有这个参数的。而这个函数调用可能在别处没有被修改。假设即使给了”pay“这个参数，程序的正确性不受影响，没错，这就是”**name“参数的用武之地了。

假如在函数定义中，给函数增加一个以”**“开头的参数，那么这个参数实际上是一个dict对象，它会将参数调用中所有没有被匹配的按名称传递的参数都放入这个dict中。例如，

def func(name, age,**other):

print(name, age, other)

func(name = 'rechar', age = 27, pay='1800')

那么运行结果输出，

rechar 27 {'pay': '1800'}

看到了吧，这里的other就将没有匹配的”pay=‘1800’“收入囊中了。

五、规定调用必须按名称匹配

当我们在定义函数时，如果第一个参数就是”*name“参数，那么可想而知，我们无法使用按顺序匹配的方式传递，因为所有的按顺序传递的参数值最终的归宿都会是这里的tuple当中。而为了给后续的参数传递值，我们只能使用按名称匹配的方法。

六、”**“参数只能出现在最后一个形参之后

想想为什么?其实很好理解，因为出现在”**“形参之后的形参，无论使用按顺序传递还是按名称传递，最终都无法到达参数值真正应该需要到的地方。所以python规定，如果需要”**“参数，那它必须是最后一个形参。否则python会报语法错误。

七、函数调用中的”*“

在表格中我们看到了有func(*iteratable)的调用，这个调用的意思是，iteratable必须是一个可迭代的容器，比如list、tuple；作为参数传递值，它最终传递到函数时，不是以一个整体出现，而是将其中的元素按照顺序传递的方式，一次赋值给函数的形参。例如，

li = ['rechar', 27]

func(*li)

这个函数调用与

func('rechar', 27)

是等价的。

八、函数调用中的”**“

知道”*“在函数调用中的效果之后，也就很好理解”**“的作用了。它是将传递进来的dict对象分解，每一个元素对应一个按名称传递的参数，根据其中的key对参数进行赋值。

Flask前言 - Python WSGI

WSGI（Web Server Gateway Interface） 的任务就是把上面的数据在 http server 和 python 程序之间简单友好地传递。它是一个标准，被定义在 PEP 333 。需要 http server 和 python 程序都要遵守一定的规范，实现这个标准的约定内容，才能正常工作。

application端定义非常简单，它只要求开发者实现一个函数来响应HTTP请求。

这个函数就是一个符合WSGI标准的一个HTTP处理函数，它接收两个参数：

envrion 和 start_response 这两个参数由服务端提供，PEP333里给出了一个wsgi server的简单实现：

或者，python中也内置了一个WSGI服务器模块 wsgiref ， 通过这个模块就可以快速实现了个WSGI Server来测试我们的 application :

可以看到结果为 wsgi_client.py 中定义的 hello world

Flask框架中的一个核心库 werkzeug 其实就是Python的WSGI规范的实用函数库

【Python】浅谈python中的json

一 前言  

   最近一直在做开发相关的工作--基于Django的web 平台，其中需要从model层传输数据到view 层做数据展示或者做业务逻辑处理。我们采用通用的Json格式--Json(JavaScript Object Notation) 是一种轻量级的数据交换格式，易于阅读和程序解析。

二 认识Json

   2.1 Json 结构

   常见的Json格式为 “名称/值”对的集合,其中 值可以是对象，列表，字典，字符串等等。比如

backup_data = {"back_to_host": "dbbk0",

"ip_address": "10.10.20.3",

"host_name": "rac4",

"port": 3306}

  2.2 使用Json

  Python的Json模块序列化与反序列化的过程分别是 编码和解码。这两个过程涉及到两组不同的函数

  编码 把一个Python对象编码转换成Json字符串，json.dumps(data)/json.dump(data,file_handler)

  解码 把Json格式字符串解码转换成Python对象，json.loads(data)/json.load(file_handler)

  在python中要使用Json模块做相关操作，必须先导入:

import Json

  2.3 主要函数

  编码函数主要有 json.dumps(data)/json.dump(data,file_handler)

   json.dumps()的参数是将python对象转换为字符串，如使用json.dumps序列化的对象json_dumps=json.dumps({'a':1, 'b':2}) ，json_dumps='{"b": 2, "a": 1}'

   json.dump 是将内置类型序列化为json对象后写入文件。

 解码函数主要由json.loads(data)/json.load(file_handler)  

    json.loads的参数是内存对象，把Json格式字符串解码转换成Python对象,json_loads=json.loads(d_json)  #{ b": 2, "a": 1}，使用load重新反序列化为dict

    json.load()的参数针对文件句柄，比如本地有一个文件/tmp/test.json  json_load=json.load(open('/tmp/test.json'))

具体案例参考如下:

In [3]: data={"back_to_host": "rac1",

...: "ip_address": "10.215.20.3",

...: "host_name": "rac3",

...: "port": 3306}

In [7]: json_str=json.dumps(data)

In [8]: print json_str

{"ip_address": "10.215.20.3", "back_to_host": "rac1", "host_name": "rac3", "port": 3306}

In [9]: json_loads=json.load(json_str)

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

AttributeError Traceback (most recent call last)

ipython-input-9-180506f16431 in module()

---- 1 json_loads=json.load(json_str)

/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/json/__init__.pyc in load(fp, encoding, cls, object_hook, parse_float, parse_int, parse_constant, object_pairs_hook, **kw)

284

285 ""

注意 从上面的报错信息来看 json.loads 传参是字符串类型，并不是文件句柄，没有 read()属性。

In [10]: json_loads=json.loads(json_str)

In [11]: print json_loads

{u'back_to_host': u'rac1', u'ip_address': u'10.215.20.3', u'host_name': u'rac3', u'port': 3306}

In [12]: type(json_loads)

Out[12]: dict

In [13]: type(json_str)

Out[13]: str

利用dump 将数据写入 dump.json

In [17]: with open('/tmp/dump.json','w') as f:

...: json.dump(json_str,f)

...:

yangyiDBA:~ yangyi$ cat /tmp/dump.json

"{\"ip_address\": \"10.10.20.3\", \"back_to_host\": \"rac1\", \"host_name\": \"rac3\", \"port\": 3306}"

yangyiDBA:~ yangyi$

利用json.load 将dump.sjon的数据读出来并赋值给 data 

In [18]: with open('/tmp/dump.json','r') as f:

...: data=json.load(f)

...:

In [19]: print data

{"ip_address": "10.10.20.3", "back_to_host": "rac1", "host_name": "rac3", "port": 3306}

三 小结

  本文算是一篇学习笔记，主要对比了json.loads/json.load  , json.dumps/ json.dump 的使用差异 ，方便以后更好的使用json 。

以上为本次分享内容，感谢观看。