4.数据类型

python中存在常用的九大数据类型，每种类型都有自己的特点和使用场景，需要根据场景灵活选择，我们需要学习数据类型的常用方法和特性

1.int:整数类型

整形包括正数，负数和0,是十进制数字的统称

1.1定义

num = -100
age = 20

 

1.2特性和方法

  • 加减乘除
    a = 100
b = 10
print(a + b)  # 110
print(a - b)  # 90
print(a * b)  # 1000
print(a / b)  # 10.0

    注意:在python3之后，除法得到的浮点数，在python2中得到的确实整数

  • 进制的转化
    num = 88

# 其他进制转化为十进制
print(int('0b1011000', base=2))  # 88
print(int('0o130', base=8))  # 88
print(int('0x58', base=16))  # 88

2.float:浮点类型

2.1定义

var = 3.1415
print(var)  # 3.1415

2.2特性和方法

  • 加减乘除,得到的还是浮点数
    var = 3.1415926
print(var + var)  # 6.2831852
print(var - var)  # 0.0
print(var * var)  # 9.86960406437476
print(var / var)  # 1.0
  • round:保留小数点数
    var= 3.1415926
print(round(var, 4))  # 3.1416

3.str:字符串类型

字符串是常量，一旦没定义，则无法别修改，某些对字符串的操作，看似修改了，但实际上是创建了一个新的字符串

字符串是一个可迭代对象，可以索引取值。切片，遍历

3.1 定义

使用英文的单引号或者双引号，甚至三引号

name = 'kunmzhao'
gender = "man"
address = """上海市"""

3.2 特性和方法

  1. 字符串相加
    print('hello' + 'world')  # helloworld
  2. 字符串乘一个正整数
    print('hello' * 2)  # hellohello
  3. 包含运算
    val = 'kunmzhao'
print('kun' in val)  # True
  4. len():字符串的长度
    print(len('hello world'))  # 11
  5. 索引取值
    val = 'hello'
print(val[0])  # h
print(val[-1])  # o
  6. 切片
    [start:end:step]
-start:起始位置,默认值为0
-end:结束为止，不包含,默认值为总长度+1
-step:步长，当 end< start，为负数
    通过切片可以很方便的实现字符串的逆置
    val = 'hello'
print(val[0:2])  # he
print(val[-1:-3:-1])  # ol
    print(val[::-1])  # olleh
  7. 可迭代
    说白了就是可以通过for循环遍历字符串的每一个字符
    val = 'hello'
for ch in val:
    print(ch, end=' ')
  8. startwith:判断字符串是否以xx开头
    val = 'hello'
print(val.startswith('hel'))  # True
  9. endwith:判断字符串是否以xx结尾
    val = 'hello'
print(val.endswith('hel'))  # Fals
  10. isdecimal:判断字符串能否转化为一个整数
    val = 'hello'
num = '100'
print(val.isdecimal())  # False
print(num.isdecimal())  # True
  11. strip/lstrip/rstrip:去除字符串两边/左边/右边指定的字符，默认为空格
    val = ' hello '
print(val.strip())  # 'hello'
print(val.lstrip())  # 'hello '
print(val.rstrip())  # ' hello'
  12. upper/lower:将字符创变成大写/小写
    val = 'hello'
print(val.upper())  # HELLO
print(val.lower())  # hello
  13. replace:替代字符串中指定的字符,可以指定替换的数量
    val = 'hello'
print(val.replace('l', '-'))  # he--o
print(val.replace('l', '-', 1))  # he-lo
  14. split:将字符串按照指定字符和切割数量进行切割，得到一个列表
    val = 'today is a good day'
print(val.split())  # ['today', 'is', 'a', 'good', 'day']
print(val.split('o', 1))  # ['t', 'day is a good day']
  15. join:将字符串列表按照指定字符拼接成一个字符串
    注意，join是将可迭代对象进行拼接，同时元素必须是字符串类型
    val = ['today', 'is', 'a', 'good', 'day']
print('-'.join(val))  # today-is-a-good-day
  16. format:字符串格式化
    name = 'kunmzhao'
age = 20
print('我是:{},年龄:{}'.format(name, age))  # 我是:kunmzhao,年龄:20
  17. encode/decode:实现字符串和字节类型按照指定编码转化
    在通过网络传输的时候，通常将信息转化为字节类型的
    name = 'kunmzhao'
print(name.encode('utf-8'))  # b'kunmzhao'
print(b'kunmzhao'.decode('utf-8'))  # kunmzhao
  18. zfill:自动填充0
    name = 'kunmzhao'
print(name.zfill(10))  # 00kunmzhao

4.bool:布尔类型

布尔类型就2个值，True和False，底层就是数字0和1

4.1定义

flag = True
flag = False

4.2方法和特性

常用于逻辑判断，无特殊方法

5.list:列表类型

列表是一个有序且可变的容器，可以存放不同类型的元素

对列表的大部分操作，都是对自身的操作，不会新生成一个新的列表，也就不存在返回值

5.1定义

li = [1, 1.2, 'a', 'kunmzhao', [1, 2, 3]]
li2 = []  # 创建空列表

5.2特性和方法

  1. 相加:返回一个新的列表
    v1 = [1, 2, 3]
v2 = [4, 5, 6]
print(v1 + v2)  # [1, 2, 3, 4, 5, 6]
  2. 乘以一个正整数:返回一个新的列表
    v1 = [1, 2, 3]
print(v1 * 2)  # [1, 2, 3, 1, 2, 3]
  3. 包含运算
    v1 = [1, 2, 3]
print(1 in v1)  # True
print(4 in v1)  # False
  4. len:获取长度
    v1 = [1, 2, 3]
print(len(v1))  # 3
  5. 索引取值
    v1 = [1, 2, 3]
print(v1[0])  # 1
print(v1[-1])  # 3
  6. 切片
    v1 = [1, 2, 3]
print(v1[1:3])  # [2, 3]
print(v1[::-1])  # [3, 2, 1]
  7. 遍历
    v1 = [1, 2, 3]
for ele in v1:
    print(ele, end=' ')  # 1 2 3
  8. append:追加一个元素
    v1 = [1, 2, 3]
v1.append(4)
print(v1)  # [1, 2, 3, 4]
  9. extend:追加一个列表
    v1 = [1, 2, 3]
v2 = [4, 5, 6]
v1.extend(v2)
print(v1)  # [1, 2, 3, 4, 5, 6]
  10. insert:在指定下表插入一个元素
    v1 = [1, 2, 3]
v1.insert(0, 100)
print(v1)  # [100, 1, 2, 3]
  11. remove:删除指定的元素
    注意：若元素不存在，则报错，若存在多个，只删除第一个
    v1 = [1, 2, 3, 1]
    if 1 in v1:
        v1.remove(1)
    print(v1)  # [2, 3, 1]
  12. pop():根据索引删除元素，默认删除最后一个,并返回删除的元素
    v1 = [1, 2, 3, 1]
val = v1.pop()
print(val, v1)  # 1 [1, 2, 3]
  13. clear:清空列表
    v1 = [1, 2, 3, 1]
v1.clear()
print(v1)  # []
  14. index:根据元素获取对应的下表
    注意:若元素不存，则报错
    v1 = [1, 2, 3, 1]
num = v1.index(1)
print(num)  # 0
  15. sort:排序
    根据参数reverse决定正序还是倒序
    v1 = [1, 2, 3, 1, 4, 7, 2, 1]
v1.sort(reverse=True)
print(v1)  # [7, 4, 3, 2, 2, 1, 1, 1]
  16. reverse:反转列表
    v1 = [1, 2, 3, 1, 4, 7, 2, 1]
v1.reverse()
print(v1)  # [1, 2, 7, 4, 1, 3, 2, 1]

6.tuple:元组类型

元组是一个有序但是不可变的容器，可以存放不同类型的元素

6.1定义

v1 = (1, 1.2, 'a', 'abc', [1, 2, 3])
v2 = (1,) # 只有一个元素的元组，必须后面加上逗号
v3 = ()  # 空元组

6.2特性和方法

  1. 相加
    v1 = (1, 2, 3)
v2 = (4, 5, 6)
v3 = v1+v2
print(v3)  # (1, 2, 3, 4, 5, 6)
  2. 乘以一个正整数
    v1 = (1, 2, 3)
print(v1 * 3)  # (1, 2, 3, 1, 2, 3, 1, 2, 3)
  3. 包含运算符
    v1 = (1, 2, 3)
print(2 in v1)  # True
print(88 in v1)  # False
  4. len:获取长度
    v1 = (1, 2, 3)
print(len(v1))  # 3
  5. 索引取值
    v1 = (1, 2, 3)
print(v1[-1])  # 3
print(v1[1])  # 2
  6. 切片
    v1 = (1, 2, 3)
print(v1[::-1])  # (3, 2, 1)
print(v1[:2])  # (1, 2)
  7. 遍历
    v1 = (1, 2, 3)
for ele in v1:
    print(ele, end=' ')  # 1 2 3

　　　

思考：元组是不可变的数据类型，那就是在声明之后就无法再改变内部元素的数量和值，但是如果元组中包含的是列表，请问列表能否修改内部元素呢？

v1 = (1, 2, 3, [1, 2, 3])
# v1[0] = 100  # 这是不被允许的
v1[-1].append(10)  # 这是被允许的
print(v1)  # (1, 2, 3, [1, 2, 3, 10])

答案是允许的，元组内的元素不让修改指的是元素的个数不能发生修改，同时每个元素的内存地址不能发生修改，而对于元组内的列表，修改内部数据，并没有修改列表整体的内存地址，所以是被允许的

7.dict:字典类型

字典是由键值对组成的，键必须是是可哈希的(int/float/bool/tuple), 值可以是任意类型，字典中对值的操作都是基于键的

字典是根据哈希算法进行查找，所以查找速度是很快的，在开发中涉及到查找，尽可能的构建成字典

7.1 定义

v1 = {
    'name': 'kunmzhao',
    'age': 18
}
v2 = {}  # 空字典

 

7.2 特性和方法

  1. len:获取长度
    v1 = {
    'name': 'kunmzhao',
    'age': 18
}
print(len(v1))  # 2
  2. 包含运算符:根据键判断，而不是值
    v1 = {
    'name': 'kunmzhao',
    'age': 18
}
print('name' in v1)  # True
print('kunmzhao' in v1)  # False
  3. 按键取值
    v1 = {
    'name': 'kunmzhao',
    'age': 18
}
# 方式一：使用索引方式取值，如果对应的键不存在，则报错
print(v1['name'])  # kunmzhao
# 方式二：get取值，键不存在则返回None或者默认值
print(v1.get('name'))  # kunmzhao
print(v1.get('123', 123))  # 123
  4. 迭代
    v1 = {
    'name': 'kunmzhao',
    'age': 18
}

# 遍历键和值
for key,value in v1.items():
    print(f'{key}:{value}', end=' ')  # name:kunmzhao age:18

# 只遍历键
for key in v1.keys():
    print(key, end=' ')  # name age

# 只遍历值
for value in v1.values():
    print(value, end=' ')  # kunmzhao 18
  5. setdefault:添加键值对
    如果字典中存在该键，则返回对应的值，否则添加键值对，并返回值
    v1 = {
        'name': 'kunmzhao',
        'age': 18
    }

    value = v1.setdefault('name', 'victor')
    print(value, v1)  # kunmzhao {'name': 'kunmzhao', 'age': 18}

    value2 = v1.setdefault('gender', 'man')
    print(value2, v1)  # man {'name': 'kunmzhao', 'age': 18, 'gender': 'man'}
  6. update:添加键值对
    如果字典中存在该键，就更新对应的值，否则，添加键值对
    v1 = {
    'name': 'kunmzhao',
    'age': 18
}

v1.update({'name': 'victor'})
v1.update({'gender': 'man'})
print(v1)  # {'name': 'victor', 'age': 18, 'gender': 'man'}
  7. pop:删除键值对
    注意：删除的键如果不存在就会报错
    v1 = {
    'name': 'kunmzhao',
    'age': 18
}

value = v1.pop('name')
print(value, v1)  # kunmzhao {'age': 18}

8.set:集合类型

集合是一个可变无序的容器，但是元素是唯一的，集合中的所有元素必须是可哈希的

8.1 定义

v1 = {1, 2, 3, 4}
v2 = set()  # 空集合

8.2 特性和方法

  1. -:计算差集
  2. &：计算并集
  3. |:计算并集
    v1 = {1, 2, 3, 4}
v2 = {3, 4, 5, 6}

print(v1 - v2)  # {1, 2}
print(v1 & v2)  # {3, 4}
print(v1 | v2) # {1, 2, 3, 4, 5, 6}
  4. 包含运算
    v1 = {1, 2, 3, 4}
print(1 in v1)  # True
  5. len:计算长度
    v1 = {1, 2, 3, 4}

print(len(v1))  # 4
  6. 迭代
    v1 = {1, 2, 3, 4}

for ele in v1:
    print(ele, end=' ')  # 1 2 3 4
  7. 添加元素
    v1 = {1, 2, 3, 4}

v1.add(5)
print(v1)  # {1, 2, 3, 4, 5}
  8. 删除元素
    删除的元素不存在也不会报错
    v1 = {1, 2, 3, 4}

v1.discard(1)
print(v1)  # {2, 3, 4}

9.空类型:None

Python的数据类型中有一个特殊的值None，意味着这个值啥都不是 或 表示空。 相当于其他语言中 null作用一样。

 

10.类型之间的相互装换

  1. 转整形
    # 浮点数转整数
print(int(3.14))  # 3

# 字符串转整数
print(int('100'))  # 100

# 布尔值转整数
print(int(True))  # 1
print(int(False))  # 0
  2. 转浮点型
    # 整形转浮点型
print(float(100))  # 100.0

# 字符串转浮点型
print(float('3.14'))  # 3.14

# 布尔值转浮点型
print(float(True))  # 1.0
print(float(False))  # 0.0
  3. 转字符串
    其它八种数据类型都可以转化为字符串
    # 整形转字符串
print(str(100))  # 100
# 浮点型转字符串
print(str(3.14))  # 3.14
# 列表转字符串
print(str([1, 2, 3]))  # [1, 2, 3]
# 元组转字符串
print(str((1, 2, 3)))  # (1, 2, 3)
# 字典转字符串
print(str({'name': 'kunmzhao', 'age': 18}))  # {'name': 'kunmzhao', 'age': 18}
# 集合转字符串
print(str({1, 2, 3}))  # {1, 2, 3}
# 布尔值转字符串
print(str(True))  # True
# None转字符串
print(str(None))  # None
  4. 转列表
    只要是可迭代的都可以转为列表
    # 字符串转列表
print(list('hello'))  # ['h', 'e', 'l', 'l', 'o']

# 元组转列表
print(list((1, 2, 3)))  # [1, 2, 3]

# 字典转列表
print(list({'name':'kunmzhao','age':18}.keys()))  # ['name', 'age']
print(list({'name':'kunmzhao','age':18}.values()))  # ['kunmzhao', 18]
print(list({'name':'kunmzhao','age':18}.items()))  # [('name', 'kunmzhao'), ('age', 18)]

# 集合转列表
print(list({1, 2, 3,4}))  # [1, 2, 3, 4]

     

  5. 转元组
    # 字符串转列表
print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')

# 元组转列表
print(tuple([1, 2, 3]))  # (1, 2, 3)

# 字典转列表
print(tuple({'name':'kunmzhao','age':18}.keys()))  # ('name', 'age')
print(tuple({'name':'kunmzhao','age':18}.values()))  # ('kunmzhao', 18)
print(tuple({'name':'kunmzhao','age':18}.items()))  # (('name', 'kunmzhao'), ('age', 18))

# 集合转列表
print(tuple({1, 2, 3,4}))  # (1, 2, 3, 4)
  6. 转字典
    字典由键值对组成，想要转化为字典，必须是等长的二级容器
    print(dict([('name', 'kunmzhao'), ('age',18)]))  # {'name': 'kunmzhao', 'age': 18}
  7. 转集合
    可以实现去重
    # 列表转集合
print(set([1, 2, 3, 4, 1, 2, ]))  # {1, 2, 3, 4}

# 元组转结合
print(set((1, 2, 3, 4, 1, 2,)))  # {1, 2, 3, 4}

# 字典转集合
print(set({'name': 'kunmzhao', 'age': 19}))  # {'name', 'age'}
  8. 转布尔值
    """
整数0，浮点数0.0，空字符串''，空列表[]，空元组()，空字典{}，空集合set()，None 转化为布尔值都是False
其它都是True
"""
posted on 2022-11-01 14:41  阿明明  阅读(175)  评论(0)    收藏  举报
博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3