1、while
while expression
statements(s)
while True:
print "=========="
x = raw_input("enter q for quit:")
if x == 'q'：
break
else:
print "end" # break退出的，这句话不会被执行；当while条件为False的时候会执行
2、函数
2.1、函数的定义和调用：
使用def语句：
def 函数名(参数列表): # 可以没有参数
函数体
def add(a, b):
c = a + b
print c
add(100,200)
def fun():
print 10
if fun():
print "ok" #这个ok并没有输出，跟函数的返回值有关
2.2、形式参数和实际参数
在定义函数时函数名后面圆括号中的变量名称成为“形式参数”
在调用函数是，函数名后面圆括号中变量名称叫做“实际参数”
2.2.1、文件头写编码：
#coding:utf8
#coding=utf8
#enoding:utf8
#encoding=utf8
2.2.2、缺省参数（默认参数）
def fun(x, y="cat"): #设置默认参数的时候一定是自右向左的
print x,y
fun("test") #这个时候就可以不用传入第二个参数了
3、函数
3.1、局部变量和全局变量：
Python中任何变量都有其特定的作用域；
在函数中定义的变量一般只能在该函数内部使用，这些只能在程序的特定部分使用的变量我们称之为局部变量
在一个文件顶部定义的变量可供该文件中的任何函数调用，这些可以为整个程序所使用的变量称为全局变量
x = 'Jason'
def fun2():
global x
x = 100 #全局变量被改写了
global y
y = 200
print x
fun2()
print x #获取到的是全局的变量
print y #y被声明为全局变量，可以引用到，前提是函数要被调用过
3.2、返回值
函数被调用后返回一个指定的值
函数调用后默认返回None
return 返回值
返回值可以使任意类型
return执行后，函数终止
区分返回值和打印
def f(x,y):
print "execute"
return x + y
a = f(1,2)
print a
def f2():
return "====" #函数返回终止，后面的不会执行
return "===="
3.3、多类型传值
3.3.1、 向函数传元组和字典
fun(*args)
fun(**k)
def f(x,y):
print x,y
t = ('a','b')
f(t, 'b') #output: ('a', 'b') b
t = ("name", "Jason")
def f(x,y):
print "%s, %s" % (x,y)
f(*t) #加星号传值，表示传递一个元组
def f2(name="Jason",age=20):
print "name: %s" % name
print "age: %d" % age
d = {"age":10, "name":"Jack"}
f2(**d) #两个星号表示传递字典
f2(age=10, name="Jack")
3.3.2、传值冗余
处理多余实参:
def fun(*args, **k)
def f3(x, *args):
print x,args #args是一个元组
f3(1) #output: 1 ()
f3(1,2,3) #output: 1 (2, 3)
def f4(x, *args, **k):
print x, args, k
f4(1, 3, name="Jason") #output: 1 (3,) {'name': 'Jason'}
4、Lambda表达式
匿名函数：lambda韩式是一种快速定义单行的最小函数，是从List借用来的，可以用在任何需要函数的地方
def f(x,y):
return xy
#Lambda表达式写法：
g=lambda x,y:xy
g(2,3)
使用lambda表达式的好处：
- 使用Python写一些执行脚本时，使用lambda可以省去定义函数的过程，让代码更加精简；
- 对于一些抽象的，不会别的地方重复调用的函数，有时候给函数起个名字也是个难题，使用lambda不需要考虑命名的问题；
- 使用lambda在某些时候让代码更容易理解；
lambda语句中，冒号前面是参数，可以有多个，用逗号隔开，冒号右边是返回值。lambda语句构建的其实是一个函数对象。
g=lambda x:x**2
print g #output: at 0x02564DB0>
reduce为逐次操作list里的每项，接收的参数为2个，最后返回的为一个结果：
def add(x,y):
return x+y
sum = reduce(add, (1,2,3)) #6
下面看一个递归的普通实现和lambda实现的例子：
def f(n):
if n>0:
return nint(f(n-1))
else:
return 1
print f(5)
#reduce实现递归的功能
l = range(1,6)
def f(x,y):
ret urn xy
reduce(f, l) #120
#lambda的写法
reduce(lambda x,y:x*y,l)
5、switch
python没有提供switch语句
python可以通过字典实现switch语句的功能：
- 首先定义一个字典
- 其次，调用字典的get()获取相应的表达式
通过字典调用函数：
{1:case1,2:case}.get(x,lambda*arg,**key:)()
from future import division
def add(x,y):
return x+y
def sub(x,y):
return x-y
def mul(x,y):
return xy
def div(x,y):
return x/y
operator = {"+":add, "-":sub, "":mul, "/":div}
operator"+"
实现switch：
def f(x,o,y):
print operator.get(o)(x,y)
f(1,"+",2)
6、内置函数
6.1、一个获取绝对值的函数：
#获取绝对值
def f(x):
if x
系统内部的绝对值函数：
abs() #绝对值
max() #最大值
min() #最小值
print abs(-1)
print max(1,2,4)
print max([1,2,3,4])
6.2、常用函数：
len() #一个列表或者一个序列 长度
divmod() #取得两个数的商和模
pow() #乘方
round() #取整
print divmod(5,2) #output: (2, 1)
print pow(2,3) #output: 8
print pow(2,3,4) #output: 0 8可以被4整除
print round(3.2) #output: 3.0
print round(3.6) #output: 4.0
callable() #测试某个函数是否可被调用
isinstance() #判断对象是什么类型的
cmp() #比较两个字符串
range() #快速生成一个序列
xrange() #快速生成一个序列，大数据xrange效率高很多
print callable(min) #True
f=1
print callable(f) #False
l = [1,2]
print type(l) #<type 'list'>
if(type(l) == type([])):
print "list"
print isinstance(l, list) #true
print cmp(1,2) #-1
print cmp(1,1) #0
6.3、类型转换函数：
类型转换的内置函数：
int()
tuple()
int()
long()
float()
complex()
str()
list()
hex()
oct()
chr()
ord()
6.4、string函数：
str.capitalize() #字符串首字母大写
str.replace() #替换
str.split() #分割
a='hello'
print a.capitalize(); #Hello
print a.replace('e', '_', 1); #h_llo 不给第三个参数，表示替换所有的
print a.split('e'); #['h', 'llo'] 不给第二个参数，表示切割所有的
help(a.replace)
引入模块的方式调用
import string
string.replace('hejsoislekjfk', 's', '_') #hej_oi_lekjfk
6.5、序列处理函数
len()
max()
min()
filter()
zip()
map()
reduce()
def f(x):
if(x > 5):
return True
print filter(f, range(10)) #[6, 7, 8, 9]
6.6、序列处理函数
下面是zip和map的演示：
name=['Jason', 'Jack']
age=['10', '12']
print zip(name, age) #[('Jason', '10'), ('Jack', '12')]
print map(None, name, age) #[('Jason', '10'), ('Jack', '12')]
#zip和map的区别：map会用None填充空缺的内容，zip则只会去掉多出的
test=[10]
print zip(name, age, test) #[('Jason', '10', 10)]
print map(None, name, age, test) #[('Jason', '10', 10), ('Jack', '12', None)]
#map还可以用于两个序列的并行计算：
a=[1,2,3]
b=[4,5,6]
def ff(x,y):
return x*y
map(None, a, b) #[('Jason', '10', 10)]
map(ff, a, b) #[('Jason', '10', 10), ('Jack', '12', None)]
下面是reduce的演示：
#使用reduce演示1加到100
l=range(1,101)
print reduce(lambda x,y:x+y, l) #5050
7、模块
模块是Python组织代码的基本方式
Python的脚本都是扩展名为py的文本文件保存的，一个脚本可以单独运行，也可以导入另一个脚本运行。当一个脚本被打入运行时，我们将其成为模块（module）
模块名与脚本的文件名相同
例如写一个名为item.py的脚本，则可以再另外一个脚本中用import item语句来导入它
def add(x,y):
return x+y
if name == "main": #当前模块下才执行下面的代码
print add(1,2)
8、包：
Python的模块可以按照目录组织为包
创建一个包的步骤是：
- 建立一个名字为包名字的文件夹
- 在该文件夹下创建一个__init__.py文件
- 根据需要在该文件夹下存放脚本文件、已编译的扩展及子包
import pack.module1, pack.module2
使用别名：
import string as str
print str.split("Hello world!", " ", 1) #['Hello', 'world!']
直接导入方法：
from string import split
print split("Hello world!"," "); #['Hello', 'world!']
