第五章 python数据类型及内置方法

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)