rikako-note/python/py.md

Python

变量

在python中，可以通过如下方式创建变量：

message = "Hello Python Crash Course world!"

字符串

字符串首字母大写

name = "ada lovelace"
print(name.title())

字符串全部字符大写

name = "Ada Lovelace"
print(name.upper())

字符串全部字符小写

name = "Ada Lovelace"
print(name.lower())

字符串删除空白符

name = " Asahi Ogura    `
# 删除左空白 
name.lstrip()
# 删除右空白
name.rstrip()
# 删除左右空白
name.strip()

访问字符串中字符

ptyhon可以通过数组下标来访问字符串中的字符，如果字符串长度为n，那么索引范围为[0, n-1]，同时，在python中还可以使用负数的索引，索引范围为[-n, -1]。

在python字符串中，第一个字符可以通过索引下标0和-n来访问，最后一个字符可以通过n-1和-1来访问。

字符串切片

字符串切片可以通过str[from:to:step]来标识，其标识下标为[from, to)范围内的子字符串，步长为step。

temp = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

其中，输出[0,10)范围内的字符串可以采用如下方式：

print(temp[0:10])  # ABCDEFGHIJ
print(temp[0:10:1]) # ABCDEFGHIJ

当步长被设置为2时，输出内容如下：

print(temp[0:10:2]) # ACEGI

正数索引和负数索引混用：

# 输出不包含末尾2个字符的子字符串
print(temp[0:-2]) # ABCDEFGHIJKLMNOPQRSTUVWX
print(temp[0:24]) # ABCDEFGHIJKLMNOPQRSTUVWX
print(temp[:-2]) # ABCDEFGHIJKLMNOPQRSTUVWX

# 输出末尾两个字符的子字符串
print(temp[-2:])

逆序输出字字符串

print(temp[::-1]) # ZYXWVUTSRQPONMLKJIHGFEDCBA
print(temp[-1:0:-1]) # ZYXWVUTSRQPONMLKJIHGFEDCBA
print(temp[25:0:-1]) # ZYXWVUTSRQPONMLKJIHGFEDCBA

字符串迭代

python中字符串可迭代，示例如下：

temp = "ABCDE"
for ind, ch in enumerate(temp):
    print("ind = "+str(ind)+", ch = "+ch, end="\n")

# ind = 0, ch = A
# ind = 1, ch = B
# ind = 2, ch = C
# ind = 3, ch = D
# ind = 4, ch = E

数字

/

python中，整数执行/操作默认并不会进行整除，而是可能生成浮点数

print(3/2) # 1.5

//

python中，如果要执行整除，应该使用//运算符，该运算符为向下取整

print(3//2) # 1
print(-3//2) # -2

和java不同，java在执行整数除时，会舍弃掉小数部分，例如-3/2，java中结果为-1，而python则是向下取整为-2

如果python中/操作想要和java保持一直，可以使用math中的trunc函数，math.trunc(-3/2)返回结果和java中一样，为-1

数字类型向字符串类型转换

可以通过str函数将数字类型转化为字符串类型

temp = 1.2
print("temp = "+str(temp))

列表

python中通过[e1, e2, ...]的形式来标识列表

访问列表中元素

可以通过数组下标的方式来访问列表中的元素

temp = [1, "2", "san"]

print(temp[1]) # 2
print(temp[-2]) # 2

列表元素操作

修改

temp = [1, "2", "san"]

temp[2] = 3.0
print(temp) # [1, '2', 3.0]

插入到末尾

如果想要向数组末尾插入元素，可以调用append方法

temp = [1, "2", "san"]

temp.append("four")
print(temp) # [1, '2', 'san', 'four']

在某位置之前插入

如果想要在特定位置之前插入元素，可以调用insert方法

temp = [1, "2", "san"]

temp.insert(1, "1.5")
print(temp)  # [1, '1.5', '2', 'san']
temp.insert(4, "four")
print(temp)  # [1, '1.5', '2', 'san', 'four']

删除列表中的元素

如果想要删除列表中的元素，可以通过del关键字进行删除

temp = [1, "2", "san"]

del temp[1]
print(temp) # [1, 'san']

列表与栈api

列表append操作是将元素追加到列表末尾，同时列表还支持pop操作，将列表末尾的元素作为栈顶元素弹出。

如果此时列表为空，那么调用pop方法将抛出异常

temp = [1, "2", "san"]


print(temp.pop())  # san
print(temp.pop())  # 2
print(temp.pop())  # 1
print(temp.pop())  # IndexError: pop from empty list

还可以为pop方法指定一个下标，此时可以弹出任何位置的元素

temp = [1, "2", "san"]


print(temp.pop(1)) # 2
print(temp.pop(0)) # 1
print(temp.pop(0)) # san

remove

在列表中，可以调用remove来移除列表中值为xxx的元素。

remove默认只会移除第一个匹配的元素

temp = [2, 1, 2, 1, 2]

temp.remove(2)
print(temp) # [1, 2, 1, 2]

列表排序

sort

可以通过sort方法针对列表中的元素进行排序，sort方法会该表列表中的元素顺序

temp = [2, 1, 2, 1, 2]

temp.sort()
print(temp) # [1, 1, 2, 2, 2]

如果想要逆向排序，可以为sort方法指定reverse=True

temp = [2, 1, 2, 1, 2]

temp.sort(reverse=True)
print(temp) # [2, 2, 2, 1, 1]

sorted

如果不想改变原列表中的元素顺序，而是生成一个排好序的新列表，可以调用sorted函数

temp = [2, 1, 2, 1, 2]

print(sorted(temp)) # [1, 1, 2, 2, 2]
print(sorted(temp, reverse=True)) # [2, 2, 2, 1, 1]
print(temp) # [2, 1, 2, 1, 2]

列表中顺序反转

如果不想对列表中元素进行排序，只是想逆序列表中的数据，可以调用reverse方法

temp = [2, 1, 2, 1, 3]

temp.reverse()
print(temp) # [3, 1, 2, 1, 2]

获取列表长度

可以通过len函数获取列表的长度

temp = [1,2,3]

temp.pop()
print(len(temp)) # 2
temp.pop()
print(len(temp)) # 1
temp.pop()
print(len(temp)) # 0

遍历列表

在python中，可以通过for ... in ...的形式来遍历列表中的元素

temp = [1, 2, 3]

for e in temp:
    print(e)

# 1
# 2
# 3

range

在python中，可以通过range函数生成一系列数字，range(m,n)会生成[m,n)范围内的数字，可用于fori形式的遍历

arr = ["1", "3", "2"]

for ind in range(0, len(arr)):
    print(arr[ind])

# 1
# 3
# 2

可以通过range函数来创建数字列表

print(list(range(0, 5))) # [0, 1, 2, 3, 4]

range也可以指定步长

print(list(range(0, 7, 2))) # [0, 2, 4, 6]

max, min, sum

针对数字型的列表，支持max、min、sum等函数来求最大值、最小值、总和

arr = list(range(1, 101))

print(max(arr)) # 100
print(min(arr)) # 1
print(sum(arr)) # 5050

根据一个列表生成另一个列表

python中，根据[expr(e) for e in list_a]的语法，可以快速根据一个列表得到应一个列表，目标列表中的每个元素都来源于来源列表的映射

arr = ['amd', 'nvidia']
graphic_msgs = ['fuck '+brand for brand in arr]
print(graphic_msgs) # ['fuck amd', 'fuck nvidia']

切片

列表的切片和字符串切片类似

arr = [1, 2, 3, 4, 5]
print(arr[::2]) # [1, 3, 5]

print([e**2 for e in arr[::2]]) # [1, 9, 25]

列表复制

在python中，如果要复制列表，可以创建整个列表的切片

arr = [1, 2, 3]
# 复制列表
arr_copied = arr[:]

print(arr_copied) # [1, 2, 3]

# 对复制后的列表进行写操作，并不会影响复制前的列表
arr_copied.pop()

print(arr_copied) # [1, 2]
print(arr) # [1, 2, 3]

元组

运行时列表中的元素可以被修改，如果想要让元素不可变，可以使用元组。

元组通过(e1, e2, e3, ...)形式来表示，和列表一样，元组也可以通过索引来访问。

但是元组中的元素无法复制，在执行赋值语句时会抛出异常。

pos = (50, 100)

pos[0] = 125 # TypeError:'tuple' object does not support item assignment

if

类似其他编程语言，python也支持if/else语法

cars = ['audi', 'bmw', 'subaru', 'toyota']
for car in cars:
    if car == 'bmw':
        print(car.upper())
    else:
        print(car.title())

and/or

python可以通过and和or操作符来拼接多个条件。

age = 179
is_alive = True

if age < 0 or age > 150 and is_alive:
    print("age wired")

列表中是否包含某值

如果想要检查列表中是否包含特定值，可以采用xxx in list_a的语法。

arr = [1, 3, 2]

print(1 in arr) # True

列表中是否不包含某值

如果想要检查列表中是否不包含特定值，可以采用xxx not in list_a的语法。

arr = [1, 3, 2]

print(1 not in arr) # False

多分支if/elif/else

python可以通过if/elif/else的语法实现多分支判断

age = 40
if age < 20:
    print("teen")
elif age < 40:
    print("man")
else:
    print("elder man")

字典

在python中，通过字典实现了其他语言中的Map数据结构。

dic = {"name": "Ogura Asahi", "age": 17}

print(dic['name']) # Ogura Asahi

向字典中添加键值对

dic = {"name": "Ogura Asahi", "age": 17}

dic['major'] = "student"
print(dic) # {'name': 'Ogura Asahi', 'age': 17, 'major': 'student'}

删除字典中的键值对

dic = {"name": "Ogura Asahi", "age": 17}

del dic['age']
print(dic) # {'name': 'Ogura Asahi'}

字典遍历

字典遍历可以通过for k, v in dic.items()的形式完成

dic = {"name": "Ogura Asahi", "age": 17}

for key, val in dic.items():
    print("key = "+key+" , value = "+str(val))

如果只想遍历字典的key集合，可以通过for k in dic.keys()的方式

dic = {"name": "Ogura Asahi", "age": 17}

for key in dic.keys():
    print("key = "+key)

如果只想遍历字典的value集合，可以通过for v in dic.values()的形式

dic = {"name": "Ogura Asahi", "age": 17}

for value in dic.values():
    print("value = "+str(value))

按顺序遍历字典的key

通常，字典的key遍历顺序是不一定的。如果想要按排序后的顺序遍历key，可以采用如下方式：

dic = {"name": "Ogura Asahi", "age": 17}

for key in sorted(dic.keys()):
    print("key = "+str(key))

while

i = 0

while i < 10:
    print(i)
    i += 1

函数

函数可通过如下方式来定义：

def fuck(brand, boss):
    print("fuck you " + boss + " and your " + brand)


fuck("Nvidia", "Jensen Huang")

在调用函数时，可以打乱传入实参顺序，只需要传参时指定参数名称即可：

def fuck(brand, boss):
    print("fuck you " + boss + " and your " + brand)


fuck(boss="Jensen Huang", brand="Nvidia")

参数默认值

声明函数时，可以为参数指定默认值，故而在调用函数时，可以对有默认值的参数进行省略

def fuck(boss, brand="Nvidia"):
    print("fuck you " + boss + " and your " + brand)


fuck("Jensen Huang")
fuck(brand="Apple", boss="Cook")

接收多个参数

通过*paramTup的形式，python会将函数接收到的参数都存储在一个元组中。

def fuck(*name_list):
    msg = "fuck "
    is_head = True
    for name in name_list:
        if not is_head:
            msg += ", "
        is_head = False
        msg += name
    print(msg)


fuck("Nvidia", "Amd")

文件操作

文件读取

with open('pi_digits.txt') as file_object:
    contents = file_object.read()
    print(contents)

写入文件

filename = 'programming.txt'
with open(filename, 'w') as file_object:
    file_object.write("I love programming.")
    file_object.write("I love creating new games.")

文件末尾追加

filename = 'programming.txt'
with open(filename, 'a') as file_object:
    file_object.write("I also love finding meaning in large datasets.\n")
    file_object.write("I love creating apps that can run in a browser.\n")

异常处理

在python中，可以通过如下语法来进行异常处理

try:
    # code block
    pass
except ErrorType1:
    # error type 1 handling code block
    pass
except ErrorType2:
    # error type 2 handling code block
    pass
except Exception as result:
    # handle other exception types
    pass
else:
    # code block that no error occurs
    pass
finally:
    # code block executed whether exception occurs
    pass

抛异常

捕获异常后重新抛出异常

如果python在捕获异常后需要重新对异常进行抛出，可以使用raise关键字

try:
    m = 10/0
except Exception as e:
    print(e)
    raise
finally:
    print("handle correctly")

主动抛出异常

主动抛出异常时，也可使用raise关键字

try:
    raise Exception("fucking Nvidia raised their price!")
except Exception as e:
    print(e)
finally:
    print("my wallet is empty!")

数据存储

json.dump

可以通过json.dump方法将内容以json的格式存储到文件中：

import json


def save_as_json(data, fd):
    json.dump(data, fd)


waifu = {
    "name": "Touma Kazusa",
    "job": "Student",
    "gender": "female",
    "age": 17
}

is_save_success = True
try:
    with open("shiro.json", "w") as shiro_fd:
        save_as_json(waifu, shiro_fd)
except Exception as e:
    print(e)
    is_save_success = False
    exit(1)
finally:
    if is_save_success:
        print("save success!")

json.load

可以通过json.load方法读取文件中的json格式内容：

import json


def read_as_json(fd):
    return json.load(fd)


is_read_success = True
try:
    with open("shiro.json", "r") as shiro_fd:
        r_obj = read_as_json(shiro_fd)
        print(r_obj)
except Exception as e:
    print(e)
    is_read_success = False
    exit(1)
finally:
    if is_read_success:
        print("read success!")

http api

python安装requests包之后，可以访问http接口

import math
import requests
import time

try:
    body = requests.get("https://api.m.taobao.com/rest/api3.do", {
        "api": "mtop.common.getTimestamp"
    }).json()
    ts = body['data']['t']
    t = time.localtime(math.trunc(int(ts) / 1000))
    time_str = time.strftime("%Y-%m-%d %H:%M:%S %z", t)
    print(time_str)
except Exception as e:
    print(e)
    raise

多线程

python可以通过引入threading和concurrent.futures两个包来引入多线程：

import math
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
import threading

import requests

ts_arr = []
lock = threading.Lock()


def query_ts():
    try:
        body = requests.get("https://api.m.taobao.com/rest/api3.do", {
            "api": "mtop.common.getTimestamp"
        }).json()
    except Exception as e:
        print(e)
        raise


def query_ts_once():
    ts_beg = time.time_ns()
    query_ts()
    ts_end = time.time_ns()
    ts_spend = math.trunc((ts_end - ts_beg) / 1000000)
    with lock:
        ts_arr.append(ts_spend)


def stress_test(test_cnt):
    with ThreadPoolExecutor(max_workers=32) as executor:
        i = 0
        f_list = []
        while i < test_cnt:
            f_t = executor.submit(query_ts_once)
            f_list.append(f_t)
            i += 1
        as_completed(f_list)


stress_test(100)
print(f"max ts : {max(ts_arr)} ms")
print(f"min ts : {min(ts_arr)} ms")
print(f"avg ts : {sum(ts_arr) / len(ts_arr)} ms")
print(ts_arr)

linux命令交互

如果想要调用系统（linux）的命令，可以使用subprocess模块。

subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, capture_output=False, shell=False, cwd=None, timeout=None, check=False, encoding=None, errors=None, text=None, env=None, universal_newlines=None)

调用示例如下：

ret = subprocess.run(['ls', '-l'], capture_output=True, text=True)
print(ret.stdout)

输出如下：

total 4
-rwxrwxrwx 1 asahi asahi  110 May  4 03:18 main.py
-rwxrwxrwx 1 asahi asahi   73 May  4 01:10 shiro.json
drwxrwxrwx 1 asahi asahi 4096 Feb  7 21:39 venv