【一】数字类型
【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