开发者

Python全栈之基本数据类型

开发者 https://www.devze.com 2022-12-05 14:16 出处:网络 作者: 熬夜泡枸杞
目录1. number类型1.1 int整型1.2 float浮点型(小数)1.3 bool布尔型1.4 复数类型2. 字符串类型3. 列表_元组_字符串3.1 列表类型3.2 元组类型3.3 字符串类型4. 集合_字典4.1 集合类型4.2 字典类型5. 变量的缓存机制
目录
  • 1. number类型
    • 1.1 int整型
    • 1.2 float浮点型(小数)
    • 1.3 bool布尔型
    • 1.4 复数类型
  • 2. 字符串类型
    • 3. 列表_元组_字符串
      • 3.1 列表类型
      • 3.2 元组类型
      • 3.3 字符串类型
    • 4. 集合_字典
      • 4.1 集合类型
      • 4.2 字典类型
    • 5. 变量的缓存机制
      • 6. 小练习
        • 总结

          1. number类型

          Number 数字类型 (int float bool complex)

          1.1 int整型

          # int 整型 (正整型 0 负整型)
          intvar = 100
          print(intvar)
          # type 获取值得类型
          res = type(intvar)
          print(res)
          # id   获取值得地址
          res = id(intvar)
          print(res)
          # 二进制整型
          intvar = 0b110
          print(intvar)
          print( type(intvar) )
          print(     id(intvar)    )
          # 八进制整型
          intvar = 0o127
          print(intvar)
          print(type(intvar))
          print(id(intvar))
          # 十六进制
          intvar = 0xff
          intvar = 0XFF
          print(intvar)
          print(type(intvar))
          print(id(intvar))
          """
          二进制 1 + 1 = `10
          八进制 7 + 1  = 10
          十六进制 f + 1 = 10
          """
          

          1.2 float浮点型(小数)

          # 表达方式之一
          floatvar = 3.6
          print(floatvar , type(floatvar))
          # 表达方式2 科学计数法
          floatvar = 5.75e5 # 小数点右移5
          floatvar = 5.7e-2 # 小数点左移2
          print(floatvar, type(floatvar))
          

          1.3 bool布尔型

          # True 真的, False 假的
          boolvar = True
          boolvar = False
          print(boolvar , type(boolvar))
          

          1.4 复数类型

          """
          3 + 4j
          实数+虚数
          实数: 3
          虚数: 4j
          j   : 如果有一个数他的平方等于-1,那么这个数就是j , 科学家认为有,表达一个高精度的类型
          """
          # 表达方式1
          complexvar = 3 + 4j
          complexvar = -3j
          print(complexvar , type(complexvar))
          # 表达方法2 
          """
          complex(实数,虚数) => 复数
          """
          res = complex(3,4)
          print(res , type(res))
          

          2. 字符串类型

          # ### 字符串类型 str
          """
          用引号引起来的就是字符串,单引号,双引号,三引号
          # 转移字符 \ + 字符串类型	
          	(1) 可以将无意义的字符变的有意义
          	(2) 可以将有意义的字符变的无意义
          \n   : 换行
          \r\n : 换行
          \t   : 缩进(水平制表符)
          \r   : 将\r后面的字符串拉到了当前行的行首 
          """
          # 1. 单引号的字符串
          strvar = '生活不知眼前的苟且'
          print(strvar , type(strvar))
          # 2. 双引号的字符串
          strvar = "还有诗和远方的田野"
          print(strvar , type(strvar))
          # 可以将无意义的字符变得有意义
          strvar = "还有诗和\n远方的田野"
          print(strvar)
          strvar = "还有诗和\r\n远方的田野"
          strvar = "还有诗和\t远方的田野"
          strvar = "还有诗和\r远方的田野"
          strvar = "还有诗和\n远方的\r田野"
          # 可以将有意义的字符变得无意义
          strvar = "还有诗和\"远\"方的田野"
          print(strvar)
          strvar = '''
          "生活就像醉酒"
          表面上'不'要
          身体却很诚实
          '''
          print(strvar)
          # 元字符串 r"字符串" 原型化输出字符串
          strvar = " D:\nython32_python\tay02"
          strvar = r" D:\nython32_python\tay02"
          print(strvar)
          # 5. 字符串的格式化
          """
          %d 整型占位符
          %f 浮点型占位符
          %s 字符串占位符
          语法格式:
          	"字符串" % (值1,值2)
          """
          # %d 整型占位符
          strvar = "小明昨天买了%d风油精,洗澡" % (2)
          print(strvar)
          # %2d 占两位(不够两位拿空格来补位)原字符串具右
          strvar = "小明昨天买了%2d风油精,洗澡" % (2)
          print(strvar)
          # %-2d 占两位(不够两位拿空格来补位)原字符串具左
          strvar = "小明昨天买了%-2d风油精,洗澡" % (2)
          print(strvar)
          # %f 浮点型占位符
          strvar = "小明一个月开%f工资" % (9.9)
          print(strvar)
          # %.2f 保留小数点后面两位小数(存在四舍五入的情况,默认保留六位小数)
          strvar = "小明一个月开%.2f工资" % (9.178)
          print(strvar)
          # %s字符串占位符
          strvar = "%s最喜欢在电影院尿尿" % ("小明")
          print(strvar)
          # 综合案例
          strvar = "%s在水里%s被发现了,罚款%.2f元,并且做了%d俯卧撑." % ("小明","尿尿",500.129,50000)
          print(strvar)
          # 如果搞不清楚用什么占位符,可以无脑使用%s
          strvar = "%s在水里%s被发现了,罚款%s元,并且做了%s俯卧撑." % ("小明", "尿尿", 500.129, 50000)
          print(strvar)
          

          3. 列表_元组_字符串

          3.1 列表类型

          """特征: 可获取,可修改,有序"""
          # 1.定义一个空列表
          listvar = []http://www.cppcns.com
          print( listvar , type(listvar))
          # 定义普通列表
          listvar = [98,6.9,True,12-90j,"赵万里"]
          # 2.获取列表中的元素
          # 正向索引   0  1   2     3      4
          listvar =   [98,6.9,True,12-90j,"赵万里"]
          # 逆向索引  -5  -4  -3     -2      -1
          res = listvar[2]
          res = listvar[-2]
          print(res)
          # 通用写法
          # len 获取容器类型数据中元素个数
          length = len(listvar)
          res = listvar[length-1]
          print(rvPrZMFyYWes)
          # 简写
          res = listvar[len(listvar)-1]
          print(res)
          # python逆向索引的特点,瞬间得到列表中最后一个元素
          print(listvar[-1])
          # 3.修改列表中的元素
          listvar = [98,6.9,True,12-90j,"赵万里"]
          listvar[3] = "大象"
          print(listvar)
          

          3.2 元组类型

          """特征:可获取,不可修改,有序"""
          # 定义一个元组
          # 正向索引    0      1      2      3
          tuplevar = ("小赵","小钱","小孙","小李")
          # 逆向索引    -4     -3     -2     -1
          print(tuplevar[2])
          print(tuplevar[-1])
          # 修改元组中的元素:元组中的值不能修改
          # tuple[0] = "萌不好心" error
          # 注意点
          """ 逗号才是区分是否是元组的标识符"""
          tuplevar = (8.9,)
          tuplevar = 8.1,
          print(tuplevar)
          print(type(tuplevar))
          # 定义空元组
          tuplevar = ()
          print(type(tuplevar))
          

          3.3 字符串类型

          """特征:可获取,不可修改,有序"""
          # 正向索引
          #		  0 1 2 3 4 5 6 7 8
          strvar = "看你,我就心跳加速"
          #		  -9-8-7-6-5-4-3-2-1
          # 逆向索引
          # 获取字符串中的元素
          print(strvar[3])
          print(strvar[-6])
          #不能修改字符串中的元素
          #strvar[3] = "你" error
          print("<=================>")
          strvar = "" # 单纯定义一个字符串类型
          print(strvar)
          print(type(strvar))
          strvar = "   " # 字符串中含有3个空格字符
          print(strvar[0])
          print(type(strvar))
          

          4. 集合_字典

          4.1 集合类型

          """特点:无序,自动去重"""
          # 1. 集合无序
          setvar = {"巨石强森","史泰龙","施瓦辛格","小明"}
          print(setvar,type(setvar))
          # 获取集合中的元素,不可以
          # setvar[0] error
          # 修改集合中的元素,不可以
          # setvar[2] = 111
          # 2. 集合自动去重
          setvar = {"巨石强森","史泰龙","史泰龙","施瓦辛格","小明"}
          print(setvar , type(setvar))
          # 3. 定义一个空集合
          setvar = set()
          print(setvar , type(setvar))
          

          4.2 字典类型

          """
          键值对存储的数据,表面上有序,本质上无序
          dicvar = {键1:值1,键2:值2,...}
          3.6版本之前,完全无序
          3.6版本之后,存储的时候,保留了字典的字面顺序,在获取内存中数据时
          重新按照字面顺序做了排序,所以看起来有序,实际上存储时还是无序
          """
          # 1. 定义一个字段
          dictvar = {"top":"the shy","middle":"肉鸡","bottom":"jacklove","jungle":"臭鞋","support":"水稻"}
          print(dictvar, type(dictvar))
          # 2. 获取字典中的值
          res = dictvar["middle"]
          print(res)
          res = dictvar["jungle"]
          print(res)
          # 3. 修改字典中的值
          dictvar["top"] = "the xboy"
          print(dictvar)
          # 4. 定义空字典
          dicvar = {}
          print(dicvar,type(dictvar))
          """
          字典的键 和 集合的值,有数据类型上的要求:
          (允许的类型范围)不可变的类型:Number(int float complex bool) str tuple
          (不允许的类型)可变的类型:list set dict
          哈希算法的提出目的是让数据尽量均匀的咋i内存当中分配,以减少哈希碰撞,提升存储分配的效率;
          哈希算法一定是无序的散列,所以集合和字典都是无序
          字典的键有要求,值没要求
          字典的值可以任意换掉,但是键不可以
          """
          # 允许的类型范围
          dictvar = {1:"abc",4.89:vPrZMFyYW111,False:333,3+90j:666,"小明":"你好帅",(1,2,3,4,5,6):9999}
          print(dictvar)
          print(dictvar[(1,2,3,4,5,6)])
          # dictvar = {[1,2,3]:123} error
          # 允许的类型范围
          setvar = {1,"a",4.56,9+3j,FavPrZMFyYWlse,(1,2,3)}
          print(setvar , type(setvar))
          # 总结:
          """
          无论是变量缓存机制还是小数据池的驻留机制,
          都是为了节省内存空间
          """
          

          5. 变量的缓存机制

          # ### 在同一文件中,变量的缓存机制 (仅仅针对python3.6版本负责)
          # 1.对于整型而言,-5~正无穷范围内的相同值 id一致
          var1 = 5
          var2 = 5
          var1 = -100
          var2 = -100
          print(id(var1) , id(var2) )
          
          # 2.对于浮点数而言,非负数范围内的相同值 id一致
          var1 = 4.67
          var2 = 4.67
          var1 = -4.67
          var2 = -4.67
          print(id(var1) , id(var2) )
          # 3.布尔值而言,值相同情况下,id一致
          var1 = True
          var2 = True
          print(id(var1) , id(var2) )
          # 4.复数在 实数+虚数 这样的结构中永不相同(只有虚数的情况例外)
          var1 = 4 +5j
          var2 = 4 +5j
          # 5j 情况下例外
          var1 = 5j
          var2 = 5j
          var1 = -5j
          var2 = -5j
          print(id(var1) ,id(var2))
          # -->容器类型部分
          # 5.字符串 和 空元组 相同的情况下,地址相同
          var1 = "你"
          var2 = "你"
          var1 = ()
          var2 = ()
          print(id(var1) ,id(var2))
          # 6.列表,元组,字典,集合无论什么情况 id标识都不同 [空元组例外]
          var1 = (1,2)
          var2 = (1,2)
          var1 = [1,2,3]
          var2 = [1,2,3]
          print(id(var1) ,id(var2))
          # 不同文件(模块)里,部分数据驻留小数据池中(仅对python3.6负责,了解)
          

          6. 小练习

          题目如下:

          1. 什么是原码反码补码
          2. 计算9 + (-3) 以及 -9 + (3)
          3. 什么是注释
          4. 注释种类
          5. 如何用注释排错
          6. 如何定义变量
          7. 变量命名
          8. 如何交换变量
          9. Python6大标准数据类型vPrZMFyYW
          10. 浮点型和复数的两种表达方法
          11. 写出三个转义字符,含义
          12. 简述如何使用字符串的格式化占位符
          13. 简述容器类型各个特征
          14. 以下各是什么类型:() , (1) , ("abc") , (False,)
          15. 字典的键和集合的值有什么要求
          16. 用几种方式获取列表中的最后一个元素
          17. 3.6版本中,变量的缓存机制有哪些
          

          解答如下:

          1.二进制表现的三种形式
          原码:用来显示 补码:用来存储计算 反码:用来转换原码反码
          正数 : 原码 = 反码 = 补码
          负数 : 原码和补码 互为取反 + 1
          2.
          9
          原码: 000 ... 1001 
          反码: 000 ... 1001 
          补码: 000 ... 1001 
          -3
          原码 100 ... 011
          反码 111 ... 100
          补码 111 ... 101
          000 ... 1001 
          111 ... 1101
          000 ... 0110  => 6
          
          -9
          原码:100 ... 1001 
          反码:111 ... 0110
          补码:111 ... 0111
          3
          原码 000 ... 011
          反码 000 ... 011
          补码 000 ... 011
          111 ... 0111
          000 ... 0011
          111 ... 1010 补码
          给你补码求原码
          补码:111 ... 1010
          反码:100 ... 0101
          原码:100 ... 0110  -6
          3. 注释就是对代码的解释,用来方便大家阅读代码的
          4. 注释种类:单行注释 多行注释
          5. 包裹代码划分范围,依次缩小范围找单行错误
          6. a =1 ,b = 2,a,b = 3,4 a=b=100 
          7. 字母数字下划线,首字符不能为数字,严格区分大小写,不能使用关键字,变量命名有意义,且不能使用中文哦
          8.
          (1) a,b = b,a  
          (2)tmp = a a = bb = tmp
          9. int float complex bool str list tuple set dict
          10.
          f = 3.56  f = 3e4 f = 3e-4
          c = 3+4j  c = complex(3,4)
          11.\n \t \r
          12."字符串" % (值1,值2 ... ) %d %f %s
          13.list : 可获取可修改有序 tuple/str:可获取,不可修改,有序 set:无序,自动去重 dict:键值对存储的数据,表面上有序,本质上无序
          14.空元祖 整型 字符串 元组
          15.可哈希不可修改的类型 Number str tuple
          16.lst[-1] lst[len(lst) - 1]
          17.int:-5~正无穷  float: 非负数 bool:值相同 complex:只有虚数例外,剩下都不一样
             str:值相同即可 tuple:空元组即可 其他容器都不相同;
          

          总结

          本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

          0

          精彩评论

          暂无评论...
          验证码 换一张
          取 消

          关注公众号