共计 10867 个字符，预计需要花费 28 分钟才能阅读完成。
一、软件装置及工具筹备
1. 装置 python
装置 python3：brew install python3查看命令：python3【间接回车】，如图则证实曾经胜利装置，否则为未装置【退出时可输出：exit（）而后点回车】
2. 装置 pip
# 下载安装脚本
curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
# 运行装置脚本
sudo python3 get-pip.py
#常用命令
#降级命令
pip pip3 install -U pip
#安装包命令
pip install Package # 最新版本
pip install Package==1.0.4 # 指定版本
pip install 'Package>=1.0.4' # 最小版本查看命令：pip3 –version【python3 版本的命令】如图：证实曾经胜利装置
3. 装置 Vscode【Download Visual Studio Code】
装置汉化插件【扩大插件搜寻 chinese】
装置 python 插件【扩大插件搜寻 python】
配置 python 运行指向 python3 的门路
装置 python 插件【扩大插件搜寻 code runner】
装置胜利后点击.py 文件, 右上角呈现运行小三角即代表胜利
二、Python 学习（入门级别）
1.Python 数据类型
内置数据类型，在编程中，数据类型是一个重要的概念。
变量能够存储不同类型的数据，并且不同类型能够执行不同的操作。
在这些类别中，Python 默认领有以下内置数据类型：
| 类型 | 变量 |
|---|---|
| 文本类型 | str |
| 数值类型 | int, float, complex |
| 序列类型 | list, tuple, range |
| 映射类型 | dict |
| 汇合类型 | set, frozenset |
| 布尔类型 | bool |
| 二进制类型 | bytes, bytearray, memoryview |
-
Python 数字
#Python 中有三种数字类型：int、float、complex #为变量赋值时，将创立数值类型的变量，实例：x = 10 # int y = 6.3 # float z = 2j # complex #如需验证 Python 中任何对象的类型，请应用 type() 函数，实例：print(type(x)) #<class 'int'> print(type(y)) #<class 'float'> print(type(z)) #<class 'complex'> -
Python 字符串
字符串或串 (String) 是由数字、字母、下划线组成的一串字符。str = 'Hello World!' print(str) # 输入残缺字符串 Hello World! print(str[0]) # 输入字符串中的第一个字符 H print(str[2:5]) # 输入字符串中第三个至第六个之间的字符串 llo print(str[2:]) # 输入从第三个字符开始的字符串 llo World! print(str * 2) # 输入字符串两次 Hello World!Hello World! print(str + "TEST") # 输入连贯的字符串 Hello World!TEST -
Python 列表
List（列表）是 Python 中应用最频繁的数据类型。
列表能够实现大多数汇合类的数据结构实现。它反对字符，数字，字符串甚至能够蕴含列表（即嵌套）。
列表用 [] 标识，是 python 最通用的复合数据类型。
列表中值的切割也能够用到变量 [头下标: 尾下标]，就能够截取相应的列表，从左到右索引默认 0 开始，从右到左索引默认 -1 开始，下标能够为空示意取到头或尾。list = ['runoob', 786 , 2.23, 'john', 70.2] tinylist = [123, 'john'] print(list) # 输入残缺列表 ['runoob', 786, 2.23, 'john', 70.2] print(list[0]) # 输入列表的第一个元素 runoob print(list[1:3]) # 输入第二个至第三个元素 [786, 2.23] print(list[2:]) # 输入从第三个开始至列表开端的所有元素 [2.23, 'john', 70.2] print(tinylist * 2) # 输入列表两次 [123, 'john', 123, 'john'] print(list + tinylist) # 打印组合的列表 ['runoob', 786, 2.23, 'john', 70.2, 123, 'john'] -
Python 元组
元组是另一个数据类型，相似于 List（列表）。
元组用 () 标识。外部元素用逗号隔开。然而元组不能二次赋值，相当于只读列表。tuple = ('runoob', 786 , 2.23, 'john', 70.2) tinytuple = (123, 'john') print(tuple) # 输入残缺元组 ('runoob', 786, 2.23, 'john', 70.2) print(tuple[0]) # 输入元组的第一个元素 runoob print(tuple[1:3]) # 输入第二个至第四个（不蕴含）的元素 (786, 2.23) print(tuple[2:]) # 输入从第三个开始至列表开端的所有元素 (2.23, 'john', 70.2) print(tinytuple * 2) # 输入元组两次 (123, 'john', 123, 'john') print(tuple + tinytuple) # 打印组合的元组 ('runoob', 786, 2.23, 'john', 70.2, 123, 'john') -
Python 字典
字典 (dictionary) 是除列表以外 python 之中最灵便的内置数据结构类型。列表是有序的对象汇合，字典是无序的对象汇合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用 ”{}” 标识。字典由索引 (key) 和它对应的值 value 组成。dict = {} dict['one'] = "one" # {'one':'one'} dict[2] = "two" # {2:'two'} tinydict = {'name': 'runoob', 'code': 6734, 'dept': 'sales'} print(dict['one']) # 输入键为 'one' 的值 one print(dict[2]) # 输入键为 2 的值 two print(tinydict) # 输入残缺的字典 {'dept': 'sales', 'code': 6734, 'name': 'runoob'} print(tinydict.keys()) # 输入所有键 ['dept', 'code', 'name'] print(tinydict.values()) # 输入所有值 ['sales', 6734, 'runoob'] -
Python 数据类型转换
有时候，咱们须要对数据内置的类型进行转换，数据类型的转换，你只须要将数据类型作为函数名即可。
以下几个内置的函数能够执行数据类型之间的转换。这些函数返回一个新的对象，示意转换的值。函数 形容 int(x [,base]) 将 x 转换为一个整数 long(x [,base] ) 将 x 转换为一个长整数 float(x) 将 x 转换到一个浮点数 complex(real [,imag]) 创立一个复数 str(x) 将对象 x 转换为字符串 repr(x) 将对象 x 转换为表达式字符串 eval(str) 用来计算在字符串中的无效 Python 表达式, 并返回一个对象 tuple(s) 将序列 s 转换为一个元组 list(s) 将序列 s 转换为一个列表 set(s) 转换为可变汇合 dict(d) 创立一个字典。d 必须是一个序列 (key,value)元组。 frozenset(s) 转换为不可变汇合 chr(x) 将一个整数转换为一个字符 unichr(x) 将一个整数转换为 Unicode 字符 ord(x) 将一个字符转换为它的整数值 hex(x) 将一个整数转换为一个十六进制字符串 oct(x) 将一个整数转换为一个八进制字符串 有时您可能须要为变量指定类型。这能够通过 casting 来实现。Python 是一门面向对象的语言，因而它应用类来定义数据类型，包含其原始类型。因而，应用构造函数实现在 python 中的转换，实例：int() - 用整数字面量、浮点字面量结构整数（通过对数进行下舍入），或者用示意残缺数字的字符串字面量 float() - 用整数字面量、浮点字面量，或字符串字面量结构浮点数（提供示意浮点数或整数的字符串）str() - 用各种数据类型结构字符串，包含字符串，整数字面量和浮点字面量 实例 整数：x = int(1) # x 将是 1 y = int(2.5) # y 将是 2 z = int("3") # z 将是 3 实例浮点数：x = float(1) # x 将是 1.0 y = float(2.5) # y 将是 2.5 z = float("3") # z 将是 3.0 w = float("4.6")# w 将是 4.6 实例字符串：x = str("S2") # x 将是 'S2' y = str(3) # y 将是 '3' z = str(4.0) # z 将是 '4.0'
2. Python 运算符
-
Python 算术运算符
以下假如变量：a=10，b=20：运算符 形容 实例 + 加 – 两个对象相加 a + b 输入后果 30 – 减 – 失去正数或是一个数减去另一个数 a * b 输入后果 200 * 乘 – 两个数相乘或是返回一个被反复若干次的字符串 a * b 输入后果 200 / 除 – x 除以 y b / a 输入后果 2 % 取模 – 返回除法的余数 b % a 输入后果 0 ** 幂 – 返回 x 的 y 次幂 a**b 为 10 的 20 次方 输入后果 100000000000000000000 // 取整除 – 返回商的整数局部（向下取整） 9//2 = 4 | -9//2 = -5以下实例演示了 Python 所有算术运算符的操作：
a = 21 b = 10 c = 0 c = a + b print("1. c 的值为：", c) # 31 c = a - b print("2. c 的值为：", c) # 11 c = a * b print("3. c 的值为：", c) # 210 c = a / b print("4. c 的值为：", c) # 2.1 c = a % b print("5. c 的值为：", c) # 1 # 批改变量 a、b、c a = 2 b = 3 c = a**b print("6. c 的值为：", c) # 8 a = 10 b = 5 c = a//b print("7. c 的值为：", c) # 2 -
Python 比拟运算符
以下假如变量：a=10，b=20：运算符 形容 实例 == 等于 – 比拟对象是否相等 (a == b) 返回 False != 不等于 – 比拟两个对象是否不相等 (a != b) 返回 True > 大于 – 返回 x 是否大于 y (a > b) 返回 False < 小于 – 返回 x 是否小于 y。所有比拟运算符返回 1 示意真，返回 0 示意假。这别离与非凡的变量 True 和 False 等价 (a < b) 返回 True >= 大于等于 – 返回 x 是否大于等于 y (a >= b) 返回 False <= 小于等于 – 返回 x 是否小于等于 y (a <= b) 返回 True 操作实例:
a = 21 b = 10 c = 0 if a == b: print("1 - a 等于 b") else: print("1 - a 不等于 b") if a != b: print("2 - a 不等于 b") else: print("2 - a 等于 b") if a < b: print("4 - a 小于 b") else: print("4 - a 大于等于 b") if a > b: print("5 - a 大于 b") else: print("5 - a 小于等于 b") # 批改变量 a 和 b 的值 a = 5 b = 20 if a <= b: print("6 - a 小于等于 b") else: print("6 - a 大于 b") if b >= a: print("7 - b 大于等于 a") else: print("7 - b 小于 a") -
Python 赋值运算符
以下假如变量：a=10，b=20：运算符 形容 实例 = 简略的赋值运算符 c = a + b 将 a + b 的运算后果赋值为 c += 加法赋值运算符 c += a 等效于 c = c + a -= 减法赋值运算符 c -= a 等效于 c = c – a *= 乘法赋值运算符 c = a 等效于 c = c a /= 除法赋值运算符 c /= a 等效于 c = c / a %= 取模赋值运算符 c %= a 等效于 c = c % a **= 幂赋值运算符 c = a 等效于 c = c a //= 取整除赋值运算符 c //= a 等效于 c = c // a 操作实例:
a = 21 b = 10 c = 0 c = a + b print("1. c 的值为：", c) # 1. c 的值为：31 c += a print("2. c 的值为：", c) # 2. c 的值为：52 c *= a print("3. c 的值为：", c) # 3. c 的值为：1092 c /= a print("4. c 的值为：", c) # 4. c 的值为：52.0 c = 2 c %= a print("5. c 的值为：", c) # 5. c 的值为：2 c **= a print("6. c 的值为：", c) # 6. c 的值为：2097152 c //= a print("7. c 的值为：", c) # 7. c 的值为：99864 -
Python 逻辑运算符
以下假如变量：a=10，b=20：运算符 形容 实例 and x and y 布尔 ” 与 ” – 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值 (a and b) 返回 20 or x or y 布尔 ” 或 ” – 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值 (a or b) 返回 10 not not x 布尔 ” 非 ” – 如果 x 为 True，返回 False。如果 x 为 False，它返回 True not(a and b) 返回 False 操作实例:
a = 10 b = 20 if a and b: print("1. 变量 a 和 b 都为 True") else: print("1. 变量 a 和 b 有一个不为 True") if a or b: print("2. 变量 a 和 b 都为 True，或其中一个变量为 True") else: print("2. 变量 a 和 b 都不为 True") # 批改变量 a 的值 a = 0 if a and b: print("3. 变量 a 和 b 都为 True") else: print("3. 变量 a 和 b 有一个不为 True") if a or b: print("4. 变量 a 和 b 都为 True，或其中一个变量为 True") else: print("4. 变量 a 和 b 都不为 True") if not(a and b): print("5. 变量 a 和 b 都为 False，或其中一个变量为 False") else: print("5. 变量 a 和 b 都为 True") -
Python 成员运算符
除了以上的一些运算符之外，Python 还反对成员运算符，测试实例中蕴含了一系列的成员，包含字符串，列表或元组。运算符 形容 实例 in 如果在指定的序列中找到值返回 True，否则返回 False x 在 y 序列中 , 如果 x 在 y 序列中返回 True not in 如果在指定的序列中没有找到值返回 True，否则返回 False x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True 操作实例:
a = 10 b = 20 list = [1, 2, 3, 4, 5] if (a in list): print("1. 变量 a 在给定的列表中 list 中") else: print("1. 变量 a 不在给定的列表中 list 中") if (b not in list): print("2. 变量 b 不在给定的列表中 list 中") else: print("2. 变量 b 在给定的列表中 list 中") # 批改变量 a 的值 a = 2 if (a in list): print("3. 变量 a 在给定的列表中 list 中") else: print("3. 变量 a 不在给定的列表中 list 中") -
Python 身份运算符
身份运算符用于比拟两个对象的存储单元运算符 形容 实例 is is 是判断两个标识符是不是援用自一个对象 x is y, 相似 id(x) == id(y) , 如果援用的是同一个对象则返回 True，否则返回 False is not is not 是判断两个标识符是不是援用自不同对象 x is not y，相似 id(a) != id(b)。如果援用的不是同一个对象则返回后果 True，否则返回 False 操作实例:
a = 20 b = 20 if (a is b): print("1. a 和 b 有雷同的标识") else: print("1. a 和 b 没有雷同的标识") if (a is not b): print("2. a 和 b 没有雷同的标识") else: print("2. a 和 b 有雷同的标识") # 批改变量 b 的值 b = 30 if (a is b): print("3. a 和 b 有雷同的标识") else: print("3. a 和 b 没有雷同的标识") if (a is not b): print("4. a 和 b 没有雷同的标识") else: print("4. a 和 b 有雷同的标识")
3. Python 条件语句
Python 条件语句是通过一条或多条语句的执行后果（True 或者 False）来决定执行的代码块。
能够通过下图来简略理解条件语句的执行过程:
Python 程序语言指定任何非 0 和非空（null）值为 true，0 或者 null 为 false。
Python 编程中 if 语句用于控制程序的执行，根本模式为：
if 判断条件：执行语句……
else：执行语句……其中 ” 判断条件 ” 成立时（非零），则执行前面的语句，而执行内容能够多行，以缩进来辨别示意同一范畴。
else 为可选语句，当须要在条件不成立时执行内容则能够执行相干语句。
操作实例:
# 例 1：if 根本用法
flag = False
name = 'python'
if name == 'python': # 判断变量是否为 python
flag = True # 条件成立时设置标记为真
print('我是 python') # 并输入欢送信息
else:
print('我是'+name) # 条件不成立时输入变量名称
print('flag:', flag)
if 语句的判断条件能够用 >（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来示意其关系。
当判断条件为多个值时，能够应用以下模式：
if 判断条件 1:
执行语句 1……
elif 判断条件 2:
执行语句 2……
elif 判断条件 3:
执行语句 3……
else:
执行语句 4……操作实例:
# 例 2：elif 用法
num = 5
if num == 0: # 判断 num 的值
print('等于 0')
elif num == 1:
print('等于 1')
elif num > 3:
print('大于 3')
elif num >= 2:
print('大于等于 2')
else:
print('以上都不是') # 条件均不成立时输入
python 多个条件判断，只能用 elif 来实现，如果判断须要多个条件需同时判断时，能够应用 or（或），示意两个条件有一个成立时判断条件胜利；应用 and（与）时，示意只有两个条件同时成立的状况下，判断条件才胜利。
操作实例:
# 例 3：if 语句多个条件
num = 9
if num >= 0 and num <= 10: # 判断值是否在 0~10 之间
print('是的')
# 输入后果: 是的
num = 10
if num < 0 or num > 10: # 判断值是否在小于 0 或大于 10
print('是的')
else:
print('不是')
# 输入后果: 不是
num = 8
# 判断值是否在 0~5 或者 10~15 之间
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):
print('是的')
else:
print('不是')
# 输入后果: 不是
3. Python 循环语句
Python 的循环语句，程序在个别状况下是按程序执行的。
编程语言提供了各种控制结构，容许更简单的执行门路。
循环语句容许咱们执行一个语句或语句组屡次，上面是在大多数编程语言中的循环语句的个别模式：
Python 提供了 for 循环和 while 循环（在 Python 中没有 do..while 循环）:
循环语句
| 循环类型 | 形容 |
|---|---|
| while 循环 | 在给定的判断条件为 true 时执行循环体，否则退出循环体。 |
| for 循环 | 反复执行语句 |
| 嵌套循环 | 你能够在 while 循环体中嵌套 for 循环 |
循环管制语句
循环管制语句能够更改语句执行的程序。Python 反对以下循环管制语句：
| 循环类型 | 形容 |
|---|---|
| break | 在语句块执行过程中终止循环，并且跳出整个循环 |
| continue | 在语句块执行过程中终止以后循环，跳出该次循环，执行下一次循环 |
| pass | pass 是空语句，是为了放弃程序结构的完整性(不重要可疏忽) |
-
Python While 循环语句
Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以解决须要反复解决的雷同工作。其根本模式为：while 判断条件(condition)：执行语句(statements)……操作实例:
count = 0 print("开始!") while (count < 9): print('The count is:', count) count = count + 1 print("完结!") # 输入后果 开始! The count is: 0 The count is: 1 The count is: 2 The count is: 3 The count is: 4 The count is: 5 The count is: 6 The count is: 7 The count is: 8 完结!while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环，此外 ” 判断条件 ” 还能够是个常值，示意循环必然成立，具体用法如下：
# continue 和 break 用法 i = 1 while i < 10: i += 1 if i % 2 > 0: # 非单数时跳过输入 continue # 满足某个条件的时候判断是否须要执行后续代码 print(i) # 输入单数 2、4、6、8、10 i = 1 print('---- 分割线 ---') while (True): # 循环条件为 1 必然成立 print(i) # 输入 1、4、7、10 i += 3 if i > 10: # 当 i 大于 10 时跳出循环 break # 跳出循环循环应用 else 语句
在 python 中，while … else 在循环条件为 false 时执行 else 语句块：
count = 0 while count < 3: print(count, "小于 3") count = count + 1 else: print(count, "不小于 3") # 输入后果 # 0 小于 3 # 1 小于 3 # 2 小于 3 # 3 不小于 3有限循环
如果条件判断语句永远为 true，循环将会有限的执行上来，事实编码要防止此状况产生，会造成程序解体，如下实例：
var = 1 while var == 1: # 该条件永远为 true，循环将有限执行上来 print("执行代码") print("完结!") #执行代码 #执行代码 #执行代码 #执行代码 #...... # Traceback (most recent call last): # File "/Users/coolpanda/ 自动化测试 /python/interfaceTest/test.py", line 3, in <module> # print("执行代码") # KeyboardInterrupt # 留神：以上的有限循环你能够应用 Control+C 来中断循环。 -
Python for 循环语句
Python for 循环能够遍历任何序列的我的项目，如一个列表或者一个字符串。
语法：# for 循环的语法格局如下：for key in obj: statements(s)实例：
# 字符串遍历 for a in 'Python': # 第一个实例 print("以后字母:", a) print("------ 分割线 ------") # List（列表）遍历 fruits = ['苹果', '西瓜', '哈密瓜'] for fruit in fruits: # 第二个实例 print('以后水果:', fruit) print("完结!") # 输入后果 # 以后字母: P # 以后字母: y # 以后字母: t # 以后字母: h # 以后字母: o # 以后字母: n # ------ 分割线 ------ # 以后水果: 苹果 # 以后水果: 西瓜 # 以后水果: 哈密瓜 # 完结!通过序列索引迭代
fruits = ['苹果', '西瓜', '哈密瓜'] for index in range(len(fruits)): print(fruits[index]) print("以上代码相当于 >") print(fruits[0]) print(fruits[1]) print(fruits[2])for 语句时同样有两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环，此外 ” 判断条件 ” 还能够是个常值，示意循环必然成立，具体用法如下：
fruits = ['苹果', '西瓜', '哈密瓜', '草莓', '榴莲'] for fruit in fruits: if(fruit == '苹果'): continue # 找到苹果 不打印 间接查找下一个 elif(fruit == '草莓'): break # 找到草莓 跳出循环 print(fruit) # 输入后果 # 西瓜 # 哈密瓜 -
Python 循环嵌套
Python 语言容许在一个循环体外面嵌入另一个循环, 依据事实场景实践上能够始终嵌套#Python for 循环嵌套语法：for iterating_var in sequence: for iterating_var in sequence: statements(s) statements(s) #Python while 循环嵌套语法：while expression: while expression: statement(s) statement(s)实例:
# while 循环嵌套 i = 2 while(i < 10): j = 2 while(j <= (i/j)): if not(i % j): break j = j + 1 if (j > i/j): print(i, "是质数") i = i + 1 # 输入后果 # 2 是质数 # 3 是质数 # 5 是质数 # 7 是质数 # for 循环嵌套 list = [2, 5, 7, 9, 11] for num in range(10): # 迭代 0 到 10 之间的数字 for i in list: # 依据因子迭代 if num == i: # 确定第一个因子 print('%d 在 10 中' % (i)) break # 跳出以后循环 # 输入后果 # 2 在 10 中 # 5 在 10 中 # 7 在 10 中 # 9 在 10 中
4. Python 函数
函数是组织好的，可重复使用的，用来实现繁多，或相关联性能的代码段。
函数能进步利用的模块性，和代码的反复利用率。你曾经晓得 Python 提供了许多内建函数，比方 print()。但你也能够本人创立函数，这被叫做用户自定义函数。
定义一个函数
你能够定义一个由本人想要性能的函数，以下是简略的规定：
- 函数代码块以 def 关键词结尾，后接函数标识符名称和圆括号()。
- 任何传入参数和自变量必须放在圆括号两头。圆括号之间能够用于定义参数。
- 函数的第一行语句能够选择性地应用文档字符串—用于寄存函数阐明。
- 函数内容以冒号起始，并且缩进。
- return [表达式] 完结函数，选择性地返回一个值给调用方。不带表达式的 return 相当于返回 None。
语法
def 函数名称(参数名称):
"函数_文档字符串"
function_suite
return [表达式]实例:
def speak(str):
print('传入参数', str) # 打印参数
return '你好' # 返回数据 不写默认返回 None
a = speak('请谈话') # 接管并调用函数
print('函数返回：', a)
# 输入后果：# 传入参数 请谈话
# 函数返回：你好
# 备注：# 1. 参数（str）可选
# 2.return 返回表达式可选
# 3.a = 变量接管回掉可选
# 即：简略版本
def speak1():
print('执行函数') # 打印参数
speak1() # 接管并调用函数
# 输入后果：# 执行函数