Python学习day3

一、集合

集合是一个无序的,不重复的数据组合,它的主要作用如下:

  • 去重,把一个列表变成集合,就自动去重了
  • 关系测试,测试两组数据之前的交集、差集、并集等关系
  • 无序的排列

1.1列表转为集合

使用set对列表转换为集合

  1. list = [1,2,3,4,5,6,6,6,6]
  2. list =set(list)
  3. print(list,type(list))
  4. {1, 2, 3, 4, 5, 6}<class 'set'>

1.2交集

1.2.1使用intersection求两个集合的交集

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe2 = {23, 4, 31, 5, 22, 1}
  3. print(jihe1.intersection(jihe2))
  4. {1, 4, 5}

1.2.2使用运算符&求交集

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe2 = {23, 4, 31, 5, 22, 1}
  3. print(jihe1&jihe2)
  4. {1, 4, 5}

1.2.3使用isdisjoint判断是否有交集,有交集为False

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe2 = {23, 4, 31, 5, 22, 1}
  3. jihe3 = {7,8,9}
  4. print(jihe1.isdisjoint(jihe2))
  5. print(jihe1.isdisjoint(jihe3))
  6. False
  7. True

1.3并集

1.3.1使用union求两个集合的并集

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe2 = {23, 4, 31, 5, 22, 1}
  3. print(jihe1.union(jihe2))
  4. {1, 2, 3, 4, 5, 6, 22, 23, 31}

1.3.2使用运算符|求并集

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe2 = {23, 4, 31, 5, 22, 1}
  3. print(jihe1|jihe2)
  4. {1, 2, 3, 4, 5, 6, 22, 23, 31}

1.4差集

1.4.1使用difference求集合1集合2中没有的差集

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe2 = {23, 4, 31, 5, 22, 1}
  3. print(jihe1.difference(jihe2))
  4. { 2, 3, 6}

1.4.2使用运算符-求差集

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe2 = {23, 4, 31, 5, 22, 1}
  3. print(jihe-jihe2)
  4. { 2, 3, 6}

1.5子集

1.5.1使用issubset判断是否为子集

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe2 = {23, 4, 31, 5, 22, 1}
  3. jihe3 = {1, 2, 3, 6}
  4. print(jihe2.issubset(jihe1))
  5. print(jihe3.issubset(jihe1))
  6. False
  7. True

1.6父集

1.6.1使用issuperset判断是否为父集

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe2 = {23, 4, 31, 5, 22, 1}
  3. jihe3 = {1, 2, 3, 6}
  4. print(jihe1.issuperset(jihe2))
  5. print(jihe1.issuperset(jihe3))
  6. False
  7. True

1.7对称差集

1.7.1使用symmetric_difference求对称差集(两个集合的并集减去子集剩下的部分)

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe2 = {23, 4, 31, 5, 22, 1}
  3. print(jihe1.symmetric_difference(jihe2))
  4. {2, 3, 22, 23, 6, 31}

1.7.2使用运算符^求差集

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe2 = {23, 4, 31, 5, 22, 1}
  3. print(jihe1^jihe2)
  4. {2, 3, 22, 23, 6, 31}

1.8在集合中添加元素

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe1.add(7)
  3. print(jihe1)
  4. {1, 2, 3, 4, 5, 6, 7}

1.9在集合中添加多个元素

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe1.update([2,222])
  3. print(jihe1)
  4. {1, 2, 3, 4, 5, 6, 222}

1.10在集合删除一个元素

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe1.remove(2)
  3. print(jihe1)
  4. {1, 3, 4, 5, 6}

1.11判断元素是否为集合的成员

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. print(1 in jihe1,"-------",8 in jihe1)
  3. True ------- False
  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. print(1 not in jihe1,"-------",8 not in jihe1)
  3. False ------- True

1.12删除一个任意的元素

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. print(jihe1)
  3. {2, 3, 4, 5, 6}

1.13删除一个指定的元素,如果该元素不存在会报错

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe1.remove(3)
  3. print(jihe1)
  4. {1, 2, 4, 5, 6}

1.14删除一个指定的元素,如果该元素不存在不报错

  1. jihe1 = {1, 2, 3, 4, 5, 6}
  2. jihe1.discard(7)
  3. jihe1.discard(2)
  4. print(jihe1)
  5. {1, 3, 4, 5, 6}

二、文件操作

  • 打开文件,得到文件句柄并赋值给一个变量
  • 通过句柄对文件进行操作
  • 关闭文件

2.1打开文件读取内容

  1. print(open("sounds","r",encoding="utf-8").read())
  2. Somehow, it seems the love I knew was always the most destructive kind
  3. Yesterday when I was young
  4. The taste of life was sweet
  5. As rain upon my tongue
  6. I teased at life as if it were a foolish game

2.2文件内存对象

正常对于一个文件打开,在进行操作,是需要加载到内容中,并在内存对象里赋值一个变量,后续再找到这个变量,来操作文件,这个文件对象就是文件句柄,一般情况通常都是用f来指定

  1. f = (open("sounds","r",encoding="utf-8"))
  2. print(f.read())
  3. Somehow, it seems the love I knew was always the most destructive kind
  4. Yesterday when I was young
  5. The taste of life was sweet
  6. As rain upon my tongue
  7. I teased at life as if it were a foolish game

2.3在文件里写入内容,

使用下面的方式会对源文件覆盖,w会写入覆盖,而且是不可读的,具体后面有讲解

  1. f = (open("sounds","w",encoding="utf-8"))
  2. f.write("chuck is most handsome\n") #\n为回车换行符
  3. f.write("楼上说的对")
  4. f.close()

2.4在文件中追加

  1. f = (open("sounds","a",encoding="utf-8"))
  2. f.write("chuck is most handsome\n") #\n为回车换行符
  3. f.write("楼上说的对")
  4. f.close()
  5. ##文件内容如下,可以看到追加了两行
  6. Somehow, it seems the love I knew was always the most destructive kind
  7. Yesterday when I was young
  8. The taste of life was sweet
  9. As rain upon my tongue
  10. I teased at life as if it were a foolish game
  11. chuck is most handsome
  12. 楼上说的对

2.5使用readline只打印前五行内容

使用readline按行读取文件内容,使用for循环读出文件的前五行

  1. f = (open("sounds","r",encoding="utf-8"))
  2. for line in range(5):
  3. print(f.readline().strip())
  4. f.close()
  5. Somehow, it seems the love I knew was always the most destructive kind
  6. Yesterday when I was young
  7. The taste of life was sweet
  8. As rain upon my tongue
  9. I teased at life as if it were a foolish game

2.5使用readlines不输出将第五行变为其他输出

readlines的输出其实是将每一行当做一个元素转换成一个列表,使用for循环将其输出其实就是在循环列表内容

  1. f = (open("sounds","r",encoding="utf-8"))
  2. count = 1
  3. for line in f.readlines():
  4. if count == 5:
  5. print("看到没,这是第%s行" % count)
  6. print(line.strip())
  7. count += 1
  8. Somehow, it seems the love I knew was always the most destructive kind
  9. Yesterday when I was young
  10. The taste of life was sweet
  11. As rain upon my tongue
  12. 看到没,这是第5
  13. I teased at life as if it were a foolish game

2.6直接循环f,逐行加载到内存中,读一行删掉一行

使用readlines的方法是逐行读取内容完一次性加载到内存中,如果文件过大,就会影响内存的使用率,加大了内存的使用空间,从磁盘读取到内存会浪费很多时间,readlines只适合读小文件,所以这时要引入其他方法来读取大文件,使用循环f方法,逐行加载到内存中,读一行删掉一行,使用此方法后内容不再是一个列表,是一个迭代器似的内容,建议以后使用此方法循环读取文件内容

  1. f = (open("sounds","r",encoding="utf-8"))
  2. count = 1
  3. for line in f:
  4. if count == 5:
  5. print("看到没,这是第%s行" % count)
  6. print(line.strip())
  7. count += 1
  8. f.close()
  9. Somehow, it seems the love I knew was always the most destructive kind
  10. Yesterday when I was young
  11. The taste of life was sweet
  12. As rain upon my tongue
  13. 看到没,这是第5
  14. I teased at life as if it were a foolish game

2.7移动读取写入文件的光标

  • 文件初始位置光标为0
  1. f = (open("sounds","r",encoding="utf-8"))
  2. print(f.tell())
  3. 0
  • 读入一行后输出
  1. f = (open("sounds","r",encoding="utf-8"))
  2. f.readline()
  3. print(f.tell())
  4. 72
  • 使用read读取指定的字符数
  1. f = (open("sounds","r",encoding="utf-8"))
  2. f.readline()
  3. print(f.read(20))
  4. print(f.tell())
  5. Yesterday when I was
  6. 92
  • 使用seek回到默认位置,seek和tell往往搭配起来使用
  1. f = (open("sounds","r",encoding="utf-8"))
  2. f.readline()
  3. print(f.read(20))
  4. f.seek(0)
  5. print(f.tell())
  6. Yesterday when I was
  7. 0

2.7其他一些操作文件的方法

  • 使用encoding打印文件的编码
  1. f = (open("sounds","r",encoding="utf-8"))
  2. print(f.encoding)
  3. utf-8
  • errors用来做异常处理的
  • fileno返回操作系统的接口的id,无需关注
  • name打印文件名字
  • tty判断是否为一个终端设备
  • seekable判断是否可以移动光标
  • readable判断文件是否可读,防止报错
  • writeable判断文件是否可写,防止报错
  • buffer内存里的一个临时文件
  • flush将内存的内容刷到磁盘中
    有些情况写文件,会首先写到buffer中,然后达到一定大小刷新到磁盘,这是缓冲的一个优势,如果对数据要求实时的一致性,要求对数据很严格,这时使用flush可以实现写每行内容立马刷进磁盘中,还可以使用flush打印进度条
  1. import sys,time
  2. for i in range(30):
  3. sys.stdout.write(">>")
  4. sys.stdout.flush()
  5. time.sleep(0.1)
  • truncate截断文件内的光标,无论是光标在哪,都会从开头计算截断位置
  1. f = (open("sounds","a",encoding="utf-8"))
  2. f.truncate(55)

2.8对文件的权限读写权限介绍

** 打开文件的模式有:**

  • r,只读模式(默认)。
  • w,只写模式。【不可读;不存在则创建;存在则删除内容;】
  • a,追加模式。【可读;不存在则创建;存在则只追加内容;】
    “+” 表示可以同时读写某个文件
  • r+,可读写文件。【可读;可写;可追加】实际是从最后追加内容,比较常用
  • w+,写读,和r+区别是先创建一个新文件后写入,python3.0不能使用seek移动光标后写入,一定都是从最后一行写入,实际上写读模式没什么卵用
  • a+,同a
    “U”表示在读取时,可以将 \r \n \r\n自动转换成 \n (与 r 或 r+ 模式同使用)
  • rU
  • r+U
    “b”表示处理二进制文件(如:FTP发送上传ISO镜像文件,linux可忽略,windows处理二进制文件时需标注,python3.0中socket传输只能使用二进制内容,二进制内容最好都是用二进制方式打开,否则可能会损坏文件)
  • rb
  • wb
  • ab

2.9修改文件里的指定内容

上面说了对文件的写读等操作,如果想要修改文件的指定内容,就需要将文件加载到内存中,在内存里修改,修改后在写回源文件,就不需要创建新文件了,但是文件太大就不合适了,内存会跑满;另一种方式是打开一个文件修改,最后写入到一个新文件里,这种方式可以应对大文件的更改,下面就是用第二种方式实现更改
原文件内容如下:

  1. Somehow, it seems the love I knew was always the most destructive kind
  2. Yesterday when I was young
  3. The taste of life was sweet
  4. As rain upon my tongue
  5. I teased at life as if it were a foolish game
  6. The way the evening breeze

将第5行的tongue改为eyes

  1. f = open("sounds","r",encoding="utf-8")
  2. f2 = open("sounds2","w",encoding="utf-8")
  3. for line in f:
  4. if "tongue" in line:
  5. line = line.replace("tongue","eyes")
  6. f2.write(line)
  7. f.close()
  8. f2.close()

新文件如下

  1. Somehow, it seems the love I knew was always the most destructive kind
  2. Yesterday when I was young
  3. The taste of life was sweet
  4. As rain upon my eyes
  5. I teased at life as if it were a foolish game
  6. The way the evening breeze

2.10学习操作文件的with方法

使用直接使用open打开文件是需要关闭的,最好是手动close,但是程序执行完依旧是会关闭文件,如果不进行手动关闭,打开文件过多的时候,只要程序不退出,打开的文件句柄始终不退出,直到程序结束时才会关闭,造成了内存空间关闭,所以要实时关闭,引入with方法,with支持同时打开多个文件,建议多使用with语法
with语句
为了避免打开文件后忘记关闭,可以通过管理上下文,即:

  1. with open('log','r') as f:
  2. ...

如此方式,当with代码块执行完毕时,内部会自动关闭并释放文件资源。
在Python 2.7 后,with又支持同时对多个文件的上下文进行管理,即:

  1. with open('log1') as obj1, open('log2') as obj2: pass

使用范例:

  1. with open("sounds","r",encoding="utf-8") as f:
  2. for line in f:
  3. print(line.strip())
  4. Somehow, it seems the love I knew was always the most destructive kind
  5. Yesterday when I was young
  6. The taste of life was sweet
  7. As rain upon my tongue
  8. I teased at life as if it were a foolish game
  9. The way the evening breeze

三、再说字符编码

[详细内容请移步这里](
http://www.cnblogs.com/luotianshuai/articles/5735051.html)

四、函数与函数式编程

4.1介绍

在过去的十年间,大家广为熟知的编程方法无非两种:面向对象和面向过程,其实,无论哪种,都是一种编程的规范或者是如何编程的方法论。而如今,一种更为古老的编程方式:函数式编程,以其不保存状态,不修改变量等特性重新进入人们的视野。下面我们就来依次了解这一传统的编程理念,让我们从基本的函数概念开始。

4.2函数定义

初中数学函数定义:一般的,在一个变化过程中,如果有两个变量x和y,并且对于x的每一个确定的值,y都有唯一确定的值与其对应,那么我们就把x称为自变量,把y称为因变量,y是x的函数。自变量x的取值范围叫做这个函数的定义域
编程语言中函数定义:函数是逻辑结构化和过程化的一种编程方法。
python中函数定义方法:

  1. def test(x): #def:定义函数的关键字,test:函数名,():内可定义形参
  2. "The function definitions" #"":文档描述(非必要,但是强烈建议为你的函数添加描述信息)
  3. x+=1 #x+=1:泛指代码块或程序处理逻辑
  4. return x #return:定义返回值
  • 注:函数式编程就是:先定义一个数学函数,然后按照这个数学模型用编程语言去实现它。至于具体如何实现和这么做的好处,后续我会详细介绍。

4.2.1定义一个函数

  1. def func1():
  2. "This is test function"
  3. print("in the func1")
  4. return 0
  5. x=func1()
  6. print(x)
  7. in the func1
  8. 0

4.3何为使用函数:

没有函数的编程只是在写逻辑(功能),想脱离函数,重用你的逻辑,唯一的方法就是拷贝

  • 代码重复利用
  • 易扩展,保持一致性

4.3.1模拟写日志的方式

  1. def log():
  2. "write log"
  3. with open("log.txt","a",encoding="utf-8") as f:
  4. f.write("end action\n")
  5. return 0
  6. def append_log1():
  7. "this is append_log1"
  8. log()
  9. return 0
  10. def append_log2():
  11. "this is append_log2"
  12. log()
  13. return 0
  14. def append_log3():
  15. "this is append_log2"
  16. log()
  17. return 0
  18. append_log1()
  19. append_log2()
  20. append_log3()

查看文件输出结果

  1. end action
  2. end action
  3. end action

4.3.2优化写日志代码,需求为:加上时间

  1. import time
  2. def log():
  3. "write log"
  4. time_format = "%Y-%m-%d %X"
  5. time_now = time.strftime(time_format)
  6. with open("log.txt","a",encoding="utf-8") as f:
  7. f.write("%s-end action\n"%time_now)
  8. return 0
  9. def append_log1():
  10. "this is append_log1"
  11. log()
  12. return 0
  13. def append_log2():
  14. "this is append_log2"
  15. log()
  16. return 0
  17. def append_log3():
  18. "this is append_log2"
  19. log()
  20. return 0
  21. append_log1()
  22. append_log2()
  23. append_log3()

查看文件输出结果

  1. end action
  2. end action
  3. end action
  4. 2016-08-10 21:28:09-end action
  5. 2016-08-10 21:28:09-end action
  6. 2016-08-10 21:28:09-end action

4.4函数和过程

过程定义:过程就是简单特殊没有返回值的函数
这么看来我们在讨论为何使用函数的的时候引入的函数,都没有返回值,没有返回值就是过程,没错,但是在python中有比较神奇的事情

  1. def test01():
  2. msg='hello The little green frog'
  3. print ms #这是一个过程
  4. def test02():
  5. msg='hello WuDaLang'
  6. print msg
  7. return msg #这是一个函数
  8. t1=test01()
  9. t2=test02()
  10. print 'from test01 return is [%s]' %t1
  11. print 'from test02 return is [%s]' %t2

4.5返回值

先使用一个函数来了解return,从下面结果看return后面的将不再执行,可以通过赋值变量接收的return的值

  1. def func2():
  2. "this is function2"
  3. print("in the func2")
  4. return 0
  5. print("this line whill become none")
  6. func2()
  7. in the func2

4.5.1return返回的各种值

  • 返回值数=0:返回None
  • 返回值数=1:返回object
  • 返回值数>1:返回tuple
    分别用3个函数(过程)来证明
  1. def func1():
  2. "this is function1"
  3. print("in func1")
  4. def func2():
  5. "this is function2"
  6. print("in func2")
  7. return 0
  8. def func3():
  9. "this is function3"
  10. print("in func3")
  11. return 1,"hello",["chuck","maliang"],{"name":"chuck"}
  12. result1 = func1()
  13. result2 = func2()
  14. result3 = func3()
  15. print(result1)
  16. print(result2)
  17. print(result3)
  18. in func1
  19. in func2
  20. in func3
  21. None #没有返回值解释器会返回None
  22. 0 #返回object ==》0
  23. (1, 'hello', ['chuck', 'maliang'], {'name': 'chuck'}) #返回一个元组tuple

4.6函数调用

  • 调用方法:
    test()执行,()表示调用函数test,()内可以有参数也可没有
    参数:
  • 形参和实参
    形参:形式参数,不是实际存在,是虚拟变量。在定义函数和函数体的时候使用形参,目的是在函数调用时接收实参(实参个数,类型应与实参一一对应)
    实参:实际参数,调用函数时传给函数的参数,可以是常量,变量,表达式,函数,传给形参
  • 实参和形参的区别
    形参是虚拟的,不占用内存空间,.形参变量只有在被调用时才分配内存单元,实参是一个变量,占用内存空间,数据传送单向,实参传给形参,不能形参传给实参
  • 位置参数和关键字
    标准调用:实参与形参位置一一对应;关键字调用:位置无需固定
  • 默认参数,调用函数的时候,默认参数非必传,如果未传就使用默认的,如果通过位置参数传参,就会使用位置传参。此项应用在安装软件默认路径的场合和连接数据库端口号等时候得到了很好的应用
  • 参数组

4.6.1形参和实参的位置参数调用

  1. def test(x,y): #x和y叫做形参
  2. print(x)
  3. print(y)
  4. test(1,2) #1和2叫做实参
  5. 1
  6. 2

4.6.2关键字参数

  1. def test(x,y):
  2. print(x)
  3. print(y)
  4. test(y=3,x=9) #这种方式就是关键字参数
  5. 9
  6. 3
  • 注:位置参数不能放在关键字参数后边即(x=3,2)

4.6.3默认参数

  1. def test(x,y=2): #y=2就是默认参数
  2. print(x)
  3. print(y)
  4. test(3)
  5. 3
  6. 2

4.6.4参数组的定义,以元组形式输出

  1. def test(*args):
  2. print(args)
  3. test(1,2,3,4,5) #这种传参方式和直接使用列表方式test(*[1,2,3,4,5])传参是一样的,这种传参方式可以结合位置参数的传参,输出结果均为元组
  4. (1, 2, 3, 4, 5)
  1. def test(x,*args):
  2. print(x)
  3. print(args)
  4. test(*[1,2,3,4,5])
  5. 1
  6. (2, 3, 4, 5)
  • 注:此方法只接收位置参数,在形参位置处,参数组只能放到所有类型参数的最后

4.6.5参数组的定义,以字典形式输出

  1. def test(x,**kwargs):
  2. print(x)
  3. print(kwargs)
  4. test("帅气",name="chuck",salary="无穷大")
  5. 帅气
  6. {'name': 'chuck', 'salary': '无穷大'} #使用了位置参数和参数组的组合,使用**kwargs可以是输出结果以字典方式输出,参数组只能放到最后
  • 注:此方法只接收关键字参数,在形参位置处,参数组只能放到所有类型参数的最后

4.6局部变量

4.6.1全局变量和局部变量

  1. def change_name(name):
  2. print("before change",name)
  3. name = "Mario" #这里的name变量就称为局部变量,此函数为name函数的作用域,这里的name变量只在这个函数内生效。
  4. print("after change",name)
  5. name = "Chuck" #函数外定义的变量称为全局变量,在整个文件中都生效,但是函数中对全局变量做了二次更改,那就是局部变量生效
  6. change_name(name)
  7. before change Chuck
  8. after change Mario

4.6.2局部变量改为全部变量

  1. def change_name():
  2. global age #此方法在函数里使用global定义的变量就是全局变量在整个程序都是生效的,此方法那慎用
  3. age = 18
  4. print("inter",age)
  5. change_name()
  6. inter 18

4.6.3一种错误的做法

  1. age = 20
  2. def change_name():
  3. global age #此方法千万不要使用,非常危险。在函数里通过golbal修改全局变量的值(将age从20改为了18),这种情况根本无法使用,无法调试,会导致整个程序乱了。说白了,就是千万不要在函数里修改全局变量
  4. age = 18
  5. print("inter",age)
  6. change_name()
  7. print('extend',age)
  8. inter 18
  9. extend 18

4.6.4列表在函数中修改

从结果可以看出函数内修改列表的元素,会导致列表在全局也修改了,同样字典也是会被修改,和字符串不同,字符串在函数里如果不通过global修改,在函数外是不会被修改的

  1. names = ["chuck","mario","shuaige"]
  2. def change_name():
  3. names[1] = "帅哥"
  4. print("inside",names)
  5. change_name()
  6. print('outside',names)
  7. inside ['chuck', '帅哥', 'shuaige']
  8. outside ['chuck', '帅哥', 'shuaige']

4.7函数递归

  • 在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。
  1. def calc(n):
  2. print(n)
  3. if int(n/2) ==0:
  4. return n
  5. return calc(int(n/2))
  6. calc(10)
  7. 输出:
  8. 10
  9. 5
  10. 2
  11. 1
  • 递归特性:
    1) 必须有一个明确的结束条件
    2)每次进入更深一层递归时,问题规模相比上次递归都应有所减少
    3) 递归效率不高,递归层次过多会导致栈溢出(在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的次数过多,会导致栈溢出)

4.8匿名函数

  • 匿名函数就是不需要显式的指定函数
  1. def calc(n):
  2. return n**n
  3. print(calc(10))
  4. #换成匿名函数
  5. calc = lambda n:n**n
  6. print(calc(10))
  • 你也许会说,用上这个东西没感觉有毛方便呀, 。。。。呵呵,如果是这么用,确实没毛线改进,不过匿名函数主要是和其它函数搭配使用的呢,如下
  1. res = map(lambda x:x**2,[1,5,7,4,8])
  2. for i in res:
  3. print(i)
  4. 1
  5. 25
  6. 49
  7. 16
  8. 64

4.8高阶函数

变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。

  1. def add(x,y,f):
  2. return f(x) + f(y
  3. res = add(3,-6,abs)
  4. print(res)

在上面内容中,abs是一个内置函数,作为参数传给了f,这样add的函数就接受了abs这个函数作为了参数,add这个函数就成为高阶函数

0
未经许可,不得转载,否则将受到作者追究,博主联系方式见首页右上角
  • 转载请注明来源:Python学习day3
  • 本文永久链接地址:http://www.52devops.com/chuck/765.html

该文章由 发布

这货来去如风,什么鬼都没留下!!!
发表我的评论
取消评论
代码 贴图 加粗 链接 删除线 签到