python语法
有序列表:
List [1, 2, 3, 4] 可变
Tuple (1, 2, 3, 4) 不可变
无序列表:
set 是一个无序不重复元素的集。基本功能包括关系运算和消除重复元素。集合的基本形式如：set('abracadabra')
Dictionary 是无序的键：值对 (key:value 对)集合
len() #查询长度
List[-1] #反向查找元素
List.append('ele') #末尾添加元素
ListA.extend(ListB) #把列表B所有元素添加到ListA中
List.append(index, 'ele') #指定位置添加元素
List.insert(index, 'ele') #指定位置添加元素
List.pop() #删除末尾元素
List.pop(index) #删除指定位置
List.pop([i]) #删除指定位置
List.remove(value) #删除值为value的元素
List[index] = ele #替换指定位置的元素
List.index(value) #返回列表中第一个值为value的元素的索引
List.count(value) #返回value在列表中出现的次数
List.sort(cmp=none, key=none, reverse=False) #给列表排序，参数可自定义
List.reverse() #给列表反转排序
del List[i] #按给定的索引来删除子项
dict = {'key1': value, 'key2': value}
dict['key1'] #取值
dict['key3'] = value #添加元素
'key4' in dict dict.get('key4') #判断dict中是否有某个key
dict.pop(key) #删除一个key
条件
1.
if 判断条件：
执行语句……
else：
执行语句……
2.
if 判断条件1：
执行语句1……
elif 判断条件2：
执行语句2……
elif 判断条件3：
执行语句3……
else：
执行语句4……
逻辑判断
and or not
循环
count = 0;
while (count < 9):
print ('the count is:', count)
count ++
fruits = ['banana', 'apple', 'mango']
for fruit in fruits:
print fruit
T = [(1,2), (3,4), (5,6)]
for (a,b) in T:
print (a,b)
1 2
3 4
5 6
定义函数
def my_abs(x):
if x >= 0:
return x
else:
return -x
请注意，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。
如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。
return None可以简写为return。
函数的参数
1.默认参数
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
一是必选参数在前，默认参数在后，否则Python的解释器会报错（思考一下为什么默认参数不能放在必选参数前面）；
二是如何设置默认参数。
当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。
使用默认参数有什么好处？最大的好处是能降低调用函数的难度。
2.可变参数
def calc(numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
调用的时候，需要先组装出一个 list 或 tuple：
calc([1, 2, 3])
calc((1, 3, 5, 7))
如果利用可变参数，我们把函数的参数改为可变参数:
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
调用函数的方式可以简化成这样：
calc(1, 2, 3)
calc(1, 3, 5, 7)
定义可变参数和定义 list 或 tuple 参数相比，仅仅在参数前面加了一个 * 号。在函数内部，参数 numbers 接收到的是一个 tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括 0 个参数：
calc()
如果已经有一个 list 或者 tuple，要调用一个可变参数怎么办？ Python允许你在 list 或 tuple 前面加一个 * 号，把 list 或 tuple 的元素变成可变参数传进去,可以这样做：
nums = [1, 2, 3]
calc(*nums)
这种写法相当有用，而且很常见。
3.关键字参数
Idef person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
函数person除了必选参数 name 和 age 外，还接受关键字参数 kw。在调用该函数时，可以只传入必选参数：
person('Michael', 30)
也可以传入任意个数的关键字参数：
person('Adam', 45, gender='M', job='Engineer')
4.混合参数
在Python中定义函数，可以用必选参数、默认参数、可变参数和关键字参数，这4种参数都可以一起使用，或者只用其中某些，但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数和关键字参数。
比如定义一个函数，包含上述4种参数：
def func(a, b, c=0, *args, **kw):
print ('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去。
func(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
小结
Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
默认参数一定要用不可变对象，如果是可变对象，运行会有逻辑错误！
要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
以及调用函数时如何传入可变参数和关键字参数的语法：
可变参数既可以直接传入：func(1, 2, 3)，又可以先组装list或tuple，再通过*args传入：func(*(1, 2, 3))；
关键字参数既可以直接传入：func(a=1, b=2)，又可以先组装dict，再通过**kw传入：func(**{'a': 1, 'b': 2})。
使用*args和**kw是Python的习惯写法，当然也可以用其他参数名，但最好使用习惯用法
匿名函数
python 使用 lambda 来创建匿名函数。
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的名字空间，且不能访问自有参数列表之外或全局名字空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
import time
start = time.clock()
fib=lambda n,x=0,y=1:x if not n else fib(n-1,y,x+y)
print (fib(20))
end = time.clock()
print ("read: %f s" % (end - start))
6765
read: 0.000000 s
start = time.clock()
fib=lambda n:1 if n<=2 else fib(n-1)+fib(n-2)
print(fib(20))
end = time.clock()
print ("read: %f s" % (end - start))
6765
read: 0.000000 s
函数中的多态
一个操作的意义取决于被操作对象的类型
def times(x,y):
return x*y
times(2,4)
传递了与上不同的数据类型
times('Python',4)
intersect([1,2,3],(1,4))
[1]
递归
1）递归就是在过程或函数里调用自身；
（2）在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。
递归算法一般用于解决三类问题： （1）数据的定义是按递归定义的。（比如Fibonacci函数） （2）问题解法按递归算法实现。（回溯） （3）数据的结构形式是按递归定义的。（比如树的遍历，图的搜索）
递归的缺点：递归算法解题的运行效率较低。在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。
示例：斐波那契数列
斐波那契数列由十三世纪意大利数学家斐波那契发现。数列中的一系列数字常被人们称之为神奇数奇异数。具体数列为：0，1，1，2，3，5，8，13，21，34，55，89，144，233等，从该数列的第三项数字开始，每个数字等于前两个相邻数字之和。而斐波那契数列中相邻两项之商就接近黄金分割数0.618，与这一数字相关的0.191、0.382、0.5和0.809等数字就构成了股市中关于市场时间和空间计算的重要数字。
在金融市场的分析方法中，斐波那契数字频频出现。例如，在波浪理论中，一轮牛市行情可以用1个上升浪来表示，也可以用5个低一个层次的小浪来表示，还可继续细分为21个或89个小浪；在空间分析体系中，反弹行情的高度通常是前方下降趋势幅度的0.382、0.5、0.618；回调行情通常是前方上升趋势的0.382、0.5和0.618。
import time
start = time.clock()
def fib(n):
if n<=2:return 1
else:
return fib(n-1)+fib(n-2)
print (fib(20))
end = time.clock()
print ("read: %f s" % (end - start))
start = time.clock()
def fib(n):
return 1 and n<=2 or fib(n-1)+fib(n-2)
print (fib(20))
end = time.clock()
print ("read: %f s" % (end - start))
