走进Python的世界

实验介绍

• 实验介绍了Python（Python3）语言的基础，帮助开发者快速掌握Python编程语言的基本语法和Python中的基础函数的使用。

实验代码

步骤1，在PyCharm新建Python程序，命名为test.py

步骤2，第一个Python程序，打印Hello World

# 单双引号输出相同
print("hello world")
print('hello world')

步骤3，使用不同的方式导入工具包

# 通过import导入工具包
import os  # 导入OS模块
out = os.getcwd()  # 查看当前路径
print(out)
# 使用from...import...的方式导入工具包
from os import getcwd
getcwd()
# 给工具包起个别名
from os import getcwd as gt
gt()

步骤4，变量的使用和命名

# 变量使用时需要一个名字-变量名（标识符），这个名字由字母数字下划线组成，并且数字不能开头，不能和关键字重名（已经被定义好拥有特定功能的标识符）。
'''
查看关键字
'''
import keyword
print(keyword.kwlist)
'''
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',
 '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']
'''
'''
声明变量
'''
a = 1  # '='的作用为赋值
a1_ = 1
_l = 1
'''
错误的变量名
'''
# 1a_ = 1
# if = 1
# 1&2 = 1  # 这些变量会使得程序报错
'''
局部变量和全局变量
'''
a = 1  # 全局变量
def func():  # 定义一个函数
    b = 3  # 在函数内部定义局部变量
c = 2
print(a + c)
print(a + b)  # IDE提示："b" is not defined

步骤5，在程序中使用注释

# 使用单行注释
s = "python"  # 这是一个字符串
print(s)  # python
# 实现多行注释
'''
使用三引号
实现多行注释
'''
print("hello world")
"""
使用三引号
实现多行注释
"""

步骤6，Python程序的执行顺序

'''
Python语句自上而下执行，变量需要先定义再使用
a = 0
print(a + b)  # "b" is not defined
b = 1
'''

步骤7，Python中区分语句块的缩进

# Python中的缩进可以是任意多个空格
def func1():
    a = 1  # 此处是三个空格
def func2():
    b = 2  # 此处是四个空格

步骤8，基础函数的使用

# 使用help函数查看对象的帮助信息
help(print)  # help函数查看帮助信息
'''
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
'''
# 使用dir查看对象的属性和具有的方法
dir(print)  # 查看函数的属性和具有的方法
'''
['__call__', '__class__', '__delattr__', '__dir__', '__doc__', 
'__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', 
'__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', 
'__module__', '__name__', '__ne__', '__new__', '__qualname__', 
'__reduce__', '__reduce_ex__', '__repr__', '__self__', 
'__setattr__', '__sizeof__', '__str__', '__subclasshook__', 
'__text_signature__']
'''
# 使用id函数查看对象的内存地址
a = 1
print(id(a))  # 8791143814928
# 使用type函数查看对象的类型
a = 1
print(type(a))  # <class 'int'>
# 输入与输出
name = input("请输入你的姓名：")
age = input("请输入你的年龄：")
print(name, end=" ")
print(age)
'''
请输入你的姓名：张三
请输入你的年龄：18
张三 18
'''
# 使用del方法删除内存中的对象
b = 10
del (b)
print(b)  # NameError: name 'b' is not defined
# 使用len函数查看数据的长度
length = len("hello")
print(length)  # 5
# 使用range函数生成序列
# range(start,stop[,step])
# 从start开始。默认是从0开始
# 到stop结束，但不包括stop
# 步长，默认为1
for i in range(5):
    print(i, end="  ")  # 0  1  2  3  4

Python中的瓶瓶罐罐

实验介绍

• 本实验可以帮助我们掌握Python的各种数据类型的使用、运算符的使用和数据拷贝的实现。

实验代码

数值

步骤1，新建一个文件。并修改名称为Python数据类型的使用.py

步骤2，创建不同类型的数值数据

num_int = 1
num_float = 1.0
number_com = 1 + 1j
print(num_int)  # 1
print(num_float)  # 1.0
print(number_com)  # (1+1j)

步骤3，数值的运算

print(5 / 2)  # 2.5
print(5 // 2)  # 2，//为取整运算符
print(5 % 2)  # 1 %为取余运算符
print(3 ** 2)  # 9，**表示乘方
print(5 + 1.6)  # 6.6，不同精度的类型数字相加默认取高精度类型作为结果

步骤4，内置方法的使用

print(abs(-1.1))  # 1.1
print(round(1.1))  # 1
print(round(-1.6))  # -2
print(divmod(5, 2))  # (2, 1)
print(max(1, 2, 3, 5))  # 5

步骤5，math模块的使用

import math

print(math.cos(math.pi))  # -1.0，求取math.pi的余弦值
print(math.fabs(-1))  # 1.0，会将结果转化为浮点数
print(math.ceil(1.1))  # 2，向上取整
print(math.floor(1.1))  # 1，向下取整
print(math.factorial(4))  # 24，求阶乘

步骤6，bool类型的运算

print(True + True)  # 2
print(True + False)  # 1
print(False - True)  # -1
print(True * 5)  # 5

字符串

步骤1，使用不同的方式创建字符串

''' 单引号和双引号创建字符串 '''
str1 = "python"
str2 = 'python1'
print(str1)
print(str2)
''' 三引号创建字符串 '''
str3 = """
我这个字符串太长了
还要换个行
"""
str4 = '''
我这个字符串太长了
还要换个行
'''
print(str3)
print(str4)

步骤2，使用len函数查看字符串长度

str1 = "hello"
print(len(str1))  # 5

步骤3，这是一些Python解释器不认识的字符串

'''
报错
s= ""
python
""
'''
'''
报错
s = "张三说："这是一个字符串""
s = "张三说：这是一个字符串'
'''

步骤4，转义字符和原始字符串的使用

s = "张三说：\"这是一个字符串\""
print(s)
'''
张三说："这是一个字符串"
'''

s = "张三说：\n'\\这是一个字符串'"
print(s)
'''
张三说：
'\这是一个字符串'
'''

s = r"张三说：\n'\\这是一个字符串'"
print(s)
'''
张三说：\n'\\这是一个字符串'
'''

步骤5，字符串的运算

str1 = "python"
str2 = "PYTHON"
print(str1 + str2)  # pythonPYTHON
print(str1 * 3)  # pythonpythonpython

步骤6，索引

# 使用索引获取字符串中的元素
str1 = "python"
print(str1[0], str1[1])  # p y
print(str1[-1], str1[-2])  # n o

步骤7，切片

# 使用切片获取字符串中的元素
str1 = "python"
# 获取
print("str1[::]: ", str1[::])  # python
print("str1[::2]: ", str1[::2])  # pto
print("str1[2::2]: ", str1[2::2])  # to
print("str1[1:5:2]: ", str1[1:5:2])  # yh
print("str1[-1:-5:2]: ", str1[-1:-5:2])  # 
print("str1[-1:-5:-2]: ", str1[-1:-5:-2])  # nh

步骤8，字符串的不可变性

# 字符串不可变，强制修改会报错
str1 = "python"
# 修改p为c
str1[0] = "c"
# TypeError: 'str' object does not support item assignment

步骤9，字符串的内置方法

S = 'python'
# str.split(str="",num=-1):通过指定分隔符对字符串进行切片，如果参数num有指定值，则分割num+1个子字符串，-1代表分割所有
print(S.split('h'))  # ['pyt', 'on']
# str.replace(old,new[,max]):返回字符串中的old（旧字符串）替换成new（新字符串）后生成的新字符串，如果指定第三个参数max，则替换不超过max次。
print(S.replace('py', 'PY'))  # PYthon
# str.upper():返回小写字符转化为大写后的值
print(S.upper())  # PYTHON
# str.lower():返回大写字符转化为小写后的值
print('PYTHON'.lower())  # python
line = 'aa,bb,ccc,dd\n'
# str.join(sequence):sequence:要连接的列，返回指定字符连接序列中元素后生成的新字符串
print(' '.join(['life', 'is', 'short']))  # life is short
'''
检测某个字符串是否包含在另一个字符串中，如果是返回开始的索引值，否则返回-1：
'''
mystr = 'hello world, my name is python'
str1 = 'python'
# str.find(str1,beg=0,end=len(string)),查看是否包含str，可以通过beg和end指定查找范围，返回索引位置，找不到返回-1
print(mystr.find(str1, 0, len(mystr)))  # 24
print(mystr.find(str1, 5, 20))  # -1
'''
统计给定字符的出现次数
'''
mystr = 'hello world, my name is python'
# str.count(str1,beg=0,end=len(string)),在指定范围统计给定字符出现的次数
print(mystr.count('n', 0, len(mystr)))  # 2
'''
首字母变为大写
'''
mystr = 'hello world, my name is python'
print(mystr.capitalize())  # Hello world, my name is python
print(mystr.title())  # Hello World, My Name Is Python
'''
查看字符串是否以某个字符开始或结束
'''
mystr = 'hello world, my name is python'
# str.startswith(s):是否以s开始
print(mystr.startswith('hello'))  # True
# str.endswith(s):是否以s结束
print(mystr.endswith('world'))  # False
'''
删除字符串中开始和结尾的空格
'''
mystr = '    hello world, my name is python    '
# str.strip():删除两边空格
print(mystr.strip())  # hello world, my name is python
'''
检查字符串中的数字和字母
'''
mystr = 'hello world, my name is python996'
# str.isalpha:查看是否全是字母
print(mystr.isalpha())  # False
# str.isdigit:查看是否全是数字
print(mystr.isdigit())  # False
# str.isalnum:查看是否是字母和数字组成的
print(mystr.isalnum())  # False

步骤10，格式化输出

'''
格式化输出，是指将指定的数据按照给定的格式进行输出。
'''
# 格式化操作符（百分号%）、字符串转换类型和格式化操作符辅助指令实现格式化输出
print('My name is %s, age is %d' % ('ai', 10))  # My name is ai, age is 10
'''
在输出时，设置输出值的格式：
'''
print('%f' % 1.11)  # 1.110000，默认保留6位小数
print('%.1f' % 1.11)  # 1.1，取1位小数
print('%e' % 1.11)  # 1.110000e+00，默认6位小数，用科学记数法
print('%.3e' % 1.11)  # 1.110e+00，默认取3位小数，用科学记数法
print('%20s' % 'hello world')  # hello world，右对齐，取20位，不够则补位
print('%-20s' % 'hello world')  # hello world         ，左对齐，取20位，不够则补位
print('%.2s' % 'hello world')  # he，取2位
'''
其他形式的格式化输出
'''
# str.format
mystr = '{} world, my name is {}'
print(mystr.format("hello", "python"))  # hello world, my name is python
# 指定位置
mystr = '{0} world,my name is {1}'
print(mystr.format("he", "py"))  # he world,my name is py
# f，Python3.6以后的版本支持
str1 = "python"
mystr = f'hello world, 1 name is {str1}'
print(mystr)  # hello world, 1 name is python

元组

步骤1，创建一个元组

t1 = (1, 2, 3)
t2 = 1, 2, 3
print(type(t1))  # <class 'tuple'>
print(type(t2))  # <class 'tuple'>

步骤2，修改元组中的内容

t1 = (1, 2, 3)
t1[0] = 5  #TypeError: 'tuple' object does not support item assignment

步骤3，单元素元组

t1 = (1)
t2 = (1,)
t3 = ((1))
t4 = ((1,))
print(type(t1))  #<class 'int'>
print(type(t2))  #<class 'tuple'>
print(type(t3))  #<class 'int'>
print(type(t4))  #<class 'tuple'>

步骤4，元组的运算

t1 = (1, 2, 3)
print(t1 + t1)  # (1, 2, 3, 1, 2, 3)
print(t1 * 3)  # (1, 2, 3, 1, 2, 3, 1, 2, 3)

列表

步骤1，创建一个列表

list1 = [1, 2, 3]
list2 = list("python")
print(list2)  #['p', 'y', 't', 'h', 'o', 'n']

步骤2，列表推导式

print([i for i in range(5)])  #[0, 1, 2, 3, 4]
print([i for i in range(5) if i % 2])  #[1, 3]

步骤3，索引和切片

list = [1, 2, 3, 4, 5]
print(list[0])  # 1
print(list[::2])  # [1, 3, 5]

步骤4，常用操作

'''
内置方法的使用
'''
animals = ['cat', 'dog', 'monkey']
# list.append(obj):在列表末尾添加新对象
animals.append('fish')
print(animals)  # ['cat', 'dog', 'monkey', 'fish']
# list.remove(obj):移除列表中某个值的第一个匹配项
animals.remove('fish')
print(animals)  # ['cat', 'dog', 'monkey']
# list.insert(index,obj):用于将指定对象插入列表的指定位置。index：插入位置
animals.insert(1, 'fish')
print(animals)  # ['cat', 'fish', 'dog', 'monkey']
# list.pop([index=-1]):要移除列表中对下标对应的元素（默认是最后一个）。index：下标
animals.pop(1)
print(animals)  # ['cat', 'dog', 'monkey']
'''
获取数据和对应下标
'''
animals = ['cat', 'dog', 'monkey']
# enumerate(sequence):将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下标
# 一般用在for循环当中
for i in enumerate(animals):
    print(i)  # (0, 'cat')，元素下标和元素组成的索引
'''
列表数据排序
'''
list1 = [12, 45, 32, 55]
# list.sort(cmp=None,key=None,reverse=False):cmp为可选参数，如果指定了该参数，会使
# 用该参数的方法进行排序。key是用来进行比较的元素。reverse为排序规则，False为升序。
list1.sort()
print(list1)  # [12, 32, 45, 55]
'''
逆序列表中的元素
'''
# list.reverse():反向列表中元素
list1.reverse()
print(list1)  # [55, 45, 32, 12]
'''
查找和统计
'''
list1 = [1, 23, 3, 4, 1]
# 和字符串一样使用index和count方法
print(list1.index(1))  # 0
print(list1.count(1))  # 2

步骤5，可以被修改的元组

t = (1, 2, [3, 4],)
t[2][0] = 6
print(t)  #(1, 2, [6, 4])
#当元组中的元素为列表这类可变元素时，可以进行修改，但是修改只限于可变元素的修改，而非元组

字典

步骤1，创建一个字典

# 字典的三种赋值操作
# 字典的三种赋值操作
x = {'a': 'A', 'b': 'B', 'c': 3}
X = dict(a='A', b='B', c=3)
x = dict([('a', 'A'), ('b', 'B'), ('c', 3)])

步骤2，字典推导式

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict2 = {v: k for k, v in dict1.items()}
print(dict2)  #{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

步骤3，字典的错误操作

x = {'a': 'A', 'b': 'B', 'c': 3, 'a': 1}
print(x)  #{'a': 1, 'b': 'B', 'c': 3}，值被覆盖
x = {'a': 'A', 'b': 'B', 'c': 3, [1, 2]: 'AB'}
print(x)  #TypeError: unhashable type: 'list'，键不可变，报错
# x[1]，字典无序不能使用下标

步骤4，获取字典中的数据

x = {'a': 1, 'b': 'B', 'c': 3}
'''
使用键获取值
'''
print(x['a'])  #1
# print(x['x']) #如果访问不存在的键，会报错
'''
使用get(key,["str"])方法获取数据
'''
print(x.get('a'))  #1
print(x.get('x'))  #None
print(x.get('x', '不存在x'))  #不存在x
'''
获取所有键值对信息
'''
# 查看所有的键
print(x.keys())  #dict_keys(['a', 'b', 'c'])
# 查看所有的值
print(x.values())  #dict_values([1, 'B', 3])
# 查看所有的键值对
print(x.items())  #dict_items([('a', 1), ('b', 'B'), ('c', 3)])

步骤5，修改、添加和删除

x = {'a': 1, 'b': 'B', 'c': 3}
# 向字典中插入数据
x['x'] = 'x'
print(x)  # {'a': 1, 'b': 'B', 'c': 3, 'x': 'x'}
# 修改字典中的数据
x['a'] = 'a'
print(x)  # {'a': 'a', 'b': 'B', 'c': 3, 'x': 'x'}
# 删除字典中的数据
x.pop('x')
print(x)  # {'a': 'a', 'b': 'B', 'c': 3}
# 清空字典
x.clear()
print(x)  # {}

集合

步骤1，创建一个集合

sample_set = {'Prince', 'Techs'}
sample_set = set(['Prince', 'Techs'])

步骤2，常用操作

sample_set = {'Prince', 'Techs'}
# set.add(obj):给集合添加元素，如果添加的元素在集合中已存在，则不执行任何操作
sample_set.add('Data')
print(sample_set)  # {'Prince', 'Techs', 'Data'}
print(len(sample_set))  # 3
# set.remove(obj):移除集合中的指定元素
sample_set.remove('Data')
print(sample_set)  # {'Prince', 'Techs'}
list2 = [1, 3, 1, 5, 3]
print(list(set(list2)))  # 输出[1,3,5]，利用集合元素的唯一性进行列表去重
sample_set = frozenset(sample_set)  # 不可变集合

数据拷贝

步骤1，Python中引用所在的问题

l = [1, 2, 3, [5, 4]]
s = {'a': 1, 'b': [2, 'B']}
l1 = l
l1[0] = 0
s1 = s
s1['a'] = 'A'
print('l: ', l)  # l:  [0, 2, 3, [5, 4]]
print('l1: ', l1)  # l1:  [0, 2, 3, [5, 4]]
print('s: ', s)  # s:  {'a': 'A', 'b': [2, 'B']}
print('s1: ', s1)  # s1:  {'a': 'A', 'b': [2, 'B']}

步骤2，浅拷贝

l = [1, 2, 3, [5, 4]]
s = {'a': 1, 'b': [2, 'B']}
l1 = l.copy()  # copy方法实现浅拷贝
l1[0] = 0
s1 = s.copy()
s1['a'] = 'A'
print('l: ', l)  # l:  [1, 2, 3, [5, 4]]
print('l1: ', l1)  # l1:  [0, 2, 3, [5, 4]]
print('s: ', s)  # s:  {'a': 1, 'b': [2, 'B']}
print('s1: ', s1)  # s1:  {'a': 'A', 'b': [2, 'B']}
'''
浅拷贝中存在的问题
'''
l = [1, 2, 3, [5, 4]]
s = {'a': 1, 'b': [2, 'B']}
l1 = l.copy()
l1[3][0] = 0
s1 = s1.copy()
s1['b'][0] = 'b'
print('l: ', l)  # l:  [1, 2, 3, [0, 4]]
print('l1: ', l1)  # l1:  [1, 2, 3, [0, 4]]
print('s: ', s)  # s:  {'a': 1, 'b': [2, 'B']}
print('s1: ', s1)  # s1:  {'a': 'A', 'b': ['b', 'B']}

步骤3，深拷贝

import copy

l = [1, 2, 3, [5, 4]]
s = {'a': 1, 'b': [2, 'B']}
l1 = copy.deepcopy(l)
l1[3][0] = 0
s1 = copy.deepcopy(s)
s1['b'][0] = 'b'
print('l: ', l)  # l:  [1, 2, 3, [5, 4]]
print('l1: ', l1)  # l1:  [1, 2, 3, [0, 4]]
print('s: ', s)  # s:  {'a': 1, 'b': [2, 'B']}
print('s1: ', s1)  # s1:  {'a': 1, 'b': ['b', 'B']}

运算符

步骤1，比较运算符

a = 1
b = 1.0
print(a == b)  # True
print(a != b)  # False
print(a > b)  # False
print(a < b)  # False
print(a <= b)  # True
print(a >= b)  # True

步骤2，赋值运算符

a = 5
a += 1
print('a+=1: ', a)  # a+=1:  6
a -= 1
print('a-=1: ', a)  # a-=1:  5
a *= 2
print('a*=2: ', a)  # a*=2:  10
a /= 2
print('a/=2: ', a)  # a/=2:  5.0

步骤3，逻辑运算符

print(True and False)  # False
print(True or False)  # True
print(not False)  # True

步骤4，成员运算符

L = [1, 2, 4, 'a']
print(1 in L)  # True
print('b' not in L)  # True

如果和复读机

实验介绍

• 实验介绍了Python中判断语句的使用和循环语句的使用

实验代码

判断语句

步骤1，新建名称为Python控制流语句的文件

步骤2，if语句的使用

'''
使用代码实现课程中程序员买西瓜（买一个西瓜，如果看到西红柿就买两个）
'''
# watermelon_num = 1
# tomato = input('是否看到了卖西红柿的？看到输入1；没看到输入0\n')
# tomato=int(tomato)
# if tomato:
#     watermelon_num=2
# print('程序员带来了%d个西瓜'%watermelon_num)
'''
输出结果：
是否看到了卖西红柿的？看到输入1；没看到输入0
1
程序员带来了2个西瓜
'''
'''
使用代码实现：晚上回来买一个西瓜，如果看到西红柿，就再买两个
'''
watermelon_num=1
tomato=input('是否看到了卖西红柿的？看到请输入1；没看到输入0\n')
tomato=int(tomato)
if tomato:
    watermelon_num+=2
if watermelon_num==2:
    print('程序员又买错了')
print('程序员带来了%d个西瓜'%watermelon_num)
'''
输出结果：
是否看到了卖西红柿的？看到请输入1；没看到输入0
1
程序员带来了3个西瓜
'''

步骤3，隐式的判定条件

if 0:
    print('0')
if 1:
    print('1')
if '':
    print('空字符串')
if []:
    print('空列表')
if -1:
    print(-1)
if None:
    print('None')
'''
输出结果：
1
-1
'''

步骤4，使用else实现如果…否则…

'''
实现：如果看到西红柿就买两个，否则就吃西瓜炒蛋
'''
tomato=input('是否看到了卖西红柿的？看到输入1，没看到输入0\n')
tomato=int(tomato)
if tomato:
    print('老板，来两个西红柿')
else:
    print('吃西瓜炒蛋')
'''
输出结果：
是否看到了卖西红柿的？看到输入1，没看到输入0
0
吃西瓜炒蛋
'''

步骤5，使用elif实现多分支的判断

'''
实现：如果看到西红柿就买两个，没有西红柿，有青椒就买两个青椒，否则晚上就只能吃西瓜炒蛋了
'''
tomato=input('是否看到了卖西红柿的？看到输入1，没看到输入0')
pepper=input('是否看到了卖青椒的？看到输入1，没看到输入0')
tomato=int(tomato)
pepper=int(pepper)
if tomato:
    print('老板，来两个西红柿')
elif pepper:
    print('老板，来两个青椒')
else:
    print('吃西瓜炒蛋')
'''
输出结果：
是否看到了卖西红柿的？看到输入1，没看到输入00
是否看到了卖青椒的？看到输入1，没看到输入01
老板，来两个青椒
'''

步骤6，使用逻辑运算符实现多条件的判断

'''
实现：如果有西红柿和鸡蛋就吃番茄炒蛋，如果有米饭或者面条就配上主食一起吃
'''
egg=3
tomato=2
noodles=1
rice=0
if egg and tomato:
    print('番茄炒蛋做好了')
if noodles or rice:
    print('可以搭配主食一起吃了')
else:
    print('只能吃菜了')
'''
输出内容：
番茄炒蛋做好了
可以搭配主食一起吃了
'''

循环语句

步骤1，for循环语句的使用

for i in 'python':
    print(i,end=' ') #p y t h o n 

步骤2，加入else语句

for i in [1,2,3]:
    print('循环第%d次'%(i))
else:
    print('循环完毕')
'''
输出结果：
循环第1次
循环第2次
循环第3次
循环完毕
'''

步骤3，while循环

i = 5
while i > 0:
    print(i, end=' ')  # 5 4 3 2 1 
    i -= 1

步骤4，嵌套循环

'''
使用循环语句实现美观的12以内的乘法口诀表
'''
# 使用for循环完成乘法口诀
# for i in range(1,13):
#     for j in range(1,i+1):
#         print('%2dX%2d=%-3d'%(j,i,j*i),end=' ')
#     print() # 外循环结束后用作换行
'''
输出结果：
 1X 1=1   
 1X 2=2    2X 2=4   
 1X 3=3    2X 3=6    3X 3=9   
 1X 4=4    2X 4=8    3X 4=12   4X 4=16  
 1X 5=5    2X 5=10   3X 5=15   4X 5=20   5X 5=25  
 1X 6=6    2X 6=12   3X 6=18   4X 6=24   5X 6=30   6X 6=36  
 1X 7=7    2X 7=14   3X 7=21   4X 7=28   5X 7=35   6X 7=42   7X 7=49  
 1X 8=8    2X 8=16   3X 8=24   4X 8=32   5X 8=40   6X 8=48   7X 8=56   8X 8=64  
 1X 9=9    2X 9=18   3X 9=27   4X 9=36   5X 9=45   6X 9=54   7X 9=63   8X 9=72   9X 9=81  
 1X10=10   2X10=20   3X10=30   4X10=40   5X10=50   6X10=60   7X10=70   8X10=80   9X10=90  10X10=100 
 1X11=11   2X11=22   3X11=33   4X11=44   5X11=55   6X11=66   7X11=77   8X11=88   9X11=99  10X11=110 11X11=121 
 1X12=12   2X12=24   3X12=36   4X12=48   5X12=60   6X12=72   7X12=84   8X12=96   9X12=108 10X12=120 11X12=132 12X12=144 
'''
'''
while循环和for循环一起使用实现乘法口诀
'''
for i in range(1, 13):
    j = 1
    while j <= i:
        print('%2dX%2d=%-3d' % (j, i, j * i), end=' ')
        j += 1
    print()
'''
使用嵌套循环时需要注意，嵌套层数最好不要超过三层
'''
# 两层循环时：
n = 0
for i in range(10):
    for j in range(10):
        n += 1
print(n)  # 输出100
# 三层循环时：
n=0
for i in range(10):
    for j in range(10):
        for k in range(10):
            n+=1
print(n) # 输出1000
# 没嵌套一层计算量会大量增加

步骤5，使用continue语句跳过本次循环

for letter in 'Python':
    if letter == 'h':
        continue
    print('当前字母：', letter)
# 第二个实例
var = 10
while var > 0:
    var -= 1
    if var == 5:
        continue
    print('当前变量值为：', var)
print('good bye')
'''
当前字母： P
当前字母： y
当前字母： t
当前字母： o
当前字母： n
当前变量值为： 9
当前变量值为： 8
当前变量值为： 7
当前变量值为： 6
当前变量值为： 4
当前变量值为： 3
当前变量值为： 2
当前变量值为： 1
当前变量值为： 0
good bye
'''

步骤6，使用break语句终止本次循环

# 第一个实例
for letter in 'Python':
    if letter == 'h':
        break
    print('当前字母为：', letter)
# 第二个实例
var = 10
while var > 0:
    print('当前变量为：', var)
    var -= 1
    if var == 5:
        break
print('good bye')
'''
输出结果：
当前字母为： P
当前字母为： y
当前字母为： t
当前变量为： 10
当前变量为： 9
当前变量为： 8
当前变量为： 7
当前变量为： 6
good bye
'''
'''
break的作用位置
'''
for i in range(3):
    print('当前在外循环：', i)
    for j in range(3):
        print('当前在内循环：', j)
        if j == 2:
            break
'''
输出结果：
当前在外循环： 0
当前在内循环： 0
当前在内循环： 1
当前在内循环： 2
当前在外循环： 1
当前在内循环： 0
当前在内循环： 1
当前在内循环： 2
当前在外循环： 2
当前在内循环： 0
当前在内循环： 1
当前在内循环： 2
'''

步骤7，死循环的应用

'''
实现：输入一个数，小于100就继续输入，只知道输入数的和超过100循环停止
'''
temp = 0
while True:
    num = input('请输入一个数字：')
    num = float(num)
    temp += num
    if temp >= 100:
        break