03数据分析

小结：集合——面向对象

集合

集合使用{}，相当于字典的键没有字典的值

1、创建集合

s1 = {'张三','dsd',1}

2、集合使用

集合是一种特殊的字典，只能存储key，不能存储value，集合不能重复，且无序

添加，查询，删除，修改

s3.add('张三1')   # 添加  # 集合不会重复出现
print（s3)        # 查询
s3.remove('张三') # 删除
s3.update({1,2,3})   # 修改

3、交集、并集、差集

s11 = {11,13,16}
s22 = {13,16,88,99}

print(s11|s22)   # 交集
print(s11&s22)   # 并集
print(s22-s11)   # 差集
print(s11-s22)   # 差集

集合不能转化为字典

---

文件操作

文件的属性 

txt        文件 

py        python文件  

doc      word文件

xlsx      excel文件

csv       excel文件

文件的路径

绝对路径和相对路径

import os
# 创建
os.mkdir('第三阶段')
# 删除
os.rmdir('第三阶段')
# 查询
a = os.listdir()
print(a)

文件读写

\n    换行

\r     回车

\t     tab制表符

文件的读写操作

• mode:[a,w,r]
• a = append    追加写入
• w = write        清空写入
• r = read          只读

##  如何把1-1000写入到本地txt文件中
f = open('number.txt',mode='a')
for i in range(1,1001):
    f.write(str(i))
    f.write('\n')
f.close()

---

函数

作用：封装代码，减少代码量，使代码更具模块化，让代码看起来更整洁

def create_file(name):
    file = open(f'{name}.txt', mode='w')
    file.write(f'{name}，要努力，才会有工作哦')
    file.close()
    pass
create_file('赵六') # 使用一次函数
create_file('七七') # 使用一次函数

练习

# 创建一个函数：名字是my_sum,作用：计算两个数的和
def my_sum(a,b):
    c=a+b
    print(f'{a}+{b}={c}')

my_sum(12,33)
my_sum(*[12,23])

位置参数：一旦在函数中定义了位置参数，就必须传递的数值，多or少都不行

默认参数：有默认参数，可以不传递值

可变参数：可以接受0个任意值

关键字参数：可以接受任意对参数   key-value 键值对

# 创建一个函数：名字是my_sum,作用：计算两个数的和
def my_sum(a,b):
    c=a+b
    print(f'{a}+{b}={c}')

my_sum(12,33)
my_sum(*[12,23])

# 关键字参数：可以接受任意对参数   key-value 键值对
def func3(**kwargs):
    print(kwargs)
func3(name='战法',age=23)

---

全局变量和局部变量

全局变量：作用域整个文件

局部变量：作用域是局部

小结：

• 全局变量的作用域是整个文件，而局部变量的作用域是函数内部
• 局部中可以使用全局变量 ，全局中不能使用局部变量
• 如果非要使用函数的内部函数，则可以使用global 修饰成全局变量，再调用一次函数，即可使用。

# 变量 -- 全局变量：作用域整个文件
a = 10
b = 20


# 变量 -- 局部变量：作用域是局部
def func1():
    global a1   #  声明a1是全局变量
    a1 = 100  # a1被称为局部变量
    print(a1)
    # c1 = a1    # 会报错 ，因为外部无a1只有内边有a1
    c1 = a1 + a
def func2():
    a = 100

func1()

print(a1)

特殊函数

匿名函数： 功能：是对简单函数的简写

回调函数：把一个函数，当成参数传递到另一个函数内部，进行调用

# 简单函数
def func1(a,b):
    print(a+b)
func1(10,23)

# 匿名函数
func2 = lambda a,b:print(a+b)
func2(10,23)

匿名函数：把def改写成lambda

参数：直接写在关键字后面，省略了函数名

def a():
    print('这是函数a的代码')

def b(x):
    print('这是在b内部的参数x:',x)
    x()
b(a)

return  和 print 区别

print ：打印，在终端打印内容，这个内容，并没有特殊含义，只是为了让你看到这个值是什么。

return ：真真实实的给你返回一个值，这个值在接下来可以像使用变量一样去使用。

一个函数必须有return,默认返回None

def my_sum(a,b):
    print(a,b)
    return a+b

y = my_sum(10,20)
print(y+20)

异常捕获

异常捕获：可以捕获运行当中的错误，保证程序运行，不会中途退出

抛出异常：拿到不可处理的数据，应该抛出异常，让程序终止

try:
    a = 50
    list1 = [1,2,3,4,5,6,7]
    print(list1[a])  # IndexError: list index out of range
except Exception as e:
    print('发生错误')
else:
    print('没有发生错误执行的代码')
print('end!')

#  和系统出现的报错一样，不过是我们写的
status = 0
if status == 0:
    raise ValueError('抛出异常')

print(10)

面向对象基础

面向对象：以编程语言中一种抽象的概念

一切皆为对象

类：抽象的     垃圾分类   干垃圾    湿垃圾    根据实例物品的特点

编程的类，会根据不同函数的功能进行划分

对象：具体的

编程的对象，可以操作类中函数的实例 ————> 变量

函数与方法：

def study():  # 函数
    print('学习')
    return None

# 定义类
class Learn():

    def study(self):   # 这个是方法 ， 方法 和 函数 的区别
        print('学习')
        return None

    def test(self):
        print('测试作业')
        return None

zhang = Learn()
zhang.test()

第一、创建一个对象

第二、通过对象调用类中的方法

class Sport():
    def sport(self):
        print('运动')
        return None

    def run(self):
        print('跑步')
        return None

Li = Sport()  # 创建一个对象
Li.run()