Python注释、标识符、关键字、变量

 一、python注释

在python程序中对于注释提供有两类语法支持

单行注释：使用#注释内容，符号对注释内容的开头

多行注释：使用三个单引号或者三个双引号的形式来进行定义

单行注释

?

1 2	# 这是一行输出模拟注释内容 print("注释一行内容")

多行注释

?

1 2 3 4 5 6

'''     这是多行输出     模拟     注释内容 ''' print("注释多行内容")

所有定义的注释信息都不会被程序解释器所执行， 也就是说这些代码都不属于程序本身的代码，所以可以随意编写。

二、python标识符

标识符实际上就是一个名称，就好比你在现实中的名字是一样的，在整个的程序开发中一般都会存在大量的程序结构（函数名称、变量名称、类名称等等），那么这样的结构名称在程序中就通过标识符的形式来描述，在Python中，标识符由字母、数字、下划线所组成，但是不能够使用数字开头，不能够使用Python中的保留字（关键字）。

举例：

 

?

1 2 3 4 5 6 7

错误标识符： 123：标识符中可以由数字所组成，但是不能以数字开头 MuYan Yootk：标识符里面的由字母所组成，但是中间由于存在有一个空格 正确标识符： yootk_lixinghua:由字母和下划线所组成 muyan123:由字母和数字所组成 mark_01：由字母、数字、下划线所组成

 

1、在编写标识符的时候尽量不要使用一些没有意义的名称，例如：i1、i2、i3

2、在编写的时候尽量让标识符由明确的含义，例如：student、name、school

3、在python定义标识符的时候双下划线"__"一般有特殊的处理函数，不要轻易定义在代码中。

三、python关键字

对于任何的编程语言来讲，由于标记名称是一个非常重要的概念，所以在进行程序编写的过程之中会使用一些特殊的标记完成一些特殊的功能，那么这些特殊的标记就称为关键字（保留字），在python中提供的关键字如下所示：

and、as、assert、break、class、continue、def、del、elif、else、except、exec、finally、for、from、global、if、import、in、is、lambda、nonlocal、not、or、pass、raise、return、try、while、with、yield、True、False、None

对于不同的python版本，有可能会出现不同的关键字情况，所以此时就可以通过Python中内部提供的一个处理机制来动态获取全部的关键字的列表

?

1 2 3 4

# 输出python中的所有关键字 import keyword from keyword import kwlist print(keyword.kwlist)

 

输出结果：

?

1	['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

四、Python 变量、常量、变量类型

变量

变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。

基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。

因此，变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。

变量赋值

Python中的变量不需要声明，变量的赋值操作既是变量声明和定义的过程。

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。

每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。例如：

?

1 2 3 4 5 6 7 8 9 10 11

name='zk' sex='man' age=29 job="none" count=1000 mile=1000.1 bool=True print(name+" "+sex+" "+job+" ") print(bool) print(count) print(mile)

执行以上程序会输出如下结果：

zk man none 
True
1000
1000.1

多个变量赋值

Python允许你同时为多个变量赋值。例如：

?

1 2 3 4

a=b=c=1 print(a) print(b) print(c)

 以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。

　您也可以为多个对象指定多个变量。例如：

?

1 2 3 4

d,e,f=5,"str",4 print(d) print(e) print(f)

　执行以上程序会输出如下结果：

5
str
4

以上实例，两个整型对象1和2的分配给变量d和e，字符串对象"john"分配给变量f。

标准数据类型

在内存中存储的数据可以有多种类型。

　　例如，person.s年龄作为一个数值存储和他或她的地址是字母数字字符存储。

　　Python有一些标准类型用于定义操作上，他们和为他们每个人的存储方法可能。

　　Python有五个标准的数据类型：

• Numbers（数字）
• String（字符串）
• List（列表）
• Tuple（元组）
• Dictionary（字典）
• Complex（复数）

Python数字

　　数字数据类型用于存储数值。

　　他们是不可改变的数据类型，这意味着改变数字数据类型会分配一个新的对象。

　　当你指定一个值时，Number对象就会被创建：

?

1 2	var1 = 1 var2 = 10

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

del语句的语法是：

?

1	del var1[,var2[,var3[....,varN]]]]

  您可以通过使用del语句删除单个或多个对象。例如：

?

1 2	del var del var_a, var_b

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

• int（有符号整型）
• long（长整型[也可以代表八进制和十六进制]）
• float（浮点型）
• complex（复数）

一些数值类型的实例

int	long	float	complex
10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j
-786	0122L	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEl	32.3+e18	.876j
-0490	535633629843L	-90.	-.6545+0J
-0x260	-052318172735L	-32.54e100	3e+26J
0x69	-4721885298529L	70.2-E12	4.53e-7j

• 长整型也可以使用小写"L"，但是还是建议您使用大写"L"，避免与数字"1"混淆。Python使用"L"来显示长整型。
• Python还支持复数，复数由实数部分和虚数部分构成，可以用a+bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型

Python字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符，字符串是有序组合。

一般记为 :

s="a1a2···an"(n>=0)

它是编程语言中表示文本的数据类型。

python的字串列表有2种取值顺序:

• 从左到右索引默认0开始的，最大范围是字符串长度少1
• 从右到左索引默认-1开始的，最大范围是字符串开头

如果你的实要取得一段子串的话，可以用到变量[头下标:尾下标]，就可以截取相应的字符串，其中下标是从0开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

比如:

s = 'ilovepython'

s[1:5]的结果是love。

当使用以冒号分隔的字符串，python返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界。

上面的结果包含了s[1]的值l，而取到的最大范围不包括上边界，就是s[5]的值p。

加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：

?

1 2 3 4 5 6 7 8

str = 'Hello World!'   print(str) # 输出完整字符串 print(str[0]) # 输出字符串中的第一个字符 print(str[2:5]) # 输出字符串中第三个至第五个之间的字符串 print(str[2:]) # 输出从第三个字符开始的字符串 print(str * 2) # 输出字符串两次 print(str + "TEST") # 输出连接的字符串

输出结果如下：

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

字符串split函数

?

1 2 3

txt='www.baidu.com' print(txt.split('.')) print(txt.split('.')[1])

 输出结果如下：

 取结尾为.jpg的文件名

?

1 2 3 4 5 6

img=['aa.png','bb.jpg','cc.jpg'] result=[] for file in img:     if file.split('.')[1]=='jpg':         result.append(file) print(result)

输出结果如下：

例题：

在网页列表中选择网页出现次数最多的网址，列表如下：

'http://www.baidu.com/index.html',
'http://www.baidu.com/1.html',
'http://post.baidu.com/index.html',
'http://mp3.baidu.com/index.html',
'http://www.baidu.com/3.html',
'http://post.baidu.com/2.html'

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14

raw = [     'http://www.baidu.com/index.html',     'http://www.baidu.com/1.html',     'http://post.baidu.com/index.html',     'http://mp3.baidu.com/index.html',     'http://www.baidu.com/3.html',     'http://post.baidu.com/2.html', ]   result=[] for single_raw in raw:     page_domain_afterhttp = single_raw.split('/')[2]     result.append(page_domain_afterhttp) print(max(result))

 输出结果：

字符串拼接

?

1 2 3 4 5 6 7 8 9

var1="zk" var2="lwt" schoolname="wanmendaxue" pinjie=var1+var2+schoolname word_1="Pi等于" word_2=3.1415 result=word_1+str(word_2) print(pinjie) print(result)

输出结果：

zklwtwanmendaxue
Pi等于3.1415

Python占位符的三种形式

?

1 2 3 4 5 6 7 8 9

name="张焜" age=29 height=1.79 school='中国矿业大学' boys=100 girls=200 print(f"我叫{name},年龄{age},学校{school},身高{height},班里有男孩{boys}个,女孩{girls}个") print("我叫%s,年龄%d,学校%s,身高%.2f,班里有男孩%d个,女孩%d个" %(name,age,school,height,boys,girls)) print("我叫{0},年龄{1},学校{2},身高{3},班里有男孩{4}个,女孩{5}个".format(name,age,school,height,boys,girls) )

Python数学函数

?

1 2 3 4 5 6 7 8 9 10 11

import math int_1=10 int_2=-10 double_1=1.45 print(abs(int_1))           #绝对值 print(abs(int_2)) print(min(int_1,int_2))     #两数取小 print(max(int_1,int_2))     #两数取大 print(math.floor(double_1)) #向下取整 print(math.ceil(double_1))  #向上取整 print(math.sqrt(int_1))     #开根号

Python数据类型转换

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

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数	描述
int(x [,base])	将x转换为一个整数
long(x [,base] )	将x转换为一个长整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
unichr(x)	将一个整数转换为Unicode字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符

1、int函数：

（1）把符合数学格式的数字型字符串转换成整数，字符串内非数字无法转换为整数
（2）把浮点数转换成整数，但是只是简单的取整，而非四舍五入，浮点数整数会消除小数部分取整

?

1 2 3 4 5 6 7 8 9 10

aa = int("124")    #Correct print("aa = ", aa)  #result=124 bb = int(123.45) #correct print("bb = ", bb) #result=123 cc = int("-123.45")  #Error,Can't Convert to int print("cc = ",cc) dd = int("34a")    #Error,Can't Convert to int print("dd = ",dd) ee = int("12.3") #Error,Can't Convert to int print(ee)

　2、float函数将整数和字符串转换成浮点数，字符串内非数字无法转换为浮点

?

1 2 3 4 5 6 7 8 9 10

aa = float("124")     #Correct print("aa = ", aa)     #result = 124.0 bb = float("123.45")  #Correct print("bb = ", bb)     #result = 123.45 cc = float(-123.6)    #Correct print("cc = ",cc)      #result = -123.6 dd = float("-123.34") #Correct print("dd = ",dd)      #result = -123.34 ee = float('123v')    #Error,Can't Convert to float print(ee)

3、str函数将数字转换成字符，字符串或整数转化为浮点数，整数后面多一位小数

?

1 2 3 4 5 6 7 8 9 10

aa = str(123.4)     #Correct print aa            #result = '123.4' bb = str(-124.a)    #SyntaxError: invalid syntax print bb cc = str("-123.45") #correct print cc            #result = '-123.45' dd = str('ddd')     #correct print dd            #result = ddd ee = str(-124.3)    #correct print ee            #result = -124.3

Python整数、浮点数的多则运算----加、减、乘、除、商、取余、次幂

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

aa=1 bb=2 print(aa+bb)   #加法  3 print(aa-bb)   #减法   -1 print(aa/bb)   #除数   0.5 print(aa//bb)  #整除   0 print(aa%bb)   #取余   1 print(bb**3)   #次幂   8 print(aa+bb,aa-bb,aa/bb,aa%bb,bb**3,sep="\n") 3 -1 0.5 1 8 print(aa+bb,aa-bb,aa/bb,aa%bb,bb**3,sep="***")　　 3***-1***0.5***1***8

Python列表

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串甚至可以包含列表（所谓嵌套）。

列表用[ ]标识。是python最通用的复合数据类型。看这段代码就明白。

列表中的值得分割也可以用到变量[头下标:尾下标]，就可以截取相应的列表，从左到右索引默认0开始的，从右到左索引默认-1开始，下标可以为空表示取到头或尾。

加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：

?

1 2 3 4 5 6 7 8 9

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ] tinylist = [123, 'john']   print(list) # 输出完整列表 print(list[0]) # 输出列表的第一个元素 print(list[1:3]) # 输出第二个至第三个的元素 print(list[2:]) # 输出从第三个开始至列表末尾的所有元素 print(tinylist * 2) # 输出列表两次 print(list + tinylist) # 打印组合的列表

Python元字典

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

?

1 2 3 4 5 6 7 8 9 10 11 12 13

Dict_1={'德国':'奔驰车队','英国':'迈凯伦车队','意大利':'法拉利车队'} print(type(Dict_1)) print(Dict_1) print(str(Dict_1)) print(Dict_1['德国'])     #获取键值 Dict_1['德国']='BMW'      #修改键值 print(Dict_1['德国']) Dict_1['中国']='红旗'     #增加键值 print(Dict_1) del Dict_1['英国']       #删除键值 print(Dict_1) Dict_1.clear()           #清空列表 print(Dict_1)

Python元组

元组是另一个数据类型，类似于List（列表）。python元组中的元素不可更改

元组用"()"标识。内部元素用逗号隔开。但是元素不能二次赋值，相当于只读列表。

?

1 2 3 4 5 6 7 8 9

tuple_1=(1,'a','BMW','XFL',3) tuple_2=(2,'b','WMB','LFX',4) print(tuple_1)     #输出完整元组1 print(tuple_2)     #输出完整元组2 print(tuple_1[1])  #输出tuple_1的第二个元素 print(tuple_1[2:]) #输出tuple_1的第三个之后的元素 print(tuple_1[:3]) #输出tuple_1的第四个之后的元素 print(tuple_1*2)   #输出两遍tuple_1 print(tuple_1+tuple_2)   #输出tuple_1和tuple_2的混合元素

Python逻辑运算

所有的基础逻辑运算结果：（1）一切皆真假（2）一切皆0和1（3）一切皆True和False

运算逻辑要有可比性：（1）整数与整数相比（2）整数与浮点数相比（3）浮点数与浮点数相比（4）字符串与字符串相比

（5）字符串不可与其他类型比大小，但是可以比相等

 比较运算符

?

1 2 3 4 5 6 7 8

a=100 b=200 print(a==b) print(a!=b) print(a>b) print(a<b) print(a>=b) print(a<=b)

 输出结果：False   True   False   True   False   True

逻辑运算（或且非运算）

?

1 2 3 4 5

a=100 b=200 print(a==b and a!=b) print(a==b or a!=b) print(not a==b)

输出结果：False 　True 　True

and优先级大于or

成员运算

?

1 2 3 4 5 6 7 8 9 10

str_1='abcd' str_2='efgh' print('a' in str_1) print('a' in str_2) print('e' in str_2) print('e' in str_1) print('a' not in str_1) print('a' not in str_2) print('e' not in str_2) print('e' not in str_1)

输出结果：True   False   True   False   False   True   False   True

身份运算（即比较内存地址）

?

1 2 3 4 5

result_1=1 result_2=1 result_3=2 print(id(result_1)==id(result_2)) print(id(result_2)==id(result_3))

 相同的值会默认指向相同的内存地址。　

?

1 2 3 4 5

bedroom_1="枕头" pillow_1="枕头" print(id(bedroom_1),id(pillow_1))      #140469614890320 140468288321552 print(bedroom_1 is pillow_1)           #False print(bedroom_1 is not pillow_1)       #True

?

1 2 3 4 5

bedroom_1="枕头" pillow_1=bedroom_1 print(id(bedroom_1),id(pillow_1))  #140469614896176 140469614896176 print(bedroom_1 is pillow_1)         #True print(bedroom_1 is not pillow_1)   #False

?

1 2 3 4 5

bedroom_1="枕头" pillow_1="枕头" print(id(bedroom_1),id(pillow_1)) print(bedroom_1 is pillow_1) print(bedroom_1==pillow_1)

is比较符用于比较两个变量的地址，两个变量地址不相同则为False。==比较符比较的是两个变量的值，值相同则为True。

参考链接：https://www.cnblogs.com/0201zcr/p/4855700.html