利用python进行数据分析 | 内建数据结构，函数

一.内建数据结构

1.元组

元组是一种固定长度，不可变的python对象序列

创建元组最简单的办法就是用逗号分隔序列值

#(4,5,6)
tup = 4,5,6
#((4,5,6),(7,8))
tup = (4,5,6),(7,8)
#(4,0,2)
tuple([4,0,2])
#('s','t','r','i','n','g')
tup = tuple('string')
#'s'
tup[0]
#如果元组中的一个对象是可变的，例如列表，你可以在它内部进行修改
tup = (['foo',[1,2],True])
#('foo',[1,2,3],True)
tup[1].append(3)
#可以用+连接元组来生成更长的元组
(1,None,'foo')+(3,0)+('bar')
#将元祖乘以整数，生成含有多份拷贝的元组
('foo','bar')*4

如果你想要将元祖型的表达式赋值给变量，python会对等号右边的值进行拆包

tup = (4,5,6)
a,b,c = tup
#5
b

由于元组的内容和长度无法改变，它的实例方法很少。一个常见的有用方法是count，用于计量某个数值在元组中出现的次数

a = (1,2,3,4,2,2,2,5)
#4
a.count(2)

2.列表

列表的长度是可变的，它所包含的内容也是可以修改的。你可以使用 [ ] 或者list类型函数来定义列表

gen = range(10)
#[0,1,2,3,4,5,6,7,8,9]
list(gen)

#使用append可以将元素添加到列表的尾部
#[0,1,2,3,4,5,6,7,8,9,10]
list.append(10)
#使用insert方法可以将元素插入到指定的列表位置
#[0,8,1,2,3,4,5,6,7,8,9,10]
list.insert(1,8)
#[0,8,2,3,4,5,6,7,8,9,10]
list.pop(2)
#元素可以通过remove移除，该方法会定位第一个符合要求的值并移除它
#[0,2,3,4,5,6,7,8,9,10]
list.remove(8)
#False
12 in list
#[3,None,'foo',4,5,(2,3)]
[3,None,'foo']+[4,5,(2,3)]
#[2,None,'foo',4,3,(2,3)]
x = [2,None,'foo']
x.extend([4,3,(2,3)]
#[1,2,3,4,6]
a = [1,4,6,2,3]
a.sort()
a
#使用切片符号可以对大多数序列类型选取其子集
seq = [2,3,4,5,6,7,8]
#[3,4,5,6]
seq[1:4]
#[2,3,4,10,11,6,7,8]
seq[3:4] = [10,11]
#[2,3,4,10,11]
seq[:5]
#[10,11,6,7,8]
seq[3:]
#[11,6,7,8]
seq[-4:]
#[2,4,11,7]
seq[::2]
#[8,7,6,11,10,4,3,2]
seq[::-1]

3.内建序列函数

①enumerate

list = ['foo','bar','baz']
mapping = {}
for i,v in enumerate(list):
  mapping[v] = i
#{'bar':1,'baz':2,'foo':0}
mapping

②sorted

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

③zip

#zip将列表，元组或其它序列的元素配对，新建一个元组构成的列表
seq1 = ['foo','bar','baz']
seq2 = ['one','two','three']
zipped = zip(seq1,seq2)
#[('foo','one'),('bar','two'),('baz','three')]
list(zipped)
#zip可以处理任意长度的序列，它生成列表长度由最短的序列决定
seq3 = [False,True]
#[('foo','one',False),('bar','two',True)]
list(zip(seq1,seq2,seq3))

④reversed

#[9,8,7,6,5,4,3,2,1,0]
list(reversed(range(10)))

4.字典

dict = {}
d1 = {'a':'some value','b':[1,2,3,4]}
d1[7] = 'an integer'
#{'a':'some value','b':[1,2,3,4],7:'an integer'}
d1
#[1,2,3,4]
d1['b']
#True
'b' in d1
#['a','b',7]
list(d1.keys())
#['some value',[1,2,3,4],'an integer']
list(d1.values())

5.集合

集合是一种无序且元素唯一的容器

集合可以有两种创建方式：通过set函数或者是字面值集与大括号的语法

#{1，2,3}
set([2,2,2,1,3,3])

二.函数

1.定义函数

def add(a,b):
  print("%d" % (a+b))

add(2,3)

'''
有时可能需要一个函数能处理比当初声明时更多的参数，这些参数叫做不定长参数，声明时不会命名
加了星号(*)的变量args会存放所有未命名的变量参数，args为元组
而加**的变量kwargs会存放命名参数，即形如key=value的参数，kwargs为字典
如果很多个值都是不定长参数，可以将缺省参数放到*args的后面
但如果有**kwargs的话，**kwargs必须是最后的
'''
def fun(a,b,*args,**kwargs):
  print("a = %d" % a)
  for key,value in kwargs.items():
    print("key=%s" % value)

#无参数，无返回值
def 函数名():
  语句

#无参数，有返回值(return可以有多个，但只要执行到一个return语句，就意味着这个函数的调用完成)
def 函数名():
  语句
  return 需要返回的数值

'''
调用函数的方式：函数名([实参列表])
如果调用的函数在定义时有形参，那么在调用的时候就应该传递参数
调用时，实参的个数和先后顺序应该和定义函数中要求的一致
如果调用的函数有返回值，那么就可以用一个变量来进行保存这个值
'''

2.匿名（lambda）函数

匿名函数是一种通过单个语句生成函数的方式，其结果是返回值

匿名函数使用lambda关键字定义，该关键字仅表达“我们声明一个匿名函数”的意思

使用lambda保留字定义，函数名就是返回结果

lambda函数用于定义简单的，能够在一行内表示的函数

a = lambda x:x*2

strings=['foo','card','bar','aaaa','abab']
strings.sort(key=lambda x:len(set(list(x))))
#['aaaa','foo','abab','bar','card']
strings

 3.将函数放到模块中

'''
用import语句导入整个函数模块
导入格式：import 函数模块名
调用模块文件中的函数格式：模块名.函数名

用import语句导入指定函数
导入格式：from 模块名 import 函数名1，函数名2...

用import语句导入所有函数
导入格式：from 模块名 import *

在导入模块，函数的过程中发现模块名，函数名过长，可以通过as语句定义别名来解决
格式：模块名[函数名] as 别名

模块搜索路径
当函数模块文件多变时，需要把函数文件独立放到一个子文件夹中，方便统一管理
但是在不同文件夹下的模块调用需要解决路径问题，不然会报“找不到模块”英文提示，且程序无法正常运行
可以用sys.path方法指定需要访问的函数模块文件
'''

4.递归函数

递归函数就是自己引用自己，递归函数就是在函数里自己调用自己

递归的两个条件

基线条件：问题可以被分解为最小的问题，当满足基线条件的时候，再去解决问题

递归条件：将问题继续分解的条件

def fun():
  fun()
fun()

5.值传递与引用传递

值传递适合于不可变类型的实参：字符串，数字，元组

引用传递适合于可变类型的实参：列表，字典

#值传递时，当函数的形参发生变化不会影响实参的值
def add(x,y):
  return x+y
x=1
y=2
print(add(x,y))

#引用传递时，当函数的形参发生变化会影响实参的值
def show(a,b):
  print(b)
def print_n()
  print("hello")
show(print_n,"world")