【一】字符串类型的内置方法(熟悉)

【1】查找

（1）find方法

#【1】默认从左到右开始查找，找得到则返回元素所在的索引位置
name = 'ligo'
str = name.find('i')
print(str) # 输出 1

#【2】也可在区间内寻找，找不到则返回-1
str = name.find('g',3,4)
print(str) # 输出 -1

#【3】也可以从右到左查找
str = name.rfind('i')
print(str) # 输出 1

（1）index方法

#【1】与find方法类似，但是找不到会报错
name = 'ligo'
str = name.index('i')
print(str) # 输出 1

#【2】也可在区间内寻找
str = name.index('g',0,4)
print(str) # 输出 2
#但是找不到会报错
str = name.index('g',3,4)
print(str)
'''
Traceback (most recent call last):
  File "D:\Python\pythonProject\pythonProject1\dmeo2.py", line 31, in <module>
    str = name.index('g',3,4)
ValueError: substring not found
'''

#【3】也可以从右到左查找
str = name.rindex('i')
print(str) # 输出 1

（1）count方法

#计算指定字符在字符串出现的次数
num = '12345666666'
str = num.count('6')
print(str) # 输出 6

【2】填充

#【1】center
#字符串长度要基于给指定字符长度的基础上增加
name = 'ligo'
# # 如果是偶数，两边填充的长度一致
print(name.center(len(name) + 4, '#'))  #输出 ##ligo##
# # 如果是奇数，左少右多
print(name.center(len(name) + 5, '#'))  #输出 ###ligo##

#【2】ljust
#左对齐，指定字符填充在原字符串的右侧
print(name.ljust(len(name) + 4, '#'))  #输出 ligo####

#【3】rjust
#右对齐，指定字符填充在原字符串的右侧
print(name.rjust(len(name) + 4, '#'))   #输出 ####lig

#【4】zfill
# 用 0 填充，填充在字符串左侧
print(name.zfill(len(name) + 4))  #输出 0000ligo

【3】制表符

name = 'ligo\tgood'  # \t表示制表符(tab键)
print(name)  # 输出 ligo	good
print(len(name)) # 输出 9
expand_name = name.expandtabs(3)   #修改\t制表符代表的空格数
print(expand_name,len(expand_name))
# 输出 ligo  good 10

【4】首字母大写

#【1】只将这一句的第一个单词的首字母大写，其他不变
text = "i am 18 years old"
print(text.capitalize())
#输出 I am 18 years old

#【2】还有一种是将这一句的每个单词的首字母都大写
text = "i am 18 years old"
print(text.title())
#输出 I Am 18 Years Old

【5】大小写翻转

#大写变小写，小写变大写
name = 'LIgo'
print(name.swapcase())  #输出 liGO

【6】判断字符类型

name = 'ligo666'
print(name.isalnum())    # 字符串中既可以包含数字也可以包含字母 True
print(name.isalpha())    # 字符串中只包含字母 False
print(name.isidentifier())  # 字符串是否是合法标识符 True
print(name.islower())    # 字符串是否是纯小写 True
print(name.isupper())    # 字符串是否是纯大写 False
print(name.isspace())    # 字符串是否全是空格 False
print(name.istitle())    # 字符串中的单词首字母是否都是大写 False

【二】列表类型(list)

【1】定义

• 列表可以包含多个元素，每个元素之间用逗号隔开，并用方括号 [] 括起来

num = [1, 2, 3, 4, 5]
word = ['a', 'b', 'c', 'd', 'e']

【2】内置方法(优先)

（1）类型强转

• list()会跟for循环一样遍历出数据类型中包含的每一个元素然后放到列表中

#字符串取出的是字符串的每一个字符
name = 'ligo'
print(list(name))
#输出 ['l', 'i', 'g', 'o']

#元祖取出的与原来的一致
tuple = (1,2,3)
print(list(tuple))
#输出 [1, 2, 3]

#字典取出的元素是键
dict = {'username': 'ligo', 'password': '123'}
print(list(dict))
#输出 ['username', 'password']

#集合取出的是去重之后的元素
set = {1, 2, 3, 6, 6, 6, 6}
print(list(set))
#输出 [1, 2, 3, 6]

#range关键字也可以转换为列表
print(list(range(10)))
#输出 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 数字不可以（整数和浮点数）
print(list(1))
print(list(3.14))
# 布尔也不可以
print(list(True))

（2）按索引存取值

[1]正向取值

num = [1, 2, 3, 4, 5]
print(num[2])
# 输出 3

[2]反向取值

num = [1, 2, 3, 4, 5]
print(num[-2])
# 输出 4

[3]索引取值无则报错

#可以按照索引修改指定位置的值
num = [1, 2, 3, 4, 5]
num[1] = 0
print(num)
# 输出 [1, 0, 3, 4, 5]

#但如果索引不存在则报错
print(num[6])
'''
Traceback (most recent call last):
  File "D:\Python\pythonProject\pythonProject1\dmeo2.py", line 142, in <module>
    print(num[6])
IndexError: list index out of range
'''

（3）切片

#顾头不顾尾
num = [1, 2, 3, 4, 5]
print(num[0:3])
# 输出 [1, 2, 3]

#步长
num = [1, 2, 3, 4, 5]
print(num[0:5:2])
#输出 [1, 3, 5]

（4）计算长度

num = [1, 2, 3, 4, 5]
print(len(num))
# 输出 5

（5）成员运算

#in
num = [1, 2, 3, 4, 5]
print(4 in num)
# 输出 True

#not in
num = [1, 2, 3, 4, 5]
print(6 not in num)
# 输出 True

（6）增加

[1]默认追加(append())

#append()默认追加在末尾
num = [1, 2, 3, 4, 5]
num.append(6)
print(num)
# 输出 [1, 2, 3, 4, 5, 6]

[2]一次性添加多个(extend())

#extend()一次性在列表尾部添加多个元素、合并列表
num1 = [1, 2, 3, 4, 5]
num2 = [6, 7, 8, 9, 10]
num1.extend(num2)
print(num1)
# 输出 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

[3]指定位置添加(insert())

#insert()在指定位置添加元素
numbers = [1, 2, 3, 4, 5]
numbers.insert(0, 0)
print(numbers)
# 输出 [0, 1, 2, 3, 4, 5]

（7）删除

[1]del

#删除指定索引的元素
num = [1, 2, 3, 4, 5]
del num[1]
print(num)
# 输出 [2, 3, 4, 5]

[2]pop

#pop()默认删除列表最后一个元素，并将删除的值返回
num= [1, 2, 3, 4, 5]
print(num.pop())  # 输出 5
#括号内可以通过加索引值来指定删除元素
print(num.pop(1))  # 输出 2
print(num)       # 输出 [1, 3, 4]

[3]remove

#remove()括号内指定要删除哪个元素，没有返回值
num = [1, 2, 3, 4, 5]
num.remove(1)
print(num)  # 输出 [2, 3, 4, 5]
#注意：如果指定的值不存在，会报错，而pop()可以通过索引删除元素，并且不会报错

（8）颠倒元素

num = [1, 2, 3, 4, 5]
print(num.reverse())  
# 输出 [5, 4, 3, 2, 1]

（9）元素排序

[1]sort()方法

#sort()方法用于对列表进行排序，默认是升序排序。
num = [2, 8, 3, 0, 5, 4]
num.sort()
print(num)  # 输出 [0, 2, 3, 4, 5, 8]

#降序排序，使用reverse参数：
num = [2, 8, 3, 0, 5, 4]
num.sort(reverse=True)
print(num)  # 输出 [8, 5, 4, 3, 2, 0]
#注意，sort()方法会直接修改原列表，而不会返回一个新的排序后的列表。

[2]sorted()方法

#如果需要保留原列表，可以使用sorted()函数
num = [2, 8, 3, 0, 5, 4]
print(sorted(num)) #输出 [0, 2, 3, 4, 5, 8]
print(num)  #输出 [2, 8, 3, 0, 5, 4]

#sort()方法默认是按照元素的大小进行排序，如果需要自定义排序规则，可以使用key参数，传入一个函数。例如，按照元素的绝对值进行排序：
num = [2, -8, 3, 0, 5, -4]
num.sort(key=abs)
print(num)  # 输出 [0, 2, 3, -4, 5, -8]
#key参数指定的函数将应用于列表中的每个元素，用于提取排序的关键字。

（10）遍历循环

[1]for循环

nums = [1, 2, 3, 4, 5]
for num in nums:
    print(num)
    #输出 1 2 3 4 5

[2]while循环

nums = [1, 2, 3, 4, 5]
count = 0
while count < len(nums):
    print(nums[count])
    count += 1
# 输出 1 2 3 4 5

[3]遍历时获取索引

#使用 enumerate()函数获取索引和值
nums = [1, 2, 3, 4, 5]
for index,num in enumerate(nums):
    print(f"index:{index}, num:{num}")
#输出 index:0, num:1
   # index:1, num:2
   # index:2, num:3
   # index:3, num:4
   # index:4, num:5

（11）步长操作

#【1】正向步长
#从列表的开头向末尾按指定步长取元素：
num = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(num[::2])
# 输出 [1, 3, 5, 7, 9]

#【2】反向步长
#从列表的末尾向开头按指定步长取元素：
num  = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(num[::-3])
# 输出 [9, 6, 3]

#【3】列表翻转
#将列表中的元素顺序颠倒过来：
num = [1, 2, 3, 4, 5]
print(num[::-1])
# 输出 [5, 4, 3, 2, 1]

【三】字典类型(dict)

【1】定义

• 字典中的元素是以键值对的方式存储在字典里的
• 字典中的数据是无序的，不能通过索引来访问，而是通过键来访问
• 字典中的键必须是不可变的，通常使用字符串、数字或元组作为键，字典中的值可以是任意类型，包括数字、字符串、列表、字典等
• 字典用花括号 {}来定义，并使用冒号 分隔键和值，多个键值对之间使用逗号分隔

dict = {'username': 'ligo', 'password': '123'}
#定义字典也可以用dict函数
dict = dict(name='ligo', password='123')

【2】内置方法

（1）取值

[1]按键key取值

#用['键名']来取出对应键的值
dict = {'username': 'ligo', 'password': '123'}
print(dict['username'])  #输出 ligo

[2]get取值

#使用get方法获取对应键的值，如果键不存在，返回None
dict = {'username': 'ligo', 'password': '123'}
print(dict.get('username'))  #输出 ligo
print(dict.get('password'))  #输出 123

（2）计算长度

#len函数计算字典中键值对的个数
dict = {'username': 'ligo', 'password': '123'}
print(len(dict)) #输出 2

（3）成员运算

#使用in和not in可以判断一个键是否在字典中
dict = {'username': 'ligo', 'password': '123'}
print('username' in dict)  # 输出 True
print('hobby' not in dict)  # 输出 True

（4）增加

[1]新增键值对

dict = {'username': 'ligo', 'password': '123'}
dict['hobby'] = 'read'
print(dict)
#输出 {'username': 'ligo', 'password': '123', 'hobby': 'read'}

[2]批量新增键值对(update())

#使用update方法可以批量新增键值对，如果键已经存在，则更新对应的值
dict = {'username': 'ligo', 'password': '123'}
dict.update({'hobby': 'read', 'phone': '123456'})
print(dict)
#输出 {'username': 'ligo', 'password': '123', 'hobby': 'read', 'phone': '123456'}

[3]增加值并返回值(setdefault())

#setdefault(key, default)方法用于获取指定键的值，如果键不存在，则返回默认值，并在字典中添加键值对
dict = {'username': 'ligo', 'password': '123'}
hobby = dict.setdefault('hobby', 'read')
print(hobby)  #输出 read 
print(dict)   #输出 {'username': 'ligo', 'password': '123', 'hobby': 'read'}

（5）删除

[1]按键删除(del)

#使用del关键字根据键删除字典中的键值对
dict = {'username': 'ligo', 'password': '123', 'hobby': 'read'}
del dict['hobby']
print(dict)
#输出 {'username': 'ligo', 'password': '123'}

[2]弹出键值对(pop())

#使用pop方法根据键弹出字典中的键值对，同时返回被弹出的值
dict = {'username': 'ligo', 'password': '123', 'hobby': 'read'}
print(dict.pop('hobby')) #输出 read
print(dict)
#输出 {'username': 'ligo', 'password': '123'}

[3]清空字典(clear())

#使用clear方法可以清空字典中的所有键值对
dict = {'username': 'ligo', 'password': '123', 'hobby': 'read'}
dict.clear()
print(dict)
#输出 {}

[4]随机删除键值对(popitem())

#popitem()方法用于随机删除字典中的一个键值对，并以元组的形式返回被删除的键值对，因为字典是无序的，所以删除的是一个随机的键值对
dict = {'username': 'ligo', 'password': '123', 'hobby': 'read'}
print(dict.popitem()) #输出 ('hobby', 'read')
print(dict)
#输出 {'username': 'ligo', 'password': '123'}
#注意：popitem()在Python 3.7+中删除的是字典中的“末尾”键值对，但在旧版本的 Python 中，删除的并不是末尾的键值对

（6）键对

#使用keys方法可以获取字典中所有的键
dict = {'username': 'ligo', 'password': '123'}
print(dict.keys())  # 输出 dict_keys(['username', 'password'])

（7）值对

#使用values方法可以获取字典中所有的值
dict = {'username': 'ligo', 'password': '123'}
print(dict.values())  # 输出 dict_values(['ligo', '123'])

（8）键值对

#使用items方法可以获取字典中所有的键值对
dict = {'username': 'ligo', 'password': '123'}
print(dict.items())   # 输出 dict_items([('username', 'ligo'), ('password', '123')])

（9）遍历循环

#【1】只遍历key
dict = {'username': 'ligo', 'password': '123'}
for key in dict:
    print(key)
# 输出
# username
# password

#【2】只遍历value
dict = {'username': 'ligo', 'password': '123'}
for value in dict.values():
    print(value)
# 输出
# ligo
# 123

#【3】遍历key和value
dict = {'username': 'ligo', 'password': '123'}
for key,value in dict.items():
    print(f"{key}:{value}")
# 输出
# username:ligo
# password:123

（10）字典排序

#字典的排序是通过字典的键来进行的，使用sorted()函数可以对字典进行排序
dict = {'a': 6, 'e': 1, 'j': 9, 'd': 3}
print(sorted(dict.items()))
#输出 [('a', 6), ('d', 3), ('e', 1), ('j', 9)]

#如果需要按值进行排序，可以使用key参数指定排序的关键字
dict = {'a': 6, 'e': 1, 'j': 9, 'd': 3}
print(sorted(dict.items(), key=lambda x: x[1]))
#输出 [('e', 1), ('d', 3), ('a', 6), ('j', 9)]