函数名的第一类对象和使用
# 第一类对象 -- 特殊点
# 没有调用得到：内存地址
#
# 1、可以当作值被赋值给变量
def func():
print(1)
a = func
a()
# 输出 1
# 2、当做元素存放在容器中
def fun1():
print("a")
def fun2():
print("b")
lst = [fun1,fun2]
for i in lst:
i()
# 输出
# a
# b
# 3、函数名可以当做函数的参数
def fun3():
print("a")
def fun3_1(fn):
print("b")
fn()
print("c")
fun3_1(fun3)
# 输出
# b
# a
# c
# 4、函数名可以当做函数的返回值
def fun4():
print("a")
def fun4_1():
print("b")
print("c")
return fun4_1
fn = fun4()
fn()
# 输出
# a
# c
# b
格式化
# python3.6版本以及以上才能够使用,f和F都可以
# f"{}" {任意数据数据}
s =f"{1}"
print(s)
# 填充字符串
s =f"{'您好'}"
print(s)
# 填充变量
s1 =f"{s}python"
print(s1)
# 填充各种计算公式
s =f"{1+2}"
print(s)
# 三元运算符
a = 10
b = 20
s2 =f"{a if a>b else b}"
print(s2)
# 两个{{ }}取一个{ }
s3 =f"{{{{hh}}}}"
# %s和format和f都能格式化，一样的操作
迭代器
# 迭代 器：工具
#
# 可迭代对象：
# list dict str set tuple
# 官方声明具有__iter__()方法的就是可迭代对象
# 查看可迭代对象
# 1、可点出来的方法都是可迭代对象
#.__iter__()
list.__iter__()
dict.__iter__()
str.__iter__()
set.__iter__()
tuple.__iter__()
#2、查看源码 command+鼠标移动到方式上
#3、dir()
print(dir(list))
s1 = "alex"
print(dir(s1))
i = 100
print(dir(i))
ls = [1,2,3]
print('_iter_' in dir(i))
print('_iter_' in dir(ls))
# 可迭代对象的优点：
# 1、使用灵活
# 2、直接查看值
#
# 可迭代对象的缺点：
# 1、消耗内存
# 2、不能迭代取值
# 可迭代对象的取值方式
# list,tuple,str -- 索引
# dict -- 键
# set -- 直接取值
# 迭代器：
# 官方声明只要具有__iter__方法__next__方法的就是迭代器
# 迭代器：
# 文件操作
f = open("文件名","r")
f.__iter__()
f.__next__()
# 将迭代对象转换成迭代器
# 迭代对象.__iter__，重新定义变量名，变成迭代器
# 再执行.__next__，一个一个取值
#
# 迭代器的优点：
# 1、节省内存
# 2、惰性机制
#
# 迭代器的缺点：
# 1、使用不灵活
# 2、操作比较繁琐
# 3、不能直接查看元素
#
# 迭代器的特性：
# 1、一次性的，用完销毁
# 2、不能逆行（不能后退）
# 3、惰性机制（节省内存）
# 将可迭代对象转成迭代器
s = () #任意可迭代对象
new_s = s.__iter__()
print(new_s)
# 将迭代器的元素一一输出
print(new_s.__next__())
print(new_s.__next__())
lst = [1,2,3,4,6]
new_list = lst.__iter__() # 将列表转成迭代器
print(new_list.__next__()) # 1
print(new_list.__next__()) # 2
print(new_list.__next__()) # 3
# 输出123 与print一一对应
s = "12345"
new_s = s.__iter__() # 将字符串转成迭代器
print(new_s.__next__()) # 1
print(new_s.__next__()) # 2
# 输出12 与print一一对应
# 输出迭代器的元素的类型
s = "123"
new_s = s.__iter__()
print(new_s)
# for 更改版循环的本质
# 列表型
s = [1, 2, 3]
count = len(s)
new_s = s.__iter__()
while count:
print(new_s.__next__())
count -= 1
# 字符串型
s1 = "alex"
count = len(s1)
new_s1 = s1.__iter__()
while count:
print(new_s1.__next__())
count -= 1
# for 循环的真正原理
s2 = "alex"
new_s2 = s2.__iter__()
# 捕获异常
while True:
try: # 监听
print(new_s2.__next__())
except StopIteration: # 捕获
print("取超了")
break
except Exception: # except 可多个 Exception 万能异常
print("我是万能的")
break
递归
# 递归
# 1、不断调用自己本身--死递归
# 官方声明：最大层次1000，实际测试998／997
def func():
print(123)
func()
func()
# 2、有明确的终止条件
def age(n):
if n == 18:
return "对"
else:
return "错"
print(age(10))
# 用递归输出每个人的年龄
# 1.宝元 18-2-2-2
# 2.太白 18-2-2
# 3.wusir 18-2
# 4.alex 18
def age(n):
if n == 4:
return 18
else:
return age(n+1)-2
print(age(1))
def age4(n):
if n == 4:
return 18
def age3(n):
if n == 4: # 问的是不是第四个了
return 18
else:
return age4(n+1)-2
def age2(n):
if n == 4: # 问的是不是第四个了
return 18
else:
return age3(n+1)-2
def age1(n):
if n == 4: # 问的是不是第四个了
return 18
else:
return age2(n+1)-2
print(age1(1))
总结
# 语法分析
# 执行法分析
#
# 陷阱，默认参数可迭代会有坑
# 不可变的迭代对象没有坑
#
# 三大器：迭代器，生成器，装饰器
# 1、函数名的第一类对象及使用
# 可以作为值赋值给变量
# 可以作为容器中的元素
# 可以当作另一个函数的参数
# 可以作为返回值
#
# 2、f格式化：f"{}{}"
# 格式化方法：f，F，%s，format
# 支持：表达式，函数调用，数字计算，列表取值，字典取值
#
# 3、迭代器
# 可迭代对象：能够使用__iter__()方法
# 迭代器：能够使用__iter__()和__next__()方法
#
# 可迭代对象的特性：
# 优点：使用灵活，可直接查看值，每个可迭代对象都有私有的方法
# 缺点：占内存，不能迭代取值
#
# 迭代器：
# 优点：省空间，惰性机制
# 缺点：使用不灵活，不能直接查看值，不能直接查看元素，不能逆行
#
# 迭代器的使用：
# 当容器中数据量较多的时候使用
#
# 4、递归
# 不断调用自己本身
# 有明确的结束条件
# 拆开理解
# 一递一归
