[Python] 基本数据类型

列表（list）

• 动态，长度大小不固定，可随意增、删、改元素（链表）
• 可放置任意数据类型
• 支持负数索引，切片操作

t = timeit.timeit(stmt="x=[1,2,3,4,5,6]", number=100000)
print(t)

元组（tuple）

• 静态，长度大小固定，无法增、删、改元素（数组）
• 可放置任意数据类型
• 支持负数索引，切片操作

t = timeit.timeit(stmt="x=(1,2,3,4,5,6)", number=100000)
print(t)

字典（dict）

• 由键--值对组成的有序元素的集合（哈希表）
• 键不可变，不重复
• 查找、添加、删除操作复杂度O(1)
• 底层哈希表中存储哈希值、键、值三个元素

d = {'b':1,'a':2,'c':10}
d_sorted_by_key = sorted(d.items(),key=lambda x:x[0])
d_sorted_by_value = sorted(d.items(),key=lambda x:x[1])
d_sorted_by_key
d_sorted_by_value

 

集合（set）

• 无序元素的集合（哈希表）
• 元素不可变，不重复
• 查找、添加、删除操作复杂度O(1)
• 底层哈希表中存储哈希值、键、值三个元素

import time

def find_unique_price_using_set(products):
    unique_price_set = set()
    for _, price in products:
        unique_price_set.add(price)
    return len(unique_price_set)

def find_unique_price_using_list(products):
    unique_price_list = []
    for _, price in products:
        if price not in unique_price_list:
            unique_price_list.append(price)
    return len(unique_price_list)

id = [x for x in range(0,10000)]
price = [x for x in range(20000, 30000)]
products = list(zip(id,price))

start_using_list = time.perf_counter()
find_unique_price_using_list(products)
end_using_list = time.perf_counter()
print("time elapse using list:{}".format(end_using_list - start_using_list))

start_using_list = time.perf_counter()
find_unique_price_using_set(products)
end_using_list = time.perf_counter()
print("time elapse using set:{}".format(end_using_list - start_using_list))

字符串（string）

• 不可变，改变字符串就要创建新的字符串
• 分割

def query_data(namespace, table):
    print("data in " + table + " at " + namespace)
    
path = 'hive://ads/traning_table'
namespace = path.split('//')[1].split('/')[0]
table = path.split('//')[1].split('/')[1]
data = query_data(namespace,table)

• 格式化输出

name = input('your name:')
gender = input('you are a boy?(y/n)')

welcome_str = 'Welcome to the matrix {prefix}{name}.'
welcome_dic = {
    'prefix' : 'Mr. ' if gender == 'y' else 'Mrs. ',
    'name' : name
}

print('authorizing...')
print(welcome_str.format(**welcome_dic))

• 数据清洗

import re

def parse(text):
    # 去除标点符号和换行符
    text = re.sub(r'[^w]',' ',text)
    # 转为小写
    text = text.lower()
    # 生成所有单词的列表
    word_list = text.split(' ')
    # 去除空白单词
    word_list = filter(None, word_list)
    # 生成单词和词频的字典
    word_cnt = {}
    for word in word_list:
        if(word not in word_cnt):
            word_cnt[word] = 0;
        word_cnt[word] += 1
    #按词频倒序排序
    sorted_word_cnt = sorted(word_cnt.items(),key=lambda kv:kv[1],reverse=True)
    return sorted_word_cnt

with open('in.txt','r') as fin:
    text = fin.read()
    
word_and_freq = parse(text)

with open('out.txt','w') as fout:
    for word, freq in word_and_freq:
        fout.write('{} {}
'.format(word,freq))

...（输入为马丁路德金的《I have a dream》）

• json
  • dumps()：打包（序列化），字典->字符串
  • loads()：解包（反序列化），字符串->字典

import json
 
params = {
    'symbol':'123456',
    'type':'limit',
    'price':123.4,
    'amount':23
}

params_str = json.dumps(params)
print('after json serialization')
print('type of params_str = {}, params_str = {}'.format(type(params_str),params_str))

original_params = json.loads(params_str)
print('after json deserialization')
print('type of original_params = {}, original_params={}'.format(type(original_params),original_params))