python基本数据类型及内置方法
一、int类型
age = 18 # age = int(18)
- 类型转换：
纯数字的字符串转换成整型：
res = int('111000222')
print(res,type(res)) - 10进制转换二进制、八进制及十六进制
# 10进制 -> 二进制
# 11 - > 1011
# 1011-> 8+2+1
# print(bin(11)) # 0b1011
# 10进制 -> 八进制
# print(oct(11)) # 0o13
# 10进制 -> 十六进制
# print(hex(11)) # 0xb
# print(hex(123)) # 0xb- 其他进制之间的转换
# 二进制->10进制
# print(int('0b1011',2)) # 11
# 二进制->8进制
# print(int('0o13',8)) # 11
# 二进制->16进制
# print(int('0xb',16)) # 11二、float类型
res = float("5.5")
print(res,type(res))
总结：int与float的使用就是针对数学运算+比较运算
三、str类型
msg='hello world' # msg=str('msg')
print(msg,type(msg))
- 类型转换：
# str可以把任意其他类型都转成字符串
# res=str({'a':1})
# print(res,type(res)) - 内置方法：
# （1）索引取值，支持正向取值，反向取值，不能修改值
msg = 'hello python'
print(msg[4])
print(msg[-1])
# （2）切片:索引的拓展应用，从一个大字符串中拷贝出一个子字符串
msg = 'hello world'
# 顾头不顾尾（左闭右开原则）,支持步长
res=msg[0:5]
print(res) # hello
print(msg) # hello world
res = msg[0:5:2] # 相当于获取了下标分别为0 2 4的数据
print(res) # hlo
res=msg[::-1] # 把字符串倒过来
print(res)
# （3）获取字符串长度len()
msg = 'hello world'
print(len(msg))
# （4）成员运算in和not in
# 判断一个子字符串是否存在于一个大字符串中
print("a" in "abc is str")
print("bmw" not in "car")
# （5）移除字符串左右两侧的符号strip，默认去掉空格
msg=' hello '
res = msg.strip()
print(msg) # 不会改变原值
print(res) # 是产生了新值
# 拓展：lstrip,rstrip，原理同strip,lstrip消除左边字符,rstrip消除右边字符,默认去掉空格
# （6）切分split：把一个字符串按照某种分隔符进行切分，得到一个列表，默认分隔符是空格
info = 'wcg 18 male'
res = info.split()
print(res)
# 拓展：rsplit 切割字符串从右开始切，得到一个列表，默认分隔符是空格
# 指定分隔符
info = 'wcg:18:male'
res = info.split(':')
print(res)
# 指定分隔次数(了解)
info = 'wcg:18:male'
res = info.split(':',1)
print(res)
# （7）字符串循环取值的问题
msg = 'i am lucy'
for i in msg:
print(i)
# （8）大小写转换（lower,upper）
msg = 'AbbbCCCC'
print(msg.lower())
print(msg.upper())
# （9）判断是否以指定字符开头/结尾（startswith,endswith）,返回值True/False
print("dog is animal".startswith("dog"))
print("dog is animal".endswith('is'))
# （10）把列表拼接成字符串（join）
''.join(['my','name','is','lucy'])
# （11）替换指定字符串（replace），可以指定替换个数，默认全部替换
msg = "you can you up no can no bb"
print(msg.replace("you","YOU",))
print(msg.replace("you","YOU",1))
# （12）判断字符串是否由纯数字组成（isdigit）
print('123'.isdigit())
print('12.3'.isdigit())
# （13）is其他系列
print('abc'.islower())
print('ABC'.isupper())
print('Hello World'.istitle())
print('123123aadsf'.isalnum()) # 字符串由字母或数字组成结果为True
print('ad'.isalpha()) # 字符串由由字母组成结果为True
print(' '.isspace()) # 字符串由空格组成结果为True
print('print'.isidentifier())
print('age_of_allen'.isidentifier())
# （14）查找指定的字符串系列（find,index）,其中find找不到会返回-1，index找不到则抛出异常
msg='hello allen hahaha'
# 找到返回起始索引
print(msg.find('e')) # 返回要查找的字符串在大字符串中的起始索引
print(msg.find('al'))
print(msg.index('e'))
# 找不到时二者的区别
print(msg.find('xxx')) # 返回-1，代表找不到
print(msg.index('xxx')) # 抛出异常
# （15）计算统计次数（count）
msg = 'hello aaa hahaha aaa、 aaa'
print(msg.count('aaa'))
# （16）打印指定长度字符串（center,ljust,rjust,zfill）
print('wcg'.center(50,'*')) # 字符串总长度50，wcg居中显示
print('wcg'.ljust(50,'*')) # 字符串总长度50，wcg靠左显示
print('wcg'.rjust(50,'*')) # 字符串总长度50，wcg靠右显示
print('wcg'.zfill(10)) # 字符串总长度10，wcg靠右显示，左边字符用0填充
# （17）首字母大写captalize,大小写翻转swapcase,每个单词都首字母大写title
print("hello world wcG".capitalize())
print("Hello WorLd ALlEn".swapcase())
print("hello world wcg".title())
# （18）设定制表符（expandtabs）
msg='hello\tworld'
print(msg.expandtabs(2)) # 设置制表符代表的空格数为2四、list类型
按位置存放多个值，以下标为key取值，下标从0开始
lst = ['abc',123,(1,5,7)] # lst = list( ['abc',123,(1,5,7)] )
print(lst[2],type(lst))
- 类型转换: 但凡能够被for循环遍历的类型都可以当做参数传给list()转成列表
res=list('hello')
print(res)
res=list({'k1':111,'k2':222,'k3':3333})
print(res) - 内置方法
# （1）按索引存取值(正向存取+反向存取)：即可以取也可以改
l=[111,'wcg','hello']
# 正向取
print(l[0])
# 反向取
print(l[-1])
# 可以取也可以改：索引存在则修改对应的值
l[0]=222
print(l)
# 无论是取值操作还是赋值操作：索引不存在则报错
l[3]=333
# （2）切片(顾头不顾尾，步长)
# 原理同字符串切片操作
# （3）获取长度（len）
lst = [1,2,3,4]
print(len(lst))
# （4）成员运算in和not in
print('aaa' in ['aaa', 1, 2])
print(1 in ['aaa', 1, 2])
# （5）往列表添加值（append,insert,extend）
# 在列表后面追加值
l = [111,'wcg','hello']
l.append(3333)
l.append(4444)
print(l)
# 根据索引位置插入值
l = [111,'wcg','hello']
l.insert(0,'lucy')
print(l)
# extend添加值
new_l = [1,2,3]
l = [111,'556','hello']
l.append(new_l)
print(l)
# （6）删除
# 方式一：通用的删除方法，只是单纯的删除、没有返回值
l = [111, '998', 'hello']
del l[1]
x = del l[1] # 抛出异常，不支持赋值语法
print(l)
# 方式二：l.pop()根据索引删除，会返回删除的值
l = [111, 'oop', 'hello']
l.pop() # 不指定索引默认删除最后一个
l.pop()
print(l)
res = l.pop(1)
print(l)
print(res)
# 方式三：l.remove()根据元素删除，返回None
l = [111, '889', [1,2,3],'hello']
l.remove([1,2,3])
print(l)
res=l.remove('hello')
print(res) # None
# （7）循环
l = [1,'aaa','bbb']
for x in l:
l.pop(1)
print(x)
# （8）统计（count）
l = [1, 'aaa', 'bbb','aaa','aaa']
l.count()
print(l.count('aaa'))
# （9）查找（index）
l = [1, 'aaa', 'bbb','aaa','aaa']
print(l.index('aaa'))
print(l.index('aaaaaaaaa')) # 找不到报错
# （10）清空列表（clear）
l = [1, 'aaa', 'bbb','aaa','aaa']
l.clear()
print(l)
# （11）列表翻转（reverse）
# 注意:不是排序，就是将列表倒过来
l = [1, 'aaa','bbb','ccc']
l.reverse()
print(l)）
# （12）排序（sort）
# 列表内元素必须是同种类型才可以排序
l = [11,-3,9,2,3.1]
l.sort() # 默认从小到大排，称之为升序
l.sort(reverse=True) # 从大到小排，设置为降序
print(l)
# 拓展:
# 字符串可以比大小，按照对应的位置的字符依次pk
# 字符串的大小是按照ASCI码表的先后顺序加以区别，表中排在后面的字符大于前面的
print('a'>'b')
print('abz'>'abcdefg')
# 了解：列表也可以比大小,原理同字符串一样,但是对应位置的元素必须是同种类型
l1 = [1,'abc','zaa']
l2 = [1,'abc','zb']
print(l1 < l2)- 利用列表模拟队列和堆栈效果
# 1、队列：FIFO,先进先出
l = []
# # 入队操作
l.append('first')
l.append('second')
l.append('third')
# 出队操作
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
# 2、堆栈：LIFO,后进先出
l = []
# 入栈操作
l.append('first')
l.append('second')
l.append('third')
# 出队操作
print(l.pop())
print(l.pop())
print(l.pop())五、tuple类型
元组就是"一个不可变的列表"
作用：按照索引/位置存放多个值，只用于读不用于改
定义:（）内用逗号分隔开多个任意类型的元素
t=(1,1.3,'aa') # t=tuple((1,1.3,'aa'))
print(t,type(t))
重点1：如果元组中只有一个元素，必须加逗号
t = (10,) # 如果元组中只有一个元素，必须加逗号
print(t,type(t))重点2：元祖中按照下标存放的数据只能读不能修改，如果该下标对应的值是可变类型，那么可以修改该下标对应的可变类型中的值
t = (1,'aaa',[1,2,3])
t[0] = 888 # 不可以修改
t[2][0] = '1' # 可以修改- 类型转换
print(tuple('hello'))
print(tuple([1,2,3]))
print(tuple({'a1':111,'a2':333})) - 内置方法
# （1）按索引取值(正向取+反向取)：只能取
t=('aa','bbb','cc')
print(t[0])
print(t[-1])
# （2）切片(顾头不顾尾，步长)
t=('aa','bbb','cc','dd','eee')
print(t[0:3])
print(t[::-1])
# （3）长度
t=('aa','bbb','cc','dd','eee')
print(len(t))
# （4）成员运算in和not in
print('aa' in t)
# （5）循环
for x in t:
print(x)
# （6）查找
t=(2,3,111,111,111,111)
print(t.index(111))
print(t.index(1111111111))
# （7）统计次数
print(t.count(111))六、dict类型
{}内用逗号分隔开多个key：value，其中value可以使任意类型，但是
key必须是不可变类型,且不能重复
创建字典的两种方式：
# （1）方式一:
d = {'k1':111,(1,2,3):222} # d=dict(...)
print(d['k1'])
print(d[(1,2,3)])
print(type(d))
d={} # 默认定义出来的是空字典
print(d,type(d))
# （2）方式二:
d = dict(x=1,y=2,z=3)
print(d,type(d))
# （3）方式三:
info=[
['name','wcg'],
('age',18),
['gender','male']
]
res=dict(info) # 一行代码搞定上述for循环的工作
print(res)
# （4）方式四:快速初始化一个字典
keys = ['name','age','gender']
d = {}
for k in keys:
d[k] = None
print(d)
d = {}.fromkeys(keys,None) # 一行代码搞定上述for循环的工作
print(d)- 内置方法
# （1）按key存取值：可存可取
d = {'k1':111}
# 针对赋值操作：key存在，则修改
d['k1']=222
# 针对赋值操作：key不存在，则创建新值
d['k2']=3333
print(d)
# （2）获取长度（len）
d = {'k1':111,'k2':2222,'k1':3333,'k1':4444}
print(d)
print(len(d))
# （3）成员运算in和not in:根据key
d = {'k1':111,'k2':2222}
print('k1' in d)
print(111 in d)
# （4）删除方法
d={'k1':111,'k2':2222}
# 通用删除
del d['k1']
print(d)
# pop删除：根据key删除元素，返回删除key对应的那个value值
# res = d.pop('k2')
# print(d)
# print(res)
# popitem删除：随机删除，返回元组(删除的key,删除的value)
# res = d.popitem()
# print(d)
# print(res)
# （5）获取键keys()，值values()，键值对items()
d = {'k1':111,'k2':2222}
d.keys()
d.values()
d.items()
# （6）for循环
for k in d.keys():
print(k)
for k in d:
print(k)
for v in d.values():
print(v)
for k,v in d.items():
print(k,v)
print(list(d.keys()))
print(list(d.values()))
print(list(d.items()))
# （7）清空操作（clear）
d = {'k1':111}
d.clear()
# （8）更新操作（update）
d.update({'k2':222,'k3':333,'k1':111111111111111})
print(d)
# （9）根据key取值另一种方法（get）
# d.get() ：根据key取值，容错性好
print(d['k2']) # key不存在则报错
print(d.get('k1')) # 111
print(d.get('k2')) # key不存在不报错，返回None
# （10）设置默认值（setdefault）
# 如果key有则不添加,返回字典中key对应的值
info = {'name':'wcg'}
res = info.setdefault('name','lucy')
print(info)
print(res)
# 如果key没有则添加，返回字典中key对应的值
info={}
res=info.setdefault('name','lucy')
print(info)
print(res)六、set类型
"""
在{}内用逗号分隔开多个元素，多个元素满足以下三个条件
1. 集合内元素必须为不可变类型
2. 集合内元素无序
3. 集合内元素没有重复
"""
s = {1,[1,2]} # 集合内元素必须为不可变类型
s = {1,'a','z','b',4,7} # 集合内元素无序
s = {1,1,1,1,1,1,'a','b'} # 集合内元素没有重复
print(s)- 类型转换
set({1,2,3})
res = set('helloworld')
print(res)
print(set([1,1,1,1,1,1,[11,222]]) # 报错，必须为不可变类型 - 内置方法
friends1 = {"lucy","kevin","jack","wcg"}
friends2 =
# （1）取交集：两者共同的好友
res = friends1 & friends2
print(res)
print(friends1.intersection(friends2))
# （2）取并集/合集：两者所有的好友
print(friends1 | friends2)
print(friends1.union(friends2))
# （3）取差集：取friends1独有的好友
print(friends1 - friends2)
print(friends1.difference(friends2))
# 取friends2独有的好友
print(friends2 - friends1)
print(friends2.difference(friends1))
# （4）对称差集: 求两个用户独有的好友们（即去掉共有的好友）
print(friends1 ^ friends2)
print(friends1.symmetric_difference(friends2))
# 4.5 父子集：包含的关系
s1 = {1,2,3}
s2 = {1,2,4}
# 不存在包含关系，下面比较均为False
print(s1 > s2)
print(s1 < s2)
s1 = {1,2,3}
s2 = {1,2}
print(s1 > s2) # 当s1大于或等于s2时，才能说是s1是s2父级
print(s1.issuperset(s2))
print(s2.issubset(s1)) # s2 < s2 =>True
s1 = {1,2,3}
s2 = {1,2,3}
print(s1 == s2) # s1与s2互为父子
print(s1.issuperset(s2))
print(s2.issuperset(s1))
# =========================去重=========================
# （1）只能针对不可变类型去重
print(set([1,1,1,1,2]))
# （2）无法保证原来的顺序
l = [1,'a','b','z',1,1,1,2]
l = list(set(l))
print(l)
# ======================其他内置方法======================
# （1）删除（discard，remove）
s = {1,2,3}
s.discard(4) # 删除元素不存在do nothing
print(s)
s.remove(4) # 删除元素不存在则报错
# （2）其他内置方法update、pop、add
s.update({1,3,5})
print(s)
res = s.pop()
print(res)
s.add(4)
print(s)
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
