首页 > 其他分享 >基本数据类型

基本数据类型

时间：2023-12-13 19:58:58浏览次数：41  
标签：基本 name list 数据类型 num dict dhy print

内容概要

  • 八大基本数据类型
    • 数字类型
      • 整数(int)
      • 浮点数(float)
    • 字符串类型(str)
    • 列表类型(list)
    • 字典类型(dict)
      • dictionary
    • 布尔类型(bool)
    • 元组类型(tuple)
    • 集合类型(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='dhy'
print(name[0]) # d

（2）字符串拼接

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

（3）切片

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

（4）成员运算

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

（5）去除空格 strip()

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

（6）切分 split()

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

（7）大小写转换

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

（8）首尾字符判断

  • startswith()判断当前字符以什么开头，返回bool值
  • endswith()判断当前字符以什么结尾，返回bool值
name = 'dhy'
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 dhy'
print(title.replace('dhy', 'godfather'))

【四】列表类型（list）

（1）类型强转

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

（2）切片

  • 顾头不顾尾
name_list = ['dhy', 'god', 'zeus']
print(name_list[0:3])  # ['dhy', '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': 'dhy', '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, 'dhy']
num_list.remove('dhy')
print(num_list)  # [1, 2, 3]

（6）改

  • 按照索引位置改值
num_list = [1, 2, 3]
num_list[0] = 'dhy'
print(num_list)  # ['dhy', 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]

【四】字典类型

（1）取值

[1]按[key]

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

[2]get取值

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

（2）计算长度 len

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

（3）成员运算

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

（4）增加

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

[1] update(key=value)

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

[2]setdefault(key,value)

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

（5）删除

[1]del

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

[2]pop()

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

[3]clear()

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

[4]popitem

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

（6）keys()键对

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

（7）values()值对

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

（8）items()键值对

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

（9）遍历循环

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

（10）sorted()字典排序

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

【五】布尔类型（bool）

（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 = ['dhy', 18]
print(tuple(name_list), type(tuple(name_list)))

（2）索引取值

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

（3）切片

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

（4）计算长度 len

name_tuple = ('dhy', 'lqq', 'jerry', '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')

【八】集合类型（set）

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

（1）类型强转

  • 集合的特点就是无序性
print(set('dhy'))  # {'h', 'd', 'y'}
  • 集合的另一大特性就是去重，去除重复的元素
print(set('dhyy'))  # {'y', 'h', 'd'}
  • 字符串类型可以强转成集合类型
  • 字典也可以去重，一般我们只对字典的值去重
print(set({'name': 'dhy', 'age': 18, 'sex': '男', 'height': 18}.values()))  # {18, '男', 'dhy'}
  • 列表类型可以强转成集合类型
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}

（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, 'dhy'}
for i in num_set:
    print(i)
# 1
# 2
# 3
# dhy

（7）计算长度 len()

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

标签：基本,name,list,数据类型,num,dict,dhy,print
From： https://www.cnblogs.com/dhyuan/p/17899778.html

相关文章

  • Solidity基本语法学习5
    文档:https://solidity-by-example.org/视频教程:https://www.youtube.com/watch?v=xv9OmztShIw&list=PLO5VPQH6OWdVQwpQfw9rZ67O6Pjfo6q-p说明本文内容payable,SendingEther(transfer,send,call),Fallback,Call,DelegateCall,functionselector,CallingOtherC......
  • Hadoop 数据类型及序列化
    1.Hadoop数据类型Java类型HadoopWritable类型BooleanBooleanWritableWritableWritableWritableWritableWritableWritableWritableWritableWritable2.为何Hadoop有自身序列化与反序列化Java自身的序列化除去本身Bean的数据......
  • 六、Playbook基本使用
    六、Playbook基本使用6.1Playbook介绍​ ansbile-playbook是一系列ansible命令的集合，利用yaml语言编写。playbook命令根据自上而下的顺序依次执行。同时，playbok开创了很多特性，它可以允许你传输某个命令的状态到后面的指令，如你可以从一台机器的文件中抓取内容并附为变量，然后在另......
  • 数据类型一些相关问题
    如何取出整型的每一位我们可以定义四个uint8_t的变量，然后将int类型变量每8位每8位的取出1intmain()2{3OLED_Init();4intnum=261;5uint8_tnum1;6uint8_tnum2;7uint8_tnum3;8uint8_tnum4;9num1=(0xff000000&num)>>2......
  • 蔡崇信看好的菜鸟，“基本面”究竟如何？
    今年5月,阿里巴巴集团曾公布云智能集团将完全分拆独立走向上市，菜鸟、盒马启动上市计划，国际数字商业集团启动外部融资。但随着16日阿里巴巴集团最新财报的发布，及宣布终止分拆阿里云、盒马IPO搁置，现在，仅有菜鸟在按原定的计划照常IPO中。作为阿里“1+6+N”之后第一家冲刺上市的业务集......
  • Vue3 setup 方法的一些基本使用总结
    官网介绍：https://cn.vuejs.org/api/composition-api-setup.html基本使用setup()钩子是在组件中使用组合式API的入口，通常只在以下情况下使用：需要在非单文件组件中使用组合式API时。需要在基于选项式API的组件中集成基于组合式API的代码时。setup方法返回值：返回一......
  • VLOOKUP函数基本使用
    结构：=VLOOKUP(查找值,数据表,列序数,匹配条件)说明：1、第一参数：查找值，比如说根据【姓名】来查找【工资】，【姓名】就是查找值，且在数据表中要位于第一列；2、第二参数：数据表，查找的数据区域，建议设置为绝对引用，在选定区域后按F4键就可以快速切换，就是在行和列的前面添加$符号，拖动公式时，......
  • 【matlab混沌理论】1.3.双摆杆基本模型
    双摆杆是混沌理论的典型运动模型之一。涉及重力加速度、摆杆长度和质量。1.双摆杆的摆角分析input:%已知物理参数L1=5;L2=3;%两摆杆长度和质量m1=3;m2=5;g=9.80665;%物理重力加速度m/s^2%定义初始参数%y0的第1参数，即摆1的初始角度；第2，即摆2的初始角......
  • 第二节 数据类型
    数据类型Kotlin的基本数据类型与Java、C++基本对应。事实上绝大多数程序语言的基本数据类型都差不多。在Java中8中基本数据类型不属于类，也就不具备“对象”特征，无法进行面向对象操作。Java的解决方案是提供包装类将基本数据类型进行封装，使之每个包装类对象封装一个基本数据类型......
  • requests模块基本使用
    1.requests模块基本使用1.1使用requests发送get请求importrequests#res响应对象，http响应，python包装成了对象，响应头，响应头。。。在res中都会有res=requests.get('https://www.cnblogs.com/Hao12345/p/17661461.html')print(res.text)#res.text------->响应体......

赞助商

阅读排行

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

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

Copyright © 2020-2023 IPS99 版权所有 IPS99