Python基础-列表_元组_字典

本节内容

列表、元组操作
字符串操作
字典操作
集合操作
文件操作
字符编码与转码

1. 列表、元组操作

列表是我们最以后最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作

定义列表示例

 names = ["ZhangYang"," Guyun"," Xiangpeng"," XuLiangChen"]

通过下标访问列表中的元素，下标从0开始计数

 >>> names[0]

 'ZhangYang'

切片示例1

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: huzhihua

 names = "ZhangYang Guyun Xiangpeng XuLiangChen"

 names = ["ZhangYang"," Guyun"," Xiangpeng"," XuLiangChen"]

 print(names)

 print(names[0],names[2])

 print(names[1:3])       #这就是切片（从0开始切，0就是ZhangYang）

执行结果：

 ['ZhangYang', ' Guyun', ' Xiangpeng', ' XuLiangChen']

 ZhangYang  Xiangpeng

 [' Guyun', ' Xiangpeng']

切片示例2

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = "ZhangYang Guyun Xiangpeng XuLiangChen"

 names = ["ZhangYang"," Guyun"," Xiangpeng"," XuLiangChen"]

 print(names)

 print(names[0],names[2])

 print(names[1:3])  #这就是切片（从0开始，取下标1至下标3之间的数字，包括1，不包括3）
print(names[3])    #取第3个值，从0从始取
print(names[-2])   #在不知道是多长的情况下，取出最后2个位置 
print(names[-2:])  #要取最后面的值，把-1省略掉 
print(names[0:3])  #取从0-3
print(names[:3])   #如果是从头开始取，0可以忽略，跟上句效果一样

执行结果：

 ['ZhangYang', ' Guyun', ' Xiangpeng', ' XuLiangChen']

 ZhangYang  Xiangpeng

 [' Guyun', ' Xiangpeng']

  XuLiangChen

  Xiangpeng

 [' Xiangpeng', ' XuLiangChen']

 ['ZhangYang', ' Guyun', ' Xiangpeng']

 ['ZhangYang', ' Guyun', ' Xiangpeng']

追加示例

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = "ZhangYang Guyun Xiangpeng XuLiangChen"

 names = ["ZhangYang"," Guyun"," Xiangpeng"," XuLiangChen"]

 names.append("LeiHaidong")   #追加到最后一行

 print(names)

执行结果：

 ['ZhangYang', ' Guyun', ' Xiangpeng', ' XuLiangChen', 'LeiHaidong']

插入示例

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = "ZhangYang Guyun Xiangpeng XuLiangChen"

 names = ["ZhangYang"," Guyun"," Xiangpeng"," XuLiangChen"]

 names.append("LeiHaidong")   #追加到最后一行

 names.insert(1,"nulige")     #插到那个位置 就写那个位置

 names.insert(3,"Xinzhiyu")   #插入3的位置，不能批量插入

 print(names)

执行结果：

 ['ZhangYang', 'nulige', ' Guyun', 'Xinzhiyu'' Xiangpeng', ' XuLiangChen', 'LeiHaidong']

修改示例

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = "ZhangYang Guyun Xiangpeng XuLiangChen"

 names = ["ZhangYang"," Guyun"," Xiangpeng"," XuLiangChen"]

 names.append("LeiHaidong")   #追加到最后一行

 names.insert(1,"nulige")     #插到那个位置 就写那个位置

 names.insert(3,"Xinzhiyu")   #插入3的位置，不能批量插入

 names[2] ="XieDi" 　　　　　　 #修改

 print(names)

执行结果：

 ['ZhangYang', 'nulige', 'XieDi', 'Xinzhiyu', ' Xiangpeng', ' XuLiangChen', 'LeiHaidong']

删除示例

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = "ZhangYang Guyun Xiangpeng XuLiangChen"

 names = ["ZhangYang"," Guyun"," Xiangpeng"," XuLiangChen"]

 names.append("LeiHaidong")   #追加到最后一行

 names.insert(1,"Nulige")     #插到那个位置 就写那个位置

 names.insert(3,"Xinzhiyu")   #插入3的位置，不能批量插入

 names[2] ="XieDi"

 #delete

 names.remove("Nulige")   #删除Nulige

 del names[1]

 print(names)

执行效果：

删除前效果：

['ZhangYang', 'Nulige', 'XieDi', 'Xinzhiyu', ' Xiangpeng', ' XuLiangChen', 'LeiHaidong']

删除后效果：

 ['ZhangYang', 'Xinzhiyu', ' Xiangpeng', ' XuLiangChen', 'LeiHaidong']

index示例
查找XieDi的位置，并将找到的结果打印出来

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = "ZhangYang Guyun Xiangpeng XuLiangChen"

 names = ["ZhangYang"," Guyun","XieDi"," Xiangpeng"," XuLiangChen"]

 # 查找XieDi的位置，并将找到的结果打印出来

 print(names)

 print(names.index("XieDi"))           #找到XieDi

 print(names[names.index("XieDi")])    #把他打印出来

执行结果：

 ['ZhangYang', ' Guyun', 'XieDi', ' Xiangpeng', ' XuLiangChen']

 2

 XieDi

拷贝示例1

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = ["4ZhangYang"," #!Guyun","xXieDi"," Xiangpeng"," XuLiangChen"]

 names2 = names.copy()

 print(names)

 print(names2)

执行结果:

 ['4ZhangYang', ' #!Guyun', 'xXieDi', ' Xiangpeng', ' XuLiangChen']

 ['4ZhangYang', ' #!Guyun', 'xXieDi', ' Xiangpeng', ' XuLiangChen']

拷贝示例2

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = ["4ZhangYang","#!Guyun","XiangPeng","ChenRonghua"]

 names2 = names.copy()

 print(names)

 print(names2)

 names[2] = "向鹏"

 print(names)

执行结果：

 ['4ZhangYang', '#!Guyun', 'XiangPeng', 'ChenRonghua']

 ['4ZhangYang', '#!Guyun', 'XiangPeng', 'ChenRonghua']

 ['4ZhangYang', '#!Guyun', '向鹏', 'ChenRonghua']

拷贝示例3

1、浅拷贝

示例1

浅拷贝就是浅浅的copy一层

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 #import copy

 names = ["4ZhangYang","#!Guyun","XiangPeng",["alex","jack"],"ChenRonghua"]

 names2 = names.copy()

 print(names)

 print(names2)

 names[2] = "向鹏"

 names[3][0] = "ALEXANDER"    #注意：复制列表，只会复制一层

 print(names)

 print(names2)

执行结果:

 ['4ZhangYang', '#!Guyun', 'XiangPeng', ['alex', 'jack'], 'ChenRonghua']

 ['4ZhangYang', '#!Guyun', 'XiangPeng', ['alex', 'jack'], 'ChenRonghua']

 ['4ZhangYang', '#!Guyun', '向鹏', ['ALEXANDER', 'jack'], 'ChenRonghua']

 ['4ZhangYang', '#!Guyun', 'XiangPeng', ['ALEXANDER', 'jack'], 'ChenRonghua']   #只拷贝了第一层，所以向鹏没有变

示例2

运行结果报错，后期再解决

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 import copy

 person=['name',['a',100]]

 #p1=copy.deepcopy(person)

 p1=copy.copy(person)

 p2=person[:]

 p3=list(person)

结果省略...

示例3

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 person = ['name',['saving',100]]

 p1=person[:]

 p2=person[:]

 p1[0]='alex'

 p2[0]='fenjie'

 p1[1][1]=50    #浅拷贝的作用，用于创建联合账号（100元，两人的两个账号各分一半，变成两个50元）

 print(p1)

 print(p2)

执行结果:

 ['alex', ['saving', 50]]

 ['fenjie', ['saving', 50]]

2、深拷贝

此实验还有点小问题，后期修改。

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 import copy

 names = ["4ZhangYang","#!Guyun","XiangPeng",["alex","jack"],"ChenRonghua"]

 #names2 = names.copy()

 #names2 = copy.copy(names)

 names2 = copy.deepcopy(names)

 print(names)

 print(names2)

 names[2] = "向鹏"

 names[3][0] = "ALEXANDER"    #注意：复制列表，只会复制一层

 print(names)

 print(names2)

执行结果：省略......

列表循环

用for实现列表循环

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 #定义一个列表

 names = ["4ZhangYang","#!Guyun","XiangPeng",["alex","jack"],"ChenRonghua"]

 for i in names:

     print(i)

执行结果：

 4ZhangYang

 #!Guyun

 XiangPeng

 ['alex', 'jack']

 ChenRonghua

跳着切片示例

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 #跳着切片

 names = ["4ZhangYang","#!Guyun","XiangPeng",["alex","jack"],"ChenRonghua","Xuliangche"]

 print(names[0:-1:2])

 print(names[::2])

 print(names[:])   #0到-1

 for i in names:

     print(i)

执行结果:

 ['4ZhangYang', 'XiangPeng', 'ChenRonghua']

 ['4ZhangYang', 'XiangPeng', 'ChenRonghua']

 ['4ZhangYang', '#!Guyun', 'XiangPeng', ['alex', 'jack'], 'ChenRonghua', 'Xuliangche']

 4ZhangYang

 #!Guyun

 XiangPeng

 ['alex', 'jack']

 ChenRonghua

 Xuliangche

元组 (也叫不可变列表)

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

语法

names = ("ales","jack","eric")

它只有两个方法，一个是count,一个是index。

示例：

 #定义一个元组

 tuple1 = (1, 2, '', 4, '')

 # 定义了一个元组之后就无法再添加或修改元组中的元素

 print tuple1[0]    # 元组的元素都有确定的顺序。元组的索引也是以0为基点的

 print tuple1[-1]   # 负的索引从元组的尾部开始计数

 print tuple1[1:3]  # 元组也可以进行切片操作。对元组切片可以得到新的元组。

 # 可以使用 in 运算符检查某元素是否存在于元组中。

 print 1 in tuple1   # True

 #使用for in 进行遍历元组

 for item in tuple1:

     print item

 # 如果需要获取item的序号 可以使用下面的遍历方法：

 for index in range(len(tuple1)):

     print tuple1[index]

 # 还可以使用内置的enumerate函数

 for index, item in enumerate(tuple1):

     print '%i, %s' % (index, item)

统计示例

#统计有两个XieDi

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = "ZhangYang Guyun Xiangpeng XuLiangChen "

 names = ["ZhangYang"," Guyun","XieDi"," Xiangpeng"," XuLiangChen"]

 names.append("LeiHaidong")

 names.insert(1,"ChenRonghua")

 names.insert(3,"Xinzhiyu")   #插入

 names[2] ="XieDi"            #修改

 print(names)

 print(names.count("XieDi"))

执行结果：

 ['ZhangYang', 'ChenRonghua', 'XieDi', 'Xinzhiyu', 'XieDi', ' Xiangpeng', ' XuLiangChen', 'LeiHaidong']

 2

清除示例

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = "ZhangYang Guyun Xiangpeng XuLiangChen "

 names = ["ZhangYang"," Guyun","XieDi"," Xiangpeng"," XuLiangChen"]

 names.append("LeiHaidong")

 names.insert(1,"ChenRonghua")

 names.insert(3,"Xinzhiyu")   #插入

 names[2] ="XieDi"            #修改

 print(names)

 print(names.count("XieDi"))

 #clear

 names.clear()

 print(names)

执行结果

 ['ZhangYang', 'ChenRonghua', 'XieDi', 'Xinzhiyu', 'XieDi', ' Xiangpeng', ' XuLiangChen', 'LeiHaidong']

 2

 []

反转示例1

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = "ZhangYang Guyun Xiangpeng XuLiangChen "

 names = ["ZhangYang"," Guyun","XieDi"," Xiangpeng"," XuLiangChen"]

 names.append("LeiHaidong")

 names.insert(1,"ChenRonghua")

 names.insert(3,"Xinzhiyu")   #插入

 names[2] ="XieDi"            #修改

 print(names)

 print(names.count("XieDi"))

 #reverse

 names.reverse()

 print(names)

执行结果：

 ['ZhangYang', 'ChenRonghua', 'XieDi', 'Xinzhiyu', 'XieDi', ' Xiangpeng', ' XuLiangChen', 'LeiHaidong']

 2

 ['LeiHaidong', ' XuLiangChen', ' Xiangpeng', 'XieDi', 'Xinzhiyu', 'XieDi', 'ChenRonghua', 'ZhangYang']    #对比第一行，反转过来了

反转示例2

 >>> names

 ['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]

 >>> names.sort() #排序

 Traceback (most recent call last):

   File "<stdin>", line 1, in <module>

 TypeError: unorderable types: int() < str()   #3.0里不同数据类型不能放在一起排序了，擦

 >>> names[-3] = ''

 >>> names[-2] = ''

 >>> names[-1] = ''

 >>> names

 ['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '', '', '']

 >>> names.sort()

 >>> names

 ['', '', '', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']

排序示例

按ASCII码顺序进行排序的

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = ["4ZhangYang"," #!Guyun","xXieDi"," Xiangpeng"," XuLiangChen"]

 print(names)

 #排序(sort)

 names.sort()

 print(names)

执行结果：

 ['4ZhangYang', ' #!Guyun', 'xXieDi', ' Xiangpeng', ' XuLiangChen']

 [' #!Guyun', ' Xiangpeng', ' XuLiangChen', '4ZhangYang', 'xXieDi']

扩展示例

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = ["4ZhangYang"," #!Guyun","xXieDi"," Xiangpeng"," XuLiangChen"]

 print(names)

 names2 = [1,2,3,4]

 names.extend(names2)

 print(names)

执行结果：

 ['4ZhangYang', ' #!Guyun', 'xXieDi', ' Xiangpeng', ' XuLiangChen']

 ['4ZhangYang', ' #!Guyun', 'xXieDi', ' Xiangpeng', ' XuLiangChen', 1, 2, 3, 4]

删除列表中的变量示例

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 names = ["4ZhangYang"," #!Guyun","xXieDi"," Xiangpeng"," XuLiangChen"]

 print(names)

 names2 = [1,2,3,4]

 names.extend(names2)

 del names2

 print(names,names2)

执行结果：

会报错，因为找不到nemes2变量的值

 Traceback (most recent call last):

 ['4ZhangYang', ' #!Guyun', 'xXieDi', ' Xiangpeng', ' XuLiangChen']

   File "D:/python/day2/name_test02.py", line 11, in <module>

     print(names,names2)

 NameError: name 'names2' is not defined

字符串操作

 >>> a = 'alex'

 >>> a [1]

 'l'

 >>> a[2]

 'e'

 #备注：列表不能直接赋值

 >>> a[2] = ''

 Traceback (most recent call last):

   File "<stdin>", line 1, in <module>

 TypeError: 'str' object does not support item assignment

集合操作

集合的元素是不允许重复且无序的集合，集合就像是字典舍弃了值一样。

主要作用如下：

去重，把一个列表变成集合，就自动去重了
关系测试，测试两组数据之前的交集、差集、并集等关系

 s = set([3,5,9,10])      #创建一个数值集合  

 t = set("Hello")         #创建一个唯一字符的集合  

 a = t | s          # t 和 s的并集  

 b = t & s          # t 和 s的交集  

 c = t – s          # 求差集（项在t中，但不在s中）  

 d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）  

 基本操作：  

 t.add('x')            # 添加一项  

 s.update([10,37,42])  # 在s中添加多项  

 使用remove()可以删除一项：  

 t.remove('H')  

 len(s)

 set 的长度  

 x in s

 测试 x 是否是 s 的成员  

 x not in s

 测试 x 是否不是 s 的成员  

 s.issubset(t)

 s <= t

 测试是否 s 中的每一个元素都在 t 中  

 s.issuperset(t)

 s >= t

 测试是否 t 中的每一个元素都在 s 中  

 s.union(t)

 s | t

 返回一个新的 set 包含 s 和 t 中的每一个元素  

 s.intersection(t)

 s & t

 返回一个新的 set 包含 s 和 t 中的公共元素  

 s.difference(t)

 s - t

 返回一个新的 set 包含 s 中有但是 t 中没有的元素  

 s.symmetric_difference(t)

 s ^ t

 返回一个新的 set 包含 s 和 t 中不重复的元素  

 s.copy()

 返回 set “s”的一个浅复制

常用操作

交集(intersection)

两组列表中，取相同的值

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 list_1 = [1,4,5,7,3,6,7,9]

 list_1 = set(list_1)

 print(list_1,type(list_1))

 list_2 = ([2,6,0,66,22,8,4])

 print(list_1,list_2)

 #交集

 print( list_1.intersection(list_2) )

执行结果：

 {1, 3, 4, 5, 6, 7, 9} <class 'set'>

 {1, 3, 4, 5, 6, 7, 9} [2, 6, 0, 66, 22, 8, 4]

 {4, 6}

并集（union)

两个列表合并成一个，去掉重复的值

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 list_1 = [1,4,5,7,3,6,7,9]

 list_1 = set(list_1)

 print(list_1,type(list_1))

 list_2 = ([2,6,0,66,22,8,4])

 print(list_1,list_2)

 #并集

 print(list_1.union(list_2))

执行结果：

 {1, 3, 4, 5, 6, 7, 9} <class 'set'>

 {1, 3, 4, 5, 6, 7, 9} [2, 6, 0, 66, 22, 8, 4]

 {0, 1, 2, 3, , 5, , 7, 66, 9, 8, 22}

差集(difference)

只保留list1里面有的，list2中没有的值。

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 list_1 = [1,4,5,7,3,6,7,9]

 list_1 = set(list_1)

 print(list_1,type(list_1))

 list_2 = ([2,6,0,66,22,8,4])

 print(list_1,list_2)

 #差集

 print(list_1.difference(list_2))
14 print(list_2.difference(list_1))

执行结果：

 {1, 3, 4, 5, 6, 7, 9} <class 'set'>

 {1, 3, 4, 5, 6, 7, 9} [2, 6, 0, 66, 22, 8, 4]

 {1, 3, 5, 7, 9}
4 {0,8,2,66,22}

对称差集（symmetric_difference）

把交集去掉了，留下的不是并集，把两个互相都没有的，取出来。

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 list_1 = [1,4,5,7,3,6,7,9]

 list_1 = set(list_1)

 list_2 = ([2,6,0,66,22,8,4])

 print(list_1,list_2)

 #反向差集

 print(list_1.symmetric_difference(list_2))

执行结果：

 {1, 3, 4, 5, 6, 7, 9} [2, 6, 0, 66, 22, 8, 4]

 {0, 1, 2, 66, 3, 5, 8, 7, 9, 22}

isdisjoint

判断有没有交集，如果有返回False，否则返回True

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 list_1 = [1,4,5,7,3,6,7,9]

 list_1 = set(list_1)

 list_2 = ([2,6,0,66,22,8,4])

 print(list_1,list_2)

 #子集

 list_3 = set([1,3,7])

 print(list_3.issubset(list_1))

 print(list_1.issubset(list_3))

16 print("---------------------------------")

17 list_4 = set([5,6,8])

18 print(list_3.isdisjoint(list_4))

执行结果：

 {1, 3, 4, 5, 6, 7, 9} [2, 6, 0, 66, 22, 8, 4]

 True

 False

 ---------------------------------

 True

判断有没有交集，如果有返回False，否则返回True

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 list_1 = [1,4,5,7,3,6,7,9]

 list_1 = set(list_1)

 list_2 = ([2,6,0,66,22,8,4])

 print(list_1,list_2)

 #子集

 list_3 = set([1,3,7])

 print(list_3.issubset(list_1))

 print(list_1.issubset(list_3))

16 print("---------------------------------")

17 list_4 = set([5,6,7,8])

18 print(list_3.isdisjoint(list_4))

执行结果：

 {1, 3, 4, 5, 6, 7, 9} [2, 6, 0, 66, 22, 8, 4]

 True

 False

4 ---------------------------------

5 False

子集(issubset)

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 list_1 = [1,4,5,7,3,6,7,9]

 list_1 = set(list_1)

 list_2 = ([2,6,0,66,22,8,4])

 print(list_1,list_2)

 #差集

 print( list_1.intersection(list_2))

 #子集

 list_3 = set([1,3,7])

 print(list_3.issubset(list_1))

 print(list_1.issubset(list_3))

执行结果：

 {1, 3, 4, 5, 6, 7, 9} [2, 6, 0, 66, 22, 8, 4]

 {4, 6}

 True

 False

交集、并集、差集、对称差集另一种用法

 #交集(intersection)

 print(list_1 & list_2)

 #并集 union

 print(list_2 | list_1)

 #差集 difference (in list 1 but not in list 2)

 print(list_1 - list_2)

 #对称差集

 print(list_1 ^ list_2)

常用操作

 #!/usr/bin/env python

 # -*- coding:utf-8 -*-

 #Author: nulige

 list_1 = [1,4,5,7,3,6,7,9]

 list_1 = set(list_1)

 list_2 = ([2,6,0,66,22,8,4])

 print(list_1,list_2)

 #添加一项(无序插入）

 list_1.add(999)

 print(list_1)

 #添加多项

 list_1.update([888,777,555])

 print(list_1)

 #pop (删除）

 # Remove and teturn an arbitrary set element.

 # 删除一个，并返回一个任意的

 print(list_1.pop())

 print(list_1.pop())

 print(list_1.pop())

 print(list_1.pop())

 #discard

 print( list_1.discard(888) )

执行结果：

 {1, 3, 4, 5, 6, 7, 9} [2, 6, 0, 66, 22, 8, 4]

 {1, 3, 4, 5, 6, 7, 999, 9}

 {1, 3, 4, 5, 6, 7, 999, 9, 777, 555, 888}

 1

 3

 4

 5

 None

Python基础-列表_元组_字典_集合的更多相关文章

Python基础-列表、元组、字典、字符串
Python基础-列表.元组.字典.字符串多维数组 nums1 = [1,2,3] #一维数组 nums2 = [1,2,3,[4,56]] #二维数组 nums3 = [1,2,3,4,['a ...
Python中列表，元组，字典，集合的区别
参考文档https://blog.csdn.net/Yeoman92/article/details/56289287 理解Python中列表,元组,字典,集合的区别列表,元组,字典,集合的区别是p ...
Python中列表、元组、字典、集合与字符串，相关函数，持续更新中……
本篇博客为博主第一次学 Python 所做的笔记(希望读者能够少点浮躁,认真阅读,平心静气学习!) 补充: 列表.元组和字符串共同属性: 属于有序序列,其中的元素有严格的先后顺序都支持双向索引,索引 ...
python基础语法3 元组，字典，集合
元组: ========================元组基本方法===========================用途:存储多个不同类型的值定义方式:用过小括号存储数据,数据与数据之间通过逗号 ...
Python自动化【第二篇】：Python基础-列表、元组、字典
本节内容模块初识 .pyc简介数据类型初识数据运算列表.元组操作字符串操作字典操作集合操作字符编码与转码一.模块初识 Python的强大之处在于他有非常丰富和强大的标准库和第三方库, ...
Python基础-列表、元组、字典、字符串（精简解析），全网最齐全。
一.列表 =====================================================1.列表的定义及格式: 列表是个有序的,可修改的,元素用逗号隔开,用中括号包围的序列 ...
Python基础-列表、元组、字典、字符串（精简解析）
一.列表 =====================================================1.列表的定义及格式: 列表是个有序的,可修改的,元素用逗号隔开,用中括号包围的序列 ...
python基础——5（元组、字典、集合）
上节复习: # 数字类型 # int:py3|py2 long:py2 # float: 3.14 # complex(5, 4) => 5 + 4j num = 12345678901234 ...
Python之列表、元组、字典、集合及字符串的详细使用
1.列表列表相当与C++中的数组,是有序的项目, 通过索引进行查找,但使用起来却方便很多,具体的操作看代码,自己实践一次就非常简单了. 注:列表一般用中括号“[ ]” #列表(数组) name_li ...
python基础知识3——基本的数据类型2——列表，元组，字典，集合
磨人的小妖精们啊!终于可以归置下自己的大脑啦,在这里我要把--整型,长整型,浮点型,字符串,列表,元组,字典,集合,这几个知识点特别多的东西,统一的捯饬捯饬,不然一直脑袋里面乱乱的. 一.列表 1.列 ...

随机推荐

php中的curl使用入门教程和常见用法实例
摘要: [目录] php中的curl使用入门教程和常见用法实例一.curl的优势二.curl的简单使用步骤三.错误处理四.获取curl请求的具体信息五.使用curl发送post请求六.文件 ...
大一上学期的一点小疑惑，代码验证ok
#include<iostream> using namespace std; class test { int *p; int pn; public: test(int n) { p = ...
【一周读书】All life is problem solving
书籍:<开放的智力> 采铜是我在知乎关注最早的大V之一,那时我脑里有一大堆疑惑和问题,是他的答案帮助我理清了思绪.我从他身上学习到对书籍的爱好,对思维方法的关注,对智慧的向往.读这本小集子 ...
CETV面试总结
在通过CETV的网上笔试之后,我收到了面试通知,我纠结片刻,就买了第二天去广州的高铁,虽然感觉自己硬件方面的知识已经快忘完了,但还是想去一下,起码是一种经历.对一个路痴和知识储备不足的我来讲,这一切都 ...
AC日记——回文子串 openjudge 1.7 34
34:回文子串总时间限制: 1000ms 内存限制: 65536kB 描述给定一个字符串,输出所有长度至少为2的回文子串. 回文子串即从左往右输出和从右往左输出结果是一样的字符串,比如:abb ...
KSFramework配置表：扩展表格解析类型
解析和扩展表格配置表示例配置表模块在编译时,把Excel转化成TSV,并根据Excel的头部信息,生成对应的代码: 比如源码库中的Test.xlsx Excel文件,两个列头,Id和Value,其 ...
[No000039]操作系统Operating Systems用户级线程User Threads
多进程是操作系统的基本图像是否可以资源不动而切换指令序列? 进程 = 资源 + 指令执行序列线程: 保留了并发的优点,避免了进程切换代价实质就是映射表不变而PC 指针变多个执行序列+ 一个地址 ...
转：Configure your eclipse for C++
from: http://omtlab.com/configure-your-eclipse-for-c/ Configure your eclipse for C++ July 7, 2013 Th ...
NSDate 哪些事
.什么是时间戳? 时间戳是自 1970 年 1 月 1 日(00:00:00 GMT)至当前时间的总秒数. 2.NSDate,时间戳,NSString 之间的转换 //string 转 date + ...
Oracle过程及函数的参数模式，In、out、in out模式
Oracle过程及函数的参数模式 In.out.in out模式在Oracle中过程与函数都可以有参数,参数的类型可以指定为in.out.in out三种模式. 三种参数的具体说明,如下图所示: ( ...

Python基础-列表_元组_字典_集合

1. 列表、元组操作

Python基础-列表_元组_字典_集合的更多相关文章

随机推荐

热门专题