Python语法笔记2

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的模块可以按照目录组织为包

创建一个包的步骤是：