python之数据类型的内置方法

整型

用途
   # 年龄 生日 整数类型
定义方式
  age = 18  # age = int(18)
类型转换
  int()  #将括号内的数据转成整型
    # 待转换的数据内部只能是纯数字
进制转换
  0b开头表示二进制数
  0o开头表示八进制数
  0x开头表示十六进制数
    # print(bin(100))  # 将十进制的100转换成二进制对应的数    0b1100100
    # print(oct(100))  # 将十进制的100转换成八进制对应的数    0o144
    # print(hex(100))  # 将十进制的100转换成十六进制对应的数  0x64

    # print(int('0b1100100',2))  # 将2进制转换成十进制  100
    # print(int('0o144',8))  # 将8进制转换成十进制  100
    # print(int('0x64',16))  # 将16进制转换成十进制  100

浮点型

  # 身高 体重 薪资...
    float()   #可以是整数，也可以是小数

字符串

  作用：
    名字，性别，国籍，地址等描述信息

  定义：
    在单引号\双引号\三引号内，由一串字符组成
      name = 'hello world!'
  1、按索引取值(正向取+反向取) ：只能取
  '''索引是从0开始的'''
  '''反向从-1开始'''
    正数表示从左往右  负数从右往左
  2、切片(顾头不顾尾，步长)
      '''截取某一段内容'''
        # print(name[1:4])  # 1 2 3  顾头不顾尾
        # print(name[-1:-5:-1])  # 默认的切片方向都是从左往右   -1修改成从右往左  和!dlr一样
        # print(name[1:4:2])  # 第三个参数表示步长  间隔几个

  3、长度len
    '''统计字符串里面的字符个数'''
      # print(len(name))  # 12   空格也算字符

  4、成员运算in和not in
    # print('hello' in name)
    # print('jason' not in name)
  5、移除指定的首尾字符strip(******)
     username = input('username>>>:')  # ' jason '
     将首尾空格移除
       username = username.strip()

     两步合并成一步
       username = input('username>>>:').strip()
     #n1 = '$$jason$$'
     移除首指定的字符
      # print(n1.lstrip('$'))  # jason$$            left
     移除尾指定的字符
      # print(n1.rstrip('$'))  # $$jason            right

  6、切分split(******)
    '''按照指定g字符串'''
      # res = 'jason|123|read'
      # print(res.split('|'))  # ['jason', '123', 'read']
        # 1.指定切割的字符不保留
        # 2.切割之后的结构是一个列表(重要)
      # res.split('|', maxsplit=1) # ['jason', '123|read']  从左往右切割指定的次数
      # print(res)
      # print(res.rsplit('|',maxsplit=1))  # ['jason|123', 'read']  从右往左切割指定的次数
  7、循环
    for i in name:
        print(i)  # 依次获取字符串中单个单个的字符
  8、  
    # res = 'jason egon kevin tony'
    # 判断字符串是否以jason开头
    # print(res.startswith('jason'))  # True
    # 判断字符串是否以tony结尾
    # print(res.endswith('tony'))  # True


      # res = 'My NAmE Is JASon 666'
      # 将所有的英文字母转成大写
      # print(res.upper())  # MY NAME IS JASON 666
      # 将所有的英文字母转成小写
      # print(res.lower())  # my name is jason 666
      
      # 字符串格式化输出
      # %s %d
      # format
      第一种  与%s一致        按照个数位置 一一传值
        # res = 'my name is {} my age is {}'
        # print(res.format('jason',18))
      第二种  按照索引取值     可以反复使用
        # res = 'my name is {0} my age is {1} {0} {0} {0}'
        # print(res.format('jason',18))
      第三种  指名道姓取值     可以反复使用
        # res = 'my name is {name} my age is {age} {name} {name} {name}'
        # print(res.format(name='jason',age=18))

      # 统计字符串中 指定字符出现的个数
        # res = 'jason a a a a  sdf se sdf we ras dsa dw e asdsa dwqd sadsa dsadas'
        # print(res.count('a'))  # 13
        # print(res.count('a', 1, 10))  # 3  指定范围统计

      # res = 'my name is jason HAJHSSAJJ SAJS  '
      # print(res.title())  # 将所有英文单词首字母大写
      # print(res.capitalize())  # 首字母大写 后面统一变小写

      # res = 'sdewqe圣诞节卡萨'
      # print(res.isalpha())  # 判断非数字 特殊符号


      判断是否是纯数字
        # guess_age = input('请输入您的年龄>>>:')
        #判断用户输入的是否是纯数字
        # if guess_age.isdigit():
       # 将字符串的数字转为整型的数字
           #guess_age = int(guess_age)  # 暂且忽略
        # else:
            # print('请输入纯数字')



      替换
      # res = 'my name is egon egon egon'
      # 将字符串中所有的egon替换成SB
      # print(res.replace('egon','SB'))  # 全局替换
      # print(res.replace('egon','SB',1))  # 局部替换



      将列表多个元素拼接成字符串
      # res = ['jason','egon','kevin','tony']
      # res1 = ['jason','egon','kevin','tony',123]
      # # print('|'.join(res))  # jason|egon|kevin|tony
      # print('|'.join(res1))  #  只能是字符串类型拼接

列表

中括号括起来内存可以存放多个元素
元素与元素之间逗号隔开元素可以是任意数据类型

name_list = ['jason', 'egon', 'tony'] # name_list = list(['jason', 'egon', 'tony'])

print(type(list(18))) # 不能

print(type(list(11.11))) # 不能

print(type(list('hello')),list('hello')) # 可以 ['h', 'e', 'l', 'l', 'o']

print(type(list([1,2,3,4])))

print(type(list({'name':'jason'})),list({'name':'jason'})) # 可以 ['name']

print(type(list(True))) # 不能

'''能够支持for循环的数据都能够被list转换成列表'''

1.索引取值
# print(name_list[0])
# print(name_list[-1])
2.切片操作
# print(name_list[0:2])
# print(name_list[0:2:2])
# print(name_list[-1:-3:-1])
3.统计列表中元素的个数
# print(len(name_list)) # 3

列表元素的CURD(增删改查)
# name_list[1] = 'egon快回来!'
# print(name_list)
末尾追加单个元素
# name_list.append('kevin')
# print(name_list) # ['jason', 'egon', 'tony', 'kevin']
# name_list.append([11,22,33,44]) # ['jason', 'egon', 'tony', [11, 22, 33, 44]]
# print(name_list)
插入元素
# name_list.insert(0,'jack')
# print(name_list) # ['jack', 'jason', 'egon', 'tony']
扩展列表
# l1 = [11,22,33,44,55,66,77]
# # for i in l1:
# # name_list.append(i)
# # print(name_list)
# name_list.extend(l1) # extend等价于for+append
# print(name_list) # ['jason', 'egon', 'tony', 11, 22, 33, 44, 55, 66, 77]

通用的删除操作
# del name_list[1]
# print(name_list) # ['jason', 'tony']

res1 = name_list.remove('tony') # 指名道姓的删除

print(name_list) # ['jason', 'egon']

print(res1) # None

res = name_list.pop() # 默认尾部弹出元素

print(name_list) # ['jason', 'egon']

print(res)

res = name_list.pop(1) # 默认指定索引位置的元素

print(name_list) # ['jason', 'tony']

print(res) # egon

l1 = [11,22,33,3,3,3,2,3,23,4,34,3,4,3,4]

print(l1.count(3)) # 6 统计列表中某个元素出现的次数

name_list.clear() # 清空列表

print(name_list) # []

l2 = [11,88,22,44,33,77,66,55]
# # l2.sort() # 排序默认是升序
# # print(l2) # [11, 22, 33, 44, 55, 66, 77, 88]
# l2.sort(reverse=True) # reverse=True 降序
# print(l2) # [88, 77, 66, 55, 44, 33, 22, 11]

l2.reverse() # 倒序

print(l2)

可变与不可变

不可变类型
整型浮点型字符串元组
可变类型
列表字典集合
# 理解图例
"""
可变类型
值改变内存地址不变
不可变类型
值改变内存地址一定变

队列与堆栈

队列先进先出

'''先进去的元素先出来'''
# l = []
# # 添加元素
# l.append(111) # l = [111,]
# l.append(222) # l = [111, 222]
# l.append(333) # l = [111, 222, 333]

取出元素

print(l.pop(0)) # 111 l = [222, 333]

print(l.pop(0)) # 222 l = [333,]

print(l.pop(0)) # 333 l = []

堆栈先进后出

'''先进去元素后出来'''
l = []
# 添加元素
l.append(111)
l.append(222)
l.append(333) # l = [111, 222, 333]
# 取值
print(l.pop()) # 333 l = [111, 222]
print(l.pop()) # 222 l = [111,]
print(l.pop()) # 111 l = []

字典

大括号括起来内部可以存放多个元素
元素的表现形式是以K:V键值对形式
K是对V的描述性信息一般都是字符串
K是不可变类型
整型浮点型字符串
V可以是任意类型
d = {'name':'jason','pwd':123}
d['name'] # 取值的时候不推荐使用
d.get('name') # 推荐使用

1、按key存取值：可存可取

d1 = {
'username':'jason',
'password':123,
'hobby':['read', 'run']
}
# print(d1['username']) # jason
# print(id(d1))
# d1['username'] = 'tony'
# print(id(d1)) # {'username': 'tony', 'password': 123, 'hobby': ['read', 'run']}
# 字典是可变类型
# print(d1['age']) # 键不存在直接报错!!!
# d1['age'] = 18 # 键存在则修改不存在则新建
# print(d1) # {'username': 'jason', 'password': 123, 'hobby': ['read', 'run'], 'age': 18}

2、长度len 统计字典中键值对的个数

print(len(d1)) # 3

3、成员运算in和not in

print('jason' in d1) # False 字典默认只暴露key value不暴露如果想取一般只能通过key

print('username' in d1) # True

4、删除

del d1['password']

print(d1) #

'''字典不能使用索引!!!'''
# res = d1.pop('password')
# print(d1) # {'username': 'jason', 'hobby': ['read', 'run']}
# print(res) # 123

5、键keys()，值values()，键值对items()

将keys()的结果可以直接看成是列表

print(d1.keys()) # 获取字典中所有的key dict_keys(['username', 'password', 'hobby']) 老母猪

for k in d1.keys():

print(k)

"""
python2与python3对比
python3
keys() dict_keys(['username', 'password', 'hobby']) 老母猪
python2
keys() ['username', 'password', 'hobby']
"""
# 将values()的结果可以直接看成是列表
# print(d1.values()) # dict_values(['jason', 123, ['read', 'run']]) 老母猪
"""
python2与python3对比
python3
values() dict_keys(['jason', 123, ['read', 'run']]) 老母猪
python2
values() ['jason', 123, ['read', 'run']]
"""
# 将items()的结果可以直接看成是列表[]套小列表()
# print(d1.items())
# for k,v in d1.items(): # 解压赋值结合 for循环
# print(k,v)
"""
python2与python3对比
python3
items() dict_keys([('username', 'jason'), ('password', 123), ('hobby', ['read', 'run'])]) 老母猪
python2
items() [('username', 'jason'), ('password', 123), ('hobby', ['read', 'run'])]
"""

6、循环

'''字典for循环只能获取到key'''
# for i in d1:
# print(i)

dict.get() # 使用频率最为广泛通过字典的key获取字典的value

print(d1.get('username')) # jason

print(d1['username']) # jason

key不存在

print(d1['age']) # 直接报错

print(d1.get('age')) # get方法键不存在也不会报错返回None(什么都没有)

print(d1.get('username','嘿嘿嘿')) # jason

print(d1.get('age','嘿嘿嘿')) # 嘿嘿嘿

'''get方法还可以给第二个参数键存在则不使用键不存在则返回第二个参数不写默认返回None'''

第一种创建字典的方式

d2 = {'k1':'v1','k2':'v2'} # dict({'k1':'v1','k2':'v2'})

第二种创建方式

res = dict(name='jason',pwd=123,hobby=['read','run'])

print(res) #

第三种创建方式

l = [

['username','jason'],

['password',123],

['hobby',['read','run']]

]

# d = {}

# for i in l: # ['username','jason'] ['password',123] ['hobby',['read','run']]

# d[i[0]] = i[1] # d['username'] = 'jason'

# print(d)

# d = {}

# for k,v in l: # ['username','jason'] ['password',123] ['hobby',['read','run']]

# d[k] = v

# print(d)

res = dict(l)

print(res) #

dict.clear() 清空

d1.clear()

print(d1)

dict.fromkeys() 快速先生成一个字典

l = ['username','pwd','hobby']

res = dict.fromkeys(l,None)

print(res)

dict.popitem()

res = d1.popitem() # 随机弹出一组键值对

print(d1)

print(res) # ('hobby', ['read', 'run'])

dict.setdefault() 重点

dd =

dd.setdefault('age',18) # 键不存在则新建

res = dd.setdefault('name','egonSBSBSB') # 键存在不修改而是获取到键对应的值

print(dd,res) # {'name': 'jason', 'pwd': 123, 'age': 18} jason

dict.update()

dd =

dd.update({'age':18}) # 键不存在则新建

dd.update({'name':'EGONDSB'}) # 键存在则修改

print(dd)

# 还不如使用下列方式

dd['age'] = 18

dd['name'] = 'jason'

元组

"""
小括号括起来括号内可以存放多个元素
元素与元素之间逗号隔开元素可以是任意类型
元组也可以简单的理解为是列表

元组属于不可变类型
"""
# t1 = (1,2,3,4,5,6)
# print(type(t1)) # tuple

类型转换与list一致支持for循环的都可以

t1 = (1)

print(type(t1)) # int

t2 = ('a')

print(type(t2)) # str

l1 = [1]

print(type(l1)) # list

"""
元组当内部只有一个元素的时候逗号不能省略

以后只要是容器类型无论内部有几个元素都必须要有逗号
尤其是只有一个元素的情况下
(1,)
[1,]
{'username':'jason',}
"""

作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读

定义：与列表类型比，只不过[]换成()

优先掌握的操作：

1、按索引取值(正向取+反向取)：只能取

t1 = (11,22,33)

t1[0] = 666

print(t1)

"""
笔试题
元组内元素的内存地址不能修改
但是如果元素是可变类型那么元素值可以改
"""
# t2 = (11,22,[11,22])
# t2[2].append(33)
# # 问:上述代码执行的结果是什么
# print(t2) # (11, 22, [11, 22, 33])
#2、切片(顾头不顾尾，步长)
# 与字符串列表一致
#3、长度
# len()
#4、成员运算in和not in
# 与列表一致

5、循环

for i in (11,22,33):

print(i)

集合

"""
大括号括起来内部可以存放多个元素
元素与元素之间逗号隔开(不是k:v键值对) 元素只能是不可变类型(整型浮点型字符串元组)
s = {1,2,3,4}

只有两种情况才会考虑使用集合
1.关系运算
两个群体之间判断交叉并集
共同好友共同关注共同点赞...
2.去重操作
去除重复的元素
"""
# se = {1,2,3,4,5} # set(1,2,3,4,5)
# print(type(se)) # set
# d1 = {}
# s1 = {}
# print(type(d1),type(s1)) # <class 'dict'> <class 'dict'>
# """定义空集合需要使用关键字set"""
# ss = set()
# print(ss,type(ss)) # set
# s = {11,1.1,'hello',(1,2,3)}
# 2.去重操作
l = [11,22,33,22,11,44,33,22,55,66,66,66]
# for循环一个个元素判断当前元素是否已存在
# new_l = []
# for i in l:
# if i not in new_l:
# new_l.append(i)
# print(new_l) # [11, 22, 33, 44, 55, 66]
# 将列表转换成集合
# res = set(l)
# print(res)
# '''集合内默认不能出现重复的元素如果出现了会自动去重'''
# r1 = {11,22,22,22,11,44,44,44}
# print(r1)

关系运算

f1 = {'jason','egon','kevin','tony'}
f2 = {'jason','jack','oscar','kevin'}
# 共同好友
print(f1 & f2) # {'jason', 'kevin'}
# f1独有的好友
print(f1 - f2) # {'tony', 'egon'}
# f2独有的好友
print(f2 - f1) # {'oscar', 'jack'}
# 所有的好友
print(f1 | f2) # {'jason', 'oscar', 'egon', 'tony', 'kevin', 'jack'}
# 求各自好友不包含共有的
print(f1 ^ f2) # {'jack', 'oscar', 'tony', 'egon'}

父集子集

"""
父级:A包含B 那么A就是B的父级
子级:A包含B 那么B就是A的子级
"""
s1 = {1,2,3,4,5}
s2 = {1,2,3}
print(s1 > s2) # True
print(s1 < s2) # False

"""

posted @ 2021-06-22 19:55 zhutianyu 阅读(61) 评论(0) 收藏举报

刷新页面返回顶部

cheer

python之数据类型的内置方法

整型

浮点型

字符串

列表

name_list = ['jason', 'egon', 'tony'] # name_list = list(['jason', 'egon', 'tony'])

print(type(list(18))) # 不能

print(type(list(11.11))) # 不能

print(type(list('hello')),list('hello')) # 可以 ['h', 'e', 'l', 'l', 'o']

print(type(list([1,2,3,4])))

print(type(list({'name':'jason'})),list({'name':'jason'})) # 可以 ['name']

print(type(list(True))) # 不能

res1 = name_list.remove('tony') # 指名道姓的删除

print(name_list) # ['jason', 'egon']

print(res1) # None

res = name_list.pop() # 默认尾部弹出元素

print(name_list) # ['jason', 'egon']

print(res)

res = name_list.pop(1) # 默认指定索引位置的元素

print(name_list) # ['jason', 'tony']

print(res) # egon

l1 = [11,22,33,3,3,3,2,3,23,4,34,3,4,3,4]

print(l1.count(3)) # 6 统计列表中某个元素出现的次数

name_list.clear() # 清空列表

print(name_list) # []

l2.reverse() # 倒序

print(l2)

可变与不可变

队列与堆栈

队列 先进先出

取出元素

print(l.pop(0)) # 111 l = [222, 333]

print(l.pop(0)) # 222 l = [333,]

print(l.pop(0)) # 333 l = []

堆栈 先进后出

字典

1、按key存取值：可存可取

2、长度len 统计字典中键值对的个数

print(len(d1)) # 3

3、成员运算in和not in

print('jason' in d1) # False 字典默认只暴露key value不暴露 如果想取 一般只能通过key

print('username' in d1) # True

4、删除

del d1['password']

print(d1) #

5、键keys()，值values()，键值对items()

将keys()的结果可以直接看成是列表

print(d1.keys()) # 获取字典中所有的key dict_keys(['username', 'password', 'hobby']) 老母猪

for k in d1.keys():

print(k)

6、循环

dict.get() # 使用频率最为广泛 通过字典的key获取字典的value

print(d1.get('username')) # jason

print(d1['username']) # jason

key不存在

print(d1['age']) # 直接报错

print(d1.get('age')) # get方法键不存在也不会报错 返回None(什么都没有)

print(d1.get('username','嘿嘿嘿')) # jason

print(d1.get('age','嘿嘿嘿')) # 嘿嘿嘿

第一种创建字典的方式

d2 = {'k1':'v1','k2':'v2'} # dict({'k1':'v1','k2':'v2'})

第二种创建方式

res = dict(name='jason',pwd=123,hobby=['read','run'])

print(res) #

第三种创建方式

l = [

['username','jason'],

['password',123],

['hobby',['read','run']]

]

# d = {}

# for i in l: # ['username','jason'] ['password',123] ['hobby',['read','run']]

# d[i[0]] = i[1] # d['username'] = 'jason'

# print(d)

# d = {}

# for k,v in l: # ['username','jason'] ['password',123] ['hobby',['read','run']]

# d[k] = v

# print(d)

res = dict(l)

队列先进先出

堆栈先进后出

print('jason' in d1) # False 字典默认只暴露key value不暴露如果想取一般只能通过key

dict.get() # 使用频率最为广泛通过字典的key获取字典的value

print(d1.get('age')) # get方法键不存在也不会报错返回None(什么都没有)

dd.setdefault('age',18) # 键不存在则新建

res = dd.setdefault('name','egonSBSBSB') # 键存在不修改而是获取到键对应的值

dd.update({'age':18}) # 键不存在则新建

类型转换与list一致支持for循环的都可以

父集子集