一、内置函数
1、作用域相关函数 locals globals
locals: 会以字典类型返回当前位置的全部局部变量
globals： 以字典类型返回当前位置的全部全局变量，包括所有导入的变量
# 两个全局变量 name,age name = '太白' age = 25 def func1(): # 两个局部变量：a, b a = 'Ws' b = {'name': '二狗'} print(globals()) # 返回一个全局变量的字典，如下注释部分 # {'__name__': '__main__', '__doc__': None, '__package__': None, # '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x108e02208>, # '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, # '__file__': '/Users/chensihan/Documents/shanshan/上课练习/000博客.py', '__cached__': None, # 'name': '太白', 'age': 25, 'func1': <function func1 at 0x108d981e0>} print(locals()) # 返回一个局部变量的字典 {'a': 'Ws', 'b': {'name': '二狗'}} func1() # 下边两个globals和locals执行结果一样， 因为是在全局执行的 print(globals()) # 此时的全局变量是name,age # {'__name__': '__main__', '__doc__': None, '__package__': None, # '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x10f66e208>, # '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, # '__file__': '/Users/chensihan/Documents/shanshan/上课练习/000博客.py', '__cached__': None, # 'name': '太白', 'age': 25, 'func1': <function func1 at 0x10f6041e0>} print(locals()) # 此时的局部变量应该是name,age # {'__name__': '__main__', '__doc__': None, '__package__': None, # '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1057cb208>, # '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, # '__file__': '/Users/chensihan/Documents/shanshan/上课练习/000博客.py', '__cached__': None, # 'name': '太白', 'age': 25, 'func1': <function func1 at 0x1057611e0>}
2、其余相关函数 eval exec
eval : 执行字符串中的代码并将结果返回给执行者。 慎用
eval('2 + 2') # 4 n = 1 eval("n + 4") # 5 eval('print(666)') # 666 s3 = 'print(666)' # 这是个字符串，第一步不执行这里 print(eval(s3)) # 执行字符串s3中的代码，接收到S3的结果666，再次print的结果是 None
exec : 执行字符串中的代码 往往执行代码流。 慎用。
r1 = ''' for i in range(3): print(i) ''' exec(r1) # 0 1 3
3、内存相关 hash id
hash：获取一个对象的哈希值（可哈希对象：int，str，Bool，tuple）
print(hash(12322)) # int类型 ，结果是 12322 print(hash('123')) # str类型，每次结果不同 print(hash('arg')) # str类型，每次结果不同 print(hash(True)) # bool类型，结果 1 print(hash(False)) # bool类型，结果 0 print(hash((1, 2, 3))) # 元祖类型，结果为固定值 2528502973977326415
id：返回对象的内存地址
# 以下类型的数据，返回的都是内存地址，每次结果都会变， print(id(12322)) print(id('123')) print(id('arg')) print(id(True)) print(id(False)) print(id((1, 2, 3)))
4、文件操作相关 open
f = open('log', 'w', encoding='utf-8') # # 新建一个log文件 print('王大锤', file=f) # 写入内容：王大锤
5、帮助信息相关 help
help: 用于查看函数或模块用途的详细说明
print(help(str)) # 显示class str的帮助信息 help('sys') # 显示sys 模块的帮助 help([1, 2, 3]) # 显示列表 list 帮助信息 a = [1, 2, 3] help(a.append) # 显示list的append方法的帮助信息
6、调用相关：callable
callable：检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
a = '大锤' def func(): print(666) print(callable(a)) # False 证明字符串a绝对不会被调用成功 print(callable(func)) # True 证明func可以被调用，但是不确定每次都能被调用成功 a()
7、查看内置属性 dir
dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；
带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
# 不带参数 print(dir()) # 查看当前模块的属性方法 # ['__annotations__', '__builtins__', '__cached__', '__doc__', # '__file__', '__loader__', '__name__', '__package__', '__spec__'] print(dir([])) # 查看列表的方法 # ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', # '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', # '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', # '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', # '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', # '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', # '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', # 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'] # 带参数 print(dir('大锤')) # 查看此字符串的方法 # ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', # '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', # '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', # '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', # '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', # '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', # 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', # 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', # 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', # 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', # 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', # 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] print(dir([1, 2, 3])) # 查看此列表的方法 # ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', # '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', # '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', # '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', # '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', # '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', # 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
8、基础数据类型相关
数据类型: bool int float complex bytes
# int 函数用于将一个字符串或数字转换为整型 print(int()) # 0 print(int('12')) # 12 print(int(3.6)) # 3 print(int('0100', base=2)) # 将2进制的 0100 转化成十进制。结果为 4 # bool 用于将给定参数转换为布尔类型，如果没有参数，返回 False print(bool()) # False print(bool(0)) # False print(bool(1)) # True （非0即true） print(bool(2)) # True # float 用于将整数和字符串转换成浮点数 print(float(1)) # 1.0 print(float(112)) # 112.0 print(float(-123.6)) # -123.6 print(float('123')) # 123.0 字符串也会转春成相应的数据 # complex 创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数 print(complex(1, 2)) # (1+2j) print(complex(1)) # 数字 (1+0j) print(complex("1")) # 当做字符串处理(1+0j) # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错 print(complex("1+2j")) # (1+2j)
进制转换: bin oct hex
# bin：将十进制转换成二进制并返回。 print(bin(10), type(bin(10))) # 0b1010 <class 'str'> # oct：将十进制转化成八进制字符串并返回。 print(oct(10), type(oct(10))) # 0o12 <class 'str'> # hex：将十进制转化成十六进制字符串并返回。 print(hex(10), type(hex(10))) # 0xa <class 'str'>
数学运算: abs divmod round pow sum min max divmod
# abs：返回数字的绝对值。 print(abs(-5)) # 5 # divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b) print(divmod(7, 2)) # (3, 1) # round：保留浮点数的小数位数，默认保留整数 print(round(7/3, 2)) # 2.33 print(round(7/3)) # 2 print(round(3.32567, 3)) # 3.326 # pow：求x**y次幂。（三个参数为x**y的结果对z取余） # pow(x,y) 等价于 x**y # pow(x,y,z) 等价于 x**y%z print(pow(2, 3)) # 两个参数为2**3次幂 结果为 8 print(pow(2.0, 3.0)) # 8.0 print(pow(2, 4, 3)) # 三个参数为2**4次幂，对3取余。 结果为1 # sum：对可迭代对象进行求和计算（可设置初始值） print(sum([1, 2, 3])) # 6 print(sum((1, 2, 3), 100)) # 106 print(sum([i for i in range(10)])) # 45 print(sum([i for i in range(10)], 100)) # 145 # min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值） print(min([1, 2, 3])) # 返回此序列最小值 1 ret = min([1, 2, -5], key=abs) # 按照绝对值的大小，返回此序列最小值 print(ret) # 1 dic = {'a': 3, 'b': 2, 'c': 1} print(min(dic, key=lambda x: dic[x])) # c 输出最小值对应的键 # x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键 l1 = [('alex', 3), ('太白', 1), ('wS', 2)] # min 默认将可迭代对象中的每个元素依次传入函数中，按照函数的返回值去取最小元素。 def func(x): return x[1] print(min(l1, key=func)) # 输出最小的元素 ('太白', 1) # max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值） print(max([1, 2, 3])) # 返回此序列最大值 3 ret = max([1, 2, -5], key=abs) # 按照绝对值的大小，返回此序列最大值 print(ret) # -5 dic = {'a': 3, 'b': 2, 'c': 1} print(max(dic, key=lambda x: dic[x])) # a # x为dic的key，lambda的返回值（即dic的值进行比较）返回最大的值对应的键 # divmod 把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b) # 分页会用到。 print(divmod(7, 3)) # (2, 1) 2为商，1为余数
列表和元祖：list tuple
# list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素） l = list((1, 2, 3)) print(l) l = list({1, 2, 3}) print(l) l = list({'k1': 1, 'k2': 2}) print(l) # tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素） tu = tuple((1, 2, 3)) print(tu) tu = tuple([1, 2, 3]) print(tu) tu = tuple({'k1': 1, 'k2': 2}) print(tu)
相关内置函数: reversed slice len enumerate all any filter map
# reversed：将一个序列翻转，并返回此翻转序列的迭代器 l1 = [1, 2, 3, 4] l1.reverse() print(l1) # [4, 3, 2, 1] l2 = reversed(l1) print(list(l2)) # [1, 2, 3, 4] ite = reversed(['a', 2, 3, 'c', 4, 2]) for i in ite: print(i) # 依次返回2 4 c 3 2 a
# slice：构造一个切片对象，用于列表的切片 li = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] obj = slice(3) print(li[obj]) # ['a', 'b', 'c'] li = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] obj2 = slice(0, 7, 2) # 从0号元素到6号元素， 步长为2取值 print(li[obj2]) # ['a', 'c', 'e', 'g'] # len:返回一个对象中元素的个数。 a = [1, 2, 3, 4] b = {'name': '大锤', 'age': 20} print(len(a)) # 4 print(len(b)) # 2 # sorted：对所有可迭代的对象进行排序操作。 L = [('a', 1), ('c', 3), ('d', 4), ('b', 2), ] print(sorted(L, key=lambda x: x[1])) # 利用key排序 [('a', 1), ('b', 2), ('c', 3), ('d', 4)] students = [('大锤', 'A', 15), ('大脸', 'B', 12), ('小娟', 'B', 10)] print(sorted(students, key=lambda s: s[2])) # 按年龄排序 [('小娟', 'B', 10), ('大脸', 'B', 12), ('大锤', 'A', 15)] print(sorted(students, key=lambda s: s[2], reverse=True)) # 按降序 [('大锤', 'A', 15), ('大脸', 'B', 12), ('小娟', 'B', 10)] l1 = [1, 2, 7, 6, 5, 4] print(sorted(l1)) # [1, 2, 4, 5, 6, 7] # enumerate:枚举，返回一个枚举对象 print(enumerate([1, 2, 3])) # <enumerate object at 0x10e2e0750> for i in enumerate([1, 2, 3]): print(i) # (0, 1) (1, 2) (2, 3) for i in enumerate([1, 2, 3], 100): print(i) # (100, 1) (101, 2) (102, 3) # all：可迭代对象中，全都是True才是True print(all([1, 2, True, 0])) # False # any：可迭代对象中，有一个True 就是True print(any([1, '', 0])) # True # zip：函数用于将可迭代的对象作为参数，将对象中位置对应的元素打包成一个个元组，然后返回由这些元组组成的列表。 # 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。 l1 = [1, 2, 3] l2 = ['a', 'b', 'c', 5] l3 = ('*', '**', (1, 2, 3)) for i in zip(l1, l2, l3): print(i) # 依次输出(1, 'a', '*') (2, 'b', '**') (3, 'c', (1, 2, 3)) # filter 过滤 通过函数过滤一个可迭代对象，返回的是True # 类似于[i for i in range(10) if i > 3] def func(x): return x % 2 == 0 ret = filter(func, [1, 2, 3, 4, 5, 6, 7]) print(ret) # <filter object at 0x10712d1d0> for i in ret: print(i) # 依次输出 2 4 6 # map: 返回一个迭代器 类比成列表推导式：循环模式 def square(x): # 计算平方数 return x ** 2 print(list(map(square, [1, 2, 3, 4, 5]))) # 计算列表各个元素的平方 [1, 4, 9, 16, 25] print(list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))) # 使用 lambda 匿名函数 [1, 4, 9, 16, 25] # 提供了两个列表，对相同位置的列表数据进行相加 print(list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))) # [3, 7, 11, 15, 19] l1 = [1, 2, 3, 4, 5, 6] def func(x): return x ** 2 print(list(map(func, l1))) # [1, 4, 9, 16, 25, 36]
字符串相关 ：str format bytes bytearry memoryview ord chr ascii %r repr
# str：将数据转化成字符串 s = 'RUNOOB' print(str(s)) # 'RUNOOB' dict = {'runoob': 'runoob.com', 'google': 'google.com'}; print(str(dict)) # "{'google': 'google.com', 'runoob': 'runoob.com'}" # format:与具体数据相关，用于计算各种小数，精算等 # 对齐方式：字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐 print(format('文字在左，包含文字在内共30个字符的位置', '<30')) print(format('文字在右，包含文字在内共30个字符的位置', '>30')) print(format('文字居中，包含文字在内共30个字符的位置', '^30')) # 整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None print(format(3, 'b')) # 转换成二进制 '11' print(format(97, 'c')) # 转换unicode成字符 'a' print(format(11, 'd')) # 转换成10进制 print(format(11, 'o')) # 转换成8进制 '13' print(format(11, 'x')) # 转换成16进制 小写字母表示 'b' print(format(11, 'X')) # 转换成16进制 大写字母表示 'B' print(format(11, 'n')) # 和d一样 '11' print(format(11)) # 默认和d一样 '11' # 浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None print(format(314159267, 'e')) # 科学计数法，默认保留6位小数 '3.141593e+08' print(format(314159267, '0.2e')) # 科学计数法，指定保留2位小数 '3.14e+08' print(format(314159267, '0.2E')) # 科学计数法，指定保留2位小数，采用大写E表示 '3.14E+08' print(format(314159267, 'f')) # 小数点计数法，默认保留6位小数 '314159267.000000' print(format(3.14159267000, 'f')) # 小数点计数法，默认保留6位小数 '3.141593' print(format(3.14159267000, '0.8f')) # 小数点计数法，指定保留8位小数 '3.14159267' print(format(3.14159267000, '0.10f')) # 小数点计数法，指定保留10位小数 '3.1415926700' print(format(3.14e+1000000, 'F')) # 小数点计数法，无穷大转换成大小字母 'INF' # g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp， # 如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数 print(format(0.00003141566,'.1g')) # p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点 # 结果为 '3e-05' print(format(0.00003141566,'.2g')) # p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点 # 结果为 '3.1e-05' print(format(0.00003141566,'.3g')) # p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点 # 结果为 '3.14e-05' print(format(0.00003141566,'.3G')) # p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写 # 结果为 '3.14E-05' print(format(3.1415926777,'.1g')) # p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点 # 结果为 '3' print(format(3.1415926777,'.2g')) # p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点 # 结果为 '3.1' print(format(3.1415926777,'.3g')) # p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点 # 结果为 '3.14' print(format(0.00003141566,'.1n')) # 和g相同 # 结果为 '3e-05' print(format(0.00003141566,'.3n')) # 和g相同 # 结果为 '3.14e-05' print(format(0.00003141566)) # 和g相同 # 结果为 3.141566e-05' # bytes：用于不同编码之间的转化 # 之前学过转码的方式 s1 = '大锤' # unicode ---> utf-8 bytes b1 = s1.encode('utf-8') print(b1) # b'xe5xa4xa7xe9x94xa4' # utf-8 bytes ---> unicode s2 = b1.decode('utf-8') print(s2) # 大锤 # 用bytes实现 s1 = '大锤' # unicode ---> utf-8 bytes b1 = bytes(s1, encoding='utf-8') print(b1) # b'xe5xa4xa7xe9x94xa4' # bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。 ret = bytearray('alex', encoding='utf-8') print(ret) # bytearray(b'alex') 这是个字节数组 print(ret[0]) # 这个数组中0号元素是字母a，这里输入出的是他的ascii码 108 ret[0] = 65 # 将0号元素重新规定ascii码，65都应的字母是A print(ret) # bytearray(b'Alex') 此时原来字节数组中的第一个字母a已经被替换成A # memoryview 返回给定参数的内存查看对象 v = memoryview(bytearray("abcefg", 'utf-8')) print(v[1]) # 98 print(v[-1]) # 103 print(v[1:4]) # <memory at 0x10f543a08> print(v[1:4].tobytes()) # b'bce' # ord:输入字符找该字符编码的位置 print(ord('a')) # 97 print(ord('中')) # 20013 # chr:输入位置数字找出其对应的字符 print(chr(97)) # a print(chr(20013)) # 中 # ascii:是ascii码中的返回该值，不是就返回/u.... print(ascii('a')) # 'a' ,是ascii码 print(ascii('中')) # 'u4e2d' , 不是ascii码 # %r 原封不动的写出来 name = '大锤' print('我叫%r' % name) # 我叫'大锤' # repr 返回一个对象的string形式（原形毕露）。 print(repr('{"name":"大锤"}')) # '{"name":"大锤"}' print('{"name":"大锤"}') # {"name":"大锤"}
数据集合： frozenset
# frozenset： 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。 a = frozenset(range(10)) # 生成一个新的不可变集合 a print(a) # frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9}) b = frozenset('runoob') print(b) # frozenset(['b', 'r', 'u', 'o', 'n'])
二、匿名函数
1、什么是匿名函数？
匿名函数： 一句话函数，一行代码实现的函数。
# 这段代码 def func(n): return n ** n print(func(10)) # 换成匿名函数 func = lambda n: n ** n print(func(10))
2、匿名函数的格式
函数名 = lambda 参数 ：返回值 #参数可以有多个，用逗号隔开 #匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值 #返回值和正常的函数一样可以是任意数据类型
3、匿名函数与内置函数结合使用
# 匿名函数与内置函数相结合使用。 # 例1 l1 = [1, 2, 3, 4, 5, 6] def func(x): return x % 2 == 0 obj1 = filter(lambda x: x % 2 == 0, l1) print(list(obj1)) # [2, 4, 6] # 例2 l = [3, 2, 100, 999, 213, 1111, 31121, 333] dic = {'k1': 10, 'k2': 100, 'k3': 30} def func(x): return dic[x] ret = dic[max(dic, key=lambda x: dic[x])] print(ret) # 100
三、递归函数
1、什么是递归函数
递归函数：在一个函数里，自己调用自己
递归的最大深度：997（防止不受外界阻力一直递归下去耗费耗费内存）
# 验证997深度 def foo(n): print(n) n += 1 foo(n) foo(1)
2、什么时候回用到递归呢？
举个例子：
问a多大了？
a说，我比 b 大两岁。 n = 4
b说，我比 c 大两岁。 n = 3
c说，我比 d 大两岁。 n = 2
d说，我18了。 n = 1
这个时候怎么计算a多大？
先来分析一下 age(d) = 18 age(c) = age(d) + 2 age(b) = age(c) + 2 age(a) = age(b) + 2
这种情况用函数写出来：
def age(n):
if n == 1: return 18 elif n > 1: return age(n-1) + 2 print(age(4))
具体步骤我们来分析一下
def age(4): if n == 1: return 30 elif n > 1: return age(3) + 2 def age(3): if n == 1: return 30 elif n > 1: return age(2) + 2 def age(2): if n == 1: return 30 elif n > 1: return age(1) + 2 def age(1): if n == 1: return 30 elif n > 1: return age(1) + 2
总结一下：
递归： 一定要返回值（返回值基本都是函数调用自己）
3、递归的具体应用
# 斐波那契数列 # 1 1 2 3 5 8 13 21 34..... # 第一种 用之前学过的老方法实现,这种方法会循环输出，一行显示一个数字 a = 0 b = 1 while b < 50: print(b) # 循环换行输出 1 2 3 5 8 13 21 34 a, b = b, a + b # 右边的表达式会在赋值变动之前执行， # 即先执行右边，比如第一次循环得到b-->1,a+b --> 0+1 然后再执行赋值 a,b =1,0+1,所以执行完这条后a=1,b=1 # 第二种 同一行输出所有数字 a = 0 b = 1 while b < 50: print(b, end=',') # end 可以将print输出到同一行并以 ,号结尾 # 结果为：1,1,2,3,5,8,13,21,34, a, b = b, a + b # 第三种 递归实现 循环输出前9项 def func(n): if n <= 1: return n else: return (func(n - 1) + func(n - 2)) for i in range(9): print(func(i)) # 第四种 递归方式实现 生成前9项的一个列表 lis = [] for i in range(9): if i == 0 or i == 1: # 第1,2项 都为1 lis.append(1) else: lis.append(lis[i-2]+lis[i-1]) # 从第3项开始每项值为前两项值之和 print(lis) # [1, 1, 2, 3, 5, 8, 13, 21, 34] # 递归顺序输出整数 1 2 3 4 5 6 7 8 9... def func(n): if n > 0 and n < 10: print(n) func(n+1) func(1) # 递归倒序输出整数 9 8 7 6 5 4 3 2 1... def func(n): if n < 10 and n > 0: print(n) func(n-1) func(9) # 求1~100的和 def sum(n): if n > 0 and n < 101: return n + sum(n + 1) else: return 0 print(sum(1)) # 5050