Python入门-数据容器

数据容器

分为五类：列表（list）元组（tuple）字符串（str）集合（set）字典（dict）

列表 [ list ]

列表内的每一份数据，称之为元素，元素之间使用逗号隔开，列表一次可以存储多个数据，且可以为不同的数据类型，支持嵌套

# 列表索引
list_name = ['python',666,True]
print(list_name[0]) # 列表索引 'python'
print(list_name[-1])# 列表索引， True

# 嵌套索引
list_name = [[1,2,3],[4,5,6]]
print(list_name[0][1])

列表索引必须是整数或切片(下面有讲解)，而不是元组

---

列表的方法

方法和函数功能一样，有传入参数有返回值，只是方法的使用格式不同

函数可以直接定义调用，而方法需要先获得方法所在的 class 类对象，然后通过类对象调用方法

# 函数定义与使用
def add(x,y):
    return x + y
num = add(1,2) # 函数的使用

# 方法的定义与使用
class Student:
    def add(self,x,y):
        return x + y
student = Student()
num = student.add(1,2) # 方法的使用

1.列表的查询功能（方法）

（1）语法：列表.index（元素） # 查找某元素的下标(下标从 0 开始)

功能：查找指定元素在列表的下标功能，如找不到，报错ValueError, 若多个值, 只返回第一个

语法：列表.find（元素）

功能: 和index几乎一致, 唯一不同的是找不到不报错, 而是返回 -1

# 查找某元素的 下标
list_name = [1,2,3,[4,5,6]]
index1 = list_name.index(2)
index2 = list_name.index(5)
print(index1)  # 1
print(index2) # ValueError

# 只适用于字符串, 返回位置索引
ss = 'abcdeaaabbb'
print(ss.find('e'))		# 4
print(ss.find('f'))		# -1

# 起始区间(左闭右开, 从0开始, 索引到位置 3-1也就是2 结束)
print(ss.find('c', 0, 3))	# 2

2.列表的修改功能（方法）

（2）语法：列表[下标] = 值

功能：修改特定位置（索引）的元素值

# 修改指定位置索引值
list_name[0] = 'itcast'
print(list_name[0]) # itcast

（3）语法：列表.insert（下标，元素）

功能：在指定的下标位置，插入指定的元素

# 指定位置插入元素
list_name.insert(1,'it')
print(list_name) # ['itcast', 'it', 2, 3, 4, 5, 6]

（4）语法：列表.append（元素）

功能：将指定元素，追加到列表的尾部

# 尾部添加数据
list_name.append('python')
print(list_name) # ['itcast', 'it', 2, 3, 4, 5, 6, 'python']

（5）语法：列表.extend（其他数据容器）

功能：将其它数据容器的内容取出，依次追加到列表尾部

# 追加一批数据
list_name.extend([7,8,9,'py'])
print(list_name) 
# ['itcast', 'it', 2, 3, 4, 5, 6, 'python', 7, 8, 9,'py']

list2 = {'a1':1} 
list_name.extend([(7,8,9),'python',list2]) # 含元组 字典
print(list_name)
# ['itcast', 'it', 2, 3, 4, 5, 6, 'python', (7, 8, 9), 'py', {'a1': 1}]

list2 = {'a2':2}
list_name.extend(list2)
# ['itcast', 'it', 2, 3, 4, 5, 6, 'python', (7, 8, 9), 'py', {'a1': 1}, 'a2']

（6）语法1：del 列表 [下标]

​ 语法2：列表.pop(下标)

​ 功能：删除指定位置的元素

# 删除元素
del list_name[1]
print(list_name)
# ['itcast', 2, 3, 4, 5, 6, 'python', (7, 8, 9), 'py', {'a1': 1}, 'a2']

cc = [1,1,2,2,3,4,5,1]
cc.pop(2)
print(cc) 
# [1, 1, 2, 3, 4, 5, 1]

（7）语句：列表.remove（元素）

​ 功能：删除某元素在列表中的第一个匹配项

# 删除第一个匹配项
my_list = [1,2,3,1,2,3]
my_list.remove(1)
print(my_list) # [2, 3, 1, 2, 3]

（8）语法：列表.clear（）

​ 功能：清空列表内容

# 清空列表
my_list.clear()
print(my_list)  # []

（9）语法：列表.count（元素）

​ 功能：统计某元素在列表内的数量

# 统计某元素在列表内的数量
print(list_name.count(2)) # 1

（10）语法：len(列表)

​ 功能：统列表中全部的元素数量

# 列表内有多少元素
print(len(list_name)) # 10

案例

list_num = [1,2,3,4,5,6,7,8,9,10]
list_singular = []
list_even = []

singular = 0
while singular < len(list_num):
    ele1 = list_num[singular]
    if ele1 % 2 == 0:
        list_singular.append(ele1)
    singular += 1
print(f'奇数列表元素：{list_singular}')

for even in list_num:
    if even % 2 == 0:
        list_even.append(even)
print(f'偶数列表元素：{list_even}')

---

元组（tuple）

元组可以说是一个不可变列表，所以，当我们需要在程序内封装数据，又不希望被封装的数据被篡改，那么元组就非常适合了。

注：元组只有一个数据时，数据后面要添加逗号，否则不是元组类型

# 用法跟列表一样，常用：index()、count()、len()
# 定义空元组
变量名称 = () # 方式1
变量名称 = tuple() # 方式2

# 注
t1 = ('hello',)
t2 = (1,)
t3 = tuple('main')
print(type(t1),t1) # <class 'tuple'> ('hello',)
print(type(t2),t2) # <class 'tuple'> (1,)
print(type(t3),t3) # <class 'tuple'> ('m', 'a', 'i', 'n')

# 元组中若包含 list ，则这个list可以被 修改
t7 = (1,2,3,[4,5,6])
print(t7)	# (1, 2, 3, [4, 5, 6])
t7[3][0] = 9
t7[3][2] = 'lll'
print(t7) 	#(1, 2, 3, [9, 5, 'lll'])

---

字符串 ( str )

同元组一样，字符串是一个无法修改的数据容器

1.语法：字符串.replace（字符串1，字符串2）

功能：将字符串内的全部：字符串1，替换为字符串2

注：字符串本身不变，而是得到了一个新字符串

# 字符串的替换
a = '112233'
b = '222'
print(a.replace(a,b)) # 222
print(a,b)	 # 112233 222
print(a.replace('1','6')) # 662233

2.语法：字符串.split（分隔符字符串）

功能：按照指定的分隔符，将字符串划分成多个 ，存入列表对象中

注：字符串本身不变，而是得到一个列表对象

# 字符串的分割
my_str = 'python and it'
print(my_str.split()) 
# 默认空格分隔 等同于：print(my_str.split(' '))
# 返回一个列表：['python', 'and', 'itheima']

3.（1）语法：字符串.strip( )
功能：去前后空格以及换行符

（2）语法：字符串.strip(字符串)
功能：去掉前后指定字符串

相当于默认去除前后空格，有参数传入时去掉传入的参数

# 字符串的规整操作
a = '  python and itcast  '
b = '12python and 12 true 21'
print(a.strip()) # python and itcast
print(b.strip('12')) # python and 12 true 
# 注：传入的是'12',但'1'和'2'都会被移除，是按照单个字符 

4.‘分隔符’.join(容器)

功能: 用指定的 分隔符 把容器中的字符串 拼接 成一个大的字符串

s5 = ['苹果', '香蕉', '橘子', '火龙果', '榴莲']
new_s5 = '-'.join(s5)
print(s5)
print(new_s5)
# ['苹果', '香蕉', '橘子', '火龙果', '榴莲']
# 苹果-香蕉-橘子-火龙果-榴莲

5.(1) startswith(字符串): 判断是否以指定字符串 开头

names = ['张三', '张三丰', '李四', '张强', '王强', '李强']
for i in names:
    if i.startswith('张'):
        print(i)

(2) endswith(字符串): 判断是否以指定字符串 结束

for i in names:
    if i.endswith('强'):
        print(i)

6.数字字符串

数字字符串返回True,其他则False

print('1'.isdigit())	# True
print('a1'.isdigit())	# False

---

数据容器的序列和切片

序列：是指内容连续、有序，可使用下标索引的一类数据容器, 列表、元组、字符串，均可以视为序列

切片：从一个序列中，取出一个子序列

语法：序列 [ 起始下标：结束下标：步长 ]

起始下标可不写，默认从头开始，到结束下标（不含），步长可不写，默认为1，步长负数表示反向取（注：起始结束下标也要反向标记）

str_val = 'hello,python!hello,world!'
print(str_val[11:5:-1])
print(str_val[-14:-20:-1])
# nohtyp
# nohtyp

---

集合 ( set )

列表、元组、字符串都支持重复元素，若使用场景需要对内容做去重，它们就不方便了。而集合最主要的特点就是不支持元素的重复（自带去重）、并且内容无序。

# 集合
s1 = {1，'a'} # 定义集合变量
s1 = list() # 定义空集合

因集合是无序的，所以不支持下标索引访问，但可以修改

1.语法：集合.add（元素）

功能：集合本身被修改，将指定元素添加到聚合内

2.语法：集合.remove（元素）

功能：集合本身被修改，将指定元素从集合内移除，无论有几个

3.语法：集合.pop（）

功能：从集合内随机移除一个元素，集合本身被修改，不可传参

4.语法：集合.clear（）

功能：清空集合

# 集合用法
my_set = {'python','itcast','hello',1,2,3,4,5,6}

my_set.add(999) # 语法1
print(my_set)
# {1, 2, 'itcast', 3, 4, 5, 6, 999, 'python', 'hello'}

my_set.remove(4) # 语法2
print(my_set)
# {1, 2, 'itcast', 3, 5, 6, 999, 'python', 'hello'}

my_set.pop() # 语法3
print(my_set)
# {2, 'itcast', 3, 5, 6, 999, 'python', 'hello'}

my_set.clear() # 语法4
print(my_set)
# set()

5.语法：集合1.difference（集合2）

功能：取出集合1和集合2的差集（集合1有而集合2没有的）

6.语法：集合1.difference_update（集合2）

功能：集合1内，删除和集合2相同的元素

7.语法：集合1.update（集合2）

功能：修改集合1,保留与集合2的并集(不用新定义集合3的union)

8.语法：集合1.union（集合2）

功能：将集合1和2组合成新集合,需要新定义集合3接收,原集合1,2不变

# 集合差集
set1 = {1,2,3,'py','it'}
set2 = {2,5,6,'it'}
set3 = set1.difference(set2)
print(set3) #{1, 3, 'py'}
# 得到一个新集合。set1 和 set2 不变

# 消除集合差集
set1.difference_update(set2)
print(set1) # {1, 3, 'py'}
# 集合1被修改，集合2不变

# 集合合并
set4 = set1.union(set2)
print(set4) # {1, 'py', 3, 2, 5, 6, 'it'}
# 得到新集合，集合1和集合2不变

print(set1) # 7 统计集合内元素数量

# 集合的遍历 for循环
set5 = {'it', 1, 2, 3, 5, 6, 'py','it', 1, 2, 3, 5, 6, 'py'}
for i in set5:
    print(i)
# it 2 3 1 5 6 py
# 因为集合不支持下标索引，所以无法使用while循环遍历

my_trin = ['python', 'hello', 'python', 'hello', 'world', '1', '1', 2, 2]
set_empty = set()

for i in my_trin:
    set_empty.add(i)
print(set_empty)

---

字典 ( dict )

字典跟集合一样使用 { }，都是无序的 ，不过存储的元素是一个个的键值对，不可以使用下标索引，因此不支持while循环，可使用 len() 函数来查看字典有多少元素

字典中的key是不可变数据类型.，但key和value可以是任意类型。key不可以为字典，不允许重复，若有重复的key，新的value将把老的value覆盖

# 定义空字典
my_dict = {} # 大括号
my_dict = dict() # 加上函数，使用小括号

# 定义字典，基于key获取value
my_dict = {'w':99,'z':88,'l':77}
print(my_dict) # {'w': 99, 'z': 88, 'l': 77}
print(my_dict['w']) # 99

# 嵌套字典
my_dict = {
    'w': {'Chinese': 77, 'math': 66, 'English': 33},
    'z': {'Chinese': 88, 'math': 86, 'English': 55},
    'l': {'Chinese': 99, 'math': 96, 'English': 66}
}
print(my_dict['w']['Chinese']) # 77

1.语法：字典[key] = value 结果：字典被修改，新增 or 更新元素

注：字典key不可重复，所以对已经存在的key执行上述操作，就是更新value

# 新增 or 更新元素
dict1 = {'k1': 1}
dict1['k2'] = 2  # 新增元素 key加value是一个元素
print(dict1)	 # {'k1': 1, 'k2': 2}
dict1['k1'] = 0	 # 更新元素
print(dict1)	 # {'k1': 0, 'k2': 2}

2.语法：字典.pop（key） 结果：字典被修改，元素被删除

3.语法：字典.clear（） 结果：清空字典

# 删除元素
dict1.pop('k1')
print(dict1)	# {'k2': 2}
# 清空字典
dict1.clear()
print(dict1)	# {}

4.语法：字典.keys（） 结果：得到字典中的全部key

# 获取全部keys
dict2 = {'a1': 1,'a2': 2,'a3': 3}
print(dict2.keys()) # dict_keys(['a1', 'a2', 'a3'])

# for循环遍历字典 
# 获取key完成遍历
dict2 = {'a1': 1,'a2': '2','a3': True}
keyes = dict2.keys()
for i in keyes:
    print(f'字典的key是{i}')
    print(f'字典的value是{dict2[i]}')
# 字典的key是a1	# 字典的value是1
# 字典的key是a2	# 字典的value是2
# 字典的key是a3	# 字典的value是True

# 直接对字典进行遍历，每次都是直接得到key
for j in dict2:
    print(j)	# a1 a2 a3 值的方法与上述一样

案例

# 级别为1的员工级别加1 且工资加 1000
my_dict = {
    'wang': {'partment': 'technology', 'salary': 3000, 'level': 1},
    'Jay': {'partment': 'market', 'salary': 5000, 'level': 2},
    'JJ': {'partment': 'market', 'salary': 7000, 'level': 3},
    'zhang': {'partment': 'technology', 'salary': 4000, 'level': 1},
    'liu': {'partment': 'market', 'salary': 6000, 'level': 2}
}

for k, v in my_dict.items():
    print(k, v)

for i in my_dict:
    if my_dict[i]['level'] == 1:
        info_name = my_dict[i]  # 获取员工的姓名信息
        # 修改员工信息
        info_name['level'] = 2  # 级别加 1
        info_name['salary'] += 1000  # 工资加1000
        # 将员工信息重新返回到 字典
        my_dict[i] = info_name
for n, d in my_dict.items():
    print(f'升职加薪后的员工表为：{n,d}')

---

数据容器总结

通用操作：

​ sorted( 数据容器，[reverse = True] ) 将容器进行降序排序(从大到小)，排序的结果会变成列表对象，字典中的value会丢失（reverse反向，默认参数为false升序，从小到大）

下标索引：

​ 支持：列表、元组、字符串 — 序列类型

​ 不支持：集合、字典 — 非序列类型

重复元素：

​ 支持：列表、元素、字符串 —序列类型

​ 不支持：集合、字典 — 非序列类型

修改操作：

​ 支持：列表、集合、字典

​ 不支持：元组、字符串

	列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	键值对
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
使用场景	可修改、可重复的一批数据记录场景	不可修改、但可重复的一批数据记录场景	一串字符的记录场景	不可重复或需要去重的数据记录场景	以key检索value的数据记录场景

---

拓展

程序中，字符串所用到的所有字符（包括特殊符号和空格），都有对应的ASCII码表，每一个字符都能对应一个数字的码值，字符串进行比较就是基于数字的码值大小进行比较的，字符串是按 位 比较的，其中只要有一位大，那么整体就大，后面就不再比较

str1 = ('a', 'A', 'b', 'C')
print(sorted(str1))
# ['A', 'C', 'a', 'b']
print(f'{'abd' > 'abc'}') # True
print(f'{'acd' > 'abo'}') # True