python笔记3 | 字符串 列表 元组 字典

1. 字符串

前面讲过的格式化类型和输入input函数就不多解释

格式化输出%s

name="BENNI"
print(f"my name is {name}")
print("my name is %s" % name)

1.1 下标

从0开始，从左向右依次递增，格式：序列名[下标编号]

str1="helloworld"
print(str1)
print(str1[0])
print(str1[6])

#输出
helloworld
h
w

1.2切片

切⽚片是指对操作的对象截取其中⼀一部分的操作。字符串串、列表、元组都⽀支持切⽚片操作。

---

序列[开始下标位置 : 结束下标位置 : 步长]

1.不包含结束下标对应的数据，正负数均可
2.步长是选取间隔，默认为1，负数就是反着来

name = "abcdefg"
print(name[2:5:1])  # cde 
print(name[2:5])  # cde 
print(name[:5])  # abcde 
print(name[1:])  # bcdefg 
print(name[:])  # abcdefg 
print(name[::2])  # aceg
print(name[:-1])  # abcdef, 负1表示倒数第⼀一个数据 print(name[-4:-1])  # def 
print(name[::-1])  # gfedcba

1.3查找

所谓字符串串查找⽅方法即是查找子串在字符串中的位置或出现的次数

1.3.1 find

find()：检测某个⼦子串串是否包含在这个字符串串中，如果在返回这个⼦子串串开始的位置下标，否则则返 回-1。

字符串串序列列.find(子串, 开始位置下标, 结束位置下标）

注意：开始和结束位置下标可以省略略，表示在整个字符串串序列列中查找。

mystr = "hello world and BENNI and Python"
print(mystr.find('and'))  # 12 print(mystr.find('and', 15, 30))  # 22 print(mystr.find('ands'))  # -1

1.3.2 index

index()：检测某个⼦子串串是否包含在这个字符串串中，如果在返回这个⼦子串串开始的位置下标，否则报错。（find区别）

字串串序列列.index(⼦串, 开始位置下标, 结束位置下标）

注意：开始和结束位置下标可以省略略，表示在整个字符串串序列列中查找。

mystr = "hello world and wechat and Benni and Python"
print(mystr.index('and'))  # 12 print(mystr.index('and', 15, 30))  # 23 print(mystr.index('ands'))  # 报错

• rfind()： 和find()功能相同，但查找⽅方向为右侧开始。
• rindex()：和index()功能相同，但查找⽅方向为右侧开始。
• count()：返回某个⼦子串串在字符串串中出现的次数

1.3.3 count

字符串序列.count(子串, 开始位置下标, 结束位置下标）

查找相应的子串在字符串中出现的次数，未出现返回0

mystr = "hello world and wechat and benni and Python"
print(mystr.count('and'))  # 3 print(mystr.count('ands'))  # 0 print(mystr.count('and', 0, 20))  # 1

1.4 修改

replace()：替换

split()：按照指定字符分割字符串。

join()：⽤用⼀个字符或子串合并字符串，即是将多个字符串合并为⼀一个新的字符串。

capitalize()：将字符串串第⼀一个字符转换成⼤大写。 title()：将字符串每个单词首字母转换成⼤写。

此部分感觉不太重要，跳过

2.列表

数据分为可变类型和不可变类型，字符串是不可变类型，列表可变

2.1查找

2.1.1下标

和字符串大同小异，0起始

2.2.2函数

2.2.2.1index

name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2))  # 1

2.2.2.2count

count()：统计指定数据在当前列列表中出现的次数。

name_list = ['Tom', 'Lily', 'Rose']
print(name_list.count('Lily'))  # 1

2.2.2.3 len

len()：访问列列表⻓长度，即列列表中数据的个数。

name_list = ['Tom', 'Lily', 'Rose']
print(len(name_list))  # 3

2.2.3判断是否存在

in：判断指定数据在某个列列表序列列，如果在返回True，否则返回False

name_list = ['Tom', 'Lily', 'Rose']
# 结果：True 
print('Lily' in name_list)
# 结果：False 
print('Lilys' in name_list)

实例

name_list = ['Tom', 'Lily', 'Rose']
name = input('请输⼊入您要搜索的名字：')
if name in name_list:    
	print(f'您输⼊入的名字是{name}, 名字已经存在')
else:    
	print(f'您输⼊入的名字是{name}, 名字不不存在')

2.3增加

2.3.1append

append()：列表结尾追加数据，如果追加的数据是一个序列，则追加整个序列。

列表序列.append(数据)

name_list = ['Tom', 'Lily', 'Rose']
name_list.append('[BENNI, YE]')

# 结果：['Tom', 'Lily', 'Rose', '[BENNI, YE]'] 
print(name_list)

2.3.2 extend

extend()如果追加的数据是一个序列，则逐一追加到原序列后

name_list = ['Tom', 'Lily', 'Rose']
name_list.extend('BENNI')
# 结果：['Tom', 'Lily', 'Rose', 'B', 'E', 'N', 'N', 'I'] 
print(name_list)

2.3.3insert

列表序列.insert(位置下标, 数据)

insert()指定位置新增数据

name_list = ['Tom', 'Lily', 'Rose']
name_list.insert(1, 'benni')
# 结果：['Tom', 'benni', 'Lily', 'Rose'] print(name_list)

2.4 删除

2.4.1del

del 目标

1.删除列表

name_list = ['Tom', 'Lily', 'Rose']
# 结果：报错提示：name 'name_list' is not defined del name_list 
print(name_list)

2.删除指定下标数据

name_list = ['Tom', 'Lily', 'Rose']
del name_list[0]
# 结果：['Lily', 'Rose'] 
print(name_list)

2.4.2 pop

列表序列.pop（下标）
删除指定数据（默认最后一个），并返回该数据。

name_list = ['Tom', 'Lily', 'Rose']
del_name = name_list.pop(1)

# 结果：Lily 
print(del_name)

# 结果：['Tom', 'Rose'] 
print(name_list)

2.4.3 remove&clear

remove()：移除列列表中某个数据的第⼀个匹配项。

列表序列.remove(数据)

name_list = ['Tom', 'Lily', 'Rose']
name_list.remove('Rose')

# 结果：['Tom', 'Lily']
print(name_list)

2.5修改

修改指定下标

name_list = ['Tom', 'Lily', 'Rose']
name_list[0] = 'aaa'
# 结果：['aaa', 'Lily', 'Rose']
print(name_list)

2.6循环遍历

2.6.1 while

name_list = ['Tom', 'Lily', 'Rose']

i = 0
while i < len(name_list):
	print(name_list[i])
	i += 1

--------------输出结果如下------------
Tom
Lily
Rose

2.6.2 for

name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
	print(i)


--------------输出结果如下------------
Tom
Lily
Rose

for的代码量少于while，优先考虑for

2.7列表嵌套

3.元组

不支持修改，可用于计入身份证号，只支持查找

3.1定义元组

# 多个数据元组
t1 = (10, 20, 30)
# 单个数据元组
t2 = (10,)

要逗号，不然就是其他类型，如上面第二个单个数据的没有逗号，t2就是int类型

3.2查找

以数据a，b，c为例

index 查找a是在第几个
count 统计a出现多少次
len 统计整个元组有多少个数据
如果元组里面有列表，列表可以修改

4.字典

不支持下标，字典数据和数据顺序没有关系，字典数据以键值对形式出现

4.1创建字典

K就是key，V就是value

字典={ K：V ，K2:V2…} K：V就是一个键值对

4.1.1有数据字典

dict1 = {
     'name': 'Tom', 'age': 20, 'gender': '男'}

4.1.2 无数据字典

dict2 = {
     }

4.2增

字典序列[key]=值

4.3删

如果要删除一个key值

del dect1["name"]

如果要清空一个字典
字典名.clear()

4.4换

如果要修改字典里key的值，和增操作一样：字典序列[key]=值

4.5查

4.5.1 KEY值查找

有就打印，没有就报错

4.5.2 get（）

字典序列列.get(key, 默认值)

dict1 = {
     'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name')) # Tom
print(dict1.get('id', 110)) # 110
print(dict1.get('id')) # None

4.5.3 values()

查找keys的所有值

dict1 = {
     'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values()) # dict_values(['Tom', 20, '男'])

4.5.4 items（）

查找字典中的所有键值对，返回可迭代对象，以元组形式出现，元组数据1是key，2是数据的值

dict1 = {
     'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items()) # dict_items([('name', 'Tom'), ('age', 20), ('gender',
'男')])

4.6 字典的循环遍历

4.6.1 遍历字典的key

dict1 = {
     'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
	print(key)

---------------输出结果如下-------------
name
age
gender

4.6.2 遍历字典的value

dict1 = {
     'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
	print(value)

---------------输出结果如下-------------
Tom
20
男

4.6.3遍历字典的元素

dict1 = {
     'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
	print(item)

-------------------输出结果如下-------------
{
     'name': 'Tom'}
{
     'age': 20}
{
     'gender': '男'}

4.6.4 遍历字典的键值对

遍历后拆包，键值对用items

dict1 = {
     'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
	print(f'{key} = {value}')

-------------------输出结果如下-------------
name=Tom
age=20
gender=男