脚本之家,脚本语言编程技术及教程分享平台!
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Python - Python基础语法知识

Python基础语法知识

2020-10-22 17:37weixin_48051271 Python

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)
……
Python基础语法知识
2.for 循环

当我们需要对列表、字典等进行遍历操作时,我们通常会用到 for 循环。

**#for循环**
for iterating_var in sequence:
   执行语句(statements)
   …… 

Python基础语法知识
当对列表、字典进行遍历时,或者当你能确定循环的次数时,通常使用 for 循环。

3.if 语句

if…else…语句用处非常广泛,当业务逻辑需要判断某个条件是否成立时,就可以用 if…else…语句。

#分支语句
if 条件:
  执行条件语句A(statements)
else:
  执行条件语句B(statements) 

Python基础语法知识
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

延伸 · 阅读

精彩推荐