《Python编程快速上手——让繁琐工作自动化》
Chp4 列表
- in和not in确定一个值是否在列表中
>>>'howdy' in ['hello','howdy']
True
- 多重赋值
变量数目和列表长度必须完全相等，否则出错。
spam=['pens','dog','red']
size,color,disposition=spam # 变量数目和列表长度必须完全相等
print(size,color,disposition)
输出结果：pens dog red
- 增强赋值
spam+=1 # 等价于spam=spam+1
spam-=1 # 等价于spam=spam-1
spam*=1 # 等价于spam=spam*1
spam/=1 # 等价于spam=spam/1
spam%=1 # 等价于spam=spam%1，取余
例如：
spam=['pens','dog','red']
print(spam)
spam*=2
print(spam)
spam+=['world'] # 这里spam为列表，所以后面＋=列表，加方括号
print(spam)
spam1='Hello'
spam1+=' World!' # 这里spam1为字符串，后面+=字符串
print(spam1)
del spam[:-1]
print(spam) # ['world']
spam+='world' # 如果直接给列表+=字符串会出现奇怪的结果
print(spam) # ['world', 'w', 'o', 'r', 'l', 'd']
输出结果：
['pens', 'dog', 'red']
['pens', 'dog', 'red', 'pens', 'dog', 'red']
['pens', 'dog', 'red', 'pens', 'dog', 'red', 'world']
Hello World!
['world']
['world', 'w', 'o', 'r', 'l', 'd']
- 方法：一种函数，用来调用一个值，类似于c中指针
如果列表名为spam，则方法形如spam.index(‘hello’)，其中.后的为方法中函数名，括号内为调用的值，如index()函数可以在列表中查询是否有'hello'这个值，并返回True或False的布尔值。对于列表中重复出现的元素，只查找或删除第一个。列表中值都是当场被改变，返回值为None。
- index() 列表中查值
- append() 将参数添加到列表末尾，insert(1,'cat') 将参数添加到列表指定位置之前
只能在列表中使用 - remove() 列表中删值
之前的del spam[0]是指定删除列表中第几个值，而这里的spam.remove('cat')是指定删除列表中某一个已知内容是什么的值，如果该值不在列表中会出现错误。 - sort()列表中值排序，只针对纯数字或纯字符的列表
- spam.sort() # 数字从小到大，字母大写在前，小写在后排序
- spam.sort(reverse=True) # 逆序
- spam.sort(key=str.lower) # 按照字母表排序，大小写混搭
- 列表缩进和随机值
- 列表跨行缩进随意，只根据]来判断列表结束；
- 也可以使用
\续行符，在其下一行中缩进随意； -
spam[random.radint(0,len(spam)-1)]是取了列表中随机值，注意先import random再使用该函数，因为列表是从0开始的，len(spam)-1就是列表中最后一个元素的下标。
- 字符串和元组
- 列表中很多操作可以用于字符串中单个文本处理，如按下标取值、切片、for、len()、in和not in。
- 字符串不能直接通过赋值语句改变，而是使用切片和连接构造一个新的字符串。
spam1='Hello'
spam1 = spam1[:2]+'~~'+spam1[2:]
print(spam1)
输出结果：He~~llo
元组(tuple)是用圆括号圈起来的(形如eggs=('hello',1,2))，与字符串一样不能直接赋值而改变。如果元组中只有一个值，要在圆括号内，该值前添加逗号。
元组用于永远不会改变值的序列。
>>> a=('hello')
>>> type(a)
<class 'str'>
>>> a=('hello',)
>>> type(a)
<class 'tuple'>
- list()转化为列表类型，tuple()转化为元组类型。
- 引用
- 列表名不保存列表中值，只是引用了内部存储该值的位置，类似于指针。所以当将列表spam赋值给cheese后，任何对cheese的操作，spam同样受到影响。
可变数据类型：列表、字典===========>保存的是引用
不可变数据类型：字符串、整型或元组===>保存的是数值本身
- 因为列表保存的是引用，所以函数中变元可以当场改变列表值，这点要特别注意！！
def eggs(value):
value.append('go!')
spam=[1,2]
eggs(spam)
print(eggs) # <function eggs at 0x000001E452C97940> 好像是直接给出了函数保存地址
print(spam)
输出结果：
<function eggs at 0x000001C03F617940>
[1, 2, 'go!']
- 如果不希望传递引起列表的改变，需要使用copy()函数，其中
cheese=copy.copy(spam)将spam列表值在内存中重新复制了一份，并将引用给了cheese，如果列表中还包含列表，需要使用copy.deepcopy()。
实践项目
4.10.1 逗号代码
def do(value):
# value是一个列表，对其进行处理，使其转为字符串返回
value.insert(-1,'and')
# str(value)
output=''
for i in range(len(value)-1):
output+=value[i]+', '
output+=value[-1]
return output
spam=['apples','bananas','tofu','cats']
output=do(spam)
print(output)
输出结果：apples, bananas, tofu, and, cats
4.10.2 字符图网格
grid=[['.','.','.','.','.','.'],
['.','0','0','.','.','.'],
['0','0','0','0','0','.'],
['0','0','0','0','0','.'],
['.','0','0','0','0','0'],
['0','0','0','0','0','.'],
['0','0','0','0','0','.'],
['.','0','0','.','.','.'],
['.','.','.','.','.','.']]
for j in range(len(grid[0])):
for i in range(len(grid)):
print(grid[i][j],end='')
print('') # 这里注意多打印一个空白命令，实现换行功能
输出结果：
..00.00..
.0000000.
.0000000.
..00000..
..00000..
....0....
Chp5 字典
- 字典用花括号表示，冒号前为键，是索引的关键词；冒号后为值，是索引得到的结果。
- 访问时加方括号！！
myCat={'name':'Bob','color':'gray','year':'2020'}
print('My cat\'s name is '+myCat['name']+'. He\'s in '+myCat['color']+'.')
# 如果字符串里包含'则前面要加\，使其能正常。
输出结果：My cat's name is Bob. He's in gray.
- 字典中表项不排序，故不能使用切片。
- 字典通过键访问，键可以是字符串、数字等，灵活性很大。注意键和值的对应关系，比如创建一个字典，用名字作为键，而生日作为值，这样可以通过名字来查找生日。
- 访问不存在与字典的键会出错，所以要先用
in判断是否存在于字典中。
- 访问字典的keys()键、values()值和items()键和值：
- 利用
for循环输出字典里所有的键、值或键和值。
spam={'color':'red','age':42}
for i in spam.keys():
print(i)
for i in spam.values():
print(i)
for i in spam.items():
print(i)
Results:
color
age
red
42
('color', 'red') # items输出的是包括键和值的元组
('age', 42)
- 类似地，列表里也可以用for输出列表所有值。
sam=['cat','dog']
for i in sam:
print(i)
输出结果：
cat
dog
-
for可以实现多重赋值，一条语句同时处理items中键和值
spam={'color':'red','age':42}
for i,j in spam.items():
print('The key in spam is '+i+', and the value is '+str(j)+'.')
Results:
The key in spam is color, and the value is red.
The key in spam is age, and the value is 42.
-
list()将返回值变为列表
因为keys()、values()和items()的返回值的数据类型分别为dict_keys()、dict_values()和dict_items()，为了方便使用可以直接使用list()转化为列表：
spam={'color':'red','age':42}
print(spam.keys())
print(list(spam.keys()))
Results:
dict_keys(['color', 'age']) # dict_keys数据类型
['color', 'age'] # 列表数据类型
- 利用in或not in检查键和值是否在字典中
- 检查键是否在字典中，以下两种方式等效：
'color' in spam
'color' in spam.keys() # 注意有括号哦！
- 检查值是否在字典中
'red' in spam.values()
- get()确保有返回值
取得某键对应的值，如果不存在则返回备用值，如spam.get('cups',0)取得字典spam中键cups对应的值是多少，如果没有该键，则返回0，而不是报错。 - setdefault()确保有键，且有返回值
取得某键的值，如果不存在该键，则为字典添加该键。
spam={'color':'red','age':42}
print(spam)
out=spam.setdefault('name','Bob')
print(spam)
print(out)
spam.setdefault('age','12')
print(spam)
Results:
{'color': 'red', 'age': 42}
{'color': 'red', 'age': 42, 'name': 'Bob'} # 键name不存在，添加并返回该值Bob
Bob
{'color': 'red', 'age': 42, 'name': 'Bob'}
- pprint()漂亮打印函数，包括pprint.pprint()无返回值直接打印和pprint.pformat()有返回值，不直接打印。
import pprint # 导入漂亮打印
message='I love learning Python!'
count ={} # 建立一个计各个字符出现次数的空字典
for character in message: # character是字符串message中的值
count.setdefault(character,0) # 默认计数count[character]为0
count[character]=count[character]+1 # 每出现一个字母就计数加一
pprint.pprint(count) # 直接输出命令，返回值为None
print(pprint.pformat(count)) # 与上一句输出来说等效
out=pprint.pformat(count) # 但不同的是该语句有返回值，返回值是字符串
print(out)
print(type(out))
Results:
{' ': 3,
'!': 1,
'I': 1,
'P': 1,
'a': 1,
'e': 2,
'g': 1,
'h': 1,
'i': 1,
'l': 2,
'n': 3,
'o': 2,
'r': 1,
't': 1,
'v': 1,
'y': 1}
{' ': 3,
'!': 1,
'I': 1,
'P': 1,
'a': 1,
'e': 2,
'g': 1,
'h': 1,
'i': 1,
'l': 2,
'n': 3,
'o': 2,
'r': 1,
't': 1,
'v': 1,
'y': 1}
<class 'str'>
>>> out
"{' ': 3,\n '!': 1,\n 'I': 1,\n 'P': 1,\n 'a': 1,\n 'e': 2,\n 'g': 1,\n 'h': 1,\n 'i': 1,\n 'l': 2,\n 'n': 3,\n 'o': 2,\n 'r': 1,\n 't': 1,\n 'v': 1,\n 'y': 1}"
- 字典的嵌套
把5.3.2中例子改编了一下，写了个新功能。
# 输出所有的食物及其数量
allGuest = {'Alice':{'apple':5,'pretzels':12},
'Bob':{'ham sandwiches':3,'apple':2},
'Carol':{'cups':3,'apple pies':1}}
def totalBrought(guests):
out=[] # 定义空白列表，存储食物及其数量
for k,v in guests.items():
for i,j in v.items():
out+=[i,j]
# print(out) # out[i]对应字典中键，out[i+1]对应字典中值
new={} # 定义空白字典，将食物和数量建立对应关系
i=0
while i <= int(len(out)-1):
#new={out[i]:out[i+1]}
#print(new)
if out[i] not in new.keys():
new.setdefault(out[i],out[i+1]) # 这里目的是把不在字典里的项加上
else:
value = new.setdefault(out[i],out[i+1]) # 这里的目的是取得已经在字典里项的值
new[out[i]]=out[i+1]+value # out[i+1]是新添加的值
i+=2
#print(new)
return new # 返回了一个字典，汇总了所有的食物和数量
#print(totalBrought(allGuest))
# 打印所有食物和数量
guest=totalBrought(allGuest)
print('Here is the food and amount:')
for i,j in guest.items():
print(i,str(j))
Results:
Here is the food and amount:
apple 7
pretzels 12
ham sandwiches 3
cups 3
apple pies 1
实践项目
5.6.1 好玩游戏的物品清单
def displayInventory(Inventory):
print('Inventory:')
num=0
for i,j in Inventory.items():
print(j,i)
num+=j
print('Total number of items: '+str(num))
Inventory={'rope':1,'torch':6,'gold coin':42,'dagger':1,'arrow':12}
displayInventory(Inventory)
5.6.2 列表到字典
当字典赋值更新时，函数必须要返回：
def displayInventory(Inventory): # 显示字典
print('Inventory:')
num=0
for i,j in Inventory.items():
print(j,i)
num+=j
print('Total number of items: '+str(num))
def addToInventory(Inventory,addedItems): # 为字典添加物品并更新
for k in range(len(addedItems)):
if addedItems[k] not in Inventory:
Inventory.setdefault(addedItems[k],1) # 物品是否存在？不存在物品为1
else:
value=Inventory.setdefault(addedItems[k],1)
Inventory[addedItems[k]]=value+1
return Inventory # 一定要返回不然Inventory为0
Inventory={'rope':1,'torch':6,'gold coin':42,'dagger':1,'arrow':12}# 原字典
dragonLoot=['gold coin','dagger','gold coin','gold coin','ruby'] # 添加物品列表
Inventory= addToInventory(Inventory,dragonLoot) # 更新字典
displayInventory(Inventory)
函数不返回时，字典也可以直接通过函数调用更新：
def displayInventory(Inventory): # 显示字典
print('Inventory:')
num=0
for i,j in Inventory.items():
print(j,i)
num+=j
print('Total number of items: '+str(num))
def addToInventory(Inventory,addedItems): # 为字典添加物品并更新
for k in range(len(addedItems)):
if addedItems[k] not in Inventory:
Inventory.setdefault(addedItems[k],1) # 物品是否存在？不存在物品为1
else:
value=Inventory.setdefault(addedItems[k],1)
Inventory[addedItems[k]]=value+1
#return Inventory # 一定要返回不然Inventory为0
Inventory={'rope':1,'torch':6,'gold coin':42,'dagger':1,'arrow':12}# 原字典
dragonLoot=['gold coin','dagger','gold coin','gold coin','ruby'] # 添加物品列表
#Inventory= addToInventory(Inventory,dragonLoot) # 更新字典
addToInventory(Inventory,dragonLoot) # 这种情况下不用返回，因为函数直接更新了字典
displayInventory(Inventory)
二者输出是相同的：
Inventory:
1 rope
6 torch
45 gold coin
2 dagger
12 arrow
1 ruby
Total number of items: 67
