温馨提示！由于新浪微博认证机制调整，您的新浪微博帐号绑定已过期，请重新绑定！&&|&&
LOFTER精选
网易考拉推荐
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
本文转载自:&总结:变量:1. &前带_的变量: &标明是一个私有变量, 只用于标明,&外部类还是可以访问到这个变量2. &前带两个_ ,后带两个_ 的变量: &标明是内置变量,3. &大写加下划线的变量: &标明是&不会发生改变的全局变量函数:1. 前带_的变量: 标明是一个私有函数, 只用于标明,2.&&前带两个_ ,后带两个_ 的函数: &标明是特殊函数Python 的代码风格由 PEP 8 描述。这个文档描述了 Python 编程风格的方方面面。在遵守这个文档的条件下，不同程序员编写的 Python 代码可以保持最大程度的相似风格。这样就易于阅读，易于在程序员之间交流。1 变量常量&: 大写加下划线USER_CONSTANT对于不会发生改变的全局变量，使用大写加下划线。私有变量&: 小写和一个前导下划线_private_valuePython 中不存在私有变量一说，若是遇到需要保护的变量，使用小写和一个前导下划线。但这只是程序员之间的一个约定，用于警告说明这是一个私有变量，外部类不要去访问它。但实际上，外部类还是可以访问到这个变量。内置变量&: 小写，两个前导下划线和两个后置下划线__class__两个前导下划线会导致变量在解释期间被更名。这是为了避免内置变量和其他变量产生冲突。用户定义的变量要严格避免这种风格。以免导致混乱。2&函数和方法总体而言应该使用，小写和下划线。但有些比较老的库使用的是混合大小写，即首单词小写，之后每个单词第一个字母大写，其余小写。但现在，小写和下划线已成为规范。私有方法&： 小写和一个前导下划线def&_secrete(self):&&&&print&"don't&test&me."这里和私有变量一样，并不是真正的私有访问权限。同时也应该注意一般函数不要使用两个前导下划线(当遇到两个前导下划线时，Python 的名称改编特性将发挥作用)。特殊函数后面会提及。特殊方法&： 小写和两个前导下划线，两个后置下划线def&__add__(self,&other):&&&&return&int.__add__(other)这种风格只应用于特殊函数，比如操作符重载等。函数参数&: 小写和下划线，缺省值等号两边无空格def&connect(self,&user=None):&&&&self._user&=&user3 类类总是使用驼峰格式命名，即所有单词首字母大写其余字母小写。类名应该简明，精确，并足以从中理解类所完成的工作。常见的一个方法是使用表示其类型或者特性的后缀，例如:SQLEngineMimeTypes对于基类而言，可以使用一个 Base 或者 Abstract 前缀BaseCookieAbstractGroupclass&UserProfile(object):&&&&def&__init__(self,&profile):&&&&&&&&return&self._profile&=&profile&&&&def&profile(self):&&&&&&&&return&self._profile4 模块和包除特殊模块 __init__ 之外，模块名称都使用不带下划线的小写字母。若是它们实现一个协议，那么通常使用lib为后缀，例如:import smtplibimport&osimport&sys5&关于参数5.1 不要用断言来实现静态类型检测断言可以用于检查参数，但不应仅仅是进行静态类型检测。 Python 是动态类型语言，静态类型检测违背了其设计思想。断言应该用于避免函数不被毫无意义的调用。5.2 不要滥用 *args 和 **kwargs*args 和 **kwargs 参数可能会破坏函数的健壮性。它们使签名变得模糊，而且代码常常开始在不应该的地方构建小的参数解析器。6 其他6.1 使用 has 或 is 前缀命名布尔元素is_connect&=&Truehas_member&=&False6.2 用复数形式命名序列members&=&['user_1',&'user_2']6.3 用显式名称命名字典person_address&=&{'user_1':'10&road&WD',&'user_2'&:&'20&street&huafu'}6.4 避免通用名称诸如 list, dict, sequence 或者 element 这样的名称应该避免。6.5 避免现有名称诸如 os, sys 这种系统已经存在的名称应该避免。7 一些数字一行列数 : PEP 8 规定为&79 列，这有些苛刻了。根据自己的情况，比如不要超过满屏时编辑器的显示列数。这样就可以在不动水平游标的情况下，方便的查看代码。一个函数 : 不要超过&30 行代码, 即可显示在一个屏幕类，可以不使用垂直游标即可看到整个函数。一个类 : 不要超过&200 行代码，不要有超过&10 个方法。一个模块 不要超过&500 行。8 验证脚本可以安装一个 pep8 脚本用于验证你的代码风格是否符合 PEP8。&&easy_install pep8&&pep8 -r --ignoire E501 Test.py这个命令行的意思是，重复打出错误，并且忽略 501 错误(代码超过 79 行)。
阅读(9515)|
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
历史上的今天
loftPermalink:'',
id:'fks_',
blogTitle:'关于python中带下划线的变量和函数 的意义',
blogAbstract:'本文转载自:&'
{list a as x}
{if x.moveFrom=='wap'}
{elseif x.moveFrom=='iphone'}
{elseif x.moveFrom=='android'}
{elseif x.moveFrom=='mobile'}
${a.selfIntro|escape}{if great260}${suplement}{/if}
{list a as x}
推荐过这篇日志的人：
{list a as x}
{if !!b&&b.length>0}
他们还推荐了：
{list b as y}
转载记录：
{list d as x}
{list a as x}
{list a as x}
{list a as x}
{list a as x}
{if x_index>4}{break}{/if}
${fn2(x.publishTime,'yyyy-MM-dd HH:mm:ss')}
{list a as x}
{if !!(blogDetail.preBlogPermalink)}
{if !!(blogDetail.nextBlogPermalink)}
{list a as x}
{if defined('newslist')&&newslist.length>0}
{list newslist as x}
{if x_index>7}{break}{/if}
{list a as x}
{var first_option =}
{list x.voteDetailList as voteToOption}
{if voteToOption==1}
{if first_option==false},{/if}&&“${b[voteToOption_index]}”&&
{if (x.role!="-1") },“我是${c[x.role]}”&&{/if}
&&&&&&&&${fn1(x.voteTime)}
{if x.userName==''}{/if}
网易公司版权所有&&
{list x.l as y}
{if defined('wl')}
{list wl as x}{/list}Python函数的参数列表中嵌套格式『[ [, [, ]]]』该如何理解，和一般的位置参数表示的区别有哪些？ - 知乎10被浏览903分享邀请回答def foo(a=None,b=None):
foo(b=123) # 输出 None 123
但是切莫以为这个违背了位置参数的性质。事实上，函数的默认值早已包含在函数对象中，在调用之前，Python就会自动将这些参数填入，然后对用户自定义了的参数进行"替换"。实际上是替我们完成了自动补全的功能，而不是“跳过”了某些参数。在此，group依然被定义。不过对于此类带有默认值的函数，[]表示法确实不规范。经过查找，题主的图片应该是来源于Python Essential Reference这本书，而官方的Process文档采用的和Thread类一样的格式。对于class的声明，Python官方文档的要求如下：Describes a class. The signature can include parentheses with parameters which will be shown as the constructor arguments所以对于class来说，其实如图中Thread类的表示方式才是最清楚直接的，截图中Process的表示方式是不标准的。嵌套式的表示法在文档中，多见于builtin里面的函数，并且这类函数至少有一个参数是不指定默认值的，下面也将以此类的function为例。================================其实这个是个相当有趣的问题，我之前都没怎么想过。根据Python官方文档的要求：The signature should include the parameters, enclosing optional parameters in brackets也就是说这个'[,]'代表着参数是可选的。但是为什么会会出现嵌套结构呢？思考过之后，我觉得这个和Python的函数参数的种类有关系，这种嵌套的表示方式暗含了函数参数的位置顺序和优先级：Python有三种不同种类的参数：1.位置参数2.变长参数(*args)3.键参数(**kwargs)其中位置参数比较特殊，顾名思义这类参数完全靠顺序来判定。以广受爱戴的open函数为例：open(name[, mode[, buffering]])
你可以声明f1 = open('file1.txt')
f2 = open('file2.txt','w')
f3 = open('file3.txt','rb',1024)
注意，在不使用“key=value”这种方式指定参数的情况下，你只能按照文档给定的顺序设置参数，而不可能打乱这个顺序，比如说设置了name和buffering却不去设置mode。原因就是因为，对于位置参数而言，传入参数的位置是标志这一参数的唯一依据。注意，mode和buffering是带有默认值的，所以上例中的f1才能如此声明。所以这种嵌套括号表示，无非是想申明一种顺序关系罢了，提醒读者参数位置不可被打乱。针对open这个函数，这种格式无非是想说说明：调用open函数，请依次传入name，mode，buffering。94 条评论分享收藏感谢收起1 个回答被折叠（）与世界分享知识、经验和见解Python函数参数类型*、**的区别
投稿：junjie
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了Python函数参数类型*、**的区别,本文用实例讲解它们的区别,并讲解了闭包的相关知识,需要的朋友可以参考下
刚开始学习python，python相对于java确实要简洁易用得多。内存回收类似hotspot的可达性分析， 不可变对象也如同java得Integer类型，with函数类似新版本C++的特性，总体来说理解起来比较轻松。只是函数部分参数的"*"与"**"，闭包等问题，着实令人迷糊了一把，弄清概念后写下此文记录下来,也希望本文能够帮助其他初学者。
所以本文是一篇学习笔记，着重于使用的细节和理解上，首先分别介绍了函数各种参数类型在调用和声明时的区别，及其在混用时需要注意的一些细节，之后讲了闭包相关的内容。如果有不对的地方欢迎指正。
函数参数不带“*”，"*" 与 "**"的区别
理解这个问题得关键在于要分开理解调用和声明语法中3者得区别.
函数调用区别
1. 不同类型的参数简述
#这里先说明python函数调用得语法为：
func(positional_args, keyword_args,
&*tuple_grp_nonkw_args, **dict_grp_kw_args)
&#为了方便说明,之后用以下函数进行举例
&def test(a,b,c,d,e):
& print a,b,c,d,e
举个例子来说明这4种调用方式得区别：
#-------------------------------
#positional_args方式
&&& test(1,2,3,4,5)
#这种调用方式的函数处理等价于
a,b,c,d,e = 1,2,3,4,5
print a,b,c,d,e
#-------------------------------
#keyword_args方式
&&& test(a=1,b=3,c=4,d=2,e=1)
#这种处理方式得函数处理等价于
print a,b,c,d,e
#-------------------------------
#*tuple_grp_nonkw_args方式
&&& x = 1,2,3,4,5
&&& test(*x)
#这种方式函数处理等价于
a,b,c,d,e = x
print a,b,c,d,e
#特别说明:x也可以为dict类型,x为dick类型时将键传递给函数
{'a': 1, 'c': 6, 'b': 2, 'e': 1, 'd': 1}
&&& test(*y)
#---------------------------------
#**dict_grp_kw_args方式
{'a': 1, 'c': 6, 'b': 2, 'e': 1, 'd': 1}
&&& test(**y)
#这种函数处理方式等价于
a = y['a']
b = y['b']
... #c,d,e不再赘述
print a,b,c,d,e
2. 不同类型参数混用需要注意的一些细节
　　接下来说明不同参数类型混用的情况,要理解不同参数混用得语法需要理解以下几方面内容.
　　首先要明白,函数调用使用参数类型必须严格按照顺序,不能随意调换顺序,否则会报错. 如 (a=1,2,3,4,5)会引发错误,; (*x,2,3)也会被当成非法.
　　其次,函数对不同方式处理的顺序也是按照上述的类型顺序.因为#keyword_args方式和**dict_grp_kw_args方式对参数一一指定,所以无所谓顺序.所以只需要考虑顺序赋值(positional_args)和列表赋值(*tuple_grp_nonkw_args)的顺序.因此,可以简单理解为只有#positional_args方式,#*tuple_grp_nonkw_args方式有逻辑先后顺序的.
　　最后,参数是不允许多次赋值的.
　　举个例子说明,顺序赋值(positional_args)和列表赋值(*tuple_grp_nonkw_args)的逻辑先后关系:
#只有在顺序赋值,列表赋值在结果上存在罗辑先后关系
#正确的例子1
&&& x = {3,4,5}
&&& test(1,2,*x)
#正确的例子2
&&& test(1,e=2,*x)
#错误的例子
&&& test(1,b=2,*x)
Traceback (most recent call last):
& File "&stdin&", line 1, in &module&
TypeError: test() got multiple values for keyword argument 'b'
#正确的例子1,处理等价于
a,b = 1,2 #顺序参数
c,d,e = x #列表参数
print a,b,c,d,e
#正确的例子2,处理等价于
a = 1 #顺序参数
e = 2 #关键字参数
b,c,d = x #列表参数
#错误的例子,处理等价于
a = 1 #顺序参数
b = 2 #关键字参数
b,c,d = x #列表参数
#这里由于b多次赋值导致异常,可见只有顺序参数和列表参数存在罗辑先后关系
函数声明区别
　　理解了函数调用中不同类型参数得区别之后,再来理解函数声明中不同参数得区别就简单很多了.
1. 函数声明中的参数类型说明
　　函数声明只有3种类型, arg, *arg , **arg 他们得作用和函数调用刚好相反. 调用时*tuple_grp_nonkw_args将列表转换为顺序参数,而声明中的*arg的作用是将顺序赋值(positional_args)转换为列表. 调用时**dict_grp_kw_args将字典转换为关键字参数,而声明中**arg则反过来将关键字参数(keyword_args)转换为字典.
特别提醒：*arg 和 **arg可以为空值.
以下举例说明上述规则:
#arg, *arg和**arg作用举例
def test2(a,*b,**c):
&print a,b,c
#---------------------------
#*arg 和 **arg可以不传递参数
&&& test2(1)
#arg必须传递参数
&&& test2()
Traceback (most recent call last):
& File "&stdin&", line 1, in &module&
TypeError: test2() takes at least 1 argument (0 given)
#----------------------------
#*arg将顺positional_args转换为列表
&&& test2(1,2,[1,2],{'a':1,'b':2})
1 (2, [1, 2], {'a': 1, 'b': 2}) {}
#该处理等价于
a = 1 #arg参数处理
b = 2,[1,2],{'a':1,'b':2} #*arg参数处理
c = dict() #**arg参数处理
print a,b,c
#-----------------------------
#**arg将keyword_args转换为字典
&&& test2(1,2,3,d={1:2,3:4}, c=12, b=1)
1 (2, 3) {'c': 12, 'b': 1, 'd': {1: 2, 3: 4}}
#该处理等价于
a = 1 #arg参数处理
b= 2,3 #*arg参数处理
#**arg参数处理
c = dict()
c['d'] = {1:2, 3:4}
c['c'] = 12
c['b'] = 1
print a,b,c
2. 处理顺序问题
　　函数总是先处理arg类型参数,再处理*arg和**arg类型的参数. 因为*arg和**arg针对的调用参数类型不同,所以不需要考虑他们得顺序.
def test2(a,*b,**c):
&print a,b,c
&&& test2(1, b=[1,2,3], c={1:2, 3:4},a=1)
Traceback (most recent call last):
& File "&stdin&", line 1, in &module&
TypeError: test2() got multiple values for keyword argument 'a'
#这里会报错得原因是,总是先处理arg类型得参数
#该函数调用等价于
#处理arg类型参数:
a = 1& #多次赋值,导致异常
#处理其他类型参数
print a,b,c
　　python的函数,原本只能访问两个区域的变量:全局,和局部(函数上下文). 实际上,函数本身也是一个对象,也有自己的作用域. 闭包通过函数与引用集合的组合,使得函数可以在它被定义的区域之外执行. 这个集合可以通过func_closure来获取这个引用集合. 这与python处理全局变量得方式一样,只不过全局变量将引用集合存储在__globals__字段中.func_closure是一个存储cell类型的元组,每个cell存储一个上下文变量.
　　另外,旧版本得python的内部函数不能在其他作用域使用的原因,并不是因为每个作用域的变量严格相互隔离,而是脱离原本的作用域后,函数失去了原本上下文的引用。需要注意的是，闭包存储的上下文信息一样是浅拷贝,所以传递给内部函数的可变对象仍然会被其他拥有该对象引用得变量修改.
&&& def foo(x,y):
...&&&& def bar():
...&&&&&&&&&&&& print x,y
...&&&& return bar
#查看func_closure的引用信息
&&& a = [1,2]
&&& b = foo(a,0)
&&& b.func_closure[0].cell_contents
&&& b.func_closure[1].cell_contents
#可变对象仍然能被修改
&&& a.append(3)
&&& b.func_closure[0].cell_contents
[1, 2, 3] 0
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具python 必包中有的函数有第一个参数self，而有的没有。
python 必包中有的函数有第一个参数self，而有的没有，请问有什么区别?例：
def _check_decoratable(origin, install=True):
if not hasattr(origin, '_decoratable_obj'):
if inspect.ismethod(origin) and not hasattr(origin, '_decoratable_obj'):
decoratable = DecoratableObject(origin)
def decoratable_method(self, *args, **kwargs):
return decoratable(self, *args, **kwargs)
decoratable_method._decoratable_obj = decoratable
def decoratable_decorate(fn, mode, **kwargs):
decoratable._decorate(fn, mode, **kwargs)
decoratable_method._decorate = decoratable_decorate
if install:
setattr(origin.im_class, origin.__name__, decoratable_method)
return decoratable_method
elif inspect.isfunction(origin):
decoratable = DecoratableObject(origin)
def decorated(*args, **kwargs):
return decoratable(*args, **kwargs)
decorated._decoratable_obj = decoratable
if install:
setattr(inspect.getmodule(origin), origin.__name__, decorated)
decorated.__name__ = origin.__name__
decorated.__module__ = origin.__module__
return decorated
return origin
def _decorate_result_with(fn, needs_params = False):
def decorator(origin):
origin = _check_decoratable(origin)
origin._decoratable_obj._decorate(fn, DecoratableObject.MODE_RESULT, needs_params=needs_params)
return origin
return decorator
类里的实例方法都要有self参数。类外定义的函数没有self参数
类里面的实例方法习惯给第一个参数起名 self，你喜欢的话也可以叫 this。
说到 this，这个和 C++ 一样的嘛，C++ 不也是隐式传入一个 const T* this 到实例方法的参数 0 上吗。
self和not_self本是一样的.....湿主，你起分别心了....
这个self只是个变量名而已，没有特殊含义
类似类静态函数和类成员函数吧
我记得如果是类的函数,需要加self代表自身,如果是单独的函数就没有必要,- -@ 书上有貌似python函数中可变参数*与**的区别 - 城里1988的博客 － 首页
在python函数(方法)参数中，经常看到在参数名称前面有一个＊或者两个＊＊的情况。例如：def&who(username,&*args1,&**args2)
&&&&#do&something这种带有＊号的参数，是可变参数，可以传任意个数的参数。*是以值的形式进行传参，函数内以tuple方式访问参数；**是以健值的形式进行传参，函数内以dict方式访问参数。代码栗子：#定义方法
def&who(username,&*args1,&**args2):
&&&&print&username
&&&&if&len(args1)&is&0:
&&&&&&&&print&&args1未传值&
&&&&&&&&for&args&in&args1:
&&&&&&&&&&&&print&&args1的参数：&,args
&&&&if&len(args2)&is&0:
&&&&&&&&print&&args2未传值&
&&&&&&&&for&key,value&in&args2.items():
&&&&&&&&&&&&print&&args2的参数：&,key,&=&,value
&&&&&&&&&&&&
who(&城里1988&)
#控制台输出:
#args1未传值
#args2未传值
who(&城里1988&,&&男&)
#控制台输出：
#args1的参数：&男
#args2未传值
who(&城里1988&,&&男&,&&中国&)
#控制台输出：
#args1的参数：&男
#args1的参数：&中国
#args2未传值
who(&城里1988&,&blog=&&)
#控制台输出：
#args1未传值
#args2的参数：&blog&=&
who(&城里1988&,&&男&,&&中国&,&blog=&&)
#控制台输出：
#args1的参数：&男
#args1的参数：&中国
#args2的参数：&blog&=&
who(&城里1988&,&&男&,&&中国&,&blog=&&,&address=&略&)
#控制台输出：
#args1的参数：&男
#args1的参数：&中国
#args2的参数：&blog&=&
#args2的参数：&address&=&略
本博客文章仅供参考，欢迎各位大神指教：！
& 2017 城里1988}