本文详细介绍了Python中的四种主要数据容器：列表、元组、字典和集合。列表是可变的有序序列，支持多种操作如遍历、添加、删除元素；元组是不可变的序列；字典是键值对存储，键唯一；集合则包含唯一无序的元素。文章通过示例代码展示了这些数据结构的创建、操作和用途。
数据的容器
列表list
列表中其中元素的数据类型可以是不一样的 其中的元素是可以允许重复的
list容器是一个有序的序列结构，这里的有序不是指的是排序，而是指存储和取出的顺序一致
列表推导式（python3.x）列表生成式
list1 = [i * 2 for i in range(1, 11)]
print(list1)输出结果：
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]例：
# 请用一行代码搞定九九乘法表
print('\n'.join([' '.join([f'{i}*{j}={i * j}' for j in range(1, i + 1)]) for i in range(1, 10)]))输出结果：
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81对列表进行操作：
创建列表的几种方式
1.直接定义一个列表
2.使用list函数 list1=list()
3.list1=[]
list1 = ["bang", 2, 3.14, True, None, 6, 2]
# 遍历列表
print(list1[0:len(list1)]) # 按照开始和结束的索引进行切片，是左闭右开的。
print(list1[0:]) # 结束的位置不写，默认取到末尾
print(list1[::2]) # 步长为2进行获取
print(list1[2:])
print(list1[-2:])
print(list1[-1::-1]) # 逆序输出结果：
['bang', 2, 3.14, True, None, 6, 2]
['bang', 2, 3.14, True, None, 6, 2]
['bang', 3.14, None, 2]
[3.14, True, None, 6, 2]
[6, 2]
[2, 6, None, True, 3.14, 2, 'bang']注：列表遍历默认从左到右，若左边下标大于右边下标，则输出[]，此时若想输出元素，则可以将步长改为-1
往列表中添加元素：
list1 = ["bang", 2, 3.14, True, None, 6, 2]
list1.append(100000)
print(list1)
list1 = ["bang", 2, 3.14, True, None, 6, 2]
list1.insert(1,'插入元素')
print(list1)
输出结果：
['bang', 2, 3.14, True, None, 6, 2, 100000]
['bang', '插入元素', 2, 3.14, True, None, 6, 2]从列表中删除元素：
list1 = ["bang", 2, 3.14, True, None, 6, 2]
list1.remove(3.14) # 删除某个具体的值
print(list1)
list1.pop(2) # 删除对应下标下的值，pop函数默认是删最后一个元素，返回值是被删除的元素
print(list1)
del list1[-2] # 删除对应下标下的值
print(list1)
输出结果：
['bang', 2, True, None, 6, 2]
['bang', 2, None, 6, 2]
['bang', 2, None, 2]enumerate函数
list1 = ["bang", 2, 3.14, True, None, 6, 2]
for i, j in enumerate(list1):
print(i, j) # 输出对应下标及元素
输出结果：
0 bang
1 2
2 3.14
3 True
4 None
5 6
6 2使用len()函数获取列表的元素个数（长度）
列表的嵌套
# 列表的嵌套
list5 = [11, 22, 33, 44, ['a', 'b', 'c', 'd']]
for i in list5:
if isinstance(i, list):
for j in i:
print(j)
输出结果：
a
b
c
d列表中的copy()函数
#浅拷贝：创建一个新对象，这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型，拷贝的就是基本类型的值，如果属性是引用类型，拷贝的就是内存地址
#深拷贝：将一个对象从内存中完整的拷贝一份出来,从堆内存中开辟一个新的区域存放新对象。
import copy
list1 = [11, 22, 33, 44, ['a', 'b', 'c', 'd']]
list2 = list1.copy() #浅拷贝
list2[4][2] = '变化1'
print(list1, list2)
list3 = copy.deepcopy(list1) #深拷贝
list3[4][1] = '变化2'
print(list1, list3)
输出结果：
[11, 22, 33, 44, ['a', 'b', '变化1', 'd']] [11, 22, 33, 44, ['a', 'b', '变化1', 'd']]
[11, 22, 33, 44, ['a', 'b', '变化1', 'd']] [11, 22, 33, 44, ['a', '变化2', '变化1', 'd']]元组 tuple
其中的元素类型也是可以不一样的，元组中的元素一旦确定就不能改变（增，删，修改都不行），但是可以进行遍历和查询
tuple1 = ('a', 1, 12.34, True)
print(tuple1)
print(tuple1[1])
输出结果：
('a', 1, 12.34, True)
1字典 dict
容器中的元素是由键值对的方式进行存储的，其中字典里的key是唯一的，value值是可以发生重复的,字典里的value值类型是可以不一样的
创建空字典
dict1 = {}
dict2 = dict()字典的一些操作：
dict1 = {'name': 'reynolds', 'age': 18, 'speciality': {'study': 'bigdata', 'game': 'mhy'},
'sport': ('篮球', '足球', '羽毛球')}
name = dict1['name'] # 从字典中进行取值
print(name)
dict1['id'] = '20191209082' # 向字典中添加值
print(dict1)
输出结果：
reynolds
{'name': 'reynolds', 'age': 18, 'speciality': {'study': 'bigdata', 'game': 'mhy'}, 'sport': ('篮球', '足球', '羽毛球'), 'id': '20191209082'}zip函数
dict2={}
# zip()函数创建字典，用于将多个序列(列表、元组等)中的元素配对（后面说可视化的时候会用到，机器学习）
list1 = ['name', 'age', 'gender']
list2 = ['reynolds', 18, '男']
for x, y in zip(list1, list2):
# print(x,y)
dict2[x] = y
print(dict2)
输出结果：
{'name': 'reynolds', 'age': 18, 'gender': '男'}# 字典常用功能函数
print(dict4['name2']) # 如果用变量名的方式直接访问数据，如果key不存在，报错
print(dict4.get("name2")) # 如果使用get()函数获取一个不存在的key，不会报错，返回一个None
dict1 = {'name': 'reynolds', 'age': 18, 'speciality': {'study': 'bigdata', 'game': 'mhy'},
'sport': ('篮球', '足球', '羽毛球')}
# 获取字典中所有的key
n1 = dict1.keys()
print(n1, type(n1))
# 获取字典中所有的value
values = dict1.values()
print(values, type(values))
# 获取字典中所有的键值对
key_values = dict1.items()
print(key_values, type(key_values))
输出结果：
dict_keys(['name', 'age', 'speciality', 'sport']) <class 'dict_keys'>
dict_values(['reynolds', 18, {'study': 'bigdata', 'game': 'mhy'}, ('篮球', '足球', '羽毛球')]) <class 'dict_values'>
dict_items([('name', 'reynolds'), ('age', 18), ('speciality', {'study': 'bigdata', 'game': 'mhy'}), ('sport', ('篮球', '足球', '羽毛球'))]) <class 'dict_items'># 两种遍历字典的方式
# 1、一次获取所有的key,然后再使用get()函数，根据key获取value值
list_keys = list(dict4.keys())
for key in list_keys:
value = dict4[key]
print(f"键值对：{key}:{value}")
print("-------------------------------------")
# 2、一次获取所有的键值对，遍历每个键值对得到key和value
key_values_list = list(dict4.items())
for key_value in key_values_list:
# print(key_value, type(key_value))
key = key_value[0]
value = key_value[1]
print(f"键值对：{key}:{value}")
字典的删除
dict1 = {'name': 'reynolds', 'age': 18, 'speciality': {'study': 'bigdata', 'game': 'mhy'},
'sport': ('篮球', '足球', '羽毛球')}
del dict1['name'] # 根据key删除对应键值对，因为key是唯一的，如果删除的key不存在会报错
print(dict1)
# s = dict1.pop('name') # pop函数根据key删除字典中键值对的时候，删除并且返回key对应的value值,如果删除的key不存在会报错
# print(s)
dict1.clear()
print(dict1)
输出结果：
{'age': 18, 'speciality': {'study': 'bigdata', 'game': 'mhy'}, 'sport': ('篮球', '足球', '羽毛球')}
{}
集合 set
元素唯一 无序（存储和取出的顺序不一致）,也是允许元素类型不一致
集合创建的方式
set1 = set() # 使用python内置的函数set()创建一个空集合
第二种方式使用大括号中放值的方式
set2 = {'xiaohu', 'shujia', 'java', 'python', 'linux', 'xiaohu'}
集合的操作
set1 = {'xiaohu', 'shujia', 'java', 'python', 'linux'}
set2 = {'mysql', 'hadoop', 'hive', 'hbase', 'xiaohu', 'shujia'}
# 并集 union()
print(set1 | set2)
# 交集
print(set1 & set2)
# 差集
print(set2 - set1)
# 对称差(异或)
print(set1 ^ set2)
输出结果：
{'python', 'xiaohu', 'shujia', 'hadoop', 'mysql', 'hive', 'hbase', 'java', 'linux'}
{'xiaohu', 'shujia'}
{'hbase', 'hive', 'mysql', 'hadoop'}
{'mysql', 'python', 'hive', 'hbase', 'java', 'linux', 'hadoop'}set3 = set()
print(set3, type(set3))
# 使用add()函数添加元素
set3.add("xiao")
set3.add(18)
print(set3, type(set3))
# 移除元素
set3.remove(18)
print(set3, type(set3))
输出结果：
set() <class 'set'>
{18, 'xiao'} <class 'set'>
{'xiao'} <class 'set'>文件操作
# 绝对路径（完整路径）：带有盘符的路径 # 相对路径：将项目作为根目录
with open('E:\\projects\\PycharmProjects\\bigdata22\\day03\\a.txt', 'r', encoding="utf-8") as f:
# print(f.read(4))
print(f.readline().strip())
print(f.readline().strip())
'文件目录'，操作方式，编码方式 'r'读 'w'覆盖写 'a'追加写
f.read(i)读i个字符
f.readline()读一行元素
f.write()写字符类和模块
模块
模块是Python中的最高级别组织单元，它 将程序代码和数据封装起来以便重用
模块的三个角色: 1. 代码重用 2. 系统命名空间的划分(模块可理解为变量名 的封装，即模块就是命名空间) 3. 实现共享服务和数据
模块导入方式
类和对象
类的创建
用 class 类名 即可以创建一个类
在类名的程序块中可以定义这个类的属性、方法等等
class student:
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
def self_introduce(self):
print(f'你好，{self.name}，{self.age}，{self.score}')
if __name__ == '__main__':
s1 = student('zhuwei', '28', '55')
print(s1.name)
s1.self_introduce()
成员的私有化
面向对象的语言一般都对对象有一些统一的要求。例如封装性。 封装性的意思是指，一个对象的成员属性要得到一定程度的保护。例如，要对一个 对象的成员属性进行修改或访问，就必须通过对象允许的方法来进行(例如要求输 入密码以确认拥有此权限等)。这样可以保护对象，使程序不易出错。
如果我们希望某些内部属性不被外部访问，我们可以在属性名称前加上两个下划线"__" 表示将该属性成员私有化，该成员在内部可以被访问，但是在外部是不能够访问的。
成员私有化不仅包括属性的私有化，也包括了方法的私有化，在方法名称前加上 __ 也可以使得函数只能被内部访问，不能够被外部访问
在属性前面加上__,就将这个属性变成私有的成员，外界不能够直接获取该属性当类中函数使用__修饰的时候，无论是当前类的对象还是子类对象都访问不了。即便加了__
类的继承
与封装性一样，继承性是面向对象程序设计的另一种重要的属性。 类的继承好比孩子与父母之间的继承关系一样，孩子拥有父母所拥有的许多 特性。在编程语言中，如果一个新的类继承另外一个类，那么这个新的类成 为子类(Subclass)，被子类继承的类称为父类 我们可以把更加一般、范围大的类的属性在父类定义，把更加具体、范围小 的特点在子类定义。
在继承关系中不仅可以使用父类中的函数，也可以定义自己特有的函数
# 学习类和对象
class High_school_student():
# 初始化函数（构造方法，这个方法的目的是为了创建对象）
def __init__(self, name, age, gender):
# 对应一个事物的属性
self.__name = name # 在属性前面加上__,就将这个属性变成私有的成员，外界不能够直接获取该属性
self.age = self.set_age(age)
# self.age = age
self.gender = gender
# 成员方法（行为）
def study(self):
print("学生可以学习")
def get_name(self):
return self.__name
def set_age(self, age):
if age > 100 or age < 0:
print("您给的年龄有误！！，默认是18岁")
return 18
else:
return age
def __info(self): # 当类中函数使用__修饰的时候，无论是当前类的对象还是子类对象都访问不了。即便加了__
print(f"姓名为：{self.__name},年龄为：{self.age},性别：{self.gender}")
class Man_student(High_school_student):
# pass
def goto_wc(self): # 在继承关系中不仅可以使用父类中的函数，也可以定义自己特有的函数
print("男同学去男厕所")
扫一扫
8105
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
