python编程快速上手前六章理论部分阅读笔记

常见错误

1.SyntaxError: EOL while scanning string literal

（忘记 了字符串末尾的单引号）

2.TypeError: ‘int’ object is not iterable

原因：不能直接用int进行迭代，而必须加个range.

for index in range(len(numbers)):正确

for i in len(index):错误

3.KeyError: ‘color’

尝试访问字典中不存在的键，将导致 KeyError 出错信息。这很像列表的“越界” IndexError 出错信息。

第一章 python基础

1.1 字符串连接和复制

代码必须显式地将整数转换为字符串，因为 Python 不

能自动完成转换。

用于两个整型或浮点型值时，操作符表示乘法。但操作符用于一个字符串 值和一个整型值时，它变成了“字符串复制”操作符。在交互式环境中输入一个字 符串乘一个数字，看看效果。

>>> ‘Alice’ * 5

‘AliceAliceAliceAliceAlice’

*操作符只能用于两个数字（作为乘法），或一个字符串和一个整型（作为字符 串复制操作符）

print只输出str类型，要进行格式转换

1.2 变量名

1．只能是一个词。

2．只能包含字母、数字和下划线。

3．不能以数字开头。

变量名使用了驼峰形式

1.3 注释

#标志之后的所有文本都是注释。

1.4 三个函数

input 输出的str

len输出的是整数

int对str类型报错，比如 **int(’7.7‘)**错误， **int(7.7)**正确

round() 方法返回浮点数x的四舍五入值。

1.5 文本和数字相等判断

虽然数字的字符串值被认为与整型值和浮点型值完全不同，但整型值可以与浮点值相等。

因为字符串是文本，而整型值和浮点型都是数字。

1.6习题

表达式和语句的区别

一个表达式会产生一个值,它可以放在任何需要一个值的地方

语句可以理解成一个行为.循环语句和if语句就是典型的语句.一个程序是由一系列语句组成的.

表达式

是由运算符和运算对象组成的,单独的一个运算对象(常量/变量)也可以叫做表达式，这是最简单的表达式.

第二章 控制流

2.1布尔值

布尔值 True 和 False

不像字符串，两边没有引号，它们总是以大写字母 T 或 F 开头，后面的字母小写

2.2 比较操作符

==

等于

!=

不等于

<

小于

>

大于

<=

小于等于

>=

大于等于

==和!=操作符实际上可以用于所有数据类型的值

请注意，整型或浮点型的值永远不会与字符串相等。表达式 42 == '42’求值为 False 是因为，Python 认为整数 42 与字符串’42’不同。

另一方面，<、>、<=和>=操作符仅用于整型和浮点型值

2.3 布尔操作符

3 个布尔操作符（and、or 和 not）用于比较布尔值。

not 操作符求 值为相反的布尔值

not True=false

2.4 混合布尔和比较操作符

计算机将先求值左边的表达式，然后再求值右边的表达式。知道两个布尔值后， 它又将整个表达式再求值为一个布尔值。

和算术操作符一样，布尔操作符也有操作顺序。在所有算术和比较操作符求值 后，Python 先求值 not 操作符，然后是 and 操作符，然后是 or 操作符。

2.5 控制流的元素

2.5.1 条件

条件总是求值为一个布尔值，True 或 False。控制 流语句根据条件是 True 还是 False，来决定做什么。几乎所有的控制流语句都使用条件。

2.5.2 代码块

一些代码行可以作为一组，放在“代码块”中。可以根据代码行的缩进，知道 代码块的开始和结束。代码块有 3 条规则。

1．缩进增加时，代码块开始。

2．代码块可以包含其他代码块。

3．缩进减少为零，或减少为外面包围代码块的缩进，代码块就结束了。

2.6 控制流语句

if 语句

最常见的控制流语句是 if 语句。if 语句的子句（也就是紧跟 if 语句的语句块）， 将在语句的条件为 True 时执行。如果条件为 False，子句将跳过。 在英文中，if 语句念起来可能是：“如果条件为真，执行子句中的代码。”在 Python

中，if 语句包含以下部分：

 if 关键字；

 条件（即求值为 True 或 False 的表达式）；

 冒号；

 在下一行开始，缩进的代码块（称为 if 子句）。

if name == 'Alice': 

 print('Hi, Alice.')

else 语句

if 子句后面有时候也可以跟着 else 语句。只有 if 语句的条件为 False 时，else 子句才会执行。在英语中，else 语句读起来可能是：“如果条件为真，执行这段 代码。否则，执行那段代码”。else 语句不包含条件，在代码中，else 语句中包 含下面部分：

 else 关键字；

 冒号；

 在下一行开始，缩进的代码块（称为 else 子句）。

if name == 'Alice':
 print('Hi, Alice.')
else:
 print('Hello, stranger.')

elif 语句

虽然只有 if 或 else 子句会被执行，但有时候可能你希望，“许多”可能的子句

中有一个被执行。elif 语句是“否则如果”，总是跟在 if 或另一条 elif 语句后面。它

提供了另一个条件，仅在前面的条件为 False 时才检查该条件。在代码中，elif 语句

总是包含以下部分：

 elif 关键字；

 条件（即求值为 True 或 False 的表达式）；

 冒号；

 在下一行开始，缩进的代码块（称为 elif 子句）。

if name == 'Alice': 

 print('Hi, Alice.') 

elif age < 12: 

 print('You are not Alice, kiddo.') 

注:最多只有一个子句会执行，对于 elif 语句，次序是很重要的。

print("input your name")
name=input()
print('input your age')
age=int(input())
if name=='wpc':
    print('hi wpc')
elif age<20:
    print('you are not wpc,boy')
elif age >100:
    print('you are not wpc,grandfather')
elif age >3000:
    print('he is not dead')

while 循环语句

利用 while 语句，可以让一个代码块一遍又一遍的执行。只要 while 语句的条件为 True，while 子句中的代码就会执行。在代码中，while 语句总是包含下面几

部分：

 关键字；

 条件（求值为 True 或 False 的表达式）；

 冒号；

 从新行开始，缩进的代码块（称为 while 子句）。

spam = 0
while spam < 5:
 print('Hello, world.')
 spam = spam + 1

break 语句

如果执行遇到 break 语句，就会马上退出 while 循环子句。在代码中，break 语句仅包含 break 关键字。

while True:
 print('Please type your name.')
 name = input() 
 if name == 'your name': 
 break 
 print('Thank you!')

continue 语句

continue 语句用于循环内部。如果程序执行遇到 continue语句，就会马上跳回到循环开始处，重新对循环条件求值（这也是执行到达循环末尾时发生的事情）

解除死循环

如果运行这个程序，它将永远在屏幕上打印 Hello world！因为 while 语句的条件总是 True。在 IDLE 的交互式环境窗口中，只有两种办法停止这个程序：按下 Ctrl-C 或从菜单中选择 ShellRestart Shell。如果你希望马上停止程序，即使它不是陷在一个无限循环中，Ctrl-C 也是很方便的

for 循环和 range()函数

在用于条件时，0、0.0 和’ '（空字符串）被认为是 False，其他值被认为是 True。

在代码中，for 语句看起来像 for i in range(5):这样，总是包含以下部分：

 for 关键字；

 一个变量名；

 in 关键字；

 调用 range()方法，最多传入 3 个参数；

 冒号；

 从下一行开始，缩退的代码块（称为 for 子句）。

print('My name is') 
for i in range(5):
 print('Jimmy Five Times (' + str(i) + ')')

range左闭右开,从0开始

等价的 while 循环

实际上可以用 while 循环来做和 for 循环同样的事，for 循环只是更简洁。

range()的开始、停止和步长参数

某些函数可以用多个参数调用，参数之间用逗号分开，range()就是其中之一。

这让你能够改变传递给 range()的整数，实现各种整数序列，包括从 0 以外的值开始。

for i in range(12, 16):
 print(i)

12
13
14
15
# 结果

range()函数也可以有第三个参数。前两个参数分别是起始值和终止值，第三个参数是“步长”。步长是每次迭代后循环变量增加的值。

调用 range(0, 10, 2)将从 0 数到 8，间隔为 2。

0 
2 
4 
6 
8

可以用

负数作为步长参数，让循环计数逐渐减少，而不是增加。

2.7 导入模块

在开始使用一个模块中的函数之前，必须用 import 语句导入该模块。在代码中，

import 语句包含以下部分：

 import 关键字；

 模块的名称；

 可选的更多模块名称，之间用逗号隔开。

import random, sys, os, math

import random
for i in range(5):
 print(random.randint(1, 10))

random.randint()函数调用求值为传递给它的两个整数之间的一个随机整数。因为 randint()属于 random 模块，必须在函数名称之前先加上 random.，告诉 python 在 random 模块中寻找这个函数。

from import 语句

import 语句的另一种形式包括 from 关键字，之后是模块名称，import 关键字和 一个星号，例如 from random import *。

使用这种形式的 import 语句，调用 random模块中的函数时不需要 random.前缀。

但是，使用完整的名称会让代码更可读，所以最好是使用普通形式的 import 语句。

2.8 用 sys.exit()提前结束程序

要介绍的最后一个控制流概念，是如何终止程序。当程序执行到指令的底部时， 总是会终止。但是，通过调用 sys.exit()函数，可以让程序终止或退出。因为这个函数在 sys 模块中，所以必须先导入 sys，才能使用它。

import sys
while True:
 print('Type exit to exit.')
 response = input()
 if response == 'exit':
 sys.exit() 
 print('You typed ' + response + '.')

第三章 函数

函数的目的:消除重复,将多次执行的代码放在一起

3.1 def 语句和参数

第一行是 def 语句，它定义了一个名为 hello()的函数。def 语句之后的代码块是函数体。这段代码在函数调用时执行，而不是在函数第一次定义时执行。

def hello(name):
  print('Hello ' + name) 
  hello('Alice')
hello('Bob')

3.2 返回值和 return 语句

用 def 语句创建函数时，可以用 return 语句指定应该返回什么值。return 语句包

含以下部分：

 return 关键字；

 函数应该返回的值或表达式。

表达式是值和操作符的组合。函数调用可以用在表达式中，因为它求值为它的返回值。

3.3 None 值

在 Python 中有一个值称为 None，它表示没有值。None 是 NoneType 数据类型的唯一值（其他编程语言可能称这个值为 null、nil 或 undefined）。就像布尔值 True和 False 一样，None 必须大写首字母 N。

所有函数调用都需要求值为一个返回值，那么 print()就返回 None。print()的返回值为None

3.4 关键字参数和 print()

大多数参数是由它们在函数调用中的位置来识别的。例如，random.randint(1, 10)与 random.randint(10, 1)不同。函数调用 random.randint(1, 10)将返回 1 到 10 之间的一个随机整数，因为第一个参数是范围的下界，第二个参数是范围的上界（而

random.randint(10, 1)会导致错误）。

但是，“关键字参数”是由函数调用时加在它们前面的关键字来识别的。关键 字参数通常用于可选变元。例如，print()函数有可选的变元 end 和 sep，分别指定在 参数末尾打印什么，以及在参数之间打印什么来隔开它们

因为 print()函数自动在传入的字符串末尾添加了换行符。但是，可以设置 end 关键字参数，将它变成另一个字符串。例如，

如果程序像这样：

print(‘Hello’, end=’’)

print(‘World’)

输出

HelloWorld

如果向 print()传入多个字符串值，该函数就会自动用一个空格分隔它 们。在交互式环境中输入以下代码

print(‘cats’, ‘dogs’, ‘mice’)

cats dogs mice

传入 sep 关键字参数，替换掉默认的分隔字符串。在交互式环境中

输入以下代码：

print(‘cats’, ‘dogs’, ‘mice’, sep=’,’)

cats,dogs,mice

3.5 局部和全局作用域

在被调用函数内赋值的变元和变量，处于该函数的“局部作用域”。在所有函数之外赋值的变量，属于“全局作用域”。处于局部作用域的变量，被称为“局部变量”。处于全局作用域的变量，被称为“全局变量”。一个变量必是其中一种，不能既是局部的又是全局的。

可以将“作用域”看成是变量的容器。当作用域被销毁时，所有保存在该作用域内的变量的值就被丢弃了。只有一个全局作用域，它是在程序开始时创建的。如果程序终止，全局作用域就被销毁，它的所有变量就被丢弃了。否则，下次你运行程序的时候，这些变量就会记住它们上次运行时的值。

一个函数被调用时，就创建了一个局部作用域。在这个函数内赋值的所有变量，存在于该局部作用域内。该函数返回时，这个局部作用域就被销毁了，这些变量就丢失了。下次调用这个函数，局部变量不会记得该函数上次被调用时它们保存的值。 作用域很重要，理由如下：

 全局作用域中的代码不能使用任何局部变量；

 但是，局部作用域可以访问全局变量；

 一个函数的局部作用域中的代码，不能使用其他局部作用域中的变量。

 如果在不同的作用域中，你可以用相同的名字命名不同的变量。

依赖全局变量就是一个坏习惯

3.5.1 局部变量不能在全局作用域内使用

def spam(): 

 eggs = 31337 

spam() 

print(eggs) 
#报错

eggs 变量只属于 spam()调用所创建的局部作用域。在程序执

行从 spam 返回后，该局部作用域就被销毁了，不再有名为 eggs 的变量。

3.5.2 局部作用域不能使用其他局部作用域内的变量

def spam():
 eggs = 99
 bacon()
 print(eggs)
def bacon():
 ham = 101
 eggs = 0
spam()
#输出为99

要点在于，一个函数中的局部变量完全与其他函数中的局部变量分隔开来。

3.5.3 全局变量可以在局部作用域中读取

def spam():
 print(eggs)
eggs = 42
spam()
print(eggs)
#打印出42

因为在 spam()函数中，没有变元名为 eggs，也没有代码为 eggs 赋值，所以当 spam()中使用 eggs 时，Python 认为它是对全局变量 eggs 的引用。这就是前面的程序运行时打印出 42 的原因

3.5.4 名称相同的局部变量和全局变量

要想生活简单，就要避免局部变量与全局变量或其他局部变量同名。但在技术上，在 Python 中让局部变量和全局变量同名是完全合法的。

def spam():
  eggs = 'spam local'
  print(eggs) # prints 'spam local'
def bacon():
  eggs = 'bacon local'
  print(eggs) # prints 'bacon local'
  spam()
  print(eggs) # prints 'bacon local'
eggs = 'global'
bacon()
print(eggs) # prints 'global'

bacon local
spam local
bacon local
global

当局部域和全局域冲突的时候服从局部域

3.6 global 语句

如果需要在一个函数内修改全局变量，就使用 global 语句。如果在函数的顶部

有 global eggs 这样的代码，它就告诉 Python，“在这个函数中，eggs 指的是全局变

量，所以不要用这个名字创建一个局部变量。”

def spam(): 

  global eggs  

  eggs = 'spam'  

eggs = 'global' 

spam() 

print(eggs)
#输出spam

因为 eggs 在 spam()的顶部被声明为 global ，所以当 eggs 被赋值为’spam’时 ，

赋值发生在全局作用域的 spam 上。没有创建局部 spam 变量。

有 4 条法则，来区分一个变量是处于局部作用域还是全局作用域：

1．如果变量在全局作用域中使用（即在所有函数之外），它就总是全局变量。

2．如果在一个函数中，有针对该变量的 global 语句，它就是全局变量。

3．否则，如果该变量用于函数中的赋值语句，它就是局部变量。

4．但是，如果该变量没有用在赋值语句中，它就是全局变量。

def spam():
 print(eggs) #正常
 # eggs = 'spam local'
eggs = 'global'
spam()

def spam():
 print(eggs) # ERROR!
 eggs = 'spam local'
eggs = 'global'
spam()
#Python 看到 spam()函数中有针对 eggs 的赋值语句，因此认为 eggs 变量是局部变量

3.7 异常处理

在 Python 程序中遇到错误，或“异常”，意味着整个程序崩溃。

你不希望这发生在真实世界的程序中。相反，你希望程序能检测错误，处理它们，

然后继续运行。

def spam(divideBy):
 return 42 / divideBy
print(spam(2))
print(spam(12))
print(spam(0))
print(spam(1))

当试图用一个数除以零时，就会发生 ZeroDivisionError。根据错误信息中给出

的行号，我们知道 spam()中的 return 语句导致了一个错误。

函数作为“黑盒”

通常，对于一个函数，你要知道的就是它的输入值（变元）和输出值。 

你并非总是需要加重自己的负担，弄清楚函数的代码实际是怎样工作的。 

如果以这种高层的方式来思考函数，通常大家会说，你将该函数看成是一 

个黑盒。 这个思想是现代编程的基础。

错误可以由 try 和 except 语句来处理。那些可能出错的语句被放在 try 子句中。

如果错误发生，程序执行就转到接下来的 except 子句开始处。

def spam(divideBy):
 try:
 return 42 / divideBy 
 except ZeroDivisionError:
 print('Error: Invalid argument.') 
print(spam(2))
print(spam(12))
print(spam(0))
print(spam(1))

21.0

3.5

Error: Invalid argument.

None

42.0

请注意，在函数调用中的 try 语句块中，发生的所有错误都会被捕捉。请考虑

以下程序，它的做法不一样，将 spam()调用放在语句块中：

def spam(divideBy):
 return 42 / divideBy
try:
 print(spam(2))
 print(spam(12))
 print(spam(0))
 print(spam(1))
except ZeroDivisionError:
 print('Error: Invalid argument.')

21.0

3.5

Error: Invalid argument.

print(spam(1))从未被执行是因为，一旦执行跳到 except 子句的代码，就不会回本文档由到 try 子句。它会继续照常向下执行。

3.8 一个小程序：猜数字

# This is a guess the number game.
import random
secretNumber = random.randint(1, 20)
print('I am thinking of a number between 1 and 20.')
# Ask the player to guess 6 times.
for guessesTaken in range(1, 7):#它有了一个秘密数字，并且给玩家 6 次猜测机会
 print('Take a guess.')
 guess = int(input())
 if guess < secretNumber:
    print('Your guess is too low.')
 elif guess > secretNumber:
    print('Your guess is too high.')
 else:
    break # This condition is the correct guess!
if guess == secretNumber:
 print('Good job! You guessed my number in ' + str(guessesTaken) + ' guesses!')
else:
 print('Nope. The number I was thinking of was ' + str(secretNumber))

编程题

print('请输入一个数字吧!!')
input_name=int(input())
def collatz(num):
    if num%2 ==0:
        return int(num/2)
    else:
        return int(num*3+1)

if input_name ==1:
    print(input_name)
else:
    result = collatz(input_name)
    print(result)
    while 1:
        result = collatz(result)
        if result == 1:
            print(result)
            break
        else:
            print(result)

第四章

列表和元组可以包含多个值，这样编写程序来处理大量数据就变得更容易。而且，由于列表本身

又可以包含其他列表，所以可以用它们将数据安排成层次结构。

4.1 列表数据类型

列表用左方括号开始，右方括号结束，即[]。列表中的值也称为“表项”。表项用逗号分隔（就是说，它们是“逗号分隔的”）。

数据类型可以任意

4.1.1 用下标取得列表中的单个值

下标从0开始

如果使用的下标超出了列表中值的个数，Python 将给出 IndexError 出错信息。

下标只能是整数，不能是浮点值。

4.1.2 负数下标

虽然下标从 0 开始并向上增长，但也可以用负整数作为下标。整数值−1 指的是列表中的最后一个下标，−2 指的是列表中倒数第二个下标

4.1.3 利用切片取得子列表

就像下标可以从列表中取得单个值一样，“切片”可以从列表中取得多个值，结果是一个新列表。切片输入在一对方括号中，像下标一样，但它有两个冒号分隔的整数。请注意下标和切片的不同

spam[2]是一个列表和下标（一个整数）。

spam[1:4]是一个列表和切片（两个整数）。

在一个切片中，第一个整数是切片开始处的下标。第二个整数是切片结束处的下标。切片向上增长，直至第二个下标的值，但不包括它。

左闭右开

4.1.4 用 len()取得列表的长度

len()函数将返回传递给它的列表中值的个数，就像它能计算字符串中字符的个数一样。

>>> len(‘hello’)

5

4.1.5用下标改变列表中的值

赋值语句左边是一个变量名，就像 spam = 4。但是，也可以使用列表的下标来改变下标处的值。

4.1.6 列表连接和列表复制

+操作符可以连接两个列表，得到一个新列表，就像它将两个字符串合并成一个新字符串一样。*操作符可以用于一个列表和一个整数，实现列表的复制。

>>> [1, 2, 3] + ['A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C'] 
>>> ['X', 'Y', 'Z'] * 3
['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z']
>>> spam = [1, 2, 3]
>>> spam = spam + ['A', 'B', 'C']
>>> spam
[1, 2, 3, 'A', 'B', 'C']

4.1.7 用 del 语句从列表中删除值

del 语句将删除列表中下标处的值，表中被删除值后面的所有值，都将向前移动一个下标。

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat']

4.2 使用列表

catNames = []
while True:
 print('Enter the name of cat ' + str(len(catNames) + 1) +
 ' (Or enter nothing to stop.):') 
 name = input()
 if name == '':
 break 
 catNames = catNames + [name] # list concatenation
print('The cat names are:')
for name in catNames:
 print(' ' + name)

使用列表的好处在于，现在数据放在一个结构中，所以程序能够更灵活的处理数据，比放在一些重复的变量中方便。

注意:类型要一致

4.2.1 列表用于循环

range(4)的返回值是类似列表的值。Python 认为它类似于[0, 1, 2, 3]。

一个常见的 Python 技巧，是在 for 循环中使用 range(len(someList))，迭代列表 的每一个下标。

>>> supplies = ['pens', 'staplers', 'flame-throwers', 'binders'] 
>>> for i in range(len(supplies)):
 print('Index ' + str(i) + ' in supplies is: ' + supplies[i])
Index 0 in supplies is: pens
Index 1 in supplies is: staplers
Index 2 in supplies is: flame-throwers
Index 3 in supplies is: binders

4.2.2 in 和 not in 操作符

利用 in 和 not in 操作符，可以确定一个值否在列表中。像其他操作符一样，in和 not in 用在表达式中，连接两个值：一个要在列表中查找的值，以及待查找的列表。这些表达式将求值为布尔值。

>>> 'howdy' in ['hello', 'hi', 'howdy', 'heyas']
True
>>> spam = ['hello', 'hi', 'howdy', 'heyas']
>>> 'cat' in spam
False

myPets = ['Zophie', 'Pooka', 'Fat-tail']
print('Enter a pet name:')
name = input()
if name not in myPets:
 print('I do not have a pet named ' + name)
else:
 print(name + ' is my pet.')

4.2.3 多重赋值技巧

多重赋值技巧是一种快捷方式，让你在一行代码中，用列表中的值为多个变量赋值。

注:变量的数目和列表的长度必须严格相等，否则 Python 将给出 ValueError

>>> cat = ['fat', 'black', 'loud']
>>> size, color, disposition = cat
#等价于
>>> cat = ['fat', 'black', 'loud']
>>> size = cat[0]
>>> color = cat[1]
>>> disposition = cat[2]

4.3 增强的赋值操作

+= -= *= /= %=

4.4 方法

方法和函数是一回事，只是它是调用在一个值上。每种数据类型都有它自己的一组方法。例如，列表数据类型有一些有用的方法， 用来查找、添加、删除或操作列表中的值

都要listname.fangfa()

4.4.1 用 index()方法在列表中查找值

用来查找某个值的下标,如果该值不在列表中，Python 就报 ValueError,如果列表中存在重复的值，就返回它第一次出现的下标。

4.4.2 用 append()和 insert()方法在列表中添加值

append()方法调用，将参数添加到列表末尾。insert()方法可以在列表任意下标处插入一个值。insert()方法的第一个参数是新值的下标，第二个参数是要插入的新值。

注:spam = spam.append(‘moose’)和 spam = spam.insert(1, ‘chicken’)书写出错误

append()和 insert()的返回值是 None，列表被当场修改了

spam.append(‘moose’)和 spam.insert(1, ‘chicken’)正确

注:方法属于单个数据类型。append()和 insert()方法是列表方法，只能在列表上调 用，不能在其他值上调用，例如字符串和整型。

4.4.3 用 remove()方法从列表中删除值

remove()方法传入一个值，它将从被调用的列表中删除.试图删除列表中不存在的值，将导致 ValueError 错误。

如果该值在列表中出现多次，只有第一次出现的值会被删除。

如果知道想要删除的值在列表中的下标，del 语句就很好用。

>>> spam = [‘cat’, ‘bat’, ‘rat’, ‘elephant’]

>>> spam.remove(‘bat’)

>>> spam

[‘cat’, ‘rat’, ‘elephant’]

4.4.4 用 sort()方法将列表中的值排序

reverse 关键字参数为 True，让 sort()按逆序排序。spam.sort(reverse=True)

注:不能对既有数字又有字符串值的列表排序，因为 Python 不知道如何比较

它们。否则报 TypeError 错误.

sort()方法对字符串排序时，使用“ASCII 字符顺序”，而不是实际的字典顺序。这意味着大写字母排在小写字母之前。因此在排序时，小写的 a 在大写的Z 之后。

如果需要按照普通的字典顺序来排序，就在 sort()方法调用时，将关键字参数key 设置为 str.lower

spam.sort(key=str.lower)

4.5Python 中缩进规则的例外

在大多数情况下，代码行的缩进告诉 Python 它属于哪一个代码块。但是，这个规则有几个例外。例如在源代码文件中，列表实际上可以跨越几行。这些行 的缩进并不重要。Python 知道，没有看到结束方括号，列表就没有结束。还有print函数

4.6 类似列表的类型：字符串和元组

列表并不是唯一表示序列值的数据类型。例如，字符串和列表实际上很相似， 只要你认为字符串是单个文本字符的列表。对列表的许多操作，也可以作用于字符串：按下标取值、切片、用于 for 循环、用于 len()，以及用于 in 和 not in 操作符

4.6.1 可变和不可变数据类型

但列表和字符串在一个重要的方面是不同的。列表是“可变的”数据类型，它的值可以添加、删除或改变。但是，字符串是“不可变的”，它不能被更改。尝试对字符串中的一个字符重新赋值，将导致 TypeError 错误。

“改变”一个字符串的正确方式，是使用切片和连接。构造一个“新的”字符串，从老的字符串那里复制一些部分。

>>> eggs = [1, 2, 3]
>>> eggs = [4, 5, 6]
>>> eggs
[4, 5, 6]

尽管列表值是可变的，这里 eggs 中的列表值并没有改变，而是整个新的不同的列表值([4, 5, 6])，覆写 了老的列表值。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LHjL1V1Z-1595908463702)(C:\Users\wpc\Documents\Markdown文档\python编程快速上手.assets\1594687941977.png)]

4.6.2 元组数据类型

除了两个方面，“元组”数据类型几乎与列表数据类型一样。首先，元组输入时用圆括号()，而不是用方括号[]。但元组与列表的主要区别还在于，元组像字符串一样，是不可变的。元组不能让它们的值被修改、添加或删除。

>>> eggs = ('hello', 42, 0.5)
>>> eggs[1] = 99
Traceback (most recent call last):
 File "<pyshell#5>", line 1, in <module>
 eggs[1] = 99
TypeError: 'tuple' object does not support item assignment

如果元组中只有一个值，你可以在括号内该值的后面跟上一个逗号，表明这种 情况。否则，Python 将认为，你只是在一个普通括号内输入了一个值。逗号告诉 Python，这是一个元组（不像其他编程语言，Python 接受列表或元组中最后表项后 面跟的逗号）

>>> type(('hello',))
<class 'tuple'>
>>> type(('hello'))
<class 'str'>

用元组告诉所有读代码的人，你不打算改变这个序列的值。如果需要一个永远不会改变的值的序列，就使用元组。使用元组而不是列表的第二个好处在于,因为它们是不可变的，它们的内容不会变化，Python 可以实现一些优化，让使用元组的代码比使用列表的代码更快

4.6.3 用 list()和 tuple()函数来转换类型

函数 list()和 tuple()将返回传递给它们的值的列表和元组版本。

如果需要元组值的一个可变版本，将元组转换成列表就很方便。

>>> tuple(['cat', 'dog', 5]) 
('cat', 'dog', 5)
>>> list(('cat', 'dog', 5))
['cat', 'dog', 5]
>>> list('hello')
['h', 'e', 'l', 'l', 'o']

4.7 引用

当你将列表赋给一个变量时，实际上是将列表的“引用” 赋给了该变量。引用是一个值，指向某些数据。列表引用是指向一个列表的值。

>>> **spam = [0, 1, 2, 3, 4, 5]**  

>>> **cheese = spam**  
>>> **cheese[1] = 'Hello!'**  

>>> **spam** 

[0, 'Hello!', 2, 3, 4, 5] 

>>> **cheese** 

[0, 'Hello!', 2, 3, 4, 5] 

记住，变量就像包含着值的盒子。因为列表变量实际上没有包含列表，而是包含了对列表的“引用”（这些引用包含一些 ID 数字，Python 在内部使用这些 ID，但是你可以忽略）。

变量包含对列表值的引用，而不是列表值本身。但对于字符串和整数值，变量 就包含了字符串或整数值。在变量必须保存可变数据类型的值时，例如列表或字典， Python 就使用引用。对于不可变的数据类型的值，例如字符串、整型或元组，Python 变量就保存值本身。 虽然 Python 变量在技术上包含了对列表或字典值的引用，但人们通常随意地说，该变量包含了列表或字典

4.7.1 传递引用

要理解参数如何传递给函数，引用就特别重要。当函数被调用时，参数的值被复制给变元。对于列表（以及字典），这意味着变元得到的是引用的拷贝。

def eggs(someParameter): 

 someParameter.append('Hello') 

spam = [1, 2, 3] 

eggs(spam) 

print(spam)

请注意，当 eggs()被调用时，没有使用返回值来为 spam 赋新值。相反，它直接当场修改了该列表。

[1, 2, 3, ‘Hello’]

尽管 spam 和 someParameter 包含了不同的引用，但它们都指向相同的列表。这就是为什么函数内的 append(‘Hello’)方法调用在函数调用返回后，仍然会对该列表产生影响。

4.7.2 copy 模块的 copy()和 deepcopy()函数

在处理列表和字典时，尽管传递引用常常是最方便的方法，但如果函数修改了传入的列表或字典，你可能不希望这些变动影响原来的列表或字典。要做到这一点，Python 提供了名为 copy 的模块，其中包含 copy()和 deepcopy()函数。

copy.copy()，可以用来复制列表或字典这样的可变值，而不只是复制引用。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K9wY1Uj3-1595908463711)(C:\Users\wpc\Documents\Markdown文档\python编程快速上手.assets\1594905544970.png)]

copy.deepcopy()函数使用条件:复制的列表中包含了列表,deepcopy()函数将同时复制它们内部的列表。

import copy
origin = [1, 2, [3, 4]]
#origin 里边有三个元素：1， 2，[3, 4]
cop1 = copy.copy(origin)
cop2 = copy.deepcopy(origin)
# cop1是否与cop2内容相同
print(cop1 == cop2)
#True
# cop1是否与cop2为同一个引用
print(cop1 is cop2)
#False
#cop1 和 cop2 看上去相同，但已不再是同一个object
origin[2][0] = "hey!"
origin[1]='wpc'
print(origin)
print(cop1)
print(cop2)
#把origin内的子list [3, 4] 改掉了一个元素，观察 cop1 和 cop2

4.8 小结

列表是可变的，这意味着它们的内容可以改变。元组和字符串虽然在某些方面像列表，却是不可变的，不能被修改。包含一个元组或字符串的变量，可以被一个新的元组或字符串覆写，但这和现场修改原来的值不是一回事，不像 append()和remove()方法在列表上的效果。

变量不直接保存列表值，它们保存对列表的“引用”。在复制变量或将列表作为函数调用的参数时，这一点很重要。因为被复制的只是列表引用，所以要注意，对该列表的所有改动都可能影响到程序中的其他变量。如果需要对一个变量中的列表修改，同时不修改原来的列表，就可以用 copy()或 deepcopy()。

copy.copy() 函数将浅拷贝列表，而 copy.deepcopy() 函数将深拷贝列表。也就是说，只有 copy.deepcopy() 会复制列表内的所有列表。

end关键字

关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符

end作用就是在b后面加个什么东西

a, b = 0, 1
while b < 1000:
    print(b, end=',')
    a, b = b, a+b

结果1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

4.9项目实践

1.假定有下面这样的列表：

spam = [‘apples’, ‘bananas’, ‘tofu’, ‘cats’]

编写一个函数，它以一个列表值作为参数，返回一个字符串。该字符串包含所

有表项，表项之间以逗号和空格分隔，并在最后一个表项之前插入 and。例如，将

前面的 spam 列表传递给函数，将返回’apples, bananas, tofu, and cats’。但你的函数应

该能够处理传递给它的任何列表。

def charu(LIST):
    length = len(LIST)
    count = 0
    zifuchuan=''
    for inx, val in enumerate(LIST):
        if inx == length - 1:
            zifuchuan = zifuchuan + 'and ' + val
            return zifuchuan
        zifuchuan=zifuchuan+val+','
spam = ['apples','bananas','tofu','cats','wpc']
print(charu(spam))

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3dIbo3B7-1595908463719)(C:\Users\wpc\Documents\Markdown文档\python编程快速上手.assets\1594993782606.png)]

def PRINT(LIST):
    Row=len(LIST)
    Colum=len(LIST[1])
    print('该list行为' + str(Row))
    print('该list列为' + str(Colum))
    for i in range(Colum) :
        for j in range(Row):
            print(LIST[j][i],end='')
            if j>=Row-1 :
                print('')
grid = [['.', '.', '.', '.', '.', '.'],
 ['.', 'O', 'O', '.', '.', '.'], 
 ['O', 'O', 'O', 'O', '.', '.'],
 ['O', 'O', 'O', 'O', 'O', '.'], 
 ['.', 'O', 'O', 'O', 'O', 'O'], 
 ['O', 'O', 'O', 'O', 'O', '.'], 
 ['O', 'O', 'O', 'O', '.', '.'], 
 ['.', 'O', 'O', '.', '.', '.'], 
 ['.', '.', '.', '.', '.', '.']]
PRINT(grid)

第五章 字典和结构化数据

5.1 字典数据类型

像列表一样，“字典”是许多值的集合。但不像列表的下标，字典的索引可以

使用许多不同数据类型，不只是整数。字典的索引被称为“键”，键及其关联的值

称为“键-值”对。在代码中，字典输入时带花括号{}。

myCat = {‘size’: ‘fat’, ‘color’: ‘gray’, ‘disposition’: ‘loud’}

可以通过它们的键访问这些值

>>> myCat[‘size’]

‘fat’

>>> 'My cat has ’ + myCat[‘color’] + ’ fur.'

‘My cat has gray fur.’

字典仍然可以用整数值作为键，就像列表使用整数值作为下标一样，但它们不

必从 0 开始，可以是任何数字。

>>> spam = {12345: ‘Luggage Combination’, 42: ‘The Answer’}

5.1.1 字典与列表

不像列表，字典中的表项是不排序的。名为 spam 的列表中，第一个表项是 spam[0]。但字典中没有“第一个”表项。虽然确定两个列表是否相同时，表项的顺序很重要,但在字典中，键-值对输入的顺序并不重要,因为字典是不排序的，所以不能像列表那样切片。

>>> spam = [‘cats’, ‘dogs’, ‘moose’]

>>> bacon = [‘dogs’, ‘moose’, ‘cats’]

>>> spam == bacon

False

>>> eggs = {‘name’: ‘Zophie’, ‘species’: ‘cat’, ‘age’: ‘8’}

>>> ham = {‘species’: ‘cat’, ‘age’: ‘8’, ‘name’: ‘Zophie’}

>>> eggs == ham

True

5.1.2 keys()、values()和 items()方法

有 3 个字典方法，它们将返回类似列表的值，分别对应于字典的键、值和键-值对：keys()、values()和 items()。这些方法返回的值不是真正的列表，它们不能被修改，没有append()方法。但这些数据类型（分别是 dict_keys、dict_values 和 dict_items）可以用于for 循环。

>>> spam = {‘color’: ‘red’, ‘age’: 42}

>>> for v in spam.values():

print(v)

red

42

这里，for 循环迭代了 spam 字典中的每个值。for 循环也可以迭代每个键，或者键-值对：

>>> for k in spam.keys():

print(k)

color

age

>>> for i in spam.items():

print(i)

(‘color’, ‘red’)

(‘age’, 42)

如果希望通过这些方法得到一个真正的列表，就把类似列表的返回值传递给 list函数。

>>> spam = {‘color’: ‘red’, ‘age’: 42}

>>> spam.keys()

dict_keys([‘color’, ‘age’])

>>> list(spam.keys())

[‘color’, ‘age’]

利用多重赋值的技巧，在 for 循环中将键和值赋给不同的变量。

>>> spam = {‘color’: ‘red’, ‘age’: 42}

>>> for k, v in spam.items():

print('Key: ’ + k + ’ Value: ’ + str(v))

Key: age Value: 42

Key: color Value: red

5.1.3 检查字典中是否存在键或值

in 和 not in 操作符可以检查值是否存在于列表和字典中。

>>> spam = {‘name’: ‘Zophie’, ‘age’: 7}

>>> ‘name’ in spam.keys()

True

>>> ‘Zophie’ in spam.values()

True

>>> ‘color’ in spam.keys()

False

>>> ‘color’ not in spam.keys()

True

>>> ‘color’ in spam

False

注意：‘color’ in spam 本质上是一个简写版本。相当于’color’ in spam.keys()

5.1.4 get()方法

在访问一个键的值之前，检查该键是否存在于字典中，这很麻烦。好在，字典有一个 get()方法，它有两个参数：要取得其值的键，以及如果该键不存在时，返回的备用值。

picnicItems = {‘apples’: 5, ‘cups’: 2}

’I am bringing ’ + str(picnicItems.get(‘eggs’, 0)) + ’ eggs.'

‘I am bringing 0 eggs.’

因为 picnicItems 字典中没有’egg’键，get()方法返回的默认值是 0。不使用 get()，代码就会产生一个错误消息，就像下面的例子：

>>> 'I am bringing ’ + str(picnicItems[‘eggs’]) + ’ eggs.'

Traceback (most recent call last):

File “<pyshell#34>”, line 1, in

‘I am bringing ’ + str(picnicItems[‘eggs’]) + ’ eggs.’

KeyError: ‘eggs’

5.1.5 setdefault()方法

setdefault()方法提供了一种方式，在一行中完成这件事。传递给该方法的第一个参数，是要检查的键。第二个参数，是如果该键不存在时要设置的值。如果该键确实存在，方法就会返回键的值。

>>> spam = {‘name’: ‘Pooka’, ‘age’: 5}

>>> spam.setdefault(‘color’, ‘black’)

‘black’

>>> spam

{‘color’: ‘black’, ‘age’: 5, ‘name’: ‘Pooka’}

>>> spam.setdefault(‘color’, ‘white’)

‘black’

>>> spam

{‘color’: ‘black’, ‘age’: 5, ‘name’: ‘Pooka’}

setdefault()方法是一个很好的快捷方式，可以确保一个键存在。

例子

message = 'It was a bright cold day in April, and the clocks were striking thirteen.'
count = {}
for character in message:
 count.setdefault(character, 0)
 count[character] = count[character] + 1
print(count)

统计词频

结果{‘I’: 1, ‘t’: 6, ’ ': 13, ‘w’: 2, ‘a’: 4, ‘s’: 3, ‘b’: 1, ‘r’: 5, ‘i’: 6, ‘g’: 2, ‘h’: 3, ‘c’: 3, ‘o’: 2, ‘l’: 3, ‘d’: 3, ‘y’: 1, ‘n’: 4, ‘A’: 1, ‘p’: 1, ‘,’: 1, ‘e’: 5, ‘k’: 2, ‘.’: 1}

5.2 漂亮打印

中导入 pprint 模块，就可以使用 pprint()和 pformat()函数，它们将“漂亮打印”一个字典的字。如果想要字典中表项的显示比 print()的输出结果更干净，这就有用了。

import pprint
message = 'It was a bright cold day in April, and the clocks were striking
thirteen.'
count = {}
for character in message:
 count.setdefault(character, 0)
 count[character] = count[character] + 1
pprint.pprint(count)

字典本身包含嵌套的列表或字典，pprint.pprint()函数就特别有用。

希望得到漂亮打印的文本作为字符串，而不是显示在屏幕上，那就调用 pprint.pformat()

pprint.pprint(someDictionaryValue)

print(pprint.pformat(someDictionaryValue))

5.3 使用数据结构对真实世界建模

5.3.1 井字棋盘

theBoard = {'top-L': 'O', 'top-M': 'O', 'top-R': 'O', 'mid-L': 'X', 'mid-M':
'X', 'mid-R': ' ', 'low-L': ' ', 'low-M': ' ', 'low-R': 'X'}
def printBoard(board):
 print(board['top-L'] + '|' + board['top-M'] + '|' + board['top-R'])
 print('-+-+-')
 print(board['mid-L'] + '|' + board['mid-M'] + '|' + board['mid-R'])
 print('-+-+-')
 print(board['low-L'] + '|' + board['low-M'] + '|' + board['low-R'])
printBoard(theBoard)

5.3.2 嵌套的字典和列表

对复杂的事物建模时，可能发现字典和列表中需要包含其他字典和列表。列表适用于包

含一组有序的值，字典适合于包含关联的键与值

allGuests = {'Alice': {'apples': 5, 'pretzels': 12},
 'Bob': {'ham sandwiches': 3, 'apples': 2},
 'Carol': {'cups': 3, 'apple pies': 1}}
def totalBrought(guests, item):
  numBrought = 0
  for k, v in guests.items():
   numBrought = numBrought + v.get(item, 0)
  return numBrought
print('Number of things being brought:')
print(' - Apples ' + str(totalBrought(allGuests, 'apples')))
print(' - Cups ' + str(totalBrought(allGuests, 'cups')))
print(' - Cakes ' + str(totalBrought(allGuests, 'cakes')))
print(' - Ham Sandwiches ' + str(totalBrought(allGuests, 'ham sandwiches')))
print(' - Apple Pies ' + str(totalBrought(allGuests, 'apple pies')))

编程任务

def displayInventory(inventory):
  print("Inventory:")
  item_total = 0
  for k, v in inventory.items():
    print(str(v) + ' ' + k)
    item_total += v
  print("Total number of items: " + str(item_total))
def addToInventory(inventory, addedItems):
 for i in addedItems:
   if i in inventory :
    inventory[i]=inventory[i]+1
   else:
    inventory.setdefault(i, 1)
 return inventory

inv = {'gold coin': 42, 'rope': 1}
dragonLoot = ['gold coin', 'dagger', 'gold coin', 'gold coin', 'ruby']
inv = addToInventory(inv, dragonLoot)
displayInventory(inv)

2．{‘foo’: 42}

3．保存在字典中的项是无序的，而列表中的项是有序的。

4．会得到 KeyError 错误。

5．没有区别。in 操作符检查一个值是不是字典中的一个键。

6．‘cat’ in spam 检查字典中是不是有一个 ‘cat’ 键，而’cat’ in spam.values() 检查是

否有一个值 ‘cat’ 对应于 spam 中的某个键。

7．spam.setdefault(‘color’, ‘black’)

8．pprint.pprint()

第六章 字符串操作

6.1 处理字符串

6.1.1 字符串字面量

字符串以单引号开始和结束

6.1.2 双引号

字符串可以用双引号开始和结束，就像用单引号一样。使用双引号的一个好处，就是字符串中可以使用单引号字符。

6.1.3 转义字符

转义字符	打印为
’	单引号
"	双引号
\t	制表符
\n	换行符
\	倒斜杠

6.1.4 原始字符串

可以在字符串开始的引号之前加上 r，使它成为原始字符串。“原始字符串”完全忽略所有的转义字符，打印出字符串中所有的倒斜杠。

>>> print(r’That is Carol’s cat.’)

That is Carol’s cat.

6.1.5 用三重引号的多行字符串

在 Python 中，多行字符串的起止是 3 个单引号或 3 个双引号。“三重引号”之间的所有引号、制表符或换行，都被认为是字符串的一部分。Python 的代码块缩进规则不适用于多行字符串。

print('''Dear Alice,
Eve's cat has been arrested for catnapping, cat burglary, and extortion. 
Sincerely,
Bob''')

结果:

Dear Alice,

Eve’s cat has been arrested for catnapping, cat burglary, and extortion.

Sincerely,

Bob

Eve’s 中的单引号字符不需要转义。在原始字符串中，转义单引号和双引号是可选的。

6.1.6 多行注释

虽然井号字符（#）表示这一行是注释，但多行字符串"""常常用作多行注释。

"""This is a test Python program.
Written by Al Sweigart al@inventwithpython.com
This program was designed for Python 3, not Python 2.
"""

6.1.7 字符串下标和切片

>>> spam = 'Hello world!'
>>> spam[0]
'H'
>>> spam[4]
'o'
>>> spam[-1]
'!'
>>> spam[0:5]
'Hello'
>>> spam[:5]
'Hello'
>>> spam[6:]
'world!'

请注意，字符串切片并没有修改原来的字符串。可以从一个变量中获取切片，记录在另一个变量中。

6.1.8 字符串的 in 和 not in 操作符

测试第一个字符串（精确匹配，区分大小写）是否在第二个字符串中。

6.2 有用的字符串方法

6.2.1 字符串方法 upper()、lower()、isupper()和 islower()

upper()和 lower()字符串方法返回一个新字符串，其中原字符串的所有字母都被相应地转换为大写或小写。字符串中非字母字符保持不变。

如果需要进行大小写无关的比较，upper()和 lower()方法就很有用。

print('How are you?')
feeling = input()
if feeling.lower() == 'great':
 print('I feel great too.')
else:
 print('I hope the rest of your day is good.')

如果字符串至少有一个字母，并且所有字母都是大写或小写，isupper()和 islower()方法就会相应地返回布尔值 True。判断字符串是否都是大写或者小写

6.2.2 isX 字符串方法

 isalpha()返回 True，如果字符串只包含字母，并且非空；

 isalnum()返回 True，如果字符串只包含字母和数字，并且非空；

 isdecimal()返回 True，如果字符串只包含数字字符，并且非空；

 isspace()返回 True，如果字符串只包含空格、制表符和换行，并且非空；

 istitle()返回 True，如果字符串仅包含以大写字母开头、后面都是小写字母的单词。

如果需要验证用户输入，isX 字符串方法是有用的。

6.2.3 字符串方法 startswith()和 endswith()

检查字符串的开始或结束部分是否等于另一个字符串，而不是整个字符串

如果一致则startswith()和 endswith()方法返回 True，如果它们所调用的字符串以该方法传入

的字符串开始或结束。否则，方法返回 False。

6.2.4 字符串方法 join()和 split()

如果有一个字符串列表，需要将它们连接起来，成为一个单独的字符串，join()方法就很有用。join()方法在一个字符串上调用，参数是一个字符串列表，返回一个字符串。返回的字符串由传入的列表中每个字符串连接而成。

>>> ', '.join(['cats', 'rats', 'bats'])
'cats, rats, bats'
>>> ' '.join(['My', 'name', 'is', 'Simon'])
'My name is Simon'
>>> 'ABC'.join(['My', 'name', 'is', 'Simon'])
'MyABCnameABCisABCSimon'

要记住，join()方法是针对一个字符串而调用的，并且传入一个列表值（很容易不小心用其他的方式调用它）。split()方法做的事情正好相反：它针对一个字符串调用，返回一个字符串列表。

>>> 'My name is Simon'.split()
['My', 'name', 'is', 'Simon']

字符串’My name is Simon’按照各种空白字符分割，诸如空格、制表符或换行符。这些空白字符不包含在返回列表的字符串中。也可以向 split()方法传入一个分割字符串，指定它按照不同的字符串分割。

>>> 'MyABCnameABCisABCSimon'.split('ABC') 
['My', 'name', 'is', 'Simon']
>>> 'My name is Simon'.split('m')
['My na', 'e is Si', 'on']

6.2.5 用 rjust()、ljust()和 center()方法对齐文本

rjust()和 ljust()字符串方法返回调用它们的字符串的填充版本，通过插入空格来对齐文本。这两个方法的第一个参数是一个整数长度，用于对齐字符串。

>>> 'Hello'.rjust(10)
' Hello' 
>>> 'Hello'.rjust(20)
' Hello'
>>> 'Hello World'.rjust(20)
' Hello World' 
>>> 'Hello'.ljust(10)
'Hello

rjust()和 ljust()方法的第二个可选参数将指定一个填充字符，取代空格字符。

>>> 'Hello'.rjust(20, '*')
'***************Hello'
>>> 'Hello'.ljust(20, '-')
'Hello---------------'

center()字符串方法与 ljust()与 rjust()类似，但它让文本居中，而不是左对齐或右对齐。

如果需要打印表格式数据，留出正确的空格，这些方法就特别有用。

def printPicnic(itemsDict, leftWidth, rightWidth):
 print('PICNIC ITEMS'.center(leftWidth + rightWidth, '-'))
 for k, v in itemsDict.items():
 print(k.ljust(leftWidth, '.') + str(v).rjust(rightWidth)) 
picnicItems = {'sandwiches': 4, 'apples': 12, 'cups': 4, 'cookies': 8000}
printPicnic(picnicItems, 12, 5)
printPicnic(picnicItems, 20, 6)

6.2.6 用 strip()、rstrip()和 lstrip()删除空白字符

删除字符串左边、右边或两边的空白字符（空格、制表符和换行符）。strip()字符串方法将返回一个新的字符串，它的开头或末尾都没有空白字符。 lstrip()和 rstrip()方法将相应删除左边或右边的空白字符。

>>> spam = ' Hello World '
>>> spam.strip()
'Hello World'
>>> spam.lstrip()
'Hello World '
>>> spam.rstrip()
' Hello World'

向 strip()方法传入参数’ampS’，告诉它在变量中存储的字符串两端，删除出现的 a、m、p 和大写的 S。传入 strip()方法的字符串中，字符的顺序并不重要：strip(‘ampS’) 做的事情和 strip(‘mapS’)或 strip(‘Spam’)一样。

>>> spam = 'SpamSpamBaconSpamEggsSpamSpam'
>>> spam.strip('ampS')
'BaconSpamEggs'

6.2.7 用 pyperclip 模块拷贝粘贴字符串

pyperclip 模块有 copy()和 paste()函数，可以向计算机的剪贴板发送文本，或从它接收文本。将程序的输出发送到剪贴板，使它很容易粘贴到邮件、文字处理程序或其他软件中。pyperclip 模块不是 Python 自带的。要安装它

6.3 项目口令保管箱

PASSWORDS = {'email': 'F7minlBDDuvMJuxESSKHFhTxFtjVB6',
             'blog': 'VmALvQyKAxiVH5G8v01if1MLZF3sdt',
             'luggage': '12345'}

import sys, pyperclip
#判断输入参数是否有问题 helloworld.py blog
if len(sys.argv) < 2:
    print('Usage: py pw.py [account] - copy account password')
    sys.exit()
#将查询的键传给account
account = sys.argv[1]  # first command line arg is the account name

if account in PASSWORDS:#查询是否有account的键
    pyperclip.copy(PASSWORDS[account])
    #复制给剪贴板
    print('Password for ' + account + ' copied to clipboard.')
else:
    print('There is no account named ' + account)

启动命令：helloworld.py blog

6.4 将剪贴板内容变成无序列表

import pyperclip

text = pyperclip.paste()

# Separate lines and add stars.
lines = text.split('\n')
for i in range(len(lines)):  # loop through all indexes for "lines" list
    lines[i] = '* ' + lines[i]  # add star to each string in "lines" list
text = '\n'.join(lines)
pyperclip.copy(text)

1．转义字符表示字符串中的一些字符，这些字符用别的方式很难在代码中打出来。
2．\n 是换行符，\t 是制表符。
3．\转义字符表示一个反斜杠。
4．Howl’s 中的单引号没有问题，因为你用了双引号来标识字符串的开始和结束。
5．多行字符串让你在字符串中使用换行符，而不必用\n 转义字符。
6．这些表达式求值为以下值：
• ‘e’
• ‘Hello’
• ‘Hello’
• 'lo world!
7．这些表达式求值为以下值：
• ‘HELLO’
• True
• ‘hello’
8．这些表达式求值为以下值：
• [‘Remember,’, ‘remember,’, ‘the’, ‘fifth’, ‘of’, ‘November.’]
• ‘There-can-be-only-one.’
9．分别用 rjust()、ljust() 和 center() 字符串方法。
10．lstrip() 和 rstrip() 方法分别从字符串的左边和右边移除空白字符。

编程作业

def printTable(tableData):
    colWidths = [0] * len(tableData)
    for i in range(len(colWidths)):
        colWidths[i] = max(len(tableData[i][0]), len(tableData[i][1]), len(tableData[i][2]), len(tableData[i][3]))
    for j in range(len(tableData[0])):
        for k in range(len(tableData)):
            print(tableData[k][j].rjust(colWidths[k]),end=' ')
        print()

tableData = [['apples', 'oranges', 'cherries', 'banana'],
             ['Alice', 'Bob', 'Carol', 'David'],
             ['dogs', 'cats', 'moose', 'goose']]
printTable(tableData)