07-Python数据类型

已于 2023-11-02 18:15:44 修改
阅读量57 收藏
点赞数 1
文章标签： python windows 开发语言
于 2023-11-02 18:09:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46678606/article/details/134188494
版权

07-Python数据类型

  1. 标准数据类型

    • Number(数字)
    • String（字符串）
    • bool（布尔类型）
    • List（列表）
    • Tuple（元组）
    • Set（集合）
    • Dictionary（字典）

    不可变标准数据类型有：Number（数字）、String（字符串）、Tuple（元组）；

    可变标准数据类型有：List（列表）、Dictionary（字典）、Set（集合）。

  2. type()函数和isinstance()函数

    1. 在详细了解Python的各种数据类型之前我们要先了解type()函数和isinstance()函数，这两个函数都是用于检查对象类型的两个常用函数。

      • type()函数返回对象的类型，它可以接受一个参数，并返回参数的类型。

        x = 5
y = "Hello"
print(type(x)) # <class 'int'>
print(type(y)) # <class 'str'>

        注意：str是String类型（字符串）

      • isinstance()函数用于检查一个对象是否属于指定的类型或类的实例。它接受两个参数，第一个参数是要检查的对象，第二个参数是要检查的类型或类。

        x = 5
y = "Hello"
print(isinstance(x, int))  # True
print(isinstance(y, int))  # False
print(isinstance(y, str))  # True
        • isinstance()函数还可以接受一个包含多个类型的元组作为第二个参数，用于检查对象是否属于元组中任意一个类型。
        x = 5
print(isinstance(x, (int, str)))  # True
print(isinstance(x, (list, dict)))  # False

      • isinstance 和 type 的区别

        • type()不会认为子类是一种父类类型。
        • isinstance()会认为子类是一种父类类型。
        # type() 和 isinstance() 的区别
class A:
    pass
class B(A):
  pass

print(isinstance(A(), A))  # True
print(type(A()) == A)  # True
print(isinstance(B(), A))  # True
print(type(B()) == A)  # False

"""
上述代码定义了两个类A和B。类B是类A的子类。然后通过isinstance()函数和type()函数对实例进行类型判断。

第一个isinstance(A(), A)，判断A类的实例是否属于A类，返回True。
第二个type(A()) == A，比较A类的实例的类型是否等于A类，返回True。
第三个isinstance(B(), A)，判断B类的实例是否属于A类，由于B类是A类的子类，所以也返回True。
第四个type(B()) == A，比较B类的实例的类型是否等于A类，由于B类是A类的子类，所以返回False。
这个示例演示了isinstance()函数和type()函数在判断对象类型方面的不同行为。
isinstance()函数可以检查对象是否是某个类的实例或其子类的实例，而type()函数则检查对象的确切类型是否与指定类型相同。
"""

    2. 总结：

      1. type()函数用于获取对象的类型。
      2. isinstance()函数用于检查对象是否属于指定的类型或类的实例。

  3. Number（数字）

    1. 这里学习Python3，在Python3中只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

      # Number
a, b, c, d = 10, 3.1415, True, 4+3j
print(type(a), type(b), type(c), type(d)) #

  4. String（字符串）

    1. Python中的字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 ** 转义特殊字符。

    2. 字符串的截取的语法格式如下：

      变量[头下标:尾下标]

    3. 索引值以 0 为开始值，-1 为从末尾的开始位置。

      在这里插入图片描述

    4. 加号 + 是字符串的连接符， 星号 ***** 表示复制当前字符串，与之结合的数字为复制的次数。实例如下：

      #  String
str = 'Python'

print(str)          # 输出字符串
print(str[0:-1])    # 输出第一个到倒数第二个的所有字符
print(str[0])       # 输出字符串第一个字符
print(str[2:5])     # 输出从第三个开始到第五个的字符
print(str[2:])      # 输出从第三个开始的后的所有字符
print(str * 2)      # 输出字符串两次，也可以写成 print(2 * str)
print(str + "TEST") # 连接字符串

      控制台输出

      Python
Pytho
P
tho
thon
PythonPython
PythonTEST

    5. Python 使用反斜杠 ** 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串

      print('Pytho\nTest')
print(r'Pytho\nTest')

      控制台输出

      Pytho
Test
Pytho\nTest

    6. 当需要在Python中跨越多行编写长字符串或长代码行时，可以使用反斜杠\作为续行符，表示下一行是上一行的延续。

      # 反斜杠\作为续行符
sentence = "This is a very long sentence that \
spans across multiple lines in the code."
print(sentence)

      控制台输出

      This is a very long sentence that spans across multiple lines in the code.

    7. 使用三引号跨越多行

      sentence = """This is a very long sentence that
spans across multiple lines in the code."""
print(sentence)

      控制台输出

      This is a very long sentence that
spans across multiple lines in the code.

    8. Python 没有单独的字符类型，一个字符就是长度为1的字符串。

      word = 'Python'
print(word[0], word[5])

print(word[-1], word[-6])

      控制台输出

      P n
n P

    注意：

    • 反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
    • 字符串可以用+运算符连接在一起，用*运算符重复。
    • Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
    • Python中的字符串不能改变。

  5. bool（布尔类型）

    1. 在 Python 中，True 和 False 都是关键字，表示布尔值。并且布尔类型即 True 或 False。
    2. 布尔类型特点：
      • 布尔类型只有两个值：True 和 False。
      • 布尔类型可以和其他数据类型进行比较，比如数字、字符串等。在比较时，Python 会将 True 视为 1，False 视为 0。
      • 布尔类型可以和逻辑运算符一起使用，包括 and、or 和 not。这些运算符可以用来组合多个布尔表达式，生成一个新的布尔值。
      • 布尔类型也可以被转换成其他数据类型，比如整数、浮点数和字符串。在转换时，True 会被转换成 1，False 会被转换成 0。
    a = True
b = False

# 比较运算符
print(2 < 3)   # True
print(2 == 3)  # False

# 逻辑运算符
print(a and b)  # False
print(a or b)   # True
print(not a)    # False

# 类型转换
print(int(a))   # 1
print(float(b)) # 0.0
print(str(a))   # "True"

    注意: 在 Python 中，所有非零的数字和非空的字符串、列表、元组等数据类型都被视为 True，只有 0、空字符串、空列表、空元组等被视为 False。因此，在进行布尔类型转换时，需要注意数据类型的真假性。

    逻辑运算符：

    • and：逻辑与运算符，当所有操作数都为True时，返回True；否则返回False。
    • or：逻辑或运算符，当至少有一个操作数为True时，返回True；否则返回False。
    • not：逻辑非运算符，用于对单个操作数取反，如果操作数为True，则返回False；如果操作数为False，则返回True。

    需要注意的是，逻辑运算符遵循短路规则。在使用and运算符时，如果第一个操作数为False，则不会计算第二个操作数，因为整个表达式已经为False。同样地，在使用or运算符时，如果第一个操作数为True，则不会计算第二个操作数，因为整个表达式已经为True。

    逻辑运算符的优先级低于比较运算符和算术运算符，但高于赋值运算符。如果需要明确指定运算的顺序，可以使用括号。

  6. List（列表）

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

    2. 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

    3. 和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

    4. 列表截取的语法格式如下：

      变量[头下标:尾下标]

      索引值以 0 为开始值，-1 为从末尾的开始位置。

      在这里插入图片描述

      加号 + 是列表连接运算符，星号 ***** 是重复操作。如下实例：

      # list
testList = ['abcd', 678, 3.14, 'Python', 99]
tinyList = [123, 'Python']

print(testList)             # 输出完整列表
print(testList[0])          # 输出列表第一个元素
print(testList[1:3])        # 从第二个开始输出到第三个元素
print(testList[2:])         # 输出从第三个元素开始的所有元素
print(tinyList * 2)         # 输出两次列表
print(testList + tinyList)  # 连接列表

      控制台输出：

      ['abcd', 678, 3.14, 'Python', 99]
abcd
[678, 3.14]
[3.14, 'Python', 99]
[123, 'Python', 123, 'Python']
['abcd', 678, 3.14, 'Python', 99, 123, 'Python']

    5. list与String是有区别的，list中的元素是可以改变的：

      a = [1, 2, 3, 4, 5, 6]
a[0] = 7
a[2:5] = [5, 4, 3]
print(a)

      控制台输出：

    6. 注意：

      • 1、List写在方括号之间，元素用逗号隔开。
      • 2、和字符串一样，list可以被索引和切片。
      • 3、List可以使用+操作符进行拼接。
      • 4、List中的元素是可以改变的。

    7. Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：

      在这里插入图片描述

  7. Tuple（元组）

    1. 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

    2. 元组中的元素类型也可以不相同：

      # 元祖
testTuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinyTuple = (123, 'runoob')

print(testTuple)             # 输出完整元组
print(testTuple[0])          # 输出元组的第一个元素
print(testTuple[1:3])        # 输出从第二个元素开始到第三个元素
print(testTuple[2:])         # 输出从第三个元素开始的所有元素
print(tinyTuple * 2)     # 输出两次元组
print(testTuple + tinyTuple)   # 连接元组

      控制台输出：

      ('abcd', 786, 2.23, 'Python', 70.2)
abcd
(786, 2.23)
(2.23, 'Python', 70.2)
(123, 'Python', 123, 'Python')
('abcd', 786, 2.23, 'Python', 70.2, 123, 'Python')

    3. 元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。

    4. 其实，可以把字符串看作一种特殊的元组。

      tup = (1, 2, 3, 4, 5, 6)
print(tup[0])  # 1

print(tup[1:5])  # (2, 3, 4, 5)

tup[0] = 7  # 修改元组元素的操作是非法的
"""
Traceback (most recent call last):
  File "D:\Python_code\python_study\02-Python入门语法\数据类型.py", line 114, in <module>
    tup[0] = 7
TypeError: 'tuple' object does not support item assignment
"""

    5. 虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

    6. 构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

      tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号

      string、list 和 tuple 都属于 sequence（序列）。

    7. 注意：

      • 与字符串一样，元组的元素不能修改。
      • 元组也可以被索引和切片，方法一样。
      • 注意构造包含 0 或 1 个元素的元组的特殊语法规则。
      • 元组也可以使用+操作符进行拼接。

  8. Set（集合）

    1. Python 中的集合（Set）是一种无序、可变的数据类型，用于存储唯一的元素。

    2. 集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

    3. 在 Python 中，集合使用大括号 {} 表示，元素之间用逗号 , 分隔。

    4. 另外，也可以使用 set() 函数创建集合。

    5. **注意：**创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

    6. 创建格式：

      parame = {value01,value02,...}
或者
set(value)

      案例：

      # Set（集合）

sites = {'Google', 'Taobao', 'Facebook', 'Zhihu', 'Baidu'}

print(sites)  # 输出集合，重复的元素被自动去掉

# 成员测试
if 'Facebook' in sites:
        print('Facebook 在集合中')
else:
    print('Facebook 不在集合中')

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)

print(a - b)   # a 和 b 的差集

print(a | b)   # a 和 b 的并集

print(a & b)   # a 和 b 的交集

print(a ^ b)    # a 和 b 中不同时存在的元素

      控制台输出：

      {'Baidu', 'Zhihu', 'Taobao', 'Google', 'Facebook'}
Facebook 在集合中
{'d', 'c', 'a', 'r', 'b'}
{'d', 'r', 'b'}
{'d', 'c', 'a', 'z', 'l', 'r', 'm', 'b'}
{'a', 'c'}
{'d', 'z', 'l', 'r', 'm', 'b'}

  9. Dictionary（字典）

    • 字典（dictionary）是Python中另一个非常有用的内置数据类型。
    • 列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
    • 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
    • 键(key)必须使用不可变类型。
    • 在同一个字典中，键(key)必须是唯一的。

    案例一：创建和访问字典

    # 创建和访问字典
# 创建一个字典
person = {"name": "Alice", "age": 25, "city": "New York"}
# 访问字典中的值
print(person["name"])  # Alice
print(person["age"])  # 25
print(person["city"])  # New York

    控制台输出：

    Alice
25
New York

    案例二：添加和修改字典中的键值对

    person = {"name": "Alice", "age": 25, "city": "New York"}
# 添加新的键值对
person["occupation"] = "Engineer"
# 修改键值对
person["age"] = 26
print(person)

    控制台输出:

    {'name': 'Alice', 'age': 26, 'city': 'New York', 'occupation': 'Engineer'}

    案例三：遍历字典的键值对

    {'name': 'Alice', 'age': 26, 'city': 'New York', 'occupation': 'Engineer'}
for key, value in person.items():
    print(key, ":", value)

    控制台输出:

    name : Alice
age : 26
city : New York
occupation : Engineer

    案例四：删除字典中的键值对

    {'name': 'Alice', 'age': 26, 'city': 'New York', 'occupation': 'Engineer'}
# 删除键值对
del person["occupation"]
print(person)

    控制台输出:

    {'name': 'Alice', 'age': 26, 'city': 'New York'}

    案例五：字典中是否存在某个键

    person = {"name": "Alice", "age": 25, "city": "New York"}
# 检查键是否存在
if "name" in person:
  print("Name exists in the dictionary.")
else:
  print("Name does not exist in the dictionary.")

    控制台输出:

    Name exists in the dictionary.

注意：

  • 字典是一种映射类型，它的元素是键值对。
  • 字典的关键字必须为不可变类型，且不能重复。
  • 创建空字典使用 { }。
怀念雨后的院子_Q
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值