首页 > 其他分享 >数据类型的内置方法 可变类型与不可变类型

数据类型的内置方法 可变类型与不可变类型

时间:2023-01-17 23:56:18浏览次数:39  
标签:内置 name 索引 18 数据类型 t1 print l1 类型

数据类型的内置方法

什么是数据类型的内置方法?

数据类型自带的操作方法或功能

调用数据类型的内置的方法的方式是:

句点符

数据类型.方法名()

eg:
	变量名.方法名()
    数据值.方法名()

1.整型相关操作方法

  • 类型转换

    int(待转换的数据类型)

    1.浮点型可以转整型 '只要小数点前面的整数 不做四舍五入'
    
    2.字符串可以转整型 '但是字符串内部必须是整数才可以'
    
    3.布尔值的使用 int(True) #1  int(False) #0
    
    4.其他类型转整型会报错
    
  • 进制数转换

    十进制转其他进制:
    十进制转二进制>>bin()
    十进制转八进制>>oct()
    十进制转十六进制>>hex()
    
    '''
    0b >>> 二进制标识
    0o >>> 八进制标识
    0x >>> 十六进制标识
    数字开头没有任何标识的激素hi十进制
    '''
    
    其他进制转十进制
    '''自动转'''
    二进制转十进制>>int(0b0101110101)
    二进制转八进制>>int(0o155)
    二进制转十六进制>>int(0x64)
    '''手动转'''
    二进制转十进制>>int('0b0101110101',2)
    八进制转十进制>>int('0o155',8)
    十六进制
    转十进制>>int('0x64',16)
    

2.浮点型相关操作方法

  • 类型转换

    float(待转换的数据)

    1.整型可以转成浮点型 '后面跟一个小数点1.0'
    
    2.字符串可以转成浮点型 '但是字符串内必须是数字(整数或者小数)'
    
    3.布尔值的使用 int(True) #1.0  int(False) #0.0
    
    4.其他类型转浮点型会报错
    
  • 数学运算逻辑容易出错

    a = 23.00
    b = 1.2
    c = a * b
    print(c) # 27.599999999999998
    
    '''
    由以上举例得出:python对数字运算精确度很低,容易出错!
    如需要精准的计算需借助其他模块!
    '''
    

3.字符串相关操作方法

  • 类型转换

    str(待转换的数据)

    1.所有的数据类型都可以转换成字符串类型
    
    2.给所有数据类型前后加引号也可以转换成字符串类型
    
  • 常用内置方法

    • 1.索引取值(单个字符串)

      1.索引取值是从0开始的 顾头不顾尾
      2.超出索引的取值范围就会报错
      3.索引支持负数 [-1] 就是取最后一个
      
      s1 = 'abcde'
      print(s1[0])   # a
      print(s1[-1])  # e
      
    • 2.切片取值(多个字符)

      l1 = [1,2,3,4,5,6,7]
      print(l1[:])  # [1,2,3,4,5,6,7]全要
      print(l1[:3]) #[1,2,3]要前3个
      print(l1[2:]) #[3,4,5,6,7]前2个不要剩下的全要
      print(l1[2:5])#[3,4,5]要索引2-索引5之间的 索引顾头不顾尾 所以最后一位不拿
      print(l1[-3:-1])#[5,6] 从后往前拿
      
    • 3.修改切片间隔

      s1 = 'abcde'
      print(s1[0:5:1]) # abcde 取索引0~索引4的值且间隔1
      print(s1[0:5:2]) # ace   取索引0~索引4的值且间隔2
      print(s1[::2])   # ace   取所有值且间隔2
      
    • 4.统计字符次数

      len(待统计的变量名或数据值)

      s1 = 'abcde'
      print(len(s1))  # 5
      
    • 5.移除首尾指定字符

      strip(想要移除的符号)

      name = '$张三$'
      
      1)移除首尾所有指定字符
        print(name.strip('$'))   # 张三   
      2)移除首指定字符
        print(name.lstrip('$'))  # 张三$ 
      3)移除尾指定字符
        print(name.rstrip('$'))  # $张三  
      4)括号内不写默认移除空格
        print(name.strip())      # 张三   
        '常用于获取用户输入移除用户不小心打的空格'
      
    • 6.切割字符串中的指定字符

      split('')当字符串中有多个重复字符分割不同数据时,可切割该指定字符以列表的形式显示

      a = 'aaa|bbb|ccc'
      
      1)切割所有指定字符
        print(a.split('|'))  # ['aaa', 'bbb', 'ccc'] 
        #注意:此处可以用【解压赋值】依次赋值给不同变量名!
      2)从左往右切指定个数
        print(a.lsplit('|',maxsplit=1))  #['aaa', 'bbb|ccc'] 
      3)从右往左切指定个数
        print(a.rsplit('|',maxsplit=1)) #['aaa|bbb', 'ccc'] 
      
      
    • 7.字符串大小写相关

      uppre() lower() isupper() islower()常用于验证码

      a = 'aHGdb'
      1.将字符串全部转成大小写
      print(a.upper())
      print(a.lower())
      
      2.判断当前字符串是否为纯大小写 结果是布尔值
      print(a.isupper())
      print(a.islower())
      
    • 8.字符串格式化输出

      方式1):等价于%s 没优势
           lx = '我的名字是{},我的年龄是{}'
           print(lx.format('张三',18))
           #结果为:我的名字是张三,我的年龄是18
      方式2):支持索引取值,可以重复使用
           lx = '我的名字是{0},我的年龄是{1}{0}{1}'
           print(lx.format('张三',18))
           #结果为:我的名字是张三,我的年龄是18张三18
      方式3):支持关键字取值(按K取值),可重复使用
           lx = '名字是{name}{name}年龄是{age}'
           print(lx.format(name='张三',age=18))
           #结果为:名字是张三张三年龄是18
      方法4):最常用!!!*****************
           name = '张三'
           age = 18
           print(f'名字是{name}年龄是{age}')
           #结果为:名字是张三年龄是18
      
      
    • 9.判断字符串中是否是纯数字

      isdigit()判断是否为纯数字 常用于用户输入时校验 结果是布尔值

      print('123'.isdigit())  # True
      print('123a'.isdigit()) # False
      
  • 其他内置方法

    • 1.替换字符串中指定内容

      replace()括号内写被替换的字符与 想要替换的字符

      a='a a a b b b'
      
      1)从左往右替换所有指定内容
        print(a.replace('a','c'))
        #结果为:c c c b b b
      2)从左往右替换指定个数的内容
        print(a.replace('a','c',1))
        #结果为:c a a b b b
      
    • 2.字符串的拼接

      '' . join([a,b]) 引号中间可以加想要拼接的字符 也可以不写 a,b分别是想要拼接起来的数据

      a='张'
      b='三'
      
      方式1):直接用+号,但是易占用较多内存
          print(a+b)  # 张三
      方式2):直接*该字符串实现拼接多个
          print(a*2)  # 张张
      方式3):建议使用join方法!切可以在拼接中插入指定字符
          print(''.join([a,b]))   # 张三
          print('|'.join([a,b]))  # 张|三
      
    • 3.统计指定字符出现的次数

      count()统计个数

      a='aabcdef'
      print(a.count('a')) #2
      '''统计a出现的次数'''
      
    • 4.判断字符串开头或者结尾

      startswith()判断开头是否为某个值

      endswith()判断结尾是否为某个值

      a='hello'
      
      #判开头是否是'he'
        print(a.startswith('he')) # True
      #判断结尾是否是'lo'
        print(a.endswith('lo')) # True
      
      
    • 5..查找某个字符对应索引值

      index() 存在则返回索引值 如果有相同的 则只会返回从左边数第一个查到的某个字符的索引值 不存在则报错

      find()存在则返回索引值 如果有相同的 则只会返回从左边数第一个查到的某个字符的索引值 不存在返回-1

      a='helloh'
      
      #获取'h'的索引值 不存在则报错
        print(a.index('h')) # 0
      #获取'a'的索引值 不存在则返回-1
        print(a.find('a'))  # -1
      
      
    • 6.正文相关转换首字母大写

      title() 将所有字符串的首字母大写

      capitalize() 将第一个字符串的首字母大写

      a = 'my name is zhangsan'
      1)将所有单词的首字母大写
        print(a.title())
        #结果为:My Name Is Zhangsan
      2)将字符串第一个字母大写
        print(a.capitalize())
        #结果为:My name is zhangsan
      
      

4.列表相关操作方法

  • 类型转换

    list(其他数据类型)

    能够被for循环的数据都可以转换成列表

    支持for循环的数据类型有:列表、字典(只有k参与)、元组、集合、字符串

    字符串、字典、元组、集合:
    
    print(list('123'))  # ['1', '2', '3']
    print(list({'name':'张三','age':'18'}))  # ['name', 'age']
    print(list((1,2,3)))  # [1, 2, 3]
    print(list({1,2,3}))  # [1, 2, 3]
    
    
  • 常用内置方法

    • 1.索引取值(单个数据值)

      '''
      1.索引值是从0开始(顾头不顾尾)
      2.超出索引范围会直接报错
      3.索引可跟负数,[-1]为取最后一个
      '''
      l1 = [1, 2, 3]
      print(l1[0])   # 1
      print(l1[-1])  # 3
      
      
    • 2.切片取值(多个数据值)

      l1 = [1,2,3,4,5,6,7]
      print(l1[:])  # [1,2,3,4,5,6,7]全要
      print(l1[:3]) #[1,2,3]要前3个
      print(l1[2:]) #[3,4,5,6,7]前2个不要剩下的全要
      print(l1[2:5])#[3,4,5]要索引2-索引5之间的 索引顾头不顾尾 所以最后一位不拿
      print(l1[-3:-1])#[5,6] 从后往前拿
      
    • 3.修改切片间隔

      l1 = [1,2,3,4,5]
      print(l1[0:5:1]) # [1,2,3,4,5] 取索引0~索引4的值且间隔1
      print(l1[0:5:2]) # [1,3,5]     取索引0~索引4的值且间隔2
      print(l1[::2])   # [1,3,5]     取所有值且间隔2
      
      
    • 4.统计列表数据值个数

      len() 统计数据值个数

      l1 = [1,2,3,4,5]
      print(len(l1))  # 5
      
      
    • 5.修改数据值

      通过索引找出想要修改的数据值 直接赋一个新的数据值

      l1 = [1,2,3,4,5]
      l1[0] = 'z'
      print(l1)
      #结果为:['z',2,3,4,5]
      
      
    • 6.添加数据值

      append()尾部追加

      insert()括号内跟索引 与 想要插入的数据值

      extend()合并两个列表

      1)尾部追加数据值
        l1 = [1, 2, 3, 4, 5]
        l1.append('zzz')
        print(l1)
        #结果为:[1, 2, 3, 4, 5, 'zzz']
      2)任意位置插入数据值(在索引几的位置插入什么数据)
        l1 = [1, 2, 3, 4, 5]
        l1.insert(1,'zzz')
        print(l1)
        #结果为:[1, 'zzz', 2, 3, 4, 5]
      3)扩展列表、合并列表
        l1=[1,2,3]
        l2=[4,5,6]
      方式一:不建议使用
        print(l1+l2)
        #结果为:[1,2,3,4,5,6]
      方式二:底层是用for+append实现的
        l1.extend(l2)
        print(l1)
        #结果为:[1,2,3,4,5,6]
      
      
    • 7.删除数据

      del() eg:del l1[0] 删除列表1中的索引值为0的数据值

      remove()删除指定数据

      pop()弹出后可以赋给一个变量名 然后删除 也可以接着用

      l1 = [1,2,3,4,5]
      1)通用删除 del:(删除某个索引对应的值)
        del l1[0]
        print(l1)
        #结果为:[2, 3, 4, 5]
      2)指定删除 remove:(彻底删除指定的数据值)
        l1.remove(2)
        print(l1)
        #结果为:[1, 3, 4, 5]
      3)取出后删除 pop:(可以把取出的值赋值给一个变量)
        '括号内不写默认最后一个,0代表第一个,1代表第二个'
        l1.pop()
        print(l1)
        #结果为:[1, 2, 3, 4]
        a = l1.pop()
        print(a)
        #结果为:5
        pop常用于观展人数中,xxx退出观战
      
      
    • 8.查看数据值对应的索引值

      index() 查看某个数据的索引值

      l1=[1,2,3,4]
      print(l1.index(1))
      #结果为:0
      
      
    • 9.统计某个数据值出现的次数

      count()统计数据值出现的次数

      l1=[1,1,2,3,4,5]
      print(l1.count(1))
      #结果为:2
      
      
    • 10.数据值排序

      sort()升序

      sort(revrese = True)降序

      l1=[4,2,5,1,2,3]
      1)升序:
        l1.sort()
        print(l1)
        #结果为:[1, 2, 2, 3, 4, 5]
      2)降序:
        l1.sort(reverse=True)
        print(l1)
        #结果为:[5, 4, 3, 2, 2, 1]
      
      
    • 11.反转列表数据值顺序

      reverse()将列表反转

      跟升序降序不同

      l1=[4,2,5,1,2,3]
      l1.reverse()
      print(l1)
      #结果为:[3, 2, 1, 5, 2, 4]
      
      
    • 12.两个列表比较

      a = [99,11]
      b = [11,22,33]
      print(a > b)
      #结果为:True
      
      l1 = ['a','b']
      l2 = ['A','B']
      print(l1 > l2)
      #结果为True
      '''
      1.两个列表在比较大小时,是按照索引0来互相比较。
      2.不同数据类型之间无法比较
      3.a比A大的原因是因为中间涉及到字符编码。a=97 A=65
      '''
      
      

5.字典相关操作方法

  • 类型转换

    dict(其他数据类型)

    字典一般是直接定义 不类型转换

  • 常用内置方法

    • 1.字典取值

      按k取值

      .get()常用来取字典中的k键

      按k取值 k不存在就会报错
      
      d = {'name':'张三','age':18}
      print(d['name'])
      #结果为:张三
      print(d['xxx'])
      #结果为:会报错
      
      get取值 k不存在时返回none
      
      d = {'name':'张三','age':18}
      print(d.get('name'))
      #结果为:张三
      print(d.get('xxx'))
      #结果为:None
      
    • 2.修改字典v值

      直接按k键 = 想要修改的新数据值

      d = {'name':'张三','age':18}
      d['name']='李四'
      print(d)
      #结果为:{'name': '李四', 'age': 18}
      
      
    • 3.新增键值对

      当k存在时 修改k对应的v值

      当k不存在时 新增键值对

      d = {'name':'张三','age':18}
      d['pwd']=123
      print(d)
      #结果为:{'name': '张三', 'age': 18, 'pwd': 123}
      
      
    • 4.删除数据

      del 直接删除

      pop() 可以给弹出的数据值绑定一个变量名 接着用

      d = {'name':'张三','age':18}
      
      1)del d['name'] #删除name的键值对
      
      2)a = d.pop('name')
        print(a)#打印出来的就是删除掉的V值
        print(d)#打印出来的就是删除后的列表
      
      
      
    • 5.统计字典中的键值对个数

      len()统计字典中键值对的个数

      d = {'name':'张三','age':18}
      print(len(d))
      #结果为:2
      
      
    • 6.获取所有键、值、键值对数据

      keys() 获取所有键 k

      values()获取所有值 v

      items()获所有键值对 k:v 支持for循环

      d = {'name':'张三','age':18}
      d = {'name':'张三','age':18}
      
      获取所有【键】
          print(d.keys())   # dict_keys(['name', 'age'])
      获取所有【值】
          print(d.values()) # dict_values(['jason', 18])
      获取所有【键值对】(组成列表套元组形式)
          print(d.items())  # dict_items([('name', 'jason'), ('age', 18)])
      
          
      items获取的值 支持for循环:
      for k,v in d.items():
          print(f'{k}:{v}')
          #结果为:
          #name:jason
          #age:18
      
      
    • 7.快速构造字典

      dict.formkeys( [ ' ' , ' ' ],' ' )

      快速生成一个值相同的字典
      '第一个列表里的数据值当作键,第二个是公共的数据值(所有键的值都相同)'
      
      d1=dict.fromkeys(['name','pwd','hobby'],123)
      print(d1)
      #结果为:{'name': 123, 'pwd': 123, 'hobby': 123} 后期可以再单个修改对应的值数据
      
      
      笔试题:
      res=dict.fromkeys(['name','pwd'],[])
      print(res)#{'name': [], 'pwd': []}
      res['name'].append('jason')
      res['pwd'].append(123)
      print(res)#{'name': ['jason', 123], 'pwd': ['jason', 123]}
      '当第二个公共数据值是可变类型的 通过任何键调用内置方法去修改值时会影响所有的键'
      
      
    • 8.从列表中取出最后的键值对

      popitem()

      d={'name':'jason','age':18,'pwd':'123'}
      print(d.popitem()) # 也可以赋值给一个变量名,打印变量名
      #打印第一次结果为:('pwd', '123')  
      print(d.popitem())
      #打印第二次结果为:('age', 18)
      print(d)
      #此时打印字典的结果为:{'name': 'jason'}
      
      当没有键值对可打印时会报错
      
      

6.元组相关操作方法

  • 类型转换

    tuple(其他类型数据)

    支持for循环的数据类型都支持转成元组:列表、字典、字符串、集合

    print(tuple([1,2,3])) # (1,2,3)
    print(tuple({'name':'张'})) # ('name',)
    print(tuple((1,2,3))) # (1,2,3)
    print(tuple({1,2,3})) # (1,2,3)
    
    
  • 常用内置方法

    • 注意:

      注意:
      1.元组内如果只有一个数据值,结尾要跟逗号
          t1 = () #空元组
          t1 = (1,)
      2.元组内索引绑定的内存地址不能被修改#除非是可变类型[元组里面的列表就可以增加或者删除]
          t1 = (1, 2, 3, [1, 2])
          # t1.append(5) #结果会报错!
          t1[-1].append(5)
          print(t1)  # (1, 2, 3, [1, 2, 5])
      3.元组不能新增或删除数据#除非是可变类型
      
      
    • 1.索引取值

      t1=(1,2,3,4,5)
      print(t1[0])   # 1
      print(t1[-1])  # 5
      
      
    • 2.切片操作

      t1=(1,2,3,4,5)
      print(t1[:])   # (1,2,3,4,5) 取所有值
      print(t1[:3])  # (1,2,3) 取索引0~索引2的值
      print(t1[1:3])  # (2,3) 取索引1~索引2的值
      print(t1[-3:-1])  # (3,4) 取倒数第二(包含)~倒数第一(不包含)的值
      
      
    • 3.切片间隔/方向

      t1=(1,2,3,4,5,6)
      print(t1[0:5:1]) # (1,2,3,4,5) 取索引0~索引4的值且间隔1
      print(t1[0:5:2]) # (1,3,5)   取索引0~索引4的值且间隔2
      print(t1[::2])   # (1,3,5)   取所有值且间隔2
      print(t1[::-1])  # (6,5,4,3,2,1) 取所有值并改变字符串方向(后进先出)
      
    • 4.统计数据值个数

      len()想要统计的数据

      t1=(1,2,3,4,5,6)
      print(len(t1))  # 6
      
      
    • 5.统计某个数据值出现的次数

      count()

      t1=(1,2,3,4,5,6)
      print(t1.count(2))  # 1
      
      
    • 6.统计元组内对应索引值

      index()

      t1=(1,2,3,4,5,6)
      print(t1.index(1))  # 0
      
      

7.集合相关操作方法

  • 类型转换

    set(其他类型数据)

    print(set('abc'))  # {'a','b','c'} 字符串
    print(set([1,2,3]))  # {1, 2, 3} 列表
    print(set({'name':'jason'}))  # {'name'} 字典
    print(set((1,2,3)))  # {1, 2, 3} 元组
    
    整型、浮点型、布尔值会报错
    
    注意:
    1.集合里的'数据值'必须是不可变类型(整型、浮点型、字符串、元组)
    2.集合内是无序的 没有索引概念
    3.如果想单独取数据值应该转成列表去取。
    
    
  • 常用内置方法

    集合不常用 只在去重、关系运算时才会考虑使用集合

    • 1.去重

      先转成列表在转成集合

      eg:把以下列表去重
      l1=[1,2,3,2,1,3]
      s1=set(l1) #把该列表转成集合
      l1=list(s1) #把该集合再转回列表
      print(l1)
      #结果为:[1, 2, 3]
      
      '集合的去重是无序的,有时候无法保留原先顺序'
      
      
    • 2.关系运算

      常用做差异校验
      eg:模拟两个人的好友
      f1 = {'jason','tony','oscar','jerry'}
      f2 = {'kevin','jerry','jason','lili'}
      
      1.求f1和f2的共同好友
      print(f1 & f2) #{'jason','jerry'}
      2.求是f1单独认识的好友
      print(f1 - f2)#{'oscar','tony'}
      3.求f1和f2所有的好友
      print(f1 | f2)#{'oscar','jason','kevin','lili','tony','jerry'}
      4.求f1和f2各自单独认识的好友
      print(f1 ^ f2)#{'lili','oscar','tony','kevin'}
      5.父集、子集
      print(f1 < f2)#false
      print(f1 > f2)#false
      '集合在做父子比较时是依照谁包含谁来判断'
      
      

可变类型与不可变类型

可变类型 不可变类型
字典、列表、集合 整型、浮点型、字符串、布尔值
值改变、内存地址不变(改自身) 值改变、内存地址也变(产生一个新的结果)

1.不可变类型

#值改变,内存地址也变(产生新的结果)
s1='$$jason$$'
s1.strip('$')

'由于产生的是新的结果,所以打印原字符串没有变化'
print(s1)  
#结果为:$$jason$$

'因为产生了新的结果,所以可以打印出来(可直接打印出来,也可以赋值一个变量名接收后打印)''
print(s1.strip('$'))  
#结果为:jason

2.可变类型

 #值改变,内存地址不变(改自身)
l1=[11,22,33]
l1.append('z')

'由于改的是自身 所以打印原本的列表就是修改后的列表'
print(l1)  
#结果为:[11,22,33,'z']

'因为没有产生新的结果,所以打印出来的是None'
print(l1.append('z'))  
#结果为:None

标签:内置,name,索引,18,数据类型,t1,print,l1,类型
From: https://www.cnblogs.com/lzy199911/p/17058956.html

相关文章

  • python基础: 数据类型及其内置方法、类型转换
    目录基本数据类型数据类型的概述1.数据类型之整形--int2.数据类型之浮点型--float3.数据类型之字符型,也称字符串类型--str4.数据类型之列表--list5.数据类型之字典--dict6.......
  • python基础: python语法之注释、PEP8规范说明、变量与常量、变量的本质、命名规范、命
    目录python基础python语法之注释PEP8规范说明变量与常量变量的本质命名规范命名风格常量基本数据类型python基础python语法之注释注释:是对所写的代码的解释说明三种......
  • java 基本数据类型 各占多少字节 有效位数
    逻辑类型:boolean整数类型:byte、short、int、long字符类型:char浮点类型:float、doubleint类型4个字节,一个字节8个bit(比特),取值范围:-2^31~(2^31)-1byte类型1个字节取值范围:-2......
  • 数据类型及常用方法
    数据类型及常用方法目录数据类型整型int浮点型float字符串str列表list字典dict布尔bool元组tuple集合set数据类型1.什么是数据类型 在日常生活中数据的表现......
  • 计算机基础 数据类型 流程控制 字符编码
    目录计算机基础数据类型流程控制字符编码一、关于计算机、编程语言、数据类型、及运算符1.关于计算机2.关于进制数3.关于单位换算4.计算机五大组成部分5.计算机三大核心......
  • C语言bool类型
    C89没有定义布尔类型,所以C语⾔判断真假时以0为假,⾮0为真。所以我们通常使⽤逻辑变量的做法:1//宏定义布尔类型23#defineBOOLint45#defineTRUE167......
  • 学习TypeScrip9(元组类型)
    如果需要一个固定大小的不同类型值的集合,我们需要使用元组。 元组就是数组的变种元组(Tuple)是固定数量的不同类型的元素的组合。元组与集合的不同之处在于,元组中的元素类型......
  • 学习TypeScrip7(内置对象)
    JavaScript中有很多​​内置对象​​,它们可以直接在TypeScript中当做定义好了的类型。ECMAScript的内置对象​​Boolean​​、Number、​​string​​、​​RegExp​​......
  • MySQL查询精度丢失、varchar与bigint之间隐式类型转换的问题
    数据库查询过滤失效。今天在测试库上做一个关联查询时出现了捞出多余的值的情况,现在换个表名重现一下再解释。做项目时遇到一个奇怪的问题,关于mysql查询精度会有所丢失的......
  • 【剑指offer知识点】Java中无符号整型、如何与int/long类型互相转化
    [1]结论  Java中没有无符号数据类型(它就是这样设计的,我没查到为什么),​​byte​​​,​​short​​​,​​int​​​和​​long​​都是有符号数据类型。当我们逻辑上说一......