python中函数也是数据_python中的函数

1.函数的参数

a.位置参数：def test(x,y,z),则调用时应该一一对应test(1,2,3)

b.关键字参数：def test(x,y,z)则调用应该test(x=2,z=3,y=7)

c.混合使用：则位置参数必须在关键字参数的左边，要不然解析器无法解析呀test(1,2,z=3).test(1,y=2,3)报错

d.默认参数：def test(x,y=None),则y是默认参数

e.参数组：非固定参数。**字典，*元祖

*args   接收参数返回的是一个元祖

**kwargs  接收参数返回的是一个字典

def test(x,*args):print(x)print(args) #会把收到的参数当成一个元祖test(1,2,3,4) #

test(1,[1,2,3,4],*[1,2,3,4],{'name':'age'}) #第一个[1,2,3,4]当作成一个元素，第二个[1,2,3,4]会使用for in遍历

def test(x,*args,**kwargs):print(x)print(type(args)) print(args)print(type(kwargs)) #print(kwargs)

test(1,2,3,4,z=4,y=6) #

test(1,2,3,**{"s":1,"r":2})

2.全局变量与局部变量

a.全局变量：定义在文件的头上

b.局部变量：在函数内部定义的，如果想在局部作用域里想要修改全局变量，则在使用前应该适应global 全局变量

name = "aaa"

defchange_name():

name= "xxx"

print("change_name:",name)

change_name()#change_name: xxx

print("name:",name) #name: aaa

defchange_name():globalname

name= "xxx"

print("change_name:",name)

change_name()#change_name: xxx

print("name:",name) #name: xxx

c.函数即变量

deffoo():print("from foo")

bar()#foo() #NameError: name 'bar' is not defined

defbar():print("from bar")

foo()#OK

在内存中，文件从头至尾加载，那么foo就相当于一个变量，函数体把其看成是字符串，然后存放在内存中，当一个foo()执行时，bar根本还没有加载在内存中。

而在下面的foo()执行的时候，内存中已经加载了bar

1.name = "liu"

2.defliu():

4.1name= "chen"

4.2print(name)

4.3defchen():

4.4.1name= "xxx"

4.4.2print(name)

4.4.3defyan():

4.4.5.1name= "yan"

4.4.5.2print(name)

4.4.4print(name)

4.4.5yan()

4.4chen()

4.5print(name)3.print(name)

4.liu()5.print(name)

3.重要的函数

a.匿名函数(lambda)

func_name = lambda x，y，z :  (x+1,y+1,z+1) (返回多个值时，应该自动加上元组，def定义的函数的返回值是自动添加元组的(元祖当作一个数返回，函数又不能返回多个值的))表示形参，x+1表示返回值，调用func_name(传入参数)，不适用于复杂逻辑

defa(x):return x+1

print(a) #

print(a(2))

a= lambda x:x+1

print(a) # at 0x7f448ff81c80>

print(a(2))

v= lambda x,y,z:x+y+zprint(v(1,2,3))

v= lambda x,y,z:(x+1,y+1,z+1) #需要自己添加元组print(v(1,2,3))defxx():return 1,2 #函数会自动以元组返回

print(xx())

b.map函数

map函数，map(func,iterable)表示传入一个处理函数和一个可迭代的对象，对可迭代对象进行遍历处理 如：res = map(lambda x:x+1,[1,2,3])(结果与原来的个数和位置一样)

返回值时一个可迭代对象。

m = map(lambda x:x**2,[1,2,3,4])print(m) #

print(list(m)) #[1, 4, 9, 16]

c.filter函数

filter函数，filter(func,iterable)表示传入一个返回值为boolean函数和一个可迭代对象，对可迭代对象进行遍历处理，filter(lambda s:s.startswith('sb'),mov)(遍历序列中每一个元素，判断每个元素得到boolean为True则留下，返回也是一个迭代器对象)

返回值：可迭代的对象

l = ["xx_sb","xxx","ddd_sb"]

f= filter(lambda x:x.endswith('sb'),l)print(f) #

print(list(f)) #['xx_sb', 'ddd_sb']

d.reduce函数(需要导入)

reduce函数，reduce(function,iterable,initializer)表示对可迭代对象进行迭代处理，例如相加，相乘等reduce(lambda x,y:x+y,[1,2,3],1)(处理一个序列，然后把序列进行合并操作)

返回值：为一个具体的结果

from functools importreduce

r= reduce(lambda x,y:x+y,[1,2,3,4],0)print(r) #10

r = reduce(lambda x,y:x*y,[1,2,3,4],1)print(r) #24

e.zip函数

zip(iterable,...]):参数iterable为可迭代对象，并且可以有多个参数.

返回：一个以元组为元素的列表.,其中第 i 个元组包含每个参数序列的第 i 个元素。返回的列表长度被截断为最短的参数序列的长度。只有一个序列参数时，它返回一个1元组的列表。没有参数时，它返回一个空的列表。

a=[1,2,3,4,5]

b=(1,2,3,4,5)

d="zhang"zz=zip(a,b,d)print(zz) #

print(list(zz)) #[(1, 1, 'z'), (2, 2, 'h'), (3, 3, 'a'), (4, 4, 'n'), (5, 5, 'g')]

a=[1,2,3]

b=[1,2,3,4]

c=[1,2,3,4,5]

zz=zip(a,b,c)print(list(zz)) #[(1, 1, 1), (2, 2, 2), (3, 3, 3)]

f.sorted函数(与sort函数)

a.基本形式

sorted(iterable[, cmp[, key[, reverse]]]) #返回一个有序的副本

iterable.sort(cmp[, key[, reverse]])　　　　 #原址排序，当让可以使用[:]分片复制一份排序，达到与 sorted一样的效果

参数解析：

(1)iterable指定要排序的list或iterable；

(2)cmp为函数，指定排序时进行比较的函数,也就是用来排序的函数，可以指定一个函数或者lambda函数，如： students为类对象的list，这个成员有三个域，用sorted进行比较时可以自己定cmp函数，例如这里要通过比较第三个数据成员来排序，代码可以这样写：

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

sorted(students, key=lambda student : student[2])#输出：[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

(3):key为函数，指定取待排序元素的哪一项进行排序，函数用上面的例子来说明，代码如下

sorted(students, key=lambda student : student[2])

4.内置函数

a.数学运算类

abs(x)

求绝对值1、参数可以是整型，也可以是复数2、若参数是复数，则返回复数的模

complex([real[, imag]])

创建一个复数

divmod(a, b)

分别取商和余数注意：整型、浮点型都可以

float([x])

将一个字符串或数转换为浮点数。如果无参数将返回0.0

int([x[, base]])

将一个字符转换为int类型，base表示进制

long([x[, base]])

将一个字符转换为long类型

pow(x, y[, z])

返回x的y次幂

range([start], stop[, step])

产生一个序列，默认从0开始

round(x[, n])

四舍五入

sum(iterable[, start])

对集合求和

oct(x)

将一个数字转化为8进制

hex(x)

将整数x转换为16进制字符串

chr(i)

返回整数i对应的ASCII字符

bin(x)

将整数x转换为二进制字符串

bool([x])

将x转换为Boolean类型

b.集合类操作

basestring()

str和unicode的超类不能直接调用，可以用作isinstance判断

format(value [, format_spec])

格式化输出字符串格式化的参数顺序从0开始，如“I am {0},I like {1}”

unichr(i)

返回给定int类型的unicode

enumerate(sequence [, start = 0])

返回一个可枚举的对象,该对象的next()方法将返回一个tuple

iter(o[, sentinel])

生成一个对象的迭代器，第二个参数表示分隔符

max(iterable[, args...][key])

返回集合中的最大值

min(iterable[, args...][key])

返回集合中的最小值

dict([arg])

创建数据字典

list([iterable])

将一个集合类转换为另外一个集合类

set()

set对象实例化

frozenset([iterable])

产生一个不可变的set

str([object])

转换为string类型

sorted(iterable[, cmp[, key[, reverse]]])

队集合排序

tuple([iterable])

生成一个tuple类型

xrange([start], stop[, step])

xrange()函数与range()类似，但xrnage()并不创建列表，而是返回一个xrange对象，它的行为与列表相似，但是只在需要时才计算列表值，当列表很大时，这个特性能为我们节省内存

c.逻辑判断

all(iterable)

1、集合中的元素都为真的时候为真2、特别的，若为空串返回为True

any(iterable)

1、集合中的元素有一个为真的时候为真2、特别的，若为空串返回为False

cmp(x, y)

如果x < y ,返回负数；x == y, 返回0；x > y,返回正数

e.反射

待补充

5.文件处理(内置函数的IO操作)

file(filename [, mode [, bufsize]])

file类型的构造函数，作用为打开一个文件，如果文件不存在且mode为写或追加时，文件将被创建。添加‘b’到mode参数中，将对文件以二进制形式操作。添加‘+’到mode参数中，将允许对文件同时进行读写操作1、参数filename：文件名称。2、参数mode：'r'(读)、'w'(写)、'a'(追加)。3、参数bufsize：如果为0表示不进行缓冲，如果为1表示进行行缓冲，如果是一个大于1的数表示缓冲区的大小 。

input([prompt])

获取用户输入推荐使用raw_input，因为该函数将不会捕获用户的错误输入

open(name[, mode[, buffering]])

打开文件与file有什么不同？推荐使用open

print

打印函数  print("xxx",end="\n")end默认是换行符

raw_input([prompt])

设置输入，输入都是作为字符串处理

a.文件处理流程

1)打开文件，得到文件句柄并赋值给一个变量

open("a.txt",encoding="UTF-8")(默认是读模式)

encoding默认是使用操作系统指定的编码。也就是以操作系统指定的编码去解析该文件。

模式：

r：只读

w:覆盖重写

a:追加

+:表示可以同时读写某个文件

b:表示以字节的方式操作  (注意：在b的模式下不能指定字符编码的。)

2)通过对句柄进行操作

read()

readline()

readlines() 读取文件，返回以每一行为元素的列表

write()

writelines()

writeable()是否可读

f.encoding ：显示文件的编码

3)关闭文件

with open("xxx","r","encoding="utf-8"") as f:

使用关键字with就不要我们关闭文件。

6.字符编码问题

-为了处理英文字符，产生了ASCII码

-为了处理中文字符，产生了GB2312

-为了处理各国字符，产生了Unicode

-为了提高Unicode存储和传输性能，产生了UTF-8，它是Unicode的一种实现形式。

python2.x

1.python2中默认的字符编码时ASCII吗，也就是说python2在处理数据时，只要数据没有指定它的编码类型，python默认将其当作ASCII吗来进行处理。这个问题最直接的表现形式在当我们编写的python文件中包含中文字符时，在运行时会提示出错。

解决方案：在文件头部加入一行编码声明  # -*- coding: utf-8 -*-

2.python2中字符串有str和unicode两种类型

这里我们注意到一个字节串”的名称，字节串是指该字符串在python中的标准形式，也就是说无论一个字符串是什么样的编码，在python中都会有一串字节串来进行表示。字节串是没有编码的，对应的最终交给计算机处理的数据形式。

在pyton2中可以直接查看到unicode的字符串。在上图中，输入unicode_name的返回值，是一个unicode字节串，我们能够直接看到这个字节串。而在python3中，我们将不能看到unicode字节串，它会被显示成中文，因为python3默认使用Unicode编码，unicode字节串将被直接处理为中文显示。

总结：

1.Python2中默认的字符编码是ASCII码。

2.Python2中字符串有str和unicode两种类型。str有各种编码的区别，unicode是没有编码的标准形式。

3.Python2中可以直接查看到unicode的字节串。

decode()与encode()方法(在python3中没有此方法了，这两种方法就可用户bytes与str之间的转，当然也可以使用bytes与str方法转换)

decode()方法将其他编码字符转化为unicode编码字符    与字符串前加u的方法实现的效果相同。

encode()方法将unicode编码字符转化为其他编码字符

linux系统，一般默认是UTF-8编码。大多数windows的系统编码是gb2312.

总结：

1.Python2的对于字符编码的转换要以unicode作为“中间人”进行转化。

2.知道自己系统的字符编码(Linux默认utf-8，Windows默认GB2312)，对症下药。

bytes与str之间的异同

python3中最重要的特性之一时对字符串和二进制数据流做了明确的区分。(python2中bytes=str)文本总是Unicode，由str类型表示，二进制数据由bytes类型表示。python3中不会以任何隐式的方式混用str和bytes，你不能拼接字符串和字符流，也无法在字节流里搜索字符串(反之亦然)，也不能将字符串传入参数为字节流的函数(反之亦然)

bytes是一种比特流，他的存在形式时01001010的这种，我们无论是在写代码，还是阅读文章的过程中，肯定不会有人直接阅读这种比特流的，他必须有一个编码方式，使得它变成有意义的比特流，而不是一堆晦涩难懂的01组合。因为编码方式的不同，对这个比特流的解读也会不同。

7.迭代器与生成器

a.迭代器

1).迭代协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个Stopiteration异常，以终止迭代(只能往后走不能往前退)

2).可迭代对象：实现了迭代器的对象，(如何实现：对象内部定义一个__iter__()方法)

3).协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具(如for循环，sum,min,max函数等)使用迭代器协议访问对象

for循环的本质：循环所有对象，全都是使用迭代器协议

为什么需要for循环呢？　　例如集合，它根本就没有索引下标，要想访问集合对象，那就只能把它转换成可迭代对象，和java中的Iterator。

而且生成可迭代对象，每次需要一个数据才加载到到内存中，每次使用完后，它又会变成垃圾，而被垃圾回收期回收，这样的效率是非常高的。

b.生成器

列表解析

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

缺点：如果数量太大，会消耗很大的内存。

生成器表达式

针对列表解析的问题，解决办法：使用生成器表达式，类似于给你一只老母鸡，可以一直下

egg_list = ('鸡蛋%s' %i for i in range(10))#生成器表达式

此时egg_list是一个可迭代对象，就可以使用for循环啦

生成器函数

deftest():

a= 4

yield 1

yield a+1b= a+3

yieldbyield b+3

a = test()其实a返回的是一个迭代器对象，则就可以使用for循环遍历，也可以调用a.next()方法访问

生成器的好处：

比起你先构造一个list列表return返回，使用yeid的生成器函数，可以节约更多的内存，需要的时候就给你生产一个。如想要生产10个包子，你要生成10个包子放在一个列表里，但是使用yeid生成一个可迭代对象，这样就可使用next()(python2.0里，python3.0使用的是__next__())方法吃一个就生成一个