Python学习笔记（基础知识篇）
本文基于Python3 编写
Python的执行方式
在执行过程中，Python会将存储在.py文件中的源代码转换为Python语言解析器所理解的二进制代码（即字节码）。随后由Python虚拟机负责运行这些预先生成并经过优化处理过的二进制指令集。这一工作原理与Java, .NET系统的运行机制有着高度的一致性。
然而，在于 Python Virtual Machine 与 Java 或 .NET 的不同之处在于它是一种层次更高的虚拟机。这里的高级并不是通常意义上的高度，并不是说这种虚拟机比 Java 或 .NET 的功能更为强大；而是在于它距离真实的机器更远或者说可以说这种虚拟机在抽象层次上更为高深。
基于C语言编译生成的Python字节码文件通常采用.pyc格式。此外，Python还支持以交互式方式运行，在主要操作系统如Unix/Linux、MacOS以及Windows环境下均可通过命令行界面启动其交互式开发环境。通过执行操作指令即可完成相应的交互操作。
Python的PyCodeObject 和 pyc 文件认识
PyCodeObject ：是 Python 编译器真正编译成的结果。
当Python程序执行时，在编译阶段生成的PyCodeObject会被存储于内存中；而一旦Python程序退出，在解释器的作用下，则会将PyCodeObject输出并保存到对应的pyc文件中。
当 Python 稨程在第二次运行时开始执行时，在程序运行过程中（或在运行期间），程序首先会在硬盘中搜索 pyc 文件；如果找到了，则会自动加载该文件；如果没有找到，则会重新执行前面的步骤。
可以说 pyc 文件其实是 PyCodeObject 的一种持久化保存方式。
Python语法规范
Python开发者特意让违反了缩进规则的程序无法通过编译,从而促使程序员养成良好的编程习惯。另外,Python语言采用缩进来标识语句块开始与结束(Off-side 规则),而不是用花括号或其他关键字进行标记。用增加缩进来标志语块开始,减少缩进则标志语块结束,因此成为语法中的重要组成部分。
if age<21:
print("你不能买酒。")
print("不过你能买口香糖。")
print("这句话在if语句块的外面。")按照《Python编程语言官方强化建议书》的要求，在编写代码时应当遵循严格的缩进格式规定。具体而言，在每一层次代码块之间应采用连续的4个空格外文字段落，并要求各层次缩进间的空白数量保持一致。尽管采用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]时
字符串的方法
replace 功能：被替换的部分用于表示替代成什么样的字符串。
字符串填空，如：
city = input("write the name of city:"")
url = "://apistore.baidu/mri.../weather?citypiny={}.format(city)3.列表
Lists（列表） 是 Python 中应用频率最高的数据结构。
通过将逗号分隔的不同数据项用方括号包围起来即可轻松创建一个列表。
该数据结构能够提供字符、数字与字符串等基本类型的支持，并且还可以容纳子列表（即嵌套）。
列表用 [ ] 标识，是 python 最通用的复合数据类型。
列表中值的切割同样可以通过指定变量 [start_index:end_index] 来实现；这将使得程序能够提取所需的部分数据序列。其中，默认情况下会按照以下方式执行：当从左往右顺序时为起始索引 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 25.字典(Dictionary)
字典是另一种可变容器模型，且可存储任意类型对象。
该技术采用 dictionary 类型表示数据结构, 其中各键值对由冒号 : 连接, 各键值对之间则以逗号 , 连接, 整个数据结构则包含在大括号 {} 内中, 其格式如下所示:
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删除字典元素
能单独删除一个元素的同时也能清除整个字典吗？答案是可以做到哦！清除整个字典只需要一次操作就可以完成任务
实例
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对象（无论是内置类型的数据结构还是自定义对象），但需要注意的是键必须唯一。创建字典时若出现同一键被指定两次的情况，则后一次赋值会被保留下来（例如以下实例）：
dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'}
print("dict['Name']: ", dict['Name'])输出结果：
dict['Name']: Manni2）键必须保持不可变 ，因此可以采用数字、字符串或元组作为键值类型。相反地，列表无法作为键值类型使用，请看以下原因：
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() 而不是 {}
虽然与字典（dict）类型相似但不会存储 value 值仅用于存储 key 键。
此外在 Python 中 set 使用 {} 表示法且要求其元素具有唯一性（即必须可哈希），但整个 set 对象本身无法被哈希。
值得注意的是该数据结构是可以动态修改的。
创建集合
parame = {value01,value02,...}
#或者
set(value)增加元素
执行函数add(a)将元素a追加至集合s中（若已有则忽略）；通过调用方法a.update(b)可实现对b中的所有元素依次添加至集合a中（若重复则仅保留首次插入）
例:
s = {"刘嘉玲", '关之琳', "王祖贤"}
s.update("麻花藤") # 迭代更新
print(s) #{'王祖贤', '花', '刘嘉玲', '麻', '关之琳', '藤'}运行结果：
{'关之琳', '花', '王祖贤', '藤', '刘嘉玲', '麻'}删除元素:
pop():随机去除
remove(a):立即删除指定元素a；若元素不存在，则抛出异常
s.discard(x):从集合中移除指定元素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__ 表示类的私有成员，在 Python 中，前后均以双下划线包围的 __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)你可以将一个Python程序的某个函数内部套用另一个自定义的函数调用机制。例如，在函数A内部调用函数B时，默认会传递给函数B所有未指定的参数和上下文环境。相反地，在一个函数A内部同样可以包含另一个自定义的函数调用逻辑。
五、函数
1.函数格式
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
通过编写函数可以增强应用程序的模块化程度；同时还可以提升代码重复使用的效率。在Python中有很多内置的标准库功能函数；但你也可以根据需求编写自定义功能。
您可创建一个函数以满足您的需求以下是一些基本规则您可以参考这些规则来编写您的函数
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。定义函数的格式：
def 函数名（参数列表）:
函数体
return *其中，def 和 return 为关键字。
这一现象需要特别注意。函数缩进后面的语句被称作是语句块；这是一个重要的概念：函数缩进用于表明语句之间的层次关系；这是一个不容忽视的问题；如果忽视了这一点...那么代码将无法成功运行；必须引起高度重视。
2.函数调用
给定一个名称用于标识该函数，并指定了参数列表以及代码布局。完成基本功能后，请确保所有参数已正确指定并完成了必要的配置工作。例如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)的过程中
③不定长参数
时有我们在开发函数接口时可能会遇到可变数量的参数问题。这表示我们无法预估输入参数的数量。
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 作为可变参数即为一个 tuple（元祖），而 hobby 同时也是一个字典（字典）。
④ 只接受关键字参数
关键字参数的使用较为简便，并且不易出现错误。然而，在某些情况下，函数通常希望某些特定的参数必须以关键字形式传递。这时应该如何实现呢？将这些必须以关键字形式传递的参数放置在某个__init__方法的某个单一字段或单独的__init__方法中即可满足这一需求。例如：
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中，在这种情况下（即字符串、元组以及数字），它们都是无法被修改的对象。而像列表和字典等则是可修改的对象。
不可变类型：在第一次赋值得到a的值5后，在第二次赋值得到a的新值10时（即相当于为a创建了一个新的int类型的实例对象并将其存储在变量中），而不是修改a当前引用的对象内容（这实际上只是为变量分配了新的对象引用）。
变量赋值 la = [1, 2, 3, 4] 后再执行操作 la[2] = 5 则实现了将 list la 中的第3个元素数值进行了修改
python 函数的参数传递
不可变类型
def ChangeInt( a ):
a = 10
b = 2
ChangeInt(b)
print( b ) # 结果是 2在实例中存在一个int类型的对象编号为2，其对应的变量名是b。在传递参数给ChangeInt函数时采用按值传递的方式将变量b复制到函数中。这样导致a和b都指向同一个int对象。当a的值设为10时，则会生成一个新的int类型对象并将其赋值给a。
可变类型 ：类似于C++中的引用传递机制，在列表结构或映射结构中实现这种行为。例如，在函数调用中使用fun(la)的方式会直接将la传递给函数fun对象，并且修改后的la也会影响到函数fun外部的状态
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 本质上只是一个简练的表达式，在Python中相比使用def定义函数而言更加简洁明了。
其主体部分是一个精炼的表达式而非传统的代码块结构，在这种框架下只能嵌入有限数量的关键逻辑。
它所拥有的命名空间是独立且封闭的，在外部环境中无法访问或修饰这些参数。
基本语法形式为：λ arg1,arg2,...,argn: expression（其中λ表示lambda函数）。
示例：
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基于此，在\lambda 表达式中使用的\texttt{num2}作为一个自由变量，在执行过程中赋值而非提前固定。这与函数的默认参数设置存在差异。值得注意的是，在这种情况下仍应优先考虑第一种方法。
6.变量作用域介绍
在一个程序中，并非所有的变量都可以在整个运行范围内自由地被访问。A variable's access permissions are determined by where it is assigned within the program.
变量的作用域决定了在哪些部分的程序可以访问某个特定的变量名称？两种最基本的变量作用域包括全局作用域和局部作用域等基本类型
全局变量
局部变量位于函数内部的变量具有局部作用域，在外部则具备全局作用域
局部变量仅能在它们声明所限定的函数内部使用,而全局变量则可在程序运行期间任何地方被访问.当调用一个函数时,在该函数内部声明的所有变量名称都会被包含在该函数的作用域内.