字符串、列表、元组、字典、集合 差异及关联

 

 

字符串、列表、元组、字典、集合　差异及关联

可迭代对象：　字符串，列表，元组，字典，集合，固定集合
可变容器：　　　列表，字典(无序)，集合(无序)，
不可变容器：　元组，固定集合(无序)

 

 

 

序列：字符串，列表，元组

集合，固定集合不重复元素
字典不重复键


字面值表示方法：
字符串           列表            元组　　　       字典　　　　　　　　
 ''　　　　　   []　　　　()　　　         {}    
 ""　                                单元素加,     :分隔键值对
 ''' '''
 """ """


构造(创建)函数：
字符串：　str()
列表：　list()    list(可迭代对象iterable)
元组： tuple()　　　tuple(iterable)
字典： dict()    dict(iterable)   dict(命名关键字传参)
集合： set()　　　　　set(iterable)
固定集合：frozenset()    frozenset(iterable)
　例：
　　d = dict([('name', 'tarena'), ('age', 15)])
　　d = dict(name='tarena', age=15)


索引　index：
字符串：  字符串[整数表达式]
列表：　　列表[整数表达式]　　　可索引赋值
元组：等同列表
字典：　字典[键]　　
　　　　添加/修改字典元素：字典[键]　= 值对象　　　
　　　　　　若字典中有该键则修改原先值


切片slice:
 字符串：字符串[开始索引　：结束索引　：步长]
　列表：　列表[start index : end index : 步长]
　　　　　切片赋值：列表[切片] = 可迭代对象
　元组切片同列表规则相同
　注：步长可省略，当步长为负整数时，反向切片。
　　　　元组的切片返回一个元组
    元组不能索引赋值和切片赋值


推导式：
　列表：　[表达式 for 变量　in 可迭代对象]　或　　[表达式 for 变量　in 可迭代对象 if 真值表达式]
　字典：{键表达式 : 值表达式 for 变量 in 可迭代对象 [if 真值表达式]}
　集合：{ 表达式 for 变量 in 可迭代对象 [if 真值表达式]}
 注：字典，集合中的中括号代表内容可省略


列表推导式的嵌套:
  语法:
    [表达式1 
      for 变量1 in 可迭代对象1 if 真值表达式1
        for 变量2 in 可迭代对象2 if 真值表达式2]


  示例：
    想生成
      ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
    [x + y for x in 'ABC' for y in '123']
　
字典推导式的嵌套：
  语法同列表推导式嵌套


方法(常用)：
　字符串：
　　S.isdigit()     判断字符串中的字符是否全为数字
　　S.isalpha()     判断字符串是否全为英文字母
　　S.islower()     判断字符串所有字符是否全为小写英文字母
　　S.isupper()     判断字符串所有字符是否全为大写英文字母
　　S.isspace()     判断字符串是否全为空白字符
　　S.center(width[,fill])  将原字符串居中，左右默认填充空格
　　S.ljust(width[,fill])   将字符串左对齐
　　S.rjust(width[,fill])   将字符串右对齐
　　S.count(sub[, start[,end]])     获取一个字符串中子串的个数
　　S.find(sub[, start[,end]])  获取字符串中子串sub的索引,失败返回-1
　　S.strip()   返回去掉左右空白字符的字符串
　　S.lstrip()  返回去掉左侧空白字符的字符串
　　S.rstrip()  返回去掉右侧空白字符的字符串　　    
　　S.upper()   生成将英文转换为大写的字符串
　　S.lower()   生成将英文转换为小写的字符串　


　　S.replace(old, new[, count])    
　　　　将原字符串的old用new代替，生成一个新的字符串


　　S.startswith(prefix[, start[, end]])    　　　　返回S是否是以prefix开头，如果以prefix开头返回True,否则返回False,


　　S.endswith(suffix[, start[, end]])  　　　　返回S是否是以prefix开头，如果以prefix开头返回True,否则返回False


　　S.title()     生成每个英文单词的首字母大写字符串
　　S.isnumeric()   判断字符串是否全为数字字符


　列表：
　　L.index(v [, begin[, end]])     返回对应元素的索引下标, begin为开始索引，end为结束索引,当 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　value 不存在时触发ValueError错误
　　L.insert(index, obj)    将某个元素插放到列表中指定的位置
　　L.count(x)  　　　　返回列表中元素的个数
　　L.remove(x)     从列表中删除第一次出现在列表中的值
　　L.copy()    　　　　复制此列表（只复制一层，不会复制深层对象)
　　L.append(x)     向列表中追加单个元素
　　L.extend(list)  向列表追加另一个列表
　　L.clear()   　　　　清空列表,等同于 L[:] = []
　　L.sort(reverse=False)   将列表中的元素进行排序，默认顺序按值的小到大的顺序排列
　　L.reverse()     列表的反转，用来改变原列表的先后顺序
　　L.pop([index])  删除索引对应的元素，如果不加索引，默认删除最后元素，同时返回删除元素的引用关系
 
 元组：
  T.count(value)  返回元素个数（同list.count)
  T.index(value, [start, [stop]]) 返回某个元素在元组的索引位置（同list.index)
　
　字典：
　　D.clear()     　　清空字典
　　D.pop(key)  　　　　移除键，同时返回此键所对应的值
　　D.copy()    　　　　返回字典D的副本,只复制一层(浅拷贝)
　　D.update(D2)    将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值
　　D.get(key, default)     返回键key所对应的值,如果没有此键，则返回default  
　　D.keys()    　　　　返回可迭代的 dict_keys 集合对象（即得到键的集合）
　　D.values()  　　　　返回可迭代的 dict_values 值对象
　　D.items()   　　　　返回可迭代的 dict_items 对象


　集合：
　　S.add(e)    　　　　　在集合中添加一个新的元素e；如果元素已经存在，则不添加
　　S.remove(e)     　从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误
　　S.discard(e)    　从集合S中移除一个元素e;
　　S.clear()   　　　　　清空集合内的所有元素
　　S.copy()    　　　　　将集合进行一次浅拷贝
　　S.pop()     　　　　　从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常
　　S.update(s2)    　用 S与s2得到的全集更新变量S
　　S.difference(s2)    　　　　　　　　用S - s2 运算，返回存在于在S中，但不在s2中的所有元素的集合
　　S.difference_update(s2)     等同于 S = S ^ s2
　　S.intersection(s2)  　　　　　　　　等同于S & s2
　　S.intersection_update(s2)   等同于S = S & s2
　　S.isdisjoint(s2)    如果S与s2交集为空返回True,非空则返回False
　　S.issubset(s2) 　　　　　如果S与s2交集为非空返回True,空则返回False
　　S.issuperset(...)   如果S为s2的子集返回True,否则返回False
　　S.symmetric_difference(s2)  　　　　　　　　返回对称补集,等同于 S ^ s2
　　S.symmetric_difference_update(s2)   用S 与 s2的对称补集更新 S
　　S.union(s2)     生成 S 与 s2的全集


函数：
　字符串编码转换函数
  ord(c)   返回一个字符的Unicode值
  chr(i)   返回i这个值所对应的字符
　整数传换为字符串函数:
  hex(i)  将整数转换为 十六进制字符串
  oct(i)  将整数转换为 八进制字符串
  bin(i)  将整数转换为 二进制字符串
　数值对象的构造(创建)函数
  float(obj)   用字符串或数字转换为浮点数
  int(x='0', base=10) 用数字或字符串转换为整数，如果不给出参数，则返回0
  complex(r=0.0, i=0.0)  用数字创建一个复数(实部为r,虚部为i)
  bool(x)     用x创建一个布尔值(True/False)
python3常用于序列的函数:
  len(seq)  返回容器的元素个数
  max(x)    返回序列(或键)的最大值元素
  min(x)    返回序列(或键)的最小值元素
  sum(x)    返回序列(或键)中所有元素的和(元素必须是数值类型)
  any(x)    真值测试, 如果容器内其中一个值为True则返回True,否则返回False
  all(x)    真值测试, 容器内所有元素的布尔值为True才返回True
　　reversed(seq)  返回反向顺序的迭代器对象
  sorted(iterable, reverse=False) 返回已排序的列表


运算：
 字符串的运算:
  + 加号运算符用于拼接字符串
  += 运算符用原字符串与右侧字符串拼接生成新的字符串
  示例：
    s = 'ABCD' + 'EFG'
    s += '123'
    print(s)
    s2 = s + s  # 
    print(s2)


  *  生成重复的字符串
  *= 生成重复的字符串并让原变量绑定生成后的字符串
  示例：
    s = "ABC" * 3  # s='ABCABCABC'
    print(s)
    s2 = 5 * '0'  # s3 = '00000'
    s = "123"
    s *= 3  # s = '123123123'
    
 列表的运算:
  + 用于拼接列表
    x = [1,2,3]
    y = [4,5,6,7]
    z = x + y # z = [1, 2, 3, 4, 5, 6, 7]
  += 用原列表与右侧列表拼接，并用变量绑定新列表
    x = [1,2,3]
    x += [4,5,6]  # x = [1,2,3,4,5,6]


  * 生成重复的列表
    x = [1,2] * 3  # x = [1,2,1,2,1,2]
    y = 3 * [5,6]  # y = [5,6,5,6,5,6]


  *= 生成重复的列表，并给原变量赋值
    x = [3,4]
    x *= 2  # x = [3,4,3,4]
    y = 3
    y *= [7,8]  # y = [7,8,7,8,7,8]


 元组的所有运算同列表的运算方式一致


集合的运算:
  交集， 并集，补集，子集，超集
运算符:
  & | - ^ < <= > >= == !=
  in / not in


& 生成两个集合的交集
  s1 = {1, 2, 3}
  s2 = {2, 3, 4}
  s1 & s2   # {2, 3}


| 生成两个集合的并集
  s1 = {1, 2, 3}
  s2 = {2, 3, 4}
  s1 | s2   # {1, 2, 3, 4}


- 生成两个集合的补集
  s1 = {1, 2, 3}
  s2 = {2, 3, 4}
  s1 - s2   # {1} #生成属性s1但不属于s2的所有元素的集合


^ 生成两个集合的对称补集
  s1 = {1, 2, 3}
  s2 = {2, 3, 4}
  s1 ^ s2  # {1, 4}


> 判断一个集合是另一个集合的超集
< 判断一个集合是别一个集合的子集
  {1, 2, 3} > {1, 2}  # True
  {2, 3, 1} > {3, 2}  # True
  {2, 3, 4} < {1, 2, 3, 4}  # True


== / != 集合相同和不同
  {1, 2, 3} == {3, 2, 1}  # True
  {1, 2, 3} != {2, 3, 4}  # True


  frozenset 与　set 的运算完全相同


比较运算符：
　字符串的比较运算:
    >
    >=
    <
    <= 
    ==
    != 
  格式:
    x > y
  比较规则：
    1. 字符串x的第一个字母与字符串y的第一个字母比较,如果不相同，则直接得到比较结果，如果相同，则再取第二个字母进行比较，以此类推
    2. 比较的依据是字符的UNICODE编码值


　列表的比较运算:
  运算符:
    < <= > >= == !=
  示例：
    [1,2,3] < [1,2,4]  # True
    [1,3]  > [1,2,4]   # True
    [5]  < [5, 0]      # True
    ["ABC", "123"] > ['abc', '456']  # False
    [1, "two"]  > ["two", 1]  # TypeError
    [1, 2]  < [3.3, 4]  # True
    [1]  < ['2']  # TypeError


in / not in 运算符
  作用：
    用于序列，字典，集合等容器中，用于判断某个值是否存在于容器中,如果存在返回True,否则返回False
not in 与 in 运算符的返回结果相反
格式:
    对象 in 序列