前言
本文基于Python3 编写,实例均于Jupyter notebook编译
Python的执行方式
Python在执行时,首先会将.py文件中的源代码编译成Python的byte code(字节码),然后再由Python Virtual Machine(Python虚拟机)来执行这些编译好的byte code。这种机制的基本思想跟Java,.NET
是一致的。
然而,Python Virtual Machine与Java或.NET的Virtual Machine不同的是,Python的Virtual Machine是一种更高级的Virtual Machine。这里的高级并不是通常意义上的高级,不是说Python的Virtual Machine比Java或.NET的功能更强大,而是说和Java 或.NET相比,Python的Virtual Machine距离真实机器的距离更远。或者可以这么说,Python的Virtual Machine是一种抽象层次更高的Virtual Machine。
基于C的Python编译出的字节码文件,通常是.pyc格式。除此之外,Python还可以以交互模式运行,比如主流操作系统Unix/Linux、Mac、Windows都可以直接在命令模式下直接运行Python交互环境。直接下达操作指令即可实现交互操作。
Python的PyCodeObject 和 pyc 文件认识
PyCodeObject :是 Python 编译器真正编译成的结果。
当 Python 程序运行时,编译的结果则是保存在内存中的 PyCodeObject 中,当 Python 程序运行结束时,Python 解释器则将 PyCodeObject 写回到 pyc 文件中。
当 Python 程序第二次运行时,首先程序会在硬盘中寻找 pyc 文件,如果找到,则直接载入,否则就重复上面的过程。
可以说 pyc 文件其实是 PyCodeObject 的一种持久化保存方式。
Python语法规范
Python开发者有意让违反了缩进规则的程序不能通过编译,以此来强制程序员养成良好的编程习惯。并且Python语言利用缩进表示语句块的开始和退出(Off-side规则),而非使用花括号或者某种关键字。增加缩进表示语句块的开始,而减少缩进则表示语句块的退出。缩进成为了语法的一部分。例如if语句:python3
if age<21:
print("你不能买酒。")
print("不过你能买口香糖。")
print("这句话在if语句块的外面。")
根据PEP(Python增强建议书)的规定,必须使用4个空格来表示每级缩进(不清楚4个空格的规定如何,在实际编写中可以自定义空格数,但是要满足每级缩进间空格数相等)。使用Tab字符和其它数目的空格虽然都可以编译通过,但不符合编码规范。支持Tab字符和其它数目的空格仅仅是为兼容很旧的的Python程序和某些有问题的编辑程序。
一、数据类型
1.变量
Python 中的变量赋值不需要类型声明。
每个变量在内存中创建,都包括变量的标识,名称和数据这些信息。
每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。
等号(=)用来给变量赋值。
等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值。
判断数据类型:type(str)
字符串类型数据转为整数型:int(str)
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
print(counter)
print(miles)
print(name)
运行实例 »
以上实例中,100,1000.0和"John"分别赋值给counter,miles,name变量。
执行以上程序会输出如下结果:
100
1000.0
John
大家都具有一定的编程基础,不过多说明。
2.字符串
基本介绍
单引号 ’ ‘或者双引号 " " 都可以,再或者 ‘’’ ‘’’ 三个引号,其中三个引号被用于过于长段的文字或者是说明,只要是三引号不完你就可以随意换行写下文字。
①字符串直接能相加,如:
str1 = 'hello'
str2 = 'world'
print(str1 + ' ' +str2)
运行结果:
hello world
②字符串相乘,如:
string = 'bang!'
total = string * 3
print(total)
结果:
bang!bang!bang!
字符串的分片与索引
字符串可以通过 string[x]
的方式进行索引、分片。
字符串的分片实际可以看作是从字符串中找出来你要截取的东西,复制出来一小段你要的长度,存储在另一个地方,而不会对字符串这个源文件改动。分片获得的每个字符串可以看作是原字符串的一个副本。
先看下面这段代码:
name = 'My name is Mike'
print(name[0])
'M'
print(name[-4])
'M'
print(name[11:14]) # from 11th to 14th, 14th one is excluded
'Mik'
print(name[11:15]) # from 11th to 15th, 15th one is excluded
'Mike'
print(name[5:])
'me is Mike'
print(name[:5])
'My na'
:
两边分别代表着字符串的分割从哪里开始,并到哪里结束。
以name[11:14]为例,截取的编号从第11个字符开始,到位置为14但不包含第14个字符结束。而像name[5:]这样的写法代表着从编号为5的字符到结束的字符串分片。相反,name[:5]则代表着从编号为0的字符开始到编号为5但包含第5个字符分片。可能容易搞混,可以想象成第一种是从5到最后面,程序员懒得数有多少个所以就省略地写,第二种是从最前面到5,同样懒得写0,所以就写成了[:5]。
字符串的方法
replace 方法:第一个参数表示被替代部分,第二个参数表示替代成怎样的字符串。
字符串填空,如:
city = input("write the name of city:"")
url = "http://apistore.baidu.com/mri.../weather?citypiny={}.format(city)
3.列表
List
(列表) 是 Python 中使用最频繁的数据类型。
创建一个列表,只要把逗号分隔的不同的数据项使用方括号括起来即可。
列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(即嵌套)。
列表用 [ ]
标识,是 python 最通用的复合数据类型。
列表中值的切割也可以用到变量 [头下标:尾下标]
,就可以截取相应的列表,从左到右索引默认 0 开始,从右到左索引默认 -1 开始,下标可以为空表示取到头或尾。
list = [ 'runoob', 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) # 打印组合的列表
输出结果:
['runoob', 786, 2.23, 'john', 70.2]
runoob
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['runoob', 786, 2.23, 'john', 70.2, 123, 'john']
更新列表
你可以对列表的数据项进行修改或更新,你也可以使用append()
方法来添加列表项,如下所示:
list = [] # 空列表
list.append('Google') # 使用 append() 添加元素
list.append('Runoob')
print(list)
输出结果:
['Google', 'Runoob']
删除列表元素
可以使用 del
语句来删除列表的元素,如下实例:
list1 = ['physics', 'chemistry', 1997, 2000]
print(list1)
del list1[2]
print("After deleting value at index 2 : ")
print(list1)
输出结果:
['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]
Python列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表,* 号用于重复列表。
Python 表达式 | 结果 | 描述 |
---|---|---|
len([1, 2, 3]) | 3 | 长度 |
[1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
[‘Hi!’] * 4 | [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] | 重复 |
3 in [1, 2, 3] | True | 元素是否存在于列表中 |
for x in [1, 2, 3]: print(x), | 1 2 3 | 迭代 |
Python列表函数&方法
Python包含以下函数:
序号 | 函数 | 功能 |
---|---|---|
1 | cmp(list1, list2) | 比较两个列表的元素 |
2 | len(list) | 列表元素个数 |
3 | max(list) | 返回列表元素最大值 |
4 | min(list) | 返回列表元素最小值 |
5 | list(seq) | 将元组转换为列表 |
Python包含以下方法:
序号 | 方法 | 功能 |
---|---|---|
1 | list.append(obj) | 在列表末尾添加新的对象 |
2 | list.count(obj) | 统计某个元素在列表中出现的次数 |
3 | list.extend(seq) | 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) |
4 | list.index(obj) | 从列表中找出某个值第一个匹配项的索引位置 |
5 | list.insert(index, obj) | 将对象插入列表 |
6 | list.pop([index=-1]) | 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值 |
7 | list.remove(obj) | 移除列表中某个值的第一个匹配项 |
8 | list.reverse() | 反向列表中元素 |
9 | list.sort(cmp=None, key=None, reverse=False) | 对原列表进行排序 |
4.元组
Python的元组与列表类似,不同之处在于元组的元素不能修改。
元组使用小括号
,列表使用方括号
。
元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可。
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
创建空元组
tup1 = ()
元组中只包含一个元素时,需要在元素后面添加逗号
tup1 = (50,)
访问元组
元组可以使用下标索引来访问元组中的值,如下实例:
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
输出结果:
tup1[0]: physics
tup2[1:5]: (2, 3, 4, 5)
修改元组
元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,如下实例:
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)
输出结果:
(12, 34.56, 'abc', 'xyz')
删除元组
元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组,如下实例:
tup = ('physics', 'chemistry', 1997, 2000)
print(tup)
del tup
print(tup)
以上实例元组被删除后,输出变量会有异常信息
NameError Traceback (most recent call last)
<ipython-input-36-7e470d4e229c> in <module>
3 print(tup)
4 del tup
----> 5 print(tup)
NameError: name 'tup' is not defined
元组运算符
与字符串一样,元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。
Python表达式 | 结果 | 描述 |
---|---|---|
len((1, 2, 3)) | 3 | 计算元素个数 |
(1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | 连接 |
(‘Hi!’,) * 4 | (‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’) | 复制 |
3 in (1, 2, 3) | True | 元素是否存在 |
for x in (1, 2, 3): print(x) | 1 2 3 | 迭代 |
元组索引,截取
因为元组也是一个序列,所以我们可以访问元组中的指定位置的元素,也可以截取索引中的一段元素,如下所示:
元组:
L = ('spam', 'Spam', 'SPAM!')
Python 表达式 | 结果 | 描述 |
---|---|---|
L[2] | ‘SPAM!’ | 读取第三个元素 |
L[-2] | ‘Spam’ | 反向读取,读取倒数第二个元素 |
L[1:] | (‘Spam’, ‘SPAM!’) | 截取元素 |
无关闭分隔符
任意无符号的对象,以逗号隔开,默认为元组,如下实例:
print('abc', -4.24e93, 18+6.6j, 'xyz')
x, y = 1, 2
print("Value of x , y : ", x,y)
以上实例运行结果:
abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2
5.字典(Dictionary)
字典是另一种可变容器模型,且可存储任意类型对象。
字典的每个键值 key=>value
用冒号 : 分割,每个键值对之间用逗号 , 分割,整个字典包括在花括号 {} 中 ,格式如下所示:
d = {key1 : value1, key2 : value2 }
键一般是唯一的,如果重复最后的一个键值对会替换前面的,值不需要唯一。
dict = {'a': 1, 'b': 2, 'b': '3'}
dict['b']
print(dict)
输出结果:
{'a': 1, 'b': '3'}
值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。
一个简单的字典实例:
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
也可如此创建字典:
dict1 = { 'abc': 456 }
dict2 = { 'abc': 123, 98.6: 37 }
访问字典里的值
把相应的键放入熟悉的方括弧,如下实例:
实例
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print ("dict['Name']: ", dict['Name'])
print( "dict['Age']: ", dict['Age'])
输出结果:
dict['Name']: Zara
dict['Age']: 7
修改字典
向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对如下实例:
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8 # 更新
dict['School'] = 'RUNOOB' # 添加
print("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
输出结果:
dict['Age']: 8
dict['School']: RUNOOB
删除字典元素
能删单一的元素也能清空字典,清空只需一项操作。
显示删除一个字典用del
命令,如下实例:
实例
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 删除键是'Name'的条目
dict.clear() # 清空字典所有条目
del dict # 删除字典
print "dict['Age']: ", dict['Age']
print "dict['School']: ", dict['School']
但这会引发一个异常,因为用del后字典不再存在:
{} #输出空字典
TypeError Traceback (most recent call last)
<ipython-input-56-e60cee0ca8a6> in <module>
6 del dict # 删除字典
7
----> 8 print("dict['Age']: ", dict['Age'] )
9 print("dict['School']: ", dict['School'])
TypeError: 'type' object is not subscriptable
注:del()方法后面也会讨论。
字典键的特性
字典值可以没有限制地取任何python对象,既可以是标准的对象,也可以是用户定义的,但键不行。
两个重要的点需要记住:
1)**不允许同一个键出现两次。**创建时如果同一个键被赋值两次,后一个值会被记住,如下实例:
dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
print("dict['Name']: ", dict['Name'])
输出结果:
dict['Name']: Manni
2)键必须不可变,所以可以用数字,字符串或元组充当,所以用列表就不行,如下实例:
dict = {['Name']: 'Zara', 'Age': 7}
print("dict['Name']: ", dict['Name'])
报错:
File "<ipython-input-59-5d3482950444>", line 2
print("dict['Name']: ", dict['Name'])
^
SyntaxError: invalid character in identifie
字典内置函数&方法列表
Python字典包含了以下内置函数:
序号 | 函数 | 描述 |
---|---|---|
1 | cmp(dict1, dict2) | 比较两个字典元素。 |
2 | len(dict) | 计算字典元素个数,即键的总数。 |
3 | str(dict) | 输出字典可打印的字符串表示。 |
4 | type(variable) | 返回输入的变量类型,如果变量是字典就返回字典类型。 |
Python字典包含了以下内置方法:
序号 | 函数 | 描述 |
---|---|---|
1 | dict.clear() | 删除字典内所有元素 |
2 | dict.copy() | 返回一个字典的浅复制 |
3 | dict.fromkeys(seq[, val]) | 创建一个新字典,以序列 seq 中元素做字典的键,val 为字典所有键对应的初始值 |
4 | dict.get(key, default=None) | 返回指定键的值,如果值不在字典中返回default值 |
5 | dict.has_key(key) | 如果键在字典dict里返回true,否则返回false |
6 | dict.items() | 以列表返回可遍历的(键, 值) 元组数组 |
7 | dict.keys() | 以列表返回一个字典所有的键 |
8 | dict.setdefault(key, default=None) | 和get()类似, 但如果键不存在于字典中,将会添加键并将值设为default |
9 | dict.update(dict2) | 把字典dict2的键/值对更新到dict里 |
10 | dict.values() | 以列表返回字典中的所有值 |
11 | pop(key[,default]) | 删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。 |
12 | popitem() | 返回并删除字典中的最后一对键和值。 |
6.集合
集合(set
)是一个无序的不重复元素序列。
可以使用大括号 { }
或者 set()
函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
set就是dict类型的数据但是不保存value, 只保存key. set也用{}表示set集合中的元素必须是可hash的, 但是set本身是不可hash得. set是可变的.
创建集合
parame = {value01,value02,...}
#或者
set(value)
增加元素
add(a)
将元素a 添加到集合 s 中,如果元素已存在,则不进行任何操作。
a.update(b)
:迭代更新,把b迭代,然后加入集合a中,a可以有多个,用逗号分开。
例:
s = {"刘嘉玲", '关之琳', "王祖贤"}
s.update("麻花藤") # 迭代更新
print(s) #{'王祖贤', '花', '刘嘉玲', '麻', '关之琳', '藤'}
运行结果:
{'关之琳', '花', '王祖贤', '藤', '刘嘉玲', '麻'}
删除元素:
pop()
:随机删除
remove(a)
:直接删除a,如果集合中不存在a,则会报错
s.discard(x)
:移除集合中的元素,且如果元素不存在,不会发生错误。
clear()
:清空
集合内置方法完整列表
方法 | 描述 |
---|---|
add() | 为集合添加元素 |
clear() | 移除集合中的所有元素 |
copy() | 拷贝一个集合 |
difference() | 返回多个集合的差集 |
difference_update() | 移除集合中的元素,该元素在指定的集合也存在。 |
discard() | 删除集合中指定的元素 |
intersection() | 返回集合的交集 |
intersection_update() | 返回集合的交集。 |
isdisjoint() | 判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。 |
issubset() | 判断指定集合是否为该方法参数集合的子集。 |
issuperset() | 判断该方法的参数集合是否为指定集合的子集 |
pop() | 随机移除元素 |
remove() | 移除指定元素 |
symmetric_difference() | 返回两个集合中不重复的元素集合。 |
symmetric_difference_update() | 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。 |
union() | 返回两个集合的并集 |
update() | 给集合添加元素 |
二、Python标识符和保留字符
1.标识符
在 Python 里,标识符由字母、数字、下划线组成。
在 Python 中,所有标识符可以包括英文
、数字
以及下划线
(_
),但不能以数字开头。
Python 中的标识符是区分大小写的。
以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo
的代表不能直接访问的类属性,需通过类提供的接口进行访问,不能用 from xxx import * 而导入。
以双下划线开头的 __foo
代表类的私有成员,以双下划线开头和结尾的 __foo
代表 Python 里特殊方法专用的标识,如 init() 代表类的构造函数。
Python 可以同一行显示多条语句,方法是用分号 ;
2.Python 保留字符
下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数,或任何其他标识符名称。
所有 Python 的关键字只包含小写字母。
and | exec | not |
assert | finally | or |
break | for | pass |
class | from | |
continue | global | raise |
def | if | return |
del | import | try |
elif | in | while |
else | is | with |
except | lambda | yield |
三、运算符
1.Python算术运算符
以下假设变量: a=10,b=20:
运算符 | 描述 | 实例 |
---|---|---|
+ | 加 - 两个对象相加 | a + b 输出结果 30 |
- | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -10 |
* | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
/ | 除 - x除以y | b / a 输出结果 2 |
% | 取模 - 返回除法的余数 | b % a 输出结果 0 |
** | 幂 - 返回x的y次幂 | a**b 为10的20次方, 输出结果 100000000000000000000 |
// | 取整除 - 返回商的整数部分(向下取整) | 9//24结果为4;9//2结果为-5 |
2.Python比较运算符
以下假设变量a为10,变量b为20:
运算符 | 描述 | 实例 |
---|---|---|
== | 等于 - 比较对象是否相等 (a == b) | 返回 False。 |
!= | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
<> | 不等于 - 比较两个对象是否不相等。python3 已废弃。 | (a <> b) 返回 true。这个运算符类似 != 。 |
> | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
< | 小于 - 返回x是否小于y。所有比较运算符返回1表示真,返回0表示假。这分别与特殊的变量True和False等价。 | (a < b) 返回 true。 |
>= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
<= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 true。 |
3.Python赋值运算符
以下假设变量a为10,变量b为20:
运算符 | 描述 | 实例 |
---|---|---|
= | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
+= | 加法赋值运算符 | c += a 等效于 c = c + a |
-= | 减法赋值运算符 | c -= a 等效于 c = c - a |
*= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
/= | 除法赋值运算符 | c /= a 等效于 c = c / a |
%= | 取模赋值运算符 | c %= a 等效于 c = c % a |
**= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
//= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
4.Python位运算符
运算符 | 描述 | 实例 |
---|---|---|
& | 按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ,二进制解释: 0000 1100 |
竖线 | 按位或运算符:只要对应的二个二进位有一个为1时,结果位就为1。 (a | b) 输出结果 61 ,二进制解释: 0011 1101 |
^ | 按位异或运算符:当两对应的二进位相异时,结果为1 | (a ^ b) 输出结果 49 ,二进制解释: 0011 0001 |
~ | 按位取反运算符:对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1 | (~a ) 输出结果 -61 ,二进制解释: 1100 0011,在一个有符号二进制数的补码形式。 |
<< | 左移动运算符:运算数的各二进位全部左移若干位,由 << 右边的数字指定了移动的位数,高位丢弃,低位补0。 | a << 2 输出结果 240 ,二进制解释: 1111 0000 |
>> | 右移动运算符:把">>"左边的运算数的各二进位全部右移若干位,>> 右边的数字指定了移动的位数 | a >> 2 输出结果 15 ,二进制解释: 0000 1111 |
5.Python逻辑运算符
Python语言支持逻辑运算符,以下假设变量 a 为 10, b为 20:
运算符 | 逻辑表达式 | 描述 | 实例 |
---|---|---|---|
and x and y | 布尔"与" | - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。 | (a and b) 返回 20。 |
or x or y | 布尔"或" | - 如果 x 是非 0,它返回 x 的值,否则它返回 y 的计算值。 | (a or b) 返回 10。 |
not not x | 布尔"非" | - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 | not(a and b) 返回 False |
6.Python成员运算符
除了以上的一些运算符之外,Python还支持成员运算符,测试实例中包含了一系列的成员,包括字符串,列表或元组。
运算符 | 描述 | 实例 |
---|---|---|
in | 如果在指定的序列中找到值返回 True,否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
not in | 如果在指定的序列中没有找到值返回 True,否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
7.Python身份运算符
身份运算符用于比较两个对象的存储单元
运算符 | 描述 | 实例 |
---|---|---|
is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True,否则返回 False |
is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y , 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True,否则返回 False。 |
8.Python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符:
运算符 | 描述 |
---|---|
** | 指数 (最高优先级) |
~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
* / % // | 乘,除,取模和取整除 |
+ - | 加法减法 |
>> << | 右移,左移运算符 |
& | 位 ‘AND’ |
^ | 位运算符 |
<= < > >= | 比较运算符 |
<> == != | 等于运算符 |
= %= /= //= -= += *= **= | 赋值运算符 |
is is not | 身份运算符 |
in not in | 成员运算符 |
not and or | 逻辑运算符 |
四、语句(条件、循环)
1.条件语句
Python程序语言指定任何非0和非空(null)值为true,0 或者 null为false。
Python 编程中 if 语句用于控制程序的执行,基本形式为:
if 判断条件:
执行语句……
else:
执行语句……
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……
2.循环语句
Python 提供了 for 循环和 while 循环(在 Python 中没有 do…while 循环):
循环类型 | 描述 |
---|---|
while 循环 | 在给定的判断条件为 true 时执行循环体,否则退出循环体。 |
for 循环 | 重复执行语句 |
嵌套循环 | 你可以在while循环体中嵌套for循环 |
循环控制语句
循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句:
控制语句 | 描述 |
---|---|
break 语句 | 在语句块执行过程中终止循环,并且跳出整个循环 |
continue 语句 | 在语句块执行过程中终止当前循环,跳出该次循环,执行下一次循环。 |
pass 语句 | pass是空语句,是为了保持程序结构的完整性。 |
循环嵌套
Python 语言允许在一个循环体里面嵌入另一个循环。
for
循环嵌套语法:
for iterating_var in sequence:
for iterating_var in sequence:
statements(s)
statements(s)
while
循环嵌套语法:
while expression:
while expression:
statement(s)
statement(s)
你可以在循环体内嵌入其他的循环体,如在while循环中可以嵌入for循环, 反之,你可以在for循环中嵌入while循环。
五、函数
1.函数格式
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print()。但你也可以自己创建函数,这被叫做用户自定义函数。
定义一个函数:
你可以定义一个由自己想要功能的函数,以下是简单的规则:
函数代码块以 def 关键词开头,后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始,并且缩进。
return [表达式] 结束函数,选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
定义函数的格式:
def 函数名(参数列表):
函数体
return *
其中,def
和 return
为关键字。
注意: 函数缩进后面的语句被称为是语句块,缩进是为了表名语句的逻辑与从属关系。缩进这个问题不能忽视,否则会导致代码无法成功运行,这里需要特别注意。
2.函数调用
定义一个函数:给了函数一个名称,指定了函数里包含的参数,和代码块结构。
这个函数的基本结构完成以后,你可以通过另一个函数调用执行,也可以直接从 Python 命令提示符执行。
如下实例调用了 printme() 函数:
# 定义函数
def printme( str ):
# 打印任何传入的字符串
print (str)
return
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")
以上实例输出结果:
我要调用用户自定义函数!
再次调用同一函数
3.函数参数
①位置参数,举例,看代码:
def trapezoid_area(base_up, base_down, height):
return 1/2 * (base_up + base_down) * height
接下来我们开始调用该函数:
trapezoid_area(1,2,3)
不难看出,填入的参数1,2,3分别对应着参数 base_up,base_down 和 height。这种传入参数的方式被称作为位置参数。
②关键词参数:在函数调用的时候,将每个参数名称后面赋予一个我们想要传入的值
def func(a, b=5, c=10):
print('a is', a, 'and b is', b, 'and c is', c)
func(3, 7)
func(25, c=24)
func(c=50, a=100)
输出:
a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50
名为 func 的函数有一个没有默认参数值的参数,后跟两个各自带有默认参数值的参数。
在第一次调用python函数时,func(3, 7),参数 a 获得了值 3,参数 b 获得了值 7,而 c 获得了默认参数值 10。
在第二次调用函数时,func(25, c=24),由于其所处的位置,变量 a 首先获得了值 25。然后,由于命名——即关键字参数——指定,变量 c 获得了值 24。变量 b 获得默认参数值 5。
在第三次调用函数时,func(c=50, a=100),我们全部使用关键字参数来指定值。在这里要注意到,尽管 a 在 c 之前定义,但我们还是在变量 a 之前指定了变量 c。
③不定长参数
有时我们在设计函数接口的时候,可会需要可变长的参数。也就是说,我们事先无法确定传入的参数个数。
Python 提供了一种元组的方式来接受没有直接定义的参数。这种方式在参数前边加星号 * 。如果在函数调用时没有指定参数,它就是一个空元组。我们也可以不向函数传递未命名的变量。例如:
def print_user_info( name , age , sex = '男' , * hobby):
# 打印用户信息
print('昵称:{}'.format(name) , end = ' ')
print('年龄:{}'.format(age) , end = ' ')
print('性别:{}'.format(sex) ,end = ' ' )
print('爱好:{}'.format(hobby))
return;
# 调用 print_user_info 函数
print_user_info( '小明' , 25, '男', '打篮球','打羽毛球','跑步')
输出的结果:
昵称:小明 年龄:25 性别:男 爱好:('打篮球', '打羽毛球', '跑步')
通过输出的结果可以知道,* hobby 是可变参数,且 hobby 其实就是一个 tuple (元组)。
可变长参数也支持关键参数,没有被定义的关键参数会被放到一个字典里。这种方式即是在参数前边加 **,更改上面的示例如下:
def print_user_info( name , age , sex = '男' , ** hobby ):
# 打印用户信息
print('昵称:{}'.format(name) , end = ' ')
print('年龄:{}'.format(age) , end = ' ')
print('性别:{}'.format(sex) ,end = ' ' )
print('爱好:{}'.format(hobby))
return;
# 调用 print_user_info 函数
print_user_info( name = '小明' , age = 25 , sex = '男', hobby = ('打篮球','打羽毛球','跑步'))
输出的结果:
昵称:小明 年龄:24 性别:男 爱好:{'hobby': ('打篮球', '打羽毛球', '跑步')}
通过对比上面的例子和这个例子,可以知道,* hobby 是可变参数,且 hobby 其实就是一个 tuple (元祖),** hobby是关键字参数,且 hobby 就是一个 dict (字典)。
④ 只接受关键字参数
关键字参数使用起来简单,不容易参数出错,那么有些时候,我们定义的函数希望某些参数强制使用关键字参数传递,这时候该怎么办呢?将强制关键字参数放到某个参数或者单个后面就能达到这种效果,比如:
def print_user_info( name , *, age, sex = '男' ):
# 打印用户信息
print('昵称:{}'.format(name) , end = ' ')
print('年龄:{}'.format(age) , end = ' ')
print('性别:{}'.format(sex))
return;
# 调用 print_user_info 函数
print_user_info( name = '小明' ,age = 25 , sex = '男' )
# 这种写法会报错,因为 age ,sex 这两个参数强制使用关键字参数
#print_user_info( '小明' , 25 , '男' )
print_user_info('小明',age='22',sex='男')
通过例子可以看,如果 age , sex 不适用关键字参数是会报错的。
4.参数传递
在 python 中,类型属于对象,变量是没有类型的:
a=[1,2,3]
a="Runoob"
以上代码中,[1,2,3] 是 List 类型,“Runoob” 是 String 类型,而变量 a 是没有类型,她仅仅是一个对象的引用(一个指针),可以是指向 List 类型对象,也可以是指向 String 类型对象。
可更改(mutable)与不可更改(immutable)对象
在 python 中,strings, tuples, 和 numbers 是不可更改的对象,而 list,dict 等则是可以修改的对象。
不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变a的值,相当于新生成了a。
可变类型:变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改,本身la没有动,只是其内部的一部分值被修改了。
python 函数的参数传递
不可变类型:类似 c++ 的值传递,如 整数、字符串、元组。如fun(a),传递的只是a的值,没有影响a对象本身。比如在 fun(a)内部修改 a 的值,只是修改另一个复制的对象,不会影响 a 本身。
def ChangeInt( a ):
a = 10
b = 2
ChangeInt(b)
print( b ) # 结果是 2
实例中有 int 对象 2,指向它的变量是 b,在传递给 ChangeInt 函数时,按传值的方式复制了变量 b,a 和 b 都指向了同一个 Int 对象,在 a=10 时,则新生成一个 int 值对象 10,并让 a 指向它。
可变类型:类似 c++ 的引用传递,如 列表,字典。如 fun(la),则是将 la 真正的传过去,修改后fun外部的la也会受影响
def changeme( mylist ):
"修改传入的列表"
mylist.append([1,2,3,4])
print ("函数内取值: ", mylist)
return
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)
传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下:
函数内取值: [10, 20, 30, [1, 2, 3, 4]]
函数外取值: [10, 20, 30, [1, 2, 3, 4]]
python 中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。
5.匿名函数
Python 使用 lambda
来创建匿名函数,也就是不再使用 def
语句这样标准的形式定义一个函数。
匿名函数主要有以下特点:
lambda 只是一个表达式,函数体比 def 简单很多。
lambda 的主体是一个表达式,而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间,且不能访问自有参数列表之外或全局命名空间里的参数。
基本语法:lambda [arg1 [,arg2,.....argn]]:expression
示例:
sum = lambda num1 , num2 : num1 + num2;
print( sum( 1 , 2 ) )
输出的结果: 3
注意:尽管 lambda 表达式
允许你定义简单函数,但是它的使用是有限制的。 你只能指定单个表达式,它的值就是最后的返回值。也就是说不能包含其他的语言特性了, 包括多个语句、条件表达式、迭代以及异常处理等等。
匿名函数中,有一个特别需要注意的问题,比如,把上面的例子改一下:
num2 = 100
sum1 = lambda num1 : num1 + num2 ;
num2 = 10000
sum2 = lambda num1 : num1 + num2 ;
print( sum1( 1 ) )
print( sum2( 1 ) )
你会认为输出什么呢?第一个输出是 101,第二个是 10001,结果不是的,输出的结果是这样:
10001
10001
这主要在于 lambda
表达式中的 num2
是一个自由变量,在运行时绑定值,而不是定义时就绑定,这跟函数的默认值参数定义是不同的。所以建议还是遇到这种情况还是使用第一种解法。
6.变量作用域介绍
一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下:
全局变量
局部变量
定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。
参考资料
本文基于以下文章编辑,如有错误之处,还请评论留言指正。
百度Python词条
博客 Python基础入门笔记(一)
RUNOOB.COM