字符串（str）
字符串的定义
我们在介绍数据类型的时候,简单介绍了一下字符串类型.因为字符串是Python语言中特别重要的概念(不仅是Python,在其他语言中也有着举重若轻的位置),我们详细的讲解一下字符串的用法。
我们已经知道了,单引号,双引号,包括三引号包围的字符组,就是字符串,例如
str = 'hello'#定义字符串变量
str = "helo"#定义字符串变量
str = """hello
hello"""#定义多行字符串变量
下标和切片
下标索引
下标在Python中的概念就是编号的意思, 字符串 元组 列表 都会经常用到下标的概念,我们可以根据下标找到它们所对应的元素.就好像生活中你要准备去看电影,电影票上的座位号找到对应的位置。
我们现在考虑这样⼀一个问题,例例如我们创建了一个字符串name = zhang ,我现在想取到名为 name 字符串里面的a字符.如何去取呢?,其实我们可以通过我们讲过的for循环来遍历这个字符串,通过这种方法来取出字符串里的字符,但是 Python 给我们提供了了更为简便的方法,我们就可以用下标来取出a 字符
name='zhangsan'
print(name[2])
a
切片
我们可以利用下表索引取到字符串里面对应的一个元素,但如果想要截取一段元素就要用到切片。
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。 切片的语法: [起始:结束:步长]
我们以字符串为例例讲解。
如果取出一部分，则可以在中括号 [] 中，使用:
name = 'abcdef'
print(name[0:3]) # 取 下标0~2 的字符
print(name[3:5]) # 取 下标为3、4 的字符
print(name[2:]) # 取 下标为2开始到最后的字符
#支持负数
name = 'abcdef'
print(name[1:-1]) # 取 下标为1开始 到 最后第2个 之间的字符
abc
de
cdef
bcde
字符串的常见操作
如有字符串mystr = 'hello world kkb' ，以下是常见的操作
mystr = 'hello world kkb'
find
检测 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1
mystr.find(str, start=0, end=len(mystr))
mystr.find('kkb')
12
mystr.find('kkb',0,10)#在mstr字符串串0-10下标范围查询
-1
index
跟 find() 方法一样，只不过如果 str 不在 mystr中会报一个异常.
mystr.index(str, start=0, end=len(mystr))
mystr.index('ab')
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-9-46892962653f> in <module>()
----> 1 mystr.index('ab')
ValueError: substring not found
count
返回str在start和end之间在mystr里面出现的次数。
mystr.count(str,start,end=len(mystr))
mystr.count('kkb')
1
replce
把mystr中的str1替换成str2 ,如果count指定，则替换不超过count次。
mystr.replace(str1,str2,mystr.count(str1))
split
以str为分隔符切片 mystr，如果maxsplit有指定值，则仅分隔maxsplit个子字符串。
mystr.split(str=" ", 2)
capitallize
把字符串的第一个字母大写
mystr.capitalize()
'Hello world kkb'
title
首字母大写
mystr.title()
'Hello World Kkb'
startswith
检查字符串是否是以hello开头, 是则返回True，否则返False
mystr.startswith('hello')
True
endswith
检查字符串是否以obj结尾，如果是则返回True，否则返False
mystr.endswith('obj')
False
lower
转换mystr中所有大写字符为小写
mystr.lower()
upper
转换mystr中所有小写字符为大写
mystr.upper()
ljust
返回一个原字符串左对齐,并使用空格填充至长度width的新字符串
width=32
mystr.ljust(width)
'hello world kkb '
rjust
返回一个原字符串右对齐,并使用空格填充至长度width的新字符串
mystr.rjust(width)
center
返回一个原字符串居中对齐,并使用空格填充至长度width的新字符串
mystr.center()
lstrip
删除mystr左边的空白字符串
mystr.lstrip()
rstrip
删除mystr右边的空白字符串
mystr.rstrip()
strip
删除mystr两端的空白字符串
mystr.strip()
a = "\n\t kkb \t\n"
print(a)
a.strip()
kkb
'kkb'
rfind
类似于 find() 函数，不不过是从右边开始查找.
mystr.find(str, start=0,end=len(mystr))
rindex
类似于 index() ，不不过是从右边开始.
mystr.rindex(str, start=0,end=len(mystr))
partition
把 mystr以str分割成三部分, str前， str和str后
mystr.partition(str)
rpartition
类似于 partition()函数,不不过是从右边开始.
mystr.rpartition(str)
splitlines
按照行分隔，返回一个包含各行作为元素的列表
mystr.splitlines()
join
mystr中每个元素后面插入 str ,构造出⼀一个新的字符串
mystr.jion(str)
列表（list）
列表简介
Python内置的一种数据类型是列表： list 。 list 是一种有序的集合，可以随时添加和删除其中的元素，写在方括号之间、用逗号分隔开的数值列表。列表内的项目不必全是相同的类型。
例如：
list1= ['spam','eggs','12',123]
注意：比C语言的数组强大的地方在于列表中的元素可以是不同类型的。
列表的常见操作
列表的长度
#⽤用len()函数可以获得list元素的个数：
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
len(namesList)
3
列表的访问
用索引来访问 list 中每一个位置的元素，记得索引是从0开始的：
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[0])
print(namesList[1])
print(namesList[2])
print(namesList[3])
xiaoWang
xiaoZhang
xiaoHua
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-42-c578a48b9b76> in <module>()
3 print(namesList[1])
4 print(namesList[2])
----> 5 print(namesList[3])
IndexError: list index out of range
注意：当索引超出了范围时，Python会报一个 IndexError 错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates) - 1
如果要取最后一个元素，除了了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：
print(namesList[-1])
#以此类推，可以获取倒数第2个、倒数第3个：
print(namesList[-2])
print(namesList[-3])
xiaoHua
xiaoZhang
xiaoWang
列表的切片
切片: 根据下标的范围获取一部分数据，⽐比如: 列表，字符串可以使用切片。
切片的使用格式
数据[起始下标:结束下标:步长]
提示： 起始下标默认0， 结束下标是不包含， 步长默认是1
# 使用切片的方式获取一部分数据
my_str=['zhangsan','lisi','wangwu',45,781,'erf']
result = my_str[1:4:1]
print(result)
#前三个
result = my_str[0:3]
print(result)
result = my_str[:3]
print(result)
['lisi', 'wangwu', 45]
['zhangsan', 'lisi', 'wangwu']
['zhangsan', 'lisi', 'wangwu']
添加元素( append , extend , insert )
通过 append 可以向列列表添加元素
#定义变量量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']
print("-----添加之前，列列表A的数据 ")
for tempName in A:
print(tempName)
#提示、并添加元素
temp = input('请输入要添加的学生姓名:')
A.append(temp)
print("-----添加之后，列列表A的数据 ")
for tempName in A:
print(tempName)
-----添加之前，列列表A的数据
xiaoWang
xiaoZhang
xiaoHua
请输入要添加的学生姓名:huohuo
-----添加之后，列列表A的数据
xiaoWang
xiaoZhang
xiaoHua
huohuo
通过 extend 可以将另⼀一个集合中的元素逐⼀一添加到列列表中
a = [1, 2]
b = [3, 4]
a.append(b)
print(a)
print('-----')
a.extend(b)
print(a)
print('-----')
# insert(index,object)` 在指定位置`index`前插入元素`object
a = [0, 1, 2]
a.insert(1, 3)
print(a)
[1, 2, [3, 4]]
-----
[1, 2, [3, 4], 3, 4]
-----
[0, 3, 1, 2]
修改元素
修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改
#定义变量量A，默认有3个元素
A = ['xiaoWang','xiaoZhang','xiaoHua']
print("-----修改之前，列列表A的数据 ")
for tempName in A: print(tempName)
#修改元素
A[1] = 'xiaoLu'
print("-----修改之后，列列表A的数据 ")
for tempName in A: print(tempName)
-----修改之前，列列表A的数据
xiaoWang
xiaoZhang
xiaoHua
-----修改之后，列列表A的数据
xiaoWang
xiaoLu
xiaoHua
查找元素
所谓的查找，就是看看指定的元素是否存在。
python中查找的常用方法为：
#待查找的列表
nameList = ['xiaoWang','xiaoZhang','xiaoHua']
#获取用户要查找的名字
findName = input('请输入要查找的姓名:')
#查找是否存在
if findName in nameList:
print('在字典中找到了了相同的名字')
else:
print('没有找到')
请输入要查找的姓名:Ryan
没有找到
index 和 count 与字符串中的用法相同
a = ['a', 'b', 'c', 'a', 'b']
a.index('a', 1, 3) # 注意左闭右开区间
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-2-5317aed0f6cc> in <module>()
1 a = ['a', 'b', 'c', 'a', 'b']
----> 2 a.index('a', 1, 3) # 注意左闭右开区间
ValueError: 'a' is not in list
a.index('a',1,4)
3
a.count('b')
2
删除元素
列表元素的常用删除方法有：
del：根据下标进行删除pop：
删除最后一个元素remove：
根据元素的值进行删除
- del
list1 = ['a','b','c','d','e','f']
print('------删除之前')
for tempName in list1:
print(tempName)
movieName=list1
del movieName[2]
print('------ 删除之后 ')
for tempName in list1:
print(tempName)
------删除之前
a
b
c
d
e
f
------ 删除之后
a
b
d
e
f
- pop
list2 = ['a','b','c','d','e','f']
print('------删除之前 ')
for tempName in list2:
print(tempName)
movieName=list2
movieName.pop()
print('------删除之后 ')
for tempName in list2:
print(tempName)
------删除之前
a
b
c
d
e
f
------删除之后
a
b
c
d
e
- remove
list2 = ['a','b','c','d','e','f']
print('------删除之前 ')
for tempName in list2:
print(tempName)
movieName=list2
movieName.remove('e')
print('------删除之后 ')
for tempName in list2:
print(tempName)
------删除之前
a
b
c
d
e
f
------删除之后
a
b
c
d
f
排序
sort 方法是将 list 按特定顺序重新排列，默认为由小到大，参数 reverse=True 可改为倒序，由大到小。
reverse 方法是将 list 逆置。
a=[1,4,3,2]
print(a)
a.sort()
print(a)
[1, 4, 3, 2]
[1, 2, 3, 4]
a=[1,4,3,2]
print(a)
a.reverse()
print(a)
[1, 4, 3, 2]
[2, 3, 4, 1]
a=[1,4,3,2]
print(a)
print('-----')
a.sort(reverse=True)
print(a)
print('-----')
a.sort(reverse=False)
print(a)
[1, 4, 3, 2]
-----
[4, 3, 2, 1]
-----
[1, 2, 3, 4]
列表的遍历
使用for循环
为了更有效率的输出列表的每个数据，可以使用循环来完成
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:
print(name)
xiaoWang
xiaoZhang
xiaoHua
使用while循环
为了更有效率的输出列表的每个数据，可以使用循环来完成
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
lenth=len(namesList)
i=0
while i < lenth:
print(namesList[i])
i+=1
xiaoWang
xiaoZhang
xiaoHua
元组（tuple）
另一种有序列列表叫元组：tuple。 tuple和list非常类似，但是 tuple一旦初始化就不能修改，比如同样是列出同学的名字：
classmates = ('Michael', 'Bob', 'Tracy')
现在， classmates这个tuple不能变了，它也没有append()，insert( )这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用 classmates[0] ， classmates[-1] ，但不能赋值成另外的元素。
不可变的tuple有什什么意义？因为tuple不不可变，所以代码更安全。如果可能，能用tuple代list就尽量用tuple。
如果要定义一个空的tuple，可以写成()：
t=()
print(t,type(t))
() <class 'tuple'>
但是，要定义一个只有1个元素的tuple ，如果你这么定义：
t=(1)
print(t,type(t))
1 <class 'int'>
定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这 就产生了了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
所以，只有1个元素的tuple定义时必须加一个逗号，来消除歧义：
t=(1,)
print(t,type(t))
(1,) <class 'tuple'>
Python在显示只有1个元素的tuple时，也会加一个逗号，以免你误解成数学计算意义上的括号。
t = ('a', 'b', ['A', 'B'])
t[2][0] = 'X'
t[2][1] = 'Y'
t
('a', 'b', ['X', 'Y'])
最后来看一个“可变的”tuple
字典（dict）
字典简介
字典是另一种可变容器器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号{}中
举个例子，假设要根据同学的名字查找对应的成绩，如果用 list 实现，需要两个 list ：
names = ['Michael', 'Bob', 'Tracy']
scores = [95, 75, 85]
给定一个名字，要查找对应的成绩，就先要在 names 中找到对应的位置，再从 scores 取出对应的成绩， list 越长，耗时越长。
如果用 dict 实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大， 查找速度都不不会变慢。用Python写一个 dict 如下：
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Michael']
95
由于一个 key 只能对应⼀一个 value ，所以，多次对一个 key 放入 value ，后面的值会把前面的值冲掉：
d['Ryan']=100
d['Ryan']
100
d['Ryan']=99
d['Ryan']
99
如果key不不存在，dict就会报错：
d['Thomas']
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-40-bf27a9c462ee> in <module>()
----> 1 d['Thomas']
KeyError: 'Thomas'
字典的常见操作
修改元素
字典的每个元素中的数据是可以修改的，只要通过 key 找到，即可修改
info = {'name':'kkb', 'id':100, 'sex':'f', 'address':'中国北北京'}
new_id = input('请输入新的学号:')
info['id'] = int(new_id)
print('修改之后的id为: %d' % info['id'])
请输入新的学号:12
修改之后的id为: 12
添加元素
- 访问不不存在的元素
info = {'name':'kkb', 'sex':'f', 'address':'中国北北京'}
print('id为:%d' % info['id'])
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-43-0f8e22620be6> in <module>()
1 #访问不不存在的元素
2 info = {'name':'kkb', 'sex':'f', 'address':'中国北北京'}
----> 3 print('id为:%d' % info['id'])
KeyError: 'id'
如果在使用变量量名['键'] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素。
- 添加新的元素
info = {'name':'kkb', 'sex':'f', 'address':'中国北北京'}
# print('id为:%d'%info['id'])#程序会终端运⾏行行，因为访问了了不不存在的键
newId = input('请输入新的学号：')
info['id'] =int(newId)
print('添加之后的id为:%d' % info['id'])
请输入新的学号：345
添加之后的id为:345
删除元素
对字典进行删除操作，有以一下几种：
del删除指定的元素
info = {'name':'kkb', 'sex':'f', 'address':'中国北北京'}
print('删除前,%s' % info['name'])
del info[name]
print('删除后,%s' % info['name'])
#删除后不存在name字段
删除前,kkb
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-55-02d163400996> in <module>()
3 print('删除前,%s' % info['name'])
4
----> 5 del info[name]
6
7 print('删除后,%s' % info['name'])
KeyError: 'xiaoHua'
del删除整个字典
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('删除前,%s' % info)
del info
print('删除后,%s' % info)
clear清空整个字典
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('清空前,%s' % info)
info.clear()
print('删除后,%s' % info)
keys
返回一个包含字典所有key的列列表
d1 = {'name':'abc','age':'18', 'class':'cnh'}
print(list(d1.keys()))
['name', 'age', 'class']
values
返回一个包含字典所有value的列表
d1 = {'name':'abc','age':'18', 'class':'cnh'}
print(list(d1.values()))
['abc', '18', 'cnh']
items
返回一个包含所有（值，键）元祖的列表
d1 = {'name':'abc','age':'18', 'class':'cnh'}
print(list(d1.items()))
[('name', 'abc'), ('age', '18'), ('class', 'cnh')]
集合（set）
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不不是 { }，因为 { }是用来创建⼀一个空字典。
my_set = {1, 4, 'abc', 'hello'}
# 不支持下标赋值和取值
# my_set[0] = 3
# value = my_set[0] # print(value)
# print(value)
#支持通过遍历获取数据
for value in my_set:
print(value)
1
hello
4
abc
my_set2={1,4,7}
for index,value in enumerate(my_set2):
print(index,value)
0 1
1 4
2 7
# 定义空的集合的时候不能直接使用{}
my_set = set()
my_set.add(1)
my_set.add(1)
print(my_set, type(my_set))
# 集合可以对容器器类型数据去重
my_list = [1, 1, 3, 5, 3]
# 把列列表转成集合，会把数据去重
my_set = set(my_list)
print(my_set)
# 列列表，元组， 集合 三者之间可以相互转换
my_tuple = (5, 3)
print(my_tuple, type(my_tuple))
{1} <class 'set'>
{1, 3, 5}
(5, 3) <class 'tuple'>
