3. python数据类型

2020/02/21 posted in 基础

字符串（str）

字符串的定义

我们在介绍数据类型的时候,简单介绍了一下字符串类型.因为字符串是Python语言中特别重要的概念(不仅是Python,在其他语言中也有着举重若轻的位置),我们详细的讲解一下字符串的用法。

我们已经知道了,单引号,双引号,包括三引号包围的字符组,就是字符串,例如

str = 'hello'#定义字符串变量
str = "helo"#定义字符串变量
str = """hello
hello"""#定义多行字符串变量

下标和切片

下标索引

下标在Python中的概念就是编号的意思, 字符串元组列表都会经常用到下标的概念,我们可以根据下标找到它们所对应的元素.就好像生活中你要准备去看电影,电影票上的座位号找到对应的位置。

我们现在考虑这样⼀一个问题,例例如我们创建了一个字符串name = zhang ,我现在想取到名为 name 字符串里面的a字符.如何去取呢?,其实我们可以通过我们讲过的for循环来遍历这个字符串,通过这种方法来取出字符串里的字符,但是 Python 给我们提供了了更为简便的方法,我们就可以用下标来取出a 字符

name='zhangsan'
print(name[2])

切片

我们可以利用下表索引取到字符串里面对应的一个元素,但如果想要截取一段元素就要用到切片。

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。 切片的语法: [起始:结束:步长]
我们以字符串为例例讲解。

如果取出一部分，则可以在中括号 [] 中，使用:

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')

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')

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)

列表的访问

用索引来访问 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中查找的常用方法为：

in （存在）,如果存在那么结果为 true ，否则为 false
not in （不存在），如果不存在那么结果为 true ，否则 false

#待查找的列表
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)

a.count('b')

删除元素

列表元素的常用删除方法有：

del：根据下标进行删除pop：
删除最后一个元素remove：
根据元素的值进行删除

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

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']

由于一个 key 只能对应⼀一个 value ，所以，多次对一个 key 放入 value ，后面的值会把前面的值冲掉：

d['Ryan']=100
d['Ryan']

d['Ryan']=99
d['Ryan']

如果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
clear()

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'>

« 6. python包的使用及读写

5.python面向对象 »

Hi, I'm Ryan

3. python数据类型

字符串（str）

字符串的定义

下标和切片

下标索引

切片

字符串的常见操作

find

index

count

replce

split

capitallize

title

startswith

endswith

lower

upper

ljust

rjust

center

lstrip

rstrip

strip

rfind

rindex

partition

rpartition

splitlines

join

列表（list）

列表简介

列表的常见操作

列表的长度

列表的访问

列表的切片

添加元素( append , extend , insert )

修改元素

查找元素

删除元素

列表的遍历

使用for循环

使用while循环

元组（tuple）

字典（dict）

字典简介

字典的常见操作

修改元素

添加元素

集合（set）

分类目录

最近文章

联系我