Python机器学习基础之Python的基本语法（一）

朴灿烈づ我的快乐病毒、 2021-09-15 09:32 520阅读 0赞

当今世界已经进入了大数据的时代。随着信息化的不断发展，人工智能、机器学习等词语越来越被人们所熟知，而他们也渐渐地成了这个时代的弄潮儿，走在了信息时代的前端。从本篇博客开始，小编将带领大家一起走进人工智能之机器学习部分，让深度学习不再成为困难。同时，相关的文章将会发布在我的博客专栏[《Python从入门到深度学习》][Python]，欢迎大家关注~

[《Python从入门到深度学习》][Python]这一系列的博客是小编深思熟虑之后决定写的，目的是方便大家共同学习，也是为了巩固自己的知识。本专栏以代码为主，相关算法的原理讲解会在本专栏更新完之后，单独的列出一个新的算法专栏进行讲解，敬请期待。为了方便共同学习，小编在代码中列出了详细的注释。

一、Python机器学习基础之Python的基本语法（一）

[二、Python机器学习基础之Python的基本语法（二）][Python_Python]

[三、Python机器学习基础之Numpy库的使用][Python_Numpy]

[四、Python机器学习基础之Pandas库的使用][Python_Pandas]

[五、Python机器学习基础之Matplotlib库的使用][Python_Matplotlib]

[六、Sklearn库和TensorFlow框架][Sklearn_TensorFlow]

[七、Python两种方式加载文件内容][Python 1]

声明：代码的运行环境为Python3。Python3与Python2在一些细节上会有所不同，希望广大读者注意。下面开始我们的第一讲：Python机器学习基础之Python的基本语法（一）。

【代码】

'''
    机器学习基础之Python的基本语法
    '''
    
    # 打印数据到控制台：python2中是不需要括号的；python3需要带括号
    print("Hello World!!")  # 值得一提的是，代码结尾的;是可有可无的
    # 同时打印多个变量，各个变量之间用,隔开
    a = "我是:"
    b = "象在舞"
    print(a, b)
    # python3中支持了Unicode（utf-8）字符串
    姓名 = '象在舞'
    print(姓名)
    
    # 注解的使用：单行注释采用#开头；多行注释使用三个单引号'''或三个双引号"""表示
    
    # 数据类型：1、Python 中的变量赋值不需要类型声明；2、Python中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头，区分大小写；
    # 3、以下划线开头的标识符有特殊意义。如：_foo 不能直接访问，需通过类提供的接口进行访问；4、在 python 中，变量是没有类型的，如：a=[1,2,3];a="Runoob"
    # [1,2,3] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，它仅仅是一个对象的引用（一个指针），可以指向 List 类型对象，也可以指向String类型对象;
    # Python3有六个标准的数据类型：Number（数字）;String（字符串）;List（列表）;Tuple（元组）;Dictionary（字典）;Set（集合，Python3新加的）
    
    # 数字：Python3支持三种不同的数字类型：int（有符号整型）；float（浮点型）；complex（复数：由实数和虚数构成，用a + bj,或complex(a,b)来表示）
    # long（长整型，注：在Python3里被去除了)
    a = 100
    print(a)
    b = 1.23
    print(b)
    c = 10 + 2j  # 复数(实数+虚数)
    print(c)
    
    # 字符串：使用引号( ' )、双引号( " )、三引号( ''' 或 """ )来表示字符串，其中三引号可以由多行组成
    a = 'xzw'
    b = "我是象在舞"
    c = '''我是象在舞,
    来自上海'''
    print(a, b, '\n', c)  # 中间用空格间隔
    
    str = 'Hello World!'
    print(str)
    print(str[0])         # 输出字符串中的第一个字符
    print(str[2:5])       # 输出字符串中第三个至第五个(不包含第6个)之间的字符串
    print(str[2:])        # 输出从第三个字符开始的字符串
    print(str * 2)        # 输出字符串两次
    print(str + "I am xzw.")   # 输出连接的字符串
    # print(str+1)         # 错误，不可以是非字符串类型(和java不一样)
    # 这种方法效率低，python中字符串是不可变的类型，使用 + 连接两个字符串时会生成一个新的字符串，生成新的字符串，就需要重新申请内存，当连
    # 续相加的字符串很多时(a+b+c+d+e+f+...) ，效率低下就是必然的了
    print('a' + 'b' + 'c')
    # 略复杂，但对多个字符进行连接时效率高，只会有一次内存的申请。如果是对list的字符进行连接的时候，这种方法是首选
    listStr = ['a', 'b', 'c']
    s = ''.join(listStr)
    print(s)
    # 字符串格式化，这种方法非常常用
    print('%s%s%s' % ('a', 'b', 'c'))
    print( 'Hello: %s %s %s' % ('xzw', 100, 22.3) )
    # 多个变量同时赋值
    a, b, c = 1, 2.2, "xzw"
    print(a, b, c)
    
    # 列表：List（列表）是Python中使用最频繁的数据类型，列表支持字符，数字，字符串，还可以包含列表（即嵌套）
    list = ['xzw', 786, 2.23, 'Eric', 70.2]
    tinylist = [123, 'Eric']
    print(list)               # 输出完整列表
    list[0] = 'aaa'
    print(list[0])            # 输出列表的第一个元素
    print(list[1:3])          # 输出第二个至第三个的元素，不包括第四个
    print(list[2:])           # 输出从第三个开始至列表末尾的所有元素
    print(tinylist * 2)       # 列表元素重复两次
    print(list + tinylist)    # 将两个列表合并
    
    # 元组：组是另一种数据类型，类似于List（列表）。元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
    tuple = ( 'xzw', 786 , 2.23, 'Eric', 70.2 )
    tinytuple = (123, 'Eric')
    print(tuple)               # 输出完整元组
    # tuple[0]='aaa'           # 错误
    print(tuple[0])            # 输出元组的第一个元素
    print(tuple[1:3])          # 输出第二个至第三个的元素
    print(tuple[2:])           # 输出从第三个开始至列表末尾的所有元素
    print(tinytuple * 2)       # 输出元组两次
    print(tuple + tinytuple)   # 打印组合的元组
    
    # 字典
    dict = {}
    dict['xzw'] = "This is xzw"
    dict[2] = "This is two"
    tinydict = {'name': 'xzw', 'code':6734, 'dept': 'sales'}
    print(dict['xzw'])          # 输出键为'one' 的值
    print(dict[2])              # 输出键为 2 的值
    print(tinydict)             # 输出完整的字典
    print(tinydict.keys())      # 输出所有键
    print(tinydict.values())    # 输出所有值
    
    # Set：Python3新加入的
    student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
    print(student)   #重复的元素被自动去掉
    if('Rose' in student) :
        print('Rose 在集合中')
    else :
        print('Rose 不在集合中')
    # set可以进行集合运算
    a = set('abcde')
    b = set('abcfg')
    print(a)
    print(b)
    print(a - b)     # a和b的差集
    print(a | b)     # a和b的并集
    print(a & b)     # a和b的交集
    print(a ^ b)     # a和b中不同时存在的元素
    
    # bytes类型：Python3新加入的
    b = b'xzw'
    print(b[0])     #打印出的是ascii码
    print(type(b))  #查看类型
    s = b.decode()  #转换为字符串
    print(s)
    b1 = s.encode() #转换为bytes类型
    print(b1)
    
    # 可变与不可变：在 python 中，string, tuple, 和 number 是不可更改的对象，而 list,dict 等则是可以修改的对象
    # 不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a
    # 可变类型：变量赋值 list=[1,2,3,4] 后再赋值 list[2]=5 则是将llist的第三个元素值更改， list本身没有动，只是其内部的一部分值被修改了
    
    # 运算符
    print(2 ** 3)  # 8 求幂
    print(10 // 3)  # 3 求整数商
    print(1 / 2)  # 0.5，和其他语言有所不同
    
    a = 100
    a += 1  # 没有a++
    print(a)
    
    # 关系运算符： > < == != ( <> 在Python3中不支持) >= <=
    # 逻辑运算符：0为假，非0为真
    a = 10
    b = 20
    if (a and b):
        print("1 - 变量 a 和 b 都为 true")
    else:
        print("1 - 变量 a 和 b 有一个不为 true")
    
    if (a or b):
        print("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
    else:
        print("2 - 变量 a 和 b 都不为 true")
    
    # 修改变量 a 的值
    a = 0
    if (a and b):
        print("3 - 变量 a 和 b 都为 true")
    else:
        print("3 - 变量 a 和 b 有一个不为 true")
    
    if (a or b):
        print("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
    else:
        print("4 - 变量 a 和 b 都不为 true")
    
    if not (a and b):
        print("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
    else:
        print("5 - 变量 a 和 b 都为 true")
    
    # 成员运算符：in、not in
    a = 1
    b = 20
    list = [1, 2, 3, 4, 5];
    
    if (a in list):
        print("1 - 变量 a 在给定的列表中 list 中")
    else:
        print("1 - 变量 a 不在给定的列表中 list 中")
    
    if (b not in list):
        print("2 - 变量 b 不在给定的列表中 list 中")
    else:
        print("2 - 变量 b 在给定的列表中 list 中")
    
    # 身份运算符
    # is 是判断两个标识符是不是引用自一个对象，x is y 类似 id(x) == id(y)
    # is 与 == 区别：is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等
    a = 20
    b = 20
    print(a is b)
    print(a is not b)
    # 修改变量 b 的值
    b = 30
    print(a is b)
    print(a is not b)
    # is在Python命令行中比较特殊，为了提高内存利用效率对于一些简单的对象，如一些数值较小的int对象，python采取重用对象内存的办法，如指向a = 2，b = 2
    # 时，由于2作为简单的int类型且数值小，python不会两次为其分配内存，而是只分配一次，然后将a与b同时指向已分配的对象
    # c = 20
    # d = 20
    # c is d
    # True
    # 如但果赋值的不是2而是较大的数值，情况就不一样了：
    # c = 5555
    # d = 5555
    # c is d
    # False
    
    # 条件：python并不支持switch语句
    num = 5
    if num == 3:
        print('boss')
    elif num == 2:
        print('user')
    elif num == 1:
        print('worker')
    elif num < 0:
        print('error')
    else:
        print('roadman')
    
    # 代码组：Python与其他语言最大区别是，Python代码块不使用大括号，Python最具特色的就是用缩进来写模块，缩进相同的一组语句构成一个代码块，我们称之代码组
    # 像if、while 、def和class等首行以关键字开始，以冒号结束，该行之后的一行或多行代码构成"代码组"
    # 我们将首行及后面的代码组称为一个"子句"(clause)缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行!!!
    # 例如：
    # if expression:
    #     suite  # 代码组
    # elif expression:
    #     suite
    # else:
    #     suite
    # 例如：(注意：没有严格缩进，在执行时会报错)。通过coding属性支持中文(在不支持中文时，加上该句)
    # 下面代码会报缩进错误IndentationError
    # # !/usr/bin/python
    # # -*- coding: UTF-8 -*-
    # if True:
    #     print("aaa")
    #     print("True")
    # else:
    #     print("bbb")
    # print("False")  # 注意缩进，只要对齐就行，至于用空格还是用tab对齐没区别
    # 注意：有些环境下，tab和空格不可以混用，有些环境下可以，因此建议在每个缩进层统一使用。'单个制表符'、'两个空格'或'四个空格'，尽量不要混用，以避免不必要的麻烦
    
    # while
    count = 0
    while count < 10:
        # while (count < 10) :  #也可以
        print('The count is:', count)
        count = count + 1
    # while … else …：循环条件为false时，执行else语句块，只执行一次
    count = 0
    while count < 5:
        print(count, " is  less than 5")
        count = count + 1
    else:
        print(count, " is not less than 5")
    
    # continue
    i = 1
    while i < 10:
        i += 1
        if i % 2 != 0:  # 非双数时跳过输出
            continue
        print(i)  # 输出双数2、4、6、8、10
    
    # break
    i = 1
    while True:
        print(i)
        i += 1
        if i > 10:  # 当i大于10时跳出循环
            break
    
    # for
    for letter in 'Python3':
        print('当前字母 :', letter)
    
    names = ['xzw', 'Eric', 'Josie']
    for name in names:
        print('当前姓名 :', name)
    
    # 通过序列索引迭代
    names = ['xzw', 'Eric', 'Josie']
    for index in range(len(names)):
        # for index in range(3): #效果相同，即(1,2,3)
        print('当前姓名 :', names[index])
    
    # for ...else
    for num in range(2, 10):  # 迭代 2 到 10 之间的数字
        for i in range(2, num):  # 根据因子迭代
            if num % i == 0:  # 确定第一个因子
                j = num / i  # 计算第二个因子
                print('%d 等于 %d * %d' % (num, i, j))
                break  # 跳出当前循环
        else:  # 循环的 else 部分
            print(num, '是一个质数')
    
    # pass:pass语句不做任何事情，一般用做占位
    for letter in 'Python':
        if letter == 'h':
            pass
            print('这是 pass 块')
        else:
            print('当前字母 :', letter)
    
    # 字符串中插入变量：
    # 方法一：
    name = 'xzw'
    sayhello = 'Hello,' + name
    print(sayhello)
    # 方法二：字符的格式化功能% s代表字符串， % d代表整数 ，都代表在字符中的占位符,变量的位置与字符串中的占位是一一对应关系
    name = 'xzw'
    age = 22
    sayhello = 'my name is %s ,and my age is %d ' % (name, age)
    print(sayhello)
    # 方法三：通过的字符串的format方法
    sayhello = 'my name is {0},and my age is {1} '
    print(sayhello.format('xzw', 22))
    
    # 文件的读写操作：
    # 读文件：
    f = open('C:\\test.txt', 'r')
    print(f.read())
    f.close()
    # 写文件：
    f = open('C:\\test.txt', 'w') # w是覆盖 ， a追加写入
    f.write('hello python!!!')
    f.close() # 写入的数据如果不关闭连接，数据可能还在内容中
    
    # 生成器
    # 列表 ：python中列表内存储的数据类型可以不一样,列表可以动态的扩展长度使用[]表示一个列表
    # 基本操作：
    list = [12, 'xzw', 1.1, 'Eric', 111]
    print(list[0])
    print(list[-1])
    list[0] = 13
    print(list)
    list.append(100)
    list.extend([20444555, 440])
    list.insert(1, 'str')
    list.pop()
    print(list)
    
    # 列表的切片：
    print(list[0:3])  # 左闭右开
    print(list[:3])
    print(list[-3:-1])  # 左闭右开
    print(list[-3:])
    print(list[0:99])
    list = list(range(1, 100))
    print(list)
    print(list[10:20])
    print(list[0:10:3])
    print(list[::5])
    print(list[::])
    
    # 列表生成式
    # 方法一：
    L = []
    for i in range(1, 10):
        L.append(i * i)
    print(L)
    
    # 方法二（列表生成式）：
    list = [x * x for x in range(1, 10)]
    print(list)
    list = [x * x for x in range(1, 10) if x % 2 == 0]
    print(list)
    
    # 生成器generator:通过列表生成式可以直接生产一个列表，元素都以计算出。如果一个列表元素非常多，直接计算出结果会产生oom。生成器可以解决：
    # 生成器没有直接计算出列表中元素的值，而是保存了计算算法，每次调用生成器时才会进行一次计算，而不是直接计算全部的值，生成器的类型是generator类型
    # 列表生成式结果是list列表类型
    # 创建生成器：
    # 方法一：
    list = (x * x for x in range(1, 10) if x % 2 == 0)
    print(list)
    print(type(list))
    # 方法二：
    # 在函数中有yield关键字声明，则该函数最终返回结果是生成器
    list = range(1, 10)
    def getSquare(list):
        for i in list:
            temp = i * i
            yield temp # 使用yield关键字，函数变为了生成器
    print(getSquare(list))
    
    # 生成器的取值：
    # 方法一：每使用next方法调用一次，就会计算一次并返回计算结果
    print(next(getSquare(list)))
    print(next(getSquare(list)))
    print(next(getSquare(list)))
    print(next(getSquare(list)))
    # 方法二：生成器也是一个可迭代对象，所以可以使用for进行迭代
    for x in getSquare(list):
        print(x)

你们在此过程中遇到了什么问题，欢迎留言，让我看看你们都遇到了哪些问题。

[Python]: https://blog.csdn.net/column/details/22367.html
[Python_Python]: https://blog.csdn.net/gdkyxy2013/article/details/80230492
[Python_Numpy]: https://blog.csdn.net/gdkyxy2013/article/details/80237596
[Python_Pandas]: https://blog.csdn.net/gdkyxy2013/article/details/80290755
[Python_Matplotlib]: https://blog.csdn.net/gdkyxy2013/article/details/80294021
[Sklearn_TensorFlow]: https://blog.csdn.net/gdkyxy2013/article/details/81157254
[Python 1]: https://blog.csdn.net/gdkyxy2013/article/details/81979214