python快速上手_Python快速上手

准备

pip 下载慢

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

vcode 配置

{"code-runner.executorMap":{"python":"set PYTHONIOENCODING=utf8 && python -u"},"python.pythonPath":"E:\\Program Files\\Python\\Python38\\python.exe","python.linting.pylintEnabled":true,"python.linting.enabled":true,"[python]":{"editor.tabSize":4}}

规范

4 个空格缩进

没有常量， 一般约定纯大写的就是常量

数据类型

动态类型

a = 123

a = '123'

print(a)

print(a-1) # 报错

数字

由于是动态类型 整数，浮点数区分起来只能靠一些函数

对大数字的支持比较好，不用担心溢出

a = 123

print(isinstance(a, int), isinstance(a, float))

a = 123.0

print(isinstance(a, int), isinstance(a, float))

字符串

单双引号没区别，有个优点如下

print("I\'m ok")

print("I'm ok")

保留换行的字符串

print('''line1

line2''')

布尔值

注意是大写，运算符为 and、or 和 not

a = True

a = False

空值

None

运算符注意

10/3 # 3.33333

集合类

元组，tuple，不可变长，使用 len(arr)获取长度，越界取值报错，无法删除使用 del 释放

z 支持切片操作，元组

a = ()

b = (2,) # 为防止歧义，只有一个元素必须要加逗号，当然，只有一个元素的数组也没啥意义

# 使用tuple函数构建tuple(list)

tuple(tuple)

tuple(dict) # 所有的key

列表，list，可变长,，使用 len(arr)获取长度，可用 append，pop，pop(i)，等方法

越界取值报错，空 list 调用 pop 报错

a = [2]

[1, 2, 3] + [4, 5, 6] # 组合['Hi!'] * 4 # 重复3 in [1,2,3]

字典，dict，其他语言都叫做 map,删除使用 pop(key)

m = {'k1': 1, 'k2': 2}

m['k3'] = 3

print('k4' in m)

print(m.get('k4')) # Noneprint(m['k4']) # KeyError

# 通过dict方法构建m1 = dict(k1=1,k2=2) # 传入关键字print(m1)

m2 = dict(zip(['k1','k2'],[1,2])) # 映射函数方式来构造字典print(m2)

m3 = dict([('k1', 1),('k2', 2)]) # 可迭代对象方式来构造字典print(m3)

集合，set

s = {1, 2, 3}

# 也可以使用set方法构建s2 = set([1,2,3,4])

s3 = set((1,2,3,4))

循环

只有一种for ... in ...的写法，想要获取下标可以换一种思路

arr = (2, 4, 6, 8, 10)

for item in arr:

print(item)

for idx in range(len(arr)):

print(arr[idx])

for i, v in enumerate(arr):

print(i, v)

列表生成

print(list(range(0, 10))) # 等价 range(10)print(list(range(0, 10, 2))) # 0 2 4 6 8

# 列表生成式print([x * x for x in range(10)])

print([x * x for x in range(10) if x > 5])

print([m + n for m in 'ABC' for n in 'XYZ'])

# 生成器,返回一个函数，每次调用next计算出下个值，最后抛出 StopIteration 异常g = (x*x for x in range(2, 10))

print(next(g)) # 4print(next(g)) # 9

函数式编程

map,reduce,filter，sorted 和 es6 里面的意思差不多

from functools import reduce

sum = reduce(lambda x, y: x+y, list(range(1, 11)))

print(sum)

函数

支持的特性：必选参数，参数默认值，可变参数，关键字参数，命名关键字参数

注意： 默认参数值必须指向不变对象，假如是 list 的话，这个引用会被一直保持着

注意：不能多传，不能少传，传值顺序不能有歧义

def f1():

pass

f1(123) # takes 0 positional arguments but 1 was given

def f2(a, b=99, *c):

print(a, b, c)

f2(1) # 1 99 ()f2(1, 2) # 1 2 ()

# f2(1, a=2) # got multiple values for argument 'a'f2(b=2, a=1) # 1 2 ()f2(2, 3, 4, 5, 6) # 2 3 (4, 5, 6)

强制使用关键词参数，*后面的参数必须通过带参数名的方式传值，不能多传，不能少传

def f2(name, *, p1, p2):

print(name, p1, p2)

# f2('zs', 5, 6)f2('zs', p1=5, p2=6)

接收多余的关键词参数(命名关键字参数)

def f2(name, **other):

print(other)

# {'age': 18, 'sex': 0}f2(name='zs', age=18, sex=0)

总结：一般其他语言为了避免可变参数的歧义，定义可变参数必须为最后一个参数，但是在 python 中有了命名关键字参数后，可变参数后面还可以定义其他关键词参数

在 Python 中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这 5 种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def f2(name, *p1, p2, p3):

print(name, p1, p2, p3)

f2('zs', 5, 6, 7, p2=6, p3=6)

当定义一个空函数时，可以使用 pass

def f1():

return

def f2():

pass

面向对象

__xx表示私有变量,其实也不是私有，解释器会把它重命名，变成_ClassName__VarName

class User(object):

attr = 'haha' # 类变量 def __init__(self, name):

self.__name = name # 定义成员变量

def print(self):

print('{"name": "%s"}' %(self.__name))

class SpecialUser(User):

def __init__(self, name, weight):

User.__init__(self, name) # 调用父类构造方法 # super(SpecialUser, self).__init__(name) self.weight = weight

u = User('zs')

u.print()

print(u._User__name)

# 动态添加属性u.extName = 'xxx'

两个函数type(),isinstance()

获取类信息dir(),hasattr(),setattr(),getattr()

模块管理

在导入模块的时候，模块会从头到尾执行一遍，然后的变量均可被导出

方便开发运行模块，类似于 main 方法吧，又不希望导入的时候被执行可以可以使用下面的魔法写法

# 在直接运行时候成立if __name__ == "__main__":

pass

导入其他 py 文件的几种方式

在 python 2.7 及之前版本中默认是先“相对”后“绝对”的顺序搜索模块，之后是先搜索绝对路径如果有就停止，所以在你的文件名，包名尽量起的不要和常用库的名字一样

import tool

# 相对导入只能在模块中使用，且无法直接执行运行，需要以模块的方式去跑

# python -m dirname.filenameimport .tool

from . import tool

# 子目录import dir.tool

dir.tool.say()

# 重命名import dir.tool as t

t.say()

# 导出单个方法from dir.tool import say,move

say()

move()

实际项目中，一般都是以目录作为模块的划分，直接导入目录，然后在在目录下的__init__.py文件去导入本目录中的文件，然后再暴露出去。系统识别到 init 文件后会把该目录视作一个模块

在如下层级关系中

|-- main.py

|-- m

| |-- a.py

| |-- b.py

没使用__init__.py时候一般是这样用的

import m.a as ma

import m.b as mb

print(ma.name)

print(mb.name)

添加__init__.py后

import m

print(m.aName)

print(m.bName)

import a

import b

aName = a.name

bName = b.name

这时会报错，因为python main.py的搜索路径是当前路径+系统模块路径，在解析__init__.py时，在上述路径中搜索不到 a 和 b

可以通过改变搜索路径来解决这问题，但是对 IDE 可能不太好

import sys

sys.path.append('m')

import a

import b

aName = a.name

bName = b.name

规范的做法是在模块内使用相对路径导入，执行main.py正常。但是由于使用了相对导入__init__.py就无法作为脚本直接执行了,需要到外层python -m m.__init__进行执行

from . import a

from . import b

aName = a.name

bName = b.name

第三方库使用 pip 管理，官方源，下载慢建议替换成清华的源

pip install –upgrade pip

pip install requests

使用 python3 的 typing 模块提高代码健壮性

Python 在 3.5 版本中引入了 typing 模块，实现了类型提示功能

这里需要注意的一点是，Python typing 本质是一种注释，可以用来帮助 IDE 进行类型检查和自动补全等操作，但是他并不会真的让执行失败。

from typing import List, Tuple, Dict

int,long,float: 整型,长整形,浮点型;

bool,str: 布尔型，字符串类型；

List, Tuple, Dict, Set:列表，元组，字典, 集合;

Iterable,Iterator:可迭代类型，迭代器类型；

Generator：生成器类型；

from typing import List

# 声明新的类型NewType = List[str]

# 定义参数类型，定义返回值类型def conv(list: List[int]) -> NewType:

temp: NewType = []

for item in list:

temp.append(hex(item))

return temp

print(conv([3, 5, 8]))

参考