三、Python核心数据类型

Python核心数据类型

1、String字符串

​ 1）Python中字符串可以使用单引号、双引号和三引号（三个单引号或三个双引号）包括起来，使用反斜杠 \ 转义特殊字符

​ 2）Python3源代码默认UTF-8，都是unicode字符串

​ 3）支持字符串拼接、截取等运算

常用的字符串操作方法

1）截取字符串

str = "Alice"
print(str[1])         # 访问位置1
print(str[0:4])
print(str[0:5:2])     # [起始位置:结束位置:步进值]
print(str[4:])        # 从指定位置到字符串末尾
print(str[:5])        # 从起始位置到指定位置

#输出结果
l
Alic
Aie
e
Alice

2）其他操作

print(str + ",Hello")  # +用于连接字符串
print(r"D\game\lol")   # 输出 \ 符号


#输出结果
Alice,Hello
D\game\lol

2、List列表

2.1特点

​ 1）一个list可以包含多种不同的混合数据类型，在列表中也可嵌套列表如[1,2,[3,4]]

​ 2）列表写于[]之间用逗号分隔

​ 3）列表的索引：0代表初始位置，-1代表末尾

​ 4）多个列表可以用+进行连接

2.2定义

​ 列表名=[变量1，变量2.....]

2.3访问与遍历

2.3.1访问

namelist_null = []    # 空列表
namelist = ["Alice", "John", "Tom"]
print(namelist[0])   # 访问初始位置
print(namelist[-1])  # 访问末尾
print(namelist)      # 直接输出
#输出结果
Alice
Tom
['Alice', 'John', 'Tom']

2.3.2遍历

# for循环遍历
namelist = ["Alice", "John", "Tom"]
for item in namelist:
    print(item)
# while循环遍历
namelist = ["Alice", "John", "Tom"]
i = 0
len = len(namelist)
while i < len:
    print(namelist[i])
    i +=1
    
#输出结果
Alice
John
Tom

Alice
John
Tom

2.4数据常用操作

2.4.1增加数据

​ 1）append方法

​ 定义：列表.append(元素) (元素也可以是列表如[1,2,[3,4]]）

​ 与extend的区别：append的参数为元素，即一个数值，而extend的参数是一个集合( 列表)， 区别如下例所示

a=[1,2]
b=[3,4]
a.append(b)
a.extend(b)
print(a)

#输出结果
[1, 2, [3, 4], 3, 4]

​ 2）insert方法

​ 定义：列表.insert(下标，元素) 作用：指定下标位置插入某元素

2.4.2删除

​ 1）del方法

​ 定义：del 列表[下标] 作用：在指定下标位置删除一个元素

​ 2）remove方法

​ 定义：列表.remove(元素) 作用：删除指定内容的元素

​ 注意在有内容重复时，删除查找到的第一个内容

​ 3）pop方法

​ 定义：列表.pop() 作用：弹出（删除）最后一个元素

2.4.3修改

​ 1）直接修改

​ 定义：列表[下标] = 新元素 作用：直接修改即重新赋值某个位置的元素

2.4.4查找

​ 1）in，not in

​ 定义：if 查找的元素 in 列表： else：

​ if 查找的元素 not in 列表： else：

​ 2）index方法

​ 定义：列表.index(所查元素, 起始位置, 结束位置) 作用：可以查找指定下标范围的元素 ，并返回元素的索引，注意范围左闭右开[起始位置, 结束位置)，找不到会报错

​ 3）count方法

​ 定义：列表.count(元素) 作用：统计列表中某元素的个数

2.4.5排序

​ 1）升序

​ 定义：列表.sort()

​ 1）倒序

​ 定义：列表.reverse()

2.5列表的嵌套

​ 定义：列表名 = [[元素1，元素2...], [元素1，元素2...] , [元素1，元素2...]....]

​ 访问：访问第一个元素2 列表名[0] [1]

2.6列表的例子

​ 题目：将八个老师随机分配到三个办公室，要求能有显示每个办公室的人数和姓名。

# -*- coding = utf-8 -*-
# @Time : 2021/7/26 17:30
# @Author : Alice
# @File : randomfenpei.py
# @Software : PyCharm
from random import randint    # 导入生成随机数的函数

offices = [[], [], []]        # 创建一个空的嵌套列表
teacher = ["A", "B", "C", "D", "E", "F", "G", "H"]     # 定义八个老师的name
for teacher_name in teacher:                           # 遍历八个老师的name
    index = randint(0,2)                               # 生成[0,2]之间的随机数
    offices[index].append(teacher_name)                # 将每个老师随机分配到offices列表中的三个嵌套列表中
i = 1
for office in  offices:                                # 第一层for循环，访问offices列表中的三个嵌套列表
    print(f"第{i}个办公室有{len(office)}个老师:")
    i += 1
    for teacher_name_ in  office:                      # 第二层for循环，依次访问三个列表中的每一个元素
        print(teacher_name_,end="\t")
    print("")
    print("-" * 20)
    
#输出结果
第1个办公室有1个老师:
G	
--------------------
第2个办公室有3个老师:
E	F	H	
--------------------
第3个办公室有4个老师:
A	B	C	D	
--------------------

3、Tuple 元组

3.1元组特点

​ tuple与list类似，访问方式一致，定义方式tuple写在小括号里，最重要的一点是tuple中的元素不 可修改，但可以包含可变对象，如list

3.2定义

元组名 = (元素1, 元素2, 元素3, ...)

示例

# 直接打印元组
tup = ("abc", 1, 26, 2.31, ['A', 'B'])
print(tup)

# 定义单元素元组
tup1 = (1,)     # 定义单元素元组必须加逗号，否则解释器会认为是类型转换
print(tup1)

#  元组内可修改list变量
tup[4][0] = 'C'
print(tup)


#输出结果
('abc', 1, 26, 2.31, ['A', 'B'])
(1,)
('abc', 1, 26, 2.31, ['C', 'B'])

3.3元组的常用操作

​ 由于元组无法进行元素的修改，所以可执行的操作很少，以下举出删除和增加的操作

3.3.1增加

​ 新建一个元组，然后把原有的元组相连接

# 增加
tup1 = (1, 2, 3)
tup2 = (4, 5, 6)
tup = tup1 + tup2
print(tup)


#输出结果
(1, 2, 3, 4, 5, 6)

3.3.2删除

​ 元组在删除时，删除的是整个元组变量

# 删除
tup1 = (1, 2, 3)
print(tup1)
del tup1
print(tup1)


#输出结果
(1, 2, 3)
Traceback (most recent call last):
  File "D:\program\Python\shixun\demo1\tuple.py", line 29, in <module>
    print(tup1)
NameError: name 'tup1' is not defined

4、Dict 字典

4.1.dict特点

1. 字典是无序的对象集合，使用key—value存储，具有很快的查找速度
2. key必须是不可变类型
3. 同一个字典中，key必须是唯一的

4.2定义

​ 字典名 = {"key1" : "value1", "key2" : "value2", "key3" : "value3", ...}

4.3访问dict内容

# 访问字典内容
info = {"name":"Alice", "age":"18" }
print(info)                                # 直接打印字典
print(info["name"])                        # 直接访问字典中存在(若访问不存在内容会报错)
print(info.get("gender"))                  # 使用get方法访问字典中不存在内容，返回None
print(info.get("gender", "字典中无此内容"))  # 使用get方法访问字典中不存在内容，并指定赋值内容
print(info.get("name", "John"))            # 使用get方法访问字典中存在内容，指定赋值内容无效


#输出结果
{'name': 'Alice', 'age': '18'}
Alice
None
字典中无此内容
Alice

4.4数据常用操作

4.4.1增加key-value对

# 增加操作
info = {"name":"Alice", "age":18 }
info["id"] = 1
print(info)


#输出结果
{'name': 'Alice', 'age': 18, 'id': 1}

4.4.2删除key-value对

#删除
# del删除key-value对
info = {"name":"Alice", "age":18 }
del info["name"]
print(info)

# del删除整个字典
del info     # 会提示错误信息，因为删除的是整个dict变量

# clear清空整个字典
info = {"name":"Alice", "age":18 }
info.clear()
print(info)


# 输出结果
{'age': 18}
{}

4.4.3修改key的value

# 修改
info = {"name":"Alice", "age":18 }
info["age"] = 20
print(info["age"])


# 输出结果
{'name': 'Alice', 'age': 20}

4.4.4查询

# 查询
# key查询，得到的是所以的键（列表）
info = {"name":"Alice", "age":18 }
print(info.keys())

# values查询，得到的是所以的值（列表）
info = {"name":"Alice", "age":18 }
print(info.values())

# items查询，得到的是所以的项（列表）,每个key-value对是一个元组
info = {"name":"Alice", "age":18 }
print(info.items())


# 输出结果
dict_keys(['name', 'age'])
dict_values(['Alice', 18])
dict_items([('name', 'Alice'), ('age', 18)])

4.4.5遍历

# 遍历
# 遍历key
print("遍历key的结果：")
for key in info.keys():
    print(key,end="\t")
print("")
print("-"*20)

# 遍历values
print("遍历values的结果：")
for value in info.values():
    print(value,end="\t")
print("")
print("-"*20)

# 遍历成对的key-value
print("遍历v对的key-value：")
for key, value in info.items():
    print(f"key={key}\tvalue={value}")
print("-"*20)


# 输出结果
遍历key的结果：
name	age	
--------------------
遍历values的结果：
Alice	18	
--------------------
遍历v对的key-value：
key=name	value=Alice
key=age	value=18
--------------------

关于遍历的补充

​ dict中可以打印成对的key-value值，那么可以联想到list中是否可以打印出一一对应的元素的下标和元素内容呢？

​ 答案是可以，利用enumerate方法即可

示例：

# 在list中遍历出一一对应的元素的下标和元素内容
mylist = ['a', 'b', 'c', 'd']
for i, item in enumerate(mylist):
    print(f"mylist[{i}] = {item}")
    

#输出结果
mylist[0] = a
mylist[1] = b
mylist[2] = c
mylist[3] = d

5、set 集合

5.1set的特点

1. set与dict类似，但不同的是set是key的集合不包含value，同时因为key不可重复，所以在set中没有重复的key。因此常用来进行去重的操作
2. set是无序的，重复元素在set中会被自动过滤
3. 因为set是同时具有无序性和无重复性的集合，所以多个set之间可以作数学上的&(交集)、|(并集)、-(差集)等运算

5.2定义

​ 集合名 = ({key1, key2, key3, ...})

示例：

s1 = ({1, 2, 3})
s2 = ({1, 2, 3, 4})
s3 = ({1, 2, 2, 3, 4})      # 只会打印一个2
print(s3)
s = s1 | s2
print("并集：", s)
s = s2 - s1
print("差集：", s)
s = s1 & s2
print("交集：", s)


# 输出结果
{1, 2, 3, 4}
并集： {1, 2, 3, 4}
差集： {4}
交集： {1, 2, 3}

6、python常用的四种数据结构总结

	定义语句	是否有序	是否可变类型
列表[ ]	列表名=[变量1，变量2.....]	有序	可变类型
元组( )	元组名 = (元素1, 元素2, 元素3, ...)	有序	不可变类型
字典{ }	字典名 = {"key1" : "value1", "key2" : "value2", "key3" : "value3", ...}	无序	key不可变, value可变
集合({ })	集合名 = ({key1, key2, key3, ...})	无序	可变类型(不重复)