十分钟学python-10分钟学会Python

#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。