python学习笔记-Day5

# 字符串格式化之%占位符

# a. 位置
s = ‘i am %s age %d‘ % (‘eason‘, 18)
print(s)

==> i am eason age 18  # 传入可迭代的对象，%占位符会根据迭代传入顺序给字符串赋值

# b. 字典
s = ‘i am %(name)s age %(age)d‘ % {‘name‘:‘eason‘,‘age‘:18}
print(s)

==> i am eason age 18  # 每一个%占位符会起一个名字，传入一个字典，将字典中%占位符名字的key对应的值传入

# c. 浮点型
s = ‘percent %.2f‘ % 99.97623    #  精确到两位小数点，并四舍五入后一位
print(s)

==> percent 99.98

# d.%显示
# 当格式化字符串时，出现了%s等占位符，需要使用%%才可以输出%（类似于转译）
--无占位符时%显示
s = ‘99%‘
print(s)
--有占位符时%显示
s = ‘jack %s 99%%‘ % ‘xx‘  # 如果使用%需要使用%转译
print(s)

==> 99%
jack xx 99%

# e. 左右对齐
s = ‘xxx|%(name)+10s|xxx‘ % {‘name‘:‘eason‘}
print(s)
s = ‘xxx|%(name)-10s|xxx‘ % {‘name‘:‘eason‘}
print(s)

==> xxx|     eason|xxx   # 占位10字符，右对齐（+号）
xxx|eason     |xxx   # 占位10字符，左对齐（-号）

# f. unicode、8进制、16进制
s = ‘unicode:%c   oct:%o,   hex:%x ‘  % (65, 15, 15)
print(s)

==> unicode:A   oct:17,   hex:f   # 分别将值转为unicode，8进制，16进制

# 字符串格式化之format（字符串方法）

# a. format的基本使用
s = ‘num1:{0}  num2:{0}  num{1}‘.format(123,456)  # 位置可以复用
print(s)

==> num1:123  num2:123  num456 # 注意字符串有三个需要格式化地方，而我们只传入两个，传入索引是可以被复用的 

# b. 指定名字修改
s = ‘name:{name:s}  age:{age}‘.format(name=‘eason‘, age=12)
print(s)
# 使用**迭代字典
s = ‘name:{name:s}  age:{age}‘.format(**{‘name‘:‘eason‘, ‘age‘:12})
print(s)

==> name:eason  age:12
name:eason  age:12  # format不仅支持迭代字典方式，而且支持指定名字修改

# c. 会根据传入类型不同自动去转换
s = ‘i am {}, age {}, {}‘.format(‘stenven‘, 18, 2.3)
print(s)

==> i am stenven, age 18, 2.3 # 不需要特定指定字符串类型或者Int或者浮点，传入时自动转换

# d. 传入迭代列表
s = ‘i am {}, age {}, {}‘.format(*[‘stenven‘, 18, 2.3])   # 使用星号遍历字典每一项
print(s)

==> i am stenven, age 18, 2.3  # 迭代列表

# e. 取列表中的元素
s = ‘i am {0[0]}, age {1[0]}, {0[2]}‘.format([‘stenven‘, 18, 2.3], [18,22])   # 使用星号遍历字典每一项
print(s)

==> i am stenven, age 18, 2.3 # 当我们没有使用"*[列表]"时，列表会当成一个元素传入，而在format格式化中，也可以读取列表某个索引的位置

# 概念：迭代器是访问集合元素的一种方式。
#          迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。
#          迭代器只能往前不会后退，不过这也没什么，因为人们很少在迭代途中往后退。
#          另外，迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。
#         迭代器仅仅在迭代到某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合，比如几个G的文件

特点：

1. 访问者不需要关心迭代器内部的结构，仅需通过next()方法不断去取下一个内容
2. 不能随机访问集合中的某个值 ，只能从头到尾依次访问
3. 访问到一半时不能往回退
4. 便于循环比较大的数据集合，节省内存

# 用我自己简要理解就是：
# 1. 迭代器是一个对象
# 2. 该对象不使用__next__方法不返回值

             

# 生成器基本概念：用普通的函数语法定义的迭代器

# 取出2层嵌套列表生成器
li = [[1,2],[3,4],[5]]
def fla(lis):
  for sublist in lis:
    for element in sublist:
      yield element

# 既然生成器本身就是一个迭代器
f = fla(li)
r1 = f.__next__()
print(r1)
r2 = f.__next__()
print(r2)
r3 = f.__next__()
print(r3)
r4 = f.__next__()
print(r4)
r5 = f.__next__()
print(r5)

==>
1
2
3
4
5

# 进入函数迭代后，遇到了yield，返回了yield返回值，并在此冻结，在下一次被__next__调用的时候，继续从此开始

# 递归，见递归。这是对“递归”最精简的定义
# 其实按照我的理解就是，在函数中调用自己，就是递归

# 例1：斐波那契递归
def fib(n):
    if n <= 2:
        return 1
    else:
        return fib(n-1) + fib(n-2)

r = fib(6)    # 查看第六位斐波那契序列数字
print(r)

# 例2：递归乘法
def f1(n):
    if n == 1:
        return 1
    return f1(n-1)*n

r = f1(5)   # 计算从1到5的阶乘
print(r)