python函数及代码复用
函数
dir
#dir(x)，可以查询到x相关的函数，x可以是模块，也可以是任意一种对象。举例如下所示：
import math
print(dir(math))
##这样可以把模块中的函数（函数和类方法）一览无余地暴露出来。对于查到的结果"__xx__"结构的(如__doc__)，它们是系统相关的函数，我们不用理会，直接看全英文的函数名即可
##dir(x)，可以查询到x相关的函数，x可以是模块，也可以是任意一种对象
即可完成。
函数中的def
全局变量是在函数之外定义的变量，载程序之行过程中全程有效。
如下代码：
def hub(ss,x=2.0,y=4.0):
ss+=x*y
ss=10
print(ss,hub(ss,3))输出结果为：
10 None
因为ss=10在函数中并没有说明。
ss=10
def hub(ss,x=2.0,y=4.0):
ss+=x*y
print(hub(ss,3))
输出结果为：
10 None
函数没有返回值，所以输出的是None
解决的办法，是给函数加上return，即函数的返回值。如下代码所示：
ss=10
def hub(ss,x=2.0,y=4.0):
ss+=x*y
return ss
print(hub(ss,3))
输出结果为：
22.0
这是因为函数有了return，所以有了返回值。
定义函数
代码举例如下：
'''2.10
.1
function
'''
def add(num1, num2):
return num1 + num2
print("f=add(12,34)",add(12,34))
print(add(3,5))
def run():
print("begin...")
print("run......")
print("end...")
print(run())
def f4(num1, num2, oper):
if oper=='+':
print(num1 + num2)
elif oper=='-':
print(num1-num2)
elif oper=='*':
print(num1 * num2)
elif oper=='/':
print(num1 / num2)
print("f=f4():",f4(1,3,'+'))
def f5(num1, num2, oper):
if oper == '+':
return num1 + num2
if oper == "-":
return num1 - num2
if oper == "*":
return num1 * num2
if oper == "/":
return num1 / num2
print(run())
ret = f5(10, 3, '/')
print(ret)
ret = f5(10, 3, '*')
print(ret)
def f2():
print('f2...begin...')
f1()
print('f2...end...')
def f1():
print('f1...begin...')
print("f2...end...")
def myfunc1(num):
num += 10
print("My function's number is{}".format(num))
ret = 20
myfunc1(ret)
print('ret=', ret)
def myfunc1(num):
num.append(10)
print("My function's number is{}" .format(num))
ret = [20]
myfunc1(ret)
print("ret=", ret)
def func1(num1, num2):
print("num1={},num2={}".format(num1, num2))
print("func1",func1(100, 200))
print()
print(func1(200, 100))
def func2(num1, num2=1):
print('num1={},num2={}'.format(num1, num2))
func2(100, 200)
func2(100)
def func3(*args):
print(type(args))
print(args)
func3()
func3(1)
func3(110, 119, 120, 911)
def func3(*args):
print(sum(args))
list = [182, 120, 119]
print(func3(*list))
def func4(num1, num2):
print("num1={0},num2={1}".format(num1, num2))
func4(100, 200)
func4(num2=100, num1=200)
num = 1000
def fun2(num1):
num2 = 200
print('num={},num1={}, num2 = {}'.format(num,num1,num2))
fun2(100)
print(num)
print("f=add__",add(3,4))
def fun3(num1):
global num2
num2 = 200
print('num1={},num2={}'.format(num1, num2))
fun3(100)
print(num2)
num1 = 100
import sys
print(sys.getrecursionlimit())
def func1(num):
if num == 1 or num == 2:
return 1
return func1(num - 1) + func1(num - 2)
for i in range(1, 11):
print(func1(i),end="",sep=" ")
func1 = lambda x: x + 1
def f2(x):
return x + 1
print("x+1",f2(3),end=" ")
函数中的return
质数-return导出-语句按照顺序执行-for-else
#return返回值是和外界沟通的，调用函数后，再定义一个值把函数结果调用出来方可。
"函数return安照语句顺序"
def fIsPrime(N):
if N<2:return False
if N==2:return True
if N>2:
for i in range(2,N):
if N%i==0:return False
else:return True#虽然执行后面的语句，return按照顺序优先导出
def fIsPrime(N):
if N<2:return False
if N==2:return True
if N>2:
for i in range(2,N):
if N%i==0:return False
return True#return按照顺序优先导出.所以这一句中的else是前面都没有导出True的时候再导出。位置在哪儿都行。
def fTest():
return False
for i in range(1,10):
if i%2==0:
return True
if fTest()==False:print("虽然执行后面的语句，return按照顺序优先导出")
具体操作实例如下：
'''''
20191023 作业
1、作业压缩包中有名为“AllMenAreBrothers.txt”【水浒传】、 “TheStoryoftheStone.txt”【红楼梦】名著文本文件，编码格式为 utf-8。
打开时按课堂示例，open()时指定编码格式。完成如下要求：
2、 要求获得每一个汉字（红楼梦和水浒传并集的汉字）【不包括空格、换行符号】出现次数，
如果某个字在其中一部小说出现，但在另外一部小说不出现，则没有出现的小说记为 0，
并将上述数据输出到文件 HZ.txt。
该文件共计三列， 第一列是汉字，第二列是水浒传中该字出现次数，第三列为红楼梦中出现次数。
每一列之间用英文逗号分开。
'''''
#第一步：
# 获得每一个汉字（红楼梦和水浒传并集的汉字）【不包括空格、换行符号】出现次数，
#如果某个字在其中一部小说出现，但在另外一部小说不出现，则没有出现的小说记为 0，
#并将上述数据输出到文件 HZ.txt。
#myFile=open("myFile.txt","wt")
file1 = open("AllMenAreBrothers.txt", "rt", encoding="utf-8") # 水浒是文件一。
txt1 = file1.read()
file1.close()
file2=open("TheStoryoftheStone.txt","rt",encoding="utf-8")
txt2=file2.read()
file2.close()
def TXT(txt1):
dic1={}
excludes={' ','\n'}
for character in txt1:
if character not in dic1:
dic1[character]=1
else:
dic1[character]+=1
for character in excludes:
del(dic1[character])
list1=list(dic1.items())
list1.sort(key=lambda x:x[1],reverse=True)
#print(list1[:10])
Set1 = set(list1)
print(Set1)
return(Set1) #return返回值是和外界沟通的，调用函数后，再定义一个值把函数中的值接着。
charSet1=TXT(txt1) #!!!!书写，是按照这样的顺序。
charSet2=TXT(txt2)
print("交集",charSet1.intersection(charSet2))
print("并集",charSet1.union(charSet2))
#myFile.close()
如下图所示代码：
def func(ls= []):
ls. append(1)
return ls
print(func())#[1]
b= func()
print(b)
print(func())
print(func())
####print(a,b)运行结果如下：
[1]
[1, 1]
[1, 1, 1]
[1, 1, 1, 1]
原因是，每次一使用函数func，这个函数就会在前面的基础上进一步增加元素。这个函数在整个程序运行过程中，所在的列表也都一直在变化。
(1) 函数定义
使用 def 保留字将一段代码定义为函数，需要确定函数名、参数名、参数的个数，使用参数名 称作为形式参数（占位符）编写函数内部的功能代码。
(2) 函数调用
通过函数名调用函数功能，对函数的各个参数赋予实际值，实际值可以是实际数据，也可以
是在调用函数前已经定义过的变量。
(3) 函数执行
函数被调用后，使用实际参数（赋予形式参数的实际值）参与函数内部代码的运行，如果有
结果则进行输出。
(4) 函数返回
函数执行结束后，根据 return 保留字的指示决定是否返回结果，如果返回结果，则结果将被
放置到函数被调用的位置，函数使用完毕，程序继续运行。
内置函数
center
如下代码所示：
str="I love China"
print(str.center(20,"&"))
print(str.center(20))chr ,ord 输出一门语言的字母
函数包留下英语字符
#以英语为例
for x in range(ord("A"),ord("Z")+1):
print(chr(x))留下汉语字符
过滤掉非汉语字符，这个需要记忆。
def isChinese(ch):
if 19968<=ord(ch)<40869:return True;
return False
#unicode汉字编码范围，19968-40869，即十六进制范围4E00-9FA5举例如下：
对文件进行字符频次统计，输出频次最高的中文字符（不包括标点符号）及其频次，字符与频次之间采用英文冒号“:”分隔
代码如下：
d = {}
file=open("命运.txt","r",encoding="utf-8")
data=file.read()
file.close()
for i in data:
if 19968<=ord(i)<40869:
d[i]=d.get(i,0)+1
l=list(d.items())
l.sort(key=lambda x:x[1],reverse=True)
print(f"{l[0][0]}:{l[0][1]}")
即可完成。
计算机转码，
代码如下所示：
# -*- coding: utf-8 -*-
"""
Created on Sat Jul 6 22:51:51 2019
@author: cc
"""
a=int(input("请输入ASCII码："))
print(a,"对应的字符为",chr(a))
b=input("请输入一个字符：")
print(b,"对应的ASCII码为",ord(b))
在Python中，ord()函数用于返回指定字符的Unicode码。Unicode是一种字符集为每个字符分配了一个唯一的数字码点。
ord()函数的语法是：
ord(character)
其中，character是要获取Unicode码的字符。
以下是一些例子来说明ord()函数的作用：
print(ord('A')) # 输出：65
print(ord('a')) # 输出：97
print(ord('中')) # 输出：20013
在上述例子中，ord()函数返回了字符’A’的Unicode码65，字符’a’的Unicode码97，以及字符’中’的Unicode码20013。
eval
eval()用来计算字符串的值。在某些场合可以实现类型转化。
# 简单的数学运算
x = 10
y = 20
result = eval("x + y")
print(result) # 输出 30
# 使用变量和函数
def square(x):
return x * x
result = eval("square(5)")
print(result) # 输出 25
# 列表推导式
result = eval("[x*x for x in range(1, 6)]")
print(result) # 输出 [1, 4, 9, 16, 25]
s=0
for i in result:
s+=i
print(s)
# 危险的使用（不要这样做！）
# 假设用户输入了恶意的代码
user_input = input("请输入一个表达式：")
result = eval(user_input) # 这可能会导致安全问题又如下代码所示：
while True:
guess=eval(input())#eval函数将字符串转化为数字进行了运算。
if guess==0x452//2:
break
print(guess)#输出553
a=eval("0x452//2")
print(a)#输出553
即可完成。
filter
代码如下：
#同时做一个排序的函数。用函数的结果作为排序的依据。
def SumScore():
pass
#可以通过key 作为函数排序的依据，相当于把key 作为相应的函数。
#python的过滤函数。
#filter
myData = [2, 3, 4, 5, 6, 7, 8, 78, 0, 4]
afterData=list(filter(lambda x:x>=3,myData))
print(afterData)
def isPrime():
pass
for i in filter(isPrime,range(90,100)):#用filter筛选出90到100的质数。
print(i)
myList=list(filter(isPrime,range(100,150)))#用filer很简洁的语言来筛选。
for i in filter(lambda X:not isPrime(X),range(100,150))
''' #根据之气那的求质数方程，返回true 和false。可以求反。即可完成。
find， find_all
代码如下：
#Python find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。
'''
find()方法语法：
str.find(str, beg=0, end=len(string))
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
BeautifulSoup 文档里，find、find_all两者的定义如下：
find_all(tag, attributes, recursive, text, limit, keywords)
find_all（标签、属性、递归、文本、限制、关键词）
find(tag, attributes, recursive, text, keywords)
find与find_all的区别，find只会取符合要求的第一个元素，find_all会根据范围限制参数limit限定的范围取元素（默认不设置代表取所有符合要求的元素，find 等价于 find_all的 limit =1 时的情形），接下来将对每个参数一一介绍。
另外，find_all会将所有满足条件的值取出，组成一个list
'''
#实例
str1 = "this is string example....exam 1 =119;esam2=112;exam3=114。参加exam ，我对知识的复习巩固就提升了。wow!!!"
str2 = "exam"
print(str1.find(str2))
#输出15
print(str1.find(str2, 10))
#输出15
print(str1.find(str2, 30,40))
#输出-1
print(str1.find(str2,10,len(str1)))
#输出15
num1=str1.find(str2)
print(str1[num1])#输出结果为e
format
format函数更确切的说法是字符串对象的方法。
花括号中有各种变化，总体来讲，分为两个部分，分别以冒号分隔。冒号前是序号或 名称，冒号后是格式。
print("{0:3.2f}".format(3.1415926))如代码所示，
第1个0，表示format()参数中编号为0的参数，在该处编号为0的参数即3.1415926。
冒号，表示格式在冒号后面
3，表示总长度为3
.2，表示小数点后保留2位。
代码举例如下：
num1=54.1415926
print("{0:5.0f}".format(num1))#选择编号为0的参数，长度为5，小数点后保留0位，即实现取整。
字符长度，代码如下：
dictionary1={'URL':"www.54.cn"}
print("my website is{URL}".format(dictionary1))
tmp=[3,4,5,6]
print("测试，为{}摄氏度。".format(tmp[2]))
#Formatted string literals
name = "Fred"
>>> f"He said his name is {name!r}."
"He said his name is 'Fred'."
>>> f"He said his name is {repr(name)}." # repr() is equivalent to !r
"He said his name is 'Fred'."
>>> width = 10
>>> precision = 4
>>> value = decimal.Decimal("12.34567")
>>> f"result: {value:{width}.{precision}}" # nested fields
'result: 12.35'
format 小数点
代码如下：
print("{} {}".format("hello","world"))
print("{1} {0}".format("hello","world"))
print("{1} {0} {1}".format("hello","world"))
print("{0} {1}".format("hello","world"))
print("{0}{1}{1}".format("hello","world"))
print("{:.2f}".format(3.1415926))
print("{:+.2f}".format(3.14159))
print("{:+.2f}".format(-3.1415926))
print("{:.0f}".format(3.1415926))
print("{:0>8d}".format(7))
print("{:x<4d}".format(7))
print("{:x<4d}".format(700))
print("{:,}".format(10099334))
print("{:.4e}".format(1870000000))
#location space
print("{:<10d}".format(4532))
print('{:>10d}'.format(87338))
print("{:^10d}".format(88344))
#JinZhi
print("进制转换189")
print("{:b}".format(189)," ",189)
print("{:d}".format(189))
print("{:o}".format(189)," ",189)
print("{:x}".format(189)," ","189")
print()
print("{:.0f}".format(3.1415926))代码如下：
s="PYTHON"
print("{0:1}".format(s))#PYTHON
s=19899
print("{0:1}".format(s))#19899在这个代码中，"{0:1}"是一个格式化字符串，其中的0表示要格式化的对象的索引（即s字符串），而1表示想要格式化的最小字段宽度。在这种情况下，最小字段宽度为1，因此输出的字符串将至少具有1个字符的宽度。由于s字符串有6个字符，因此完整输出了整个字符串。如果想要只输出一个位置长度的“P”，可以将最小字段宽度设置为1，然后使用切片来截取字符串的第一个字符，如下所示：
s=“PYTHON”
print(“{0:1}”.format(s)[0])lambda
lambda 匿名函数。匿名函数用lambda关键字定义。lambda 的没有括号。def定义的是具名函数。
代码如下：
list1 = [1, 2, 3, 4]
list2 = [4, 5, 6, 9]
list3 = list(map(lambda x, y: x + y, list1, list2))
print(list3)
#lambda是匿名函数。不适用def 标准语句。
sum=lambda x,y:x+y
print(sum(12,20))
list1 = [0,3,8,2,8,99,1, 2, 3, 4]
lambada可以和sort结合，如下所示：
#认识lambda 匿名函数。匿名函数用lambda关键字定义。lambda 的没有括号。def定义的是具名函数。
# lambda 用于小体量的一次性函数，避免污染换进，简化代码。
#dynasty.sort(key=lambda x:x[1],reverse=True)
myData.sort(key=lambda x:x%5)#仍然以除以5排列
print(myData)
myData=[2,3,4,5,6,7,8,78,0,4]
myData.sort()#默认按升序纪念性排序。
myData.sort(reverse=True)#反序排列输出排序。
print(myData)
#首先要把这些基本的语法明白。老师的课件上的程序可以写一些。
#身份证上如何做到按照年月排序。
myData=list(range(1,100))
print(myData)
myData.sort(reverse=True)
def Mod5(N):
return N%5
myData.sort(key=Mod5)#可以称作排序函数，注意没有括号
print("OK")
myData=list(range(1,100))
print(myData)
myData.sort(reverse=True)
def Mod5(N):
return N%5
myData.sort(key=Mod5)#相当于把每个数交给这个函数来说出来，按照优先来排序。此处Mod5没有括号，
print(666)
replace
函数-replace-千分位去逗号-代替
a=float(everynum2.replace(',', ''))
'''
https://blog.csdn.net/qq_40584718/article/details/79712716
问题：将a='1,077'怎么转化为a=1077背景：就是在网页抓取时，有时会碰到这种计数风格，就很纠结，
直接引用int(),float()等都会出现错误，因为这个逗号，无法识别。
然后就考虑用到replace，直接将‘，’换成‘’，然后int(),不就解决了吗？
但是我昨晚刚好绕过了这种方法，当时想着，replace(',',' '),换成了空格，
然后又用了一次strip，居然又回去了。
最后直接的方法是这样子的：int(a.replace(',',''))
'''strip
代码如下：
#Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
#注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
#(￣▽￣)"
#★★★开头，结尾，删除。
#★汉语u输入法很神奇。
strNumber = "00000003210Runoob01230000000"
a=strNumber.strip('0')#注意里面得是字符串。
print(a)
str2 = " Runoob " # 去除首尾空格
print(str2.strip())
list2=['北京,116649_26257\n','天津,75633_1684\n','上海,32633_1684\n']
dic={}
for i in list2:
it = i.split(",") #用split()分割。这样就把一个长的字符串分割成小的字符串。
print(it)
it3=it[1].split("_") #it[1]指的是'116649_26257\n'
print(it3)
it2 = it[1].strip().split("_")#注意，得加引号strip(),去掉空格，去的是\n
print(it2)
dic[it[0]] = it2 #用dic[word]=XXX,让列表中元素转换为字典键。
print()
print(dic)
print("列表到字典")即可完成。
split 切分
切分的鄂时候，需要审题。
s ='an apple a day'
def split(s):
return s.split('a')
print(s.split())#['an', 'apple', 'a', 'day']
print(s.split(s))#['', '']
print(split(s))#['', 'n ', 'pple ', ' d', 'y']
切分代码如下：
list2=['北京,116649_26257\n','天津,75633_1684\n','上海,32633_1684\n']
'''
dic={}
for i in list2:
it = i.split(",") #用split()分割。这样就把一个长的字符串分割成小的字符串。
print(it)
it3=it[1].split("_") #it[1]指的是'116649_26257\n'
print(it3)
it2 = it[1].strip().split("_")#注意，得加引号strip(),去掉空格，去的是\n
print(it2)
dic[it[0]] = it2 #用dic[word]=XXX,让列表中元素转换为字典键。
print()
print(dic)
print("列表到字典")
'''
list2=['北京,116649_26257\n','天津,75633_1684\n','上海,32633_1684\n']
dic={}
for i in list2:
it1=i.strip("\n")
it= it1.split(",") #用split()分割。这样就把一个长的字符串分割成小的字符串。北京,116649_26257\n'分成了两个部分。
itanother=it[1].split("_")
print(itanother)
dic[it[0]]=itanother
print(dic)
#print(it)
#print(it[1])
#print(it[0])
#print()
#year=it[1].split("_")
#print(year)
即可完成。
# -*- coding: utf-8 -*-
"""
Created on Wed Jul 3 14:44:58 2019
@author: cc
"""
a=list('hello')
print(a)
name="Johen dikey"
b=list(name)
# a=name.split()
# print(a)
print(b)
a=['I',"LOVE",'YOU',"!"]
b=' '.join(a)
print(b)
print()
sen="hello good boy"
c=sen.split()
print(c)
len(c)
sort reverse 正序和反序
sort默认的是从小到大的排序。
# -*- coding: utf-8 -*-
"""
Created on Wed Jul 3 15:12:36 2019
@author: cc
"""
print("输入整数，大小排序，中间用空格分开")
nums=input("请输入数据：")
numLine=[int(n) for n in nums.split()]
numLine.sort()
print(numLine)
反序，用reverse。
a=int(input("请输入一个正整数："))
b=list(str(a))
b.reverse() #原来，直接用b.reverse()就可以把顺序弄反过来。b的名称不变，但是内容却发生了变化。后面环环相扣。
if int(b[0])==0: #注意==是两个。由于写了一个=号，程序没有运行出来，花费了大量时间找问题。经验教训。
del b[0]
list2="".join(b)
print(list2)
else:
list2="".join(b)
print(list2)
#注意：==是两个。由于写了一个=号，程序没有运行出来，花费了大量时间找问题。
如果想要取得最高分或者最大数，则需要加上“reverse=True”这样的说明。
'''
'''
f=open("name.txt","r",encoding="utf-8")
names=f.readlines()
f.close()
f=open("vote.txt","r",encoding="utf-8")
votes=f.readlines()
f.close()
D={}
NUM=0
for vote in votes:
num = len(vote.split())
if num==1 and vote in names:
D[vote[:-1]]=D.get(vote[:-1],0)+1
NUM+=1
l=list(D.items())
l.sort(key=lambda s:s[1],reverse=True)
print(l)
name=l[0][0]
score=l[0][1]
print("有效票数为：{} 当选村民为:{}，票数为：{}".format(NUM, name, score))
即可完成。
sorted
sorted-字符串排序-位-产生新列表。
a=[0,5,2,11,4]
sorted(a,key=lambda x:str(x))
print(a)#sorted()会生成一个新的列表，所以a 还是原来的a
b=sorted(a,key=lambda x:str(x))#sorted生成新列表。字符串排序依据是位序列派。先看第一位，再看第二个位。
print(b)
time
时间-time-暂停，代码如下：
time.sleep(60+random.randint(0,59))
#60加上随机数——>暂停时间
#输出时间格式。当地时间和国标时间。
import time
print('time函数输出时间格式',time.ctime(time.time()))
print(time.asctime(time.gmtime(time.time())))
import time
myTime=time.strptime('20180301152351','%Y%m%d%H%M%S')#strptime:string prensenting time，用字符数表达的时间。time函数。
myTimStamp=time.mktime(myTime)#我的时间戳。time 函数。mktime:Convert a time expressed in seconds
此前为了实现时间换算，写的代码如下，但是比较繁琐：
'''
这些例题来自：菜鸟教程/python/python3实例
题目非常好,随时可以联系
获取几天前地时间并转化为指定格式
'''
time.strptime(‘2018-10-07’, ‘%Y-%m-%d’)#将 字符串形式时间（strptime）转化为 切分形式的标准形式时间（strcut_time）
time.strftime(’%Y-%m-%d’, struct_time) #将标准形式时间（strcut_time）转化为字符串形式。
#时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。返回的是flot类型的数字。产生时间戳方式的函数主要有time()，clock()等。
mylist=[['SUB', '70456597', '1', '000-006', '10', '20180301133335', '41', '8', '20180301141529', '25', 'NM'],['SUB', '70456597', '1', '000-006', '8', '20180301090724', '15', '10', '20180301100018', '41', 'NM']]
def zhuanHua():
import time
for i in myList:
myUpTime=time.mktime(time.strptime(i[upTime],'%Y%m%d%H%M%S'))#strptime:用字符数表达的时间。mktime:用时间戳表示的函数。二者都是time包的内置函数。
myDownTime=time.mktime(time.strptime(i[downTime],'%Y%m%d%H%M%S'))
print(myUpTime)
input()
##
##import time
##
##myTime=time.strptime('20180301152351','%Y%m%d%H%M%S')#strptime:string prensenting time，用字符数表达的时间。time函数。
##print(myTime)
##myTimStamp=time.mktime(myTime)#我的时间戳。time 函数。mktime:Convert a time expressed in seconds
##
##
#转化字符串日期为容易读的格式
import time
import datetime
mydatetime=datetime.datetime.now()
print('当前时间',mydatetime)
timeStamp=time.mktime(mydatetime.timetuple())
print('当前时间戳：',timeStamp)
StrTime=mydatetime.strftime("%Y-%m-%d")
StrTime2=mydatetime.strftime("%m-%d")
print('当前时间的另一种表示',StrTime,'or',StrTime2)
#计算时间差。
import time
start=time.clock()
for i in range(100):
print(i)
end=time.clock()
print('两者时间差是{}'.format(end-start))
import time
import datetime
#先获得时间数组格式地日期
threeDayAgo=(datetime.datetime.now()-datetime.timedelta(days=3))
print(threeDayAgo)
#转化为时间戳
timeStamp=int(time.mktime(threeDayAgo.timetuple()))
print(timeStamp)
#转化为其他字符串格式
otherStytleTime=threeDayAgo.strftime('%Y-%m-%d %H:%M:%S')
print(otherStytleTime)
#给定时间戳
timeStamp=1557502800
dateArray=datetime.datetime.utcfromtimestamp(timeStamp)
threeDayAgo=dateArray-datetime.timedelta(days=3)
print(threeDayAgo)
两者相比，前者更加优美简洁。
这里提到了“时间戳”的概念。
'''
一边看着ipad上的例题，一遍用电脑实验做题，效率非常高。
时间戳（timestamp），一个能表示一份数据在某个特定时间之前已经存在的、 完整的、 可验证的数据,通常是一个字符序列，唯一地标识某一刻的时间。使用数字签名技术产生的数据， 签名的对象包括了原始文件信息、 签名参数、 签名时间等信息。广泛的运用在知识产权保护、 合同签字、 金融帐务、 电子报价投标、 股票交易等方面。
时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数
利用时间戳可以方便地比价时间差别。
'''
#一、将时间戳转换为指定格式日期时间
import time
now=int(time.time())
print(now)
#获得当前的时间戳，数字形式
timeArray=time.localtime(now)
print(timeArray)
#获得当前时间
otherStytleTime=time.strftime('%Y-%m-%d %H:%M:%S',timeArray)
print(otherStytleTime)
#将当前时间用另一种格式展现
#二、将指定格式日期时间转换为时间戳
a1='2019-12-17 20:55:47'
import time
timeArray=time.strptime(a1,'%Y-%m-%d %H:%M:%S')
print(timeArray)
#转化为了时间数组
timestamp=int(time.mktime(timeArray))
print(timestamp)
#转化为了时间戳
a1='20191217205547'
import time
timeArray=time.strptime(a1,'%Y%m%d%H%M%S')
#print(timeArray)
#转化为了时间数组
timeChuo=int(time.mktime(timeArray))
print(timeChuo)
print(now-timeChuo)
即可完成。
type
代码如下：
def func():
print("hello")
print(type(func))#<class 'function'>
print(type(func()))#<class 'NoneType'>zip
python中，程序读人一个表示星期几的数字(1-7),输出对应的星期字符串名称。例如:输入3,返回“星期三”。
代码如下：
idict={}
numList=[str(i) for i in range(1,8)]#输入数字
hanStr="一二三四五六七"#对应汉字字符
xy=zip(numList,hanStr)
for i in xy:
idict[i[0]]=i[1]
#print(idict)
day=input("请输入阿拉伯数字表示星期几：")
print(f"今天是星期{idict[day]}。")
即可完成。
生活场景简单应用
生成随机密码
代码如下：
myList=[str(i) for i in range(10)]+[chr(i) for i in range(ord("A"),ord("Z")+1)]
from random import choice
print("".join([choice(myList) for i in range(8)]))
即可完成。
字符串的大小写转化
代码如下：
s = "Hello World"
print(s.lower()) # 输出：hello world
print(s.upper()) # 输出：HELLO WORLD
print(s.swapcase()) # 输出：hELLO wORLD
s = "hello world"
print(s.capitalize()) # 输出：Hello world
即可完成。
华氏转为摄氏
# -*- coding: utf-8 -*-
"""
Created on Mon Jul 1 10:24:39 2019
@author: cc
"""
lower,higher=input("请输入华氏温度上下界,中间用空格空开：").split()
lower,higher=int(lower),int(higher)
for i in range(lower,higher,2):
print("华氏",i, "摄氏""{:.2f}".format(5*(i-32)/9))
if密码
# -*- coding: utf-8 -*-
"""
Created on Tue Jul 2 21:20:15 2019
@author: cc
"""
x,y=map(int,input("请输入密码和验证数字：").split())
if x==12345:
if y==1:
print("通过")
else:
print("继续等待")
else:
print("不得通过")
地下城数字
# -*- coding: utf-8 -*-
"""
Created on Wed Jul 3 15:20:59 2019
@author: cc
"""
a=[1,2,3,4,5,6,7,78,8,7,0]
x=int(input("请输入你手中的随机数字："))
found=False
for k in a:
if k==x:
found=True
print("恭喜您进入地下城")
break
if False:
print("很遗憾，数字不符，未能进入地下城")
print("结束")
阿拉伯数字转化为大写数字
代码如下所示：
"""
卷一239
卷二285
卷三137
卷四159
卷五246
卷六95
"""
bstr="〇一二三四五六七八九"
numlist=[str(i) for i in range(0,10)]
xy=zip(numlist,bstr)
mydict={}
for i in xy:
mydict[i[0]]=i[1]
for i in range(1,240):
numStr=str(i)
hysz=""
for i in numStr:
hysz+=mydict[i]
print(hysz)
即可完成。
猜拳游戏
代码如下：
import random
myList=["剪刀","石头","布"]
def CaiQuan():
print("剪刀","石头","布")#充分利用三者之间循环而产生的相生相克
computerChoice=random.choice(myList)
playerChoice=input("请输入：")
print(computerChoice,playerChoice)
if computerChoice==playerChoice:
print("平局")
return 0
elif computerChoice==myList[myList.index(playerChoice)-1]:
print("玩家胜利")
return 1
else:
print("电脑胜利")
return 2
computerScore=0
playerScore=0
for i in range(5):
myNum=CaiQuan()
if myNum==1:
playerScore+=1
elif myNum==2:
computerScore+=1
else:
playerScore,computerScore=playerScore,computerScore
print()
print("电脑",computerScore,"VS",playerScore,"玩家")
计算古韵反切规律
代码如下：
#这个程序用来计算王韻反切的規律
myFile=open('wangYun.txt','r',encoding='utf-16')
myData=myFile.read()
myFile.close()
#print(myData)
yunMu=0
daiBiaoZi=1#左邊王韻，右邊廣韻。
wangYun=2#反切下字
guangYun=3
firstNum=0#第一個被切字
myList=[]#用到的所有反切下字
wrongList=[]
myDict={}
myData=myData.splitlines()
#Fun()從文本中提取出分析的韻，放到列表lineList
lineList=[]
changeYun='東'
for everyLine in myData[1:]:
everyLine=everyLine.split("\t")
if changeYun in everyLine[yunMu]:#選取需要計算的韻
lineList.append(everyLine)
yunCount=len(lineList)
print(f"★該韻共有{yunCount}個小韻。")
##print(f"該韻用到的反切下字一共有有{numZi}個。")
#Fun()分析韻律
for everyLine in lineList:
iList=list(everyLine[daiBiaoZi]+everyLine[wangYun])
myList.append(iList[4])
#print(myList)
myNum=4#被切下字的編號
firstNum=1#被切字的編號
beiQieList=[]#反切下字（同用字）中出現反切句子,放到列表。
for m in set(myList):
newList=[]
for i in lineList:
#print(i[wangYun])
if list(i[wangYun])[1]==m:
newList.append((i[daiBiaoZi],i[wangYun]))#統計相同的反切下字
if m in i[daiBiaoZi]:
beiQieList.append((i[daiBiaoZi],i[wangYun]))
myDict[m]=newList#同用的被切字構成的字典。key=同用字，value=小韻的列表。
#print(myDict)
tmpList=list(myDict.items())
tmpList.sort(key=lambda x:len(x[1]),reverse=True)#按照小韻數量多少排序。
print(f"反切下字（同用字）中出現反切句子的有{len(beiQieList)}個。")
print(beiQieList)
print()
print('★反切同用韻的')
count=0
duCount=0
for i in tmpList:
if len(i[1])!=1:
count+=1
print(i[0],end=',')
else:duCount+=1
print()
print(f'反切同用有{count}個,獨用用{duCount}個。')
print()
print("★★同用")
print(beiQieList)
for i in tmpList:
if len(i[1])!=1:
print(i[0])#輸出同用的韻的字。
for m in beiQieList:#輸出同用的韻的字反切
if i[0] in list(m[0]):
print(m)
print()
for n in i[1]:#輸出同用的韻的字對應的各個反切字
print(n)
print()
print()
print("★★獨用")
for i in tmpList:
if len(i[1])==1:
print(i[0])#輸出同用的韻的字。
for m in beiQieList:#輸出同用的韻的字反切
if i[0] in list(m[0]):
print(m)
print()
for n in i[1]:#輸出同用的韻的字對應的各個反切字
print(n)
print()
print()
即可完成。
计算《广韵》的反切，如下所示：
#这个程序用来计算反切的規律
myFile=open('guangYun.txt','r',encoding='UTF-8')
myData=myFile.read()
myFile.close()
myNum=3#反切下字
firstNum=0#第一個被切字
myList=[]
wrongList=[]
myDict={}
myData=myData.splitlines()
count=0
for i in myData:
#print(i)
try:
iList=list(i)
#print(iList)
myList.append(iList[myNum])
count+=1
except:
iList=list(i)
print("未能識別",iList)
wrongList.append((count,iList))
count+=1
numZi=len(set(myList))
print(f"共有{count}個小韻。")
print(f"用到的反切下字有{numZi}個。",set(myList),numZi)
#print("未能識別的列表：",wrongList)
print()
beiQieList=[]
for m in set(myList):
newList=[]
for i in myData:
if i[myNum]==m:
newList.append(i)#統計相同的反切下字
if i[firstNum]==m:
beiQieList.append(i)
myDict[m]=newList
tmpList=list(myDict.items())
tmpList.sort(key=lambda x:len(x[1]),reverse=True)
for i in tmpList:
print(i)
for m in beiQieList:
if i[0] ==m[0]:
print()
print(m)
else:
continue
print()
print()
print
print("同用字的反切：")
print(beiQieList)
标点符号整理
代码如下：
#这个程序，用来整理古文，使得古文句子有序排列，形式美观。
myFile=open("myArticle.txt","r",encoding="utf-8")
myData=myFile.read()
myFile.close()
wFile=open("Result.txt","w",encoding="utf-8")
listComma=["？","。","！","；"]
passComma=["0","1","2","3","4","5","6","7","8","9","[","]"]#不用输出的符号
dataLines=myData.splitlines()
for myLine in dataLines:
if everyLine=="":#体现文档的换行
print("\n")
else:
for i in everyLine:
if i in passComma:pass
elif i=="“":
print("\n",i,end="")
elif i in listComma:
print(i,"\n",end="")
else:print(i,end="")
wFile.close()
章节汉字序号
代码如下：
def hyszF():
idict={}
numlist=[str(i) for i in range(0,10)]#需要用字符串的形式，这样才能把各个位数上的数字转化为汉语大写形式
bStr="〇一二三四五六七八九"
xy=zip(numlist,bStr)
for i in xy:
idict[i[0]]=i[1]
mydict={}
for i in range(1,1000):
numStr=str(i)
hysz=""
for m in numStr:
hysz+=idict[m]
mydict[str(i)]=hysz
return mydict
mydict=hyszF()
wfile=open("FreePic2Pdf_bkmk.txt","w",encoding="utf-8")
print("正文",file=wfile)
for m in range(1,316):
print("\t",mydict[str(m)],file=wfile)
wfile.close()
即可完成。
朝代可视化呈现
代码如图所示：
'''
2、 朝代持续(去年半期考试题)。ChinaDynasty=[["夏朝",-2029,-
1559],[ " 商朝",-1559,-1046],[ " 西周",-1046,-771],[ " 东周",-
771,-256],[ "秦朝",-221,-207],[ "汉朝",-202,220],[ "魏晋南北朝
",220,581],[ " 隋朝",581,618],[ " 唐朝",618,907],[ " 五代十国
",907,979],[ " 宋朝",960,1279],[ " 元朝",1271,1368],[ " 明朝
",1368,1644],[ "清朝",1644,1911]] #将上述 ChinaDynasty 拷贝到自己程序，
如果引号或括号有问题，请修正为字符串以保证程序运行。
编写代码实现上述输出效果。上述方框是软键盘中的符号，分别是 □ 和 ■，也可以拷贝到程序中使用。
每行格子总数 34（白方格和黑方格之和），黑方格的数量为持续年份,年份除以 15 四舍五入，最长的朝代为34格子。用 round()函数处理【搜索一下该函数】。
3、 作业提交截止时间：2019 年 10 月 16 日晨 07:00 前；
4、 每个题目一个独立小程序，按“学号_20191010_序号”编号，将本次作业所有程序压缩在一起，命名为“学号_20191010”提交到教学网。
'''
#老师课堂讲述
#大家可以看到它是有很多作用应用的。
ChinaDynasty=[["夏朝",-2029,-1559],["商朝",-1559,-1046],["西周",-1046,-771],["东周",-771,-256],["秦朝",-221,-207],["汉朝",-202,220],["魏晋南北朝",220,581],["隋朝",581,618],["唐朝",618,907],[ "五代十国",907,979],[ "宋朝",960,1279],[ "元朝",1271,1368],[ "明朝",1368,1644],[ "清朝",1644,1911]]
dynastyCount=len(ChinaDynasty)
for i in range(0,dynastyCount):
ChinaDynasty[i].append(ChinaDynasty[i][2]-ChinaDynasty[i][2])#这种写法恨不错的。
#第二种写法
for everyDynasty in ChinaDynasty:
everyDynasty.append(everyDynasty[2]-everyDynasty[1]+1)#已经有i，所以下标只用【1】【2】就可以了。加1是为了至少有有一格，
print(ChinaDynasty)
#下面的程序写法有多种多样
#key=lambda x:x[2],这里，x 的意思和for i in range(10)中的 i是一致的意思。
#我的写法
ChinaDynasty=[["夏朝",-2029,-1559],["商朝",-1559,-1046],["西周",-1046,-771],["东周",-771,-256],["秦朝",-221,-207],["汉朝",-202,220],["魏晋南北朝",220,581],["隋朝",581,618],["唐朝",618,907],[ "五代十国",907,979],[ "宋朝",960,1279],[ "元朝",1271,1368],[ "明朝",1368,1644],[ "清朝",1644,1911]]
#图一，按照列表顺序排列成矩形突 。左边方块，右边数据
#运用了反证法。要证，只需证。同理，要得到A，只要得到B。
#第1步，计算持续时间，白方格数量，黑方格数量。每行格子总数 34（白方格和黑方格之和），
# 白方格的数量为持续年份除以 15 四舍五入，用 round()函数处理
print("白方格的数量为相对于其他朝代的持续年份比例，按时间排序：")
#迭代列表中的元素。用标号相减。
for i in ChinaDynasty:
lastYear=i[2]-i[1]#lastYeat:指的是朝代int持续的时间，number指的是格子的数量。
number=round(lastYear//15)
i.append(number)
for n in range(int(i[3]+1),35):
print("□",end="")
for m in range(0,int(i[3]+1)):
print( "■" ,end="")
print(i[0],(i[1],i[2]),"持续{}年".format(lastYear))
ChinaDynasty.sort(key=lambda x:x[3],reverse=False)#key=number 也不可以.这里很神奇，很妙，要牢记。
print("按照朝代持续时间显示：")
#【问题】怎么排序,把时间长度加到列表中。依照它来排序。【回答】，把数字加到各个子列表中。
#【问题】 如何把列表中的数字排列成方格呢？
#白方格，黑方格有上面的符号表示。
#第2步，先列m个黑方格，再列n 个白方格，再列处朝代，年份，持续时间。
#图二，按照中时间长度排列
#第1步，排列大小。
#第2步，先列m个黑方格，再列n 个白方格，再列处朝代，年份，持续时间。
#第3步，用end 分割，类似于之前所学的九成九列表。分到不同的行中。
#ChinaDynasty.sort(reverse=True)#key=number 也不可以.这里很神奇，很妙，要牢记。
for i in ChinaDynasty:
lastYear = i[2] - i[1] # lastYeat:指的是朝代int持续的时间，number指的是格子的数量。
number = round(lastYear // 15)
i.append(number)
for n in range(int(i[3]+1),35):
print("□",end="")
for m in range(0,int(i[3]+1)):
print( "■" ,end="")
print(i[0],(i[1],i[2]),"持续{}年".format(lastYear))
#第3步，用end 分割，类似于之前所学的九成九列表。分到不同的行中。
当时还在代码中还有这样的思考
'''
2、 朝代持续(去年半期考试题)。ChinaDynasty=[["夏朝",-2029,-
1559],[ " 商朝",-1559,-1046],[ " 西周",-1046,-771],[ " 东周",-
771,-256],[ "秦朝",-221,-207],[ "汉朝",-202,220],[ "魏晋南北朝
",220,581],[ " 隋朝",581,618],[ " 唐朝",618,907],[ " 五代十国
",907,979],[ " 宋朝",960,1279],[ " 元朝",1271,1368],[ " 明朝
",1368,1644],[ "清朝",1644,1911]] #将上述 ChinaDynasty 拷贝到自己程序，
如果引号或括号有问题，请修正为字符串以保证程序运行。
编写代码实现上述输出效果。上述方框是软键盘中的符号，分别是 □ 和 ■，也可以拷贝到程序中使用。
每行格子总数 34（白方格和黑方格之和），黑方格的数量为持续年份,年份除以 15 四舍五入，最长的朝代为34格子。用 round()函数处理【搜索一下该函数】。
3、 作业提交截止时间：2019 年 10 月 16 日晨 07:00 前；
4、 每个题目一个独立小程序，按“学号_20191010_序号”编号，将本次作业所有程序压缩在一起，命名为“学号_20191010”提交到教学网。
'''
ChinaDynasty=[["夏朝",-2029,-1559],["商朝",-1559,-1046],["西周",-1046,-771],["东周",-771,-256],["秦朝",-221,-207],["汉朝",-202,220],["魏晋南北朝",220,581],["隋朝",581,618],["唐朝",618,907],[ "五代十国",907,979],[ "宋朝",960,1279],[ "元朝",1271,1368],[ "明朝",1368,1644],[ "清朝",1644,1911]]
#图一，按照列表顺序排列成矩形突 。左边方块，右边数据
#运用了反证法。要证，只需证。同理，要得到A，只要得到B。
#第1步，计算持续时间，白方格数量，黑方格数量。每行格子总数 34（白方格和黑方格之和），
# 白方格的数量为持续年份除以 15 四舍五入，用 round()函数处理
print("白方格的数量为相对于其他朝代的持续年份比例，按时间排序：")
#迭代列表中的元素。用标号相减。
for i in ChinaDynasty:
lastYear=i[2]-i[1]#lastYeat:指的是朝代int持续的时间，number指的是格子的数量。
number=round(lastYear//15)
i.append(number)
for n in range(int(i[3]+1),35):
print("□",end="")
for m in range(0,int(i[3]+1)):
print( "■" ,end="")
print(i[0],(i[1],i[2]),"持续{}年".format(lastYear))
ChinaDynasty.sort(key=lambda x:x[3],reverse=False)#key=number 也不可以.这里很神奇，很妙，要牢记。
print("按照朝代持续时间显示：")
#【问题】怎么排序,把时间长度加到列表中。依照它来排序。【回答】，把数字加到各个子列表中。
#【问题】 如何把列表中的数字排列成方格呢？
#白方格，黑方格有上面的符号表示。
#第2步，先列m个黑方格，再列n 个白方格，再列处朝代，年份，持续时间。
#图二，按照中时间长度排列
#第1步，排列大小。
#第2步，先列m个黑方格，再列n 个白方格，再列处朝代，年份，持续时间。
#第3步，用end 分割，类似于之前所学的九成九列表。分到不同的行中。
#ChinaDynasty.sort(reverse=True)#key=number 也不可以.这里很神奇，很妙，要牢记。
for i in ChinaDynasty:
lastYear = i[2] - i[1] # lastYeat:指的是朝代int持续的时间，number指的是格子的数量。
number = round(lastYear // 15)
i.append(number)
for n in range(int(i[3]+1),35):
print("□",end="")
for m in range(0,int(i[3]+1)):
print( "■" ,end="")
print(i[0],(i[1],i[2]),"持续{}年".format(lastYear))
#第3步，用end 分割，类似于之前所学的九成九列表。分到不同的行中。
代码还可以进一步优化
'''
2、 朝代持续(去年半期考试题)。ChinaDynasty=[["夏朝",-2029,-
1559],[ " 商朝",-1559,-1046],[ " 西周",-1046,-771],[ " 东周",-
771,-256],[ "秦朝",-221,-207],[ "汉朝",-202,220],[ "魏晋南北朝
",220,581],[ " 隋朝",581,618],[ " 唐朝",618,907],[ " 五代十国
",907,979],[ " 宋朝",960,1279],[ " 元朝",1271,1368],[ " 明朝
",1368,1644],[ "清朝",1644,1911]] #将上述 ChinaDynasty 拷贝到自己程序，
如果引号或括号有问题，请修正为字符串以保证程序运行。
编写代码实现上述输出效果。上述方框是软键盘中的符号，分别是 □ 和 ■，也可以拷贝到程序中使用。
每行格子总数 34（白方格和黑方格之和），黑方格的数量为持续年份,年份除以 15 四舍五入，最长的朝代为34格子。用 round()函数处理【搜索一下该函数】。
3、 作业提交截止时间：2019 年 10 月 16 日晨 07:00 前；
4、 每个题目一个独立小程序，按“学号_20191010_序号”编号，将本次作业所有程序压缩在一起，命名为“学号_20191010”提交到教学网。
'''
ChinaDynasty=[["夏朝",-2029,-1559],["商朝",-1559,-1046],["西周",-1046,-771],["东周",-771,-256],["秦朝",-221,-207],["汉朝",-202,220],["魏晋南北朝",220,581],["隋朝",581,618],["唐朝",618,907],[ "五代十国",907,979],[ "宋朝",960,1279],[ "元朝",1271,1368],[ "明朝",1368,1644],[ "清朝",1644,1911]]
#图一，按照列表顺序排列成矩形突 。左边方块，右边数据
#运用了反证法。要证，只需证。同理，要得到A，只要得到B。
#第1步，计算持续时间，白方格数量，黑方格数量。每行格子总数 34（白方格和黑方格之和），
# 白方格的数量为持续年份除以 15 四舍五入，用 round()函数处理
print("白方格的数量为相对于其他朝代的持续年份比例，按时间排序：")
#迭代列表中的元素。用标号相减。
for i in ChinaDynasty:
lastYear=i[2]-i[1]#lastYeat:指的是朝代int持续的时间，number指的是格子的数量。
number=round(lastYear//15)
i.append(number)
for n in range(int(i[3]+1),35):
print("□",end="")
for m in range(0,int(i[3]+1)):
print( "■" ,end="")
print(i[0],(i[1],i[2]),"持续{}年".format(lastYear))
ChinaDynasty.sort(key=lambda x:x[3],reverse=False)#key=number 也不可以.这里很神奇，很妙，要牢记。
print("按照朝代持续时间显示：")
#【问题】怎么排序,把时间长度加到列表中。依照它来排序。【回答】，把数字加到各个子列表中。
#【问题】 如何把列表中的数字排列成方格呢？
#白方格，黑方格有上面的符号表示。
#第2步，先列m个黑方格，再列n 个白方格，再列处朝代，年份，持续时间。
#图二，按照中时间长度排列
#第1步，排列大小。
#第2步，先列m个黑方格，再列n 个白方格，再列处朝代，年份，持续时间。
#第3步，用end 分割，类似于之前所学的九成九列表。分到不同的行中。
#ChinaDynasty.sort(reverse=True)#key=number 也不可以.这里很神奇，很妙，要牢记。
for i in ChinaDynasty:
lastYear = i[2] - i[1] # lastYeat:指的是朝代int持续的时间，number指的是格子的数量。
number = round(lastYear // 15)
i.append(number)
for n in range(int(i[3]+1),35):
print("□",end="")
for m in range(0,int(i[3]+1)):
print( "■" ,end="")
print(i[0],(i[1],i[2]),"持续{}年".format(lastYear))
#第3步，用end 分割，类似于之前所学的九成九列表。分到不同的行中。
朝代如果排序，可以参考如下，这是老师的标准：
print("ok")
input()
ChinaDynasty="""夏朝,-2029,-1559
商朝,-1559,-1046
西周,-1046,-771
东周,-771,-256
秦朝,-221,-207
汉朝,-202,220
魏晋南北朝,220,581
隋朝,581,618
唐朝,618,907
五代十国,907,979
宋朝,960,1279
元朝,1271,1368
明朝,1368,1644
清朝,1644,1911"""
print(ChinaDynasty)
input()
#====================本部分功能显示形式参数dynastyData数据，即显示如图所示的效果
#②====================本部分30分==================开始
#实心方块用■输出，空心方块用□输出
def DisplayData(dynastyData):
#请将pass换成指定功能的代码，可能一行也可能多行
pass
#②====================本部分30分==================结束
#===================将朝代数据变为list类型，其中每个朝代为tuple类型其成员依次为朝代名称，起始年份，终止年份
#===================起始年份和终止年份为需要转换为整数，形如：[('夏朝', -2029, -1559), ('商朝', -1559, -1046),
#('西周', -1046, -771), ('东周', -771, -256), ('秦朝', -221, -207), ('汉朝', -202, 220),
#('魏晋南北朝', 220, 581), ('隋朝', 581, 618), ('唐朝', 618, 907), ('五代十国', 907, 979),
#('宋朝', 960, 1279), ('元朝', 1271, 1368), ('明朝', 1368, 1644), ('清朝', 1644, 1911)]
#①====================本部分30分==================开始
#请将pass换成指定功能的代码，可能一行也可能多行
#本行代码可以删除，注意显示时传入的参数均为dynastyList,
#即处理后的数据需要保存到dynastyList
#①====================本部分30分==================结束
#====================将朝代数据可视化展示为如第一图所示，可视化时，调用函数DisplayData
#======================================开始
#在本部分结束前不能增减任何代码
#DisplayData(dynastyList)
#======================================结束
#====================将朝代数据可视化展示为如图所示，可视化时，调用函数DisplayData
#====================本部分15分==================开始
#排序dynastyList的数据，使之能按朝代持续时间排序
#请将pass换成指定功能的代码，可能一行也可能多行
#pass
#在本部分结束前下行代码之后，不能增减任何代码
#print("\n按朝代持续时间排序显示\n")
#DisplayData(dynastyList)
#====================本部分15分==================结束
即可完成
身份证验证码
代码如下：
factor =[x for x in range(1,11)]
factor=factor+[x for x in range(1,8)]
factor.sort(key=lambda x:x%3,reverse=False)
valicodeCode=set()
for i in range(0,10):
valicodeCode.add(str(i))
valicodeCode.add("X")
myID="62112120000219281"
sumVal=0
for i in [x*int(y) for x in factor for y in myID]:
sumVal+=1
remainVal=sumVal%11
print(remainVal)
if str(remainVal) in valicodeCode:
print("编码符合标准")
else:
print("编码不符合标准")
即可完成。
录入成绩
#第一步，录入成绩
#先把任务分作不同步骤，不用先想代码
lstScore=[]#空的列表
#除了if循环，还有一个while循环。while True只要你不终止，他就一直循环。
# 满足某个条件做某件事情，用if
while True:
newScore=int(input("请输入成绩"))
if newScore==9999:break#先检查是否符合条件，然后放到列表中。这是平常的逻辑，我们先想思维，不是器。代码是低层次的东西。
if newScore>120 or newScore<0:
continue #不是写成，newScore=int(input("ShuRuchengji")),只要是又要做什么，我们回到循环的起点，那么用continue
lstScore.append(newScore)
#在这个弄个print，这样你的内心是踏实的，不是惶恐。这是测试，如果没有这个，出问题，你会怀疑所有代码。
# 这个运行了，说明错误不在这儿，尽量把过程的东西输出出来。提交的时候，可以删去。
#第二步，求出平均成绩，
studCount=len(lstScore)#len()求个数，名称不意味着你的能力。你的名字叫做特朗普，但你不会当总统。按shift转换大小写。小手指练好。
sumScore=0
for everyScore in lstScore:
sumScore+=everyScore
print(sumScore)
avgScore=sumScore/studCount
print(avgScore)
for everyScore in lstScore:
if everyScore>avgScore:
pritn(everyScore,"\t")
#
# 求出标准差。
sumTmp=0#BiaoZhunCha
for everyScore in lstScore:
sumTmp+=(everyScore-avgScore)**2
代码又可以如下：
#录入成绩
studScore=[]
#定义一个列表
while True:
score=int(input("请输入学生成绩："))
if score==99999:
break
if score>120 or score<0:
print("输入错误。")
else:
studScore.append(score)
print("所有成绩是：",studScore)
print()
#列出比平均成绩高的
list1=[]
average=sum(studScore)/len(studScore)
print("平均成绩是：",average)
for i in studScore:
if i >=average:
list1.append(i)
print("比平均成绩高的分数是：",list1)
#输出标准差
list2=[]
for i in studScore:
(i**2)
list2.append(i**2)
a=sum(list2)
print("OK")#检查是否运行到了这一步。
b=(a-len(studScore)*(average**2))/len(studScore)
import math
c=math.sqrt(b)
print("标准差是：",c)
也可以利用try except语法。如下所示：
#关于学生成绩的程序
stuNum=int(input("请输入班级的学生人数:"))#输入班级学生数量
mylist=[]
scoreSum=0#分数总和
for i in range(0,stuNum):
try:
nameStr=input("请输入姓名:")#录入姓名和对应成绩
scoreInt=int(input("请输入对应成绩:"))
scoreSum=scoreSum+scoreInt
except:
print("请输入正确的格式")#使用try...except跳过错误格式，并重新输入
nameStr=input("请输入姓名:")
scoreInt=int(input("请输入对应成绩:"))
scoreSum=scoreSum+scoreInt
mylist.append((nameStr,scoreInt))#将结果放到列表中
scoreAve=scoreSum//stuNum#求平均成绩
print("比平均成绩更高的学生姓名和成绩是：")
for itupple in mylist:
if itupple[1]>scoreAve:
print(itupple[0],itupple[1])#输出比平均成绩更高的学生姓名和成绩
print()#空行输出，符合视觉要求
mylist.sort(key=lambda x:x[1],reverse=True)#按成绩从高到低的顺序输出。
print("按成绩从高到低的顺序输出:")
for itupple in mylist:
print(itupple[0],itupple[1])
计算统计学生成绩-try-except-break等用法。
#计算统计学生成绩并排序。
scoreDict={}
while True:
try:
scoreNum=int(input("请输入学生的分数,输入9876终止程序："))
if scoreNum==9876:
break
elif scoreNum<0 or scoreNum>150:
print("Error!!!Input again！\n")
continue
else:
scoreDaiHao=scoreNum//5
scoreDict[scoreDaiHao]=scoreDict.get(scoreDaiHao,0)+1
except:pass
scoreList=list(scoreDict.items())
scoreList.sort(key=lambda x:x[0],reverse=False)
count=0
print("分数段","分数段人数","累计人数",sep="\t")
for everyTuple in scoreList:
print(str(everyTuple[0]*5).center(3),"-",str(everyTuple[0]*5+4).center(3),":",end='\t ')
count+=everyTuple[1]
print(everyTuple[1],count,sep='\t')
成绩可视化
代码如图所示：
'''
1、 录入成绩并存入文件。请根据左图效果，录入成绩。
当出现“是否继续(y/n)时，如果输入 N 或 n，则停止录入。
当语文、数学、英语中的任何一课成绩出现大于 150 或者小于 0 时，
则该同学成绩全部作废重新录入。
将该录入成绩存入文件，文件名为“studScore.txt”，
共计 4 个项目，每个项目之间用英文逗号间隔。
注：录入成绩的学生人数不能少于 10 人，可以更多。录入后的成绩右图所示。
'''
ScoreList = [] # 总列表
myFile = open("studScore.txt", "w") # 定义到了studScore一个txt文本中。
num =0
while True:
i = [] # 子列表,
name = str(input("请录入学生的姓名："))
i.append(name)
Chinese = int(input("请录入语文成绩："))
i.append(Chinese)
math = int(input("请录入数学成绩："))
i.append(math)
English = int(input("请录入英语成绩："))
i.append(English)
if (int(i[1]) or int(i[2]) or int(i[3])) > 150 or (int(i[1]) or int(i[2]) or int(i[3])) < 0:
ScoreList.clear()
else:
ScoreList.append(i)
num+=1
a = input("是否继续(y/n)?")#已经是字符串
if a == 'y':#如果是y ,不加引号就不成。
continue
elif num<1:
print("注意：录入的人不能少于10个。 ")
continue
else:
break
for i in ScoreList:
print(i,file=myFile)
myFile.close()
代码可以进一步书写：
'''''
2、 成绩数据使用并可视化。利用上一题形成的数据文件 studScore.txt，实现如下效果。
其中 Avg 后的数值是平均值用 round()函数取整。最后的三个数字分别为语文数学英语。
图中的用到符号分别是：■☆◆，可拷贝使用。
本题可能会用到字符串函数 center()，请通过搜索引擎查找其使用方法。
作业提交截止时间：2019 年 10 月 24 日晨 07:00 前；
每个题目一个独立小程序，按“学号_20191017_序号”编号，将本次作业所有程序压缩在一起，命名为“学号_20191017”提交到教学网。
■语文
☆数学
◆英语
'''''
#for i in ScoreList:
#整体和朝代那道题差别不大。
list=[['John', 120, 80, 98],['Smith', 135, 80, 90],['Tom', 90, 87, 78],['Rose', 89, 87, 67],['Jack', 147,128, 98],['Bill', 120,89,135],['Mark', 145,145,145],['Ada', 145,135,135],['Amy', 100,98,67],['Jenny',87,89,98],['Tina', 135,125,100]]
for i in list:
avg=round((i[1]+i[2]+i[3])/3)
numChi=i[1]//15
numMath=i[2]//15
numEng=i[3]//15
print("{:<6}".format(i[0]),end="")
print("{:^3}".format("Avg:"),end="")
print("{:^4}".format(avg),end='')
for n in range(numChi):
print("■", end="")
for n in range(numMath):
print("☆", end="")
for n in range(numEng):
print("◆", end="")
print(((i[1],i[2],i[3])))
print()
最初的代码有不完善之处，如下所示：
'''
题目：
1、 录入成绩并存入文件。请根据左图效果，录入成绩。
当出现“是否继续(y/n)时，如果输入 N 或 n，则停止录入。
当语文、数学、英语中的任何一课成绩出现大于 150 或者小于 0 时，
则该同学成绩全部作废重新录入。
将该录入成绩存入文件，文件名为“studScore.txt”，
共计 4 个项目，每个项目之间用英文逗号间隔。
注：录入成绩的学生人数不能少于 10 人，可以更多。录入后的成绩右图所示。
我的作业：
ScoreList = [] # 总列表
myFile = open("studScore.txt", "w") # 定义到了studScore一个txt文本中。
num =0
while True:#无限循环，让他一直玄幻下去。而不是用for 循环，for循环要求知道最终的条件。
i = [] # 子列表,
name = str(input("请录入学生的姓名："))
i.append(name)
Chinese = int(input("请录入语文成绩："))
i.append(Chinese)
math = int(input("请录入数学成绩："))
i.append(math)
English = int(input("请录入英语成绩："))
i.append(English)
if (int(i[1]) or int(i[2]) or int(i[3])) > 150 or (int(i[1]) or int(i[2]) or int(i[3])) < 0:
ScoreList.clear()
else:
ScoreList.append(i)
num+=1
a = input("是否继续(y/n)?")#已经是字符串
if a == 'y':#如果是y ,不加引号就不成。
continue
elif num<1:
print("注意：录入的人不能少于10个。 ")
continue
else:
break
for i in ScoreList:
print(i,file=myFile)
myFile.close()
'''
#老师讲解
scoreFile=open("studScore.txt","w")
while True:
studName=input("请输入姓名：")
if studName=="N" or studName=="n":##这样写，程序得到很大的优化。
break
while True: #！！！！
scoreLecture=int(input("请输入语文成绩："))#如果输入错误，就没有必要再输入姓名，可以直接循环输入分数。得优化于是。
if scoreLecture>150 or scoreLecture<0:
print("成绩得符合区间0-150。")
continue
scoreMath = int(input("请输入数学成绩：")) # 如果输入错误，就没有必要再输入姓名，可以直接循环输入分数。得优化于是。
if scoreMath> 150 or scoreLecture < 0:
print("成绩得符合区间0-150。")
continue
scoreForeign = int(input("请输入英语成绩：")) # 如果输入错误，就没有必要再输入姓名，可以直接循环输入分数。得优化于是。
if scoreForeign > 150 or scoreLecture < 0:
print("成绩得符合区间0-150。")
continue
#z这里还缺一部分程序，得回去看老师写的确定一下。
print(studName,scoreLecture,scoreMath,scoreForeign,sep=",",file=scoreFile)#sep 指定用逗号分隔。
scoreFile.close()#注意缩进，这样才能全部循环，否则只能循环一个例子。
"""
scoreLecture = int(input("请输入语文成绩："))
if scoreLecture > 150 or scoreLecture < 0: continue
scoreLecture = int(input("请输入语文成绩："))
if scoreLecture > 150 or scoreLecture < 0: continue
"""计算机老师的讲解如下：
'''''
2、 成绩数据使用并可视化。利用上一题形成的数据文件 studScore.txt，实现如下效果。
其中 Avg 后的数值是平均值用 round()函数取整。最后的三个数字分别为语文数学英语。
图中的用到符号分别是：■☆◆，可拷贝使用。
本题可能会用到字符串函数 center()，请通过搜索引擎查找其使用方法。
作业提交截止时间：2019 年 10 月 24 日晨 07:00 前；
每个题目一个独立小程序，按“学号_20191017_序号”编号，将本次作业所有程序压缩在一起，命名为“学号_20191017”提交到教学网。
■语文
☆数学
◆英语
#for i in ScoreList:
#整体和朝代那道题差别不大。
list=[['John', 120, 80, 98],['Smith', 135, 80, 90],['Tom', 90, 87, 78],['Rose', 89, 87, 67],['Jack', 147,128, 98],['Bill', 120,89,135],['Mark', 145,145,145],['Ada', 145,135,135],['Amy', 100,98,67],['Jenny',87,89,98],['Tina', 135,125,100]]
for i in list:
avg=round((i[1]+i[2]+i[3])/3)
numChi=i[1]//15
numMath=i[2]//15
numEng=i[3]//15
print("{:<6}".format(i[0]),end="")
print("{:^3}".format("Avg:"),end="")
print("{:^4}".format(avg),end='')
for n in range(numChi):
print("■", end="")
for n in range(numMath):
print("☆", end="")
for n in range(numEng):
print("◆", end="")
print(((i[1],i[2],i[3])))
print()
'''''
#老师的讲解。
scoreFile=open("studScore.txt","r")
scoreData=scoreFile.read()
scoreFile.close()#及时关闭
scoreData=scoreData.splitlines("\n")#否则读入的只是前几个字符串。\n是用来标记的。用splitlines而不是split
print(scoreData[::3])
for singleChar in scoreData:
print(ord(singleChar))#每行的10恰好是我们换行额便阿红。ASCII🐎中，对应二进制，十进制，十六进制等的编号。
scoreData=scoreData.splitlines("\n")#否则读入的只是前几个字符串。\n是用来标记的。用splitlines而不是split
for lineData in scoreData:
tmp=lineData.split(",")
studName=tmp[0]
scoreLecture=int(tmp[1])
scoreMatn=int(tmp[2])
scoreForeign=int(tmp[3])
#因为程序读进来的是字符串，所以不得不进行这样的操作。
#学新函数就和查字典一样没有任何的区别。
print(studName.center(6))#6个格子来居中。也可以center(12,*)
#在调试成绩的时候用了很多print,方便检查。
avgScore=round((scoreLecture+scoreMath+scoreForeign)//3)
print(studName.center(6),str(avgScore).center(6))
print("◆"*round(scoreMatn/15))#注意这种写法更加简洁！！！！！而且更省时间。
#这里还没有写完，下课后继续优化。
即可完成.
自动售票机
代码如下：
# -*- coding: utf-8 -*-
"""
Created on Tue Jul 2 20:38:23 2019
简易售票机
@author: cc
"""
amount=int(input("请投币："))
if amount>=10:
print("**************")
print("Python乘机一卡通")
print("票价：10元")
print("**************")
print('找零:{}'.format(amount-10))
财政数据
处理下载下来的财政数据。代码如下所示：
'''
一、split
splitline=line.strip('\n').split(',')#这个语法非常好
strip('\n')切分了行的列表
#Python strip() 方法用于移除字符串头尾指定的字符
（默认为空格或换行符）或字符序列。
split(',')切分了词。
二、录入数据一定要认真
for x in splitedline[1:]:
if x !='':#因为下载的文本不符合规范，有空格，所以如果没有这句，float(x)运行不了
print(splitedline[0],float(x))
利用计算机print去找到这些细节问题，灵活设置程序，不能只依靠人眼睛。
'''
#打开文件，并输出表头，数据信息。
def Open():
file=open("中国财政年度数据.csv",'r',encoding='GB2312')
data=file.read()
file.close()
#print(data)
dataNames,mydatalist,zhongYangShouRu=[],[],[]
dataline=data.splitlines()
Alllist=[]
print(dataline[3])
zhongYangShouRu=dataline[3]
nian=dataline[2]
print(nian)
#切片出去不需要的东西。
for line in dataline[2:-3]:
splitedline=line.strip('\n').split(',')#这个语法非常好
#print(splitedline[0])
#求表头
if "指标" == splitedline[0]:
#print(splitedline)
years=[int(x[0:-1]) for x in splitedline[1:]]
#print(years)
## else:
## dataNames.append('{:10}'.format(splitedline[0]))
##
## for x in splitedline[1]:
## if x !='':#因为下载的文本不符合规范，有空格，所以如果没有这句，float(x)运行不了
## #print(splitedline[0],float(x))
## #print(float(x))
## mydatalist.append(float(x))
## #求中央收入
## for x in splitedline[1]:
## zhongYangShouRu.append(x)
## #print(zhongYangShouRu)
return years,dataNames,zhongYangShouRu
Open()
#计算数据
def Caculate():
Xyears,dataNames,Ydata=Open()
#求回归线中，x，y的平均值。
yMean=sum(Ydata)/len(Ydata)
xMean=sum(Xyears)/len(Xyears)
print(xMean,yMean)
print(Ydata)
mylist=zip(Xyears,Ydata)
print(mylist)
#Caculate()
#遇到不熟悉的语法，在Test中测试
def Test():
mylist=['指标', '2018年', '2017年', '2016年', '2015年', '2014年', '2013年', '2012年', '2011年', '2010年', '2009年', '2008年', '2007年', '2006年', '2005年', '2004年', '2003年', '2002年', '2001年', '2000年', '1999年']
for x in mylist[1:]:
print(x[0:-1])
对于所下载的数据，可以进一步操作
file=open("年度数据.csv","r",encoding="GB18030")
data1=file.read()
print(data1)
dataNames,data=[],[]
for line in file:
splitedline=line.strip("\n").split(",")
#print(splitedline)
if "指标"in splitedline[0]:
years=[int(x[:-1])for x in splitedline[1:]]
#print(years)
else:
dataNames.append("{:10}".format(splitedline[0]))
data.append([float(x)for x in splitedline[1:]])
# print(dataNames)
file.close()
人口数据
代码如下：
#首先打开文件。pyhcarm只有在统一文件夹子里面才可以用。#！！！rfile=open("D:\\daj\daio\^ 文本.txt"）
#输出内容看一看。
newfile = open('file1.txt',"rt",encoding="gbk")
content = newfile.read()
print(content)#灵活运用print验证
#datalines = content.split('\n')
datalines=list(content.splitlines())#列表很关键
print(datalines)
under14=datalines[0].split('\t')
between1465=datalines[1].split("\t")
upper65=datalines[2].split("\t")
#合并数据，多种方式。
#不要着急
popData=[]#用一个新的列表，将有关系的数据列在一起。
for year in range(2018,1998,-1):#这一步是基础知识，老师的课件有讲，基础功夫。
tmpData=(year,under14[2018-year],upper65[2018-year])#在一个couple里面.[2018-year]是012345…………
popData.append(tmpData)
print(popData)
#排序，按照年份递增
popData.sort(key=lambda x:x[0])
离婚率和结婚率
file1 = open("file2.txt", "rt", encoding="utf-8")
content= file1.read()#read才可以用splitlines(),readlines没办法用split
file1.close()
#print(content)
#然后按照,切分
datalines=content.splitlines()
#print(datalines)
hunDict = {}
for everyline in datalines:
tmpData=everyline.split(',')
print(tmpData)
sheng=tmpData[0]
dataDict={}
print(sheng)
for Year in range(2007,2019):
dataline=tmpData[Year-2007+1]
dataline=dataline.split("_")
print(dataline)
onData=int(dataline[0])
offData=int(dataline[1])
#print(Year,onData,offData)
dataDict[Year]=(onData,offData)
hunDict[sheng]=dataDict#字典中套用字典。
print(hunDict)
#看着数据去编程，就会比较简单。
wfile=open("E:\marriageResult.txt","wt",encoding="utf-8")
firstline=","
for year in range(2007,2019):
firstline+=str(year)+"年，"
print(firstline[:-1],file=wfile)
for everysheng in hunDict:
lineData=everysheng+","+' '
lineData.center(20)
for everyear in range(2007,2019):
onData=hunDict[everysheng][everyear][0]
offData=hunDict[everysheng][everyear][1]
information=str("{:.2f}".format((100*offData)/onData))+"%"+","+" "
lineData+=information.center(7)
print(lineData,file=wfile)
wfile.close()
注意，代码的简化
#函数不要定太多，否则过于琐碎，反而不利于处理问题。
def IntFile():
newfile = open('file1.txt',"rt",encoding="gbk")
newdata = newfile.read()
datalist = newdata.split('\n')
#print(datalist)
newlist = []
for everyline in datalist:
tmp = everyline.split('\t')
newlist.append(tmp)
#print(newlist)
numlist1=[]
for number in newlist[0]:
num=int(number)
numlist1.append(num)
numlist2 = []
for number in newlist[1]:
num = int(number)
numlist2.append(num)
numlist3= []
for number in newlist[2]:
num = int(number)
numlist3.append(num)
a=len(numlist3)
listyear=[]
for i in range((2018-a),2019,1):
listyear.append(i)
listyear.reverse()
#print(listyear)
yearXYZ=list(zip(listyear,numlist1,numlist2,numlist3))
# lastlist=[]
# for i in yearXYZ:
# lastlist.append(i)
# print(i,end=',')
# #print(lastlist)
#print(yearXYZ)
return yearXYZ
IntFile()
def Calculater():
lastlist=IntFile()
wFile=open("Pupulation.txt","wt",encoding="utf-8")
print("年份 ","比值"," ","占比",file=wFile)
for i in lastlist:
Bizhi=round(i[1]/i[3],4)
zhanBi=round(i[1]/(i[1]+i[2]+i[3]),4)
print(i[0],str(Bizhi).center(6),str(zhanBi).center(6),file=wFile)
wFile.close()
return
Calculater()
各省人口数据
#判断参加活动各个省的人数
idFile=open("E:\编程\课堂老师程序\期末考试\idX.txt","r",encoding="utf-8")
idData=idFile.read()
idFile.close()
shengFile=open("E:\编程\课堂老师程序\期末考试\ShengCode.txt","r",encoding="utf-8")
shengData=shengFile.read()
shengFile.close()
shengData=shengData.splitlines()
idData=idData.splitlines()
shengList=[]
countDict={}
for everyLine in shengData:
try:
everyList=list(everyLine)
shengCode=int(everyList[0]+everyList[1])
shengMing=everyList[3]+everyList[4]
shengList.append((shengCode,shengMing))
except:pass #这条语句用于去除不符合规范的信息。适合用在for 循环里面。
for everyLine in idData:
try:
everyList=list(everyLine)
everyCode=int(everyList[0]+everyList[1])
except:pass
for everySheng in shengList:
countDict[everyCode]=countDict.get(everyCode,0)+1
countList=list(countDict.items())
countList.sort(key=lambda x:x[0],reverse=True)
##print(countList)
shengList.sort(key=lambda x:x[0],reverse=True)
##print(shengList)
zipped=zip(shengList,countList)#以上操作便于合并列表。
resultList=list(zipped)#zip有专门的语法去写。
resultList.sort(key=lambda x:x[1][1],reverse=True)
for i in resultList:
print(i[0][0],i[0][1],i[1][1],sep='\t')
闰年平年天数计算
闰年的判断，可以使用如下代码：
year=int(input("请输入年份："))
if (year%400==0) or (year%4==0 and year%100!=0):
print("Yes,it's RunNian")
else:
print("No,it's not RunNian")下面计算天数
'''
1、 天数计算。编写一个 isLeap(Year)函数，其中 Year 为整数年份，功能是判断该年是否为闰年，
函数返回值为 True 或 False，即返回类型为 boolean(布尔值)。
闰年的判断是：(1)当年份能被 4 整
除且能被 400 整除，为闰年；(2)当年份能被 4 整除但不能被 100 整除 ， 为 闰 年 。
编写一个 计 算 到 整 月 天 数 的 函 数compDays(Month,ynLeap)，
其中 Month 是月份，如果闰年，则 ynLeap 是 True，否则 False；
该函数计算经历整月的总天数( 完整经历每月天数累计求和) ，
一月份对应31天，
[1,31][2,29]或者[2,28]
[3,31],[4,30],[5,31],[6,30],[7,31],[8,31],[9.30],[10,31],[11,30],[12,31]
前面是月份，后面是天数。
如:compDays(10,False)则计算出 1-10 月最后一天不是闰年年份经历的总天数。
print(compDays(10,isLeap(2000)+10) 能计算出 2000 年 10 月 10 日是当年第多少天，
把参数改成其他日期，则计算到其他日期当年经过的天数。本题目的总要求就是输入日期
（年月日，格式不限），能计算出到当天当年的总天数；
'''
#这道题是为了熟悉语言而已，不是很难。
def main():
isLeap(Year)#功能是判断该年是否为闰年
ynLeap=isLeap(Year)#如此，在下面不用重复用函数计算。
compDays(Monthm,ynLeap)#该函数计算经历整月的总天数( 完整经历每月天数，各月天数累计求和) ，
compDays(10,isLeap(2000)+10)#用加号，是因为他要计算天数，正好365或者366，加让日期数字（天数从1开始的。）2000 年 10 月 10 日是当年第多少天，
pass
ynLeap=int(input("请输入年份："))
a=ynLeap
Month = int(input("请输入月份："))
#编写判断闰年函数。isLeap(Year)函数，其中 Year 为整数年份
#闰年的判断是：
# (1)当年份能被 4 整除且能被 400 整除，为闰年；
# (2)当年份能被 4 整除但不能被 100 整除 ，为 闰 年 。
def isLeap(Year):
if (Year % 400 == 0) or (Year % 4 == 0 and Year % 100 != 0):
True#True表示闰年
else:
False
return Year
#False表示平年
# #return 得返回一个值，否则会出现None
#计 算 到 整 月 天 数 的 函 数compDays(Month,ynLeap)，其中 Month 是月份，
# ynLeap 是 True或 False，如果闰年，则 ynLeap 是 True，否则 False；
# 【问题】语法是否合适？？ynLeap=isLeap(Year)可以省去继续调用函数。
#月份的数据。
# [1,31]，[2,29]或者[2,28]
#[3,31],[4,30],[5,31],[6,30],[7,31],[8,31],[9.30],[10,31],[11,30],[12,31]
def compDays(Month,ynLeap):
# 提前在外部判断ynLeap是否是平年如年，在下面compDays()中就可以直接用True,False
sumDay =0
isLeap(ynLeap)
#第一步，判断闰年平年。
# if，调用[2,29]或者[2,28]。
RunNian=[[1,31],[2,29],[3,31],[4,30],[5,31],[6,30],[7,31],[8,31],[9,30],[10,31],[11,30],[12,31]]
PingNian=[[1,31],[2,28],[3,31],[4,30],[5,31],[6,30],[7,31],[8,31],[9,30],[10,31],[11,30],[12,31]]
if ynLeap==True: #我在这儿还写了if isLeap(ynleap)==True,也没有必要。
RiLi=RunNian
#二月份天数
#第二步，判断月份数字，然后累加。用循环结构
for i in RiLi[0:Month]: #遍历日历中的月份
sumDay+=i[1]
else:
RiLi=PingNian
for i in RiLi[0:Month]:
#此处，之前写的是for i in Rili : while i<Month sumDay+=i[1],陷入了死循环，是因为忘记了i=i+1。如果i=1,泽一直循环。
# 实际上没有必要，复杂了。for 和while 几乎没有见过一起用。。
sumDay+=i[1]
print("从{0}年第一天起，到{1}月份，一共经历了{2}天。".format(a,Month,sumDay))
return(sumDay)
print(compDays(Month,ynLeap))
print("OK")
print(compDays(8,isLeap(2009)+10))
#得有print才能够显示出来。
#print(compDays(5,False))#b编程序时候，代入简单的数字验证。
#print(compDays(5,True))
#第三步，输入月份数字，可以输出和。
#print(compDays(10,isLeap(2000)+10) ，第一个10，月份；第二个isLeap(2000),是判断闰年工具。第三个10，为日子。
# 能计算出 2000 年 10 月 10 日是当年第多少天，
代码还可以如下：
'''
1、 天数计算。编写一个 isLeap(Year)函数，其中 Year 为整数年份，功能是判断该年是否为闰年，
函数返回值为 True 或 False，即返回类型为 boolean(布尔值)。
闰年的判断是：(1)当年份能被 4 整
除且能被 400 整除，为闰年；(2)当年份能被 4 整除但不能被 100 整除 ， 为 闰 年 。
编写一个 计 算 到 整 月 天 数 的 函 数compDays(Month,ynLeap)，
其中 Month 是月份，如果闰年，则 ynLeap 是 True，否则 False；
该函数计算经历整月的总天数( 完整经历每月天数累计求和) ，
一月份对应31天，
[1,31][2,29]或者[2,28]
[3,31],[4,30],[5,31],[6,30],[7,31],[8,31],[9.30],[10,31],[11,30],[12,31]
前面是月份，后面是天数。
如:compDays(10,False)则计算出 1-10 月最后一天不是闰年年份经历的总天数。
print(compDays(10,isLeap(2000)+10) 能计算出 2000 年 10 月 10 日是当年第多少天，
把参数改成其他日期，则计算到其他日期当年经过的天数。本题目的总要求就是输入日期
（年月日，格式不限），能计算出到当天当年的总天数；
'''
def main():
isLeap(Year)#功能是判断该年是否为闰年
ynLeap=isLeap(Year)#如此，在下面不用重复用函数计算。
compDays(Monthm,ynLeap)#该函数计算经历整月的总天数( 完整经历每月天数，各月天数累计求和) ，
compDays(10,isLeap(2000)+10)#用加号，是因为他要计算天数，正好365或者366，加让日期数字（天数从1开始的。）2000 年 10 月 10 日是当年第多少天，
pass
ynLeap=int(input("请输入年份："))
a=ynLeap
Month = int(input("请输入月份："))
#编写判断闰年函数。isLeap(Year)函数，其中 Year 为整数年份
#闰年的判断是：
# (1)当年份能被 4 整除且能被 400 整除，为闰年；
# (2)当年份能被 4 整除但不能被 100 整除 ，为 闰 年 。
def isLeap(Year):
if (Year % 400 == 0) or (Year % 4 == 0 and Year % 100 != 0):
True#True表示闰年
else:
False
return Year
#False表示平年
# #return 得返回一个值，否则会出现None
#计 算 到 整 月 天 数 的 函 数compDays(Month,ynLeap)，其中 Month 是月份，
# ynLeap 是 True或 False，如果闰年，则 ynLeap 是 True，否则 False；
# 【问题】语法是否合适？？ynLeap=isLeap(Year)可以省去继续调用函数。
#月份的数据。
# [1,31]，[2,29]或者[2,28]
#[3,31],[4,30],[5,31],[6,30],[7,31],[8,31],[9.30],[10,31],[11,30],[12,31]
def compDays(Month,ynLeap):
# 提前在外部判断ynLeap是否是平年如年，在下面compDays()中就可以直接用True,False
sumDay =0
isLeap(ynLeap)
#第一步，判断闰年平年。
# if，调用[2,29]或者[2,28]。
RunNian=[[1,31],[2,29],[3,31],[4,30],[5,31],[6,30],[7,31],[8,31],[9,30],[10,31],[11,30],[12,31]]
PingNian=[[1,31],[2,28],[3,31],[4,30],[5,31],[6,30],[7,31],[8,31],[9,30],[10,31],[11,30],[12,31]]
if ynLeap==True: #我在这儿还写了if isLeap(ynleap)==True,也没有必要。
RiLi=RunNian
#二月份天数
#第二步，判断月份数字，然后累加。用循环结构
for i in RiLi[0:Month]: #遍历日历中的月份
sumDay+=i[1]
else:
RiLi=PingNian
for i in RiLi[0:Month]:
#此处，之前写的是for i in Rili : while i<Month sumDay+=i[1],陷入了死循环，是因为忘记了i=i+1。如果i=1,泽一直循环。
# 实际上没有必要，复杂了。for 和while 几乎没有见过一起用。。
sumDay+=i[1]
print("从{0}年第一天起，到{1}月份，一共经历了{2}天。".format(a,Month,sumDay))
return(sumDay)
print(compDays(Month,ynLeap))
print("OK")
print(compDays(8,isLeap(2009)+10))
#得有print才能够显示出来。
#print(compDays(5,False))#b编程序时候，代入简单的数字验证。
#print(compDays(5,True))
#第三步，输入月份数字，可以输出和。
#print(compDays(10,isLeap(2000)+10) ，第一个10，月份；第二个isLeap(2000),是判断闰年工具。第三个10，为日子。
# 能计算出 2000 年 10 月 10 日是当年第多少天，
即可完成。
python 函数包的简单应用
语词
jieba切分语词
myFile=open("资本论.txt","r",encoding="utf-8")
myData=myFile.read()
myFile.close()
import jieba
wordsList=jieba.lcut(myData)#用lcut 生成列表，比用cut生成字符串好。
wordsDict={}
for i in wordsList:
wordsDict[i]=wordsDict.get(i,0)+1#生成字典。
lineList=list(wordsDict.items())
lineList.sort(key=lambda x:x[1],reverse=True)#排序
def Result():#便于让形式美观。
count=0
print("词条".ljust(16),"数量",sep='\t',file=writeFile)
for (i,num) in lineList:
if len(i)==1 and (19968>ord(i) or ord(i)>40869):#在最后清除非汉字，有利于减少运算量。
continue
print(i.ljust(16),num,sep='\t',file=writeFile)
count+=1
if count==10000:break
writeFile=open("1700014174_Work08_00.txt","w",encoding="utf-8")
Result()
writeFile.close()
小说切分
#打开文件的函数。
def Open():
file=open('E:\\文件\\2020文件\\书籍文本\\三国演义.txt','r',encoding='GB18030')
myData=file.read()
file.close()
datalist=myData.splitlines()
## for i in datalist:
## print(i)
## input()
import jieba
myWords=jieba.lcut(myData)
print(myWords)
myfile=open('1700014174_work01.txt','w',encoding='utf-8')
Open()
myfile.close()
计算机 积累程序 分词 jieba包的使用。
import jieba
# 待分词的句子
sentence = '今天的天气很不错'
# 对句子分词，返回词组成的字符串列表
words = jieba.lcut(sentence)
# 输出词列表
print(words)
# 用空格拼接词并输出
print(" ".join(words))
将汉字按照2字1词模式切分。
file=open("FreePic2Pdf_bkmk.txt","r",encoding="utf-8")
data=file.read()
file.close()
datalines=data.splitlines()
wfile=open("FreePic2Pdf_bkmk.txt","w",encoding="utf-8")
for line in datalines:
if " " in line:
nline=line.split(" ")
if len(nline[-1])>10:
for word in nline[:-1]:
print(word,file=wfile)
mstr=nline[-1]
a=len(mstr)
n=0
for i in range(0,a):
if n%2==0:
print("\t",end="",sep="",file=wfile)
print(mstr[i],end="",sep="",file=wfile)
else:
print(mstr[i],end="",sep="",file=wfile)
print("\n",end="",file=wfile)
n+=1
print("\n",file=wfile)
else:
for w in nline:
print("\t",w,file=wfile)
else:print(line,file=wfile)
wfile.close()
json统计词频
'''
## allContent=dataStr
## myTitle=myDict['title']
## myKeywords=myDict['keywords']
## myDesc=myDict['desc']
'''
#这个程序用来计算新闻的词频。
file=open('news2016zh_train.json','r',encoding='utf-8')
import json
import jieba
import time
wordsDict={}
count=0
while count<1000:
dataStr=file.readline()
for everyStr in '012345.6789#@$!%^&*()_+；“”':
dataStr=dataStr.replace(everyStr,'')#在最开始就通过字符串，替换消除不合适选项
myDict=json.loads(dataStr)#将json文件转化为字典,可以分类考察词频
myContent=myDict['content']
contentWords=jieba.lcut(myContent)#这里的变量可以替换为myContent,myDesc等等。
for iWord in contentWords:
if len(iWord)!=1:
wordsDict[iWord]=wordsDict.get(iWord,0)+1
count+=1
file.close()
myList=list(wordsDict.items())
myList.sort(key=lambda x:x[1],reverse=True)
print(myList[:50])
print(time.process_time())
即可完成。
利用字典统计连接词
代码如下：
#定义一个函数，用来相加字典。
def addDic(dicA,dicB):
newDic={}
for key in dicA:
if dicB.get(key):
newDic[key]=dicA[key]+dicB[key]
else:
newDic[key]=dicA[key]
for key in dicB:
if dicA.get(key):
pass
else:
newDic[key]=dicB[key]
return newDic
#这个程序用来计算文本中的跟随字
file=open('mytest.txt','r',encoding='utf-8')
import time
wordsDict={}#总的字典。key是各个字。
count=0
while True:
dataStr=file.readline()
for everyStr in '？·）-/「！（ABCDEFGHIJKLMNOPQRSTUVWXYZ:<\n,abcdefghijklmnopqrstuvwxyz{}：，012345. 6789#@$!%^&*()。\\r、_+；，"“”':
dataStr=dataStr.replace(everyStr,'')#在最开始就通过字符串，替换消除不合适选项
myList=list(dataStr)
for everyWord in set(myList):#用集合加快速度。
everyDict={}#第二级字典，key是各个后接字
count=0
for iWord in myList[:-1]:
count+=1
if iWord==everyWord:
afterWord=myList[count]##计算出本字后的字
everyDict[afterWord]=everyDict.get(afterWord,0)+1
if everyWord not in wordsDict:
wordsDict[everyWord]=everyDict
else:#将wordsDict[everyWord].values()对应的字典→dicA和dicB→eveyDict合并，调用之前的函数。
dicA=wordsDict[everyWord]
dicB=everyDict
wordsDict[everyWord]=addDic(dicA,dicB)
if not dataStr:
break
file.close()
resultList=list(wordsDict.items())
resultList.sort(key=lambda x:len(x[1]),reverse=True)
for i in resultList:
print(i[0],':',end='')
for (k,v) in i[1].items():
print(k,v,end=',')
print()
print(time.process_time())即可完成。
计算新闻词频-先用字符串去除不符合选项-json文件处理
#这个程序用来计算新闻的词频。
file=open('news2016zh_valid.json','r',encoding='utf-8')
import json
import jieba
wordsDict={}
count=0
while count<30:
dataStr=file.readline()
for everyStr in '012345.6789#@$!%^&*()_+；“”':
dataStr=dataStr.replace(everyStr,'')#在最开始就通过字符串，替换消除不合适选项
myDict=json.loads(dataStr)#将json文件转化为字典,可以分类考察词频
allContent=dataStr
myContent=myDict['content']
myTitle=myDict['title']
myKeywords=myDict['keywords']
myDesc=myDict['desc']
contentWords=jieba.lcut(allContent)#这里的变量可以替换为myContent,myDesc等等。
for iWord in contentWords:
if len(iWord)!=1:
wordsDict[iWord]=wordsDict.get(iWord,0)+1
if False:break
count+=1
file.close()
myList=list(wordsDict.items())
myList.sort(key=lambda x:x[1],reverse=True)
print(myList[:50])
sys路径
代码如下
#sys可以查看程序运行所在的位置。
##在 python 用 import 或者 from...import 来导入相应的模块。
##
##将整个模块(somemodule)导入，格式为： import somemodule
##
##从某个模块中导入某个函数,格式为： from somemodule import somefunction
##
##从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
##
##将某个模块中的全部函数导入，格式为： from somemodule import *
import sys
print('================Python import mode==========================')
print ('命令行参数为:')
for i in sys.argv:
print (i)
print ('\n python 路径为',sys.path)
即可完成。
beautiful soup
提取书签
代码如下：
'''
<span id="ztree_159_span" class="node_name">谢灵运 虽无壮士节 与世亦殊伦</span>
</a></li><li id="ztree_160" class="level0" tabindex="0" hidefocus="true" treenode="">
<span id="ztree_160_switch" title="" class="button level0 switch center_docu" treenode_switch="">
</span><a id="ztree_160_a"class="level0" treenode_a="" onclick="" target="_blank" style=""
title="范晔 文为士范 行非士则">
'''
myWord="""
[Images]
[Font]
Language=GBK
FontSize=7
Margin=0.5
[Bkmk]
File=FreePic2Pdf_bkmk.txt
AddAsText=0
ShowBkmk=1
ShowAll=1
BasePage=30
[Main]
ContentsPage=
TextPage=
"""
contentPage=33
import requests
from bs4 import BeautifulSoup as bs
webFile=open("搜神记.html","r",encoding="utf=8")
data=webFile.read()
webFile.close()
mysoup=bs(data,"html.parser")
mysoup.prettify()
result=mysoup.find_all("span")
writeFile=open("FreePic2Pdf_bkmk.txt","w",encoding="utf-8")
for i in result:
if "node_name" in str(i):
print(i.get_text(),"\t",contentPage,file=writeFile)
writeFile.close()
itfFile=open("FreePic2Pdf.itf","w",encoding="utf-8")
print(myWord,file=itfFile)
itfFile.close()
文件 pdf 书签 从网络上爬虫提取 beautiful soup 超星图书馆的书。
file=open("FreePic2Pdf_bkmk.txt","r",encoding="utf-16LE")
data=file.read()
file.close()
writeFile=open("E:\FreePic2Pdf_bkmk.txt","w",encoding="utf-16LE")
myStr="0123456789"
for i in myStr:
data=data.replace(i,"")#这种结构是迭代。如果不采用此结构，替换的数量就是有限的几个。
datalines=data.splitlines()
for line in datalines:
print(line,"33",file=writeFile)
writeFile.close()
itf=open("FreePic2Pdf.itf","r",encoding="utf-16LE")
idata=itf.read()
itf.close()
itfFile=open("E:\FreePic2Pdf.itf","w",encoding="utf-16LE")
print(idata,file=itfFile)
itfFile.close()
文件 pdf书签 提取后进一步编辑 去除页码加上新页码。
下载歌曲
代码如下：
import requests
from bs4 import BeautifulSoup as bs
url1='''
https://c.y.qq.com/soso/fcgi-bin/client_search_cp?
ct=24&qqmusic_ver=1298&
new_json=1&remoteplace=txt.yqq.song&
searchid=57068364391640558&t=0&aggr=1&cr=1&catZhida=1&lossless=0&flag_qc=0&
'''
url2="p=1"
url3="""
&n=10&w=%E5%91%A8%E6%9D%B0%E4%BC%A6&g_tk_new_20200303=5381&g_tk=5381&loginUin=0&hostUin=0&format=json&inCharset=utf8&outCharset=utf-8¬ice=0&platform=yqq.json&needNewCode=0
"""
for i in range(1,6):
url=url1+"p="+str(i)+url3
webFile=requests.get(url)
webFile.encoding="utf-8"
data=webFile.text
jsonMusic=webFile.json()
listMusic = jsonMusic['data']['song']['list']
for i in listMusic:
print("专辑名：",i["albumname"])
print("歌曲名：",i["songname"])
print('播放时长：'+str(i['interval'])+'秒')
print('播放链接：https://y.qq.com/n/yqq/song/'+i['media_mid']+'.html\n\n')
随机数random
random
库采用梅森旋转算法
(Mersenne
twister)
生成伪随机数序列，可用于除随机性要
求更高的加解密算法外的大多数工程应用。
最基本的函数是
random. random()
，它生成一个
[0.0,
1.0)
之间的随机小数，所有其他随机函数都是基于这个函数
扩展而来。
代码如下：
from random import *
print(random())
print(randint(19,345))
print(uniform(109,234))
在Python中，通过设定一个种子(seed)，可以确保每次调用随机函数生成的随机数是相同的。种子是一个整数值，它作为随机数生成器的起点。当使用相同的种子时，随函数将按照相同的顺序生成相同的随机数序列。
要设定种子并生成相同的随机数序列，可以使用random模块中的seed()函数。seed()函数接受一个整数参数，该参数作为种子值。
以下是一个示例代码，展示了如何设定种子并生成相同的随机数序列：
import random
# 设定种子
random.seed(42)
# 生成随机数
print(random.random()) # 输出：0.6394267984578837
# 再次生成随机数
random.seed(42)
print(random.random()) # 输出：0.6394267984578837
在上面的代码中，我们首先设定种子为42，然后调用random.random()函数生成一个随机数。接着，我们再次设定种子为42，并再次调用random.random()函数生成另一个随机数。由于种子相同，所以两次调用生成的随机数是相同的。
需要注意的是，只有在相同的种子下，生成的随机数序列才会相同。如果改变种子，生成的随机数序列也会改变。
排列参考文献 pypinyin
生活中的实际情况：写完论文后，文本中有很多条参考文献，用pyhon写代码，按照每一条参考文献的第一个汉字的字母顺序，排列参考文献。
询问“文心一言”，请人工智能写一下代码。人工智能给出的参考如下：
分析：要按照每条参考文献的第一个汉字的字母顺序排列参考文献，我们可以按照以下步骤进行：
- 读取参考文献列表。
- 提取每条参考文献的第一个汉字。
- 将这些汉字转换为拼音。
- 根据拼音对参考文献进行排序。
- 输出排序后的参考文献列表。
以下是一个简单的Python代码示例，使用pypinyin库将汉字转换为拼音，然后根据拼音排序：
from pypinyin import lazy_pinyin
# 假设参考文献是一个列表，其中每个元素都是一个字符串，代表一条参考文献
references = [
"文献1",
"文献2",
"参考3",
"文4",
"献5",
"文6",
]
# 使用pypinyin将每个参考文献的第一个汉字转换为拼音，并添加到新的列表中
pinyin_references = [lazy_pinyin(ref)[0] for ref in references]
# 根据拼音对参考文献进行排序
sorted_references = sorted(zip(pinyin_references, references), key=lambda x: x[0])
# 输出排序后的参考文献列表
for pinyin, ref in sorted_references:
print(ref)注意：这个代码示例使用了lazy_pinyin函数，它只会转换每个汉字的第一个字母为拼音，而不是整个汉字。如果你希望获取整个汉字的拼音，可以使用pypinyin库的pinyin函数代替。
在电脑上实际操作，如下：
myfile=open("wenxian.txt","r",encoding="utf-8")
data=myfile.read()
myfile.close()
ref_lines=data.splitlines()
ref_lines=[s for s in ref_lines if s]#列表中的元素可能是空字符串（空行），你可以使用列表推导式删除这些空字符串
from pypinyin import lazy_pinyin
# 使用pypinyin，遍历每个参考文献ref，将其第一个汉字lazy_pinyin(ref)[0] 转换为拼音，并添加到新的列表pinYin_ref中
pinYin_ref=[lazy_pinyin(ref)[0] for ref in ref_lines]
sorted_references = sorted(zip(pinYin_ref, ref_lines), key=lambda x: x[0])
for pinyin,ref in sorted_references:
print(ref)
实际上，对这段代码可以继续优化。如下所示：
myfile=open("wenxian.txt","r",encoding="utf-8")
data=myfile.read()
myfile.close()
data=data.replace("参看","")#脚注中有时候会有“参看”二字，无用，删除。
data=data.replace("转引","")
data=data.replace(" ","")#把无效的空格信息删除
data=data.replace("；","\n")#脚注中有时候用“；”并列了几条参考文献，将它们分开。
ref_lines=data.splitlines()
ref_lines=[s for s in ref_lines if s]#列表中的元素可能是空字符串（空行），你可以使用列表推导式删除这些空字符串
myref_lines=[]
for s in ref_lines:
if " 《" in s[0:3]:pass
elif "《" in s[0]:pass
else:
start_index = s.rfind("第") # 找到最后一个"第"的位置
end_index = s.rfind("页") # 找到最后一个"页"的位置
if start_index != -1 and end_index != -1: # 如果找到了匹配的位置
s= s[:start_index-1] + "。" # 切片移除"第x页。"这部分字符
myref_lines.append(s)#对参考文献条进一步修正。
myref_lines=list(set(myref_lines))
##for i in myref_lines:
## print(i)
from pypinyin import lazy_pinyin
# 使用pypinyin，遍历每个参考文献ref，将其第一个汉字lazy_pinyin(ref)[0] 转换为拼音，并添加到新的列表pinYin_ref中
pinYin_ref=[lazy_pinyin(ref)[0] for ref in myref_lines]
print(pinYin_ref)
sorted_references = sorted(zip(pinYin_ref, myref_lines), key=lambda x: x[0])
for pinyin,ref in sorted_references:
print(ref)
该代码，删除了一些无效的信息。
让它按照文献的不同类型来进行排列。
即可完成。
遍历文件夹中的文件os
os.chdir("E:\eng")
subList=os.listdir(os.getcwd())#总的eng文件夹。
print(subList)
os.getcwd()
#作用：获取当前的工作路径；
os.getcwd()
os.listdir(path)
#作用：传入任意一个path路径，返回的是该路径下所有文件和目录组成的列表；
os.walk(path)
#含义 ：传入任意一个path路径，深层次遍历指定路径下的所有子文件夹，返回的是一个由路径、文件夹列表、文件列表组成的元组。
os.path.exists(path)
#含义：传入一个path路径，判断指定路径下的目录是否存在。存在返回True，否则返回False；
os.mkdir(path)
#含义：传入一个path路径，创建单层(单个)文件夹；
#注意：如果文件夹已经存在，就会报错。因此创建文件夹之前，需要使用os.path.exists(path)函数判断文件夹是否存在；在运行os 得时候，在E盘新建了文件夹，命名为"test"。test文件夹里的程序，命名为"mytest.py"。
运行的时候，出现如下问题：“OSError: [WinError 123] 文件名、目录名或卷标语法不正确”。
推测，文件见命名为test,在程序运行的时候会因为同名而产生冲突。所以， 重新命名文件夹为“scoretest”。
然后运行程序：
import os
os.chdir("E:\scoretest")
subList=os.listdir(os.getcwd())#总的eng文件夹
print(subList)
这时候，就会呈现出该文件夹中的子项。
积累程序-滚动的广告牌。
import os,time
#滚动的广告牌
def main():
content="欢迎光临穿着熊快餐车，喵喵喵~"
for i in range(16):
os.system("clear")
print(content)
content=content[1:]+content[0]#形成一个循环。
if __name__=='__main__':
main()
input()
#第二类方法
#r:回车符,返回到这一行的开头,return的意思。\n:换行符,到下一行的同一位置,纵坐标相同,new line的意思。\t:制表符
content = '欢迎光临穿着熊快餐车，喵喵喵～'
for i in range(16):
print('\r'+content, end='', flush=True)
content = content[1:]+content[0]
time.sleep(0.25)
print('')
for i in range(16):
print(content, end='', flush=True)
content = content[1:]+content[0]
time.sleep(0.25)
print('')
数据处理numpy
'''
如果想知道函数包的用法。上cmd,
import <函数包>
或者 from <函数包> import <某函数>
help(函数包)
dir(函数包)
'''
def Hanshu():
#一维数组
import numpy as np
myrange=range(10)
print(myrange)
#print(type(inylist))
newlist=list(myrange)
mylist3=np.array(newlist)
#print(mylist3)
for i in mylist3:
print(i)
#print(type(newlist))
myrange2=np.arange(10)
def ZhenXian():
#制作正弦曲线y=x^3
import matplotlib.pyplot as plt
import numpy as np
x=np.linspace(-5,5,250)
y=np.sin(x**3)
plt.plot(x,y,'r--')
plt.show()
#ZhenXian()
def Zhengtai():
#用于绘图的模块
import matplotlib.pyplot as plt
import numpy as np
import random
#设置随机种子
a=np.random.seed(1234)
#随机产生的样本量
N=10000
#生成正态随机数
randnorm=np.random.normal(size=N)
#print(randnorm)
bins=np.sqrt(N)
#正态分布密度函数
sigma=1;mu=0
a=1/(np.sqrt(2*sigma*np.pi))
b=np.exp(-((bins-mu)**2)/2)
norm_dist=a*b
print(norm_dist)
x=np.sqrt(N)
y=norm_dist
plt.plot(x,y,'r--')
plt.show()
#最后这个正态图没有做出来
#《python 可视化数据分析》李迎，第102页
#Zhengtai()
import matplotlib.pyplot as plt
import numpy as np
import random
#等差数列。
mylist=np.arange(2,50,3)
#随机数列
newlist=np.linspace(1,10,50)
print(mylist)
print(newlist)
数据可视panda
'''
https://blog.csdn.net/qq_43003358/article/details/103809293
电影评分数据的统计分析及可视化
1. 数据准备（获取、读取）
从网上获取的电影评分数据集。包含6040个用户对3900部电影做出的1000209条评分。数据集包含3个文件，各文件说明如下：
（1）"ratings.dat"：UserID，MovieID，Rating，Timestamp
- UserI：用户ID（1-6040）
- MovieID：电影ID（1-3952）
- Rating：评分（1-5） are made on a 5-star scale (whole-star ratings only)
- Timestamp：时间戳（时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。）
每个用户至少有 20 个评分
（2）"users.dat"：UserID，Gender，Age，Occupation，Zip-code
- Gender：性别"M"（男），"F"（女）
- Age：年龄，根据如下范围标注为对应数字
* 1: "Under 18"
* 18: "18-24"
* 25: "25-34"
* 35: "35-44"
* 45: "45-49"
* 50: "50-55"
* 56: "56+"
-Occupation：职业，根据如下列表标注为对应数字
* 0: "other" or not specified
* 1: "academic/educator"
* 2: "artist"
* 3: "clerical/admin"
* 4: "college/grad student"
* 5: "customer service"
* 6: "doctor/health care"
* 7: "executive/managerial"
* 8: "farmer"
* 9: "homemaker"
* 10: "K-12 student"
* 11: "lawyer"
* 12: "programmer"
* 13: "retired"
* 14: "sales/marketing"
* 15: "scientist"
* 16: "self-employed"
* 17: "technician/engineer"
* 18: "tradesman/craftsman"
* 19: "unemployed"
* 20: "writer"
- Zip-code:邮编
（3）"movies.dat" ：MovieID，Title，Genres
-Title：电影名
- Genres ：题材（包含于下面的列表中）
* Action
* Adventure
* Animation
* Children's
* Comedy
* Crime
* Documentary
* Drama
* Fantasy
* Film-Noir
* Horror
* Musical
* Mystery
* Romance
* Sci-Fi
* Thriller
* War
* Western
'''
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
#读取users数据集
unames = ['user_id', 'gender', 'age', 'occupation', 'zip']
users = pd.read_table('users.dat', sep='::', header=None, names=unames, engine='python')
#读取ratings数据集
rnames = ['user_id', 'movie_id', 'rating', 'timestamp']
ratings = pd.read_table('ratings.dat', sep='::', header=None, names=rnames, engine='python')
#读取movies数据集
mnames = ['movie_id', 'title', 'genres']
movies = pd.read_table('movies.dat', sep='::', header=None, names=mnames, engine='python')程序界面tkinter
tkinter说明
tkinter 是 Python 的标准 GUI（图形用户界面）库，用于开发桌面应用程序。它提供了一个跨平台的框架，使得开发者可以在 Windows、Linux 和 macOS 等操作系统上创建图形用户界面。
以下是关于
tkinter的一些基本解释和要点：
起源：
tkinter是 Tk 工具包的 Python 接口。Tk 工具包（也称为 Tk 或 Tkinter）是一个用于创建图形用户界面的开源工具包，最初由 John Ousterhout 在加州大学伯克利分校开发。组件：
tkinter提供了许多预定义的组件，如按钮（Button）、标签（Label）、文本框（Entry）、列表框（Listbox）、滚动条（Scrollbar）等。- 这些组件可以组合在一起，以创建复杂的用户界面。
布局管理：
tkinter提供了几种布局管理器，如pack、grid和place，用于控制组件在窗口中的位置和大小。事件处理：
- 用户与 GUI 组件的交互（如点击按钮或输入文本）会产生事件。
tkinter允许你定义事件处理程序（也称为回调函数），这些程序会在特定事件发生时执行。使用方式：
- 你可以使用面向对象的方法或函数式方法来使用
tkinter。面向对象的方法更为常见，因为它更加直观和易于理解。
代码如下：
import tkinter as tk
def on_button_click():
print("Button clicked!")
# 创建主窗口
root = tk.Tk()
root.title("My First Tkinter App")
# 创建一个标签
label = tk.Label(root, text="Hello, Tkinter!")
label.pack(pady=20) # 使用 pack 布局管理器放置标签
# 创建一个按钮，并绑定点击事件到 on_button_click 函数
button = tk.Button(root, text="Click Me!", command=on_button_click)
button.pack(pady=20) # 使用 pack 布局管理器放置按钮
# 进入主事件循环
root.mainloop()效果界面如下所示：
又一个代码如下所示：
import tkinter as tk
# 定义事件处理函数
def on_button_click():
user_input = entry.get() # 从输入框获取文本
label.config(text=f"Hello, {user_input}!") # 更新标签的文本
# 创建主窗口
root = tk.Tk()
root.title("简单桌面应用程序")
# 创建一个标签
label = tk.Label(root, text="请输入你的名字：")
label.pack(pady=20) # 使用pack布局管理器放置标签
# 创建一个输入框
entry = tk.Entry(root)
entry.pack(pady=10) # 使用pack布局管理器放置输入框
# 创建一个按钮，并绑定点击事件到on_button_click函数
button = tk.Button(root, text="点击我", command=on_button_click)
button.pack(pady=20) # 使用pack布局管理器放置按钮
# 进入主事件循环
root.mainloop()生成效果如下:
即可完成。
在这个示例中，我们首先导入了
tkinter模块，并定义了一个名为on_button_click的函数，该函数将在按钮被点击时触发。在这个函数中，我们从输入框（entry）中获取用户输入的文本，并使用这个文本来更新标签（label）的显示内容。界面依次从上到下：创建主窗口（
root），并设置了窗口的标题；创建了标签（label）、输入框（entry）和按钮（button），并使用pack布局管理器将它们放置在窗口中。
最后，我们调用了
root.mainloop()来启动应用程序的主事件循环，这将使窗口保持打开状态，并等待用户交互。
数据可视化matplotlib
坐标点
数据可视化 matploactlib基本语法 确定纵坐标点 导入包
from matplotlib.pyplot import *
plot([1,2,3,2,3,2,2,1])#纵坐标的值。横坐标默认为纵坐标所在的序列。
show()
运行这段代码，执行效果如下：
即可完成。
统计图
数据可视化； 基础语法； matplotlib 数据； 案例来自书籍。
from matplotlib.pyplot import *
# some simple data
x = [1,2,3,4]
y = [5,4,3,2]
# create new figure
figure()
# divide subplots into 2 x 3 grid
# and select #1
subplot(231)
plot(x, y)
# select #2
subplot(232)
bar(x, y)
# horizontal bar-charts
subplot(233)
barh(x, y)
# create stacked bar charts
subplot(234)
bar(x, y)
# we need more data for stacked bar charts
y1 = [7,8,5,3]
bar(x, y1, bottom=y, color = 'r')
# box plot
subplot(235)
boxplot(x)
# scatter plot
subplot(236)
scatter(x,y)
show()运行这段代码，在出现的Figure界面，选择界面下方的保存按钮，
生成统计图，代码执行的效果如下：
对这段代码进行重新调试。
from matplotlib.pyplot import *
x = [0,1,2,3,4] # some simple data
y = [6,5,4,3,2]
figure()# create new figure
subplot(231) # divide subplots into 2 x 3 grid # and select #1 把显示界面进行分割。如3 x 3分割,然后选择第1个。
plot(x, y)
subplot(232) # select #2选择第二个区域。
bar(x, y) # horizontal bar-charts ，纵向统计图。
subplot(233) # select #3选择第三个区域。
barh(x, y) #横向统计图
subplot(234) # create stacked bar charts 选择第四个模块。
bar(x, y)
y1 = [3,7,8,5,3] # we need more data for stacked bar charts 。纵坐标统计图中，y1之上为需要填充颜色染色部分。
bar(x, y1, bottom=y, color = 'r') #在y的基础上，又加了y1 长度。注意，需要保持y和y1元素个数的一致。
subplot(235) # box plot 选择第5个区域
boxplot(x) #统计x所在的范围，方块图。
subplot(236)
scatter(x,y)# scatter plot ，散点图。
show()
所得效果如下：
正弦函数
数据可视化；绘制正弦曲线； 用qt matplotlib包
要想生成正弦函数，有如下代码：
import matplotlib.pyplot as pyplot
import numpy as np
m=int(input("请输入想要在1到10的距离内用多少点来表示这幅正弦函数图："))
x=np.linspace(-10,10,m)#横坐标x为1到10，m个横坐标点。
y=np.sin(x)
pyplot.plot(x,y,label=f"y=sin(x),x∈[-10,10],n={m})")
pyplot.legend()
pyplot.show()#展示这幅图。
生成图如下所示：
要想得到不同精度的图，可以进行如下设置：
import matplotlib.pyplot as pyplot
import numpy as np
for m in range(10,100,5):
x=np.linspace(1,10,m)#横坐标x为1到10，m个横坐标点。
y=np.sin(x)
pyplot.plot(x,y,label=f"x=np.linspace(1,10,{m})")
pyplot.legend()
pyplot.show()
运行这段代码，可以依次得到不同的正弦函数图。原因在于有m个横坐标点。通过m坐标点数的变化，可以得到不同精度的图形。
图像调整
积累程序 ；数据可视化； matplotlib； 参数调整 ls lw color 等。
对于函数图像的颜色、宽度、形状等，都可以进行调整。
import matplotlib.pyplot as pyplot
import numpy as np
x=np.linspace(1,10,100)#横坐标x为1到10，m个横坐标点。
y=np.sin(x)
pyplot.plot(x,y,label=f"y=sin(x),x=∈(1,10),n=100",ls="-.",lw="0.5",color="r")
pyplot.legend()
pyplot.show()
生成图像如下所示：
ls ="- ."，指的是线条的形式。举例如下：
'-', '--', '-.', ':'
lw="0.5"，指的是线条的宽度。
即可完成。
python函数包的综合应用
处理excel文件 openpyxl
整理并提取文件名称
统计各个高中的高考录取数据。各个数据表格的名称不一致。列表栏目也不一致。
整理数据文件，从xls文件中提取各个高中的名称，如下代码：
import os
import openpyxl
os.chdir("E:\scoretest")
subList=os.listdir(os.getcwd())
for isen in subList:
#先从文件中取中学的名字。
name=isen.split("中")
aSen=name[0]
bSen=aSen+"中"
if bSen[-3:]=="高级中":
school=bSen+"学"
elif bSen[-3:]=="高中学":
school=bSen[:-1]
elif bSen[-3]=="第":
school=bSen+"学"
else:
school=bSen
print(school)获取各个文件中第一行标题栏
openpyxl处理文件需要注意，它针对的是xlsx，而不是xls。如果是xls，仅仅表面上改变一下名称为xlsx是不行的，openpyxl依然无法处理。可以选择用函数包xlrd等，或者是通过Excel或者WPS将xls文件另存为xlsx文件，这样就能够打开了。
import os
import openpyxl
os.chdir("E:\scoretest")
subList=os.listdir(os.getcwd())
for myxlsxName in subList:
print(myxlsxName)
wb=openpyxl.load_workbook(filename=myxlsxName)
mysheet=wb[wb.sheetnames[0]] #读取xlsx文件中的第一张表。
column_count = mysheet.max_column #获取竖列column的数量。
row_count=mysheet.max_row+1#获取横行column的数量。因为循环的时候是“左闭右开”，所以会加上1。
headList=[]
for col in range(1,column_count+1):
cell_value = mysheet.cell(row=1, column=col).value
headList.append(cell_value)
print(headList)
即可完成。
打开相关文件
使用openpyxl安装包，读取xlsx文件。下面是一个案例
import openpyxl
file1=openpyxl.load_workbook("Marvel.xlsx")#打开工作表
sheet=file1["new title"]
sheetname=file1.sheetnames# 获取“Marvel.xlsx”工作薄中名为“new title”的工作表
print(sheetname)# sheetnames是用来获取工作薄所有工作表的名字的，如果不知道工作薄到底有几个工作表，就可以把工作表的名字都打
A1cell=sheet['A1']
A1value=A1cell.value# 把“new title”工作表中A1单元格赋值给A1_cell，再利用单元格value属性，就能打印出A1单元格的值
print(A1value)
下面是另外一个案例.
import openpyxl
wb2=openpyxl.load_workbook(filename="积累文档-QQ音乐链接简练版.xlsx")
sheetRanges=wb2[wb2.sheetnames[0]]#定位到表格第一张表
myList=[]
for row in sheetRanges.rows:#遍历每一横行
iList=[]
iList.append(row[0].value)#输出xlsx文件每一单元格中的值
iList.append(row[1].value)
myList.append(iList)
newLine=[]
for everyLine in myList:
if len(everyLine[0])>=20:
newStr=everyLine[0].replace(everyLine[0],"关于腾讯 ")
newLine.append([newStr,everyLine[1]])#依据字符串长度判断，将delStr中的语句替换，使得文本更加简明清晰
else:
newLine.append(everyLine)
for i in newLine:
print(i)
即可完成。
又如下面例子。
import os
from random import choice,randrange
from random import *
from openpyxl import Workbook,load_workbook
import sqlite3
def GRD():
for i in range(10):
xlsName="xlsxs"+str(i)+".xlsx"
totalLines=randrange(100)
wb=Workbook()
ws=wb.worksheets[0]
ws.append(["a","b","c","d","e"])
for j in range(totalLines):
line=[chr(randint(50,70)) for x in range(5) ]
ws.append(line)
wb.save(xlsName)
GRD()
print(os.getcwd())
os.chdir("E:\社团")
print(os.listdir(os.getcwd()))
xlsxs=("xlsxs"+ fn for fn in os.listdir("."))
with sqlite3.connect("dataxlsx.db") as conn:
cur=conn.cursor()
for xlsx in xlsxs:
sql="INSERT INFO fromxlsx VALUE(?,?,?,?,?)"
cur.executemany(sql,eachXlsx(xlsx))
conn.commit()
即可完成。
统计各个xlsx表中的成绩
完整代码如下：
import os
import openpyxl
wblast=openpyxl.Workbook()
wslast=wblast.active
rowHead=["姓名","性别","民族","就读学校","文理/理科","高考成绩","录取院校","录取专业"]
wslast.append(rowHead)
os.chdir("E:\scoretest")
subList=os.listdir(os.getcwd())
n=2 #在总的汇集表格中列出其名,n=1的时候是标题栏。n>=2是正文。
for myxlsxName in subList:
#先从文件中取中学的名字。
name=myxlsxName.split("中")
aSen=name[0]
bSen=aSen+"中"
if bSen[-3:]=="高级中":
school=bSen+"学"
elif bSen[-3:]=="高中学":
school=bSen[:-1]
elif bSen[-3]=="第":
school=bSen+"学"
else:
school=bSen
print(school)
wb=openpyxl.load_workbook(filename=myxlsxName)
mysheet=wb[wb.sheetnames[0]] #读取xlsx文件中的第一张表。
column_count = mysheet.max_column #获取竖列column的数量。
row_count=mysheet.max_row+1#获取横行column的数量。因为循环的时候是“左闭右开”，所以会加上1。
headList=[]
for col in range(1,column_count+1):
cell_value = mysheet.cell(row=1, column=col).value
headList.append(cell_value)
nameCol=headList.index("姓名")+1
if "录取院校" in headList:
universityIndex=headList.index("录取院校")#用于将不规则的字头题目转化为统一的文本形式
headList[universityIndex]="录取学校"
elif "录取大学" in headList:
universityIndex=headList.index("录取大学")
headList[universityIndex]="录取学校"
else:pass
universityCol=headList.index("录取学校")+1
if "文科/理科" in headList:
wenliIndex=headList.index("文科/理科")
headList[wenliIndex]=("文理科")
elif "科类" in headList:
wenliIndex=headList.index("科类")
headList[wenliIndex]="文理科"
else:pass
if "文理科" in headList:
wenlikeCol=headList.index("文理科")+1
else:wenlikeCol=10
if "高考分数" in headList:
fenshuIndex=headList.index("高考分数")
headList[fenshuIndex]="高考成绩"
else:pass
if "高考成绩" in headList: fenshuCol=headList.index("高考成绩")+1
else:fenshuCol=10
if "民族" in headList:minzuCol=headList.index("民族")+1
else:minzuCol=10
if "性别" in headList:xingbieCol=headList.index("性别")+1
else:xingbieCol=10
if "专业" in headList:majorCol=headList.index("专业")+1
else:majorCol=10
for row in range(2,mysheet.max_row+1):
name_cell_value=mysheet.cell(row=row,column=nameCol).value
university_cell_value=mysheet.cell(row=row,column=universityCol).value
wenlike_cell_value=mysheet.cell(row=row,column=wenlikeCol).value
fenshu_cell_value=mysheet.cell(row=row,column=fenshuCol).value
minzu_cell_value=mysheet.cell(row=row,column=minzuCol).value
xingbie_cell_value=mysheet.cell(row=row,column=xingbieCol).value
fenshu_cell_value=mysheet.cell(row=row,column=fenshuCol).value
major_cell_value=mysheet.cell(row=row,column=majorCol).value
wslast.cell(n,1,name_cell_value)
wslast.cell(n,2,xingbie_cell_value)
wslast.cell(n,3,minzu_cell_value)
wslast.cell(n,4,school)
wslast.cell(n,5,wenlike_cell_value)
wslast.cell(n,6,fenshu_cell_value)
wslast.cell(n,7,university_cell_value)
wslast.cell(n,8,major_cell_value)
n+=1
wblast.save("E:\scoreCa.xlsx")
比较两个表格的异同
在处理完毕高考成绩后，现在需要比较两张表格的异同。则用如下代码：
import os
import openpyxl
from openpyxl import Workbook
wblost=Workbook()
wslost=wblost.active
wb2=openpyxl.load_workbook(filename="scoreCa.xlsx")#这张表上的人名有些遗失
mysheet2=wb2[wb2.sheetnames[0]] #读取xlsx文件中的第一张表。
column_count2 = mysheet2.max_column #获取竖列column的数量。
row_count2=mysheet2.max_row+1#获取横行column的数量。因为循环的时候是“左闭右开”，所以会加上1。
nameList2=[]
for row in range(1,row_count2+1):
cell_value = mysheet2.cell(row=row, column=1).value
name2=cell_value
nameList2.append(name2)
wb1=openpyxl.load_workbook(filename="allinfo.xlsx")#这张表中的人名比较全。
mysheet=wb1[wb1.sheetnames[0]] #读取xlsx文件中的第一张表。
column_count = mysheet.max_column #获取竖列column的数量。
row_count=mysheet.max_row+1#获取横行column的数量。因为循环的时候是“左闭右开”，所以会加上1。
n=1#是指的工作表中第一个横行
for row in range(1,row_count+1):
cell_value = mysheet.cell(row=row, column=1).value
name=cell_value
iList=[]
if name not in nameList2:
for column in range(1,column_count+1):
ivalue=mysheet.cell(row=row,column=column).value
iList.append(ivalue)
for i,item in enumerate(iList):#将列表中的字符串，输入到工作表中的每一行中。
wslost.cell(n,i+1,item)
n+=1
wblost.save("lost.xlsx")即可完成。
读取图片并转化数据 cv2
cv2.imread
以下这段代码可以识别英文命名的图片，而不能识别中文命名的图片。如何解决呢？
import pandas as pd
import cv2
import pytesseract
import os
os.chdir("E:\scoretest")
subList=os.listdir(os.getcwd())
for scoreName in subList:
# 读取PNG图片
image = cv2.imread(scoreName)
# 使用Tesseract OCR库识别图片中的文字
text = pytesseract.image_to_string(image, lang='chi_sim')
# 将识别的文字转换为DataFrame
rows = text.split('\n')
data = []
for row in rows:
if row.strip() == '':
continue
data.append(row.split('\t'))
df = pd.DataFrame(data)
# 将DataFrame保存为Excel
df.to_excel(f'{scoreName}.xlsx', index=False)
cv2.imread("scoreName")方法读取图像，发现imread无法读取中文文件和中文目录，只能识别英文文件和英文目录。
为了解决中文文件目录的问题，可以尝试如下操作：
#要让cv2识别中文命名的文件，可以使用Python的os模块来对文件路径进行编码转换。下面是一段示例代码：
import cv2
import os
def imread_cn(file_path):
# 获取文件的目录和文件名
directory, filename = os.path.split(file_path)
# 将目录进行编码转换
directory = directory.encode('utf-8')
# 将目录和文件名拼接为完整的路径
file_path = os.path.join(directory, filename)
# 使用cv2.imread()方法读取图像
image = cv2.imread(file_path)
return image
# 示例用法
image_path = '中文文件名.jpg'
image = imread_cn(image_path)
在上述代码中，我们首先使用os.path.split()方法获取文件的目录和文件名。然后，将目录进行编码转换，使用encode('utf-8')方法将目录转换为字节字符串。最后，将目录和文件名拼接为完整的路径，并使用cv2.imread()方法读取图像。
将image_path变量替换为中文命名文件的路径，然后运行代码即可。
但是，这样尝试后，发现改动的只是文件夹的名称，对于用中文命名的图片，无济于事。
cv2.imdecode()
进一步思考原因：cv2.imread读到带中文路径图片，会报错。解决方法：先用np.fromfile()读取为np.uint8格式，再使用cv2.imdecode()解码。代码如下：
import pandas as pd
import cv2
import pytesseract
import os
import numpy as np
os.chdir("E:\scoretest")
subList=os.listdir(os.getcwd())#总的eng文件夹
for scoreName in subList:
image = cv2.imdecode(np.fromfile(scoreName, dtype=np.uint8), cv2.IMREAD_COLOR)
# imdecode读取的是rgb，如果后续需要opencv处理的话，需要转换成bgr，转换后图片颜色会变化
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
# 使用Tesseract OCR库识别图片中的文字
text = pytesseract.image_to_string(image, lang='chi_sim')
# 将识别的文字转换为DataFrame
rows = text.split('\n')
data = []
for row in rows:
if row.strip() == '':
continue
data.append(row.split('\t'))
df = pd.DataFrame(data)
# 将DataFrame保存为Excel
df.to_excel(f'{scoreName}.xlsx', index=False)
"E:\scoretest"文件中是jpg和png格式的图片，由上面程序，通过Console平台，可以将图片数据转化为excel数据。
运行代码后，发现大多数图片能够得到处理，但是有几幅图片，红底白字，可能无法识别。所以，需要进一步优化代码。
笔者思考：推测可能是因为字体和图片颜色的问题。cv2读取彩色图片通道顺序为B、G、R，PIL显示图片是R、G、B顺序，因此读出来图片颜色会改变，需要对图像通道进行调序。
询问BingChat，ChatGPT思考后给出几个可能原因：
要进一步优化代码以解决红底白字图片无法识别的问题，可以尝试以下方法：
-
调整图像预处理步骤：在将图像从RGB转换为BGR之前，尝试对图像进行一些预处理操作，例如二值化、灰度化、调整亮度和对比度等。这样可以尝试改变图像的颜色和对比度，以提高文字识别的准确性。
-
调整Tesseract OCR的参数：可以尝试调整OCR的参数，例如语言设置、扫描方向、字符集等。可以查阅Tesseract OCR的文档以了解更多可用的参数选项，并根据具体情况进行调整。
-
使用其他OCR库：除了Tesseract OCR，还有其他OCR库可供选择，例如百度OCR、阿里云OCR等。可以尝试使用其他OCR库来进行文字识别，并比较识别结果的准确性。
-
手动处理无法识别的图片：对于无法通过自动识别的图片，可以手动进行处理。例如，使用图像处理软件对图片进行调整、增强或修改，以提高文字的可读性。然后再使用代码进行文字识别。
优化代码的具体方法和步骤可能因具体情况而异，可以根据实际情况和需求进行尝试和调整。
基于ChatGpt的建议，选择寻找其它图像处理软件。下面是一个很好的网站平台：
诚华OCR - 图片转文字 - 免费在线OCR (109876543210.com)
诚华 OCR 图片 →文件，https://zhcn.109876543210.com/。这个网站平台可以说是上面笔者博客所写代码的“完全加强版”。两者的原理应该一致。当然，软件平台生成后，就可以商业化运营。这是软件市场的常规现象。
登录平台后， 将图片数据转化为表格xlsx数据。
然后，对于自己所编写代码、网站平台都未能清晰识别的图片，则选择用飞书、微信、QQ等的“识别”功能，按照每一列来截取识别。这些APP识别的准确率通常比较高。通常即为截图快捷键。
打包程序pyInstaller
使用
Py
Installer ，
需要注意
以下问题：
·文件路径中不能出现
空格和英文句号（．）；
·源文件必须是
UTF-8
编码，暂不支持
其他编码类型。
采用
IDLE
编写的源文件都保存为
UTF-8 编码形式，可直接使用
相关语句如下
自己写了一个代码w.py，代码如下，实现程序的打包：
pyinstaller -F w.py在如下网站中，生成Logo图形。
生成图标后，写如下代码。
pyinstaller -i w.ico -F w.py通过这些操作后，在运行程序所在的文件夹中，就会生成一些新的文件夹，这些新文件夹中，含有exe文件，点击后，可以直接运行程序。
即可完成。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
