Python笔记相关(上)

简介: Python笔记相关

Python


Turtle官方文档


货币兑换

money=input("请输入货币符号($/¥)和金额:")
while 1+1==2:
    if money[0] in ['¥']:
        print("可兑换的美元为:$%.4f"%(eval(money[1:len(money)])*0.1452))
        break
    elif money[0] in ['$']:
        print("可兑换的人民币为:¥%.4f" % (eval(money[1:len(money)])*6.8833))
        break
    else :
        money = input("输入格式有误,例:$100。请重新输入:")

1、input()函数只能返回字符串,所以应用eval()函数将字符串转换为可计算的数值.

2、1+1=2 表示无限循环,只有输入了正确的格式,输出了结果才会跳出循环。否则将一直循环输入语句。

3、关键字 in 表示money[0]是否存在于数组[‘¥’]中,[‘¥’]表示一个数组,不过只有一个元素。

4、%.4f 为格式符,表示输出为保留小数点后4的浮点数。

5、money[0] 索引 索引编号为0的字符,即第一个字符。

6、len()函数获取字符串长度,money[1:len(money)] 表示切片除了第一个字符(索引编号为0)外的所有字符。


Version 1.0

while True:
    money = input("请输入货币符号($/¥)和金额:")
    if money[0] in ['¥']:
        print("可兑换的美元为:$%.4f"%(eval(money[1:len(money)])*0.1452))
        break
    elif money[0] in ['$']:
        print("可兑换的人民币为:¥%.4f" % (eval(money[1:len(money)])*6.8833))
        break
    else :
        print("输入格式有误,例:$100。请重新输入.")


Version 2.0(调用函数)


文件名 curExchange.py

def exchange(money): #定义函数
    while True:
        if money[0] in ['¥']:
            print("可兑换的美元为:$%.4f" % (eval(money[1:len(money)]) * 0.1452))
            break
        elif money[0] in ['$']:
            print("可兑换的人民币为:¥%.4f" % (eval(money[1:len(money)]) * 6.8833))
            break
        else:
            money = input("输入格式有误,例:$100。请重新输入:")
money = input("请输入货币符号($/¥)和金额:")
exchange(money)  #调用函数


Version 3.0(调用模块)


将前一个文件封装为一个模块,创建一个新文件,调用模块。

import curExchange #导入模块 文件名 curExchange.py
m= curExchange.money
if __name__== 'main':  #判断执行的文件是否为当前文件,若是则执行该分支,否者不执行。
    curExchange.exchange(m)  #前有空格


1、 if name== ‘main’: 没有此句将会执行两次打印输出语句,原模块执行一次,调用后执行一次。


等边三角

import turtle as t #导入turtle模块,取别名为 t
t.pencolor("black") #画笔颜色
t.fillcolor("pink") #填充颜色
t.begin_fill() #填充开始
t.forward(200) #长度200像素
t.seth(240) #角度240°
t.forward(200)
t.seth(120)
t.forward(200)
t.end_fill() #填充结束


import turtle as t #导入turtle模块,取别名为 t
t.pencolor("black") #画笔颜色
t.fillcolor("pink") #填充颜色
t.begin_fill() #填充开始
t.seth(-45)
while True:
    t.forward(200)
    t.right(90) #右902度
    if abs(t.pos())<1:  #回到原点结束
        break
t.end_fill() #填充结束


五边形

import turtle as t #导入turtle模块,取别名为 t
t.pencolor("black") #画笔颜色
t.fillcolor("pink") #填充颜色
t.begin_fill() #填充开始
while True:
    t.forward(200)
    t.right(72) 
    if abs(t.pos())<1:  #回到原点结束
        break
t.end_fill() #填充结束


正六边形

import turtle as t #导入turtle模块,取别名为 t
t.pencolor("black") #画笔颜色
t.fillcolor("pink") #填充颜色
t.begin_fill() #填充开始
t.seth(-30)
while True:
    t.forward(100)
    t.right(60)
    if abs(t.pos())<1:  #回到原点结束
        break
t.end_fill() #填充结束


circle()函数

圆形

import turtle as t #导入turtle模块,取别名为 t
t.pencolor("black") #画笔颜色
t.fillcolor("pink") #填充颜色
t.begin_fill() #填充开始
t.circle(100)
t.end_fill() #填充结束

1、circle() 函数的三个参数,

第一个:radius 设置半径,不可省。

第二个:extent 设置弧度,默认为360度,可省

第三个:steps 设置步长,默认为无限次,即一个圆,可用于画正多边形。也可省。

2、所以前面所有的都可以用circle()函数画出


正N边形

import turtle as t #导入turtle模块,取别名为 t
t.pencolor("black") #画笔颜色
t.fillcolor("pink") #填充颜色
t.begin_fill() #填充开始
t.circle(100,None,N) #将N改为数值,则变为正N边形.
t.end_fill() #填充结束
t.exitonclick() #点击才关闭窗口(不自动关闭)

例:t.circle(100,None,3)

结果如图:


数学模块math


先来一口鸡汤

print("如果每天努力一点,那么一年后后的成果将有(1+0.01)^365=%.6f"%(1+0.01)**365)
print("如果每天再努力一点,那么一年后后的成果将达到(1+0.02)^365=%.6f"%(1+0.02)**365)
print("如果每天退步一点,那么一年后后的成果将只有(1-0.01)^365=%.6f"%(1-0.01)**365)

输出结果:

如果每天努力一点,那么一年后后的成果将有(1+0.01)^365=37.783434

如果每天再努力一点,那么一年后后的成果将达到(1+0.02)^365=1377.408292

如果每天退步一点,那么一年后后的成果将只有(1-0.01)^365=0.025518


格式化输出

import math as m
print("圆周率为 {:.20f}".format(m.pi)) #浮点数小数点后20位
a=m.floor(m.pi*10**8)
print(a)
print("以科学计数法显示:{:e}".format(a))
print("千位分隔符显示:{0:,}".format(a))
print("以小数点后两位百分比显示:{:.2%}".format(a))

输出结果:

圆周率为 3.14159265358979311600

314159265

以科学计数法显示:3.141593e+08

千位分隔符显示:314,159,265

千位分隔符显示:31415926500.00%


循环输出图形

for i in range(11): #循环11次
    print("___*",end='')  #不换行

输出结果


九九乘法表

for i in range(1,10):
    for j in range(1,i+1):
        print("%d*%d=%-3d"%(j,i,i*j),end='')
    print('') #换行

输出结果:

1*1=1  
1*2=2  2*2=4  
1*3=3  2*3=6  3*3=9  
1*4=4  2*4=8  3*4=12 4*4=16 
1*5=5  2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6  2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7  2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8  2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 


"百鸡百钱"问题


问:公鸡每只值五文钱,母鸡每只值三文钱,小鸡每三只值一文钱。现在用一百文钱买一百只鸡。问:这一百只鸡中,公鸡、母鸡、小鸡各有多少只?

count=0 #计数
for i in range(20): #公鸡数
    for j in range(33): #母鸡数
        for k in range(300): #小鸡数
            if 5*i+3*j+1/3*k==100 and i+j+k==100 :
                count+=1
                print("第{}种情况:公鸡数为{},母鸡数为{},小鸡数为{}".format(count,i,j,k))
                break

输出结果:

第1种情况:公鸡数为0,母鸡数为25,小鸡数为75

第2种情况:公鸡数为4,母鸡数为18,小鸡数为78

第3种情况:公鸡数为8,母鸡数为11,小鸡数为81

第4种情况:公鸡数为12,母鸡数为4,小鸡数为84

思路:

1、列出方程:设数量分别为i,j,k。

2、根据数量 :i+j+k==100

3、根据总金额: 5i+3j+1/3*k==100

4、循环遍历出所有满足条件的值。

5、可以先粗略判断循环范围:公鸡5钱一只,20只就将满100钱,所以数量必定不超出20;其他类似。


扔骰子游戏(P102.7)

import random
winA = 0 #选手A获胜次数
winB = 0 #选手B获胜次数
win = 0 #平局次数
for i in range(50):
    sumA = 0 
  sumB = 0
    for j in range(10):
        if j % 2 == 0:  #轮流扔
            A = random.randint(1, 6)
            sumA += A #统计5次总和
        else:
            B = random.randint(1, 6)
            sumB += B
    if sumA > sumB:
        winA += 1
    elif sumB > sumA:
        winB += 1
    else:
        win += 1
if winA > winB:
    print("恭喜选手A以{}的胜利次数获胜!".format(winA))
elif winB > winA:
    print("恭喜选手B以{}的胜利次数获胜!".format(winB))
else:
    print("双方平局!")
print("统计:选手A获胜次数为{}次,选手B获胜次数为{}次,平局次数为{}".format(winA, winB, win))


回文素数

输出2-1000内所有的回文素数

for i in range(2, 1001):
    count=0
    for j in range(2, i):
        if i % j != 0:
            count+=1 #计数不能整除的次数
    if count ==(i-2) : #当不能整除的次数为当前数减去2(本身整除一次,整除1一次),便为素数.
        if str(i)[0]==str(i)[-1]: #判断是否回文
            print(i,end=' ')

输出结果

2 3 5 7 11 101 131 151 181 191 313 353 373 383 727 757 787 797 919 929


素数


Version 1.0

for i in range(2, 1001):
    flag=1
    for j in range(2, i):
        if i % j == 0:
            flag=0
            break
    if flag==1:
        print(i,end=' ')

1、设置一个标志flag,判断2到本身之间,是否有数可被整除,有则将flag赋值为0,表示此数可被当前j整除,且不需再进行之后判断,跳出循环。

2、如没有可被整除的数,flag将不会被改变,默认为1,则输出素数i。

Version 2.0

for i in range(2, 1001):
    count=0
    for j in range(2, i):
        if i % j != 0:
            count+=1 #计数不能整除的次数
    if count ==(i-2) : #当不能整除的次数为当前数减去2(本身整除一次,整除1一次),便为素数.
        print(i,end=' ')

1、根据不可被整除的次数判断,是否为素数。


Version 3.0

for i in range(2, 1001):
    count=0
    for j in range(2, i):
        if i % j == 0:
            count+=1 
    if count == 0 : 
        print(i,end=' ')

1、根据可被整除的次数判断,可被整除的次数只有1和本身2次。

2、但是循环遍历范围除去了1和本身,所以应为0次。

3、可在count+=1,后加break退出循环,提高效率。只是count计数的不再是可被整除的次数,而是相当于一个flag(标志)了。


Version 4.0

while True:
    try:
        i = eval(input("请输入一个整数,判断是否为素数:"))
        flag = 1
        for j in range(2, i):
            if i % j == 0:
                flag = 0
                print("%d不是素数" % i)
                break
        if flag == 1:
            print("%d是素数" % i)
        break
    except:
        print("输入有误,请重新输入!")

1、修改功能:输入判断

2、try :except :排除错误的输入情况。


version 5.0

使用列表存储展示

调用函数

动态输入

def shu(ar=100):
    lists = []
    for i in range(2, ar):
        flag = 1
        for j in range(2, i):
            if i % j == 0:
                flag = 0
                break
        if flag == 1:
            lists.append(i)
    print(lists)
c = eval(input("请输入你想得到素数的范围:"))
shu(c)

水仙花数


找出3位数所有的水仙花数

for i in range(100,1000):
    if (i//100%10)**3+(i//10%10)**3+(i%10)**3==i:
        print(i)

1、 i//100%10 表示 百位

2、 i//10%10 表示 十位

3、 i%10 表示 个位

输出结果:

153

370

371

407


销售额提成(P102.10)

m = eval(input("工资查询__请输入您的销售额:"))
salary = 2000
if m <= 3000:
    print("您的工资为%.2f元" % salary)
elif m > 3000 and m <= 7000:
    print("您的工资为%.2f元" % (salary+m*0.1))
elif m > 7000 and m <= 10000:
    print("您的工资为%.2f元" % (salary+m*0.15))
else:
    print("您的工资为%.2f元" % (salary + m * 0.2))

动态时钟

from turtle import *  # 导入turtle模块
from datetime import *  # 导入datetime模块
def skip(step):
    penup()  # 抬起画笔
    forward(step)  # 跳跃的距离step
    pendown()  # 放下画笔
# 刻画时钟刻度
def setup_clock(radius):  # 时钟的大小,即半径radius
    reset()
    pensize(7)  # 画笔粗细
    for i in range(60):  # 刻画时钟刻度
        skip(radius)  # 在距离时钟圆心radius的距离开始落笔
        if i % 5 == 0:  # 每隔4个圆点
            forward(20)  # 刻画一条短线
            skip(-radius - 20)  # 再次回到圆点
        else:  # 刻画点
            dot(5, "pink")  # dot()刻画圆点,参数表示大小和颜色
            skip(-radius)  # 再次回到圆点
        right(6)  # 向右转6度,为什么是6度?60个刻度...360/60=6
def make_hand(name, length):
    reset()
    skip(-0.1 * length)  # 圆点往后退0.1倍length
    begin_poly()
    forward(1.1 * length)  # 再向前1.1倍length,刻画指针圆心前后长度的比例,1:10
    end_poly()
    handForm = get_poly()  # 返回最后记录的多边形
    register_shape(name, handForm)  # 注册形状,命名为name
def init():
    global secHand, minHand, hurHand, printer  # 声明全局变量,使函数内部可修改变量的值
    mode("logo")  # 重置指针的初始方向,向上.
    # 秒针
    secHand = Turtle()  # 建立Turtle对象
    make_hand("secHand", 130)  # 参数:名字和长度
    secHand.shape("secHand")  # 见下面
    # 分针
    minHand = Turtle()
    make_hand("minHand", 125)
    minHand.shape("minHand")
    # 时针
    hurHand = Turtle()
    make_hand("hurHand", 90)
    hurHand.shape("hurHand")
    for hand in secHand, minHand, hurHand:
        hand.shapesize(1, 1, 3)  # 调整指针的粗细
        hand.speed(0)  # 调整指针速度
    # 建立输出文字的打印对象
    printer = Turtle()
    printer.hideturtle()  # 使海龟不可见。 当你绘制复杂图形时这是个好主意,因为隐藏海龟可显着加快绘制速度。
    printer.penup()
# 返回当前的星期
def week(t):
    week = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"]  # 创建一个列表
    return week[t.weekday()]  # t.weekday()返回一个0-6的序列,0为周一,6为周日
# 刻画显示的时间格式
def day(t):
    return "%s %d %d %d:%d" % (t.year, t.month, t.day, t.hour, t.minute)
def tick():
    t = datetime.today()  # 获取当前本地时间
    second = t.second + t.microsecond * 0.000001  # 微秒换算为秒,比例为1:0.000001。
    minute = t.minute + t.second / 60.0  # 当前分钟数,例:当前2分12秒,应换算为2.2分
    hour = t.hour + t.minute / 60  # 同理
    secHand.setheading(second * 6)  # 为指针设置方向
    minHand.setheading(minute * 6)  # 分钟和秒钟刻度一圈都有60个刻度,所以每个度数应为360/60==6度
    hurHand.setheading(hour * 30)  # 而时针的刻度是12个,360/12==30度
    tracer(False)  # 隐藏绘图,直接显示绘画结果
    printer.fd(70)  # 向前移动指定的距离,插入星期显示
    printer.write(week(t), align="center", font=("Courier", 14, "bold"))
    printer.back(130)  # 向后移动指定的距离,插入日期显示
    printer.write(day(t), align="center", font=("Courier", 14, "bold"))
    printer.home()  # 将画笔移动到原点,即坐标(0,0),初始方向与mode()设置的模式不同而不同
    tracer(True)  # 重新打开绘图过程
    ontimer(tick, 100)  # 100毫秒后调用 tick()函数,1秒等于1000毫秒
# 控制逻辑
def main():
    tracer(False)  # 关闭画笔动画
    init()  # 初始化各个对象
    setup_clock(200)  # 画时钟表框
    tracer(True)  # 开启动画
    tick()  # 获取当前本地日期,实时显示
    done()  # 暂停程序,停止画笔绘制,但绘图窗体不关闭,直到用户关闭Python Turtle图形化窗口为止
# 调用函数
main()

所用到的部分函数:

mode()

register_shape()

shape()

_ploy()

reset()

write()

class turtle.Turtle


RawTurtle 的子类,具有相同的接口,但其绘图场所为默认的 Screen 类对象,在首次使用时自动创建。


效果图

随机6位验证码

import random as r
code = []
for i in range(6):  # 6位验证码
    state = r.randint(0, 2)  # 随机大小写字母和数字
    if state == 0:
        code.append(chr(r.randint(48, 57)))  # chr()转换为字符
    elif state == 1:
        code.append(chr(r.randint(65, 90)))
    elif state == 2:
        code.append(chr(r.randint(97, 122)))
s = "".join(code)  # 以""(即空)把字符连接成字符串
print(s)

1、需先定义一个空列表

2、根据随机的state,判断列表是数字、大写字母、小写字母。

3、append() 向列表添加元素

4、chr() 转换为字符 str()转换为字符串 不一样

5、" ".join() 以空连接成字符串


字符串反转


输入一个字符串,将其反转后输出.

例:输入 abcde

输出 edcba

s = input("请输入一个字符串:")
ls = list(s)  #转换为列表
ls.reverse()  #将其反转
sr = ""
for i in range(len(s)): #循环连接成字符串
    sr += ls[i]
print(sr)

或者,换一种连接字符串的方式

s = input("请输入一个字符串:")
ls = list(s)
ls.reverse()
sr = "".join(ls)
print(sr)

join 连接用法实例


利用字符串的函数 join。这个函数接受一个列表或元组,然后用字符串依次连接列表中每一个元素:

注意:列表中含有int类型将报错.

>> list1 = ['P', 'y', 't', 'h', 'o', 'n']
>> "".join(list1)
>> 'Python'
>> tuple1 = ('P', 'y', 't', 'h', 'o', 'n')
>> "".join(tuple1)
>> 'Python'

每个字符之间加 “|”

list1 = ['P', 'y', 't', 'h', 'o', 'n']
"|".join(list1)
'P|y|t|h|o|n

进制转换


输入十进制,输出其二进制,八进制和十六进制


以…算出二进制,或用python内置函数bin()

num = eval(input("请输入一个数字:"))
print("八进制为:%o" % num)
print("十六进制为:%X" % num)
print("转换为二进制为:%s" % bin(num))
print("转换为八进制为:", oct(num))
print("转换为十六进制为:", hex(num))
b = []  # 存储余数
while True:  # 一直循环,商为0时利用break退出循环
    s = num // 2  # 商
    y = num % 2  # 余数
    b = b + [y]  # 每一个余数存储到b中
    if s == 0:
        break  # 余数为0时结束循环
    num = s
b.reverse()  # 使b中的元素反向排列
for i in range(len(b)):  # 将列表中的元素转为字符类型
    b[i] = str(b[i])
print("二进制为:%s" % "".join(b))


Python笔记相关(中):https://developer.aliyun.com/article/1488578

相关文章
|
13天前
|
存储 设计模式 算法
|
13天前
|
Python
小笔记:Python 使用字符串调用函数
小笔记:Python 使用字符串调用函数
45 0
|
13天前
|
JavaScript 前端开发 测试技术
[小笔记]TypeScript/JavaScript模拟Python中的Range函数
[小笔记]TypeScript/JavaScript模拟Python中的Range函数
32 0
|
7天前
|
Python
Python基础 笔记(九) 函数及进阶
Python基础 笔记(九) 函数及进阶
28 6
|
7天前
|
存储 数据库 数据安全/隐私保护
Python基础 笔记(二) 注释、变量及类型的介绍
Python基础 笔记(二) 注释、变量及类型的介绍
26 6
|
7天前
|
Python
Python基础 笔记(十) 文件操作、异常、模块
Python基础 笔记(十) 文件操作、异常、模块
22 3
|
7天前
|
存储 Python 容器
Python 基础 笔记(八) 容器---元组、字典、集合
Python 基础 笔记(八) 容器---元组、字典、集合
19 4
|
7天前
|
存储 索引 Python
Python基础 笔记(七) 容器--字符串、列表
Python基础 笔记(七) 容器--字符串、列表
18 4
|
7天前
|
Python
Python基础 笔记(六) 循环语句
Python基础 笔记(六) 循环语句
24 5
|
7天前
|
Python
Python学习 笔记(五) 判断语句
Python学习 笔记(五) 判断语句
21 3