数据类型及操作
1. 数据类型的种类
检测数据类型的方法: type()
注意: 数据按照是否能直接修改分为可变类型和不可变类型两种。
- 可变类型:列表、字典、集合
- 不可变类型:字符串、元组、整型、浮点型
1.1 字符串
1.1.1 字符串的表示
字符串支持单引号,双引号以及三引号,其中三引号可以换行。
name1 = 'Tom'
name2 = "Rose"
name3 = ''' Tom '''
name4 = """ Rose """
a = ''' i am Tom,
nice to meet you! '''
b = """ i am Rose,
nice to meet you! """
当字符串里本身就有引号时,注意:
c = "I'm Tom"
d = 'I \'m Tom' # 转义字符反斜杠,“\”
- 反斜杠可以用来转义,使用
r
可以让反斜杠不发生转义。 如r"this is a line with \n"
则\n
会显示,并不是换行。- Python 中单引号
'
和双引号"
使用完全相同。- Python 没有单独的字符类型,一个字符就是长度为 1 的字符串。
1.1.2 字符串的操作
(1)切片
切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
序列[开始位置下标:结束位置下标:步⻓]
注意:
- 不包含结束位置下标对应的数据(前闭后开), 正负整数均可
- 步长是选取间隔,正负整数均可,默认步⻓为1
- 计算机为数据序列中每个元素分配的从0开始的编号
name = "abcdefg"
print(name[:-1]) # abcdef, 负1表示倒数第⼀个数据
print(name[::-1]) # gfedcba,倒序
(2)查找
所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数
① find()
检测某个子串是否包含在这个字符串中,如果在返回这个子串开始的位置下标,否则返回-1。
字符串序列.find(⼦串, 开始位置下标, 结束位置下标)
注意:开始和结束位置下标可以省略,表示在整个字符串序列中查找
② index()
检测某个子串是否包含在这个字符串中,如果在返回这个子串开始的位置下标,否则报异常。
注意:
index()
和find()
语法一致,只是在查找不到子串时前者报异常,后者返回-1
另外:
rfind()
和find()
功能相同,find
返回成功匹配的第一个字符的位置索引,rfind
返回最后一次成功匹配的字符的位置索引rindex()
和index()
功能相同,index
返回成功匹配的第一个字符的位置索引,rindex
返回最后一次成功匹配的字符的位置索引
③ count()
返回某个子串在字符串中出现的次数
注意:
count()
和find()
、index()
语法一致,只是结果返回子串出现次数
④ len() 返回字符串的长度
len(字符串序列)
(3)修改
字符串类型的数据修改的时候不能改变原有字符串,属于不能直接修改数据的类型即是不可变类型。
① replace()
用新子串替换旧子串
字符串序列.replace(旧⼦串, 新⼦串, 替换次数)
mystr = "hello world and you and Python"
# 结果:hello world & you & Python,省略第三个参数默认替换所有子串
print(mystr.replace('and', '&'))
# 结果: hello world & you & Python,第三个参数大于子串个数默认替换所有子串
print(mystr.replace('and', '&', 10))
# 结果: hello world and you and Python【未改变原字符串】
print(mystr)
② split()
按照指定字符分割字符串(默认#以空格为分隔符,包含 \n
)
字符串序列.split(分割字符, num)
注意:
num
表示的是分割字符出现的次数,即将来返回数据个数为num+1
个,通俗来讲,就是分割几次- 如果分割字符是原有字符串中的子串,分割后则丢失该子串
③ join()
用一个字符或子串合并字符串,即是将多个字符串合并为一个新的字符串
字符或子串.join(多字符串组成的序列)
list1 = ['wo', 'ai', 'zhong', 'guo']
t1 = ('aa', 'b', 'cc', 'ddd')
# 结果:wo_ai_zhong_guo
print('_'.join(list1))
# 结果:aa...b...cc...ddd
print('...'.join(t1))
④ capitalize()
将字符串第⼀个字符转换成大写,其它字母均小写
mystr = "hello world and you and Python"
# 结果:Hello world and you and python
print(mystr.capitalize())
⑤ title()
将字符串每个单词首字母转换成大写,其它字母均小写
⑥ lower()
将字符串中大写转小写
upper()
将字符串中小写转大写
swapcase()
交换字符串中的大小写
⑦ strip()
删除字符串两侧空白字符
lstrip()
删除字符串左侧空白字符
rstrip()
删除字符串右侧空白字符
⑧ ljust()
返回⼀个原字符串左对齐,并使用指定字符(默认空格)填充至对应长度的新字符串。
字符串序列.ljust(长度, 填充字符)
rjust()
返回⼀个原字符串右对齐,……
center()
返回⼀个原字符串居中对齐,……
(4)判断
所谓判断即是判断真假,返回的结果是布尔型数据类型:True
或 False
。
① startswith()
检查字符串是否是以指定子串开头,是则返回True
,否则返回 False
。如果设置开始和结束位置下标,则在指定范围内检查
字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)
endswith()
检查字符串是否是以指定子串结尾,……
② isalpha()
如果字符串至少有⼀个字符并且所有字符都是字母则返回 True
, 否则返回 False
isdigit()
如果字符串只包含数字则返回 True
否则返回 False
isalnum()
如果字符串至少有⼀个字符并且所有字符都是字母 或 数字则返回 True
,否则返回False
。
isspace()
:如果字符串中只包含空白,则返回 True
,否则返回 False
islower()
:判断字符串的区分大小写的字符是否全为小写
isupper()
:判断字符串的的字符是否全为大写
istitle()
:判断字符串的的所有单词是否首字母(开头)是大写其他为小写
1.2 列表
1.2.1 列表的表示
[数据1, 数据2, 数据3, 数据4......]
注意:列表可以⼀次性存储多个数据,且可以为不同数据类型
1.2.2 列表的操作
(1)查找
① len()
访问列表长度,即列表中数据的个数
name_list = ['Tom', 'Lily', 'Rose']
print(len(name_list)) # 3
② index()
查找列表中该元素第一次出现的索引
③ count()
注意:
find()
操作仅对于字符串可用
(2)判断是否存在
in
:判断指定数据在某个列表序列,如果在返回True
,否则返回False
not in
:判断指定数据不在某个列表序列,如果不在返回True
,否则返回False
(3)增加
① append()
列表结尾追加数据;如果追加的数据是⼀个序列,则追加整个序列到列表
# 单个数据
name_list = ['Tom', 'Lily', 'Rose']
name_list.append('xiaoming')
# 结果:['Tom', 'Lily', 'Rose', 'xiaoming']
print(name_list)
# 序列数据
name_list = ['Tom', 'Lily', 'Rose']
name_list.append(['xiaoming', 'xiaohong'])
# 结果:['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
print(name_list)
② extend()
列表结尾追加数据,如果数据是⼀个序列,则将这个序列的数据逐⼀添加到列表
# 单个数据
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend('xiaoming')
# 结果:['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
print(name_list)
# 序列数据
name_list = ['Tom', 'Lily', 'Rose']
name_list.extend(['xiaoming', 'xiaohong'])
# 结果:['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
print(name_list)
③ insert()
指定位置新增数据
列表序列.insert(位置下标, 数据)
(4)删除
① del
del 列表名称[下标]
# 或者
del(列表名称[下标])
② pop()
删除指定下标的数据(不指定下标时,默认为最后⼀个),并返回该数据
列表序列.pop(下标)
③ remove()
移除列表中某个数据的第⼀个匹配项,不存在则报错
列表序列.remove(数据)
④ clear()
清空列表
列表序列.clear()
(5)修改
① 修改指定下标数据
name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'aaa'
# 结果:['aaa', 'Lily', 'Rose']
print(name_list)
② reverse()
反转列表
num_list = [1, 5, 2, 3, 6, 8]
num_list.reverse()
# 结果:[8, 6, 3, 2, 5, 1]
print(num_list)
③ sort()
列表排序
列表序列.sort(key=None, reverse=False)
注意:reverse表示排序规则,reverse = True 降序, reverse = False 升序(默认)
num_list = [1, 5, 2, 3, 6, 8]
num_list.sort()
# 结果:[1, 2, 3, 5, 6, 8]
print(num_list)
sorted() 作为 Python 内置函数之一,其功能是对序列(列表、元组、字典、集合、还包括字符串)进行排序:
list = sorted(iterable, key=None, reverse=False)
其中,iterable 表示指定的序列,key 参数可以自定义排序规则;reverse 参数指定以升序(False,默认)还是降序(True)进行排序。sorted() 函数会返回一个排好序的列表。key 参数和 reverse 参数是可选参数,即可以使用,也可以忽略。
(6)copy()
name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
# 结果:['Tom', 'Lily', 'Rose']
print(name_li2)
1.3 元组
1.3.1 元组的表示
定义元组使用小括号,且逗号隔开各个数据,数据可以是不同的数据类型,一个元组可以存储多个数据,元组内的数据是不能修改的
# 多个数据元组
t1 = (10, 20, 30)
# 单个数据元组
t2 = (10,)
print(type(t2)) # tuple
t3 = (20)
print(type(t3)) # int
注意:如果定义的元组只有⼀个数据,那么这个数据后面也要添加逗号,否则数据类型为唯⼀的这个数据的数据类型
1.3.2 元组的操作
元组数据不支持修改,只支持查找
① 按下标查找
② index()
③ count()
④ len()
但是如果元组里面有列表,修改列表里面的数据则是支持的
tuple1 = (10, 20, ['aa', 'bb', 'cc'], 50, 30)
print(tuple1[2]) # 访问到列表
# 结果:(10, 20, ['aaaaa', 'bb', 'cc'], 50, 30)
tuple1[2][0] = 'aaaaa'
print(tuple1)
注意:元组的访问和处理速度比列表要快
1.4 字典
1.4.1 字典的表示
字典里面的数据是以键值对形式出现,字典数据和数据顺序没有关系,即字典不支持下标,后期无论数据如何变化,只需要按照对应的键的名字查找数据即可
字典特点:
- 符号为大括号
- 数据为键值对形式出现
- 各个键值对之间用逗号隔开
# 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
# 空字典
dict2 = {}
dict3 = dict()
注意:
- ⼀般称冒号前面的为键
key
,简称k
;冒号后面的为值value
,简称v
。- 字典的 键 必须要 可哈希(不可变数据类型【字符串、元组】)
1.4.2 字典的操作
(1)增加/修改
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1['name'] = 'Rose'
# 结果:{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)
dict1['id'] = 110
# {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
print(dict1)
注意:如果
key
存在则修改这个key
对应的值;如果key
不存在则新增此键值对
(2)删除
① del()
或del
删除字典或删除字典中指定键值对
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
del dict1['gender']
# 结果:{'name': 'Tom', 'age': 20}
print(dict1)
pop()也可以用于字典
,对于列表来说,删除指定下标的数据(不指定下标时,默认为最后⼀个),并返回该数据,对于字典来说,必须指定参数【键】返回【值】
dicts = {'a': 1, 'b': 2, 'c': 3}
print(dicts.pop('a')) # 1
②clear()
清空字典
(3)查询
① key-value
查找
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1['name']) # Tom
print(dict1['id']) # 报错
② get()
字典序列.get(key, 默认值)
注意:如果当前查找的
key
存在则返回其对应的value值,不存在则返回第⼆个参数(默认值),如果省略第⼆个参数,则返回None
。
③ values()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values()) # dict_values(['Tom', 20, '男'])
④ keys()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])
⑤ items()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender',
'男')])
(4)遍历
① key
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
print(key)
② value
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
print(value)
③ item
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
print(item)
④ 键值对
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
print(f'{key} = {value}')
1.5 集合
1.5.1 集合的表示
创建集合使用 {}
或set()
, 但是如果要创建空集合只能使用set()
,因为{}
用来创建空字典。
s1 = {10, 20, 30, 40, 50}
print(s1) # {50, 20, 40, 10, 30}
s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2) # {50, 20, 40, 10, 30}
s3 = set('abcdefg')
print(s3) # {'f', 'c', 'd', 'g', 'a', 'b', 'e'}
s4 = set()
print(type(s4)) # <class 'set'>
s5 = {}
print(type(s5)) # <class 'dict'>
注意:
- 集合可以去掉重复数据;
- 集合数据是无序的,故不支持下标
- 集合内的元素必须是可哈希(不可变)的,但是集合本身是不可哈希(可变)的
1.5.2 集合的操作
(1)增加
① add()
增加单个数据
注意:因为集合有去重功能,所以,当向集合内追加的数据是当前集合已有数据的话,则不进行任何操作。
s = set()
s.add((1, 2, 3))
print(s) # {(1, 2, 3)}
add
也可以添加序列,但是序列必须可哈希
② update()
增加序列
s1 = {10, 20}
# s1.update(100) 报错
s1.update([100, 200])
s1.update('abc')
print(s1) # {100, 'b', 200, 10, 'a', 20, 'c'}
(2)删除
① remove()
删除集合中的指定数据,如果数据不存在则报错
s1 = {10, 20}
s1.remove(10)
print(s1)
s1.remove(10) # 报错
print(s1)
② pop()
随机(因为集合无序)删除集合中的某个数据,并返回这个数据
s1 = {10, 20, 30, 40, 50}
del_num = s1.pop()
print(del_num)
print(s1)
③ discard()
删除集合中的指定数据,如果数据不存在也不会报错
s1 = {10, 20}
s1.discard(10)
print(s1)
s1.discard(10)
print(s1)
(3)查找
in
:判断数据在集合序列
not in
:判断数据不在集合序列
2. 数据类型转换
# eval() -- 将字符串中的数据转换成Python表达式原本类型
str1 = '10'
str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1))) # <class 'int'>
print(type(eval(str2))) # <class 'list'>
print(type(eval(str3))) # <class 'tuple'>
3. 公共的操作
3.1 运算符
3.2 公共方法
注意:
len()
max()
min()
del()
括号内部放参数
enumerate()
enumerate(可遍历对象, start=0)
注意:
start
参数用来设置遍历数据的下标的起始值,默认为0
list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1):
print(i)
for index, char in enumerate(list1, start=1):
print(f'下标是{index}, 对应的字符是{char}')
注意: 可遍历对象包括字符串、元组、列表、
range()
函数
4. 推导式
4.1 列表推导式
需求:创建⼀个0-10的列表。
list1 = [i for i in range(10)]
print(list1)
(1) 带if
# 需求:创建0-10的偶数列表
list1 = [i for i in range(10) if i % 2 == 0]
print(list1)
(2) 多个for
# 创建[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)
4.2 字典推导式
字典推导式作用:快速合并列表为字典或提取字典中目标数据。
# 创建⼀个字典:字典key是1-5数字,value是这个数字的2次⽅。
dict1 = {i: i**2 for i in range(1, 5)}
print(dict1) # {1: 1, 2: 4, 3: 9, 4: 16}
# 将两个列表合并为⼀个字典
list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']
dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)
# 提取字典中⽬标数据
counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
# 需求:提取上述电脑数量⼤于等于200的字典数据
count1 = {key: value for key, value in counts.items() if value >= 200}
print(count1) # {'MBP': 268, 'DELL': 201}
4.3 集合推导式
# 创建⼀个集合,数据为下⽅列表的2次⽅
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1) # {1, 4} # 注意集合的去重功能