python学习笔记：字符串,列表,元组,字典,集合

字符串

字符串以常量的形式存储在内存中,在向变量赋值时仅将字符串常量的地址赋给相应变量,当用此变量赋值给其他变量时,仅将地址赋值给新变量(使用三引号声明的字符串会单独的常量池中开辟空间,因此若同一字符串使用三引号包裹与使用单或双引号包裹的变量的地址不同).

• 比较两个字符串的内容是否相同要使用 ==

• 使用单引号(''),双引号("")或三引号(''' ''')引起来的内容为字符串.
  当使用三引号时,使用print()输出时会按照字符串的原格式输出

  mgs = '''
  AAA BBB   CCC
      DDD
       EEE
  '''
  print(mgs) #其按照原来的格式输出 
  

• 可以使用+拼接字符串,用+只可以拼接字符串类型的变量或值
  如

  age = 22
  print('年龄是:'+ age) #此时若运行则会报错,因为变量age并非字符串类型
  

  解决方法:

  • 使用内置函数str(变量名)将相应变量转换为字符串形式

    age = 22
    print('年龄是:'+str(age))
    

  • 使用占位符
    在定义字符串时可以使用占位符,需要在字符串末尾为占位符赋值

    date = '2020年7月10日'
    str='今天是:%s'%date #为占位符赋值的语句应当与字符串末尾的引号(不论是单双还是三引号)位于同一行
    print(str)
    

• 字符串运算符

  • + 字符串连接
  • * 字符串复制

    str = 'a' * 5
    print(str) #结果打印5个a
    

  • in 判断子串是否在否字符串中

    str1 = 'app'
    str2 = 'application'
    print(str1 in str2) # 打印结果为True 
    

  • not in :与in相反
  • r 保留原格式
  • 取子串

    • [i] 取相应字符串索引值为i处的字符(索引自0开始)

      str = 'abcdefgh'
      print(str[3]) #结果打印字母 d
      

    • [i:j] 取字符串中自索引i开始到索引j-1处的子串,其中索引j可以省略,此时表示取到末尾;索引 i亦可以省略,表示自索引0开始取;索引值可以取负值,最右端的索引值为-1.
      例:字符串为 abcdefgh

      a	b	c	d	e	f	g	h
      0	1	2	3	4	5	6	7
      -8	-7	-6	-5	-4	-3	-2	-1

      str = 'abcdefgh'
      print(str[2:5])#结果打印 cde
      print(str[3:]) #结果打印 defgh
      print(str[:2]) #结果打印 ab
      print(str[-1:])#结果打印 h
      print(str[:-2])#结果打印 abcdef
      print(str[-3:-1])#结果打印 fg
      print(str[:]) # 结果 abcdefgh
      

    • [i:j:k] 取子串,

      • i 开始取的索引
      • j 结束位置的后一个索引(不包含索引j处的字符)
      • k 其符号控制方向,数值控制步长
        • 当k>0时,为正向取子串,此时要求 i 表示的位置应当为与j表示的位置的左边
        • 当k<0时,为反向取子串,此时要求 i 表示的位置应当为与j表示的位置的右边
          • 当k=-1 且 i=j=0时表示逆序输出原字符串

      str = 'abcdefgh'
      print(str[::-1]) # 输出 hgfedcba
      print(str[5:2:-1]) # 输出 fed
      print(str[-3:2:-1]) # 输出 fed
      print(str[::-2]) # 输出 hfdb 其表示以步长为2逆序在原字符串末尾开始取出子串
      print(str[-3:2:-2]) # 输出 fd
      print(str[::1])  # 输出abcdefgh
      
      

• len() :求字符串的长度

  str = 'sahsk'
  print(len(str))
  print(len('hello world'))
  

字符串内建函数

• 调用方式: 字符串常量/字符串变量.函数名()
• 大小写相关函数
  • capitalize() : 将字符串的首字母(若为字母的话)变为大写
  • casefold() :把字符串转换为小写。
  • title() : 返回标题化的字符串,所有单词均以大写开始,其余小写
  • istitle() : 判断某字符串内容是否为标题化的
  • upper() : 全部转为大写字母
  • lower() : 全部转为小写字母
  • swapcase():切换大小写，小写成为大写，反之亦然。

      # 验证码检测
      import random
  
      src = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
      check_code = ''
      for i in range(4):
          pos = random.randint(0, len(src))
          check_code += src[pos - 1]
      print('验证码为{}'.format(check_code))
      user_input = input('请输入验证码:')
      if user_input.lower() == check_code.lower():
          print('验证码正确')
      else:
          print('验证码错误')
  

• 查找与替换相关函数

  • find(value, start, end)
    查找指定值的***首次***出现。如果找不到该值,则find()方法返回 -1。

    参数	描述
    value	必需。要检索的值。
    start	可选。开始检索的位置。默认是 0。
    end	可选。结束检索的位置。默认是字符串的结尾。

    find()方法与index()方法几乎相同,唯一的区别是,如果找不到该值,index() 方法将引发异常。

    # 找出某字符在某字符串中所有出现的位置
    str = 'hello world'
    pos = 0
    while pos != -1:
        pos = str.find('l', pos + 1)
        if pos != -1:
            print(pos)
    # 在一字符串中取出指定字符串:
    str = 'I come form China.'
    str_sub = input('please input:')
    i = str.find(str_sub)
    if i != -1:
        print(str[i: i + len(str_sub)])
    else:
        print('none')
    

  • rfind(value, start, end)
    方法查找指定值的***最后一次***出现。如果找不到该值，则将返回 -1

    #截取网址中的文件名
    url = 'https://dss0.bdstatic.com/5aV1bjqh_Q23odCf/static/superman/img/logo/logo.png' # 截取处logo.png
    pos = url.rfind('/') # 查找路径中 / 最后一次出现的位置
    filename = url[pos+1:]
    print(filename)
    

    rfind() 方法与 rindex() 方法几乎相同。

  • lfind() rindex() lindex()

  • replace(oldvalue, newvalue, count)
    用另一个指定的短语替换一个指定的短语。
    注释：如果未指定其他内容，则将替换所有出现的指定短语。

    参数	描述
    oldvalue	必需。要检索的字符串。
    newvalue	必需。替换旧值的字符串。
    count	可选。数字，指定要替换的旧值出现次数。默认为所有的出现。

  • startswith(value, start, end)
    如果字符串以指定的值开头，则 startswith() 方法返回 True，否则返回 False。

    参数	描述
    value	必需。检查字符串是否以其开头的值。
    start	可选。整数，规定从哪个位置开始搜索。
    end	可选。整数，规定结束搜索的位置。

  • endswith(value, start, end)
    如果字符串以指定值结尾，则 endswith() 方法返回 True，否则返回 False。

• 编码与译码相关(多用于网络应用中)

  • encode(encoding=encoding, errors=errors)
    使用指定的编码对字符串进行编码。如果未指定编码，则将使用 UTF-8。

    参数	描述
    encoding	可选。字符串。规定要使用的编码。默认是 UTF-8。
    errors	可选。字符串。规定错误方法。合法值是： ‘backslashreplace’ - 使用反斜杠代替无法编码的字符 ‘ignore’ - 忽略无法编码的字符 ‘namereplace’ - 用解释字符的文本替换字符 ‘strict’ - 默认值，失败时引发错误 ‘replace’ - 用问号替换字符 ‘xmlcharrefreplace’ - 用 xml 字符替换字符

    msg = '星期一'
    res = msg.encode('utf-8')
    print(res) # 字符串'星期一'的utf-8编码 b'\xe6\x98\x9f\xe6\x9c\x9f\xe4\xb8\x80'
    

  • decode()
    用何种编码进行的编码就需要使用何种编码进行解码

    #接上例
    res_decode = res.decode('utf-8')
    print(res_decode) # 对 b'\xe6\x98\x9f\xe6\x9c\x9f\xe4\xb8\x80' 进行译码
    

• 判断内容
  • isalnum() : 如果字符串中的所有字符都是字母数字，则返回 True。
  • isalpha(): 如果字符串中的所有字符都在字母表中，则返回 True。
  • isdecimal(): 如果字符串中的所有字符都是小数，则返回 True。
  • isdigit(): 如果字符串中的所有字符都是数字，则返回 True。
  • isidentifier(): 如果字符串是标识符，则返回 True。
  • islower() : 如果字符串中的所有字符都是小写，则返回 True。
  • isnumeric() : 如果字符串中的所有字符都是数，则返回 True。
  • isprintable() : 如果字符串中的所有字符都是可打印的，则返回 True。
  • isspace() : 如果字符串中的所有字符都是空白字符，则返回 True。
  • istitle() : 如果字符串遵循标题规则，则返回 True。
  • islower() :
  • isupper():
• 内容处理

  • join(iterabl) : 把可迭代对象的元素连接到字符串的末尾。
    获取可迭代对象中的所有项目，并将它们连接为一个字符串。
    必须将字符串指定为分隔符。
    (将调用函数的字符串作为分隔符,将序列中的元素(即参数)合并为一个字符串)

    strs = ("Bill", "Steve", "Elon")
    x = "#".join(strs)
    print(x) # 输出 Bill#Steve#Elon
    y = '-'.join("sss")
    print(y) # 输出 s-s-s
    

  • center(length, character) :
    其使用指定的字符（默认为空格）作为填充字符使字符串居中对齐。

    参数	描述
    length	必需。所返回字符串的长度。
    character	可选。填补两侧缺失空间的字符。默认是 " "（空格）。

    txt = "banana"
    x = txt.center(20, "O")
    print(x) # 输出 OOOOOOObananaOOOOOOO
    

  • count(value, start, end) 返回指定值在字符串中出现的次数。

    参数	描述
    value	必需。字符串。要检索的字符串。
    start	可选。整数。开始检索的位置。默认是 0。
    end	可选。整数。结束检索的位置。默认是字符串的结尾。

  • zfill(len):在字符串的开头填充指定数量的 0 值,直到达到指定的(参数len)长度。
    如果 len 参数的值小于字符串的长度，则不执行填充。

    参数	描述
    length	必需。所返回字符串的长度。

  • ljust(length, character) : 返回字符串的左对齐版本。

    参数	描述
    length	必需。所返回字符串的长度。
    character	可选。用于填充缺少空间（在字符串的右侧）的字符。默认值为空格。

    txt = "banana"
    x = txt.ljust(20)
    print(x, "is my favorite fruit.")#结果是，"banana" 一词的右边有14个空格。
    

  • rjust():返回字符串的右对齐版本。

  • strip(characters):返回字符串的剪裁版本。
    删除任何前导（开头的空格）和尾随（结尾的空格）字符（空格是要删除的默认前导字符）。

    参数	描述
    character	可选。一组作为前导字符,其为要删除的字符。

    txt = ",,,,,rrttgg.....banana....rrr"
    x = txt.strip(",.grt")
    print(x) # 输出banana
    

  • lstrip(characters) :返回字符串的左修剪版本,删除所有前导字符(空格是要删除的默认前导字符)

    txt = ",,,,,ssaaww.....banana"
    x = txt.lstrip(",.asw")
    print(x)# 输出 banana
    

  • partition(value) :搜索指定的字符串(及参数value)第一次出现的地方，并将该字符串拆分为包含三个元素的元组。

    1. value 之前的部分
    2. value的内容
    3. value之后的部分

    txt = "I could eat bananas all day"
    x = txt.partition("bananas")
    print(x) # 输出  ('I could eat ', 'bananas', ' all day')
    

    • 如果找不到指定的值，则 rpartition() 方法将返回一个有三个元素的元组，其中包含：
      1. 整个字符串，
      2. 一个空字符串，
      3. 一个空字符串.

  • rpartition(value):搜索指定字符串的最后一次出现，并将该字符串拆分为包含三个元素的元组。

    1. value 之前的部分
    2. value的内容
    3. value之后的部分
    • 如果找不到指定的值，则 rpartition() 方法将返回一个有三个元素的元组，其中包含：
      1. 整个字符串，
      2. 一个空字符串，
      3. 一个空字符串.

  • split(separator, max) :在指定的分隔符处拆分字符串，并返回列表。
    注释：若指定 max，列表将包含指定数量加一的元素。

    参数	描述
    separator	可选。规定分割字符串时要使用的分隔符。默认值为空白字符。
    max	可选。规定要执行的拆分数。默认值为 -1，即“所有出现次数”。

    txt = "apple#banana#cherry#orange"
    x = txt.split("#")
    print(x)#输出 ['apple', 'banana', 'cherry', 'orange']
    
    # 将 max 参数设置为 1，将返回包含 2 个元素的列表！
    x = txt.split("#", 1)
    print(x)# 输出 ['apple', 'banana#cherry#orange']
    

  • rsplit(separator, max):从右侧开始将字符串拆分为列表。
    注释：若指定 max，列表将包含指定数量加一的元素。

  • splitlines(keeplinebreaks):在换行符处拆分字符串并返回列表。

    参数	描述
    keeplinebreaks	可选。规定是否应包含换行符（True）或不包含（False）。默认值不包含（False）。

格式化输出

占位符

占位符以%开头 后跟特定字母表示特定变量,如s,d,f.....
在使用占位符后,必须在print()函数的参数列表中使用%(用于替换的值或变量)来为其赋值

• 常用占位符
  • %s 字符串占位符,(系统会自动使用str()函数将非字符串的类型转换为字符串)
  • %d 整形占位符,(系统会自动使用int()函数将非整形的数值类型转换为整形)
  • %.nf 浮点型占位符,n表示要保留的小数点后的位数(其余四舍五入)

如

name = 'Mike'
age = 22
wage = 98765.4321
date = '2020年7月10日'
#方式1:
print('我的名字是:%s,我今年%d岁,我的月薪是:%.2f元' % (name, age, wage))
print('今天是:%s' % date) #若只有一个占位符,则括号可以省略
#方式2:
mgs = '''
我的名字是:%s,我今年%d岁,我的月薪是:%.2f元
''' % (name, age, wage)
print(mgs)

format形式

format()为字符串的内置函数
在定义字符串时,在其中使用{}来代替要拼接的内容,在字符串外调用format()函数,在其参数列表中传入相应的值或变量.

• 花括号中默认为空,此时自动顺序匹配format()函数中的参数内容
• 也可以在其中可以添加索引值,用来表示此处使用format()函数中的第几个值来替换,

age = 22
str = '我今年{}岁了,我喜欢{}'.format(age, '打游戏')
print(str) # 输出我今年22岁了,我喜欢打游戏

age = 18
str2 = '我今年{1}岁了,我喜欢{0}'.format(age, '打游戏')
print(str2) # 输出我今年打游戏岁了,我喜欢18

列表 List

基本使用

- 格式:  
      列表名 = [值1,值2,值3,...值n] 
           注:
              1. 列表中的元素的数据类型可以不相同,可以为任何数据类型,如整形,列表,元组....
              2. 元素可以重复,元素有顺序
              3. 多个列表可以使用`+`进行合并,效果同内置函数 extend(列表名)
              4. 列表可以嵌套,如[1,2,[1,2],3]
- 空列表:  
       列表名 = []  
- 元素获取:   
       列表名[索引值]  索引值类似字符串,可以取负值.
- 列表长度:
       len(列表名)
- 列表排序:
       sorted(iterable, key=key, reverse=reverse)
       sorted(列表名,可选 执行以确定顺序的函数 默认为 None,可选 布尔值 False 将按升序排序，True 将按降序排序。默认为 False。)
- 元素遍历:
       使用循环
- 查找元素:
       待查找元素 in 列表名 # 其返回布尔值
- 删除元素:
       使用 关键字 del
       格式: del 列表名[索引值] 
- 取子列表:  同字符串
          列表名[起始索引:结束索引(不包含)]
          列表名[起始索引:结束索引(不包含):方向 步长]
- 添加元素:
      列表的内置函数:
              · append(元素) : 在列表末尾追加元素
              · extend(列表名): 列表合并,将参数列表中的元素添加到调用方列表末尾.
                      注意:此函数的参数也可以传入字符串,
                      这样会将参数字符串的各个字符都看作单独元素合并到调用方列表中
              · insert(position, element):在指定位置添加元素
- 交换元素:
       交换索引值为 i, j 的元素的位置
       list_name[i],list_name[j] = list_name[j],list_name[i]
- 列表元素最值:
         使用系统内置函数max(),min(),可以对元素为数字或者字符串的列表求最值
- 列表复制:
          使用乘号"*"
- 强制转换为list:
          使用函数 list() 进行转换 ,其参数必须为可迭代的数据,如字符串,元组...,也可以将range()函数生成的数据集转换为列表类型,见下例.

	元素1	元素2	元素3	元素4	元素5	元素6	元素7	元素8
正向下标	0	1	2	3	4	5	6	7
逆向下标	-8	-7	-6	-5	-4	-3	-2	-1

fruits = ['apple','bannan','orange','梨','peach']
print('grupe' in fruits) # 判断列表fruits中是否含有元素 'grupe'

# 修改列表中某元素的值
for i in len(fruits)-1:
    if '梨' in fruits[i]:
        fruits[i] = 'pair'

# 删除列表中的元素
del fruits[3]
# 列表元素降序排序(使用系统内置函数)
nums = [3, 1, 44, -1, 5, 2]
nums_sorted = sorted(nums, reverse = True)
print(nums_sorted) # 输出[44, 5, 3, 2, 1, -1]

# 列表复制
lists = [1,2]
lists_2 = lists * 2
print(list_2) #输出 [1,2,1,2]
# 类型转换
list_r = list(range(1,11,2)) 
lsit_s = list('abc') 
print(list_r) # 输出[1,3,5,7,9]
print(lsit_s) # 输出['a','b','c']

iterable 可迭代的

List 内置函数

• 添加元素

  • append(元素) : 在列表末尾追加元素
  • extend(列表名): 列表合并,将参数列表中的元素添加到调用方列表末尾.
    注意:此函数的参数也可以传入字符串,
    这样会将参数字符串的各个字符都看作单独元素合并到调用方列表中
  • insert(position, element):在指定位置添加元素

• 删除元素

  • del list_name[index] 其并非list的内置函数
  • pop(pos) 删除指定位置的元素,并将此元素返回,参数默认值为-1(即列表中的最后一个元素)

    参数	描述
    pos	可选。数字，指定需删除元素的位置。默认值 -1，返回最后的项目。

    
    fruits = ['apple', 'banana', 'cherry']
    x = fruits.pop(1)# 将列表中索引值为1的元素删除并将其赋值给变量x
    

  • remove(element) 删除列表中的第一个匹配项,若无此元素则抛出异常

    参数	描述
    element	必需。需删除的任何类型（字符串、数字、列表等）的元素。

  • clear() 删除列表中的所有元素

• copy() 返回列表的副本

• reverse() 颠倒列表的顺序,列表中元素位置改变,注意:使用列表名[::-1]不改变列表元素的顺序

• count(value) 返回具有指定值的元素数量。

• sort(reverse=True|False, key=myFunc):对列表进行排序

  参数	描述
  reverse	可选,指定是否逆序
  key=myFunc	可选。=============================

  • 冒泡排序

    lists = [9, 27, 2, 3, 7, 1, 0, -2]
    for i in range(len(lists) - 1, 0, -1):
        for j in range(i):
            if lists[j] > lists[j + 1]:
                te = lists[j]
                lists[j] = lists[j + 1]
                lists[j + 1] = te
    print(lists)
    

  tuple 元组

  类似列表

  • 格式(元素1,元素2...)
  • 元组可以为空
  • 若括号中仅有一个元素,则其数据类型为此元素的数据类型,而非元组(tuple);若在此元素后添加一个逗号,则其数据类型变为元组类型
    如:

    t1 = ('hello')
    print(type(t1))# <class 'string'>
    t2 =('hello',)
    print(type(t2))# <class 'tuple'>
    

  • 内容不可修改,元组并没有用于增删的内置函数,一旦创建,则在生命周期内不可修改
    因此元素不可排序或反转
  • 强制转换为元组
    • 使用系统内置函数 tuple() 将其他可迭代数据转换为元组类型
  • 取元素或子元组
    • 取元素:元组名称[索引值]
    • 取子元组: 同字符串及列表
  • 元组的内置函数
    • count(value) :返回元组中指定值出现的次数。
    • index(value) :查找指定值的第一次出现。如果未找到该值,将引发异常

拆包与装包

• 拆包:将可迭代数据中的元素分别赋值给一定数量的变量
  系统底层会首先将各个元素单独拆分开,之后按顺序与接收变量一一对应,
  • 例

    t1 = (1,2,4)
    a,b,c = t1
    print(a,b,c)# 输出 1 2 4
    

  • 接收变量个数应当与元素数一致,否则报错
    解决办法:装包
    • 使用 *变量名作为其中一个变量,若系统在解释时遇到星号,会将其后变量变为一个容器(列表)
      其会自动将对应位置的多余元素封装在以此列表中(即装包),当元素数相对变量数较少时会封装为空列表

      t1 = (1,2,4,6,8,9)
      a,*list_a,c  = t1 
      print(a,c,list_a) #打印 1 9 [2, 4, 6, 8]
      
      t2 = (5,)
      a,*b = t2
      print(a,b) # 输出 5 []
      

• 当容器类型的变量作为参数传入函数时，在其前方添加星号*(若为字典类型时需添加双星号**)传入,也为拆包的一种情况,其表示将容器中的元素一个一个的分离出来作为参数传入.
  如在使用print()函数打印可迭代数据时,若在其之前添加一个星号,则视为拆包,打印结果为其中的各个元素

  str = 'abcde'
  list_1 = [1, 2, 3, 4]
  tuple_1 = (5, 6, 7, 8, 9)
  print(*str)  # 输出 a b c d e
  print(*list_1)  # 输出 1 2 3 4
  print(*tuple_1)  # 输出 5 6 7 8 9
  

dict 字典

• 格式: {key:value,key:value,key:value.....}
  如:dict3 = {'ID':'19980112','name':'feng'}

• 以键值对方式保存 key:value

• key的值不可重复

• 空字典:

  • 格式1 : dict1 = {}
  • 格式2 : dict_2 = dict()

• 转换为字典:系统内置函数: dict(keyword_arguments)

  参数	描述
  keyword_arguments	必需。任意多的关键字参数,亦可以为列表

  注:当参数为列表或元组时,其内容需要满足一定的格式,使其可以转化为键值对的形式
  其参数可以为:

  • key = value,key = value ...的形式

    x = dict(name = "Bill", age = 63, country = "USA")
    

  • 列表 列表的格式需要满足[(key,value),(key,value),.....]的格式
    即列表中的元素为含有两个元素的元组,系统会将每个元组中的第一个元素作为作为key,第二个元素作为value

    dict1 = dict([('name','feng'),('age',18)])
    print(dict1) # 打印 {'name': 'feng', 'age': 18}
    

• 添加:字典名[key] = value若添加时的key值重复,则会***覆盖***原来的数据

  dict_1 = {}
  dict_1['name'] = 'feng'
  dict_2['age'] = 18
  

• 修改某个key对应的value:使用上述添加的方法,使key与原来相同

• 查找

  • in关键字:判断某值是否在字典的key中出现
  • 获得某个key对应的value值: 字典名[key], 若字典中不存在,则报错.
  • 内置函数
    • get(keyname, value):返回指定键(key)对应的值(value)

      参数	描述
      keyname	必需。您要从中返回值的项目的键名。
      value	可选。如果指定的键不存在，则返回一个值。默认值 None。

• 删除

  • del 字典名[key] 若 key不存在,则会报错
  • 内置函数
    • pop(keyname, defaultvalue)删除拥有指定键的元素,被删除的项的value通过返回值的形式返回.

      参数	描述
      keyname	必需。您要从中返回值的项目的键名。
      defaultvalue	可选,返回值,假如指定的键不存在,如果未指定此参数,且无此项目，则会引发错误。

    • popitem()删除最后插入的键值对, 删除的项目是 popitem() 方法的返回值，以元组的形式。

      car = {
      "brand": "Porsche",
      "model": "911",
      "year": 1963
      }
      x = car.popitem()
      print(x) # 打印结果 ('year', 1963)
      

    • clear()删除字典中的所有元素

• 遍历

  • 循环

    dict1 = dict([('name','feng'),('age',18)])
    for i in dict1:
        print(i,dict1[i])
    

  • 内置函数
    • items():返回包含每个键值对的元组的***列表***
      返回一个 view 对象。这个视图对象包含字典的键值对，形式为列表中的元组。
      当在字典中添加项目时，视图对象也会更新

          car = {
          "brand": "Ford",
          "model": "Mustang",
          "year": 1964
          }
          x = car.items()
          print(x)
          # 打印结果dict_items([('brand', 'Ford'), ('model', 'Mustang'), ('year', 1964)])#其为一个view对象
      
          # 因为通过items()函数返回的列表中的元素为含有两个元素的元组,因此可以通过拆包的方法获取便利时的元组中的各个元素值
          for key,value in car.items():
              print(key,value)
      

    • values():返回包含字典中所有的value的列表.
      其返回 view 对象。这个视图对象包含列表形式的字典值value。
      当在字典中添加项目时，视图对象也会更新.

          car = {
          "brand": "Porsche",
          "model": "911",
          "year": 1963
          }
          x = car.values()
          car["color"] = "white"
          print(x)# 打印结果dict_values(['Porsche', '911', 1963, 'white']) #其为一个view对象
      

    • keys():返回包含字典键的列表.
      返回 view 对象。这个视图对象包含列表形式的字典键key。
      当在字典中添加项目时，视图对象也会更新

      car = {
      "brand": "Porsche",
      "model": "911",
      "year": 1963
      }
      x = car.keys()
      car["color"] = "white"
      print(x)#打印dict_keys(['brand', 'model', 'year', 'color'])
      

• 内置函数

  • update(iterable) 使用指定的键值对字典进行更新
    参数iterable为具有键值对的字典或可迭代对象，会被插入到字典中。

        car = {
        "brand": "Porsche",
        "model": "911",
        "year": 1963
        }
        car.update({"color": "White"})
        car.update([("cost", 1000)])
        print(car)
    

  • fromkeys(keys, value)返回拥有指定键和值的字典

    参数	描述
    keys	必需。指定新字典键的可迭代对象。
    value	可选。所有键的值。默认值是 None。

    #创建拥有 3 个键的字典，值均为 0：
    x = ('key1', 'key2', 'key3')
    y = 0
    thisdict = dict.fromkeys(x, y)#此处使用关键字 "dict"调用此函数
    print(thisdict)# {'key1': 0, 'key2': 0, 'key3': 0}
    

set 集合

***无序、不重复***的元素序列(可以利用其不重复的特点去重)

• 格式 {元素1,元素2.元素3....}
• 空集合 set() 注:空集合只可以用此方法创建(空的花括号被视为空字典)

s1 = set() # 空集合
s2 = {1,2,4,7}

• 转换为集合 使用系统内置方法 set(iterable)

• 去除重复

  list_1 = [9,1,2,3,2,1,5]
  set_1 = set(list_1)#强制转换为集合类型
  print(set_1) # {1, 2, 3, 5, 9}
  

• 添加元素
  内置方法

  • add(element)向集合添加单个元素(被添加的元素必须是hashable的,比如list和set不可添加,tuple可添加)。

  x = {"apple", "banana", "cherry"}
  y = ("google", "microsoft") #其为一个元组,在使用此函数进行添加时,会将整个元组看作一个元素添加到集合中
  x.add(y) 
  x.add(100)
  print(x)#{'cherry', 100, ('google', 'microsoft'), 'banana', 'apple'}
  

  • update(iterable) 用此集合和其他可迭代数据(可以为列表,元素,集合…)的并集来更新集合。
    通过添加另一个集合中的项目来更新当前集合。
    如果两个集合中都存在一个项目，则更新后的集合中将仅出现一次该项目。

  x = {1,3,5}
  y = {1,4}
  z = (2,6)
  s= [9]
  x.update(y) 
  x.update(z) 
  print(x)# {1, 2, 3, 4, 5, 6, 9}
  

• 删除元素
  内置函数:

  • remove(item) 删除指定元素。若元素不存在则会引发错误
  • discard(value)删除指定项目。若元素不存在不引发错误
  • pop() 从集合中删除一个随机的项目(一般删除第一个),并返回被删除的值。
  • clear() 删除集合中的所有元素。

• 运算符
  注:set不支持+和*

  • in
  • == :判断集合内容是否相同
  • !=
  • - : 集合的差运算 ,效果同集合的内置函数 difference(set)
  • & : 集合的交运算,效果同集合的内置函数intersection(set1,set2 ... etc)
  • | : 集合的并运算,效果同集合的内置函数union(set1, set2 ...)
  • ^ : 集合的对称差运算(两集合中不同的元素(A | B) - (A & B)),效果同集合的内置函数symmetric_difference(set)

• 内置函数

  • remove(item) 删除指定元素。若元素不存在则会引发错误
  • discard(value)删除指定项目。若元素不存在不引发错误
  • pop() 从集合中删除一个随机的项目(一般删除第一个),并返回被删除的值。
  • clear() 删除集合中的所有元素。
  • difference(set) 与参数集合做差运算并返回此集合
  • intersection(set1,set2 ... etc) 与参数集合做交运算并返回此集合
  • union(set1, set2 ...) 与参数集合做并运算并返回此集合
  • symmetric_difference(set)与参数集合做对称差运算并返回此集合(两集合中不同的元素(A | B) - (A & B))
  • difference_update(set)在原集合中删除两个集合中都存在的项目。
    (其并不返回新的集合,则是在原集合的基础上只保留其余参数集合的差集,其不与difference(set)相同).
    亦可理解为求其与参数集合的差集并赋值给原集合.
  • intersection_update()求其与参数集合的交集并赋值给原集合.
  • symmetric_difference_update()求其与参数集合的对称差集并赋值给原集合.
  • isdisjoint() 返回两个集合是否有交集。
  • issubset()返回另一个集合是否包含此集合。
  • issuperset()返回此集合是否包含另一个集合。