Python：常用的数据类型

    a1 = 1             #整型
    #a2 = 51924361L    #长整型-仅支持于python2
    a3 = 1.2           #浮点型
    a3_1 = 2.5e2
    a4 = 3.14j         #复数
    print(a1, a3, a3_1, a4)

1.2 数字类型转换

1）int(x) 将x转换为一个整数。

2）float(x) 将x转换到一个浮点数。

3）complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

4）complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

    # 数字类型转换
    a5 = 1.0
    int(a5)
    a6 = int(a5)
    print(a5)
    print(a6)
    print(type(a5)) #'float'
    print(type(a6)) #'int'

1.3 数字运算

1）运算符：+，-， *， / ，//，**，=

2） / ：返回一个浮点数

3） // ：只想得到整数的结果，丢弃可能的分数部分。// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系

4）= ：用于给变量赋值

5）** ：幂运算

6）不同类型的数混合运算时会将整数转换为浮点数

    # 数字运算
    b1 = 1+2  #3
    b2 = 50-10 #40
    b3 = 2*4  #8
    b4 = 12/3 #4.0  返回一个浮点数
    b5 = 13/3 #4.333333333333333  整数除法返回浮点型
    b6 = 13//3  #4  整数除法返回向下取整后的结果
    b7 = 3*2+5  #11
    b8 = 3**2 #3的2次方
    
    print(b1, b2, b3, b4, b5, b6, b7, b8)

2. bool 布尔类型

布尔(bool)是整型的子类型。

在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。在Python3 中，把 True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字进行相加减乘除。

2.1bool()的使用

    print("====布尔值验证====")
    b1 = 0
    print(bool(b1))  # False
    b2 = 0.0
    print(bool(b2))  # False
    b3 = -0.0
    print(bool(b3))  # False
    b4 = {}
    print(bool(b4))  # False
    b5 = []
    print(bool(b5))  # False
    b6 = 1
    print(bool(b6))  # True
    b7 = -1
    print(bool(b7))  # True
    b8 = ''
    print(bool(b8))  # False
    b9 = ""
    print(bool(b9))  # False
    b10 = "False"
    print(bool(b10))  # True
    b11 = 'False'
    print(bool(b11))  # True
    b12 = None
    print(bool(b12))  # False
    b13 = False
    print(bool(b13))  # False
    b14 = True
    print(bool(b14))  # True
    b15 = bool(10 > 9)
    print(bool(b15))  # True

2.2布尔类型运算

1）and：与运算，只有所有表达式都为True，and运算的结果才是True

    c1 = True and False
    print(c1)  # False
    c2 = True and True
    print(c2)  # True
    c3 = False and False
    print(c3)  # False

2）or：或运算，只要其中一个表达式为True，or运算的结果就为True

    c4 = True or False
    print(c4)  # True
    c5 = True or True
    print(c5)  # True
    c6 = False or False
    print(c6)  # False

3）not：非运算，它是单目运算符（只对一个变量进行操作），把True变成False，把False变成True

    c7 = not True
    print(c7)  # False
    c8 = not False
    print(c8)  # True
    c9 = not 1 > 2
    print(c9)  # True

4）四则运算时，True的值为1，False的值为0

    # false 0  true 1
    
    b7 = -1
    b16 = 10 + bool(b7)
    print(bool(b16))  # True
    print(b16)  # 11

    b17 = True + 1  # 2
    print(b17)

    b18 = False + 1  # 1
    print(b18)

3.String（字符串）

3.1字符串创建

1）Python 中最常用的数据类型。使用引号( ' ' 或 " " )来创建字符串

    c1 = ''
    c2 = ""
    c3 = 'hello'
    c4 = "python3 String"

3.2 访问字符串中的值

1）访问子字符串，可以使用方括号 [ ] 来截取字符串，格式：变量[头下标:尾下标]

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

    c3 = 'hello'
    c4 = "python3 String"

    print("c3[0]:", c3[0])  # h
    print("c3[1:4]:", c3[1:4])  # ell
    print("c3[1:]:", c3[1:])  # ello
    print("c3[:4]:", c3[:4])  # hell
    print("c4[-1]:", c4[-1])  # g
    print("c4[-8:-1]:", c4[-8:-1])  # 3 Strin

3.3 字符串更新

    # 字符串更新
    c4 = "python3 String"
    c5 = c4[:8] + "Update"
    print(c5)  # python3 Update

4.List（列表）

List 可以修改可以删除，可以访问查询

4.1 列表创建

1）列表使用方括号 [ ]

    l1 = ['python', 'gongKongMall', 2022, 1999]
    l2 = [0, 1, 2, 3, 4, 5]
    l3 = ["a", "b", "c", "d"]
    l4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

4.2 访问列表中的值

1）列表索引从 0 开始，依次1，2，依此类推。通过索引列表可以进行截取、组合等操作。

2）索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，依此类推。

3）支持使用 [] 截取字符

    l1 = ['python', 'gongKongMall', 2022, 1999]
    print(l1[0])  # python
    print(l1[1])  # gongKongMall
    print(l1[3])  # 1999

    print(l1[-1])  # 1999
    print(l1[-2])  # 2022
    print(l1[-4])  # python

    # 截取字符 
    l5 = [10, 20, 30, 40, 50, 60, 70, 80, 90]
    print(l5[0:4])  #[10, 20, 30, 40]
    # 从第二位开始（包含）截取到倒数第二位（不包含）
    print("l4[1:-2]: ", l4[1:-2])  # ['green', 'blue', 'yellow']

4.3 更新/删除列表

    # 更新列表
    l1 = ['python', 'gongKongMall', 2022, 1999]
    l2 = [0, 1, 2, 3, 4, 5]
    l2[2] = 'update list'
    print(l2) # [0, 1, 'update list', 3, 4, 5]
    l1.append('test update')
    print(l1) # ['python', 'gongKongMall', 2022, 1999, 'test update']

    # 删除
    del l1[2]
    print(l1)

5.Tuple（元组）

Tuple 元素值不允许修改，不允许删除，可以访问查询

5.1 元组创建

1）元组使用小括号 ( )，逗号隔开；不需要括号也可以。

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

    t0 = ()
    t1 = ('python', 'gongKongMall', 2022, 1999)
    t2 = (0, 1, 2, 3, 4, 5)
    t3 = "a", "b", "c", "d"   #  不需要括号也可以
    t4 = ('red', 'green', 'blue', 'yellow', 'white', 'black')
    t5 = (50)
    t6 = (50,)
    print(type(t5))  # <class 'int'>
    print(type(t6))  # <class 'tuple'>

5.2 访问元组中的值

1）正向索引：索引从 0 开始，依次1，2，依此类推。可以进行截取、组合等操作。

2）反向索引：索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，依此类推。

3）截取使用 []

    t1 = ('python', 'gongKongMall', 2022, 1999)
    print(t1[0])   # python
    print(t1[1])  # gongKongMall
    print(t1[-1])  # 1999
    print(t1[-2])  # 2022
    print(t1[-4])  # python

    # 截取字符
    t7 = (10, 20, 30, 40, 50, 60, 70, 80, 90)
    print(t7[0:4])  # (10, 20, 30, 40)
    print("l4[1:-2]: ", t4[1:-2])  # ('green', 'blue', 'yellow')

5.3 元组运算

1）元组之间可以使用 + 号和 * 号进行运算。

    tup1 = len((1, 2, 3))
    print(tup1)  # 3

    tup2 = (1, 2, 3) + (4, 5, 6)
    print(tup2)  # (1, 2, 3, 4, 5, 6)

    tup3 = ('Hi!',) * 4
    print(tup3)  # ('Hi!', 'Hi!', 'Hi!', 'Hi!')

    3 in (1, 2, 3)
    for x in (1, 2, 3):
        print(x, end=" ")  # 1 2 3

6.Set（集合）

6.1 集合创建

1）集合（set）是一个无序的不重复元素序列。

2）使用大括号 { } 或者 set() 函数创建集合。

3）创建空集合用 set() ，不能用 { }。

    set()  # 空集合必须用set()，不能用{}
    s1 = {'python', 'gongKongMall', 2022, 1999}

6.2 集合操作

6.2.1 添加元素

1）s.add( x ) ：将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

2）s.update( x ) ：也可以添加元素，且参数可以是列表，元组，字典等。x 可以有多个，用逗号分开。

    s1.add('10086')
    print(s1)  # 无序 {'python', '10086', 2022, 'gongKongMall', 1999}
    s1.update('gks')
    print(s1)   # {2022, 1999, 'gongKongMall', 's', '10086', 'k', 'g', 'python'}
    s1.update({11, 33})
    print(s1)  # {'10086', 33, 'g', 2022, 'python', 11, 1999, 's', 'k', 'gongKongMall'}
    s1.update([1, 4], [5, 6])
    print(s1)   # {'s', 33, 1, 'gongKongMall', 'g', 2022, 4, 5, 6, 'python', 'k', 11, '10086', 1999}

6.2.2 移除元素

1）s.remove( x ) ：将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

2）s.discard( x )：如果元素不存在，不会发生错误。

3）s.pop()：随机删除集合中的一个元素。pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

    s1.remove(33)
    # s1.remove('33')  # '33'不存在 移除报错
    print(s1)   # {1, 's', 4, 5, 2022, 6, 11, 1999, '10086', 'g', 'k', 'python', 'gongKongMall'}
    s1.discard(11)
    s1.discard('33')  # '33'不存在 移除不报错
    print(s1)  # {'10086', 's', 1, 4, 2022, 5, 6, 1999, 'g', 'k', 'gongKongMall', 'python'}

    s2 = s1.pop()  # 随机删除, 选择无序排列的第一个元素 删除
    print(s2)

6.2.3 计算集合元素个数

1）len(s) ：计算集合元素个数

    s3 = len(s1)
    print(s3)  # 11

6.2.4 判断元素是否在集合中存在

1） x in s ：判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

    'python' in s1  # True
    '2021' in s1  # False

6.2.5 清空集合

1）s.clear() ：清空集合 s。

    s1.clear()
    print(s1)  # set()

6.3 集合运算

    a = set('abracadabra')
    b = set('alacazam')
    print(a)  # {'r', 'd', 'b', 'a', 'c'}

    s4 = a - b  # 集合a中包含而集合b中不包含的元素
    print(s4)  # {'r', 'd', 'b'}
    s5 = a | b  # 集合a或b中包含的所有元素
    print(s5)  # {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
    s6 = a & b  # 集合a和b中都包含了的元素
    print(s6)  # {'a', 'c'}
    s7 = a ^ b  # 不同时包含于a和b的元素
    print(s7)  # {'r', 'd', 'b', 'm', 'z', 'l'}

7.Dictionary（字典）

7.1 字典创建

1）d = {key1 : value1, key2 : value2, key3 : value3 }：字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在 {} 中。

2）键必须是唯一的，但值则不必。

3）值可以取任何数据类型，但键必须是不可变的，如字符串，数字，不可以用列表。

4）d ={ } ：空字典。

5）d = dict() ：使用函数dict()创建字典。

    d = {}  # 空字典
    print(type(d))  # <class 'dict'>
    print(len(d))  # 0

    d1 = dict()
    print(type(d1))  # <class 'dict'>
    print(len(d1))  # 0

    d2 = {"loginName": "0002",
            "password": "123456",
            "returnUrl": "",
            "operation": True,
            "validateCode": "688699",
            "deviceId": None}

    d3 = {"a": None,
          "b": False,
          "c": True,
          "e": ["1", 12],
          "f": ("1n", 90),
          "g": {"h": 1,
                "i": "112",
                "j": True}
          }

7.2 访问字典里的值

    print(d2["loginName"])  # 0002
    print(d2["operation"])  # True

    # print(d2["pwd"])  # 访问不存在的报错

7.3 修改字典

    d2["loginName"] = "0006"
    print(d2["loginName"])  # 0006
    d2["tel"] = "6886888"
    print(d2)

7.4 删除字典元素

    del d2["deviceId"]  # 删除键 "deviceId"
    d2.clear()  # 清空字典
    del d2  # 删除字典 
    # print(d2["deviceId"] ) # 删除后访问会引发异常

Dannywxd

关注

11
点赞
踩
28

收藏

觉得还不错? 一键收藏
0
评论
Python：常用的数据类型

Python常用的数据类型 Number 数据类型用于存储数值。1）整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。2）长整型(long integers) - 无限大小的整数，整数最后是一个大写或小写的L （注：只适用于python2，python3不区分，只有一种整数类型Int）3）浮点型(floating point real values) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示............
复制链接

扫一扫