Python基础——函数（200512）

Python——函数

函数

1.函数概述：

　　函数：用于完成特定功能的一段代码块，可用于重复使用。函数能够提高应用的模块性，和代码的利用率；函数包含内置函数和用户自定义的函数两种。

2.为什么使用函数：

• 代码可以重复使用，提高代码的利用率

• 保持代码一致性，易维护

• 可扩展性

定义函数

1.定义一个函数

　　1）可以定义一个特定功能的函数，规则如下：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明
• 函数内容以冒号起始，并且缩进
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None

　　2）语法：

def function(x):
  '''函数说明文档'''
    x += 1
    return expression
function(2)

# def:定义函数的关键字
# function:函数名
# （）：括号内可以设置参数，形参
# x += 1:泛指代码块或程序处理逻辑
# return expression：定义返回值
# function(2):传入实参

　　3）举例：定义一个打印 hello + name 的函数

def greet(name):
    '''打招呼函数'''
    mes = 'hello %s !'%name
    return mes
res = greet('alex')
print(res)
# =>hello alex !

2.函数返回值

　　1）函数和过程

• 过程：没有return返回值的函数
• 函数：有return返回值

　　2）返回值

　　return [expression] 语句：退出函数，函数运行到return语句就是直接退出函数，不会再继续运行函数体内return下面的语句。return返回值。

　　<1>  默认返回值

　　默认返回值：在函数体内部若无return返回值，则默认返回None，return是函数结束的标志。

def greet(name):
    print('hello %s !'%name)
print(greet('张三'))
# =>hello 张三 !
# =>None

　　<2> 1个返回值

　　有1个返回值：指定了返回值

def greet(name):
    print('hello %s !'%name)
    return '你真棒！'
print(greet('张三'))
# =>hello 张三 !
# =>你真棒！

　　<3> 多个返回值

　　多个返回值：指定了多个返回值，当有多个返回值时，以元组形式返回，内含多个值

def greet(name):
    print('hello %s !'%name)
    return '你真棒！','Are you OK!','666'
print(greet('张三'))
# =>hello 张三 !
# =>('你真棒！', 'Are you OK!', '666')

3.函数参数

　　1）形参和实参

• 形参：形参在函数被调用时使用，只在函数体内部有效
• 实参：可以是常量、变量、表达式、函数等，函数调用时将值传递给形参

def calc(x,y):  # x,y :形参
    result = x+y
    return result
c = calc(1,2) # 1,2:实参(具体数值)
print(c)
# =>3

　　2）位置参数

　　位置参数：传递的实参个数与形参必须一一对应，少一个和多一个都不行，不对应会报错

# 一一对应
def position(x,y,z):
    print(x)
    print(y)
    print(z)
position(1,2,3)
# =>1
# =>2
# =>3

# 不对应
def position(x,y,z):
    print(x)
    print(y)
    print(z)
position(1,2,3,4)
# =>报错

　　3）关键字参数

　　关键字参数：对形参无需对应，但必须进行一一指定 ，少一个和多一个都不行，否则会报错

def key(x,y,z):
    print(x)
    print(y)
    print(z)
key(x=1,y=2,z=3)
# =>1
# =>2
# =>3

　　4）位置和关键字参数混合使用

　　位置和关键字参数混合使用：位置参数必须在左边也就是前边，关键字参数在后面，一一对应 关系，多个值会报错

def position_key(x,y,z):
    print(x)
    print(y)
    print(z)
position_key(1,2,z=3)
# =>1
# =>2
# =>3

position(1,y=2,3) 
# =>报错

　　5）默认参数

　　默认参数：定义了默认形参，实参就可以不用传递，若传递会覆盖默认参数

def default(x,type='King'):   # type='King'：为默认参数
    print(x)
    print(type)
default('hello')   # 不对默认参数进行传递
# =>hello
# =>King
default('hello','lisi')   # 对默认参数进行传递，会覆盖原有参数
# =>hello
# =>lisi

　　6）参数组

　　参数组：（**字典；*列表）传递可变长参数

def test(x,*args):  # *：作为列表存储
    print(x)
    print(args)   # 作为元组输出
test(1,2,3,4,5)
# =>1
# =>(2, 3, 4, 5)

def test(x,**kwargs):  # **：作为字典存储
    print(x)
    print(kwargs)   # 作为字典输出
test(1,y=2,z=3)
# =>1
# =>{'y': 2, 'z': 3}

def test(x,*args,**kwargs):  # 可以接受多个值
    print(x)
    print(args)  # 作为元组输出
    print(kwargs)   # 作为字典输出
test(1,2,3,4,5,6,7,y=2,z=3)
# =>1
# =>(2, 3, 4, 5, 6, 7)
# =>{'y': 2, 'z': 3}
test(1,*[1,2,3],**{'y':2,'z':3})
# =>1
# =>(1, 2, 3)
# =>{'y': 2, 'z': 3}

　　7）参数集合实例

# 第1种：1传给x；2传给y；3传给z
def func(x,y,z):
    print(x,y,z)
func(1,2,3)
# =>1 2 3

# 第2种：1传给x；3传给z；3传给y,改变y的默认值
def func(x,z,y=5):
    print(x,y,z)
func(1,3,3)
# =>1 3 3

# 第3种：1传给x; 2传给y; 3,4,5,6作为元组传给*z
def func(x,y,*z):
    print(x,y,z)
func(1,2,3,4,5,6)
# =1 2 (3, 4, 5, 6)

# 第4种:1传给x; 2,3作为元组传给*z；**y无元素传递为空字典
def func(x,*z,**y):
    print(x,y,z)
func(1,2,3)
# =>1 {} (2, 3)

# 第5种:1传给x; name=2,age=3键值对传给**z形成字典；*y无元素传递为空元组
def func(x,*y,**z):
    print(x,y,z)
func(1,name=2,age=3)
# =>1 () {'name': 2, 'age': 3}

# 第6种:1传给x；2,3,4作为元组传给*y；name=2,age=3键值对传给**z形成字典
def func(x,*y,**z):
    print(x,y,z)
func(1,2,3,4,name=2,age=3)
# =>1 (2, 3, 4) {'name': 2, 'age': 3}

# 第7种:name=2,age=3键值对传给**z成为字典；x=2为默认值无元素传递则继续为默认值2；*y无元素传递为空元组
def func(x=2,*y,**z):
    print(x,y,z)
func(name=2,age=3)
# =>2 () {'name': 2, 'age': 3}

# 第8种：1,2,3,4,5作为元组传给*y；**z无元素传递为空字典
def func(*y,**z):
    print(y,z)
func(1,2,3,4,5)
# =>(1, 2, 3, 4, 5) {}

# 第9种：[1,2,3,4,5]作为一个元素传给*y形成包含列表的元组；**z无元素传递为空字典
def func(*y,**z):
    print(y,z)
func([1,2,3,4,5])
# =>([1, 2, 3, 4, 5],) {}

# 第10种：*[1,2,3,4,5]有星号直接传给*y，直接中括号变小括号形成元组；**z无元素传递为空字典
def func(*y,**z):
    print(y,z)
func(*[1,2,3,4,5])
# =>(1, 2, 3, 4, 5) {}

# 第11种：*[1,2,3,4,5]有星号直接传给*y，直接中括号变小括号形成元组；name=2,age=3键值对传给**z形成字典
def func(*y,**z):
    print(y,z)
func(*[1,2,3,4,5],name='alex',age=18)
# =>(1, 2, 3, 4, 5) {'name': 'alex', 'age': 18}

# 第12种：*[1,2,3,4,5]有星号直接传给*y，直接中括号变小括号，{'name':'alex','age':18}无双星号，也作为一个元素最终形成元组；**z无元素传递为空字典
def func(*y,**z):
    print(y,z)
func(*[1,2,3,4,5],{'name':'alex','age':18})
# =>(1, 2, 3, 4, 5, {'name': 'alex', 'age': 18}) {}

# 第13种：*[1,2,3,4,5]有星号直接传给*y，直接中括号变小括号形成元组；**{'name':'alex','age':18}有双星号，直接作为字典传递，形成字典
def func(*y,**z):
    print(y,z)
func(*[1,2,3,4,5],**{'name':'alex','age':18})
# =>(1, 2, 3, 4, 5) {'name': 'alex', 'age': 18}

# 第14种
def func1(x=1,*y,**z):
    print(x,y,z)
    return y
    print(x)
def func2(arg):
    ret = func1(name=arg)
    print(ret)
res = func2('alex')
print(res)
# =>1 () {'name': 'alex'}
# =>()
# =>None

# 第15种
def func(arg):
    arg.append(55)
li = [11,22,33,44]
func(li)
print(li)
# =>[11, 22, 33, 44, 55]
li = func(li)
print(li)
# =>None

# 第16种
def func1(arg):
    print(arg+100)
def func2(arg):
    ret = func1(arg+1)
    print(arg)
    print(ret)
ret = func2(7)
print(ret)
# =>108
#   7
#   None
#   None

4.函数作用域

　　一个程序内变量的访问不是随处都可以进行访问的，访问权限决定于变量在哪里被赋值。

　　函数的作用域决定了在哪一部分可以访问哪个特定的变量名称，两种最基本的变量作用域为：

• 全局变量
• 局部变量

　　1）函数作用域

　　函数作用域：与函数的调用位置无关，只与存在位置有关

　　<1> 一般函数作用域

def one():
    print('666')
one()
# =>666
print(one)  # 打印one的内存地址
# =><function one at 0x000002004BC95438>
print(one())
# =>666
# =>None

　　<2> 嵌套函数作用域

name = '张三'
def find_name():
    name = '李四'
    def find_name_one():
        name = '王二麻子'
        def find_name_two():
            name = '刘五'
            print(name)
        return find_name_two
    return find_name_one
# 方法一：
value = find_name()   # 得到的值为find_name_one的内存地址
print(value)
# =><function find_name.<locals>.find_name_one at 0x0000020068585678>
value_one = value()    # 运行find_name_one()函数，得到的值为find_name_two的内存地址
print(value_one)
# =><function find_name.<locals>.find_name_one.<locals>.find_name_two at 0x000001B114285708>
value_two = value_one()    # 运行find_name_two（）函数，打印‘刘五’，因函数中无返回值return，所以得到默认返回值None
print(value_two)
# =>刘五
# =>None
# 方法二
find_name()()()
# =>刘五
print(find_name()()())
# =>刘五
# =>None

5.局部变量与全局变量

　　1）局部变量和全局变量

• 局部变量和全局变量：在子程序中定义的变量称为局部变量，在程序一开始定义的变量称为全局变量。
• 当全局变量与局部变量同名时，在定义了局部变量的子程序内，局部变量起作用；其它地方全局变量起作用。

name = '李四'   # 全局变量，全部能够使用
def what_name():
    name1 = '王五'    # 局部变量，只能在函数体内使用，只能局部调用
    print('%s , %s' %(name,name1))
what_name()
# =>李四 , 王五
print(name)
# =>李四

　　2）global 关键字

　　<1> 函数内无 global 关键字

　　① 有声明局部变量：

• 优先读取局部变量；
• 能读取全局变量，无法对全局变量重新赋值，但是对于可变类型（集合、列表、字典），可对其内部元素进行操作

name = '李四'  # 不可变类型，全局变量
def what_name():   # 无global关键字，有局部变量声明
    name = '张三'   # 声明局部变量
    print(name)
print(name)  # 此处打印全局变量，局部变量没有对全局变量进行修改，还为调用函数
# =>李四
what_name()  # 此处进入函数what_name（）内，由于函数体内对变量name进行了声明修改，所以打印出来为局部声明的变量
# =>张三
print(name)  # 此处没有global关键字，函数体内对name进行了修改但是无法影响到全局变量name
# =>李四

li = [1,2,3,4,5]  # 可变类型，全局变量
def lis():
    li.append(111)   # 读取全局变量，对于可变类型列表内的元素进行操作
    print(li)
print(li)  # 没有运行函数体dis,全局变量没有变化
# =>[1, 2, 3, 4, 5]
lis()  # 运行了函数，对列表li进行了元素添加修改
# =>[1, 2, 3, 4, 5, 111]
print(li)   # 无global关键字，但函数体内可以对可变类型进行修改
# =>[1, 2, 3, 4, 5, 111]

　　② 无声明局部变量

　　无声明局部变量：如果有对变量的操作，直接读取全局变量，不能对其赋值，只能读取

name = '李四'  # 不可变类型，全局变量
def what_name():   # 无global关键字，无局部变量声明，直接读取全局变量
    print(name)
print(name)  # 此处打印全局变量，无局部变量声明，所以不对其进行修改
# =>李四
what_name()  # 此处进入函数what_name（）内，无局部变量声明，直接读取全局变量name
# =>李四

　　<2> 函数内有 global 关键字

　　注意：global 变量，读取全局变量，局部变量与全局变量相同时，对其进行修改；若不相同时，函数体外部可以调用函数体内的局部变量。global 变量要放在声明变量的前面也就是上面，让global 先执行，在声明变量。

　　① 有声明局部变量

name = '李四'  # 不可变类型，全局变量
def what_name():   # 有global关键字，有局部变量声明
    global name    # 修改全局变量name,由'李四'变为‘张三’，不仅函数体可以使用，函数体外也可以使用。（注意前提：程序是从上而下执行，如果没有执行函数体内的代码块，则变量只为全局变量）
    name = '张三'   # 声明局部变量
    print(name)
print(name)  # 此处因为还没有执行函数what_name（）代码块，所以直接打印全局变量
# =>李四
what_name()  # 此处进入函数what_name（）代码块内，局部变量name进行了声明变为‘张三’，将其变为全局变量，所以之后操作无论函数体内还是函数外变量name已发生了变化，变为‘张三’
# =>张三
print(name)  # 此处由于前面执行了what_name（）函数，局部变量name发生变化，变为全局变量，所以name改变，变为“张三”
# =>张三

　　② 无声明局部变量

name = '李四'  # 不可变类型，全局变量
def what_name():   # 有global关键字，无局部变量声明，直接读取全局变量
    global name1    # 将name1变量变为全局变量，之后name1变量函数体内外皆可使用（前提：name1要想在函数体外使用，必须先执行函数体）
    print(name)
print(name)  # 此处没有运行函数，直接打印全局变量
# =>李四
what_name()  # 此处进入函数what_name（）代码块内，变量name没有发生变化，所以执行结果还是为全局变量的值
# =>李四
# print(name1)  # 报错！！！（name1在函数体what_name内，虽然global是全局变量，但没有对其进行赋值操作，所以无法打印，报错！）

6.嵌套函数

　　嵌套函数：在一个函数中定义了另外一个函数　　

　　1）第1种

NAME = '张三'  # 1
def one():  # 2
    name = '一层函数' # 3
    print(name)  # 4
    def two():  # 5
        name = '二层函数'  # 6
        print(name)  # 7
        def three():  # 8
            name = '三层函数'  # 9
            print(name)  # 10
        three()  # 11
        print(name)  # 12
    two()  # 13
    print(name)  # 14
one() # 15
# =>一层函数
# =>二层函数
# =>三层函数
# =>二层函数
# =>一层函数

# 代码总体执行顺序：1->2（将整个代码块加载如内存）->15->3->4->5（加载入内存）->13->6->7->8（加载入内存）->11->9->10->12->14
# 打印结果执行顺序：4->7->10->12->14

　　2）第2种

name = '张三'
def one():
    name = '李四'
    def one_one():
        global name   # global 声明全局变量
        name = '王二麻子'
    one_one()
    print(name)
print(name)
# =>张三
one()
# =>李四
print(name)
# =>王二麻子

name = '张三'
def one():
    name = '李四'
    def one_one():
        nonlocal name   # nonlocal 声明上一级变量
        name = '王二麻子'
    one_one()
    print(name)
print(name)
# =>张三
one()
# =>王二麻子
print(name)
# =>张三

　　3）第3种

def father(name):
    print('I am father %s'%(name))
    def son():
        print('I am son')
    print(locals())   # 打印当前层的局部变量
father('alex')
# =>I am father alex
# =>{'name': 'alex', 'son': <function father.<locals>.son at 0x0000022AD8C85288>}

7.前向引用

　　1）风湿理论

　　风湿理论：函数即变量

　　在函数使用之前必须要有定义，定义后才能使用

def one():
    print(1)
    two()
def two():
    print(2)
one()
# =>1
# =>2

 8.递归函数

　　1）递归函数

　　递归函数：在函数内部，可以调用其他函数，如果一个函数在内部调用自己本身，这个函数就是递归函数。

　　2）递归函数特性

• 必须有一个明确的结束条件
• 每次进入更深一层递归时，问题规模相比上次都应有所减少
• 递归效率不高，递归层次过多会导致栈溢出

　　3）案例

　　<1> 案例1

import time
person_list = ['张三','李四','王二麻子','刘五']
def ask_way(person_list):
    print('-'*100)
    if len(person_list) == 0:
        return '无人知道路！'
    person = person_list.pop(0)
    if person == '王二麻子':
        return '王二麻子说：我知道路，沙坡头在中国宁夏中卫！'
    print('你好！帅哥%s，请问一下沙坡头在哪里？'%person)
    print('%s回答道：我不知道，你等着，我帮你问问%s'%(person,person_list))
    time.sleep(1)
    res = ask_way(person_list)
    print('%s问的结果是：%s'%(person,res))
    return res
res = ask_way(person_list)
print(res)
# =>----------------------------------------------------------------------------------------------------
# =>你好！帅哥张三，请问一下沙坡头在哪里？
# =>张三回答道：我不知道，你等着，我帮你问问['李四', '王二麻子', '刘五']
# =>----------------------------------------------------------------------------------------------------
# =>你好！帅哥李四，请问一下沙坡头在哪里？
# =>李四回答道：我不知道，你等着，我帮你问问['王二麻子', '刘五']
# =>----------------------------------------------------------------------------------------------------
# =>李四问的结果是：王二麻子说：我知道路，沙坡头在中国宁夏中卫！
# =>张三问的结果是：王二麻子说：我知道路，沙坡头在中国宁夏中卫！
# =>王二麻子说：我知道路，沙坡头在中国宁夏中卫！

　　<2> 案例2

def calc(n):
    print(n)
    if int(n/2) == 0:
        return n
    res = calc(int(n/2))
    return res
calc(10)   # 不带返回值
# =>10
# =>5
# =>2
# =>1
print(calc(10))   # 带返回值
# =>10
# =>5
# =>2
# =>1
# =>1

9.匿名函数

　　Python 采用 lambda 关键字创建匿名函数

• lambda 只是一个表达式，函数体比 def 简单很多
  
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去
• lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率

　　1）语法

lambda x:x+1   # 匿名函数（格式）：lambda 形参：返回值

　　2）举例

# 常规函数
def calc(x):
    return x+1
res = calc(10)
print(res)
# =>11 

# 匿名函数
lambda x:x+1   # 匿名函数（格式）：lambda 形参：返回值
print(lambda x:x+1)   # 打印内存地址
# =><function <lambda> at 0x000001A4111E5318>
func = lambda x:x+1
print(func(10))
# =>11

10.编程的方法论

　　1) 面向过程编程

 　　面向过程编程：找到解决问题的入口，按照一个固定的流程去模拟解决问题的流程。

　　如：

　　<1> 搜索目标，用户输入（配偶要求，按照要求到数据结构（字典）内检索合适的人群）；

　　<2> 表白：表白成功进入<3>,否则进入<2>;

　　<3> 恋爱：恋爱成功进入<4>,否则返回<1>;

　　<4> 见家长：家长同意进入<5>,家长说你是她失散多年的妹妹，返回<1>

　　<5> 结婚。

　　2）函数式编程

　　函数式编程：函数式=编程语言定义的函数+数学意义的函数

　　通俗讲，函数式就是用编程语言来实现数学函数，这种函数内对象是永恒不变的，要么参数是函数，要么返回值是函数；没有 for 和 while 循环，所有的循环都由递归实现，无变量的赋值（即不用变量去保存状态），无赋值即不改变。

　　函数式编程的特征：

　　<1> 不可变数据

• 不可变：不用变量保存状态，不修改变量

　　例1：数学函数表达式：y = 2*x + 1,用函数实现

# 函数式编程：省去复杂的中间过程，但可读性较差
def calc(x):
    return 2*x+1

# 面向过程编程：细化过程，每一个过程都较为详细，可读性比较高，但教繁琐
def calc(x):
    res = 2*x
    res += 1
    return res

　　<2> 第一类对象

　　第一类对象：函数即“变量”

　　高阶函数两个特征（满足其一变为高阶函数）：

• 函数接收的参数是一个函数名
• 返回值中包含函数名

# 第1种：把函数当做参数传给另外一个函数
def foo(n):
    print(n)
def bar(name):
    print('my name is %s'%name)
foo(bar('alex'))
# =>my name is alex
# =>None


# 第2种：返回值中包含函数
def bar():
    print('from bar')
def foo():
    print('from foo')
    return bar
n = foo()  # 运行foo()函数
# =>from foo
n()   # 运行foo()
# =>from bar

def handle():
    print('from handle')
    return handle
h = handle()
# =>from handle
h()
# =>from handle

　　<3> 尾调用优化（尾递归）

　　尾调用：在函数的最后一步调用另外一个函数（最后一行不一定是函数的最后一步）

# 第1种：函数bar在foo内为尾递归
def bar(n):
    return n
def foo(x):
    return bar(x)

# 第2种：函数bar1和bar2在foo内均为尾调用，二者在if判断条件不同情况下都有可能作为函数的最后一步
def bar1(n):
    return n
def bar2(n):
    return n+1
def foo(x):
    if type(x) is str:
        return bar1(x)
    elif type(x) is int:
        return bar2(x)
    
# 第3种：函数bar在foo内为非尾调用
def bar(n):
    return n
def foo(x):
    y = bar(x)
    return y

# 第4种：函数bar在foo内为非尾调用
def bar(n):
    return n
def foo(x):
    return bar(x)+1

Python内置函数

　　1.abs():返回数字的绝对值。

　　举例：

print(abs(-100))
# =>-100

print(abs(250))
# =>250

print(abs(78.4))
# =>78.4

　　2.all():用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。元素除了是 0、空、None、False 外都算 True。

　　all()函数等价于：

def all(iterable):
    for element in iterable:
        if not element:
            return False
    return True

　　举例：

a = all((1,0,2))
print(a)
# =>False
b = all(['',121,'sf'])
print(b)
# =>False
c = all({'我':'I','':''})
print(c)
# =>False
d = all([12,23,45])
print(d)
# =>True
e = all([[],34,'ok',True])
print(e)
# =>False
f = all([{},78,'df'])
print(f)
# =>False

　　3.any():用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。元素除了是 0、空、FALSE 外都算 TRUE。

　　any() 函数等价于：

def any(iterable):
    for element in iterable:
        if element:
            return True
    return False

　　举例：

a = any((1,0,2))
print(a)
# =>True
b = any(['',121,'sf'])
print(b)
# =>True
c = any({'我':'I','':''})
print(c)
# =>True
d = any([12,23,45])
print(d)
# =>True
e = any([[],34,'ok',True])
print(e)
# =>True
f = any([{},78,'df'])
print(f)
# =>True
g = any([[],'',0,False])
print(g)
# =>False

　　4.bin():返回一个整数 int 或者长整数 long int 的二进制表示.0b表示二进制。

　　举例：

a = bin(120)
print(a)
# =>0b1111000

　　5.bool():用于将给定参数转换为布尔类型，如果没有参数，返回 False。

　　举例：

a = bool(0)
print(a)
# =>False
b = bool([])
print(b)
# =>False
c = bool('I love you')
print(c)
# =>True

　　6.bytes():将字符串转换为字节数。

　　举例： 

a = 'I love you!!!'
print(bytes(a,encoding='utf-8'))
# =>b'I love you!!!'
print(bytes(a,encoding='utf-8').decode('utf-8'))
# =>I love you!!!

　　7.chr():用一个范围在 range（256）内的（就是0～255）整数作参数，返回一个对应的字符,按照ASCII表进行转换。

　　举例：

a = chr(50)
print(a)
# =>2
b = chr(78)
print(b)
# =>N

　　8.dir():获取某一对象下的方法属性。

　　举例：

a = dir(tuple)
print(a)

　　9.dict():用于创建一个字典。

　　举例：

a = dict()
print(a,type(a))
# =>{} <class 'dict'>
b = dict(a=12,b=23)
print(b,type(b))
# =>{'a': 12, 'b': 23} <class 'dict'>

 　　10.divmod():把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b).可用于分页使用。

　　举例：

a = divmod(10,3)  # 可用于分页，如制作网页时，总共有10条信息，1页只显示3条，可使用divmod（）函数进行分页
print(a)
# =>(3, 1)
b = divmod(15,3)
print(b)
# =>(5, 0)

　　11.enumerate():用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

　　语法：

enumerate(sequence,[start = 0])

　　参数：

　　sequence:一个序列、迭代器或其他支持迭代对象

　　start:下标起始位置

　　举例：

a = ['张三','李四','王二麻子']
print(list(enumerate(a,1)))
# =>[(1, '张三'), (2, '李四'), (3, '王二麻子')]
b = {'name':'alex','age':18,'tel':'1234546'}
for i,o in enumerate(b.values(),1):
    print(i,o)
# =>1 alex
# =>2 18
# =>3 1234546

　　12.eval():①提取字符串中的数据结构；②可以将字符串中的数学运算进行计算。

　　举例：

a = eval('2*7')
print(a)
# =>14
b = eval('[11,22,33]')
print(b[1],type(b))
# =>22 <class 'list'>

　　13.filter()：①用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。返回迭代器对象；②该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

　　举例：

a = filter(lambda x:x%2==1,[1,2,3,4,5,6,7,8,9])  # 过滤出列表中的奇数
print(list(a))
# =>[1, 3, 5, 7, 9]
def func(x):
    return x == True
b = [[],{},False,0,True,'',111]
c = list(filter(func,b))
print(c)
# =>[True]

　　14.float():用于整数和字符串转换为浮点数。

　　举例：

a = float(13)
print(a)
# =>13.0
b = float('78.4')
print(b)
# =>78.4

　　15.format():用于字符串格式化。

　　举例：

a = 'my name is {} ,age {}'.format('alex',18)
print(a)
# =>my name is alex ,age 18
b = 'my name is {name} ,age {age}'.format(name='alex',age=18)
print(b)
# =>my name is alex ,age 18

　　16.frozenset():创建一个冻结的集合，冻结后集合不能再添加或删除任何元素。

　　举例:

a = frozenset(range(1,10))
print(a)
# =>frozenset({1, 2, 3, 4, 5, 6, 7, 8, 9})

　　17.hash():进行哈希运算。①可哈希的（不可变类型）；②不可哈希的（可变类型）,返回对象的哈希值。

　　举例：

a = 'I love you'
print(hash(a))
# =>9013143733982312212
b = (1,2,3)
print(hash(b))
# =>2528502973977326415
c = 1
print(hash(c))
# =>1

　　18.help():用于查看函数或模块用途的详细说明。

　　举例：

print(help(list))   # 查看list的详细说明

　　19.hex():十进制转换为十六进制（0x：十六进制）。

　　举例：

# ---实例
a = hex(5)
print(a)
# =>0x5
b = hex(45)
print(b)
# =>0x2d

　　20.oct():十进制转换为八进制（0o：八进制）。

　　举例：

a = oct(12)
print(a)
# =>0o14
b = oct(111)
print(b)
# =>0o157

　　21.id():获取对象的内存地址。

　　举例：

a = id('i love you')
print(a)
# =>2232217431280

　　22.globals():打印当前位置的全局变量。

　　23.locals():打印当前位置的局部变量。

　　24.input():输入。

　　举例：

a = input('你的名字：')
print(a)
# =>你的名字：alex
# =>alex

　　25.int():将一个字符串或数字转换为整型。

　　举例：

a = '123'
print(int(a),type(a))
# =>123 <class 'str'>
b = 78.3
print(int(b),type(b))
# =>78 <class 'float'>

　　26.len():返回对象（字符、列表、元组等）长度或项目个数。

　　举例：

print(len('i love you'))
# =>10
print(len([1,2,3,4,5,6]))
# =>6

　　27.list():用于创建列表。

　　举例：

a = 'I love you'
print(list(a))
# =>['I', ' ', 'l', 'o', 'v', 'e', ' ', 'y', 'o', 'u
b = (1,2,3,4)
print(list(b))
# =>[1, 2, 3, 4]

　　28.map():①根据提供的函数对指定序列做映射，返回迭代器对象；②第一个参数function以参数序列中的每一个元素调用function函数，返回包含每次function函数返回值的新列表。

　　举例：

a = map(lambda x:x*100,[1,2,3,4,5,6,7,8,9])
print(list(a))
# =>[100, 200, 300, 400, 500, 600, 700, 800, 900]
def func(x):
    return x**2
b = [12,13,14]
c = list(map(func,b))
print(c)
# =>[144, 169, 196]

　　29.max():返回给定参数的最大值，参数可以为序列。

　　举例：

print(max(12,32,45,23,50))
# =>50
print(max(['bs','fb','ok']))
# =>ok

　　30.min():返回给定参数的最小值，参数可以为序列。

　　举例：

print(min(12,32,45,23,50))
# =>12
print(min(['bs','fb','ok']))
# =>bs

　　31.next():①返回迭代器的下一个项目；②next() 函数要和生成迭代器的iter() 函数一起使用。

　　举例：

a = 'Interesting'
b = iter(a)
print(next(b))
# =>I
print(next(b))
# =>n
print(next(b))
# =>t

mes = iter([1,2,3,4,5])
while True:
    try:
        x = next(mes)
        print(x)
    except StopIteration:
        break
# =>1
# =>2
# =>3
# =>4
# =>5

　　32.ord():将一个字符转化为ASCII中相对应的数字。

　　举例：

print(ord('!'))
# =>33
print(ord('a'))
# =>97

　　33.pow(x,y,z): 两个参数幂运算,三个参数先取幂运算再除第三个参数所得出的余数。

　　举例：

print(pow(10,3))
# =>1000
print(pow(15,2,2))
# =>1

　　34.print():打印输出。

　　举例：

print('Hello world!')
# =>Hello world!

　　35.range():range(start,stop,step)可创建一个整数列表，一般用在for循环中。

　　举例：

a = range(1,10)
print(a)
# =>range(1, 10)
b = range(2,25,3)
print(b)
# =>range(2, 25, 3)
c = 'love'
for i in range(1,3):
    print(i)
# =>1
# =>2

　　36.reduce():①使用前需要导入模块“from functools import reduce”；②对参数序列中元素进行累积，返回运算结果数值；③函数将一个数据集合（链表、元组等）中的所有数据进行下列操作：用传给reduce中的函数function(有两个参数)先对集合中的第1、2个元素进行操作，得到的结果再与第三个数据用function函数运算，最后得到一个结果。

　　举例：

from functools import reduce
print(reduce(lambda x,y:x+y,[12,13,14,15,16]))
# =>70

　　37.reverse():用于反转列表中的元素。

　　举例：

a = [234,45,123,34]
a.reverse()
print(a)
# =>[34, 123, 45, 234]

　　38.reversed():返回一个反转的迭代器。

　　举例：

a = 'love you'
print(list(reversed(a)))
# =>['u', 'o', 'y', ' ', 'e', 'v', 'o', 'l']
b = [234,76,34,89]
print(list(reversed(b)))
# =>[89, 34, 76, 234]

　　39.round():返回浮点数x的四舍五入值。

　　举例：

print(round(23.456))
# =>23
print(round(78.98))
# =>79

　　40.set():创建一个无序不重复元素集合，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

　　举例：

print(set('i love you'))
# =>{'v', 'l', 'o', 'e', ' ', 'i', 'y', 'u'}
print(set([12,23,43,56,12,87,23]))
# =>{43, 12, 23, 87, 56}

　　41.slice():设置切片。

　　举例：

# 方法一：
mes = 'interesting'
print(mes[3:7])
# =>eres

# 方法二：
mes = 'interesting'
a = slice(3,7)   # 设置切片
print(mes[a])
# =>eres
b = slice(1,10,2)   # 可设置步长
print(mes[b])
# =>neetn

　　42.sorted():排序（从小到大）,排序本质比较大小，不同类型数据不能排序。

　　举例：

a = [12,43,54,11]
print(sorted(a))
# =>[11, 12, 43, 54]

　　43.str():将对象转换为字符串。

　　举例：

a = 12345
b = str(a)
print(b,type(b))
# =>12345 <class 'str'>

　　44.sum():对系列进行求和计算。

　　举例：

a = [12,43,54,11]
print(sum(a))
# =>120

　　45.tuple():创建一个元组。

　　举例：

a = 'interesting'
print(tuple(a))
# =>('i', 'n', 't', 'e', 'r', 'e', 's', 't', 'i', 'n', 'g')
b = [12,43,54,11]
print(tuple(b))
# =>(12, 43, 54, 11)

　　46.type():返回数据的类型。

　　举例：

print(type(111))
# =><class 'int'>
print(type('ok'))
# =><class 'str'>
print(type([11,22,33]))
# =><class 'list'>
print(type({'ok':'好'}))
# =><class 'dict'>

　　47.zip():①拉链函数（左右一一对应）；②用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

　　举例：

print(list(zip(('a','b','c'),(1,2,3))))
# =>[('a', 1), ('b', 2), ('c', 3)]
dic = {'name':'alex','age':24,'money':10000}
print(list(zip(dic.keys(),dic.values())))
# =>[('name', 'alex'), ('age', 24), ('money', 10000)]