1- Python 学习路径——入门篇

一. 语法和编码规范

Hello World

• python：

print("Hello World")

• C:

#include <stdio.h>
int main(){
	printf("Hello World");
	return 0;
}

• Java：

public class HelloWorld{
	public static void main(string[]args){
	System.out.println("Hello World");
	}}

引入工具

• 在 Python 脚本文件中引入工具包使用到的语句有：

import package
import package as pk
from xx import package

• 推荐使用：from os import getcwd as gt 这种导包格式

标识符

• 标识符：用来标识某个实体的一个符号，用于给变量、函数、语句块、对象等命名。

• Python 标识符命名规则：

  • 由字母、下划线和数字组成
  • 不能以数字开头
  • 不能和关键字重名

关键字

• Python 中已经定义好的，一些具有特殊功能的标识符。
• Python 中的关键字获取方式：

import keyword
keyword.kwlist

变量

• Python 中的变量是对数据存储地址的引用：

  • 数据在计算机上进行存储，会得到一个相应的存储地址
  • 给变量赋值，并不是将数据赋予变量，而是将变量指向了数据所在的存储地址。

• Python 的程序自上而下地执行，使用变量时需要先定义再使用。

• 变量的使用范围：

  • 局部变量：定义在函数内的变量，作用范围只能是函数内部范围内。
  • 全局变量：定义在函数和对象外部，作用范围是整个模块内。

注释

• 注释：对代码的解释和说明，其目的是让人们能够轻松地了解代码。在执行过程中，注释会被忽略。

• Python 中的注释：

  • 单行注释符：#
  • 多行注释使用：doc string ( ‘’‘…’‘’ , “”“…”“” )

规范

• PEP8 规范

  • 书写 Python 代码时的规范，并不是语法规则。
  • 提高代码的可读性和美观性。

• 常用的 PEP8 规范有：

  • 和语法相关的每一层缩进都用 4 个空格来表示
  • 函数和类的定义，代码前后都要用 2 个空行进行分隔
  • 二元运算符的左右两侧应该保留 1 个空格
  • 变量、函数和属性应该使用小写字母来拼写，多个单词使用下划线连接
  • 模块级别的常量，应该采用全大写字母，多个单词使用下划线连接

---

二. 基础函数

输出与输入

• print，用于输出

  • 打印传递的值
  • 可以通过 end 指定结尾符号（默认换行）

• input，用于接收用户输入

  • 接收键盘输入
  • 接收的数据统一为字符串（py3）

查看帮助信息

• help，查看对象的帮助信息

• dir，返回对象的属性和方法列表

• id，查看对象内存地址

• type，用于查看对象类型

  • type 还可以作为元类使用

---

三. Python 环境安装

参考链接： Python环境安装

---

四. 数值

数据和容器

• Python 中提供了六种内置的数据类型：

  • Number（数值）、String（字符串）、List（列表）、Tuple（元组）、Dictionary（字典）、Set（集合）

• 这些数据类型如同容器一般用于存放数据。

数据类型

• 这些数据类型不仅可以提高 Python 的运行效率，还极大地提高了开发效率。

• Python 中数据类型的分类：

  • 有序：可以使用下标（索引）访问元素
  • 无序：不可以使用下标（索引）访问元素
  • 可变：可以被修改
  • 不可变：不可以被修改

Number（数值）

• Python 3 中数值类型支持：

类型	值	范围
int	1,2	无穷
float	1.2,3.7 E-2	无穷
bool	True	[True, False]
complex	x+yj	x 是实数部分，y 是虚数部分

复数

• 复数由实数部分和虚数部分构成
  • 虚数不能单独存在，它们总是和一个值为 0.0 的实数部分一起构成一个复数。
  • 虚数部分必须有后缀 j 或 J。
  • 实数部分和虚数部分都是浮点数。

数值的计算

• 数值类型的基本操作：
  • 加（ + ）
  • 减（ - ）
  • 乘（ * ）
  • 除（ / ）
  • 取余/取整（%，//）
  • 乘方（ ** ）
  • 如果不同的类型的数字（如 int，float）进行运算，则结果类型为精度较高的那个类型。

计算函数

• Python 中内置了很多用于数值计算的函数。
  • 求绝对值：abs (x)
  • 四舍五入：round (x)
  • 返回两个数值的商和余数：divmod (y, x)
  • 求取最大值：max、min
  • 求和：sum

math 模块

• Python math 模块提供了许多对浮点数的数学运算函数。

  • 同时还提供了 cmath 模块，cmath 模块的函数跟 math 模块函数基本一致，区别是 cmath 模块运算的是复数，math 模块运算的是数学运算。

• math 模块常用方法：

  • 三角函数：sin、cos、tanh
  • 获取绝对值：fabs
  • 向上取整：ceil；向下取整：floor
  • 获取阶乘：factorial
  • x 的 y 次方：pow

---

五. 字符串

字符和字符串

• 字符指类字形单位或符号，包括字母、数字、运算符号、标点符号和其他符号，以及一些功能性符号。

• 字符串是编程语言中最常见的一种数据类型由字符组成，具有以下特征：

  • 有限的字符集合
  • 可以由汉字、数字、字母、符号组成
  • 一般有引号包裹

Python 中的 String（字符串）

• Python 中字符串是一个由多个字符组成的序列。

• Python 中没有字符。

• 字符的个数即为字符串的长度。 （可用 len 函数查看）

• 单个字符被认作长度为 1 的字符。

• Python 中的字符串是有序且不可变的。

创建一个字符串

• 在 Python 中声明一个字符串有 3 种方式：
  • 使用单引号 (‘…’) 创建
  • 使用双引号 (‘’…‘’) 创建
  • 使用三引号 (‘’‘…’‘’,“”“…”“”) 创建
  • 除了三种声明方式外，还可以通过类型转化的方式 str (obj)，生成字符串。

a = 'String'

b = "String"

c = '''
String
String
'''

• 使用单引号和双引号创建的字符串是一样的，不能换行
• 使用三引号创建的字符串可以是很长的字符串（可换行）

转义字符 - 特殊的字符串

• 在字符串中因为有一些字符因为本身具备一些功能，所以无法直接使用，如双引号和单引号。此时可以使用转义字符来实现这些符号的使用。

• 转义字符：\

  • 可以屏蔽符号原有的功能
  • 加入特殊字母可以使用特殊功能
  • 输出 \ ，可以使用 \\ 。

• 常见的转义字符

符号	作用
\n	换行
\t	水平制表 (HT)(跳到下一个 TAB 位置)
\	代表一个反斜线字符
\0	空字符 (NUL)
\v	垂直制表 (VT)

• 原始字符串：在字符串有一些 \ ，但是不希望进行转义可以使用原始字符串。
  • 字符串前面加 r 或者 R 实现。

字符串的运算

• +：拼接两个字符串

a = 'hello'
b = 'world'
a + b = 'helloworld'

• * ：字符串乘以一个数字可以得到重复次数的新的字符串

"a" * 2 => "aa"

索引与切片

索引

• 获取字符串中的字符元素：
  • 因为字符串是个有序序列，所以我们在访问字符串中的某些元素时可以根据元素对应的下标(索引)来访问: strln]。正向访问时下标从0开始，到字符串长度减1。逆向访问时从1开始，每次递减1。

Str = "python" => Str[O] => 'p'

切片

• 批量获取（切片）： str[a:b:c]，a 是起始元素的位置，b 是终止元素的位置，c 是步长。

  • abc 同样可以为负值
  • 当 a 为 0，b 为 n，c 为 1 时，可以省略不写
  • str[::] 表示取所有
  • str[::2] 表示每两个取一个

• 注意：

  • 切片时一定要根据起始和终止位置设置步长
    • 切片和索引可以用在 Python 中所有的有序序列中。

字符串的常用操作

操作	解释
分割	str.split(str1) 以为 str1为分隔符对字符串切割
替换	str.replace(str1,str2) 将字符串中的 str1替换为 str2生成新的字符串
大写	str.lower() 将字符串中的大写字符转化为大写
小写	str.upper() 将字符串中的大写字符转化为小写
拼接	str.join(iter) 将所给参数中的元素以指定的字符连接生成一个新的字符串
格式化输出	% 字符串转换类型和格式化操作符辅助指令实现格式化输出

字符串格式化输出

• 字符串格式转换类型表

格式	格式符描述
%c	字符及其 ASCII 码
%s	字符串
%d	有符号整数（十进制）
%u	无符号整数（十进制）
%o	无符号整数（八进制）
%x	无符号整数（十六进制）
%X	无符号整数（十六进制大写字符）
%e	浮点数字（科学计数法）
%E	浮点数字（科学计数法，用 E 代替 e）
%f	浮点数字（用小数点符号）

• 格式化操作辅助指令

符号	作用
*	定义宽度或者小数点精度
-	用作左对齐
+	在正数前面显示加号 (+)
<sp>	在正数前面显示空格
#	在八进制数前显示零(0)，在十六进制前显示0x 或者 0X
0	显示数字前面填充“0”而不是默认的空格。
(var)	映射变量(字典参数)
m.n	m 是显示的最小总宽度，n 是小数点后的信数

string 模块

• 在 Python 中，字符串本身内置了很多的操作方法和属性，除此以外 Python 还提供了一个字符串操作模块 string。
  • 在 Python3中 string 模快提供的方法，和字符串内置的方法相似度较高

---

六. 元组

Tuple（元组）

• 元组是一个有序且不可变序列，其中的元素可以是任意对象。

  • 元组可以使用索引和切片的方式取值。

• 元组中的数据一旦生成就无法更改。

元组的创建

• 元组存储的数据更加安全。

• 元组由一个小括号包裹，元素用逗号隔开。声明一个元组有三种方式：

  • Tuple = tuple((obj1,obj2,...))
  • Tuple = (obj1, obj2, ...)
  • Tuple = obj1,obj2,obj3

单元素元组

• 如果在声明元组时元组只有一个元素，需要在元素后面加上逗号告诉解释器这不是运算符号中的括号。
• 嵌套元组中也是如此。

元组的运算

• + ：拼接两个元组

• * ：元组乘以一个数字可以得到重复次数的新的元组

---

七. 列表

List（列表）

• 列表是一个有序可变的序列，其中的元素可以是任意对象。
  • 列表可以使用索引和切片的方式取值。
  • 列表可以随意的修改、删除和增加元素。
  • 相较于元组而言，列表的安全性差，但是灵活性高。
  • 列表支持的运算符同元组一样。

列表的创建方式

• 列表由一个中括号包裹住元素，元素用逗号隔开。创建列表的方式有：
  • List = list((obj1,obj2,...))
  • List = [obj1, obj2, ....]
  • 列表推导式

列表推导式

• 推导式是可以从一个数据序列构建另一个新的数据序列的结构体可以快速生成序列。

• 列表推导式

  • [i for i in range(5)]
  • [i for i in range(5) if i%2]
  • [(x,y) for x in range(5) if x%2==0 for y in range(5) if y%2==1]

列表常用操作

操作	解释
增加	list.append(obj) 将参数内的对象添加至列表的尾部 list.insert(index,obj) 将对象插入到列表的 index 位置 list.extend(iter) 将可选代对象的每个元素逐个插入列表的尾部
删除	list.pop([index]) 删除下标为 index 的元素，并将其返回 list.remove(obj) 删除列表中第一个出现的给定元素
查找	list.index(obj) 返回给定元素第一次出现位置的下标
排序	list.sort() 对列表进行排序，默认是升序
逆序	list.reverse() 将列表中的元素进行逆置
数量统计	list.count(obj) 返回给定元素出现的次数

列表与数组

• Python 中的列表在外观上和数组是有些相似的，但是两者并不是一种结构
  • Python 的内置数据结构中并没有数组，需要借助于工具包 numpy 实现
  • 列表可以和数组相互转化，但是本质是不一样的

---

八. 字典

Dictionary（字典）

• 字典的每个元素由两部分组成——键和值，所以字典的元素也被称为键值对。
  • 其中键是不可变且唯一的。
  • 如果字典有相同的键，则后面的键对应的值会将前面的值覆盖。
  • 数据量大时，字典数据的访问速度比列表快。
  • 字典是无序可变的序列。

创建字典

• 字典由一对花括号包裹，元素由逗号隔开。常见的字典创建方式：
  • `Dict = [key:value,]
  • Dict = dict(key=value,)
  • Dict = dict([(key,value),])
  • 字典推导式

字典的常用操作

操作	解释
获取	dict.get(key,default=None) 根据键获取值键不存在时返回默认值。 dict.items() 返回一个包含所有（键，值）元组的列表。 dict.keys() 返回一个所有键组成的列表。 dict.values() 返回一个所有值组成的列表。 dict[key] = value 增加键值对 {key: value}，若 key 已存在，则修改现有 key 的值。
添加	dict[key] = value 增加键值对 {key: value}，若 key 已存在，则修改现有 key 的值。
更新	dict.update(dict1) 使用 dict1对字典进行更新。
删除	dict.pop(key) 删除并返回 key 对应的值。 dict.popitem() 随机删除并返回一个键值对。 dict.clear() 清空字典

---

九. 集合

Set（集合）

• 集合中的元素是唯一的，重复的元素会被删除。

• 集合是由一个花括号包裹，内部元素以逗号隔开。声明一个集合的方式有：

  • Set = set()
  • Set = {obj1,obj2....}

集合的运算

• 逻辑运算：
  • 交集 set1 & set2：两个集合中相同的元素。
  • 对称差集 set1 ^ set2：两个集合中不同的元素。
  • 并集 set1 | set2：两个集合内总共的元素（重复的删除）。
  • 差集 set1 - set 2：集合一中包含而集合二中不包含的元素。

集合的常用操作

操作	解释
添加	set.add(obj) 添加元素，如果元素已存在，则不会进行任何操作。 set.update(obj) 添加对象可以是列表字典等，且可以是多个，用逗号隔开。
删除	set.remove(obj) 移除元素（移除不存在元素是，会抛出异常） set.discard(obj) 删除元素（元素不存在时不会抛出异常） set.clear() 清空集合 set.pop() 随机删除一个元素

集合妙用

• 当前有一个列表 ([1,2,3,1,2,1,4,5,2,5]) ，可以利用集合进行去重。
  • 即先将列表转为集合，然后再转为列表。

a = [1,2,3,1,2,1,4,5,2,5]
a = set(a)
a = list(a)
print (a)

[1, 2, 3, 4, 5]

---

十. 数据拷贝

数据引用产生的问题

问题一

L1 = [1,2,[3,4,5]]
L2 = L1
L2[0] = 6
print("L1:",L1)
print("L2:",L2)

L1: [6, 2, [3, 4, 5]]
L2: [6, 2, [3, 4, 5]]

• 在 Python 中变量名是对于数据的引用
  • L2 = L1 ，只是将 L2 指向了 L1 所指向的地址

问题二

L1 = [1,2,[3,4,5]]
L2 = L1.copy()
L2[2][0] = 6
print("L1:",L1)
print("L2:",L2)

L1: [1, 2, [6, 4, 5]]
L2: [1, 2, [6, 4, 5]]

数据拷贝

对于问题一

• 在 Python 中为了防止上述问题出现，可以使用拷贝的生成一份新的数据。

L1 = [1,2,[3,4,5]]
L2 = L1.copy()
L2[0] = 6
print("L1:",L1)
print("L2:",L2)

L1: [1, 2, [3, 4, 5]]
L2: [6, 2, [3, 4, 5]]

对于问题二

• 深拷贝和浅拷贝
  • 在 Python 中对于数据的拷贝可以根据拷贝形式的不同分为深拷贝和浅拷贝。
  • 浅拷贝 copy() 即对数据的表面结构进行拷贝，如果数据为嵌素是对之前数据的引用。修改之前套的结构，则嵌套结构里面的的数据会影响拷贝得到的数据。
  • 深拷贝，解决了嵌套结构中深层结构只是引用的问题，它会对所有的数据进行一次复制，修改之前的数据则不会改变拷贝得到的数据。
  • 实现深拷贝：导入 Python 中的 copy 模块，使用模块中的 deepcopy() 方法。

import copy

L1 = [1,2,[3,4,5]]
L2 = copy.deepcopy(L1)
L2[2][0] = 6
print("L1:",L1)
print("L2:",L2)

L1: [1, 2, [3, 4, 5]]
L2: [1, 2, [6, 4, 5]]

---

十一. 运算符

• Python 运算符大致可分为7种，即算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、成员运算符以及身份运算符。

比较运算符

• Python 提供了 6 种比较运算符

  • > （大于）
  • < （小于）
  • == （等于）
  • != （不等于）
  • >= （大于等于）
  • <= （小于等于）

• 比较运算的结果是一个布尔值，True 或者 False

赋值运算符

• Python 形成了丰富的赋值运算符：

  • = （ b = c ）
  • += （ b += c → b = b+c ）
  • -= （ b -= c → b = b-c ）
  • /= （ b /= c → b = b/c ）
  • %= （ b %= c → b = b%c ）
  • *= （ b *= c → b = b*c ）
  • //= （ b // c → b = b//c ）

• 多变量赋值：

  • a, b, c = 1,2,3
  • A = B = C =1

逻辑运算符

• Python 中 3 种逻辑运算符分别为

  • and (与)，or (或)，not(非)
  • 逻辑运算的结果是布尔值，True 或者 False

• A and B ：当 A 为 False 时，运算结果为 False，否则返回 B 的值

• A or B ：当 A 为 True 时，运算结 A 的值，否则返回 B 的值。

• not A ：当 A 为 True 时，返回否则返回 True。

位运算符

成员运算符

• Python 支持成员运算符。

• Python 中有如下数据结构：字符串列表、元组、字典。

• 字符串、列表、字典，它们就像一个集合，其中包含若干元素，这些元素就是集合的成员，对于一个给定的元素，它有可能在（ in ）一个给定的集合中，也可能不在（ not in ），Python 中采用成员运算符来判断元素是否属于成员，成员运算的结果为布尔值，True 或者 False。

身份运算符

• 身份运算符用于比较两个标识符所引用对象的存储单元，计算结果为布尔值，包含两个运算符：is 和 is not，分别用于判断两个标识符是否引用自一个对象。

• is 和 == 的区别：

  • is 用于判断两个变量引用对象是否为同一个
  • == 用于判断引用变量的值是否相等

---

十二. 数据结构基础

• 数据结构是软件开发中最基础的部分，也是较为重要的部分，常见的数据结构有：
  • 线性表
  • 数组
  • 链表
  • 队列
  • 树
  • 图
  • 堆、栈
  • 散列表

---

十三. 判断语句

程序中的如果…就…

• 在 Python 中实现如果使用的是关键字 if

• Python 中的条件控制是通过条件语句的执行结果（True 或者 False）来决定执行的代码块。

• Python 中的“对”和“错”

  • False：0、None、[]、()、{}、“”
  • Ture：除 False 以外的任意对象

如果…就…否则…

• 在 Python 中 if 判定条件外，还可以使用 else 表示其他情况下。

多分支判断（elif）

• Python 中使用 if 来控制程序的执行，如果有多个条件分支的判断可以使用 if -elif -else 的形式。

多条件判断

if h==green" and 
tem<=37.3:
	print("come in")

if h=="green" or test==True:
print("come in")

判断语句小技巧

• 使用隐式的判断条件。
• 将最可能出现的判断放在前面。
• 避免深层次的判断嵌套。
• 避免无意义的判断。

---

十四. 循环语句

复读机

• 对于需要重复执行的任务，判断语句不适合使用，取而代之的是循环语句。
  • 循环语句可以根据设置的循环次数，来执行相同的代码块。
  • 设置循环次数同样需要判断条件。
  • Python 中的循环语句分为 for 循环和 while 循环。

循环语句 - for

• Python 中的 for 语句与其他语言中的 for 语句不太一样，它接受可迭代对象（例如序列）作为其参数，每次迭代其中的一个元素。

• 可以在 for 循环后面加入 else 语句块，在循环结束时执行。

循环语句 - while

• Python 语言中 while 语句用于执行循环程序，在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。

• 可以在 while 后面加入 else 语句块，在条件为假时执行

跳过/跳出循环

• 在 Python 中使用 continue 实现本次循环的跳过

  • continue 语句用来告诉 Python 跳过当前循环的剩余语句，然后继续进行下轮循环。
  • continue 语句可用在 while 和 for 循环中。

• Python 中使用 break 来结束整个循环。

  • break 语句结束整个循环。如果触发了 break，则当前循环终止（循环对应的 else 也不会执行）

嵌套循环

for i in range(1, 13):
    for j in range(1, 1 + i):
        print("%d × %d = %s" % (j, i, i * j))

死循环与空循环

• 空循环，即在循环任务中循环体是空的，不执行任何任务。
  • 会导致系统 CPU 占用了高
  • 浪费计算资源

递归

• 递归，程序调用自身的编程技巧称为递归，它通常把一个大型的复杂的问题转化为一个与原问题相似的规模较小的问题来解决。