部分数据类型的内置方法及字符串内置方法

昨日内容回顾

【一】循环结构

【1】while 循环

• break：退出当前循环
• coutinue：退出本次循环
• tag : 标志位，可以通过最里层的标志位直接将最外层的while循环断掉

【2】for 循环

• 遍历可迭代类型（可以被索引取值的都可以被迭代，可一个个取值的就是可迭代的）
• 遍历的意思就是将被需要遍历的类型中的每一个值取出来
• [' ',' ', ' ']

【3】range关键字

• 生成一系列数字
• 可以实现重复获取

for i in range(1,5):
    name = f"gdy and hyt{i}"
    print(name)
# gdy and hyt1
# gdy and hyt2
# gdy and hyt3
# gdy and hyt4    

【二】数据类型的内置方法

【1】数字类型

（1）整数类型

• 强制类型转换：必须符合整数类型的格式

• 进制转换：bin 二进制 hex 十六进制（有字母） oct 八进制（不超过8）

• int 可以将其他进制转回十进制

• isdigit() 可以判断当前是否符合整数类型的形式

（2）浮点数类型

• 强制类型转换：必须符合浮点数类型的格式

• isdecimal() 可以判断当前是否符合浮点数类型的格式

【2】字符串类型

（1）字符串拼接

• 用 + 进行拼接

（2）字符串 * 数字

• 相当于当前字符串重复 数字的次数

（3）切分 split

• 默认参数 是空格
• 可以指定参数 |
• 默认是从左向右 并且默认切的次数不限，可以控制次数

name = "gdy|hyt|999"
print(name.split("|"))
print(name.split('|',1))		# 切一次

• 可以修改切的方向，从右向左，可以更改成从左向右
• rsplit

print(name.rsplit("|",1))

（4）切片 按照指定区间将字符串的某部分 提出来

• 切片也是 顾头不顾尾

print(name[0:5])

• 步长

print(name[0:5:2])

（5）计算长度 len

print(len(name))

（6）索引取值

• 正索引从0开始

• 负索引从-1开始

（7）去除首尾特殊字符 strip

• 默认去除空格

name = ' $gdy$ '
name = '$gdy$'
print(len(name))
print(name.strip())
# 指定去除的字符，默认是去除两侧
print(name.strip('$'))
# 指定去除某侧的特殊字符
print(name.lstrip('$'))
print(name.rstrip('$'))

（8）替换 ---> 旧的换成新的字符

• replace(需要替换的内容，替换后的内容)

name = "gdy_and_hyt"
# 替换原来的字符，成为新的字符
print(name.replace('_and_',"or"))

（9）控制字符串的大小写

name = "gdy"
# 让英文字符全大写
print(name.upper())
# 全小写
print(name.lower())

（10）判断首位字符 startswith / endswith

name = 'cool_girl_hyt'
print(name.startswith('cool'))			# 开头
print(name.endswith('hyt'))				# 结尾

（11）字符串的格式输出语法

• %s %d只能按位置
• format 按位置或者关键字
• f + {}只需要放进去就行

（12）' '.join() ---> 得到的结果是字符串

• 对参数的要求比较特殊，参数必须是可遍历的

（13）判断字符串是否全是大写或小写

name = "Gdy"
print(name.isupper())		# 大写
print(name.islower())		# 小写

今日内容

不需硬记（字符串内置）

（1）字符串的查找 字符串内部的字符

name = "gdy hello"

• 默认是从左向右找并且返回当前字符在字符串内部的索引坐标

print(name.find('d'))  # 2

（2）index 方法

• index 查找不存在的字符就会报错

print(name.index('A'))

• 默认从左向右找并且只找一次

print(name.index('g'))

• 指定查找的方向从右向左

print(name.rindex('g'))

（3）计算当前字符在字符串中出现的次数

print(name.count('d'))
name = 'gdy and hyt'
print(name.count('d'))
print(name.find('d'))
print(name.rindex('d'))

（4）填充字符串

• 填充的长度[算上原本字符串长度填充后的长度]，填充的字符

• 如果是偶数则两侧填充一致

name "gdy"
print(name.center(len(name) + 2,'*'))

如果是奇数，左少右多

name "gdy"
print(name.center(len(name) + 3,'*'))

name "gdy"

• 只填充左侧用r

print(name.ljust(len(name) + 3,'*'))

• 只填充右侧l

print(name.rjust(len(name) + 3,'*'))

• 补充字符串，不够的长度用 0 补齐

print(name.zfill(len(name + 3)))

（5）制表符

name = 'gdy \thello'
print(name)

（6）首字母大写

sentence =  'my name is hyt'

• 一个句子的首字母大写

print(sentence.capitalize())			# My name is hyt

• 一个句子的每一个单词的首个单词大写

print(sentence.title())					# My Name Is Hyt

（7）单词大小写翻转

name = 'Hyt'
print(name.swapcase())				# hYT

（8）判断字符串类型

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

列表的内置方法

• 只要可迭代的都能转

【1】类型强制转换

（1）字符串可以，并且转换后的列表是字符串的每一个字符

name = 'dream'		
print(list(name))			# ['d', 'r', 'e', 'a', 'm']

(2)元组可以，转换后的列表中的元素类型和转换之前一致

num = (1,2,3,4,5,6,7,8,9,10,11,12)
print(list(num))			# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

（3）字典可以，转换后的列表中存储的元素是当前字典的键

name_dict ={'username':'gdy','password':'123'}
print(list(name_dict))				# ['username', 'password']

（4）集合

num_set = {1,2,3,4,7,7,7,7,5}
print(list(num_set))			# [1, 2, 3, 4, 5, 7]

（5）rang关键字也可以转换为列表，并且元素是指定区间内的每一个元素

print(list(range(0,5)))			# [0, 1, 2, 3, 4]

• 注意：数字不可以，布尔值也不可以

【2】支持索引取值

• 如果取的索引大于总的数据长度就会报错

num_list = [1,2,3]
print(num_list)			# 会报错

【3】切片

num_list =[1,2,3,4,5,6,7,8,9]
print(num_list[0:6:2])				# [1, 3, 5]

【4】计算列表内的元素个数 len

num_list = [1, 2, 3, 4, 5, 6]
print(len(num_list)

【5】成员运算

num_list = [1,2,3,4,5,6,7,8,9]
print(1 in num_list)				# True
print(0 in num_list)				# False

【6】列表操作 增删查改

（1）增加

• append
• 默认追加到最后，没有返回值，直接改变原来的列表

num_list = [1,2,3,4,5,6,7,8,9]
num_list.append(999)
print(num_list)					# [1, 2, 3, 4, 5, 6, 7, 8, 9, 999]

• extend
• 可以追加多个元素，可迭代

num_list = [1,2,3,4,5,6,7,8,9]
num_list.extend([11,22])
num_list.extend((22,3))
print(num_list)					#  [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 22, 3]

• insert
• 可以安装索引位置插入元素
• 语法：参数（索引位置，元素）

num_list = [1,2,3,4,5,6,7,8,9]
num_list.insert(0,66)
print(num_list)					# [66, 1, 2, 3, 4, 5, 6, 7, 8, 9]

（2）删除

• del 列表[索引]
• 可以接受返回值，并且返回删除的那个元素的值
• 可以放索引的位置

num_list = [1,2,3,4,5,6,7,8,9]
del num_list[0]
print(num_list)					# [2, 3, 4, 5, 6, 7, 8, 9]

• pop() ；弹出
• 可以接受返回值，并且返回值就是删除的那个元素

num_list = [1,2,3,4,5,6,7,8,9]

print(num_list.pop())			# 9
print(num_list.pop(0))			# 1
print(num_list)					# [2, 3, 4, 5, 6, 7, 8]

• remove： 必须放定值

num_list = [1,2,3,4,5,6,7,8,9]
num_list.remove(2)
num_list.remove(7)
print(num_list)				# [1, 3, 4, 5, 6, 8, 9]

【7】颠倒元素

num_list = [1,2,3,4,5,6,7,8,9,'gdy']
print(num_list.reverse())				# None
print(num_list)							# ['gdy', 9, 8, 7, 6, 5, 4, 3, 2, 1]

【8】对列表中的元素进行排序

• 不会返回值，直接更改原来的列表

num_list = [1,2,3,8,5,6,9,7]
print(num_list.sort())
print(num_list)				# [1, 2, 3, 5, 6, 7, 8, 9]

• 将排序后的结果倒序

print(num_list.sort(reverse=True))
print(num_list)				# [9, 8, 7, 6, 5, 3, 2, 1]

• sorted 函数
• 可以返回原来值，并输出更改后的值

num_list = [1,2,3,8,5,6,9,7]
num_new = sorted(num_list)
print(num_new)					# [1, 2, 3, 5, 6, 7, 8, 9]
print(num_list)					# [1, 2, 3, 8, 5, 6, 9, 7]

【9】遍历循环列表

• for 直接遍历列表，遍历索引 range
• while 自定义起始值 < 列表最大长度 按照索引取值

【10】列表的步长

num_list = [1,2,3,4,5,6,7,8,9]
print(num_list[::2])				# [1, 3, 5, 7, 9]

• 从头取到尾且倒着取

num_list = [1,2,3,4,5,6,7,8,9]
print(num_list[::-2])				# [9, 7, 5, 3, 1]