锐客网

  1. 首页 > 生活百科 > it技术 > >

python中映射函数 python映射类型

字典IT技术

python基础数据结构：序列、映射、集合参考资料：
Python中常见的数据结构可以统称为容器（container） 。序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器 。
一、序列（列表、元组和字符串）
序列中的每个元素都有自己的编号 。Python中有6种内建的序列 。其中列表和元组是最常见的类型 。其他包括字符串、Unicode字符串、buffer对象和xrange对象 。下面重点介绍下列表、元组和字符串 。
1、列表
列表是可变的，这是它区别于字符串和元组的最重要的特点 ， 一句话概括即：列表可以修改，而字符串和元组不能 。
（1）、创建
通过下面的方式即可创建一个列表：
输出：
['hello', 'world']
[1, 2, 3]
可以看到，这中创建方式非常类似于javascript中的数组 。
（2）、list函数
通过list函数（其实list是一种类型而不是函数）对字符串创建列表非常有效：
输出：
['h', 'e', 'l', 'l', 'o']
2、元组
元组与列表一样，也是一种序列，唯一不同的是元组不能被修改（字符串其实也有这种特点） 。
（1） 、创建
输出：
(1, 2, 3) ('jeffreyzhao', 'cnblogs') (1, 2, 3, 4) () (1,)
从上面我们可以分析得出：
a、逗号分隔一些值，元组自动创建完成；
b、元组大部分时候是通过圆括号括起来的；
c、空元组可以用没有包含内容的圆括号来表示；
d、只含一个值的元组 ， 必须加个逗号（,）；
（2）、tuple函数
tuple函数和序列的list函数几乎一样：以一个序列（注意是序列）作为参数并把它转换为元组 。如果参数就算元组 ， 那么该参数就会原样返回：
输出：
(1, 2, 3)
('j', 'e', 'f', 'f')
(1, 2, 3)
Traceback (most recent call last):
File "F:\Python\test.py", line 7, in
t4=tuple(123)
TypeError: 'int' object is not iterable
3、字符串
（1）创建
输出：
Hello world
H
H
e
l
l
o
w
o
r
l
d
（2）、格式化
format（）：
print(‘{0} was {1} years old when he wrote this book’. format(name,age) )
print(‘{} was {} years old when he wrote this book’. format(name,age) )
print(‘{name} was {age} years old when he wrote this book’. format(name=’Lily’,age=’22’) )
#对于浮点数“0.333”保留小数点后三位
print(‘{0 : .3f}’.format(1.0/3) )
结果：0.333
#使用下划线填充文本，并保持文字处于中间位置
#使用^定义‘_____hello_____’字符串长度为11
print(‘{0 : ^_11}’.format(‘hello’) )
结果：_____hello_____
%:
格式化操作符的右操作数可以是任何东西 ， 如果是元组或者映射类型（如字典） ， 那么字符串格式化将会有所不同 。
输出：
Hello,world
Hello,World
注意：如果需要转换的元组作为转换表达式的一部分存在 ， 那么必须将它用圆括号括起来：
输出：
Traceback (most recent call last):
File "F:\Python\test.py", line 2, in
str1='%s,%s' % 'Hello','world'
TypeError: not enough arguments for format string
如果需要输出%这个特殊字符，毫无疑问，我们会想到转义，但是Python中正确的处理方式如下：
输出：100%
对数字进行格式化处理，通常需要控制输出的宽度和精度：
输出：
3.14
3.141593
3.14
字符串格式化还包含很多其他丰富的转换类型，可参考官方文档 。
4、通用序列操作（方法）
从列表、元组以及字符串可以“抽象”出序列的一些公共通用方法（不是你想像中的CRUD），这些操作包括：索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）以及检查某个元素是否属于序列的成员 。除此之外，还有计算序列长度、最大最小元素等内置函数 。
（1）索引
输出
H
2
345
索引从0（从左向右）开始，所有序列可通过这种方式进行索引 。神奇的是，索引可以从最后一个位置（从右向左）开始 ， 编号是-1：
输出：
o
3
123
（2）分片
分片操作用来访问一定范围内的元素 。分片通过冒号相隔的两个索引来实现：
输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4]
[6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[7, 8]
[7, 8, 9]
不同的步长，有不同的输出：
输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 2, 4, 6, 8]
[0, 3, 6, 9]
[]
（3）序列相加
输出：
Hello world
[1, 2, 3, 2, 3, 4]
Traceback (most recent call last):
File "F:\Python\test.py", line 7, in
print str1 num1
TypeError: cannot concatenate 'str' and 'list' objects
（4）乘法
输出：
[None, None, None, None, None, None, None, None, None, None]
HelloHello
[1, 2, 1, 2]
Traceback (most recent call last):
File "F:\Python\test.py", line 5, in
print str1*num1
TypeError: can't multiply sequence by non-int of type 'list'
（5）成员资格
in运算符会用来检查一个对象是否为某个序列（或者其他类型）的成员（即元素）：
输出：
False
True
True
（6）长度、最大最小值
通过内建函数len、max和min可以返回序列中所包含元素的数量、最大和最小元素 。
输出：
5
o
H
5
123
1
二、映射（字典）
映射中的每个元素都有一个名字，如你所知，这个名字专业的名称叫键 。字典（也叫散列表）是Python中唯一内建的映射类型 。
1、键类型
字典的键可以是数字、字符串或者是元组，键必须唯一 。在Python中，数字、字符串和元组都被设计成不可变类型，而常见的列表以及集合（set）都是可变的 ， 所以列表和集合不能作为字典的键 。键可以为任何不可变类型，这正是Python中的字典最强大的地方 。
输出：
{1: 1}
Traceback (most recent call last):
File "F:\Python\test.py", line 6, in
d[list1]="Hello world."
TypeError: unhashable type: 'list'
2、自动添加
即使键在字典中并不存在 ， 也可以为它分配一个值，这样字典就会建立新的项 。
3、成员资格
表达式item in d（d为字典）查找的是键（containskey），而不是值（containsvalue） 。
三、集合
集合（Set）在Python 2.3引入 ， 通常使用较新版Python可直接创建，如下所示：
strs=set(['jeff','wong','cnblogs'])
nums=set(range(10))
看上去 ， 集合就是由序列（或者其他可迭代的对象）构建的 。集合的几个重要特点和方法如下：
1、副本是被忽略的
集合主要用于检查成员资格 ， 因此副本是被忽略的，如下示例所示,输出的集合内容是一样的 。
输出如下：
set([0, 1, 2, 3, 4, 5])
set([0, 1, 2, 3, 4, 5])
2、集合元素的顺序是随意的
这一点和字典非常像，可以简单理解集合为没有value的字典 。
输出如下：
set(['wong', 'cnblogs', 'jeff'])
3、集合常用方法
a、并集union
输出：
set([1, 2, 3])
set([2, 3, 4])
set([1, 2, 3, 4])
union操作返回两个集合的并集，不改变原有集合 。使用按位与（OR）运算符“|”可以得到一样的结果：
输出和上面union操作一模一样的结果 。
其他常见操作包括（交集）,=,=,-,copy()等等，这里不再列举 。
输出如下：
set([1, 2, 3])
set([2, 3, 4])
set([2, 3])
True
set([1, 2, 3])
False
b、add和remove
和序列添加和移除的方法非常类似 ， 可参考官方文档：
输出：
set([1])
set([1, 2])
set([1])
set([1])
False
Traceback (most recent call last):
File "F:\Python\test.py", line 9, in
set1.remove(29) #移除不存在的项
KeyError: 29
4、frozenset
集合是可变的，所以不能用做字典的键 。集合本身只能包含不可变值，所以也就不能包含其他集合：
输出如下：
Traceback (most recent call last):
File "F:\Python\test.py", line 3, in
set1.add(set2)
TypeError: unhashable type: 'set'
可以使用frozenset类型用于代表不可变（可散列）的集合：
输出：
set([1, frozenset([2])])
python有多少内置函数Python内置函数有很多python中映射函数 ， 为大家推荐5个神仙级的内置函数python中映射函数：
(1)Lambda函数
用于创建匿名函数，即没有名称的函数 。它只是一个表达式 ， 函数体比def简单很多 。当我们需要创建一个函数来执行单个操作并且可以在一行中编写时，就可以用到匿名函数python中映射函数了 。
Lamdba的主体是一个表达式，而不是一个代码块 。仅仅能在lambda表达式中封装有限的逻辑进去 。
利用Lamdba函数 ， 往往可以将代码简化许多 。
(2)Map函数
会将一个函数映射到一个输入列表的所有元素上，比如我们先创建了一个函数来返回一个大写的输入单词 ， 然后将此函数应有到列表colors中的所有元素 。
我们还可以使用匿名函数lamdba来配合map函数 ， 这样可以更加精简 。
(3)Reduce函数
当需要对一个列表进行一些计算并返回结果时 ， reduce()是个非常有用的函数 。举个例子，当需要计算一个整数列表所有元素的乘积时，即可使用reduce函数实现 。
它与函数的最大的区别就是，reduce()里的映射函数(function)接收两个参数，而map接收一个参数 。
(4)enumerate函数
用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标 ， 一般用在for循环当中 。
它的两个参数，一个是序列、迭代器或其他支持迭代对象;另一个是下标起始位置，默认情况从0开始，也可以自定义计数器的起始编号 。
(5)Zip函数
用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
当我们使用zip()函数时，如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同 。
python字典操作函数字典是一种通过名字或者关键字引用的得数据结构，其键可以是数字、字符串、元组，这种结构类型也称之为映射 。字典类型是Python中唯一内建的映射类型，基本的操作包括如下：
(1)len()：返回字典中键—值对的数量；
(2)d[k]:返回关键字对于的值；
(3)d[k]=v:将值关联到键值k上；
(4)del d[k]:删除键值为k的项；
(5)key in d:键值key是否在d中，是返回True，否则返回False 。
(6)clear函数：清除字典中的所有项
(7)copy函数：返回一个具有相同键值的新字典；deepcopy()函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题
(8)fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None
(9)get函数：访问字典成员
(10)has_key函数：检查字典中是否含有给出的键
(11)items和iteritems函数:items将所有的字典项以列表方式返回，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表
(12)keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器
(13)pop函数：删除字典中对应的键
(14)popitem函数：移出字典中的项
(15)setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值
(16)update函数：用一个字典更新另外一个字典
(17) values和itervalues函数：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素
一、字典的创建
1.1 直接创建字典
d={'one':1,'two':2,'three':3}
printd
printd['two']
printd['three']
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
1.2 通过dict创建字典
# _*_ coding:utf-8 _*_
items=[('one',1),('two',2),('three',3),('four',4)]
printu'items中的内容:'
printitems
printu'利用dict创建字典，输出字典内容:'
d=dict(items)
printd
printu'查询字典中的内容:'
printd['one']
printd['three']
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
items中的内容:
[('one',1), ('two',2), ('three',3), ('four',4)]
利用dict创建字典，输出字典内容:
{'four':4,'three':3,'two':2,'one':1}
查询字典中的内容:
或者通过关键字创建字典
# _*_ coding:utf-8 _*_
d=dict(one=1,two=2,three=3)
printu'输出字典内容:'
printd
printu'查询字典中的内容:'
printd['one']
printd['three']
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
输出字典内容:
{'three':3,'two':2,'one':1}
查询字典中的内容:
二、字典的格式化字符串
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3,'four':4}
printd
print"three is %(three)s."%d
运算结果：
【python中映射函数 python映射类型】 =======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'four':4,'three':3,'two':2,'one':1}
threeis3.
三、字典方法
3.1 clear函数：清除字典中的所有项
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3,'four':4}
printd
d.clear()
printd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'four':4,'three':3,'two':2,'one':1}
{}
请看下面两个例子
3.1.1
# _*_ coding:utf-8 _*_
d={}
dd=d
d['one']=1
d['two']=2
printdd
d={}
printd
printdd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'two':2,'one':1}
{}
{'two':2,'one':1}
3.1.2
# _*_ coding:utf-8 _*_
d={}
dd=d
d['one']=1
d['two']=2
printdd
d.clear()
printd
printdd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'two':2,'one':1}
{}
{}
3.1.2与3.1.1唯一不同的是在对字典d的清空处理上，3.1.1将d关联到一个新的空字典上 ， 这种方式对字典dd是没有影响的，所以在字典d被置空后 ， 字典dd里面的值仍旧没有变化 。但是在3.1.2中clear方法清空字典d中的内容，clear是一个原地操作的方法，使得d中的内容全部被置空，这样dd所指向的空间也被置空 。
3.2 copy函数：返回一个具有相同键值的新字典
# _*_ coding:utf-8 _*_
x={'one':1,'two':2,'three':3,'test':['a','b','c']}
printu'初始X字典：'
printx
printu'X复制到Y：'
y=x.copy()
printu'Y字典：'
printy
y['three']=33
printu'修改Y中的值 ， 观察输出：'
printy
printx
printu'删除Y中的值，观察输出'
y['test'].remove('c')
printy
printx
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
初始X字典：
{'test': ['a','b','c'],'three':3,'two':2,'one':1}
X复制到Y：
Y字典：
{'test': ['a','b','c'],'one':1,'three':3,'two':2}
修改Y中的值，观察输出：
{'test': ['a','b','c'],'one':1,'three':33,'two':2}
{'test': ['a','b','c'],'three':3,'two':2,'one':1}
删除Y中的值，观察输出
{'test': ['a','b'],'one':1,'three':33,'two':2}
{'test': ['a','b'],'three':3,'two':2,'one':1}
注：在复制的副本中对值进行替换后，对原来的字典不产生影响，但是如果修改了副本，原始的字典也会被修改 。deepcopy函数使用深复制 ， 复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题 。
# _*_ coding:utf-8 _*_
fromcopyimportdeepcopy
x={}
x['test']=['a','b','c','d']
y=x.copy()
z=deepcopy(x)
printu'输出：'
printy
printz
printu'修改后输出：'
x['test'].append('e')
printy
printz
运算输出：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
输出：
{'test': ['a','b','c','d']}
{'test': ['a','b','c','d']}
修改后输出：
{'test': ['a','b','c','d','e']}
{'test': ['a','b','c','d']}
3.3 fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None
# _*_ coding:utf-8 _*_
d=dict.fromkeys(['one','two','three'])
printd
运算输出：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':None,'two':None,'one':None}
或者指定默认的对应值
# _*_ coding:utf-8 _*_
d=dict.fromkeys(['one','two','three'],'unknow')
printd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':'unknow','two':'unknow','one':'unknow'}
3.4 get函数：访问字典成员
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.get('one')
printd.get('four')
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
1
None
注：get函数可以访问字典中不存在的键，当该键不存在是返回None
3.5 has_key函数：检查字典中是否含有给出的键
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.has_key('one')
printd.has_key('four')
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
True
False
3.6 items和iteritems函数:items将所有的字典项以列表方式返回 ， 列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
list=d.items()
forkey,valueinlist:
printkey,':',value
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
three :3
two :2
one :1
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
it=d.iteritems()
fork,vinit:
print"d[%s]="%k,v
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
d[three]=3
d[two]=2
d[one]=1
3.7 keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printu'keys方法：'
list=d.keys()
printlist
printu'\niterkeys方法：'
it=d.iterkeys()
forxinit:
printx
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
keys方法：
['three','two','one']
iterkeys方法：
three
two
one
3.8 pop函数：删除字典中对应的键
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
d.pop('one')
printd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
{'three':3,'two':2}
3.9 popitem函数：移出字典中的项
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
d.popitem()
printd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':1}
{'two':2,'one':1}
3.10 setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值
# _*_ coding:utf-8 _*_
d={'one':1,'two':2,'three':3}
printd
printd.setdefault('one',1)
printd.setdefault('four',4)
printd
运算结果：
{'three':3,'two':2,'one':1}
{'four':4,'three':3,'two':2,'one':1}
3.11 update函数：用一个字典更新另外一个字典
# _*_ coding:utf-8 _*_
d={
'one':123,
'two':2,
'three':3
}
printd
x={'one':1}
d.update(x)
printd
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
{'three':3,'two':2,'one':123}
{'three':3,'two':2,'one':1}
3.12 values和itervalues函数：values以列表的形式返回字典中的值 ， itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素
# _*_ coding:utf-8 _*_
d={
'one':123,
'two':2,
'three':3,
'test':2
}
printd.values()
运算结果：
=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======
[2,3,2,123]
python 中的map（转载）1 map()函数python中映射函数的简介以及语法python中映射函数：
map是python内置函数python中映射函数，会根据提供的函数对指定的序列做映射 。
map()函数的格式是python中映射函数：
map(function,iterable,...)
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合 。
把函数依次作用在list中的每一个元素上，得到一个新的list并返回 。注意，map不改变原list，而是返回一个新list 。
2 map()函数实例：
del square(x):
return x ** 2
map(square,[1,2,3,4,5])---- -要打印结果需要 print(*map(square,[1,2,3,4,5])),这块打印python中映射函数了再打印就会为空
# 结果如下:
[1,4,9,16,25]
通过使用lambda匿名函数的方法使用map()函数：
map(lambda x, y: x y,[1,3,5,7,9],[2,4,6,8,10])
# 结果如下：
[3,7,11,15,19]
通过lambda函数使返回值是一个元组：
map(lambdax, y : (x**y,x y),[2,4,6],[3,2,1])
# 结果如下
[(8,5),(16,6),(6,7)]
当不传入function时，map()就等同于zip()，将多个列表相同位置的元素归并到一个元组：
map(None,[2,4,6],[3,2,1])
# 结果如下
[(2,3),(4,2),(6,1)]
通过map还可以实现类型转换
将元组转换为list：
map(int,(1,2,3))
# 结果如下：
[1,2,3]
将字符串转换为list：
map(int,'1234')
# 结果如下：
[1,2,3,4]
提取字典中的key，并将结果放在一个list中：
map(int,{1:2,2:3,3:4})
# 结果如下
[1,2,3]
原文链接：
python的映射类型有哪些直接访问、序列、映射 。字典是一种映射模式 。类型).字典对象是可变的 。它是一种容器类型，可以存储 。存储任何Python对象，包括其他容器类型 。字典类型和序列类型容器类之间的区别在于数据的存储和访问方式不同 。该序列仅使用数字键(从序列的开头开始计数词序索引) 。Dictionary，一种映射类型，可以使用其他类型作为键，最常用的是字符串作为键 。创建字典:字典条目的语法格式是key: value，多个字典条目包含在{}中 。映射对象用于将哈希表值映射到任意对象 。在python中，有一种映射类型叫做dictionary 。这是可变的 。这本字典的关键字是任意的 。作为值，我们可以使用不同种类的元素，如列表、整数或任何其他可变类型的对象 。与字典相关的一些方法和操作是-方法镜头(d)len()方法返回字典中元素的数量 。操作d [k]它将返回带有键“k”的d项 。如果未映射该键，可能会引发KeyError 。方法迭代(d)这个方法将返回字典键上的迭代器 。我们也可以使用iter(d.keys())来执行这个任务 。方法get(键[，默认值])get()方法将从键中返回值 。第二个参数是可选的 。如果该键不存在，它将返回默认值 。方法项目()它将以(键，值)对格式返回项目 。方法关键字()返回字典中不同键的列表 。方法值()从字典中返回不同值的列表 。方法更新修改字典中的elem元素 。示例代码myDict = {'ten' : 10，' twenty' : 20 ， '三十':30，'四十':40}打印(我的字典)print(list(myDict.keys()))print(list(myDict.values()))#从键值对创建项目print(list(myDict.items()))myDict.update({'fifty' : 50})打印(我的字典)输出结果{ '十':10，'二十':20 ， '三十':30，'四十':40}['十'，'二十'，'三十'，'四十'][10, 20, 30, 40][('十' ， 10)，('二十'，20)，('三十' ， 30) ， ('四十'，40)]{ '十':10，'二十':20，'三十':30，'四十':40，'五十':50}
关于python中映射函数和python映射类型的介绍到此就结束了 ， 不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站 。

    推荐阅读


    上一篇：mysql变更主键 mysql如何更改主键值

    下一篇：传真连接不上 传真机连不上服务器怎么办