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

晨汘上镱

数据类型的内置方法

什么是数据类型的内置方法？
​        数据类型自带的操作方法或功能
调用数据类型的内置的方法的方式是：
​        句点符

1. 数据类型.方法名（）
3. eg：
4.         变量名.方法名（）
5.     数据值.方法名（）

复制代码

1.整型相关操作方法

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

  复制代码
• 进制数转换
  1. 十进制转其他进制:
  2. 十进制转二进制>>bin()
  3. 十进制转八进制>>oct()
  4. 十进制转十六进制>>hex()
  6. '''
  7. 0b >>> 二进制标识
  8. 0o >>> 八进制标识
  9. 0x >>> 十六进制标识
  10. 数字开头没有任何标识的激素hi十进制
  11. '''
  13. 其他进制转十进制
  14. '''自动转'''
  15. 二进制转十进制>>int(0b0101110101)
  16. 二进制转八进制>>int(0o155)
  17. 二进制转十六进制>>int(0x64)
  18. '''手动转'''
  19. 二进制转十进制>>int('0b0101110101',2)
  20. 八进制转十进制>>int('0o155',8)
  21. 十六进制
  22. 转十进制>>int('0x64',16)

  复制代码

2.浮点型相关操作方法

• 类型转换
  float（待转换的数据）
  1. 1.整型可以转成浮点型 '后面跟一个小数点1.0'
  3. 2.字符串可以转成浮点型 '但是字符串内必须是数字（整数或者小数）'
  5. 3.布尔值的使用 int（True） #1.0  int（False） #0.0
  7. 4.其他类型转浮点型会报错

  复制代码
• 数学运算逻辑容易出错
  1. a = 23.00
  2. b = 1.2
  3. c = a * b
  4. print(c) # 27.599999999999998
  6. '''
  7. 由以上举例得出：python对数字运算精确度很低,容易出错！
  8. 如需要精准的计算需借助其他模块！
  9. '''

  复制代码

3.字符串相关操作方法

• 类型转换
  str（待转换的数据）
  1. 1.所有的数据类型都可以转换成字符串类型
  3. 2.给所有数据类型前后加引号也可以转换成字符串类型

  复制代码
• 常用内置方法
  
  
  
  • 1.索引取值（单个字符串）
    1. 1.索引取值是从0开始的 顾头不顾尾
    2. 2.超出索引的取值范围就会报错
    3. 3.索引支持负数 [-1] 就是取最后一个
    5. s1 = 'abcde'
    6. print(s1[0])   # a
    7. print(s1[-1])  # e

    复制代码
  • 2.切片取值（多个字符）
    1. l1 = [1,2,3,4,5,6,7]
    2. print(l1[:])  # [1,2,3,4,5,6,7]全要
    3. print(l1[:3]) #[1,2,3]要前3个
    4. print(l1[2:]) #[3,4,5,6,7]前2个不要剩下的全要
    5. print(l1[2:5])#[3,4,5]要索引2-索引5之间的 索引顾头不顾尾 所以最后一位不拿
    6. print(l1[-3:-1])#[5,6] 从后往前拿

    复制代码
  • 3.修改切片间隔
    1. s1 = 'abcde'
    2. print(s1[0:5:1]) # abcde 取索引0~索引4的值且间隔1
    3. print(s1[0:5:2]) # ace   取索引0~索引4的值且间隔2
    4. print(s1[::2])   # ace   取所有值且间隔2

    复制代码
  • 4.统计字符次数
    len（待统计的变量名或数据值）
    1. s1 = 'abcde'
    2. print(len(s1))  # 5

    复制代码
  • 5.移除首尾指定字符
    strip(想要移除的符号)
    1. name = '$张三$'
    3. 1)移除首尾所有指定字符
    4.   print(name.strip('$'))   # 张三   
    5. 2)移除首指定字符
    6.   print(name.lstrip('$'))  # 张三$
    7. 3)移除尾指定字符
    8.   print(name.rstrip('$'))  # $张三  
    9. 4)括号内不写默认移除空格
    10.   print(name.strip())      # 张三   
    11.   '常用于获取用户输入移除用户不小心打的空格'

    复制代码
  • 6.切割字符串中的指定字符
    split（''）当字符串中有多个重复字符分割不同数据时，可切割该指定字符以列表的形式显示
    1. a = 'aaa|bbb|ccc'
    3. 1)切割所有指定字符
    4.   print(a.split('|'))  # ['aaa', 'bbb', 'ccc']
    5.   #注意：此处可以用【解压赋值】依次赋值给不同变量名！
    6. 2)从左往右切指定个数
    7.   print(a.lsplit('|',maxsplit=1))  #['aaa', 'bbb|ccc']
    8. 3)从右往左切指定个数
    9.   print(a.rsplit('|',maxsplit=1)) #['aaa|bbb', 'ccc']

    复制代码
  • 7.字符串大小写相关
    uppre（） lower() isupper() islower()常用于验证码
    1. a = 'aHGdb'
    2. 1.将字符串全部转成大小写
    3. print(a.upper())
    4. print(a.lower())
    6. 2.判断当前字符串是否为纯大小写 结果是布尔值
    7. print(a.isupper())
    8. print(a.islower())

    复制代码
  • 8.字符串格式化输出
    1. 方式1)：等价于%s 没优势
    2.      lx = '我的名字是{},我的年龄是{}'
    3.      print(lx.format('张三',18))
    4.      #结果为：我的名字是张三,我的年龄是18
    5. 方式2)：支持索引取值，可以重复使用
    6.      lx = '我的名字是{0},我的年龄是{1}{0}{1}'
    7.      print(lx.format('张三',18))
    8.      #结果为：我的名字是张三,我的年龄是18张三18
    9. 方式3)：支持关键字取值(按K取值),可重复使用
    10.      lx = '名字是{name}{name}年龄是{age}'
    11.      print(lx.format(name='张三',age=18))
    12.      #结果为：名字是张三张三年龄是18
    13. 方法4)：最常用！！！*****************
    14.      name = '张三'
    15.      age = 18
    16.      print(f'名字是{name}年龄是{age}')
    17.      #结果为：名字是张三年龄是18

    复制代码
  • 9.判断字符串中是否是纯数字
    isdigit()判断是否为纯数字 常用于用户输入时校验 结果是布尔值
    1. print('123'.isdigit())  # True
    2. print('123a'.isdigit()) # False

    复制代码
  
  
• 其他内置方法
  
  
  
  • 1.替换字符串中指定内容
    replace()括号内写被替换的字符与 想要替换的字符
    1. a='a a a b b b'
    3. 1)从左往右替换所有指定内容
    4.   print(a.replace('a','c'))
    5.   #结果为：c c c b b b
    6. 2)从左往右替换指定个数的内容
    7.   print(a.replace('a','c',1))
    8.   #结果为：c a a b b b

    复制代码
  • 2.字符串的拼接
    '' . join([a,b]) 引号中间可以加想要拼接的字符 也可以不写 a，b分别是想要拼接起来的数据
    1. a='张'
    2. b='三'
    4. 方式1)：直接用+号,但是易占用较多内存
    5.     print(a+b)  # 张三
    6. 方式2)：直接*该字符串实现拼接多个
    7.     print(a*2)  # 张张
    8. 方式3)：建议使用join方法！切可以在拼接中插入指定字符
    9.     print(''.join([a,b]))   # 张三
    10.     print('|'.join([a,b]))  # 张|三

    复制代码
  • 3.统计指定字符出现的次数
    count（）统计个数
    1. a='aabcdef'
    2. print(a.count('a')) #2
    3. '''统计a出现的次数'''

    复制代码
  • 4.判断字符串开头或者结尾
    startswith()判断开头是否为某个值
    endswith（）判断结尾是否为某个值
    1. a='hello'
    3. #判开头是否是'he'
    4.   print(a.startswith('he')) # True
    5. #判断结尾是否是'lo'
    6.   print(a.endswith('lo')) # True

    复制代码
  • 5..查找某个字符对应索引值
    index（） 存在则返回索引值 如果有相同的 则只会返回从左边数第一个查到的某个字符的索引值 不存在则报错
    find（）存在则返回索引值 如果有相同的 则只会返回从左边数第一个查到的某个字符的索引值 不存在返回-1
    1. a='helloh'
    3. #获取'h'的索引值 不存在则报错
    4.   print(a.index('h')) # 0
    5. #获取'a'的索引值 不存在则返回-1
    6.   print(a.find('a'))  # -1

    复制代码
  • 6.正文相关转换首字母大写
    title() 将所有字符串的首字母大写
    capitalize() 将第一个字符串的首字母大写
    1. a = 'my name is zhangsan'
    2. 1)将所有单词的首字母大写
    3.   print(a.title())
    4.   #结果为：My Name Is Zhangsan
    5. 2)将字符串第一个字母大写
    6.   print(a.capitalize())
    7.   #结果为：My name is zhangsan

    复制代码
  
  

4.列表相关操作方法

• 类型转换
  list（其他数据类型）
  能够被for循环的数据都可以转换成列表
  支持for循环的数据类型有：列表、字典(只有k参与)、元组、集合、字符串
  1. 字符串、字典、元组、集合：
  3. print(list('123'))  # ['1', '2', '3']
  4. print(list({'name':'张三','age':'18'}))  # ['name', 'age']
  5. print(list((1,2,3)))  # [1, 2, 3]
  6. print(list({1,2,3}))  # [1, 2, 3]

  复制代码
• 常用内置方法
  
  
  
  • 1.索引取值（单个数据值）
    1. '''
    2. 1.索引值是从0开始(顾头不顾尾)
    3. 2.超出索引范围会直接报错
    4. 3.索引可跟负数,[-1]为取最后一个
    5. '''
    6. l1 = [1, 2, 3]
    7. print(l1[0])   # 1
    8. print(l1[-1])  # 3

    复制代码
  • 2.切片取值（多个数据值）
    1. l1 = [1,2,3,4,5,6,7]
    2. print(l1[:])  # [1,2,3,4,5,6,7]全要
    3. print(l1[:3]) #[1,2,3]要前3个
    4. print(l1[2:]) #[3,4,5,6,7]前2个不要剩下的全要
    5. print(l1[2:5])#[3,4,5]要索引2-索引5之间的 索引顾头不顾尾 所以最后一位不拿
    6. print(l1[-3:-1])#[5,6] 从后往前拿

    复制代码
  • 3.修改切片间隔
    1. l1 = [1,2,3,4,5]
    2. print(l1[0:5:1]) # [1,2,3,4,5] 取索引0~索引4的值且间隔1
    3. print(l1[0:5:2]) # [1,3,5]     取索引0~索引4的值且间隔2
    4. print(l1[::2])   # [1,3,5]     取所有值且间隔2

    复制代码
  • 4.统计列表数据值个数
    len() 统计数据值个数
    1. l1 = [1,2,3,4,5]
    2. print(len(l1))  # 5

    复制代码
  • 5.修改数据值
    通过索引找出想要修改的数据值 直接赋一个新的数据值
    1. l1 = [1,2,3,4,5]
    2. l1[0] = 'z'
    3. print(l1)
    4. #结果为：['z',2,3,4,5]

    复制代码
  • 6.添加数据值
    append（）尾部追加
    insert（）括号内跟索引 与 想要插入的数据值
    extend（）合并两个列表
    1. 1)尾部追加数据值
    2.   l1 = [1, 2, 3, 4, 5]
    3.   l1.append('zzz')
    4.   print(l1)
    5.   #结果为：[1, 2, 3, 4, 5, 'zzz']
    6. 2)任意位置插入数据值(在索引几的位置插入什么数据)
    7.   l1 = [1, 2, 3, 4, 5]
    8.   l1.insert(1,'zzz')
    9.   print(l1)
    10.   #结果为：[1, 'zzz', 2, 3, 4, 5]
    11. 3)扩展列表、合并列表
    12.   l1=[1,2,3]
    13.   l2=[4,5,6]
    14. 方式一：不建议使用
    15.   print(l1+l2)
    16.   #结果为：[1,2,3,4,5,6]
    17. 方式二：底层是用for+append实现的
    18.   l1.extend(l2)
    19.   print(l1)
    20.   #结果为：[1,2,3,4,5,6]

    复制代码
  • 7.删除数据
    del() eg：del  l1[0] 删除列表1中的索引值为0的数据值
    remove（）删除指定数据
    pop（）弹出后可以赋给一个变量名 然后删除 也可以接着用
    1. l1 = [1,2,3,4,5]
    2. 1)通用删除 del：(删除某个索引对应的值)
    3.   del l1[0]
    4.   print(l1)
    5.   #结果为：[2, 3, 4, 5]
    6. 2)指定删除 remove：(彻底删除指定的数据值)
    7.   l1.remove(2)
    8.   print(l1)
    9.   #结果为：[1, 3, 4, 5]
    10. 3)取出后删除 pop：(可以把取出的值赋值给一个变量)
    11.   '括号内不写默认最后一个,0代表第一个,1代表第二个'
    12.   l1.pop()
    13.   print(l1)
    14.   #结果为：[1, 2, 3, 4]
    15.   a = l1.pop()
    16.   print(a)
    17.   #结果为：5
    18.   pop常用于观展人数中，xxx退出观战

    复制代码
  • 8.查看数据值对应的索引值
    index() 查看某个数据的索引值
    1. l1=[1,2,3,4]
    2. print(l1.index(1))
    3. #结果为：0

    复制代码
  • 9.统计某个数据值出现的次数
    count（）统计数据值出现的次数
    1. l1=[1,1,2,3,4,5]
    2. print(l1.count(1))
    3. #结果为：2

    复制代码
  • 10.数据值排序
    sort（）升序
    sort（revrese = True）降序
    1. l1=[4,2,5,1,2,3]
    2. 1)升序：
    3.   l1.sort()
    4.   print(l1)
    5.   #结果为：[1, 2, 2, 3, 4, 5]
    6. 2)降序：
    7.   l1.sort(reverse=True)
    8.   print(l1)
    9.   #结果为：[5, 4, 3, 2, 2, 1]

    复制代码
  • 11.反转列表数据值顺序
    reverse()将列表反转
    跟升序降序不同
    1. l1=[4,2,5,1,2,3]
    2. l1.reverse()
    3. print(l1)
    4. #结果为：[3, 2, 1, 5, 2, 4]

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

    复制代码
  
  

5.字典相关操作方法

• 类型转换
  dict（其他数据类型）
  字典一般是直接定义 不类型转换
  
• 常用内置方法
  
  
  
  • 1.字典取值
    按k取值
    .get（）常用来取字典中的k键
    1. 按k取值 k不存在就会报错
    3. d = {'name':'张三','age':18}
    4. print(d['name'])
    5. #结果为：张三
    6. print(d['xxx'])
    7. #结果为：会报错
    9. get取值 k不存在时返回none
    11. d = {'name':'张三','age':18}
    12. print(d.get('name'))
    13. #结果为：张三
    14. print(d.get('xxx'))
    15. #结果为：None

    复制代码
  • 2.修改字典v值
    直接按k键 = 想要修改的新数据值
    1. d = {'name':'张三','age':18}
    2. d['name']='李四'
    3. print(d)
    4. #结果为：{'name': '李四', 'age': 18}

    复制代码
  • 3.新增键值对
    当k存在时 修改k对应的v值
    当k不存在时 新增键值对
    1. d = {'name':'张三','age':18}
    2. d['pwd']=123
    3. print(d)
    4. #结果为：{'name': '张三', 'age': 18, 'pwd': 123}

    复制代码
  • 4.删除数据
    del 直接删除
    pop() 可以给弹出的数据值绑定一个变量名 接着用
    1. d = {'name':'张三','age':18}
    3. 1)del d['name'] #删除name的键值对
    5. 2)a = d.pop('name')
    6.   print(a)#打印出来的就是删除掉的V值
    7.   print(d)#打印出来的就是删除后的列表

    复制代码
  • 5.统计字典中的键值对个数
    len（）统计字典中键值对的个数
    1. d = {'name':'张三','age':18}
    2. print(len(d))
    3. #结果为：2

    复制代码
  • 6.获取所有键、值、键值对数据
    keys（） 获取所有键 k
    values（）获取所有值 v
    items（）获所有键值对 k：v  支持for循环
    1. d = {'name':'张三','age':18}
    2. d = {'name':'张三','age':18}
    4. 获取所有【键】
    5.     print(d.keys())   # dict_keys(['name', 'age'])
    6. 获取所有【值】
    7.     print(d.values()) # dict_values(['jason', 18])
    8. 获取所有【键值对】(组成列表套元组形式)
    9.     print(d.items())  # dict_items([('name', 'jason'), ('age', 18)])
    11.    
    12. items获取的值 支持for循环：
    13. for k,v in d.items():
    14.     print(f'{k}:{v}')
    15.     #结果为：
    16.     #name：jason
    17.     #age：18

    复制代码
  • 7.快速构造字典
    dict.formkeys( [ ' ' , ' ' ],' ' )
    1. 快速生成一个值相同的字典
    2. '第一个列表里的数据值当作键，第二个是公共的数据值(所有键的值都相同)'
    4. d1=dict.fromkeys(['name','pwd','hobby'],123)
    5. print(d1)
    6. #结果为：{'name': 123, 'pwd': 123, 'hobby': 123} 后期可以再单个修改对应的值数据
    9. 笔试题：
    10. res=dict.fromkeys(['name','pwd'],[])
    11. print(res)#{'name': [], 'pwd': []}
    12. res['name'].append('jason')
    13. res['pwd'].append(123)
    14. print(res)#{'name': ['jason', 123], 'pwd': ['jason', 123]}
    15. '当第二个公共数据值是可变类型的 通过任何键调用内置方法去修改值时会影响所有的键'

    复制代码
  • 8.从列表中取出最后的键值对
    popitem()
    1. d={'name':'jason','age':18,'pwd':'123'}
    2. print(d.popitem()) # 也可以赋值给一个变量名,打印变量名
    3. #打印第一次结果为：('pwd', '123')  
    4. print(d.popitem())
    5. #打印第二次结果为：('age', 18)
    6. print(d)
    7. #此时打印字典的结果为：{'name': 'jason'}
    9. 当没有键值对可打印时会报错

    复制代码
  
  

6.元组相关操作方法

• 类型转换
  tuple（其他类型数据）
  支持for循环的数据类型都支持转成元组：列表、字典、字符串、集合
  1. print(tuple([1,2,3])) # (1,2,3)
  2. print(tuple({'name':'张'})) # ('name',)
  3. print(tuple((1,2,3))) # (1,2,3)
  4. print(tuple({1,2,3})) # (1,2,3)

  复制代码
• 常用内置方法
  
  
  
  • 注意：
    1. 注意：
    2. 1.元组内如果只有一个数据值,结尾要跟逗号
    3.     t1 = () #空元组
    4.     t1 = (1,)
    5. 2.元组内索引绑定的内存地址不能被修改#除非是可变类型[元组里面的列表就可以增加或者删除]
    6.     t1 = (1, 2, 3, [1, 2])
    7.     # t1.append(5) #结果会报错！
    8.     t1[-1].append(5)
    9.     print(t1)  # (1, 2, 3, [1, 2, 5])
    10. 3.元组不能新增或删除数据#除非是可变类型

    复制代码
  • 1.索引取值
    1. t1=(1,2,3,4,5)
    2. print(t1[0])   # 1
    3. print(t1[-1])  # 5

    复制代码
  • 2.切片操作
    1. t1=(1,2,3,4,5)
    2. print(t1[:])   # (1,2,3,4,5) 取所有值
    3. print(t1[:3])  # (1,2,3) 取索引0~索引2的值
    4. print(t1[1:3])  # (2,3) 取索引1~索引2的值
    5. print(t1[-3:-1])  # (3,4) 取倒数第二(包含)~倒数第一(不包含)的值

    复制代码
  • 3.切片间隔/方向
    1. t1=(1,2,3,4,5,6)
    2. print(t1[0:5:1]) # (1,2,3,4,5) 取索引0~索引4的值且间隔1
    3. print(t1[0:5:2]) # (1,3,5)   取索引0~索引4的值且间隔2
    4. print(t1[::2])   # (1,3,5)   取所有值且间隔2
    5. print(t1[::-1])  # (6,5,4,3,2,1) 取所有值并改变字符串方向(后进先出)

    复制代码
  • 4.统计数据值个数
    len（）想要统计的数据
    1. t1=(1,2,3,4,5,6)
    2. print(len(t1))  # 6

    复制代码
  • 5.统计某个数据值出现的次数
    count（）
    1. t1=(1,2,3,4,5,6)
    2. print(t1.count(2))  # 1

    复制代码
  • 6.统计元组内对应索引值
    index()
    1. t1=(1,2,3,4,5,6)
    2. print(t1.index(1))  # 0

    复制代码
  
  

7.集合相关操作方法

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

  复制代码
• 常用内置方法
  集合不常用 只在去重、关系运算时才会考虑使用集合
  
  
  
  • 1.去重
    先转成列表在转成集合
    1. eg：把以下列表去重
    2. l1=[1,2,3,2,1,3]
    3. s1=set(l1) #把该列表转成集合
    4. l1=list(s1) #把该集合再转回列表
    5. print(l1)
    6. #结果为：[1, 2, 3]
    8. '集合的去重是无序的,有时候无法保留原先顺序'

    复制代码
  • 2.关系运算
    1. 常用做差异校验
    2. eg：模拟两个人的好友
    3. f1 = {'jason','tony','oscar','jerry'}
    4. f2 = {'kevin','jerry','jason','lili'}
    6. 1.求f1和f2的共同好友
    7. print(f1 & f2) #{'jason','jerry'}
    8. 2.求是f1单独认识的好友
    9. print(f1 - f2)#{'oscar','tony'}
    10. 3.求f1和f2所有的好友
    11. print(f1 | f2)#{'oscar','jason','kevin','lili','tony','jerry'}
    12. 4.求f1和f2各自单独认识的好友
    13. print(f1 ^ f2)#{'lili','oscar','tony','kevin'}
    14. 5.父集、子集
    15. print(f1 < f2)#false
    16. print(f1 > f2)#false
    17. '集合在做父子比较时是依照谁包含谁来判断'

    复制代码
  
  

可变类型与不可变类型

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

1. #值改变，内存地址也变(产生新的结果)
2. s1='$$jason$$'
3. s1.strip('$')
5. '由于产生的是新的结果，所以打印原字符串没有变化'
6. print(s1)  
7. #结果为：$$jason$$
9. '因为产生了新的结果，所以可以打印出来(可直接打印出来,也可以赋值一个变量名接收后打印)''
10. print(s1.strip('$'))  
11. #结果为：jason

复制代码

2.可变类型

1. #值改变,内存地址不变(改自身)
2. l1=[11,22,33]
3. l1.append('z')
5. '由于改的是自身 所以打印原本的列表就是修改后的列表'
6. print(l1)  
7. #结果为：[11,22,33,'z']
9. '因为没有产生新的结果,所以打印出来的是None'
10. print(l1.append('z'))  
11. #结果为：None

复制代码

来源:https://www.cnblogs.com/lzy199911/p/17058956.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！