由于以及学习过Java等一些面向对象变成语言,所以这里只记录一下Python中的一些特别的地方

数据类型

list

  • 用len()函数可以获得list元素的个数
  • 要删除list末尾的元素,用pop()方法
  • 要删除指定位置的元素,用pop(i)方法,其中i是索引位置
  • list里面的元素的数据类型也可以不同
  • 如果要取最后一个元素,除了计算索引位置外,还可以用-1做索引,直接获取最后一个元素

以此类推,可以获取倒数第2个、倒数第3个

classmates = ['Michael', 'Bob', 'Tracy']
classmates[-1]
classmates[-2]

tuple

另一种有序列表叫元组:tuple。tuple和list非常类似,但是tuple一旦初始化就不能修改,tuple使用(),而list使用[]

//定义一个不变的集合
classmates = ('Michael', 'Bob', 'Tracy')

布尔值

python中的布尔类型用True和False表示,布尔值可以用and、or和not运算

字典dict

Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度

//初始化时赋值
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
//通过key放入
d['Adam'] = 67
//若取值时,key不存在,则返回None类型,或者返回自定义的默认值
d.get('Thomas')
d.get('Thomas',-1)
//要删除一个key,用pop(key)方法,对应的value也会从dict中删除
d.pop('Bob')

list 和 dict 对比

和list比较,dict有以下几个特点:

查找和插入的速度极快,不会随着key的增加而变慢;
需要占用大量的内存,内存浪费多。
而list相反:

查找和插入的时间随着元素的增加而增加;
占用空间小,浪费内存很少。
所以,dict是用空间来换取时间的一种方法。

dict可以用在需要高速查找的很多地方,在Python代码中几乎无处不在,正确使用dict非常重要,需要牢记的第一条就是dict的key必须是不可变对象

set

set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key,set可以看成数学意义上的无序和无重复元素的集合。
要创建一个set,需要提供一个list作为输入集合:

s = set([1, 2, 3])
//重复元素在set中自动被过滤
>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}
//通过add(key)方法可以添加元素到set中,可以重复添加,但不会有效果:
s.add(4)
//通过remove(key)方法可以删除元素:
s.remove(4)

条件语句和循环

if 表达式后面要加个:

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

循环有以下两种:

sum = 0
for x in range(101):
    sum = sum + x
print(sum)
//while循环,表达式后面都要有 :
sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

函数

在Python中,定义一个函数要使用def语句,依次写出函数名、括号、括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

//pass语句什么都不做,那有什么用?实际上pass可以用来作为占位符,
//比如现在还没想好怎么写函数的代码,就可以先放一个pass,让代码能运行起来
def nop():
    pass

函数返回值

Python的函数返回多值其实就是返回一个tuple,而多个变量可以同时接收一个tuple,按位置赋给对应的值

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny


>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print(x, y)
151.96152422706632 70.0
//但其实这只是一种假象,Python函数返回的仍然是单一值:

>>> r = move(100, 100, 60, math.pi / 6)
>>> print(r)
(151.96152422706632, 70.0)
def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

nums = [1, 2, 3]
calc(*nums)

高级特性

切片

对这种经常取指定索引范围的操作,用循环十分繁琐,因此,Python提供了切片(Slice)操作符,能大大简化这种操作。
切片可以用于list,tuple和字符串。

取前3个元素,用一行代码就可以完成切片:

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
//L[0:3]表示,从索引0开始取,直到索引3为止,但不包括索引3。即索引0,1,2,正好是3个元素
L[0:3]
//如果第一个索引是0,还可以省略
L[:3]

//既然Python支持L[-1]取倒数第一个元素,那么它同样支持倒数切片
L[-2:]
L[-2:-1]

//前10个数,每两个取一个:
 L = list(range(100))
 L[:10:2]
//所有数,每5个取一个:
L[::5]
//什么都不写,只写[:]就可以原样复制一个list:
L[:]

迭代

在Python中,迭代是通过for ... in来完成的

d = {'a': 1, 'b': 2, 'c': 3}
for key in d:
    print(key)
//如果要迭代value,可以用:
for value in d.values()
//如果要同时迭代key和value,可以用:
for k, v in d.items()


//如果要对list实现类似Java那样的下标循环
//Python内置的enumerate函数可以把一个list变成索引-元素对,这样就可以在for循环中同时迭代索引和元素本身
for i, value in enumerate(['A', 'B', 'C']):
     print(i, value)

列表生成式List Comprehensions

列表生成式即List Comprehensions,是Python内置的非常简单却强大的可以用来创建list的生成式
举个例子,要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用list(range(1, 11)):

list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

[x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
//for循环后面还可以加上if判断,这样我们就可以筛选出仅偶数的平方
[x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]
//可以使用两层循环,可以生成全排列:
[m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

生成器generator

通过List Comprehensions可以直接创建一个列表,但是有时列表数据量太大,或者只是需要知道这个list的元素是按照什么算法计算得到的,可以使用生成器generator,要遍历内部的元素时,可以使用for循环

g = (x * x for x in range(10))
for n in g:
    print(n)

另一种定义generator的方式是在函数中使用yield关键字,如定义一个斐波那契数列的generator:

//在执行过程中,遇到yield就中断,下次又继续执行
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'
//调用时使用for循环
for n in fib(6):
   print(n)

函数式编程

map() 和 reduce()

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

map()传入的第一个参数是f,即函数对象本身。由于结果r是一个Iterator,Iterator是惰性序列,因此通过list()函数让它把整个序列都计算出来并返回一个list

再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3, ...]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,其效果就是:

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

//比如对一个序列求和,就可以用reduce实现
>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

//将一个str转换成数字
from functools import reduce

DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

def str2int(s):
    def fn(x, y):
        return x * 10 + y
    def char2num(s):
        return DIGITS[s]
    return reduce(fn, map(char2num, s))
如果觉得我的文章对你有用,请随意赞赏