Python-04-数据结构
2019-07-24 09:15:30来源：博客园 阅读 ()
一、数字
整数
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。
浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
常用方法：
- int 将字符串转化为数字
#!/usr/bin/env python # -*- coding:utf-8 -*- a = '123' print(type(a), a) a = int(a) print(type(a), a) #输出 <class 'str'> 123 <class 'int'> 123
- bit_length 当前数字的二进制至少用几位表示
#!/usr/bin/env python # -*- coding:utf-8 -*- age = 10 r = age.bit_length() print(r) #输出 4
二、字符串
1. 常用方法
- capitalize 把字符串的第一个字符大写
mystr.capitalize()
- casefold lower 转换 mystr 中所有大写字符为小写 casefold可以识别特殊字符
mystr.lower()
- upper 转换 mystr 中的小写字母为大写
mystr.upper()
- swapcase 大小写切换
mystr.swapcase()
test = 'sFHVahKHJss' v = test.swapcase() print(v) #输出 SfhvAHkhjSS
- center 返回一个原字符串居中,并使用fillchar填充至长度 width 的新字符串
mystr.center(width, fillchar=” ”)
- count 返回str在start和end之间 在 mystr里面出现的次数
mystr.count(str, start=0, end=len(mystr))
- endswith 检查字符串是否以obj结束，如果是返回True,否则返回 False.
mystr.endswith(obj)
- startswith 检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False
mystr.startswith(obj)
- find 检测str是否包含在 mystr中，如果包含返回开始的索引值，否则返回-1
mystr.find(str, start=0, end=len(mystr))
- index 跟find()方法一样，只不过如果str不在 mystr中会报一个异常
mystr.index(str, start=0, end=len(mystr))
- format 字符串格式化
#!/usr/bin/env python
# -*- coding:utf-8 -*-
test = 'my name is {name},age is {age}'
print(test)
mstr = test.format(name='Tom', age=15)
print(mstr)
#输出
my name is {name},age is {age}
my name is Tom,age is 15
# format的三种玩法
res1 = '{} {} {}'.format('egon', 18, 'male')
res2 = '{1} {0} {1}'.format('egon', 18, 'male')
res3 = '{name} {age} {sex}'.format(sex='male', name='egon', age=18)
print(res1)
print(res2)
print(res3)
#输出
egon 18 male
18 egon 18
egon 18 male
- format_map 类似于format，但传入的参数是一个字典
#!/usr/bin/env python
# -*- coding:utf-8 -*-
test = 'my name is {name},age is {age}'
print(test)
mstr = test.format_map({"name":"Tom", "age":"15"})
print(mstr)
#输出
my name is {name},age is {age}
my name is Tom,age is 15
- replace 把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次
mystr.replace(str1, str2, mystr.count(str1))
name = 'alex say :i have one tesla,my name is alex'
print(name.replace('alex', 'SB', 1))
#输出
SB say :i have one tesla,my name is alex
- split 以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串
mystr.split(str=" ", maxsplit)
name = 'root:x:0:0::/root:/bin/bash'
print(name.split(':')) # 默认分隔符为空格
name = 'C:/a/b/c/d.txt' # 只想拿到顶级目录
print(name.split('/', 1))
#输出
['root', 'x', '0', '0', '', '/root', '/bin/bash']
['C:', 'a/b/c/d.txt']
- rsplit 类似split，但从右边开始
- title 把字符串的每个单词首字母大写
mystr.title()
- ljust 返回一个原字符串左对齐,并使用fillchar填充至长度 width 的新字符串
mystr.ljust(width, fillchar=” ”)
- rjust 返回一个原字符串右对齐,并使用fillchar填充至长度 width 的新字符串
mystr.rjust(width, fillchar=” ”)
- zfill 返回指定长度的字符串，原字符串右对齐，前面填充0
mystr.zfill(width)
- lstrip 删除 mystr 左边的空白字符 也可以去除指定的字符
mystr.lstrip()
#!/usr/bin/env python
# -*- encoding:utf-8 -*-
test = 'asdfghh'
v = test.lstrip('8assdf') # 消除所有匹配到的字符
print(v)
#输出
ghh
- rstrip 删除 mystr 右边的空白字符 也可以去除指定的字符
mystr.rstrip()
- strip 删除mystr字符串两端的空白字符 也可以去除指定的字符
mystr.strip()
- rfind 类似于 find()函数，不过是从右边开始查找
mystr.rfind(str, start=0,end=len(mystr) )
- rindex 类似于 index()，不过是从右边开始.
mystr.rindex( str, start=0,end=len(mystr))
- partition 把mystr以str分割成三部分,str前，str和str后
mystr.partition(str)
test = 'ahjsyklsuiyska'
v = test.partition('s')
print(v)
#输出
('ahj', 's', 'yklsuiyska')
- rpartition 类似于 partition()函数,不过是从右边开始.
mystr.rpartition(str）
- splitlines 按照行分隔，返回一个包含各行作为元素的列表
mystr.splitlines()
test = 'ahjsykls\nuiyska\nvjshgk\ndhvgks' v1 = test.splitlines(True) print(v1) v2 = test.splitlines(False) print(v2) #输出 ['ahjsykls\n', 'uiyska\n', 'vjshgk\n', 'dhvgks'] ['ahjsykls', 'uiyska', 'vjshgk', 'dhvgks']
- isupper 判断字符串否全是大写字母
mystr.isupper()
- islower 判断字符串否全是小写字母
mystr.islower()
- isalpha 如果 mystr 所有字符都是字母 则返回 True,否则返回 False
mystr.isalpha()
- isdigit isdecimal isnumeric 如果 mystr 只包含数字则返回 True 否则返回 False。isdigit可以判断一些特殊字符例如②。 isnumeric可以判断中文数字例如二。
mystr.isdigit()
#!/usr/bin/env python # -*- encoding:utf-8 -*- test = '②' v1 = test.isdecimal() v2 = test.isdigit() print(v1, v2) #输出 False True
test = '二' v1 = test.isdecimal() v2 = test.isdigit() v3 = test.isnumeric() print(v1, v2, v3) #输出 False False True
- isalnum 如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
mystr.isalnum()
- isspace 如果 mystr 中只包含空格，则返回 True，否则返回 False
mystr.isspace()
- istitle 如果字符串的每个单词的首字母都是大写，则返回True，否则返回False
mystr.istitle()
- isprintable 判断字符串是否能够被打印
mystr.isprintable()
test = '\n' v = test.isprintable() print(v) #输出 False
- join 将字符串、元组、列表中的元素以mystr连接生成一个新的字符串
mystr.join(str)
mystr = ' ' print(mystr.join(["haha", "hehe", "heihei"])) mystr = '-' print(mystr.join(["haha", "hehe", "heihei"])) # 运行结果： haha hehe heihei haha-hehe-heihei
- expandtabs 方法把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。从头开始数，数到第一个\t正好为8个空格，不足则补空格，如果还有\t，接着从第一个\t数到第二个\t仍然为8个空格，以此类推直到最后一个\t结束。
S.expandtabs([tabsize=8])#!/usr/bin/python3
S = "this is\tstring example....wow!!!"
print ("原始字符串: " + S)
print ("替换 \\t 符号: " + S.expandtabs())
print ("使用16个空格替换 \\t 符号: " + S.expandtabs(16))
"""
以上实例输出结果如下：
原始字符串: this is string example....wow!!!
替换 \t 符号: this is string example....wow!!!
使用16个空格替换 \t 符号: this is string example....wow!!!
"""
#!/usr/bin/env python #-*- encoding:utf-8 -*- S = "username\temail\tpassword\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123\nlaiying\tying@q.com\t123" v = S.expandtabs(20) print(v)
- translate 替换字符串中指定的字符
test = 'ahjsykliuiyjka'
m = str.maketrans('aeiou','12345')
v = test.translate(m)
print(v)
#输出
1hjsykl353yjk1
重点：
1、strip,lstrip,rstrip
2、lower,upper
3、startswith,endswith
4、format的三种玩法
5、split,rsplit
6、join
7、replace
8、isdigit
2. 下标切片
字符串中"下标"的使用
字符串实际上就是字符的数组，所以支持下标索引。
如果有字符串:name = 'abcdef'，在内存中的实际存储如下:
如果想取出部分字符，那么可以通过下标的方法，（注意python中下标从 0 开始）
name = 'abcdef' print(name[0]) print(name[1]) print(name[2]) 运行结果： a b c
切片
切片是指对操作的对象截取其中一部分的操作。
切片的语法：变量名[起始:结束:步长]
注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（包含起始位本身但不包含结束位本身)。结束位可以不写，那么默认按照步长一直到末尾。
如果取出一部分，则可以在中括号[]中
示例1： name = 'abcdef' print(name[0:3]) # 取下标0~2 的字符 运行结果： abc 示例2： name = 'abcdef' print(name[2:]) # 取下标为2开始到最后的字符 运行结果： cdef 示例3： name = 'abcdef' print(name[len(name)-1]) # 取下标为字符长度-1的字符 print(name[-1]) # 取下标为倒数第一个的字符 运行结果： f f 示例4： name = 'abcdef' print(name[1:-1]) # 取第2个到倒数第2个字符切片 print(name[0::2]) # 从第一个字符开始每次步长为2取切片 运行结果： bcde ace 示例5： name = 'abcdef' print(name[-1:-5:-1]) # 逆向取倒数第一个到倒数第4个字符切片 print(name[-1::-1]) # 逆向取倒数第一个到末尾的字符切片 print(name[::-1]) # 倒序字符的切片 运行结果： fedc fedcba fedcba
三、列表
1. 添加元素("增"append, extend, insert)
append：通过append可以向列表添加元素，并且默认添加在列表末尾。
示例：
namesList = ['tom', 'jerry', 'jhon']
print("----添加之前，列表中的元素----")
print(namesList)
print("----添加之后，列表中的元素----")
namesList.append("james")
print(namesList)
运行结果：
----添加之前，列表中的元素----
['tom', 'jerry', 'jhon']
----添加之后，列表中的元素----
['tom', 'jerry', 'jhon', 'james']
extend：通过extend可以将另一个集合中的元素逐一添加到列表中
示例：
print("----使用append添加----")
a = ['a', 'b', 'c']
b = ['1', '2', '3']
a.append(b)
print(a)
print("----使用extend添加----")
a = ['a', 'b', 'c']
b = ['1', '2', '3']
a.extend(b)
print(a)
运行结果：
----使用append添加----
['a', 'b', 'c', ['1', '2', '3']]
----使用extend添加----
['a', 'b', 'c', '1', '2', '3']
insert：insert(index, object) 在指定位置index前插入元素object
示例：
a = ['a', 'b', 'c'] a.insert(1, "haha") print(a) 运行结果： ['a', 'haha', 'b', 'c']
2. 删除元素("删"del, pop, remove,clear)
del：根据下标进行删除
示例：
movieName = ['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
print('------删除之前------')
print(movieName)
print('------删除之后------')
del movieName[2]
print(movieName)
运行结果：
------删除之前------
['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
------删除之后------
['绿巨人', '钢铁侠', '雷神', '洛基']
pop：删除最后一个元素
示例：
movieName = ['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
print('------删除之前------')
print(movieName)
print('------删除之后------')
movieName.pop() # 也可以传入下标作为参数，删除该下标的元素
print(movieName)
运行结果：
------删除之前------
['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
------删除之后------
['绿巨人', '钢铁侠', '超人', '雷神']
remove：根据元素的值进行删除
示例：
movieName = ['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
print('------删除之前------')
print(movieName)
print('------删除之后------')
movieName.remove('超人')
print(movieName)
运行结果：
------删除之前------
['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
------删除之后------
['绿巨人', '钢铁侠', '雷神', '洛基']
clear:清空所有元素
mlist = [1, 2, 3, 4, 5, 6, 7] mlist.clear() print(mlist) 运行结果： []
3. 修改元素("改")
修改元素的时候，要通过下标来确定要修改的是哪个元素，然后对其重新赋值
示例：
movieName = ['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
print('------修改之前------')
print(movieName)
print('------修改之后------')
movieName[2] = '美国队长'
print(movieName)
运行结果：
------修改之前------
['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
------修改之后------
['绿巨人', '钢铁侠', '美国队长', '雷神', '洛基']
4. 查找元素("查"in, not in, index, count)
in, not in
示例：
name_list = ['tom', 'jerry', 'alice', 'james']
print('tom' in name_list)
print('tom' not in name_list)
运行结果：
True
False
index, count
示例：
name_list = ['tom', 'jerry', 'alice', 'james', 'jerry']
print(name_list.index('jerry', 1, 3))
print(name_list.index('jerry', 4, 6))
print(name_list.count('jerry'))
运行结果：
1
4
2
5. 排序(sort, reverse)
- sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
- reverse方法是将list逆置。
示例：
a = [1, 4, 2, 3, 6, 5, 9, 8, 7]
print('----原列表----')
print(a)
print('----reverse----')
a.reverse()
print(a)
print('----sort----')
a.sort()
print(a)
print('----sort(reverse=True)----')
a.sort(reverse=True)
print(a)
运行结果：
----原列表----
[1, 4, 2, 3, 6, 5, 9, 8, 7]
----reverse----
[7, 8, 9, 5, 6, 3, 2, 4, 1]
----sort----
[1, 2, 3, 4, 5, 6, 7, 8, 9]
----sort(reverse=True)----
[9, 8, 7, 6, 5, 4, 3, 2, 1]
四、元组
python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。
tuple = (1, 2, 3, 4)
1. 访问元组
tuple = (1, 2, 3, 4) print(tuple[0]) print(tuple[2]) 运行结果： 1 3
2. 元组的内置函数count, index
tuple = ('tom', 'jerry', 'alice', 'james')
print(tuple.index('alice', 1, 3))
print(tuple.count('jerry'))
运行结果：
2
1
五、字典
字典的创建
person = {"name": "sb", 'age': 18}
或
person = dict(name='sb', age=18)
person = dict({"name": "sb", 'age': 18})
person = dict((['name','sb'],['age',18]))
{}.fromkeys(seq,100) #不指定100默认为None
注意：
>>> dic={}.fromkeys(['k1','k2'],[])
>>> dic
{'k1': [], 'k2': []}
>>> dic['k1'].append(1)
>>> dic
{'k1': [1], 'k2': [1]}
变量info为字典类型：
info = {'name':'孙悟空', 'id':100, 'sex':'男', 'address':'花果山'}
说明：
- 字典和列表一样，也能够存储多个数据
- 列表中找某个元素时，是根据下标进行的。字典中找某个元素时，是根据'名字'（就是冒号:前面的那个值，例如上面代码中的'name'、'id'、'sex'）
- 字典的每个元素由2部分组成，键:值。例如 'name':'孙悟空' ,'name'为键，'孙悟空'为值
1. 根据键访问值
info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print(info['name'])
print(info['address'])
运行结果：
孙悟空
花果山
若访问不存在的键，则会报错：
info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print(info['haha'])
运行结果：
Traceback (most recent call last):
File "X:/xxx/xxx/xxx.py", line 2, in <module>
print(info['haha'])
KeyError: 'haha'
在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：
info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print(info.get('name'))
print(info.get('haha'))
print(info.get('haha', 'haha'))
运行结果：
孙悟空
None
haha
2. 修改元素
字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print('----修改前----')
print(info)
print('----修改后----')
info['name'] = "齐天大圣"
print(info)
运行结果：
----修改前----
{'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
----修改后----
{'name': '齐天大圣', 'id': 100, 'sex': '男', 'address': '花果山'}
3. 添加元素
如果在使用变量名['键'] = 数据时，这个“键”在字典中，不存在，那么就会新增这个元素
info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print('----修改前----')
print(info)
print('----修改后----')
info['age'] = 500
print(info)
运行结果：
----修改前----
{'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
----修改后----
{'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山', 'age': 500}
4. 删除元素
del删除指定的元素
info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print('----删除前----')
print(info)
print('----删除后----')
del info['sex']
print(info)
运行结果：
----删除前----
{'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
----删除后----
{'name': '孙悟空', 'id': 100, 'address': '花果山'}
clear清空整个字典
info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
print('----清空前----')
print(info)
print('----清空后----')
info.clear()
print(info)
运行结果：
----清空前----
{'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
----清空后----
{}
pop删除指定元素，若删除的元素不存在，可以指定返回值
dic = {
'k1': 'v1',
'k2': 'v2'
}
v = dic.pop('k1')
print(dic, v)
# 运行结果
{'k2': 'v2'} v1
dic = {
'k1': 'v1',
'k2': 'v2'
}
v = dic.pop('k111', 1)
print(dic, v)
# 运行结果
{'k1': 'v1', 'k2': 'v2'} 1
5. keys
返回一个包含字典所有KEY的列表
>>> info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
>>> info.keys()
dict_keys(['name', 'id', 'sex', 'address'])
>>>
6. values
返回一个包含字典所有value的列表
>>> info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
>>> info.values()
dict_values(['孙悟空', 100, '男', '花果山'])
>>>
7. items
返回一个包含所有（键，值）元组的列表
>>> info = {'name': '孙悟空', 'address': '花果山'}
>>> info.items()
dict_items([('name', '孙悟空'), ('address', '花果山')])
>>>
8. has_key和in
python3去除了has _key替换为in
如果key在字典中，返回True，否则返回False
>>> info = {'name': '孙悟空', 'address': '花果山'}
>>> 'name' in info
True
>>> 'age' in info
False
>>>
看看python2中的has_key，当然python2中in也可以使用
>>> info = {'name': '孙悟空', 'address': '花果山'}
>>> 'name' in info
True
>>> info.has_key('name')
True
>>> info.has_key('age')
False
>>>
9. update
dic = {
'k1': 'v1',
'k2': 'v2'
}
dic.update({'k1': 123, 'k3': 456})
print(dic)
# 运行结果
{'k1': 123, 'k2': 'v2', 'k3': 456}
10. 字典遍历
info = {'name': '孙悟空', 'address': '花果山'}
print('----遍历字典的key（键）----')
for key in info.keys():
print(key, end='\t')
print()
print('----遍历字典的value（值）----')
for value in info.values():
print(value, end='\t')
print()
print('----遍历字典的项（元素）----')
for item in info.items():
print(item, end='\t')
运行结果：
----遍历字典的key（键）----
name address
----遍历字典的value（值）----
孙悟空 花果山
----遍历字典的项（元素）----
('name', '孙悟空') ('address', '花果山')
六、集合
1. 定义
定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的key
特点：
-
- 不同元素组成
- 无序
- 每个元素必须是不可变类型
2. 集合的创建
{1,2,3,1}
或
定义可变集合set
>>> set_test=set('hello')
>>> set_test
{'l', 'o', 'e', 'h'}
改为不可变集合frozenset
>>> f_set_test=frozenset(set_test)
>>> f_set_test
frozenset({'l', 'e', 'h', 'o'})
3. 常用操作
add 添加元素
s = {1, 2, 3}
s.add(4)
print(s)
运行结果
{1，2，3，4}
pop 随机删除一个元素
s = {'b', 123, 2, 3, 'a'}
s.pop()
print(s)
#运行结果
{3, 'b', 'a', 123}
remove 删除指定元素，删除不存在的元素时会报错
s = {'b', 123, 2, 3, 'a'}
s.remove('a')
print(s)
# 运行结果
{2, 3, 'b', 123}
discard 删除指定元素，删除不存在的元素时不会报错
intersection 或 & 交集
s = {'b', 123, 2, 3, 'a'}
b = {'a', 2, 5, 123}
sb = s.intersection(b)
print(sb)
print(s & b)
# 运行结果
{2, 123, 'a'}
{2, 123, 'a'}
union 或 | 并集
s = {'b', 123, 2, 3, 'a'}
b = {'a', 2, 5, 123}
sb = s.union(b)
print(sb)
print(s | b)
# 运行结果
{2, 3, 'a', 5, 'b', 123}
{2, 3, 'a', 5, 'b', 123}
difference 或 - 差集
s = {'b', 123, 2, 3, 'a'}
b = {'a', 2, 5, 123}
sb = s - b
bs = b - s
print(sb, bs)
# 运行结果
{3, 'b'} {5}
symmetric_difference 或 ^ 交叉补集（两个集合不共有的部分）
s = {'b', 123, 2, 3, 'a'}
b = {'a', 2, 5, 123}
sb = s.symmetric_difference(b)
print(sb)
# 运行结果
{3, 5, 'b'}
difference_update 返回两集合的差集
s = {'b', 123, 2, 3, 'a'}
b = {'a', 2, 5, 123}
s.difference_update(b) # 将两集合的差集返回给s
print(s)
# 运行结果
{3, 'b'}
isdisjoint 如果两集合的交集为空集，返回True
s = {'b', 2, 3, }
b = {'a', 5, 123}
v = s.isdisjoint(b)
print(v)
# 运行结果
True
issubset 如果s1是s2的子集，返回True
s1 = {1, 2}
s2 = {1, 2, 3}
v = s1.issubset(s2)
print(v)
#运行结果
True
issuperset 如果s1包含s2父集，返回True
s1 = {1, 2}
s2 = {1, 2, 3}
v = s1.issuperset(s2)
print(v)
# 运行结果
False
update 更新
s1 = {1, 2}
s2 = {1, 2, 3}
s1.update(s2)
print(s1)
# 运行结果
{1，2，3}
原文链接:https://www.cnblogs.com/lsf123456/p/11132809.html
如有疑问请与原作者联系
标签：
版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有
- Python 数据结构理解分享 2019-07-24
- django修改表数据结构后报错的解决办法 2019-07-24
- python算法与数据结构-二叉树的代码实现(46) 2019-07-24
- python算法与数据结构-数据结构中常用树的介绍(45) 2019-07-24
- python算法与数据结构-栈(43) 2019-07-24
IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设
网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源
网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它
服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护
软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷
网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash
