Get unique values from a list in python - Stack Overflow
to customize your list.
Join the Stack Overflow Community
Stack Overflow is a community of 6.5 million programmers, just like you, helping each other.
J it only takes a minute:
I want to get the unique values from the following list:
[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
The output which I require is:
[u'nowplaying', u'PBS', u'job', u'debate', u'thenandnow']
I tried the following code:
output = []
for x in trends:
if x not in output:
output.append(x)
print output
but it didn't work. Any help would be appreciated.
1,40721640
1,30031010
First declare your list properly, separated by commas
You can get the unique values by converting the list to a set
mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
myset = set(mylist)
print myset
If you use it further as a list, you should convert it back to list by doing
mynewlist = list(myset)
Another possibility, probably faster would be to use a set from the beginning, instead of a list. Then your code should be
output = set()
for x in trends:
output.add(x)
print output
As it has been pointed out, the sets do not maintain the original order. If you need so, you should look up about the
To be consistent with the type I would use:
mylist = list(set(mylist))
The exemple you provide do not correspond to lists in Python. This ressemble nested dict, which is probably not what you intended.
A python list:
a = ['a', 'b', 'c', 'd', 'b']
To get unique items, just transform it into a set (which you can transform back again into a list if required):
b = set(a)
&&& set(['a', 'b', 'c', 'd'])
what type is your output variable?
are what you just need. Declare output like this:
output = set([]) # initialize an empty set
and you're ready to go adding elements with output.add(elem) and be sure they're unique.
Warning: sets DO NOT preserve the original order of the list.
5,99222247
set - unordered collection of unique elements. List of elements can be passed to set's constructor. So, pass list with duplicate elements, we get set with unique elements and transform it back to list then get list with unique elements. I can say nothing about performance and memory overhead, but I hope, it's not so important with small lists.
list(set(my_not_unique_list))
Simply and short.
5,22271537
If we need to keep the elements order, how about this:
used = [] #use set() + .add instead of .append if performance matters
mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = [x for x in mylist if x not in used and (used.append(x) or True)]
And one more solution using reduce and without the temporary used var.
mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = reduce(lambda l, x: l.append(x) or l if x not in l else l, mylist, [])
UPDATE - Oct 1, 2016
Another solution with reduce, but this time without .append which makes it more human readable and easier to understand.
mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = reduce(lambda l, x: l+[x] if x not in l else l, mylist, [])
#which can also be writed as:
unique = reduce(lambda l, x: l if x in l else l+[x], mylist, [])
NOTE: Have in mind that more human-readable we get, more unperformant the script is.
import timeit
setup = "mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']"
timeit.timeit('[x for x in mylist if x not in used and (used.append(x) or True)]', setup='used = [];'+setup)
#10x to Michael for pointing out that we can get faster with set()
timeit.timeit('[x for x in mylist if x not in used and (used.add(x) or True)]', setup='used = set();'+setup)
timeit.timeit('reduce(lambda l, x: l.append(x) or l if x not in l else l, mylist, [])', setup=setup)
timeit.timeit('reduce(lambda l, x: l+[x] if x not in l else l, mylist, [])', setup=setup)
timeit.timeit('reduce(lambda l, x: l if x in l else l+[x], mylist, [])', setup=setup)
ANSWERING COMMENTS
Because @monica asked a good question about "how is this working?". For everyone having problems figuring it out. I will try to give a more deep explanation about how this works and what sorcer)
So she first asked:
I try to understand why unique = [used.append(x) for x in mylist if x
not in used] is not working.
Well it's actually working
&&& used = []
&&& mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
&&& unique = [used.append(x) for x in mylist if x not in used]
&&& print used
[u'nowplaying', u'PBS', u'job', u'debate', u'thenandnow']
&&& print unique
[None, None, None, None, None]
The problem is that we are just not getting the desired results inside the unique variable, but only inside the used variable. This is because during the list comprehension .append modifies the used variable and returns None.
So in order to get the results into the unique variable, and still use the same logic with .append(x) if x not in used, we need to move this .append call on the right side of the list comprehension and just return x on the left side.
But if we are too naive and just go with:
&&& unique = [x for x in mylist if x not in used and used.append(x)]
&&& print unique
We will get nothing in return.
Again, this is because the .append method returns None, and it this gives on our logical expression the following look:
x not in used and None
This will basically always:
evaluates to False when x is in used,
evaluates to None when x is not in used.
And in both cases (False/None), this will be treated as falsy value and we will get an empty list as a result.
But why this evaluates to None when x is not in used? Someone may ask.
Well it's because this is how Python's
operators .
The expression x and y if x is false, its value is
otherwise, y is evaluated and the resulting value is
So when x is not in used (i.e. when its True) the next part or the expression will be evaluated (used.append(x)) and its value (None) will be returned.
But that's what we want in order to get the unique elements from a list with duplicates, we want to .append them into a new list only when we they came across for a fist time.
So we really want to evaluate used.append(x) only when x is not in used, maybe if there is a way to turn this None value into a truthy one we will be fine, right?
Well, yes and here is where the 2nd type of short-circuit operators come to play.
The expression x or y if x is true, its value is
otherwise, y is evaluated and the resulting value is
We know that .append(x) will always be falsy, so if we just add one or next to him, we will always get the next part. That's why we write:
x not in used and (used.append(x) or True)
so we can evaluate used.append(x) and get True as a result, only when the first part of the expression (x not in used) is True.
Similar fashion can be seen in the 2nd approach with the reduce method.
(l.append(x) or l) if x not in l else l
#similar as the above, but maybe more readable
#we return l unchanged when x is in l
#we append x to l and return l when x is not in l
l if x in l else (l.append(x) or l)
Append x to l and return that l when x is not in l. Thanks to the or statement .append is evaluated and l is returned after that.
Return l untouched when x is in l
4,18821026
Same order unique list using only a list compression.
& my_list = [1, 2, 1, 3, 2, 4, 3, 5, 4, 3, 2, 3, 1]
& unique_list = [
for i, e in enumerate(my_list)
if my_list.index(e) == i
& unique_list
[1, 2, 3, 4, 5]
enumerates gives the index i and element e as a tuple.
my_list.index returns the first index of e. If the first index isn't i then the current iteration's e is not the first e in the list.
I should note that this isn't a good way to do it, performance-wise. This is just a way that achieves it using only a list compression.
If you are using numpy in your code (which might be a good choice for larger amounts of data), check out numpy.unique:
&&& import numpy as np
&&& wordsList = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
&&& np.unique(wordsList)
array([u'PBS', u'debate', u'job', u'nowplaying', u'thenandnow'],
dtype='&U10')
As you can see, numpy supports not only numeric data, string arrays are also possible. Of course, the result is a numpy array, but it doesn't matter a lot, because it still behaves like a sequence:
&&& for word in np.unique(wordsList):
print word
nowplaying
thenandnow
If you really want to have a vanilla python list back, you can always call list().
However, the result is automatically sorted, as you can see from the above code fragments. Check out
if retaining list order is required.
First thing, the example you gave is not a valid list.
example_list = [u'nowplaying',u'PBS', u'PBS', u'nowplaying', u'job', u'debate',u'thenandnow']
Suppose if above is the example list. Then you can use the following recipe as give the itertools example doc
that can return the unique values and preserving the order as you seem to require. The iterable here is the example_list
from itertools import ifilterfalse
def unique_everseen(iterable, key=None):
"List unique elements, preserving order. Remember all elements ever seen."
# unique_everseen('AAAABBBCCDAABBB') --& A B C D
# unique_everseen('ABBCcAD', str.lower) --& A B C D
seen = set()
seen_add = seen.add
if key is None:
for element in ifilterfalse(seen.__contains__, iterable):
seen_add(element)
yield element
for element in iterable:
k = key(element)
if k not in seen:
seen_add(k)
yield element
23.6k85385
def get_distinct(original_list):
distinct_list = []
for each in original_list:
if each not in distinct_list:
distinct_list.append(each)
return distinct_list
61k1896133
def setlist(lst=[]):
return list(set(lst))
At the begin of your code just declare your output list as empty: output=[]
Instead of your code you may use this code trends=list(set(trends))
As a bonus,
is a simple way to get both the unique values and the count for each value:
from collections import Counter
l = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
c = Counter(l)
6,82333339
To get unique values from your list use code below:
trends = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
output = set(trends)
output = list(output)
IMPORTANT:
Approach above won't work if any of items in a list is not
which is case for
types, for instance
trends = [{'super':u'nowplaying'}, u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
output = set(trends)
Traceback (most recent call last):
File "&stdin&", line 1, in &module&
TypeError: unhashable type: 'dict'
That means that you have to be sure that trends list would always contains only hashable items otherwise you have to use more sophisticated code:
from copy import deepcopy
trends = [{'super':u'nowplaying'}, [u'PBS',], [u'PBS',], u'nowplaying', u'job', u'debate', u'thenandnow', {'super':u'nowplaying'}]
output = set(trends)
output = list(output)
except TypeError:
trends_copy = deepcopy(trends)
while trends_copy:
trend = trends_copy.pop()
if trends_copy.count(trend) == 0:
output.append(trend)
print output
6,82011033
For long arrays
s = np.empty(len(var))
s[:] = np.nan
x_positions = np.where(var==x)
s[x_positions[0][0]]=x
sorted_var=s[~np.isnan(s)]
5,371113553
Set is a collection of ordered and unique elements. So, you can use set as below to get a unique list:
unique_list = list(set([u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']))
My solution to check contents for uniqueness but preserve the original
def getUnique(self):
notunique = self.readLines()
unique = []
for line in notunique: # Loop over content
append = True # Will be set to false if line matches existing line
for existing in unique:
if line == existing: # Line exists ? do not append and go to the next line
append = False
break # Already know file is unique, break loop
if append: unique.append(line) # Line not found? add to list
return unique
Probably can be more efficient by using dictionary keys to check for existence instead of doing a whole file loop for each line, I wouldn't use my solution for large sets.
I know this is an old question, but here's my unique solution: class inheritance!:
class UniqueList(list):
def appendunique(self,item):
if item not in self:
self.append(item)
return True
return False
Then, if you want to uniquely append items to a list you just call appendunique on a UniqueList. Because it inherits from a list, it basically acts like a list, so you can use functions like index() etc. And because it returns true or false, you can find out if appending succeeded (unique item) or failed (already in the list).
To get a unique list of items from a list, use a for loop appending items to a UniqueList (then copy over to the list).
Example usage code:
unique = UniqueList()
for each in [1,2,2,3,3,4]:
if unique.appendunique(each):
print 'Uniquely appended ' + str(each)
print 'Already contains ' + str(each)
Uniquely appended 1
Uniquely appended 2
Already contains 2
Uniquely appended 3
Already contains 3
Uniquely appended 4
Copying to list:
unique = UniqueList()
for each in [1,2,2,3,3,4]:
unique.appendunique(each)
newlist = unique[:]
print newlist
[1, 2, 3, 4]
If you want to get unique elements from a list and keep their original order, then you may employ
data structure from Python's standard library:
from collections import OrderedDict
def keep_unique(elements):
return list(OrderedDict.fromkeys(elements).keys())
elements = [2, 1, 4, 2, 1, 1, 5, 3, 1, 1]
required_output = [2, 1, 4, 5, 3]
assert keep_unique(elements) == required_output
In fact, if you are using Python ≥ 3.6, you can use plain dict for that:
def keep_unique(elements):
return list(dict.fromkeys(elements).keys())
It's become possible after the introduction of "compact" representation of dicts. Check it out . Though this "considered an implementation detail and should not be relied upon".
Use the following function:
def uniquefy_list(input_list):
This function
takes a list as input and return a list containing only unique elements from the input list
output_list=[]
for elm123 in input_list:
in_both_lists=0
for elm234 in output_list:
if elm123 == elm234:
in_both_lists=1
if in_both_lists == 0:
output_list.append(elm123)
return output_list
Try this function, it's similar to your code but it's a dynamic range.
def unique(a):
while k & len(a):
if a[k] in a[k+1:]:
Your Answer
Sign up or
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Post as a guest
By posting your answer, you agree to the
Not the answer you're looking for?
Browse other questions tagged
Stack Overflow works best with JavaScript enabledHibernate uniqueResult方法的使用
以前写代码，总免不了编写登陆部分。在获取user的时候，只可能返回一个user实例，或者为null。以前使用以下方法实现。
public User get(String id){&&
&&& Session session=HibernateUtil.getSessionFactory().openSession();&&
&&& String hql=&from User u where u.id = ?&;&&
&&& List list=session.createQuery(hql).setString(0, id).list();&&
&&& if (list.size()==1){&&
&&&&&&& return (User)list.get(0);&&
&&& }else{&&
public User get(String id){&&
&&& Session session=HibernateUtil.getSessionFactory().openSession();&&
&&& String hql=&from User u where u.id = ?&;&&
&&& List list=session.createQuery(hql).setString(0, id).list();&&
&&& if (list.size()==1){&&
&&&&&&& return (User)list.get(0);&&
&&& }else{&&
&昨天重读hibernate的参考手册，发现query接口提供了一个更好的方法用来获取实例，当返回的实例明确只有一个或者为null的时候。
uniqueResult
public Object uniqueResult()throws HibernateException返回:单个实例或者null抛出:当返回的实例大于一个的时候的抛出NonUniqueResultException对应的使用方法如下:
public User get(String id){&&
Session session=HibernateUtil.getSessionFactory().openSession();&&&&&
String hql=&from User u where u.id=?&;&&&&&
return (User)session.createQuery(hql).setString(0, id).uniqueResult();&
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467142',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'3110人阅读
/rushoooooo/archive//2164623.html
& & & &这几天在做图像处理方面的研究，其中有一部分是关于图像分割方面的，图像目标在分割出来之后要做进一步的处理，因此有必要将目标图像的信息保存在一个变量里面，一开始想到的是数组，但是马上就发现使用数组的缺点：数组长度固定，动态分配内存很容易导致错误发生。最重要的一点是我要保存目标图像的每一点的坐标值，使用数组就有点无能为力了。因此到百度、Google大神上面找思路，终于被我发现在c++的标准库里面还有这么一个模板类：list，下面就是对找到的资料的汇总和加工。
vc6自带的msdn帮助文档的解释
以下是引自msdn帮助文档（中文是我自己翻译的，错误之处请包涵。）：
& & &The template class describes an object that controls a varying-length sequence of elements of type T. The sequence is stored as a bidirectional linked list of elements, each containing a member of type T.
& & 本模板类描述了一个对象，这个对象是类型为T的可变长度的序列元素。这个序列采用双向链表的方式存储每一个元素，其中每一个元素的数据流行都是T。
& & &The object allocates and frees storage for the sequence it controls through a protected object named allocator, of class A. Such an allocator object must have the same external interface as an object of template class allocator. Note that allocatoris not
copied when the object is assigned.
& & &对序列对象的分配和释放操作通过一个受保护的对象allocator进行。这样一个allocator对象必须有相同的外部接口作为一个模板类分配器的对象。注意：当对象被分配之后allocator不能被复制。
& & List reallocation occurs when a member function must insert or erase elements of the controlled sequence. In all such cases, only iterators or references that point at erased portions of the controlled sequence become invalid.
& & 当一个成员要进行insert或者erase操作时，列表的重新分配操作发生。在这种情况下，只有迭代器或者引用所指向的要删除的对象的指针变为无效。
msdn帮助文档自带的例子
下面为msdn帮助文档中自带的一个例子，该例展示了如何使用迭代器读取列表中的元素和进行插入操作。
#include &list&
#include &iostream&
typedef list&int& LISTINT;
void main()
& & int rgTest1[] = {5,6,7};
& & int rgTest2[] = {10,11,12};
& & LISTINT listI
& & LISTINT listA
& & LISTINT::
& & // Insert one at a time
& & listInt.insert (listInt.begin(), 2);
& & listInt.insert (listInt.begin(), 1);
& & listInt.insert (listInt.end(), 3);
& & // 1 2 3
& & for (i = listInt.begin(); i != listInt.end(); ++i)
& & & & cout && *i && & &;
& & cout &&
& & // Insert 3 fours
& & listInt.insert (listInt.end(), 3, 4);
& & // 1 2 3 4 4 4
& & for (i = listInt.begin(); i != listInt.end(); ++i)
& & & & cout && *i && & &;
& & cout &&
& & // Insert an array in there
& & listInt.insert (listInt.end(), rgTest1, rgTest1 + 3);
& & // 1 2 3 4 4 4 5 6 7
& & for (i = listInt.begin(); i != listInt.end(); ++i)
& & & & cout && *i && & &;
& & cout &&
& & // Insert another LISTINT
& & listAnother.insert (listAnother.begin(), rgTest2, rgTest2+3);
& & listInt.insert (listInt.end(), listAnother.begin(), listAnother.end());
& & // 1 2 3 4 4 4 5 6 7 10 11 12
& & for (i = listInt.begin(); i != listInt.end(); ++i)
& & & & cout && *i && & &;
& & cout &&
Program Output is:
1 2 3 4 4 4
1 2 3 4 4 4 5 6 7
1 2 3 4 4 4 5 6 7 10 11 12
list::list模板类的主要函数介绍
assign() &//给list赋值
back() //返回最后一个元素
begin() //返回指向第一个元素的迭代器
clear() //删除所有元素
empty() //如果list是空的则返回true&
end() //返回末尾的迭代器
erase() //删除一个元素
front() //返回第一个元素
get_allocator() //返回list的配置器
insert() //插入一个元素到list中
max_size() //返回list能容纳的最大元素数量
merge() //合并两个list&
pop_back() //删除最后一个元素
pop_front() //删除第一个元素
push_back() //在list的末尾添加一个元素
push_front() //在list的头部添加一个元素
rbegin() //返回指向第一个元素的逆向迭代器
remove_if() //按指定条件删除元素
remove() //从list删除元素
rend() //指向list末尾的逆向迭代器
resize() //改变list的大小
reverse() //把list的元素倒转
size() //返回list中的元素个数
sort() //给list排序
splice() //合并两个list&
swap() //交换两个list&
unique() //删除list中重复的元素
常用的操作主要是有插入操作、删除操作。list为实现头尾高效的插入和删除操作而提供了大多数的支持函数，而对于随机访问函数，则只能从头部或者尾部进行遍历操作。
关于remove和erase函数
上面的介绍中关于插入等等操作都有帮助的例子，但是对于删除函数，这个需要有一些注意的地方。下面请看例子：
#include &iostream&
#include &list&
#include &numeric&
#include &algorithm&
//创建一个list容器的实例LISTINT
typedef list&int& TESTINT;
void main()
& //使用TESTINT创建一个list类型的对象
& //使用TESTINT创建一个迭代器对象
& TESTINT::&
& &//从前面向listOne容器中添加数据
& test.push_front (2);
& test.push_front (1);
& //从后面向listOne容器中添加数据
& test.push_back (3);
& test.push_back (4);
& //显示删除前的数据
& cout&&&before delete&&&
& for (i = test.begin(); i != test.end(); ++i)
&cout && *i && & &;
& //从列表中删除一个元素
& i = test.begin();
& while(i != test.end())
& & int tmp = *i;
& & if(tmp == 2){
test.erase(i++);//在这里要是指针前进1个，否则迭代器失效
& & }else{
i++;
& //显示删除后的数据
& cout&&&after delete&&&
& for (i = test.begin(); i != test.end(); ++i)
& & & & cout && *i && & &;
& & & 在使用list的时候不能使用随机访问的方式，只能按照迭代的方式进行访问，这样的话在进行删除操作的时候就可能会出现某一次删除操作之后指针没有指向下一个有效的元素而导致迭代器失效。因此，在进行删除操作时候最好使用while的方式,使用for循环如果控制不好，可能会导致迭代器失效。
& & &使用模版类可以极大的提高编程的效率，想想之前为了实现每个目标区域像素点的存取操作而使用这个方法都没有很好的解决问题，真后悔没有足够的知识积累，在此记录下来，共勉之。
下面的资料是在学习list模版类中找到的，以下内容均来自互联网。
C++ Lists（链表）
Lists将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢.
assign() 给list赋值
back() 返回最后一个元素
begin() 返回指向第一个元素的迭代器
clear() 删除所有元素
empty() 如果list是空的则返回true&
end() 返回末尾的迭代器
erase() 删除一个元素
front() 返回第一个元素
get_allocator() 返回list的配置器
insert() 插入一个元素到list中
max_size() 返回list能容纳的最大元素数量
merge() 合并两个list&
pop_back() 删除最后一个元素
pop_front() 删除第一个元素
push_back() 在list的末尾添加一个元素
push_front() 在list的头部添加一个元素
rbegin() 返回指向第一个元素的逆向迭代器
remove() 从list删除元素
remove_if() 按指定条件删除元素
rend() 指向list末尾的逆向迭代器
resize() 改变list的大小
reverse() 把list的元素倒转
size() 返回list中的元素个数
sort() 给list排序
splice() 合并两个list&
swap() 交换两个list&
unique() 删除list中重复的元素
附List用法实例：
#include &iostream&
#include &list&
#include &numeric&
#include &algorithm&
//创建一个list容器的实例LISTINT
typedef list&int& LISTINT;
//创建一个list容器的实例LISTCHAR
typedef list&char& LISTCHAR;
void main(void)
& & //--------------------------
& & //用list容器处理整型数据
& & //--------------------------
& & //用LISTINT创建一个名为listOne的list对象
& & LISTINT listO
& & //声明i为迭代器
& & LISTINT::
& & //从前面向listOne容器中添加数据
& & listOne.push_front (2);
& & listOne.push_front (1);
& & //从后面向listOne容器中添加数据
& & listOne.push_back (3);
& & listOne.push_back (4);
& & //从前向后显示listOne中的数据
& & cout&&&listOne.begin()--- listOne.end():&&&
& & for (i = listOne.begin(); i != listOne.end(); ++i)
& & & & cout && *i && & &;
& & cout &&
& & //从后向后显示listOne中的数据
LISTINT::reverse_
& & cout&&&listOne.rbegin()---listOne.rend():&&&
& & for (ir =listOne.rbegin(); ir!=listOne.rend();ir++) {
& & & & cout && *ir && & &;
& & cout &&
& & //使用STL的accumulate(累加)算法
& & int result = accumulate(listOne.begin(), listOne.end(),0);
& & cout&&&Sum=&&&result&&
& & cout&&&------------------&&&
& & //--------------------------
& & //用list容器处理字符型数据
& & //--------------------------
& & //用LISTCHAR创建一个名为listOne的list对象
& & LISTCHAR listT
& & //声明i为迭代器
& & LISTCHAR::
& & //从前面向listTwo容器中添加数据
& & listTwo.push_front ('A');
& & listTwo.push_front ('B');
& & //从后面向listTwo容器中添加数据
& & listTwo.push_back ('x');
& & listTwo.push_back ('y');
& & //从前向后显示listTwo中的数据
& & cout&&&listTwo.begin()---listTwo.end():&&&
& & for (j = listTwo.begin(); j != listTwo.end(); ++j)
& & & & cout && char(*j) && & &;
& & cout &&
& & //使用STL的max_element算法求listTwo中的最大元素并显示
& & j=max_element(listTwo.begin(),listTwo.end());
& & cout && &The maximum element in listTwo is: &&&char(*j)&&
#include &iostream&
#include &list&
typedef list&int& INTLIST;
//从前向后显示list队列的全部元素
void put_list(INTLIST list, char *name)
& & INTLIST::
& & cout && &The contents of & && name && & : &;
& & for(plist = list.begin(); plist != list.end(); plist++)
& & & & cout && *plist && & &;
& & cout&&
//测试list容器的功能
void main(void)
//list1对象初始为空
& & INTLIST list1; &&
& & //list2对象最初有10个值为6的元素
& & INTLIST list2(10,6);&
& & //list3对象最初有3个值为6的元素
& & INTLIST list3(list2.begin(),--list2.end());
& & //声明一个名为i的双向迭代器
& & INTLIST::
& & //从前向后显示各list对象的元素
& & put_list(list1,&list1&);
& & put_list(list2,&list2&);
& & put_list(list3,&list3&);
//从list1序列后面添加两个元素
list1.push_back(2);
list1.push_back(4);
cout&&&list1.push_back(2) and list1.push_back(4):&&&
& & put_list(list1,&list1&);
//从list1序列前面添加两个元素
list1.push_front(5);
list1.push_front(7);
cout&&&list1.push_front(5) and list1.push_front(7):&&&
& & put_list(list1,&list1&);
//在list1序列中间插入数据
list1.insert(++list1.begin(),3,9);
cout&&&list1.insert(list1.begin()+1,3,9):&&&
& & put_list(list1,&list1&);
//测试引用类函数
cout&&&list1.front()=&&&list1.front()&&
cout&&&list1.back()=&&&list1.back()&&
//从list1序列的前后各移去一个元素
list1.pop_front();
list1.pop_back();
cout&&&list1.pop_front() and list1.pop_back():&&&
& & put_list(list1,&list1&);
//清除list1中的第2个元素
list1.erase(++list1.begin());
cout&&&list1.erase(++list1.begin()):&&&
& & put_list(list1,&list1&);
//对list2赋值并显示
list2.assign(8,1);
cout&&&list2.assign(8,1):&&&
& & put_list(list2,&list2&);
//显示序列的状态信息
cout&&&list1.max_size(): &&&list1.max_size()&&
cout&&&list1.size(): &&&list1.size()&&
cout&&&list1.empty(): &&&list1.empty()&&
//list序列容器的运算
& & put_list(list1,&list1&);
& & put_list(list3,&list3&);
cout&&&list1&list3: &&&(list1&list3)&&
cout&&&list1&list3: &&&(list1&list3)&&
//对list1容器排序
list1.sort();
& & put_list(list1,&list1&);
//结合处理
list1.splice(++list1.begin(), list3);
& & put_list(list1,&list1&);
& & put_list(list3,&list3&);&
补充：STL标准函数find进行vector 、list链表查找
#include &vector&
#include &algorithm&
#include &iostream&
class example
example(int val)
bool operator==(example const & rhs)
return (i == rhs.i) ? true :
int main(void)
vector&example&
ve.push_back(1);
vector&example&::
example elem(1);
it = find(ve.begin(), ve.end(), elem);
cout&&boolalpha&&(*it == elem);
C++中的vector使用范例
vector是C++标准模板库中的部分内容，它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector是一个容器，它能够存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，可以动态改变大小。
// c语言风格
int myHouse[100] ;
// 采用vector
vector&int& vecMyHouse(100);
当如上定义后，vecMyHouse就可以存放100个int型的数据了。
1. 它可以像普通数组一样访问
eg: vecMyHouse[50] = 1024;
2. 你可以顺序地向容器中填充数据
eg：int i =0 ;
for( ；i& 25; i++ )
vecMyHouse.push_back(1);
3. 它还可以动态地改变它的大小，通过下面这条语句实现
// 将容器的大小改为400,这样容器中就可以容纳400个int型数据了
eg:vecMyHouse.resize(400);
4. 你也可以在容器中装入自定义的数据类型
// 自定义一个class
class Cmyclass
// 定义一个存放class的容器
vector&Cmyclass& vecMyH
5. 你可以在定义容器时为它赋初值
// 定义一个容纳100个int型数据的容器,初值赋为0
vector&int& vecMyHouse(100,0);
6. 你可以把一个容器的对象赋值给另外一个容器
// 定义一个容纳100个int型数据的容器,初值赋为0
vector&int& vecMyHouse(100,0);
// 定义一个新的容器,内容与上述容器一样
vector&int& myV
myVec = vecMyH
二、 以上是vector容器的简单介绍，下面将详细介绍它的其他功能：
1. 为了使用vector，必须在你的头文件中包含下面的代码：
#include &vector&
2. vector属于std命名域的，因此需要通过命名限定，可以在文件开头加上
using std::
或者直接在使用vector的代码前加前缀
std::vector&int& myH
3. vector提供如下函数或操作：
下面列举了部分常用的功能
// 定义一个vector
std::vector&int&
// 可以使用的功能
c.clear() 移除容器中所有数据。
c.empty() 判断容器是否为空。
c.erase(pos) 删除pos位置的数据
c.erase(beg,end) 删除[beg,end)区间的数据
c.front() 传回第一个数据。
c.insert(pos,elem) 在pos位置插入一个elem拷贝
c.pop_back() 删除最后一个数据。
c.push_back(elem) 在尾部加入一个数据。
c.resize(num) 重新设置该容器的大小
c.size() 回容器中实际数据的个数。
c.begin() 返回指向容器第一个元素的迭代器
c.end() 返回指向容器最后一个元素的迭代器
三、下面描述一下什么是迭代器
迭代器相当于指针，例如：
// 对于变量而言，使用指针指向对应的变量
// 以后就可以使用 * 加指针来操作该变量了
int a = 10;
// 使用指针操作该变量
eg： *p = 11; // 操作后a变为 11
// 对于容器，使用迭代器操作容器中对应位置的值
// 当迭代器指向了容器中的某位置,则可以使用 * 加迭代器操作该位置了
// 定义一个vector
std::vector&int& myV
//添加10个元素
for(int j =0 ; j&10 ; j++)
myVec.push_back(j);
// 定义一个迭代器
std::vector&int&::
// 指向容器的首个元素
p = myVec.begin();
// 移动到下一个元素
p ++;
// 修改该元素赋值
*p = 20 ; //& 则myVec容器中的第二个值被修改为了20
// 循环扫描迭代器,改变所有的值
p = myVec.begin();
for( ; p!= myVec.end(); p++ )
以上简单讲述了vector的用法，仅供入门之用,谢谢。
-------------------------------------------------------------------------------------
1.vector 的数据的存入和输出：
#include&stdio.h&
#include&vector&
#include &iostream&
void main()
int i = 0;
vector&int&
for( i = 0; i & 10; i++ )
v.push_back( i );//把元素一个一个存入到vector中
//对存入的数据清空
for( i = 0; i & v.size(); i++ )//v.size() 表示vector存入元素的个数
cout && v[ i ] && & &; //把每个元素显示出来
//注：你也可以用v.begin()和v.end() 来得到vector开始的和结束的元素地址的指针位置。你也可以这样做：
vector&int&::
for( iter = v.begin(); iter != v.end(); iter++ )
cout && *iter &&
2. 对于二维vector的定义。
1)定义一个10个vector元素，并对每个vector符&#。
#include&stdio.h&
#include&vector&
#include &iostream&
void main()
int i = 0, j = 0;
//定义一个二维的动态数组，有10行，每一行是一个用一个vector存储这一行的数据。
//所以每一行的长度是可以变化的。之所以用到vector&int&(0)是对vector初始化，否则不能对vector存入元素。
vector& vector&int& & Array( 10, vector&int&(0) );
for( j = 0; j & 10; j++ )
for ( i = 0; i & 9; i++ )
Array[ j ].push_back( i );
for( j = 0; j & 10; j++ )
for( i = 0; i & Array[ j ].size(); i++ )
cout && Array[ j ][ i ] && & &;
2)定义一个行列都是变化的数组。
#include&stdio.h&
#include&vector&
#include &iostream&
void main()
int i = 0, j = 0;
vector& vector&int& & A
vector& int &
for( j = 0; j & 10; j++ )
Array.push_back( line );//要对每一个vector初始化，否则不能存入元素。
for ( i = 0; i & 9; i++ )
Array[ j ].push_back( i );
for( j = 0; j & 10; j++ )
for( i = 0; i & Array[ j ].size(); i++ )
cout && Array[ j ][ i ] && & &;
使用 vettor erase 指定元素
#include &iostream&
#include &vector&
int main()
vector&int&
arr.push_back(6);
arr.push_back(8);
arr.push_back(3);
arr.push_back(8);
for(vector&int&::iterator it=arr.begin(); it!=arr.end(); )
if(* it == 8)
it = arr.erase(it);
++
cout && &After remove 8:\n&;
// for(vector&int&::iterator it = arr.begin(); it & arr.end(); ++it)
& & for( it = arr.begin(); it & arr.end(); ++it)
cout && * it && & &;
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：102711次
积分：1083
积分：1083
排名：千里之外
转载：15篇
评论：23条
(1)(2)(3)(1)(7)(8)(13)(1)(1)(1)(1)