函数知识的回顾

内容回顾

1.文件

文件的基本操作

什么是文件？
	文件是操作系统暴露给用户操作硬盘的快捷方式
文件打开的固定模板
	with open(r'a.txt', r, encoding='utf8') as f
   with关键字 open关键字  r路径前面特殊含义防止查找困难，
'a.txt' 文件的路径，r只读模式。encoding编码模式，as f赋值给变量名f

文件的读写模式

r  只读模式
w  只写模式
a  尾部追加

文件操作模式

t	文本模式
	只能操作文本文件
	读写都是以字符为单位
   需要写encoding参数

b   二进制模式
	可以操作所有的文件类型
   读写是以bytes为单位
	不需要写conding参数

文件的方法

read  只读模式
write  只写模式
readlines  一次性的读并转为列表
writeable  判断文件是否可写
readable   判断文件是否可读
for循环   相当于一行行的读文件
readline  一次只读一行
writelines  接收一个列表，一次性将列表中的所有数据写入
fuush   将内存中文件数据立刻刷到硬盘相当于ctrl+s

文件光标

关键字
	seek
        """
    seek(offset, whence)
        offset是位移量 以字节为单位
        whence是模式   0  1  2
            0是基于文件开头
                文本和二进制模式都可以使用
            1是基于当前位置
                只有二进制模式可以使用
            2是基于文件末尾
                只有二进制模式可以使用
    """

文件内数据的修改

硬盘存储的原理：
	硬盘存储就像于光盘会刻在硬盘上面
文件内数据修改：
1.直接覆盖原来的内容，重新写一份新的
2.直接在另外的地方重新写一份，然后直接将文件名改为原文件的名字

2.普通函数

函数的语法结构

def 函数名():  # def 是关键字  ()内为形参
"""函数注释"""
	函数体代码  # 注意缩进
函数名()  # 直接调用函数  ()内为实参

函数的定义与调用

函数在定义阶段只判断语法是否错误，不执行
函数在调用阶段才会执行函数
函数的定义就是关键字加函数名，下面有函数体代码
函数的调用只有函数名加括号、
函数分分类：
	空函数，就是只是定义了一个函数体，但是没有内容，提醒以后可以补
 	无参函数：就是不需要传参，定义函数的时候括号内什么都没有
	有参函数：需要传参，定义函数的时候括号内有需要传参的内容

函数的返回值

代码展示：
	def intex():
    print('index')
    return 123
return后面跟着就是返回值，表示调用函数以后需要返回给调用者的结果
1.返回值的获取
	def intex():
    print('index')
    return 123
res = intex()   # 有等号先看等号右边是调用函数，函数调用以后将返回值赋值给变量名res，这样就可以获取返回值了
2.return返回值的多种情况：
    1.没有return，默认返回None
    2.return返回值后面什么都没有，返回None
	 3.return后面有什么就返回什么
	 4.return后面有多个数据，会自动组成元组返回
	 5.函数体代码碰到return会直接结束

函数的参数

形参：函数定义阶段，函数名后面括号内填写的
实参：函数调用阶段，函数名后面括号内填写传给形参的

函数参数之位置参数

位置形参：函数定义阶段，括号内按照从左到右的顺序填写的变量名
位置实参：函数调用阶段，括号内按照从做到有的顺序填写的数据值
口诀：
"""
越简单越短的放在前面
越复杂越长的方在后面
"""

默认参数

默认形参：
	也叫关键字形参，函数在定义阶段会直接将一个变量名赋值，这样实参在传参的时候可以给这个位置传参，也可以不传，不传就直接使用默认数据值，传参的话，就按照传参的数据值
代码展示不传参：
def index(name, age=18):
	print(name, age)


index('a ning')  # a ning 18
"""没有传参年龄，会直接使用默认形参赋值的18"""
代码展示传参：
	def index(name, age=18):
    print(name, age)


index('a ning', 21)  # a ning 21
"""传参的情况下，会直接使用传参的数据值21"""

关键字实参

我们在传参的时候，想要把某个数据值直接给到形参，直接在实参中形参变量名 = 数据值，就可以把这个数据值专门给到这个形参
代码展示：
def index(name, age, hobby):
    print(name, age, hobby)


index('a ning', 21, hobby='yellow')  # a ning 21 yellow

可变长形参

代码展示(形参一定是在函数定义阶段)：
def index(*args):
    print(args)


index(1, 2, 3, 4, 5, 5)  # (1, 2, 3, 4, 5, 5)
"""*表示可以接收多余的位置实参然后赋值给变量名args，并组成元组的形式展示，如果没有传参那就是一个空的元组"""
代码展示：
def index(a, *args):
    print(a,args)


index(1, 2, 3, 4, 5, 5)  # 1 (2, 3, 4, 5, 5）
"""看形参，有一个位置形参还有一个可变长形参，那么位置形参就接收第一个位置实参，剩下的实参被可变长形参接收，组成一个元组"""
-------------------------------------------------------------
代码展示：
def index(**kwargs):
    print(kwargs)


index(a=1, b=2,c=2)  # {'a': 1, 'b': 2, 'c': 2}
"""**kwargs中**表示可以接收多余的关键字实参，并将其赋值给变量名kwargs，组成字典的形式（形参为键，实参为值）"""
可变长形参值的就是可以接收多的位置形参和关键字实参，*表示接收的是位置实参，展示为元组，**表示接收的是关键字实参，展示为字典

可变长实参

代码展示：
def index(a, b, c):
    print(a, b, c)


l1 = [1, 2, 3]
index(*l1)  # 1 2 3
"""实参中的*表示将列表l1打散成数据值，分别传参给形参，类似于for循环按照位置实参一一传给形参"""
列表的不同之处：
def index(a, b):
    print(a, b)


l1_dict = {'name':'a ning', 'age':18}
index(*l1_dict)  # name age
"""*可以打散列表，但是只能获取键传参过去"""
def index(name, age):
    print(name, age)


l1_dict = {'name': 'a ning', 'age': 18}
index(**l1_dict)  # a ning 18
"""**可以打散字典，但是要注意形参必须得是字典的键，否则会报错"""

函数名的多种用法

1.函数名可以作为返回值
代码展示：
def index():
    print('123')
    return index
res = index()
2.函数名可以当做变量名赋值
def index():
    print('123')
    return index
res = index
res()   # 这句话就相当于index() 同样起到调用函数的效果
3.函数名可以当做函数的参数
def index():
    print('123')
    return index
def func(a):
    print('a')
func(index)
4.可以做成容器的数据
def index():
    print('123')
    return index
def func(a):
    print('a')
is_dice = {'1':index, '2':func}

3.空间名称

空间名称的定义

什么名称空间？
	名称空间就是用来存储变量名名字以及和数据值绑定关系的地方
1.内置名称空间
	解释器级别，解释器运行自动产生，关闭则销毁
2.全局名称空间
	py文件级别，py文件运行的时候产生，运行结束则销毁
3.局部名称空间
	函数体代码级别，函数调用的时候产生，运行结束销毁

作用域

内置名称空间
	解释器级别的全局有效
全局名称空间
	py文件级别的全局有限
局部名称空间
	函数体代码内有效

名字的查找顺序

查找名字的时候，首先要看自己在哪个位置，然后再去找
1.当我们在局部名称空间的时候
局部名称空间>>>全局名称空间>>>内置名称空间
2.当我们在全局名称空间的时候
全局名称空间>>>内置名称空间

名字查找切记，名字一般是从小向外

global与nonlocal

global
	局部名称空间名字修改全局名称空间名字
nonlocal
	内层局部名称空间名字修改外层局部名称空间名字

4.闭包函数

定义：
	在函数内部的函数，就是函数嵌套，并且内部的函数用到了外部函数的名字
代码展示：
def index(name):
    name = 'jason'

    def inner():
        print(name)
闭包函数实际是给函数传参的另一种方式
代码展示：
def index(name):


    def inner():
        print(name)
    return inner
res = index('jason')  # res接收index函数的返回值inner
res()  # 调用res就相当于函数inner的调用

5.装饰器

有参装饰器和无参装饰器

装饰器的定义：在不改变对象原代码和调用方式的情况下给原代码增加新的功能呢
无参装饰器模板：
def outer(func_name):
    def inner(*args, **kwargs):
        print('函数执行添加的功能')
        res = func_name(*args, **kwargs)
        print('函数执行之后添加的功能')
        return res
    return inner
"""关键在与知道谁是谁，func_name其实是调用的函数，inner其实是调用的函数重新打的赋值"""
有参装饰器模板：
def outer_pulse(func):
    def outer(func_name):
        def inner(*args, **kwargs):
            print('函数执行添加的功能')
            res = func_name(*args, **kwargs)
            print('函数执行之后添加的功能')
            return res
        return inner
    return outer
"""当装饰器局内需要额外的参数时，需要用到有参装饰器"""
"""函数名加括号执行的优先级最高，先看函数名里面的括号传参，然后才会执行语法糖"""

装饰器语法糖

代码展示：
def outer(func_name):
    def inner(*args, **kwargs):
        print('函数执行前加的功能')
        res = func_name(*args, **kwargs)
        print('函数执行以后加的功能')
        return res

    return inner

@outer
def index():
    print('hello')
"""语法糖会自动将下面紧挨着的函数名当做第一个参数自动传给@后面的装饰器"""

多层语法糖

@outter1
@outter2
@outter3
def index():
    print('from index')
"""多层语法糖的加载顺序是有下往上的，从紧挨着函数的开始执行，每次执行之后如果上面还有语法糖，就会直接将返回值传给上一个语法糖，如果上面没有语法糖，则会变形将传给index"""

6.递归函数

1.函数的递归调用
	直接或者间接的调用自己
代码展示：
	def index():
    print('123')
    index()


	index()
"""最大递归深度1000"""
2.递归函数
  1.直接或者间接的调用自己
  2.每次调用都必须比上次简单
  3.有明确的结束条件   

二分法：

l1 = [12, 21, 32, 43, 56, 76, 87, 98, 123, 321, 453, 565, 678, 754, 812, 987, 1001, 1232]
def index(a, b):
    # if len(a)//2 == 0:
    #     print('抱歉没找到')
    #     return
    l1_num = len(a) // 2
    if b > a[l1_num]:
        l1_list = a[l1_num+1:]
        return index(l1_list, b)
    elif b < a[l1_num]:
        l2_list = a[:l1_num]
        return index(l2_list, b)
    else:
        print('找到了')

index(l1, 987)

7.三元表达式

三元表达式

name = 'jaosn'  # 给出条件
res = '老师' if name == 'jaosn' else '学生'
"""数据值1,if条件，else数据值2"""
print(res)
"""条件成立就会使用数据值1，条件不成立就会使用数据值2，一般是二选一的情况下使用"""

各种生成式

列表生成式
代码展示：
name_list = ['jason', 'kevin', 'oscar', 'tony', 'jerry']
# 给列表里面所有的人名后面加_Nb
name_list = ['jason', 'kevin', 'oscar', 'tony', 'jerry']
new_list = [name + '_NB' for name in name_list]
print(new_list)
"""先for循环name_lits，然后赋值给name，再添加_NB,因为在列表里面，所以直接就是一个新的列表"""
字典生成式
s1 = 'hello world'
s2 = {k:v for k,v in enumerate(s1, start=100)}
print(s2)
关键字：enumerate  将字母的索引值排列出来，并可以选择索引开始的数值

8.匿名函数

没有名字的函数，需要使用关键字lambda
语法结构：
lambda 形参：返回值
一般不单独只用

9.常见内置函数

重要的内置函数

1.map()  映射
代码展示：
l1 = [1, 2, 3, 4, 5]
res = map(lambda x: x + 1, l1)  # map配合lambda一起使用
print(list(res))  # [2, 3, 4, 5, 6]
映射产生的值也相当于工厂，所以需要转成列表一个个取出来
2.max/min  最大或者最小
l1 = [11,22,33,44]
res = max(l1)  # 得出列表里面最大的数字
res1 = min(l1)  # 得出列表里面最小的数字
3.reduce
传多个值，返回一个值
需要在模块下面才可以执行
from functools import reduce

l1 = [11, 22, 33, 44, 55, 66, 77, 88]
res = reduce(lambda a, b: a * b, l1)  # 两个相乘，需要从l1列表里面取值
print(res)
4.zip() 
将2个列表一一对应以元组的形象展现
代码展示：
l1 = [11, 22, 33, 44, 55]
l2 = ['jason', 'kevin', 'oscar', 'jerry', 'tony']
res = zip(l1, l2)
print(list(res))  # [(11, 'jason'), (22, 'kevin'), (33, 'oscar'), (44, 'jerry'), (55, 'tony')]
print(dict(res))  # 可以将zip转的值转成以字典的形式，键值对
5.filter  快速取出比我们想要值大的数字
l1 = [11, 22, 33, 44, 55, 66, 77, 88]
res = filter(lambda x: x > 40, l1)
print(list(res))
6.sorten
修改列表为升序，跟列表内置函数sort一致
l1 = [21, 12, 53, 64, 76, 32, 11, 22]
res = sorted(l1)
print(res)

常见的内置函数

1.abs() 绝对值
2.all() 所有数据值对应的布尔值为Ture结果才为Ture
3.any() 所有数据值对应的布尔值有一个为Ture就为Ture
4.bin() 二进制 oct() 八进制 hex() 十六进制  int()
5.bytes() 转换成bytes类型
6.callable()  判断名字是否可以加括号
7.chr() ord() 基于ASCII编码表做转换
8.dir() 返回括号内对象能够调用的名字
9.divmod()  元组，第一个数据为整除数，第二个是余数
10.enumerate() 枚举
11.eval() exec() 能够识别字符串中的python并执行
12.hash()  哈希加密
13.id() 查看内存地址 input()输入 isinstance()判断类型
14.map() 映射 max()最大 min()最小
15.open() 打开文件
16.pow() 幂次方
17.range() 相当于工厂把括号里面的数字拿出来
18.round() 五舍六入
19.sum() 求和
20.zip() 拉链

10.可迭代对象

1.可迭代对象
	内置有__iter__方法的都称为可迭代对象
2.非可迭代对象：
	int、float、bool、函数对象
可迭代对象：
	str、list、dict、tuple、set、文件对象

迭代器对象

1.由可迭代对象调用内置方法__iter__方法产生
2.迭代器对象的作用是提供一种不依赖索引取值的方式，有了迭代器我们的字典才可以被索引
注意：迭代器对象是由可迭代对象调用__iter__方法产生，迭代器对象调用__iter__不会有任何变化

for循环的本质

for 变量名 in 可迭代对象
"""首先将可迭代对象调用__iter__方法转为迭代器对象，然后调用__next__取值"""

原文地址：http://www.cnblogs.com/zhanghong1229/p/16797000.html