Python基础语法知识

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