vscode 配置 python3开发环境
https://blog.csdn.net/weixin_40528417/article/details/81141567
Python面向对象
语法
以下是 print() 方法的语法:
print(*objects, sep=' ', end='
', file=sys.stdout)
参数
objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
sep -- 用来间隔多个对象，默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符
，我们可以换成其他字符串。
file -- 要写入的文件对象。
print("www","runoob","com",sep=".") # 设置间隔符
输出： www.runoob.com
- print格式化
print('{0},{1}'.format('zhangk', 32))
print('{},{},{}'.format('zhangk','boy',32))
print('{name},{sex},{age}'.format(age=32,sex='male',name='zhangk'))
# 格式限定符
# 它有着丰富的的“格式限定符”（语法是{}中带:号），比如：
# 填充与对齐
# 填充常跟对齐一起使用
# ^、<、>分别是居中、左对齐、右对齐，后面带宽度
# :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充
print('{:>8}'.format('zhang'))
print('{:0>8}'.format('zhang'))
print('{:a<8}'.format('zhang'))
print('{:p^10}'.format('zhang'))
# 精度与类型f
# 精度常跟类型f一起使用
print('{:.2f}'.format(31.31412))
# 其他类型
# 主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制
print('{:b}'.format(15))
print('{:d}'.format(15))
print('{:o}'.format(15))
print('{:x}'.format(15))
# 用逗号还能用来做金额的千位分隔符
print('{:,}'.format(123456789))
基础
- 多行语句
可以使用斜杠（ ）将一行的语句分为多行显示，如下所示：
语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例：total = item_one + item_two + item_threedays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'] - Python注释
python中单行注释采用 # 开头。python 中多行注释使用三个单引号(''')或三个双引号(""")。''' 这是多行注释，使用单引号。 这是多行注释，使用单引号。 这是多行注释，使用单引号。 ''' """ 这是多行注释，使用双引号。 这是多行注释，使用双引号。 这是多行注释，使用双引号。 """ - 同一行显示多条语句
Python可以在同一行中使用多条语句，语句之间使用分号(;)分割，以下是一个简单的实例：import sys; x = 'runoob'; sys.stdout.write(x + ' ')
Python的数组分三种类型
Python的数组分三种类型：
- (1) list 普通的链表，初始化后可以通过特定方法动态增加元素。
定义方式：arr = [元素] - (2) Tuple 固定的数组，一旦定义后，其元素个数是不能再改变的。
定义方式：arr = (元素) - (3) Dictionary 词典类型， 即是Hash数组。
定义方式：arr = {元素k:v}
变量
-
多变量赋值
Python允许你同时为多个变量赋值。例如：a = b = c = 1也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, "john" -
Python 元组
元组是另一个数据类型，类似于 List（列表）。
元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。tuple = ("runoob", 786, 2.23, "john", 70.2) tinytuple = (123, "john") print(tuple) # 输出完整元组 print(tuple[0]) # 输出元组的第一个元素 print(tuple[1:3]) # 输出第二个至第四个（不包含）的元素 print(tuple[2:]) # 输出从第三个开始至列表末尾的所有元素 print(tinytuple * 2) # 输出元组两次 print(tuple + tinytuple) # 打印组合的元组以上实例输出结果：
('runoob', 786, 2.23, 'john', 70.2)
runoob
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('runoob', 786, 2.23, 'john', 70.2, 123, 'john') -
Python 字典
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。dict = {} dict["one"] = "This is one" dict[2] = "This is two" tinydict = {"name": "john", "code": 6734, "dept": "sales"} print(dict["one"]) # 输出键为'one' 的值 print(dict[2]) # 输出键为 2 的值 print(tinydict) # 输出完整的字典 print(tinydict.keys()) # 输出所有键 print(tinydict.values()) # 输出所有值输出结果为：
This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']
Python运算符
% 取模 - 返回除法的余数
** 幂 - 返回x的y次幂
// 取整除 - 返回商的整数部分（向下取整） 9//2输出为4 -9//2输出为-5
-
Python位运算符
运算符 描述 & 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 ^ 按位异或运算符：当两对应的二进位相异时，结果为1 ~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1 << 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。 >> 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 a = 60 # 60 = 0011 1100 b = 13 # 13 = 0000 1101 c = 0 c = a & b # 12 = 0000 1100 print("1 - c 的值为：", c) c = a | b # 61 = 0011 1101 print("2 - c 的值为：", c) c = a ^ b # 49 = 0011 0001 print("3 - c 的值为：", c) c = ~a # -61 = 1100 0011 print("4 - c 的值为：", c) c = a << 2 # 240 = 1111 0000 print("5 - c 的值为：", c) c = a >> 2 # 15 = 0000 1111 print("6 - c 的值为：", c) -
Python逻辑运算符
运算符 逻辑表达式 描述 and x and y 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 or x or y 布尔"或" - 如果 x 是非 0，它返回 x 的值，否则它返回 y 的计算值。 not not x 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 -
Python成员运算符
运算符 描述 实例 in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 -
Python身份运算符
运算符 描述 实例 is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。
Python 循环语句
循环控制语句
| 控制语句 | 描述 |
|---|---|
| break 语句 | 在语句块执行过程中终止循环，并且跳出整个循环 |
| continue 语句 | 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。 |
| pass 语句 | pass是空语句，是为了保持程序结构的完整性。 |
# 输出 Python 的每个字母
for letter in "Python":
if letter == "h":
pass # pass 不做任何事情，一般用做占位语句。
print("这是 pass 块")
print("当前字母 :", letter)
print("Good bye!")
Python 字符串
-
Python 字符串格式化
控制语句 描述 %c 格式化字符及其ASCII码 %s 格式化字符串 %d 格式化整数 %u 格式化无符号整型 %o 格式化无符号八进制数 %x 格式化无符号十六进制数 %X 格式化无符号十六进制数（大写） %f 格式化浮点数字，可指定小数点后的精度 %e 用科学计数法格式化浮点数 %E 作用同%e，用科学计数法格式化浮点数 %g %f和%e的简写 %G %f 和 %E 的简写 %p 用十六进制数格式化变量的地址
Python函数
lambda 匿名函数
语法
lambda函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
如下实例：
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print("相加后的值为 : ", sum(10, 20))
print("相加后的值为 : ", sum(20, 20))
return 语句
return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。
Python 模块
Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。
import 语句
祥见 Python import与from import使用
from…import 语句
祥见 Python import与from import使用
from…import* 语句
祥见 Python import与from import使用
Python中的包
包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。
简单来说，包就是文件夹，但该文件夹下必须存在 init.py 文件, 该文件的内容可以为空。init.py 用于标识当前文件夹是一个包。
考虑一个在 package_runoob 目录下的 runoob1.py、runoob2.py、init.py 文件，test.py 为测试调用包的代码，目录结构如下：
|-test.py
|-package_runoob
|-- init.py
|-- runoob1.py
|-- runoob2.py
源代码如下：
package_runoob/runoob1.py
def runoob1():
print("I'm in runoob1")
package_runoob/runoob2.py
def runoob2():
print("I'm in runoob2")
package_runoob/_init_.py
if __name__ == '__main__':
print '作为主程序运行'
else:
print 'package_runoob 初始化'
然后我们在 package_runoob 同级目录下创建 test.py 来调用 package_runoob 包
# 导入 Phone 包
from package_runoob.runoob1 import runoob1
from package_runoob.runoob2 import runoob2
runoob1()
runoob2()
以上实例输出结果：
package_runoob 初始化
I'm in runoob1
I'm in runoob2
Python异常处理
比如抛出常规错误的基类 Exception
try:
fo = open("foo.txt", "w")
print("文件名: ", fo.name)
print("是否已关闭 : ", fo.closed)
print("访问模式 : ", fo.mode)
print("末尾是否强制加空格 : ", fo.softspace)
fo.write("www.runoob.com!
Very good site!
")
except Exception as e:
print(e)
finally:
# 关闭打开的文件
fo.close()
Python设计模式
类的私有属性
__privateAttrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__privateAttrs。
单下划线、双下划线、头尾双下划线说明：
- _foo_: 定义的是特殊方法，一般是系统定义名字 ，类似 init() 之类的。
- _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
- __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。
Python import与from import使用
锚点 Python import与from import使用
import语句
语法：
import module1[, module2[,... moduleN]]
实例：
1、使用random模块ranint() 函数：
# printRandom.py
import random
for i in range(5):
print(random.randint(1, 10))
# result:
5
3
6
4
9
2、导入多个模块：
import math, sys, random, os
from import语句
这是导入模块的另一种形式，使用这种形式的 import 语句， 调用 模块中的函数时不需要 moduleName. 前缀 。但是，使用完整的名称会让代码更可读，所以最好是使用普通形式的 import 语句 。
语法：
from moduleName import name1[, name2[, ... nameN]]|*
实例：
导入random模块下的所有函数：
from random import *
for i in range(5):
print(randint(1, 10)) # 这里就不需要random.前缀了
导入random模块下的randint, random函数：
from random import randint, random
不建议用 "from module import *"
在实践中, "from module import *" 不是良好的编程风格，如果使用from导入变量，且那些变量碰巧和作用域中现有变量同名，那么变量名就会被悄悄覆盖掉。使用import语句的时候就不会发生这种问题，因为我们是通过模块名才获取的变量名，像module.attr不会和现有作用域的attr冲突。
何时使用from import：
我们只在两种场合下建议使用这样的方法, 一个场合是：目标模块中的属性非常多, 反复键入模块名很不方便 , 例如 Tkinter (Python/Tk) 和 NumPy (Numeric Python) 模块 , 可能还有 socket 模块。
另一个场合是在交互解释器下, 因为这样可以减少输入次数。
python实例方法，静态方法，类方法
来源 https://www.jianshu.com/p/212b6fdb2c50
python 类语法中有三种方法，实例方法，静态方法，类方法。
# coding:utf-8
class Foo(object):
"""类三种方法语法形式"""
def instance_method(self): #第一个参数必须要默认传实例对象，一般习惯用self。
print("是类{}的实例方法，只能被实例对象调用".format(Foo))
@staticmethod
def static_method(): #静态方法，参数没有要求。
print("是静态方法")
@classmethod
def class_method(cls): #类方法，第一个参数必须要默认传类，一般习惯用cls。
print("是类方法")
foo = Foo()
foo.instance_method()
foo.static_method()
foo.class_method()
print('----------------')
Foo.static_method()
Foo.class_method()
实例方法只能被实例对象调用，静态方法(由@staticmethod装饰的方法)、类方法(由@classmethod装饰的方法)，可以被类或类的实例对象调用。
实例方法，第一个参数必须要默认传实例对象，一般习惯用self。
静态方法，参数没有要求。
类方法，第一个参数必须要默认传类，一般习惯用cls。
静态方法、类方法使用区别或者说使用场景
1、类方法用在模拟java定义多个构造函数的情况。
由于python类中只能有一个初始化方法，不能按照不同的情况初始化类。
# coding:utf-8
class Book(object):
def __init__(self, title):
self.title = title
@classmethod
def create(cls, title):
book = cls(title=title)
return book
book1 = Book("python")
book2 = Book.create("python and django")
print(book1.title)
print(book2.title)
2、类中静态方法方法调用静态方法的情况。
下面的代码，静态方法调用另一个静态方法，如果改用类方法调用静态方法，可以让cls代替类，
让代码看起来精简一些。也防止类名修改了，不用在类定义中修改原来的类名。
# coding:utf-8
class Foo(object):
X = 1
Y = 2
@staticmethod
def averag(*mixes):
return sum(mixes) / len(mixes)
@staticmethod
def static_method():
return Foo.averag(Foo.X, Foo.Y)
@classmethod
def class_method(cls):
return cls.averag(cls.X, cls.Y)
foo = Foo()
print(foo.static_method())
print(foo.class_method())
3、继承类中的区别
从下面代码可以看出，如果子类继承父类的方法，子类覆盖了父类的静态方法，
子类的实例继承了父类的static_method静态方法，调用该方法，还是调用的父类的方法和类属性。
子类的实例继承了父类的class_method类方法，调用该方法，调用的是子类的方法和子类的类属性。
# coding:utf-8
class Foo(object):
X = 1
Y = 2
@staticmethod
def averag(*mixes):
return sum(mixes) / len(mixes)
@staticmethod
def static_method():
return Foo.averag(Foo.X, Foo.Y)
@classmethod
def class_method(cls):
return cls.averag(cls.X, cls.Y)
class Son(Foo):
X = 3
Y = 5
@staticmethod
def averag(*mixes):
return sum(mixes) / 3
p = Son()
print(p.static_method())
print(p.class_method())
python中self和cls的区别
self代表类的实例，而非类
class Test:
def prt(self):
print(self)
print(self.__class__)
t = Test()
t.prt()
输出：
<__main__.Test instance at 0x10d066878>
_main_.Test
从执行结果可以很明显的看出，self 代表的是类的实例，代表 当前对象的地址，而 self._class_ 则指向类。
class A(object):
def foo1(self):
print("Hello", self)
@staticmethod
def foo2():
print("hello")
@classmethod
def foo3(cls):
print("hello", cls)
a = A()
a.foo1() # self 代表的是类的实例，代表 当前对象的地址
# 输出 Hello <__main__.A object at 0x00000208384802B0>
A.foo1(a) # self 代表的是类的实例，代表 当前对象的地址
# 输出 Hello <__main__.A object at 0x00000208384802B0>
A.foo2() # 这里，由于静态方法没有参数，故可以不传东西
# 输出 hello
A.foo3() # cls表示这个类本身
# 输出 hello <class '__main__.A'>
- 1、self表示一个具体的实例本身。如果用了staticmethod，那么就可以无视这个self，将这个方法当成一个普通的函数使用。
- 2、cls表示这个类本身。
- 3、类先调用__new__方法，返回该类的实例对象，这个实例对象就是__init__方法的第一个参数self，即self是__new__的返回值。
Python中的__new__ __init__区别
来源：https://www.cnblogs.com/suntp/p/6445286.html
_init_ 方法
_init_ 方法通常用在初始化一个类实例的时候。例如：
# -*- coding: utf-8 -*-
class A(object):
def __init__(self,*args, **kwargs):
print "init A"
def __new__(cls,*args, **kwargs):
print "new A %s"%cls
#return super(A, cls).__new__(cls, *args, **kwargs)
return object.__new__(cls, *args, **kwargs)
1、继承自object的新式类才有__new__
2、_new_至少要有一个参数cls，代表当前类，此参数在实例化时由Python解释器自动识别
3、_new_必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类（通过super(当前类名, cls)）__new__出来的实例，或者直接是object的__new__出来的实例
4、__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值
5、如果__new__创建的是当前类的实例，会自动调用__init__函数，通过return语句里面调用的__new__函数的第一个参数是cls来保证是当前类实例，如果是其他类的类名，；那么实际创建返回的就是其他类的实例，其实就不会调用当前类的__init__函数，也不会调用其他类的__init__函数。
python中带*号的参数，一个星号，两个星号
参数前加一个星号，将传递进来的参数放在同一个元组中，该参数的返回值是一个元组
参数前两个星号，将传递进来的参数放到同一个字典中，该参数返回值为一个字典
def function_with_one_star(*d):
print(d, type(d))
def function_with_two_stars(**d):
print(d, type(d))
# 上面定义了两个函数，分别用了带一个星号和两个星号的参数，它们是什么意思，运行下面的代码：
function_with_one_star(1, 2, 3)
function_with_two_stars(a=1, b=2, c=3)
# 结果如下
(1, 2, 3) <</span>class 'tuple'>
{'a': 1, 'c': 3, 'b': 2} <</span>class 'dict'>
python列表和元组的区别
- 元组（Tuple） t = (1, 2, 3, 4)
列表（List） t = [1, 2, 3, 4, 5, 6] - 列表和元组的区别
- 列表是动态数组，它们可变且可以重设长度（改变其内部元素的个数）。
- 元组是静态数组，它们不可变，且其内部数据一旦创建便无法改变。
- 元组缓存于Python运行时环境，这意味着我们每次使用元组时无须访问内核去分配内存。
这些区别结实率两者在设计哲学上的不同：
- 列表可被用于保存多个互相独立对象的数据集合
- 元组用于描述一个不会改不安的事务的多个属性
虽然它们不支持改变大小，但是我们可以将两个元组合并成一个新元组 ，如：
t1 = (1, 2, 3, 4)
t2 = (5, 6, 7, 8)
print(t1 + t2)
结果：
(1, 2, 3, 4, 5, 6, 7, 8)
python三种字符串（无前缀，前缀u，前缀b）与encode()
三种前缀（无前缀，前缀u，前缀b），但是字符串的类型只有两种（str，bytes）
encode()函数根据括号内的编码方式，把str类型的字符串转换为bytes字符串，字符对应的若干十六进制数，根据编码方式决定。
strString = b'我爱你中国'
# b'' bytes转字符串为:
strString.decode('utf-8')
Python raise用法
自行引发异常
def main():
try:
# 使用try...except来捕捉异常
# 此时即使程序出现异常，也不会传播给main函数
mtd(3)
except Exception as e:
print('程序出现异常:', e)
# 不使用try...except捕捉异常，异常会传播出来导致程序中止
mtd(3)
def mtd(a):
if a > 0:
raise ValueError("a的值大于0，不符合要求")
main()
Python yield
来源 https://www.ibm.com/developerworks/cn/opensource/os-cn-python-yield/
yield 的作用就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator，调用 fab(5) 不会执行 fab 函数，而是返回一个 iterable 对象！在 for 循环执行时，每次循环都会执行 fab 函数内部的代码，执行到 yield b 时，fab 函数就返回一个迭代值，下次迭代时，代码从 yield b 的下一条语句继续执行，而函数的本地变量看起来和上次中断执行前是完全一样的，于是函数继续执行，直到再次遇到 yield。
示例1：
def fab(max):
n, a, b = 0, 0, 1
while n < max:
yield b
# print b
a, b = b, a + b
n = n + 1
for n in fab(5):
print(n)
示例2：
def count(n):
print ("cunting" )
while n > 0:
print ('before yield')
yield n #生成值：n
n -= 1
print ('after yield' )
for n in count(5):
print(n)
# 输出
cunting
before yield
5
after yield
before yield
4
after yield
before yield
3
after yield
before yield
2
after yield
before yield
1
after yield
为方便理解，再改成例3：
def count(n):
print ("cunting" )
while n > 0:
print ('before yield')
yield n #生成值：n
n -= 1
print ('after yield' )
c = count(5)
print("
")
c.__next__()
print("
")
c.__next__()
print("
")
c.__next__()
print("
")
c.__next__()
print("
")
c.__next__()
#输出：
cunting
before yield
after yield
before yield
after yield
before yield
after yield
before yield
after yield
before yield
例4：
def fibonacci():
a=b=1
#yield a #如果没有这个yield就不会输出a的初始值1
#yield b #如果没有这个yield就不会输出b的初始值1
while True:
a,b = b,a+b
yield b
for num in fibonacci():
if num > 100:
break
print (num),
输出：
2
3
5
8
13
21
34
55
89
for在字典、列表、元组、join内
注册for后没有冒号
import random
import string
# 创建字典：
dic = {
str(i): i
for i in range(5)
}
print(type(dic))
print(dic)
# 创建列表：
list = [
i
for i in range(5)
]
print(type(list))
print(list)
# 创建"元组"generator迭代器：
tup = (
i
for i in range(5)
)
print(type(tup))
print(tup)
#随机生成一个11位的字符串
bid = ''.join(random.choice(string.ascii_letters + string.digits) for x in range(11))
print(type(bid))
print(bid)
输出：
<class 'dict'>
{'0': 'ok0yes', '1': 'ok1yes', '2': 'ok2yes', '3': 'ok3yes', '4': 'ok4yes'}
<class 'list'>
[0, 1, 2, 3, 4]
<class 'generator'>
<generator object <genexpr> at 0x0000020B66E720A0>
<class 'str'>
hIgc66bAm7v