第五章 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)