python编程从入门到实践学习笔记

最新推荐文章于 2022-10-31 16:31:26 发布

九月星城

最新推荐文章于 2022-10-31 16:31:26 发布

阅读量884

点赞数 1

分类专栏：笔记 python

本文链接：https://blog.csdn.net/xingcheng_1314/article/details/118938668

版权

python 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

笔记

2 篇文章 0 订阅

订阅专栏

第一章

一、安装python

1.python官网地址
https://www.python.org/downloads/release/
2.下载好后用管理员模式打开安装包
3.

第二章

2.1 运行

    hello_world.py
    运行文件拓展名为.py的文件，编辑器会用python解释器来运行它。
    语法高亮

2.2 变量

message = “hello python world”

其中message为变量

2.2.1 变量的命名和使用

变量名只能包含字母、数字和下划线。可以以字母或者下划线打头，但不能以数字打头。
变量名不能包含空格，可以用下滑线代替分割单词。
不能将python关键字和函数名作为变量名。
多个变量赋值：x,y,z = 0, 0, 0，就是可以连写的意思
变量名尽可能简短但要具有描述性。
慎用小写字母l和大写字母O。
尽量使用小写字母作为python的变量名，用全大写字符作为常量名。

2.2.2 使用变量避免命名错误

当不小心错误拼写了变量名，python解释器会提供traceback
NameError：name ‘ ** ’ is not defined

2.3 字符串

字符串就是一系列字符。在python中，用引号括起来的都是字符串，其中的引号可以是单引号，也可以是双引号。
“this is a string.”

2.3.1 使用方法修改字符串的大小写

upper()将字符串所有字符变为大写
lower()将字符串所有字符变为小写
title()以首字母大写的方式显式每个单词

name = ‘Ada Lovelace’
print(name.upper())
print(name.lower())

output:
ADA LOVELACE
ada lovelace

2.3.2 拼接字符串

python使用（+）来合并字符串

first_name = "ada"
last_name = "lovelace"
full_name = first_name + " " +last_name
print(full_name)

output:
ada lovelace

2.3.3 添加空白和删除空白

制表符：\t
换行符：\n
rstrip() 保证字符串尾没空白
lstrip() 保证字符串头没空白
strip() 去除字符串两端空白

f_lan = ' python '
f_lan.rstrip()
>' python'
f_lan.lstrip()
>'python '
f_lan.strip()
>'python'

2.3.4 使用字符串时避免语法错误

在用单引号括起的字符串中，如果包含撇号，就将导致错误。如果想在单引号括起的字符串中输入撇号，则要加“\”进行转意。

message = 'one of python\'s strengths is its diverse community.
print(message)

output:
one of python's strength is its diverse community.

2.4 数字

2.4.1 整数

在python中可以对整数进行（+）（-）（*）（/）运算，其中（**）表示乘方运算。

2.4.2 浮点数

python将带小数点的数字都称为浮点数。

>>>0.1 + 0.1
>0.2
>>>2 * 0.2
>0.4

2.4.3 使用函数str()避免类型错误

函数str()，让python将非字符串值表示为字符串

age = 23
age = str(age)

2.5注释

    一行行注释可以用：#
    多行注释可以用：’’’ ‘’’
    注释或多行注释快捷键 ctrl + 1

# 这是一行注释
''' 
这是好几行注释
这是好几行注释
这是好几行注释
'''

第三章列表简介

3.1 列表是什么

列表是由一系列按特定顺序排列的元素（元素类型为str）组成。
python中用方括号（[ ]）来表示列表，并用逗号来分隔其中的元素。

3.1.1 访问列表元素

列表是有序集合，因此要访问列表的任何元素，只需将该元素的位置或索引告诉python即可。
要访问列表元素，可指出列表的名称，再指出元素的索引，并将其放在方括号内。

bicycles = ['trek','cannodale','redline']
print(bicycles[0])

output:
trek

3.1.2 索引

python中，第一个列表元素的索引是0，不是1
访问列表中最后一个元素，索引为-1
访问列表中修改、添加和删除元素

3.2.1 修改列表元素

要修改列表元素，可制定列表名和要修改元素的索引，再制定该元素的新值。

motorcycles = ['honda','yamaha','suzuki']
motorcycles[0] = 'dayun'
print(motorcycles[0])

output:
dayun

3.2.2 在列表中添加和删除元素

在列表末尾添加元素 list.append(’ ')
在列表中插入元素 list.insert(位置，‘ ’）
用del语句删除元素 del list[位置]
方法pop()可删除列表末尾的元素，并能接着使用它。列表弹出（pop）源自于这样的对比：列表就像一个栈，而删除列表末尾的元素相当于弹出栈顶元素。

motorcycles = ['honda','yamaha','suzuki']
popped_motorcycle = motorcycles.pop()
print(popped_motorcycle)

output:
suzuki

弹出列表中任何位置的元素 pop()，在pop()中输入索引，则可删除列表中任意位置的元素。
根据值删除元素 list.remove(‘值’)，使用remove()从列表中删除元素时，也可接着使用它的值。

3.3 组织列表

3.3.1 使用方法sort（）对列表进行永久性排序

可以根据数字或者字母排序

cars = ['bmw','audi','toyota','subaru']
cars.sort()
print(cars)

output:
['audi','bmw','subaru','toyota']

如果想按字母顺序倒序排序，可以给sort()方法传参 reverse=true

3.3.2 使用函数sorted()对列表进行临时排序

要保留列表元素原来的排列顺序，同时以特定的顺序呈现他们，可使用函数sorted()。

cars = ['bmw','audi','toyota','subaru']
print(sorted(cars))

output:
['audi','bmw','subaru','toyota']

如果想要按字母相反的顺序显示列表，也可向sorted()传递参数** reverse = True**

3.3.3 倒着打印列表

list.reverse()

cars = ['bmw','audi','toyota','subaru']
cars.reverse()
print(cars)

output:
['subaru','toyota','audi','bmw']

3.3.4 确定列表的长度

len()可快速获悉列表的长度，长度为元素的个数。

第四章操作列表

4.1 遍历整个列表

magicians = ['alice','dacid','carolina']
for magician in magicians:
	print(magician)

output:
alice
dacid
carolina

每一次循环中magician就代表当时被操纵的元素。注意三点：冒号、单复数和缩进。

4.2 创建数值列表

4.2.1 使用range()生成数字

    range()函数可以生成一系列数字。
    range(0,5):生成0~4每次加1,等于range(5)
    range(2,12,2):生成每次2~10，每次加2

for value in range(1,5):
	print(value)

output:
1
2
3
4

for value in range(2,12,2):
	print(value)

output:
2
4
6
8
10

4.2.2 使用range()创建数字列表

list（）可以将range（）的结果转变为列表

numbers = list(range(1,6)
print(numbers)

output:
[1,2,3,4,5]

将前10个整数的平方加入到一个列表中
squares = []
for value in range(1,11):
	squares.append(value**2)
print(squares)

output:
[1,4,9,16,25,36,49,64,81,100]

4.2.3 对数字列表执行简单的统计计算

最大值max()，最小值()，求和sum()

digits = [1,2,3,4,5,6,7,8,9,0]
min(digits)
>0
max(digits)
>9
sum(digits)
>45

4.2.4 列表解析

列表解析将for循环和创建新元素的代码合并成一行。
列表名 = [列表元素语句 for 元素 in range(,)]

squares = [value**2 for value in range(1,11)]
print(squares)

4.3 使用列表的一部分

处理列表部分元素的时候可以使用切片。

4.3.1 切片

players = ['charles','martina','michael','florence','eli']
print(players[0:3])

output:
['chrles','martina','michael']

如果要提取列表的第2~4个元素，可将起始索引指定为1，并将终止索引指定为4
如果没有指定第一个索引，python将自动从列表开头开始
如果没有指定最后一个索引，python将提取到末尾
要提取最后i个元素，可使用list[-3,1]
便利切片的方式与遍历列表相同

4.3.2 复制列表

需要根据既有列表创建相同的全新列表，可创建一个包含整个列表的切片，方法是同时省略起始索引和终止索引。

假设a为list，b=a，则b变化时a也会变化

my_foods = ['pizza','falafel','carrot cake']
friend_foods = my_foods[:]
friend_foods1 = my_foods
friend_foods.append('ice cream')
print(my_foods)
friend_foods1.append('ice cream')
print(my_foods)

output:
['pizza','falafel','carrot cake']
['pizza','falafel','carrot cake','ice cream']

4.4 元组

元素不可修改的列表为元组，元组用圆括号（）来标识。除了定义元组和修改元组元素值之外其他都和列表操作相同。

4.4.1 定义元组

dimensions = (200,50)
print(dimensions[0])

output:
200

4.4.2 修改元素变量

如果想要修改元素变量，只能重新定义整个元组。

dimensions = (200，50)
print(dimension)
dimensions = (500,20)
print(dimensions)

output:
200   50
500   20

4.6 设置代码格式

行长：每行不超过80字符

第五章

5.1 条件测试

每条if语句的核心都是一个值为True或False的表达式，这种表达式是条件测试。

5.2.1 检查是否相等与不相等

判断是否相等：“==”
判断是否不相等：“！=”
检查是否相等时不考虑大小写，即要区分大写字母与小写字母

5.2.2 比较数字

“=”，“<”，“>”，“<=”，“>=”

5.2.3 检查多个条件

可以使用and和or比对多个条件
and检查两个条件都为True，or检查两个条件有一个满足

5.2.4 检查特定值在或不在列表中

in或者not in

5.2.5 布尔表达式

布尔表达式是条件测试的别名。与条件表达式一样，布尔表达式的结果要么为True，要么为False。

5.3 if语句

5.3.1 if-else语句

需要在条件测试通过了执行一个操作，没通过时执行另一个操作。

age = 17
if age >= 18:
	print(..)
else:
	print(..)

5.3.2 if-elif-else 结构

python只执行if-elif-else结构中的一个代码块，它依次检查每个条件测试，直到遇到通过了的条件测试。
if-elif-else中elif可多次出现，即完整结构为if-elif-elif-…-else。
其中else可以省略
测试多个条件都需要满足时，需要使用多个if代码块

5.4 使用if语句处理列表

在if语句中将列表名用在条件表达式中时，python将在列表至少包含一个元素时返回True，并在列表为空时返回False。

第六章字典

6.1 使用字典

字典是一系列键-值对，即字典名 = {‘键’：‘值’，‘键’：‘值’｝

6.2.1 访问字典中的值

要获取与键相关联的值，可依次指定字典名和放在方括号内的值

alien_0 = {'color':'green'}
print(alien_0['color']

output:
green

get()方法。
dict.get（‘键’，‘ ’）第一个参数用于指定键，必不可少，当有该键对应的值时返回该值；第二个参数为指定的键不存在时要返回的值。

6.2.2 添加键-值对

要添加键-值对，可依次指定字典名、用方括号括起键和相关联的值。python不关心键-值对的添加顺序，而只关心键和值对关联关系。

alien_0 = {'color':'green','points':5}
alien_0['x_posi'] = 0
print(alien_0)

output:
{'color':'green','points':5,'x_posi':0}

6.2.3 修改字典的值

要修改字典中的值，可依次指定字典名，用方括号括起的键以及与该键相关联的新值。

alien_0 = {'color':'green'}
alien_0['color'] = 'yellow'
print(alien_0)

output:
{'color':'yellow'}

6.2.4 删除键值对

del dict[‘键’]
del alien_0 [‘points’]

6.3 遍历字典

6.3.1 遍历所有的键值对

要编写用于遍历字典的for循环，可声明两个变量，用于存储键-值对中的键和值。对于这两个变量，可使用任何名称。

for k,v in user_0.items()

6.3.2 遍历字典中的所有键

遍历键对：1.遍历字典时，会默认遍历所有的键；2.在不需要使用字典中的值时，用方法keys()遍历键。这两种方法是一样的

for k in user_0.keys()
=
for k in user_0

方法keys()并非只能用于遍历，实际上，它返回一个列表，其中包括字典中的所有键。
print(字典.keys()) 可返回键表

6.3.3 遍历字典中的所有值

如果要调用字典中包含的值，可使用方法values()，它返回一个值列表，而不包括任何键。

for v in user_0.values()

通过对包含重复元素的列表调用set()，可让python找出列表中独一无二的元素。

6.4 嵌套

6.4.1 字典列表

将一系列字典嵌套在列表中

alien_0 = {'color':'green','points':5}
alien_1 = ['color':'yellow','points':10}
alien_2 = ['color':'red','points':15}
aliens = [alien_0,alien_1,alien_2]

for alien in aliens:
	print(alien)

output:
{'color':'green','points':5}
['color':'yellow','points':10}
['color':'red','points':15}

6.4.2 在字典中存储列表

pizza = {
	'crust':'thick',
	'toppings':['mushrooms','extra chess']
	}

for topping in pizza['toppings']:
	print(topping)

output:
mushrooms
extra cheese

6.4.3 在字典中存储字典

users = {
	'aeinstein':{
		'first':'albert',
		'last':'einstein',
		'location':'princeton'
	},
	'mcurie':{
		'first':'marie',
		'last':'curie',
		'location':'paris'}
	}

第七章用户输入和while循环

7.1 函数input()的工作原理

函数input()接受一个参数：即要向用户显示的提示或说明，让用户知道该如何做。

message = input("Tell me something,and I will repeat it back to you:")
print(message)

output:
Tell me something,and I will repeat it back to you:
Hello everyone!

7.1.1 编写清晰的程序

提示可能超过一行，在这种情况下可将提示存储在一个变量中，再将该变量传递给函数input()。

prompt = “If you tell us who you are,we can personalize the messages you see."
prompt += "\nWhat is your first name?"

7.1.2 使用int()来获取数值输入

int（变量）= 数值

7.1.3 求模运算符

求模运算符（%）将两个数相除并返回余数，可用来判断奇偶。
偶数都能被2整除，因此对一个数和2执行求模运算的结果为0，即 number%2 == 0，那么这个数就是偶数，否则就是奇数。

4 % 3
>1
6 % 3
>0

7.2 while循环简介

遍历序列和数组时，只能用for，用while会死循环

7.2.1 使用while循环

可以使用while循环来数数

current_number == 1
while current_number <= 5：
	current_number += 1

7.2.2 使用标志

在要求很多条件都满足才继续运行的程序中，可定义一个变量，用于判断整个程序是否处于活动状态，这个变量被称为标志。
在while语句中就只需检查一个条件，标志当前值是否为True，并将所有测试都放在其他地方。

active = True
while active:
	message = input(prompt)
	if message == 'quit':
		active = False
	else:
		print(message)

7.2.4 使用break和continue退出循环

break：立即退出while循环，不再运行循环余下的代码，也不管条件测试的结果如何
continue：要返回到循环开头，并根据条件测试结果决定是否继续执行循环。跳出当前循环剩下的语句，进行下一轮循环。

7.3 使用while循环来处理列表和字典

7.3.1 在列表之间移动元素

users = ['alice','brian','candace']
confirmed_users = []

while users:
	current_user = users.pop()
	confirmed_users.append(current_user)

7.3.2 删除包含特定值的所有列表元素

假设有一个宠物列表，其中包含多个值为‘cat’的元素。要删除所有这些元素，可不断运行一个while循环，直到列表中不再包含值‘cat’

pets = ['dog','cat','dog','cat','goldfish','cat']
while 'cat' in pets:
	pets.remove('cat')

7.3.3 使用用户输入来填充字典

responses = {}
while polling_active:
	name = input('name')
	respense = input('response')
	respenses[name] = response

第八章函数

8.1 定义函数

def greet_user（）：             //①
	print('hello')              
greet_user

①处代码用关键字def 来定义一个函数，greet_user是函数名，还能在后面的括号中指出函数为完成其任务需要的参数
紧跟着①后面缩进的结构为函数体
要调用函数，可依次指定函数名以及用括号括起的必要信息

8.1.1 向函数传递信息

可在函数定义def greet_user()括号内添加username。

def greet_user()：
	print（'hello,' + username.title() + '!'
greet_user('jesse')

8.1.2 实参和形参

在函数greet_user(name) 变量username是一个形参----函数完成其工作所需的一项信息
在代码greet_user（‘jesse’)中，值’jesse’是一个实参，实参是调用函数时传递给函数的信息

8.2 传递实参

8.2.1 位置实参

python 必须将函数调用中的每个实参都关联到函数定义中的一个形参，最简单的关联方式是基于实参的顺序，这种方式是位置实参

def descrive_pet(animal_type,pet_name):
	print(animal_type)
	print(pet_name)
describe_pet('hamster','harry')

调用函数多次：可以调用函数多次，传递不同的参数
位置实参的顺序不可变

8.2.2 关键字实参

关键字实参是传递给函数的名称-值对。

def describe_pet(animal_type,pet_name):
	print(animal_type + pet_name)
describe_pet(animal_type = 'hamster',pet_name='harry')
=
describe_pet(pet_name ='harry',animal_type='hamster')

8.2.3 默认值

编写函数时，可给每个形参指定默认值，那么在实参没有指定时就会使用形参的默认值

def describe_pet(pet_name,animal_type='dog'):
	print(animal_type + pet_name)
describe_pet(pet_name='willie')

8.2.4 等效的函数调用

在调用参数时，要混合调用方式，同样的调用方式必须放在一起

#以下是错误的，原因在于传值给abd的实参放在了最后
def describe_pet(pet_name,abd,animal_type='dog'):
    print(pet_name + animal_type + abd)

describe_pet('liuliu',animal_type='dog','hahah')

8.3 返回值

函数可返回任何类型的值，包括列表字典等数据结构

8.3.1 返回简单值

def get_formatted_name(first_name,last_name):
	full_name = first_name +' ' +last_name
	terutn full_name.title()
	
musician = get_formatted_name('jimi','hendrix')
print(musician)

8.3.2 让实参变成可选的

想要让实参变成可选的，就可以在形参处给一个空字符串的值。

def get_formatted_name(first_name,last_name,middle_name=''):

8.4 传递列表

列表可以作为参数传递给函数，在函数中的形参作为列表也可以修改，如果不想修改列表原来的值，可以用list[:]复制一个列表。

8.5 传递任意数量的实参

有时候不知道函数需要接受多少个实参，可以在形参前加 “ * ” 以收入不定数量的实参。

def make_pizza(*toppings):
	print(toppings)
make_pizza('pepperoni')
make_pizza('mushrooms','green peppers','extra cheese')

8.5.1 使用*args传参

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。*args 用来将参数打包成tuple给函数体调用

def function(x, y, *args):
    print(x, y, args)

function(1, 2, 3, 4, 5)

output:
1,2,(3,4,5)

8.5.2 使用 **kwrgs传递字典

**kwargs 打包关键字参数成dict给函数体调用

def function(**kwargs):
    print( kwargs, type(kwargs))
function(a=1，b=2，c=3)

output：
{'a':1,'b':2,'c':3}

def build_profile（first，last，**user_info）：
	profile = {}
	profile['first_name' ] = first
	for key,value in user_info.items():
		profile[key] = value
	return profile
user_profile = build_profile('albert',location = 'prinveton',field='physics')
print(user_profile)

output:
{'first_name':'albert','location':'princeton','field':'physice'}

8.5.3 位置关系

参数arg、*args、**kwargs三个参数的位置必须是一定的。必须是(arg,*args,**kwargs)这个顺序，否则程序会报错。

8.6 导入函数

导入整个模块，即.py结尾的文件： import pizza
导入模块中的某个函数：from 文件 import 函数
使用as给函数指定别名：from 文件 import 函数 as 别名
使用as给模块指定别名：import 文件 as 别名
导入模块中的所有函数： import *

8.7 函数编写指南

编写函数应指定的是线性名称，在其中只使用小写字母和下划线
给形参和实参指定默认值时，等号两边不要有空格
函数或类的定义下面都用文档字符串""" “”"注释
在类内用一行来区分两个函数，类之间空两行。

第九章类

9.1 创建和使用类

9.1.1创建Dog类

class Dog()：
	def __init__(self,name,age):
		self.name = name
		self.age = age
	def sit(self):
		print(self.name.title() + "is now sitting.")
	def roll_over(self):
		print(self.name.title() + " rolled over!")

方法__init__()
类中的函数称为方法；__init__是一个特殊的方法，每当创建新实例的时候，将自动传入实参self。每个与类相关联的方法调用都自动传递实参self，它是一个执行实例本身的引用，让实例能够访问类中的属性和方法。
可以说该方法中的属性都为类原本的属性。
Dog()类还定义了另外两个方法，sit()和roll_over()，这两个方法不需要额外的信息，它们只有一个形参self，self会包含Dog()类的所有本身属性。

9.1.2 根据类创建实例

class Dog()：
	--snip--
my_dog = Dog('willie',6)                                //①
print(my_dog.name + " is " + str(mydog.age) + " years old")

    在①处，python使用实参’willie‘和6调用Dog类中的方法__init__（）。方法__init__()创建一个表示特定小狗的示例，并使用我们提供的值来设置属性name和age。
    init（）并未显式地包含return语句，但python自动返回一个表示这条小狗的实例。

访问属性
要访问实例的属性，可使用句点表示法即 my_dog.name
调用方法
根据Dog类创建实例后，就可以使用句点表示法来调用Dog类中定义的任何方法。
创建多个实例
可按需求创建任意数量的实例，入your_dog之类

9.2 使用类和实例

创建类后需要执行的一个重要任务是修改实例的属性。

class Car():
	def __init__(self,make,model,year):
		self.make = make
		self.model = model
		self.year = year
	def get_descriptive_name(self):
		long_name = str(self.year) + ' ' + self.make + ' ' +self.model
		return long_name.title()

9.2.1 属性指定默认值

类中的每个属性都必须有初始值，哪怕这个值是0或空字符串。如果给了初始值，就无需包含为它提供初始值的形参。

class Car():
	def __init__(self,make,model,year):
		self.make = make
		self.model = model
		self.year = year
		self.odometer_reading = 0                   #指定了默认值

9.2.3 修改默认的值

直接修改属性的值
实例名.属性名 = 新值

class Car():
		--snip--
my_new_car = Car('audi','a4',2016)
my_new_car.make = 'Tesla'                #修改属性名

通过方法修改属性的值
可定义一个方法，用于修改属性，方法内部也是 self.属性名 = 新值

class Car（）：
		--snip--
	def update_name(self,mileage):
		self.name = mileage

9.3 继承

一个类继承另一个类时，它将自动获得另一个类的所有属性和方法；原有的类称为父类，新类为子类。

9.3.1 子类继承父类的属性

class Car（）:
	def __init__(self,make,model,year):
		self.make = make
		self.model = model
		self.year = year

class ElectricCar(Car):                   #继承父类的子类
	def __init__(self,make,model,year):
		super().__init__(make,model,year) #继承父类的属性

9.3.2 给子类定义属性和方法

让一个类继承另一个类后，可添加区分子类和父类所需的新属性和方法。

```python
class Car（）:
	def __init__(self,make,model,year):
		self.make = make
		self.model = model
		self.year = year

class ElectricCar(Car):                   #继承父类的子类
	def __init__(self,make,model,year):
		super().__init__(make,model,year) 
		self.battery_size = 70            #子类的特有属性

9.3.3 重写父类的方法

对于父类的方法，只要它不符合子类模拟的实物的行为，可在子类中定义一个这样的方法，即它与要重写的父类方法同名。

9.3.5 将实例用作属性

使用代码模拟实物的时候，可能会发现添加的细节特别多：属性和方法清单都太长。这个时候可以将类的一部分作为一个独立的类提取出来。

class Car()：
	--snip--
class Battery():
	def __init__(self,battery_size=70):
		self.battery_size = battery_size
class ElectricCar(Car):
	super().__init__(make,model,year)
	self.battery = Battery()        # 即将属性设置为一个类

9.4 导入类

导入类的方法和导入函数的方法相同。

# car.py是一个模块，Car是一个类
from car import Car

第十章文件和异常

10.1 从文件中读取数据

10.1.1 读取整个文件

with open（‘文件名’）as 变量

with open('pi_digits.txt') as file_object:
	contents = file_object.read()
	print(contents)

函数open（），要以任何方式使用文件－哪怕仅仅是打印其内容，都得先打开文件，这样才能访问。函数open（）接受一个参数：要打开的文件的名称。

10.1.2 文件路径

相对路径
相对路径是相对于当前py文件下的文件，文件路径用反斜杠标识()
比如当前文件在python_work下，要打开python_work下中一个test文件夹中的test_text.txt文件。

with open('test/test_text.txt') as file_object   #file_object是test_text.txt在代码中的对象名。

10.1.3 逐行读取

要逐行读取文件中的内容，可以对文件对象使用for循环。文件中每行的末尾有一个看不见的换行符，这样会造成多余的空白行，可以使用rstrip()来消除。

with open('pi_digits.txt') as pi:
	for line in pi:
		print(line.rstrip())

outut:
3.2415926
3243243
2453654

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

readlines()从文件中读取每一行，并将其存储在一个列表中。

with open('filename') as file_object:
	lines = file_object.readlines()
for line in lines:
	print(line.rstrip())

10.2 写入文件

10.2.1 写入空文件

open()的第二个实参可以是‘w’，‘r’，‘a’，‘r+’

r:只读，不存在则返回异常
w:覆盖写模式，不存在则创建
x:创建写模式，不存在则创建，存在则异常
a:追加写模式，同上
b:二进制文件模式
+：原功能基础增加读写功能

with open('filename','w') as file_object:
	file_object.write('I love programming.')

python只能将字符串写入文本文件。要将数值写进去要先用str()将其转换为字符串格式。
x写入多行时需要自行在文本末尾添加换行符。

10.2.2 附近内容到文件末尾

打开文件时使用 ‘a’ 即可。

with open('filename','a') as file_object

10.3 存储数据

10.3.1 使用json.dump()和json.load()

函数json.dump()接受两个实参：要存储的数据以及可用于存储数据的文件对象。

import json
numbers = [2,3,5,7,11,13]
with open('numbers.json','w') as f_obj:
	json.dump(numbers,f_obj)

json.load()用于读取json文件中的数据

import json
with open('filename') as f_obj:
	numbers = json.load(f_obj)
	print(numbers)

output:
[2,3,5,7,11,13]

10.4 异常

使用了try-except代码块时，即便出现异常，程序也会继续运行显式友好的错误消息，而不是令用户迷惑的traceback。

10.3.1 使用try-except代码块

try：
	print(5/0)
except ZeroDivisionError:
	print("you can't divide by zero!")

10.3.2 else代码块

else 是写try余下的语句。

try：
	answer = int(first_number)/int(second_number)
except ZeroDivisionError:
	print('you cant divide by 0!')
else:
	print(answer)

10.3.6 分析文本

使用方法split（），根据一个字符串创建一个单词列表。

title = "Alice in Wonderland"
title.split()
['Alice','in','Wonderland']

九月星城

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
python编程从入门到实践学习笔记

第一章一、安装python1.python官网地址https://www.python.org/downloads/release/2.下载好后用管理员模式打开安装包3.第二章2.1 运行hello_world.py运行文件拓展名为.py的文件，编辑器会用python解释器来运行它。语法高亮2.2 变量‘’‘pythonmessage = “hello python world”‘’’其中message为变量2.2.1 变量的命名和使用变量名只能包含字母、数字和下划线。可
复制链接

扫一扫