大一菜鸡Python总结

初次接触Python的一些入门知识

字符串及数据类型等

Python程序控制结构

想要写出一个比较好的程序控制结构，画流程图是非常重要的。想必在高中大家都有所借出流程图吧。以下是

流程图的7个基本元素

在这里插入图片描述
运用好基本元素就可以画出一个这样的流程图啦。

分支结构

程序由三种基本结构组成：顺序结构、分支结构、循环结构，这些基本结构都有一个入口和一个出口。任何程序都由这三种基本结构组合而成。

顺序结构
是程序按照线性顺序依次执行的一种运行方式，其中语句块S1和语句块S2表示一个或一组顺序执行的语句

2.分支结构
是程序根据条件判断结果而选择不同向前执行路径的一种运行方式，包括单分支结构和二分支结构。由二分支结构会组合形成多分支结构

在这里插入图片描述
3.循环结构
是程序根据条件判断结果向后反复执行的一种运行方式，根据循环体触发条件不同，包括条件循环和遍历循环结构

Python分支结构

共有单分支结构、二分支结构、多分支结构，其中分支结构还可以加入条件判断及组合

单分支结构
if <条件> :

<语句块>
2.二分支结构
if <条件> :

<语句块1>

else :

<语句块2>

3.多分支结构
f <条件1> :

<语句块1>

elif <条件2> :

<语句块2>

……
else :

<语句块N>

条件判断及组合

在这里插入图片描述

用于条件组合的三个保留字在这里插入图片描述

Python循环结构

根据循环执行次数的确定性，循环可以分为确定次数循环和非确定次数循环。确定次数循环指循环体对循环次数有明确的定义循环次数采用遍历结构中元素个数来体现。无限循环一直保持循环操作直到特定循环条件不被满足才结束，不需要提前知道确定循环次数。
1.遍历循环
遍历某个结构形成的循环运行方式，从遍历结构中逐一提取元素，放在循环变量中
for <循环变量> in <遍历结构> :

<语句块>

由保留字for和in组成，完整遍历所有元素后结束每次循环，所获得元素放入循环变量，并执行一次语句块

其中遍历循环的应用有：计数循环(N次)【遍历由range(M,N,K)函数产生的数字序列，产生循环】、计数循环(特定次)
【遍历由range(M,N,K)函数产生的数字序列，产生循环】、字符串遍历循环【遍历字符串每个字符，产生循环】、列表遍历循环【遍历其每个元素，产生循环】、文件遍历循环【fi是一个文件标识符，遍历其每行，产生循环】下图：在这里插入图片描述

无限循环

由条件控制的循环运行方式
反复执行语句块，直到条件不满足时结束

无限循环的应用
当我们陷入无限循环时，我们可以设置一些保留字，当其符合一些条件时使其强制退出。例如：在这里插入图片描述
break用来跳出最内层for或while循环，脱离该循环后程序从循环后代码继续续执行break跳出并结束当前整个循环，执行循环后的语句。
continue用来结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环， continue结束当次循环，继续执行后续次数循环
在这里插入图片描述

循环与else

在这里插入图片描述
for循环和while循环中都存在一个else扩展用法。
• else中的语句块只在一种条件下执行，即for循环正常遍历了
所有内容没有因为break或return而退出。

random库的使用

random库是生成及使用随机数的Python标准库，random库采用梅森旋转算法（Mersenne twister）生成伪随机数序列，可用于除随机性要求更高的加解密算法外的大多数工程应用。
使用random库: import random
在这里插入图片描述

列表&元组&字符串

序列是具有先后关系的一组元素，而列表元组字符串都属于序列类型。

在这里插入图片描述
序列通用操作符

在这里插入图片描述

列表

是一种序列类型，创建后可以随意被修改，使用方括号 [] 或list() 创建，元素间用逗号 , 分隔，列表中各元素类型可以不同，无长度限制
列表类型操作函数和方法
在这里插入图片描述

元组

是一种序列类型，一旦创建就不能被修改使用小括号 () 或 tuple() 创建，元素间用逗号 , 分隔可以使用或不使用小括号
创建空元组
tup1 = ();
元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：

tup1 = (50)
type(tup1) # 不加逗号，类型为整型
<class ‘int’>

tup1 = (50,)
type(tup1) # 加上逗号，类型为元组
<class ‘tuple’>

元组继承了序列类型的全部通用操作
元组因为创建后不能修改，因此没有特殊操作

访问元组

元组可以使用下标索引来访问元组中的值，如下实例:

tup1 = (‘Google’, ‘Runoob’, 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
以上实例输出结果：
tup1[0]: Google
tup2[1:5]: (2, 3, 4, 5)

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
tup1 = (12, 34.56);
tup2 = (‘abc’, ‘xyz’)

创建一个新的元组

tup3 = tup1 + tup2;
print (tup3)
以上实例输出结果：
(12, 34.56, ‘abc’, ‘xyz’)

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
tup = (‘Google’, ‘Runoob’, 1997, 2000)

print (tup)
del tup;
print ("删除后的元组 tup : ")
print (tup)
以上实例元组被删除后，输出变量会有异常信息
在这里插入图片描述
元组用于元素不改变的应用场景，更多用于固定搭配场景
如数据保护，将列表类型转换成元组类型 lt = tuple(ls)

列表更加灵活，它是最常用的序列类型

最主要作用：表示一组有序数据，进而操作它们
如元素遍历，
for item in ls(lt): <语句块>

字典

通过任意键信息查找一组数据中值信息的过程叫映射，映射是一种键(索引)和值(数据)的对应。
键值对：键是数据索引的扩展
字典是键值对的集合，键值对之间无序
在这里插入图片描述
键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
采用大括号{}和dict()创建，键值对用冒号: 表示
{<键1>:<值1>, <键2>:<值2>, … , <键n>:<值n>}
dict = {‘七幺二’: ‘712’卡特琳娜’: ‘9106’, ‘菲比’: ‘3258’}

在字典变量中，通过键获得值

<字典变量> = {<键1>:<值1>, … , <键n>:<值n>}

<值> = <字典变量>[<键>] <字典变量>[<键>] = <值>
[ ] 用来向字典变量中索引或增加元素

>>> dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
>>> dict["Alice"]
'2341'
>>> dict['Tom']='4554'
>>> dict
{'Alice': '2341', 'Beth': '9102', 'Cecil': '3258', 'Tom': '4554'}

字典处理函数及方法
在这里插入图片描述

集合

集合是多个元素的无序组合，集合类型与数学中的集合概念一致。集合元素之间无序，每个元素唯一，不存在相同元素。集合元素不可更改，不能是可变数据类型

！

集合用大括号 {} 表示，元素间用逗号分隔
建立集合类型用 {} 或 set()
建立空集合类型，必须使用set()

由于集合元素是无序的，集合的打印效果与定义顺序可以不一致。由于集合元素独一无二，使用集合类型能够过滤掉重复元素。set(x)函数可以用于生成集合

>>>S = {425, "BIT", (10, "CS"), 424}
>>>S
{424, 425, (10, 'CS'), 'BIT'}

>>>W = set(‘apple’)
{'e', 'p', 'a', 'l'}
>>>V = set(( "cat", "dog", "tiger", "human" ))
{'cat', 'human', 'dog', 'tiger'}

在这里插入图片描述

"""
set是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素。
set支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算。
set支持x in set, len(set), for x in set。
set不记录元素位置或者插入点, 因此不支持indexing, slicing, 或其它类序列的操作
"""
s = set([3,5,9,10])                                  # 创建一个数值集合，返回{3, 5, 9, 10}
t = set("Hello")                                     # 创建一个唯一字符的集合返回{}
a = t | s          t.union(s)                        # t 和 s的并集
b = t & s         t.intersection(s)                  # t 和 s的交集
c = t – s         t.difference(s)                    # 求差集（项在t中, 但不在s中）  
d = t ^ s          t.symmetric_difference(s)         # 对称差集（项在t或s中, 但不会同时出现在二者中）
t.add('x')         t.remove('H')                     # 增加/删除一个item
 t.update([10,37,42])                                # 利用[......]更新s集合
x in s,  x not in s                                  # 集合中是否存在某个值
s.issubset(t)   s.issuperset(t)   s.copy()  s.discard(x)  s.clear()
{x**2 for x in [1, 2, 3, 4]}                         # 集合解析，结果：{16, 1, 4, 9}
{x for x in 'spam'}                                  # 集合解析，结果：{'a', 'p', 's', 'm'}

字符串类型

字符串有2类,共4种表示方法

由一对单引号或双引号表示，仅表示单行字符串
"请输入带有符号的温度值: "或者 'C‘
由一对三单引号或三双引号表示，可表示多行字符串
‘’’ Python
语言 ‘’’
字符串类型的表示

在这里插入图片描述

字符串的使用

索引：返回字符串中单个字符 <字符串>[M]
切片：返回字符串中一段字符子串 <字符串>[M: N]
<字符串>[M: N: K]，根据步长K对字符串切片
转义符 \ （1）转义符表达特定字符的本意
" 这里有个双引号(")" 结果为这里有个双引号(")

转义符形成一些组合，表达一些不可打印的含义
"\b"回退 "\n"换行(光标移动到下行首) “\r” 回车(光标移动到本行首)

在这里插入图片描述

字符串的处理方法

在这里插入图片描述

“”"
基于C语言的’print’模型，并且在大多数的现有的语言中使用。
通用结构：%[(name)][flag][width].[precision]typecode
“”"
“this is %d %s bird” % (1, ‘dead’) # 一般的格式化表达式
“%s—%s—%s” % (42, 3.14, [1, 2, 3]) # 字符串输出：‘42—3.14—[1, 2, 3]’
“%d…%6d…%-6d…%06d” % (1234, 1234, 1234, 1234) # 对齐方式及填充：“1234… 1234…1234 …001234”
x = 1.23456789
“%e | %f | %g” % (x, x, x) # 对齐方式：“1.234568e+00 | 1.234568 | 1.23457”
“%6.2f*%-6.2f*%06.2f*%+6.2f” % (x, x, x, x) # 对齐方式：’ 1.23*1.23 001.23 +1.23’
“%(name1)d—%(name2)s” % {“name1”:23, “name2”:“value2”} # 基于字典的格式化表达式
“%(name)s is %(age)d” % vars() # vars()函数调用返回一个字典，包含了所有本函数调用时存在的变量

普通调用

“{0}, {1} and {2}”.format(‘spam’, ‘ham’, ‘eggs’) # 基于位置的调用
“{motto} and {pork}”.format(motto = ‘spam’, pork = ‘ham’) # 基于Key的调用
“{motto} and {0}”.format(ham, motto = ‘spam’) # 混合调用

添加键属性偏移量 (import sys)

“my {1[spam]} runs {0.platform}”.format(sys, {‘spam’:‘laptop’}) # 基于位置的键和属性
“{config[spam]} {sys.platform}”.format(sys = sys, config = {‘spam’:‘laptop’}) # 基于Key的键和属性
“first = {0[0]}, second = {0[1]}”.format([‘A’, ‘B’, ‘C’]) # 基于位置的偏移量

具体格式化

“{0:e}, {1:.3e}, {2:g}”.format(3.14159, 3.14159, 3.14159) # 输出’3.141590e+00, 3.142e+00, 3.14159’
“{fieldname:format_spec}”.format(…)

说明:

“”"
fieldname是指定参数的一个数字或关键字, 后边可跟可选的".name"或"[index]“成分引用
format_spec ::= [[fill]align][sign][#][0][width][,][.precision][type]
fill ::= #填充字符
align ::= “<” | “>” | “=” | “^” #对齐方式
sign ::= “+” | “-” | " " #符号说明
width ::= integer #字符串宽度
precision ::= integer #浮点数精度
type ::= “b” | “c” | “d” | “e” | “E” | “f” | “F” | “g” | “G” | “n” | “o” | “s” | “x” | “X” | “%”
“””
例子:
‘={0:10} = {1:10}’.format(‘spam’, 123.456) # 输出’=spam = 123.456’
‘={0:>10}=’.format(‘test’) # 输出’= test=’
‘={0:<10}=’.format(‘test’) # 输出’=test =’
‘={0:^10}=’.format(‘test’) # 输出’= test =’
‘{0:X}, {1:o}, {2:b}’.format(255, 255, 255) # 输出’FF, 377, 11111111’
‘My name is {0:{1}}.’.format(‘Fred’, 8) # 输出’My name is Fred .’ 动态指定参数

定义函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
我们以自定义一个求绝对值的my_abs函数为例：
print(my_abs(-99))
Run
请自行测试并调用my_abs看看返回结果是否正确。
请注意，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。
如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return。
在Python交互环境中定义函数时，注意Python会出现…的提示。函数定义结束后需要按两次回车重新回到>>>提示符下：
Command Prompt - python

def my_abs(x):
… if x >= 0:
… return x
… else:
… return -x
…

my_abs(-9)
9

_
如果你已经把my_abs()的函数定义保存为abstest.py文件了，那么，可以在该文件的当前目录下启动Python解释器，用from abstest import my_abs来导入my_abs()函数，注意abstest是文件名（不含.py扩展名）
Command Prompt - python
x

from abstest import my_abs
my_abs(-9)
9

空函数
如果想定义一个什么事也不做的空函数，可以用pass语句：
def nop():
pass
pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。
pass还可以用在其他语句里，比如：
if age >= 18:
pass
缺少了pass，代码运行就会有语法错误。
参数检查
调用函数时，如果参数个数不对，Python解释器会自动检查出来，并抛出TypeError：

my_abs(1, 2)
Traceback (most recent call last):
File “”, line 1, in
TypeError: my_abs() takes 1 positional argument but 2 were given
但是如果参数类型不对，Python解释器就无法帮我们检查。试试my_abs和内置函数abs的差别：

my_abs(‘A’)
Traceback (most recent call last):
File “”, line 1, in
File “”, line 2, in my_abs
TypeError: unorderable types: str() >= int()

abs(‘A’)
Traceback (most recent call last):
File “”, line 1, in
TypeError: bad operand type for abs(): ‘str’
当传入了不恰当的参数时，内置函数abs会检查出参数错误，而我们定义的my_abs没有参数检查，会导致if语句出错，出错信息和abs不一样。所以，这个函数定义不够完善。
让我们修改一下my_abs的定义，对参数类型做检查，只允许整数和浮点数类型的参数。数据类型检查可以用内置函数isinstance()实现：
def my_abs(x):
if not isinstance(x, (int, float)):
raise TypeError(‘bad operand type’)
if x >= 0:
return x
else:
return -x
添加了参数检查后，如果传入错误的参数类型，函数就可以抛出一个错误：

my_abs(‘A’)
Traceback (most recent call last):
File “”, line 1, in
File “”, line 3, in my_abs
TypeError: bad operand type
错误和异常处理将在后续讲到。
返回多个值
函数可以返回多个值吗？答案是肯定的。
比如在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的坐标：
import math

def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
import math语句表示导入math包，并允许后续代码引用math包里的sin、cos等函数。
然后，我们就可以同时获得返回值：

x, y = move(100, 100, 60, math.pi / 6)
print(x, y)
151.96152422706632 70.0
但其实这只是一种假象，Python函数返回的仍然是单一值：

r = move(100, 100, 60, math.pi / 6)
print®
(151.96152422706632, 70.0)
原来返回值是一个tuple！但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。
小结
定义函数时，需要确定函数名和参数个数；
如果有必要，可以先对参数的数据类型做检查；
函数体内部可以用return随时返回函数结果；
函数执行完毕也没有return语句时，自动return None。
函数可以同时返回多个值，但其实就是一个tuple。

局部变量和全局变量

一个程序中的变量包括两类：全局变量和局部变量。

•全局变量指在函数之外定义的变量，一般没有缩进，在程序执行全过程有效。

•局部变量指在函数内部使用的变量，仅在函数内部有效，当函数退出时变量将不存在。
规则1: 局部变量和全局变量是不同变量
规则2: 局部变量为组合数据类型且未创建新变量，等同于全局变量
总结：
基本数据类型，无论是否重名，局部变量与全局变量不同

可以通过global保留字在函数内部声明全局变量

组合数据类型，如果局部变量未真实创建，则是全局变量

lambda函数

python 使用 lambda 来创建匿名函数，不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式，函数体比 def 简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
在这里插入图片描述

递归的定义

函数作为一种代码封装，可以被其他程序调用，当然，也可以被函数内部代码调用。这种函数定义中调用函数自身的方式称为递归

! 递归在数学和计算机应用上非常强大，能够非常简洁的解决重要问题。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。可以试试fact(1000)：

fact(1000)
Traceback (most recent call last):
File “”, line 1, in
File “”, line 4, in fact
…
File “”, line 4, in fact
RuntimeError: maximum recursion depth exceeded in comparison
解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。
尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。
上面的fact(n)函数由于return n * fact(n - 1)引入了乘法表达式，所以就不是尾递归了。要改成尾递归方式，需要多一点代码，主要是要把每一步的乘积传入到递归函数中：
def fact(n):
return fact_iter(n, 1)

def fact_iter(num, product):
if num == 1:
return product
return fact_iter(num - 1, num * product)
可以看到，return fact_iter(num - 1, num * product)仅返回递归函数本身，num - 1和num * product在函数调用前就会被计算，不影响函数调用。
fact(5)对应的fact_iter(5, 1)的调用如下：
===> fact_iter(5, 1)
===> fact_iter(4, 5)
===> fact_iter(3, 20)
===> fact_iter(2, 60)
===> fact_iter(1, 120)
===> 120
尾递归调用时，如果做了优化，栈不会增长，因此，无论多少次调用也不会导致栈溢出。
遗憾的是，大多数编程语言没有针对尾递归做优化，Python解释器也没有做优化，所以，即使把上面的fact(n)函数改成尾递归方式，也会导致栈溢出。
小结
使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。
针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。
Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题

使用模块

Python本身就内置了很多非常有用的模块，只要安装完毕，这些模块就可以立刻使用。
我们以内建的sys模块为例，编写一个hello的模块：

’ a test module ’

author = ‘Michael Liao’

import sys

def test():
args = sys.argv
if len(args)==1:
print(‘Hello, world!’)
elif len(args)==2:
print(‘Hello, %s!’ % args[1])
else:
print(‘Too many arguments!’)

if name’main’:
test()
第1行和第2行是标准注释，第1行注释可以让这个hello.py文件直接在Unix/Linux/Mac上运行，第2行注释表示.py文件本身使用标准UTF-8编码；
第4行是一个字符串，表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释；
第6行使用__author__变量把作者写进去，这样当你公开源代码后别人就可以瞻仰你的大名；
以上就是Python模块的标准文件模板，当然也可以全部删掉不写，但是，按标准办事肯定没错。
后面开始就是真正的代码部分。
你可能注意到了，使用sys模块的第一步，就是导入该模块：
import sys
导入sys模块后，我们就有了变量sys指向该模块，利用sys这个变量，就可以访问sys模块的所有功能。
sys模块有一个argv变量，用list存储了命令行的所有参数。argv至少有一个元素，因为第一个参数永远是该.py文件的名称，例如：
运行python3 hello.py获得的sys.argv就是[‘hello.py’]；
运行python3 hello.py Michael获得的sys.argv就是[‘hello.py’, 'Michael]。
最后，注意到这两行代码：
if name’main’:
test()
当我们在命令行运行hello模块文件时，Python解释器把一个特殊变量__name__置为__main__，而如果在其他地方导入该hello模块时，if判断将失败，因此，这种if测试可以让一个模块通过命令行运行时执行一些额外的代码，最常见的就是运行测试。
我们可以用命令行运行hello.py看看效果：
$ python3 hello.py
Hello, world!
$ python hello.py Michael
Hello, Michael!
如果启动Python交互环境，再导入hello模块：
$ python3
Python 3.4.3 (v3.4.3:9b73f1c3e601, Feb 23 2015, 02:52:03)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type “help”, “copyright”, “credits” or “license” for more information.

import hello

导入时，没有打印Hello, word!，因为没有执行test()函数。
调用hello.test()时，才能打印出Hello, word!：

hello.test()
Hello, world!
作用域
在一个模块中，我们可能会定义很多函数和变量，但有的函数和变量我们希望给别人使用，有的函数和变量我们希望仅仅在模块内部使用。在Python中，是通过_前缀来实现的。
正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等；
类似__xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途，比如上面的__author__，__name__就是特殊变量，hello模块定义的文档注释也可以用特殊变量__doc__访问，我们自己的变量一般不要用这种变量名；
类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等；
之所以我们说，private函数和变量“不应该”被直接引用，而不是“不能”被直接引用，是因为Python并没有一种方法可以完全限制访问private函数或变量，但是，从编程习惯上不应该引用private函数或变量。
private函数或变量不应该被别人引用，那它们有什么用呢？请看例子：
def _private_1(name):
return ‘Hello, %s’ % name

def _private_2(name):
return ‘Hi, %s’ % name

def greeting(name):
if len(name) > 3:
return _private_1(name)
else:
return _private_2(name)
我们在模块里公开greeting()函数，而把内部逻辑用private函数隐藏起来了，这样，调用greeting()函数不用关心内部的private函数细节，这也是一种非常有用的代码封装和抽象的方法，即：
外部不需要引用的函数全部定义成private，只有外部需要引用的函数才定义为public。

库的安装方法

方法1(主要方法): 使用pip命令
方法2: 集成安装方法
方法3: 文件安装方法

文件处理

文件的打开关闭
文件处理的步骤: 打开 - 操作 - 关闭

rng

file_object = open(“filename”, “openmode”)
… #操作
file_object.close()
with open(“filename”, “openmode”) as file_object:
… #操作
filename：文件路径及名称，当与源文件同目录是可省略路径
openmode：打开模式，文本or二进制，读or写
打开模式
openmode details
‘r’ 只读模式，默认值，如果文件不存在，返回FileNotFoundError
‘w’ 覆盖写模式，文件不存在则创建，存在则完全覆盖
‘x’ 创建写模式，文件不存在则创建，存在则返回FileExistsError
‘a’ 追加写模式，文件不存在则创建，存在则在文件最后追加内容
‘b’ 二进制文件模式
‘t’ 文本文件模式，默认值
‘+’ 与r/w/x/a一同使用，在原功能基础上增加同时读写功能
文件内容的读取
operation details
f.read(size=-1) 读入全部内容，如果给出参数，读入前size长度
f.readline(size=-1) 读入一行内容，如果给出参数，读入该行前size长度
f.readlines(hint=-1) 读入文件所有行，以每行为元素形成列表，如果给出参数，读入前hint行
f.write(s) 向文件写入一个字符串或字节流
f.writelines(lines) 将一个元素全为字符串的列表写入文件
f.seek(offset) 改变当前文件操作指针的位置，offset含义如下:0 – 文件开头； 1 – 当前位置； 2 – 文件结尾
文件的全文本操作
一次读入，统一处理

fo = open(fname,“r”)
txt = fo.read()
…#对全文txt进行处理
fo.close()
按数量读入，逐步处理

fo = open(fname,“r”)
txt = fo.read(2)
while txt != “”:
#对txt进行处理
txt = fo.read(2)
fo.close()
文件的逐行操作
一次读入，分行处理

fo = open(fname,“r”)
for line in fo.readlines():
print(line)
fo.close()
分行读入，逐行处理

fo = open(fname,“r”)
for line in fo:
print(line)
fo.close()
数据文件的写入
fo = open(“output.txt”,“w+”)
ls = [“China”, “France”, “America”]
fo.writelines(ls)
fo.seek(0)
for line in fo:
print(line)
fo.close()
使用json模块
.json 文件中存储的数据结构为列表或字典。

json.dump() 用来存储数据到json文件中，接受两个实参：要存储的数据和用于存储数据的文件对象

import json

numbers = [1, 2, 3, 4, 5, 6]
filename = ‘number.json’
with open(filename, ‘w’) as f_obj:
json.dump(numbers, f_obj)
则number.json文件中的内容的格式与python中一样，为列表[1, 2, 3, 4, 5, 6]

json.load() 用来从json文件读取数据到内存中

import json

filename = ‘number.json’
with open(filename, ‘r’) as f_obj:
numbers = json.load(f_obj)
则numbers为列表[1, 2, 3, 4, 5, 6]

转载于：<https://www.cnblogs.com/tzhao/p/9855232.html >

错误和异常

语法错误

从软件方面来说，错误是语法或是逻辑上的。
语法错误指示软件的结构上有错误，导致不能被解释器解释或编译器无法编译。这些错误必须在程序执行前纠正。

逻辑错误可能是由于不完整或是不合法的输入所致；还可能是逻辑无法生成，或是输出结果需要的过程无法执行。这些错误通常分别被称为域错误和范围错误。

异常

程序出现了错误而在正常控制流以外采取的行为。

分为两个阶段:
首先是引起异常发生的错误
然后是检测和采取可能的措施

引起异常发生的错误

在发生了一个异常条件(有时候也叫做例外的条件)后，只要检测到错误并且意识到异常条件，解释器会引发一个异常。
引发也可以叫做触发或者生成，解释器通过它通知当前控制流有错误发生。
异常就是错误发生的信号，当前流将被打断，用来处理这个错误并采取相应的操作。

检测和采取可能的措施

异常引发后，可以调用很多不同的操作，可以忽略错误(记录错误但不采取任何措施, 采取补救措施后终止程序)，或是减轻问题的影响后设法继续执行程序。
异常可以通过 try 语句来检测。
任何在 try 语句块里的代码都会被监测，检查有无异常发生。
try-except 语句
在这里插入图片描述
多个except 语句

try …except…else 语句，当没有异常发生时，else中的语句将会被执行

try …except…finally
无论异常是否发生，在程序结束前，finally中的语句都会被执行

raise
要引发异常，可以使用raise语句，并将一个类（必须是Exception子类）
或者实例作为参数。