Python函数1

1. 函数

• 优点：代码可复用，代码可维护性高，容易排错，可读性好，利于团队开发

1.1 定义函数

# 语法
'''
def 函数名 ([参数1],[参数2],...[参数n])：
   '''注释 '''
    函数体
    
函数名：名命名规则同变量名，满足标识符命名规则，不能与系统函数重名，风格见名知其意
参数n ：用于向函数中传递，如果有多个参数用','分隔，如不指定表示该函数没有参数，在调用不指定参数，在没有函数参数也要保留小括号
注释  ：说明该函数功能说明，要传递参数作用
函数体：实现功能得代码段，相对def关键字，必须保持一定得缩进      
'''

1.2 函数创建和调用

# 创建乘法表
def table(row,col):
    '''
    :param row: 行
    :param col: 列
    :return: 乘法表
    '''
    for i in range(1,row + 1):
        for j in range(1,col + 1):
            if j <= i:
                print("%d*%d=%2d" % (i,j,i * j),end=" ")
        print('')

# 函数调用
# 语法：函数名([参数])
table(9,9)  # 打印99乘法表

2.参数

2.1 形参与实参

• 形式参数：定义函数时，函数名后面括号中参数为"形式参数"，也称形参。
• 实际参数：在调用一个函数时，函数名后面括号中得参数为”实际参数“，也称实参

# 形参： 函数定义的时候小括号里的参数叫形参
# 求圆的面积，r代表形参
def area(r):
    return 3.14 * r * r

# 函数调用的时候所传的参数，叫实参数字10实参
print(area(10))

2.2 位置参数

• 位置参数，必须按照正确顺序传递到函数中，调用时数量必须与定义一致，位置必须与定义一直。

def say_hello(name,age,home):
    print('大家好，我是{},我今年{}岁了,我来自{}'.format(name,age,home))

# 调用函数数量位置必须与定义形参保持一致
say_hello('宫园薰','18','东京')  # 输出：大家好，我是宫园薰,我今年18岁了,我来自东京

2.3 关键字参数

• 关键字参数，用形参的名字来确定输入的参数值，通过指定实参，不需要与形参位置完全一致，只要将形参参数名写正确即可

def say_hello(name,age,home):
    print('大家好，我是{},我今年{}岁了,我来自{}'.format(name,age,home))

# 调用函数指定形参确定参数值
say_hello(age=18,home='东京',name='有马公生') # 大家好，我是有马公生,我今年18岁了,我来自东京

2.4 为参数设置默认值

• 调用函数，如没指定某个参数，会抛出异常，所以定义函数，可以定义形式参数默认值，没有参数传递时，使用定义函数时设置默认值。
• 定义函数时，指定默认的形参必须在所以参数的最后，否则将产生语法错误
• 默认值必须时不可变对象，默认只计算一次
• 在Python中，使用"函数名.defaults",查看函数的默认值，结果是一个元组

# 使用可变对象为函数参数默认值，多次调用导致意外情况，如下
def demo(j=[]):
    print("j的值：",j)
    j.append(1)
demo()  # obj的值： []
demo()  # obj的值： [1]

# 使用None作为可变对象默认值
def dem(j=None):
    if j == None:
        j = []
    print("j的值：",j)
    j.append(1)
dem()  # j的值： []
dem()  # j的值： []

2.5 可变参数

• 可变参数，传入的参数个数是可变的，可以是1个，2个到任意个，还可以是0个
• 定义可变参数，主要有两种形式：一种*parameter,吗，另一种**parameter

# *parameter将接收到任意多个参数存放到一个元组中
def anime(*name):
    print('\n我喜欢的动漫有：')
    for item in name:
        print(item)
anime('四月是你的谎言','火影忍者','海贼王','妖精的尾巴')
'''
输出：
我喜欢的动漫有：
四月是你的谎言
火影忍者
海贼王
妖精的尾巴
'''
# 如果使用已存在列表作为可变参数
list = ['火影忍者','死神','你的名字']
anime(*list)
'''
输出：
我喜欢的动漫有：
火影忍者
死神
你的名字
'''

# **parameter 接受任意多个显示赋值实际参数，并且放到一个字典中
def parameter(**sign):
    print()
    for key,value in sign.items():    # 遍历字典
       print(key + '属于' + value + '动漫中人物')

parameter(漩涡鸣人='火影忍者',路飞='海泽王')
parameter(夏露露='妖精的尾巴')
'''
输出：
漩涡鸣人属于火影忍者动漫中人物
路飞属于海泽王动漫中人物

夏露露属于妖精的尾巴动漫中人物
'''

# 如果已存在字典作为函数可变参数，在字典名字前加**
dict = {'纳兹':'妖精的尾巴','娜美':'海贼王'}
parameter(**dict)
'''
纳兹属于妖精的尾巴动漫中人物
娜美属于海贼王动漫中人物
'''

3.返回值

• return的作用一个是终止函数的执行，所有执行了return后其余的语句不会被执行
• 如果没有return语句，则默认返回的是None
• return还可以返回给调用这数值
• return可以返回一个值，如果要返回多个值，那么返回的是一个元组

# return返回Bmi的值
def bmi(height,wight):
    Bmi = wight/(height*height)
    return Bmi

print(bmi(height=1.7,wight=60))

4.pass空语句

• Python中有一个pass语句，表示空语句，不做任何事情，起到占位作用，或者保障语法完整。

def test():
	pass   # 占位置符 

5.文档字符串

• 函数文档字符串documentation string(docstring)是在函数开头，用来解释其接口的字符串，简而言之：帮助文档
• 包含函数的基础信息，功能简介，每个形参类型，使用信息
• 文档字符串书写规则：必须在函数首行，使用三引号注释的多行字符串(’’’ ‘’’)或(""" “”")，函数文档的第一行一般概述函数的主要功能，第二行空，第三行详细描述。

def test():
    '''
    函数名：test
    功能：测试
    参数：无
    :return: 无
    '''
    print("函数输出成功")

# 使用__doc__属性查看文档字符串
print(test.__doc__)
'''
输出：
    函数名：test
    功能：测试
    参数：无
    :return: 无
'''

6.变量的作用域

• 变量的作用域程序代码能够访问该变量区域，超出该区域访问就会出现错误
• 程序中根据变量有效范围，将变量分为局部变量，全局变量

6.1 局部变量

• 局部变量是指在函数体内部定义并使用的变量，只在函数体内有效

# 局部变量 在函数体外调用报错
def test():
   message = '希望如钻石般闪亮'
   print('局部变量message=' + message)
test()      # 可以正常调用
print('局部变量message=' + message)  # 函数体外调用报错：NameError: name 'message' is not defined

6.2 全局变量

• 全局变量能够作用函数体内外的变量，全局变量有两种情况
• 定义一个变量在函数体外，函数体内外都可以访问
• 在函数体内定义，使用global关键字修饰，该变量可以变为全局变量，在函数体外能访问，并且在函数体内可以对其进行修改
• 当局部变量与全局变量重名时，对函数体的变量进行复制后，不影响函数体外的变量
• 注意：尽管Python允许全局变量与局部变量可以重名，在实际开发中不建议这样操作，很容易让代码混乱，难以分清哪些时全局变量，哪些时局部变量

# 情况一：函数体外定义全局变量,函数体变量与全局变量同名，不影响全局变量的值
message = '希望如钻石般闪亮'                            # 全局变量
print('函数体外：message=' + message)                  # 输出：函数体外：message=希望如钻石般闪亮
def test():
    message = '我是否住进了你的心房'
    print('函数体内：message=' + message)
test()                                                # 输出：函数体内：message=我是否住进了你的心房
print('函数体外：message=' + message)                   # 输出：函数体外：message=希望如钻石般闪亮

# 情况二：定义局内变量使用global关键字修饰，可以看到函数体内修改全局变量的值
message = '希望如钻石般闪亮'                            # 全局变量
print('函数体外：message=' + message)                  # 输出：函数体外：message=希望如钻石般闪亮
def test():
    global message
    message = '我是否住进了你的心房'
    print('函数体内：message=' + message)
test()                                                 # 输出：函数体内：message=我是否住进了你的心房
print('函数体外：message=' + message)                   # 输出：函数体外：message=我是否住进了你的心房

7.匿名函数

• 没有函数名函数，应用需要一个函数，不想费神去命名这个函数，通常情况这样函数只能用一次
• Python中使用lambda表达式创建匿名函数

# 语法：result = lambda[arg1[,..,arg,arg2n]]:expression
# result:用于调用lambda表达式
# [arg1[,..,arg,arg2n]]:可选参数，用于要传递参数列表
# expression:必选参数，实现具体功能表达式
import math                                # 导入数学模块
r = 10                                     # 半径
result = lambda r:math.pi*r*r              # 计算圆面积lambda表达式
print('半径为',r,'圆的面积：',result(r))    # 输出：半径为 10 圆的面积： 314.1592653589793

8.常用Python内置函数

内置函数	作用
dict()	用于创建一个字典
help()	用于查看函数或模块用途的详细说明
dir()	不带参数时，返回当前范围内变量，方法和定义的类型列表；带参数时，返回参数的属性，方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息
hex()	用于将十进制整数转换为十六进制，以字符串形式表示
next()	返回迭代器的下一项目
divmod()	把除数和余数运算结合起来，返回一个包含商和余数的元组(a//b,a%b)
id()	用于获取对象内存地址
sorted()	对所有可迭代对象进行排序操作
ascii()	返回一个表示对象的字符串，但是对于字符串中的非ASCII字符则返回通过repr()函数使用\x,\u,或\U编码字符
oct()	将一个整数转化为八进制字符串
bin()	返回一个整数int或这长整数long int 的二进制形式
open()	用于打开一个文件
str()	将对象转化为始于人阅读的形式
sum()	对序列进行求和
filter()	用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新序列
format()	格式化字符串

9.作业

9.1 对加减乘除分别封装一个函数进行计算，参数是两个数，返回值是计算结果

# 定义加减乘除函数
ops = {'+':lambda x,y:x+y,
       '-':lambda x,y:x-y,
       '*':lambda x,y:x*y,
       '/':lambda x,y: (x/y) if y<0 or y > 0 else "被除数不能为0"
       }
a,op,b = input("请输入四则运算例如：1 + 1：").split(" ")
if op in ops:
    print(ops[op](float(a),float(b)))
else:
    print("不支持的运算符")

9.2 写函数，传入一个参数n,返回n的阶乘

# 定义阶乘函数
def factorial(c):
    fac = 1
    if c < 0:
        print('抱歉，负数没有阶乘')
    elif c == 0:
        print('0的阶乘为1')
    else:
        for i in range(1,c + 1):
            fac = fac * i
        print('%d的阶乘为%d'%(c,fac))

if __name__ == '__main__':
    num = int(input('请输入一个整数：'))
    factorial(num)

9.3 传入一个正整数，判断这个数是否是素数，如果是返回True,否则反馈False

# 定义素数函数
def prime_number(a):
    if a > 1:
        for i in range(2,a):
            if a % i == 0:
                return 'False'
        else:
            return 'True'
    else:
        return 'False'

# 主程序入口
if __name__ == '__main__':
    pr = prime_number(2)
    print(pr)

9.4 写函数，计算并返回传入字符串中数字个数，字母个数，空格个数以及其他字符的个数。

def testing(a):
    b = 0
    c = 0
    d = 0
    e = 0
    f = 0
    for i in a:
        v = ''.join(i)
        if len(v.encode('utf-8')) == 3:
            f += 1
            continue
        if v.isalpha() == 1:
            b += 1
        elif v.isdigit() == 1:
            c += 1
        elif v.isspace() == 1:
            d += 1
        else:
            e += 1
    print('统计:\n汉字{}个\n字母{}个\n数字{}个\n空格{}\n其他字符{}个'.format(f,b,c,d,e))

if __name__ == '__main__':
    str = input('请输入一段字符串：')
    testing(str)

9.5 写一个函数，传入一个字符串时间：例如5点30分29秒表示为：'5:30:29’然后返回下一秒的时间(字符串)

def add_time(time):
    list1 = [int(x) for x in time.strip().split(':')]
    #计算总秒数
    seconds = list1[0] * 3600 + list1[1] * 60 + list1[2] + 1

    # 秒数
    list1[2] = seconds % 60

    #分钟
    list1[1] = seconds % 3600 // 60

    #小时
    list1[0] = seconds // 3600 % 24
    return  ":".join(["{:02}".format(x) for x in list1])

print(add_time("23:59:59"))