python3-基本数据类型_python3 数据类型

---

前言

Python3 中有六个标准的数据类型：

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

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

一、Number（数字）

数据类型不允许改变，如果改变数字数据类型的值，将重新分配内存空间

Python3 支持 int、float、bool、complex（复数）

四种基本类型：

给数字类型的变量赋值时会直接被创建：

x = 5    # int
y = 3.8  # float
z = 6j   # complex
j = True #bool
1
2
3
4

使用type()函数查看数据类型：

print(type(x))
print(type(y))
print(type(z))
print(type(j))
1
2
3
4

数据类型的转换:

x = int(2.8) # x trun to 2
y = float("3")   # y trun to 3.0
z = str(3.0)  # z trun to '3.0'
1
2
3

数值运算：

print(1 + 3)
print(1 - 3)
print(1 * 3)
print(1 / 3)
print(1 // 3)
print(1 // 3.0)
print(1 % 3)
print(1 ** 3)

"""
输出结果：
4
-2
3
0.3333333333333333
0
0.0
1
1
"""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

二、String（字符串）

python中的字符串用单引号或双引号引起来，转义时使用转义字符\或者r’ '表示

+ 是字符串的连接符， * 表示复制当前字符串，数字为复制的次数

字符串格式：

str = "hello"
1

遍历字符串：

for i in "hello":
  print(i)
1
2

字符串长度：
计算长度，使用len()函数

a = "Hello"
print(len(a))
1
2

检查字符串：

检查是否在字符串中，可用关键字in 不在可以用not in

a = "Hello"
print("l" in a)
1
2

字符串切片：

表达方式：str[start : end : step]
其中start表示起始位置，end表示结束位置，step表示步长

a = "Hello"
print(a[:3])#从起始位置切片
print(a[3:])#切到结尾
print(b[-3:-1])#负索引，从结尾开始计算，取-3位置到最后的位置
1
2
3
4

字符串格式化：

#+拼接
age = twenty-senven
txt = "My name is panpan, I am " + age
print(txt)
#format格式化
age = 27
txt = "My name is panpan, and I am {}"
print(txt.format(age))

#%s、%d格式化
print("I'm %s. I'm %d year old" % ('panpan', 27))
1
2
3
4
5
6
7
8
9
10
11

字符串修改：

a = "Hello "
print(a.upper())
print(a.lower())
print(a.strip())
print(a.replace("H", "h"))
print(a.split(" "))
print(a.title())
1
2
3
4
5
6
7

注意：所有字符串方法都返回新值，它们不会更改原始字符串

三、List（列表）

列表中元素的类型可以不相同，它支持数字，字符串、列表（所谓嵌套）

列表是写在方括号 [ ] 之间、用逗号分隔开的元素列表，列表项是有序的，可修改的，并允许重复的

列表语法格式：

列表名=[值1，值2]
1

列表索引语法格式如下：

变量[开始索引:结束索引：步长]
注意：索引从0开始计算，截取部分：含头不含尾，即结束索引的值不取
1
2

列表遍历：

# 遍历list列表的元素，使用for循环
for i in lists:
    print(i)
1
2
3

列表方法：

列表函数：

列表运算：

增加列表元素：

#+ 添加
list1+list2
#append()，末尾追加一个元素
list.append(元素)
#extend(),末尾添加多个元素
list。extend（[元素1，元素2]）
#insert(),指定位置插入
list.insert(指定位置，元素)
1
2
3
4
5
6
7
8

删除列表元素：

#删除单个
del 列表[下标]

#删除多个
del 列表[开始索引，结束索引]
1
2
3
4
5

修改列表元素：

#修改单个值
列表[下标]=新值

#修改多个元素（通过切片）：
列表[起始位置：结束位置]=[新值1，新值2]
1
2
3
4
5

查询列表元素：

#获取单个值
列表[下标]

#获取多个值
列表[起始位置：结束位置：步长]

1
2
3
4
5
6

四、Tuple（元组）

元组有序的，不可更改的
元组写在小括号 () 里，元素之间用逗号隔开

元组格式：
元组名=（值1，值2）

a = (1,2,3)
b = ()    # 空元组
c = (1,) # 一个元素，需要在元素后添加逗号
1
2
3

注意：元组不能添加、删除、修改元素

遍历元组：

tuple = ("apple", "banana", "cherry")
for i in tuple:
  print(i)
1
2
3

拼接元组：
使用+运算符

tuple1 = ("a", "b" , "c")
tuple2 = (1, 2, 3)

tuple3 = tuple1 + tuple2
print(tuple3)
1
2
3
4
5

使用*运算符

fruits = ("apple", "banana", "cherry")
tuple = fruits * 2
print(tuple)
1
2
3

输出元组：

a = (1,2,3)
b = ("hi","hello")
print (a)             # 输出完整元组
print (a[0])          # 输出元组的第一个元素
print (a[1:3])        # 输出从第二个元素开始到第三个元素
print (a[2:])         # 输出从第三个元素开始的所有元素
print (a * 2)         # 输出两次元组
print (a+ b)          # 连接元组
1
2
3
4
5
6
7
8

五、Dictionary（字典）

字典是无序的，用 { } 标识，是键(key) : 值(value) 的集合，键必须是不可变类型，在一个字典中，键是唯一的（列表是有序的）

新建字典：

方法一：
'''使用{}创建字典'''
dict1 =	{
  "name": "盘盘",
  "mobile": "13700000000",
  "age": 18
}
 print(dict1 )
 print(type(dict1 ))
 
 方法二：​
 '''第二种创建dict()'''
 dict1 = dict(name='盘盘', age=18)
 print(dict1)
​
方法三：
 '''空字典'''
 d1 = {}
 print(d1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

新增键的值：

dict["hobby"]="yoga"
1

删除键的值：

 del dict['盘盘']  # 删除指定的key-value
 dict.clear()  # 清空字典的元素
1
2

修改键的值：

dict["name"]="盘盘2"
1

获取键的值：

#获取name的值，结果应为：盘盘
方法一：
dict["name"]
方法二：
dict.get("name")
1
2
3
4
5

遍历字典：

for i in dict:
  #输出键
  print(i)
  #输出值
  print(dict[i])
1
2
3
4
5

遍历字典的值：

for i in dict.values():
  print(i)
1
2

遍历字典键值：

for x, y in dict.items():
  print(x, y)
1
2

字典方法：

字典的特点:

1. 字典中的元素是无序的
2. 字典中的所有元素都是一个 key-value对，key不允许重复，value可以重复
3. 字典中的key必须是不可变对象

六、Set（集合）

创建set集合，使用{ }
多个值之间用，隔开

集合创建格式：

集合名={值1，值2}
s = {1,4}
1
2

遍历集合：

set = {"盘盘", "盘盘1", "盘盘2"}
for i in set:
	print(i)
1
2
3

集合方法：

集合示例：

"""
set集合（无序）：{}
不能使用和下标有关的操作
"""
names = {"盘盘", "盘盘1", "盘盘2"}
names.add("盘盘3")  # 添加元素
names.pop()  # 随机删除元素
names.remove("盘盘")  # 删除指定元素
names.clear()  #清空set集合
print(names)

1
2
3
4
5
6
7
8
9
10
11