Python 3.0进阶

---

@author:云都小生(Cloudking)

目录

• 高级数据类型（List、tuple、dict、set）
• 
  
• 高级特性
• 
  
• 函数
• 
  
• 高阶函数
• 
  

  高级数据类型

  ---

  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() 函数也会接受许多不同的数据，并将它们打印出来。
  
  我们在写自己函数的时候，也可以添加会用到的参数。

  >>> def printdata(name,sex,age): print(“这位同学的数据是:%s %s %s” % (name,sex,age)) >>> printdata(“Cloudking”,”jj”,”20”) 这位同学的数据是:Cloudking jj 20

  当然，可以按照自己的需求返回数据

  >>> 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

  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