python 基础（四）
一. 本章主要内容简介：
1. Python内置函数的功能用途(继续上一章讲解)
内置函数：
1）数字运算、类型转换、集合类操作：
bin()、oct()、int()、hex() 进制转换，round()四舍五入，pow()返回x的y次幂，range() 生成序列，sum()求和，divmod()商和余数 ，
chr() 、ord()用来做ascii码转换，max()序列中最大值， min()最小值；random随机数；
basestring() 是str和unicode的超类（父类），format()格式化字符串，unichr()返回给定int类型的unicode，enumerate()枚举函数，iter()生成一个对象的迭代器,
complex()复数，float()浮点数，bool()布尔值，dict()字典，list()列表，tuple()元组，str()字符串，set()集合，frozenset()产生一个不可变的set,sorted()排序，
yeild()、xrange()py3时此函数已取消，生成器，len()计算长度；
2）逻辑判断：
all()所有元素为真、any()任何一个为真、cmp()比较是否相等（Python3已经没有这个函数了）；
3）IO操作：
input() 获取输入（Python3之前使用raw_input），print()打印输出，open()文件操作；
4）反射
callable() 检查对象object是否可调用、 classmethod() 是用来指定一个类的方法为类方法
compile() 将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。
dir()不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
delattr()删除object对象名为name的属性，eval()计算表达式expression的值，filter()用于过滤序列。
execfile()用法类似exec()，不同的是execfile的参数filename为文件名，而exec的参数为字符串。
getattr()获取一个类的属性，globals()返回一个描述当前全局符号表的字典，hasattr() 判断对象object是否包含名为name的特性，
hash()如果对象object为哈希表类型，返回对象object的哈希值，isinstance()判断object是否是class的实例，
id()返回对象的唯一标识，issubclass()判断是否是子类，len()返回序列长度，locals()返回当前的变量列表， map()遍历每个元素，执行function操作，
memoryview()返回一个内存镜像类型的对象， next()类似于iterator.next()， object()基类，
property()属性访问的包装类，设置后可以通过c.x=value等来访问setter和getter,
reduce()合并操作，从第一个开始是前两个参数，然后是前两个的结果与第三个合并进行处理，以此类推,
reload()重新加载模块, setattr()设置属性值, repr()将一个对象变幻为可打印的格式,
slice()是个类，切片类型，Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).
staticmethod()声明静态方法，是个注解，super()引用父类， type()返回该object的类型，
vars()返回对象的变量，若无参数与dict()方法类似，bytearray()返回一个byte数组，
zip()按列合并多个可迭代对象的列值，相同列的元素生成一个元组元素，有一列的元素为空时，就不再生成；
5）重要的内置函数，一会做一些实例，这里只做简介；
2. 装饰器讲解；
装饰器是比较难理解的，这里只做简介。装饰器使用环境：不想改变原函数，又要添加额外的功能时使用，装饰器可以在原函数之前、之后添加新增功能；
二. 通过实例讲解内置函数
2.1 内置函数
1）数字运算类：
1、绝对值：abs(-1) 结果：1；
2、最大最小值：max([1,2,3])结果：3； min([1,2,3])结果：1
3、序列长度：len('abc')结果：3； len([1,2,3])结果：3； len((1,2,3))结果：3
4、取商和余数：divmod(5,2) 结果：(2,1)
5、乘方：pow(2,3,4)//2**3/4 官方功能说明： Equivalent to x**y (with two arguments) or x**y % z (with three arguments)
6、四舍五入：round(2.7) 结果：3
7、求和：sum((1,2,3)) 结果：6 将纯数字元素的列表或元组，计算求和；
8、切片：a = [1,2,3,4,5] ;a[0:3]结果：[1,2,3], 切片执行顾前不顾后，从0位开始，到3的位置终止，不包括3
9、步长：a = [1,2,3,4,5] ;a[0:5:2]结果：[1,3,5], 步长是隔几个数取值，取值范围1-5，每隔两个取值，1开始取，2开始步长一次，3的时候步长为2，再次取值，以此类推；
2）进制转换：
1、二进制转换，bin(10) 结果：'0b1010' ，将十进制转为二进制表示；
2、八进制转换，oct(10) 结果： '0o12' ， 将十进制转为八进制表示；
3、十进制整数表示，int(10) 结果： 10 ， 默认是字符串，int后转成十进制整数；
4、十六进制转换，hex(16) 结果：'0x10， 将十进制转为十六进制表示；
3）类型 和 类型转换：
1、整数类型转换，int('123') 结果：123， 将字符串转换成整数类型；
2、字符串类型转换，type(str(int('123'))) 结果：<class 'str'>， 将数字转成字符串类型；
3、浮点类型转换，float(123) 结果：123.0， 将整数转为浮点数表示；
4、复数类型转换，complex(123) 结果：(123+0j)， 将整数或浮点数转为复数；
5、列表类型转换, list((1,2,3))、list('123') 结果：['1','2','3'], 将可迭代对象转为列表； 注意：字符串可以转换，数字类型不行（不可迭代）
6、元组类型转换， tuple((1,2,3))、tuple('123')结果：（'1','2','3'）, 将可迭代对象转为列表； 注意：字符串可以转换，数字类型不行（不可迭代）
7、集合类型转换，set('abc') 结果：{’a','b','c'} 将可迭代对象转为集合；
8、字典类型转换，类型是字符串样子却是字典，需要json格式化转换，如：a = '{"a":1}' ； json.loads(a) 结果：a转为字典类型；
9、布尔类型，布尔类型只有True和False两种返回值， 0、None、False、" "、[]、()、{}是False，其它是True；
10、ASCII码转换，chr(48)与ord('0'), 对照ASSCII表操作，效果更好，chr(65) 结果：ASSCII 码的 ‘A'；ord('A')结果：65；
chr(48)返回对应的ASCII字符0,与ord('0')作用相反。
11、查看类型，type()，返回一个值的类型，type('abc') 结果：<class 'str'>；type(123) 结果：<class 'int'>；
4）判断：
1、所有元素为真，才为真，all((1,'a')) 结果：True，参数必须是可迭代类型；
2、任何一个为真，就为真，any((1,0,None)) 结果：True，参数必须是可迭代类型；
3、判断object是否是class的实例，isinstance('a',str) 结果： True， 两个参数，字符串a 和 str类型，’a‘是str类型返回True；
4、 判断对象是否可以调用， callable() 如果对象可以调用的，则返回true,如果对象不能调用，则返回false.
5）filter ()、map()和 lambda（）函数；
1、filter（函数，可迭代对象），过滤序列；
# filter def f1(a): if a > 22: return True li = [11,22,33,44,55] ret = filter(f1,li) print(list(ret))
执行结果：
[33,44,55]
- lambda 函数，操作简单的条件语句；
li = [11,22,22,33,44,55] r = filter(lambda a: a > 33, li) print(list(r))
执行结果：
[44,55]
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。
2、map（函数，可迭代对象）， 执行函数操作，将返回值添加到结果中；
def f1(a): return a + 100 r = map(f1,li) print(list(r)) 执行结果： [111, 122, 122, 133, 144, 155]
- lambda 函数，操作简单的条件语句；
li = [11,22,33,44,55] ret = map(lambda a: a + 100 ,li) print(list(ret)) 执行结果: [111, 122, 133, 144, 155]
3、filter 和 map 的区别：
filter 函数返回True，将结果添加到结果中；
map 将函数返回值添加到结果中；
6） globals() 和 locals()
1、globals(*args, **kwargs) 返回一个当前作用域里全局变量的字典； Return a dictionary containing the current scope's globla variables.
2、locals(*args, **kwargs) 返回一个当前作用域里局部变量的字典； Return a dictionary containing the current scope's local variables.
7）len() 函数
- len返回序列长度；
s = "刘海龙" print(len(s)) z = bytes(s,encoding='utf-8') print(len(z)) 执行结果： 3 9
这个结果： Python2和3是不同的，中文字符Python3是按字符计算的，一个字是一个字符，支持通过bytes转为字节；
Python2是按字节计算的，一个中文字符等于2个gbk字节，3个utf8字节，并且不支持转为字符；
8）compile()、exec() 和eval()函数
1、compile(source, filename, mode[, flags[, dont_inherit]])
中文说明：
将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。
参数source：字符串或者AST（Abstract Syntax Trees）对象。
参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
参数model：指定编译代码的种类。可以指定为 ‘exec’,’eval’,’single’。
参数flag和dont_inherit：这两个参数暂不介绍，可选参数。
a = "print(123)" r = compile(a,"<string>" , "exec") exec(r) print(a) print(r) 执行结果： 123 print(123) <code object <module> at 0x00000000006C2F60, file "<string>", line 1>
过程解析：
a 是一个字符串，通过compile函数，将字符串编译成Python代码，exec 执行代码，得到print结果；
有三种模式（single、exec、eval）
通过exec可以执行动态Python代码，类似Javascript的eval功能；而Python中的eval函数可以计算Python表达式，并返回结果（exec不返回结果，print(eval("…"))打印None）；
s = "3*3" ret = eval(s) print(ret) 执行结果： 9 过程解析： s 变量是一个字符串3*3，不是可计算的数字类型，当使用eval函数执解析后，打印就会将s转换，并计算表达式，返回结果；
9） range(生成数字序列)、random（生成随机数）
range()的返回值，Python3和2的区别很大； a = range(5) print(a) 执行结果： range(0, 5) # 制作6位随机数小程序： import random li = [] for i in range(6): r = random.randrange(0,5) if r == 2 or r == 4: num = random.randrange(0,10) li.append(str(num)) else: temp = random.randrange(65,91) c = chr(temp) li.append(c) result = "".join(li) print(result)
过程解析：
加载random模块，准备一个空列表，循环6次（生成6个值），定义r在循环时，随机取0-5的值，如果r的值是2或是4时，随机取0-9的数字追加到列表，
其它值时取大写字母追加到列表，将列表通过join转为字符串，打印这个循环6次的字符串，即是6个随机数；
10）zip()函数
- 按列合并多个可迭代对象的列值，相同列的元素生成一个元组元素，当其中一个列的元素为空时，就不再继续生成；调用时，要指定类型调用；
a = (1,2,3,4,5) b = ['alex','wusir','hailong','dawang','eric'] c = {'filter','map','exec','eval'} ret = zip(a,b,c) print(list(ret)) 执行结果： [(1, 'alex', 'map'), (2, 'wusir', 'filter'), (3, 'hailong', 'exec'), (4, 'dawang', 'eval')]
过程解析：
定义三个不同的序列，使用zip函数合并列值，相同列的元素生成一个元组元素，当c的值没有第五个值的时候，就不再继续生成了，结果就是，在内存里生成了四个元组元素；
打印返回值时，要使用相应的序列函数转换，可以使用列表、元组或集合内置函数转换成相应类型使用； 本实例使用list函数转换成列表；
三. 装饰器
3.1 Python程序的执行顺序
def f1(): print(123) def f1(): print('abc') f1() # 函数执行结果： abc # 过程解析： 定义两个相同的函数，输出不同的内容，当在下方调用此函数时，执行的是最后定义的函数；
画个图：
实例二：
# 函数和执行函数的表示方法 def func(): print('func') func # 表示函数 func() # 表示执行func函数 # lambda创建函数，以及相同函数的执行顺序： def func(): print('func') func = lambda a: a + 3 print(func(4)) 备注：lambda表达式只是创建一个函数，并不执行；
3.2 装饰器是什么？如何使用？
装饰器就是把函数包装一下，为函数添加一些附加功能，装饰器就是一个函数，参数为被包装的函数，返回包装后的函数；
实例讲解：
def d(fp): def _d(*arg, **karg): print("do sth before fp..") r= fp(*arg, **karg) print("do sth after fp..") return r return _d @d def f(f): print("call" ,f) #上面使用@d来表示装饰器和下面是一个意思 #f = d(f) # 执行函数f f("hailong") # 执行结果： do sth before fp.. call hailong do sth after fp..
# 过程解析：
定义一个d函数，返回值是嵌套在函数里的函数的返回值；函数本身是不执行的，只是加载到内存里，当使用@d时，就是给下面的函数加一个d函数的装饰器；
@d会自动执行d函数，并且把@d下面的f函数，作为d函数的参数使用，然后将d函数的返回值，赋值给下面的f函数；
@d 装饰器的执行过程，如下图：
执行函数过程，关系变化，如图：
注意点：
函数参数的使用个数 ，实例中装饰器函数的内部函数参数使用的是可变长参数，这样当f函数传入参数时，不受参数个数限制；
四. 做练习题
孰能生巧，要多做练习；
编写用户管理程序 ：
普通用户： 登录、注册、修改密码、查看本用户信息；
管理用户： 1、 登录、注册、修改密码、查看本用户信息；
2、 删除添加普通用户，修改普通用户密码；
3、 查看所有普通用户信息，按照指定关键字搜索用户信息；
4、 提高普通用户权限；
提示：
1. 用户信息：文件，如 hailong|123|hail@gmail.com|dianhua|....
2. 权限用装饰器