基本数据类之内置方法

一.字符串的内置方法（二）

1.移除字符串首尾的指定字符，可以选择方向

s = '###oscar###'
print(s.strip('#'))  # oscar 默认首位都去除
print(s.lstrip('#'))  # oscar### 去除左边
print(s.rstrip('#'))  # ###oscar 去除右边

2.大小相关操作

# 大小写相关操作
s1 = 'OsCar Is BoY'
print(s1.lower())  # 把字符串的字母全部换成小写 oscar is boy
print(s1.upper())  # 把字符串的字母全部换成大写 OSCAR IS BOY
print(s1.islower())  # 判断字符串的字母是否全部是小写 结果返回布尔值
print(s1.isupper())  # 判断字符串的字母是否全部是大写 结果返回布尔值

利用这个小知识点我们可以做一个经常见的验证码功能：

# 图片验证码
l = 'Oas125A'
print('呈现给用户的%s:'%l)
i = input('输入验证码:').strip()
if l.lower() == i.lower():  # 在这里同意换成小写
    print('验证码正确')
else:
    print('验证码错误')

3.判断字符串的首尾是否是指定的字符

# 判断字符串的首尾是否是指定的字符
s3 = 'oscar tony jason'
print(s3.startswith('o'))  # 判断开头的字母，返回结果是布尔值 True
print(s3.startswith('oscar'))  # 也可以是多个字符 True
print(s3.startswith('tony'))  # False
print(s3.endswith('n'))  # 判断结尾的字母 True
print(s3.endswith('jason'))  # 也可以是多个字符

4.格式化输出

（1）.占位符（就是根据%s、%d来占位）

（2）.format方法：

方式一：跟占位符差不多

print('my name is {} ,age is {}'.format('oscar',21))  # 用花括号{}来占位

方式二：根据索引取值，可以反复使用

print('my name is {0} {0} ,age is {1} {0}'.format('oscar',21))  # 根据下标来索引取值

方式三：直接指定

print('my name is {name},age is {age}'.format(name = 'oscar', age = 21))  #  直接指名道姓

方式四：直接使用已经出现过的变量

name = 'oscar'
age = 21
print('my name is {name},age is {age}')  # 直接输入变量名

5.拼接字符串

# 拼接字符串
s4 = '你好'
s5 = '我是oscar'
print(s4 + s5)  # 连接字符串 你好我是oscar
print(s4 * 5)  # 重复某个字符串，重复几遍就乘多少 你好你好你好你好你好
# join方法相当于将括号内的元素进行for循环
print(','.join(s5))  # 我,是,o,s,c,a,r
print('|'.join(['oscar','tony','jason']))  # oscar|tony|jason
# 注意：join的元素必须是字符串，否则报错

6.替换字符串中指定的字符

# 替换字符串中指定的字符
s6 = 'oscar oscar oscar oscar oscar'
print(s6.replace('oscar','jason'))  # jason jason jason jason jason
print(s6.replace('oscar','jason',2))  # 也可以指定替换的个数，从左往右数 jason jason oscar oscar oscar

7.判断字符串是否是纯数字

# 判断字符串是否是纯数字
print('oscar123'.isdigit())  # 判断字符串是否是纯数字组成，返回结果是布尔值 False
print('12.23'.isdigit())  # 带小数点也不行 False
print('123456'.isdigit())  # 必须是纯数字 True

有这个知识点我们就可以解决成绩判断不小心输入字母或小数点的问题：

score = input('>>:')
if score.isdigit():  # 判断是否是纯数字
    score = int(score)
else:
    print('输错了')

了解操作

1.查找指定字符对应的位置

# 查找指定字符对应的位置
s8 = 'oscar is boy'
print(s8.find('r'))  # 从左往右查找，找到一个就结束
print(s8.find('b', 0, 7))  # 在一个指定的范围寻找，-1就是没有找到
print(s8.index('s'))  # 从左往右查找，找到一个就结束
print(s8.index('b', 0 , 7))  # index找不到就会报错，不建议使用

2.文本位置改变

# 文本位置改变
s9 = 'oscar'
print(s9.center(15, '*'))  # 字符串在中间，其余的用“*”补充 *****oscar*****
print(s9.ljust(15, '*'))  # 字符串在左边，其余的用“*”补充 oscar**********
print(s9.rjust(15, '*'))  # 字符串在右边，其余的用“*”补充  **********oscar
print(s9.zfill(15))  # 字符串在右边，其余的用“0”补充 0000000000oscar

3.特殊符号：斜杠与一些一些英文字母的组合会产生特殊的含义

# 特殊符号
print('oscar\njason\tto\any')  # \n换行符，\t四个空格，\a：“”
print(r'oscar\njason\tto\any')  # 前面加一个“r”就可以取消特殊含义 oscar\njason\tto\any

4.captalize,swapcase,title

（1）.首字母大写

# 首字母大写
s = 'oscar is boy'
print(s.capitalize())  # Oscar is boy

（2）.大小写翻转

# 大小写翻转
s = 'oscar IS Boy'  # OSCAR is bOY
print(s.swapcase())

（3）.每个单词首字母大写

# 每个单词的首字母大写
s = 'oscar IS Boy'  # Oscar Is Boy
print(s.title())

列表内置方法

1.类型转换

列表类型转换支持遵循for循环的数据类型，所以可以进行列表数据类型转换的基本数据类型有：字典、字符串、元组、集合。

# 类型转换
print(list(11))  # 报错
print(list(11.22))  # 报错
print(list(True))  # 报错
print(list('oscar'))  # ['o', 's', 'c', 'a', 'r']
print(list({'name':'oscar','age': 21}))  # ['name', 'age']
print(list({11, 22, 33}))  # [33, 11, 22]
print(list((11, 22, 33)))  # [11, 22, 33]

2.索引取值

# 索引取值
s = ['oscar', 'jason', 11, 22]
print(s[2])

3.切片操作

# 切片操作
s = ['oscar', 'jason', 11, 22]
print(s[0:3])  # ['oscar', 'jason', 11]
print(s[-2:-1])  # [11]

4.步长

# 步长
s = ['oscar', 'jason', 11, 22]
print(s[0:3])  # ['oscar', 'jason', 11]
print(s[0:3:2])  # ['oscar', 11]

5.统计列表中元素的个数

# 统计列表中元素的个数
s = ['oscar', 'jason', 11, 22]
print(len(s))  # 4

6.成员运算，最小判断单位是元素，不是元素中的字符

# 成员运算
s = ['oscar', 'jason', 11, 22]
print(11 in s)  # True
print(1 in s)  # False

7.列表添加元素

方式一：在尾部添加单个元素

# 在尾部添加元素
s = ['oscar', 'jason', 11, 22]
s.append('tony')
print(s)  # ['oscar', 'jason', 11, 22, 'tony']

方式二：在指定位置添加单个元素

# 在指定位置添加元素
s = ['oscar', 'jason', 11, 22]
s.insert(2, 'tony')
print(s)  # ['oscar', 'jason', 'tony', 11, 22]

方式三：合并列表

# 合并列表
s = ['oscar', 'jason', 11, 22]
s1 = ['tony', 33, 55]
s.extend(s1)
print(s)  # ['oscar', 'jason', 11, 22, 'tony', 33, 55]

8.删除元素

方式一：通用的删除方式

# 通用删除方式
s = ['oscar', 'jason', 11, 22]
del s[1]
print(s)  # ['oscar', 11, 22]

方式二：指定的直接删除元素

# 指定直接删除元素
s = ['oscar', 'jason', 11, 22]
print(s.remove('oscar'))  # 直接删除，不在使用 None
print(s)  # s = ['oscar', 'jason', 11, 22]

方式三：延迟删除

# 延迟删除
s = ['oscar', 'jason', 11, 22]
print(s.pop())  # 22 默认是最后一位，还可以调用
print(s)  # ['oscar', 'jason', 11]
print(s.pop(1))  # jason 可以指定
print(s)  # ['oscar', 11]

9.修改列表元素

# 修改列表元素
s = ['oscar', 'jason', 11, 22]
s[1] = 'tony'
print(s)  # 指定元素修改 ['oscar', 'tony', 11, 22]

10.排序

# 排序
s = [11, 22, 99, 22, 44, 66]
s.sort()  # 默认是升序 
print(s)  # [11, 22, 22, 44, 66, 99]
s.sort(reverse=True)  # 修改为降序
print(s)  # [99, 66, 44, 22, 22, 11]

11.翻转

# 翻转
s = [11, 22, 99, 22, 44, 66]
s.reverse()  # 前后颠倒
print(s)  # [66, 44, 22, 99, 22, 11]

12.比较运算

# 比较运算
s = [11, 22, 99, 22, 44, 66]
s1 = [33, 1, 2, 3]
print(s1 > s)  # True 列表比较的时候，比较的是相同索引位置上的元素，有一个出来结果，后面的就不在做比较

13.统计列表中某个元素出现的次数

# 统计列表中某个元素出现的次数
s = [11, 22, 22, 33, 11, 55, 11, 33, 66, 22, 44]
print(s.count(11))  # 3

14.清除列表中元素

# 清除元素
s = [11, 22, 22, 33, 11, 55, 11, 33, 66, 22, 44]
s.clear()
print(s)  # 清除所有元素 []

可变类型和不可变类型

可变类型：值改变，内存地址不变，改变的是本身

 不可变类型：值改变，内存地址肯定改变，修改过程中产生了新的值

 查看内存地址的方法：id关键字

# 不可变类型 字符串
s = '##oscar##'
print(id(s.strip('#')))  # 2604580852600
print(id(s))  # 2604580875440

# 可变类型 列表
s = [11, 22, 33]
print(id(s))  # 3094027050248
s.append(111)
print(id(s))  # 3094027050248

队列与堆栈

队列：先进先出

# 队列
s = []
# 先进
s.append(1)
s.append(2)
s.append(3)
print(s)
# 先出
for i in s:
    print(i)
print(s.pop(0))
print(s.pop(0))
print(s.pop(0))

堆栈：先进后出

# 堆栈
s = []
# 先进
s.append(1)
s.append(2)
s.append(3)
print(s)
# 后出
print(s.pop())
print(s.pop())
print(s.pop())