Python编程：从入门到实践.pdf ：Python 基础笔记，最基本的 Python语法，快速上手入门 Python

在学习 python 时的一些简单的笔记，参考学习书本为 Python编程：从入门到实践.pdf 。因为前三章相对简单，因此没有具体的笔记。
测试部分的笔记待补充。

注：原文章在 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)

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 "", 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 "", 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)

 in 
----> 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)

 in 
----> 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文件来存储

测试代码