python字符串string-列表[]-元组()-字典{}总结

这几个基本的数据类型在Python中使用非常多，熟练使用这个几个数据类型将大大提高Python编程能力。这里基于最近验证的例子来总结一下这几个数据类型！

一、字符串string

字符串处理在其它高级语言中也是很重要的，熟练处理字符串可以避免少走弯路，提高编程能力。

1.字符串运算

以下表格数据引用自：https://www.runoob.com/python/python-strings.html，后面的一些例子中都会有所体现。

操作符	描述	实例
+	字符串连接	>>>a + b ‘HelloPython’
*	重复输出字符串	>>>a * 2 ‘HelloHello’
[]	通过索引获取字符串中字符	>>>a[1] ‘e’
[ : ]	截取字符串中的一部分	>>>a[1:4] ‘ell’
in	成员运算符 - 如果字符串中包含给定的字符返回 True	>>>“H” in a True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	>>>“M” not in a True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	>>>print r’\n’ \n >>> print R’\n’ \n
%	格式字符串	请看下一章节

上面的 ‘in’ 和 'not in’非常好理解，很像自然语言。

2.字符串定义和访问

• 字符串可以用 单引号 和 双引号 圈住，结尾不需要加分号;,
• 字符串可以通过索引直接访问单个字符str[0],就是访问索引为0的元素
• 字符串可以通过 “:”，初步对字符串进行分割，一般适用具有固定格式的字符串。其语法为str[start_index:end_index:step],
  start_index:开始访问的字符索引，end_index:这个一开始我以为最后一个字符串的索引，但在实际使用时发现实际打印出的最后一个字符为end_index前一个字符，step：每一次跳过的长度。

var1 = 'armwind1'
var2 = "armwind11"
print("var1:%s,var2:%s,var1[0]:%s,var1[1:]%s,var1[:4]%s" %(var1,var2,var1[0],var1[1:],var1[:3]))

上面格式化很像C语言的风格，

D:\test\python>python str.py
var1:armwind1,var2:armwind11,var1[0]:a,var1[1:]rmwind1,var1[:4]arm

二、字符串拆分和拼接

1.拆分

• 拆分1：如果是一个字符串且大小固定，可以直接使用[:]来进行，这个上面已经记录了。
• 拆分2：如果是具有特殊分隔符的就可以使用内部函数spilit(),

str = "armwind1:  armwind2:  armwind3:"

#split all special characters
ll = str.split(':')
print("typeof(ll):%s" %type(ll))

#with blank space
for i in ll:
    print i

#without blank space
print('---------')
for i in ll:
    print i.strip()
print('---------')

#split 1 times
lll = str.split(':',1)
for i in lll :
    print i

基于运行结果发现如下：

• split() 返回的是一个list类型的对象
• split() 可以有多个参数，用于区分分割的次数，默认是分割所有的特殊字符。
• strip() 用于清除字符串左右的空格

运行结果：

D:\test\python>python str.py
typeof(ll):<type 'list'>
armwind1
  armwind2
  armwind3
 
---------
armwind1
armwind2
armwind3

---------
armwind1
  armwind2:  armwind3:

2.拼接

如java和c#等高级语言一样，同样可以使用+号的形式，拼接字符串。如。

var1 = "armwind77"
var2 = "armwind88"
var3 = var1 + var2
var4 = 88
var5 = var1 + str(var4)

print "var[7:9]:", var1[7:9] + " and " + var2[7:9]
print "var3:", var3
print "var5:", var5

下面的运行结果，可以看到完全和高级语言一模一样。不过要特别注意的地方是：不同数字类型不可以直接使用+”。

var[7:9]: 77 and 88
var3: armwind77armwind88
var5: armwind7788

三、List[列表]

list和高级语言中的string很类似，使用时可大胆尝试string的方法，不能用在查找罢了。
list就是列表的意思，不过和java，c++高级语言不同的是 元素可以使用不同类型的数据

1.list操作符

表格数据引用自：https://www.runoob.com/python/python-lists.html

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 x,	1 2 3	迭代

2.list对象定义

• 定义时直接用方括号包含元素即可，
• 元素可以是不同类型，对应字符串可以使用单引号和双引号。
• 可以直接使用索引访问对应的元素

var = ['armwind1', "armwind2"]
var1 = []
print("var[0]:%s,var[1]:%s,var1:%s" %(var[0],var[1],var1))

运行结果：

D:\test\python>python list.py
var[0]:armwind1,var[1]:armwind2,var1:[]

3.增加和删除操作

var1 = ["armwind1", "armwind2", 2019, "->", 2020]
for x in var1 :
    print x

print var1
print "var1.len", len(var1)

var1.append("armwind3")
var1.append("armwind4")
print var1
print "var1.len", len(var1)

del var1[1]
print var1
print "var1.len", len(var1)

上面进行增删操作后的结果如预期一样，基本上最常用的操作就是append()

armwind1
armwind2
2019
->
2020
['armwind1', 'armwind2', 2019, '->', 2020]
var1.len 5
['armwind1', 'armwind2', 2019, '->', 2020, 'armwind3', 'armwind4']
var1.len 7
['armwind1', 2019, '->', 2020, 'armwind3', 'armwind4']
var1.len 6

list常用的方法：表格数据引用自：https://www.runoob.com/python/python-lists.html

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

四、tuple(元组）

1. 元组的特点

• 元组的元素不可以修改
• 元素可以是不同类型
• 创建空元组 cell = ()
• 元组包含一个元素 cell = (2020,)
• 元组的索引从0开始

2.元组运算符

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

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 x,	1 2 3	迭代

3. 实例演示

var1 = (2019,"2020")
var2 = (2019)
var3 = (2020,)
print var2
print type(var2)
print var3
print type(var3)

print var1

for x in var1 :
    print x

运行结果如下，从下面的结果可以验证，

• 1.元组元素可以不同、
• 2.单个元素的元组后面一定要加逗号，要不然解释器不认为是元组。

2019
<type ‘int’>
(2020,)
<type ‘tuple’>
(2019, ‘2020’)
2019
2020

4. 元组存在的意义

上面的例子感觉元组合和列表的功能类似，而且列表功能更强一点，那为什么还会存在元组这一类型。元组强调的就是不可更改性，确保数据的安全性。结合网友经验和之前编程经验，总结下面2条

• 1.确实是静态数据，例如一天24小时，就是24小时
• 2.函数参数和返回值
  • 参数使用元组，确保数据安全性，就像我们在C中使用const修饰参数一样。
  • 返回值使用元组，扩展了返回值数量。

五、dict(字典）

dict为多组键值对组成的几何，由于其可以是不同类型，个人感觉它就像C语言中的结构体，同时定义格式又有点像json文本的感觉。

1.dict特性

• 同一个键没赋值两次，只会记住最后一次赋的值
• 键不可以更改，可以是字符串、数字、元组，但不可以是列表
• 键值对中，值的类型也可以是不同的数据类型。

dic = {'name': "armwind", 'name':"armwind11","age": 30, 119: 2020, 'l': "cet4", ("birth"): ("stu1","stu2","stu3")}

print(type(dic[119]),type(dic['name']),type(dic[("birth")]))
print("keys:%s" %dic.keys())
print("values:%s" %dic.values())
print("---------------------")
for key,value in dic.items():
    print('{key}:{value}'.format(key = key, value = value))
print("---------------------")
print("override data")
dic['name'] = "armwind111"
dic['age'] = 32
it = dic.items()
print("type:%s" %it)

for key,value in dic.items():
    print('{key}:{value}'.format(key = key, value = value))

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

运行结果：

D:\test\python>python dict.py
(<type 'int'>, <type 'str'>, <type 'tuple'>)
keys:['age', 'l', 'name', 'birth', 119]
values:[30, 'cet4', 'armwind11', ('stu1', 'stu2', 'stu3'), 2020]
---------------------
age:30
l:cet4
name:armwind11
birth:('stu1', 'stu2', 'stu3')
119:2020
---------------------
override data
type:[('age', 32), ('l', 'cet4'), ('name', 'armwind111'), ('birth', ('stu1', 'stu2', 'stu3')), (119, 2020)]
age:32
l:cet4
name:armwind111
birth:('stu1', 'stu2', 'stu3')
119:2020
---------------------

2.dict常用方法

• dict.keys():返回所有键的元组对象
• dict.values()：返回所有值的元组对象
• dict.items()：返回键值对的列表对象，其中每一个元素是元组类型，如上面例子：

  dic = {'name': "armwind", 'name':"armwind11","age": 30, 119: 2020, 'l': "cet4", ("birth"): ("stu1","stu2","stu3")}
  it = dic.items()
  print("type:%s" %it)
  
  输出：
  type:[('age', 32), ('l', 'cet4'), ('name', 'armwind111'), ('birth', ('stu1', 'stu2', 'stu3')), (119, 2020)]