Python_列表、字典、字符串、集合操作

一、list

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。对于list的操作，我们要学会增删改查。

查

我们可以直接索引查找，也可以通过切片进行查找，切片的原则是左包括右不包括。

　　L = ['wuchao','jinxin','xiaohu','sanpang','ligang']

　　print(L[1:])            # 取到最后

　　print(L[1:-1])          # 取到倒数第二个

　　print(L[1:-1:2])        # 步长为2，从左到右一次走两个，也就是隔一个取一个，默认步长为1

　　print(L[3::-2])         # 步长为2，从右往左

　　count：统计某个元素在列表中出现的次数。

　　P = ['to', 'be', 'or', 'not', 'to', 'be']

　　t = P.count('to')

　　print(t)

　　index:：查找list中某个元素的索引值，配合修改，如果一个列表中有多个同样的值，要取出其中一个，可以使用切片的方式打印出小列表，在进行相加。

　　a = ['wuchao','jinxin','xiaohu','sanpang','ligang']

　　print(a.index('jinxin'))

　　in:：查看某元素是否在列表里

　　b = ['wuchao','jinxin','xiaohu','sanpang','ligang']

　　print('wj' in b)

增

增加有两种方式，分别是append()和insert()，他们的区别是append()只能是在最后变追加，而insert()可以通过索引，将数据插入到人任意位置。

　　L = ['wuchao','jinxin','xiaohu','sanpang','ligang']

　　L.append('xuepeng')     # 默认插入到最后一个位置

　　L.insert(2,'wj')        # 将数据插入任意位置

　　extend：方法可以在列表的末尾一次性追加另一个序列中的多个值。

　　a = [1,2,3]

　　b = [4,5,6]

　　a.extend(b)

　　print(a)

　　print(b)

改

其实就是把list中的值取出来，再次进行赋值。

　　L = ['wuchao','jinxin','xiaohu','sanpang','ligang']

　　L[1] = 'haidilao'       # 普通替换

　　L[1:3]=['a', 'b']       # 切片修改

　　reverse：倒叙打印列表，直接对列表进行操作，无返回值。

　　a = ['wuchao','jinxin','xiaohu','sanpang','ligang']

　　a.reverse()

　　print(a)

　　sort：按照顺序打印,字母的排序是按照ACISS码进行排序。

    a = [4,6,8,2,1,5,2]

    b = ['wuchao','jinxin','Xiaohu','sanpang','Ligang']

    a.sort()

    a.sort(reverse=True)

    b.sort()

    print(a)

    print(b)

删

我们删除通常有三种方式，分别是remove()、pop()和del()，其中最需要注意的是pop()删除方法，他既可以按照索引位置删除，同时还可以返回删除的值，之后会经常使用。

　　L = ['wuchao','jinxin','xiaohu','sanpang','ligang']

　　L.remove('wuchao')      # 删除wuchao

　　L.removr(L[0])          # 删除0位置

　　L.pop(0)                # 直接删除索引位置

　　M = L.pop()            # pop可以返回删除的值，之后很常用，如果括号内不写，则表示最后一个
　　del L[0]                # del直接删除，删除多个

　　L.clear()               # 清空

二、字典（dictionary）

字典一种key - value 的数据类型，使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容。

语法：

dic = {'name':'mu', 'age':24, 'hobby':{'name':'girl', 'age':23}, 'is_handsome':True}

字典特性：

　　字典是无序的；

　　key值是唯一的。

对于字典的操作，增删改查是基础的运用，对于字典，还需掌握字典的遍历、字典的嵌套等等。

增

　　增加有两种方式，一种是直接增加，一种是使用内置方法增加。

dic_1 = {'name':'mu'}

dic_1['age'] = 24

print(dic_1)

dic_1.setdefault('hobby', 'girl')

ret = dic_1.setdefault('hobby', 'girl')

print(ret)

print(dic_1)

查

　　可以单个查看，也可以整体查看，同时可以只提取键或者值进行查看。

dic_2 = {'name': 'mu', 'hobby': 'girl', 'age': 24}

print(dic_2['name'])

# 查看dict中所有的键、值和键值对，需要注意的是，这是一个新的数据类型，并不是一个列表,如果需要拿出来使用，需要进行类型转换

print(dic_2.keys())

print(dic_2.values())

print(dic_2.items())

print(type(dic_2.keys()))

print(list(dic_2.keys()))

改

dic_3 = {'name': 'mu', 'hobby': 'girl', 'age': 24}

dic_3['age'] = 18

print(dic_3)

# update 更新： 如下调用dic_4之后，会将dic_4的能容更新至dic_3，如果有相同的键，则更新值

dic_4 = {'':'', 'name':'wj'}

dic_3.update(dic_4)

print(dic_3)

print(dic_4)

删

　　通过删除键，来删除整个键值对。

dic_5 = {'name': 'mu', 'hobby': 'girl', 'age': 24}

del dic_5['name']             # 删除字典中的某组指定键值对

print(dic_5)

　　清空整个字典。

dic_5 = {'name': 'mu', 'hobby': 'girl', 'age': 24}

dic_5.clear()

print(dic_5)

　　删除整个字典。

dic_5 = {'name': 'mu', 'hobby': 'girl', 'age': 24}

del dic_5

print(dic_5)

　　pop删除，这个删除后是有返回值的

dic_5 = {'name': 'mu', 'hobby': 'girl', 'age': 24}

ret = dic_5.pop('age')        # 删除字典中的某组指定键值对，并返回值
print(ret)
print(dic_5)

　　返回键值对,随机删除一对，因为dict是无序的。

dic_5 = {'name': 'mu', 'hobby': 'girl', 'age': 24}

a = dic_5.popitem()

print(a,dic_5)

其他操作

　　当值一样时，批量创建建。

dic_6 = dict.fromkeys(['host1', 'host2', 'host3'], 'test')

print(dic_6)

dic_6['host1'] = 'abc'

print(dic_6)

　　字典排序。

dic_7 = {'c':555, 'b':333, 'a':111}

sorted(dic_7)

sorted((dic_7.values()))

print(sorted(dic_7))

print(sorted((dic_7.values())))

　　字典的遍历，字典的遍历,for循环循环字典遍历的时候，默认打印键。

dic = {'name':'mu', 'age':''}

for i in dic:

    print(i)

for i in dic.values():

    print(i)

for i in dic:

    print(i,dic[i])                                     # 推荐用这种，速度快，直接打印

for i in dic.items():

    print(i)

for i, v in dic.items():                                # 数据需要转换，用这种方式，耗内存，并且时间长

    print(i, v)

　　字典的嵌套。

menu = {

    '北京':{

        '朝阳':{

            '国贸':{

                'CICC':{},

                'HP':{},

                '渣打银行':{},

                'CCTV':{}

            },

            '望京':{

                '陌陌':{},

                '阿里巴巴':{},

                '奔驰':{}

            },

            '三里屯':{

                '优衣库':{},

                'apple':{},

            }

        },

        '昌平':{

            '沙河':{

                '老男孩':{},

                '阿泰包子':{}

            },

            '天通苑':{

                '链家':{},

                '我爱我家':{},

            },

            '回龙观':{}

        },

        '海淀':{

            '五道口':{

                '谷歌':{},

                '网易':{},

                'Sogo':{},

                '快手':{},

            },

        },

        '中关村':{

            '优酷':{},

            '爱奇艺':{},

            '腾讯':{},

            '汽车之家':{},

            '新东方':{},

        }

    },

    '上海':{

        '浦东':{

            '陆家嘴':{

                'CICC':{},

                '高盛':{},

                '摩根':{},

            },

            '外滩':{}

        },

        '闵行':{},

        '静安':{},

    },

    '山东':{

        '济南':{},

        '德州':{

            '乐陵':{

                '丁务镇':{},

                '城区':{},

            },

            '虞城':{},

            '平原县':{},

        },

        '青岛':{},

    }

}

三、字符串

# 重复输出操作

print('Hello' * 2)

# 字符串切片

print('helloworld'[2:])

# in判断是否在字符串中

print('el' in 'hello')

print(123 in [23, 56, 123])

# 字符串拼接

a = ''

b = ''

c = ''

d1 = a + b + c                                  # 效率低，开辟多内存，不好

print(d1)

d2 = '---'.join([a, b ,c])                      # 效率高,是通过某个字符串将这三个拼接起来

print(d2)

# python内置方法

st = 'hello world'

# 统计元素个数

print(st.count('l'))

# 字符串首字母大写

print(st.capitalize())

# 打印50’-‘，字符串居中

print(st.center(50, '-'))

# 判断字符串是以某个字符串为开始/结尾的，返回布尔值

print(st.endswith('d'))

print(st.startswith('s'))                           # 文件处理判断标准

# 添加空格（没用）

st_test1 = 'he\tllo world'

print(st_test1.expandtabs(5))

# 查找到字符串的第一个元素，并将索引值返回

print(st.find('d'))

# 格式化赋值

st_test2 = 'hello world {name} is {age}'

print(st_test2.format(name = 'mu', age = ''))

print(st_test2.format_map({'name':'mu', 'age':24}))

# 查找索引值，会报错，find返回-1，不报错

print(st.index('d'))

# 字符串中是否只包含字母、数字、汉字。

print('abc123'.isalnum())

# 判断是否是十进制。

print(''.isdecimal())

# 判断字符串是否为一个整形

print(st.isdigit())

print(''.isdigit())

print('123456.999'.isnumeric())

# 判断字符串是否为全小写/大写

print(st.islower())

print(st.isupper())

# 判断是否为空格

print(' '.isspace())

# 判断是否标题（每个单词首字母大写）

print('My Title'.istitle())

# 所有大写变为小写/小写变大写/反转大小写

print('My Title'.lower())

print('My Title'.upper())

print('My Title'.swapcase())

#

print('My Title'.ljust(20,'*'))

print('My Title'.rjust(20,'*'))

# 去掉左右的空格和换行，字符串内的空格不动

print(' My Title', '\n', ''.strip())

四、set

定义：把不同的元素组合到一起就是set

作用：可变集合，可对集合进行添加删除等，set整体是可哈希的，里边的值是不可哈希的。他本身是不能做字典的键。

特点：元素必须是不同的，如果是相同的，会自动去掉一个,集合对象是一组无序的可哈希的值，是不可变类型，集合成员可以做字典的键。（字典的键也是不可哈希的）

1. set的创建

s_1 = set('linux_unix')                           # 会进行去重

print(s_1)

将set转换为list：

s_2 = ['mu', 'ee', 'mu']

s_3 = set(s_2)

print(set(s_3), type(s_3))

s_4 = list(s_3)

print(s_4, type(s_4))

　　不可哈希的值会报错：

li = [[1, 2], 3, 4]

s = set(li)

print(s)

li = [{1:''}, 3, 4]

s = set(li)

print(s)

2. 访问set

　　使用for循环遍历：

s_2 = ['mu', 'ee', 'mu']

s_3 = set(s_2)

for i in s_3:

    print(i)

3. 更新set

　　add添加：把后边会当作一个整体，update会将容器中的值分开，但是add会认为添加了一个容器

s_1 = ['mu', 'ee', 'mu']

s_2 = set(s_1)

s_2.add('uu')

print(s_2)

　　update：会把后边的值当作每一个元素进行更新

s_1 = ['mu', 'ee', 'mu']

s_2 = set(s_1)

s_2.update('oppos')

print(s_2)

s_1 = ['mu', 'ee', 'mu']

s_2 = set(s_1)

s_2.update(['', 'old'])

print(s_2)

　　remove：删除

s_1 = ['mu', 'ee', 'mu']

s_2 = set(s_1)

s_2.remove('mu')

print(s_2)

　　pop：随机删除

s_1 = ['mu', 'ee', 'mu', 'wj']

s_2 = set(s_1)

s_2.pop()

print(s_2)

　　clear：清空集合中的值

s_1 = ['mu', 'ee', 'mu']

s_2 = set(s_1)

s_2.clear()

print(s_2)

　　del：直接删除集合

s_1 = ['mu', 'ee', 'mu']

s_2 = set(s_1)

del s_2

print(s_2)

4. 集合的操作符

　　in, not in

s_1 = ['mu', 'ee', 'mu']

s_2 = set(s_1)

print('mu' in s_2)

print('mu' not in s_2)

　　等价于不等价（==，！=）

print(set('abc') == set('abccba'))

　　父级子集

print(a.issubset(b))                                      # a完全包含b

print(a.issubset(b))                                      # a是b的子集，b完全包含a

5. 关系测试：交集、并集、差集、对称差集

a = set([1, 2, 3, 4, 5])

b = set([4, 5, 6, 7, 8])

# intersection: 交集

print(a.intersection(b))                                  # a, b中都有的值

print(a & b)

# union: 并集

print(a.union(b))                                         # a, b中所有的值

print(a | b)

# difference: 差集

print(a.difference(b))                                     # 在a中但是不在b中

print(a - b)

# symmetric_difference: 对称差集

print(a.symmetric_difference(b))                           # 对称差集（反向交际），除去a, b中都有的值

print(a ^ b)

巴特西