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 x*y

#Lambda表达式写法:
g=lambda x,y:x*y
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 n*int(f(n-1))
else:
return 1
print f(5)

#reduce实现递归的功能
l = range(1,6)
def f(x,y):
ret urn x*y
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[“+”](1,2)

实现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) #
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!’]

arthinking wechat
欢迎关注itzhai公众号