乐趣区

关于python:利用-Python-进行数据分析-1-数据结构函数和文件

本文是我集体学习《利用 Python 进行数据分析》一书的笔记。整个系列于今日起连载。

1.1 数据结构

Python 的根本数据结构包含元组、列表、字典、汇合,此外还有一些非凡的数据结构(如 range 对象、字符串等)。

1.1.1 元组(tuple)

什么是元组?元组是固定长度、内容不可扭转的序列。

如何创立元组?

# 用逗号分隔是创立元组最简略的办法
tup = 1, 2, 3
tup = "a", "b", "any"
tup = (2, 3, 4), (5, 6)

# 用 tuple() 能够将一个序列转换为元组
tup = tuple([2, 3, 4])

元组的内容是不可扭转的,这句话如何了解呢?

 in: tup
out: (2, 3, 4)

 in: tup[0] = 5   # 该行命令是无奈运行的,这是因为元组内的值是不能扭转的

# 然而,如果元组内的某对象是能够扭转的,能够在其对应地位上进行批改
 in: tup = (1, [1, 2, 3], 2)
     tup[1].append(4)  
     tup
out: (1, [1, 2, 3, 4], 2)

尽管元组的内容是不可扭转的,然而元组能够串联和拆分。

# 串联元组
(1, 2, 4) + ('haha', [2, 3], True)   # 利用加号能够串联元组
(1, 2) * 3   # 利用乘号能够对元组进行复制串联

# 拆分元组
a, b, c = (1, 2, 3)
a, b, (c, d) = (1, 2, (3, 4))  # 甚至元组内的元组也会被拆分

 in: info = 'name', 'age', 'job', 'zipcode'
     a, b, *_ = info   # 能够从元组的结尾选取想要的值,其余的值保留在 *_ 中
     print('a={}, b={}'.format(a, b))
out: a=name, b=age

元组的办法不多,罕用的是 count()。

 in: num = 1, 2, 2, 2, 3, 4, 5
     num.count(2)   # count() 能够用于计数:计算元组对象中某个值呈现的总次数
out: 3

1.1.2 列表(list)

与元组不同,列表的长度是可变的,内容也能够被批改。

如何创立列表?

list_fruit = ['apple', 'banana', 'orange', 'orange']
tup = 'apple', 'banana', 'orange', 'orange'
list_fruit = list(tup)   # 能够利用 list() 将其余序列转换为列表

列表的可变性,让咱们可能对列表进行诸多操作。

  • 向列表中增加或移除元素:
# 增加元素
list_fruit.append('pear')  # 在列表的末端增加元素
list_fruit.insert(1, 'durian')  # 在列表的特定地位增加元素
# insert 比 append 计算量大,因为插入后,后续元素的援用必须在外部迁徙

# 移除元素
list_fruit.pop(1)  # 移除并返回指定地位的元素
list_fruit.remove('orange')  # 移除指定的元素(从第一个开始,一次移除一个)# 列表的串联
list_fruit + ['melon', 'grape']
list_fruit.extend(['durian', 'watermelon'])  # 能够利用 extend() 追加多个元素
# 加法计算量更大,因为加法创立了一个新的列表,而 extend() 是在原列表上追加元素
  • 排序
# sort() 能够将一个列表原地排序(而不创立新的对象)in: a = [2, 4, 6, 3, 1]
     a.sort()  
     a
out: [1, 2, 3, 4, 6]   # 默认是升序排列
 in: b = ['hah', 'kdjalkdjalk', 'd', 'ldkld']
     b.sort(key=len)   # 能够通过指定 key 参数,按元素长度排列
     b
out: ['d', 'hah', 'ldkld', 'kdjalkdjalk']

# sorted() 也能够排序,但不会扭转原序列,而是创立一个新列表
 in: a = [1, 5, 7, 3, 4]
     print('sorted_a =',sorted(a))
     print('a =',a)
out: sorted_a =  [1, 3, 4, 5, 7]
     a =  [1, 5, 7, 3, 4]
  • 切片
 in: seq = [1, 2, 4, 6, 2, 4, 8, 9]
     seq[1:4]
out: [2, 4, 6]

 in: seq[0:2] = [100, 60]   # 能够间接对切片赋值,会扭转原来的列表
     seq
out: [100, 60, 4, 6, 2, 4, 8, 9]

 in: seq[::2]  # 在第二个冒号前面应用 step,能够隔一段距离取元素
     seq[::-1]  # 这种办法能够把列表颠倒过去
out: [100, 4, 2, 8]
     [9, 8, 4, 2, 6, 4, 60, 100]

# PS: 元组也能够切片 :)
  • enumerate() 序列函数
# 在迭代时,咱们经常心愿通晓以后项的序号,因而咱们可能会这样写:i = 0
for value in list_fruit:
    print('第 {} 个元素是:{}'.format(i, value))
    i += 1

# 上述代码能够被简化:for i, value in enumerate(list_fruit):   # 能够返回 (i, value) 款式的元组
    print('第 {} 个元素是:{}'.format(i, value))
  • zip() 成对组合
# zip() 能够将多个序列成对组合成一个 zip 对象(元祖列表)
 in: seq1 = [1, 2, 3]
     seq2 = ['happy', 'sad', 'angry', 'peace']
     zipped = zip(seq1, seq2)   
     zipped
out: <zip object at 0x00000149BAC687C0>   # 这是一个迭代器,能够调用 __next__()

 in: list(zipped)   # 利用 list() 将迭代器实体化
out: [(1, 'happy'), (2, 'sad'), (3, 'angry')]   # 能够看到,zip 后元组的个数取决于最短的序列
  • reversed() 颠倒序列
 in: seq1 = [1, 2, 3]
     r = reversed(seq1)   # reversed 函数生成了一个 list_reverseiterator 对象——从后向前迭代的一个迭代器
     list(r)   # 想看到内容,还是须要应用 list() 将迭代器对象实体化
out: [3, 2, 1]

1.1.3 字典(dict)

字典的用法我记录得较为零散,间接列举在上面:

# 能够用 in 查看字典中是否蕴含某个键
 in: dict_test1 = {'a': 'hahaha', 'b': [1, 3, 4],3:(12,3)}
     'a' in dict_test1
out: True

# 将键值移出字典
del dict_test1['b']   # del 能够删除一对键值
dict_test1.pop(3)   # pop() 能够删除一对键值,并返回被删除的值

# 失去键列表和值列表
list(dict_test1.keys())  # 学会应用 list() 函数,能够将一些非凡序列实体化
list(dict_test1.values())
# dict_test1.keys() 失去的是一个 dict_keys 序列,它不是一个 list,不能用下标拜访
keys = dict_test1.keys()
keys[0]   # 该条命令不能运行
list(keys)[0]   # 这样才能够  

# 字典的更新
# update 函数能够更新字典(存在的键,值被替换;不存在的键,追加新的键值)in: d = {'a':123,'b':456}
     d.update({'b': 789, 'c': '更新'})  
out: {'a': 123, 'b': 789, 'c': '更新'}

1.1.4 汇合(set)

汇合是一个无序的、不可反复的元素集。其概念相似于数学中的汇合,能够进行合并、交加等数学运算。

# 创立汇合
 in: {2, 2, 2, 1, 3, 3}
     set([2, 2, 2, 1, 3, 3])   # set() 能够把其余序列转为汇合
out: {1, 2, 3}   # 汇合是不可反复的

a = {1, 2, 3, 4, 5}
b = {3, 4, 5, 6, 7, 8}
# 并集
a.union(b)
a | b
# 交加
a.intersection(b)
a & b

1.1.5 range 对象

range() 是在 for 循环中使用很频繁的函数,我在测试代码的时候偶尔发现,range() 建设的对象既不是元组,也不是列表,而是独特的 range 对象。

range 对象像元组一样,其内容是不可批改的;但 range 对象不能像元组一样存储不同类型的内容,只能存储一个等差数列。

range 对象、字符串、元组、列表、字典、汇合,都是 可迭代的对象 。咱们能够应用 iter() 建设一个 迭代器

# 以 range 对象为例
 in: a = range(2)
     iter_test = iter(a)   # 基于可迭代的对象,创立一个迭代器
     iter_test   
out: <range_iterator object at 0x00000149BABF42D0>

 in: iter_test.__next__()   # 迭代器都有 __next__() 办法,能够返回下一个元素
out: 0

 in: iter_test.__next__()
out: 1

 in: iter_test.__next__()
out: Traceback (most recent call last):
     File "<input>", line 1, in <module>
     StopIteration   # 迭代器是一次性应用的,从头迭代到尾,而后就不能再迭代了

for 循环的实质就是基于可迭代的对象建设一个迭代器,顺次迭代到开端。

1.1.6 列表推导式

能够用列表推导式简化 for 循环代码:

 in: string = ['a', 'apple', 'orange', 'banana']
     [i.upper() for i in string if len(i) > 2]
out: ['APPLE', 'ORANGE', 'BANANA']

推导式还能够嵌套:

 in: all_data = [['Eureka', 'Nirvash', 'Landon'], ['Bill', 'Steve']]
     [name for names in all_data for name in names if len(name) > 5]
out: ['Eureka', 'Nirvash', 'Landon']

1.2 函数

Python 中的函数有几个非凡的应用办法:

# 函数能够返回多个值
def f():
    a = 5
    b = 6
    c = 7
    return a, b, c
a, b, c = f()

# Lambda 函数(匿名函数)def short_function(x):
    return x * 2
equiv_anon = lambda x: x * 2   # 这个匿名函数和下面的惯例函数有雷同的作用

# 函数作为参数传递到另一个函数
def apply_to_list(some_list, f):   # 此处的 f 是一个函数
    return [f(x) for x in some_list]
ints = [4, 0, 1, 5, 6]
apply_to_list(ints, lambda x: x * 2)   # 此处咱们把一个匿名函数作为参数传进去了

1.3 文件操作

Python 中能够新建、关上本地文件。我更偏好上面这种形式:

with open('tmp.txt', 'a') as f:   # a:追加模式
    f.write('add some words.')
退出移动版