Python中级之数据类型的内置方法1(数字类型和字符串)

【一】数字类型

【1】整数类型(int)

（1）定义

直接用整数定义，整数类型的值不能修改

num = 6

（2）内置方法

int.bit_length()

#返回整数的二进制表示中最高位的位数，不包括符号和前导零。
a = 10
b = a.bit_length()
print(b)
# 输出 4

int.to_bytes(length, byteorder, signed)

# 将整数转换为字节数组。
# 参数length指定生成的字节数组的长度，byteorder指定字节顺序，signed指定是否考虑整数的符号。
a = 10
b = a.to_bytes(2,byteorder='big',signed=False)
print(b)
#输出 b'\x00\n'

int.from_bytes(bytes, byteorder, signed)

# 将字节数组转换为整数。
# 参数bytes是输入的字节数组，byteorder指定字节顺序，signed指定是否考虑整数的符号
a = b'\x00\n'
b = int.from_bytes(a,byteorder='big',signed=False)
print(b)
# 输出 10

int.add(other)

#整数的加法运算
a = 10
b = 5
c = a.__add__(b)
print(c)
#输出 15

int.sub(other)

#整数的减法运算
a = 10
b = 5
c = a.__sub__(b)
print(c)
#输出 5

int.mul(other)

#整数的乘法运算
a = 10
b = 5
c = a.__mul__(b)
print(c)
#输出 50

int.truediv(other)

#整数的真除法运算
a = 10
b = 5
c = a.__truediv__(b)
print(c)
#输出 2.0

int.floordiv(other)

#整数的整除法运算
a = 10
b = 5
c = a.__floordiv__(b)
print(c)
#输出 2

int.mod(other)

#整数的取模运算
a = 10
b = 5
c = a.__mod__(b)
print(c)
#输出 0

int.pow(other, modulo=None)

#整数的幂运算
a = 10
b = 5
c = a.__pow__(b)
print(c)
#输出 100000

（3）类型强转

可以将纯整数的字符串直接转换成整型（如果包含任意非整数符号，会报错）

#正确示例
a = "1234"
b = int(a)
print(b,type(b))
#输出 1234 <class 'int'>

#错误示例（含有非整数符号）
a = "3.14"
b = int(a)
print(b,type(b))
'''
Traceback (most recent call last):
  File "D:\Python\pythonProject\pythonProject1\demo5.py", line 119, in <module>
    b = int(a)
ValueError: invalid literal for int() with base 10: '3.14'
'''

（4）进制转换

整数类型提供了一些方法来进行进制转换，主要涉及到二进制、八进制、十六进制

十进制转二进制：bin()

a = 10
b = bin(a)
print(b)
#输出 0b1010

十进制转八进制：oct()

a = 10
b = oct(a)
print(b)
#输出 0o12

十进制转十六进制：hex()

a = 10
b = hex(a)
print(b)
#输出 0xa

其他进制转十进制：int()
int()函数可以将不同进制的字符串转换为十进制整数
- 二进制（以 '0b' 或 '0B' 开头）
- 八进制（以 '0o' 或 '0O' 开头）
- 十六进制（以 '0x' 或 '0X' 开头）

a = '0b1010'
b = int(a, 2)
print(b)
# 输出：10

a = '0o12'
b = int(a, 8)
print(b)
# 输出：10

a = '0xa'
b = int(a, 16)
print(b)
# 输出：10

【2】浮点数类型(float)

（1）定义

表示有小数点的数字的数字类型

float = 1.00

（2）内置方法

浮点数类型的内置方法包含数学运算的加减乘除

# 加法
float = 2.5 + 2.4
print(float)
#输出 4.9

# 减法
float = 7.8 - 2.3
print(float)
#输出 5.5

# 乘法
float = 2.5 * 6.0
print(float)
#输出 15.0

# 除法
float = 7.5 / 1.5
print(float)
#输出 5.0

# 取整
float_num = round(1.545741877)
print(float_num)
#输出 2
#由于计算机存储浮点数的方式，可能存在一些精度问题

（4）类型强转

类型强转就是将一个数据类型转换为另一个数据类型

#通过内置函数来类型强转
## 将整数转换为浮点数
int_num = 10
float_num = float(int_num)
print(float_num)
#输出 10.0

# 将浮点数转换为整数
float_num = 5.21
int_num = int(float_num)
print(int_num)
#输出 5
#类型强转在处理不同类型的数据时非常常见，确保数据在执行某些操作时具有相同的类型，以避免出现错误。

【3】判断数字类型

（1）数字类型说明

num1 = b'4'  # bytes
num2 = '4'   # unicode，Python 3 中不需要在字符串前加 'u'
num3 = '四'  # 中文数字
num4 = 'Ⅳ'   # 罗马数字

（2）判断数字类型(isdigit)

# isdigit: bytes, unicode
print(num1.isdigit())  # True
print(num2.isdigit())  # True
print(num3.isdigit())  # False
print(num4.isdigit())  # False

（3）判断小数类型(isdecimal)

# isdecimal: unicode（bytes 类型没有 isdecimal 方法）
print(num2.isdecimal())  # True
print(num3.isdecimal())  # False
print(num4.isdecimal())  # False

（4）判断数字类型(isnumeric)

# isnumeric: unicode, 中文数字, 罗马数字（bytes 类型没有 isnumeric 方法）
print(num2.isnumeric())  # True
print(num3.isnumeric())  # True
print(num4.isnumeric())  # True

（5）无法判断浮点数

# 这三种方法无法判断浮点数
num5 = '4.3'
print(num5.isdigit())    # False
print(num5.isdecimal())  # False
print(num5.isnumeric())  # False

【二】字符串类型(str)

【1】定义

字符串是字符组成的，可以是数字、字母等，通常使用单引号、双引号和三引号来定义

#单引号定义
name = 'ligo'
#双引号定义
name = "ligo"
#三引号定义
name = '''ligo'''

还可以用三引号来定义多行字符串

sentence = '''
My name is ligo,
I am 18 years old.
'''

【2】内置方法(优先)

（1）字符串拼接

字符串拼接是将多个字符串连接在一起形成一个新的字符串。
可以使用 + 运算符来实现字符串拼接。

str1 = 'Hello,'
str2 = 'World!'
str3 = str1 + ' ' + str2
print(str3)
# 输出 Hello, World!

（1）索引取值

[1]正索引取值

#字符串中的每个字符都有一个索引，正索引从0开始，从左到右依次增加
name = "ligo"
char = name[1]
print(char)
#输出 i

[2]反索引取值

#反索引从右到左依次增加，最右边的字符索引为 -1
name = "ligo"
char = name[-1]
print(char)
#输出 o

[3]只能取值，不能修改

name = "ligo"
name[2] = 'd'
'''
Traceback (most recent call last):
  File "D:\Python\pythonProject\pythonProject1\demo5.py", line 180, in <module>
    name[2] = 'd'
TypeError: 'str' object does not support item assignment
'''

（2）切片(顾头不顾尾)

[1]切片顾头不顾尾

切片用于获取字符串的一部分，可以指定起始索引和结束索引

# 从索引1到索引3（不包括3）
name = "ligo"
char = name[1:3]
print(char)
#输出 ig

[2]步长

# 从索引0到索引4（不包括4）步长为2，所以索引0为l，索引2为g
name = "ligo"
char = name[0:4:2]
print(char)
#输出 lg

[3]反向切片

name = "ligo"
char = name[-4:-1] #反向切片索引要从小到大
print(char)
#输出 lig

（3）计算长度(len)

name = 'ligo'
length = len(name)
print(length)
# 输出: 4

（4）成员运算

in 和 not in 用于检查一个字符串是否包含另一个字符串

[1]in

name_list = ['ligo','scott']
name = 'ligo' in name_list
print(name)
#输出 True

[2]not in

name_list = ['ligo','scott']
name = 'Travis' in name_list
print(name)
# 输出 False

（5）去除空格(strip)

strip() 方法用于去除字符串首尾的空格，也可以去除特殊字符（例如换行）

[1] 默认 strip

默认情况下，strip() 方法会去除字符串开头和结尾的所有空格。

text = '  Hello, World!  '
stripped_text = text.strip()
print(stripped_text)
# 输出: Hello, World!

[2] 左去除 lstrip

lstrip() 方法用于去除字符串开头的空格。

text = '  Hello, World!  '
left_stripped_text = text.lstrip()
print(left_stripped_text)
# 输出: Hello, World!

[3] 右去除 rstrip

rstrip()方法用于去除字符串结尾的空格。

text = '  Hello, World!  '
right_stripped_text = text.rstrip()
print(right_stripped_text)
# 输出: Hello, World!

[4] 去除指定字符

如果需要去除字符串开头和结尾的指定字符，可以传入一个字符串参数给 strip()方法。

text = '(Hello, World!)'
stripped_text = text.strip('()')
print(stripped_text)
# 输出: Hello, World!

（6）切分(split)

split() 方法用于将字符串切分成多个子字符串，并返回一个包含切分后子字符串的列表。

[1] 默认切分符

如果不指定切分符，则默认使用空格作为切分符。

text = 'Hello, World!'
split_result = text.split()
print(split_result)
# 输出: ['Hello,', 'World!']

[2] 指定分隔符

可以通过传递一个分隔符参数给 split()`方法来指定切分符。

text = 'apple,orange,banana'
split_result = text.split(',')
print(split_result)
# 输出: ['apple', 'orange', 'banana']

（7）遍历字符串

使用 for 循环可以遍历字符串中的每个字符

name = 'ligo'
for char in name:
    print(char)
# 输出：
# l
# i
# g
# o

（8）字符串重复

使用 * 运算符可以实现字符串的重复

str = 'good'
repeated_str = str * 3
print(repeated_str)
# 输出: goodgoodgood

（9）大小写转换

[1]小写转大写(upper())

#将给定字符串中的所有字母变为大写
name = 'ligo'
upper_name = name.upper()
print(upper_name)
# 输出: LIGO

[2]大写转小写(lower())

#将给定字符串中的所有字母变为小写
name = 'Ligo'
lower_name = name.lower()
print(lower_name)
# 输出: ligo

（10）首尾字符判断

[1]判断字符开头(startswith())

startswith()判断字符串是否以括号内指定的字符开头，结果为布尔值True或False

text = 'Python is fun'
result = text.startswith('Python')
print(result)
# 输出: True

[2]判断字符结尾(endswith())

endswith()判断字符串是否以括号内指定的字符结尾，结果为布尔值True或False

text = 'Python is fun'
result = text.endswith('fun')
print(result)
# 输出: True

（11）格式化输出

[1] % 输出

# 格式化输出语法一 ： %
name = "ligo"
age = 18
height = 180

# 使用 %s 占位符，输出字符串
print("My name is %s." % name)  
# My name is ligo.

# 使用 %d 占位符，输出整数
print("My age is %d." % age)  
# My age is 18.

# 使用 %f 占位符，输出浮点数，默认保留六位小数
print("My height is %f." % height)  
# My height is 180.000000.

# 使用 %.2f 占位符，保留两位小数
print("My height is %.2f." % height)  
# My height is 180.00.

# 使用 %x 占位符，输出十六进制整数
number = 255
print("Number in hex: %x." % number)  
# Number in hex: ff.

# 两个以上的占位符格式化输出
print("My name is %s; My age is %d" % (name, age)) 
# My name is ligo; My age is 18

在上例中，%s 和 %d 是占位符，分别表示字符串和整数，而 (name, age) 是传入这两个占位符的实际值。
占位符类型
- %s：字符串
- %d：整数
- %f：浮点数
- %x：十六进制整数

[2] formate 输出

使用 format 方法进行格式化输出，通过花括号 {} 表示占位符，然后调用 format 方法传入实际值

name = "ligo"
age = 18
# 格式化输出语法三 ： format
print("My name is {}; My age is {}".format(name, age)) #按顺序传入format方法的值
# My name is ligo; My age is 18

[3] f + {} 输出

使用（f + {}）进行格式化输出，通过在字符串前加上 f 或 F 前缀，然后在字符串中使用 {} 表示占位符，并在 {} 中直接引用变量。

name = "ligo"
age = 18
# 格式化输出语法二 ： f + {}
print(f"My name is {name}; My age is {age}")
# My name is ligo; My age is 18

从可迭代对象中取出多个字符串，然后按照指定的分隔符进行拼接，拼接的结果为字符串

res_1 = '%'.join('hello')  # 从字符串'hello'中取出多个字符串，然后按照%作为分隔符号进行拼接
print(res_1)  # h%e%l%l%o

res_2 = '|'.join(['ligo', '18', 'read'])  # 从列表中取出多个字符串，然后按照*作为分隔符号进行拼接
print(res_2)  # ligo|18|read

（13）替换replace

#用新的字符替换字符串中旧的字符
res = 'my name is ligo, my age is 18!'  # 将ligo改为scott
res = res.replace('ligo', 'scott')  # 语法:replace('旧内容', '新内容')
print(res)  # my name is scott, my age is 18!

# 可以指定修改的个数
res = 'my name is ligo, my age is 18!'
res = res.replace('my', 'MY', 2)  # 把两个my都改为MY
print(res)  # MY name is ligo, My age is 18!

（14）判断类型isdigit

#判断字符串是否是纯数字组成，返回结果为True或False
str = '123456'
res = str.isdigit()
print(res)  # True

str = '123456a'
res = str.isdigit()
print(res)  # False

posted @ 2024-05-08 15:29 Ligo6 阅读(59) 评论(0) 收藏举报

刷新页面返回顶部

ligo6

Python中级之数据类型的内置方法1(数字类型和字符串)

【一】数字类型

【1】整数类型(int)

（1）定义

（2）内置方法

（3）类型强转

（4）进制转换

【2】浮点数类型(float)

（1）定义

（2）内置方法

（4）类型强转

【3】判断数字类型

（1）数字类型说明

（2）判断数字类型(isdigit)

（3）判断小数类型(isdecimal)

（4）判断数字类型(isnumeric)

（5）无法判断浮点数

【二】字符串类型(str)

【1】定义

【2】内置方法(优先)

（1）字符串拼接

（1）索引取值

[1]正索引取值

[2]反索引取值

[3]只能取值，不能修改

（2）切片(顾头不顾尾)

[1]切片顾头不顾尾

[2]步长

[3]反向切片

（3）计算长度(len)

（4）成员运算

[1]in

[2]not in

（5）去除空格(strip)

[1] 默认 strip

[2] 左去除 lstrip

[3] 右去除 rstrip

[4] 去除指定字符

（6）切分(split)

[1] 默认切分符

[2] 指定分隔符

（7）遍历字符串

（8）字符串重复

（9）大小写转换

[1]小写转大写(upper())

[2]大写转小写(lower())

（10）首尾字符判断

[1]判断字符开头(startswith())

[2]判断字符结尾(endswith())

（11）格式化输出

[1] % 输出

[2] formate 输出

[3] f + {} 输出

（13）替换replace

（14）判断类型isdigit

公告