《Python机器学习及实践：从零开始通往Kaggle竞赛之路》第1章 简介篇 学习笔记（二）1.4Python编程基础总结
目录
1.4Python编程基础
1、Python基本语法
（1）一段正确运行的Python代码
（2）一段错误运行的代码
（3）小结
2、Python数据类型
（1）数字（Number）
（2）布尔值（Boolean）
（3）字符串（String）
（4）元组（Tuple）
（5）列表（List）
（6）字典（Dictionary）
3、Python数据运算
（1）算术运算
（2）比较运算
（3）赋值运算
（4）逻辑运算
（5）成员运算
4、Python流程控制
（1）分支语句（if）
（2）循环控制（for）
5、Python函数（模块）设计
6、Python编程库（包）的导入
7、Python基础综合实践
1.4Python编程基础 1、Python基本语法 （1）一段正确运行的Python代码
# 代码1：一段正确运行的Python代码
isMLGeek = True
# 如果您是一位机器学习爱好者，系统常规输出：推荐您购买《Python机器学习及实践》。
if isMLGeek:
print('I recommend you to read "DIY Machine Learning Systems for Kaggle Competitions with Python Programming"!')
本地输出：
I recommend you to read "DIY Machine Learning Systems for Kaggle Competitions with Python Programming"!
（2）一段错误运行的代码
# 代码2：一段错误运行的代码
# isMLGeek
# 错误提示
# Traceback (most recent call last):
# File "F:/AC/pycharm/kaggle/kaggle1.py", line 4, in
# if isMLGeek:
# NameError: name 'isMLGeek' is not defined
（3）小结
①命令提示符：代码中每一行有关Python的编程语句都由>>>作为命令提示符。如果使用Pycharm或者IPython Notebook等集成开发平台，我们则看不到Python命令行提示符。
②代码缩进：许多在C、C++和Java语言中需要用{}来分割的模块，在Python中都严格采用缩进机制进行区分。
③注释：为代码添加注释是一种专业性的良好习惯，使得代码便于追溯并且提高可读性。
④瑞士计算机科学家、1984年图灵奖获得者Niklaus E. wirth在他1976年出版的著名书籍Algorithms + Data Structures = Programs中阐述了一个非常经典的观点：程序是由数据结构与算法组成。
2、Python数据类型
（1）数字（Number）
常用的数字类型包括整型数（Integer）、长整型数（Long）、浮点数（Float）以及复杂型数（Complex）。整型数和浮点数是我们平时最常使用的两类。
（2）布尔值（Boolean）
在Python中，用来表示真/假有固定的表示：True代表真，False代表假。切记，Python是大小写敏感的编程语言，因此只有按照这样输入才会被解释器理解为布尔值。
（3）字符串（String）
在Python里，字符串的表示可以使用成对的英文单引号或者双引号辅助进行表示：'abc'或者"123"。
（4）元组（Tuple）
元组是一系列Python数据类型按照顺序组成的序列。使用一组小括号()表征，如(1, 'abc', 0.4)是一个包含有三个元素的元组。元组中的数据类型不必统一，这个是Python的一大特点。我们可以通过索引直接从元组中找到我们需要的数据。特别需要提醒的是，大多数编程语言都默认索引的起始值为0，不是1。
（5）列表（List）
列表是用一对中括号[]来组织数据，如[1, 'abc', 0.4]。需要记住一点例外的是：Python允许在使用者在访问列表的同时修改列表里的数据，而元组则不然。
（6）字典（Dictionary）
这是Python里面非常实用而且功能强大的数据结构，特别在数据处理任务里面，字典几乎成了数据存储的主流形式。从字典自身的数据结构而言，它包括多组键（key）:值（value）对，Python是用大括号来容纳这些键值对，如{1:'1', 'abc':0.1, 0.4:80}。字典中的键是唯一的，但是没有数据类型的要求。
3、Python数据运算
（1）算术运算
Python常用的算术运算符有：加法（+）、减法（-）、乘法（*）、除法（/）、取模（%）以及幂指数（**）运算。
# 代码3：算术运算代码举例
# 整数加法。
a1 = 10 + 20
print('a1 = ', a1)
# 整数与浮点数的减法。
a2 = 30 - 60.6
print('a2 = ', a2)
# 整数与浮点数的乘法。
a3 = 4 * 8.9
print('a3 = ', a3)
# 整数与整数的除法，这里会发现结果只是保留了取整后的商数。（备注：Python3.7版本中，结果为浮点数）
a4 = 5 / 4
print('a4 = ', a4)
# 整数与浮点数的除法，结果变为浮点数。
a5 = 5.0 / 4
print('a5 = ', a5)
# 整数取模运算。
a6 = 5 % 4
print('a6 = ', a6)
# 幂指数运算。
a7 = 2.0 ** 3
print('a7 = ', a7)
本地输出：
a1 = 30
a2 = -30.6
a3 = 35.6
a4 = 1.25
a5 = 1.25
a6 = 1
a7 = 8.0
（2）比较运算
如果说，算术运算的返回值一般是数字类型的话；那么，比较运算则反馈布尔值类型的结果。
# 代码4：比较运算代码举例
# 整数比较。
a8 = 10 20
print('a9 = ', a9)
# 整数与浮点数的比较。
a10 = 30 = 30.0
print('a11 = ', a11)
# 判断两个值是否相等。
a12 = 30 == 40
print('a12 = ', a12)
# 两个值不相等的判定。
a13 = 30 != 40
print('a13 = ', a13)
本地输出：
a8 = True
a9 = False
a10 = True
a11 = True
a12 = False
a13 = True
（3）赋值运算
与许多流行的高级编程语言C、C++、Java等不同，Python在声明变量时不需要预告知类型。
# 代码5：赋值运算代码样例
# 将一个元组赋值给变量t。
t = (1, 'abc', 0.4)
print('t = ', t)
# 试图更改元组t的第一个元素，但是解释器报错，具体原因我们已经讲过，元组一旦初始化不可以改变内部元素。
# t[0] = 2
# 错误提示
# Traceback (most recent call last):
# File "F:/AC/pycharm/kaggle/kaggle1.py", line 61, in
# t[0] = 2
# TypeError: 'tuple' object does not support item assignment
# 将一个列表赋值给变量l。
l = [1, 'abc', 0.4]
print('l = ', l)
# 试图更改列表l的第一个元素。
l[0] = 2
print('l = ', l)
# 试图对更新过的列表l的第一个元素2，进行递增1并重新赋值的操作。
l[0] += 1
print('l = ', l)
# 观察输出，应该为3。
l[0]
print('l[0] = ', l[0])
# 试图对更新过的列表l的第一个元素2，进行递减2，并且重新赋值给l[0]。
l[0] -= 2
print('l = ', l)
# 观察输出，应该为1。
print('l[0] = ', l[0])
本地输出：
t = (1, 'abc', 0.4)
l = [1, 'abc', 0.4]
l = [2, 'abc', 0.4]
l = [3, 'abc', 0.4]
l[0] = 3
l = [1, 'abc', 0.4]
l[0] = 1
（4）逻辑运算
这种类型的运算比较简单，共有三种：与（and）、或（or）、非（not）。
# 代码6：逻辑运算代码样例
# 与（and）运算只有二者都是True返回值才是True。
a14 = True and True
print('a14 = ', a14)
a15 = True and False
print('a15 = ', a15)
# 或（or）运算只要有其中一方为True，运算结果就是True。
a16 = True or False
print('a16 = ', a16)
a17 = False or False
print('a17 = ', a17)
# 非（not）运算直接反转布尔值。
a18 = not True
print('a18 = ', a18)
本地输出：
a14 = True
a15 = False
a16 = True
a17 = False
a18 = False
（5）成员运算
这是针对Python里面较为复杂的数据结构而设立的一种运算，主要面向元组、列表和字典。通过运算符in询问是否有某个元素在元组或者列表里出现，或者检视某个键（key）是否在字典里存在。
# 代码7：成员运算代码样例
# 将一个列表赋值给变量l，一个元组赋值给变量t，一个字典赋值给变量d。
l = [1, 'abc', 0.4]
t = (1, 'abc', 0.4)
d = {1: '1', 'abc': 0.1, 0.4: 80}
# 试图询问1列表中是否有0.4。
a19 = 0.4 in l
print('a19 = ', a19)
# 试图询问t元组中是否有1。
a20 = 1 in t
print('a20 = ', a20)
# 试图询问字典d中是否有键'abc'。
a21 = 'abc' in d
print('a21 = ', a21)
# in只能用来考量是否有键（key），不能告诉您是否有值（value）。
a22 = 0.1 in d
print('a22 = ', a22)
本地输出：
a19 = True
a20 = True
a21 = True
a22 = False
4、Python流程控制
（1）分支语句（if）
解释器会依次询问if与elif后面的布尔值或者反馈布尔值的表达式，一旦其中任何一个为真，便会执行对应的多行分支语句；如果其中没有任何一个为真，则执行else对应的语句。
常用几种语法结构如下：
if 布尔值/表达式:
【制表符】执行分支1（可以有多行，都需要制表符缩进）
【制表符】……
else:
【制表符】执行分支2（可以有多行，都需要制表符缩进）
【制表符】……
或者
if 布尔值/表达式:
【制表符】执行分支1（可以有多行，都需要制表符缩进）
【制表符】……
elif 布尔值/表达式:
【制表符】执行分支2（可以有多行，都需要制表符缩进）
【制表符】……
else:
【制表符】执行分支3（可以有多行，都需要制表符缩进）
【制表符】……
# 代码8：分支语句代码样例
# 首先将True的布尔值赋予变量b。
b = True
# 然后使用分支语句if else组合。
if b:
print("It's True!")
else:
print("It's False!")
# 接着使用分支语句if elif else组合，将False的布尔值赋予变量b，True赋予变量c。
b = False
c = True
if b:
print("b is True!")
elif c:
print("c is True!")
else:
print("Both are False!")
# 将False的布尔值赋予变量b，False赋予变量c，重复一遍，观察结果。
b = False
c = False
if b:
print("b is True!")
elif c:
print("c is True!")
else:
print("Both are False!")
本地输出：
It's True!
c is True!
Both are False!
（2）循环控制（for）
在执行循环语句时，临时变量会逐个获得可遍历数据结构中的值；每获取到其中一个值之后，制表符缩进的所有语句会执行一次。
常见的一种遍历语法如下：
for 临时变量 in 可遍历数据结构（列表、元组、字典）
【制表符】执行语句（可以有多行，都需要制表符缩进）
【制表符】……
# 代码9：循环语句代码样例
# 对字典d的键进行循环遍历，输出每组键值对。
d = {1: '1', 'abc': 0.1, 0.4: 80}
for k in d:
print(k, ":", d[k])
本地输出：
1 : 1
abc : 0.1
0.4 : 80
5、Python函数（模块）设计
在对函数/模块的设计方面，我们可以向函数提供必要的参数输入，同时可以从函数/模块获取所需的返回值。Python采用def这个关键词来定义一个函数/模块。
# 代码10：函数定义和调用代码样例
# 定义一个名叫foo的函数，传入参数x。
def foo(x):
# 为x执行平方运算，返回所得的值，同时注意函数体内部所有代码一律缩进。
return x ** 2
# 调用函数foo，传入参数值为8.0，观察输出，结果为64.0。
a23 = foo(8.0)
print('a23 = ', a23)
本地输出：
a23 = 64.0
6、Python编程库（包）的导入
有一些编程库默认配置在Python最基本的解释器环境中，这些是我们经常要用到的；也有一些是其他编程爱好者所开发，发布在PyPI（Python Package Index）平台上，这些需要我们自主安装。实际使用中，哪怕是执行一些相对简单的数学运算，我们甚至都能在Python语言的内置程序库中找到可以导入（import）并且使用的包。
# 代码11：程序库/工具包导入代码示例
# 直接使用import导入math工具包。
import math
# 调用math包下的函数exp求自然指数。
a24 = math.exp(2)
print('a24 = ', a24)
# 从（from）math工具包里指定导入exp函数。
from math import exp
# 直接使用函数名称调用exp，不需要声明math包。
a25 = exp(2)
print('a25 = ', a25)
# 从（from）math工具包里指定导入exp函数，并且对exp重新命名为ep。
from math import exp as ep
# 使用函数exp的临时替代名称调用。
a26 = ep(2)
print('a26 = ', a26)
本地输出：
a24 = 7.38905609893065
a25 = 7.38905609893065
a26 = 7.38905609893065
7、Python基础综合实践
# 代码12：“良/恶性乳腺癌肿瘤预测”完整代码样例
# 导入pandas工具包，并且更名为pd。
import pandas as pd
# 调用pandas工具包的read_csv函数/模块，传入训练文件地址参数，获得返回的数据并且存至变量df_train。
df_train = pd.read_csv('../Datasets/Breast-Cancer/breast-cancer-train.csv')
# 调用pandas工具包的read_csv函数/模块，传入测试文件地址参数，获得返回的数据并且存至变量df_test。
df_test = pd.read_csv('../Datasets/Breast-Cancer/breast-cancer-test.csv')
# 选取'Clump Thickness'与'Ceil Size'作为特征，构建测试集中的正负分类样本。
df_test_negative = df_test.loc[df_test['Type'] == 0][['Clump Thickness', 'Cell Size']]
df_test_positive = df_test.loc[df_test['Type'] == 1][['Clump Thickness', 'Cell Size']]
# 导入matplotlib工具包中的pyplot并简化命名为plt。
import matplotlib.pyplot as plt
# 绘制图1-2中的良性肿瘤样本点，标记为红色的o。
plt.scatter(df_test_negative['Clump Thickness'], df_test_negative['Cell Size'], marker='o', s=200, c='red')
# 绘制图1-2中的恶性肿瘤样本点，标记为黑色的x。
plt.scatter(df_test_positive['Clump Thickness'], df_test_positive['Cell Size'], marker='x', s=150, c='black')
# 绘制x，y轴的说明。
plt.xlabel('Clump Thickness')
plt.ylabel('Ceil Size')
# 显示图1-2。
plt.show()
# 导入numpy工具包，并且重命名为np。
import numpy as np
# 利用numpy中的random函数随机采样直线的截距和系数。
intercept = np.random.random([1])
coef = np.random.random([2])
lx = np.arange(0, 12)
ly = (-intercept - lx * coef[0]) / coef[1]
# 绘制一条随机直线。
plt.plot(lx, ly, c='yellow')
# 绘制图1-3。
plt.scatter(df_test_negative['Clump Thickness'], df_test_negative['Cell Size'], marker='o', s=200, c='red')
plt.scatter(df_test_positive['Clump Thickness'], df_test_positive['Cell Size'], marker='x', s=150, c='black')
plt.xlabel('Clump Thickness')
plt.ylabel('Ceil Size')
plt.show()
# 导入sklearn中的逻辑斯蒂回归分类器。
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
# 使用前10条训练样本学习直线的系数和截距。
lr.fit(df_train[['Clump Thickness', 'Cell Size']][:10], df_train['Type'][:10])
print('Testing accuracy (10 training samples):', lr.score(df_test[['Clump Thickness', 'Cell Size']], df_test['Type']))
intercept = lr.intercept_
coef = lr.coef_[0, :]
# 原本这个分类面应该是lx * coef[0] + ly * coef[1] + intercept = 0，映射到2维平面上之后，应该是：
ly = (-intercept - lx * coef[0]) / coef[1]
# 绘制图1-4。
plt.plot(lx, ly, c='green')
plt.scatter(df_test_negative['Clump Thickness'], df_test_negative['Cell Size'], marker='o', s=200, c='red')
plt.scatter(df_test_positive['Clump Thickness'], df_test_positive['Cell Size'], marker='x', s=150, c='black')
plt.xlabel('Clump Thickness')
plt.ylabel('Ceil Size')
plt.show()
lr = LogisticRegression()
# 使用所有训练样本学习直线的系数和截距。
lr.fit(df_train[['Clump Thickness', 'Cell Size']], df_train['Type'])
print('Testing accuracy (all training samples):', lr.score(df_test[['Clump Thickness', 'Cell Size']], df_test['Type']))
intercept = lr.intercept_
coef = lr.coef_[0, :]
ly = (-intercept - lx * coef[0]) / coef[1]
# 绘制图1-5。
plt.plot(lx, ly, c='blue')
plt.scatter(df_test_negative['Clump Thickness'], df_test_negative['Cell Size'], marker='o', s=200, c='red')
plt.scatter(df_test_positive['Clump Thickness'], df_test_positive['Cell Size'], marker='x', s=150, c='black')
plt.xlabel('Clump Thickness')
plt.ylabel('Ceil Size')
plt.show()
本地输出：具体本地输出请参照
作者：wyatt007
