Python机器学习基础之Python的基本语法（一）-蒲公英云

   当今世界已经进入了大数据的时代。随着信息化的不断发展，人工智能、机器学习等词语越来越被人们所熟知，而他们也渐渐地成了这个时代的弄潮儿，走在了信息时代的前端。从本篇博客开始，小编将带领大家一起走进人工智能之机器学习部分，让深度学习不再成为困难。同时，相关的文章将会发布在我的博客专栏[《Python从入门到深度学习》][Python]，欢迎大家关注~
  [《Python从入门到深度学习》][Python]这一系列的博客是小编深思熟虑之后决定写的，目的是方便大家共同学习，也是为了巩固自己的知识。本专栏以代码为主，相关算法的原理讲解会在本专栏更新完之后，单独的列出一个新的算法专栏进行讲解，敬请期待。为了方便共同学习，小编在代码中列出了详细的注释。

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

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

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

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

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

六、Sklearn库和TensorFlow框架

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

   声明：代码的运行环境为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)