Python关键字介绍和使用

最新推荐文章于 2024-03-02 20:33:24 发布

armwind

最新推荐文章于 2024-03-02 20:33:24 发布

阅读量1.1k

点赞数 2

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/armwind/article/details/104040089

版权

Python 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

最经新型冠状病毒非常严重，春节假期哪也去不了，索性就在家里稍微学习一下Python，毕竟乘着人工智能的浪潮Python已经非常流行了。同时工作中也需要修改编写Python脚本，更点燃学习Python的渴望。这里记录下学习笔记，有过面向对象，面向过程的编程经验，学习起来应该会快点。下面先列举出pytyon关键字，let’s go！

文章目录

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

python版本：

D:\test\python>python --version
Python 2.7.10

1.and、print

这个和C语言的 “&&” 运算是一样的，只有and两边同时为TRUE时，表达式才为TRUE。

怎么样算FALSE: 空列表：[]、空元组：()、空字典:：{}、空字符串：’’或“”、零值：0
怎么样算TRUE:除了上面的其它都为TRUE。

实例：

a = 1
b = 1
list = ['hello']
list1 = []

if a and b :
    print("hello world")

if list1 and a:
    print("list is no null")

if list:
    print("list is no null:--->%s" %list[0])
    del list[0]

if list is not None:
    print list
    print("empty list")

输出结果：

D:\test\python>python and.py
hello world
list is no null:—>hello
[]
empty list

上面可以看到and两边可以是列表，bool值，由此验证上面的两项。

2.exec

此关键字和linux shell中的exec同样类似，都是为了执行脚本命令而实现的。当需要动态执行python命令时，可以使用此命令

a = 2
b = 3
cmd = 'print(\'hello world\')'
exec(cmd)
cmd = 'print(\'a + b = %d\' %(a+b))'
exec(cmd)

结果：

D:\test\python>python exec.py
hello world
a + b = 5

3.not

此关键字可以理解成 “非” 的意思，类似于C语言中的 ‘!’ 所以用起来很容易理解。

a = 0
b = []
c = ('1')

if not a :
    print ('a is FALSE')
if not (a and len(b)) :
    print ("(a and len(b)) is 0")
if not len(b) :
    print ('list b is None')
if not len(c) :
    print("c is None")

输出not作用对象可以是一个bool值bool表达式。
输出结果：

D:\test\python>python not.py
a is FALSE
(a and len(b)) is 0
list b is None

4.assert、is

assert
和其它编程语言一样，这里也是断言的意思。用于判断某一个条件是否达到预计条件。如果不满足的话，同样会抛出异常。

a = 66
b = ['55','armwind']
c = []
assert a > 44 and b
print a
assert len(b) is not 0
print ('len:%d' %len(b))
assert len(c) is not 0
print (c)

上面能够看到 assert后面是表达式，当然也可以是一个bool值。下面的结果可以看到，如果断言不满足时，会抛出断言错误。
结果：

66
len:2
Traceback (most recent call last):
File “assert.py”, line 8, in
assert len© is not 0
AssertionError

is：即为是的意思，上面例子可见。

5.finally

此关键字一般和try,except一起使用，从字面意思可以了解这里是最终的意思，就是最后都要执行的。这里就顺便一起总结下

常用的异常

异常名称	描述

AttributeError	试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
IOError	输入/输出异常；基本上是无法打开文件
ImportError	无法引入模块或包；基本上是路径问题或名称错误
IndentationError	语法错误（的子类）；代码没有正确对齐
IndexError	下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
KeyError	试图访问字典里不存在的键
KeyboardInterrupt	Ctrl+C被按下
NameError	使用一个还未被赋予对象的变量
SyntaxError	Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
TypeError	传入对象类型与要求的不符合
UnboundLocalError	试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量导致你以为正在访问它
ValueError	传入一个调用者不期望的值，即使值的类型是正确的

例子

dat=['armwind1','armwind2']
dic={'name': 'armwind', 'age': 30}

try :
    print  dat[3]
    print dic['name1']
except IndexError as e:
    print('IndexError:%s' %e)
except KeyError as e:
    print('keyError:%s' %e)
except ValueError as e:
    print('ValueError:%s' %e)
finally :
    print("do something")

上面的异常中加入了2个异常，“IndexError”，“KeyError ”，但是只捕获到了第一个异常，由此可以看到，try…except只能捕获到第一个异常。例子中使用as关键字，打印出了异常。运行结果如下：

D:\test\python>python try.py
IndexError:list index out of range
do something

6.or

类似于C语言的 “||” 运算，例子就不多说了，通之前的and和not是一样的。

7.for、break、continue、in

同C语言中的break，continue作用一样，其中break跳出大循环体，continue跳出当前循环。for语句和C语言还是有些出入的，python中的可以遍历任何序列的数据，如一个列表或者一个字符串。

dat = 'cfj'
dic = ['armwind1','armwind2','armwind3']
for d in dat:
    print(d)
print('--------dic-----------')
for d in dic:
    print(d)
print('--------int-----------')
for i in range(1,20):
    if i == 6:
        break
    if i == 2:
        continue
    print(i)

从下面的结果可以看出for循环确实可以循环遍历字符串中的每一个字符，不过这样操作意义不大。一般都是循环遍历列表。
结果：

D:\test\python>python break.py
c
f
j
--------dic-----------
armwind1
armwind2
armwind3
--------int-----------
1
3
4
5

8.pass

pass字面意思就是什么都不做，相当于占位符。当我们定义了一个接口后，如果不实现的话则会报错，在方法中添加pass就不会报错了。

def test():

print("hello world")

上面如果不加pass的话，则会报下面的错误，加上就可以成功运行。

File “pass.py”, line 3
print(“hello world”)
^
IndentationError: expected an indented block

9.class、def、return

python中的class与其它面向对象的语言类似，不够python中一些命名需要注意下

this
python中没有this指针，取而代之是self，在类形参里面第一个参数需要是 “self” 记住是这样写的即可。
构造函数
构造函数形如__init__(self,arg1,arg2,...),注意开始是 self 。
析构函数
构造函数形如__del_(self,arg1,arg2,...),注意开始是 self 。
私有成员
私有成员需要开始加入2个下划线 __param
私有方法
私有方法需要开始加入2个下划线 __func
类的继承
在声明类时，在类名后面添加对应父类名称即可。例如有父类father，则其子类为 class son(father):. 如果是多继承，则子类的为class son(father1, fater2): 如下面例子单继承object。

class human(object):
    def __init__(self, nam, ag, phone) :
        print("create human %s" %nam)
        self.name = nam
        self.age = ag
        self.__phone = phone

    def __set_phone(self, p):
        self.__phone = p

    def print_property(self) :
        print('name:%s, age:%d, phone:%d' %(self.name, self.age, self.__phone))

    def get_name(self):
        return self.name

    def set_property(self, nam, ag):
        self.name = nam
        self.age = ag
        self.__set_phone(999999999)

    def __del__(self):
        print("delete human %s" %self.name)

def main():
    hum1 = human("armwind1",29, 66666)
    hum1.print_property()
    hum1.set_property("armwind11", 28)
    hum1.print_property()
    p_name = hum1.get_name()
    print('hum1 name:%s' %p_name)

    del hum1

    hum2 = human("armwind2",30, 88888)
    hum2.print_property()
    hum2.set_property("armwind22", 31)
    hum2.print_property()
    p_name = hum2.get_name()
    print('hum2 name:%s' %p_name)

if __name__ == '__main__':
    main()

输出结果：

D:\test\python>python class.py
create human armwind1
name:armwind1, age:29, phone:66666
name:armwind11, age:28, phone:999999999
hum1 name:armwind11
delete human armwind11
create human armwind2
name:armwind2, age:30, phone:88888
name:armwind22, age:31, phone:999999999
hum2 name:armwind22
delete human armwind22

10.global

Python中定义函数时，若想在函数内部对函数外的变量进行操作，就需要在函数内部声明其为global。

g_name = 'armwind1'

def set_name(name) :
    g_name = name

def main():
    print(g_name)
    set_name("armwind2")
    print(g_name)

if __name__ == '__main__':
    main()

输出结果：

D:\test\python>python gloa.py
armwind1
armwind1

上面能够看到设置了名字竟然没有变化，这是由于name是全局变量，需要在函数内部声明一下name为全局变量。具体声明如下：

g_name = 'armwind1'

def set_name(name) :
    global g_name
    g_name = name

def main():
    print(g_name)
    set_name("armwind2")
    print(g_name)

if __name__ == '__main__':
    main()

结果：

D:\test\python>python gloa.py
armwind1
armwind2

11.raise

字面意思就是提出，也就是发起一个系统异常，立即终止当前进程，这与windows的signal和类似。但这和try…except捕获异常防止进程停止正好相反

print("hello world")
raise NameError

运行结果：

D:\test\python>python raise.py
hello world
Traceback (most recent call last):
File “raise.py”, line 2, in
raise NameError
NameError

12.if、elif、else

这里面的else除了和if组成我们常见语句还和while，for也是有关系的，不过最常见还是和if搭配.有c语言编程基础的一看即会。

#try else test
def try_else_test():
    try:
        a = int('aa')
    except ValueError as e:
        print("ValueError")
    else:
        print("all ok")

#for else test
def for_else_test():
    c = [1,2]
    for i in c:
        print(i)
    else:
        print("done")

def main():
    count=0
    while count > 12:
        if (11 > 0):
            print("count > 12,break")
            break
        count += 1
    else:
        print('game over')
    try_else_test()
    for_else_test()
    #if test
    num = int(input('please input:'))
    if num > 0:
        print('%d > 0 ' %num)
    elif num == 0:
        print('%d == 0' %num)
    else:
        print('%d < 0' %num)

if __name__ == '__main__':
    main()

运行结果：

game over
ValueError
1
2
done
please input:-1
-1 < 0

13.import、from

这两个都是导入模块和模块内部方法时使用的，其中模块导入一般有中方式

直接使用import xxx,其中xxx就是模块的名字，这个很常见，一把都是这样用的。使用是一般是模块名字加类名或者方法名，如xxx.yyyy()，其中xxx为模块名字，yyy为类名或者方法名字。
使用from单独导入某个类或者方法，这样就不需要在使用时加入模块名字了。具体可以参考下面测试例子
创建hello 模块

class hello1:
    def __init__(self):
        print("I'm hello1")
    def test(self):
        print("hello world1")

class hello2:
    def __init__(self):
        print("I'm hello2")
    def test(self):
        print("hello world2")

class hello3:
    def __init__(self):
        print("I'm hello3")
    def test(self):
        print("hello world3")

导入hell模块

import hello
from hello import hello1

te1 = hello1()
te2 = hello.hello2()
te2.test()
te3 = hello3()

上面测试例程导入了hello模块，同时也使用from导入了模块中的hello1类，那么分别使用hello1类名和hello.hello2()方法调用了相应的方法。但是没有直接导入hello3方法，也没有在使用时使用模块名字使用类，这样就直接报错了，下面可以看到hello3不能直接使用。

运行结果：

D:\test\python>python test.py
I’m hello1
I’m hello2
hello world2
Traceback (most recent call last):
File “test.py”, line 7, in
te3 = hello3()
NameError: name ‘hello3’ is not defined

14.while

此关键字同c语言中的while具有同样的性质，后面可以接bool值或表达式，格式不同罢了。

c = 0
while (c < 5) :
    c = c+1
    print("c:%d" %c)

运行结果：

D:\test\python>python while.py
c:1
c:2
c:3
c:4
c:5

15.with、as

with内置函数可以让python解释器自动关闭文件流，开发人员不用关心文件是否已经被关闭。
as：字面意思就是当做的意思，可以把对象重新命名。

dat=['armwind1','armwind2']
try :
    print  dat[3]
except IndexError as e:
    print('IndexError:%s' %e)
finally :
    print("do something")

with open('data.txt','w+') as file:
    file.write('hello world')
    print("write success")
    file.seek(0,0)
    print(file.read())

运行结果如预期一样，只是不要忘记移动文件指针。

D:\test\python>python as.py
IndexError:list index out of range
do something
write success
hello world

16.lambda

xy = lambda x, y: x - y冒号前是参数，冒号后是表达式输出.使用lambda时，不需要重新定义函数，就可以实现一个类似于函数的变量。即简化代码又提高代码运行速度。

def test(p1,p2):
    return lambda x : p1*x + p2*x

def main():
    add = lambda x, y : x+y
    print("add:%d" %add(1,2))

    lam = test(1,2)
    print('lam(2):%d' %lam(2))

if __name__ == '__main__':
    main()