精华内容
下载资源
问答
  • python 直接替换列表中的元素4种方法

    万次阅读 多人点赞 2018-12-04 10:27:12
    列表中的元素直接更改、替换。 例子:表面列表aaa中的元素‘黑色’替换成‘黄色’。 aaa=['黑色','红色','白色','黑色'] 第一种方法(不建议): aaa=['黑色','红色','白色','黑色'] aaa=str(aaa) bbb=aaa....

    把列表中的元素直接更改、替换。

    (直接替换、判断替换、替换批量的元素、替换多个元素)

    例子:表面列表aaa中的元素‘黑色’替换成‘黄色’。

    aaa=['黑色','红色','白色','黑色']

     

    第一种方法(不建议):

    aaa=['黑色','红色','白色','黑色']
    aaa=str(aaa)
    bbb=aaa.replace("黑色","黄色")
    bbb
    
    结果:
    "['黄色', '红色', '白色', '黄色']"

    第二种方法:

    aaa=['黑色','红色','白色','黑色']
    bbb=['黄色' if i =='黑色' else i for i in aaa]
    bbb
    
    结果:
    ['黄色', '红色', '白色', '黄色']

    第三种方法:(替换批量的元素)

    aaa=['黑色','红色','白色','黑色']
    ccc=['黑色','红色']
    bbb=['黄色' if i in ccc  else i for i in aaa]
    bbb
    
    结果:
    ['黄色', '黄色', '白色', '黄色']

    第四种方法:(替换多个元素)

    aaa=['黑色','红色','白色','黑色']
    ccc={'黑色':'黄色','红色':'白色'}
    bbb=[ccc[i] if i in ccc else i for i in aaa]
    bbb
    
    结果:
    ['黄色', '白色', '白色', '黄色']

    承接python、R、sql、spss作业代写:数据分析、数据挖掘、数据爬虫、机器学习、模型代跑、算法优化

    https://item.taobao.com/item.htm?spm=a2oq0.12575281.0.0.50111deb9xAUhJ&ft=t&id=634285173072

    展开全文
  • 数据结构基本上就是——它们是可以处理一些 数据 ...假想你有一个购物列表,上面记载着你要买的东西,你就容易理解列表了。只不过在你的购物表上,可能每样东西都独自占有一行, 而在Python中,你在每个项目之间...

    数据结构基本上就是——它们是可以处理一些 数据 的 结构 。或者说,它们是用来存储一组相关数据的。

     

    在Python中有四种内建的数据结构——列表、元组和字典,集合。我们将会学习如何使用它们,以及它们如何使编程变得简单

     

     

     

    一、列表list

     

    是处理一组有序项目的数据结构,即你可以在一个列表中存储一个 序列 的项目。假想你有一个购物列表,上面记载着你要买的东西,你就容易理解列表了。只不过在你的购物表上,可能每样东西都独自占有一行,

     

    而在Python中,你在每个项目之间用逗号分割。列表中的项目应该包括在方括号中,这样Python就知道你是在指明一个列表。

     

    一旦你创建了一个列表,你可以添加、删除或是搜索列表中的项目。由于你可以增加或删除项目,我们说列表是 可变的 数据类型,即这种类型是可以被改变的

    # 购物清单
    shoplist = ['苹果', '芒果', '胡萝卜', '香蕉']

     

    基本操作

    print ('我有', len(shoplist),'个商品在我的购物清单.')
    print ('它们是:'), # 提示
    ​
    for item in shoplist:
        print(item)
    print ('我还买了大米.')
    ​
    shoplist.append('大米')
    print ('现在我的购物清单是', shoplist)
    # ['苹果', '芒果', '胡萝卜', '香蕉','大米']

    基本操作——增

    append 追加

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li.append('大米')
    print(li)
    # ['苹果', '芒果', '胡萝卜', '香蕉','大米']
    ​
    li.append(1)
    # ['苹果', '芒果', '胡萝卜', '香蕉','大米', 1]
    ​
    print(li.append('hello'))   
    #None:无返回值,li.append()只是一个方法、动作
    ​
    print(li)   
    # ['苹果', '芒果', '胡萝卜', '香蕉','大米', 1 , 'hello']

     

    insert 插入

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li.insert(3,'草莓')
    ​
    print(li)   
    # ['苹果', '芒果', '胡萝卜', '草莓', '香蕉']

     

    extend 追加到末尾

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li.extend('cc')
    print(li)
    # ['苹果', '芒果', '胡萝卜', '香蕉', 'c', 'c']
    ​
    li.extend([1,2,3])
    print(li)
    # ['苹果', '芒果', '胡萝卜', '香蕉', 'c', 'c', 123]
    ​
    li.extend(123) #报错:数字不能迭代
    print(li)   
    #TypeError: 'int' object is not iterable

    应用实例:

    连续输入员工姓名,输入Q/q退出并打印列表

    li = []
    while True:
        username = input("请输入要添加的员工姓名:")
        if username.strip().upper() == 'Q':
            break
        li.append(username)
        print(li)
    print(li)

    运行结果:

     

    列表——删

    remove:按照元素删除

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li.remove('芒果')
    print(li)  
    #  ['苹果', '胡萝卜', '香蕉']

    pop:按照索引删除——有返回值

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    name = li.pop(1)  #有返回值
    print(name,li)
    # 芒果 ['苹果', '胡萝卜', '香蕉']
    ​
    name = li.pop()  #不写索引则默认删除最后一个
    print(name,li)
    # 香蕉 ['苹果', '胡萝卜']

     clear: 清空

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li.clear()
    print(li)
    #[]

     

    del:删除

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    del li[2:]
    print(li)
    # ['苹果', '芒果']
    ​
    del li  #删除之后,已经不存在,打印报错
    print(li)
     #NameError: name 'li' is not defined

    循环删除

    li = [11,22,33,44,55]
    for i in range(len(li)):
        print(i)
        del li[0]
        print(li)

     

     

    列表——改

    li[索引] = ‘被修改的内容’

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li[0] = '火龙果'  #将索引为0的位置改为‘火龙果’
    print(li)
    # ['火龙果', '芒果', '胡萝卜', '香蕉']

     

    li[切片] = ‘被修改的内容’(迭代式:分成最小的元素,一个一个添加)

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    li[0:2] = 'abcd' 
    # 将索引0-2替换为abcd,切片之后迭代处理
    ​
    print(li)
    // ['a', 'b', 'c', 'd', '胡萝卜', '香蕉']
    ​
    li[0:3]=['我','喜欢','吃','水果']
    print(li)
    // ['我', '喜欢', '吃', '水果', 'd', '胡萝卜', '香蕉'

     

    列表——查

    从头到尾 :for循环

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    for i in li:
        print(i)

    某一个:索引

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    print(li[1])    #芒果

    一段:切片

    li = ['苹果', '芒果', '胡萝卜', '香蕉']
    print(li[0:2])    #['苹果', '芒果', '胡萝卜']

    列表——嵌套

    li = ['苹果', '芒果', '胡萝卜', ['a','b','c'],'香蕉']
    print(li[2][1]) #萝
    li[3][0].upper() 
    #把列表中第四个元素列表的第一个元素变为大写
    ​
    print(li)
    # ['苹果', '芒果', '胡萝卜', ['a', 'b', 'c'], '香蕉']

    列表——循环打印

    #索引默认从零开始
    li = ['alex','taibai','wusir','egon']
    for i in li:
        print(li.index(i),i)
    
     
    #指定索引从100开始
    for index,i in enumerate(li,100):
        print(index,i)
    
    运行结果:
     

    其他常用操作

    split:字符串转换成列表 str--->list

    s = 'xcsd_cdc_eht_木木'
    print(s.split('_'))  
    // ['xcsd', 'cdc', 'eht', '木木']
    ​
    s1 = 'xc sdc dc eht曾 木木'
    print(s1.split(' '))    
    // ['xc', 'sdc', 'dc', 'eht曾', '木木']

     

    join:列表转换成字符串 list--->str

    join(可迭代对象iterable)   split

    可迭代对象iterable:list,str,元祖

    li = ['xcsd', 'cdc', 'eht', '木木']
    s = ''.join(li)
    print(s)  #xcsdcdceht木木
    s1 = '_'.join(li)
    print(s1)  #xcsd_cdc_eht_木木

    range:顾头不顾尾——相当于有序的数字列表(可以反向,加步长)

    for i in range(2,6):
        print(i)
        
    for i in range(3):   #从0开始,0可省略

    应用实例:

    循环打印,列表里遇到列表也需要循环打印

    li = [1,2,3,5,'alex',[2,3,4,5,'taibai'],'afds']
    for i in li:
        if type(i) == list:
            for n in i:
                print(n)
        else:
            print(i)

    运行结果:

     

    二、元祖

     

    元组和列表十分类似,只不过元组和字符串一样是 不可变的 即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。

    元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候,即被使用的元组的值不会改变

    tu1 = (1)
    tu2 = (1,)
    print(tu1,type(tu1))    #1 <class 'int'>
    print(tu2,type(tu2))    #(1,) <class 'tuple'>
    tu3 = ([1])
    tu4 = ([1],)
    print(tu3,type(tu3))    #[1] <class 'list'>
    print(tu4,type(tu4))    #([1],) <class 'tuple'>

    元组的基本操作

    tu = (1,2,3,'alex','egon')
    print(tu[2])    #3
    print(tu[0:2])  #(1, 2)
    for i in tu:
        print(i)    #循环打印元祖

     

    字典

    字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿,即,我们把键(名字)和值(详细情况)联系在一起。注意,键必须是唯一的,就像如果有两个人恰巧同名的话,你无法找到正确的信息。

    注意,你只能使用不可变的对象(比如字符串)来作为字典的键,但是你可以把不可变或可变的对象作为字典的值。

    基本说来就是,你应该只使用简单的对象作为键。

    键值对在字典中以这样的方式标记:d = {key1 : value1, key2 : value2 }。

    注意它们的键/值对用冒号分割,而各个对用逗号分割,所有这些都包括在花括号中


    dict
        key(键)必须是不可变数据类型,可哈希
        value(值)任意数据类型


    dict 优点:二分查找去查询
        存储大量的关系型数据
    特点:<=3.5版本无序,3.6以后都是有序

     

    1.字典— 增

    dic['键'] = 值

    dic1 = {'age':18,'name':'xc','sex':'female'}
    dic1['height'] = 165
    print(dic1) 
    # 没有键值对,增加
    # {'age': 18, 'name': 'xc', 'sex': 'female', 'height': 165}
    ​
    dic1['age'] = 21
    print(dic1) 
    #有键值对,则修改
    #{'age': 21, 'name': 'xc', 'sex': 'female', 'height': 165}


     

    setdefault 设置默认

    # dic1 = {'age':18,'name':'xc','sex':'female'}
    dic1.setdefault('weight',120)
    print(dic1)     
    # 没有键值对,增加
    # {'age': 18, 'name': 'xc', 'sex': 'female', 'weight': 120}
    ​
    dic1.setdefault('name','aa')
    print(dic1)      
    #有键值对,不做任何操作
    # {'age': 18, 'name': 'xc', 'sex': 'female', 'weight': 120}

    2. 字典—— 删

    删除优先使用pop(有返回值,要删除的内容不存在时不报错),而不是del

    pop 删除

    dic1 = {'age':18,'name':'xc','sex':'female'}
    print(dic1.pop('age'))  
    #有age直接删除---有返回值,按键删除
    ​
    print(dic1)     
    #18   {'name': 'xc', 'sex': 'female'}
    ​
    print(dic1.pop('erge','没有此键/None')) 
     #没有erge----可设置返回值:没有此键/None
     
    print(dic1)     
    #没有此键/None    {'name': 'xc', 'sex': 'female'}

    popitem 随机删除

    dic1 = {'age':18,'name':'xc','sex':'female'}
    print(dic1.popitem())  
    #('sex', 'female')
    #随机删除:有返回值-----返回元祖:删除的键值

     clear 清空

    dic1 = {'age':18,'name':'xc','sex':'female'}
    dic1.clear()    #清空字典
    print(dic1)     #{}

    del 删除

    dic1 = {'age':18,'name':'xc','sex':'female'}
    del dic1['name']   
    # 有,则删除
    # del dic1['name1']  #没有,则报错
    ​
    print(dic1)     
    #{'age': 18, 'sex': 'female'}

     

    3. 字典—— 改 

    update

    dic = {'age':18,'name':'xc','sex':'female'}
    dic2 = {'name':'alex','weight':'168'}
    dic2.update(dic)      
    #有则更新覆盖,没有则增加
    ​
    print(dic)  
    #{'age': 18, 'name': 'xc', 'sex': 'female'}
    ​
    print(dic2) 
    #{'name': 'xc', 'weight': '168', 'age': 18, 'sex': 'female'}

     

    4. 字典——查

    keys,values,items

    dic1 = {'age':18,'name':'xc','sex':'female'}
    ​
    print(dic1.keys(),type(dic1.keys()))    
    #键 dict_keys(['age', 'name', 'sex']) <class 'dict_keys'>
    ​
    print(dic1.values())    
    #值 dict_values([18, 'xc', 'female'])
    ​
    print(dic1.items())     
    #元祖 dict_items([('age', 18), ('name', 'xc'), ('sex', 'female')])

    得到键值,首选get

    print(dic1['name'])      #有则打印
    #print(dic1['name1'])    #没有则报错
    ​
    print(dic1.get('name'))  
    #有name直接输出---有返回值
    ​
    print(dic1.get('name1','没有此键'))  
    #没有name1----可设置返回值:没有此键/None

     

    循环输出

    for i in dic1:
        print(i)    #循环打印键(默认为键)
        
    for i in dic1.keys():
        print(i)    #循环打印键
        
    for i in dic1.values():
        print(i)    #循环打印值
        
    for i in dic1.items():
        print(i)    #循环打印键值对
    ​
    for k,v in dic1.items():
        print(k,v)    #打印键和值

    5. 字典的嵌套

    dic = {    'name':['alex','wusir','xinchen'],
        'py9':{
            'time':'1213',
            'study_fee':19800,
            'addr':'CBD',
        },
        'age':21
    }
    dic['age'] = 56 
    # 找到age,再更新为56
    print(dic)
    ​
    dic['name'].append('rt')    
    #找到name,在添加名字
    print(dic)
    ​
    dic['name'][1] = dic['name'][1].upper() 
    #找到name,再把wusir变为大写
    print(dic)
    ​
    dic['py9']['female'] = 6    
    #找到元祖,增加键值对female:6
    print(dic)

     

    应用实例:

    #输入一串字符,遇到字母,转换为‘_’,并打印输出

    info = input('请输入:')
    for i in info:
        if i.isalpha():
            info = info.replace(i,'_')
    print(info)

      运行结果:

     

    四、集合

    集合 类似于列表,但每个元素都必须是独一无二且不可变的:

    它是无序的

     

    基本操作

    print(set1)     
    #{1, 2, 3}
    ​
    set2 = {1,2,3,[2,3],{'name':'xc'}}  
    #列表是可变的(不可哈希),所以出错
    print(set2)     
    #TypeError: unhashable type: 'list'

    1. 集合——增 

    add

    set1 = {'alex','wusir','ritian','egon','barry'}
    # (1)add    #因为集合是无序的,所以每次运行结果不一定一样,增加的位置也不一定一样
    set1.add('nvshen')  
    #{'ritian', 'nvshen', 'egon', 'wusir', 'alex', 'barry'}
    print(set1)

    update

    set1.update('xc')   
    #迭代添加,依然是无序的
    print(set1) 
    #{'egon', 'x', 'wusir', 'nvshen', 'c', 'alex', 'ritian', 'barry'}

     

     

    2. 集合——删 

    set1 = {'alex','wusir','ritian','egon','barry'}

    pop--随机删除

    print(set1.pop())   
    #egon:有返回值,返回本次删除的内容
    ​
    print(set1)     
    #{'barry', 'alex', 'wusir', 'ritian'}

    remove——指定元素删除

    set1.remove('alex')
    print(set1)    
     #{'egon', 'wusir', 'barry', 'ritian'}
    
    

    clear——清空

    set1.clear()
    print(set1)     
    #空集合:set()

     

    del

    del set1        
    ​
    #删除之后集合不存在,报错
    print(set1)    
     #NameError: name 'set1' is not defined

    3.集合不能改

    集合是无序;

    集合中的元素是不可变数据类型

     

    4. 集合——查

    set1 = {'alex','wusir','ritian','egon','barry'}
    for i in set1:
        print(i)

       运行结果:

     

    5. 集合之间的操作

    set1 = {1,2,3,4,5}
    set2 = {4,5,6,7,8}

    交集

    print(set1 & set2)      
    #(1) {4, 5}
    ​
    print(set1.intersection(set2))      
    #(2) {4, 5}

     

    并集

    print(set1 | set2)          
    #(1) {1, 2, 3, 4, 5, 6, 7, 8}
    ​
    print(set1.union(set2))     
    #(2) {1, 2, 3, 4, 5, 6, 7, 8}
    
    

    反交集--除交集以外的其他元素

    print(set1 ^ set2)          
    #(1) {1, 2, 3, 6, 7, 8}
    ​
    print(set1.symmetric_difference(set2))     
    #(2) {1, 2, 3, 6, 7, 8}

    差集--前者独有的

    print(set1 - set2)              #(1) {1, 2, 3}
    print(set1.difference(set2))     #(2) {1, 2, 3}
    print(set2 - set1)              #(1) {8, 6, 7}
    print(set2.difference(set1))     #(2) {8, 6, 7}

     

    子集与超集

    set3 = {1,2,3,4,5}
    set4 = {1,2,3,4,5,6,7,8}
    print('------ set3是set4的子集 ------')
    print(set3 < set4)      #True
    print(set3.issubset(set4))   #True
    ​
    print('------ set4是set3的超集 ------')
    print(set4 > set3)      #True
    print(set4.issuperset(set3))   #True

     

    五、公共方法

    排序

    正向排序:sort()  

    li = [1,5,4,2,6,7,3]
    li.sort()
    print(li)   #[1, 2, 3, 4, 5, 6, 7]

    倒序排序:li.sort(reverse = True)

    li = [1,5,4,2,6,7,3]
    li.sort(reverse = True)
    print(li)   #[7, 6, 5, 4, 3, 2, 1]

    反转:li.reverse()

    li = [1,5,4,2,6,7,3]
    li.reverse()
    print(li)     #[3, 7, 6, 2, 4, 5, 1]

    补充:

    字符串列表排序——根据字符串的第一个字符对应的ASCII码排序

    li = ['ojhy','asa','cvd','hdk']
    li.sort()
    print(li)   #['asa', 'cvd', 'hdk', 'ojhy']

    count()  数元素出现的次数

    li = ['xcsd', 'cdc', '木木',[1, 5, 2], 'eht', '木木']
    num = li.count('木木')
    ​
    print(num)  #2:'木木'出现2次

    len()  计算列表的长度

    li = ['xcsd', 'cdc', '木木',[1, 5, 2], 'eht', '木木']
    l = len(li)
    print(l)   #6:列表长度为6

    li.index('元素')   查看索引

    li = ['xcsd', 'cdc', '辛辰',[1, 5, 2], 'eht', '辛辰']
    print(li.index('eht'))  
    #4:'eht'的索引为4元祖
    
    

    六. 区别与异同

      列表list 元组  tuple 集合 set  字典 dict
    可否读写  读写  只读 读写  读写
    可否重复
    存储方式

    (不能重复)

    键值对

    (键不能重复)

    是否有序 有序 有序 无序 自动正序
    初始化 [1,'a']  ('a', 1)

     set([1,2])
     或 {1,2}

     {'a':1,'b':2}
    添加   append  只读  add  d['key'] = 'value'
    读元素  l[2:]    t[0]  无    d['a']

     

     

    《python小白入门系列教程》

     

     

     

    IT入门 感谢关注

     

    一学就会 Python入门教程 →

    程序员用的单词表→

    练习地址:www.520mg.com/it

     

     

    展开全文
  • 【python】输出列表元素,以空格/逗号为分隔符

    万次阅读 多人点赞 2017-08-12 19:34:00
    输出列表元素,以空格/逗号为分隔符

    给定list,如何以空格/逗号等符号以分隔符输出呢?

    一般的,简单的for循环可以打印出list的内容:

     

    l=[1,2,3,4]
    for i in l:
        print(i)

    输出结果一行一个元素:

     

    1

    2

    3

    4

    若想得到以空格或逗号为分隔符的输出结果,代码可改为:

     

    l=[1,2,3,4]
    for i in l:
        print(i,end=' ')#以空格为分隔符

     

    输出结果为:1 2 3 4 (注意,此时4后面还有一个空格)

     

    l=[1,2,3,4]
    for i in l:
        print(i,end=', ')#以逗号为分隔符

     

    输出结果为:1,2,3,4, (注意,此时4后面还有一个空格)

     

    那么如何才能在输出最后一个数字之后不输出分隔符呢,http://blog.csdn.net/ericxieforever/article/details/45173103 提供了一个方法:

     

     

    l = [1,2,3,4]  
    print(" ".join(str(i) for i in l)) 

     

    输出结果为:1 2 3 4(注意,此时4后面没有空格啦)

     

    以逗号为分隔符

     

    l = [1,2,3,4]  
    print(",".join(str(i) for i in l)) 

    输出结果为:1,2,3,4(注意,此时4后面没有逗号)

    展开全文
  • FreeRTOS高级篇1---FreeRTOS列表列表

    万次阅读 多人点赞 2016-04-19 14:34:13
    FreeRTOS内核调度大量使用了列表(list)这一数据结构。我们如果想一探FreeRTOS背后的运行机制,首先遇到的拦路虎就是列表。对于FreeRTOS内核来说,列表就是它最基础的部分。我们在这一章集中讲解列表列表项的结构...

          FreeRTOS内核调度大量使用了列表(list)和列表项(list item)数据结构。我们如果想一探FreeRTOS背后的运行机制,首先遇到的拦路虎就是列表和列表项。对于FreeRTOS内核来说,列表就是它最基础的部分。我们在这一章集中讲解列表和列表项的结构以及操作函数,在下一章讲解任务创建时,会用到本章的知识点。

          列表被FreeRTOS调度器使用,用于跟踪任务,处于就绪、挂起、延时的任务,都会被挂接到各自的列表中。用户程序如果有需要,也可以使用列表。

          FreeRTOS列表使用指针指向列表项。一个列表(list)下面可能有很多个列表项(list item),每个列表项都有一个指针指向列表。如图1-1所示。

     

    图1-1:列表与列表项

          列表项有两种形式,全功能版的列表项xLIST_ITEM和迷你版的列表项xMINI_LIST_ITEM。我们来看一下它们具体的定义,先看全功能版。

     

    struct xLIST_ITEM
    {
         listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE           /*用于检测列表项数据是否完整*/
         configLIST_VOLATILE TickType_t xItemValue;           /*列表项值*/
         struct xLIST_ITEM * configLIST_VOLATILE pxNext;      /*指向列表中下一个列表项*/
         struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;  /*指向列表中上一个列表项*/
         void * pvOwner;                                     /*指向一个任务TCB*/
         void * configLIST_VOLATILE pvContainer;             /*指向包含该列表项的列表 */
         listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE          /*用于检测列表项数据是否完整*/
    };
    typedef struct xLIST_ITEM ListItem_t;

     

          宏listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE和listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE用于检查列表项数据是否完整,在projdefs.h中,如果将宏configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES设置为1,则使能列表项数据完整性检查,则宏listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE和listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE会被两个已知的数值代替。

          xItemValue是列表项值,通常是一个被跟踪的任务优先级或是一个调度事件的计数器值。如果任务因为等待从队列取数据而进入阻塞状态,则任务的事件列表项的列表项值保存任务优先级有关信息,状态列表项的列表项值保存阻塞时间有关的信息。这个变量被configLIST_VOLATILE修饰,configLIST_VOLATILE被映射成C语言关键字volatile,表明这个变量是“易变的”,告诉编译器不得对这个变量进行代码优化,因为列表项的成员可能会在中断服务程序中被更新。关于volatile关键字,如果不是熟悉的话,可以参考我的博文《编写优质嵌入式C程序》第3.2.4节。

          pxNext和pxPrevious是列表项类型指针,用来指向列表中下一个和上一个列表项,通过这两个指针,列表项之间可以形成类似双向链表结构。

          指针pvOwner通常指向一个任务TCB。

          指针pvContainer指向包含该列表项的列表。

          迷你版的列表项xMINI_LIST_ITEM是全功能版列表项xLIST_ITEM的一个子集,定义如下所示:

     

    struct xMINI_LIST_ITEM
    {
         listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE           /*用于检测列表项数据是否完整*/
         configLIST_VOLATILE TickType_t xItemValue;
         struct xLIST_ITEM * configLIST_VOLATILE pxNext;
         struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;
    };
    typedef struct xMINI_LIST_ITEM MiniListItem_t;

     

             既然有了全功能版的列表项,为什么还要声明迷你版的列表项呢?这是因为列表结构体需要一个列表项成员,但又不需要列表项中的所有字段,所以才有了迷你版列表项。列表结构体定义为:

     

    typedef struct xLIST
    {
         listFIRST_LIST_INTEGRITY_CHECK_VALUE                        /*用于检测列表项数据是否完整*/
         configLIST_VOLATILE UBaseType_t uxNumberOfItems;
         ListItem_t * configLIST_VOLATILE pxIndex;                   /*用于遍历列表*/
         MiniListItem_t xListEnd;                                    /*列表项*/
         listSECOND_LIST_INTEGRITY_CHECK_VALUE                       /*用于检测列表项数据是否完整*/
    }List_t;

     

          和列表项定义相同,宏listFIRST_LIST_INTEGRITY_CHECK_VALUE和listSECOND_LIST_INTEGRITY_CHECK_VALUE用于检查列表项数据是否完整,在projdefs.h中,如果将宏configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES设置为1,则使能列表项数据完整性检查,则宏listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE和listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE会被两个已知的数值代替。

          uxNumberOfItems表示该列表中挂接的列表项数目,0表示列表为空。

          列表项类型指针用于遍历列表,列表初始化后,这个指针指向&xListEnd。通过宏listGET_OWNER_OF_NEXT_ENTRY()来获取列表中的下一个列表项。

          列表项xListEnd用于标记列表结束。xListEnd.xItemValue被初始化为一个常数,其值与硬件架构相关,为0xFFFF(16位架构)或者0xFFFFFFFF(32位架构)。

          下面我们看一下列表操作。FreeROTS提供了几个API函数,用于初始化列表和列表项以及列表项插入操作。

    1.初始化列表

          列表结构体中包含一个列表项成员,主要用于标记列表结束。初始化列表就是把这个列表项插入到列表中。
    void vListInitialise( List_t * const pxList )
    {
         /*列表索引指向列表项*/
         pxList->pxIndex = ( ListItem_t * )&( pxList->xListEnd );                  
         /* 设置为最大可能值 */
         pxList->xListEnd.xItemValue =portMAX_DELAY;
     
         /* 列表项xListEnd的pxNext和pxPrevious指针指向了它自己 */
         pxList->xListEnd.pxNext = (ListItem_t * ) &( pxList->xListEnd );
         pxList->xListEnd.pxPrevious= ( ListItem_t * ) &( pxList->xListEnd );
         pxList->uxNumberOfItems = ( UBaseType_t) 0U;
     
         /* 设置为已知值,用于检测列表数据是否完整*/
         listSET_LIST_INTEGRITY_CHECK_1_VALUE(pxList );
         listSET_LIST_INTEGRITY_CHECK_2_VALUE(pxList );
    }

          如果宏configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES设置为1,则使能列表项数据完整性检查,则宏listSET_LIST_INTEGRITY_CHECK_1_VALUE()和listSET_LIST_INTEGRITY_CHECK_2_VALUE被一个已知值代替,默认为0x5a5a(16位架构)或者0x5a5a5a5a(32位架构)。

          假设禁止列表数据完整性检查,初始化后的列表如图1-2所示,uxNumberOfItems被初始化为0,xListEnd.xItemValue初始化为0xffffffff,pxIndex、xListEnd.pxNext和xListEnd.pxPrevious初始化为指向列表项xListEnd。

     

    图1-2:初始化后的列表

    2.初始化列表项

          列表项的初始比较简单,只要确保列表项不在任何列表中即可。

     

    void vListInitialiseItem( ListItem_t * const pxItem )
    {
         pxItem->pvContainer = NULL;
     
         /*设置为已知值,用于检测列表项数据是否完整*/
         listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE(pxItem );
         listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE(pxItem );
    }

     

          如果宏configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES设置为1,则使能列表项数据完整性检查,则宏listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE和listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE会被两个已知的数值代替,默认为0x5a5a(16位架构)或者0x5a5a5a5a(32位架构)。

          假设禁止列表项数据完整性检查,初始化后的列表项如图1-3所示。仅是将指针pvContainer设置为空指针,该指针用于指向包含该列表项的列表,这里设置为NULL表示这个列表项不属于任何列表。

     

    图1-3:初始化后的列表项

    3.将列表项插入到列表中,列表项所在的位置取决于列表项的列表项值(xItemValue)。

          每个列表项对象都有一个列表项值(xItemValue),通常是一个被跟踪的任务优先级或是一个调度事件的计数器值。调用API函数vListInsert( List_t * const pxList, ListItem_t * const pxNewListItem)可以将pxNewListItem指向的列表项插入到pxList指向的列表中,列表项在列表的位置由pxNewListItem->xItemValue决定,按照升序排列。

     

    void vListInsert( List_t * const pxList, ListItem_t * const pxNewListItem )
    {
    ListItem_t *pxIterator;
    const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;
     
             /* 检查列表和列表项数据的完整性,仅当configASSERT()定义时有效。*/
             listTEST_LIST_INTEGRITY( pxList );
             listTEST_LIST_ITEM_INTEGRITY(pxNewListItem );
     
             /*将新的列表项插入到列表,根据xItemValue的值升序插入列表。*/
             if( xValueOfInsertion == portMAX_DELAY)
             {
                       pxIterator =pxList->xListEnd.pxPrevious;
             }
             else
             {
                       for( pxIterator = (ListItem_t * ) &( pxList->xListEnd );pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator =pxIterator->pxNext )
                       {
                                /* 这里为空 */
                       }
             }
     
             pxNewListItem->pxNext =pxIterator->pxNext;
             pxNewListItem->pxNext->pxPrevious= pxNewListItem;
             pxNewListItem->pxPrevious =pxIterator;
             pxIterator->pxNext = pxNewListItem;
     
             pxNewListItem->pvContainer = ( void* ) pxList;
     
             ( pxList->uxNumberOfItems )++;
    }

     

          根据xItemValue的值将新的列表项插入到列表。如果列表中存在与新列表项xItemValue值相同的列表项,则新插入的列表项位于它之后。如果列表项的xItemValue值等于portMAX_DELAY(列表结束标记,我们在讲列表数据结构时,说到每个列表数据结构体中都有一个列表项成员xListEnd,用于标记列表结束。xListEnd.xItemValue被初始化为一个常数,其值与硬件架构相关,为0xFFFF或者0xFFFFFFFF。这个常数在移植层定义,即宏portMAX_DELAY),则表示到达了列表结束位置。

          我们用图示的方法来讲解这个函数,我们假设一个列表项值(xItemValue)为32的列表项插入到如图1-2所示的初始化后的列表中,调用vListInsert()函数后,列表和列表项的关系如图1-4所示。列表项xListItem_1的成员指针pxNext和pxPrevious都指向了xListEnd,而xListEnd的成员指针pxNext和pxPrevious都指向了列表项xListItem_1;列表项xListItem_1的成员指针pvContainer指向了列表xList_1;列表成员uxNumberOfItems为1。

     

    图1-4:将列表项插入到列表

          在此基础上,如果再将一个列表项值xItemValue)为40的列表项插入到列表中,调用vListInsert()函数后,列表和列表项的关系如图1-5所示。

     

    图1-5:将列表项插入到列表

     

    4.将列表项插入到列表末端

            第3节讲的API插入函数是根据列表项中的列表项值(xItemValue)来决定插入位置的,本节所讲的API函数vListInsertEnd()是简单的将列表项插入到列表的末端。在下一章任务创建分析的文章中,将会遇到这个API函数,到时再以图标的形式分析这个函数,现在给出这个函数的源码。

     

    void vListInsertEnd( List_t * const pxList, ListItem_t * const pxNewListItem )
    {
    ListItem_t* const pxIndex = pxList->pxIndex;
     
             /*检查列表和列表项数据的完整性,仅当configASSERT()定义时有效。*/
             listTEST_LIST_INTEGRITY( pxList );
             listTEST_LIST_ITEM_INTEGRITY(pxNewListItem );
     
             /*向列表中插入新的列表项*/
             pxNewListItem->pxNext = pxIndex;
             pxNewListItem->pxPrevious =pxIndex->pxPrevious;
     
             mtCOVERAGE_TEST_DELAY();
     
             pxIndex->pxPrevious->pxNext =pxNewListItem;
             pxIndex->pxPrevious = pxNewListItem;
     
             pxNewListItem->pvContainer = ( void* ) pxList;
     
             ( pxList->uxNumberOfItems )++;
    }

     

     

     

     

     

     

    展开全文
  • Python列表和元组的详细区别

    万次阅读 多人点赞 2018-06-06 20:40:06
    Python列表和元组的详细区别 一、列表和元组的区别 二、列表(List) 三、元组(Tuple) Python列表和元组的详细区别 一、列表和元组的区别 列表是动态数组,它们不可变且可以重设长度(改变其内部元素...
  • Python中如何求列表list的平均数

    万次阅读 多人点赞 2019-09-28 10:12:07
    Python中如何求列表list的平均数 当列表list中只包含数字时,如何求取它的平均数: from numpy import * a = [52,69,35,65,89,15,34] b = mean(a) print(b) 运行结果: 51.285714285714285 ...
  • 列表.py

    千次阅读 2019-05-09 19:46:47
    列表
  • Android自定义的下拉列表框控件

    万次阅读 2017-10-20 13:49:40
    Android中的有个原生的下拉列表控件Spinner,但是这个控件有时候不符合我们自己的要求, 比如有时候我们需要类似windows 或者web网页中常见的那种下拉列表控件,类似下图这样的: 这个时候只有自己动手...
  • pyhton列表习题

    万次阅读 2018-08-08 20:13:10
    有一些数存在列表中, 如: L = [1, 3, 2, 1, 6, 4, 2, …., 98, 82] 1) 将列表L中出现的数字存于另一个列表L2中 要求: 重复出现多次的数字只在L2列表中保留一份(去重) 2) 将列表中出现两次的数字存于L3列表中...
  • 1、保存列表为.txt文件 #1/list写入txtipTable = ['158.59.194.213', '18.9.14.13', '58.59.14.21'] fileObject = open('sampleList.txt', 'w') for ip in ipTable: fileObject.write(ip) fileObject....
  • Python-列表学习笔记(完)

    万次阅读 多人点赞 2020-06-06 09:35:03
    列表推导式列表元素的增加列表元素的删除列表元素的访问列表元素出现的次数切片(slice)列表的排序列表元素的查找列表的其他方法列表相关的内置函数 列表 列表:用于存储任意数目、任意类型的数据集合。 列表的...
  • 1.无序列表是一个项目的列表,此列项目使用粗体圆点(典型的小黑圆圈)进行标记。 无序列表始于 <ul 标签。每个列表项始于 <li。 2.无序列表的type属性有三个值 disc:表示实心小圆点 circle:表示空心...
  • 有序列表:数字 + 英文句号 + 空格 + 标题 ##### 有序列表 1. part 1 2. part 2 3. part 3 有序列表 part 1 part 2 part 3 无序列表:*/+/- + 空格 + 标题
  • FreeRTOS列表列表

    千次阅读 2017-09-05 20:39:55
    FreeRTOS 列表列表
  • 1.列表(List)的定义 列表是Python中最基本的数据结构 列表中的每个元素都分配一个位置,一个元素对应一个位置 第一个索引是0,第二个索引是1,依此类推 2.列表的创建 列表里:可以同时储存不同的数据类型 li = [1,...
  • 双滑动列表实现

    千次阅读 多人点赞 2020-07-31 17:13:03
    在项目中,我们经常会使用到列表来展示奖励或者任务,通常我们遇见的都是很简单的单滑动列表,如下案列: 这不,最近有个新功能,需要展示一个进度滑动列表和一个奖励滑动列表,如下案例 首先想到的是将进度条和...
  • 无序列表:给一堆数据添加列表语义, 并且这一堆数据中所有的数据都没有先后之分。 格式:<ul> 需要显示的条目内容</li> </ul> li其实是英文list item的缩写注意:1.一定要记住ul标签是用来给一堆数据添加列表...
  • 【Python学习之路】列表推导式

    万次阅读 2019-12-15 20:56:12
    列表推导式 循环可以用来生成列表: values = [10, 21, 4, 7, 12] squares = [] for x in values: squares.append(x**2) print squares [100, 441, 16, 49, 144] 列表推导式可以使用更简单的方法来创建这个列表:...
  • Python列表模糊匹配列表

    万次阅读 2018-12-06 15:08:49
    B列表模糊匹配A列表 a = ['123','666','355'] b = ['2','5'] for i in range(len(b)): for j in range(len(a)): if a[j].find(b[i]) == -1: continue print(a[j]) 执行结果: ...
  • 有序列表和无序列表之间的区别是:前缀的不同,有序的是有大写字母和小写字母、数字、罗马数字等,而无序列表是实心圆、空心圆、实心正方形。 但是共同点是都有前缀。 而自定义列表与有序无序的区别是没有前缀,...
  • 下拉列表列表标签

    千次阅读 2018-06-14 20:41:51
    下拉菜单和列表标签&lt;option&gt; 下拉菜单和列表项目标签&lt;optgroup&gt; 下拉菜单和列表项目分组标签&lt;textarea&gt; 文字域标签下拉菜单和列表标签语法:&lt;select&...
  • 列表的查找和插入算法

    万次阅读 2018-10-09 14:14:10
    列表查找 散列表查找是一种特殊的查找方法,它能够通过对关键字的值快速定位待查找元素的位置。再查找方面,散列表有着极高的效率。但是一个散列表或多或少会存在冲突,为了解决冲突,我们设计了两个方法,一个是...
  • Python递归求出列表(包括列表中的子列表)中的最大值 要求:求出列表中的所有值的最大数,包括列表中带有子列表的。 按照Python给出的内置函数(max)只能求出列表中的最大值,无法求出包括列表中的子列表的最大...
  • Python列表

    千次阅读 多人点赞 2016-10-16 20:01:48
    # -*- coding:UTF-8 -*-def read_list(): # 创建列表list list = ['physics', 'chemistry', 1997, 2000] print list # 访问列表中的值 print list[1] # 删除列表元素 del list[1] print list # len()
  • Markdown语法之列表

    万次阅读 2018-07-21 15:39:00
    Markdown 语法支持有序列表和无序列表,有序列表由数字 + 英文句号 + 空格 + 列表内容标记,无序列表由星号/加号/减号 + 空格 + 列表内容标记。 有序列表 标记语法: 数字 + 英文句号 + 空格 + 列表...
  • 目标:列表含有子列表展开成一个列表列表的扁平化 如: [['智利', '葡萄牙', '德国']] 转换为 ['智利', '葡萄牙', '德国'] # 代码实现 k1=[['智利', '葡萄牙', '德国']] k2 = sum(k1, []) print(k2) 元素都...
  • 输入一个任意长度的列表,并将列表中的所有元素按顺序输出,每输出一个元素后面加逗号,在输出最后一个元素时,把逗号变为and 例如: 有如下列表: spam = ['a', 'b', 'c', 'd'] 输出格式为: 'a,b,c and d' ...
  • python通关-列表操作方法详解

    万次阅读 多人点赞 2021-01-13 22:54:23
    列表是Python中最基本的数据结构,列表是最常用的Python数据类型,列表是一个数据的集合,集合内可以放任何数据类型,可对集合方便的增删改查操作。Python已经内置确定序列的长度以及确定最大和最小的元素的方法 ...
  • python四种方法实现去除列表中的重复元素

    万次阅读 多人点赞 2017-07-27 15:47:47
    一共使用四种方法来去除列表中的重复元素,下面是具体实现: #!usr/bin/env python #encoding:utf-8 ''''' __Author__:沂水寒城 功能:去除列表中的重复元素 ''' def func1(one_list): ''' 使用集合,个人...
  • 本文主要介绍list(列表)的几种展现形式:普通列表、带箭头列表、带数字角标列表、带图文列表 效果图如下: 1、普通列表:只需要在ul节点上添加.mui-table-view类、在li节点上添加.mui-table-view-cell类即可 2...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 772,922
精华内容 309,168
关键字:

列表