一文教会你掌握Python
Python是一门面向通用目的高端编程语言。那代码风格是简单清晰。在数据处理行业中，这门语言是当之无愧的第一。
现在说一下2和3的区别。Python 2和Python 3都比较常用，但是这两个版本又有一些的区别。只要记得，以后在编程的时候，可能会遇到版本不一而导致程序无法运行的问题就行了。
下来我们可以说一些Python编程中的一些技术细节。
1. 字符串
首先是字符串，任何语言编程中都离不开字符串。字符串是一些字符的集合。这是集合用单引号或者双引号，包含起来，基本上这两种表示方式没有区别。
'test'
"test"
如果文字中包含多行，需要用三个引号来表示。
'''test another
test'''
"""test another
test"""
下面说一下字符串的操作。
两个字符串相加，直接用加号就可以了。
"Test"+"test2" => “Testtest2”
多个字符串相连，直接用单引号，连起来就可以了。
' a ‘' b ‘' c‘=>' a b c‘
字符串的重复直接用乘号。
‘A’ * 5 ⇒”AAAAA”
字符串的索引和取值。
a=”test”
a[0]=>’t’
索引值为负的话表示从后面取。
a[-2]=>’s’
取一段儿的话，用冒号。
a[0:2]=>”te”, 最后结尾索引不包括在内。
只用冒号表示，取全部字符串。
a[:]=>”test”
只输入右边数值表示从左边第一个字符开始。
a[:2]=>”te”
只输入左边数值表示取到最后。
a[2:]=>”st”
下面是字符串的相关函数。
len() 返回字符串中字符的个数,也就是字符串的长度。
len(a)=>4
字符串儿对象的方法。
split返回的是一个字符串数组。
str=”This is a test”
str.split(“ ”) => [“This”, “is”, “a”, “test”]
这个方法可以输入一个参数，指定最多可以进行多少次的分解。
str.split(“ ”， 1) => [“This”, “is a test”]
这个方法对应的反向操作是join。把一个数组或者列表合成为一个字符串。
‘ ’.join([“This”, “is”, “a”, “test”])=>”This is a test.”
接下来是大小写的操作。分别调用Upper, Lower.
‘a’.Upper()=>’A’
‘A’.Lower()=>’a’
还有一些比较常用的方法:
string.isalnum, 是否是字符或者数字？
string.isalpha, 是否是字符？
string.isdigit, 是否是数字？
string.islower, 是否是小写？
string.isspace, 是否是空格?
string.istitle, 是否第1个字符为大写？
string.isupper是否是大写？
字符串的格式化。
打印用print函数或者命令。
print(‘test’) = > test
print (4+5)=> 9 (Python 3)
用百分号来格式化。
'%s, %s' % ('a1', 'a2') => a1 a2
'{}'.format(2) => 2
'{1} {0}'.format(1, 2) (Python 3)
'2 1'
百分号后面的转义符有：
d/i — 整数
u — 无符号整数
o — 8进制整数
h/H — 16进制整数
f — 浮点型数字
e/E — 用指数表示的浮点型数字
g/G — 用最佳符号表示的浮点型数字
s — 字符串
c — 单个字符
2. 接下来说一下数字类型数据。
类型和转换
整数类型
数值范围从负20亿到正20亿
int() # 这是取整函数。
int(3.9)=>3
长整型。
如果数字超出了整型的范围就应该用长整型
在数字前面加大写的L来表示长整型整数(如 7L)
长整型因为范围比较大，它会降低程序的运行速度
long() # Python 2
Float 浮点型数字。
最多支持15~16个数字
可以使用指数表示方法 1e3 => 1000
float()
float(3)=>3.0
复数
使用复数函数，可以输入一个复数(比如 complex(1.2, 7)) 或者用j表示虚部 (e.g. 1.2 + 7j)
complex()
数字操作符。
+ 加法。
-减法。
*乘法。
/ 除法
** 指数
% 模运算。
// # Python 3
5 // 2=>2
>> 右移位。
<< 左移位。
函数
abs() 取绝对值。
round() 四舍五入。
divmod() 除法得出商和余数。
divmod(9, 4) =>(2, 1)
pow() 指数运算。
pow (3, 2)=>9
coerce() — 数值类型匹配， 可以从低范围数字类型像高范围数据类型匹配
整数类型 < 常整数类型 < 浮点型 < 复数类型
coerce (1, 2L)=>(1L, 2L)
str() — 转化数字为字符串
玩数字离不开数学模块
import math
math.pi 圆周率。
3.141592653589793
math.sqrt(4) =>2.0 开平方。
3. 列表。
在Python里面列表和数组没有区别。创建了一个列表，可以用方括号， 可以用list函数。
fruit = ['apple', 'banana', 'orange']
meat = list(['pork', 'beef', 'chicken'])
mix = [123, ['Python', 'SQL'], 'iPhone']
索引和取值
取值方面跟上面的字符串类似。但是要注意，列表是可以修改的，字符串是不可以修改的。
mylist = [1, 2, 3, 4, 5, 6]
mylist[1] = 10
mylist =>[1, 10, 3, 4, 5, 6]
上面的例子，原来的列表被修改过了。这种情况下Python不会重新创建一个列表。你可以同时更新几个元素。
mylist = [1, 2, 3, 4, 5]
mylist[3:5] = [100, 101]
mylist=>[1, 2, 3, 100, 101, 6]
如果被更新的元素长度跟输入的数值不匹配，那么以原先的列表会被收缩或者扩张。
newlist = [1, 2, 3]
newlist[0:2] = [4]
newlist =>[4, 3]
你可以在现有的列表中插入另一个列表。
newlist = [1, 2, 3]
newlist[2] = [2, 2, 2]
newlist=>[1, [2, 2, 2], 3]
如果你把现有的列表，用等号复制给另一个列表，当你修改其中一个列表的时候，两个列表都会被修改， 因为他们始终指向同一个列表。
技术上在Python里面，等号是传递引用的。
x = [1, 2, 3]
y = x
y=>[1, 2, 3]
x[1] = 1000
x=>[1, 1000, 3]
y=> [1, 1000, 3]
如果你想避免这种情况， 你需要用copy模块。
x = [1, 2, 3]
y = x[:]
x[1] = 1000
x=>[1, 1000, 3]
y=>[1, 2, 3]
或者
import copy
x = [1, 2, 3]
y = copy.copy(x)
x[0] = 10
x=>[10, 2, 3]
y =>[1, 2, 3]
删除列表中的元素，你可以用del。
mylist = [1, 2, 3, 4]
del mylist[1]
mylist=>[1, 3, 4]
del mylist[:2]
mylist=>[4]
操作符
你可以用加号来合并两个列表。
a = [1, 2, 3]
b = [4, 5, 6]
a + b=>[1, 2, 3, 4, 5, 6]
你可以用星号来重复一个列表。
a = [1, 2]
a * 2=>[1, 2, 1, 2]
[a] * 2=>[[1, 2], [1, 2]]
可以检查一个列表中是否包含另一个列表。
mylist = [1, 2, 3, 4]
1 in mylist =>True
10 in mylist=> False
列表的相关函数
len() — 返回列表的长度，也就是列表中含有多少个元素。
mylist = [1, 2, 3, 4]
len(mylist)=>4
min() — 返回最小的列表元素。
max() — 返回最大的列表元素。
list() — 把一个tuple转换成一个list, 或者创建一个列表。
mytuple = (1, 2, 3)
list(mytuple)=>[1, 2, 3]
列表的方法
列表的方法会修改它自身， 因此你不需要把列表方法的返回值，返回给另一个变量。
list.append(element) — 在列表中添加一个元素或者另一个列表。
a = [1, 2, 3]
a.append(4)
a=>[1, 2, 3, 4]
b = [7, 8]
a.append(b)
a=>[1, 2, 3, 4, [7, 8]]
list.extend(list) — 在已有的列表尾端添加另一个列表。
a = [1, 2, 3]
b = [7, 8]
a.extend(b) => [1, 2, 3, 7, 8]
list.insert(index, element) — 在列表中指定位置插入一个元素。
a = [1, 2, 3]
a.insert(1, 10)
a=>[1, 10, 2, 3]
list.remove(value) — 删除在列表中出现的第1个指定元素。
a = [1, 2, 3]
a.remove(2)
a=>[1, 3]
list.pop(index) — 返回指定位置的元素，并且把这个元素从列表中删除。
a = [1, 2, 3]
a.pop(1)=>2
a=>[1, 3]
list.sort() — 按照数字顺序或者字符串顺序进行排序。
a = [3, 2, 1]
a.sort()
a=>[1, 2, 3]
list.count(value) — 检查指定的数值在列表中出现的次数。
a = [1, 1, 1, 2, 3,]
a.count(1)=>3
list.index(value) — 返回指定数值的第1个索引。
a = [1, 2, 3, 4]
a.index(2) =>1
列表动态
你可以使用一个for loop来动态的生成一个新的列表， 比如下面的例子是说对老列表中的每个元素取平方。
old = [1, 2, 3, 4, 5]
new = [i**2 for i in old]
new=>[1, 4, 9, 16, 25]
列表动态非常简单，上面的运算过程相当于下面这个:
old = [1, 2, 3, 4, 5]
new = []
for i in old:
... new.append(i**2)
...
new=>[1, 4, 9, 16, 25]
在列表动态里面你还可以使用if条件判断:
old = [1, 2, 3, 4, 5]
new = [i for i i n old if i % 2 == 1]
new=> [1, 3, 5]
列表动态还允许你使用多个for loop。
a = [(i, j) for i in range(2) for j in range(3)]
a=>[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]
4. Tuple 元组
Tuple 跟列表很类似。只是不能被修改。Tuple主要有下面的好处:
比列表更快
因为无法修改所以能够很好的保护数据
创建purple的方式可以用圆括号来把数据括起来，并不是必须的。
mytuple = 1, 2, 3
type(mytuple)=>
向里面添加数据也很简单，是这样。
mytuple + (7, )=>(1, 2, 3, 7)
也可以用tuple函数，来把一个列表转成一个tuple。
mylist = [1, 2, 3]
tuple(mylist)=>(1, 2, 3)
索引和取值
操作符。
跟列表的操作符是一样的。
函数
跟列表的函数列表也非常类似。
len() — 返回长度
min() — 返回最小值
max() — 返回最大值
tuple() — 把列表转成
方法
既然couple是不可被修改的，列表的一些方法并不适用它。
tuple.count(value) — 计算某个值出现了多少次。
tuple.index(value) 返回某个值的第1个索引
5. 字典
字典就是一种数据对应的数据结构。
只要是不可改变的值，都可以作为它的键。
获取自己的字典中的数据，不是通过索引，而是通过键值。
创建一个字典用大括号，有冒号来连接键值和对应值。
键值必须是唯一的不可改变的。
mydict = {key1: value1, key2: value2}
索引和取值。
字典通过键值来取值。
dict = {'a': 'apple', 'b': 'banana'}
dict['a']=>'apple'
字典的值是可以改变的，这跟列表有点类似。
dict = {'a': 'apple', 'b': 'banana'}
dict['a'] = 'burger'
dict=>{'a': 'burger', 'b': 'banana'}
可以向字典中添加新的元素对。
dict = {'a': 'apple', 'b': 'banana'}
dict['c'] = 'cat'
dict=> dict = {'a': 'apple', 'b': 'banana', 'c': 'cat'}
字典取值无法像列表那样取一段。
操作符。
in — 这个操作符， 主要是判断某个键值在字典中是否存在， 可以访问字典的键值， 不能用来访问对应的元素值。
dict = {'a': 'apple', 'b': 'banana'}
'a' in dict => True
'apple' in dict =>False
del — 用来删除元素对
dict = {'a': 'apple', 'b': 'banana'}
del dict
dict=>
6. 函数
len() — 返回字典中元素对的个数。
方法
dict.keys() — 返回字典中的键值列表。
dict.values() — 返回字典中的元素值列表。
dict.items() — 返回字典中元素对的列表。
dict.clear — 清除字典中所有的元素对。
dict = {'a': 'apple', 'b': 'banana'}
dict=>{}
dict.get(key, default = None) 对指定的键值进行取值。
dict = {'a': 'apple', 'b': 'banana'}
dict.get('a') =>'apple'
dict.get('c')
dict.get('c', "doesn't exist") => "doesn't exist"
dict.copy() — 拷贝当前的字典，新生成的字典修改不会影响到原来的字典。
dict = {'a': 'apple', 'b': 'banana'}
dict2 = dict.copy()
dict2=>{'a': 'apple', 'b': 'banana'}
dict['a'] = 'dog'
dict=> {'a': 'cat', 'b': 'banana'}
dict2=> {'a': 'apple', 'b': 'banana'}
dict.update(dict) — 用另外一个字典来更新现有的字典。
dict = {'a': 'apple', 'b': 'banana'}
dict2 = {'a': 'dog', 'b': 'banana', 'c': 'cat'}
dict.update(dict2) =>dict {'a': dog', 'b': 'banana', 'c':'cat'}
7. 文件
打开操作。
Python可以对文件对象进行操作，open() 可以返回一个文件对象, 然后用读写函数对文件对象进行操作。
参数说明，第1个参数是文件名，你指定打开哪个文件？第2个参数是打开的方式，不填的话是只读。
r — 文件读操作，文件必须存在，否则出错。
w — 文件写操作，如果文件不存在，则会创建新文件。
a — 文件添加内容操作，如果文件不存在也会创建新文件。
r+ — 读写打开文件操作，文件内容不会被删除。
w+ — 读写打开文件操作，文件内容会被删除。
a+ — 读写打开文件操作，文件内容不会被删除，可以指指定缓冲方式：
0 — 不缓冲no buffering
1 — 行缓冲line buffering
其他值代表缓冲的大小。
方法
file.read() — 打开整个文件，返回所有的数据为字符串。
file.readline() — 逐行读取文件。
file.readlines() — 打开整个文件返回文件内容的行列表。
file.write() — 往文件里写入内容。
file.writelines() — 往文件里写入多行数据。
file.close() — 关闭文件。
8. 管道
Pipe是指一个命令中读取输出数据，或者向一个命令发送输出数据。
Python 用 os 模块中的popen() 函数来创建一个管道。
import os
from os import popen
9. 条件判断。
x == y — 等于判断。
x != y — 不等于判断。
x > y — 大于判断。
x < y — 小于判断。
x >= y — 大于等于判断。
x < = y — 小于等于判断。
in — 存在判断。
not in — 不存在判断。
is — 完全相同判断。
not is — 不完全相同判断。
is None — 空值判断。
is not None — 非空值判断。
and — 与条件判断。
or — 或条件判断。
not — 非条件判断。
if 如果条件判断。
if expression:
... statement
... elif expression: 其他如果。
... statement
... else:
... statement
注意在if后面的冒号下面有4个空格符。
嵌套
def countdown(n):
if n < 0:
print(Done!)
else:
print(n)
countdown(n-1)
10. For循环。
for循环用来遍历一个序列中的所有元素。
for name_whatever_you_want in sequence:
statements
如果你想用一个for循环来循环多个序列， 你可以使用这样:
x = [1, 2, 3, 4]
y = [5, 6, 7, 8]
for i in range(len(x)):
... print(x[i], y[i])
1 5
2 6
3 7
4 8
11. while 循环。
这个循环不是基于序列的。但是也非常有用。
while expression:
statements
跳出循环，需要用break:
while condition_is_true:
break
12. 函数。
函数是一系列操作的集合。用户可以调用已经定义好的函数，也可以自己定义函数。
函数是非常强大的，它可以允许你重复使用你自己的代码。
要创建一个新的函数，你需要使用这个关键字def。
def function_name(parameter1, parameter2,...):
''' This is the documentation of this function.'''
body area
(return XXX)
参数。
函数的参数放在圆括号内, 对于函数的参数，你可以设定缺省值, 一定要记住一点，设置缺省值的参数一定要放在最后面，对有缺省值的参数，如果你在调用函数的时候设定某个值，函数就会启用你设定的新值。
一个很方便的地方是在你对函数的参数设置的时候，你可以指定函数参数的名字。>>> def count_letter (string, letter = 'a')。
有时候你不知道要往函数里传多少个参数Python语言的设计里面也考虑了这一点，你用星号就可以了。
>>> def max_length(*string)
这个函数会返回所有输入的字符串中，长度最长的那一个。
Python 也允许你输入不指定个数的元素对， 这个地方你需要用双星号
>>> def print_dict(**dict):
13. map()和lambda
数据对应函数。
使用这种方法，可以简化你的代码。
num = ['1', '2', '3']
letter = ['a', 'b', 'c']
combine = []
for i in range(len(num)):
... combine.append(': '.join((num[i], letter[i])))
...
Combine => ['1: a', '2: b', '3: c']
简单点是这样：
>>> def combine_list(list1, list2):
... return ': '.join([list1, list2])
...
num = ['1', '2', '3']
letter = ['a', 'b', 'c']
list(map(combine_list, num, letter)) => ['1: a', '2: b', '3: c']
Python Lamda操作符有点像列表动态。
两者结合功能非常强大。
num = ['1', '2', '3']
letter = ['a', 'b', 'c']
list(map(lambda list1, list2: ': '.join([list1, list2]), num, letter)) =>['1: a', '2: b', '3: c']
Lambda也可以跟过滤器结合使用。
num = [1, 3, -2, -10, 5]
list(filter(lambda x: x < 0, num))=> [-2, -10]
14. 模块。
Python语言的核心是非常小而简单的。要让它更加强大，就需要很多额外的模块。数学模块和拷贝模块是经常被用到的。
这些一个个的模块都是由Python语言编写的程序集合单元。
15. re
正则表达式模块。
是一个非常强大的模块。如果你的程序中经常用到匹配和查找的功能，你可能会需要这个模块。
re.compile() — 创建一个正则表达式对象
re.match() 匹配
re.search()查找
re.split() — 字符串的分解
re.findall() — 找到所有的匹配
在上一期的强大的Python简介中，提到了几个重要的模块，感兴趣的可以去那一篇中找一下。
16. 异常处理。
在写程序的时候，不管你有多么的小心，总会或多或少的出现一些异常。这个时候我们就需要异常处理。
Python中提供了一种方法可以跟踪你的程序运行异常错误。
一个简单的例子就是除数为0。
x = 1
y = 0
print(x/y)
Traceback (most recent call last):
File "
ZeroDivisionError: division by zero
>>> try:
... print(x/y)
哪里出了错误，一目了然。
怎么样，东西虽然多，对你来说不难吧？
好了，这期就先说这些，这里是丁哥开讲，欢迎关注防止失联。