4、数据类型

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

4.1、字符串类型（str）

• 创建字符串类型

  v = '123'
  a = '''456'''
  b = """1111100"""
  print(type(v),type(a),type(b))#<class 'str'> <class 'str'> <class 'str'>
  

  • 字符串类型内置函数

    • 字符串字母转换

      • upper大写转换

        • 在执行此函数，内部会先循环判断是否为小写字符，然后再吧小写字符转换成大写

        v = 'aFcD'
        a = v.upper()
        print(v)	#aFcD
        print(a)	#AFCD
        

      • lower转换小写

        • 意思跟转换大写差不多

        v = 'ADSSS'
        a = v.lower()
        print(a)	#adsss
        

    • 字符串判断

      • isdigit判断是否为数字

        • 只能判断字符串中类似阿拉伯数字的字符
        • 返回True或False

        #示例1
        
        v  = '1'
        if v.isdigit():
           print(v)
        else:
           print('不是数字')
        
        #示例2,打印字符串中的数字
        
        v ='asdr124r6das656'
        for i in v :
           if i.isdigit():
              print(i)
                
        #示例3,打印字符串中数字出现个数
        v ='asdr124r6das656'
        totle = 0
        for i in v :
           if i.isdigit():
              totle +=1
        print(totle)	#7
        
        #示例4,打印字符串中数字的总和
        
        v ='asdr124r6das656'
        totle = 0
        for i in v :
           if i.isdigit():
              totle +=int(i)   #这涉及强制类型转换最后写
        print(totle)	#30
        
        

    • startswith以什么开头

      • 返回True或False

      v ='asdr124r6das656'
      if v.startswith('as'):
         print('以as开头')	#以as开头
      

    • endswith以什么结尾

      • 返回True或False

      v ='asdr124r6das656'
      if v.endswith('6'):
         print('以6结尾')	#以6结尾
      

  • 字符串去空格

    无法去中间的空格

    • strip去两边的空格

      • 普遍用于用户校验上

      v = ' 123aa '
      print(v)	# 123aa #
      a = v.strip()
      print(a)	#123aa#
      

    • lstrip去左边的空格

      v = ' 123aa '
      print(v)	# 123aa #
      a = v.lstrip()
      print(a)	#123aa #
      

    • rstri去右边的空格

      v = ' 123aa '
      print(v)	# 123aa #
      a = v.rstrip()
      print(a)	# 123aa#
      

  • 字符串替换

    • replace替换

      #示例1
      v = 'asdasddasgfedtgy21354esdasdfasd'
      a = v.replace('da','h')     #把da全部替换成h
      print(a)
      
      #示例2
      v = 'asdasddasgfedtgy21354esdasdfasd'
      a = v.replace('da','h',1)   #指定替换次数为1次
      print(a)
      

  • 字符串分割

    • split分割

      • 分割完成后形成一个列表
      • 默认从左往右分割

      #示例1以a为分隔符分割
      v = 'asdasddasgfedtgy21354esdasdfasd'
      a = v.split('a')	
      print(a)	#['', 'sd', 'sdd', 'sgfedtgy21354esd', 'sdf', 'sd']
      
      #示例2以a为分隔符分割2次
      v = 'asdasddasgfedtgy21354esdasdfasd'
      a = v.split('a',2)	
      print(a)	#['', 'sd', 'sddasgfedtgy21354esdasdfasd']
      
      #示例3从右往左分割2次
      v = 'asdasddasgfedtgy21354esdasdfasd'
      a = v.rsplit('a',2)
      print(a)	#['asdasddasgfedtgy21354esd', 'sdf', 'sd']
      

  • 字符串格式化

    • %占位符

      • s字符串

        print('我是%s'%('sun',))
        

      • d数字

        print('我是%s,今年%d'%('sun',20,))
        

      • %转义

        print('我是%s,今年%d,智商%%100'%('sun',20,))
        

    • format字符串索引位置插入字符

      • 顺序插入

        print('我是{}，几年{}，智商{}'.format('玉行','26','%100'))
        

      • 关键字插入

        print('我是{name}，几年{age}，智商{bfb}'.format(bfb='%100',name='玉行',age='26'))
        

    • join字符串拼接

      v = 'abc'
      b = '_'.join(v)
      print(b)      
      

  • 编码解码

    • encode转换编码

      • 转换成二进制，以十六进制显示

      v = '男孩'
      b = v.encode('utf-8')
      print(b)  	#b'\xe7\x94\xb7\xe5\xad\xa9'
      

    • decond解码

      • 用什么编码编码，就用什么编码解码

      v = '男孩'
      b = v.encode('utf-8')
      print(b)
      a = b.decode('utf-8')
      print(a)	#男孩
      

4.2、整型（int）

• 创建整型

  v = 12
  print(type(v))	#<class 'int'>
  

• Python2与Python3区别

  • Python2

    • 32位系统：-2147483648~2147483647

    • 64位系统：-9223372036854775808~9223372036854775807

    • 超出范围自动转成long(长整形)

    • 整数除法只能保留整数位

    • 想要显示小数位添加下面模块

      from __future__ import division
      

  • python3

    • 只有int()
    • 整数除法保留所有

4.3、布尔值（bool）

• 只有两个值
  • True（真）
  • False（假）
• 布尔值转换
  • 数字转布尔
    • 0为False
  • 数字转布尔
    • 0为False
  • 字符串转布尔
    • “”为False
  • 列表转布尔
    • [] 为False
  • 元组转布尔
    • （）为False
  • 集合转布尔
    • {}为False
  • 其他都为True

4.4、列表（list）

• 创建列表

  #创建空列表
  v = []
  print(type(v))	#<class 'list'>
  #创建数值列表
  v = [11,22,'ssd','234s']
  print(type(v))
  

• 列表类型内置函数

  • 添加元素

    • append添加一个元素到列表的最后

      #示例一
      v = [11,22,'ssd','234s']
      v.append('1112')
      print(v)
      #示例二
      v = []
      while True:
         user_name = input('请输入用户名：')
         if user_name != 'N':
            v.append(user_name)
         else:
            break
      print(v)
      '''
      请输入用户名：sun
      请输入用户名：123
      请输入用户名：ssdgfgh
      请输入用户名：2wrtttg
      请输入用户名：N
      ['sun', '123', 'ssdgfgh', '2wrtttg']
      '''
      

    • insert按照索引位置添加元素

      • 索引位置从0开始数

      v = ['sun', '123', 'ssdgfgh', '2wrtttg']
      v.insert(2,'hang')
      print(v)	#['sun', '123', 'hang', 'ssdgfgh', '2wrtttg']
      

  • 删除

    • 修改原有值

    • remove根据元素删除

      • 无返回值

      v = ['sun', '123', 'ssdgfgh', '2wrtttg']
      v.remove('123')
      print(v)	#['sun', 'ssdgfgh', '2wrtttg']
      

    • pop根据索引为止删除

      • 返回删除元素值

      #示例一删除指定位置元素
      v = ['sun', '123', 'ssdgfgh', '2wrtttg']
      v.pop(2)
      print(v)	#['sun', '123', '2wrtttg']
      
      #示例二删除最后元素（默认）
      v = ['sun', '123', 'ssdgfgh', '2wrtttg']
      v.pop()
      print(v)	#['sun', '123', 'ssdgfgh']
      
      #示例三提取删除元素的值
      v = ['sun', '123', 'ssdgfgh', '2wrtttg']
      a = v.pop()
      print('被删除元素：',a)	#被删除元素： 2wrtttg
      print('删除后列表：',v)	#print('删除后列表：',v)
      

    • del根据列表索引删除

      • 无返回值

      #指定元素位置删除
      v = ['sun', '123', 'ssdgfgh', '2wrtttg']
      del v[1]
      print(v)	#['sun', 'ssdgfgh', '2wrtttg']
      
      #删除整个列表
      v = ['sun', '123', 'ssdgfgh', '2wrtttg']
      del v
      print(v)
      

  • 排序

    • reverse列表反转打印

      • 修改原有值

      v = ['sun', '123', 'ssdgfgh', '2wrtttg']
      v.reverse()
      print(v)	#['2wrtttg', 'ssdgfgh', '123', 'sun']
      

    • sort排序

      • 修改原有值

      #从小到大
      v = ['sun', '123', 'ssdgfgh', '2wrtttg']
      v.sort(reverse=False)
      print(v)	#['123', '2wrtttg', 'ssdgfgh', 'sun']
      #从大到小
      v = ['sun', '123', 'ssdgfgh', '2wrtttg']
      v.sort(reverse=True)
      print(v)	#['sun', 'ssdgfgh', '2wrtttg', '123']
      

      • 总结：汉字 > 字母 > 数字

  • 嵌套

    • 总结：元素中如果有元组，则元组不可修改

    v = ['sun', '123',[11,22,33],(11,22,33), 'ssdgfgh', '孙']
    print(v[2])
    print(v[2][2])
    v[2] = 11
    print(v)
    #下面代码执行报错
    '''
    v[3][2] = 11
    print(v)
    '''
    #正确的代码
    v[3] = 11
    print(v)
    

4.5、元组（tuple）

• 创建元组

  #创建空元组
  v = ()
  print(type(v))	#<class 'tuple'>
  

• 元组嵌套

  • 如果元组中的元素是可变类型，那么这个元素内部的值可以修改

    '''
    v = (11,22,[1,2,3],44)
    v[2] = 0
    print(v)	#代码会报错，因为整个列表是元组的元素，元组中的元素不能被修改
    '''
    v = (11,22,[1,2,3],44)
    v[2][2] = 0
    print(v)	#(11, 22, [1, 2, 0], 44)
    

4.6、字典（dict）

• 无序列表，3.6之后变为有序列表

• 创建字典

  v = {'k1':'v1',}
  print(type(v))	#<class 'dict'>
  #info = {键:值,键:值,键:值,键:值,键:值,}
  

• 字典取值

  #获取单个值
  info = {'k1':'v1','k2':'v2','k3':'v3','k4':'v4',}
  print(info['k3'])	#v3
  

• 字典类型内置函数

  • keys获取字典中所有的键

    info = {'k1':'v1','k2':'v2','k3':'v3','k4':'v4',}
    for i in info.keys():
        print(i)	#k1 k2 k3 k4
    

  • values获取字典中所有的键

    info = {'k1':'v1','k2':'v2','k3':'v3','k4':'v4',}
    for i in info.values():
        print(i)	#v1 v2 v3 v4
    

  • 以列表返回可遍历的(键, 值) 元组数组

    info = {'k1':'v1','k2':'v2','k3':'v3','k4':'v4',}
    for i,a in info.items():
        print(i,a)	
    

4.7、集合（set）

• 无序列表，值不重复

• 集合类型内置函数

  • 添加

    • add在集合末尾添加

      v = {'aaa','bbb',111,333}
      v.add('345')
      print(v)	#{'aaa','bbb',111,333,'345'}
      

    • 批量更新

      v = {'aaa','bbb',111,333}
      v.update({'cvb','ni'})
      print(v)	#{'ni', 'aaa', 'bbb', 'cvb', 333, 111}
      

  • 删除

    • discard按照元素删除

      v = {'aaa','bbb',111,333}
      v.discard(111)
      print(v)	#{'aaa','bbb',333}
      

  • 求集运算

    • intersection交集

      • 生成X&Y中都有的值创建集合赋值给变量

        v = {'11',2,'sw','22'}
        a = v.intersection({1,2,'sw'})
        print(a)	#{2,'sw'}
        

    • union并集

      • 把两个集合的合成一起，把重复的去除，然后生成一个集合

        v = {'11',2,'sw','22'}
        a = v.union({1,2,'sw'})
        print(a)	#{'22', '11', 2, 1, 'sw'}
        

    • difference差集

      • 把y中存在的x中也存在的值删除，剩余的值生成新的集合

        v = {'11',2,'sw','22'}
        a = v.difference({1,2,'sw'})
        print(a)	#{'11', '22'}
        

    • symmetric_difference对称差集

      • 把x中存在的Y中不能存在的和Y中存在的X中不存在的值，生成新的集合

        v = {'11',2,'sw','22'}
        a = v.symmetric_difference({1,2,'sw'})
        print(a)	#{1, '11', '22'}
        
        

4.8、公共功能

1. len计算长度

   • 字符串

     v = 'sdfgggg'
     print(len(v))	#7
     

   • 列表

     v = ['1',2,4,'aaaa']
     print(len(v))	#4
     

   • 元组

     v = ('1',2,4,'aaaa')
     print(len(v))	#4
     

   • 字典

     • 独特：一组键值对为一个元素

     v = {'k1':'v1','k2':'v2'}
     print(len(v))	#2
     

   • 集合

     v = {'k1',1,3,'sss'}
     print(len(v))	#4
     

2. 索引

   • 字符串

     str1  ='12dasdasdas'
     print(str1[2])	#d
     

   • 列表

     v = ['1',2,4,'aaaa']
     print(v[2])	#4
     v[2] = '66'
     print(v)	#['1', 2, '66', 'aaaa']
     

   • 元组

     • 无法通过索引修改值

     v = (1,'2','222','asd')
     print(v[1])	#2
     

   • 字典

     v = {'k1':'v1','k2':'v2','k3':'v3','k4':'v4',}
     print(v['k1'])	#v1
     v['k3'] = 666
     print(v)	#{'k1': 'v1', 'k2': 'v2', 'k3': 666, 'k4': 'v4'}
     

3. 切片

   取前不去后

   • 字符串

     str1  ='12dasdasdas'
     print(str1[2:4])	#da
     

   • 列表

     str1  = ['1',2,4,'aaaa','22222']
     print(str1[2:4])	#[4, 'aaaa']
     

   • 元组

     str1  = (1,2,4,'aaaa','22222')
     print(str1[2:4])	#(4, 'aaaa')
     

4. 步长

   • 字符串

     #示例一从第二个字符开始第10个字符结束步长为2
     v = 'dsafdgerhfgdhasas'
     print(v[2:10:2])	
     #示例二反向打印
     v = 'dsafdgerhfgdhasas'
     print(v[::-1])
     

   • 列表

     #示例一
     v = [11,2,3,45,'aaa']
     print(v[1:4:2])	#[2, 45]
     #示例二反向打印
     v = [11,2,3,45,'aaa']
     print(v[::-1])	#['aaa', 45, 3, 2, 11]
     

   • 元组

     #示例1
     v = (1,2,3,'111111',333,2222,5555)
     print(v[1:5:2])	#	(2, '111111')
     #反向打印
     v = (1,2,3,'111111',333,2222,5555)
     print(v[::-1])	#(5555, 2222, 333, '111111', 3, 2, 1)
     

4.9、内存转换

• 整型

  • -5~256

    v = -5
    a = -5
    print(id(v),id(a))#8791372584416 8791372584416
    

    v = 2571
    b = v
    print(id(v),id(b))	#34949616 34949616
    

• 字符串

  • ‘f_!’ * 3 更新
  • 相同全字母字符串不更新

• 查看内存地址

  • id()

• ==比较值是否相等

• is比较内存地址是否相等

4.10、可变数据类型和不可变数据类型

• 可变数据类型（指的是内部元素）

  • 列表
  • 字典
  • 集合

• 不可变数据类型

  • 字符串
  • 元组

4.11、强制类型转换

• 字符串

  v = 23
  a = str(v)
  print(type(a)) #<class 'str'>
  

• 整型

  v = '2345'
  a = int(v)
  print(a,type(a))	#2345 <class 'int'>
  

• 布尔值

  v = 0
  a = bool(v)
  print(a)	#False
  

• 列表

  v = 'sdsdwqed'
  a = list(v)
  print(a)	#['s', 'd', 's', 'd', 'w', 'q', 'e', 'd']
  

• 元组

  v = [11,22,33,'asdasd']
  a = tuple(v)
  print(a)	#(11, 22, 33, 'asdasd')
  

• 集合

  v = [11,22,33,33,'aaaa']
  a = set(v)
  print(a)	#{33, 11, 'aaaa', 22}
  

来源：https://www.cnblogs.com/sunyuhang1/p/12653802.html