一、函数基础
函数是将一些语句集合在一起的部件，可在程序中多次运行；函数是为了最大程度的代码重用；函数能以多种形式接收传递的参数，并返回不同的值。
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)
110lambda语句定义的函数：
>>> 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)
|
本文转自 元婴期 51CTO博客，原文链接:http://blog.51cto.com/jiayimeng/1899086