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) # {'username': 'jason', 'hobby': ['read', 'run']}
'''字典不能使用索引!!!'''
# 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) # {'name': 'jason', 'pwd': 123, 'hobby': ['read', 'run']}
# 第三种创建方式
# 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) # {'username': 'jason', 'password': 123, 'hobby': ['read', 'run']}
# 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 = {'name':'jason','pwd':123}
# dd.setdefault('age',18) # 键不存在 则新建
# res = dd.setdefault('name','egonSBSBSB') # 键存在不修改 而是获取到键对应的值
# print(dd,res) # {'name': 'jason', 'pwd': 123, 'age': 18} jason
# dict.update()
# dd = {'name':'jason','pwd':123}
# 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
"""
浙公网安备 33010602011771号