列表，元组，集合，字典的内置方法

列表内置方法

• 内置列表的本质

  在程序中运用最多的就是增删改查这四种功能， 跟在内置方法后方所变化的都是一次性数据如果没有给它一个变量名
  将他存起来的话那么这个数据在后面就无法继续使用
  

• 增加

  1.oppend()在列表末尾增加元素
  l1 = [a, b, c]
  l1.append('d')
  print(l1)
  [a, b, c, d]
  
  2.extend()在列表末尾增加多个元素
  l1 = [a, b, c]
  l1.extend(d, e, f, g)
  print(l1)
  [a, b, c, d, e, f, g]
  
  3.insert()在指定位置插入元素
  l1 = [a, b, c， d, e, f, g]
  l1.insert(3, joseph)
  print(l1)
  [a, b, c， joseph, d, e, f, g]
  

• 删除

  1.del() 删除对应的值
  l1 = [a, b, c， d, e, f, g]
  l1.del(4)
  print(l1)
  [a, b, c， d, f, g]
  
  2.pop()默认弹出列表最后一个元素但是也可以定义弹出对象，
  l1 = [a, b, c， d, e, f, g]
  l2 = l1.pop()
  print(l1)
  g
  
  l2 = l1.pop(1)
  print(l1)
  b
  
  3.remove（） 删除已知的定义元素，并且这个元素会直接删除不会返回
  l1 = [a, b, c， d, e, f, g]
  l2 = l2.remove(d)
  print(l2)
  [a, b, c， e, f, g]
  

• 颠倒

  1.reverse() 将整个列表中的元素前后前后颠倒
  l1 = [a, b, c， d, e, f, g]
  l1.reverse()
  print(l1)
  [g, f, e, d, c, b, a]
  

• 升序降序

  1.给元素进行排序，但是这些元素必须是同样的数据类型否则将无法排序
  
  
  2.sort（）给列表中的元素进行排序(默认的则是从小到大进行排序)
  l1 = [11, 33, 55, 4, 9, 77]
  l1.sort()
  print(l1)
  [4, 9, 11, 33, 55, 77]
  2.1
  l1 = [11, 33, 55, 4, 9, 77]
  l1.sort(reverse=True)  # reverse用来否定排序判断后直接更改为倒序排序
  print(l1)
  [77, 55, 33, 11, 9, 4]
  
  
  3.除了我们经常使用的数字排序其实字符串也是可以进行排序的， 根据ascii码（万国码）之中字符的定位来排序
  

可变类型与不可变类型

• 可变数据类型

  值发生改变时，内存地址不会变化， 即id不变，改变的只是这个值
  

• 不可变数值

  值发生改变时，内存地址也发生变化， 即id改变，不是直接改变这个值而是直接创建了一个新的值
  

• 数据类型

  >>> num = 8
  >>> print(id(num))
  140711988299648
  >>>
  >>> num = 10
  >>> print(id(num))
  140711988299712
  >>>
  # 在整数中更改了数值那么他的地址就直接发生了改变所以它属于不可变数值，浮点数和整数一样都会改变id地址
  

• 字符串

  >>> str = 'joseph'
  >>> id(str)
  2347791156336
  >>> str = 'alex'
  >>> id(str)
  2347791156656
  >>>
  # 在字符串中我们更改了他的数值，他的地址发生了变化所以它属于不可变数据类型
  

• 列表

  >>> list = [11, 22, 33,]
  >>> id(list)
  2347790860480
  >>>
  >>> list[2] = '55'
  >>> id(list)
  2347790860480
  >>>
  >>> list[1] = '77'
  >>> id(list)
  2347790860480
  >>>
  我们更改列表中任意一个数值他的地址没有发生任何变化，即id没变，所以列表属于可变类型，元组和字典都和列表
  一样改变其中一个数值他的地址不会变所以元组和字典也都属于可变类型
  

元组内置方法

• 元组的定义

  在使用元组的时候必须使用括号括住即使元组中只有一个一个数值那么也需要括住并且需要在这个数值后方跟上逗号否
  则系统会直接认为这个元组是别的数据类型，它里面是什么类型的那么就会自动变为什么类型
  

• 元组的类型转换

  1.只要可以被for循环的数据类型都可以被转为元组
  print（tuple('joseph')）
  # (‘j’, 'o', 's', 'e', 'p', 'h') 
  print（tuple([1,2,3])）
  # (1, 2, 3)
  print（tuple({"name":"joseph","age":21})） 
  # ('name', 'age')
  print（tuple((1,2,3)）)
  # (1, 2, 3)
  print（tuple({1,2,3,4})）
  # (1, 2, 3, 4)
  

• 索引取值

  data = (11, 22, 33, 'joseph', 1.2)
  print(data[2])
  33
  print(data[-2])
  'joseph'
  data[4] = 'alex'
  报错
  # 在元组索引取值时可以采用正负两种方式取值，但是元组中的数值是不能改变的
  

• 切片

  data = (11, 22, 33, 'joseph', 1.2)
  print(data[0, 4, 2])
  [11, 33, 1.2]
  

• 长度

  data = (11, 22, 33, 'joseph', 1.2)
  print(len(data))
  5
  

• 成员运算

  data = (11, 22, 33, 'joseph', 1.2)
  joseph in data:
  True
  joseph not in data:
  False
  

• 循环

  data = (11, 22, 33, 'joseph', 1.2)
  for i in data:
      print(data)
  ...
  11
  22
  33
  joseph
  1.2
  

字典内置方法

• 字典的类型转换

  1.
  data = dict([['name, joseph'], ('age', 21)])
  print(data)
  {'name'：'joseph', 'age'：'21'}
  
  2.
  print(dict(name='joseph', pwd=123))
  {'name':'joseph', 'pwd':'123'}
  

• 按k取值

  1.按k取值
  dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
  print(dict('name'))
  'joseph'
  print(dict('hobby')[1])
  'play games'
  
  2.给字典增加键值对
  dict['gender'] = 'male'  
  print(dict)
  {'name': 'joseph', 'age':'21', 'hobby':['read', 'play games'], 'gender':'male'}
  
  3.
  dict['name'] = 'alex'
  print(dict)
  {'name': 'alex', 'age':'21', 'hobby':['read', 'play games'], 'gender':'male'}
  

• len长度

  dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
  len(dict)
  3
  

• 成员运算

  dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
  'name' in dict
  True
  

• 删除

  dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
  dict.pop('name')
  print('dict')
  {'age':'21', 'hobby':['read', 'play games'] }
  

• 取所有值

  dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
  1.取所有的k值
  dict.keys()
  ['name', 'age', 'hobby']
  
  2.取所有的v值
  dict.values()
  ['joseph', '21', ['read', 'play games']]
  
  3.取所有的kv
  dict.items()
  ['name':'joseph','age':'21', 'hobby':['read', 'play games'] ]
  

• 循环

  dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
  1.默认循环的值是字典的k值
  for key in dict.keys()：
  	print(key)
  'name'
  'age'
  'hobby'
  
  2.只循环v值
  for key in dict.values():
  	print(key)
  'joseph'
  '21'
  ['read', 'play games']
  
  3.循环k，v键值对
  for key in dic.items():
  	print(key)
  'name':'joseph'
  'age':'21’
  'hobby':['read', 'play games'] 
  

• get()

  dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
  dict.get('name')
  'joseph'  # key存在，则获取key对应的value值
  data=dict.get('XXX') # key不存在，不会报错而是默认返回None
  print(data)
  None  
  data=dic.get('gender','male') # key不存在时，可以设置默认返回的值,如果遇到没有的k，v键值对那么就会
  直接给上方字典增加进去
  print(data)
  male 
  # ps:字典取值建议使用get方法
  

• pop()

  # 固定选取k值将选区的kv键值对弹出，可以进行存储
  dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
  value = dict.pop('age')
  print(dict)
  ['name':'joseph', 'hobby':['read', 'play games'] ]
  print(value)
  'age':'21'
  

• popitem()

  # 随机弹出一个键值对，也可以使用变量名去存储
  dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
  item = dict.popitem()
  print(dict)
  ['name':'joseph', 'hobby':['read', 'play games'] ]
  print(item)
  'age':'21'
  

• update()

  # 使用新字典换旧字典，如果旧字典中没有那么就会新增一个字典
  dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
  dict.update('name':'alex', 'gender':'male')
  print(dict)
  ['name':'alex','age':'21', 'hobby':['read', 'play games'] , 'gender':'male']
  

• fromkeys()

  # 定义替换字典中的v值
  dict = {'name':'joseph','age':'21', 'hobby':['read', 'play games'] }
  dict = dict.fromkeys(['name', 'age', 'hobby'], [])
  print(dict)
  ['name':[],'age':[], 'hobby':[] ]
  

• setdefault()

  # 键存在则获取键对应的值 键不存在则设置 并返回设置的新值
  dict={'name':'joseph', 'hobby':['read', 'play games'] }
  data=dict.setdefault('age','21')
  print(data)
  '21'
  dict # 字典中新增了键值对
  ['name':'joseph','age':'21', 'hobby':['read', 'play games'] ]
  

集合内置方法

• 集合类型转换

  # 只要能被for循环的遍历的数据类型，只有每一个值都必须为不可变类型才可以转为集合，都可以传给set()转换成
  集合类型
  # 空集合必须拿set来定义
  s = set([1,2,3,4])
  s1 = set((1,2,3,4))
  s2 = set({'name':'Joseph',})
  s3 = set('alex')
  s,s1,s2,s3
  {1, 2, 3, 4} {1, 2, 3, 4} {'name'} {'a', 'l', 'e', 'x'}
  

• 合集:求两个用户名单的所有用户（重复的只留一个）

  pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
  linuxs={'kermit','tony','gangdan'}
  
  print（'pythons'|'linuxs'）
  {'tony', 'jason', 'oscar', 'gangdan', 'kermit', 'biubiu', 'kevin', 'ricky'}
  

• 交集:求两个用户名单的共同用户

  pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
  linuxs={'kermit','tony','gangdan'}
  
  print('python'&'linuxs')
  {'gangdan'}
  

• 差集：求两个用户名单未重复的用户

  pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
  linuxs={'kermit','tony','gangdan'}
  
  print('pythons'-'linuxs')
  {'jason', 'oscar', 'biubiu', 'kevin', 'ricky'}
  

• 对称差集：求两个用户名单的共同用户除去共同用户

  pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
  linuxs={'kermit','tony','gangdan'}
  
  print('pythons'^'linuxs')
  {'tony', 'jason', 'oscar', 'kermit', 'biubiu', 'kevin', 'ricky'}
  

• 值是否相等

  pythons={'jason','oscar','kevin','ricky','gangdan','biubiu'}
  linuxs={'kermit','tony','gangdan'}
  
  print('pythons'=='linuxs')
  False
  

• 父集

  s1 = {1, 2, 3, 4, 5, 6, 7}
  s2 = {3, 2, 1}
  print(s1 > s2)  # s1是否是s2的父集 
  True
  

• 子集

  s1 = {1, 2, 3, 4, 5, 6, 7}
  s2 = {3, 2, 1}
  print(s1 < s2)  # s2是不是s1的子集
  False
  

标签：内置,name,age,元组,joseph,dict,l1,print,字典
来源： https://www.cnblogs.com/joseph-bright/p/16417930.html