单行注释：井号#
print('hello world') #单行注释多行注释：三个单引号之间的内容
print('hello') ''' 多行注释 多行注释 '''加注释的快捷键：Ctrl+/
分为两种：从0开始正向递增 和 从-1开始逆向递减
如：TempStr[0]是正数第一个字符
TempStr[-1]是倒数第一个字符
TempStr[0 : -1]表示从第1个字符到倒数第2个字符（不包括倒数第1个）
TempStr[1 ：3]表示从第1个字符到第2个字符（不包括第3个）
中括号[ 元素1，元素2，… ，元素n]
if TempStr[-1] in ['F', 'f']: #TempStr[-1]是倒数第一个字符， #此语句意为：字符串TempStr的最后一个字符是否在列表F和f内"请输入温度值"并没有存入TempStr，只是一个提示，真正存在TempStr中的是键盘输入的字符串123，
即TempStr字符串存的是字符串“123”
print()函数默认换行，它有个参数end=’\n’，只要使end的参数为’’ 或 ‘空格’ 或其他即可
print('hello world',end='') print('!!!') >>>hello world!!! for i in range(5): print(i,end='-') >>>0-1-2-3-4-作用：去掉参数最外层的引号并执行剩下的语句
>>>eval('1') 输出 1 >>>eval('1+2') 输出 3 >>>eval("'1+2'") 输出 '1+2' >>>eval("print('hello world')") #相当于执行print('hello world') 输出 hello world与eval()函数功能相反的函数：str()
单击待debug语句左侧，出现红点。
右击空白区域，选debug
屏幕左上角的坐标为（0,0），turtle绘图窗口左上角坐标为（startx，starty）
turtle.setup（宽度，高度，窗口起始横坐标，窗口起始纵坐标）
turtle.setup(宽度, 高度,startx, starty) #若后两个参数不填，则默认窗口在屏幕中间海龟行进方向默认是向右的！
turtle.goto(横坐标，纵坐标) #海龟向某坐标行进； turtle.fd(d)或 turtle.forward(d) #向海龟头的正前方行进长度为d像素的距离； turtle.bk(d)或 turtle.backward #向海龟头的正后方行进长度为d像素的距离； turtle.circle(r, 角度) #曲线运行，默认以当前海龟头的左侧，r为半径，曲线行进某某角度海龟的头默认是向右的，即海龟行进方向默认是向右的！
turtle.seth（角度） #是使海龟的头转到某一角度，只转动方向，不行进！ turtle.left(角度) #以当前方向为准，向左转某某角度，注意：只转动方向，不行进！ turtle.right(角度) #以当前方向为准，向右转某某角度，注意：只转动方向，不行进！（一笔带过，貌似不重要？？？）
import的三种用法
import 库名 库名.函数名 优点：不会出现函数重名 缺点：繁琐
from 库名 import * 优点：简洁 缺点：可能函数重名
import 库名 as 库别名
turtle.penup 提笔
turtle.pendown 落笔
turtle.pensize（画笔宽度）
turtle.pencolor（“画笔颜色”）或 turtle.pencolor（x,y,z）三个RGB参数
turtle.penup() #提笔 turtle.fd(-250) #海龟倒退250像素 turtle.pendown() #落笔 turtle.pensize(25) #画笔宽度25像素 turtle.pencolor("purple") #画笔颜色为紫色purple海龟行进方向默认是向右的！
turtle.goto(横坐标，纵坐标) #海龟向某坐标行进； turtle.fd(d) #向海龟头的正前方行进长度为d像素的距离； turtle.bk(d) #向海龟头的正后方行进长度为d像素的距离； turtle.circle #曲线运行，默认以当前海龟头的左侧，r为半径，曲线行进某某角度海龟的头默认是向右的，即海龟行进方向默认是向右的！
turtle.seth（角度） #是使海龟的头转到某一角度，只转动方向，不行进！ turtle.left(角度) #以当前方向为准，向左转某某角度，注意：只转动方向，不行进！ turtle.right(角度) #以当前方向为准，向右转某某角度，注意：只转动方向，不行进！range（n）：产生从0到n-1的数
range（n，m）：产生从n到m-1的数
for i in range(4): print(i) """输出： 0 1 2 3 """ for i in range(2,5): print(i) """输出： 2 3 4 """浮点数间运算存在不确定尾数（不属于bug），如0.1+0.2结果为0.3000000xxxxx，并非严格的0.3
round（x， n）表示对x四舍五入，保留小数点后n位
0.1 + 0.2 == 0.3 #False，事实上0.1+0.2结果为0.3000000xxxxx，并非严格的0.3 round(0.1 + 0.2, 1) == 0.3 #True，将相加后的结果保留一位小数，则等于0.3用e或E表示
如 2e3，表示2乘以10^3，结果为2000
4.3e-3 表示4.3乘以10^-3，结果为0.0043
z.real 获取实部
z.imag 获取虚部
指数：用两个星号 **
print(2**3) #答案是2^3=8 #等价于pow(2, 3) print(2^3) #错误写法 print(4, 0.5) #开方，根号4，结果为2abd(x) 取绝对值
divmode(x, y) 同时输出商和余数 如divmode(10, 3) 结果为(3, 1)
pow(x, y, [z]) 求幂，并除以z取余 ，（z可以省略，则不用除以z取余）
t = pow(2, 4, 5) print(t) #结果为1，内部计算过程为：2的四次，等于16, 16再除以5取余，等于1 round(x, [n]) 对x以n位小数四舍五入 t = round(1.584, 1) print(t) #结果为1.6max(X1, X2, … , Xn) 取最大值
min(X1, X2, … , Xn) 取最小值
str = 'Aa,Bb,Cc,Dd,aa' print(str.lower()) #字符全部小写 print(str.upper()) #字符全部大写 print(str.split(",")) #将原字符串以逗号相隔的部分返回成列表 print(str.count ('a')) #返回子串'a'在str中出现的次数 print(str.replace('Aa','Pp')) #将str中'Aa'替换为'Pp',但并没改变原str的值 >>>输出： aa,bb,cc,dd,aa AA,BB,CC,DD,AA ['Aa', 'Bb', 'Cc', 'Dd','aa'] 3 Pp,Bb,Cc,Dd,aa
str.center(宽度，[填充物]) ：
str = 'abc' print(str.center(10, '*')) #总长10，str居中，其他部分由'*'填充 >>> ***abc****str.strip()函数：
str = 'ab123aa456ba' print(str.strip('ab')) #删除字符串首尾的字符a、b，中间的不删 >>>123aa456 str = 'ab123bca' print(str.strip('abc'))#与顺序无关，只要首尾出现a、b、c 就删掉 >>>123str.join()函数：
str1 = 'abc' str2 = "-" print(str2.join(str1)) #在str1的每个字符之间加一个字符串str2, >>>a-b-c str1 = 'abc' str2 = "12" print(str2.join(str1)) #在abc的每个字符之间加一个字符串12 >>>a12b12c可以分类两类：1.填充(单个字符)、对齐、宽度
2. <，> 精度、类型
print("{0:=^10}".format("abcd")) >>> ===abcd=== print("{0:*>10}".format('abcd')) >>> ======abcd print("{0:10}".format("abcd")) >>> abcd print("{0:,.2f}".format(12345.6789)) >>>12,345.68 print("{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425)) >>>110101001,Ʃ,425,651,1a9,1A9 print("{0:e},{0:E},{0:f},{0:%}".format(3.14)) >>>3.140000e+00,3.140000E+00,3.140000,314.000000%time.time() time.ctime() time.gmtime()
import time #输出： print(time.time()) #1593655860.126274 返回浮点数，不常用 print(time.ctime()) #Thu Jul 2 10:11:00 2020 返回字符串 print(time.gmtime())#time.struct_time(tm_year=2020, tm_mon=7, tm_mday=2, tm_hour=2,tm_min=11, tm_sec=0, tm_wday=3, tm_yday=184,tm_isdst=0) #返回计算机内部时间格式strftime()与strptime功能相反！
import time ts = time.gmtime() print(time.strftime('%A %Y-%m-%d %p %H:%M:%S',ts)) >>>Thursday 2020-07-02 AM 03:59:17
import time start = time.perf_counter() for i in range(10): print(i,end='') end = time.perf_counter() print("\n未使用sleep()时所用时间：" + str(end - start) + '秒') print("perf_counter()函数返回值类型为" + str(type(start))) start1 = time.perf_counter() for i in range(10): print(i,end='') #print(待输出数据,end=‘’)表示不换行 time.sleep(3) end1 = time.perf_counter() print("\n使用sleep(3)后所用时间：" + str(end1 - start1) + '秒') >>>0123456789 未使用sleep()时所用时间：0.10264549600000006秒 perf_counter()函数返回值类型为<class 'float'> 0123456789 使用sleep(3)后所用时间：3.097026212秒
紧凑形式：
print("请您猜一个数字：") guess = eval(input()) print("猜{}了".format('对' if guess==99 else '错'))执行顺序：
先执行try 后的语句块1；
若1发生异常，执行except后的语句块2；
若1不发生异常，执行else后的语句块3；
finally后的语句块4是一定会执行的。
print("请输入一个数字：",end='') try: Input = eval(input()) print("{}的平方为{}".format(Input,Input**2)) except: print("输入有误，不是数字") else: print("成功输出了{}的平方".format(Input)) finally: print("结束") >>>请输入一个数字：5 5的平方为25 成功输出了5的平方 结束 >>>请输入一个数字：kk 输入有误，不是数字 结束法一：用eval函数
a1, a2 = eval(input("input two number:")) #输入时用逗号隔开 print(a1) print(a2)法二：用map函数 和 split函数
注意：中间用各种空字符隔开，包括空格、换行(\n)、制表符(\t)等，不能用逗号隔开！
#只用split，则输入类型默认为str a1, a2 = input('输入两个数 a1和a2:').split() ##输入时用空格或回车隔开，不能用逗号 print('a1为' + a1 + '，类型为:'+str(type(a1))) print('a2为' + a2 + '，类型为:'+str(type(a2))) >>> 输入两个数 a1和a2:1 2 a1为1，类型为:<class 'str'> a2为2，类型为:<class 'str'> #引入map，可以改变输入类型 a1,a2 = map(int,input("input two number:").split()) #输入时用空格或回车隔开，不能用逗号 print(a1) #此时a1、b1的类型为int型 print(a2) print(type(a1)) >>> input two number:1 2 1 2 <class 'int'> #若想用逗号隔开，可以改变split()内的参数为split(',') a1,a2 = map(int,input("input two number:").split(‘，’))break：结束当前整个循环，去执行循环之后的语句。注意：只退出一层循环！
continue：跳过次轮循环，去执行下一轮循环，并没有完全退出循环
for c in 'python': if c == 'h': continue #遇到字符'h'，跳过此次循环，继续下一轮循环 print(c,end='') >>>pyton for c in 'python': if c == 'h': break #遇到字符'h'，结束整个循环 print(c,end='') >>>pyt如果循环没有被break结束，就奖励执行else语句。
总共8个函数：
random()的作用：随机生成一个0.0~1.0的小数
为什么要加种子：一旦种子确定，每次生成的随机数就是确定的， 如：种子seed(10)，每次生成的第一个随机数一定是0.57… 故种子有利于代码重现。
import random random.seed(10) for i in range(3): print(random.random()) >>> 0.5714025946899135 0.4288890546751146 0.5780913011344704randint(a, b)： 生成一个[a，b]之间的整数 uniform(a, b))： 生成一个[a，b]之间的小数 randrange(m，n，[k])：生成一个[m，n)之间以k为步长的整数 getrandbits(k)：生成一个k比特(k位)长的整数 注： 1比特(bit)=位；1字节(byte)=8位=8比特 choice(seq)：从序列seq中随机选一个元素 shuffle(seq)：将序列seq中元素随机打乱，无返回值
import random print(random.randint(10, 20)) #随机生成一个10到20的整数 print(random.uniform(10, 20)) #随机生成一个10到20的小数 print(random.randrange(10, 80, 10)) #生成一个[10,80)之间以10为步长的整数 print(random.getrandbits(8)) #生成一个8位(比特)的整数 print(random.choice([1,2,3,4,5,6]))#从序列seq中随机选一个元素 s = [1,2,3,4,5,6,7,8] random.shuffle(s) #因为shuffle函数没有返回值，因此不能直接输出 print(s) >>> 20 12.180292396424115 60 200 6 [8, 4, 3, 7, 5, 2, 6, 1]格式： def 函数名 (参数)： 函数体 return 返回值
可有可无
无参数：
def fact(): print('hello world') fact() #调用函数有参数：
#求n的阶乘n！ def fact(n): result = 1 for i in range(1,n+1): result = result * i return result x = fact(3) print(x)格式： def 函数名（非可选参数，可选参数）
注意：1.非可选参数 必须在 可选参数 之前 2.若可选参数没填，则默认为函数定义时的值； 若可选参数填了，则按调用时的值。
#求n的阶乘，然后除以m 即：n！//m def fact(n, m = 1): #第二个参数是可选的 s = 1 for i in range(1, n+1): s = s * i return s//m print(fact(10)) #第二个参数没填，则按定义时的m=1 print(fact(10, 5)) #第二个参数填了，则按m=5 print(fact(n=10,m=5)) print(fact(m=5,n=10)) #利用参数名来对应 >>> 3628800 725760 725760 725760参数的数量不确定时用可变参数 （略）
返回值可有可无 return可以返回0个值，也可以返回多个值（逗号隔开）
def fact(n, m = 1): s = 1 for i in range(1, n+1): s = s * i return n, m, s//m #返回值有三个 print(fact(10, 5)) #直接输出三个返回值 a,b,c = fact(10, 5) #将三个返回值分别赋值给a，b，c print(a,b,c) #输出a，b，c >>> (10, 5, 725760) #直接输出三个返回值，会以元组形式输出，即 加括号，逗号隔开 10 5 725760
不加global限定词的局部变量：
n, s = 10, 100 def fact(n): s = 1 i = 1 while i <= n: s = s * i i = i + 1 return s print(fact(n), s) >>>3628800 100在函数体内参数前加global限定词，声明为全局变量。
n, s = 10, 100 def fact(n): global s # s成了全局变量 i = 1 while i <= n: s = s * i i = i + 1 return s print(fact(n), s) #fact(n)与s值一样 >>>3628800 3628800若局部变量是组合数据类型，且未在函数内创建，则等同于全局变量。
#ls是组合数据类型，且未在函数内创建，则为全局变量 ls = ['a', 'b'] def func(a): ls.append(a) # append函数是给ls增加一个元素 return func('c') print(ls) >>> ['a', 'b', 'c'] #ls等同于全局变量，所以函数外也加了元素'c' ################################# #ls是组合数据类型，但在函数内又创建，则为局部变量 ls = ['a', 'b'] def func2(a): ls = [] ls.append(a) return func2('c') print(ls) >>> ['a', 'b'] #ls等同于局部变量，所以出了函数，内部的ls被销毁，所以并没有加元素'c'<函数名> = lambda <参数> ：<表达式> f = lambda x , y ： x + y
f = lambda x, y : x + y print(f(1, 2)) >>>3 f1 = lambda : 'hello world' print(f1()) >>>hello world ls = ['a', 'b'] f2 = lambda a : ls.append(a) f2('c') print(ls) >>>['a', 'b', 'c']import turtle import time def drawGap(): #绘制数码管间隔 turtle.penup() turtle.fd(5) def drawLine(draw): #绘制单条线，参数为真则落笔画实线，参数为假则抬笔画虚线 drawGap() if draw: turtle.pendown() else: turtle.penup() turtle.fd(40) #每一条线，长度为40像素 drawGap() turtle.right(90) #画完每一笔后，都将海龟头右转90度 def drawDigit(Digit): #绘制一个数字Digit，分了七步，每步画一条线 if Digit in [2,3,4,5,6,8,9]: #第一条线，如果数字是[2,3,4,5,6,8,9],则画实线，否则画虚线 drawLine(True) #以下的从第二条线开始，用了if...else的紧凑形式，功能是一样的 else: drawLine(False) drawLine(True) if Digit in [0,3,4,5,6,7,8,9] else drawLine(False) #if...else的紧凑形式 drawLine(True) if Digit in [0,2,3,5,6,8] else drawLine(False) drawLine(True) if Digit in [0,1,2,6,8] else drawLine(False) turtle.left(90) drawLine(True) if Digit in [0,1,4,5,6,8,9] else drawLine(False) drawLine(True) if Digit in [0,2,3,5,6,7,8,9] else drawLine(False) drawLine(True) if Digit in [0,2,3,4,7,8,9] else drawLine(False) turtle.left(180) #画完最后一条线后，海龟头左转180度，即 准备下一个数字的绘制 turtle.penup() #抬笔，向前（实际是向右）移动20像素，准备画下一个数字 turtle.fd(20) def drawDate(date): #画一个完整的时间，其中参数为时间字符串,格式为'%Y-%m=%d+', #则遇到'-'绘制汉字'年'，遇到'='绘制汉字'月'，遇到'+'绘制汉字'日' for i in date: if i == '-': turtle.write('年', font=('Arial', 18, 'normal')) turtle.fd(40) elif i == '=': turtle.write('月', font=('Arial', 18, 'normal')) turtle.fd(40) elif i == '+': turtle.write('日', font=('Arial', 18, 'normal')) else: drawDigit(eval(i)) #用eval将时间字符串的每个字符转化成整型，才能作为drawDigit的参数 def main(): #主函数 turtle.hideturtle() #隐藏画笔形状 turtle.setup(800, 350, 200, 200) turtle.penup() turtle.fd(-300) turtle.pensize(5) t = time.gmtime() #获取时间，格式为计算机内部时间格式 ts = time.strftime('%Y-%m=%d+', t) #利用strftime函数，进行格式化，使时间格式为‘%Y-%m=%d+’ drawDate(ts) turtle.done() main()
可以将 *.py 文件转化为可执行文件 *.exe
用大括号表示，逗号隔开，集合元素是唯一、不重复的，且没有先后顺序。
A = {1, 2, '12', (1, 2, '12')} print(A) >>>{1, 2, '12', (1, 2, '12')} B = set('1233') # set函数新建一个集合，参数是字符串，返回该字符串拆开的单个字符组成的字符串,并去掉重复元素 print(B) >>>{'1', '2', '3'} C = {'python', 123, 'python', 123} print(C) >>>{123, 'python'} #自动去掉重复的元素
遍历集合函数：
def trave1(A): for item in A: print(item, end=',') def trave2(A): try: while True: print(A.pop(), end=',') #pop函数，返回集合中的一个元素并将其删除，当集合为空时报错，转向执行except语句 except: pass #pass是一条空语句，但此处不加pass还不行. A = {1, 2, '12', (1, 2, '12')} trave1(A) trave2(A) >>>12,1,2,(1, 2, '12'), >>>12,1,2,(1, 2, '12'),利用了集合中无重复元素的特点
ls = ["1", "2","1", "A", "A", "B"]#列表ls有重复元素 print(ls) s = set(ls) #用set函数将列表转化成集合，则自动去除了重复元素 print(s) ls = list(s)#再将集合转化成列表 print(ls) >>> ['1', '2', '1', 'A', 'A', 'B'] {'1', '2', 'B', 'A'} ['1', '2', 'B', 'A']序列类型扩展出：字符串类型、元组类型、列表类型 序列类型的操作符：
序列类型的函数：
s = "python123.io" print(max(s)) >>> y #字母之间的大小是通过字母序比较的，y是此字符串中最大的类似于C语言的数组，用方括号和逗号[a0, a1, …, an]
ls = ["cat", "dog", "tiger"] print(ls) ls1 = ls #并不是重新定义一个列表，而是同一个列表，有两个名字 print(ls1)
d = {1:"LL", "age":25} print(d[1]) print(d.keys()) print(d.values()) print(d.items()) LL dict_keys([1, 'age']) dict_values(['LL', 25]) dict_items([(1, 'LL'), ('age', 25)])
