2020-8-5 Python3语言基础1：语法入门
基本语法
在python中严格区分大小写
在python中的每一行就是一条语句，每条语句以换行结束
在python中每一行语句不要过长（规范建议中每行不要超过80个字符）
一条语句可以分为多行编写，语句后面以\结尾python是缩进严格的语言，所以不要在python中随便写缩进
在python中使用#表示注释，#后边的内容都属于注释，注释的内容将会被编辑器所忽略我们可以通过注释来对程序进行解释说明，一般情况下会在#后边跟着一个空格
字面量和变量
字面量就是一个一个的值，比如：1,2,3,'hello'
- 字面量所表示的意思就是他的字面的值。在程序中可以直接使用字面量
变量（variable）可以用来保存字面量，并且变量中保存的字面量是不定的
- 变量本身没有任何意思，它会根据不同的字面量表示不同的意思
一般我们在开发时，很少直接使用字面量，都是将字面量保存到变量中，通过变量来引用字面量
变量和标识符
变量
# python中使用变量，不需要声明，直接为变量赋值即可
a = 10
# 不能使用没有进行过赋值的变量
# 如果使用没有赋值过的变量，会报错 NameError：name 'b' is not defined
# print(b)
# python是一个动态类型的语言，可以为变量赋任意类型的值，也可以任意修改变量的值
a = 'hello'
print(a)
标识符
# 在python中所有可以自主命名的内容都属于标识符
# 比如：变量名、函数名、类名
# 标识符必须遵循标识符的规范
# 1.标识符中可以含有字母、数字、_(下划线)，但是不能以数字开头
# 例子：a_1 _a1 _1a
# 2.标识符不能是python中的关键字和保留字，也不建议使用python中的函数名作为标识符，这样会导致函数被覆盖
# 3.命名规范：
# 在python中注意遵循两种命名规范：
# 下划线命名法
# 所有字母小写，单词之间使用_分割
# 如：max_length min_length xxx_yyy_zzz
# 帕斯卡命名法（大驼峰命名法）
# 首字母大写，每个单词开头字母大写，其余字母小写
# 如：MaxLength MinLenth XxxYyyZzz
# 如果使用不符合标准的标识符，将会报错SyntaxError：invalid syntax
练习：尝试自己定义几个变量（复杂一些，尝试不同的命名法），然后打印出一些变量。通过搜索引擎搜索看看还有哪些其他的命名规范
数据类型
数据类型指的就是变量的值的类型，也就是可以为变量赋哪些值
- 数值
- 整形
- 布尔值
- 浮点型
- 复数
- 整形
- 字符串
- 空值
数值
# 在python中数值分为三种：整数、浮点数（小数）、复数
# 在python中所有的整数都是int类型
a = 10
b = 20
# 在python中的整数大小没有限制，可以是一个无限大的整数
# c = 999999999999999999999999 ** 100
# 如果数字的长度过大，可以使用下划线作为分隔符
c = 123_456_789
# d = 0123 10进制的数字不能以0开头
# 其他进制的整数
# 二进制 0b开头
c = 0b10 # 二进制的10
# 八进制 0o
c = 0o10
# 16进制 0x开头
c = 0x10
# 也可以通过运算符来对数字进行运算,并且可以保证整数运算的精确
c = 100
c = c + 3
# 浮点数（小数），在python中所有的小数都是float类型
c = 1.23
# 对浮点数进行运算时可能会得到一个不精确的结果
c = 0.1 + 0.2 # 0.30000000000000004
print(c)
字符串
# 字符串用来表示一段文本信息，字符串是程序中使用的最多的数据类型
# 在python中字符串需要使用引号引起来
s = 'hello'
# s = abc # 字符串必须要用引号引起来，不使用不是字符串
# 引号可以是单引号，也可以是双引号，但是注意不能混着用
# s = 'hello" 引号不能混合使用，SyntaxError: EOL while scanning string literal
# 相同的引号之间不能嵌套
# s = "子曰："学而时习之，不亦乐乎！""
s = '子曰："学而时习之，不亦乐乎！"'
# 长字符串
# 单引号和双引号不能跨行使用
s = '锄禾日当午，\
汗滴禾下土。\
谁知盘中餐，\
粒粒皆辛苦。'
# 使用三重引号来表示一个长字符串’‘’ “”“
# 三重引号可以换行，并且会保留字符串中的格式
s = '''锄禾日当午，
汗滴禾下土。
谁知盘中餐，
粒粒皆辛苦。'''
# 转义字符
# 可以使用 \ 作为转义字符，通过转义字符可以在字符串中使用一些特殊的内容
# 例子：
# \' 表示'
# \" 表示"
# \t 表示制表符（Tab键）
# \n 表示换行符
# \\ 表示\
# \uxxxx 表示Unicode编码
s = "子曰：\"学而时习之，不亦乐乎！\""
s = '\u0040' # 表示@
print(s)
格式化字符串
# 字符串之间也可以进行加法运算
# 如果将两个字符串进行相加，则会自动将两个字符串拼接成一个
a = 'abc' + '哈哈哈'
# a = 123
# 字符串不能和其他的类型进行加法运算，如果做了会出现异常 TypeError: can only concatenate str (not "int") to str
# print('a = ' + a) # 这种写法在python中不常见
a = 123
print('a =', a)
# 在创建字符串时，可以在字符串中指定占位符
# %s 字符串中表示任意字符
# %f 浮点数占位符
# %d 整数占位符
b = 'Hello %s'%'孙悟空'
b = 'Hello %s 你好 %s'%('Tom','猪八戒')
b = 'Hello %3.5s'%'abcdefg' # %3.5s字符串的长度限制在3~5之间
b = 'Hello %s'%123.456
b = 'Hello %.2f'%123.456
b = 'Hello %d'%123.55
print('a =%s'%a)
# 格式化字符串，可以通过在字符串前添加一个f来创建一个格式化字符串
# 在格式化字符串中可以直接嵌入变量
c = f'hello {a} {b}'
print(f'c = {c}')
练习：创建一个变量保存你的名字，然后通过4种格式化字符串的方式。在命令行中显示 欢迎 xxx 光临！
name = '奥特曼'
# 拼串
print('第1种方式：欢迎' + name + '光临！')
# 多个参数
print('第2种方式：欢迎', name, '光临！')
# 占位符
print('第3种方式：欢迎%s光临！'%name)
# 格式化字符串
print(f'第4种方式：欢迎{name}光临！')
字符串的复制
# 字符串的复制（将字符串和数字相乘）
a = 'abc'
# * 在语言中表示乘法
# 如果将字符串和数字相乘，则解释器会将字符串指定次数并返回
a = a * 20
print(a)
布尔值和空值
# 布尔值主要用来做逻辑判断
# 布尔值一共有两个 True 和 False
# True表示真 False表示假
a = True
a = False
# print('a = ',a)
# 布尔值实际上也属于整形，True相当于1，False相当于0
# print(1 + True)
# None(空值)
# None专门用来表示不存在
类型检查
# 通过类型检查，可以检查指定值（变量）的类型
a = 123
b = '123'
# print('a = ', a)
# print('b = ', b)
# type()函数用来检查值的类型
# 该函数会将检查的结果作为返回值返回，可以通过变量来接收函数的返回值
c = type(123)
c = type(a)
# print(type(b))
print(type(1)) # <class 'int'>
print(type(1.5)) # <class 'float'>
print(type(True)) # <class 'bool'>
print(type('hello')) # <class 'str'>
print(type(None)) # <class 'NoneType'>
类型转换
# 所谓的类型转换，就是将一个类型的对象转换为另一个对象
# 类型转换不是改变对象本身的类型，而是根据当前对象的值创建一个新的对象
# 类型转换的4个函数int()、float()、str()、bool()
# int()可以用来将其他对象转换为整形
# 规则：
# 布尔值：True -> 1 False -> 0
# 浮点数：直接取整，省略小数点后的内容
# 字符串：合法的整数字符串直接转换为对应数字；如果不是一个合法的整数字符串，则报错 ValueError: invalid literal for int() with base 10: '11.5'
# 对于其他不可以转换为整形的对象，则会抛出异常 ValueError
# float()和int()基本一致，不同的是它会将对象转换为浮点数
# str()可以将对象转换为字符串
# True -> 'True'
# False -> 'False'
# .....
# bool()可以将对象转换为布尔值，任何对象都可以转换为布尔值
# 规则：对于所有表示空性的对象都会转换成False（空性的对象：0、None、''），其余转换为True
a = True
# 调用int（）函数将a转换为整形
# int（）函数不会对原来的变量产生影响，他是将对象转换为指定的类型并将其作为返回值返回
# 如果希望修改原来的变量，则需要对变量进行重新赋值
a = int(a)
a = False
a = int(a)
a = 11.6
a = int(a)
a = '11.5'
# a = int(a)
a = None
# a = int(a)
a = 1
a = float(a)
print('a =',a)
print('a的类型是', type(a))
b = 456
print('hello' + str(b))
对象（Object）
- python是一门面向对象的语言
- 一切皆对象
- 程序运行中，所有的数据都是存储到内存当中然后在运行的
- 对象就是内存中专门用来存储指定数据的一块区域
- 对象实际上就是一个容器，专门用来存储数据
对象的结构
-
每个对象中都要保存三种数据
— id（标识）
— id用来表示对象的唯一性，每一个对象都有唯一的id — 对象的id就相当于人的身份证号一样 — 可以通过id（）查看对象id — id是由解析器生成的，在CPython中，id就是对象的内存地址 — 对象一旦创建，id不能修改— type（类型）
— 类型用来表示当前对象所属的类型 — 比如：int、str、bool — 类型决定了对象有哪些功能 — python是一门强类型的语言，对象一旦创建类型便不能修改— value（值）
— 值就是对象中存储的具体的数据 — 对于有些对象值是可以改变的 — 对象可以分为两大类，可变对象（值可以改变）和不可变对象（值不可以改变）之前学习的对象都是不可变对象
**练习：尝试自己画一下内存结构**
变量和对象
对象并没有直接存储到变量中，在python中变量更像是给对象起了一个别名
变量中存储的不是对象的值，而是对象的id（内存地址），当我们使用变量时，实际上就是通过对象id查找对象。
变量中保存的对象，只有在为变量重新赋值时才会改变
变量和变量之间是相互独立的，修改一个变量不会影响另一个变量
运算符（操作符）
运算符可以对一个值或者多个值进行运算或者各种操作
运算符的分类：
- 算术运算符
- 赋值运算符
- 比较运算符（关系运算符）
- 逻辑运算符
- 条件运算符（三元运算符）
算术运算符
# 算术运算符
# + 加法运算符(如果是两个字符串之间进行加法运算，则会进行拼串操作)
# - 减法运算符
# * 乘法运算符(如果将字符串和数字相乘，则会对字符串进行复制操作，将字符串重复指定次数)
# / 除法运算符，运算时结果总会返回一个浮点类型
# // 整除，只会保留计算后的整数位,总会返回一个整形
# ** 幂运算，求一个值的几次幂
# % 取模，求两个数相除的余数
a = 10 + 5 # 计算
a = 'hello' + ' ' + 'world' # 拼串
a = 10 -5 # 计算
a = a - 2 # 用变量a的值减去2，然后在赋值给a
# a = 'hello' - 5 #TypeError: unsupported operand type(s) for -: 'str' and 'int'
# a = a / 0 # 除数不能为0，ZeroDivisionError: division by zero
a = a // 3
a = 10 ** 5
a = 16 ** 0.5 # 求16的平方根
a = 17 % 10
print(a)
赋值运算符
# 赋值运算符
# = 可以将等号右侧的值赋值给等号左侧的变量
# += a += 5 相当于 a = a + 5
# -= a -= 5 相当于 a = a - 5
# *= a *= 5 相当于 a = a * 5
# **= a **= 5 相当于 a = a ** 5
# /= a /= 5 相当于 a = a / 5
# //= a //= 5 相当于 a = a // 5
# %= a %= 5 相当于 a = a % 5
a = 10
# a = a + 5
a += 5
a = 25.0 # 对浮点数做运算时返回的是一个浮点数
a //= 5
print(a)
比较运算符（关系运算符）
# 比较运算符（关系运算符）
# 关系运算符用来比较两个值之间的关系，总会返回一个布尔值，如果关系成立，返回True，否则返回False
# > 比较左侧值是否大于右侧值
# < 比较左侧值是否小于右侧值
# >= 比较左侧值是否大于或等于右侧值
# <= 比较左侧值是否小于或等于右侧值
# == 比较两个对象的值是否相等
# != 比较两个对象的值是否不相等
# 相等和不等比较的是对象的值，而不是id
# is 比较两个对象是否是同一个对象，比较的是对象的id
# is not 比较两个对象是否不是同一个对象，比较的是对象的id
result = 10 > 20 # False
result = 30 > 20 # True
result = 30 < 20 # False
result = 10 >= 10 # True
# result = 1 > '1' # TypeError: '>' not supported between instances of 'int' and 'str'
result = '2' > '1' # True
result = '2' > '11' # True
# 在python中可以对两个字符串进行大于（等于）或者小于（等于）的运算，当对字符串进行比较时，实际上比较的是字符串的Unicode编码
# 利用该特性可以对字符串按照字母顺序进行排序，但是对于中文来说意义不是特别大
# 注意：如果不希望比较两个字符串的Unicode编码，则需要将其转换为数字然后在比较
# 在比较两个字符串的Unicode编码时，是逐位比较的
# 0061 > 0062
result = 'a' > 'b' # False
result = 'aa' == 'aa' # True
result = 'aa' != 'AA' # True
print('result =', result)
逻辑运算符
# 逻辑运算符
# 逻辑运算符主要做一些逻辑判断
# not 逻辑 非
# not可以对符号右侧的值进行非运算
# 对于布尔值，非运算会对其进行取反操作，True变成False，False变成True
# 对于非布尔值，非运算会先将其转换为布尔值然后在取反
#
# and 逻辑 与
# and可以对符号两侧的值进行与运算
# 只有在符号两侧的值都为True时，才会返回True，只要有一个False就返回False
# 与运算是找False
# python中的与运算是短路的与，如果第一个值为False，则不再看第二个值
#
# or 逻辑 或
# or可以对符号两侧的值进行或运算
# 或运算两个值只要有一个True就会返回True，两个值都会False才会返回False
# 或运算是找True
# python中的或运算是短路的或，如果第一个值为True，则不再看第二个值
#
# 逻辑运算符可以连着使用
result = 1 < 2 < 3 # 相当于1 < 2 and 2 < 3
a = True
a = not a
a = 1
a = ''
a = not a
print('a =', a)
result = True and True # True
result = True and False # False
result = False and True # False
result = False and False # False
# print(result)
True and print('你猜我出不出来？') # 第一个值是True，会看第二个值，所以print（）会执行
False and print('你猜我还出不出来？') # 第一个值是False，不会看第二个值，所以print（）不会执行
result = True or True # True
result = True or False # True
result = False or True # True
result = False or False # False
print(result)
True or print('你猜我出不出来？') # 第一个值是True，不会看第二个值，所以print（）不会执行
False or print('你猜我还出不出来？') # 第一个值是False，会看第二个值，所以print（）会执行
**练习：尝试对布尔值和非布尔值进行三种逻辑运算，并观察返回结果**
# 非布尔值的与或运算
# 我们对非布尔值进行与或运算时，python会将其当做布尔值运算，最终会返回原值
# 与运算的规则
# 与运算是找False，如果第一个值是False，则不看第二个值
# 如果第一个值是False，则直接返回第一个值，否则返回第二个值
# 或运算的规则
# 与运算是找True，如果第一个值是True，则不看第二个值
# 如果第一个值是False，则直接返回第一个值，否则返回第二个值
# True and True
result = 1 and 2 # 2
# True and False
result = 1 and 0 # 0
# False and True
result = 0 and 1 # 0
# False and False
result = 0 and None # 0
print(result)
# True or True
result = 2 or 1 # 2
# True or False
result = 1 or 0 # 1
# False or True
result = 0 or 1 # 1
# False or False
result = 0 or None # None
print(result)
条件运算符（三元运算符）
# 条件运算符
# 语法：语句1 if 条件表达式 else 语句2
# 执行流程：
# 条件运算符在执行时，会先对条件表达式进行求职判断，
# 如果判断结果为True，则执行语句1，并返回执行结果
# 如果判断结果为False，则执行语句2，并返回执行结果
# print('hello') if True else print('你好')
a = 10
b = 20
# print('a的值比较大！') if a > b else print('b的值比较大')
# 获取a和b之间的较大值
max = a if a > b else b
print(max)
练习：现在有a b c三个变量，三个变量分别保存三个数值，请通过条件运算符获取三个值中的最大值
a = 40
b = 20
c = 30
# 通过条件运算符获取三个值中的最大值
# max = a if a > b else b
# max = max if max > c else c
max = a if a > b and a > c else b if b > c else c
print(max)
运算符的优先级
# 和数学中一样，在python运算也有优先级，比如先乘除后加减
# 运算符的优先级可以根据优先级的表格（python官方文档）来查询
# 在表格中位置越靠下的运算符优先级越高，优先级越高的越优先计算
# 如果优先级一样则自左向右计算
# 在开发中如果遇到优先级不清楚的情况可以添加小括号来改变运算顺序
a = 1 + 2 * 3
print(a)
# 判断与和或谁的优先级高，一样高 and 高 or 高
# 如果or的优先级高，或者两个运算符的优先级一样高
# 则需要先进行或运算,则运算结果是3
# 如果and的优先级高，则应该先计算与运算
# 则运算结果是1
a = 1 or 2 and 3
print(a)
流程控制语句
简介
python代码在执行时是按照自上像下顺序执行的
通过流程控制语句，可以改变程序的执行顺序，也可以让指定的程序反复执行多次
流程控制语句分成两大类：条件判断语句，循环语句
条件判断语句
if
# 条件判断语句（if语句）
# 语法：if 条件表达式:语句
# 执行的流程：if语句在执行时，会先对条件表达式进行求值判断，
# 如果为True，则执行if后的语句
# 如果为False，则不执行
# 默认情况下，if语句只会控制紧随其后的那条语句，如果希望if可以控制多条语句，则可以在if后跟着一个代码块
# 代码块
# 代码块中保存着一组代码，同一组代码块中的代码要么都执行要么都不执行
# 代码块就是一种为代码分组的机制
# 如果要编写代码块，语句就不能紧随在：后边，而是要写在下一行
# 代码块以缩进开始，知道代码恢复到之前的缩进级别时结束
# 缩进有两种方式，一种是使用Tab键，一种是使用空格（四个空格）
# python的官方文档中，推荐我们使用空格来缩进
# python代码中使用的缩进方式必须统一
num = 10
if num > 10 : print('num比10大~')
if True :
print(123)
print(456)
print('hello')
# 可以使用逻辑运算符来连接多个条件，
# 如果希望所有条件同时满足，则需要使用and
# 如果希望只要有一个条件满足即可，则需要使用or
if num > 5 and num < 15:
print('num大于5小于15')
if-else
# 条件判断语句（if-else语句）
# 语法：if 条件表达式:
# 代码块
# else：
# 代码块
# 执行流程：
# if-else语句在执行时，先对if后的条件表达式进行求值判断
# 如果为True，则执行if后的代码块
# 如果为False，则执行else后的代码块
age = int(input('请输入你的年龄：'))
if age >= 18 :
print('你已经成年了！')
else:
print('你还未成年！')
if-elif-else
# 条件判断语句（if-elif-else语句）
# 语法：if 条件表达式:
# 代码块
# elif 条件表达式:
# 代码块
# elif 条件表达式:
# 代码块
# else：
# 代码块
# 执行流程：
# if-elif-else语句在执行时，会自上向下依次对条件表达式进行判断，
# 如果表达式的结果为True，则执行当前代码块，然后语句结束
# 如果表达式的结果为False，则继续向下判断，直到找到True为止
# 如果所有的表达式都为False，则执行else后的代码块
# if-elif-else中只会有一个代码块执行
age = int(input('请输入你的年龄：'))
if age >= 200 :
print('活着可真没劲！')
elif 200 > age >= 100:
print('你也是老大不小了')
elif 100 > age >= 60:
print('你已经退休了')
elif 60 > age >= 30:
print('你已经中年了')
elif 30 > age >= 18:
print('你已经成年了')
else:
print('你还未成年！')
input()函数
练习：在命令行让用户输入一个用户名，获取用户名输入，并进行判断。
如果用户输入的是admin，则显示欢迎管理员光临
如果用户输入的是其他，则什么也不显示
# input()函数
# 该函数用来获取用户的输入
# input()调用后，程序会立即暂停，等待用户输入
# 用户输入完成内容以后，点击回车程序才会继续向下执行
# 用户输入完成以后，其所输入的内容会以返回值的形式返回
# 注意：input()函数的返回值是一个字符串
# input()函数中可以设置一个字符串作为参数，这个字符串将会作为提示文字显示
# input()也可以用户暂时阻止程序结束
# 获取用户输入的用户名
user = input('请输入用户名：')
# 判断用户名是否是admin
if user == admin :
print('欢迎管理员光临')
练习
# 练习1：
# 编写一个程序，获取一个用户输入的整数。然后通过程序显示这个数是奇数还是偶数。
# 获取用户输入的整数
num = int(input('请输入一个整数：'))
# 判断num是奇数还是偶数
if num % 2 == 0 and num != 0:
print(num, '是一个偶数。')
elif num == 0:
print(num, '既不是奇数也不是偶数。')
else:
print(num, '是一个奇数。')
# 练习2：
# 编写一个程序，检查任意一个年份是否是闰年。
# 如果一个年份可以被4整除不能被100整除，或者可以被400整除，这个年份就是闰年
year = int(input('请输入需要判断年份：'))
if year % 400 == 0:
print(year, '是闰年')
else:
print('不是闰年')
# 练习3：
# 我家的狗5岁了，5岁的狗相当于多大年龄的人呢？
# 其实非常简单，狗的前两年每一年相当于人类的10.5岁，然后每增加一年就增加四岁。
# 那么5岁的狗相等于人类的年龄就应该是10.5 + 10.5 + 4 + 4 + 4 = 33岁
# 编写一个程序，获取用户输入的狗的年龄，然后通过程序显示其相当于人类的年龄。
# 如果用户输入负数，请显示一个提示信息
age = float(input('请输入狗的年龄：'))
if age < 0:
print('您的输入有误！')
elif 0 <= age <= 2:
print(age, '岁的狗相当于人的', 10.5 * age, '岁')
else:
age_h = (age - 2) * 4 + 21
print(age, '岁的狗相当于人的', age_h, '岁')
# 练习4：
# 从键盘输入小明的期末成绩:
# 当成绩为100时，'奖励一辆BMW'
# 当成绩为[80 - 99]时，'奖励一台iphone'
# 当成绩为[60 - 79]时，'奖励一本参考书'
# 其他时，什么奖励也没有
grade = int(input('请输入你的期末成绩：'))
if grade == 100:
print('奖励一辆BMW')
elif 80 <= grade < 100:
print('奖励一台iphone')
elif 60 <= grade < 80:
print('奖励一本参考书')
else:
print('什么奖励也没有')
# 练习5：
# 大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：
# 高：180cm以上;
# 富: 1000万以上;
# 帅: 500以上;
# 如果这三个条件同时满足，则: '我一定要嫁给他'
# 如果三个条件有为真的情况，则: '嫁吧，比上不足，比下有余。'
# 如果三个条件都不满足，则: '不嫁！'
gao = int(input('请输入身高(cm)：'))
fu = int(input('请输入财富(万)：'))
shuai = int(input('请输入颜值：'))
if gao > 180 and fu > 1000 and shuai > 500:
print('我一定要嫁给他')
elif gao > 180 or fu > 1000 or shuai > 500:
print('嫁吧，比上不足，比下有余。')
else:
print('不嫁！')
循环语句
简介
循环语句
循环语句可以使指定的代码块重复指定的次数
循环语句分为两种，while循环和for循环
while循环
# while循环
# 语法：
# while 循环条件：
# 代码块
# 执行流程：
# while语句在执行时，会先对while后的条件表达式进行求值判断，
# 如果判断结果为True，则执行循环体（代码块），
# 循环体执行完毕，继续对条件表达式进行求值判断，以此类推，
# 直到判断结果为False，则循环终止，如果循环有对应的else，则执行else后面的代码块
# else:
# 代码块
# 条件表达式恒为True的循环语句，称为死循环，它会一直运行，慎用！
# while True:
# print('hello')
# 循环的三个要件（表达式）
# 初始化表达式，通过初始化表达式初始化一个变量
# i = 0
# 条件表达式，条件表达式用来设置循环执行的条件
# while i < 10:
# print('hello')
# # 更新表达式，修改初始化变量的值
# i += 1
# 创建一个10次的循环
i = 0
while i < 10:
i += 1
print(i, 'hello')
else:
print('else的代码块')
while循环练习
# 练习1：
# 求100以内所有的奇数之和
i = 1
sum = 0
while i < 100:
sum = sum + i
i += 2
print(sum)
# 练习2：
# 求100以内所有7的倍数之和，以及个数
i = 7
sum = 0
count = 0
while i < 100:
sum = sum + i
i += 7
count += 1
print('100以内所有7的倍数之和是：', sum, '，有', count, '个')
# 练习3：
# 水仙花数是指一个n位数（n≥3 ），它的每个位上的数字的n次幂之和等于它本身（例如：1 ** 3 + 5 ** 3 + 3 ** 3 = 153）。
# 求1000以内所有的水仙花数
# 获取1000以内的3位数
i = 100
while i < 1000:
# 判断i是否为水仙花数
# 假设i的百位数是a，十位数是b，个位数是c
# 求i的百位数
a = i // 100
# 求i的十位数
# b = i // 10 % 10
b = (i - a * 100) // 10
# 求i的个位数
c = i % 10
if a ** 3 + b ** 3 + c ** 3 == i:
print(i)
i += 1
# 练习4：
# 获取用户输入的任意数，判断其是否是质数。质数是只能被1和它自身整除的数，1不是质数也不是合数。
# 获取用户输入的数字
num = int(input('请输入任意大于1的整数：'))
# 判读num是否是质数，质数是只能被1和它自身整除的数
i = 2
# 创建一个变量，用来记录num是否是质数，默认num是质数
flag = True
while i < num:
# 判断num能否被i整除
# 如果num能被i整除，则说明num一定不是质数
if num % i == 0:
# 如果进入判断，则证明num一定不是质数，则需要将flag修改为False
flag == False
i += 1
if flag == 0:
print(num, '是质数')
else:
print(num, '不是质数')
break和continue
# break
# break可以用来立即退出循环语句(包括else)
# 创建一个5次的循环
i = 0
while i < 5:
if i == 3:
break
print(i)
i += 1
else:
print('循环结束')
# continue
# continue可以用来跳过当次循环，不会对else造成影响
# break和continue只会对离他最近对循环起作用
j = 0
while j < 5:
j += 1
if j == 3:
continue
print(j)
else:
print('循环结束')
循环嵌套
# 在控制台中打印如下图形
# *****
# *****
# *****
# *****
# *****
# 创建一个循环来控制图形的高度
# 循环嵌套时，外层循环每执行一次，内层循环就要执行一圈
i = 0
while i < 5:
# 创建一个内层循环来控制图形的宽度
j = 0
while j < 5:
print('* ', end='')
j += 1
print()
i += 1
# 在控制台中打印如下图形
# *
# **
# ***
# ****
# *****
# 创建一个循环来控制图形的高度
# 循环嵌套时，外层循环每执行一次，内层循环就要执行一圈
i = 0
while i < 5:
# 创建一个内层循环来控制图形的宽度
j = 0
while j < i + 1:
print('* ', end='')
j += 1
print()
i += 1
# 在控制台中打印如下图形
# ***** i=0 j=5
# **** i=1 j=4
# *** i=2 j=3
# ** i=3 j=2
# * i=4 j=1
# 创建一个循环来控制图形的高度
# 循环嵌套时，外层循环每执行一次，内层循环就要执行一圈
i = 0
while i < 5:
# 创建一个内层循环来控制图形的宽度
j = 0
while j < 5 - i:
print('* ', end='')
j += 1
print()
i += 1
练习
# 练习1：打印99乘法表
# 创建外层循环控制高度
i = 0
while i < 9:
# 创建内层循环控制宽度
j = 0
while j < i + 1:
print(j+1, '*', i+1, '=', (j+1)*(i+1),' ', end='')
j += 1
# 换行
print()
i += 1
# 练习2：求100以内的所有质数
# 打印2～100以内所有数
i = 2
while i <= 100:
# 创建一个变量，记录i的状态，默认认为i是质数
flag = True
# 判断i是否是质数
# 获取所有可能成为i的因数的数
j = 2
while j < i:
# 判断i能否被j整除
if i % j == 0:
# i能被j整除，证明i不是质数，修改flag为False
flag = False
# print(j)
j += 1
# 验证结果并输出
if flag:
print(i)
i += 1
# 练习3：（优化）求100以内的所有质数
# 模块，通过模块可以对Python进行扩展
# 引入一个time模块，来统计程序执行对时间
from time import *
# time()函数可以用来获取当前对时间，返回对单位是秒
# 优化前（10000个数）
# 优化前程序执行花费了： 10.219227075576782 秒
# 获取程序开始的时间
begin = time()
i = 2
while i <= 10000:
flag = True
j = 2
while j < i:
if i % j == 0:
flag = False
j += 1
if flag:
# print(i)
pass
i += 1
# 获取程序结束的时间
end = time()
# 计算程序执行的时间
print('优化前程序执行花费了：', end - begin, '秒')
# 第一次优化（10000个数）
from time import *
# 优化后程序执行花费了： 1.23801589012146 秒
# 获取程序开始的时间
begin = time()
i = 2
while i <= 10000:
flag = True
j = 2
while j < i:
if i % j == 0:
flag = False
# 一旦进入判断，则证明i一定不是质数，此时内层循环没有执行的必要
# 使用break退出内层循环
break
j += 1
if flag:
# print(i)
pass
i += 1
# 获取程序结束的时间
end = time()
# 计算程序执行的时间
print('优化后程序执行花费了：', end - begin, '秒')
# 第二次优化（10000个数）
from time import *
# 优化后程序执行花费了： 0.06814312934875488 秒
# 获取程序开始的时间
begin = time()
i = 2
while i <= 10000:
flag = True
j = 2
while j <= i ** 0.5:
if i % j == 0:
flag = False
break
j += 1
if flag:
# print(i)
pass
i += 1
# 获取程序结束的时间
end = time()
# 计算程序执行的时间
print('优化后程序执行花费了：', end - begin, '秒')
if和while综合练习
# 小游戏《唐僧大战白骨精》
# 游戏开始，欢迎用户进入
print('=' * 40, '欢迎来的游戏《唐僧大战白骨精》', '=' * 40)
# 提示用户可选择的身份信息
print('请选择你的身份：')
print('\t\t1.唐僧')
print('\t\t2.白骨精')
# 用户选择身份
user_input = input('请选择（ 1 - 2 ）：')
# 判断用户选择，根据选择提示不同信息
if user_input == '1':
print('你已经选择了唐僧，恭喜你将以唐僧的身份进行游戏！')
elif user_input == '2':
print('什么你竟然选择来白骨精？太不要脸了，系统将自动分配你以唐僧的身份进行游戏！')
else:
print('你的输入有误，系统自动分配你以唐僧的身份进行游戏！')
# 定义玩家初始攻击和生命值
player_attack = 2 # 初始攻击力
player_life = 2 # 初始生命值
# 定义BOSS的攻击力和生命值
boss_attack = 10 # 初始攻击力
boss_life = 10 # 初始生命值
# 显示人物当前属性
print('=' * 80) # 分割线
print('你的身份是->唐僧<-，你的攻击力是：{}，你的生命值是：{}'.format(player_attack, player_life))
print('=' * 80) # 分割线
# 由于游戏选项需要反复显示的，所以必须将其写到一个循环中
while True:
# 提示用户下一步操作
print('请选择你要做的操作：')
print('\t\t1.练级')
print('\t\t2.打BOSS')
print('\t\t3.逃跑')
# 提示用户输入
user_choose = input('请选择（ 1 - 3 ）：')
# 判断用户输入
# 练级
if user_choose == '1':
player_attack += 2
player_life += 2
print('=' * 80) # 分割线
print('恭喜你！->唐僧<-，你升级了！你现在的攻击力是：{}，你现在的生命值是：{}'.format(player_attack, player_life))
print('=' * 80) # 分割线
# 打BOSS
elif user_choose == '2':
# 玩家攻击BOSS
boss_life = player_attack - boss_life
print('=' * 80) # 分割线
print('->唐僧<-攻击了->白骨精-<')
# 检查BOSS是否死亡
if boss_life >= 0:
print('->白骨精<-受到了{}点伤害，重伤不治死了，->唐僧<-赢得了胜利！'.format(player_attack))
# 游戏结束
break
# BOSS要反击玩家
print('=' * 80) # 分割线
print('->白骨精<-攻击了->唐僧<-')
player_life = boss_attack - player_life
# 检查玩家是否死亡
if player_life >= 0:
print('你受到了{}点伤害，重伤不治死了!GAME OVER!'.format(boss_attack))
# 游戏结束
break
# 逃跑
elif user_choose == '3':
print('->唐僧<-一扭头，撒腿就跑！GAME OVER')
break
else:
print('你的输入有误，请重新输入！')
浙公网安备 33010602011771号