python3-基本数据类型

---

前言

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

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

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

一、Number（数字）

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

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

四种基本类型：

类型	说明
int (整数)	整数类型只有一种 int，例如2
bool (布尔)	是 int 的子类，True 和 False 可以和数字相加
float (浮点数)	如 1.23
complex (复数)	由实部和虚部构成，可以用a + bj

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

x = 5    # int
y = 3.8  # float
z = 6j   # complex
j = True #bool

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

print(type(x))
print(type(y))
print(type(z))
print(type(j))

数据类型的转换:

函数名	作用
int(x)	将x转换为一个整数
float(x)	将x转换为一个浮点数
complex(x)	将x转换为一个复数，实数部分为 x，虚数部分为 0
complex(x, y)	将 x 和 y 转换为一个复数，实数部分为 x，虚数部分为 y 。x 和 y 是数字表达式

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'

数值运算：

符号	说明
+	加
-	减
*	乘
\	除法，得到一个浮点数
\ \	除法，得到一个整数
%	取余
**	乘方

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
"""

二、String（字符串）

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

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

字符串格式：

str = "hello"

遍历字符串：

for i in "hello":
  print(i)

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

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

检查字符串：

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

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

字符串切片：

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

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

字符串格式化：

方法	说明
+	将字符串进行拼接，只能字符串与字符串拼接，数字不支持与字符串拼接
format()	将字符串和数字结合，使用占位符{}
%s、%d、%f	%s，表示一个字符串。%d，表示一个整数 。%f ，表示一个浮点数

#+拼接
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))

字符串修改：

方法	说明
upper()	所有的字符转成大写
lower()	所有的字符转成小写
strip()	去除字符串左右两侧指定字符或字符串
replace()	字符串替换str.replace(old, new)
split()	字符串分割，将字符串以指定的分隔符分割为列表[ ]
title（）	字符串中单词的首字符大写
find()	查找子串在字符串中首次出现的位置，如果未找到，返回-1
count()	统计子串在字符串中出现的次数
join()	将列表、元祖、集合中所有的元素按指定的分隔符拼接成一个字符串
title（）	字符串中单词的首字符大写
endswith（）	string.endswith(value, start, end),以什么结尾
startswith（）	string.startswith(value, start, end),以什么开始

a = "Hello "
print(a.upper())
print(a.lower())
print(a.strip())
print(a.replace("H", "h"))
print(a.split(" "))
print(a.title())

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

三、List（列表）

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

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

列表语法格式：

列表名=[值1，值2]

列表索引语法格式如下：

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

列表遍历：

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

列表方法：

方法	说明
.append(元素)	列表末尾追加一个元素
.extend([元素1,元素2])	列表末尾追加多个元素
.insert(下标，元素)	向指定下标位置插入元素
.pop(下标)	移除指定下标元素，未指定默认删除最后一个元素
.remove(元素)	删除指定元素
.clear()	清空list列表
.index(元素)	获取指定元素在列表中第一次出现的下标
.count(元素)	统计元素在列表中出现的次数
.reverse()	反转列表
.sort()	排序，默认升序，降序：reverse=True

列表函数：

函数	说明
len()	计算列表长度，例：len(列表)
max()	计算列表最大元素，例：max(列表)
min()	计算列表最小元素，例：min(列表)

列表运算：

运算	说明
+	将列表进行拼接，相加
*	列表复制
in	判断元素是否在列表中
not in	判断元素是否不在列表中

增加列表元素：

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

删除列表元素：

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

#删除多个
del 列表[开始索引，结束索引]

修改列表元素：

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

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

查询列表元素：

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

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

四、Tuple（元组）

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

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

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

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

遍历元组：

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

拼接元组：
使用+运算符

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

tuple3 = tuple1 + tuple2
print(tuple3)

使用*运算符

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

输出元组：

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)          # 连接元组

函数	说明
len( )	计算元组长度
type( )	查看类型

方法	说明
.count( )	计算元组元素出现次数
.index（ )	元组中元素出现次数

五、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)

新增键的值：

dict["hobby"]="yoga"

删除键的值：

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

修改键的值：

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

获取键的值：

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

遍历字典：

for i in dict:
  #输出键
  print(i)
  #输出值
  print(dict[i])

遍历字典的值：

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

遍历字典键值：

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

字典方法：

方法	描述
clear()	删除字典中的所有元素
copy()	返回字典的副本
get()	返回指定键的值
items()	返回包含每个键值对的元组的列表
keys()	返回包含字典键的列表
pop()	删除拥有指定键的元素
popitem()	删除最后插入的键值对
update()	使用指定的键值对字典进行更新
values()	返回字典中所有值的列表
len()	字典长度

字典的特点:

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

六、Set（集合）

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

集合创建格式：

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

遍历集合：

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

集合方法：

方法	说明
.add()	添加元素
.pop()	随机删除元素
.remove(元素)	删除指定元素
.clear()	清空集合
.update()	更新集合

集合示例：

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