Python基础重点复习（4）

木大打电动

已于 2022-08-23 11:10:35 修改

阅读量429

点赞数

分类专栏： Python 文章标签： python

于 2022-08-22 11:39:42 首次发布

本文链接：https://blog.csdn.net/fff1739/article/details/126426772

版权

Python 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

本文介绍了函数的基础概念，包括加减乘除运算、参数的不同传递方式（位置参数、关键字参数、默认值和动态参数），以及函数的嵌套、闭包和lambda表达式的应用。同时涵盖了内置函数、数据结构与操作、函数返回值和编程技巧等内容。

摘要由CSDN通过智能技术生成

函数

# 加减乘除四则运算
def calculator(a, opt, b):
    if opt == "+":
        print(a + b)
    elif opt == "-":
        print(a - b)
    elif opt == "*":
        print(a * b)
    elif opt == "/":
        print(a / b)
    else:
        print("请输入正确的参数")

calculator(7, "+", 3)
calculator(7, "-", 3)
calculator(7, "*", 3)
calculator(7, "/", 3)
calculator(7, "#", 3)

print("---------------------------------------")

# 实参
def eva(name, drive, color, gender):
    print(name, drive, color, gender)

eva("明日香", "二号机", "红色", "女")
eva(name="绫波丽", gender="女", color="蓝色", drive="零号机")  # 关键字传参
eva("绫波丽", "零号机", gender="女", color="蓝色")
# 混合参数，位置参数在前，关键字参数在后，例如open("xxx.txt", mode="xx", encoding="xx")

print("---------------------------------------")

# 形参
def onepiece(name, hear, gender="男"):  # 默认值参数，要放在位置参数后面
    print(name, hear, gender)

onepiece("索隆", "绿藻头")
onepiece("山治", "黄毛")
onepiece("娜美", "橘色", "女")

print("======================")

def eat(*food):  # 位置参数的动态传参，接收到的值统一放在元祖里
    print(food)

eat("蔬菜", "米饭", "回锅肉")


def eat(**food):  # 关键字的动态传参，接收到的值统一放在字典里
    print(food)

eat(food="蔬菜", rice="米饭")

print("---------------------------------------")

def func(a, b, *args, c="你好", **kwargs):
    print(a, b, args, c, kwargs)

func(1, 2, 3, 4, 5, 6, c="哈哈", ok=7, yes=8)
# 顺序:位置参数 > *args > 默认值 > **kwargs


def func(*args, **kwargs):  # 没有限制的接收任何参数
    print(args, kwargs)

func()
func(1)
func(1, 2, 3, a=5, b=6)

print("---------------------------------------")

op_lst = ["路飞", "香克斯", "黑胡子", "五老星"]

def func(*args):
    print(args)

func(*op_lst)  # *是把列表中的每个元素取出来当做位置参数进行传递
               # **是把列表中的每个元素取出来当做关键字参数进行传递

函数返回值

def func():  # 若函数内没有return，此时内部默认返回None
    pass
    #return None
print(func())  # None

print("-----------------------------------------")

def func():  # 若return后面不写值，默认返回None
    print(111)
    return  # 停止程序，下面的代码不执行
    print(222)

print(func())  # 111 None

print("-----------------------------------------")

def func():  # 若返回多个值，收到的是多个值组成的元组
    return 1, 2, 3, 4

print(func())  # (1, 2, 3, 4)

内置函数

s = "111"
i = int(s)  # 类型转换
b = bool(s)
f = float(s)

a = 10
print(bin(a))  # 二进制
print(oct(a))  # 八进制
print(hex(a))  # 十六进制

a = 0b10010
print(int(a))  # 十进制

print("------------------------------------")

a = 2
b = 5
print(pow(a, b))  # 等价于 a ** b

lst = [1, 3, 7, 20, 51]
print(max(lst))
print(min(lst))
print(sum(lst))

print("------------------------------------")

s = {1, 2, 3, 4, 5}
lst = list(s)  # 转换成列表,同理tuple()是转换成元组
# # 相当于
# lst = []
# for item in s:
#     lst.append(item)
print(lst)

s = [1, 12, 3, 15, 7]
print(list(reversed(s)))  # 列表翻转

print("------------------------------------")

a = 20
print(format(a, "08b"))  # 8位二进制，0补齐，超出范围则不管
# b二进制,o八进制,x十六进

a = "飞"
print(ord(a))  # unicode编码位置
print(chr(39134))  # 根据编码位置展示文字

print("------------------------------------")

print(all([5050, "你好", "EVA"]))  # 与and效果一样，判断元素是否都是真
print(all([0, "你好", "EVA"]))

print(any([0, "你好", "EVA"]))  # 与or一样
print(any([0, "", ""]))

lst = ["EVA", "海贼王", "春物"]
for index, item in enumerate(lst):  # 拿到索引和元素
    print(index, item)

print("------------------------------------")

s = "EVA"
print(hash(s))  # 转化成内存地址，进行数据存储，形成哈希表
print(id(s))  # 拿到内存地址

print("------------------------------------")

lst = ["明日香", "凌波丽", "碇真嗣"]
lst2 = ["二号机", "零号机", "初号机"]
lst3 = ["红", "蓝", "紫"]

result = zip(lst, lst2, lst3)  # 把多个可迭代内容，根据对应索引进行合并
print(list(result))

print("------------------------------------")

lst = [3, 22, 16, 5, 12]
s = sorted(lst)  # 顺序排序
print(s)
s = sorted(lst, reverse=True)  # 倒序排序
print(s)

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

def func(item):  # 参数对应列表中的每个元素
    return len(item)

lst = ["明日香", "凌波丽", "EVANGELION", "路飞", "赤犬大将"]
s = sorted(lst, key=func)  # key是排序规则(函数)

# 简化成lambda表达式
s = sorted(lst, key=lambda x : len(x))
print(s)

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

lst = [
    {"id": 23, "name": "吉良吉影", "age": 33},
    {"id": 6, "name": "碇真嗣", "age": 16},
    {"id": 13, "name": "明日香", "age": 17},
    {"id": 9, "name": "凌波丽", "age": 16}
]

# 根据年龄排序
s = sorted(lst, key=lambda d : d['age'])
print(s)

# 根据id从大到小排序
s = sorted(lst, key=lambda d : d['id'], reverse=True)
print(s)

print("------------------------------------")

lst = ["香吉士", "香克斯", "路奇", "路飞", "赤犬大将"]
# 提取不姓香的人
f = filter(lambda x: not x.startswith("香"), lst)
print(list(f))

print("------------------------------------")

lst = [1, 2, 3 ,4 ,5]
result = [i * i for i in lst]
print(result)

# 用map函数实现批量处理
result = map(lambda x: x * x, lst)
print(list(result))

函数的嵌套

# 嵌套
def func1():
    print("a")
    def func2():
        print("b")
        def func3():
            print("c")
        func3()
    func2()

func1()  # a b c


print("--------------------------------")

def func():
    def inner():
        print(112233)
    return inner  # 返回的是函数，把函数当成变量返回

f = func()  # f是func内部的inner
f()  # 112233

print("=================")
# 代理模式
def func(a):
    a()  # targert()

def target():
    print("我是target")

func(target)  # 实参可以是函数

# 重点：函数可以作为返回值返回，函数可以作为参数进行传递。函数名实际上就是一个变量名，都表示一个内存地址

闭包

"""
    闭包：内层函数对外层函数局部变量的使用，此时内层函数被称为闭包函数
    作用: 1.可以让一个变量常驻于内存
         2.避免全局变量被修改
"""
def func():
    a = 10
    def inner():
        nonlocal a
        a += 1
        return a
    return inner

f = func()
r = f()
print(r)  # 11
r2 = f()
print(r2)  # 12

匿名函数lambda表达式

def func(a, b):
    return a + b

ret = func(1, 4)
print(ret)


# 用lambda表达式简化上述代码
# 语法：变量 = lambda 参数1,参数2,... : 返回值

func = lambda a, b : a + b  # 这个实际上就是个函数

ret = func(2, 6)
print(ret)