内建结构-list-dict-set

1. 关于列表的函数

• append() => list.append(value)  ,在列表的最后插入元素
• insert()  =>  list.insert(n,value)  , 在第n+1个元素前面插入value
• del()    => del list[n]  , 删除第n+1个元素
• pop()  =>  value = list.pop() value为拿出的元素, 把最后一个取出来(删除)
• remove() list.remove(value),将列表中的某值删除(要删除的值必须存在于列表中)
• clear() => list.clear()   清空列表
• reverse() => list.reverse()  翻转列表内容,也可以用分片的方法
• extend() => 扩展列表,两个列表,把一个直接拼接到另一上  a.extend(b) ,将b拼接到a上
• count() =>  list.count(value) 查找列表中指定元素的个数
• copy()  => b = a.copy()  将 a copy一份并指向b   (浅拷贝)

　　深拷贝需要使用特定工具:

  2.元组 tuple - 元祖的元素不能修改,元组没有增删改的操作.

    1)元祖的创建:tuple = () / tuple = (1,2,3,...)  / tuple = 1,2,3

    2) 关于元组的函数

         —cmp(tup1,tup2): 比较两个元组元素

         —len(tup): 返回元组中元素的个数

         —max(tup): 返回元组中元素最大的值

         —min(tup): 返回元组中元素最小的值

         —tuple(seq): 将列表转化为元组

 

         —tuple.index(obj)：从元组中找出某个值第一个匹配项的索引值

 

         —tuple.count(obj)： 统计某个元素在元组中出现的次数

   3) 元组变量交换法

          

# 将变量a与b的值进行交换
a = 1
b = 2

a, b = b, a

# java风格写法
c = a
a = b
b = c

 

 

 

   4) 遍历(for循环)
        

# 单层元组的遍历
tuple = (1,2,'a',True)
for i in tuple:
    print(i)

# 多层元组的遍历
tuple = ((1,2,3), (3,4,5), (5,6,7))
for k, m, n in tuple:
    print(k,m,n)

 

3. 集合(set) ,用大括号表示,集合中的元素不能重复

 

 

    1) 无序性, 唯一性

    2) 定义: s = set() / s = {1,2,3}  注意大括号中一定要有值,否则定义的就是一个dict

    3) 集合没有索引,不能分片,可以过滤重复项,集合内的数据必须是可哈希的

    4) 集合的序列操作

       (1) 成员检测

s = {1, 2, 3, 4, 5}
print(2 in s)

    5) 集合的遍历(for)

     

s = {(1, 2, 3), (1, 2, 3), (1, 2, 3)}
for k, m, n :
    print(k, m, n)

     6) 用集合创建集合

    

s = {1,2,3,4}

ss = {i for i in s if i%2 == 0}
print(ss)

      7) 关于集合的函数

         - len max min

        - set(obj)  转化为集合

        - s.add(value)   => 向集合中添加元素

        - s.clear()   =>  清空集合

        - b.copy(s) => 拷贝

        - s.remove(value) 移除指定的值,如果要移除的值不存在则报错

        - s.discard(value) 移除集合中指定的值,如果要移除的值不存在也不报错

        - s.pop()   移除一个元素

     8) 集合的交并补:

       intersection 交集

      difference  补集

      union  并集

      issubset 检查一个元素是否是另一个元素的子集

     issuperset 检查一个集合是否为另一个超集

s1 = {1,2,3,4,5}
s2 = {3,4,5,6,7,8}

s_1 = s1.intersection(s2)

s_2 = s1.difference(s2)

s_3 = s1.union(s2)

s_4 = s1.issubset(s2)

   9) 集合的数学运算
      交:  s1 & s2
      补:  s1 - s2

      并 : s1 | s2

   10) 冰冻集合

      不能进行任何修改的集合:定义方式 >  s = frozenset()

 4.字典( dict )

   1) 创建:  d = {} / d = dict() / d = {'name':'Tom', 'age':13,...}  / d = dict({'name':'Tom', 'age':13,...})  / d = dict(name='Tom', age=13,...)  /  d = dict( [('name','Tom'), ('age',13),...])

   2) 字典是序列类型,但是是无序的,没有分片和索引,字典中的key值必须是可hash的,value无所谓

   3) 字典的常见操作:

       (1) 访问字典中的数据 : d = {'name':'Tom',age:12}  => d['name']

       (2) 字典的增删改 :

　　                             d['name'] = '小明'  修改,

                                    del d['name'] 删除 ,

                                    'key' in dict  成员检测 ,检测的是key

       (3) 字典的遍历:

      　　

d = {'name':'Tom', 'age':14}

for k in d:
    print(k, d[k])  # name  Tom \n  age  14

for k in d.keys():
    print(k, d[k]) # name Tom \n  age 14

for v in d.values():
    print(k)  #Tom  \n  14
for k, v in d.items():
    print(k, v) # name Tom \n age 14     

   4) 字典生成式

    

d = {'name':'tom', 'age':2}

dd = {k:v for k, v in d.items() if v%2 == 0}

   5) 字典的相关函数

     (1) len() max() min() dict()

     (2)str(字典):返回字典的字符串格式

     (3) clear() 清空字典

     (4) items() 返回字典的键值对组成的元组的格式

     (5)keys() 返回字典的key

     (6) values() 返回字典的value

     (7) get() 根据指定键返回相应的值,可以设置默认值

d = {'name':'tom', age:16}

print(d.get('nam'))  找不到返回None   # None

找不到返回的值可以自定义
print(d.get('nam',-1))    # -1

print(d.get('name')) 返回结果为键的值  # tom

   (8) fromkeys() 使用指定的序列作为键,使用一个值作为字典的所有的值

l = ['name','hobby']

d = dict.fromkeys(l,"dfsaf")

print(d)  # {'name':'adafd','hobby':'fdsagd'}