标签：turtle word 函数 python 元素 第二天 print 日记 def
1、for语句--遍历循环
for 循环变量 in 遍历结构：
语句1
else：
语句2
2、while语句--无限循环
while 条件：
语句1
else：
语句2
3、循环保留字
break：跳出最内层for或while循环，跳出该循环后从循环代码后继续执行
for s in "BIT":
for i in range(10):
print(s,end="")
if s == "T":
break
"""
BBBBBBBBBBIIIIIIIIIIT
"""coutinue结束当前当次循环，跳出循环体中下面尚未执行的语句，但是不跳出当前循环
for s in "PYTHON":
if s == "T":
continue
print(s,end="")
"""
PYHON
"""for s in "PYTHON":
if s == "T":
break
print(s,end="")
"""
PY
"""4、random库（伪随机数）
| seed(a=None) | 初始化随机数种子 |
| random() | 生成一个[0,1}的随机小数 |
| randint(a,b) | 生成一个[a,b]之间的整数 |
| getrandits(K) | 生成一个K比特长度的随机整数 |
| randrange() | 生成A和B之间的以X步数的随机整数 |
| uniform() | 生成一个两数之间的随机小数 |
| choice() | 从序列类型中随机返回一个元素 |
| shuffle() | 序列类型中的元素随机排列返回打乱后的序列 |
| sample(pop,k) | 从pop类型中随机选取K个元素 |
5、蒙特卡罗方法求解值
from random import random
from math import sqrt
import time
DARTS = 10000
hits = 0.0
time.perf_counter()
for i in range(1,DARTS+1):
x,y = random(),random()
dist = sqrt(x**2 + y**2)
if dist <= 1.0:
hits = hits +1
pi = 4 * (hits/DARTS)
print("Pi值是{}。".format(pi))
print("运行时间是：{:5.5}s".format(time.perf_counter()))
"""
Pi值是3.158。
运行时间是：0.044677s
"""6、异常处理
try：
语句1
except 异常类型：
语句2
try:
num = eval(input("请输入一个整数："))
print(num **2)
except NameError:
print("输入错误，请输入一个整数！")try：
语句1
except 异常类型1：
语句2
else：
语句3
finally：
语句4
7、函数的定义
函数是具有特定功能的、可重用的语句组，用函数名表示并通过函数名进行功能调用。
使用函数的2个目的：降低编程难度；代码重用
def 函数名 参数：
函数体
return 返回值
def happy():
print("Happy birthday to you!")
def happyB(name):
happy()
happy()
print("Happy birthday,dear{}!".format(name))
happy()
happyB("Mike")
print()
happyB("Lily")
"""
Happy birthday to you!
Happy birthday to you!
Happy birthday,dearMike!
Happy birthday to you!
Happy birthday to you!
Happy birthday to you!
Happy birthday,dearLicy!
Happy birthday to you!
"""8、函数的调用
1）调用程序在调用处暂停执行
2）在调用时将实参复制给函数的形参
3）执行函数体语句
4）函数调用结束给出返回值，程序回到调用前的暂停处继续执行
9、lambda函数
lambda是保留字，该函数定义一个匿名函数，意义是将函数名作为函数结果返回
函数名 = lambda 参数列表：表达式
f = lambda x,y : x + y
type(f)
print(f(10,22))
"""
32
"""10、函数的参数传递
def dup(str,times = 2):
print(str * times)
dup("knock!")
dup("knock!",4)
"""
knock!knock!
knock!knock!knock!knock!
"""参数存在默认值，在定义函数时可以直接为这些参数指定默认值；
函数调用时需要按顺序输入参数，可选参数必须定义在非可选参数的后面；
可以设计可变数量参数，通过在参数前增加星号实现，带有星号的可变参数只能出现在参数列表的最后
def vfunc(a, *b):
print(type(b))
for n in b:
a += n
return a
print(vfunc(1,2,3,4,5)) #1是赋给a的，2、3、4、5是b，b是元组
"""
<class 'tuple'>
15
"""11、函数的返回值
return语句退回函数并将程序返回到函数被调用的位置继续执行
函数也可以没有return语句，此时不返回值
函数可以有多个return返回多个值
12、函数的变量
程序中的变量有2种：全局变量和局部变量
全局变量：函数之外定义的变量
全局变量：函数内部使用的变量，只在函数内有效
n = 1
def func(a,b):
c = a * b
return c
s = func("knock!",2)
print(c)
"""
Traceback (most recent call last):
File "F:\Tools\pythonProject\main.py", line 6, in <module>
print(c)
NameError: name 'c' is not defined
"""n = 1
def func(a,b):
n = b
return a * b
s = func("knock!",2)
print(s,n)
"""
knock!knock! 1
"""global n 可以将n变为全局变量
ls = []
def func(a,b):
ls.append(b)
return a*b
s = func("konck!",2)
print(s,ls)
# konck!konck! [2]注意列表在func函数调用后发生了变化。这是因为列表等组合数据类型由于操作多个数据，所以他们在使用中有创建和引用的分别。
当列表变量被[]赋值时，这个列表才被真实创建，否则之前都是一次引用。
若func函数内部存在一个已经真实创建过且名称为ls的列表，那么func函数将操作该列表且不会修改全局变量
13、datetime库
提供了一系列由简单到复杂的时间处理方法
| datetime.date | 日期表示类 |
| datetime.time | 时间表示类 |
| datetime.datetime | 日期和时间表示类 |
| datetime.timedelta | 与时间间隔有关的类 |
| datetime.tzinfo | 时区有关的信息表示类 |
1）datetime.now() 获取当前时间和事件对象
2）datetime.utcnow() 获取当前日期和时间对应的UTC世界标准时间
3）datetime(year,month,day,hour,minute,second,microsecond) 构造一个日期和时间对象
4）.min 返回最小时间对象
5）.max 返回最大时间对象
6）.year 返回包含的年份
7）.month 返回包含的月份
8）.day 返回包含的日期
9）.hour 返回包含的小时
10）.minute 返回包含的分钟
11） .second 返回包含的秒钟
12） .microsecond 返回包含的微妙钟
13） .isoformat 采用ISO 8601标准显示时间
14）.isoweekday 根据日期计算星期后返回1-7
15）.strftime 根据格式化字符串format进行格式显示的方法
18、strftime()方法
时间格式化最有效的方式
%Y表示年份，%m表示月份，%B表示月名，%b表示月名缩写
%d表示日期，%A表示星期，%a表示星期缩写，%H表示小时
%I表示小时（12小时制） %p表示上午或者下午 %M表示分钟 %S表示秒
strftime方法格式化字符串的数字左侧会自动补零
19、七段数码管绘制
输入：当前日期的数字形式
处理：根据每个数字绘制七段数码管表示
输出：绘制当前的七段数码表示
import turtle,datetime
def drawLine(draw):
turtle.pendown() if draw else turtle.penup()
turtle.fd(40)
turtle.right(90)
def drawDight(d):
drawLine(True) if d in [2,3,4,5,6,8,9] else drawLine(False)
drawLine(True) if d in [0,1,3,4,5,6,7,8,9,] else drawLine(False)
drawLine(True) if d in [0,2,3,5,6,8,9] else drawLine(False)
drawLine(True) if d in [0,2,6,8] else drawLine(False)
turtle.left(90)
drawLine(True) if d in [0,4,5,6,8,9] else drawLine(False)
drawLine(True) if d in [0,2,3,5,6,7,8,9] else drawLine(False)
drawLine(True) if d in [0,1,2,3,4,7,8,9] else drawLine(False)
turtle.left(180)
turtle.penup()
turtle.fd(20)
def drawDate(date):
for i in date:
drawDight(eval(i))
def main():
turtle.setup(800,350,200,200)
turtle.penup()
turtle.fd(-300)
turtle.pensize(5)
drawDate(datetime.datetime.now().strftime('%Y%m%d'))
turtle.hideturtle()
main()20、代码复用和模块化设计
函数封装的直接好处就是代码复用
面向过程是一种以过程描述为主要方法的编程方式
对象是程序的一种高级抽象方式，它将程序代码组织成更高级别的类，对象包括表征对象特征的属性和代表对象操作的方法，即由属性和方法组成。
模块化设计是对程序合理划分功能模块并基于模块设计程序，通常将程序划分为主程序、子程序和子程序间关系
紧耦合：尽可能合理划分功能块，功能块内部耦合紧密
松耦合：模块间关系尽可能简单，功能块之间耦合度低
21、函数递归
函数被函数内部代码调用，即调用函数自身
存在一个或者多个基例，基例不需要再次递归而且它确定的表达式
所有递归链都要以一个或多个基例结尾
# 阶乘
def fact(n):
if n == 0:
return 1
else:
return n * fact(n-1)
num = eval(input("请输入一个整数："))
print(fact(abs(int(num))))#字符串反转
def reverse(s):
return reverse(s[1:]) + s[0]
reverse("ABC")
"""
RecursionError: maximum recursion depth exceeded 超出基例
"""def reverse(s):
if s == "":
return s
else:
return reverse(s[1:]) + s[0]
str = input("请输入一个字符串：")
print(reverse(str))22、绘制科赫曲线
正整数n代表科赫曲线的阶数，表示生成科赫曲线过程的操作次数，科赫曲线的初始化阶阶数是0，表示一个长度为L的直线。对L分为3段，中间1段被边长为L/3的等边三角形的2个边代替，得到1阶科赫曲线，包含4条线段。重复即刻得到n阶科赫曲线。
import turtle
def koch(size,n):
if n== 0:
turtle.fd(size)
else:
for angle in [0,60,-120,60]:
turtle.left(angle)
koch(size/3,n-1)
def main():
turtle.setup(800,400)
turtle.speed(0)
turtle.penup()
turtle.goto(-300,-50)
turtle.pendown()
turtle.pensize(2)
koch(600,3)
turtle.hideturtle()
main()
23、python内置函数
python提供68个内置函数
| all | id | round | compile | locals | abs |
| input | set | dir | map | any | int |
| sorted | exec | menmoryview | asci | len | str |
| enumerate | next | bin | list | tuple | filter |
| object | bool | max | type | format | property |
| chr | min | zip | frozenset | repr | complex |
| oct | getattr | setattr | dict | poen | golbals |
| silce | divmod | ord | bytes | hasattr | eval |
| pow | staticmethod | delattr | help | sum | float |
| bytearray | super | isinstance | issubclass | hash | |
| range | callable | issubclass | vars | hex | reversed |
| classmethod | iter | _import_ |
24、组合数据类型
可以分为3类：
序列类型：一个元素向量，元素之间存在先后关系，通过序号访问，元素间不排他
集合类型：元素集合，元素间无序，相同元素在集合中唯一存在
映射类型：键-值数据项的组合，每个元素都是一个键值对
25、序列类型
一维元素向量，元素间存在先后关系，通过序号访问
有字符串、元组和列表3种
字符串：单一字符的有序组合
元组：包含0个或多个数据项的不可变序列
列表：可以修改数据项的序列
26、序列类型的操作符和函数
| x in s | 若x是s的元素，返回True否则返回False |
| x not in s | 若x不是s的元素，返回True否则返回False |
| s+t | 连接s和t |
| s*n | 将s复制n次 |
| s[i] | 索引返回第i个元素 |
| s[i:j] | 分片，返回第s到j-1个元素 |
| s[i:j:k] | 分片，返回第i到j-1个以k为步的子序列 |
| len(s) | s的元素个数 |
| min(s) | s中最小元素 |
| max(s) | s中最大元素 |
| s.index(x,i,j) | 从j到j中第一次出现x的位置 |
| s.count(x) | 出现x的总次数 |
27、元组
一旦创建就不能修改 用圆括号表示
28、集合类型
包含0个或多个数据项的无序组合，元素不可重复，元素类型只能是固定数据类型
能够进行哈希运算的类型都可以作为集合元素
数据类型 set
聚合没有索引和位置的概念，不能分片，用{}表示
29、集合类型操作符
| S-T 或S.difference | 返回新集合，在S不在T中的元素 |
| S-=T或S.difference_update() | 更新集合，在S不在T中元素 |
| S&T或S.intersection_update() | 返回新集合，同时在S和T的元素 |
| S&=T或S.intersection_update() | 更新集合，同时在S和T的元素 |
| S^T或S.symmetric_difference() | 新集合，集合S和T的元素且不包括同时在两者的元素 |
| S=^T | 更新集合，同上 |
| S|T | 新集合，包含S和T的所有元素 |
| S=|T | 更新集合S 包括集合S和T中所有元素 |
| S<=T | S与T相同或S是T子集返回True否则False |
| S>=T | S与T相同或S是T超集返回True否则Fasle |
30、映射类型
键对值类型，每个元素都是1个键值对，元素无序。
主要是字典类型。
31、列表类型
list列表是包含0个或多个对象引用的有序序列，属于序列类型。
列表十分灵活，支持多种操作符和函数
32、列表类型的操作
| ls[i]=x | 替换第i个元素为x |
| ls[i:j]=lt | 用列表lt替换ls中从i到j-1个元素 |
| ls[i:j:k]=lt | lt替代列表ls中从i到j-1中以k为步数的元素 |
| del | 删除 |
| del[i:j:k] | 删除从i到j-1以k为步的元素 |
| ls+=lt或ls.extend() | 将lt加入ls中 |
| ls*=n | 复制n次ls |
| ls.append | 最后加入元素 |
| ls.clear | 删除所有元素 |
| ls.copy | 生成新列表，复制所有元素 |
| ls.insert(i,x) | 在第i个位置中插入x |
| ls.remove(x) | 第一个元素x删掉 |
| ls.reverse(x) | 元素反转 |
| ls.pop(i) | 将第i个元素取出并删除 |
33、基本统计值计算
输入：从用户输入、文件、网络等途径获得一组数据
处理：适当的数据结构和算法
输出：平均值、标准差和中位数
from math import sqrt
def getNum():
nums = []
iNumStr = input("请输入数字（直接按回车退出）：")
while iNumStr != "":
nums.append(eval(iNumStr))
return nums
def mean(numbers):
s = 0.0
for num in numbers:
s = s + num
return s / len(numbers)
def dev(numbers,mean):
sdev = 0.0
for num in numbers:
sdev = sdev + (num - mean)**2
return sqrt(sdev / (len(numbers)-1))
def median(numbers):
sorted(numbers)
size = len(numbers)
if size % 2 == 0:
med = (numbers[size//2]-1 + numbers[size//2])/2
else:
med = numbers[size//2]
return med
n = getNum()
m = mean(n)
print("平均值：{},方差：{},中位数：{}.".format(m,dev(n,m),median(n)))这个代码在pycharm运行会出现ZeroDivisionError: float division by zero的错误，还在排查原因中
34、字典类型
键对值，见前面介绍，不赘叙。
35、字典类型的操作
| .keys() | 返回所有键 |
| .values() | 返回所有值 |
| .items() | 返回所有键值对 |
| .get() | 键存在返回相应的值，否则返回默认值 |
| .pop() | 键催在则返回相应值，同时删除键值对，否则返回默认值 |
| .popitem() | 随机从字典中取出一个键值对，以元组形式返回 |
| .clear() | 删除所有键值对 |
| del | 删除字典某个键值对 |
| key in d | 键在字典返回True否则False |
36、jieba库
一个第三方中文分词函数库
安装方法：pip install jieba
jieba库支持3种分词模式：
精确模式：将句子最精确分开，最适合文本分析
全模式：把句子中所有可以成词的词语都扫描出来 但是无法消除歧义
搜索引擎模式：在精确模式的基础上对长词再次切分
37、jieba库常用分词函数
| jieba.cut() | 精确模式，返回一个可迭代的数据类型 |
| jieba.cut(s,cut_all=True) | 全模式，输出文本s中所有可能的单词 |
| jieba.cut_for_search(s) | 搜索引擎模式，适合搜索引擎建立索引的分词结果 |
| jieba.lcut(s) | 精确模式，返回1个列表模型 |
| jieba.lcut(s,cut_all=True) | 全模式，返回一个列表模型 |
| jieba_lcut_for_search(s) | 搜索引擎模式，返回一个列表模型 |
| jieba.add_word(w) | 向分词词典中增加新词w |
38、文本词频统计
统计英文版hamlet的最高10组词频
def getText():
txt = open("hamlet.txt","r").read()
txt = txt.lower()
for ch in '!"$%&()*+-,./:;<=>?@[\\]^_`{|}~':
txt = txt.replace(ch,"")
return txt
hamletTxt = getText()
words = hamletTxt.split()
counts = {}
for word in words:
counts[word] = counts.get(word,0) +1
items = list(counts.items())
items.sort(key = lambda x:x[1],reverse=True)
for i in range(10):
word,count = items[i]
print("{0:<10}{1:>5}".format(word,count))
"""
the 1137
and 963
to 736
of 669
you 546
i 540
a 527
my 513
hamlet 459
in 435
"""注意文本要放在pythonproject的文件夹里面才能读取txt。文本已放在我的空间可自取。
39、《三国演义》任务出场次数统计
若出现 'utf-8' codec can't decode byte 0xa1 in position 0: invalid start byte很可能是编码的问题，在保存文本的txt时应当选择utf-8的格式，如图。
同上，需要txt文本在空间自取。
import jieba
txt = open("三国演义.txt","r",encoding='utf-8').read()
words = jieba.lcut(txt)
counts = {}
for word in words:
if len(word) == 1:
continue
else:
counts[word] = counts.get(word,0) +1
items = list(counts.items())
items.sort(key = lambda x:x[1],reverse=True)
for i in range(15):
word,count = items[i]
print("{0:<10}{1:>5}".format(word,count))
"""
Building prefix dict from the default dictionary ...
Dumping model to file cache C:\Users\14375\AppData\Local\Temp\jieba.cache
Loading model cost 0.561 seconds.
Prefix dict has been built successfully.
曹操 953
孔明 836
将军 772
却说 656
玄德 585
关公 510
丞相 491
二人 469
不可 440
荆州 425
玄德曰 390
孔明曰 390
不能 384
如此 378
张飞 358
"""升级版
import jieba
excludes = {"将军","却说","荆州","二人","不可","不能","如此"}
txt = open("三国演义.txt","r",encoding='utf-8').read()
words = jieba.lcut(txt)
counts = {}
for word in words:
if len(word) == 1:
continue
elif word == '诸葛亮' or word == '孔明曰' or word == "诸葛丞相":
rword = "孔明"
elif word == "关公" or word == "云长":
rword = "关羽"
elif word == "玄德" or word == "玄德曰":
rword ="刘备"
elif word == "蒙德" or word == "曹丞相":
rword = "曹操"
else:
rword = word
counts[rword] = counts.get(rword,0) +1
for word in excludes:
del(counts[word])
items = list(counts.items())
items.sort(key = lambda x:x[1],reverse=True)
for i in range(5):
word,count = items[i]
print("{0:<10}{1:>5}".format(word,count))
原本的作者写的代码逻辑漏洞很大，本来他把丞相直接赋给了曹操，实际上诸葛亮也是丞相，因此很难判断丞相到底指的是曹操还是诸葛亮。而且这个代码也不严谨，所以只能当作娱乐程序，大家不要当真。
标签：turtle,word,函数,python,元素,第二天,print,日记,def 来源： https://blog.csdn.net/u014443556/article/details/121645782
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。