【Python语言速回顾】——函数&模块&类与对象
目录
引入
一、函数
1、函数概述
2、参数和返回值
3、函数的调用
二、模块
1、模块概述
2、模块应用实例
三、类与对象
1、面向对象概述
2、类
3、类的特点
引入
为了使程序实现的代码更加简单。需要把程序分成越来越小的组成部分，3种方式——函数、对象、模块。
一、函数
1、函数概述
C语言大括号{}里是函数体，python种缩进块里是函数体（配合def和冒号：）
函数外面定义的变量是全局变量（大写配合下划线）
函数内部定义的局部变量（小写配合下划线），只在内部有效
def foodprice(per_price,number):
sum_price = per_price*number
return sum_price
PER_PRICE = float(input('请输入单价：'))
NUMBER = float(input('请输入数量：'))
SUM_PRICE = foodprice(PER_PRICE,NUMBER)
print('一共',SUM_PRICE,'元')
==========运行结果==========
请输入单价：15
请输入数量：4
一共 60.0 元若想在函数内部修改全局变量，并使之在整个程序生效用关键字global：
def foodprice(per_price,number):
global PER_PRICE
PER_PRICE = 10
sum_price = per_price*number
return sum_price2、参数和返回值
在python种，函数参数分为3种：位置参数、可变参数、关键字参数。参数的类型不同，参数的传递方式也不同。
①位置参数
位置参数：传入参数值按照位置顺序依次赋给参数。
传递方式：直接传入参数即可，如果有多个参数，位置先后顺序不可改变。若交换顺序，函数结果则不同
def sub(x,y):
return x-y
>>> sub(10,5)
5
>>> sub(5,10)
-5②关键字参数
关键字参数：通过参数名指定需要赋值的参数，可忽略参数顺序
传递方式：2种，一是直接传入参数，二是先将参数封装成字典，再在封装后的字典前添加两个星号**传入
>>> sub(y=5,x=10)
5
>>> sub(**{'y':5,'x':10})
5③默认值参数
当函数调用忘记给某个参数值时，会使用默认值代替（以防报错）
def sub(x=100,y=50):
return x-y
>>> sub()
50
>>> sub(51)
1
>>> sub(10,5)
5④可变参数
可变参数：在定义函数参数时，我们不知道到底需要几个参数，只要在参数前面加上星号*即可。
def var(*param):
print('可变参数param中第3个参数是：',param[2])
print('可变参数param的长度是:',len(param))
>>> var('BUCT',1958,'Liming',100,'A')
可变参数param中第3个参数是： Liming
可变参数param的长度是: 5除了可变参数，后也可有普通参数（普参需要用关键字参数传值）：
def var(*param,str1):
print('可变参数param中第3个参数是：',param[2])
print('可变参数param的长度是:',len(param))
print('我是普通参数:',str1)
>>> var('BUCT',1958,'Liming',100,'A',str1 = '普参')
可变参数param中第3个参数是： Liming
可变参数param的长度是: 5
我是普通参数: 普参⑤函数的返回值
若没有用return指定返回值，则返回一个空None
result = var('BUCT',1958,'Liming',100,'A',str1 = '普参')
>>> print(result)
None若将函数改为：
def var(*param,str1):
print('可变参数param中第3个参数是：',param[2])
print('可变参数param的长度是:',len(param))
print('我是普通参数:',str1)
return param
>>> print(result)
('BUCT', 1958, 'Liming', 100, 'A')
3、函数的调用
自定义函数：先定义再调用
内置函数：直接调用，有的在特定模块里，需要先import相应模块
①嵌套调用
内嵌函数/内部函数：在函数内部再定义一个函数，作用域只在其相邻外层函数缩进块内部。
②使用闭包
闭包：函数式编程的一个重要的语法结构，在一个内部函数里对外部作用域（不是全局作用域）的变量进行引用。此时这个内部函数叫做闭包函数，如下sub2（b）就是引用了a，为闭包函数：
def sub(a):
def sub2(b):
result = a-b
return result
return sub2
print(sub(10)(5))
运行结果：5注：闭包本质还是内嵌函数，不能再全局域访问，外部函数sub的局部变量对于闭包来说是全局变量，可以访问但是不能修改。
③递归调用
递归：严格说其属于算法范畴，不属于语法范围。函数调用自身的行为叫做递归。
两个条件：调用函数自身、设置了正确的返回条件。如计算正整数N的阶乘：
常规迭代算法：
def factorial(n):
result = n
for i in range(1,n):
result *= i
return result
print(factorial(10))
运行结果：3628800迭代算法：
def factorial(n):
if n == 1:
return 1
else:
return n*factorial(n-1)
print(factorial(10))
运行结果：3628800注：python默认递归深度为100层（限制），也可用sys.setrecursionlimit（x）指定递归深度。递归有危险（消耗时间和空间），因为它是基于弹栈和出栈操作；递归忘记返回时/未设置正确返回条件时，会使程序崩溃，消耗掉所有内存。
二、模块
1、模块概述
模块实际上是一种更为高级的封装。前面容器（元组，列表）是对数据的封装，函数是对语句的封装，类是方法和属性的封装，模块就是对程序的封装。——就是我们保存的实现特定功能的.py文件
命名空间：一个包含了一个或多个变量名称和它们各自对应的对象值的字典，python可调用局部命名空间和全局命名空间中的变量。
如果一个局部变量与全局变量重名，则再函数内部调用局部变量时，会屏蔽全局变量。
如果要修改函数内全局变量的值，需要借助global
①模块导入方法
方法一：
import modulename
import modulename1，modulename2使用函数时modulename.functionname()即可
方法二:
from modulename import functionname1,functionname2方法三：
import modulename as newname相当于给模块起了个新名字，便于记忆也方便调用
②自定义模块和包
自定义模块：
编写的mine.py文件放在与调用程序同一目录下，在其他文件中使用时就可import mine使用。
自定义包：
在大型项目开发中，为了避免模块名重复，python引入了按目录来组织模块的方法，称为包（package）。
包是一个分层级的文件目录结构，定义了有模块、子包、子包下的子包等组成的命名空间。
只要顶层报名不与其他人重名，内部的所有模块都不会冲突。——P114
③安装第三方包
pip install xxxx
2、模块应用实例
①日期和时间相关：datatime模块
导入：
from datetime import datetime
#不能import datetime，可以import datetime.datetime（因为datetime模块里还有一个datetime类）获取当前日期时间：
>>> now = datetime.now()
>>> print(now)
2023-10-05 17:28:24.303285获取指定日期时间：
>>> dt = datetime(2020,12,12,11,30,45)
>>> print(dt)
2020-12-12 11:30:45datetime与timestamp互相转换：
把1970-1-1 00：00：00 UTC+00：00的时间作为epoch time，记为0，当前时间就是相对于epoch time的秒数，称为timestamp。
计算机中存储的当前时间是以timestamp表示的，与时区无关，全球各地计算机在任意时刻的timestamp是相同的。
>>> dt = dt.timestamp()
>>> print(dt)
1607743845.0
#再转换回去：
>>> dt = datetime.fromtimestamp(dt)
>>> print(dt)
2020-12-12 11:30:45str转换为datetime：
用户输入的日期和时间类型是字符串，要处理日期和时间，必须把str转换为datetime
>>> test = datetime.strptime('2023-10-05 17:49:00','%Y-%m-%d %H:%M:%S') #特殊字符规定了格式
>>> print(test)
2023-10-05 17:49:00datetime转换为str：
若已有datetime对象，要把它格式化为字符才能显示给用户
>>> now = datetime.now()
>>> print(now.strftime('%a,%b %d %H:%M'))
Thu,Oct 05 17:28datetime加减计算：（再导入timedelta类）
>>> from datetime import datetime,timedelta
>>> now = datetime.now()
>>> now
datetime.datetime(2023, 10, 5, 17, 58, 9, 377124)
>>> now + timedelta(hours = 2)
datetime.datetime(2023, 10, 5, 19, 58, 9, 377124)
>>> now - timedelta(days = 3)
datetime.datetime(2023, 10, 2, 17, 58, 9, 377124)本地时间转换为UTC时间：（再导入timedelta、timezone类）
本地时间为系统设定时区的时间，例如北京时间是UTC+8:00时区的时间，而UTC时间指UTC+0:00时区的时间。datetime里面有时区属性tzinfo。
>>> from datetime import datetime,timedelta,timezone
>>> new_utc = timezone(timedelta(hours = 8)) #创建新时区UTC+8：00
>>> new_utc1 = timezone(timedelta(hours = 7)) #创建新时区UTC+7：00
>>> now = datetime.now()
>>> now
datetime.datetime(2023, 10, 5, 18, 9, 17, 667655)
>>> test = now.replace(tzinfo = new_utc) #为当前时间强制设置新的时区
>>> test
datetime.datetime(2023, 10, 5, 18, 9, 17, 667655, tzinfo=datetime.timezone(datetime.timedelta(0, 28800)))
>>> test1 = now.replace(tzinfo = new_utc1) #为当前时间强制设置新的时区UTC+7：00
>>> test1
datetime.datetime(2023, 10, 5, 18, 9, 17, 667655, tzinfo=datetime.timezone(datetime.timedelta(0, 25200)))时区转换：
先用datetime类提供的utcnow（）方法获取当前UTC时间，再用astimezone（）方法转换为任意时区的时间
②读写JSON数据：json模块
JSON是一种轻量级的数据交换格式，等同于python里面的字典格式，里面可以包含方括号括起来的数组（列表）。json模块专门解决json格式的数据，提供4种方法：dumps()、dump()、loads（）、load（）
dumps()、dump()实现序列化功能：
dumps()实现将数据序列化为字符串str，而使用dump（）时必须传文件描述符，将序列化的字符串str保存到文件中。
>>> import json
>>> json.dumps('huang')
'"huang"'
>>> json.dumps(13.14)
'13.14'
>>> dict1 = {'name':'huang','school':'buct'}
>>> json.dumps(dict1)
'{"name": "huang", "school": "buct"}'
>>> with open("D:\\json_test.json","w",encoding = 'utf-8')as file_test:
json.dump(dict1,file_test,indent = 4)
运行结果：dump()方法将字典数据dict_test保存到D盘文件夹下的json_test.json文件中，里面的内容如下
{
"name": "huang",
"school": "buct"
}loads()、load（）是反序列化方法：
loads()只完成了反序列化，load()只接收文件描述符，完成了读取文件和反序列化。
>>> json.loads(json.dumps(dict1)) #loads直接操作程序中的字典
{'name': 'huang', 'school': 'buct'} #dumps将字典序列化成str，loads又使其恢复字典身份
>>> with open("D:\\json_test.json","r",encoding = 'utf-8')as file_test: #读刚才保存的序列化str字符串数据
test_loads = json.loads(file_test.read()) #用loads实现反序列化
file_test.seek(0) #重新定位在文件的第0位及开始位置
test_load = json.load(file_test) #用load实现反序列化
>>> print(test_loads)
{'name': 'huang', 'school': 'buct'}
>>> print(test_load)
{'name': 'huang', 'school': 'buct'}③系统相关：sys模块
sys是python自带模块，包含了与系统相关的信息。可通过help(sys)或dir(sys)查看sys模块的可用方法（很多），下面列举几种。
sys.path包含输入模块的目录名列表：
>>> sys.path
['',
'D:\\python3.6.6\\Lib\\idlelib',
'D:\\python3.6.6\\python36.zip',
'D:\\python3.6.6\\DLLs',
'D:\\python3.6.6\\lib',
'D:\\python3.6.6',
'D:\\python3.6.6\\lib\\site-packages']该命令获取了指定模块搜索路径的字符串集合。将写好的模块放在上面得到的某个路径下，就可以在使用import导入时正确找到，也可以用sys.path.append(自定义路径）添加模块路径。——“自定义模块乱放程序是找不到的！”
sys.argv在外部向程序内部传递参数：
????
sys.argv变量是一个包含了命令行参数的字符串列表，利用命令行向程序传递参数。其中脚本的名称是sys.argv列表的第一个参数。
④数学：math模块
math模块也是python自带模块，包含了和数学运算公式相关的信息——P125
⑤随机数：random模块
列举常用模块：
生成随机整数（需指定上下限，且下限小于上限）：randint
import random
>>> random.randint(10,2390) #生成指定范围内的随机整数
2375生成随机浮点数：random
>>> random.random()
0.9935870033845187
>>> random.uniform(10,100)
27.07308173076904
>>> random.uniform(100,10)
18.198994262912336随机字符：choice
>>> random.choice('98%$333#@')
'3'洗牌：shuffle
>>> test = ['a','B',1,2,5,'%']
>>> random.shuffle(test)
>>> print(test)
[5, 1, 2, 'a', 'B', '%']三、类与对象
1、面向对象概述
面向对象编程（Object Oriented Programming，OOP），是一种程序设计思想，是以建立模型体现出来的抽象思维过程和面向对象的方法。
模型是用来反映现实世界中的事物特征的，是对事物特征和变化规律的抽象化，是更普遍、更集中、更深刻地描述客体的特征。
OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。
术语简介：
1、类：是创建对象的代码段，描述了对象的特征、属性、要实现的功能，以及采用的方法等。
2、属性：描述了对象的静态特征。
3、方法：描述了对象的动态动作。
4、对象：对象是类的一个实例，就是模拟真实事件，把数据和代码段都集合到一起，即属性、方法的集合。
5、实例：就是类的实体。
6、实例化：创建类的一个实例过程。
7、封装：把对象的属性、方法、事件集中到一个统一的类中，并对调用者屏蔽其中的细节。
8、继承：一个类共享另一个类的数据结构和方法的机制称为继承。起始类称为基类、超类、父类，而继承类称为派生类、子类。继承类是对被继承类的拓展。
9、多态：一个同样的函数对于不同的对象可以具有不同的实现。
10、接口：定义了方法、属性的结构，为其成员提供违约，不提供实现。不能直接从接口创建对象，必须首先创建一个类来实现接口所定义的内容。
11、重载：一个方法可以具有许多不同的接口，但方法的名称是相同的。
12、事件：事件是由某个外部行为所引发的对象方法。
13、重写：在派生类中，对基类某个方法的程序代码及进行重新编码，使其实现不同的功能。
14、构造函数：是创建对象所调用的特殊方法。
15、析构函数：是释放对象时所调用的特殊方法。2、类
①类的定义
类就是对象的属性和方法的拼接，静态的特征称为属性，动态的动作称为方法。
>>> class Person: #规定类名以大写字母开头
#属性
skincolor = "yellow"
high = 185
weight = 75
#方法
def goroad(self):
print("人走路动作的测试...")
def sleep(self):
print("睡觉，晚安！")②类的使用（类实例化为对象）
>>> p = Person() #将类实例化为对象，注意后面要加括号（）③类的构造方法及专有方法
类的构造方法：__int__(self)。只要实例化一个对象，此方法就会在对象被创建时自动调用——实例化对象时是可以传入参数的，这些参数会自动传入__int__(self，param1，param2...)方法中，可以通过重写这个方法来自定义对象的初始化操作。
>>> class Bear:
def __init__(self,name):
self.name = name
def kill(self):
print("%s是保护动物不可猎杀"%self.name)
>>> a = Bear("狗熊")
>>> a.kill()
狗熊是保护动物不可猎杀解释：与Person()相比，这里重写了__init__()方法，不然默认为__init__(self)。在Bear()中给了一个参数name，成了__init__(self,name)，第一个参数self是默认的，所以调用时把“狗熊”传给了name。也可以给name默认参数，这样即使忘记传入参数，程序也不会报错：
>>> class Bear:
def __init__(self,name = "狗熊"):
self.name = name
def kill(self):
print("%s是保护动物不可猎杀"%self.name)
>>> b = Bear()
>>> b.kill()
狗熊是保护动物不可猎杀
>>> c = Bear("丹顶鹤")
>>> c.kill()
丹顶鹤是保护动物不可猎杀④类的访问权限
在C++和JAVA中是通过关键字public、private来表明访问权限是共有的还是私有的。在python中，默认情况下对象的属性和方法是公开的、公有的，通过点(.)操作符来访问。如上面的kill()函数（方法）的访问，也可以访问变量：
>>> class Test:
name = "大连橡塑"
>>> a = Test()
>>> a.name
'大连橡塑'若变量前面加上双下划线(__)就表示声明为私有变量就不可访问：
>>> class Test:
__name = "君欣旅店"
>>> a = Test()
>>> a.__name
Traceback (most recent call last):
File "", line 1, in
a.__name
AttributeError: 'Test' object has no attribute '__name' 可利用函数方法访问私有变量：
>>> class Test:
__name = "君欣旅店"
def getname(self):
return self.__name
>>> a = Test()
>>> a.getname()
'君欣旅店'也可通过"_类名__变量名"格式访问私有变量：
>>> a._Test__name
'君欣旅店'（由此可见python的私有机制是伪私有，python的类是没有权限控制的，变量可以被外界调用）
⑤获取对象信息
类实例化对象后（如a = Test())，对象就可以调用类的属性和方法：
即a.getname()、a.name、a.kill()这些
3、类的特点
①封装
形式上看，对象封装了属性就是变量，而方法和函数是独立性很强的模块，封装就是一种信息掩蔽技术，使数据更加安全！
如列表实质上是python的一个序列对象，sort()就是其中一个方法/函数：
>>> list1 = ['E','C','B','A','D']
>>> list1.sort()
>>> list1
['A', 'B', 'C', 'D', 'E']②多态
不同对象对同一方法响应不同的行动就是多态（内部方法/函数名相同，但是不同类里面定义的功能不同）：
>>> class Test1:
def func(self):
print("这是响应1...")
>>> class Test2:
def func(self):
print("这是响应2...")
>>> x = Test1()
>>> y = Test2()
>>> x.func()
这是响应1...
>>> y.func()
这是响应2...注意：self相当于C++的this指针。由同一个类可以生成无数个对象，这些对象都源于同一个类的属性和方法，当一个对象的方法被调用时，对象会将自身作为第一个参数传给self参数，接收self参数时，python就知道是哪个对象在调用方法了。
③继承
继承是子类自动共享父类数据和方法的机制。语法格式如下：
class ClassName(BaseClassName):
...
ClassName：子类名称，第一个字母必须大写。
BaseClassName/paraname：父类名称。子类可继承父类的任何属性和方法，如下定义类Test_list继承列表list的属性和方法（append和sort）：
>>> class Test_list(list):
pass
>>> list1 = Test_list()
>>> list1.append('B')
>>> list1
['B']
>>> list1.append('UCT')
>>> list1
['B', 'UCT']
>>> list1.sort()
>>> list1
['B', 'UCT']使用类继承机制时的注意事项：
a、若子类中定义与父类同名的方法或属性，自动覆盖父类里对应的属性或方法。
b、子类重写父类中同名的属性或方法，若被重写的子类同名的方法里面没有引入父类同名的方法，实例化对象调用父类的同名方法就会出错：
import random
class Dog:
def __init__(self):
self.x = random.randint(1,100) #两个缩进
self.y = random.randint(1,100)
def run_Dog(self):
self.x += 1
print("狗狗的位置是:",self.x,self.y)
class Dog1(Dog):
pass
class Dog2(Dog):
def __init__(self):
self.hungry = True
def eat(self):
if self.hungry:
print("狗想吃东西了！")
self.hungry = False
else:
print("狗吃饱了！")
调用：
>>> dog = Dog()
>>> dog.run_Dog()
狗狗的位置是: 62 69
>>> dog1 = Dog1()
>>> dog1.run_Dog()
狗狗的位置是: 29 89
>>> dog2 = Dog2()
>>> dog2.eat()
狗想吃东西了！
>>> dog2.eat()
狗吃饱了！
>>> dog2.run_Dog() #报错报错！！！分析：子类Dog2重写了父类（基类）Dog的构造函数__init__(self)，则父类构造函数里的方法被覆盖。要解决此问题，就要在子类里面重写父类同名方法时，先引入父类的同名方法，两种技术：a、调用未绑定的父类方法；b、使用super函数
a、调用未绑定的父类方法——语法格式：paraname.func(self)。父类名.方法名.(self)
对上面示例代码的Dog2类更改：
def __init__(self):
Dog.__init__(self) #加了这一行
self.hungry = True
调用：
>>> dog2 = Dog2()
>>> dog2.run_Dog()
狗狗的位置是: 85 16b、使用super函数，该函数可以自动找到父类方法和传入的self参数，语法格式：super().func([parameter])。parameter为可选参数，若是self可省略。
对上面示例代码的Dog2类更改：
def __init__(self):
super().__init__() #加了这一行
self.hungry = True
调用：
>>> dog2 = Dog2()
>>> dog2.run_Dog()
狗狗的位置是: 96 82使用super函数的方便之处在于不用写任何关于基类（父类）的名称，直接写重写的方法即可，会自动去父类去寻找，尤其在多重继承中，或者子类有多个祖先类时，能自动跳过多种层级去寻找。如果以后要更改父类，直接修改括号（）里面的父类名称即可，不用再修改重写的同名方法里的内容。
④多重继承
一个子类同时继承多个父类的属性和方法：
class Classname（Base1，Base2，Base3）：
...虽然多重继承的机制可以使子类继承多个属性和方法，但是容易导致代码混乱，引起不可预见的Bug，一般尽量避免使用。
