阅读 21

Python 基础

大蟒蛇略略略

流程控制

# 菲波那切数列
a, b = 0, 1
while a < 10:
    print(a, end=',')
    a, b = b, a+b

# if语句
x = int(input('Please enter an integer:'))
if  x < 0:
    print('小于0')
else:
    print('大于等于0')

# for 语句
arr = ['Emlice', 'Alice', 'Xiaomo']
for item in arr:
    print(item, len(item))

# 循环添加的时候要先用切片进行拷贝再处理
arr = ['Emlice', 'Alice', 'Xiaomo']
for item in arr[:]:
    if len(item) > 5:
        arr.insert(0, item)
print(arr)

# range() 函数
for i in range(5):
    print(i)

# 循环字典
knights = { 'a': 1, 'b': 2 }
for k, v in knights.items():
    print(k, v)

# enumerate() 可以将索引位置和其对应的值取出
arr = ['Alice', 'Emlice', 'Xiaoming']
for i, v in enumerate(arr):
    print(i, v)

# 两个数组一起匹配
arr1, arr2 = [5, 6, 7], ['Alice', 'Emlice', 'Xiaoming']
for a, b in zip(arr1, arr2):
    print(a, b)

# 逆向匹配
arr = ['Alice', 'Emlice', 'Xiaoming']
for v in reversed(arr):
    print(v)

# 循环修改数组的时候, 通常创建一个数组来操作比较简单且安全
import math
raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
filter_data = []
for v in raw_data:
    if not math.isnan(v):
        filter_data.append(v)
print(filter_data)

# 迭代对象创建列表
arr = list(range(5))
print(arr)

# range 并不会生成数组,只会在被迭代的时候返回对应的值
# 通过 list 函数可以在可迭代的对象中创建数组
arr = list(range(5))
print(arr)

# break 和 continue 语句,以及循环中的 else 子句
# else 子句是属于 for 而不是 if 的,当 for 循环完或者条件为假的时候执行
for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, 'equals', x, '*', n//x)
            break
    else:
        print(n, 'is a prime number')

# 定义函数
# 定义一个输出任意范围内菲波那切数列的函数(前两个数之和等于第三个)
def fib(n):
    '''打印菲波那切数列直到n'''
    res = []
    a, b = 0, 1
    while a < n:
        res.append(a)
        a, b = b, a + b
    return res
arr = fib(2000)
print(arr)

# *xxx 接受到一个除了正式形参以外的位置参数的元组
# **xxx 接受到一个除了正式形参以外的对应关键字参数的字典
def cheeseShop(kind, *args, **keywords):
    print(kind)
    for v in args:
        print(v)
    print('---' * 10)
    for k in keywords:
        print(k, ':', keywords[k])

cheeseShop(
    'son',
    'xixi', 'haha', 'lala',
    name='Emlice',
    age=26
)

# 任意参数列表
def concat(*args, sep='/'):
    return sep.join(args)
str = concat('Alice', 'Emlice', 'Xiaoming', sep='*')
print(str)

# 类似 JS 的赋值解构
# 数组
arr = list(range(3, 6))
print(arr)

args = [3, 6]
arr2 = list(range(*args))
print(arr2)
# 对象
def parrot(voltate, state='a stiff', action='voom'):
    print(voltate, state, action)
obj = {
    'voltate': 'Alice',
    'state': 'Emlice',
    'action': 'Xiaoming'
}
parrot(**obj)

# 使用 lambda 来返回一个函数
def make(n):
    return lambda x : x + n
f = make(42)
print(f(1))

# 使用 lambda 来传递一个函数做为参数
pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
pairs.sort(key=lambda pair : pair[1])
print(pairs)

# 文档字符串
def docStr():
    '''
    Hi, My name is Emlice!
    '''
    pass
print(docStr, __doc__)

# 函数标注
def f(ham: str, eggs: str = 'eggs') -> str:
    print('Annotations:', f.__annotations__)
    print('Arguments:', ham, eggs)
    return ham + ' and ' + eggs
str = f('spam')
print(str)
复制代码

数据结构

列表的基本操作

# 尾部加入一个元素 x
list.append(x)

# 给定位置 插入一个值
list.insert(i, x)

# 删除第一个元素 x
list.remove(x)

# 尾部/给定位置 删除一个值
list.pop([i])

# 删除列表中的所有元素
list.clear()

# 返回列表中的第一个值为x的元素的索引(从0开始),限定查找范围
list.index(x, [, start[, end]])

# 返回元素 x 在列表中出现的次数
list.count(x)

# 对列表中的元素进行排序
list.sort(key=None, reverse=False)

# 反转列表中的元素
list.reverse()

# 返回一个列表的浅拷贝, 相当于 a[:]
list.copy()
复制代码

列表当做栈来使用(后进先出)

arr = [1, 2, 3]
# 入栈
arr.append(4)
# 出栈
arr.pop()
print(arr)
复制代码

列表当做队列来使用(先进先出)

但是列表作为队列相当低效,因为每次变动都会导致所有列表元素的联动 collections.deque 被用于快速的从列表两端操作

from collections import deque
queue = deque(['Emlice', 'Alice', 'Xiaoming'])
queue.append('Tom')
queue.append('Tone')
queue.popleft()
queue.popleft()
print(queue)
复制代码

列表推导式

推导的时候如果表达式是元组, 就一定要加上括号

# 创建一个平方列表(三种等价操作)
squares = []
for x in range(10):
    squares.append(x**2)

squares = list(map(lambda x: x**2, range(10)))

squares = [x**2 for x in range(10)]

# 推导一个排列组合
arr = [(x, y) for x in [1,2,3] for y in [3,1,2] if x != y]

# 二维数组拆分
arr = [[1,2,3], [4,5,6], [7,8,9]]
res = [arr, ]
复制代码

del

# 根据索引删除列表中指定数据
# 也可以根据 del arr 删除整个变量 arr
arr = [1, 2, 3, 4, 5]
del arr[1]
del arr[1:3]
del arr[:]
print(arr)
复制代码

元组和序列

# 元组的项不可以被重新分配
t = 1, 2, 'hello'
t[2]
u = t, [1, 2, 3, 4, 5]

# 序列解包
x, y, z = (1, 2, 3)
复制代码

集合

# 创建一个空集合只能用 set() 不能用 {},后者创建一个空字典
a = set('abcd')
b = set('cdef')
# a有b没有
a - b
# a b 合集
a | b
# a b 交集
a & b
# a b 合集但不包括交集部分
a ^ b

# 集合也支持推导式
a = {x for x in 'abcdefg' if x not in 'abc'}
print(a)
复制代码

模块

如何引入模块

# 引入fibo模块,可以通过fibo.xxx访问内部变量和方法
import fibo
# 引入来自fibo模块的fib方法,新模块直接使用fib调用
from fibo import fib
# 引入模块的所有方法, 不推荐
from fibo import *
# 引入模块并将名称绑定为新模块的名称, 直接使用 xxx.fib 调用
import fibo as fib
# 引入来自fibo模块的fib方法,并把名称改为fibonacci,新模块直接使用fibonacci调用
from fibo import fib as fibonacci
复制代码

当模块被引入时某段代码不运行

python模块被引入的时候 name 会变成模块名,否则为 main

# 输出斐波那契数列
def fib(n):
    result = []
    a, b = 0, 1
    while a < n:
        result.append(a)
        a, b = b, a + b
    return result

print(__name__)

# 如果当前模块是被引入的,这段代码不运行
if __name__ == '__main__':
    import os
    os.system('clear')
    print('嘻嘻')
复制代码