Python之路4Day

内置函数处理

li  = [11,22,33,44]

def f1(arg):

arg.append(55)

li = f1(li)

fi(li)

print(li)

函数默认返回值None

参数引用

例题：

1.将字符串"老男人"转换成UTF-8编码的字节类型

s = "lannanren"

(字节)bytes(s,encoding=‘utf8-8‘)   #encoding定义字符编码

2.avs计算绝对值

3.列举布尔值为False的值

False:      [],{},None,0,"",()    为空的基本都是False

内置函数：

any :一个为真就为真

all ：所有为真就为真

callable()  #是否被执行，被调用

例：def f1():

pass

print(callable(f1))

print(callable(f2))

f1()

f2()

>>>  True                 可以被调用

>>>  False                不可以被调用

chr()：

ord()：                   chr 和 ord都是数字和字母间的转换  根据ASCLL表进行转换的

r=chr(65)

print(r)

N=ord("B")

print(N)

输出

A

66

join:用法     起连接作用   输出必须是字符串

li = ["a","b","c"]

print("".join(li))

>>> abc

li = ["a","b","c"]

print("".join(li))

>>> a-b-c

随机验证模块(random)

例1：随机生成大写字母

import random              #65-90每个数字对应一个大写字母

i = random.randrange(65,91)

c =chr(i)

print(c)

例2：当循环第三/第五次生成数字（第三位或第五位是数字）

import random

list = []

for i in range(6):

if i==2 or i==4:             #当第三次循环时生成数字i代表第三位生成数字

num = random.randrange(0,10)

list.append(str(num))       #由于JOIN输出只能是字符串所以str转换下

else:

temp = random.randrange(65,90)

c = chr(temp)

list.append(c)

# # # li = ["c","b","a"] #cba

result = "".join(list)        #连接功能

print(result)

例3：每一位都可能是2或4

import random                          #random方法返回随机生成的一个实数，它在[0,1)范围内。

list[]

for i in range(6):

r = random.randrange(0,5)

if i==2 or i==4:             #每一位都可能是2或4

num = random.randrange(0,10)

list.append(str(num))       #由于JOIN输出只能是字符串所以str转换下

else:

temp = random.randrange(65,90)

c = chr(temp)

list.append(c)

# # # li = ["c","b","a"] #cba

result = "".join(list)        #连接功能

print(result)

python执行过程：

1.读取文件内容open,str到内存

2.python,把字符串 -> 编译 =》特殊代码

3.执行代码

compile()                 #把字符串编译成代码

#编译模式single，eval,exec

exec()         #执行python代码,接收代码或字符串，无返回值。

例：

s = "print(13)"

r = compile(s,"<string>","exec")

exec(r)

>>>13

evel()          #执行表达式并获取结果

例:

ret = eval("7+4+5")

print(ret)

>>>16           #返回值

dict() #字典

dir()#快速查看对象提供的功能

例：

print(dir(list))

>>>[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘,

‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘,

help()#功能详细

例:

help(list)

divmod():             # 用于进行分页进行除法求职，（100.10）分别为被除数，除数，

返回值为r[0]位商，r[1]余数。

r = divmod(100,10)

print(r[0])

print(r[1])

>>>10

>>>0

enumerate 函数用于遍历序列中的元素以及它们的下标：

例

>>> for i,j in enumerate((‘a‘,‘b‘,‘c‘)):  #元组

print i,j

0 a

1 b

2 c

>>> for i,j in enumerate([1,2,3]):         #列表

print i,j

0 1

1 2

2 3

>>> for i,j in enumerate({‘a‘:1,‘b‘:2}):    #字典

print i,j

0 a

1 b

>>> for i,j in enumerate(‘abc‘):            #字符串

print i,j

0 a

1 b

2 c

isinstance:       用于判断，对象是否是某个类的实例

例1：s = [11,22,33]

r = isinstance(s,list)

print(r)

>>>True

s = ‘113322‘

r = isinstance(s, str)

print(r)

>>>True

s = ((‘11‘,‘3322‘))

r = isinstance(s, tuple)  #tuple元组

print(r)

>>>True

s = {‘1‘:‘11‘,‘2‘:‘3322‘}

r = isinstance(s, dict)

print(r)

>>>True

lambad表达式：为了简化函数。

功能：

1、只能做简单的操作
2、自动return

看下两个函数对比：

‘‘‘正常函数‘‘‘

def func(arg):

return arg + 1

result = func(100)

print result

‘‘‘lambda表达式‘‘‘

func2 =  lambda a: a + 1

result = func2(10000)

#这里调用函数的时候就是lambda表达式左边的等号就是他函数的调用！

print result

#执行结果：

#101

#10001

引用http://www.cnblogs.com/luotianshuai

map函数：

功能：遍历序列，对序列中每个元素进行操作，最终获取新的序列。

解释：

在Python中，最基本的数据结构是序列（sequence）。序列中的每个元素被分配一个序号——即元素的位置，也称为索引。第一个索引是 0，第二个则是 1，以此类推。序列中的最后一个元素标记为 -1，倒数第二个元素为 -2，一次类推。

Python包含 6 中内建的序列，包括列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。

例子：

‘‘‘例子1‘‘‘

li =  [11,22,33]

def func1(arg):

return arg + 1  #这里乘除都可以

new_list = map(func1,li)  #这里map调用函数，函数的规则你可以自己指定，你函数定义成什么他就做什么操作！

print new_list

输出结果：[12, 23, 34]

‘‘‘例子2‘‘‘

li = [‘shuaige‘,‘nihao‘,]

def func1(arg):

return ‘%s test string‘ % arg  #或者使用+进行拼接万恶的+能不用最好不用他会在内存中开辟新的空间！

new_strlist = map(func1,li)

print new_strlist

输出结果：[‘shuaige test string‘, ‘nihao test string‘]

‘‘‘例子3‘‘‘

li = ‘abcdefg‘

def func1(arg):

return ‘%s test string‘ % arg

new_list = map(func1,li)

print new_list

#结果：[‘a test string‘, ‘b test string‘, ‘c test string‘, ‘d test string‘, ‘e test string‘, ‘f test string‘, ‘g test string‘]

使用lambda表达式实例：

li = [11,22,33,44,55]

new_li = map(lambda a:a + 100,li)

print new_li

#输出结果：   [111, 122, 133, 144, 155]

#多个列表操作：

l1 = [11,22,33,44,55]

l2 = [22,33,44,55,66]

l3 = [33,44,55,66,77]

print map(lambda a1,a2,a3:a1+a2+a3,l1,l2,l3)

#输出结果：  [66, 99, 132, 165, 198]

#这里需要注意如果使用map函数列表中的元素必须是相同的才可以!否则就会报下面的错误！

#TypeError: unsupported operand type(s) for +: ‘int‘ and ‘NoneType‘，如果看下面

l1 = [11,22,33,44,55]

l2 = [22,33,44,55,66]

l3 = [33,44,55,66,]

#l3的数据少一个，如果元素里的元素为空那么他调用的时候这个元素就是None

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

li = [11,22,33,44,55,66,77,88]

print filter(lambda a:a>33,li)
输出结果：[44, 55, 66, 77, 88]

装饰器

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

简单的来说在不修改原函数的情况下，在对原函数进行包装！

一、初创公司有N个业务部门，1个基础平台部门，基础平台负责提供底层的功能，如：数据库操作、redis调用、监控API等功能。业务部门使用基础功能时，只需调用基础平台提供的功能即可。如下：

目前公司有条不紊的进行着，但是，以前基础平台的开发人员在写代码时候没有关注验证相关的问题，即：基础平台的提供的功能可以被任何人使用。现在需要对基础平台的所有功能进行重构，为平台提供的所有功能添加验证机制，即：执行功能前，先进行验证。

老大把工作交给 Low B，他是这么做的：

当天Low B 被开除了...

老大把工作交给 Low BB，他是这么做的：

 修改原基础平台代码

过了一周 Low BB 被开除了...

老大把工作交给 Low BBB，他是这么做的：

 新建立一个函数把函数应用到原基础函数上

老大看了下Low BBB 的实现，嘴角漏出了一丝的欣慰的笑，语重心长的跟Low BBB聊了个天：

老大说：

写代码要遵循开发封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：

• 封闭：已实现的功能代码块
• 开放：对扩展开发

如果将开放封闭原则应用在上述需求中，那么就不允许在函数 f1 、f2、f3、f4的内部进行修改代码，老板就给了Low BBB一个实现方案：

对于上述代码，也是仅仅对基础平台的代码进行修改，就可以实现在其他人调用函数 f1 f2 f3 f4 之前都进行【验证】操作，并且其他业务部门无需做任何操作。

Low BBB心惊胆战的问了下，这段代码的内部执行原理是什么呢？

老大正要生气，突然Low BBB的手机掉到地上，恰恰屏保就是Low BBB的女友照片，老大一看一紧一抖，喜笑颜开，交定了Low BBB这个朋友。详细的开始讲解了：

单独以f1为例：

当执行的时候，python是由上到下执行的，首先执行到def w1(func):这里把def w1(func)加载到内存

当执行到@w1的时候@w1是python的语法糖！他会把他下面的函数进行封装。

把f1这个函数作为def w1(func)的参数传进去！就是：f1()=w1(f1)

然后def w1(func):  == w1(f1)就会执行：

@w1就相当于做了一个替换

def f1()  <==> def inner()

二、被装饰的函数如果有参数呢？

用动态参数搞定！

三、一个函数可以被多个装饰器装饰吗？

输出结果：

这个被多个装饰器装饰，其实就是套完一层在套一层！勿把自己绕进去！

 四、还有什么更吊的装饰器吗？

来自为知笔记(Wiz)