大家好,本文将围绕python编程从入门到精通pdf网盘展开说明,python编程入门经典pdf下载是一个很多人都想弄明白的事情,想搞清楚python编程入门到精通pdf需要先了解以下几个事情。
Source code download: 本文相关源码
在学习 python
时的一些简单的笔记,参考学习书本为 Python编程:从入门到实践.pdf
。因为前三章相对简单,因此没有具体的笔记学python编程的书。
测试部分的笔记待补充。
注:原文章在
jupyter notebook
书写,因此文章中的代码块上面为
python
代码,下面为即时运行结果
第四章——列表
name='mike'
name.title()
print(name)
print(name.title())
name_title=name.title()
print(name_title)
mike
Mike
Mike
.title()为首字母大写,.upper()为全部大写,.lower()为全部小写,但要注意,这些都不会修改变量本身,只是返回一个改变后的值,因此要写在print的()内或将其赋值给另一个变量,然后输出此变量
name1="mike alice"
name2='mike,alice'
name3='mike/alice'
name4='mike5alice'
print(name1.title())
print(name2.title())
print(name3.title())
print(name4.title())
Mike Alice
Mike,Alice
Mike/Alice
Mike5Alice
注意这个.title()方法,它会找到字符串中的所有独立单词,然后把它们首字母大写,只要不同单词之间用非字母的字符(如空格,符号,数字等等)隔开了,这就是两个单词,会被分别大写首字母
arr=['a','b','c']
print(arr)
['a', 'b', 'c']
print列表会把**整个列表(包括[])**都打印
arr=[]
arr.append('new')
print(arr)
['new']
**.append()**在列表后面插入元素,一次只能插入一个
arr=['a','b','c']
arr.insert(1,'d')
print(arr)
['a', 'd', 'b', 'c']
.insert()在列表中插入元素,第一个参数写要插入的位置,第二个写插入内容注意同样从0开始
arr=['a','b','c','d']
del arr[1]
print(arr)
['a', 'c', 'd']
del语句(注意不是方法)在列表中删除元素,del arr[],中括号内填要删除元素的位置
而且del函数不需要()
arr1=['a','b','c','d']
arr1.pop()
print('arr1:',end='')
print(arr1)
arr2=['a','b','c','d']
arr2.pop(1)
print('arr2:',end='')
print(arr2)
arr3=['a','b','c','d']
arr3_0=arr3.pop(0)
print('arr3:',end='')
print(arr3)
print('arr3_0:'+arr3_0)
arr1:['a', 'b', 'c']
arr2:['a', 'c', 'd']
arr3:['b', 'c', 'd']
arr3_0:a
.pop()在列表中删除元素,更像是弹出元素,对于.pop()弹出的元素,还可以再利用,储存在另外的变量中,如arr3_0;如果在()中不加数字,则默认弹出最后的一个元素
arr1=['a','b','c','d']
arr1.remove('a')
print(arr1)
arr2=['a','b','c','d','a']
the_remove_element='a'
arr2.remove(the_remove_element)
print(arr2)
['b', 'c', 'd']
['b', 'c', 'd', 'a']
.remove()在列表中删除指定值的元素,括号内填要删除的元素的内容,和.pop()一样,被删除的元素可以被赋给另一个变量再利用,但只能删除第一个指定的值,可以通过多次使用+循环判断来删除全部的,但当列表中没有指定值时,程序会报错
arr1=['b','a','d','c']
arr1.sort()
print(arr1)
arr2=['b','a','d','c']
arr2.sort(reverse=True)
print(arr2)
['a', 'b', 'c', 'd']
['d', 'c', 'b', 'a']
.sort()是对列表进行永久性排序,即修改列表本身,可以通过在()中传递参数reverse=True来倒序排列,注意这个True首字母必须大写,不然报错
arr=['b','a','d','c']
print(sorted(arr))
print(arr)
print(sorted(arr,reverse=True))
['a', 'b', 'c', 'd']
['b', 'a', 'd', 'c']
['d', 'c', 'b', 'a']
函数sorted()用于对列表临时排序,只是返回一个排序后的列表,而列表本身不发生改变,注意这个是函数,不是方法,同样可以reverse=True来倒序,但注意要写在arr的后面
arr=['a','b','c','d']
arr.reverse()
print(arr)
arr.reverse()
print(arr)
['d', 'c', 'b', 'a']
['a', 'b', 'c', 'd']
**.reverse()**用于永久性反转列表元素,注意不是排序,只是把所有的元素倒转了,**要恢复到原来的顺序,只要再用一次.reverse()**即可
arr=['a','b','c','d']
print(len(arr))
4
**函数len()**用于获取列表的长度,即元素个数,其返回列表中的元素个数
arr=['a','b','c','d']
for element in arr:
print(element+' is a letter.')
print('That\'s true\n')
print('END')
a is a letter.
That's true
b is a letter.
That's true
c is a letter.
That's true
d is a letter.
That's true
END
for 临时变量 in 列表名:(注意不要漏掉:)
sentence1
sentence2
...
缩进表明该行代码属于上一行,可以在for后面使用多个缩进,从而对列表中的每一个元素执行若干操作
临时变量的名字是任意的,但最好用有意义的名称
for num in range(1,5):
print(num)
print('*****')
for num in range(5):
print(num)
print('*****')
#输出1,2,3的平方
squares=[]
for num in range(1,4):
squares.append(num**2)
print(squares)
print('*****')
#指定步长
for num in range(1,6,2):
print(num)
1
2
3
4
*****
0
1
2
3
4
*****
[1, 4, 9]
*****
1
3
5
range()函数可以生成一系列数字,range(start,stop,step),但要注意这一系列数字不是列表list,不能直接print(range(1,5)),但可以用for一个个输出,从start开始输出,到stop停止,但不输出stop,而step为指定步长,即从start开始,每次加step输出
若()中只填一个数字,则默认该数字为stop,start默认为0
且注意不能倒序,stop要比start大
nums=list(range(1,5))
print(nums)
[1, 2, 3, 4]
**list()**函数可以把range()直接转换成list列表
nums=[1,2,3,4,5,6]
print(min(nums))
print(max(nums))
print(sum(nums))
1
6
21
对于数字列表(而不是range),python中有函数**min(),max(),sum()**来处理数据
#列表解析
squares=[num**2 for num in range(1,6)]
print(squares)
#常规写法
squares=[]
for num in range(1,6):
squares.append(num**2)
print(squares)
[1, 4, 9, 16, 25]
[1, 4, 9, 16, 25]
列表解析的语法/写法,可以将若干行代码合并成一行,在[]中,首先是定义一个表达式,该表达式的值会加到list中,然后就是for语句,它是用来提供表达式数值给表达式使用
如例子中是提供num给表达式num**2
另外注意该for是没有**:**的
#切片
names=['mike','alice','tim','jack']
print(names[1:3])
print(names[:3])
print(names[1:])
print(names[-2:])#使用负数索引并且不写stop来输出最后的几个切片,这样就无需知道list的长度也可以输出最后三个元素
['alice', 'tim']
['mike', 'alice', 'tim']
['alice', 'tim', 'jack']
['tim', 'jack']
通过[start:stop]来将列表切片,切片后的还是一个列表,和range一样,stop不会被输出,start不写则默认0,stop默认最后一个+1
可以通过使用负数索引来输出列表后面的切片
#复制列表
names_1=['mike','alice','tim','jack']
names_2=names_1[:]
names_1.append('1')
names_2.append('2')
print(names_1)
print(names_2)
#错误的复制列表
names_1=['mike','alice','tim','jack']
names_2=names_1
names_1.append('1')
names_2.append('2')
print(names_1)
print(names_2)
['mike', 'alice', 'tim', 'jack', '1']
['mike', 'alice', 'tim', 'jack', '2']
['mike', 'alice', 'tim', 'jack', '1', '2']
['mike', 'alice', 'tim', 'jack', '1', '2']
通过把list的切片(当然也可以[:]什么都不写来复制整个list)赋值给另外一个变量,来实现复制列表,这相当于创造了一个新的list副本
而如果不是赋值切片,而是直接赋值,则只是把两个变量都关联到了一个列表中,从而对两个变量中的任何一个更改都会导致列表被更改
menu=('cola','cake','chicken')
print(menu)
menu=('tea','milk')
print(menu)
('cola', 'cake', 'chicken')
('tea', 'milk')
元组(tuple)是不可更改元素的list,用()小括号而不是[],但元组变量可以被重新赋值,即让这个变量对应另外一个元组
第五章——if语句
names=['mike','alice','tim','jack']
if 'mike' in names:
print('yes')
if 'mike' in names and 'tom' not in names:
print('yes')
yes
yes
关键字in 和 not in用来判断一个元素是不是在列表/元组中
关键字and 和 or用来逻辑判断,and和or两边的表达式可以加括号(),也可以不加
elif可以有很多个,并且是按顺序执行的,即前面的if/elif不通过才执行,如果有一个if/elif通过了,则会舍弃剩下的elif。因此适用于仅一种条件满足的情况,如果有多个条件都可以满足的,应该用多个if语句
else可以没有,因为其包罗万象,因此有时候用elif会使条件更清晰
str=[]
if str:
print('list is not empty')
else:
print('list is empty')
list is not empty
对于空列表,在if语句中为返回False,而非空列表,则为True。
因此可以在程序执行来检查list是不是有元素的
dic={1:'one',2:'two'}
print(dic)
dic[3]='three'
print(dic)
dic[3]='3rd'
print(dic)
print(dic[1])
del dic[1]
print(dic)
{1: 'one', 2: 'two'}
{1: 'one', 2: 'two', 3: 'three'}
{1: 'one', 2: 'two', 3: '3rd'}
one
{2: 'two', 3: '3rd'}
字典是用大括号{}括起来的,其中是一系列键-值对,通过键可以找到与之关联的值,键一般是数字或字符串或对应字符串和数字的变量还有元组(即可哈希对象),而值则可以是python中的任何对象
键和值用**冒号:隔开,不同的键值对用逗号,**隔开
往字典中添加新的键值对和修改其中原有的键值对都是通过字典名[键名]=值的方式
而要获取值,则用字典名[键名],这会返回与键相关联的值
删除键值对用的是del函数,同样注意其是没有括号的
nums={
1:'one',4:'four',
2:'two',
3:'three',
}
print(nums)
{1: 'one', 4: 'four', 2: 'two', 3: 'three'}
通过上述方式可以将可以清楚的将数量很多的键值对清楚的写出来,可以每个占一行,当然也可以不这样,只要注意加上逗号,就可以
这里用缩进可以更清楚的显示,如果不缩进也是没问题的,这里不是从属关系,因为它们都在一个大括号{}内
对于其他的很长的代码如print()一大串东西也可以这样来分行写
dic={
1:"one",
2:'two',
3:'three',4:'four'
}
for num,english in dic.items():
print(str(num)+'\'s English is',english)
<built-in method items of dict object at 0x000001D330631A80>
1's English is one
2's English is two
3's English is three
4's English is four
通过**for key,value in dic.items()😗*来实现遍历所有的键值对,其中key保存键,value保存值,当然这两个变量可以用任何名称来命名
注意要用到**.items()**方法,不要忘了:
.items()操作会把键值对转换成一个个的元组,如:a:1会变成(a,1)从而用key,value可以逐一获取
dic={
4:'four',
1:"one",
2:'two',
3:'three',
}
for num in dic.keys():
print(num)
print('\n')
for num in dic:
print(num)
print('\n')
for num in sorted(dic.keys()):
print(num)
for num in dic:
print(dic[num])
4
1
2
3
4
1
2
3
1
2
3
4
four
one
two
three
通过**.keys()方法来遍历字典中的键,事实上,.keys()方法是返回一个包含字典中所有键的list**,因此对list能使用的方法对dic.keys()同样使用,如用sorted输出排序好的键
因此python默认遍历所有的键,所以.keys()方法如果不用,输出也是一样的,但用了.keys()会更清楚,但print(dic),和print(dic.keys())的输出情况是不一样 的,一个是键值对,一个是键
如例子中,因为num是存储着键,因此可以通过dic[num]来访问获得这个键对应的值
dic={
1:"one",
2:'two',
3:'three',
4:'four',
}
for english in dic.values():
print(english)
one
two
three
four
.values()方法用来返回一个包含字典中所有值的list
dic={
1:"one",
2:'two',
3:'three',
4:'four',
5:'one'
}
for eng in set(dic.values()):
print(eng)
four
two
three
one
set()函数用来对一个list使用,返回一个无序的里面每个元素都是只有一个的**(即除去了重复的元素,只保留一个)的list
一定注意是返回的是无序的,每次运行都会不一样
可以对dic.values()使用,因为字典中的值很多情况下会是重复的,这样可以除去重复的值
#在列表中存储字典
mike={'name':'mike','ID':'1'}
jack={'name':'jack','ID':'2'}
names=[mike,jack]
print(names)
for name in names:
print(name)
for name in names:
print(name['name'],name["ID"])
[{'name': 'mike', 'ID': '1'}, {'name': 'jack', 'ID': '2'}]
{'name': 'mike', 'ID': '1'}
{'name': 'jack', 'ID': '2'}
mike 1
jack 2
#在字典中存储列表
pizza={'size':'small',
'toppings':["tomatoes","potatoes","sausage"]}
print(pizza)
for key,value in pizza.items():
print(key,value)
print('the size is:'+pizza['size'])
for topping in pizza['toppings']:
print('\t'+topping)
{'size': 'small', 'toppings': ['tomatoes', 'potatoes', 'sausage']}
size small
toppings ['tomatoes', 'potatoes', 'sausage']
the size is:small
tomatoes
potatoes
sausage
#在字典中存储字典
users={'mike':{'name':'mike','age':'19'},
'jack':{'name':'jack','age':'18'}}
print(users)
print(users['mike'])
print(users['mike']['name'])#可以双重[],从而一层层打开字典
for user,info in users.items():
print(user+'\'s name is '+info['name'],', age is '+info['age'])
{'mike': {'name': 'mike', 'age': '19'}, 'jack': {'name': 'jack', 'age': '18'}}
{'name': 'mike', 'age': '19'}
mike
mike's name is mike , age is 19
jack's name is jack , age is 18
第七章——用户输入和while循环
将数值输入用于比较和计算时,务必要将其转换为int型
message=''
while message!='quit':
message=input()
if message!='quit':
print(message)
a
a
b
b
quit
对于要通过用户输入来选择退出,那么就需要将用户的输入设置为while的条件,但由于最开始用户是没有输入的,因此要给message设置一个初始值
sign=True
while sign==True:
message=input()
if message=='quit':
sign=False
else:
print(message)
q
q
quit
通过设置标志作为while的条件,当标志为True时,执行循环,当循环中任何一个情况使得标志为False时,都可以让循环终止
这样可以使得在会退出的情况很多的时候,只要检查标志就可以了
python中也有break和continue
animal=['cat','cat','dog','cat']
while 'cat' in animal:
animal.remove('cat')
print(animal)
['dog']
用while循环来删除list中的所有目标元素,如例子中用 ‘cat’ in animal这样的判断句式来作为条件,当animal中没有‘cat’时,循环自然终止
for循环是一种遍历列表的有效方式,但在for循环中不应修改列表,否则将导致Python难以跟踪其中的元素。
要在遍历列表的同时对其进行修改,可使用while循环。
对于for item in items:
这里的item是变量
对于while和if item in items:
这里的item是一个具体的值,如果item在items中,那么这个in语句是True,如果不在,那么这个in语句是False
第八章——函数
def func(a,b):
print(a,b)
func(1,2)#位置实参(position argument)
func(a=1,b=2)#关键字实参(keyword argument),关键字实参无需考虑位置
func(1,b=2)#这种方式,则关键字实参必须在位置形参后面
#否则会报错positional argument follows keyword argument
print('*****')
def func1(a,b=1):#有默认值的形参必须在无默认值形参的后面
print(a,b)
func1(2)#则默认2是赋值给a的,b则使用默认值
func1(2,3)
func1(a=2)
func1(a=2,b=3)
1 2
1 2
1 2
*****
2 1
2 3
2 1
2 3
def func(nums):
nums[3]=3
print(nums)
a={1:1,2:2}
print(a)#初始的字典
func(a)#在函数中操作后的字典
print(a)#操作后的字典,显示其已经被修改
{1: 1, 2: 2}
{1: 1, 2: 2, 3: 3}
{1: 1, 2: 2, 3: 3}
def func(nums):
nums.append(3)
print(nums)
a=[1,2]
print(a)
func(a[:])#在函数中,传入的副本被修改
print(a)#显示原列表未被修改
[1, 2]
[1, 2, 3]
[1, 2]
python中函数可以返回列表和字典
同时没有指针,可以直接传递列表和字典等给函数,这里的传入相当于传入指针,在函数中对列表和字典的修改都是直接对原始数据的永久性修改。//但是对于其他参数,则并不会修改原数据,和c中是一样的,函数中的变量和主程序中的变量是无关的,传参数只是赋值
如果想要保留列表中原始数据,可以传入副本,如list[:],即用切片的方式
import module_name#导入模块,使用其中函数时需要用module.function的方式(注意不要忘了句点)
from module_name import function_name#只导入模块中的这个函数,使用时直接用函数名,因为已经显式的表达了
from module_name import function1_name,function2_name,function3_name#可以导入任意数量的函数,分别用逗号隔开
import module_name as nickname#给模块加个别名,这样用别名即可,避免和主程序的名字冲突
from module_name import function_name as nickname#同上
from module_name import *#导入模块中所有函数,使用时直接使用函数名即可
File "<ipython-input-1-389ba8ac33df>", line 3
from module_name import function1_name,function2_name,function3_name#可以导入任意数量的函数,分别用逗号隔开
^
SyntaxError: invalid character in identifier
第九章——类
类的首字母注意要大写,调用方法不要忘记(),定义方法不要忘记(self)
与函数大体相似,导入方法和使用方法也一样
要注意下,如果导入的模块中的主程序有可以运行的代码,则在导入后,仍会在导入后的程序中运行,因此在模块中不要出现除函数和类外的代码
如果有需要测试的代码,则要用if init==‘main’:(codes)
# 类
class Restaurant():#而这个括号内则不需要填形参
def __init__(self,name,cuisine_type):#这里括号内填入这个创建类需要的的形参
self.name=name
self.cuisine_type=cuisine_type
self.num_served=0
def describe_restaurant(self):#不要self可以吗,不行,self是必须要有的参数
print('the restaurant\'s name is '+self.name)
print('the cuisine type is '+self.cuisine_type)
def open_restaurant(self):
print('the restaurant is open.')
def set_num_served(self,num_served):
self.num_served=num_served
def increment_num_served(self,increment):
self.num_served+=increment
restaurant=Restaurant('little box','sweet')#定义实例
# restaurant1=Restaurant('medium box','hot')
# restaurant2=Restaurant('big box','spicy')
# restaurant.describe_restaurant()
# restaurant1.describe_restaurant()
# restaurant2.describe_restaurant()
# print(restaurant.num_served)
# restaurant.increment_num_served(111)
# print(restaurant.num_served)
class menu():
def __init__(self):
self.food_type=2
self.food=['carrot','potato']
def show_food(self):
for food in self.food:
print(food)
class Canteen(Restaurant):#括号内要填父类的名称
def __init__(self,name,cuisine_type): #这里是Canteen本身的属性,因为是继承父类,所以必须要有和父类一样的形参,但可以自己多加形参,且
#顺序不必和父类一样,如def __init__(self,name,size,cuisine_type):在中间加了一个size的形参
#当然这个size的形参要在下面去赋给canteen属性,如self.size=size
'''succeed'''
super().__init__(name,cuisine_type) #这里是父类的形参,必须和父类保持一致,且没有self,因为这个__init__是父类的,不是canteen的
#注意顺序可以改变,但上面的canteen中的两个顺序也要改变,否则输入的参数会赋值给相反的变量
#我理解是下面这个super后面的__init__是用来与父类联系的,里面括号里面的形参会传递给父类,但
#其实这里面的名字不需要和父类的相同,这里的name,cuisine_type只是起到传递的作用,
#可以改成a,b是一样的,如果这样的话,那么上面def后面的__init__也要把name,cuisine_type改成a,b
#因为super后的行参是由def后面的形参提供的
#总结:
#def __init__()内的形参是Canteen这个类定义,可以任意取名字和数量(不必和父类一样),
#而下面super().__init__()内形参必须是def __init__()里面的全部或者部分已定义的形参,它们会像
#创建一个父类的实例(restaurant=Restaurant(a,b))一样把参数传递给父类,调用父类,
#故名字不必和父类一样,但为了清晰,我们通常是用一样的名字
self.num=11 #子类的特殊属性
self.menu=menu()#将实例用作属性
def construct_canteen(self,number):#子类的特殊方法
self.num+=number
canteen=Canteen('jiujiang','tasty')#定义实例
# print(canteen.name)
# canteen.describe_restaurant()
# canteen.set_num_served(100)
# print(canteen.num_served)
# canteen.construct_canteen(2)
# print(canteen.num)
# canteen.menu.show_food()#使用作为属性的实例中的方法
# print(canteen.menu.food_type)#使用作为属性的实例中的属性
①对于继承,只要class son(father):在括号里写父类的名字就可以了,而不需要再def init():
这样父类的属性和方法都可以被可以被子类使用,因此,建立实例时,要输入的实参和父类中形参的数目需保持一致
②如果在子类中用了def init():则父类中的def init():会被覆盖,这就是重写,子类的属性被子类中的def init():重新定义
如果在父类中有需要用到父类的参数才能运行的方法,同时要在子类中使用这个方法时,如父类中有self.name,并且有个print(self.name),那么因为子类的属性被重写,所以会缺少self.name这个属性,而无法使用这个print,这时的解决办法是在子类中同样再定义一个self.name的属性就可以了
因为子类是继承父类的,而除了__init__被重写了以外,其他都没有变,故只要能提供一个一样名字的参数,就可以继续使用父类的方法了
③如果在子类中重写了__init__,而仍然想要使用父类的属性,那么则要用到**super()**方法了,super方法在写在子类的def init():下面,从属于def init():,如上super().init(name,cuisine_type)
(关于init):__init__和其他的方法一样,都是由def定义的方法,(因此在其他方法中能执行的如for,print等等都是一样可以在这里面用的),只不过它会在一创建实例时就被调用,如果在def init():下写一个print(‘a’),那么只要一创建实例,就会执行print(‘a’),因此由它来定义类的属性,因为这样的话,每次创建实例时就要输入__init__中的参数,就可以在一开始就给实例赋予属性
另外1:事实上,也可以在其他方法中创建属性,这样创建的属性和在__init__中创建的没有区别,都是在整个类的所有方法中(而如果仅是方法中的局部变量,则在其他方法中不能使用)可以使用的,但是,由于其他方法必须在实例创建后调用,因此这些属性必须要调用方法后才能赋予实例,如
def function1(self,a):
print(‘this is from father’)
self.a=a
def function2(self):
print(self.a)
因此self.a这个属性必须在function1被调用后才能被才被赋予实例,而在function2中要用到self.a这个属性,所以,要使用function2,必须要先使用function1才行
另外2:关于self,self是永远指向创建的实例的,因此在所有的方法中,都必须有self这样形参,而且必须放在第一位参数,事实上,如果用别的名字不用self,也是可以的运行成功的,但是一般都选择self,编译器也会提醒使用self
另外3:关于super().,这个方法是用来调用父类,如上所见,super().init(),可以用来调用父类的性质,因为由上,__init__和其他方法没区别,因此,super()同样可以用来调用其他方法,super().function(),和上面调用__init__是一样的,通常是被用来在重写父类方法后还想调用其方法
def func(): #重写父类方法
pass
def func1():
super().func() #这样在就可以通过调用func1来调用父类中原始的func()方法了,**但一般都不需要这样**
第十章——文件和异常
with open('file_name') as nickname # (such as file_object):
txt=file_object.read()
File "<ipython-input-3-8b8347ab7f7a>", line 1
with open('file_name') as nickname # (such as file_object):
^
SyntaxError: invalid syntax
**open()**函数可以打开文件,括号内填入需要打开文件的文件名(包括后缀,这和模块不一样(模块默认.py所以不需要后缀))
**close()**可以关闭文件,但是如果用open和close容易产生bug
可以使用上面的关键字with,它可以在不再需要访问文件时将文件自动关闭,即让python去确定关闭,而我们只要打开就可以
一定要用as给这个文件一个别名,否则在下面不能使用它
用方法**.read()**可以读取文件的全部内容,并存入上面的txt变量中
相对文件路径:如果要读取的文件位于与程序相同目录下的子文件夹中,那么只需要把该子文件和其中的文件名写在open()即可,如open(‘txt_file\file.txt’)
绝对文件路径:即把文件的全部路径全部写出来
一般采取把文件路径存在一个变量中,再把变量传递给open会更清楚
(**要注意Windows下的文件路径用的是反斜杠**)
with open('pi.txt') as object:
for line in object:
print(line.rstrip(),end='')
print(line[:5])
---------------------------------------------------------------------------
FileNotFoundError Traceback (most recent call last)
<ipython-input-3-b128a636d124> in <module>
----> 1 with open('pi.txt') as object:
2 for line in object:
3 print(line.rstrip(),end='')
FileNotFoundError: [Errno 2] No such file or directory: 'pi.txt'
通过for循环来逐行读取文件中的文字,这时不需要再用.read()方法,因为这个方法是读取文件中的全部内容
直接for line in file:即可
要注意这时输出的文字,每两行中间都会空一行,这时因为文件中的每行末尾都有一个\n,然后print又会自动加一个\n,所以换了两次行。可以通过**.rstrip()**把每行末尾的空白字符删除(这里是\n)
对于字符串,可以通过[:5]来输出指定长度的文本
with open('pi.txt') as object:
lines=object.readlines()
print(lines)
---------------------------------------------------------------------------
FileNotFoundError Traceback (most recent call last)
<ipython-input-5-da4bd4254afc> in <module>
----> 1 with open('pi.txt') as object:
2 lines=object.readlines()
3 print(lines)
FileNotFoundError: [Errno 2] No such file or directory: 'pi.txt'
方法**.readlines()可以读取文件中的每一行,并且把它们都存在一个列表中并返回**,在上面的例子的,这个列表存在了变量lines中,并且每一行都被作为一个元素存在列表中
读取文本文件时,python将其中的所有文本都解读为字符串,因此要使用数据,要用int和float来转换
if birthday in pi:
print()
可以通过关键字in,让python去查找生日数据是不是在pi中,这里要先把pi变成一个字符串**(如删除空格和换行,把每一行连接在一起等等)**
#写入文件
with open('pi1.txt','w') as file_object:
file_object.write('this is also pi.\nyes')
通过在open()中使用两个参数中的第二个参数来指定模式
读取模式——‘r’,只能读取文件
写入模式——‘w’,只能写入文件,如果第一个参数中的文件名的文件不存在,则python会创建它,如果有指定的文件,该模式会把原文件清空,然后写入要写入的内容
使用**.write()方法写入,括号内填要写入的的字符串(只能是字符串,如果是数据,则要先转换成字符串),且注意该方法不会自动添加\n,因此如果要换行,则必须自己添加**,
附加模式——‘a’,不会清空原文件,会在最后面添加,一般会在字符串最前面加一个\n,因为原文件最后一行不一定有\n,会导致加入的字符串和原文件的字符串连在一起
读取和写入模式——‘r+’
#利用json格式文件存储数据
#这个例子用try来实现用户第一次加载文件时由于没有namejson文件而出现FileNotFoundError异常来提示用户输入name,而之后由于有了name.json文件
#则不需要再让用户输入name了
import json
filename_name='name.json'
try:
with open(filename_name,'r') as file_object:
name=json.load(file_object)
print('Welcome back',name)
except FileNotFoundError:
name=input('what\'s your name?')
with open(filename_name,'w') as file_object:
json.dump(name,file_object)
print('Hello,',name)
print('Have a good time!')
Welcome back mike
# 重构上面的这个函数,使之分成多个函数,更加清晰
import json
def get_stored_name():
filename='filename_name.json'
try:
with open(filename) as file_object:
# name=json.load(file_object)
name=file_object.read()
except FileNotFoundError:
return None#使用none,用于后面的if判断
else:
return name
def get_new_name():
filename='filename_name.json'
name=input('Please enter your name:')
with open(filename,'w') as file_object:
# json.dump(name,file_object)
file_object.write(name)
print('Hello,',name)
def greet_user():
name=get_stored_name()
if name:#用if来判断有没有name文件
print('Welcome back,',name)
else:
get_new_name()
greet_user()
json是需要import的一个模块
json.dump()包含两个参数,第一个是要存入的数据,第二个是要填入数据的.json文件(如果这个文件不存在,则会报错,因为json不具备创建文件功能,只能写入,因此需要用open来创建,因为如果open中的文件名文件不存在,open会自动创建这样一个文件,这里open要用’w’写入模式)
(注意在写入模式下,这个函数和.write()是一样的会把文件清空再写入,如果要加在原来的后面,则要用open函数的’a’附加模式)
json.load()包含一个参数,即要加载到内存中的文件
(注意:两个函数中都不能用filename,因为它只是文件名,而不是文件,用open()函数打开并用在as后面的别名(如上面的file_object)才是IO文件,IO文件才是可以读写的,千万注意,在用open()后,要使用文件都是用as后面的)
事实上,用json模块能实现的,用.read()和.write()也能实现,效果是一样的。只不过json模块更多的是用json文件来存储
测试代码