1、Python 变量

变量存储在内存中的值。

每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

Python 中的变量赋值不需要类型声明。

等号（=）用来给变量赋值。

stockName = 'BABA' # string
stockPrice = 11.11 # float
volume = 1111 # int

stockName

'BABA'

2、 Python数值

数字(Number)

最常用的数字类型包括整型数(int),浮点型(float),正负数皆可。

整数型(int)

type(-123456)

int

浮点型(float)

type(-11.11)

float

布尔值(Boolean)

主要用于判断真假，True代表真，False代表假。

price = 11.11
type(price>10)

bool

3、Python序列(有顺序)

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

序列数据类型：

• 字符串(String)

• 列表(List)

• 元组(Tuple)

3_1 字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。用引号限制起来。

DaYu = '大鱼是你身边No_1的QuantitativeTrader'

print(type(DaYu))

<class 'str'>

print(DaYu[1])

鱼

字符串运算符

+/ */ in/ not in

a = 'Hello'
b = 'Quant'
a+' '+b

'Hello Quant'

a*2

'HelloHello'

if 'Q'not in a:
    print('Yes')
else:
    print('No')

Yes

字符串格式化

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

Channel = '%s used %d-year to make %.2f dollars.'% ('Channel', 5.5, 9999.99123456)

字符串内建函数

Channel.count('9')

6

Channel.find('a')

2

StockList = ['600036.SH', '000001.SZ']
for s in StockList:
    if s.startswith('6'):
        print('6开头：',s)
    elif s.endswith('SZ'):
        print('SZ股票：',s)

6开头： 600036.SH
SZ股票： 000001.SZ

print('Hello{}{}'.format(' ', 'Quant'))

Hello Quant

print('Hello{1}{0}'.format('!!!', 'Quant'))

HelloQuant!!!

print('Hello{Name1}{Mark1}'.format(Mark1='!!!', Name1='Quant'))

HelloQuant!!!

factor = ['pe', 'pb', 'roe']
# 'pe,pb,roe'
factor_str = ','.join(factor)

factor_str.split(',')

['pe', 'pb', 'roe']

3_2 列表

列表的数据项不需要具有相同的类型

列表中的元素可被修改

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

l = [6, 'Quant', 11.11]

l[1:]

['Quant', 11.11]

l[0] = 666

l

[666, 'Quant', 11.11]

列表添加

append/insert/extend

l.append('Trader')

l.insert(0, 6)

l

[6, 666, 'Quant', 11.11, 'Trader']

l.extend(['strategy', 1111])

l

[6, 666, 'Quant', 11.11, 'Trader', 'strategy', 1111]

列表删除

remove(value)/pop(index)/del

l.remove(6)

l.pop(-1)

1111

del l[0:3]

l

['Trader', 'strategy']

3_3 元组

元组是一系列Python数据类型安装顺序组成的序列。用小括号表征。

元组中的元素不可变。

t = (6, 'Quant', 11.11)

t[0] = 666

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-81-7407f8ac265b> in <module>()
----> 1 t[0] = 666


TypeError: 'tuple' object does not support item assignment

t+('Trader', 1111)

(6, 'Quant', 11.11, 'Trader', 1111)

4 - 映射 (键值对应，无序)

字典

字典是非常实用的数据结构，它包括了多组键(Key):值(Value)。字典用{}表示。

d = {}
d['Apple'] = 150
d['BABA'] = 200

d['Apple']

150

d.keys()

dict_keys(['Apple', 'BABA'])

d.values()

dict_values([150, 200])

字典读取

dict.get(key, default=None) | 返回指定键的值，如果值不在字典中返回default值

d.get('Tencent', 100)

100

d

{'Apple': 150, 'BABA': 200}

添加字典

dict.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

dict.update({key : value})

d.setdefault('Tencent',100)

100

d.update({'BIDU':500})

d

{'Apple': 150, 'BABA': 200, 'Tencent': 100, 'BIDU': 500}

字典修改

d['Apple']=50

d

{'Apple': 50, 'BABA': 200, 'Tencent': 100, 'BIDU': 500}

字典删除

d.pop('BABA')

200

d

{'Apple': 50, 'Tencent': 100, 'BIDU': 500}

del d['Tencent']

d

{'Apple': 50, 'BIDU': 500}

字典迭代

pool = [k for k,v in d.items()]

用序列创建字典

dict.fromkeys(seq[, val]) | 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值

d.fromkeys(pool, 1/len(pool))

{'Apple': 0.5, 'BIDU': 0.5}

5. 集合

函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

x = set('BABA')
y = set(['BABA', 'APPLE', 'BABA'])
z = set([1,2,3,4,5,6,6,6,6,6])

无序去重

x

{'A', 'B'}

y

{'APPLE', 'BABA'}

z

{1, 2, 3, 4, 5, 6}

取交集

x&y

set()

x|z

{1, 2, 3, 4, 5, 6, 'A', 'B'}

x-z

{'A', 'B'}

- 数据转换

list/tuple/set/dict

t = (1,2,3,4,5,6,6,6)

l = list(t)

s = set(l)

tuple(s)

(1, 2, 3, 4, 5, 6)

zip()

zip函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

l = list(s)

keysName = ['a','b','c','d','e','f']

dict(list(zip(keysName, l)))

{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}