[Python知识库]全网最全python教程，从零到精通（学python有它就够必收藏）

1.1. Python的诞生

Python的作者是著名的“龟叔”Guido van Rossum，1989年，龟叔为了打发无聊的圣诞节，开始编写Python语言。1991年，第一个Python编译器诞生。它是用C语言实现的，并能够调用C语言的库文件。

荣登2018年TIOBE年度最佳编程语言，很多大公司，包括google、Yahoo都大量的使用Python。

1.1.1. 提升自己的逼格，你需要了解

Python的发音与拼写
Python的意思是蟒蛇，是取自英国20世纪70年代首播的电视喜剧《蒙提.派森干的飞行马戏团》（Monty Python’s Flying Circus）
Python的作者是Guido van Rossum（龟叔）

Python是龟叔在1989年圣诞节期间，为了打发无聊的圣诞节而用C编写的一个编程语言

Python第一个公开发行版发行于1991年
Python目前有两个主要版本，Python2和Python3，最新版分别为2.7.12和3.7.2
Life is short, you need Python. 人生苦短，我用Python。

1）官 网：https://www.python.org/ 2）中文社区：http://www.pythontab.com/

面向对象的解释型语言
简单易学
丰富的库
强制使用制表符作为语句缩进(white space)

1.1.2. Python各个版本发布时间

1989年由荷兰人Guido van Rossum于1989年发明，第一个公开发行版发行于1991年

Python 1.0 - January 1994 增加了 lambda, map, filter and reduce.
Python 2.0 - October 16, 2000，加入了内存回收机制，构成了现在Python语言框架的基础
Python 2.4 - November 30, 2004, 同年目前最流行的WEB框架Django 诞生
Python 2.5 - September 19, 2006
Python 2.6 - October 1, 2008
Python 2.7 - July 3, 2010
Python 3.0 - December 3, 2008
Python 3.1 - June 27, 2009
Python 3.2 - February 20, 2011
Python 3.3 - September 29, 2012
Python 3.4 - March 16, 2014
Python 3.5 - September 13, 2015

1.1.3. Python主要应用领域

人工智能: 典型库NumPy, SciPy, Matplotlib, TensorFlow
云计算: 云计算最火的语言， 典型应用OpenStack
WEB开发: 众多优秀的WEB框架，众多大型网站均为Python开发，Youtube, Dropbox, 豆瓣。。。， 典型WEB框架有Django，Flask
系统运维: 运维人员必备语言
金融：量化交易，金融分析，在金融工程领域，Python不但在用，且用的最多，而且重要性逐年提高。
图形GUI: PyQT, WxPython,TkInter

1.1.4. Python在一些公司的应用

谷歌：Google App Engine 、code.google.com 、Google earth 、谷歌爬虫、Google广告等项目都在大量使用Python开发
CIA: 美国中情局网站就是用Python开发的
NASA: 美国航天局(NASA)大量使用Python进行数据分析和运算
YouTube:世界上最大的视频网站YouTube就是用Python开发的
Dropbox:美国最大的在线云存储网站，全部用Python实现，每天网站处理10亿个文件的上传和下载
Instagram:美国最大的图片分享社交网站，每天超过3千万张照片被分享，全部用python开发
Facebook:大量的基础库均通过Python实现的
Redhat: 世界上最流行的Linux发行版本中的yum包管理工具就是用python开发的
豆瓣: 公司几乎所有的业务均是通过Python开发的
知乎: 国内最大的问答社区，通过Python开发(国外Quora)
除上面之外，还有搜狐、金山、腾讯、盛大、网易、百度、阿里、淘宝 、土豆、新浪、果壳等公司都在使用Python完成各种各样的任务。

1.2. Python 的安装

因为 Python 是跨平台的，它可以运行在 Windows、Mac 和各种 Linux/Unix 系统上。目前，Python 有两个版本，一个是 2.x 版，一个是 3.x版，这两个版本是不兼容的。安装的是 3.6.1 版本的。

官网地址：https://www.python.org/

是 windows 系统，下载完后，直接安装，不过这里记得勾上Add Python 3.6 to PATH，然后点 “Install Now” 即可完成安装。

Python安装.png

安装完成后，打开命令提示符窗口，敲入 python 后，出现下面的情况，证明 Python 安装成功了。你看到提示符 >>> 就表示我们已经在 Python交互式环境中了，可以输入任何 Python 代码，回车后会立刻得到执行结果。

运行python.png

1.3. Python中文文档

https://docs.python.org/zh-cn/3/

1.4. 集成开发环境 IDE

我们使用Pycharm 下载地址：http://www.jetbrains.com/pycharm

1.4.1. 在Pycharm上运行第一个Python应用程序

1.4.2. 1新建项目

打开PyCharm，单击“file”，然后选中“New Project…"

选择项目要保存的位置，选择python.exe,点击create

3、弹出的窗口里点击ok，项目就创建好了

1.4.3. 2、新建python文件

1、右击项目，点击New ，再点击Python File

2、输入要创建的python文件的名称，点击ok

1.4.4. 3、写代码，运行

1、输入代码 print(“Hello world!”)

image

2、右击空白处，选择Run ‘PrintHello’

1.4.5. 4、运行结果

运行成功，控制台打印出了“Hello world!”

2.1. 变量定义

在 Python 中，每个变量 在使用前都必须赋值，变量 赋值以后 该变量 才会被创建
等号（=）用来给变量赋值
= 左边是一个变量名
= 右边是存储在变量中的值

变量名 = 值

2.1.1. 实例1—— 学生注册

# 定义变量---学生学号
studentNo = "9527"

# 定义变量---学生密码
stuentPassword = "123"

# 在程序中，如果要输出变量的内容，需要使用 print 函数
print(studentNo)
print(stuentPassword)
说明#是代码注释，快捷键是Ctrl+/

Python的代码缩进

Python语言通过缩进来组织代码块，这是Python的强制要求。 下面的代码有误：

# 定义变量---学生学号
    studentNo = "9527"

# 定义变量---学生密码
stuentPassword = "123"

# 在程序中，如果要输出变量的内容，需要使用 print 函数
print(studentNo)
print(stuentPassword)

这样也不行

# 定义变量---学生学号
studentNo = "9527"

# 定义变量---学生密码
stuentPassword = "123"

# 在程序中，如果要输出变量的内容，需要使用 print 函数
    print(studentNo)
print(stuentPassword)

和其他编程语言不同，Python代码对格式要求非常严格。代码写的里出外进，无法通过编译。后面我们在分支，循环，函数，类等知识点时还会多次看到这种情况。

2.1.2. 实例2—— 超市买菜

需求
柿子的价格是 8.5 元/斤
买了 7.5 斤 柿子
计算付款金额

# 定义柿子价格变量
price = 8.5

# 定义购买重量
weight = 7.5

# 计算金额
money = price * weight

print(money)

2.2. 变量的类型

变量的四要素：
变量的名称
变量保存的数据
变量存储数据的类型
变量的内存地址（标识）

2.2.1. 变量类型的演练 —— 表达个人信息

需求
定义变量保存小强的个人信息
姓名：小强
年龄：22 岁
性别：是男生
身高：1.80 米
体重：77.0 公斤
利用 单步调试 确认变量中保存数据的类型

提问
在演练中，一共有几种数据类型？
4 种
str —— 字符串
bool —— 布尔（真假）
int —— 整数
float —— 浮点数（小数）
在 Python 中定义变量时需要指定类型吗？
不需要
Python 可以根据 = 等号右侧的值，自动推导出变量中存储数据的类型

2.2.2. 变量的类型

在 Python 中定义变量是 不需要指定类型（在其他很多高级语言中都需要）
数据类型可以分为 数字型 和 非数字型
数字型
整型 (int)
浮点型（float）
布尔型（bool）
真 True 非 0 数 —— 非零即真
假 False 0
非数字型
字符串
列表
元组
字典
使用 type 函数可以查看一个变量的类型

type(name)

2.2.3. 不同类型变量之间的计算

1) 数字型变量 之间可以直接计算
在 Python 中，两个数字型变量是可以直接进行 算数运算的
如果变量是 bool 型，在计算时
True 对应的数字是 1
False 对应的数字是 0
演练步骤
定义整数 i = 10
定义浮点数 f = 10.5
定义布尔型 b = True
在PyCharm中，使用上述三个变量相互进行算术运算

i = 10
f = 10.5
b = True

print(i+f+b)

21.5

发生了自动类型转换，全部转换成了浮点数。
2) 字符串变量 之间使用 + 拼接字符串
在 Python 中，字符串之间可以使用 + 拼接生成新的字符串

first_name = "三"
last_name = "张"
print(first_name + last_name)

3) 字符串变量 可以和 整数 使用 * 重复拼接相同的字符串

print("-" * 50)

输出

 '--------------------------------------------------'

4) 数字型变量 和 字符串 之间 不能进行其他计算

first_name = "zhang"
x = 10

print( x + first_name)
---------------------------------------------------------------------------
TypeError: unsupported operand type(s) for +: 'int' and 'str'
类型错误：`+` 不支持的操作类型：`int` 和 `str`

解决办法：使用str(x)将x的类型强制转换成字符串类型

first_name = "zhang"
x = 10
print(str(x)+first_name)

2.2.4. 变量的输入

所谓 输入，就是 用代码 获取 用户通过 键盘 输入的信息
例如：去银行取钱，在 ATM 上输入密码
在 Python 中，如果要获取用户在 键盘 上的输入信息，需要使用到 input 函数
1) 关于函数
一个 提前准备好的功能(别人或者自己写的代码)，可以直接使用，而 不用关心内部的细节
目前已经学习过的函数

2) input 函数实现键盘输入
在 Python 中可以使用 input 函数从键盘等待用户的输入
用户输入的 任何内容 Python 都认为是一个 字符串
语法如下：

字符串变量 = input("提示信息：")

3) 其他类型转换函数

4) 变量输入演练 —— 超市买苹果
需求
收银员输入 苹果的价格，单位：元／斤
收银员输入 用户购买苹果的重量，单位：斤
计算并且 输出 付款金额
代码

# 1. 输入苹果单价
price_str = input("请输入苹果价格：")

# 2. 要求苹果重量
weight_str = input("请输入苹果重量：")

# 3. 计算金额
# 1> 将苹果单价转换成小数
price = float(price_str)

# 2> 将苹果重量转换成小数
weight = float(weight_str)

# 3> 计算付款金额
money = price * weight

print(money)

2.2.5. 变量的格式化输出

使用%

苹果单价 9.00 元／斤，购买了 5.00 斤，需要支付 45.00 元

在 Python 中可以使用 print 函数将信息输出到控制台
如果希望输出文字信息的同时，一起输出 数据，就需要使用到 格式化操作符
% 被称为 格式化操作符，专门用于处理字符串中的格式
包含 % 的字符串，被称为 格式化字符串
% 和不同的 字符 连用，不同类型的数据 需要使用 不同的格式化字符

语法格式如下：

print("格式化字符串" % 变量1)

print("格式化字符串" % (变量1, 变量2...))

举个栗子
需求

定义字符串变量 name，输出 我的名字叫 小明，请多多关照！
定义整数变量 student_no，输出 我的学号是 000001
定义小数 price、weight、money，输出 苹果单价 9.00 元／斤，购买了 5.00 斤，需要支付 45.00 元
定义一个小数 scale，输出 数据比例是 10.00%

print("我的名字叫 %s，请多多关照！" % name)
print("我的学号是 %06d" % student_no)
print("苹果单价 %.02f 元／斤，购买 %.02f 斤，需要支付 %.02f 元" % (price, weight, money))
print("数据比例是 %.02f%%" % (scale * 100))

使用format
用法：
它通过{}和:来代替传统%方式
字符串format()方法的基本使用格式是：
<模板字符串>.format(<逗号分隔的参数>)
其中，模板字符串是一个由字符串和槽组成的字符串，用来控制字符串和变量的显示效果。槽用大括号({})表示，对应format()方法中逗号分隔的参数。

str = "{}曰：学而时习之，不亦说乎。".format("孔子")
print(str)

'孔子曰：学而时习之，不亦说乎。'

如果模板字符串有多个槽，且槽内没有指定序号，则按照槽出现的顺序分别对应.format()方法中的不同参数。

"{}曰：学而时习之，不亦{}。".format("孔子","说乎")

'孔子曰：学而时习之，不亦说乎。'

可以通过format()参数的序号在模板字符串槽中指定参数的使用，参数从0开始编号

"{1}曰：学而时习之，不亦{0}。".format("说乎","孔子")

'孔子曰：学而时习之，不亦说乎。'

f-字符串
f-string是 Python 3.6 中定义的一种参数化字符串的方式，主要是让格式化字符串更加便捷。 在 f-string 中，不要再使用 %-格式化 或者 format 函数中的复杂写法，可以直接在字符串中写入变量名。f-string 用 {} 标识变量，区别在于 {} 不再是用来占位的，而是直接写入变量名。 修改上面的格式化例子：

name = input('请输入姓名：')
fondness = input('请输入爱好：')
print(f'{name} 的爱好是 {fondness}！')    # 字符串前面的 f 大小写均可

课上实践 —— 个人名片

需求
在控制台依次提示用户输入：姓名、公司、职位、电话、邮箱
按照以下格式输出：

**************************************************
公司名称

姓名 (职位)

电话：电话
邮箱：邮箱
**************************************************

"""
在控制台依次提示用户输入：姓名、公司、职位、电话、电子邮箱
"""
name = input("请输入姓名：")
company = input("请输入公司：")
title = input("请输入职位：")
phone = input("请输入电话：")
email = input("请输入邮箱：")

print("*" * 50)
print(company)
print()
print("%s (%s)" % (name, title))
print()
print("电话：%s" % phone)
print("邮箱：%s" % email)
print("*" * 50)

课后作业 使用f-string方法实现上述需求。

2.3. 变量的命名

2.3.1. 标识符和关键字

1.1 标识符

标识符就是程序员自己命名的 变量名。 名字 需要有 见名知义 的效果，不要随意起名。
不好的变量命名

c1 = '小朱学长'
n = 1500

好的变量命名

company = '小朱学长'
employeeNum = 1500

标示符可以由 字母、下划线 和 数字 组成
不能以数字开头
不能与关键字重名

1.2 关键字

关键字 就是在 Python 内部已经使用的标识符
关键字 具有特殊的功能和含义
开发者 不允许定义和关键字相同的名字的标示符
通过以下命令可以查看 Python 中的关键字

import keyword
print(keyword.kwlist)

['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 
'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 
'with', 'yield']

关键字的学习及使用，会在后面的课程中介绍

import 关键字 可以导入一个 “工具包”

在 Python 中不同的工具包，提供有不同的工具

2.3.2. 变量的命名规则

命名规则 可以被视为一种 惯例，并无绝对与强制 目的是为了 增加代码的识别和可读性

注意 Python 中的 标识符 是 区分大小写的

userName = 'zhangsan'
print(username)

Traceback (most recent call last):
  File "C:/Users/Administrator/PycharmProjects/hellopython/test.py", line 2, in <module>
    print(username)
NameError: name 'username' is not defined

在定义变量时，为了保证代码格式，= 的左右应该各保留一个空格
在 Python 中，如果 变量名 需要由 二个 或 多个单词 组成时，可以按照以下方式命名
每个单词都使用小写字母
单词与单词之间使用 _下划线 连接
例如：first_name、last_name、qq_number、qq_password

2.4驼峰命名法

当 变量名 是由二个或多个单词组成时，还可以利用驼峰命名法来命名
小驼峰式命名法
第一个单词以小写字母开始，后续单词的首字母大写
例如：firstName、lastName
大驼峰式命名法
每一个单词的首字母都采用大写字母
例如：FirstName、LastName、CamelCase

3.1运算符

3.1.1. 算数运算符

是完成基本的算术运算使用的符号，用来处理四则运算

>>> a=10
>>> b=5
>>> print(a+b)
15
>>> print(a-b)
5
>>> print(a*b)
50
>>> print(a/b)
2.0
>>> print(a**b)
100000
>>> print(a//b)
2
>>> print(a%b)
0

3.1.2. 比较（关系）运算符

>>> a=10
>>> b=20
>>> a==b
False
>>> a!=b
True
>>> a>b
False
>>> a<b
True
>>> a>=b
False
>>> a<=b
True

3.1.3. 逻辑运算符

>>> a=True
>>> b=False
>>> a and b
False
>>> a or b
True
>>> not a
False
>>> not -1
False
>>> not 0
True

3.1.4. 赋值运算符

在 Python 中，使用 = 可以给变量赋值
在算术运算时，为了简化代码的编写，Python 还提供了一系列的 与 算术运算符 对应的 赋值运算符
注意：赋值运算符中间不能使用空格

>>> a=10
>>> b=20
>>> c=0
>>> c=a+b
>>> print(c)
30
>>> c+=10
>>> print(c)
40
>>> c-=a
>>> print(c)
30
>>> c*=a
>>> print(c)
300
>>> c/=a
>>> print(c)
30.0
>>> c%=a
>>> print(c)
0.0
>>> c=a**5
>>> print(c)
100000
>>> c//=b
>>> print(c)
5000
>>> print(b)
20

3.1.5. 运算符的优先级

以下表格的算数优先级由高到最低顺序排列

4.1. 条件语句

Python 条件语句跟其他语言基本一致的，都是通过一条或多条语句的执行结果（ True 或者 False ）来决定执行的代码块。

Python 程序语言指定任何非 0 和非空（None）值为 True，0 或者 None为 False。

4.1.1. if 语句的基本形式

Python 中，if 语句的基本形式如下：

if 判断条件：
    执行语句……
else：
    执行语句……

前面也提到过，Python 语言有着严格的缩进要求，因此这里也需要注意缩进，也不要少写了冒号 : 。

if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。

例如：

# -*-coding:utf-8-*-

results=59

if results>=60:
    print ('及格')
else :
    print ('不及格')

输出的结果为：

不及格

上面也说道，非零数值、非空字符串、非空 list 等，判断为True，否则为False。因此也可以这样写：

num = 6
if num :
    print('Hello Python')

4.1.2. if 语句多个判断条件的形式

有些时候，我们的判断语句不可能只有两个，有些时候需要多个，比如上面的例子中大于 60 的为及格，那我们还要判断大于 90 的为优秀，在 80 到 90 之间的良好呢？

这时候需要用到 if 语句多个判断条件，

用伪代码来表示：

if 判断条件1:
    执行语句1……
elif 判断条件2:
    执行语句2……
elif 判断条件3:
    执行语句3……
else:
    执行语句4……

实例：

# -*-coding:utf-8-*-

results = 89

if results > 90:
    print('优秀')
elif results > 80:
    print('良好')
elif results > 60:
    print ('及格')
else :
    print ('不及格')

输出的结果：

良好

4.1.3. if 语句多个条件同时判断

Python 不像 Java 有 switch 语句，所以多个条件判断，只能用 elif 来实现，但是有时候需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。

# -*-coding:utf-8-*-

java = 86
python = 68

if java > 80 and  python > 80:
    print('优秀')
else :
    print('不优秀')

输出结果：

不优秀

注意：if 有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于 >（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。

java = 86
python = 68

if (80 <= java < 90) or (80 <= python < 90):
    print('良好')

输出结果：

良好

课上练习1

我想买车，买什么车决定于我在银行有多少存款
如果我的存款超过500万，我就买路虎
否则，如果我的存款超过100万，我就买宝马
否则， 如果我的存款超过50万，我就买迈腾
否则， 如果我的存款超过10万，我就买福特
否则， 如果我的存款10万以下 ，我买比亚迪

课上练习2

输入小明的考试成绩，显示所获奖励
成绩==100分，爸爸给他买辆车
成绩>=90分，妈妈给他买MP4
90分>成绩>=60分，妈妈给他买本参考书
成绩<60分，什么都不买

4.2. 循环语句

一般编程语言都有循环语句，循环语句允许我们执行一个语句或语句组多次。

循环语句的一般形式如下：

Python 提供了 for 循环和 while 循环，当然还有一些控制循环的语句：

4.2.1. While 循环语句

count = 1
sum = 0
while count <= 100:
    sum = sum + count
    count = count + 1
print(sum)

输出的结果：

5050

当然 while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于跳出本层循环

比如，上面的例子是计算 1 到 100 所有整数的和，当我们需要判断 sum 大于 1000 的时候，不在相加时，可以用到 break ，退出整个循环

count = 1
sum = 0
while  count <= 100:
    sum = sum + count
    if  sum > 1000:  #当 sum 大于 1000 的时候退出循环
        break
    count = count + 1
print(sum)

输出的结果：

1035

有时候，我们只想统计 1 到 100 之间的奇数和，那么也就是说当 count 是偶数，也就是双数的时候，我们需要跳出当次的循环，不想加，这时候可以用到 continue

count = 1
sum = 0
while  count <= 100:
    if count % 2 == 0:  # 双数时跳过输出
        count = count + 1
        continue
    sum = sum + count
    count = count + 1
print(sum)

输出的语句：

2500

在 Python 的 while 循环中，还可以使用 else 语句，while … else 在循环条件为 false 时执行 else 语句块

比如：

count = 0
while count < 5:
   print (count)
   count = count + 1
else:
   print (count)

输出的结果：

0
1
2
3
4
5

4.2.2. for 循环语句

for循环可以遍历任何序列的项目，如一个字符串
它的流程图基本如下：

基本的语法格式：

for iterating_var in sequence:
   statements(s)

实例：

for letter in 'www.neuedu.com':
    print(letter)

输出的结果如下：

w
w
w
.
n
e
u
e
d
u
.
c
o
m

range()函数

Python函数range()让你能够轻松地生成一系列的数字。例如，可以像下面这样使用函数range()来打印一系列的数字：

for value in range(1,5):
    print(value)

上述代码好像应该打印数字1~5，但实际上它不会打印数字5：

1
2
3
4

在这个示例中，range()只是打印数字1~4，这是你在编程语言中经常看到的差一行为的结果。函数range()让Python从你指定的第一个值开始数，并在到达你指定的第二个值后停止，因此输出不包含第二个值（这里为5）。

要打印数字1~5，需要使用range(1,6)：

for value in range(1,6):
    print(value)

这样，输出将从1开始，到5结束：

    1
    2
    3
    4
    5

4.2.3. 嵌套循环

Python 语言允许在一个循环体里面嵌入另一个循环。上面的实例也是使用了嵌套循环的。
具体的语法如下：
for 循环嵌套语法

for iterating_var in sequence:
   for iterating_var in sequence:
      statements(s)
   statements(s)

while 循环嵌套语法

while expression:
   while expression:
      statement(s)
   statement(s)

除此之外，你也可以在循环体内嵌入其他的循环体，如在 while 循环中可以嵌入 for 循环， 反之，你可以在 for 循环中嵌入 while 循环

有 while … else 语句，当然也有 for … else 语句啦，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。

for num in range(10,20):  # 迭代 10 到 20 之间的数字
   for i in range(2,num): # 根据因子迭代
      if num%i == 0:      # 确定第一个因子
         j=num/i          # 计算第二个因子
         print ('%d 是一个合数' % num)
         break            # 跳出当前循环
   else:                  # 循环的 else 部分
      print ('%d 是一个质数' % num)

输出的结果：

10 是一个合数
11 是一个质数
12 是一个合数
13 是一个质数
14 是一个合数
15 是一个合数
16 是一个合数
17 是一个质数
18 是一个合数
19 是一个质数

课上案例 打印九九乘法表

# 打印九九乘法表
for i in range(1, 10):
        for j in range(1, i+1):
            print('{}x{}={}\t'.format(i, j, i*j), end='')
        print()

1x1=1   
2x1=2   2x2=4   
3x1=3   3x2=6   3x3=9   
4x1=4   4x2=8   4x3=12  4x4=16  
5x1=5   5x2=10  5x3=15  5x4=20  5x5=25  
6x1=6   6x2=12  6x3=18  6x4=24  6x5=30  6x6=36  
7x1=7   7x2=14  7x3=21  7x4=28  7x5=35  7x6=42  7x7=49  
8x1=8   8x2=16  8x3=24  8x4=32  8x5=40  8x6=48  8x7=56  8x8=64  
9x1=9   9x2=18  9x3=27  9x4=36  9x5=45  9x6=54  9x7=63  9x8=72  9x9=81

4.3. 随机数的处理

在 Python 中，要使用随机数，首先需要导入 随机数 的 模块 —— “工具包”

import random

导入模块后，可以直接在 模块名称 后面敲一个 . ，会提示该模块中包含的所有函数

random.randint(a, b) ，返回 [a, b] 之间的整数，包含 a 和 b

例如：

random.randint(12, 20)  # 生成的随机数n: 12 <= n <= 20   
random.randint(20, 20)  # 结果永远是 20   
random.randint(20, 10)  # 该语句是错误的，下限必须小于上限

综合练习—猜数字

计算机要求用户输入数值范围的最小值和最大值。计算机随后“思考”出在这个范围之内的一个随机数，并且重复地要求用户猜测这个数，直到用户猜对了。在用户每次进行猜测之后，计算机都会给出一个提示，并且会在这个过程的最后显示出总的猜测次数。这个程序包含了几种类型的我们学过的 Python 语句，例如，输入语句、输出语句、赋值语句、循环和条件语句。
一个可能的游戏过程如下：

Enter the smaller number: 1
Enter the larger number: 20
Enter your guess: 5
Too small
Enter your guess: 9
Too small
Enter your guess: 15
Too small
Enter your guess: 17
Too large
Enter your guess: 16
You've got it in 5 tries!

import random

smaller = int(input("Enter the smaller number: "))
larger = int(input("Enter the larger number: "))
myNumber = random.randint(smaller, larger)
count = 0
while True:
    count += 1
    userNumber = int(input("Enter your guess: "))
    if userNumber < myNumber:
        print("Too small")
    elif userNumber > myNumber:
        print("Too large")
    else:
        print("You've got it in", count, "tries!")
        break

5.1. 列表定义

列表是Python中内置有序可变序列，列表的所有元素放在一对中括号“[]”中，并使用逗号分隔开；
一个列表中的数据类型可以各不相同，可以同时分别为整数、实数、字符串等基本类型，甚至是列表、字典以及其他自定义类型的对象。
例如：

[1,2,3,2.4,5]
[0.01,"zhangsan",[1,2,3]]

创建
使用“=”直接将一个列表赋值给变量即可创建列表对象。例如：a_list = []，b_list = [1，2,3]
使用list()函数将元组、range对象、字符串或其他类型的可迭代对象类型的数据转换为列表。
例如：a_list = list(“Hello”) 将字符串 “hello” 转换成列表 [‘H’，‘e’，‘l’，‘l’，‘o’]
删除 当不再使用时，使用del命令删除整个列表 例如：

>>>x =[1,2,3]

>>>del  x[1]                    #删除指定位置元素

>>>x

[1，3]

>>>del x                        #删除整个列表

>>>x

Traceback (most recent call last):

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

      x

NameError: name 'x' is not defined

5.2. 列表元素的增加

5.2.1. append()

向列表尾部追加一个元素，不改变其内存首地址，属于原地操作。 例如：

>>>x = [1,2,3]

>>>x.append(4)

>>>x

[1,2,3,4]

5.2.2. insert()

向列表任意位置插入一个元素，不改变其内存首地址，属于原地操作。
例如：

>>>x = [1,3,4]
>>>x.insert(1,2)
>>>x
[1,2,3,4]

5.2.3. extend()

将另一个迭代对象的所有元素添加至该列表对象尾部，不改变其内存首地址，属于原地操作。
例如：

>>>x = [1,2]

>>>x.extend([3,4])

>>>x

[1,2,3,4]

5.3. 运算符" + " 和" * "

并不是真的为列表添加元素，而是创建一个新列表,不属于原地操作，而是返回新列表。

>>> x = [1,2,3]
>>>y = x + [4]
>>>y
[1,2,3,4]
>>>y = x*2
>>>y
[1,2,3,4,1,2,3,4]

此时x保持不变，依旧是[1,2,3]

5.4. 列表元素的删除

5.4.1. pop()

使用列表的pop()方法删除并返回指定（默认为最后一个）位置上的元素，如果给定的索引超出了列表的范围则抛出异常。

>>>x = [1,2,3,4]
>>>x.pop()                        #弹出并返回尾部元素
4
>>>x.pop(1)                     #弹出并返回指定位置的元素
>>>2

5.4.2. remove()

删除首次出现的指定元素，如果列表中不存在要删除的元素，则抛出异常。
例如：

>>>x = [1,2,2,3,4]

>>>x.remove(2)

>>>x

[1,2,3,4]

5.4.3. clear()

清空列表。
例如：

>>>x = [1,2,3,4]

>>>x.clear()

>>>x

[ ]

5.4.4. del

删除列表中的指定位置上的元素。
例如：

>>>x = [1,2,3,4]

>>>del x[1]

>>>x

[1,3,4]

5.5. 列表元素访问与计数

5.5.1. count()

统计指定元素在列表对象中出现的次数。
例如：

>>> x =[1,2,3,3,4,5]

>>>x.count(3)

2

>>>x.count(0)

0

1.5.2. index()

获取指定元素首次出现的下标，若列表对象中不存在指定元素，则抛出异常。
例如：

>>>x = [1,2,3,2,2,4]

>>>x.index(2)

1

5.5.3. in

测试列表中是否存在某元素
例如：

>>>x = [1,2,3,4]

>>>3 in x

True

>>>5 in x

False

5.6. 列表排序

5.6.1. sort()

按照指定规则对所有元素进行排序，默认规则是直接比较规则大小。
例如：

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> import random

>>> random.shuffle(aList)                              #随机降序

>>> aList

[3, 4, 15, 11, 9, 17, 13, 6, 7, 5]

>>> aList.sort()                                              #默认是升序排序

>>> aList.sort(reverse = True)                       #降序排序

>>> aList

[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

5.6.2. reverse()

将列表中所有元素原地逆序排列。

例如：

>>>x = [1,3,2,4,6,5]

>>>x.reverse()

>>>x

[5,6,4,2,3,1]

5.6.3. sorted()

使用内置函数sorted对列表进行排序并返回新列表，不对原列表做任何修改。
例如：

>>>x = [6,4,2,4,1]

>>> sorted(x)                                     #升序排序

[1,2,4,4,6]

>>> sorted(aList,reverse = True)             #降序排序

[6,4,4,2,1]

>>>x

[6,4,2,4,1]

5.6.4. reversed()

返回一个逆序排列后的迭代对象，不对原列表做任何修改。

>>>x =[1,5,3,6,2]

>>>list(reversed(x))

[2,6,3,5,1]

>>>x

[1,5,3,6,2]

5.7. 用于序列操作的常用内置函数

5.7.1. len()

返回列表中的元素个数，同样适用于元组、字典、集合、字符串等。

5.7.2. max()、 min()

返回列表中的最大或最小元素，同样适用于元组、字典、集合、range对象等。

5.7.3. sum()

对列表的元素进行求和运算。

5.7.4. zip()

返回可迭代的zip对象。
例如：

>>> aList = [1, 2, 3]

>>> bList = [4, 5, 6]

>>> cList = zip(a, b)                               #返回zip对象

>>> cList

<zip object at 0x0000000003728908>

>>> list(cList)                                         #把zip对象转换成列表

[(1, 4), (2, 5), (3, 6)]

5.7.5. enumerate()

枚举列表元素，返回枚举对象，其中每个元素为包含下标和值的元组。该函数对元组、字符串同样有效。

例如：

>>> for item in enumerate('abcdef'):
print(item)
(0, 'a')

(1, 'b')

(2, 'c')

(3, 'd')

(4, 'e')

(5, 'f')

5.8. 遍历列表的三种方式

a = ['a','b','c','d','e','f']
for i in a:
    print(i)

for i in range(len(a)):
    print(i,a[i])
for i,ele in enumerate(a):
    print(i,ele)

5.9. 列表推导式

列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，代码具有非常强的可读性。

语法形式：[表达式 for 变量 in 序列或迭代对象]

列表推导式在逻辑上相当于一个循环，只是形式更加简洁。

lis = [i for i in range(100)]
print(lis)

使用列表推导式实现嵌套列表的平铺

>>> vec = [[1,2,3], [4,5,6], [7,8,9]]

>>> [num for elem in vec for num in elem]

[1, 2, 3, 4, 5, 6, 7, 8, 9]

相当于：

>>> vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

>>> result = []

>>> for elem in vec:

    for num in elem:

  result.append(num)

>>> result

[1, 2, 3, 4, 5, 6, 7, 8, 9]

过滤不符合条件的元素 从列表中选择符合条件的元素组成新的列表

>>> aList = [-1,-4,6,7.5,-2.3,9,-11]

>>> [i for i in aList if i>0]

[6, 7.5, 9]

在列表推导式中使用多个循环，实现多序列元素的任意组合，并且可以结合条件语句过滤特定元素

>>> [(x, y) for x in range(3) for y in range(3)]

[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

>>> [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]

[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

列表综合练习
写一个循环，不断的问用户想买什么，用户选择一个商品编号，就把对应的商品添加到购物车里，最终用户输入q退出时，打印购物车里的商品列表

products = [['iphone',6888],['三星',3000],['小米',2500]]
shopping_car = []
flag = True
while flag:
    print("******商品列表******")
    for index,i in enumerate(products):
        print("%s.  %s|  %s" %(index,i[0],i[1]))
    choice = input("请输入您想购买的商品的编号：")
    if choice.isdigit():#isdigit()判断变量是什么类型
        choice = int(choice)
        if choice>=0 and choice<len(products):
            shopping_car.append(products[choice])
            print("已经将%s加入购物车" %(products[choice]))
        else:
            print("该商品不存在")
    elif choice == "q":
        if len(shopping_car)>0:
            print("您打算购买以下商品：")
            for index,i in enumerate(shopping_car):
                print("%s. %s|  %s" %(index,i[0],i[1]))
        else:
            print("您的购物车中没有添加商品")
        flag = False

5.10. 列表切片

使用索引获取列表的元素（随机读取）

列表元素支持用索引访问，正向索引从0开始

  colors=["red","blue","green"]

  colors[0] =="red"

  colors[1]=="blue"

同时，也可以使用负向索引(python中有序序列都支持负向索引)

 colors[-1]=="green"

5.10.1. 列表的切片操作

切片操作不是列表特有的，python中的有序序列都支持切片，如字符串，元组。
切片的返回结果类型和切片对象类型一致，返回的是切片对象的子序列，如：对一个列表切片返回一个列表，字符串切片返回字符串。

  li=["A","B","C","D"]

格式： li[start : end : step]

start是切片起点索引，end是切片终点索引，但切片结果不包括终点索引的值。step是步长默认是1。

     t=li[0:3]        ["A","B","C"]        #起点的0索引可以省略，t=li[:3]

      t=li[2: ]        ["C","D"]           #省略end，则切到末尾

      t=li[1:3]        ["B","C"]

      t=li[0:4:2]       ["A","C"]       #从li[0]到li[3],设定步长为2。

如何确定start和end，他们是什么关系？ 在step的符号一定的情况下，start和end可以混合使用正向和反向索引，无论怎样，你都要保证 start和end之间有和step方向一致元素 间隔，否则会切出空列表

            t=li[0:2]

            t=li[0:-2]

            t=li[-4:-2]

            t=li[-4:2]

上面的结果都是一样的；t为[“A”,“B”]

         t=li[-1:-3:-1]

         t=li[-1:1:-1]

         t=li[3:1:-1]

         t=li[3:-3:-1]

上面的结果都是一样的；t为[“D”,“C”]

         t=li[-1:-3]

         t=li[-1:1]

         t=li[3:1]

         t=li[3:-3]

都切出空列表

同时，step的正负决定了切片结果的元素采集的先后

省略start 和 end表示以原列表全部为目标

t=li[::-1]     t--->["C","B","A"]     #反向切，切出全部 

t=li[:]        t--->["A","B","C","D"]   #正向切全部

5.10.2. 使用切片来原地修改列表内容

>>> aList = [3, 5, 7]

>>> aList[len(aList):] = [9]               #在尾部追加元素

>>> aList

[3, 5, 7, 9]

>>> aList[:3] = [1, 2, 3]                  #替换前3个元素

>>> aList

[1, 2, 3, 9]

>>> aList[:3] = []                         #删除前3个元素

>>> aList

[9]

5.10.3. 使用del与切片结合来删除列表元素

>>> aList = [3,5,7,9,11]

>>> del aList[:3]                          #删除前3个元素

>>> aList

[9, 11]



>>> aList = [3,5,7,9,11]

>>> del aList[::2]                         #删除偶数位置上的元素

>>> aList

[5, 9]

5.10.4. 切片返回的是列表元素的浅复制

所谓浅复制，是指生成一个新的列表，并且把原列表中所有元素的引用都复制到新列表中。

例如：

>>> aList = [3, 5, 7]

>>> bList = aList              #bList与aList指向同一个内存

>>> bList

[3, 5, 7]

>>> bList[1] = 8                #修改其中一个对象会影响另一个

>>> aList

[3, 8, 7]

>>> aList == bList             #两个列表的元素完全一样

True

>>> aList is bList              #两个列表是同一个对象

True

>>> id(aList)                     #内存地址相同

19061816

>>> id(bList)

19061816

>>> aList = [3, 5, 7]

>>> bList = aList[::]                 #切片，浅复制

>>> aList == bList                    #两个列表的元素完全一样

True

>>> aList is bList                    #但不是同一个对象

False

>>> id(aList) == id(bList)            #内存地址不一样

False

>>> bList[1] = 8                      #修改其中一个不会影响另一个

>>> bList

[3, 8, 7]

>>> aList

[3, 5, 7]

5.11. 元组

元组属于不可变序列（元素集合），一旦创建，用任何方法都不可以修改其元素。从形式上，元组的所有元素放在一对圆括号中，元素之间用逗号分隔。

5.11.1. 元组的创建与删除

创建 使用“=”将一个元组赋值给变量
例如：

>>>x = (1,2,3)                               #直接把元组赋值给一个变量
>>>x
(1,2,3)

创建只有一个元素的元组

x =(3)
print(type(x))
x =(3,)
print(type(x))

输出

<class 'int'>
<class 'tuple'>

创建空元组的方法

>>>x = ()                                       #空元组

>>>x

()

>>>x = tuple()                              #空元组

>>>x

()

使用tuple函数将其他序列转换为元组

>>>tuple(range(5))                   

(0,1,2,3,4)

>>> tuple('abcdefg')                          #把字符串转换为元组

('a', 'b', 'c', 'd', 'e', 'f', 'g')

>>> aList

[-1, -4, 6, 7.5, -2.3, 9, -11]

>>> tuple(aList)                                #把列表转换为元组

(-1, -4, 6, 7.5, -2.3, 9, -11)

删除 使用del可以删除元组对象，不能删除元组中的元素

5.11.2. 元组与列表的区别

1.元组中的数据一旦定义就不允许更改。
2.元组没有append()、extend()和insert()等方法，无法向元组中添加元素。
3.元组没有remove()或pop()方法，也无法对元组元素进行del操作，不能从元组中删除元素。
4.从效果上看，tuple( )冻结列表，而list( )融化元组。

5.12. 元组的优点

1.元组的速度比列表更快。
2.元组对不需要改变的数据进行“写保护”将使得代码更加安全。
3.元组可用作字典键（特别是包含字符串、数值和其它元组这样的不可变数据的元组）。元组有时还作为函数的返回值返回（返回多个值）。

6.1. 字符串的常用操作方法

6.1.1. 字符串切片

获取Python字符串中的某字符可以使用索引：

lang = '小朱学长'
print(lang[0])
print(lang[3])

小
学

截取字符串中的一段字符串可以使用切片，切片在方括号中使用冒号:来分隔需要截取的首尾字符串的索引，方式是包括开头，不包括结尾

lang[2:4]
# 学长

当尾索引没有给出时，默认截取到字符串的末尾

lang[2:]
# 学长

当头索引没有给出的时候默认从字符串开头开始截取

lang[:3]
# 小朱学

当尾索引和头索引都没有给出的时候，默认返回整个字符串，不过这只是一个浅拷贝

    lang[:]
    # 小朱学长

当尾索引大于总的字符串长度时，默认只截取到字符串末尾，很明显使用这种方法来截取一段到字符串末尾的子字符串是非常不明智的，应该是不给出尾索引才是最佳实践

    lang[3:100]
    # 长

当头索引为负数时，则是指从字符串的尾部开始计数，最末尾的字符记为-1，以此类推，因此此时应该注意尾索引的值，尾索引同样可以为负数，如果尾索引的值指明的字符串位置小于或等于头索引，此时返回的就是空字符串

    lang[-2:]
    # 学长
    lang[-2,2]
    # ''

切片的第三个参数是步长

s = 'www.neuedu.com'
#### 切片取出来的字符串与原字符串无关，原字符串不变
print(s[6: 10])
print(s[7:: 2])

uedu
eucm

反向取数字需要加上反向步长

print(s[-1: -4: -1])
print(s[-1: 2]) #### 取不到数据，因为步长默认-1
print(s[-1: 2: -1])#### 可以

moc

moc.udeuen.

6.1.2. 把字符串全部大写或小写upper， lower

s = 'www.NEUEDU.com'
print(s.upper())    #### 全部大写
print(s.lower())    #### 全部小写

6.1.3. 判读以xx开头或结尾startswith，endswith

s = 'www.neuedu.com'
print(s.startswith('www'))    #### 判断是否以www开头
print(s.endswith('com'))    #### 判断是否以com结尾

True
True

6.1.4. 查找元素find ，index

s = 'chhengt'
print(s.find('h'))  #### 通过元素找索引找到第一个就返回（可切片）
print(s.find('b'))  #### 找不到返回 -1
print(s.index('b'))   #### 找不到会报错

Traceback (most recent call last):
1
  File "C:/Users/Administrator/PycharmProjects/textgame/tests/test_bag.py", line 4, in <module>
-1
    print(s.index('b'))   #### 找不到会报错
ValueError: substring not found

6.1.5. strip 默认去除字符前后两端的空格， 换行符， tab

s = 'qqwalex qqwusir barryy'
print(s.strip('qqw'))
print(s.strip(''))
print(s.lstrip('yy'))
print(s.rstrip('yy'))

alex qqwusir barryy
qqwalex qqwusir barryy
qqwalex qqwusir barryy
qqwalex qqwusir barr

6.1.6. split 把字符串分割成列表

#### 分割出的元素比分隔符数+1  ***
#### 字符串变成->>>列表
s = 'qqwalex qqwusir barryy'
s1 = 'qqwale;x qqwu;sir bar;ryy'
print(s.split())    #### 默认以空格分割
print(s1.split(';'))    #### 以指定字符分割
print(s1.split(';', 1)) #### 指定分割多少个

['qqwalex', 'qqwusir', 'barryy']
['qqwale', 'x qqwu', 'sir bar', 'ryy']
['qqwale', 'x qqwu', 'sir bar;ryy']

6.1.7. join把列表转化成字符串

#### 列表转化成字符串 list --> str
s = 'alex'####看成字符列表
li = ['aa', 'ddj', 'kk']    #### 必须全是字符串
s1 = '_'.join(s)
print(s1)
s2 = ' '.join(li)
print(s2)

a_l_e_x
aa ddj kk

6.1.8. is系列

#### 字符串.isalnum()    所有字符都是数字或者字母，为真返回 Ture，否则返回 False。
#### 字符串.isalpha()     所有字符都是字母，为真返回 Ture，否则返回 False。
#### 字符串.isdigit()     所有字符都是数字，为真返回 Ture，否则返回 False。
#### 字符串.islower()    所有字符都是小写，为真返回 Ture，否则返回 False。
#### 字符串.isupper()    所有字符都是大写，为真返回 Ture，否则返回 False。
#### 字符串.istitle()            所有单词都是首字母大写，为真返回 Ture，否则返回 False。
#### 字符串.isspace()    所有字符都是空白字符，为真返回 Ture，否则返回 False。    

#### is 系列
name = 'taibai123'
print(name.isalnum())   #### 字符串由数字或字母组成时返回真
print(name.isalpha())   #### 字符只由字母组成时返回真
print(name.isdigit())   #### 字符只由数字组成时返回真

6.1.9. count 计算字符串中某个字符出现的次数 *

#### count 计算字符串中某个字符出现的次数  ***
s = 'www.neuedu.com'
print(s.count('u'))
print(s.count('u', 7))

2
1

6.1.10. replace 替换字符串中指定的字符

s = 'asdf 之一，asdf也，asdf'
#### replace  ***
s1 = s.replace('asdf', '日天')
print(s1)
s1 = s.replace('asdf', '日天', 1)
print(s1)

日天 之一，日天也，日天
日天 之一，asdf也，asdf

6.1.11. format格式化输出

#### format 格式化输出  ***
#### 第一种方式：
s = '我叫{}, 今年{}， 性别{}'.format('小五', 25, '女')
print(s)
#### 第二种方式
s1 = '我叫{0}, 今年{1}， 性别{2}，我依然叫{0}'.format('小五', 25, '女')
print(s1)
#### 第三种方式
s2 = '我叫{name}, 今年{age}， 性别{sex}，我依然叫{name}'.format(age=25, sex='女',name='小五')
print(s2)

我叫小五, 今年25， 性别女
我叫小五, 今年25， 性别女，我依然叫小五
我叫小五, 今年25， 性别女，我依然叫小五

6.1.12. capitalize() 首字母大写

s = 'chen wuang4fhsa￥fh。f'
#### capitalize() 首字母大写 **
s1 = s.capitalize()
print(s1)

Chen wuang4fhsa￥fh。f

6.1.13. center() 将字符串居中可以设置总长度，可以设置填充物

#### center() 将字符串居中可以设置总长度，可以设置填充物 *
s = 'chenziwu'
s2 = s.center(50)
s2 = s.center(50, '*')
print(s2) 

*********************chenziwu*********************

6.1.14. title 非字母隔开的每个单词的首字母大写 *

s = 'chen wuang4fhsa￥fh。f'
#### title  非字母隔开的每个单词的首字母大写 *
s4 = s.title()
print(s4)

Chen Wuang4Fhsa￥Fh。F

6.1.15. 字符串是不可变变量，不支持直接通过下标修改

msg = 'abcdefg'
# msg[2] = 'z'

msg = msg[:2] + 'z' + msg[3:]

print(msg)

6.2. 综合练习 龟兔赛跑

(模拟龟兔赛跑)本练习中要模拟龟兔赛跑的寓言故事。用随机数产生器建立模拟龟兔赛跑的程序。 对手从70个方格的第1格开始起跑，每格表示跑道上的一个可能位置，终点线在第70格处。 第一个到达终点的选手奖励一个新鲜萝卜和莴苣。兔子要在山坡上睡一觉，因此可能失去冠军。 有一个每秒钟滴答一次的钟，程序应按下列规则调整动物的位置：

用变量跟踪动物的位置(即位置号1到70)。每个动物从位置1开始，如果动物跌到第1格以外，则移回第1格。 产生随机整数1≤i≤10)，以得到上表中的百分比。对于乌龟，1≤i≤5时快走，6≤i≤7时跌跤，8≤i≤10时慢走，兔子也用相似的方法。 起跑时，打印： BANG !!! AND THEY’ RE OFF !!! 时钟每次滴答一下(即每个重复循环)，打印第70格位置的一条线，显示乌龟的位置T和兔子的位置H。 如果两者占用一格，则乌龟会咬兔子，程序从该位置开始打印 OUCH!!!。除T、H和OUCH!!!以外的其他打印位置都是空的。 打印每一行之后，测试某个动物是否超过了第70格，如果是,则打印获胜者，停止模拟。 如果乌龟赢，则打印TORTOISE WINS!!!YAY!!!。如果兔子赢，则打印Hare wins．Yush。 如果两个动物同时赢，则可以同情弱者，让乌龟赢，或者打印It’s a tie。如果两者都没有赢，则再次循环，模拟下一个时钟滴答。 准备运行程序时，让一组拉拉队看比赛，你会发现观众有多么投入。

from random import randint
import time

print('begin')
hPos = 0
tPos = 0

while True:
    paodao = '_' * 70
    n = randint(0,10) + 1
    if n <= 5:
        tPos += 3
    elif 5 < n <= 7:
        tPos -= 6
    else:
        tPos += 1

    if n <= 2:
        hPos = hPos
    elif 3 <= n <= 4:
        hPos += 9
    elif n == 5:
        hPos -= 12
    elif 6 <= n <= 8:
        hPos += 1
    else:
        hPos -= 2

    if tPos >= 70 or hPos >= 70:
        break

    if tPos == hPos:
        paodao = paodao[:tPos] + '咬' + paodao[tPos:]
    else:
        paodao = paodao[:tPos] + '龟' + paodao[tPos:]
        paodao = paodao[:hPos] + '兔' + paodao[hPos:]

    print(paodao)
    time.sleep(0.5)

if tPos > 70:
    print('龟赢')
else:
    print('兔赢')

6.3. 综合练习 猜单词游戏

任务目的

1.掌握字符串常用操作 2.掌握随机数的用法 3.掌握控制台基本输入输出 4.掌握循环，分支条件的用法 5.培养编程思维，提高分析问题能力`

任务描述

需求

给定单词数组（不少于10个），程序随机选择其中的一个，并显示单词字符长度个横线（-），用户有5次猜测机会，用户每次猜一个字母，如果正确，则将在相应的位置上显示出来；如错误则猜测机会减一，重复该过程，直至单词的全部字母全部猜出或者猜测次数用完，最后宣布用户胜利或失败。

实例

例如随机选出的单词是apple，程序先打印- - - - - 用户输入p，程序打印 -pp-- 用户输入e，程序打印 -pp-e 用户输入t，程序打印 -pp-e 您还有4次机会 用户输入a，程序打印 app-e 用户输入l，程序打印 apple 恭喜您，取得胜利。

任务注意事项

请注意代码风格的整齐、优雅 代码中含有必要的注释 代码

import random
words = ['program','banana','tiger','policeman','interface']
index = random.randint(0,len(words) - 1)
word = words[index]
print(word)
wordbak = '-' * len(word)
print(wordbak)
guessTimes = 5
wordlst = list(wordbak)

while True:

    if guessTimes <= 0:
        break
    if '-' not in wordlst:
        break
    char = input('请输入一个字符：')
    if char in word:
        for i,c in enumerate(word):
            if c == char:
                wordlst[i] = char
    else:
        guessTimes -= 1
        print('你还剩下{}次机会'.format(guessTimes))

    print(''.join(wordlst))

if guessTimes > 0:
    print('you win')
else:
    print('you lose')