转自：http://blog.csdn.net/sfh366958228/article/details/43449527
一、基本语法
1、raw_input()取的内容永远以字符串的形式返回
2、“”和’'的一个区别是
“This’s a test!” √
’This’s a test!’ ×
'This\'s a test!' √
3、在if或者for后，如果需要接代码块，加上：，并且换行，代码每行开始都需要Tab缩进，或者以四个空格代替缩进
4、一个函数的定义如下：
def printHello():
print "Hello"
5、函数可以有多个返回值
def getNewPoint(x, y):
nx = x + 1
ny = y + 1
return nx, ny
x, y = getNewPoint(1, 2)
其实看似是直接允许有多个返回值，但实际上返回的是一个tuple，语法上返回一个tuple可以省略括号，多个变量可以同时接收一个tuple，按照位置付给对应的值。
6、如果有代码块暂时没有想好怎么写，如函数，或者if结果，可以用pass代替，以防报错，如：
def nop():
pass
7、由于变量并没有固定的数据类型，所以如果函数有需求固定参数类型需要指定，如：
def my_abs(x):
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x >= 0:
return x
else:
return -x
8、函数支持默认参数，但是必选参数需要在前面，默认参数在后面。并且默认参数必须是不变对象，如果是List，List内的值会记住上次调用的值。
def add_end(L=[]):
L.append('END')
return L ×
def add_end(L=None):
if L is None:
L = []
L.append('END')
return L √
9、可变参数，允许传入多个，甚至0个参数，接收的时候会自动转变为一个tuple。
def calc(*numbers):
sum = 0
for n in number:
sum = sum + n
return sum
如果已经有了list或者tuple，在调用的时候:
calc(nums[0], nums[1], nums[2]) √
calc(*nums)
10、关键字参数，与可变参数类似，但是接收的时候自动转为的是dict而不是tuple
def person(name, age, **kw):
print 'name:', name, 'age:', age, 'other:', kw >>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
类似于可变参数，如果已有一个dict，需要传参，可以在前面加**调用
11、定义函数的时候，如果需要一起使用四种参数，顺序必须是：
必选参数、默认参数、可变参数、关键字参数
def func(a, b, c=0, *args, **kw): print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw 在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。 >>> func(1, 2) a = 1 b = 2 c = 0 args = () kw = {} >>> func(1, 2, c=3) a = 1 b = 2 c = 3 args = () kw = {} >>> func(1, 2, 3, 'a', 'b') a = 1 b = 2 c = 3 args = ('a', 'b') kw = {} >>> func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
12、Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。
13、tuple和list一样，都是有序列表，但是tuple不可变，定义list用[]，定义tuple用()
二、高级特性
1、切片，快速取出list中指定范围数据（tuple也是一种list，字符串也可以看做一种list）
list[a:b:c] a是起始位置，b是结束位置（不包含），c可有可无，间隔数
三个参数都可以省略，a默认为0，b默认为len(list)，c默认为1
2、迭代
dict = {'one':1, ’two':2}
for key in dict:
pass
这样迭代出来的只有key，如果需要迭代key和value，那么：
for key, value in dict.iteritems():
pass
判断一个对象是否为可迭代对象：
from collections import Iterable >>> isinstance('abc', Iterable):
pass
如果要对list实现像java那样的下标循环，可以使用enumerate
for i,value in enumerate(['A', 'B', 'C']):
pass
3、列表生成式
快速生成1-10
list = range(1, 11)
L = []
for x in range(1, 11):
if x % 2 == 0:
L.append(x * x)
可以简写成L = [x * x for x in range(1 , 11) if x %2 == 0]
两层循环实现全排列：
L = [m + n for m in 'ABC' for n in 'XYZ']
可以在列表生成式中的for循环里调用两个变量：
dict = {'one':1, ’two':2}
L = [k + '=' + v for k, v in dict.iteritems()]
4、生成器generator，通过列表生成式，我们可以直接创建一个列表，但是由于内存限制，列表的容量肯定有限，如果我们仅仅需要几个元素，那用列表生成式就浪费了大量空间。
generator应运而生，使用的方法和列表生成式相比只是把[]改成()。一边循环一边计算，通过next方法可以获取其中元素。
g = (X * X for x in range(10))
g.next()#0
g.next()#1
g.next()#4
g.next()#9
...
比较繁琐，其实用for循环也可以实现
for n in g:
print n
如果推算的方法比较复杂，我们还可以通过函数来实现生成器
def fib(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
yield是定义generator的关键字，如果一个函数包含了yield，那么它就不再是一个普通函数，而是一个generator。该函数会在每次调用next()的时候执行，遇到yield语句的时候返回，再次执行时从上次返回的yield语句处继续执行。
for n in fib(6):
print n
三、函数式编程
函数式编程允许把函数本身作为参数传入另一个函数，还允许返回一个函数
python对函数式编程提供部分支持，由于python允许使用变量，所以python不是纯函数编程语言
1、变量可以指向函数
x = abs(-10) # x = 10
x = abs # x等于与函数abs
2、函数名也是变量
abs = 10 # abs变成了数值，而不再是取绝对值函数，由于abs函数是定义在__builtin__模块中，所以要让修改abs变量的指向在其他模块也生效，要用__buildin__.abs = 10
3、传入函数
函数可以作为一个参数，传给另一个函数，被传入的函数称之为高阶函数
def add(x, y, f):
return f(x) + f(y)
4、map函数，python内置函数，接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用在序列的每个元素上，并将结果作为新的list返回
def f(x):
return x * x
map(f, range(1, 4)) # [1, 4, 9]
map(str, range(1,4)) # ['1', '2', '3']
5、reduce函数，同为python内置函数，参数需求同map，不过传入的函数必须接收两个参数。
reduce(f, [a, b, c, d]) = f(f(f(a, b), c), d)
6、可以在函数里定义函数
def str2int(s):
def fn(x, y):
return x * 10 + y
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
return reduce(fn, map(char2num, s))
通过lambda简化如下
def char2num(s):
return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
def str2int(s):
return reduce(lambda x,y: x*10+y, map(char2num, s))
7、lambda（匿名函数）用法，只能含有一个表达式， fn = lambda x, y : x * 10 + y
fn(2, 4) # 24
8、filter函数，用于过滤序列，接收一个返回值为布尔型的函数和一个序列，根据返回值是True或者False决定是否保留钙元素
9、sorted函数，用于排序，和以上内置函数不同，它通过传入自定义函数实现排序，是传在第二参数位置
默认我们规定，两个元素x和y，x<y返回-1.x==y返回0，x>y返回1
10、如果在函数里定义一个函数，并作为返回值返回
11、通过__name__可以拿到函数的名字
如： f = abs
abs.__name__ # abs
f,__name__ # abs
12、装饰器（decorator），在代码运行期间动态增加功能的方式。本质上decorator就是一个返回函数的高阶函数，所以我们要定义一个能打印日志的decorator可以如下：
def log(func):
def wrapper(*args, **kw):
print 'call %s():' % fun.__name__
return fun(*args, **kw)
return wrapper
借助Python的@语法，吧decorator置于函数定义处：
@log
def now():
print '2013-12-25'
把@log放到now()定义处相当于执行了now = log(now)
如果decorator本身需要传入参数，如需要自定义输出的log内容，需要写一个3层嵌套：
def log(text):
def decorator(func):
def wrapper(*args, **kw):
print '%s %s():' % (text, fun.__name__)
return fun(*args, **kw)
return wrapper
return decorator
@log('execute')
def now():
print '2013-12-25'
和两层嵌套的decorator相比，效果相当于
now = log('execute')(now)
以上两种decorator的定义没有问题，但函数也是对象，它有__name__属性，经过装饰之后，__name__已经从now编程了wrapper
python内置的functools.wraps就是用于替换__name__，所以一个完整的decorator如下：
import functools
def log(func):
@functools.wraps(func)
def wrapper(*args, **kw):
print 'call %s():' % fun.__name__
return fun(*args, **kw)
return wrapper
面向对象设计模式中，decorator被称作装饰模式，OOP的装饰模式需要通过继承和组合来实现，而Python除了可以通过OOP的方式实现，直接从语法层次支持decorator。
13、偏函数，可以通过functoools.partial创建，作用是把一个函数的某些参数固定住（设置默认值），返回一个新的函数。
int('12345')
int('12345', 8)
import functools
int2 = functools.partial(int, 2)
转载请注明原文地址: https://www.6miu.com/read-48983.html
