python

　　基本认知

　　python是一种面向对象的解释性的计算机语言，它是结合了解释性，编译性，互动性和面向对象的脚本语言

　　python的应用领域非常广泛

　　　　比如：WEB开发、网络编程、爬虫、云计算、AI、自动化运维、金融分析、科学计算、游戏开发等领域

　　所有语言一样，python也同样有自己的优缺点：

　　　　优点：开源，免费，易学，易维护，可移植，可扩展。

　　　　缺点：相比较编译性语言，运行速度慢，代码不能加密。

　

　一、编程语言介绍

 

　　1.机器语言：直接用二进制编程，直接控制硬件，需要掌握硬件的操作细节

     　　优点：执行效率高
     　　缺点:   开发效率低

　　2.汇编语言:用英文标签取代二进制指令去编写程序，直接控制硬件，需要掌握硬件的操作细节。   

　　　 优点：开发效率比机器语言高
    　　 缺点：仍然没有改变直接操作硬件的本质，执行效率高，但不如机器语言高。

　　3.高级语言:直接用人类的语言去编写程序，不再需要掌握硬件的操作细节。
  　　 编译型C：类似于谷歌返回，经过一次翻译，以后可以直接拿着翻译的结果去执行。
  　　 编译的工具----->编译器
  　　 　　优点：执行效率比解释器高
   　　　　缺点：开发效率低于解释型
  　　 解释型python：类似与同声传译，翻译官相当于解释器。
   　　　　优点：开发效率高于编译型。
  　　　　 缺点：执行效率低于编译型。

　　4.安装python解释器，实现多版本共存
   　　  设置环境变量PATH

　　5.运行python程序的两种方式:
  　　 方式一：交互式：
     　　 优点:输入一行代码立刻返回结果
     　　 缺点：无法永久保存
   　   方式二:(命令行)：pythonD:\test.txt
     　　 优点：以文件的方式将代码永久保存了下来，以后还可以用。
  
   　　注意：
   　　　　1.运行python程序是不考虑文件后缀名的，但约定俗成，应该将python程序的后缀名命名为.py
   　　　　2.运行python程序的三个步骤(******)
    　　　　   1.先启动python解释器
     　　　　  2.将python程序当中普通的文本文件读入内存（此时没有语法的概念）
    　　　　   3.python解释器解释执行刚刚读入内存的代码，开始识别python的语法
  
　　 6.变量
 　　7.与用户交互
 　　8.基本数据类型：
  　　　　int
  　　　　flot
  　　　　str
  　　　　list
  　　　　dic
  　　　　bool

 

　　二、变量

　　　　什么是变量？
    　　　　量：是衡量/记录现实世界中的某种特征/状态
   　　 　　变：指的是记录的状态是可以发生变化的

　　　　为什么要用变量
   　　 　　是为了让计算机能够像人一样去将一个事物的特征/状态记忆下来（存到计算机内存)
   　　 　　以后可以取出来使用
　　　　如何使用变量
   　　　　#定义变量的语法
   　　　　age=18
   　　　　变量名：相当于一个门牌号，是访问到值的唯一方式
   　　　　 =：赋值符号是将值的内存地址绑定给变量名age
   　　　　值：用来表示状态的

 

　　　　变量的使用:通过变量引用
   　　　　  #print(age)
　　　　　　总结：变量的使用规则：先定义，再通过变量名去引用

 

　　　　变量名的命名规则：变量是用来访问变量值的，所以变量名应该遵循一定的规范，来方便我们标识存到内存中值的功能

　　　　　　大前提：变量名的命名应该能够反映出值记录的状态
  　　 　　　　salary=3.1
   　　　　　　name='wxx'
   　　　　　　weight=75
　　　　　　#1.变量名只能是字母，数字或下划线的任意组合
　　　　　　#2.变量名的第一个字符不能是数字
　　　　　　#3.不能将变量名命名为python的关键字
　　　　　　'''
　　　　　　'and','as','asssert','break',,,,,,,,
　　　　　　'''
　　　　　　#4变量名命名风格：1.下划线(纯小写+下划线)
  　　　　　　 age_of_oldboy=73#推荐
　　　　　　#2 驼峰体
 　　　　　　  AgeOfOldboy=73

 

　　　　　　#6.定义一个变量，变量的值都具备三个特征
　　　　　　id:反映值在内存中的位置
　　　　　　类型:不同类型的值是用来表示/记录不同的状态的
　　　　　　value：即我们存放到内存中的数据，用来表示某种状态
   　　 　　　　#age=18
   　　　　　　 #print(id(age))
    　　　　　　#print(type(age))
    　　　　　　#peint(age)

　　

 

　　三、基本数据类型

　　　　 数字　　

　　　　#int整形
　　　　定义：age=10 #age=int(10)
　　　　用于标识：年龄，等级，身份证号，qq号，个数

　　　　#float浮点型
　　　　定义：salary=3.1 #salary=float(3.1)
　　　　用于标识：工资，身高，体重
　　　　

　　　　字符串(str)
　　　　#在python中，加''或者""、'''  '''引号的字符就是字符串类型
　　　　定义：var='hello word' #var=str('hello word')
　　　　用于标识：描述性的内容，比如姓名，性别等
　　　　在python中单引号、双引号、三引号并没有什么区别，使用三引号可以为程序字段添加注释功能，这里需要注意的是引号的嵌套
　　　　字符串常用操作：
　　　　　　1，字符串拼接：
　　　　　　　　var1='hello'
　　　　　　　　var2='word'
　　　　　　　　var=var1+var2
　　　　　　　　print(var)
　　　　　　　　>>>'helloword'
　　　　　　2,字符串相乘
　　　　　　　　test=var*5
　　　　　　　　print（test）
　　　　　　　　>>>'hellowordhellowordhellowordhellowordhelloword'
　　　　　　注意：
　　　　　　　　1，字符串相加并不是在字符串1的基础之上加上字符串2，而是申请一个全新的内存空间存入字符串1和字符串2，相当于字符串1与字符串2的空间被复制了一次
　　　　　　　　2，字符串只能加字符串类型，不能字符串加其他类型数据
　　　　
　　　　
　　　　列表(list)
　　　　#在[]内用逗号分隔开，可以存放多个任意类型的值
　　　　定义：var=['name','age','sex',]　　#var=list(['name','age','sex',])
　　　　用来标识：存多个值的情况，比如存储一个公司的多个部门
　　　　列表用作存储数据操作
　　　　列表取值操作

　　　　字典（dict）
　　　　#在{}内用逗号分割开，可以存放多个key:value类型的值，value可以是任意类型
　　　　定义：info={
　　　　　　　　　'name':'wxx',
　　　　　　　　　'age':18,
　　　　　　　　　'sex':'未知'
　　　　　　　　}
　　　　字典的嵌套、取值
　　　　

　　　　布尔类型：True和False　　　 
　　　　
　　　　
　　　　可变不可变类型：
　　　　　　可变类型定义：在id不变的情况下，value可以变，比如：列表，字典
　　　　　　不可变类型定义：value变的情况下，id也跟着改变，比如：字符串，元组


　　　　格式化输出：
　　　　　　s%字符串占位符：可以接收字符串，也可以接收数字
　　　　　　d%数字占位符：只能接收数字


　　四，流程控制

　　　　流程控制之if...else
　　　　流程控制之while循环
　　　　流程控制之for循环

　　函数

　一，初级函数

　　　　函数基础

　　　　1，什么是函数？

　　　　　　函数是可以实现一些特定功能的方法或者程序。

　　　　2，为什么要用函数？

　　　　　　　　——不用函数会出现哪些问题

　　　　　　　　1，代码的组织结构不清晰，可读性差　　

　　　　　　　　2，遇到重复的功能只能重复编写实现代码，代码冗余
　　　　　　　　3，需要扩展功能时，需要找出所有实现该功能的代码去修改，无法统一管理，而且维护难度大

　　　　3，python中函数分为两类

　　　　　　　　1，内置函数

　　　　　　　　　　python解释器已经为我们定义好了的函数即内置函数。对于内置函数，我们无需事先定义，拿来直接用即可，如len(),sum(),max()

　　　　　　　　2，自定义函数

　　　　　　　　　　对于内置函数所不能实现的功能，需要我们自己根据需求，事先定制好自己的函数来实现某种功能，遇到应用场景时，调用自定义的函数即可

 　　　　4，如何自定义函数

　　　　　　　　#语法
　　　　　　　　def 函数名(参数1,参数2,参数3,...):
   　　　　　　　　　　 '''注释'''
   　　　　　　　　　　 函数体
    　　　　　　　　　　return 返回的值

　　　　　　　　#函数名要能反映其意义

　　　　5，自定义函数的使用原则：先定义，后调用

　　　　　　　　定义阶段：只检测语法，不执行代码
　　　　　　　　def foo():
  　　　　　　　　  print('from foo')
 　　　　　　　　   bar()
　　　　　　　　def bar():
   　　　　　　　　 print('from bar')
　　　　　　　　调用阶段
　　　　　　　　foo()

　　　　 6，函数定义的三种形式

　　　　　　　　1、无参：应用场景仅仅只是执行一些操作，比如与用户交互，打印
　　　　　　　　2、有参：需要根据外部传进来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值
　　　　　　　　3、空函数：设计代码结构

　　　　　　　　注意：

　　　　　　　　　　1、定义时无参，意味着调用时也无需传入参数
　　　　　　　　　　2、定义时有参，意味着调用时则必须传入参数

　　　　　7，调用函数

　　　　　　　　1，函数的调用：函数名加括号
　　　　　　　　　　　　1 先找到名字
　　　　　　　　　　　　2 根据名字调用代码

　　　　　　　　2，函数调用的三种形式

　　　　　　　　　　　　1 语句形式：foo()
　　　　　　　　　　　　2 表达式形式：3*len('hello')
　　　　　　　　　　　　3 当中另外一个函数的参数：range(len('hello'))

　　　　　8，函数的参数

　　　　　　　　1，形参与实参

　　　　　　　　　　形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定

　　　　　　　　

　　　　　　　　2、位置参数：按照从左到右的顺序定义的参数        

　　　　　　　　　　位置形参：必选参数        

　　　　　　　　　　位置实参：按照位置给形参传值

　　　　　　　　3、关键字参数：按照key=value的形式定义的实参        

　　　　　　　　　　无需按照位置为形参传值        

　　　　　　　　　　注意的问题：                

　　　　　　　　　　　　1. 关键字实参必须在位置实参右面                

　　　　　　　　　　　　2. 对同一个形参不能重复传值

　　　　　　　　4、默认参数：形参在定义时就已经为其赋值        

　　　　　　　　　　可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）        

　　　　　　　　　　注意的问题：                

　　　　　　　　　　　　1. 只在定义时赋值一次                

　　　　　　　　　　　　2. 默认参数的定义应该在位置形参右面                

　　　　　　　　　　　　3. 默认参数通常应该定义成不可变类型

 　　　　　　　　5、可变长参数：
        　　　　　　　　可变长指的是实参值的个数不固定
        　　　　　　　　而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs

 　　　　　　　　6、命名关键字参数：

　　　　　　　　　　*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递可以保证，传入的参数中一定包含某些关键字

　　　　　　　　　　def foo(x,y,*args,a=1,b,**kwargs):
　　　　　　　　　　　   print(x,y)
          　　　　　　　　　print(args) print(a)
         　　　　　　　　　 print(b)
         　　　　　　　　　 print(kwargs)

　　　　　　　　　　foo(1,2,3,4,5,b=3,c=4,d=5)
　　　　　　　　　　结果：            

　　　　　　　　　　　　1            

　　　　　　　　　　　　2            

　　　　　　　　　　　　(3, 4, 5)            

　　　　　　　　　　　　1            

　　　　　　　　　　　　3            

　　　　　　　　　　　　{'c': 4, 'd': 5}

函数对象

1，函数是第一类对象

　　1、可以被引用
　　2、可以当作参数传递
　　3、返回值可以是函数
　　4、可以当作容器类型的元素

2，利用函数该特性，可以取代if多分支

def foo():
    print('foo')

def bar():
    print('bar')

dic={
    'foo':foo,
    'bar':bar,
}
while True:
    choice=input('>>: ').strip()
    if choice in dic:
        dic[choice]()

 

函数嵌套

1，函数的嵌套调用

def max(x,y):
    return x if x > y else y

def max4(a,b,c,d):
    res1=max(a,b)
    res2=max(res1,c)
    res3=max(res2,d)
    return res3
print(max4(1,2,3,4))

 

2，函数的嵌套定义

def f1():
    def f2():
        def f3():
            print('from f3')
        f3()
    f2()

f1()
f3() #报错

 

名称空间

1，什么是名称空间

　　名称空间：存放名字的地方，三种名称空间，（之前遗留的问题x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方　　　　　

2，名称空间的加载顺序

　　python test.py
　　#1、python解释器先启动，因而首先加载的是：内置名称空间
　　#2、执行test.py文件，然后以文件为基础，加载全局名称空间
　　#3、在执行文件的过程中如果调用函数，则临时产生局部名称空间

3，名称空间的查找顺序

局部名称空间--->全局名称空间--->内置名称空间

#需要注意的是：在全局无法查看局部的，在局部可以查看全局的，如下示例

# max=1
def f1():
    # max=2
    def f2():
        # max=3
        print(max)
    f2()
f1()
print(max)

 

作用域

#1、作用域即范围
        - 全局范围（内置名称空间与全局名称空间属于该范围）：全局存活，全局有效
　     - 局部范围（局部名称空间属于该范围）：临时存活，局部有效
#2、作用域关系是在函数定义阶段就已经固定的，与函数的调用位置无关，如下
x=1
def f1():
    def f2():
        print(x)
    return f2
x=100
def f3(func):
    x=2
    func()
x=10000
f3(f1())

#3、查看作用域：globals(),locals()


LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
locals 是函数内的名字空间，包括局部变量和形参
enclosing 外部嵌套函数的名字空间（闭包中常见）
globals 全局变量，函数定义所在模块的名字空间
builtins 内置模块的名字空间

 

 

 

　　　　

二，高级函数

闭包函数

1，什么是闭包函数？

#内部函数包含对外部作用域而非全局作用域的引用

#提示：之前我们都是通过参数将外部的值传给函数，闭包提供了另外一种思路，包起来喽，包起呦，包起来哇

        def counter():
            n=0
            def incr():
                nonlocal n
                x=n
                n+=1
                return x
            return incr

        c=counter()
        print(c())
        print(c())
        print(c())
        print(c.__closure__[0].cell_contents) #查看闭包的元素

 

2，闭包的意义与应用

#闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
#应用领域：延迟计算（原来我们是传参，现在我们是包起来）
    from urllib.request import urlopen

    def index(url):
        def get():
            return urlopen(url).read()
        return get

    baidu=index('http://www.baidu.com')
    print(baidu().decode('utf-8'))

 

 

装饰器

1，为何要用装饰器

　在不改变已有函数代码的前提下，为了给已经存在的函数或对象添加额外的功能

 2，什么是装饰器

　装饰器本质上就是一个python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外的功能，装饰器的返回值也是一个函数对象。
　它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。
　装饰器是解决这类问题的绝佳设计模式，有了装饰器，我们就可以抽离出大量的函数功能本身无关的雷同代码并继续实现代码重用

 3，装饰器原则

　　装饰器遵循：开放封闭原则

　　　　开放封闭原则：对修改封闭，对扩展开放

　　　　　　1，不修改被装饰对象的源代码

　　　　　　2，不修改被装饰对象的调用方式

4，装饰器语法

被装饰函数的正上方，单独一行
        @deco1
        @deco2
        @deco3
        def foo():
            pass

        foo=deco1(deco2(deco3(foo)))

 

 5，装饰器的使用

无参装饰器

import time
def timmer(func):
    def wrapper(*args,**kwargs):
        start_time=time.time()
        res=func(*args,**kwargs)
        stop_time=time.time()
        print('run time is %s' %(stop_time-start_time))
        return res
    return wrapper

@timmer
def foo():
    time.sleep(3)
    print('from foo')
foo()

无参装饰器

 

有参装饰器

def auth(driver='file'):
    def auth2(func):
        def wrapper(*args,**kwargs):
            name=input("user: ")
            pwd=input("pwd: ")

            if driver == 'file':
                if name == 'egon' and pwd == '123':
                    print('login successful')
                    res=func(*args,**kwargs)
                    return res
            elif driver == 'ldap':
                print('ldap')
        return wrapper
    return auth2

@auth(driver='file')
def foo(name):
    print(name)

foo('egon')

有参装饰器

 

6，装饰器之wraps

from functools import wraps

def deco(func):
    @wraps(func) #加在最内层函数正上方
    def wrapper(*args,**kwargs):
        return func(*args,**kwargs)
    return wrapper

@deco
def index():
    '''哈哈哈哈'''
    print('from index')

print(index.__doc__)

 

7，装饰器叠加

　　1. 加载顺序(outter函数的调用顺序):自下而上
　　2. 执行顺序(wrapper函数的执行顺序):自上而下　　

def outter1(func1): #func1=wrapper2的内存地址
    print('加载了outter1')
    def wrapper1(*args,**kwargs):
        print('执行了wrapper1')
        res1=func1(*args,**kwargs)
        return res1
    return wrapper1

def outter2(func2): #func2=wrapper3的内存地址
    print('加载了outter2')
    def wrapper2(*args,**kwargs):
        print('执行了wrapper2')
        res2=func2(*args,**kwargs)
        return res2
    return wrapper2

def outter3(func3): # func3=最原始的那个index的内存地址
    print('加载了outter3')
    def wrapper3(*args,**kwargs):
        print('执行了wrapper3')
        res3=func3(*args,**kwargs)
        return res3
    return wrapper3



@outter1 # outter1(wrapper2的内存地址)======>index=wrapper1的内存地址
@outter2 # outter2(wrapper3的内存地址)======>wrapper2的内存地址
@outter3 # outter3(最原始的那个index的内存地址)===>wrapper3的内存地址
def index():
    print('from index')

print('======================================================')
index()

示范代码

 

 

迭代器

1，什么是迭代器？

在python中如果一个对象同时有__iter__()方法和__next__()方法，则称这个对象是迭代器（Iterator）；
其中__iter__()方法是让对象可以用for...in循环遍历，__next__()方法是让对象可以通过next（实例名）访问下一个元素。

 

 2，为何要有迭代器？什么是可迭代对象？什么是迭代器对象？

#1、为何要有迭代器？
对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器

#2、什么是可迭代对象？
可迭代对象指的是内置有__iter__方法的对象，即obj.__iter__，如下
'hello'.__iter__
(1,2,3).__iter__
[1,2,3].__iter__
{'a':1}.__iter__
{'a','b'}.__iter__
open('a.txt').__iter__

#3、什么是迭代器对象？
可迭代对象执行obj.__iter__()得到的结果就是迭代器对象
而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象

文件类型是迭代器对象
open('a.txt').__iter__()
open('a.txt').__next__()


#4、注意：
迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象

 

3，迭代器对象的使用

dic={'a':1,'b':2,'c':3}
iter_dic=dic.__iter__() #得到迭代器对象，迭代器对象即有__iter__又有__next__，但是：迭代器.__iter__()得到的仍然是迭代器本身
iter_dic.__iter__() is iter_dic #True

print(iter_dic.__next__()) #等同于next(iter_dic)
print(iter_dic.__next__()) #等同于next(iter_dic)
print(iter_dic.__next__()) #等同于next(iter_dic)
# print(iter_dic.__next__()) #抛出异常StopIteration，或者说结束标志

#有了迭代器，我们就可以不依赖索引迭代取值了
iter_dic=dic.__iter__()
while 1:
    try:
        k=next(iter_dic)
        print(dic[k])
    except StopIteration:
        break
        
#这么写太丑陋了，需要我们自己捕捉异常，控制next，python这么牛逼，能不能帮我解决呢？能，请看for循环

 

4，for循环

#基于for循环，我们可以完全不再依赖索引去取值了
dic={'a':1,'b':2,'c':3}
for k in dic:
    print(dic[k])

#for循环的工作原理
#1：执行in后对象的dic.__iter__()方法，得到一个迭代器对象iter_dic
#2: 执行next(iter_dic),将得到的值赋值给k,然后执行循环体代码
#3: 重复过程2，直到捕捉到异常StopIteration,结束循环

 

5，迭代器的优缺点

#优点：
  - 提供一种统一的、不依赖于索引的迭代方式
  - 惰性计算，节省内存
#缺点：
  - 无法获取长度（只有在next完毕才知道到底有几个值）
  - 一次性的，只能往后走，不能往前退

 

6,迭代器有两种类型：

　　1，集合数据类型：列表，字典，元组，集合，字符串

　　2，generator:包括生成器和带有yield的生成函数

 

 

生成器

1，什么是生成器？

#只要函数内部包含有yield关键字，那么函数名()的到的结果就是生成器，并且不会执行函数内部代码

def func():
    print('====>first')
    yield 1
    print('====>second')
    yield 2
    print('====>third')
    yield 3
    print('====>end')

g=func()
print(g) #

 

2，生成器就是迭代器

g.__iter__
g.__next__
#2、所以生成器就是迭代器，因此可以这么取值
res=next(g)
print(res)

 

3，协程函数与yield

#yield关键字的另外一种使用形式：表达式形式的yield
def eater(name):
    print('%s 准备开始吃饭啦' %name)
    food_list=[]
    while True:
        food=yield food_list
        print('%s 吃了 %s' % (name,food))
        food_list.append(food)

g=eater('egon')
g.send(None) #对于表达式形式的yield，在使用时，第一次必须传None，g.send(None)等同于next(g)
g.send('蒸羊羔')
g.send('蒸鹿茸')
g.send('蒸熊掌')
g.send('烧素鸭')
g.close()
g.send('烧素鹅')
g.send('烧鹿尾')

 

4，定义生成器的方式：

　　1，列表生成式 [] 改为 (),使用for循环调用即可

　　2，定义yield关键字

　　　　如果一个函数定义中包含yield关键字，则这个函数为一个生成器

　　　　注意：yield的原理是，在每次进行迭代调用next()时执行，遇到yield语句返回，下次执行从上一次返回的yield语句处继续执行。

 

 

三元表达式

 

name=input('姓名>>: ')
res='SB' if name == 'wxx' else 'NB'
print(res)

 

 列表推到式

 

#1、示例
egg_list=[]
for i in range(10):
    egg_list.append('鸡蛋%s' %i)

egg_list=['鸡蛋%s' %i for i in range(10)]

#2、语法
[expression for item1 in iterable1 if condition1
for item2 in iterable2 if condition2
...
for itemN in iterableN if conditionN
]
类似于
res=[]
for item1 in iterable1:
    if condition1:
        for item2 in iterable2:
            if condition2
                ...
                for itemN in iterableN:
                    if conditionN:
                        res.append(expression)

#3、优点：方便，改变了编程习惯，可称之为声明式编程

 

生成器表达式

 

#1、把列表推导式的[]换成()就是生成器表达式

#2、示例：生一筐鸡蛋变成给你一只老母鸡，用的时候就下蛋，这也是生成器的特性
>>> chicken=('鸡蛋%s' %i for i in range(5))
>>> chicken
 at 0x10143f200>
>>> next(chicken)
'鸡蛋0'
>>> list(chicken) #因chicken可迭代，因而可以转成列表
['鸡蛋1', '鸡蛋2', '鸡蛋3', '鸡蛋4',]

#3、优点：省内存，一次只产生一个值在内存中

 

 

递归

1，递归调用的定义

 

#递归调用是函数嵌套调用的一种特殊形式，函数在调用时，直接或间接调用了自身，就是递归调用
#直接调用本身
def f1():
    print('from f1')
    f1()
f1()

#间接调用本身
def f1():
    print('from f1')
    f2()

def f2():
    print('from f2')
    f1()
f1()

# 调用函数会产生局部的名称空间，占用内存，因为上述这种调用会无需调用本身，python解释器的内存管理机制为了防止其无限制占用内存，对函数的递归调用做了最大的层级限制
四 可以修改递归最大深度

import sys
sys.getrecursionlimit()
sys.setrecursionlimit(2000)

def f1(n):
    print('from f1',n)
    f1(n+1)
f1(1)

虽然可以设置，但是因为不是尾递归，仍然要保存栈，内存大小一定，不可能无限递归，而且无限制地递归调用本身是毫无意义的，递归应该分为两个明确的阶段，回溯与递推

详解

 

2，递归调用分为两个阶段：递归，回溯

 

#1、递归调用应该包含两个明确的阶段：回溯，递推
    回溯就是从外向里一层一层递归调用下去，
        回溯阶段必须要有一个明确地结束条件，每进入下一次递归时，问题的规模都应该有所减少（否则，单纯地重复调用自身是毫无意义的）

    递推就是从里向外一层一层结束递归

#2、示例+图解。。。
# salary(5)=salary(4)+300
# salary(4)=salary(3)+300
# salary(3)=salary(2)+300
# salary(2)=salary(1)+300
# salary(1)=100
#
# salary(n)=salary(n-1)+300     n>1
# salary(1) =100                n=1

def salary(n):
    if n == 1:
        return 100
    return salary(n-1)+300

print(salary(5))

 

 

3，python中的递归效率低且没有尾递归优化

 

#python中的递归
python中的递归效率低，需要在进入下一次递归时保留当前的状态，在其他语言中可以有解决方法：尾递归优化，即在函数的最后一步（而非最后一行)调用自己，尾递归优化：http://egon09.blog.51cto.com/9161406/1842475
但是python又没有尾递归，且对递归层级做了限制

#总结递归的使用：
1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

 

 

4，二分法

想从一个按照从小到大排列的数字列表中找到指定的数字，遍历的效率太低，用二分法（算法的一种，算法是解决问题的方法）可以极大低缩小问题规模

 

实现类似于in的效果

l=[1,2,10,30,33,99,101,200,301,311,402,403,500,900,1000] #从小到大排列的数字列表

def search(n,l):
    print(l)
    if len(l) == 0:
        print('not exists')
        return
    mid_index=len(l) // 2
    if n > l[mid_index]:
        #in the right
        l=l[mid_index+1:]
        search(n,l)
    elif n < l[mid_index]:
        #in the left
        l=l[:mid_index]
        search(n,l)
    else:
        print('find it')


search(3,l)

实现类似于in的效果

 

实现类似于l.index(30)的效果

l=[1,2,10,30,33,99,101,200,301,402]

def search(num,l,start=0,stop=len(l)-1):
    if start <= stop:
        mid=start+(stop-start)//2
        print('start:[%s] stop:[%s] mid:[%s] mid_val:[%s]' %(start,stop,mid,l[mid]))
        if num > l[mid]:
            start=mid+1
        elif num < l[mid]:
            stop=mid-1
        else:
            print('find it',mid)
            return
        search(num,l,start,stop)
    else: #如果stop > start则意味着列表实际上已经全部切完，即切为空
        print('not exists')
        return

search(301,l)

实现类似于l.index(30)的效果

 

 

 

匿名函数

1，什么是匿名函数？

 

匿名就是没有名字
def func(x,y,z=1):
    return x+y+z

匿名
lambda x,y,z=1:x+y+z #与函数有相同的作用域，但是匿名意味着引用计数为0，使用一次就释放，除非让其有名字
func=lambda x,y,z=1:x+y+z 
func(1,2,3)
#让其有名字就没有意义

 

 

2，有名函数与匿名函数对比

 

#有名函数与匿名函数的对比
有名函数：循环使用，保存了名字，通过名字就可以重复引用函数功能

匿名函数：一次性使用，随时随时定义

应用：max，min，sorted,map,reduce,filter

 

内置函数

注意事项

 

#注意：内置函数id()可以返回一个对象的身份，返回值为整数。这个整数通常对应与该对象在内存中的位置，但这与python的具体实现有关，不应该作为对身份的定义，即不够精准，最精准的还是以内存地址为准。is运算符用于比较两个对象的身份，等号比较两个对象的值，内置函数type()则返回一个对象的类型

#更多内置函数：https://docs.python.org/3/library/functions.html?highlight=built#ascii 

 

 

 

　　常用模块

 

一time与datatime模块

二random模块

三os模块

四sys模块

五shutil模块

六json与pickle模块

七shelve模块

八xml模块

九configparser模块

十hashlib模块

十一suprocess模块

十二logging模块

十三re模块

十四numpy模块

十五pandas模块

十六collections模块

十七PyQt5模块

十八pyecharts模块

十九echarts模块

二十jieba模块

1，matplotlib模块

2，scipy模块

3，pygame模块

4，opencv-python模块

5，xlrd模块

6，xlwt模块

7，string模块

8，tkinter模块

9，qrcode模块

10，pystrich模块

　　面向对象编程设计与开发

　　网络编程-socket开发

　　并发编程

 

　　　　

 

转载于:https://www.cnblogs.com/Rglin/p/9338216.html