资讯中心 Info
当前位置:爱尚教育 > 资讯中心 >
一篇文章让你轻松入门Python基础
发布日期:2020-08-03 阅读次数:

 

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 "", line 1, in

ZeroDivisionError: division by zero

>>> try:

... print(x/y)

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

怎么样,东西虽然多,对你来说不难吧?

课程体系
通知公告