from__future__import ......：py编译器引入高版本功能，需在首行。（比如，3.多版本对于2.多来说就是future）
import argparse:解析命令行参数和选项的标准模块（视频：https://www.aparat.com/v/pl6c0/Python_Tutorial_-_Argparse）
import os.path关于路径的各种各样的操作
import sys：关于系统的操作（外部参数向程序内部传递，退出程序，指定模块搜索路径字符串集合，标准流对象）
import torch:使用GPU和CPU优化深度学习的张量库(官方中文文档：https://pytorch-cn.readthedocs.io/zh/latest/)
import pdb:代码调试（？）：查找所有匹配的路径并将其以list形式返回
import re:使用正则表达式,处理文本经典模块
import glob: 查找匹配路径并以列表返回
import copy:用来深复制的包（因为python的对象都是建立索引来的，如果要改变对象，则要使用）
numpy.random.normal(loc,scale,size)：创建一个高斯分布，参数为均值(对称中心)，标准差（越大越矮胖，越小越高瘦），输出shape(?)
lambda表达式：所有只用一行就能够表达函数可转lambda,格式：
```
lambda para1,para2:para1 op para2  #冒号前面是参数，后面是表达式
```

assert:

一般用于测试
后面跟true
否则, 会报错

python命名规则:

#模块: 小写 + 下划线--------------------------------------------------

# 正确的模块名
import decoder
import html_parser

# 不推荐的模块名
import Decoder



#类名: 驼峰(首字母大写) + 不是下划线------------------------------------------------

class Farm():
    pass

class AnimalFarm(Farm):
    pass

class _PrivateFarm(Farm):
    pass



#函数: 小写 + 下划线----------------------------------------------------

def run():
    pass

def run_with_env():
    pass

class Person():
    def _private_func():
        pass




#变量名: 小写 + 下划线----------------------------------------------------

    count = 0
    school_name = ''



#常量: 大写 + 下划线----------------------------------------------------
    MAX_CLIENT = 100
    MAX_CONNECTION = 1000
    CONNECTION_TIMEOUT = 600

指定使用某个GPU运行:

在python文件第一行加上以下语句，这个python脚本就只会使用id为“2”的gpu。

import os
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = "2"
# use multiple gpus
# os.environ["CUDA_VISIBLE_DEVICES"] = "0,1"

yield:

作用: 返回一个可以用来迭代（for循环）的生成器。
应用场景: 一个需要返回一系列值的，含有循环的函数中。
迭代器:
- 迭代器是一个对象
- 这种对象每次只能调取一个数据元素。
- 迭代器不断调用 next() 方法
生成器函数和生成器:
- 生成器函数是一种特殊的函数，它的函数内部含有yield表达式
- 调用它会返回一个特殊的迭代器，称生成器。
- ```
def func():
    return 1
 
def gen():
    yield 1
 
print(type(func))   # <class 'function'>
print(type(gen))    # <class 'function'>
 
print(type(func())) # <class 'int'>
print(type(gen()))  # <class 'generator'>
```
- 如果一个函数定义中包含 yield 表达式，那么该函数是一个生成器函数
- 实际上，yield 仅能用于定义生成器函数。
- 与普通函数不同，生成器函数被调用后，其函数体内的代码并不会立即执行，而是返回一个生成器
- yield的本质功能还是返回了一个可供迭代的列表。
yield的优点:
- 如果容器内的元素数量非常多（比如有 10 ** 8 个），或者容器内的元素体积非常大
- yield 把函数变成一个生成器函数，每次只产生一个元素，就能节省很多开销了。

eval（）：

能够以Python表达式的方式解析并执行字符串
将去掉字符串的两个引号
单引号，双引号，eval()函数都将其解释为int类型；三引号则解释为str类型

[::]:

enumerate() :

用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,
同时列出数据和数据下标
一般用在 for 循环当中

python @property的介绍与使用：

@property是python的一种装饰器，是用来修饰方法的。

作用：
- 可以使用@property装饰器来创建只读属性
- @property装饰器会将方法转换为相同名称的只读属性
- 可以与所定义的属性配合使用，这样可以防止属性被修改。
- python进行属性的定义时，没办法设置私有属性，因此要通过@property的方法来进行设置。这样可以隐藏属性名，让用户进行使用的时候无法随意修改。

修饰方法，是方法可以像属性一样访问：
- 调用的时候，方法后面添加了()，那么就会显示错误信息
- 如果后面加入了()，那么就是当作函数来调用，而它却不是callable（可调用）的

python中/和//的区别:

“ / ” 为浮点数除法，返回浮点结果
“ // ” 表示整数除法，返回不大于结果的一个最大整数

print("6 / 4 =" + str(6 / 4))       #1.5
print("6 // 4 =" + str(6 // 4))     #1

Python中异常捕捉try..except...finally的使用：

前言：

Python开发中，常见错误类型有两种：语法错误和异常。（此处要讨论的自然是异常）
如果有异常不处理，程序会挂起，异常后的代码都不会执行。


#0.捕捉异常和不捕捉异常的区别在哪里？
num = 5
print(num/0)
 
print("我是try之外的代码，你猜我会执行吗？哈哈哈")
print("我是try之外的代码，你猜我会执行吗？呵呵呵呵")
-------不捕捉异常的结果，异常代码后面的代码print都不会执行-------------------------------------
Traceback (most recent call last):
  File "D:/pythoyworkspace/file_demo/Class_Demo/Exception_demo.py", line 3, in <module>
    print(num/0)
ZeroDivisionError: division by zero



#即，异常之后的代码都没有执行

常见的错误，如：
- 文件不存在
- 除以整数零
如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之外的代码。

------------------捕捉异常的代码---------------------------------------------------------
try:
    num = 5
    print(num/0)
except Exception as ex_results:
    print("有情况")
    print("抓了一个异常：",ex_results)
print("我是try之外的代码，你猜我会执行吗？哈哈哈")
==============捕捉异常后代码的执行结果：异常后的代码print会执行=============================
有情况
抓了一个异常： division by zero
我是try之外的代码，你猜我会执行吗？哈哈哈
我是try之外的代码，你猜我会执行吗？呵呵呵

try--except同时处理多个异常类型。


try:
    num = 5
    print(num/0)
    print("准备open the file")
    f1 = open("aaa.txt","r")
    print("the file is open")
except(IOError,ZeroDivisionError): #可以同时处理多个异常，各种类型用元组封装
    print("垃圾，程序有异常了")

如果不确定异常类型，可以except后面什么都不写。


try:
    num = 5
    print(num/0)
    print("准备open the file")
    f1 = open("aaa.txt","r")
    print("the file is open")
except:
    print("垃圾，程序有异常了")

打印异常类型，但是实际异常后面的代码不会执行，所以只能捕捉一个异常。


try:
    f1 = open("aaa.txt", "r")
    print("the file is open")
    num = 5
    print(num/0)
    print("准备open the file")
except (IOError,ZeroDivisionError) as ex_results: 
    print(ex_results)
=========================================================================
[Errno 2] No such file or directory: 'aaa.txt'

捕捉所有异常，这种情况适合不知道异常具体类型，但是又想存储打印异常类型。


try:
    num = 5
    print(num/0)
    f1 = open("aaa.txt", "r")
    print("the file is open")
    print("准备open the file")
except Exception as ex_results:
    print("有情况")
    print("抓了一个异常：",ex_results)
print("我是try之外的代码，你猜我会执行吗？哈哈哈")
print("我是try之外的代码，你猜我会执行吗？呵呵呵呵")
==========================================================================
有情况
抓了一个异常： division by zero
我是try之外的代码，你猜我会执行吗？哈哈哈
我是try之外的代码，你猜我会执行吗？呵呵呵呵

try--except可以配上else,类似while else ,for else的使用（这里可以把except当if用，if else同except else的逻辑关系）
else 只有在没有异常时才会执行的代码

try:
    num = input("请输入一个整数除数：")
    result = 100.0/int(num)
    print("商的结果是：%f"%result)
except ZeroDivisionError as ex_results:
    print("有情况")
    print("抓了一个异常：",ex_results)
else :
    print("恭喜,没有 错误")
==========================================================================
请输入一个整数除数：6
商的结果是：16.666667
恭喜,没有 错误
请输入一个整数除数：0
有情况
抓了一个异常： float division by zero

finally：在程序中，如果一个段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用finally。比如文件关闭，释放锁，把数据库连接返还给连接池等,注意：finally是可选的选项。
finally 无论是否有异常，都会执行的代码


try:
    f1 = open("test.txt","rU")
    for i in f1:
        i=i.strip()
        print(i)
except Exception as E_results:
    print("捕捉有异常：",E_results)
finally: #finally的代码是肯定执行的，不管是否有异常,但是finally语块是可选的。
    f1.close
    print("我不管，我肯定要执行。")
------------------程序无异常会执行-----------------------------------
ccccccccccd
ddddddddddddddddd
333343434343
safsdfasdfsadfsa
我不管，我肯定要执行。


------------------程序有异常还是会执行----------------------------------
File "D:/pythoyworkspace/file_demo/Class_Demo/Exception_demo.py", line 44, in <module>
捕捉有异常： [Errno 2] No such file or directory: 'tes2t.txt'
    f1.close
我不管，我肯定要执行。

注意try..finally的使用,可以没有except。（finally是可选的）


try:
    f1 = open("tes3t.txt","rU")
    for i in f1:
        i=i.strip()
        print(i)
finally: #finally的代码是肯定执行的，不管是否有异常,但是finally语块是可选的。
    print("我不管，我肯定要执行。")
    f1.close

异常类型要很精确的，否则没有用。如果不确定异常类型，可以直接什么都不写


try:
    num = 5
    print(num/0) #ZeroDivisionError: division by zero
except IOError:
    print("报错了，分母不能为0")


try:
    num = 5
    print(num/0) #ZeroDivisionError: division by zero
except ZeroDivisionError:
    print("报错了，分母不能为0")


try:
    num = 5
    print(num/0) #ZeroDivisionError: division by zero
except :
    print("报错了，分母不能为0")

异常的传递（子函数如果没有异常处理语句，会传回给调用函数，直到处理）（其实就是子函数调用的过程）
异常之后的语句都不会执行
异常的传递 —— 当 函数/方法 执行 出现异常，会 将异常传递 给函数/方法的 调用一方
如果 传递到主程序，仍然 没有异常处理，程序才会被终止
在开发中，可以在主函数中增加 异常捕获
而在主函数中调用的其他函数，只要出现异常，都会传递到主函数的 异常捕获 中
这样就不需要在代码中，增加大量的 异常捕获，能够保证代码的整洁

def test1():
    print("----test1-1----")
    print(num)
    print("----test1-2----")
 
def test2():
    print("----test2-1----")
    test1()
    print("----test2-2----")
 
def test3():
    try:
        print("----test3-1----")
        test1()
        print("----test3-2----")
    except Exception as result:
        print("捕获到了异常，信息是:%s" % result)
 
    print("----test3-3---")
#注意分析执行的结果
test3()
print("------test3执行完了，分割一下-----")
test2()
 
====================执行结果如下=======================================================
----test3-1----
Traceback (most recent call last):
----test1-1----
  File "D:/pythoyworkspace/file_demo/Class_Demo/Exception_demo.py", line 23, in <module>
    test2()
捕获到了异常，信息是:name 'num' is not defined
----test3-3---
 
------test3执行完了，分割一下------------
NameError: name 'num' is not defined
----test2-1----
----test1-1----

开发中异常处理模式

try:
    # 尝试执行的代码
    pass
except 错误类型1:
    # 针对错误类型1，对应的代码处理
    pass
except 错误类型2:
    # 针对错误类型2，对应的代码处理
    pass
except (错误类型3, 错误类型4):
    # 针对错误类型3 和 4，对应的代码处理
    pass
except Exception as result:
    # 打印错误信息
    print(result)
else:
    # 没有异常才会执行的代码
    pass
finally:
    # 无论是否有异常，都会执行的代码
    print("无论是否有异常，都会执行的代码")

参考博文：https://blog.csdn.net/qq_26442553/article/details/81780004

Python——基础（不断扩充）

fromfutureimport ......：py编译器引入高版本功能，需在首行。（比如，3.多版本对于2.多来说就是future）

import argparse:解析命令行参数和选项的标准模块（视频：https://www.aparat.com/v/pl6c0/Python_Tutorial_-_Argparse）

import os.path关于路径的各种各样的操作

import sys：关于系统的操作（外部参数向程序内部传递，退出程序，指定模块搜索路径字符串集合，标准流对象）

import torch:使用GPU和CPU优化深度学习的张量库(官方中文文档：https://pytorch-cn.readthedocs.io/zh/latest/)

import pdb:代码调试（？）：查找所有匹配的路径并将其以list形式返回

import re:使用正则表达式,处理文本经典模块

import glob: 查找匹配路径并以列表返回

import copy:用来深复制的包（因为python的对象都是建立索引来的，如果要改变对象，则要使用）

numpy.random.normal(loc,scale,size)：创建一个高斯分布，参数为均值(对称中心)，标准差（越大越矮胖，越小越高瘦），输出shape(?)

lambda表达式：所有只用一行就能够表达函数可转lambda,格式：

assert:

python命名规则:

指定使用某个GPU运行:

yield:

迭代器:

生成器函数和生成器:

eval（）：

[::]:

enumerate() :

python @property的介绍与使用：

python中/和//的区别:

Python中异常捕捉try..except...finally的使用：

前言：

猜你喜欢

Python——基础（不断扩充）

from__future__import ......：py编译器引入高版本功能，需在首行。（比如，3.多版本对于2.多来说就是future）

import argparse:解析命令行参数和选项的标准模块（视频：https://www.aparat.com/v/pl6c0/Python_Tutorial_-_Argparse）

import os.path关于路径的各种各样的操作

import sys：关于系统的操作（外部参数向程序内部传递，退出程序，指定模块搜索路径字符串集合，标准流对象）

import torch:使用GPU和CPU优化深度学习的张量库(官方中文文档：https://pytorch-cn.readthedocs.io/zh/latest/)

import pdb:代码调试（？）：查找所有匹配的路径并将其以list形式返回

import re:使用正则表达式,处理文本经典模块

import glob: 查找匹配路径并以列表返回

import copy:用来深复制的包（因为python的对象都是建立索引来的，如果要改变对象，则要使用）

numpy.random.normal(loc,scale,size)：创建一个高斯分布，参数为均值(对称中心)，标准差（越大越矮胖，越小越高瘦），输出shape(?)

lambda表达式：所有只用一行就能够表达函数可转lambda,格式：

assert:

python命名规则:

指定使用某个GPU运行:

yield:

迭代器:

生成器函数 和 生成器:

eval（）：

[::]:

enumerate() :

python @property的介绍与使用：

python中/和//的区别:

Python中异常捕捉try..except...finally的使用：

前言：

猜你喜欢

fromfutureimport ......：py编译器引入高版本功能，需在首行。（比如，3.多版本对于2.多来说就是future）

生成器函数和生成器: