一、概述

上一篇文章：Python 基础语法介绍（一），已经介绍了一部分基础知识了，这里就继续介绍python基础知识。

二、函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段，函数能提高应用的模块性，和代码的重复利用率。

1）函数定义

定义函数规则如下：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号 : 起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None。

Python 定义函数使用 def 关键字，一般格式如下：

def 函数名（参数列表）:
    函数体

在定义函数名字的时候我们需要注意几点：

• 关键字不能作为函数名字。

• 函数名中不能存在空格。

• 函数名的首字母必须是大小写字母或者下划线。

• 函数名的其余字母可以使用字母、数字以及下划线。

• 不同函数名大小写不同的时候为不同函数。

示例如下：

#!/usr/bin/python3

# 定义函数
def get_name():
    pass
def get_salary():
    pass
def add_money():
    pass

2）函数调用

当我们创建好函数之后，如果不调用的话，函数永远都不会执行。调用函数的时候，解释器会跳到函数体内，执行函数内的语句，当执行完毕之后回到调用的位置继续执行后续语句。

示例如下：

#!/usr/bin/python3

# 定义函数
def helloworld():
    print('调用函数')
    print('helloworld')
    print('人生苦短，我用Python')

# 调用函数
helloworld()
print('调用完毕')

3）函数传参

在调用函数的时候，主函数和调用函数之间总是离不开数据的传递，有了数据的传递，也就是参数的传递。参数的作用是用来传递数据给函数使用。

1、形式参数和实际参数

• 形式参数为我们定义函数的时候再括号中定义的参数，我们在函数的内部会使用这个参数进行代码的编写；
• 而实际参数为函数调用的时候传进来的参数，函数返回的结果是根据这个实际参数来代替形式参数。

2、关键字参数

为了提高程序的可读性，在函数调用的时候还可以使用关键字参数调用。

示例如下：

>>> def volume(length,width,height):
...     volume = length * width * height
...     print('体积为：',volume)
...
>>> volume(length=20,width=30,height=3)
体积为： 1800

3、参数默认值

当我们定义一个函数的时候，可以给函数的参数定义一个初始值，这样在我们调用函数的时候如果没有给出实际参数，那么函数会使用默认参数。

示例如下：

>>> def volume(length=100,width=100,height=10):
...     volume = length * width * height
...     print(volume)
...
>>> volume()#不给出实际参数的时候会使用默认参数100000
>>> volume(10,10,10)#给出实际参数会传递实际参数给出输出结果
1000

4、可变参数

在Python中函数的参数个数是可以变化的，也就是说参数的数量可以是不确定的，这种参数被称为可变参数。可变参数分为两种：

• 一种是参数前加 *，这种方式的可变参数在传递的时候是以元组的形式传递。
• 一种是参数前加**，这种方式的可变参数在传递的时候以字典的形式传递。

元组形式示例如下：

>>> def add_number(*number):
...     add_num = 0
...     for i in number:
...             add_num += i
...     print(add_num)
...
>>> add_number(1,2,3,4,5)
15

字典形式示例如下：

>>> def printinfo( arg1, **vardict ):
...    "打印任何传入的参数"
...    print ("输出: ")
...    print (arg1)
...    print (vardict)
...
>>>
>>> printinfo(1, a=2,b=3)
输出:
1
{'a': 2, 'b': 3}
>>>

4）函数返回值

在使用函数的过程中通常是调用函数，然后被调用的函数中的内容会依次被执行，但是我们有的时候需要的不只是执行的步骤，我们还需要获取到函数中的一些变量，因此我们在使用函数的时候还可以增添一个返回值来获取函数中的一些数据。

1、语法结构

Python中关于返回值需要使用return语句，它的语法结构为：

return data

示例如下：

def get_sum(a,b):
    sum = a + b
    return sum
get_sum(1,2)

2、多值返回

在返回多个值的时候原理和一个值的时候类似，我们需要注意的一点是当我们返回的是多个值的时候，多个值是被存储在元组当中的。

示例如下：

>>> def get_data():
...     a = 1
...     b = 2
...     c = 3
...     d = 4
...     return a,b,c,d
...
>>> print('返回值的类型:',type(get_data()))
返回值的类型: <class 'tuple'>
>>> print('返回值:',get_data())
返回值: (1, 2, 3, 4)
>>>

5）变量作用域

变量的作用域指的是一个变量能够有效的区域，因为我们在使用函数的时候，有的变量是在主程序中定义的，有的是在调用的函数中定义的，当我们的主程序使用函数中定义的变量时，就会出现异常。下面来介绍一下局部变量和全局变量。

1、局部变量

局部变量，顾名思义，就是作用在局部区域的变量，如果是在函数中定义的变量，那么就只在函数中起作用，如果在函数外部使用函数内部的变量，就会出现异常。

示例如下：

>>> def test():
...     data = '局部变量'
...     print('在函数内部输出data为：',data)
...
>>> test()
在函数内部输出data为： 局部变量
>>> print('在主程序中输出data：',data)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'data' is not defined
>>>

从上面执行结果可知，由于变量data是在函数内部定义的，我们在主程序中使用变量data则会出现访问的变量不存在的问题。

【结论】在函数内部定义的变量为局部变量，未作特别声明（global）的话是不可以在函数外使用的。

2、全局变量

全局变量我们也可以从字面意思中理解到它就是作用在全局的变量，有的同学可能自然而然的认为那么全局变量一定是定义在主程序中的变量了，其实全局变量也是可以作用在函数中的，在这里我们来介绍两种全局变量的使用方式：

【1】在主程序中定义全局变量

>>> data = '全局变量data'
>>> def test():
...     print('这是作用在函数中的全局变量：',data)
...
>>> test()
这是作用在函数中的全局变量： 全局变量data
>>> print('这是作用在函数外的全局变量：',data)
这是作用在函数外的全局变量： 全局变量data
>>>

【2】 使用global关键字在函数中声明全局变量

在函数内定义的变量也可以变成全局变量，这时候我们就要使用到global关键字。

首先我们先看一下当全局变量和局部变量的名字相同的时候会是一个怎么样的情况，看下面的例子：

>>> data = '这里是全局变量data'
>>> print(data)
这里是全局变量data
>>> def test():
...     data = '这里是局部变量data'
...     print(data)
...
>>> test()
这里是局部变量data
>>> print('再检查一下全局变量data:',data)
再检查一下全局变量data: 这里是全局变量data
>>>

使用global关键字示例如下：

>>> data = '这里是全局变量data'
>>> print(data)
这里是全局变量data
>>> def test():
...     global data
...     data = '这里是局部变量data'
...     print(data)
...
>>> test()
这里是局部变量data
>>> print('再检查一下全局变量data:',data)
再检查一下全局变量data: 这里是局部变量data
>>>

通过global关键字，在局部中声明告诉这个函数global 变量是一个全局变量，那么修改了之后，全局中的变量都做了修改，global关键字就是可以使一个变量变成全局变量。

6）匿名函数（lambda）

想必大家都知道匿名是什么含义，匿名就是指没有名字，我们在写程序的过程中有时不需要给函数命名，这时候就可以使用匿名函数，我们在Python中使用lambda表达式来使用匿名函数。

1、匿名函数的定义

通过一个例子来介绍一下lambda函数的简单使用，变量m为我们输入的值，我们需要采用匿名函数来返回m的平方和，也就是输入2要返回值为4。

>>> m = int(input('请输入一个数字:'))#m为输入的值
请输入一个数字:6
>>> a = lambda x : x * x #使用变量a来构成一个表达式
>>> print('返回值为：',a(m))
返回值为： 36
>>>

通过下图再来看一下它的结构：

2、序列调用匿名方法

在序列中同样可以使用匿名函数，使用匿名函数可以帮助我们进行很快的数据筛选，看下面的例子：

>>> my_list = [1,4,6,9,12,23,25,28,36,38,41,56,63,77,88,99]
>>> print(list(filter(lambda x : x % 2 == 0,my_list)))
[4, 6, 12, 28, 36, 38, 56, 88]
>>>

7）常用内置函数

Python中常用的内置函数如下：

函数名	说明
abs()	返回绝对值
bin()	返回二进制
bool()	返回布尔值
chr()	用一个范围在256内的整数作参数，返回一个对应的字符
cmp(x,y)	用于比较，前者大于后者返回1，相等返回0，小于后者返回-1
dict()	创建字典
eval()	返回字符串表达式的值
file()	创建一个 file 对象
filter()	过滤函数
float()	把整数和字符串转换成浮点数
format()	格式化函数
getattr()	返回一个对象属性值
globals()	全局变量
hash()	返回一个对象的哈希值
help()	查看函数或者模块的功能
hex()	将10进制整数转换成16进制
id()	返回一个对象在内存中的地址
input()	标准输入
isinstance()	判断一个对象是否为已知的类型
int()	把字符串或数字转换为整型
len()	返回序列的长度
list()	把其他数据类型转换为列表
map()	映射函数
max()	返回最大值
min()	返回最小值
next()	返回迭代对象的下一项
oct()	整数转换八进制数
pow(x,y)	返回x的y次方
print()	输出
range()	创建整数序列
reduce()	聚合函数
reverse()	逆序
round()	对浮点数四舍五入
set()	创建集合
sorted()	排序
sum()	求和

三、python 模块

Python中有很多功能强大的模块，这些模块有的存在于Python系统库中，有的存在于第三方库中，这些模块会为我们提供各种各样的功能。

看下面的示意图：

1）导入模块

1、第一种方式：import 模块名

示例如下：

import random#从系统库中引入这个模块
test = random.randint(1,10)#使用random模块中的randint()方法
print('生成一个随机数：',test)

2、第二种方式：import 模块名 as 别名

import math as t
test = t.cos(2.5)
print(test)

3、第三种方式：from 模块名 import 函数名

from random import randint
test = randint(1,10)
print(test)

2）自定义模块和导入模块

引入的模块通常有三种类型：

• 一种是系统库中存在的模块。
• 一种是第三方模块。
• 最后一种就是我们自己定义来的模块。

1、自定义模块

模块名（文件名）为getcolor.py

def get_color(n):
    if n<13:
        return '梅花'
    elif n<26:
        return '方块'
    elif n<39:
        return '红桃'
    else:
        return '黑桃'

模块名（文件名）为getvalue.py

def get_value(n):
    if n==0 or n==13 or n==26 or n==39:
        return 'A'
    elif n==12 or n==25 or n==38 or n==51:
        return 'K'
    elif n==11 or n==24 or n==37 or n==50:
        return 'Q'
    elif n==10 or n==23 or n==36 or n==49:
        return 'J'
    else:
        return n%13

2、调用自定义模块

导入自己定义的模块，关键代码如下：

from getcolor import get_color
from getvalue import get_value

四、异常处理和程序调试

1）异常处理 try…except

一张图了解异常处理机制：

示例如下：

try:
    runoob()
except AssertionError as error:
    print(error)
else:
    try:
        with open('file.log') as file:
            read_data = file.read()
    except FileNotFoundError as fnf_error:
        print(fnf_error)
finally:
    print('这句话，无论异常是否发生都会执行。')

2）手动抛出异常

Python 使用 raise 语句抛出一个指定的异常。
raise语法格式如下：

raise [Exception [, args [, traceback]]]

示例如下：

>>> x = 10
>>> if x > 5:
...     raise Exception('x 不能大于 5。x 的值为: {}'.format(x))
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
Exception: x 不能大于 5。x 的值为: 10
>>>

3）用户自定义异常

>>> class MyError(Exception):
...   def __init__(self, value):
...       self.value = value
...   def __str__(self):
...       return repr(self.value)
...
>>> try:
...   raise MyError(2*2)
... except MyError as e:
...   print('My exception occurred, value:', e.value)
...
My exception occurred, value: 4
>>>

4）程序调试

使用assert断言对Ptyhon程序调试分析，在表达式条件为 false 的时候触发异常。。它的语法结构为：

assert expression[,describe]

示例如下：

>>> assert True     # 条件为 true 正常执行
>>> assert False    # 条件为 false 触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError
>>> assert 1==1    # 条件为 true 正常执行
>>> assert 1==2    # 条件为 false 触发异常
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

>>> assert 1==2 # '1 不等于 2'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: 1 不等于 2
>>>
>>> import sys
>>> assert ('linux' in sys.platform) #"该代码只能在 Linux 下执行，在window下执行会报如下错误"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

五、File 文件操作

在Python中访问文件、访问目录、读取文件和写入文件的操作是非常常见的，Python的文件对象也被称为类似文件对象或者流。

1）创建和打开文件

创建或者打开文件的时候需要使用到open()函数，它的语法结构为：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:

• file: 必需，文件路径（相对或者绝对路径）。
• mode: 可选，文件打开模式（常用）
• buffering: 设置缓冲
• encoding: 一般使用utf8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型
• opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

mode 常用参数如下：

2）file对象

• file.write(str)——将字符串写入文件，返回的是写入的字符长度。
• file.read([size])——从文件读取指定的字节数，如果未给定或为负则读取所有。
• file.readline([size])——读取整行，包括 “\n” 字符。
• file.readlines([sizeint])——读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
• file.flush()——刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
• file.close()——关闭文件。关闭后文件不能再进行读写操作。
• file.writelines(sequence)——向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

示例如下：

file = open('test.txt','w')
file.write('第一次写入。')
print(file)
file = open('test.txt','a+')
file.write('第二次追加写入。')
print(file)

我们可以在写入之后需要文件关闭掉，以保证文件中的内容不被恶意插件修改，关闭的方式为：

file.close()

但是使用with可以省略file.close()，因为with会自动关闭文件。

3）with…open()

每次都写close()比较繁琐，Python引入with语句，这样能够确保最后文件一定被关闭，且不用手动再调用close方法。

示例如下：

>>> with open('files.txt','w+') as file:
...     file.write('hello world!!!')
...
14
>>> file.readlines()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: I/O operation on closed file.
>>>

六、os 模块

我们对文件的管理是通过文件对象的方式实现的，而文件是Python中os模块，我们在管理文件或目录的时候，就需要使用Python中的os模块，os模块中有非常多的方法来帮助我们处理文件及目录。

1）常用 os 方法

常用的os方法如下表格：

示例如下：

>>> import os
>>> os.name#返回nt为windows,posix为Linux、Unix或mac os。
>>> os.linesep#当前系统的换行符
'\r\n'
>>> os.sep#当前系统的分隔符
'\\'
>>> os.name
'nt'

2）常用 os.path 方法

os.path是一个针对路径的模块，模块内提供对文件、目录和路径管理的函数，常见的方法如下表格：

其中最常用的几种分别是abspath()、exists(path)、join(path,name)、basename(path)、dirname(path)、isdir(path)，我们来看个例子：

>>> import os
>>> print('当前目录：',os.getcwd())
当前目录： /root
>>> print('判断当前目录是否存在,存在的话返回True',os.path.exists(os.getcwd()))
判断当前目录是否存在,存在的话返回True True
>>>

七、日期与时间

Python 程序能用很多方式处理日期和时间，转换日期格式是一个常见的功能。

1）获取当前时间戳

示例如下：

>>> import time  # 引入time模块
>>>
>>> # 获取当前时间戳
... ticks = time.time()
>>> print ("当前时间戳为:", ticks)
当前时间戳为: 1675176378.2444868
>>>

2）获取当前时间

从返回浮点数的时间戳方式向时间元组转换，只要将浮点数传递给如localtime之类的函数。

>>> import time
>>>
>>> localtime = time.localtime(time.time())
>>> print ("本地时间为 :", localtime)
本地时间为 : time.struct_time(tm_year=2023, tm_mon=1, tm_mday=31, tm_hour=22, tm_min=47, tm_sec=16, tm_wday=1, tm_yday=31, tm_isdst=0)
>>>

3）格式化时间

>>> import time
>>>
>>> localtime = time.asctime( time.localtime(time.time()) )
>>> print ("本地时间为 :", localtime)
本地时间为 : Tue Jan 31 22:48:00 2023
>>> print ("本地时间为 :", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
本地时间为 : 2023-01-31 22:49:12
>>>

4）时间戳和格式化时间相互转化

时间戳转格式化时间

>>> import time
>>> timestamp = 1675175334 # 时间戳
>>> formattime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timestamp))
>>> print(formattime )
2023-01-31 22:28:54
>>>

格式化时间转时间戳

>>> import time
>>> dt = "2023-01-31 22:28:54"
>>> timeArray = time.strptime(dt, "%Y-%m-%d %H:%M:%S")
>>> timestamp = time.mktime(timeArray)
>>> print(timestamp)
1675175334.0
>>>

python基础部分就先到这里了，非常简单，网络资料也很多，都差不多，这里也只是针对常用的知识点整理了一下。讲完了基础部分，接下来就进入高级编程了，例如：面向对象、网络编程等等，请小伙伴耐心，也可关注我的公众号【大数据与云原生技术分享】深入交流~