Python基础学习笔记（二）—— 数据类型及操作

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

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)

②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)) # 
s5 = {}
print(type(s5)) # 

注意：

• 集合可以去掉重复数据；
• 集合数据是无序的，故不支持下标
• 集合内的元素必须是可哈希（不可变）的,但是集合本身是不可哈希（可变）的

1.5.2 集合的操作

（1）增加

① 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))) # 
print(type(eval(str2))) # 
print(type(eval(str3))) # 

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} # 注意集合的去重功能