一、软件装置及工具筹备

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   # inty = 6.3  # floatz = 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])       # 输入字符串中第三个至第六个之间的字符串 lloprint(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])             # 输入列表的第一个元素 runoobprint(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])            # 输入元组的第一个元素 runoobprint(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' 的值 oneprint(dict[2])             # 输入键为 2 的值 twoprint(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 将是 1y = int(2.5) # y 将是 2z = int("3") # z 将是 3实例浮点数：x = float(1)     # x 将是 1.0y = float(2.5)   # y 将是 2.5z = float("3")   # z 将是 3.0w = 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除以yb / a 输入后果 2
    %取模 - 返回除法的余数b % a 输入后果 0
    **幂 - 返回x的y次幂a**b 为10的20次方 输入后果 100000000000000000000
    //取整除 - 返回商的整数局部（向下取整）9//2 = 4 ｜ -9//2 = -5

    以下实例演示了Python所有算术运算符的操作：

    a = 21b = 10c = 0c = a + bprint("1. c 的值为：", c)  # 31c = a - bprint("2. c 的值为：", c)  # 11c = a * bprint("3. c 的值为：", c)  # 210c = a / bprint("4. c 的值为：", c)  # 2.1c = a % bprint("5. c 的值为：", c)  # 1# 批改变量 a 、b 、ca = 2b = 3c = a**bprint("6. c 的值为：", c)  # 8a = 10b = 5c = a//bprint("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 = 21b = 10c = 0if 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 = 5b = 20if 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 = 21b = 10c = 0c = a + bprint("1. c 的值为：", c) # 1. c 的值为： 31c += aprint("2. c 的值为：", c) # 2. c 的值为： 52c *= aprint("3. c 的值为：", c) # 3. c 的值为： 1092c /= aprint("4. c 的值为：", c) # 4. c 的值为： 52.0c = 2c %= aprint("5. c 的值为：", c) # 5. c 的值为： 2c **= aprint("6. c 的值为：", c) # 6. c 的值为： 2097152c //= aprint("7. c 的值为：", c) # 7. c 的值为： 99864

  • Python逻辑运算符
    以下假如变量： a=10，b=20：

    运算符形容实例
    andx and y 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值(a and b) 返回 20
    orx or y 布尔"或" - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值(a or b) 返回 10
    notnot x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 Truenot(a and b) 返回 False

    操作实例:

    a = 10b = 20if 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 = 0if 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，否则返回 Falsex 在 y 序列中 , 如果 x 在 y 序列中返回 True
    not in如果在指定的序列中没有找到值返回 True，否则返回 Falsex 不在 y 序列中 , 如果 x 不在 y 序列中返回 True

    操作实例:

    a = 10b = 20list = [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 = 2if (a in list):  print("3. 变量 a 在给定的列表中 list 中")else:  print("3. 变量 a 不在给定的列表中 list 中")

  • Python身份运算符
    身份运算符用于比拟两个对象的存储单元

    运算符形容实例
    isis 是判断两个标识符是不是援用自一个对象x is y, 相似 id(x) == id(y) , 如果援用的是同一个对象则返回 True，否则返回 False
    is notis not 是判断两个标识符是不是援用自不同对象x is not y ， 相似 id(a) != id(b)。如果援用的不是同一个对象则返回后果 True，否则返回 False

    操作实例:

    a = 20b = 20if (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 = 30if (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 = Falsename = '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 = 5if 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 = 9if num >= 0 and num <= 10:    # 判断值是否在0~10之间    print('是的')# 输入后果: 是的num = 10if 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在语句块执行过程中终止以后循环，跳出该次循环，执行下一次循环
passpass是空语句，是为了放弃程序结构的完整性(不重要可疏忽)

  • Python While 循环语句
    Python 编程中 while 语句用于循环执行程序，即在某条件下，循环执行某段程序，以解决须要反复解决的雷同工作。其根本模式为：

    while 判断条件(condition)：  执行语句(statements)……

    操作实例:

    count = 0print("开始!")while (count < 9):  print('The count is:', count)  count = count + 1print("完结!")# 输入后果开始!The count is: 0The count is: 1The count is: 2The count is: 3The count is: 4The count is: 5The count is: 6The count is: 7The count is: 8完结!

    while 语句时还有另外两个重要的命令 continue，break 来跳过循环，continue 用于跳过该次循环，break 则是用于退出循环，此外"判断条件"还能够是个常值，示意循环必然成立，具体用法如下：

    # continue 和 break 用法i = 1while i < 10:  i += 1  if i % 2 > 0:   # 非单数时跳过输入      continue    # 满足某个条件的时候判断是否须要执行后续代码  print(i)        # 输入单数2、4、6、8、10i = 1print('----分割线---')while (True):            # 循环条件为1必然成立  print(i)        # 输入1、4、7、10  i += 3  if i > 10:     # 当i大于10时跳出循环      break      # 跳出循环
    循环应用 else 语句

    在 python 中，while … else 在循环条件为 false 时执行 else 语句块：

    count = 0while count < 3:    print(count, " 小于 3")    count = count + 1else:    print(count, " 不小于 3")# 输入后果# 0  小于 3# 1  小于 3# 2  小于 3# 3  不小于 3
    有限循环

    如果条件判断语句永远为 true，循环将会有限的执行上来，事实编码要防止此状况产生，会造成程序解体，如下实例：

    var = 1while 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 = 2while(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()  # 接管并调用函数# 输入后果：# 执行函数