10分钟学会Python

Python是互联网、数据科学、量化交易等领域使用最广泛的编程语言之一，是BigQuant主要使用的策略开发语言。

本文简短而全面，用十分钟的时间带你走入Python的大门。建议一边学习，一边在BigQuant在线开发环境里实践。

目录

1. 语法
2. 导入库
3. 数据类型
4. 数学运算
5. 比较和布尔运算
6. 条件表达式
7. 列表
8. 元组
9. 字符串
10. 字典
11. 集合
12. 函数
13. 匿名（Lambda）函数
14. For循环与While循环
15. 生成式
16. FAQ

1. 语法

Python中没有强制的语句终止字符，代码块是通过缩进来指示的。缩进表示一个代码块的开始，逆缩进则表示一个代码块的结束。一般用4个空格来表示缩进。

• 声明以冒号(:)字符结束，并且开启一个缩进级别。
• 单行注释以井号字符(#)开头，多行注释则以多行字符串的形式出现。
• 赋值（事实上是将对象绑定到名字）通过等号(“=”)实现
• 双等号(“==”)用于相等判断

# 本行是注释
some_var = 3
print(some_var)

print(some_var == 4)

if some_var > 1:
    print('Python就是这么简单')

3
False
Python就是这么简单

2. 导入库

外部库可以使用 import [libname] 关键字来导入，也可以使用 from [libname] import [funcname] 来导入所需要的函数。例如：

import math
math.sqrt(25)

5.0

from math import sqrt
sqrt(25)

5.0

3. 数据类型

查看数据类型：

type(2)

int

type('two')

str

type(True)

bool

类型转换:

float(2)

2.0

int(2.9)

2

str(2.9)

'2.9'

4. 数学运算

10 + 4

14

10 - 4

6

10 * 4

40

10 % 4      # 计算余数

2

10 / 4

2.5

5. 比较和布尔运算

赋值

x = 5

比较:

x > 3

True

x >= 3

True

x != 3

True

x == 5

True

布尔运算:

# and：与
5 > 3 and 6 > 3

True

# or：或
5 > 3 or 5 < 3

True

# not：非
not False

True

6. 条件表达式

# if 语句
if x > 0:
    print('positive')

positive

# if/else 语句
if x > 0:
    print('positive')
else:
    print('zero or negative')

positive

# if/elif/else 语句
if x > 0:
    print('positive')
elif x == 0:
    print('zero')
else:
    print('negative')

positive

7. 列表

• 列表的特点: 有序，可迭代，可变，可以包含多个数据类型

创建列表

# 两种创建空列表的方法如下
empty_list = []
empty_list = list()

# 创建列表
simpsons = ['homer', 'marge', 'bart']

获取列表数据:

# 列表的第0个元素（列表的下标从0开始，这和C语言等一致）
simpsons[0]

'homer'

# 列表元素个数
len(simpsons)

3

列表方法:

# 在尾部追加，操作符+=完成同样的功能
simpsons.append('lisa')
simpsons

['homer', 'marge', 'bart', 'lisa']

# 在尾部追加多个元素
simpsons.extend(['itchy', 'scratchy'])
simpsons

['homer', 'marge', 'bart', 'lisa', 'itchy', 'scratchy']

# 在索引位置处将数据项插入列表
simpsons.insert(0, 'maggie')
simpsons

['maggie', 'homer', 'marge', 'bart', 'lisa', 'itchy', 'scratchy']

# 列表从左往右搜索第一个出现的元素，并移除
simpsons.remove('bart')
simpsons

['maggie', 'homer', 'marge', 'lisa', 'itchy', 'scratchy']

# 替代列表第一个元素
simpsons[0] = 'krusty'
simpsons

['krusty', 'homer', 'marge', 'lisa', 'itchy', 'scratchy']

# 统计元素出现次数
simpsons.count('lisa')

1

# returns index of first instance
simpsons.index('itchy')

4

列表切片:

weekdays = ['mon', 'tues', 'wed', 'thurs', 'fri']

# 第一个元素，索引值为0
weekdays[0]

'mon'

# 前三个元素，索引值为0、1、2,，其中0可以省略
print(weekdays[0:3] == weekdays[:3])
weekdays[0:3]

True

['mon', 'tues', 'wed']

# 从索引值为3的元素的位置到最后位置的元素
weekdays[3:]

['thurs', 'fri']

# 最后一个元素
weekdays[-1]

'fri'

# 每隔两个元素进行存取
weekdays[::2]

['mon', 'wed', 'fri']

# 反转列表，等价于list(reversed(weekdays))
weekdays[::-1]

['fri', 'thurs', 'wed', 'tues', 'mon']

# 对列表进行排序 (原地修改列表但不返回列表)
simpsons.sort()
simpsons

['homer', 'itchy', 'krusty', 'lisa', 'marge', 'scratchy']

# 反向排序
simpsons.sort(reverse=True)
simpsons

['scratchy', 'marge', 'lisa', 'krusty', 'itchy', 'homer']

# 根据传入的规则排序，以长度为例
simpsons.sort(key=len)
simpsons

['lisa', 'marge', 'itchy', 'homer', 'krusty', 'scratchy']

# 返回已排序列表(并不修改原列表)，可以传入排序规则:
simpsons = [ 'krusty', 'itchy', 'scratchy', 'lisa']
sorted(simpsons, key=len)

['lisa', 'itchy', 'krusty', 'scratchy']

# 对象引用
num = [10,20,30,40,50]
same_num = num

# 会同时修改两个对象
same_num[0] = 0
print(num)
print(same_num)

[0, 20, 30, 40, 50]
[0, 20, 30, 40, 50]

# 检查是否是同一个对象
num is same_num

True

# 判断两个对象是否相等
num == same_num

True

8. 元组

• 元组性质: 有序，可迭代，不可变，可以包含多个数据类型
• 类似于列表, 但不可变

# 直接创建一个元组
digits = (0, 1, 'two')

# 将列表转化为元组
digits = tuple([0, 1, 'two'])

# 元组第三个位置的元素
digits[2]

'two'

# 元组长度
len(digits)

3

# 统计元组中元素出现的次数
digits.count('two')

1

# 返回该元素第一次出现的索引值
digits.index(1)

1

# 元组不可修改，下面语句会报错
# digits[2] = 2

9. 字符串

• 字符串性质: 可迭代，不可变

# 创建字符串
s = 'I like you'

# 字符串切片
s[0]

'I'

# 长度
len(s)

10

字符串切片类似于列表切片:

s[:6]

'I like'

s[7:]

'you'

s[-1]

'u'

字符串方法 (并不修改原字符串):

s.lower()

'i like you'

s.upper()

'I LIKE YOU'

s.startswith('I')

True

s.endswith('you')

True

# 返回在字符串中的最左位置，如果没有找到，就返回-1
s.find('like')

2

# 字符串替换
s.replace('like', 'love')

'I love you'

字符串分割:

# 返回一个被空白字符分割的字符串列表
s.split(' ')

['I', 'like', 'you']

# 返回一个被特定字符分割的字符串列表
s2 = 'a, an, the'
s2.split(',')

['a', ' an', ' the']

# 字符串拼接
stooges = ['larry', 'curly', 'moe']
' '.join(stooges)

'larry curly moe'

# + 也可作字符串拼接
s3 = 'The meaning of life is'
s4 = '42'
s3 + ' ' + s4

'The meaning of life is 42'

# 移除开始和结尾的空白字符
s5 = '  ham and cheese  '
s5.strip()

'ham and cheese'

格式化字符串:

# 方法1
'raining %s and %s' % ('cats', 'dogs')

'raining cats and dogs'

# 方法2
'raining {} and {}'.format('cats', 'dogs')

'raining cats and dogs'

10. 字典

• 字典性质: 无序，可迭代，可变，可以包含多个数据类型
• 由键-值对组成
• 键必须是唯一的, 可以是字符串、数字、元组
• 值可以是任何类型

字典的键与值:

# 创建一个空字典（两种方法）
empty_dict = {}
empty_dict = dict()

# 创建字典（两种方法）
family = {'dad':'homer', 'mom':'marge', 'size':6}
family = dict(dad='homer', mom='marge', size=6)
family

{'dad': 'homer', 'mom': 'marge', 'size': 6}

# 传入键名，获取字典键值
family['dad']

'homer'

# 返回字典的键-值对数目
len(family)

3

# 检查字典中是否含有某个键名
'mom' in family

True

# 返回键名
family.keys()

dict_keys(['size', 'dad', 'mom'])

# 返回键值
family.values()

dict_values([6, 'homer', 'marge'])

# 返回键值对
family.items()

dict_items([('size', 6), ('dad', 'homer'), ('mom', 'marge')])

修改字典:

# 增加一个键-值
family['cat'] = 'snowball'
family

{'cat': 'snowball', 'dad': 'homer', 'mom': 'marge', 'size': 6}

# 编辑一个已存在的键-值
family['cat'] = 'snowball ii'
family

{'cat': 'snowball ii', 'dad': 'homer', 'mom': 'marge', 'size': 6}

# 删除一个键-值
del family['cat']
family

{'dad': 'homer', 'mom': 'marge', 'size': 6}

# 字典值可以是列表
family['kids'] = ['bart', 'lisa']
family

{'dad': 'homer', 'kids': ['bart', 'lisa'], 'mom': 'marge', 'size': 6}

# 增加多个键-值
family.update({'baby':'maggie', 'grandpa':'abe'})
family

{'baby': 'maggie',
 'dad': 'homer',
 'grandpa': 'abe',
 'kids': ['bart', 'lisa'],
 'mom': 'marge',
 'size': 6}

获取键值的一个更安全的方法（get）:

# 获取字典值，等价于family['mom']
family.get('mom')

'marge'

# 如果字典中不存在，返回一个默认值
family.get('grandma', 'not found')

'not found'

11. 集合

• 集合性质: 无序, 可迭代, 可变, 可以包含多个数据类型
• 集合中元素是唯一的(字符串, 数字, or 元组)
• 类似于字典，只有键名，没有键值

创建集合:

# 创建空集合
empty_set = set()

# 创建集合
languages = {'python', 'r', 'java'}

# 将列表转化为集合
snakes = set(['cobra', 'viper', 'python'])

集合运算:

# 交集
languages & snakes

{'python'}

# 并集
languages | snakes

{'cobra', 'java', 'python', 'r', 'viper'}

# 差集
languages - snakes

{'java', 'r'}

修改集合 (并不返回集合):

# a增加元素
languages.add('sql')
languages

{'java', 'python', 'r', 'sql'}

# 增加一个已存在的元素
languages.add('r')
languages

{'java', 'python', 'r', 'sql'}

# 移除元素
languages.remove('java')
languages

{'python', 'r', 'sql'}

# 移除所有元素
languages.clear()
languages

set()

从列表中获取唯一元素的排序列表:

sorted(set([9, 0, 2, 1, 0]))

[0, 1, 2, 9]

12. 函数

定义没有参数、没有返回值的函数:

def print_text():
    print('this is text')

# 调用函数
print_text()

this is text

定义含有一个参数、含有一个返回值的函数:

# 定义函数
def square_this(x):
    return x**2

# 调用函数
result = square_this(3)
print(result)

9

定义含有两个位置参数（非默认值）、一个关键字参数（默认值）的函数:

def calc(a, b, op='add'):
    if op == 'add':
        return a + b
    elif op == 'sub':
        return a - b
    else:
        print('valid operations are add and sub')

# 调用函数
calc(10, 4, op='add')

14

# 通过参数位置来传入参数值
calc(10, 4, 'add')

14

# ‘op’关键字参数为默认值
calc(10, 4)

14

calc(10, 4, 'sub')

6

calc(10, 4, 'div')

valid operations are add and sub

如果您尚未编写函数体，请使用pass作为占位符:

def stub():
    pass

函数含有两个返回值:

def min_max(nums):
    return min(nums), max(nums)

# 多个返回值可以绑定到类型为元组的变量上
nums = [1, 2, 3]
min_max_num = min_max(nums)
min_max_num

(1, 3)

# 多个返回值绑定到多个变量上（）通过元组解包的方式
min_num, max_num = min_max(nums)
print(min_num)
print(max_num)

1
3

13. 匿名（Lambda）函数

• 主要用于临时定义由另一个函数使用的函数

定义函数:

# 最常见的定义函数的方法——def
def squared(x):
    return x**2

# 使用lambda定义函数的方法，等价于def函数定义
squared = lambda x: x**2

依据字符串最后一个元素的顺序，将字符串列表进行排序:

# 使用def函数定义的方法
simpsons = ['homer', 'marge', 'bart']
def last_letter(word):
    return word[-1]
sorted(simpsons, key=last_letter)

['marge', 'homer', 'bart']

# 使用lambda函数定义的方法
sorted(simpsons, key=lambda word: word[-1])

['marge', 'homer', 'bart']

14. For循环与While循环

for 循环:

# for循环
fruits = ['apple', 'orange']
for fruit in fruits:
    print(fruit.upper())

APPLE
ORANGE

# 对字典的循环，依次打印字典的键名和键值
family = {'dad':'homer', 'mom':'marge', 'size':6}
for key, value in family.items():
    print(key, value)

size 6
dad homer
mom marge

# 对列表的循环，依次打印列表元素的索引值和元素
for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 orange

``while`` 循环:

count = 0
while count < 5:
    print('This will print 5 times')
    count += 1    # 等价于 'count = count + 1'

This will print 5 times
This will print 5 times
This will print 5 times
This will print 5 times
This will print 5 times

15. 生成式

列表生成式:

# 通过for循环获得一个列表，该列表的每个元素是原始列表对应元素的三次方
nums = [1, 2, 3, 4, 5]
cubes = []
for num in nums:
    cubes.append(num**3)
cubes

[1, 8, 27, 64, 125]

# 使用列表生成式
cubes = [num**3 for num in nums]
cubes

[1, 8, 27, 64, 125]

# 如果只想获得偶数值的列表
# 语法: [expression for variable in iterable if condition]
cubes_of_even = [num**3 for num in nums if num % 2 == 0]
cubes_of_even

[8, 64]

集合生成式:

fruits = ['apple', 'banana', 'cherry']
unique_lengths = {len(fruit) for fruit in fruits}
unique_lengths

{5, 6}

字典生成式:

fruit_lengths = {fruit:len(fruit) for fruit in fruits}
fruit_lengths

{'apple': 5, 'banana': 6, 'cherry': 6}

fruit_indices = {fruit:index for index, fruit in enumerate(fruits)}
fruit_indices

{'apple': 0, 'banana': 1, 'cherry': 2}

16. FAQ

1. 应该学Python 2 还是 Python 3？

如果你还在问这个问题，选择Python 3。Python 3已经被广泛支持和使用，Python 2的程序可以通过 2to3 转换为Python 3。对初学者来说，Python 2和3区别不大。BigQuant的策略开发语言是Python 3。

---

Generated by nbsphinx from a Jupyter notebook. [a reference-style link][mylink]