python教程：列表(list)、元组(tuple)、字典(dict)

最新推荐文章于 2024-08-27 21:45:00 发布
最新推荐文章于 2024-08-27 21:45:00 发布
阅读量687 收藏
点赞数 1
文章标签： python 编程语言
原文链接：https://www.jianshu.com/u/8f2987e2f9fb
版权
一、列表

1、定义列表，取出列表中的值

names = [] #定义空列表
names = ['a','b','c'] #定义一个非空列表

# 取出列表中的值
>>> names = ['a','b','c']
>>> names[0]
'a'
>>> names[1]
'b'
>>> names[2]
'c'
>>> names[-1]#倒着取最后一个值
'c'

2、切片

>>> names = ['a','b','c','d'] # 列表的下标值是从0开始取值的
>>> names[1:3] #取1到3之间的元素，包括1，不包括3
['b', 'c']
>>> names[1:-1] #取1到-1之间的元素，包括1，不包括-1
['b', 'c']
>>> names[0:3]
['a', 'b', 'c']
>>> names[:3] #从头开始取，0可以省略，效果等同于names[0:3]
['a', 'b', 'c']
>>> names[3:]  #想取到最后一个值，必须不能写-1，只能这么写
['d']
>>> names[0::2] #后面的2表示：每隔一个元素就取一个
['a', 'c']
>>> names[::2] #从头开始0可以省略，效果跟上一句一样
['a', 'c']

切片小结：

①序列始终都是从左向右切片的，不能是从右向左

①列表切片时，起始位的元素是包括的，结束位的元素是不包括（又叫顾头不顾尾），最后一个位置表示步长（names[开始位:结束位:步长]）

②如果从0位置取值，0可以省略

③想取最后一个值时，结束位不能是-1，因为结束位的元素不包括，所以只能留空

3、列表函数&方法

函数：

序号函数
1cmp(list1, list2) #比较两个列表的元素
2len(list) #列表元素个数
3max(list) #返回列表元素最大值
4min(list) #返回列表元素最小值
5list(seq) #将元组转换为列表

方法：

序号方法
1list.append(obj)　　#在列表末尾添加新的对象
2list.count(obj)　　#统计某个元素在列表中出现的次数
3list.extend(seq)　　#在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4list.index(obj)　　#从列表中找出某个值第一个匹配项的索引位置
5list.insert(index, obj)　　#将对象插入列表
6list.pop([index=-1])　　#移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7list.remove(obj)　　#移除列表中某个值的第一个匹配项
8list.reverse()　　#反向列表中元素
9list.sort([func])　　#对原列表进行排序
10list.clear()　　#清空列表
11list.copy()　　#复制列表

演示：

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
 # append 列表末尾添加新的对象
 >>>    names = ['a','b','c','d']
 >>>    names.append('e')
 >>>    print(names)
 ['a', 'b', 'c', 'd', 'e']#e是新加的元素
 
 #统计（count(元素)）
 >>> names = ['a','b','c','d','a']
 >>> print(names.count('a')) #统计'a'元素的个数
 2
 
 #扩展（extend）names2的列表合并到names1中，但是，names2这个列表依然存在，如果想删除names2这个变量，则只需del names2即可
 >>> names1 = ['a','b','c','d']
 >>> names2 = [1,2,3,4]
 >>> names1.extend(names2)
 >>> print(names1)
 ['a', 'b', 'c', 'd', 1, 2, 3, 4]
 
 # insert(下标值，插入的内容) 
 >>> names = ['a','b','c','d']
 >>> names.insert(0,'1') #0表示需要插入的下标值，'1'表示插入的内容
 >>> print(names)
 ['1', 'a', 'b', 'c', 'd'] #在下标值为0的地方插入'1'
 
 #翻转（reverse()）
 >>> names = ['a','b','c','d']
 >>> names.reverse()
 >>> print(names)
 ['d', 'c', 'b', 'a']  #将整个列表翻转过来
 
 #排序（sort()）
 >>> names = [4,2,3,1]
 >>> names.sort()
 >>> print(names)
 [1, 2, 3, 4]
 
 #清空列表（clear()）
 >>> names = ['a','b','c','d']
 >>> names.clear()
 >>> print(names)
 []
 
 #复制(copy())
 >>> names1 = ['a','b','c','d']
 >>> names2 = names1.copy()
 >>> print(names2)
 ['a', 'b', 'c', 'd']

删除（del、remove(元素)、pop()）

 #根据下标值删除元素
 >>> names = ['a','b','c','d']
 >>> del names[0] 
 >>> print(names)
 ['b', 'c', 'd']
 
 #根据元素删除
 >>> names = ['a','b','c','d']
 >>> names.remove('a')
 >>> print(names)
 ['b', 'c', 'd']
 
 #删除最后一个
 >>> names = ['a','b','c','d']
 >>> names.pop()
 'd'
 >>> print(names)
 ['a', 'b', 'c']
 
 #pop返回从列表中移除的元素对象
 >>> names = ['a','b','c','d']
 >>> names_pop=names.pop(-1)
 >>> print(names_pop)
 d
二、元组

元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表

元组使用小括号，列表使用方括号

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可

用途：一般情况下用于自己写的程序能存下数据，但是又希望这些数据不会被改变，比如：数据库连接信息等

1.访问元祖

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
>>> name = ('a','b','c','d')
#下标值跟列表一样，也是从0开始
>>> print(name[0])
'a'
>>> print(name[1])
'b'
#访问最后一个元素
>>> print(name[-1])
'd'

2，count（统计） 与 index（索引）

# count 统计元素数量
>>> name = ('a','b','c','a')
>>> print(name.count('a'))
2

# index 查看元素下标
>>> name = ('a','b','c','a')
>>> print(name.index('b'))
1

3、修改元组 删除元祖

#元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
>>> tup1 = (12, 34.56);
>>> tup2 = ('abc', 'xyz')

# 以下修改元组元素操作是非法的。
# tup1[0] = 100

# 创建一个新的元组
>>> tup3 = tup1 + tup2;
>>> print (tup3)
(12, 34.56, 'abc', 'xyz')



#元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
>>> tup = ('Google', 'Runoob', 1997, 2000)

>>> print (tup)
>>> del tup;
>>> print ("删除后的元组 tup : ")
>>> print (tup)

#以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
Traceback (most recent call last):
    print (tup) # NameError: name 'tup' is not defined
NameError: name 'tup' is not defined
('Google', 'Runoob', 1997, 2000)
删除后的元组 tup :

小结：

①元组中的数据不可以被修改，不可以被添加，不可以被删除(当然除非是元组中嵌套列表或者字典，列表和字典中的值是可以被更改的）

②元组的获取元素的方式和列表一样，都是通过下标值访问，下标值都是从0开始

③由于元组只能读，不能写，所以元组只有count和index两个方法

④元组的切片功能和列表一样

4、元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式结果描述
len((1, 2, 3))3计算元素个数
(1, 2, 3) + (4, 5, 6)(1, 2, 3, 4, 5, 6)连接
(‘Hi!’,) * 4(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)复制
3 in (1, 2, 3)True元素是否存在
for x in (1, 2, 3): print x1 2 3迭代

5、元祖内置函数

序号方法
1len(tuple)　　#计算元组元素个数
2max(tuple)　　#返回元组中元素最大值
3min(tuple)　　#返回元组中元素最小值
4tuple(seq)　　#将列表转换为元组
三、字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }

1、特征：

字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行

  1. 字典是无序的；

  2. 字典的key是唯一的,不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

 >>> dict = {'Name': 'QQ', 'Age': 7, 'Name': 'DD'}
 >>> print ("dict['Name']: ", dict['Name'])
 dict['Name']:  DD
  1. 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例:
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
>>> dict = {['Name']: 'Runoob', 'Age': 7}
>>> print ("dict['Name']: ", dict['Name'])

#错误如下
Traceback (most recent call last):
    dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'

2、基本用法：增加、查看、修改、删除

  1. 增加
>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
#新增
>>> stu_info["wanger"] = 30
#输出结果
>>> print(stu_info)
{'zhangsan': 23, 'lisi': 18, 'qigao': 18, 'wanger': 30}
  1. 查看

通过key查找value

>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
#存在key返回value
>>> print(stu_info["qigao"])
18

#不存在key提示报错
>>> print(stu_info["wanger"])
Traceback (most recent call last):
    print(stu_info["wanger"])
KeyError: 'wanger'

通过get(key) 查找value

>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
#存在则返回对应的value
>>> print(stu_info.get("qigao"))
18

#不存在返回None
>>> print(stu_info.get("wanger"))
None

注：get(k)不存在key值，则返回None，通过key直接访问会报错，所以建议推荐用get(k)这个方法获取value

通过key in 字典判断 key是否存在与字典中

 >>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
 >>> print("qigao"  in stu_info ) #标准用法,在Python3和Python2.7都可以用
 True
  1. 修改
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
#修改'qigao'对应的value值，由18改为23
>>> stu_info["qigao"] = 23
#输出
>>> print(stu_info)
{'wanger': 30, 'lisi': 18, 'zhangsan': 23, 'qigao': 23}
  1. 删除(del、pop、popitem)
#del
>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
>>> del stu_info['qigao']
#结果输出
>>> print(stu_info)
{'zhangsan': 23, 'lisi': 18}

注：如果是del stu_info的话，则是删除stu_info这个变量


#pop
>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
#删除时给出提示
>>> print(stu_info.pop("qigao"))
18
#输出结果
>>> print(stu_info)
{'zhangsan': 23, 'lisi': 18}


#popitem
>>> stu_info = {"zhangsan":23,"lisi":18,"qigao":18}
#删除时给出提示
>>> print(stu_info.popitem())
('qigao', 18)
#输出结果
>>> print(stu_info)
{'zhangsan': 23, 'lisi': 18}

3、字典内置函数&方法

内置函数

序号描述
1len(dict) #计算字典元素个数，即键的总数
2str(dict) #输出字典可打印的字符串表示
3type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型
'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
#返回字典的元素个数(len )
>>> dict = {'Name': 'zhangsan', 'Age': 7};
>>> print (len (dict))
2


#返回字符串(str)
>>> dict = {'Name': 'zhangsan', 'Age': 7};
>>> print (str (dict))
{'Name': 'zhangsan', 'Age': 7}


#返回输入的变量类型(type)
>>> dict = {'Name': 'zhangsan', 'Age': 7};
>>> print (type (dict))
<class 'dict'>

方法

序号描述
1dict.clear() #删除字典内所有元素
2dict.copy() #返回一个字典的浅复制
3dict.fromkeys(seq[, val]) #创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4dict.get(key, default=None) #返回指定键的值，如果值不在字典中返回default值
5dict.items() #以列表返回可遍历的(键, 值) 元组数组
6dict.keys() #以列表返回一个字典所有的键
7dict.setdefault(key, default=None) #和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
8dict.update(dict2) #把字典dict2的键/值对更新到dict里
9dict.values() #以列表返回字典中的所有值
10pop(key[,default]) #删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出.否则，返回default值
11popitem() #返回并删除字典中的最后一对键和值
#删除字典内所有元素   clear()
>>> dict = {'Name': 'Zara', 'Age': 7}

>>> print ("字典长度 : %d" %  len(dict))
>>> dict.clear()
>>> print ("字典删除后长度 : %d" %  len(dict))

#输出：
字典长度 : 2
字典删除后长度 : 0


#-----------------------------------------------------------------------------------


##返回一个字典的浅复制   copy()
>>> dict1 = {'user': 'runoob', 'num': [1, 2, 3]}

>>> dict2 = dict1  # 浅拷贝: 引用对象
>>> dict3 = dict1.copy()  # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用

>>> # 修改 data 数据
>>> dict1['user'] = 'root'
>>> dict1['num'].remove(1)

>>> # 输出结果
>>> print(dict1)
>>> print(dict2)
>>> print(dict3)

#输出：
{'user': 'root', 'num': [2, 3]}
{'user': 'root', 'num': [2, 3]}
{'user': 'runoob', 'num': [2, 3]}


#-----------------------------------------------------------------------------------


#函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值    fromkeys()
>>> seq = ('name', 'age', 'sex')

>>> dict = dict.fromkeys(seq)
>>> print ("新的字典为 : %s" %  str(dict))

>>> dict = dict.fromkeys(seq, 10)
>>> print ("新的字典为 : %s" %  str(dict))

#输出：
新的字典为 : {'name': None, 'age': None, 'sex': None}
新的字典为 : {'name': 10, 'age': 10, 'sex': 10}


#-----------------------------------------------------------------------------------


#函数返回指定键的值，如果值不在字典中返回默认值   get()
>>> dict = {'Name': 'Runoob', 'Age': 27}

>>> print ("Age 值为 : %s" %  dict.get('Age'))
>>> print ("Sex 值为 : %s" %  dict.get('Sex', "NA"))

#输出：
Age 值为 : 27
Sex 值为 : NA


#-----------------------------------------------------------------------------------


#方法以列表返回可遍历的(键, 值) 元组数组   items()
>>> dict = {'Name': 'Runoob', 'Age': 7}

>>> print ("Value : %s" %  dict.items())

#输出：
Value : dict_items([('Name', 'Runoob'), ('Age', 7)])


#-----------------------------------------------------------------------------------


#返回一个字典所有的键值   keys()
>>> dict = {'Name': 'QQ', 'Age': 7}

>>> print ("字典所有的键为 : %s" %  dict.keys())
>>> print ("字典所有值为 : ",  list(dict.values()))

#输出：
字典所有的键为 : dict_keys(['Name', 'Age'])
字典所有值为 :  ['QQ', 7]


#-----------------------------------------------------------------------------------


#和get()方法类似，如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值    setdefault()
>>> dict = {'Name': 'Runoob', 'Age': 7}

>>> print ("Age 键的值为 : %s" %  dict.setdefault('Age', None))
>>> print ("Sex 键的值为 : %s" %  dict.setdefault('Sex', None))
>>> print ("新字典为：", dict)

#输出：
Age 键的值为 : 7
Sex 键的值为 : None
新字典为： {'Name': 'Runoob', 'Age': 7, 'Sex': None}


#-----------------------------------------------------------------------------------


#把字典dict2的键值对更新到dict里   update()
>>> dict = {'Name': 'Runoob', 'Age': 7}
>>> dict2 = {'Sex': 'female' }

>>> dict.update(dict2)
>>> print ("更新字典 dict : ", dict)

#输出：
更新字典 dict :  {'Name': 'Runoob', 'Age': 7, 'Sex': 'female'}


#-----------------------------------------------------------------------------------


#返回字典中的所有值    values()
>>> dict = {'Name': 'Zara', 'Age': 7}

>>> print ("Value : %s" %  dict.values())

#输出：
Value : dict_values(['Zara', 7])

4、循环字典

'''
遇到问题没人解答？小编创建了一个Python学习交流QQ群：778463939
寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！
'''
#方法一
for key in dict:
    print(key,dict[key])

#方法二
for k,v in info.items(): #会先把dict转成list,数据量大时莫用
    print(k,v)

注：

①方法1的效率比方法2的效率高很多

②方法1是直接通过key取value

③方法2是先把字典转换成一个列表，再去取值

④当数据量比较大的时候，用第二种方法时，字典转换成列表的这个过程需要花大量的时间老转换，当然数据量不大，没有关系，效率差不多

Python热爱者
关注
Python dictionary items()系列函数的使用
revilwang的专栏
08-19 1万+
源自《Python cookbook》第3版7.1节第2个例子： import html # available only in Python 3.x def make_elements(name, value, **attrs): keyvals = [' %s="%s"' % item for item in attrs.items()] attr_str = ''.j
Python 容器类型--list、tuple、dict、set
m0_69298614的博客
08-16 1615
方式一lst1 = []#方式二#list()为工厂函数，可以把其他数据类型转换为list#若在list()中传递的是可迭代对象时，可挨个存入列表t1 = ()t2 = (1, ) #初始元组只有一个元素时，后面要打逗号，没有逗号为int类型t3 = (1)
Python青少年简明教程：列表（List）、元组（tuple）和字典（dict）
最新发布
cnds123的专栏
08-27 929
在Python中，没有传统意义上像C或Java那样的“数组”数据类型，但Python提供了几种可以模拟数组行为的数据结构，如列表（list）、元组（tuple）其中最常用的是列表（List）。在Python中，对于列表（list）这样的对象，方法是指那些可以在列表上调用的函数，这些函数能够直接操作列表中的数据。换句话说，方法是属于特定对象的函数，它们定义了对象的行为。Python中元组（tuple）的元素索引与列表（list）的索引在索引和切片操作上表现相同，主要区别在于元组是不可变的，而列表是可变的。
python列表list，元组tuple，字典dict
ZJE
05-04 722
1.列表list的特点 2.列表基本操作 3.列表的操作函数 4.元组tuple的特点 5.元组的基本操作 6.字典dict的特点 7.字典的基本操作 1.列表list 的特点 1.列表用 [] 表示 2.列表内的数据可重复 3.列表内的数据可通过索引来访问(就像数组，第一个元素的索引为0) 4.列表初始化后，可对列表进行修改 5.列表中的元素可以不
Python学习小记--列表/元组/字典/函数
LinSeeker85的博客
02-01 235
# range中定步长range(start, end, step) members = list(range(2,10,2)) print(members)  #[2, 4, 6, 8] # 两个星号**表示乘方 squares = [] for val in range(1,10):  # 不包含右闭包     square = val **2     squares.append(...
Python列表 元组 字典 以及函数
weixin_33975951的博客
05-24 141
一.元组 不可改变的（） 1，type() 类型 tuple=(30,) 加,代表元组 2.元组可以相加 + * 3.列表转为元组 t=tuple(list) 4.元组里的列表可以进行增删改的操作 二.字典d={} key--value 1.增 d[" "]=值 删del 改--覆盖 2.d,keys() d.values() d.items()---键值对一起输出 3._s...
Python容器：列表、元组、字典与集合[收集].pdf
10-11
Python 容器：列表、元组、字典与集合 Python 语言中提供了多种容器类型，包括列表、元组、字典和集合等，这些容器类型可以用来存储和操作数据。下面是对这些容器类型的详细介绍： 列表（List） 列表是一种可变的...
Python 的内置数据类型：列表 list、元组 tuple、字典 dict、集合 set.
12-21
Python数据类型：list list 是一种有序集合，由于Python是动态语言，所以 list 中包含的元素并不要求都必须是同一种数据类型，我们完全可以在 list 中包含各种数据。 访问列表中最后一个元素：L[-1]，索引值为 -1。...
掌握Python数组：列表、元组、字典与集合的实现
在Python中，数组可以以四种不同的方式表达，分别是列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set）。这四种数据结构各自具有独特的特性，适用于不同的场景。" 知识点一：列表（List） 列表是Python...
python入门之：列表+元组+字典+集合（csdn）————程序.pdf
12-03
在Python中，数据结构是非常基础且重要的概念，包括列表、元组、字典和集合。本文将深入探讨这些概念及其用法。 首先，我们来看列表(List)。列表是Python中最常用的数据结构之一，它可以存储任意类型的元素，并且...
python基础：列表，元组，字典的用法
weixin_50235838的博客
02-23 697
除非十点四十
python中list ，tuple，dict的操作
weixin_38859557的博客
05-10 456
列表的操作：列表的操作：list 1:copy :列表的拷贝（浅拷贝） 还有一个深拷贝这是由于list里面可以还有dict或者list ，深拷贝就是不管有多少层，都拷贝出来 2：count 3：extend：扩展就是把两个列表合并起来；其实是把原来的列表扩展开 ；最好是在列表或者tuple里面最后加上一个逗号 4：index 获取下标 5：insert（i,'value')指定下标存入数字 6：a...
Python基础——列表（list）、元组（tuple）、字典（dict）、集合（set）的使用
行者无疆的博客
05-03 365
List容器 List的创建 方法一： Lista=[‘hello’,’world’,8] 方法二： Listb=list([‘hello’,’world’,8]) 方法三： Listc=[i for i in range(start,end)] List的修改   同一个List中可以存放任意类型的数据。   append()添加元素到末尾；   insert(loc,element)讲元素插入到指定位置；   pop()删除末尾元素；   pop(index)删除指定位置的元素；   clear(
Python中的tuple元组和dict字典的用法
qq_38358499的博客
03-19 5858
1.tuple元组 （1）元组的基本知识 a）概念：是一种有序的集合 b）元组和列表的区别： 格式： 元组：()，列表：[ ]； 列表中的元素可以进行增加和删除操作，但是，元组中的元素不能进行修改 c）元组和列表的相同点： 都是一种容器，都可以同时存储不同类型的数据 （2）元组的创建 创建空列表：list1 = [] 创建有元素的列表：list1 =[元素1，元素2，，，，...
Python【系列教程】之list（列表），tuple（元组），dict（字典）
小米吃辣椒的博客
08-26 1171
一、列表和元组的通用用法 （1） # 定义list myList = ["a", 20, "python"] print(myList) # 定义元组 myTuple = ('a', 20, 'python') print(myTuple) # list,元组和 str的用法类似 print(myList[0]) print(myList[-1]) print(myTuple[0]) pr...
[Python] 元组(tuple)、列表[list]、字典{dict}
weixin_39552387的博客
03-26 219
###定义一个元组(tuple)，定义了一个元组之后就无法再添加或修改元组的元素，但对元组切片可以添加会修改元组的元素。 tuple1 = 'a', tuple2 = ('a','b','c','d','e','f','g') #常规来说， print(tuple2[1:5]) tuplex = tuple2[:2]+('h')+temp[2:] print(tuplex) #使用for循环进行遍...
Python的list,tuple和dict
annikakakak的博客
09-25 181
Python的list,tuple和dict 注：复习总结，部分英文中括号没法显示，就用了中文中括号代替。 List 定义：List是列表，可以用来存放元素，包括各种类型的元素，比如说数或者字符串。 怎么遍历：L = [‘Alice’, 66, ‘Bob’, True, ‘False’, 100] for item in L: print(item) 怎么按索引查询：names = [‘Alice’, ‘Bob’, ‘David’, ‘Ellena’] print(names[0]) print(name
Python 中的Dic和List
weixin_43823453的博客
09-25 626
title: Python 学习笔记 date: 2020-03-27 12:00:00 tags: 编程语言入门 python cover: https://www.wallpaperup.com/wallpaper/download/67364/b923d937f90f4f6a40fd21b02b8d0521/1280/800 Python 学习笔记 因毕业设计需要，学习下入门级的python基本知识。 需要注意的数据类型 Dic : Python包含以下函数: 序号 函数及描述 .
Python——list,tuple,dict与set
chandler7k的博客
06-09 222
list 列表list是一种有序的集合，可以随时添加和删除其中的元素 比如，列出班里所有同学的名字，就可以用一个list表示：>>> classmates = ['Michael', 'Bob', 'Tracy'] >>> classmates ['Michael', 'Bob', 'Tracy']len()返回 list 长度>>> len(classmates) 3关于调用：从0开始，超出长度
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值