小猪的Python学习之旅 —— 1.基础知识储备

引言：(文章比较长，建议看目录按需学习～)

      以前刚学编程的时候就对Python略有耳闻，不过学校只有C，C++，Java，C#。
和PHP有句"PHP是最好的语言" 这种家喻户晓的骚话一样，Python也有
"人生苦短，我用Python"。而接触Python这个词最多的场合就是在一些技术群里，
有些大佬张嘴动不动就说什么Py交易，作为潜伏在群里的开发萌新的我每次都
会忍不住会发出这样的感慨：

而真正接触了下Python是在上家公司，当时老大让我写个脚本去下载
仓库里最近打包的apk，当时东凑凑西凑凑最后总算拼成了一个可运行
的py文件，因为不了解Python里的数据结构，全部用的字符串变量，
后面被老大教育了一番才知道有元组这种东西。因为本身做Android的，
Python用到的场合不多，加之觉得Kotlin有点意思，就没去研究Python了。

前段时间，手头的事做得差不多了，无聊四处张望时，看到隔壁后台
小哥迅雷疯狂下载东西，建文件夹，粘贴复制，不知道还以为他在给
小电影分类呢，后来一问才知道，运营让他把服务器上所有的音频
文件下下来，然后根据对应的类别下到对应文件夹，所以他做的事情
就是：迅雷批量下载过歌曲 -> 看mysql歌曲的分组 -> 建文件夹
-> 粘贴复制歌曲到这个文件夹下，咋一看，流程挺简单的，然而有
4700多首歌，几百个目录，这样慢慢搞怕是要搞几天，而且常时间
机械化的重复某项工作，很容易出错。看着一脸绝望的后台小哥：

于心不忍，决定写个py脚本来拯救他，脑子里也有了程序的大概逻辑:

• 1.让后台导出一份mysql建表语句，安装mysql把表建起来；
• 2.Python连mysql，读取表里的数据
• 3.编写带limit去重的sql查询语句，查询得到所有分类
• 4.得到的所有分类就是要创建的文件夹，迭代批量创建文件夹；
• 5.sql查询歌曲下载url与分类，拼接，写入到文件中；
• 6.读取文件，迭代：下载url截取文件名与分类路径拼接成文件
  的完整路径，调用下载相关函数下载url到对应路径即可。

逻辑挺简单明了的，然而各种坑，最后折腾了一天才能弄出来
遇到了下面这些问题：

• 1.最坑的解码问题：默认使用Python2，中文乱码，各种网上搜，
  设置编码方式，都没用，头皮发麻，特别是在截取文件名的时候。
  后面换了一波Python3，很舒服，什么问题都没了。
• 2.没有对异常进行捕获，有些资源失效404，下到中途才发现.;
• 3.想弄多线程下载的，因为Python很多基础不知道，后面放弃了;

当看到所有文件都下载到了对应的位置，一种油然而生的成就感，
比起写APP天天画界面，请求，解析数据，显示数据，有意思太多，
毕竟学习开发兴趣很重要，索性从零开始学习下Python吧，越学越觉得：

理由上班时的闲暇时间，历时两周总算是把基础知识的东西过了
一遍，遂有此文，毕竟初学者，有些地方可能理解有误，望看到
的大佬不吝赐教，文中大部分内容摘自：
《Python 3 教程》与《小甲鱼的零基础入门学习Python》
有兴趣的可以阅读下这两本书~
本文不是入门教程啊，完全没有编程经验的不建议阅读！
完全小白可以看下这本：《编程小白的第一本Python入门书》

[TOC]

• 官网：http://www.python.org/
• API：https://docs.python.org/release/3.6.3/
• 中文API(3.5.2)：http://python.usyiyi.cn/translate/python_352/index.html
• awesome-python：https://github.com/vinta/awesome-python
• awesome-python(翻译)：https://github.com/jobbole/awesome-python-cn

• 《Python 3 教程》：http://www.runoob.com/python3/python3-tutorial.html
• 《老齐零基础学Python》：https://www.gitbook.com/book/looly/python-basic/details
• 《小甲鱼的零基础入门学习Python》：很不错的一本入门书籍，我就是看这本~
• 《Python核心编程（第3版）》：也是挺有名的一本书，还没看~

！！！Python 3的语法 不完全兼容 Python 2的语法！！！

菜逼刚学Python没多久，不敢大声哔哔，最直接原因：
Python 3默认使用utf-8，在处理中文的时候可以
减少很多编解码的问题，而Python 2默认使用ascii。

另外的原因：与时俱进，IT行业发展那么迅速，完全过渡只是时间问题；
举个例子：Android Studio刚出的没多久的时候，各种说卡啊，垃圾，
只能开一个项目等各种嫌弃，不如Eclipse好用；然而现在开发Android
还是用Eclipse的都是会被歧视一波的，另外官方已经确定Python 2.7会
在2020年退休。So：人生苦短，我用Python3。

而且Python 2.7预计会在2020年退休

更多比较的文章可见：

Python2.x与3​​.x版本区别
Python2orPython3
Python3.x和Python2.x的区别

官网下载：https://www.python.org/downloads/，
自己选择需要的版本与操作系统。

• Windows

傻瓜式下一步就好，记得勾选Add Python x.x to Path！勾选
了你装完就不用自己去配置环境变量，安装完毕后打开CMD输入：
python3 -V 能查看到安装的Python版本说明安装成功，
如果提示错误：python3不是内部或外部命令之类的话，恭喜你
可以百度下：Python3环境变量配置 了~

• Mac

方法一：官网下安装包，傻瓜下一步；
方法二：如果有装Homebrew，终端输入：brew install Python3 安装即可。

• Ubuntu：一般内置，执行下述命令可查看版本，如果想安装自己喜欢
  的版本可以键入：sudo apt-get install python版本号 进行安装

其实在安装完Python后就可以进行Python编程了，直接命令行输入python3，
就可以使用自带的IDLE进行开发了；又或者直接用Sublime Text或NotePad++
这类代码查看工具直接编写代码，然后保存成后缀为.py的文件，然后python3
执行这个py文件就可以了。

虽然可以，但是挺不方便的，比如缩进问题，Python通过缩进来表示代码块，
代码一多，某一行没有正确的使用缩进，结果可能与你预期的相差甚远。
智能提示，方便的依赖库管理等，这两个就不用说了吧，具体的还得你自己体会。

官网下载：https://www.jetbrains.com/pycharm/download/
下载Professional版本，傻瓜式安装，打开后会弹出注册页面，
勾选License server，在License server address输入注册服务器，
网上搜很多，然后就可以愉快的进行py开发了。

软件的基本使用也非常简单，Jetbrains的IDE都是差不多的~
有一点要注意的地方是，如果你想切换项目依赖的Python版本号的话：
打开设置(Preference或settings)，修改即可：

有时项目中需要引入其他模块或者模块中的某个函数，需要用到import和
from...import，用法示例如下：

import sys  # 导入整个模块
from sys import argv   # 导入模块中的需要用到的部分
from urllib.error import URLError, HTTPError # 多个的时候可以用逗号隔开
from sys import *  # 导出模块中的所有
# 另外还可以使用as关键字为模块设置别名，比如 import sys as s
# 调用的时候直接s.argv 这样就可以了。

'''
这是
Python的
多行注释
'''

a = b = c = 1
a,b,c = 1,2,"Python"

list1 = [1,2.0,"a",True]  # 定义列表
print(list1[1])    # 通过[下标]访问元素，从0开始，结果输出：2.0
print(list1[1:3])  # 支持截取，比如这里的[1:3]，结果输出：[2.0, 'a']
print(list1[1:3:2])# 还可以有第三个参数，步长，默认为1，结果输出:[2.0]
print(list1[2:])   # 输出结果：['a', True]
print(list1[-2])   # 负数的话从后面开始访问，结果输出：a
print(list1.index("a"))   # 返回参数在列表中的位置，结果输出：2    

# 修改列表元素
list1[1] = 3.0     # 直接获得元素后进行修改，此时列表元素：[1, 3.0, 'a', True]

# 添加元素
list1.append('Jay')# 追加一个元素，此时列表元素：[1, 2.0, 'a', True, 'Jay']
list1.insert(2,'pig')     # 插入一个元素，此时列表元素：[1, 2.0, 'pig', 'a', True]
print(list1.pop()) # 移除最后一个元素，并返回元素的值，结果输出：True  

# 删除元素
del list1[0]# 删除索引位置的值，此时列表元素：[2.0, 'a', True]
list1.remove('a')  # 删除指定的元素值，此时列表元素：[1, 2.0, True]

# 其他(使用+号可以组合列表，*号可以重复列表)
print(list1+list1) # 输出结果：[1, 2.0, 'a', True, 1, 2.0, 'a', True]
print(list1*2)     # 输出结果：[1, 2.0, 'a', True, 1, 2.0, 'a', True]
print('a' in list1)# 判断列表中是否有此元素，输出结果：True
print('b' not in list1)   # 判断原始中是不是没有这个元素，输出结果：True
for x in list:     # 迭代遍历列表
print(len(list1))  # 获得列表长度，结果输出：4
print(list1.count(1))     # 统计某个元素在列表中出现的次数，结果输出：2，因为True的值也是1
max(list1)  # 获得列表中的元素最大值，列表元素类型需要为数字
min(list1)  # 获得列表中的元素最小值，列表元素类型需要为数字
list1.sort()# 对原列表元素进行排序，本地排序(会修改值)，返回None，
     # 只能比较数字！默认从小到大，从大到小可以用可选参数，括号里加上：
     # key = lambda x:-1*x

list1.reverse()    # 反转列表元素，会修改列表，返回None
list2 = list1.copy()      # 拷贝列表，重新开辟了内存空间！和等号赋值不一样！
list(tuple) # 将元组或字符串转换为列表

dict1 = {}     # 定义一个空字典
dict2 = {'a': 1, 'b': 2, 3: "c"}    # 定义一个普通字典
dict4 = dict2.copy()  # 浅复制一个字典

# 可以使用fromkeys创建并返回新的字典，有两个参数，键和键对应的值
# 值可以不提供，默认None，不过有个小细节要注意，下面的例子输出
# 的结果是：{1: ['a', 'b', 'c'], 2: ['a', 'b', 'c'], 3: ['a', 'b', 'c']}
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
dict3 = {}
dict3 = dict3.fromkeys(list1, list2)
print(dict3)

# 通过键查询对应的值，如果没有这个键会报错TypeError，这里输出结果：2
print(dict2['b'])    
print(dict2.get("d")) # 通过get()方法查询键对应的值，没有的话会返回None
 # 还可以加上一个默认的返回参数get(x,y)
print(dict2.setdefault("d")) # 和get()类似，如果找不到键的话会自动添加 键:None
print("d" in dict2)   # 字典中是否有此键，这里输出结果：False
print("d" not in dict2)      # 字典中是否没有此键，这里输出结果：True

print(dict2.keys())   # 返回字典中所有的键，这里输出结果：dict_keys(['a', 3, 'b'])
print(dict2.values()) # 返回字典中所有的值，这里输出结果：dict_values([1, 'c', 2])
print(dict2.items())  # 返回字典中所有的键值对，这里输出结果：
 # dict_items([('a', 1), (3, 'c'), ('b', 2)])

# 修改键对应的值，此时字典元素：{3: 'c', 'a': 1, 'b': 'HaHa'}
dict2['b'] = 'HaHa' 
dict2.update(b:'Pig') # 使用update方法可以更新键对应的值，不过键需要为字符串！

# 删除字典元素
del(dict2['b'])# 删除某个键值对，此时字典元素：{3: 'c', 'a': 1}
dict2.clear()  # 移除字典中所有的键值对，此时剩下空字典：{}
del dict2      # 删除整个字典，删除后无法再重复引用！！！
print(dict2.pop('a')) # 根据键删除对应的值，返回被删除的值。
print(dict2.popitem())# 删除一个项，随机，比如：('b', 2)

# 遍历字典：
for d in dict2:
    print("%s:%s" % (d, dict2.get(d)))

for (k,v) in dict2.items():
    print("%s:%s" % (k, v))

set1 = set()  # 创建空集合
set2 = {1, 2, 3, 4, 5, 1}  # 普通方式创建集合
print(set2)  # 重复元素会被自动删除，输出结果：{1, 2, 3, 4, 5}

set3 = set('12345')  # 字符串
print(set3)  # 输出：{'2', '5', '3', '4', '1'}，集合元素无序

print(6 in set2)  # 判断集合中是否有此元素：输出结果：False
print(6 not in set2)  # 判断集合中是否有此元素：输出结果：True

set2.add("6")  # 添加元素
print(set2)  # 输出结果：{1, 2, 3, 4, 5, '6'}

set2.remove(2)  # 删除元素，如果删除的元素不存在会报错
print(set2)  # 输出结果：{1, 3, 4, 5, '6'}

# 遍历集合，输出结果： 1  3   4   5   6
for data in set2:
    print(data, end="t")

# 使用frozenset()函数定义不可变集合
set4 = frozenset({1, 2, 3, 4, 5})

str1 = "Hello Python"
print(str1[3])    # 输出结果：l
print(str1[2:])   # 输出结果：llo Python
print(str1[2:5])  # 输出结果：llo
print(str1[2:10:2])      # 输出结果：loPt
print(str1[0:8] + str1[8:])     # 输出结果：Hello Python
str2 = str1[6:] * 3
print(str2)# 输出结果：PythonPythonPython

# 位置参数
str1 = "{0}生{1}，{2}{3}！".format("人","苦短","我用","Python")
print(str1) # 输出结果：人生苦短，我用Python！

# 关键字参数
str1 = "{a}生{c}，{b}{d}！".format(a = "人", c = "苦短",b = "我用",d = "Python")
print(str1) # 输出结果：人生苦短，我用Python！

# 位置参数可以与关键字参数一起使用，不过位置参数需要在关键字参数前，否则会报错！

# 另外还有个叫替换域的东西，冒号代表格式化符号开始，比如下面的例子：
str1 = "{0}:{1:.4}".format("圆周率", 3.1415926)
print(str1) # 输出结果：圆周率:3.142

print("3 + 7 = %d" % (3 + 7))   # 输出结果： 3 + 7 = 10
print("3 - 7 = %d" % (3 - 7))   # 输出结果： 3 - 7 = -4
print("3 * 7 = %d" % (3 * 7))   # 输出结果： 3 * 7 = 21
print("7 / 3 = %f" % (7 / 3))   # 输出结果： 7 / 3 = 2.333333
print("7 %% 3 = %d" % (7 % 3))  # 输出结果： 7 % 3 = 1
print("3 ** 6 = %d" % (7 ** 3)) # 输出结果： 3 ** 6 = 343
print("3 // 6 = %f" % (7 // 3)) # 输出结果： 3 // 6 = 2.000000

import time, datetime

# 获取当前时间
moment = time.localtime()   
print("年：%s" % moment[0])
print("月：%s" % moment[1])
print("日：%s" % moment[2])
print("时：%s" % moment[3])
print("分：%s" % moment[4])
print("秒：%s" % (moment[5] + 1))
print("周几：%s" % (moment[6] + 1))
print("一年第几天：%s" % moment[7])
print("是否为夏令时：%s" % moment[8]) 

# 格式化时间(这里要注意strftime和strptime是不一样的！！！)
moment1 = time.strftime('%Y-%m-%d %H:%M:%S')
moment2 = time.strftime('%a %b %d %H:%M:%S %Y', time.localtime())
moment3 = time.mktime(time.strptime(moment2, '%a %b %d %H:%M:%S %Y'))
print(moment1)  # 输出结果：2017-12-02 11:08:02
print(moment2)  # 输出结果：Sat Dec 02 11:08:02 2017
print(moment3)  # 输出结果：1512184082.0   日期转换为时间戳

# 获得当前时间戳
print(time.time())  # 输出结果：1512185208.0942981

# 获得当前时间(时间数组，还需strftime格式化下)
print(datetime.datetime.now())  # 输出结果：2017-12-02 11:34:44.726843

# 时间戳转换为时间
# 方法一：(输出结果：2017-12-02 11:08:02)
moment4 = 1512184082
moment5 = time.localtime(moment4)  # 转换成时间数组
print(time.strftime('%Y-%m-%d %H:%M:%S', moment5))  # 格式化
# 方法二：
moment6 = datetime.datetime.utcfromtimestamp(moment4)
print(moment6)  # 直接输出：2017-12-02 03:08:02
moment7 = moment6.strftime('%a %b %d %H:%M:%S %Y')
print(moment7)  # 格式化后输出：Sat Dec 02 03:08:02 2017

# 延迟执行
time.sleep(秒)

def func(n):
    a, b = 0, 1
    while n > 0:
 n -= 1
 yield b
 a, b = b, a + b

for i in func(10):
    print(i, end="t")

# 输出结果：1 1 2 3 5 8 13 21 34 55 

big = lambda x, y: x > y
print("第一个参数比第二个参数大：%s" % big(1, 2))
# 输出结果：第一个参数比第二个参数大：False

def sum(n):
    if n == 1:
 return 1
    else:
 return n + sum(n - 1)

print("1到100的求和结果是: %d" % sum(100))

# 输出结果：1到100的求和结果是: 5050

# 1.最简单的，try捕获了任何异常，直接丢给except后的代码块处理：
try:
    result = 1 / 0
except:
    print("捕获到异常了!")  # 输出：捕获到异常了!

# 2.捕获特定类型：
try:
    result = 1 / 0
except ZeroDivisionError:
    print("捕获到除数为零的错误")   # 输出：捕获到除数为零的错误

# 3.针对不同的异常设置多个except
try:
    sum = 1 + '2'
    result = 1 / 0
except TypeError as reason:
    print("类型出错：" + str(reason))
except ZeroDivisionError as reason:
    print("除数为0：" + str(reason))    
# 输出：类型出错：unsupported operand type(s) for +: 'int' and 'str'

# 4.对多个异常统一处理
try:
    result = 1 / 0
    sum = 1 + '2'
except (TypeError, ZeroDivisionError) as reason:
    print(str(reason))  # 输出：division by zero

# 5.当没有检测到异常时才执行的代码块，可以用else
try:
    result = 4 / 2
except ZeroDivisionError as reason:
    print(str(reason))
else:
    print("没有发生异常，输出结果：%d" % result)
# 输出：没有发生异常，输出结果：2

# 6.无论是否发生异常都会执行的一段代码块，比如io流关闭，
# 可以使用finally子句，如果发生异常先走except子句，后走finally子句。
try:
    result = 4 / 2
except ZeroDivisionError as reason:
    print(str(reason))
else:
    print("没有发生异常，输出结果：%d" % result)
finally:
    print("无论是否发生异常都会执行～")
# 输出结果：
# 没有发生异常，输出结果：2
# 无论是否发生异常都会执行～

try:
    with open('123.txt', "w") as f:
 for line in f:
     print(line)
except OSError as reason:
    print("发生异常：" + str(reason))

# 输出结果：发生异常：not readable

# 输出结果依次是：异常类，类示例，跟踪记录对象
try:
    result = 1 / 0
except:
    import sys
    tuple_exception = sys.exc_info()

for i in tuple_exception:
    print(i)

# 输出结果：
# 
# division by zero
# 

# 读取123.txt文件里的内容打印，同时写入到321.txt中
try:
    f1 = open("321.txt", "w")
    with open("123.txt", "r") as f2:
 for line in f2:
     print(line, end="")
     f1.write(line)

except OSError as reason:
    print("发生异常" + str(reason))
finally:
    f1.close()  # 用完要关闭文件，f2不用是因为用了with

if __name__ == '__main__':
    test()

pip install 库名  # 安装
python3 -m pip install 库名     # 作用同上，可以区分python2和python3而已
pip install --upgrade pip      # 更新pip
pip uninstall 库名      # 卸载库
pip list # 查看已安装库列表

pipreqs 导出到哪个目录

pip install -r requirements.txt

pip freeze > requirements.txt