Python基础
Python 语言是一门动态的，面向对象编程的语言，它凭借入门简单，功能强大等优势，受到越来越多开发人员的追捧，已成为一门长期霸榜前三位的热门编程语言。
它的语法非常简洁，同样的功能，相比 Java 等老牌编程语言，Python 花费更少的代码行数便可将其实现；对初学者也非常友好，它的代码可读性和可调试性很强，在复杂情况下，初学者也可以将重心放在编程对象和解决问题的思维方法上，而不必去过多关心语言的语法和类型。
Python 安装
Python 的最新版本是 3.8.3. 你可以点击进入 Pyhton 官网下载安装包直接安装。
如果你当前系统用的是 Python2，那么你需要安装最新版本 Python 3，安装完毕后，你可以通过输入以下命令行，来查看你系统的默认版本号。
如果发现显示的是 Python 2.x, 你可以通过如下方式更改默认值。
1.如果你的电脑是 Windows 系统
通过“Windows + R”快捷键组合打开运行；
输入“sysdm.cpl”；
点击“环境变量（N）”，在弹出的对话框中，找到“系统变量”；
选中“Path”，并将 Python 的路径更改为 Python3 这一安装路径；
再次在命令行输入“python”查看输出的版本号。
2.如果你的电脑是 MacOS 系统
打开 Terminal， 在命令行中输入“which python3”，
你将看到如下类似输出：/usr/local/bin/python3
在 Terminal 继续输入“open ~/.bash_profile ” ，并修改文件如下：
alias python="/usr/local/bin/python3"
保存并关闭文件，然后运行如下命令：
source ~/.bash_profile
在 Terminal 里继续输入命令行入“python”，查看输出的版本号。
为了更有效率地开发，Python 安装好后，你还需要点击进入 Pycharm 官网，下载并配置集成开发环境。
Python 标准数据类型
不像其他语言，Python 中的定义变量无须进行类型声明。Python的 标准数据类型有：Numbers（数字）、String（字符串）、List（列表）、Tuple（元组）和 Dictionary（字典）。
下面举个小例子来看下这几种类型的用法：
#定义数字变量
total_num = 100
#定义字符串变量
welcome_words = "欢迎来到蔡超的测试开发课"
#定义列表。列表元素可修改，也可以添加删除
student_list = ["Kevin", "Emily", "Ray"]
#定义元组（元组与列表类似,区别在于元组的元素不能修改）
unique_student = ("Kevin", "Emily", "Ray")
#定义字典,字典一般是key-value结构
course_rank = {"math": "Kevin", "logic": "Emily", "English": "Ray"}
在 Python 中，List 和 Dictionary 分别有很多种内置用法，在此介绍其中最常用的部分。
1.List 常用操作
#定义列表 list1 = ['Kevin', 'Emily']
#计算列表元素个数
语法：len（list）
举例：len(list1)
#获取列表的第N个元素
语法：list[N]
举例：list1[0] #返回Kevin
#往List的末尾添加一个元素
语法：list.append（x）
举例：list1.append（'Ray'）#执行完后，list1变成['Kevin', 'Emily'，'Ray']
#扩展List，常常用来把一个可迭代数据的每一个元素append到List里, 它相当于a[len(a):] = iterable
语法：list.extend(x)
举例：list1.extend([2,3,4])
print(list1) #返回['Kevin', 'Emily'，'Ray'，2， 3， 4]
#插入列表
语法：list.insert(i, x) #在第i个位置插入x元素
举例：list1.insert(0, 'Ray') #在第0个位置插入元素Ray,列表变成['Ray', 'Kevin', 'Emily']
#删除元素
语法：list.remove(x)#删除列表里第一个元素，它的值等于x
举例：list1.remove('Kevin')
#删除指定位置的元素,如果没有指定i，就删除最后一个元素并返回剩余的list
语法：list1.pop(i)
举例：list1.pop(0) #删除"Kevin这个元素"
#清空列表
语法：list.clear()
举例：list1.clear()
#返回list中x出现的次数
语法：list.count(x)
举例：list1.count("Kevin")
#给列表排序, 把list安装key的值来排序， 当reverse等于true时为倒序。
语法：list.sort(key=None, reverse=False)
举例：list1.sort(reverse=true) #返回['Emily'，'Kevin']
#翻转列表
语法：list.reverse()
举例：list1.reverse() #返回['Emily'，'Kevin']
2.Dictionary 常用操作
#先定义字典
dict1 = {"math": "Kevin", "logic": "Emily"}
#返回指定键的值,如果字典里没这个可以则返回default的值
#获取math的值
dict1.get("math")
#获取不存在的值English, 则返回Ray
dict1.get("English", default="Ray")
#获取字典里的所有key
dict1.keys()
#获取字典所有的values
dict1.values()
#获取字典的key和value
for k, v in dict1.items():
print('{key} -- {value}'.format(key=k, value=v))
#改变字典的值
dict1["math"] = "Ray" # 执行后，字典变成{"math": "Ray", "logic": "Emily"}
#删除字典的某个值
del dict1["math"] #执行后，字典变成{"logic": "Emily"}
#删除字典
del dict1
Python 控制流
控制流非常重要，你的代码要如实表现业务逻辑，就必须掌握控制流，控制流中最常见的是分支语句和循环。
在 Python 里，常用的控制流关键字如下：
1.while 循环
while 循环的作用在与，当某个条件成立时，一直执行循环语句， 直至循环条件不成立为止。
#while循环
while 判断条件(condition)：
执行语句(statements)
……
2.for 循环
当我们需要对列表、字典等进行遍历操作时，我们通常会用到 for 循环。
**#for循环**
for iterating_var in sequence:
执行语句(statements)
……
当对列表、字典进行遍历时，或者当你能确定循环的次数时，通常使用 for 循环。
3.if 语句
if…else…语句用处非常广泛，当业务逻辑需要判断某个条件是否成立时，就可以用 if…else…语句。
#分支语句
if 条件：
执行条件语句A(statements)
else：
执行条件语句B(statements)
4.控制流应用案例
了解了 Python 的控制流后，下面直接看个例子加深下印象，我建立了一个名为 test.py 的文件，内容如下：
#test.py
my_students = ["Kevin", "Emily"]
course_rank = {"math": "Kevin", "logic": "Emily", "English": "Ray"}
if __name__ == "__main__":
my_students_rank = {}
for k, v in course_rank.items():
if( v in my_students):
my_students_rank[v] = k
p_len = len(my_students_rank)
while(p_len >0):
for p in my_students_rank.keys():
print('{person} are good at {course}'.format(person=p, course=my_students_rank[p]))
p_len -= 1
那么这段代码是什么含义呢？我来逐句解释一下：
#test.py
#1. 我定义了一个list类型的数据变量my_students,存放我所有的学生。
my_students = ["Kevin", "Emily"]
#2. 我定义了个dict类型的变量course_rank，存放整个学校所有课程分数最高的学生。
course_rank = {"math": "Kevin", "logic": "Emily", "English": "Ray"}
#如果该模块被直接调用时，则执行第9行以后的语句，否则不执行。
if __name__ == "__main__":
#定义了一个字典my_students_rank。存放课程分数最高，且是我教的学生。
my_students_rank = {}
#循环获取course_rank里的所有key和value，如果value在我的学生列表 my_students里，则把学生名字作为key，课程作为value保存在新建立的字典my_students_rank里。
for k, v in course_rank.items():
if( v in my_students):
my_students_rank[v] = k
#获取课程分数最高，且是我的学生的人数
p_len = len(my_students_rank)
#循环字典里的每个key和value， 把每个学生擅长的科目打印出来。
while(p_len >0):
for p in my_students_rank.keys():
print('{person} are good at {course}'.format(person=p, course=my_students_rank[p]))
p_len -= 1
我们来执行下这段语句：
#在terminal里，定位到test.py所在的目录下，然后执行
python test.py
可以看到如下结果：
Kevin is good at math
Emily is good at logic
了解了 While 语句，for 语句， if…else…语句，你就可以使用代码来表述真实业务场景了。
但你会发现这些代码完全是流水账似的，没有函数也没有模块，这显然不符合代码规范。那么，我们就必须学习下模块和函数。
函数、模块、包
上面我们讲了 Python 里的基本语法语句的使用，下面我们看下这些基本语法语句是如何被使用的。通常我们的代码为了方便调用，都会以函数、模块、包等形式存在。
1.函数
函数就是能实现一定功能的代码语句的集合。在 Python 中定义函数很简单：
def 函数名(参数)：
函数体
跟其他语言一样， Python 函数定义同样支持无形参、有形参、可变参数等；而函数可以有返回值，也可以没有返回值。下面我们来一一学习：
- 无形参–不需要参数输入
# 无形参，无返回值
def print_log():
print(''' Welcome to Kevin's class ! ''')
if __name__ == "__main__":
print_log()
- 有形参–函数接受用户参数
#有一个形参，有返回值
def is_true(x):
rerutn x >0
# 有两个形参，有返回值
def min_number(x, y):
if x>=y:
x,y = y, x
return x
#有可变个形参， 有返回值
def sum_mumber(*args):
total = 0
for k in args:
total +=k
return total
#可变个形参，接受key-value的形式, 无返回值
def count_student(**kwargs):
for k, v in kwargs.items():
print('{0} - {1}'.format(k, v))
#请你运行下面的函数，来理解Python的函数
if __name__ == "__main__":
total = sum_number(1, 2)
print(total)
min = min_number(1, 2)
print(min)
count_student(math='kevin', logic='emily')
2.模块
模块是为了编写可维护的代码，而把函数分组放到不同文件里的行为。在 Python 中，一个 .py文件 就是一个模块，一个模块可以包括一个或多个功能，模块有可以被一个或多个其他模块引用。
使用模块的好处很多， 我讲典型的两个：
- 既提高了编程的效率，也增强了代码的可维护性。
把模块导入到当前模块，当前模块即可拥有模块已经实现的功能。如果模块的功能本身需要更改，我们只需要更改模块定义的地方即可，其他地方都无须更改。
- 不同模块的函数名和变量名可以重名。
有了模块，避免了函数名和变量名之间的冲突，例如如下的文件结构：
myproject
|--module1.py
|--module2.py
假设我在 module1.py 里和 module2.py 里，同时定义一个名字为 take_picture() 的函数。这两个不同模块的函数虽然都叫 take_picutre，但其行为可以不相同，也不会相互影响。
看到这里你可能会问，那如果模块名也相同怎么办呢？
3.包
为了解决这个问题，Python 又定义了包（Package）。包就是一个目录文件，它必须包含一个名为 init.py 的文件。
如下就是一个包结构，在一个包里，不同层级目录下可以包含名字相同的模块。
myproject
|-- web
|-- module.py
|-- __init__.py
|-- API
|-- module.py
|-- __init__.py
|-- __init__.py
你可以看出，在 web 层级和 API 层级它们都包含着名字相同的模块 module.py，以下列出不同包下的模块引用方式：
# 引入web目录下的包, 假设此目录下module.py里有类变量Module
from web.module import Module
# 引入API目录下的包，假设此目录下module.py里有类变量Module
from API.module import Module
可以看出来，函数、模块、包的作用是把代码模块化，方便我们调用和写出更高效的编写代码。
模块的导入
有了函数、模块和包， 客观上我们就可以写出符合规范的代码。
那么，一个模块是如何被其他模块调用的呢？有如下三种方式：
1. 直接导入模块
#假设module1.py文件里有个take_picture方法
import module1
采用这种方式导入后，就可以直接使用
module1.take_picture()
这一方式来调用 take_picture 函数，如果 module1 里含有其他函数，在 module1 被导入后，均可以通过 module1.xxx() 的方式来使用。
2. 采用 from…import 方式导入
有时候我们并不想把一个模块的所有功能都导入进来，假设我只想使用 take_picture 这一个方法，那么我可以使用 from…import 的方式：
from module1 import take_picture
采用这种方式导入后，如果我要使用 take_picture 函数，我可以直接在代码里以如下方式使用：
take_picture()
可以注意到，这种情况我就不必要写模块名字了。
但假设这个模块里还有个 xxx 函数，我在没有导入的情况下，是无法直接通过 module1.xxx() 或者 xxx() 这样的方式使用的。
3. 采用 from…import 方式导入*
如果你想一次性地导入一个模块下的所有函数， 你可以使用如下方式：
from module1 import *
采用这种方式导入后，你可以直接使用这个模块下的所有函数。
4. 动态导入
上面介绍的三种导入方式都属于静态导入，这个很好理解。
但在实际应用中，也会有在程序运行时才知道要具体导入哪个模块的情况（例如，测试框架自动查找测试用例并导入测试用例所属的模块），这时就需要动态导入。
动态导入常常用 importlib 来完成，常用的动态导入有以下两种方式。
- 从模块直接导入
import importlib
#导入a.b模块
mod = importlib.import_module（ "a.b"）
- 根据模块名，文件名导入
import importlib.util
spec = importlib.util.spec_from_file_location("a.b", "/path/to/file.py")
md = importlib.util.module_from_spec(spec)
spec.loader.exec_module(md)
这个方式比较常用。下面我来举个具体的例子， 假设现在我们的项目目录情况如下:
myproject
|-- tests
|-- a.py
|-- __init__.py
|-- b.py
在模块 a.py 里，我定义了一个函数：
def hello():
print('i am module a!')
现在，我想在模块 b 中使用 hello() 这个函数， 要怎么操作呢？
#b.py
import os
import glob
import importlib.util
def find_modules_from_folder(folder):
absolute_f = os.path.abspath(folder)
md = glob.glob(os.path.join(absolute_f, "*.py"))
return [(os.path.basename(f)[:-3], f) for f in md if os.path.isfile(f) and not f.endswith('__init__.py')]
def import_modules_dynamically(mod, file_path):
spec = importlib.util.spec_from_file_location(mod, file_path)
md = importlib.util.module_from_spec(spec)
spec.loader.exec_module(md)
return md
if __name__ == "__main__":
module = find_modules_from_folder('.')
for m in module:
mod = import_modules_dynamically(m[0], m[1])
mod.hello()
这个代码有点复杂，先给定一个文件夹，然后通过函数 find_modules_from_folder 来得到这个文件夹下的模块，及其对应的文件路径，然后我再通过 spec_from_file_location 来动态加载。
小结
本节主要分享了 Python 的一些基础编程知识，其中涉及变量、函数、控制流的定义，及其相关操作，最后分享了模块的导入，这些知识是使用 Python 编程时的必会知识。
本文地址：https://blog.csdn.net/weixin_48051271/article/details/108786130