数据类型的内置方法

在日常生活中不同类型的数据具有不同的功能
eg:表格数据文件具有处理表格的各项功能(透视表 图形化 公式计算)
视频数据文件具有快进 加速等各项功能
...

1.整型int

  1.  # 方式在代码中展示出来的效果就是  名字()
  2.     # 类型转换
  3.     # res = '123'
  4.     # print(type(res))
  5.     # res = int(res)
  6.     # print(type(res))
  7.     '''int在做类型转换的时候 只能转换纯数字'''
  8.     # int('123.123')  # 报错 不识别小数点
  9.     # int('jason123')  # 报错 不识别除数字以外的数据
  10.     '''int其实还可以做进制数转换'''
  11.     print(bin(100))  # 将十进制的100转换成二进制  0b1100100
  12.     print(oct(100))  # 将十进制的100转换成八进制  0o144
  13.     print(hex(100))  # 将十进制的100转换成十六进制  0x64
  14.     # 0b开头为二进制数  0o开头为八进制数  0x开头为十六进制数
  15.     print(int('0b1100100', 2))  # 100
  16.     print(int('0o144', 8))  # 100
  17.     print(int('0x64', 16))  # 100

2.浮点型float

  1.      # 类型转换
  2.     res = '123.23'
  3.     # print(type(res))
  4.     # res = float(res)
  5.     # print(type(res))
  6.     print(float('123'))  # 123.0

3.字符串str

  1.  # 类型转换
  2.         print(str(123))
  3.         print(str(123.21))
  4.         print(str([1, 2, 3, 4]))
  5.         print(str({'name': 'jason', 'pwd': 123}))
  6.         print(str((1, 2, 3, 4)))
  7.         print(str(True))
  8.         print(str({1, 2, 3, 4}))
  9.     # 基本用法
  10.     res = 'hello world!'
  11.     # 1.索引取值
  12.     # print(res[1])  # e
  13.     # 2.切片操作  顾头不顾尾
  14.     # print(res[1:4])  # ell
  15.     # 3.步长操作
  16.     # print(res[1:10])  # ello worl
  17.     # print(res[1:10:2])  # el ol
  18.     # 4.索引支持负数
  19.     # print(res[-1])  # !  最后一位
  20.     # print(res[-5:-1])  # orld  顾头不顾尾
  21.     # print(res[-5:-1:-1])  # 方向冲突
  22.     # 5.统计字符串内部字符的个数
  23.     # print(len(res))  # 12
  24.     # 6.移除字符串首尾指定的字符    strip()
  25.     # name = '  jason  '
  26.     # print(name, len(name))
  27.     # print(len(name.strip()))  # 默认移除首尾的空格
  28.     # name1 = '$$jason$$'
  29.     # print(name1.strip('$'))  # jason
  30.     # print(name1.lstrip('$'))  # jason$$
  31.     # print(name1.rstrip('$'))  # $$jason
  33.     # username = input('username>>>:')
  34.     # username = username.strip()
  35.     # username = input('username>>>:').strip()
  36.     # if username == 'jason':
  37.     #     print('老板好')
  38.     # else:
  39.     #     print('去你妹的')
  40.     # 7.按照指定的字符切割字符串 split()    该方法的结果是一个列表
  41.     # res2 = 'jason|123|18'
  42.     # print(res2.split('|'))  # ['jason', '123', '18']
  43.     # print(res2.split('|', maxsplit=1))  # ['jason', '123|18']  maxsplit用于控制切割的次数
  44.     # print(res2.rsplit('|', maxsplit=1))  # ['jason|123', '18']
  45.     """如何查看数据类型都有哪些内置方法
  46.         句点符(.)
  47.     """

8.大小写

转全大写

print(res.upper()) # JASON123 JASON

转全小写

print(res.lower()) # jason123 jason

判断是否是纯大写

print(res.isupper())

print(res1.isupper())

判断是否是纯小写

print(res.islower())

print(res1.islower())

9. 判断字符串是否以指定的字符开头

9.1 判断开头

s1 = 'jason 123 newapeman heiheihei oldgirl'

print(s1.startswith('tony')) # False

print(s1.startswith('j')) # True

print(s1.startswith('jas')) # True

print(s1.startswith('jason')) # True

9.2判断结尾

print(s1.endswith('oldboy')) # False

print(s1.endswith('l')) # True

print(s1.endswith('rl')) # True

print(s1.endswith('oldgirl')) # True

10. 字符串内置方法 format()

第一种玩法 相当于%s占位符

s2 = 'my name is {} my age is {}'

print(s2.format('jason',18)) # my name is jason my age is 18

第二种玩法 大括号内写索引值可以打破顺序 并且可以反复使用相同位置的数据

s3 = '{1} my name is {1} my age is {0} {0} {0} {1} {1}'

print(s3.format('jason', 18))

第三种玩法 大括号内写变量名

s4 = '{name1} my name is {name1} my age is {age} {name1} {name1}'

print(s4.format(name1='jason', age=18))

11.字符串的拼接

方式1 字符串相加

print('hello' + 'world')

方式2 join方法

12.替换字符串中指定的字符

13. 判断字符串中是否是纯数字


'''实际案例'''

guess_age = input('请输入猜测的年龄>>>:').strip()

if guess_age.isdigit():

guess_age = int(guess_age)

else:

print('你能不能好好输')

14. 需要简单了解的内置方法

4.列表的内置方法list

  • 列表内一般都会存储相同数据类型的数据
  • 只有可迭代对象的数据类型才能转换成列表，不然就会报错

1. 修改值

name_list = ['jason', 'kevin', 'tony', 'jack']

name_list[0] = 666
print(name_list) # [666, 'kevin', 'tony', 'jack']

2. 添加值

方式1 尾部追加(将括号内的数据当成一个整体追加到列表末尾)
name_list.append(666)
print(name_list) # ['jason', 'kevin', 'tony', 'jack', 666]
name_list.append([666, 777, 888, 999])
print(name_list) # ['jason', 'kevin', 'tony', 'jack', [666, 777, 888, 999]]
方式2 插入元素(将括号内的数据当成一个整体插入到索引指定位置)
name_list.insert(0, 'heiheihei')
print(name_list) # ['heiheihei', 'jason', 'kevin', 'tony', 'jack']
name_list.insert(2, 'hahaha')
print(name_list) # ['jason', 'kevin', 'hahaha', 'tony', 'jack']
name_list.insert(0, [11, 22, 33])
print(name_list)
方式3 扩展元素(相当于for循环+append操作)
name_list.extend([111, 222, 333, 444, 555])
print(name_list) # ['jason', 'kevin', 'tony', 'jack', 111, 222, 333, 444, 555]

3. 列表删除数据

删除数据
方式1 通用删除方式
del name_list[1] # 根据索引直接删除 del是关键字delete缩写
print(name_list) # ['jason', 'tony', 'jack']
方式2 remove() 括号内指定需要移除的元素值
name_list.remove('jason')
print(name_list)
print(name_list.remove('jason')) # None
方式3 pop() 括号内指定需要弹出的元素索引值 括号内如果不写参数则默认弹出列表尾部元素
name_list.pop(1)
print(name_list)
name_list.pop()
print(name_list)
print(name_list.pop()) # jack

3. 列表删除数据

删除数据
方式1 通用删除方式
del name_list[1] # 根据索引直接删除 del是关键字delete缩写
print(name_list) # ['jason', 'tony', 'jack']
方式2 remove() 括号内指定需要移除的元素值
name_list.remove('jason')
print(name_list)
print(name_list.remove('jason')) # None
方式3 pop() 括号内指定需要弹出的元素索引值 括号内如果不写参数则默认弹出列表尾部元素
name_list.pop(1)
print(name_list)
name_list.pop()
print(name_list)
print(name_list.pop()) # jack

4.升序降序

  1. l1 = [44, 22, 11, 33, 99, 77, 88, 66]
  2. # l1.sort()  # 默认是升序
  3. # l1.sort(reverse=True)  # 参数指定 降序
  4. # print(l1)
  5. # l1.reverse()  # 顺序颠倒
  6. # print(l1)

5. 列表的切片

  1. l1 = [44, 22, 11, 33, 99, 77, 88, 66]
  2. # print(l1[1:5])
  3. # print(l1[::-1])  # 冒号左右两边不写数字默认全都要
  4. # print(l1[:5])  # [44, 22, 11, 33, 99]  左边不写默认从头开始
  5. # print(l1[1:])  # [22, 11, 33, 99, 77, 88, 66]  右边不写默认到尾部

6. 列表比较大小

  1.  ll1 = [999, 111]
  2.  ll2 = [111, 222, 333, 444, 555, 666, 777, 888]
  3.  print(ll1 > ll2)  # True  列表比较运算采用相同索引元素比较 只要有一个比出了结果就直接得出结论
  4.  s1 = 'hello world'
  5.  s2 = 'abc'
  6.  print(s1 > s2)  # 字符串比较大小也是按照索引位置内部转成ASCII对应的数字比较

5. 字典的内置方法dict

1. 取值

  1. dic = {
  2.     'name': 'jason',
  3.     'age': 18,
  4.     'hobbies': ['play game', 'basketball']
  5. }
  6.  print(dic['name'])
  7.  print(dic['pwd'])    #  报错  这个方法不推荐使用
  8.  print(dic.get('name'))  # jason   强烈推荐
  9.  # 即使k不存在  不会报错，会返回值：None
  10.  print(dic.get('pwd', '哈哈哈'))  # 'pwd'不存在返回值:'哈哈哈'   强烈推荐

2. 修改值

  1. dic = {
  2.     'name': 'jason',
  3.     'age': 18,
  4.     'hobbies': ['play game', 'basketball']
  5. }
  6. # 按k修改值 新增键值对(使用频率最高)
  7.  dic['name'] = 'jasonNB'  # 键存在为修改值
  8.  print(dic)
  9.  dic['hobbies'].append('read')
  10.  print(dic)
  11.  dic['pwd'] = 123  # 键不存在为新增键值对
  12.  print(dic)

3. 统计键值对个数


  2. dic = {
  3.     'name': 'jason',
  4.     'age': 18,
  5.     'hobbies': ['play game', 'basketball']
  6. }
  7. print(len(dic))  # 3

4. 成员运算

  1.  print('jason' in dic)   # False
  2.  print('name' in dic)   # True
  3. # 因为字典只暴露K值，V不暴露给外界

5. 删除元素

  1. # 方式1
  2.  del dic['name']
  3.  print(dic)
  4. # 方式2  指定k弹出键值对 给出v
  5.  print(dic.pop('age'))
  6.  print(dic)
  7. # 方式2是最经常用的，其他基本不用
  8. # 方式3  弹出键值对 组织成元组的形式 第一个元素是k第二个元素是v(了解)
  9.  print(dic.popitem())
  10.  print(dic)

6. keys( )、values( )、item( )

  1.  print(dic.keys())  # dict_keys(['name', 'age', 'hobbies'])  获取字典所有的键 看成列表即可
  2.  print(dic.values())  # dict_values(['jason', 18, ['play game', 'basketball']])  获取字典所有的值 看成列表即可
  3.  print(dic.items())  # dict_items([('name', 'jason'), ('age', 18), ('hobbies', ['play game', 'basketball'])])
  4. # 获取字典里面所有的键值对 组织成列表套元组的形式 元组内有两个元素 第一个是k第二个是v

7. 字典需要了解的方法

  1. dic = {
  2.     'name': 'jason',
  3.     'age': 18,
  4.     'hobbies': ['play game', 'basketball']
  5. }
  6. # 1.更新字典  键存在则修改 不存在则创建
  7.  dic.update({'name': 'jasonNB', 'pwd': 123})
  8.  print(dic)
  9. # 2.当键存在的情况下 不修改而是获取该键对应的值
  10.  print(dic.setdefault('name', 'jasonNB'))
  11.  print(dic)
  12. # 当键不存在的情况下 新增一组键值对 并且该方法的结果是新增的值
  13. print(dic.setdefault('pwd', '123'))
  14. print(dic)
  15. # 3.初始化字典
  16.  print(dict.fromkeys(['k1', 'k2', 'k3'], []))
  17. '''笔试题'''
  18.  res = dict.fromkeys(['k1', 'k2', 'k3'], [])
  19.  res['k1'].append(111)
  20.  res['k2'].append(222)
  21.  res['k3'].append(333)
  22.  res['k1'] = [111,222,333]
  23.  res['k1'].append(444)
  24.  print(res)

6. 元组的内置方法tuple

1. 元组的最重要的规则

小括号括起来 内部存放多个元素 元素与元素逗号隔开
元素可以是任意数据 但是元组内元素不支持‘修改’(索引指向的元素的内存地址不能改变)
也可以简单的认为它是一个不可变的列表

  1. # 元组第一道笔试题
  2.  t1 = (111)  # 整型
  3.  t2 = (11.11)  # 浮点型
  4.  t3 = ('hello')  # 字符串
  5. '''元组哪怕内部只有一个元素 也需要加上逗号'''
  6.  t1 = (111,)  # 元组
  7.  t2 = (11.11,)  # 元组
  8.  t3 = ('hello',)  # 元组
  9.     '''容器类型:内部可以存放多个值的数据类型都可以称之为容器类型
  10.     建议:所有的容器类型在存储数据的时候 如果内部只有一个元素
  11.         那么也推荐你加上逗号

2. 索引取值、切片操作、步长、统计个数、for循环

  1.  t = (111, 222, 333, 444, 555)
  2. # 1.索引取值
  3.  print(t[2])
  4.  print(t[-1])
  5. # 2.切片操作
  6.  print(t[1:5])
  7.  print(t[1:])
  8.  print(t[:])
  9. # 3.步长
  10.  print(t[1:5:2])
  11.  4.统计元组内元素的个数
  12.  print(len(t))  # 5
  13. # 5.for循环
  14.  for i in t:
  15.      print(i)

3. 类型转换

  1. # 类型转换  能够支持for循环的数据都可以转换成元组
  2.  print(tuple(111))
  3.  print(tuple(11.11))
  4.  print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')
  5.  print(tuple([11,22,33]))  # (11, 22, 33)
  6.  print(tuple({'name':'jason','pwd':123}))  # ('name', 'pwd')

7. 集合set

集合是大括号括起来，里面有多个元素，元素与元素之间用逗号隔开，元素类型是不可变类型，不能有重复的元素。

1. 去重

  1. # 1.定义空集合需要使用关键字set
  2.  s1 = set()
  3. # 2.类型转换  能够支持for循环的数据类型都可以转成集合(元素要是不可变类型)
  4. '''集合内元素是无序的'''
  5. # 去重
  6.  s1 = {1, 2, 2, 2, 3, 4, 3, 4, 3, 1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3}
  7.  print(s1)  # {1, 2, 3, 4}
  8.  name_list = ['kevin', 'jason', 'jason', 'jason', 'kevin', 'kevin']
  9. # 1.先将列表转换成集合
  10.  s1 = set(name_list)
  11. # 2.再将去重之后的集合转换成列表
  12.  l1 = list(s1)
  13.  print(l1)

  1. """课堂练习题"""
  2. ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
  3. # 基本要求:去重即可
  4.  s1 = set(ll)
  5.  ll1 = list(s1)
  6.  print(ll1)
  8. # 拔高要求:去重并保留原来的顺序
  9.  1.先定义一个新列表
  10.  new_list = []
  11.  # 2.for循环ll列表
  12.  for i in ll:
  13.      # 3.判断当前元素是否在新列表中
  14.      if i not in new_list:
  15.          # 3.1 如果不在 则添加到新列表
  16.          new_list.append(i)
  17.      # 3.2 如果在 则不管
  18.  print(new_list)

2. 集合关系运算

  1. # 关系运算
  2. """两个群体之间做差异比较    共同好友 共同关注..."""
  3. friends1 = {"zero", "kevin", "jason", "eg"}  # 用户1的好友们
  4. friends2 = {"Jy", "ricky", "jason", "eg"}  # 用户2的好友们
  5. # 1.求两个用户的共同好友
  6.  print(friends1 & friends2)  # {'jason', 'eg'}
  7. # 2.求两个用户所有的好友
  8.  print(friends1 | friends2)  # {'kevin', 'ricky', 'jason', 'zero', 'Jy', 'eg'}
  9. # 3.求用户1独有的好友
  10.  print(friends1 - friends2)  # {'zero', 'kevin'}
  11. # 4.求用户2独有的好友
  12.  print(friends2 - friends1)  # {'ricky', 'Jy'}
  13. # 5.求用户1和用户2各自的好友
  14.  print(friends1 ^ friends2)  # {'Jy', 'zero', 'kevin', 'ricky'}
  15. # 6.父集与子集
  16.  s1 = {11, 22, 33, 44}
  17.  s2 = {11, 33}
  18.  print(s1 > s2)  # 判断s1是否是s2的父集   True
  19.  print(s2 < s1)  # 判断s2是否是s1的子集   True
  20. '''死记硬背'''

python数据类型内置的方法的更多相关文章

  1. Python 的内置字符串方法（收藏专用）

    Python 的内置字符串方法(收藏专用) method 字符串 string python3.x  python 4.7k 次阅读  ·  读完需要 44 分钟 5 字符串处理是非常常用的技能,但 ...

  2. python数据类型内置方法

    内容概要 列表内置方法 字典内置方法 字符串转换成字典的方法 eval() 元组内置方法 元组相关笔试题 集合内置方法 列表内置方法 l1 = [2, 4, 5, 7, 3, 9, 0, 6] # 升 ...

  3. python数据类型内置方法 字符串和列表

    1.字符串 内置方法操作# a = 'qqssf'#1. print(a[-1:]) #按索引取,正向从0开始,反向从-1开始# print(len(a)) #取长度# a = 'qqssf'# 2. ...

  4. Python：内置split()方法

    描述 Python split()通过指定分隔符对字符串进行切片,如果参数num 有指定值,则仅分隔 num 个子字符串 语法 split()方法语法: str.split(str="&qu ...

  5. python常用数据类型内置方法介绍

    熟练掌握python常用数据类型内置方法是每个初学者必须具备的内功. 下面介绍了python常用的集中数据类型及其方法,点开源代码,其中对主要方法都进行了中文注释. 一.整型 a = 100 a.xx ...

  6. python循环与基本数据类型内置方法

    今天又是充满希望的一天呢 一.python循环 1.wuile与else连用 当while没有被关键'break'主动结束的情况下 正常结束循环体代码之后会执行else的子代码 "" ...

  7. 【python基础】第09回 数据类型内置方法 01

    本章内容概要 1.数据类型的内置方法简介 2.整型相关方法 3.浮点型相关方法 4.字符串相关方法 5.列表相关方法 本章内容详情 1.数据类型的内置方法简介 数据类型是用来记录事物状态的,而事物的状 ...

  8. python中其他数据类型内置方法

    补充字符串数据类型内置方法 1.移除字符串首尾的指定字符可以选择方向1: s1 = '$$$jason$$$' print(s1.strip('$')) # jason print(s1.lstrip ...

  9. Python成长之路第二篇（1）_数据类型内置函数用法

    数据类型内置函数用法int 关于内置方法是非常的多这里呢做了一下总结 (1)__abs__(...)返回x的绝对值 #返回x的绝对值!!!都是双下划线 x.__abs__() <==> a ...

随机推荐

  1. Block对变量的引用

    如果在 Block 内部使用外部的变量,Block 会持有这个变量.下面来看几中特殊的情况,看 Block 对变量的持有情况如何. typeof @interface X : NSObject @pr ...

  2. 从MyIE2平滑升级到Maxthon的完美方案

    经过几个Beta版本的测试MyIE2改名为Maxthon的新版浏览器终于发布了正式版本.喜欢MyIE2的朋友们也可以放心的将你的MyIE2升级为Maxthon了.以下是MyIE2平滑过渡到Mathxo ...

  3. 微服务8：通信之RPC实践篇（附源码）

    ★微服务系列 微服务1:微服务及其演进史 微服务2:微服务全景架构 微服务3:微服务拆分策略 微服务4:服务注册与发现 微服务5:服务注册与发现(实践篇) 微服务6:通信之网关 微服务7:通信之RPC ...

  4. Mybatis使用注解开发(未完)

    使用注解来映射简单语句会使代码显得更加简洁,但对于稍微复杂一点的语句,Java 注解不仅力不从心 注解在接口实现 @Select("SELECT * FROM user") Lis ...

  5. chili

    靶机准备 首先将靶机ova文件导入 网络模式改为NAT 扫描ip netdiscover -r 192.168.164.0/24 kali:192.168.164.137 渗透测试 扫描端口 nmap ...

  6. Vue中import和require的对比

    Vue中import和require的对比 一.前言 ​ vue框架想必是我们前端朋友们必学的知识点,说它难也没有那么难,说简单也没有那么简单,主要技术就是那么几个,可是里面的细节很多,有些时候我们会 ...

  7. 《HelloGitHub》第 72 期

    兴趣是最好的老师,HelloGitHub 让你对编程感兴趣! 简介 HelloGitHub 分享 GitHub 上有趣.入门级的开源项目. https://github.com/521xueweiha ...

  8. Redis的数据类型操作（二）

    1.String:key-value(做缓存) Redis中所有的数据都是字符串.命令不区分大小写,key是区分大小写的.Redis是单线程的.Redis中不适合保存内容大的数据. get.set.i ...

  9. 转：master公式(主方法)

    master公式(也称主方法)是利用分治策略来解决问题经常使用的时间复杂度的分析方法,(补充:分治策略的递归解法还有两个常用的方法叫做代入法和递归树法),众所众知,分治策略中使用递归来求解问题分为三步 ...

  10. hdu 1175 连连看 DFS_字节跳动笔试原题

    转载至:https://www.cnblogs.com/LQBZ/p/4253962.html Problem Description "连连看"相信很多人都玩过.没玩过也没关系, ...