在于copy，只是浅复制，只要复制源发生更改，复制的镜像也会跟着变化
deepcopy，是复制之后，等到一个新的复制对象
对于简单的 object，用 copy 和 deep copy 没区别
复杂的 object， 如 list 中套着 list 的情况， copy 中的 子list，并未从原 object 真的「独立」出来。也就是说，如果你改变原 object 的子 list 中的一个元素，你的 copy 就会跟着一起变。这跟我们直觉上对「复制」的理解不同。
import copy
spam = [1,2,[2,3]]
print(spam)
cop1=copy.copy(spam)
cop2=copy.deepcopy(spam)
cop3=spam
spam[2][0]=[1,2,3,4]
print('这是spam:',spam)
print('这是cop1:',cop1)
print('这是cop2:',cop2)
print('这是cop3:',cop3)
显示：
[1, 2, [2, 3]]
这是spam: [1, 2, [[1, 2, 3, 4], 3]]
这是cop1: [1, 2, [[1, 2, 3, 4], 3]]
这是cop2: [1, 2, [2, 3]]
这是cop3: [1, 2, [[1, 2, 3, 4], 3]]
--------------------------分割线-------------------------------------------------------------------
打印心形图：
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 j in range(0,6):
for i in range(0,9):
print(grid[i][j],end=' ')
print(end=' \n')
打印效果：
. . 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 . . . .
购物清单结构：
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')))
显示每个种类的数量：
题目：
import numpy as np
tableData = [['apples', 'oranges', 'cherries', 'banana'],
['Alice', 'Bob', 'Carol', 'David'],
['dogs', 'cats', 'moose', 'goose']]
colWidths = len(tableData)
rowWidths = len(tableData[0])
t=0
for k in range(0,colWidths):
for v in range(0,rowWidths):
if len(tableData[k][v])>t:
t=len(tableData[k][v])
text=''.rjust(t)
new_tableData=np.tile(text,(rowWidths,colWidths))
for k in range(0,colWidths):
for v in range(0,rowWidths):
new_tableData[v][k]=tableData[k][v]
#print(new_tableData[v][k].rjust(t+1),end='')
#print('\n')
print(new_tableData)
for k in range(0,rowWidths):
for v in range(0,colWidths):
print(new_tableData[k][v].rjust(t),end='')
print('\n')
效果：
正则表达式：
头文件：import re
re.complie()------------------匹配规则
.search()----------------------寻找可以匹配规则的段落
.group()-----------------------返回匹配的字符
.groups()---------------------返回所有匹配的字符
.findall()---------------------返回所有匹配的字符，返回一个字符串列表
*意味着“匹配零次或多次”，+（加号）则意味着“匹配一次或多次”。
（字符）?表明它前面的分组在这个模式中是可选的
.（句点）字符称为“通配符”
字符分类[0-5]只匹配数字 0 到 5，这比输入(0|1|2|3|4|5)要短很多
通过在字符分类的左方括号后加上一个插入字符（^），就可以得到“非字符类”。 非字符类将匹配不在这个字符类中的所有字符。
贪心和不贪心匹配只需要多个？
- ?匹配零次或一次前面的分组。
- * 匹配零次或多次前面的分组。
- +匹配一次或多次前面的分组。
- {n}匹配 n 次前面的分组。
- {n,}匹配 n 次或更多前面的分组。
- {,m}匹配零次到 m 次前面的分组。
- {n,m}匹配至少 n 次、至多 m 次前面的分组。
- {n,m}?或*?或+?对前面的分组进行非贪心匹配。
- ^spam 意味着字符串必须以 spam 开始。
- spam$意味着字符串必须以 spam 结束。
- .匹配所有字符，换行符除外。
- \d、\w 和\s 分别匹配数字、单词和空格。
- \D、\W 和\S 分别匹配出数字、单词和空格外的所有字符。
- [abc]匹配方括号内的任意字符（诸如 a、b 或 c）。
- [^abc]匹配不在方括号内的任意字符。.
- 正则表达式的(.*?)$部分，将匹配日期之后的任何文本
如果你希望在正则表达式中使用re.VERBOSE来编写注释，还希望使用re.IGNRECASE来忽略大小写，该怎么办？
遗憾的是，re.compile()函数只接收一个值作为它的第二个参数。可以使用管道字符串(|)将变量组合起来，从而绕过这个
限制。管道字符在这个称为“按位或”操作符。
项目：建立35个文件内50到测试题的答案和顺序
import random,os
#创建文件夹
if os.path.exists('Quiz') ==0:
print('创建文件夹Quiz')
os.mkdir('Quiz')
os.chdir('Quiz')
print(os.getcwd())
capitals = {'Alabama': 'Montgomery', 'Alaska': 'Juneau', 'Arizona': 'Phoenix',
'Arkansas': 'Little Rock', 'California': 'Sacramento', 'Colorado': 'Denver',
'Connecticut': 'Hartford', 'Delaware': 'Dover', 'Florida': 'Tallahassee',
'Georgia': 'Atlanta', 'Hawaii': 'Honolulu', 'Idaho': 'Boise', 'Illinois':
'Springfield', 'Indiana': 'Indianapolis', 'Iowa': 'Des Moines', 'Kansas':
'Topeka', 'Kentucky': 'Frankfort', 'Louisiana': 'Baton Rouge', 'Maine':
'Augusta', 'Maryland': 'Annapolis', 'Massachusetts': 'Boston', 'Michigan':
'Lansing', 'Minnesota': 'Saint Paul', 'Mississippi': 'Jackson', 'Missouri':
'Jefferson City', 'Montana': 'Helena', 'Nebraska': 'Lincoln', 'Nevada':
'Carson City', 'New Hampshire': 'Concord', 'New Jersey': 'Trenton', 'New Mexico': 'Santa Fe', 'New York': 'Albany', 'North Carolina': 'Raleigh',
'North Dakota': 'Bismarck', 'Ohio': 'Columbus', 'Oklahoma': 'Oklahoma City',
'Oregon': 'Salem', 'Pennsylvania': 'Harrisburg', 'Rhode Island': 'Providence',
'South Carolina': 'Columbia', 'South Dakota': 'Pierre', 'Tennessee':
'Nashville', 'Texas': 'Austin', 'Utah': 'Salt Lake City', 'Vermont':
'Montpelier', 'Virginia': 'Richmond', 'Washington': 'Olympia', 'West Virginia': 'Charleston', 'Wisconsin': 'Madison', 'Wyoming': 'Cheyenne'}
for quizNum in range(35):
quizFile=open('capitalsquiz%s.txt'%(quizNum+1),'w')
answerKeyFile=open('capitalsquiz_answer%s.txt'%(quizNum+1),'w')
#quizFile开头
quizFile.write('Name:\n\nDate:\n\nPeriod:\n\n')
quizFile.write((' ' * 20) + 'State Capitals Quiz (Form %s)' % (quizNum + 1))
quizFile.write('\n\n')
states = list(capitals.keys())
random.shuffle(states)
#设置正确答案:
for questionNum in range(50):
correctAnswer = capitals[states[questionNum]]
wrongAnswers = list(capitals.values())
del wrongAnswers[wrongAnswers.index(correctAnswer)]
wrongAnswers = random.sample(wrongAnswers, 3)
answerOptions = wrongAnswers + [correctAnswer]
random.shuffle(answerOptions)
#写入问题和答案
quizFile.write('%s. What is the capital of %s?\n' % (questionNum + 1,states[questionNum]))
for i in range(4):
quizFile.write(' %s. %s\n' % ('ABCD'[i], answerOptions[i]))
quizFile.write('\n')
#写入对应的答案到标准答案
answerKeyFile.write('%s. %s\n' % (questionNum + 1, 'ABCD'[answerOptions.index(correctAnswer)]))
quizFile.close()
answerKeyFile.close()
send2trash 模块，用于删除、移动、复制文件，shutil 模块下的rmtree是永久删除文件夹及下面的子文件，unlink是删除文件，备注子文件必须为空。
项目：复制图片
import shutil,os,re
os.chdir('E:\python')
if not os.path.exists('picture_copy'):
os.mkdir('picture_copy')
print(os.getcwd())
pathName=str(input('请输入需要搜索的地址名称：'))
picRegex=re.compile(r'''
(\.pic|\.jpg|\.jepg|\.png){1}
''',re.VERBOSE)
#匹配是否只是一个硬盘的盘符,若如只输入C即搜索C盘，若是其他盘符子级文件，不必更改文件地址
pathRegex=re.compile(r'(.:\\)')
mo=pathRegex.search(pathName)
if not mo:
pathName=pathName+':\\'
#print(pathName)
#遍历所有满足的文件
for folderName,subfolders,fileNames in os.walk(pathName):
for fileName in fileNames:
matchFile=picRegex.search(fileName)
if matchFile ==None:
continue
fileNamesPath=folderName+'\\'+fileName
print(fileNamesPath)
shutil.copy(fileNamesPath,'E:\python\picture_copy')
print('%s has been copied'%(fileName))
print('搜索完毕，已经没有图片可以复制！')
调试与报错：
如果没有 try 和 except 语句覆盖抛出异常的 raise 语句，该程序就会崩溃，并显示异常的出错信息。
import requests
res = requests.get('http://inventwithpython.com/page_that_does_not_exist')
#用于提醒下载状态
try:
res.raise_for_status()
except Exception as exc:
print('There was a problem: %s' % (exc))
json.loads:导入json数据
json.dumps:将python数据转换为json格式
Unix 纪元时间戳（time 模块中使用）是一个浮点值或整型值，表示自 1970 年 1 月 1 日午夜 0 点（UTC）以来的秒数。
datetime 对象（属于 datetime 模块）包含一些整型值，保存在 year、month、day、
hour、minute 和 second 等属性中。
timedelta 对象（属于 datetime 模块）表示的一段时间，而不是一个特定的时刻。
下面回顾了时间函数及其参数和返回值：
time.time()函数返回一个浮点值，表示当前时刻的 Unix 纪元时间戳。
time.sleep(seconds)函数让程序暂停 seconds 参数指定的秒数。
datetime.datetime(year, month, day, hour, minute, second)函数返回参数指定的时
第 15 章 保持时间、计划任务和启动程序
刻的 datetime 对象。如果没有提供 hour、minute 或 second 参数，它们默认为 0。 datetime.datetime.now()函数返回当前时刻的 datetime 对象。
datetime.datetime.fromtimestamp(epoch)函数返回 epoch 时间戳参数表示的时刻
的 datetime 对象。
datetime.timedelta(weeks, days, hours, minutes, seconds, milliseconds, microseconds)函
数返回一个表示一段时间的 timedelta 对象。该函数的关键字参数都是可选的，
不包括 month 或 year。 total_seconds()方法用于 timedelta 对象，返回 timedelta 对象表示的秒数。
strftime(format)方法返回一个字符串，用 format 字符串中的定制格式来表示
datetime 对象表示的时间。详细格式参见表 15-1。 datetime.datetime.strptime(time_string, format)函数返回一个 datetime 对象，它的
时刻由 time_string 指定，利用 format 字符串参数来解析。
#function - 线程函数。
# args - 传递给线程函数的参数,他必须是个tuple类型。
# kwargs - 可选参数。*
Python通过两个标准库thread和threading提供对线程的支持。
thread提供了低级别的、原始的线程以及一个简单的锁。
threading 模块提供的其他方法：
threading.currentThread(): 返回当前的线程变量。
threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
threading.activeCount(): 返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。
除了使用方法外，线程模块同样提供了Thread类来处理线程，Thread类提供了以下方法:
run(): 用以表示线程活动的方法。
start():启动线程活动。
join([time]): 等待至线程中止。这阻塞调用线程直至线程的join() 方法被调用中止-正常退出或者抛出未处理的
异常-或者是可选的超时发生。
isAlive(): 返回线程是否活动的。
getName(): 返回线程名。
setName(): 设置线程名。
364
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
