Python第三天-函数

解构赋值

a, b, c = [1, 2, 3]  # 列表解构
print(a, b, c)
a, b, c = (1, 2, 3,)  # 元组解构
print(a, b, c)
a, b, c = {1, 2, 3}  # 集合解构
print(a, b, c)
a, b, c = range(1, 4)  # 范围解构
print(a, b, c)
a, b, c = "hel"  # 字符串解构
print(a, b, c)
a, b = {"name": "lisi", "age": 34}  # 字典解构
print(a, b)

将可迭代对象依次赋值给左边变量

函数定义

def my_sum(num1, num2):
    '''
    calculate two num sum
    :param num1:
    :param num2:
    :return:
    '''
    return num1 + num2


print(my_sum(2, 5))  # 位置对应
print(my_sum(num2=5, num1=2))  # 参数名称对应
print(my_sum(3, num2=8))  # 混合

使用def关键字声明函数，3引号声明函数文档注释，没有return语句会返回None，多个返回值会包装成元组。实参和形参必须一一对应，不能多也不能少。位置对应必须在名称对应之前。

默认参数

def my_sum(num1, num2, num3=0):
    '''
    calculate three num sum
    :param num1: 
    :param num2: 
    :param num3: 
    :return: 
    '''
    return num1 + num2 + num3


print(my_sum(6, 5))
print(my_sum(6, 5, 2))

默认参数在声明函数时定义，传参使用参数值，不传使用默认值。默认参数必须为不可变对象。

可变参数

def my_sum(*nums):
    sum = 0
    for num in nums:
        sum += num
    return sum


print(my_sum(1, 2, 3, 4, 6))  # 可变参数
print(my_sum(*[1, 2, 3, 4, 5]))  # 解构赋值

python会将多个参数包装成元组传递给函数。

关键字参数

def person(name, age, **kwargs):
    return {"name": name, "age": age, **kwargs}

print(person("lisi", 23, city="shanghai", job="java"))
print(person(**{"name": "lisi", "age": 23, "city": "shanghai", "job": "java"}))  # 解构赋值

python会将多个关键字参数包装成字典传递给函数。

局部变量和全局变量

NAME = "lisi"  # 全局变量
AGE = 23  # 全局变量

def change_name():
    global NAME  # 关联全局变量
    NAME = "lisi2"  # 修改全局变量
    AGE = 34  # 局部变量
    print(NAME, AGE)

change_name()

print(NAME, AGE)

使用global修改全局变量，先找局部变量，找不到再找全局变量。

NAME = "lisi"  # 全局变量

def change_name():
    NAME = "xioaming" 

    def change_name2():
        nonlocal NAME  #关联上一级作用域变量
        NAME = "xioali" # 修改
        print(NAME)

    change_name2()
    print(NAME)

change_name()
print(NAME)

使用nonlocal修改上一级作用域变量

递归函数

def my_sum(*nums):
    if len(nums) == 0:
        return 0
    return my_sum(*nums[0:-1]) + nums[-1]


print(my_sum(1, 2, 3, 6))
print(my_sum(1))
print(my_sum())

递归就是直接或间接的调用自己。

闭包

def create_counter(num=0):
    def inc():
        nonlocal num
        num += 1
        return num

    return inc


counter = create_counter()
print(counter())  # 1
print(counter())  # 2
counter = create_counter(5)
print(counter())  # 6
print(counter())  # 7

python中，只有函数内部或函数内部的子函数才可以读取或修改局部变量，闭包就是可以读取其他函数内部变量的函数，简单理解为函数内部的函数，它是将函数内部和函数外部连接的桥梁。

lambda函数

my_sum = lambda x, y: x + y
print(my_sum(3, 4))

python的lambda函数的函数体只能是表达式，不能是多条语句。

内置函数

print(abs(-12))  # 求绝对值
print(min(3, 5, 7, -3, 4))  # 最小值
print(max(4, 5, 6, 7))  # 最大值
print(sum([1, 2, 3], 0))  # 求和
print(pow(3, 2))  # 求幂次方
print(round(3.4568, 2))  # 四舍五入
print(divmod(9, 2))  # 求商和余数
print(int("123"))  # 转为int类型
print(float("123"))  # 转为float类型
print(bool("1"))  # 转为bool类型 0或空为False
print(bin(123))  # 转为2进制字符串
print(oct(123))  # 转为8进制字符串
print(hex(123))  # 转为16进制字符串
print(ord("A"))  # 获取对应的10进制整数
print(chr(65))  # 获取对应的字符
print(eval('2**3'))  # 执行python语句
exec('print(2**3)')  # 执行python语句

f = open("test.txt", "r")  # 打开文件
print(f.readlines())

print(str([1, 2, 3]))  # 转为字符串形式


class Person():
    pass


p = Person()
setattr(p, "len", 4)  # 设置属性值
print(getattr(p, "len"))  # 获取属性值
print(hasattr(p, "len"))  # 是否包含属性
delattr(p, "len")  # 删除属性
print(all([1, 2, 3, 0]))  # 可迭代对象是否全部为True
print(any([1, 2, 3, 0]))  # 可迭代对象是否有一个为True
print(dir())  # 获取当前模块的属性列表
it = iter([1, 2, 3])  # 获取列表的迭代器对象
while True:
    try:
        print(next(it))  # 获取迭代器的下一个对象，没有抛出异常
    except StopIteration:
        break
sli = slice(0, 2, 1)  # 创建切片对象
print([1, 2, 3, 4, 5][sli])
print(id("lisi"))  # 获取对象的内存地址
print(sorted([1, 3, 6, 4]))  # 对可迭代对象排序
print(list(reversed([1, 3, 6, 4])))  # 翻转可迭代对象
print(ascii([1, 2, 3]))  # 获取对象的字符串表示
for (i, v) in enumerate(["lisi", "zhangsan"]):  # 获取可迭代对象的索引序列，包含索引和数据
    print(i, v)
print(isinstance("", (str, list)))  # 对象是否为类的实例
print(issubclass(bool, int))  # 是否为父类


class Father:
    def sing(self):
        print("father sing")


class Child(Father):
    def sing(self):
        super().sing()  # 调用父类方法
        print("child sing")


print(Child().sing())
print(bytearray("lisi", encoding="utf-8"))  # 创建字节数组
print(bytes("lisi", encoding="utf-8"))  # 创建不可变字节数组
print(dict(name="lisi", age=23))  # 创建一个字典
print(tuple([1, 2, 3]))  # 创建元组
print(list((1, 2, 3,)))  # 创建列表
print(set([1, 2, 3]))  # 创建集合
print(frozenset([1, 2, 3]))  # 创建不可变集合
print(range(5))  # 创建范围对象
print(list(filter(lambda x: len(x) >= 4, ["java", "go", "python"])))  # 过滤可迭代对象
print("abc")  # 打印输出函数
print(callable(Child))  # 是否是可调用的
print("name:{name},age:{age}".format(name="lisi", age=23))  # 字符串格式化
print(len("hello"))  # 获取对象长度
print(type(""))  # 获取对象类型
print(vars(p))  # 获取对象的属性
print(hash("abxc"))  # 获取对象的哈希值
print(list(map(lambda x: x ** 2, [1, 2, 3])))  # 映射
print(list(zip([1, 2, 3], [4, 5, 6])))  # 将可迭代对象打包成元组
print(help('str'))  # 查看函数或模块的详细信息
print(input("please input num: "))  # 接受标准输入