python中的列表、字典、字符串

列表和字符串都存在:作用

下面详细说明一下“:”在里面所起的作用;

• 格式： [起始 start:终止 end:步长 step]
• 开头（默认位置0）到结尾（默认位置-1）的整个字符串
• [:] 提取从[start:] 从start 提取到结尾
• [:end] 从开头提取到end - 1
• [start:end] 从start 提取到end - 1
• [start:end:step] 从start 提取到end - 1，每step 个字符提取一个
• 左侧第一个字符的位置/偏移量为0，右侧最后一个字符的位置/偏移量为-1

列表

1. list[::-1]翻转

list = [i for i in range(10)]
print('list[::-1]:', list[::-1])
print('list[3::-1]:', list[3::-1])

#输出
list[::-1]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
list[3::-1]: [3, 2, 1, 0]

2. list切片

list = [i for i in range(10)]
print('list[:]:', list[:])
print('list[0:2]:', list[0:2])
print("list[-1:]: ", list[-1:])
print("list[:-1]: ", list[:-1])
print("list[-8:-3]:", list[-8:-3])

#输出
list[:]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list[0:2]: [0, 1]
list[-1:]:  [9]
list[:-1]:  [0, 1, 2, 3, 4, 5, 6, 7, 8]
list[-8:-3]: [2, 3, 4, 5, 6]

3. list中的index

[1, 2, 3, 4].index(2)

#输出
１

列表

列表：用于存储任意数目、任意类型的数据集合。

列表是内置可变序列，是包含多个元素的有序连续的内存空间。列表定义的标准语法格式：
　　　　　　　　　　　a = [10,20,30,40]
其中，10,20,30,40 这些称为：列表 a 的元素。
列表中的元素可以各不相同，可以是任意类型。比如：
　　　　　　　　　　　a = [10,20,'abc',True]
列表对象的常用方法汇总如下，方便大家学习和查阅。

列表的创建

基本上语法[]创建

>>> a = [10,20,'haizei']
>>> b = []

list()创建

使用list()将任何可迭代的数据转化为列表。

>>> a = list() #创建一个空的列表对象
>>> a = list(range(10))
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a = list('haizeiwang')
>>> a
['h', 'a', 'i', 'z', 'e', 'i', 'w', 'a', 'n', 'g']

range()创建整数列表

range()可以帮助我们非常方便的创建整数列表，这在开发中及其有用。语法格式为：
　　　　　　　range([start,] end [,step])
start 参数：可选，表示起始数字。默认是 0
end 参数：必选，表示结尾数字。
step 参数：可选，表示步长，默认为 1
python3 中 range()返回的是一个 range 对象，而不是列表。我们需要通过 list()方法将其转换成列表对象。

>>> list(range(3,15,2))
[3, 5, 7, 9, 11, 13]
>>> list(range(15,3,-1))
[15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4]
>>> list(range(15,3,-2))
[15, 13, 11, 9, 7, 5]

推导式生成列表

可以使用ｉｆ过滤元素

>>> a = [i*2 for i in range(10)]
>>> a
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> a = [i for i in range(10) if i%9==0]
>>> a
[0, 9]

列表元素的添加和删除

　　当列表增加和删除元素时，列表会自动进行内存管理，大大减少了程序员的负担。但这个特点涉及列表元素的大量移动，效率较低。除非必要，我们一般只在列表的尾部添加元素或删除元素，这会大大提高列表的操作效率。

１、append()方法

原地修改列表对象，是真正的列表尾部添加新的元素，速度最快，推荐使用

>>> a = [1,2,3]
>>> a.append(4)
>>> a
[1, 2, 3, 4]
>>> a.append([5,6])
>>> a
[1, 2, 3, 4, [5, 6]]

２、+运算符操作

并不是真正的尾部添加元素，而是创建新的列表对象；将原列表的元素和新列表的元素依次复制到新的列表对象中。这样，会涉及大量的复制操作，对于操作大量元素不建议使用。

>>> a = [1,2,3]
>>> id(a)
140208770595656
>>> a = a+[4]
>>> a
[1, 2, 3, 4]
>>> id(a)
140208770595720

３、extend()方法

将目标列表的所有元素添加到本列表的尾部，属于原地操作，不创建新的列表对象。

>>> a = [20,40]
>>> id(a)
46016072
>>> a.extend([50,60])
>>> id(a)
46016072

３、insert()插入元素

使用 insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后面所有的元素进行移动，会影响处理速度。涉及大量元素时，尽量避免使用。类似发生这种移动的函数还有：remove()、pop()、del()，它们在删除非尾部元素时也会发生操作位置后面元素的移动。

>>> a = [20,'30']
>>> a.insert(1,60)
>>> a
[20, 60, '30']

列表元素的删除

index()获得指定元素在列表中首次出现的索引

index()可以获取指定元素首次出现的索引位置。语法是：index(value,[start,[end]])。其中，start 和 end 指定了搜索的范围。

第二个代码是start=3

>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.index(20)
1
>>> a.index(20,3)
5
>>> a.index(30,5,7)
6

count()获得指定元素在列表中出现的次数

cout()可以返回指定元素在列表中出现的次数。

>>> a = [10,20,30,40,50,20,30,20,30]
>>> a.count(20)
3

len()返回列表长度

成员资格的判断

　　判断列表中是否存在指定的元素，我们可以使用 count()方法，返回 0 则表示不存在，返回大于 0 则表示存在。但是，一般我们会使用更加简洁的 in 关键字来判断，直接返回 True　或 False。

>>> a = [10,20,30,40,50,20,30,20,30]
>>> 20 in a
True
>>> 100 in a
False
>>> 100 not in a
True

字符串

　　字符串的本质是：字符序列。python的字符串是不可变的，我们无法对字符串左热河修改。但可以将字符串的一部分复制到新创建的字符串，达到“看起来修改”的效果。

　　python不支持单字符类型，单字符也是作为一个字符串使用的。

　　python直接支持Unicode,可以表示世界上任何书面语言的字符。python3的字符默认就是16位Unicode编码。

１、空字符串和len()函数

>>> c = ''
>>> len(c)
0
>>> d = "I Love you 我爱你"
>>> len(d)
14

２、字符串拼接和字符串复制

可以使用＋将多个字符串拼接起来

• 如果＋两边都是字符串，则拼接。
• 如果＋两边都是数字，则加法运算。
• 如果＋两边类型不同，则会抛出异常。

>>> a = 'ab' + 'cd' + 'ef'
>>> a
'abcdef'

复制

>>> a = 'six'*3
>>> a
'sixsixsix'

３、从控制台读取字符串

我们可以使用input()从控制台读取键盘的输入的内容。

>>> myname = input("请输入你的名字:")
请输入你的名字:zhangyuting
>>> myname
'zhangyuting'

４、str实现其他数据类型转型成字符串

>>> str(3.65)
'3.65'
>>> str(5.20)
'5.2'
>>> str(3.14e2)
'314.0'
>>> str(True)
'True'
>>> 
>>> int(3.14e2)
314
>>> int('314')
314
>>> float('3.14')
3.14

５、使用[]提取字符

６、replace()实现字符串替换

字符串是’不改变的‘，这里面也可以证明。replace只是生成了新的字符串，对原字符串没有修改。

>>> a = 'abcdefhijkmno'
>>> a.replace('a', '我')
'我bcdefhijkmno'
>>> a
'abcdefhijkmno'

７、字符串切片slice操作

看上面具体的介绍

>>> a = 'abcdefghijkmn'
>>> a[:]
'abcdefghijkmn'
>>> a[2:]
'cdefghijkmn'
>>> a[2:4]
'cd'
>>> a[1:5:2]
'bd'
>>> 
>>> a[-3:]
'kmn'
>>> a[-6:-2]
'hijk'
>>> a[::-1]
'nmkjihgfedcba'

８、split()分割和join()合并

split()可以基于指定分隔符将字符串分割成多个子字符串（存储在列表中），若不指定分隔符，默认使用空白字符（换行符/空格/制表符）。

>>> a = 'to be or not to be'
>>> a.split()
['to', 'be', 'or', 'not', 'to', 'be']
>>> a.split('be')
['to ', ' or not to ', '']

split() 方法语法：

str.split(str="", num=string.count(str)).

参数

• str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
• num -- 分割次数。默认为 -1, 即分隔所有。

>>> a.split(' ', 1)
['to', 'be or not to be']

join的作用和split()作用刚好相反，用于将一系列字符串连接起来。

>>> a = ['1', '2', '3']
>>> '*'.join(a)
'1*2*3'
>>> ''.join(a)
'123'

拼接字符串要点

使用字符串拼接＋，会生成新的字符串对象，因此不推荐使用＋来拼接字符串，推荐使用join函数，因为join函数在拼接字符串之前会计算所有字符串的长度，然后逐一拷贝，仅新建一次对象。

字典

统计字符串中每个字符的个数，选取前k个作为输出

# -*- coding:utf-8 -*-
class Solution:
    def topNum(self, str, k):
        dt = {}
        for c in str:
            if c not in dt:
                dt[c] = 1
            else:
                dt[c] += 1
        print(dt)
        print(dt.items())
        print(type(dt.items()))
        for i in dt.items():
            print(i[1])
        L = sorted(dt.items(), key=lambda item: item[1], reverse=True)
        return L[:k]

so = Solution()
str = 'sdavsdfsdfwrhgfjhhedfsad'
res = so.topNum(str, k=5)
print(res)

　　字典是“键值对”的无序可变序列，字典中的每个元素都是一个键值对，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、删除、更新对应的“值对象”。

　　字典中通过“键对象”找到对应的“值对象”。“键”是任意的不可变数据，比如：整数，浮点数，字符串，元组。但是：列表，字典，集合这些可变对象不能作为“键”。并且“键”不可重复。“值”可以是重复的数据，并且可以重复。

１、字典的创建

a = dict(name='zhangyu',age=18,dd=[1,2,3])
b = dict(name='zhangyu',age=18,dd=[1,2,3])
c = dict([('name','zhangyu'),('age',18)])
>>> e = {}
>>> f = dict()

通过zip()函数创建字典对象

>>> k = ['name', 'age', 'job']
>>> v = ['zhangyu', '18', 'pro']
>>> zip(k,v)
<zip object at 0x7f37720ebe08>
>>> d = dict(zip(k,v))
>>> d
{'name': 'zhangyu', 'age': '18', 'job': 'p

通过fromkeys创建值为空的字典

>>> a = dict.fromkeys(['name', 'age', 'job'])
>>> a
{'name': None, 'age': None, 'job': None}

2、字典元素的访问

1. 通过 [键] 获得“值”。若键不存在，则抛出异常。

2. 通过 get()方法获得“值”。推荐使用。优点是：指定键不存在，返回 None；也可以设定指定键不存在时默认返回的对象。推荐使用 get()获取“值对象”

3. 列出所有的键值对

>>> a = {'name':'zhangyu', 'age':24, 'job':'pro'}
>>> a.items()
dict_items([('name', 'zhangyu'), ('age', 24), ('job', 'pro')])

4. 列出所有的键，列出所有的值

>>> a.keys()
dict_keys(['name', 'age', 'job'])
>>> a.values()
dict_values(['zhangyu', 24, 'pro'])

5. len() 键值对的个数
6. 检测一个“键”是否在字典中

>>> a = {'name':'zhangyu', 'age':24, 'job':'pro'}
>>> 'name' in a
True

访问字典

#-*-coding:utf-8-*-
a = {'name': 'zhangyu', 'age': 24, 'job': 'pro'}
for i in a:
    print(i)

for i in a.keys():
    print(i)

for i in a.values():
    print(i)


#结果
name
age
job
name
age
job
zhangyu
24
pro

统计字符串每个字符的个数

#-*-coding:utf-8-*-
def solution(str):
    res = {}
    for i in str:
        if i not in res:
            res[i] = 1
        else:
            res[i] += 1
    return res

if __name__ == "__main__":
    res = solution(str='adfsadfasfasfasfsdfvgrf')
    print(res)

３、字典元素的添加、修改、删除

1. 给字典新增“键值对”。如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在，则新增“键值对”。

>>> a = {'name':'zhangyu', 'age':24, 'job':'pro'}
>>> a['address'] = 'hangzhou'
>>> a
{'name': 'zhangyu', 'age': 24, 'job': 'pro', 'address': 'hangzhou'}

2. 使用 update()将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复，则直接覆盖

>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> b = {'name':'gaoxixi','money':1000,'sex':'男的'}
>>> a.update(b)
>>> a
{'name': 'gaoxixi', 'age': 18, 'job': 'programmer', 'money': 1000, 'sex': '男的'}

3. 字典中元素的删除，可以使用 del()方法；或者 clear()删除所有键值对；pop()删除指定键值对，并返回对应的“值对象”；

>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> del(a['name'])
>>> a
{'age': 18, 'job': 'programmer'}
>>> b = a.pop('age')
>>> b
18

4. popitem() ：随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念；popitem 弹出随机的项，因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不首先获取键的列表）

>>> a = {'name':'gaoqi','age':18,'job':'programmer'}
>>> a.popitem()
('job', 'programmer')
>>> a
{'name': 'gaoqi', 'age': 18}
>>> a.popitem()
('age', 18)
>>> a
{'name': 'gaoqi'}

４、序列解包

序列解包可以用于元组、列表、字典。序列解包可以让我们方便的对多个变量赋值。

>>> x,y,z=(20,30,10)
>>> x
20
>>> y
30
>>> z
10
>>> (a,b,c)=(9,8,10)
>>> a
9 >
>> [a,b,c]=[10,20,30]
>>> a
10
>>> b
20

序列解包用于字典时，默认是对“键”进行操作； 如果需要对键值对操作，则需要使用items()；如果需要对“值”进行操作，则需要使用 values()；

>>> s = {'name':'gaoqi','age':18,'job':'teacher'}
>>> name,age,job=s #默认对键进行操作
>>> name
'name'
>>> name,age,job=s.items() #对键值对进行操作
>>> name
('name', 'gaoqi')
>>> name,age,job=s.values() #对值进行操作
>>> name
'gaoqi

三元运算符

推导式创建序列

推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合，从而避免冗长的代码。推导式是典型的 Python 风格，会使用它代表你已经超过 Python 初学者的水平。

列表推导式

列表推导式生成列表对象，语法如下：
                                  [表达式 for item in 可迭代对象 ]
                                或者：{表达式 for item in 可迭代对象 if 条件判断}

>>> [x for x in range(1,5)]
[1, 2, 3, 4]
>>> [x*2 for x in range(1,5)]
[2, 4, 6, 8]
>>> [x*2 for x in range(1,20) if x==5]
[10]
>>> [a for a in 'abcadas']
['a', 'b', 'c', 'a', 'd', 'a', 's']
>>> cell = [(row,col) for row in range(1,5) for col in range(1,5)]
>>> cell
[(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (3, 1), (3, 2), (3, 3), (3, 4), (4, 1), (4, 2), (4, 3), (4, 4)]

字典推导式

字典的推导式生成字典对象，格式如下：
                          {key_expression : value_expression for 表达式 in 可迭代对象}
类似于列表推导式，字典推导也可以增加 if 条件判断、多个 for 循环。

>>> str = 'i love you i love haizeiwang'
>>> dt = {c:str.count(c) for c in str}
>>> dt
{'i': 4, ' ': 5, 'l': 2, 'o': 3, 'v': 2, 'e': 3, 'y': 1, 'u': 1, 'h': 1, 'a': 2, 'z': 1, 'w': 1, 'n': 1, 'g': 1}

集合推导式

集合推导式生成集合，和列表推导式的语法格式类似：
                                      {表达式 for item in 可迭代对象 }
                      或者：{表达式 for item in 可迭代对象 if 条件判断}

>>> {x for x in range(1,100) if x%9==0}
{99, 36, 72, 9, 45, 81, 18, 54, 90, 27, 63}

生成器推导式

一个生成器只能运行一次。第一次迭代可以得到数据，第二次迭代发现数据已经没有了

>>> gnt = (x for x in range(1,100) if x%9==0)
>>> for x in gnt:
print(x,end=' ')
9 18 27 36 45 54 63 72 81 90 99
>>> for x in gnt:
print(x,end=' ')
>>>

集合

集合是无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典中的“键对象”，因此是不能重复的且唯一的

集合创建和删除

1. 使用{}创建集合对象，并使用 add()方法添加元素

>>> a = {3, 5, 7}
>>> a
{3, 5, 7}
>>> a.add(9)
>>> a
{9, 3, 5, 7}
>>> a.add(3)
>>> a
{9, 3, 5, 7}

2. 使用 set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保留一个。

>>> a = [1, 2, 3, 3]
>>> a
[1, 2, 3, 3]
>>> b = set(a)
>>> b
{1, 2, 3}

3. remove()删除指定元素；clear()清空整个集合

>>> a = {10,20,30,40,50}
>>> a.remove(20)
>>> a
{10, 50, 30}

集合相关操作

像数学中概念一样，Python 对集合也提供了并集、交集、差集等运算。我们给出示例：

>>> a = {1,3,'sxt'}
>>> b = {'he','it','sxt'}
>>> a|b #并集
{1, 3, 'sxt', 'he', 'it'}
>>> a&b #交集
{'sxt'}
>>> a-b #差集
{1, 3}
>>> a.union(b) #并集
{1, 3, 'sxt', 'he', 'it'}
>>> a.intersection(b) #交集
{'sxt'}
>>> a.difference(b) #差集
{1, 3}