Python 学习之路（三） - 数据序列

一、列表

        （一）、列表

                列表可以一次性储存多个数据，数据可以为不同类型

                        例：List = [1, 1.2, '1', {'name' : 'Tom}, {1, 2, 3}, [1, 2, 3]]

        （二）、两种创建列表的方式

a = []  # 创建一个空的列表
print(a, type(a))
b = list('123')
print(b, type(b))  # 通常用来转化


"""
输出：
[] <class 'list'>
['1', '2', '3'] <class 'list'>
"""

        （三）、列表嵌套

# 列表是可以嵌套的，例：
List = [[1, 2, 3], ['1', '2', '3'], ['a', 'b', 'c']]

        （四）、列表增加数据

# 数据增加(append)
List = [1, 2, 3, 4]
print(List)
List.append(5)  # append将数据添加到列表最后面
print(List)
List.append([6, 7, 8, 9])  # 如果append是一个序列，那么将会追加整个序列到列表
print(List)


"""
输出：
[1, 2, 3, 4]
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, [6, 7, 8, 9]]
"""

# extend()  列表结尾追加数据，如果数据是一个序列，则将这个序列的数据逐一添加到列表
List = ['0', '1', '2']
List.extend('4567')
print(List)

# 输出：['0', '1', '2', '4', '5', '6', '7']

# insert() 指定位置新增数据    格式：insert(索引位置, 数据)
date = [1, 2, 4, 5]
print(date)
date.insert(2, 3)  # 第二个位置中添加一个数据，python是从0开始计算，即数据1位置是0
print(date)

"""
输出：
[1, 2, 4, 5]
[1, 2, 3, 4, 5]
"""

二、字典

        可以用来储存多个数据，字典里面的数据是以"键值对"形式出现，字典数据和数据顺序没有关系，即字典不支持下标，后期无论数据的顺序如何变化，只需要按照对应的键的名字查找数据即可。

        字典特点：
        - 符号为大括号{}
        - 数据为键值对形式出现
        - 各个键值对之间用逗号隔开
        - 字典没有索引(下标)的概念!

# 1、空字典
Dict = {}  # 创建一个空的字典
# 注：字段前面的key值需要引号括起来，不然系统会判断为变量，字典中可以以变量数据代入（key值和value值均可）
dictionary = {
    'name': 'Tom',
    'age': 15,
    'gender': '男',
    'school': 'Harvard University'
}  # 创建一个有数据的字典

# 增加，在字典中，使用    字典名字[key值] = value值     就可以往字典中加入新的数据了
# 特别注意：字典中的这个key如果存在则会被直接替换，比如 dictionary['age'] = 17，那么字典数据age的value值将会直接替换为17
# 往字典中加入ID字段
print(dictionary)
dictionary['age'] = 22  # key值存在，那么对应的value值将会被替换
print(dictionary)
dictionary['id'] = 1  # key值不存在，那么就会加入一个新的key值和value值
print(dictionary)

"""
输出：
{'name': 'Tom', 'age': 21, 'gender': '男', 'school': 'Harvard University'}
{'name': 'Tom', 'age': 22, 'gender': '男', 'school': 'Harvard University'}
{'name': 'Tom', 'age': 22, 'gender': '男', 'school': 'Harvard University', 'id': 1}
"""

三、元组

        一个元组可以存储多个数据，元组内的数据是不能修改的
        元组特点：定义元组使用小括号，且逗号隔开各个数据，数据可以是不同的数据类型，且元组内的数据是不能修改的。

        特别注意：如果定义的元组只有一个数据，那么这个数据后面也好添加逗号，否则数据类型为唯一的这个数据的数据类型

        我通常使用元组是用于给变量赋值，如：a, b, c = 1, 2, 3

t2 = (10,)
print(type(t2))  # tuple

t3 = (20)
print(type(t3))  # int

t4 = ('hello')
print(type(t4))  # str

四、集合

        创建集合使用`{}`或`set()`， 但是如果要创建空集合只能使用`set()`，因为`{}`用来创建空字典。集合的特点，不会有重复的数据，可以用来去重，因为集合是无序的，所以集合不支持下标。

s1 = {10, 20, 30, 40, 50}
print(s1)

s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2)  #  去重成{40, 10, 50, 20, 30}

s3 = set('abcdefg')
print(s3)  # {'d', 'f', 'c', 'g', 'a', 'b', 'e'}

s4 = set()
print(type(s4))  # set

s5 = {}
print(type(s5))  # dict

五、公共操作

运算符	描述	支持类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	元素是否不存在	字符串、列表、元组、字典

        （一）、+  合并

                在字符串和列表以及元组当中，+意味着合并，即将两个值合并，在int整形变量中，意味着进行数值计算

s, s1 = 'hello', ' world'  # 这是一个元组操作，意思就是将 world赋值给s1,将hello赋值给s
print(s + s1)
List, List_1 = [1, 2, 3], ['1', '2', '3']  # 列表相加
print(List + List_1)
t, t1 = (1, 2, 3), ('1', '2', '3')  # 元组相加
print(t + t1)
print(20 + 20)  # int类型

"""
输出：
hello world
[1, 2, 3, '1', '2', '3']
(1, 2, 3, '1', '2', '3')
40
"""

        （二）、 * 复制 

                将一个值重复多次

s = 'hello ' * 5  # 字符串
print(s)
List = [666] * 5  # 列表
print(List)
Tuple = (1, 2) * 5  # 元组
print(Tuple)
print(4 * 5)  # 放在int类型里表示运算

"""
输出：
hello hello hello hello hello 
[666, 666, 666, 666, 666]
(1, 2, 1, 2, 1, 2, 1, 2, 1, 2)
20
"""

        （三）、in/not in

                 成员运算符，判断指定序列中是否可以找到这个值，找到返回True，找不到返回False；not in则相反

print('s' in 'hello')
print('s' not in 'hello')
print(1 in [1, 2, 3, 4])
print(1 not in [1, 2, 3, 4])
print(1 in ('1', '2', '3'))  # 识别类型，int类型的1和str类型的1不一样，所以不存在
print(1 not in ('1', '2', '3'))
print('names' in {'name': 'Tom', 'age': 12, 'order': 'names'})  # 注意：字典找的是key不是value
print('name' not in {'name': 'Tom', 'age': 12})

"""
输出：
False
True
True
False
False
True
False
False
"""

六、常用查找、切片 ★

         “下标”又叫“索引”，就是编号；下标的作用即是通过下标快速找到对应的数据，在Python中下标的计算是从0开始的，即第一个数据编号为0，以此类推

        （一）、查找

                下标、索引

                         格式：变量名[索引]

List = [1, 2, 3, 4, 5, 6]
print(List[0])  # 查找List中第0个数据，返回的值是1
print(List[-1])  # -号的作用是反着取，即查找List中最后一个数据
# 注意：从后面开始取值的时候，索引是从1开始，不是0
# 索引支持的变量有很多，字符串和元组同理，取值方法同上，以下为一些不能进行索引的数据类型

Set = {1, 2, 3, 4}  # 集合不支持索引，如果打印则会报错
# print(Set[0])  # 这段代码运行将会报错，所以暂时注释了

Dict = {
    'age': 15,
    'id': 20,
    'name': 'Tom'
}
# print(Dict[0])  # 字典也不能进行索引，因为这个0会被认为是一个key，运行这段将会报错


"""
输出：
1
6
"""

                字典的查找

                        格式：变量名[key值]

                                在使用字典查找的时候需要理解一个概念，就是什么是key值（键值），以及什么是value值，比如下方的字典，key值即是age、id、name这三个，后面的15, 20, 'Tom'都是这个这些键值所分别对应的value值，即冒号前面的是key值，冒号后面到逗号前面是这个key对应的value值；键值和value值是一一对应的，即age不能又是15，也是20；如果需要给一个value值赋值多个数据，请使用列表（list）或者字典（dict）以及集合（set）、元组（tuple）这种可以储存多个数据的数据类型，value值是可以支持任何合理的数据类型的；在字典中是支持变量的，key值也可以是变量，所以记得加上引号声明意义为字符串。

Dict = {
    'age': 15,  # value值错误写法15,20    如果需要多个数据请使用列表等
    'id': 20,
    'name': 'Tom'
}
print(Dict['age'])  # 找出字典中age的对应的value值，即15
# print(Dict['school'])  # 键值(key值)不存在就报错

# 输出：15



# value和key值都可以是变量
s = 'name'
Dict_01 = {
    s: 'Tom',
    'age': 12,
    'order': s
}
print(Dict_01)

# 输出：{'name': 'Tom', 'age': 12, 'order': 'name'}


# get()
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name'))  # Tom
print(dict1.get('id', 110))  # 110
print(dict1.get('id'))  # None 

        （二）、切片

                是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

                序列[开始位置下标:结束位置下标:步长]
                1. 不包含结束位置下标对应的数据， 正负整数均可；
                2. 步长是选取间隔，正负整数均可，默认步长为1。

a = [88, 13, 11, 77, 59, 11, 79, 86, 48, 33]
print(a[:])  # 取全部数据
print(a[:3])  # 取前3个数据
print(a[3:])  # 取第三个之后的全部数据
print(a[1:3])  # 从第二个数据开始取到第三个，不取第三个，左闭右开
print(a[::2])  # 跳一个取一个数据
print(a[1:7:2])  # 取第二个数据到第七个前，跳一个取一个
print(a[:-1])  # 取第一个到最后一个前（不取最后一个）的数据，即去除最后一个数据
print(a[-2:])  # 取最后两个数据，即第-2个数据到结束
print(a[-3:-1])  # 倒数第三个数据到最后一个数据前，左闭右开
print(a[-4:-1:-1])  # 特别注意，这样是取不到数据的，因为步长和取值范围发生了冲突

# 字符串和元组的取法和这个列表是一样的，就不在这里写了


"""
输出：
[88, 13, 11, 77, 59, 11, 79, 86, 48, 33]
[88, 13, 11]
[77, 59, 11, 79, 86, 48, 33]
[13, 11]
[88, 11, 59, 79, 48]
11 [13, 77, 11]
[88, 13, 11, 77, 59, 11, 79, 86, 48]
[48, 33]
[86, 48]
[]
"""

七、其它操作

        （一）、增加数据

                列表

# 列表 append
a = [15, 20, 25, 62]
b = [21, 23, 66, 77]
a.append(47)  # 往数组中增加一个数据
print(a)
a.append(b)
print(a)  # 将b整个数据追加到后面

# 输出
"""
[15, 20, 25, 62, 47]
[15, 20, 25, 62, 47, [21, 23, 66, 77]]
"""

# extend()  追加到结尾，如果数据是一个序列，则将这个序列的数据逐一添加到列表
a = ['hello']
b = ' world'
a.extend(b)
print(a)
a.extend([' world', 'hi'])  # 如果不想被打散，那就把加的东西变为一个列表
print(a)

"""
输出：
['hello', ' ', 'w', 'o', 'r', 'l', 'd']
['hello', ' ', 'w', 'o', 'r', 'l', 'd', ' world', 'hi']
"""

# insert() 指定位置新增数据 格式：列表名.insert(索引位置, 要加的内容)
a = [1, 3, 4, 5, 6]
a.insert(1, 2)  # 往位置1，即第二个数据位置插入新的数据，数据是2
print(a)

# 输出：[1, 2, 3, 4, 5, 6]

                字典 

                        注意：往字典中加入新数据时请保证原本字典没有这个key值，否则就是修改原来的数据。

# 往字典中加入数据的格式是  字典名字[key值] = value值
Dict = {'id': 1, 'age': 18, 'name': 'lisa'}
print(Dict)
Dict['gender'] = '女'  # 字典中加入一个键值gender，其中的value值是女
print(Dict)
Dict['id'] = 2  # 键值存在就修改，注意id需要引号
print(Dict)

"""
输出：
{'id': 1, 'age': 18, 'name': 'lisa'}
{'id': 1, 'age': 18, 'name': 'lisa', 'gender': '女'}
{'id': 2, 'age': 18, 'name': 'lisa', 'gender': '女'}
"""

        （二）、删除数据

# del删除数据   格式：del 变量
a = [1, 3, 7, 5, 23]
del a  # 删除后变量会一同删除，这个时候再打印就会显示没有定义这个变量
# 全部数据类型都可以，相当于删除了整个变量


# pop 索引删除  格式：变量名.pop(索引)
b = [1, 2, 3, 6]
b.pop(2)  # 删除第三个元素
print(b)
# 需要可以被索引的数据类型

# 输出：[1, 2, 6]


# remove 删除值，移除的是元素     格式：变量名.remove(元素)
c = [1, 2, 3, 6]
c.remove(3)  # 删除3这个元素，元素不存在就报错
print(c)

# 输出：[1, 2, 6]


# clear 删除列表中全部元素，但是变量名保留   格式：变量名.clear()
d = [1, 2, 3, 6]
d.clear()  # 删除元素
print(d)
# 字典也同理

# 输出：[]

        （三）、修改数据

# list修改数据    格式：变量名[索引] = 新的值
a = [2, 5, 6, 7, 8]
a[0] = 4
print(a)

# reversed  倒换数据顺序
a.reverse()  # 将a的数据顺序倒换过来
print(a)

# sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作，且sort只是改变顺序，sorted则是返回一个新的数据
# sort格式：列表.sort(reverse= True)     sorted格式：sorted(iterable, cmp=None, key=None, reverse=False)
a = [1, 5, 3, 15, 7, 9]
a.sort()
print(a)
b = [1, 4, 6, 17, 8, 11]
c = sorted(b)
print(b, c, sep='\n')  # sep是每一个逗号隔开用什么，默认是一个空格，这里换成换行

"""
输出：
[4, 5, 6, 7, 8]
[8, 7, 6, 5, 4]
[1, 3, 5, 7, 9, 15]
[1, 4, 6, 17, 8, 11]
[1, 4, 6, 8, 11, 17]
"""

        （四）、遍历循环

                依次打印列表中的各个数据。

a = [17, 33, 37, 74, 11, 99, 76, 30, 88, 91]
for i in a:
    print(i)

"""
输出：
17
33
37
74
11
99
76
30
88
91
注：元组、集合、字符串也是依次打印各个字符，这里就不一一列举了
"""


# 字典
# 遍历key值
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
    print(key)

"""
输出：
name
age
gender
"""


# 遍历value值
for value in dict1.values():
    print(value)

"""
输出：
Tom
20
男
"""


# 遍历key和value值
for i in dict1.items():
    print(i)

"""
输出：
('name', 'Tom')
('age', 20)
('gender', '男')
"""

八、字符串其它操作

        （一）、count

                计算字符串某个元素出现的次数

                格式：字符串.count(子串, 开始位置下标, 结束位置下标)

# count 计算元素出现的次数   格式：字符串.count(子串, 开始位置下标, 结束位置下标)
string = 'hello my name is xxx, what your name？ Do you like your name？'
print(string.count('name'))  # 3
print(string.count('names'))  # 0
print(string.count('name', 0, 30))  # 计算开始到第30个字符这个元素出现了几次，注：空格也算一个字符


"""
输出：
3
0
1
"""

        （二）、replace 替换字符

                格式：字符串.replace(旧子串, 新子串, 替换次数)

                注意：替换次数如果查出子串出现次数，则替换次数为该子串出现次数。

                特别注意 : replace方法不能直接修改数据

# replace 替换字符
string = 'hello my name is xxx, what your name？ Do you like your name？'
new_string = string.replace('name', 'Name')
print(new_string)
new_string_01 = string.replace('name', 'Name', 1)
print(new_string_01)


"""
输出：
hello my Name is xxx, what your Name？ Do you like your Name？
hello my Name is xxx, what your name？ Do you like your name？
"""

        （三）、split分隔字符

                格式：字符串.split(分割字符, 分割的次数)

string = 'hello my name is xxx, what your name？ Do you like your name？'
print(string.split())  # 默认以一个空格分隔为列表，不写分隔次数分隔全部
print(string.split('?'))  # 按指定内容分隔
print(string.split(' ', 3))  # 就分隔三次


"""
输出：
['hello', 'my', 'name', 'is', 'xxx,', 'what', 'your', 'name？', 'Do', 'you', 'like', 'your', 'name？']
['hello my name is xxx, what your name？ Do you like your name？']
['hello', 'my', 'name', 'is xxx, what your name？ Do you like your name？']
"""

        （四）、join  列表或者元组 拼接字符串

                格式：字符或子串.join(多字符串组成的序列)

string = ['My', 'name', 'is', 'lisa']
print(' '.join(string), type(' '.join(string)))


"""
输出：
My name is lisa <class 'str'>
"""

        （五）、strip 删除字符串两边内容

                格式：字符串.strip(内容)        内容默认为空格

# 可以看见，中间的空格没有去除，只能去除两边的内容
s1 = ' hello world '
print(s1.strip())

# 输出：hello world


# 当然，也可以自己指定去除什么字符串
s2 = 'Hello world he'
print(s2.strip('He'))

# 输出：llo world h

        （六）、find 找到字符串的索引位置

                格式：字符串.find(要找的字符串, 从哪开始, 到哪结束)

string = '你好呀,最近过得怎么样？'
print(string.find('好'))  # 注：索引从0开始计算
print(string.find('好', 4))  # 从第4个开始找
print(string.find('好', 100))  # 超出范围也是-1，即找不到
print(string.find('好', 1, 10))  # 也可以指定开始和结束位置


"""
输出：
1
-1
-1
1
"""

最后给个随便写的案例运用

# 实例，统计字符串出现次数并将值进行降序排序
s = 'You and me from one world We are family travel dream A thousand miles meeting in Beijing Come together ' \
    'Share the joy of life You and me from one world we are family You and me from one world we are family'
date = {}
for i in s.split():
    if i in date.keys():
        date[i] += 1
    else:
        date[i] = 1
print(sorted(date.items(), key=lambda Sort: (Sort[1], Sort[0]), reverse=True))
# lambda不熟悉，不然可以将key按升序，value按降序这种


# 输出：[('world', 3), ('one', 3), ('me', 3), ('from', 3), ('family', 3), ('are', 3), ('and', 3), ('You', 3), ('we', 2), ('travel', 1), ('together', 1), ('thousand', 1), ('the', 1), ('of', 1), ('miles', 1), ('meeting', 1), ('life', 1), ('joy', 1), ('in', 1), ('dream', 1), ('We', 1), ('Share', 1), ('Come', 1), ('Beijing', 1), ('A', 1)]