【Python】列表、字典、元组、集合和字符串_python数字 字符串 列表 元组 字典

  本文是我在学习Python过程当中的心得和学习笔记，包含了Python的入门知识，控制结构，列表，字典，元组，集合，字符串，函数等等Python基础内容，并附上了学习的代码，仅供大家参考。如果有问题，有错误欢迎大家留言。剩余的内容可以通过 这篇文章找到。

一、列表

1.1列表

  列表类似于C语言当中的数组，只是Python的列表当中，列表的元素可以是整型、浮点型、布尔型、字符串型。同样的，列表对象也具有三个属性：标识，类型，值，这个和变量类似。

lst = [98,'人生苦短，我学Python',True,3.14]  #定义列表第一种方式
lst2 = list([98,'人生苦短，我学Python',True,3.14])  #定义列表第一种方式
print(type(lst))        
print(lst[0],lst[-1])   #索引可以从0开始，也可以从-1开始
1
2
3
4
'
运行
运行

1.2列表的索引

  正向索引，从0开始，到n-1；逆向索引，从-1开始，到-n结束。

lst = ['hello','人生苦短，我学Python',True,'hello']  #定义列表第一种方式
print(lst.index('hello'))   #打印hello元素的索引，如果有多个相同元素，则输出第一个索引
print(lst.index('hello',1,4))   #加上查找的区域，从索引1找到索引3，不包括4
print(lst.index('hello',1,5))   #加上查找的区域，从索引1找到索引4，列表最大索引只有3，但是不会报错
#print(lst.index('hello',1,3)) #如果找不到该元素就会报错，ValueError: 'hello' is not in list
1
2
3
4
5
'
运行
运行

  这里注意切片区间是在[start, stop)内，即包括start在内，但不包括stop在内的区间，若stop为空，则切片区间包含最后一个元素。

lst = [10,20,30,40,50,60,70,80]
#print(lst[start:stop:step])
print(lst[1:6:])    #切片默认步长为1
print(lst[1:6])     #切片默认步长为1
print(lst[1:6:1])
print(lst[:6:2])    #切片的第一个元素默认从索引0开始，不包括索引为6的元素
print(lst[1::2])    #切片的最后一个元素默认以索引N-1结束
#step为负数情况
print(lst[::-1])    #step = -1， 列表逆转
print(lst[7::-1])   #start = 7， step = -1， 列表逆转
print(lst[6:0:-2])  #不包括索引为0的元素
#列表的遍历
for item in lst:
    print(item);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'
运行
运行

1.3列表添加、删除元素

  python使用append、extend、insert、切片式添加列表元素

lst1 = [10 ,20 ,30]
lst1.append(100)        #在列表末尾添加这个元素
print(lst1)
lst2 = ['hello','world']
lst1.append(lst2)       #把lst2当做一个元素添加近lst1中
print(lst1)
lst1.extend(lst2)       #在列表末尾添加至少一个元素(可以多个)
print(lst1)
lst1.insert(1,90)        #在列表索引为1的位置添加元素90，之前的元素按顺序后移
print(lst1)
lst3 = [True, False, 'hello']
#在任意位置添加N多个元素，切片式添加
lst1[1:] = lst3
print(lst1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'
运行
运行

删除元素

lst = [10,20,30,40,50,60,70,80,90]
lst.remove(30)  #从列表中移除一个元素，如果有重复元素则移除第一个元素
print(lst)
#lst.remove(100) #若列表中不存在该元素，则抛出异常list.remove(x): x not in list

lst.pop(1)      #删除索引为1的元素
print(lst)
lst.pop()       #不给参数，就删除列表的最后一个元素
print(lst)

#切片操作，至少删除一个元素，产生一个新的列表对象
new_lst = lst[1:3]  #将原列表的索引1-3赋值给新列表
print('new_lst=',new_lst)
#不产生新列表
lst[1:3] = []
print(lst)
lst.clear()
print(lst)

del lst
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
'
运行
运行

修改元素

lst = [10,20,30,40,50]
lst[2] = 100    #修改列表单个元素
print(lst)
#修改列表多个元素，此处修改索引1和索引2，不包括索引3
#剩下的元素直接添加在后面，其余元素后移
lst[1:3] = [100,200,300,400,500]
print(lst)
1
2
3
4
5
6
7
'
运行
运行

1.4列表排序

使用sort()进行排序：

lst = [20,40, 10, 98, 54]
print('排序前的列表',lst,'id=',id(lst))
lst.sort()
print('排序后的列表',lst,'id=',id(lst))
#对比二者id,可以看出sort()是在原列表上做修改，没有产生心的列表
#指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)  #reverse=True表示降序，reverse=False表示升序
print(lst)
lst.sort(reverse=False)
print(lst)
1
2
3
4
5
6
7
8
9
10
'
运行
运行

使用内置函数sorted()进行排序：

#使用内置函数进行排序，会产生一个新的列表变量
lst = [20,40, 10, 98, 54]
print('原列表',lst)
new_lst = sorted(lst)#默认是升序
print(lst)
print(new_lst)
descend_list = sorted(lst,reverse=True)
print(descend_list)
1
2
3
4
5
6
7
8
'
运行
运行

1.5列表生成式

lst = [i for i in range(1,10)]
print(lst)
1
2
'
运行
运行

二、 字典

  字典是顺序不可变的序列，无需考虑元素顺序，用{ }表示，同时字典当中的元素是key-value成对存在。
  相比之下，列表是可变序列，列表需要考虑元素顺序，用[ ]表示，元素用index和element表示。

d = {'name':'张三','name':'李四'}
print(d)    #key值不允许重复,这里虽然定义了两个字典元素，但key值重复了，因此最终只输出一个

lst = [10,20,30]
lst.insert(1,100)
print(lst)
d = {lst:100}
print(d)    #key值必须是不可改变的，这里会报错unhashable type: 'list'
1
2
3
4
5
6
7
8

2.1 字典的创建

字典的实现原理：
  字典的实现原理与查字典类似，Python中的字典是根据key查找value所在的位置。

"""使用{}创建字典"""
scores = {'张三':100,'李四':98,'王五':45}
print(scores)
print(type(scores))

"""第二种创建dict()"""
student = dict(name='jack',age=20)
print(student)

"""空字典"""
d = {}
print(d)
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

2.2 字典元素的获取

  这里需要注意的是字典的key用[ ]，列表的索引用（ ），例如scores[‘张三’]，lst(1)

scores = {'张三':100,'李四':98,'王五':45}
"""第一种方式，使用[]"""
print(scores['张三'])
#print(scores['陈六']) #KeyError: '陈六'

"""第二种方式，使用get()方法"""
print(scores.get('张三'))
print(scores.get('陈六'))     #None
print(scores.get('麻七',99))  #99是在查找‘麻七’所对value不存在是的默认值
1
2
3
4
5
6
7
8
9
'
运行
运行

2.3 字典元素的增、删、改

scores = {'张三':100,'李四':98,'王五':45}
print('张三' in scores)
print('张三' not in scores)

del scores['张三']    #删除指定的key-value对
#scores.clear()      #清空字典的元素
print(scores)
scores['陈六']=98     #新增元素
print(scores)

scores['陈六']=100     #新增元素
print(scores)
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

2.4获取字典的视图

scores = {'张三':100,'李四':98,'王五':45}
#获取所有的key
keys = scores.keys()
print(keys)
print(type(keys))
print(list(keys))    #将所有的key组成的视图转换为列表

#获取所有的value
values = scores.values()
print(values)
print(type(values))
print(list(values)) #将所有的values组成的视图转换为列表

#获取所有的key-value对
items = scores.items()
print(items)
print(list(items)) #转换之后的列表元素是由元组（‘key’:value）组成
#字典的遍历
for item in scores:
    print(item,scores[item],scores.get(item))	
    #scores[item],scores.get(item)的作用是一样的
    #唯一的区别是，若找不到该元素，是否抛出异常，get（）不会抛出异常，返回None
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
'
运行
运行

2.5 字典生成式

#字典生成式
items = ['Fruits','Books','Others']
prices = [98,78,85,100,120]

d = {item.upper() : price for item , price in zip(items,prices) }
#将items和prices列表内的元素依次赋值给item和price
#然后打包成item:price类型，存入字典当中
#这里upper()是将item内的字母全部换成大写
print(d)
1
2
3
4
5
6
7
8
9
'
运行
运行

三、 元组

  我们可以通过对比对象增、删、改操作前后的id,确定是否可变，若一样，则为可变对象，不一样，则为不可变对象。

"""可变序列：列表，字典"""
lst = [10,26,45]
print(id(lst))
lst.append(300)
print(id(lst))
#这里前后输出的lst的id是不变的，说明改变前后是同一个列表，说明列表是可变的
"""不可变序列：字符串，元组"""
s = 'hello'
print(id(s))
s = s+'world'
print(id(s))
print(S)
1
2
3
4
5
6
7
8
9
10
11
12

3.1 元组的创建方式

'''第一种创建方式，使用()'''
t = ('python','world',98)
print(t)
print(type(t))

t1 = 'python','world',98    #省略了小括号
print(t1)
print(type(t1))

t2 = ('python',)    #元组仅有一个元素时要加,
print(t2)
print(type(t2))

'''第二种创建方式，使用内置函数tuple()'''
t3 = tuple( ('python','world',98) )
print(t3)
print(type(t3))

'''空列表、空字典、空元组的创建方式'''
lst = []
lst1 = list()

d = {}
d2 = dict()

t4 = ()
t5 = tuple()

print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
'
运行
运行

3.2 元组为不可变序列的原因

t = (10,[20,30],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
'''尝试将t[1]修改为100'''
print(id(100))
#t[1] = 100     #这里直接报错
'''由于[20,30]是列表，而列表是可变序列，所以可以向列表中添加元素，而列表的内存地址不变'''
t[1].append(100)    #向列表中添加元素
print(t,id(t[1]))   #可以看出t[1]的id地址没有变
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

3.3 元组的遍历

t = ('python','world',98)
'''第一种获取元组元素的方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
#print(t[3]) #tuple index out of range
'''遍历元组'''
for item in t:
    print(item)
1
2
3
4
5
6
7
8
9
'
运行
运行

四、集合

4.1 集合的创建

"""第一种创建方式使用{}"""
s = {2,3,4,5,5,6,7} #集合中的元素不允许重复
print(s)        #可以看到虽然集合定义中有两个5，但实际上只存在一个

"""第二种创建方式使用内置函数set()"""
s1 = set(range(6))  #使用range()产生[0,6)之间的整数序列，再通过set()将序列转成集合
print(s1,type(s1))

s2 = set([1,2,4,5,5,5,6,6]) #将[]构成的序列转成集合
print(s2,type(s2))

s3 = set((1,2,4,4,5,65))    #将元组中的元素转成集合
print(s3,type(s3))  #集合中的元素是无序的

s4 = set('python')
print(s4,type(s4))  #这里多运行几次，每次结果都不同，很容易看出集合元素是无序的

s5 = set({1,2,4,4,5,65})    #{}集合类型使用set()后还是集合类型
print(s5,type(s5))
#定义一个空集合
s6 ={}  #行不通，这样定义出来是dict字典类型
print(type(s6))

s7 = set()  #这个才是空集合的定义方法
print(type(s7))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
'
运行
运行

4.2 集合的判断及增、删

s = {10,20,30}
"""集合元素的判断操作"""
print(10 in s)  #True
print(100 in s) #False
print(10 not in s)  #False
print(100 not in s) #True
"""集合元素的新增操作"""
s.add(1)   #add一次添加一个元素
s.update({2,3})  #updata一次至少添加一个元素
s.update([4,5])
s.update((6,7))
print(s)

"""集合元素的删除操作"""
s.remove(1) #移除1
#s.remove(100)   #不存在key值为100的元素，抛异常，KeyError: 100
print(s)
s.discard(2)    #删除元素2
s.discard(100)  #不存在的元素，不抛异常
print(s)
s.pop()
#s.pop(5)#pop()函数没有参数，TypeError: set.pop() takes no arguments (1 given)
print(s)    #随机删除一个元素，不过这个随机也不是那么随机，应该是伪随机删除
s.clear()   #清空集合当中的所有元素
print(s)    #输出为set()，因此可以看出，set()就是空集合
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
'
运行
运行

4.3 集合之间的关系

"""两个集合是否相等(元素相同，就相等)"""
s = {10,20,30,40}
s2 = {30,40,20,10}
print(s==s2)    #True
print(s!=s2)    #False
"""一个集合是否是另外一个集合的子集"""
s1 = {10,20,30,40,50,60}
s2 = {10,20,30,40}
s3 = {10,20,90}
print(s2.issubset(s1))    #True
print(s3.issubset(s1))    #False
"""一个集合是否是另外一个集合的超集(母集)"""
print(s1.issuperset(s2))    #True
print(s1.issuperset(s3))    #False
"""两个集合是否含有交集"""
print(s2.isdisjoint(s3))    #False  有交集为FALSE
s4 = {100,200,300}
print(s2.isdisjoint(s4))    #True   没有交集为TRUE
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'
运行
运行

4.4 集合的数学操作

#1、交集
s1 = {10,20,30,40}
s2 = {20,30,40,50,60}
print('s1和s2的交集：',s1.intersection(s2))
print('s1和s2的交集：',s1 & s2)  #与intersection()与 & 等价，交集操作
print(s1)
print(s2)   #求交集操作不会影响原来的集合，以下的集合操作同样如此
#2、并集操作
print('s1和s2的并集：',s1.union(s2))
print('s1和s2的并集：',s1 | s2)  #union与 | 等价，并集操作
#3、差集操作
print('s1和s2的差集：',s1.difference(s2))
print('s1和s2的差集：',s1 - s2)
#4、对称差集操作
print('s1和s2的对称差集：',s1.symmetric_difference(s2))
print('s1和s2的对称差集：',s1 ^ s2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
'
运行
运行

4.5 集合生成式

  集合生成式与列表生成式类似，将[ ]改为{ }即为集合生成式，如下：

s = {i for i in range(1,10)}
print(s,type(s))
1
2
'
运行
运行

4.6 列表、元组、字典、集合总结

五、字符串

5.1 字符串的驻留机制

a = 'python'
b = "python"
c = '''python'''
print(a,id(a))
print(b,id(b))
print(c,id(c))
#从输出结果可以看出，虽然创建了三个字符创， 但其ID都是一样的，这就是Python的驻留机制。
1
2
3
4
5
6
7
'
运行
运行

  这里的交互模式就是在cmd当中输入Python进行操作。

  运行以下代码，可以看出，创建a后在创建b，python使用了驻留机制，即a b的ID相同。而后面再用join( )创建c，可以看出c的ID与a b不同。驻留机制是在编译器编译是起效，join( )函数是在代码运行时起效，因此在创建c时驻留机制不起效。

a = 'abc'
b = "ab"+'c'
c = ''''''.join(['ab','c'])
print(a is b)
print(a is c)
print(a,id(a),type(a))
print(b,id(b),type(b))
print(c,id(c),type(c))
1
2
3
4
5
6
7
8
'
运行
运行

5.2 字符串的查找

s = 'hello,hello'
#字符创对应索引
#           h  e  l  l  o  ,  h  e l  l  o
#正向索引    0   1  2  3  4  5  6  7  8  9 10
#逆向索引   -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
print(s.index('lo'))    #3，子串第一次出现的索引
print(s.find('lo'))     #3
print(s.rindex('lo'))   #9，子串最后一次出现的索引
print(s.rfind('lo'))    #9

#print(s.index('k'))     #3，找不到就报错，ValueError: substring not found
print(s.find('k'))      #-1，找不到不报错，返回-1
#print(s.rindex('k'))    #3，找不到就报错，ValueError: substring not found
print(s.rfind('k'))     #-1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'
运行
运行

5.3 字符串的各种操作

5.3.1 字符串对齐

对齐操作和填充操作

s = 'hello,python'  #原字符串长度为12
"""居中对齐"""
print(s.center(20,'*')) #字符串长度设置为20，居中对齐，然后以*进行填充
"""左对齐"""
print(s.ljust(20,'*'))  #左对齐
print(s.ljust(10))      #设置宽度小于原字符，返回原字符
print(s.ljust(20))      #默认以空格进行填充
"""右对齐"""
print(s.rjust(20,'*'))  #右对齐
print(s.rjust(20))      #默认以空格进行填充
print(s.rjust(10))      #设置宽度小于原字符，返回原字符
"""右对齐，使用0进行填充"""
print(s.zfill(20))
print(s.zfill(10))
print('-8910'.zfill(8)) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'
运行
运行

5.3.2 字符串比较和切片操作

  这里的ordinal value指的就是ASCII码。

print('apple'>'app')    #True，字符依次比较，到第四个时是'l'>'',因此结果为True
print('apple'>'banana') #False，相当于比较第一个字符'a'和'b'，相当于97>98，结果为False
#字符对应ASCII值
print(ord('a'),ord('b'))
print(ord('黄'))
#根据ASCII值得到字符
print(chr(97),chr(98))
print(chr(40644))
"""==与is的区别
    ==比较的是value
    is比较的是ID
"""
a = b = 'python'
c = 'python'
print(a==b,b==c) #True，值相等
print(a is b,a is c)#True，内存地址相等
print(id(a),id(b),id(c))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'
运行
运行

字符串的切片操作

'''字符串的切片操作'''
s = 'hello,python'
# [start:end:step]
s1 = s[:5]  #从0开始，5结束，不包含5，默认步长为1
s2 = s[6:]  #从6开始，直至字符串末尾，默认步长为1
s3 = '!'
newstr = s1 + s2 + s3
print(s1)
print(s2)
print(s3)
print(newstr)
s4 = s[ : : -1] #字符串倒序
print(s4)
1
2
3
4
5
6
7
8
9
10
11
12
13
'
运行
运行

5.3.3 字符串的格式化输出

'''字符串格式化输出（占位符的使用）'''
name = '张三'
age = 20
print('我叫%s,今年%d岁' % (name,age))
print('我叫{0},今年{1}岁'.format(name,age))
print(f'我叫{name},今年{age}岁') #f-string方法
'''数字输出精度和字符串宽度'''
print('%10d' % 99)  #10表示的是宽度,不足的部分用空格替代
print('%.3f' % 3.1415926)  #.3表示取三位小数，四舍五入制
print('%10.3f' % 3.1415926)  #两者混合使用
print('hellohello') #一共十个字符，作为上述输出的对比
#与保留三位小数.3f不同，这里使用的是.3表示一共有效数字为3位（包含整数和小数）
print('{0:.3}'.format(3.1415926))
#宽度为10，小数保留三位
print('{0:10.3f}'.format(3.1415926))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
'
运行
运行

5.4 字符串的各种函数

5.4.1 大小写转换函数

s = 'hello,python'
a = s.upper()   #转换成大写之后，会产生一个新的字符串对象
print(a,id(a))
print(s,id(s))
b = s.lower()   #转换成小写之后，同样会产生一个新的字符创对象
print(b,id(b))
print(s,id(s))
print( b == s ) #True,比较的是value
print(b is s)   #False,比较的是ID
s2 = 'hello,Python'
print(s2.swapcase())
print(s2.title())
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

5.4.2 分割函数split( )

s = 'hello world python'
lst = s.split() #默认以空格进行分割
print(lst)
s1 = 'hello|world|python'
print(s1.split(sep = '|'))  #以|进行分割
print(s1.split(sep = '|',maxsplit=1))   #以|进行分割，只分割一次
"""rsplit()从右侧开始分割"""
print(s.rsplit())
print(s1.rsplit('|'))
print(s1.rsplit('|',1))
1
2
3
4
5
6
7
8
9
10
'
运行
运行

5.4.3 判断函数 isidentifier( )

  这些Python的内置函数主要用在开发时，判断用户输入的字符串是否合法。

s = 'hello,python'
#标识符由字母、下划线和数字组成，但第一个字符不能是数字
print('1',s.isidentifier()) #False
print('2','hello'.isidentifier()) #True
print('3','张三_'.isidentifier()) #True，说明Python可以将汉字作为合法的标志符
print('4','张三_123'.isidentifier()) #True

print('5','\t'.isspace()) #True

print('6','abc'.isalpha()) #True
print('7','张三'.isalpha()) #True,Python将汉字看作字母
print('8','张三1'.isalpha()) #False

print('9','123'.isdecimal()) #True
print('10','123四'.isdecimal()) #False,四不是十进制数
print('11','Ⅱ'.isdecimal()) #False，罗马数字不是十进制数

print('12','123'.isnumeric()) #True
print('13','123四'.isnumeric()) #True，Python将‘四’看作数字
print('14','Ⅱ'.isnumeric()) #True，罗马数字是数字
#alnum = alpha + num
print('15','abc1'.isalnum()) #True
print('16','张三123'.isalnum()) #True
print('17','abc!'.isalnum()) #False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
'
运行
运行

5.4.4 替换和合并 / replace( )和joint( )

替换与合并

s = 'hello,python'
print(s.replace('python','jave'))   #用jave去替换Python
s1 = 'hello,python,python,python'
print(s1.replace('python','jave',2))    #替换两次
#使用join()函数，将列表转化为字符串
lst = ['hello','jave','python']
print('|'.join(lst))    #用|隔开
print(''.join(lst))     #不隔开
#元组转化为字符串
t = ('hello','jave','python')
print(''.join(t))
print('*'.join('python'))   #'python'字符串用*隔开
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

5.5字符串的编码与解码

'''字符串编码与解码'''
s = '天涯共此时'
print(s.encode(encoding='GBK')) #在GBK这种编码格式当中，一个中文占两个字节
print(s.encode(encoding='UTF-8')) #在GBK这种编码格式当中，一个中文占三个字节
byte = s.encode(encoding='GBK') #GBK格式编码
#byte代表一个二进制数据
print(byte.decode(encoding='GBK')) #GBK格式解码
1
2
3
4
5
6
7
'
运行
运行