《利用Python进行数据分析.第2版》笔记一（2、3章）_python数据分析(第2版) 完整高清版+笔记+随书源码-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_24994587/article/details/125988780

本文整理自： https ://www.jianshu.com/p/04d180d90a3f

大家可以自行前往学习。

第2章 python语法基础

1、用 isinstance 函数检查对象是某个类型的实例：

In [21]: a = 5

In [22]: isinstance(a, int)
Out[22]: True

isinstance 可以用类型元组，检查对象的类型是否在元组中：

In [23]: a = 5; b = 4.5

In [24]: isinstance(a, (int, float))
Out[24]: True

In [25]: isinstance(b, (int, float))
Out[25]: True

2、引入

假设有以下模块：

# some_module.py
PI = 3.14159

def f(x):
    return x + 2

def g(a, b):
    return a + b

如果想从同目录下的另一个文件访问 some_module.py 中定义的变量和函数，可以/：

import some_module
result = some_module.f(5)
pi = some_module.PI

或者：

from some_module import f, g, PI
result = g(5, PI)

使用 as 关键字，你可以给引入起不同的变量名：

import some_module as sm
from some_module import PI as pi, g as gf

r1 = sm.f(pi)
r2 = gf(6, pi)

3、许多 python 对象使用 str 函数可以被转化为字符串：

In [61]: a = 5.6

In [62]: s = str(a)

In [63]: print(s)
5.6

将两个字符串合并，会产生一个新的字符串：

In [71]: a = 'this is the first half '

In [72]: b = 'and this is the second half'

In [73]: a + b
Out[73]: 'this is the first half and this is the second half'

第3章 python的数据结构、函数和文件

3.1 数据结构和序列

元组

元组是一个固定长度，不可改变的python序列对象。创建元组的最简单方式，是用逗号分隔一列值：

In [1]: tup = 4, 5, 6

In [2]: tup
Out[2]: (4, 5, 6)

当用复杂的表达式定义元组，最好将值放到圆括号内，如下所示：

In [3]: nested_tup = (4, 5, 6), (7, 8)

In [4]: nested_tup
Out[4]: ((4, 5, 6), (7, 8))

用 tuple 可以将任意序列或迭代器转换成元组：

In [5]: tuple([4, 0, 2])
Out[5]: (4, 0, 2)

In [6]: tup = tuple('string')

In [7]: tup
Out[7]: ('s', 't', 'r', 'i', 'n', 'g')

可以用方括号访问元组中的元素。序列是从0开始的：

In [8]: tup[0]
Out[8]: 's'

元组中存储的对象可能是可变对象。一旦创建了元组，元组中的对象就不能修改了。

如果元组中的某个对象是可变的，比如列表，可以在原位进行修改：

In [9]: tup = tuple(['foo', [1, 2], True])

In [10]: tup[2] = False
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-10-c7308343b841> in <module>()
----> 1 tup[2] = False
TypeError: 'tuple' object does not support item assignment

In [11]: tup[1].append(3)

In [12]: tup
Out[12]: ('foo', [1, 2, 3], True)

可以用加号运算符将元组串联起来：

In [13]: (4, None, 'foo') + (6, 0) + ('bar',)
Out[13]: (4, None, 'foo', 6, 0, 'bar')

元组乘以一个整数，像列表一样，会将几个元组的复制串联起来：

In [14]: ('foo', 'bar') * 4
Out[14]: ('foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'bar')

对象本身并没有被复制，只是引用了它。

拆分元组

。。。

python新增了更多高级的元组拆分功能，允许从元组的开头“摘取”几个元素。它在变量前加 * ，这用于抓取任意长度列表的位置参数：

In [29]: values = 1, 2, 3, 4, 5

In [30]: a, b, *rest = values

In [31]: a, b
Out[31]: (1, 2)

In [32]: rest
Out[32]: [3, 4, 5]

列表

与元组对比，列表的长度可变、内容可以被修改。你可以用方括号定义，或用 list 函数：

In [36]: a_list = [2, 3, 7, None]

In [37]: tup = ('foo', 'bar', 'baz')

In [38]: b_list = list(tup)

In [39]: b_list
Out[39]: ['foo', 'bar', 'baz']

In [40]: b_list[1] = 'peekaboo'

In [41]: b_list
Out[41]: ['foo', 'peekaboo', 'baz']

添加和删除元素

可以用 append在列表末尾添加元素：

In [45]: b_list.append('dwarf')

In [46]: b_list
Out[46]: ['foo', 'peekaboo', 'baz', 'dwarf']

insert 可以在特定的位置插入元素：

In [47]: b_list.insert(1, 'red')

In [48]: b_list
Out[48]: ['foo', 'red', 'peekaboo', 'baz', 'dwarf']

串联和组合列表

与元组类似，可以用加号将两个列表串联起来：

In [57]: [4, None, 'foo'] + [7, 8, (2, 3)]
Out[57]: [4, None, 'foo', 7, 8, (2, 3)]

如果已经定义了一个列表，用 extend 方法可以追加多个元素：

In [58]: x = [4, None, 'foo']

In [59]: x.extend([7, 8, (2, 3)])

In [60]: x
Out[60]: [4, None, 'foo', 7, 8, (2, 3)]

切片

用切片可以选取大多数序列类型的一部分，切片的基本形式是在方括号中使用 start：stop：

In [73]: seq = [7, 2, 3, 7, 5, 6, 0, 1]

In [74]: seq[1:5]
Out[74]: [2, 3, 7, 5]

切片的起始元素是包括的，不包含结束元素。因此，结果中包含的个数是 stop-start。

start 或 stop 都可以被省略，省略之后，分别默认序列的开头和结尾：

In [77]: seq[:5]
Out[77]: [7, 2, 3, 6, 3]

In [78]: seq[3:]
Out[78]: [6, 3, 5, 6, 0, 1]

负数表明从后向前切片（最后一个元素为-1）：

In [79]: seq[-4:]
Out[79]: [5, 6, 0, 1]

In [80]: seq[-6:-2]
Out[80]: [6, 3, 5, 6]

字典

字典可能是Python最为重要的数据结构。它更为常见的名字是哈希映射或关联数组。它是键值对的大小可变集合，键和值都是Python对象。创建字典的方法之一是使用尖括号，用冒号分隔键和值：

In [101]: empty_dict = {}

In [102]: d1 = {'a' : 'some value', 'b' : [1, 2, 3, 4]}

In [103]: d1
Out[103]: {'a': 'some value', 'b': [1, 2, 3, 4]}

你可以像访问列表或元组中的元素一样，访问、插入或设定字典中的元素：

In [104]: d1[7] = 'an integer'

In [105]: d1
Out[105]: {'a': 'some value', 'b': [1, 2, 3, 4], 7: 'an integer'}

In [106]: d1['b']
Out[106]: [1, 2, 3, 4]

你可以用检查列表和元组是否包含某个值的方法，检查字典中是否包含某个键：

In [107]: 'b' in d1
Out[107]: True

keys和values是字典的键和值的迭代器方法。虽然键值对没有顺序，这两个方法可以用相同的顺序输出键和值：

In [117]: list(d1.keys())
Out[117]: ['a', 'b', 7]

In [118]: list(d1.values())
Out[118]: ['some value', [1, 2, 3, 4], 'an integer']

关于集合 set 请自行前往查看

返回多个值

函数可以返回多个值：

def f():
    a = 5
    b = 6
    c = 7
    return a, b, c

a, b, c = f()

该函数其实只返回了一个对象，也就是一个元组，最后该元组会被拆包到各个结果变量中。

更多内容，参阅python官方文档。