python基础语法及知识总结（Python数据结构）

人生苦短，我用Python

使用Python做数据挖掘已经两年多了，在处理数据的过程中经常会使用到一些数据结构，比如，列表、元组、集合、字典，虽然经常用，但是老是记不住他们常用的一些函数和方法，那就趁此机会整理一下

注：文章内容根据小甲鱼的《零基础入门学习Python》课程而整理

列表

一：创建列表 ：列表中元素以逗号隔开并且以中括号将他们括起来

在Python中列表的含义和其他程序语言中的数组类似，由一系列元素组成并且可以通过下标进行访问。不同的是，列表里面的元素可以是任何数据类型，甚至可以是一个列表。

1）创建一个纯由字符串组成的列表，并赋值给变量member

member = ['小甲鱼','黑夜','牡丹','怡静']

2）创建一个混合列表，列表内的元素有数字，字符串和纯数字列表，并将其赋值给变量mix

mix = ['小甲鱼',120,[3,2,1]]

3）创建一个空列表，并将其赋值给变量empty：

empty = []

二：通过列表相关函数向列表内添加新元素

在这里我们主要介绍列表的三个函数 append() extent() insert()并举实例介绍它们的用法

1） append()函数

append()函数需要一个参数，该参数将作为一个元素加入到列表的末尾，这种方法一次只能加一个元素

member = ['小甲鱼','黑夜','牡丹','怡静']

>>>member.append('青牛')

>>>member

['小甲鱼','黑夜','牡丹','怡静','青牛']

2） extend()函数，实现了一次性加入多个元素

这个参数是一个列表，通过这个函数可以将此列表内的元素加到列表末尾，调用方式为 列list.extend(newlist)

member = ['小甲鱼','黑夜','牡丹','怡静']

newlist = ['醉酒','John_farmer']

>>>member.extent(newlist)

>>>member

['小甲鱼','黑夜','牡丹','怡静','醉酒','John_farmer']

3）insert()函数

上述两种方法，加入的元素自动被添加到列表的末尾，而insert()函数允许用户将加入的元素放置到任何位置，因此它需要两个参数第一个是新元素在列表中的位置，第二个为该元素，其调用形式为 列表.insert(位置,元素) 注意列表中第一个元素位置是从0开始的

member = ['小甲鱼','黑夜','牡丹','怡静'] 我们想将"醉酒"这个字符串元素放到列表member首位

>>>member.insert(0,'醉酒')

>>>member

['醉酒','小甲鱼','黑夜','牡丹','怡静']

三,通过索引值获得单个列表元素方法，删除列表中某一元素的方法及通过列表分片实现获取列表中多个元素的方法。

1. 通过索引值获得列表中元素

>>>member = ['小甲鱼','黑夜','牡丹','怡静']

>>>member[0]

'小甲鱼'

2. 从列表中删除元素的方法

1）remove()函数

参数是一个元素，调用该函数则删除该列表中的该元素，如果输入的元素不在列表中，则程序报错，例如

member = ['小甲鱼','黑夜','牡丹','怡静']

>>>member.remove('黑夜')

['小甲鱼','牡丹','怡静']

而此时如果再执行member.remove('黑夜'),由于该元素已经不存在此列表中，执行时将会报错

2）del语句

直接删除一个元素值，可以直接通过索引值获得需要删除的元素，例如：

>>>member = ['小甲鱼','黑夜','牡丹','怡静']

>>>del member[2]

>>>member

['小甲鱼','黑夜','怡静']

而执行语句del member，则member列表被删除，如果想再访问member则程序报错，因为它已经不存在了。

3）pop()函数

不需要参数，直接返回列表中最后一个元素并删除，例如：

>>>member = ['小甲鱼','黑夜','牡丹','怡静']

>>>name = member.pop()

>>>name

'怡静

>>>member

['小甲鱼','黑夜','牡丹']

3. 列表分片(slice)

当需要从列表一次性取出多个元素时，需要通过列表分片的方式来实现，其基本形式是列表名[左索引值:右索引值]，左右索引值都可以省略，左索引值省略时表明，列表元素从0开始，右索引值省略表示包含左索引值右边的所有元素。例如：

>>>member = ['小甲鱼','黑夜','牡丹','怡静']

>>>split1 = member[1:3]，则split1= ['黑夜','牡丹'] #member本身元素并没有发生变化，相当于生成了包含元素1和2的新列表

split2 = member[:3]，则列表split2= ['小甲鱼','黑夜','牡丹'] #表示从第0个索引值开始

split3 = member[1:]，则列表split3= ['黑夜','牡丹','怡静'] #表示从左索引值开始到列表右边所有元素

split4 = member[:]，则列表split4= ['小甲鱼','黑夜','牡丹','怡静'] #相当于复制了一份原列表

四：列表中一些常用操作符和列表内的一些常用的内置函数使用

1. 列表中一些常用的操作符

1）比较操作符

列表是可以比较大小的，例如：

list1 = [123,456]

list2 = [456,123]

>>>list1>list2

False

在Python中会直接取两个数组的第0个元素进行比较，如果相等则继续对列表下一个元素进行比较，不相等则给出False或者True的值。这里面需要注意：元素的值必须符合比较运算符的适用范围，例如可以是两个数字进行对比，也可以是两个字符进行对比。

2）逻辑操作符

list1, list2, list3 = [123,456], [456,123], [123,456]

>>>(list1 < list2) and (list1 == list3) #先对两个列表进行比较，再进行逻辑与运算

True

3）连接操作符

在列表中连接操作符为 ，例如：

list1, list2 = [123,456], [789]

list3 = list1 list2

则list3=[123,456,789]， 号起到了将两个列表中的元素连接起来的作用，这里需要注意的是，＋号两边必须都是列表 "list3 345"是会报错的

4）重复操作符

以*进行列表中的元素重复操作，例如：

>>>list1 = [123,456]

>>>list1*3

[123,456,123,456,123,456]

5）成员关系操作符

in 和 not in 分别表示参数是否在列表中，

list1=[123,456]

>>>123 in list1

True，

>>>'小甲鱼' in list1

False，

>>>'小甲鱼' not in list1

True。

另外，in 和 not in只能访问属于列表同一层的元素，例如：

list1 = [123,456,['小甲鱼'，'醉酒'],789] 这是一个列表中含有列表元素的的列表。

>>> '醉酒' in list1

False #因为'醉酒'是在list1[2]这个元素列表中，

>>>'醉酒' in list1[2]

True

那么问题来了，如何访问元素'小甲鱼'和'醉酒'呢，这里是通过类似其他程序语言的二维数组形式实现的。例如list1[2][0]为'小甲鱼'。

2. 列表内的内置函数

首先通过dir(list)找出列表中有哪些内置函数：append clear copy count extend index insert pop remove reverse sort

1）clear() 函数

用于删除列表中的所有元素，形成一个空的列表，例如：

>>>list1 = [123,456,789]

list1.clear() 的值为[]，一个空的列表

2）copy()函数

用于浅拷贝一个列表，例如：

list1 = [123,456]

list2 = list1.copy()

>>>list2

[123,456]

它的功能和列表分片功能 list2 = list1[:]作用是一样的；他们两个与赋值运算符=是有区别的，前者是在内存中重新申请一个空间并存放列表的值，而=则是将列表的地址直接赋值给了另一个列表

list1 = [1,3,5]

list2 =list1

list3 = list1.copy()

list1.append（'醉酒'）

>>>list1

[1,3,5,'醉酒']

>>>list3

[1,3,5]

3）count()函数

用于统计所需参数在列表中出现的次数，例如：

list1 = [1,3,1,4,1,5,1,10]

>>>list1.count(1)

4

>>>list1.count(100)

0

4）index()函数

用于寻找所输入参数在列表中的第一个位置并返回该位置值，还有两个参数可以确定寻找该值的的列表范围，例如：

list1 = [1,3,1,4,1,5,1,10]

>>>list1.index(1)

0

>>>list1.index(1,2,4)

2

>>>list1.index(100) 则报错，因为100不存在该列表中

5）reverse()函数

将列表中所有元素倒置，例如

list1 = [1,2,3,4,5]

>>>list1.reverse()

[5,4,3,2,1]

6）sort()函数&sorted()函数

这是一个比较重要的函数，其有三个参数值，前两个分别是指定排序算法和算法搭配的关键字，最后一个是reverse =False，说明默认状态下sort是按照从小到大进行排序，如果想改为从大到小则将reverse=True，例如

>>>list1 = [12,7,9,15,18,4]

>>>list1.sort()

[4,7,9,12,15,18]

>>>list1.sort(reverse=True) 从大到小排列

[18,15,12,9,7,4]

>>>sorted([5,2,3,1,4])

[1,2,3,4,5]

sort()与sorted()的不同在于，sort是在原位重新排列列表，而sorted()是产生一个新的列表。

元组，通过与列表进行对比来介绍元组独有的用法和特点，

1. 创建和访问元组，元组一旦建立，元组内的元素不允许修改和删除。

1.1 元组的创建：大多数时候，元组的标示是一个()，例如：

empty = () #定义了一个空元组

tuple1 = (1,7,4) #定义了一个纯数字的普通元组

tuple2 = (2,'小甲鱼','醉酒青牛',5) #定义了一个具有数字和字符串的混合元组

然而，当元组中仅有一个元素时，需要将元素后面加上逗号，例如：

tuple3 = (1,) #定义了一个只包含数字1的元组，1后面必须加上逗号才表示元组

甚至，不需要括号，仅仅有逗号就行，例如：

tuple4 = 1,

1.2 元组的访问：

元组的访问形式与列表一样都是:tuple[index]，

例如：tuple4 = (1,5,9)

>>>tuple4[1]

5

tuple4[1] = 4 #将会报语法错误,不允许修改

和列表一样，可以对元组使用拼接操作符，重复操作符，逻辑操作符，关系操作符和成员操作符等。

2. 更新和删除元组

虽然元组本身不允许修改和删除，我们可以对原元组的元素进行修改并新生成一个新的元组存放这些修改后元素，例如：

tuple5 = ('小甲鱼','黑夜','小布丁') #定义一个纯字符串的元组

tuple5 = tuple5[:2] ("醉酒",) tuple5[2:] #通过元组分片形式和拼接操作，生成了在原元组的第一个位置上插入'醉酒青牛'元素的新元组

>>>tuple5

('小甲鱼','醉酒','黑夜','小布丁') #这样就实现了tuple5元组的更新，其实相当于重新生成了一个新的元组，并将其复制给了tuple5，原先的元组还存在，只是已经不再叫tuple5，它会被Python内存垃圾回收。

可以通过del语句直接删除一个元组，但是不允许利用del删除元组的一个元素，例如：

tuple6 = (1,3)

del tuple6

当然也可以采取变通的方法去掉元组的一个元素，例如：

tuple7 = ('小甲鱼','醉酒','黑夜','小布丁') #定义一个纯字符串的元组

tuple7 = tuple7[:1] tuple7[2:] #通过元组分片形式和拼接操作，生成了去掉了'醉酒青牛'元素的新元组并赋值给tuple7

>>>tuple7

('小甲鱼','黑夜','小布丁') #原先的元组还存在，只是已经不再叫tuple7，它会被Python内存垃圾回收。

另外：Python中的函数是可以返回多个值的，其实是以元组的形式返回多个值

集合

一： 集合的概念和使用

在这里集合的概念和数学里集合的概念是一致的，都是一组元素的集，且元素之间不能重复。

1，Python中集合的定义和字典类似，都需要大括号，区别在于集合不需要映射

>>> dict1 = {}

>>> type(dict1)

<class 'dict'>

>>> set1 = {1,4,'小甲鱼'}

>>> type(set1)

<class 'set'>

2. set()函数

和序列工厂函数list()，str()，tuple()一样，可以将序列类型直接强制转换为一个集合类型

一个列表[1,2,3,4,5,5,3,1,0]，如何去除列表内的重复元素，两种方法可供选择，第一种是常规方法，见下面所示：

>>> list2 = [1,2,3,4,5,5,3,1,0]

>>> list3 = []

>>> for each in list2:

if each not in list3:

list3.append(each)

>>> list3

[1, 2, 3, 4, 5, 0]

第二种方法使用集合的元素不重复性，通过将列表先强制转换为集合，再转换为列表形式实现

>>> list4 = [1,2,3,4,5,5,3,1,0]

>>> list4 = list(set(list4))

>>> list4

[0, 1, 2, 3, 4, 5]

3. 集合类型几个内置函数：

add()增加一个元素到集合内，remove()从集合内删除一个元素

>>> set2 = {1,2,3,4}

>>> set2.add(5)

>>> set2

{1, 2, 3, 4, 5}

>>> set2.remove(1)

>>> set2

{2, 3, 4, 5}

4. 将一个集合冻结使之无法添加和删除元素的函数frozenset()

>>> set3 = frozenset(set2)

>>> set3

frozenset({2, 3, 4, 5})

>>> set3.remove(2)

Traceback (most recent call last):

File "<pyshell#30>", line 1, in <module>

set3.remove(2)

AttributeError: 'frozenset' object has no attribute 'remove'

字典

1. 字典的创建和访问

字典不同于前述的序列类型，它是一种映射类型，它的引入就是为了简化定义索引值和元素值存在特定关系的定义和访问问题。字典的定义形式为：字典变量名 = {key1:value1,key2:value2....}。这里面key代表索引值，而value代表映射的值，通过大括号将其括起来进行字典的定义。访问字典时直接以字典变量名[key]进行访问，例如定义一个阿拉伯数字与相应英文的映射字典，举例说明：

>>> dict1 = {1:'one',2:'two',3:'three'}

>>> dict1[2]

'two'

2. dict()函数的用法

创建一个空字典，举例说明：

>>> dict3 = dict()

>>> dict3

{}

通过将key和value作为一个序列类型（元组或列表）创建一个字典

>>> dict4 = dict((('李宁','一切皆有可能'),('鱼C工作室','让编程改变世界')))

>>> dict4

{'李宁': '一切皆有可能', '鱼C工作室': '让编程改变世界'}

通过对关键字赋值创建一个字典，注意关键字必须是一个字符串类型且不能加引号，因为程序会默认为其加上一个引号，举例说明：

>>> dict5 = dict(李宁='一切皆有可能', 鱼C工作室='让编程改变世界')

>>> dict5

{'李宁': '一切皆有可能', '鱼C工作室': '让编程改变世界'}

3. 修改或添加字典元素

通过将变量赋值给字典访问类修改或者增加字典的元素、

>>> dict6 = {'李宁': '一切皆有可能', '鱼C工作室': '让编程改变世界'}

>>> dict6['李宁'] = '打造民族品牌'

当key值存在于字典内时，则重置key的value值

>>> dict6

{'李宁': '打造民族品牌', '鱼C工作室': '让编程改变世界'}

>>> dict6['小甲鱼']='让更多的人学会编程'

当key值不存在于字典内时，则字典增加一个相（key:value）

>>> dict6

{'小甲鱼': '让更多的人学会编程', '李宁': '打造民族品牌', '鱼C工作室': '让编程改变世界'}

常用的内置函数

主要涉及到创建一个新的字典并返回该对象的fromkeys()，访问字典函数函数keyes(),values(),items()，成员操作符in not in，清除一个字典内容的clear()和复制一个新的字典的copy()，自动去除一个字典item的pop()和popitem()，以及最后更新字典的setdefault()和update()。

1. 工厂函数的概念

和序列类型的工厂函数一样，dict()也是一个工厂函数2. 字典类型内置函数的用法

2.1 fromkeys(iterable, value=None, /) 创建并返回一个新的字典。其中第一个参数是一个可迭代对象（序列类型），第二个参数是value值，当第二个参数不提供时，则默认为none，举例说明：

>>> dict1 = dict()

>>> dict2 = dict1.fromkeys((1, 2, 3), 'number')

>>> dict2

{1: 'number', 2: 'number', 3: 'number'}

>>> dict1

{}

>>> dict3 = dict1.fromkeys((1, 2, 3))

>>> dict3

{1: None, 2: None, 3: None}

2.2 访问字典的内置函数，这里主要是访问字典的key的keys()，访问字典的value的values()，访问item的items()。当然也可以直接用get()通过key访问其对应的value。

>>> dict4 = dict1.fromkeys((1,2,3),'赞')

>>> dict4

{1: '赞', 2: '赞', 3: '赞'}

>>> dict4.keys()

dict_keys([1, 2, 3])

>>> for eachkey in dict4.keys():

print(eachkey)

1

2

3

>>> for eachvalue in dict4.values():

print(eachvalue)

赞

赞

赞

>>> for eachitem in dict4.items():

print(eachitem)

(1, '赞')

(2, '赞')

(3, '赞')

get(k[,d])通过key返回对应的value值，第一个参数为key值，第二个参数为默认返回的value值，当key存在则返回对应的value，不存在字典内时返回该值，如果不提供则默认为none，举例说明

>>> dict5 = {1:'one',2:'two',3:'three'}

>>> dict5.get(3,'木有')

'three'

>>> dict5.get(4,'木有')

'木有'

>>> dict5.get(4)

>>> print(dict5.get(4))

None

2.3 清空字典和复制一个字典函数clear()和copy()。这里面主要要搞清楚copy()和=赋值的区别，copy()相当于复制出一个新的字典，两者互不影响，而赋值=仅是将字典内存地址赋值出去，两者共同指向一个地址，

>>> dict6 = dict5

>>> dict7 = dict5.copy()

>>> id(dict6)

58796168

>>> id(dict5)

58796168

>>> id(dict7)

58795208

>>> dict5

{1: 'one', 2: 'two', 3: 'three'}

>>> dict6.clear()

>>>dict6

{}

>>> dict5

{}

>>> dict7

{1: 'one', 2: 'two', 3: 'three'}

2.4 去除字典一个元素内置函数。pop(k[,d])，当k存在字典的key时，在字典内去除该key对应的（key,value），否则返回d的值，当d不提供时返回错误，举例说明：

>>> dict7

{1: 'one', 2: 'two', 3: 'three'}

>>> dict7.pop(1,'木有')

'one'

>>> dict7

{2: 'two', 3: 'three'}

>>> dict7.pop(1,'木有')

'木有'

>>> dict7.pop(1)

Traceback (most recent call last):

File "<pyshell#46>", line 1, in <module>

dict7.pop(1)

KeyError: 1

popitem()去除字典内的一个（key,value），如果字典本身为空时报错

>>> dict7

{2: 'two', 3: 'three'}

>>> dict7.popitem()

(2, 'two')

>>> dict7

{3: 'three'}

2.5 给字典增加一个item，setdefault(k[,d])，返回k对应的value值，当k不在字典内时则返回d的值，如果d没提供则返回空；同时如果k不存在字典内时，将d作为value映射给k

>>> dict7

{3: 'three'}

>>> dict7.setdefault(1,'one')

'one'

>>> dict7

{1: 'one', 3: 'three'}

>>> dict7.setdefault(2)

>>> dict7

{1: 'one', 2: None, 3: 'three'}

>>> dict7.setdefault(3,'有')

'three'

D.update([E, ]**F) 将一个字典内的item作为item添加到字典内

>>> dict7

{1: 'one', 2: None, 3: 'three', 4: 'two'}

>>> dict7.pop(4)

'two'

>>> dict7

{1: 'one', 2: None, 3: 'three'}

>>> dict8 = {4:'four'}

>>> dict7.update(dict8)

>>> dict7

{1: 'one', 2: None, 3: 'three', 4: 'four'}

>>> dict9 = {2:'two'}

>>> dict7.update(dict9)

>>>dict7

{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

,