day03

不爱写代码555555

已于 2023-01-04 21:44:42 修改

阅读量216

点赞数

文章标签： python 开发语言 Powered by 金山文档

于 2023-01-01 22:33:08 首次发布

本文链接：https://blog.csdn.net/m0_59550403/article/details/128515656

版权

- python容器

1.1列表list

1.1.1 列表元素

# 对于列表而言，其中元素的数据类型可以是不一样的

# 其中的元素是可以允许重复的

list1 = ["小虎", 2, 3.14, True, None, 6, 2]
print(list1)

1.1.2 列表结构

# list容器是一个有序的序列结构

# 这里的有序不是指的是排序，而是指存储和取出的顺序一致

list2 = [11, 44, 1, 3, 12, 45]
print(list2)

1.1.3 列表序列操作

# 列表可以进行一系列序列操作，如索引、切片、加、乘和检查成员等

list3 = list()  # 创建列表的第二种方式：使用python内置的函数list()来进行创建空的列表
print(list3)
list4 = []
print(list4)

1.1.4 列表推导式

# 列表推导式（python3.x）列表生成式

--常规代码

# list5 = []
# for i in range(1, 11):
#     list5.append(i*2)

--列表推导式

list5 = [i * 2 for i in range(1, 11)]
print(list5)

enumberate函数：获得列表下标及其对应的元素

list5 = ['lebron','curry','durant','rose','23','30','7','1']
for i, j in enumerate(list5):
    print(i, j)

1.1.5 列表元素添加

# 使用列表中的append()函数向列表中末尾添加元素

list = ['LeBron','Curry','Durant','23','30','7']
list.append('Harden')
list.append('1')
print(list)

1.1.6 列表元素删除

#当我们知道要删除某个值的时候，使用remove()

list = ['LeBron','Curry','Durant','23','30','7','Harden','1']
list.remove('Harden')    #该函数是没有返回值的
list.remove('1')
print(list)

1.1.7 列表索引

#列表的索引

# 从左往右，从0开始编号，从右往左也有编号，从-1开始

1.1.8 列表的删除（索引）

#列表的删除

1.del函数

list = ['LeBron','Curry','Durant','23','30','7','Harden','1']
del list[-2]
print(list)

2.pop函数

list = ['LeBron','Curry','Durant','23','30','7','Harden','1']
s = list.pop(1)  # pop函数默认是删最后一个元素，返回值是被删除的元素
print(s)
print(list)

1.1.9 列表元素插入

#insert函数：指定元素位置添加新元素

list = ['LeBron','Curry','Durant','23','30','7','Harden','1']
list.insert(4,'Irving')
list.insert(5,'11')
print(list)

1.1.10 列表长度

# 使用len()函数获取列表的元素个数（长度）

list = ['LeBron','Curry','Durant','23','30','7','Harden','1']
print(len(list))

1.1.11 遍历列表

list = ['LeBron','Curry','Durant','23','30','7','Harden','1']
print(list[0:len(list)])  # 按照开始和结束的索引进行切片，是左闭右开的。
print(list[0:])  # 结束的位置不写，默认取到末尾
print(list[::2])  # 步长为2进行获取
print(list[2:])
print(list[-2:])   #从右边第二个元素向右边遍历
print(list[-1::-1])  # 逆序（第二个-1意思是向左遍历）

1.1.12 列表的嵌套

#isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()

list1 = [11, 22, 33, 44, ['a', 'b', 'c', 'd']]
for i in list1:
    if isinstance(i, list):   #判断是否为列表
        for j in i:
            print(j，end = ' ')

list1 = [11, 22, 33, 44, ['a', 'b', 'c', 'd']]
list1[4][2] = 'z'   #表示对列表中嵌套列表元素的修改
print(list1)

1.1.13 copy函数

# 浅拷贝

list1 = [11, 22, 33, 44, ['a', 'b', 'c', 'd']]
list2 = list1.copy()
list2[4][2] = 'z'
print(f"list1:{list1}")
print(f"list2:{list2}")

# 深拷贝

import copy
list1 = [11, 22, 33, 44, ['a', 'b', 'c', 'd']]
list2 = copy.deepcopy(list1)
list2[4][2] = 'z'
print(f"list1:{list1}")
print(f"list2:{list2}")

1.2 元组tuple

# 其中的元素类型也是可以不一样的

tuple1 = ('a', 1, 12.34, True)
print(tuple1)
print(tuple1[1])

# tuple1[1] = 'b' # 元组中的元素一旦确定就不能改变（增，删，修改都不行），但是可以进行遍历和查询

1.3 字典

# 容器中的元素是由键值对的方式进行存储的

# 其中字典里的key是唯一的，value值是可以发生重复的,字典里的value值类型是可以不一样的

dict1 = {'name': 'LeBron', 'age': 38, 'speciality': {'taco': 'Tuesday', 'ball': 'basketball'}, 'sport': ('篮球', '橄榄球', '高尔夫')}
print(dict1)

1.3.1 创建一个空字典

dict2 = {}
print(dict2, type(dict2))
dict3 = dict()
print(dict3, type(dict3))

1.3.2 从非空字典中取值

dict1 = {'name': 'LeBron', 'age': 38, 'speciality': {'taco': 'Tuesday', 'ball': 'basketball'}, 'sport': ('篮球', '橄榄球', '高尔夫')}
name = dict1['name']
print(name)

1.3.3 如何给一个空字典进行赋值

dict1 = {'name': 'LeBron', 'age': 38, 'speciality': {'taco': 'Tuesday', 'ball': 'basketball'}, 'sport': ('篮球', '橄榄球', '高尔夫')}
dict1['name'] = 'Curry'
print(dict1)

1.3.4 zip()函数创建字典

#用于将多个序列(列表、元组等)中的元素配对（后面说可视化的时候会用到，机器学习）

dict4 = {}
list1 = ['name', 'age', 'gender']
list2 = ['小虎', 18, '男']
for x, y in zip(list1, list2):
    # print(x,y)
    dict4[x] = y
print(dict4)

1.3.5 字典常用功能函数

dict4 = {}
print(dict4['name2']) # 如果用变量名的方式直接访问数据，如果key不存在，报错

dict4 = {}
print(dict4.get("name2"))  # 如果使用get()函数获取一个不存在的key，不会报错，返回一个None

1.3.6 获取键值对

# 获取字典中所有的key

# 获取字典中所有的value

# 获取字典中所有的键值对

dict4={'name':'LeBron','age':38,'hobby':('basketball','taco')}
n1 = list(dict4.keys())
print(n1, type(n1))
# 获取字典中所有的value
values = list(dict4.values())
print(values, type(values))
# 获取字典中所有的键值对
key_values = list(dict4.items())
print(key_values, type(key_values))

1.3.7 两种遍历字典的方式

1、一次获取所有的key,然后再使用get()函数，根据key获取value值

dict4={'name':'LeBron','age':38,'hobby':('basketball','taco')}
list_keys = list(dict4.keys())
for key in list_keys:
    value = dict4[key]
    print(f"键值对：{key}:{value}")

2.一次获取所有的键值对，遍历每个键值对得到key和value

key_values_list = list(dict4.items())
for key_value in key_values_list:
    key = key_value[0]
    value = key_value[1]
    print(f"键值对：{key}:{value}")

1.3.8 字典的删除操作

#根据key删除对应键值对，因为key是唯一的，如果删除的key不存在会报错

dict4={'name':'LeBron','age':38,'hobby':('basketball','taco')}
del dict4['name2']  
print(dict4)

#pop函数根据key删除字典中键值对的时候，删除并且返回key对应的value值,如果删除的key不存在会报错

dict4={'name':'LeBron','age':38,'hobby':('basketball','taco')}
s = dict4.pop('name2') 
print(s)

1.4 集合

# 集合创建的方式 set集合特点：元素唯一无序（存储和取出的顺序不一致）,也是允许元素类型不一致

1.4.1 创建方式

1.使用python内置的函数set()创建一个空集合

set1 = set()  
print(set1, type(set1))

2. 使用大括号中放值的方式

set2 = {'xiaohu', 'shujia', 'java', 'python', 'linux', 'xiaohu'}
print(set2, type(set2))

#需要注意的是，创建空集合，必须使用 set() ，而不是{}，因为{}表示创建一个空的字典

1.4.2 集合的运算

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)

# 使用add()函数添加元素

set3 = set()
set3.add("xiaohu")
set3.add(18)
print(set3, type(set3))

# 移除元素

set3.remove(18)
print(set3, type(set3))

1.5 文件

1.5.1 路径

# 绝对路径（完整路径）：带有盘符的路径

# 相对路径：将项目作为根目录

1.5.2文件读写

#读操作

with open('E:\\Projects\\pythonProject\\bigdata22\\day03\\a.txt') as f:#斜杠为两条
    print(f.read())    #read可加数字

#写操作

1.覆盖写：本质上是两步操作：1、先清空 2、再写

with open('E:\\Projects\\pythonProject\\bigdata22\\day03\\a.txt','w') as f:
    print(f.write('lebron'))

2.追加写：在原有的末尾继续添加

with open('E:\\Projects\\pythonProject\\bigdata22\\day03\\a.txt','a',encoding="utf-8") as f:
    f.write('durant')
    f.write("lebron")

#通过 open() 函数打开文件，返回文件对象

#对文件对象进行读取操作，除了前面介绍的 read() 之外还有两种读取数据的方法: readline() 是每次读入一条数据的方式， readlines() 是一次性读入文件所有数据

#readlines() 读取后得到的是每行数据组成的列表，但是一行样本数据全部存储为一个字符串，并且数据读入后并没有将换行符去掉(windows系统的换行符是 \r\n ，linux系统的换行符号是 \n)

#在读入数据之后，用 for 循环对每一个元素去除换行符，并将每一个变量值用字符串处理方法 .split() 分隔开来

#.strip() 本身是一个对字符串指定字符去除的方法，但括号里参数为空的时候，就会去除 \r \n \t

#设置参数 mode=w。 write() 、 writelines() 是两个对文件对象的写入数据的方法。 write() 是逐次写入， writelines() 可对一个列表里的所有数据一次性写入文件中

#如果有换行需要，则要在每条数据后增加换行符，同时用字符串 .join() 的方法

1.6 类和模块

1.6.1 概念

#模块介绍：

内置电池(batteriesincluded)

基础代码库，覆盖了网络通信、文件处理、数据库接口、图形系统、XML处理

#第三方工具包

• Pandas:数据处理与分析

• Numpy:科学计算

• Scikit-learn:基于SciPy和Numpy的开源机器学习模块• Tensorflow:深度学习框架

#导入模块

模块的方式非常简单，在"import"后加上"模块名称"就可以了

通过这一句，计算机就在指定的位置找到了"numpy.py"文件，并准备好该文件拥有的之后会用到的函数和属性。在导入"numpy"后，我们就可以通过点符号"."连接模块名称和函数名，使用该模块中的函数和属性

#指定的方式是采用"import模块名称 as 别名"。我们可以将"numpy"简记为"np"，并且在调用时，直接使用"np"就可以:

#只导入某个对象

此过程的实现方式是“from模块名称 import函数名称"，但是要注意我们只拿到了某个具体的工具，而没有拿到整个工具箱

1.6.2 类的创建

# 学习类和对象
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("男同学去男厕所")

#初始化方__法init__方法

__init__是一种特殊的方法，使得实例一开始就拥有类模板所具有的属性

self参数是类中函数定义时必须使用的参数，并且永远是第一个参数，该参数表示创建的实例本身

一旦"__init__"存在除了"self"之外的参数，那么在创建实例 "student_a"时，我们就需要传入相应的参数值(不过"self"不需要传入数值，Python解释器会自动将实例变量传入)

    def __info(self): # 当类中函数使用__修饰的时候，无论是当前类的对象还是子类对象都访问不了。即便加了__
        print(f"姓名为：{self.__name},年龄为：{self.age},性别：{self.gender}")

成员的私有化

面向对象的语言一般都对对象有一些统一的要求。例如封装性。封装性的意思是指，一个对象的成员属性要得到一定程度的保护。例如，要对一个对象的成员属性进行修改或访问，就必须通过对象允许的方法来进行(例如要求输入密码以确认拥有此权限等)。这样可以保护对象，使程序不易出错。

如果我们希望某些内部属性不被外部访问，我们可以在属性名称前加上两个下划线"__" 表示将该属性成员私有化，该成员在内部可以被访问，但是在外部是不能够访问的。

成员私有化不仅包括属性的私有化，也包括了方法的私有化，在方法名称前加上 __ 也可以使得函数只能被内部访问，不能够被外部访问

在属性前面加上__,就将这个属性变成私有的成员，外界不能够直接获取该属性当类中函数使用__修饰的时候，无论是当前类的对象还是子类对象都访问不了。即便加了__

类的继承

与封装性一样，继承性是面向对象程序设计的另一种重要的属性。类的继承好比孩子与父母之间的继承关系一样，孩子拥有父母所拥有的许多特性。在编程语言中，如果一个新的类继承另外一个类，那么这个新的类成为子类(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("男同学去男厕所")

# 学习类和对象
class High_school_student():
    # 初始化函数（构造方法，这个方法的目的是为了创建对象）
    def __init__(self, name, age, gender):
        # 对应一个事物的属性
        self.__name = name  # 在属性前面加上__,就将这个属性变成私有的成员，外界不能够直接获取该属性

    def __info(self): # 当类中函数使用__修饰的时候，无论是当前类的对象还是子类对象都访问不了。即便加了__
        print(f"姓名为：{self.__name},年龄为：{self.age},性别：{self.gender}")


class Man_student(High_school_student):
    # pass
    def goto_wc(self): # 在继承关系中不仅可以使用父类中的函数，也可以定义自己特有的函数
        print("男同学去男厕所")