导图社区 Python编程快速上手
- 1.2k
- 123
- 12
- 举报
Python编程快速上手
Python编程快速上手思维导图，该导图内容包含了控制流、函数、列表、字典和结构化数据等等五大重点内容。这在学python，而这本书第一部分是相对简单的。学完后可以初步的进行实战训练了
提示: 本内容由社区用户上传并分享。平台不对内容的真实性、合法性、知识产权归属及是否侵害第三方权利进行事前审核或保证。本内容可能包含受版权保护的图片、字体或其他第三方素材，使用前请自行确认授权范围。
- 相似推荐
- 大纲
Python 编程快速上手
Python 基础
I. 控 制 流
1. 布尔值
>>> spam = True >>> spam True
2. 比较操作符
== != < > <= >=
3. 布尔操作符
二元布尔操作符
and 和 or 操作符总是接受两个布尔值（或表达式），所以它们被认为是“二元”操作符。 >>> True and True True >>> True and False False 表达式 求值为 True or True True True or False True False or True True False or False False
not 操作符
>>> not True False >>> not not not not True True
4. 混合布尔和比较操作符
>>> (4 < 5) and (5 < 6) True >>> (4 < 5) and (9 < 6) False
5. 控制流的元素
条件
代码块
6. 程序执行
7. 控制流语句
if 语句
else 语句
elif 语句
while 循环语句
break 语句
continue 语句
for 循环和 range()函数
range()的开始、停止和步长参数
for i in range(12, 16): print(i) 12 13 14 15 for i in range(0, 10, 2): print(i) 0 2 4 6 8 for i in range(5, -1, -1): print(i) 5 4 3 2 1 0
8. 导入模块
import 关键字
9. 用 sys.exit()提前结束程序
import sys while True: print('Type exit to exit.') response = input() if response == 'exit': sys.exit() print('You typed ' + response + '.')
II. 函 数
1. def语句和参数
2. 返回值和 return 语句
3. None 值
4. 关键字参数和 print()

5. 局部和全局作用域
局部变量不能在全局作用域内使用 局部作用域不能使用其他局部作用域内的变量 全局变量可以在局部作用域中读取
名称相同的局部变量和全局变量
要想生活简单，就要避免局部变量与全局变量或其他局部变量同名。但在技术上，在 Python 中让局部变量和全局变量同名是完全合法的。为了看看实际发生的情 况，请在文件编辑器中输入以下代码，并保存为 sameName.py： 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 个不同的变量，但令人迷惑的是，它们都名为 eggs。 这些变量是： 名为 eggs 的变量，存在于 spam()被调用时的局部作用域； 名为 eggs 的变量，存在于 bacon()被调用时的局部作用域； 名为 eggs 的变量，存在于全局作用域。 因为这 3 个独立的变量都有相同的名字，追踪某一个时刻使用的是哪个变量， 可能比较麻烦。这就是应该避免在不同作用域内使用相同变量名的原因。
global 语句
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．但是，如果该变量没有用在赋值语句中，它就是全局变量。
6. 异常处理
错误可以由 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 print(spam(1))从未被执行是因为，一旦执行跳到 except 子句的代码，就不会回到 try 子句。它会继续照常向下执行
7. 习题
1．为什么在程序中加入函数会有好处？ 2．函数中的代码何时执行：在函数被定义时，还是在函数被调用时？ 3．什么语句创建一个函数？ 4．一个函数和一次函数调用有什么区别？ 5．Python 程序中有多少全局作用域？有多少局部作用域？ 6．当函数调用返回时，局部作用域中的变量发生了什么？ 7．什么是返回值？返回值可以作为表达式的一部分吗？ 8．如果函数没有返回语句，对它调用的返回值是什么？ 9．如何强制函数中的一个变量指的是全局变量？ 10．None 的数据类型是什么？ 11．import areallyourpetsnamederic 语句做了什么？ 12．如果在名为 spam的模块中，有一个名为 bacon()的函数，在引入 spam后， 如何调用它？ 13．如何防止程序在遇到错误时崩溃？ 14．try 子句中发生了什么？except 子句中发生了什么？
8. 实践项目
Collatz 序列
编写一个名为 collatz()的函数，它有一个名为 number 的参数。如果参数是偶数， 那么 collatz()就打印出 number // 2，并返回该值。如果 number 是奇数，collatz()就打 印并返回 3 * number + 1。 然后编写一个程序，让用户输入一个整数，并不断对这个数调用 collatz()，直 到函数返回值１（令人惊奇的是，这个序列对于任何整数都有效，利用这个序列， 你迟早会得到 1！既使数学家也不能确定为什么。你的程序在研究所谓的“Collatz 序列”，它有时候被称为“最简单的、不可能的数学问题”）。记得将 input()的返回值用 int()函数转成一个整数，否则它会是一个字符串。
输入验证
在前面的项目中添加 try 和 except 语句，检测用户是否输入了一个非整数的字 符串。正常情况下，int()函数在传入一个非整数字符串时，会产生ValueError 错误， 比如 int('puppy')。在 except 子句中，向用户输出一条信息，告诉他们必须输入一个 整数。
III. 列 表
1. 列表数据类型
用下标取得列表中的单个值
负数下标
利用切片取得子列表
>>> spam = ['cat', 'bat', 'rat', 'elephant'] >>> spam[0:4] ['cat', 'bat', 'rat', 'elephant'] >>> spam[1:3] ['bat', 'rat'] >>> spam[0:-1] ['cat', 'bat', 'rat']
用 len()取得列表的长度
用下标改变列表中的值
列表连接和列表复制
>>> [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']
用 del 语句从列表中删除值
>>> spam = ['cat', 'bat', 'rat', 'elephant'] >>> del spam[2] >>> spam ['cat', 'bat', 'elephant'] >>> del spam[2] >>> spam ['cat', 'bat'] >>> del spam >>> spam 错误
2. 使用列表
列表用于循环
in 和 not in 操作符
>>> 'howdy' in ['hello', 'hi', 'howdy', 'heyas'] True >>> spam = ['hello', 'hi', 'howdy', 'heyas'] >>> 'cat' in spam False
多重赋值技巧
>>> cat = ['fat', 'black', 'loud'] >>> size, color, disposition = cat 变量的数目和列表的长度必须严格相等，否则 Python 将给出ValueError
3. 增强的赋值操作
spam += 1 spam -= 1 spam *= 1 spam /= 1 spam %= 1
4. 方法
index()方法在列表中查找值
>>> spam = ['hello', 'hi', 'howdy', 'heyas'] >>> spam.index('hello') 0 >>> spam.index('heyas') 3 如果列表中存在重复的值，就返回它第一次出现的下标。在交互式环境中输入 以下代码，注意 index()返回 1，而不是 3： >>> spam = ['Zophie', 'Pooka', 'Fat-tail', 'Pooka'] >>> spam.index('Pooka') 1
append()和 insert()方法在列表中添加值
append()方法调用，将参数添加到列表末尾 >>> spam = ['cat', 'dog', 'bat'] >>> spam.append('moose') >>> spam ['cat', 'dog', 'bat', 'moose'] insert()方法可以在列表任意下标处插入一个值 >>> spam = ['cat', 'dog', 'bat'] >>> spam.insert(1, 'chicken') >>> spam ['cat', 'chicken', 'dog', 'bat'] 请注意，代码是 spam.append('moose')和 spam.insert(1, 'chicken')，而不是 spam =spam.append('moose')和 spam = spam.insert(1, 'chicken') append()和 insert()方法是列表方法，只能在列表上调用，不能在其他值上调用
remove()方法从列表中删除值
给 remove()方法传入一个值，它将从被调用的列表中删除。 >>> spam = ['cat', 'bat', 'rat', 'elephant'] >>> spam.remove('bat') >>> spam ['cat', 'rat', 'elephant'] 试图删除列表中不存在的值，将导致ValueError 错误。 如果该值在列表中出现多次，只有第一次出现的值会被删除。 如果知道想要删除的值在列表中的下标，del 语句就很好用
sort()方法将列表中的值排序
数值的列表或字符串的列表，能用 sort()方法排序 >>> spam = [2, 5, 3.14, 1, -7] >>> spam.sort() >>> spam [-7, 1, 2, 3.14, 5] >>> spam = ['ants', 'cats', 'dogs', 'badgers', 'elephants'] >>> spam.sort() >>> spam ['ants', 'badgers', 'cats', 'dogs', 'elephants'] 也可以指定 reverse 关键字参数为True，让 sort()按逆序排序 >>> spam.sort(reverse=True) >>> spam ['elephants', 'dogs', 'cats', 'badgers', 'ants'] 不要写出 spam = spam.sort()这样的代码，试图记录返回值 不能对既有数字又有字符串值的列表排序 sort()方法对字符串排序时，使用“ASCII 字符顺序”，而不是实际的字典顺序。这意味着大写字母排在小写字母之前。因此在排序时，小写的 a 在大写的 Z之后。如果需要按照普通的字典顺序来排序，就在 sort()方法调用时，将关键字参数 key 设置为 str.lower
5. 例子程序：神奇 8 球和列表
6. 类似列表的类型：字符串和元组
可变和不可变数据类型
但列表和字符串在一个重要的方面是不同的。列表是“可变的”数据类型，它的值可以添加、删除或改变。但是，字符串是“不可变的”，它不能被更改。 “改变”一个字符串的正确方式，是使用切片和连接。构造一个“新的”字符串，从老的字符串那里复制一些部分。
元组数据类型
除了两个方面，“元组”数据类型几乎与列表数据类型一样。首先，元组输入时用圆括号()，而不是用方括号[]。但元组与列表的主要区别还在于，元组像字符串一样，是不可变的。 如果元组中只有一个值，你可以在括号内该值的后面跟上一个逗号，表明这种情况。否则，Python 将认为，你只是在一个普通括号内输入了一个值。逗号告诉 Python，这是一个元组 >>> type(('hello',)) <class 'tuple'> >>> type(('hello')) <class 'str'>
用 list()和 tuple()函数来转换类型
>>> tuple(['cat', 'dog', 5]) ('cat', 'dog', 5) >>> list(('cat', 'dog', 5)) ['cat', 'dog', 5] >>> list('hello') ['h', 'e', 'l', 'l', 'o']
7. 引用
传递引用
当函数被调用时，参数的值被复制给变元。对于列表（以及字典，我将在下一章中讨论），这意味着变元得到的 是引用的拷贝。 def eggs(someParameter): someParameter.append('Hello') spam = [1, 2, 3] eggs(spam) print(spam) [1, 2, 3, 'Hello'] 请注意，当 eggs()被调用时，没有使用返回值来为 spam赋新值。相反，它直接当场修改了该列表。 尽管spam和someParameter 包含了不同的引用，但它们都指向相同的列表。这就是为什么函数内的append('Hello')方法调用在函数调用返回后，仍然会对该列表产生影响。
copy 模块的 copy()和 deepcopy()函数
Python 提供了名为 copy 的模块，其中包含 copy()和 deepcopy()函数。第一个函数 copy.copy()，可以用来复制列表或字典这样的可变值，而不只是复制引用。 >>> import copy >>> spam = ['A', 'B', 'C', 'D'] >>> cheese = copy.copy(spam) >>> cheese[1] = 42 >>> spam ['A', 'B', 'C', 'D'] >>> cheese ['A', 42, 'C', 'D'] 如果要复制的列表中包含了列表，那就使用 copy.deepcopy()函数来代替
8. 习题
1．什么是[]？ 2．如何将'hello'赋给列表的第三个值，而列表保存在名为 spam的变量中？（假定变量包含[2, 4, 6, 8, 10]）。 对接下来的 3 个问题，假定 spam包含列表['a', 'b', 'c', 'd']。 3．spam[int('3' * 2) / 11]求值为多少？ d 4．spam[-1]求值为多少？ 5．spam[:2]求值为多少？ 对接下来的 3 个问题。假定 bacon 包含列表[3.14, 'cat', 11, 'cat', True]。 6．bacon.index('cat')求值为多少？ 7．bacon.append(99)让 bacon 中的列表值变成什么样？ 8．bacon.remove('cat')让 bacon 中的列表时变成什么样？ 9．列表连接和复制的操作符是什么？ 10．append()和 insert()列表方法之间的区别是什么？ 11．从列表中删除值有哪两种方法？ 12．请说出列表值和字符串的几点相似之处。 13．列表和元组之间的区别是什么？ 14．如果元组中只有一个整数值 42，如何输入该元组？ 15．如何从列表值得到元组形式？如何从元组值得到列表形式？ 16．“包含”列表的变量，实际上并未真地直接包含列表。它们包含的是什么？ 17．copy.copy()和 copy.deepcopy()之间的区别是什么？
9. 实践项目
第一题 def a(object): b='' object[len(object)-1]='and cats' for i in range(len(object)): b=b+', '+object[i] return b[2:] print(a(spam)) 第二题 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', '.', '.', '.'], ['.', '.', '.', '.', '.', '.']] for i in range(9): for x in range(9): print(grid[x][i],end='') print('\n')
IV. 字典和结构化数据
1. 样式
样式 myCat = {'size': 'fat', 'color': 'gray', 'disposition': 'loud'}
访问 myCat['size']
字典仍然可以用整数值作为键，就像列表使用整数值作为下标一样 但它们不必从 0 开始，可以是任何数字。 spam = {12345: 'Luggage Combination', 42: 'The Answer'}
2. 字典与列表
不排序
eggs = {'name': 'Zophie', 'species': 'cat', 'age': '8'} ham = {'species': 'cat', 'age': '8', 'name': 'Zophie'} eggs == ham True
返回类似列表的值
键 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 k in spam.keys(): print(k) color age for i in spam.items(): print(i) ('color', 'red') ('age', 42) 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
3. in
spam = {'name': 'Zophie', 'age': 7} 'color' in spam False 'color' in spam本质上是一个简写版本。相当于'color' in spam.keys()
4. get()：有两个参数，要取得其值的键；如果该键不存在，返回备用值。
picnicItems = {'apples': 5, 'cups': 2} 'I am bringing ' + str(picnicItems.get('cups', 0)) + ' cups.' 'I am bringing 2 cups.' 'I am bringing ' + str(picnicItems.get('eggs', 0)) + ' eggs.' 'I am bringing 0 eggs.'
5. 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'} 程序循环迭代message 字符串中的每个字符，计算每个字符出现的次数 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}
综合练习 计算所有客人带来的食物的总数。 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')))
Number of things being brought: - Apples 7 - Cups 3 - Cakes 0 - Ham Sandwiches 3 - Apple Pies 1
6. 习题
1．空字典的代码是怎样的？ 2．一个字典包含键'fow'和值 42，看起来是怎样的？ 3．字典和列表的主要区别是什么？ 4．如果 spam是{'bar': 100}，你试图访问 spam['foo']，会发生什么？ 5．如果一个字典保存在 spam中，表达式'cat' in spam和'cat' in spam.keys()之间 的区别是什么？ 6．如果一个字典保存在变量中，表达式'cat' in spam和'cat' in spam.values()之间 的区别是什么？ 7．下面代码的简洁写法是什么？ if 'color' not in spam: spam['color'] = 'black'
7. 项目
第一题 好玩游戏的物品清单 你在创建一个好玩的视频游戏。 用于对玩家物品清单建模的数据结构是一个字典。其中键是字符串，描述清单中的物品，值是一个整型值，说明玩家有多少该物 品。例如，字典值{'rope': 1, 'torch': 6, 'gold coin': 42, 'dagger': 1, 'arrow': 12}意味着玩 家有 1 条绳索、6 个火把、42 枚金币等。 写一个名为displayInventory()的函数，它接受任何可能的物品清单，并显示如下： Inventory: 12 arrow 42 gold coin 1 rope 6 torch 1 dagger Total number of items: 62 第二题 列表到字典的函数，针对好玩游戏物品清单 假设征服一条龙的战利品表示为这样的字符串列表： dragonLoot = ['gold coin', 'dagger', 'gold coin', 'gold coin', 'ruby'] 写一个名字为addToInventory(inventory, addedItems)的函数，其中 inventory 参数是一个字典，表示玩家的物品清单（像前面项目一样），addedItems 参数是一个列表， 就像 dragonLoot。 addToInventory()函数应该返回一个字典，表示更新过的物品清单。请注意，列表可以包含多个同样的项。你的代码看起来可能像这样： def addToInventory(inventory, addedItems): # your code goes here inv = {'gold coin': 42, 'rope': 1} dragonLoot = ['gold coin', 'dagger', 'gold coin', 'gold coin', 'ruby'] inv = addToInventory(inv, dragonLoot) displayInventory(inv) 前面的程序（加上前一个项目中的displayInventory()函数）将输出如下： Inventory: 45 gold coin 1 rope 1 ruby 1 dagger Total number of items: 48
V. 字符串操作
1. 处理字符串
单双引号
字符串以单引号开始和结束，如果里面有单引号可以用双引号开始和结束。 如果在字符串中既需要使用单引号又需要使用双引号， 那就要使用转义字符。
转义字符
表 6-1 转义字符 转义字符 \' 单引号 \" 双引号 \t 制表符 \n 换行符 \\ 倒斜杠
原始字符串
可以在字符串开始的引号之前加上 r，使它成为原始字符串。“原始字符串”完 全忽略所有的转义字符，打印出字符串中所有的倒斜杠。 print(r'That is Carol\'s cat.') That is Carol\'s cat.
用三重引号的多行字符串
“三重引号”之间的 所有引号、制表符或换行，都被认为是字符串的一部分。
多行注释
井号字符（#）表示这一行是注释，但多行字符（“”“ ”“”）串常常用作多行注释。
字符串下标和切片
字符串的 in 和 not in 操作符
2. 处理函数
upper()
全部单词转大写
lower()
全部单词转小写
isupper()
判断全部单词是大写
islower()
判断全部单词是小写
spam = 'Hello world!' spam.islower() False spam.isupper() False 'HELLO'.isupper() True 'abc12345'.islower() True '12345'.islower() False '12345'.isupper() False 'Hello'.upper() 'HELLO' 'Hello'.upper().lower() 'hello' 'Hello'.upper().lower().upper() 'HELLO' 'HELLO'.lower() 'hello' 'HELLO'.lower().islower() True
startswith()
endswith()
如果只需要检查字符串的开始或结束部分是否等于另一个字符串， 而不是整个 字符串，这些方法就可以替代等于操作符==，这很有用。
>>> 'Hello world!'.startswith('Hello') True >>> 'Hello world!'.endswith('world!') True >>> 'abc123'.startswith('abcdef') False >>> 'abc123'.endswith('12') False >>> 'Hello world!'.startswith('Hello world!') True >>> 'Hello world!'.endswith('Hello world!') True
join()
有一个字符串列表，需要将它们连接起来，成为一个单独的字符串
>>> ', '.join(['cats', 'rats', 'bats']) 'cats, rats, bats' >>> ' '.join(['My', 'name', 'is', 'Simon']) 'My name is Simon' >>> 'ABC'.join(['My', 'name', 'is', 'Simon']) 'MyABCnameABCisABCSimon'
split()
它针对一个字符串调 用，返回一个字符串列表。
>>> 'My name is Simon'.split() ['My', 'name', 'is', 'Simon'] >>> 'MyABCnameABCisABCSimon'.split('ABC') ['My', 'name', 'is', 'Simon'] >>> 'My name is Simon'.split('m') ['My na', 'e is Si', 'on'] >>> spam = '''Dear Alice, How have you been? I am fine. There is a container in the fridge that is labeled "Milk Experiment". Please do not drink it. Sincerely, Bob''' >>> spam.split('\n') ['Dear Alice,', 'How have you been? I am fine.', 'There is a container in the fridge', 'that is labeled "Milk Experiment".', '', 'Please do not drink it.', 'Sincerely,', 'Bob']
rjust()
ljust()
>>> 'Hello'.rjust(10) ' Hello' >>> 'Hello'.rjust(20) ' Hello' >>> 'Hello'.ljust(10) 'Hello ' 'Hello'.rjust(10)是说我们希望右对齐，将'Hello'放在一个长度为 10 的字符串中。 'Hello'有 5 个字符，所以左边会加上 5 个空格，得到一个 10 个字符的字符串，实现 'Hello'右对齐。 rjust()和 ljust()方法的第二个可选参数将指定一个填充字符，取代空格字符。在交互式环境中输入以下代码： >>> 'Hello'.rjust(20, '*') '***************Hello' >>> 'Hello'.ljust(20, '-') 'Hello---------------'
center()
>>> 'Hello'.center(20) 'Hello ' >>> 'Hello'.center(20, '=') '=======Hello========'
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)
strip()
rstrip()
lstrip()
strip()字符串方法将返回一个新的字符串，它的开头或末尾都没有空白字符。 lstrip()和 rstrip()方法将相应删除左边或右边的空白字符。
>>> spam = ' Hello World ' >>> spam.strip() 'Hello World' >>> spam.lstrip() 'Hello World ' >>> spam.rstrip() ' Hello World' >>> spam = 'SpamSpamBaconSpamEggsSpamSpam' >>> spam.strip('ampS') 'BaconSpamEggs' 向 strip()方法传入参数'ampS'，告诉它在变量中存储的字符串两端，删除出现的a、m、p 和大写的 S。传入 strip()方法的字符串中，字符的顺序并不重要：strip('ampS') 做的事情和 strip('mapS')或 strip('Spam')一样。
pyperclip 模块
copy()函数
paste()函数
>>> import pyperclip >>> pyperclip.copy('Hello world!') >>> pyperclip.paste() 'Hello world!'
3. 项目：口令保管箱
你可能在许多不同网站上拥有账号，每个账号使用相同的口令是个坏习惯。如果这些网站中任何一个有安全漏洞，黑客就会知道你所有的其他账号的口令。最好 是在你的计算机上，使用口令管理器软件，利用一个主控口令，解锁口令管理器。 然后将某个账户口令拷贝到剪贴板，再将它粘贴到网站的口令输入框。 你在这个例子中创建的口令管理器程序并不安全，但它基本展示了这种程序的工作原理。
4. 项目：在 Wiki 标记中添加无序列表
在编辑一篇维基百科的文章时，你可以创建一个无序列表，即让每个列表项占据一行，并在前面放置一个星号。 但是假设你有一个非常大的列表，希望添加前面 的星号。 你可以在每一行开始处输入这些星号，一行接一行。或者也可以用一小段 Python 脚本，将这个任务自动化。 bulletPointAdder.py 脚本将从剪贴板中取得文本，在每一行开始处加上星号和空格，然后将这段新的文本贴回到剪贴板。 例如，如果我将下面的文本复制到剪贴板 （取自于维基百科的文章“List of Lists of Lists”）： Lists of animals Lists of aquarium life Lists of biologists by author abbreviation Lists of cultivars 然后运行 bulletPointAdder.py 程序，剪贴板中就会包含下面的内容： * Lists of animals * Lists of aquarium life * Lists of biologists by author abbreviation * Lists of cultivars 这段前面加了星号的文本，就可以粘贴回维基百科的文章中，成为一个无序列表。
5. 习题
1．什么是转义字符？ 2．转义字符\n 和\t 代表什么？ 3．如何在字符串中放入一个倒斜杠字符\？ 4．字符串"Howl's Moving Castle"是有效字符串。为什么单词中的单引号没有转义，却没有问题？ 5．如果你不希望在字符串中加入\n，怎样写一个带有换行的字符串？ 6．下面的表达式求值为什么？ • 'Hello world!'[1] • 'Hello world!'[0:5] • 'Hello world!'[:5] • 'Hello world!'[3:] 7．下面的表达式求值为什么？ • 'Hello'.upper() • 'Hello'.upper().isupper() • 'Hello'.upper().lower() 8．下面的表达式求值为什么？ • 'Remember, remember, the fifth of November.'.split() • '-'.join('There can be only one.'.split()) 9．什么字符串方法能用于字符串右对齐、左对齐和居中？ 10．如何去掉字符串开始或末尾的空白字符？
6. 项目
编写一个名为 printTable()的函数，它接受字符串的列表的列表，将它显示在组织良好的表格中，每列右对齐。假定所有内层列表都包含同样数目的字符串。例如， 该值可能看起来像这样： tableData = [['apples', 'oranges', 'cherries', 'banana'], ['Alice', 'Bob', 'Carol', 'David'], ['dogs', 'cats', 'moose', 'goose']] 你的 printTable()函数将打印出： apples Alice dogs oranges Bob cats cherries Carol moose banana David goose 你的代码首先必须找到每个内层列表中最长的字符串，这样整列就有足够的宽度以放下所有字符串。你可以将每一列的最大宽度，保存为一个整数的列表。printTable()函 数的开始可以是colWidths = [0] *len(tableData)，这创建了一个列表，它包含了一些0， 数目与 tableData 中内层列表的数目相同。这样，colWidths[0]就可以保存 tableData[0]中 最长字符串的宽度，colWidths[1]就可以保存tableData[1]中最长字符串的宽度，以此类推。 然后可以找到colWidths列表中最大的值，决定将什么整数宽度传递给rjust()字符串方法 tableData = [['apples','oranges','cherries','banana'], ['Alice','Bob','Carol','David'], ['dogs','cats','moose','goose']] def printTable(data): str_data = '' col_len = [] for row in range(0,len(data[0])): for col in range(0,len(data)): col_len.append(len(data[col][row])) max_col_len = max(col_len) print("列表各元素长度为：") print(col_len) print("列表中最大值为：",max_col_len) for row in range(0,len(data[0])): for col in range(0,len(data)): print(data[col][row].rjust(max_col_len),end='') print() return str_data f_data = printTable(tableData) print(f_data) 待改
isX方法
isalpha()返回True，如果字符串只包含字母，并且非空； isalnum()返回 True，如果字符串只包含字母和数字，并且非空； isdecimal()返回 True，如果字符串只包含数字字符，并且非空； isspace()返回True，如果字符串只包含空格、制表符和换行，并且非空； istitle()返回True，如果字符串仅包含以大写字母开头、后面都是小写字母的单词。
>>> 'hello'.isalpha() True >>> 'hello123'.isalpha() False >>> 'hello123'.isalnum() True >>> 'hello'.isalnum() True >>> '123'.isdecimal() True >>> ' '.isspace() True >>> 'This Is Title Case'.istitle() True >>> 'This Is Title Case 123'.istitle() True >>> 'This Is not Title Case'.istitle() False >>> 'This Is NOT Title Case Either'.istitle() False while True: print('Enter your age:') age = input() if age.isdecimal(): break print('Please enter a number for your age.') while True: print('Select a new password (letters and numbers only):') password = input() if password.isalnum(): break print('Passwords can only have letters and numbers.')