Python编程快速上⼿—让繁琐⼯作⾃动化（学习记录的笔记随
时更新）
"""
Python编程快速上⼿
—让繁琐⼯作⾃动化
⽹页显⽰不全，略显⿇烦可以复制代码到⾃⼰的编辑器查看
笔记
"""
# **：指数  %：取余数  \\：整除
#  *号还可以作为字符串复制的操作符：'abc'*2 = 'abcabc'(*号只能⽤于两个数字或⼀个字符串与⼀个整型数字)
# ⼀个表达式中使⽤多个布尔操作符，Python 先求值not 操作符，然后是and 操作符，然后是or 操作符。2 + 2 == 4 and not 2 + 2 == 5 and 2 * 2 == 2 + 2    结果：Tu # 其他数据类型中的某些值，条件认为它们等价于True 和False。在⽤于条件时，0、0.0 和' '（空字符串）被认为是False，其他值被认为是True （应⽤与for  while语# range()函数也可以有第三个参数。前两个参数分别是起始值和终⽌值，第三个参数是“步长”(列表切⽚时⼀样)
#  import aa， bb， cc
# 调⽤it()函数，可以让程序终⽌或退出。（先导⼊sys模块）
# 每个函数调⽤都会返回⼀个值， print()也是⼀个函数，其返回⼀个None；在幕后，对于所有没有return 语句的函数定义，Python 都会在末尾加上return None。这类# print()函数内有可选参数end 和 sep ； end指末尾打印什么，默认值为末尾添加换⾏符。  sep指在打印参数之间⽤什么来分隔开他们，默认为空格；两个可选的默认print('cats', 'dogs', 'mice', sep='-') #cats-dogs-mice
# 1.全局作⽤域中的代码不能使⽤任何局部变量；
# 2.但是，局部作⽤域可以访问全局变量；（只有全局变量能⽤于全局作⽤域）
# 3.⼀个函数的局部作⽤域中的代码，不能使⽤其他局部作⽤域中的变量。（⼀个函数中的局部变量完
全与其他函数中的局部变量分隔开来。）
# 4.如果在不同的作⽤域中，你可以⽤相同的名字命名不同的变量。也就是说，可以有⼀个名为spam 的局部变量，和⼀个名为spam 的全局变量。
# 需要在⼀个函数内修改全局变量，就使⽤global 语句  global name 将函数内的变量name  变成全局变量
# +操作符可以连接合并两个列表；*操作符可以⽤于复制列表
# range(len(列表))可以⽤来迭代列表的所有下标
# 多重赋值技巧： (变量的数⽬和列表的长度必须严格相等，否则Python 将给出ValueError：)
cat = ['fat', 'black', 'loud']
size, color, disposition = cat
print(size)
print(color)
print(disposition)
# ⽤index()⽅法在列表中查值的位置：index()⽅法，可以传⼊⼀个值，如果该值存在于列表中，就返回它的下标
spam = ['hello', 'hi', 'howdy', 'heyas']
print(spam.index('howdy'))
# ⽤sort()对字符串进⾏排序是⼤写字母开头永远在⼩写字母前⾯['A', 'B', 'a', 'b']
# 字符串和列表实际上很相似，可以认为字符串是单个⽂本字符的列表。对列表的许多操作，也可以作⽤于字符串：按下标取值、切⽚、⽤于for 循环、⽤于len()，以及# 列表和字符串在⼀个重要的⽅⾯是不同的。列表是“可变的”数据类型，它的值可以添加、删除或改变。但是，字符串是“不可变的”，它不能被更改（只能改变指向他的
# 如果元组中只有⼀个值，你可以在括号内该值的后⾯跟上⼀个逗号告诉Python，这是⼀个元组 ('hello',) 是⼀个元组。（元组也是不可变的，但元组内的列表可变）
# >>> tuple(['cat', 'dog', 5])结果：('cat', 'dog', 5)转换成元组，转换列表⽤list；
# 引⽤：
# 变量保存字符串和整数值时的情况：
"""
>>> spam = 42
>>> cheese = spam    # cheese = spam 等于是把spam的值拷贝给了cheese，即使后⾯spm值修改了，并不影响cheese。
>>> spam = 100
>>> spam
100
>>> cheese
42
"""
# ⽽变量被赋予列表不是这样的。当你将列表赋给⼀个变量时，实际上是将列表的“引⽤”赋给了该变量。引⽤是⼀个值，指向某些数据。列表引⽤是指向⼀个列表的值："""
"""
>>> spam = [0, 1, 2, 3, 4, 5]
>>> cheese = spam    #这⾥的cheese = spam等于是把spam引⽤列表的值的ID（可以理解为列表的地址）拷贝给了cheese，实际上列表并没有拷贝，所以只要有⼀>>> cheese[1] = 'Hello!'
>>> spam
[0, 'Hello!', 2, 3, 4, 5]
>>> cheese
[0, 'Hello!', 2, 3, 4, 5]
"""
"""
变量包含对列表值的引⽤，⽽不是列表值本⾝。但对于字符串和整数值，变量
就包含了字符串或整数值。在变量必须保存可变数据类型的值时，例如列表或字典，
Python 就使⽤引⽤。对于不可变的数据类型的值，例如字符串、整型或元组，Python
变量就保存值本⾝。
"""
# 当函数被调⽤时，参数的值被复制给变元。对于列表以及字典，这意味着变元得到的是“引⽤”的拷贝：
def eggs(someParameter):
someParameter.append('Hello')
spam = [1, 2, 3]
eggs(spam)
print(spam)  #原列表的最终值会被函数改变，因为函数并未拷贝列表，只是复制了列表的“引⽤”，若不想列表值被修改可以⽤元组。
# copy 模块的copy()和deepcopy()函数： Python 提供了名为copy 的模块，其中包含copy()和deepcopy()函数。第⼀个函数py()，可以⽤来复制列表或字典这# 也可以⽤copy()函数直接复制列表⽽不是复制列表的引⽤：
"""
>>> import copy
>>> spam = ['A', 'B', 'C', 'D']
>>> cheese = py(spam)
>>> cheese[1] = 42
>>> spam
['A', 'B', 'C', 'D']
>>> cheese
['A', 42, 'C', 'D']
"""
# 如果要复制的列表中包含了列表，那就使⽤copy.deepcopy()函数来代替。
# 变量不直接保存列表值，它们保存对列表的“引⽤”。在复制变量或将列表作为函数调⽤的参数时，这⼀点很重要。因为被复制的只是列表引⽤，所以要注意，
# 循环嵌套的列表可以⽤aaa[][]来访问元素
#字典：不像列表，字典中的表项是不排序的，同时字典中的键必须是不可变值（str、int等）。
# get()和 setdefailt()的⽤法：
# get(key, 备⽤值) ⽅法，它有两个参数：要取得其值的键，以及如果该键不存在时，返回的备⽤值（防⽌报错）
picnicItems = {'apples': 5, 'cups': 2}
('orange', 'none'))
# setdefailt(key, 将要设置的值)要取得其值的键，以及如果该键不存在时要设置的值。如果该键确实存在，⽅法就会返回键的值。
"""
>>> spam = {'name': 'Pooka', 'age': 5}
>>> spam.setdefault('color', 'black')
'black'
>>> spam
{'color': 'black', 'age': 5, 'name': 'Pooka'}
>>> spam.setdefault('color', 'white')
'black'
"""
# ⽅法get()和setdefault()的区别在于get()不会修原字典值，只是⽤来防⽌错误。setdefault()则会修改原字典，为没有到值的键或者没有到的键添加默认设置值。message = 'It was a bright cold day in April, and the clocks were striking thirteen.'
"""计算message中每个字母出现的次数"""
count = {}
for letter in message:
count.setdefault(letter, 0)
count.setdefault(letter, 0)
count[letter] = count[letter] + 1
import pprint    # 导⼊pprint 模块，就可以使⽤pprint()和pformat()函数，它们将“漂亮打印”⼀个字典的字。pformat()和pprint⼀样只是单纯获取其格式不打印pprint.pprint(count)
pfo = pprint.pformat(count)
"""第六章：字符串操作"""
# print(r'That is Carol\'s cat.') 输出：That is Carol\'s cat.  在引号前加上r使它成为原始字符串。“原始字符串”完全忽略所有的转义字符
print('' in 'spm')
# 由于字符串是不可变的所以upper()、lower()等不会修改字符串本⾝，⽽是返回⼀个新的字符串
# isupper()和islower()⽅法⽤于判断字符串似否都是⼤⼩写，相应地返回布尔值True或者Flast：  xxx.islower()
# isX 字符串⽅法：⽤法aaa.isX()
"""
isalpha()返回True，如果字符串只包含字母，并且⾮空；
isalnum()返回True，如果字符串只包含字母和数字，并且⾮空；
isdecimal()返回True，如果字符串只包含数字字符，并且⾮空；
isspace()返回True，如果字符串只包含空格、制表符和换⾏，并且⾮空；
istitle()返回True，如果字符串仅包含以⼤写字母开头、后⾯都是⼩写字母的单词。
"""
# 字符串⽅法startswith()和endswith()⽤法和上⾯⼀样，括号内传⼊要检查的内容，⽤于检查字符串开头或结尾是否与实参⼀致。
# join()⽅法在⼀个字符串上调⽤，参数是⼀个字符串列表，返回⼀个字符串，返回的字符串由传⼊的列表中每个字符串连接⽽成。（作⽤在字符串上，传⼊列表，将列# split()⽅法做的事情正好相反：它针对⼀个字符串调⽤，返回⼀个字符串列表。(作⽤在字符串上，传⼊字符串参数，根据传⼊字符串作为分隔条件，将字符串转换成'''
>>> 'ABC'.join(['My', 'name', 'is', 'Simon'])
>>> 'MyABCnameABCisABCSimon'
>>> 'My name is Simon'.split()
['My', 'name', 'is', 'Simon']
MyABCnameABCisABCSimon'.split('ABC')
['My', 'name', 'is', 'Simon']
'''
#⽤rjust()、ljust()和center()⽅法对齐⽂本:
"""
>>> 'Hello'.rjust(20, '*')
'***************Hello'
>>> 'Hello'.ljust(20, '-')    # 第⼆个参数为可选参数，默认为空格
'Hello---------------'
>>> 'Hello'.center(20, '=')
'=======Hello========'
"""
# strip()、rstrip()和lstrip() 分别⽤于删除两边、右边和左边空⽩字符（也可以向它们传⼊字符串实参，删除两边对应的字符串）
# pyperclip 模块拷贝粘贴字符串：pyperclip 模块有copy()和paste()函数，⽤来复制和粘贴剪切板(需要安装第三⽅模块)
import pyperclip
a = pyperclip.paste()
print(a)
# 关于命令⾏参数sys.argv[1]：表⽰在运⾏命令提⽰符中运⾏py⽂件时输出的值就是sys.argv[1]，⽽sys.argv[0]则是这个变量本⾝（例如在C盘根⽬录运⾏cmd命令：C："""--------------------------------------------------------------第⼆部分---------------------------------------------------------------------"""
# 正则表达式
"""不使⽤正则表达式查号码。"""
def isPhoneNumber(text):  #号码格式为XXX-XXX-XXXX
if len(text) != 12:
return False
for i in range(0, 3):
if not              text[i].isdecimal():
return False
if text[3] != '-':
return False
for i in range(4, 7):
if not text[i].isdecimal():
return False
if text[7] != '-':
return False
for i in range(8, 12):
if not text[i].isdecimal():
return False
return True
message = 'Call me at 415-555-1011 tomorrow. 415-555-9999 is my office.'
for i in range(len(message)):
chunk = message[i:i+12]
if isPhoneNumber(chunk):
print('Phone number found: ' + chunk)
print('Done')
# 使⽤正则表达式查（正则表达式，简称为regex，是⽂本模式的描述⽅法）
import re                # Python 中所有正则表达式的函数都在re 模块中。 \d 表⽰⼀个数字字符； \d{3}表⽰匹这个数字3次（就是3位数）；
phoneNumRegex = repile(r'\d\d\d-\d\d\d-\d\d\d\d')    # Regex 对象的search()⽅法查传⼊的字符串
mo = phoneNumRegex.search('My number is 415-555-4242.')    # 如果字符串中没有到该正则表达式模式，search()⽅法将返回None。如果到了该模式，sear print('Phone number found: ' + mo.group())        # Match 对象有⼀个group()⽅法，它返回被查字符串中实际匹配的⽂本
"""
在Python 中使⽤正则表达式有⼏个步骤，但每⼀步都相当简单。
1．⽤import re 导⼊正则表达式模块。
2．⽤repile()函数创建⼀个Regex 对象（记得使⽤原始字符串）。
3．向Regex 对象的search()⽅法传⼊想查的字符串。它返回⼀个Match 对象。
4．调⽤Match 对象的group()⽅法，返回实际匹配⽂本的字符串。
"""
print('利⽤括号分组')
# 添加括号将在正则表达式中创建“分组”：(\d\d\d)-(\d\d\d-\d\d\d\d)。然后可以使⽤group()匹配对象⽅法，从⼀个分组中获取匹配的⽂本。
phoneNumRegex = repile(r'(\d\d\d)-(\d\d\d-\d\d\d\d)')
mo = phoneNumRegex.search('My number is 415-555-4242.')
ups())              # groups返回多个值的元组。
up(0))              # group⾮复数情况下不传⼊参数和传⼊0⼀样代表返回整个匹配⽂本。
up(1))
up(2))
aa, bb = mo.groups()            # 注意此处的groups  为复数后⾯有s
print(aa)
# 传递给repile()的原始字符串中，\(和\)转义字符将匹配实际的括号字符（同理想要正则表达式中匹配\ . ?等特殊符号可以⽤转义符进⾏转义）。
""" # 正则表达式符号:
匹配零次或⼀次前⾯的分组。    #此分组并⾮⼀定是（）分组，可以是单个字符
*匹配零次或多次前⾯的分组。
+匹配⼀次或多次前⾯的分组。
python正则表达式不包含
{n}匹配n 次前⾯的分组。
{n,}匹配n 次或更多前⾯的分组。
{,m}匹配零次到m 次前⾯的分组。
{n,m}匹配⾄少n 次、⾄多m 次前⾯的分组。
{n,m}?或*?或+?对前⾯的分组进⾏⾮贪⼼匹配。
^spam 意味着字符串必须以spam 开始。
^spam 意味着字符串必须以spam 开始。
spam$意味着字符串必须以spam 结束。
.表⽰“通配符”匹配所有字符，换⾏符除外。（可以⽤.*号匹配所有字符，默认使⽤贪⼼模式）
\d、\w 和\s 分别匹配数字、字母、数字或下划线字符（可以认为是匹配“单词”字符）和空格、制表符、换⾏符。
\D、\W 和\S 分别匹配数字、字母、数字或下划线字符（可以认为是匹配“单词”字符）和空格、制表符、换⾏符外的所有字符。
[abc]匹配⽅括号内的任意字符（诸如a、b 或c）。注意⽅括号内所有表达式符号会被解释，不需要写成\?  \) 或者\.
[^abc]匹配不在⽅括号内的任意字符。
|字符称为“管道”，匹配许多表达式中的⼀个时,，第⼀次出现的匹配⽂本，将作为Match 对象返回。
字符分类[aeiouAEIOU]将匹配所有元⾳字符，不论⼤⼩写  [0-9]匹配所有数字字符
"""
batRegex = repile(r'Batwo?man')  #  ?匹配零次或⼀次前⾯的分组。
mo1 = batRegex.search('The Adventures of Batwman')
up())
print('findall()⽅法')
# 除了search ⽅法外，Regex 对象也有⼀个findall()⽅法。search()将返回⼀个Match对象，包含被查字符串中的“第⼀次”匹配的⽂本，⽽findall()⽅法将返回⼀组字符
phoneNumRegex = repile(r'\d\d\d-\d\d\d-\d\d\d\d') # has no groups
print(phoneNumRegex.findall('Cell: 415-555-9999 Work: 212-555-0000')) #另⼀⽅⾯，findall()不是返回⼀个Match 对象，⽽是返回⼀个字符串列表
# output:['415-555-9999', '212-555-0000']  (返回⼀个列表)
# 如果在正则表达式中有分组，那么findall 将返回元组的列表
phoneNumRegex = repile(r'(\d\d\d)-\d\d\d-(\d\d\d\d)') # has groups
print(phoneNumRegex.findall('Cell: 415-555-9999 Work: 212-555-0000')) #
# output ： [('415', '9999'), ('212', '0000')]      注意只返回有分组的部分
# 也可以⽤句点号.匹配换⾏符，例如像repile()传递第⼆参数re.DOTALL可以让句点字符匹配所有字符，包括换⾏字符
newlineRegex = repile('.*', re.DOTALL)
# 要让正则表达式不区分⼤⼩写，可以向repile()传⼊re.IGNORECASE 或re.I，作为第⼆个参数
robocop = repile(r'robocop', re.I)
# ⽤sub()⽅法替换字符串，Regex对象的sub()⽅法需要传⼊两个参数。第⼀个参数是⼀个字符串，⽤于取代发现的匹配。第⼆个参数是⼀个字符串，即正则表达式namesRegex = repile(r'Agent \w+')        # sub()⽅法返回替换完成后的字符串
namesRegex.sub('CENSORED', 'Agent Alice gave the secret documents to Agent Bob.')
# output：'CENSORED gave the secret documents to CENSORED.'
# 在sub()的第⼀个参数中，可以输⼊\1、\2、\3……。表⽰“在替换中输⼊分组1、2、3……的⽂本”。具体⽤法如下
agentNamesRegex = repile(r'Agent (\w)\w*')
agentNamesRegex.sub(r'\1****', 'Agent Alice told Agent Carol that AgentEve knew Agent Bob was a double agent.')  # 把分组1中的(\w)放在需要替换的字符\1的位置# output： A**** told C**** that E**** knew B**** was a double agent.
# 忽略正则表达式字符串中的空⽩符和注释，可以向repile()传⼊变量re.VERBOSE，作为第⼆个参数。（可以将正则表达式放在多⾏中，并加上注释）：phoneRegex = repile(r'((\d{3}|\(\d{3}\))?(\s|-|\.)?\d{3}(\s|-|\.)\d{4}(\s*(ext|x|ext.)\s*\d{2,5})?)')  #这个复杂的正则表达式可以写成下⾯这样：
phoneRegex = repile(r'''(
(\d{3}|\(\d{3}\))?      # area code
(\s|-|\.)?        # separator
\d{3}        # first 3 digits
(\s|-|\.)        # separator
\d{4}        # last 4 digits
(\s*(ext|x|ext.)\s*\d{2,5})?  # extension
)''', re.VERBOSE)
# repile()函数只接受⼀个值作为它的第⼆参数。可以使⽤管道字符（|）将变量组合起来，从⽽绕过这个限制。管道字符在这⾥称为“按位或”操作符someRegexValue = repile('foo', re.IGNORECASE | re.DOTALL | re.VERBOSE)
print("\n项⽬：电话号码和E-mail 地址提取程序")
"""改程序在此处运⾏有问题，需要新建⼀个PY⽂件单独的把这个程序放进去才能正常获取电话或者邮件"""
import pyperclip, re

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。