python_day4内置函数补充

之前内容回顾

1、python基础2、基本数据类型：str、dict、list、tuple、set.. s = "alex" => str # s是创建的一个对象，所有功能被保存在其对应的str的类里 对象是类的实例 isinstance(s, str) ==> True3、函数式编程 函数定义 内置函数 文件处理 注意： li = [11,22,33,44] def f1(arg): #此函数没有返回值，默认返回None arg.append(55) li = f1(li) # li被重新赋值了，而其返回值为None print(li)# 如果li没有被重新赋值，则li == [11,22,33,44,55]4、其他 三目运算 lambda表达式

内置函数补充

callable() # 查询是否可以被调用chr() # 将数字转换成对应的ascii码ord() # 将ascii码转换成数字abs() # 取绝对值bool() # 取布尔值 # 0, None, "", [], {}, () # 以上布尔类型值都是False（注意双引号里面没有空格，列表跟字典里面无所谓）bin() #十进制转二进制oct() #十进制转八进制hex() #十进制转十六进制 utf-8 一个汉字：三个字节gbk 一个汉字：两个字节 # 字符串转换成字节类型# bytes("要转换的字符串",encoding="某种编码格式")

python file.py执行文件过程： 1、读取文件内容open，string（字符串形式）到内存 2、python，把字符串 -> 编译 =》特殊代码 3、执行代码 >>> s = "print(123)"#字符串 >>> r = compile(s, "<string>", "exec")#将字符串编译成python代码 #有几种模式single, eval ,exec >>> print(r) #code <code object <module> at 0x0000018F219D2660, file "<string>", line 1> >>> exec(r) #执行 123 >>> #将字符串编译成python代码 compile() #执行python代码，接收：代码（直接执行）或者字符串（先编译再执行）；虽然很牛逼，但没有返回值 exec("7+8+9") #执行表达式，并且获取结果（有返回值） ret = eval("7+8+9") print(ret)

dir(list) #快速查看对象提供了哪些功能help(dir) #帮助读源码的 #共97条数据，每页显示10条，需要多少页 r = divmod(97, 10) print(r) # (9, 7) 商9余7 # r[0] == 9 && r[1] == 7 #可以这么写： n1, n2 = divmod(97, 10) s = "alex"#用于判断，对象是某个类的实例isinstance(s, str) ==> True

ret = filter(函数, 可迭代的对象) # filter内部会循环被迭代的对象，然后执行函数，符合条件的元素就被添加到ret中 # 函数返回值为True，将元素添加到结果中！！！ >>> a = [11,22,33,44] >>> ret = filter(lambda x:x>33, a) >>> print(ret) <filter object at 0x000001CE9A862518> >>> print(list(ret)) [44] ret2 = map(函数，可迭代的对象) # map将函数的返回值添加到结果中！！！ >>> a = [11,22,33,44] >>> ret2 = map(lambda x:x>11, a)#lambda返回值为bool类型 >>> print(list(ret2)) [False, True, True, True] >>> ret2 = map(lambda x:x+11, a)#lambda返回值为int类型 >>> print(list(ret2)) [22, 33, 44, 55] >>>

len()在python2.7跟python3.0里面的不同：>>> li = "理解" #python3里面，中文默认是字符来算的 >>> len(li) 2 >>> b = bytes(li, encoding='utf-8') #可以显式的转换成字节 >>> len(b) 6 >>>

sum([11,22,33,44])max([11,22,33,44]) min([11,22,33,44]) pow(2, 10)#乘方 =》1024 round(1.2)#四舍五入 li = [11,22,3,4] li.reverse() 《===》reversed(li) #内部执行li.reverse()方法 li.sort() 《===》 sorted(li)

zip(): #仅限于python3.. >>> l1 = ["Your", 11, 22] >>> l2 = ["are", 22, 33, 55] >>> l3 = ["beautiful", 33, 44] >>> r = zip(l1, l2, l3) >>> print(list(r)) #依次取出每个数组的元素进行组合;如果元素长度不一致会被砍到一样长 [('Your', 'are', 'beautiful'), (11, 22, 33), (22, 33, 44)] >>> print(list(r)) #为啥第二此打印会变成空列表？？ [] >>> a, b, c = zip(*[('Your', 'are', 'beautiful'), (11, 22, 33), (22, 33, 44)]) >>> print(a, b, c) # zip(*list)也就是列表前面带个星号，是上述操作的逆操作 ('Your', 11, 22) ('are', 22, 33) ('beautiful', 33, 44) >>>

反射：（以后补充） delattr(), getattr(), setattr(), hasattr()迭代器： iter(), next()

内置函数补充 二

一、map遍历序列，对序列中每个元素进行操作，最终获取新的序列。

# 每个元素加100

li = [11, 22, 33]
new_list = map(lambda a: a + 100, li)

# 两个列表对应元素相加
li = [11, 22, 33]
sl = [1, 2, 3]
new_list = map(lambda a, b: a + b, li, sl)

二、filter对于序列中的元素进行筛选，最终获取符合条件的序列

li = [11, 22, 33]    # 获取列表中大于12的所有元素集合

new_list = filter(lambda arg: arg > 22, li)  # filter第一个参数为空，将获取原来序列

三、reduce对于序列内所有元素进行累计操作

li = [11, 22, 33]    # 获取序列所有元素的和
result = reduce(lambda arg1, arg2: arg1 + arg2, li)

# reduce的第一个参数，函数必须要有两个参数
# reduce的第二个参数，要循环的序列
# reduce的第三个参数，初始值

yield生成器

1、对比range 和 xrange 的区别

>>> print range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print xrange(10)
xrange(10)

如上代码所示，range会在内存中创建所有指定的数字，而xrange不会立即创建，只有在迭代循环时，才去创建每个数组。

# 自定义生成器nrange
def nrange(num):
temp = -1
while True:
temp = temp + 1
if temp >= num:
return
else:
yield temp

2、文件操作的 read 和 xreadlinex 的的区别

read会读取所有内容到内存
xreadlines则只有在循环迭代时才获取

# 基于next自定义生成器NReadlines
def NReadlines():
with open('log','r') as f:
while True:
line = f.next()
if line:
yield line
else:
return

for i in NReadlines():
print i

# 基于seek和tell自定义生成器NReadlines
def NReadlines():
with open('log','r') as f:
seek = 0
while True:
f.seek(seek)
data = f.readline()
if data:
seek = f.tell()
yield data
else:
return

for item in NReadlines():
print item

装饰器

装饰器是函数，只不过该函数可以具有特殊的含义，装饰器用来装饰函数或类，使用装饰器可以在函数执行前和执行后添加相应操作。

#!/usr/bin/env python
#coding:utf-8

def Before(request,kargs):
print 'before'

def After(request,kargs):
print 'after'

def Filter(before_func,after_func):
def outer(main_func):
def wrapper(request,kargs):

before_result = before_func(request,kargs)
if(before_result != None):
return before_result;

main_result = main_func(request,kargs)
if(main_result != None):
return main_result;

after_result = after_func(request,kargs)
if(after_result != None):
return after_result;

return wrapper
return outer

@Filter(Before, After)
def Index(request,kargs):
print 'index'

if __name__ == '__main__':
Index(1,2)

冒泡算法

需求：请按照从小到大对列表 [13, 22, 6, 99, 11] 进行排序思路：相邻两个值进行比较，将较大的值放在右侧，依次比较！

# 第一步
li = [13, 22, 6, 99, 11]

for m in range(4):     # 等价于 #for m in range(len(li)-1):
if li[m]> li[m+1]:
temp = li[m+1]
li[m+1] = li[m]
li[m] = temp

# 第二步
li = [13, 22, 6, 99, 11]

for m in range(4):     # 等价于 #for m in range(len(li)-1):
if li[m]> li[m+1]:
temp = li[m+1]
li[m+1] = li[m]
li[m] = temp

for m in range(3):     # 等价于 #for m in range(len(li)-2):
if li[m]> li[m+1]:
temp = li[m+1]
li[m+1] = li[m]
li[m] = temp

for m in range(2):     # 等价于 #for m in range(len(li)-3):
if li[m]> li[m+1]:
temp = li[m+1]
li[m+1] = li[m]
li[m] = temp

for m in range(1):     # 等价于 #for m in range(len(li)-4):
if li[m]> li[m+1]:
temp = li[m+1]
li[m+1] = li[m]
li[m] = temp
print li

# 第三步
li = [13, 22, 6, 99, 11]

for i in range(1,5):
for m in range(len(li)-i):
if li[m] > li[m+1]:
temp = li[m+1]
li[m+1] = li[m]
li[m] = temp

递归

利用函数编写如下数列：

斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377

# demo
def func(arg1,arg2):
if arg1 == 0:
print arg1, arg2
arg3 = arg1 + arg2
print arg3
func(arg2, arg3)

func(0,1)