Python3 知识点总结精简版

---

一、基础语法

• 标识符
• python保留字
• 注释 多行注释可以用多个 # 号，还有 ‘’’ 和 “”"：
• 行与缩进
• 多行语句 反斜杠(\)
• 数字类型 int, bool, float, complex(复数)
• 字符串
• python中单引号和双引号使用完全相同。
• 使用三引号(’’'或""")可以指定一个多行字符串。
• 转义符 ‘’
• 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示，并不是换行。
• 按字面意义级联字符串，如"this " "is " "string"会被自动转换为this is string。
• 字符串可以用 + 运算符连接在一起，用 * 运算符重复。
• Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
• Python中的字符串不能改变。
• Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。
• 字符串的截取的语法格式如下：变量[头下标:尾下标:步长]
• 空行
• 函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
• 空行与代码缩进不同，空行并不是Python语法的一部分。书写时不插入空行，Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。
• 记住：空行也是程序代码的一部分。
• 同一行显示多条语句 Python可以在同一行中使用多条语句，语句之间使用分号(;)分割。
• print 输出 print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""
• import 与 from…import
• 将整个模块(somemodule)导入，格式为： import somemodule
• 从某个模块中导入某个函数,格式为： from somemodule import somefunction
• 将某个模块中的全部函数导入，格式为： from somemodule import *

---

二、基本数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

• 多个变量赋值
  a = b = c = 1
  a, b, c = 1, 2, “runoob”

• 标准数据类型
  Python3 中有六个标准的数据类型：

  • Number（数字）
  • String（字符串）
  • Tuple（元组）
  • List（列表）
  • Set（集合）
  • Dictionary（字典）

• Python3 的六个标准数据类型中：
  不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
  可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

• Number数值运算

  >>> 5 + 4  # 加法
  9
  >>> 4.3 - 2 # 减法
  2.3
  >>> 3 * 7  # 乘法
  21
  >>> 2 / 4  # 除法，得到一个浮点数
  0.5
  >>> 2 // 4 # 除法，得到一个整数
  0
  >>> 17 % 3 # 取余
  2
  >>> 2 ** 5 # 乘方
  32
  

  1、Python可以同时为多个变量赋值，如a, b = 1, 2。
  2、一个变量可以通过赋值指向不同类型的对象。
  3、数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。
  4、在混合计算时，Python会把整型转换成为浮点数。
  5、Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

• String（字符串）
  字符串的截取的语法格式如下：

  变量[头下标:尾下标]

  索引值以 0 为开始值，-1 为从末尾的开始位置。
  
  加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数。

• Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

  >>> print('Ru\noob')
  Ru
  oob
  >>> print(r'Ru\noob')
  Ru\noob
  >>>
  

  另外，反斜杠()可以作为续行符，表示下一行是上一行的延续。也可以使用 “”"…""" 或者 ‘’’…’’’ 跨越多行。

  注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串。

  与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm’会导致错误。

• List（列表）
  List（列表） 是 Python 中使用最频繁的数据类型。

  1、List写在方括号之间，元素用逗号隔开。
  2、和字符串一样，list可以被索引和切片。
  3、List可以使用+操作符进行拼接。
  4、List中的元素是可以改变的。

  Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
  
  如果第三个参数为负数表示逆向读取，以下实例用于翻转字符串：

  # 第三个参数为步长，-1 表示逆向
  inputWords=inputWords[-1::-1]
  

• Tuple（元组）
  元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
  元组中的元素类型也可以不相同

  tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
  tinytuple = (123, 'runoob')
  
  print (tuple)             # 输出完整元组
  print (tuple[0])          # 输出元组的第一个元素
  print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
  print (tuple[2:])         # 输出从第三个元素开始的所有元素
  print (tinytuple * 2)     # 输出两次元组
  print (tuple + tinytuple) # 连接元组
  

  以上实例输出结果：

  ('abcd', 786, 2.23, 'runoob', 70.2)
  abcd
  (786, 2.23)
  (2.23, 'runoob', 70.2)
  (123, 'runoob', 123, 'runoob')
  ('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')
  

  虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

  构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

  tup1 = ()    # 空元组
  tup2 = (20,) # 一个元素，需要在元素后添加逗号
  

• Set（集合）
  集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

  基本功能是进行成员关系测试和删除重复元素。

  可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

  # set可以进行集合运算
  a = set('abracadabra')
  b = set('alacazam')
  
  print(a)
  
  print(a - b)     # a 和 b 的差集
  
  print(a | b)     # a 和 b 的并集
  
  print(a & b)     # a 和 b 的交集
  
  print(a ^ b)     # a 和 b 中不同时存在的元素
  

  {'Zhihu', 'Baidu', 'Taobao', 'Runoob', 'Google', 'Facebook'}
  Runoob 在集合中
  {'b', 'c', 'a', 'r', 'd'}
  {'r', 'b', 'd'}
  {'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
  {'c', 'a'}
  {'z', 'b', 'm', 'r', 'l', 'd'}
  

• Dictionary（字典）
  列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

  字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

  键(key)必须使用不可变类型。

  在同一个字典中，键(key)必须是唯一的。

  构造函数 dict() 可以直接从键值对序列中构建字典如下：

  >>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
  {'Runoob': 1, 'Google': 2, 'Taobao': 3}
  >>> {x: x**2 for x in (2, 4, 6)}
  {2: 4, 4: 16, 6: 36}
  >>> dict(Runoob=1, Google=2, Taobao=3)
  {'Runoob': 1, 'Google': 2, 'Taobao': 3}
  >>>
  

  另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。

  注意：
  1、字典是一种映射类型，它的元素是键值对。
  2、字典的关键字必须为不可变类型，且不能重复。
  3、创建空字典使用 { }。

• Python数据类型转换
  

• Python3 运算符
  Python 语言支持以下类型的运算符:

  • 算术运算符
  • 比较（关系）运算符
  • 赋值运算符
  • 逻辑运算符
  • 位运算符
  • 成员运算符
  • 身份运算符
  • 运算符优先级

• Python逻辑运算符
  

• Python成员运算符
  

  if ( a in list ):
     print ("1 - 变量 a 在给定的列表中 list 中")
  else:
     print ("1 - 变量 a 不在给定的列表中 list 中")
   
  if ( b not in list ):
     print ("2 - 变量 b 不在给定的列表中 list 中")
  else:
     print ("2 - 变量 b 在给定的列表中 list 中")
  

• Python身份运算符
  身份运算符用于比较两个对象的存储单元
  
  is 与 == 区别：
  is 用于判断两个变量引用对象是否为同一个，== 用于判断引用变量的值是否相等。

• Python字符串格式化
  Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

  print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
  

  我叫 小明 今年 10 岁!
  

• f-string
  f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。
  之前我们习惯用百分号 (%):

  >>> name = 'Runoob'
  >>> 'Hello %s' % name
  'Hello Runoob'
  

  f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去，实例如下：

  >>> name = 'Runoob'
  >>> f'Hello {name}'  # 替换变量
  'Hello Runoob'
  >>> f'{1+2}'         # 使用表达式
  '3'
  
  >>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
  >>> f'{w["name"]}: {w["url"]}'
  'Runoob: www.runoob.com'
  

  用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。

  在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果：

  >>> x = 1
  >>> print(f'{x+1}')   # Python 3.6
  2
  
  >>> x = 1
  >>> print(f'{x+1=}')   # Python 3.8
  'x+1=2'
  

---

三、条件和循环语句

• if 语句

  if condition_1:
      block_1
  elif condition_2:
      block_2
  else:
      block_3
  

• while 循环

  while counter <= n:
      sum = sum + counter
      counter += 1
  

• while 循环使用 else 语句

  while count < 5:
     print (count, " 小于 5")
     count = count + 1
  else:
     print (count, " 大于或等于 5")
  

• while循环体中只有一条语句

  while (flag): print ('欢迎访问菜鸟教程!')
  

• for 语句

  sites = ["Baidu", "Google","Runoob","Taobao"]
  for site in sites:
      print("循环数据 " + site)
  else:
      print("没有循环数据!")
  

• 如果你需要遍历数字序列，可以使用内置range()函数，它会生成数列。

for i in range(5):
	print(i)
for i in range(5,9) : # 指定区间的值
    print(i)
for i in range(0, 10, 3) : # 指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做'步长')
    print(i)
for i in range(-10, -100, -30) :
	print(i)
	
# 结合range()和len()函数以遍历一个序列的索引	
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
	print(i, a[i])
	
# 还可以使用range()函数来创建一个列表：
>>>list(range(5))
[0, 1, 2, 3, 4]

• break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
• continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
• 循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行，但循环被 break 终止时不执行。
• pass 语句
  pass 不做任何事情，一般用做占位语句。

>>>while True:
...     pass  # 等待键盘中断 (Ctrl+C)

---

四、迭代器与生成器

1. 迭代器

• 迭代是访问集合元素的一种方式。
• 迭代器是一个可以记住遍历的位置的对象。
• 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
• 迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2

>>> list=[1,2,3,4]
>>> str = "123456789"
>>> it = iter(str)
>>> print(next(it))
1
>>> print(next(it))
2
>>> 

>>> tuple = (1,"2","dd",54)
>>> it = iter(tuple)
>>> print(next(it))
1
>>> print(next(it))
2
>>> print(next(it))
dd
>>> print(next(it))
54
>>> 

迭代器对象可以使用常规for语句进行遍历：

>>> tuple = (1,"2","dd",54)
>>> it = iter(tuple)
>>> for i in it:
	print(i)

	
1
2
dd
54
>>> 

也可以使用 next() 函数：

>>> import sys         # 引入 sys 模块

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象

>>> while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()
        
1
2
3
4

• 创建一个迭代器
  把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。

  如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 __init__(), 它会在对象初始化的时候执行。

  • __iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。

  • __next__() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

  • 创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

  class MyNumbers:
    def __iter__(self): # 设置初值
      self.a = 1
      return self
   
    def __next__(self): # 设置步长
      x = self.a
      self.a += 1
      return x
  
  myclass = MyNumbers()
  myiter = iter(myclass)
  

• StopIteration
  StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

  class MyNumbers:
    def __iter__(self):
      self.a = 1
      return self
   
    def __next__(self):
      if self.a <= 20:
        x = self.a
        self.a += 1
        return x
      else:
        raise StopIteration # 手动设置异常，使用 raise 语句即可
  

2. 生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

调用一个生成器函数，返回的是一个迭代器对象。

>>> import sys
>>> def fibonacci(n): # 生成器函数 - 斐波那契
	a, b, counter = 0, 1, 0
	while True:
		if (counter > n): 
		    return
		yield a
		# yield相当于return，只不过这里返回的是一个迭代器，指向a的值，下面的两条语句在下一次执行next()方法时继续运行。
		# 暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
		a, b = b, a + b
		counter += 1

f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

---

五、函数

内建函数 比如print()
用户自定义函数

• 定义一个函数
• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 圆括号之间可以用于定义参数。
• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

def max(a, b):
    if a > b:
        return a
    else:
        return b

• 函数调用
• 可更改与不可更改对象
  在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
• 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
• 可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5，则是将 list la的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
• 总结：列表、字典、集合、元组中只有元组不能修改。
• 参数传递
• 不可变类型：类似 C++ 的值传递，如整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象。
• 可变类型：类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响。
• 总结：二者的区别在于参数类型是不可变还是可变类型，不可变类型修改值，实际上是新生成的一个对象，已经改变了原来变量的指向，但未改变原来对象的值。可变类型实际上是改变的传进来的变量指向对象的一部分。

传不可变对象实例
# 通过 id() 函数来查看内存地址变化：
def change(a):
    print(id(a))   # 指向的是同一个对象
    a=10
    print(id(a))   # 一个新对象

a=1
print(id(a))
change(a)

>>>4379369136
>>>4379369136
>>>4379369424

传可变对象实例
# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

# 传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：
函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

参数

1. 必需参数

必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。

#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不加参数会报错
printme()

2. 关键字参数

函数调用使用关键字参数来确定传入的参数值。

使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。

#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" )

3. 默认参数

调用函数时，如果没有传递参数，则会使用默认参数。

#可写函数说明
def printinfo( name, age = 35 ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( name="runoob" )

名字:  runoob
年龄:  35

4. 不定长参数

你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名。

• 加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

  # 可写函数说明
  def printinfo( arg1, *vartuple ):
     "打印任何传入的参数"
     print ("输出: ")
     print (arg1)
     print (vartuple)
   
  # 调用printinfo 函数
  printinfo( 70, 60, 50 )
  

  输出: 
  70
  (60, 50)
  

• 如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量。

  # 可写函数说明
  def printinfo( arg1, *vartuple ):
     "打印任何传入的参数"
     print ("输出: ")
     print (arg1)
     for var in vartuple:
        print (var)
     return
   
  # 调用printinfo 函数
  printinfo( 10 )
  printinfo( 70, 60, 50 )
  

  输出:
  10
  输出:
  70
  60
  50
  

• 加了两个星号 ** 的参数会以字典的形式导入。

  # 可写函数说明
  def printinfo( arg1, **vardict ):
     "打印任何传入的参数"
     print ("输出: ")
     print (arg1)
     print (vardict)
   
  # 调用printinfo 函数
  printinfo(1, a=2,b=3)
  

  输出: 
  1
  {'a': 2, 'b': 3}
  

• 声明函数时，参数中星号 * 可以单独出现.如果单独出现星号 * 后的参数必须用关键字传入。

  >>> def f(a,b,*,c):
  ...     return a+b+c
  ... 
  >>> f(1,2,3)   # 报错
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: f() takes 2 positional arguments but 3 were given
  >>> f(1,2,c=3) # 正常
  6
  >>>
  

匿名函数

python 使用 lambda 来创建匿名函数。

所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

• lambda 只是一个表达式，函数体比 def 简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
 
# 调用sum函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))

相加后的值为 :  30
相加后的值为 :  40

---

六、输入和输出

1.输出格式美化

Python两种输出值的方式: 表达式语句和 print() 函数。
第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。
如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。

如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

• str()： 函数返回一个用户易读的表达形式。
• repr()： 产生一个解释器易读的表达形式。

>>> s = 'Hello, Runoob'
>>> str(s)
'Hello, Runoob'
>>> repr(s)
"'Hello, Runoob'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'x 的值为： ' + repr(x) + ',  y 的值为：' + repr(y) + '...'
>>> print(s)
x 的值为： 32.5,  y 的值为：40000...
>>> #  repr() 函数可以转义字符串中的特殊字符
... hello = 'hello, runoob\n'
>>> hellos = repr(hello)
>>> print(hellos)
'hello, runoob\n'
>>> # repr() 的参数可以是 Python 的任何对象
... repr((x, y, ('Google', 'Runoob')))
"(32.5, 40000, ('Google', 'Runoob'))"

这里有两种方式输出一个平方与立方的表:

>>> for x in range(1, 11):
...     print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
...     # 注意前一行 'end' 的使用
...     print(repr(x*x*x).rjust(4))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

>>> for x in range(1, 11):
...     print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

注意：在第一个例子中, 每列间的空格由 print() 添加。

这个例子展示了字符串对象的 rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。

还有类似的方法, 如 ljust() 和 center()。 这些方法并不会写任何东西, 它们仅仅返回新的字符串。
另一个方法 zfill(), 它会在数字的左边填充 0，如下所示：

>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'

2.str.format() 的基本使用

>>> print('{}网址： "{}!"'.format('菜鸟教程', 'www.runoob.com'))
菜鸟教程网址： "www.runoob.com!"

括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。

在括号中的数字用于指向传入对象在 format() 中的位置，如下所示：

>>> print('{0} 和 {1}'.format('Google', 'Runoob'))
Google 和 Runoob
>>> print('{1} 和 {0}'.format('Google', 'Runoob'))
Runoob 和 Google

如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。

>>> print('{name}网址： {site}'.format(name='菜鸟教程', site='www.runoob.com'))
菜鸟教程网址： www.runoob.com

位置及关键字参数可以任意的结合:

>>> print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))
站点列表 Google, Runoob, 和 Taobao。

3.旧式字符串格式化

% 操作符也可以实现字符串格式化。 它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返回格式化后的字符串. 例如:

>>> import math
>>> print('常量 PI 的值近似为：%5.3f。' % math.pi)
常量 PI 的值近似为：3.142。

因为 str.format() 是比较新的函数， 大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该语言中移除, 应该更多的使用 str.format().

4.读取键盘输入

input() 内置函数从标准输入读入一行文本，默认的标准输入是键盘。

str = input("请输入：");
print ("你输入的内容是: ", str)

5.读和写文件

open() 将会返回一个 file 对象，基本语法格式如下:

open(filename, mode)

• filename：包含了你要访问的文件名称的字符串值。
• mode：决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读®。

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。

模式	r	r+	w	w+	a	a+
读	+	+		+		+
写		+	+	+	+	+
创建			+	+	+	+
覆盖			+	+
指针在开始	+	+	+	+
指针在结尾					+	+

1.将字符串写入到文件 foo.txt 中

# 打开一个文件
f = open("/tmp/foo.txt", "w")

f.write( "Python 是一个非常好的语言。\n是的，的确非常好!!\n" )

# 关闭打开的文件
f.close()

• 第一个参数为要打开的文件名。
• 第二个参数描述文件如何使用的字符。 mode 可以是 ‘r’ 如果文件只读, ‘w’ 只用于写 (如果存在同名文件则将被删除), 和 ‘a’ 用于追加文件内容; 所写的任何数据都会被自动增加到末尾. ‘r+’ 同时用于读写。 mode参数是可选的; ‘r’ 将是默认值。

如果要写入一些不是字符串的东西, 那么将需要先进行转换:

# 打开一个文件
f = open("/tmp/foo1.txt", "w")

value = ('www.runoob.com', 14)
s = str(value)
f.write(s)

# 关闭打开的文件
f.close()

('www.runoob.com', 14)

2.读取一个文件的内容

f.read()

为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。

size 是一个可选的数字类型的参数。 当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。

以下实例假定文件 foo.txt 已存在（上面实例中已创建）：

# 打开一个文件
f = open("/tmp/foo.txt", "r")

str = f.read()
print(str)

# 关闭打开的文件
f.close()

f.readline()

f.readline() 会从文件中读取单独的一行。换行符为 ‘\n’。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行。

# 打开一个文件
f = open("/tmp/foo.txt", "r")

str = f.readline()
print(str)

# 关闭打开的文件
f.close()

f.readlines()

f.readlines() 将返回该文件中包含的所有行。

如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。

# 打开一个文件
f = open("/tmp/foo.txt", "r")

str = f.readlines()
print(str)

# 关闭打开的文件
f.close()

['Python 是一个非常好的语言。\n', '是的，的确非常好!!\n']

另一种方式是迭代一个文件对象然后读取每行:

# 打开一个文件
f = open("/tmp/foo.txt", "r")

for line in f:
    print(line, end='')

# 关闭打开的文件
f.close()

Python 是一个非常好的语言。
是的，的确非常好!!

f.tell()

f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。

f.seek()

如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。

from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：

• seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
• seek(x,1) ： 表示从当前位置往后移动x个字符
• seek(-x,2)：表示从文件的结尾往前移动x个字符

from_what 值为默认为0，即文件开头。下面给出一个完整的例子：

>>> f = open('/tmp/foo.txt', 'rb+')
>>> f.write(b'0123456789abcdef')
16
>>> f.seek(5)     # 移动到文件的第六个字节
5
>>> f.read(1)
b'5'
>>> f.seek(-3, 2) # 移动到文件的倒数第三字节
13
>>> f.read(1)
b'd'

f.close()

在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。

当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。

>>> f.close()
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file

当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短:

>>> with open('/tmp/foo.txt', 'r') as f:
...     read_data = f.read()
>>> f.closed
True

文件对象还有其他方法, 如 isatty() 和 trucate(), 但这些通常比较少用。

---

七、错误和异常

Python 有两种错误很容易辨认：语法错误和异常。
Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。

异常处理

try/except

异常捕捉可以使用 try/except 语句。

while True:
    try:
        x = int(input("请输入一个数字: "))
        break
    except ValueError:
        print("您输入的不是数字，请再次尝试输入！")

• 如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的 except 子句将被执行。

• 如果一个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。

一个except子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:

except (RuntimeError, TypeError, NameError):
    pass

最后一个except子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再次把异常抛出。

try:
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise

try/except…else

else 子句将在 try 子句没有发生任何异常的时候执行。

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

try-finally 语句

try-finally 语句无论是否发生异常都将执行最后的代码。

try:
    runoob()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print('这句话，无论异常是否发生都会执行。')

抛出异常

Python 使用 raise 语句抛出一个指定的异常。

x = 10
if x > 5:
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))

执行以上代码会触发异常：

Traceback (most recent call last):
  File "test.py", line 3, in <module>
    raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
Exception: x 不能大于 5。x 的值为: 10

raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。

如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。

>>> try:
        raise NameError('HiThere')
    except NameError:
        print('An exception flew by!')
        raise
   
An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in ?
NameError: HiThere

定义清理行为

try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。 例如:

>>> try:
...     raise KeyboardInterrupt
... finally:
...     print('Goodbye, world!')
...
Goodbye, world!
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
KeyboardInterrupt

以上例子不管 try 子句里面有没有发生异常，finally 子句都会执行。

如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个异常会在 finally 子句执行后被抛出。

预定义的清理行为

一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执行。

这面这个例子展示了尝试打开一个文件，然后把内容打印到屏幕上:

for line in open("myfile.txt"):
    print(line, end="")

以上这段代码的问题是，当执行完毕后，文件会保持打开状态，并没有被关闭。

关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:

with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。