2019.8.14学习内容及笔记

小结

函数递归

num = 0
count = 0
while count < 101:
    print(count) # 0--100循环
    num += count
    count += 1
print(num) # 0--100求和

递归 ： 递进 ； 归来

count = 0
def f1():
    global count # 修改成全局的count，让下面的count都是全局的count
    count += 1
    print(count) 
    f1()
f1()

递归的核心：递进的时候能够到达一个结果，问题的规模越来越小（不一定要真正到达）；设置一个条件，能够让最后一次函数调用结束；

递归代码：（递归更多是一种思想，用来解决某种问题）

count = 0                                       
def f1():                                       
    global count # 将局部里面的count修改成全局的count       
    if count > 100:                             
        return                                  
    count += 1                                  
    print(count)                                
    f1()                                        
f1()                                            

s = '{[]}'                           
def isvalid(s: str) ->bool:          
    print(s)                         
    s = ''                           
    if not s:                        
        return True                  
    if s.find('[]') != -1 or s.find('
        if '{}' in s:                
            s = s.replace('{}','')   
        if '[]'in s:                 
            s = s.replace('[]','')   
        if '()'in s:                 
            s = s.replace('()','')   
        if s == '':                  
            return True              
        res = isvalid(s)             
        print(res)                   
        if not res:                  
            return False             
    else:                            
        return True                  
res = isvalid(s)                     
print(res)                           

# 求年龄                            
 # 16/18/20/22/24/26,求第五人的年龄     
                                 
def func(x):                     
    age = 16                     
    age = age + 2*x              
    return age                   
res = func(5)                    
print(res)                       

# 内置方法                          
# abs(绝对值)                      
#print(abs(-10))  # 10          
                                
# bin （二进制）                     
#print(bin(97)) # 0b1100001 ：011
                                
# hex （十六进制）                    
#print(hex(97)) # 0x61          
                                
# oct （八进制）                     
# print(oct(97)) # 0o141     

# def func():                              
#     pass                                 
# print('callable(func):',callable(func)) #
#print('callable(1,]):',callable([1,])) # F
                                           
# chr() 返回ascll码对应字符                       
# print(chr(97)) #a                        
                                           
# ord() chr()参考ASCII码表将数字转成对应字符；ord()将字符转换成
#vprint(ord('a'))                          
                                           
# enumerate  将元素按索引位置排列出来                  
# for ind, value in enumerate([1,2,3]):    
#     print(ind,value)   # 0 1             
#                        # 1 2             
#                        # 2 3             
                                           
# eval() 把字符串翻译成数据类型                       
#print("eval('1+1'):", eval('1+1'))# eval('
                                           
# exec()  执行，相当于print，在python2中使用          
# exec('print("12345")')  #12345           
                                           
# 只要记住一个enumerate                          

面向过程编程

拆分：面向 过程 编程

按照 流程（流水线思想） 码代码

一堆变量/参数--》函数一（过程一）--》函数二（过程二）--》结果

上一个过程的输出必定是下一个过程的输入

面向过程编程优点：思路清晰

缺点：

1. 上一个过程完蛋了，下一个过程也完蛋
2. 功能与功能之间不独立
3. 牵一发而动全身