01. 数据类型
1.1 类与对象
- 类:是对具有公共特征的事物进行的归类,是一个抽象的描述。如人类、动物类、天体类。
对象:是一个类下具体存在的一个实体,是真真实实存在的一个事物,是参与运算的实际数据。如张继科(人类的对象)、小黑(动物类的对象)、地球(天体类的对象)。
1.2 数据类型与type()函数
1.2.1 Python中的数据类型
Python中的数据类型有数值、字符串、列表、元组、字典、集合、空值七大类。
- 数值类型:
- 整形(int):如1、51、58099、-123等。
- 浮点型(float):如3.14、5.26、-12.34等。
- 布尔类型(bool):True(1)和False(0)。
- 复数类型(complex):如123-234j。
- 字符串(str):如’Hi’、”Hello”、”””World”””等。
- 列表(lst):如[1, 2, 3, “Hello”, True]。
- 元组(tuple):如(1, 2, 3, ‘Hello’, True)。
- 字典(dict):如{‘k1’: ‘v1’, ‘k2’: ‘v2’}。
- 集合(set)如:{1, 2, 3, 5}。
空值(NoneType):即什么都没有的数据,这个类型中只有一个值:None。
type(数据)
函数可以判断数据的类型,其返回值是<class '数据类型'>
类型的数据。a, b = 123, None
c = [1, 2, 3]
print(type(a), type(b), type(c)) # <class 'int'> <class 'NoneType'> <class 'list'>
1.3 Python动态类型
编程语言除了分为解释型语言和编译型语言外,还可以分为强类型语言(如C、Java等)和弱类型语言(也称动态类型语言,如Python、JavaScript等)。
在强类型语言中,变量在定义时会致明其类型,一个变量只能被赋值一种类型的数据。
int number = 12; // 定义变量number,且规定其类型为整型。
number = 245; // 为其赋值一个整型数据,合法。
number = "ABC"; // 为其赋值一个字符串类型数据,非法,报错。
number = 3.14; // 为其赋值一个浮点型数据,非法,报错。
在弱类型语言中,变量在定义时不需要指明其类型,变量的类型是根据当前传入的值决定的,且一个变量可以传入不同类型的数据。 ```python data = 123 # 现在data是一个整型变量 print(type(data)) #
,type()函数返回变量或数据的类型,格式为
data = “ABC” # 现在data是一个字符串类型的变量。
print(type(data)) #
<a name="dZUw6"></a>
### 1.4 标记变量的数据类型(没有什么意义)
- Python可以使用`变量名: 数据类型`的形式标记数据的类型。
- 但是意义不大,因为这里只起到了一个标记的作用,没有强制的约束力。
- 因此,哪怕给一个变量标记了int,这个变量还是可以被赋予其他类型的数据。
```python
num: int = 199
print(type(num)) # <class 'int'>
num = "ABC"
print(type(num)) # <class 'str'>
- 这种方式标记变量,在PyCharm里如果赋予不同类型的数据时,其背景会进行高亮显示,但并不会报错。
-
02. 运算符
2.1 Python运算符概述
Python的运算符有:
- 算术运算符:+、-、、/、//、%、*
- 赋值运算符:=、+=、-=、=、/=、//=、%=、*=
- 比较运算符:>、>=、<、<=、==、!=
- 海象运算符::=
- 逻辑运算符:and、or、not
- 成员运算符:in、not in
- 身份运算符:is、is not
- 位运算符:&、|、^、~、<<、>>
- 运算符优先级:算数运算符 >> 位运算符 >> 比较运算符 >> 逻辑运算符 >> 赋值运算符
- 优先级高的运算符先执行,优先级低的运算符后执行,但可以通过小括号改变运算符优先级。
布尔类型的数据可以参与算术运算与位运算,参与运算时True视作1,False视作0。
2.2 算数运算符
2.2.1 算数运算符详解
+
:对于数值型数据来说,+就是进行加法运算的;对于字符串而言,+号用于实现两个字符串之间的拼接。 ```python print(31 + 25) # 56 print(3.14 + 5.26) # 8.4 print(0.1 + 0.2) # 0.30000000000000004,二进制精度问题
print(“abc” + “def”) # abcdef
- `-`:对于数值型数据来说,-就是进行减法运算的。
```python
print(31 - 25) # 6
print(3.14 - 5.26) # -2.1199999999999997
print(0.1 - 0.2) # -0.1
*
:对于数值型数据来说,就是进行运算的;对于字符串而言,`str n`用于实现字符串str重复n次。print(34 * 32) # 1088
print(3.14 * 5.26) # 16.5164
print("ABC" * 3) # ABCABCABC
/
:对于数值型数据来说,/就是进行除法运算的,其结果为float类型。print(4 / 2) # 2.0
print(23.45 / 3.14) # 7.468152866242038
//
:对于数值型数据来说,//是进行整除运算的。- 整除的结果为一个整数,即对/除法运算的结果进行向下取整(小于等于商的整数)。
- 当被除数是浮点数时,结果为x.0。 ```python print(4 // 2) # 2 print(4.0 // 2) # 2.0
向下取整
print(5 // 2) # 2 print(-10 // 4) # -3
- `%`:对于数值型数据来说,%是进行取余运算的。
```python
print(15 % 2) # 1,3,15 / 2 = 7 …… 1
**
:对于数值型数据来说,**是进行次幂运算的,即。- 若0 < y < 1,即时,其运算结果是浮点数的。 ```python print(2 3) # 8 print(27 (1/3)) # 3.0
**的优先级高于正负号
print(-1 2) # -1,实际上是-(1 2) print((-1) ** 2) # 1
<a name="JJqdJ"></a>
#### 2.2.2 布尔数据参与算数运算
- 如果布尔类型的数据【True 和 False】参与算术运算,则True会被当做1、False会被当做0进行运算。
```python
print(True + 10) # 11
print(25 + False) # 25
print(True + False) # 1
print(False - True) # -1
算术运算符的优先级:
**
>>正+负-号
>>*、/、//、%(这四个是平级的)
>>+、-(这两个是平级的)
2.3 赋值运算符
=
:将等号右边的表达式的计算结果,赋值给等号左边的变量。num = 12 * 24
print(num) # 288
+=
:将符号左边变量的值取出,与符号右边的数据进行加法运算,再将计算结果赋值给符号左边的变量,x += n => x = x + n
。- 如一个变量num = 34,num += 25就是将num的值取出与25做加法运算,即34 + 25 = 59,最后将59赋值给变量num。
num = 34
num += 25
print(num) # 59
- 如一个变量num = 34,num += 25就是将num的值取出与25做加法运算,即34 + 25 = 59,最后将59赋值给变量num。
-=
:将符号左边变量的值取出,与符号右边的数据进行减法运算,再将计算结果赋值给符号左边的变量,x -= n => x = x - n
。- 如一个变量num = 34,num -= 25就是将num的值取出与25做减法运算,即34 - 25 = 9,最后将9赋值给变量num。
num = 34
num -= 25
print(num) # 9
- 如一个变量num = 34,num -= 25就是将num的值取出与25做减法运算,即34 - 25 = 9,最后将9赋值给变量num。
*=
:将符号左边变量的值取出,与符号右边的数据进行乘法运算,再将计算结果赋值给符号左边的变量,x *= n => x = x * n
。- 如一个变量num = 3,num = 4就是将num的值取出与4做乘法运算,即3 4 = 12,最后将12赋值给变量num。
num = 3
num *= 4
print(num) # 12
- 如一个变量num = 3,num = 4就是将num的值取出与4做乘法运算,即3 4 = 12,最后将12赋值给变量num。
/=
:将符号左边变量的值取出,与符号右边的数据进行除法运算,再将计算结果赋值给符号左边的变量,x /= n => x = x / n
。- 如一个变量num = 35,num /= 7就是将num的值取出与7做除法运算,即35 / 7 = 5.0,最后将5.0赋值给变量num。
num = 35
num /= 7
print(num) # 5.0
- 如一个变量num = 35,num /= 7就是将num的值取出与7做除法运算,即35 / 7 = 5.0,最后将5.0赋值给变量num。
//=
:将符号左边变量的值取出,与符号右边的数据进行整除运算,再将计算结果赋值给符号左边的变量,x //= n => x = x // n
。- 如一个变量num = -10,num //= 3就是将num的值取出与3做整除运算,即-10 / 3 = -4,最后将-4赋值给变量num。
num = -10
num //= 3
print(num) # -4
- 如一个变量num = -10,num //= 3就是将num的值取出与3做整除运算,即-10 / 3 = -4,最后将-4赋值给变量num。
%=
:将符号左边变量的值取出,与符号右边的数据进行取模运算,再将计算结果赋值给符号左边的变量,x %= n => x = x % n
。- 如一个变量num = 22,num %= 4就是将num的值取出与4做整除运算,即22 % 4 = 2,最后将2赋值给变量num。
num = 22
num %= 4
print(num) # 2
- 如一个变量num = 22,num %= 4就是将num的值取出与4做整除运算,即22 % 4 = 2,最后将2赋值给变量num。
**=
:将符号左边变量的值取出,与符号右边的数据进行次幂运算,再将计算结果赋值给符号左边的变量,x **= n => x = x ** n
。比较运算符用于比较两个数据在数学关系中的大小,其结果是布尔类型的。
x > y
:判断x是否大于y。print(3 > 5) # False
x >= y
:判断x是否大于等于y。print(25 >= 16) # True
x < y
:判断x是否小于y。print(14 < 35) # True
x <= y
:判断x是否小于等于y。print(35 <= 123) # True
x == y
:判断x是否等于y。print(12 == 12) # True
x != y
:判断x是否不等于y。print(12 != 12) # False
2.4.2 字符串比较大小
- 计算机基础概念与Python环境搭建 — 01. 计算机基础知识 — 04. 编码与解码中提到,计算机在存储数据时是先将数据转换成编码集对应的十进制数据,再转换成十进制对应的二进制数据,最后再存储到计算机的硬件设备上的。
- 根据数据的存储规则,可以得出比较两个字符串的大小的规则为:比较两个字符串左边第一个字符对应的十进制数据,如果第一个字符一样,则比较第二个字符。以此类推,直到得出结果为止。 ```python print(‘a’ > ‘A’) # True,实际上比较的是97(a的ASCII码)和65(A的ASCII码)的大小。
print(“hello” > “head”) # True,h相同,比较e,e也相同,比较l和a,l的ASCII为108,a为97,因此”hello”大于”head”。
<a name="BHHxi"></a>
### 2.5 海象运算符
- 海象运算符是3.8中新增的语法;符号为:`:=`,原名为赋值表达式,因其符号的样子像海象的鼻子而得名海象运算符。
- 海象运算符主要作用是在定义一个变量的同时,让这个变量参与到逻辑运算中,可用于简化代码。
- 现有一个一次函数![](https://cdn.nlark.com/yuque/__latex/448c591515443994aab271b2ee5ed3eb.svg#card=math&code=f%28x%29%20%3D%202x%20%2B%201&id=XmXZk),要求![](https://cdn.nlark.com/yuque/__latex/bad4a92ef03a3b344ee4163ce134e5d8.svg#card=math&code=f%2817%29&id=HKGWx)的值,在Python中可以这么写:
```python
x = 17
y = 2 * x + 1
print(y) # 35
海象运算符就可以做到在定义x的同时,让x参与到y的赋值运算中。
y = 2 * (x := 17) + 1
print(y) # 35
2.6 逻辑运算符
逻辑运算符用于判断逻辑条件是否成立,有逻辑与(and)、逻辑或(or)、逻辑非(not)三类。
2.6.1 逻辑与and
计算规则:用and连接,只有当两个都为True时,才会True;只要有一个为False,或者两个都为False,那么结果就为False。
- 计算公式:(一假则全假,全真才为真)
- True and True -> True
- True and False -> False
- False and True -> False
- False and False -> False
- 短路原则:若左边表达式为假,则直接返回False,右边表达式不会进行计算。
- 示例:判断num是否及大于35,又小于64。 ```python num = 77 res = num > 35 and num < 64 print(res) # False
注:Python支持数学那样的连续比较,故第2行代码可写为:res = 35 < num < 64
但在理解上,依旧需要理解成逻辑与的关系。
<a name="Z7Kr4"></a>
#### 2.6.2 逻辑或or
- 计算规则:用or连接,只有当两个都为False时,结果才为Flase;只要有一个为True结果就为True。
- 计算公式:(一真则全真,全假才为假)
- True and True -> True
- True and False -> True
- False and True -> True
- False and False -> False
- 短路原则:若左边表达式为真,则直接返回True,右边表达式不会进行计算。
- 示例:判断num是否大于20或者小于-10。
```python
num = -31
res = num > 20 or num < -10
print(res) # True
2.6.3 and短路与or短路
and短路:左边表达式不成立时,右边表达式不执行【这里的表达式是指与and连接的表达式】,除了这个表达式不执行外,如果还有其他表达式,则其他表达式会执行。
num = 0
res1 = num != 0 and num % 3 == 0 or num % 5 == 0 # num % 3 == 0不执行,num % 5 == 0执行。
res2 = num != 0 and (num % 3 == 0 or num % 5 == 0) # (num % 3 == 0 or num % 5 == 0)整体不执行。
print(res1, res2) # True False
or短路:左边表达式成立,右边不执行,or可以短路后面的一切表达式。
num = 0
res = num % 3 == 0 or num % 5 == 0 and num != 0 # num % 5 == 0 and num != 0整体不执行。
print(res) # True
2.6.4 逻辑非not
计算规则:用not表示,即对逻辑结果取反,真变假,假变真。
- 计算公式:(一真则全真,全假才为假)
- not True -> False
- not False -> True
示例:判断一个字符是否不是小写英文字母。
ch = "n"
res = not ("a" <= ch <= "z")
print(res) # False,注意,若为True则表示ch不是小写英文字母;若为False则表示ch是小写英文字母。
2.6.5 非布尔类型的数据进行逻辑运算
非布尔类型的数据参与逻辑运算时会按照3.2.4中的转换规则进行隐式转换,转换完成后再参与逻辑运算。
- 隐式转换:只是将数据当成转换后的结果进行运算,数据本身不变。
- 如0转换后是False,13转换后是True,但0还是0,13还是13。
逻辑与运算:因为and的短路原则,左边表达式不成立,右边表达式不执行,使得最后运算结果如下:
- 左边表达式为假,结果就是左边表达式的值。
- 左边表达式为真,结果就是右边表达式的值。
print(10 and 11) # 11;10隐式转换后为True,故结果是左边表达式的值。
print([] and 13) # [];空列表隐式转换后为False,False造成and短路,结果为[]
print(not 1 and 0) # False;1隐式转换为True,故not 1的结果为False,False造成and短路,结果为(not 1)的值False
逻辑或运算:因为or的短路原则,左边表达式成立,右边表达式不执行,使得最后运算结果如下:
成员运算符用于判断某个数据是否在容器(字符串、列表、元组、字典、集合)中:
数据 in 容器
:判断数据是否在容器中。数据 not in 容器
:判断数据是否不在容器中。
示例:判断字符串Hel是否在字符串Hello中,123是否不在列表[234, 345, 456]中。
print("Hel" in "Hello") # True
print(123 not in [234, 345, 456]) # True
2.8 身份运算符
2.8.1 id()获取对象内存地址
id(数据对象)
函数用于获取数据对象在内存中的地址。>>> id(3.14)
3045776901712
>>> id(False)
140727462754440
如果是不可变类型的数据(整型、浮点型、布尔类型、字符串类型、元组),那么只要数据字面量一致,那么在内存中的地址一定一致。
>>> a = 10
>>> b = 10
>>> id(a), id(b)
(3045776255568, 3045776255568)
>>> print(id(a) == id(b))
True
如果是可变类型的数据(列表、字典、集合),那么只要定义一个数据对象,内存中就会新产生一份。
身份运算符是基于
id()
函数的结果,对两个数据对象的内存地址进行判断的。数值型数据中的特殊部分:
- -5~256之间的数值型数据会缓存在内存中,这部分数据在使用时会直接拿内存中的数据。
故-5~256之间的数值型数据不管定义几个,都是同一个数据。
>>> a, b = 3.14, 3.14
>>> a is b
True
>>> c, d = -34, -34
>>> c is d
True
但是如果超出了这个范围,就需要重新将数据加载到内存中,并且定义一次就会添加一次。
- 故超出这个范围的数据其数据对象的地址是不一样的。
>>> a = 257
>>> b = 256
>>> a is b
False
>>> c = -6
>>> d = -6
>>> c is d
False
字符串数据中的特殊部分:字符串中如果包含特殊字符,则定义一次就会产生一个新的数据对象。
>>> s1 = "zxcvbnm,.mnbvcxz"
>>> s2 = "zxcvbnm,.mnbvcxz"
>>> s1 is s2 # s1和s2虽然字面量一样,但含有英文逗号和英文句号两个符号。
False
>>> s3 = "qwertyuiop"
>>> s4 = "qwertyuiop"
>>> s3 is s4 # s3和s4字面量一样,且没有任何特殊符号。
True
2.9 位运算符
2.9.1 原码、反码与补码
计算机中的数据是以二进制进行存储的,但是二进制又有以下三种形态:
- 正数的原码、反码、补码相同,因此转换主要是针对于负数而言的。
- 原码:十进制数据转为对应的二进制数据。
- 正数13:0000 1101(数据在计算机中最小的存储单位是字节,占8个位)
- 负数-13:1000 1101(最高位1为符号位,0表示正数,1表示负数)
- 反码:在原码的基础上,除了最高位符号位外,其余位按位取反(0转1,1转0)
- 正数13:0000 1101(原码、反码、补码相同)
- 负数-13:1111 0010(将原码非符号位按位取反)
- 补码:在反码的基础上+1。
- 正数13:0000 1101(原码、反码、补码相同)
- 负数-13:1111 0011(在反码的基础上+1)
数据在进行运算时,是通过补码运算的;十进制和二进制数据间的转换是通过原码完成的。
2.9.2 位运算符详解
位运算符是将数据转为其对应的二进制数据,按位置依次进行运算的。
&
:按位与,相同位置上有一个数据为0,则该位结果为0。 ```python print(6 & -7) # 0 “”” 6的补码:0000 0110 -7的补码:1111 1001 原码:1000 0111 反码:1111 1000 补码:1111 1001
按位与: 0000 0110
1111 1001
0000 0000 结果为正数补码,即原码转十进制为0。 “””
- `|`:按位或,相同位置上有一个数据为1,则该位结果为1。
```python
print(6 | -7) # -1
"""
6的补码:0000 0110
-7的补码:1111 1001
原码:1000 0111
反码:1111 1000
补码:1111 1001
按位或:
0000 0110
1111 1001
---------
1111 1111
结果为负数补码,要转原码:
反码(补码-1) : 1111 1110
原码(符号位不变,其余位按位取反): 1000 0001
转十进制数据:-1
"""
^
:按位异或,相同位置上数据相同,则该位结果为0;相同位置上数据不同,则该位结果为1。 ```python print(6 ^ -7) # -1 “”” 6的补码:0000 0110 -7的补码:1111 1001 原码:1000 0111 反码:1111 1000 补码:1111 1001
按位异或: 0000 0110
1111 1001
1111 1111 结果为负数补码,要转原码: 反码(补码-1) : 1111 1110 原码(符号位不变,其余位按位取反): 1000 0001 转十进制数据:-1 “”” print(6 ^ 7) # 1 “”” 6的补码:0000 0110 7的补码:0000 0111 按位异或: 0000 0110
0000 0111
0000 0001 结果为正数补码,即原码转十进制为1。 “””
- `~`:按位取反,将二进制位置上的数据0转1,1转0。
```python
print(~6) # -7
"""
6的补码:0000 0110
按位取反:1111 1001
结果为负数补码,要转原码:
反码(补码-1) : 1111 1000
原码(符号位不变,其余位按位取反): 1000 0111
转十进制数据:-7
"""
<<
:按位左移,将二进制向左移动指定的位数,右边空出补0。数据 << 移动位数
的结果为print(3 << 2) # 12
"""
3的补码:0000 0011
按位左移2位:0000 11__
右边空位补0:0000 1100
结果为正数补码,即原码转十进制为12。
"""
print(3 << 5) # 96
"""
3的补码:0000 0011
按位左移5位:011_ ____
右边空位补0:0110 0000
结果为正数补码,即原码转十进制为96。
"""
>>
:按位右移,将二进制向右移动指定的位数,左边空出正数补0负数补1,右边超出位置舍去。数据 >> 移动位数
的结果为- 正数右移最小为0;负数右移最大为-1。
print(-48 >> 1) # -24
"""
-48 原码:1011 0000
反码:1100 1111
补码:1101 0000
按位右移:1110 1000 | 0 (舍弃部分)
结果为负数补码,要转原码:
反码(补码-1) : 1110 0111
原码(符号位不变,其余位按位取反): 1001 1000
转十进制数据:-24
"""
print(-48 >> 3) # -6
"""
-48 原码:1011 0000
反码:1100 1111
补码:1101 0000
按位右移:1111 1111 | 1110 1000 0 (舍弃部分)
结果为负数补码,要转原码:
反码(补码-1) : 1111 1110
原码(符号位不变,其余位按位取反): 1000 0001
转十进制数据:-1
"""
2.9.3 交换两个变量的值
方式一:借助第三方临时变量。
a, b = 10, 20
tmp = a # tmp = 10;a = 10;b = 20
a = b # tmp = 10;a = 20;b = 20
b = tmp # tmp = 10;a = 20;b = 10
print(a, b) # 20 10
方式二:按位异或。(一个数与相同的数异或两次,结果是其本身)
a, b = 10, 20
a = a ^ b # a = 10 ^ 20;b = 20
b = a ^ b # a = 10 ^ 20;b = 10 ^ 20 ^ 20 = 10
a = a ^ b # a = 10 ^ 20 ^ 10 = 20 ^ 10 ^ 10 = 20;b = 10
print(a, b) # 20 10
方式三:距离求和求差。
a, b = 10, 20
a = a + b # a = 10 + 20;b = 20
b = a - b # a = 10 + 20;b = 10 + 20 - 20 = 10
a = a - b # a = 10 + 20 - 10 = 20;b = 10
print(a, b) # 20 10
方式四:Python独有的方法。
a, b = 10, 20
print(a, b) # 10 20
a, b = b, a
print(a, b) # 20 10
03. 输入数据及数据类型转换
3.1 input()输入函数
3.1.1 input()函数实现输入功能
input()函数与print()函数是一对输入输出函数,input()函数负责在控制台上通过键盘输入数据。
- input()函数的基础语法:
变量名 = input(输入提示信息)
- 示例:实现下图的程序:
代码实现:
name = input("请输入你的姓名:")
gender = input("请输入你的性别(男士/女士):")
print("您好,", name, gender)
3.1.2 input()输入数据的类型
input()函数在运行时,不管从键盘中获取到什么类型的数据,这个数据都会被当成字符串处理,并不会自动解析其类型。
- 如下列代码,按理来说name应该是字符串型数据,age应该是整型数据,但结果却都是字符串型数据。 ```python name = input() age = input() print(type(name), type(age))
“”” 运行结果: Jack 18
- 如果要输入指定格式的数据,还需要在input()外面套一层类型转换函数。
<a name="N8Vnf"></a>
### 3.2 数据类型转换
<a name="e0xvZ"></a>
#### 3.2.1 int()转换为十进制整型
- `int(数据)`函数会将括号内的参数转换为十进制整型数据,详细来说有如下三个功能:
- 将整型字符串中的整型数据转换出来。
- 对浮点型数据进行取整。
- 将其他进制的数据转换成十进制数据。
```python
num1 = int("123")
print(type(num1), num1) # <class 'int'> 123
num2 = int(12.34)
print(type(num2), num2) # <class 'int'> 12
num3 = int(0b1001)
print(type(num3), num3) # <class 'int'> 9
- 对于其他进制的字符串数据,直接转换是会报错的,需要根据进制指定base参数的值。
```python
直接转换,报错。
print(int(“0b1011”)) # ValueError: invalid literal for int() with base 10: ‘0b1011’
根据字符串中数据的进制,指定base的值。
print(int(“0b1011”, base=2)) # 11 print(int(“0o62”, base=8)) # 50 print(int(“0xA1C7”, base=16)) # 41415
不知道字符串中数据的几进制时,指定base的值为0,Python会自动识别。
print(int(“0b1011”, base=0)) # 11 print(int(“0o62”, base=0)) # 50 print(int(“0xA1C7”, base=0)) # 41415
- 注意,如果数据类型不满足整型的转换格式,会报错:`ValueError: invalid literal for int() with base 10: 'data'`
```python
print(int('3.14')) # '3.14'是浮点型字符串,无法直接转换为整型数据
# 正确写法
print(int(float('3.14'))) # 3
print(int("数据是:10")) # ”数据是:“这部分是字符串数据,无法转换。
3.2.2 float()转换为浮点型
float(数据)
函数会将括号内的参数转换为浮点型数据,详细来说有如下两个功能:- 将浮点型字符串转换为浮点型数据。
- 将整型数据转换为num.0形式的浮点数。(不常用)
```python
num1 = float(“3.14”)
print(type(num1), num1) #
3.14
num2 = float(3)
print(type(num2), num2) #
- 如果数据类型不满足浮点型的转换格式,也会报错。
<a name="Tysav"></a>
#### 3.2.3 str()转换为字符串类型
- 与int()和float()恰好相反,`str(数据)`函数是将数据转换为字符串的形式。
```python
str1 = str(123)
print(type(str1), str1) # <class 'str'> 123
- 当字符串类型的数据需要与数值型的数据进行拼接时,不能直接使用+号连接两个数据。 ```python name = “Dosbo” age = 21 info = name + “ is “ + age + “ years old.” print(info)
运行报错:TypeError: can only concatenate str (not “int”) to str
- 而是需要先将数值型数据转换为字符串型数据,再用+号做连接操作。
```python
name = "Dosbo"
age = 21
info = name + " is " + str(age) + " years old."
print(info) # Dosbo is 21 years old.
3.2.4 bool()转换为布尔类型
bool(数据)
函数可以将数据转换为布尔类型的数据。转换规则:
当数据为整型或浮点型时,数据非0即为True,为0即为False。
print(bool(0)) # False
print(bool(5)) # True
print(bool(31.23)) # True
print(bool(0.0)) # False
print(bool(-31.1)) # True
当数据为容器类型的数据时,容器非空即为True,为空即为False。
print(bool("")) # False
print(bool(" ")) # True
print(bool("ABC")) # True
print(bool([])) # False
print(bool((12, 34, 56))) # True
空类型None为False。
print(bool(None)) # False
3.2.5 eval()动态类型转换
eval()会自动识别括号内参数的类型,然后将其转换为对应的类型。
- 注意:eval()不能识别str类型的数据,否则会报错。 ```python name = input(“请输入姓名:”) # name是字符串类型的数据,因此外面不能套eval()函数。 age = eval(input(“请输入年龄:”)) gpa = eval(input(“请输入绩点:”))
print(type(name), name) print(type(age), age) print(type(gpa), gpa)
“”” 运行结果: 请输入姓名:杜沈波 请输入年龄:21 请输入绩点:4.5
<a name="BuPXt"></a>
### 3.3 其他形态数据之间的转换
<a name="Dii3N"></a>
#### 3.3.1 bin()转换成二进制
- `bin(数据)`函数可以将其他进制的数据转换成二进制数据。
```python
print(bin(109)) # 0b1101101
print(bin(0o765)) # 0b111110101
print(bin(0x9ADF)) # 0b1001101011011111
3.3.2 oct()转换成八进制
oct(数据)
函数可以将其他进制的数据转换成八进制数据。print(oct(0b1101101)) # 0o155
print(oct(109)) # 0o155
print(oct(0x9ADF)) # 0o115337
3.3.3 hex()转换成十六进制
hex(数据)
函数可以将其他进制的数据转换成十六进制数据。print(hex(0b1101101)) # 0x6d
print(hex(0o115337)) # 0x9adf
print(hex(109)) # 0x6d
3.3.4 ord()字符数据转换成十进制数据
ord(字符)
函数获取字符数据对应的十进制数据。print(ord("A")) # 65
print(ord("a")) # 97
print(ord("0")) # 48
print(ord("亿")) # 20159
3.3.5 chr()十进制数据转换成字符数据
chr(数据)
函数可以按照文本的编码规则,获取十进制数据对应的字符。print(chr(65)) # A
print(chr(97)) # a
print(chr(48)) # 0
print(chr(20159)) # 亿