首页 > 其他分享 >数据类型内置方法

数据类型内置方法

时间：2023-12-04 11:22:37浏览次数：24  
标签：heart 内置 name list 数据类型 num dict print 方法

数据类型内置方法介绍

  • 八大基本数据类型
    • 数字类型
      • 整形（int）
      • 浮点型（float）
    • 字符串（str）
    • 列表（list）
    • 元组（tuple）
    • 布尔（bool）
    • 字典（dict）
    • 集合（set）

【一】整型（int）

（1）类型强转

  • 可以将由纯整数构成的字符串直接转换成整型
    • 符合int类型格式的字符串可以强转成整数类型
num = '123'
print(num, type(num))  # 123 <class 'str'>
print(int(num), type(int(num)))  # 123 <class 'int'>
  • 十进制数转为其他进制
# bin() 十进制转二进制
# oct() 十进制转八进制
# hex() 十进制转十六进制
print(bin(999))
  • 其他进制转为十进制
    • 二进制（以'0b'或者'0B'开头）
    • 八进制（以'0o'或者'0O'开头）
    • 十六进制（以'0x'或者'0X'开头）
# int() 其他进制转为十进制
print(int('0b11100',2))
print(int('0o1747',8))
print(int('0x3e7',16))

【二】浮点类型（float）

（1）类型强转

  • 符合float类型格式的字符串可以强转成浮点类型
num = '18.0'
print(num, type(num))  # 18.0 <class 'str'>
print(float(num), type(float(num)))  # 18.0 <class 'float'>

（2）取整-round

  • 四舍五入---round
print(round(3.5)) # 4
print(round(4.0)) # 4

【三】字符串类型（str）

（1）索引取值

  • 只能取值不能修改
name='heart'
print(name[0]) # h

（2）字符串拼接

  • +号拼接
word1 = 'hello'
word2 = 'world'
print(word1 + ',' + word2) # hello,world
  • .join给每个字符拼接
word1 = 'hello'
print('-'.join(word1))  # h-e-l-l-o

（3）切片

  • 切片也是顾头不顾尾 [起始位置:想要的结束位置+1]
name = 'heart'
name_one = name[0] + name[1]
print(name_one)  # he

name_two = name[2:4 + 1]
print(name_two)  # art
  • 切片也可以加步长 [起始位置:想要的结束位置+1:step]
name = 'heart'
name_three = name[0:5 + 1:2]
print(name_three)  # hat
  • 从指定索引切到最后 [起始位置::]
name = 'heart'
name_four = name[1::]
print(name_four)  # eart

（4）成员运算

  • in和not in用于检查一个字符串是否包含另一个字符串
name = 'heart'
print('h' in name)  # True
print('d' in name)  # False

（5）去除空格 strip()

  • strip()方法用于去除字符串里的空格
    • lstrip()用于去除字符左边的空格
    • rstrip()用于去除字符右边的空格
name='  heart   '
print(name.strip()) # heart
  • 还可以去除指定的字符
name = '&&heart&&'
print(name.strip('&')) # heart

（6）切分 split()

  • 顾名思义就是将字符串切分成多个子字符串，并返回一个包含切分后字符串的列表
name = 'heart-425'
print(name.split('-')) # ['heart', '425']

（7）大小写转换

  • 小写转大写upper()
    • isupper()判断是否为纯大写
  • 大写转小写lower()
    • islower()判断是否为纯小写
name = 'HeArt'
print(name.upper())  # HEART
print(name.lower())  # heart

（8）首尾字符判断

  • startswith()判断当前字符以什么开头，返回bool值
  • endswith()判断当前字符以什么结尾，返回bool值
name = 'heart'
print(name.startswith('h'))  # True
print(name.startswith('e'))  # False
print(name.endswith('t'))  # True
print(name.endswith('r'))  # False

（9）替换replace

  • replace可以替换字符串中的词
title = 'my hero is heart'
print(title.replace('heart', 'godfather'))

【四】列表类型（list）

（1）类型强转

  • 字符串类型强转成列表类型的话就是将每一个元素都拿出，凑成一个列表
name = 'heart'
print(list(name))  # ['h', 'e', 'a', 'r', 't']
  • 元组类型强转成列表类型，每一个元素就是列表的元素
name_tuple = ('heart', 'godfather')
print(list(name_tuple))  # ['heart', 'godfather']
  • 集合类型强转成列表类型，每一个元素就是列表的元素
name_set = {'heart', 'godfather'}
print(list(name_set))  # ['heart', 'godfather']
  • 字典类型强转成列表类型，每一个键就是列表的元素
name_dict = {'heart': '123456', 'god': '123'}
print(list(name_dict))  # ['heart', 'god']
  • range生成新列表
print(list(range(1, 5)))  # [1, 2, 3, 4]

（2）切片

  • 顾头不顾尾
name_list = ['heart', 'god', 'zeus']
print(name_list[0:3])  # ['heart', 'god', 'zeus']
  • 步长
num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(num_list[0:8:2])  # [1, 3, 5, 7]

（3）计算长度 len

num_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(len(num_list))  # 9

（4）增加

[1]append()

  • 在结尾进行增加，只允许每次加一个元素
num_list = [1, 2, 3, 4, 5, 6]
num_list.append(11)
print(num_list)  # [1, 2, 3, 4, 5, 6, 11]

[2]extend()

  • 可以一次性添加多个元素
num_list = [1, 2, 3, 4, 5, 6]
num_list.extend((11, 22, 33))
num_list.extend([99, 88, 77])
num_list.extend({'name': 'heart', 'age': '18'})
print(num_list)  # [1, 2, 3, 4, 5, 6, 11, 22, 33, 99, 88, 77, 'name', 'age']

[3]insert()

  • 按指定位置添加
num_list = [1, 2, 3, 4, 5, 6]
num_list.insert(1, 'a')
print(num_list)  # [1, 'a', 2, 3, 4, 5, 6]

（5）删除

[1]del

  • 删除指定索引的元素
num_list = [1, 2, 3]
del num_list[0]
print(num_list) # [2, 3]

[2]pop()

  • 默认删除列表最后一个元素，并将删除的值返回
num_list = [1, 2, 3]
a = num_list.pop()
print(a) # 3
print(num_list) # [1, 2]

[3]remove()

  • 指名道姓删除括号内的元素，没有返回值
  • 与pop不同，pop是通过索引值来删除的
num_list = [1, 2, 3, 'heart']
num_list.remove('heart')
print(num_list)  # [1, 2, 3]

（6）改

  • 按照索引位置改值
num_list = [1, 2, 3]
num_list[0] = 'heart'
print(num_list)  # ['heart', 2, 3]

[1]reverse()

  • 颠倒列表内元素排列，无返回值，影响的是原来列表
num_list = [1, 2, 3, 4, 5, 6]
num_list.reverse()
print(num_list)  # [6, 5, 4, 3, 2, 1]

[2]sort()

  • sort()方法用于对列表进行排序，默认是升序
num_list = [1, 3, 5, 4, 6, 8]
num_list.sort()
print(num_list)  # [1, 3, 4, 5, 6, 8]
  • reverse=True降序排序
num_list = [1, 3, 5, 4, 6, 8]
num_list.sort(reverse=True)
print(num_list)  # [8, 6, 5, 4, 3, 1]

[3]sorted

  • sorted函数可以保留原来的列表
  • 也可以排序，默认正序，返回值就是排好序的新列表
num_list = [1, 3, 5, 4, 6, 8]
a = sorted(num_list)
print(a)  # [1, 3, 4, 5, 6, 8]
print(num_list)  # [1, 3, 5, 4, 6, 8]

【五】布尔类型（bool）

（1）类型强转

  • 代表真的情况：
    • 数字类型 1（有值的数字类型都是真）
    • 有值的字符串/列表/字典/元组/集合
num = 1
print(bool(num), type(bool(num)))  # True <class 'bool'>
  • 代表假的情况：
    • 数字类型0
    • 空的字符串/列表/元组/字典
num = 0
num_one = ''
print(bool(num), type(bool(num)))  # False <class 'bool'>
print(bool(num_one), type(bool(num_one)))  # False <class 'bool'>

【六】元组类型（tuple）

（1）类型强转

  • 但凡能被for循环遍历的数据类型都可以传给tuple()转换成元组类型
name_list = ['heart', 18]
print(tuple(name_list), type(tuple(name_list)))

（2）索引取值

  • 元组也支持索引取值，只能取不能改
name_tuple = ('heart', 'god')
print(name_tuple[0])  # heart

（3）切片

  • 顾头不顾尾[起始索引:结束索引:step]
name_tuple = ('heart', 'god', 'father', 'tom')
print(name_tuple[0:2])  # ('heart', 'god')

（4）计算长度 len

name_tuple = ('heart', 'god', 'father', 'tom')
print(len(name_tuple))  # 4

（5）成员运算

num_tuple = (1, 2, 3, 4)
print(3 in num_tuple)  # True

（6）循环取值

num_tuple = (1, 2, 3, 4)
num_tuple_two = ('a', 'b', 'c')
print(num_tuple + num_tuple_two)  # (1, 2, 3, 4, 'a', 'b', 'c')

【七】字典类型（dict）

（1）取值

[1]按[key]

dict_one = {'name': 'heart', 'age': 18, 'height': '180'}
print(dict_one['name'])  # heart

[2]get取值

  • 使用get方法可以根据键获取对应的值，如果键不存在，则返回指定的值
dict_one = {'name': 'heart', 'age': 18}
print(dict_one.get('name'))  # heart
print(dict_one.get('height', 180))  # 180

（2）计算长度 len

  • 使用len函数可以计算字典中键值对的个数
dict_one = {'name': 'heart', 'age': 18, 'height': 180}
print(len(dict_one))  # 3

（3）成员运算

  • 使用in和not in可以判断键是否存在字典中
dict_one = {'name': 'heart', 'age': 18, 'height': 180}
print('name' in dict_one)  # True

（4）增加

  • 如果没有这个键，那就将键添加进字典里
  • 如果存在这个键，就直接替换成新内容
dict_one = {'name': 'heart', 'age': 18, 'height': 180}
dict_one['sex'] = '男'
dict_one['name'] = 'heart1'
print(dict_one)  # {'name': 'heart1', 'age': 18, 'height': 180, 'sex': '男'}

[1] update(key=value)

  • 使用update()方法可以批量增加键值对，如果键已经存在，则更新字典
dict_one = {'name': 'heart'}
dict_one.update(sex='男', hobby=['music'])
print(dict_one)  # {'name': 'heart', 'sex': '男', 'hobby': ['music']}

[2]setdefault(key,value)

  • 用于获取指定键的值，如果键不存在，则返回默认值，有返回值，并且返回值就是你添加到字典中的值，只能单个增加元素
dict_one = {'name': 'heart'}
res = dict_one.setdefault('sex', '男')
print(dict_one)  # {'name': 'heart', 'sex': '男'}
print(res)  # 男

（5）删除

[1]del

  • 根据字典中的键删除指定的键值
dict_one = {'name': 'heart', 'age': 18}
del dict_one['name']
print(dict_one)  # {'age': 18}

[2]pop()

  • 使用pop方法可以根据键弹出字典中的键值对，同时返回被弹出的值
dict_one = {'name': 'heart', 'age': 18, 'height': 180}
print(dict_one.pop('age'))  # 18
print(dict_one)  # {'name': 'heart', 'height': 180}

[3]clear()

  • 使用clear方法可以清空字典中的所有键值对
dict_one = {'name': 'heart', 'age': 18, 'height': 180}
dict_one.clear()
print(dict_one)  # {}

[4]popitem

  • 删除字典中结尾的一个键值对，并以元组的形式返回被删除的键值
dict_one = {'name': 'heart', 'age': 18, 'height': 180}
print(dict_one.popitem())  # ('height', 180)
print(dict_one)  # {'name': 'heart', 'age': 18}

（6）keys()键对

  • 使用keys方法可以获取字典里所有的键
dict_one = {'name': 'heart', 'age': 18, 'height': 180}
print(dict_one.keys())  # dict_keys(['name', 'age', 'height'])

（7）values()值对

  • 使用values方法可以获取字典中所有的值
dict_one = {'name': 'heart', 'age': 18, 'height': 180}
print(dict_one.values())  # dict_values(['heart', 18, 180])

（8）items()键值对

  • 使用item方法可以获取字典中所有的键值对
dict_one = {'name': 'heart', 'age': 18, 'height': 180}
print(dict_one.items())  # dict_items([('name', 'heart'), ('age', 18), ('height', 180)])

（9）遍历循环

  • 可以遍历字典，但是遍历字典出来的是键
dict_one = {'name': 'heart', 'age': 18, 'height': 180}
for i in dict_one:
    print(i)
  • 可以遍历字典的键值对，根据解压赋值
dict_one = {'name': 'heart', 'age': 18, 'height': 180}
for k,v in dict_one.items():
    print(k,v)

（10）sorted()字典排序

  • 字典的排序是通过字典的键来进行的
dict_one = {'name': 'heart', 'age': 18, 'height': 180}
print(sorted(dict_one))  # ['age', 'height', 'name']

【八】集合类型（set）

  • 集合类型的定义使用大括号（），元素之间使用,分隔

（1）类型强转

  • 集合的特点就是无序性
print(set('heart'))  # {'t', 'e', 'h', 'r', 'a'}
  • 集合的另一大特性就是去重，去除重复的元素
print(set('heartt'))  # {'t', 'e', 'h', 'r', 'a'}
  • 字符串类型可以强转成集合类型
  • 字典也可以去重，一般我们只对字典的值去重
    • 因为字典的键一般情况下都是唯一的，不需要更改
print(set({'name': 'heart', 'age': 18, 'sex': '男', 'height': 18}.values()))  # {18, '男', 'heart'}
  • 列表类型可以强转成集合类型
num_list = [1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 6]
print(set(num_list))  # {1, 2, 3, 4, 5, 6}

（2）添加元素

[1]add()

  • 添加单个元素
num_set = {1, 2, 3, 4}
num_set.add(5)
print(num_set)  # {1, 2, 3, 4, 5}

[2]update()

  • 添加多个元素（字符串/列表/字典/元组）

  • 重复的元素会按照集合的特性进行去重

num_set = {1, 2, 3, 4}
num_set.update((1, 2, 5, 6))
print(num_set)  # {1, 2, 3, 4, 5, 6}

（3）删除元素

[1]remove()

  • 只能按照集合中的值删除掉指定元素
num_set = {1, 2, 3, 4, 5, 6}
num_set.remove(1)
print(num_set)  # {2, 3, 4, 5, 6}

[2]discard()

  • 用于移除集合中的指定元素，如果元素不存在无反应，不会报错，没有返回值
num_set = {1, 2, 3, 4, 5, 6}
num_set.discard(7)
print(num_set)  # {1, 2, 3, 4, 5, 6}

[3]pop()

  • 删除集合中的第一个元素
num_set = {1, 2, 3, 4, 5, 6}
num_set.pop()
print(num_set)  # {2, 3, 4, 5, 6}

（4）集合操作

[1]union()并集

num_set = {1, 2, 3, 4, 5, 6}
num_set_two = {2, 3, 7, 8}
union_set = set.union(num_set, num_set_two)
print(union_set)  # {1, 2, 3, 4, 5, 6, 7, 8}

[2]intersection()交集

num_set = {1, 2, 3, 4}
num_set_two = {2, 3, 7, 8}
union_set = set.intersection(num_set, num_set_two)
print(union_set)  # {2, 3}

[3]difference()差集

  • 方法返回当前集合和其他集合的差集
num_set = {1, 2, 3, 4}
num_set_two = {2, 3, 7, 8}
union_set = set.difference(num_set, num_set_two)
print(union_set)  # {1, 4}

（5）成员运算

  • 虽然集合是无序的，但是不影响判断元素在不在集合里面，在就是True，不在就是False
num_set = {1, 2, 3}
print(1 in num_set)  # True

（6）循环

num_set = {1, 2, 3, 'heart'}
for i in num_set:
    print(i)
# 1
# 2
# 3
# heart

（7）计算长度 len()

num_set = {1, 2, 3, 'heart'}
print(len(num_set))  # 4

【九】数据类型总结

  • 能索引取值：字符串 / 列表 / 元组
  • 能键取值：字典
  • 能变化的：列表 / 字典
  • 不能变化的： 数字类型 / 字符串 / 集合 / 元组

【十】判断类型

  • 这三个方法都无法判断浮点数

（1）判断数字类型 isdigit()

  • isdigit只对只包含数字0-9的字符串返回True
num1='3'
print(num1.isdigit()) # True

（2）判断小数类型 isdecimal()

num1='3'
print(num1.isdecimal()) # True

（3）判断数字类型 isnumeric()

  • isnumeric在包含任何数字字符时返回True
num1='3'
print(num1.isnumeric()) # True

标签：heart,内置,name,list,数据类型,num,dict,print,方法
From： https://www.cnblogs.com/ssrheart/p/17874514.html

相关文章

  • Python中用requests处理cookies的3种方法
    在接口测试中，大多数项目的接口是需要登录后进行操作的，经常用到requests库进行模拟登录及登录后的操作，下面是我不断踩坑后总结出来的关于登录凭证cookies的3种操作方法。一.用requests.utils.dict_from_cookiejar()把返回的cookies转换成字典1.处理cookies：importreques......
  • notepad++中的正则表示式使用方法
    当使用Notepad+中的正则表达式时，可以利用以下常用的元字符和语法规则来构建你的表达式：正则表达式知识准备字符匹配：\d：匹配任意数字。\w：匹配任意字母、数字或下划线。\s：匹配任意空白字符（空格、制表符等）。.：匹配除换行符外的任意字符。重复次数：*：匹配前一个元素零次或......
  • hibernate使用原生sql查询Hibernate原生SQL多表查询字段名重复问题以及解决方法
    解决方案通过将别名.*换成{别名.*}hibernate会自动为我们生成别名,具体修改如下图： ......
  • .NET 7（C#）配置使用log4net日志框架的方法
    .NET7（C#）中配置和使用log4net日志框架是一个涉及多步骤的过程。log4net是一个高度灵活且强大的日志记录库，可用于记录应用程序的运行时信息。它支持各种日志输出格式和目的地，如文件、数据库、控制台等。以下是在.NET7（C#）项目中配置和使用log4net的基本步骤：1.安装log4net......
  • Linux下设置定时任务常用的三种方法
    在Linux系统中，设置定时任务是一项常见且重要的操作，它有助于自动化执行各种任务，如系统维护、备份和日志审计。Linux提供了多种工具来安排这些自动化任务，其中最常用的三种方法是Cron、At和SystemdTimers。1.cronCron是Linux中最传统且广泛使用的定时任务工具。它允许用......
  • 文本编辑器（Vi）及使用方法
    可使用的文本编辑器：Emacs——著名的集成开发环境和文本编辑器，被公认为是最受专业程序员喜爱的代码编辑器之一，有着极强扩展性的编程语言，从而实现了包括编程、编译乃至网络浏览等等功能的扩展。Nano——一种被许多可启动Linux系统以及其他空间有限的Linux环境所使用的流行且简化......
  • R语言Outliers异常值检测方法比较|附代码数据
    原文链接：http://tecdat.cn/?p=8502原文出处：拓端数据部落公众号最近我们被客户要求撰写关于异常值检测的研究报告，包括一些图形和统计输出。识别异常值的方法有很多种，R中有很多不同的方法。 关于异常值方法的文章结合了理论和实践。理论一切都很好，但异常值是异常值，因为它们不遵......
  • excute方法和submit方法
    区别：  1.参数    execute Runnable    submit   Callable  2.返回值    execute：void    submit：Future  3.异常    execute会在子线程中抛出异常，在主线程捕捉不到    submit不会字码抛出异常，而是会讲一次暂时存起来，等Future.get......
  • 内置线程池的使用
    packageorg.example.c2;importlombok.extern.slf4j.Slf4j;importjava.util.concurrent.ExecutorService;importjava.util.concurrent.Executors;importjava.util.concurrent.ScheduledExecutorService;importjava.util.concurrent.TimeUnit;/****@Author徐庶......
  • Java基础-数据类型
    目录注释写代码时，书写注释是一个非常好的习惯。平时写代码一定要注意规范选中代码，shift+ctrl+/搞定。标识符java所有的组成部分都需要名字，类名，变量名以及方法名被称为标识符。所有的标识符都是以字母，美元符，或者下划线开始的。数据类型1.强类型语言：要求变量的使用要严......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99