Python之 函数笔记
目录
第一节：
定义一个函数：
一个简单函数的使用： (无参数)
带参数的函数:
带默认值参数的函数：
当参数的数据类型是列表：
带可变参数的函数(装包和拆包):
可变参数 *args：
可变参数 **kwargs：
装包和拆包：
带返回值的函数：
第二节：
全局变量和局部变量：
可变和不可变类型：
变量作用域（LEGB）：
第三节：
函数注释问题：
函数引用：
函数嵌套：
函数闭包：
装饰器：
简单装饰器举例：
装饰器功能：
原函数带参数时——装饰器：
带返回值的装饰器：
多层装饰器：
装饰器本身有参数时：
嵌套函数，闭包，装饰器之间联系：
第四节：
递归函数：
匿名函数：
使用方式：
匿名函数作函数的参数：
匿名函数与内置函数结合使用：
第一节：
函数可简单分为以下：
1.无参数
2.带可变参数
3.带默认值参数
4.带返回值
定义一个函数：
def 函数名(可选择参数):
函数体
一个简单函数的使用： (无参数)
def jsy(): # 将函数加载到内存空间print('jsy')jsy() # 调用函数输出：
jsy没有参数时，函数就相当于一个具体功能的实现。
带参数的函数:
该代码为求 1~n 的总和
#求 1~n 的总和
def sum(i):a = 1s = 0for j in range(i):s += aa += 1print('1~{}的总和是{}'.format(i,s))
sum(5)输出：
1~5的总和是15
所谓可变参数是指在定义函数时，参数为可变的变量，当使用该函数时需要在括号里加上传入的变量
带默认值参数的函数：
1.在定义函数的时候，有一个或多个参数已经赋好值了，默认了参数的值
2.默认设置好的参数可以不写，当然写上会覆盖默认参数值
3.在定义函数的时候，普通参数要在默认值参数的前面
4.默认参数的顺序是固定的，可通过指明关键字参数来赋值，通过该方式可改变赋值顺序
下面举例说明：
def borrow_book(username, bookname, number=1, school='北大'):print('进入{}的借书系统...'.format(school))print('{}已借{}，借阅{}本'.format(username, bookname, number))borrow_book('jsy', '狂人日记') #对于默认值参数可默认赋值，可以不手动赋值borrow_book('jsy', '大主宰', 6) #要改变默认值参数值时，需要按顺序给它的参数重新赋值borrow_book('jsy',bookname= '朝花夕拾', school='清华') #指明关键字参数来赋值，非默认参数也可使用输出：
进入北大的借书系统...
jsy已借狂人日记，借阅1本
进入北大的借书系统...
jsy已借大主宰，借阅6本
进入清华的借书系统...
jsy已借朝花夕拾，借阅1本当参数的数据类型是列表：
把实参的地址传入形参，函数内部也可对外部的list直接修改(下文中我们会提到可变和不可变类型)
library = ['高数', '政治', '英语', '计算机组成和原理']def add_book(bookname): # 形参library.append(bookname)print('添加成功！')def show_book(books): # 遍历时相当于传入library的地址for book in books:print(book)add_book('数据结构') # 实参
show_book(library) # 实参输出：
添加成功！
高数
政治
英语
计算机组成和原理
数据结构带可变参数的函数(装包和拆包):
可变参数可理解为传入参数的数目和类型可以变化，而在使用可变参数时就会出现装包和拆包的动作。
可变参数可分为：
*args （arguments）默认为一个容器，多个参数，缺省参数在*args的后面
**kwargs （keywardarguments）关键字参数多个可变参数 *args：
当*args使用时，可以改变*后的参数名；作用于单个元素
在函数中的装包，以元组输出
def get_(*a): # 可写入多个参数print(a) # 以元组形式输出get_(1)
get_(1, 2, 3, 4)
输出：
(1,)
(1, 2, 3, 4)*也可以在普通赋值时使用：
a, *b, c = 1, 2, 3, 4, 5
print(a, b, c) # a和c只能赋一个值，而b可以列表形式存放多值输出：
1 [2, 3, 4] 5
此时，由于*的使用出现了装包的现象
可变参数 **kwargs：
需要注意它的传值方式；作用于关键字参数(键值对)
如果说 * 是对列表，元组，集合进行装包拆包的操作，那么 ** 就是对字典的装包拆包操作
def show_book(**kwargs):print(kwargs) # 打印为字典for k, v in kwargs.items():print(k, v)show_book() #无参数输出字典，说明**在字典层面进行操作
show_book(bookname='墨菲定律', author='鸿雁') # 仅以键值对的形式赋值，加到字典中# 一颗星*是拆元组列表集合的包，两颗星**是拆字典的包
book = {'book': '红楼梦', 'author': '曹雪芹'}
show_book(**book) #很明显，这是一个拆包操作输出：
{}
{'bookname': '墨菲定律', 'author': '鸿雁'}
bookname 墨菲定律
author 鸿雁
book 红楼梦
author 曹雪芹当 * 和 ** 同时存在：
此时传入参数也是要按照参数顺序进行传值
def show_(*args, **kwargs): #装包到kwargsprint(args)print(kwargs)book = {'book': '红楼梦', 'author': '曹雪芹'}
show_('jsy', 'JJ', **book) #book拆包；也可以看出来**只接受字典
输出：
('jsy', 'JJ')
{'book': '红楼梦', 'author': '曹雪芹'}装包和拆包：
该过程便可理解为一次装包
a, b = (1, 2)
print(a, b)在下面代码例子中，拆包是指在给函数传入的参数是列表或是集合，元组时，想要传入其中的元素，所以要将其拆开，故需在名称前加上*
装包时，是由于传入参数的数目是变化的，不固定的，要将其打包作为元组整体传入，然后在函数内部对元组进行操作
ran_list = [23, 4, 5, 47, 85, 96, 1, 0] # 需要先进行拆包
def get_sum(*args): #再进行装包print(args)s = 0for i in args:s += iprint('和：', s)get_sum(*ran_list) # 自动拆包输出：
(23, 4, 5, 47, 85, 96, 1, 0)
和： 261带返回值的函数：
参数：外界向函数传值
返回值：函数内容向外界传达，停止函数的调用，立刻结束函数并返回值
return
1.若一个函数有返回值，需要接收
2.当返回多个值时，为元组形式
3.当函数没有返回值时，返回None
下面举一个用函数实现冒泡排序的例子：
将列表元素从小到大进行排序，并返回最小值和最大值
def get_sort(number):# 排序：冒泡排序for i in range(0, len(number) - 1):for j in range(0, len(number) - 1 - i):if number[j] > number[j + 1]:number[j], number[j + 1] = number[j + 1], number[j]# 获取头，尾min = number[0]max = number[-1]# 返回return min, max # 返回多个值时，为元组形式list1 = [21, 11, 25, 69, 96, 12, 1, 10, 20]
print(get_sort(list1))输出：
[1, 10, 11, 12, 20, 21, 25, 69, 96]
(1, 96)第二节：
全局变量和局部变量：
通俗的讲，函数外部定义的变量可称为全局变量，函数内部定义的变量可称为局部变量
1.局部变量在函数被调用时创建内存空间，在函数完成后被回收
2.查看局部变量使用locals()
3.查看全局变量使用globals()
优先级问题：当函数里想要使用变量a， 如果函数里面没有a，则使用全局变量a
如果函数里定义了a，则(优先)使用局部变量a
Python搜索变量或是函数优先级：局部变量--->全局变量--->builtins
举例说明：
# 函数里有a ，优先找内部a
# 全局变量
a = 100def test1():# 局部变量a = 0print('a = ', a) # 函数里有a ，优先找内部atest1() #调用函数此时输出的是局部变量a：
a = 0
# 函数里没有a，则使用全局变量a
a = 100
def test2():b = 2print('a = ', a) # 函数里没有a，则使用全局变量aprint('b = ', b)test2()此时输出全局变量a：
a = 100
b = 2可变和不可变类型：
不可变：当改变变量的值时，地址也发生了改变 （int str float tuple）
可变：当改变变量的值时，地址没有发生改变 （bool list set 字典）
全局变量可以在函数内调用，但是想要修改全局变量的值，要看它是可变还是不可变类型
如果变量是不可变类型：则需 global 关键字声明，才可修改。
如果变量是可变类型：则可以直接修改，不用加global。
用global改变 int 类型的全局变量：
a = 100def test3():# 改变全局变量a的值global aa = 0 #在全局上，a的值变为0print('a = ',a)test3()输出：
a = 0对于可变类型在函数里可进行修改：
library = ['红楼梦','西游记','三国演义']def add_book(bookname):if bookname not in library:library.append(bookname)else:print('已经存在该书！')
def show_book():for book in library:print(book)add_book('墨菲定律')
show_book()对于列表，可以在函数里直接用append()进行添加元素。
输出：
红楼梦
西游记
三国演义
墨菲定律变量作用域（LEGB）：
L:local 本地(内部函数)
E:enclosing 嵌套(外部函数)
G:global 全局
B:built-in 系统内置的
第三节：
函数注释问题：
需要注意的是，对自己写的函数进行适当的注释，有助于其他人的阅读理解，并且可能也是以后的工作要求，所以养成代码注释，函数注释的习惯也是相当的重要。
所谓函数注释，是在函数体里写的注释，而且需要按照一定的格式去写，格式的话，可以CTRL+左键，进入系统函数的builtins去参照。
大致格式：
def 函数名(username,password,...)'''函数的说明：参数说明：:param username::param password:返回值说明：:return:'''函数引用：
sys.getrefcount() 获取一块空间地址引用次数
del 可用来删除，且删除后减少了一次引用
使用该函数时，引用次数会默认+1
import syslist1 = [1, 2, 3, 4, 5, 6]
list2 = list1
list3 = list1print(sys.getrefcount(list1))del list3 # 删去list3时，引用次数为3print(sys.getrefcount(list1))
输出：
4
3使用sys.getrefcount函数 ，也是对list1的一次引用，故第一次输出为4次
函数参数引用：
1.函数参数是传递引用，也就是数据的内存地址
2.必须要分清传递的值是可变类型还是不可变类型
可变：函数里面改变，外部全局变量也改变
不可变：函数里面改变，外部不改变
函数嵌套：
nonlocal 在闭包内修改或使用外部函数变量
global 修改或使用全局变量
举例说明：
def outer():a = 100 # 变量def inner(): # 相当于变量b = 200 nonlocal aa += b # 内部函数不能修改外部函数变量，想要修改需要加关键字nonlocalprint('我是内部函数inner', b)result = locals() # locals()表示查看函数中的局部变量print(result)print(a)inner()print(a) # 调用inner后，a的值发生改变outer()
输出：
{'inner': <function outer.<locals>.inner at 0x000001E4A09BA550>, 'a': 100}
100
我是内部函数inner 200
300第一个输出，函数outer()的局部变量，可见inner和a均是，函数也可作为变量
第二个输出为outer()下的a的值
第三个输出调用了inner()的print语句，执行了inner里的内容
第四个，由于执行了inner()，使用nonlocal调用了外部函数的a,并使a=a+b，结果为300
函数闭包：
闭包是函数及其相关的引用环境组合而成的实体：（即 闭包 = 函数快+引用环境）
如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包。
函数闭包需满足以下几点：
1.嵌套函数
2.内部函数引用了外部函数的变量
3.返回值是内部函数
举例说明：
以下情况称为闭包
# 闭包举例 以下情况称作闭包
def outer(n):a = 10def inner():b = a + nprint('内部函数：', b)return inner #返回的是inner的地址r = outer(5) #r接住了inner的地址
print(r)
r() #相当于执行inner输出：
<function outer.<locals>.inner at 0x000001B475CCA4C0>
内部函数： 15装饰器：
装饰器遵循”开放-封闭“原则：对实现功能代码块封闭
对扩展开放
使用装饰器目的：在不改变原函数的前提下增加函数的功能，降低函数冗余性
定义：
def aaa(func):def xxx(*args,**kwargs):......func()......return yyyreturn xxx装饰：
@装饰器名 ----> 原函数 = 装饰(原函数)
def 原函数():pass简单装饰器举例：
#定义装饰器
def decorater(func): #必须有参数def wrapper():# func() #调用func函数，该函数为houseprint('刷漆')print('装修房子')print('------------------>')return wrapper #不加括号为返回函数的地址#使用装饰器
@decorater
def house():print('毛坯房...')house() #此时house地址为wrapper的地址@decorater的底层动作： 变相执行装饰器decorater(func) 把该标识下面的函数house作为decorater的参数，接收装饰器的返回值，等价于 house = decorater (house)，huose接收了wrapper的地址，house称为被装饰函数
装饰器功能：
1.引入日志
2.函数执行时间统计
3.执行函数前预备处理
4.执行函数后清理功能
5.权限校验等场景
6.缓存
原函数带参数时——装饰器：
注意：如果原函数有参数，则装饰器的内部函数也要有参数，两者参数名可不同；
当原函数传入多个参数时，可在装饰器内部使用可变参数 *args 。
举例说明：
当装饰器内部同时使用可变参数 *args和**kwargs，此时为万能装饰器，不受函数参数的限制
#带参数的装饰器
def decorater(func):def weapper(*args,**kwargs): #此时为万能装饰器# args 是一个元组 ('北京五环',1000)func(*args,**kwargs) #利用了 * 拆包print('刷漆')print('装修房子')return weapper@decorater
def house(address):print('房子的地址是：{}，是一个毛坯房......'.format(address))@decorater
def workspace(address,area):print('车间在{}，有{}平米'.format(address,area))house('魏都大厦') #house就是wrapper
workspace('北京五环',1000)
输出：
房子的地址是：魏都大厦，是一个毛坯房......
刷漆
装修房子
车间在北京五环，有1000平米
刷漆
装修房子带返回值的装饰器：
该代码执行顺序为：
1.从@decorater 开始，people作为函数decorater的参数(func=people)，再返回wrapper的地址给people，使其(people和wrapper)地址空间相同。
2.执行 r = people() ，打印people的语句，再进入wrapper，使 r = 785，再依次打印并返回值 785 给全局变量 r
3.最后将 r(785) 打印
def decorater(func):def wrapper(*args,**kwargs):r = func(*args,**kwargs) #是people的返回值，785print('===========================')print('我是钢铁侠')return rreturn wrapper@decorater
def people():print('I am IronMan...')return 785r = people() #people就是wrapper，仅仅赋值也会执行people(wrapper)，执行时相当于将people()内容拼接在wrapper()内容的上面
print(r)
输出：
I am IronMan...
===========================
我是钢铁侠
785多层装饰器：
注意：多层装饰器指原函数被多个装饰器嵌套装饰，若出现该情况，则产生“就近原则”，即谁距离原函数最近则优先使用哪个装饰器。
举例说明：
# 多层装饰器
def decorater1(func):print('第一个装饰器')def wrapper(*args, **kwargs):func()print('第一个wrapper')return wrapperdef decorater2(func):print('第二个装饰器')def wrapper(*args, **kwargs):func()print('第二个wrapper')return wrapper@decorater1
@decorater2
def jsy():print('Hello World !')jsy()输出：
第二个装饰器
第一个装饰器
Hello World !
第二个wrapper
第一个wrapper可以看到，由于“就近原则”，先执行距离函数jsy最近的装饰器decorater2。
装饰器本身有参数时：
注意：
1.带参数的装饰器是三层的
2.最外面的函数负责接收装饰器的参数
3.里面的内容还是原装饰器的内容
4.不要忘了装饰器也要返回
举例说明：
# 装饰器带参数
def outer(a): #第一层：负责接收装饰器参数def decorater(func): #第二层：负责接收函数def wrapper(*args, **kwargs): #第三层：负责接收函数参数func(*args, **kwargs)print('今年{}岁'.format(a))return wrapperreturn decorater #注意装饰器的返回@outer(a=10)
def house(name):print('我的名字是{}'.format(name))house('jsy')输出：
我的名字是jsy
今年10岁嵌套函数，闭包，装饰器之间联系：
一个嵌套函数，外层函数将内层函数返回出来，叫做闭包
一个闭包，往内层函数的参数中传入函数，形成了装饰器
第四节：
递归函数：
递归函数的本质类似于我们俗称的“套娃”，本身较少使用，一般用于文件操作，且递归次数过多会出现报错。
定义：
一个函数在内部不调用其他函数而是有限次调用本身。
1.递归必须设定终点(执行次数有限)
2.递归通常有一个入口(即传入参数)
举例（打印数字1~10）：
# 打印数字 1~10
def test(i):if i == 10:print('10') # 此情况递归结束. 需先考虑递归结束的情况else:print(i)i += 1test(i) # 否则的情况下，调用递归test(1)设参数为1，是从1~10打印输出，控制打印起点；且在不满足 i = 10 的情况下，递增i并且对对函数本身进行递归。
举例（实现1~10的累加）：
# 实现1~10的累加
def test1(i):if i == 10:return 10else:return i + test1(i + 1)r = test1(10)
print(r)举例（斐波那契数列）：
# 斐波那契数列
def fbnq(i): # i为斐波那契数列数字顺序if i > 2:return fbnq(i - 1) + fbnq(i - 2)else:return 1r = fbnq(8)
print(r)打印出斐波那契数列的第8个数值
（21）
匿名函数：
1.用lambda 关键词能创建小型匿名函数
2.省略了用def创建函数的标准步骤，具有简洁性
使用方式：
lambda 参数列表：(返回值)运算表达式
举例说明：
r = lambda a: a + 1 # r是匿名函数的名字
print(r)
print(r(1))输出：
<function <lambda> at 0x00000164F3DDC430>
2第一个输出匿名函数的地址空间
第二个输出匿名函数的返回值
匿名函数作函数的参数：
使用场合：当函数需要作参数时，为了简便性，可以将其定义为匿名函数。
举例说明:
#匿名函数做参数
def jsy(x,y,func): #func是一个函数参数print(x,y)print(func) #打印了匿名函数的地址result = func(x,y) #执行匿名函数并将返回值赋给resultprint('{}+{}={}'.format(x,y,result))jsy(1,2,lambda x,y:x+y) #匿名函数作为jsy函数的第三个参数出现输出：
1 2
<function <lambda> at 0x000001E98906C670>
1+2=3定义匿名函数并传给func，然后在jsy()里调用匿名函数，并返回值给result
匿名函数与内置函数结合使用：
高阶函数：一个函数在另一个函数中作参数使用
一些内置函数：
max:找最大值
min:找最小值
sorted:对列表进行排序 用法：sorted(可迭代式 , 查找的key , reverse是否倒序)
filter类:用来过滤一个列表里符合规定的所以元素，得到结果是一个迭代器(filter对象)
map类:将列表里的每一项数据都进行相同操作，得到的结果是一个迭代器(map对象)
reduce:(不是系统函数)，使用前要导入 from functools import reduce，
### max函数与lambda的结合使用
sorted(iterable, key= None, reverse = False)，第一个参数是可迭代内容，第二个参数为待比较的关键字，也可以是一个函数的返回值(所以使用匿名函数更加便捷)，第三个参数控制是否倒序输出。
#max函数与lambda的结合使用
list1 = [['tom',19],['tony',20],['lily',18],['danniel',22]]
m = max(list1,key=lambda x:x[1])
print(m)输出：
['danniel', 22]由于key值是max函数要进行比较大小的值，故使lambda函数的返回值为第二层列表里的第二个值，并将其指向了key，然后用max函数进行比较。
min,max,sorted的使用均与key有关。
### map与lambda的结合使用
使用map时需注意，map(function,iterable): 第一个参数是函数，第二个参数是可迭代内容
用于遍历列表，对其中元素进行统一操作的。
举例说明：
list1 = [['tom',19],['tony',20],['lily',18],['danniel',22]]
m = map(lambda x:x[0],list1) #map(函数，可迭代式)print(m)
print(list(m)) #将map对象强转为list输出：
<map object at 0x00000178A1284280>
['tom', 'tony', 'lily', 'danniel']第一个输出为map对象的地址空间
第二个输出为 将map强转为list
### filter与lambda的结合使用
注意：filter的匿名函数要求返回值必须是bool类型，只有条件为真才满足过滤要求
filter第一个参数是函数，第二个参数是可迭代式；用于筛选元素
举例：
list1 = [['tom',19],['tony',20],['lily',18],['danniel',22]]
result = filter(lambda x:x[1]>20,list1) #迭代list1中的内容print(result)
print(tuple(result))输出：
<filter object at 0x0000023EDD2448B0>
(['danniel', 22],)像过滤器一样，对list1进行迭代，选择出满足lambda函数里条件的，进行输出
### reduce与lambda的结合使用
reduce有三个参数，第一个为函数，第二个要是序列，第三个是初始值默认为None；可用于对序列的累加，减乘除
from functools import reduce
r = reduce(lambda x,y:x+y,[1,2,3,4,5]) #列表元素累加
print(r)
要先在 functools 里导入 reduce，才能使用。
输出相当于对列表里的元素进行了累加操作。
1,2 --->3
3,3 ---->6
6,4 ----->10
10,5 ----->15 (返回最后结果)
当出现第三个参数时：
list1 = [1]
r = reduce(lambda x, y: x - y, list1, 2)
print(r) # 说明初始化值赋给了x，list1中的唯一元素给了y，使x-y=1输出：
1说明初始化值赋给了x，list1中的唯一元素给了y，使x-y=1
Python之 函数笔记相关推荐
- python shapely函数 笔记
Shapely是一个Python库,用于操作和分析笛卡尔坐标系中的几何对象.https://shapely.readthedocs.io/en/latest/manual.html#empty-fea ...
- python eval 入门_Python学习笔记整理3之输入输出、python eval函数
Python学习笔记整理3之输入输出.python eval函数 来源:中文源码网 浏览: 次 日期:2018年9月2日 Python学习笔记整理3之输入输出.python eval函数 ...
- Python数模笔记-模拟退火算法（1）多变量函数优化
1.模拟退火算法 模拟退火算法借鉴了统计物理学的思想,是一种简单.通用的启发式优化算法,并在理论上具有概率性全局优化性能,因而在科研和工程中得到了广泛的应用. 退火是金属从熔融状态缓慢冷却.最终达到能 ...
- python3for metro_Fluent Python 译本 读书笔记 第5章 一等函数
这是学习<流畅的Python>的第二天,今天希望把这一章看完,之所以跳过第二部分,是因为我对第三部分兴趣更多一些,之后再看第二部分吧.笔记不是对书的重复,只是把我接触到的任何不是特别熟悉的 ...
- python实现函数ifodd_09-Python笔记整理(函数)
函数也是对象 函数的返回值 1.函数的返回值: a.就是函数返回给调用者的值 b.就是return关键字后面的表达式的值 c.就是函数调用表达式的值 python中每个函数都是有返回值的,返回值就是r ...
- python函数参数传递机制_Python 学习笔记（一） 理解Python的函数传参机制
对于刚接触Python不久的新手,Python的函数传参机制往往会让人迷惑.学过C的同学都知道函数参数可以传值或者传地址.比如下面这段代码 点击(此处)折叠或打开 void func(int inpu ...
- python calu_Python学习笔记4：函数
1.函数 函数就是一段具有特点功能的.可重用的语句组. 在Python中函数是以关键词 def 开头,空格之后连接函数名和圆括号(),最后一个冒号:结尾. 函数名只能包含字符串.下划线和数字且不能以数 ...
- python自定义函数复制字符串_Python学习笔记摘要（一）类型 字符串 函数 列表 深浅拷贝...
python中的对象和类型 在python中,认为系统中的每一个"东西"都是一个对象,在python中,"对象"有着特殊的意义,python中的对象有: 一个标 ...
- python函数笔记_python笔记之函数
python中函数定义是使用def进行定义,函数可以理解为 多个语句代码组成,用来实现单一或者相关功能的代码段,在程序中可以重复调用而无需编写重复代码. 1 def add(a,b): #定义一个函数 ...
最新文章
- The resource identified by this request is only capable of generating responses with characteristics
- Android 根据从服务器中获取的rgb值实现动态改变圆角加框的Imageview 的背景色
- 【Python】青少年蓝桥杯_每日一题_9.27_输出最大值最小值平均值
- 一致性协议raft详解（二）：安全性
- 怎么把程序内部坐标转为屏幕坐标_全网最详细CNC加工中心程序代码大全！
- ORA-24324 ORA-24323 ORA-01090
- Spring AMQP + Rabbit 配置多数据源消息队列
- 用户文件夹安全权限设置只能复制即上传不能删除和修改名称和修改数据或写入数据等
- Socket Programming
- 新闻抓取门道全面解析
- 简单聊聊什么是Sass、Pass和Iass?
- 番茄学习--番茄工具推荐
- 社会生活中的十二条著名法则
- 使用tk.mapper和pagehelper一个bug记录：没有为 'PAGE_TABLE_ALIAS' 的列 4 指定任何列名称
- 缓冲区溢出漏洞浅析（三）
- 远程计算机云电脑,教你一招 手机免费变云电脑可以玩PC云游戏
- SQL Server 2008 简体中文正式版下载地址(附序列号)
- vs 没法f12_键盘快捷键 - F12不再适用于Visual Studio
- 项目规划管理 - 4
- GIS文件转化为GMT文件的步骤