【Python3学习笔记】之【Python基础——基本数据类型】Python3 基本数据类型多个变量赋值标准数据类型数据类型转换

143 阅读 0 评论 95 点赞

我是靠谱客的博主仁爱狗，这篇文章主要介绍【Python3学习笔记】之【Python基础——基本数据类型】Python3 基本数据类型多个变量赋值标准数据类型数据类型转换，现在分享给大家，希望可以做个参考。

Python3 基本数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

复制代码

1
2
3
4
5
6
7
8
counter = 100  # 整型变量
miles = 1000.1  # 浮点型变量
name = "Rookie"  # 字符串

print(counter)
print(miles)
print(name)

复制代码

1
2
3
4
100
1000.1
Rookie

多个变量赋值

python 允许同时给多个变量赋值。例如：

复制代码

1
2
3
4
5
a = b = c = 1
count = a + b + c

print(count)

复制代码

1
2
3

或者：

复制代码

1
2
3
4
5
6
a, b, c = 1, 2, "Hello,World"

print(a)
print(b)
print(c)

复制代码

1
2
3
4
1
2
Hello,World

标准数据类型

python 中有六个标准数据类型：

Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）

其中：

不可变数据：Number（数字）、String（字符串）、Tuple（元组）；
可变数据：List（列表）、Set（集合）、Dictionary（字典）。

Number（数字）

python3 支持 int、float、bool、complex（负数）。

在python3 中只有一种整型int，表示长整型，取消了python2 中的Long。
内置的type() 函数可以用来查询变量所指对象类型。例如：

复制代码

1
2
3
4
a, b, c, d = 1, 2.0, True, 4+3j

print(type(a), type(b), type(c), type(d))

复制代码

1
2
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

也可以用isinstance() 函数来判断：

复制代码

1
2
3
4
5
a, b = 1, 2.0

print(isinstance(a, int))
print(isinstance(b, int))

复制代码

1
2
3
True
False

type 和 isinstance 函数的区别：

type() 不会认为子类是一种父类类型。
isinstance() 则会认为子类是一种父类类型。

例如：

复制代码

1
2
3
4
5
6
7
8
9
class A:  # 创建类A
  pass
class B(A):  # 创建类B，为类A的子类
  pass
  
# 分别用两个函数判断类B是否等于类A
print(type(B())==A)
print(isinstance(B(), A))

复制代码

1
2
3
False
True

关于父类子类会在后续面向对象中讲到

注意：在python2 中没有布尔类型，它用数字0表示False，用1表示True。到python3中把True 和False 定义成了关键字，但他们的值依然是1和0，且可以和数字相加。
例如：

复制代码

1
2
3
4
a, b = True, False

print(a + a +b)

复制代码

1
2
2

可以用del() 函数删除一个或者多个已被创建的对象：

复制代码

1
2
3
4
5
6
7
a, b, c = 1, 2, 3

del a
del b, c

print(a, b, c)

此时会报错显示a 不存在。

数值运算

复制代码

1
2
3
4
5
6
7
8
9
10
a, b = 9, 2

print(a + b)  # 加
print(a - b)  # 减
print(a * b)  # 乘
print(a / b)  #  除（得到浮点数）
print(a // b)  #  除（得到整数，直接舍去小数，不是四舍五入）
print(b % a)  # 取余
print(a ** b)  # 乘方

复制代码

注意：Python 还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的实部a和虚部b都是浮点型。

String（字符串）

python 中字符串用单引号 ’ 或者双引号 " 括起来，同时使用反斜杠转义特殊字符。
字符串截取语法格式如下：

复制代码

1
2
3
str[0:10:2]
变量[头下标:尾下标:步长]

索引值以0开始，-1为末尾位置：

复制代码

1
2
3
4
5
6
从后面的索引:  -6  -5  -4  -3  -2  -1  
从前面的索引:   0   1   2   3   4   5  
            +---+---+---+---+---+---+
            | a | b | c | d | e | f |
            +---+---+---+---+---+---+

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
str = "Hello!World!"

print(str)				# 输出字符串
print(str[0])			# 输出第一个字符
print(str[-1])			# 输出最后一个字符
print(str[0:-1])		# 输出第一个到倒数第二个字符串
print(str[:-1])			# 同上
print(str[1:])			# 输出第二个字符后面所有字符
print(str[:-1:2])		# 输出第一个到倒数第二个字符串，步长为2（每隔一个字符取一次）
print(str[::-1])		# 逆序输出
print(str * 2)			# 输出两次
print(str + "!!!!")		# 连接字符串

复制代码

1
2
3
4
5
6
7
8
9
10
11
Hello!World!
H
!
Hello!World
Hello!World
ello!World!
HloWrd
!dlroW!olleH
Hello!World!Hello!World!
Hello!World!!!!!

注意：字符串截取的时候str[头下标:尾下标]，是一个左闭右开区间[头下标,尾下标)，即包含左不包含右。

与C 字符串不同的是，python 的字符串不能被改变。比如向一个索引位置赋值：str[3] = ‘a’，会导致错误。

List（列表）

List（列表）是python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样，同样可以被索引，列表被截取后会返回一个包含所需元素的新列表。

截取格式和字符串相同。

复制代码

1
2
3
4
5
6
7
8
9
list_1 = [1, 2, 3]
list_2 = [4, 5, 6]
list_3 = [123, 1.2, True, 'abc', list_1]

print(list_1)               # 输出list_1
print(list_3)               # 输出list_3
print(list_3[0:3])          # 输出list_3的第1到3个字符
print(list_1 + list_2)      # 连接list_1和list_2并输出

复制代码

1
2
3
4
5
[1, 2, 3]
[123, 1.2, True, 'abc', [1, 2, 3]]
[123, 1.2, True]
[1, 2, 3, 4, 5, 6]

与python 字符串不同的是，列表可以改变：

复制代码

1
2
3
4
5
list = [1, 2, 3, 4, 5]

list[0] = 2
print(list)

复制代码

1
2
[2, 2, 3, 4, 5]

LIst 还内置了许多方法，如append()、pop() 等，在后续章节会讲到。
注意：

List 写在方括号中间，元素之间用逗号隔开
和字符串一样的索引规则
可以用+将两个List拼接为一个List
List中的元素可以改变

Tuple（元组）

Tuplr（元组）与列表类似，但是元组不可修改。元组是写在小括号 () 里，用逗号分隔开的。

元组里也可以包含多种类型元素：

复制代码

1
2
3
4
5
6
7
8
9
10
11
tuple_1 = [1, 2, 3]
tuple_2 = [4, 5, 6]
tuple_3 = [123, 1.2, True, 'abc', tuple_1]
tuple_4 = tuple_1 + tuple_2

print(tuple_1)               # 输出tuple_1
print(tuple_3)               # 输出tuple_3
print(tuple_3[0:3])          # 输出tuple_3的第1到3个字符
print(tuple_1 + tuple_2)     # 连接tuple_1和tuple_2并输出
print(tuple_4)

复制代码

1
2
3
4
5
6
[1, 2, 3]
[123, 1.2, True, 'abc', [1, 2, 3]]
[123, 1.2, True]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]

截取规则和字符串、列表一致，不再赘述。

当元组没有元素或只包含一个元素时，即空元组单元组时，有特殊规则：

复制代码

1
2
3
list_1 = ()  # 空元组
list_2 = (1,)  # 单元组（需要加一个逗号表示元组）

注意：

元组不可修改
索引规则同字符串、列表
单元组空元组的使用
元组也可以拼接

Set（集合）

Set（集合）是一个或多个形态各异的大小整体组成的，构成集合的事物或者对象称作元素或者成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 {} 或者 set() 函数创建集合，注意：创建一个空集合必须使用 set() ，因为 {} 是创建一个空字典。

创建格式：

复制代码

1
2
3
parame = {value1, value2}
set(value)

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
a = set('aabcd')
b = {'c', 'd', 'e', 'f'}

print(a, b)     # 输出两个集合，并且集合中重复的元素不会被打印

# 成员测试
if 'b' in a :
    print('True')
else :
    print('False')

# 集合运算

print(a - b)    # a和b的差集
print(a | b)    # a和b的并集
print(a & b)    # a和b的交集
print(a ^ b)    # a和b中不同时存在的元素

复制代码

1
2
3
4
5
6
7
{'a', 'c', 'b', 'd'} {'c', 'e', 'f', 'd'}
True
{'a', 'b'}
{'a', 'd', 'b', 'e', 'c', 'f'}
{'c', 'd'}
{'a', 'b', 'e', 'f'}

Dictionary（字典）

列表是有序的对象集合，字典是无序的对象集合。两者区别在于：字典中的元素是通过键来存取的，而不是通过偏移。

字典是一种映射类型，字典用 {} 标识，它是一个无序的 **键（key）：值（value）**的集合。

在一个字典中：键（key）必须不可变且唯一。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
dict_1 = {}
dict_1['name'] = 'Jack'
dict_1['age'] = 18
dict_1['gender'] = 'male'

print(dict_1.keys())  # 输出字典dict所有键
print(dict_1.values())  # 输出字典dict所有值
print(dict_1['name'])  # 输出字典dict键为name的值
print(dict_1)  # 输出字典

# 其它构建方法

# 一
dict_2 = {"name": "Lisa", "age": 18, "gender": "female"}
print(dict_2)
# 二
dict_3 = {'name': 'Bob',
          'age': 19,
          'gender': 'male'}
print(dict_3)
# 三
dict_4 = {x: x ** 2 for x in (2, 4, 6)}
print(dict_4)
# 四
dict_5 = dict([('name', 'Jay',), ('age', 18), ('gender', 'female')])
print(dict_5)

复制代码

1
2
3
4
5
6
7
8
9
dict_keys(['name', 'age', 'gender'])
dict_values(['Jack', 18, 'male'])
Jack
{'name': 'Jack', 'age': 18, 'gender': 'male'}
{'name': 'Lisa', 'age': 18, 'gender': 'female'}
{'name': 'Bob', 'age': 19, 'gender': 'male'}
{2: 4, 4: 16, 6: 36}
{'name': 'Jay', 'age': 18, 'gender': 'female'}

字典也有内置函数，之后会讲到。

注意：

字典是一种映射类型，元素时键值对
同一字典中的关键字必须为不可变类型，且不可重复
创建空字典用 {}

数据类型转换

函数	描述
int(x [,base])	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
a = 1.0
print(a, type(a))
a = int(a)
print(a, type(a))
a = float(a)
print(a, type(a))
a = str(a)
print(a, type(a))
a = tuple(a)
print(a, type(a))
a = list(a)
print(a, type(a))
a = set(a)
print(a, type(a))

复制代码

1
2
3
4
5
6
7
8
1.0 <class 'float'>
1 <class 'int'>
1.0 <class 'float'>
1.0 <class 'str'>
('1', '.', '0') <class 'tuple'>
['1', '.', '0'] <class 'list'>
{'0', '.', '1'} <class 'set'>