Python编程快速上手—让繁琐工作自动化 笔记_python编程快速上手——让繁琐工作自动化

第2章 控制流

range

for i in range(1,10,2):
    print(i)
    
# 1
# 3
# 5
# 7
# 9
1
2
3
4
5
6
7
8
'
运行
运行

两个整数之间的一个随机整数

import random

for i in range(5):
    print(random.randint(1, 10))
    
# 7
# 4
# 10
# 7
# 6
1
2
3
4
5
6
7
8
9
10
'
运行
运行

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

import sys
while True:
	print('Type exit to exit.')
	response = input()
	if response == 'exit':
	sys.exit()
	print('You typed ' + response + '.')
1
2
3
4
5
6
7

第3章 函数

print('Hello', end='-')
print('World')

Hello-World
1
2
3
4

如果向 print()传入多个字符串值，该函数就会自动用一个空格分隔它们

print('cats', 'dogs', 'mice')
cats dogs mice
1
2

可以传入 sep 关键字参数，替换掉默认的分隔字符串

print('cats', 'dogs', 'mice', sep=',')
cats,dogs,mice
1
2

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

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

记得将 input()的返回值用 int()函数转成一个整数，否则它会是一个字符串。

列表

用 del 语句从列表中删除值

spam = ['cat', 'bat', 'rat', 'elephant']
del spam[2]
1
2
'
运行
运行

多重赋值技巧

cat = ['fat', 'black', 'loud']
size = cat[0]
color = cat[1]
disposition = cat[2]
1
2
3
4
'
运行
运行

cat = ['fat', 'black', 'loud']
size, color, disposition = cat
1
2
'
运行
运行

增强的赋值语句 等价的赋值语句

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
1
2
3
4
5

+=操作符也可以完成字符串和列表的连接，*=操作符可以完成字符串和列表的复制
1

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

spam = ['hello', 'hi', 'howdy', 'heyas']
spam.index('hello')
0
1
2
3
'
运行
运行

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

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

>>> spam = ['cat', 'dog', 'bat']
>>> spam.insert(1, 'chicken')
>>> spam
['cat', 'chicken', 'dog', 'bat']
1
2
3
4

append()和 insert()方法是列表方法，只能在列表上调用，不能在其他值上调用，例如字符串和整型

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

>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> spam.remove('bat')
>>> spam
['cat', 'rat', 'elephant']
1
2
3
4

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

>>> spam = ['cat', 'bat', 'rat', 'cat', 'hat', 'cat']
>>> spam.remove('cat')
>>> spam
['bat', 'rat', 'cat', 'hat', 'cat']
1
2
3
4

用 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']
1
2
3
4
5
6
7
8

也可以指定 reverse 关键字参数为 True，让 sort()按逆序排序

>>> spam.sort(reverse=True)
>>> spam
['elephants', 'dogs', 'cats', 'badgers', 'ants']
1
2
3

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

>>> spam = ['a', 'z', 'A', 'Z']
>>> spam.sort(key=str.lower)
>>> spam
['a', 'A', 'z', 'Z']
1
2
3
4

在行末使用续行字符\，将一条指令写成多行。可以把\看成是“这条指令在下一行继续”。\续行字符之后的一行中，缩进并不重要

print('Four score and seven ' + \
'years ago...')
1
2
'
运行
运行

字符串切片

切片取值
# [起始位置索引:结束位置索引,不包含:步长]
temp = "abcdefg"
res1 = temp[::] # 注意:不可少
print(res1) # abcdefg
res2 = temp[0:-1:2]
print(res2) # ace
1
2
3
4
5
6
7

字符串的格式化
# 按默认一对一格式化
temp1 = "我叫{},今年{}岁了!"
res1 = temp1.format('咸鱼',22)
print(res1) # 我叫咸鱼,今年22岁了!

# 按索引格式化
temp2 = "我叫{1},今年{0}岁了!"
res2 = temp2.format('咸鱼',22)
print(res2) # 我叫22,今年咸鱼岁了!

# 键值对
temp3 = "我叫{name},今年{age}岁了!"
res3 = temp3.format(age=22,name='咸鱼')
print(res3) # 我叫咸鱼,今年22岁了!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2020/6/17

使用元组而不是列表的第二个好处在于，因为它们是不可变的，它们的内容不会变化，Python 可以实现一些优化，让使用元组的代码比使用列表的代码更快。

>>> import copy
>>> spam = ['A', 'B', 'C', 'D']
>>> cheese = copy.copy(spam)
>>> cheese[1] = 42
>>> spam
['A', 'B', 'C', 'D']
>>> cheese
['A', 42, 'C', 'D']
1
2
3
4
5
6
7
8

字典

get()方法

字典有一个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.'
1
2
3
4
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'}
1
2
3
4
5
6
7
8
9

计算一个字符串中每个字符出现的次数

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}
1
2
3
4
5
6
7
8
'
运行
运行

漂亮打印

pprint 模块，可以使用 pprint()和 pformat()函数

from pprint 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(count)
{' ': 13,
 ',': 1,
 '.': 1,
 'A': 1,
 'I': 1,
 'a': 4,
 'b': 1,
 'c': 3,
 'd': 3,
 'e': 5,
 'g': 2,
 'h': 3,
 'i': 6,
 'k': 2,
 'l': 3,
 'n': 4,
 'o': 2,
 'p': 1,
 'r': 5,
 's': 3,
 't': 6,
 'w': 2,
 'y': 1}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
'
运行
运行

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

如果希望得到漂亮打印的文本作为字符串，而不是显示在屏幕上，那就调用
pprint.pformat()。下面两行代码是等价的：

pprint.pprint(someDictionaryValue)
print(pprint.pformat(someDictionaryValue))
1
2

字符串

原始字符串

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

print(r'That is Carol\'s cat.')
That is Carol\'s cat.
1
2

原始字符串，Python 认为倒斜杠是字符串的一部分，而不是转义字符的开始。正则表达式字符串，那么原始字符串就很有用。

用三重引号的多行字符串
Python 的代码块缩进规则不适用于多行字符串。

print('''Dear Alice,
Eve's cat has been arrested for catnapping, cat burglary, and extortion.
Sincerely,
Bob''')
1
2
3
4
'
运行
运行

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

如果它们所调用的字符串以该方法传入的字符串开始或结束。否则，方法返回 False。

>>> '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
1
2
3
4
5
6
7
8
9
10
11
12

如果只需要检查字符串的开始或结束部分是否等于另一个字符串，而不是整个字符串，这些方法就可以替代等于操作符==，这很有用。

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

>>> ', '.join(['cats', 'rats', 'bats'])
'cats, rats, bats'
>>> ' '.join(['My', 'name', 'is', 'Simon'])
'My name is Simon'
>>> 'ABC'.join(['My', 'name', 'is', 'Simon'])
'MyABCnameABCisABCSimon'
1
2
3
4
5
6

'My name is Simon'.split()
Out[17]: ['My', 'name', 'is', 'Simon']
1
2

>>> 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']
1
2
3
4
5
6
7
8
9
10
11

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

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

>>> 'Hello'.rjust(10)
' Hello'
>>> 'Hello'.rjust(20)
' Hello'
>>> 'Hello World'.rjust(20)
' Hello World'
>>> 'Hello'.ljust(10)
'Hello 
1
2
3
4
5
6
7
8

‘Hello’.rjust(10)是说我们希望右对齐，将’Hello’放在一个长度为 10 的字符串中。
'Hello’有 5 个字符，所以左边会加上 5 个空格，得到一个 10 个字符的字符串，实现
'Hello’右对齐。

>>> 'Hello'.rjust(20, '*')
'***************Hello'
>>> 'Hello'.ljust(20, '-')
'Hello---------------'
1
2
3
4

>>> 'Hello'.center(20)
' Hello '
>>> 'Hello'.center(20, '=')
'=======Hello========'
1
2
3
4

6-18