本篇主要描述了Python中的字符串(str)、列表(str)、元组(tuple)、字典(dict)、集合(set)的特点以及使用
字符串(str)
字符串的定义
定义字符串可以使用单引号',双引号",三单引号''',三双引号"""，如下图
定义字符串
使用三单引号
'''或三双引号"""可以实现多行文本
字符串的连接
Python中的字符串连接可以使用+号来实现
连接字符串
但是
+号只能够连接两个字符串，如果要实现字符串与其他类型的值连接，例如int型，则需要把int数据通过str()函数或者是repr()函数将int数据转为字符串后才能够实现连接，如下图
连接字符串
转义字符
转义字符并不是只有Python才有的，跟其他语言一样，Python可以使用转义字符来表示一些特殊的字符，下表是一些常用的转义字符
| 转义字符 | 描述 |
|---|---|
| \(在行尾时) | 续行符 |
| \\ | 反斜杠符号 |
| ' | 单引号 |
| " | 双引号 |
| \a | 响铃 |
| \b | 退格(Backspace) |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy | 十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other | 其它的字符以普通格式输出 |
索引和切片
字符串是由一个或多个字符组成的有序的值，如下图，0就是字符串p的索引,字母i的索引就是7,索引可以从左到又，索引值从0开始，也可以从右到左，索引值从-1开始
>>> s6='python is good'
>>> s6[1]
'y'
>>> s6.index('I')
7
如果需要截取字符串中的部分字符串，截取出来的可以称之为切片
>>> s6[2:11]
'thon is g'
>>> s6[2:]
'thon is good'
>>> s6[:7]
'python '
>>> s6[:99]
'python is good'
>>> s6[-8:-4]
' is '
>>> s6[-8:]
' is good'
>>> s6[:-4]
'python is '
>>> s6[1:11:2]
'yhni '
-
s6[2:11]表示字符串s6取索引值为2-10的字符 -
s6[2:]表示取索引值为2之后的字符 -
s6[:7]表示取索引值为7之前的字符 -
s6[:99]当索引值超出之后，则会取得所有字符，但是并不提倡这样做 -
s6[-8:-4]表示从右到左，取-8到-4之间到字符其实s6[-8:-4]=s6[len(s6)-8:len(s6)-4]=s6[14-8:14-4]=s6[6:10] -
s6[-8:]表示从右到左，取索引值为-8之后到所有字符 -
s6[:-4]表示从右到左取索引值为-4之前到所有字符 -
s6[1:11:2]表示取索引值为1-10之间的字符，步长为2
列表(list)
列表的定义
在Python中，列表使用方括号[]定义，相对其他语言，Python的列表中元素并不会限定必须类型统一,列表的内容可以是字符串，数字，甚至是一个列表，元组，字典或者是集合
>>> l1=[]
>>> l1.append(1)
>>> l1.append("str")
>>> l1.append(["list1","list2"])
>>> l1.append(("123",123))
>>> l1.append({"456":456})
>>> l1.append(set('test'))
>>> l1
[1, 'str', ['list1', 'list2'], ('123', 123), {'456': 456}, {'s', 'e', 't'}]
>>> type(l1[0])
<class 'int'>
>>> type(l1[1])
<class 'str'>
>>> type(l1[2])
<class 'list'>
>>> type(l1[3])
<class 'tuple'>
>>> type(l1[4])
<class 'dict'>
>>> type(l1[5])
<class 'set'>
索引和切片
列表和字符串一样，都有索引和切片，但与字符串不同但是，列表但索引得到但是列表中的一个项
>>> l1[0]
1
>>> l1[1]
'str'
>>> l1[2:4]
[['list1', 'list2'], ('123', 123)]
>>> l1[:4]
[1, 'str', ['list1', 'list2'], ('123', 123)]
>>> l1[2:]
[['list1', 'list2'], ('123', 123), {'456': 456}, {'s', 'e', 't'}]
>>> l1[-1:]
[{'s', 'e', 't'}]
>>> l1[:-1]
[1, 'str', ['list1', 'list2'], ('123', 123), {'456': 456}]
列表的操作
列表的反转
列表反转在实际编程中也是比较常见的，可以通过以下方式对列表进行反转
reverse()会将列表内容进行反转
>>> l1
[1, 'str', ['list1', 'list2'], ('123', 123), {'456': 456}, {'s', 'e', 't'}]
>>> l1[::-1]
[{'s', 'e', 't'}, {'456': 456}, ('123', 123), ['list1', 'list2'], 'str', 1]
>>> list(reversed(l1))
[{'s', 'e', 't'}, {'456': 456}, ('123', 123), ['list1', 'list2'], 'str', 1]
>>> l1
[1, 'str', ['list1', 'list2'], ('123', 123), {'456': 456}, {'s', 'e', 't'}]
>>> l1.reverse()
>>> l1
[{'s', 'e', 't'}, {'456': 456}, ('123', 123), ['list1', 'list2'], 'str', 1]
列表的长度，最大值，最小值，添加，删除
在列表中，可以通过len()获取列表的长度，通过max()获取列表的最大值,min()获取列表的最小值，append()函数进行列表的增加数据，insert()函数添加到列表中到指定位置，remove()函数删除某个项,pop()可以删除最后一项,可以通过*重复列表中的数据
>>> l2=[5,1,9,2,9,3,1,4,7,5,6,7,9]
>>> len(l2)
8
>>> max(l2)
9
>>> min(l2)
1
>>> l2.append("addItem")
>>> l2.remove("addItem")
>>> l2.insert(0,99)
>>> l2
[99, 5, 1, 9, 2, 9, 3, 1, 4, 7, 5, 6, 7, 9]
>>> l2.pop()
9
>>> l2*2
[99, 5, 1, 9, 2, 9, 3, 1, 4, 7, 5, 6, 7, 99, 5, 1, 9, 2, 9, 3, 1, 4, 7, 5, 6, 7]
列表的连接
列表可以通过+号进行连接，可以使用extend()将一个列表的内容添加到另一个列表中,通过以下代码可以得知，使用+号操作并不会改变原列表到值，使用extend()则会将原列表到值改变了
>>> l2
[5, 1, 9, 2, 9, 3, 1, 4, 7, 5, 6, 7]
>>> l3
['l3-1', 'l3-2']
>>> l2+l3
[5, 1, 9, 2, 9, 3, 1, 4, 7, 5, 6, 7, 'l3-1', 'l3-2']
>>> l2
[5, 1, 9, 2, 9, 3, 1, 4, 7, 5, 6, 7]
>>> l3
['l3-1', 'l3-2']
>>> l2.extend(l3)
>>> l2
[5, 1, 9, 2, 9, 3, 1, 4, 7, 5, 6, 7, 'l3-1', 'l3-2']
元组
在Python中元组跟列表有点相似，但又有其特殊性，列表是可以增加修改删除的，但是元组是不可变的，不能够进行增加伤处修改等操作
元组的定义
>>> t1=123,'abc',['aaa']
>>> type(t1)
<class 'tuple'>
>>> t2=(123,'abc',['aaa'])
>>> type(t2)
<class 'tuple'>
索引和切片
因为元组跟list相似,且元组也是有序等，所以元组也有索引和切片
>>> t3=(123,'abc',['aaa'],{"asda","test"},3.3)
>>> t3[0]
123
>>> t3[1:]
('abc', ['aaa'], {'test', 'asda'}, 3.3)
>>> t3[:-3]
(123, 'abc')
字典
字典的定义
字典定义的方式比较多，以下列出其中几种方法
- 构建空字典，然后向里面添加数据
>>> d1={}
>>> type(d1)
<class 'dict'>
>>> d1[1]=123
>>> d1['2']="456"
>>> d1["a"]=789
>>> d1
{1: 123, '2': '456', 'a': 789}
- 直接构建非空字典
>>> d2={"name":"username",'age':18,'list':["item1","item2"]}
>>> type(d2)
<class 'dict'>
>>> d2
{'name': 'username', 'age': 18, 'list': ['item1', 'item2']}
- 使用元组构建字典
>>> t3=(["key1","value1"],["key2","value2"])
>>> d3=dict(t3)
>>> d3
{'key1': 'value1', 'key2': 'value2'}
>>> type(d3)
<class 'dict'>
- 直接使用key=value方式构建
>>> d4=dict(id='1',age=1,name='test')
>>> type(d4)
<class 'dict'>
>>> d4
{'id': '1', 'age': 1, 'name': 'test'}
字典的操作
-
d[key]可以得到字典对应key的值，当key不存在则报错 -
d[key]=value将value付给字典对应key -
len(d)返回字典中键值对的数量 -
key in d检查字典中是否含有键为key的值 -
del d[key]删除字典中含有键为key的像 -
d.get(key,defaultvalue)可以获取字典中对应key的值，当key不存在时，如果defaultvalue没有传，则返回None，否则返回defaultvalue -
d.setdefault(key,defaultvalue)如果字典中不存在对应的key，则添加对应的key，defaultvalue不填时，value为None，否则为defaultvalue -
d.clear()清空字典里面的内容 -
pop(key)和popitem()都可以删除字典中的内容，pop需要传入对应的key，popitem则随机删除一对键值对
>>> d4['id']
'1'
>>> d4['id']=2
>>> len(d4)
3
>>> 'id' in d4
True
>>> d4
{'id': 2, 'age': 1, 'name': 'test'}
>>> del d4['id']
>>> d4
{'age': 1, 'name': 'test'}
>>> d4.get('age')
1
>>> d4.get('id')
>>> d4.get('id','-1')
'-1'
>>> d4
{'age': 1, 'name': 'test'}
>>> d4.setdefault('id')
>>> d4
{'age': 1, 'name': 'test', 'id': None}
>>> d4.setdefault('id1',1)
1
>>> d4
{'age': 1, 'name': 'test', 'id': None, 'id1': 1}
>>> d4.clear()
>>> d4
{}
>>> d5={'id': 2, 'age': 1, 'name': 'test',1:999,2:666,3:777}
>>> d5.pop('id')
2
>>> d5
{'age': 1, 'name': 'test', 1: 999, 2: 666, 3: 777}
>>> d5.popitem()
(3, 777)
>>> d5
{'age': 1, 'name': 'test', 1: 999, 2: 666}
字典的copy
字典可以通过copy()方法进行拷贝，且对其中的一个简直对进行修改并不会影响到原来的字典
>>> d6={1:1,2:2.2,'3':'3','l':[123,'123','456']}
>>> d6
{1: 1, 2: 2.2, '3': '3', 'l': [123, '123', '456']}
>>> d7=d6.copy()
>>> d7
{1: 1, 2: 2.2, '3': '3', 'l': [123, '123', '456']}
>>> d7[1]='999'
>>> d7
{1: '999', 2: 2.2, '3': '3', 'l': [123, '123', '456']}
>>> d6
{1: 1, 2: 2.2, '3': '3', 'l': [123, '123', '456']}
但是如果如果是修改列表的话，那么就会出现两个字典的列表内容一起修改了，因为这种拷贝只是浅拷贝，两个字典中的列表地址其实是一样的
>>> d7['l'].append(74125)
>>> d7
{1: '999', 2: 2.2, '3': '3', 'l': [123, '123', '456', 74125]}
>>> d6
{1: 1, 2: 2.2, '3': '3', 'l': [123, '123', '456', 74125]}
>>> id(d6['l'])
4540976712
>>> id(d7['l'])
4540976712
如果需要实现深拷贝，则需要导入copy模块，使用deepcopy()函数进行深拷贝
>>> d7
{1: '999', 2: 2.2, '3': '3', 'l': [123, '123', '456', 74125]}
>>> import copy
>>> d8=copy.deepcopy(d7)
>>> d8
{1: '999', 2: 2.2, '3': '3', 'l': [123, '123', '456', 74125]}
>>> d8['l'].append('append')
>>> d8
{1: '999', 2: 2.2, '3': '3', 'l': [123, '123', '456', 74125, 'append']}
>>> d7
{1: '999', 2: 2.2, '3': '3', 'l': [123, '123', '456', 74125]}
集合
集合的定义
以下为集合的定义方式，集合会自动去除重复的数据，且集合中元素是无需的
>>> s1=set('fglsdfglsfghalerwer')
>>> s1
{'a', 'r', 'd', 'h', 'w', 's', 'e', 'g', 'f', 'l'}
>>> s2=set([1,2,58,1,5,6,7,8,6,9])
>>> s2
{1, 2, 5, 6, 7, 8, 9, 58}
集合的操作
- 集合可以通过
add()实现对集合的添加 - 通过
update()可以把一个集合里的数据添加到另一个集合里面 -
pop()可以随机的删除集合中到一个元素 -
remove()可以删除集合中指定元素，如果元素不存在则报错 -
discard()可以删除集合中指定元素，如果元素不存在则返回None -
clear()可以清空集合所有元素
>>> s2.add('test')
>>> s2
{1, 2, 5, 6, 7, 8, 9, 'test', 58}
>>> s1
{'a', 'r', 'd', 'h', 'w', 's', 'e', 'g', 'f', 'l'}
>>> s1.update(s2)
>>> s1
{1, 2, 5, 6, 7, 'h', 8, 9, 'test', 'e', 'd', 'a', 'r', 'w', 's', 'g', 'f', 58, 'l'}
>>> s2
{1, 2, 5, 6, 7, 8, 9, 'test', 58}
>>> s1.pop()
1
>>> s1.remove('test')
>>> s1
{2, 5, 6, 7, 'h', 8, 9, 'e', 'a', 'w', 's', 'g', 58, 'd', 'r', 'f', 'l'}
>>> s1.discard('r')
>>> s1
{2, 5, 6, 7, 'h', 8, 9, 'e', 'a', 'w', 's', 'g', 58, 'd', 'f', 'l'}
>>> s1.clear()
>>> s1
set()
