-
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】输出列表元素,以空格/逗号为分隔符
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后面没有逗号)
-
05-Python—列表、元祖、字典、集合操作大全:建议收藏
2020-08-26 23:12:39数据结构基本上就是——它们是可以处理一些 数据 ...假想你有一个购物列表,上面记载着你要买的东西,你就容易理解列表了。只不过在你的购物表上,可能每样东西都独自占有一行, 而在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入门 感谢关注
练习地址:www.520mg.com/it
-
Python列表和元组的详细区别
2018-06-06 20:40:06Python列表和元组的详细区别 一、列表和元组的区别 二、列表(List) 三、元组(Tuple) Python列表和元组的详细区别 一、列表和元组的区别 列表是动态数组,它们不可变且可以重设长度(改变其内部元素...Python列表和元组的详细区别
一、列表和元组的区别
- 列表是动态数组,它们可变且可以重设长度(改变其内部元素的个数)。
- 元组是静态数组,它们不可变,且其内部数据一旦创建便无法改变。
- 元组缓存于Python运行时环境,这意味着我们每次使用元组时无须访问内核去分配内存。
这些区别结实率两者在设计哲学上的不同:
- 列表可被用于保存多个互相独立对象的数据集合
- 元组用于描述一个不会改不安的事务的多个属性
二、列表(List)
列表一旦创建了我们就可以根据自己的需要随意改变它的内容:
>>> l = [1, 2, 3, 4, 5, 6] >>> l[0] = l[2] * l[3] >>> l [12, 2, 3, 4, 5, 6]
另外我们可以给列边添加新的数据来增加其大小:
>>> len(l) 6 >>> l.append(7) >>> l [12, 2, 3, 4, 5, 6, 7] >>> len(l) 7
这是因为动态数组支持resize操作,可以增加数组的容量。当一个大小为N的列表第一次需要添加数据时,Python会创建一个新的列表,足够放原来的N个元素以及额外添加的元素。不过,实际分配的并不是N+1个元素,而是M个元素,M > N, 这是为了给未来的添加预留空间。然后旧列表的数据被复制到新列表中,旧列表则会被销毁。从设计理念上来说,第一次添加可能是后续多次添加的开始,通过预留空间的做法,我们就可以减少这一分配空间的操作次数以及内存复制的次数。这点非常重要,因为内存复制可能非常的昂贵,特别是当列表大小开始增长以后。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GdQpXs7R-1599024560319)(./image/列表的添加操作.jpg)]
三、元组(Tuple)
元组是固定且不可改变的。这意味着一旦元组被创建,和列表不同,它的内容无法被修改或它的大小也无法被改变。
>>> t = (1, 2, 3, 4) >>> t[0] = 5 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment
虽然它们不支持改变大小,但是我们可以将两个元组合并成一个新元组。这一操作类似列表的resize操作,但我们不需要为新生的元组分配任何额外的空间:
>>> t1 = (1, 2, 3, 4) >>> t2 = (5, 6, 7, 8) >>> t1 + t2 (1, 2, 3, 4, 5, 6, 7, 8)
如果我们将其与列表的append操作比较,我们会看到它的复杂度是O(n)而不是列表的O(1)。这是因为对元组每添加一个新元素都会有分配和复制操作,而不是像列表那样仅在额外的空间耗尽时发生。所以元组并没有提供一个类似append的自增操作,任意两个元组相加始终返回一个新分配的元组。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nIsaGxH8-1599024560321)(./image/元组的合并操作.jpg)]
该网站为Python Tutor,一个能够对python运行内存可视化的网站,非常适合初学者研究,在运行过程中内存发生了什么。
元组的静态特性的另一个好处体现在一些会在Python后台发生的事情:资源缓存。
Python是一门垃圾收集语言,这意味着当一个变量不再被使用时,Python会将该变量使用的内存释放回操作系统,以供其他程序(变量)使用。然而,对于长度为1~20的元组,即使它们不在被使用,它们的空间也不会立刻还给系统,而是留待未来使用。这意味着当未来需要一个同样大小的新的元组时,我们不再需要向操作系统申请一块内存来存放数据,因为我们已经有了预留的空间。
这看上去可能是个细微的好处,但是实际上是元组一个很神奇的地方:它们可以被轻松快速地创建,因为它们可以避免跟操作系统频繁的打交道,而后者会花很长的时间。
下面举个例子会非常直观的说明问题
In [1]: %timeit l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 93.7 ns ± 3.33 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) In [2]: %timeit t = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) 18.5 ns ± 1.19 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
上面的示例中显示了初始化一个列表比初始化一个元组慢了5.1倍——如果这是在一个循环中,这点差别会很快的累加起来。
-
FreeRTOS高级篇1---FreeRTOS列表和列表项
2016-04-19 14:34:13FreeRTOS内核调度大量使用了列表(list)这一数据结构。我们如果想一探FreeRTOS背后的运行机制,首先遇到的拦路虎就是列表。对于FreeRTOS内核来说,列表就是它最基础的部分。我们在这一章集中讲解列表和列表项的结构... -
Python中如何求列表list的平均数
2019-09-28 10:12:07Python中如何求列表list的平均数 当列表list中只包含数字时,如何求取它的平均数: from numpy import * a = [52,69,35,65,89,15,34] b = mean(a) print(b) 运行结果: 51.285714285714285 ... -
Android自定义的下拉列表框控件
2017-10-20 13:49:40Android中的有个原生的下拉列表控件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列表中... -
列表.py
2019-05-09 19:46:47列表 -
python保存列表、字典数据到本地文件
2017-12-22 22:59:221、保存列表为.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)列表的排序列表元素的查找列表的其他方法列表相关的内置函数 列表 列表:用于存储任意数目、任意类型的数据集合。 列表的... -
HTML的无序列表、有序列表、自定义列表
2019-04-24 20:05:031.无序列表是一个项目的列表,此列项目使用粗体圆点(典型的小黑圆圈)进行标记。 无序列表始于 <ul 标签。每个列表项始于 <li。 2.无序列表的type属性有三个值 disc:表示实心小圆点 circle:表示空心... -
Markdown中的有序列表,无序列表和多级列表
2020-02-04 15:34:57有序列表:数字 + 英文句号 + 空格 + 标题 ##### 有序列表 1. part 1 2. part 2 3. part 3 有序列表 part 1 part 2 part 3 无序列表:*/+/- + 空格 + 标题 -
python中列表的定义以及如何创建列表
2019-06-30 10:33:001.列表(List)的定义 列表是Python中最基本的数据结构 列表中的每个元素都分配一个位置,一个元素对应一个位置 第一个索引是0,第二个索引是1,依此类推 2.列表的创建 列表里:可以同时储存不同的数据类型 li = [1,... -
FreeRTOS列表和列表项
2017-09-05 20:39:55FreeRTOS 列表和列表项 -
双滑动列表实现
2020-07-31 17:13:03在项目中,我们经常会使用到列表来展示奖励或者任务,通常我们遇见的都是很简单的单滑动列表,如下案列: 这不,最近有个新功能,需要展示一个进度滑动列表和一个奖励滑动列表,如下案例 首先想到的是将进度条和... -
【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] 列表推导式可以使用更简单的方法来创建这个列表:... -
散列表的查找和插入算法
2018-10-09 14:14:10散列表查找 散列表查找是一种特殊的查找方法,它能够通过对关键字的值快速定位待查找元素的位置。再查找方面,散列表有着极高的效率。但是一个散列表或多或少会存在冲突,为了解决冲突,我们设计了两个方法,一个是... -
列表标签:无序列表、有序列表、定义列表
2017-03-12 13:06:47无序列表:给一堆数据添加列表语义, 并且这一堆数据中所有的数据都没有先后之分。 格式:<ul> 需要显示的条目内容</li> </ul> li其实是英文list item的缩写注意:1.一定要记住ul标签是用来给一堆数据添加列表... -
python四种方法实现去除列表中的重复元素
2017-07-27 15:47:47一共使用四种方法来去除列表中的重复元素,下面是具体实现: #!usr/bin/env python #encoding:utf-8 ''''' __Author__:沂水寒城 功能:去除列表中的重复元素 ''' def func1(one_list): ''' 使用集合,个人... -
Markdown语法之列表
2018-07-21 15:39:00Markdown 语法支持有序列表和无序列表,有序列表由数字 + 英文句号 + 空格 + 列表内容标记,无序列表由星号/加号/减号 + 空格 + 列表内容标记。 有序列表 标记语法: 数字 + 英文句号 + 空格 + 列表... -
Python列表模糊匹配列表
2018-12-06 15:08:49B列表模糊匹配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下拉菜单和列表标签<option> 下拉菜单和列表项目标签<optgroup> 下拉菜单和列表项目分组标签<textarea> 文字域标签下拉菜单和列表标签语法:<select&... -
无序列表、有序列表和自定义列表的区别
2018-08-16 16:30:00有序列表和无序列表之间的区别是:前缀的不同,有序的是有大写字母和小写字母、数字、罗马数字等,而无序列表是实心圆、空心圆、实心正方形。 但是共同点是都有前缀。 而自定义列表与有序无序的区别是没有前缀,... -
【Python】 输入一个列表并将列表中元素按要求输出
2019-09-14 13:50:34输入一个任意长度的列表,并将列表中的所有元素按顺序输出,每输出一个元素后面加逗号,在输出最后一个元素时,把逗号变为and 例如: 有如下列表: spam = ['a', 'b', 'c', 'd'] 输出格式为: 'a,b,c and d' ... -
Python递归求出列表(包括列表中的子列表)的最大值
2018-09-29 15:30:21Python递归求出列表(包括列表中的子列表)中的最大值 要求:求出列表中的所有值的最大数,包括列表中带有子列表的。 按照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() -
【python 列表里的列表】列表的扁平化
2018-10-09 14:36:09目标:列表含有子列表展开成一个列表,列表的扁平化 如: [['智利', '葡萄牙', '德国']] 转换为 ['智利', '葡萄牙', '德国'] # 代码实现 k1=[['智利', '葡萄牙', '德国']] k2 = sum(k1, []) print(k2) 元素都... -
python语法(三)——函数 如何返回多个数组 列表返回值 以及接收方法
2018-06-02 20:38:25我们使用python开发时,自定义的函数 有时候需要返回多个值,可能是多个数值、字符串也有可能是多个列表,那么如何返回;返回之后 在调用该函数时 又应该如何接收呢?例如:我定义了一个函数,传入一个url;解析该... -
Python进阶(一)-初识Python数据元素:列表&元组
2017-03-14 16:19:21Python进阶(一)-初识Python数据元素:列表&元组 毕业论文已完成,下面就是等待盲审结果了。在此期间,已感觉论文无从看起。就学习一下Python吧,听说这是一门很神奇的语言。下面言归正传~ 在线文档查询:点击...
-
微信支付2021系列之扫码支付一学就会java版
-
vc++ 游戏源码贪吃蛇.zip
-
数据类型转换、运算符、方法入门
-
玩转日语思维——汉译日公式.pdf
-
数字信号处理DSP课程设计作业.zip
-
vue+ts项目语法规范
-
2020植物蛋白饮料创新趋势.pdf
-
scala http get请求
-
FPGA基于dds的正弦波发生器与频率计综合设计作业
-
android测量view宽高
-
linux epoll服务器+windows 客户端 socket tcp通信的例子.zip
-
STM32:F407步进电机S形加减速算法的实现
-
MFC开发简单聊天程序
-
C语言-网吧管理系统
-
vue + element + 省市县联动
-
【面试题】连续数列
-
Java项目技术标书范例(适合陪标).docx
-
彻底学会正则表达式
-
Redis的内存模型
-
Microsoft Remote Desktop Beta.app.zip