Python-基础1（数据类型）

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 前言
• 1、数据类型
• • 1.1、int整型
  • [1.2、float 浮点型](#1.2、float 浮点型)
  • [bool 布尔型](#bool 布尔型)
  • String字符串初识
  • 数据类型转换
  • 字符的编码和解码
• [2、 输入输出](#2、 输入输出)
• • 输出
• 3、运算符
• • 算数运算符
  • 赋值运算符
  • 比较运算符
  • 逻辑运算符
  • 位运算符
  • 身份运算符

---

前言

1、数据类型

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。Python 3中常见的数据类型分类如下，

基本数据类型

数值：整数（int）、浮点数（float）、复数（complex）、布尔（bool）

字符串（str）

容器数据类型：列表（list），元组（tuple），集合（set），字典（dist）

特殊数据类型：None，表示空值或缺失值，只有一个值 None。常用于函数没有返回值时，或者表示变量没有被赋值。

其中不可变数据（3个）：Number(数字)，String(字符串)，Tuple(元组)

可变数据类型（3个）：List(列表)，Dictionary(字典)，Set(集合)

（这里的可变不可变，其实相当于是指针，不可变类型，当你对一个变量重新赋值的时候，比如a=10,到a=11,经过这修改之后，a变量的地址也就发生了改变，而可变数值类型，就是当你给一个变量进行赋值的时候，其所指的地址没有发生改变）

a = 10
print(id(a))  # 假设内存地址是：140732827137096

a = 11        # 看起来我们"改变"了 a 的值
print(id(a))  # 内存地址变成了：140732827137128 (地址变了！)

my_list = [1, 2, 3]
print(id(my_list))  # 假设内存地址是：2348972348900

my_list.append(4)   # 在列表末尾添加元素
my_list[0] = 99     # 修改列表第一个元素

print(my_list)      # 输出: [99, 2, 3, 4]
print(id(my_list))  # 内存地址依然是：2348972348900 (地址没变！)

1.1、int整型

书写很大的数时，可使用下划线将其中的数字分组，使其更清晰易读。

num1 = 1_000_000_000_000_000
print(num1)  # 1000000000000000

可以使用 type() 来查看变量类型，使用 isinstance() 来判断变量类型。

type() 和 isinstance() 的区别在于 type() 不会认为子类是一种父类类型，isinstance() 会认为子类是一种父类类型。bool类型是int类型的子类型。

num1 = True
num2 = 10
print(type(num1))  # <class 'bool'>
print(type(num2))  # <class 'int'>
print(type(num1) == type(num2))  # False
print(isinstance(num1, bool))  # True
print(isinstance(num1, int))  # True，Python3中，bool是int的子类
print(isinstance(num2, int))  # True

小整数池：Python将 [-5, 256] 的整数维护在小整数对象池中。这些整数提前创建好且不会被垃圾回收，避免了为整数频繁申请和销毁内存空间。不管在程序的什么位置，使用的位于这个范围内的整数都是同一个对象（不同的 Python 实现：小整数池的范围和实现细节可能因 Python 的不同实现（如 CPython、Jython、IronPython 等）而有所不同。上述提到的[-5, 256]范围是 CPython 的默认实现。）。

大整数池：一开始大整数池为空，每创建一个大整数就会向池中存储一个。

1.2、float 浮点型

Python将所有带小数点的数称为浮点数。要注意在使用浮点数进行计算时可能会存在微小误差，可以通过导入decimal解决。

num1 = 0.1
num2 = 0.2
print(num1 + num2)  # 0.30000000000000004

from decimal import Decimal
num3 = Decimal('1.0')
num4 = Decimal('0.9')
print(num3-num4) #0.1

也可以使用科学计数法表示浮点数。

num1 = 1.3e7
print(num1)  # 13000000.0

bool 布尔型

布尔型变量只有 True 和 False，用于真假的判断。

bool1 = True

bool2 = False

print(bool1, bool2) # True False

Python3中，bool 是 int 的子类，True 和 False 可以和数字相加。

True1、False0 会返回 True

is 运算符用于比较两个对象的身份（即它们是否是同一个对象，是否在内存中占据相同的位置），而不是比较它们的值。注意和上述的isinstance的区别

print(True == 1) # True

print(False == 0) # True

print(True is 1) # False

print(False is 0) # False

在Python中，能够解释为假的值不只有False，还有：

None

0

0.0

False

所有的空容器（空列表、空元组、空字典、空集合、空字符串）

String字符串初识

字符串就是一系列字符。在Python中，用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号。可使用反斜杠 \ 转义特殊字符。

str1 = 'This is a "string"'

str2 = "This is a 'string' too"

print(str1) # This is a "string"

print(str2) # This is a 'string' too

str1 = "This is a 'string'"

str2 = 'This is a "string" too'

print(str1) # This is a 'string'

print(str2) # This is a "string" too

也可以使用三个引号表示多行字符串。三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。

一个典型的用例是，当你需要一块HTML或者SQL时，使用三个引号就很简单

str1 = """hello world
HELLO WORLD"""
print(str1)

转义字符	说明
\	在行尾作为续行符
|反斜杠符号
'	单引号
"	双引号
\b	退格
\n	换行
\t	横向制表符
\r	回车，回到行首

1）intern机制

每个（字符串），不夹杂空格或者特殊符号，默认开启intern机制，共享内存，靠引用计数决定是否销毁。相同的字符串默认只保留一份，当创建一个字符串，它会先检查内存里有没有这个字符串，如果有就不再创建新的了。

a = "hello_world123"
b = "hello_world123"

print(a is b)        # 输出: True
print(id(a) == id(b))# 输出: True

# 解释：a 和 b 的内存地址完全一致，说明内存中只有一个 "hello_world123" 对象。

# 我们在运行时动态生成包含空格或特殊符号的字符串
s1 = "hello world!"
s2 = "hello " + "world!"

print(s1 == s2) # 输出: True (它们的值是一样的)
print(s1 is s2) # 输出: False (它们的内存地址不同！)

# 解释：因为包含空格和感叹号，且是动态生成的，Python 默认没有触发驻留机制，
# 导致内存中出现了两份一模一样的 "hello world!"。

字符串缓冲池：单个字母，长度为1的 ASCII 字符会被 interned，包括空字符。

数据类型转换

自动类型转换（隐式转换），对两种不同类型的数据进行运算，较小的数据类型（整数）就会转换为较大的数据类型（浮点数）以避免数据丢失，计算结果为浮点型：

num1 = 2
num2 = 3.0
print(num1 + num2)  # 5.0

两个整型进行除法运算结果也是浮点型：

num1 = 9
num2 = 1
print(num1 / num2)  # 9.0

而整型和字符串相加会报错，此时Python无法进行隐式转换完成计算：

num1 = 123
str1 = "456"
print(num1 + str1)  # 报错

强制类型转换（显式转换）

可以通过函数对数据类型进行转换。[,base]意思就是可填可不填

函数	说明
int(x [,base])	将x转换为一个整数，x若为字符串可用base指定进制
float(x)	将x转换为一个浮点数
complex(real[,imag])	创建一个实部为real，虚部为imag的复数
str(x)	str(x) 将对象x转换为一个字符串
repr(x)	将对象x转换为一个字符串，可以转义字符串中的特殊字符
eval(x)	执行x字符串表达式，并返回表达式的值
bin(x)	将一个整数转换为一个二进制字符串
oct(x)	将一个整数转换为一个八进制字符串
hex(x)	将一个整数转换为一个十六进制字符串
ord(x)	将一个字符转换为它的ASCII整数值
chr(x)	将一个整数转换为一个Unicode字符
tuple(s)	将序列s转换为一个元组
list(s)	将序列s转换为一个列表
set(s)	转换s为可变集合

num_int = 123
num_str = "456"
print("num_int 数据类型为:",type(num_int))
print("类型转换前，num_str 数据类型为:",type(num_str))
num_str = int(num_str)    # 强制转换为整型
print("类型转换后，num_str 数据类型为:",type(num_str))
num_sum = num_int + num_str
print("num_int 与 num_str 相加结果为:",num_sum)
print("sum 数据类型为:",type(num_sum))
输出：
num_int 数据类型为: <class 'int'>
类型转换前，num_str 数据类型为: <class 'str'>
类型转换后，num_str 数据类型为: <class 'int'>
num_int 与 num_str 相加结果为: 579
sum 数据类型为: <class 'int'>

字符的编码和解码

str1 = '你好中国'
print(str1)
print(type(str1))
# 将字符串数据类型转换为字节型数据的过程成为编码 encode，需要指定编码类型  
byte1 = str1.encode(encoding='utf8')
# 4个字符转换为了12个字节, 所以一个汉字占用3个字节
print(byte1)  # b'\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xb8\xad\xe5\x9b\xbd'
print(type(byte1))  # <class 'bytes'>

# 在进行编码集使用时,一定要注意,使用什么编码集编码,就要使用它解码,否则报错.
# 'utf-8' codec can't decode byte 0xc4 in position 0: invalid continuation byt
# byte2 = str1.encode(encoding='gbk')
# print(byte2) 
# print(type(byte2))  

# 将字节型数据转换为字符型数据的过程称为解码 decode
str2 = byte1.decode(encoding='utf8')
print(str2)  # 你好中国
print(type(str2))  # <class 'str'>

2、 输入输出

如果接收用户在键盘上输入一些字符，Python提供了一个input()函数，可以让用户输入字符串，并存放到一个字符串变量里。

语法：字符串变量 = input("提示信息")

# Python开始等待你的输入。这时，你可以输入任意字符，然后按回车后完成输入。
input_str = input("请输入：")
# 输入完成后，不会有任何提示，刚才输入的内容存放到input_str变量里了
print("input_str数据类型为:",type(input_str))#<class 'str'>
# 输出input_str查看变量内容
print(input_str)

输出

普通输出：使用 print() 可将内容打印。

print("Hello Python")

多个内容之间可以使用逗号隔开。

print("Hello", " Python")

可以使用 end= 来控制 print() 以什么结尾。

print("使用\\n结尾", end="\n")  # 用\n结尾，等同于print("使用\\n结尾")
print('使用""结尾', end="")  # 用空字符串结尾
print("Hello")

格式化输出：我比较常用的是,字符串前加上一个f,字符串中的{}内写入变量名

int1 = 10
float1 = 3.14159
str3 = f"int1 = {int1}, float1 = {float1}"
print(str3)  # int1 = 10, float1 = 3.14159

{}内变量名后可以加上 = ，打印时会在变量值前加上 变量名=。

int1 = 10
float1 = 3.14159
str3 = f"{int1 = }, {float1 = }"
print(str3)  # int1 = 10, float1 = 3.14159

{}外再套一层{}，即{{}}则打印出来就是带有括号的

int1 = 10
float1 = 3.14159
str3 = f"{{int1 = }, {float1 = }}"
print(str3)  # {int1 = 10, float1 = 3.14159}

如果你想让 float1 只保留两位小数：

int1 = 10

float1 = 3.14159

如果想控制更加多元的输出，你只需要在变量名后面加上一个 冒号 :，然后紧跟格式化控制符即可。语法规则是：f"{变量:格式化规则}"

str3 = f"int1 = {int1}, float1 = {float1:.2f}"
print(str3)  
# 输出: int1 = 10, float1 = 3.14

3、运算符

算数运算符

运算符 说明 实例

• 加 a + b

• 减、或取负 a - b、-a

• 乘 a * b
  / 除 a / b
  // 整除，除后向下取整 a // b
  % 模，返回除法的余数 a % b
  ** 幂 a ** b

运算符	说明	实例
+	加	a+b
-	减或取负	a-b、-a
*	乘	a*b
/	除	a/b
//	整除，除后向下取整	a//b
%	模，返回除法的余数	a%b
**	幂	a**b

# -------------算术运算符---------------
a = 20
b = 10
c = a + b
print(a , "+" , b , "的结果为" , c)
c = a - b
print(a , "-" , b , "的结果为" , c)
c = a * b 
print(a , "*" , b , "的结果为" , c)
c = a / b  #注意：结果为浮点类型
print(a , "/" , b , "的结果为" , c)
c = a % b 
print(a , "%" , b , "的结果为" , c)
a = 2
b = 3
c = a ** b
print(a , "的" , b , "次方结果为" , c)
a = 10
b = 3
c = a // b 
print(a , "//" , b , "的结果为" , c)
print("-" * 30) # 输出30次-
输出结果：
20 + 10 的结果为 30
20 - 10 的结果为 10
20 * 10 的结果为 200
20 / 10 的结果为 2.0
20 % 10 的结果为 0
2 的 3 次方结果为 8
10 // 3 的结果为 3

赋值运算符

运算符	说明	实例
=	赋值	a = 1
+=	加法赋值	a += 2，等同于a = a + 2
-=	减法赋值	a -= 2，等同于a = a - 2
*=	乘法赋值	a *= 2，等同于a = a * 2
/=	除法赋值	a /= 2，等同于a = a / 2
//=	整除赋值	a //= 2，等同于a = a // 2
%=	模赋值	a %= 2，等同于a = a % 2
**=	幂赋值	a **= 2，等同于a = a ** 2
:=	海象运算符，在表达式中同时进行赋值和返回赋值的值。Python3.8 版本新增	num1 = 20 print((num2 := 3**2) > num1) print(num2)

比较运算符

运算符	说明	实例
==	相等，比较两者的值	a == b
!=	不相等	a != b
>	大于	a > b
<	小于	a < b
>=	大于等于	a >= b
<=	小于等于	a <= b

注意：除了不同数据类型的数据不能比较大小
# -------------比较运算符---------------
num1 = 10
num2 = 20
print(num1 == num2)  # False
print(num1 != num2)  # True
print(num1 > num2)   # Flase
print(num1 < num2)   # True
print(num1 >= num2)  # False
print(num1 <= num2)  # True
num3 = 'abc'
# 注意：不同的数据类型之间不能进行大小的比较
print(num1 > num3)
# 如果是字符串比较大小，是从最左边开始逐个比较字符串中相应位置的字符的ASCII码
print('5' > '6') # False
print('15' > '6') # False

逻辑运算符

运算符	说明
and	与，x and y，若x为False返回x的值，否则返回y的值
or	或，x or y，若x为True返回x的值，否则返回y的值
not	非，not x，若x为True返回False，若x为False返回True

b1 = False
b2 = True
print(b1 and b2)  # False
print(b1 or b2)  # True
print(not(b1))  # True
print(5 and 8) # 8 非0表示True，0表示False
print(0 and 8) # 0
print(5 or 8)  # 5
print(0 or 8)  # 8
print(not(5))  # False

位运算符

运算符	说明	实例
&	按位与	a & b
^	按位异或	a ^ b
~	按位取反	~ a
<<	按位左移	a << 1
>>	按位右移	a >> 1

a = 10   # 二进制: 1010
b = 6    # 二进制: 0110

print("a =", a, "二进制:", bin(a))
print("b =", b, "二进制:", bin(b))
print("-" * 40)

# 1. 按位与 &
c = a & b
print("a & b =", c, "二进制:", bin(c))   # 1010 & 0110 = 0010

# 2. 按位异或 ^相异为1 相同为零
c = a ^ b
print("a ^ b =", c, "二进制:", bin(c))   # 1010 ^ 0110 = 1100

# 3. 按位取反 ~
c = ~a
print("~a =", c, "二进制:", bin(c))

# 4. 按位左移 <<
c = a << 1
print("a << 1 =", c, "二进制:", bin(c))  # 1010 -> 10100

# 5. 按位右移 >>
c = a >> 1
print("a >> 1 =", c, "二进制:", bin(c))  # 1010 -> 0101

身份运算符

运算符	说明	实例
is	判断两个标识符是不是引用自相同对象	a is b，类似id(a) == id(b)。如果引用的是同一个对象则返回True，否则返回False
is not	判断两个标识符是不是引用自不同对象	a is not b，类似id(a) != id(b)。如果引用的不是同一个对象则返回True，否则返回False

# -------------身份运算符---------------
m = 20
n = 20
q = 30
print(m is n)  # True 判断m和n在内存中是否指向同一个地址，因为小整数池的原因
print(n is q)  # False
print(n is not q)  # True
# id() 用于获取对象在内存中的地址
print(id(m) == id(n)) # True

print("-" * 30)
# -------------is和==的区别---------------
a = [1,2,3]
b = a 

print(b is a)  # True
print(b == a)  # True

b = a[:]
print(b)
print(b is a)  # False
print(b == a)  # True