python 在字符串list中找出包含特定字符串的 python list 包含字符串

一、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 = {'1':'111', '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':'24'}

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':{},
                '高盛':{},
                '摩根':{},
            },
            '外滩':{}
        },
        '闵行':{},
        '静安':{},
    },
    '山东':{
        '济南':{},
        '德州':{
            '乐陵':{
                '丁务镇':{},
                '城区':{},
            },
            '虞城':{},
            '平原县':{},
        },
        '青岛':{},
    }
}

View Code

 

三、字符串

# 重复输出操作
print('Hello' * 2)

# 字符串切片
print('helloworld'[2:])

# in判断是否在字符串中
print('el' in 'hello')
print(123 in [23, 56, 123])

# 字符串拼接
a = '123'
b = '234'
c = '234'
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 = '24'))
print(st_test2.format_map({'name':'mu', 'age':24}))

# 查找索引值，会报错，find返回-1，不报错
print(st.index('d'))

# 字符串中是否只包含字母、数字、汉字。
print('abc123'.isalnum())

# 判断是否是十进制。
print('0010'.isdecimal())

# 判断字符串是否为一个整形
print(st.isdigit())
print('123999'.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:'2'}, 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(['12', '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)