数据类型内置方法（上）——整型、浮点型、字符串、列表
什么是内置方法？
每个数据类型都拥有不同的内置功能，这些功能都保存在已经编译好的关键字内，可以直接引用，这些关键字就是内置方法。
数据类型调用内置方法的统一句式为>>>:句点符(.)
# 如：'Alex'. 字符串内置方法 name = 'Alex' name. 字符串内置方法 （# 变量名.内置方法） 'Alex'.字符串内置方法 （#数据值.内置方法）
一、整型内置方法
1. 类型转换（将其他数据类型转换为整型）
- 关键字
int()
浮点型转换成整型：
a = int(11.12) print(a, type(a)) # 11 <class 'int'> b = int(11.58) print(b, type(b)) # 11 <class 'int'>
符点型可以直接转换成整型，小数点部分直接省略。
字符串转换为整型：
a = int('11') print(a, type(a)) # 11 a = int('11.11') print(a, type(a)) # 报错
字符串转换为整形，必须为纯数字，有小数点的情况识别不了，会报错。
2. 进制数转换
将十进制转换为其他进制
将其他进制转换为十进制
二、浮点型内置方法
1. 类型转换（将其他数据类型转换为浮点型）
- 关键字
float(其他数据类型)
整型转换为符点型：
a = float(11) print(a, type(a)) # 11.0 <class 'float'>
字符串转换为符点型：
a = float('11.11') print(a, type(a)) # 11.11 <class 'float'>
b = float('11.1.1')
print(b, type(b)) # 报错
c = float('abc')
print(c, type(c)) # 报错
字符串转换为符点形，必须为纯数字，最多只能有一个小数点，其他情况识别不了，会报错。
三、字符串内置方法
1. 类型转换
- 关键字
str(其他数据类型) - 字符串可以转任意数据类型(只需要在前后加引号即可)
2. 字符串取值
如果想单独截出字符串的部分内容，可以使用字符串取值的功能。
例：s1 = beautiful
（1）索引取值
例： s1 = 'beautiful'
print(s1[0]) # b
print(s1[-1]) # l 支持负数，从末尾开始
print(s1[100]) # 报错 超出范围
（2）切片取值
print(s1[1:5]) # eaut 顾头不顾尾，从索引1一直到索引4 print(s1[-1:-5]) # 默认的顺序是从左往右 print(s1[-5:-1]) # tifu 顾头不顾尾 print(s1[1: 5: 1]) # eaut 从索引1开始，到索引4结束，最后一们数字指的是所取的两个数字的位置差 print(s1[1: 5: 2]) # eu 从索引1开始，到索引4结束，隔一位取一个 print(s1[-1:-5: -1]) # lufi 从右往左取值 print(s1[:]) # beautiful 不写数字默认都要 print(s1[2:]) # autiful 从索引2开始后面都要 print(s1[:5]) # beaut 从索引0开始到索引4结束 print(s1[::2]) # batfl 从索引0开始，隔一位取一个
3. 统计字符串中字符的个数
print(length(s1)
s1 = 'beautiful' print(len(s1)) # 9
4. 移除字符串中的字符
字符串.strip() # 括号内不写，默认移除首尾的空格
a = ' beautiful ' print(len(a)) # 11 print(len(a.strip())) # 9
案例：
username = input('username>>>:') if username == 'Alex': print('登录成功')
在执行上述代码的过程中，如果输入用户名的时候不小心加了空格，命令就不会被执行，如下图：
如何解决这个问题呢？
方法1： username = input('username>>>:').strip() if username == ' Alex': print('登录成功')
方法2： username = input('username>>>:') username = username.strip() if username == 'Alex': print('登录成功')
移除字符串首尾指定的字符
字符串.strip(指定字符)
默认是移除到所有指定的字符，若strip前加l，则是移除左边的，若strip前加r，则是移除右边的。
例：res1 = '&&&Alex&&&&&'
print(res1.strip('&')) # Alex 移除所有 print(res1.lstrip('&')) # Alex&&&&& 移除左边的 print(res1.rstrip('&')) # &&&Alex 移除右边的
5. 切割字符串中指定的字符
字符串.split('想切掉的字符')
该方法的处理结果是一个列表。默认是从左往右切，如果split前加r时，则为从右往左切。
例：res = 'Alex|123|read'
print(res.split('|')) # ['Alex', '123', 'read'] print(res.split('|', maxsplit=1)) # ['Alex', '123|read'] 从左往右切指定个数 print(res.rsplit('|', maxsplit=1)) # ['Alex|123', 'read'] 从右往左切指定个数
6. 字符串格式化输出
(1)等价于%s占位
res = 'My name is {}, my age is {}'.format('Alex', 18) print(res) # My name is Alex， my age is 18
（2）索引取值，并且支持重复使用
res = 'My name is {0}, my age is {1}, {0} used to dream of becoming the richest person in the world when she was {1} years old' .format('Alex', 18) print(res) # My name is Alex, my age is 18, Alex used to dream of becoming the richest person in the world when she was 18 years old
（3）关键字传参（占位符见名知意）
res = 'My name is {name1}, my age is {age1}'.format(name1='Alex', age1=18) print(res) # My name is Alex, my age is 18
（4）推荐使用（***）
在格式化输出前加f方法直接获取上述字符内容并进行填写操作，更加简洁，相当于可以在指定的模板上填写任意的数据值。
name = input('username>>>:') age = input('age>>>:') res = f'my name is {name}, my age is {age}'
7. 字符串大小写转换(只适用于英文字母)
字符串.upper() # 小写字母转大写字母
字符串.lower() # 大写字母转小写字母
例：res = 'hEllO WorLD'
print(res.upper()) # HELLO WORLD print(res.lower()) # hello world
我们在登录一些网页时，经常要输入验证码，验证码中有大写也有小写，用户不管输入大小还是小写都能比对成功，这里面就用到了这样的操作：
运行结果：
另外，字符串.isupper()可以判断字符串是否是纯大写，字符串.islower()可以判断字符串是否是纯小写
res = 'ABCD' print(res.isupper()) # True print(res.islower()) # False
8. 判断字符串中是否是纯数字
res = 'Alex' print(res.isdigit()) # False res = '123456' print(res.isdigit()) # True res = '' print(res.isdigit()) # False
字符串.strip可以使得编写的代码健壮性更强，在必须输入数字的情况下不能输入其他字符。
运行结果：
9. 替换字符串中指定的内容
字符串.replace
res = 'My name is Alex Alex Alex' print(res.replace('Alex', 'Judy')) # My name is Judy Judy Judy
上述方法将原字符串中的”Alex“都替换成了”Judy“，如果要替换指定位置的字符，该怎么操作呢？来看下面的代码：
res = 'My name is Alex Alex Alex' print(res.replace('Alex', 'Judy', 1)) # My name is Judy Alex Alex
# 在后面加上一个数字，表示替换指定位置的字符。
10. 字符串的拼接
ss1 = 'hello' ss2 = 'world' print(ss1 + ss2) # helloworld 把ss1和ss2的字符串组合到一起 print(ss1 * 3) # hellohellohello 把ss1拼接3次
print('|'.join(['Alex', '123', 'read'])) # Alex|123|read 用某一个特定的符号将多个字符串隔开 注意：字符串和数字之间是不可以拼接的，如： print('|'.join(['Alex', 123])) # 报错 参与拼接的数字值必须都为字符串
11. 统计指定字符出现的次数
字符串.count
res = 'hello world' print(res.count('l')) # 3
12. 判断字符串的开头或结尾
字符串.startswith #判断字符串的开始
字符串.endswith #判断字符串的结尾
res = 'hello world' print(res.startswith('h')) # True print(res.startswith('a')) # False
res = 'hello world' print(res.endswith('h')) # False print(res.endswith('d')) # True
13. 大小写转换
字符串.title() # 将每个单词的首字母大写
字符串.capitalize() # 将除了首字母以外的所有字母小写
字符串.swapcase() # 将大小写互换
res = 'hEllO WorLD' print(res.title()) # Hello World print(res.capitalize()) # Hello world print(res.swapcase()) # HeLLo wORld
14. 查找对应的索引
print(res.index())
print(res.find())
区别：如果字符串里没有该字母，inedx直接报错，find返回 -1
四、列表内置方法
1. 类型转换
- 关键字
list(其他数据类型) - 能够被for循环的数据类型都可以转成列表
print(list('hello')) # ['h', 'e', 'l', 'l', 'o'] 获取字符串里的每一个字符作为元素，生成一个列表 print(list({'name': 'jason', 'pwd': 123})) # ['name', 'pwd'] 只能获取key键作为元素，生成一个列表 print(list((11, 22, 33, 44))) # [11, 22, 33, 44] 获取元组里的每一个元素，作为元素生成列表 print(list({1, 2, 3, 4, 5})) # [1, 2, 3, 4, 5] 获取集合里的每一个元素，生成列表
2. 方法
（1）索引取值（正负数）
（2）切片操作
（3）统计列表中数据值的个数
# 上述与字符串操作一致
（4）数据值修改
l1 = [111, 222, 333, 444, 555, 666, 777, 888] l1[0] = 123 print(l1) # [123, 222, 333, 444, 555, 666, 777, 888]
（5）列表添加数据
方式1：尾部追加数据值
l1.append(要添加的数据值)
l1 = [111, 222, 333] l1.append(888) print(l1) # [111, 222, 333, 888] 以数字形式插入 l1.append(’888‘) print(l1) # [111, 222, 333, '888'] 以字符串形式插入 l1.append(['Alex', 'Judy', 'Andy']) print(l1) # [111, 222, 333, '888', ['Alex', 'Judy', 'Andy']] 以列表形式插入
方式 2：任意位置插入数据值
insert(索引值，数据值)
l1 = [111, 222, 333] l1.insert(0, 'Alex') #在索引0的位置插入’Alex‘ print(l1) # ['Alex', 111, 222, 333]
方式3：扩展列表，合并列表
ll1 = [11, 22, 33] ll2 = [55, 66, 77] 方法1： print(ll1 + ll2) # [11, 22, 33, 55, 66, 77] 方法2： ll1.extend(ll2) # 等价于for循环 + append print(ll1) # [11, 22, 33, 55, 66, 77] 方法3： for i in ll2: ll1.append(i) print(ll1) # [11, 22, 33, 55, 66, 77]
(6) 删除列表数据
方式1：del list[索引值]
l1 = [11, 22, 33] del l1[0] #删除索引0位置处的数据 print(l1) # [22, 33]
方式2：list.remove(数据值)
l1 = [11, 22, 33] l1.remove(11) print(l1) # [22, 33]
方式3：list.pop(索引值)
l1 = [11, 22, 33] l1.pop(0) # 括号里填写索引值 print(l1) # [22, 33]
* list.pop() # 括号里面没有数字，默认从尾部弹出数据值
l1 = [11, 22, 33] l1.pop() # 默认从尾部弹出数据值 print(l1) # [11, 22]
remove与pop的区别：
remove括号里填具体的数据值，pop括号里填数据对应的索引值；remove直接删除对应的数据，pop是弹出数据，对数据并未进行删除。
l1 = [11, 22, 33] a = l1.pop(0) print(a) # 11 弹出的数据依然存在，为11 b = l1.remove(11) # None 删除的数据没有了
（7）排序
list. sort() # 默认是升序
ss = [45, 53, 24, 90, 86, 63] ss.sort() print(ss) # [24, 45, 53, 63, 86, 90]
list.sort(reverse = True) # 改为降序
ss = [45, 53, 24, 90, 86, 63] ss.sort(reverse=True) # 变为降序 print(ss) # [90, 86, 63, 53, 45, 24]
（8）统计列表中某个数据值出现的次数
print(l1.count(数据值))
ss = [45, 53, 24, 90, 86, 63, 90] print(ss.count(90)) # 2
（9）颠倒列表顺序
list.reverse()
ss = [45, 53, 24, 90, 86, 63, 90] print(ss) # [90, 63, 86, 90, 24, 53, 45]
补充：可变类型与不可变类型
可变类型：
值改变，内存地址不变
l1 = [11, 22, 33] print(l1, id(l1)) # [11, 22, 33] 2563066745856 l1.append(44) print(l1, id(l1)) # [11, 22, 33, 44] 2563066745856
列表在调用内置方法后，自己发生了变化，但是内存地址没有变。
不可变类型：
值改变，内存地址肯定变
s1 = '&&&Alex&&' print(s1, id(s1)) # &&&Alex&& 2111207046640 s1.strip('&') print(s1, id(s1)) # &&&Alex&& 2111207046640
字符串在调用内置方法后，自身并没有发生变化，内存地址也没有变，如果想要打印出来的数据值跟之前不一样，只能重新赋值。
***如何查看调用方法之后有没有新的结果，可以在调用该方法的代码左侧添加变量名和赋值符号
ret = l1.append(11)
res = s1.strip('$')
l1 = [11, 22, 33] l1.append(11) ret = l1.append(11) print =(ret) # None 列表在调用内置方法之后修改的就是自身,并没有产生新的结果 s1 = '&&&Alex&&' s1.strip('&') print(s1) # &&&Alex&& # 字符串在调用内置方法之后并不会修改自己，而是产生了一个新的结果 res = s1.strip('&') print(res) # Alex
