- Python基础
- 标识符
- 标准数据类型
- 语句
- 运算符
- 函数
- range函数
- 模块(Module)
- dir()函数
- 重新执行模块`reload`
- 包
- 类
- 类变量和实例变量
- 类方法
- 类属性(property)
- 类继承
- 类实例的创建与调用
- 命名空间和作用域
主要与C/C++ 语法进行一个区分。 Python基础 标识符
_func()# 表示不能直接访问的类属性，需要通过类提供的接口访问，不可以使用from xxx import *导入。 __func()# 表示类的私有成员 __func__()# 表示python内专用的特殊方法表示，比如__main__
有时候单下划线在程序中会作为临时性的名称使用。
# "_"表示不会在后面再次用到该名称以及其值。
for _ in range(10):
Train_step()
标准数据类型
对String、List等数据类型访问时，不仅可以从左到右访问；也可以从右到左访问，默认从-1开始。
Tuple不能二次赋值，是只读列表。
List是有序的、Dictionary是无序的，通过键值对查值。
重点是不同类型之间的转换。
x = int(10) print(type(x))
out：
y = float(x) print(type(y))
out：
chr(x)# 将一个整数转换为char unichr(x)# 转换为Unicode字符 ord(x)# 将一个字符转换为它的整数值 hex(x)# 转为16进制的【字符串】 oct(x)# 转为8进制的 str(x)# 将对象x转为为字符串 repr(x)# 转为表达式字符串（详细解释看下面） eval(str)# 计算在【字符串】中有效的Python表达式←是一个非常强大的函数！ tuple(s) list(s) set(s)# 将序列转换为可变集合 frozenset(s)# 将序列转换为不可变集合 dict(d)# d必须是一个序列(key,value)的元组
【关于str与repr的详细解释】
【关于eval的详细解释】
\\
语句可以使用’'来将一行的语句分为多行。
total = item_one +
item_two +
item_three
但是如果语句中包含"[]“、”{}“、”()"就不需要使用多行连接符。
days = ['Mon','Tues','Wed',
'Thur','Fri']
允许同时为多个变量赋值。
a = b = c = 1
函数之间 or 类的方法之间用空行间隔，表示一段新代码的开始。类和函数入口之间也用一行空格分隔，以突出函数入口的开始。
\\
运算符算术运算符
| / | 除，x除以y |
|---|---|
| // | 取整除，返回商的整数部分 |
| ****** | 返回x的y次幂 |
比较运算符
| <> | != |
|---|
逻辑运算符
| and | x and y |
|---|---|
| or | x or y |
| not | not x |
成员运算符
| in | 如果在指定序列中找到，返回True |
|---|---|
| not in | 如果在指定序列中没有找到，返回True |
身份运算符
| is | is判断两个标识符是不是引用自一个对象 x is y |
|---|---|
| is not | is判断两个标识符是不是引用自不同对象 |
运算符优先级
| 运算符 | 描述 |
|---|---|
| ****** | 指数，最高优先级 |
| ~、+@、-@ | 按位翻转、一元加减 |
| *、/、%、// | 乘除、取模、取整除 |
| +、- | 加减 |
| >>、<< | 右移、左移 |
| & | 位运算"AND" |
| ^、| | 位运算符 |
| <=、<、>、>= | 比较运算符 |
| <>、==、!= | 等于运算符 |
| =、%=、/=、//=-=、+=、*=、**= | 赋值运算符 |
| is、is not | 身份运算符 |
| in、not in | 成员运算符 |
| not、or、and | 逻辑运算符 |
\\
函数 range函数range(start,stop[,step]) # start：从start开始计数，默认从0开始 # stop：计数到stop停止，但不包括stop。 # step：步长，默认为1
# 上一个栗子
x = 83
flag = 0;
for i in range(2,x):
if(x%i) == 0:
flag = 1;
break;
if(flag != 1):
print(f'{x} is a prime')
out： 83 is a prime
\\
函数一般更多的是自定义函数，有如下规则：
- 代码块以def关键词开头，后接函数标识符名称以及圆括号"( )"。
- 任何传入参数和自变量必须放在圆括号中。圆括号之间可以定义参数。
- 函数的内容以':'起始，以缩进来标记函数的结束。
- 默认情况下，参数值和参数名称按照函数声明中定义的顺序匹配。
- 函数可以返回多个值，参数可以有默认值。
import math
def move(x,y,distance,angle = 0):
"该函数用于移动(x,y)"
newx = x + distance*math.cos(math.pi*angle/180)
newy = y + distance*math.sin(math.pi*angle/180)
return newx,newy
x,y = move(3,4,5,53)
print(f"X:{x}, Y:{y}")
out： X:6.009075115760242, Y:7.993177550236464
Python中除了传递普通实参之外，还可以传递list、dict、*args和*kargs
- *args：表示输入数据长度不确定，通过*args将任意长度的参数传递给函数，系统自动将其用元组表示。
- *kargs：输入数据长度不确定，系统自动将其用dict表示
\\
\\
Module是一个Python文件，以.py结尾，包含了Python对象定义和Python对象语句。模块可有逻辑地组织相关Python代码段。模块能定义函数、类、变量，模块里也能包含可执行代码。这些可执行语句通常用于进行模块地初始化工作，并只在模块第一次被导入时执行。
# 一般导入有以下三种方式 import modname # 导入模块 from modname import modfunc # 从模块中导入指定部分到当前命名空间 from modname import * # 把一个模块中地全部内容全部导入当前地命名空间
搜索路径：
当导入一个Module，Python解析器对模块位置地搜索顺序如下：
- 当前目录。
- 如果不在目录，Python搜索shell变量PYTHONPATH下每个目录。
- 如果都找不到，Python会查看默认路径。Unix下默认路径一般为/usr/local/lib/python。
模块搜索路径存储在system模块的sys.path中。变量里包含当前目录、PYTHONPATH和由安装过程决定的默认目录。
dir()函数查看模块定义的名字可以使用dir()函数。它返回的列表包含了一个模块中定义的所有模块、变量和函数，如以下的实例。
# 导入内置math模块 import math dir(math)
[‘doc’, ‘loader’, ‘name’, ‘package’, ‘spec’, ‘acos’, ‘acosh’, ‘asin’, ‘asinh’, ‘atan’, ‘atan2’,‘atanh’, ‘ceil’, ‘copysign’, ‘cos’, ‘cosh’, ‘degrees’, ‘e’, ‘erf’, ‘erfc’, ‘exp’, ‘expm1’, ‘fabs’, ‘factorial’, ‘floor’, ‘fmod’, ‘frexp’, ‘fsum’, ‘gamma’, ‘gcd’, ‘hypot’, ‘inf’, ‘isclose’, ‘isfinite’, ‘isinf’, ‘isnan’, ‘ldexp’, ‘lgamma’, ‘log’, ‘log10’, ‘log1p’, ‘log2’, ‘modf’, ‘nan’, ‘pi’, ‘pow’, ‘radians’, ‘remainder’, ‘sin’, ‘sinh’, ‘sqrt’, ‘tan’, ‘tanh’, ‘tau’, ‘trunc’]
在以上的栗子中，特殊字符变量如__name__指向的是模块的名字、__file__指向该模块的导入文件名、__doc__为指向注释语句。
\\
当一个模块被导入一个脚本，模块顶层部分的代码只会被执行一次。如果需要重新执行模块里顶层部分的代码，可以使用reload()函数。该函数会重新导入之前导入的模块。
reload(modname)包
当需要很多模块的时候，需要把这些功能依赖的模块组成包。包是分层次的文件目录结构，它定义了由模块、子包、子包下子包等组成的Python应用环境。采用包可以避免不同的人编写相同的模块名。不同的包内可以具有相同的包名。
包中包含__init__.py文件的文件夹。__init__.py中的内容可以为空，用于标识当前文件夹是一个包。
导入包中单独的模块或是函数的方法如下：
import PackageA.SubPackageA.ModuleA# 使用时必须用全路径名 from PackageA.SubPackageA import ModuleA# 使用时可以直接使用模块名而不用加上包前缀 from PackageA.SubPackageA.ModuleA import FunctionA# 直接导入模块中的函数or变量
\\
\\
类变量是类的所有实例化对象共有的，而实例变量是每个实例化对象自身特有的。
感觉类似于C++中的静态变量以及成员变量。
Python默认类变量为公有类型，用两个下划线开头，可以声明该变量为私有变量。
class Dog:
kind='lalala';
def __init__(self,name):
self.name = name
a = Dog('A')
print(a.name)
print(a.kind)
b = Dog('B')
print(b.name)
print(b.kind)
A
lalala
B
lalala
\\
类方法Python中有三种定义类方法，包括常规方式、@classmethod修饰方式和@staticmethod 修饰方式。
- 常规方式：必须包含self，且为第一个参数，self代表的是类的实例。
- 类方法(classmethod)：将self换成任意标识。
- 静态方法(staticmethod)：允许用类名.静态方法名称方式调用。
class A:
__privateVar=0 # 私有类变量
publicVar=0 #公有类变量
def __init__(self,value = 0):# 构造函数
self.mVar = value
def func(self,x): # 普通函数
self.__privateVar += x+self.mVar
self.mVar +=1
print(f"self:{self.__privateVar}")
print(f"mVar:{self.mVar}")
@classmethod
def cls_func(cls,x):
cls.__privateVar +=x
print(f"cls:{cls.__privateVar}")
@staticmethod
def static_func(x):
A.publicVar +=x
print(f"static:{A.publicVar}")
a = A(1)
b = A(10)
a.func(0)
b.func(5)
self:1
mVar:2
self:15
mVar:11
print(a._A__privateVar)
1
a.cls_func(2) b.cls_func(3)
cls:2
cls:5
A.static_func(1000) a.static_func(12)
static:1000
static:1012
__init__是构造函数，在生成对象时调用，并赋予成员变量初值。
使用__开头，声明的方法是私有方法，不能在类外调用。
class PrivateMethodDemo:
_name = 'protected 变量'
__info = 'private 变量'
def __init__(self,value=0):
pass
def _func(self):
print("调用protected 方法")
def __func2(self):
print("调用private 方法")
def get(self):
self.__func2()
return(self.__info)
demo = PrivateMethodDemo()
info = demo.get()
print('显示' + info)
调用private 方法
显示private 变量
demo._func()
调用protected 方法
\\
类属性(property)property是一种特殊的类属性，访问它时会执行一段@property定义的代码(函数)，然后返回值。
即成员变量
class Circle:
def __init__(self,radius):
self.radius = radius # 圆的半径
@property
def area(self):
return math.pi*self.radius**2 # 计算面积
c = Circle(10)
print(c.radius)
print(c.area) # 用访问成员变量一样的形式访问area，执行area函数，并返回值
10
314.1592653589793
\\
类继承- BaseClassName：父类
- DerivedClassName：子类
在Java/C++中：对于子类与父类之间命名相同、返回值相同、参数相同的函数，叫做重写。
对于重载则是在同一个类中，有多个命名相同的函数，它们的返回值以及参数都可能不同。
在子类重写方法内，引用父类方法有两种方法。
class person:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def show(self):
print(f"person:{self.name} {self.age} {self.sex}")
class student(person):
def __init__(self,name,age,sex,course,score):
person.__init__(self,name,age,sex)
self.course = course
self.score = score
def show(self):
print(f"student:{self.name} {self.age} {self.sex} {self.course} {self.score}")
p = person('A','20','F')
s = student('B','18','M','Python','100')
p.show()
s.show()
person:A 20 F
student:B 18 M Python 100
当然，Python也是支持多继承的。建议大家看看以下链接的博客:【一个非常详细的对于继承机制的介绍】
对于下面的例子，如果没有特别说明(比如super)，Python实例化时只会调用一个__init__方法。
class A:
def __init__(self):
print("我是class A的初始化")
super().__init__() # 在一个父类中使用super()方法用于调用下一个父类即B的init方法
class B:
def __init__(self):
print("我是class B的初始化")
class C(A,B):
pass
c=C()
我是class A的初始化
我是class B的初始化
\\
类实例的创建与调用实例化类在其他的编程语言如Java/C++中，一般会使用关键字new。但是Python中没有new关键字，类的实例化类似函数调用方式：a = A()
如果定义了__init__方法，可以通过__init__函数来接收其他的参数。
调用类的成员变量(或者称之为属性)，就直接使用对象.方法来访问。(但注意的是私有变量无法这么访问，会报错）
protected变量和public变量均可这么访问。
\\
\\
一个Python表达式可以访问局部命名空间和全局命名空间里的变量。如果局部变量与全局变量重名，则局部变量会覆盖全局变量。(这一点和C++是一样的）
在函数内也可以定义全局变量或者是操作全局变量，只需使用global关键字即可。Python 3 增加了nonlocal：表示声明的变量是作用域为嵌套的函数最外层范围的一个变量，nonlocal可以从内层修改外层的变量值。
Python有两个内置的函数locals()和globals()，可以用于显示所有基于dict的局部变量和全局变量。
def func():
def do_local():
var = 'local var'
def do_nonlocal():
nonlocal var
var = 'nonlocal var'
def do_global():
global var
var = 'global var'
var = 'var'
do_local()
print("after do_local:["+var+']')
do_nonlocal()
print("after do_nonlocal:["+var+']')
do_global()
print("after do_global:["+var+']')
func()
print("In global scope:["+var+']')
after do_local:[var]
after do_nonlocal:[nonlocal var]
after do_global:[nonlocal var]
In global scope:[global var]
