Python 基础语法介绍（一）

一、概述

Python 是一个高层次的结合了解释性、编译性、互动性和面向目标的解释性编程言语。其实python的基础语法跟其它编程言语都非常相似，仅仅写法有些不相同而已。

关于Python更详细的介绍和环境准备能够参阅我这篇文章：Python 介绍和环境准备

二、变量

1）变量界说

语法规矩：

变量名 = 值
变量名 = 变量名 = 值

例如：

var1 = 123
var2 = var3 = 456

界说变量的语法规矩中间的=，并不是数学中等于号的意思，在编程言语中而是赋值的意思。赋值：其实程序在履行的时分，先核算等号（=）右边的值，然后把右边的值赋值给等号左面的变量名中。

注意点：变量名自界说，要满意标识符的命名规矩。

2）界说变量的规矩

变量命名规范 – 标识符命名规矩是Python中界说各种姓名的时分的统一规范，详细规范如下：

1. 由数字、字母、下划线组成

2. 不能以数字开头

3. 不能运用Python内置关键字

4. 严厉区别巨细写

下面是罗列的常见关键字，这些关键字不必去背，在学习Python的过程中自然就会记得的，不必就不会犯错，也能够经过keyword模块查看

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']

3）变量命名规范

• 见名知义

• 大驼峰：即每个单词首字母都大写，例如：UserName

• 小驼峰：第二个（含）今后的单词首字母大写，力例如：userName

• 下划线：例如：user_name

4）变量类型转化

Python是弱类型言语，弱类型言语有下面两个特色：

• 变量不必先声明就能够直接赋值，对一个没声明的变量赋值就相当于界说了一个新变量。
• 变量的数据类型能够改变，如，一个变量能够先被赋值为字符串，后再被赋值为整数。

在Python中，为了应对不同的业务需求，把数据分为下面几种类型：

1. Number（数字）
   • int：有符号整型
   • long：长整型，也能够代表八进制和十六进制（Python3中没有）
   • float：浮点型
   • complex：复数
2. String（字符串）
3. Boolean 布尔类型
   • True 真
   • False 假
4. List（列表）
5. Tuple（元组）
6. Set（调集）
7. Dictionary（字典）

Python3 的六个规范数据类型中：

【温馨提示】不论关于多大或许多小的整数，Python 3.x 只用 int 一种类型存储，表明为长整型，而且整数的取值范围是无限的。

示例如下：

# 类型转化
age = 18
#打印age看一下值，这里经过type()函数来输出age的类型
print(age, type(age))
# #强制类型转化把age转化为浮点型，再输出一下age的值和age的类型
age = float(age)
print(age, type(age))

常用的类型转化函数：

函数	功用
int(x)	把x转化为整数
float(x)	把x转化为浮点数
str(x)	把x转化为字符串类型
list(x)	把x转化为列表类型
chr(x)	把x转化为一个字符
ord(x)	把字符x转化为相应整数值
hex(x)	把整数x转化为十六进制字符串
oct(x)	把整数x转化为八进制字符串

三、注释

Python 中的注释有单行注释和多行注释，注释不会影响程序的履行，只会使代码更易于阅读和了解。

1）单行注释

Python 中单行注释以 # 开头，例如：

print("Hello, World!")

2）多行注释

多行注释用三个单引号 ”’ 或许三个双引号 “”” 将注释括起来，例如:

1、单引号（”’）注释

#!/usr/bin/python3 
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号 
这是多行注释，用三个单引号
'''
print("Hello, World!")

2、双引号（”””）注释

#!/usr/bin/python3 
"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号 
这是多行注释，用三个双引号
"""
print("Hello, World!")

四、运算符

Python的运算符，运算符是一些特别的符号，经过运算符将不同的数据衔接构成表达式。先经过一张图来看一下常用操作符。

1）算术运算符

运算符	功用	输入	输出
+	加	66+22	88
–	减	66-22	44
*	乘	11*6	66
/	除	60/10	6
%	取余	10%9	1
//	整除	20//9	2
**	幂	3**3	27，即三的三次方

2）关系运算符

界说：a=1，b=2

运算符	功用	输入	输出
大于		a>b	False
<	小于	a<b	False
!=	不等于	a!=b	True
==	判段是否持平	a==b	False
>=	大于等于	a>=b	False
<=	小于等于	a<=b	True

3）赋值运算符

赋值运算符从字面上能够了解为赋给变量一个值，一般咱们用=将右边的指赋给左面。下面来经过下表来看一下常用的赋值运算符：

运算符	功用	输入
=	赋值	a=2
-=	减赋值	a-=2（a=a-2）
+=	加赋值	a+=2（a=a+2）
*=	乘赋值	a*=2（a=a*2）
/=	除赋值	a/=2（a=a/2）
%=	取余赋值	a%=2（a=a%2）
**=	幂赋值	a**=2（a=a**2）
//=	整除赋值	a//=2（a=a//2）

4） 逻辑运算符

界说：a=5，b=1

运算符	功用	输入	输出
and	与	a>0 and a>b	True
or	或	a>100 or a>b	True
not	非	not（a>b and a>0）	False

5）位运算符

位操作符属于操作符中比较难的内容，位操作符以二进制为单位进行运算，操作的目标以及成果都是整数型。位操作符有如下几个：&（按位与）、|（按位或）、^（按位异或）、~（按位取反）、>>（右位移）和<<（左位移）。

详细阐明看下表：

运算符	名称	比如	功用
&	按位与	A&B	A和B进行位与运算
|	按位或	A|B	A和B进行位或运算
~	按位取反	~A	A进行取反运算
	按位异或	A^B	A和B进行位异或运算
>>	右位移	A>>c	A右移c位
<<	左位移	A<<c	A左移c位

1、位与运算（A&B）

位与运算中，A和B按位进行与运算，当每位对应满是1的时分对应成果位1，反之为0

【定论】能够看出，当10111001&00100011得到00100011。当对应位一起为1才为1。

2、位或运算（A|B）

【定论】能够看出，当10110010 | 01011110得到11111110，对应方位存在一个1的时分即为1。

3、异或位运算（A^B）

【定论】能够看出，10110010^01011110得到11101100，对应方位相反的时分，即0对应1，1对应0的时分得到1。

4、按位取反运算（~A）

【定论】按位取反的过程中需求运用补码运算，即0补为1，1补为0。

5、左右位移

右移时，（第一行为移动前，第二行为移动后）

【定论】右边最低位为溢出位被丢掉，在填充左面最高位时，假如最高位是0，则填0，假如最高位是1，则填1。右移相当于除上2的n次方。

左移时， （第一行为移动前，第二行为移动后）

【定论】左面最高位为溢出位被丢掉，在最右边空位补0，左移相当于乘上2的n次方。

运算符优先级如下：

五、数据类型

Python3 中有七个规范的数据类型：

• Number（数字）
• Boolean（布尔类型）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）
• Set（调集）

数字和布尔类型就没什么可说的了，这里主要讲一下另外五种类型：字符串、列表、元组、字典、调集

1）String（字符串）

1、创立字符串

字符串是 Python 中最常用的数据类型。咱们能够运用引号( ‘ 或 ” )来创立字符串。创立字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'

2、字符串衔接

字符串自带衔接办法，在衔接的时分咱们能够运用+直接衔接或追加一个字符串到另一个字符串的结尾。

示例如下：

>>> my_str = 'www.test.com'
>>> my_str
'www.test.com'
>>> his_str = '人生苦短，我用Python'
>>> my_str + his_str
'www.test.com人生苦短，我用Python'

3、字符串切片

字符串切片对错常常用的功用，示例如下：

>>> my_str = 'www.test.com'
>>> my_str 
'www.test.com'
>>> my_str[0:2]#经过切片拜访0-1
'ww'
>>> my_str[3:6]#3-5
'.te'
>>> my_str[7:10]#7-9
't.c'
>>> my_str[::2]#步长为2的拜访整个字符串
'wwts.o'
>>> my_str[::-1]#逆置字符串
'moc.tset.www'

4、字符串常用办法

【1】count()办法

一般运用count()办法来核算字符串中的某个元素在字符串中呈现的次数，假如不存在回来0，假如存在则回来存在的次数，语法格局如下：

my_str.count(x)

my_str 为咱们要检索的字符串名，x为咱们要核算的字符。

示例如下：

>>> my_str = 'www.test.com'
>>> my_str
'www.test.com'
>>> my_str.count('w')
3
>>> my_str.count('.')
2
>>> my_str.count('t')
2
>>> my_str.count('*')

回来的数字即该字符在字符串中呈现的次数，因为*不存在，所以回来值为0。

【2】find()办法

find办法来检索字符串中是否包括指定元素，假如包括该元素则回来该元素第一次呈现的索引方位，假如不存在该字符则回来-1，它的语法结构为：

my_str.find(x)

my_str 为要检索的字符串名，x为咱们要寻觅的元素。

示例如下：

>>> my_str = 'www.test.com'
>>> my_str
'www.test.com'
>>> my_str.find('w')#寻觅字符w
>>> my_str.find('t')#寻觅字符p
4
>>> my_str.find('m')#寻觅字符m
11
>>> my_str.find('*')#寻觅字符*，因为*不存在因此回来-1
-1

【3】index()办法

index()办法和find()办法相似，index()办法在检索到指定字符的时分也会回来该字符第一次呈现的索引方位，但是假如检索不到就会抛出异常，它的语法格局为：

my_str.index(x)

my_str为要检索的字符串名，x为要寻觅的元素。

示例如下：

>>> my_str = 'www.test.com'
>>> my_str.index('w')
>>> my_str.index('o')
10
>>> my_str.index('*')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found

上面三种办法为他们的省略格局，在规范文档中，他们的格局分别为：

my_str.count(x[,start[,end]])
my_str.find(x[,start[,end]])
my_str.index(x[,start[,end]])

示例如下：

>>> my_str = 'www.test.com'
>>> my_str.index('o',6,13)#在6-12之间寻觅o
10
>>> my_str.count('w',0,5)#核算w在0-4之间存在的次数
3
>>> my_str.find('t',3,9)#在3-8之间寻觅t
4

【4】lower()办法和upper()办法

这两种办法和上一节的测验办法相似，前者lower()是回来一个副本，副本中把字符串中一切字符转化为了小写字符，而后者upper()是回来一个副本，副本中把字符串中一切字符转化为了大写字符。

示例如下：

>>> my_str = 'ABCabc'#包括巨细写字母的字符串
>>> my_str.upper()#将字符串悉数大写
'ABCABC'
>>> my_str.lower()#将字符串悉数小写
'abcabc'
>>> my_str#再看一下原始字符串有没有改变
'ABCabc'

【5】lstrip()办法、rstrip ()办法和strip()办法

这三种办法的原理类型，他们都是用于处理字符串中的空白字符。

• lstrip()办法会回来一个副本，副本中的字符串删去一切前导的空白字符。

• rstrip()办法会回来一个副本，副本中的字符串删去一切后导的空白字符。

• strip()办法会回来一个副本，副本中的字符串删去一切前导和后导的空白字符。

示例如下：

>>> my_str = ' \n\t www.test.com \t\n  '
>>> my_str.rstrip()#回来删去后导空白字符的副本
' \n\t  
>>> my_str.lstrip()#回来删去前导空白字符的副本
'www.test.com \t\n  '
>>> my_str.strip()#回来删去前导后导空白字符的副本
'www.test.com'

【6】replace() 办法

replace()办法回来一个副本，副本中将咱们需求替代的字符替换掉，它的语法格局为：

my_str.replace(old,new)

my_str为字符串名，old为要替换掉的字符，new为替换上的字符。

示例如下：

>>> my_str = 'www.test.com'
>>> my_str.replace('test','hello')
'www.hello.com'

5、格局化字符串

格局化字符串就是在先创立一个空间，然后再这个空间留几个方位，然后根据需求填入相应的内容，这里留出的方位相当于占位符，格局化字符串有两种办法。一种是运用%操作符，一种是运用format()办法。

【1】 %操作符

%操作符在咱们格局化字符串的时分非常方便，它的语法结构如下：

 '%[+][-][0][.m]格局化字符'%iteration

• iteration为咱们要填入的内容，第一个%后面为咱们要挑选的格局。

• [+]为右对齐，数字巨细代表对齐宽度。

• [-]为左对齐，数字巨细代表对齐宽度。

• [.m]中的m为可选精度，表明保存小数点后几位小数。

• 格局化字符为咱们需求选定的格局，它的常用类型为字符串%s、十进制整数%d、单字符%c、浮点数%f、十六进制数%x、八进制数%o、字符%%。

示例如下：

>>> my_str =66666.66666
>>> print('保存2位小数格局为:%.2f'%my_str)保存2位小数格局为:66666.67
>>> for i in range(5):
...     print('%-5d'%i,end=' ')#左对齐办法
...     print('%5d'%i)#右对齐办法
...
0         0
1         1
2         2
3         3
4         4

【2】format()办法

format()办法提供了更多的办法去格局化字符串，它的基本语法是经过‘{}’和‘:’来代替‘%’。它的语法格局为：

str.format()

示例如下：

namea = '小明'
nameb = '小华'
print('{}是{}的好朋友'.format(namea,nameb))

2）List（列表）

列表是最常用的 Python 数据类型，它能够作为一个方括号内的逗号分隔值呈现。在其它言语里叫做数组。

1、创立列表

创立一个列表，只要把逗号分隔的不同的数据项运用方括号括起来即可。如下所示：

list1 = ['Google', 'test', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

2、拜访列表中的值

与字符串的索引相同，列表索引从 0 开端，第二个索引是 1，依此类推。

#!/usr/bin/python3
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )
print( list[1] )
print( list[2] )

索引也能够从尾部开端，最后一个元素的索引为 -1，往前一位为 -2，以此类推。

#!/usr/bin/python3
list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[-1] )
print( list[-2] )
print( list[-3] )

3、更新列表

#!/usr/bin/python3
list = ['Google', 'test', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
list1 = ['Google', 'test', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

4、删去列表元素

#!/usr/bin/python3
list = ['Google', 'test', 1997, 2000]
print ("原始列表 : ", list)
del list[2]
print ("删去第三个元素 : ", list)

5、列表截取与拼接

列表截取示例如下：

>>>L=['Google', 'test', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['test', 'Taobao']
>>>

列表拼接示例如下：

>>>squares = [1, 4, 9, 16, 25]
>>> squares += [36, 49, 64, 81, 100]
>>> squares
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
>>>

6、常用办法

• len(list)——列表元素个数
• list(seq)——将元组转化为列表
• max(list)——回来列表元素最大值
• min(list)——回来列表元素最小值
• list.append(obj)——在列表结尾添加新的目标
• list.insert(index, obj)——在列表头部添加新的目标
• list.pop([index=-1])——移除列表中的一个元素（默认最后一个元素），而且回来该元素的值
• list.remove(obj)——移除列表中某个值的第一个匹配项
• list.reverse()——反向列表中元素
• list.sort( key=None, reverse=False)——对原列表进行排序
• list.clear()——清空列表

3）Tuple（元组）

• Python 的元组与列表相似，不同之处在于元组的元素不能修正。
• 元组运用小括号( )，列表运用方括号 [ ]。
• 元组创立很简单，只需求在括号中添加元素，并运用逗号离隔即可。

1、创立元组

示例如下：

>>> tup1 = ('Google', 'test', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d"   #  不需求括号也能够
>>> type(tup3)
<class 'tuple'>

2、拜访元组

元组能够运用下标索引来拜访元组中的值，如下实例:

>>> tup1 = ('Google', 'test', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5, 6, 7 )
>>> print ("tup1[0]: ", tup1[0])
tup1[0]:  Google
>>> print ("tup2[1:5]: ", tup2[1:5])
tup2[1:5]:  (2, 3, 4, 5)
>>>

3、修正元组

元组中的元素值是不允许修正的，但咱们能够对元组进行衔接组合生成一个新的元组，原有的元组是不变的，如下实例:

>>> tup1 = (12, 34.56)
>>> tup2 = ('abc', 'xyz')
>>> tup3 = tup1 + tup2
>>> print (tup3)
(12, 34.56, 'abc', 'xyz')
>>>

4、删去元组

元组中的元素值是不允许删去的，但咱们能够运用del句子来删去整个元组，如下实例:

>>> tup = ('Google', 'Runoob', 1997, 2000)
>>> print (tup)
('Google', 'Runoob', 1997, 2000)
>>> del tup
>>> print ("删去后的元组 tup : ")
删去后的元组 tup :
>>> print (tup)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'tup' is not defined
>>>

5、元组截取

示例如下：

>>> tup = ('Google', 'test', 'Taobao', 'Wiki', 'Weibo','Weixin')
>>> tup[1]
'test'
>>> tup[-2]
'Weibo'
>>> tup[1:]
('test', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
>>> tup[1:4]
('test', 'Taobao', 'Wiki')
>>>

6、常用函数

• len(tuple)——核算元组元素个数。
• max(tuple)——回来元组中元素最大值。
• min(tuple)——回来元组中元素最小值。
• tuple(iterable)——将可迭代系列转化为元组。

4）Dictionary（字典）

字典和列表和元组不同，字典中存储的是一组数据，且可存储恣意类型的数据。

字典的每个键值 key=>value 对用冒号 : 切割，每个对之间用逗号(,)切割，整个字典包括在花括号 {} 中 ,格局如下所示：

d = {key1 : value1, key2 : value2, key3 : value3 }

1、创立字典

tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }

2、拜访字典里的值

>>> tinydict = {'Name': 'test', 'Age': 7, 'Class': 'First'}
>>> print ("tinydict['Name']: ", tinydict['Name'])
tinydict['Name']:  test
>>> print ("tinydict['Age']: ", tinydict['Age'])
tinydict['Age']:  7

3、修正字典

>>> tinydict = {'Name': 'test', 'Age': 7, 'Class': 'First'}
>>> tinydict['Age'] = 8               # 更新 Age
>>> tinydict['School'] = "python教程"  # 添加信息
>>> print ("tinydict['Age']: ", tinydict['Age'])
tinydict['Age']:  8
>>> print ("tinydict['School']: ", tinydict['School'])
tinydict['School']:  python教程
>>>

4、删去字典元素

>>> tinydict = {'Name': 'test', 'Age': 7, 'Class': 'First'}
>>> del tinydict['Name'] # 删去键 'Name'
>>> tinydict.clear()     # 清空字典
>>> del tinydict         # 删去字典
>>> print ("tinydict['Age']: ", tinydict['Age'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'tinydict' is not defined
>>> print ("tinydict['School']: ", tinydict['School'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'tinydict' is not defined
>>>

但这会引发一个异常，因为用履行 del 操作后字典不再存在。

5、常用办法

• len(dict)——核算字典元素个数，即键的总数。
• str(dict)——输出字典，能够打印的字符串表明。
• type(variable)——回来输入的变量类型，假如变量是字典就回来字典类型。
• dict.clear()——删去字典内一切元素。
• dict.get(key, default=None)——回来指定键的值，假如键不在字典中回来 default 设置的默认值
• key in dict——假如键在字典dict里回来true，否则回来false。
• dict.items()——以列表回来一个视图目标。
• dict.keys()——回来一个视图目标。
• dict.values()——回来一个视图目标。
• pop(key[,default])——删去字典 key（键）所对应的值，回来被删去的值。

5）Set（调集）

调集（set）是一个无序的不重复元素序列。能够运用大括号 { } 或许 set() 函数创立调集。

parame = {value01,value02,...}
或许
set(value)

【注意】创立一个空调集必须用 set() 而不是 { }，因为 { } 是用来创立一个空字典。

1、创立调集

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}

2、拜访调集元素

print(basket)

3、添加调集元素

s.add( x )

将元素 x 添加到调集 s 中，假如元素已存在，则不进行任何操作。

示例如下：

>>> thisset = set(("Google", "test", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Google', 'test', 'Facebook'}
>>>

还有一个办法，也能够添加元素，且参数能够是列表，元组，字典等，语法格局如下：

s.update( x )

示例如下：

>>> thisset = set(("Google", "test", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 'Google', 3, 'Taobao', 'test'}
>>> thisset.update([1,4],[5,6])
>>> print(thisset)
{1, 'Google', 3, 4, 5, 6, 'Taobao', 'test'}
>>>

【温馨提示】添加的元素方位是不确定的，是随机的。

4、移除元素

语法格局如下：

s.remove( x )

示例如下：

>>> thisset = set(("Google", "test", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'test'}
>>> thisset.remove("Facebook")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>

从上面可知，删去不存在的元素会报错，假如元素不存在，不会发生错误。格局如下所示：

s.discard( x )

示例如下：

>>> thisset = set(("Google", "test", "Taobao"))
>>> thisset.discard("Google")
>>> print(thisset)
{'Taobao', 'test'}
>>> thisset.discard("Facebook")
>>> print(thisset)
{'Taobao', 'test'}
>>>

5、常用函数

• len(s)——核算调集元素个数。
• s.add(x)——给调集添加元素。
• s.update(x)——给调集添加元素。
• s.remove(x)——移除指定元素。
• s.union(s2)——回来两个调集的并集。
• s.clear()——清空调集。
• x in s——判别元素是否在调集中存在。

六、流程操控

流程操控三种结构，它们分别是次序结构、挑选结构、循环结构。

1）挑选结构

1、if句子

Python 条件句子是经过一条或多条句子的履行成果（True 或许 False）来决定履行的代码块。

语法格局如下：

if 表达式1:
    句子
    if 表达式2:
        句子
    elif 表达式3:
        句子
    else:
        句子
elif 表达式4:
    句子
else:
    句子

示例如下：

# !/usr/bin/python3
num=int(input("输入一个数字："))
if num%2==0:
    if num%3==0:
        print ("你输入的数字能够整除 2 和 3")
    else:
        print ("你输入的数字能够整除 2，但不能整除 3")
else:
    if num%3==0:
        print ("你输入的数字能够整除 3，但不能整除 2")
    else:
        print  ("你输入的数字不能整除 2 和 3")

2、match..case句子

Python 3.10 增加了 match…case 的条件判别，不需求再运用一连串的 if-else 来判别了。就跟其它言语switch…case相同。

语法格局如下：

match subject:
    case <pattern_1>:
        <action_1>
    case <pattern_2>:
        <action_2>
    case <pattern_3>:
        <action_3>
    case _:
        <action_wildcard>

case _: 相似于 C 和 Java 中的 default:，当其他 case 都无法匹配时，匹配这条，保证永久会匹配成功。

示例如下：

mystatus=400
print(http_error(400))
def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"

3）循环结构

Python 中的循环句子有 while 和 for 句子。

1、while句子

Python 中 while 句子的一般形式：

while 判别条件(condition)：
    履行句子(statements)……

履行流程图如下：

示例如下：

#!/usr/bin/env python3
n = 100
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1
print("1 到 %d 之和为: %d" % (n,sum))

履行成果如下：

1 到 100 之和为: 5050

while 循环运用 else 句子

语法格局如下：

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>

示例如下：

#!/usr/bin/python3
count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

履行以上脚本，输出成果如下：

0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于 5

2、for句子

Python for 循环能够遍历任何可迭代目标，如一个列表或许一个字符串。

for循环的一般格局如下：

for <variable> in <sequence>:
    <statements>
else:
    <statements>

流程图：

示例如下：

#!/usr/bin/python3
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    print(site)

以上代码履行输出成果为：

Baidu
Google
Runoob
Taobao

for…else 语法

在 Python 中，for…else 句子用于在循环完毕后履行一段代码。 语法格局如下：

for item in iterable:
    # 循环主体
else:
    # 循环完毕后履行的代码

示例如下：

for x in range(6):
  print(x)
else:
  print("Finally finished!")

嵌套for循环示例如下（九九乘法表）：

for i in range(1,10):#先遍历1~9
    for j in range(1,i+1):#然后遍历1~i
        print(i,'*',j,'=',i * j,end='丨')#循环输出1~i * i的值
    print(end='\n')

输出信息：

1 * 1 = 1丨
2 * 1 = 2丨2 * 2 = 4丨
3 * 1 = 3丨3 * 2 = 6丨3 * 3 = 9丨
4 * 1 = 4丨4 * 2 = 8丨4 * 3 = 12丨4 * 4 = 16丨
5 * 1 = 5丨5 * 2 = 10丨5 * 3 = 15丨5 * 4 = 20丨5 * 5 = 25丨
6 * 1 = 6丨6 * 2 = 12丨6 * 3 = 18丨6 * 4 = 24丨6 * 5 = 30丨6 * 6 = 36丨
7 * 1 = 7丨7 * 2 = 14丨7 * 3 = 21丨7 * 4 = 28丨7 * 5 = 35丨7 * 6 = 42丨7 * 7 = 49丨
8 * 1 = 8丨8 * 2 = 16丨8 * 3 = 24丨8 * 4 = 32丨8 * 5 = 40丨8 * 6 = 48丨8 * 7 = 56丨8 * 8 = 64丨
9 * 1 = 9丨9 * 2 = 18丨9 * 3 = 27丨9 * 4 = 36丨9 * 5 = 45丨9 * 6 = 54丨9 * 7 = 63丨9 * 8 = 72丨9 * 9 = 81丨

4）break 和 continue 句子

1、break 句子

break 句子能够跳出 for 和 while 的循环体。假如你从 for 或 while 循环中终止，任何对应的循环 else 块将不履行。

2、continue 句子

continue 句子被用来告诉 Python 跳过当前循环，然后继续进行下一轮循环。

示例如下：

n = 5
while n > 0:
    n -= 1
    if n == 2:
        continue
    print(n)
print('循环完毕。')

这些基础知识非常简单，也对错常重要的，其实网上有很多材料介绍，这里仅仅整理了一些常用的，因为篇幅比较长，剩下的部分放在下篇文章介绍，有疑问的小伙伴欢迎给我留言，也可关注我的大众号【大数据与云原生技术共享】进行深入技术交流~