Python数据分析笔记----第三章

1.数据结构和序列

1.1元组

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

1.1.1元组的创建

几种创建元组的方式

• In [1]: x = 1,2,3
  
  In [2]: x
  Out[2]: (1, 2, 3)
  
  

• In [3]: nested_tup = (1,2),(3,4)
  
  In [4]: nested_tup
  Out[4]: ((1, 2), (3, 4))
  

• 使用tuple()函数将任意序列或迭代器转换为元组

In [5]: tuple('zhangfan')
Out[5]: ('z', 'h', 'a', 'n', 'g', 'f', 'a', 'n')

In [6]: tuple([1,2,3,4])
Out[6]: (1, 2, 3, 4)

1.1.2注意点：

• 虽然对象元组中存储的对象，其自身是可以改变的，但是元组一旦创建，各个位置上的对象是无法被修改的

  In [9]: a = tuple(['foo',[1,2],True])
  
  In [10]: a[0] = 'zhangfan'
  ---------------------------------------------------------------------------
  TypeError                                 Traceback (most recent call last)
  <ipython-input-10-42b591950580> in <module>()
  ----> 1 a[0] = 'zhangfan'
  
  TypeError: 'tuple' object does not support item assignment
  
  In [11]: a[1].append(3)
  
  In [12]: a[2] = False
  ---------------------------------------------------------------------------
  TypeError                                 Traceback (most recent call last)
  <ipython-input-12-f7414e7f4a16> in <module>()
  ----> 1 a[2] = False
  
  TypeError: 'tuple' object does not support item assignment
  

• 元组支持加法和数乘，即元组和元组可以做加法，元组可以和一个整数进行乘法

• 元组拆包

  In [13]: a
  Out[13]: ('foo', [1, 2, 3], True)
  
  In [14]: b,c,d = a
  
  In [15]: b,c,d
  Out[15]: ('foo', [1, 2, 3], True)
  

• 拆包的特殊用法：*rest可以用来匹配剩下来没有匹配的所有对象，并以列表的形式返回

  In [16]: values = [1,2,3,4]
  
  In [18]: a,b,*rest = values
  
  In [19]: rest
  Out[19]: [3, 4]
  

1.1.3元组方法

由于元组的内容和长度是无法改变的，因此实例方法很少，比较常用的有一个count()方法，用来计量某个数组在元组中出现的次数

In [21]: a = [1,1,1,1,2,6,7,7,8,8,9,9,9]

In [22]: a.count()
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-22-f11c6a8bc4f8> in <module>()
----> 1 a.count()

TypeError: count() takes exactly one argument (0 given)

In [23]: a.count(1)
Out[23]: 4

1.2列表

列表的长度可变，所包含的内容可以修改

1.2.1列表的创建

• []
• list()

1.2.2常用方法

• append()追加元素

• ls.insert(index,element)，在特定位置插入元素

  In [24]: ls = [1,2,3]
  
  In [25]: ls.insert(3,4)#在下标为3的地方插入整数4
  
  In [26]: ls
  Out[26]: [1, 2, 3, 4]
  

• ls.pop(index)，删除特定位置上的元素

  In [26]: ls
  Out[26]: [1, 2, 3, 4]
  
  In [27]: ls.pop(1)
  Out[27]: 2
  
  In [28]: ls
  Out[28]: [1, 3, 4]
  

• ls.remove(element)，删除第一个匹配element的元素

  In [28]: ls
  Out[28]: [1, 3, 4]
  
  In [29]: ls.remove(3)
  
  In [30]: ls
  Out[30]: [1, 4]
  

• in操作

• not in 操作

• 连接与联合

  连接：用+号将两个列表连接，形成一个新的列表，会产生新对象，效率低一些

  联合：通过ls1.extend(ls2),来联合两个列表，会改变ls1,但是不会产生新对象，效率高一些

  In [30]: ls
  Out[30]: [1, 4]
  
  In [31]: ls +[2,3]#列表的连接
  Out[31]: [1, 4, 2, 3]
  
  In [32]: ls#列表的连接不会改变原来的列表
  Out[32]: [1, 4]
  
  In [33]: ls.extend([2,3])#列表的联合
  
  In [34]: ls#联合会改变原来的列表
  Out[34]: [1, 4, 2, 3]
  

• ls.sort()，对列表进行排序，会改变原来的列表，不会产生新对象，注意与内置函数sorted()函数的区别

  其中sort()函数有一个参数key，传入函数的名称，可以用来表示排序的依据

  In [34]: ls
  Out[34]: [1, 4, 2, 3]
  
  In [35]: ls.sort()
  
  In [36]: ls
  Out[36]: [1, 2, 3, 4]
  
  In [37]: ls2 = ['dfasdfds','dfasdfadfasfa','dfsa','dsfadfasfsadfasdfs']
  
  In [38]: ls2.sort()
  
  In [39]: ls2
  Out[39]: ['dfasdfadfasfa', 'dfasdfds', 'dfsa', 'dsfadfasfsadfasdfs']
  
  In [40]: ls2.sort(key=len)#传入len这个函数，表示按照字符串的长度来排序
  
  In [41]: ls2
  Out[41]: ['dfsa', 'dfasdfds', 'dfasdfadfasfa', 'dsfadfasfsadfasdfs']
  

  sorted(ls)会产生一个新对象及新列表，不会改变原来的列表

1.2.3列表的切片

In [41]: ls2
Out[41]: ['dfsa', 'dfasdfds', 'dfasdfadfasfa', 'dsfadfasfsadfasdfs']

In [42]: ls2[2:4]
Out[42]: ['dfasdfadfasfa', 'dsfadfasfsadfasdfs']

In [43]: ls2[::1]
Out[43]: ['dfsa', 'dfasdfds', 'dfasdfadfasfa', 'dsfadfasfsadfasdfs']

In [44]: ls2[:2]
Out[44]: ['dfsa', 'dfasdfds']

In [45]: ls2[::2]#每隔两个取一个
Out[45]: ['dfsa', 'dfasdfadfasfa']

1.3内建序列函数

1.3.1enumerate()

for i, value in enumerate(collection):
    #循环体
    #i表示循环的下标，value表示collection中的值

1.3.2sorted()

与ls.sort()用法一致，但是会产生一个新对象，不会改变原来的列表

1.3.3zip()

将元组、列表或其他序列的元素配对

In [67]: seq1
Out[67]: ['foo', 'bar', 'baz']

In [68]: seq2
Out[68]: ['one', 'two', 'three']

In [69]: x = list(zip(seq1,seq2))#配对

In [70]: x
Out[70]: [('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

In [71]: m,n = zip(*x)#拆分

In [72]: m,n
Out[72]: (('foo', 'bar', 'baz'), ('one', 'two', 'three'))

1.3.4reversed()

翻转排列列表，reversed()是一个生成器，如果没有实例化（如使用list或for循环），它并不会产生一个倒序的列表

1.4字典

别名：哈希表或关联数组

• in操作可以用来判断字典中是否存才某个键
• del d1[key]用来删除某个键值对
• d1.pop(key)用来删除某个键值对，并返回删除的键值对的值
• d1.update(d2),用来合并两个字典
• d1.keys()和d1.values()分别以列表的形式返回字典的键和值
• value = d1.get(key,default_value),从一个字典中按照key查找某个值，找到就返回找到的值，否则返回default_value
• 字典的值可以是任何的Python类型，但是字典的键一定是不可变类型，如标量或元组（此时要求元组内的对象也必须是不可变对象）
• 可以hash()化的对象就是不可变对象

1.5集合

• set()
• {}
• python 集合操作
• a.union(b) or a|b 集合的并
• a.intersection(b) or a&b 集合的交
• 集合的元素也必须是不可变的
• a.issubset(b) a是否是b的子集合
• a.issuperset(b) a是否是b的超集

1.6map(函数名，序列)

对序列中的每个元素，调用这个函数

In [73]: string = ['a','bb','ccc','dddd','eee']

In [75]: set(map(len,string))
Out[75]: {1, 2, 3, 4}

1.7推导式

[expr for val in collection if condition]

对元组，集合，字典等序列都可以使用推导式，推导式可以嵌套

1.8函数是对象

funcs = [len,sorted,enumerate]
for func in funcs:
    func()#可以直接这样调用函数

1.9匿名函数

func = lambda x : x*2

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

1.10科里化

从已有的函数中衍生出新函数，即在函数内部调用另外一个函数

1.11生成器

构造生成器的-----yield

def squares(n=10):
    for i in range(n):
        yield print(i)
#将return 换成了yield就行了

在调用生成器的时候，代码并不会执行，只有当你请求生成器中的元素是，代码才会执行

使用生成器能够节省内存，减小电脑内存的开销

2.文件与操作系统

Python文件操作

• 获取当前的路径

  #第一种，只适用于IPython和Jupyter
  #魔术命令
  %pwd
  
  #第二种，通用
  import os
  os.getcwd()