基本数据类型-列表_元组_字典

基本数据类型-列表_元组_字典

一、列表（list)书写格式：[]
1 #通过list类创建的
2
3 li = [1, 12, 9, "age", ["刘正文", ["19", 10, ],"庞麦郎"], "ales", True]  
1、列表格式2、列表中可以嵌套任何类型
  • 中括号起来
  • ，分割每个元素
  • 列表中的元素可以是 数字，字符串，列表，布尔值....所有的都能放进去
  • "集合" ，内部放置任何东西
3、索引取值
1 li = [1, 12, 9, "age", ["刘正文", ["19", 10, ],"庞麦郎"], "ales", True]
2 print(li[3]) #索引取值

执行结果：

1 age
4、切片，切片结果也是列表
1 li = [1, 12, 9, "age", ["刘正文", ["19", 10, ],"庞麦郎"], "ales", True]
2 print(li[3:-1])  #切片，切片的结果也是列表

执行结果：

1 [‘age‘, [‘刘正文‘, [‘19‘, 10], ‘庞麦郎‘], ‘ales‘]
5、for循环
  while循环
1 li = [1, 12, 9, "age", ["刘正文", ["19", 10, ],"庞麦郎"], "ales", True]
2 for item in li:
3     print(item)

执行结果：

1 1
2 12
3 9
4 age
5 [‘刘正文‘, [‘19‘, 10], ‘庞麦郎‘]
6 ales
7 True

6、索引

  • 修改

列表元素，可以被修改

ps1:

1 li = [1, 12, 9, "age", ["刘正文", ["19", 10, ],"庞麦郎"], "ales", True]
2 li[1] = 120
3 print(li)

执行结果：

1 [1, 120, 9, ‘age‘, [‘刘正文‘, [‘19‘, 10], ‘庞麦郎‘], ‘ales‘, True]

ps2:

1 li = [1, 12, 9, "age", ["刘正文", ["19", 10, ],"庞麦郎"], "ales", True]
2 li[1] = [11,22,33,44]
3 print(li)

执行结果：

1 [1, [11, 22, 33, 44], 9, ‘age‘, [‘刘正文‘, [‘19‘, 10], ‘庞麦郎‘], ‘ales‘, True]
  • 删除

删除，第一种方式

1 li = [1, 12, 9, "age", ["刘正文", ["19", 10, ],"庞麦郎"], "ales", True]
2 del li[1]   #删除12
3 print(li)

执行结果：

1 [1, 9, ‘age‘, [‘刘正文‘, [‘19‘, 10], ‘庞麦郎‘], ‘ales‘, True]

7、切片

  • 修改
1 li = [1, 12, 9, "age", ["刘正文", ["19", 10, ],"庞麦郎"], "ales", True]
2 li[1:3] = [120,90]   #修改12,9
3 print(li)

执行结果：

1 [1, 120, 90, ‘age‘, [‘刘正文‘, [‘19‘, 10], ‘庞麦郎‘], ‘ales‘, True]
  • 删除
1 li = [1, 12, 9, "age", ["刘正文", ["19", 10, ],"庞麦郎"], "ales", True]
2 del li[2:6]
3 print(li)

执行结果：

1 [1, 12, True]

8、in操作

作用：判断这个元素是否在列表中

ps1:

值存在这个列表中，就是Ture

1 li = [1, 12, 9, "age", ["刘正文", ["19", 10, ],"庞麦郎"], "ales", True]
2 v = 1 in li   #1在这个列表中，就是True
3 print(v)
1 True

ps2:

值不存在这个列表中，就是Flase

1 li = [1, 12, 9, "age", ["刘正文", ["19", 10, ],"庞麦郎"], "ales", True]
2 v = 120 in li
3 print(v)

执行结果：

1 False

ps3:

因为在列表中的元素，以逗号做为分割，就是个整体，所以是Flase
1 li = [1, 12, 9, "age", ["史正文", ["19", 10, ],"庞麦郎"], "ales", True]
2 #因为在列表中的元素，以逗号做为分割，就是个整体，所以是Flase
3 v = "刘正文" in li    #史正文在第4个素引的列表中，所以是Flase
4 print(v)

执行结果：

1 False

9、操作

1 li = [1, 12, 9, "age", ["石振文", ["19", 10], "庞麦郎"], "alex", True]
2 li[4][1][0][1]  #索引取值，可以一直往里面找

补充知识：

只要我想把某个值，转成什么，就写上对应的类型，就可以进行转换

1 把字符串转成整型
2
3 a = "123"
4 int(a)
5 a = 123
1 把整型转到字符串
2
3 a = 123
4 str(a)

10、转换

1、字符串转换列表 li = list("asdfasdfasdf"), 内部使用for循环

1 s = "pouaskdfauspdfiajsdkfj"
2 new_li = list(s)
3 print(new_li)

执行结果：

1 [‘p‘, ‘o‘, ‘u‘, ‘a‘, ‘s‘, ‘k‘, ‘d‘, ‘f‘, ‘a‘, ‘u‘, ‘s‘, ‘p‘, ‘d‘, ‘f‘, ‘i‘, ‘a‘, ‘j‘, ‘s‘, ‘d‘, ‘k‘, ‘f‘, ‘j‘]

2、列表转换成字符串

需要自己写for循环一个一个处理，即有数字又有符串

1 li = [11,22,33,"123","alex"]
2 r = str(li) # 指的就是把上面列表打印出来
3 print(r)

执行结果：

1 [11, 22, 33, ‘123‘, ‘alex‘]

列表转换成字符串

1 li = [11,22,33,"123","alex"]
2 s = ""
3 for i in li:
4     s = s + str(i)
5 print(s)

执行结果：

1 112233123alex

3、直接使用字符串join方法：列表中的元素只有字符串

1 li = ["123","alex"]
2 v = "".join(li)
3 print(v)

执行结果：

1 123alex

4、补充：

1、字符串创建后，不可修改  replace:替换

1 v = "alex"
2 v = v.replace(‘l‘,‘el‘)
3 print(v)

执行结果：

1 aelex

2、列表

li = [11,22,33,44]
li[0]
li[0] = 999

s = "alex"
li[0]
s[0] = "E"

li = [11,22,33,44]
print(li)
print(li)
print(li)
print(li)
print(li)
print(li)
print(li)
print(li)
列表，有序；元素可以被修改

列表
list
li = [111,22,33,44]

列表内容的总结：

1. 书写格式
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)
一般写元组的时候，推荐在最后加入 ,
元素不可被修改，不能被增加或者删除

2. 索引
v = tu[0]
print(v)

3. 切片
v = tu[0:2]
print(v)

4. 可以被for循环，可迭代对象
for item in tu:
    print(item)

5. 转换
s = "asdfasdf0"
li = ["asdf","asdfasdf"]
tu = ("asdf","asdf")

v = tuple(s)
print(v)

v = tuple(li)
print(v)

v = list(tu)
print(v)

v = "_".join(tu)
print(v)

li = ["asdf","asdfasdf"]
li.extend((11,22,33,))
print(li)

6.元组的一级元素不可修改/删除/增加
tu = (111,"alex",(11,22),[(33,44)],True,33,44,)

元组，有序
v = tu[3][0][0]
print(v)
v=tu[3]
print(v)
tu[3][0] = 567
print(tu)

二、参数

1、追加 append

1 li = [11, 22, 33, 22, 44]
2 li.append(5)
3 li.append("alex")
4 li.append([1234,2323])
5 print(li)

执行结果：

1 [11, 22, 33, 22, 44, 5, ‘alex‘, [1234, 2323]]

2、清空列表 clear

1 li = [11, 22, 33, 22, 44]
2 li.clear()   #清空列表中的值
3 print(li)

执行结果：

1 []

3、拷贝，浅拷贝 copy()

1 li = [11, 22, 33, 22, 44]
2 v = li.copy()
3 print(v)
4 print(li)

执行结果：

1 [11, 22, 33, 22, 44]
2 [11, 22, 33, 22, 44]

4、计算元素出现的次数  count

1 li = [11, 22, 33, 22, 44]
2 v = li.count(22)  #统计22出现了几次，所以是2次
3 print(v)

执行结果：

2

5、扩展原列表，参数，可迭代对象 extend

1 li = [11, 22, 33, 22, 44]
2 li.extend([9898,"不得了"])
3 print(li)

执行结果：

1 [11, 22, 33, 22, 44, 9898, ‘不得了‘]

6、根据值获取当前值索引位置（左边优先） index

1 li = [11, 22, 33, 22, 44]
2 v = li.index(22)   #从0开始数
3 print(v)

执行结果：

1 1

7、在指定索引位置插入元素 insert

1 li = [11, 22, 33, 22, 44]
2 li.insert(0,99)
3 print(li)

执行结果：

1 [99, 11, 22, 33, 22, 44]

8、删除某个值  pop

1.指定索引

2、默认最后一个，并获取删除的值

ps1:

1 li = [11, 22, 33, 22, 44]
2 v = li.pop()
3 print(li)
4 print(v)

执行结果：

1 [11, 22, 33, 22]   #删除了44
2 44   #获取删除的值

ps2:

1 li = [11, 22, 33, 22, 44]
2 v = li.pop(1)  #指定删除的参数，删除第1个，从0开始数
3 print(li)
4 print(v)

执行结果：

1 [11, 33, 22, 44]
2 22

9、删除列表中的指定值，左边优先  remove

PS:删除的命令一共有几个 pop、remove、del li[0]、del li[7:9]、clear
1 li = [11, 22, 33, 22, 44]
2 li.remove(22)
3 print(li)

执行结果：

1 [11, 33, 22, 44]

10、将当前列表进行翻转 reverse

1 li = [11, 22, 33, 22, 44]
2 li.reverse()
3 print(li)

执行结果：

1 [44, 22, 33, 22, 11]

11、列表的排序(从大到小） sort(reverse=True)

1 li = [11, 22, 33, 22, 44]
2 li.sort()
3 li.sort(reverse=True)
4 print(li)

执行结果：

1 [44, 33, 22, 22, 11]

12、enumrate

为一个可迭代的对象添加序号，可迭代的对象你可以理解成能用for循环的就是可迭代的。默认是编号是从0开始，可以设置从1开始

1 li = ["手机", "电脑", "鼠标垫", "游艇"]
2 for k, i in enumerate(li,1):
3     print(k,i)

执行结果

1 1 手机
2 2 电脑
3 3 鼠标垫
4 4 游艇

三、元组  

书写格式：()

1、元组的一级元素不可修改/删除/增加

ps1:

1 tu = (111, "alex", (11, 22), [(33, 44),9], True, 33, 44,)
2 #元组，有序
3 v = tu[3][0][0]
4 print(v)

执行结果：

1 33

ps2:

1 tu = (111, "alex", (11, 22), [(33, 44),9], True, 33, 44,)
2 v = tu[3]    #从0开始数， " " （） [] 都只能算一个数
3 print(v)

执行结果：

1 [(33, 44), 9]

ps3:

列表可以被替换

1 tu = (111, "alex", (11, 22), [(33, 44)], True, 33, 44,)
2 tu[3][0] = 567   #获取到，列表可以被替换
3 print(tu)

执行结果：

1 (111, ‘alex‘, (11, 22), [567], True, 33, 44)

2、列表和元组的使用说明：

1 什么时候用列表，什么时候用元组
2 可以被修改的就用list
3 不能被修改的就用元组
4 元组要修改的话，可以转成列表，再替换

四、字典（dict)  

字典{}，列表[], 元组()

总结：

1、字典是以键值对的方式出现：key:value
2、字典的value的值可以是任何值
3、布尔值、列表、字典不能作为字典的key,但元组可以，做为列表的key
4、字典是无序的

书写格式：{}

1、基本结构，字典是以键值对的方式出现

info = {
        "k1":"v1", #键值对
        "k2":"v2"
 }

“k1”:"v1" 表示为：key:value 前面是key,后面是值

2、字典的value（值）可以是任何值

 1 info = {
 2     "k1": 18,
 3     "k2": True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             ‘kk1‘: ‘vv1‘,
12             ‘kk2‘: ‘vv2‘,
13             ‘kk3‘: (11, 22),
14         }
15     ],
16     "k4": (11, 22, 33, 44)
17 }
18 print(info)

执行结果：

1 {‘k3‘: [11, [], (), 22, 33, {‘kk1‘: ‘vv1‘, ‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}], ‘k4‘: (11, 22, 33, 44), ‘k1‘: 18, ‘k2‘: True}

3、布尔值、列表、字典不能作为字典的key

ps1:

1 info ={
2     1: ‘asdf‘,
3     "k1": ‘asdf‘,
4     True: "123",   #布尔值不能作为字典的key，只能是值
5 }
6 print(info)

执行结果：

1 {1: ‘123‘, ‘k1‘: ‘asdf‘}

ps2:

 1 info = {
 2     1: ‘asdf‘,
 3     "k1": ‘asdf‘,
 4      True: "123",
 5     #[11,22]: 123   #列表不能做为字典的key，会报错。
 6     (11,22): 123,   #元组可以，做为列表的key
 7     #{‘k1‘:‘v1‘}: 123  #字典不可以做为字典的key("TypeError: unhashable type:‘dict‘)
 8
 9 }
10 print(info)

执行结果：

1 {1: ‘123‘, ‘k1‘: ‘asdf‘, (11, 22): 123}

4、字典无序

 1 info = {
 2     "k1": 18,
 3     "k2": True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             ‘kk1‘: ‘vv1‘,
12             ‘kk2‘: ‘vv2‘,
13             ‘kk3‘: (11, 22),
14         }
15     ],
16     "k4": (11, 22, 33, 44)
17 }
18 print(info)

执行结果：

两次结果进行比较，会发现字典是无序的。

运行程序1次得出的结果：

1 {‘k3‘: [11, [], (), 22, 33, {‘kk1‘: ‘vv1‘, ‘kk3‘: (11, 22), ‘kk2‘: ‘vv2‘}], ‘k1‘: 18, ‘k2‘: True, ‘k4‘: (11, 22, 33, 44)}

再运行程序得出的结果：

1 {‘k4‘: (11, 22, 33, 44), ‘k3‘: [11, [], (), 22, 33, {‘kk1‘: ‘vv1‘, ‘kk3‘: (11, 22), ‘kk2‘: ‘vv2‘}], ‘k1‘: 18, ‘k2‘: True}

5、索引方式找到指定元素

ps1：

取18的值

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             ‘kk1‘: ‘vv1‘,
12             ‘kk2‘: ‘vv2‘,
13             ‘kk3‘: (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 v = info[‘k1‘]   #获取key的值，就是18
19 print(v)
20 v = info[2]      #获取2的值，就是True
21 print(v)

执行结果：

1 18
2 True

ps2:

找到11

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             ‘kk1‘: ‘vv1‘,
12             ‘kk2‘: ‘vv2‘,
13             ‘kk3‘: (11,22),   #找到11
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 v = info[‘k3‘][5][‘kk3‘][0]  #找到11; 最后元组拿到第一个元素，加[0]
19 print(v)

执行结果：

1 11

6、字典支持 del 删除

ps1:

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             ‘kk1‘: ‘vv1‘,
12             ‘kk2‘: ‘vv2‘,
13             ‘kk3‘: (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 del info[‘k1‘]

执行结果：

      #删除掉了，所以什么都没有

ps2:

删除kk1

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             ‘kk1‘: ‘vv1‘,
12             ‘kk2‘: ‘vv2‘,
13             ‘kk3‘: (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 del info[‘k3‘][5][‘kk1‘]  #删除‘kk1‘: ‘vv1‘,
19 print(info)

执行结果：

1 {‘k1‘: 18, ‘k3‘: [11, [], (), 22, 33, {‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}], 2: True, ‘k4‘: (11, 22, 33, 44)}

7、字典的for循环

ps1:

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             ‘kk1‘: ‘vv1‘,
12             ‘kk2‘: ‘vv2‘,
13             ‘kk3‘: (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 for item in info:
19     print(item)

执行结果：

1 {2: True, ‘k4‘: (11, 22, 33, 44), ‘k3‘: [11, [], (), 22, 33, {‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}], ‘k1‘: 18}
2 2
3 k4
4 k3
5 k1

ps2:

dict里面的功能

info.keys() 默认循环他所有的key

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             ‘kk1‘: ‘vv1‘,
12             ‘kk2‘: ‘vv2‘,
13             ‘kk3‘: (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 for item in info.keys():
19     print(item)

执行结果：

1 {‘k4‘: (11, 22, 33, 44), 2: True, ‘k3‘: [11, [], (), 22, 33, {‘kk3‘: (11, 22), ‘kk2‘: ‘vv2‘}], ‘k1‘: 18}
2 k4
3 2
4 k3
5 k1

ps3:

循环他的values()

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             ‘kk1‘: ‘vv1‘,
12             ‘kk2‘: ‘vv2‘,
13             ‘kk3‘: (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 for item in info.values():
19     print(item)

执行结果：

1 {2: True, ‘k4‘: (11, 22, 33, 44), ‘k1‘: 18, ‘k3‘: [11, [], (), 22, 33, {‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}]}
2 True
3 (11, 22, 33, 44)
4 18
5 [11, [], (), 22, 33, {‘kk1‘: ‘vv1‘, ‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}]

ps4:

即想获取key，又想获取values

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             ‘kk1‘: ‘vv1‘,
12             ‘kk2‘: ‘vv2‘,
13             ‘kk3‘: (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 for item in info.keys():    #即想获取key，又想获取values
19     print(item,info[item])

执行结果：

1 {‘k4‘: (11, 22, 33, 44), 2: True, ‘k3‘: [11, [], (), 22, 33, {‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}], ‘k1‘: 18}
2 k4 (11, 22, 33, 44)
3 2 True
4 k3 [11, [], (), 22, 33, {‘kk2‘: ‘vv2‘, ‘kk1‘: ‘vv1‘, ‘kk3‘: (11, 22)}]
5 k1 18

ps5:

获取键值对

 1 info = {
 2     "k1": 18,
 3     2: True,
 4     "k3": [
 5         11,
 6         [],
 7         (),
 8         22,
 9         33,
10         {
11             ‘kk1‘: ‘vv1‘,
12             ‘kk2‘: ‘vv2‘,
13             ‘kk3‘: (11,22),
14         }
15     ],
16     "k4": (11,22,33,44)
17 }
18 for k,v in info.items():
19     print(k,v)

执行结果：

1 {‘k1‘: 18, 2: True, ‘k4‘: (11, 22, 33, 44), ‘k3‘: [11, [], (), 22, 33, {‘kk2‘: ‘vv2‘, ‘kk3‘: (11, 22)}]}
2 k1 18
3 2 True
4 k4 (11, 22, 33, 44)
5 k3 [11, [], (), 22, 33, {‘kk2‘: ‘vv2‘, ‘kk1‘: ‘vv1‘, ‘kk3‘: (11, 22)}]

ps6:

True 1 False 0

1 info ={
2     "k1": ‘asdf‘,
3     True: "123",
4     # [11,22]: 123
5     (11,22): 123,
6     # {‘k1‘:‘ v1‘}: 123
7
8 }
9 print(info)

执行结果：

1 {True: ‘123‘, ‘k1‘: ‘asdf‘, (11, 22): 123}

ps7:  打印序号,并取出key和value的值

1 #打印序号,并取出key和value的值
2 dic = {‘k1‘:123,123:123,‘999‘:123}
3 for i,v ,in enumerate(dic.items(),1):
4     print(i,v[0],v[1])
5
6 for i,v in enumerate(dic,1):
7     print(i,v,dic[v])

复习字典：

字典:{},列表:[], 元组:()

总结：

1、字典key:value
2、字典的value的值可以是任何值
3、布尔值、列表、字典不能作为字典的key,但元组可以，做为列表的key
4、字典是无序的

一、字典的增加，删除，修改，查询

示例：

1 info={‘nulige‘: 28, ‘alex‘: 30, ‘liuyang‘: ‘man‘, ‘wusir‘: ‘woman‘}

1、增加和修改

增加key和vlaue

 1 #修改value
 2 info[‘nulige‘]=18
 3 print(info)
 4
 5 #增加
 6 info.update({‘sunkai‘:18})
 7 print(info)
 8
 9 #增加key和vlaue(没有就增加，有就修改）
10 info[‘lihuafen‘]=35
11 print(info)

往字典的列表中加入元 素

 1 #往wusir字典中加入一个元素44
 2
 3 info={‘nulige‘: 28, ‘alex‘: 30, ‘liuyang‘: ‘man‘, ‘wusir‘: [11,22,33]}
 4 info[‘wusir‘].append(44)
 5 print(info)
 6
 7
 8 #往wusir字典的第一个位置插入个元素18
 9 info={‘nulige‘: 28, ‘alex‘: 30, ‘liuyang‘: ‘man‘, ‘wusir‘: [11,22,33]}
10 info[‘wusir‘].insert(0,44)
11 print(info)

2、删除

 1 #删除
 2 del info[‘nulige‘]
 3 print(info)
 4
 5 #删除
 6 info.pop(‘alex‘)
 7 print(info)
 8
 9 #清空字典
10 info.clear()
11 print(info) #{}

3、查询

获取字典的key和values

 1 #取字典的key
 2
 3 #法1：
 4 for item in info:
 5 print(item)
 6
 7 #法2：
 8 for item in info.keys():
 9 print(item)
10
11 #取字典的values
12 for item in info.values():
13 print(item)
14
15 #取key和values
16 for item in info.keys():
17 print(item,info[item])

4、获取字典键值对应的值

1 for k,v in info.items():
2 print(k,v)
3
4 #结果：
5 nulige 28
6 alex 30
7 wusir woman
8 liuyang man

5、打印序号，取key和value

 1 info={‘nulige‘: 28, ‘alex‘: 30, ‘liuyang‘: ‘man‘, ‘wusir‘: ‘woman‘}
 2
 3 法一：
 4 for i,v,in enumerate(info.items(),1):
 5     print(i,v[0],v[1])
 6
 7 法二：
 8 for i,v in enumerate(info,1):
 9     print(i,v,info[v])
10
11 执行结果：
12 1 nulige 28
13 2 alex 30
14 3 wusir woman
15 4 liuyang man

6、计算字典总个数

1 info={‘nulige‘: 28, ‘alex‘: 30, ‘liuyang‘: ‘man‘, ‘wusir‘: ‘woman‘}
2 print(len(info))
3
4 #执行结果：
5 4

五、整理必须掌握的东西

一、数字int(..)

二、字符串replace/find/join/strip/startswith/split/upper/lower/formattempalte = "i am {name}, age : {age}"# v = tempalte.format(name=‘alex‘,age=19)v = tempalte.format(**{"name": ‘alex‘,‘age‘: 19})print(v)

三、列表append、extend、insert索引、切片、循环

四、元组忽略索引、切片、循环 以及元素不能被修改

五、字典get/update/keys/values/itemsfor,索引

dic = {    "k1": ‘v1‘}

v = "k1" in dicprint(v)

v = "v1" in dic.values()print(v)

六、布尔值0 1bool(...)None ""  () []  {} 0 ==> False
时间： 2024-10-05 23:27:05

基本数据类型-列表_元组_字典的相关文章

Python学习之路——Python基础之基本数据类型(列表、元组和字典)

基本数据类型 数字 字符串 列表 list 元组 tuple 字典 dict 布尔值 bool 列表和元组 列表:有序,元素可以被修改元组: 书写格式:元组的一级元素不可被修改,不能被增加或者删除,一般写元租的时候,推荐在最后加入',' 索引:v = tu[0] 切片:v = tu[0:2] 可以被for循环,可迭代对象: for item in tu 转换:str <--> list <--> tupleTips:元组中嵌套的列表的元素可以被修改 字典 dict: info =

python数据类型——列表、元组、字典、集合

python中的序列,是一块用来存储多个值的连续内存空间,类似于C语言中的数组 常用的序列结构有列表.元组.字典.字符串.集合等, 无序序列:字典.集合 有序序列:列表.元组.字符串,支持双向索引(第一个元素下标为0,最后一个元素下标为-1) 不可变序列:字符串.元组 可变序列:列表.集合.字典 一.列表 尽量从列表尾增加或删除元素,可以大幅度提高处理速度 列表中的元素可以不相同 列表常用方法,见下表,可参考https://www.cnblogs.com/huangping/p/7730347.

python数据类型—列表、元组、字典

*列表生成 *元组 *字典 以下实验均由2.7版本操作完成 一.列表生成 1.语法: range(starti  stop  step)         2.7版本 list(range(starti  stop  step)))    3.5版本 生成一个从数字1到10的列表: print(list.pop()); a=list(range(1,10)); print(a)  ## [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 2.通过循环生成列表: 语法:[x for x

基本数据类型-集合(set)_上周内容回顾（列表_元组_集合）

上周内容回顾 字符串数字列表元组字典 可变不可变:1.可变:列表,字典2.不可变: 字符串,数字,元组 访问顺序:1.直接访问:数字2.顺序访问:字符串,列表,元组3.映射: 字典 存放元素个数:容器类型:列表,元组,字典原子:数字,字符串 set集合是一个无序而且不重复的集合,有些类似于数学中的集合,也可以求交集,求并集等 集合特性:1.不同元素组成2.无序3.集合中元素必须是不可变类型 1 class set(object): 2 """ 3 set() -> ne

数据类型总结（二）（列表，元组，字典）

一.变量的赋值操作 x=1 a=10 b=10 # #链式赋值 a=b=c=d=e=f=10 print(a,b,c,d,e,f) #多元赋值 #方式一 x=1 y=2 z=x #z=1 x=y #x=2 y=z #y=1 print(x,y) #方式二:python特有 x,y=y,x print(x,y) #增量赋值 x=10 x+=1 #x=x+1 print(x) #解压序列类型 s='hello' a=s[0] b=s[1] c=s[2] d=s[3] e=s[4] print(a,b

组合数据类型练习，英文词频统计实例上列表，元组，字典，集合的遍历。 总结列表，元组，字典，集合的联系与区别。

1.字典实例:建立学生学号成绩字典,做增删改查遍历操作. d={'天':95,'青':78,'色':65,'等':66}print('学生成绩字典:',d)d['烟']=98print('增加:',d)d.pop('等')print('删除:',d)d['天']=78print('修改:',d)print('查询青成绩:',d.get('青','无')) 2.列表,元组,字典,集合的遍历.总结列表,元组,字典,集合的联系与区别. s=list('123456789')t=set('7564231

python基础知识——基本的数据类型2——列表，元组，字典，集合

磨人的小妖精们啊!终于可以归置下自己的大脑啦,在这里我要把--整型,长整型,浮点型,字符串,列表,元组,字典,集合,这几个知识点特别多的东西,统一的捯饬捯饬,不然一直脑袋里面乱乱的. 一.列表 1.列表的全部方法 如:['1','2'].['wupeiqi', 'alex'] 1 >>> dir(list) 2 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '_

python的列表，元组和字典简单介绍

引 入 java                                   python 存取多个值:数组或list集合 ------------------------> 列表,元组 key-value格式:    Map        ------------------------>    字典 自己学习发现,java跟python这两门面向对象语言在数据类型的定义上,很多思想都是互通的,这里不说java,简单介绍一下python的列表,元组和字典. 一.列表 List: 最通

Python学习笔记六：列表、元组、字典

学习其他语言很少关注数组是的结构是怎么回事,都是直接使用.Python定义了列表.元组.字典三种数据结构,是我们使用python的基础,因此有必要理解它们的含义,我想这个和python一切皆对象的思想有关.python的数据结构更加灵活. 1. 列表[lists] 序列是Python中最基本的数据结构.序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推. Python有6个序列的内置类型,但最常见的是列表和元组. 序列都可以进行的操作包括索引,切片,加