全栈测试 一 | py3基础 一 常见数据类型List&Tuple&dict

元组

---

 元组：特点就是内容不可变，算只读的列表，可以被查询，不能被修改

a = 2,
print(a)
print(type(a))

b = ('a','b','c')
print(b[1])

运行结果：

(2,)
<class 'tuple'>
b

字典

---

字典：内部数据打印时是无序的，键值是哈希的，有唯一性

#创建字典
a = {'a':'python','b':'ruby','c':'java'}  #直接创建一个字典
print(a)

#内置字典方法创建：dict
a = dict((('a','b'),))
print(a)

a = dict([['a','b'],])
print(a)

#修改字典
a = {'a': 'b'}
set1 = a.setdefault("c","java")
print(a)
print(set1)

#查询操作
a = {'a':'python','b':'ruby','c':'java'}
print(a.keys())
print(a.values())
print(a.items())
print(a['a'])

#update方法
a = {'a':'python','b':'ruby','c':'java'}
b = {'d':'shell'}
a.update(b)
print(a)
a.update({'a':'javascript'})
print(a)

#删除方法
a = {'a':'python','b':'ruby','c':'java'}
a.clear()
print(a) # 清空字典

a = {'a':'python','b':'ruby','c':'java'}
del a['a']
print(a)

print("********************")
a = {'a':'python','b':'ruby','c':'java'}
b = a.pop('b')
print(a)
print(b)

print("********************")
a = {'a':'python','b':'ruby','c':'java'}
b = a.popitem()
print(a)
print(b)

a = {'a':'python','b':'ruby','c':'java'}
del a  #整个字典被删除

print('其他字典方法')
a = {'first':'python'}
b = dict.fromkeys(['a','b'],['test'])
print(a)
print(b)

print('字典的遍历')
a = {'a':'python','b':'ruby','c':'java'}
for i,j in a.items():
    print(i,j)

for i in a:    #效率比上面的高
    print(i,a[i])

字符串

---

 只列举几个简单的应用

print('join 字符串合并方法')
a = ['python','ruby','java']
b = ''.join(a)
print(b)

c = '*'.join(a)
print(c)


print('字符串常用方法')
a = 'python py'
print(a.count('p'))
print(a.capitalize())

print("format格式化输出")
a = "my favorite book {name} and {name2}"
print(a.format_map({'name':'python','name2':'java'}))
print(a.format(name = 'shell',name2 = 'bash'))
print(a.isdigit())

常用内置函数参考

---

#-- 常用列表常量和操作  
    L = [[1, 2], 'string', {}]                        # 嵌套列表  
    L = list('spam')                                  # 列表初始化  
    L = list(range(0, 4))                             # 列表初始化  
    list(map(ord, 'spam'))                            # 列表解析  
    len(L)                                            # 求列表长度  
    L.count(value)                                    # 求列表中某个值的个数  
    L.append(obj)                                     # 向列表的尾部添加数据，比如append(2)，添加元素2  
    L.insert(index, obj)                              # 向列表的指定index位置添加数据，index及其之后的数据后移  
    L.extend(interable)                               # 通过添加iterable中的元素来扩展列表，比如extend([2])，添加元素2，注意和append的区别  
    L.index(value, [start, [stop]])                   # 返回列表中值value的第一个索引  
    L.pop([index])                                    # 删除并返回index处的元素，默认为删除并返回最后一个元素  
    L.remove(value)                                   # 删除列表中的value值，只删除第一次出现的value的值  
    L.reverse()                                       # 反转列表  
    L.sort(cmp=None, key=None, reverse=False)         # 排序列表  
    a = [1, 2, 3], b = a[10:]                         # 注意，这里不会引发IndexError异常，只会返回一个空的列表[]  
    a = [], a += [1]                                  # 这里实在原有列表的基础上进行操作，即列表的id没有改变  
    a = [], a = a + [1]                               # 这里最后的a要构建一个新的列表，即a的id发生了变化  
       
#-- 用切片来删除序列的某一段  
    a = [1, 2, 3, 4, 5, 6, 7]  
    a[1:4] = []                                       # a = [1, 5, 6, 7]  
    a = [0, 1, 2, 3, 4, 5, 6, 7]  
    del a[::2]                                        # 去除偶数项(偶数索引的)，a = [1, 3, 5, 7]  
      
#-- 常用字典常量和操作  
    D = {}  
    D = {'spam':2, 'tol':{'ham':1}}                   # 嵌套字典  
    D = dict.fromkeys(['s', 'd'], 8)                  # {'d': 8, 's': 8}  
    D = dict(name = 'tom', age = 12)                  # {'age': 12, 'name': 'tom'}  
    D = dict([('name', 'tom'), ('age', 12)])          # {'age': 12, 'name': 'tom'}  
    D = dict(zip(['name', 'age'], ['tom', 12]))       # {'age': 12, 'name': 'tom'}  
    D.keys()    D.values()    D.items()               # 字典键、值以及键值对  
    D.get(key, default)                               # get函数  
    D.update(D_other)                                 # 合并字典，如果存在相同的键值，D_other的数据会覆盖掉D的数据  
    D.pop(key, [D])                                   # 删除字典中键值为key的项，返回键值为key的值，如果不存在，返回默认值D，否则异常  
    D.popitem()                                       # pop字典中的一项（一个键值对）  
    D.setdefault(k[, d])                              # 设置D中某一项的默认值。如果k存在，则返回D[k]，否则设置D[k]=d，同时返回D[k]。  
    del D                                             # 删除字典  
    del D['key']                                      # 删除字典的某一项  
    if key in D:   if key not in D:                   # 测试字典键是否存在  
    # 字典注意事项：（1）对新索引赋值会添加一项（2）字典键不一定非得是字符串，也可以为任何的不可变对象  
  
#-- 字典解析  
    D = {k:8 for k in ['s', 'd']}                     # {'d': 8, 's': 8}  
    D = {k:v for (k, v) in zip(['name', 'age'], ['tom', 12])}  
      
#-- 字典的特殊方法__missing__：当查找找不到key时，会执行该方法  
    class Dict(dict):  
        def __missing__(self, key):  
            self[key] = []  
            return self[key]  
    dct = Dict()  
    dct["foo"].append(1)    # 这有点类似于collections.defalutdict  
    dct["foo"]              # [1]  
      
#-- 元组和列表的唯一区别在于元组是不可变对象，列表时可变对象  
    a = [1, 2, 3]           # a[1] = 0, OK  
    a = (1, 2, 3)           # a[1] = 0, Error  
    a = ([1, 2])            # a[0][1] = 0, OK  
    a = [(1, 2)]            # a[0][1] = 0, Error  
      
#-- 元组的特殊语法: 逗号和圆括号  
    D = (12)                # 此时D为一个整数 即D = 12  
    D = (12, )              # 此时D为一个元组 即D = (12, )