python基础

python基础从了解到入门

Posted by 青夜梓藤 on 2019-05-21

python 基础从了解到入门


python 基础

1 字符串处理

首字母大写:str.title()

转换成大写:str.upper()

转换成小写:str.lower()

字符串拼接:+

制表符:\t

换行:\n

删除空白:str.lstrip() str.rstrip() str.strip()

2 整数

加减乘除:+ - * /
乘方:**

3 浮点数

4 str()类型转换

如 str(23)

5 列表

python 中用[]表示列表,用逗号分隔其中的元素

1
2
fruits= ['apple','banana','orange']
print fruits

5.1 访问元素

1
2
3
4
5
6
#访问某个元素
print(fruits[0].title())

#Python中将索引指向-1,可访问最后一个元素,这种索引页适合其他的负索引,如-2表示倒数第二个元素,-3表示导出
第3个元素
print fruits[-1]

5.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
# 修改
fruits[0]='tomato'


# 添加,append()方法将元素加到末尾而不影响其它元素
fruits.append('apple')


# append()方法让动态创建数组变得十分容易,可先创建一个空数组,再动态添加数据
nums = []
nums.append('1')
nums.append('3')


# 插入,使用insert(),可以在列表任意位置插入数据
nums.insert(1,'2')


# 删除,del删除,前提:知道要删除的元素在列表中的位置
del nums[0]


# 删除,pop()删除---后进先出,从列表中弹出最后一个元素
fruits= ['apple','banana','orange']
print fruits
poped_fruits = fruits.pop()
print fruits
print poped_fruits


# 弹出列表中任何位置的元素,可以用pop()来弹出列表中任意位置的元素,只需要在括号中传要弹出元素的索引
poped_fruits = fruits.pop(1)


# 说明,如果你要从列表删除一个元素,且不再以任何方式使用它,就使用del语句;如果你要在删除元素后还能继续
用它,就使用方法pop()。


# 根据值删除元素,remove(),remove只删除第一个指定的值,如果要删除的值在列表中出现多次,俺就需要循环判断
来删除
fruits.remove('orange')

5.3 列表排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# sort()方法,永久排序,永久性修改列表元素排序,不可恢复到原来的排序
fruits= ['tomato','apple','banana','orange']
fruits.sort()
print fruits
fruits.sort(reverse=True)#按字母表逆序排


# sorted(),临时排序,sorted()让你能够按特定顺序显示列表元素,同时不影响它们在列表中的原始排列顺序,逆序
排列,传递参数reverse=True
fruits= ['tomato','apple','banana','orange']
fruits_sorted = sorted(fruits)
print fruits
print fruits_sorted
fruits_sorted = sorted(fruits,reverse=True)


# 倒着打印列表
fruits= ['tomato','apple','banana','orange']
fruits.reverse()
print fruits

5.4 缺少列表长度 len()

1
2
fruits= ['tomato','apple','banana','orange']
len(fuits)

5.5 遍历整个列表

1
2
3
fruits= ['tomato','apple','banana','orange']
for f in fruits:
print f

5.6 数值列表

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
# 打印一系列数字in range(),注意in range()是前闭后开的
for i in range(1,5):
print i


# 使用range()创建数字列表
nums = list(range(1,6))
print nums


# 使用函数range()时,还可指定步长,打印1-10内所有的偶数
nums = list(range(2,11,2))
print nums


# 使用range()几乎能实现所有的数字集,如下为1-10的乘方
squares = []
for i in range(1,11):
square = i**2
squares.append(square)
print squares


# 对数字列表执行简单的统计计算min()/max()/sum()
min(squares)
max(squares)
sum(squares)


#要使用下面这种语法,首先指定一个描述性的列表名,如squares;然后,指定一个左方括号,并定义一个表达式,用
于生成你要存储到列表中的值。在这个示例中,表达式为value**2,它计算平方值。接下来,编写一个for循环,用于给
表达式提供值,再加上右方括号
squares = [value**2 for value in range(1,11)]

5.7 列表切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 要创建切片,可指定要使用的第一个元素和最后一个元素的索引。 与函数range()一样
fruits= ['tomato','apple','banana','orange']
print fruits[0:2]
print fruits[1:3]


# 如果没有指定第一个索引,Python将自动从列表开头开始
print fruits[:3]


# 不指定第二个索引,则切片终止于列表末尾
print fruits[2:]


# 可以使用负索引,打印列表末尾元素,如下打印后3个
print fruits[-3:]

5.8 遍历切片

1
2
3
fruits= ['tomato','apple','banana','orange']
for f in fruits[:3]:
print f

5.9 复制列表

1
2
3
# 复制列表原理,创建一个包含整个列表的切片,方法是同时省略起始索引和终止索引([:])
my_fruits= ['tomato','apple','banana','orange']
your_fruits = my_fruits[:]

6 元组

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的,这对处理网站的用户列表或游戏中的角色列表至关重要。然而,有时候你需要创建一系列不可修改的元素,元组可以满足这种需求

6.1 定义元组

1
2
3
4
#元组看起来犹如列表,但使用圆括号而不是方括号来标识
bytime = ('year','month','day')
print bytime[0]
print bytime[1]

6.2 遍历元组

1
2
for t in bytime:
print t

6.3 修改元组变量

1
2
3
# 虽然不能修改元组的元素,但可以给存储元组的变量赋值。因此,可通过重新定义整个元组来修改元组变量
bytime = ('year','month','day')
bytime = ('year','month','day','hour','minite','second')

7 if

7.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
# 检查是否相等
car = 'Bwt'
car == 'bwt'# 考虑大小写
car.lower() == 'bwt'#不考虑大小写


# 检查是否不相等
car = 'Bwt'
if(car != 'Audio'):
print 'error'


# 比较数字 > < >= <= ==
# 多个条件检查
# and :与关系
# or:或关系


# 检查特定值是否包含在列表中,可以用in实现
bytime = ('year','month','day')
bytimes = ['yy','mm','dd']
'years' in bytime
'years' in bytimes


# 检查特定值是否不包含在列表中,not in
bytime = ('year','month','day')
'years' not in bytime

7.2 if 语句格式

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
# 最简单的if
if conditional_test:
do something


# if-else
age = 17
if age > 18:
print '未成年'
else:
print '已成年'


# if-elif-else
age = 12
if age < 4:
print("Your admission cost is $0.")
elif age > 18:
print("Your admission cost is $5.")
else:
print("Your admission cost is $10.")


# 使用多个elif
age = 12
if age < 4:
price = 0
elif age < 18:
price = 5
elif age < 65:
price = 10
else:
price = 5
print("Your admission cost is $" + str(price) + ".")


# 省略else代码块,else是一条包罗万象的语句,只要不满足任何if或elif中的条件测试,其中的代码就会执行,可能
会引入无效甚至恶意的数据。

# 测试多个条件,多个if连续判断

7.3 使用 if 语句处理列表

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
# 检查特殊元素
fruits = ['tomato','apple','banana','orange']
for fruit in fruits:
if fruit == 'apple':
print 'sorry ,we are out of '+ fruit + 'now'
else:
print 'buy'+ fruit


# 确定列表不是空的
fruits = []
if fruits :
for fruit in fruits:
print 'buy'+ fruit
else:
print 'buy nothing'


# 使用多个列表
avilable_fruit = ['apple
','banana','orange']
buy_fruit= ['tomato','apple']
for buy in buy_fruit:
if buy in avilable_fruit:
print ('buy '+buy)
else:
print ('sorry ,we are out of '+ buy + 'now')

8 字典

8.1 定义字典,花括号

1
stu={'name':'zhangsan','age':18,'class':'test'}

8.2 访问字典中的值

1
print (stu['name'])

8.3 添加键值对

1
2
stu['addr']='湖北武汉'
stu['work']='Tester'

8.4 创建空字典

8.5 修改字典中的值

1
2
stu={'name':'zhangsan','age':18,'class':'test'}
stu['age']=20

8.6 删除键值对

1
2
stu={'name':'zhangsan','age':'18,'class':'test'}
del stu['class']#注意删除的键值对永远消失了

8.7 遍历字典

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
#遍历所有键值对
stu={'name':'zhangsan','age':'18','class':'test'}
for key,value in stu.items():
print('\nkey: '+key)
print('value: '+value)


# 遍历所有键
stu={'name':'zhangsan','age':18,'class':'test'}
for key in stu.keys():
print('\nkey: '+key)


# 遍历字典时,会默认遍历所有的键,因此,如果将上述代码中的for key in stu.keys():替换为for key in stu:,
输出将不变。


# 方法keys()并非只能用于遍历,实际上,它返回一个列表,其中包含字典中的所有键
if 'class' not in stu.keys():
print(stu['name']+'已经毕业')


# 按顺序遍历字典中所有键
stu={'name':'zhangsan','age':18,'class':'test'}
for key in sorted(stu.keys()):
print('\nkey: '+key)


# 遍历字典中的所有值
intersts={'张珊':'sing','李思':'dance','王武':'sing','赵流':'write'}
for value in intersts.values():
print('\nvalue: '+value)


# 通过对包含重复元素的列表调用set(),可让Python找出列表中独一无二的元素,并使用这些元素来创建一个集合
intersts={'张珊':'sing','李思':'dance','王武':'sing','赵流':'write'}
for value in set(intersts.values()):
print('\nvalue: '+value)

8.8 嵌套

将一系列字典存储在列表中,或将列表作为值存储在字典中,这称为嵌套

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
# 字典列表
stu_1 = {'name':'zhangsan','age':'18','grade':'72'}
stu_2 = {'name':'lisi','age':'20','grade':'90'}
stu_3 = {'name':'wangwu','age':'17','grade':'80'}
stu_list = [stu_1,stu_2,stu_3]
for stu in stu_list:
print (stu)


aliens = []
# 创建30个绿色的外星人
for alien_number in range(30):
new_alien = {'color': 'green', 'points': 5, 'speed': 'slow'}
aliens.append(new_alien)
# 显示前五个外星人
for alien in aliens[:5]:
print(alien)
print("...")


# 显示创建了多少个外星人
print("Total number of aliens: " + str(len(aliens)))


# 将前三个外星人修改为黄色的、速度为中等且值10个点
for alien in range[:3]:
if alien['color'] == 'green':
alien['color']= 'red'
alien['points'] = 10
alien['speed']='medium'
print alien


# 在字典中存储列表
goods ={'zhangsan':['sing','dance'],'lisi':['look book','have foods'],'wangwu':['write','sports']}
for name,good in goods.items():
print (name + "'s goods are:")
for g in good:
print (g)


# 在字典中存储字典
grades = {'zhangsan':{'english':'80','math':'90','chinese':'72'},'lisi':{'english':'82','math':'70','chinese':'92'}}
for name,grade in grades.items():
print (name + "'s grades are :")
for sub,score in grade.items():
print (sub + ":" + score)

9 用户输入函数

9.1 input()

让程序暂停运行,等待用户输入一些文本。获取用户输入后,Python 将其存储在个变量中,以方便你使用。Python 2.7,应使用函数 raw_input()来提示用户输入

1
2
3
4
5
msg = input("请输入你喜欢的数字")
print (msg +"是个很美妙的数字")

msg = raw_input("请输入你喜欢的数字")
print (msg +"是个很美妙的数字")

9.2 使用 int 来将获取的字符转换为数字

age = input(“how old are you?”)
age = int(age)
if age > 18:
print (‘>18’)

9.3 求模运算

求模运算符(%)是一个很有用的工具,它将两个数相除并返回余数,可用于判断奇数偶数

1
7%3

10 while 循环

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
61
62
63
64
65
66
67
68
69
70
71
72
# 条件不满足退出
num = 1
while num <=5:
print (num)
num += 1


# 用户自己选择何时退出
msg = ''
while msg != 'quit':
msg = input('tell me something')
if msg != 'quit':
print (msg)


# 使用标识控制程序结束
flag = True
while flag:
msg = input('input something')
if msg == 'quit':
flag = False
else:
print (msg)


# 使用break退出循环
while True:
msg = input('input something')
if msg == 'quit':
break
else:
print ('I love ' + msg)


# 在循环中使用continue
num = 0
while num <10:
num += 1
if num % 2 == 0:
continue
print (num)


# while循环来处理列表和字典
# 将补考通过的学员加入通过学员列表中
stu_fail = ['xiaoming','qingqing','dongdong']
stu_pass = []
while stu_fail:
passstu = stu_fail.pop()
print ('恭喜'+passstu+'补考通过')
stu_pass.append(passstu)
print (stu_pass)


# 删除列表中包含的某元素(全删,并不是只删除第一个)
test= ['dog','cat','pig','dog','mouse','dog']
while 'dog' in test:
test.remove('dog')
print (test)


# 使用用户输入来填充字典
response = {}
flag = True
while flag:
name = input('what is your name ?')
res = input('what is intersting ?')
response[name] = res
ismore = input('do you want to others ,yes or no ? ')
if ismore == 'no':
flag = False
print (response)

11 函数

11.1 函数应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 所有补考的学员考完后移动到通过人员列表中
def haveexam(all,passstus):
while all:
current = all.pop()
print (current + 'is having the exam !')
passstus.append(current)

def passstu(psslist):
for stu in psslist:
print (stu + 'has pass the exam !')

stus = ['xiaoming','xiaohua','honghong']
pass_stu = []
haveexam(stus,pass_stu)
passstu(pass_stu )
1
2
3
4
5
6
# 上述学员通过后,会从原来的补考列表中删除,要想原来的补考列表仍保留,可通过传递备份实现
stus = ['xiaoming','xiaohua','honghong']
stus_bak = stus[:]
pass_stu = []
haveexam(stus_bak,pass_stu)
passstu(pass_stu )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 传递任意数量实参
# *fruits,创建一个名为fruits的空元组,,并将收到的所有值都封装到这个元组中,将实参封装到一个元组中,即便
函数只收到一个值也如此
def shopping(*fruits):
for fruit in fruits:
print ('add ' + fruit + 'to order list')

shopping('apple','orange','banana')


# 结合使用位置实参和任意数量实参
def shopping(counts ,*fruits):
print ('I have '+counts + ' yuan .I can buy : ')
for fruit in fruits:
print (fruit)

shopping('10','apple','orange','banana')
1
2
3
4
5
6
7
8
9
10
11
# 使用任意数量的关键字参数
def get_user_info(firname,lastname,**otherinfo):
user_info = {}
user_info['firstnam']= firname
user_info['lastname']= lastname
for key,value in otherinfo.items():
user_info[key]= value
return user_info

stu_info = get_user_info('zhang','san',age=12,grade='one')
print (stu_info)

11.2 将函数存储在模块中

① 导入整个模块
创建test.py文件,import test
② 导入特定的函数
from module_name import function_name
from module_name import function_0, function_1, function_2
③ 使用as给函数指定别名
from module_name import function_name as fn
④ 使用 as 给模块指定别名
import module_name as mn
⑤ 导入模块中的所有函数
from module_name import *

12 类

12.1 使用类和实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Dog():
def __init__(self,name,age):
self.name = name
self.age = age

def sit(self):
print (self.name + 'is sitting')

def roll_over(self):
print (self.name + 'is rolling ,and its age is '+ str(self.age))

dog = Dog('jack',18)
dog.sit()
dog.roll_over()


# 在Python 2.7中创建类时,需要做细微的修改——在括号内包含单词object
class ClassName(object):

12.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
class Car():
def __init__(self, name, model, year):
self.name = name
self.medel = model
self.year = year
self.runlength = 0


def get_fullname(self):
ful = str(self.year) + ',' + self.name + ',' + self.medel
print(ful)
return ful


def update_run(self, mil):
if mil >= self.runlength:
self.runlength = mil
else:
print('you can not run back length')


def increce_run(self, addmil):
self.runlength += addmil


class ElecCar(Car):
def __init__(self, name, model, year):
super().__init__(name, model, year)


my_elec_car = ElecCar('Audi', 'Q4', 2013)
my_elec_car.get_fullname()
my_elec_car.update_run(10)
my_elec_car.increce_run(20)
print(str(my_elec_car.runlength))


# 在Python 2.7中,继承语法稍有不同,函数super()需要两个实参:子类名和对象self
class ElectricCar(Car):
def __init__(self, make, model, year):
super(ElectricCar, self).__init__(make, model, year)

12.3 给子类定义属性和方法

1
2
3
4
5
6
7
class ElecCar(Car):
def __init__(self, name, model, year):
super().__init__(name, model, year)
self.color = 'red'

def print_color(self):
print('my color is '+ self.color)

12.4 重写父类方法

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
class Car():
def __init__(self, name, model, year):
self.name = name
self.medel = model
self.year = year
self.runlength = 0

def get_fullname(self):
ful = str(self.year) + ',' + self.name + ',' + self.medel
print(ful)
return ful

def update_run(self, mil):
if mil >= self.runlength:
self.runlength = mil
else:
print('you can not run back length')

def increce_run(self, addmil):
self.runlength += addmil

def to_write(self):
print ('i am father')


class ElecCar(Car):
def __init__(self, name, model, year):
super().__init__(name, model, year)
self.color = 'red'

def print_color(self):
print('my color is ' + self.color)

def update_run(self):
print('hhh')

def to_write(self):
print ('i am sun')


my_elec_car = ElecCar('Audi', 'Q4', 2013)
my_elec_car.get_fullname()
my_elec_car.update_run()
my_elec_car.increce_run(20)
print(str(my_elec_car.runlength))
my_elec_car.print_color()
my_elec_car.to_write()


# update_run()和to_write()都是重写父类方法,在子类中定义一个与父类同名的方法,参数可不同,Python将不会考
虑父类的这个方法,而只关注子类中定义的相应方法

12.5 将实例用作属性

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
class Car():
def __init__(self, name, model, year):
self.name = name
self.medel = model
self.year = year
self.runlength = 0

def get_fullname(self):
ful = str(self.year) + ',' + self.name + ',' + self.medel
print(ful)
return ful

def update_run(self, mil):
if mil >= self.runlength:
self.runlength = mil
else:
print('you can not run back length')

def increce_run(self, addmil):
self.runlength += addmil

def to_write(self):
print ('i am father')

class CarAttr():
def __init__(self,color='red',size=4):
self.color =color
self.size = size

def print_color(self):
print('my color is '+ self.color)

def print_size(self):
print('my color is ' + str(self.size))

class ElecCar(Car):
def __init__(self, name, model, year):
super().__init__(name, model, year)
self.attr = CarAttr()

def update_run(self):
print('我是重写的方法')

def to_write(self):
print ('i am son')


my_elec_car = ElecCar('Audi', 'Q4', 2013)
# 调用父方法
my_elec_car.get_fullname()
my_elec_car.increce_run(20)
print(str(my_elec_car.runlength))
# 调用重写的方法
my_elec_car.update_run()
my_elec_car.to_write()
# 将实例用作属性定义的方法
my_elec_car.attr.print_size()
my_elec_car.attr.print_color()

12.6 导入类

1
2
3
4
5
6
7
8
9
10
11
12
# 导入单个类:
from car import Car

# 从一个模块中导入多个类:
from car import Car, ElectricCar

# 导入整个模块:
import car

# 导入模块中的所有类,不推荐,需要从一个模块中导入很多类时,最好导入整个模块,并用module_name.class_name
语法来访问类:
from module_name import *

12.7 OrderedDict

字典让你能够将信息关联起来,但它们不记录你添加键—值对的顺序。要创建字典并记录其
中的键—值对的添加顺序,可使用模块 collections 中的 OrderedDict 类

1
2
3
4
5
6
7
8
from collections import OrderedDict
favarite_fruit = OrderedDict()
favarite_fruit['xiaodong']='apple'
favarite_fruit['xiaoxi']='pear'
favarite_fruit['xiaonan']='banana'
favarite_fruit['xiaobei']='orange'
for name,fruit in favarite_fruit.items():
print(name + "'s favarite fruit is " + fruit)

13 文件

13.1 读取整个文件

1
2
3
4
5
6
7
8
9
10
# open()要以任何方式使用文件都得先打开文件,哪怕仅仅是打印其内容
# 关键字with在不再需要访问文件后将其关闭
# 在文件路径中使用反斜杠(\)而不是斜杠(/)
with open ('D:/pythontest/pi_digits.txt') as file:
# 读取文件全部内容
contents = file.read()
# read()到达文件末尾时返回一个空字符串,而将这个空字符串显示出来时就是一个空行。
print (contents)
# 要删除多出来的空行,可在print语句中使用rstrip():
print (contents.rstrip())

13.2 逐行读取

1
2
3
4
filepath= 'D:/pythontest/pi_digits.txt'
with open(filepath) as file:
for line in file:
print (line.rstrip())

13.3 创建一个包含文件各行内容的列表

1
2
3
4
5
6
7
filepath= 'D:/pythontest/pi_digits.txt'
with open(filepath) as file:
# 从文件中读取每一行,并将其存储在一个列表中
lines = file.readlines()

for line in lines:
print (line)

13.4 使用文件内容

1
2
3
4
5
6
7
8
9
filepath= 'D:/pythontest/pi_digits.txt'
with open(filepath) as file:
# 从文件中读取每一行,并将其存储在一个列表中
lines = file.readlines()
pi= ''
for line in lines:
pi += line.strip()
print (pi)
print(len(pi))

13.5 包含一百万位的大型文件

1
2
3
4
5
6
7
8
9
10
11
filepath= 'D:/pythontest/pi_digits.txt'
with open(filepath) as file:
# 从文件中读取每一行,并将其存储在一个列表中
lines = file.readlines()
pi= ''
for line in lines:
pi += line.strip()


# 保留10位
print (pi[:10]+'...')

13.6 写入空文件

1
2
3
4
5
filepath= 'D:/pythontest/write.txt'
# 已写入方式打开文件
with open(filepath,'w') as file:
# 这种方式写入文件会直接覆盖掉文件原有内容,并不是追加写
file.write('test')

13.7 写入多行

1
2
3
4
5
6
7
filepath= 'D:/pythontest/write.txt'
# 已写入方式打开文件
filepath= 'D:/pythontest/write.txt'
with open(filepath,'w') as file:
# 这种方式写入文件会直接覆盖掉文件原有内容,并不是追加写
file.write('line one \n')
file.write('line two \n')

13.8 追加写

1
2
3
4
5
filepath= 'D:/pythontest/write.txt'
with open(filepath,'a') as file:
# 这种方式写入文件会直接覆盖掉文件原有内容,并不是追加写
file.write('line three \n')
file.write('line four\n')

14 异常

14.1 处理 ZeroDivisionError 异常

1
2
3
4
try:
print(5/0)
except ZeroDivisionError:
print ('you can not devide by zero')

14.2 使用异常避免崩溃

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# try-except-else工作原理:只有可能引发异常的代码才需要放在try语句中,仅在try代码块成功执行时才需要运行的
代码应放在else代码块中。except代码块指示try代码块运行出现了异常该怎么办。
print('give me two number and i will tell you the division result to you')
print("press 'q' to quit")

while True:
fir_num = input('the first number')
if fir_num == 'q':
break
sec_num = input('the second number')
if sec_num == 'q':
break
try:
result = int(fir_num)/int(sec_num)
except Exception as e:
print(e)
else:
print (result)

14.3 处理 FileNotFoundErro

1
2
3
4
5
6
7
8
filepath = 'D:/pythontest/test.txt'
try:
with open(filepath) as file:
contents = file.read()
except FileNotFoundError:
print(filepath+' not exsit')
else:
print(contents)

14.4 分析文本

1
2
3
4
5
6
7
8
9
10
11
filepath = 'D:/pythontest/write.txt'
try:
with open(filepath) as file:
contents = file.read()
except Exception as e:
print('something error,the detail into is : '+e)
else:
words = contents.split(' ')
words_len = len(words)
print (words)
print('total num is :'+ str(words_len))

14.5 使用多个文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def count_book(filepath):
try:
with open(filepath) as file:
contents = file.read()
except Exception as e:
print( e)
else:
words = contents
words_len = len(words)
print (words)
print( 'total num is :' + str(words_len))

books = ['D:/pythontest/write.txt' ,'D:/pythontest/1.txt' ,'D:/pythontest/2.txt','D:/pythontest/3.txt']
for book in books:
count_book(book)

14.6 存储数据

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
# json.dump(),将数字列表存储到json文件中
import json
nums = [1,2,3,4,5]
file = 'D:/pythontest/3.txt'
with open(file,'w') as file_obj:
json.dump(nums,file_obj)


# json.load(),将列表读取到内存
import json
filepath = 'D:/pythontest/3.txt'
with open(filepath) as file_obj:
nums = json.load(file_obj)
print (nums)


# 保存和读取用户生成的数据
import json
username = input('tell me your name and i will remember it :')
filepath = 'D:/pythontest/username.txt'
with open(filepath,'w') as file_obj:
json.dump(username,file_obj)
print('i have remember your name,'+username)



import json
filepath = 'D:/pythontest/username.txt'
try:
with open(filepath) as file_obj:
username = json.load(file_obj)
print('welcome bace '+ username)
except FileNotFoundError:
with open(filepath,'w') as file_obj:
username = input('tell me your name and i will remember it :')
json.dump(username,file_obj)
print('i have remember your name,'+username)