python小白-day3 函数

一、Python函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

• 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

• 面向对象：对函数进行分类和封装，让开发“更快更好更强...”

注：函数式编程最重要的是增强代码的重用性和可读性

二、定义一个函数

1、你可以定义一个由自己想要功能的函数，以下是简单的规则：

• ①、函数代码块以def关键词开头，后接函数标识符名称和圆括号()。

  ②、任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。

  ③、函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。

  ④、函数内容以冒号起始，并且缩进。

  ⑤、Return[expression]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

2、语法

1 2 3 4

def functionname( parameters ):     "函数_文档字符串"     function_suite     return [expression]

默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。

3、实例

1 2 3 4

def printme():      name = 'hetan'      print (name)      return

三、函数调用

定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。

这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。

如下实例调用了printme()函数：

1 2 3 4 5 6 7

def printme():      name = 'hetan'      print (name)      return printme() f = printme f()

注：函数名也可以赋值，赋值后的变量也可以用词函数

四、函数的参数

以下是调用函数时可使用的正式参数类型：

• ①、必备参数

• ②、命名参数

• ③、缺省参数

• ④、不定长参数

1、必备参数

必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

1 2 3 4 5

def printme(name):      name = name      print (name)      return printme( 'hetan' )

调用printme()函数，你必须传入一个参数，不然会出现语法错误：

1 2 3 4

def printme(name):      print (name)      return printme()

2、命名参数

命名参数和函数调用关系紧密，调用方用参数的命名确定传入的参数值。你可以跳过不传的参数或者乱序传参，因为Python解释器能够用参数名匹配参数值。用命名参数调用printme()函数：

1 2 3 4

def printme(name,age):      print (name,age)      return printme(age = 25 ,name = 'hetan' )

3、缺省参数

调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

1 2 3 4 5

def printme(name,age = 25 ):      print (name,age)      return printme(age = 35 ,name = 'hetan' ) printme(name = 'hetan' )

4、不定长参数

①、序列

1 2 3

def show( * args):      print (args) show( 11 , 12 , 13 )

②、字典

1 2 3

def show1( * * kwargs):      print (kwargs) show1(n1 = 12 ,n2 = 13 )

③、序列和字典

1 2 3 4

def show2( * args, * * kwargs):      print (args, type (args))      print (kwargs, type (kwargs)) show2( 11 , 22 , 33 ,n3 = 12 ,n4 = 15 )

五、内置函数

1、abs()绝对值函数

1 2	print ( abs ( - 1 )) print ( abs ( 1 ))

2、all()集合中的元素都为真的时候为真,特别的，若为空串返回为True。

1 2 3 4 5 6

li = [ 'name' , 'age' ] li1 = [] li2 = [ 'name' ,[]] print ( all (li)) print ( all (li1)) print ( all (li2))

3、any()集合中的元素有一个为真的时候为真，特别的，若为空串返回为False。

1 2 3 4 5 6

li = [ 'name' , 'age' ] li1 = [] li2 = [ 'name' ,[]] print ( any (li)) print ( any (li1)) print ( any (li2))

4、chr()返回整数对应的ASCII字符

     ord()返回字符对应的ASC码数字编号

1 2	print ( chr ( 65 )) print ( ord ( 'A' ))

5、bin(x)将整数x转换为二进制字符串

1	print ( bin ( 10 ))

6、bool(x)返回x的布尔值

1 2	print ( bool ( 0 )) print ( bool ( 1 ))

7、dir()不带参数时，返回当前范围内的变量、方法和定义的类型列表，带参数时，返回参数的属性、方法列表。

1 2	print ( dir ()) print ( dir ( list ))

8、divmod()分别取商和余数

1	print ( divmod ( 10 , 3 ))

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

1 2 3

name = [ 'hetan' , 'liuyao' , 'wudonghang' ] for i,j in enumerate (name, 1 ):      print (i,j)

10、eval()将字符串str当成有效的表达式来求值并返回计算结果。

1 2 3

name =  '[[1,2], [3,4], [5,6], [7,8], [9,0]]' a = eval (name) print (a)

11、filter(function, iterable)函数可以对序列做过滤处理，就是说可以使用一个自定的函数过滤一个序列，把序列的每一项传到自定义的过滤函数里处理，并返回结果做过滤。最终一次性返回过滤后的结果。参数function：返回值为True或False的函数，可以为None，参数iterable：序列或可迭代对象。

1 2 3 4 5 6

def guolvhanshu(num):      if num> 5 and num< 10 :          return num seq = ( 12 , 50 , 8 , 17 , 65 , 14 , 9 , 6 , 14 , 5 ) result = filter (guolvhanshu,seq) print ( list (result))

12、hex(x)将整数x转换为16进制字符串。

1	print ( hex ( 20 ))

13、id()返回对象的内存地址

1	print ( id ( 'hetan' ))

14、len()返回对象的长度

1 2	seq = ( 12 , 50 , 8 , 17 , 65 , 14 , 9 , 6 , 14 , 5 ) print ( len (seq))

15、map(function, iterable)遍历每个元素，执行function操作

1 2 3 4 5 6

def guolvhanshu(num):      num = num + 100      return num seq = ( 12 , 50 , 8 , 17 , 65 , 14 , 9 , 6 , 14 , 5 ) result = map (guolvhanshu,seq) print ( list (result))

16、oct()八进制转换

1	print ( oct ( 87 ))

17、range()产生一个序列，默认从0开始

1	print ( list ( range ( 10 )))

18、reversed()反转

1 2 3 4

li = list ( range ( 10 )) li1 = reversed (li) print (li) print ( list (li1))

19、round()四舍五入

1 2	print ( round ( 4.6 )) print ( round ( 4.5 ))

20、sorted()队集合排序

1 2	seq = ( 12 , 50 , 8 , 17 , 65 , 14 , 9 , 6 , 14 , 5 ) print ( sorted (seq))

21、sum()对集合求和

1 2	seq = ( 12 , 50 , 8 , 17 , 65 , 14 , 9 , 6 , 14 , 5 ) print ( sum (seq))

22、type()返回该object的类型

1 2	seq = ( 12 , 50 , 8 , 17 , 65 , 14 , 9 , 6 , 14 , 5 ) print ( type (seq))

23、vars()返回对象的变量，若无参数与dict()方法类似。

1 2	print ( vars ()) print ( vars ( list ))

运行结果太多，就不展示了

24、zip()zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表。具体意思不好用文字来表述，直接看示例：

示例1：

1 2 3 4 5

x = [ 1 , 2 , 3 ] y = [ 4 , 5 , 6 ] z = [ 7 , 8 , 9 ] xyz = zip (x, y, z) print (x,y,z)

示例2：

1 2 3 4

x = [ 1 , 2 , 3 ] y = [ 4 , 5 , 6 , 7 ] xy = zip (x, y) print ( list (xy))

示例3：

1 2 3 4 5 6

x = [ 1 , 2 , 3 ] y = [ 4 , 5 , 6 ] z = [ 7 , 8 , 9 ] xyz = zip (x, y, z) u = zip ( * xyz) print ( list (u))

一般认为这是一个unzip的过程，它的运行机制是这样的：

在运行zip(*xyz)之前，xyz的值是：[(1, 4, 7), (2, 5, 8), (3, 6, 9)]

那么，zip(*xyz) 等价于 zip((1, 4, 7), (2, 5, 8), (3, 6, 9))

所以，运行结果是：[(1, 2, 3), (4, 5, 6), (7, 8, 9)]

注：在函数调用中使用*list/tuple的方式表示将list/tuple分开，作为位置参数传递给对应函数（前提是对应函数支持不定个数的位置参数）

示例4：

1 2 3

x = [ 1 , 2 , 3 ] r = zip ( * [x] * 3 ) print ( list (r))

示例5：

它的运行机制是这样的：

[x]生成一个列表的列表，它只有一个元素x

[x] * 3生成一个列表的列表，它有3个元素，[x, x, x]

zip(* [x] * 3)的意思就明确了，zip(x, x, x)

六、open函数

你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的辅助方法才可以调用它进行读写。

①、打开文件

语法：文件句柄 = open('文件路径','模式')

读写模式的类型有：

rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)
w     以写方式打开，
a     以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+     以读写模式打开
w+     以读写模式打开 (参见 w )
a+     以读写模式打开 (参见 a )
rb     以二进制读模式打开
wb     以二进制写模式打开 (参见 w )
ab     以二进制追加模式打开 (参见 a )
rb+    以二进制读写模式打开 (参见 r+ )
wb+    以二进制读写模式打开 (参见 w+ )
ab+    以二进制读写模式打开 (参见 a+ )

注：1、使用'W'，文件若存在，首先要清空，然后（重新）创建

     2、使用'a'模式 ，把所有要写入文件的数据都追加到文件的末尾，即使你使用了seek（）指向文件的其他地方，如果文件不存在，将自动被创建。

②、文件操作

1、close()关闭文件

2、fileno()文件描述符

3、flush()刷新文件内部缓冲区

4、isatty()判断文件是否是同意tty设备

5、next()获取下一行数据，不存在，则报错。

6、read()读取指定字符数据

1 2 3 4

f = open ( 'test.log' , 'r' ,encoding = 'utf-8' ) ret = f.read( 3 ) f.close() print (ret)

7、readinto()读取到缓冲区，不要用，3.x将被遗弃

8、readline()仅读取一行数据

1 2 3 4

f = open ( 'test.log' , 'r' ,encoding = 'utf-8' ) ret = f.readline() f.close() print (ret)

9、readlines()读取所有数据，并根据换行保存至列表

1 2 3 4

f = open ( 'test.log' , 'r' ,encoding = 'utf-8' ) ret = f.readlines() f.close() print (ret)

10、seek()指定文件中指针位置，按字节移动

1 2 3 4 5

f = open ( 'test.log' , 'r' ,encoding = 'utf-8' ) f.seek( 5 ) ret = f.readlines() f.close() print (ret)

11、tell()获取当前指针位置，按字节显示

1 2 3 4 5 6 7

f = open ( 'test.log' , 'r' ,encoding = 'utf-8' ) f.seek( 5 ) print (f.tell()) ret = f.readlines() print (f.tell()) f.close() print (ret)

12、truncate()截断数据，仅保留指定之前的数据。

1 2 3 4 5 6 7

f = open ( 'test.log' , 'r+' ,encoding = 'utf-8' ) print (f.readlines()) f.seek( 0 ) f.truncate( 5 ) ret = f.readline() f.close() print (ret)

13、write()写操作

1 2 3 4 5 6

f = open ( 'test.log' , 'r+' ,encoding = 'utf-8' ) print (f.readlines()) f.write( 'asdasfasf' ) f.seek( 0 ) print (f.readlines()) f.close()

14、writelines()将一个字符串列表写入文件，3.x将弃用。

15、xreadlines()可用于逐行读取文件，非全部，3.x将弃用。

3、管理上下文

为了避免打开文件后忘记关闭，可以通过管理上下文，即：

1 2	with open ( 'test.log' , 'r' ,encoding = 'utf-8' ) as f:      print (f.readlines())

如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。

1 2	with open ( 'test.log1' ) as f1, open ( 'test.log2' ) as f2:      pass

七、lambda表达式

学习条件运算时，对于简单的 if else 语句，可以使用三元运算来表示，即：

1 2 3 4 5 6 7

if 1 = = 1 :      name = 'hetan' else :      name = 'liuyao' print (name) name = 'hetan' if 1 = = 1 else 'liuyao' print (name)

对于简单的函数，也存在一种简便的表示方式，即：lambda表达式

1 2 3 4 5

def func(arg):      return arg + 1 print (func( 123 )) func1 = lambda arg:arg + 1 print (func1( 123 ))

来自为知笔记(Wiz)

转载于:https://www.cnblogs.com/hetan/p/5138350.html