数据类型及操作
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} # 注意集合的去重功能
528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
