学习大数据的第42天（python篇）——学习python的第2天

学习大数据的第42天（python篇）——学习python的第2天

Python 判断循环

判断

格式:
if 表达式1:
代码块1(缩进)
代码块2(缩进)
代码块3(缩进)
elif 表达式2:
代码块4(缩进)
代码块5(缩进)
代码块6(缩进)
else:
代码块7(缩进)
代码块8(缩进)

age = 200
if age <= 0 | age >= 150:
    print("成精了...")
elif age >= 18:
    print("成年...")
elif age < 18:
    print("未成年...")
else:
    print("未知")

循环

Python中为了语法简洁 没有 do while

for循环
while循环：
格式：
while(表达1):
代码块(需要缩进)
代码块(需要缩进)
代码块(需要缩进)

循环小练习，求阶乘

# 5! = 5 * 4 * 3 * 2 * 1

res = 1
n = 5
while (n >= 1):
    res *= n
    n -= 1
print(res)

Python 连接Mysql的常规操作

先更换阿里云镜像，方便后来的下载包

安装命令：

install:安装包
格式：pip install
注：如果需要指定版本安装则需要使用 pip install == version
uninstall: 卸载已安装的包
格式: pip , <已存在的包名>
list: 查看pip已安装的模块
格式 pip list
help: 查看pip中的所有命令
pip --help

换源：
将pip文件夹复制到 C:\用户\当前用户

1、首先下载Mysql的包pymysql

安装pymysql：pip install pymysql

2、import导包

import pymysql

3、创建连接

host：mysql的ip地址，我这里是linux上的ip地址

database：数据库名称

port：端口号（mysql默认3306）

conn = pymysql.connect(user='root', password='123456', host='192.168.6.100', database='shujia', port=3306)

4、获得数据库游标以及再根据游标获得结果集

cursor = conn.cursor()
res = cursor.execute('sql语句')

5、获得数据

# print(cursor.fetchone())  # 获取一条数据
# print(cursor.fetchmany(5))  # 获取5条数据
# print(cursor.fetchall())  # 获取全部数据
for i in range(res):
    print('获取到一条数据', cursor.fetchone())

6、也可以使用with as （为了防止开发者忘记关闭连接）

with pymysql.connect(user='root', password='123456', host='192.168.233.10', database='company', port=3306) as conn:
    with conn.cursor() as cursor:
        res = cursor.execute("sql语句")
        for i in range(res):
            print(cursor.fetchone())

Python处理文件（IO流）

读取文件：

格式：

​ f1 = open(file="…/data/students.txt", mode=‘r’, encoding=‘utf-8’)

​ file：文件路径

​ mode：操作方式（r读取，w覆盖写入数据，a追加数据）

​ encoding：字符集

# mode='r' 表示只读模式
f1 = open(file="./data/students.txt", mode='r', encoding='utf8')
print(f1.read(15))  # 获取15位数据
print(f1.readline())  # 获取当前下标下的整行数据
print(f1.readline())
print(f1.readlines())  # 获取当前下标后的所有数据
f1.close()
# 获取所有数据
# print(f1.read())

# 获取15位数据（按照一个字符一个字符的来获取）
# print(f1.read(15))

print(f1.readline())  # 获取当前下标下的整行数据
# 获取的结果为list集合
print(f1.readlines())  # 获取当前下标后的所有数据

# mode='w' 表示写入模式
f2 = open(file="../data/write.txt", mode='w', encoding='utf-8')
f2.writelines("输入一行数据\n")
f2.writelines("输入一行数据\n")
f2.writelines("输入一行数据\n")
f2.writelines("输入一行数据\n")

# mode=a 表示追加数据
f2 = open(file="./data/write.txt", mode='a', encoding='utf8')
f2.writelines("输入一行数据\n")
f2.writelines("输入一行数据\n")
f2.writelines("输入一行数据\n")
f2.write("输入数据")
f2.close()

f1.close()
f2.close()

需求：将一个文件中的数据，写入另一个文件

'''
    需求：需要从students.txt中读取数据并写入 students_new.txt
'''
with open(file="../data/students.txt", mode='r', encoding='utf8') as f3:
    with open(file='../data/students_new.txt',mode='a',encoding='utf8') as f4:
        f4.writelines(f3.readlines())

Python函数以及参数的定义

函数的格式：

def 函数名(参数1,参数2,参数3):
代码块(需要缩进)
代码块(需要缩进)
代码块(需要缩进)
需要返回值
return 数据

函数类型：

注意递归函数的使用

# 阶乘
# 5! = 5 * 4 * 3 * 2 * 1

def jiecheng(n):
    if n == 1:
        return 1
    else:
        return n * jiecheng(n - 1)


print(jiecheng(5))

参数的类型：

位置参数

默认参数

可变参数

关键字参数

匿名函数的使用

# 函数的参数
'''
    参数类型：
        位置参数、默认参数、可变参数、关键字参数
'''

# 位置参数
'''
    特点：
        1. 位置参数可包含多个
        2. 函数调用时位置参数不能为空
'''


def chengfa1(a, b):
    print(a * b)


# chengfa1(1)

# 默认参数
'''
    特点：
        1.定义函数的时候，需要去指定参数的默认值
        2.使用时，可通过再次传入参数值进行覆盖默认值
'''


def chengfa2(a, b=0):
    print(a * b)


chengfa2(2)
chengfa2(2, b=3)

# 可变参数
'''
    特点：
        1.可变参数的写法需要在参数名之前加一个*如: *args
        2.可变参数实际是一个tuple
'''


def chengfa3(*args):
    print(args, type(args))


chengfa3(2, 3, 4, 5)


def chengfa4(*args):
    sum = 1
    for i in args:
        sum *= i
    print(sum)


chengfa4(4, 5, 6, 7)

# 关键字参数
'''
    特点：
        1.定义参数时需要用**参数名表示关键字参数 如：**kwargs
        2.类型是一个字典类型
        3.传入时需要按照k=v形式进行传入
        4.可以接收多个kv参数
'''


def info(name, age, **kwargs):
    print(name, age, kwargs, type(kwargs))


info("zhangsan", 23, gender="男")
info("zhangsan", 23, gender="男", skill="打游戏")


# 判断传入参数有没有age,如果有则打印，没有则提示：请输入age
def info2(name, **kwargs):
    if ('age' in kwargs.keys()):
        print("age:", kwargs["age"])
    else:
        print('请输入age')


info2(name="lisi")
info2(name="wangwu", age=3)

# 匿名函数
# 获取x的y次方
lambda_function = lambda x, y: x ** y
print(lambda_function(2, 3))

Python的面向对象——封装、继承、多态

封装：

特点：

1.构造方法：需要重写 __init__方法
2.对象属性：需要在 init 方法中通过 self.属性名称 去定义
3.获取对象的字符串信息： 需要重写 str 方法
4.定义对象的方法时：可以通过self.属性名去获取对应的属性名

封装、继承、多态：
1.Python中没有严格的封装概念

举例：Person类

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__secret = "这是一个秘密"

    # 相当于Java中的toString方法
    def __str__(self):
        return '\t'.join(["Person", self.name, str(self.age)])

    def skill(self):
        print(self.name + "能够直立行走...")

    def get(self):
        print(self.__secret)

person1 = Person("张三", 24)
print(person1, type(person1))
print(person1.age)
print(person1.name)
person1.skill()

person2 = Person("李四", 48)
person2.get()
# print(person2.__secret)  # 内部属性不能被外部对象访问
print(person2._Person__secret)  # 内部属性可以通过 _+类名+内部属性名进行访问

继承：

特点：
1.如果一个新的类继承了已有的一个类，那么被继承的类叫 父类，新的类叫做子类
2.范围大的一般被用来做父类，具体的一般用来做子类
3.子类可以调用父类中的方法及属性
4.如果子类中的函数与父类重名,则调用子类方法

举例老师学生继承Person类

class Teacher(Person):
    def __init__(self, t_name, t_age):
        # 如果需要构建父类对象，需要传入父类中所需的参数，并且super中需要传入子类名称及其self
        super(Teacher, self).__init__(name=t_name, age=t_age)
        self.teach = "computer"

    def skill(self):
        print("可以搞大数据...")


t = Teacher("杨老师", 30)
print(t.name)
t.skill()
t.get()


class Student(Person):
    def __init__(self, t_name, t_age):
        super(Student, self).__init__(name=t_name, age=t_age)
        self.teach = "王者"

    def skill(self):
        print("可以打王者荣耀...")


s = Student("王同学", 20)
s.skill()

'''
    1.可以通过对象的引用调用其方法
    2.父类应用指向子类对象
    3.Python中并不注重是否继承及检查类型，只注重有没有方法及属性
'''class Teacher(Person):
    def __init__(self, t_name, t_age):
        # 如果需要构建父类对象，需要传入父类中所需的参数，并且super中需要传入子类名称及其self
        super(Teacher, self).__init__(name=t_name, age=t_age)
        self.teach = "computer"

    def skill(self):
        print("可以搞大数据...")


t = Teacher("杨老师", 30)
print(t.name)
t.skill()
t.get()


class Student(Person):
    def __init__(self, t_name, t_age):
        super(Student, self).__init__(name=t_name, age=t_age)
        self.teach = "王者"

    def skill(self):
        print("可以打王者荣耀...")


s = Student("王同学", 20)
s.skill()

注意：

1.可以通过对象的引用调用其方法

2.父类应用指向子类对象

3.Python中并不注重是否继承及检查类型，只注重有没有方法及属性

# 猴子补丁

class Dog:
    pass


# 创建一个函数
skill_functioni = lambda: print("是人是狗都在秀...")

dog1 = Dog()

# 将函数赋值给dog作为dog新增的补丁方法
dog1.skill = skill_functioni
dog1.skill()

python模块的应用

# 模块的应用

from package1.ModelA import print_hello
import package1.ModelA as MA
# from package1 import ModelB
# from package1.ModelB import print_hello

'''
    特点：
        1.导入模块时，会去执行模块中的代码块
        2.模块的两种导入方法 import ...  from 包 import
        3.方法和模块导入方式一致
'''
print_hello()


import sys
print(sys.path)

python异常处理

# 编译错误

print("hhhh")
# prin("hello")

'''
    六大常见异常：
        除零错误 ZeroDivisionError ：除数为0
        关键词错误 NameError ：没有定义直接使用
        值错误 ValueError ：某些函数或者方法只适用于特定的数据类型，如果 对数据类型的操作不当，就会产生类型错误 
        索引错误 IndexError: 超出索引取值范围
        属性错误 AttributeError : 调用不合适的方法或属性
        缩进错误 IndentationError: 没有按规定进行缩进(高版本有优化)

'''

# 属性错误
# AttributeError
# tuple = (1, 2, 3)
# tuple.append(1)

# 索引错误
# IndexError
# list = [1, 2, 4]
# print(list[4])

# 值错误
# ValueError
'''
a = "123"
print(int(a))
b = "abc"
print(int(b))
'''

# 除零错误
# ZeroDivisionError
# print(10 / 0)

# 语法错误
# SyntaxError
# print(")

# 缩进错误
# IndentationError
'''
for i in range(1,4):
   print(i)
    print(i)
'''

# 关键词错误
# NameError
# prin("hello")


# 捕获异常
'''
    格式：
        try:
            可能出现问题的代码块
            可能出现问题的代码块
            可能出现问题的代码块
        except 捕获异常种类1 as 异常种类别名:
            出现异常种类1，执行...
        except 捕获异常种类2 as 异常种类别名:
            出现异常种类2，执行...
        else:
            没有发生异常可以执行...
        finally:
            不管有没有错误都执行...
'''

'''
    特点：
        1.当出现多个错误时，以程序运行顺序捕获错误为主
        2.当捕获异常时，如果出现较大范围的异常类型时，以较大范围的异常为主（注：异常存在继承关系）
'''


# 捕获单一错误
try:
    print("start")
    tuple = (1, 2, 3)
    tuple.append(1)
    print("end")
except AttributeError as attribute:
    print(attribute)
    print("已经捕获到异常:AttributeError")
finally:
    print("不管有没有错误都执行...")

# 捕获多种类型错误
try:
    print("start")
    print(10/0)
    tuple = (1, 2, 3)
    tuple.append(1)
    print("end")
except ZeroDivisionError as zero:
    print(zero)
    print("捕获到除零错误...")
except AttributeError as attribute:
    print(attribute)
    print("已经捕获到异常:AttributeError")

print('>>>'*20)
try:
    print("start")
    print(10/0)
    tuple = (1, 2, 3)
    tuple.append(1)
    print("end")
except Exception as e:
    print(e)
    print("捕获到异常...")
except ZeroDivisionError as zero:
    print(zero)
    print("捕获到除零错误...")

Python的科学计算生态圈

NumPy 处理一些多维矩阵

Scipy library 主要是积分运算，优化以及图形

Matplotlib 画图（二维图形）

IPython

Sympy 用的不多

pandas 主要是数据分析，数据处理（比较重要）数据清洗，提供比较好的数据结构

Dataframe （spark中也有）

Numpy

Numpy 是一个专门用于矩阵化运算，科学计算的开源Python

​ 强大的ndarray的多维数组结构

​ 成熟的函数库

​ 用于整合C/C++和Fortran代码的工具包

​ 实用的线性代数，傅里叶变换和随机数模块

​ Numpy和稀疏矩阵运算包scipy配合使用非常 方便

基本的数据结构（ndarray）

import numpy as np

# numpy
# 安装：pip install numpy

import numpy as np

data = [
    [1, 2, 3],
    [4, 5, 6]
]
np_arr = np.array(data)
print(np_arr, type(np_arr))

# jupyter notebook
# 安装：pip install jupyter notebook
# 使用：jupyter notebook

# np_arr.astype()

print(np_arr[:,1])
print(np.split(np_arr,2))

print(np_arr.reshape(3,2))

print(np_arr+np_arr)
print(np_arr-np_arr)
print(np_arr*np_arr)
print(np_arr/np_arr)