高同学上课笔记

最新推荐文章于 2024-04-18 16:40:17 发布

HTmonster

最新推荐文章于 2024-04-18 16:40:17 发布

阅读量661

点赞数

分类专栏： python教学

本文链接：https://blog.csdn.net/weixin_38371073/article/details/104130207

版权

python教学专栏收录该内容

9 篇文章 1 订阅

订阅专栏

知识点简洁版

在这里插入图片描述

第一课

1.引入库

import turtle as t #引入 工具名 as 别名

2. turtle库常见操作

#笔操作 
turtle.penup() #抬起画笔，之后移动画笔不绘制形状
turtle.pendown() #落下画笔，之后移动画笔绘制形状

#笔走向
turtle.forward(distance) #画笔向前移动distance距离
turtle.backforward(distance) #画笔向后移动distance距离
turtle.right(degree) #绘制方向向右旋转degree度
turtle.left(degree) #绘制方向向左旋转degree度
turtle.circle(radius,degree) #画弧度（圆） 参数：半径 角度

# 画笔设置
turtle.pensize() #设置画笔宽度
turtle.pencolor() #设置画笔颜色，常用颜色{white,black,grey,dark,green,gold,violet,purple}

#转移
turtle.goto()#转移坐标

#完成工作
turtle.done()

##填充颜色
turtle.fillcolor() #设置填充的颜色 ‘red’ ‘green’ 'yellow’等
turtle.begin_fill() #开始填充的起点
turtle.end_fill() #结束填充点

3. 画直线

import turtle as t# 拿出画图工具
t.pendown()# 1.笔尖向下
t.forward(100)# 2.向前移动 距离
t.penup()# 3.笔尖抬起

t.done()# 完成工作

第二节课

改进：使用循环来画多边形


import turtle as t # 引入 库

t.pendown()

n=7  #边数

for j in range(n):
    t.forward(50)
    t.left(360/n)

t.penup()

t.done()

第三节课

计算机交互

0.输入

获取到的数据是字符串类型转化为整数 int()

x = input("提示信息")
# x 包存获取到的东西
# 提示信息  引号

1.输出

print(x)
# 括号里面是要输出的内容

第四节课

变量类型

数字 1 22 34.5
字符串 “abc" "1”

条件判断


age=int(input("请输入你的年龄："))

if age>=18:
    print("可以开车")
else:
    print("不可以开车")

阅卷老师程序

方法1：循环的嵌套

score=int(input("请输入你的成绩："))
if score>=90:
    print("A")
else:
    # >90
    if score>=80:
        #80-90
        print("B")
    else:
        if score>=60:
            print("C")
        else:
            print("D")

方法2： if单独范围判断

score = int(input("请输入成绩："))


if 100>=score>=90:
    print("A")
if 90>score>=80:
    print("B")
if 80>score>=60:
    print("C")
if 60>score>=0:
    print("D")

方法3： if-elif-else

score = int(input("请输入成绩："))

if 100>=score>=90:
    print("A")
elif score>=80:
    print("B")
elif score>=60:
    print("C")
else:
    print("D")

常量布尔值

True  #真
False #假

比较符

比较符	含义
<	小于
<=	小于等于
>	大于
>=	大于等于
==	等于
!=	不等于

逻辑组合

关键词	意义
and	与
or	或
not	非

if画平行线

import turtle


for j in range(4):
    if j==1 or j==3:
        turtle.penup()
    else:
        turtle.pendown()
    turtle.forward(100)
    turtle.left(90)

turtle.done()

第五节课

条件判断语法总结

1. if

2. if-else

3. if-elif-elif-else

第六节课

for 循环

逐一的从序列里取出数据循环赋值给变量

语法格式

for 变量  in  序列：
	循环的内容

序列
- range()
- 列表
- 字符串

range函数

生成序列

语法格式

range(start,end,step)

# start: 开始（包括）
# end:  结束（不包括）
# step: 间隔

# 只有一个参数时候 默认0开始

例子

print(range(4))  # range(4)= range(0,4)
print(list(range(0,4)))   # range(0,4) => [0,1,2,3]
print(list(range(3,8)))   # range(3,5) => [3.4.5.6.7]
print(list(range(0,6,2))) # range(0,6,2) => [0,2,4]
print(list(range(0,6,3))) # range(0,6,3) => [0,3]

课后习题

import turtle as t

t.pendown()

t.hideturtle() # 隐藏箭头
t.speed(10)    # 画画的速度

for j in range(3,11):
    t.fillcolor(j/10,0,0)
    t.begin_fill()
    for i in range(4): # ！
        t.forward(100)
        t.left(90) # ！
    t.end_fill()

t.penup()
t.done()

第七课

总结：流程控制语句

1. 顺序语句

默认情况从上到下

2. 分支语句

if 语句

第四五课

3. 循环语句

for 循环

第六节课

while 循环

break 语句与continue语句

break语句：跳出循环剩下的不执行
continue语句：重新开始循环剩下的不执行

对比	break	continue
区别	跳出循环	不跳出
共同点	剩下的都不执行	=

生成随机数

import random
num=random.randint(0,100)# 随机生成0-100之间的随机整数

猜大小游戏

# 生成一个随机被猜的数 num

# 循环3次
	# 获取用户的输入  guessnum  注意类型的变换 input() int()
	
	# 进行对比
	# 1. 如果猜对  注意退出 （break)
	# 2. 大了
	# 3. 小了

第八课 while循环

一种循环满足条件循环不满足条件下退出循环

语法格式

while 条件:
	循环的内容

例子

while True:
    str=input("请说我很菜：")
    if str == "我很菜":
        break
while input("请说我很菜：")!="我很菜":
	print("还不承认 ")

对比

	for	while
区别	循环次数已知	循环次数未知侧重于条件的判断
共同点	都是循环都可以用break与continue语句	=

第九节课

字符串


str1='我是单引号 '
str2="我是双引号"
str3='''
我是三引号
            我的格式不会变
                                不信你看看          
'''
print(str1)
print(str2)
print(str3)

# in操作 看字符在不在字符串里面
print("是" in str1)

# +号进行 字符串拼接
print(str1+str2)

# *号进行 字符串的复制
print(str1*3)

# len() 查看字符串的长度
print(len(str2))

格式化字符串

1. %号操作符

print("%d * %d = %d "%(i,j,i*j))

操作符	类型
%d	整数
%s	字符串
%u	无符号整数（自然数）
%f	浮点数（小数）

2. format()函数

print("{} * {} = {} ".format(i,j,i*j),end="")

print函数不换行

print("",end=""）

对比

	%操作符	format()函数
占位符	%d %s %e	{}
分配	%()	.format()

打印九九乘法表

for i in range(1,10):
    for j in range(1,i+1):
        print("",end="") #不换行 这里写格式化字符串 i*j=(i*j)
    print()# 换行

列表

定义

[ 中括号包围
，逗号分隔

查看列表的信息

通过序号
序号从 0开始

列表增加

append()函数添加在末尾
insert() 函数指定插入的位置

列表删除

remove()函数

列表修改

通过序号然后重新赋值

例子


# 列表的定义 [ ]  ,
fruits=['apple','banana','pear']


# 查看列
# 长度
print(len(fruits))
#print(fruit[0])


# 列表增加
#fruits.append('watermelon')
#fruits.insert(2,'watermelon')
# 列表修改
#fruits[0]='watwermelon'

# 列表删除
fruits.remove(fruit[0])

print(fruits)

列表的高级操作

排序默认升序

sort()

排序降序

sort(reverse=True)

列表反转

reverse()

查看元素的序号

index()

统计元素的个数

count()

例子

h=[155,167,178,165,166,165,165,171]

# 排序 默认升序
# h.sort()
#
# # 排序 降序
# h.sort(reverse=True)

# 列表反转
# h.reverse()

# 查看元素的序号
print(h.index(178))

# 统计元素的个数
print(h.count(165))

元组

tuple

	元组	列表
定义	(, )	[ , ]
append()	不支持	支持
remove()	不支持	支持
修改	不支持	支持
下标查看	支持	支持
len()	支持	支持
切片	支持	支持

元组和列表很类似
但是元组只可查看不可修改
列表->元组 tuple()
元组-> 列表 list()

第十课

字典

dict

定义

{} 包围
元素用 , 分隔
元素 key:value

修改

通过键进行修改

增加

通过键进行增加

删除

删除单独元素 del dict[xxx]
清空 dict.clear()
删除整个 del dict


# 字典的定义
luna = {
    "name":"luna", # key : value
    "gender":"woman",
    "job":"fashi",
    "place":"daye",
    "zhandouli":2000
}

print(type(luna))

# 访问  通过 key
print(luna["job"])
print(luna.get("a"))

# 修改  通过 key
luna["job"]="zhanshi"

print(luna["job"])

# 增加
luna["defence"]=200

print(luna)

# 删除
# 删除一个条目
del luna["job"]

# 删除所有条目
luna.clear()

print(luna)

# 直接删除整个
del luna

print(luna)

键的要求

只能出现一次，出现多次按照最后的为准
不能改变，只能用数字，字符串，元组不能用列表

字典的常用函数

dict.get(key) 范围字典key对应的值，不存在则返回None
dict.setdefault(key) 范围字典key对应的值，不存在则返回None并添加到字典里
dict.keys() 返回所有的key
dict.value() 返回所有的value
dict.items() 以元祖列表的形式返回 Key与Value

随机选择

import random
key=random.choice(list(dict.keys()))# 随机选择一个key（英文）

中级思维导图

函数

函数定义

必需
- def
- 函数名
- 函数主体
非必需
- 参数
- return 返回值


def  函数名字（参数[默认参数]):
		# 函数的主体
		return  返回值

函数使用

与函数定义在同一文件

函数名字（参数） #没有返回值
x = 函数名字（参数）# 有返回值

不同文件

import 函数定义所在文件

文件名.函数名（参数）

例子

# 定义函数  画多边形  参数 边数与边长
def polygon(n,d):
    import turtle
    turtle.pendown()

    for i in range(n):
        turtle.forward(d)
        turtle.left(360 / n)

    turtle.penup()
    turtle.done()

# 本文件使用
polygon(7,100)

默认参数

在函数定义的时候指定一个默认值
调用函数时候可以不指定自动的使用默认值


def guessGame(start=0,end=100):
    import random
    num=random.randint(start,end)
    while True:
        user_guss=int(input("请输入数字:"))
        if num==user_guss:
            print("恭喜")
            break
        elif user_guss>num:
            print("太大了")
        else:
            print("太小了")


guessGame() # 使用默认参数
guessGame(start=-100,end=100) #自己指定参数

递归

汉诺塔游戏


def hanoi(n,x,y,z):
    '''
     汉诺塔

    :param n: 盘子数
    :param x: from 柱
    :param y: by 柱
    :param z: to 柱
    '''

    if n ==1:
        print(x,"-->",z)
    else:
        hanoi(n-1,x,z,y)
        print(x,"-->",z)
        hanoi(n-1,y,x,z)

hanoi(4,'a','b','c')

阶乘

def fact(n):
    if n==1:
        return 1
    else:
        return fact(n-1)*n
 
 print(fact(3))  # 6

0.背景资料

0.1 pygame模块

模块名	功能
pygame.cdrom	访问光驱
pygame.cursors	加载光标
pygame.display	访问设备显示
pygame.draw	绘制形状、线和点
pygame.event	管理事件
pygame.font	使用字体
pygame.image	加载和存储图片
pygame.joystick	使用手柄或类似的东西
pygame.key	读取键盘按键
pygame.mixer	声音
pygame.mouse	鼠标
pygame.movie	播放视频
pygame.music	播放音频
pygame.overlay	访问高级视频叠加
pygame.rect	管理矩形区域
pygame.sndarray	操作声音数据
pygame.sprite	操作移动图像
pygame.surface	管理图像和屏幕
pygame.surfarray	管理点阵图像数据
pygame.time	管理时间和帧信息
pygame.transform	缩放和移动图像

键盘事件

https://cloud.tencent.com/developer/article/1490216

可参考文章：
https://zhuanlan.zhihu.com/p/54139946
https://blog.csdn.net/zha6476003/article/details/82940350
https://blog.csdn.net/qq_40801709/article/details/88603430

小球游戏框架

import pygame

pygame.init()
screen = pygame.display.set_mode((600, 500))
pygame.display.set_caption(“BALL”)

ball_x = 0
ball_y = 100
while True：
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
    screen.fill((0,0,0))
    pygame.draw.circle(screen, (100, 40, 30), (ball_x, ball_y), 30, 0)
    ball_x += 1
	pygame.display.update()

游戏布局

import pygame

def print_text(scr,font,text,color,pos):
    ''' 输出字体'''
    imgtext = font.render(text, True,color)
    scr.blit(imgtext,pos)


if __name__ == '__main__':
    pygame.init()
    screen=pygame.display.set_mode((600,500))
    pygame.display.set_caption("BALL")

    # 字体类型
    font=pygame.font.Font(None,44)
    
    # 球的坐标
    ball_x=200
    ball_y=100

    # 矩形的坐标
    rect_x=20
    rect_y=400

    # 矩形的长宽
    rect_w=200
    rect_h=20
    while True:
        for event in pygame.event.get():
            if event.type==pygame.QUIT:
                pygame.quit()

        screen.fill((255, 255, 255))

        # # 字体渲染为图像  参数： 内容 抗锯齿，颜色
        # imgtext=font.render("life: 3",True,(0,0,0))
        # imgtext2=font.render("score:10",True,(0,0,0))
        # # 放在屏幕上
        # screen.blit(imgtext,(0,0))
        # screen.blit(imgtext2,(400,0))

        print_text(screen,font,"life: 3",(0,0,0),(0,0))
        print_text(screen,font,"score:10",(0,0,0),(400,0))

        pygame.draw.circle(screen,(200,100,30),(ball_x,ball_y),20,0)
        pygame.draw.rect(screen,(0,0,0),(rect_x,rect_y,rect_w,rect_h),0)

        pygame.display.update()

小球与板运动

import pygame,random


def print_text(scr, font, text, color, pos):
    ''' 输出字体'''
    imgtext = font.render(text, True, color)
    scr.blit(imgtext, pos)


if __name__ == '__main__':

    scr_w,scr_h=600,800

    pygame.init()
    screen = pygame.display.set_mode((scr_w,scr_h))
    pygame.display.set_caption("BALL")

    # 字体类型
    font = pygame.font.Font(None, 44)

    # 球的坐标
    ball_x = 200
    ball_y = 100

    ball_v=1

    # 矩形的坐标
    rect_x = 20
    rect_y = 700

    # 矩形的长宽
    rect_w = 200
    rect_h = 20
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
            # 板运动
            if event.type == pygame.MOUSEMOTION:
               rect_x,_ = event.pos

        screen.fill((255, 255, 255))

        print_text(screen, font, "life: 3", (0, 0, 0), (0, 0))
        print_text(screen, font, "score:10", (0, 0, 0), (400, 0))

        pygame.draw.circle(screen, (200, 100, 30), (ball_x, ball_y), 20, 0)
        pygame.draw.rect(screen, (0, 0, 0), (rect_x, rect_y, rect_w, rect_h), 0)

        # 小球运动
        if ball_y >= scr_h:
            ball_y=0
            ball_x=random.randint(0,scr_w)
        ball_y=ball_y+ball_v

        # 得分判断
        if ball_y == rect_y:
            if rect_x+rect_w>ball_x>rect_x:
                ball_y = 0
                ball_x = random.randint(0, scr_w)

        pygame.display.update()

开始与结束页面

import pygame,random


def print_text(scr, font, text, color, pos):
    ''' 输出字体'''
    imgtext = font.render(text, True, color)
    scr.blit(imgtext, pos)


if __name__ == '__main__':

    scr_w,scr_h=600,800

    pygame.init()
    screen = pygame.display.set_mode((scr_w,scr_h))
    pygame.display.set_caption("BALL")

    # 字体类型
    font = pygame.font.Font(None, 44)
    #
    font2 = pygame.font.Font(None,60)

    # 球的坐标
    ball_x = 200
    ball_y = 100

    ball_v=1

    # 矩形的坐标
    rect_x = 20
    rect_y = 700

    # 矩形的长宽
    rect_w = 200
    rect_h = 20

    #
    score=0
    life=-1 #

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
            # 板运动  鼠标方法
            # if event.type == pygame.MOUSEMOTION:
            #    event.pos 返回 x,y
            #    rect_x,_ = event.pos
            # 事件类型：键盘按下
            if event.type == pygame.KEYDOWN:

                # r s  重新开始游戏
                if event.key == pygame.K_r or event.key == pygame.K_s:
                    life, score = 3, 0
                # e  退出
                elif event.key == pygame.K_e:
                    pygame.quit()
                # 右箭头
                elif event.key == pygame.K_RIGHT:
                    rect_x+=30
                # 左箭头
                elif event.key == pygame.K_LEFT:
                    rect_x-=30


        screen.fill((255, 255, 255))

        if life==-1:
            print_text(screen,font,"BALL GAME",(0,0,0),(200,200))
            print_text(screen,font,"start:s",(0,0,0),(220,400))
        elif life==0:
            print_text(screen,font,"Your score: {}".format(score),(0,0,0),(200,200))
            print_text(screen,font,"Restart: r End:e",(0,0,0),(150,400))
        else:
            print_text(screen, font, "life: {}".format(life), (0, 0, 0), (0, 0))
            print_text(screen, font, "score:{}".format(score), (0, 0, 0), (400, 0))

            pygame.draw.circle(screen, (200, 100, 30), (ball_x, ball_y), 20, 0)
            pygame.draw.rect(screen, (0, 0, 0), (rect_x, rect_y, rect_w, rect_h), 0)
            # 小球运动
            if ball_y >= scr_h:
                ball_y=0
                ball_x=random.randint(0,scr_w)
            ball_y=ball_y+ball_v

            # 得分判断
            if ball_y == rect_y:
                if rect_x+rect_w>ball_x>rect_x:
                    ball_y = 0
                    ball_x = random.randint(0, scr_w)
                    score+=1 #score=score+1
                else:
                    life-=1

        pygame.display.update()

python标准库

OS库

import os

for path in os.listdir(".\dir1"):
    c_path=os.path.join(".\dir1",path)
    if os.path.isfile(c_path):
        print(os.path.abspath(c_path))

文件操作

读取文件

f.read() 读取全部
f.readline() 读取一行
f.readlines() 读取多行返回列表一行一个元素

写文件

标志

a 追加写
w 覆盖

写方式

f.write() 写入一个东西
f.writelines() 写入一个列表/元组写入多个内容

安全读写方式

# 安全的方法
with open("yrf.txt","w") as f:
    f.write("awsl\n")
    f.writelines(["xswl\n", "kswl\n", "mmp"])

with open("test.txt","r",encoding="utf-8") as f1,open("yrf.txt", "w") as f2:
    d=f1.read()
    f2.write(d)

import shutil

shutil.copyfile("test.txt","test2.txt")

time库

参考教程

import time
# 返回 时间戳 秒  当前的时间距离1970年1月0日0分0秒的秒数
print(time.time())

# 返回 时间元组  默认是当前时间
print(time.localtime())
print(time.localtime(2000000000))

# 将时间元组（默认当前时间）  转化为 固定时间格式字符串
print(time.asctime())  #Wed Mar 18 19:11:38 2020
print(time.asctime(time.localtime(2000000000))) #Wed May 18 11:33:20 2033

# 将时间戳（默认当前时间）  转化为 固定时间格式字符串
print(time.ctime())  #Wed Mar 18 19:11:38 2020
print(time.ctime(2000000000)) #Wed May 18 11:33:20 2033

# 将时间元组（默认当前时间）  转化为 自定义时间格式字符串
print(time.strftime("%Y-%m-%d %H:%M:%S")) # 2020-03-18 19:20:41
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime(2000000000))) #

# 自定义时间格式字符串 转化为  将时间元组
print(time.strptime("2020-03-18 19:20:41","%Y-%m-%d %H:%M:%S"))

在这里插入图片描述

calendar库

import calendar

# 返回一年的年历
print(calendar.calendar(2020))

# 返回一个月的月历
print(calendar.month(2020,3))

# 返回一个月的月历  通过列表的方式
print(calendar.monthcalendar(2020,3))

# 判断是不是闰年
print(calendar.isleap(2020))

# 返回日期的星期数
print(calendar.weekday(2020,3,18))

datetime库

类

date类日期
time类时间
datetime 日期+时间
timedelta 时间差

方法	方法说明	用法
eq(…)	等于(x==y)	x.eq(y)
ge(…)	大于等于(x>=y)	x.ge(y)
gt(…)	大于(x>y)	x.gt(y)
le(…)	小于等于(x<=y)	x.le(y)
lt(…)	小于(x<y)	x.lt(y)
ne(…)	不等于(x!=y)	x.ne(y)

返回值为True\False

import datetime

date_a=datetime.date(2020,1,1)
date_b=datetime.date.today()# 返回一个今天的date类

print(type(date_b)) #<class 'datetime.date'>

# 1. 日期比较
print(date_b.__eq__(date_a)) # False
print(date_b.__gt__(date_a)) # True

# 2. 时间差
print(date_b.__sub__(date_a)) #81 days, 0:00:00
print(date_b.__rsub__(date_a)) #-81 days, 0:00:00

# 3.ISO标准
print(date_a.isocalendar()) #输出元祖 (2020, 1, 3)
print(date_a.isoformat())   #2020-01-01

# 4.输出字符串
print(date_a.__format__("%Y=%m=%d")) #2020=01=01
print(date_a.__str__())              #2020-01-01
print(date_a.ctime())                #Wed Jan  1 00:00:00 2020


#
now=datetime.datetime.now()

print(now.date()) #拆成date类  2020-03-22
print(now.time()) #拆成time类  19:24:52.398586

print(datetime.datetime.combine(now.date(),now.time())) #合并成datetime类 2020-03-22 19:26:52.827282

# timedelta
birth_day=datetime.date(598,1,28)
dead_day=datetime.date(649,7,10)

# 活了多少天
print(type(dead_day.__sub__(birth_day))) #<class 'datetime.timedelta'>
print(dead_day.__sub__(birth_day)) #18790 days, 0:00:00
print(dead_day.__sub__(birth_day).days) #18790

print(dead_day-birth_day)#18790 days, 0:00:00

#时间差类
time_delta=datetime.timedelta(days=8,hours=8,minutes=8,seconds=8)

# 八天八个小时八分八秒后的日期
print(now+time_delta) #2020-03-31 03:43:57.750139

面向对象编程


class student():
    # =============属性 =============
    # 使用变量来描述
    name=None
    score_h=None
    score_m=None

    #==============方法===============
    # 第一个参数必须是self

    # 必备  实例化的时候使用 对象实例化的时候会自动调用
    def __init__(self,name,score_h,score_m):
        self.name=name
        self.score_h=score_h
        self.score_m=score_m

    #其他
    def set_score_h(self,score):
        '''更新历史成绩'''
        self.score_h=score

    def set_score_m(self,score):
        '''更新数学成绩'''
        self.score_m=score

    def printsocre(self):
        print("{} 的 历史成绩{}  数学成绩{}".format(self.name,self.score_h,self.score_m))

if __name__ == '__main__':

    zhangsang = student("张三",90,98)

    zhangsang.printsocre()
    zhangsang.set_score_h(45)
    zhangsang.printsocre()

对象继承



# 父类
class person():
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def eat(self):
        print("eating...")

# 子类
class student(person):
    # 子类会继承父类的所有属性与方法
    def __init__(self,name,age,score):
        # 先初始化父类的属性
        super(student,self).__init__(name,age)
        # 再初始化子类的属性
        self.score=score

    # 定义子类的动作
    def tell(self):
        print("score:{}".format(self.score))

if __name__ == '__main__':
    zhans = student("张三",18,99)
    zhans.tell() # 子类的方法
    zhans.eat() # 父类的方法

类的重载


class Animal():
    # 父类 动物
    def run(self):
        # 所有动物都会动  但是各自动的方式不一样
        print("Animal is running...")

class Dog(Animal):

    def run(self):
        # 子类需要根据实际情况 改变一下
        print("Dog is running...")

if __name__ == '__main__':
    xiaohuan=Dog()

    xiaohuan.run()

类的多态

实例化后的对象可以作为参数传入函数中
基于重载
这样不同类别的对象做相同的动作结果可能不一样


class Animal:
    # 如果类不继承可以不加括号
    # 父类 动物
    def run(self):
        # 所有动物都会动  但是各自动的方式不一样
        print("Animal is running...")

class Dog(Animal):

    def run(self):
        # 子类需要根据实际情况 改变一下
        print("Dog is running...")

def moving(cls):
    # 不属于任何类 独立的一个函数
    # 是对21-22行的内容总结
    cls.run()

if __name__ == '__main__':
    # Animal().run()
    # Dog().run()
    # 类的实例化 =》将虚拟的东西变成实际的东西
    moving(Dog())

班级

from 定义的文件名 import student,teacher
import random

class Class:
    name=None
    teachers=[]
    students=[]

    def __init__(self,name):
        self.name=name

    def addStudent(self,student):
        self.students.append(student)

    def addTeacher(self,teacher):
        self.teachers.append(teacher)

    def haveAClass(self):
        teacher=random.choice(self.teachers)

        teacher.teaching()
        for stu in self.students:
            stu.learning()

    def haveAMeeting(self):
        teacher = random.choice(self.teachers)

        teacher.holding()
        for stu in self.students:
            stu.listening()

    def haveAclear(self):

        events=["扫地","擦黑板","擦窗子","倒垃圾"]

        for stu in self.students:
            stu.cleaning(random.choice(events))

if __name__ == '__main__':
    teacher1=teacher("女","张老师","历史")
    teacher2=teacher("男","李老师","数学")
    teacher3=teacher("男","王老师","英语")

    student1=student('男',"张一",99,(1,1),0)
    student2=student('男',"孙悟空",90,(1,2),1)
    student3=student('女',"花木兰",99,(2,1),2)
    student4=student('男',"恺",99,(2,2),3)

    yiban=Class("一班")

    yiban.addTeacher(teacher1)
    yiban.addTeacher(teacher2)
    yiban.addTeacher(teacher3)

    yiban.addStudent(student1)
    yiban.addStudent(student2)
    yiban.addStudent(student3)
    yiban.addStudent(student4)

    yiban.haveAClass()
    print("="*100)
    yiban.haveAclear()
    print("=" * 100)
    yiban.haveAMeeting()

GUI图形界面

from tkinter import *

class GUIcalc:

    def __init__(self):

        root=Tk()  #创建主窗口

        root.title("计算器")
        # root.geometry("300x400")

        # 框架1
        frame1 = Frame(root)
        
        # 在框架1里面创建两个单行文本框 并放置在框架
        Entry(frame1).grid(row=0,column=0,columnspan=4)
        Entry(frame1).grid(row=1,column=0,columnspan=4)
        
        # 把框架1 放在主窗口里 
        frame1.pack(side=TOP,expand=YES)

        #
        frame2 = Frame(root)
        
        # 按钮的文字 按钮的宽度
        Button(frame2,text="C",width=4).grid(row=1,column=0)
        Button(frame2,text="1").grid(row=1,column=1)


        frame2.pack(side=BOTTOM)

        root.mainloop()

if __name__ == '__main__':
    calc=GUIcalc()

from tkinter import *


class cal:
    symbol=["+","-","*","/"]

    def __init__(self):

        self.showText=""
        self.resultText=""

    def clear(self):
        '''c 按钮的功能，清除所有'''
        self.showText=""
        self.resultText=""

        return (self.showText,self.resultText)

    def record(self,new):
        ''' 记录按钮按下的值 '''
        self.showText=self.showText+new

        return (self.showText,self.resultText)

    def percent(self):
        '''按下百分比按键'''
        pos=0
        if self.showText[-1] in self.symbol:
            return (self.showText, self.resultText)
        for i in range(len(self.showText)-1,-1,-1):
            # 倒序遍历
            if self.showText[i] in self.symbol:
                pos=i# 记录符号的位置
                break

        # 后半部分除以100
        num=float(self.showText[pos:]) / 100
        #前半部分
        fore=self.showText[0:pos+1] if pos>0 else ""

        #重新组合起来
        self.showText=fore+str(num)

        return (self.showText, self.resultText)

    def equal(self):
        # self.showtext 1+0.56

        try:
            # 有可能出错的语句
            # eval 把字符串表达式 运行 返回结果
            rst=eval(self.showText)
        except:
            # 如果出错就会运行这一个
            rst="Error"
        self.resultText=rst
        self.showText=""

        return (self.showText, self.resultText)

class GUICal:
    def __init__(self):
        self.root = Tk()
        self.root.title(" 计算器")
        self.root.maxsize(200, 300)

        # 要显示的文字
        self.showText=StringVar()
        self.resultText=StringVar()
        self.showText.set("")
        self.resultText.set("")

        # 逻辑层
        self.cal=cal()

        self.EntryFrame()
        self.ButtonFrame()



    def clearHandler(self):
        # clear的处理函数
        (text1,text2)=self.cal.clear()
        self.showText.set(text1)
        self.resultText.set(text2)

    def recordHandler(self,record):
        (text1,text2)=self.cal.record(record)
        self.showText.set(text1)
        self.resultText.set(text2)

    def percentHandler(self):
        (text1, text2) = self.cal.percent()
        self.showText.set(text1)
        self.resultText.set(text2)

    def equalHandler(self):
        (text1, text2) = self.cal.equal()
        self.showText.set(text1)
        self.resultText.set(text2)

    def ButtonFrame(self):
        fm2 = Frame(self.root)
        Button(fm2, text="C", width=8, bg="orange",command=lambda :self.clearHandler()).grid(row=1, column=0, columnspan=2)
        Button(fm2, text="%",command=lambda :self.percentHandler()).grid(row=1, column=2)
        Button(fm2, text="/",command=lambda:self.recordHandler("/")).grid(row=1, column=3)
        Button(fm2, text="7",command=lambda:self.recordHandler("7")).grid(row=2, column=0)
        Button(fm2, text="8",command=lambda:self.recordHandler("8")).grid(row=2, column=1)
        Button(fm2, text="9",command=lambda:self.recordHandler("9")).grid(row=2, column=2)
        Button(fm2, text="*",command=lambda:self.recordHandler("*")).grid(row=2, column=3)
        Button(fm2, text="4",command=lambda:self.recordHandler("4")).grid(row=3, column=0)
        Button(fm2, text="5",command=lambda:self.recordHandler("5")).grid(row=3, column=1)
        Button(fm2, text=" 6",command=lambda:self.recordHandler("6")).grid(row=3, column=2)
        Button(fm2, text=" -",command=lambda:self.recordHandler("-")).grid(row=3, column=3)
        Button(fm2, text=" 1",command=lambda:self.recordHandler("1")).grid(row=4, column=0)
        Button(fm2, text=" 2",command=lambda:self.recordHandler("2")).grid(row=4, column=1)
        Button(fm2, text=" 3",command=lambda:self.recordHandler("3")).grid(row=4, column=2)
        Button(fm2, text=" +",command=lambda:self.recordHandler("+")).grid(row=4, column=3)
        Button(fm2, text=" 0", width=5,command=lambda:self.recordHandler("0")).grid(row=5, column=0, columnspan=2)
        Button(fm2, text=" .", bg='orange',command=lambda:self.recordHandler(".")).grid(row=5, column=2)
        Button(fm2, text=" =", bg="#3CA0D0",command=lambda :self.equalHandler()).grid(row=5, column=3)
        fm2.pack(side=BOTTOM)

    def EntryFrame(self):
        fm1 = Frame(self.root)
        Entry(fm1,textvariable=self.showText).grid(row=0, column=0, columnspan=4)
        Entry(fm1, background="#eee",textvariable=self.resultText).grid(row=1, column=0, columnspan=4)
        fm1.pack(side=TOP, expand=YES)

    def start(self):
        self.root.mainloop()


t = GUICal()
t.start()

Button 的command属性：按钮被按下执行的操作
lambda函数：匿名函数只有一行表达式：前是参数：后是一个操作
try:expect:: 可能出错的语句放在try里那么如果出错程序不会停止会执行expect里面的语句
eval函数：将字符串当作代码执行得到结果
选择赋值： x= value1 if condition else value2 如果条件成立 x=value1 否则x=value2

pyinstaller 打包

常用参数

-F, –onefile 打包一个单个文件，如果你的代码都写在一个.py文件的话，可以用这个，如果是多个.py文件就别用
-D, –onedir 打包多个文件，在dist中生成很多依赖文件，适合以框架形式编写工具代码，我个人比较推荐这样，代码易于维护
-a, –ascii 不包含编码.在支持Unicode的python版本上默认包含所有的编码.
-d, –debug 产生debug版本的可执行文件
-w,–windowed,–noconsole 使用Windows子系统执行.当程序启动的时候不会打开命令行(只对Windows有效)
-c,–nowindowed,–console 使用控制台子系统执行(默认)(只对Windows有效)pyinstaller -c xxxx.pypyinstaller xxxx.py --console
-o DIR, –out=DIR 指定spec文件的生成目录,如果没有指定,而且当前目录是PyInstaller的根目录,会自动创建一个用于输出(spec和生成的可执行文件)的目录.如果没有指定,而当前目录不是PyInstaller的根目录,则会输出到当前的目录下.
-p DIR, –path=DIR 设置导入路径(和使用PYTHONPATH效果相似).可以用路径分割符(Windows使用分号,Linux使用冒号)分割,指定多个目录.也可以使用多个-p参数来设置多个导入路径，让pyinstaller自己去找程序需要的资源
–icon=<FILE.ICO> 将file.ico添加为可执行文件的资源(只对Windows系统有效)，改变程序的图标 pyinstaller -i ico路径 xxxxx.py
-n NAME, –name=NAME 可选的项目(产生的spec的)名字.如果省略,第一个脚本的主文件名将作为spec的名字

HTmonster

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
高同学上课笔记

第一课1.引入库 import turtle as t #引入工具名 as 别名2. turtle库常见操作#笔操作 turtle.penup() #抬起画笔，之后移动画笔不绘制形状turtle.pendown() #落下画笔，之后移动画笔绘制形状#笔走向turtle.forward(distance) #画笔向前移动distance距离turtle.backforward...
复制链接

扫一扫