1、Function 函数
编程中，需要重复写的功能，可以包装成一个函数
1）定义函数
定义函数之前，实现给一个字符串增加前缀和后缀的操作：
|
1
2
3
4
5
6
7
8
|
f1 = "f1"
f2 = "f2"
f1 += ".txt"
f1 = "my_" + f1
f2 += ".txt"
f2 = "my_" + f2
print(f1, f2)
my_f1.txt my_f2.txt
|
定义函数之后：
|
1
2
3
4
5
6
7
8
|
def modify_name(filename):
filename += ".txt"
filename = "my_" + filename
print(filename)
modify_name("f1")
modify_name("f2")
my_f1.txt
my_f2.txt
|
上述函数里面用到了参数，调用的时候需要进进行传参数，但有时也可以没有参数，eg：
|
1
2
3
4
5
6
7
|
def modify_name():
filename = "f1"
filename += ".txt"
filename = "my_" + filename
print(filename)
modify_name()
my_f1.txt
|
一个函数也可以拥有返回值，将函数处理后，可以将想要返回的结果返回
|
1
2
3
4
5
6
7
|
def modify_name(filename):
filename += ".txt"
filename = "my_" + filename
return filename
new_filename = modify_name("f1")
print(new_filename)
my_f1.txt
|
2)参数设置
调用函数时，如果函数有参数，那么需要给函数传参，函数本来的参数叫实参，传入的参数叫实参，参数传递有以下几种方式：
|
1
2
3
4
5
6
7
8
9
|
def f(x, a, b, c):
return a*x**2 + b*x + c*1
print(f(2, 1, 1, 0)) # 忽略参数名，需要按顺序一一对应
print(f(x=2, a=1, b=1, c=0)) # 写上参数名，按名字传参
print(f(a=1, c=0, x=2, b=1)) # 若用参数名，可以打乱顺序传参
6
6
6
|
另外，对于不是一直变化的参数，可以给参数设置一个默认值，如果设置了默认值，传参时可以不给改参数传值，否则每个参数都要传参成功才能调用
|
1
2
3
4
5
6
7
|
def f(x, a=1, b=1, c=0):
return a*x**2 + b*x + c*1
print(f(2, a=2))
print(f(2))
10
6
|
Tip: 设置了默认值的参数和未设置默认值的参数要分开放，也就是说不可以将未设置默认值的参数跟在设置了默认值参数的后面
3）全局和局部变量
- 全局变量（global）：函数里外都能用（公用）
- 局部变量（local）：仅在函数内使用（私用）
|
1
2
3
4
5
|
def modify_name():
filename = "f1.txt" # 这里就是一个局部变量
print("local filename:", filename)
modify_name()
print("global filename:", filename) # 这里会报错
|
|
1
2
3
4
5
|
filename = "f1.txt" # 这里便是一个全局变量
def modify_name():
print("local filename:", filename)
modify_name()
print("global filename:", filename)
|
- 全局变量和局部变量冲突时，局部变量优先！！！
|
1
2
3
4
5
6
7
8
|
filename = "f1.txt"
def modify_name():
filename = "f2.txt"
print("local filename:", filename)
modify_name()
print("global filename:", filename)
local filename: f2.txt
global filename: f1.txt
|
- 特殊情况：允许内部来修改外部的值，必须使用global声明，相当于提出了一个申请
|
1
2
3
4
5
6
7
8
9
10
11
|
filename = "f1.txt"
def modify_name():
global filename # 提出申请
filename = "f2.txt"
print("local filename:", filename)
modify_name()
print("global filename:", filename)
local filename: f2.txt
global filename: f2.txt
|
2、Class类
目的：为了描述一个或一类具体的物体，eg：猫的特征，动作等
1）定义class
使用class File来创建一个类，注意通常约定类的名字要首字母大写。
然后使用my_file = File()来创建一个实例，每个实例都继承了一个类的基本属性
|
1
2
3
4
5
6
7
8
9
10
|
class File:
def __init__(self):
self.name = "f1"
self.create_time = "today"
my_file = File()
print(my_file.name)
print(my_file.create_time)
f1
today
|
- 其中 self 是作为类自己的一个索引，不管你在定义类的时候，想要获取这个类的什么属性或功能，都可以通过self来获取。
- __init__()：创建一个实例的时候，类都会自动进行一次初始化，即运行一遍__init__()函数
- 修改属性的值：(但这样修改的值，仅对当前实例有效)
|
1
2
3
|
my_file.name = "new_name"
print(my_file.name)
new_name
|
2）class的功能
- __init__()：也可以对该函数进行传参：
|
1
2
3
4
5
6
7
8
9
10
|
class File:
def __init__(self, name, create_time="today"):
self.name = name
self.create_time = create_time
my_file = File("my_file")
print(my_file.name)
print(my_file.create_time)
my_file
today
|
- 还可以定义更多的功能，比如重命名等
|
1
2
3
4
5
6
7
8
9
10
11
|
class File:
def __init__(self, name, create_time="today"):
self.name = name
self.create_time = create_time
def change_name(self, new_name):
self.name = new_name
my_file = File("my_file")
my_file.change_name("new_name")
print(my_file.name)
new_name
|
- 而且类的功能也可以有返回值
|
1
2
3
4
5
6
7
8
9
10
|
class File:
def __init__(self, name, create_time="today"):
self.name = name
self.create_time = create_time
def get_info(self):
return self.name + " is created at " + self.create_time
my_file = File("my_file")
print(my_file.get_info())
my_file is created at today
|
3)继承
- 俩个类分开写，eg：
|
1
2
3
4
5
6
7
8
9
10
11
|
class Video:
def __init__(self, name, window_size=(1080, 720)):
self.name = name
self.window_size = window_size
self.create_time = "today"
class Text:
def __init__(self, name, language="zh-cn"):
self.name = name
self.language = language
self.create_time = "today"
|
可以发现，这俩个类是有共性的，比如都有name，和create_time
所以，可以编写一个底层类，使得这俩个类继承底层类，从而减少了类之间的共有属性/功能的重复开发！！！
一个类可以继承另一个类，从而使得这个类成为子类，被继承的类为父类
子类可以继承父类的功能/功能，而且子类还可以重定义父类的功能
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
class File:
def __init__(self, name, create_time="today"):
self.name = name
self.create_time = create_time
def get_info(self):
return self.name + " is created at " + self.create_time
class Video(File):
def __init__(self, name, window_size=(1080, 720)):
# 将共有属性的设置导入File父类
super().__init__(name=name, create_time="today")
self.window_size = window_size
class Text(File):
def __init__(self, name, language="zh-cn"):
super().__init__(name=name, create_time="today")
self.language = language
# 也可以在子类中复用父类功能
def get_more_info(self):
return self.get_info() + ", using language of " + self.language
v = Video("my_video")
t = Text("my_text")
print(v.get_info()) # 调用父类功能
print(t.create_time) # 调用父类的属性
print(t.language) # 调用自己的属性
print(t.get_more_info()) # 调用自己复用父类的功能
my_video is created at today
today
zh-cn
my_text is created at today, using language of zh-cn
|
4）私有属性和功能
- 私有：_一个下划线开头，弱隐藏，不想让别人用，但别人在必要情况下还是可以用的
- 私有：__俩个下划线开头，强隐藏，不让别人使用
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
class File:
def __init__(self):
self.name = "f1"
self.__deleted = False # 不让别人使用这个变量
self._type = "txt" # 不想别人使用这个变量
def delete(self):
self.__force_delete()
def __force_delete(self): # 不让别人使用这个功能
self.__deleted = True
return True
def _soft_delete(self): # 不想让别人使用这个功能
self.__force_delete() # 虽然是强隐藏，但是可以在内部随便调用
return True
f = File()
print(f._type) # 可以拿到值，但是会有⚠️
print(f._soft_delete()) # 可以调用，但是会有⚠️
print(f.__deleted) # 会直接报错
print(f.__force_delete) # 会直接报错
|
5）特殊方法
| 定义 | 含义 |
|---|---|
| def __init__() | 初始化实例 |
| def __repr__() | 字符串的“官方”表现形式 |
| def __str__() | 字符串的“非正式”值 |
| def __iter__() | 遍历某个序列 |
| def __next__() | 从迭代器中获取下一个值 |
| … | … |
3、Module模块
Moudel主要是为一个相对比较大的工程，涉及到多个文件之间的互相调用关系。
- 对于一个项目来说，它需要去实现很多功能，这时候，如果可以把某一个或者某一类功能分类写到了一个文件之中，在合并的时候，我不便不需要知道文件中的代码具体什么，我只需要调用你给的这个文件中的功能就可以！也
- 就是说，作为你所给文件中的功能的使用者，我不关心你实现功能的代码，我只关系我可以使用函数调用到你这个功能就好
|
1
2
3
|
# file.py
def create_name():
return "new_file.txt"
|
eg: 比如上述file.py文件，实现了create_name的功能，然而作为这个功能的使用者，我不需要去了解这个功能所使用的代码，我只关心如何调用使用这个功能
1）引用module
比如新建了一个me.py，需要在这个文件之中引用file.py中的create_name()的功能
|
1
2
3
4
|
# me.py
import file
print(file.create_name())
new_file.txt
|
或者也可以这样调用
|
1
2
3
4
5
6
7
8
9
10
|
# me.py
import file as f1
print("f1:", f1.create_name())
class File:
def create_name(self):
return "new_file.txt"
f2 = File()
print("f2:", f2.create_name())
f1: new_file.txt
f2: new_file.txt
|
可以发现，这和类功能调用有着非常大的相似之处！！！
还有更多的引用方式：
|
1
2
3
4
|
# me.py
from file import create_name
print(create_name())
new_file.txt
|
假设file.py中还有一个函数create_time()
|
1
2
3
4
5
6
|
# me.py
from file import create_name, create_time
print(create_name())
print(create_time())
new_file.txt
today
|
如何file.py中函数太多，记不清，那么可以如此引用：
|
1
2
3
4
5
6
7
8
|
# me.py
# 第一种
import file
print("1", file.create_name())
#第二种
from file import *
print("2", create_name())
print("2", create_time())
|
2）大项目的模块管理
在正规的module中，我们常会看到一个__init__.py文件，就像class里的def __init__(self)，可以在里面写上如何初始化你的files目录，也可以设定目录中各元素的关系。
|
1
2
|
# files/__init__.py
from .video import get_video_size
|
设置好__init__.py后，就可以直接从files里import get_video_size这个属于video.py的功能了
|
1
2
3
|
# me.py
from files import get_video_size
print(get_video_size())
|
但和video.py同级的text.py就无法通过import方式获取到text.py中的功能，因为未在files/__init__.py中声明
|
1
2
|
# me.py
from files import create_name
|
如果不在files/__init__.py中声明，但还想调用，则可以使用：
|
1
2
3
4
5
6
|
# me.py
import files.text
print(files.text.create_name)
# 或者
from files import text
print(text.create_name)
|
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注服务器之家的更多内容！
原文链接：https://blog.csdn.net/Mrwei_418/article/details/120987368