一文教会你掌握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)=><class 'tuple'>

向里面添加数据也很简单，是这样。

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=> <class '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)

参数。

函数的参数放在圆括号内, 对于函数的参数，点击即可领取python视频教程你可以设定缺省值, 一定要记住一点，设置缺省值的参数一定要放在最后面，对有缺省值的参数，如果你在调用函数的时候设定某个值，函数就会启用你设定的新值。

一个很方便的地方是在你对函数的参数设置的时候，你可以指定函数参数的名字。>>> 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 "<stdin>", line 1, in <module>

ZeroDivisionError: division by zero

>>> try:

... print(x/y)

哪里出了错误，一目了然。

怎么样，东西虽然多，对你来说不难吧？