一天速成Python教程

木马蛋糕 發表於 2020-3-1 11:06:00

<h4 id="一python基础">一、Python基础</h4>
Python是对象有类型，变量无类型的动态类型语言，追求简单优雅易读。可以在终端中逐行运行，也可以编写成大型的面向对象的工程。在开始写之前，注意Python 2.X中，开头要写上<code>#coding:utf-8</code>，并且Python通过缩进知道一个特定的代码块于周围的代码保持独立。所用的空格数很重要，因此应该使用编辑器确定缩进，并且不要手动改变空格数。根据PEP的规定，必须使用4个空格来表示每级缩排。使用Tab字符和其它数目的空格虽然都可以编译通过，但不符合编码规范。
<h5 id="1数字和字符">1.数字和字符</h5>
<ol>
<li>Python本身支持整数与浮点数，计算如下表</li>
</ol>
<table>
<thead>
<tr>
<th>运算符</th>
<th>描述</th>
<th>示例</th>
<th>运算结果</th>
</tr>
</thead>
<tbody>
<tr>
<td>+</td>
<td>加</td>
<td>7 + 2</td>
<td>9</td>
</tr>
<tr>
<td>-</td>
<td>减</td>
<td>7 - 2</td>
<td>5</td>
</tr>
<tr>
<td>*</td>
<td>乘</td>
<td>7 * 2</td>
<td>14</td>
</tr>
<tr>
<td>/</td>
<td>浮点数除法</td>
<td>7 / 2</td>
<td>3.5</td>
</tr>
<tr>
<td>//</td>
<td>整数除法</td>
<td>7 // 2</td>
<td>3</td>
</tr>
<tr>
<td>%</td>
<td>求余</td>
<td>7 % 2</td>
<td>1</td>
</tr>
<tr>
<td>**</td>
<td>幂</td>
<td>7 ** 2</td>
<td>49</td>
</tr>
</tbody>
</table>
强制类型转换使用<code>int(num)</code>与<code>float(num)</code>进行。
<ol start="2">
<li>字符串</li>
</ol>
使用引号包裹，例如：
<pre><code class="language-python">>>> 'python'
'python'
>>> "python"
'python'
</code></pre>
可见可以使用两种引号进行创建，这样的好处是可以创建本身就包含引号的字符串，而不用使用转义符。可以在双引号包裹的字符串使用单引号，或者在单引号包裹的字符串中使用双引号：
<pre><code class="language-python">>>> "'She' is a boy."
"'She' is a boy."
>>> 'A "boy" likes her.'
'A "boy" likes her.'
</code></pre>
还可以使用三个单引号创建字符串：
<pre><code class="language-python">>>> '''
... 我们去看烟火好吗
... 去，去看那
... 繁花之中如何再生繁花
... 梦境之上如何再现梦境
... '''
'\n我们去看烟火好吗\n去，去看那\n繁花之中如何再生繁花\n梦境之上如何再现梦境\n'
</code></pre>
<ul>
<li>
在字符串中使用<code>str(value)</code>进行强制类型转换。
</li>
<li>
使用<code>\</code>进行转义
</li>
</ul>
<pre><code class="language-python">>>> print('a\tbc')
a bc
</code></pre>
<ul>
<li>使用<code>+</code>进行拼接</li>
</ul>
<pre><code class="language-python">>>> a = 'apple'
>>> b = 'pen'
>>> a + ' ' + b
'apple pen'
</code></pre>
<ul>
<li>使用<code>*</code>复制</li>
</ul>
<pre><code class="language-python">>>> s = 'apple'
>>> s * 3
'appleappleapple'
</code></pre>
<ul>
<li>使用<code>[]</code>提取字符</li>
</ul>
<pre><code class="language-python">>>> letters = 'abcdefg'
>>> letters
'a'
>>> letters
'e'
</code></pre>
<ul>
<li>使用<code></code>分片</li>
</ul>
<pre><code class="language-python"># [:] 提取全部
# 从start到结尾
# [:end] 从开头到end - 1
# 从strat到end - 1
# 从start到end - 1，每step个字符提取一个
>>> letters = 'abcdefghijklmn'
>>> letters[:]
'abcdefghijklmn'
>>> letters
'defghijklmn'
>>> letters[:3]
'abc'
>>> letters
'defg'
>>> letters
'ac'
>>> letters[-1::]
'n'
>>> letters[::-1]
'nmlkjihgfedcba'
</code></pre>
<ul>
<li>使用<code>len(value)</code>获得长度</li>
</ul>
<pre><code class="language-python">>>> letters = 'abcdefghijklmn'
>>> len(letters)
14
</code></pre>
<ul>
<li>使用<code>split(value)</code>进行分割，value填写分割字符，返回一个列表</li>
</ul>
<pre><code class="language-python">>>> letters = 'a,b,c,d,e,f'
>>> letters.split(',')
['a', 'b', 'c', 'd', 'e', 'f']
</code></pre>
<ul>
<li>同样可以使用<code>join()</code>将列表进行合并成字符串</li>
</ul>
<pre><code class="language-python">>>> letters_list = letters.split(',')
>>> ','.join(letters_list)
'a,b,c,d,e,f'
</code></pre>
<ul>
<li>最后，可以使用`replace(sub, newsub, n), sub是需要被替换的子串，newsub是用于替换的新子串,n是需要替换多少处</li>
</ul>
<pre><code class="language-python">>>> setup = 'a boy likes playing basketball.'
>>> setup.replace('boy','girl')
'a girl likes playing basketball.'
>>> setup.replace('a', 'b')
'b boy likes plbying bbsketbbll.'
>>> setup.replace('a', 'b', 1)
'b boy likes playing basketball.'
</code></pre>
<h5 id="2语句">2.语句</h5>
1.import语句，导入模块使用，两种形式：
形式1：import module-name。import后面跟空格，然后是模块名称，例如：import os
形式2：from module1 import module11。module1是一个大模块，里面还有子模块module11，只想用module11，就这么写了。
2.条件语句：
if...elif...else语句
<pre><code class="language-python">if 条件1:
执行的内容1
elif 条件2:
执行的内容2
elif 条件3：
执行的内容3
else:
执行的内容4
</code></pre>
3.循环语句：
for语句
<pre><code class="language-python">for 循环规则：
操作语句
</code></pre>
for循环所应用的对象，应该是可迭代的。
判断一个对象是否可迭代使用collections模块的Iterable类型判断：
<pre><code class="language-python">>>> from collections import Iterable
>>> isinstance('abc',Iterable)
True
>>> isinstance(,Iterable)
True
>>> isinstance(1234,Iterable)
False
</code></pre>
while语句
和C语言中大同小异，只不过可以使用while...else...,同理，在for语句中也可以使用for... else...
<pre><code class="language-python">#test.py
a = 3
b = 2
while a > b:
print('a>b')
a -= 1
else:
print('a<b')
</code></pre>
<pre><code class="language-shell">$ python test.py
a>b
a</pre>
<blockquote>
循环（loop），指的是在满足条件的情况下，重复执行同一段代码。比如，while语句。
迭代（iterate），指的是按照某种顺序逐个访问列表中的每一项。比如，for语句。
递归（recursion），指的是一个函数不断调用自身的行为。比如，以编程方式输出著名的斐波纳契数列。
遍历（traversal），指的是按照一定的规则访问树形结构中的每个节点，而且每个节点都只访问一次。
</blockquote>
<h5 id="3函数">3.函数</h5>
1.定义函数
使用<code>def:</code>函数的开头，define的缩写，后面跟函数名称和参数，最后一点要加“：”冒号。例如 <code>def add(x,y):</code>
2.函式体的第一个语句可以是字串（即为注释）; 这个字串就是函式的文档字符串, 或称为 docstring。例如：
<pre><code class="language-python">def split_data_set(dataSet, axis, value):
"""
输入：数据集，选择维度，选择值
输出：划分数据集
描述：按照给定特征划分数据集；去除选择维度中等于选择值的项
"""
</code></pre>
3.命名规范，这里参考PEP8
<blockquote>
b（单个小写字母）
B（单个大写字母）
小写（小写）
lower_case_with_underscores（含底线的小写）
大写（UPPERCASE）
UPPER_CASE_WITH_UNDERSCORES（含底线的大写）
大写字母（字首大写，又称CapWords或CamelCase - 如此称呼是因为字母看起来崎岖不平），有时也称为StudlyCaps。
注意：如果有缩写字，将缩写字的每个字母大写。也就是写HTTPServerError比HttpServerError好。
mixedCase（类似字首大写，只差开头单字的第一个字母是小写）
Capitalized_Words_With_Underscores（字首大写加底线）
来自命名惯例
</blockquote>
4.参数与变量
形参与实参：
函数名后面的括号里如果有变量，它们通常被称为“形参”。调用函数的时候，给函数提供的值叫做“实参”，或者“参数”。个人理解，实参是在函数调用前就实际存在的参数，而形参是在调用函数的时候，用于将实参的值传入函数用的。
参数与变量的区别，每个形参的名称均可作为过程内的局部变量。形参名称的使用方法与其他任何变量的使用方法相同。 
实参表示在您调用过程时传递给过程形参的值。
局部变量与全局变量：
在函数里面的就是局部变量，在函数外面的就是全局变量。在C和JAVA中主要是有一个主函数或主方法开始运行的地方，而Python并没有，Python是逐行运行的。但可以使用<code>if __name__ == '__main__'</code>来规定当前程序的程序入口是什么，防止模块之间相互引用导致入口混乱。
<h5 id="4初级内建函数">4.初级内建函数</h5>
1.<code>print(value, seq=' ', end='\n')</code> 在Python 3.X中，为一个函数，其中参数<code>seq=' '</code>为分隔符，参数<code>end='\n'</code>为结尾换行符号，可以自己修改。
<blockquote>
Tips:
print实质是将输出重定向到sys.stdout.write标准输出，可以修改参数file，指定输出到文件。
print()是同步阻塞的，所以频繁的print会大大降低程序运行速度，比如在训练模型时注意减少print的次数。
</blockquote>
2.<code>id(obj)</code>查看对象内存地址。
3.<code>type(obj)</code>查看对象的类型。
4.<code>round(value, n)</code>四舍五入到小数点后n位。
5.<code>a = input(msg)</code>打印出msg，并从键盘输入一个变量赋值给a，a为str类型。
6.<code>dir(module)</code>查看module模块的工具（方法）。
7.<code>help(math.pow)</code>查看math工具下pow工具的帮助，按q返回交互模式。
使用例子：
<pre><code class="language-python"># -*- coding:utf-8 -*-

import sys
import math
import time

integer_1 = 1
float_2 = 2.35
string = 'abc'

print(id(integer_1)) #查看内存地址
print(type(integer_1), type(float_2), type(string), sep='|') #查看类型，并用|分割
print(round(float_2)) #四舍五入
print(dir(math)) #查看math下的方法

input_test = input("请输入")
print(input_test, type(input_test)) #输入测试，并打印类型

help(math.pow)
</code></pre>
输出：
<pre><code class="language-shell">94520588557952
<class 'int'>|<class 'float'>|<class 'str'>
2
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
请输入3
3 <class 'str'>

Help on built-in function pow in module math:

pow(...)
pow(x, y)

Return x**y (x to the power of y).
(END)
</code></pre>
<h4 id="二python容器列表元组字典与集合">二、Python容器：列表、元组、字典与集合</h4>
<h5 id="1列表">1.列表</h5>
1.使用<code>[]</code>或<code>list()</code>来创建列表
<pre><code class="language-python">>>> #使用[]创建

>>> list(12345) #不可迭代报错
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>> list('1,2,3,4,5') #按照字符分割
['1', ',', '2', ',', '3', ',', '4', ',', '5']
>>> list('12345')
['1', '2', '3', '4', '5']
</code></pre>
如果使用<code>list()</code>是不允许将不可迭代的转换成列表，如果是可迭代的，例如字符串，则会按照字符分割成列表。
2.使用<code></code>选取元素，并修改。
<pre><code class="language-python">>>> l =
>>> l #选取
1
>>> l = 2 #修改
>>> l

>>> matrix = [, #创建三阶行列式
... ,
... ]
>>> matrix
[, , ]
>>> matrix #和矩阵写法一样，行优先，只不过从0开始
1
</code></pre>
list类似于数组，但数组只有一个类型，而list里面可以包含多个类型。列表的一个重要特征：列表是可以修改的。这种修改，不是复制一个新的，而是在原地进行修改。
3.使用<code>append()</code>与<code>extend()</code>扩充列表
列表扩容的函数append()和extend()都是原地修改列表,所以没有返回值，所以不能赋给某个变量。
<pre><code class="language-python">>>> lst1 =
>>> lst1.append(["lyx","xyl"])
>>> lst1
]#append的结果
>>> len(lst1)
4

>>> lst2 =
>>> lst2.extend(["lyx","xyl"])
>>> lst2
#extend的结果
>>> len(lst2)
5
</code></pre>
总结以下就是append是整建制地追加，extend是个体化扩编。
4.使用<code>insert()</code>插入，使用<code>del</code>,<code>remove()</code>与<code>pop()</code>删除
<pre><code class="language-python">>>> lst =
>>> lst.insert(0,0)
>>> lst

>>> lst.insert(3,3.5)
>>> lst

>>> lst.insert(10,5)
>>> lst

</code></pre>
使用<code>insert(offset,value)</code>,当offset为0时则插入到头部，当offset超过了尾部，则会插入到最后，并不会引起异常。
<pre><code class="language-python">>>> lst =
>>> del lst
>>> lst

>>> lst.remove(3)
>>> lst

>>> lst.pop()
5
>>> lst

</code></pre>
使用<code>del</code>则是删除指定位置的元素，使用<code>remove()</code>则是删除指定值的数，使用<code>pop()</code>则是弹栈操作，返回最后一位元素，即栈顶元素。
5.使用<code>in</code>判断元素是否存在，<code>count()</code>记录特定值出现次数，<code>index()</code>查询具有特定值的元素位置
<pre><code class="language-python">>>> word =
>>> 1 in word
True
>>> 6 in word
False
>>> word.count(1)
3
>>> word.index(1)
0
>>> word.index(1,1)
5
>>> word.index(1,6)
6
</code></pre>
<code>index(str, beg=0, end=len(string))</code>,其中<code>beg</code>规定开始索引，<code>end</code>默认为列表长度，返回开始索引位置后第一次出现的<code>str</code>的位置。
6.使用<code>sort()</code>与<code>sorted()</code>排列数组
默认都是升序排列，加上参数<code>reverse=True</code>则降序排列。
<ul>
<li><code>sort()</code>会对原列表进行排序，改变原列表内容。</li>
<li><code>sorted()</code>则会返回排序好的列表副本，原列表内容不变。</li>
</ul>
<pre><code class="language-python">>>> lst =
>>> lst_copy = sorted(lst)
>>> lst_copy

>>> lst

>>> lst.sort()
>>> lst

>>> lst.sort(reverse=True)
>>> lst

</code></pre>
7.使用<code>=</code>赋值，<code>copy()</code>复制
<pre><code class="language-python">>>> a =
>>> b = a
>>> b

>>> a = 0
>>> b

>>> c = a.copy() #使用copy()复制
>>> d = list(a) #使用list()函数复制
>>> f = a[:] #使用列表分片
>>> a = 1
>>> c

>>> d

>>> f

</code></pre>
即使用<code>=</code>赋值后，b与a是同一个对象，修改任意一个都会修改对方，使用<code>copy()</code>,<code>list()</code>与<code>[:]</code>都可以做到创建一个新对象的作用。
8.使用<code>range()</code>生成列表
在Python3中，<code>range()</code>的返回值已经变为<code>range</code>类型，不再是原来的<code>list</code>类型，但依旧可以使用<code>list</code>函数转换过去。<code>range(start, end, step)</code>，即生成一个从<code>start</code>开始，<code>end - 1</code>结束的列表，<code>step</code>为步长，多用于循环之中。
<pre><code class="language-python">>>> range(0,5)
range(0, 5)
>>> type(range(0,5))
<class 'range'>
>>> for i in range(0,5):
... print(i)
...
0
1
2
3
4
</code></pre>
<h5 id="2元组">2.元组</h5>
1.使用<code>()</code>与<code>tuple()</code>创建元组
<pre><code class="language-python">>>> tup =
>>> tup =tuple(tup)
>>> tup
(1, 2, 3)
>>> (1,2,3)
(1, 2, 3)
>>> tup
1
>>> tup = 2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
</code></pre>
元组与列表使用方法基本都是相同的，但最大的区别就是一旦创建元组就不能修改，所以所有修改列表的操作元组这里都不能用，dir(tuple)可知，对元组进行操作的只有['count','index']。所以使用场景就是元组的占用空间小，你不会意外修改元组的值和它可以作为字典的键。
<h5 id="3字典">3.字典</h5>
字典与列表类似，可以原地修改，即它是可变的，但它的顺序无关紧要，因为其本质就是键值对。在字典中的“键”，必须是不可变的数据类型；“值”可以是任意数据类型。
1.使用<code>{}</code>与<code>dict()</code>来创建字典
<pre><code class="language-python">>>> mydict = {"1":"a","2":"b"} #初始化字典
>>> mydict
{'1': 'a', '2': 'b'}
>>> lst = [,,] #将二维列表转换成字典
>>> mydict = dict(lst)
>>> mydict
{1: 2, 3: 4, 5: 6}
>>> string = ('12','34','56') #将双字符的字符串元组转换成字典
>>> mydict = dict(string)
>>> mydict
{'1': '2', '3': '4', '5': '6'}
</code></pre>
2.使用<code></code>添加或修改元素，使用<code>in</code>判断键是否存在于字典
<pre><code class="language-python">>>> mydict = {1: 2, 3: 4, 5: 6}
>>> mydict = 8
>>> mydict
{1: 2, 3: 4, 5: 6, 7: 8}
>>> if 2 in mydict:
... mydict = 0
... else:
... mydict = 0
...
>>> mydict
{1: 2, 3: 0, 5: 6, 7: 8}
</code></pre>
3.使用<code>update()</code>合并字典
<pre><code class="language-python">>>> a = {1:2,3:4}
>>> a
{1: 2, 3: 4}
>>> b = {5:6,7:8}
>>> b
{5: 6, 7: 8}
>>> a.update(b)
>>> a
{1: 2, 3: 4, 5: 6, 7: 8}
>>> c = {1:'a'} #如果使用同样的键，则新归入字典的值会取代原有的值
>>> a.update(c)
>>> a
{1: 'a', 3: 4, 5: 6, 7: 8}
</code></pre>
4.使用<code>del</code>删除指定键元素与<code>clear()</code>清空字典
<pre><code class="language-python">>>> a
{1: 'a', 3: 4, 5: 6, 7: 8}
>>> del a
>>> a
{3: 4, 5: 6, 7: 8}
>>> a.clear()
>>> a
{}
</code></pre>
5.使用<code></code>与<code>get()</code>获取元素
<pre><code class="language-python">>>> a = {1:2,3:4}
>>> a
2
>>> a
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 2
>>> a.get(1)
2
>>> a.get(2)
</code></pre>
使用<code></code>获取，如果键不存在则会抛出异常，所以改用<code>get()</code>方法，不存在的话会返回None。
6.使用<code>keys()</code>，<code>values()</code>与<code>items()</code>
<pre><code class="language-python">>>> a = {1: 2, 3: 4, 5: 6, 7: 8}
>>> a.keys() #使用keys()返回所有key值
dict_keys()
>>> type(a.keys())
<class 'dict_keys'>
>>> list(a.keys())

>>> a.values() #使用values()返回所有value值
dict_values()
>>> a.items() #使用items()返回所有键值对
dict_items([(1, 2), (3, 4), (5, 6), (7, 8)])
</code></pre>
我们可以看到，在Python3中，返回的类型已经变成<code>'dict_keys'</code>等等这种方法，这样做的目的是list占用空间较大，且效率不高，所以如果需要用到list，再使用list函数即可。
<h5 id="4集合">4.集合</h5>
集合的概念与数学中的集合概念是相同的，即集合中的元素是互异的。
1.使用<code>{}</code>与<code>set()</code>创建集合
<pre><code class="language-python">>>> s = {1,2,3,4,1}
>>> s
{1, 2, 3, 4}
>>> a =
>>> s = set(a)
>>> s
{1, 2, 3, 4, 5}
</code></pre>
可见，在Python中去重是非常简单的事情，直接转换成集合就行了。
同样也可以使用<code>in</code>来判断一个元素是否存在于集合之中，这里就不在举例。
2.集合中运算
<pre><code class="language-python">>>> a = {1,2,3}
>>> b = {2,3}
>>> a > b #使用>=与<=判断是否是子集，使用>与<判断是否是真子集
True
>>> a > a
False
>>> a & b #使用&做交集
{2, 3}
>>> a | b #使用|做并集
{1, 2, 3}
>>> a - b #使用-做差集
{1}
>>> b - a
set()
>>> b ^ a #使用^做异或集
{1}
</code></pre>
<h5 id="5进一步的内建函数">5.进一步的内建函数</h5>
1.<code>zip(*iterables)</code>,使用它可以做到并行迭代，举例说明：
<pre><code class="language-python">>>> a = (1,2,3)
>>> b = (4,5,6)
>>> for i,j in zip(a,b):
... print(i,j)
...
1 4
2 5
3 6
</code></pre>
所以可以使用其进行生成字典操作：
<pre><code class="language-python">>>> a = (1,2,3)
>>> b = (4,5,6)
>>> dict(zip(a,b))
{1: 4, 2: 5, 3: 6}
</code></pre>
2.<code>map(function, iterable, ...)</code>,类似于MapReduce中的Map阶段，即将后面的iterable作用于前面的function，举例说明：
<pre><code class="language-python">>>> def add(x):
... return x + 10
...
>>> lst =
>>> map(add, lst)
<map object at 0x000002C359ACC9B0>
>>> list(map(add, lst))

</code></pre>
同样我们可以看到，在Python3中返回的是一个map对象，依旧是节省时间的作用，也就是<code>lazy evaluation</code>。
3.<code>enumerate(iterable, start=0)</code>,其实就是枚举，具体看下面的例子:
<pre><code class="language-python">>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
</code></pre>
<h5 id="6可变长度的函数参数">6.可变长度的函数参数</h5>
在Python中，有两种变长参数，分别是元组（非关键字参数）和字典（关键字参数）。其调用方式是：func( *args, **kwargs ) 
因为有时候不知道传进去多少个参数，所以要用可变长的参数，在参数前加一个星号*代表传入的参数会被储存为元组，加两个星号**代表传入的会被储存为字典，要使用键值对的方式传入，具体见下例
<pre><code class="language-python">>>> def print_args(*args):
... print('tuple',args)
...
>>> print_args() #如果不传参，则返回空的tuple()
tuple ()
>>> print_args(1,3,12,'asd',)
tuple (1, 3, 12, 'asd', )
>>> def print_kwargs(**kwargs):
... print('dict',kwargs)
...
>>> print_kwargs(a='a',b='b',c='c')
dict {'a': 'a', 'b': 'b', 'c': 'c'}
</code></pre>
那么这样做有什么用呢？下面举一些例子说明：
<pre><code class="language-python">#转置一个矩阵
>>> matrix = [,,]
>>> matrix = list(map(list, zip(*matrix)))
>>> matrix
[, , ]
</code></pre>
<code>zip(*value)</code>因为在函数调用中使用*list/tuple的方式表示将list/tuple分开，作为位置参数传递给对应函数，所以起到了转置矩阵的作用。
<h4 id="三python高级用法">三、Python高级用法</h4>
<h5 id="1列表推导式">1.列表推导式</h5>
例如我们要创建一个0到10的列表，那么我们可能首先会想到使用<code>range()</code>
<pre><code class="language-python">>>> list(range(0,11))

</code></pre>
然而更加Pythonic的方法是使用列表推导式，即<code></code>,举例说明
<pre><code class="language-python">>>>

>>>

>>>

</code></pre>
这里我们可以用它构建一个空的二维数组，即一个m*n的矩阵
<pre><code class="language-python">>>> [ for row in range(3)]
[, , ]
</code></pre>
再举一个例子，取出有相同值的列表中第n次出现的下标
<pre><code class="language-python">>>> nums =
>>> index = #其中idx是下标，1为目标值，即取出了所有1的位置下标
>>> index

</code></pre>
<h5 id="2匿名函数lambda函数">2.匿名函数：<code>lambda()</code>函数</h5>
Python中，为实现函数式编程，<code>lambda</code>不能少，它是用于语句表达的匿名函数，可以用来代替小的函数，下面举例说明。
<pre><code class="language-python">#判断一个数是否是偶数
>>> f = lambda x: True if x % 2 == 0 else False
>>> print(f(4))
True
>>> print(f(5))
False
</code></pre>
<pre><code class="language-python">#字典按values排序
>>> dict = {'four': 4, 'three': 3, 'two': 2, 'one': 1}
>>> dict_lst = sorted(dict.items(), key=lambda x:x)
>>> dict_lst
[('one', 1), ('two', 2), ('three', 3), ('four', 4)]
</code></pre>
<h5 id="3日期与时间">3.日期与时间</h5>
使用python处理日期与时间，需要用到<code>datetime</code>模块，例如获取当前时间
<pre><code class="language-python">>>> from datetime import datetime
>>> now = datetime.now()
>>> print(now)
2018-01-17 19:55:50.371107
</code></pre>
很多时候使用时间戳来表示时间，我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time，记为<code>0</code>（1970年以前的时间timestamp为负数），当前时间就是相对于epoch time的秒数，称为timestamp。
<pre><code class="language-python">>>> now.timestamp()
1516190150.371107
#相应的转回来使用
>>> t = now.timestamp()
>>> print(datetime.fromtimestamp(t))
2018-01-17 19:55:50.371107
#还可以转成UTC时间
>>> print(datetime.utcfromtimestamp(t))
2018-01-17 11:55:50.371107
</code></pre>
然而这些都是<code>datetime</code>类型的数据，不便于处理，所以我们要将其转换成字符串类型，字符串<code>'%Y-%m-%d %H:%M:%S'</code>规定了日期和时间部分的格式。
<pre><code class="language-python">>>> print(now.strftime('%Y-%m-%d %H:%M:%S'))
2018-01-17 19:55:50
>>> print(now.strftime('%Y-%m-%d'))
2018-01-17
>>> print(now.strftime('%Y%m%d'))
20180117
#当然也可以字符串转datetime
>>> now = now.strftime('%Y%m%d')
>>> now
'20180117'
>>> now = datetime.strptime(now, '%Y%m%d')
>>> now
datetime.datetime(2018, 1, 17, 0, 0)
</code></pre>
可以随意调整你需要的格式。
有时我们还会用到时间的运算，这里必须结合<code>datetime</code>和<code>timedelta</code>
<pre><code class="language-python">>>> from datetime import datetime, timedelta
>>> now = datetime.now()
>>> now
datetime.datetime(2018, 1, 17, 20, 3, 53, 221673)
>>> now + timedelta(hours=1)
datetime.datetime(2018, 1, 17, 21, 3, 53, 221673)
>>> now - timedelta(days=7)
datetime.datetime(2018, 1, 10, 20, 3, 53, 221673)
>>> (now - timedelta(days=7)).strftime('%Y-%m-%d-%H-%M-%S')
'2018-01-10-20-03-53'
>>> (now - timedelta(days=7)).strftime('%Y-%m-%d-%H-%M-%S').split('-')
['2018', '01', '10', '20', '03', '53']
</code></pre>
把分隔符号统一便于分隔，分隔成list后便于进行时间粒度划分处理。
最后一个实用的是判断星期几：
<pre><code class="language-python">>>> from datetime import datetime
>>> text = '2012-09-20'
>>> y = datetime.strptime(text, '%Y-%m-%d')
>>> y.weekday()
3
</code></pre>
<h5 id="4高级内建函数">4.高级内建函数</h5>
1.<code>reduce(function, iterable[, initializer])</code>,有map当然就会有reduce，在Python3中，reduce()已经从全局命名空间中移除，放到了functools模块中，如果要是用，需要用<code>from functools import reduce</code>引入之。
map是上下运算，reduce是横着逐个元素进行运算，下面举个例子：
<pre><code class="language-python">#基础用法
>>> reduce(lambda x,y: x+y,)
15
#进阶
>>> a =
>>> b =
>>> list(zip(a,b))
[(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]
>>> sum(x*y for x,y in zip(a,b))
130
>>> reduce(lambda x,y:x+y,map(lambda x,y:x*y,a,b))
130
</code></pre>
2.<code>filter(function, iterable)</code>,filter的中文含义是“过滤器”，在python中，它就是起到了过滤器的作用。
<pre><code class="language-python">>>> numbers = range(-5,5)
>>> numbers
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]

>>> filter(lambda x: x>0, numbers)

>>> #与上面那句等效

</code></pre>
3.<code>yield</code>生成器，返回值变为一个生成器对象
<pre><code class="language-python">#例如输出斐波那契数列前N个数字
>>> def fab(max):
... n, a, b = 0, 0, 1
... while n < max:
... print(b)
... a, b = b, a + b
... n = n + 1
...
>>> fab(5)
1
1
2
3
5
#修改后变为
>>> def fab(max):
... n, a, b = 0, 0, 1
... while n < max:
... yield(b)
... a, b = b, a + b
... n = n + 1
...
>>> fab(5)
<generator object fab at 0x000002C359B6F410>
>>> for i in fab(5):
... print(i)
...
1
1
2
3
5
</code></pre>
这样做的好处是它不是全部存在内存里，它只在要调用的时候在内存里生成，这样就能和上述一样做到<code>lazy evaluation</code>,需要的时候才迭代。
<h5 id="5文件操作">5.文件操作</h5>
1.打开文件：
fp = open("test.txt",w) 
直接打开一个文件，如果文件不存在则创建文件 
关于open 模式：
<blockquote>
w 以写方式打开， 
a 以追加模式打开 (从 EOF 开始, 必要时创建新文件) 
r+ 以读写模式打开 
w+ 以读写模式打开 (参见 w ) 
a+ 以读写模式打开 (参见 a )
</blockquote>
2.关闭文件：
使用file.close()或者with open("131.txt","w") as f:来关闭，建议使用第二种操作
<pre><code class="language-python">>>> with open("131.txt","w") as f:
... f.write("This is a file")
...
14
</code></pre>
3.read/readline/readlines
<ul>
<li>read：如果指定了参数size，就按照该指定长度从文件中读取内容，否则，就读取全文。被读出来的内容，全部塞到一个字符串里面。这样有好处，就是东西都到内存里面了，随时取用，比较快捷；也是因为这点，如果文件内容太多了，内存会吃不消的。</li>
<li>readline：那个可选参数size的含义同上。它则是以行为单位返回字符串，也就是每次只读一行，依次循环，如果不限定size，直到最后一个返回的是空字符串，意味着到文件末尾了(EOF)。</li>
<li>readlines：size同上。它返回的是以行为单位的列表，即相当于先执行readline()，得到每一行，然后把这一行的字符串作为列表中的元素塞到一个列表中，最后将此列表返回。</li>
</ul>
<pre><code class="language-python">>>> with open("airport_gz_passenger_24.csv","r") as f:
... text = f.read()
...
>>> text = text.split('\n')
>>> text
'passengerCount,WIFIAPTag,slice10min'
>>> with open("airport_gz_passenger_24.csv","r") as f:
... f.readline()
...
'passengerCount,WIFIAPTag,slice10min\n'
>>> with open("airport_gz_passenger_24.csv","r") as f:
... text = f.readlines()
...
>>> text
'passengerCount,WIFIAPTag,slice10min\n'

</code></pre>
<h5 id="5多进程实现并行处理">5.多进程实现并行处理</h5>
在Python中使用<code>multiprocessing</code>模块来实现多进程，下面举例说明
<pre><code class="language-python">#一个简单的查找程序
import multiprocessing
import time

def find(flag):
num = 99
if flag == 0:
s1 = time.time()
for i in range(0, 101):
time.sleep(0.1)
 if num == i:
 print("顺序找到")
 print("耗时" + str(time.time() - s1))
if flag == 1:
s2 = time.time()
for i in range(101, 0, -1):
time.sleep(0.1)
if num == i:
 print("逆序找到")
 print("耗时" + str(time.time() - s2))

if __name__ == "__main__":
pool = multiprocessing.Pool(processes = 2)
for i in range(2):
 pool.apply_async(find, (i, )) #维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
 print("开始")
 pool.close()
 pool.join() #调用join之前，先调用close函数，否则会出错。执行完close后不会有新的进程加入到pool,join函数等待所有子进程结束
print("结束")
</code></pre>
结果如下：
<pre><code class="language-shell">C:\Users\Cabbage\Desktop\毕业设计\code\first>python mulprocess_1.py
开始
逆序找到
耗时0.30155348777770996
顺序找到
耗时10.043102502822876
结束
</code></pre>
<h5 id="6异常处理">6.异常处理</h5>
1.错误与异常
语法错误，或者称之为解析错误：
<pre><code class="language-python">>>> while True print('Hello world')
File "<stdin>", line 1, in ?
while True print('Hello world')
^
SyntaxError: invalid syntax
</code></pre>
异常
即使一条语句或表达式在语法上是正确的，在运行它的时候，也有可能发生错误。在执行期间检测到的错误被称为异常并且程序不会无条件地崩溃：你很快就会知道如何在 Python 程序中处理它们。然而大多数异常都不会被程序处理，导致产生类似下面的错误信息：
<pre><code class="language-python">>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly
</code></pre>
最后一行的错误消息指示发生了什么事。异常有不同的类型,下面列出常见异常：
<table>
<thead>
<tr>
<th style="text-align: center">异常</th>
<th style="text-align: center">描述</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align: center">NameError</td>
<td style="text-align: center">尝试访问一个没有申明的变量</td>
</tr>
<tr>
<td style="text-align: center">ZeroDivisionError</td>
<td style="text-align: center">除数为0</td>
</tr>
<tr>
<td style="text-align: center">SyntaxError</td>
<td style="text-align: center">语法错误</td>
</tr>
<tr>
<td style="text-align: center">IndexError</td>
<td style="text-align: center">索引超出序列范围</td>
</tr>
<tr>
<td style="text-align: center">KeyError</td>
<td style="text-align: center">请求一个不存在的字典关键字</td>
</tr>
<tr>
<td style="text-align: center">IOError</td>
<td style="text-align: center">输入输出错误（比如你要读的文件不存在）</td>
</tr>
<tr>
<td style="text-align: center">AttributeError</td>
<td style="text-align: center">尝试访问未知的对象属性</td>
</tr>
</tbody>
</table>
2.使用<code>try...except</code>处理异常
抛出异常
可以通过编程来选择处理部分异常。看一下下面的例子，它会一直要求用户输入直到输入一个合法的整数为止，但允许用户中断这个程序（使用Control-C或系统支持的任何方法）；注意用户产生的中断引发的是 KeyboardInterrupt 异常。
<pre><code class="language-python">while True:
try:
x = int(input("输入一个数字： "))
break
except ValueError:
print("这不是数字，重新输入。")

</code></pre>
输出为：
<pre><code class="language-shell">C:\Users\Cabbage\Desktop\毕业设计\code\first>python error.py
输入一个数字： a
这不是数字，重新输入。
输入一个数字： b
这不是数字，重新输入。
输入一个数字： 1
</code></pre>
引发异常
raise语句允许程序员强行引发一个指定的异常。例如：
<pre><code class="language-python">inputValue = input("请输入a,b或c:")
if inputValue in "abc":
print(inputValue)
else:
raise(ValueError)
</code></pre>
结果为：
<pre><code class="language-shell">C:\Users\Cabbage\Desktop\毕业设计\code\first>python raise.py
请输入a,b或c:f
Traceback (most recent call last):
File "raise.py", line 5, in <module>
raise(ValueError)
ValueError

C:\Users\Cabbage\Desktop\毕业设计\code\first>python raise.py
请输入a,b或c:a
a
</code></pre> 
来源：https://www.cnblogs.com/harrylyx/p/12388692.html

頁: [1]

琼殿技术论坛's Archiver

一天速成Python教程