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

 

 

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


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

 

 

 

序列:字符串,列表,元组


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


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


构造(创建)函数:
字符串: 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 序列

阅读更多

没有更多推荐了,返回首页