大家好，小编来为大家解答以下问题，python快速编程入门课后答案第二版，python快速编程入门第二版电子版，现在让我们一起来看看吧！
在学习 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文件来存储
测试代码
2566
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
