笨方法学python笔记

编程是什么

编程就是通过输出一种语言给计算机“听”，命令其去执行相应的操作。

我们称我们给计算机下达的命令称为指令。一般说程序就是有多个指令构成的。

计算机需要使用非常多的电路来实现”思考“，在最低层，这些电路就是一些开关，通过控制开关的通电状态，来进行计算，开关的状态，也就是电路的状态有两种状态，有0或1，这就构成了一个二进制位，成为1比特bit

IDLE

IDLE就是一个python shell。shell也就是外壳，也就是说，这是一个通过键入文本与程序交互的途径。也就是利用这个shell与python进行交互。IDLE本身也是个GUI(图形用户界面)[表示界面中含有窗口、菜单、按钮、滚动条]。没有GUI的程序称为文本模式text-mode程序、控制台console程序或命令行command-line程序。

这个是python中的提示符prompt，提示符是程序等待你键入信息时显示的符号。也就是说python已经准备好了，在等着你下达指令呢。

子啊编程中，打印指的是在屏幕中显示文本。我们用于计算机执行相应工作的指令的另一种叫法就是代码

关键keyword字也称为保留字reserved word.

交互

打印hello word运行代码或称为下达指令的时候就称为在交互模式种使用python。建立命令后python就执行这个命令。

执行executing命令，也就是运行的另一种形象说法

程序到底是什么

程序是多个指令集合在一起。如果只是在交互窗口键入指令，python不会记住你键入的内容，需要使用一个文本编辑器将其保存到硬盘上。这个untitled意味未命名。

如果出现问题

基本上只会发生两种类型的我错误。

1. 语法错误

语法错误syntax error。语法就是一种编程语言的拼写和文法规则，所以出现语法错误意味着你键入的某个内容是不正确的python代码。

2. 运行错误

这种错误呢是在程序运行时才会发生的错误。也就是会出现Traceback(most recent call last），traceback开头的代码表示错误消息开始。下一行指出那些指令指出哪里发生错误。bug就是臭虫，他们就把讨厌的错误称为bug。

程序还具有什么功能

真正的程序还具有

• input输入
• process 处理输入
• 产生输出 output

猜数游戏比如这个就具有输入，处理以及输出：

import random
secret = random.randint(1,99)
guess = 0
tries = 0
print("AHOY! I'm the Dread Pirate Roberts, and I have a secret!")
print("It's a number from 1 to 99. I'll give you 6 tries")
while guess != secret and tries < 6:
    guess = int(input("What's yer guess?"))
    if guess < secret:
        print("Too low,ye scury dog!")
    elif guess > secret:
        print("Too high,landlubber!")

    tries = tries + 1

if guess == secret:
    print("Avast! ye  got it! Found my secret,ye did!")
else:
    print("No more guesses! Better luck next time , matey!")
    print("The secret number was",secret)   

输入，处理，输出很重要的三个步骤，要把这些步骤记住。既然要有输入，为了处理这些输入，首先计算机必须先记住他们，或者把他们保存在某个地方。计算机会把这些内容包括输入以及程序本身保存在它的内存中。

那什么是计算机内存呢，我们说过，计算机就是一大堆开关。内存就像是放在同一个位置上的一组开关，以单一某种方式设置了这些开关，他们就会一直保持那种状态，知道你做出改变，也就是说他会记住你原先的设置。写入内存也就是设置开关，读内存也就是查看开关如何设置。

问题来了，我么为什么要把一个东西放在内存中的某个位置，另外，放在那里之后我们又如何将其找回来呢。

在python中，我们希望程序记住某个东西，以便你以后使用。python会在计算机内存中给这个东西留出位置，下次想要引用时只需要使用同一个名字。需要使用赋值符号=，assign。也就是说给你以后将会使用的数据加了个方便以后查阅的标签。以及找到标签就想起了值。

加了双引号“”，python中的print函数就会把引号里面的内容原样打印出来

算术表达式arithmetic expression是数字和符号的组合，计算evaluate表示算出他的值

当然不同的数据需要不同的内存来储存。

其他语言给数据贴标签的过程也称作把值储存在变量中。python稍微与去他语言有所不同，他并不是把值储存在变量中，更像是把名字放在值上。 变量就是你不需要准确的知道信息储存在内存中的那个位置，只需要记住储存变量所用的名字，在使用这个名字就可以了。

同一个东西或者同一个值可以有不同的名字，也就是可以有不同的标签

字符串相加喝着更恰当地称为字符串拼接concatenaztion

如果需要希望得到一个跨多行的字符串,必须使用一种特殊字符的字符串,称为三重引号字符串triple-quoted string

long_string = """
加了双引号“”，python中的print函数就会把引号里面的内容原样打印出来
算术表达式arithmetic expression是数字和符号的组合，计算evaluate表示算出他的值
当然不同的数据需要不同的内存来储存。
其他语言给数据贴标签的过程也称作把值储存在变量中。python稍微与去他语言有所不同，他并不是把值储存在变量中，更像是把名字放在值上。  变量就是你不需要准确的知道信息储存在内存中的那个位置，只需要记住储存变量所用的名字，在使用这个名字就可以了。
"""

变量到底有多可变

可以将旧东西贴上新标签,也就是给旧东西命了个新名字.

要记得,一个东西上可以贴多个标签,当一个数据上没有任何标签时,python就会把他从计算机内存中删除.这样一来只要是没有名字也称为没有标签的时候,就不会存在在内存中.注意,名字/标签 可以改变,但是值一定是改变不了的.

自增increment自减decrement

程序中最常见的bug就是改变了不该改变的变量,或者尽管改变的变量无误,但是时机不合适.为了避免这种情况,有效的方法是使用容易记住的变量名.

一般遵循传统都会将小写的单词记作变量名

变量也叫名字或者是变量名

变量是指让计算机内存中记住或者保存信息

基本数学运算

整数integer

小数decimal number 在计算机中小数也成为浮点数floating-pointnumber 简写为floats.//这个是floor division整除./这个称为正常除法.像加减乘除+-*/这些操作符因为他会处理放在符号两边的数字.我们称为赋值操作符assignment operator,因为我们用它给变量赋值.

操作符operator就是会对两边的东西有影响或者有操作的符号.这种影响可能是复制检查或者改变一个或者多个这样的东西.

操作数 +(操作符) +操作数 完成算术运算的+-*/都为操作符,被操作的东西称为操作数operand

被除数除以除数得到商,商quotient,余数remainder为1.python有一个操作符可以用来计算整数相除的余数,这称为取余modulus操作

python中会用一种稍微不同的方式处理非常大的数,例如4.79389717413e+025

这个e是计算机中显示非常大或者非常小的数字采用的一种方法,叫做E-notation.若在处理非常大或者非常小的数,把那这些数都显示出来可能会非长费劲,这种情况在数学和科学领域经常出现.显示数的零一种方式就是使用科学计数法scientific notation 就是一个小数在乘以10的幂

上标superscript是指一个字符或者一组字符比其余文本高一些,例如10^{13}

下标subscript就是指一个或者一些字符会比其余文本低一些

chp1~chp3

---

改变类型

或者说是类型转换type conversion

例如

• float()
• int()
• str()

像float(),int(),str()后面有小括号，因为他们不是Python的关键字，他们只是Python中的内置有函数

像input（）这样的函数，其实已经内置了print（）函数

来自互联网的输入

输入不一定都来自用户。还有一些其它方法可以用来获得输入，可以从计算机硬盘中的文件获得输入，也可以从互联网中获取输入。

GUI是什么

GUI是Graphical User Interface(图形用户界面)，在GUI中，不光光是键入文本和返回文本，用户还可以看到窗口按钮文本框等图形，而且还可以用鼠标点击，还可以通过键盘键入。GUI是与程序交互的一种不同的方式。

我们一直都在使用GUI，web浏览器是一个GUI，IDLE也是一个GUI。为了建立自己的GUI，我们可以借助EasyGui这个模块，模块就是一种扩展方式，它可以像Python中增加非内置的内容

easy gui是一个模块，用于在Python中进行非常简单、非常简单的GUI编程。easygui不同于其他GUI生成器，因为easygui不是事件驱动的。相反，所有的GUI交互都是通过简单的函数调用来调用的。

easy gui提供了一个易于使用的界面，用于与用户进行简单的GUI交互。它不需要程序员了解任何关于tkinter, frames, widgets, callbacks 或者 lambda的信息。easygui在python 2和3上运行，并且没有任何依赖关系。

获取Python的工具包easygui（推荐学习：Python视频教程） 先从网上下载支持Python的工具包easygui-0.96或easygui-0.97。 这里提供一个网站：https://sourceforge.net/projects/easygui/files/0.96 解压之后又两个文件为setup.py和easygui.py两个文件。easygui安装
第一步：在GUI工具包所在路径，进入环境，输入dir，查询该文件下是否有安装文件。
第二步：命令安装
输入命令
python setup.py install
静等下载即可！
打开IDLE，引入easygui。
import easygui
写入测试代码。
easygui.msgbox('Hello World')

我这里是是直接将下载的文档全部放到了C:\Users\JD\AppData\Local\Programs\Python\Python38\Lib\site-packages中的easygui文件夹中(自己建的)然后执行 python setup.py install就好了

https://blog.csdn.net/qq_41647438/article/details/88606380

https://zhuanlan.zhihu.com/p/60910595

GUI输入

我们刚才看见的消息框实际上只是对话框dialog box的一个例子，对话框包含了一些GUI元素，用来告诉用户某些信息，或者从用户中得到一些输入。输入可以是按钮点击，或者是文件名，也可以是某个文本（字符串）。

chp4-chp6.3

---

在easygui中，用户点击的按钮的标签就是输入input，不是键入而是点击按钮这就是GUI的关键。

默认输入

有时用户输入信息时，可能会期望得到某个答案，或者有一个很常见或最可能输入的答案。这个值称为默认值default。这个最常见的答案可以由你为用户输入，这样用户就不用在键入叻1.有了默认值，只有当有用户有不同的输入时才有必要键入。要在一个输入框中放入默认值。来接着修改程序

import random ,easygui
secret = random.randint(1,99)
guess = 0
tries = 0
easygui.msgbox("""AHOY! I'm the Dread Pirate Roberts,and I have a scret!
It's a number from 1 to 99. I'll give you 6 tries.""")
while guess != secret and tries < 6:
    guess = easygui.integerbox("What's yer guess ,matey?")
    if not guess:break
    if guess < secret:
        easygui.msgbox(str(guess)+" is too low,ye scurvy dog!")
    elif guesws > secret:
        easygui.msgbox(str(guess)+" is too high,landlubber!")
    tries = tries + 1
if guess == secret:
    easygui.msgbox("Avast!Ye got it!Found my secret, ye did!")
else:
    easygui.msgbox("No more guesses! The numnber was " + str(secret))

GUI就是图形用户界面的缩写Graphical User Interface在TGUI中并不只是键入文本和返回文本，用户可以看到窗口按你有文本框等图形，并且鼠标可以点击，还可以通过键盘键入

仅仅包含ok的简单消息框：

import easygui
easygui.msgbox("Hello world")

其中easygui中的msgbox()函数用于创立一个消息框，大多数情况下easygui函数名字就是相应英语单词的缩写msgbox也就是message box\rarr msgbox,消息框，也就是将文本展示在消息框上去，仅仅带有一个ok按钮。在点击ok按钮，消息框就会结束。

怎样得到有输入的GUI呢

import easygui
user_response = easygui.msgbox("Hello there!")
>>>print(user_response)

上面这些message box msgbox消息框只是对话框dialog box 的一个例子。对话框并高喊一些GUI元素，用来告诉用户某些信息，或者从用户得到一些输入。输入可以是按钮点击如“OK”或者是文件名，或者是某个文本字符串。message box msgbox就是包含一条消息和一个按钮ok的对小框。

现介绍不同类型的对话框，包含更多按钮和其他内容先创建一个包含多个按钮的对话框例如消息框，具体做法是使用一个按钮框button box bottonbox。下面建立一个程序不是在交互模式中完成。

import easygui
favor = easygui.buttonbox("What is your favorite ice cream flavor?",choices = ['Vanilla','Chocolate','Strawberry'])
easygui.msgbox("You picked "+favor)

现在既不是OK也不是多个按钮框，而是下拉式选择框也就是choice box，choicebox

import easygui
flavor = easygui.choicebox("What is your favorite ice cream flavor?",choices =
                           ['Vanilla','Chocolate','Strawberry'])
easygui.msgbox("You picked "+ flavor)

若不是选择，而是输入文本呢也就是使用输入框输入文本也就是emter box，enterbox

import easygui
flavor = easygui.enterbox("What is your favourite ice cream flavor?")
easygui.msgbox("Your entered "+flavor)

好，有时用户输入信息是，可能会期望得到某个答案，或者有一个很常见的或者最可能的输入的答案。这个称为默认值default这个最常见的答案可以有你为用户自动输入，这样一用户就不用在键入了。有了默认值后，只有当用户有不同的我输入时才有必要键入

import easygui
flavor = easygui.enterbox("What is you favorite ice cream flavor?",default = "Vanilla")
easygui.msgbox("You entered" + flavor)

那数字呢，如果想在easygui中输入一个数，完全可以先通过输入框得到一个字符串，然后使用int（）或i这float（）由这个字符串创建一个数

或者easygui还提供一种整数框integer box integerbox可以用她来输入整数，还可以对所输入的数设置一个下届和一个上界，不过整数框不允许输入浮点数（小数）要输入小数，必须先通过输入框的得到字符串，在使用float()转化这个字符串。

import random ,easygui
secret = random.randint(1,99)
guess = 0
tries = 0
easygui.msgbox("""AHOY! I'm the Dread Pirate Roberts,and I have a scret!
It's a number from 1 to 99. I'll give you 6 tries.""")
while guess != secret and tries < 6:
    guess = easygui.integerbox("What's yer guess ,matey?")
    if not guess:break
    if guess < secret:
        easygui.msgbox(str(guess)+" is too low,ye scurvy dog!")
    elif guesws > secret:
        easygui.msgbox(str(guess)+" is too high,landlubber!")
    tries = tries + 1
if guess == secret:
    easygui.msgbox("Avast!Ye got it!Found my secret, ye did!")
else:
    easygui.msgbox("No more guesses! The numnber was " + str(secret))

作业：显示一个文本信息

import easygui
easygui.msgbox("显示一个文本信息")

chp6.3-chp6.6

---

判断

有了输入处理输出以及将输入赋值给一个变量，先在补充一些决策技术decision-making

程序能够根据输入做出不同的事情。决策时程序要做出检查完成一个测试，查看某个条件是否为真，Python完成测试的方法有限，而且每个测试只有两个可能答案：真true或者假false

Python会判断

• 这两个东西相等么
• 其中一个是不是小于另一个
• 其中一个是不是大于另一个

也就是做出判断条件为真或者为假，条件condiktion，真true假false

完成测试并且根据结果做出判断称为分支branching。程序根据测试结果来决定走那条路，或者说沿哪个分支执行程序

Python使用关键字if测试条件

if timesAnswer == correctanswer:
    print("You got it right!")
    score = score + 1
print("Thanks for playing.")

这些代码行构成一个代码块，因为相对于上面和下面的代码行已经将他缩进

代码块block十一行或者放在一起的多行代码，他们都与程序的某个部分相关比如if语句，在Python中通过将代码行缩进来构成代码块

if后面的冒号：告诉Python下面将是一个指令快，这个指令快包括从前面的if行一下知道下一个不锁进的代码行之间的所有缩进代码行，如果条件为真就会完成之后代码块中的所有工作。

不光有等于号==，也还有>大于号，小于号>，以及>=大于等于号，！=不等于号这种比较操作符comparision operator也称为关系操作符relational operator。因为他们要测试两边值得关系relation相等还是不相等，比较也成为条件测试conditional test 或者逻辑测试logical test。在编程中，逻辑logical就是指某个结论的答案是真还是假。 if、else if elif、...这些是如果第一个逻辑测试为假则向下顺序进行

age = float(input("Enter your age:"))
grade = int(input("Enter your grade:"))
if age >= 8:
    if grade >=3:
        print("You can play this game")
else:
    print("Sorry, you can't play the game."

当然了也可以使用and结合多个条件，

age = float(input("Enter your age:"))
grade = int(input("Enter your grade:"))
if age >= 8 and if grade >=3:
    print("You can play this game")
else:
    print("Sorry, you can't play the game.")

以上介绍了+-*/等数学运算符，还有比较操作符<,>,==等，and or 和not关键字也是操作符这些被称为逻辑操作符logical operator ，这些操作符用来修改比较，可以结合两个或多个比较and和or或者取反

作业题1

user_pay = float(input("请输入你购买的金额："))
if user_pay <= 10:
    print(f"会给你10/%的折扣，也就是{0.9*user_pay}")
else:
    print(f"会给你20/%的折扣，也就是{0.8*user_pay}")

加上gui

import easygui
user_pay = float(easygui.enterbox("请输入你购买的金额：",default = "0.00"))
if user_pay <= 10:
    easygui.msgbox(f"会给你10/%的折扣，也就是{0.9*user_pay}")
else:
    easygui.msgbox(f"会给你20/%的折扣，也就是{0.8*user_pay}")

作业题2

import easygui as e
e.msgbox("您好可以填一下我们的调查问卷么？")
gender = e.buttonbox("请选择您的性别,其中m代表男性，n代表女性",choices=['m','n'])
if gender == 'm':
    gender = '男'
else:
    gender = '女'
e.msgbox(f"你好您的性别是:{gender}")
age = int(e.enterbox("请输入您的年龄：",default = "1"))
if gender == '女' and 10<= age <=12:
    e.msgbox("恭喜你可以参加球队。")
else:
    e.msgbox("你很优秀，但是不好意思，我们这不着球员了")

或者是

import easygui as e
e.msgbox("您好可以填一下我们的调查问卷么？")
gender = e.buttonbox("请选择您的性别,其中m代表男性，n代表女性",choices=['m','n'])
if gender == 'm':
    gender = '男'
    e.msgbox("你很优秀，但是不好意思，我们这不着球员了")
else:
    gender = '女'
    e.msgbox(f"你好您的性别是:{gender}")
    age = int(e.enterbox("请输入您的年龄：",default = "1"))
    if gender == '女' and 10<= age <=12:
        e.msgbox("恭喜你可以参加球队。")
    else:
        e.msgbox("你很优秀，但是不好意思，我们这不着球员了")

第三题

gas_cc = int(input("油箱总共少升油，单位升："))
percent_full = int(input("油箱有多满："))
km_per_liter = int(input("你的汽车每升油可以走多远（km）"))
km = int(gas_cc * percent_full * km_per_liter/100)
if km >=200:
    print(f"""Size of tank:{gas_cc}
percent full:{percent_full}
km per liter:{km_per_liter}
You can go another 240 km
The next gas station is 200 km away
You can wait for the next station.

    """)
else:
    print(f"""
    Size of tank:{gas_cc}
    percent full:{percent_full}
    km per liter:{km_per_liter}
    You can go another {km} km
    The next gas station is 200 km away
    Get gas now.

    """)

转圈

对于大多数人来叔，反复做同样的事情很烦人，既然如此，我们可以让计算机做，让计算机去执行这些重复的任务。计算机程序周而复始的完成重复的任务或者来说是步骤，称为循环looping。主要有两种类型的循环：

• 重复一定次数的循环，成为计数循环 counting loop
• 重复直至发生某种情况时结束的循环，称为条件循环condititional loop因为只要条件为真，这种循环就会一直持续下去

第一种循环为计数循环，或者称为for循环，因为许多语言都使用for关键字来创建这种类型的循环

for looper in[1,2,3,4,5]:
    print("hello ")

===== RESTART: D:/codelife/py_code/idle/fands/0822_7,6testmutlicondition.py ====
hello 
hello 
hello 
hello 
hello 

瞧，这是不是重复。虽然只有一个print语句，但是显示了5次hello，第一行

for looper in [1,2,3,4,5]:翻译

• 变量looper的值从1开始
• 对应列表的每一个值，这个循环会把下一个指令块中的所有工作完成一次
• 每次执行循环时，变量looper会赋值这个列表中的下一个值
• 第二行pring("hello world")就是Python每次循环时要执行的代码块。这个代码块告诉程序每次循环时都要做什么。这个代码块称为循环体body of the loop

我们称循环一次为一次迭代。iteration

现在有

for looper in[1,2,3,4,5]:
    print(looper)

===== RESTART: D:/codelife/py_code/idle/fands/0822_7,6testmutlicondition.py ====
1
2
3
4
5

那失控的循环也叫做无限循环。只要ctrl + c就可以结束循环。游戏和图形程序通常都在一个循环中进行。这邪恶程序需要不断从鼠标键盘或游戏控制器得到输入，然后处理这个输入，并且更新这个屏幕。开始写程序时，我们会大量使用循环。

中括号[ ]

我们发现循环列表包围在中括号里，Python就是利用中括号以及数之间的逗号来建立列表list。我们需要知道列表只是一种容器，可以用来存放一些东西。在这里东西就是数，也就是每次循环迭代时looper所取的值。

打印8的乘法表

for looper in[1,2,3,4,5]:
    print(looper,"times 8 =",looper * 8)

一条捷径

在上面中，我们只是循环了五次，也就是迭代了5次：for looper in [1,2,3,4,5]

如果希望循环100次或者1000次呢，很费劲，利用range() 函数，只需要输入起始值和结束值，他就会为你创建这二者之间的所有值，range()会创建一个列表，表示包含在某个范围的数。

for looper in range(1,5):
    print(looper,"times 8 =",looper * 8)

===== RESTART: D:/codelife/py_code/idle/fands/0822_7,6testmutlicondition.py ====
1 times 8 = 8
2 times 8 = 16
3 times 8 = 24
4 times 8 = 32
>>> 

range(1,5)给出的列表是[1,2,3,4]

>>> range(1,3)
range(1, 3)
>>> bool(range(1,3) == [1,2])
False

为什么print(range(1,3))输出的是range(1,3) 因为在Python中range()函数不会提供一个数字列表，二十会提供一个可迭代的iterable的东西。你可以使用循环来遍历它。我们基本上把循环的变量称作为looper

循环变量名

循环变量也是变量，变量只是对应于一个值的名字而已。将这个变量用作循环计数器也是可以的。我们用能够描述变量用途的变量名。比如说鬼妖循环的变量取名为looper，不过有时还有一些列外，我们使用i,j,k作为循环变量，这是种惯例，作为循环变量i,j,k 不应当有其他用途。

for i in range(1,5):
    print(i,"times 8 =",i * 8)

rang()写法

不一定range()非得提供两个数，也可以仅仅提供一个数，

for i in rang(5)
#这个等价于
for i in rang(0,5)
>>>[0,1,2,3,4]

因为大多数程序员都是从0开始进行循环而不是从1开始，如果写rang(5)也就是会得到循环5次的迭代。为什么大多数程序员从0而不是从1开始循环呢，字符串旧思想那个是一个字符列表。计数循环使用列表来完成迭代，这说明，可以利用一个字符串来循环。字符串中的每个字符对应循环中的一次迭代

目前为止，我们的计数循环都是每次迭代时计数增加1，，如果想反向计数或者步长为2来计数，rang()函数可以有1个额外的参数，利用这个参数把补偿从默认值的1改为不同的值

参数argument也就是使用类似range（）的函数时放在括号里的值。我们说向函数传递了参数，有时也用形参parameter。

rang()函数中的数会从第一个开始，让后计算。

for i in range(10,0,-1):
    print(i)

倒计时

import time
for i in range(10,0,-1):
    print(i)
    time.sleep(1) #等待一秒
print("Blast off!")

没有数字的计数

在前面的所有例子中，循环变量都是一个数。按照变成属于来讲，循环迭代处理一个数字列表。但是列表不一定每个非得是数字列表。也可以是字符列表（一个字符串）或者是其他列表

for i in ["sad","df","asfd","sadfs"]:
    print(123,i)

这也是一种计数循环因为尽管列表不是数字列表，Python也要统计列表中有多少项来确定循环要循环多少次。以上也都是foe循环或者称为计数循环，也就是将列表中的对象作为迭代的次数。第二种循环也称为while循环或者是条件循环。

如果你前提知道希望循环运行多次，那么for循环很适合。不过，有时你可能希望循环一直在进行，知道发生某种情况下才结束，而且不知道之前会有多少次循环。这时就可以用while循环来实现。

在此之前我们了解了条件和测试，还学习了if语句。while循环并不统计运行了多少次循环，他只会用一个测试来确定是么时候通知循环。while循环也称为条件循环conditional loop 。条件循环在满足条件时会一直保持循环。while循环使用Python关键字while来执行循环。

# 是3就终止循环
while True:
    user_number = int(input("请输入3："))
    if user_number == 3:
        print("You did it")
        break
    else:
        print(f"您输入的数字是{user_number},不是3，请继续输入")

# 不是3就一直循环
while True:
    user_number = int(input("请输入一个数字："))
    if user_number != 3:
        print("You did it")
        break
    else:
        print(f"您输入的数字是{user_number},是3，请继续输入")

# 当然还有另一种写法，在关键字while上面和下面分别写个input函数
#如果不满足条件之后，关键字后面还是按照顺序进行

chp8.7

---

跳出循环 break和continue

有时会希望在中间离开循环，也就是for循环计数循环结束之前，或者while循环条件循环结束条件之前。有两种做法，可以利用continue直接跳到循环的下一次迭代，或者直接用break完全终止循环。

提前跳转循环continue

如果想停止执行循环的当前迭代，提前跳到下一次迭代，就需要一条continue语句

for i in range(1,7):
    print("hello",end = " ")
    print("i=",i,end = "\t")
    if i == 3:
        continue
    print("Hello ,how are you today")

import easygui
num = int(easygui.enterbox("Which multiplication table would you like?"))
easygui.msgbox(f"You choice number is {num}")
easygui.msgbox("Here's your table:")
for i in range(1,11):
    easygui.msgbox("%d * %d = %d"%(num,i,num*i))
    #print("%d * %d = "%(num,i),num*i)

import easygui
num = int(easygui.enterbox("Which multiplication table would you like?"))
easygui.msgbox(f"You choice number is {num}")
easygui.msgbox("Here's your table:")
i = 0
while i < 10:
    i += 1
    easygui.msgbox("%d * %d = %d"%(num,i,num*i))
    #print("%d * %d = "%(num,i),num*i)
    
import easygui
num = int(easygui.enterbox("Which multiplication table would you like?"))
easygui.msgbox(f"You choice number is {num}")
easygui.msgbox("Here's your table:")
i = 1
while i <= 10:    
    easygui.msgbox("%d * %d = %d"%(num,i,num*i))
    i += 1
    #print("%d * %d = "%(num,i),num*i)

import easygui
num = int(easygui.enterbox("Which multiplication table would you like?"))
easygui.msgbox(f"You choice number is {num}")
high = int(easygui.enterbox("How high do you want to go?"))
easygui.msgbox("Here's your table:")
i = 1
while i <= high:    
    easygui.msgbox("%d * %d = %d"%(num,i,num*i))
    i += 1
    #print("%d * %d = "%(num,i),num*i)
  
import easygui
num = int(easygui.enterbox("Which multiplication table would you like?"))
easygui.msgbox(f"You choice number is {num}")
high = int(easygui.enterbox("How high do you want to go?"))
easygui.msgbox("Here's your table:")
for i in range(1,high + 1):    
    easygui.msgbox("%d * %d = %d"%(num,i,num*i))
    i += 1
    #print("%d * %d = "%(num,i),num*i)

注释

有时候我们可以在程序中加入一些说明，描述这个程序是做什么的，这让方便别人了解你的想法。在计算机程序中，这些说明就称为注释comment

文档documentation就是关于一个程序的信息。

• 有单行注释

• 多行注释

  *******************

  这个程序是用来说明Python中如何让使用注释

  型号所在的行只为将注释

  与其他行代码清楚的区分开

  *******************

  """
  这个程序是用来说明Python中如何让使用注释
  这个程序是用来说明Python中如何让使用注释
  这个程序是用来说明Python中如何让使用注释
  """

• 行末注释

注释风格

现在看来注释越多越好，宁可过于谨慎注释过多，也比注释过少要好。

游戏时间

学习编程的一种常见做法是，先键入一些代码，尽管你可能完全不理解这些代码。

但有时仅仅键入代码就能让你对程序如何让工作找到一点感觉

安装Pygame模块

import pygame, sys, random
skier_images = ["skier_down.png","skier_right1.png","skier_right2.png", "skier_left2.png","skier_left1.png"]
class SkierClass(pygame.sprite.Sprite):
    def __init__(self):
        pygame.sprite.Sprite.__init__(self)
        self.image = pygame.image.load("skier_down.png")
        self.rect = self.image.get_rect()
        self.rect.center = [320,100]
        self.angle = 0
    def turn(self,direction):
        self.angle = self.angle + direction
        if self.angle < -2: self.angle = -2
        if self.angle > 2 : self.angle = 2
        center = self.rect.center
        self.image = pygame.image.load(skier_images[self.angle])
        self.rect = self.image.get_rect()
        self.rect.center = center
        speed = [self.angle,6 - abs(self.angle) * 2]
        return speed
    def move(self, speed):
        self.rect.centerx = self.rect.centerx + speed[0]
        if self.rect.centerx < 20: self.rect.centerx = 20
        if self.rect.centerx > 620: self.rect.centerx = 620

class ObstacleClass(pygame.sprite.Sprite):
    def __init__(self,image_file,location,type):
        pygame.sprite.Sprite.__init__(self)
        self.image_file = image_file
        self.image = pygame.image.load(image_file)
        self.rect = self.image.get_rect()
        self.rect.center = location
        self.type = type
        self.passed = False
    def update(self):
        global speed
        self.rect.centery -= speed[1]
        if self.rect.centery < -32:
            self.kill()

def create_map():
    global ostacles
    locations = []
    for i in range(10):
        row = random.randint(0,9)
        col = random.randint(0,9)
        location = [col * 64 + 20 ,row * 64 + 20 + 640]
        if not (location in locations):
            locations.append(location)
            type = random.choice(["tree","flag"])
            if type == "tree": img = "skier_tree.png"
            elif type == "flag": img = "skier_flag.png"
            obstacle = ObstacleClass(img, location, type)
            obstacles.add(obstacle)
def animate():
    screen.fill([255,255,255])
    obstacles.draw(screen)
    screen.blit(skier.image,skier.rect)
    screen.blit(score_text, [10,10])
    pygame.display.flip()
pygame.init()
screen = pygame.display.set_mode([640,640])
clock = pygame.time.Clock()
skier  = SkierClass()
speed = [0,6]
obstacles = pygame.sprite.Group()
map_position = 0
points = 0
create_map()
font = pygame.font.Font(None,50)

running = True
while running:
    clock.tick(30)
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                speed = skier.turn(-1)
            elif event.key == pygame.K_RIGHT:
                speed = skier.turn(1)
    skier.move(speed)
    map_position += speed[1]
    if map_position >= 640:
        create_map()
        map_position = 0

    hit = pygame.sprite.spritecollide(skier,obstacles,False)
    if hit:
        if hit[0].type == "tree" and not hit[0].passed:
            points = points - 100
            skier.image = pygame.image.load("skier_crash.png")
            animate()
            pygame.time.delay(1000)
            skier.angle = 0
            speed = [0,6]
            hit[0].passed = True
        elif hit[0].type == "flag" and not hit[0].passed:
            points += 10
            hit[0].kill()

    obstacles.update()
    score_text = font.render("Score:" + str(points),1,(0,0,0))
    animate()
pygame.quit()

~chp10

---

嵌套与可变循环体

在循环体也就是代码块中可以放置其他代码，这些代码本身也可以是代码块

嵌套循环就是一个循环出现在另一个循环里。对于外循环的每次迭代，内循环都要完成他的所有迭代。

multiplier = 5
for i in range (1,11):
    print(f"{i} x {multiplier} = {i*multiplier}")

如果想一次打印3个乘法表，只需要把原来的循环(打印一个乘法表)包含在一个外循环中(运行三次)，这样，程序就会打印3个乘法表而不只是一个。

for multiplier in range(5,8):
    # multiplier = 5
    for i in range (1,11):
        print(f"{i} x {multiplier} = {i*multiplier}")

也就是内循环打印一个乘法表，外循环分别用567做三次迭代。

可变循环

固定的数(比如range()函数使用的数)也称为常数constant。如果在一个for循环的range（）函数使用常数，程序运行时总会运行相同的次数，在这种情况下，我们称循环次数是硬编码的hard-coded，因为其在编码中被定义了。我们在实际中希望循环次数由用户来决定，或者由程序的另一部分决定，对于这种情况，我们需要一个变量。

例如，假设你要建立一个太空神枪手游戏。只要有外星人消灭就要重绘屏幕。必须要有某个计数器来跟踪还剩下多少外星人，只要屏幕更新，就需要循环处理剩下的外星人在屏幕上画出他们的图像，每次玩家消灭一个外星人时外星人数就要回改变。下面下给出一个可变循环的简单示例：

numStars = int(input("How many stars do you want?"))
for i in range(1,numStars+1):
    print("*",end = "")

可变嵌套循环

就是一个嵌套循环，其中一个或者多个循环在range()函数中使用了变量。

一个可变嵌套循环

numLines = int(input("How many lines of stars do you want?"))
numStars = int(input("How many stars per line?"))
for line in range(0,numLines):
    for star in range(0,numStars):
        print('*',end = " ")
    print()

这里只有连个循环一个外循环一个内循环，也就是一个嵌套循环

现在看嵌套嵌套循环（或者说是双重嵌套循环）

numBlocks = int(input("How many blocks of stars do you want "))
numLines = int(input("How many lines in each blocks? "))
numStars = int(input("How many stars per line? "))
for block in range(0,numBlocks):
    for line in range(0,numLines):
        for star in range(0,numStars):
            print('*',end = " ")
        print()
    print()

更多可变嵌套循环

更复杂的星号块

numBlocks = int(input("How many blocks of stars do you want? "))
for block in range(1,numBlocks + 1):
    for line in range(1,block + 2):
        for star in range(1,(block + line) * 2):
            print('*',end = '')
        print()
    print()

在嵌套循环中打印循环变量

numBlocks = int(input("How many blocks of stars do you want? "))
for block in range(1,numBlocks + 1):
    for line in range(1,block * 2):
        for star in range(1,(block + line) * 2):
            print('*',end = ' ')
        print('line = ',line,'star = ',star)
    print()

How many blocks of stars do you want? 3
* * * line =  1 star =  3

* * * * * line =  1 star =  5
* * * * * * * line =  2 star =  7
* * * * * * * * * line =  3 star =  9

* * * * * * * line =  1 star =  7
* * * * * * * * * line =  2 star =  9
* * * * * * * * * * * line =  3 star =  11
* * * * * * * * * * * * * line =  4 star =  13
* * * * * * * * * * * * * * * line =  5 star =  15

>>> 

使用嵌套循环

我们能够使用嵌套循环做些什么呢，嵌套循环最擅长的工作就是得出一系列决定所有可能的排列组合。

排列permutation，表示结合一组事物的唯一方式。组合combination很相似，区别在于，对于组合来说，顺序并不重要，排列中顺序会有影响。

考虑问题可以使用决策树decision tree ，在每个决策点都有两个选择，是或者否，这棵树的每一条不统的路径分别描述了热狗部分的不同组合。

我们可以使用嵌套循环列出来所有的组合，也就是这颗决策树的所有路径。由于这棵树有5个决策点，所以我们的决策树中有5层，相应的，程序中就会拥有五个循环嵌套。

热狗组合

print("\t\tDog\t\tBun\t\tKetchup\t\tMustand\t\tOnions")
count = 1
for dog in [0,1]:
    for bun in [0,1]:
        for ketchup in [0,1]:
            for mustard in [0,1]:
                for onion in [0,1]:
				  print('#',count,'\t\t',dog,'\t\t',bun,'\t\t',ketchup,'\t\t',mustard,'\t\t',onion)
                    count = count + 1

		Dog		Bun		Ketchup		Mustand		Onions
# 1 		 0 		 0 		 0 		 0 		 0
# 2 		 0 		 0 		 0 		 0 		 1
# 3 		 0 		 0 		 0 		 1 		 0
# 4 		 0 		 0 		 0 		 1 		 1
# 5 		 0 		 0 		 1 		 0 		 0
# 6 		 0 		 0 		 1 		 0 		 1
# 7 		 0 		 0 		 1 		 1 		 0
# 8 		 0 		 0 		 1 		 1 		 1
# 9 		 0 		 1 		 0 		 0 		 0
# 10 		 0 		 1 		 0 		 0 		 1
# 11 		 0 		 1 		 0 		 1 		 0
# 12 		 0 		 1 		 0 		 1 		 1
# 13 		 0 		 1 		 1 		 0 		 0
# 14 		 0 		 1 		 1 		 0 		 1
# 15 		 0 		 1 		 1 		 1 		 0
# 16 		 0 		 1 		 1 		 1 		 1
# 17 		 1 		 0 		 0 		 0 		 0
# 18 		 1 		 0 		 0 		 0 		 1
# 19 		 1 		 0 		 0 		 1 		 0
# 20 		 1 		 0 		 0 		 1 		 1
# 21 		 1 		 0 		 1 		 0 		 0
# 22 		 1 		 0 		 1 		 0 		 1
# 23 		 1 		 0 		 1 		 1 		 0
# 24 		 1 		 0 		 1 		 1 		 1
# 25 		 1 		 1 		 0 		 0 		 0
# 26 		 1 		 1 		 0 		 0 		 1
# 27 		 1 		 1 		 0 		 1 		 0
# 28 		 1 		 1 		 0 		 1 		 1
# 29 		 1 		 1 		 1 		 0 		 0
# 30 		 1 		 1 		 1 		 0 		 1
# 31 		 1 		 1 		 1 		 1 		 0
# 32 		 1 		 1 		 1 		 1 		 1
>>> 

这个正是嵌套循环，即一个循环放在另一个循环中。

• 外循环热狗循环运行两次
• 对热狗循环的每一次迭代，小面包循环运行两次，所以会执行4次
• 对小面包的循环的每一次迭代，番茄酱循环会运行两次，所以他会运行8次
• 依次类推

最内层循环(嵌套最深的循环，也就是洋葱循环)会运行32次，这就涵盖了所有的可能组合，因此也就是共有32种可能的组合。

~chp11_P112

---

import time
for i in range(10,0,-1):
    print(i)
    time.sleep(1)
print("Blast off")

import time
stoptime = int(input("请输入停止时间: "))
for i in range(stoptime,0,-1):
    print(i)
    time.sleep(1)
print("Blast off")

import time
stoptime = int(input("请输入停止时间: "))
for i in range(stoptime,0,-1):
    print(i,end = "\t")
    print("* " * i)
    time.sleep(1)
print("Blast off")

列表

列表很有用，很多陈虚谷都用到了列表，图形和游戏编程我们就是用到了大量的列表。因为游戏中的很多图形对象常常都储存在列表中。

family = ['Mom','Dad','Junior','Baby']
luckyNumber = [2,7,14,26,30]

列表中的单个元素就叫做项或者元素item，就像创建任何其他变量一样，创建列表也是要为他赋某个值。而且还可以创建一个空的列表。在很多情况下我们不知道列表中会有什么，也不知道列表中有多少元素，只知道将会用一个列表来保存这些内容，有了空列表后，程序就可以像这个列表增加元素。

中括号[] 中没有任何元素，所以这个列表是空的，空列表有什么用，为什么要创建一个空列表。我们只知道白纸方便作图。

像列表中增加元素

要像列表中增加元素可以使用append()，

family = [] #创建了一个新的空列表
family.append('David')
print(family)
=========== RESTART: D:/codelife/py_code/idle/fands/0824_creatlist.py ==========
['David']
>>> 
# 再增加一个元素
family.append('Mary')
print(family)
=========== RESTART: D:/codelife/py_code/idle/fands/0824_creatlist.py ==========
>>>['David', 'Mary']

对于friend.append() friend与append()之间的那个点.，这就是对象。pythohn中很多东西都是对象object要想用对象做某种处理，需要向这个对象的名字变量名，然后加一个点，在后面是对对象做的操作。所以要想friends列表追加一个元素，就要写成friends.append(something)

列表中可以包含任何内容

列表中可以包含Python能储存的任何类型的数据，包括数字、字符串、对象，甚至可以包含其他列表，并不要求列表中的元素是同种类型的或是同一种东西，这说明，一个列表中可以包含同时包含不同的类型，列入数字和字符串like this：

my_lists = [5,10,23.67,'hello',myTeacher,7,another_list]

>>>letters = ['a','b','c','d','e']

为什么索引从0开始而不是从1开始，因为二进制数也就是比特，二进制计数从0开始，所以为了搞笑的使用比特位而没有任何浪费，内存位置和列表索引也都从0开始。

索引index表示某个东西的位置，index的复数形式是indices

当然也可以使用索引从列表中一次获取多个元素，这叫做列表的分片slicing，与for循环的range()函数类似，分片获取元素时，会从第一个索引开始，不过到达第二个算因之前停止，要牢记取回的橡树总数就是两个所引数只差。

对于列表分片，对列表分片是取回的是另一个通常是更小的列表称为原列表的一个分片slice，原来的列表并没有改变，这个分片是源列表的部分副本copy

letters = ['a','b','c','d','e']
letters[0]
>>>'a'
letters[:3]
['a', 'b', 'c']
letters[3:]
['d', 'e']
letters[:]
['a', 'b', 'c', 'd', 'e']

我们说过分片也就是切片，是建立在源列表的副本。所以letters[ : ]会建立整个列表的副本。如果想对列表作出修改，但同时还想保持原来的列表不做任何改变，使用这种分片就会很方便。

修改元素

可以使用索引来修改元素

向列表中增加元素

向列表中增加元素总共有3种方法，

• append()像列表尾部增加一个元素
• extend()像列表尾部增加多个元素
• ‘insert()在列表中的某个位置增加一个元素，不一定非得在列表尾部，可以告诉他要增加元素的位置。

增加到为尾部append()，他把一个元素增加到列表尾部。letters.append(’n‘)