随笔- 644&
&镇场诗：　　　　清心感悟智慧语，不着世间名与利。学水处下纳百川，舍尽贡高我慢意。　　　　学有小成返哺根，愿铸一良心博客。诚心于此写经验，愿见文者得启发。——————————————————————————————————————————code:
member=['文殊','普贤','观音','弥勒','舍名利']
print(member)
#索引值1 到 3-1的内容
newMember=member[1:3]
print(newMember)
#索引值 0到 3-1的内容
newMember=member[:3]
print(newMember)
#索引值1 及其以后的所有元素
newMember=member[1:]
print(newMember)
#创建列表的的副本
copyMember=member[:]
print(copyMember)
#原列表未改变
print(member)
============= RESTART: C:/Users/Administrator/Desktop/mytest2.py =============
['文殊', '普贤', '观音', '弥勒', '舍名利']
['普贤', '观音']
['文殊', '普贤', '观音']
['普贤', '观音', '弥勒', '舍名利']
['文殊', '普贤', '观音', '弥勒', '舍名利']
['文殊', '普贤', '观音', '弥勒', '舍名利']
创建列表的副本及注意事项
member=['文殊','普贤','观音','弥勒','舍名利']
print(member)
#创建列表的的副本
copyMember=member[:]
print(copyMember)
#调换列表的前两个元素
temp=copyMember[0]
copyMember[0]=copyMember[1]
copyMember[1]=temp
print(copyMember)
#原列表未改变
print(member)
#不用[:]，只是用简单的= ，那么会。。。
members=['北斗阳明贪狼星君','北斗阴精巨门星君','北斗真人禄存星君','北斗玄冥文曲星君','北斗丹元廉贞星君','北斗北极武曲星君','北斗天关破军星君']
newMember=members
print(members)
temp=newMember[0]
newMember[0]=newMember[1]
newMember[1]=temp
#你会发现一改全改，所以要是想给列表创建副本的话，需要用到 【：】
print(members)
print(newMember)
============= RESTART: C:/Users/Administrator/Desktop/mytest2.py =============
['文殊', '普贤', '观音', '弥勒', '舍名利']
['文殊', '普贤', '观音', '弥勒', '舍名利']
['普贤', '文殊', '观音', '弥勒', '舍名利']
['文殊', '普贤', '观音', '弥勒', '舍名利']
['北斗阳明贪狼星君', '北斗阴精巨门星君', '北斗真人禄存星君', '北斗玄冥文曲星君', '北斗丹元廉贞星君', '北斗北极武曲星君', '北斗天关破军星君']
['北斗阴精巨门星君', '北斗阳明贪狼星君', '北斗真人禄存星君', '北斗玄冥文曲星君', '北斗丹元廉贞星君', '北斗北极武曲星君', '北斗天关破军星君']
['北斗阴精巨门星君', '北斗阳明贪狼星君', '北斗真人禄存星君', '北斗玄冥文曲星君', '北斗丹元廉贞星君', '北斗北极武曲星君', '北斗天关破军星君']
注：我没看过什么书，只看过儒释道的书籍，所以举的例子不是普通的例子，但是效果都是一样的，还望能看得过去。
——————————————————————————————————————————博文的精髓，在技术部分，更在镇场一诗。Python版本3.5,系统 Windows7。Python是优秀的语言，值得努力学习。我是跟着小甲鱼视频教程学习的，推荐。我是一个新手，所以如果博文的内容有可以改进的地方，甚至有错误的地方，请留下评论，我一定努力改正，争取成就一个良心博客。注：此文仅作为科研学习，如果我无意中侵犯了您的权益，请务必及时告知，我会做出改正。
阅读(...) 评论()Python学习之函数详解
时间： 23:06:22
&&&& 阅读：239
&&&& 评论：
&&&& 收藏：0
函数是对程序逻辑进行结构化或过程化的一种编程方法。能将整块代码巧妙地隔离成易于管理的小块，这样在以后的中十分重要，可以使你的程序更加简洁，有逻辑，可读性强。
.函数的调用
Python内置了很多有用的函数，我们可以直接调用。要调用一个函数，需要知道函数的名称和参数，比如求绝对值的函数abs，只有一个参数。可以在交互式环境中用help()查看关于调用函数的相关信息
&&& abs(100)100
Help&&built-in&&&&&__:
Return the absolute value of the&.
Python中已经有很多非常实用的函数，如果应用的好，可以大大提高效率。
那么现在一定有小伙伴要问，我们能不能定义自己想要的函数？当然可以。
在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
我们以自定义一个求绝对值的myabs函数为例：
大家可以自己试验一下代码。请注意：
1.Python的缩进规则。
2.函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。
&有两种形式：&1&返回一个值。&2&返回多个值。
现看看&&的：
&&&&(a,b):
&c&&&&&firstvalue(1,2)3
再看看&&的：
&&&&(a,b):
&(a,b,c)&&& x,y,z = secondvalue(1,2)&&&&&’x=’,x,’y=’,y,’z=’,z
x= 1 y= 2 z= 3
.函数的参数
Python的函数定义非常简单，但灵活度却非常大。除了正常定义的必选参数外，还可以使用默认参数、可变参数和关键字参数，使得函数定义出来的接口，不但能处理复杂的参数，还可以简化调用者的代码。
我们来举一个例子。比如现在我们想要计算x的立方。接着上一节的内容，我们使用多参数函数：
&&&&(x, n):
&s&&& power(5, 2)25&&& power(5, 3)125
这个函数可以计算任意数的n次方。但是请读者试一试输入power（5）你会发现报错，这是因为你只输入了一个参数。
但是如果我们经常使用的只是计算x的立方，为了简化输入，我们可以这样：
&&&&(x, n=3):
这样，当我们调用power(5)时，相当于调用power(5, 2)：
从上面的例子可以看出，默认参数可以简化函数的调用。设置默认参数时，有几点要注意：
一&是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；
&是如何设置默认参数。当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。
&&&&&(a,b=7,c=10):...&&a,b,c
...&&& func(2)2 7 10&&& func(2,b=5)2 5 10&&& func(2,c=6)2 7 6
其中默认参数有一些坑，提示：（默认参数一定要用不可变对象，如果是可变对象，运行会有逻辑错误！比如不能把默认参数定义为可变的list）虽然有办法解决但还是尽量避免。
在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
比如我们计算a平方&+ b平方&+ c平方&+ ……。
&(numbers):
&n&&numbers:
sum = sum + n * n
这是想要计算需要把numbers定义成一个list或tuple，才能使用for in循环把list中的数字调用出来用于计算。
&&& calc([1, 2, 3])14&&& calc((1, 3, 5, 7))84
为了简化这一步，我们使用可变参数。定义可变参数和定义list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：
&(*numbers):
&n&&numbers:
sum = sum + n * n
这是只需要输入calc（1,2,3）即可。
如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做：
&&& nums = [1, 2, 3]&&& calc(nums[0], nums[1], nums[2])14
这种写法当然是可行的，问题是太繁琐，所以Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：
&&& nums = [1, 2, 3]&&& calc(*nums)14
这种写法相当有用，而且很常见。可见*可以把元素变为可变参数从而可以更灵活的使用。
还有其他的参数如&&，和有这几种参数一起使用而得到的&&。这些就不详细介绍了。（感觉没咋用啊）
比如我们给个组合参数的例子，我们使用默认参数和可变参数：
&(a, b, c=0, *args):
&’a =’, a, ’b =’, b, ’c =’, c, ’args =’, args&&& func(1, 2)
a = 1 b = 2 c = 0 args = ()&&& func(1, 2, c=3)
a = 1 b = 2 c = 3 args = ()&&& func(1,2,3,’a’,’b’)
a = 1 b = 2 c = 3 args = (’a’, ’b’)
.几种高阶函数的使用
这一部分可能内容比较复杂，所以我们重点讲解几个用以处理list的高阶函数，来体会Python中函数的意义。Python是一门非常强大的语言，其中有很多功能就7体现在对函数的抽象应用之中。其中变量可以指向函数，函数的参数能接收变量，比如：
&&& a=f&&& a(2)3
那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。
一个最简单的高阶函数：
&(x, y, f):
&f(x) + f(y)
&&& add(-2,-9,abs)
#令a=-2,b=-9,f=abs 11
现在我们可以看出Python中函数是十分抽象的。接下来介绍几种常用的高阶函数。
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。所以map是处理序列的有力工具之一。
来个例子：
&&&&&(x):...&&x+100... &&& a = [11,22,33]&&& map(add,a)
[111, 122, 133]
即实现了让一个list中所有元素都加上100的操作，同理可以定义别的函数或者使用Python的自带函数导入map中，完成对list中元素的处理。例如：
&&& map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])
[’1’, ’2’, ’3’, ’4’, ’5’, ’6’, ’7’, ’8’, ’9’]
map是将函数应用于list中的每个元素，从而得到一个新的list，而reduce则是将list中的元素利用函数累计运算类似于复合函数。
reduce(, [x1, x2, x3, x4]) = f(((, x2), x3), x4)
我们来举一个例子，比如我们自己定义一个求和函数。
&&&&&(x, y):...&&x + y
...&&& reduce(add, [1,2,3])6
通过使用reduce我们可以使单个函数的功能大大加强。
比如一个二进制转十进制转换器（顺便复习一下）：
a.append(int(i)) #上面的程序把数字字符串转化为整数的list
&(x,y): #在这个地方我们可以再定义一个函数
&reduce(g,a) &&& f(’536’)32
（自己编的程序比较简陋。。）大家可以看到reduce的应用。并发现Python函数定义的灵活性。
Python内建的filter()函数用于过滤序列。
和map()类似，filter()也接收一个函数和一个序列。和map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
例如，在一个list中，删掉偶数，只保留奇数，可以这么写：
&n % 2 == 1
filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])#&结果: [1, 5, 9, 15]
思考题：请尝试用filter()删除1~100的素数。（以后会有更好的方法）
排序也是在程序中经常用到的算法。排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较，但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。通常规定，对于两个元素x和y，如果认为x & y，则返回-1，如果认为x == y，则返回0，如果认为x & y，则返回1，这样，排序算法就不用关心具体的比较过程，而是根据比较结果直接排序。
&&&&([36, 5, 12, 9, 21])[5, 9, 12, 21, 36]
同样的sorted()也是一个高阶函数。我们可以通过上述排序原理利用自己定义的函数来对一个序列进行排序。比如倒序：
我们利用这个函数相当于改变了排序的规则（负负得正啊，是不是）
传入自定义的比较函数daoxu，就可以实现倒序排序：
&&&&([36, 5, 12, 9, 21], daoxu)[36, 21, 12, 9, 5]
默认情况下，对字符串排序，是按照ASCII的大小比较的，由于’Z’ & ’a’，结果，大写字母Z会排在小写字母a的前面。现在，我们提出排序应该忽略大小写，按照字母序排序。要实现这个算法，不必对现有代码大加改动，只要我们能定义出忽略大小写的比较算法就可以：
这是我们的想法就是定义一个函数先把一个list中的字符串全变成小写，然后再比较顺序，这样就可以忽略大小写的影响了。
&(s1, s2):
u1 = s1.upper()
u2 = s2.upper()
现在把这个函数扔到sorted（）中来实现我们想要的排序
&&& sorted([’bob’, ’about’, ’Zoo’, ’Credit’], ignore)
[’about’, ’bob’, ’Credit’, ’Zoo’]
好了以上我们就介绍了四种高阶函数。从上述例子可以看出，高阶函数的抽象能力是非常强大的，而且，核心代码可以保持得非常简洁。
这篇文章讲述的主要是对list进行处理的函数。函数的应用需要经常的练习，并在练习中发现问题，（比如缩进，return的位置都会影响最终结果），有时更需要扎实的数学功底比如上文中素数的提取方法（更好的算法更高效）。
文章来源：China’s Prices Project
加入时间：
&&关注此人&&发短消息
“jiangjie190”关注的人------（）
“jiangjie190”的粉丝们------（）
&&国之画&&&& &&&&chrome插件&&
版权所有 京ICP备号-2
迷上了代码！语言最常见的括号有三种，分别是：小括号( )、中括号[ ]和大括号也叫做花括号{ }。其作用也各不相同，分别用来代表不同的。
python中的小括号( )：代表tuple元组数据类型，元组是一种不可变序列。创建方法很简单，大多时候都是用小括号括起来的。
&&& tup = (1,2,3)
&&& ()#空元组
&&& 55,#一个值的元组
&Python 元组遍历排序操作方法有对元组操作的更详细讲解。
2、python中的中括号[ ]：代表list列表数据类型，列表是一种可变的序列。其创建方法即简单又特别，像下面一样：
&&& list('python')
['p', 'y', 't', 'h', 'o', 'n']
3、python大括号{ }花括号：代表dict字典数据类型，字典是由键对值组组成。冒号':'分开键和值，逗号','隔开组。用大括号创建的方法如下：
&&& dic={'jon':'boy','lili':'girl'}
{'lili': 'girl', 'jon': 'boy'}
阅读(...) 评论()1.函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个&别名&：
&&& a = abs # 变量a指向abs函数
&&& a(-1) # 所以也可以通过a调用abs函数1
可以将任意函数名字改名。
2.定义一个函数要使用def语句，同时要有冒号，函数体放在缩进里面。
3.如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。
　　return None可以简写为return。
4.定义一个什么事也不做的空函数，可以用pass语句。还没想好怎么写函数的代码，就可以先用pass代替，让代码先运行起来。
5.Python的函数返回多值其实就是返回一个tuple。
6.默认参数：由于我们经常计算x2，所以，完全可以把第二个参数n的默认值设定为2：
def power(x, n=2):
while n & 0:
这样，当我们调用power(5)时，相当于调用power(5, 2)：
7.当不按顺序提供部分默认参数时，需要把参数名写上。
8.定义默认参数要牢记一点：默认参数必须指向不变对象！
9.把函数的参数改为可变参数：
def calc(*numbers):
for n in numbers:
sum = sum + n * n
return sum
定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。
10.Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去
11.尾递归优化，尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
return fact_iter(num - 1, num * product)#即返回函数本身
阅读(...) 评论()python中的冒号怎么用?_百度知道
python中的冒号怎么用?
我有更好的答案
函数，循环，if条件，类定义等后面有block，block要缩进，因此这些语句后面要加上冒号，这是python的语法python的冒号和java、c中的{}是一样的block是一组语句
采纳率：82%
来自团队：
至于为什么这样子，我们又不是研究理论的，循环，条件， block需要缩进，所以这些语句后面都有一个冒号。每个语言里几乎都有有。就是一组语句，循环体，条件分支，类的定义等等都是一个block的概念。死记硬背就可以了。什么是一个block，类定义等后面都是跟着一个block函数。比如函数体
本回答被提问者采纳
每一个block之前必须有冒号提示。就是说函数名后面必须要有冒号下一行才会有缩进啊。
就是说是一种对解释器的提示么？有了：下一行才会自动缩进么？怎么样才算一个模块啊？
为您推荐：
其他类似问题
您可能关注的内容
python的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。}