1. 基于深度学习的python速通(一)
  2. 基于深度学习的python速通(三)
  3. 基于深度学习的python速通(二)

深度学习相关库

  • NumPy——为python加上了关键的数组变量类型
  • Pandas——在Numpy数组的基础上添加了与Excel类似的行列标签
  • Matplotlib——借鉴Matlab，使Python具备了绘图能力
  • Scikit-learn——机器学习库，内含分类、回归、聚类、降维等多种算法
  • Pytorch——Facebook的深度学习框架

变量类型与输出语句

Python是动态输入类型的语言，类似Matlab，变量类型动态推断，静态类型的C语言需声明变量类型int a = 1，Python为a = 1

变量类型

  • 变量名由数字、字母、下划线组成，不能以数字开头，不能与内置函数重名
  • 根据变量是否可以充当容器，将变量类型分为基本类型和高级类型。
    • 基本变量类型：字符串、数字、布尔型
    • 高级变量类型：集合、元组、列表、字典
      变量类型示例
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      # 字符串
      str = 'hello world'
      print(a)
      # 数字
      num = 1
      print(a)
      # 布尔型
      boolean = True
      print(a)
      # 集合
      set = {1,2,3}
      print(a)
      # 元组
      tuple = (1,2,3)
      print(a)
      # 列表
      list = [1,2,3]
      print(a)
      # 字典
      dict = {'a':1,'b':2}
      print(a)

输出语句

经典用法

在字符串中插入其他变量，可使用f或format方法

1
2
3
name = '张三'
age = 18
print(f'我是{name}，我今年{age}岁')

转义字符

  • \n：换行
  • \t：制表符
  • \\：反斜杠
  • \'：单引号
  • \"：双引号
    1
    print('hello\nworld')
    转移字符只在print函数中生效

数据类型

运算符

+—+—+—+—+

运算符 名称 示例 说明
+ 加法 a + b 两个数相加
- 减法 a - b 第一个数减去第二个数
* 乘法 a * b 两个数相乘
/ 除法 a / b 第一个数除以第二个数
% 取余 a % b 第一个数除以第二个数的余数
** 幂 a ** b 第一个数的第二个数次幂
// 取整 a // b 第一个数除以第二个数的整数部分
+—+—+—+—+

布尔型

基于高级变量类型生成

1
2
3
4
5
6
# 集合——检查某变量是否在集合中
set_v = set([1,2,3])
print(2 in set_v)
print(2 not in set_v)
>True
>Fulse
1
2
3
4
5
6
# 元组——检查某变量是否在元组中
tuple_v = ([1,2,3])
print(2 in tuple_v)
print(2 not in tuple_v)
>True
>Fulse

同时检查多个条件

  • and: 与，两个条件都为True时，结果为True
  • or: 或，两个条件有一个为True时，结果为True
  • not: 非，条件为True时，结果为False
    1
    2
    3
    4
    5
    6
    7
    8
    a = 1
    b = 2
    print(a < 2 and b > 1)
    print(a < 2 or b > 1)
    print(not a < 2)
    >True
    >True
    >Fulse

条件语句

bool值通常作为if判断的条件，if判断的语法规则为

1
2
3
4
5
6
if Boolean:
    执行语句
elif Boolean：
    执行语句
else：
    其他情况

注意事项

  • Python利用缩进（四个空格）表示代码块的范围，每个判断条件后有一个冒号：
  • if语句中可以嵌套if语句，elif语句可以有多个，else语句最多只能有一个

基本变量间的转换

字符串、整型、浮点、Boolean可以无缝切换

  • int()：将变量转换为整数
  • float()：将变量转换为浮点数
  • str()：将变量转换为字符串
  • bool()：将变量转换为布尔型
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    a = 1
    b = 1.0
    c = '1'
    d = True
    print(str(a,b,c,d))
    >1 1.0 1 True
    print(int(a,b,c,d))
    >1 1 1 1
    print(bool(a,b,c,d))
    >True True True True # 其他变量转化为布尔型时，只有当字符串为空、数字为0、列表为空、元组为空、集合为空时，结果为False

高级变量类型

高级变量类型，即集合、元组、列表、字典，他们有一个共同点：作为容器，它们可以随意容纳任意变量（同一个容器内可以包含全部7种变量类型）

集合

无序的、不重复的元素集合
集合的创建

1
2
3
4
# 直接创建
set = {1,2,3}
# 从列表创建
set = set([1,2,3])

元组

有序的、不重复的元素集合

创建元组

1
2
3
4
5
6
7
8
# 直接创建
tuple = (1,2,3)
# 从列表创建
tuple = tuple([1,2,3])
# 省略括号
tuple = 1,2,3
# 元组中只有一个元素时，需要在元素后添加逗号
tuple = (1,)

输出语句中的元组法

高级变量类型都可以容纳所有的变量类型，包括元组

1
2
“a”，1，True，[1,2,3]
>(‘a’,1,True,[1,2,3])

元组法可以替代format方法

1
2
3
4
5
6
anser = 98
print(f'答案为：{answer}')
print('答案为：',answer)
>答案为：98
>答案为： 98
# 元组法会比format方法多出一个空格

元组拆分

  1. 极速创建新变量
    1
    2
    3
    4
    tuple = (1,2,3)
    a,b,c = tuple
    print(a,b,c)
    >1 2 3
  2. 极速交换变量值
    1
    2
    3
    4
    5
    a = 1
    b = 2
    a,b = b,a
    print(a,b)
    >2 1
  3. 拆包
    1
    2
    3
    4
    values = 1,2,3,4,5
    a,b,*rest = values
    print(a,b,rest)
    >1 2 [3,4,5]
  4. 元组的常用方法
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    # 统计元组中元素的个数
    tuple = (1,2,3)
    print(len(tuple))
    >3
    # 统计元组中某个元素的个数
    tuple = (1,2,3,1)
    print(tuple.count(1))
    >2
    # 查找元组中某个元素的索引
    tuple = (1,2,3)
    print(tuple.index(2))
    >1

列表

由多个有序的变量组成，其中元素间可以无任何关系，出现标为中括号[]，变量使用逗号分隔

创建列表

1
2
3
4
5
6
# 直接创建
list = [1,2,3]
# list函数从元组创建
list = list((1,2,3))
# list函数从字符串创建
list = list('123')

列表访问与修改

访问列表元素时使用中括号[]，索引从0开始

1
2
3
4
5
6
7
8
9
10
11
list = ['yuzisoft',114,514,True,(1,2,3)]
print(list[0])
>yuzisoft
print(list[1])
>114
print(list[2])
>514
print(list[3])
>True
print(list[4])
>(1,2,3)

可以通过访问某列表元素的方式对数值进行修改

1
2
3
4
list = [1,2,3]
list[0] = 4
print(list)
>[4,2,3]

列表常用方法

1
2
3
4
5
6
7
8
# 列表长度
list = [1,2,3]
print(len(list))
>3
# 列表元素类型
list = [1,2,3]
print(type(list[0]))
><class 'int'>

切片

切片是指从列表中取出一部分元素，生成一个新的列表

1
2
3
4
5
6
7
list = [1,2,3,4,5,6,7,8,9]
print(list[1:5])
print(list[ :5])
print(list[1:])
>[2,3,4,5]
>[1,2,3,4,5]
>[2,3,4,5,6,7,8,9]

当明确几个元素采样一次时

1
2
3
list = [1,2,3,4,5,6,7,8,9]
print(list[1:5:2])
>[2,4]

列表元素的添加

1
2
3
4
list = [1,2,3]
list.append(4)
print(list)
>[1,2,3,4]

列表元素的删除

1
2
3
4
list = [1,2,3]
list.remove(2)
print(list)
>[1,3]

字典

由多个键值对组成，其中键值对之间使用逗号分隔，键和值之间使用冒号分隔，整个字典使用大括号{}包裹

创建字典

1
2
3
4
# 直接创建
dict = {'name':'yuzisoft','age':18}
# 从列表创建
dict = dict([('name','yuzisoft'),('age',18)])

字典中的元素值可以是任何变量

1
2
3
4
5
6
7
dict_v = {
    0:'a',
    1:'b',
    2:'c',
}
print(dict_v[0],dict_v[1],dict_v[2])
>a b c

添加元素

1
2
3
4
dict = {'name':'MurasameAya','age':500}
dict['gender'] = 'taidaojing'
print(dict)
>{'name': 'MurasameAya', 'age': 500, 'gender': 'taidaojing'}

删除元素

1
2
3
4
dict = {'name':'MurasameAya','age':500}
dict['gender'] = 'taidaojing'
print(dict)
>{'name': 'MurasameAya', 'age': 500, 'gender': 'taidaojing'}

循环语句

for循环

for循环可以让循环变量一此去边类表中的每个元素

1
2
3
4
list = [1,2,3,4,5,6,7,8,9]
for i in list:
    print(i)
>1 2 3 4 5 6 7 8 9

while循环

while循环可以让循环变量在满足条件时一直循环，直到不满足条件时结束循环

1
2
3
4
5
i = 0
while i < 5: # 知道bool值为False时结束循环
    print(i)
    i += 1
>0 1 2 3 4

高级变量间的转换

集合、元组、列表、字典四者之间可以无缝切换，需要用到四个函数

  • 转换为集合：set()
  • 转换为元组：tuple()
  • 转换为列表：list()
  • 转换为字典：dict()
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    # 定义变量
    set_v = [1,2,3]
    tuple_v = (1,2,3)
    list_v = [1,2,3]
    dict_v = {'name':'yuzisoft','age':18}
    # 转换为集合
    print(set(tuple_v))
    print(set(list_v))
    print(set(dict_v.keys()))
    print(set(dict_v.values()))
    print(set(dict_v.items()))
    >{1, 2, 3}
    >{1, 2, 3}
    >{'age', 'name'}
    >{18, 'yuzisoft'}
    >{('age', 18), ('name', 'yuzisoft')}
    # 转换为元组
    print(tuple(set_v))
    print(tuple(list_v))
    print(tuple(dict_v.keys()))
    print(tuple(dict_v.values()))
    print(tuple(dict_v.items()))
    >(1, 2, 3)
    >(1, 2, 3)
    >('name', 'age')
    >('yuzisoft', 18)
    >(('name', 'yuzisoft'), ('age', 18))
    # 转换为列表
    print(list(set_v))
    print(list(tuple_v))
    print(list(dict_v.keys()))
    print(list(dict_v.values()))
    print(list(dict_v.items()))
    >[1, 2, 3]
    >[1, 2, 3]
    >['name', 'age']
    >['yuzisoft', 18]
    >[('name', 'yuzisoft'), ('age', 18)]
    # 转换为字典
    print(dict(zip(tuple_v,list_v)))
    print(dict(zip(list_v,tuple_v)))
    print(dict(zip(dict_v.keys(),dict_v.values())))
    >{1: 1, 2: 2, 3: 3}
    >{1: 1, 2: 2, 3: 3}
    >{'name': 'yuzisoft', 'age': 18}

函数

函数可以避免大段重复代码，其格式为

1
2
3
4
5
6
def 函数名(参数1,参数2,参数3...):
    """
    文档字符串（函数说明）
    """
    函数体
    return 返回值

文档字符串用于解释函数的作用，查看某函数文档字符串的方法是.__doc__
函数中return可省略（一般不省略），不写return则返回None

吞吐变量

  1. 吞吐多个普通参数
    输入多个值本质上是输入了一个元组，输出多个值本质是输出看了一个元组
    1
    2
    3
    4
    5
    def func(a,b):
        """
        加法器和乘法器
        """
        return a+b,a*b
  2. 吞吐一个任意数量的参数
    当函数的参数数量不确定时，可以使用*args来接收任意数量的参数
    1
    2
    3
    4
    5
    6
    7
    8
    9
    def func(*args):
        """
        任意数量参数的加法器
        """
        return sum(args)

    bot=(1,2,3,4,5,6,7)
    sum_v=func(*bot)  # 使用*解包元组，将元组中的元素作为独立参数传递
    print(sum_v)

类

  • 类的本质是在一堆函数之间传递参数
  • 根据约定，类的名称需要首字母大写
  • 类的定义需要使用class关键字
  • 类的定义需要使用缩进
  • 类的定义需要使用self作为第一个参数
  • 类的定义需要使用__init__方法来初始化类的属性
  • 类的定义需要使用__str__方法来定义类的字符串表示
  • 类的定义需要使用__len__方法来定义类的长度
  • 类的定义需要使用__del__方法来定义类的析构函数
  • 类的定义需要使用__call__方法来定义类的调用函数
  • 类的定义需要使用__getitem__方法来定义类的索引函数
  • 类的定义需要使用__setitem__方法来定义类的赋值函数
  • 类的定义需要使用__delitem__方法来定义类的删除函数
  • 类的定义需要使用__contains__方法来定义类的包含函数
  • 类的定义需要使用__iter__方法来定义类的迭代函数
  • 以上只有前六行有用

创建和使用类

  1. 创建类
    类的创建需要使用class关键字，类的名称需要首字母大写，类的定义需要使用缩进
    1
    2
    3
    4
    5
    class 类名:
        """
        类的文档字符串
        """
        类的定义
  2. 使用类
    类的使用需要使用类名()来创建类的实例，类的实例需要使用.来访问类的属性和方法
    1
    2
    类名.属性
    类名.方法()
    类的示范
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    class Counter:
        """
        计数器
        """

        def __init__(self,a,b):
            """
            a、b为公共变量，也是self的属性
            """
            self.a=a
            self.b=b
        
        def add(self):
            return(self.a*self.b)

        def sub(self):
            return(self.a-self.b)
        
        def mul(self):
            return(self.a*self.b)
        
        def div(self):
            return(self.a/self.b)
  • 函数内部的变量与外部是在两个空间，为了使自定义方法能在类里互通，需要一个self作为舰船，将需要互通的变量作为self的属性进行传递，因此，特殊方法__init__旨在使用舰船self来承载公共变量a和b
  • __init__特殊方法后的括号里要写上舰船self以及公共变量a和b，而自定义方法后的括号里只需要写上self即可
    类的编写完成后，可以创造出很多的实例出来
    接上例
    1
    2
    3
    4
    5
    6
    # 创建类的实例
    cnt = Counter(10,5) # 创建实例cnt
    print(cnt.a,cnt.b)
    print(cnt.add)
    >10 5
    >15

属性的默认值

上文说到，属性即公共变量，上一个实例里的属性即a和b。我们可以给self的属性一个默认值，此时默认值不用写进__init__后面的括号里

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Man:
    """
    Man!
    """
    def __init__(self,name,age):
        """
        公共变量
        """
        self.name=name
        self.age=age
        self.gender='hilicopter' # 一个带有默认值的属性

    def pres(self):
        """
        自我介绍
        """
        print(f'我是{self.name}，我今年{self.age}岁')

cxk = Man('cxk',18)
cxk.pres()
print(cxk.gender)
>我是cxk，我今年18岁
>hilicopter

继承

继承是在某个类（父类）的基础上添加几个方法，形成另一个类（子类）

  • 父类从无到有去写属性和方法，第一行是class 类名：
  • 子类可继承父类的属性和方法，第一行是class 类名(父类名)：
    子类在特殊方法里使用super()函数，就可以继承到父类的全部属性和方法
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    # 父类
    class Counter:
        """
        计算器
        """
        def __init__(self,a,b):
            """
            a、b为公共变量，也是self的属性
            """
            self.a=a
            self.b=b
        def add(self):
            return(self.a+self.b)
        def sub(self):
            return(self.a-self.b)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    # 子类
    class Counter2(Counter):
        """
        高级计算器
        """
        def __init__(self,a,b):
            """
            引用父类的属性
            """
            super().__init__(a,b) # 继承父类

        def mul(self):
            return(self.a*self.b)
        # 重写父类的方法
        def div(self):
            return(self.a/self.b)

    test = Counter2(10,5)
    print(test.add())
    print(test.mul())
    >15
    >50
    如果想在子类里修改父类中的某个方法，可以直接在子类里写一个同名方法，即可实现覆写，也可以称其为“变异”
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    # 子类
    class Counter2(Counter):
        """
        高级计算器
        """
        def __init__(self,a,b):
            """
            引用父类的属性
            """
            super().__init__(a,b) # 继承父类

        def mul(self):
            return(self.a*self.b)
        # 重写父类的方法
        def div(self):
            return(self.a/self.b)
        # 新增方法
        def pow(self):
            return(self.a**self.b)

掠夺

继承只能继承一个类的方法，但如果想要得到很多其他类的方法，则需要掠夺功能，一个类可以掠夺很多其他的类，实例如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 父类1
class Counter:
    """
    计算器
    """
    def __init__(self,a,b):
        """
        a、b为公共变量，也是self的属性
        """
        self.a=a
        self.b=b
    def add(self):
        return(self.a+self.b)
    def sub(self):
        return(self.a-self.b)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 掠夺者
class Amrc:
    """
    本身只能乘除的计算器，掠夺了加减功能
    """
    def __init__(self,c,d):
        """
        c、d为公共变量，也是self的属性
        """
        self.c=c
        self.d=d
        self.cnt=Counter(c,d) # 掠夺Counter类的方法
        return(self.c*self.d)
    
    def mul(self):
        return(self.c*self.d)
    def div(self):
        return(self.c/self.d)

test = Amrc(10,5) # 创建实例
print(test.mul()) # 自己的方法
print(test.cnt.add()) # 掠夺的方法
>50
>15

掠夺的本质是将另一类的实例当作self的属性用，这样被掠夺的类的数量就无上限了。此外，加入掠夺者和被掠夺这里都有add函数，掠夺者里的方法用test.add()，被掠夺者里的方法用test.cnt.add()，于是就不必去覆写了。

本篇到此结束，接下来赶到现场是基于`深度学习的python(二)-Numpy`篇