一、函数基础

   函数是将一些语句集合在一起的部件，可在程序中多次运行；函数是为了最大程度的代码重用；函数能以多种形式接收传递的参数，并返回不同的值。

   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、内置函数（小部分）

wKiom1ipp5zzRB-JAAKbDCcAqK4074.png

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)