List是Python中一种叫列表的数据类型,是一种有序的集合,可以随时添加和删除其中的元素。
>>> nameList = [“Cloudking”,”Rootkit”,”Sam”] >>> nameList [‘Cloudking’, ‘Rootkit’, ‘Sam’] >>>列表有点类似其他语言中的数组,List比普通的数组更灵活,它更像杂货箱,可以存储各种类型的数据。索引方式,跟普通数组的索引方式是一样的。
>>> nameList[0]
'Cloudking'
>>> nameList[1]
'Rootkit'
>>> nameList[-1]
Sam
>>> len(nameList)
3
索引下标是从0开始,可以进行反向索引(-x)。我们还可以通过 len() 函数来计算该List的长度。如果索引超过list的长度,就会出错。
给指定List插入数据的两个函数,分别是append()、insert() 想删除对应的数据则用pop()
>>> nameList.append('Yurli')
>>> nameList
['Cloudking', 'Rootkit', 'Sam', 'Yurli']
>>> nameList.insert(3,"Koke")
>>> nameList
['Cloudking', 'Rootkit', 'Sam', 'Koke', 'Yurli']
>>> nameList.pop()
'Yurli'
>>> nameList
['Cloudking', 'Rootkit', 'Sam', 'Koke']
>>> nameList.pop(3)
'Koke'
>>> nameList
['Cloudking', 'Rootkit', 'Sam']
>>>
我还要告诉你,List内部还能是另一个List。
>>> dataList = [1,[‘jj怪’,’女’],0] >>> dataList [1, [‘jj怪’, ‘女’], 0]tuple在Python中叫元组,跟List类似。但是元组是被锁上的List,直白的说,它的数据一旦定义,就不能被改变。
>>> dataClass = (1,2,3,4)
>>> dataClass[0] = "d"
Traceback (most recent call last):
dataClass[0] = "d"
TypeError: 'tuple' object does not support item assignment
>>> dataClass[0] = 12
Traceback (most recent call last):
dataClass[0] = 12
TypeError: 'tuple' object does not support item assignment
>>>
记住,tuple的定义语法跟list的定义方法是有区别的,前者是()后者是[]。我们试图修改tuple一开始定义的元素,却发生了错误。但是,tuple实际上是可以修改的。tuple原本的元素不能改变,但是它的指向可以改变。
>>> dataClass = (1,2,['x','y'])
>>> dataClass[2][0] = 'a'
>>> dataClass[2][1] = 'b'
>>> dataClass
(1, 2, ['a', 'b'])
由于List本身的指向是会改变的,所以在tuple中,它里面的内容是可以被改变。
dict是用来存储key-value(键-值)类型是数据。现实中我们经常会有这种数据 name:Cloudking 而dict刚好可以用来存储
>> data =
{'name':"Cloudking",'sex':'jj','age':20}
>>> data['name']
'Cloudking'
>>> data['sex']
'jj'
>>>
记住,字典的定义语法,用的是{}花括号。输入key就能查询到相对应的值,如果key不存在,dict就会报错。
可以使用pop(key)来删除指定的key-value。
set很像数学中的集合。它可以像dict那样存储key,但是不能重复。
>>> set1 = set([1,2,3])
>>> set1
{1, 2, 3}
>>> set1.remove(2)
>>> set1
{1, 3}
>>> set1.add(4)
>>> set1
{1, 3, 4}
>>> set1.add(4)
>>> set1
{1, 3, 4}
>>>
可以使用 remove()来删除指定的数据,可以使用 add()来添加元素。
set还可以进行两种操作,分别是交集并集。
>>> set1 = set([1,5,8])
>>> set2 = set([1,7,9])
>>> set1 & set2
{1}
>>> set1 | set2
{1, 5, 7, 8, 9}
怎么样,完全跟我们数学中,集合的交集并集一样吧。
首先我们来说说如何利用特性对list或tuple进行操作。我们可以截取它们一部分的元素:
>>> listTest = ['Cloudking','Rookit','Sam','Keke']
>>> listTest[0:2]
['Cloudking', 'Rookit']
>>> listTest[:2]
['Cloudking', 'Rookit']
>>> listTest[2:]
['Sam', 'Keke']
>>> listTest[2:]
['Sam', 'Keke']
>>> listTest[-2:]
['Sam', 'Keke']
>>> listTest[:-2]
['Cloudking', 'Rookit']
>>> listTest1 = listTest[:]
>>> listTest1
['Cloudking', 'Rookit', 'Sam', 'Keke']
>>> listTest[::2]
['Cloudking', 'Sam']
>>> listTest[1::2]
['Rookit', 'Keke']
>>>
上面这些操作,在Python中称为切片。[x:y] 就是切x~y之间的元素,不包括y; [:x] 且0~x之间的元素,不包括x; [x:] 切x到结尾的元素; [::x]每个x个元素,切一次; [x:y:n] 从x到y,每隔n个就且一次。
高级特性还有另一个,由于list、tuple或是字符串,都是可迭代的对象,所以Python的for循环支持它们进行循环。
>>> listTest = ["jj怪","奶哥","电哥"]
>>> for i in listTest:
print(i)
jj怪
奶哥
电哥
>>>
字符串也可以这样被迭代。
现在让你生成一个列表,从1~100的数字都遍历一遍,你会怎么做?当然是直接for迭代,但有木有更简便的方式呢?有!列表生成式。
>>> list(range(1,100)) #生成1~100列表
>
>>> data = []
>>> for i in range(1,100): #生成1~100列表
data.append(i)
>>> print(data)
>>> [x for x in range(1,100)] #列表生成式
最后那个就是列表生成式,当然,你还可以加条件。
>>> [x for x in range(10,20) if x-5>10]
[16, 17, 18, 19]
可以看出,语法结构是这样的[返回值 循环 条件]
生成器(generator)可以一边运算一边生成,不用一次性就生成,浪费空间。那怎么做呢?其实很简单,跟列表生成式差不多,只是把外面的中括号变成括号。
>>> gen = (x for x in range(10,20) if x-5>10)
[16, 17, 18, 19]
>>> gen = (x for x in range(10,20) if x-5>10)
>>> next(gen)
16
>>> next(gen)
17
看上面的例子,生成之后,可以使用 next() 来提取下一个元素。当没有更多的元素时,抛出StopIteration的错误。为了避免这种异常,通常都是直接用for来遍历。生成器还能有另外一种方式来定义,当一个函数里面含有 yield 这个关键词时,这个函数就是生成器。
>>> data_iter():
n = 1
while True:
n = n + 2
yield n
这个生成器会无限的生成元素,但是每生成一个它就会中断一次,yield就类似中断的意思。
函数跟我们数序概念中的函数是不一样的,这里的函数代表一段特定功能的代码。例如我们之前用到的 print()和input()都是函数。
那么函数有什么作用呢?函数可以提高程序的复用性,可以使我们开发越方便。如果我们没有函数,每一次想要使用print()就得去把函数代码复制到我们函数内,你说有多麻烦?
我们先来看看函数的定义语法,以及函数的调用。
def printboom():
print(“Boom···”)
>>> printboom()
Boom···
def 函数名(): 就是函数的定义语法,接着就是函数的代码了。想要调用哪个函数,直接输入函数名就行了,当然,这是无参函数的调用方法。
有参函数例如abs(x) 会把传入的数值x的绝对值返回。在使用函数之前,需要先了解函数有什么参数,print() 函数也会接受许多不同的数据,并将它们打印出来。
我们在写自己函数的时候,也可以添加会用到的参数。
当然,可以按照自己的需求返回数据
>>> a = [1,2,3,4,5,8,9,6]
>>> add_data(a)
>>> def add_data(a):
total = 0
for i in a:
total += i
return total
>>> print(add_data(a))
38
>>>
return 就是函数用来返回数据的语法
参数类别:默认参数、可变参数、关键字参数、命名关键字参数。(我们一般用的叫位置参数)
>>> def indata(number,address="广州"):
print(number,address)
>>> indata(1)
1 广州
>>> indata(1,"北京")
1 北京
>>>
这样的就叫默认函数,在使用函数的时候你可以不修改address,直接indata(1),地址会默认是”广州”。由于第二次调用函数的时候,默认参数经常都会被改变,所以默认参数必须指向不变对象。
有时候我们不能确定函数参数的数量,我们并不能定义参数的数量,所以Python提供了一种解决方案。在参数前面加一个*,表示这个参数是可变参数,可变参数在函数调用时自动组装为一个tuple。
关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。什么意思呢?有一个软件让你提供自己的信息,但是上面的选项不能满足你,你想表现自己,想添加更多的参数,怎么解决?
>>>def indata(name,age,**kdata):
···
这样一来,你输入好name和age后,还可以继续输入你想要添加的信息,例如: “兴趣”:”打球、敲代码”。不过你需要记住,是dict型数据,而不是简单的list、tuple。
如果要限制关键字参数的名字,就可以用命名关键字参。命名关键字参数必须传入参数名,若命名关键字参数有默认值,则可以不输入。
>>> def indata(name,age,*,sex,score):
print(name,age,sex,score)
>>> indata("Cloudking",20,sex = 'jj',score=100)
Cloudking 20 jj 100
>>> indata("Cloudking",20,sex = 'jj')
Traceback (most recent call last):
indata("Cloudking",20,sex = 'jj')
TypeError: indata() missing 1 required keyword-only argument: 'score'
Python中所有类型的参数都可以随意组合,但参数定义的顺序必须是:必选参数、默认参数、可变参数、命名关键字参数和关键字参数。此外还有一个知识点,函数是可以被作为参数,也可以被作为返回值的。
首先需要了解的是map() 函数接收两个参数,一个是函数,一个是Iterable,map将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator返回。
>>> def total(x): return x*x >>> a = map(total,[1,2,3,4,5]) >>> a >>> list(a) [1, 4, 9, 16, 25]reduce()函数作用在一个序列上,这个函数必须接收两个参数,一个参数是函数,另一个参数是列表。reduce把函数计算的结果继续和序列的下一个元素做累积计算。
def total(x):
return x + y
sumdata = reduce(total,[1,2,3,4,5])
from functools import reduce
def sumdata(x,y):
return x + y
reduce(sumdata,[1,2,3,4,5])
15
其实只要抓住累积 这两个词,就能理解这个函数了。
filter() 函数用于过滤,跟map和reduce这两个函数一样,它也要接受一个函数和一个数列。它把传入的函数依次作用于每个元素,然后根据返回值是True还是False决定保留还是丢弃该元素。
>>> def ifnot(n):
return n+5 > 20
>>> def ifnot(n):
return n+5 > 20
>>> list(filter(ifnot,[2,8,15,16,29]))
[16, 29]
这个程序只保留+5超过20的数值,可见filter相当于一个筛选函数。
闭包 这个概念,在很多编程语言中都有。闭包怎么理解呢?当一个函数里面的属性,在函数返回后,还能被新函数引用,就叫做闭包。
def func(name):
def inner_func(age):
print ('name:',name,'age:',age)
return inner_func
bb = func('Cloudking')
bb(20)
当func函数返回的时候,func函数内的name还是存在的,并没有因为函数的结束而清除。这就产生了一个闭包inner_func,闭包内可以访问这个name变量。
匿名函数,可以用在我们不用显示定义函数的时候。
list(map(lambda x : x + x,[1,2,3,4,5]))
[2, 4, 6, 8, 10]
如果你想要在函数运行的过程中,动态的添加功能,没问题,Python满足你,生成一个“装饰器”(Decorator)。
def Test(func):
def printx(*args,**kw):
print('This is add func')
return func(*args,**kw)
return printx
@Test
def show():
print("Test Over!")
show()
分析一下上面这个例子的结构,在Test函数里面还有一个函数,首先会先放回该内部函数的地址,当函数运行的时候,就会自动再添加这个内部函数的功能。如果你想给一个函数动态添加功能,需要在该函数前面加语法糖(@fun)
偏函数,我们可以利用functools.partial将一个函数的某些参数给固定住。
>>> import functools
>>> max2 = funtools.partial(max,10)
>>> max2 = functools.partial(max,10)
>>> max2(1,5,9,15)
15
max() 这个函数会返回最大的值,而我们使用functools.partial设置了max的一个偏函数max2()。在max2中加入一个参数10,结果如上。
2017/8/25 1:24:21 @author:Cloudking