Python 学习笔记 day05--数据类型

原创已于 2025-07-24 11:15:28 修改 · 721 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#学习 #笔记

于 2025-07-23 22:57:12 首次发布

1.数据类型-元组

元组使用小括号 ( )包裹，定义好后，元素不可修改。元组创建只需要在括号中添加元素，并使用逗号隔开即可。元组是有序且不可更改的集合。

q1 = (1, 34, "word", "excel", "ppt")
print(q1)

#----(1, 34, 'word', 'excel', 'ppt')

元组中只包含一个元素时，需要在元素后面添加逗号 " , "，否则括号会被当作运算符使用：

q1 = (50)
print(type(q1))   # 不加逗号，类型为整型

#----<class 'int'>

q2 = (50,)
print(type(q2))     # 加上逗号，类型为元组
#----<class 'tuple'>

1.1 元组元素访问

1.1.1 下标访问

下标就是编号，（即数据的编号位置）
从左向右访问，从0开始；
从右向左访问，从-1开始。

元表下标访问格式：变量名[下标]

q1 = (1, 34, "word", "excel", "ppt")
print(q1)

print(q1[-1])

#----ppt

1.1.2 切片访问

切片访问和下标访问类似
下标访问每次只能访问单个元素,切片访问每次可以访问多个元素

切片访问格式：变量名[起始值：终止值：步长]

访问时:
1.如果没有设置起始值，默认起始值为开头位置；
2.如果没有设置终止值，默认到列表结束，如果设置了终止值，到终止位置结束，不包括结尾位置；
3.如果没有设置步长，步长默认为1

q1 = (1, 34, "word", "excel", "ppt")

print(q1[::])
print(q1[1::])
print(q1[:3:])
print(q1[::2])

#----(1, 34, 'word', 'excel', 'ppt')
#----(34, 'word', 'excel', 'ppt')
#----(1, 34, 'word')
#----(1, 'word', 'ppt')

1.2 元组的加法和乘法

+ :表示字符串拼接， * n :代表字符串复制n次

q2 = ("PS", "CAD")
q3 = ("a", "ppt", "d", "f", "asdf")
print(q2 + q3)
print(q2 * 2)
print(q3 * 2)

#----('PS', 'CAD', 'a', 'ppt', 'd', 'f', 'asdf')
#----('PS', 'CAD', 'PS', 'CAD')
#----('a', 'ppt', 'd', 'f', 'asdf', 'a', 'ppt', 'd', 'f', 'asdf')

1.3 元组相关函数

len	获取元组的元素个数
max	求最大值
min	求最小值
in关键字	判断某元素是否存在
not in
del	删除元组

字符串、列表、元组的共同点：都可以使用下标访问、切片访问

q4 = (1, 2, 3, 19, 23, 80)
print(len(q4))
print(max(q4))

#----6
#----80

2 序列函数

len( ):计算长度或元素个数

q4 = (1, 2, 3, 19, 23, 80)
print(len(q4))

#----6

max( ) 和 min( ) :求序列中最大值、最小值(元素数据类型相同)

q4 = (1, 2, 3, 19, 23, 80)
q5 = "abcde"
q6 = [[33, -1, 55], [33,0]]
q7 = ["qq", "ww", "e"]

print(max(q4))
print(max(q5))
print(max(q6))
print(max(q7))

#----80
#----e
#----[33, 0]
#----ww

# 自定义判断依据
print(min(q6, key=len))
print(min(q7, key=len))

#----[33, 0]
#----e

sum( ):求序列元素和，start设置起始值

w1 = (1, 2.56, 22, 88)
print(sum(w1))
print(sum(w1, start=20))

#----113.56
#----133.56

sorted( ):排序，返回新列表，原序列不变

q4 = (1, 2, 3, 19, 23, 80)
q5 = "bcdfrat"
q6 = [[33, -1, 55], [33, 0]]
q7 = ["qq", "ww", "e"]

print(sorted(q4))
print(sorted(q5))
print(sorted(q6))
print(sorted(q7))

#----[1, 2, 3, 19, 23, 80]
#----['a', 'b', 'c', 'd', 'f', 'r', 't']
#----[[33, -1, 55], [33, 0]]
#----['e', 'qq', 'ww']

reversed( ):反转，返回迭代器，需要强转或for循环遍历

q5 = (1, 2, 3, 19, 23, 80)
print(list(reversed(q5)))  # 强制转换为列表list
# ----[80, 23, 19, 3, 2, 1]

q6 = ("hty", "qer", "dbj")
print(reversed(q6))  
# <reversed object at 0x0000019DEBB45910>
print(list(reversed(q6)))
# ----['dbj', 'qer', 'hty']

all( ) :判断序列元素是否都为真

any( )：判断序列某个元素是否为真

q6 = (1, 2.56, 222, 88)
q7 = (0, 1, 2.56, 222, 88)
q8 = ()

print(all(q6))
print(any(q6))
print(all(q7))
print(any(q7))
print(q8)

#----True
#----True
#----False
#----True
#----False #any 空

#---0为假
#---1为真

zip( ): 把多个可迭代对象对应位置的元素打包成元组，返回由元组组成的新对象，需要强转或for循环遍历。当序列元素个数不同时，以最少的为准

q6 = (1, 2.56, 222, 88)
q7 = (0, 1, 2.56, 222, 88)
q8 = ("word", "excel", "ppt")
q9 = zip(q6, q7, q8)
print(list(q9))

#----[(1, 0, 'word'), (2.56, 1, 'excel'), (222, 2.56, 'ppt')]

map( ): 对可迭代对象中的每一个元素应用一个指定的函数，返回迭代器，需要强转或for循环遍历

w1 = ("12", "34", "56")
w2 = map(int, w1)
print(list(w2))

#----[12, 34, 56]  元组转列表

w3 = ["hty", "q3243", "dbj"]
w4 = map(str, w3)
print(tuple(w4))

#----('hty', 'q3243', 'dbj')  列表转元组

filter( ):对可迭代对象中的每一个元素应用一个判断函数，把结果为True的元素以迭代器的形式返回，需要强转或for循环遍历。

w3 = ["hty", "qwer", "dbj", "123"]
w4 = filter(str.isalnum, w3)
print(tuple(w4))

#----('hty', 'qwer', 'dbj', '123')

w3 = ["hty", "qwer", "dbj", "123", "+"]
w4 = filter(str.isalnum, w3) #filter返回判断为True的数据
# isalnum 判断字母或数字
print(tuple(w4))

#----('hty', 'qwer', 'dbj', '123')

enumerate( ) :把可迭代对象中的下标和元素以元组的形式组合，返回迭代器，需要强转或for循环遍历。

w3 = ["hty", "qwer", "dbj", "123"]
w4 = enumerate(w3)
print(tuple(w4))

#----((0, 'hty'), (1, 'qwer'), (2, 'dbj'), (3, '123'))

3.数据类型-集合

集合（Set）是无序且不重复元素序列的集合。在 Python 中，集合用花括号 {} 编写。
集合分为可变集合和不可变集合；
可变集合的元素定义好后不可修改，但集合本身可以增加或删除，集合元素只能是数字、字符串、元组。

a1 = {2, 1, 2, 2.3, "qq", 2, "ww", 2, "aas"}
print(a1)
print(type(a1))

使用集合实现去重：

a1 = [2, 1, 2, 2.3, "qq", 2, "ww", 2, "aas"]
print(set(a1))  #列表转换为set类型，集合set自动去重，以达到去重效果

3.1 可变集合的元素增加

add( ):一次添加一个元素，可以是数字、字符串、元组
update(): 一次添加多个元素

a1 = {2, 1, 2, 2.3, "qq", 2, "ww", 2, "aas"}
a1.add(("CAD", "PPT"))
print(a1)

a1.update("excel", [2.3, 77])
print(a1)

#----{1, 2, 2.3, ('CAD', 'PPT'), 'qq', 'aas', 'ww'}
#----{1, 2, 2.3, ('CAD', 'PPT'), 'e', 'qq', 'x', 'c', 77, 'aas', 'l', 'ww'}

3.2 可变集合的元素删除

remove():删除指定元素，如果不存在，会报错

discard():删除指定元素，如果不存在，不报错

pop():删除第一个元素，如果集合为空，会报错

#remove()
a2 = {1, 2, 2.3, ('CAD', 'PPT'), 'qq', 'aas', 'ww'}
a2.remove(2.3)

print(a2)
#----{1, 2, ('CAD', 'PPT'), 'qq', 'aas', 'ww'}

#discard()
a2 = {1, 2, 2.3, ('CAD', 'PPT'), 'qq', 'aas', 'ww'}
a2.discard(2.3)

print(a2)
#----{1, 2, ('CAD', 'PPT'), 'qq', 'aas', 'ww'}

#pop()  括号里不可添加下标或指定元素。否则报错
a2 = {1, 2, 2.3, ('CAD', 'PPT'), 'qq', 'aas', 'ww'}
a2.pop()

print(a2)
#----{2, 2.3, ('CAD', 'PPT'), 'qq', 'aas', 'ww'}

3.3 可变集合的元素查找

in : 判断某元素是否存在

not in ：

a2 = {1, 2, 2.3, ('CAD', 'PPT'), 'qq', 'aas', 'ww'}
print("hi" in a2)

#----False

3.4 可变集合的其他函数

len():计算集合元素个数

set() 生成一个集合

set(iterable)
# iterable：可选参数，可以是任何可迭代对象（如列表、元组、字符串等），如果不提供参数，则创建空集合

a1 = set()
print(a1)  # 输出: set()
print(type(a1))  # 输出: <class 'set'>

a2 = [1, 2, 2, 3, 3, 3]
my_set = set(a2)
print(my_set)  # 输出: {1, 2, 3} (自动去重)

a3 = (4, 5, 5, 6, 6, 6)
my_set = set(a3)
print(my_set)  # 输出: {4, 5, 6}

copy() 浅拷贝

clear() 清空元素

e1 = {2.55, 34, 245, "word", "ppt", "excel"}
e2 = {2.55, "ppt"}

# 求e1和e2的交集
print(e1.intersection(e2))
#----{'ppt', 2.55}

# 求e1和e2的并集
print(e1.union(e2))

#----{'ppt', 2.55, 34, 'word', 245, 'excel'}

# e2是e1的子集
print(e2.issubset(e1))

#----True

# e1中包含e2
print(e1.issuperset(e2))

#----True

3.5 不可变集合

元素不可变，元素的个数也不可变

a1 = frozenset("word")
print(a1)
print(type(a1))
a2 = frozenset([1, 2, 3, 4])
print(a2)

#----frozenset({'l', 'o', 'h', 'e'})
#----<class 'frozenset'>
#----frozenset({1, 2, 3, 4})

4.数据类型-字典

字典是一个无序可变的集合。字典用花括号 { } 编写，拥有键和值。字典的每个键值用冒号 : 分割，每个对之间用逗号(,)分割，键的值可以修改。

s1 = {"name": "zs", "age": 18, "height": "180"}
print(s1)
print(type(s1))

#----{'name': 'zs', 'age': 18, 'height': '180'}
#----<class 'dict'>

# iterable 对应字典的键
# value 对应值，默认值为none
d2 = dict.fromkeys([1, "name", 3], (11, 22, 33))
print(d2)
print(type(d2))

#----{1: (11, 22, 33), 'name': (11, 22, 33), 3: (11, 22, 33)}
#----<class 'dict'>

4.1 键值对的特性

键是唯一的，键和值一一对应

键不可变，可以是数字、字符串、元组；值可以是任意类型

4.2 字典的访问：

字典名[键名]

如果字典中没有这个键，会报错

s1 = {"name": "zs", "age": 18, "height": "180"}

print(s1["name"])

#----zs

4.3 键值对的添加

字典名[键名] = 值

s1 = {"name": "zs", "age": 18, "height": "180"}
s1["hobby"] = "IT"
print(s1)

#----{'name': 'zs', 'age': 18, 'height': '180', 'hobby': 'IT'}

update() 字典的合并

s1 = {"name": "zs", "age": 18, "height": "180"}
s2 = {"name1": "ls", "class": 72}
s2.update(s1)
print(s2)

#----{'name1': 'ls', 'class': 72, 'name': 'zs', 'age': 18, 'height': '180'}

4.4 键值对的删除

pop()
clear()
del
popitem()

# pop()
s1 = {"name": "zs", "age": 18, "height": "180","name1": "ls", "class": 72}
s1.pop("name1")
print(s1)

#----{'name': 'zs', 'age': 18, 'height': '180', 'class': 72}

#clear()
s1 = {"name": "zs", "age": 18, "height": "180","name1": "ls", "class": 72}
s1.clear()
print(s1)

#----{}

#del
s1 = {"name": "zs", "age": 18, "height": "180","name1": "ls", "class": 72}
del s1
print(s1)

#----NameError: name 's1' is not defined


# 随机删除一组键值对，python3.7后变成删除最后一组
#popitem()
s1 = {"name": "zs", "age": 18, "height": "180","name1": "ls", "class": 72}
s1.popitem()
print(s1)

#----{'name': 'zs', 'age': 18, 'height': '180', 'name1': 'ls'}

4.5 键值对的修改

修改单个：字典名[键名] = 新值

修改多个：update()

s1 = {"name": "zs", "age": 18, "height": "180", "name1": "ls", "class": 72}
s1["age"] = 30
print(s1)

#----{'name': 'zs', 'age': 30, 'height': '180', 'name1': 'ls', 'class': 72}

s1 = {"name": "zs", "age": 18, "height": "180", "name1": "ls", "class": 72}
s1.update({"age": 35, "height": "175"})
print(s1)

#----{'name': 'zs', 'age': 35, 'height': '175', 'name1': 'ls', 'class': 72}

4.6 键值对的查询

1.直接通过键名
2.in或not in关键字
3.get()函数：如果键名不存在可以指定提示语
4.setdefault() 查询键值对，如果不存在，会创建该键值对，默认值为none

s1 = {"name": "zs", "age": 18, "height": "180", "class": 72}
print(s1["name"])
print(s1.get("name11", "不存在"))
# 参数1：要查询的键名
# 参数2：当键名不存在时，创建新的键值对的值
print(s1.setdefault("name"))
print(s1.setdefault("name123", 12345))
print(s1)

#----zs
#----不存在
#----zs
#----12345
#----{'name': 'zs', 'age': 18, 'height': '180', 'class': 72, 'name123': 12345}

4.7 其他函数

len() 获取元素个数
copy() 浅拷贝
keys() 获取所有的key值
values() 获取所有的value
items() 获取所有键值对

# keys() 获取所有的key值
s1 = {"name": "zs", "age": 18, "height": "180", "class": 72}
print(s1.keys())

#----dict_keys(['name', 'age', 'height', 'class'])

# values() 获取所有的value
s1 = {"name": "zs", "age": 18, "height": "180", "class": 72}
s2 = s1.values()
print(s2)

#----dict_values(['zs', 18, '180', 72])

# items() 获取所有键值对
s1 = {"name": "zs", "age": 18, "height": "180", "class": 72}
s2 = s1.items()
print(s2)

#----dict_items([('name', 'zs'), ('age', 18), ('height', '180'), ('class', 72)])