python语法入门

September 3, 2022

python 镜像下载：https://repo.huaweicloud.com/python/
教程：https://docs.python.org/zh-cn/3/tutorial/
参考：https://docs.python.org/zh-cn/3/reference/
文档：https://docs.python.org/zh-cn/3/contents.html
标准库：https://docs.python.org/zh-cn/3/library/
内置函数：https://docs.python.org/zh-cn/3/library/functions.html

关于语言

类型注解在 python 3.5 后引入，仅作注解，不影响解释器。
https://zhuanlan.zhihu.com/p/419955374
分号不是必须的，用于在一行中编写多个语句。
表示字符串字面量和文档注释时，单引号与双引号作用相同。
单行注释使用 # 标记，多行字符串使用连续三个（单/双）引号，不支持嵌套。
布尔值是 True 和 False （首字母大写），空值是 None。

pip 镜像

pip 是 python 的包管理器，PyPI 指的是包索引

linux: ~/.pip/pip.conf
windows: %USERPROFILE%\pip\pip.ini

toml

[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
[install]
trusted-host = https://pypi.tuna.tsinghua.edu.cn

shebang

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

数字

int: int = 1
float: float = 1.2
complex1: complex = 1.2 + 3.4j
complex2: complex = complex(1.2, 3.4)
div1: float = 3/2
div2: int = 3//2

字符串

str1 = "x\r\ny"
str2 = 'x\r\ny'
str3 = r"x\r\ny" # 原始字符串
str4 = """\
x
y
""" # 多行字符串，首行的反斜线表示丢弃首行的换行
str5 = 3 * "ha" # hahaha
str6 = "ha" + 'ha' # haha （连接字符串变量）
str7 = "ha" 'ha' # haha （连接字符串字面量）
str8 = f"PI = {math.pi:.7f}" # 格式化字符串，控制位语法类 c

字符串 format() 方法

类型转换

int(x [,base ])         # 将 x 转换为一个整数
long(x [,base ])        # 将 x 转换为一个长整数
float(x)                # 将 x 转换为一个浮点数
complex(real [,imag ])  # 创建一个复数
str(x)                  # 将对象 x 转换为字符串
repr(x)                 # 将对象 x 转换为表达式字符串
eval(str)               # 用来计算在字符串中的有效 Python 表达式，并返回一个对象
tuple(s)                # 将序列 s 转换为一个元组
list(s)                 # 将序列 s 转换为一个列表
chr(x)                  # 将一个整数转换为一个字符
unichr(x)               # 将一个整数转换为 Unicode 字符
ord(x)                  # 将一个字符转换为它的整数值
hex(x)                  # 将一个整数转换为一个十六进制字符串
oct(x)                  # 将一个整数转换为一个八进制字符串

函数

def fib(n: int) -> None:    # 注意，类型定义仅作语法演示
    """文档注释内容"""
    a, b = 0, 1
    while a < n:
        print(a, end=' ')
        a, b = b, a+b
    pass

支持默认值和关键字参数

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
#     -----------    ----------     ----------
#       |             |                  |
#       |        位置或关键字参数           |
#       |                                - 仅允许关键词参数
#        -- 仅允许位置参数

支持 lambda

f = lambda a, b: a+b
f(1, 2) # 3

def f(a, b):
    return a + b

ff = f

支持解包

def concat(*args, sep="/"):
    return sep.join(args)

concat("aaa", "bbb", sep=".") # aaabbb

def params(pos1, pos2):
    print(pos1 + pos2)

params(**{"pos1": "aaa", "pos2": "bbb"}) # aaabbb
params(*("aaa","bbb")) # aaabbb
params(*["aaa","bbb"]) # aaabbb
params(*{"aaa","bbb"}) # aaabbb


def f(param, *args, **map):
    print(param)
    print(args)
    print(map)

f(123, "aaa", "bbb", k1="v1", k2="v2")
# ---    --------     --------------
#  |         |               |
# param=123  |               |
#         args=('aaa','bbb') |
#                          map={'k1':'v1','k2':'v2'}

简单输入输出

###################
import sys
print(sys.argv)
###################
a = input("请输入")
print(a)
###################

序列 sequence

字符串 str

这里提到字符串是因为字符串也是序列的一种
和列表一样可以使用切片

列表 list

list = [1, "2", 3.0]

list.append(x)
list.extend(iterable)
list.insert(i, x)
list.remove(x)
list.pop([i])
list.clear()
list.index(x[, start[, end]])
list.count(x)
list.sort(*, key=None, reverse=False)
list.reverse()
list.copy()

切片 slice

del list[0]
del list[2:4]
del list[:]

元组 tuple

tuple = ("hello", 123)
# or
tuple = "hello", 123

x, y = tuple

集合 set

set = {'a', 'b', 'c'}
# or
set = set("abc")
set = set(list)

字典 dict

dict = {'k': 'v', 1: 2}
# or
dict = dict(k='v', x='y')
# or
dict = dict([('k','v'), (1, 2)])

dict['key'] = 'value'
del dict['key']
'k' in dict # True
'k' not in dict # False

迭代器

迭代器可用于 for in 循环

range(n)     # [0, n)
range(a, b)  # [a, b)
reversed(range(...))

for k, v in dict.items()
for i, v in enumerate(list)
for v1, v2 in zip(list1, list2)

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

迭代器原理

from typing import Iterable, Iterator


class IterClass(Iterator):  # 迭代器对象
    def __iter__(self):
        return self

    def __next__(self):
        return 123
        raise StopIteration  # 抛出此异常表示终止迭代器


class CanIterClass(Iterable):  # 可迭代对象
    def __iter__(self):
        return IterClass()


obj = CanIterClass()
it = iter(obj)
ni = next(it)

生成器

def gen():
    yield 123


it = gen()
ni = next(it)

#  支持推导
it = (123 for i in range(10))

推导式

快速生成字面量

list = [x**2 for x in range(10)]
set = {x for x in 'abracadabra' if x not in 'abc'}
dict = {x: x**2 for x in (2, 4, 6)}

模块化

https://docs.python.org/zh-cn/3/tutorial/modules.html

import math
from math import sin, cos
from math import *
import math as mathematics
from math import sin as my_sin, cos as my_cos

__init__.py 表示目录为包
该脚本可指定导出的模块列表，不指定则导出全部

__all__ = ["funcXXX", "classXXX", "varXXX"]

目录结构

package/
        __init__.py
        model/
                __init__.py
                m1.py
                m2.py
        view/
                __init__.py
                v1.py
                v2.py
        controller/
                __init__.py
                c1.py
                c2.py

项目管理可用 virtualenv

错误处理

https://docs.python.org/zh-cn/3/tutorial/errors.html

def func():
    raise ConnectionError

try:
    func()
except ConnectionError as exc:
    raise RuntimeError('Failed to open database') from exc



def divide(x, y):
    try:
        result = x / y
    except (ZeroDivisionError, Exception):
        print("division by zero!")
    else:
        print("result is", result)
    finally:
        print("executing finally clause")


with open("myfile.txt") as f:
    for line in f:
        print(line, end="")

面向对象

class MyClass:
    """文档注释"""
    i = 123

    def __init__(self, param):
        self.param = param

    def f(self):  # 第一个参数必须为 self
        print('hello world')


c = MyClass("some_str")
print(MyClass.i)  # 123
print(c.i)  # 123
print(c.param)  # some_str
c.f()  # 调用 MyClass.f(c)

class DerivedClassName(BaseClassName):
    pass


class DerivedClassName(Base1, Base2, Base3):
    pass

协程

import asyncio


async def test():
    return 'test'


async def async_function(*params):
    s = await test()
    return "{} {}".format(s, ','.join(list(map(str, params))))


try:
    async_function(123, 456).send(None)
except StopIteration as e:
    print(e.value)  # async_function 的返回值


asyncio.run(async_function(123, 456))  # 得不到返回值

←Back to home

This work is licensed under CC BY-NC-SA 4.0