python 入门

（看了一个入门课程，整理到这里）

通用

• id(variable) 返回变量地址
• type(variable) 返回变量类型
• python 是动态类型语言（像 PHP），执行到才知道是什么类型
• 断言：
  • crash program
  • pass：不做处理
  • assert age == 18, 'output error'：判断 age 是否等于 18，若不是报错，错误内容可省略

变量类型

• 字符串 string
• 数字 int float complex ...
• 列表 list
• 元组 tuple
• 字典 dict

string

• 单引号 和 双引号 效果一样
• 'string {}; string {}'.format(str_1, str_2) 字符串格式化输出
• +：字符串连接
• *：字符串重复拼接自身多少次
• len()：返回字符串长度
• str[startIndex:endIndex]：字符串截取
• str[startIndex:endIndex:interval]：字符串截取，从第 startIndex 个到 endIndex 每 interval 取一个字符
• str[-10:] 取字符串最后 10 个字符
• str[::-1]：反转字符串
• 字符串类型上自带方法，比如可用 str.capitalize? 来查看方法定义的解释
• str.capitalize()：仅首字母大写
• str.center(20, '%')，将字符串按 20 个位置居中，其他填充 %
• str.count('Z')：计算字符出现次数
• str.endswith('subStr')：是否按子字符串结尾
• str.startswith('subStr')：是否按子字符串起始
• str.find('subStr'<, index>)：返回子字符串的起始下标，若无，返回 -1。从 index 开始查找
• str.index('subStr')：返回子字符串的起始下标，若无，报错
• str.lower()/str.upper(), str.isupper()/str.islower(), str.istitle()
• str.strip()/str.lstrip()/str.rstrip()： 去 除空字符
• str.swapcase()：按大小写翻转

math 包

• math.pow(3, 10) 开方
• 3 ** 10 开方
• math.floor()/math.ceil()
• math.radians()
• math.sin(math.pi/2)
• min(2, 3, 4)/max(2, 3, 4)
• sum([1, 2, 3])
• divmod(10, 3)

bool

• True == 1/False == 0
• True + 10 == 11
• and, or, not: 与, 或, 非运算。但由于是弱类型语言，非 bool 类型的变量运算返回值可能仍为非 bool 类型
• 操作符： <, >, <=, ..., is，is：是相同对象

list

• 定义：li = []/li = list()
• python 中的列表可存任意的混合类型
• +：列表拼接
• * n：重复拼接列表 n 次
• li.append()：在 li 本身上追加
• li.copy()：复制值到新引用
• li.extend()：两个列表拼接，等同于 +
• li.inert(0, 100)：在 0 下标插入值 100
• li.pop(index)：弹出 index 处的值
• li.remove('x')：移除元素，若无，报错
• li.sort()/li.sort(reverse=True)：排序/反转
• elem in li：判断 elem 是否在 li 中
• li.clear()：清空列表

tuple 元组

• 定义： t = tuple(), t = ()
• 不可变类型的列表，所以拥有的方法少： t.count(), t.index(i)
• 括号可省略：a = 1, 2, 3

dict 字典

• 相当于 map
• 定义： d = {}, d = dict()。如 d = {'a': 'A', 'b': 'B'}
• 拉锁函数，将两个列表对应起来成为一个 dict： zip(list_1, list_2, ...) 返回 <zipo at 0x107xxx>
• 拉锁，转换一下成 list：list(zip(l_1, l_2))，返回 [(l_1_0, l_2_0), (l_1_1, l_2_1)]
• 拉锁，转换成字典：dict(list(zip(l_1, l_2)))
• dict.fromkeys(l, 10) 从列表 l 中生成对应 key，且值为 10 的字典
• d.get('key', 'defaultVal')，从字典 d 中取 key 对应的值，若取不到，默认为 defaultVal
• d.values()，返回字段的值。（应该不是 list 类型）
• d.items()，返回所有值。（应该不是 list 类型）
• d.pop('key')，删除 key 及对应的值，若无，报错
• d['key']，取 key 值，但若无，报错
• d.setdefault('key', value)，当 key 不存在时设置 key 的值

条件判断

if condition:
    do_somethind()
elif condition:
    do_somethind()
else:
    do_something()

• 上方 condtion 可以是不是 bool 表达式，因为 python 是弱类型，任何类型的空值强转为 bool 类型时都是 False
• 断言：
  • crash program
  • pass：不做处理
  • assert age == 18, 'output error'：判断 age 是否等于 18，若不是报错，错误内容可省略
• continue
• break

循环

• for
• while
• for new_variable in range(n)
• list(range(n))：生成一个从 0 到 n-1 共 n个元素的列表
• while 'value' in list / while 'value' not in list，判断 value 是不是在 list 中
• for 循环也可以有个 else 分支：如果在循环中没有 break 语句，就进入 else 中 （NB）
• for 构建推导式：
  • 列表推导式：new_list = [number * 10 for number in number_list]，从 number_list 列表中构建出新的列表 new_list
  • 字典推导式：new_list = [ key for key, value in dict_1.items() if value == 10，从字典中构建出新的列表 new_list
  • 字典推导式：new_dict = {key: 10 for key in dict_a}
  • 没有元组推导式，但可用生成器
  • 生成器：obj = (number * 10 for number in number_list)
  • 生成器，再用强制类型转换得到元组（也可以转换成其他类型，如 list）： tuple(obj)
  • 生成器就相当于先创建一个生成器（加工的机器），在你使用时（如输出或其他读取时）每读一次取一个，直到读完（所以生成器不能再读第二遍）

for elem in li:
    do_something()

while condition:
    do_something()

函数

def func_name(variable_list):
    do_something()
    return

• variable_list 参数列表
  • 位置参数，位置相关传入。
  • 关键字参数，位置无关：传参时用 variable_element=xxx 传入即可。
  • 参数的收集
    • *keys，一个星号收集位置参数
    • **kwkeys，两个星号收集关键字参数（是需传入字典吧？）
• 函数装饰器：将函数作为参数传入，即函数包裹另一个函数。

def test():
    return random.random()

def decorator(func):
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

# 用法1：
f = decorator(test)

# 用法2：在 test 定义时加上 @
@decorator
def test():
    return random.random()

• func_name.__name__ 取函数名

类

class Person:
    def __init__(self, name, age): # 构建函数
        # do_something

    @property # 将函数名作为属性，可按属性访问
    def name(self):
        return self._name

class Student(Person): # 继承
    pass # 占位

BeautifulSoup

import requests
from bs4 import BeautifulSoup

url = 'https://bj.lianjia.com/zufang/'
resp = requests.get(url)
soup = BeautifulSoup(resp.text, 'lxml')

link_divs = soup.find_all('div', class_="pic-panel") # 按类查 divs
links = [div.a.get('href') for div in link_divs] # 取 div 上 a 标签的 href 属性
# div_elem.text 是取 div 中的文本
# a_elem.get('href') 是取 a 中的属性

科学计算 numpy

• 数组 array 数据结构：只能存储单种数据类型， 需要 import array 库
• a = array.array('i', range(10))，i代表 int 型

import numpy as np

# 定义
a_list = list(range(10)) # 生成列表
b = np.array(a_list) # 从 list 中生成数组
c = np.zeros(10, dtype=int) # 生成 10 个元素值为 0 的数组，第二个参数可省略，默认 float 类型
d = np.zeros((4, 4)) # 二维四行四列的数组
e = np.ones((4, 4), dtype=float) # 值为 1
f = np.full((3, 3), 3.14) # 自己设定值
g = zeros_like(f) # 按 f 变量的结构生成值为 0 的数组。还有 ones_like(), full_like()
np.random.random() # 加强版的 random，可生成随机数为值的数组
np.arange(0, 10, 2) # 从 0 到 10 步长为 2 生成数组
np.linspace(0, 3, 10) # 从 0 到 3 生成 10 个元素的数组，线性取值
np.eye(5) # 生成 5 行 5 列的单位矩阵

# 取值
f[-1][0] # 数组取元素也可以用 -1 代表最后一个元素
f[2, 0] # 等同于 f[2][0]
f[:2, :2] # 多维数组也可以切片
f[:2][:1] # 这种方式就不等同于 f[:2, :1] 了，等同于 (f[:2])[:1]

# 属性
a.ndim # 维度
a.shape # shape，如 (3, 3) 3 * 3
a.size # 空间大小（元素个数）
a.dtype # 类型
a.itemsize # 元素占空间大小，如 8 字节
a.ntypes # 变量总共占空间大小

# 运算
a + 10 # 每个元素 +10，等价于 a.add(10)
# 还有其他操作符，特殊的： `//` 为 floor_divide

# 比较
a > 3 # 返回 True/False 的数组，比较每个元素
a != 3
a == a
np.all(a > -1) # 是否所有元素均大于 -1，返回一个 True/False
np.any(a > -1) # 是否包含任一元素大于 -1

# 变形
a.reshape(4, 5) # 元素数量要相等才能用
# 排序
np.sort(a)
a.sort()
a.sort(axis=0)
# 拼接
np.concatenate([], axis=0) # 拼接的数组放数组中，拼接的方向

数据计算 pandas

• csv 数据格式
• import pandas as pd
• df = pd.read_csv('path/to/csv.file') 返回 pandas.core.frame.DataFrame 类型
• df.head(5) 取前 5 行数据

DataFrame

• df.columns 列名
• df.index 索引，就是行标
• df.loc[index] 按索引取数据。（索引是可以自己设定的，所以不一定是数值）
• df.loc[:2] 按索引取数据。（索引是可以自己设定的，所以不一定是数值）
• df[:2] 等同于 df.loc[:2]，但不能用 df[0] 取数据
• df.iloc[index] 按数值索引取数据
• df['数学'] 等同于 df.数学
• df.数学 > 80 返回 pandas.core.serier.Series 类型，索引+True/False（每行比较）
• df[df.数学 > 80] 取出数学成绩>80的部分数据
• df.values, df.数学.values
• df.数学.value_counts()，统计
• df['数学等级'] = df.数学.map(func)
• df.applymap(lambda x: x + 10) 对所有数据进行操作
• df.drop(['数学'], axis=1) 纵向删除 数学 一列

画图 matplotlib

• 可以画线性图、直方图、条形图、点状分布图等等。
• import matplotlib.pyplot as plt
• plt.plot(x, y)

import matplotlib.pyplot as plt
%matplotlib inline # 此行指明把图画在 xxx 处（示例用的是 notebook）
x = np.linspace(0, 10, 20) # 0 - 10 共 20 个数
y = np.sin(x) # 函数
plt.plot(x, y) # 画出图；plt.plot(x, y, '--') 用虚线画

fig = plt.figure() # 生成画幕
plt.plot(x, y)
fig.savefig('path/to/save')

（这个库比较复杂，并且对我现在也没多大用处，知道就行，不再细看整理了）