Python入门从这里开始

---

1、变量

在Python中使用变量时，需要遵守一些规则和指南。违反这些规则将引发错误，而指南旨在让你编写的代码更容易阅读和理解。请务必牢记下述有关变量的规则。

• 变量名只能包含字母、数字和下划线。变量名可以字母或下划线打头，但不能以数字打头，例如，可将变量命名为message_1，但不能将其命名为1_message。
• 变量名不能包含空格，但可使用下划线来分隔其中的单词。例如，变量名greeting_message可行，但变量名greeting message会引发错误。
• 不要将Python关键字和函数名用作变量名，即不要使用Python保留用于特殊用途的单词，如print (请参见附录A.4)。
• 变量名应既简短又具有描述性。例如，name比n好，student_name比s_n好，name_length比length_of_persons_name好。
• 慎用小写字母l和大写字母O，因为它们可能被人错看成数字1和0。

2、字符串

2.1、修改字符串的大小写

name = "nsh is a good boy" 

print(name.title())

结果

Nsh Is A Good Boy

 

name = "nsh Is a Good boy"  
print(name.title()) 
print(name.lower()) 
print(name.upper())

结果：

Nsh Is A Good Boy 
nsh is a good boy 
NSH IS A GOOD BOY

2.2、合并(拼接)字符串

name = "Good boy!"  
hello = "hello," 
print(hello + name)

结果：

hello,Good boy!

2.3、使用制表符或换行符来添加空白

 

str = "Languages:\n\tPython\n\tC\n\tJavaScript" 
print(str)

结果：

Languages: 
    Python 
    C 
    JavaScript

2.4、删除空白

2.4.1、删除末尾空格

rstrip()方法：删除字符串末尾空格，不会改变原有变量

str = "i am a good boy!  " 
str2 = "i am a good boy!" 
print(str.__eq__(str2)) 
print(str.rstrip().__eq__(str2))

结果：

False 
True

 

2.4.2、删除字符串开头空格

lstrip方法：删除字符串开头空格，不会改变原有变量

str = "  i am a good boy!" 
str2 = "i am a good boy!" 
str3 = "  i am a good boy!  " 
print(str.__eq__(str2)) 
print(str.lstrip().__eq__(str2)) 
print(str3.strip().__eq__(str2))

结果：

False 
True 
True

2.4.3、删除字符串两端空格

strip方法：删除字符串两端空格，不会改变变量。

代码见2.4.2

3、数字

3.1、整数

3.2、浮点数

3.3、str() 避免类型错误

age = 23 
message = "Happy " + age + "rd Birthday!" 
print(message)

结果：

Traceback (most recent call last): 
    File "/Users/nsh/pythonWork/study/__main__.py", line 9, in <module> 
    message = "Happy " + age + "rd Birthday!" 
TypeError: can only concatenate str (not "int") to str

正确：

age = 23 
message = "Happy " + str(age) + "rd Birthday!" 
print(message)

结果：

Happy 23rd Birthday!

4、注释

#开头的行是注释

（"""或'''） 三个双引号或者三个单引号为段注释

5、列表

5.1、创建列表

5.1.1、创建字符串列表

arr = ["a","bc","nsh","hah"]

5.1.2、创建数值列表

5.1.2.1、使用range()函数创建

函数range() 让你能够轻松地生成一系列的数字。不是列表,要创建数字列表，可使用函数list() 将range() 的结果直接转换为列表。函数range() 时，还可指定步长

num = range(1,6) 
print(num) 
for n in num: 
    print(n) 

print("list --------") 
num2 = list(range(1,6)) 
print(num2)

结果：

range(1, 6)
1 
2 
3 
4 
5 
list -------- 
[1, 2, 3, 4, 5]

5.2、访问列表

5.2.1、访问某个位置的元素

arr = ["a","bc","nsh","hah"] print(arr[0])

5.2.2、遍历列表

cars = ['bmw', 'audi', 'toyota', 'subaru'] 
for car in cars: 
    print(car)

5.3、修改、添加、删除元素

5.3.1、修改元素

arr = ["a","bc","nsh","hah"] 
print(arr) 
arr[0]="b" 
print(arr)

结果：

['a', 'bc', 'nsh', 'hah']
['b', 'bc', 'nsh', 'hah']

5.3.2、添加元素

arr = ["a","bc","nsh","hah"] 
print(arr) 
arr.append("boy") 
print(arr)

结果：

['a', 'bc', 'nsh', 'hah'] 
['a', 'bc', 'nsh', 'hah', 'boy']

5.3.3、插入元素

insert() 可在列表的任何位置添加新元素,这种操作将列表中既有的每个元素都右 移一个位置

arr = ["i","am","a","good","boy"] 
print(arr) 
arr.insert(0,"hello") 
print(arr)

结果：

['i', 'am', 'a', 'good', 'boy'] 
['hello', 'i', 'am', 'a', 'good', 'boy']

5.3.4、删除元素

5.3.4.1、使用del 删除元素

arr = ["i","am","a","good","boy"] 
print(arr) 
arr.insert(0,"hello")
print(arr) 
del arr[0] 
print(arr)

结果：

['i', 'am', 'a', 'good', 'boy'] 
['hello', 'i', 'am', 'a', 'good', 'boy'] 
['i', 'am', 'a', 'good', 'boy']

5.3.4.2、使用pop删除元素

pop() 可删除并返回列表末尾的元素

arr = ["i","am","a","good","boy"] 
print(arr) 
arr.insert(0,"hello") 
print(arr) 
str = arr.pop() 
print(str) 
print(arr)

结果

['i', 'am', 'a', 'good', 'boy'] 
['hello', 'i', 'am', 'a', 'good', 'boy'] 
boy 
['hello', 'i', 'am', 'a', 'good']

pop() 可删除并返回列表中某个位置的元素

arr = ["i","am","a","good","boy"] 
print(arr) 
arr.insert(0,"hello") 
print(arr) 
str = arr.pop(0) 
print(str) 
print(arr)

结果：

['i', 'am', 'a', 'good', 'boy'] 
['hello', 'i', 'am', 'a', 'good', 'boy']
 hello 
['i', 'am', 'a', 'good', 'boy']

5.3.4.3、根据值删除元素

有时候，你不知道要从列表中删除的值所处的位置。如果你只知道要删除的元素的值，可使用方法remove() 。方法remove() 只删除第一个指定的值。

arr = ["boy","i","am","a","good","boy"] 
print(arr) 
arr.remove("boy") 
print(arr)

结果：

['boy', 'i', 'am', 'a', 'good', 'boy'] 
['i', 'am', 'a', 'good', 'boy']

5.4、排序

sort() 对列表进行永久性排序

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

结果

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

sorted() 对列表进行临时排序

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

结果：

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

5.5、列表反转

要反转列表元素的排列顺序，可使用方法reverse()，并非排序，只是将列表的元素反转，永久性的

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

结果：

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

5.6、列表的长度

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

结果：

['bmw', 'audi', 'toyota', 'subaru'] 
4

5.7、数值列表的简单统计计算

num = [4,6,2,8] 
print("max:"+ str(max(num))) 
print("min:"+str(min(num))) 
print("sum:"+str(sum(num)))

结果：

max:8 
min:2 
sum:20

5.8、列表解析

列表解析 将for 循环和创建新元素的代码合并成一行，并自动 附加新元素。

num = [v for v in range(1,5)] 
print(num) 
num2 = [v ** 2 for v in range(1,5)] 
print(num2)

结果：

[1, 2, 3, 4] 
[1, 4, 9, 16]

要使用这种语法，首先指定一个描述性的列表名，如squares ;然后，指定一个左方括号，并定义一个表达式，用于生成你要存储到列表中的值。在这个示例中，表达式 为value**2，它计算平方值。接下来，编写一个for循环，用于给表达式提供值，再加上右方括号。在这个示例中，for循环为for value in range(1,11)，它将值 1~10提供给表达式value**2 。请注意，这里的for 语句末尾没有冒号。

5.9、列表切片

处理列表的部分元素——Python称之为切片，要创建切片，可指定要使用的第一个元素和最后一个元素的索引。切片会创建一个全新的列表

num = [2,5,8,2,1,6,7] 
num_new = num[0:4] 
print(num) 
print(num_new) 
num[0] = 1 
print(num) 
print(num_new)

结果：

[2, 5, 8, 2, 1, 6, 7] 
[2, 5, 8, 2] 
[1, 5, 8, 2, 1, 6, 7] 
[2, 5, 8, 2]

如果省略第一个索引，Python将自动从列表开头开始；如果省略终止索引，终止于列表末尾。

5.9.1、遍历切片

num = [2,5,8,2,1,6,7] 
num_new = num[0:4] 
print(num) 
print(num_new) 
for n in num_new: 
    print(n)

结果：

[2, 5, 8, 2, 1, 6, 7] 
[2, 5, 8, 2] 
2 
5 
8 
2

5.10、复制列表

通过切片实现

num = [2,5,8,2,1,6,7] 
num_copy = num[:] 
print(num) 
print(num_copy) 
print("modify data num[0] = 1") 
num[0]=1 
print(num) 
print(num_copy)

结果：

[2, 5, 8, 2, 1, 6, 7] 
[2, 5, 8, 2, 1, 6, 7] 
modify data num[0] = 1 
[1, 5, 8, 2, 1, 6, 7] 
[2, 5, 8, 2, 1, 6, 7]

6、元组（不可变列表）

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的，这对处理网站的用户列表或游戏中的角色列表至关重要。然而，有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的 ，而不可变的列表被称为元组 。

6.1、定义元组

元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。

num = (2,5) 
print(num[0]) 
num[0] = 3 
print(num[0])

结果：

Traceback (most recent call last): 2 
File "/Users/nsh/pythonWork/study/__main__.py", line 12, 
    in <module> num[0] = 3 
TypeError: 'tuple' object does not support item assignment

6.2、遍历元组

和列表一样

6.3、修改元组变量

元组内元素不可变，但是元素变量是可变的

num = (2,5,6)
print(num) 
num = (4,5,7) 
print(num)

结果：

(2, 5, 6) 
(4, 5, 7)

7、if 语句

7.1、检查多个条件

7.1.1、and 检查多个条件

7.1.2、or 检查多个条件

7.2、列表包含

cars = ['bmw', 'audi', 'toyota', 'subaru'] 
if "bmw" in cars: 
    print("包含") 
else: 
    print("不包含") 

if "nsh" not in cars: 
    print("不包含") 
else: 
    print("包含")

结果：

包含 
不包含

7.3、列表不包含

见7.2列表包含

8、字典

8.1、创建字典

dicts = {"name":"nsh","age":25} 
print(dicts)

8.2、访问字典

8.2.1、访问单个键值对

两种访问字典的方式，用法类似Java的HashMap

dicts = {"name":"nsh","age":25} 
print(dicts.get("name")) 
print(dicts["name"])

结果：

nsh
nsh

8.2.2、遍历字典

dic={"name":"nsh","age":25,"score":98} 
for k,v in dic.items(): 
    print(k) 
    print(v)

结果：

name 
nsh 
age 
25 
score 
98

8.2.3、遍历字典所有键

dic={"name":"nsh","age":25,"score":98} 
for k in dic.keys(): 
    print(k)

结果：

name 
age 
score

8.2.4、遍历字典所有值

dic={"name":"nsh","age":25,"score":98} 
for v in dic.values(): 
    print(v)

结果：

nsh 
25 
98

8.3、添加、修改、删除字典值

8.3.1、添加字典值

dicts = {"name":"nsh","age":25} 
print(dicts) 
dicts["sex"]="men" //dicts.__setitem__("sex","men") 
print(dicts)

结果

{'name': 'nsh', 'age': 25} 
{'name': 'nsh', 'age': 25, 'sex': 'men'}

8.3.2、修改字典值

dicts = {"name":"nsh","age":25} 
    print(dicts) 
    dicts["sex"]="men" 
    print(dicts) 
    dicts['name']='杨贵妃'//dicts.__setitem__("name","杨贵妃") 
    print(dicts)

结果

{'name': 'nsh', 'age': 25} 
{'name': 'nsh', 'age': 25, 'sex': 'men'} 
{'name': '杨贵妃', 'age': 25, 'sex': 'men'}

8.3.3、删除字典值

dic={"name":"nsh","age":25} 
    print(dic) 
    del dic['name'] 
    print(dic)

结果：

{'name': 'nsh', 'age': 25} 
{'age': 25}

9、函数

9.1、函数定义

没什么好讲的，每个语言都一样

9.2、传递参数

9.2.1、位置实参

def test(a="0",b="0"): 
    print(a+b) 

test("1","2")//位置实参 
test("2","1")//位置实参 
test(a="1",b="2")//关键字实参 
test(b="2",a="1")//关键字实参 
test()

结果：

12 
21 
12 
12 
00

 

9.2.2、关键字实参

见9.2.1位置实参

9.2.3、传递任意数量的实参

有时候，你预先不知道函数需要接受多少个实参，好在Python允许函数从调用语句中收集任意数量的实参。

def test(*arr): 
    for ar in arr: 
        print(ar) 
    
test("a","b","dbsd")

结果：

a b dbsd

形参名*arr中的星号让Python创建一个名为arr 的空元组，并将收到的所有值都封装到这个元组中。函数体内的print 语句通过生成输出来证明Python能够处理 使用一个值调用函数的情形，也能处理使用三个值来调用函数的情形。它以类似的方式处理不同的调用，注意，Python将实参封装到一个元组中，即便函数只收到一个值也如此:

9.2.4、结合使用位置实参和任意数量实参

如果要让函数接受不同类型的实参，必须在函数定义中将接纳任意数量实参的形参放在最后。Python先匹配位置实参和关键字实参，再将余下的实参都收集到最后一个形参中。

def test(a,*arr): p
    rint(a) 
    print("__________") 
    for ar in arr: 
        print(ar) 

test("a","b","dbsd")

结果：

a 
__________ 
b 
dbsd

 

9.2.5、使用任意数量的关键字实参

有时候，需要接受任意数量的实参，但预先不知道传递给函数的会是什么样的信息。在这种情况下，可将函数编写成能够接受任意数量的键—值对——调用语句提供了多少就接 受多少。

def test(a,*arr,**dic): 
    print(a) 
    print("__________") 
    for ar in arr: 
        print(ar) 
    
    for k,v in dic.items(): 
        print("k:"+k) 
        print("v:"+v) 

test("a","abc","d",k1="v1",k2="v2")

结果：

a 
__________ 
abc 
d 
k:k1 
v:v1 
k:k2 
v:v2

9.3、函数存储在模块中

9.3.1、导入整个模块

Func.py

def func1(): 
    print("func1")

main.py

import Func 

def start(): 
    Func.func1() 

start()

只需编写一条import 语句并在其中指定模块名，就可在程序中使用该模块中的所有函数。如果你使用这种import 语句导入了名为module_name.py 的整个模块，就可使用下面的语法来使用其中任何一个函数:

module_name.function_name()

9.3.2、导入特定的函数

//导入方法的语法如下: 
from module_name import function_name 
//通过用逗号分隔函数名，可根据需要从模块中导入任意数量的函数: 
from module_name import function_0,function_1,function_2

9.3.3、使用as 给函数指定别名

如果要导入的函数的名称可能与程序中现有的名称冲突，或者函数的名称太长，可指定简短而独一无二的别名 ——函数的另一个名称，类似于外号。要给函数指定这种特殊外 号，需要在导入它时这样做。

from Func import func1 as f 

def start(): 
    f() 

start()

9.3.4、导入模块中的所有函数

from Func import * 

def start(): 
    func1() 

start()

10、类

10.1、创建和使用类

10.1.1、创建类

class Dog(object): 
    def __init__(self,name="",age=0,color=""): 
        self.__name = name 
        self.__age = age 
        self.color = color 

    def sit(self): 
        print(self.__name+" sit") 

    def roll_over(self): 
        print(self.__name+" roll over")

1. 方法__init__()

__init__() 是一个特殊的方法，每当你根据Dog 类创建新实例时，Python都会自动运行它。在这个方法的名称中，开头和末尾各有两个下划线，这是一种约定，旨在避免Python默认方法与普通方法发生名称冲突。

我们将方法__init__() 定义成了包含三个形参:self 、name 和age 。在这个方法的定义中，形参self 必不可少，还必须位于其他形参的前面。为何必须在方法定义中包 含形参self 呢?因为Python调用这个__init__() 方法来创建Dog 实例时，将自动传入实参self 。每个与类相关联的方法调用都自动传递实参self ，它是一个指向实例本身 的引用，让实例能够访问类中的属性和方法。我们创建Dog 实例时，Python将调用Dog 类的方法__init__() 。我们将通过实参向Dog() 传递名字和年龄;self 会自动传递，因此我们不需要传递它。每当我们根据Dog 类创建实例时，都只需给最后两个形参(name 和age )提供值。

10.1.2、创建实例

dog = Dog("tom",3,"white")

10.1.3、访问属性和方法

dog.color//访问属性 
dog.sit()//调用方法

10.2、继承

10.2.1、子类的方法 __init__()

class Car(): 
    def __init__(self,name="",color=""): 
        self.__name = name 
        self.__color = color 

class BMW(Car): 
    def __init__(self,name="",color="",price=0): 
        super().__init__(name,color) 
        self.__price = price 

if __name__=="__main__": 
    bmw = BMW("bmw", "red", 23) 
    pass

10.2.2、Python 2.7中的继承

在Python 2.7中，继承语法稍有不同

class Car(object): 
    def __init__(self,name="",color=""): 
        self.__name = name 
        self.__color = color 

class BMW(Car): 
    def __init__(self,name="",color="",price=0): 
        super(BMW,self).__init__(name,color) 
        self.__price = price 

if __name__=="__main__": 
    bmw = BMW("bmw", "red", 23) 
    pass

函数super() 需要两个实参:子类名和对象self 。为帮助Python将父类和子类关联起来，这些实参必不可少。另外，在Python 2.7中使用继承时，务必在定义父类时在括号内指 定object 。

10.2.3、子类定义自己的属性、方法

class Car(): 
    def __init__(self,name="",color=""): 
        self.__name = name 
        self.__color = color 
    
    def run(self): 
        print(self.__name+"car is run") 

class BMW(Car): 
    def __init__(self,name="",color="",price=0): 
        super().__init__(name,color) 
        self.__price = price //自己的属性 
    
    def getPrice(self): //自己的方法 
        return self.__price 

if __name__=="__main__": 
    bmw = BMW("bmw", "red", 23) 
    print(bmw.getPrice())

10.2.4、子类重写父类方法

class Car(): 
    def __init__(self,name="",color=""): 
        self.__name = name 
        self.__color = color 
    def run(self): 
        print(self.__name+"car is run") 

class BMW(Car): 
    def __init__(self,name="",color="",price=0): 
        super().__init__(name,color) 
        self.__price = price 

    def getPrice(self): 
        return self.__price 

    def run(self): 
        print("bmw is run") 

if __name__=="__main__": 
    bmw = BMW("bmw", "red", 23) 
    print(bmw.getPrice()) 
    bmw.run()

10.3、导入类

10.3.1、导入单个类

下面来创建一个只包含Car 类的模块。这让我们面临一个微妙的命名问题:在本章中，已经有一个名为car.py的文件，但这个模块也应命名为car.py，因为它包含表示汽车的代 码。我们将这样解决这个命名问题:将Car 类存储在一个名为car.py的模块中，该模块将覆盖前面使用的文件car.py。从现在开始，使用该模块的程序都必须使用更具体的文件 名，如my_car.py。下面是模块car.py，其中只包含Car 类的代码:

car.py

class Car(): 
    def __init__(self,name="",color=""): 
        self.__name = name 
        self.__color = color 
    def run(self): 
        print(self.__name+"car is run")

下面来创建另一个文件——my_car.py，在其中导入Car 类并创建其实例:

my_car.py

from car import Car 
my_new_car = Car('audi', 'red') 
my_new_car.run()

10.3.2、在一个模块中存储多个类

虽然同一个模块中的类之间应存在某种相关性，但可根据需要在一个模块中存储任意数量的类。类Battery 和ElectricCar 都可帮助模拟汽车，因此下面将它们都加入模块

car.py中:

class Car(): 
    def __init__(self,name="",color=""): 
        self.__name = name 
        self.__color = color 
    def run(self): 
        print(self.__name+"car is run") 

class BMW(Car): 
    def __init__(self,name="",color="",price=0): 
        super().__init__(name,color) 
        self.__price = price 

    def getPrice(self): 
        return self.__price 

    def run(self): 
        print("bmw is run")

my_car.py

from car import BMW 

my_bmw = BMW('bmw', 'red', 25) 
my_bmw.run()

10.3.3、从一个模块中导入多个类

可根据需要在程序文件中导入任意数量的类。如果我们要在同一个程序中创建普通汽车和电动汽车，就需要将Car 和ElectricCar 类都导入:

from car import BMW,Car 

my_bmw = BMW('bmw', 'red', 25) 
my_bmw.run()

10.3.4、导入整个模块

你还可以导入整个模块，再使用句点表示法访问需要的类。这种导入方法很简单，代码也易于阅读。由于创建类实例的代码都包含模块名，因此不会与当前文件使用的任何名称发生冲突。

import car 

my_bmw = car.BMW('bmw', 'red', 25) 
my_bmw.run()

10.3.5、导入模块中的所有类

from module_name import *

不推荐使用这种导入方式，其原因有二。首先，如果只要看一下文件开头的import 语句，就能清楚地知道程序使用了哪些类，将大有裨益;但这种导入方式没有明确地指出你 使用了模块中的哪些类。这种导入方式还可能引发名称方面的困惑。如果你不小心导入了一个与程序文件中其他东西同名的类，将引发难以诊断的错误。这里之所以介绍这种导 入方式，是因为虽然不推荐使用这种方式，但你可能会在别人编写的代码中见到它。

10.4、Python标准库

10.4.1、OrderedDict

字典让你能够将信息关联起来，但它们不记录你添加键—值对的顺序。要创建字典并记录其中的键—值对的添加顺序，可使用模块collections 中的OrderedDict 类。OrderedDict 实例的行为几乎与字典相同，区别只在于记录了键—值对的添加顺序。

11、文件和异常

11.1、从文件读取数据

11.1.1、读取整个文件

with open('test.txt') as f: 
    Str = f.read() 
    print(Str)

11.1.2、逐行读取文件

if __name__=="__main__": 
    with open('test.txt') as f: 
        for l in f: 
            print(l)

我们通过对文件对象执行循环来遍历文件中的每一行。我们打印每一行时，发现空白行更多了；为何会出现这些空白行呢?因为在这个文件中，每行的末尾都有一个看不见的换行符，而print 语句也会加上一个换行符，因此每行末尾都有两个换行符:一个来自文件，另一 个来自print 语句。要消除这些多余的空白行，可在print 语句中使用rstrip() :

if __name__=="__main__": 
    with open('test.txt') as f: 
        for l in f: 
            print(l.rstrip()) 

或 
if __name__=="__main__": 
    with open('test.txt') as f: 
        while True: 
            s = f.readline() 
            if s: 
                print(s) 
            else: 
                break

11.2、写入文件

11.2.1、写入空文件

if __name__=="__main__": 
    msg = "i love you" 
    with open('test.txt','w') as f:
         f.write(msg)

在这个示例中，调用open() 时提供了两个实参。第一个实参也是要打开的文件的名称;第二个实参('w' )告诉Python，我们要以写入模式 打开这个文件。打开文件 时，可指定读取模式 ('r' )、写入模式 ('w' )、附加模式 ('a' )或让你能够读取和写入文件的模式('r+' )。如果你省略了模式实参，Python将以默认的只读模式打 开文件。

如果你要写入的文件不存在，函数open() 将自动创建它。然而，以写入('w' )模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空 该文件。

函数write() 不会在你写入的文本末尾添加换行符，因此如果你写入多行时没有指定换行符，文件看起来可能不是你希望的那样:

11.3、异常

Python使用被称为异常 的特殊对象来管理程序执行期间发生的错误。每当发生让Python不知所措的错误时，它都会创建一个异常对象。如果你编写了处理该异常的代码，程序将继续运行;如果你未对异常进行处理，程序将停止，并显示一个traceback，其中包含有关异常的报告。

异常是使用try-except 代码块处理的。try-except 代码块让Python执行指定的操作，同时告诉Python发生异常时怎么办。使用了try-except 代码块时，即便出现异常，程序也将继续运行:显示你编写的友好的错误消息，而不是令用户迷惑的traceback。

11.3.1、使用try-except 代码块

if __name__=="__main__": 
    try: 
        a = 1/1 
    except Exception as e: 
        print("error") 
    else: 
        print("o") 
    finally: 
        print("f")

通过将可能引发错误的代码放在try-except 代码块中，可提高这个程序抵御错误的能力。错误是执行除法运算的代码行导致的，因此我们需要将它放到try-except 代码块中。这个示例还包含一个else 代码块;依赖于try 代码块成功执行的代码都应放到else 代码块中；finally代码块无论try成功与否都会执行。