函数的第一名称和使用

函数的第一类名称和使用

# 函数名在传递的时候可以跟函数定义不在同一级
# 函数名是一个变量, 但它是一个特殊的变量, 与括号配合可以执行函数的变量
# 函数名可以查地址

# 函数名的第一类对象的使用方式如下:
# 1.可以当做值,赋值给变量
# 2.可以当做容器中的元素
# 3.可以当做函数的参数
# 4.可以当做函数的返回值
# str,int,list,tuple,dict也可以这样使用


# def cen():
#     print("呵呵")
# print(cen) #函数名查询的是函数地址

#函数名可以当一个变量赋值给另一个变量
# def cen():
#     print("呵呵")
#     print(cen)#函数的地址
# a=cen#将函数的地址当一个变量赋给另一个变量
# a()  #相当于调用cen()函数


# 函数名可以当容器类的元素
# def cen1():
#     print("呵呵")
# def cen2():
#     print("呵呵")
# def cen3():
#     print("呵呵")
# def cen4():
#     print("呵呵")
# ls=[cen1,cen2,cen3,cen4]
# for i in ls:
#     i()
# 函数名可以当做函数的参数
# def cen():
#     print("吃了吗")
# def cen1(fn):
#     print("我是cen1")
#     fn()
#     print("我是cen1")
# cen1(cen)
# 函数名可以当函数的返回值

# def func_1():
#     print("这里是函数1")
#     def func_2():
#         print("这里是函数2")
#     print("这里是函数1")
#     return func_2
# fn = func_1()
# # 执行函数1.  函数1返回的是函数2, 这时fn指向的就是上面函数2
# print (fn() )   # 执行func_2函数
#
# def foo(a):
#     def func(a):
#         def f1(a):
#             print(a)
#             return "aelx"
#         return f1(a)
#     return func(a)
# print(foo(5))
# 结果：
# 5
# aelx


# 先看函数调用，如果括号里有函数先执行括号里的函数，这里的重点是先执行右边的内容然后执行完再返回来执行剩下的东西。
# 注意：函数是谁调用就将返回值 给他。
# def func(a):
#     a()
#
# def foo(b):
#     return b()
#
# def f1(c):
#     def a():
#         def f3():
#             print(3333)
#             return [f3,a,f1]
#         print(11)
#         return f3()
#     return c(a())
#
# def aa(b):
#     print(111)
#     return b
# print(f1(aa))
# 结果：
# 11
# 3333
# 111
# [<function f1.<locals>.a.<locals>.f3 at 0x0000014564BF3EA0>,
# <function f1.<locals>.a at 0x0000014564BF3E18>,
# <function f1 at 0x0000014564BF3D90>]

# 再来一个：
# def f1(c):
#     def a():
#         def f3():
#             print(3333)
#             return [f3,a,f1]
#         print(11)
#         return f3()
#     return c(a())
#
# def aa(b):
#     print(111)
#     return b
# print(f1(aa))

# 结果：
# 11
# 3333
# 111
# [<function f1.<locals>.a.<locals>.f3 at 0x000002A1172E3D08>,
# <function f1.<locals>.a at 0x000002A1172E3D90>,
# <function f1 at 0x000002A1172E3BF8>]

f-strings的使用：

# f-strings的使用
# name="姜会"
# sex="男"
# age="18"
# print(f"姓名：{ name} 性别：{sex} 年龄：{age}")
# print(f"{3*4}")
# name="asddf"
# print(f"{name.upper()}")
#
# def sum_a_b(a,b):
#     return a + b
# a = 1
# b = 2
# print('求和的结果为' + f'{sum_a_b(a,b)}')

迭代器

# 可迭代对象
# list,tuple,str,set,dict 取值方式只能直接看
# 只要具有__iter__() 方法就是一个可迭代对象

# 迭代器:工具
# 具有__iter__()和__next__()两个方法才是迭代器

# 迭代对象如何转化成迭代器：可迭代对象用iter(可迭代对象)或 可迭代对象.__iter__().都可以把可迭代对象转化成迭代器。

# 重点：
# for循环的本质   *****
# while True:
#     try:
#         print(l.__next__())
#     except StopIteration:
#         break


# l1 = [1, 2, 3,]
# obj = l1.__iter__()  # 或者 iter(l1)
# # print(obj)  # <list_iterator object at 0x000002057FE1A3C8>
# ret = obj.__next__()
# print(ret)
# ret = obj.__next__()
# print(ret)
# ret = obj.__next__()
# print(ret)
# ret = obj.__next__()  # StopIteration
# print(ret)


# l1 = [1, 2, 3, 4, 5, 6]
# obj = iter(l1)
# #
# # for i in range(2):
# #     print(next(obj))
# #
# # for i in range(2):
# #     print(next(obj))




#  可迭代对象的缺点：
#
# ​ 1.占用内存。
#
# ​ 2.可迭代对象不能迭代取值（除去索引，key以外）。
#
# ​ 迭代器的优点：
#
# ​ 1.节省内存。 ​ 迭代器在内存中相当于只占一个数据的空间：因为每次取值都上一条数据会在内存释放，加载当前的此条数据。
#
# ​ 惰性机制。 ​ next一次，取一个值，绝不过多取值。

# ​ 迭代器的缺点：
#
# ​ 1.不能直观的查看里面的数据。
#  2.一次性用完就没了
# ​ 3.取值时不走回头路，只能一直向下取值。

#
#  可迭代对象：
#
# ​ 是一个私有的方法比较多，操作灵活（比如列表，字典的增删改查，字符串的常用操作方法等）,比较直观，但是占用内存，而且不能直接通过循环迭代取值的这么一个数据集。
#
# ​ 应用：当你侧重于对于数据可以灵活处理，并且内存空间足够，将数据集设置为可迭代对象是明确的选择。
#
# ​ 迭代器：
#
# ​ 是一个非常节省内存，可以记录取值位置，可以直接通过循环+next方法取值，但是不直观，操作方法比较单一的数据集。
#
# ​ 应用：当你的数据量过大，大到足以撑爆你的内存或者你以节省内存为首选因素时，将数据集设置为迭代器是一个不错的选择。
# （可参考为什么python把文件句柄设置成迭代器）。



# 空间换时间： 容器存储大量的元素，取值时 取值时间短，但是容器占用空间较大
# 时间换空间： 迭代器就是节省了空间，但是取值时间较长

# 迭代器是基于上一次停留的位置，进行取值
# 可迭代对象：具有iter()方法就是一个可迭代对象
# 迭代器：具有iter()和next()方法就是一个迭代器


# python3和python2的区别:

# pyhton3:
    # iter()和 __iter__() 都有
    # next()和__next__()都有

# python2:
    # iter()和__iter__()
    # next()

总结

# 总结：
# 1.函数名的第一类对象及使用
    # 1.1 函数名可以当做值,赋值给变量
    # 1.2 函数名可以当做容器内的元素
    # 1.3 函数名可以当做函数的参数
    # 1.4 函数名可以当做函数的返回值
    #     课上代码一定多吸收吸收


# 2.f-strings

#     f"{变量名}"
#     F"{变量名}"
#     f"""{变量名}"""
#     f"{input()}"
#     f"{3 if 3>2 else 2}"
#     lst = [1,2,3,4,5]
#     f"{lst[4]}"
#     f"{lst[-1]}"
#     f"{dic['key1']}"

# 3.迭代器

# 迭代器的优点:
#     1.惰性机制 -- 节省空间

# 迭代器的缺点：
#     1.不能直接查看值  迭代器查看到的是一个迭代器的内存地址
#     2.一次性，用完就没有了
#     3.不能逆行（后退）


# 空间换时间： 容器存储大量的元素，取值时 取值时间短，但是容器占用空间较大
# 时间换空间： 迭代器就是节省了空间，但是取值时间较长

# 迭代器是基于上一次停留的位置，进行取值
# 可迭代对象：具有iter()方法就是一个可迭代对象
# 迭代器：具有iter()和next()方法就是一个迭代器


# for循环的本质   *****
# while True:
#     try:
#         print(l.__next__())
#     except StopIteration:
#         break

# python3和python2的区别:

# pyhton3:

    # iter()和 __iter__() 都有
    # next()和__next__()都有

# python2:

    # iter()和__iter__()
    # next()