目录
目录
前言
第1章 python基础
1.1 操作符和数据类型
1.2 字符串连接(+)和复制(*)
1.3 赋值(=)、等于(==)
1.4 变量名
1.5 内部函数
第2章 控制流
2.1 布尔值(True/False)
2.2 比较操作符、布尔操作符
2.3 控制流语句
2.4 导入模块
2.5 sys.exit():提前结束程序
第3章 函数
3.1 def语句和参数
3.2 None值(没有值、NoneType数据类型)
3.3 局部和全局作用域
3.4 global语句
3.5 异常处理 try... except...
第4章 列表list[]
4.1 取得列表中的单个值:list[index]
4.2 切片取得子列表:list[:]
4.3 len(list)函数取得列表长度、in、not in
4.4 改变列表元素的值
4.5 列表连接(+)、列表复制(*)、多重赋值、增强赋值
4.6 查找列表值的下标:index()方法
4.7 删除列表中的值:del语句、remove()方法、pop()方法
4.8 插入列表值:insert()、append()方法
4.9 排序列表值:sort()、reverse()方法
4.10 字符串str、元组tuple()
4.11 列表和元组类型相互转换list()、tuple()
4.12 引用:copy()、deepcopy()函数
第5章 字典dict{}和结构化数据
5.1 字典、dict.keys()、dict.values()、dict.items()
5.2 get()方法、setdefault()方法
5.3 pprint()、pformat()函数
第6章 字符串操作
6.1 处理字符串
6.2 字符串下标、切片、in、not in操作符
6.3 有用的字符串方法
学习《Python快速编程上手 让繁琐工作自动化》第一部分的内容总结,部分未按照书籍目录整理。
22/3/17 补充:我学习的中文版是第一版,但2019年已经有英文第二版了,中文现在也有了,啃英文有点慢,这个学习笔记是基于第二版的,推荐一下。
【python 让繁琐工作自动化】目录_今岁成蹊的博客-CSDN博客
第二版的官方视频也推荐。
豆瓣评分9.6的Python神书,578页Python编程快速上手,零基础小白福音_哔哩哔哩_bilibili
第二版英文版在线书籍参考:
Automate the Boring Stuff with Python
整体上,第二版比第一版多了第八章 输入验证、第十四章 处理Google表格。
细节部分,使用了一些新模块:如pyinputplus等。
操作符 | 说明 | 操作符 | 说明 |
---|---|---|---|
** | 指数 | +、- | 加、减 |
% | 取模/取余数 | * 、/ | 乘、除 |
// | 整除/商数取整 |
数据类型 | 例子 |
---|---|
整型 integer int | -2, -1, 0, 1, 88 |
浮点型 float | -1.0, 1.34, 0.0, --0.5(=0.5) |
字符串 string str | 'a','A','Abddf','11 cats!' |
"Alice" + "Bob" AliceBob
"Alice"*3 AliceAliceAlice
TypeError情况:
字符串+数字:"Alice" + 12 ,如需要,则需用str()将12变为字符串形式,"Alice" + str(12)
字符串*字符串:*"Alice1" * "Alice2"
字符串*浮点型:"Alice" * 5.0
Spam = 2 spam --> 2
Spam == 2 --> True
只能一个词
只能包含字母、数字、下划线
不能以数字开头
惯例:以小写字母开头、驼峰形式
(1) 注释
# :注释此行后面的代码
\: 续行符
print('For your ' + \
'infomation')
# For your infomation
msg1 = '''维护
秩序!
'''
"""
维护
秩序!
"""
print(msg1)
msg2 = """ni
w
****"""
print(msg2)
"""
ni
w
****
"""
(2) print():
将()内的字符串显示到屏幕
关键字参数有可选变元end、sep:
end: 参数末尾打印什么
sep: 参数之间打印什么
print("a","b","c",sep=',',end='...') # a,b,c...
(3) input():
等待用户键盘输入一些文本,返回值是字符串
(4) len():
求值一个整型,()中字符串字符的个数
(5) str()、int()、float():
将传入值变为字符串、整数、浮点数形式。
不能求值为整数的值传入int()会报错,如int('99.9')、int('one')都不行。
int(7.9) --> 7
大小写不能错误!不能做为变量名。
比较操作符的求值为True或False.
比较操作符 | 说明 | 比较操作符 | 说明 |
---|---|---|---|
== | 等于(用于所有数据类型值) | <、> | 小于、大于 (仅用于整型、浮点型值) |
!= | 不等于(用于所有数据类型值) | <=、>= | 小于等于、大于等于(仅用于整型、浮点型值) |
布尔操作符 | 说明 | 布尔操作符 | 说明 |
---|---|---|---|
and | 二元布尔操作符,两个为真结果为真。True and False --> False | not | 一元布尔操作符,not True --> False |
or | 二元布尔操作符,一个为真结果为真。True or False --> True |
操作顺序:算数和比较操作符求值 --> not 操作符 --> and 操作符--> or 操作符。
(1) if语句
if 条件(求值为True或False的表达式):
代码块
if 条件(求值为True或False的表达式):
代码块1
else:
代码块2
if 条件1(求值为True或False的表达式):
代码块2
elif 条件2(求值为True或False的表达式):
代码块2
elif ...:
...
else:
代码块n
如果有一系列elif语句,仅有一条或0条或执行,一旦一个语句条件为True,其他elif语句会自动跳过。
(2) while循环语句(break、continue):
while 条件(求值为True或False的表达式):
代码块
break:提前跳出while循环,接着while后的语句执行。
continue:用于循环内部,马上调回循环开始,重新对循环条件求值。
(3) for循环、range()函数:
for循环和while循环可以做同样的事,但for循环更简洁。
range的三个参数,包含起始值、不包含终止值。
for 变量 in range(起始、停止、步长):
代码块
-------------------------
for i in range(4): # 0 1 2 3
print(i)
for j in range(4,7): # 4 5 6
print(j)
for k in range(1,9,3): # 1 4 7
print(k)
for h in range(10,1,-3): # 10 7 4
print(h)
import 模块1,模块2
-------------------------
import random
j = random.randint(1,100) # 随机取1-100之间的整数,包含1和100
=========================
from 模块1 import *
-------------------------
from random import *
j = randint(1,100) # 可直接调用函数,不写模块名前缀,但可读性不如前者
sys.exit()可以让程序终止会退出,在sys模块中。
import sys
while True:
print('type exit to exit.')
response = input()
if response == 'exit':
sys.exit()
print('You typed ' + response +'.')
传入函数的变量在程序结束后会被丢弃!
def hello(变元/变量):
代码块
return 返回值/表达式
print()函数的返回值就是None。
全局作用域的代码不能使用任何局部变量
局部作用域可以访问全局变量
一个函数的局部作用域中代码不能使用其他局部作用域中的变量
不同作用域可以使用相同的名字命名不同的变量。
不要过度依赖全局变量,当程序很大时,难以追踪变量赋值的缺陷位置
如果需要在一个函数内修改全局变量,就使用 global 语句。
def spam():
global eggs
eggs = 100
eggs = 'global'
print(eggs) # global
spam()
print(eggs) # 100
判断一个变量是局部变量还是全局变量:
全局变量:变量在全局作用域中使用、在一个函数中有针对该变量的global语句、在函数中没有针对该变量的global语句,也有用于赋值语句。
局部变量:在函数中没有针对该变量的global语句,且用于赋值语句。
一旦执行跳到except子句代码,就不会回到try子句。try出错代码后面的代码就不会执行。
def spam(divideBy):
try:
return 43/divideBy
except ZeroDivisionError: # 除数为零异常
print('Error:Invalid argument.')
通过下标index,index只能是整数,如 list[-1]、 list[0]、list[2],不能是浮点值。
负数下标代表倒数,如-1是最后一个下标,-2是倒数第二个下标
list = [1,3,5,6,7]
print(list[-1],list[0],list[2]) # 7 1 5
列表可以嵌套列表。
list = [1,3,[5,7,8],1,1,2]
print(list[-1],list[0],list[2]) #2 1 [5,7,8]
print(list[2][2]) # 8
list[起始值:终止值:步长]:包含列表中起始值下标的值,但不包括终止值下标的值。
list = [1,3,5,6,7,11,14,16,18]
print(list[1:3]) # [3,5]
print(list[:3]) # [1,3,5]
print(list[7:]) # [16,18]
print(list[1:6:2]) # [3,6,11]
print(list[::3]) # [1, 6, 14]
查找值 in 查找列表:返回布尔值,值在列表中返回True
查找值 not in 查找列表:返回布尔值,值不在列表中返回True
list = [1,3,5,6,7,11,14,16,18]
print(len(list)) # 9
for i in range(len(list)):
print(i)
list = [1,3,5,6,7,11,14,16,18]
list[0] = 99
print(list) # [99,3,5,6,7,11,14,16,18]
*操作符用于一个列表和一个整数。
可用列表中的值为多个变量复制,变量数量必须和列表长度严格相等,否则ValueError。
list1,list2 = [1,2,3],[4,5,6,7]
print(list1 + list2) # [1, 2, 3, 4, 5, 6, 7]
print(list1 * 3) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
a,b,c = list1
print(a,b,c) # 1 2 3
赋值语句 | 等价语句 | 赋值语句 | 等价语句 |
---|---|---|---|
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 |
a = 'AFDGF'
a += "abdbf"
print(a) # AFDGFabdbf
b = ['Mood']
b *= 3
print(b) # ['Mood','Mood','Mood']
如果值不在列表中,报错ValueError.
如果值在列表中有多个,返回第一次出现的下标。
a = ['hello','wird','hahahah','wird','hahahah']
i1 = a.index('hello')
print(i1) # 0
i2 = a.index('wird')
print(i2) # 1
知道下标用del,知道值用remove。
del list[index] :删除列表中下标为index的值,index为整数,也可以切片删除。
list.remove('cat'): 删除指定的值,如果值出现多次,只删除第一次出现的。
list.pop():删除列表最后一个元素
list = [1,3,5,6,7,11,14,16,18]
del list[0]
print(list) # [3,5,6,7,11,14,16,18]
del list[0:3]
print(list) # [7,11,14,16,18]
del list[::2]
print(list) # [11, 16]
list.pop()
print(list) # [11]
list1 = ['cat','bga','cat','cat']
list1.remove('cat')
print(list1) # ['bga','cat','cat']
insert()、append()方法返回值是None,列表被直接修改。
只能在列表上调用,不能在字符串等其他值调用。
append(): 将参数添加在列表末尾
insert(新值下标, 插入新值): 将新值添加在指定的下标位置
list = ['a','b','c']
list.append('hello')
print(list) # ['a','b','c','hello']
list.insert(3,'d')
print(list) # ['a','b','c','d','hello']
不能对既有数字又有字符串的列表排序,如[1,3,'a']不能排序!!
sort():将数值或字符串的列表按照ASCII码顺序排序。先数字(字符串格式),再大写字母、再小写字母。
sort(key=str.lower):按照字母顺序排序,同样的字母先大写再小写。排序时将所有当小写,但实际并不改变列表值。
sort(reverse = True):将数值或字符串的列表按照ASCII码字符倒序排序。
reverse(): 将列表倒序排序。
a = ['egg', 'a', 'A', 'Gigg', 'Zippo', '!!', '@', 'zIPPO', '112', '9', '2.3', '-3.8', '?']
a.sort()
print(a) # ['!!', '-3.8', '112', '2.3', '9', '?', '@', 'A', 'Gigg', 'Zippo', 'a', 'egg', 'zIPPO']
-----------------------------------------------
a = ['egg', 'a', 'A', 'Gigg', 'Zippo', '!!', '@', 'zIPPO', '112', '9', '2.3', '-3.8', '?']
a.sort(key=str.lower)
print(a) # ['!!', '-3.8', '112', '2.3', '9', '?', '@', 'a', 'A', 'egg', 'Gigg', 'Zippo', 'zIPPO']
-----------------------------------------------
a = ['egg', 'a', 'A', 'Gigg', 'Zippo', '!!', '@', 'zIPPO', '112', '9', '2.3', '-3.8', '?']
a.sort(reverse = True)
print(a) # ['zIPPO', 'egg', 'a', 'Zippo', 'Gigg', 'A', '@', '?', '9', '2.3', '112', '-3.8', '!!']
-----------------------------------------------
a = ['egg', 'a', 'A', 'Gigg', 'Zippo', '!!', '@', 'zIPPO', '112', '9', '2.3', '-3.8', '?']
a.reverse()
print(a) # ['?', '-3.8', '2.3', '9', '112', 'zIPPO', '@', '!!', 'Zippo', 'Gigg', 'A', 'a', 'egg']
字符串也可以下标取值、切片、用于for循环、len()、in操作符、not in操作符
列表元素是可变的,字符串是不可变的,字符串不能对其中一个字符重新赋值。
改变字符串的方法:切片、连接。
重新给整个列表赋值,列表的id(内存地址)是改变了的,如果不想改变只是覆写,列表内存地址不变,只能通过del将列表值一个一个元素删除,再通过append一个一个元素赋值。
元组是不可变的。值不能被修改、添加、删除。
如果元组还有一个值,要在后面加上逗号(,),否则会被认为是个字符串类型。
type(('hello',)) # 元组类型
type('hello') # 字符串类型
print(list(('abc',))) # abc
print(list(('abc'))) # ['a', 'b', 'c']
print(tuple(['a','b','c'])) # ('a', 'b', 'c')
对列表或字典可变数据类型的值时,使用引用。
对于字符串、整型、元组等不可变的数据类型的值,变量保存值本身。
直接将变量a赋值给一个新变量b,b改变时,a不会改变。
直接将列表a赋值给一个新列表b,b的一个元素改变时,a也会改变。
如果不希望原列表改变,则使用a的切片赋值,或使用copy模块中的copy()、deepcopy()函数
copy(): 深拷贝父对象(一级目录),子对象(二级目录)不拷贝,还是引用。
deepcopy(): 父对象(一级目录)和子对象(二级目录)都拷贝。
a1 = 10
b1 = a1
b1 = 99
print(a1,b1) # 10,99
# -----------------------
a2 = [1,2,3,4]
b2 = a2
b2[1] = 99
print(a2,b2) # [1,99,3,4] [1,99,3,4]
# -----------------------
a3 = [1,2,3,4]
b3 = a3[:]
b3[1] = 99
print(a3,b3) # [1,2,3,4] [1,99,3,4]
# -----------------------
a4 = {'name': 'Calhoun', 'age': 23}
b4 = a4
b4['age'] = 99
print(a4, b4) # {'name': 'Calhoun', 'age': 99} {'name': 'Calhoun', 'age': 99}
copy()、deepcopy()函数
import copy
dict1 = {'user': 'runoob', 'num': [1, 2, 3]}
dict2 = dict1 # 浅拷贝: 引用对象
dict3 = copy.copy(dict1) # 浅拷贝:深拷贝父对象(一级目录),子对象(二级目录)不拷贝,子对象是引用
dict4 = copy.deepcopy(dict1) # 深拷贝
# 修改 data 数据
dict1['user'] = 'root'
dict1['num'].remove(1)
# 输出结果
print('原字典:', dict1)
print('赋值字典:', dict2)
print('copy字典:', dict3)
print('deepcopy字典:', dict4)
"""
原字典: {'user': 'root', 'num': [2, 3]}
赋值字典: {'user': 'root', 'num': [2, 3]}
copy字典: {'user': 'runoob', 'num': [2, 3]}
deepcopy字典: {'user': 'runoob', 'num': [1, 2, 3]}
"""
键(key):字典的索引,dict.keys()方法,返回类似列表的值,但不是真正的列表,不能被修改。可用list()转化为列表。
值(value):字典的键关联的值,dict.values()方法,返回类似列表的值,但不是真正的列表,不能被修改。可用list()转化为列表。
键-值对(item):dict.items()方法,返回类似列表的值,但不是真正的列表,不能被修改。可用list()转化为列表。
dict1 = {'user': 'runoob', 'num': [1, 2, 3]}
a1 = dict1.keys()
b1 = dict1.values()
c1 = dict1.items()
print(a1, b1, c1, end='\n', sep='\n')
print(list(a1), list(b1), list(c1), end='\n', sep='\n')
"""
dict_keys(['user', 'num'])
dict_values(['runoob', [1, 2, 3]])
dict_items([('user', 'runoob'), ('num', [1, 2, 3])])
['user', 'num']
['runoob', [1, 2, 3]]
[('user', 'runoob'), ('num', [1, 2, 3])]
"""
字典是不排序的,可以用in 或not in 查看键是否存在字典中。for dict in dict1是for dict in dict1.keys()的简写。
dict1 = {'user': 'runoob', 'num': [1, 2, 3]}
a21 = 'runoob' in dict1.items()
a22 = 'runoob' in dict1.keys()
a22_1 = 'runoob' in dict1
a23 = 'runoob' in dict1.values()
print(a21, a22, a22_1, a23) # False False False True
get(取得值的键, 键不存在返回的备用值): 如果键存在,返回该键对应的值,否则返回备用值,默认备用值可设为0.
setdefault(检查的键, 该键不存在时设定的值):为某键设定一个默认值,但如果该键存在,则不做改变。
dict1 = {'user': 'runoob', 'num': [1, 2, 3]}
a1 = dict1.get('num',1)
a2 = dict1.get('num1','None')
print(a1,a2) # [1, 2, 3] None
dict1.setdefault('Age',45)
print(dict1) # {'user': 'runoob', 'num': [1, 2, 3], 'Age': 45}
dict1.setdefault('user','Bob')
print(dict1) # {'user': 'runoob', 'num': [1, 2, 3], 'Age': 45}
setdefault()可用来计算字符串每个字符出现的次数。
msg = 'Hello,I\'m lijing.What is your name ?'
count = {}
for i in msg:
count.setdefault(i, 0)
count[i] = count[i] + 1
print(count)
"""
{'H': 1, 'e': 2, 'l': 3, 'o': 2, ',': 1, 'I': 1, "'": 1, 'm': 2, ' ': 5, 'i': 3, 'j': 1, 'n': 2, 'g': 1, '.': 1, 'W': 1, 'h': 1, 'a': 2, 't': 1, 's': 1, 'y': 1, 'u': 1, 'r': 1, '?': 1}
"""
使用pprint()、pformat()函数,需要导入pprint模块。
如果想得到显示在屏幕上的漂亮字符串,则使用pprint.pformat(),以下代码中的print(pprint.pformat(count))和pprint.pprint(count) 两者等价!
import pprint
msg = 'Hello,I\'m lijing.What is your name ?'
count = {}
for i in msg:
count.setdefault(i, 0)
count[i] = count[i] + 1
f1 = pprint.pformat(count)
pprint.pprint(count)
"""
{' ': 5,
"'": 1,
',': 1,
'.': 1,
'?': 1,
'H': 1,
'I': 1,
'W': 1,
'a': 2,
'e': 2,
'g': 1,
'h': 1,
'i': 3,
'j': 1,
'l': 3,
'm': 2,
'n': 2,
'o': 2,
'r': 1,
's': 1,
't': 1,
'u': 1,
'y': 1}
"""
用双引号“字符串”作为开始和结束,这样字符串就可以包含单引号'。
转义符\:可以在字符串中用单引号和双引号。
原始字符串r: 通过在引号前加r使它成为原始字符串,即忽略转义字符,打印字符串中的\符号。
三重引号:多行字符串,里面不需要转义,常用于多行注释。引号、制表符、换行都是字符串一部分 、代码块缩进规则不适用多行字符串。
#:单行注释。
与列表类似。
(1) upper()、lower()、isupper()、islower()
upper() : 返回一个新字符串,将原字符串的字母都转换为大写,非字母字符不变。没有改变原字符串!
lower() : 返回一个新字符串,将原字符串的字母都转换为小写,非字母字符不变。没有改变原字符串!
isupper() : 返回布尔值,字符串至少一个字母,且所有字母都大写,返回值为真,否则为假。
islower() : 返回布尔值,字符串至少一个字母,且所有字母都小写,返回值为真,否则为假。
(2) isX()
isalpha(): 如果字符串只包含字母,并且非空,返回 True。
isalnum(): 如果字符串只包含字母和数字,并且非空,返回 True。
isdecimal(): 如果字符串只包含数字字符,并且非空,返回 True。
isspace(): 如果字符串只包含空格、制表符和换行,并且非空,返回 True。
istitle(): 如果字符串仅包含以大写字母开头、后面都是小写字母的单词,返回 True。
a1, a2, a3, a4, a5 = 'Add', 'Add1234', '1234.5', ' \t', 'HueW'
print(a1.isalpha(), a1.istitle()) # True True
print(a2.isalnum(), a2.isdecimal()) # True False
print(a3.isalpha(), a3.isdecimal()) # False False
print(a4.isspace()) # True
print(a5.istitle()) # False
(3) startswith()、endswith()
startswith():如果字符串以调用的字符串开始,返回True,否则返回False
endswith():如果字符串以调用的字符串结束,返回True,否则返回False
a1, a2= 'Add','HueW'
print(a1.startswith('Ad'), a1.startswith('ad')) # True False
print(a2.endswith('eW'), a2.endswith('leW')) # True False
(4) join()、split()
join(): 将字符串列表连接成一个字符串。'连接符'.join(字符串列表)
split(): 针对字符串调用,返回字符串列表。默认为所有的空字符,包括空格、换行(\n)、制表符(\t)等。
a1 = '-'.join(['cats', 'rats', 'bats'])
print(a1) # cats-rats-bats
a2 = a1.split('-')
print(a2) # ['cats', 'rats', 'bats']
a3 = "MyHHHNameHHHIsHHHJing.".split('HHH')
print(a3) # ['My', 'Name', 'Is', 'Jing.']
msg = """ Dear,
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"""
a4 = msg.split()
print(a4)
"""
['Dear,', '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']
"""
(5)对齐文本:rjust()、ljust()、center()
通过插入填充字符对齐文本。
rjust():字符串右对齐,左边补填充字符(默认空格),如果字符串长度大于指定的长度,则不补也不报错
ljust():字符串左对齐,右边补填充字符
center():字符串居中,两边补填充字符,先在字符串右边补一个填充字符,再左边再右边,直到长度达到指定长度
a1 = 'Hello'
print(a1.rjust(10))
print(a1.rjust(10, '*'))
print(a1.rjust(4, '*'))
print(a1.ljust(10, '*'))
print(a1.center(10, '*'))
"""
Hello
*****Hello
Hello
Hello*****
**Hello***
"""
(6)删除空白字符:strip()、rstrip()、lstrip()
删除字符串左边、右边或两边的空白字符(空格、制表符和换行符)。返回一个新的字符串。
strip():无参数,则删除开头或末尾的空白字符。
rstrip():无参数,则删除右边的空白字符
lstrip():无参数,则删除左边的空白字符
可输入字符串参数,但字符串的顺序并不重要!只要包含这些字符就可以,区分大小写
a1 = 'Hellol12345oolHe'
print(a1.strip('eHl')) # ol12345oo
(7)pyperclip模块:电脑剪贴板
pyperclip是第三方模块,需要先安装包:
pip install pyperclip
copy():将内容拷贝至电脑剪贴板。
paste(): 粘贴电脑剪贴板的内容。
import pyperclip
a1 = '字符串'
print(pyperclip.paste()) # 目前剪贴板的内容
pyperclip.copy(a1) # 字符串,在别的地方粘贴:字符串