python函数用法 & 类型判断type、isinstance方法使用

 　　python函数用法比java更加灵活。支持可变参数与参数默认值:

　　　　pass是空语句，为了保持结构完整性。

# python函数练习
# 1.python自带的一些常见函数的练习
print(abs(-95))
print(hash(-95))
print("sssssssssssssssss"+str(95))


# 2.自定义函数
def my_abs(a):
    if a >= 0:
        return a
    else:
        return -a


# 3.定义不带参数与返回值的函数(无返回值的函数类似于return None,可以简写为return)
def print_star():
    print("***********")


print_star()
x=print_star() #实际返回的为None
print(x)


# 4.多个返回值的函数定义以及使用方法(实际返回的是一个tuple，用多个值获取tuple的时候实际是将每个tuple的元素赋给对应的值)
def twoReturnValue():
    return 'a','b'

x, y = twoReturnValue();
print(x, y)
value=twoReturnValue()
print(value)



# 5.递归函数的用法(自己调用自己的函数)
# 5.1.计算裴波那契数列的第N个数字1 1 2 3 5 8 13 ...
def count(index):
    if index == 1:
        return 1
    if index == 2:
        return 1
    return count(index-1)+count(index-2)

print(count(7))
# 5.2计算N的阶乘
def jiecheng(n):
    if n==1:
        return 1
    else:
        return n*jiecheng(n-1)

print(jiecheng(3))


# 6.默认参数的用法
# 6.1默认参数求n的x次方，如果不传入n的话默认为2
def power(x, n=2):
    s=1
    while n > 0:
        s=s*x
        n=n-1
    return s
print(power(5,3))
print(power(5))

# 可变参数的用法(实际传入的是一个集合)
def fun3(*arg):
    print(len(arg))
    print(arg)
    for ele in arg:
        print(ele)

fun3(1,5,8,5)



# 定义一个空函数(pass关键字是空语句，是为了保持程序结构的完整性)
def fun4():
    pass

fun4()

补充：  默认值加多个参数用法, 有默认值参数，后续的方参数必须全部有默认值。 且前面不带参数的都是必传参数

# 默认值加多个参数用法, 有默认值参数，后续的方参数必须全部有默认值
def function1(x, a=None, b={}, c=[], d=None):
    print("====")
    print(x)
    print(a)
    print(b)
    print(c)
    print(d)

function1(1);
function1(1, 2);
function1(1, 2, c=[1, 3]);

结果：

====
1
None
{}
[]
None
====
1
2
{}
[]
None
====
1
2
{}
[1, 3]
None

 

补充:python也有类似于java的main函数

#主函数用法
if __name__ == '__main__':
    print('这是主函数，类似于Java的main函数，是程序的入口')

结果:

　　这是主函数，类似于Java的main函数，是程序的入口

 

Python作为一门较为灵活的解释型脚本语言，其中定义的main()函数只有当该Python脚本直接作为执行程序时才会执行；当该python脚本被作为模块(module)引入(import)时，其中的main()函数将不会被执行。

Python单独的函数调用都是从上到下，从左到右，一般是先写函数，然后在下面按照顺序来调用（或者下面的调用上面的）。但是在class中函数的调用可以不按照顺序调用函数（这个仅仅在class中）。

 

附一些函数练习题:

# 函数部分练习题
# 1.获取三个数字中最大的一个
def fun1(a,b,c):
    if a >=b and a>=c:
        return a
    elif b >= c and b>= a:
        return b
    else:
        return c
print(fun1(1,2,3))

# 2.编写一个函数，将一个集合升序排列
def fun2(list):
    for index2 in range(len(list)):
        for index22 in range(index2+1,len(list)):
            if list[index2] > list[index22]:
                tmp=list[index2]
                list[index2]=list[index22]
                list[index22]=tmp
    return list

print(fun2([1,6,9,8,5,6,96,5]))

# 3.编写函数往集合中插入元素
def fun3(list,element):
    list.append(element)
    return list

print(fun3([1,2],5))


# 4.编写函数，实现从控制台输入一个数字并在控制台打印
def fun4():
    print("您输入的数字是:", input("请输入一个数字"))

fun4()

# 5.编写一个函数，实现将一个集合中的元素反转
def fun5(list):
    tmpList=[]
    index5 = len(list)-1
    while index5>=0:
        tmpList.append(list[index5])
        index5 = index5-1
    return tmpList

print(fun5([5,5,9,6,8,4]))


# 6.编写函数，设置一个整数参数，如果传6，打印如下内容
def fun6(num):
    for i in range(num):
        print(str(i)+"+"+str(num-i)+"="+str(num))
    print(str(num)+"+"+str(num-num)+"="+str(num))

fun6(6)



# 7、编写函数，实现登录验证功能，验证次数最多三次
def fun7(name,password):
    for i in range(3):
        input_name=input("请输入用户名:")
        input_password=input("请输入密码:")
        if input_name == name and input_password==password:
            print("你牛逼")
            return
        else:
            print("输入错误!您还有"+str(2-i)+"次机会")

fun7("n","p")


# 8、编写函数，计算某个数的阶乘(递归函数的用法或者使用循环计算)
def fun8(num):
    if num <1:
        print("请传递正数参数")
        return
    if num==1:
        return 1
    else:
        return num * fun8(num-1)

print(fun8(6))

补充： python 也可以限定参数类型 

1. 方法定义以及调用如下

def handle(requestHeaders:dict):
    """
    自定义的处理，可以在这里进行处理或者对结果进行校验

    :param requestHeaders: 请求header
    :return: 无返回值，可以自行判断验证逻辑以及处理
    """
    # 循环遍历dict
    for key in requestHeaders:
        print("key:", key, "value:", requestHeaders[key])

    length = len(requestHeaders);
    if length == 0:
        pass
    elif length ==1:
        return length;
    else:
        return "str1"


# Press the green button in the gutter to run the script.
if __name__ == '__main__':
    # 定义一个dict类型
    dict1 = {"zhangsan": 100, "lisi": 999, "wangwu": 99}
    result1 = handle(dict1)
    print("======1")
    print(result1) # str1
    print(result1 is None) # False
    print(result1 is not None) # True
    print(type(result1)) # <class 'str'>
    print(type(result1) == str) # True
    print(isinstance(result1, str)) # True
    print(isinstance(result1, bool)) # False

    # 用如下类型会报错。
    # handler(1)

2. 上面也是一个标准的方法注释，用Ctrl+Q 可以查看方法签名，如下：

 　　箭头后面表示返回的参数类型。没有返回值，默认是返回None。 

 3. type() 等价于获取class 对象

# list 也可以限定类型
list1: list[int] = []

# 下面两个等价
print(list1.__class__) # <class 'list'>
print(type(list1)) # <class 'list'>
print(type(list1) == list1.__class__) # True

 补充： 两种可变参数

　　*args、**args2 分别表示元祖类型和字典类型，比如：

def test(a, b, c=3, *args):
    '''

    :param a:
    :param b:
    :param c:
    :param args: args中保存的是没有利用的所有多余参数，保存方式为元组
    :return:
    '''
    print(a)
    print(b)
    print(c)
    print(args)


test(11, 22, 33, 44, 55, 66, 77)
print("======1")
test(11, 22, 33)

print("********")


def test1(a, b, c=3, *args1, **args2):
    print(a)
    print(b)
    print(c)
    print(args1)
    print(args1.__class__)
    print(args2)
    print(args2.__class__)


test1(11, 22, 33, 44, dd=44, ee=55, ff=66)
print("======1")
test1(11, 22, 33)

结果：

11
22
33
(44, 55, 66, 77)
======1
11
22
33
()
********
11
22
33
(44,)
<class 'tuple'>
{'dd': 44, 'ee': 55, 'ff': 66}
<class 'dict'>
======1
11
22
33
()
<class 'tuple'>
{}
<class 'dict'>

 补充: python 函数是一个特殊的对象，其类型是function。 也可以赋值给其他变量，然后通过其他变量引用后进行方法调用

def myFun(arg):
    print(arg)


# 函数是一个特殊的类型，函数也可以赋值给其他变量，然后通过引用的方式进行调用
print(myFun)
print(myFun.__class__)
var1 = myFun
var1("22")

结果：

<function myFun at 0x000001FF6C12EF70>
<class 'function'>
22

补充： 在方法调用时* 和 **， 分别用于tuple和dict 类型，用于将元素拆开然后传给对应参数 

def test1(param1, param2):
    print(param1)
    print(param2)


def test2(key2, key1):
    print(key1)
    print(key2)

def test3(param1, param2, key2, key1):
    print(param1)
    print(param2)
    print(key1)
    print(key2)


tuple1 = (1, 2)
# *param 相当于根据下标将tuple 拆开后传递到对应位置的参数
test1(*tuple1)
print("====")
# **dict1 相当于将dict 解开，根据key 传递到方法对应的参数
dict1 = {"key1": "value1", "key2": "value2"}
test2(**dict1)
print("====")
test3(*tuple1, **dict1)

结果：

1
2
====
value1
value2
====
1
2
value1
value2