python类常量

A. python命名规则是什么

1、模块

模块尽量使用小写命名，首字母保持小写，尽量不要用下划线。

2、类名

类名使用驼峰(CamelCase)命名风格，首字母大写，私有类可用一个下划线开头。

3、函数

函数名一律小写，如有多个单词，用下划线隔开。

4、变量名

变量名尽量小写, 如有多个单词，用下划线隔开。

5、常量

常量使用以下划线分隔的大写命名。

基本语法：

Python的设计目标之一是让代码具备高度的可阅读性。它设计时尽量使用其它语言经常使用的标点符号和英文单字，让代码看起来整洁美观。

它不像其他的静态语言如C、Pascal那样需要重复书写声明语句，也不像它们的语法那样经常有特殊情况和意外。

Python开发者有意让违反了缩进规则的程序不能通过编译，以此来强制程序员养成良好的编程习惯。并且Python语言利用缩进表示语句块的开始和退出，而非使用花括号或者某种关键字。增加缩进表示语句块的开始，而减少缩进则表示语句块的退出。缩进成为了语法的一部分。

B. 如何定义和使用Python中常量

一、访问字典的元素使用dobj.get(key, somethingelse)，如果对应key值元素不存在，你将会得到somethingelse值，例如“not found” 不要使用dobj[key]，因为如果key对应元素不存在，则会产生KeyError异常，这样必须使用try...except来封装 二、名字空间中的属性可以通过字典__dict__来访问 __setattr__负责处理属性赋值，其内进行赋值时要使用self.__dict__[attr] = value以防止递归 三、sys.moles是一个字典，它包含了从Python开始运行起，被导入的所有模块。键字就是模块名，键值就是模块对象。请注意除了你的程序导入的模块外还有其它模块。Python在启动时预先装入了一些模块，如果你在一个Python IDE环境下，sys.moles包含了你在IDE中运行的所有程序所导入的所有模块定义class _const(object): class ConstError(TypeError): pass def __setattr__(self, name, value): if self.__dict__.has_key(name): raise self.ConstError, "Cant rebind const(%s)" % name self.__dict__[name] = value def __delattr__(self, name): if name in self.__dict__: raise self.ConstError, "Cant unbind const(%s)" % name raise NameError, nameimport syssys.moles[__name__] = _const()使用import const const.value = somevalue const.value = newvalue # 产生异常const.ConstError技巧1、使用__setattr__来控制重新绑定 2、sys.moles[name]得到的是模块对象，通过模块对象可以访问其模块属性；而Python不会进行严格的类型检测，所以直接将一个 _const类对象加入sys.moles字典，而__name__的值为对应模块const的名字const，通过 sys.moles[__name__] = _const()用类对象替换模块对象，将对应的名字空间加以限制，当使用import const时，会发生sys.moles[const] = _const()；而访问const.attrvalue时会发生sys.moles[const].attrvalue，即 _const().attrvalue

C. 0x18是合法的python整型常量吗

0x18是合法的python整型常量。
Python 数字数据类型用于存储数值。
数字类型是不允许改变的,这就意味着如果改变数字数据类型得值，将重新分配内存空间。
以下实例在变量赋值时 Number 对象将被创建：
IntOne=1

IntTwo=2

也可以使用del语句删除一些数字对象的引用。

del IntOne

del IntTwo

当然了，也允许删除多个：

del IntOne,IntTwo

Python 支持三种不同的数值类型：

整型(Int) - 被称为是整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的。也就是没有像java一样限制int类型的大小。
浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示(2.5e2 = 2.5 x 102 = 250)。

复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。用表达式表示虚数也是可以的。

Python 数字类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。

int(x) 将x转换为一个整数。

float(x) 将x转换到一个浮点数。

complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。

complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。

Python 可以使用 ** 操作来进行幂运算：

变量在使用前必须先"定义"(即赋予变量一个值)，否则会出现错误：

不同类型的数混合运算时会将整数转换为浮点数(当然指的是不同的数，如果不是数的话就会出现错误了)

常用函数：

abs(x) x的绝对值

ceil() 返回数字的上入整数，如math.ceil(4.1) 返回 5

使用 (x>y)-(x

exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045

fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0

floor(x) 返回数字的下舍整数，如math.floor(4.9)返回 4

log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0

log10(x) 返回以10为基数的x的对数，如math.log10(100)返回 2.0

max(x1,x2,,,,) 返回给定参数的最大值，参数可以为序列。

min(x1,x2) 返回给定参数的最小值，参数可以为序列。

mdf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。

pow(x,y) x**y 运算后的值。

round(x,n) 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。

sqrt(x) 返回数字x的平方根。
随机数函数
随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性。
choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange(start,stop,step) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random() 随机生成下一个实数，它在[0,1)范围内。
seed(x) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定， Python会帮你选择seed。
shuffle(seq) 将序列的所有元素随机排
unform(x,y) 随机生成下一个实数，它在[x,y]范围内。
数学常量：
i,e

D. 如何给python中设定常量

"""
首先声明：python没有真正意义上的常量！

但我们可以通过私有属性以及property属性相结合，自己设置出属于python的伪常量。

当然，这个常量其实也是可以改的，不过是比较麻烦，平常可以当作一个常量用

"""
#1.先是用私有属性初始化一个量

classMan(object):
def__init__(self,age):
self.__age=age
#2.然后用property获取到
@property
defAGE(self):
returnself.__age
#3.最后得到常量man.AGE,设置的常量，因property属性，所以调用不需要括号
man=Man(300)
print(man.AGE)


#4.现在验证，输入以下代码，结果为"AttributeError:can'tsetattribute"
man.AGE=33
#5.这就是python简单的设置伪常量！

E. python数值常量合法的判断

一个整数集合S是合法的，指S的任意子集subS有Fun(SubS)！=X，其中X是一个固定整数，Fun(A)的定义如下：
A为一个整数集合，设A中有n个元素，分别为a0，a1，a2,...,an-1,那么定义：Fun(A)=a0ora1or...oran-1；Fun({})=0,即空集的函数值为0.其中，or为或操作。
现在给你一个集合Y与整数X的值，问在集合Y至少删除多少个元素能使集合Y合法？
例如：Y={1,2,4}，X=7；显然现在的Y不合法，因为1or2or4=7，但是删除掉任何一个元素后Y将合法。所以，答案是1。

F. 一文搞懂python数据类型和结构

每次python从入门到精通都是从头开始看，做这个学习笔记主要是为了让自己可以省去学习数据类型和结构那几章的时间，所以“偷懒”可以促进生产力发展......

分别是： 整数型、浮点型、复数、常量、布尔型、字符串 。其中复数基本不会使用到，可以不用太关注

分别是 列表、字典、集合和元组 ，其中最常见并且工作中经常使用到的就是列表和字段，其他两个不常见。

02、字典
列表之外，字典可能是python中用的也比较多的数据结构了，由于字典的底层应用哈希映射，所以要求字典的所有key必须是不可变元素（可哈希对象），增删改查操作一般都能实现O(1)复杂度，是低复杂度的必备数据结构。

03、集合
集合（set）是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

集合操作可能最常见于用于对列表去重，它的最大特性是各元素仅保留1次，底层也是应用了哈希函数，所以在集合中查找元素一般也可实现O(1)复杂度，同时集合的嵌套元素也要求是不可变类型（可哈希对象）
add：在集合中增加一个元素，如果元素已存在，则无实际操作

pop：不接受任何参数，堪称是最神秘的操作，不同于列表的从尾端删除、字典的指定键删除，集合的pop操作看似是"随机"删除。但实际上是按照加入集合的先后顺序，删除"最早"加入的元素

除了与列表和字典中类似的增删改操作外，集合还支持数学概念下的集合操作，如交集、并集、差集等。

04、元组
如果说列表、字典和集合都有其各自擅长应用场景的话，那么元组可能是最没有存在感的数据结构：它接口有限、功能单一，而且是不可变类型。一般而言，用元组解决的问题都可以用列表实现。但使用用元组时，更多在于暗示该序列为不可变类型。当然，当元组内嵌套子列表时实际上是可以对嵌套的子列表进行更改操作的。

https://github.com/zqkyy/py_basic_structure

有问题可以私信我，欢迎交流！

G. python选择结构分为哪几类每一类的语法格式怎么书写

分三类：单分支，双分支，多分支。
输出
用print()在括号中加上字符串，就可以向屏幕上输出指定的文字。比如输出'hello, world'，用代码实现如下：

>>> print('hello, world')
print()函数也可以接受多个字符串，用逗号“,”隔开，就可以连成一串输出：

>>> print('The quick brown fox', 'jumps over', 'the lazy dog')
The quick brown fox jumps over the lazy dog
print()会依次打印每个字符串，遇到逗号“,”会输出一个空格

print()也可以打印整数，或者计算结果：

>>> print(300)
300
>>> print(100 + 200)
300
因此，我们可以把计算100 + 200的结果打印得更漂亮一点：

>>> print('100 + 200 =', 100 + 200)
100 + 200 = 300
输入
Python提供了一个input()，可以让用户输入字符串，并存放到一个变量里。比如输入用户的名字：

>>> name = input()
Michael
当你输入name = input()并按下回车后，Python交互式命令行就在等待你的输入了。这时，你可以输入任意字符，然后按回车后完成输入。

输入完成后，不会有任何提示，Python交互式命令行又回到>>>状态了。那我们刚才输入的内容到哪去了？答案是存放到name变量里了。可以直接输入name查看变量内容：

>>> name
'Michael'
结合输入输出

name = input()
print('hello,', name)
数据类型

整数
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。

浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。

整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。

字符串
字符串是以单引号'或双引号"括起来的任意文本，比如'abc'，"xyz"等等。请注意，''或""本身只是一种表示方式，不是字符串的一部分，因此，字符串'abc'只有a，b，c这3个字符。如果'本身也是一个字符，那就可以用""括起来，比如"I'm OK"包含的字符是I，'，m，空格，O，K这6个字符。

如果字符串内部既包含'又包含"怎么办？可以用转义字符\来标识，比如：

'I\'m \"OK\"!'
表示的字符串内容是：

I'm "OK"!
转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\，可以在Python的交互式命令行用print()打印字符串看看：

>>> print('I\'m ok.')
I'm ok.
>>> print('I\'m learning\nPython.')
I'm learning
Python.
>>> print('\\\n\\')
\
\
如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r''表示''内部的字符串默认不转义，可以自己试试：

>>> print('\\\t\\')
\ \
>>> print(r'\\\t\\')
\\\t\\
如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用'''...'''的格式表示多行内容，可以自己试试：

>>> print('''line1
... line2
... line3''')
line1
line2
line3
上面是在交互式命令行内输入，注意在输入多行内容时，提示符由>>>变为...，提示你可以接着上一行输入，注意...是提示符，不是代码的一部分：

┌────────────────────────────────────────────────────────┐
│Command Prompt - python _ □ x │
├────────────────────────────────────────────────────────┤
│>>> print('''line1 │
│... line2 │
│... line3''') │
│line1 │
│line2 │
│line3 │
│ │
│>>> _ │
│ │
│ │
│ │
└────────────────────────────────────────────────────────┘
当输入完结束符```和括号)后，执行该语句并打印结果。

如果写成程序并存为.py文件，就是：

print('''line1
line2
line3''')
多行字符串'''...'''还可以在前面加上r使用

布尔值
布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：

>>> True
True
not运算是非运算，它是一个单目运算符，把True变成False，False变成True：

>>> not True
False
空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型，我们后面会继续讲到。

变量
变量的概念基本上和初中代数的方程变量是一致的，只是在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。

变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头，比如：

a = 1
变量a是一个整数。

t_007 = 'T007'
变量t_007是一个字符串。

Answer = True
变量Answer是一个布尔值True。

在Python中，等号=是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。

最后，理解变量在计算机内存中的表示也非常重要。当我们写：

a = 'ABC'
时，Python解释器干了两件事情：

在内存中创建了一个'ABC'的字符串；
在内存中创建了一个名为a的变量，并把它指向'ABC'。
也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据

常量
所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：

PI = 3.14159265359
但事实上PI仍然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法，如果你一定要改变变量PI的值，也没人能拦住你。

最后解释一下整数的除法为什么也是精确的。在Python中，有两种除法，一种除法是/：

>>> 10 / 3
3.3333333333333335
/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：

>>> 9 / 3
3.0
还有一种除法是//，称为地板除，两个整数的除法仍然是整数：

>>> 10 // 3
3
你没有看错，整数的地板除//永远是整数，即使除不尽。要做精确的除法，使用/就可以。

因为//除法只取结果的整数部分，所以Python还提供一个余数运算，可以得到两个整数相除的余数：

>>> 10 % 3
1
无论整数做//除法还是取余数，结果永远是整数，所以，整数运算结果永远是精确的。

H. python常量的值可以改变吗

首先先要理解常量与变量、赋值即定义
常量
1、python常量：内存中用于保存固定值的单元、在程序中、常量的值不能发生改变的
2、python常量命名规范：通常是以大写字母开头进行区分-Chy常量 chy变量
3、python常量的赋值：数字 字符串 布尔值 空值
4、举例：Aa=123、Ab='chy'、Ac=True和False、Ad=' ';
变量
1、python变量：占用内存中一块空间、用来存放变量的值（或地址）、存放的值是可以发生改变的
2、python变量命名规范：第1个字符必须是字母或下划线开始（_）不可用数字开头 不要用中文开头
3、第1个字符后边可以使用字母、数字、下划线进行组合 chy_0201=[1,2,3]
4、变量的赋值：
变量名=常量
a = 1
print(a)
变量名=其他变量名
a = 1
a = a + 1
print(a)
变量名=表达式
if a = 1:
print('ok')
变量名=函数（返回值）
a = 1
b = 2
c = a + b * 2
print(c)
5、python变量的命名是区分大小写的、小写是变量 大写是常量 chy与Chy是不同的
6、python中已经被使用的关键字不能用于声明变量
7、python中对变量进行赋值时、单引号和双引号是一样的 '' ""
8、赋值可以使用任意类型的数据、一个变量的类型不固定、变量值是有固定的类型的
9、查看数据类型使用type(变量名) asd='123' print(type(asd))
10、通过id（变量名）可以查看变量指向的内存地址
另外一般定义为常量就不会去重新赋值，如果要多次赋值，那就用变量。
首先声明：python没有真正意义上的常量！

但我们可以通过私有属性以及property属性相结合，zhuan自己设置出属于python的伪常量。
当然，这个常量其实也是可以改的，不过是比较麻烦，平常可以当作一个常量用
#1.先是用私有属性初始化一个量
class Man(object):
def __init__(self,age):
self.__age=age
#2.然后用property获取到
@property
def AGE(self):
return self.__age
#3.最后得到常量man.AGE,设置的常量，因property属性，所以调用不需要括号
man = Man(300)
print(man.AGE)
#4.现在验证，输入以下代码，结果为"AttributeError: can't set attribute"
man.AGE=33
#5.这就是python简单的设置伪常量！
希望对你有帮助！谢谢采纳！

I. python中常量类型有哪些

常量定义：不可以被改变的量python中无固定语法，约定俗成的是将变量名全部大写。
例如：
PI=3.141592653BIRTH_OF_SYLAR=1990
Python并未提供如C/C++/Java一样的const修饰符。
换言之，#python中没有常量。

python提供了新的方法实现常量：即通过自定义类实现常量。
需要满足两个条件：
命名全部为大写值，被赋值便不可再修改。
例如：
HOST=飗.0.0.1'

J. 在python中怎么定义常量

通常是在py 函数上面，import下面

大写字母作为常量名。

比如：

importxxx

WORKER_NUMBER=100

defhehe():
......