Python教程之递归

递归函数(Recursive Function)

  1. 有座山,山上有座庙,庙里有个老和尚,他在讲故事,讲的是什么呢?讲的是从前有座山,山上有座庙,庙里有个老和尚,他在讲故事,讲的是什么呢?讲的是从前有座山……上面的故事形成了一种无限循环,永远也讲不完。我们可以用while循环来实现,以下是代码示例:
    >>> s = "从前有座山,山上有座庙,庙里有个老和尚,他在讲故事,讲的是什么呢?讲的是"
    
    >>> while True:
    
    print(s)

    上面的无限循环,虽然我们用现在的知识还无法让for循环实现,但通过技巧,也是可以用for循环实现的。在Python中,还有一种方式可以实现,那就是用递归法,它的英文名是recursive。什么是递归呢?简单地说就是在函数中调用了自己。下面我们来定义一个这样的函数:

>>> def rec():              # 定义函数

print("从前有座山,山上有座庙,庙里有个老和尚,他在讲故事,讲的是什么呢?讲的是:")

rec()                 # 调用自己

>>> rec()
  1. 上面的函数,当打印了字符串后,又调用了自己,所以它会形成无限循环。在一般的程序设计中不要使用它,否则就会“跌入无底深渊”。怎么结束这种无限循环?请看下例代码:
  2. >> def rec(level):
    
    if level > 0 :
    
    print("从前有座山,山上有座庙,庙里有个老和尚,他在讲故事,讲的是什么呢?讲的是:")
    
    rec(level-1)
    
    return
    
    >>> rec(3)
    
    从前有座山,山上有座庙,庙里有个老和尚,他在讲故事,讲的是什么呢?讲的是:
    
    从前有座山,山上有座庙,庙里有个老和尚,他在讲故事,讲的是什么呢?讲的是:
    
    从前有座山,山上有座庙,庙里有个老和尚,他在讲故事,讲的是什么呢?讲的是:

    下面我们来分析一下当调用rec(3)函数时的运行过程。

  3. python递归调用分析图
  4. 我们看到,当rec(3)执行时,由于3大于0,所以它会先打印并且调用rec(2)。基于同样的道理,rec(2)也是由于2大于0,它也会先打印,然后再调用rec(1)。rec(1)也是一样,一直会调用到rec(0),由于0大于0不成立,它并不会打印,会直接运行到return返回。rec(0)运行完毕后也就意味着rec(1)运行完毕,依此类推,最后就会运行到标记为14的return语句,整个rec(3)的运行过程才结束。上面的圆形标记,从1到10是“递”的过程,从11到14是“归”的过程。通过给函数设定level参数,实现了rec(3)函数的“递”和“归”的过程。接下来分析一个经典示例,用递归法求阶乘。

    阶乘(Factorial )

  5. 计算阶乘是递归程序设计的一个经典示例。要求出某个数的阶乘就是用那个数去乘以所有比它小的自然数(大于0)。例如,factorial(5)等价于5*4*3*2*1,而factorial(3)等价于 3*2*1。阶乘的一个有趣的特性是,某个数的阶乘等于起始数乘以比它小1的数的阶乘。例如,factorial(5)与5 * factorial(4)相同。这也就是说factorial(n) = n * factorial(n-1)。这其实是一种递归的定义,所以我们可以定义递归函数来求n的阶乘。
  6. >>> def f(n):
    
    return n * f(n-1)
    
    
    >>> f(3)

    上面定义了名为f的递归函数,当调用f(3)时,调用情况大概如下所示:

    f(3) -> 3 * f(2) -> 2 * f(1) -> 1 * f(0) -> 0 * f(-1) -> -1 * f(-2)………

    当运行上面的函数,程序马上会报错,错误提示为:

    RecursionError: maximum recursion depth exceeded

    上面表示的意思是:递归错误:超过了最大的递归深度,即超过了最多调用次数。

    由于上面定义的f函数没有编写结束条件,所以理论上它会“无限”地运行下去。可是Python可不会让这种行为发生,它会对递归的调用次数进行限制,默认最多只能调用1000次。通过导入sys模块,可以用sys.getrecursionlimit命令查看最大的递归次数限制。由于1的阶乘就是1,所以n大于1递归才有意义,否则n到1了直接让它返回1即可。以下是改进的求阶乘的函数:

  7. >>> def f(n):
    
    if n >1 :
    
    return n * f(n-1)
    
    else:
    
    return 1
    
    
    
    >>> f(3)
    
    >>> 6

     

    如果n等于3,f(3)的运行过程如下图所示

    Python递归求阶乘分析图当调用f(3)时,根据条件判断语句,由于3大于1,所以它会返回 3 * f(2),那么f(2)被调用,由于2大于1,所以它会返回2*f(1)。f(1)的结果就是1,所以2*f(1)的结果是2,那么3*f(2)的结果就是6,最后f(3)就能返回6了。

  • 请给下列递归函数加上结束条件。
  • >>> def func(number):
    
    print(number)
    
    func(number-1)

    下列是有错误的求自然数和的递归函数,请修改成正确的代码。

  • >>> def zsum(n):
    
    if n > 1:
    
    return n + zsum(n)
    
    else:
    
    return n

    阅读下列代码,说出每行代码的意思,你能想像得出它会画大致什么图形吗?

  • from turtle import *
    
    t = Turtle(visible=False)
    
    def draw_square(t,length,level):
    
       if level > 0 :
        for i in range(4):
          t.fd(length)
          t.right(90)
    
    draw_square(t,length//4 ,level-1)
    
    draw_square(t,100,3)
发表在 杂谈 | Python教程之递归已关闭评论

python的os模块启蒙

这是本人去年写的草稿Python教程。

Python之所以强大和它有诸多的模块是分不开的。海龟模块能帮助我们画出漂亮的图形,随机模块能产生随机数,除此之外,还有今天要学的OS模块。它和上述的模块一样是Python内置的。

  1. OS模块概述(Overview of OS Module)

我们天天和计算机打交道,使用各种软件,它们为我们提供各种功能。软件分为三个类型,最低层的的叫输入输出系统,英文为basic input and ouput system,简称BIOS。当计算机开机时,这个软件从固件中读取出来,CPU会执行它。程序会检测计算机各个部件正不正常,如果一切正常,它就会从磁盘中读取操作系统的第一个程序,这个程序就会继续引导计算机运行,直到我们最后看到一切安好的桌面,这时计算机就成功地启动了。上面提到了操作系统,它的英文名为Operating System,简称OS。顾名思义,它是用来操作计算机的一整套系统,我们先简单地把OS看成是程序的集合体。在计算机桌面上,我们能看到各种图标,它们有些对应一个程序,如QQ,酷狗等,它们及其附属文件叫应用软件(application software),这些应用软件通过调用操作系统的一些功能,从而可以帮助我们完成某项任务。我们学的Python功能强大,它也是能调用操作系统的功能的。这是由于它内置了OS模块。要在Python中使用OS模块的各种功能,需要先导入它,用import os这句命令就行了。在OS模块中有很多命令,如新建文件夹(目录),删除文件,重命名文件,遍历路径下面的文件等。所谓路径,它和位置的概念非常像,一个文件有一个位置,一个文件夹也有一个位置。当我们对着文件单击右键,在弹出的菜单中选择属性后,我们就能在属性对话框中看到文件的信息,这其中就有“位置”这个项目。它表明了文件所在的路径或文件夹。

如下图所示:

看到了上面的“位置”两个字吗?它的值是一串以反斜杠分隔的字符。上面图中的文件名是:Python.png。它的位置信息表明了它是在C盘的User文件夹下面的Administrator文件夹下面的Desktop目录,这就是它的路径。在Windows中路径是以反斜杠分隔,而在其它操作系统中,如Linux则是以正斜杠分隔。Python为了能适应多种操作系统,使用os.sep来表示路径的分隔符。下面来看看在windows操作系统中os.sep是什么。

>>> import os         # 导入os模块

>>> os.sep              # 路径分隔符

'\\'                           # 反斜杠

>>>

在上在的代码中,第3句,它显示的是反斜杠。为了使编写的程序能适合任何操作系统,当我们要合成一个路径时,应该使用os.sep。下图是一个文件夹的截图,它里面所有的文件所在的路径都是:C:\Intel\Logs

  1. 当前工作文件夹(Current Work Directory)

当我们编写了一个py文件后,我们会把它保存在一个文件夹里。当双击这个py文件,那么它的当前工作文件夹就是它本身所在的这个目录。如果是在IDLE的shell中,那么当前工作文件夹是什么路径呢?可以通过os的getcwd命令来获取它。如下面代码所示:

>>> import   os           # 导入os模块

>>> os.getcwd()          # 获取当前工作目录

'C:\\Python\\Python36'

>>>

上面的第3行就是当前工作文件夹。当然,每台电脑显示的路径会不一样,这是由安装Python的时候决定的。如果读取文件或创建文件的时候不写明具体的路径,Python就会在当前工作目录中寻找,如果没找到,就会报错。以下的代码就会报错,这是由于当前文件夹并没有叫Python.txt的文件。

>>> open("Python.txt")

Traceback (most recent call last):

File "<pyshell#4>", line 1, in <module>

  open("Python.txt")

FileNotFoundError: [Errno 2] No such file or directory: 'Python.txt'    # 文件没有找到错误

>>>

当然,如果是写文件,则会在当前文件夹下面创建一个文件,读者可以试试,在此不在赘述。

  1. 新建目录(Make Directory)

 上面说了,如果以只读模式打开一个不存在的文件,那么就会报文件找不到的错误。当然,我们可以首先把这个文件建好再去打开它。假设,我们把这个文件放在D盘的某个目录,如果那个目录不存在,那么可以手工建立它。更好的方法是用os.mkdir命令自动建立。下面的代码新建了一个目录,然后在那个目录里写入了一个文件:

>>> path = "D:" + os.sep + "我家住在黄土高坡"       # 设定一个路径字符串
   
>>> os.mkdir(path)                                # 新建一个文件夹

>>> filename = path + os.sep + "真的吗.txt"        # 拟定一个文件名

>>> f = open(filename,mode='w')                   # 创建新的文件

>>> f.write("当然是真的")                          # 写入字符串

5                                                # 返回写入的字符数量

>>> f.close()                                    # 关闭文件

>>>

mkdir是用来创建文件夹的,它是英文make和directory两个单词的缩写结合。使用它的方法较为简单,只要在它的小括号里面写上路径名称就行了。需要注意的时,如果直接写路径名当遇到要写路径分隔符的时候,在windows操作系统中要写两个反斜杠,这是由于在Python中反斜杠是一个转义字符。其它的转义字符有回车符号、换行符号、制表符号。它们分别写作\r、\n、\t。简单的理解下,只要记住在Python中连续的两个反斜杠就表示斜杠的意思就行了。

上面的代码会成功创建一个文件并写入字符串,写入的字符个数是5,这在第6行有所体现。现在如果再去打开读取它就不会出错了。注意到上面用的os.sep了吗,在windows中,它的庐山真面目就是反斜杠。sep这三个字符来源于英文separator, 分隔器,分隔符。

OS模块还有很多命令,接下来做几个练习,巩固一下所学的知识。

  • 请指出下列代码的问题。
  • >>> import OS
    
    >>> print(OS.Sep)

    请指出下列代码的问题,如果是正确的会有什么运行结果?

  • >>> import os
    
    >>> for p in range(10):
    
    os.mkdir("D:" + os.sep + p)

    请分析下列代码的运行结果。

  • import os
    
    import random
    
    
    
    path = os.getcwd()
    
    s = ""
    
    for i in range(3):
    
    s = s + str(random.randint(1,1000))
    
    new_path = path + os.sep + s
    
    os.mkdir(new_path)
    
    f = open(new_path + os.sep + s + ".txt",mode='w')
    
    f.write("Hello")
    
    f.close()
    
    print(new_path)

    下面是一张文件夹的截图,说一下Global.db文件所在的路径。

发表在 杂谈 | python的os模块启蒙已关闭评论

if …else条件判断Python教程

这是本人去年写的草稿教程。

  1. 比较运算符 (Comparison operator)

   华山论剑,比的是武功的高低。欲与天公试比高,这可是在和天比高低。在Python中我们也经常要比较比较。一般来说,比的是数据的大小。如,我们常说5大于3或10小于100,这就是在比较数据的大小,得出的结果是成立或不成立。刚才我们用的是汉语,现在改用Python来比较吧,其实非常简单,只不过借用数学中的关系运算符,下面的代码展示了如何进行数据比较:

>>> 5 > 3            # 5大于3 ?

True                 # 真 (成立,是)

>>> 10 < 3           # 10小于3 ?

False                # 假 (不成立,否)

>>> 5 == 3           # 5等于3 ?

False                # 假 (不成立,否)

>>> 5 == 5           # 5等于5 ?

True                 # 真 (成立,是)

>>> x = 10           # 定义x变量,值为10

>>> y = 100          # 定义y变量,值为100

>>> x != y           # x不等于y ?

True                # 真 (成立,是)

>>> x >= 10         # x大于等于10 ?

True                # 真 (成立,是)

>>> y <= 100        # y小于等于100 ?

True                # 真 (成立,是)

>>>

>>> bool("下雨") == True   # 非空字符串转换成bool为真

True

在上面的代码中,我们看到了好多式子,这些式子叫做关系表达式。关系表达式的运算结果要么是True,要么是False。表达式里的大于号或等于号这些符号,它们叫做关系运算符或比较运算符。这些运算符和数学中的是不是很相似呢。由于在Python中非空字符串转换成bool值的时候结果是True,所以第18行的值为True,值得注意的是如果要比较两个数据是否相等要用两个紧连着的等于号,如果要比较两个数据是否不相等,则要用感叹号和等于号(第11行),这两个符号要紧连着,不能用空格之类的字符把它们分开。如以下用法是错误的。

1

2

3

4

5

>>> x !  = y

SyntaxError: invalid syntax

>>> x =  = y

SyntaxError: invalid syntax

>>>

  1. if 语句 (if statement)

   “曾经有很多次学习的机会摆在我面前,我没有珍惜,如果上天再给我一次机会,我一定会好好学习,天天向上,再也不重演少壮不努力,老大徒伤悲的剧情了。”在上面有一个词汇是“如果”,它的英文为if。在Python中也能使用它。怎么使用呢?请看下面源代码:

>>> if  3 > 1 :                   # 如果3大于1

print("3大于1")             # 打印字符串



3大于1

>>>

让我们把第1行翻译成中文吧。它的意思是说如果3大于1则打印字符串。这是不是非常好理解。上面演示的是最简单的if语句的用法,它的语法为以下所示:

python的if条件表达式语法一

上面图示中的表达式可以是关系表达式,它的值为True的时候就会执行语句组。语句组是有共同缩进的一些语句。一条语句也不写是不行的,如果真的不需要任何语句,那至少得写一个pass。pass也是一个关键词,它只是占个位置,什么也不干。

我们在生活中还会不假思索地思考这样的话:如果下雨,就呆在家里,否则出去晒太阳。下面看看Python怎么把“汉语”用它自己的语言表达:

>>> if bool("下雨") == True:      # 如果 成立

print("呆在家里")

else:                            # 否则

print("外出晒太阳")



呆在家里

>>>

在第1行代码中bool(“下雨”)把非空字符串转换成逻辑值,它的结果就是True,所以上面会打印“呆在家里”。这是一种如果…否则…型的if语句,它的语法形式如下所示:

上面图示表达的意思是如果表达式成立则运行它下面的语句组,否则运行else下面的语句组,要注意冒号是必不可少的。else在英文中是否则的意思,下面是一个简单的示例,请在你的大脑中运行一下吧:

for i in range(10):
   if i > 4:
      print(i,"是大于4的数据。")
   else:
      print(i,"不是大于4的数据。")

if语句不光有上面2种形式,还有下面的第三种形式,可以表述为if…elif…elif…else。

elif可以理解为否则如果的意思。举个例子,期末考试结束了,老师要判断学生成绩的等级,那么他就能编制作一个简单的程序。

score = 70                 # 定义变量,名为score

if score >= 90:           # 如果得分大于等于90

    print("成绩优秀!")   # 打印

elif score >=70:          # 否则如果得分大于等于70

   print("成绩良好!")   # 打印

elif score >=60:          # 否则如果得分大于等于60

    print("成绩及格!")    # 打印

else:                   # 否则

    print("不及格!")      # 打印

根据不同的score,运行上面的程序会有不同的结果,以下是这种if语句的语法:

上面的语法图中,else语句分枝也可以不要,elif分枝可以有很多个。当然,语句组们相对于if、elif、else的缩进也要是一样的,这是Python特色,不按规矩来,Python就会直接给你一个大红脸。

  1. 一行if (short hand if)

如果if语句下面只有一行语句,那么可以把它放在冒号的后面。以下代码是正确的:

>>> x = 5
>>> if x > 0: print("x是大于0的数据。")

由于Python的语句之间可以用分号隔开,所以下面的一行if也是可以的,虽然不推荐这么做。

>>> x = 5
>>> if x > 0: print("x是大于0的数据。") ; print("程序运行结束")

条件运算式 (Conditional Expressions)

条件运算式能在一行内对条件进行判断,如果成立那么结果就是表达式1的结果,否则就是表达式2的结果。以下是它的语法图:

下面是一个条件运算式的例子:

>>> raining = False

>>> print("让我们去", '海滩'  if  not  raining  else '图书馆')

让我们去海滩

>>> raining = True

>>> print("让我们去", '海滩'  if  not  raining  else '图书馆')

让我们去图书馆

>>> age = 12

>>> s =  '未成年'  if  age < 21 else  '成年人'

>>> s

'未成年'

上面第2句的print语句里有 ‘海滩’ if not raining else ‘图书馆’ 这条语句。由于raining的值为False,所以这条语句的返回值为’海滩’。第9行的代码中,由于age的值小于21,所以返回的是’未成年’。

  1. 嵌套if (nested if)

if 语句下面的语句也可以是if语句,即,它们是可以嵌套的,以下是一个例子。

for  i in range(10):

   if i >3 :                   # 如果 i 大于3

     if i/4 == 1 :

         print(i)

如果能不用嵌套的语句解决问题,那么尽量不要使用,这会降低程序的可读性。Python哲学之一就是扁平胜于嵌套。我们学的for循环和if语句它都能起一种控制代码运行流向的作用,所以它们叫做流程控制语句。

请指出下列代码的问题。

>>> a = = 33

>>> b = 200

>>> if b > a:

>>> print("b比a大")

请说出这句代码的结果:’天南地北’ if True else ‘中西合壁’。

  • 请说出下列代码运行结果后amount变量的值。
  • >>> number = 10
    
    >>> counter = 20
    
    >>> amount = 5 if number < 10 else counter

     

发表在 杂谈 | if …else条件判断Python教程已关闭评论

python打金蛋小游戏,拦球得分小游戏

本人编写的python小游戏程序,为了不增加复杂度,所以没有再去增加更多的功能,仅抛砖引玉之用。
界面是这样的,没有加音效:

"""本程序运行需要安装汉化版turtle.py库
   下载网址 http://www.halifa.net/turtle.rar
   本游戏用鼠标操作去打金蛋,金蛋被打到后会掉下来,接住了可以加分,拦板会变长。
   所有金蛋打完后,游戏结束,显示得分。如果没有接到小球,游戏失败!
   
"""
from turtle import *
from time import sleep
from random import randint
屏幕=当前屏幕()
屏幕.标题("打金蛋小游戏")
屏幕.背景颜色("black")
游戏结束="假"
移动速度=0
小球=图形对象()
小球.速度(0)
小球.形状("circle")
小球.颜色("white","red")
小球.抬笔()
小球.形状大小(0.5,0.5)
小球.到(0,-50)
小球.设置方向(randint(1,360))

                
拦板=图形对象(visible=False)
拦板.速度(0)
拦板.画笔颜色('gray')
拦板.填充颜色("brown")
拦板.抬笔()
拦板.形状('square')
拦板的长度=3
拦板.形状大小(拦板的长度,0.3)
拦板.到(0,200)
拦板.写字("打金蛋小游戏",align='center',font=("黑体",30,"normal"))
拦板.到(0,-250)
拦板.显示()

def 标题显示鼠标坐标(x,y):
    拦板.设置x坐标(x)
屏幕.当鼠标移动(标题显示鼠标坐标)

class 金蛋(图形对象):
    
    总分=0
    计数器=0
    def __init__(自己,x=0,y=0,敌人=小球,拦板=拦板):
        图形对象.__init__(自己,visible=False)
        自己.形状("circle")
        自己.形状大小(2,1)
        自己.颜色("white","yellow")        
        自己.抬笔()
        自己.到(x,y)
        自己.显示()
        自己.被撞='否'
        自己.死亡='否'
        自己.敌人=敌人
        自己.拦板=拦板
        自己.垂直速度=0
        自己.等待被撞()        
    def 等待被撞(自己):
        global 游戏结束
        if 游戏结束=="假":
                
            if 自己.被撞=='否':
                if 自己.距离(自己.敌人)abs(屏幕.窗口宽度()/2):
        小球.设置方向(-小球.方向())
    if abs(小球.y坐标())>abs(屏幕.窗口高度()/2):
        小球.设置方向(180-小球.方向())
    sleep(0.001)

#游戏结束
print("游戏结束!",游戏结束)
屏幕.清屏()
屏幕.背景颜色("cyan")
小球.隐藏()
小球.到(0,0)
小球.颜色("red","blue")
if 金蛋.计数器==len(金蛋们):
    字符串="你打完所有的金蛋了!你的得分是:" + str(金蛋.总分) + "分!"
else:
    字符串="你把小球球给弄丢了,你的得分是:0分!"
    屏幕.标题("打金蛋小游戏,当前得分:0分")
    
小球.写字(字符串,align="center",font=("黑体",25,"normal"))
发表在 turtle | 标签为 , , | 留下评论

少儿python编程之两打海龟画图形

本例是24只海龟几乎同时移动画出来的图形,每只海龟画了两段“曲线”,画了一段红色曲线后向后转又画一段绿色的曲线。
程序首先把背景设为黑色,然后生成24只海龟把它们放到一个列表。接着让列表里的海龟依次画“曲线”。

#下面是python 源代码示例:

 

""" 073_两打海龟画图形.py
    本程序生成24只海龟,每只海龟画一段曲线后折回,再画一段曲线。  
    
"""
from turtle import *
bgcolor('black')
delay(0)
两打海龟=[]
for i in range(24):
    两打海龟.append(Turtle(shape='blank'))  #把每只海龟放到列表,方便统筹安排。


计数器=0
for 每只龟 in 两打海龟:                     #设置每只龟的一些初始属性。
    每只龟.speed(0)
    每只龟.pensize(2)
    每只龟.setheading(计数器*15)            #设定每只龟的初始方向,360/24=15度
    每只龟.color('black','black')
    计数器=计数器+1
    
红色=0                                      #总共重复20次。
for i in range(20):                         #   让每只龟移动15像素后旋转10度。
    红色=红色+12                            
    for 每只龟 in 两打海龟:
        每只龟.fd(15)
        每只龟.right(10)
        每只龟.pencolor(红色,0,0)
        title('红色分量为:' + str(红色))

for 每只龟 in 两打海龟:                     #让每只海龟向后,即转180度。
    每只龟.right(180)
    
绿色=0
for i in range(20):
    绿色=绿色+12
    for 每只龟 in 两打海龟:
        每只龟.fd(15)
        每只龟.right(10)
        每只龟.pencolor(0,绿色,0)
        title('绿色分量为:' + str(绿色))

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

画出来的图形是这样的:

发表在 turtle | 标签为 , , , | 留下评论

少儿python编程之rgb颜色混合器

python中的颜色能用一个三元组来表示,三元组里存储的是红绿蓝三种颜色的份量。在这里,我们用ondrag事件命令拖动海龟,让它的y坐标在0到255的范围内上下移动。
把这个y坐标当成RGB中的一个值,这样可以组合三元色。让背景得到这个三元色的组合,所以背景的颜色就能跟着变换了。

ondrag命令的参数为一个事件处理函数。

#下面是python 海龟作图模块制作的颜色色混合器 源代码示例:

 
""" 072_颜色混合器.py

     本程序也能做为RGB颜色展示用途。  
"""
from turtle import *
r=0
g=0
b=0
bgcolor("black")
delay(0)
红龟=Turtle(visible=False)
红龟.color('gray100','red')      #分别设定海龟的画笔颜色和填充颜色
红龟.shapesize(5)                #让海龟变大为原来的5倍
红龟.penup()
红龟.goto(-100,0)
红龟.showturtle()

def 红色变换(x,y):                #作为ondrag的事件处理函数,它一定要有x和y参数,接收鼠标的x,y坐标。   
    global r,g,b
    r=max(0,min(y,255))           #限定r的范围为0到255。
    红龟.sety(r)
    bgcolor(r,g,b)
    title("当前RGB值:(" + str(r) + ","  + str(g) + "," + str(b) + ")")

绿龟=Turtle(visible=False)
绿龟.color('gray100',(0,255,0))      #分别设定海龟的画笔颜色和填充颜色
绿龟.shapesize(5)                    #让海龟变大为原来的5倍
绿龟.penup()
绿龟.goto(0,0)
绿龟.showturtle()

def 绿色变换(x,y):                #作为ondrag的事件处理函数,它一定要有x和y参数,接收鼠标的x,y坐标。   
    global r,g,b
    g=max(0,min(y,255))           #限定r的范围为0到255。
    绿龟.sety(g)
    bgcolor(r,g,b)
    title("当前RGB值:(" + str(r) + ","  + str(g) + "," + str(b) + ")")

蓝龟=Turtle(visible=False)
蓝龟.color('gray100','blue')      #分别设定海龟的画笔颜色和填充颜色
蓝龟.shapesize(5)                 #让海龟变大为原来的5倍
蓝龟.penup()
蓝龟.goto(100,0)
蓝龟.showturtle()

def 蓝色变换(x,y):                #作为ondrag的事件处理函数,它一定要有x和y参数,接收鼠标的x,y坐标。   
    global r,g,b
    b=max(0,min(y,255))           #限定r的范围为0到255。
    蓝龟.sety(b)   
    bgcolor(r,g,b)
    title("当前RGB值:(" + str(r) +  ","  + str(g) + "," + str(b) + ")")
        
红龟.ondrag(红色变换)             #拖动事件发生时,调用红色变换函数,这个函数会接受鼠标的坐标。
绿龟.ondrag(绿色变换)             #拖动事件发生时,调用红色变换函数,这个函数会接受鼠标的坐标。
蓝龟.ondrag(蓝色变换)             #拖动事件发生时,调用红色变换函数,这个函数会接受鼠标的坐标。
listen()

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , , , | 留下评论

少儿python编程之局部变量与全局变量

python中定义一个变量很简单,不需要声明类型。只要直接取一个名字,并且要让这个名字得到一个值(或指向一个对象)。
这个名字也叫标识符,用来标识一个对象的。就像我们人一样,每个人都有一个姓名,姓名就是标识我们的符号。
在函数中也能定义变量,如果在函数中定义了一个变量。我在函数外使用这个变量会怎么样呢?可以自行测试。
所以变量定义的位置可以是不同的,根据位置不同有全局变量和局部变量之分(或叫公共变量与私有变量)。
如果在函数外定义了一个变量,在函数里能使用它的值吗?
如果在函数外定义了一个变量,在函数里能改变它的值吗?
如果在函数外定义了一个变量,在函数内能删除这个变量吗?
下面的代码,结果会打印什么呢? 可以先测试一下。

x=5
def 函数1():      #定义函数
    x=12          #给x赋值为12
    del x         #删除变量x 
函数1()
print(x)

上面的函数内有一个x变量,它和函数外的x变量虽然同名称,但它们不是同一个变量。虽然在函数内用del马上又删除了x变量,但不影响外面的x变量。所以结果还是5。函数里定义的变量叫本地变量,也就是局部变量。 如果我想在函数内修改函数外的x的值,要怎么写呢?我们只要在函数内声明x为全局变量即可,语法为:
global x

上面就表示x这个变量是函数外部定义的全局变量,相当于告诉python,你不要再建立同名的x变量了!

#下面是python 局部变量与全局变量 源代码示例:

  
""" 071_局部变量与全局变量.py
   我们已经使用过局部变量与全局变量了。
   局部变量是只能在函数中使用的变量。函数运行结束后,局部变量也就消失了。
   全局变量是在主程序中运行的变量,也就是在函数外定义的变量。
   我们可以在函数中使用全局变量,但只能引用它的值。
   如果在函数中要改变全局变量的值,那么就要加global关键词进行声明。
   表示,现在使用的是在函数外定义的变量。
   如果不使用global进行声明,python会默认建立同名的局部变量。
   当函数运行结束后,同名的局部变量会被删除,并不会影响到全局变量。
   
    
"""
from turtle import *
from time import sleep
r=255
g=12
b=44
bgcolor("black")
红龟=Turtle(visible=False)
红龟.color('gray100','black')      #分别设定海龟的画笔颜色和填充颜色
红龟.shapesize(5)                  #让海龟变大为原来的5倍
红龟.showturtle()

def 改变颜色1():
                                  #在本函数中,直接使用了全局变量的值。
    红龟.fillcolor(r,g,b)         #设定龟的填充颜色为(r,g,b)

改变颜色1()
print("在函数中可以使用全局变量的值")
print(r,g,b)

sleep(2)
def 改变颜色2():
    r=0;g=210;b=55                #python会新建三个同名的r,g,b变量,对外部的r,g,b变量没有影响。
    红龟.fillcolor(r,g,b)         #设定龟的填充颜色为(r,g,b)

改变颜色2()
print("函数中定义的同名r,g,b三个变量,并没有影响到全局变量的值")
print(r,g,b)

sleep(2)
def 改变颜色3():
    global r,g,b                 #声明r,g,b三个变量是全局变量,不必要新建三个同名的r,g,b变量了。
    r=2;g=15;b=225               #改变三个全局变量的值
    红龟.fillcolor(r,g,b)        #设定龟的填充颜色为(r,g,b)

改变颜色3()
print("函数中对r,g,b进行了声明,声明它们是全局变量,所以它们的值改变了")
print(r,g,b)

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 Uncategorized | 标签为 , , , | 留下评论

少儿python编程发红光的小海龟

这节课是学习颜色的RGB表示方法,用一个三元组表示一种颜色,三元组中的每个数值从0到255。
程序运行后有一只小海龟,它的颜色会变得越来越红,最后像发出红光一样。

#下面是python 发红光的小海龟 源代码示例:

   
""" 070_发红光的小龟.py
    我们以前用的是颜色字符串来表示颜色,在python海龟画图中我们能用三个从0到255的数值来表示一种颜色。
    例:(255,0,0)表示的是红色,(0,255,0)表示的是绿色,(0,0,255)表示的是蓝色。
    用这种方法表示颜色叫RGB表示法,R即red,代表红色。G即green代表绿色。B即Blue代表蓝色。
    在计算机中所有的颜色都是用RGB三种颜色合成的。
    我们把RGB三种颜色都分成256份。让它们的值从0到255,如果R的值为0的话,表示红色份量为0。
    即没有红色,当红色的份量一直增大到最后为255的时候,就是红色最红的时候。
    当G的值为0的话,表示绿色份量为0,即没有绿色,G的值一直增大,就会让绿色的份量越来越多。
    当B的值越来越大,蓝色的份量也是越来越多。
    本程序演示的是红色的份量越来越多,小海龟越来越红,它的其它颜色份量都为0。
    如果R和G的份量同时越来越多,小海龟的颜色会怎么样呢?(把B份量设为0)
"""
from turtle import *
bgcolor("black")

红龟=Turtle(visible=False)
红龟.color('black','black')      #分别设定海龟的画笔颜色和填充颜色
红龟.shapesize(5)                #让海龟变大为原来的5倍
红龟.penup()
红龟.goto(-100,0)
红龟.showturtle()
i=0
def 发光():
    global i                     #声明i是全局变量,即这里的i是函数外面定义的i
    红龟.fillcolor(i,0,0)        #设定龟的填充颜色为(i,0,0)
    i=i + 1
    i=i % 256                    #对255取余,因为每种颜色份量的最大值只能是255
    title("当前RGB值:(" + str(i) + ",0,0)")
    ontimer(发光,10)             #每10毫秒调用一次发光这个函数
发光()

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , | 留下评论

少儿python编程之画十字架让它旋转的练习参考答案

我们可以自定义海龟的形状,然后注册到python预定义的图形列表。这样我们新建海龟对象的时候就能选择刚才定义的图形。

下面的代码是先画一个十字架,把十字架进行登记,然后新建一个海龟对象用这个十字架做为自己的形状的代码。

练习十的题目就是画一个十字架,然后把它旋转起来。

#下面是练习十源代码示例:

  
""" 069_练习十.py
    练习画一个十字架,然后让它旋转。
"""
from turtle import *
print("海龟本来的图形:\n",getshapes())
#以下是画一个图形,用来注册做海龟的图形的。
形状=Turtle()                    #新建‘形状’海龟,它的使命就是画一个正方形,然后被注册到海龟的图形列表。
形状.begin_poly()                #开始记录多边形的顶点,当前的海龟位置是第一个顶点,做为图形旋转中心。

for i in range(4):               #让i依次的值为0,1,2,3,让for语句组重复4次
    形状.fd(100)
    形状.fd(-100)
    形状.right(90)

形状.end_poly()                  #结束记录多边形的顶点。
p = 形状.get_poly()              #得到刚才所画的图形的每个顶点,形成元组,放到变量p这里。
register_shape("十字架", p)      #注册p为正方形的名称,以后就能用它做海龟本身的图形了。
形状.clear()
形状.hideturtle()                #名字叫‘形状’的海龟完成了任务,把它隐藏起来。
del 形状                         #名字叫'形状‘的海龟完成了任务,我们不仅仅把它隐藏,而且把它给删除。


                                 #下面是建立一个叫cross的海龟对象,cross的意思是十字架的意思。
cross=Turtle(shape='十字架')
cross.pencolor("blue")
cross.pensize(5)
cross.fillcolor("green")

def 旋转十字架():
    cross.right(30)
    ontimer(旋转十字架,10)
旋转十字架()

print("新增十字架后的列表:\n",getshapes())

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , | 留下评论

少儿python编程之海龟自定义图形

python的海龟作图模块新建一个海龟相当于新建一个角色,我们可以给它换其它图形,以改变它的样子。
getshapes()命令能获取当前所有的图形,用一个列表显示出每个名字。要改变角色的图形用shape命令即可。
如果用上ontimer命令,就能不断地给角色更换图形,从而实现动画效果。

#下面是python自定义海龟图形源代码示例:

   
""" 068_自定义海龟图形.py
    python的海龟画图能加载外部的图片做为海龟本身的图形,也能自己画一个图做为海龟对象的形状。
    海龟的图形存放在一个列表里,我们能用getshapes()命令查看这个列表里有些什么图形。
    本节课让海龟首先画一个正方形,然后把这个正方形做为海龟本身的图形。
    
"""
from turtle import *
print("海龟本来的图形:",getshapes())
#以下是画一个图形,用来注册做海龟的图形的。
形状=Turtle()     #新建‘形状’海龟,它的使命就是画一个正方形,然后被注册到海龟的图形列表。
形状.begin_poly() #开始记录多边形的顶点,当前的海龟位置是第一个顶点,做为图形旋转中心。
形状.begin_fill() #开始填充图形,不填充也是可以的。
for i in range(4): #让i依次的值为0,1,2,3,让for语句组重复4次
    形状.fd(100)
    形状.right(90)
形状.end_fill()   #结束填充 
形状.end_poly()   #结束记录多边形的顶点。
p = 形状.get_poly()  #得到刚才所画的图形的每个顶点,形成元组,放到变量p这里。
print("p是:",p)
print()
print("p是一个元组,它记录了多边形的每个顶点的坐标值。")
register_shape("正方形", p)  #注册p为正方形的名称,以后就能用它做海龟本身的图形了。

#input("输入任意键继续...")
形状.clear()
形状.hideturtle() #名字叫‘形状’的海龟完成了任务,把它隐藏起来。
del 形状          #名字叫'形状‘的海龟完成了任务,我们不仅仅把它隐藏,而且把它给删除。


#下面是建立一个叫正方形1的海龟对象,让它的形状为刚才定义的 正方形。
正方形1=Turtle(shape='正方形')
正方形1.pencolor("cyan")
正方形1.fillcolor("green")

def 旋转正方形():
    正方形1.right(10)
    ontimer(旋转正方形,10)
旋转正方形()


#input("输入任意键继续...")

#问题:

#即然p是一个元组,里面存储的是每个坐标点,那么我们能不能自己直接定义一个有各个顶点的元组呢?
#所以,我们不必要新建所谓的‘形状’海龟了
#我们直接定义一个元组即可,下面是一个例子
#这里定义一个元组也叫p,它的第一个项目是(0,0),第二个项目是(0,100)
#当用register_shape注册时它的第一个项目就是旋转中心。

p=((0,0),(0,100))
addshape("线条", p)             #用addshape也可以
print("\n所有的形状为:",getshapes())
条子=Turtle(shape='线条')
条子.pensize(5)
条子.pencolor("red") 
条子.penup()
条子.goto(0,200)

def 旋转条子():
    条子.right(10)
    ontimer(旋转条子,10)
旋转条子()


少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

运行后是这样的,单击才能看到动画效果,因为这是缩略图:

发表在 turtle | 标签为 , | 留下评论

少儿python编程之贪吃蛇小游戏

贪吃蛇小游戏的核心代码在于如何让蛇吃一个食物身体就变长。在海龟作图中,有图章命令可以实现这个功能。相比在scratch语言中简单的图章命令。

python中的图章功能功能更丰富,可以实现更佳的动画效果。基本原因就是蛇碰到食物就多盖一个章,并清除最开始盖的第一个章,这样看起来就有种蛇越来越长的效果。

#下面是python贪吃蛇小游戏源代码示例:

  
""" 067_贪吃蛇小游戏4_得分与结束游戏.py
   本节课制作一个完整的贪吃蛇小游戏。
   
"""
from turtle import *
from time import sleep
from random import randint
from winsound import PlaySound,SND_ASYNC
背景音乐="欢快女唱电音歌曲超嗨.wav"
碰撞声="碰撞声.wav"
小蛇=Turtle()
小蛇.penup()
小蛇.speed(0)                    #让小蛇的速度最快
小蛇.pencolor("white")
小蛇.fillcolor("cyan")
游戏结束=False                   #增加了游戏结束的逻辑变量
得分=0
屏幕=小蛇.getscreen()
屏幕.title("贪吃蛇小游戏")

屏幕宽度=800
屏幕高度=600
屏幕.setup(屏幕宽度,屏幕高度)
屏幕.bgcolor("black")

#设定让贪吃蛇不断地移动的函数。
def 移动小蛇():
    global 游戏结束
    小蛇.clearstamps(1)     #清除最开始盖的第一个章
    小蛇.stamp()            #马上又盖一个章
    小蛇.fd(20)
    #这里是游戏结束的核心代码,以小蛇超出边界做为小蛇死亡。
    if 小蛇.xcor()<(屏幕宽度/2) and 小蛇.xcor()>(-屏幕宽度/2) and 小蛇.ycor()<(屏幕高度/2) and 小蛇.ycor()>(-屏幕高度/2):
        屏幕.ontimer(移动小蛇,10)
    else:
        PlaySound(碰撞声, SND_ASYNC) #异步播放音效
        游戏结束=True
        endGame()


#增加边框代码段
小边=Turtle(visible=False)
小边.pensize(30)
小边.pencolor('red')
小边.fillcolor('red')
小边.setheading(90)
小边.speed(0)
小边.penup()
小边.goto(-屏幕宽度/2,屏幕高度/2)
小边.pendown()
for i in range(2):
    小边.fd(屏幕宽度)
    小边.right(90)
    小边.fd(屏幕高度)
    小边.right(90)

    
#以下是主要增加的代码段
食物=Turtle(visible=False)
食物.penup()
食物.speed(0)
食物.goto(randint(50-屏幕宽度/2,屏幕宽度/2-50),randint(50-屏幕高度/2,屏幕高度/2-50))
食物.pencolor("yellow")
食物.fillcolor("green")
食物.shape("circle")
食物.showturtle()
def 等待小蛇():
    global 得分                      #增加全局变量统计所吃到的食物数量
    if 食物.distance(小蛇.pos())

上面的程序运行后,出现的界面是这样的,中间一个按钮在闪动,单击开始按钮就会有小蛇出来,你需要马上操作它去吃食物,否则小蛇碰到边缘就会死掉。

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

程序运行后视频演示:

发表在 turtle | 标签为 , , | 留下评论

少儿python编程之简易太空射击小游戏

这是用海龟作图模块制作的,为方便学习python而设计的简易小游戏。程序运行后,在太空中有一小广块,还有一个小箭头。
箭头代表自己方,目标是摧毁小方块,用键盘的左右键能改变箭头的方向,配有声音效果。碰撞检测用的是海龟对象的distance命令,
当两个角色的距离小于某一个数值时,认为它们相撞,让它们一起消失。

#下面是python太空射击简易小游戏源代码示例:

  

""" 064_简易射击小游戏二.py """
from winsound import PlaySound,SND_ASYNC
from turtle import *
from random import randint
from time import sleep
碰撞声音 = 'sound.wav'
发射声音='fashe.wav'

方块=Turtle(visible=False)
方块.shape("square")
方块.pencolor("cyan")                #设定方块的画笔颜色为青色,在这里相当于边框颜色
方块.fillcolor("white")              #设定方块的填充颜色为白色,相当于方块的颜色
方块.penup()
方块.goto(randint(-200,200),randint(0,200)) #移到一个随机位置
方块.showturtle()                    #显示出方块来
屏幕=方块.getscreen()
屏幕.bgpic("背景.png")                #背景可以用一个海龟随机打点实现,这做为练习。
屏幕.title("简易射击小游戏教学第二部分") 
屏幕.delay(1)
箭头初始位置=(0,-200)                 #由于箭头发射后需要再次回到初始位置,所以应该设置一个元组
箭头=Turtle(visible=False)
箭头.shape("arrow")
箭头.penup()
箭头.pencolor("yellow")
箭头.fillcolor("white")
箭头.goto(箭头初始位置)
箭头.showturtle()
箭头移动次数=35 

def 发射():
    global 箭头移动次数 
    if 箭头移动次数==35 :        
        箭头.goto(箭头初始位置)
        箭头.showturtle()
        PlaySound(发射声音, SND_ASYNC) #异步播放音效
        移动箭头()
def 移动箭头():
    global 箭头移动次数
    
    if 箭头移动次数>0:
        箭头.fd(20)
        #以下为主要增加的代码
        if 箭头.distance(方块.pos())

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , | 留下评论

少儿python编程之用海龟模块做弹球动画

我们可以用海龟画图来做弹球动画,在海龟模块中Turtle()这个命令实际的动作是类产生一个对象,我们可以用它来建立‘角色’。
用对象的shape()方法改变它的图片。所谓对象的方法,是属于对象的函数,只有对象才能调用它。在程序中,我们新建了一个x速度和一个叫y速度的变量。
它们用来做小球每次在水平和垂直方向移动的距离,每次移动的距离越长,速度好像就越快。

#下面是 源代码示例:

  
""" 062_弹球动画.py
    海龟本身的图形有“arrow”, “turtle”, “circle”, “square”, “triangle”, “classic”. 这几种。
    分别是:箭头,海龟,圆形,方形,三角形,经典形状。
    本节课,我们把小海龟的形状改变为圆形,让它像一个弹球一样在屏幕里弹来弹去。
"""
from winsound import PlaySound,SND_ASYNC   #从winsound模块,导入播放声音的命令和一个用于异步播放的常量。
from turtle import *
from random import randint
from time import sleep

碰撞声 = 'sound.wav'
球=Turtle(visible=False)           #新建海龟,让它的可见属性为False,即一出世是不可见的。
                
球.shape("circle")                 #改变‘球’对象的形状为圆形                
球.showturtle()                    #显示出来
w,h=window_width(),window_height() #获取屏幕的宽度和高度,分别赋值给w,h变量。
x速度=randint(-20,20)              #x速度是每次移动的水平距离
y速度=randint(-20,20)              #y速度是每次移动的垂直距离

球.penup()
while True:
    球.goto(球.xcor()+x速度,球.ycor()+y速度)    #球.xcor()能获取当前球的水平坐标,球.ycor()能获取当前球的垂直坐标
    #经过上一句后,球的水平位置增加了 x速度  的距离,球的垂直位置增加了  y速度的距离
    
    
    if 球.xcor()>w/2 or 球.xcor()<-w/2: x速度=-x速度 PlaySound(碰撞声, SND_ASYNC) #异步播放音效,这就不必等到声音播放结束后才能运行下面的代码。 if 球.ycor()>h/2 or 球.ycor()<-h/2:
        y速度=-y速度
        PlaySound(碰撞声, SND_ASYNC) #异步播放音效

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , , | 留下评论

少儿python编程之给图像添加文字

在python中图像处理模块的名字已经改为pillow即枕头模块。安装好pillow模块后,要打开图像需要导入Image类。
如果还要修改图形对象,比如在图像上写上自己的签名,那么需要导入ImageFont和ImageDraw类。
ImageFont是创建字体样式,ImageDraw用来在图像上创建2D绘图界面,最后保存图像即可。

#下面是的源代码示例中,#号后面是注释说明文字,有一些python基础的可以看懂:

  

""" 061_给图像添加文字.py
    修改图像,给它添加文字 """

from PIL import Image, ImageFont, ImageDraw   #从PIL模块中导入三个类
图象 = Image.open('文革照.jpg')               #载入图片
w, h = 图象.size                              #获取图片宽度和高度
#图像是以最左上角的坐标为(0,0)
#往右为x坐标增加,往下为y坐标增加

x坐标 = 0.02*w                               #x坐标为图像宽度的2%处,1000,20
y坐标 = 0.02*h                               #y坐标为图像高度的2%处,假设图像的高度也是1000,那么y坐标=20

字体样式 = ImageFont.truetype('C:\\windows\fonts\\simhei.ttf', 40) #载入数值的字体及大小
文字='星空培训首创python创意编程培训'
draw = ImageDraw.Draw(图象)                  #创建2D绘图界面
 
                                             #在2D绘图界面上写字
draw.text((x坐标, y坐标), 文字, font=字体样式, fill='red')

#参数说明
    #第一个参数是元组,表示要写的位置坐标,如可以直接写在(10,10)的位置也可以
    #第二个参数就是要写的字符串了,就是上面叫‘文字’的变量。
    #第三个参数就是字体的样式。
    #第四个参数是字体颜色,fill='red'即表示字为红色

图象.save('修改后的图形.png')                #保存生成图像即可,

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 pillow | 标签为 , , , | 留下评论

少儿python编程之海龟画图模块制作的动态情景配音画《春晓》

这是一个动态背景画,然后附上音乐和郎诵。运行结果是下面的视频:

在程序中需要准备gif动画,拆分成单独的图像,用pil模块拆也行。
然后用ontimer命令让背景轮换,接着就是播放音乐和用write写字了。

#下面是用海龟做图制作的动态情景配音画《春晓》源代码示例:

  

"""059_动态情景配音画《春晓》.py
"""
from winsound import PlaySound,SND_ASYNC
from turtle import *
from time import sleep  
音乐文件 = '春晓.wav'
小虹=Turtle()    
小虹.hideturtle()
屏幕=小虹.getscreen()    #得到小虹所在的画图屏幕,get是得到的意思,screen是屏幕的意思。
屏幕.setup(700,500)

图形=["下雨001.png","下雨002.png","下雨003.png","下雨004.png"]
指针=0
def 动态背景():
    global 指针
    屏幕.bgpic(图形[指针])
    指针=指针+1
    指针=指针 % 4
    屏幕.ontimer(动态背景,100)
    
动态背景()

PlaySound(音乐文件, SND_ASYNC) #异步播放音效
小虹.penup()
小虹.goto(-100,100)
小虹.pencolor("cyan")
小虹.write("春晓",font=("",24,"bold"))
小虹.sety(小虹.ycor()-50)
sleep(1)
小虹.write("---------孟浩然",font=("",14,"bold"))
小虹.sety(小虹.ycor()-50)
sleep(1)
小虹.write("春眠不觉晓",font=("",24,"bold"))
小虹.sety(小虹.ycor()-50)
sleep(1)
小虹.write("处处闻啼鸟",font=("",24,"bold"))
小虹.sety(小虹.ycor()-50)
sleep(1)
小虹.write("夜来风雨声",font=("",24,"bold"))
小虹.sety(小虹.ycor()-50)
sleep(1)
小虹.write("花落知多少",font=("",24,"bold"))

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , , , | 留下评论

少儿python编程之海龟画螺旋转小广块彩图

这是一个画彩色图形的案例,本程序还可以进行优化,请分析代码!

#下面是python画螺旋转小广块彩图源代码示例:

  
"""058_螺旋彩图.py
 本节课我们主要理解代码中名为指针的变量的作用。 
"""
from turtle import *
def 画正方形(龟,边长):
    龟.pendown()
    龟.begin_fill()
    for i in range(4):
        龟.fd(边长)
        龟.right(90)
    龟.end_fill()
    龟.penup()

颜色表=('red','orange','yellow','green','cyan','blue','purple')

t=Turtle()    #创建了一只海龟,默认方向为向上,即朝向正北方向,方向度数为0度。
t.speed(0)

屏幕=t.getscreen()    #得到t的画图屏幕对象,

屏幕.bgcolor("black")    #给屏幕设定背景颜色为黑色。

指针=0
for i in range(150):
    t.pencolor(颜色表[指针])
    t.fillcolor(颜色表[指针])
    画正方形(t,10)
    t.fd(15+i/2)
    t.right(28)
    指针=指针+1             #颜色表的长度是7,当指针到了7的值是,又变成0了
    if 指针==len(颜色表):   #指针的值为0,1,2,3,4,5,6,0,1,2,3,4,5,6,0,1,2,3....
        指针=0              #难道每次都要重新计算一下颜色表的长度?

    


运行结果会画如下图形:

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , | 留下评论

少儿python编程之split和join分开与连接命令教程

split把序列分开成列表,join用某种字符(空的也行)连接列表,它们执行的是相反的操作。

#下面是python的split和join用法源代码示例:

  

"""057_分开与连接.py
   几乎每种计算机语言都有split或类似的命令,split是分开,劈开的意思。
   它能让一个字符串以某种字符串分隔,返回的是列表。
   join就是连接的意思,这个命令能连接一个序列。join返回的是字符串,split和join的作用刚好相反。

   我们还要学习replace命令,这也是一个每种计算机语言都有的命令。
   replace是替换的意思,它能把字符串中的某些字换成其它字符。
   
"""

字串1="我的同学的朋友的妹妹是我的好朋友"
表=字串1.split('的')           #以 '的'字分开 字串1,得到一个列表。
print(表)

s='的'.join(表)                #用 '的'来连接 表,得到一个字符串。
print(s)

点='.'
域名="www.HaLiFa.net"  
print(点.join(域名.split(点)))


毛毛的作文="""今天我去了外婆家,先美美的吃了一顿,然后快快乐乐地玩了2个小时,最后看了会书竟然睡着了。
当我醒来的时候,发现我在自己的家里,原来外婆趁我睡着的时候,小心地抱着我送回家了。
因为我家离外婆家很近。"""

新作文=毛毛的作文.replace('外婆','奶奶')
新作文=新作文.replace('我','小明')
print(新作文)

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 杂谈 | 标签为 , , | 留下评论

少儿python编程之海龟画图事件与按键检测

python海龟画图模块的事件与按键检测是tkinter事件与按键检测的封装。提供了诸如定时器等功能,这可以做为伪多线程,能让我们编制小动画,小游戏!

#下是pyhton的turtle模块事件与按键检测例子,:

  
"""055_事件与按键检测.py
  我们以前学过,一个函数的参数可能是字符串,数值等。其实函数的参数也可能是另一个函数的名称。
  我们要学习下‘事件’,所谓'事件'就是当发生了什么事情时再去执行动作这一整个过程。
  我们需要定义是事件所生的动作是什么,也就是要定义一个函数。
  让这个函数来执行事件的动作。
  
  在海龟画图里也有事件,比如我们按了某个键,鼠标单击了屏幕对象,这都是事件。
  屏幕有onkeypress事件命令,onkeypress就是'当按键'的意思。
  当我们按了某个键的话,就执行事先设定好的动作,
  这里,动作是一个我们自己定义的函数。
"""
from turtle import *          #从海龟模块导入所有命令

小龟=Turtle()
屏幕=小龟.getscreen()
#事先设定好4个动作,也就是定义4个函数
def 前进():
    小龟.fd(20)
def 倒退():
    小龟.fd(-20)
def 右转():
    小龟.right(5)
def 左转():
    小龟.left(5)           #left是向左的意思,这里是小让龟向左旋转
    

#下面这句命令的意思是,如果我们按了向上箭头↑,那么就调用 前进 这个函数    
屏幕.onkeypress(前进,"Up")   #onkeypress命令的参数为一个不带参数的函数和按键
屏幕.onkeypress(倒退,"Down")
屏幕.onkeypress(右转,"Right")
屏幕.onkeypress(左转,"Left")

屏幕.listen()            #onkeypress设定好后,一定要用listen()侦听
 
屏幕.exitonclick()       #鼠标单击屏幕,结束海龟画图 exit结束 onclick 当单击

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , , , | 留下评论

少儿python编程之海龟画图挑错练习

#下是看一个错误的python程序,先在自己头脑里运行一下,看能挑出多少错误!:

  
"""054_挑错练习.py
   本程序有很多错误,请一一找出,并给每一行写出注释。

"""
form turtle import * 
小球=turtle(visible=False)
小球.shape("circle")
小球.showturtle
宽度=window_width()
高度=window_height()
计数器=0
小球.speed(0)
小球.fillcolor(yellow)
小球.pencolor('red')
小球.begin_fill()
while true:
    小球.fd(200)
    小球.left(170)
    计数器=计数器+1
    if 计数器>60
    break

小球.hideturtle

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , , | 留下评论

少儿python编程之海龟读诗

我们可以通过海龟的xcor()和ycor()获取x,y坐标,也能通过setx()和sety()设置海龟的x,y坐标。
goto()命令也能设置x,y坐标。write命令能让海龟对象在屏幕上写字,参数是字符串和一个元组,元组的内容是字体的种类,大小,样式,用法如下:

海龟对象.write("少儿编程吧网址是www.scratch8.net",font=('黑体',18,'normal'))

字体种类即是黑体还是微软雅黑等字体,不写也行,python会聪明地选择默认的字体。
最后的normal代表普通的字体样式。

#下面是python的海龟类xcor()和ycor()获取x和y坐标与write源代码示例:

  
"""053_海龟读诗.py
  本节课我们学习write命令,以及如何获取海龟的x坐标和y坐标命令。
  write命令是写命令,能让海龟在画图屏幕上写字,不需要落笔。
  用法为:
  write(要写的内容字符串,font(字体名,大小,样式))
  字体名 是一个字符串,可以留为空字符串,如果这样的话,python会用默认的字体。
  大小 是一个数值就是表示所写的字的大小
  样式 也是一个字符串,表示是正常(normal),粗体(bold),还是斜体(italic)
  海龟的xcor()和ycor()能分别获取它的x和y坐标。

"""

from turtle import *          #从海龟模块导入所有命令

诗的内容=list()               #新建空的列表,叫  诗的内容
try:
    文件=open("忆江南乡.txt") #打开文件,返回到叫 文件 的文件对象
    for 行 in 文件:           #对于文件中的每个项目,都添加到列表里
        诗的内容.append(行)
    文件.close()              #关闭文件

except:                       # try语句组里发生了意外的话,except进行出错提示
    print("文件不存在或损坏!")

if len(诗的内容)>0:          #如果 诗的内容 这个列表的长度是大于0,说明读入了内容
    小龟=Turtle()            #那么 就可以新建一只小龟了。
    屏幕=小龟.getscreen()    #得到小龟的画图屏幕
    屏幕.bgcolor("cyan")     #设定画图屏幕背景色为青色,纯粹为了增加点色彩
    小龟.pencolor("blue")    #设定小龟的画笔颜色为蓝色
    小龟.penup()             #把小龟的笔抬起来,因为用write命令不需要落笔
    小龟.goto(-200,100)      #确定开始写字的坐标
    for 项目 in 诗的内容:    #对于列表中的每个项目,都把它写出来,然后移到下一行
        小龟.write(项目,font=("",24,"italic"))
        小龟.goto(小龟.xcor() ,小龟.ycor()-50)
        # xcor()获取小龟的x坐标,ycor()获取小龟的y坐标
    小龟.hideturtle()        #把小龟隐藏

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , , | 留下评论

少儿python编程之数据分析启蒙

在海量的互联网数据中,如果不知道舍取提练数据,那你将被消息淹没。下面的代码打开一个文件,统计里面有多少个少儿编程吧这个词语。

"""052_数据分析启蒙.py
  数据分析包含了对数据进行提取,统计等内容,现在我们来打开一个文件,统计出它里面有多少个‘少儿编程吧’这个词语。  
"""
数量=0
文件名="一篇文章.txt"
try:                        #对属于自己的语句组进行试错
    f=open(文件名,'r')      #打开文件,返回文件对象 为 f
    for 每行 in f:          #对于 f 中的每一行
        for 字 in 每行:     #对于每行中的每一个字
            if 字=='少儿编程吧':
                数量=数量+1
    print("\'" + 文件名 + "\'包含" + str(数量) + "个\'少儿编程吧\'词语")
    f.close()
except:
    print("出错啦,文件不存在或文件损坏等原因导致。")
发表在 turtle | 标签为 , , , | 留下评论

少儿python编程之海龟画图保存为矢量图像

python的海龟画图用到了tkinter模块,所以能调用画布保存海龟所画的图形。海龟的画图屏幕由画布和可滚动条等组成。

#下面是海龟画图后再把图像保存为矢量图像的源代码:

  
"""051_保存图像.py
  我们可以用小海龟画图,画了图之后可以用截屏等方式保存图像。
  我们其实可以用python自带的命令来保存图像,这样才原汁原味。
  本课把第50课的程序稍微改一改,调用相关命令保存图像。
"""
from turtle import *
from random import choice

小龟=Turtle()
小龟.pensize(3)

def 画多边形(龟,边长,边数):
    for i in range(边数):
        龟.fd(边长)
        龟.right(360/边数)


颜色表=('red','orange','yellow','green','cyan','blue','purple','black','gray','brown')
屏幕=小龟.getscreen()    #得到小龟的画图屏幕

for i in range(3,30):   #i依次获取3,4...29的数值
    小龟.pencolor(choice(颜色表))
    画多边形(小龟,30,i)
    
小龟.hideturtle()
画布=屏幕.getcanvas()       #把屏幕图像输出之前要获取画布这个对象
                            #getcanvas()是得到屏幕的画布命令
画布.postscript(file = "我在星空培训学python画的图像.eps")

#postscript()命令能把图形输出为矢量格式,可以用photoshop等图像软件打开编辑。

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , , , | 留下评论

少儿python编程之画正多边形代码优化教程

我们这里有一段程序,要求把它缩短,程序是这样的:

"""050_找规律优化程序.py
  在本课中, 我们把代码进行修改。  
"""
from turtle import *
from time import sleep

小龟=Turtle()
小龟.speed(1)

for i in range(3):
    小龟.fd(30)    
    小龟.right(120)

sleep(2)
小龟.clear()      
for i in range(4):
    小龟.fd(30)    
    小龟.right(90)

sleep(2)
小龟.clear()            #清除屏幕图像
for i in range(8):
    小龟.fd(30)    
    小龟.right(45)

sleep(2)
小龟.clear()
for i in range(16):
    小龟.fd(30)    
    小龟.right(22.5)

sleep(2)
小龟.clear()
for i in range(36):
    小龟.fd(30)   
    小龟.right(10)

我们从代码看到有一只小海龟首先重复3次画了三角形,然后是重复4次画了正方形,接着是8次,16次,36次,都是画正多边形。所以我们应该定义一个画正多边形的函数。 为了再次缩短代码我们可以把这些重复的次数放到一个列表里头,然后依次把列表里的迭代出来,每迭代出一次就画一个正多边形。下面是优化缩短后的代码:

"""050_找规律优化程序.py
  在本课中, 我们把代码进行修改。  
"""
from turtle import *
from time import sleep

小龟=Turtle()
小龟.speed(1)

def 画多边形(龟,边长,边数):
    for i in range(边数):
        龟.fd(边长)
        龟.right(360/边数)

表=[3,4,8,16,36]
for 数 in 表:
    画多边形(小龟,30,数)
    sleep(2)
    小龟.clear()
发表在 turtle | 标签为 , , , | 留下评论

少儿python编程之练习九正方形区域打点实验参考答案

题目是编程让海龟在边长为200的正方形区域打彩色的圆点。

#下是参考答案:

  
"""049_练习九.py
编制程序让10只海龟在边长为200的正方形区域里随机移动,移动到新的地方就打一个点。
打点的命令是dot(),参数是直径。如 dot(10)能打一个直径为10像素的点。
程序中可设置隐藏海龟,这样运行会更快。

"""

from turtle import *

from random import choice,randint    #choice是从序列中随机选择一个项目的命令

颜色表=('red','orange','yellow','green','cyan','blue','purple','black','white','gray','brown')

海龟窝=[]
for i in range(10):
    海龟窝.append(Turtle())
    
for 龟 in 海龟窝:
    龟.hideturtle()

for i in range(100):
    for 龟 in 海龟窝:        #让每只海龟都goto到新的地方打一个点。
        龟.pencolor(choice(颜色表))   #从颜色表中随机选择一个字符串做为颜色值
        x=randint(-100,100)
        y=randint(-100,100)
        龟.goto(x,y)
        龟.dot(10)

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , , , | 留下评论

少儿python编程之海龟在屏幕范围内随机移动

屏幕的宽度和高度可以通过window_width()和window_height()求出,利用randint能产生不超过屏幕边界的整数,这样就能让海龟在屏幕范围内随机移动。

#下是再看一个python让海龟在屏幕范围内随机移动的源代码:

  
"""048_屏幕范围随机移动.py
   让小海龟在屏幕范围内随机的移动,画出彩色线条。
  
"""
from turtle import *
from time import sleep
from random import choice,randint    #choice是从序列中随机选择一个项目的命令

颜色表=('red','orange','yellow','green','cyan','blue','purple','black','white','gray','brown')

小虹=Turtle()            #新建海龟对象
 
屏幕=小虹.getscreen()    #得到小虹所在的屏幕对象

w=window_width()
h=window_height()
屏幕.title("画彩色线条小程序,当前画图屏幕分辨率:" + str(w) + "," + str(h))
屏幕.bgcolor("black")

for i in range(100):
    小虹.pencolor(choice(颜色表))   #从颜色表中随机选择一个字符串做为颜色值
    x=randint(-int(w/2),int(w/2))   #如果W是720的话,那么x的范围就是 -360到360
    y=randint(-int(h/2),int(h/2))   #由于randint 的参数要为整数,所以要转换为int
    小虹.goto(x,y)
    sleep(0.1)

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , , , | 留下评论

少儿python编程之海龟画图窗口屏幕边界

当我们新建一只海龟,海龟画图窗口就自动崩出来了。这窗口的宽度和高度是多少呢?今有window_width()和window_height()两条命令可以解决此事。

windows就是窗口,width就是宽度,height就是高度的意思。英文单词还是要记住一些的。

#下是python源代码,关于获取海龟画图屏幕窗口大小的:

 
"""047_屏幕边界.py
这节课我们明确一下海龟画图屏幕最左边,最右边,最上边,最下边的边界值。
  
"""
from turtle import *
from time import sleep  

小虹=Turtle()    
 
屏幕=小虹.getscreen()    #得到小虹所在的画图屏幕,get是得到的意思,screen是屏幕的意思。

屏幕.bgpic("xy坐标轴.gif")
w=window_width()
h=window_height()
屏幕.title("屏幕的宽度和高度分别为:"+ str(w) + "," + str(h))

小虹.penup()                  #抬笔,把笔拿起来,这样移动就不会留下轨迹了。
sleep(3)
小虹.goto(-w/2,0)          #移到最左边
屏幕.title(str(-w/2) + ",0")

sleep(3)
小虹.goto(w/2,0)           #移到最右边
屏幕.title(str(w/2) + ",0")

sleep(3)
小虹.goto(0,h/2)           #移到最上边
屏幕.title("0," + str(h/2))

sleep(3)
小虹.goto(0,-h/2)           #移到最下边
屏幕.title("0," + str(-h/2))

sleep(3)
小虹.goto(0,0)              #回到中心点
屏幕.title("0,0")
 

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , | 留下评论

少儿python编程之函数的返回值

前面我们提到过函数有返回值。这就是函数‘辛勤工作后’给你的结果。当然它可不一定会给你这个结果。现在明确一下,函数的返回值可以是一个字符串,也可以是一个整数等对象,甚至另一个函数。如果函数中没有return这条返回语句,默认返回的是None,即空。
#下面是函数返回值一例:

"""046_函数的返回值.py

   函数是有返回值的,什么是函数的返回值呢?
   可以理解为函数经过一系列的运算,最后给出一个答案,
   把这个结果传递给你,怎么传递?用的是return语句,并且函数运行到这里就结束。
   
"""
from random import randint

def 加法(x,y):   #定义加法函数,并定义两个形式参数。
    c=x + y
    return c     #如果不写return语句,函数也会返回值,返回的是空值 None

a=randint(1,100)
b=randint(1,100)
结果=加法(a,b)   #实际参数
print(结果)


def 连接(s1,s2):
    return str(s1) + str(s2)

print(连接('abcd','3721'))

发表在 python | 标签为 , | 留下评论

少儿python编程之龟窝连续画正方形

下面的代码是上一节课代码的升级版本,因为上一节课的代码有重复的段落,没必要这么长,我们完全可以用for循环语句缩短代码。

#下是缩短后的代码

  
"""045_缩短044代码.py
  其实第44课的代码还是有点长,如果有几十只海龟呢,那么也要很长的代码。
  我们可以看下044那个py文件,有很多重复的代码。

"""
from turtle import *
from time import sleep

def 画正方形(海龟,边长):   #定义一个函数,定义两个形式参数。
    海龟.speed(1)
    for j in range(4):
        海龟.fd(边长)
        海龟.right(90)
i=0
龟窝=(Turtle(),Turtle(),Turtle(),Turtle())
print(龟窝)

input("按回车键让四只海龟依次连着画4个正方形。")

for 龟 in 龟窝:              #对于龟窝中的每只龟
    龟.right(i*90)           #首先把这只龟旋转90*i度,然后连着画四个正方形。
    for j in range(4):
        画正方形(龟,50)      #调用画正方形函数,把实际参数传递给形式参数。
        龟.fd(50)
    i=i+1
    sleep(2)                 #等待2秒钟,纯粹是为了方便本程序讲解
    #一只龟画完了画个正方形后,就轮到下一只龟画正方形了。

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , | 留下评论

少儿python编程之函数初步

函数,初次接触过的可能觉得很高深的样子。我们来个比喻。

牛吃草,挤出的是奶,那么我们输入的是草,输出的是奶,牛相当于生物工厂,牛也就是一个函数。

把一个数据变成另外的数据。把一个对象变成另外的对象。或者它就是画一幅图像,或写一幅春联。

在计算机语言中,函数就承担这种功能。它也可以是一个小模块,像个小积木,有特定的用途。

现在程序员编程,大多数都是在调用其它程序员事先写好的各种函数,好像在搭积木。

像 print命令就是一个函数,我们给它输入参数,它就能打印出来数据。我们也不知道它是怎么打印的。

有些事情,我们不必要知道,天下事情如此之多,不必要全都知道,都去了解下反而是浪费生命!

还有导入海龟模块后用Turtle(),能生成一只海龟,我们现在根本不要了刨根问底问这海龟到底是怎么来的。

好了,怎么定义函数呢?用def关键词,它来源于英文define的前三个字母,意思就是定义!

def后面是空格,然后是函数的名称,接着是小括号,里面写几个变量,由于是定义函数,变量只是形式上的。

我们把它们叫形式参数。当函数被调用时,参数们才会得到实际的值。最后不要忘了:冒号。

定义函数语法如下:

def 写春联(题目):
    语句一
    语句二
    语句三
    return 春联

上面我们定义了一个叫写春联的函数,它有一个参数为题目,这是一个字符串参数。

只要我们输入春联的题目,这个函数就会聪明地给你作出一幅春联来,最后有个return是把春联返回给你。

怎么使用呢?假设我想生成一幅关于鸡年的春联,那么我就这样使用函数:

横批="金鸡贺岁"
我的春联=写春联(横批)

上面,我们调用写春联的函数,让它写一幅春联,然后我就让它存储在我的春联这个变量里。刚才不是说函数的参数是题目吗?怎么又变成横批了?

在定义函数的时候,它的参数只是形式上的。当我们调用函数的时候,会把横批的值赋给题目的。所以名字当然可以不一样。

#下是再看一个python函数的例子:

  
"""044_函数初步.py
   其实我们学的print、int等这些都是些函数,这是python早就定义好了的。
   我们也能自己定义一个函数,“函数”让程序记住我们写好的代码并重复使用。
   如果不用函数,程序可能很长,也不方便维护。
"""
from turtle import *
def 画正方形(海龟,边长):   #定义一个函数,定义两个形式参数。
    海龟.speed(4)
    for j in range(4):
        海龟.fd(边长)
        海龟.right(90)

小花=Turtle()
for i in range(4):
    画正方形(小花,50)      #调用画正方形函数,把实际参数传递给形式参数。
    小花.fd(50)

小艳=Turtle()
小艳.right(90)
for i in range(4):
    画正方形(小艳,50)
    小艳.fd(50)

小彩=Turtle()
小彩.right(180)
for i in range(4):
    画正方形(小彩,50)
    小彩.fd(50)

小丽=Turtle()
小丽.right(270)
for i in range(4):
    画正方形(小丽,50)
    小丽.fd(50)

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 标签为 , , | 留下评论

python少儿编程之open读写文件

以前我们用basic语言,说它是简单的适合于入门的计算机语言,而python更胜一筹。python打开文件只要一个简单的open命令即可。因为它的设计哲学就是要‘简’。
open即打开的意思,你要打开一个文件,那就open呀,顾名思义。

#以下是python打开文件或建立文件写文件的例子:

  
"""043_读写文件.py
   文件是可以读取的,即把文件的内容呈现出来,我们可以看得到具体内容,这叫读文件。
   读文件用open命令,用法是:open(文件路径,模式)
   两个参数都是字符串,其中模式有r模式,这是只读模式,也可以是w模式,这是写模式。
   还有a模式是追加模式,即我们可以先打开文件,然后往文件末尾添加内容。   
   如果不写第二个参数,那么默认为读文件。
   open命令读文件返回的是文件对象,它是可迭代的。也就是说,
   可以用for循环把文件里面的内容一项一项的赋值给一个变量。那么这个‘一项’是个什么呢?
   是一行,我们还是用实例来验证吧。
"""

f=open("班级号.txt",'r')  #如果当前目录下有班级号.txt文件,那么会打开它,否则出错。
for 每行 in f:            
    print(每行)
f.close()                #读取完文件内容后,要关闭这个文件。


f2=open("今天的事情.txt",'w')                  #用写模式打开文件。
f2.write("练习python编程。\n")                 #写入一行到文件里。
f2.write("到 http://www.HaLiFa.net 领些内部优惠券。\n")
f2.write("领了后再到淘宝购物。\n")
f2.close()

input("按回车键继续运行程序...")  #程序处于等待状态,直到我们按回车键。

f3=open("今天的事情.txt",'a')   #a是追加模式,如果写w,那么会把以前的内容全部覆盖。
f3.write("购了物后再练习python编程。\n")  #如果是重要文件,那文件内容就丢失了。
f3.close()

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 标签为 , , , , | 留下评论

python少儿编程之if多条件选择语法示例

在其它计算机语言有select case或switch等关键词对多种条件进行选择,然后执行不同的代码。可是,在python中,却没有这样的关键词。但是可以用if .. elif..elif…做同样的事情。以下是一个例子:

"""042_多条件选择.py
  我们做事会根据不同的情况选择不同的方法,当有很多种不同的情况时就需要准备好很多种对应的方法。
  注意每条语句的空格缩进。每条语句在属于自己的语句组中缩进的空格数是一样的,否则会出错或程序乱套。

"""
while True:
    try:                     #进入试错过程,有语句出错程序即会跳转到excel语句组执行。        
        x=int(input("请输入考试得分:"))
        if x>=90:
            print("你的成绩是优秀。")
        elif x>=80:
            print("你的成绩是良好。")           
        elif x>=60:
            print("你及格了,继续努力!")
        else:
            print("本次考试你没有及格!")
        break
    except:
        print("输入错误,请重来!")

print("程序运行结束。")
发表在 python | 标签为 , , , | 留下评论

python少儿编程之练习八输入数值求和

练习八参考答案如下:

"""041_练习八.py
   编制程序要求输入一些整数,以输入空字符串为结束,即直接敲回车以示所有的数据输入完毕。
   打印出所输入数据的和。
   要求:如果用户乱输入,程序也能正确运行下去。我们可以这样设计:
   一旦用户输入的不是整数,我们就把这个数设定为0,并且给出提示:
   输入的不是整数,自动把它变为0了。
"""


和=0
while True:
    x=input("请输入数据:")
    if x=='':break
    try:            #进入测试语句组,测试会不会出错,一旦某条语句出错,跳转到except语句组
        x=int(x)
    except:
        x=0
        print("您所输入的不是一个整数,程序自动把它变为0了。")
    和 = 和 + x


print("你所输入的所有整数的和为:",str(和))
发表在 python | 标签为 , , | 留下评论

少儿python编程之try..Except异常试错处理

我们要打开一个文档,这个文档被损坏了,是打不开的,我们的python程序运行到这里就会崩溃!

当然,我们可以事先进行判断,用其它代码判断文档是否损坏,是否还存在等等,把一切可能出现的情况都预测好,然后再打开,这样才万无一失。

可是,经常会有意外发生,哪会事先都考虑得这么周到。python充许我们不管三七二十一,你可以先尝试着打开,一旦出错了,那么python可以捕获到此错误,然后python立即跳转到你事先安排好的代码段去执行。

这有点像亡羊补牢,未为晚也! 其语法是把你要试图尝试的代码放到try:语句组中,出错处理的语句组放到except:语句组中。try在英文中就是尝试的意思,except在英文中就是异常,除非等的意思。

语法如下:

try:
    语句一
    语句二
    语句n
except:
    语句一
    语句二
    语句n

当python程序运行到try这里时,当然它会运行属于try的语句组,只要这些语句组中的某一句出错了,那么程序马上跳转到except语句组,执行那里的代码。

这是一种容错机制,可以让我们的python程序更加健壮,下面是一个例子,首先要求输入宽度和高度,你可以随便输入一个数据,字符串都可以,看程序会不会崩溃?

仔细分析,然后新建一个py文件,运行,看和你想像的是不是一样?

  
"""040_试错.py
  如果我们要把字符串转换为整数,那么这个字符串必需‘长’得像整数。否则就会出错。
  我们来试一下。

"""
from turtle import *

w=input("请输入你想设置的屏幕宽度:")
h=input("请输入你想设置的屏幕高度:")


try:                #试错  ,意思是说如果下面的语句组中某条语句出错了,那么就会立
    w=int(w)        #即跳转到except语句组,运行那里的语句。
    h=int(h)        
    
except:             #出错了,发生意外了,叫异常处理
    w=300
    h=300
    
setup(width=w,height=h)         #设置海龟画图屏幕的宽度和高度,setup就是设置的意思。

海龟=Turtle()    #创建了一只海龟,默认方向为向上,即朝向正北方向,方向度数为0度。
 

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 标签为 , , , | 留下评论

少儿python编程之交互与海龟画图屏幕设置

人类自己发明了计算机,让计算机和人类可以互动。常见的对话框就是一种交互形式。本课主要讲input和setup命令。

#以下是input和setup命令python源代码示例:

  
"""039_交互与屏幕设置.py
   人和计算机交互可以通过键盘输入,鼠标单击也是一种交互。通过麦克风跳舞毯等都是和计算机进行交互。
   交互是一种信息的双向传输,像是我们和计算机在交谈一样。
   现在我们学习input命令,通过键盘输入字符串和计算机交互。
   并且setup命令 ,它能设置屏幕的宽度和高度,用法为:setup(width=数值,height=数值)
   我们用过屏幕的title()命令,它能设置屏幕的标题。
   在屏幕上,其实会有画布的,有时还会出现滚动条。我们用getcanvas()命令得到屏幕的画布。
   画布是一个对象,海龟画图其实是在画布上画的。
   window_width()和window_height()能获取屏幕的宽度和高度,方便我们引用。
   

"""
from turtle import *

w=input("请输入你想设置的屏幕宽度:")
h=input("请输入你想设置的屏幕高度:")

if w=='':w=300                 #如果w为空字符串,表示没有输入,那么我们让w=300
if h=='':h=300

w=int(w)                        #把字符串转换为整数。
h=int(h)

setup(width=w,height=h)         #设置海龟画图屏幕的宽度和高度,setup就是设置的意思。

海龟=Turtle()    #创建了一只海龟,默认方向为向上,即朝向正北方向,方向度数为0度。

 
屏幕=海龟.getscreen()    #得到海龟1号的画图屏幕,get是得到的意思,screen是屏幕的意思。

画布=屏幕.getcanvas()    #其实屏幕上有画布,海龟做画最终是在画布上画的。
                         #还有滚动条,我们知道这两点就行了。
                         #canvas是画布的意思。

屏幕.title(str(window_width()) + "," + str(window_height()))  #在屏幕的标题栏里显示抬头。

运行后,首先需要输入屏幕的宽度和高度,然后海龟画图窗口才会出现。

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 标签为 , , | 留下评论

少儿python编程之练习六参考答案

本练习是要求用海龟作图画一个三角形并填充颜色,不限定具体是哪种类型的三角形。

#以下是引蛇出洞系列微课练习六参考答案:

  
"""038_练习七.py
 编制程序画一个三角形,每条边的颜色是随机的,然后填充此三角形,最后隐藏海龟。
附:
颜色表=('red','orange','yellow','green','cyan','blue','purple','black','white','gray','brown')
"""
from turtle import *
from random import randint
颜色表=('red','orange','yellow','green','cyan','blue','purple','black','white','gray','brown')

海龟=Turtle()     

随机色=颜色表[randint(0,len(颜色表)-1)]  #在颜色表中随机选择一种颜色
海龟.fillcolor(随机色)      

海龟.begin_fill()

随机色=颜色表[randint(0,len(颜色表)-1)]
海龟.pencolor(随机色)
海龟.goto(100,100)

随机色=颜色表[randint(0,len(颜色表)-1)]
海龟.pencolor(随机色)
海龟.goto(100,0)

随机色=颜色表[randint(0,len(颜色表)-1)]
海龟.pencolor(随机色)
海龟.goto(0,0)

海龟.end_fill()  
 
海龟.hideturtle()     #隐藏海龟

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 标签为 , , | 留下评论

少儿python编程之画笔颜色

python海龟画图的画笔颜色可以用颜色字符串来表示,也能用rgb三原色组合来表示,这里讲述的是用颜色字符串表示一种颜色。

值得注意的是用颜色字符串中的gray能表示灰度,值从0到100,即”gray0″,”gray1″,”gray2″…..

#以下是python画笔颜色的例子:

 
"""037_画笔颜色.py
    海龟的画笔是可以变色的。如果画了封闭的图形,还能设定填充的颜色。
    如果要设定画笔的颜色,我们可以用python预定义的颜色字符串,如要设定画笔的颜色为红色的话,是这样设置的。
    pencolor('red')
    在我们的课程中,我们只要使用下面的颜色字符串即可。
    'red','orange','yellow','green','cyan','blue','purple','black','white','gray','brown'
    我们可以直接使用颜色字符串。在本例中,我们把上述11个颜色字符串放到了一个元组中,以方便for循环使用。
"""
from turtle import *

#依次对应:红   橙       黄      绿      青      蓝     紫       黑     白      灰      棕
颜色表=('red','orange','yellow','green','cyan','blue','purple','black','white','gray','brown')
#为什么用元组的形式来存储颜色表呢,因为设定好了就不需要改变它的内容,所以用元组更适合。

t=Turtle()                   #创建了一只海龟,默认方向为向上,即朝向正北方向,方向度数为0度。
 
屏幕=t.getscreen()           #得到t的画图屏幕

屏幕.bgcolor("cyan")         #给屏幕设定背景颜色为青色。

t.pensize(6)                 #设定海龟t的画笔大小为6

for 颜色 in 颜色表:          #对于 颜色表 中的每种颜色 ,依次赋值给  颜色  这个变量。
    t.pencolor(颜色)   
    t.fd(20)
    

t.fillcolor(颜色表[5])       #设定填充颜色为 蓝色
t.begin_fill()               #画封闭图形之前,如果要填充颜色,则需要使用 begin_fill(),意为开始填充
t.circle(50)                 #画半径为50的圆形
t.end_fill()                 #画完了封闭的图形之后,前面使用了 begin_fill(),这里就要end_fill()
 
t.hideturtle()               #隐藏海龟t
 

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , | 留下评论

少儿python编程之坐标系统

python海龟画图坐标图是这样的,和数学直角坐标系一样。海龟通过唯一的坐标来确定位置。

#以下是python海龟画图坐标系统源代码例子:

 
"""036_坐标系统.py
   海龟的画图屏幕有着数学坐标系,海龟用坐标来表示它的精确的位置。
   表示海龟的坐标用(x,y)来表示,刚好和元组的表示方法一样。
   海龟在屏幕中央的坐标为(0,0),这是中心点坐标。
   海龟的x坐标表示的是离中心点的左右距离,当海龟在中心点右边的时候,它的x坐标是正数。
   当海龟在中心点左边的时候,它的x坐标是负数。
   海龟的y坐标表示的是离中心点的上下距离,当海龟在中心点上边的时候,它的y坐标是正数。
   当海龟在中心点下边的时候,它的y坐标是负数。
   
   
"""
from turtle import *
from time import sleep  #从时间模块里导入sleep延时等待命令,sleep在英文里是睡眠

t=Turtle()    #创建了一只海龟,默认方向为向上,即朝向正北方向,方向度数为0度。

 
屏幕=t.getscreen()    #得到t的画图屏幕,get是得到的意思,screen是屏幕的意思。

屏幕.bgpic("xy坐标轴.gif")    #给屏幕设定背景图片,bgpic是 背景图片 的意思
                              #需要事先把名为‘xy坐标轴.gif’的图片放到当前目录下。
t.pensize(5)                 #设定海龟t的画笔大小为5
t.goto(100,100)              #让海龟移到坐标为(100,100)的位置
屏幕.title(t.pos())          # t.pos()是获取海龟的坐标的方法, 返回的是一个元组。
sleep(2)

t.goto(100,0)                #让海龟移到坐标为(100,0)的位置
屏幕.title(t.pos())
sleep(2)

t.goto(0,100)                #让海龟移到坐标为(0,100)的位置
屏幕.title(t.pos())
sleep(2)

t.goto(0,0)
屏幕.title(t.pos())


少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , | 留下评论

少儿python编程之练习六参考答案

#以下是引蛇出洞系列微课练习六参考答案:

 
"""034_练习六.py

编制程序让海龟每隔0.5秒旋转1度,共转一圈。
接着,随机设定海龟的方向100次,每次设定后等待1秒钟。
要求要实时的在海龟画图屏幕的标题显示海龟当前方向度数。
最后,打印字符“程序运行完毕”。

"""
from turtle import *
from time import sleep
from random import randint

海龟1=Turtle()
屏幕=海龟1.getscreen()

for i in range(360):
    海龟1.right(1)
    屏幕.title(str(海龟1.heading()))
    sleep(0.5)


for i in range(100):
    海龟1.setheading(randint(1,360))
    屏幕.title(str(海龟1.heading()))
    sleep(1)

print("程序运行完毕")
    

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 标签为 , , | 留下评论

少儿python编程之设定海龟的方向

海龟的方向可以通过seth()或setheading()来设定。

#以下是设定海龟方向的例子:

 

"""033_直接设定海龟方向.py
   海龟的方向不仅能通过旋转的方式改变,我们也能直接设定它的方向。用的命令是:
   setheading()
   用法是:
   海龟对象.setheading()
   它的参数是数值,假设我想让海龟的方向为45度,那么我就可以这样:
   海龟对象.setheading(45)
   
   set在英文中是设置的意思,heading就是方向,朝向的意思。

"""
from turtle import *
from time import sleep  #从时间模块里导入sleep延时等待命令,sleep在英文里是睡眠

海龟1号=Turtle()       #创建了一只海龟,默认方向为向上,即朝向正北方向,方向度数为0度。

屏幕=海龟1号.getscreen()    #得到海龟1号的画图屏幕,get是得到的意思,screen是屏幕的意思。
屏幕.title('我的方向是朝北,度数为0度。')      #给画图屏幕设定标题,title是标题的意思,参数是一个字符串。

for i in range(1,9):
    sleep(2)            #等待2秒钟
    海龟1号.setheading(i*45)   
    屏幕.title("当前方向的度数为:" + str(海龟1号.heading()))

#根据range(1,9)和for的作用,i会依次得到从1到8的数值。
#当i为1时,i*45的值是45,用setheading(45)就能把海龟的方向设置为45度(朝正东北方向)
#当i为2时,i*45的值是90,用setheading(90)就能把海龟的方向设置为90度(朝正东方向)
#当i时3时,i*45的值是135,用setheading(135)就能把海龟的方向设置为135度(朝正东南方向)
#i为其它数值是,依此类推。 

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , | 留下评论

少儿python编程之改写上节课代码

#以下是python源代码,请直接粘贴到IDLE新建的py文件中,然后保存文件,再运行即可,#后面是注释:

 
"""032_改写31课代码.py
   本节课把上节课的代码用for循环实现一下,并且学习一个新命令,获取海龟当前的方向度数。
   用法为:

   海龟对象.heading()

   返回一个小数,如果要和其它字符串连接起来,需要用str()命令把它转换成字符串。

   heading就是方向,航向,朝向的意思。
"""
from turtle import *
from time import sleep        #从时间模块里导入sleep延时等待命令,sleep在英文里是睡眠。

海龟1号=Turtle()              #创建了一只海龟,默认方向为向上,即朝向正北方向,方向度数为0度。

当前方向=['朝东','朝南','朝西','朝北']

屏幕=海龟1号.getscreen()     #得到海龟1号的画图屏幕,get是得到的意思,screen是屏幕的意思。
屏幕.title('我的方向是朝北,度数为0度。')   #给画图屏幕设定标题,title是标题的意思,参数是一个字符串。

for i in range(4):
    sleep(2)                 #等待2秒钟
    海龟1号.right(90)        #海龟向右旋转90度
    屏幕.title(当前方向[i] + ",方向的度数为:" + str(海龟1号.heading()))


少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 标签为 , , , | 留下评论

少儿python编程之海龟画图的logo模式的方向

python海龟画图来自于著名的logo,基本上把logo语言给包含进去了。在python海龟画图中有两种画图模式。
一种是standard,叫标准模式,一种叫logo模式,logo模式接近于logo计算机语言,也和scratch画图模式一样。
logo模式以向上朝正北方向为0度方向,以向右旋转为方向增加,向左旋转为方向减少。
从0度向右旋转到90度,这时方向向右,朝正东。
再旋转90度,这时方向为向下,朝正南方向。
从0度向左旋转90度,这时方向为左,朝正西。
再向左旋转90度,这时方向为现下,也是朝正南。看下图:

#以下是python海龟画图方向示意源代码例子:

 
"""031_海龟画图之方向.py
    经过前面30课的预备学习,我们对python已经有稍微的了解,也看见过小海龟了。
    现在来正式学习python的海龟画图。
    我们这里学习python海龟画图需要配合配置文件turtle.cfg。进入此链接可以下载配置文件:
    http://www.HaLiFa.net/download/turtle.cfg
    下载后,请把它复制到C:\pyton34文件夹中,
    否则海龟移动的方式及图形可能有点不一样。
    请把你所编写的py文件保存到C:\python34中,当然如果你装的是python3.6或其它版本,
    可能对应的文件夹就是C:\python36,依此类推。
    
    当我们创建一只海龟,就会出现一个窗口,这个窗口默认宽度是计算机整个屏幕的一半,
    高度是屏幕高度的3/4。小海龟就会在窗口中央。我们把这窗口叫海龟画图屏幕。
    小海龟默认的方向为向上(朝北),这时方向为0度。
    把海龟的方向向右旋转90度,这时海龟的方向是朝东,
    再向右旋转90度,这时海龟的方向为朝南,再向右旋转90度,这时海龟的方向为朝西。
    再向右旋转90度,这时海龟的方向为朝北,转了一圈,回到了原来的方向。
"""
from turtle import *
from time import sleep  #从时间模块里导入sleep延时等待命令,sleep在英文里是睡眠

海龟1号=Turtle()    #创建了一只海龟,默认方向为向上,即朝向正北方向,方向度数为0度。

屏幕=海龟1号.getscreen()    #得到海龟1号的画图屏幕,get是得到的意思,screen是屏幕的意思。
屏幕.title('我的方向是朝北,度数为0度。')      #给画图屏幕设定标题,title是标题的意思,参数是一个字符串。

sleep(2)            #等待2秒钟
海龟1号.right(90)   #海龟向右旋转90度,这时会朝正东方向,方向度数为90度。
屏幕.title('我朝东啦,方向为90度。')

sleep(2)
海龟1号.right(90)   #方向度数为180度,朝正南方向
屏幕.title('我朝南啦,方向为180度。')

sleep(2)
海龟1号.right(90)   #方向度数为270度,朝正西方向
屏幕.title('我朝西啦,方向为270度。')

sleep(2)
海龟1号.right(90)   #方向度数为360度,朝正北方向,转了一圈又回到了初始方向。和0度时方向一样。
屏幕.title('我又回到朝北的方向啦。方向为360度,和0度是一样的方向。')

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 turtle | 标签为 , , , | 留下评论

少儿python编程之练习五列表参考答案

#练习五是关于列表的题目,粘贴下面代码到新建的py文件保存运行即可:

 
"""030_练习五.py
   编制程序产生100个大小为从1到1000的随机数(海龟也可以),把它们全部放到列表。打印这个列表,

   然后把列表所有数据全部弹出,打印列表。      
"""
from random import randint         #从random模块导入randint命令

表=list()                          #建立空表,名字就叫作 表

for i in range(100):               #让i迭代100次,每次产生的随机数加入到表中。
    表.append(randint(1,1000))
    
print(表)

print()

for i in range(100):
    表.pop()                       #每次弹出表最后一个数据
    
print(表)                          #最后表变成了空表

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 标签为 , , , | 留下评论

python少儿编程之海龟入篮

如果新建了一个变量,我们可以打印出这个变量所引用的值,如果新建了一个海龟对象,我们打印这个引用海龟对象的变量,会有什么结果呢?
我们在IDLE里输入这样的命令:
>>> from turtle import *
>>> 米开郎基罗=Turtle() #新建一只海龟,用米开郎基罗这个名称做为它的标识符
>>> print(米开郎基罗)

>>>
看图例,有说明:

#以下是海龟入篮的例子:

 
"""029_海龟入篮.py
   海龟入篮,就是海龟到篮子里面的意思。   这里的篮子实际上是一个列表。
   本例我们要学习新的列表命令append和pop,append能让列表装进新的数据。
   pop能让列表弹出最后的数据。
   本例我们产生很多海龟,让它们进入一个‘篮子’里。     
"""

from turtle import *

篮子=[]

海龟0=Turtle()
print(海龟0)
print()
print()


篮子.append(海龟0)              #把海龟0加入到篮子里。

海龟1=Turtle()
篮子.append(海龟1)

海龟2=Turtle()
篮子.append(海龟2)

海龟3=Turtle()
篮子.append(海龟3)

print(篮子)
print()

篮子.pop()                     #把篮子最后加入的海龟弹出去
print(篮子)

print()
print("海龟3",海龟3)

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 标签为 , , , | 留下评论

少儿python编程之列表二_切片操作

切片,顾名思义,切成一片一片,在python中,我们可以访问序列中连续的一段数据,这叫序列的切片访问。

访问方法是:列表名称[a:b:c]

上面的a,b,c都是数值,全部都可以省略,如果全都省略,那么访问的就是列表中的所有数据。

a为要访问的起始索引数据,b为要访问的结束索引数据,但不包括此数据,c为步长。

假设有序列为:

百家姓=[‘赵’,’钱’,’孙’,’李’,’周’,’吴’,’郑’,’王’,’冯’,’陈’,’楮’,’卫’]

那么
百家姓[1:5:2] 表示的是从索引为1开始到第5个结束,但不包括第5个姓,并且中间要隔一个姓。结果是:
[‘钱’, ‘李’]

请看下列图例:

#以下是列表二_切片的例子:

 
"""028_列表二_切片.py

   序列中的数据可以一个一个的访问,我们把这叫遍历。

   序列中的数据也可以成片成片的访问,或者说一次取出连续的一些数据。

   像切西瓜一样把序列‘切’成一片一片。

   对序列进行切片的基本方法为:列表名[起始序号:结束序号:步长]

   其中,结束序号是不包括的本身在内的。
     
"""

列表=['3','2','7','6','8','9','a','y']

print(列表[0:3])      #取第0,1,2个数据。从第0个开始,第3个结束,但不包括第3个数据。


新表1=列表[:3]        #起始序号没有写,默认为0
print(新表1)

新表2=列表[:5:2]      #从0个数据开始,到第5个结束(但不包括),步长为2
print(新表2) 


print(['3','2','7','6','8','9','a','y'][2:6]) #从第2个数据开始到第6个数据结束(不包括) 
    

print('www.HaLiFa.net'[:2])                   #取前面两个字符


我国名称='中华人民共和国'
for i in range(len(我国名称)):      #len(我国名称)的值是7,range(7)会产生0,1,2,3,4,5,6这些数字
    print(我国名称[:i+1])           #i会依次得到0,1,2...6这些数字
                                    #所以,print(我国名称[:1]) print(我国名称[:2]) print(我国名称[:3])
                                    #print(我国名称[:4]) print(我国名称[:5]) print(我国名称[:6])
                                    #print(我国名称[:7])
    

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 标签为 , | 留下评论

少儿python编程之遍历循环

游览祖国大好和山,用计算机术语来说,这是对我们国家的土地进行遍历。什么是遍历,在概看两个字也能猜出来,下面直接上代码,看看我们如何遍历字符串等序列。

#以下是python遍历的例子:

 
"""027_遍历.py

   前面学习for循环的时候就对字符串进行过遍历。
   现在再来明确一下什么是遍历。
   遍历,顾名思义,就是看一遍,走一篇,对每个数据进行访问一次的意思。
   在计算机语言中经常要对一些数据进行遍历。
   如,全班有60个同学,要把每个同学的姓名依次写在纸上,这其实是一种遍历。
   序列都是可以遍历的,一个整数就不能遍历,如果要‘强制’遍历那得先把它转换为字符串。
   本节讲完后,请用while循环对列表进行遍历。  
"""

字串='仰望星空去留无意'

print(字串[0])        #打印第0个字符,序列中的项目序号是从0开始

#方法一,遍历字符串中的每一个字
for i in range(len(字串)):         #range(8)能生从0到7的数字,
    print(字串[i],end=' ')
    
print()
#方法二,遍历字符串中的每一个字
for 字 in 字串:
    print(字,end=' ')


print()

列表1=list()          #用list命令也能创建列表。list在英文中就是列表的意思。
print('用list()创建一个空的列表',列表1)       # []

print()
列表2=list('晓楼一夜听春雨') #用list命令从一个字符串创建一个列表
print("list('晓楼一夜听春雨')可以把字符串转换为一个列表。\n",列表2)

print()
for 字 in 列表2:             #访问列表2中的每一个项目,依次把每个项目赋值给字这个变量。即遍历列表2
    print(字,end=' ')

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 留下评论

少儿python编程之列表入门

python中的数据结构比较灵活,列表是其中之一,它和其它计算机语言中的数组有相似的地方。如basic语言中的数组,一旦确定为整型数组,那变量单元只能赋值为整数。

python中的变量单元用来引用其它对象。列表中的每个项目从序号0开始进行索引,每个项目所引用的对象可各不相同,当然也能引用另一个列表。

新建列表可以用list()命令,如 列表1=list() 会新建一个空的列表,列表2=[]也一样会新建一个空的列表,列表3=(‘少儿编程吧’)会把字符串转换一个列表。

#以下是列表的源代码例子:

 
"""026_列表一.py
   字符串是一种序列,列表也是一种序列。字符串是在双引号或单引号或三引号内的一些字符。
   列表中的项目是在中括号里,项目可以是数字,字符串,甚至也是一个列表。
   列表的基本形式是这样的:[项目一,项目二,项目三,项目四]
   一个项目也没有的列表是空列表,记作:[]
   下面,我们实例化几个列表,看看列表到底长什么样子。
"""

列表1=[]                    #在中括号里,什么也没有,这是一个空的列表

列表2=[3,2,7,6,8]           #这个列表里是一些数字

列表3=['3','2','7','6','8'] #这个列表的每个项目是字符串,虽然这字符串只有一个字符

列表4=[52,'星空',"华侨"]    #这个列表里即有数值,又有字符串

for 项目 in ['越南','华夏','东欧','南澳','阿拉斯佳']:  #对列表中的每个项目进行遍历
    print(项目,end=' ')     #注意end参数,它的值是一个 空格

print(列表4[0])            #列表中的每一个成员都可以被引用,序号从0开始,在列表的名字后加中括号
print(列表4[1])            #这是打印列表4的第1个项目。 
print(列表4[2])            #这是打印列表4的第2个项目。  

print()                       # range(3) 相当于0,1,2
for i in range(len(列表4)):   #len()不仅可以求字符串的长度,也能求列表的长度,只要是属于序列,都能用len来求长度。
    print(列表4[i])           #打印列表中的第i个项目。

列表不仅能存放数字,字符串,甚至另一个列表,也能存放一只由Turtle()新建的”海龟”对象,因为海龟是一个对象,列表本来就能存对象的!

聪明的你能让列表一下子装进10只”海龟”吗?

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 留下评论

少儿python编程之求100以内的偶数参考答案

少儿python编程之求100以内的偶数参考答案

#以下是python求100以内偶数和的参考答案一:

 
"""025_练习四.py

   用for循环编制程序,求1到100以内的所有偶数和。要求以下列的打印形式输出结果:
   2+4+6+8+10+12+14+16+18+20+22+24+26+28+30+32+34+36+38+40+42+44+46+48+50
   +52+54+56+58+60+62+64+66+68+70+72+74+76+78+80+82+84+86+88+90+92+94+96+98=2450     
"""
和=0
for i in range(2,100,2):    #由于是1到100内偶数,所以应该从2开始,步长为2。
    if i<98:                #小于98的偶数的分隔符应该为+号。
        分隔符='+'
    else:
        分隔符="="          #最后的分隔符应该为=号。
    print(i,end=分隔符)     #print有一个叫end的参数,它默认为换行,在这里我们不能让它为默认值                           
    和 = 和 + i

print(和)
     

#以下是python求100以内偶数和的参考答案二:

 
和=0
偶数=2

while 偶数<100:
    和 = 和 + 偶数               #把偶数的值累加到和里。
    if 偶数<98:
        print(偶数,end='+' )     #print有一个叫end的参数,它默认为换行,在这里我们不能让它为默认值                           
    else:
        print(偶数,end='')       #最后一个偶数打印完后不要再连+加号了。
    偶数=偶数 + 2
    
print("=",和)

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 留下评论

少儿python编程之for循环之range()命令

在python中的for循环经常要用到range()命令,它能产生一个可迭代的序列。用for来推动这个range()产生的可迭代序列即可实现重复执行。

#以下是for循环的一个例子:

"""024_for循环二.py
   本节课继续讲述for循环。字符串是一种序列,for循环可以把字符串包含的每一个字符依次赋值给一个变量。
   当这个变量每得到一次值,属于for循环的语句组就执行一次。
   在本节中,我们学习新的命令range(),它可以产生连续的整数序列。range在英文中是范围的意思。
   range()命令语法为:range(起始值,最大值,步长),步长是每次增加的值。range命令的第一个和第三个参数可以忽略。
   如果忽略第一个参数,那么起始值就是从0开始。如果第三个参数被忽略,那么步长默认为1,即每次增加1。   
   所以,我们使用range()就有三种用法,下面分别是这三种用法。      
"""

数字序列=range(10)          #只有一个参数的,range(10)产生从0到9共10个数字
for x in 数字序列:
    print(x) 

print()
数字序列=range(1,10)        #range(1,10)产生从1,2,3,4,5,6,7,8,9共9个数字
for x in 数字序列:
    print(x)

print()
数字序列=range(1,20,3)      #range(1,20,3)产生1,4,7,10,13,16,19共7个数字
for x in 数字序列:
    print(x) 


#print函数的end参数用法
print()
for i in range(5):          #0,1,2,3,4
    print(i,end=",")        #每次打印后print会自动换一行,如果想让所打印的数字在同一行怎么办呢?
                            #给print加上一个end参数,意为结束参数,让它的值为一个逗号,
                            #print打印完就不会换行了,换成了逗号。

#求自然数的和
print()
和=0
for i in range(1,11):        #1,2,3,4,5,6,7,8,9,10
    和=和+i

    
print("1+2+3...+10的和为:",和)
    

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 留下评论

少儿python编程之for循环入门

很多计算机语言中都有for循环,它可以让属于自己的语句组重复一定的次数。python的for循环和其它计算机语言的for有较大的区别。

它的本质是对序列进行迭代,即它是把序列中的每个项目的值依次取出来,赋值给一个变量。当这个变量得到一个值时,就执行一次语句组。

然后如此重复。由于字符串属于序列,下面给出一种for语句的用法:

for 每个字 in ‘少儿编程吧的网址是www.scratch8.net’:

上面这条语句首先会新建了一个变量叫:每个字。

for 的使命就是让这个叫:每个字 的变量依次得到’少’,’儿’,’编’,……等等这些字。每得到一个值,就执行一句属于它的语句组。

下面是一个简单的例子:


for 字 in '少儿编程吧的网址是www.scratch8.net':
    print(字)

上面会把每个字都打印出来,打印完一个字后,默认是换行。所以会打印一竖的字。

#以下是for循环入门的一个例子,注意#号后面的不是代码,是注释,给人看的:

 

"""023_for循环一.py
   在python中, for循环用 for 和 in 两个英文单词做为关键词,让属于自己的语句组重复执行一定的次数。
   for这个单词在英文里是‘每’‘因为’等的意思,in是在.....里面的意思。

   语法格式是这样的:

   for 变量 in 序列:
       语句一
       语句二
       语句三
    
   它的意思是,对于序列中的每一个项目,依次赋值给变量,变量的名称可以根据不同的情况命名。

   每一次赋值后就执行一次属于for的语句组。

   上面的语句一,语句二,语句三就是属于for的语句组,它们离最左边的空格数是一样的。

   字符串中的每一个项目就是组成字符串的每一个符号,如字符串 'abcxyz'它就是由6个字母组成的。

   字符串属于序列,所以能用于for循环,下面是几个for循环的例子。   
      
"""
for 数字 in '012345':    #对于字符串'012345'中的每一个数字分别一个一个的赋值给 数字 这个变量
    print(数字)          #所以这个print语句共重复执行了5次,数字的值分别是'0','1','2','3','4','5'

print()

for 字母 in 'abcdefg':  #对于字符串'abcdefg'中的每个字母,依次赋值给 字母 这个变量。
    print(字母)         #print(字母) 共执行了7次,字母这个变量依次得了'a','b','c','d','e','f','g'

print()
for x in '1350799xyz': #对于字符串'1350799xyz'的每个符号,依次赋值给 x 这个变量。
    print(x)

少儿python编程培训预订开始,单击链接享受优惠:https://item.taobao.com/item.htm?id=544061935133

发表在 python | 留下评论

少儿python编程之海龟画图画正方形(logo编程)

海龟画图最先由logo计算机语言的发明者发明,现在在多种语言中已经借用它来学习计算机入门。如易语言本身带有海龟模块,它的易乐谷也完全是中文的一个logo。
scratch中也有画图功能,和海龟画图也异曲同工。python发明人鬼斗凡先生(Guido van Rossum)高瞻远瞩地在python中加入海龟画图模块。它用来通过logo画图的方法学习python入门,也能用画做小动画,小游戏。 如果完全没有接触过编程语言,那你要想像一下或亲自走一下。你自己站在地上,往前走,每次走10步,走10步后向右转90度,把上面的过程重复4次,是不是能走出一个正方形。现在,我们用python编程语言表达出来,把你的思维用计算机语言表达出来,思想是一致的。

#以下是画正方形源代码,注意#号后面的不是代码,是注释,给人看的:

 
"""022_画正方形.py

    前面学过了在python中有一个海龟模块,现在我们来更加明确一下。
    python的海龟模块里包含很多命令,当我们创建一只海龟的时候,海龟的‘笔’默认为落下的。
    所以当我们移动海龟就会留下轨迹。
    在本例中,创建一只海龟,它会自动出现在一个窗口中央,我们把这个窗口叫做海龟屏幕。
    海龟的默认方向为朝上(模式为logo时),我们让它前进100像素然后向右转90度,重复4次,借此就可以画一个正方形。
    在运行完本程序后,请说出变量,计数器的值是多少。
    并把本程序while循环的条件表达式改为True,加上相关语句,让属于while的语句组重复执行四次。
    
""" 
from turtle import *           #从海龟模块中导入所有的命令。

小海龟=Turtle()

计数器=0

while 计数器<4:               #当 计数器小于10,也就是说,当表达式的值为True的时候,
                              #运行属于while的语句组。
    小海龟.fd(100)
    小海龟.right(90)          #right命令让海龟向右转90度。
    计数器=计数器+1

把上面的python代码用人类语言来翻译一下就是:

从海龟模块导入所有命令后,新建一只小‘小海龟’的海龟对象。重复4次让小海龟往前移动100像素再向右旋转90度的过程。

发表在 python | 留下评论