概述
Python3基础
语法简介
Python是一种计算机编程语言。
任何一种编程语言都有自己的一套语法，
编译器或者解释器就是负责把符合语法的程序代码转换成CPU能够执行的机器码，
然后执行。
Python也有自己的解释器。
Python的语法比较简单，采用缩进方式，
写出来的代码就像下面的样子：
# print absolute value of an integer:
a = 100
if a >= 0:
print(a)
else:
print(-a)
- 注释：
以#开头的语句是注释，注释是给人看的，
可以是任意内容，解释器会忽略掉注释。
- 语句：
每一行都是一个语句，当语句以冒号:结尾时，
缩进的语句视为代码块。
- 缩进：
按照约定俗成的管理，应该始终坚持使用4个空格的缩进。
缩进的另一个好处是强迫你写出缩进较少的代码。
缩进的坏处就是“复制－粘贴”功能失效了，
IDE很难像格式化Java代码那样格式化Python代码。
- 大小写敏感：
请务必注意，Python程序是大小写敏感的，如果写错了大小写，程序会报错。
- 注意：
Python使用缩进来组织代码块，
请务必遵守约定俗成的习惯，
坚持使用4个空格的缩进。
在文本编辑器中，需要设置把Tab自动转换为4个空格，
确保不混用Tab和空格。
基础语法
Python 标识符
- 标识符：
Python 中的标识符由字母、数字、下划线组成，
Python 中的标识符但不能以数字开头。
Python 中的标识符是区分大小写的。
- 以下划线开头的标识符是有特殊意义的：
以单下划线开头 _foo 的代表不能直接访问的类属性，
需通过类提供的接口进行访问；
- 以双下划线开头的 标识符 代表类的私有成员：
以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，
如 __init__()代表类的构造函数。
- 同一行显示多条语句
Python 可以同一行显示多条语句，方法是用分号 ; 分开，如：
>>> print 'hello';print 'freencre';
hello
freencre
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 |
行和缩进
学习 Python 与其他语言最大的区别就是，
Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。
python 最具特色的就是用缩进来写模块。
缩进的空白数量是可变的，
但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。
如下所示：
if True:
print "True"
else:
print "False"
多行语句
Python语句中一般以新行作为为语句的结束符。
- 使用“多行连接符”
但是我们可以使用斜杠（ ）将一行的语句分为多行显示，如下所示：
total = item_one +
item_two +
item_three
- 不使用“多行连接符”
语句中包含 [], {} 或 () 括号就不需要使用多行连接符。
如下实例：
days = ['Monday', 'Tuesday', 'Wednesday',
'Thursday', 'Friday']
Python 引号
Python 可以使用引号( ' )、双引号( " )、三引号( ''' 或 """ ) 来表示字符串，
引号的开始与结束必须的相同类型的。
三引号可以由多行组成，编写多行文本的快捷语法，
三引号常用于文档字符串，在文件的特定地点，被当做注释。
word = 'word'
sentence = "这是一个句子。"
paragraph = """这是一个段落。
包含了多个语句"""
Python注释
- 单行注释
python中单行注释采用 # 开头。
注释可以在语句或表达式行末：
# 第一个注释
print "Hello, Python!"; # 第二个注释
输出结果：
Hello, Python!
- 多行注释
python 中多行注释使用三个单引号(''')或三个双引号(""")。
'''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''
"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""
同一行显示多条语句
Python可以在同一行中使用多条语句，
语句之间使用分号(;)分割
以下是一个简单的实例：
import sys; x = 'freencre'; sys.stdout.write(x + 'n')
Print 输出
print 默认输出是换行的，
如果要实现不换行需要在变量末尾加上逗号 ,
方法一：
x=10; y=20
print(x, y)
方法二：
print('contents', end='!@#$%^&*')
end就表示print将如何结束，默认为end="n"（换行）
x=10; y=20
print(x, end=’ ’)
print(y)
数据类型
数据类型
计算机能处理数值，
还可以处理文本、图形、音频、视频、网页等各种各样的数据，
不同的数据，需要定义不同的数据类型。
在Python中，能够直接处理的数据类型有以下几种：
整数
Python可以处理任意大小的整数，包括负整数，
在程序中的表示方法和数学上的写法一模一样，
例如：1，100，-8080，0，等等。
计算机由于使用二进制，有时候用十六进制表示整数比较方便，
十六进制用0x前缀和0-9，a-f表示，
例如：0xff00，0xa5b4c3d2，等等。
浮点数
浮点数也就是小数，之所以称为浮点数，
一个浮点数的小数点位置是可变的，
比如，1.23x(10^9)9和12.3x(10^8)是完全相等的。
浮点数可以用数学写法，如1.23，3.14，-9.01，等等。
但是对于很大或很小的浮点数，就必须用科学计数法表示，
把10用e替代，
1.23x(10^9)就是1.23e9，或者12.3e8，
0.00011可以写成1.1e-4。
整数和浮点数在计算机内部存储的方式是不同的，
整数运算永远是精确的，
而浮点数运算则可能会有四舍五入的误差。
字符串
字符串是以单引号'或双引号"括起来的任意文本
请注意，''或""本身只是一种表示方式，不是字符串的一部分，
因此，字符串'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 learningnPython.')
I'm learning
Python.
默认不转义：
如果字符串里面有很多字符都需要转义，就需要加很多，
为了简化，Python还允许用r''表示''内部的字符串默认不转义：
多行内容：
如果字符串内部有很多换行，用n写在一行里不好阅读，
为了简化，Python允许用'''...'''的格式表示多行内容
str='''
... hello
... python
... bye'''
print(str)
布尔值
在Python中，布尔值和布尔代数的表示完全一致，
一个布尔值只有True、False两种值（请注意大小写），
要么是True，要么是False.
布尔值可以用and、or和not运算：
and：逻辑与； or：逻辑或； not逻辑非
空值
空值是Python里一个特殊的值，用None表示。
None不能理解为0，因为0是有意义的，
而None是一个特殊的空值。
对应其它语言的null
常量和变量
变量
在计算机程序中，变量不仅可以是数字，还可以是任意数据类型。
变量在程序中就是用一个 变量名 来表示，
变量名必须是大小写英文字母、数字和_的组合，且不能用数字开头，
a = 1 # 变量a是一个整数。
name = 'cat007' # 变量name是一个字符串。
Answer = True # 变量Answer是一个布尔值True。
赋值符号
在Python中，等号=是赋值语句，
可以把任意数据类型赋值给变量，
同一个变量可以反复赋值，而且可以是不同类型的变量，
请不要把赋值语句的等号等同于数学的等号。
例如：
a = 123 # a是整数
print(a)
a = 'ABC' # a变成了字符串
print(a)
动态语言
这种变量类型不固定的语言称之为动态语言，与之对应的是静态语言。
静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。
例如Java是静态语言，赋值语句如下（// 表示注释）：
int a = 123; // a是整数类型变量
a = "ABC"; // 错误：不能把字符串赋给整型变量
和静态语言相比，动态语言更灵活，就是这个原因。
常量
所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。
在Python中，通常用全部大写的变量名表示常量：
比如：PI = 3.14159265359
但事实上PI仍然是一个变量，
Python根本没有任何机制保证PI不会被改变，
所以，用全部大写的变量名来表示常量只是一个习惯上的用法，
除法
在Python中，有两种除法，
一种除法是/： 小数运算，精确。
一种除法是//： 整数运算，取整。
>>> 10 / 3
3.3333333333333335
- /除法【单除】：
计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：
>>> 9 / 3
3.0
- 除法//【双除】，称为地板除（向下取整），
两个整数的除法仍然是整数：
>>> 10 // 3
3
整数的地板除//永远是整数，即使除不尽。
要做精确的除法，就需要使用/。
求余
因为//除法只取结果的整数部分，
Python还提供一个余数运算%，可以得到两个整数相除的余数：
>>> 10 % 3
1
无论整数做//除法还是取余数，结果永远是整数。
运算符
Python语言支持以下类型的运算符:
- 算术运算符
- 比较（关系）运算符
- 赋值运算符
- 逻辑运算符
- 位运算符
- 成员运算符
- 身份运算符
- 运算符优先级
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//2 输出结果 4 , 9.0//2.0 输出结果 4.0 |
Python比较运算符
以下假设变量a为10，变量b为20：
| 运算符 | 描述 | 实例 |
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
| <> | 不等于 - 比较两个对象是否不相等 注意：在python3.x中已经取消了该运算符。 | (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。 |
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 |
Python位运算符
按位运算符是把数字看作二进制来进行计算的。
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 |
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 |
Python成员运算符
Python还支持成员运算符，
测试实例中包含了一系列的成员，包括字符串，列表或元组。
| 运算符 | 描述 | 实例 |
| in | 如果在指定的序列中： 找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中： 没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
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。 |
注： id() 函数用于获取对象内存地址。
Python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符：
| 运算符 | 描述 |
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not or and | 逻辑运算符 |
字符编码
字符串也是一种数据类型，但是，字符串比较特殊的是还有一个编码问题。
因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理。
最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），
所以，一个字节能表示的最大的整数就是255（二进制11111111=十进制255），
如果要表示更大的整数，就必须用更多的字节。
比如两个字节可以表示的最大整数是65535，
4个字节可以表示的最大整数是4294967295。
ASCII编码：
最早只有127个字符被编码到计算机里，
也就是大小写英文字母、数字和一些符号，
这个编码表被称为ASCII编码，
比如大写字母A的编码是65，小写字母a的编码是97。
中文编码：
要处理中文显然一个字节是不够的，至少需要两个字节，
而且还不能和ASCII编码冲突，
所以，中国制定了GB2312编码，用来把中文编进去。
其它编码：
全世界有上百种语言，
日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里，
各国有各国的标准，就会不可避免地出现冲突，
结果就是，在多语言混合的文本中，显示出来会有乱码。
Unicode编码：
Unicode应运而生（世界编码大一统）。
Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。
Unicode标准用两个字节表示一个字符。
现代操作系统和大多数编程语言都直接支持Unicode。
字符串
Python 字符串
字符串是 Python 中最常用的数据类型。
我们可以使用引号('或")来创建字符串。
创建字符串很简单，只要为变量分配一个值即可。例如：
var1 = 'Hello World!'
var2 = "Python Freencre"
Python访问字符串中的值
Python不支持单字符类型，
单字符也在Python也是作为一个字符串使用。
Python访问子字符串，
可以使用方括号来截取字符串，如下实例：
var1 = 'Hello World!'
print("var1[0]: ", var1[0])
Python字符串更新
可以对已存在的字符串进行修改，并赋值给另一个变量，
如下实例：
var1 = 'Hello World!'
print(var1)
var1 = 'Hello freencre!'
print(var1)
Python转义字符
在需要在字符中使用特殊字符时，python用反斜杠()转义字符。如下表：
| 转义字符 | 描述 |
| (在行尾时) | 续行符 |
| \ | 反斜杠符号 |
| ' | 单引号 |
| " | 双引号 |
| a | 响铃 |
| n | 换行 |
| t | 横向制表符 |
| r | 回车 |
Python字符串运算符
下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：
| 操作符 | 描述 | 实例 |
| + | 字符串连接 | >>>a + b 'HelloPython' |
| * | 重复输出字符串 | >>>a * 2 'HelloHello' |
| [] | 通过索引获取字符串中字符，下标从0开始 | >>>a[1] 'e' |
| [ : ] | 截取字符串中的一部分 | >>>a[1:4] 'ell' |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | >>>"H" in a True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | >>>"M" not in a True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | >>>print r'n' n >>> print R'n' n |
| % | 格式字符串 |
|
Python 字符串格式化
Python 支持格式化字符串的输出 。
尽管这样可能会用到非常复杂的表达式，
但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
如下实例：
print("name is %s, weight is %d kg!" % ('Freencre', 21) )
python字符串格式化符号:
| 符 号 | 描述 |
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %f 和 %E 的简写 |
| %p | 用十六进制数格式化变量的地址 |
Python三引号（triple quotes）
python中三引号可以将复杂的字符串进行复制:
python三引号允许一个字符串跨多行，
字符串中可以包含换行符、制表符以及其他特殊字符。
三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。
>>> hi = '''hi
there'''
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，
自始至终保持一小块字符串的格式是所谓的WYSIWYG（所见即所得）格式的。
一个典型的用例是，当你需要一块HTML或者SQL时，
这时用字符串组合，特殊字符串转义将会非常的繁琐。
infoHTML = '''
<HTML><HEAD><TITLE>
Friends Demo</TITLE></HEAD>
<BODY><H3>Hello</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="alert(‘Hello,world’)"></FORM>
</BODY></HTML>
'''
Unicode 字符串
Python 中定义一个 Unicode 字符串和定义一个普通字符串一样简单：
>>> u'Hello World !'
引号前小写的"u"表示这里创建的是一个 Unicode 字符串。
在最新的Python 3版本中，字符串是以Unicode编码的，
也就是说，Python3的字符串支持多语言，例如：
>>> print('包含中文的str')
对于单个字符的编码，
Python提供了
ord()函数获取字符的整数表示，
chr()函数把编码转换为对应的字符：
>>> ord('A')
65
>>> ord('中')
20013
字节流bytes
由于Python的字符串类型是str，
在内存中以Unicode表示，
一个字符对应若干个字节。
如果要在网络上传输，或者保存到磁盘上，
就需要把str变为以字节为单位的bytes。
Python对bytes类型的数据用带b前缀的单引号或双引号表示：
例如：x = b'ABC'
要注意区分'ABC'和b'ABC'，
前者是str，后者虽然内容显示得和前者一样，
但bytes的每个字符都只占用一个字节。
encode()方法
在操作字符串时，我们经常遇到str和bytes的互相转换。
为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。
以Unicode表示的str通过encode()方法可以编码为指定的bytes，例如：
>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'xe4xb8xadxe6x96x87'
列表：List
List简介
Python 列表(List)，也叫序列。
列表是Python中最基本的数据结构。
列表中的每个元素都分配一个数字（位置，或索引），
第一个索引是0，第二个索引是1，依此类推。
列表是最常用的Python数据类型，
它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建列表
只要把逗号分隔的不同的数据项使用方括号括起来即可。
如下所示：
list1 = ['apple', 'banana', 2008, True];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
访问列表
与字符串的索引一样，列表索引从0开始。
列表可以进行截取、组合等。
访问列表中的值
使用下标索引来访问列表中的值，
同样你也可以使用方括号的形式截取字符，
如下所示：
list1 = ['apple', 'banana', 2008, True];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print(list1[0])
print(list2[1:5])
更新列表
可以对列表的数据项进行修改或更新，
也可以使用append()方法来添加列表项，
如下所示：
list1 = ['apple', 'banana', 2008, True];
list1.append(2018)
print(list1)
删除列表元素
可以使用 del 语句来删除列表的的元素，
如下实例：
list1 = ['apple', 'banana', 2008, True];
del list1[1]
print(list1)
列表操作符
列表对 + 和 * 的操作符与字符串相似。
+号 用于组合列表，
*号 用于重复列表。
如下所示：
| Python 表达式 | 结果 | 描述 |
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| ['Hi!'] * 3 | ['Hi!', 'Hi!', 'Hi!'] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print(x,) | 1 2 3 | 迭代 |
列表截取
Python 的列表截取实例如下：
>>> L = ['apple', 'banana', 'watermelon']
>>> L[2]
>>> L[-2]
>>> L[1:]
描述：
| Python 表达式 | 结果 | 描述 |
| L[2] | ' watermelon ' | 读取列表中第三个元素 |
| L[-2] | ' banana ' | 读取列表中倒数第二个元素 |
| L[1:] | ['banana', 'watermelon'] | 从第二个元素开始截取列表 |
元组：tuple
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
创建元组
元组创建很简单，
只需要在一对圆括号中添加元素，并使用逗号隔开即可。
如下实例：
tup1 = ('apple', 'banana', 2018, True);
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"
创建空元组
tup1 = ();
创建只包含一个元素的元组
元组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (50,);
访问元组
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
元组可以使用下标索引来访问元组中的值，
如下实例:
tup1 = ('apple', 'banana', 2018, True);
tup2 = (1, 2, 3, 4, 5 )
print( tup1[0])
print(tup2[1:3])
修改元组
元组中的元素值是不允许修改的，
但我们可以对元组进行连接组合，
如下实例:
tup1 = (12, 34);
tup2 = ('abc', 'xyz');
# 以下修改元组元素操作是非法的。
# tup1[0] = 100;
# 创建一个新的元组
tup3 = tup1 + tup2;
print(tup3)
删除元组
元组中的元素值是不允许删除的，
但我们可以使用del语句来删除整个元组，
如下实例:
tup1 = ('apple', 'banana', 2018, True);;
print(tup1)
del tup1;
print(tup1)
以上实例元组被删除后，输出变量会有异常信息，
元组运算符
与字符串一样，元组之间可以使用 +号 和 *号 进行运算。
这就意味着它们可以组合和复制，运算后会生成一个新的元组。
| Python 表达式 | 结果 | 描述 |
| len((1, 2, 3)) | 3 | 计算元素个数 |
| (1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | 连接 |
| ('Hi!',) * 3 | ('Hi!', 'Hi!', 'Hi!') | 复制 |
| 3 in (1, 2, 3) | True | 元素是否存在 |
| for x in (1, 2, 3): print(x) | 1 2 3 | 迭代 |
元组索引，截取
因为元组也是一个序列，
所以我们可以访问元组中的指定位置的元素，
也可以截取一段元素，
如下所示：
L = ('aaa', 'bbb', 'ccc')
| Python 表达式 | 结果 | 描述 |
| L[2] | 'ccc' | 读取第三个元素 |
| L[-2] | 'bbb' | 反向读取；读取倒数第二个元素 |
| L[1:] | ('bbb', 'ccc') | 截取元素 |
无关闭分隔符
任意 无符号的对象，以逗号隔开，默认为元组，
如下实例：
a=1,2,3,'e'
b=(1,2,3,'e')
元组内置函数
Python元组包含了以下内置函数
| 序号 | 方法及描述 |
| a | len(tuple) 计算元组元素个数。 |
| b | max(tuple) 返回元组中元素最大值。 |
| c | min(tuple) 返回元组中元素最小值。 |
| d | tuple(seq) 将列表转换为元组。 |
字典：dict
dict简介
Python内置了字典：dict的支持，dict全称dictionary，
类似于其他语言中的map，使用键-值（key-value）存储，具有极快的查找速度。
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，
整个字典包括在花括号({})中 ,
格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，
但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：
dict = {'aaa': 123, 'bbb': 251, 'ccc': 325}
dict原理
类似于查字典，
首先在字典的索引表里（比如部首表）查这个字对应的页码，
然后直接翻到该页，找到这个字。
无论找哪个字，这种查找速度都非常快，
不会随着字典大小的增加而变慢。
dict就是这种实现方式，给定一个名字，比如'apple'，
dict在内部就可以直接计算出apple对应的存放成绩的“页码”，
也就是具体的内存地址，直接取出来，所以速度非常快。
这种key-value存储方式，在放进去的时候，
必须根据key算出value的存放位置，
这样，取的时候才能根据key直接拿到value。
dict特点
和list比较，dict有以下几个特点：
查找和插入的速度极快，不会随着key的增加而变慢；
需要占用大量的内存，内存浪费多。
而list相反：
查找和插入的时间随着元素的增加而增加；
占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法。
dict可以用在需要高速查找的很多地方，
在Python代码中几乎无处不在，正确使用dict非常重要，
需要牢记的第一条就是dict的key必须是不可变对象。
这是因为dict根据key来计算value的存储位置，
如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。
这个通过key计算位置的算法称为哈希算法（Hash）。
访问字典里的值
把相应的键放入熟悉的方括弧，
如果用字典里没有的键 访问数据，会输出错误：
如下实例:
dict = {'aaa': 123, 'bbb': 251, 'ccc': 325}
print( dict['aaa'] )
print( dict['ccc'] )
print( dict['ddd'] )
修改字典
增加新的键/值对，
修改或删除已有键/值对
如下实例:
dict = {'aaa': 123, 'bbb': 251, 'ccc': 325}
dict['ddd'] = 888
print(dict)
删除字典元素
- 删除单一的元素
- 清空字典。
如下实例:
dict = {'aaa': 123, 'bbb': 251, 'ccc': 325}
del dict['aaa'];print(dict)
dict.clear();print(dict) #清空后，该字典依然存在
del dict #del之后，该字典消失了
集合：set
创建集合
python的set和其他语言类似, 是一个无序不重复元素集,
作为一个无序的集合，sets不记录元素位置或者插入点。
集合用于包含一组无序的对象。
创建集合：大括号或 set() 函数可以用来创建集合。
注意：想要创建空集合，必须使用 set() 而不是 {}，后者用于创建空字典。
比如：
a = {2,3,4,5}
s = set([3,5,9,10]) #创建一个数值集合
t = set("Hello") #创建一个唯一字符的集合
分析如下：
与列表和元组不同，集合是无序的，也无法通过数字进行索引。
集合中的元素不能重复。
例如，如果检查前面代码中t集合的值，结果会是：
>>> t
set(['H', 'e', 'l', 'o'])
注意只出现了一个'l'。
集合的操作
集合支持一系列标准操作，包括并集、交集、差集和对称差集，
例如：
a = t | s # t 和 s的并集
b = t & s # t 和 s的交集
c = t–s # 求差集（项在t中，但不在s中）
d = t ^ s # 对称差集（项在t或s中，但不会同时出现在二者中）
- 基本操作：
t.add('x') # 添加一项
s.update([10,37,42]) # 在s中添加多项
- remove()删除一项：
t.remove('H')
- len(s)：求set的长度
len(s)
- x in s
测试 x 是否是 s 的成员
- s.issubset(t)
s <= t
测试是否 s 中的每一个元素都在 t 中
- 集合并集：s.union(t)
s | t
返回一个新的 set 包含 s 和 t 中的每一个元素
- 集合交集：s.intersection(t)
s & t
返回一个新的 set 包含 s 和 t 中的公共元素
选择结构
Python条件语句是通过一条或多条语句的执行结果
（True或者False）来决定执行的代码块。
可以通过下图来简单了解条件语句的执行过程:
Python程序语言指定任何非0和非空（null）值为true，0 或者 null为false。
Python 编程中 if 语句用于控制程序的执行，基本形式为：
if 判断条件：
执行语句……
else：
执行语句……
其中"判断条件"成立时（非零），则执行后面的语句，
而执行内容可以多行，以缩进来区分表示同一范围。
else 为可选语句，当需要在条件不成立时执行内容则可以执行相关语句，
if 语句的判断条件：
>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）。
当判断条件为多个值时，可以使用以下形式：
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……
由于 python 并不支持 switch 语句，
所以多个条件判断，只能用 elif 来实现，
如果判断需要多个条件需同时判断时，
or （或）： 表示两个条件有一个成立时判断条件成功；
and （与）： 表示只有两个条件同时成立的情况下，判断条件才成功。
当if有多个条件时可使用括号来区分判断的先后顺序，。
循环结构
编程语言提供了各种控制结构，允许更复杂的执行路径。
循环语句允许我们执行一个语句或语句组多次，
下面是在大多数编程语言中的循环语句的一般形式：
循环语句
Python提供了for循环和while循环（在Python中没有do..while循环）:
| 循环类型 | 描述 |
| while 循环 | 在给定的判断条件为 true 时执行循环体，否则退出循环体。 |
| for 循环 | 重复执行语句 |
| 嵌套循环 | 你可以在while循环体中嵌套for循环 |
循环控制语句
循环控制语句可以更改语句执行的顺序。
Python支持以下循环控制语句：
| 控制语句 | 描述 |
| break 语句 | 在语句块执行过程中终止循环，并且跳出整个循环 |
| continue 语句 | 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。 |
| pass 语句 | pass是空语句，是为了保持程序结构的完整性。 |
while 语句
Python 编程中 while 语句用于循环执行程序，
即在某条件下，循环执行某段程序，以处理需要重复处理的相同任务。
其基本形式为：
while 判断条件：
执行语句……
执行语句可以是单个语句或语句块。
判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。
当判断条件假false时，循环结束。
执行流程图如下：
实例
count = 0
while(count < 9):
print('The count is:', count )
count = count + 1
print("Good bye!")
while 语句时还有另外两个重要的命令 continue，break 来跳过循环，
continue 用于跳过该次循环，
break 则是用于退出循环，
此外"判断条件"还可以是个常值，表示循环必定成立，
无限循环
如果条件判断语句永远为 true，循环将会无限的执行下去，
while(1):
print(‘hello’)
注意：以上的无限循环你可以使用 CTRL+C 来中断循环。
for循环
Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
语法：
for循环的语法格式如下：
for iterating_var in sequence:
statements(s)
流程图：
实例：
for letter in 'Python': # 第一个实例
print (letter)
通过序列索引迭代
另外一种执行循环的遍历方式是通过索引，如下实例：
实例
fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
print('当前水果 :', fruits[index] )
以上实例我们使用了内置函数 len() 和 range(),
len()： 返回列表的长度，即元素的个数。
range： 返回一个序列的数。
Python 循环嵌套
Python 语言允许在一个循环体里面嵌入另一个循环。
Python for 循环嵌套语法：
for iterating_var in sequence:
for iterating_var in sequence:
statements(s)
statements(s)
Python while 循环嵌套语法：
while expression:
while expression:
statement(s)
statement(s)
可以在循环体内嵌入其他的循环体，
如在while循环中可以嵌入for循环，
可以在for循环中嵌入while循环。
Python break 语句
Python break语句，就像在C语言中，打破了最小封闭for或while循环。
break语句用来终止循环语句，
即循环条件没有False条件或者序列还没被完全递归完，也会停止执行循环语句。
break语句用在while和for循环中。
如果您使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码。
Python语言 break 语句语法：
break
流程图：
实例(Python 2.0+)
for letter in 'Python':
if letter == 'h':
break
print('当前字母 :', letter)
Python continue 语句
Python continue 语句跳出本次循环，而break跳出整个循环。
continue 语句用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。
continue语句用在while和for循环中。
Python 语言 continue 语句语法格式如下：
continue
流程图：
实例：
for letter in 'Python':
if letter == 'h':
continue
print('当前字母 :', letter)
最后
以上就是柔弱西装为你收集整理的Python3简明教程之2基础Python3基础的全部内容，希望文章能够帮你解决Python3简明教程之2基础Python3基础所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复