数据类型内置方法上：整型、浮点型、字符串、列表

python之数据类型内置方法

目录

• §零、数据类型内置方法理论
  • 0、什么是数据类型的内置方法
  • 1、如何调用内置方法
• §一、整型int内置方法与操作
  • 1、类型转换
  • 2、进制数转换
  • 3、关于python的内置方法的缺点
• §二、浮点型float内置方法与操作
  • 1、类型转换
• §三、字符串str内置方法与操作
  • 1、类型转换
  • 2、必须要掌握的方法
    • 1.索引取值str[值1]
    • 2.切片操作str[值1:值2]
    • 3.修改切片方向（间隔/步长）str[值1:值2:值3]
    • 4.统计字符串中字符的个数len
    • 5.移除字符串首位指定字符.strip()
    • 6.切割字符串中指定的字符 .split()
    • 7.字符串格式化输出.format()
  • 3、需要掌握的方法
    • 1.转换大小写upper与lower
    • 2.判断字符串中是否是纯数字.isdigit()
    • 3.替换字符串中指定的内容.replace()
    • 4.字符串的拼接+ 或者 * 或者.join()
    • 5.统计指定字符出现的次数.count()
    • 6.判断字符串的开头或者结尾.startswith()和.endswith()
    • 7.其他方法补充.startswith()和.endswith()
• §四、列表list内置方法及操作
  • 1、将其他数据类型转换为列表
  • 2、必须要掌握的方法
    • 1.索引取值(正负数) 同字符串
    • 2.切片操作 同字符串
    • 3.间隔数 同字符串
    • 4.统计列表中数据值的个数长度len()
    • 5.数据值修改
    • 6.列表添加数据值.append()/.insert()/.extend()
    • 7.删除列表数据
    • 8.排序.sort()
    • 9.统计列表中某个数据值出现的次数.count()
    • 10.颠倒列表顺序.reverse()
• §五、可变类型与不可变类型
  • 1.可变类型
  • 2.不可变类型

§零、数据类型内置方法理论

0、什么是数据类型的内置方法

​ 首先，我们回顾一下什么是数据类型：

​ 数据类型定义了可以对数据执行的操作、数据的含义以及存储该类型值的方式。只有给数据赋予明确的数据类型，计算机才能对数据进行处理运算。针对不同的数据采用最佳的数据类型来表示出该数据的价值。

​ 而在程序员开发时，需要对数据进行一些列的操作，因此在python中，就针对每种不同的数据类型的内置一系列方法，就是我们所学习的数据类型内置方法

1、如何调用内置方法

​ 在python中数据类型调用内置方法的统一句式为：句点符

#例子，将几个字符串拼接起来
str1 = "Java" "Python" "C++" "Go"
print(str1)
----------------------
JavaPythonC++Go

§一、整型int内置方法与操作

1、类型转换

将其他数据类型转换成 整型int

#语句
int(+其他数据类型)
#举例
s = '123'
res = int(s)
print(s, type(res))
运行结果------------------
123 <class 'str'>

int可以将由纯整数构成的字符串直接转换成整型，若包含其他任意非整数符号，则会报错
float浮点型可以直接转换为 int整型
str字符串则必须满足内部是纯数字才可以

2、进制数转换

​ 可以通过一些关键字来将十进制的数字转换为二进制、八进制、十六进制

• 十进制数 转换为其他进制

#十进制数 100转换为其他进制
1.二进制 bin （binary number）
print(bin(100))  # 0b1100100
2.八进制 oct  （octonary number）
print(oct(100))  # 0o144
3.十六进制 hex  （hexadecimal number）
print(hex(100))  # 0x64

非十进制数，可以通过其开头来判别是什么进制数
0b开头为二进制
0o开头为八进制
0x开头为十六进制

• 其他进制数转为十进制数

#其他进制数转为十进制数 decimal number
print(int(0b1100100))
print(int(0o144))
print(int(0x64))
     	
print(int("0b1100100", 2))
print(int("0o144", 8))
print(int("0x64", 16))

3、关于python的内置方法的缺点

​ python自身对数字对敏感度较低（精确度低），由于计算机使用二进制的原因，无法用有限位数的二进制表达0.1

#举例
print(1.1*2.2)
-----------------
2.4200000000000004

§二、浮点型float内置方法与操作

1、类型转换

#语句
float(+其类型的数据)
字符串里面可以允许出现一个小数点 其他都必须是纯数字
#举例
s = '12.3'
res = float(s)
print(res,type(res))
------------------
12.3, <class 'float'>

§三、字符串str内置方法与操作

1、类型转换

#语句
str(+其类型的数据)
可以转换任何类型的数据（只要在前后加引号即可）
 
#举例
s = [12.3[]
res = str(s)
print(res, type(res))
------------------
12.2 <class 'str'>

2、必须要掌握的方法

s1 = 	'hello world'

1.索引取值str[值1]

​ 起始位置0开始，超出范围则直接报错

str[值1] 值1位索引值
 
s1 = 	'hello world'
print(s1[0])  # h
print(s1[-1])  # d  支持负数 从末尾开始索引取值
------------------
h
d

2.切片操作str[值1:值2]

str[值1:值2] 从 索引1 一直到索引 值2到前一位
 
s1 = 	'hello world'
print(s1[1:5])  # 顾头不顾尾，从索引1一直切取到索引4
print(s1[-5:-1])  # 默认顺序是从左到右
print(s1[-1:-5])  # 如果数字是左大右小，则不会输出结果
------------------
ello
worl
 

3.修改切片方向（间隔/步长）str[值1:值2:值3]

str[值1:值2:值3] 从索引1一直到索引2，每次到步长为值3
 
s1 = 	'hello world'
print(s1[-1:-5:-1])
print(s1[:])  # 不写数字就默认都要
print(s1[2:])  # 从索引2开始往后都要
print(s1[:5])  # 从索引0开始往后要到4
print(s1[::2])
------------------
dlro
hello world
llo world
hello
hlowrd

4.统计字符串中字符的个数len

空格也算一个字符

#获取字符串的长度，即字符的个数，但凡存在于引号内的都算作字符
长度 len(+字符串的变量名)
 
s1 = 	'hello world'
------------------
11

用for循环如何实现

s1 = 'hello world'
count = 0
for i in s1:
    if True:
        count += 1
print(count)
------------------
11

5.移除字符串首位指定字符.strip()

• （1）括号内不指定字符串时，默认移除首尾的空格

# 举例 移除登陆用户名中的空格
username = input('请输入用户名：').strip()  # 末尾加上.strip()即可在获取输入的时候，自动移除首尾空格
if username == 'jason':
    print('登陆成功')

• （2）移除括号内指定字符，默认移除首尾的指定字符不能移除字符串中间的同样字符

name = '**str*ing**'
print(name.strip('*'))
------------------
str*ing

• （3）移除指定字符，可指定首部或尾部

1.首部  变量名.lstrip()
name = '**str*ing**'
print(name.lstrip('*'))
------------------
str*ing**
 
2.尾部  变量名.rstrip()
name = '**str*ing**'
print(name.rstrip('*'))
------------------
**str*ing

6.切割字符串中指定的字符 .split()

• （1）该方法处理的结果是一个列表

#语句
变量名.split('指定切割去掉的字符')
1.
bro_name = 'yasou,zed,grave'
print(bro_name.split(','))
------------------
['yasou', 'zed', 'grave']
 
2.运用赋值语法,将变量名直接赋值
bro_name = 'doinb,uzi,jackeylove,369,knight'
lng, rng, tes, jdg, tes= bro_name.split(',')
print(bro_name.split(','))
print(tes)  # 当两个变量名相同时，只会将靠后的数据值赋值给变量名
------------------
['doinb', 'uzi', 'jackeylove', '369', 'knight']
knight

• （2）可以从左往右，或者从右往左选择切割个数

从右往左加r为.rsplit()

从左往右，.split()本身就是从左往右切割

1.从左往右切割 .split('指定切割去掉的字符',maxsplit=个数)
 
bro_name = 'doinb,uzi,369,jackeylove,knight,pandac'
print(bro_name.split(',', maxsplit=2))
------------------
['doinb', 'uzi', '369,jackeylove,knight,pandac']
 
2.从右往左切割 .rsplit('指定切割去掉的字符',maxsplit=个数)
 
bro_name = 'doinb,uzi,369,jackeylove,knight,pandac'
print(bro_name.rsplit(',', maxsplit=2))
------------------
['doinb,uzi,369,jackeylove', 'knight', 'pandac']

7.字符串格式化输出.format()

• （1）format等价于占位符

# 与 {} 一起使用，有几个{}，format里面就要有几个字符串
res = 'rng has {} tes has {} edg has {}'.format('breath','jackeylove','meiko')
print(res)
------------------
rng has breath tes has jackeylove edg has meiko

• （2）format索引取索引值

# {}中+索引值
res = 'rng has {0} tes has {1} edg has {2}'.format('breath','jackeylove','meiko')
print(res)
------------------
rng has breath tes has jackeylove edg has meiko

• （3）format直接索引变量名

# {}中+变量名
res = 'rng has {rng} tes has {tes} edg has {edg}'.format(rng='breath',tes='jackeylove',edg='meiko')
print(res)
------------------
rng has breath tes has jackeylove edg has meiko

• （4）format索引变量名 f+'字符串'用法

# 当变量名为动态时候，format占位 的 变量名 也会随之改变，比占位符号好用
tes = 'jackeylove'
rng = 'ming'
edg = 'meiko'
res = f'rng has {rng} tes has {tes} edg has {edg}'
print(res)
------------------
rng has breath tes has jackeylove edg has meiko

3、需要掌握的方法

1.转换大小写upper与lower

tes = 'jACkEylOVe'
print(tes.upper())
print(tes.lower())
------------------
JACKEYLOVE
jackeylove

图片验证码判断机制

'''图片验证码:生成没有大小写统一的验证码 展示给用户看
   获取用户输入的验证码 将用户输入的验证码和当初产生的验证码统一转大写或者小写再判断是否一致
'''
# 1展示验证码
code = 'jACkEylOVe'
print('给用户展示验证码', code)
# 2获取用户输入
user_code = input('请输入验证码：').strip()  # 5去掉用户输入的前后空格
# 4加入验证码和用户输入统一大小写机制
code = code.upper()
user_code = user_code.upper()
# 3判读用户输入是否正确
if user_code ==code:
    print('验证成功')
else:
    print('失败')
------------------ 
给用户展示验证码 jACkEylOVe
请输入验证码：   jackeylove  
验证成功

2.判断字符串中是否是纯数字.isdigit()

# isdigit 的判断结果是布尔值
tes = 'jackeylove'
print(tes.isdigit())
------------------ 
False

3.替换字符串中指定的内容.replace()

# 语句
.replace(被代替的字符, 代替的字符, 替换个数)
 
sen = 'uzi is no.1 adc, uzi is no.1 adc, uzi is no.1 adc, uzi is no.1 adc'
print(sen.replace('uzi', 'jackeylove', 2))
------------------ 
jackeylove is no.1 adc, jackeylove is no.1 adc, uzi is no.1 adc, uzi is no.1 adc

4.字符串的拼接+ 或者 * 或者.join()

1.str1 + str2 + str3
# 多个字符串凭借可以直接相加
s1 = 'jackeylove'
s2 = 'no.1 adc'
print(s1 + 'is' + s2)
------------------ 
jackeyloveisno.1 adc
 
2.str * 数字n 直接输出n遍 str
 
s1 = 'jackeylove'
print(s1 * 10)
------------------ 
jackeylovejackeylovejackeylovejackeylovejackeylovejackeylovejackeylovejackeylovejackeylovejackeylove
 
3.  .join()语句
#字符串1+.join([str1,str2,...,strn])，将列表[]中的字符串，用字符串拼接起来
 
print('|'.join(['jason', 'loves', 'read', 'DBJ']))
------------------ 
jason|loves|read|DBJ

5.统计指定字符出现的次数.count()

#语句
字符串.count('字符')，统计该字符在字符串中出现的次数
 
tes = 'jackeylove'
print(tes.count('e'))
------------------ 
2

6.判断字符串的开头或者结尾.startswith()和.endswith()

# 语句
字符串.startswith/.endswith ('需要判断的某一个或多个字符')
其得到的结果是布尔值 True/False
 
res = 'jason say hello'
print(res.startswith('jason'))
print(res.startswith('j'))
print(res.startswith('say'))
print(res.endswith('o'))
------------------
True
True
False
True

7.其他方法补充.startswith()和.endswith()

1. .title()  # 将字符串中的每个单词的首字母大写
2. .capitalize()  # 将第一个单词的首字母大写
3. .swapcase()  # 将字母的大小写反转
4. .index()  # 查找字符，找不到直接报错
index在使用的时候其大小写也要和字符串中一致，如果不一致也视为找不到
5. .find()  # 查找字符，找不到会返回-1

找不到字符的情况下，find与index的运行结果不同

§四、列表list内置方法及操作

1、将其他数据类型转换为列表

​ 能够被for循环的数据类型都可以转换成列表：字符串、字典、元组、集合

# 语句
list(+要转换的数据类型)
 
  print(list('hello'))
	print(list({'name': 'jason', 'pwd': 123}))
	print(list((1, 2, 3, 4)))
	print(list({1, 2, 3, 4, 5}))

2、必须要掌握的方法

1.索引取值(正负数) 同字符串

# 语句
	列表的变量名+[索引值]
 
l1 = ['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']
print(l1[0])
print(l1[-1])
------------------
dOinB
KniGHT

2.切片操作 同字符串

# 语句
	列表的变量名+[索引值1:索引值2]  # 左包含右不包含
 
l1 = ['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']
print(l1[0:4])
print(l1[:])  # 只大 一个：表示从第一位到最后一位
------------------
['dOinB', 'uZi', 'jAckEyloVe', 369]
['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']

3.间隔数 同字符串

# 语句
  列表的变量名+[索引值1:索引值2：步长]
 
l1 = ['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']
print(l1[::2])
print(l1[::-2])  # 步长为负值，表示方向从右往左
print(l1[-4:-1])
print(l1[-1:-2])  # 如果数据值左大右小，输出结果是空列表
------------------
['dOinB', 'jAckEyloVe', 'KniGHT']
['KniGHT', 'jAckEyloVe', 'dOinB']
['uZi', 'jAckEyloVe', 369]
[]

4.统计列表中数据值的个数长度len()

l1 = ['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']
print(len(l1))
------------------
5

5.数据值修改

# 语句
列表变量名[索引值] = 要修改的值
 
l1 = ['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']
l1[0] = 123
print(l1)
------------------
[123, 'uZi', 'jAckEyloVe', 369, 'KniGHT']

6.列表添加数据值.append()/.insert()/.extend()

• （1）尾部追加数据值 .append()

列表名.append(要加入的数据值)
 
l1 = ['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']
l1.append(123)
print(l1)
------------------
['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT', 369, 123]

为什么第一种方法打印的是none

• （2）任意位置插入数据值 .insert()

# 语句
列表名.insert(索引值,要插入该索引值的数据值)
 
l1 = ['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']
l1.insert(0, 11111)
print(l1)
------------------
[11111, 'dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']

• （3）扩展列表 合并列表 .extend()

1. 列表1 + 列表2
ll1 = [11, 22, 33]
ll2 = [44, 55, 66]
print(ll1 + ll2)  
------------------ 
[11, 22, 33, 44, 55, 66]
 
2. .extend()
# 语句
列表1+.extend(列表2)
print(ll1 + ll2)  # [11, 22, 33, 44, 55, 66]
ll1.extend(ll2)  # extend相当于 for循环+append
print(ll1)  
------------------
[11, 22, 33, 44, 55, 66]
 
#用for循环来写
ll1 = [11, 22, 33]
ll2 = [44, 55, 66]
for i in ll2:
    ll1.append(i)
print(ll1)
------------------
[11, 22, 33, 44, 55, 66]

7.删除列表数据

• （1）通用的删除关键字 del

# 语句
  del +列表[索引值]
 
l1 = ['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']
del l1[0]
print(l1)
------------------
['uZi', 'jAckEyloVe', 369, 'KniGHT']

• （2）删除括号内的数据值 .remove()

列表名.remove(要删除的数据值)
 
l1 = ['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']
l1.remove('uZi')  # 如果删除的是字符串，大小写要一致
print(l1)
------------------
['dOinB', 'jAckEyloVe', 369, 'KniGHT']

• （3）括号内填写索引值 .pop()

列表名.pop(要删除的数据值)
 
l1 = ['dOinB', 'uZi', 'jAckEyloVe', 369, 'KniGHT']
l1.pop(1)
print(l1)
------------------
['dOinB', 'jAckEyloVe', 369, 'KniGHT']

Pop 与 remove的区别

pop是弹出删除数据值，会暂时保存这个数据值

remove是直接删除这个数据值

8.排序.sort()

# 列表名+.sort()
 
l1 = [22, 33, 11, 369, 1]
l1.sort()  # 默认是升序
print(l1)
------------------
[1, 11, 22, 33, 369]
 
l1 = [22, 33, 11, 369, 1]
l1.sort(reverse=True) # 改为降序
print(l1)
------------------
[369, 33, 22, 11, 1]

9.统计列表中某个数据值出现的次数.count()

# 列表名+.count(要统计的数据值)
 
l1 = [22, 33, 11, 369, 1, 1, 1, 1]
print(l1.count(1))
------------------
4

10.颠倒列表顺序.reverse()

# 列表名+.reverse
 
l1 = [22, 33, 11, 369, 1, 1, 1, 1]
l1.reverse
print(l1)
------------------
[22, 33, 11, 369, 1, 1, 1, 1]

§五、可变类型与不可变类型

​ 字符串在调用内置方法之后并不会修改自己 而是产生了一个新的结果

​ 列表在调用内置方法之后修改的就是自身 并没有产生一个新的结果

​ 因此， 可以在调用该方法的代码左侧添加变量名和赋值符号，查看调用方法之后有没有新的结果

1.可变类型

	 值改变，内存地址不改变

2.不可变类型

	 值改变，内存地址肯定改变