一、函数基础
函数是将一些语句集合在一起的部件，可在程序中多次运行；函数是为了最大程度的代码重用；函数能以多种形式接收传递的参数，并返回不同的值。
1、自定义函数
def语句
| 1 | def 语句将创建一个函数对象并将其赋值给一个变量名。 |
函数变量名
| 1 | def 语句在首行定义函数名，赋值给函数对象，并可在括号中传递参数 |
函数体
| 1 | 函数执行的具体操作 |
返回值
| 1 2 3 4 5 6 7 8 | 函数是通过 return 语句将运行代码得倒的值传递给调用者，返回值成为函数调用的结果 >>> def f1(): print ( 123 ) return "111" >>> f1() 123 '111' |
全局变量
| 1 2 | 在函数之外的模块文件中顶层书写的变量为全局变量，全局变量可以被函数读取，全局变量在函数体中 可以被修改，但不能被重新赋值。全局变量变量名最好为大写。 |
global
| 1 2 3 4 5 6 7 8 9 10 11 | 全局变量在函数中可以通过alobal语句重新赋值，字典和列表等不可以 >>> NAME = "jym" >>> def f1(): age = 18 global NAME NAME = 'jym1' print (age,NAME) >>> f1() 18 jym1 |
传递参数
| 1 | 参数通过赋值传递给函数，参数的传递为对象引用，即修改传递的对象可以改变调用者共享的对象。 |
可传递参数类型
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 | 1 、普通参数：严格按照顺序，将实际参数赋值给形式参数 >>> def f1(k1,k2): print (k1,k2) >>> f1( 'name' , 18 ) name 18 2 、指定参数：将实际参数赋值给指定的形式参数 >>> def f1(k1,k2): print (k1,k2) >>> f1(k1 = 'jym' ,k2 = 18 ) jym 18 3 、默认参数：必须放置在参数列表的最后 >>> def f1(k1,k2,k3 = 'ok' ): print (k1,k2,k3) >>> f1( 'jym' , 18 ) jym 18 ok >>> f1( 'jym' , 18 , 'OK' ) jym 18 OK 4 、动态参数 * 接受任意形式的实际参数，默认将传递的参数，全部放置于元组中 >>> def f1 ( * args): print (args, type (args)) >>> f1( 11 , 22 , 33 , 'gg' ) ( 11 , 22 , 33 , 'gg' ) < class 'tuple' > >>> l1 = [ 11 , 22 , 33 , 'gg' ] >>> f1( * l1) ( 11 , 22 , 33 , 'gg' ) < class 'tuple' > 5 、动态参数 * * 接受指定参数，默认将传递的参数，全部放置于字典中 >>> def f1( * * args): print (args, type (args)) >>> f1(s1 = 'dict' ,s2 = 18 ) { 's1' : 'dict' , 's2' : 18 } < class 'dict' > >>> dic = { 'k1' : 'v1' , 'k2' : 'v2' } >>> f1(kk = dic) { 'kk' : { 'k1' : 'v1' , 'k2' : 'v2' }} < class 'dict' > >>> f1( * * dic) { 'k1' : 'v1' , 'k2' : 'v2' } < class 'dict' > 6 、组合参数 >>> def f1( * args, * * kwargs): print (args, type (args)) print (kwargs, type (kwargs)) >>> f1( 11 , 22 ,k1 = 'v1' ,k2 = 'v2' ) ( 11 , 22 ) < class 'tuple' > { 'k1' : 'v1' , 'k2' : 'v2' } < class 'dict' > |
lambda表达式
| 1 2 3 4 5 6 7 8 9 10 11 12 | lambda 表达式创建一个对象但将其作为结果返回， lambda 表达式可以用在定义简单功能的函数， 或 def 语句不能使用的地方。 原 def 语句定义的函数： >>> def f1(a1): return a1 + 100 >>> f1( 10 ) 110 lambda 语句定义的函数： >>> f2 = lambda a1: a1 + 100 >>> f2( 10 ) 110 |
2、函数实例
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 | 例1：寻找序列的交集 def intersect(seq1,seq2): res = [] for i in seq1: if i in seq2: res.append(i) return res 例2：简单的提示用户注册或登录 def login(username,password): '' ' For the user log in :param username: user input :param password: user input : return : True success, False failure '' ' user_db = open ( "user_db" , 'r' ) for line in user_db: line_list = line.strip(). split ( ":" ) if line_list[0] == username and line_list[1] == password: return True return False def register(username,password): '' ' Used to user registration :param username: user input username :param password: user input password : return : None '' ' user_db = open ( "user_db" , 'a' ) temp = "\n" +username + ":" + password user_db.write(temp) user_db.close() def main(): login_msg = input( "1:login; 2:register :" ) if login_msg == "1" : username = input( "please input your name:" ) password = input( "please input your password:" ) ret_login = login(username,password) if ret_login: print( "login success..." ) else : print( "login failure..." ) elif login_msg == "2" : username = input( "please input your name:" ) password = input( "please input your password:" ) register(username,password) main() |
3、递归函数
在函数的内部调用自身本身，这就是递归函数，但要注意的是，递归效率低，最好使用循环解决问题
示例：
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | 使用 for 循环阶乘 def f(n): ret = 1 for i in range ( 1 ,n): ret = ret * i return ret print (f( 20 )) 使用递归 def fact(n): # 结束条件 if n = = 1 : return 1 return n * fact(n - 1 ) print (fact( 20 )) |
4、内置函数（小部分）
abs()：取绝对值
| 1 2 | >>> print(abs(-3)) 3 |
all(),any() : 判断可迭代对象的真假
| 1 2 3 4 5 6 7 8 9 10 11 | #all() 全部为真，就为真,包含可迭代对象 #any() 有一个为真，就为真，包含可迭代对象 #false = 0,None,[],{},(),"",'' >>> all([1,2,3,4]) True >>> all([0,1,2,[]]) False >>> any(([],1,0,None)) True >>> any([0,None,[],{},(), "" , '' ]) False |
bin()：将传入的十进制数转换为二进制
oct()：将传入的十进制数转换为八进制
hex()：将传入的十进制数转换为十六进制
| 1 2 3 4 5 6 | >>> bin(5) '0b101' >>> oct(15) '0o17' >>> hex(15) '0xf' |
bool()：判断传入的值的真假
| 1 2 3 4 | >>> bool(1) True >>> bool([]) False |
bytes()：字符串转换为字节类型
| 1 2 3 4 5 | >>> str1 = "余则成" >>> bytes(str1,encoding= "utf-8" ) b '\xe4\xbd\x99\xe5\x88\x99\xe6\x88\x90' >>> bytes(str1,encoding= "gbk" ) b '\xd3\xe0\xd4\xf2\xb3\xc9' |
str()：任意类型转化内字符串
| 1 2 3 4 5 6 7 8 | >>> str(bytes(str1,encoding= "utf-8" ),encoding= "utf-8" ) '余则成' >>> i = 111 >>> str(i) '111' >>> l = [1,2,3,4] >>> print(str(l), type (str(1))) [1, 2, 3, 4] <class 'str' > |
二、内置函数之文件处理
1、open()，创建一个Python文件对象，可以作为计算机上的一个文件链接。
打开文件
| 1 2 3 4 5 6 7 8 | file1 = open ( "user_db" , 'r' ) #只读，读出字符串 file1 = open ( "user_db" , 'rb' ) #只读，读出字节类型 file2 = open ( "user_db" , 'w' ) #写入，以字符串形式，先清空源文件 file2 = open ( "user_db" , 'wb' ) #写入，以字节码形式，先清空源文件 file2 = open ( "user_db" , 'x' ) #文件存在，报错，不存在，创建并只写 file3 = open ( "user_db" , 'a' ) #追加，以字符串形式 file3 = open ( "user_db" , 'ab' ) #追加，以字节码形式 file3 = open ( "user_db" , 'r+' ,encoding= "utf-8" ) #同时对文件可读可写 |
操作文件
| 1 2 3 4 5 6 7 8 9 | str1 = file1. read () #把整个文件读进单一字符串 str1 = file1. read (N) #读取之后的N个字节（一或多个）到一个字符串 str1 = file1.readline() #读取下一行（包括行末标识符）到一个字符串 li1 = file1.readlines() #读取整个文件到字符串列表 file2.write(STR) #写入字节字符床到文件 file2.writelines(LIST) #把列表内所有字符串写入文件 file2.flush() #把输出缓冲区刷到硬盘中，但不关闭文件 file2.seek(N) #将文件指针移动至N处 file2.close() #关闭文件 |
2、文件上下文管理器
不依赖于python自身的垃圾回收器，将文件处理代码包装到逻辑层中，在退出后可以自动关闭文件。在2.6以上，3.X系列的版本可使用。
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | 将user_db文件中的前10行写入到user_db1文件中 with open ( 'user_db' , 'r' ,encoding= "utf-8" ) as f1, open ( "user_db1" , 'w' ,encoding= "utf-8" ) as f2: times = 0 for line in f1: print(line) times += 1 if times <=10: f2.write(line) else : break 将user_db文件中的全部内容写入user_db1文件中，并替换其中的字符串 with open ( 'user_db' , 'r' ,encoding= "utf-8" ) as f1, open ( "user_db1" , 'w' ,encoding= "utf-8" ) as f2: for line in f1: new_str = line.replace( "old_str" , "new_str" ) f2.write(new_str) |