一、软件装置及工具筹备
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() # 接管并调用函数
# 输入后果:
# 执行函数